Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
iptables-essentials — Iptables Essentials: Regras e Comandos Comuns de Firewall. | Kitploit
Ferramentas/GitHubGitHub/trimstray/iptables-essentials
Auditoria de ConfiguraçãoSegurança de RedeAprendizado e EducaçãoRecursos Curados
GitHubtrimstray/iptables-essentials

iptables-essentials

Iptables Essentials: Regras e Comandos Comuns de Firewall.

Ver Repositório
1.6k2892há 1 anoRevisado pelo Kitploit

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

Iptables Essenciais: Regras e Comandos Comuns de Firewall


Pull Requests Licença MIT


☑️ TODO

  • Adicionar exemplos úteis de configuração do Iptables
  • Adicionar configuração útil de Configurações do Kernel (sysctl)
  • Adicionar links para recursos externos úteis
  • Adicionar exemplos de configuração avançada, comandos, regras

Tabela de Conteúdos

  • Ferramentas para ajudar a configurar o Iptables
  • Manuais/Howtos/Tutoriais
  • Configuração útil das Configurações do Kernel (sysctl)
    • rp_filter
    • log_martians
    • send_redirects
    • accept_source_route
    • accept_redirects
    • tcp_syncookies
    • icmp_echo_ignore_broadcasts
    • ip_forward
  • Como funciona?
  • Regras do Iptables
    • Salvando Regras
      • Baseado em Debian
      • Baseado em RedHat
    • Listar todas as regras iptables ativas com verbose
    • Listar todas as regras iptables ativas com linhas numéricas e verbose
    • Imprimir todas as regras iptables ativas
    • Listar Regras como Tabelas para a cadeia INPUT
    • Imprimir todas as especificações de regras na cadeia INPUT
    • Mostrar Contagens de Pacotes e Tamanho Agregado
    • Para exibir regras das cadeias INPUT ou OUTPUT com linhas numéricas e verbose
    • Eliminar Regra por Cadeia e Número
    • Eliminar Regra por Especificação
    • Limpar Todas as Regras, Eliminar Todas as Cadeias e Aceitar Tudo
    • Limpar Todas as Cadeias
    • Limpar uma Única Cadeia
    • Inserir Regras de Firewall
    • Permitir Conexões de Loopback
    • Permitir Conexões de Entrada Estabelecidas e Relacionadas
    • Permitir Conexões de Saída Estabelecidas
    • Interno para Externo
    • Descartar Pacotes Inválidos
    • Bloquear um Endereço IP
    • Bloquear um Endereço IP e Rejeitar
    • Bloquear Conexões a uma Interface de Rede
    • Permitir Todo SSH de Entrada
    • Permitir SSH de Entrada de um Endereço IP ou Sub-rede Específico
    • Permitir SSH de Saída
    • Permitir Rsync de Entrada de um Endereço IP ou Sub-rede Específico
    • Permitir Todo HTTP de Entrada
    • Permitir Todo HTTPS de Entrada
    • Permitir Todo HTTP e HTTPS de Entrada
    • Permitir MySQL de um Endereço IP ou Sub-rede Específico
    • Permitir MySQL para uma Interface de Rede Específica
    • PostgreSQL de um Endereço IP ou Sub-rede Específico
    • Permitir PostgreSQL para uma Interface de Rede Específica
    • Bloquear SMTP de Saída
    • Permitir Todo SMTP de Entrada
    • Permitir Todo IMAP de Entrada
    • Permitir Todo IMAPS de Entrada
    • Permitir Todo POP3 de Entrada
    • Permitir Todo POP3S de Entrada
    • Descartar Endereço de Rede Privada na Interface Pública
    • Descartar Todo Tráfego de Saída para Redes do Facebook
    • Registrar e Descartar Pacotes
    • Registrar e Descartar Pacotes com Número Limitado de Entradas de Log
    • Descartar ou Aceitar Tráfego de Endereço MAC
    • Bloquear ou Permitir Pedido de Ping ICMP
    • Especificar Múltiplas Portas com multiport
    • Balanceamento de Carga com random* ou nth*
    • Restringir o Número de Conexões com limit e iplimit*
    • Manter uma Lista de Conexões Recentes para Correspondência
    • Correspondência contra uma string* na Carga de Dados de um Pacote
    • Regras Baseadas em Tempo com time*
    • Correspondência de Pacotes com Base em Valores TTL
    • Proteção contra varredura de portas
    • Proteção contra força bruta SSH
    • Proteção contra inundação SYN
      • Mitigando Inundações SYN com SYNPROXY
    • Bloquear Novos Pacotes que Não São SYN
    • Forçar verificação de pacotes fragmentados
    • Pacotes XMAS
    • Descartar todos os pacotes NULL
    • Bloquear Valores MSS Incomuns
    • Bloquear Pacotes com Flags TCP Falsas
    • Bloquear Pacotes de Sub-redes Privadas (Spoofing)
  • Exemplos de configuração avançada
    • Manipulação de pacotes em Python usando o alvo NFQUEUE
      • ACEITAR todos os pacotes de uma fonte específica em (filter:INPUT) e DESCARTAR todo o resto
      • Escreva seu próprio script de port knocking para proteger o acesso SSH

  • Ferramentas para ajudar a configurar o Iptables

      :small_orange_diamond: Shorewall - ferramenta de configuração avançada de gateway/firewall para GNU/Linux.
      :small_orange_diamond: Firewalld - fornece um firewall gerenciado dinamicamente.
      :small_orange_diamond: UFW - ferramenta de configuração de firewall padrão do Ubuntu.
      :small_orange_diamond: FireHOL - oferece configuração simples e poderosa para todos os requisitos de firewall e modelagem de tráfego do Linux.

    Manuais/Howtos/Tutoriais

      :small_orange_diamond: Melhores práticas: iptables - por Major Hayden
      :small_orange_diamond: Um Guia Aprofundado sobre Iptables, o Firewall do Linux
      :small_orange_diamond: Funcionalidades Avançadas do netfilter/iptables
      :small_orange_diamond: Firewalls Linux Usando iptables
      :small_orange_diamond: Depuração de iptables e armadilhas comuns de firewall?
      :small_orange_diamond: HOWTO de Hacking do Netfilter
      :small_orange_diamond: Limitação de taxa por IP com iptables

    Configuração útil das Configurações do Kernel (sysctl)

    rp_filter

    Desabilita a triangulação de roteamento. Responda a consultas na mesma interface, não em outra. Também protege contra falsificação de IP.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/rp_filter = 1 EOF

    root@kitploit:~
    - [rp_filter e Segurança Linux LPIC-3](https://www.theurbanpenguin.com/rp_filter-and-lpic-3-linux-security/)
    - [Configurações de rp_filter do kernel Linux (Filtragem de caminho reverso)](https://www.slashroot.in/linux-kernel-rpfilter-settings-reverse-path-filtering)
    - [Filtragem de Caminho Reverso](http://tldp.org/HOWTO/Adv-Routing-HOWTO/lartc.kernel.rpf.html)
    
    ##### log_martians
    
      > _Ativar o registro de pacotes com endereços IP malformados._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/conf/all/log_martians = 1
    EOF
    
    • Qual é a utilidade do registro de pacotes marcianos?
    send_redirects

    Desativa o envio de todos os pacotes ICMP redirecionados IPv4 em todas as interfaces.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/send_redirects = 0 EOF

    root@kitploit:~
    - [Desabilitar roteamento por origem](https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/security_guide/sect-security_guide-server_security-disable-source-routing)
    - [O que são redirecionamentos ICMP e eles devem ser bloqueados?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)
    
    ##### accept_source_route
    
      > _Desabilitar pacotes roteados por origem (pacotes com a opção Rota de Origem Estrita (SSR) ou Roteamento de Origem Flexível (LSR) configurada)._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/conf/all/accept_source_route = 0
    EOF
    
    • Desabilitar roteamento de origem
    • O sistema não deve aceitar pacotes roteados por fonte IPv4 por padrão.
    accept_redirects

    Desabilitar a aceitação de redirecionamentos ICMP.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/conf/all/accept_redirects = 0 EOF

    root@kitploit:~
    - [O que são redirecionamentos ICMP e eles devem ser bloqueados?](https://askubuntu.com/questions/118273/what-are-icmp-redirects-and-should-they-be-blocked)
    - [O sistema operacional Red Hat Enterprise Linux deve ignorar mensagens de redirecionamento do Protocolo de Mensagens de Controle da Internet (ICMP) versão 4 (IPv4).](https://www.stigviewer.com/stig/red_hat_enterprise_linux_7/2018-11-28/finding/V-73175)
    
    ##### tcp_syncookies
    
      > _Ative as proteções contra inundação SYN (proteção contra ataques de Negação de Serviço (DOS))._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/tcp_syncookies = 1
    EOF
    
    • Fortalecendo sua pilha TCP/IP contra inundações SYN
    • Linux: Ative a proteção de cookies TCP SYN
    • Alternativa melhor para tcp_syncookies no Linux
    icmp_echo_ignore_broadcasts

    Desativar resposta a pings de broadcast.```bash cat << EOF >> /etc/sysctl.d/40-custom.conf net/ipv4/icmp_echo_ignore_broadcasts = 1 EOF

    root@kitploit:~
    - [Para que serve o broadcast ICMP?](https://superuser.com/questions/306065/what-is-icmp-broadcast-good-for)
    - [O sistema não deve responder a ICMPv4 enviado para um endereço de broadcast.](https://www.stigviewer.com/stig/red_hat_enterprise_linux_6/2018-11-28/finding/V-38535)
    
    ##### ip_forward
    
      > _Ativar roteamento IP. Necessário se o firewall estiver protegendo uma rede, incluindo NAT._```bash
    cat << EOF >> /etc/sysctl.d/40-custom.conf
    net/ipv4/ip_forward = 1
    EOF
    
    • Introdução a roteadores
    • Como Ativar o Encaminhamento IP no Linux
    • O que é o encaminhamento IP do kernel?

    Como funciona?

    Master

    Regras do Iptables

    Salvando Regras

    Baseado em Debian```bash

    netfilter-persistent save

    root@kitploit:~
    ###### RedHat Baseado```bash
    service iptables save
    

    Listar todas as regras iptables ativas com verbose```bash

    iptables -n -L -v

    root@kitploit:~
    #### Listar todas as regras ativas do iptables com linhas numeradas e verbose```bash
    iptables -n -L -v --line-numbers
    

    Imprimir todas as regras iptables ativas```bash

    iptables -S

    root@kitploit:~
    #### Listar Regras como Tabelas para a cadeia INPUT```bash
    iptables -L INPUT
    

    Imprimir todas as especificações de regras na cadeia INPUT```bash

    iptables -S INPUT

    root@kitploit:~
    #### Mostrar Contagens de Pacotes e Tamanho Agregado```bash
    iptables -L INPUT -v
    

    Para exibir regras da cadeia INPUT ou OUTPUT com linhas numéricas e verbose```bash

    iptables -L INPUT -n -v iptables -L OUTPUT -n -v --line-numbers

    root@kitploit:~
    #### Excluir Regra por Cadeia e Número```bash
    iptables -D INPUT 10
    

    Excluir Regra por Especificação```bash

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

    root@kitploit:~
    #### Limpar Todas as Regras, Excluir Todas as Cadeias, e Aceitar Tudo```bash
    iptables -P INPUT ACCEPT
    iptables -P FORWARD ACCEPT
    iptables -P OUTPUT ACCEPT
    
    iptables -t nat -F
    iptables -t mangle -F
    iptables -F
    iptables -X
    

    Limpar Todas as Cadeias```bash

    iptables -F

    root@kitploit:~
    #### Limpar uma única cadeia```bash
    iptables -F INPUT
    

    Inserir Regras de Firewall```bash

    iptables -I INPUT 2 -s 202.54.1.2 -j DROP

    root@kitploit:~
    #### Permitir Conexões Loopback```bash
    iptables -A INPUT -i lo -j ACCEPT
    iptables -A OUTPUT -o lo -j ACCEPT
    

    Permitir Conexões de Entrada Estabelecidas e Relacionadas```bash

    iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

    root@kitploit:~
    #### Permitir Conexões de Saída Estabelecidas```bash
    iptables -A OUTPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Interno para Externo```bash

    iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

    root@kitploit:~
    #### Descartar Pacotes Inválidos```bash
    iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
    

    Bloquear um Endereço IP```bash

    iptables -A INPUT -s 192.168.252.10 -j DROP

    root@kitploit:~
    #### Bloquear e Endereço IP e Rejeitar```bash
    iptables -A INPUT -s 192.168.252.10 -j REJECT
    

    Bloquear Conexões a uma Interface de Rede```bash

    iptables -A INPUT -i eth0 -s 192.168.252.10 -j DROP

    root@kitploit:~
    #### Permitir Todo SSH de Entrada```bash
    iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir SSH de entrada de endereço IP ou sub-rede específico```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir SSH de saída```bash
    iptables -A OUTPUT -p tcp --dport 22 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A INPUT -p tcp --sport 22 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir Rsync de Entrada de um Endereço IP ou Sub-rede Específicos```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 873 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 873 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir Todo HTTP de Entrada```bash
    iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 80 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir Todo HTTPS de Entrada```bash

    iptables -A INPUT -p tcp --dport 443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 443 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir Todo o HTTP e HTTPS de Entrada```bash
    iptables -A INPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp -m multiport --dports 80,443 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir MySQL a partir de um Endereço IP ou Sub-rede Específicos```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir MySQL para Interface de Rede Específica```bash
    iptables -A INPUT -i eth1 -p tcp --dport 3306 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth1 -p tcp --sport 3306 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    PostgreSQL a partir de Endereço IP ou Sub-rede Específicos```bash

    iptables -A INPUT -p tcp -s 192.168.240.0/24 --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir PostgreSQL para interface de rede específica```bash
    iptables -A INPUT -i eth1 -p tcp --dport 5432 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -o eth1 -p tcp --sport 5432 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Bloquear Correio SMTP de Saída```bash

    iptables -A OUTPUT -p tcp --dport 25 -j REJECT

    root@kitploit:~
    #### Permitir todo o SMTP de entrada```bash
    iptables -A INPUT -p tcp --dport 25 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 25 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir Todo IMAP de Entrada```bash

    iptables -A INPUT -p tcp --dport 143 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 143 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir Todo o IMAPS de Entrada```bash
    iptables -A INPUT -p tcp --dport 993 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 993 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Permitir Todo POP3 de Entrada```bash

    iptables -A INPUT -p tcp --dport 110 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -p tcp --sport 110 -m conntrack --ctstate ESTABLISHED -j ACCEPT

    root@kitploit:~
    #### Permitir Todas as Conexões POP3S de Entrada```bash
    iptables -A INPUT -p tcp --dport 995 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
    iptables -A OUTPUT -p tcp --sport 995 -m conntrack --ctstate ESTABLISHED -j ACCEPT
    

    Descartar Endereço de Rede Privada na Interface Pública```bash

    iptables -A INPUT -i eth1 -s 192.168.0.0/24 -j DROP iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

    root@kitploit:~
    #### Bloquear Todo Tráfego de Saída para Redes do Facebook
    
    Obter AS do Facebook:```bash
    whois -h v4.whois.cymru.com " -v $(host facebook.com | grep "has address" | cut -d " " -f4)" | tail -n1 | awk '{print $1}'
    

    Soltar:```bash for i in $(whois -h whois.radb.net -- '-i origin AS32934' | grep "^route:" | cut -d ":" -f2 | sed -e 's/^[ \t]*//' | sort -n -t . -k 1,1 -k 2,2 -k 3,3 -k 4,4 | cut -d ":" -f2 | sed 's/$/;/') ; do

    iptables -A OUTPUT -s "$i" -j REJECT

    done

    root@kitploit:~
    #### Registrar e Descartar Pacotes```bash
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j LOG --log-prefix "IP_SPOOF A: "
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP
    

    Por padrão, tudo é registrado no arquivo /var/log/messages:```bash tail -f /var/log/messages grep --color 'IP SPOOF' /var/log/messages

    root@kitploit:~
    #### Registrar e Descartar Pacotes com Número Limitado de Entradas de Log```bash
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -m limit --limit 5/m --limit-burst 7 -j LOG --log-prefix "IP_SPOOF A: "
    iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP
    

    Descartar ou Aceitar Tráfego do Endereço MAC```bash

    iptables -A INPUT -m mac --mac-source 00:0F:EA:91:04:08 -j DROP iptables -A INPUT -p tcp --destination-port 22 -m mac --mac-source 00:0F:EA:91:04:07 -j ACCEPT

    root@kitploit:~
    #### Bloquear ou Permitir Requisição de Ping ICMP```bash
    iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
    iptables -A INPUT -i eth1 -p icmp --icmp-type echo-request -j DROP
    

    Especificando Múltiplas Portas com `multiport````bash

    iptables -A INPUT -i eth0 -p tcp -m state --state NEW -m multiport --dports ssh,smtp,http,https -j ACCEPT

    root@kitploit:~
    #### Balanceamento de Carga com `random*` ou `nth*````bash
    _ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")
    
    for ip in "${_ips[@]}" ; do
      iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m nth --counter 0 --every 4 --packet 0 \
        -j DNAT --to-destination ${ip}:80
    done
    

    ou```bash _ips=("172.31.250.10" "172.31.250.11" "172.31.250.12" "172.31.250.13")

    for ip in "${_ips[@]}" ; do iptables -A PREROUTING -i eth0 -p tcp --dport 80 -m state --state NEW -m random --average 25
    -j DNAT --to-destination ${ip}:80 done

    root@kitploit:~
    #### Restringindo o Número de Conexões com `limit` e `iplimit*````bash
    iptables -A FORWARD -m state --state NEW -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
        -m limit --limit 20/hour --limit-burst 5 -j ACCEPT
    

    ou```bash iptables -A INPUT -p tcp -m state --state NEW --dport http -m iplimit --iplimit-above 5 -j DROP

    root@kitploit:~
    #### Manter uma Lista de Conexões Recentes para Correspondência```bash
    iptables -A FORWARD -m recent --name portscan --rcheck --seconds 100 -j DROP
    iptables -A FORWARD -p tcp -i eth0 --dport 443 -m recent --name portscan --set -j DROP
    

    Correspondência contra um string* no Payload de Dados de um Pacote```bash

    iptables -A FORWARD -m string --string '.com' -j DROP iptables -A FORWARD -m string --string '.exe' -j DROP

    root@kitploit:~
    #### Regras baseadas em tempo com `time*````bash
    iptables -A FORWARD -p tcp -m multiport --dport http,https -o eth0 -i eth1 \
        -m time --timestart 21:30 --timestop 22:30 --days Mon,Tue,Wed,Thu,Fri -j ACCEPT
    

    Correspondência de Pacotes com Base em Valores TTL```bash

    iptables -A INPUT -s 1.2.3.4 -m ttl --ttl-lt 40 -j REJECT

    root@kitploit:~
    #### Proteção contra varredura de portas```bash
    iptables -N port-scanning
    iptables -A port-scanning -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s --limit-burst 2 -j RETURN
    iptables -A port-scanning -j DROP
    

    Proteção contra força bruta SSH```bash

    iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --set iptables -A INPUT -p tcp --dport ssh -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 10 -j DROP

    root@kitploit:~
    #### Proteção contra Syn-flood```bash
    iptables -N syn_flood
    
    iptables -A INPUT -p tcp --syn -j syn_flood
    iptables -A syn_flood -m limit --limit 1/s --limit-burst 3 -j RETURN
    iptables -A syn_flood -j DROP
    
    iptables -A INPUT -p icmp -m limit --limit  1/s --limit-burst 1 -j ACCEPT
    
    iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j LOG --log-prefix PING-DROP:
    iptables -A INPUT -p icmp -j DROP
    
    iptables -A OUTPUT -p icmp -j ACCEPT
    
    Mitigando inundações SYN com SYNPROXY```bash

    iptables -t raw -A PREROUTING -p tcp -m tcp --syn -j CT --notrack iptables -A INPUT -p tcp -m tcp -m conntrack --ctstate INVALID,UNTRACKED -j SYNPROXY --sack-perm --timestamp --wscale 7 --mss 1460 iptables -A INPUT -m conntrack --ctstate INVALID -j DROP

    root@kitploit:~
    #### Bloquear Novos Pacotes Que Não São SYN```bash
    iptables -A INPUT -p tcp ! --syn -m state --state NEW -j DROP
    

    ou```bash iptables -t mangle -A PREROUTING -p tcp ! --syn -m conntrack --ctstate NEW -j DROP

    root@kitploit:~
    #### Verificação de pacotes de fragmentos forçados```bash
    iptables -A INPUT -f -j DROP
    

    Pacotes XMAS```bash

    iptables -A INPUT -p tcp --tcp-flags ALL ALL -j DROP

    root@kitploit:~
    #### Descartar todos os pacotes NULL```bash
    iptables -A INPUT -p tcp --tcp-flags ALL NONE -j DROP
    

    Bloquear Valores MSS Incomuns```bash

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

    root@kitploit:~
    #### Bloquear Pacotes Com Flags TCP Falsas```bash
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN,RST,PSH,ACK,URG NONE -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,SYN FIN,SYN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,RST FIN,RST -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags FIN,ACK FIN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,URG URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,FIN FIN -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ACK,PSH PSH -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL ALL -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL NONE -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL FIN,PSH,URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,FIN,PSH,URG -j DROP
    iptables -t mangle -A PREROUTING -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -j DROP
    

    Bloquear Pacotes de Sub-redes Privadas (Spoofing)```bash

    _subnets=("224.0.0.0/3" "169.254.0.0/16" "172.16.0.0/12" "192.0.2.0/24" "192.168.0.0/16" "10.0.0.0/8" "0.0.0.0/8" "240.0.0.0/5")

    for _sub in "${_subnets[@]}" ; do iptables -t mangle -A PREROUTING -s "$_sub" -j DROP done iptables -t mangle -A PREROUTING -s 127.0.0.0/8 ! -i lo -j DROP

    root@kitploit:~
    ## Exemplos de configuração avançada
    
    ### Manipulação de pacotes em Python usando o alvo NFQUEUE
    
      > _Este alvo passa o pacote para o espaço do usuário usando o manipulador nfnetlink_queue. O pacote é colocado na fila identificada pelo seu número de fila de 16 bits. O espaço do usuário pode inspecionar e modificar o pacote, se desejado. O espaço do usuário deve então descartar ou reinjetar o pacote no kernel._
    
    #### ACEITAR todos os pacotes de uma fonte específica em (filter:INPUT) e REJEITAR todo o resto
    
      > _Esta regra encaminha todos os pacotes filter:INPUT para a fila 1 com o alvo NFQUEUE._```bash
    iptables -A INPUT -j NFQUEUE --queue-num 1
    

    Script para vincular à fila 1 do netfilter e lidar com pacotes.```python #!/usr/bin/python3

    from netfilterqueue import NetfilterQueue from scapy.all import *

    def packetanalyzer(pkt): ip=IP(pkt.get_payload()) if(ip.src=="192.168.122.1"): print(f"New packet from {ip.src}") pkt.accept() else: pkt.drop()

    nfqueue=NetfilterQueue() nfqueue.bind(1, packetanalyzer) nfqueue.run()

    root@kitploit:~
    #### Escreva seu próprio script de port knocking para proteger o acesso ssh
    
    > _DROP todas as requisições ssh e enviar requisições de porta secretas para o user-space com o destino NFQUEUE._```bash
    iptables -t filter -I INPUT -p tcp --dport 22 -j DROP
    iptables -t raw -I PREROUTING -p tcp --sport 65534 --dport 65535 -j NFQUEUE --queue-num 1
    

    _Este script captura pacotes da netfilter queue 1 e verifica SOURCEPORT e SECRETPORT para port knocking e permite que a origem se conecte ao ssh por EXPIRETIME, o padrão é 30 minutos.```python #!/usr/bin/python3

    from os import system from netfilterqueue import NetfilterQueue from scapy.layers.inet import IP from time import time

    SOURCEPORT=65534 SECRETPORT=65535 EXPIRETIME=30 ALLOWED={}

    def portknocking(pkt): packet=IP(pkt.get_payload()) currtime=time() for item in list(ALLOWED): if(currtime-ALLOWED[item] >= EXPIRETIME*60): del ALLOWED[item] if(packet.sport==SOURCEPORT and packet.dport==SECRETPORT and packet.src not in ALLOWED): print(f"Port {packet.dport} knocked by {packet.src}:{packet.sport}") system(f"iptables -I INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT") system(f"echo 'iptables -D INPUT -p tcp --dport 22 -s {packet.src} -j ACCEPT' | at now + {EXPIRETIME} minutes") ALLOWED[packet.src]=time() pkt.drop()

    nfqueue=NetfilterQueue() nfqueue.bind(1, portknocking)

    try: nfqueue.run() except KeyboardInterrupt: print("\nExit with Keyboard Interrupt")

    root@kitploit:~
    > _Para bater na porta e permitir conexões ssh do seu computador, basta executar este comando:_```bash
    nc -p 65534 SERVER 65535
    
    Baixar ferramenta