Ich bin mir sicher, dass Linux-Systemadministratoren mit iptablesder Benutzeroberfläche des netfilterPaketfilter-Frameworks vertraut sind .

Diese "Frage" soll nun ein Community-Wiki zum Sammeln verschiedener Teile der iptablesWeisheit sein. Nichts ist zu gewöhnlich oder zu dunkel. Veröffentlichen Sie alles, was Sie wissen, damit andere das Beste daraus machen können iptables.

Verwenden von Whitelist und Blacklist mit Iptables

#!/bin/bash

WHITELIST=/whitelist.txt
BLACKLIST=/blacklist.txt

#THIS WILL CLEAR ALL EXISTING RULES!
echo 'Clearing all rules'
iptables -F

#
## Whitelist
#

for x in `grep -v ^# $WHITELIST | awk '{print $1}'`; do
        echo "Permitting $x..."
        $IPTABLES -A INPUT -t filter -s $x -j ACCEPT
done

#
## Blacklist
#

for x in `grep -v ^# $BLACKLIST | awk '{print $1}'`; do
        echo "Denying $x..."
        $IPTABLES -A INPUT -t filter -s $x -j DROP
done

Skript zum Öffnen von Ports

#!/bin/bash
ALLOWEDTCP="80 3128 3784"
ALLOWEDUDP="3128 3784"

#
## Permitted Ports
#

for port in $ALLOWEDTCP; do
       echo "Accepting port TCP $port..."
       $IPTABLES -A INPUT -t filter -p tcp --dport $port -j ACCEPT
done

for port in $ALLOWEDUDP; do
        echo "Accepting port UDP $port..."
        $IPTABLES -A INPUT -t filter -p udp --dport $port -j ACCEPT
done

Portscan wird blockiert

# Attempt to block portscans
# Anyone who tried to portscan us is locked out for an entire day.
iptables -A INPUT   -m recent --name portscan --rcheck --seconds 86400 -j DROP
iptables -A FORWARD -m recent --name portscan --rcheck --seconds 86400 -j DROP

# Once the day has passed, remove them from the portscan list
iptables -A INPUT   -m recent --name portscan --remove
iptables -A FORWARD -m recent --name portscan --remove

# These rules add scanners to the portscan list, and log the attempt.
iptables -A INPUT   -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A INPUT   -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP

iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j LOG --log-prefix "Portscan:"
iptables -A FORWARD -p tcp -m tcp --dport 139 -m recent --name portscan --set -j DROP

Gefälschte / ungültige Pakete

# Reject spoofed packets
# These adresses are mostly used for LAN's, so if these would come to a WAN-only server, drop them.
iptables -A INPUT -s 10.0.0.0/8 -j DROP
iptables -A INPUT -s 169.254.0.0/16 -j DROP
iptables -A INPUT -s 172.16.0.0/12 -j DROP
iptables -A INPUT -s 127.0.0.0/8 -j DROP

#Multicast-adresses.
iptables -A INPUT -s 224.0.0.0/4 -j DROP
iptables -A INPUT -d 224.0.0.0/4 -j DROP
iptables -A INPUT -s 240.0.0.0/5 -j DROP
iptables -A INPUT -d 240.0.0.0/5 -j DROP
iptables -A INPUT -s 0.0.0.0/8 -j DROP
iptables -A INPUT -d 0.0.0.0/8 -j DROP
iptables -A INPUT -d 239.255.255.0/24 -j DROP
iptables -A INPUT -d 255.255.255.255 -j DROP

# Drop all invalid packets
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A FORWARD -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state INVALID -j DROP

Block Schlumpf Angriffe

# Stop smurf attacks
iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
iptables -A INPUT -p icmp -m icmp -j DROP

# Drop excessive RST packets to avoid smurf attacks
iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT

ICMP blockieren (auch bekannt als Ping)

# Don't allow pings through
iptables -A INPUT -p icmp -m icmp --icmp-type 8 -j DROP

Optimieren Sie die Leistung von netfilter mit ipset

Wenn Sie viele ähnliche Regeln auf der Basis von IP, Port oder beidem schreiben , sollten Sie erwägen, ipsetdie Leistung von Netfilter zu optimieren.

Zum Beispiel:

iptables -s 192.168.1.11 -j ACCEPT
iptables -s 192.168.1.27 -j ACCEPT
iptables -s 192.168.1.44 -j ACCEPT
... hundreds of similar rules ...
iptables -s 192.168.251.177 -j ACCEPT

Dies bedeutet, dass ein Paket mit der Quelladresse 192.168.251.177 zuerst Hunderte von Regeln durchlaufen muss, bevor es sein ACCEPT-Urteil erhalten kann.

Natürlich teilen erfahrene Systemadministratoren die Regeln nach Subnetz auf. Das bedeutet aber immer noch Hunderte von Regeln.

ipset zur Rettung!

Definieren Sie zunächst ein IP-Set vom ipmapTyp:

ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16

Dann füllen Sie es mit den Adressen:

for ip in $LIST_OF_ALLOWED_IP; do ipset -A Allowed_Hosts $ip; done

Ersetzen Sie abschließend die obigen Hunderte von iptables-Regeln durch eine Regel:

iptables -m set --match-set Allowed_Hosts src -j ACCEPT

Wenn ein Paket eintrifft, führt netfilter eine sehr schnelle Bitmap-Suche nach der Quell-IP (src) des Pakets anhand des Allowed_HostsIP-Satzes durch. Für alle Pakete, die von 192.168.0.0/16 stammen, gilt eine Regel. Und glauben Sie mir, dass das Durchsuchen einer Bitmap mindestens zwei Größenordnungen schneller ist als das Durchführen von Hunderten von Iptables-Regelprüfungen.

ipsetist nicht auf IP-Adressen beschränkt. Es kann auch basierend auf Ports, IP-Port-Tupel, Netzwerk- / Subnetz-Adressen, IP-MAC-Tupel usw. übereinstimmen. Und es kann diesen Kriterien als Quelle oder Ziel oder als Mischung aus beiden (im Fall von Tupeln) entsprechen.

