Saya yakin sysadmin Linux cukup akrab dengan iptables, antarmuka userland ke netfilterkerangka packet-filtering.

Sekarang, "Pertanyaan" ini dimaksudkan untuk menjadi Wiki Komunitas untuk mengumpulkan bersama berbagai potongan-potongan iptableskebijaksanaan. Tidak ada yang terlalu umum atau tidak jelas. Posting apa pun yang Anda tahu yang akan membantu orang lain memanfaatkan iptables.

Menggunakan daftar putih dan daftar hitam dengan 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

Script untuk membuka port

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

Memblokir portscan

# 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

Paket palsu / tidak valid

# 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

Blokir serangan Smurf

# 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

Blokir ICMP (alias ping)

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

Optimalkan Performa netfilter Menggunakan ipset

Jika Anda menulis banyak aturan serupa hanya berdasarkan IP, port, atau keduanya, pertimbangkan ipsetuntuk mengoptimalkan kinerja netfilter.

Sebagai contoh:

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

Ini berarti bahwa sebuah paket dengan alamat sumber 192.168.251.177 harus terlebih dahulu melewati ratusan aturan sebelum bisa mendapatkan putusan ACCEPT.

Tentu saja, sysadmin yang berpengalaman akan membagi aturan dengan subnet. Tapi itu tetap berarti ratusan aturan.

ipset untuk menyelamatkan!

Pertama, tentukan IP Set ipmapjenis:

ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16

Kemudian, isi dengan alamat:

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

Akhirnya, ganti ratusan aturan iptables di atas dengan satu aturan:

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

Ketika sebuah paket tiba, netfilter akan melakukan pencarian bitmap sangat cepat untuk IP sumber paket (src) terhadap Allowed_HostsIP Set. Semua paket yang berasal dari 192.168.0.0/16 akan mengalami satu aturan. Dan percayalah bahwa pencarian bitmap setidaknya dua urutan besarnya lebih cepat daripada melakukan ratusan iptables memeriksa aturan.

ipsettidak terbatas pada alamat IP. Ia juga dapat mencocokkan berdasarkan port, IP-port tuple, alamat jaringan / subnet, IP-MAC tuple, dan seterusnya dan seterusnya. Dan itu dapat mencocokkan kriteria tersebut sebagai sumber atau tujuan atau campuran keduanya (dalam kasus tupel).

Dan akhirnya, dengan ipsetAnda dapat secara otomatis memasukkan alamat IP dalam daftar hitam / daftar putih. Daftar hitam / daftar putih ini juga dapat 'menua', sehingga secara otomatis menghapus alamat IP setelah jumlah waktu yang dapat dikonfigurasi berlalu.

Silakan merujuk ke ipsethalaman manual untuk lebih jelasnya.

CATATAN SANGAT PENTING:

Beberapa distro Linux mungkin tidak memiliki dukungan 'out-of-the-box' untuk ipset(misalnya Ubuntu 10,04 memiliki masalah ini). Pada sistem ini satu metode adalah menginstal ipsetdari kode sumber.

Sebagai gantinya, unduh ipsetsumber dari situs webnya: http://ipset.netfilter.org/install.html

Atau, jika Anda menggunakan xtables-addons, ipset yang termasuk dalam sumbernya: http://xtables-addons.sourceforge.net/

Tambahkan komentar ke aturan Anda:

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

Blokir Serangan TCP yang Terkenal

Tambahkan aturan berikut, sebaiknya di -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

Serangan yang diblokir adalah, masing-masing:

• Serangan SYN-FIN
• Serangan SYN-RST
• Serangan X-Mas
• pemindaian FIN nmap
• NULLflags attack
• Serangan ALLflags

(jangan ragu untuk mengedit nama serangan di atas)

Mengaktifkan NAT

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

Langkah 1 mengatur parameter kernel untuk memungkinkan penerusan ip, langkah 2 mengatur aturan iptables yang memungkinkan NAT pada antarmuka eth0.

Blokir serangan ICMP

Tambahkan aturan berikut, sebaiknya di -t raw -A PREROUTING

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

Aturan pertama memblokir semua paket ICMP yang "bendera fragmentasi" bukan 0. (ICMP tidak boleh difragmentasi; mereka harus membawa muatan kecil)

