ubuntuusers.de

I2P auf dem Raspberry Pi 2

Archivierte Anleitung

Dieser Artikel wurde archiviert. Das bedeutet, dass er nicht mehr auf Richtigkeit überprüft oder anderweitig gepflegt wird. Der Inhalt wurde für keine aktuell unterstützte Ubuntu-Version getestet. Wenn du Gründe für eine Wiederherstellung siehst, melde dich bitte in der Diskussion zum Artikel. Bis dahin bleibt die Seite für weitere Änderungen gesperrt.

Achtung!

Die Verwendung dieses Howto geschieht auf eigene Gefahr. Bei Problemen mit der Anleitung melde dies bitte in der dazugehörigen Diskussion und wende dich zusätzlich an den Verfasser des Howtos.

Hinweis:

Diese Howto-Anleitung wurde zuletzt von Lock-3 am 27.06.2014 unter Ubuntu 14.04 und Ubuntu MATE 15.04 erfolgreich getestet.

Zum Verständnis dieses Artikels sind folgende Seiten hilfreich:

Dieses HowTo beschreibt, wie man Ubuntu 14.04 LTS auf einen Raspberry Pi 2 Modell B 🇬🇧 installiert und einen I2P-Router darauf betreiben kann.

Achtung!

Die auf den Pi portierte Ubuntu-Version wurde von Canonical-Mitarbeiter Ryan Finnie erstellt und ist nicht offiziell. Sie wird über den Blog 🇬🇧 des Entwicklers sowie auf der Wiki-Seite von Raspberry Pi 🇬🇧 zur Verfügung gestellt, jedoch mit dem ausdrücklichen Hinweis darauf, dass eine Versorgung mit Sicherheitsupdates im Gegensatz zum originalen LTS-Kernel nicht garantiert wird. Nähere Informationen finden sich auf den beiden genannten Seiten.

Alternativ kann man Ubuntu-Mate 15.04 🇬🇧 als Grundsystem installieren. Dies ist einfacher umzusetzen und wird deswegen nur kurz am Ende des Howtos beschrieben. Unabhängig davon, welches Grundsystem man wählt, ist das Vorgehen zur Installation des I2P-Routers ab dem Abschnitt Installation von JDK 8 für ARM für beide Systeme identisch.

Voraussetzungen

Für die Installation wird benötigt:

  • Ein Raspberry Pi 2 Model B (die Vorgängermodelle der Raspberry Pi 1-Serie werden aufgrund der fehlenden ARM-v7 Architektur nicht von den beschriebenen Ubuntu-Versionen unterstützt)

  • Eine ausreichend große und schnelle microSD-Karte (Empfohlen: Class 10, > 6 GiB bei Nutzung mit Desktop-Oberfläche und 2 GiB Swap-Datei)

  • Stromversorgung für den Pi

  • HDMI-Kabel zum Anschluss des Monitors

  • Falls kein Ethernet-Kabel genutzt werden soll, kann optional ein Wlan-Stick verwendet werden. Wer jedoch vor der Installation der grafischen Oberfläche die WLAN-Verbindung nicht über die Kommandozeile einrichten kann oder will, sollte solange eine Kabelverbindung zum Router herstellen, bis die grafische Oberfläche installiert ist.

Installation des Grundsystems

Die zugrunde liegende Ubuntu-Variante 14.04 LTS baut auf Ubuntu-Core auf und kommt out-of-the-box ohne grafische Oberfläche daher. Wahlweise kann jedoch Xfce, LXDE oder KDE nachinstalliert werden. KDE ist allerdings selbst mit abgeschalteten Desktop-Effekten sehr langsam und die Installation von Unity ist aufgrund der fehlenden 3D-Beschleunigung nicht möglich. Nach einem direkten Vergleich hat sich LXDE als performanteste Oberfläche herausgestellt (subjektiv).

Die Anleitung zur Installation und Einrichtung des Grundsystems ist größtenteils an die Beschreibung von Albrecht H. 🇩🇪 angelehnt.

Herunterladen und Entpacken des ISO-Images

