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

Was ist Oniontip?

Oniontip entstand während eines Bitcoin Hackathons in Dublin und der Quelltext ist auf GitHub zu finden. Die Idee ist, dass Betreiber von TOR-Servern eine Bitcoinaddresse im ContactInfo-Feld hinterlassen. Die Adresse wird extrahiert und der dazugehörige TOR-Server wird dann auf der Oniontip-Webseite aufgelistet.

Möchte eine Person die selbstlosen TOR-Betreiber beim Betrieb der für das TOR-Netzwerk überlebenswichtigen Server unterstützen, so kann dieser auf Oniontip eine Spenden-Bitcoinaddresse anfordern und etwas überweisen.

Diese Spende wird vom Script anteilig auf alle Server aufgeteilt. Die Server, welche mehr Bandbreite dem TOR-Projekt zur Verfügung stellen, bekommen ein dementsprechend größeres Stückchen vom Bitcoin ab.

Ich habe meine TOR-Relays vor einigen Tagen (~ eine Woche?) dort eingetragen und seitdem wurden ganze 12 Bitcoins gespendet. Im Namen der Betreiber sage ich Danke dafür.

Die Konfiguration anpassen

Um seinen TOR-Server bei Oniontip.com listen zu lassen, muss man das ContactInfo-Feld in der Konfigurationsdatei anpassen:

gehaxelt@torhost:~$ cat /etc/tor/torrc | grep ContactInfo
#ContactInfo Random Person <nobody AT example dot com>
#ContactInfo 0xFFFFFFFF Random Person <nobody AT example dot com>
ContactInfo tor@noreply.com - 1McE8F5bE7SmcHJzvvGSfvricVPUjhUGt5

Die Bitcoinadresse solltet ihr natürlich anpassen, ansonsten habe ich einen kleinen Nebenverdienst ;)
Nach einem Neustart des TOR-Daemons und einigen Stunden des Wartens sollte euer Server in der Liste erscheinen:

service tor restart

Fazit

Ich für meinen Teil finde die Idee ganz gut. Diese wird wahrscheinlich nicht die Kosten der Serverbetreiber decken, jedoch ihren Dienst als kleine Motivation erfüllen. Sollte ich irgendwann mal ein paar Bitcoins rumliegen haben, so werde ich eine Spende an Oniontip in Erwägung ziehen.

~ Sebastian

Whonix-Konzept (Quelle: www.whonix.org)

Durch diesen Trick kann die Workstation nicht mehr so einfach die echte IP-Adresse verraten, die echte IP ist nicht auf der Workstation gespeichert.

Wenn man schon VirtualBox nutzt sollte die Installation von Whonix recht schnell gemacht sein. Einfach die Systemabbilder von der Whonix-Webseite herunterladen und installieren. Auf der Webseite von Whonix sind diese Schritte auch noch ausführlich dokumentiert.

Fazit: Sieht gut aus. Einfach mal ausprobieren.

Ansonsten: Whonix sucht auch noch Mitwirkende.

da wir nun wissen, dass alle TOR-Nutzer von der NSA überwacht werden, kann es ja nicht viel mehr schaden, wenn man das TOR-Netzwerk mit einem TOR-Relay-Server unterstützt. Wie man TOR dahingehend konfiguriert erkläre ich kurz in diesem Artikel.

Was ist TOR?

TOR ist eine Software. Mit dieser Software lässt sich ein Bereich im Internet erzeugen, welcher nur von TOR-Nutzern besucht werden kann. Dieser wird auch gerne „Deepweb“ bzw. „Darknet“ genannt, da dort nahezu anonym gesurft bzw. Inhalte angeboten werden können. Das ist u.a. einer der Gründe weshalb die Geheimdienste TOR nicht mögen. Andererseits wird es oft von Journalisten bzw. von Menschen mit eingeschränkter Meinungsfreiheit (Zensur, usw.) genutzt.

Für das TOR-Netzwerk gibt es zwei wichtige Arten von Servern (Nodes):

• Exit-Node: Ein Exit-Node ermöglicht das Erreichen von „normalen“ Internetdiensten aus dem TOR-Netzwerk. Die Betreiber solcher Server bekommen oft rechtliche Schwierigkeiten, da viele Angriffe daraus gefahren werden.
• Relay-Node: Ein Relay-Node leitet nur verschlüsselten Traffic zwischen mehreren TOR-Nodes weiter. Man weiß also nicht, ob gut oder bösartiger Traffic weitergeleitet wird. Man bekommt keine rechtl. Probleme (zumindest ist bisher nichts bekannt) und das TOR-Netzwerk wird aktiv unterstützt.

 TOR-Relay konfigurieren

Zunächst benötigen wir das TOR-Paket aus den Paketquellen. Normalerweise befindet es sich dort unter dem Namen „tor“.

sudo apt-get install tor tor-arm

