Was ist Iodine?

Iodine ist ein IP-over-DNS Tunnel. Das bedeutet, dass man seinen normalen IP-Traffic in viele kleine Stückchen zerhackt und dann über das DNS-Protocol verschickt. Ein Server dient dabei als Proxy. Viele Hotspots blockieren TCP und UDP Traffic, um die Zahlung einer Gebühr zu fordern. Allerdings besteht diese Beschränkung oft nicht für den DNS-Verkehr (Port 53 UDP), sodass Hotspots ‚umgangen‘ werden können. ‚Umgangen‘ ist hier jedoch die falsche Bezeichnung, denn das Relayen des DNS-Traffics könnte genauso deaktiviert bzw. nur für zahlende Kunden konfiguriert werden.

Voraussetzungen

Damit das ganze System korrekt funktioniert, benötigt man folgende Voraussetzungen:

• (virtuellen) Server:
  • Rootrechte
  • Iptables
  • Port 53 udp frei
• Domain-Registrar, bei dem man eigene NS-Einträge setzen kann
• Für Nutzung auf dem Handy:
  • Rootrechte
  • AndIodine
  • Proxydroid
• Für Nutzung auf dem PC:
  • Rootrechte
  • Tsocks

Folgende Annahmen gelten für diesen Blogpost:

• Euer Server hat die IP: 127.0.0.1
• Eure Domain lautet: domain.tld
• Eine Subdomain lautet: iodns.domain.tld
• Die Subdomain zeigt auf den Server: 127.0.0.1
• Iodine-Subdomain ist: iod.domain.tld

Einrichtung des DNS

Damit Iodine funktioniert, muss es einen Nameserver emulieren. Dazu müsst ihr euch bei eurem DNS-Registrar anmelden und dort einige neue Einträge anlegen:

• A-Record: iodns.domain.tld -> 127.0.0.1
• NS-Record: iod.domain.tld -> iodns.domain.tld

Nun werden alle DNS-Anfragen, welche auf iod.domain.tld enden, an den Server geschickt, auf dem wir später Iodine laufen lassen werden.

Einrichtung von Iodine

Man loggt sich auf seinem Server ein und lädt den Iodine-Sourcecode herunter:

curl http://code.kryo.se/iodine/iodine-0.7.0.tar.gz -o /tmp/iodine.tgz

Man entpackt das Archiv:

cd /tmp/
tar xfv iodine.tgz

Zuletzt dann noch kompilieren und installieren:

cd /tmp/iodine-*/
make
sudo make install

Ihr solltet daraufhin zwei Binaries im Ordner ‚/usr/local/sbin/‘ finden:

ls /usr/local/sbin/
iodine iodined

Die Binary mit dem ‚d‘ hinten ist der Daemon, welchen wir auf dem Server laufen lassen werden. Am Besten legt man dazu einen neuen Nutzer an:

sudo useradd -m -s /bin/nologin iodine

Danach führt man folgenden Befehl aus:

sudo /usr/local/sbin/iodined -f -c -u iodine -P geheimesPW 192.168.99.1 iod.domain.tld

Die Parameter erklärt:

• -f: Behält das Programm im Vordergrund. Sollte nach einem Testlauf deaktiviert werden bzw. muss in Kombination mit Daemontools genutzt werden.
• -c: Verhindert das IP-Checking, welches ansonten zu Verbindungsproblemen führen kann.
• -u: Ändert den Nutzer, mit dem der Daemon läuft
• -P: Setzt ein Passwort
• 192.168.99.1 ist das Subnetz für den Tunnel.

Als nächstes muss man noch einige Einstellungen an der Firewall ändern:

• Port 53 UDP muss geöffnet werden, damit Pakete zu Iodine durchkommen
• Port 8080 TCP muss auf dem virtuellen Interface von Iodine (dns0/192.168.99.1) geöffnet werden, um den Socks-Server laufen zu lassen.

Im nächsten Schritt richten wir noch einen simplen Socks-Server ein, welcher auf dem dns0-Interface lauschen wird. Alle Clients werden später ihren Traffic über den Socks-Server tunneln.

An dieser Stelle sei erwähnt, dass man mittels IP-Forwarding den gesamten Traffic über Iodine tunneln lassen könnte, jedoch wollte ich in meinem Anwendungsszenario nur bestimmte Programme über den Tunnel telefonieren lassen.

Wir werden das kleine Tool Ssocks nutzen. Man lädt die Quellen herunter:

curl http://netassist.dl.sourceforge.net/project/ssocks/ssocks-0.0.14.tar.gz -o /tmp/ssocks.tgz

Danach werden diese entpackt und gebaut:

cd /tmp/
tar xfv ssocks.tgz
cd ssocks-*
./configure
make
sudo make install

Man legt wieder einen neuen User an:

