Anleitung: OpenVPN Script fuer automatische Kaskadierung und Verbindungsueberwachung

@nonono

So, du kannst gerne erneut testen. :)

Nun wird automatisch erkannt, ob iptables oder nftables installiert ist und welcher der beiden aktiv ist.
Dementsprechend gibt das Script dies auch aus.

Sag Bescheid, wenn wieder was sein sollte.

Bash:
#!/bin/bash
#
function fw_rules_iptables {
    # loeschen der vorhandenen Regeln
    iptables -F

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    iptables -t filter -A OUTPUT -o "$1" -p udp -m multiport --dports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A OUTPUT -o "$1" -p tcp -m multiport --dports 300,301,1142,142,1152,152,22 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p udp -m multiport --sports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p tcp -m multiport --sports 300,301,1142,142,1152,152,22 -m state --state ESTABLISHED,RELATED -j ACCEPT

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    iptables -t filter -A OUTPUT --dst 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A INPUT --src 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A INPUT --src 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 172.16.0.0/12 -j ACCEPT
    iptables -t filter -A INPUT --src 172.16.0.0/12 -j ACCEPT

    # Blockieren saemtlicher, nicht zuvor definierter, Netzwerkanfragen
    iptables -t filter -A OUTPUT -o "$1" -j DROP
    iptables -t filter -A INPUT -i "$1" -j DROP
}
function fw_rules_nftables {
    # Hinzufuegen einer neuen Table
    nft add table block_without_tun

    # loeschen der vorhandenen Regeln
    nft flush table block_without_tun

    # Chains anlegen
    nft add chain block_without_tun input { type filter hook input priority 0 \; }
    nft add chain block_without_tun output { type filter hook input priority 0 \; }

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol udp udp dport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state new,related,established counter accept
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol tcp tcp dport { 300,301,1142,142,1152,152,22} ct state new,related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol udp udp sport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol tcp tcp sport { 300,301,1142,142,1152,152,22} ct state related,established counter accept

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    nft add rule block_without_tun output ip daddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun input ip saddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun output ip daddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun input ip saddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun output ip daddr 172.16.0.0/12 counter accept
    nft add rule block_without_tun input ip saddr 172.16.0.0/12 counter accept

    # Blockieren saemtlicher -nicht zuvor definierter- Netzwerkanfragen
    nft add rule block_without_tun output oifname '"'"$1"'"' counter drop
    nft add rule block_without_tun input iifname '"'"$1"'"' counter drop
}

echo -e "\n\nKillswitch-Script zum Abriegeln der physischen Netzwerkadapter"
echo -e "--------------------------------------------------------------\n"

# ermitteln der genutzten Firewall
dpkg -l | grep ^ii | awk '{print $2}' | grep -w "iptables" >> /dev/null
inst_ipt="$?"

dpkg -l | grep ^ii | awk '{print $2}' | grep -w "nftables" >> /dev/null
inst_nft="$?"

if [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "1" ];
then
    echo -e "'iptables' oder 'nftables' nicht installiert!"
    echo -e "Bitte erst die gewuenschte Firewall mit folgendem Befehl installieren und anschliessend das Script erneut ausfuehren:"
    echo -e "\niptables:\tsudo apt-get install iptables\n"
    echo -e "\nnftables:\tsudo apt-get install nftables\n"
    exit
elif [ "$inst_ipt" -eq "$inst_nft" ];
then

    if systemctl status nftables | grep -w "inactive" >> /dev/null
    then
        use_fw=iptables
    else
        use_fw=nftables
    fi
elif [ "$inst_ipt" -eq "0" ] && [ "$inst_nft" -eq "1" ];
then
    use_fw=iptables
elif [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "0" ];
then
    use_fw=nftables
else
    echo -e "\n--------------------------------"
    echo -e "unbekannter Status - beenden!"
    echo -e "--------------------------------\n\n"
    exit