Wir installieren zusätzlich noch das Programm „tor-arm“, welches uns die Verwaltung/Überwachung des TOR-Relays etwas vereinfacht.

Sind die Pakete installiert, so erstellen wir uns ein Passwort für den Verwaltungszugang:

tor --hash-password [PASSWORD]

Den von Tor ausgegeben Hash kopiert ihr euch am Besten in die Zwischenablage.

Als nächsten bearbeiten wir die Konfigurationsdatei von Tor. Diese findet ihr in /etc/tor/torrc. Die wichtigsten Optionen sind folgende:

Log notice file /var/log/tor/notices.log
RunAsDaemon 1
DataDirectory /var/lib/tor
ControlPort 9051
HashedControlPassword [HASHEDPASSWORD]
CookieAuthentication 0
ORPort 9001
Nickname [Ein eindeutiger Nodename]
RelayBandwidthRate 1 MB # Throttle traffic to 100KB/s (800Kbps)
RelayBandwidthBurst 1 MB # But allow bursts up to 200KB/s (1600Kbps)
DirPort 9030
ExitPolicy reject *:*
DisableDebuggerAttachment 0

Am wichtigsten ist die Option „ExitPolicy“, denn diese regelt welche Daten nach außen weitergeleitet werden dürfen. Da wir nur einen Relay erstellen wollen muss der Wert auf „*:*“ gesetzt sein. Ansonsten muss in der Firewall noch TCP-Port 9001 bzw. 9030 geöffnet werden.

Mit den Optionen „RelayBandwidthRate“ bzw. „-Burst“ kann eingestellt werden, ob die Bandbreite limitiert werden soll. Nicht zu vergessen ist außerdem das richtige Passwort, sowie einen eindeutigen Nicknamen zu setzen.

Die restlichen Parameter sollten sich von selbst erklären bzw. finden sich in der Datei noch ausreichend detaillierte Beschreibungen. Nach der Konfiguration muss man den Tor-Node einmal neustarten:

sudo /etc/init.d/tor restart

Tor-Arm: Ein kleines Verwaltungstool

Tor-Arm ist ein kleines in Python geschriebenes Tool mit dem man Tor etwas verwalten kann. Das sieht dann ungefähr so aus:

Wir haben das Tool weiter oben bereits installiert und auch schon das Passwort gesetzt. Ihr müsst das Programm also nur noch aufrufen:

arm

Schon seit ihr mit der Einrichtung und der Unterstützung des Tor-Netzwerkes fertig. Ihr solltet noch zur Kenntnis nehmen, dass Tor-Relays sehr viel Bandbreite verbrauchen können.

~ Sebastian

Da die Quelltexte der Tor Software z.T. offen sind, können wir diese einfach herunterladen und selbst kompilieren. Im Großen und Ganzen werden das 4 Compilevorgänge welche wir ausführen werden:

• Openssl
• Libevent
• Tor
• Tor-arm

Da wir keine Rootrechte haben, werden wir uns eine „/“-ähnliche Struktur im Homeverzeichnis anlegen. 

Openssl kompilieren & installieren

Die erste Voraussetzung für Tor ist openssl. Falls das auf dem System noch nicht vorhanden ist, müssen wir es selbst kompilieren. Dazu wechseln wir in den RAM und erstellen einen separaten Ordner:

cd /tmp/ && mkdir openssl && cd openssl

Im nächsten Schritt laden wir uns das Archiv herunter und entpacken es:

wget http://www.openssl.org/source/openssl-1.0.1e.tar.gz && tar xfv openssl-1.0.1e.tar.gz && cd openssl-1.0.1e

Dem Konfigurationstool „config“ übergeben wir unser Homeverzeichnis als Prefix, damit die Dateien für die Installation entsprechend vorbereitet werden.

./Config --prefix=/home/$USER/
make
make install

Nachdem dieser Prozess abgeschlossen ist, können wir mit der nächsten Prozedur anfangen.

Libevent kompilieren & installieren

Für die Bibliothek „libevent“ führen wir ähnliche Schritte aus. Als erstes erstellen wir wieder einen neuen Ordner.

cd /tmp/ && mkdir libevent && cd libevent

Danach wieder den Quellcoder herunterladen, entpacken, konfigurieren und installieren… ihr wisst schon.

wget https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz 
tar xfv libevent-2.0.21-stable.tar.gz
cd libevent-2.0.21-stable
./configure --prefix=/home/$USER/
make && make install

Endlich: Tor kompilieren & installieren

Jetzt können wir den Vorgang endlich für das eigentliche Programm ausführen. Die Prozedur sollte euch mittlerweile schon bekannt sein ;)

cd /tmp && mkdir tor && cd tor
wget https://www.torproject.org/dist/tor-0.2.3.25.tar.gz
tar xfv tor-0.2.3.25.tar.gz
cd tor-0.2.3.25
./configure --prefix=/home/$USER/
make && make install