Und schließlich können ipsetSie mit IP-Adressen automatisch in Blacklists / Whitelists setzen. Diese Blacklists / Whitelists können auch "altern" und somit die IP-Adresse automatisch löschen, nachdem eine konfigurierbare Zeitspanne verstrichen ist.

Weitere Informationen finden Sie in ipsetder Manpage von.

SEHR WICHTIGER HINWEIS:

Einige Linux-Distributionen unterstützen möglicherweise nicht "out-of-the-box" ipset(z. B. Ubuntu 10.04 hatte dieses Problem). Auf diesen Systemen besteht eine Methode darin, ipsetaus dem Quellcode zu installieren .

Laden Sie stattdessen den ipsetQuellcode von der Website herunter: http://ipset.netfilter.org/install.html

Wenn Sie Alternativ verwenden xtables-addons, ipset ist in der Quelle enthalten: http://xtables-addons.sourceforge.net/

Fügen Sie Kommentare zu Ihren Regeln hinzu:

-m comment --comment "Comments help to read output of iptables -nvL"

Blockieren Sie bekannte TCP-Angriffe

Fügen Sie die folgenden Regeln hinzu, vorzugsweise in -t raw -A PREROUTING

-p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
-p tcp --tcp-flags SYN,RST SYN,RST -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,PSH,URG -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
-p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG FIN,SYN,RST,PSH,ACK,URG -j DROP

Die Angriffe, die geblockt werden, sind:

• SYN-FIN-Angriff
• SYN-RST-Angriff
• Weihnachtsangriff
• nmap FIN scan
• NULLflags greifen an
• ALLflags greifen an

(Fühlen Sie sich frei, die Namen der oben genannten Angriffe zu bearbeiten.)

NAT aktivieren

1. echo 1 > /proc/sys/net/ipv4/ip_forward
2. /sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

In Schritt 1 wird der Kernel-Parameter so festgelegt, dass IP-Weiterleitungen möglich sind. In Schritt 2 wird eine iptables-Regel eingerichtet, mit der NAT auf der Schnittstelle eth0 aktiviert wird.

Blockieren Sie ICMP-Angriffe

Fügen Sie die folgenden Regeln hinzu, vorzugsweise in -t raw -A PREROUTING

-p icmp -m u32 ! --u32 "4&0x3FFF=0"   -j DROP
-p icmp -m length --length 1492:65535 -j DROP

Die erste Regel blockiert alle ICMP-Pakete, deren "Fragmentierungsflag" nicht 0 ist. (ICMP sollte niemals fragmentiert werden; sie sollten kleine Nutzdaten enthalten.)

Die zweite Regel blockiert übergroße, nicht fragmentierte ICMP-Pakete.

Verwenden von FireHOL - dem praktischen iptables-Wrapper

Ich fand es viel intuitiver als direkte Iptables-Befehle. Speziell für Leute mit Erfahrung mit anderen Firewalls:

FireHOL ist ein iptables-Firewall-Generator, der Stateful-iptables-Paketfilter-Firewalls auf Linux-Hosts und -Routern mit einer beliebigen Anzahl von Netzwerkschnittstellen, einer beliebigen Anzahl von Routen, einer beliebigen Anzahl von Diensten und einer beliebigen Anzahl von Komplexitäten zwischen Variationen der Dienste (einschließlich positiver und negativer) erstellt Ausdrücke).

(aus meiner iptables_tricks.txt-Datei, die an vielen Stellen neu kompiliert wurde: P)

Lässt iptables zwischen neuen Verbindungen von derselben IP an Port 22 (SSH) 15 Sekunden warten:

 iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
 iptables -A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT

IPTABLES-Video-Tutorials

Folge 1 http://www.youtube.com/watch?v=ldB8kDEtTZA&feature=player_embedded

Folge 2 http://www.youtube.com/watch?v=aDaEXxRHeXY&feature=related

Letzte Episode

http://www.youtube.com/watch?v=JojqHKcSxpo&feature=player_embedded

Ein guter Start für jeden Neuling.

IP-Sets überarbeitet

Es gibt bereits eine Antwort, in der IP-Sätze erwähnt werden. Es ist jedoch insofern eindimensional, als es sich auf die Leistungsverbesserungen gegenüber klassischen Regeln und die Tatsache konzentriert, dass IP-Sätze das Problem mit vielen individuellen IP-Adressen mildern, die in der CIDR-Notation nicht einfach als Subnetz ausgedrückt werden können.

Notation unten verwendet

Denn ipsetich werde die Notation verwenden, die von gelesen ipset restoreund von geschrieben wurde ipset save.

Entsprechend werde ich für iptables(und ip6tables) Regeln die Notation so verwenden, wie sie gelesen iptables-restoreund geschrieben wurde iptables-save. Dies führt zu einer kürzeren Schreibweise und ermöglicht es mir, potenzielle Nur-IPv4- Regeln (mit Präfix -4) oder Nur-IPv6- -6Regeln (mit Präfix ) hervorzuheben .

In einigen Beispielen leiten wir den Paketfluss in eine andere Kette um. Es wird davon ausgegangen, dass die Kette zu diesem Zeitpunkt vorhanden ist, sodass die Linien zum Erstellen der Ketten nicht erstellt werden (auch der Tabellenname oder die COMMITam Ende angeführten Befehle werden nicht erwähnt ).

Erweiterte IP-Sätze

IP-Sets können viel mehr als in der anderen Antwort erwähnt, und Sie sollten auf jeden Fall die IP-Set-Dokumentation ( ipset(8)) zusammen mit iptables-extensions(8)diesem kurzen Eintrag hier lesen .

Zum Beispiel werde konzentriere ich mich hauptsächlich auf drei Satztypen: hash:ip, hash:netund list:set, aber es gibt mehr als diejenigen , und sie alle gültigen Anwendungsfälle haben.

Sie können zum Beispiel auch Portnummern abgleichen, nicht nur IP-Adressen .

