Iptables-Grundlagen: Gängige Firewall-Regeln und Befehle

☑️ TODO

Nützliche Iptables-Konfigurationsbeispiele hinzufügen
Nützliche Kernel-Einstellungen (sysctl) hinzufügen
Links zu nützlichen externen Ressourcen hinzufügen
Erweiterte Konfigurationsbeispiele, Befehle und Regeln hinzufügen

Inhaltsverzeichnis

Werkzeuge zur Konfiguration von Iptables
Handbücher/Howtos/Tutorials
Nützliche Kernel-Einstellungen (sysctl)
Wie funktioniert es?
Iptables-Regeln
Erweiterte Konfigurationsbeispiele
- Paketverarbeitung in Python mit NFQUEUE-Ziel
  - ALLE Pakete von bestimmter Quelle auf (filter:INPUT) AKZEPTIEREN und alles andere VERWERFEN
  - Eigenes Port-Knocking-Skript schreiben, um SSH-Zugriff zu sichern

Werkzeuge zur Konfiguration von Iptables

  :small_orange_diamond: Shorewall - erweitertes Gateway/Firewall-Konfigurationstool für GNU/Linux.
  :small_orange_diamond: Firewalld - bietet eine dynamisch verwaltete Firewall.
  :small_orange_diamond: UFW - Standard-Firewall-Konfigurationstool für Ubuntu.
  :small_orange_diamond: FireHOL - bietet einfache und leistungsstarke Konfiguration für alle Linux-Firewall- und Traffic-Shaping-Anforderungen.

Handbücher/Howtos/Tutorials

  :small_orange_diamond: Best practices: iptables - von Major Hayden
  :small_orange_diamond: Ein ausführlicher Leitfaden zu Iptables, der Linux-Firewall
  :small_orange_diamond: Erweiterte Funktionen von netfilter/iptables
  :small_orange_diamond: Linux-Firewalls mit iptables
  :small_orange_diamond: Debuggen von iptables und häufige Firewall-Fallstricke?
  :small_orange_diamond: Netfilter Hacking HOWTO
  :small_orange_diamond: Pro-IP-Ratenbegrenzung mit iptables

Nützliche Kernel-Einstellungen (sysctl)

rp_filter

Deaktivieren der Routing-Triangulation. Antworten auf Anfragen über dieselbe Schnittstelle, nicht über eine andere. Schützt auch vor IP-Spoofing.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/rp_filter = 1 EOF

