Rețete

Scop: aruncă pachetele în starea INVALID (nu se potrivesc cu nicio conexiune cunoscută). De ce în această ordine: pune regula înaintea regulilor generale de ACCEPT. INVALID înseamnă pachete care nu se potrivesc cu nicio conexiune cunoscută (malformate sau în afara secvenței); apar și la unele scanări, dar nu e un detector de scanări. Folosește -m conntrack (nu -m state, care e depreciat). Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: iptables -D INPUT -m conntrack --ctstate INVALID -j DROP.

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

Scop: blochezi temporar o adresă: o adaugi într-un set cu timeout de 3600 s; elementele expiră singure la 1 oră, fără intervenție manuală. De ce în această ordine: se creează setul (hash:ip cu timeout 3600), se adaugă IP-ul, abia apoi regula DROP; regula e înaintea politicii DROP generale. Setul cu timeout e ideal pentru blocări de scurtă durată: se șterge singur. Verificare: ipset list temp-block (vezi IP-ul cu timpul rămas) și iptables -L INPUT -n -v --line-numbers (contorul pe regula DROP). Anulare: iptables -D INPUT -m set --match-set temp-block src -j DROP, apoi ipset destroy temp-block. Avertisment: 203.0.113.50 e un IP de documentație; rulează dintr-o a doua sesiune. Dacă adaugi alt IP în set, e blocat la fel, pentru 1 oră. Timeout-ul implicit al setului (3600 s) se aplică fiecărui element nou; un element poate avea alt timeout (ipset add temp-block 203.0.113.50 timeout 600).

ipset create temp-block hash:ip timeout 3600
ipset add temp-block 203.0.113.50
iptables -I INPUT -m set --match-set temp-block src -j DROP

Fondul oricărui host: permite loopback și conexiunile deja stabilite/relate, apoi SSH. Setează DROP doar la final, ca să nu te blochezi.

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
iptables -P INPUT DROP

Scop: blochează un IP de documentație doar pe un port (îl refuză pe HTTPS, dar îl lasă să facă altceva). De ce în această ordine: regula e specifică (un IP, un port), deci poate sta oriunde înaintea regulilor generale de ACCEPT. Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: iptables -D INPUT -s 203.0.113.50 -p tcp --dport 443 -j DROP (sau cu numărul liniei).

iptables -I INPUT -s 203.0.113.50 -p tcp --dport 443 -j DROP

Inserează o regulă DROP pentru un IP sau o rețea /24. IP de documentație.

iptables -I INPUT -s 203.0.113.50 -j DROP
iptables -I INPUT -s 203.0.113.0/24 -j DROP

Scop: un port acceptă trafic doar de la un singur IP de administrare; restul pe același port e blocat. De ce în această ordine: ACCEPT pentru IP-ul permis e primul. DROP-ul cu ! -s nu poate afecta niciodată IP-ul permis, deci rețeta rămâne corectă chiar dacă ordinea se schimbă. Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: ștergi ambele reguli cu -D (aceeași specificație sau numere de linie). Avertisment: regulile din INPUT nu filtrează porturile publicate de Docker; pentru containere folosește DOCKER-USER.

iptables -I INPUT -p tcp --dport 8080 -s 192.168.1.10 -j ACCEPT
iptables -A INPUT -p tcp --dport 8080 ! -s 192.168.1.10 -j DROP

Scop: containerele (172.17.0.0/16) nu mai pot iniția conexiuni NOI spre rețeaua locală 192.168.1.0/24; răspunsurile la conexiunile deja stabilite (ESTABLISHED) trec. De ce în această ordine: regula e în DOCKER-USER, înaintea regulilor Docker proprii, deci oprește traficul din container spre LAN înainte ca FORWARD să-l ruteze. -m conntrack --ctstate NEW e obligatoriu: fără el ar fi aruncate și pachetele de RĂSPUNS la conexiunile inițiate din LAN către un port publicat, deci un client din LAN nu ar mai putea ajunge la container. Verificare: iptables -L DOCKER-USER -n -v --line-numbers (contorul pe regula DROP crește când containerul inițiază o conexiune nouă spre LAN) și test cu curl din container spre un host din LAN (trebuie să eșueze). Test mental: un client din LAN trebuie să poată în continuare să acceseze portul publicat al containerului (conexiunea e inițiată din LAN, răspunsul e ESTABLISHED și trece). Anulare: iptables -D DOCKER-USER -s 172.17.0.0/16 -d 192.168.1.0/24 -m conntrack --ctstate NEW -j DROP. Avertisment: 172.17.0.0/16 (rețeaua docker0) și 192.168.1.0/24 sunt exemple — pune subrețelele tale reale. Dacă ai rețele bridge suplimentare, adaugă o regulă pentru fiecare. --ctstate NEW înseamnă că regula blochează doar inițierea din container, nu răspunsul.

iptables -I DOCKER-USER -s 172.17.0.0/16 -d 192.168.1.0/24 -m conntrack --ctstate NEW -j DROP

Scop: arăți concret de ce regulile din INPUT NU filtrează porturile publicate de Docker: traficul ajuns la un port publicat e rutat către container (după DNAT destinația e IP-ul de pe bridge), deci trece prin FORWARD, nu prin INPUT. De ce în această ordine: se pune o regulă LOG în FORWARD pe interfața de ieșire către container (docker0); când cineva se conectează la portul publicat, pachetul apare aici, iar o regulă echivalentă în INPUT ar rămâne la 0 pachete. LOG cu limită, ca să nu-ți înece log-ul. Verificare: conectează-te la portul publicat, apoi iptables -L FORWARD -n -v --line-numbers (contorul pe regula LOG crește) și jurnalul kernelului (liniile cu prefix-ul IPT-DOCKER-FWD:). Anulare: ștergi regula LOG din FORWARD (aceeași specificație ca în commands). Avertisment: docker0 e numele implicit al bridge-ului; pune bridge-ul tău. Dacă vrei să filtrezi portul publicat, fă-l în DOCKER-USER sau FORWARD, nu în INPUT.

iptables -I FORWARD -o docker0 -m limit --limit 5/min -j LOG --log-prefix "IPT-DOCKER-FWD: " --log-level 4

Scop: portul publicat 80 (container) e accesibil doar din rețeaua locală 192.168.1.0/24; tot ce nu vine din LAN e aruncat în DOCKER-USER. De ce în această ordine: în DOCKER-USER pachetul a trecut DEJĂ prin DNAT, deci --dport ar fi portul din container, nu cel publicat; pentru portul publicat folosește -m conntrack --ctorigdstport (conform documentației Docker, Packet filtering and firewalls). O singură regulă de DROP cu ! -s: aruncă tot ce nu vine din LAN, iar traficul din LAN trece mai departe, fără un ACCEPT explicit. Verificare: iptables -L DOCKER-USER -n -v --line-numbers (contorul pe regula DROP) și test cu curl din LAN (merge) și din exterior (nu merge). Anulare: iptables -D DOCKER-USER -i eth0 -p tcp -m conntrack --ctorigdstport 80 ! -s 192.168.1.0/24 -j DROP. Avertisment: eth0 (interfața de intrare), 192.168.1.0/24 și 80 sunt exemple — pune interfața, rețeaua și portul tău. Un -j ACCEPT explicit în DOCKER-USER ocolește regulile Docker proprii; dacă vrei să lași pachetul să meargă mai departe (spre regulile Docker), folosește -j RETURN. Regula e în DOCKER-USER, nu în INPUT: regulile din INPUT NU filtrează porturile publicate de Docker (traficul trece prin FORWARD către container).

iptables -I DOCKER-USER -i eth0 -p tcp -m conntrack --ctorigdstport 80 ! -s 192.168.1.0/24 -j DROP

Regulile tale pentru porturile publicate se pun în lanțul DOCKER-USER. Docker își gestionează singur restul regulilor.

iptables -I DOCKER-USER -s 203.0.113.0/24 -j DROP

