Freifunk Lippe Gateway

Aus wiki.freifunk.net
Wechseln zu: Navigation, Suche

Freifunk Lippe nutzt die Firmware GLUON aus Norddeutschland und kann damit ein stabiles Netz bereitstellen. Dabei ist es wichtig, auf passend eingerichtete Gateways aufzusetzen. Die Vorgaben für die Einrichtung sind wie folgt zusammengefasst. Nach der Vorlage wurden bereits mehrere Gateway-Server aufgesetzt, so dass wir sicher versprechen können, dass es am Ende funktioniert :-)

Wir können uns kaum für das unglaubliche, was die Leute in Norddeutschland mit GLUON und der ffmap leisten, bedanken. Der Lohn dürfte sein, dass sich die Firmware sehr schnell verbreitet. Wir können uns auf die Software verlassen und die Entwickler sind immer offen und hilfsbereit und nehmen dazu auch noch jede guten Hinweise/Ideen auf. An dieser Stelle also auch ein GROßES DANKE!

Allgemeine Infos über die Freifunker der Region Lippe finden sich unter http://www.freifunk-lippe.de. Die jeweils aktuellen Images, die wir auf Basis von GLUON regelmäßig erstellen, stehen zum Download bereit http://update.freifunk-lippe.de.

Gateway aufsetzen

Hier müssen wir uns sehr bei den Freifunkern aus Gütersloh und Nordlippe bedanken, die mit viel Engagement, vielen Tipps, viel Geduld und noch mehr Unterstützung den Weg bereitet haben. Danke insbesondere dem Wusel42 :-)

Linux

Als erstes ist ein Rechner im Internet notwendig, der mit Linux vorbereitet ist. Wir verwenden derzeit Debian 7. Der Server sollte eine KVM sein, bei der man Module im Kernel nachladen kann. Ein Root-Server ohne Virtualisierung ist eher nicht sinnvoll. Da bietet sich die Umsetzung von VMs auf dem Root-Server an.

Paket Quellen

Um auf dem Linux die notwendige Software zu installieren, muss man die Paketquellen definieren. Insbesondere für GLUON sind Pakete notwendig, die im normalen Umfang bei Debian nicht dabei sind. Daher müssen wir hier direkt ansetzen und die erste Konfiguration durchführen.

Erst mal diese Quellen in die /etc/apt/source.list einfügen:

deb http://repo.universe-factory.net/debian/ sid main
deb http://download.opensuse.org/repositories/home:/fusselkater:/ffms/Debian_7.0/ /

Für die libjson-c2 wegen der Abhängigkeit von fastd >= 15 bitte noch diese Quelle aus dem Backport einbinden:

deb http://http.debian.net/debian wheezy-backports main

Für die GPG Schlüssel noch diese auf der Console als root ausführen, damit der apt nicht ständig meckert:

gpg --keyserver pgpkeys.mit.edu --recv-key 16EF3F64CB201D9C
gpg -a --export 16EF3F64CB201D9C | apt-key add -
wget http://download.opensuse.org/repositories/home:fusselkater:ffms/Debian_7.0/Release.key
apt-key add - < Release.key

So, jetzt kann es los gehen und die Pakete werden installiert. Zuvor bitte noch das Repository auf den aktuellen Stand bringen:

  apt-get update

Software installieren

Wir haben uns an Tipps gehalten, selbst einiges lernen müssen, diese Auflistungen immer wieder korrigiert. Aktuell steht die Empfehlung für folgenden Pakete zur installieren:

   ^ Paket              ^ Beschreibung
 | sudo               | Ausführung von Befehlen mit Root-Rechten |
 | bridge-utils       | Verwaltung von Netzwerkbrücken           |
 | batctl=2013.4.0-1  | B.A.T.M.A.N. Verwaltungstools            |
 | openvpn            | VPN für Verbindung zur Anonymisierung    |
 | haveged            | Entropie                                 |
 | fastd              | VPN für Verbindung zu den Knoten         |
 | radvd              | IPv6 Router Advertisements               |
 | isc-dhcp-server    | DHCP Server                              |
 | bind9              | DNS Server                               |
 | git                | Versionsverwaltungssystem                |
 | alfred             | ALFRED Datenübertragung - Version 2014.3 |
 | alfred-json        | ALFRED Datenausgabe                      |
 | batman-adv-dkms    | Batman-Kernelmodul - Version 2013.04     |
 | batman-vis         | Batman-Kernelmodul - Version 2013.04     |
 | ntp                | Zeitsynchronisation                      |
 | curl               | Linux Tool                               |
 | unp                | Linux Tool                               |
 | quilt              | Linux Tool                               |
 | debhelper          | Linux Tool                               |
 |                    |                                          |
 | nagios-nrpe-server | Statusüberwachung, wenn man das möchte   |

Die Installation erfolgt über die folgende Befehlszeile als root:

  apt-get install bridge-utils batctl=2013.4.0-1 openvpn haveged fastd radvd isc-dhcp-server bind9 git alfred-json batman-adv-dkms ntp curl unp quilt debhelper

Nun noch 'alfred 2014.3' und passend dazu 'batadv-vis 2014.3' installieren. Da das leider in der Version nicht im Repository enthalten ist, muss man es wie folgt aus den Sourcen ziehen, bauen und dann installieren:

 mkdir /fflip
 cd /fflip
 wget http://debian.draic.info/pool/main/a/alfred/alfred_2014.3.0.orig.tar.gz
 unp alfred_2014.3.0.orig.tar.gz
 cd alfred-2014.3.0/
 wget http://debian.draic.info/pool/main/a/alfred/alfred_2014.3.0-11.debian.tar.gz
 unp alfred_2014.3.0-11.debian.tar.gz
 mv alfred_2014.3.0-11.debian.tar.gz ../
 dpkg-buildpackage -b -us -uc -d
 cd ../
 dpkg -i alfred_2014.3.0-11_amd64.deb batadv-vis_2014.3.0-11_amd64.deb

