Tenho certeza de que os administradores de sistemas Linux estão familiarizados com iptablesa interface do usuário para a netfilterestrutura de filtragem de pacotes.

Agora, essa "pergunta" deve ser um Wiki da comunidade para reunir vários pedaços de iptablessabedoria. Nada é muito comum ou muito obscuro. Poste qualquer coisa que você saiba que ajude outras pessoas a aproveitar ao máximo iptables.

Usando lista branca e lista negra com 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 para abrir portas

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

Bloquear 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

Pacotes falsificados / inválidos

# 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

Bloquear ataques 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

Bloquear ICMP (também conhecido como ping)

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

Otimize o desempenho do netfilter usando ipset

Se você escrever muitas regras semelhantes baseadas em mero IP, porta ou ambas, considere usar ipsetpara otimizar o desempenho do netfilter.

Por exemplo:

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

Isso significa que um pacote com o endereço de origem 192.168.251.177 deve primeiro percorrer centenas de regras antes de obter o veredicto de ACEITAR.

Obviamente, administradores de sistemas experientes dividirão as regras por sub-rede. Mas isso ainda significa centenas de regras.

ipset para o resgate!

Primeiro, defina um conjunto de IPs do ipmaptipo:

ipset -N Allowed_Hosts ipmap --network 192.168.0.0/16

Em seguida, preencha-o com os endereços:

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

Por fim, substitua as centenas de regras do iptables acima por uma regra:

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

Quando um pacote chega, o netfilter executará uma pesquisa de bitmap muito rápida pelo IP de origem (src) do pacote no Allowed_Hostsconjunto de IPs. Todos os pacotes provenientes de 192.168.0.0/16 experimentarão uma regra. E acredite em mim: pesquisar um bitmap é pelo menos duas ordens de magnitudes mais rápido do que realizar centenas de verificação de regras do iptables.

ipsetnão está limitado a endereços IP. Também pode corresponder com base em portas, tupla de porta IP, endereços de rede / sub-rede, tupla de IP-MAC e assim por diante. E pode corresponder a esses critérios como origem ou destino ou uma combinação de ambos (no caso de tuplas).

E, finalmente, ipsetvocê pode colocar automaticamente os endereços IP nas listas negras / brancas. Essas listas negras / listas brancas também podem "envelhecer", excluindo automaticamente o endereço IP após um período configurável.

Por favor, consulte a ipsetpágina do manual para mais detalhes.

NOTA MUITO IMPORTANTE:

Algumas distribuições de Linux podem não ter suporte 'pronto para uso' ipset(por exemplo, Ubuntu 10.04 teve esse problema). Nestes sistemas, um método é instalar a ipsetpartir do código fonte.

Em vez disso, faça o download ipsetda fonte do site: http://ipset.netfilter.org/install.html

Como alternativa, se você usar xtables-addons, o ipset será incluído em sua fonte: http://xtables-addons.sourceforge.net/

Adicione comentários às suas regras:

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

Bloquear ataques TCP conhecidos

Adicione as seguintes regras, de preferência em -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

Os ataques bloqueados são, respectivamente:

• Ataque SYN-FIN
• Ataque SYN-RST
• Ataque X-Mas
• Verificação FIN do nmap
• Ataque de NULLflags
• Ataque de bandeiras

(fique à vontade para editar os nomes dos ataques acima)

Ativando o NAT

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

A etapa 1 define o parâmetro do kernel para permitir o encaminhamento de ip, a etapa 2 configura uma regra de tabelas de ip que habilita o NAT na interface eth0.

Bloquear ataques de ICMP

Adicione as seguintes regras, de preferência em -t raw -A PREROUTING

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

A primeira regra bloqueia todos os pacotes ICMP cujo "sinalizador de fragmentação" não é 0. (ICMP nunca deve ser fragmentado; eles devem estar carregando pequenas cargas úteis)

A segunda regra bloqueia pacotes ICMP não fragmentados de tamanho grande.

usando FireHOL - wrapper conveniente do iptables

Achei muito mais intuitivo do que os comandos diretos do iptables. Especialmente para pessoas com experiência anterior com outros firewalls:

O FireHOL é um gerador de firewall iptables que produz firewalls stateful de filtragem de pacotes iptables, em hosts e roteadores Linux com qualquer número de interfaces de rede, qualquer número de rotas, qualquer número de serviços servidos, qualquer complexidade entre variações dos serviços (incluindo positivo e negativo). expressões).

