Jestem pewien, że sysadmini Linuksa są dość dobrze zaznajomieni z iptablesinterfejsem użytkownika do środowiska netfilterfiltrowania pakietów.

To „Pytanie” ma być Wiki Społeczności do zbierania różnych iptablesmądrości. Nic nie jest zbyt powszechne ani zbyt niejasne. Publikuj wszystko, co wiesz, co pomogłoby innym w pełni wykorzystać iptables.

Używanie białej listy i czarnej listy w 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

Skrypt do otwierania portów

#!/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

Blokowanie portówcan

# 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

Sfałszowane / nieprawidłowe pakiety

# 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

Blokuj ataki Smerfa

# 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

Blokuj ICMP (inaczej ping)

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

Zoptymalizuj wydajność netfiltera za pomocą ipset

Jeśli piszesz wiele podobnych reguł na podstawie samego adresu IP, portu lub obu, rozważ użycie ipsetoptymalizującego wydajność netfiltera.

Na przykład:

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

Oznacza to, że pakiet o adresie źródłowym 192.168.251.177 musi najpierw przejść setki reguł, zanim będzie mógł uzyskać werdykt AKCEPTUJ.

Oczywiście doświadczeni administratorzy podzielą reguły według podsieci. Ale to wciąż oznacza setki zasad.

ipset na pomoc!

Najpierw zdefiniuj zestaw IP ipmaptypu:

ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16

Następnie wypełnij go adresami:

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

Na koniec zastąp setki powyższych reguł iptables jedną regułą:

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

Kiedy nadejdzie pakiet, netfilter wykona bardzo szybkie wyszukiwanie bitmapy dla źródłowego (src) adresu IP względem Allowed_Hostszestawu adresów IP. Wszystkie pakiety pochodzące od 192.168.0.0/16 będą podlegały jednej regule. I wierzcie mi, że wyszukiwanie mapy bitowej jest o co najmniej dwa rzędy wielkości szybsze niż przeprowadzanie setek sprawdzania reguł w iptables.

ipsetnie jest ograniczony do adresów IP. Może także dopasowywać na podstawie portów, krotki portu IP, adresów sieci / podsieci, krotki IP-MAC i tak dalej. I może pasować do tych kryteriów jako źródła lub celu lub kombinacji obu (w przypadku krotek).

I na koniec, ipsetmożesz automatycznie umieszczać adresy IP na czarnych listach / białych listach. Te czarne listy / białe listy mogą również „starzeć się”, a tym samym automatycznie usuwać adres IP po upływie określonego czasu.

Więcej informacji można znaleźć na ipsetstronie podręcznika użytkownika.

BARDZO WAŻNA UWAGA:

Niektóre dystrybucje Linuksa mogą nie mieć gotowej obsługi ipset(np. Ten problem miał Ubuntu 10.04). W tych systemach jedną metodą jest instalacja ipsetz kodu źródłowego.

Zamiast tego pobierz ipsetźródło ze strony internetowej: http://ipset.netfilter.org/install.html

Alternatywnie, jeśli używasz xtables-addons, ipset znajduje się w jego źródle: http://xtables-addons.sourceforge.net/

Dodaj komentarze do swoich zasad:

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

Blokuj dobrze znane ataki TCP

Dodaj następujące reguły, najlepiej w -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

Blokowane ataki to odpowiednio:

• Atak SYN-FIN
• Atak SYN-RST
• Atak X-Mas
• skan nmap FIN
• Atak NULLflags
• ALLflags atakują

(możesz edytować nazwy powyższych ataków)

Włączanie NAT

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

Krok 1 ustawia parametr jądra, aby umożliwić przekazywanie ip, krok 2 ustanawia regułę iptables, która włącza NAT na interfejsie eth0.

Blokuj ataki ICMP

Dodaj następujące reguły, najlepiej w -t raw -A PREROUTING

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

Pierwsza reguła blokuje wszystkie pakiety ICMP, których „flaga fragmentacji” nie jest równa 0. (ICMP nigdy nie powinien być fragmentowany; powinny one przenosić małe ładunki)

Druga reguła blokuje duże niefragmentowane pakiety ICMP.

za pomocą FireHOL - wygodnego opakowania iptables