fi

# ermitteln vorhandener physischer Netzwerkadapter
mapfile -t phy_net < <(grep -E -v 'tun|lo' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]' | grep -E '*[0-9]')

# ermitteln vorhandener VPN-TUN
mapfile -t tun_net < <(grep 'tun' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]')

if [ "${#tun_net[*]}" -gt "0" ];
then
    START=0
    count="$((${#phy_net[*]}-"1"))"
    echo -e "Es wurden folgende physischen Apdater erkannt"
    echo -e "---------------------------------------------"
    for (( i=START; i<=count; i++ ))
    do
        echo -e "==> ${phy_net[i]}"
    done
    echo -e "\n\nErkannte, aktive Firewall"
    echo -e "-------------------------"

    if [ "$use_fw" == "iptables" ];
    then
        echo -e "==> 'iptables' scheint aktiv zu sein!\n"
    elif [ "$use_fw" == "nftables" ];
    then
        echo -e "==> 'nftables' scheint aktiv zu sein!\n"
    fi
    echo -e "Firewall-Konfiguration von $use_fw wird somit angepasst!"

    echo -e "\nHINWEIS: Nach einem Neustart werden die Anpassungen automatisch zurueckgesetzt!"
    echo -e "Welche Aktion soll ausgefuehrt werden?\n"
    echo -e "(i)mport der Regeln\n(l)oeschen saemtlicher Regeln\n(a)bbruch des Scripts"
    read -r answer

    case "$answer" in
        i)
            START=0
            count="$((${#phy_net[*]}-"1"))"
            echo -e "\nAntwort: 'import'\n"
            for (( i=START; i<=count; i++ ))
            do
                if [ "$use_fw" == "iptables" ];
                then
                    fw_rules_iptables "${phy_net[i]}"
                elif [ "$use_fw" == "nftables" ];
                then
                    fw_rules_nftables "${phy_net[i]}"
                fi
            done
            echo -e "\n-------------------------------------------"
            echo -e "Hinzufuegen der Firewall-Regeln erfolgreich"
            echo -e "-------------------------------------------\n\n"
            ;;

        l)
            echo -e "\nAntwort: 'loeschen'\n"
            if [ "$use_fw" == "iptables" ];
            then
                iptables -F
            elif [ "$use_fw" == "nftables" ];
            then
                nft flush table block_without_tun
            fi
            echo -e "\n----------------------------------------"
            echo -e "Loeschen der Firewall-Regeln erfolgreich"
            echo -e "----------------------------------------\n\n"
            ;;

        a)
            echo -e "\nAntwort: 'abbruch'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac

else
    echo -e "Es konnten KEINE TUN-Adapter ermittelt werden"
    echo -e "Bitte die VPN-Verbindungen aufbauen und das Script im Anschluss erneut starten!\n"

    echo -e "Soll versucht werden, saemtliche temporaere 'iptables' und 'nftables' Regeln zu entfernen?\n"
    echo -e "(j)a / (n)ein"
    read -r answer

    case "$answer" in
        j)
            echo -e "\nAntwort: 'ja'\n"
            iptables -F
            nft flush table block_without_tun
            echo -e "\n---------------"
            echo -e "Regeln entfernt"
            echo -e "---------------\n\n"
            ;;

        n)
            echo -e "\nAntwort: 'nein'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac
fi
 
Last edited:

nonono

Member
@PrivateMember: Alles klar, danke :)

Nach einem Test stellt sich raus, dass Debian vor nft gern ein sudo hätte. Ich hab das angepasst. Die Regeln werden auch importiert, killen aber sämtlichen Netzwerktraffic und auch die VPN Verbindung pingt dann aus und lässt sich nicht neu aufbauen. Dicht ist es also. Leider etwas zu dicht :)
 
Last edited:
Könntest du mir bitte den Output posten, wenn du den Befehl 'ip addr' ausführst?
Du kannst gerne deine IP und MAC vorher ausschneiden.