Optionale Pakete

Die folgenden Pakete sollten auch direkt mit installiert werden, damit in der Anleitung später alles vorbereitet ist.

Optional für die Anbindung an das ICVPN:

  apt-get install tinc

Optional für die ffmap-Backend Umsetzung:

  apt-get install rrdtool python python3-pip nodejs nodejs-legacy

Optional:

  apt-get install nagios-nrpe-server

SSH einrichten

Für den Zugriff auf den Server sollte es einen User geben, der per SSH erreichbar ist. So kann man den Server besser konfigurieren und betreuen. Auf der Console als root folgende Befehle ausführen, damit ein neuer User für SSH angelegt wird:

  adduser --shell /bin/bash fflip

Das Zertifikat für SSH wird wie folgt erstellt:

  sudo -H -u fflip ssh-keygen -t rsa
  scp /home/fflip/.ssh/id_rsa.pub /home/fflip/.ssh/authorized_keys
  chmod 0644 /home/fflip/.ssh/authorized_keys

In der SSH Konfiguration /etc/ssh/sshd_config nun noch den User als erlaubter User eintragen:

  AllowUsers fflip

Nun SSH mit folgendem Befehl als root neu laden:

  service ssh reload

Konfiguration des Gateway

So jetzt wird's Erst ;-) Nach der kurzen Einleitung kommt jetzt die Kür ;-) Dieser Block ist der wichtigste und umfangreichste. Nehmt Euch genug Zeit und passt höllisch auf, damit Ihr keine Fehler macht. Das Fehlersuchen kann später zu echten Qual werden!

Die Software muss nun so konfiguriert werden, dass die Freifunk Router sich mit dem Gateway verbinden können und sich die Einstellungen ziehen, um die Clients ins Internet zu bringen. Jeder Client ist am Ende direkt mit dem Gateway verbunden. Der Router leitet "einfach nur" alles weiter. Der Router ist aber trotzdem noch eine wichtige Einheit, denn ohne den Router, wäre die Verbindung zum Gateway nicht möglich. Der Router sucht sich auch aus, mit welchem Gateway er sich verbindet und kann (wenn möglich) das Freifunknetz meshen. So lassen sich auch andere Router in das Netz bringen, die selbst keinen Internetanschluss haben. Hier liegt u.a. der Reiz der neueren Freifunknetze.

IP Forwarding

In der Konfigurationsdatei /etc/sysctl.d/forwarding.conf bitte die folgenden Zeilen eintragen, damit das IP Forwarding für IPv4 und IPv6 laufen:

  # IPv4 Forwarding
  net.ipv4.ip_forward=1
  
  # IPv6 Forwarding
  net.ipv6.conf.all.forwarding = 1


Netzwerk

Nun kommt das eigentlich wichtigste. Das Netzwerk muss eingerichtet werden, so das die einzelnen Schnittstellen bereitstehen und eine Art Brücke vom Freifunknetz in das Internet aufbauen.

