Freifunk Nordlippe Gateway

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

In der zweiten Jahreshälfte 2014 hat sich für Nordlippe eine Freifunkinitiative gebildet. Zunächst haben wir mit der Firmware anderer Gruppen experimentiert und danken für die Nutzung und super freundliche Unterstützung. Wir haben uns dann auf GLUON aus Norddeutschland fixiert. Die Firmware ist derzeit die, die am besten unterstützt wird und eine rege Entwicklergemeinde sein "eigen" nennen kann. Die jeweils aktuellen Images, die wir auf Basis von GLUON regelmäßig erstellen, stehen zum Download bereit http://update.freifunk-nordlippe.de.

Mit einer eigenen Firmware ergibt sich automatisch auch die Notwendigkeit eigener Gateways. Doch das Konzept der Netzwerktopologie beim Freifunk ist nicht so einfach. GLUON hat einen sehr anspruchvollen Netzaufbau, der es aber durch die geniale Logik ermöglicht, ganz einfach neue Router aufzustellen, die sich dann automatisch in das Freifunknetz einwählen und sofort funktionsfähig sind.

Gateway aufsetzen

Wir möchten uns nun der Konfiguration der Gateways bei uns zuwenden. Hier müssen wir uns sehr bei den Freifunkern aus Gütersloh bedanken, die uns in der Startphase mit vielen Tipps, viel Geduld und noch mehr Unterstützung den Weg bereitet haben. Danke Wusel42 :-)

Linux

Als erstes ist ein Rechner im Internet notwendig, der mit Linux vorbereitet ist. Wir verwenden Debian.

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 https://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 noch diese Quelle aus dem Backport:

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

Für die GPG Schlüssel noch diese auf der Console als root ausführen:

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 noch das Repository auf den aktuellen Stand bringen:

  apt-get update

Software installieren

Wir haben uns an die Beschreibungen und Tipps von anderen gehalten und es ist empfohlen, die folgenden Pakete zu 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             | A.L.F.R.E.D. Datenübertragung            |
 | alfred-json        | A.L.F.R.E.D. Datenausgabe                |
 | batman-adv-dkms    | Batman-Kernelmodul in Version 2013.04    |
 | ntp                | Zeitsynchronisation                      |
 | curl               | 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 alfred-json batman-adv-dkms ntp curl


Nun noch 'alfred 2014.3' und passend dazu 'batadv-vis' installieren. Dies erfolgt aus den Sourcen wie folgt:

 apt-get install unp quilt debhelper
 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

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 ffnl

Das Zertifikat für SSH wird wie folgt erstellt:

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

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

  AllowUsers ffnl

Nun SSH mit folgendem Befehl als root neu laden:

  service ssh reload

Konfiguration

So jetzt wird's Erst ;-) Nach der Einleitung kommt jetzt die Kür.

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 Schnittstelle 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änig 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
       netmask 255.255.255.224
       network 192.168.1.0
       gateway 192.168.1.1
       dns-nameservers 10.136.[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-ffnl
  iface br-ffnl inet static
       address 10.136.[GW Nr].1
       netmask 255.255.0.0
       bridge_ports none 
  
  iface br-ffnl inet6 static
       address fd42:ffee:ff42::1[GW Nr]
       netmask 64
       
       post-up /sbin/ip -6 addr add fd42:ffee:ff42::1[GW Nr]/64 dev br-ffnl
       post-up /sbin/ip rule add iif br-ffnl table 42
       pre-down /sbin/ip -6 addr del fd42:ffee:ff42::1[GW Nr]/64 dev br-ffnl
       pre-down /sbin/ip rule del iif br-ffnl 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önnenDaten für die Knotenkarte gesammelt werden.
  
  allow-hotplug bat0
  iface bat0 inet6 manual
       pre-up modprobe batman-adv
       pre-up batctl if add ffnl-mesh
       
       post-up ip link set dev bat0 up
       post-up brctl addif br-ffnl bat0
       post-up batctl it 10000
       post-up ip rule add from all fwmark 0x1 table 42
  
       pre-down brctl delif br-ffnl bat0 || true
       down ip link set dev bat0 down
               
       post-up start-stop-daemon -b --start --exec /usr/sbin/alfred -- -i br-ffnl -b bat0 -m; # -m steht für den FFMAP-Master, Clients bitte ohne -m !!
       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]             ffnl-gw0[GW Nr]                    ffnl-gw0[GW Nr]
  [externe IP]             vpn[GW Nr].freifunk-nordlippe.de   vpn[GW Nr]
  10.136.[GW Nr].1         ffnl
  fd42:ffee:ff42::1[GW Nr] ffnl

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/ffnl/iptables_ffnl.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.136.0.0/16 dev br-ffnl src 10.136.[GW-Nr].1 table 42
 /sbin/ip route add 0/1 dev tun0 table 42
 /sbin/ip route add 128/1 dev tun0 table 42
 /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
 /sbin/iptables -t mangle -I PREROUTING -s 10.136.0.0/16 -j MARK --set-mark 0x1
 /sbin/iptables -t mangle -I OUTPUT -s 10.136.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/ffnl/iptables_ffnl.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/ffnl/iptables_ffnl.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 /ffnl/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 /ffnl/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 /ffnl/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 /ffnl
  mkdir /ffnl/gateway-ffnl/peers
  mkdir /ffnl/gateway-ffnl/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/ffnl/fastd.conf soll bitte diese Zeilen enthalten:


  # Bind to a fixed address and port, IPv4 and IPv6 at Port 1234
  bind [EXTERNE-IPv4]:1234 interface "eth0";
  # bind [EXTERNE-IPv6]:1234 interface "eth0";
  
  # Set the user, fastd will work as
  user "nobody";
  
  # Set the interface name
  interface "ffnl-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";
  
  #hide ip addresses yes;
  #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 "/ffnl/gateway-ffnl/peers/";
  include peers from "/ffnl/gateway-ffnl/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:[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/ffnl/iptables_ffnl.sh
  ";