Speichern und Wiederherstellen von IP-Sets wie mit iptables-saveundiptables-restore

Sie können IP-Satzdeklarationen in großen Mengen erstellen und durch Weiterleiten in importieren ipset restore. Wenn Sie Ihren Befehl widerstandsfähiger gegenüber bereits vorhandenen Einträgen machen möchten, verwenden Sie ipset -exist restore.

Wenn sich Ihre Regeln in einer Datei mit dem Namen befinden default.set, würden Sie Folgendes verwenden:

ipset -exist restore < default.set

Eine solche Datei kann Einträge zu createSets und zu addEinträgen darin enthalten . Im Allgemeinen scheinen die meisten Befehle von der Befehlszeile eine entsprechende Version in den Dateien zu haben. Beispiel (Erstellen einer Reihe von DNS-Servern):

create dns4 hash:ip family inet
create dns6 hash:ip family inet6
# Google DNS servers
add dns4 8.8.8.8
add dns4 8.8.4.4
add dns6 2001:4860:4860::8888
add dns6 2001:4860:4860::8844

Hier wird ein Satz für IPv4 ( dns4) und ein Satz für IPv6 ( dns6) erstellt.

Zeitüberschreitungen bei IP-Sätzen

Zeitüberschreitungen in IP-Sätzen können sowohl pro Satz als auch pro Eintrag als Standard festgelegt werden. Dies ist sehr nützlich für Szenarien, in denen Sie jemanden vorübergehend blockieren möchten (z. B. zum Scannen von Ports oder zum Versuch, Ihren SSH-Server zu brachialisieren).

Dies funktioniert folgendermaßen (Standardeinstellung bei der Erstellung von IP-Sets):

create ssh_loggedon4 hash:ip  family inet  timeout 5400
create ssh_loggedon6 hash:ip  family inet6 timeout 5400
create ssh_dynblock4 hash:ip  family inet  timeout 1800
create ssh_dynblock6 hash:ip  family inet6 timeout 1800

Wir werden im Folgenden auf diese speziellen Sets zurückkommen und die Gründe dafür erläutern, warum sie so eingestellt sind, wie sie sind.

Wenn Sie Ihr Timeout für eine bestimmte IP-Adresse festlegen möchten, können Sie einfach sagen:

add ssh_dynblock4 1.2.3.4 timeout 7200

So blockieren Sie IP 1.2.3.4 für zwei Stunden anstelle der (festgelegten) Standard-halben Stunde.

Wenn Sie sich das ipset save ssh_dynblock4nach kurzer Zeit ansehen würden, würden Sie etwas in etwa so sehen:

create ssh_dynblock4 hash:ip family inet hashsize 1024 maxelem 65536 timeout 1800
add ssh_dynblock4 1.2.3.4 timeout 6954

Timeout-Vorbehalte

• Zeitüberschreitungen sind eine Funktion in jedem Satz. Wenn sich das Gerät nicht wurde erstellt mit Timeout - Unterstützung wird ein Fehler (zB erhalten Kernel error received: Unknown error -1).
• Zeitüberschreitungen werden in Sekunden angegeben. Verwenden Sie Bash-arithmetische Ausdrücke, um beispielsweise von Minuten zu Sekunden zu gelangen. Z.B:sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))

Überprüfen, ob ein Eintrag in einem bestimmten IP-Satz vorhanden ist

In Ihren Skripten kann es hilfreich sein, zu überprüfen, ob bereits ein Eintrag vorhanden ist. Dies kann erreicht werden ipset test, indem null zurückgegeben wird, wenn der Eintrag vorhanden ist, andernfalls ungleich null. So können die üblichen Prüfungen in einem Skript angewendet werden:

if ipset test dns4 8.8.8.8; then
  echo "Google DNS is in the set"
fi

In vielen Fällen möchten Sie jedoch lieber den -existSchalter verwenden, ipsetum ihn anzuweisen, sich nicht über vorhandene Einträge zu beschweren.

IP-Sätze aus iptablesRegeln auffüllen

Dies ist meiner Meinung nach eine der Killerfunktionen von IP-Sets. Sie können nicht nur mit den Einträgen eines IP-Sets abgleichen, sondern auch einem vorhandenen IP-Set neue Einträge hinzufügen.

Zum Beispiel haben Sie in dieser Antwort auf diese Frage:

-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --update --seconds 15 -j DROP
-A INPUT -p tcp -i eth0 -m state --state NEW --dport 22 -m recent --set -j ACCEPT

... mit der Absicht, Verbindungsversuche zu SSH (TCP-Port 22) einzuschränken. Das verwendete Modul recentprotokolliert die letzten Verbindungsversuche. Anstelle des stateModuls bevorzuge ich jedoch das conntrackModul.

# Say on your input chain of the filter table you have
   -A INPUT -i eth+ -p tcp --dport ssh -j SSH
# Then inside the SSH chain you can
# 1. create an entry in the recent list on new connections
   -A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
# 2. check whether 3 connection attempts were made within 2 minutes
#    and if so add or update an entry in the ssh_dynblock4 IP set
-4 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock4 src --exist
-6 -A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock6 src --exist
# 3. last but not least reject the packets if the source IP is in our
#    IP set
-4 -A SSH -m set --match-set ssh_dynblock4 src -j REJECT
-6 -A SSH -m set --match-set ssh_dynblock6 src -j REJECT

In diesem Fall leite ich den Fluss in die SSHKette um, sodass ich mich nicht -p tcp --dport sshfür jede einzelne Regel wiederholen muss .

Wiederholen:

• -m setmacht darauf iptablesaufmerksam, dass wir Switches des setModuls verwenden (das IP-Sets verarbeitet)
• --match-set ssh_dynblock4 srcWeist iptablesan, die source ( src) -Adresse mit der benannten set ( ssh_dynblock4) -Adresse abzugleichen
  • dies entspricht sudo ipset test ssh_dynblock4 $IP(wo $IPenthält die Quell-IP-Adresse für das Paket)
