# File: /srv/docker/mariadb/docker-compose.yml
---
version: "3"
services:
  mysql:
    image: mariadb:10.4
    container_name: mariadb
    environment:
      TZ: "UTC"
      MYSQL_ROOT_PASSWORD: "xxxxxxxxxxx"
    volumes:
      - /srv/containers/mariadb/data:/var/lib/mysql:rw
    restart: unless-stopped
    networks:
      default:
        ipv4_address: 172.25.1.2

networks:
  default:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.25.1.0/24
    driver_opts:
      com.docker.network.bridge.name: br_mariadb

# File: /srv/docker/nextcloud/docker-compose.yml
---
version: "3"
services:
  web:
    container_name: nextcloud
    image: nextcloud:25-fpm
    networks:
      default:
        ipv4_address: 172.25.2.10

  push:
    container_name: nextcloud_push
    image: nextcloud:25-fpm
    networks:
      default:
        ipv4_address: 172.25.2.11

networks:
  default:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.25.2.0/24
    driver_opts:
      com.docker.network.bridge.name: br_nextcloud

# File: /srv/docker/mailserver/docker-compose.yml
---
version: "3"
services:
  postfix:
    container_name: dovecot
    image: dovecot_image
    networks:
      default:
        ipv4_address: 172.25.3.2

  postfix:
    container_name: postfix
    image: postfix_image
    networks:
      default:
        ipv4_address: 172.25.3.3

networks:
  default:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.25.3.0/24
    driver_opts:
      com.docker.network.bridge.name: br_mailserver

#!/usr/bin/nft -f

flush ruleset

table inet filter {
  # erlaube Transfer in das Internet für bestimmte Ports
  # Kombination aus SRC_IP + SRC_INTERFACE + DEST_IP + PROTOCOL + PORT
  set fwd_docker_to_wan {
    type ipv4_addr . ifname . ipv4_addr . inet_proto . inet_service
    flags interval
    counter
    elements = {
      , # SMTP Versand
      172.25.3.2 . "br_mailserver" . 0.0.0.0/0 . tcp . 25,
      , # HTTPS zum Aktualisieren von Addons
      172.25.3.2 . "br_nextcloud" . 0.0.0.0/0 . tcp . 443, # weiterer Kommentar
    }

  # erlaubt Traffic zwischen Containern
  # Kombination aus SRC_IP + DEST_IP + PROTOCOL + PORT
  set fwd_docker_accept {
    type ipv4_addr . ipv4_addr . inet_proto . inet_service;
    flags interval
    counter
    elements = {
     172.25.3.2  . 172.25.1.2 . tcp . 3306,  # Postfix zu Mariadb
     172.25.2.10 . 172.25.1.2 . tcp . 3306,  # Nextcloud zu Mariadb
     172.25.2.10 . 172.25.3.3 . tcp . 143,   # Nextcloud Dovecot
     172.25.2.10 . 172.25.3.3 . tcp . 993,   # Nextcloud Dovecot
    }
  }
      
  chain forward {
    type filter hook forward priority 0;
    # hergestellte Verbindungen werden direkt durchgelassen
    ct state { established, related } accept

    # erlaubt Kombinationen die im Set fwd_docker_accept enthalten sind
    ip saddr . ip daddr . meta l4proto . th dport \
      @fwd_docker_accept accept
    # erlaubt Kombinationen die im Set fwd_docker_to_wan enthalten sind
    oifname eth0 ip saddr . iifname  . ip daddr . meta l4proto . th dport \
      @fwd_docker_to_wan accept
 
 	# sonstiger Transfer wird gedroppt und geloggt
    # einsehbar mittels dmesg
    log drop
  }
}

table ip nat {
  chain postrouting {
    type nat hook postrouting priority srcnat; policy accept;
    oifname eth0 masquerade
  }
}

nft -c -f /etc/nftables.conf

systemctl restart nftables

# Autostart für nftables aktivieren
systemctl enable nftables

docker ps | grep <NAME>
container_id="xxxxxxxxxxx"

pid=$(docker inspect -f '{{.State.Pid}}' ${container_id})

mkdir -p /var/run/netns/
ln -sfT /proc/$pid/ns/net /var/run/netns/${container_id}

ip netns | grep ${container_id}

ip netns exec ${container_id} ip a

ip netns exec ${container_id} bash

#!/usr/bin/bash

# Datei zum auslesen der Zugriffe
file="/var/log/nginx/my-host.access.log"

while true; do
    # Datei folgend öffnen, filtern und zeilenweise lesen
    tail -n1 -F "${file}" --retry | grep --line-buffered '"GET / HTTP/1.1" 200'  | while read line;do
        # IP-Adresse aus der Zeile extrahieren (Split nach Leerzeichen)
        ip=${line%% *};
        echo "whitelisting IP [$ip]";
        # Hinzufügen der IP-Adresse in IP-Set myset mit 24 Stunden Timeout
        nft add element inet filter myset { ${line%% *} timeout 24h };
    done
done

table inet filter {

    set myset {
        type ipv4_addr
        flags timeout
    }
    
.....

}

modprobe dummy numdummies=5

$ ip -o link | grep dummy
44572: dummy0: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000\    link/ether 72:a0:77:02:5e:57 brd ff:ff:ff:ff:ff:ff
44573: dummy1: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000\    link/ether 36:dd:a2:0c:81:d0 brd ff:ff:ff:ff:ff:ff
44574: dummy2: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000\    link/ether 1e:f3:22:bc:6a:74 brd ff:ff:ff:ff:ff:ff
44575: dummy3: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000\    link/ether 56:ef:c3:3b:9a:b9 brd ff:ff:ff:ff:ff:ff
44576: dummy4: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000\    link/ether 5a:92:bf:48:9f:82 brd ff:ff:ff:ff:ff:ff

# File: /etc/systemd/network/99-dummy10.netdev

[NetDev]
Name=dummy10
Kind=dummy

# File: /etc/systemd/network/99-dummy10.network

[Match]
Name=dummy10

[Network]
Address=10.10.10.33/24

systemctl reload systemd-networkd

network:
  dummy-devices:
    dummy0:
      addresses:
        - 192.168.0.123/24
    dummy1:
      addresses:
        - 192.168.1.123/24
    ...

netplan apply

# Ubuntu
apt-get install docker.io docker-compose

# Archlinux
pacman -Syu docker docker-compose

TOKEN=<NORDVPN TOKEN>
docker run --rm --cap-add=NET_ADMIN --name nordvpn_key_fetch \
  -e TOKEN=${TOKEN} ghcr.io/bubuntux/nordvpn:get_private_key

<einige Ausgaben später...>

############################################################
IP: 10.5.0.2/32
Private Key: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
＼(＾O＾)／
############################################################

version: "3.8"
services:
  nvpn_01:
    container_name: "wgeasy_nvpn_01"
    image: ghcr.io/bubuntux/nordlynx
    restart: unless-stopped
    environment:
      # privater Schlüssel zum Verbindung zu NordVPN Lynx (vorher ausgelesen)
      PRIVATE_KEY: "<SUPER_GEHEIMES_NORDVPN_SECRET>"
      # Subnetz des Wireguard Servers, muss mit WG_DEFAULT_ADDRESS zusammenpassen!
      NET_LOCAL: "192.168.33.0/24"
      # IP-Adresse des wg-Containers (siehe wg01.networks.default.ip4_address)
      WG_CONTAINER_IP: "172.18.18.11"
      # Skript mit Anpassungen, damit die Wireguard Clients erreicht werden
      PRE_UP: "/hooks/pre_connect.sh"
      # optional um bestimmte Server zu wählen (Beispiel hier ist DE)
      #QUERY: 'filters\[country_id\]=81'
    volumes:
    - /srv/docker/wg_easy/nvpn_01:/hooks:ro
    cap_add:
    - NET_ADMIN
    - NET_RAW
    networks:
      default:
        ipv4_address: 172.18.18.2

  wg_01:
    container_name: "wgeasy_wg_01"
    image: weejewel/wg-easy
    ports:
      - "51820:51820/udp"
      - "51821:51821/tcp"
      # FALLS ein Webserver davor geschaltet werden soll, kann dieser Port auch deaktiviert werden und die Container-IP als Ziel für z.B. nginx / Traefik / Apache genutzt werden
      # Alternativ bindet man den HTTP Port nur lokal und referenziert diese im Webserver
      #- "127.0.0.1:51821:51821/tcp"
    environment:
      # IP-Adresse des NordVPN-Containers, wird als Router für die Wireguard-Clients genutzt (siehe nvpn_01.networks.default.ipv4_address)
      CUSTOM_GW: "172.18.18.2"
      # Hostname / IP-Adresse des Servers, wird in der Client Config von Wireguard hinterlegt
      WG_HOST: "my.host.com"
      # Admin Password für das Webinterface
      # Empfehlung: keine Sonderzeichen, könnte (!) zu Fehlern führen
      PASSWORD: "<MEIN_SUPER_SICHERES_KENNWORT>"
      # Subnetz für Wireguard-Clients, MUSS mit NET_LOCAL von NordVPN zusammenpassen!
      # x wird von wgeasy ersetzt und muss so bleiben
      WG_DEFAULT_ADDRESS: "192.168.33.x"
      # DNS Server, wird von den Wireguard-Clients im Tunnel genutzt
      WG_DEFAULT_DNS: "1.1.1.1,9.9.9.9"
      # Standard MTU ist 1500, da Pakete durch einen Tunnel müssen, benötigen wir eine kleinere MTU
      WG_MTU: "1420"
      # alle 30 Sekunden wird die Verbindung überprüft
      WG_PERSISTENT_KEEPALIVE: "30"
      WG_PRE_UP: "/hooks/pre_up.sh"

      # hier kann entschieden werden, welche Netzwerke / IPs durch den Tunnel geroutet werden sollen
      # WICHTIG: dies wird nur beim Generieren der Client-Config berücksichtigt, spätere Anpassungen haben KEINEN VERÄNDERNDEN Effekt auf bereits generierte Tunnel-Configs!
      # nachträgliche Änderungen müssen im Client selbständig nachgepflegt werden, oder der Tunnel neu angelegt und die Config heruntergeladen werden!

      # 2 Beispiele:

      # ALLE IP-Adressen werden über den Tunnel geroutet, hierbei können auch lokale Adressen möglicherweise nicht mehr erreicht werden (z.B. Drucker, Handys, ...)
      # sollte es zu Problemen kommen, das Netz 0.0.0.0/0 im Client hinterlegen (aus Gründen der Kompatibilität mit manchen Betriebssystemen wurde dieses hier in 2 x /1 geteilt)
      WG_ALLOWED_IPS: "0.0.0.0/1,128.0.0.0/1"

      # Sollen private IP-Adressen ausgenommen werden (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16):
      WG_ALLOWED_IPS: "0.0.0.0/5,8.0.0.0/7,11.0.0.0/8,12.0.0.0/6,16.0.0.0/4,32.0.0.0/3,64.0.0.0/2,128.0.0.0/3,160.0.0.0/5,168.0.0.0/6,172.0.0.0/12,172.32.0.0/11,172.64.0.0/10,172.128.0.0/9,173.0.0.0/8,174.0.0.0/7,176.0.0.0/4,192.0.0.0/9,192.128.0.0/11,192.160.0.0/13,192.169.0.0/16,192.170.0.0/15,192.172.0.0/14,192.176.0.0/12,192.192.0.0/10,193.0.0.0/8,194.0.0.0/7,196.0.0.0/6,200.0.0.0/5,208.0.0.0/4,224.0.0.0/3"
    volumes:
      # wird durch das Webinterface beschrieben, deswegen rw!
      - /srv/docker/wg_easy/wg_01_config:/etc/wireguard:rw
      - /srv/docker/wg_easy/wg_01_hooks:/hooks:ro
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1
    networks:
      default:
        ipv4_address: 172.18.18.11
networks:
  default:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.18.18.0/24
    driver_opts:
      com.docker.network.bridge.name: br_wgeasy

#File: /srv/docker/wg_easy/nvpn_01/pre_connect.sh

#!/bin/bash
# löschen der existierenden Route von NordPVN
ip route del $NET_LOCAL
# Route um das Wireguard-Netz über wgeasy Container zu routen
ip route add $NET_LOCAL via $WG_CONTAINER_IP

#File: /srv/docker/wg_easy/wg_01_hooks/pre_up.sh

#/bin/bash
set -e

# Netzwerk und Standard-Gateway auslesen
NETWORK=${WG_DEFAULT_ADDRESS/.x/.0/24}
GW=$(/sbin/ip route | awk '/default/ { print $3 }')

# Webinterface vom Server erlaubt
iptables -I INPUT -s ${GW} -p tcp --dport 51821 -j ACCEPT

# optionale Freigaben

# Webinterface durch Wireguard Clients
#iptables -I INPUT -s ${NETWORK} -p tcp --dport 51821 -j ACCEPT

# Webinterface von überall erreichbar
#iptables -I INPUT -p tcp --dport 51821 -j ACCEPT


# DNS im Container erlauben
iptables -I INPUT -i lo -s 127.0.0.1 -j ACCEPT

# existierende Verbindungen werden erlaubt
iptables -I INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT

# Standard-Regel ist das Verwerfen von Paketen, Accept wird von wg-easy  später hinterlegt!
iptables -P INPUT DROP
iptables -P FORWARD DROP

# wg-easy legt eine masquerade (Source-Nat) Regel an, diese hebeln wir aus, damit im Nordvpn Container die Tunnel-IP-Adresse des Clients ersichtlich ist und nicht zwischen den Containern NAT betrieben wird
iptables -t nat -I POSTROUTING -j ACCEPT

# Pakete von WG-Clients werden durch eine gesonderte Routing-Tabelle behandelt, damit diese in den NordVPN Container geroutet werden
# Dies ist notwendig, damit der wg-easy Container selbst ein Gateway hat und das Webinterface erreichbar ist

# Routen für IP-Pakete von WG-Clients werden in Tabelle 1000 gesucht
ip rule add from ${NETWORK} lookup 1000

# Standard-GW für Tunnel-Clients über den NordVPN Container
ip route add default via ${CUSTOM_GW} table 1000

# alle privaten Netze werden geblockt, denn diese sollen nicht über NordVPN geroutet werden!
# weitere IP-Adressen (/32) oder Netze können hier hinterlegt
# Außerdem wird somit zusätzlich sichergestellt, dass WG-Clients sich unereinander nicht erreichen können.
ip route add blackhole 10.0.0.0/8 table 1000
ip route add blackhole 172.16.0.0/12 table 1000
ip route add blackhole 192.168.0.0/16 table 1000

# optionale Route (Wireguard Clients können sich untereinander erreichen)
# ip route add ${NETWORK} dev wg0 table 1000

# eventuell andere lokale IP-Adressen auf dem WG Host wie Pihole, oder als exklude vom VPN Tunnel
# ip route add x.x.x.x via ${GW} table 1000

cd /srv/docker/wg_easy/

# Berechtigung der Skripts anpassen, damit diese ausführbar sind
find . -name "*.sh" -exec chmod +x {} \;

cd /srv/docker/wg_easy/
docker-compose up -d

docker run --name nvpn_temp -ti --rm --entrypoint /bin/bash ghcr.io/bubuntux/nordlynx:latest


curl "https://api.nordvpn.com/v1/servers/countries" | jq -r '.[] | "\( .name ) \( .id )"'