Dann noch bitte den Scriptoutput nach der Ausführung.

Wenn du das Script mit sudo ausführst, dann werden sämtliche Befehle innerhalb des Scripts auch mit sudo ausgeführt. Das hatte ich auf zwei Debian Systemen und auch auf einem RPi durchgetestet. 🤔

Ist für mich gerade leider unerklärlich, weshalb bei Dir alles geblockt wird, da die Tun-Interfaces doch gar nicht angefasst werden.

Deshalb bitte mal den von mir gewünschten output posten, vielleicht erkenne ich da was. 🙂

Noch was: wie startest du die VPN-Verbindung?
 

nonono

Member
Code:
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host 
valid_lft forever preferred_lft forever
2: enp57s0f1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether xxxx
inet xxxx/24 brd xxxxxxx scope global dynamic noprefixroute enp57s0f1
valid_lft 863470sec preferred_lft 863470sec
inet6 xxxx scope global temporary dynamic 
valid_lft 7132sec preferred_lft 3532sec
inet6 xxxx scope global dynamic mngtmpaddr noprefixroute 
valid_lft 7132sec preferred_lft 3532sec
inet6xxxx scope link noprefixroute 
valid_lft forever preferred_lft forever
3: wlp58s0: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default qlen 1000
link/ether xxxx
4: tun0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UNKNOWN group default qlen 100
link/none 
inet xxxx brd 10.3.5.255 scope global tun0
valid_lft forever preferred_lft forever
inet6 xxxx scope global 
valid_lft forever preferred_lft forever
inet6 xxxx scope link stable-privacy 
valid_lft forever preferred_lft forever

und

Code:
Killswitch-Script zum Abriegeln der physischen Netzwerkadapter
--------------------------------------------------------------

Es wurden folgende physischen Apdater erkannt
---------------------------------------------
==> wlp58s0
==> enp57s0f1


Erkannte, aktive Firewall
-------------------------
==> 'nftables' scheint aktiv zu sein!

Firewall-Konfiguration von nftables wird somit angepasst!

HINWEIS: Nach einem Neustart werden die Anpassungen automatisch zurueckgesetzt!
Welche Aktion soll ausgefuehrt werden?

(i)mport der Regeln
(l)oeschen saemtlicher Regeln
(a)bbruch des Scripts
i

Antwort: 'import'


-------------------------------------------
Hinzufuegen der Firewall-Regeln erfolgreich
-------------------------------------------
Das führt dann zu:

Inactivity timeout (--ping-restart), restarting

und es geht nichts mehr nach draußen.


Openvpn starte ich mittels sudo openvpn <config> im Terminal. Warum man seid Debian Buster auch als root nochmal su vor gewissen Befehlen eingeben muss hab ich auch noch nicht rausgefunden. (Beispiel: shutdown, openvpn, etc)
 
@nonono
Danke, das sieht doch soweit schon mal gut aus.

Ich habe auch eine Vermutung, was es sein könnte.
In meinem Script siehst du oben in den Funktionen für iptables und nftables die freigegebenen ports. Hier habe ich die Standardports angegeben.

Schau du mal bitte in eine deiner openVPN-Configs rein. Dort erkennst du relativ schnell die Server-IP's. Hinter diesen steht immer der jeweilige Port. Nenne mir bitte aus der zuletzt verwendeten config die Ports. 🙂
 
@nonono
Perfekt, danke - war meine Vermutung korrekt.
Ich habe die Ports entsprechend ergänzt, hier das Script:

Bash:
#!/bin/bash
#
function fw_rules_iptables {
    # loeschen der vorhandenen Regeln
    iptables -F

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    iptables -t filter -A OUTPUT -o "$1" -p udp -m multiport --dports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A OUTPUT -o "$1" -p tcp -m multiport --dports 300,301,1142,142,1152,152,22 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p udp -m multiport --sports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p tcp -m multiport --sports 300,301,1142,142,1152,152,22 -m state --state ESTABLISHED,RELATED -j ACCEPT

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    iptables -t filter -A OUTPUT --dst 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A INPUT --src 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A INPUT --src 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 172.16.0.0/12 -j ACCEPT
    iptables -t filter -A INPUT --src 172.16.0.0/12 -j ACCEPT

    # Blockieren saemtlicher, nicht zuvor definierter, Netzwerkanfragen
    iptables -t filter -A OUTPUT -o "$1" -j DROP
    iptables -t filter -A INPUT -i "$1" -j DROP
}
function fw_rules_nftables {
    # Hinzufuegen einer neuen Table
    nft add table block_without_tun

    # loeschen der vorhandenen Regeln
    nft flush table block_without_tun

    # Chains anlegen
    nft add chain block_without_tun input { type filter hook input priority 0 \; }
    nft add chain block_without_tun output { type filter hook input priority 0 \; }

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol udp udp dport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state new,related,established counter accept
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol tcp tcp dport { 300,301,1142,142,1152,152,22} ct state new,related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol udp udp sport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol tcp tcp sport { 300,301,1142,142,1152,152,22} ct state related,established counter accept

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    nft add rule block_without_tun output ip daddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun input ip saddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun output ip daddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun input ip saddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun output ip daddr 172.16.0.0/12 counter accept
    nft add rule block_without_tun input ip saddr 172.16.0.0/12 counter accept

    # Blockieren saemtlicher -nicht zuvor definierter- Netzwerkanfragen
    nft add rule block_without_tun output oifname '"'"$1"'"' counter drop
    nft add rule block_without_tun input iifname '"'"$1"'"' counter drop
}

echo -e "\n\nKillswitch-Script zum Abriegeln der physischen Netzwerkadapter"
echo -e "--------------------------------------------------------------\n"

# ermitteln der genutzten Firewall
dpkg -l | grep ^ii | awk '{print $2}' | grep -w "iptables" >> /dev/null
inst_ipt="$?"

dpkg -l | grep ^ii | awk '{print $2}' | grep -w "nftables" >> /dev/null
inst_nft="$?"

if [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "1" ];
then
    echo -e "'iptables' oder 'nftables' nicht installiert!"
    echo -e "Bitte erst die gewuenschte Firewall mit folgendem Befehl installieren und anschliessend das Script erneut ausfuehren:"
    echo -e "\niptables:\tsudo apt-get install iptables\n"
    echo -e "\nnftables:\tsudo apt-get install nftables\n"
    exit
elif [ "$inst_ipt" -eq "$inst_nft" ];
then

    if systemctl status nftables | grep -w "inactive" >> /dev/null
    then
        use_fw=iptables
    else
        use_fw=nftables
    fi
elif [ "$inst_ipt" -eq "0" ] && [ "$inst_nft" -eq "1" ];
then
    use_fw=iptables
elif [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "0" ];
then
    use_fw=nftables
else
    echo -e "\n--------------------------------"
    echo -e "unbekannter Status - beenden!"
    echo -e "--------------------------------\n\n"
    exit
fi

# ermitteln vorhandener physischer Netzwerkadapter
mapfile -t phy_net < <(grep -E -v 'tun|lo' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]' | grep -E '*[0-9]')

# ermitteln vorhandener VPN-TUN
mapfile -t tun_net < <(grep 'tun' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]')

