Iodine: IP over DNS – Hotspots umgehen

In diesem Blogpost möchte ich beschreiben wie man mit Hilfe von Iodine und ein paar weiteren Tools Hotspots umgehen kann. Das kann zum Beispiel im Ausland nützlich sein, wo für WLAN Zugänge u.a. erhebliche Preise verlangt werden.

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‚. 

ProxyDroid
Entwickler: Max Lv
Preis: Kostenlos

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

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.