Nun sollten in das /ffnl/gateway-ffnl/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/ffnl/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-ffnl {
   AdvSendAdvert on;
   IgnoreIfMissing on;
   AdvManagedFlag off;
   AdvOtherConfigFlag on;
   MaxRtrAdvInterval 200;
   AdvLinkMTU 1280;
   prefix fd42:ffee:ff42::/64 {
               AdvOnLink on;
               AdvAutonomous on;
               AdvRouterAddr on;
   };
 
   RDNSS fd42: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 ".ffnl";
   
   # möglichst kurze Leasetime
   default-lease-time 120;
   max-lease-time 600;
   
   log-facility local7;
   
   subnet 10.136.0.0 netmask 255.255.0.0 {
     authoritative;
     range 10.136.[GW Nr].2 10.136.[GW Nr].254;
   
     option routers 10.136.[GW Nr].1;
     
     option domain-name-servers 10.136.[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 fd42:ffee:ff42::/64 {
   option dhcp6.name-servers fd42: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-ffnl"

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

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

Server, Routing, etc mal testen

Man schaue sich die Routings an, ob die passen. Dazu kann man das mit diesen Befehlen prüfen:

 ifconfig
 ping ccc.de
 nslookup ccc.de
 nslookup map.ffnl
 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


Wichtig für die ffmap 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

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

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"
  
  ### ffnl html ###
  $HTTP["host"] =~ "vpn\.freifunk-nordlippe\.de$" {
       server.document-root = "/www/html"
       server.error-handler-404 = "/e404.html"
  }
  
  ### ffnl update ###
  $HTTP["host"] =~ "update\.freifunk-nordlippe\.de$" {
       server.document-root = "/www/update"
       server.error-handler-404 = "/e404.html"
  }
  
  ### ffnl ffmap ###
  $HTTP["host"] =~ "map\.freifunk-nordlippe\.de$" {
       server.document-root = "/ffnl/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/experimental
 mkdir /ffnl/ffnl-sync/
 mkdir /ffnl/ffnl-sync/images
 mkdir /ffnl/ffnl-sync/images/upgrade
 mkdir /ffnl/ffnl-sync/images/factory
 
 ln -s /ffnl/ffnl-sync/images/upgrade/ /www/update/experimental/
 ln -s /ffnl/ffnl-sync/images/factory/ /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 "ffnl" {
       type master;
       file "/etc/bind/db.ffnl";
  };


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.ffnl Datei mit Inhalt füllen:

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


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


 service bind9 restart

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.136.0.[GW Nr]
 include_dir=/var/gateway-ffnl/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 ffnl erfolgen:

FFmap meshviewer Frontend und Backend (neue Version)

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.

 apt-get install rrdtool python python3-pip
 apt-get install nodejs-legacy
 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


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

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

cd /ffnl 
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 ffnl erneut Schritt für Schritt durchlaufen.

Nun bitte noch die Konfiguration für die Community Nordlippe 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-nordlippe/data/",
   "siteName": "Freifunk Nordlippe",
   "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-nordlippe.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 /ffnl/ffmap-backend && ./backend.py -d /ffnl/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 /ffnl/

cd /ffnl
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:  "nordlippe.freifunk.net",

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

 {
  "cityname": "Freifunk Nordlippe",
  "sitename": "nordlippe.freifunk.net",
  "url": "http://www.freifunk-nordlippe.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 -
 apt-get install nodejs
 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 /ffnl/ffmap-d3/build

So sieht es am Ende so aus:

 [...]  
      Alias /map /ffnl/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 /ffnl/ffmap-d3/build/ verweist. Damit ist dann der Aufruf über eine passende Subdomain map.freifunk-nordlippe.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 /ffnl/:

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

Nun muss noch Zubehör installiert werden:

 cd ffmap-backend
 apt-get install python3-pip
 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 /ffnl/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 ffnl-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 /ffnl/ffmap-backend && ./bat2nodes.py -a aliases.json -m bat0 -d /ffnl/ffmap-d3/build/

Drücken wir die Dauemn! Nun sollte es laufen :-)

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.

Es ist das Tinc zu installieren, wenn es nicht schon verfügbar ist:

 apt-get install tinc

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 = nordlippe[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

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