Jetzt solltet ihr die Tor-Binaries im ~/bin Verzeichnis finden. Bevor ihr Tor ausführt, solltet ihr diesen korrekt konfigurieren. 

Tor als Relay-Node konfigurieren

Im Tor-System gibt es drei verschiedene Servertypen. Die Entry-, Relay- & Exitnodes. Die ersten Beiden sollte man ohne weitere Kopfschmerzen bzw. Probleme betreiben können. Über die Entry-Nodes verbinden sich die Tor-Nutzer mit dem Tor-Netzwerk. Die Relay-Nodes dienen als Zwischenstellen zwischen dem Entry und dem Exit Node. Der Exit-Node ist dann die Schnittstelle zwischen Tor-Netzwerk und Internet. Die Personen, die diese Art von Server betreiben bekommen oft Post von unglücklichen Administratoren bzw. Multimediaunternehmen ;)

Wie auch immer, wir erstellen nur einen Relay-Node, welcher das Tor-Netzwerk erweitert. Tor liefert eine Beispielkonfiguration, welche wir als Grundlage verwenden und als „torrc“ kopieren.

cp ~/etc/tor/torrc.sample ~/etc/tor/torrc

Öffnet diese danach mit eurem favorisierten Texteditor. Die folgenden Einstellungen sollten ähnlich gesetzt werden. (Suchfunktion empfehlenswert):

• ExitPolicy reject *:* # no exits allowed
  
• Nickname MyUniqueNode #Tor nodes nickname
• ORPort 9001 #Tor port
• RelayBandwidthRate 5000 KB # Throttle traffic to 100KB/s (800Kbps)
• RelayBandwidthBurst 5000 KB # But allow bursts up to 200KB/s (1600Kbps)
• Log notice file /home/[BENUTZER]/var/log/tor/notices.log #Logfile
• Log debug file /home/[BENUTZER]/var/log/tor/debug.log #Logfile
• ControlPort 9051 #Controlport
• HashedControlPassword 16:PASSWORT #(siehe weiter unten)

Den Wert für den Eintrag „HashedControlPassword“ müssen wir zunächst generieren. Die benötigten Hashwert erhaltet ihr über folgenden Aufruf:

~/bin/tor --hash-password PASSWORT

Speichert eure Konfiguration und prüft zwei Mal, ob der Wert ExitPolicy korrekt gesetzt ist ;)

Damit wir Tor später unsere Binaries im ~/bin Verzeichnis ohne weitere Umstände ausführen können, fügen wir den Pfad einfach zur PATH Variable hinzu:

export PATH=$PATH:/home/$USER/bin

Ihr solltet nun Tor über die Eingabe von „tor“ direkt ausführen können. Tor sollte ohne weitere Fehlermeldungen starten, und anfangen seine Arbeit als Relay-Node aufzunehmen. Voraussetzung ist, dass die oben angegebenen Ports von Außen erreichbar sind.

Tor-Arm installieren

Es bietet sich immer an, eine textbasierte UI zu haben, um Informationen über den Torserver zu erhalten. Dazu bietet sich das kleine Tool „tor-arm“ an. Es basiert auf Python. Ich gehe davon aus, dass Python bereits auf dem System zur Verfügung gestellt wird. Andernfalls muss Python nach dem zuvor gezeigten Schema installiert werden.

Um Tor-arm einzurichten, müssen wir ein wenig an den Dateien rum basteln. Zunächst laden wir diese aber erstmal herunter und entpacken das neue Archiv.

mkdir /tmp/torarm && cd /tmp/torarm
wget http://www.atagar.com/arm/resources/static/arm-1.4.5.0.tar.bz2
tar xfv arm-1.4.5.0.tar.bz2 
cd arm

Danach müssen wir  einen Ordner für arm erstellen und die Dateien kopieren:

mkdir -p ~/etc/arm/
cp src/* ~/etc/arm/

Also nächstes kopieren wir das zum Starten benötigte Shellscript:

cp arm ~/bin/

Dieses Script müssen wir noch ein wenig bearbeiten. Öffnet die Datei unter ~/bin/arm und ändert die ersten Zeilen ab:

if [ "$0" = /home/$USER/bin/arm ]; then
  arm_base=/home/$USER/etc/arm/

Speichert die Datei ab. Jetzt solltet ihr „arm“ aufrufen können und es sollte euch nach dem Control-Passwort fragen. Habt ihr dieses eingegeben, dann sollte euch eine schöne UI über euren Tor-Node informieren.

Fazit

Der Artikel wurde am Ende doch etwas länger als erwartet. Ich hoffe aber trotzdem damit einige zu motivieren einen kopfschmerzfreien Tor-Relay Node aufzusetzen, um das Tor-Netzwerk zu unterstützen. Wer die ganzen Quelltexte nicht selbst kompilieren möchte, der kann auf fertige Pakete zugreifen: tor, tor-arm.

~Sebastian