Als erstes kommt die Netzwerkbrücke (Schnittstelle zwischen dem "Mesh" Netzwerk und dem Internet-Ausgang per VPN:

Hinweis: diese Konfiguration ist allgemeingültig für unser Netz. Daher ist das jeweilige Gateway in den IP-Adressen mit [GW Nr] geschrieben. Diese Nummer muss natürlich durchgängig gleich sein, da sonst nichts funktionieren wird!

Bitte die /etc/network/interfaces mit Folgenden Zeilen befüllen. Das eth0 sollte so belassen werden, wie es bereits eingerichtet war, damit die Netzwerkhardware auch weiterhin im Internet erreichbar ist:

  # The loopback network interface
  auto lo
  iface lo inet loopback
   
  # The primary network interface (here it's a local network)
  allow-hotplug eth0
  iface eth0 inet static
       address 192.168.1.100    # reine Bespieldaten!
       netmask 255.255.255.224  # Hier bitte das vom
       network 192.168.1.0      # Server-Hoster übernehmen !
       gateway 192.168.1.1      # Sonst geht nix mehr :-(
       dns-nameservers 10.138.[GW-Nr].1 85.214.20.141 213.73.91.35 
  
  # Netwerkbruecke fuer Freifunk 
  # - Hier laeuft der Traffic von den einzelnen Routern und dem externen VPN zusammen 
  # - Unter der hier konfigurierten IP ist der Server selber im Freifunk Netz erreichbar 
  # - bridge_ports none sorgt dafuer, dass die Bruecke auch ohne Interface erstellt wird
  
  auto br-fflip
  iface br-fflip inet static
       address 10.138.[GW Nr].1
       netmask 255.255.0.0
       bridge_ports none 
  
  iface br-fflip inet6 static
       address fe42:ffee:ff42::1[GW Nr]
       netmask 64
       
       post-up /sbin/ip -6 addr add fe42:ffee:ff42::1[GW Nr]/64 dev br-fflip
       post-up /sbin/ip rule add iif br-fflip table 42
       pre-down /sbin/ip -6 addr del fe42:ffee:ff42::1[GW Nr]/64 dev br-fflip
       pre-down /sbin/ip rule del iif br-fflip table 42   
  
  # Batman Interface 
  # - Erstellt das virtuelle Inteface fuer das Batman-Modul und bindet dieses an die Netzwerkbruecke 
  # - Die unten angelegte Routing-Tabelle wird spaeter fuer das Routing innerhalb von Freifunk (Router/VPN) verwendet 
  #
  # Bevor das Netzwerkinterface gestartet wird, wird zur Sicherheit nochmal batman-adv geladen.
  # Nachdem das Interface gestartet ist, wird eine IP-Regel angelegt, die besagt, dass alle Pakete, die über das bat0-Interface eingehen,
  # und mit 0x1 markiert sind, über die Routing-Tabelle 42 geleitet werden. 
  # Dies ist wichtig, damit die Pakete aus dem Mesh wirklich über das VPN raus gehen.
  #
  # Es wird alfred und batadv-vis gestartet. Damit können Daten für die Knotenkarte gesammelt werden.
  
  allow-hotplug bat0
  iface bat0 inet6 manual
       pre-up modprobe batman-adv
       pre-up batctl if add fflip-mesh
       
       post-up ip link set dev bat0 up
       post-up brctl addif br-fflip bat0
       post-up batctl it 10000
       post-up ip rule add from all fwmark 0x1 table 42
  
       pre-down brctl delif br-fflip bat0 || true
       down ip link set dev bat0 down
               
       post-up start-stop-daemon -b --start --exec /usr/sbin/alfred -- -i br-fflip -b bat0; # -m; # -m steht für den FFMAP-Master, Clients bitte ohne -m / nur wenn ein Master notwendig ist -m setzen!!
       post-up start-stop-daemon -b --start --exec /usr/sbin/batadv-vis -- -i bat0 -s;


Die /etc/hosts mit Folgenden Zeilen befüllen:

  127.0.0.1                localhost
  [externe IP]             fflip-gw0[GW Nr]                    fflip-gw0[GW Nr]
  [externe IP]             gw0[GW Nr].freifunk-lippe.de        fflip-gw0[GW Nr]
  10.138.[GW Nr].1         fflip
  fe42:ffee:ff42::1[GW Nr] fflip

Die /etc/hosts mit Folgenden Zeilen befüllen:

  fflip-gw0[GW Nr]

IP Tables

Lege die Konfigurationsdatei /etc/iptables.up.rules an mit Folgendem:

 # Damit werden alle Pakete, die über die Bridge rein kommen, mit dem 0x1-Flag markiert, und damit über Routing-Tabelle 42 geschickt.
 # Es gibt noch 2 Regeln für DNS, dass auch DNS-Pakete (Port 53 TCP/UDP) über die Tabelle 42 geschickt werden.
 
 *filter
 :INPUT ACCEPT [0:0]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [0:0]
 COMMIT
 *mangle
 :PREROUTING ACCEPT [0:0]
 :INPUT ACCEPT [0:0]
 :FORWARD ACCEPT [0:0]
 :OUTPUT ACCEPT [0:0]
 :POSTROUTING ACCEPT [0:0]
 COMMIT
 *nat
 :PREROUTING ACCEPT [0:0]
 :INPUT ACCEPT [0:0]
 :OUTPUT ACCEPT [0:0]
 :POSTROUTING ACCEPT [0:0]
 COMMIT

Nun müssen die IP Tables geladen werden. Bitte erstellt die Datei /etc/network/if-pre-up.d/iptables mit folgenden Zeilen:

 #!/bin/sh
 /sbin/iptables-restore < /etc/iptables.up.rules

Bitte nun noch eine Datei /etc/fastd/fflip/iptables_fflip.sh erstellen, die alle Routing iptables Vorgaben enthält:

 #!/bin/sh
 /sbin/ip route add default via [EXTERNE-IPv4] table 42
 /sbin/ip route add 10.138.0.0/16 dev br-fflip src 10.138.[GW-Nr].1 table 42
 #/sbin/ip route add 0/1 dev tun0 table 42 # nur bei OpenVPN-Exit auskommentieren!
 # /sbin/ip route add 128/1 dev tun0 table 42 # nur bei OpenVPN-Exit auskommentieren!
 /sbin/ip route del default via [EXTERNE-IPv4] table 42
 /sbin/iptables -t nat -I POSTROUTING -s 0/0 -d 0/0 -j MASQUERADE
 # /sbin/iptables -t nat -D POSTROUTING -s 0/0 -d 0/0 -o tun0 -j MASQUERADE # nur bei OpenVPN-Exit auskommentieren!
 /sbin/iptables -t mangle -I PREROUTING -s 10.138.0.0/16 -j MARK --set-mark 0x1
 /sbin/iptables -t mangle -I OUTPUT -s 10.138.0.0/16 -j MARK --set-mark 0x1

Jetzt müssen die für Linux ausführbar werden. Dazu dies als root auf der Konsole eingeben:

 chmod +x /etc/network/if-pre-up.d/iptables
 chmod +x /etc/fastd/fflip/iptables_fflip.sh
 
 iptables-restore < /etc/iptables.up.rules

VPN

Achtung: Kopiere bitte nicht die Konfigurationsdateien von einem Gateway auf andere Gateways!

Für das VPN werden diese Dateien benötigt, die alle nach /etc/openvpn/ müssen:

 ca.crt
 crl.pem
 mullvad.crt
 mullvad.key
 mullvad_linux.conf

Die Datei mullvad_linux.conf muss noch um folgende Zeilen am Ende ergänzt werden:

 #custom 
 route-noexec
 up /etc/openvpn/mullvad_up.sh
 up /etc/fastd/fflip/iptables_fflip.sh

Mullvad hat an seinen Konfigurationen seit mehreren Sicherheitslücken bei OpenVPN und Snowden/NSA geändert. Es kann sein, dass ein Fehler zur Cipher-Liste angezeigt wird. Dann muss in der mullvad_linux.conf die Zeile zur TLS-Verschlüsselung beginnend tls-cipher auskommentiert werden. Wenn kein IPv6 am Server ins Internet möglich ist, kann auch tun-ipv6 auskommentiert werden.


Die Datei /etc/openvpn/mullvad_up.sh gibt es noch nicht.Also bitte die Datei mit folgenden Zeilen anlegen:

 #!/bin/sh
 ip route replace 0.0.0.0/1 via $5 table 42
 ip route replace 128.0.0.0/1 via $5 table 42
 
 service dnsmaq restart
 exit 0

Diese Datei muss nun auch als root ausführbar gemacht werden:

 chmod +x /etc/openvpn/mullvad_up.sh

Damit Linux auch diese VPN-Schnittstelle kennt, muss tun in der Datei /etc/modules bekannt gemacht werden. OpenVPN benötigt ein tun-Interface. Trage einfach in eine eigene neue Zeile dies ein

  tun

Bitte nun als root über die Konsole tun aktivieren und den VPN starten mit:

  modprobe tun
  
  service openvpn start

VPN-Connect regelmäßig überprüfen

Es ist sinnvoll regelmäßig zu prüfen, ob die VPN Verbindung noch aktiv ist. Dazu wird ein Script auf dem Server abgelegt, dass dann über den CRON immer neu den VPN-Connect prüft.

Script /fflip/check-vpn.sh

 #!/bin/bash
 
 # Test gateway is connected to VPN
 test=$(ping -q -I tun0 8.8.8.8 -c 4 -i 1 -W 5 | grep 100 )
 
 if [ "$test" != "" ]
  then
    echo "VPN nicht da - Neustart!"
    service openvpn restart      # Fehler - VPN nicht da - Neustart
  else
    echo "alles gut"
 fi


Dann noch das Script ausführbar machen:

 chmod ug+x /fflip/check-vpn.sh

Danach in die Datei /etc/crontab das Skript alle 10 Minute auszuführen und damit regelmäßig der VPN-Status geprüft wird.

 # Check VPN via openvpn is running, if not service restart
 */10 * * * * root /fflip/check-vpn.sh > /dev/null

Die Änderungen übernehmen durch einen Neustart des Cron-Dämonen:

 service cron restart

Mesh - fastd

Wir brauchen für den neuen Server die Schlüssel für fastd. fastd ist im Grunde ein VPN und der sichert die Leitung zwischen Router und Gateway ab, daher die Notwendigkeit des Schlüsselpaars

Als root dies eingeben und mit der Maus etwas rumwackeln, damit die Schlüssel etwas sicherer werden :-)

 fastd --generate-key