sudo useradd -m -s /bin/nologin ssocks

Danach kann man den Socks-Proxy ganz einfach starten:

sudo -u "ssocks" /usr/local/bin/ssocksd -b 192.168.99.1 --port 8080

Nun sollte die Konfiguration des Servers abgeschlossen sein.

Nutzung auf dem Handy

Um Iodine auf dem Handy nutzen zu können, muss dieses gerootet sein. Danach installiert man sich aus dem F-Droid Store die App AndIodine.

In der App legt man ein neues Profil an und setzt folgende Optionen:

• Tunnel Topdomain: iod.domain.tld
• Password: geheimesPw
• Lazy mode: Häkchen
• Raw mode: Häkchen
• Default route: Kein Häkchen

Die restlichen Einstellungen können so gelassen werden. Hilfestellung bekommt man über die Fragezeichen neben den Optionsfeldern.

Dann benötigt man noch eine App aus dem Playstore, nämlich ‚Proxydroid‚. [appbox googleplay org.proxydroid ]

In dieser App legt man folgende Optionen fest:

• Host: 192.168.99.1
• Port: 8080
• Type: SOCKS5
• Global Proxy: Häkchen

Um über Iodine ins Internet zu kommen, wird folgender Algorithmus angewendet:

1. Verbindung zum Hotspot herstellen
2. AndIodine öffnen und eine Verbindung zum Iodine-Server herstellen
3. Proxydroid starten und Proxy aktivieren
4. Fertig

Danach sollte man über den Proxy surfen können.

Nutzung mit dem PC

Zunächst installiert man sich, ähnlich wie oben aufgeführt, Iodine. Danach kann man sich folgendermaßen zum Server verbinden:

/usr/local/sbin/iodine -f 127.0.0.1 iod.domain.tld

Die Parameter erklärt:

• -f: Im Vordergrund bleiben
• 127.0.0.1: IP eures (Name)servers
• iod.domain.tld: Iodine-Subdomain

Danach solltet ihr den Server pingen können:

ping 192.168.99.1

Der letzte Schritt besteht darin, einen kleinen Socks-Proxy zu installieren bzw. ein Tool, welches den Traffic einer Applikation transparent durch unseren Iodine-Socks-Proxy schiebt. Ich nutze dafür ‚tsocks‘. Unter Archlinux gibt es dazu ein Paket:

sudo pacman -S tsocks

Danach kopiert man sich die Beispielkonfiguration nach /etc/:

cp /usr/share/tsocks/tsocks.conf.simple.example /etc/tsocks.conf

Darin ändert man die entsprechenden Einträge folgendermaßen ab:

# We can access 192.168.0.* directly
local = 192.168.99.0/255.255.255.0

# Otherwise we use the server
server = 192.168.99.1
server_port = 8080
server_type = 5

Nun kann man einem Programm einfach ‚tsocks‘ voranstellen. Zum Vergleich:

$> curl ip.gehaxelt.in
91.9.YY.XX
$> tsocks curl ip.gehaxelt.in
87.106.YY.XX

Fertig!

Geschwindigkeit

Je nachdem welche Fragmentsize der DNS-Relay durchlässt, schwankt die Übertragungsgeschwindigkeit enorm. Am Besten ist natürlich der ‚Raw mode‘, denn dann können die Pakete direkt an unseren Nameserver geschickt werden. Zusätzlich fällt ins Gewicht, dass DNS auf UDP basiert und dadurch viele Vorteile gegenüber TCP fehlen. Beispielsweise die Retransmission, wenn ein Paket im Internet verloren geht.

Meine Erfahrungen zeigen, dass die Geschwindigkeit von 1 Megabyte/10 Minuten (13Kbit/s ~ 2KB/s) bis hin zu 600KB/s schwankt. Es ist also weniger zum richtigen Surfen, als zum ‚Notfall‘-Emailabrufen geeignet.

~ Sebastian

Die Einrichtung von Iodine

Die Einrichtung nicht nicht besonders schwer. Als Voraussetzung wird nicht viel benötigt, außer ein „/dev/tun“ Device auf dem Server, um eine virtuelle Netzwerkschnittstelle zu erzeugen.

Als erstes lädt man sich den Sourcecode herunter und kompiliert diesen mit den bekannten Schritten:

mkdir /tmp/iodine
cd /tmp/iodine
wget http://code.kryo.se/iodine/iodine-0.7.0.tar.gz -O iodine.tgz
tar xfv iodine.tgz
mv iodine-* src
cd src
make

Nun hat man ein neues Verzeichnis namens „bin“:

$ pwd
/tmp/iodine/src
$ ls bin/
insgesamt 288K
drwxr-xr-x 2 gehaxelt users   80 28. Aug 02:09 .
drwxr-xr-x 7 gehaxelt users  260 28. Aug 02:09 ..
-rwxr-xr-x 1 gehaxelt users 139K 28. Aug 02:09 iodine
-rwxr-xr-x 1 gehaxelt users 147K 28. Aug 02:09 iodined

