Die Installation

Offensichtlich benötigt man auf einem Server den TOR- bzw. OpenVPN-Daemon. Zusätzlich werden wir noch die Iptables brauchen. Diese sollte man leicht über die Paketverwaltung installieren können:

sudo apt-get install openvpn-server tor iptables

Ich werde hier nicht weiter erläutern, wie man OpenVPN konfiguriert. Dazu verweise ich auf das gute Tutorial auf ubuntuusers.de. Im Folgendem werde ich von dieser OpenVPN-Konfiguration ausgehen:

• 10.10.0.1/24-Subnetz
• tun0-Interface

Konfiguration von TOR

Die Default-Konfiguration des TOR-Daemons ist brauchbar. Wir möchten später den Traffic, welcher von den OpenVPN Nutzern kommt über TOR schicken. Dazu bietet uns TOR drei Optionen an:

• DNS-Proxy (Wird benötigt, um *.onion aufzulösen)
• Socks-Proxy (Falls man nur Socks benötigt)
• Transparenter-Proxy (Falls man allen Traffic tunneln möchte)

Wir interessieren uns vor allem für den DNS-Proxy und den transparenten Proxy. Folgende Einstellungen müssen in die /etc/tor/torrc übernommen werden:

VirtualAddrNetwork 10.192.0.0/10
AutomapHostsOnResolve 1
DNSPort 10.10.0.1:53530
TransPort 10.10.0.1:9040

In Kombination mit „AutomapHostsOnResolve“ muss ein beliebiges „privates“ Subnetz als VirtualAddrNetwork zugewiesen werden. Andererseits werden die Daten ans Loopback geroutet und das möchten wir nicht.

Nach dem Speichern muss Tor einmal neugestartet werden:

sudo service tor restart

Ob die Ports richtig zugewiesen sind und korrekt laufen, kann man mit netstat überprüfen:

gehaxelt@VPNBox ~ % sudo netstat -tulpen | grep tor
[sudo] password for gehaxelt: 
tcp 0 0 10.10.0.1:9040 0.0.0.0:* LISTEN 0 3964140 1525/tor 
tcp 0 0 127.0.0.1:9051 0.0.0.0:* LISTEN 0 3964141 1525/tor 
udp 0 0 10.10.0.1:53530 0.0.0.0:* 0 3964139 1525/tor

Damit ist die Konfiguration von TOR soweit abgeschlossen.

Konfiguration der IPtables

Den Großteil der Arbeit nehmen uns die IPtables ab. Mit deren Hilfe werden wir den eingehenden Traffic auf dem OpenVPN-Device „tun0“ durch unseren transparenten TOR-Proxy schicken. Folgende IPtables-Regeln solltet ihr hinzufügen:

export IPTABLES=/sbin/iptables
export OVPN=tun0
###Transparent Tor Proxy
$IPTABLES -A INPUT -i $OVPN -s 10.10.0.0/24 -m state --state NEW -j ACCEPT
$IPTABLES -t nat -A PREROUTING -i $OVPN -p udp --dport 53 -s 10.10.0.0/24 -j DNAT --to-destination 10.10.0.1:53530
$IPTABLES -t nat -A PREROUTING -i $OVPN -p tcp -s 10.10.0.0/24 -j DNAT --to-destination 10.10.0.1:9040
$IPTABLES -t nat -A PREROUTING -i $OVPN -p udp -s 10.10.0.0/24 -j DNAT --to-destination 10.10.0.1:9040

Mit der ersten Regel erlauben wir eingehenden Traffic auf dem OpenVPN-Server. Als nächstes leiten wir mit Hilfe eines Destination-NATs den DNS-Traffic von Port 53 auf den DNS-Proxy von Tor (53530) um. Die beiden letzten Regeln könnte man zusammenfassen, jedoch finde ich die Trennung in UDP+TCP übersichtlicher. Diese Regeln leiten dem restlichen Traffic auf den transparenten TOR-Proxy um.

Die Auftrennung zwischen DNS und restlichem Traffic müssen wir machen, damit sich TOR um die Auflösung der *.onion-Adressen kümmern kann. Damit das ordentlich funktioniert müssen die Clients ihre  DNS-Requests nach Außen zum VPN-Server schicken. Das klappt entweder durch pushen einer Konfiguration über den OpenVPN-Server oder durch manuelles Eintragen eines öffentlichen DNS-Servers (z.B. 8.8.8.8) in der /etc/resolv.conf.

Fazit

Meiner Meinung nach ist das eine ganz einfache Möglichkeit zentral einen TOR-Daemon zu betreiben und anderen Geräten einfach nur einen VPN-Zugang zu verpassen. Zu beachten ist aber, das der Traffic zwischen dem OpenVPN-Server und dem TOR-Proxy mitgeschnitten werden kann.

~ Sebastian

Voraussetzungen

Während diesem Blogeintrag werden einige weitere Tools benötigt, welche ich zum entsprechenden Zeitpunkt einführe. Trotzdem sollte man die folgenden drei Voraussetzungen erfüllen, damit sich das Weiterlesen lohnt:

• Burp Proxy – http://portswigger.net/burp/proxy.html
• Exportierte CA Certicifate (PortSwigger) – http://portswigger.net/burp/help/proxy_options_installingCAcert.html
• Android SDK – http://developer.android.com/sdk/index.html

Im weiteren Verlauf werde ich davon ausgehen, dass diese Tools heruntergeladen, installiert und eingerichtet wurden. Dies sollte relativ intuitiv sein, und im Zweifel findet sich Hilfe im Internet.

Emulator einrichten

Wir müssen zunächst einen neuen Android-Emulator erstellen. Die entsprechende GUI rufen wir mit diesem Befehl auf:

android avd

Dort erstellen wir einen neuen Emulator. Spendiert diesem eine SD-Karte und aktiviert die „externe“ Tastatur. Der erstelle Simulator wird im Folgenden den Namen „BurpTesting“ tragen.

Sollte die Tastatur später nicht erkannt werden, so müsst ihr in einer Konfigurationsdatei die Option „hw.keyboard“ von „no“ auf „yes setzen.

~/.android/avd/BurpTesting.avd/config.ini
hw.keyboard=yes

Emulator mit Proxy starten

Zunächst starten wir die Burp Suite. Ich habe den Proxy auf 127.0.0.1:8888 konfiguriert.

Wenn Burp läuft, können wir den Emulator starten. Dabei hängen wir dem Programmaufruf noch einige Parameter an:

• HTTP-Proxy ist localhost:8888
• HTTP Debug auf der Konsole
• Interne Speicher ist 500MB groß
• Kein Sound
• GPU Rendering aktiv
• Keine Bootanimation

Der gesamte Befehl sieht dann so aus:

emulator -avd BurpTesting -http-proxy localhost:8888 -debug-proxy -partition-size 1000 -no-audio -no-boot-anim -gpu on

Der Emulator sollte nun langsam hochfahren. Es kann einige Minuten dauern, bis man beim Homescreen ankommt.

Portswigger CA Certificate installieren

Damit wir später ohne Probleme HTTPS Verbindungen untersuchen können, müssen wir das von Burp mitgelieferte CA Certificate im Emulator hinzufügen. Dazu schieben wir das Zertifikat zunächst auf die SD Karte. Im nächsten Schritt teilen wir „adb“ mit, welchen Emulator wir als nächstes ansprechen möchten:

adb devices

Dort sollte nun ein Emulator erscheinen. Als nächstes kopieren wir das angesprochene Zertifikat:

adb push PortSwiggerCA /sdcard/PortSwiggerCA.crt

Wichtig ist, dass auf der SD Karte das Zertifikat auf „.crt“ endet, ansonsten erkennt Android dieses nicht.

Als nächstes müssen wir einen Screen lock im Emulator festlegen, damit wir das Zertifikat installieren können. Geht im Emulator dazu auf „HOME“->“Settings“->“Security“->“Screen lock“. Ich habe die PIN-Methode gewählt, da sich dieser relativ einfach über die Tastatur eingeben lässt.

Ist der Screen lock gesetzt, könnt ihr auf der gleichen Einstellungsseite unter „Credential Storage“->“Install from SD card“ auswählen. Der Emulator sollte nun das PortSwigger Zertifikat erkennen und auf Euer abnicken installieren.

Zwischenfazit

Bis hierhin habt ihr den Emulator soweit eingerichtet, dass ihr dessen Traffic (auch HTTPS) im Burp sehen und manipulieren könnt.

Das macht natürlich nur Spaß, wenn man sich Apps zum Testen installieren kann.

Playstore auf dem Emulator einrichten

Wir möchten die zusätzlichen Apps über den Google Play Store beziehen. Dazu müssen wir diesen auf dem Emulator installieren.

Ich habe die für den Google Play Store benötigten APKs in einem Archiv zusammengestellt, und stelle Euch dieses hier zur Verfügung. Mittels der beigefügten „install.sh“ werden die Dateien über adb push auf den Emulator kopiert.

Download: http://uploads.blogpasis.net/Playstore.tgz

Nachdem ihr die Dateien nach den Anweisungen der „install.sh“ oder direkt per Aufruf der Datei auf den Emulator kopiert habt, solltet Ihr den Google Play Store in der Appübersicht sehen. Danach braucht Ihr nur noch darin anzumelden.

Den Google Play Store müsst Ihr bei jedem Start des Emulators erneut installieren, da ich keine Möglichkeit gefunden habe, die Änderungen beizubehalten.

Fazit

Ihr habt nun die Möglichkeit Euch Apps aus dem Google Play Store herunterzuladen, und dessen Traffic zu untersuchen. Dies kann bei sicherheitskritischen Apps, sowie auch bei kleinen Spielen interessant sein. Zudem sollte es möglich werden, genau zu überprüfen, welche Daten eine App an Ihren Server überträgt.

~ Sebastian