- [rp_filter und LPIC-3 Linux Security](https://www.theurbanpenguin.com/rp_filter-and-lpic-3-linux-security/)
- [Linux-Kernel-rp_filter-Einstellungen (Reverse path filtering)](https://www.slashroot.in/linux-kernel-rpfilter-settings-reverse-path-filtering)
- [Reverse Path Filtering](http://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.kernel.rpf.html)

##### log_martians

  > _Aktivieren Sie die Protokollierung von Paketen mit fehlerhaften IP-Adressen._```bash
cat << EOF >> /etc/sysctl.d/40-custom.conf
net/ipv4/conf/all/log_martians = 1
EOF

Welchen Nutzen hat das Protokollieren von Martian-Paketen?

send_redirects

Deaktiviert das Senden aller IPv4 ICMP Redirect-Pakete auf allen Schnittstellen.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/send_redirects = 0 EOF

- [Quellrouting deaktivieren](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/security_guide/sect-security_guide-server_security-disable-source-routing)
- [Was sind ICMP-Weiterleitungen und sollten sie blockiert werden?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)

##### accept_source_route

  > _Quellrouting-Pakete deaktivieren (Pakete mit der Option 'Strict Source Route' (SSR) oder 'Loose Source Routing' (LSR) deaktivieren)._```bash
cat << EOF >> /etc/sysctl.d/40-custom.conf
net/ipv4/conf/all/accept_source_route = 0
EOF

accept_redirects

Deaktivieren der Annahme von ICMP-Umleitungen.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/accept_redirects = 0 EOF

- [Was sind ICMP-Weiterleitungen und sollten sie blockiert werden?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)
- [Das Betriebssystem Red Hat Enterprise Linux muss Internet Protocol Version 4 (IPv4) Internet Control Message Protocol (ICMP)-Weiterleitungsnachrichten ignorieren.](https://www.stigviewer.com/stig/red_hat_enterprise_linux_7/2018-11-28/finding/V-73175)

##### tcp_syncookies

  > _SYN-Flood-Schutz aktivieren (Schutz vor Denial-of-Service (DoS)-Angriffen)._```bash
cat << EOF >> /etc/sysctl.d/40-custom.conf
net/ipv4/tcp_syncookies = 1
EOF

icmp_echo_ignore_broadcasts

Antwort auf Ping-Broadcasts deaktivieren.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/icmp_echo_ignore_broadcasts = 1 EOF

- [Was ist ICMP-Broadcast gut?](https://superuser.com/questions/306065/what-is-icmp-broadcast-good-for)
- [Das System darf nicht auf ICMPv4 antworten, das an eine Broadcast-Adresse gesendet wurde.](https://www.stigviewer.com/stig/red_hat_enterprise_linux_6/2018-11-28/finding/V-38535)

##### ip_forward

  > _IP-Routing aktivieren. Erforderlich, wenn Ihre Firewall ein Netzwerk schützt, inklusive NAT._```bash
cat << EOF >> /etc/sysctl.d/40-custom.conf
net/ipv4/ip_forward = 1
EOF

Wie funktioniert es?

Master

Iptables-Regeln

Regeln speichern

Debian-basiert```bash

netfilter-persistent save

###### RedHat-basiert```bash
service iptables save

Liste alle aktiven iptables-Regeln mit verbose auf```bash

iptables -n -L -v

#### Auflisten aller aktiven iptables-Regeln mit numerischen Zeilen und ausführlich```bash
iptables -n -L -v --line-numbers

Alle aktiven iptables-Regeln ausgeben```bash

iptables -S

#### Regeln als Tabellen für INPUT chain```bash
iptables -L INPUT

Alle Regelspezifikationen in der INPUT-Kette ausgeben```bash

iptables -S INPUT

#### Paketzahlen und Gesamtgröße anzeigen```bash
iptables -L INPUT -v

Um INPUT- oder OUTPUT-Chain-Regeln mit nummerierten Zeilen und ausführlich anzuzeigen```bash

iptables -L INPUT -n -v iptables -L OUTPUT -n -v --line-numbers

#### Regel nach Kette und Nummer löschen```bash
iptables -D INPUT 10

Regel nach Spezifikation löschen```bash

iptables -D INPUT -m conntrack --ctstate INVALID -j DROP

#### Alle Regeln Leeren, Alle Ketten Löschen, und Alle Akzeptieren```bash
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

iptables -t nat -F
iptables -t mangle -F
iptables -F
iptables -X

Alle Ketten leeren```bash

iptables -F

#### Leeren einer einzelnen Kette```bash
iptables -F INPUT

Firewall-Regeln einfügen```bash

iptables -I INPUT 2 -s 202.54.1.2 -j DROP

#### Loopback-Verbindungen zulassen```bash
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

Erlaube etablierte und zugehörige eingehende Verbindungen```bash

iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

#### Erlaube etablierte ausgehende Verbindungen```bash
iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT

Intern zu Extern```bash

iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

#### Ungültige Pakete verwerfen```bash
iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

IP-Adresse blockieren```bash

iptables -A INPUT -s 192.168.252.10 -j DROP

#### Block und IP-Adresse und Ablehnen```bash
iptables -A INPUT -s 192.168.252.10 -j REJECT

Blockieren von Verbindungen zu einer Netzwerkschnittstelle```bash

iptables -A INPUT -i eth0 -s 192.168.252.10 -j DROP

#### Allen eingehenden SSH-Verkehr zulassen```bash
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Erlaube eingehende SSH von einer bestimmten IP-Adresse oder einem Subnetz```bash

iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### Ausgehende SSH erlauben```bash
iptables -A OUTPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Erlaube eingehendes Rsync von einer bestimmten IP-Adresse oder einem Subnetz```bash

iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 873 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 873 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### Alle eingehenden HTTP-Verbindungen zulassen```bash
iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 80 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Erlaube allen eingehenden HTTPS-Verkehr```bash

iptables -A INPUT -p tcp --dport 443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 443 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### Alle eingehenden HTTP und HTTPS zulassen```bash
iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate ESTABLISHED -j ACCEPT

MySQL von bestimmter IP-Adresse oder Subnetz erlauben```bash

iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### MySQL auf ein bestimmtes Netzwerk-Interface beschränken```bash
iptables -A INPUT -i eth1 -p tcp --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o eth1 -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT

PostgreSQL von bestimmter IP-Adresse oder Subnetz```bash

iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### PostgreSQL auf bestimmte Netzwerkschnittstelle zulassen```bash
iptables -A INPUT -i eth1 -p tcp --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -o eth1 -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Ausgehende SMTP-Mail blockieren```bash

iptables -A OUTPUT -p tcp --dport 25 -j REJECT

#### Alle eingehenden SMTP zulassen```bash
iptables -A INPUT -p tcp --dport 25 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 25 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Alle eingehenden IMAP zulassen```bash

iptables -A INPUT -p tcp --dport 143 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 143 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### Alle eingehenden IMAPS zulassen```bash
iptables -A INPUT -p tcp --dport 993 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 993 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Alle eingehenden POP3 zulassen```bash

iptables -A INPUT -p tcp --dport 110 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 110 -m conntrack --ctstate ESTABLISHED -j ACCEPT

#### Alle eingehenden POP3S zulassen```bash
iptables -A INPUT -p tcp --dport 995 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 995 -m conntrack --ctstate ESTABLISHED -j ACCEPT

Private Netzwerkadresse auf öffentlicher Schnittstelle verwerfen```bash

iptables -A INPUT -i eth1 -s 192.168.0.0/24 -j DROP iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

#### Alle ausgehenden Verbindungen zu Facebook-Netzwerken blockieren

Holen Sie die Facebook-AS:```bash
whois -h v4.whois.cymru.com " -v $(host facebook.com | grep "has address" | cut -d " " -f4)" | tail -n1 | awk '{print $1}'

Drop:

iptables -A OUTPUT -s "$i" -j REJECT

done

#### Protokollieren und Pakete verwerfen```bash
iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j LOG --log-prefix "IP_SPOOF A: "
iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Standardmäßig wird alles in die Datei /var/log/messages protokolliert:```bash tail -f /var/log/messages grep --color 'IP SPOOF' /var/log/messages

#### Protokollieren und Verwerfen von Paketen mit begrenzter Anzahl von Protokolleinträgen```bash
iptables -A INPUT -i eth1 -s 10.0.0.0/8 -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix "IP_SPOOF A: "
iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

Datenverkehr von MAC-Adressen verwerfen oder akzeptieren```bash

iptables -A INPUT -m mac --mac-source 00:0F:EA:91:04:08 -j DROP iptables -A INPUT -p tcp --destination-port 22 -m mac --mac-source 00:0F:EA:91:04:07 -j ACCEPT

#### ICMP Ping Request blockieren oder zulassen```bash
iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
iptables -A INPUT -i eth1 -p icmp --icmp-type echo-request -j DROP

Mehrere Ports mit `multiport` angeben```bash

iptables -A INPUT -i eth0 -p tcp -m state --state NEW -m multiport --dports ssh,smtp,http,https -j ACCEPT

#### Lastausgleich mit `random*` oder `nth*````bash
_ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")

for ip in "${_ips[@]}" ; do
  iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m nth --counter 0 --every 4 --packet 0 \
    -j DNAT --to-destination ${ip}:80
done

oder```bash _ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")

for ip in "${_ips[@]}" ; do iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m random --average 25
-j DNAT --to-destination ${ip}:80 done

#### Einschränkung der Anzahl der Verbindungen mit `limit` und `iplimit*````bash
iptables -A FORWARD -m state --state NEW -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
    -m limit --limit 20/hour --limit-burst 5 -j ACCEPT

oder```bash iptables -A INPUT -p tcp -m state --state NEW --dport http -m iplimit --iplimit-above 5 -j DROP

#### Verwalten einer Liste aktueller Verbindungen zum Abgleich```bash
iptables -A FORWARD -m recent --name portscan --rcheck --seconds 100 -j DROP
iptables -A FORWARD -p tcp -i eth0 --dport 443 -m recent --name portscan --set -j DROP

Abgleich gegen eine `string*` in den Daten-Nutzdaten eines Pakets```bash

iptables -A FORWARD -m string --string '.com' -j DROP iptables -A FORWARD -m string --string '.exe' -j DROP

#### Zeitbasierte Regeln mit `time*````bash
iptables -A FORWARD -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
    -m time --timestart 21:30 --timestop 22:30 --days Mon,Tue,Wed,Thu,Fri -j ACCEPT

Paketabgleich basierend auf TTL-Werten```bash

iptables -A INPUT -s 1.2.3.4 -m ttl --ttl-lt 40 -j REJECT

#### Schutz vor Port-Scans```bash
iptables -N port-scanning
iptables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN
iptables -A port-scanning -j DROP

SSH Brute-Force-Schutz```bash

iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --set iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 10 -j DROP

#### Syn-flood-Schutz```bash
iptables -N syn_flood

iptables -A INPUT -p tcp --syn -j syn_flood
iptables -A syn_flood -m limit --limit 1/s --limit-burst 3 -j RETURN
iptables -A syn_flood -j DROP

iptables -A INPUT -p icmp -m limit --limit  1/s --limit-burst 1 -j ACCEPT

iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j LOG --log-prefix PING-DROP:
iptables -A INPUT -p icmp -j DROP

iptables -A OUTPUT -p icmp -j ACCEPT

Abschwächung von SYN-Fluten mit SYNPROXY```bash

iptables -t raw -A PREROUTING -p tcp -m tcp --syn -j CT --notrack iptables -A INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460 iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

#### Blockiere neue Pakete, die nicht SYN sind```bash
iptables -A INPUT -p tcp ! --syn -m state --state NEW -j DROP

oder```bash iptables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP

#### Force Fragments-Paketprüfung```bash
iptables -A INPUT -f -j DROP

XMAS packets```bash

iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP

#### Alle NULL-Pakete verwerfen```bash
iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP

Ungewöhnliche MSS-Werte blockieren```bash

iptables -t mangle -A PREROUTING -p tcp -m conntrack --ctstate NEW -m tcpmss ! --mss 536:65535 -j DROP

#### Pakete mit gefälschten TCP-Flags blockieren```bash
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP
iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP

Pakete aus privaten Subnetzen blockieren (Spoofing)```bash

_subnets=("224.0.0.0/3" "169.254.0.0/16" "172.16.0.0/12" "192.0.2.0/24" "192.168.0.0/16" "10.0.0.0/8" "0.0.0.0/8" "240.0.0.0/5")

for _sub in "${_subnets[@]}" ; do iptables -t mangle -A PREROUTING -s "$_sub" -j DROP done iptables -t mangle -A PREROUTING -s 127.0.0.0/8 ! -i lo -j DROP

## Erweiterte Konfigurationsbeispiele

### Paketverarbeitung in Python mit NFQUEUE-Ziel

  > _Dieses Ziel leitet das Paket mithilfe des nfnetlink_queue-Handlers an den Userspace weiter. Das Paket wird in die Warteschlange gestellt, die durch ihre 16-Bit-Warteschlangennummer identifiziert wird. Der Userspace kann das Paket bei Bedarf inspizieren und modifizieren. Der Userspace muss das Paket dann verwerfen oder wieder in den Kernel einspeisen._

#### ACCEPT alle Pakete von einer bestimmten Quelle auf (filter:INPUT) und DROP alles andere

  > _Diese Regel leitet alle filter:INPUT-Pakete mit dem NFQUEUE-Ziel an Warteschlange 1 weiter._```bash
iptables -A INPUT -j NFQUEUE --queue-num 1

Skript zum Binden an netfilter queue 1 und zum Verarbeiten von Paketen.```python #!/usr/bin/python3

from netfilterqueue import NetfilterQueue from scapy.all import *

def packetanalyzer(pkt): ip=IP(pkt.get_payload()) if(ip.src=="192.168.122.1"): print(f"New packet from {ip.src}") pkt.accept() else: pkt.drop()

nfqueue=NetfilterQueue() nfqueue.bind(1, packetanalyzer) nfqueue.run()

#### Schreiben Sie Ihr eigenes Port-Knocking-Skript, um den SSH-Zugriff zu sichern

  > _Alle SSH-Anfragen ablehnen (DROP) und geheime Port-Anfragen mit dem NFQUEUE-Ziel an den Benutzerraum senden._```bash
iptables -t filter -I INPUT -p tcp --dport 22 -j DROP
iptables -t raw -I PREROUTING -p tcp --sport 65534 --dport 65535 -j NFQUEUE --queue-num 1

_Dieses Skript erfasst Pakete aus netfilter queue 1 und prüft SOURCEPORT und SECRETPORT für Port Knocking und erlaubt der Quelle, sich für EXPIRETIME mit SSH zu verbinden, Standard ist 30 Minuten.```python #!/usr/bin/python3

from os import system from netfilterqueue import NetfilterQueue from scapy.layers.inet import IP from time import time

SOURCEPORT=65534 SECRETPORT=65535 EXPIRETIME=30 ALLOWED={}

def portknocking(pkt): packet=IP(pkt.get_payload()) currtime=time() for item in list(ALLOWED): if(currtime-ALLOWED[item] >= EXPIRETIME*60): del ALLOWED[item] if(packet.sport==SOURCEPORT and packet.dport==SECRETPORT and packet.src not in ALLOWED): print(f"Port {packet.dport} knocked by {packet.src}:{packet.sport}") system(f"iptables -I INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT") system(f"echo 'iptables -D INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT' | at now + {EXPIRETIME} minutes") ALLOWED[packet.src]=time() pkt.drop()

nfqueue=NetfilterQueue() nfqueue.bind(1, portknocking)

try: nfqueue.run() except KeyboardInterrupt: print("\nExit with Keyboard Interrupt")

> _Um Port-Knocking durchzuführen und SSH-Verbindungen von Ihrem Computer zu erlauben, führen Sie einfach diesen Befehl aus:_```bash
nc -p 65534 SERVER 65535

iptables-essentials

Beliebteste