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

ich zeige euch heute wie man die freie Metasuchmaschine searx installieren kann.

Als allererstes holt ihr euch die neuste Version via git

$ git clone https://github.com/asciimoo/searx.git

Dann wechselt ihr ins searx Verzeichnis und führt folgende Befehle aus

$ cd searx/
$ pip-2.7 install -r requirements.txt
$ sed -i -e "s/ultrasecretkey/`openssl rand -hex 16`/g" searx/settings.yml

Passt dann die searx/settings.yml euren Wünschen entsprechend an und ändert den Port unter dem searx läuft (z.B. port : 13378). Überprüft danach ob alles erstmal halbwegs läuft mit

$ python2.7 searx/webapp.py
$ nc localhost 13378
GET / HTTP/1.0⏎⏎

Wenn nur HTML Code und keine Fehlermeldungen auftauchen ist alles soweit in Ordnung und ihr könnt die Debug-Einstellungen entfernen

$ sed -i -e "s/debug : True/debug : False/g" searx/settings.yml

Erstellt dann einen neuen Service:

$ uberspace-setup-service searx "cd ~/searx;python2.7 searx/webapp.py"
$ svc -u ~/service/searx

Erzeugt in /var/www/virtual/<username> einen neuen Ordner für searx:

$ cd /var/www/virtual/<username>
$ mkdir searx.mydomain.de
$ cd searx.mydomain.de
$ vim .htaccess

Fügt dort folgenden Text ein:

RewriteBase /
RewriteEngine On
RewriteRule (.*) http://localhost:13378/$1 [P]

Wobei ihr den Port entsprechend ändern müsst.

Dann sollte searx von außen unter http://searx.mydomain.de verfügbar sein.

Viel Spaß mit eurer neuen Metasuchmaschine

bitwave

falls ihr Student seid, und für ganz wenig Geld einen mittelklasse Vserver oder ein einfaches Webhostingpaket wollt, dann könnt ihr euch die folgenden Angebote der 1und1-Aktion „Campus Code“ anschauen.

Insgesamt gibt es 6 verschiedene Angebote – alle für 1€/Jahr solange man Student ist:

• Linux Vserver
• Linux Webhostingpaket
• Windows Webhostingpaket
• MyWebsiteLite
• MailXChange
• .de-Domain

Ich vermute mal, dass für die meisten Leute die letzten 3 Angebote relativ uninteressant sind. Falls nicht, findet man hier eine Übersicht der Angebote und weitere Informationen.

Wenn man sich für Webhosting (Linux-basiert) interessiert und keine Angst vor der Kommandozeile hat, dann möchte ich auf die Ubernauten bei Uberspace verweisen. Man zahlt zwar mindestens 1€/Monat, aber dafür hat man sehr viel mehr Möglichkeiten und top Support.

Der Linux-VServer für 1€/Jahr

Damit kommen wir dann zum interessanten Teil, denn bei diesem Paket gibt es sogar eine Domain gratis dazu ;)

• Bis zu 2GB Ram
• 50 GB HDD
• 100 Mbit/s ohne Einschränkungen
• Eigene IPv4
• CPU ??

Für ganze 0.08€/Monat sollte das kein zu schlechter Deal sein. Jedoch ist mit starker künstlicher Einschränkung der Ressourcen zu rechnen, wie man diesem Thread entnehmen kann. Beispielsweise läuft ein TOR-Server nur mit begrenzter Bandbreite (600-700kb/s), da numtcpsock auf 365 gesetzt ist.

Für einen einfachen Webserver mit Datenbank und einigen Webseiten sollte das Angebot jedoch locker ausreichen. Die Prozessanzahl ist laut CodarByte auf 96 Prozesse limitiert. D.h. bei vielen gut besuchten Webseiten mit entsprechend vielen Apache-Kindprozessen könnte es zu Problemen kommen.

Ich habe mir mein Paket soeben bestellt und werde diesen Blogpost updaten, sobald der Server geliefert wurde und ich einige Benchmarks posten 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.

gestern war ich an einem Ort an dem es Internet nur per Kabel gab. Mit meinem Laptop hab ich dann fix einen WLAN Hotspot aufgemacht, sodass die mobilen Endgeräte ebenfalls mit der täglichen Dosis Internet versorgt werden konnten.

Die Voraussetzung

Man benötigt einen AP-fähigen WLAN-Adapter. Ich hatte das Glück das mein integrierter WLAN-Adapter die Eigenschaft erfüllt. Ansonsten kann ein günstiger USB-WLAN-Stick helfen. Ein Device kann als Access Point genutzt werden, wenn es die Features „AP“ bzw. „AP/VLAN“ beherrscht:

$> iw list | grep AP
 Device supports AP-side u-APSD.
 * AP
 * AP/VLAN

Den Acess Point erstellen