Scop: închizi două căi de atac ICMP și de rutare: hostul ignoră răspunsurile la ICMP broadcast (protecție la Smurf) și nu mai acceptă source routing (pachetele cu opțiunea de rutare sursă nu mai schimbă drumul). De ce în această ordine: cele trei chei sunt independente, ordinea nu contează; dar toate se setează o dată, pentru a le putea revizui împreună. accept_source_route e separat pe IPv4 și IPv6, deci sunt trei chei în total. Pe multe distribuții moderne aceste valori sunt deja cele sigure; rețeta le fixează explicit, ca să nu depinzi de valorile implicite ale distribuției. Verificare: sysctl net.ipv4.icmp_echo_ignore_broadcasts (valoare 1) și sysctl net.ipv4.conf.all.accept_source_route net.ipv6.conf.all.accept_source_route (ambele 0). Anulare: notează valorile actuale înainte (sysctl net.ipv4.icmp_echo_ignore_broadcasts net.ipv4.conf.all.accept_source_route net.ipv6.conf.all.accept_source_route) și revino la ele cu sysctl -w pentru fiecare cheie (pe multe nuclee icmp_echo_ignore_broadcasts e deja 1 implicit, deci „a reveni la implicite” nu e întotdeauna 0). Avertisment: sysctl -w NU persistă la repornire — vezi rețeta de persistență în /etc/sysctl.d/.

sysctl -w net.ipv4.icmp_echo_ignore_broadcasts=1
sysctl -w net.ipv4.conf.all.accept_source_route=0
sysctl -w net.ipv6.conf.all.accept_source_route=0

Scop: activezi forwardul de pachete la nivel de kernel (obligatoriu pentru NAT / port forward) și îl faci persistent în /etc/sysctl.d/, ca să supraviețuiască repornirii. De ce în această ordine: întâi scrii fișierul în /etc/sysctl.d/ (prin tee, ca să vezi conținutul pe ecran), apoi rulezi sysctl --system, care aplică toate fișierele din /etc/sysctl.d/ în ordinea corectă și validează sintaxa. sysctl -w NU persistă la repornire; doar fișierul din /etc/sysctl.d/ rămâne. Verificare: sysctl net.ipv4.ip_forward (valoare 1) și, după o repornire de test, tot 1 (nu 0). Anulare: sysctl -w net.ipv4.ip_forward=0 și ștergi sau comentezi linia din /etc/sysctl.d/99-ipv4-forward.conf, apoi sysctl --system. Avertisment: activezi forward-ul și pe un server care nu trebuie să ruteze — dacă vrei doar un host simplu, lasă-l la 0. Numele fișierului 99-ipv4-forward.conf e pentru a fi citit spre final; numește-l cum preferi, atâta timp cât e în /etc/sysctl.d/ cu extensia .conf. sudo apare doar aici (ca tee să poată scrie în /etc); celelalte comenzi din site presupun root.

echo "net.ipv4.ip_forward = 1" | sudo tee /etc/sysctl.d/99-ipv4-forward.conf
sudo sysctl --system

Scop: permite cel mult 3 conexiuni SSH în paralel de la o singură sursă; restul (conexiuni noi) e aruncat. De ce în această ordine: regula de DROP pentru peste limită stă înaintea ACCEPT-ului, ca să oprească conexiunile noi peste plafon. connlimit numără conexiunile deja urmărite de conntrack de la aceeași adresă sursă (mască implicită /32) către portul 22; a patra conexiune simultană este aruncată. Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: iptables -D INPUT -p tcp --dport 22 --syn -m connlimit --connlimit-above 3 -m conntrack --ctstate NEW -j DROP. Avertisment: testează dintr-o a doua sesiune SSH.

iptables -A INPUT -p tcp --dport 22 --syn -m connlimit --connlimit-above 3 -m conntrack --ctstate NEW -j DROP
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT

Blochează dacă sunt mai mult de 3 conexiuni noi SSH în 60 s de la aceeași sursă.

iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set --name SSH
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 4 --name SSH -j DROP