Zunächst lädt man sich das Image auf Ryan Finnies Blog 🇬🇧 ⮷ oder auf der Wiki-Seite von Ubuntu.com 🇬🇧 herunter, welches später auf die microSD-Karte gespielt wird. Optional, aber empfehlenswert ist die Prüfung der PGP-Signatur. Im Anschluss wird das Image entpackt und man erhält die Dateien 2015-03-02-ubuntu-trusty.img und 2015-03-02-ubuntu-trusty.bmap.

Image auf microSD-Karte übertragen

Der Vorgang ist z.B. auf dem 321linux-Blog 🇩🇪 oder auf raspberrypi.org 🇬🇧 sehr ausführlich beschrieben und ist nach dieser Anleitung durchzuführen.

Kurz zusammengefasst wird der Befehl dd verwendet, um das Image auf die microSD-Karte zu schreiben. Dieser Vorgang kann vor allem bei größeren microSD-Karten sehr lange dauern:

dd bs=4M if=/Pfad/zum/Image/yyyy-mm-dd-ubuntu-trusty.img of=/dev/sdx bs=1M 

Achtung!

  • dd wird ohne weitere Rückfragen bzw. Sicherheitsabfragen ausgeführt. Bei unachtsamen Aufrufen könnten evtl. vorhandene Daten überschrieben werden!

  • Da sich die Geräte-Bezeichnungen nach jedem Bootvorgang ändern können, sind vor der Verwendung von dd stets die aktuellen Gerätedateien zu überprüfen. Dies kann man zum Beispiel mit df -h machen.

  • Der dd-Befehl gibt keine Informationen aus. Falls man den Fortschritt der Operation sehen möchte, öffnet man ein zweites Terminal und führt dort den Befehl "sudo pkill -USR1 -n -x dd" aus. Alternativ nutzt man anstelle von dd den Befehl dcfldd 🇩🇪, welcher den Fortschritt direkt anzeigt.

Experten-Info:

Wer sich bei bei diesem Schritt etwas Zeit sparen und die Sache eleganter angehen will, kann die zuvor entpackte 2015-03-02-ubuntu-trusty.bmap in Kombination mit bmap-tools 🇬🇧 verwenden. Dadurch werden beim Aufspielen des Images nur die benötigten Blöcke geschrieben. Der Befehl dazu lautet "sudo bmaptool copy --bmap ubuntu-trusty.bmap ubuntu-trusty.img /dev/sdX" und führt in der Praxis zum selben Ergebnis wie bei Benutzung des dd-Befehls.

Ext4-Partition vergrößern

Nachdem das Image auf die microSD-Karte übertragen ist, befindet sich dort eine kleine Ext4-Partition. Diese muss nun vergrößert werden, damit später genügend Platz für die Installation der grafischen Oberfläche vorhanden ist. Am einfachsten ist dies mit GParted zu realisieren. Falls keine weiteren Partitionen auf der microSD-Karte benötigt werden, kann die Ext4-Partition auf den gesamten verfügbaren Platz vergrößert werden.

System starten

Nachdem das Image auf die microSD-Karte geschoben und die Ext4-Partition entsprechend vergrößert wurde, kann man die microSD-Karte in den Raspberry Pi einlegen und den Pi starten. Hierzu gibt es keinen Schalter. Der Start erfolgt, sobald man dem Pi Strom zuführt.

Nun kann man sich auf den Pi anmelden:

  • Benutzername: ubuntu

  • Passwort: ubuntu

Achtung!

  • Es wird dringend empfohlen, zuerst das Root-Passwort zu ändern! Details sind dem Artikel passwd zu entnehmen.

  • Zudem sollte man einen neuen Benutzer anlegen, den man der Gruppe sudo hinzufügt und anschließend den voreingerichteten Benutzer ubuntu samt Homeverzeichnis über den Befehl "deluser --remove-home ubuntu" löschen.

Einrichten des Grundsystems

Locale-Einstellungen anpassen

Für die Benutzung des Englischen Desktops mit deutscher Tastaturbelegung sollte zunächst folgende Befehle ausgeführt werden.

sudo locale-gen en_US.UTF-8
sudo locale-gen de_DE.UTF-8
sudo dpkg-reconfigure keyboard-configuration 

System Updaten und Desktop installieren

Nach einem Update mittels

sudo apt-get update
sudo apt-get dist-upgrade 