Normalerweise müsste man hostapd / dnsmasq usw. von Hand konfigurieren. Allerdings gibt es im AUR ein Paket namens „create_ap“, welches uns die ganze Arbeit abnimmt.

$> yaourt create_ap
1 aur/create_ap git~20140817-1 [installed] (20)
 A shell script to create a NATed/Bridged Software Access Point(aka WiFi)

Nach der Installation muss man das Script nur noch mit Rootrechten ausführen:

sudo create_ap wlan0 eth0 MyWifi 1234567890

Nun wird wlan0 zu einem Access Point umgewandelt. Der Hotspot nennt sich „MyWifi“ und hat das recht langweilige Passwort „1234567890“. Der Traffic wird dann übers „eth0“ weitergeleitet.

~ Sebastian

Meine Highlights waren: 

• Gehaxelt war da!
• YUR war da!
• Die Leute von Uberspace persönlich getroffen (Sind echt ganz nette Menschen)
• Hab einen Open Mandriva USB-Stick bekommen
• Berlin Linux User Group getroffen
• Und ein echt guter Vortrag über freie Softwaretools

Ich hoffe der Linuxtag findet auch nächstes Jahr wieder statt.

Ein wenig zur Theorie und dem Warum?

Ich hab mich nicht groß mit der Theorie der Crypto-Währungen auseinandergesetzt, doch im Großen und Ganzen geht es darum, mathematische Berechnungen durchzuführen, bis ein (Aufgaben)-„Block“ gelöst wurde. Man investiert Rechenpower um einen Block zu lösen und bei Erfolg wird man mit einer bestimmten Anzahl an Coins belohnt. Der Litecoin-Algorithmus sieht eine Belohnung von 50 LTC pro gelösten Block vor.

Als Einzelperson ohne entsprechend speziell darauf ausgelegte Hardware ist es sehr unwahrscheinlich, dass man zeitnah einen Block selbst gelöst bekommt. Die Hash-Rate meiner beiden Server (CPU-Mining) liegt gerade bei ~60kH/s. Der Profit-Rechner liefert mir folgende Wahrscheinlichkeiten:

Time to Find a Block
Expected Time	 935 days 01 hours
Probability of a Block in 1 hour	 0.00%
Probability of a Block in 6 hours 	0.03%
Probability of a Block in 12 hours	 0.05%
Probability of a Block in 24 hours	 0.11%
Probability of a Block in 48 hours	 0.21%
Probability of a Block in 72 hours	 0.32%
Probability of a Block in 7 days	 0.75%
Probability of a Block in 14 days 	1.49%

Bei einer Belohnung von 50 LTC und einem Preis von 2.5$ wären das 125$ (94€) die ich erst in frühstens 2.5 Jahren sehen würde.

Aus diesem Grund gibt  es sogenannte „Pools“. Das sind sozusagen Verbände bzw. Gruppen von verschiedenen Minern, welche zusammen an einem Block rechnen und den erzeugten Gewinn je nach Beteiligung aufteilen. Das hat den Vorteil, dass die Auszahlung in LTC bzw. in Dollar regelmäßiger stattfindet.

Ich habe mich zum Beispiel im Pool „http://pooledbits.com“ eingetragen. Dort gibt es keine Gebühren und es wird ungefähr 1 Block am Tag gelöst.

Nun zum zweiten Teil der Frage: Warum mine ich eigentlich Litecoins und nicht z.B. Bitcoins?

Einerseits ist Bitcoin ein wenig ausgelutscht. Ich vermute, dass sich der relative hohe Preis nicht (mehr/sehr) lange halten wird, und dafür lohnt sich der Aufwand (Rechenpower) nicht. Stattdessen investiere ich die Rechenpower der sonst „idlenden“ Vserver in Litecoins. Die Währung ist von der Berechnungsschwierigkeit etwas leichter als Bitcoin, und außerdem hält sich der Preis stabil bei 2.5$. Sollte Bitcoin irgendwann abdanken, dann könnte mit etwas Glück der Preis der Litecoins steigen -> Win.

Meiner Meinung nach kann es nicht schaden ein paar Litecoins gemined zu haben. Sollte der Preis steigen, hat man gewonnen, andernfalls hat man nichts verloren. Die Kosten der Server kann man mit dem Minen sowieso nicht decken. Laut dem Rechner wären das bei mir ungefähr 4$ (ungerechnet 3€) an Gewinn pro Monat für beide Vserver.

Die Einrichtung des Miners

Wenn man sich für einen LTC-Mining-Pool entschieden hat, dann erstellt man sich bei diesem einen Account. Normalerweise gibt es im Webinterface die Möglichkeit „neue Worker“ anzulegen. Diese Worker sind eure Computer, welche für euch rechnen werden.