Uważam, że jest to o wiele bardziej intuicyjne niż bezpośrednie polecenia iptables. Szczególnie dla osób z przeszłymi doświadczeniami z innymi zaporami ogniowymi:

FireHOL to generator zapory ogniowej iptables, produkujący stanowe zapory filtrujące pakiety iptables, na hostach i routerach Linux z dowolną liczbą interfejsów sieciowych, dowolną liczbą tras, dowolną liczbą obsługiwanych usług, dowolną złożonością między odmianami usług (w tym dodatnimi i ujemnymi wyrażenia).

(z mojego pliku iptables_tricks.txt, skompilowanego z wielu miejsc: P)

Sprawia, że ​​iptables czeka 15 sekund między nowymi połączeniami z tego samego adresu IP na porcie 22 (SSH):

 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

Samouczki wideo IPTABLES

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

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

Ostatni odcinek

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

Będzie dobrym początkiem dla każdego początkującego.

Powtórzono zestawy adresów IP

Odpowiedź już wspomina o zestawach adresów IP. Jest jednak raczej jednowymiarowy, ponieważ koncentruje się na wzroście wydajności w porównaniu z klasycznymi regułami oraz na tym, że zestawy IP łagodzą problem z wieloma indywidualnymi adresami IP, których nie można łatwo wyrazić jako podsieć w notacji CIDR.

Notacja używana poniżej

Dla ipsetbędę używać notacji odczytywane przez ipset restorescenariusz ipset save.

Odpowiednio do iptables(i ip6tables) reguł użyję notacji odczytanej iptables-restorei napisanej przez iptables-save. To sprawia, że ​​notacja jest krótsza i pozwala mi wyróżnić potencjalne reguły tylko dla IPv4 (z prefiksem -4) lub tylko z IPv6 (z prefiksem -6).

W niektórych przykładach przekierujemy przepływ pakietów na inny łańcuch. Zakłada się, że łańcuch istnieje w tym momencie, więc linie do tworzenia łańcuchów nie są tworzone (nie wymieniono też nazwy tabeli ani poleceń COMMITna końcu).

Zaawansowane zestawy adresów IP

Zestawy IP mogą zrobić znacznie więcej niż zostało wspomniane w drugiej odpowiedzi i zdecydowanie powinieneś przeczytać dokumentację zestawu IP ( ipset(8)) oraz iptables-extensions(8)oprócz tego krótkiego wpisu tutaj.

Na przykład skupię się głównie na trzech ustawionych typów: hash:ip, hash:neti list:set, ale jest więcej niż tych, a wszystkie one mają ważne przypadki użycia.

Możesz na przykład dopasować również numery portów, a nie tylko adresy IP .

Zapisywanie i przywracanie zestawów adresów IP jak przy pomocy iptables-saveiiptables-restore

Można tworzyć zbiorcze deklaracje zestawu adresów IP i importować je, przesyłając je do pipety ipset restore. Jeśli chcesz, aby twoje polecenie było bardziej odporne na już istniejące wpisy, użyj ipset -exist restore.

Jeśli Twoje reguły znajdują się w pliku o nazwie, default.setmożesz użyć:

ipset -exist restore < default.set

Taki plik może zawierać wpisy do createzestawów i addwpisów do nich. Ale generalnie większość poleceń z wiersza poleceń wydaje się mieć odpowiednią wersję w plikach. Przykład (tworzenie zestawu serwerów DNS):

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

Tutaj tworzony jest jeden zestaw dla IPv4 ( dns4), a drugi dla IPv6 ( dns6).

Przekroczono limity czasu w zestawach adresów IP

Limity czasu w zestawach IP można ustawić domyślnie dla każdego zestawu, a także dla jednego wpisu. Jest to bardzo przydatne w scenariuszach, w których chcesz tymczasowo zablokować kogoś (np. Podczas skanowania portów lub próby brutalnego użycia serwera SSH).

Sposób działania jest następujący (domyślny podczas tworzenia zestawów adresów IP):

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

Wrócimy do tych konkretnych zestawów poniżej i uzasadnienia, dlaczego są ustawione takimi, jakimi są.

Jeśli chcesz ustawić limit czasu dla określonego adresu IP, możesz po prostu powiedzieć:

add ssh_dynblock4 1.2.3.4 timeout 7200

Aby zablokować IP 1.2.3.4 na dwie godziny zamiast (ustawionego) domyślnego pół godziny.

Jeśli spojrzysz na to ipset save ssh_dynblock4po chwili, zobaczysz coś w rodzaju:

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

Ograniczenia dotyczące limitu czasu

• limity czasu są funkcją w danym zestawie. Jeśli zestaw nie został utworzony z obsługą limitu czasu, pojawi się błąd (np Kernel error received: Unknown error -1.).
• limity czasu są podawane w sekundach. Używaj wyrażeń arytmetycznych Bash, na przykład, aby uzyskać minuty od sekund. Na przykład:sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))

Sprawdzanie, czy istnieje wpis w danym zestawie adresów IP

Wewnątrz skryptów przydatne może być sprawdzenie, czy pozycja już istnieje. Można to osiągnąć, przy pomocy ipset testktórego zwracane jest zero, jeśli pozycja istnieje, a w przeciwnym razie niezerowa. Tak więc zwykłe kontrole można zastosować w skrypcie:

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

Jednak w wielu przypadkach wolisz użyć -existprzełącznika, aby ipsetnakazać mu nie narzekać na istniejące wpisy.

Wypełnianie zestawów adresów IP z iptablesreguł

To, moim zdaniem, jest jedną z zabójczych cech zestawów IP. Nie tylko możesz dopasować do wpisów zestawu IP, ale możesz także dodawać nowe wpisy do istniejącego zestawu IP.

Na przykład w tej odpowiedzi na to pytanie masz:

-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

... z zamiarem ograniczenia prób połączenia z SSH (port TCP 22). Używany moduł recentśledzi ostatnie próby połączenia. Zamiast statemodułu wolę jednak conntrackmoduł.

# 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

W tym przypadku przekierowuję przepływ do SSHłańcucha, tak że nie muszę powtarzać się -p tcp --dport sshdla każdej reguły.

Powtarzać:

• -m setsprawia, że iptableszdaje sobie sprawę, że jesteśmy za pomocą przełączników z setmodułu (który obsługuje zestawy IP)
• --match-set ssh_dynblock4 srcmówi, iptablesaby dopasować adres source ( src) do nazwanego set ( ssh_dynblock4)
  • odpowiada to sudo ipset test ssh_dynblock4 $IP(gdzie $IPzawiera źródłowy adres IP pakietu)
• -j SET --add-set ssh_dynblock4 src --existdodaje lub aktualizuje adres source ( src) z pakietu do zestawu IP ssh_dynblock4. Jeśli pozycja istnieje ( --exist), zostanie po prostu zaktualizowana.
  • odpowiada to sudo ipset -exist add ssh_dynblock4 $IP(gdzie $IPzawiera źródłowy adres IP pakietu)

Jeśli zamiast tego chcesz dopasować adres docelowy / docelowy, użyj dstzamiast niego src. Więcej informacji znajdziesz w instrukcji obsługi.

Zestawy zestawów

Zestawy IP mogą zawierać inne zestawy. Teraz, jeśli śledziłeś ten artykuł do tej pory, zastanawiasz się, czy można łączyć zestawy. I oczywiście tak jest. Dla zestawów IP z góry możemy utworzyć dwa zestawy wspólne ssh_dynblocki ssh_loggedonodpowiednio zawierać tylko zestawy IPv4 i tylko IPv6:

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

Kolejne pytanie, które powinno pojawić się w twojej głowie, brzmi: czy pozwala nam to dopasowywać i manipulować zestawami adresów IP w sposób niezależny od wersji IP.

Odpowiedź na to brzmi: TAK! (niestety, nie było to wyraźnie udokumentowane podczas ostatniej kontroli)

W związku z tym można przepisać zasady z poprzedniej sekcji, aby przeczytać:

-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

co jest o wiele bardziej zwięzłe. I tak, jest to wypróbowane i przetestowane i działa jak urok.

Wszystko razem: obrona SSH przed brutalną siłą

Na moich serwerach mam skrypt uruchamiany jako cronzadanie, które pobiera kilka nazw hostów i przetwarza je na adresy IP, a następnie podaje je do zestawu adresów IP dla „zaufanych hostów”. Chodzi o to, że zaufani gospodarze podejmują więcej prób zalogowania się na serwerze i niekoniecznie są blokowani tak długo, jak inni.