Aturan kedua memblokir paket ICMP unfragmented yang terlalu besar.

menggunakan FireHOL - pembungkus iptables yang nyaman

Saya menemukan itu jauh lebih intuitif daripada perintah iptables langsung. Khusus untuk orang-orang dengan pengalaman masa lalu dengan firewall lain:

FireHOL adalah generator firewall iptables yang menghasilkan firewall penyaringan paket iptables stateful, pada host dan router Linux dengan sejumlah antarmuka jaringan, sejumlah rute, sejumlah layanan yang dilayani, sejumlah kompleksitas antara variasi layanan (termasuk positif dan negatif ekspresi).

(dari file iptables_tricks.txt saya, dikompilasi ulang dari banyak tempat: P)

Membuat iptables menunggu 15 detik antara koneksi baru dari IP yang sama pada port 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

Tutorial video IPTABLES

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

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

Episode terakhir

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

Akan menjadi awal yang baik untuk pemula.

Set IP ditinjau kembali

Sudah ada jawaban yang menyebutkan set IP. Namun, ini agak satu dimensi karena berfokus pada perolehan kinerja dibandingkan aturan klasik dan fakta bahwa set IP mengurangi masalah yang dimiliki seseorang dengan banyak alamat IP individual yang tidak dapat dengan mudah dinyatakan sebagai subnet dalam notasi CIDR.

Notasi digunakan di bawah ini

Karena ipsetsaya akan menggunakan notasi yang dibaca ipset restoredan ditulis oleh ipset save.

Sejalan dengan iptables(dan ip6tables) aturan, saya akan menggunakan notasi yang dibaca iptables-restoredan ditulis oleh iptables-save. Ini menghasilkan notasi yang lebih pendek dan memungkinkan saya untuk menyoroti aturan IPv4-only (prefixed -4) atau only-IPv6 (prefixed -6).

Dalam beberapa contoh kita akan mengalihkan aliran paket ke rantai lain. Rantai diasumsikan ada pada saat itu, sehingga garis-garis untuk membuat rantai tidak diproduksi (juga tidak ada nama tabel yang disebutkan atau perintah-perintah COMMITdi akhir).

Set IP tingkat lanjut

Set IP dapat melakukan lebih banyak daripada yang disebutkan dalam jawaban lain dan Anda harus membaca dokumentasi set IP ( ipset(8)) bersama dengan iptables-extensions(8)tambahan entri singkat ini di sini.

Sebagai contoh saya akan terutama berfokus pada tiga jenis set: hash:ip, hash:netdan list:set, tetapi ada lebih dari mereka dan mereka semua memiliki kasus penggunaan valid.

Misalnya, Anda juga dapat mencocokkan nomor port, bukan hanya alamat IP .

Menyimpan dan memulihkan set IP seperti dengan iptables-savedaniptables-restore

Anda dapat membuat deklarasi set IP secara massal dan mengimpornya dengan memasukkannya ke dalam pip ipset restore. Jika Anda ingin membuat perintah Anda lebih tangguh terhadap entri yang sudah ada, gunakan ipset -exist restore.

Jika aturan Anda ada dalam file yang disebut default.setAnda akan menggunakan:

ipset -exist restore < default.set

File seperti itu dapat berisi entri untuk createditetapkan dan addentri ke dalamnya. Tetapi umumnya sebagian besar perintah dari baris perintah tampaknya memiliki versi yang sesuai dalam file. Contoh (membuat satu set server 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

Di sini satu set dibuat untuk IPv4 ( dns4) dan satu set untuk IPv6 ( dns6).

Timeout pada set IP

Timeout dalam set IP dapat ditetapkan sebagai default per set dan juga per entri. Ini sangat berguna untuk skenario di mana Anda ingin memblokir seseorang untuk sementara waktu (mis. Untuk pemindaian port atau berusaha memaksa server SSH Anda dengan kasar).

Cara kerjanya adalah sebagai berikut (default selama pembuatan set 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

Kami akan kembali ke set khusus di bawah ini dan alasan mengapa mereka mengaturnya.

Jika Anda ingin mengatur batas waktu Anda untuk alamat IP tertentu, Anda bisa mengatakan:

add ssh_dynblock4 1.2.3.4 timeout 7200

Untuk memblokir IP 1.2.3.4 selama dua jam, alih-alih setengah (standar) default.

Jika Anda melihatnya ipset save ssh_dynblock4setelah beberapa saat, Anda akan melihat sesuatu seperti:

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

Peringatan batas waktu

• batas waktu adalah fitur pada set yang diberikan. Jika set tidak dibuat dengan dukungan batas waktu Anda akan menerima kesalahan (misalnya Kernel error received: Unknown error -1).
• batas waktu diberikan dalam detik. Gunakan ekspresi aritmatika Bash untuk mendapatkan dari menit ke detik, misalnya. Misalnya:sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))

Memeriksa apakah ada entri dalam set IP yang diberikan

Di dalam skrip Anda dapat bermanfaat untuk melihat apakah entri sudah ada. Ini dapat dicapai dengan ipset testyang mengembalikan nol jika entri ada dan bukan nol sebaliknya. Jadi cek biasa dapat diterapkan dalam skrip:

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

Namun, dalam banyak kasus Anda lebih suka menggunakan -existsakelar ipsetuntuk mengarahkannya agar tidak mengeluh tentang entri yang ada.

Mengisi set IP dari iptablesaturan

Ini, menurut saya, adalah salah satu fitur pembunuh set IP. Anda tidak hanya dapat mencocokkan dengan entri set IP, Anda juga dapat menambahkan entri baru ke set IP yang ada.

Misalnya dalam jawaban untuk pertanyaan ini, Anda memiliki:

-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

... dengan tujuan untuk menilai batas upaya koneksi ke SSH (TCP port 22). Modul yang digunakan recentmelacak upaya koneksi terbaru. Alih-alih statemodul, saya lebih suka 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

Dalam hal ini saya mengarahkan aliran ke SSHrantai sedemikian rupa sehingga saya tidak perlu mengulangi sendiri -p tcp --dport sshuntuk setiap aturan tunggal.

Untuk mengulangi:

• -m setmembuat iptablessadar bahwa kita sedang menggunakan switch dari setmodul (yang menangani IP set)
• --match-set ssh_dynblock4 srcmemberitahu iptablesagar mencocokkan sumber ( src) alamat dengan set bernama ( ssh_dynblock4)
  • ini sesuai dengan sudo ipset test ssh_dynblock4 $IP(di mana $IPberisi alamat IP sumber untuk paket)
• -j SET --add-set ssh_dynblock4 src --existmenambah atau memperbarui alamat sumber ( src) dari paket ke dalam set IP ssh_dynblock4. Jika ada entri ( --exist) itu hanya akan diperbarui.
  • ini sesuai dengan sudo ipset -exist add ssh_dynblock4 $IP(di mana $IPberisi alamat IP sumber untuk paket)

Jika Anda ingin mencocokkan alamat target / tujuan, Anda akan menggunakannya dstsebagai gantinya src. Konsultasikan manual untuk opsi lebih lanjut.

Set set

Set IP dapat berisi set lainnya. Sekarang jika Anda mengikuti artikel sampai di sini Anda akan bertanya-tanya apakah mungkin untuk menggabungkan set. Dan tentu saja. Untuk set IP dari atas kita dapat membuat dua set gabungan ssh_dynblockdan ssh_loggedonmasing - masing berisi set IPv4-only dan IPv6-only:

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

Dan pertanyaan berikutnya yang harus muncul dalam pikiran Anda adalah apakah ini memungkinkan kami untuk mencocokkan dan dan memanipulasi set IP dalam mode IP versi-agnostik.

Dan jawabannya adalah: Ya! (Sayangnya, ini tidak didokumentasikan secara eksplisit terakhir kali saya periksa)

Akibatnya aturan dari bagian sebelumnya dapat ditulis ulang untuk dibaca:

-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

yang jauh lebih ringkas. Dan ya, ini dicoba dan diuji dan bekerja seperti pesona.

Menyatukan semuanya: SSH brute-force defense