if [ "${#tun_net[*]}" -gt "0" ];
then
    START=0
    count="$((${#phy_net[*]}-"1"))"
    echo -e "Es wurden folgende physischen Apdater erkannt"
    echo -e "---------------------------------------------"
    for (( i=START; i<=count; i++ ))
    do
        echo -e "==> ${phy_net[i]}"
    done
    echo -e "\n\nErkannte, aktive Firewall"
    echo -e "-------------------------"

    if [ "$use_fw" == "iptables" ];
    then
        echo -e "==> 'iptables' scheint aktiv zu sein!\n"
    elif [ "$use_fw" == "nftables" ];
    then
        echo -e "==> 'nftables' scheint aktiv zu sein!\n"
    fi
    echo -e "Firewall-Konfiguration von $use_fw wird somit angepasst!"

    echo -e "\nHINWEIS: Nach einem Neustart werden die Anpassungen automatisch zurueckgesetzt!"
    echo -e "Welche Aktion soll ausgefuehrt werden?\n"
    echo -e "(i)mport der Regeln\n(l)oeschen saemtlicher Regeln\n(a)bbruch des Scripts"
    read -r answer

    case "$answer" in
        i)
            START=0
            count="$((${#phy_net[*]}-"1"))"
            echo -e "\nAntwort: 'import'\n"
            for (( i=START; i<=count; i++ ))
            do
                if [ "$use_fw" == "iptables" ];
                then
                    fw_rules_iptables "${phy_net[i]}"
                elif [ "$use_fw" == "nftables" ];
                then
                    fw_rules_nftables "${phy_net[i]}"
                fi
            done
            echo -e "\n-------------------------------------------"
            echo -e "Hinzufuegen der Firewall-Regeln erfolgreich"
            echo -e "-------------------------------------------\n\n"
            ;;

        l)
            echo -e "\nAntwort: 'loeschen'\n"
            if [ "$use_fw" == "iptables" ];
            then
                iptables -F
            elif [ "$use_fw" == "nftables" ];
            then
                nft flush table block_without_tun
            fi
            echo -e "\n----------------------------------------"
            echo -e "Loeschen der Firewall-Regeln erfolgreich"
            echo -e "----------------------------------------\n\n"
            ;;

        a)
            echo -e "\nAntwort: 'abbruch'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac

else
    echo -e "Es konnten KEINE TUN-Adapter ermittelt werden"
    echo -e "Bitte die VPN-Verbindungen aufbauen und das Script im Anschluss erneut starten!\n"

    echo -e "Soll versucht werden, saemtliche temporaere 'iptables' und 'nftables' Regeln zu entfernen?\n"
    echo -e "(j)a / (n)ein"
    read -r answer

    case "$answer" in
        j)
            echo -e "\nAntwort: 'ja'\n"
            iptables -F
            nft flush table block_without_tun
            echo -e "\n---------------"
            echo -e "Regeln entfernt"
            echo -e "---------------\n\n"
            ;;

        n)
            echo -e "\nAntwort: 'nein'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac
fi
 

nonono

Member
Das gleiche Problem wie zuvor. Bei der Standardfreigabe für lokalen LAN Traffic ist mir aufgefallen, dass du andere Ranges nutzt als bei mir genutzt werden. Ich habe beispielsweise lokal 192.168.178.x - Könnte es daran liegen?
 
