In einem recht restriktivem Netzwerk benötigte ich eine Möglichkeit, um auf diverse interne Dienste über das Internet zugreifen zu können. Diesen Anlass nahm ich als Gelegenheit um etwas mit TOR und Onioncat herumzuspielen. Mein primäres Ziel war es, sicheren Zugriff auf den internen Mailserver zu gewähren, sodass man E-Mails abrufen kann ohne direkt mit dem LAN verbunden zu sein.
TOR dient hier lediglich als Transportebene, so ist keine Portweiterleitung im Router notwendig. Onioncat wird als hidden-service bereitgestellt und erzeugt ein Overlay-Netzwerk, welches IPv6 als Protokoll auf Layer 3 verwendet. Die Dienste sind dann später über eine statische IPv6 Adresse via TOR/Onioncat erreichbar.
Info: Niemand benötigt globale RootCAs denen generell Vertrauen geschenkt wird, wenn die Onion-Adresse des hidden-service Endpunkts gleichzeitig dem Identitätsnachweis dient!
Zusätzlich greife ich mit port knocking auf eine Technologie aus den 90’ern zurück, um SSH-Zugriff auf das Gateway zu gewähren - alt aber purer Spaß!
Es gibt jede Menge sichere port-knocking Implementierungen, aber sie alle haben gemein, dass sie einen speziellen Client voraussetzen.
Ein einfaches iptables-basiertes Setup is hingegen mit jedem beliebigen Client wie beispielsweise netcat nutzbar.
Als Server/Gateway Hardware nutze ich einen BeagleBone Black auf dem Archlinux läuft.
Übersicht
Vereinfacht lassen sich die Kommunikationswege folgendermaßen darstellen:
+---------+ +---------+
| VLAN #2 | | VLAN #1 |
|---------| |---------|
| | | |
| +----+ | IPv6 | +----+ |
| | GW +-+--to--+-+ MX | |
| +-++-+ | IPv4 | +----+ |
| || | | |
+----++---+ +---------+
||
+----++--------------------+
| || T |
| IP || O T +++++++++ USER
| v4 || R A ++ |
| || C ++ |
| ++ N ++ |
| ++ O ++ |
| ++ I ++ |
| IP ++ N ++ |
| v6 ++ O ++ |
| ++ ++ |
| ++++ |
| ++ |
| |
|--------------------------|
| INTERNET |
+--------------------------+
Der Mailserver befindet sich in VLAN #2, welches ausschließlich von VLAN #1 zu erreichen ist.
Unsere Gateway-Box wird per Ethernet direkt ins VLAN #1 gehangen und dort via DHCP eine IP-Adresse
beziehen. Ausgehender Traffic ins Internet ist auf den relevanten Ports (TOR) ungefiltert.
Der TOR Client auf dem Gateway verbindet sich mit dem Onion-Netzwerk und startet den hidden-service.
Darauf hin ist das Gateway unter der IPV6-Adresse für andere Onioncat Teilnehmer erreichbar.
Sobald ein weiterer Onioncat-Endpunkt bekannt ist, kann dieser mit dem Gateway über IPv6 auf Port 443
kommunizieren und das socat Relay übersetzt den Datenfluss in IPv4 und leitet ihn weiter an den Mailserver
in VLAN #2. Btw. fragt nicht, warum der Mailserver auf Port 443 erreichbar ist.. es handelt sich hier um
einen Microsoft Exchange ActiveSync Server.
Zur einfacheren Administration des Gateways ist dieses auf zwei Wege per SSH zu erreichen:
-
Optional via mDNS aus dem lokalen Netzwerk. Dies einfach aus Bequemlichkeit; die IP-Adresse wird per DHCP zugewiesen und wenn das Lease ausläuft, kann sie sich ändern. Dank
avahihabe ich einen generischen Hostnamen für das Gateway. -
Über TOR/Onioncat.
In beiden Fällen kommt port-knocking zum Tragen. Netcat, vom Client ausgeführt, klopft in bestimmter Reihenfolge an definierte Ports und iptables auf der Gateway-Seite registriert dies und wenn alles passt, wird der SSH Port geöffnet.
Vorzüge dieses Setups
- Es wird keine statische öffentliche IP-Adresse benötigt
- Die öffentliche IP-Adresse wird versteckt
- Es wird via Onioncat eine einzigartige IPv6-Adresse bereitgestellt, die von der hidden-service ID abgeleitet wird
- DNS ist nicht involviert und
leakagesollte damit kein Sicherheitsproblem darstellen
Installation benötigter Pakete
Auf Gateway und Client müssen folgende Pakete installiert werden: tor, nyx, sowie optional avahi aus dem offiziellen Archlinux Paket-Verzeichnis und onioncat aus dem AUR.
$ sudo pacman -S tor nyx
$ yay -S onioncat
Globale Konfiguration
Für Onioncat benötigen wir ein Script, welches von systemd verwendet wird um den Dienst zu starten:
$ sudo vim /usr/local/bin/onioncat
$ sudo chmod 755 /usr/local/bin/onioncat
#!/usr/bin/env bash
set -o errexit
set -o pipefail
__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
if [[ ${EUID} != 0 ]] ; then
echo "Please run as root!"
exit 1
fi
tor_path="/var/lib/tor/ocat"
if /bin/systemctl -q is-active tor; then
while [ ! -f "${tor_path}/hostname" ]; do sleep 1; done
onion_address=$(cat "${tor_path}/hostname")
if [[ ! -z "$onion_address" ]]; then
ocat -B -C $onion_address
else
echo "TOR hidden service address still empty. TOR running? Exiting."
exit 2
fi
else
echo "TOR not started / systemd unit not active. Exiting.."
exit 3
fi
Danach erstellen wir das systemd unitfile:
$ sudo vim /etc/systemd/system/onioncat.service
$ sudo chmod 644 /etc/systemd/system/onioncat.service
Expand to view: /etc/systemd/system/onioncat.service
[Unit]
Description=IPv6 tunnel over TOR
Requires=network-online.target tor.service
After=network-online.target tor.service
[Service]
Type=simple
ExecStart=/usr/local/bin/onioncat
ExecReload=/usr/bin/kill -HUP $MAINPID
KillSignal=SIGINT
Restart=on-failure
RestartSec=10
RestartPreventExitStatus=SIGTERM SIGKILL
SyslogIdentifier=onioncat
[Install]
WantedBy=multi-user.target
Konfiguration: Gateway
Autostart für TOR und Onioncat aktivieren und Dienste starten:
$ sudo systemctl daemon-reload
$ sudo systemctl enable --now tor
$ sudo systemctl enable --now onioncat
Sobald der TOR Client mit dem Onion-Netzwerk verbunden und der Onioncat hidden-service gestartet ist,
kann man sich die einzigartige IPv6-Adresse des Gateways anzeigen lassen:
$ ocat -i $(sudo cat /var/lib/tor/ocat/hostname)
Dieser Befehl wandelt die Onion ID (hidden-service ID) in eine durch Onioncat vergebene IPv6 Adresse um.
IPv6-zu-IPv4 Tunnel
Auf dem Gateway benötigen wir zusätzlich socat und iptables.
$ sudo pacman -S socat iptables
Ein Script welches das socat Relay started und den Datenfluss zum Mailserver weiterleitet.
$ sudo vim /usr/local/bin/ipv6-mx-gate
$ sudo chmod 755 /usr/local/bin/ipv6-mx-gate
#!/usr/bin/env bash
ipv6_address="fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b"
srv_address="192.168.2.1"
while ! ip -6 addr show tun0 | grep -q "${ipv6_address}"; do sleep 1; done
/usr/bin/socat TCP6-LISTEN:443,reuseaddr,fork,bind=[${ipv6_address}] TCP4:${srv_address}:443
Ein weiteres unitfile für den IPv6-zu-IPv4 Tunnel:
$ sudo vim /etc/systemd/system/ipv6-mx-gate.service
$ sudo chmod 644 /etc/systemd/system/ipv6-mx-gate.service
Expand to view: /etc/systemd/system/ipv6-mx-gate.service
[Unit]
Description=IPv6 <-> IPv4 tunnel (for access to mx)
After=onioncat.service
[Service]
ExecStart=/usr/local/bin/ipv6-mx-gate
[Install]
WantedBy=multi-user.target
Autostart für den Tunnel aktivieren und Dienst starten:
$ sudo systemctl daemon-reload
$ sudo systemctl enable --now ipv6-mx-gate
iptables
Für die Konfiguration der iptables Regeln setze ich folgendes Script ein:
#!/usr/bin/env bash
set -o errexit
set -o pipefail
__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
if [[ ${EUID} != 0 ]] ; then
echo "Please run as root!"
exit 1
fi
function flush_rules() {
$ipt -F # Delete all rules (flush chains)
$ipt -X # Delete all chains
$ipt -Z # Zero all packet and byte counters
$ipt -t nat -F # Flush and
$ipt -t nat -X # delete NAT table
$ipt -t mangle -F # Flush and
$ipt -t mangle -X # delete MANGLE table
$ipt -t raw -F # Flush and
$ipt -t raw -X # delete RAW table
$ipt -t security -F # Flush and
$ipt -t security -X # delete SECURITY table
}
# VARIABLES
# ---------
ipt="$(which iptables)"
ipt_save="$(which iptables-save)"
ipt_restore="$(which iptables-restore)"
rules="/etc/iptables/iptables.rules"
log="LOG --log-level debug --log-tcp-sequence --log-tcp-options --log-ip-options"
rlimit="-m limit --limit 5/m --limit-burst 10"
if [[ $# > 0 ]]; then
if [[ "$1" =~ ^(-d|--disable)$ ]]; then
# Accept everything
$ipt -P INPUT ACCEPT
$ipt -P FORWARD ACCEPT
$ipt -P OUTPUT ACCEPT
ip6tables -P INPUT ACCEPT
ip6tables -P FORWARD ACCEPT
ip6tables -P OUTPUT ACCEPT
flush_rules
ip6tables-restore < /etc/iptables/empty.rules # Cleanup ip6tables
# CONFIGURATION
#--------------
echo 0 > /proc/sys/net/ipv4/ip_forward # Disable IP forward
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all # Enable Ping (echo replies)
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts # Enable echo reply on broadcasts
exit 0
fi
fi
# IPv4 CONFIGURATION
# ==================
# Flushing old rules
flush_rules 'DROP'
# DEFAULT CHAINS
#---------------
$ipt -N DROPLOG
$ipt -A DROPLOG -j $log $rlimit --log-prefix "[IPv4]: "
$ipt -A DROPLOG -j DROP
# CONFIGURATION
#--------------
echo 0 > /proc/sys/net/ipv4/ip_forward # Disable IP forward
echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_all # Disable Ping (echo replies)
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts # Disable echo reply on broadcasts
# DEFAULT RULES
#--------------
$ipt -P OUTPUT ACCEPT # Allow complete outbound traffic
$ipt -A INPUT -i lo -j ACCEPT # Allows all incoming loopback traffic
$ipt -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Allow incoming connections related to existing allowed connections
$ipt -A INPUT -m conntrack --ctstate INVALID -j DROP # Explicitly drop invalid incoming traffic
$ipt -A INPUT -m conntrack --ctstate NEW -p tcp --tcp-flags ALL ALL -j DROP # Make portscanns
$ipt -A INPUT -m conntrack --ctstate NEW -p tcp --tcp-flags ALL NONE -j DROP # a bit harder.
# INBOUND RULES
#--------------
$ipt -A INPUT -i eth0 -m conntrack --ctstate NEW -p udp --dport 5353 -j ACCEPT # DNS (Avahi)
$ipt -A INPUT -i eth0 -m conntrack --ctstate NEW -p udp --dport 67:68 --sport 67:68 -j ACCEPT # DHCP
$ipt -A INPUT -i eth0 -p tcp --dport 63879 -m recent --set --rsource --name MDNS_KNOCK1 -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE0 (MDNS) " --log-level 7
$ipt -A INPUT -i eth0 -p tcp --dport 36978 -m recent --rcheck --rsource --seconds 5 --name MDNS_KNOCK1 -m recent --set --rsource --name MDNS_OPEN_DOOR -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE1 (MDNS) " --log-level 6
$ipt -A INPUT -i eth0 -p tcp --dport 22 -m state --state NEW -m recent --rcheck --rsource --seconds 15 --name MDNS_OPEN_DOOR -j ACCEPT
#$ipt -A INPUT -i wg+ -p icmp --icmp-type 8 -j ACCEPT # ICMP on Wireguard interface
#$ipt -A INPUT -i wg+ -d 192.168.28.1 -p tcp --dport 42341 -m recent --set --rsource --name WG_KNOCK1 -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE0 (WG) " --log-level 7
#$ipt -A INPUT -i wg+ -d 192.168.28.1 -p tcp --dport 24143 -m recent --rcheck --rsource --seconds 5 --name WG_KNOCK1 -m recent --set --rsource --name WG_OPEN_DOOR -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE1 (WG) " --log-level 6
#$ipt -A INPUT -i wg+ -d 192.168.28.1 -p tcp --dport 22 -m state --state NEW -m recent --rcheck --rsource --seconds 15 --name WG_OPEN_DOOR -j ACCEPT # Port knocking (open)
# EXPLICITLY DROP EVERYTHING ELSE
#--------------------------------
$ipt -A INPUT -m conntrack --ctstate NEW -p 2 -j DROP #
$ipt -A INPUT -m conntrack --ctstate NEW -p udp --dport 137 -j DROP # Drop some very
$ipt -A INPUT -m conntrack --ctstate NEW -p udp --dport 138 -j DROP # annoying packets
$ipt -A INPUT -m conntrack --ctstate NEW -p udp --dport 5355 -j DROP # without logging
$ipt -A INPUT -m conntrack --ctstate NEW -p udp --dport 1900 -j DROP #
$ipt -A INPUT -j DROPLOG # Log dropped packets
$ipt -P INPUT DROP # Drop logged packets
$ipt -A FORWARD -j DROPLOG
$ipt -P FORWARD DROP
# Save IPv4 configuration
$ipt_save > $rules
# IPv6 CONFIGURATION
# ==================
# VARIABLES
# ---------
ipt="$(which ip6tables)"
ipt_save="$(which ip6tables-save)"
ipt_restore="$(which ip6tables-restore)"
rules="/etc/iptables/ip6tables.rules"
# CLEANUP
#--------
flush_rules 'DROP'
# DEFAULT CHAINS
#---------------
$ipt -N DROPLOG
$ipt -A DROPLOG -j $log $rlimit --log-prefix "[IPv6]: "
$ipt -A DROPLOG -j DROP
# DEFAULT RULES
#--------------
$ipt -P OUTPUT ACCEPT # Allow complete outbound traffic
$ipt -A INPUT -i lo -j ACCEPT # Allows all incoming loopback traffic
$ipt -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Allow incoming connections related to existing allowed connections
$ipt -A INPUT -m conntrack --ctstate INVALID -j DROP # Explicitly drop invalid incoming traffic
$ipt -A INPUT -m conntrack --ctstate NEW -p tcp --tcp-flags ALL ALL -j DROP # Make portscanns
$ipt -A INPUT -m conntrack --ctstate NEW -p tcp --tcp-flags ALL NONE -j DROP # a bit harder.
# INBOUND RULES
#--------------
$ipt -A INPUT -p icmpv6 -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b --icmpv6-type 128 -j ACCEPT # ICMPv6 Ping
$ipt -A INPUT -i tun+ -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b -p tcp --dport 443 -j ACCEPT # Forwarded to MX using socat
$ipt -A INPUT -i tun+ -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b -p tcp --dport 63725 -m recent --set --rsource --name OCAT_KNOCK1 -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE0 (OCAT) " --log-level 7
$ipt -A INPUT -i tun+ -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b -p tcp --dport 36527 -m recent --rcheck --rsource --seconds 5 --name OCAT_KNOCK1 -m recent --set --rsource --name OCAT_OPEN_DOOR -m limit --limit 5/min -j LOG --log-prefix "SSH PORT KNOCK STATE1 (OCAT) " --log-level 6
$ipt -A INPUT -i tun+ -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b -p tcp --dport 22 -m state --state NEW -m recent --rcheck --rsource --seconds 15 --name OCAT_OPEN_DOOR -j ACCEPT
#$ipt -A INPUT -i tun+ -d fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b -p tcp --dport 5555 --sport 5555 -m state --state NEW -m recent --rcheck --rsource --seconds 15 --name OCAT_OPEN_DOOR -j ACCEPT # Wireguard - Port knocking (open)
# EXPLICITLY DROP EVERYTHING ELSE
#--------------------------------
$ipt -A INPUT -p icmpv6 --icmpv6-type 136 -j DROP # Drop
$ipt -A INPUT -p icmpv6 --icmpv6-type 135 -j DROP # some
$ipt -A INPUT -p icmpv6 --icmpv6-type 133 -j DROP # very
$ipt -A INPUT -p udp --dport 546 -j DROP # annoying
$ipt -A INPUT -p udp --dport 5353 -j DROP # pakets silently
$ipt -A INPUT -j DROPLOG # Log dropped packets
$ipt -P INPUT DROP # Drop logged packets
$ipt -A FORWARD -j DROPLOG
$ipt -P FORWARD DROP
# Save IPv6 configuration and exit gracefully:
$ipt_save > $rules && exit 0
Konfiguration: Client
Ein Autostart von TOR ist auf dem Client sicherlich nicht zwingend erforderlich, hier genügt es die Dienste manuell zu starten:
$ sudo systemctl start tor
$ sudo systemctl start onioncat
Sobald TOR verbunden ist, sollte kurz darauf auch der Onioncat-Dienst verfügbar und somit die IPv6-Adresse des Gateways erreichbar sein.
Bei einem initialen Verbindungsaufbau dürfte in etwa folgendes im systemd journal zu lesen sein.
Die hidden-service ID meines Gateways lautet hier wrg2p2ttysvquls3.onion und die Onioncat Adresse fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b.
$ sudo journalctl -f -u onioncat
[4:connector : info] trying to connect to "wrg2p2ttysvquls3.onion" [fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b] on 11
[4:connector : info] SOCKS connection successfully opened on fd 11
[4:connector : info] inserting peer fd 11 to active peer list
[3:acceptor : info] connection 12 [0] accepted on listener 6 from 127.0.0.1 port 57330
[3:acceptor : info] inserting peer fd 12 to active peer list
Der Verbindungsaufbau kann je nach Bandbreite beider Parteien (bzw. Qualität der Onion-Netzwerkverbindung) mehrere Sekunden (mitunter sogar Minuten) in Anspruch nehmen. Danach werden Ping-Anfragen normal beantwortet:
$ ping fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b
PING fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b(fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b) 56 data bytes
64 bytes from fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b: icmp_seq=3 ttl=64 time=367 ms
64 bytes from fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b: icmp_seq=4 ttl=64 time=306 ms
64 bytes from fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b: icmp_seq=5 ttl=64 time=367 ms
Wenn eine Weile keine Daten ausgetauscht wurden, kann es bei erneutem Verbindungsaufbau wieder etwas dauern. Hier hilft es u.U. das Journal im Auge zu behalten, um andere Fehler auszuschließen.
Wenn der Onioncat-Tunnel besteht sollte der freigegebene, interne Dienst - in meinem Fall - auf Port 443 erreichbar sein:
$ curl -ks https://[fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b]:443
port-knocking
Um sich per SSH zum Gateway verbinden zu können, habe ich ein kleines Script geschrieben, dass mir die ganze
manuelle Arbeit abnimmt. Zuerst wird versucht eine Verbindung via mDNS aufzubauen, hierfür wird der avahi-daemon
gestartet. Wenn der Avahi-Hostname aoe.local innerhalb des angegebenen Timeout-Wertes nicht aufgelöst werden kann,
werden die TOR und Onioncat Dienste ausgeführt. Sobald ein Onioncat-Tunnel zustande gekommen ist, wird versucht eine
SSH-Verbindung zu öffnen. Optional kann zusätzlich noch ein VPN (Wireguard) verbunden werden, das weitere Konfigurationen
auf Gateway und Client voraussetzt.
knock.sh
#!/usr/bin/env bash
# shellcheck disable=SC2034
declare -A MDNS=( [addr]='aoe.local' [ports]='63879,36978' [timeout]='5' [deps]='avahi-daemon.service' )
declare -A ONIONCAT=( [addr]='fd87:d87e:eb43:b44d:a7ea:73c4:ab0a:2e5b' [ports]='63725,36527' [timeout]='300' [deps]='tor,onioncat' )
declare -A WIREGUARD=( [addr]='192.168.28.1' [ports]='42341,24143' [timeout]='100' [deps]='wireguard-client@wg0' )
SSH='ssh -qo UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'
PROTOCOLS=('MDNS' 'ONIONCAT' 'WIREGUARD')
function check_deps() {
declare -n _proto="$1" # MDNS|ONIONCAT|WIREGUARD
IFS=',' read -ra _services <<< "${_proto[deps]}"
for service in "${_services[@]}"; do
if ! systemctl -q is-active "$service"; then
sudo systemctl start "$service"
fi
done
}
function knock() {
local _proto="$1" # 4|6
local _ip="$2"
IFS=',' read -ra _ports <<< "$3"
echo -n "Knocking on ${_ip}: "
i=0
for port in "${_ports[@]}"; do
nc "-${_proto}" -w 1 "$_ip" "$port" >/dev/null 2>&1
((i++))
if [[ "$i" -ne "${#_ports[@]}" ]]; then
echo -n "${port}, "
else
echo "${port}"
fi
done
}
function connect() {
local _proto="$1" # MDNS|ONIONCAT|WIREGUARD
declare -n _params="$_proto"
local _t
case "$_proto" in
MDNS)
echo -n 'Trying to resolve hostname using mDNS..'
res=$(timeout "${_params[timeout]}" avahi-resolve-host-name -4 -n "${_params[addr]}" 2>&1 | awk '{print $2}')
if [[ "$res" == *to* ]] || [[ "$res" == *SIGTERM,* ]]; then
echo 'failed'
return 1
else
echo 'resolved'
knock 4 "$res" "${_params[ports]}"
$SSH "$USER@${res}"
exit 0
fi
;;
ONIONCAT)
echo -n 'Initialising onioncat tunnel..'
_t=0
until ping -6 -w1 -c1 "${_params[addr]}" >/dev/null 2>&1; do
echo -n '.' && ((_t++))
if [[ "$_t" -eq "${_params[timeout]}" ]]; then
echo 'failed'
echo "Error: Unable to establish IPv6 (ocat) tunnel"
return 2
fi
done && echo 'done'
knock 6 "${_params[addr]}" "${_params[ports]}"
$SSH "$USER@${_params[addr]}"
exit 0
;;
WIREGUARD)
echo -n 'Initialising VPN..'
_t=0
until ping -w1 -c1 "${_params[addr]}" >/dev/null 2>&1; do
echo -n '.' && ((t++))
if [[ "$_t" -eq "${_params[timeout]}" ]]; then
echo 'failed'
echo "Error: Unable to establish VPN (WireGuard) connection"
return 3
fi
done && echo 'done'
knock 6 "${_params[addr]}" "${_params[ports]}"
$SSH "$USER@${_params[addr]}"
exit 0
;;
esac
}
for proto in "${PROTOCOLS[@]}"; do
check_deps "$proto"
connect "$proto"
done
Um sich per SSH zum Gateway zu verbinden, genügt es das Script auszuführen:
Bzw. wenn man sich im gleichen Netzwerk wie das Gateway befindet: