linksunten Archiv

Linux wird in der Linken aus guten Gründen immer beliebter. Doch die wenigsten trauen sich an die Kommandozeile, um beispielsweise eine Firewall zu installieren oder einen Server aufzusetzen. Wir wollen euch anhand eines praktischen Beispiels – gemeinsames Protokollieren in Echtzeit – die Systemadministration unter Linux näher bringen. Auf dem Weg zu einem lokalen infinote-Protokollserver werden wir Netzwerke mit netstat analysieren, eine iptables-Firewall einrichten und sie mit nmap testen, Zugriffe auf SSH-Tunnel beschränken und eine git-Versionsgeschichte des Protokolls anlegen.

• 01) Wir schaffen zusammen, nicht allein - Zum Kollaborativen Schreiben
• 02) Communication tools for liberatory social change - Online Etherpad vs. lokaler Server
• 03) Linux. The choice of a GNU generation. - Wahl des Betriebssystems und der Software
  
• 04) Ein paar Voraussetzungen müssen sein - Festplattenverschlüsselung & Passwörter
• 05) Sieh nur, die Server lauschen - Lokale Server mit Netstat anzeigen
  
• 06) Öffnungen in Brandwänden sind unzulässig - Eine iptables Firewall als Schutz 
• 07) Was genau macht denn die Firewall? - Eine Erklärung der iptables-Regeln
  
• 08) Kriminelle Energie braucht Portscanner - nmap sucht nach offenen Ports 
• 09) Setting up infinoted quick'n'dirty - Ein Server für kollaboratives Schreiben  
• 10) Gobby: inclined to shoot one's mouth off - Ein kollaborativer Texteditor
  
• 11) Keeping your communiqués secret - Portforwarding über SSH-Tunnel
• 12) Indistinguishable from magic - Versionskontrolle mit git
• 13) It's all about communication - Kontakt zum Autonomen Techkollektiv Freiburg

01) Wir schaffen zusammen, nicht allein - Zum Kollaborativen Schreiben

In vielen politische Gruppen ist es üblich, Protokolle ihrer Treffen zu schreiben. Dabei gibt es einige Probleme, die immer wieder auftreten: insbesondere bei Treffen mit vielen TeilnehmerInnen ist der oder die Protokollierende schnell überfordert, kann sich nicht angemessen einbringen oder zumindest seine oder ihre eigenen Beiträge nicht sorgfältig protokollieren. Falls mehrere Protokollierende sich die Arbeit teilen, können diese ihre Protokolle nicht in Echtzeit zusammenführen, so dass oft doppelte Arbeit gemacht wird. Auch gibt es keine Möglichkeit, in Echtzeit falsche Informationen zu korrigieren und Lücken zu füllen. Wenn diese Protokolle anschließend elektronisch verbreitet werden sollen, werden sie oft direkt digital erstellt. Um die angerissenen Probleme zu beheben oder zumindest abzuschwächen, bietet es sich daher an, mit mehreren Personen zeitgleich dasselbe Dokument zu bearbeiten. Der Fachbegriff dafür: Kollaboratives Schreiben.

02) Communication tools for liberatory social change - Online Etherpad vs. lokaler Server

Eine komfortable Möglichkeit des kollaborativen Schreibens sind Etherpads. Das linke Tech-Kollektiv Riseup bietet beispielsweise einen solchen Service an: pad.riseup.net. Etherpads erlauben gemeinschaftliches Bearbeiten von einfachem Text in Echtzeit und eignen sich hervorragend für spontanes, gemeinschaftliches Protokollieren. Aber sie haben auch zwei grundlegende Probleme: ein Internetanschluss ist Voraussetzung und die Inhalte werden auf einem entfernten Server gespeichert. In diesem Artikel wird erklärt, wie ein Rechner mit einer Firewall geschützt und als lokaler Server für kollaboratives Schreiben eingesetzt werden kann. Wenn zudem noch ein Router eingesetzt wird oder ein Rechner so konfiguriert wird, dass er als als lokaler Hotspot dient, steht dem gemeinsamen Protokollieren klandestiner Treffen in abgelegenen Gegenden nichts mehr im Weg. Außer vielleicht der Erkenntnis, dass manche Dinge besser nicht protokolliert werden sollten.

