computer:network:pihole

Pihole-DNS-Server

Auf einem OrangePi zero installiert

Pihole

DNScrypt-Proxy

https://blog.sean-wright.com/dns-with-pi-hole-dnscrypt/

  1. Change the current directory to /opt: cd /opt
  2. Download the latest version: sudo wget https://github.com/DNSCrypt/dnscrypt-proxy/releases/download/2.0.45/dnscrypt-proxy-linux_arm64-2.0.45.tar.gz
  3. Unarchive the downloaded archive: sudo tar -xvzf ./dnscrypt-proxy-linux_arm64-2.0.45.tar.gz
  4. Remove the downloaded archive: sudo rm dnscrypt-proxy-linux_arm64-2.0.45.tar.gz
  5. Rename the unpacked directory: `sudo mv ./linux-x86_64 ./dnscrypt-proxy
  6. Change directory to dnscrypt-proxy: cd dnscrypt-proxy
  7. Create configuration from an example: sudo cp ./example-dnscrypt-proxy.toml ./dnscrypt-proxy.toml
  8. Edit the configuration:
  server_names = ['cloudflare'] # you can can change this and get a list of names from https://dnscrypt.info/public-servers
  listen_addresses = ['127.0.0.1:54']
  1. Install the dnscrypt-proxy: sudo ./dnscrypt-proxy -service install
  2. Start dnscrypt-proxy: sudo ./dnscrypt-proxy -service start

DynDNS-Script

Raspberry Pi mit WireGuard als VPN Server

https://www.bachmann-lan.de/raspberry-pi-mit-wireguard-als-vpn-server-mit-wireguard/

Aufbau und Setup

  Raspberry Pi 3 mit Raspbian Buster Lite
  der Pi hängt im LAN hinter dem Hauptrouter
  LAN: 192.168.150.0/24 (Pi: 192.168.150.200)
  VPN Netz: 10.10.10.0/24 (VPN Server: 10.10.10.1, VPN Client1: 10.10.10.2, VPN Client2: 10.10.10.3)
  Clients als Road Warrior (Android Smartphone und Windows 10 Notebook)

Installation

WireGuard auf dem Raspberry Pi installieren. (Zur Vereinfachung alles als root.)

Raspbian Stretch 

$ apt-get update
$ apt-get upgrade 
$ apt-get install raspberrypi-kernel-headers
$ echo "deb http://deb.debian.org/debian/ unstable main" | tee --append /etc/apt/sources.list.d/unstable.list
$ apt-get install dirmngr 
$ apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 8B48AD6246925553 
$ printf 'Package: *\nPin: release a=unstable\nPin-Priority: 150\n' | tee --append /etc/apt/preferences.d/limit-unstable
$ apt-get update
$ apt-get install wireguard 
$ reboot

Raspbian Buster (07.07.2019) 

$ apt-get update
$ apt-get upgrade 
$ apt-get install raspberrypi-kernel-headers
$ echo "deb http://deb.debian.org/debian/ unstable main" | tee --append /etc/apt/sources.list.d/unstable.list
$ apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 04EE7237B7D453EC
$ printf 'Package: *\nPin: release a=unstable\nPin-Priority: 150\n' | tee --append /etc/apt/preferences.d/limit-unstable
$ apt-get update
$ apt-get install wireguard 
$ reboot

Aktivieren von IPv4 forwarding in der /etc/sysctl.conf 

# Uncomment the next line to enable packet forwarding for IPv4
net.ipv4.ip_forward = 1

Den Pi neu starten und die Änderungen nochmal überprüfen. 

$ sysctl net.ipv4.ip_forward 
net.ipv4.ip_forward = 1

Keys generieren

Die Erstellung der keys wird im Verzeichnis /etc/wireguard durchgeführt.
Um sicherzustellen dass alle Dateien die richtigen Berechtigungen haben, muss die umask auf 077 gesetzt sein. 

$ umask 077

Server Key generieren

private und public key für den Server 

$ wg genkey | tee server-private.key | wg pubkey > server-public.key
$ ls -l server*
-rw------- 1 root root 45 Mar 31 10:38 server-private.key
-rw------- 1 root root 45 Mar 31 10:38 server-public.key

Client Keys generieren

private und public key für die Clients 

$ wg genkey | tee client1-private.key | wg pubkey > client1-public.key
$ wg genkey | tee client2-private.key | wg pubkey > client2-public.key

$ ls -l client*

  1. rw——- 1 root root 45 Mar 31 10:41 client1-private.key
  2. rw——- 1 root root 45 Mar 31 10:41 client1-public.key
  3. rw——- 1 root root 45 Mar 31 10:41 client2-private.key
  4. rw——- 1 root root 45 Mar 31 10:41 client2-public.key

Server Konfiguration

Dazu wird die Datei /etc/wireguard/wg0.conf erstellt. (Die neue VPN Schnittstelle ist wg0.)
Bei den iptables Regeln muss ggf. noch der Name der Netzwerkschnittstelle angepasst werden! Bei mir ist es eth0. 

[Interface]
Address = 10.10.10.1/24
ListenPort = 51820
PrivateKey = <server-private.key einfügen>
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j   MASQUERADE
# Client1 Smartphone
[Peer]
PublicKey = <client1-public.key einfügen>
AllowedIPs = 10.10.10.2/32
# Client2 Notebook
[Peer]
PublicKey = <client2-public.key einfügen>
AllowedIPs = 10.10.10.3/32
Client Konfiguration

Für jeden Client erstelle ich eine eigene Konfigurationsdatei.

/etc/wireguard/client1.conf 

[Interface]
PrivateKey = <client1-private.key einfügen>
Address = 10.10.10.2
DNS = 192.168.150.20
[Peer]
PublicKey = <server-public.key einfügen>
Endpoint = vpn.your-public-server.net:51820
AllowedIPs = 0.0.0.0/0, 192.168.150.0/24
PersistentKeepalive = 25

/etc/wireguard/client2.conf 

[Interface]
PrivateKey = <client2-private.key einfügen>
Address = 10.10.10.3
DNS = 192.168.150.20
[Peer]
PublicKey = <server-public.key einfügen>
Endpoint = vpn.your-public-server.net:51820
AllowedIPs = 0.0.0.0/0, 192.168.150.0/24
PersistentKeepalive = 25

Als DNS Server nutze ich meinen eigenen im lokalen LAN und mit 0.0.0.0/0 wird alles (der komplette traffic) durch das VPN geroutet.
Da ich mich hinter einem NAT befinde, wird mit PersistentKeepalive = 25 versucht die Verbindung aufrecht zu halten.
WireGuard starten 

$ wg-quick up wg0
[#] ip link add wg0 type wireguard
[#] wg setconf wg0 /dev/fd/63
[#] ip address add 10.10.10.1 dev wg0
[#] ip link set mtu 1420 up dev wg0
[#] iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

WireGuard beim Systemstart automatisch laden.

$ systemctl enable wg-quick@wg0
Created symlink /etc/systemd/system/multi-user.target.wants/wg-quick@wg0.service → /lib/systemd/system/wg-quick@.service.

WireGuard Status

Status der aktiven wg0 Schnittstelle. 

$ wg
interface: wg0
  public key: 9EHJpPuO59RsFbejPZacyZ34TkT7Exas/ZKQsAfTU0U=
  private key: (hidden)
  listening port: 51820
peer: mSOXtoZPSCoZL48u9IZGlpov5T4jAwZ7yhETTDosHVU=
  allowed ips: 10.10.10.2/32
peer: 9q9PAKC5MUNaF4QmcH5hoqwpWoX2R4/KewvLi0SebmQ=
  allowed ips: 10.10.10.3/32

Firewall Konfiguration

Der UDP Port 51820 muss an den internen VPN Server weitergeleitet werden. (hier für meinen MikroTik Router) 

/ip firewall filter
add action=accept chain=forward dst-port=51820 protocol=udp
/ip firewall nat
add action=dst-nat chain=dstnat dst-port=51820 in-interface=wan protocol=udp to-addresses=192.168.150.200 to-ports=51820

Road Warrior – Android Client

Für Android nehme ich die offizielle WireGuard App aus dem Google Play Store.

Die Einstellungen der App kann mittels einer Datei, QR-Code oder manuell erfolgen. Auf dem Server wird ein QR-Code für den Client1 erstellt. 

$ apt install -y qrencode

QR-Code für den Client1 erstellen. 

$ qrencode -t ansiutf8 < client1.conf

Abscannen und fertig. Ohne die mühselige tipperei auf dem Smartphone.

Road Warrior – Windows Client

Für Windows nehme ich den offiziellen WireGuard Client.
Nach der Installation die (auf dem Server erzeugte) client2.conf importierenund die VPN Verbindung aktivieren.

WireGuard updaten

Das hat mich schon viel Nerven gekostet, weil nach einem Kernel Update des Systems wireguard-dkms nicht mehr kompiliert und mit einer Fehlermeldung abbricht. Sollte es mal Probleme geben, kann man folgendes versuchen. 

# Variante A (nach jedem Kernel Update)
$ dpkg-reconfigure wireguard-dkms
# Variante B
$ apt remove wireguard*
$ apt install bc libncurses5-dev
$ apt install wireguard

Mittlerweile kompiliere ich mir dir WireGuard Kernel Module und das wg Tool selber. Ist super einfach und schnell erledigt.
WireGuard nicht aus den Repos installieren und ggf. installierte Pakete vorher deinstallieren! 

# Toolchain installieren
$ apt-get install libmnl-dev libelf-dev linux-headers-$(uname -r) build-essential pkg-config
# WireGuard empfiehlt den aktuellen Snapshot zu verwenden
$ wget https://git.zx2c4.com/WireGuard/snapshot/WireGuard-0.0.2019mmdd.tar.xz
# Kernel Module und das wg Tool kompilieren (dauert noch keine 2 Minuten)
$ cd WireGuard-0.0.2019mmdd/src
$ make
# als root installieren
$ make install
# neustarten und fertig
$ reboot

WireGuard Compiling the Kernel Module from Source | current Snapshot versions

Die installierte Version kann man gut mit dmesg herausfinden. 

$ dmesg | grep wireguard
[   17.787932] wireguard: loading out-of-tree module taints kernel.
[   17.792398] wireguard: WireGuard 0.0.20191212 loaded. See www.wireguard.com for information.
[   17.792405] wireguard: Copyright (C) 2015-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
# etwas kompakter
$ dmesg | awk '/WireGuard/ {print $4,$5}'
WireGuard 0.0.20191212

Fazit

Im Vergleich zu OpenVPN ist die Einrichtung und Konfiguration, trotz der langen Anleitung, in wenigen Minuten erledigt.
Der Tunnelaufbau und das Routing funktionierten auf Anhieb reibungslos und schnell.

17.05.2019 – Nach ca. 6 Wochen bin ich immer noch mehr als zufrieden! Schneller Tunnelaufbau und immer eine stabile Verbindung!
Links

  • computer/network/pihole.txt
  • Last modified: 2022/10/25 10:09
  • by springm