kann man sich je nach Wunsch eine grafische Oberfläche installieren. Dieser Vorgang kann einige Zeit in Anspruch nehmen. Für die Installation gibt man im Terminal folgendes ein:

  • Für LXDE:

    sudo apt-get install lubuntu-desktop 
  • Für Xfce:

    sudo apt-get install xubuntu-desktop 
  • Für KDE (aus Gründen der Performance nicht empfohlen):

    sudo apt-get install kubuntu-desktop 

Nach der Installation kann der Pi mit dem Befehl:

sudo shutdown -r now 

neu gestartet. Nach dem erneuten Hochfahren kann man sich wie gewohnt an der Benutzeroberfläche anmelden.

Zusätzlichen Grafiktreiber installieren

Mit fbturbo 🇬🇧 ist ein beschleunigter Grafiktreiber X.org 🇬🇧 für den Pi verfügbar, den man installieren und nutzen sollte. Die Installation erfolgt mit:

sudo apt-get install xserver-xorg-video-fbturbo 

Im Anschluss muss man eine xorg.conf erstellen und so konfigurieren, dass der Treiber auch verwendet wird. Dazu installiert man beispielsweise den Editor Nano:

sudo apt-get install nano 

und öffnet die /etc/X11/xorg.conf. (Zu diesem Zeitpunkt existiert die Datei noch nicht. Sie wird jedoch erzeugt, sobald man sie wie unten beschrieben abspeichert)

sudo nano /etc/X11/xorg.conf  

Nun fügt man die folgenden Zeilen in die Datei ein und speichert sie mit der Tastenkombination Strg + X . Die Rückfrage wird nochmals mit Y + bestätigt.

Section "Device"
    Identifier "Raspberry Pi FBDEV"
    Driver "fbturbo"
    Option "fbdev" "/dev/fb0"
    Option "SwapbuffersWait" "true"
EndSection

Um zu prüfen, ob der Treiber auch verwendet wird, sucht man nach einem Neustart in der Datei /var/log/Xorg.0.log nach dem Eintrag.

(II) FBTURBO(0): processor: ARM Cortex-A7

Ist dieser vorhanden, wird der Treiber verwendet.

Im Anschluss sind noch ein paar Raspberry-Pi spezifische Programme zu installieren und Links zu setzten. Details dazu finden sich auf der Download-Seite des Images 🇬🇧

sudo apt-get install libraspberrypi-bin libraspberrypi-dev
sudo ln -s /usr /opt/vc
sudo apt-get install libraspberrypi-bin-nonfree 

Nach einem zweiten Neustart ist der Pi fertig aufgesetzt und kann benutzt werden. Wer den Raspberry Pi von einem anderen Rechner aus steuern will, findet weiter unten auf dieser Seite 🇩🇪 noch gute Hinweise dazu.

Swap-Datei erzeugen

Nach der Installation besitzt das System keinen Auslagerungsspeicher. Dieser kann optional z.B. mit dem Befehl dphys 🇬🇧 als Datei angelegt werden. Zu beachten ist, dass bei der Installation von dphys automatisch eine Swap-Datei im Verzeichnis /var erzeugt wird, die die doppelte Größe des verfügbaren RAM-Speichers besitzt. Im Falle des Raspberry Pi Modell B also etwa 2 GiB. Man sollte sich zuvor vergewissern, dass ausreichend Speicherplatz auf der zuvor vergrößerten ext4-Partition vorhanden ist.

sudo apt-get install dphys-swapfile 

Installation von Oracle Java JDK 8 für ARM

Hinweis!

Fremdsoftware kann das System gefährden.

Die Standard-Java Installation auf Ubuntu nutzt auf dem Raspberry Pi keine Just-in-Time Compilation (JIT) und interpretiert Java-Code byteweise. Dies führt dazu, dass der I2P-Router zwar betrieben werden kann, jedoch eine unnötig hohe Systemlast erzeugt. Aufgrund der begrenzten Ressourcen des Raspberry Pi empfiehlt es sich, Oracle Java JDK 8 für ARM zu installieren. Diese Empfehlung findet sich auch auf der Projektseite von I2P 🇬🇧.

Experten-Info:

Alternativ zur Installation von JDK 8 für ARM kann der I2P-Router auch mit der vorinstallierten Java-Version mit dem zusätzlichen Argument „cacoa“ betrieben werden. Nähere Informationen dazu finden sich hier 🇬🇧. Diese Variante wurde allerdings nicht getestet.