03) Linux. The choice of a GNU generation. - Wahl des Betriebssystems und der Software

Wir beschreiben die Installation des Programms infinoted, welches das infinote Protokoll implementiert, auf dem der Debian-basierten GNU/Linux-Betriebssystem Xubuntu. Linux kommt unseren anarchistischen Überzeugungen recht nahe und Xubuntu bietet eine gute Mischung aus aktueller Software und schnellen Sicherheitsupdates. Als Editor benutzen wir Gobby, den es auch in einer Macintosh- und einer Windows-Variante gibt. Eine Alternative zu diesem Vorgehen wäre die Installationen eines Web-Servers mit einem Etherpad. Dann könnte der Dienst zwar von jedem netzwerkfähigen Gerät mit Browser benutzt werden. Doch eine Verschlüsselung muss natürlich sein. Und einen Webserver mit Etherpad samt https-Verschlüsselung einzurichten ist deutlich komplizierter und nicht so robust wie eine infinoted/Gobby-Lösung mit TLS-Verschlüsselung. Alternativ kann die Verschlüsslung auch über Portforwarding mittels SSH geschehen, wie im Kapitel Keeping your communiqués secret beschrieben.

04) Ein paar Voraussetzungen müssen sein - Festplattenverschlüsselung & Passwörter

Wenn ihr dieser Anleitung folgt oder unsere Experimente als Anregung zum Aufsetzen eines lokalen Protokollrechners nutzt, dann sollte dieser Server nicht nur gegen Angriffe aus dem Netz geschützt, sondern auch lokal abgesichert werden. Es ist besonders wichtig, dass ihr die Festplatte verschlüsselt und dafür ein sicheres Passwort mit mindestens 16 Stellen verwendet, das ihr sonst nirgendwo benutzt. Bei Xubuntu ist Festplattenverschlüsselung ab Version 12.10 standardmäßig integriert. Nach der Verschlüsselung müsst ihr bei jedem Xubuntu-Systemstart euer Passwort eingeben, ansonsten ist eure Festplatte nicht lesbar. Außerdem solltet ihr das System aktuell halten, also die Aktualisierungsverwaltung als Geschenk von Leuten verstehen, die Sicherheitsprobleme für euch gelöst haben, und nicht als lästiges Rumgenerve, für das ihr ausgerechnet jetzt nun wirklich keine Zeit habt.

05) Sieh nur, die Server lauschen - Lokale Server mit Netstat anzeigen

Ein Server ist ein Hintergrundprogramm, das einen Dienst anbietet. Diesen Dienst kann ein anderes Programm, ein Client, nutzen. Der Client kann entweder auf dem gleichen Rechner laufen oder den Dienst übers Netz nutzen. Der Server bietet seinen Dienst auf einem Port an, das heißt er lauscht auf diesem Port auf Anfragen eines Clients. Welche Server auf welchem Port lauschen, könnt ihr euch in einem Terminal mit dem Tool netstat anzeigen lassen. (Das Zeichen $ steht dabei für eine Eingabeaufforderung im Terminal und darf nicht mit eingegeben werden. sudo [= superuser do] führt den nächsten Befehl mit root-Rechten aus.)

$ sudo apt-get install net-tools


$ sudo netstat -lnptu


Die Ausgabe des Befehls sieht zugegebenermaßen auf den ersten Blick etwas kryptisch aus. Eine nähere Erläuterung von netstat bekommt ihr über die man-Page des Befehls. Allerdings ist die deutsche Übersetzung der man-Page sehr viel schlechter als das englische Original, deswegen solltet ihr euch das Original durchlesen:

$ LC_ALL=C man netstat

Die Ausgabe des netstat-Aufrufs führt alle Ports auf, auf denen ein Server lauscht, also alle offenen Ports. Und offene Ports auf von außen erreichbaren Netzwerkinterfaces können ein Einfallstor für Hackangriffe auf den Rechner sein. Grundsätzlich sollten auf solchen Interfaces nur Programme lauschen, von denen ihr wisst, was sie tun und warum ihr sie laufen lasst. Und genau dafür braucht ihr eine Firewall.

06) Öffnungen in Brandwänden sind unzulässig - Eine iptables Firewall als Schutz

Eine Funktion einer Firewall ist es, Ports zu öffnen oder zu schließen. Da wir unseren Server unter Linux einrichten wollen, werden wir die Standard-Firewall unter Linux einrichten: iptables. Konkret schreiben wir eine Textdatei mit iptables-Befehlen: ein Shell-Skript. Wir installieren zuerst iptables und benutzen dann einen beliebigen Texteditor, um die Firewall zu erstellen. Zum Beispiel können wir GNU nano verwenden:

$ sudo apt-get install iptables

$ sudo nano /etc/init.d/firewall

In nano können wir nun das Firewall-Skript erstellen, also folgende Zeilen komplett in nano kopieren:

#!/bin/sh
### BEGIN INIT INFO
# Provides:          firewall
# Required-Start:    mountkernfs, $local_fs
# Required-Stop:     $local_fs
# X-Start-Before:    $network
# X-Stop-After:      $network
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start firewall at boot time
# Description:       Start an iptables based firewall to block inbound connections
### END INIT INFO
case "$1" in
    start | restart )
        if [ "$1" = "restart" ]; then
            # kill all input rules
            iptables -F INPUT
            ip6tables -F INPUT
        fi
        ### allow all local communication
        iptables -A INPUT -i lo -j ACCEPT
        ip6tables -A INPUT -i lo -j ACCEPT
        ### keep all already established communication
        iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
        ip6tables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
        ### open ssh port
        #iptables -A INPUT -m state --state NEW -m tcp -p tcp --destination-port 2222 -j ACCEPT

        ### open infinoted port

        iptables -A INPUT -p tcp --dport 6523 -j ACCEPT
        ###log all communication
        #iptables -A INPUT -j LOG
        ### reject the rest
        iptables -A INPUT -j REJECT
        ip6tables -A INPUT -j REJECT
        ;;
    stop)
        ### kill all input rules
        iptables -F INPUT
        ip6tables -F INPUT
        ;;
    *)
        echo "Usage: $0 {start|stop|restart}"
        exit 1
        ;;
esac

Anschließend beenden wir nano mit Strg+X, machen das Skript nur für root lesbar, richten einen automatischen Startmodus ein und starten es hier und jetzt:

$ sudo chmod 700 /etc/init.d/firewall

$ sudo update-rc.d firewall defaults
$ sudo service firewall start

07) Was genau macht denn die Firewall? - Eine Erklärung der iptables-Regeln

Unser Firewall-Skript ist eine Aneinanderreihung von Befehlen, die auch im Terminal ausgeführt werden können. Wir wollen die wichtigsten erklären, um die Funktionsweise der Firewall zu erläutern. Zeilen, die mit einer Raute # beginnen, werden bei der Ausführung ignoriert, sie sind auskommentiert. Diese Raute hat nichts mit dem Zeichen zu tun, das anzeigt, ob wir Befehle als root eingeben sollen.

Am Anfang steht eine Shebang (#!/bin/sh), die angibt, um was für eine Art Skript es sich handelt. In unserem Fall ist das die Shell, in der wir auch bisher die Befehle eingegeben haben. Der INIT INFO Teil legt fest, wann das Skript im automatischen Startmodus gestartet wird und die case-Anweisungen unterscheiden, ob wir das Skript starten oder stoppen. Wenn wir das Skript stoppen, sorgt iptables -F INPUT dafür, dass alle INPUT-Regeln gelöscht werden. Wir kümmern uns hier nur um die INPUT-Regeln, also die Regeln für eingehende Anfragen. Wenn keine Regeln definiert sind, werden einfach alle Anfragen durchgereicht zu Servern, die auf Ports lauschen.

Mit iptables -A INPUT -i lo -j ACCEPT wird die Input-Schlange der lo-Netzwerksschnittstelle freigeschaltet. lo steht hier für Verbindungen eures Rechners zu euch selbst. Dieser Art der Verbindung mag erst einmal sinnlos klingen, aber sie erlaubt es Clients auf dem Serverrechner mit dem Server zu kommunizieren, ohne dass erst eine Verbindung nach außen aufgebaut werden muss. lo ist eine virtuelle Netzwerkschnittstelle im Gegensatz zum Beispiel zur physikalischen Netzwerksschnittstelle eth0, so heißt meistens die kabelgebundene LAN-Schnittstelle, oder wlan0, wie häufig die WLAN-Schnittstelle heißt. Der Befehl ip6tables -A INPUT -i lo -j ACCEPT ist das IPv6-Pendant zum IPv4-Befehl iptables. Bei IPv6 handelt es sich um ein neues Netzwerkprotokoll, das aus Datenschutz-Sicht einige Probleme mit sich bringt, aber demnächst Standard wird.

Mit iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT stellen wir sicher, dass Verbindungen, die von einem Programm auf dem eigenen Rechner aktiv nach außen geöffnet werden, auch von außen erreichbar sind. Außerdem öffnen wir mit iptables -A INPUT -p tcp --dport 6523 -j ACCEPT den Port 6523, den Standardport von infinoted. Wenn eine Anfrage von außen von keiner der bisherigen Regeln durchgelassen wurde, wird sie anschließend mit iptables -A INPUT -j REJECT verworfen.

08) Kriminelle Energie braucht Portscanner - nmap sucht nach offenen Ports