Äußerst merkwürdig. :(
Die Range-Freigabe (Subnet) im Script schließt auch Deinen Adressbereich mit ein. 👍

Für nftables folgendes aus dem Script:
Bash:
    nft add rule block_without_tun output ip daddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun input ip saddr 192.168.0.0/16 counter accept
bedeutet, dass lediglich '192.168.' sich nicht ändern darf (Standard Klasse-C Netz) -> alle Werte im 3. und 4. Oktett werden nicht ausgewertet.

Eine weitere Vermutung wäre, dass du per IPv6 only ins Internet gehst, was theoretisch aber auch nicht stören sollte.
Jetzt stehe ich ein bisschen auf dem Schlauch. 🤔

Vielleicht hat noch ein anderer Forennutzer noch eine Idee?
@PP Frank ?
 
Dann Feuer frei!

Bash:
#!/bin/bash
#
function fw_rules_iptables {
    # loeschen der vorhandenen Regeln
    iptables -F

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    iptables -t filter -A OUTPUT -o "$1" -p udp -m multiport --dports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A OUTPUT -o "$1" -p tcp -m multiport --dports 300,301,1142,142,1152,152,22,44,443,4433 -m state --state NEW,ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p udp -m multiport --sports 1148,148,1149,149,1150,150,1151,151,44,443,4433 -m state --state ESTABLISHED,RELATED -j ACCEPT
    iptables -t filter -A INPUT -i "$1" -p tcp -m multiport --sports 300,301,1142,142,1152,152,22,44,443,4433 -m state --state ESTABLISHED,RELATED -j ACCEPT

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    iptables -t filter -A OUTPUT --dst 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A INPUT --src 192.168.0.0/16 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A INPUT --src 10.0.0.0/8 -j ACCEPT
    iptables -t filter -A OUTPUT --dst 172.16.0.0/12 -j ACCEPT
    iptables -t filter -A INPUT --src 172.16.0.0/12 -j ACCEPT

    # Blockieren saemtlicher, nicht zuvor definierter, Netzwerkanfragen
    iptables -t filter -A OUTPUT -o "$1" -j DROP
    iptables -t filter -A INPUT -i "$1" -j DROP
}
function fw_rules_nftables {
    # Hinzufuegen einer neuen Table
    nft add table block_without_tun

    # loeschen der vorhandenen Regeln
    nft flush table block_without_tun

    # Chains anlegen
    nft add chain block_without_tun input { type filter hook input priority 0 \; }
    nft add chain block_without_tun output { type filter hook input priority 0 \; }

    # Freigabe der openVPN-Ports der Standardkonfiguration von Perfect-Privacy
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol udp udp dport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state new,related,established counter accept
    nft add rule block_without_tun output oifname '"'"$1"'"' ip protocol tcp tcp dport { 300,301,1142,142,1152,152,22,44,443,4433} ct state new,related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol udp udp sport { 1148,148,1149,149,1150,150,1151,151,44,443,4433} ct state related,established counter accept
    nft add rule block_without_tun input iifname '"'"$1"'"' ip protocol tcp tcp sport { 300,301,1142,142,1152,152,22,44,443,4433} ct state related,established counter accept

    # Freigabe der Standard-IP-Ranges fuer lokale Netzwerke
    nft add rule block_without_tun output ip daddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun input ip saddr 192.168.0.0/16 counter accept
    nft add rule block_without_tun output ip daddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun input ip saddr 10.0.0.0/8 counter accept
    nft add rule block_without_tun output ip daddr 172.16.0.0/12 counter accept
    nft add rule block_without_tun input ip saddr 172.16.0.0/12 counter accept

    # Blockieren saemtlicher -nicht zuvor definierter- Netzwerkanfragen
    nft add rule block_without_tun output oifname '"'"$1"'"' counter drop
    nft add rule block_without_tun input iifname '"'"$1"'"' counter drop
}

echo -e "\n\nKillswitch-Script zum Abriegeln der physischen Netzwerkadapter"
echo -e "--------------------------------------------------------------\n"

# ermitteln der genutzten Firewall
dpkg -l | grep ^ii | awk '{print $2}' | grep -w "iptables" >> /dev/null
inst_ipt="$?"

dpkg -l | grep ^ii | awk '{print $2}' | grep -w "nftables" >> /dev/null
inst_nft="$?"

if [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "1" ];
then
    echo -e "'iptables' oder 'nftables' nicht installiert!"
    echo -e "Bitte erst die gewuenschte Firewall mit folgendem Befehl installieren und anschliessend das Script erneut ausfuehren:"
    echo -e "\niptables:\tsudo apt-get install iptables\n"
    echo -e "\nnftables:\tsudo apt-get install nftables\n"
    exit
elif [ "$inst_ipt" -eq "$inst_nft" ];
then

    if systemctl status nftables | grep -w "inactive" >> /dev/null
    then
        use_fw=iptables
    else
        use_fw=nftables
    fi
elif [ "$inst_ipt" -eq "0" ] && [ "$inst_nft" -eq "1" ];
then
    use_fw=iptables
elif [ "$inst_ipt" -eq "1" ] && [ "$inst_nft" -eq "0" ];
then
    use_fw=nftables
else
    echo -e "\n--------------------------------"
    echo -e "unbekannter Status - beenden!"
    echo -e "--------------------------------\n\n"
    exit
fi

# ermitteln vorhandener physischer Netzwerkadapter
mapfile -t phy_net < <(grep -E -v 'tun|lo' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]' | grep -E '*[0-9]')

# ermitteln vorhandener VPN-TUN
mapfile -t tun_net < <(grep 'tun' /proc/net/dev | cut -d ':' -f 1 | tr -d '[:blank:]')

if [ "${#tun_net[*]}" -gt "0" ];
then
    START=0
    count="$((${#phy_net[*]}-"1"))"
    echo -e "Es wurden folgende physischen Apdater erkannt"
    echo -e "---------------------------------------------"
    for (( i=START; i<=count; i++ ))
    do
        echo -e "==> ${phy_net[i]}"
    done
    echo -e "\n\nErkannte, aktive Firewall"
    echo -e "-------------------------"

    if [ "$use_fw" == "iptables" ];
    then
        echo -e "==> 'iptables' scheint aktiv zu sein!\n"
    elif [ "$use_fw" == "nftables" ];
    then
        echo -e "==> 'nftables' scheint aktiv zu sein!\n"
    fi
    echo -e "Firewall-Konfiguration von $use_fw wird somit angepasst!"

    echo -e "\nHINWEIS: Nach einem Neustart werden die Anpassungen automatisch zurueckgesetzt!"
    echo -e "Welche Aktion soll ausgefuehrt werden?\n"
    echo -e "(i)mport der Regeln\n(l)oeschen saemtlicher Regeln\n(a)bbruch des Scripts"
    read -r answer

    case "$answer" in
        i)
            START=0
            count="$((${#phy_net[*]}-"1"))"
            echo -e "\nAntwort: 'import'\n"
            for (( i=START; i<=count; i++ ))
            do
                if [ "$use_fw" == "iptables" ];
                then
                    fw_rules_iptables "${phy_net[i]}"
                elif [ "$use_fw" == "nftables" ];
                then
                    fw_rules_nftables "${phy_net[i]}"
                fi
            done
            echo -e "\n-------------------------------------------"
            echo -e "Hinzufuegen der Firewall-Regeln erfolgreich"
            echo -e "-------------------------------------------\n\n"
            ;;

        l)
            echo -e "\nAntwort: 'loeschen'\n"
            if [ "$use_fw" == "iptables" ];
            then
                iptables -F
            elif [ "$use_fw" == "nftables" ];
            then
                nft flush table block_without_tun
            fi
            echo -e "\n----------------------------------------"
            echo -e "Loeschen der Firewall-Regeln erfolgreich"
            echo -e "----------------------------------------\n\n"
            ;;

        a)
            echo -e "\nAntwort: 'abbruch'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac

else
    echo -e "Es konnten KEINE TUN-Adapter ermittelt werden"
    echo -e "Bitte die VPN-Verbindungen aufbauen und das Script im Anschluss erneut starten!\n"

    echo -e "Soll versucht werden, saemtliche temporaere 'iptables' und 'nftables' Regeln zu entfernen?\n"
    echo -e "(j)a / (n)ein"
    read -r answer

    case "$answer" in
        j)
            echo -e "\nAntwort: 'ja'\n"
            iptables -F
            nft flush table block_without_tun
            echo -e "\n---------------"
            echo -e "Regeln entfernt"
            echo -e "---------------\n\n"
            ;;

        n)
            echo -e "\nAntwort: 'nein'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;

        *)
            echo -e "\nAntwort: 'undefiniert'\n"
            echo -e "\n-------------"
            echo -e "Scriptabbruch"
            echo -e "-------------\n\n"
            ;;
    esac
fi
Aber ACHTUNG!
TCP 443 ist Standard HTTPS -> das wird somit trotzdem funktionieren, wenn der Tunnel weg sein sollte!
 

nonono

Member
Hm, kann ich das irgendwie ändern? Ansonsten funktionierts wie geplant. Danke an dieser Stelle.

edit: Doch nicht. Webseiten lassen sich normal aufrufen und ssh funktioniert auch. Pinganfragen werden aber beispielsweise geblockt.