Vor der Installation muss Java SE von der Oracle-Seite 🇬🇧 auf den Pi heruntergeladen werden (32bit-Version für ARM v6/v7 Hard Float ABI).

Im folgenden Beispiel erfolgt die Installation in den Ordner /opt/java/. Die heruntergeladene Datei jdk-8u33-linux-arm-vfp-hflt.tar.gz liegt im Homeverzeichnis des Benutzers. Falls abweichende Pfade gewünscht sind, diese in den folgenden Codezeilen bitte entsprechend anpassen (die heruntergeladene Datei kann später abweichende Namen besitzen).

Zunächst wird das Installationsverzeichnis erstellt:

sudo mkdir -p -v /opt/java 

Im Anschluss wird das heruntergeladene Paket im Homeverzeichnis entpackt:

tar xvzf ~/jdk-8u33-linux-arm-vfp-hflt.tar.gz -C /opt/java/ 

Bei Bedarf kann die heruntergeladene jdk-8uVERSION-linux-arm32-vfp-hflt.tar.gz noch gelöscht werden, da sie nicht mehr benötigt wird:

rm ~/jdk-8u33-linux-arm-vfp-hflt.tar.gz 

Um die Installation des JDK abzuschließen, muss dem System noch mitgeteilt werden, dass eine neue JVM vorhanden ist und wo sich diese befindet.:

sudo update-alternatives --install "/usr/bin/java" "java" "/opt/java/jdk1.8.0_VERSION/bin/java" 1 

Zudem muss dem System mitgeteilt werden, dass die JDK der neue systemweite Standard sein soll:

sudo update-alternatives --set java /opt/java/jdk1.8.0_VERSION/bin/java 

Damit ist die Installation abgeschlossen. Um zu testen, ob alles funktioniert hat, kann man sich die aktuell verwendete Java-Version anzeigen lassen:

java -version 

Beispiel:

java version “1.8.0_60“
Java(TM) SE Runtime Enviroment (build 1.8.0_60-b27)
Java HotSpot(TM) Client VM (build 25.33-b05, mixed mode

Bei Problemen finden sich nähere Informationen zum Thema im Artikel zu Java.

Installation des I2P-Routers

Hinweis!

Fremdsoftware kann das System gefährden.

Grundlegendes zu I2P und seiner Installation wird im Artikel Archiv/I2P beschrieben. Aufgrund der ARMv7-Architektur des Pi gibt es bei der Installation des I2P-Routers jedoch einiges zu beachten.

Im Folgenden wird I2P in dem Ordner ~/i2pbin/ im Homeverzeichnis des Benutzers installiert. Ist ein anderer Pfad gewünscht, diesen bitte entsprechend anpassen:

mkdir ~/i2pbin 

Dann lädt man sich auf der Projektseite 🇬🇧 die Linux-Variante i2pinstall_VERSION.jar herunter und kopiert sie in den erzeugten Installationsordner (Abgleich der PGP-Signatur nach dem Herunterladen empfohlen). Alternativ kann die Datei über das Terminal heruntergeladen werden. (Versionsnummer anpassen):

cd ~/i2pbin
wget http://mirror.i2p2.de/i2pinstall_VERSION.jar 

Jetzt wird die Installation gestartet:

cd ~/i2pbin
java -jar i2pinstall_VERSION.jar -console 

Die Installation erfolgt in den Ordner, in dem auch die .jar liegt, also ~/i2pbin. Zudem wird im Homeverzeichnis ein Ordner ~/.i2p angelegt. Theoretisch könnte der Router nun über den Befehl:

~/i2pbin/i2prouter start 

gestartet werden. Aufgrund der ARM-Architektur funktioniert jedoch der Java-Service-Wrapper nach der Standardinstallation nicht, weswegen man den Router zunächst nicht über ~/i2pbin/i2prouter starten kann, sondern nur über die Datei ~/i2pbin/runplain.sh. Hier ist also noch etwas Handarbeit nötig, um auch ~/i2pbin/i2prouter zum Laufen zu bringen.

Experten-Info:

Bei Start des I2P-Routers über die runplain.sh wird der Java-Service-Wrapper nicht benutzt und somit vom Router die Einstellungen in der ~/i2pbin/wrapper.config ignoriert. Ärgerlich ist das für diejenigen Nutzer, die z.B. aufgrund hoher Bandbreiteneinstellungen den Wert wrapper.java.maxmemory erhöhen wollen.)