I odwrotnie, mam zablokowane całe kraje z łączeniem się z moim serwerem SSH, z (potencjalnym) wyjątkiem zaufanych hostów (tj. Kolejność reguł ma znaczenie).

Pozostaje to jednak ćwiczeniu dla czytelnika. W tym miejscu chciałbym dodać porządne rozwiązanie, które wykorzysta zestawy zawarte w ssh_loggedonzestawie, aby umożliwić przekazywanie kolejnych prób połączenia i nie podlegać takiej samej kontroli, jak inne pakiety.

Ważne jest, aby pamiętać o domyślnych limitach czasu 90 minut ssh_loggedoni 30 minut dla ssh_dynblocknastępujących iptableszasad:

-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

Do tej pory powinieneś zadać sobie pytanie, w jaki sposób łączący adres IP kończy się w ssh_loggedonpodzestawach. Więc czytaj dalej ...

Bonus: dodanie adresu IP, z którego logujesz się podczas logowania SSH

Jeśli eksperymentowałeś z sshrcprzyjaciółmi i dowiesz się o ich wadach. Ale PAM przybywa na ratunek. Moduł o nazwie pam_exec.sopozwala nam wywoływać skrypt podczas logowania SSH w punkcie, w którym wiemy, że użytkownik jest dopuszczony.

W /etc/pam.d/sshdponiżej pam_envi pam_selinuxwpisy dodać następujący wiersz:

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

i upewnij się, że twoja wersja skryptu ( /path/to/your/scriptpowyżej) istnieje i jest wykonywalna.

PAM używa zmiennych środowiskowych do komunikowania o tym, co się dzieje, dzięki czemu możesz użyć prostego skryptu takiego jak ten:

#!/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

Niestety ipsetnarzędzie nie ma wbudowanych inteligentnych funkcji netfiltera. Musimy więc odróżnić IPv4 od IPv6 IP set podczas dodawania naszego wpisu. W przeciwnym razie ipsetzałożymy, że chcemy dodać kolejny zestaw do zestawu, zamiast adresu IP. I oczywiście jest mało prawdopodobne, aby istniał zestaw nazwany na podstawie adresu IP :)

Sprawdzamy więc :adres IP i dołączamy 6do nazwy zestawu w takim przypadku i w 4innym przypadku.

Koniec.

Innym GUI, którego można użyć do skonfigurowania iptables, jest Firewall Builder . Umożliwia użytkownikom tworzenie elementów reguł jako obiektów w bazie danych, a następnie przeciąganie i upuszczanie tych obiektów w edytorze reguł w celu utworzenia pożądanych zasad zapory. Następnie aplikacja generuje plik skryptu ze wszystkimi poleceniami iptables wymaganymi do wdrożenia reguł.

W przeciwieństwie do niektórych innych rozwiązań GUI iptables, w których możesz zarządzać tylko jedną konfiguracją iptables na raz, za pomocą Firewall Builder możesz zarządzać dużą liczbą konfiguracji iptables za pomocą jednej aplikacji. Firewall Builder działa na systemach Linux, Windows i Mac OS X, istnieje już od ponad 10 lat i ma tysiące aktywnych użytkowników na całym świecie.

Pełne ujawnienie informacji - jestem współzałożycielem NetCitadel, firmy rozwijającej Firewall Builder.

rejestruj połączenie wychodzące z identyfikatorem użytkownika

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

przekierowanie portów / połączeń:

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

Dopasuj kilka nazw interfejsów do znaku wieloznacznego

Przykład: masz eth0 i eth1 i chciałby, aby umożliwić żadnego ruchu pomiędzy nimi?

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

Użyłem tego w przeszłości, aby dopasować veth<something>interfejsy dynamicznie tworzone i nazywane przez LXC. Więc mogę dopasować wszystko naraz veth+.

Celowo nazwałem też niektóre interfejsy _<something>, aby się z nimi równać _+.

Blokuj nietypowe wartości MSS

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

SYNPROXY target dla ochrony DDos