An diesem Punkt solltet ihr eure Firewall testen. Dafür müsst ihre eure IP-Adresse in Erfahrung bringen, und dafür müsst ihr erst einmal rausfinden, über welches Interface (Netzwerkkarte) ihr im Netz seid. Der Befehl ifconfig zeigt die verfügbaren Netzwerkschnittstellen an, iwconfig nur die WLAN-Schnittstellen. Wenn ihr über WLAN im Netz seid, dann ist es wahrscheinlich die Zahl hinter inet Adresse im Abschnitt wlan0. Nehmen wir einfach mal an, eure Adresse sei 192.168.1.42. Dann braucht ihr jetzt einen zweiten Rechner (oder eine VirtualBox mit Bridged Networking), denn eine Firewall lässt sich nur von außen zuverlässig testen. Installiert auf dem zweiten Rechner einen Portscanner wie nmap, also ein Programm, das nach offenen Ports sucht, und führt anschließend einen Portscan durch:

$ sudo apt-get install nmap

$ sudo nmap -sS -PN -p- 192.168.1.42

Das Ergebnis sollte genau einen offenen Port anzeigen, und zwar den von uns geöffneten Port 6523. Ihr solltet den Portscan noch einmal wiederholen, nachdem ihr auf dem Protokollrechner mit service firewall stop die Firewall gestoppt habt. Falls ihr euch an dieser Stelle fragt, wie ein Angriff auf solch einen offenen Port aussehen kann, empfehlen wir das Programm Metasploit, das im Buch The Penetration Tester's Guide näher beschrieben und in der auf Ubuntu basierenden Hacker-Distribution Backtrack Linux enthalten ist.

09) Setting up infinoted quick'n'dirty - Ein Server für kollaboratives Schreiben

Wir haben nun die Voraussetzungen dafür geschaffen, einen infinoted-Server aufsetzen zu können. Zuerst installieren wir die Software:

$ sudo apt-get install gobby-infinote infinoted moreutils openssl

Damit die Clients verschlüsselt mit dem Server kommunizieren können, müssen wir uns TLS-Zertifikate erstellen (und das kann etwas dauern):

$ mkdir ~/.infinote-git; mkdir ~/.infinote; infinoted --create-key --key-file=`echo ~/`.infinote/infinoted-key.pem --create-certificate --certificate-file=`echo ~/`.infinote/infinoted-certificate.pem --daemonize; killall infinoted

Sobald sich ein Client mit dem Server verbindet, wird das TLS-Zertifikat des Servers angefordert und der dazugehörige Fingerprint angezeigt. Dieser Fingerprint sollte mit dem Fingerprint des Protokollservers verglichen werden, damit klar ist, dass niemand in der Mitte lauscht. Der Fingerprint des Protokollserver-Schlüssels wird mit diesem Befehl angezeigt:

$ openssl x509 -fingerprint -sha1 -noout -in ~/.infinote/infinoted-certificate.pem

Nun können wir den Protokollserver starten:

$ infinoted --daemonize --security-policy=require-tls --autosave-interval=10 --certificate-file=`echo ~/`.infinote/infinoted-certificate.pem --key-file=`echo ~/`.infinote/infinoted-key.pem --sync-directory=`echo ~/`.infinote-git --sync-interval=60 --password 'Mindestens16Stellen!'