Neuinstallation des Java-Service-Wrappers

Hinweis!

Fremdsoftware kann das System gefährden.

Hierzu geht man wie auf der Projektseite 🇬🇧 von I2P beschrieben vor. Zunächst lädt man sich hier 🇬🇧 die aktuelle Version des Java Service Wrappers für Linux herunter (armhf und aus lizenzrechtlichen Gründen die Community-Variante!) und kopiert sie in das Homeverzeichnis.

Anschließend wechselt man in einem Terminal in das Homeverzeichnis und entpackt den Wrapper (Versionsbezeichnung beachten):

cd ~
tar xzf wrapper-linux-armhf-VERSION.tar.gz.tar.gz 

Man erhält das Verzeichnis ~/wrapper-linux-armhf. Jetzt werden einige Dateien aus dem neuen Wrapper-Verzeichnis in den Installationsordner von I2P kopiert (bei abweichenden I2P-Installationsverzeichnis Pfad anpassen):

cp ~/wrapper-linux-armhf/bin/wrapper ~/i2pbin/i2psvc
cp ~/wrapper-linux-armhf/lib/wrapper.jar ~/i2pbin/lib
cp ~/wrapper-linux-armhf/lib/libwrapper.so ~/i2pbin/lib 

Die Installation des Wrappers ist damit beendet. Vor dem Start des Routers muss man in der Datei ~/i2pbin/wrapper.config noch den JDK 8 für ARM Installationspfad angeben. Dazu editiert man die Datei wie folgt:

Vorher:

#********************************************************************
# Java Application
wrapper.java.command=java
# Specify a specific java binary:
# set.JAVA_HOME=/path/to/java
# wrapper.java.command=%JAVA_HOME%/bin/java

Nachher:

#********************************************************************
# Java Application
# wrapper.java.command=java
# Specify a specific java binary:
set.JAVA_HOME=/opt/java/jdk1.8.0_33
wrapper.java.command=%JAVA_HOME%/bin/java

Nun sollte der I2P-Router auch über den Befehl:

~/i2pbin/i2prouter start 

gestartet werden können.

Bei eventuell auftretenden Problemen kann ein Blick in die /tmp/wrapper.log hilfreich sein.

jbigi-Bibliothek hinzufügen

Hinweis:

Ab I2P-Version 0.9.22 kann dieser Schritt komplett übersprungen werden, da die jbigi-Bibliothek bei der Installation bereits korrekt eingebunden wird. Im Sinne einer Archivierung bleibt der Abschnitt jedoch noch einige Zeit erhalten.

Startet man den I2P-Router jetzt, ist er theoretisch und praktisch voll einsatzbereit. Nach einiger Zeit wird man jedoch merken, dass Tunnelabfragen oft wegen hoher Nachrichtenlatenz abgelehnt werden und auch bei geringer genutzter Bandbreite die Systemressourcen (vor allem die CPU) schnell an ihre Grenzen kommen. Grund dafür ist die Bibliothek jbigi. Sie optimiert kryptografische Operationen innerhalb des I2P-Routers und beschleunigt diese deutlich. In der Standardinstallation sind etwa 25 Versionen der jbigi für verschiedene Architekturen enthalten. Nach Recherchen des I2P Mitentwicklers "zzz" hat sich ergeben, dass der I2P-Installer die CPU-Version des Raspberry Pi derzeit (Version 0.9.19) nicht korrekt ausliest und somit die falsche vorkonfigurierte ARM-Version der jbigi-Bibliothek verwendet.

Hinweis:

Zu einem späteren Zeitpunkt (ab Version 0.9.22) ist dieses Problem evtl. bereits gefixt und die Bibliothek wird bei der Installtion korrekt angelegt. Deswegen sollte man auf der Seite http://localhost:7657/logs (Seite ist nur bei aktivem I2P-Router erreichbar) prüfen, ob die jbigi-Bibliothek bereits optimiert ist. Falls ja, findet sich im oberen Teil der Seite der Hinweis "jbigi: Locally optimized native Biginterger library loaded from file" oder "Native BigInteger library libjbigi-linux-armv*.so loaded from source". Falls nicht, erscheint der Hinweis "Native BigInteger library jbigi not loaded - using pure java". Ist die jbigi bereits optimiert, kann dieser Abschnitt komplett übersprungen werden!