Celem tego celu jest sprawdzenie, czy host, który wysłał pakiet SYN, ustanawia połączenie lub nic nie robi po zainicjowaniu połączenia SYN. Jeśli nic nie robi, odrzuca pakiet przy minimalnym wysiłku.

Ustaw pakiety syn do tabeli śledzenia połączeń w surowej tabeli

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

Włącz synproxy dla serwera http:

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

Zasób: cel SYNPROXY z bloga RHEL

Ograniczanie wszystkich indywidualnych adresów IP do limitu przepustowości wychodzącej za pomocą zestawów IP

Możesz skonfigurować serwer tak, aby zezwalał tylko na każdy indywidualny stopień wykorzystania przepustowości IP 15GiB miesięcznie, w nadziei, że odzwierciedli lub uniknie ataku wykorzystania przepustowości, być może dla twojego zmierzonego limitu przepustowości u twojego dostawcy usług internetowych. Można to osiągnąć w następujący sposób:

Najpierw utwórz zestawy adresów IP dla IPv4 i 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

Teraz dodaj swoje reguły iptables. Pierwszy wiersz doda adres IP do zestawu, jeśli jeszcze go nie ma. Drugi wiersz nie będzie pasował, jeśli bajty przesłane dla adresu IP w zestawie są większe niż określona liczba. To samo dzieje się w przypadku 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

Zapobiegnie to atakom, takim jak użytkownik żądający dużego pliku z serwera przez długi czas lub z jakiejkolwiek usługi w tym zakresie. To samo można zrobić dla łańcucha INPUT.

Coś, co robię, głównie z powodu mojej niewiedzy o bardziej eleganckim rozwiązaniu, to ręczne sprawdzanie moich dzienników Nginx co 4 godziny, a serwer poczty loguje się co 2 minuty pod kątem nadmiernego dostępu przez poszczególne adresy IP. Uruchomiłem razem kilka skryptów, które:

1. Sprawdź access.loglistę 10 najlepszych adresów IP uporządkowanych według liczby trafień na serwer
2. Zrzuć wyniki do pliku dziennika
3. Popatrz na inny skrypt na ten plik dziennika i zablokuj wszelkie adresy IP, które trafiły na serwer więcej niż X razy w ciągu ostatnich X godzin
4. Ochroń moje iptables.save

Oto jak to wygląda:

#!/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

Jedną z rzeczy, które BARDZO ważne jest, aby zauważyć tutaj, że POTRZEBUJESZ ustawić białą listę lub zaczniesz blokować wiele autentycznych adresów IP z serwerów, z których otrzymujesz dużo wiadomości e-mail z lub w przypadku innych dzienników, adresy IP, które po prostu dużo uderzaj w serwer z uzasadnionych powodów. Moja biała lista jest właśnie wbudowana w ten skrypt, dodając rury grep zaraz po | grep ']' | które wyglądają mniej więcej tak: „grep -v 127.0 |” .
Musisz poświęcić trochę czasu, aby nauczyć serwer, które adresy IP o dużym natężeniu ruchu są prawidłowe, a które nie. Dla mnie oznaczało to, że musiałem spędzić mniej więcej pierwszy tydzień, sprawdzając ręcznie moje logi co kilka godzin, szukając ip o dużym natężeniu ruchu na iplocation.net, a następnie dodając te legalne, takie jak amazon, box.com, a nawet mój dom / biuro Zakresy adresów IP do tej białej listy. Jeśli tego nie zrobisz, prawdopodobnie zostaniesz zablokowany na własnym serwerze lub zaczniesz blokować legalne serwery poczty / sieci i powodować zakłócenia w ruchu e-mail lub ruchu.

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"

Znów wiem, że jest to prymitywne jak diabli, i prawdopodobnie istnieje ładny, czysty, skuteczny protokół, który to wszystko robi, ale nie wiedziałem o tym i ta sprawa trwa już rok lub dwa i powstrzymuje złych facetów. Jedyną rzeczą, którą bardzo POWAŻNIE polecam, jest posiadanie serwera proxy lub innego serwera w skrzydłach, którego można użyć do uzyskania dostępu do głównego serwera. Powodem jest to, że jeśli robisz tworzenie stron internetowych nieoczekiwanie, a ty pinguj siebie 2000 razy w ciągu 5 godzin, aby wykonać pewne testy, które można zablokować bez możliwości powrotu, z wyjątkiem serwera proxy.