Nun werden die beiden Schlüssel angezeigt. Bitte diese herauskopieren und irgendwo ablegen, die werden später noch benötigt! Im Folgenden wird der sichere private Schlüssel als [SERVER-SECRET-KEY] aufgeführt und müssen durch die erzeugten Schlüssel sinnvoll ersetzt werden! Den öffentlichen Schlüssel bitte aufheben. Der wird bei der Erstellung der Firmware benötigt, damit die Router dann auch den neuen Gateway kennen!

Bitte als root zwei neue Verzeichnisse anlegen. Dort werden die Schlüssel für das Freifunknetz hinterlegt, damit Gateway und Router später zusammenfinden können:

  mkdir /fflip  (wenn noch nicht durch den Schritt weiter oben angelegt)
  mkdir /fflip/gateway-fflip/peers
  mkdir /fflip/gateway-fflip/gateways

Es ist eine Konfigurationsdatei für fastd notwendig. In der folgenden Konfiguration bitte die [EXTERNE-IPv4] durch die echte IP vom Server ersetzen. Wenn es auch eine IPv6 gibt, kann die entsprechende Zeile aktiviert werden und benötigt die echte IPv6 [EXTERNE-IPv6]. Die Konfigurationsdatei /etc/fastd/fflip/fastd.conf soll bitte diese Zeilen enthalten:


  # Bind to a fixed address and port, IPv4 and IPv6 at Port 1234
  # bind [EXTERNE-IPv6]:1234 interface "eth0"; # wenn IPv6, aber dann muss noch weit mehr angepasst werden!
  bind [EXTERNE-IPv4]:1234 interface "eth0";
  
  # Set the user, fastd will work as
  user "nobody";
  
  # Set the interface name
  interface "fflip-mesh";
  
  # Set the mode, the interface will work as
  mode tap;
  
  # Set the mtu of the interface (salsa2012 with ipv6 will need 1406)
  mtu 1406;
  
  # Set the methods (aes128-gcm preferred, salsa2012+umac preferred for nodes)
  method "salsa2012+umac"; # aktuelle Verschlüsselung für optimale Performance
  
  #hide ip addresses yes; # aktivieren, wenn keine Log-Daten auf dem Server liegen sollen
  #hide mac addresses yes:
  
  # Secret key generated by `fastd --generate-key`
  secret "[SERVER-SECRET-KEY]";
  
  # Log everything to syslog
  log to syslog level debug;
  
  # Include peers from our git-repos
  include peers from "/fflip/gateway-fflip/peers/";
  include peers from "/fflip/gateway-fflip/gateways/";
  
  # Configure a shell command that is run on connection attempts by unknown peers (true means, all attempts are accepted)
  on verify "true";
  # on verify "/etc/fastd/fastd-blacklist.sh $PEER_KEY";
  
  # Configure a shell command that is run when fastd comes up
  on up "
    ip link set dev $INTERFACE address de:42:42:42:42:0[GW Nr]
    ip link set dev $INTERFACE up
    ifup bat0
    batctl if add $INTERFACE
    batctl gw server 54 Mbit/ 54 Mbit
    batctl vm server
    sh /etc/fastd/fflip/iptables_fflip.sh
  ";

Nun sollten in das /fflip/gateway-fflip/gateways/ Verzeichnis auch alle Gateways hinterlegt werden. Die Datei sollte einfach benannt werden. Für unser Gateway 01 wäre es gw01. Die Datei muss den public-Key des jeweiligen Gateway haben und die öffentliche IP-Adresse für den fastd Remote Zugriff. Damit ergibt sich folgender Inhalt:

 key "[SERVER-PUBLIC-KEY]";
 remote [EXTERNE-IPv4]:1234;

Das Beste ist, wenn man nun dier fastd-Konfiguration mal überprüft. Vorher muss der Server rebootet werden, damit die vorher durchgeführten Anpassungen auch Wirkung zeigen :-)

Dann als root auf der Konsole mit folgender Zeile die fastd Einstellungen prüfen:

 fastd -c /etc/fastd/fflip/fastd.conf

Wenn das erfolgreich war, kann nun fastd gestartet werden, auch wieder als root mit:

 service fastd start

Wichtig: In der Konfiguration wird jeder Router reingelassen. Das mag nicht jeder, aber es vereinfacht die Integration der Router und damit auch die Verteilung. Wenn man das nicht möchte, müsste jeder Router separat mit seinem öffentlichen Schlüssel unter '.../peers/ hinterlegt werden. Auskommentiert ist eine Zeile bei on verify die eine Blacklist führt. Damit kann man unliebsame Genossen aussperren. Wenn man das haben möchte, so ist eine Datei /etc/fastd/fastd-blacklist.sh zu erstellen mit folgenden Zeilen und dann auch ausführbar zu machen:

  #!/bin/bash
  PEER_KEY=$1
  if /bin/grep -Fq $PEER_KEY /etc/fastd/fastd-blacklist.json; then
       exit 1
  else
       exit 0
  fi

Wie die weiteren Dateien mit der Blacklist aussehen, findet man unter diesem Link https://github.com/ffruhr/fastdbl

DHCP

DHCP radvd IPv6

Es wird für IPv6 die Konfigurationsdatei /etc/radvd.conf mit folgenden Zeilen benötigt:

 interface br-fflip {
   AdvSendAdvert on;
   IgnoreIfMissing on;
   AdvManagedFlag off;
   AdvOtherConfigFlag on;
   MaxRtrAdvInterval 200;
   AdvLinkMTU 1280;
   prefix fe42:ffee:ff42::/64 {
               AdvOnLink on;
               AdvAutonomous on;
               AdvRouterAddr on;
   };
 
   RDNSS fe42:ffee:ff42::1[GW Nr] {
   };
 };

Jetzt kann radvd als root auf der Konsole gestartet werden:

 service radvd restart

DHCP isc-dhcp-server IPv4 und IPv6

Die Konfigurationsdatei /etc/dhcp/dhcpd.conf wird für IPv4 mit folgenden Zeilen benötigt:

   ddns-update-style none;
   option domain-name ".fflip";
   
   # möglichst kurze Leasetime
   default-lease-time 120;
   max-lease-time 600;
   
   log-facility local7;
   
   subnet 10.138.0.0 netmask 255.255.0.0 {
     authoritative;
     range 10.138.[GW Nr]0.1 10.138.[GW Nr]2.254;
   
     option routers 10.138.[GW Nr].1;
     
     option domain-name-servers 10.138.[GW Nr].1; # für die eigenen DNS-Einträge
     # option domain-name-servers 85.214.20.141; # weitere anonyme DNS
     # option domain-name-servers 213.73.91.35;
   }
   
   include "/etc/dhcp/static.conf";

Bitte eine leere Datei /etc/dhcp/static.conf erzeugen. Da kann später mal was rein.

Und jetzt noch die Konfigurationsdatei /etc/dhcp/dhcpd6.conf wird für IPv6 mit folgenden Zeilen definiert:

 subnet6 fe42:ffee:ff42::/64 {
   option dhcp6.name-servers fe42:ffee:ff42::1[GW-Nr];
 }

Auf dem DHCP-Server muss noch das Bridge-Interface für IPv4 festgelegt werden. Bitte die Datei /etc/default/isc-dhcp-server mit folgender Option ergänzen:

   # On what interfaces should the DHCP server (dhcpd) serve DHCP requests?
   # Separate multiple interfaces with spaces, e.g. "eth0 eth1".
   INTERFACES="br-fflip"

Und dann noch das Bridge-Interface für IPv6. Bitte die Datei /etc/default/isc-dhcp6-server mit folgender Option ergänzen:

   # On what interfaces should the DHCP server (dhcpd) serve DHCP requests?
   # Separate multiple interfaces with spaces, e.g. "eth0 eth1".
   INTERFACES="br-fflip"

Am Besten wird der DHCP-Server vor dem Start und Betrieb noch mal geprüft. Bitte vorher den Server rebooten und dann auf der Konsole als root folgende Zeile ausführen:

  dhcpd -f -d

War das erfolgreich, so kann der DHCP-Server als root gestartet werden:

  service isc-dhcp-server restart

WebServer

Damit man auch den Gateway im Browser sehen und aufrufen kann, benötigt man einen WebServer. Dieser kann dann auch für den Autoupdater die Images zum Download anbieten. Man kann aber auch Infos zum Gateway oder Werbematerial hinterlegen. Aber auch wichtig ist der WebServer, damit man die Karte zum Freifunk Netz zeigen kann (ALFRED).

Lighttpd ist ein schlanker Server, er alles kann, was wir hier brauchen. So den WerbServer installierten:

 apt-get update
 apt-get install lighttpd

Dann in der Konfiguration lighttpd.conf die jeweiligen Websites hinterlegen. Natürlich entsprechende Pfade auch auf dem Server einrichten und mit Inhalt bestücken.

  server.modules = (
       "mod_access",
       "mod_alias",
       "mod_compress",
       "mod_redirect",
  )
  
  server.document-root        = "/www/html"
  server.pid-file             = "/var/run/lighttpd.pid"
  server.username             = "www-data"
  server.groupname            = "www-data"
  server.port                 = 80
  
  index-file.names            = ( "index.php", "index.html", "index.ff" )
  
  compress.cache-dir          = "/var/cache/lighttpd/compress/"
  compress.filetype           = ( "application/javascript", "text/css", "text/html", "text/plain" )
  include_shell "/usr/share/lighttpd/use-ipv6.pl " + server.port
  include_shell "/usr/share/lighttpd/create-mime.assign.pl"
  include_shell "/usr/share/lighttpd/include-conf-enabled.pl"
  
  ### fflip html ###
  $HTTP["host"] =~ "vpn\.freifunk-lippe\.de$" {
       server.document-root = "/www/html"
       server.error-handler-404 = "/e404.html"
  }
  
  ### fflip update ###
  $HTTP["host"] =~ "update\.freifunk-lippe\.de$" {
       server.document-root = "/www/update"
       server.error-handler-404 = "/e404.html"
  }
  
  ### fflip ffmap ###
  $HTTP["host"] =~ "map\.freifunk-lippe\.de$" {
       server.document-root = "/fflip/ffmap-d3/build/"
       server.error-handler-404 = "/e404.html"
  }