Scop: limitează rata SYN (anti-flood) fără să anulezi politica DROP pentru porturi. De ce în această ordine: SYN-urile în limită se întorc (RETURN) și sunt evaluate de regulile normale; ce depășește limita e aruncat de DROP-ul din lanțul propriu. Saltul -A INPUT -p tcp --syn -j SYN_FLOOD trebuie să fie înaintea regulilor ACCEPT pentru porturi; altfel ACCEPT-urile pe porturi ar lăsa prin orice SYN în limita de rată, inclusiv pe porturi care nu ar trebui deschise. Verificare: iptables -L INPUT -n -v --line-numbers și iptables -L SYN_FLOOD -n -v --line-numbers. Anulare, în această ordine: iptables -D INPUT -p tcp --syn -j SYN_FLOOD, apoi iptables -F SYN_FLOOD, apoi iptables -X SYN_FLOOD. Avertisment: limita se aplică tuturor SYN-urilor la un loc, deci setează-o peste vârful real de trafic legitim.

iptables -N SYN_FLOOD
iptables -A SYN_FLOOD -m limit --limit 25/second --limit-burst 50 -j RETURN
iptables -A SYN_FLOOD -j DROP
iptables -A INPUT -p tcp --syn -j SYN_FLOOD

Pentru liste mari de IP-uri, folosește ipset (hash:ip) în loc de reguli individuale.

ipset create blocklist hash:ip
ipset add blocklist 203.0.113.50
iptables -I INPUT -m set --match-set blocklist src -j DROP

Scop: închizi un port (25, SMTP), dar vrei să vezi cine încearcă să se conecteze. De ce în această ordine: regula LOG stă înaintea DROP-ului pentru port, ca fiecare conexiune nouă aruncată să fie mai întâi înregistrată; LOG nu oprește procesarea, deci pachetul ajunge și la DROP. Limita de 5/min previne înecarea log-ului. Verificare: iptables -L INPUT -n -v --line-numbers (contorul pe regula LOG) și jurnalul kernelului, vizibil prin dmesg sau journalctl -k (liniile cu prefix-ul IPT-SMTP:). Anulare: ștergi ambele reguli cu -D (aceeași specificație).

iptables -A INPUT -p tcp --dport 25 -m conntrack --ctstate NEW -m limit --limit 5/min -j LOG --log-prefix "IPT-SMTP: " --log-level 4
iptables -A INPUT -p tcp --dport 25 -m conntrack --ctstate NEW -j DROP

Scop: înregistrezi cine încearcă SSH înainte ca regula de limitare (recent) să le arunce. De ce în această ordine: -I pune regula LOG prima (poziția 1), deci fiecare încercare nouă pe portul 22 e înregistrată, fie că e acceptată, fie că e aruncată de regulile de mai jos; cu -A regula ar fi pusă la sfârșit, după DROP-ul cu recent, și tocmai conexiunile aruncate nu s-ar vedea. Verificare: iptables -L INPUT -n -v --line-numbers (contorul pe regula LOG) și jurnalul kernelului, vizibil prin dmesg sau journalctl -k (liniile cu prefix-ul IPT-SSH:). Anulare: iptables -D INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m limit --limit 3/min -j LOG --log-prefix "IPT-SSH: " --log-level 4. Avertisment: limita de 3/min înseamnă că în timpul unui atac se văd doar primele 3 linii pe minut.

iptables -I INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m limit --limit 3/min -j LOG --log-prefix "IPT-SSH: " --log-level 4

Scop: scrie în logul kernelului un număr limitat de pachete, ca să vezi cine e blocat de politica implicită. Rețeta presupune politica INPUT DROP: regula LOG e ultima din lanț, deci vede doar pachetele pe care le aruncă politica. De ce în această ordine: LOG-ul se adaugă cu -A la final, ca să fie ultima regulă din INPUT; pachetele care nu se potrivesc cu nicio regulă de ACCEPT trec prin LOG (care nu oprește procesarea) și abia apoi sunt aruncate de politica DROP. Limita de 5/min previne înecarea log-ului. Verificare: iptables -L INPUT -n -v --line-numbers (contorul pe regula LOG) și jurnalul kernelului, vizibil prin dmesg sau journalctl -k (liniile cu prefix-ul IPT-DROP:). Anulare: iptables -D INPUT -m limit --limit 5/min -j LOG --log-prefix "IPT-DROP: " --log-level 4.

iptables -A INPUT -m limit --limit 5/min -j LOG --log-prefix "IPT-DROP: " --log-level 4

Hostul funcționează ca router: masquerade pe interfața de ieșire + forward activ.

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sysctl -w net.ipv4.ip_forward=1