Praktisch und theoretisch lohnt sich GPU-Mining mehr, als CPU-Mining. Da ich aber den GPU-Miner auf meiner Nvidia-Karte nicht zum Laufen bringen konnte, und die Server (auf denen ich mine) keine brauchbare Grafikkarte haben, erkläre ich nur das CPU-Mining.

Wir führen wieder die Standard-Schritte zum Selbst-kompilieren von Software aus:

mkdir /tmp/mining && cd /tmp/mining
wget http://sourceforge.net/projects/cpuminer/files/pooler-cpuminer-2.3.2.tar.gz
tar xfv pooler-cpuminer-2.3.2.tar.gz
cd cpuminer-2.3.2
./configure CFLAGS="-O3"
make
sudo make install

Danach sollte uns das Programm „minerd“ zur Verfügung stellen. Das Programm werden wir mit folgenden Parametern aufrufen:

minerd --url=[URL] --userpass=[USER.Workername:PW] --threads [ANZAHL]

Im Webinterface des Pool sollte die URL des Mining-Servers stehen, zu dem sich der Minerd verbinden soll. Den Benutzernamen bzw. Workernamen und das dazugehörige Passwort findet ihr ebenfalls dort. Der Aufruf sollte am Ende so ähnlich aussehen:

minerd --url=stratum+tcp://pooledbits.com:8338 --userpass=gehaxelt.1:x --threads 8

Die Personen, welche meinen Artikel über die Daemontools gelesen haben, könnte die Einrichtung als Service interessieren.

Dazu legen wir erstmal einen neuen Benutzer an:

sudo useradd -M -s /bin/nologin miner

Dem Benutzer wird kein Home-Verzeichnis erstellt (-M) und die Shell wird auf /bin/nologin gesetzt (-s), da wir den Benutzer an sich nur als Dummy benötigen. Die „run“-Datei sieht dann folgendermaßen aus:

#!/bin/bash
USER="miner"
exec 2>&1
exec setuidgid miner minerd --url=stratum+tcp://pooledbits.com:8338 --userpass=gehaxelt.1:x --threads 8

Damit sollte minerd immer schön am Minen sein :)

In der Logdatei meldet sich der erfolgreiche Start von Minerd folgendermaßen:

@400000005232038139b3fedc [2013-09-12 20:09:59] 8 miner threads started, using 'scrypt' algorithm.
@400000005232038418f2872c [2013-09-12 20:10:02] thread 2: 1524 hashes, 1.05 khash/s
@400000005232038425f7a09c [2013-09-12 20:10:02] accepted: 1/1 (100.00%), 1.05 khash/s (yay!!!)
@40000000523203842c47ee0c [2013-09-12 20:10:02] thread 1: 4104 hashes, 2.31 khash/s
@40000000523203842caa324c [2013-09-12 20:10:02] thread 5: 4104 hashes, 2.30 khash/s
@400000005232038434e0b094 [2013-09-12 20:10:02] thread 3: 4104 hashes, 2.13 khash/s
@40000000523203850ade0544 [2013-09-12 20:10:03] thread 7: 4104 hashes, 1.86 khash/s
@4000000052320385195d109c [2013-09-12 20:10:03] thread 0: 4104 hashes, 1.67 khash/s
@40000000523203851d04f28c [2013-09-12 20:10:03] thread 6: 4104 hashes, 1.63 khash/s
@40000000523203852850b784 [2013-09-12 20:10:03] thread 4: 4104 hashes, 1.51 khash/s
@40000000523203862ce78d54 [2013-09-12 20:10:04] thread 1: 5976 hashes, 2.97 khash/s
@4000000052320386375588f4 [2013-09-12 20:10:04] accepted: 2/2 (100.00%), 15.12 khash/s (yay!!!)
@4000000052320388374e87fc [2013-09-12 20:10:06] thread 3: 18420 hashes, 4.56 khash/s
@4000000052320389061aa134 [2013-09-12 20:10:07] accepted: 3/3 (100.00%), 17.55 khash/s (yay!!!)
@40000000523203893a05f73c [2013-09-12 20:10:07] thread 1: 11508 hashes, 3.57 khash/s
@400000005232038a091e34a4 [2013-09-12 20:10:08] accepted: 4/4 (100.00%), 18.15 khash/s (yay!!!)
@400000005232038a2b361494 [2013-09-12 20:10:08] thread 3: 8592 hashes, 4.78 khash/s
@400000005232038a359d0f3c [2013-09-12 20:10:08] accepted: 5/5 (100.00%), 18.37 khash/s (yay!!!)

Fazit

Litecoin ist eine Crypto-Währung, welche sich mit genug Rechenpower „verdienen“ lässt. Ohne entsprechende Hardware kann man aber keinen Profit erwarten, und trotzdem kann es vorteilhaft sein einige Litecoins (LTCs) generiert zu haben, falls der Preis – wie am Beispiel von Bitcoin – schlagartig steigen sollte.

~ 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