SSL Zertifikat für den WebServer erstellen.

 cd /etc/lighttpd
 openssl req -x509 -nodes -days 3650 -newkey rsa:4096 -keyout privateKey.key -out ca.crt
 openssl x509 -in ca.crt -out ca.pem -outform PEM
 openssl req -new -x509 -newkey rsa:4096 -keyout server.pem -out lighttpd.pem -days 3650 -nodes
 chmod 400 server.pem

Pfade für den WebServer auf dem Server anlegen:

 mkdir /www
 mkdir /www/html
 mkdir /www/
 mkdir /www/update/
 mkdir /www/update/stable
 mkdir /www/update/experimental
 

WebServer starten:

 service lighttpd restart

DNS-Server (BIND)

Für das interne Freifunknetz ist nun noch der DNS-Server bind9 mit den Konfigurationsdateien wie folgt zu konfigurieren:

Erstmal diese Datei /etc/bind/named.conf.options

  options {
       directory "/var/cache/bind";
       
       // If there is a firewall between you and nameservers you want
       // to talk to, you may need to fix the firewall to allow multiple
       // ports to talk.  See http://www.kb.cert.org/vuls/id/800113
       
       // If your ISP provided one or more IP addresses for stable 
       // nameservers, you probably want to use them as forwarders.  
       // Uncomment the following block, and insert the addresses replacing 
       // the all-0's placeholder.
       
       // Zugriff auf anonyme DNS Server zum Laden von existierenden DNS Einträgen im Internet
       forwarders {
               85.214.20.141;
               213.73.91.35;
       };
       
       //========================================================================
       // If BIND logs error messages about the root key being expired,
       // you will need to update your keys.  See https://www.isc.org/bind-keys
       //========================================================================
       dnssec-enable yes;
       dnssec-validation yes;
       dnssec-lookaside auto;
       
       recursion yes;
       allow-recursion { localnets; localhost; };
       
       auth-nxdomain no;    # conform to RFC1035
       listen-on-v6 { any; };
   };

Dann in der Datei /etc/bind/named.conf.default-zones folgendes am Ende ergänzen:

  zone "fflip" {
       type master;
       file "/etc/bind/db.fflip";
  };


Und diese Datei /etc/bind/named.conf.local

  // Do any local configuration here
  // Consider adding the 1918 zones here, if they are not used in your organization
  
  include "/etc/bind/zones.rfc1918";


Nun die db.fflip Datei mit Inhalt füllen:

 ;
 ; BIND data file for local loopback interface
 ;
 $TTL    604800
 @       IN      SOA     fflip. root.fflip. (
                               6         ; Serial
                          604800         ; Refresh
                           86400         ; Retry
                         2419200         ; Expire
                          604800 )       ; Negative Cache TTL
 ;
 @       IN      NS      fflip.
 @       IN      A       10.138.[GW Nr].1
 @       IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; Update
 update                  IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; Update Service
 update.services         IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; Mumble
 mumble                  IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; NTP
 ntp                     IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; NTP Service
 ntp.services            IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; FF Map
 map                     IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]
 
 ;; FF Map1
 map1                    IN      A       10.138.[GW Nr].1
                         IN      AAAA    fe42:ffee:ff42::1[GW Nr]


Mit den Dateien kann bind9 als root über die Konsole gestartet werden:

 service bind9 restart

InterCity VPNs

Das InterCity-VPN wird über Tinc aufgebaut. Das IC-VPN verbindet viele Freifunk-Netzwerke zu einem eigenen "parallelen" Internet. Dort gibt es zahlreiche Dienste und man kann sich z.B. über das Netzwerk eMails schicken, ohne dass diese über das "normale" Internet laufen müssen. Eine Dokumentation ist im Freifunk Wiki verfügbar.

Die Konfiguration der Verbindungspartner ist in dem Git Repo hinterlegt. Hier muss jeweils der neue Server eingetragen werden.

Dann das Repo auf den lokalen Server holen:

 cd /var 
 git clone https://github.com/freifunk/icvpn

Dann das Verzeichnis /etc/tinc/icvpn erstellen:

 mkdir /etc/tinc/icvpn
 ln /var/icvpn/hosts /etc/tinc/icvpn/hosts -s

Nun werden noch die Schlüssel für den neuen Server erzeugt. Die Dateien müssen in dem Verzeichnis /etc/tinc/icvpn abgelegt werden.

 cd /etc/tinc/icvpn
 tinc generate-keys

Jetzt folgt die Konfiguration in /etc/tinc/icvpn/tinc.conf:

 Name = lippe[GW Nr]
 PrivateKeyFile = /etc/tinc/icvpn/rsa_key.priv
 Mode = Switch
 PingTimeout = 30
 Port = 656
 Hostnames = yes 

In dem Verzeichnis muss auch ein Script /etc/tinc/icvpn/tinc-up angelegt werden. Die IP Adresse innerhalb des VPNs ist für den Server in der Liste [[1]] einzutrage:.

 #!/bin/sh
 /sbin/ip link set dev $INTERFACE up
 /sbin/ip addr add dev $INTERFACE 10.207.X.Y/16 broadcast 10.207.255.255 scope link
 /sbin/ip -6 addr add dev $INTERFACE fec0::a:cf:X:Y/96 preferred_lft 0

In der Datei /etc/tinc/nets.boot wird noch ergänzt, dass Tinc automatisch gestartet wird:

 icvpn

NRPE Überwachung

Wenn man mehrere Gateways hat, können diese von einem zentralen Nagios Server überwacht werden.

Dafür ist die Konfigurationsdatei /etc/nagios/nrpe.cfg mit folgenden Zeilen anzupassen:


 allowed_hosts=10.138.0.[GW Nr]
 include_dir=/var/gateway-fflip/nrpe/