Um diesen Fehler zu beheben, gibt es 2 Möglichkeiten, welche nun beschrieben werden. Es genügt, einen der beiden Wege umzusetzen.

  1. jbigi-Bibliothek selbst kompilieren und in den I2P-Installationsordner kopieren

  2. Die korrekte jbigi-Bibliothek aus den vorkonfigurierten Archiv entpacken, umbenennen und in den I2P-Installationsordner kopieren

Vorab: Überprüfen der encryp und decrypt time

Bevor man eine neue jbigi-Bibliothek verwendet, sollte man auf der Seite http://localhost:7657/stats zwei Kennwerte auslesen die besagen, wie "effektiv" der Router Nachrichten ver- und entschlüsselt. Diese Werte sind crypto.elGamal.decrypt und crypto.elGamal.encrypt (in ms). Man sollte sich die beiden Werte notieren, um später überprüfen zu können, ob die gebaute jbigi auch eine Verbesserung mit sich bringt.

Hinweis:

Laut I2P-Homepage sollte der Wert für encrypt unter 50ms liegen. In meinem Fall lag er nach der Standardinstallation bei 494ms und nach der Optimierung der jbigi bei 25ms!

jbigi-Bibliothek aus dem Archiv verwenden

Die für verschiedene Systeme vorkonfigurierten jbigi-Bibliotheken befinden sich in der Datei ~/i2pbin/lib/jbigi.jar. Aktuell (I2P-Version 0.9.19) wird aus diesem Archiv die Datei "libjbigi-linux-armv6.so" benötigt. Die "libjbigi-linux-armv5.so" und "libjbigi-linux-armv7.so" funktionieren nicht! Man entpackt das Verzeichnis, kopiert die libjbigi-linux-armv6.so in den I2P-Installationsordner und bennent die Datei dann in libjbigi.so um.

mkdir ~/unpackedjar
mv ~/i2pbin/lib/jbigi.jar ~/unpackedjar
cd ~/unpackedjar
unzip jbigi.jar
mv libjbigi-linux-armv5.so ~/i2pbin/libjbigi.so
rmdir ~/unpackedjar 

jbigi-Bibliothek selbst bauen

Dafür benötigt man zunächst GMP 🇬🇧 und installiert dazu folgendes Paket aus den Paketquellen:

sudo apt-get install libgmp3-dev 

Dann lädt man sich von der Projektseite 🇬🇧 den aktuellen Source-Code von I2P (i2psource_VERSION.tar.bz2) herunter und entpackt ihn in das Home-Verzeichnis (oder abweichend falls gewünscht).

Nun wird der Source-Code entpackt und im entstandenen Verzeichnis ~/i2p-VERSION/core/c/jbigi/ nach den folgenden zwei Dateien gesucht:

  • build.sh

  • build_jbigi.sh

Diese öffnen man nun mit einem Editor. Den beiden Skripten muss über die Variablen I2P und JAVA_HOME mitgeteilt werden, wo der I2P-Router bzw. JDK installiert sind. Dazu fügt man die Variablen zunächst in der Datei build.sh ein:

Vorher:

#!/bin/sh
#
#  Build the jbigi library for i2p
#
#  To build a static library:
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh
#       This script downloads gmp-4.3.2.tar.bz2 to this directory
#       (if a different version, change the VER= line below)
#
#  To build a dynamic library (you must have a libgmp.so somewhere in your system)
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh dynamic
#
#  The resulting library is lib/libjbigi.so
#

rm -rf bin/local
mkdir -p lib bin/local

# Use 4.3.2 32bit CPUs.
# Use 5.0.2 64bit CPUs.
VER=4.3.2

Nachher:

#!/bin/sh
#
#  Build the jbigi library for i2p
#
#  To build a static library:
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh
#       This script downloads gmp-4.3.2.tar.bz2 to this directory
#       (if a different version, change the VER= line below)
#
#  To build a dynamic library (you must have a libgmp.so somewhere in your system)
#     Set $I2P to point to your I2P installation
#     Set $JAVA_HOME to point to your Java SDK
#     build.sh dynamic
#
#  The resulting library is lib/libjbigi.so
#