Nachschauen, ob der Protokollserver läuft:

$ ps -ef | grep [i]nfinoted

Die IP-Adresse des Protokollrechners herausfinden, wenn das verwendete Interface wlan0 ist:

$ ifdata -pa wlan0

Und nach getaner Arbeit den Protokollserver abschießen:

$ killall infinoted

Die Einstellungen können alternativ auch in Konfigurationsdateien gespeichert werden. Auch kann der Server als Systemdienst laufen, aber gerade bei sensiblen Daten ist davon abzuraten, den Server ständig laufen zu lassen. Denn was nicht läuft, kann auch nicht so leicht gehackt werden.

10) Gobby: inclined to shoot one's mouth off - Ein kollaborativer Texteditor

Als Client verwenden wir Gobby, das wir auf dem Protokollrechner gleich mitinstalliert haben. Für anderen Betriebssysteme kann der Gobby-Download von der Website des Projekts erfolgen. Gestartet wird das Programm übers Menü oder über die Kommandozeile:

$ gobby &

$ exit

Unter Datei → Zu Server verbinden kann die IP-Adresse des Protokollrechners eingetragen werden. Ein Client auf dem Protokollrechner selbst kann sich auf 127.0.0.1 oder localhost verbinden. Anschließend können in Gobby über das Menü oder mit einem Rechtsklick auf den Protokollrechner neue Ordner und Dokumente angelegt werden. Außerdem steht in Gobby auch ein Chatfenster zur Verfügung, über den sich die ProtokollantInnen über Fragen des Protokolls austauschen können, ohne die anderen zu stören.

11) Keeping your communiqués secret - Portforwarding über SSH-Tunnel

Als Alternative zu einem offenen Port nach außen für jeden Server, der auf unserem Rechner einen Service anbieten soll, können wir wie oben erwähnt das Standardprotokoll SSH zur Verschlüsselung zwischen zwei Rechnern benutzen und die Ports tunneln. Dabei lassen wir per SSH einen Port auf dem Server (in unserem Fall der Gobby-Standardport 6523 auf einen Port auf unserem Server weiterleiten, zum Beispiel ebenfalls 6523). Als erstes setzen wir einen SSH-Server auf unserem Protokollrechner auf:

$ sudo apt-get install openssh-server pwgen

Normalerweise lauscht der SSH-Server auf Port 22, aber wir benutzen lieber einen anderen Port, um Angriffe zu erschweren. Dazu ändern wir die SSH-Konfigurationsdatei und ändern die Zeile Port 22 zum Beispiel in Port 2222:

$ sudo nano /etc/ssh/sshd_config

Ans Ende der sshd_config fügen wir einige Zeilen ein, die SSH-Tunnel auf den User, den wir später erstellen, und auf den lokalen Gobby-Port zu beschränken:

AllowTcpForwarding no
Match User forward
AllowTcpForwarding yes
PermitOpen localhost:6523


Anschließend passen wir unsere Firewall an, indem wir den Gobby-Port nach außen schließen und den SSH-Port öffnen:

$ sudo nano /etc/init.d/firewall

Die entsprechenden Zeilen im Firewall-Skript sollten dann folgendermaßen aussehen:

### open ssh port
iptables -A INPUT -m state --state NEW -m tcp -p tcp --destination-port 2222 -j ACCEPT

### open infinoted port

#iptables -A INPUT -p tcp --dport 6523 -j ACCEPT


Jetzt müssen wir noch die beiden Skripte neu starten:

$ sudo service firewall restart

$ sudo service ssh restart

Damit von außen auf den Protokollrechner zugegriffen werden kann, muss es einen Account geben, der fast keine Rechte hat, damit den Service niemand missbrauchen kann. Wir legen einen Account forward an und vergeben ein Passwort (das wir uns zum Beispiel mit pwgen -s1 16 zuvor erstellen):

$ sudo groupadd forward
$ sudo useradd -d /dev/null -g forward -s /bin/false forward
$ sudo passwd forward