Scop: hostul nu răspunde la ping (echo-request) de la nicio sursă, inclusiv din rețeaua locală. De ce în această ordine: inserează regula sus cu -I, ca să arunce echo-request înainte de orice ACCEPT general de ICMP (de exemplu regula de ping limitat); dacă ar sta după un ACCEPT de echo-request, n-ar avea efect. Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: iptables -D INPUT -p icmp --icmp-type echo-request -j DROP (sau cu numărul liniei). Avertisment: blochează și ping-ul din rețeaua locală; pentru doar-LAN vezi rețeta următoare.

iptables -I INPUT -p icmp --icmp-type echo-request -j DROP

Scop: portul 22 acceptă conexiuni noi doar din rețeaua de administrare (192.168.1.0/24), păstrată într-un set ipset (hash:net) în loc de o regulă cu -s. De ce în această ordine: se creează setul (hash:net acceptă o rețea cu mask CIDR), se adaugă rețeaua, abia apoi regula -m set --match-set ... src -j ACCEPT; regula e înaintea politicii DROP (rețeta presupune politica INPUT DROP). Verificare: ipset list admin-subs (vede 192.168.1.0/24) și iptables -L INPUT -n -v --line-numbers (contorul pe regula ACCEPT). Anulare: iptables -D INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m set --match-set admin-subs src -j ACCEPT, apoi ipset destroy admin-subs. Avertisment: 192.168.1.0/24 e un exemplu — pune rețeaua ta de administrare. Ordinea la anulare contează: întâi ștergi regula iptables, abia apoi ipset destroy; altfel ipset refuză (eroare „Set cannot be destroyed: it is in use by a kernel component”), fiindcă setul e legat de o regulă.

ipset create admin-subs hash:net
ipset add admin-subs 192.168.1.0/24
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m set --match-set admin-subs src -j ACCEPT

Permite echo-request cu limită (1/s, burst 5) — restul nu e acceptat explicit.

iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/second --limit-burst 5 -j ACCEPT

Scop: ping-ul e acceptat doar din rețeaua locală (192.168.1.0/24); din exterior e aruncat. De ce în această ordine: prima regulă (poziția 1) lasă echo-request din LAN; a doua regulă (poziția 2) aruncă orice alt echo-request. Prima trebuie să stea înaintea celei de-a doua, altfel ping-ul local e aruncat și el. Verificare: iptables -L INPUT -n -v --line-numbers. Anulare: ștergi ambele reguli cu -D (aceeași specificație), în aceeași ordine ca adăugarea.

iptables -I INPUT -p icmp --icmp-type echo-request -s 192.168.1.0/24 -j ACCEPT
iptables -I INPUT 2 -p icmp --icmp-type echo-request -j DROP

Scop: redirecționează un port de pe interfața externă (8080) către un host intern (192.168.1.10:80) și lași traficul FORWARD să treacă în ambele sensuri. De ce în această ordine: regula ESTABLISHED,RELATED e prima în FORWARD, ca răspunsurile server→client să treacă (ele au sursa 192.168.1.10 și destinația clientul, deci nu se potrivesc cu regula client→server). După DNAT, portul destinație din FORWARD e 80, nu 8080, de aceea regula ACCEPT client→server folosește --dport 80. Verificare: iptables -t nat -L PREROUTING -n -v --line-numbers și iptables -L FORWARD -n -v --line-numbers; test cu curl http://server:8080 din exterior. Anulare, în ordine inversă: ștergi regula ACCEPT client→server, apoi regula ESTABLISHED,RELATED, apoi regula DNAT (fiecare cu -D, aceeași specificație). Avertisment: net.ipv4.ip_forward=1 e obligatoriu, altfel traficul nu e rutat. Dacă serverul intern nu are această mașină ca gateway implicit, răspunsurile nu se întorc prin ea; în acel caz ai nevoie și de SNAT/MASQUERADE pe interfața internă. eth0, 8080 și 192.168.1.10 sunt exemple — pune valorile tale.

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 8080 -j DNAT --to-destination 192.168.1.10:80
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -i eth0 -d 192.168.1.10 -p tcp --dport 80 -m conntrack --ctstate NEW -j ACCEPT