(do meu arquivo iptables_tricks.txt, recompilado de vários lugares: P)

Faz o iptables esperar 15 segundos entre novas conexões do mesmo IP na porta 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

Tutoriais em vídeo IPTABLES

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

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

Episódio final

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

Será um bom começo para qualquer novato.

Conjuntos de IP revisitados

Já existe uma resposta mencionando conjuntos de IPs. No entanto, é bastante unidimensional, pois se concentra nos ganhos de desempenho em relação às regras clássicas e no fato de que os conjuntos de IP atenuam o problema que se tem com muitos endereços IP individuais que não podem ser facilmente expressos como uma sub-rede na notação CIDR.

Notação usada abaixo

Pois ipsetusarei a notação lida ipset restoree escrita por ipset save.

Correspondentemente, para as regras iptables(e ip6tables), usarei a notação conforme lida iptables-restoree escrita por iptables-save. Isso contribui para uma notação mais curta e me permite destacar regras em potencial apenas IPv4 (prefixadas -4) ou somente IPv6 (prefixadas -6).

Em alguns exemplos, desviaremos o fluxo de pacotes para outra cadeia. Presume-se que a cadeia exista nesse ponto; portanto, as linhas para criar as cadeias não são produzidas (nem o nome da tabela é mencionado ou os comandos são COMMITexibidos no final).

Conjuntos de IP avançados

Os conjuntos de IPs podem fazer muito mais do que o mencionado na outra resposta e você deve definitivamente ler a documentação do conjunto de IPs ( ipset(8)), iptables-extensions(8)além desta breve entrada aqui.

Por exemplo, eu vou concentrar-se principalmente em três tipos de conjunto: hash:ip, hash:nete list:set, mas há mais do que aqueles e todos eles têm casos de uso válidos.

Você pode, por exemplo, também combinar números de porta, não apenas endereços IP .

Salvar e restaurar conjuntos de IPs como iptables-saveeiptables-restore

Você pode criar declarações de conjunto de IP em massa e importá-las, canalizando-as para ipset restore. Se você deseja tornar seu comando mais resistente a entradas já existentes, use ipset -exist restore.

Se suas regras estiverem em um arquivo chamado, default.setvocê usaria:

ipset -exist restore < default.set

Um arquivo como esse pode conter entradas para createconjuntos e addentradas para eles. Mas geralmente a maioria dos comandos da linha de comando parece ter uma versão correspondente nos arquivos. Exemplo (criando um conjunto de servidores 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

Aqui, um conjunto é criado para IPv4 ( dns4) e outro para IPv6 ( dns6).

Tempo limite em conjuntos de IP

Os tempos limites nos conjuntos de IPs podem ser definidos como padrão por conjunto e também por entrada. Isso é muito útil para cenários em que você deseja bloquear alguém temporariamente (por exemplo, para varredura de porta ou tentativa de força bruta no servidor SSH).

A maneira como isso funciona é a seguinte (padrão durante a criação de conjuntos de 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

Voltaremos a esses conjuntos específicos abaixo e à lógica de por que eles são definidos da maneira que são.

Se você deseja definir o tempo limite para um endereço IP específico, basta dizer:

add ssh_dynblock4 1.2.3.4 timeout 7200

Para bloquear o IP 1.2.3.4 por duas horas, em vez da meia hora padrão (definida).

Se você analisar isso ipset save ssh_dynblock4daqui a pouco, verá algo como:

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

Advertências de tempo limite

• tempos limite são um recurso em qualquer conjunto. Se o conjunto não foi criado com suporte ao tempo limite, você receberá um erro (por exemplo Kernel error received: Unknown error -1).
• tempos limite são dados em segundos. Use expressões aritméticas do Bash para passar de minutos a segundos, por exemplo. Por exemplo:sudo ipset add ssh_dynblock4 1.2.3.4 timeout $((120*60))

Verificando se existe uma entrada em um determinado conjunto de IPs

Dentro de seus scripts, pode ser útil verificar se uma entrada já existe. Isso pode ser alcançado com o ipset testqual retorna zero se a entrada existir e diferente de zero. Portanto, as verificações usuais podem ser aplicadas em um script:

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

No entanto, em muitos casos, você prefere usar a -existopção ipsetpara direcioná-la a não reclamar das entradas existentes.

Preenchendo conjuntos de IPs de iptablesregras

Este, na minha opinião, é um dos principais recursos dos conjuntos de IPs. Além de poder corresponder às entradas de um conjunto de IPs, você também pode adicionar novas entradas a um conjunto de IPs existente.

Por exemplo, nesta resposta a esta pergunta, você tem:

-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

... com a intenção de limitar a taxa de tentativas de conexão ao SSH (porta TCP 22). O módulo usado recentcontrola as tentativas recentes de conexão. Em vez do statemódulo, eu prefiro o conntrackmódulo, no entanto.

# 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

Nesse caso, estou redirecionando o fluxo para a SSHcadeia, de modo que não precise me repetir -p tcp --dport sshpara todas as regras.

Reiterar:

• -m settorna iptablesconscientes de que estamos usando interruptores do setmódulo (que lida com conjuntos IP)
• --match-set ssh_dynblock4 srcinforma iptablespara combinar o endereço de origem ( src) com o conjunto nomeado ( ssh_dynblock4)
  • corresponde a sudo ipset test ssh_dynblock4 $IP(onde $IPcontém o endereço IP de origem do pacote)
• -j SET --add-set ssh_dynblock4 src --existadiciona ou atualiza o endereço de origem ( src) do pacote no conjunto de IPs ssh_dynblock4. Se existir uma entrada ( --exist), ela será simplesmente atualizada.
  • corresponde a sudo ipset -exist add ssh_dynblock4 $IP(onde $IPcontém o endereço IP de origem do pacote)

Se você deseja corresponder ao endereço de destino / destino, use em dstvez de src. Consulte o manual para mais opções.

Conjuntos de conjuntos

Os conjuntos de IPs podem conter outros conjuntos. Agora, se você seguiu o artigo até aqui, terá se perguntado se é possível combinar conjuntos. E é claro que é. Para os conjuntos de IPs acima, podemos criar dois conjuntos de juntas ssh_dynblocke, ssh_loggedonrespectivamente, para conter os conjuntos somente de IPv4 e somente 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

E a próxima pergunta que deve aparecer em sua mente é se isso nos permite combinar e manipular conjuntos de IP de maneira independente de versão de IP.

E a resposta para isso é retumbante: SIM! (infelizmente, isso não foi documentado explicitamente da última vez que verifiquei)

Consequentemente, as regras da seção anterior podem ser reescritas para ler:

-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

o que é muito mais conciso. E sim, isso é experimentado e testado e funciona como um encanto.

Juntando tudo: defesa da força bruta do SSH

Nos meus servidores, eu tenho um script executado como um crontrabalho que pega vários nomes de host e os resolve para endereços IP, depois alimenta-o no conjunto de IPs para "hosts confiáveis". A idéia é que os hosts confiáveis ​​obtenham mais tentativas de logon no servidor e não sejam necessariamente bloqueados pelo tempo que mais alguém.

Por outro lado, países inteiros impediram de se conectar ao meu servidor SSH, com a exceção (potencial) de hosts confiáveis ​​(ou seja, a ordem das regras é importante).

No entanto, isso é deixado como um exercício para o leitor. Aqui, eu gostaria de adicionar uma solução elegante que utilizará os conjuntos contidos no ssh_loggedonconjunto para permitir que tentativas subseqüentes de conexão sejam realizadas e não sejam sujeitas ao mesmo escrutínio que os outros pacotes.

É importante lembrar os tempos limite padrão de 90 minutos ssh_loggedone 30 minutos ssh_dynblockao observar as seguintes iptablesregras:

-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

Agora, você deve se perguntar como o endereço IP de conexão termina nos ssh_loggedonsubconjuntos. Então continue a ler ...

Bônus: adicionando o IP com o qual você efetua login durante o logon SSH

Se você já fez experiências com sshrcamigos, já aprendeu suas deficiências. Mas o PAM vem em socorro. Um módulo chamado pam_exec.sopermite invocar um script durante o logon SSH em um ponto em que sabemos que o usuário é admitido.

No /etc/pam.d/sshdabaixo do pam_enve pam_selinuxentradas adicione a seguinte linha:

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

e verifique se a sua versão do script ( /path/to/your/scriptacima) existe e é executável.

O PAM usa variáveis ​​de ambiente para comunicar o que está acontecendo, para que você possa usar um script simples como este:

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

Infelizmente, o ipsetutilitário não parece ter as esperanças internas do netfilter. Portanto, precisamos distinguir entre o conjunto de IPs IPv4 e IPv6 ao adicionar nossa entrada. Caso contrário ipset, assumiremos que queremos adicionar outro conjunto ao conjunto de conjuntos, em vez do IP. E é claro que é improvável que exista um conjunto com o nome de um IP :)

Portanto, verificamos :o endereço IP e anexamos 6ao nome do conjunto nesse caso ou 4não.

O fim.

Outra GUI que pode ser usada para configurar o iptables é o Firewall Builder . Ele permite que os usuários criem elementos de regra como objetos em um banco de dados e, em seguida, arraste e solte esses objetos em um editor de regras para criar a política de firewall desejada. O aplicativo gera um arquivo de script com todos os comandos iptables necessários para implementar as regras.

Diferentemente de outras soluções da GUI do iptables, nas quais você só pode gerenciar uma configuração de iptables por vez, com o Firewall Builder, você pode gerenciar um grande número de configurações de iptables, tudo a partir de um único aplicativo. O Firewall Builder roda em Linux, Windows e Mac OS X, existe há mais de 10 anos e possui milhares de usuários ativos em todo o mundo.

Divulgação total - Sou co-fundador da NetCitadel, que é a empresa que desenvolve o Firewall Builder.

log de conexão de saída com 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: "

encaminhamento de porta / conexão:

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

Combine vários nomes de interface com um curinga

Exemplo: você tem eth0 e eth1 gostaria de permitir algum tráfego entre eles?

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

Eu usei isso no passado para corresponder às veth<something>interfaces criadas dinamicamente e nomeadas pelo LXC. Para que eu possa combinar tudo de uma vez com veth+.

Também intencionalmente nomeei algumas interfaces _<something>para comparar _+.

Bloquear valores incomuns de MSS

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

Alvo SYNPROXY para proteção de DDos

O objetivo deste destino é verificar se o host que enviou o pacote SYN estabelece a conexão ou não faz nada após iniciar a conexão SYN. Se não fizer nada, descarta o pacote com o mínimo esforço.

Definir pacotes syn para a tabela de rastreamento de conexão na tabela bruta

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

Ative o synproxy para o servidor http:

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

Recurso: alvo SYNPROXY do blog RHEL

Limitando todos os endereços IP individuais a uma cota de largura de banda de saída com conjuntos de IP

Você pode configurar seu servidor para permitir apenas cada IP 15GiByte individual de uso de largura de banda por mês, na esperança de refletir ou evitar um ataque de uso de largura de banda, talvez para sua cota de largura de banda medida no seu ISP. Pode ser realizado da seguinte maneira:

Primeiro, crie os conjuntos de IPs para IPv4 e 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

Agora adicione suas regras do iptables. A primeira linha adicionará o IP ao conjunto se ele ainda não estiver lá. A segunda linha não corresponderá se os bytes transferidos para o IP no conjunto forem maiores que a quantidade especificada. O mesmo é feito para o 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

Isso impedirá ataques como um usuário solicitando um arquivo grande do seu servidor da web por um longo período de tempo ou de qualquer serviço nesse sentido. O mesmo pode ser feito para a cadeia INPUT.

Algo que faço, principalmente devido à minha ignorância de uma solução mais elegante, é verificar manualmente meus logs do Nginx a cada 4 horas e o servidor de email a cada 2 minutos para acesso excessivo por IPs individuais. Eu corro alguns scripts juntos que:

1. Marque access.loge liste os 10 principais IPs organizados por quantos hits eles têm no servidor
2. Despejar os resultados em um arquivo de log
3. Faça outro script examinar esse arquivo de log e banir qualquer IP que tenha atingido o servidor mais de X vezes nas últimas X horas
4. Salve meu iptables.save

Aqui está o que parece:

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

Uma coisa que é MUITO importante notar aqui é que você PRECISA configurar uma lista de permissões ou começa a bloquear muitos IPs autênticos de servidores, para os quais você recebe muitos emails de ou no caso de outros logs, IPs que basta acessar muito o servidor por razões legítimas. Minha lista de permissões é incorporada neste script adicionando grep pipes logo após | grep ']' | que se parece com isso "grep -v 127.0 |" .
Você precisa reservar um tempo para ensinar ao servidor quais IPs de alto tráfego são legítimos e quais não são. Para mim, isso significava que eu tinha que passar a primeira semana mais ou menos verificando meus logs manualmente a cada duas horas, procurando ips de alto tráfego no iplocation.net e adicionando os legítimos como amazon, box.com ou até minha casa / escritório O intervalo de IPs para esta lista de permissões. Caso contrário, você provavelmente será bloqueado em seu próprio servidor ou começará a bloquear servidores de correio / web legítimos e causará interrupções no email ou no tráfego.

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"

Novamente, eu sei que isso é bruto como o inferno e provavelmente existe um protocolo eficiente, limpo e eficiente, que faz tudo isso, mas eu não sabia disso e isso já dura um ano ou dois e mantém os bandidos à distância. A única coisa que eu seriamente recomendo seriamente que você tenha um proxy ou outro servidor disponível para acessar o servidor principal. A razão é que, se você estiver desenvolvendo um dia um dia, do nada, e você efetue ping 2000 vezes em 5 horas para alguns testes, você poderá ser bloqueado sem retorno, exceto por um proxy.

Você pode ver que em checkBadIPs.sheu coloquei grep -v 127.0 e em meus arquivos reais eu tenho várias regras de ignorar para meus próprios IPs e outros intervalos de IP confiáveis, mas às vezes seu IP muda, você esquece de atualizar e fica bloqueado fora do seu próprio servidor.

Enfim, espero que ajude.

ATUALIZAR

Eu mudei um pouco as coisas para que, agora, em vez de verificar a cada duas horas, alguns logs sejam verificados a cada 2 minutos, principalmente meu log de autenticação ssh e o log de email, pois eles estavam sendo pressionados :(.

Eu configuro scripts específicos para cada arquivo de log, embora seja fácil o suficiente com o script manual que uso quando desejo inspecionar logs. Se parece com isso:

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

Isso requer 2 entradas ao executar, o arquivo de log que você deseja verificar e a que distância do passado você deseja verificar.

Portanto, se eu quisesse verificar mail.log para as contagens de IP, digamos 75 minutos no passado, eu executaria:

$ sudo script.sh mail.log 75

Concordo com os comentários sobre ipsets e sinalizadores tcp, mas ainda falta muito:

Use xtables-addons geoip match em vez de ipsets para listas de países. Atualize os dados geoip regularmente (pelo menos uma vez por mês). Os dados são mais dinâmicos que uma lista de ipsets de ignorar.

Considere o rastreamento do estado da conexão com sinalizadores tcp. Por exemplo, um tcp RST ou ACK só faz sentido para uma conexão estabelecida. O SYN faz sentido apenas para conexões novas e relacionadas. Um SYN para uma conexão estabelecida significa que seu SYN + ACK foi perdido ou uma tentativa de invasão e deve ser redefinido, pois os dois lados da conexão não concordam quanto ao estado.

Embora nenhum, SYN + RST e FIN + RST sejam combinações ilegais, o SYN + FIN é válido agora em TCP de abertura rápida (opção TCP 34), especialmente para DNS. Pacotes SYN, mesmo com abertura rápida, não devem ser fragmentados. Não considero regras com os sinalizadores PSH e URG como úteis. Não confunda o estado de rastreamento de conexão com o estado TCP: Uma resposta RST a um pacote SYN é estabelecida para fins de rastreamento.

O SYNPROXY é para pacotes encaminhados e não adiciona nada para os entregues localmente além do suporte ao syncookie.

Os pacotes de erro ICMP sempre estarão no estado relacionado e com comprimento 48: 576, se forem válidos. Comprimento 84: 1280 para IPv6. Todos os outros devem ser ignorados. Como o tamanho máximo também é o MTU mínimo, eles nunca devem ser fragmentados. As solicitações do ICMP (pings, registros de data e hora etc.) sempre serão novas e as respostas serão estabelecidas. Solte pacotes ICMP em outros estados.

Como o exemplo SSH com uma lista recente e aceitando apenas pacotes SYN subsequentes, o mesmo deve ser feito para o SMTP e é semelhante a "lista cinza" apenas no dado de endereço IP.

Na tabela de filtros, a primeira regra (ou a segunda, se aceitar pacotes de estado estabelecidos primeiro) nas cadeias de entrada e saída deve aceitar tudo na interface de loopback. Você deve confiar em seus próprios pacotes internos. Se não puder, você terá problemas maiores além de uma solução de firewall.

Por fim, não copie cegamente as regras, a menos que você realmente entenda o que elas fazem. Muitas listas de regras semelhantes fazem isso e, na maioria das vezes, o resultado é ridículo.

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