Falls die IP des Protokoll-Rechners 192.168.1.42 ist, können wir mit folgendem Befehl den Gobby-Port über SSH tunneln. Die zweite 6523 ist dabei der Port auf dem Protokollrechner, alle Parameter können auch in einer Konfigurationsdatei hinterlegt werden. Dieser Befehl wird dabei auf dem Client-Rechner ausgeführt!

$ ssh -f -N -L 6523:localhost:6523 forward@192.168.1.42 -p 2222

Anschließend ist der Gobby-Server sowohl auf dem Protokollrechner als auch auf den Client-Rechner über localhost ansprechbar. Nach einer Session sollte auf dem Protokollrechner der SSH-Account gesperrt werden (passwd -l reicht nicht, der login z.B. über SSH-Keys ist weiterhin möglich):

$ sudo usermod -e 1 forward

Entsperrt werden kann der Account bei einer neuen Session mit

$ sudo usermod -e -1 forward

12) Indistinguishable from magic - Versionskontrolle mit git

Ein Problem bei Gobby ist, dass jede Person nur ihre eigenen Änderungen rückgängig machen kann. Eine Person kann also den kompletten Text löschen und es gibt keine Möglichkeit mehr, an die bisherigen Versionen zu gelangen. Um dieses Problem zu umgehen, können wir das Versionskontrollsystem git auf dem Protokollrechner nutzen:

$ sudo apt-get install git qgit


Wir initialisieren ein git-Repository mit beliebigen Daten (um lästige Hinweise auszublenden):

$ cd ~/.infinote-git

$ git init

$ git config user.name "Your Name Comes Here"
$ git config user.email you@yourdomain.example.com

$ git config color.status auto
$ git config color.branch auto

$ git add .

$ git commit -m 'Initial commit'

Wir wollen natürlich nicht jede Minute von Hand unsere Texte sichern, deshalb schreiben wir uns ein Skript, dass wir über cron starten:

$ mkdir ~/.infinote-git/bin

$ nano ~/.infinote-git/bin/infinote-git


Das Skript schaut zuerst nach, ob überhaupt ein infinote-Server läuft und sichert dann bei Änderungen den aktuellen Stand ab:

#!/bin/sh

# check if an infinoted server is running

if [ ! "$(pidof infinoted)" ]; then

  exit 1

fi

# backup texts

cd  ~/.infinote-git

git add .

git commit -a -m "Scheduled commit `date +%Y-%m-%dT%H-%M-%S`"

Anschließend müssen wir das Skript noch ausführbar machen:

$ chmod 700 ~/.infinote-git/bin/infinote-git


Nun fügen wir das Skript noch zur crontab hinzu:

$ crontab -e

Die crontab-Zeile zum minütlichen Absichern sieht so aus:

*/1 * * * * `echo ~/`.infinote-git/bin/infinote-git > /dev/null 2>&1

Die Versionsgeschichte können wir beispielsweise mit qgit anschauen:

$ cd ~/.infinote-git

$ qgit

Dort beim ersten Start Whole history auswählen Show this dialog when opening a repository abwählen. Dann unten rechts die Datei anklicken und mit der rechten Maustaste View file (Strg+A) auswählen. Anschließend können mit den Pfeil hoch-/Pfeil runter-Tasten die verschiedenen Versionen angeschaut werden.

13) It's all about communication - Kontakt zum Autonomen Techkollektiv Freiburg 

Wenn ihr dieser Anleitung bis hier gefolgt seid, dann habt ihr einen Protokollserver, Protokollclients und eine Versionskontrolle installiert und konfiguriert. Ihr habt euren Rechner mit einer Firewall geschützt, nach offenen Ports gescannt und Zugänge per SSH-Tunnel freigeschaltet. Neben der Verbesserung der Kommunikation durch kollaboratives Schreiben soll diese Anleitung auch den Einstieg in die Systemadministration und Netzwerktechnik ermöglichen. Wir würden uns über Feedback freuen, ob und in welche Richtung die Reise eurer Meinung nach weitergehen sollte oder welche Teile genauer beschrieben werden sollten. Wenn ihr Fragen, Anregungen, Kritik oder gerne auch Feedback zu euren Erfahrungen mit den vorgestellten Techniken habt, dann schreibt doch einen Kommentar oder schickt uns eine Mail an atf at inventati dot org (GPG-Key).

Autonomes Techkollektiv Freiburg

März 2012