• -j SET --add-set ssh_dynblock4 src --existFügt die source ( src) -Adresse aus dem Paket zur IP-Gruppe hinzu oder aktualisiert sie ssh_dynblock4. Wenn ein Eintrag existiert ( --exist), wird er einfach aktualisiert.
  • dies entspricht sudo ipset -exist add ssh_dynblock4 $IP(wo $IPenthält die Quell-IP-Adresse für das Paket)

Wenn Sie stattdessen die Ziel- / Zieladresse abgleichen möchten, verwenden Sie dststatt src. Weitere Optionen finden Sie im Handbuch.

Sätze von Sätzen

IP-Sets können andere Sets enthalten. Wenn Sie dem Artikel bis hierher gefolgt sind, haben Sie sich gefragt, ob es möglich ist, Sets zu kombinieren. Und natürlich ist es das auch. Für die IP - Sets von oben wir zwei Gelenksätze erstellen können ssh_dynblockund ssh_loggedonjeweils die enthalten nur IPv4-und IPv6-Sets:

create ssh_loggedon4 hash:ip  family inet  timeout 5400
create ssh_loggedon6 hash:ip  family inet6 timeout 5400
create ssh_dynblock4 hash:ip  family inet  timeout 1800
create ssh_dynblock6 hash:ip  family inet6 timeout 1800
# Sets of sets
create ssh_loggedon  list:set
create ssh_dynblock  list:set
# Populate the sets of sets
add ssh_loggedon ssh_loggedon4
add ssh_loggedon ssh_loggedon6
add ssh_dynblock ssh_dynblock4
add ssh_dynblock ssh_dynblock6

Und die nächste Frage , die in Ihrem Kopf auftauchen sollten , ist , ob dies uns erlaubt zu passen und und IP - Sets in einer IP - Version unabhängige Art und Weise zu manipulieren.

Und die Antwort darauf lautet: JA! (Leider wurde dies nicht explizit dokumentiert, als ich das letzte Mal nachgesehen habe)

Infolgedessen können die Regeln aus dem vorherigen Abschnitt folgendermaßen umgeschrieben werden:

-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT

Das ist viel prägnanter. Und ja, das ist bewährt und wirkt wie ein Zauber.

Alles zusammen: SSH-Brute-Force-Verteidigung

Auf meinen Servern wird ein Skript als cronJob ausgeführt, der eine Reihe von Hostnamen aufnimmt, diese in IP-Adressen auflöst und dann in die IP-Gruppe für "vertrauenswürdige Hosts" eingibt. Die Idee ist, dass vertrauenswürdige Hosts mehr Versuche erhalten, sich am Server anzumelden, und nicht unbedingt so lange gesperrt werden, wie andere.

Umgekehrt haben ganze Länder die Verbindung zu meinem SSH-Server gesperrt, mit der (potenziellen) Ausnahme von vertrauenswürdigen Hosts (dh die Reihenfolge der Regeln ist von Bedeutung).

Dies ist jedoch eine Übung für den Leser. Hier möchte ich eine saubere Lösung hinzufügen, die die im Set enthaltenen Sätze verwendet, ssh_loggedonum zu ermöglichen, dass nachfolgende Verbindungsversuche weitergeleitet werden und nicht der gleichen Prüfung unterliegen wie die anderen Pakete.

Es ist wichtig, die Standard-Zeitüberschreitungen von 90 Minuten für ssh_loggedonund 30 Minuten für ssh_dynblockdie folgenden iptablesRegeln zu berücksichtigen:

-A INPUT -i eth+ -p tcp --dport ssh -j SSH
-A SSH -m set --match-set ssh_loggedon src -j ACCEPT
-A SSH -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
-A SSH -m conntrack --ctstate NEW -m recent --set --name tarpit
-A SSH -m conntrack --ctstate NEW -m recent --rcheck --seconds 120 --hitcount 3 --name tarpit -j SET --add-set ssh_dynblock src --exist
-A SSH -m set --match-set ssh_dynblock src -j REJECT

Inzwischen sollten Sie sich fragen, wie die IP-Adresse der Verbindung in die ssh_loggedonUntergruppen gelangt. Also lesen Sie weiter ...

Bonus: Hinzufügen der IP, mit der Sie sich bei der SSH-Anmeldung anmelden

Wenn Sie mit sshrcFreunden experimentiert haben , haben Sie von seinen Mängeln erfahren. Aber PAM kommt zur Rettung. Ein Modul namens pam_exec.soermöglicht es uns, ein Skript während der SSH-Anmeldung an einem Punkt aufzurufen, an dem wir wissen, dass der Benutzer zugelassen ist.

Fügen Sie /etc/pam.d/sshdunter den Einträgen pam_envund pam_selinuxdie folgende Zeile hinzu:

session    optional     pam_exec.so stdout /path/to/your/script

und stellen Sie sicher, dass Ihre Version des Skripts ( /path/to/your/scriptoben) vorhanden und ausführbar ist.

PAM verwendet Umgebungsvariablen, um zu kommunizieren, was gerade vor sich geht, sodass Sie ein einfaches Skript wie das folgende verwenden können:

#!/bin/bash
# When called via pam_exec.so ...
SETNAME=ssh_loggedon
if [[ "$PAM_TYPE" == "open_session" ]] && [[ -n "$PAM_RHOST" ]]; then
    [[ "x$PAM_RHOST" != "x${PAM_RHOST//:/}" ]] && SETNAME="${SETNAME}6" || SETNAME="${SETNAME}4"
    ipset -exist add $SETNAME "$PAM_RHOST"
fi

Leider ipsetscheint das Dienstprogramm nicht die eingebauten Smarts von Netfilter zu haben. Daher müssen wir beim Hinzufügen unseres Eintrags zwischen IPv4- und IPv6-IP-Sätzen unterscheiden. Andernfalls ipsetwird davon ausgegangen, dass wir dem Satz von Sätzen anstelle der IP einen weiteren Satz hinzufügen möchten . Und natürlich ist es unwahrscheinlich, dass ein Set nach einer IP benannt wird :)