I2P=/home/serverd/i2pbin
JAVA_HOME=/opt/java/jdk1.8.0_33

rm -rf bin/local
mkdir -p lib bin/local

# Use 4.3.2 32bit CPUs.
# Use 5.0.2 64bit CPUs.
VER=4.3.2

In der build_jbigi.sh geht man analog vor. Hier genügt es allerdings, die Variable „JAVA_HOME=/opt/java/jdk1.8.0_33“ zu definieren. Jetzt wechselt man im Terminal in den Ordner und führt die build.sh mit dem Attribut dynamic aus:

cd ~/i2p-VERSION/core/c/jbigi
sh build.sh dynamic 

Am Ende der Ausgabe erhält man etwa folgende Zeilen:

...
INFO: run time: 1474ms (14ms each)
INFO: 100 runs complete without any errors
native run time: 	1474ms (14ms each)
java run time:   	14989ms (148ms each)
native = 9.833878177330043% of pure java time
If the second run shows better performance, please use the jbigi that you have compiled so that I2P will work better!
(You can do that just by copying lib/libjbigi.so over the existing libjbigi.so file in $I2P)

Die angegebene „native run time“ sollte um Faktor 5-10 schneller sein als die „java run time“. Ist dies der Fall, ist alles in Ordnung. Man folgt den Anweisungen und kopiert die erzeugte libjbigi.so in den I2P-Installationsordner.

cp ~/i2p-VERSION/core/c/jbigi/lib/libjbigi.so ~/i2pbin/libjbigi.so 

Überprüfen der Änderung

Wird der Router nun gestartet (vorheriges Abschalten, kein Neustart), wird die Bibliothek jbigi geladen und verwendet. Geprüft werden kann dies auf der Seite http://localhost:7657/logs. Findet sich dort die Zeile "jbigi: Locally optimized native Biginterger library loaded from file" war die Aktion erfolgreich.

Auf der Seite http://localhost:7657/stats sollten nun die Werte crypto.elGamal.decrypt und crypto.elGamal.encrypt deutlich reduziert worden sein und der Router dadurch besser laufen. In meinem Fall etwa 25ms encrypt (vorher 450ms) und 140ms decrypt (vorher 2700ms).

Tipps zur Optimierung

Die folgenden Tipps erläutern die gängisten Möglichkeiten, die Lese- und Schreibvorgänge auf die verwendete microSD-Karte durch das System zu reduzieren, um somit die Lebensdauer der Karte zu erhöhen. Ihre Umsetzung ist optional. Weiterführende Informationen zu dem Thema finden sich im Wiki-Artikel zur Nutzung von SSD-Festplatten.

I2P Log-Dateien in Ram auslagern

Man kann man die Log-Dateien des I2P-Routers als RAM-Disk auslagern. Entscheidet man sich dafür, muss man in der Datei ~/i2pbin/i2prouter in der Variable I2PTEMP den Pfad angeben, in dem die zuvor angelegten Ram-Disk eingebunden wurde. Zudem werden die Variablen PIDDIR und LOGDIR angepasst.

I2PTEMP="Pfad/zur/Ram-Disk"
PIDDIR="$I2PTEMP"
LOGDIR="$I2PTEMP/logs"

Journaling deaktivieren

Über den Sinn und Unsinn dieses Schrittes ist im Wiki-Artikel zum Thema TRIM ausführlich berichtet. Letztendlich muss jeder Nutzer für sich entscheiden, ob er die Gefahr eines Datenverlustes für den (geringen) Performance-Vorteil in Kauf nehmen möchte.

Entscheidet man sich dafür, kann man das Journaling bei ausgebundener Raspberry-Pi-Systempartition wie folgt deaktivieren (Partitionsbezeichnung sda1 entsprechend anpassen):

sudo tune2fs -O ^has_journal /dev/sda1 

Anschließend überprüft man, ob das Journaling tatsächlich deaktiviert wurde. In diesem Fall sollte unter "Filesystem features" nun kein has_journal mehr aufgeführt sein.

sudo tune2fs -l /dev/sda1 