Di server saya, saya memiliki skrip yang dijalankan sebagai cronpekerjaan yang mengambil banyak nama host dan menyelesaikannya ke alamat IP, kemudian memasukkannya ke dalam set IP untuk "host tepercaya". Idenya adalah bahwa host tepercaya mendapatkan lebih banyak upaya untuk masuk ke server dan tidak harus diblokir selama orang lain.

Sebaliknya, saya memiliki seluruh negara yang diblokir dari menghubungkan ke server SSH saya, dengan pengecualian (potensial) dari host tepercaya (yaitu urutan aturan masalah).

Namun, itu dibiarkan sebagai latihan untuk pembaca. Di sini saya ingin menambahkan solusi yang rapi yang akan menggunakan set yang terkandung dalam ssh_loggedonset untuk memungkinkan upaya koneksi berikutnya untuk diberikan dan tidak menjadi subyek pengawasan yang sama dengan paket lainnya.

Penting untuk mengingat batas waktu default 90 menit ssh_loggedondan 30 menit ssh_dynblockketika melihat iptablesaturan berikut :

-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

Sekarang Anda harus bertanya pada diri sendiri bagaimana alamat IP yang menghubungkan berakhir di ssh_loggedonsub-set. Jadi baca terus ...

Bonus: menambahkan IP yang Anda masuk dengan selama SSH masuk

Jika Anda telah bereksperimen dengan sshrcdan berteman, Anda akan mengetahui kekurangannya. Tapi PAM datang untuk menyelamatkan. Modul bernama pam_exec.somemungkinkan kita untuk memanggil skrip selama masuk SSH pada titik di mana kita tahu bahwa pengguna diterima.

Di /etc/pam.d/sshdbawah pam_envdan pam_selinuxentri menambahkan baris berikut:

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

dan pastikan versi skrip Anda (di /path/to/your/scriptatas) ada dan dapat dieksekusi.

PAM menggunakan variabel lingkungan untuk mengomunikasikan apa yang terjadi, sehingga Anda dapat menggunakan skrip sederhana seperti ini:

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

Sayangnya ipsetutilitas tersebut tampaknya tidak memiliki kecerdasan netfilter bawaan. Jadi kita perlu membedakan antara set IP IPv4 dan IPv6 saat menambahkan entri kita. Kalau tidak ipsetakan menganggap kita ingin menambahkan set lain ke set set, bukan IP. Dan tentu saja itu tidak mungkin bahwa akan ada satu set bernama setelah IP :)

Jadi kami memeriksa :alamat IP dan menambahkan 6nama yang ditetapkan dalam kasus tersebut dan 4sebaliknya.

Tamat.

GUI lain yang dapat digunakan untuk mengkonfigurasi iptables adalah Firewall Builder . Itu memungkinkan pengguna membuat elemen aturan sebagai objek dalam database dan kemudian drag-and-drop objek ini ke editor aturan untuk membuat kebijakan firewall yang diinginkan. Aplikasi kemudian menghasilkan file skrip dengan semua perintah iptables yang diperlukan untuk mengimplementasikan aturan.

Tidak seperti beberapa solusi GUI iptables lain di mana Anda hanya dapat mengelola satu konfigurasi iptables pada satu waktu, dengan Firewall Builder Anda dapat mengelola sejumlah besar konfigurasi iptables semua dari satu aplikasi. Firewall Builder berjalan di Linux, Windows dan Mac OS X, telah ada selama lebih dari 10 tahun dan memiliki ribuan pengguna aktif di seluruh dunia.

Pengungkapan Penuh - Saya adalah pendiri NetCitadel yang merupakan perusahaan yang mengembangkan Firewall Builder.

log koneksi keluar dengan uid

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 / penerusan koneksi:

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

Cocokkan beberapa nama antarmuka dengan wildcard

Contoh: Anda memiliki eth0 dan eth1 ingin mengizinkan lalu lintas di antara mereka?

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

Saya telah menggunakan ini di masa lalu untuk mencocokkan veth<something>antarmuka yang dibuat dan dinamai secara dinamis oleh LXC. Jadi saya bisa mencocokkan semuanya sekaligus veth+.

Saya juga sengaja menamai beberapa antarmuka _<something>agar sesuai _+.