In diesem Fall überprüfen wir :die IP-Adresse und hängen sie 6an den festgelegten Namen an 4.

Das Ende.

Eine andere GUI, die zum Konfigurieren von iptables verwendet werden kann, ist Firewall Builder . Benutzer können Regelelemente als Objekte in einer Datenbank erstellen und diese Objekte dann per Drag & Drop in einen Regeleditor ziehen, um die gewünschte Firewall-Richtlinie zu erstellen. Die Anwendung generiert dann eine Skriptdatei mit allen iptables-Befehlen, die zum Implementieren der Regeln erforderlich sind.

Im Gegensatz zu einigen anderen iptables-GUI-Lösungen, bei denen Sie jeweils nur eine iptables-Konfiguration verwalten können, können Sie mit Firewall Builder eine große Anzahl von iptables-Konfigurationen von einer einzigen Anwendung aus verwalten. Firewall Builder läuft unter Linux, Windows und Mac OS X, gibt es seit über 10 Jahren und hat Tausende von aktiven Benutzern auf der ganzen Welt.

Vollständige Offenlegung - Ich bin Mitbegründer von NetCitadel, dem Unternehmen, das Firewall Builder entwickelt.

Ausgehende Verbindung mit UID protokollieren

iptables -A OUTPUT -m state --state NEW -m tcp -p tcp -m limit --limit 5/m -j LOG --log-uid --log-prefix="outgoing connection: "

Port- / Verbindungsweiterleitung:

iptables -A PREROUTING -t nat -i eth1 -p tcp --dport 80 -j DNAT --to 10.0.1.7:80
iptables -A INPUT -p tcp -m state --state NEW --dport 80 -i eth1 -j ACCEPT

Ordnen Sie mehrere Schnittstellennamen einem Platzhalter zu

Beispiel: Sie haben eth0 und eth1 möchten Datenverkehr zwischen ihnen zulassen?

iptables -A FORWARD -i eth+ -o eth+ -j ACCEPT

Ich habe dies in der Vergangenheit verwendet, um den veth<something>von LXC dynamisch erstellten und benannten Schnittstellen zu entsprechen. So kann ich mit auf einmal mithalten veth+.

Ich habe auch absichtlich einige Schnittstellen benannt, _<something>um sie abzugleichen _+.

Blockieren Sie ungewöhnliche MSS-Werte

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

SYNPROXY-Ziel für DDos-Schutz

Der Zweck dieses Ziels besteht darin, zu überprüfen, ob der Host, der das SYN-Paket gesendet hat, die Verbindung herstellt oder nach dem Einleiten der SYN-Verbindung nichts unternimmt. Wenn es nichts tut, verwirft es das Paket mit minimalem Aufwand.

Legen Sie die Syn-Pakete für die Verbindungsverfolgungstabelle in der Basistabelle fest

iptables -t raw -A PREROUTING -p tcp -m tcp --dport 80 --syn -j CT --notrack

Aktivieren Sie Synproxy für http-Server:

iptables -A INPUT -p tcp -m tcp --dport 80 -m conntrack --ctstate INVALID,UNTRACKED \
-j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460

Ressource: SYNPROXY-Ziel aus dem RHEL-Blog

Begrenzen aller einzelnen IP-Adressen auf ein ausgehendes Bandbreitenkontingent mit IP-Sets

Sie können Ihren Server so konfigurieren, dass nur jede einzelne IP-Adresse eine Bandbreite von 15 Gigabyte pro Monat zulässt, in der Hoffnung, einen Angriff auf die Bandbreitennutzung zu reflektieren oder ihm auszuweichen, möglicherweise aufgrund Ihres gemessenen Bandbreitenkontingents bei Ihrem Internetdienstanbieter. Dies kann folgendermaßen erreicht werden:

Erstellen Sie zunächst die IP-Sets für IPv4 und IPv6:

ipset create IP_QUOTA_SET_OUT hash:ip timeout 345600 counters
ipset create IP_QUOTA_SET_OUT_INET6 hash:ip timeout 345600 counters family inet6

Fügen Sie nun Ihre iptables-Regeln hinzu. In der ersten Zeile wird die IP zum Satz hinzugefügt, sofern sie nicht bereits vorhanden ist. Die zweite Zeile stimmt nicht überein, wenn die für die IP im Satz übertragenen Bytes größer als die angegebene Menge sind. Das Gleiche gilt dann auch für IPv6.

iptables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT dst -j SET --add-set IP_QUOTA_SET_OUT dst --timeout 345600
iptables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT dst --bytes-gt 16106127360 -j DROP

ip6tables -I OUTPUT -m set ! --match-set IP_QUOTA_SET_OUT_INET6 src -j SET --add-set IP_QUOTA_SET_OUT_INET6 src --timeout 345600
ip6tables -I OUTPUT -m set --match-set IP_QUOTA_SET_OUT_INET6 src --bytes-gt 16106127360 -j DROP

Auf diese Weise wird verhindert, dass ein Benutzer über einen längeren Zeitraum hinweg eine große Datei von Ihrem Webserver oder von einem anderen Dienst anfordert. Das gleiche kann für die INPUT-Kette gemacht werden.

Ich überprüfe meine Nginx-Protokolle manuell alle 4 Stunden und die Protokolle des Mailservers alle 2 Minuten auf übermäßigen Zugriff durch einzelne IP-Adressen, vor allem, weil ich eine elegantere Lösung nicht kenne. Ich führe ein paar Skripte zusammen, die:

1. Überprüfen Sie die access.logund listen Sie die Top-10-IPs auf, sortiert nach der Anzahl der Zugriffe auf den Server
2. Speichern Sie die Ergebnisse in einer Protokolldatei
3. Sehen Sie sich diese Protokolldatei mit einem anderen Skript an und sperren Sie alle IP-Adressen, die den Server in den letzten X Stunden mehr als x Mal getroffen haben
4. Rette meine iptables.save

So sieht es aus:

#!/bin/bash

# This script checks the last 2 minutes of log entries to see if any 
# IP has made over 99 connections

