Installation of an etherpad on a local linux server

Darf man fragen, was Sie da machen? (Seyfried)

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


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: 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:


# 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
case "$1" in
    start | restart )
        if [ "$1" = "restart" ]; then
            # kill all input rules
            iptables -F INPUT
            ip6tables -F INPUT
        ### 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
        ### kill all input rules
        iptables -F INPUT
        ip6tables -F INPUT
        echo "Usage: $0 {start|stop|restart}"
        exit 1


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 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-


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 DateiZu Server verbinden kann die IP-Adresse des Protokollrechners eingetragen werden. Ein Client auf dem Protokollrechner selbst kann sich auf 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 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@ -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 "Your Name Comes Here"
$ git config

$ 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:




# check if an infinoted server is running

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

  exit 1



# 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

Zeige Kommentare: ausgeklappt | moderiert

Ich erachte es persönlich als sehr wichtig sich mit Sicherheitsinfrastruktur auseinander zu setzen und vertraut zu machen und habe dies in meinem privaten und politischen Umfeld auch schon getan. Euer Text ist für den technisch mittelmäßig begabten Aktivisten vielleicht noch ganz gut zu händeln, aber bei all den Fachbegriffen und Scripten werden sich leider auch viele wieder abschrecken lassen sich ernsthaft damit zu beschäftigen.


Es wäre richtig gut, wenn ihr als Technikkollektiv eine Art Komplettinstallation entwickeln könntet die alles mitbringt, so im Stil ISO runterladen, brennen, einlegen booten, klick, klick, Passwort für Verschlüsselung, klick, klick, läuft.


Darin gleich auch noch implementiert ein Firefox mit TOR, ein Thunderbird mit enigma Verschlüsselung. Ich bin zwar sehr sicher im Umgang mit Linux, aber nicht in der Erstellung solche Instalationsroutinen, aber da sollten sich doch sicherlich einige erfahrene Menschen finden lassen.

Das ganze dann zum kostenlosen Download als Komplett-Rund-Um-Sicher-Paket für alle Aktivistn und diese die es weden wollen.


Ansonsten erst einmal ganz, ganz großes Lob für den tollen Artikel! Werde demnächst mal Schritt für Schritt alles ausprobieren und Rückmeldung geben, ob es irgendwo hakt.

Ok I will try my comment in English:


Personally I think it is very important to take a look at security infrastructure and learn to handle it. I have done this in my personal an political periphery. Perhaps your text is good to unterstand for moderate trained activists and they can handle it, but all the tecnical terms and scripts will scare a lot of people to try it seriously.


It would be much better, if the tecnical collective build up a kind of all-in-one-installation-solution in proper style like download ISO, burn it, put in, boot, click, click, insert passwort for crypt, click, click, ready.


Also you could implement a Firefox with TOR node and Thundebird with enigma encryption. So I'm good trained with Linux but such a installation routine I can't program, but there are some people out there who can do that.