Blokir nilai MSS yang tidak biasa

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

SYNPROXY target untuk perlindungan DDos

Tujuan dari target ini adalah untuk memeriksa apakah host yang mengirim paket SYN membuat koneksi atau tidak melakukan apa-apa setelah memulai koneksi SYN. Jika tidak melakukan apa-apa, ia membuang paket dengan usaha minimal.

Setel paket syn ke tabel pelacakan koneksi di tabel mentah

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

Aktifkan synproxy untuk server http:

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

Sumber: target SYNPROXY dari blog RHEL

Membatasi semua alamat IP individu menjadi kuota bandwidth keluar dengan Set IP

Anda dapat mengonfigurasikan server Anda untuk hanya mengizinkan setiap IP 15GiByte penggunaan bandwidth per bulan, dengan harapan dapat mencerminkan atau menghindari serangan penggunaan bandwidth, mungkin untuk kuota bandwidth terukur Anda di ISP Anda. Ini dapat dicapai sebagai berikut:

Pertama-tama buat set IP untuk IPv4 dan 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

Sekarang tambahkan aturan iptables Anda. Baris pertama akan menambahkan IP ke set jika belum ada di sana. Baris kedua tidak akan cocok jika byte yang ditransfer untuk IP dalam set lebih besar dari jumlah yang ditentukan. Kemudian hal yang sama dilakukan untuk 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

Ini akan mencegah serangan seperti pengguna yang meminta file besar dari server web Anda untuk jangka waktu yang lama, atau dari layanan apa pun dalam hal ini. Hal yang sama dapat dilakukan untuk rantai INPUT.

Sesuatu yang saya lakukan, terutama karena ketidaktahuan saya akan solusi yang lebih elegan, adalah memeriksa secara manual log Nginx saya setiap 4 jam dan server mail mencatat setiap 2 menit untuk akses berlebihan oleh masing-masing IP. Saya menjalankan beberapa skrip bersama bahwa:

1. Periksa access.logdan daftarkan 10 IP teratas yang diorganisasikan oleh berapa banyak hit yang mereka miliki ke server
2. Buang hasilnya menjadi file log
3. Minta skrip lain melihat file log itu dan ban IP apa pun yang telah menghantam server lebih dari jumlah X kali selama X jam terakhir
4. Simpan saya iptables.save

Begini tampilannya:

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

Satu hal yang SANGAT penting untuk dicatat di sini adalah bahwa Anda PERLU untuk menyiapkan daftar putih atau Anda akan mulai memblokir banyak IP asli dari server yang Anda baru saja menerima banyak email dari atau dalam kasus log lain, IP itu tekan saja server Anda banyak untuk alasan yang sah. Daftar putih saya baru saja dibangun ke dalam skrip ini dengan menambahkan pipa grep tepat setelah | grep ']' | yang terlihat seperti ini "grep -v 127.0 |" .
Anda perlu meluangkan waktu untuk mengajar server Anda tentang IP lalu lintas tinggi mana yang sah dan mana yang tidak. Bagi saya ini berarti saya harus menghabiskan minggu pertama atau lebih memeriksa log saya secara manual setiap beberapa jam, mencari ip lalu lintas tinggi di iplocation.net dan kemudian menambahkan yang sah seperti amazon, box.com atau bahkan rumah / kantor saya Rentang IP ke daftar putih ini. Jika tidak, kemungkinan besar Anda akan diblokir dari server Anda sendiri atau Anda akan mulai memblokir mail / server web yang sah dan menyebabkan gangguan pada email atau lalu lintas.

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"

Sekali lagi saya tahu ini sangat kasar dan mungkin ada protokol efisien bersih yang bagus yang melakukan semua ini tetapi saya tidak tahu tentang hal ini dan hal ini telah berlangsung selama satu atau dua tahun sekarang dan menjaga orang-orang jahat di teluk. Satu hal yang saya akan sangat SERIUS merekomendasikan adalah bahwa Anda memiliki proxy atau server lain di sayap yang dapat Anda gunakan untuk mengakses server utama Anda .. Alasannya adalah bahwa jika Anda melakukan pengembangan web suatu hari tiba-tiba dan Anda ping diri Anda 2000 kali dalam 5 jam untuk beberapa pengujian Anda bisa diblokir tanpa jalan kembali kecuali untuk proxy.