Widać, że w checkBadIPs.shumieściłem grep -v 127.0, aw moich rzeczywistych plikach mam mnóstwo reguł ignorowania dla moich własnych adresów IP i innych zaufanych zakresów adresów IP, ale czasami twoje adresy IP się zmieniają, zapominasz o aktualizacji, a następnie jesteś zablokowany z własnego serwera.

W każdym razie, mam nadzieję, że to pomaga.

AKTUALIZACJA

Trochę zmieniłem rzeczy, więc teraz zamiast sprawdzania co kilka godzin sprawdzam niektóre logi co 2 minuty, głównie mój dziennik uwierzytelniania ssh i dziennik poczty, gdy były walone :(.

Konfiguruję określone skrypty dla każdego pliku dziennika, chociaż byłoby to łatwe z ręcznego skryptu, którego używam sam, gdy chcę sprawdzać dzienniki. Wygląda tak:

#!/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

Wymaga to 2 danych wejściowych podczas uruchamiania, pliku dziennika, który chcesz przeskanować, i jak daleko wstecz chcesz skanować.

Więc jeśli chciałbym sprawdzić mail.log pod kątem liczby adresów IP, powiedz 75 minut w przeszłość, uruchomiłbym:

$ sudo script.sh mail.log 75

Zgadzam się z komentarzami na temat ipsetów i flag tcp, ale wciąż wiele brakuje:

Używaj dopasowania geograficznego xtables-addons zamiast ipset dla list krajów. Regularnie aktualizuj dane geograficzne (co najmniej raz w miesiącu). Dane są bardziej dynamiczne niż lista ipset ognia i zapomnienia.

Rozważ śledzenie stanu połączenia za pomocą flag tcp. Na przykład RST lub ACK tcp ma sens tylko dla ustanowionego połączenia. SYN ma sens tylko dla nowych i powiązanych połączeń. SYN dla ustanowionego połączenia oznacza utratę SYN + ACK lub próbę włamania i powinien zostać zresetowany, ponieważ obie strony połączenia nie zgadzają się co do stanu.

Chociaż żaden, SYN + RST i FIN + RST nie są niedozwolonymi kombinacjami, SYN + FIN jest teraz ważny w ramach szybkiego otwierania TCP (opcja TCP 34), szczególnie w przypadku DNS. Pakiety SYN, nawet z szybkim otwieraniem, nie powinny być pofragmentowane. Nie uważam reguł z flagami PSH i URG za przydatne. Nie pomyl stanu śledzenia połączenia ze stanem TCP: Reakcja RST na pakiet SYN jest ustalana na potrzeby śledzenia.

SYNPROXY jest przeznaczony dla pakietów przesyłanych dalej i nie dodaje nic dla pakietów dostarczanych lokalnie poza obsługą syncookie.

Pakiety błędów ICMP zawsze będą w stanie pokrewnym i będą miały długość 48: 576, jeśli są poprawne. Długość 84: 1280 dla IPv6. Wszystkie pozostałe należy zignorować. Ponieważ ich maksymalny rozmiar jest również minimalnym MTU, nigdy nie należy ich fragmentować. Żądania ICMP (pingi, znaczniki czasu itp.) Zawsze będą nowe i odpowiedzi zostaną ustalone. Upuść pakiety ICMP w innych stanach.

Podobnie jak w przypadku przykładu SSH z niedawną listą i akceptującego tylko kolejne pakiety SYN, to samo należy zrobić dla SMTP i jest podobne do „szarej listy” tylko w odniesieniu do adresu IP.

W tabeli filtrów pierwsza (lub druga, jeśli najpierw akceptujesz ustanowione pakiety stanów) w łańcuchach wejściowych i wyjściowych powinna akceptować wszystko w interfejsie sprzężenia zwrotnego. Powinieneś zaufać własnym pakietom wewnętrznym. Jeśli nie możesz, masz większe problemy poza rozwiązaniem zapory ogniowej.

Wreszcie, nie ślepo kopiuj reguł, chyba że naprawdę rozumiesz, co oni robią. Robi to wiele podobnych list reguł i przez większość czasu wynik jest śmieszny.

#!/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