Die erste Datei ist der Client und die letztere der Server (Daemon).

Falls man möchte, kann man noch ein

sudo make install

ausführen, um die beiden Dateien im System zu verankern. Das habe ich hier nicht gemacht.

Die Nutzung von Iodine

Zunächst müssen wir auf einem Server den Iodine-Dienst starten.

sudo iodined -f -P "GeheimesPW" 10.50.0.1 google.com 

Die Parameter bedeuten:

• -f : Im Vordergrund laufen
• -P : Passwort für die Verbindung setzen (Keine Verschlüsselung, nur Authentifzierung)
• 10.50.0.1 : Subnetz für das VPN
• google.com : Domain die wir „abrufen“

Das Programm müssen wir mit Rootrechten ausführen, da es sich an den UDP Port 53 bindet. Ihr solltet also sicherstellen, das dort nicht bereits ein Nameserver o.ä. läuft und das der Port von außen erreichbar ist (Firewall!).

Den Client führen wir lokal aus:

> sudo iodine -f -r -P "GeheimesPW" SERVERIP google.com
Opened dns0
Opened IPv4 UDP socket
Sending DNS queries for google.com to SERVERIP
Autodetecting DNS query type (use -T to override).
Using DNS type NULL queries
Version ok, both using protocol v 0x00000502. You are user #0
Setting IP of dns0 to 10.50.0.2
Setting MTU of dns0 to 1130
Server tunnel IP is 10.50.0.1
Skipping raw mode
Using EDNS0 extension
Switching upstream to codec Base128
Server switched upstream to codec Base128
No alternative downstream codec available, using default (Raw)
Switching to lazy mode for low-latency
Server switched to lazy mode
Autoprobing max downstream fragment size... (skip with -m fragsize)
768 ok.. 1152 ok.. ...1344 not ok.. ...1248 not ok.. ...1200 not ok.. 1176 ok.. ...1188 not ok.. will use 1176-2=1174
Setting downstream fragment size to max 1174...
Connection setup complete, transmitting data

Die Parameter sind die folgenden:

• -f : Wieder im Vordergrund
• -r : Testen, ob direkte UDP-Verbindung zum Server möglich ist (ohne DNS-Relay)
• -P : Passwort vom Server
• SERVERIP : Die IP des Servers auf dem der Iodine-Daemon läuft
• google.com : Die oben konfigurierte Domain

Wir sollten nun eine zusätzliche Netzwerkschnittstelle sehen:

$ ip a 
[snip]
4: dns0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1130 qdisc pfifo_fast state UNKNOWN group default qlen 500
    link/none 
    inet 10.50.0.2/27 scope global dns0
       valid_lft forever preferred_lft forever

Nun sollte es möglich sein, den Server über diese IP-over-DNS Verbindung zu pingen:

> ping -c 5 10.50.0.1
PING 10.50.0.1 (10.50.0.1) 56(84) bytes of data.
64 bytes from 10.50.0.1: icmp_seq=1 ttl=64 time=126 ms
64 bytes from 10.50.0.1: icmp_seq=2 ttl=64 time=127 ms
64 bytes from 10.50.0.1: icmp_seq=3 ttl=64 time=128 ms
64 bytes from 10.50.0.1: icmp_seq=4 ttl=64 time=126 ms
64 bytes from 10.50.0.1: icmp_seq=5 ttl=64 time=134 ms

--- 10.50.0.1 ping statistics ---
5 packets transmitted, 5 received, 0% packet loss, time 4000ms
rtt min/avg/max/mdev = 126.827/128.975/134.496/2.886 ms

Bedenkt bitte, das Iodine den „DNS“-Traffic nicht verschlüsselt und daher die Daten mitgelesen werden können.

Erweiterte Nutzung

Zuletzt noch ein kleiner Tipp wie man effektiv ohne viel Aufwand Traffic mit Hilfe eines SOCKS-Proxy verschlüsselt überträgt. Dazu können wir ganz einfach unseren SSH-Client nutzen um einen entsprechenden Tunnel zwischen unserem PC und dem Server aufzubauen.

ssh -n -N -D 1080 user@10.50.0.1

Die Parameter sind die folgenden:

• -n : Kein Lesen von der Standardeingabe
• -N : Keine Kommandos ausführen
• -D Port : Socks-Tunnel auf Port [Port] öffnen
• user@10.50.0.1 : Benutzername und VPN-IP des Iodine-Servers

Danach kann man im Browser localhost:1080 als Socks(5)-Proxy konfigurieren und sollte dann den Traffic verschlüsselt über die Iodine-Verbindung übertragen bekommen.

~ Sebastian