Scop: traficul care ajunge pe portul 80 al acestui host e mutat local pe portul 8080 (aplicație pe port neobișnuit). De ce în această ordine: REDIRECT e o variantă de DNAT către același host; se pune în PREROUTING (pentru traficul de intrare). E trafic local, deci nu are nevoie de ip_forward și nu afectează regulile din FORWARD. Verificare: iptables -t nat -L PREROUTING -n -v --line-numbers și test de conexiune pe portul 80. Anulare: iptables -t nat -D PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080. Avertisment: REDIRECT se face în PREROUTING, înainte de INPUT, deci în INPUT pachetul are deja portul destinație 8080: cu politica INPUT DROP trebuie să accepți 8080, nu 80 (iptables -A INPUT -p tcp --dport 8080 -m conntrack --ctstate NEW -j ACCEPT). Avertisment: PREROUTING nu se aplică conexiunilor generate chiar de acest host (ele trec prin OUTPUT); testul local cu curl localhost:80 nu verifică regula.

iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080

Scop: filtrezi pachetele al căror IP sursă nu poate fi atins pe interfața pe care au sosit (rp_filter, reverse path). Setarea 2 (loose) acceptă dacă sursa e atinsă prin ORICE interfață; 1 (strict) cere exact interfața pe care a sosit pachetul. De ce în această ordine: valoarea 2 e recomandată pentru hosturi cu rutare asimetrică (de ex. mai multe rute sau load-balancing): cu 1 strict, pachetele legitime pot fi aruncate tocmai pentru că sursa se atinge pe o altă interfață, deci 1 strict poate rupe rutarea asimetrică. Aici aplici 2 ca să nu-ți rupi traficul. Verificare: sysctl net.ipv4.conf.all.rp_filter (valoare 2) și, pe o interfață concretă, sysctl net.ipv4.conf.eth0.rp_filter. Anulare: notează valoarea actuală înainte (sysctl net.ipv4.conf.all.rp_filter) și revino la ea cu sysctl -w net.ipv4.conf.all.rp_filter=<valoare> (0 doar dacă dezactivezi filtrul complet). Avertisment: dacă ai o configurare simetrică simplă, 1 strict e mai strâns; dar pe un host cu mai multe interfețe sau rute, 1 poate arunca trafic legitim. sysctl -w NU persistă la repornire — vezi rețeta de persistență în /etc/sysctl.d/.

sysctl -w net.ipv4.conf.all.rp_filter=2
sysctl -w net.ipv4.conf.default.rp_filter=2

Scop: seturile ipset dispar la repornire, iar regulile iptables care le folosesc eșuează dacă setul nu există; se salvează și se restaurează manual ca fișier. De ce în această ordine: se salvează seturile într-un fișier (ipset save > fișier) și se restaurează cu ipset restore < fișier; RESTAURAREA se face ÎNAINTEA oricărei reguli iptables care referă setul, altfel regula nu se aplică (kernel refuză să lege o regulă de un set inexistent). Verificare: ipset list (toate seturile restaurate, cu elementele) și iptables -S | grep match-set (regulile legate de seturi, fără erori). Anulare: ștergi fișierul /etc/ipset.save (sau calea ta) și, dacă vrei, ipset flush (golește elementele, păstrează seturile). Avertisment: pentru persistență automată la boot, rulează ipset restore la pornire (unit systemd sau script în /etc/network/if-up.d) și iptables-restore după el; ordinea e: întâi ipset restore, apoi iptables-restore. ipset restore pică dacă setul există deja; pentru cazul ăsta folosește ipset restore -exist < /etc/ipset.save. Redirecționările > și < cer drepturi de root (fișierul e în /etc).

ipset save > /etc/ipset.save
ipset restore < /etc/ipset.save

Blochează pachete cu combinații de flaguri TCP nefolosite în trafic normal.

iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP

Scop: extinde baza stateful cu porturile web pentru un server de internet. De ce în această ordine: iptables evaluează regulile de sus în jos, prima potrivire câștigă. Loopback, ESTABLISHED/RELATED, SSH și porturile 80/443 trebuie să treacă înainte de politica DROP; dacă pui -P INPUT DROP mai devreme, te blochezi. Dacă ai deja regulile de bază, adaugă doar liniile pentru porturile 80 și 443 înaintea politicii DROP; politica se setează o singură dată, la final. Verificare: iptables -L -n -v --line-numbers. Anulare: întâi iptables -P INPUT ACCEPT, apoi ștergi regulile cu -D (aceeași specificație sau numărul liniei). Avertisment: rulează dintr-o a doua sesiune SSH deja deschisă, altfel te blochezi.

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -m conntrack --ctstate NEW -j ACCEPT
iptables -P INPUT DROP

Scop: pachetele din rețeaua locală ies pe internet cu o adresă sursă fixă (a hostului router), nu cu adresele lor interne. De ce în această ordine: regula e în POSTROUTING (după rutare), unde sursa se poate înlocui sigur; se aplică doar traficului din 192.168.1.0/24 care pleacă prin eth1. SNAT cu IP fix se folosește când ai o adresă statică (masquerade e pentru adrese dinamice). Verificare: iptables -t nat -L POSTROUTING -n -v --line-numbers. Anulare: iptables -t nat -D POSTROUTING -s 192.168.1.0/24 -o eth1 -j SNAT --to-source 203.0.113.1. Avertisment: rulează și sysctl -w net.ipv4.ip_forward=1 (forward activ), altfel traficul nu e rutat deloc. Avertisment: eth1 și 203.0.113.1 sunt exemple — pune interfața ta și adresa ta publică. Avertisment: dacă politica FORWARD e DROP, mai ai nevoie de reguli în FORWARD (traficul din LAN spre exterior și o regulă generală ESTABLISHED,RELATED ca răspunsurile să treacă); vezi regula ESTABLISHED,RELATED din rețeta cu port forward.

iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth1 -j SNAT --to-source 203.0.113.1

Scop: conexiunile noi SSH sunt acceptate doar din rețeaua de administrare (192.168.1.0/24); restul cade pe politică. De ce în această ordine: ACCEPT-ul SSH e restrâns la sursa de administrare și stă înainte de politica DROP; o conexiune nouă din afara rețelei nu se potrivește cu nicio regulă de ACCEPT și e aruncată de DROP (pachetele de răspuns trec prin ESTABLISHED). Verificare: iptables -L -n -v --line-numbers. Anulare: ștergi regula cu -D (iptables -D INPUT -p tcp --dport 22 -s 192.168.1.0/24 -m conntrack --ctstate NEW -j ACCEPT) și, dacă e cazul, adaugă regula largă de SSH. Avertisment: 192.168.1.0/24 e un exemplu — pune rețeaua ta de administrare și rulează dintr-o a doua sesiune SSH.

iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -s 192.168.1.0/24 -m conntrack --ctstate NEW -j ACCEPT
iptables -P INPUT DROP

Scop: muti SSH de pe portul 22 pe 2222, fără să pierzi accesul. Pășii, în ordine: 1. în sshd_config adaugă Port 2222 ÎN PLUS față de Port 22, verifică cu sshd -t și repornește serviciul; 2. rulează comanda de mai sus (regula de ACCEPT pe 2222); 3. dintr-o a doua sesiune testează ssh -p 2222 utilizator@server; 4. abia după ce merge, șterge regula veche (iptables -D INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT) și scoate Port 22 din sshd_config. De ce în această ordine: ACCEPT-ul pe 2222 e activat și verificat înainte să ștergi portul 22; dacă inversezi, rămâi blocat în momentul în care noua regulă nu funcționează. Verificare: iptables -L INPUT -n -v --line-numbers (2222 ACCEPT; 22 dispare doar la final). Anulare: reintrodu regula pe 22 (iptables -I INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -j ACCEPT) și, dacă e cazul, șterge cea de pe 2222. Avertisment: rulează totul dintr-o sesiune SSH deschisă înainte, pe portul vechi.

iptables -I INPUT -p tcp --dport 2222 -m conntrack --ctstate NEW -j ACCEPT

Activează SYN cookies ca protecție împotriva unor SYN flood-uri (nivel kernel).

sysctl -w net.ipv4.tcp_syncookies=1