Der NRPE-Daemon benötigt Berechtigungen die in der /etc/sudoers:

 nagios  ALL=NOPASSWD: /usr/sbin/batctl

Sync Thing (OpenSource Sync Tool)

Um Dateien dezentral und ohne einen zentralen Server mittels P-2-P zu verteilen, bietet sich dieses Tool an.

Folgende Zeilen als root eingeben und das Tool wird installiert und aktualisiert sich dann:

  curl -s https://syncthing.net/release-key.txt | apt-key add -
  echo deb http://apt.syncthing.net/ syncthing release | tee /etc/apt/sources.list.d/syncthing-release.list
  apt-get update
  apt-get install syncthing


FFmap Einrichten

Die FFmap visualisiert die Freifunk Router. So hat man visuell einen Überblick über die Infrastruktur. WICHTIG: dies darf nicht als ROOT sondern muss als lokaler User fflip erfolgen:

FFmap meshviewer Frontend und Backend (neue Version)

WICHTIG: die folgenden Eingaben auf der Console müssen unter dem User fflip erfolgen!

Es werden laufende batctl, alfred-json und batadv-vis benötigt. Als Basis für das Frondend muss Folgendes installiert werden. Wer sein FFmap-3d aktualisiert, muss npm nicht neu installieren.

 cd /fflip
 sudo su -c "gem install sass"
 curl -L --insecure https://www.npmjs.org/install.sh | bash
 pip install git://github.com/networkx/networkx.git#egg=networkx
 pip-3.2 install networkx

Nun können die Sourcen für den meshviewer heruntergeladen werden:

git clone https://github.com/ffnord/ffmap-backend.git
cd ffmap-backend
git checkout v2
cd ..
git clone https://github.com/tcatm/meshviewer.git

Dann in das Verzeichnis und mit folgenden Befehlszeilen die notwendige Installation abschließen:

 cd meshviewer
 npm install
 npm install bower grunt-cli
 node_modules/.bin/bower install --allow-root
 
 node_modules/.bin/grunt --force

Die letzte Zeile installiert die Basis für das Frondend. Es dürfen keine Fehler angezeigt werden. Wenn 'ERR angezeigt wird, wurden vermutlich die Zeilen als root eingegeben. Wenn das der Fall war, dann bitte die Verzeichnisse komplett löschen und dann unter dem User fflip erneut Schritt für Schritt durchlaufen.

Nun bitte noch die Konfiguration für die Region Lippe vornehmen. Dazu kopiere config.js.example in config.js und passe die Parameter an. Am Ende sieht die Datei so aus:

 define({
   "dataPath": "http://map.freifunk-lippe/data/",
   "siteName": "Freifunk Lippe",
   "mapSigmaScale": 0.5,
   "showContact": false,
   "maxAge": 14
 })

Nun abschließend die Installation fertigstellen, dass die relevanten Dateien in dem Verzeichnis build liegen. Darauf muss dann der WebServer als map-Verzeichnis (map.freifunk-lippe.de) beim Aufruf zeigen. So können dort dann auch über den Cronjob die eingesammelten Daten in der Mesh-View abgerufen werden.

Das Script backend.py für die Zusammensammlung der Daten hat einen Parameter, der die Ausgabe steuert: -d output. Dies ist wichtig für das Frontend, welches diese Daten an einem bestimmten Ort für die Darstellung benötigt. Das Backend-Script kann über die Hilfe auch alle weiteren Parameter anzeigen ( backend.py --help ).

Mit der folgenden Zeile im Crontab werden dann die Daten regelmäßig autom. bereitgestellt:

 */5 *   * * *    root   cd /fflip/ffmap-backend && ./backend.py -d /fflip/meshviewer/data/ -a aliases.json --vpn ae:7f:58:7d:6c:2a

FFmap3D Frontend (veraltet -> wird nicht mehr genutzt und weiterentwickelt)

Das Original Frontend liegt hier: https://github.com/ffnord/ffmap-d3 und von dort holen wir es uns in das Verzeichnis /fflip/

cd /fflip
wget https://github.com/ffnord/ffmap-d3/archive/deprecated.zip
unzip deprecated.zip

Nun werden die Sourcen für die Map in ein separates Verzeichnis ffmap-d3 heruntergeladen. Es sind jetzt 2 Konfigurationsdateien anzupassen:

1. Bei dieser Konfiguration ffmap-d3/config.js folgende Zeile anpassen:

 sitename:  "lippe.freifunk.net",

2. Bei dieser Konfiguration ffmap-d3/config.json folgende Zeilen anpassen:

 {
  "cityname": "Freifunk Lippe",
  "sitename": "lippe.freifunk.net",
  "url": "http://www.freifunk-lippe.de"
 }

Nun muss noch Zubehör installiert werden. Dazu bitte folgende Zeilen auf der Konsole als root eingeben:

 cd ffmap-d3
 curl -sL https://deb.nodesource.com/setup | bash -
 npm install -g grunt-cli bower
 npm install
 bower install --allow-root
 grunt

Bei den einzelnen Comandozeilen sollten längere Ausgaben folgen, doch immer ohne Fehlermeldungen. Nach dem letzten Comando sollte ein Done, without errors. angezeigt werden. Das ist ein Zeichen, es hat alles funktioniert, der Kram ist installiert.

Jetzt muss noch der Webserver angepaßt werden, damit das Frontend für die FFmap auch im Internet abrufbar ist. Für den Apapche ist in der Konfigurationsdatei /etc/apache2/sites-enabled/000-default diese eine Zeile einzufügen:

 Alias /map /fflip/ffmap-d3/build

So sieht es am Ende so aus:

 [...]  
      Alias /map /fflip/ffmap-d3/build
 </VirtualHost>