now=$(date +"%m_%d_%Y")

/root/bin/checkBadIPs_mail.sh > /home/ipChecker/ipcheckMAIL_$now.txt
cat /home/ipChecker/ipcheckMAIL_$now.txt | \
    grep " \\(\\([9][9]\\)\\|\\([0-9][0-9][0-9]\\+\\)\\) " | \
    awk '{print $2}' > /home/ipChecker/badMailIPs_$now.sh
sed -i "s/^/\/usr\/local\/sbin\/blockIP /g" /home/ipChecker/badMailIPs_$now.sh
/bin/bash /home/ipChecker/badMailIPs_$now.sh
cat /home/ipChecker/ipcheckMAIL_$now.txt >> /home/ipChecker/ipcheckMAIL_$now.log
rm /home/ipChecker/ipcheckMAIL_$now.txt
rm /home/ipChecker/badMailIPs_$now.sh

Eine Sache, die hier SEHR wichtig ist, ist, dass Sie eine Whitelist einrichten MÜSSEN, oder dass Sie damit beginnen, eine Menge authentischer IPs von Servern zu blockieren, von denen Sie nur eine Menge E-Mails erhalten, oder bei anderen Protokollen IPs, die dies sind Schlagen Sie einfach Ihren Server aus legitimen Gründen häufig an. Meine Whitelist wird nur durch Hinzufügen von grep-Pipes direkt nach | in dieses Skript integriert grep ']' | die ungefähr so ​​aussehen "grep -v 127.0 |" .
Sie müssen sich die Zeit nehmen, um Ihrem Server beizubringen, welche IP-Adressen mit hohem Datenverkehr legitim sind und welche nicht. Für mich bedeutete dies, dass ich die erste Woche damit zubringen musste, meine Protokolle alle paar Stunden manuell zu überprüfen, die IPs mit hohem Datenverkehr auf iplocation.net nachzuschlagen und dann die legitimen IPs wie amazon, box.com oder sogar mein Zuhause / Büro hinzuzufügen IP reicht bis zu dieser Whitelist. Wenn Sie dies nicht tun, werden Sie wahrscheinlich von Ihrem eigenen Server blockiert, oder Sie werden damit beginnen, legitime Mail- / Webserver zu blockieren und Unterbrechungen in E-Mail oder im Datenverkehr zu verursachen.

cat /var/log/mail.log | awk \
    -v d1="$(date --date="-2 min" "+%b %_d %H:%M")" \
    -v d2="$(date "+%b %_d %H:%M")" \
    '$0 > d1 && $0 < d2 || $0 ~ d2' | \
    grep '\[' | grep '\]' | \
    grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | grep -v 127.0 | \
    awk '{print $1}' | sort | uniq -c | sort -n | tail -10

#!/bin/bash
sudo iptables -I INPUT -s $1 -j DROP
sudo bash -c "iptables-save > /etc/network/iptables.save"

Wiederum weiß ich, dass dies verdammt grob ist und es wahrscheinlich ein nettes, sauberes, effizientes Protokoll gibt, das all das erledigt, aber ich wusste nichts davon, und dieses Ding läuft jetzt schon ein oder zwei Jahre und hält die Bösen in Schach. Die eine Sache, die ich sehr ernsthaft empfehlen würde, ist, dass Sie einen Proxy oder einen anderen Server in den Flügeln haben, die Sie verwenden können, um auf Ihren Hauptserver zuzugreifen. Der Grund ist, dass, wenn Sie einen Tag aus heiterem Himmel Webentwicklung machen Pingen Sie sich selbst 2000 Mal in 5 Stunden für einige Tests, die Sie ohne einen Proxy blockieren könnten.

Sie können sehen, dass checkBadIPs.shich in grep -v 127.0 geschrieben habe und in meinen tatsächlichen Dateien eine Menge Ignorierregeln für meine eigenen IPs und andere vertrauenswürdige IP-Bereiche habe, aber manchmal ändert sich Ihre IP, Sie vergessen zu aktualisieren und dann sind Sie gesperrt aus Ihrem eigenen Server.

Wie auch immer, hoffe das hilft.

AKTUALISIEREN