nftables zeigt als aktuelle Regeln nur das an:

Code:
nft list table inet filter
table inet filter {
        chain input {
                type filter hook input priority 0; policy accept;
        }

        chain forward {
                type filter hook forward priority 0; policy accept;
        }

        chain output {
                type filter hook output priority 0; policy accept;
        }
}
 
Last edited:
Du kannst dir nach der Anmeldung im PP Kundenportal die gewünschten Configs herunterladen.

SSH habe ich über Port 22 freigegeben, das ist richtig so. HTTPS Webseiten gehen ja auch, aufgrund der Tatsache mit dem TCP 443, ping wird korrekt geblockt. 👍🏼

Wenn du per 'sudo nft list ruleset'
dir die Regeln auflisten lässt, muss ein Block mit dem Tablename 'block_without_tun' angezeigt werden, dieser beinhaltet die Regeln nach dem Import. Du hast jedoch die Standardtabelle 'inet filter' hier gepostet.

Keep in mind: nach einem Prozessneustart von nftables oder einem Systemneustart werden die Regeln wieder entfernt.
 

nonono

Member
Kann man auch alles dicht machen wenn die Verbindung nicht über tun0 geht? Ich hatte das früher mal per iptables. Allerdings hatte ich das so gelöst, dass ich Verbindungen zu allen Servern die in den PP Configs stehen erlaubt hatte und sonst nichts.
 
Last edited:
In der Regel sichert man ja grundsätzlich die Verbindung über ein Whitelisting ab (nur notwendige Freigaben und am Ende Deny All).

Wenn die Regeln erst bei Verbindungsabbruch greifen sollen weiß ich nicht, wie träge das ist -> Datenleck.

Ich kann mich belesen, kann aber nichts versprechen.
 

tlo335

Member
Das ich in einem anderen thread, man könnte den kram ja in ein github packen und die user mitcommiten lassen.

Wurde forsch abgelehnt.
 
UPDATE

Changelog
- stetige Verbindungsüberprüfung nicht mehr über die von PP bereitgestellte CSV, sondern über die zuletzt ermittelte öffentliche IP per 'icanhazip.com' -> wesentlich stabiler in der Abfrage
- somit kann das Script nun, theoretisch, auch für andere VPN-Anbieter genutzt werden, welche Kaskadierung ermöglichen (z.B. oVPN, ZorroVPN)

-> falls jemand Kunde von oVPN, ZorroVPN oder eines anderen Anbieters ist, welcher Kaskadierung ermöglicht, kann gerne mit meinen Scripten die Kaskadierung getestet werden
-> ich freue mich über Feedback
 
Das ich in einem anderen thread, man könnte den kram ja in ein github packen und die user mitcommiten lassen.

Wurde forsch abgelehnt.
Da frage ich mich halt nur, warum sowas abgelehnt wird...

Ich versuche demnächst mal was zu bauen, denn eigentlich muss nur ab und zu (z.B. täglich), das openVPN-Config-zip aus dem Tutorial heruntergeladen werden, per RegEx sämtliche IP-Adressen exportieren und dann noch die Dubletten entfernen.

Dazu melde ich mich wieder. 👍
 
Top