Statt dieser vorgenannten einfachen Lösung, kann man aber auch eine eigene Datei /etc/apache2/sites-enable/000-ffmap erstellen, die auf das Verzeichnis /fflip/ffmap-d3/build/ verweist. Damit ist dann der Aufruf über eine passende Subdomain map.freifunk-lippe.de realisierbar. Bitte nicht vergessen, den Webserver neu zu starten, damit die geänderte Konfiguration auch gezogen wird.

FFmap Backend (veraltet -> Beschreibung für das veraltete Frontend D3)

Das Backend hat nun die Aufgabe die Daten der Router/Clients für die Karte zu besorgen.

Zunächst installieren wir das Backend. Derzeit ist Version vom Freifunk Mainz gut vorbereitet. Diese Version holen wir jetzt in unser Verzeichnis /fflip/:

 cd /fflip
 wget https://github.com/ffnord/ffmap-backend/archive/v1.zip
 unzip v1.zip

Nun muss noch Zubehör installiert werden:

 cd ffmap-backend
 pip-3.2 install photon_core
 git clone https://github.com/spookey/photon.git
 cd photon/
 python3 setup.py install

Für das Aktivieren von ALFRED zum Daten holen, folgende Kommandos eingeben:

 alfred-json -z -r 158
 alfred-json -z -r 159
 batadv-vis -i bat0 -f json
 batctl -m bat0 gwl -n
 batctl -m bat0 gw

Die Aliases-Datei ist wichtig. Aus ihr geht hervor welche der Router/Clients am Gateway hängen. Ohne das sieht die Karte leer bzw. falsch aus Daher in der Datei /fflip/ffmap-backend/aliases.json folgendes hinterlegen:

 {
  "de:42:42:42:42:01" : {
     "name" : "=GW01=",
     "vpn" : true,
     "firmware" : "Debian",
     "hardware" : "x86"
    },
  "de:42:42:42:42:02" : {
     "name" : "=GW02=",
     "vpn" : true,
     "firmware" : "Debian",
     "hardware" : "x86"
   }
  "de:42:42:42:42:03" : {
     "name" : "=GW03=",
     "vpn" : true,
     "firmware" : "Debian",
     "hardware" : "x86"
   }
 }

Die Angabe für die jeweiligen Gateways ist die MAC Adresse des fflip-mesh Netzwerks. In dieser Konfiguration ist es immer die MAC de:42:42:42:42:0[GW Nr].

Der Cron Job für die Automatisierung noch in der Datei /etc/crontab einrichten, der die Karte regelmäßig alle 5 Minuten aktualisiert:

 */5 * * * * root cd /fflip/ffmap-backend && ./bat2nodes.py -a aliases.json -m bat0 -d /fflip/ffmap-d3/build/

Drücken wir die Daumen! Nun sollte es laufen :-) ...oder auch nicht. Das ffmap-Projekt entwickelt sich schnell weiter, da kommen wir mit der Anpassung dieser Beschreibung kaum hinterher.

Testen ! Server, Routing, etc

Bevor das Gateway jetzt ins produktive Netz eingebunden werden soll, ist ein Testen der Konfiguration absolut sinnvoll :-)

Reboot

Als erstes sollte ein reboot die Probe sein, ob mit der Konfiguration der Server überhaupt wieder hoch kommt. So wurden dann auch alle Einstellungen gezogen.

Grundsätzliches

Man schaue sich auf jeden Fall die Interfaces, Namensauflösung und Routings an, ob die passen. Dazu kann man das mit diesen Befehlen prüfen:

 ifconfig
 ping ccc.de
 nslookup ccc.de
 nslookup map.fflip
 ping -q -I tun0 8.8.8.8
 route -n
 ip route show
 ip route show table 42
 ip rule show
 iptables -L -v -n -t mangle
 iptables -L -v -n -t nat

ffmap Framework

Wichtig für die Knotendaten in einer Map (ffmap-Framework) ist, dass die korrekten Versionen für batman-adv (2013.4.0) und batctl (2013.4.0) laufen. Daher mit folgenden Befehlen die Versionen prüfen.

 cat /sys/module/batman_adv/version
 batctl -v
 batadv-vis -v

Bandbreite prüfen

Wer mal die Bandbreite gerade bei einem gemiedeten Server prüfen möchte, kann das recht einfach mit wget machen. Einfach folgenden Test mit 100 MB durchführen und in der Zusammenfassung sieht man die max. Bandbreite für den Download. Dies ist schon mal ein guter Indikator. Der Werte sollte in jedem Fall größer 5 M/s sein, wenn der Anbieter eine 100 MBit Karte bei der Hardware versprochen hatte.

 wget -O /dev/null http://speedtest.dal01.softlayer.com/downloads/test100.zip

Fertig

Der Server ist jetzt fertig und sollte als Gateway laufen. Bitte den Server neu starten und schauen, ob man sich mit fastd als Client an den Server anmelden kann.

Mit einem PC/Notebook kann die Verfügbarkeit des Gateways getestet werden bzw. kann man so auch ohne FF Router eine sichere Verbindung fastd herstellen.

Eine Client Datei (z.B. client-test.conf) soll die fastd-Test-Verbindung mit folgendem Inhalt ermöglichen:

 mode tap;
 method "salsa2012+umac";
 mtu 1406;
 secret "[ein privater fastd key für den client]";
 peer "FreifunkRouter" {
   remote "[GW Server].freifunk-lippe.de":1234; # IPV4 Server
   key "[der öffentlicher fastd key vom server]";
 }
 on up "
   ip link set up $INTERFACE
   batctl if add $INTERFACE
 ";

Dann auf der Konsole fastd als client starten:

  fastd -c /etc/fastd/client_test.conf

Man sollte nun sehen, dass der Gateway gefunden wird und sich mittels Handshake verbindet und dann erfolgreich den fastd-VPN geöffnet hat. Parallel kann man das auch auf dem Server im System-Log verfolgen. Wichtig sind mögliche Fehlermeldungen, wenn die Verbindung nicht ordnungsgem. erfolgt.