Ich habe die Dinge ein wenig geändert, so dass ich jetzt anstatt alle paar Stunden einige Protokolle alle 2 Minuten überprüfen lasse, hauptsächlich mein SSH-Authentifizierungsprotokoll und das E-Mail-Protokoll, als sie gestampft wurden :(.

Ich richte für jede Protokolldatei spezielle Skripte ein, obwohl dies mit dem manuellen Skript, das ich selbst verwende, um Protokolle zu untersuchen, recht einfach wäre. Sieht aus wie das:

#!/bin/bash

log=$1 time=$2

cat /var/log/${log} | awk \
    -v d1="$(date --date="-${time} min" "+%b %_d %H:%M")" \
    -v d2="$(date "+%b %_d %H:%M")" \
    '$0 > d1 && $0 < d2 || $0 ~ d2' | \
    grep '\[' | grep '\]' | \
    grep -Eo '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' | \
    sort | uniq -c | sort -n | tail -10

Dies erfordert 2 Eingaben beim Ausführen, die Protokolldatei, die Sie scannen möchten, und wie weit zurück in die Vergangenheit Sie scannen möchten.

Wenn ich also mail.log auf die IP-Zählungen überprüfen wollte, würde ich sagen, dass 75 Minuten vergangen sind:

$ sudo script.sh mail.log 75

Ich stimme den Kommentaren zu ipsets und tcp Flags zu, aber es fehlt noch eine Menge:

Verwenden Sie xtables-addons geoip match anstelle von ipsets für Länderlisten. Aktualisieren Sie die Geoip-Daten regelmäßig (mindestens einmal pro Monat). Die Daten sind dynamischer als eine Fire-and-Forget-Ipset-Liste.

Betrachten Sie die Verfolgung des Verbindungsstatus mit TCP-Flags. Beispielsweise ist ein TCP-RST oder ein ACK nur für eine hergestellte Verbindung sinnvoll. SYN ist nur für neue und verwandte Verbindungen sinnvoll. Ein SYN für eine hergestellte Verbindung bedeutet, dass entweder Ihr SYN + ACK verloren gegangen ist oder ein Hackversuch unternommen wurde und zurückgesetzt werden sollte, da beide Seiten der Verbindung nicht zustimmen, was den Status betrifft.

Obwohl keine, SYN + RST und FIN + RST unzulässige Kombinationen sind, ist SYN + FIN jetzt unter TCP Fast-Open (TCP-Option 34) gültig, insbesondere für DNS. SYN-Pakete sollten auch bei Fast-Open nicht fragmentiert werden. Ich halte Regeln mit den PSH- und URG-Flags nicht für nützlich. Verwechseln Sie den Verbindungsverfolgungsstatus nicht mit dem TCP-Status: Eine RST-Antwort auf ein SYN-Paket wird zu Verfolgungszwecken eingerichtet.

SYNPROXY ist für weitergeleitete Pakete gedacht und fügt nichts für lokal zugestellte Pakete hinzu, außer der Unterstützung von Syncookie.

ICMP-Fehlerpakete befinden sich immer im zugehörigen Status und haben die Länge 48: 576, wenn sie gültig sind. Länge 84: 1280 für IPv6. Alle anderen sollten ignoriert werden. Da ihre maximale Größe auch die minimale MTU ist, sollten sie niemals fragmentiert werden. ICMP-Anforderungen (Pings, Zeitstempel usw.) sind immer neu und es werden Antworten erstellt. Verwerfen von ICMP-Paketen in anderen Zuständen.

Ähnlich wie im SSH-Beispiel mit einer kürzlich erstellten Liste und der Annahme nur nachfolgender SYN-Pakete sollte dies auch für SMTP erfolgen und ähnelt dem "Greylisting" nur für das IP-Adressdatum.

In der Filtertabelle sollte die erste (oder zweite, wenn zuerst eingerichtete Statuspakete akzeptiert werden) Regel in der Eingabe- und Ausgabekette alles auf der Loopback-Schnittstelle akzeptieren. Sie sollten Ihren eigenen internen Paketen vertrauen. Wenn Sie dies nicht können, haben Sie größere Probleme als bei einer Firewall-Lösung.

Kopieren Sie Regeln nicht blindlings, es sei denn, Sie verstehen wirklich, was sie tun. So viele ähnliche Regellisten tun dies, und die meiste Zeit ist das Ergebnis lächerlich.

#!/bin/bash
# The following iptables/ip6tables configurations have
# been kindly shared with us from ArckWiki. There are
# a few additions apart from what has been defined.
#
#=================Flush current definitions==============
    iptables -F
    ip6tables -F
    iptables -X
    ip6tables -X

#
#=================Chains=================================
#
#----Define chains for opened ports
    iptables -N TCP
    ip6tables -N TCP
    iptables -N UDP
    ip6tables -N UDP

#
#----Setting up the filter table for NAT
#   iptables -N fw-interfaces
#   ip6tables -N fw-interfaces
#   iptables -N fw-open
#   ip6tables -N fw-open

#
#================Default Chain reactions=================
#
#----Default FORWARD reaction
    iptables -P FORWARD DROP
    ip6tables -P FORWARD DROP

#
#----Default OUTPUT reaction
    iptables -P OUTPUT ACCEPT
    ip6tables -P OUTPUT ACCEPT

#
#----Shellshock
    iptables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP
    ip6tables -A INPUT -m string --algo bm --hex-string '|28 29 20 7B|' -j DROP

#
#----Default INPUT reaction
    iptables -P INPUT DROP
    ip6tables -P INPUT DROP
#
#----Drop spoofing packets
    iptables -A INPUT -i eth0 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -i wlan0 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -i wlan1 -s 127.0.0.0/8 -j DROP
    iptables -A INPUT -s 10.0.0.0/8 -j DROP
    iptables -A INPUT -s 169.254.0.0/16 -j DROP
    iptables -A INPUT -s 172.16.0.0/12 -j DROP
    iptables -A INPUT -s 224.0.0.0/4 -j DROP
    iptables -A INPUT -d 224.0.0.0/4 -j DROP
    iptables -A INPUT -s 240.0.0.0/5 -j DROP
    iptables -A INPUT -d 240.0.0.0/5 -j DROP
    iptables -A INPUT -s 0.0.0.0/8 -j DROP
    iptables -A INPUT -d 0.0.0.0/8 -j DROP
    iptables -A INPUT -d 239.255.255.0/24 -j DROP
    iptables -A INPUT -d 255.255.255.255 -j DROP

#
#================Ping rate limiting globally=============
    iptables -A INPUT -p icmp --icmp-type 8 -m limit --limit 30/min --limit-burst 8 -j ACCEPT
    ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 --match limit --limit-burst 8 -j ACCEPT
    iptables -A INPUT -p icmp --icmp-type 8 -j DROP
    ip6tables -A INPUT -p icmpv6 --icmpv6-type 8 -j DROP

#
#----flooding RST packets, smurf attack Rejection
    iptables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags RST RST -m limit --limit 2/second --limit-burst 2 -j ACCEPT

#
#----Bogus packet DROP
    iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
    iptables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP
    ip6tables -A INPUT -p tcp -m tcp --tcp-flags SYN,RST SYN,RST -j DROP

#
#================RELATED,ESTABLISHED reaction============
    iptables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
    ip6tables -A INPUT --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

#
#================unfetered loopback======================
    iptables -A INPUT -i lo -j ACCEPT
    ip6tables -A INPUT -i lo -j ACCEPT

#
#================INVALID catagory of packets=============
    iptables -A INPUT -p 41 -j ACCEPT
    iptables -A INPUT --match conntrack --ctstate INVALID -j DROP
    ip6tables -A INPUT --match conntrack --ctstate INVALID -j DROP

#
#================IPv6 reactions and definitions==========
    ip6tables -A INPUT -s fe80::/10 -p icmpv6 -j ACCEPT
    ip6tables -t raw -A PREROUTING -p icmpv6 -s fe80::/10 -j ACCEPT
    ip6tables -t raw -A PREROUTING --match rpfilter -j ACCEPT
    ip6tables -t raw -A PREROUTING -j DROP
#
#=======Acceptable INVALIDs and a curteous response======
    iptables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
    ip6tables -A INPUT -p udp --match conntrack --ctstate NEW -j UDP
    iptables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP
    ip6tables -A INPUT -p tcp --syn --match conntrack --ctstate NEW -j TCP

#
#================Defining the TCP and UDP chains
#
#########################################################
#            Notes for port open definitions            #
# It is important to note that this should be config-   #
# ured differently if you're providing any routing      #
# activity for any purpose. it is up to you to actively #
# define what suites your needs to get the job done.    #
# In this example, I'm exempting IPv6 from being able   #
# to interact with SSH protocols for two reasons. The   #
# first is because it is generally easier and more com- #
# for internal networks to be deployed with IPv4. The   #
# second reason is, IPv6 can be deployed globally.      #
#########################################################
#
#----SSH configured for eth0
    iptables -A TCP -i eth0 -p tcp --dport ssh -j ACCEPT

#!---Blocking SSH interactions in IPv6
    ip6tables -A TCP -p tcp --dport ssh -j DROP

#!---Leave commented for end service device
#   iptables -A TCP -p tcp --dport 80 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 80 -j ACCEPT
#   iptables -A TCP -p tcp --dport 443 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 443 -j ACCEPT
#
#!---Uncomment for remote service to this device
#   iptables -A TCP -p tcp --dport 22 -j ACCEPT
#   ip6tables -A TCP -p tcp --dport 22 -j ACCEPT
#
#!---Uncomment if you're providing routing services
#   iptables -A UDP -p udp 53 -j ACCEPT
#   ip6tables -A UDP -p udp 53 -j ACCEPT
#
#=================Tricking port scanners=================
#
#----SYN scans
    iptables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
    ip6tables -I TCP -p tcp --match recent --update --seconds 60 --name TCP-PORTSCAN -j DROP
    iptables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP
    ip6tables -A INPUT -p tcp --match recent --set --name TCP-PORTSCAN -j DROP

#
#----UDP scans
    iptables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
    ip6tables -I UDP -p udp --match recent --update --seconds 60 --name UDP-PORTSCAN -j DROP
    iptables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP
    ip6tables -A INPUT -p udp --match recent --set --name UDP-PORTSCAN -j DROP

#
#----For SMURF attack protection
    iptables -A INPUT -p icmp -m icmp --icmp-type address-mask-request -j DROP
    iptables -A INPUT -p icmp -m icmp --icmp-type timestamp-request -j DROP
    iptables -A INPUT -p icmp -m limit --limit 2/second --limit-burst 2 -j ACCEPT
    ip6tables -A INPUT -p icmpv6 -m limit --limit 2/second --limit-burst 2 -j ACCEPT

#
#----Ending all other undefined connections
    iptables -A INPUT -j DROP
    ip6tables -A INPUT -j DROP

#
#=======Defining the IN_SSH chain for bruteforce of SSH==
#
#!---I've elected to keep IPv6 out of this realm for
#!---ease of use
    iptables -N IN_SSH
    iptables -A INPUT -p tcp --dport ssh --match conntrack --ctstate NEW -j IN_SSH
    iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 3 --seconds 10 -j DROP
    iptables -A IN_SSH --match recent --name sshbf --rttl --rcheck --hitcount 4 --seconds 1800 -j DROP
    iptables -A IN_SSH --match recent --name sshbf --set -j ACCEPT
    iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -j IN_SSH

#
#==================Setting up a NAT gateway==============
#
#########################################################
#                                                       #
# I commented this half out because it's not something  #
# that will apply to all setups. Make note of all par-  #
# tinate interfaces and what exactly is going on.       #
#                                                       #
#########################################################
#
#----Setting up the FORWARD chain
#   iptables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#   ip6tables -A FORWARD --match conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT
#
#
#----Defining the fw-interfaces/open chains for FORWARD
#   iptables -A FORWARD -j fw-interfaces
#   ip6tables -A FORWARD -j fw-interfaces
#   iptables -A FORWARD -j fw-open
#   ip6tables -A FORWARD -j fw-open
#   iptables -A FORWARD -j DROP # Should be REJECT. But, fuck them
#   ip6tables -A FORWARD -j DROP
#   iptables -P FORWARD DROP
#   ip6tables -P FORWARD DROP
#
#
#----Setting up the nat table
#   iptables -A fw-interfaces -i ### -j ACCEPT
#   ip6tables -A fw-interfaces -i ### -j ACCEPT
#   iptables -t nat -A POSTROUTING -s w.x.y.z/S -o ppp0 -j MASQUERADE
#   ip6tables -t nat -A POSTROUTING -s fe::/10 -o ppp0 -j MASQUERADE
#----The above lines should be repeated specifically for EACH interface
#
#----Setting up the PREROUTING chain
#
#######################################################
#                             #
# The PREROUTING chain will redirect either port      #
# targets to be redirected. This can also redirect    #
# traffic inbound to your network from the gateway    #
# to this machine. This can be useful if you're using #
# a honeypot or have any service within your network  #
# that you want to be pointed to a specific device.   #
#                             #
#######################################################
#
#----SSH honeypot server
#   iptables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#   ip6tables -A fw-open -d HONEYPOT_IP -p tcp --dport 22 -j ACCEPT
#----With intuition, you can configure the above to also direct specific
#----requests to other devices providing those services. The bellow will
#----be for a squid server
#   iptables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
#   ip6tables -A fw-open -d SQUID_IP -p tcp --dport 80 -j ACCEPT
#   iptables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#   ip6tables -t nat -A PREROUTING -i ppp0 -p tcp --dport 8000 -j DNAT --to SQUID_IP
#
#===============Declare configurations=================
    iptables -nvL
    ip6tables -nvL