linksunten Archiv

Linux is becoming more popular among leftist activists for good reasons. But only few activists dare to use the command line for instance to install a firewall or set  up a server. We want to introduce you to system administration of linux by way of a practical example: collaboratively taking minutes in real time. On our way to a local infinote protocol server we will analyse the network with netstat, configure an iptables firewall and probe it with nmap, tunnel access through SSH and build a revision history with git.

• 01) We are working together not alone - On collaborative writing
• 02) Communication tools for liberatory social change - Online etherpad vs. local server
• 03) Linux. The choice of a GNU generation. - The choice of the operating system and the software
  
• 04) Some prerequisite are necessary - Hard disk encryption & password
• 05) Look, the servers are listening - Print local servers with netstat

  ---

• 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) We are working together not alone - On collaborative writing

It's common practice among groups of political activists to take minutes of their meetings. Some problems tend to occur over and over again: particularly at large meetings with lots of participants the minute taker is unable to keep up with the discussion, is unable to participate in the discussion or is at least unable to take minutes of his or her own statements. If multiple minute takers share the work they are not able to merge their minutes in real time and this leads to double work. Moreover, it's not possible to correct mistakes and fill in gaps in the minutes. If the minutes are going to be distributes electronically afterwards they are often created digitally in the first place. To solve or at least mitigate the mentioned problems it would be desirable that multiple persons can work on the same document at the same time. The technical term for this is: collaborative writing.

02) Communication tools for liberatory social change - Online etherpad vs. local server

A comfortable tool for collaborative writing are etherpads. For example the radical tech collective Riseup offers such a service: pad.riseup.net. Etherpads facilitate collaborative writing of plain text in real time and are suited very well for spontaneous collaborative writing. But the are two intrinsic problems: an internet connection is mandatory and the content is saved on a remote server. This articles describes how to use a local server for collaborative writing and how to protect the server with a firewall. If additionally a router is used or a local computer is configured to serve as a hotspot then there are no more obstacles to collaboratively take minutes of clandestine meetings in remote areas. Except for the insight that some things should better not be written down.

03) Linux. The choice of a GNU generation. - The choice of the operating system and the software

We'll describe the installation of the program infinoted which implements the infinote protocoll on the Debian based GNU/Linux operating system Xubuntu. Linux is quite close to our anarchist opinions and Xubuntu offers a good mixture of up-to-date software and fast security updates. We use Gobby as editor which is also available in a Macintosh and Windows flavour. An alternative to this approach could be the installation of a web server with an etherpad. Then the service could be used by any network capabable device with a browser. But we need encryption, of course. And to set up a web server with etherpad with https encryption is much more complicated and not as robust as an infinoted/Gobby solution with TLS encryption. Alternatively, we can set up our encryption through port forwarding via SSH as explained in the chapter Keeping your communiqués secret.

04) Some prerequisite are necessary - Hard disk encryption & passwords

If you follow this guide or if you decide to use our expirements as encouragement to set up a local minutes server then you should fortify that server not only against attacks from the internet but also against local attacks. It is vital that you encrypt your hard disk and that you choose a secure password with at least 16 characters. Sstarting with version 12.10 Xubuntu ships with hard disk encryption as a default option. With encryption in place you have to enter a password every time you boot the computer or your hard drive won't be readable. Additionally, you should keep your system up-to-date and understand the update system as a gift from people who have solved security problems for you instead of being annoyed as right now you really don't have time for this.

05) Look, the servers are listening - Print local servers with netstat

A server is a background program that provides a service. This service can be used by a different program, a client. The client can run either on the same computer or it can use the service over a network. The server provides its service on a port, i.e. it listens on  this port for requests of clients. You can use the tool netstat in a terminal to see which server listens on which port. (The symbol $ is part of the command prompt of the terminal and ought not be entered as part of the command. The command sudo [=superuser do] executes the following command with root permissions.)

$ sudo apt-get install net-tools


$ sudo netstat -lnptu


The output of the command admittedly looks a bit cryptic at first sight. A description of netstat can be found at the man page of the command. The german translation of the man page is much worse than the English original. Therefore, you should read the original man page:

$ LC_ALL=C man netstat

The output of netstat lists all ports on which a server listens. i.e. all open ports. All open ports on network interfaces which can be accessed from outside are potential entry points for hacking attacks. Basically, only trusted programs should listen on those kind of interfaces. You should know what those programs do and why they are executed. For this, you need a 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 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