Anda dapat melihat bahwa di checkBadIPs.shsaya telah meletakkan grep -v 127.0 dan dalam file saya yang sebenarnya, saya memiliki banyak aturan abaikan untuk IP saya sendiri dan rentang IP tepercaya lainnya, tetapi terkadang IP Anda berubah, Anda lupa memperbarui dan kemudian Anda terkunci keluar dari server Anda sendiri.

Bagaimanapun, harapan itu membantu.

MEMPERBARUI

Saya telah mengubah hal-hal sedikit sehingga sekarang alih-alih memeriksa setiap beberapa jam, saya memiliki beberapa log diperiksa setiap 2 menit, terutama log ssh auth dan log mail saat mereka ditumbuk :(.

Saya menyiapkan skrip khusus untuk setiap file log meskipun akan cukup mudah dari skrip manual yang saya gunakan sendiri ketika ingin memeriksa log. Terlihat seperti ini:

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

Ini membutuhkan 2 input saat dijalankan, file log yang ingin Anda pindai dan seberapa jauh ke masa lalu yang ingin Anda pindai.

Jadi jika saya ingin memeriksa mail.log untuk hitungan ip katakan 75 menit ke masa lalu saya akan menjalankan:

$ sudo script.sh mail.log 75

Saya setuju dengan komentar tentang ipset dan bendera tcp, tetapi masih banyak yang hilang:

Gunakan xtables-addons yang cocok dengan geoip sebagai ganti ipsets untuk daftar negara. Perbarui data geoip secara rutin (setidaknya sekali sebulan). Data lebih dinamis dari daftar ipset api-dan-lupa.

Pertimbangkan pelacakan status koneksi dengan flag tcp. Sebagai contoh, tcp RST atau ACK hanya masuk akal untuk koneksi yang dibuat. SYN hanya masuk akal untuk koneksi baru dan terkait. SYN untuk koneksi yang dibuat berarti SYN + ACK Anda hilang atau upaya hack dan harus diatur ulang karena kedua sisi koneksi tidak setuju untuk menyatakan.

Meskipun tidak ada, SYN + RST dan FIN + RST adalah kombinasi ilegal, SYN + FIN sekarang valid di bawah TCP fast-open (opsi TCP 34), terutama untuk DNS. Paket SYN, bahkan dengan buka cepat, tidak boleh difragmentasi. Saya tidak menganggap aturan dengan flag PSH dan URG bermanfaat. Jangan bingung kondisi pelacakan koneksi dengan status TCP: Respons RST terhadap paket SYN dibuat untuk tujuan pelacakan.

SYNPROXY adalah untuk paket yang diteruskan dan tidak menambahkan apa pun untuk yang dikirimkan secara lokal di luar dukungan sinkronisasi.

Paket kesalahan ICMP akan selalu berada dalam status terkait dan panjang 48: 576 jika valid. Durasi 84: 1280 untuk IPv6. Semua yang lain harus diabaikan. Karena ukuran maksimumnya juga merupakan MTU minimum, mereka tidak boleh terfragmentasi. Permintaan ICMP (ping, cap waktu, dll.) Akan selalu baru, dan balasan akan dibuat. Jatuhkan paket ICMP di negara bagian lain.

Seperti contoh SSH dengan daftar terbaru dan hanya menerima paket SYN berikutnya, hal yang sama harus dilakukan untuk SMTP, dan mirip dengan "greylisting" pada datum alamat IP saja.

Dalam tabel filter, aturan pertama (atau kedua, jika menerima paket state yang ditetapkan terlebih dahulu) dalam rantai input dan output harus menerima semua yang ada di antarmuka loopback. Anda harus mempercayai paket internal Anda sendiri. Jika tidak bisa, Anda memiliki masalah yang lebih besar di luar solusi firewall.

Terakhir, jangan menyalin aturan secara membabi buta kecuali Anda benar-benar mengerti apa yang mereka lakukan. Begitu banyak daftar aturan serupa yang melakukan itu, dan sebagian besar waktu, hasilnya menggelikan.

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