Abschließend wird das Filesystem noch auch Fehler überprüft.

sudo e2fsck -f /dev/sda1 

Swap-Datei auslagern/deaktivieren/löschen

Das Schreiben von Daten aus dem Arbeitsspeicher in die Swap-Datei verursacht viele Schreibvorgänge und verschlechtert die Perfomance des Systems. Nach Möglichkeit sollte man das System so betreiben, dass ein Auslagerungsspeicher nicht nötig ist. In diesem Fall kann man die Swap-Datei deaktivieren bzw. löschen. Sollen auf dem System jedoch weitere speicherhungrige Programme laufen, kann man die Swap-Datei auch auf eine externe Festplatte auslagern, um die microSD-Karte zu schonen.

Wie man diese 3 Varianten unter Verwendung von dphys realisiert, ist auf der manpage 🇬🇧 beschrieben. Weitere Informationen und Möglichkeiten finden sich im Wiki-Artikel zu Swap.

Ubuntu Mate 15.04 als Grundsystem

Seit März 2015 gibt es auch eine Version von Ubuntu-Mate 15.04 🇬🇧 für den Raspberry Pi 2. Diese basiert auf der armhf-Version von Ubuntu und nicht auf Snappy Core. Seit April 2015 wird auch hier das PPA von Ryan Finnie benutzt.

Die Installation ist deutlich einfacher also die der oben beschriebenen Ubuntu 14.04-Variante. Wer also Ubuntu-Mate als Grundsystem aufsetzen möchte, schreibt sich das Image mittels dd auf die microSD-Karte und bootet das System. Der übrige Installationsprozess ist komplett in einer grafischen Oberfläche geführt. Sobald das System installiert ist und mit dem Update-Manager alle Updates durchgeführt wurden, kann man beginnen diesen Artikel ab dem Abschnitt Installation von JDK 8 für ARM abzuarbeiten um den I2P-Router zu installieren. Im Abschnitt jbigi-Bibliothek-hinzufügen nutzt man hier die Variante jbigi-Bibliothek aus dem Archiv verwenden.

Hinweis:

  • Der erste Boot-Vorgang und der Installationsprozess laufen sehr langsam. Ab dem ersten Start nach der Installation läuft das System deutlich flotter und die Performance ist durchaus vergleichbar mit der bei Installation von Ubuntu 14.04 samt LXDE-Desktopumgebung.

  • Es ist möglich, dass das Tastaturlayout nach der Installation auf Englisch gestellt ist, obwohl man bei der Installation Deutsch angegeben hat. In dem Fall kann man das Layout über "System-Einstellungen-Hardware-Tastatur" anpassen

Trivia

Unabhängig davon, was man in den Weiten des I2P-Netzwerkes vor hat, sollte man sich stets bewusst machen, dass auch hier keine 100 prozentige Sicherheit und Anonymität gewärleistet werden kann. Zum Einen befindet sich I2P noch in der Beta-Phase und ist mit (sehr grob geschätzten) 37000 Routern ein noch recht kleines Netzwerk.

Zum Anderen ist das Vorhaben, eine auf IP und TCP/UDP basierende Kommunikation komplett sicher und anonym zu gestalten m.E. eine Utopie. Diese Protokolle wurden schlicht nicht dafür geschaffen, dies zu gewährleisten. Es sind jedoch Ansätze wie beispielsweise I2P, die - richtig angewendet - das derzeit höchstmögliche Maß an Sicherheit und Anonymität gewährleisten können. Man kann also durchaus nach bestem Wissen und Gewissen dazu beitragen, diese (aktiv) zu unterstüzen. Dazu genügt bereits die bloße Teilnahme am Netzwerk.

  • Ubuntu 14.04 LTS für den Raspberry Pi

    • Ryan Finnies Blog 🇬🇧 - mit zusätzliche Informationen und Release Notes

    • wiki.buntu.com 🇬🇧 - enthält ebenfalls zusätzliche Informationen und Release Notes

    • Raspberry Pi Forum 🇬🇧 - Offizielles Diskussionsforum rund um die portierte Ubuntu-Version

  • Howto - Übersicht aller Howto-Artikel

Diese Revision wurde am 24. März 2020 21:07 von Heinrich_Schwietering erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Howto