script do consultor de regras do iptables

Existe um servidor sem qualquer defesa do iptables :ACCEPT all..

Pode haver aplicativos personalizados neste servidor.

Se precisarmos proteger esse servidor (negar tudo e deixar apenas o que é necessário pelos aplicativos) com regras estritas do iptables, teremos que descobrir manualmente qual aplicativo usa qual dst/src port/protocole depois temos que escrever as regras do iptables para eles..

A pergunta : existem scripts que podem ajudar a coletar essas informações de uma máquina em execução? (dos logs?) - E gerando automaticamente as regras do iptables?

Como se estivesse audit2allowligado SELinux. Apenas por iptables!

A máquina não pode ter nenhuma interrupção!

Ex .: o script "MAGIC" deve rodar uma semana / mês na máquina, coletando informações e, depois de uma semana / mês, o script poderá produzir um arquivo de regras do iptables que podemos usar.

Muitas pessoas podem entrar nessa situação (como proteger um servidor em relação ao iptables). E seria ótimo se houvesse um script / solução que possa fazer isso: \

Faça manualmente

sudo ss -tuanp

ou

sudo netstat -tuanp

Explicação:

-t - show tcp sockets
-u - show udp sockets
-a - show all sockets
-n - show numeric, don't resolve 
-p - show process name

Funcione tcpdumpna máquina por uma semana ou mais para capturar o tráfego médio. Em seguida, você pode navegar no tráfego usando o wireshark posteriormente para ver quais portas estão sendo usadas.

O comando para isso seria tcpdump -i <interface> -s 65535 -w <some-file>

Você pode mapear isso de volta usando netstat -tuanppara ver quais PIDs / aplicativos estão usando quais portas.

Teoricamente, isso poderia ser roteirizado.

Você pode começar com um modelo muito básico, como https://gist.github.com/jirutka/3742890 , que permite apenas ssh e ping, e adicionar qualquer outra coisa manualmente.

um script rápido para gerar regras do iptables para seu aplicativo escutando na interface pública (0.0.0.0) / tcp

netstat -lnpt | egrep '0.0.0.0:[0-9]+' | awk '{print $4,$7}' | \
sed -E -e 's/0.0.0.0://g' -e 's|[0-9]+/||' | \
awk '{printf ("iptables -A INPUT -p tcp --dport %5d --syn -m conntrack --ctstate NEW -m comment %s \n", $1,$2) }'

você também pode usar o iptables -I INPUT <number>para injetar as regras em um local específico, que você pode listar comiptables -nvL --line-numbers INPUT

Infelizmente, não existe um script que eu já tenha visto que possa ser executado no modo de aprendizado ou no modo passivo registrando todo o uso da rede, obtendo seus resultados e gerando um firewall real usando iptablesseus logs.

Sua melhor aposta será começar de maneira simples e continuar adicionando várias peças à medida que você começa a entender completamente quais serviços seu sistema está fornecendo. Você precisará usar ferramentas como netstatpara ver quais portas estão em uso para os vários serviços que você hospeda, bem como quais endereços IP estão acessando.

$ sudo netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       PID/Program name   
tcp        0      0 0.0.0.0:25                  0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:890                 0.0.0.0:*                   LISTEN      26149/ypbind        
tcp        0      0 0.0.0.0:445                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 127.0.0.1:2207              0.0.0.0:*                   LISTEN      26226/python        
tcp        0      0 127.0.0.1:2208              0.0.0.0:*                   LISTEN      26221/./hpiod       
tcp        0      0 127.0.0.1:199               0.0.0.0:*                   LISTEN      26237/snmpd         
tcp        0      0 0.0.0.0:809                 0.0.0.0:*                   LISTEN      26067/rpc.statd     
tcp        0      0 0.0.0.0:139                 0.0.0.0:*                   LISTEN      26321/smbd          
tcp        0      0 0.0.0.0:587                 0.0.0.0:*                   LISTEN      26292/sendmail      
tcp        0      0 0.0.0.0:111                 0.0.0.0:*                   LISTEN      26038/portmap       
tcp        0      0 0.0.0.0:35604               0.0.0.0:*                   LISTEN      -                   
tcp        0      0 0.0.0.0:22                  0.0.0.0:*                   LISTEN      26249/sshd          
tcp        0      0 0.0.0.0:631                 0.0.0.0:*                   LISTEN      26257/cupsd         
tcp        0      0 :::22                       :::*                        LISTEN      26249/sshd          
tcp        0      0 :::631                      :::*                        LISTEN      26257/cupsd         

NOTA: No exemplo acima, você pode ver quais serviços eu tenho executando em um servidor que está aceitando conexões TCP, ou seja, eles estão "ouvindo" conexões em várias portas.

É muito fácil começar com coisas como SSH (porta 22) e HTTP (porta 80), se forem típicas do seu sistema, então eu faria esses tipos de serviços em massa de uma só vez. Para outros serviços, como LDAP ou NIS, você pode executá-los de maneira mais controlada, certificando-se de que as coisas não quebrem ao apresentá-los.

Ferramentas como FireHOL , Firewall Builder (fwbuilder) e eztables podem ser úteis ao atacar este projeto, pois fornecem uma boa camada de abstração por ter que criar iptableregras personalizadas manualmente, o que pode ser complicado.

O FireHOL é uma linguagem (e um programa para executá-lo) que cria firewalls seguros e com estado de qualquer complexidade, de configurações fáceis de entender e legíveis por humanos.

exemplo

transparent_squid 8080 "squid root" inface eth0

interface eth0 mylan
    policy accept

interface ppp+ internet
    server smtp accept
    server http accept
    server ftp  accept
    server ssh  accept src example.firehol.org

    client all  accept

router mylan2internet inface eth0 outface ppp+
    masquerade
    route all accept

O Fwbuilder é uma ferramenta gráfica exclusiva de firewall que permite ao usuário criar objetos e, em seguida, arrastar e soltar esses objetos nos firewalls, para criar um poderoso sistema de segurança para um único PC ou uma rede de PCs. O Fwbuilder suporta uma ampla gama de firewalls (Cisco ASA / PIX, tabelas de ip do Linux, ipfilter do FreeBSD, pf do OpenBSD e mais), para que suas regras possam ser implementadas em várias plataformas. Vamos dar uma olhada no uso do Fwbuilder no Linux, que pode se tornar um caso ao longo da vida com um poderoso sistema de segurança.

exemplo

O Eztables permite que você configure rapidamente um firewall sem nunca tocar no iptables. A sintaxe da regra de firewall foi projetada para ser fácil de ler e aplicar.

É assim que você permite que toda a Internet acesse seu servidor na porta TCP 80:

  allow_in any $eth0 any 80/tcp

O Eztables foi projetado para ser simples, mas poderoso. Não importa se você deseja proteger seu laptop, está configurando um roteador doméstico ou criando um firewall da empresa.

Usando Fail2Ban

Com um iptablesfirewall rudimentar instalado, você provavelmente desejará complementá-lo usando uma ferramenta como o Fail2Ban .

O Fail2ban verifica os arquivos de log (por exemplo, / var / log / apache / error_log) e bane os IPs que mostram os sinais maliciosos - muitas falhas de senha, buscas por explorações, etc. Geralmente, o Fail2Ban é usado para atualizar as regras de firewall para rejeitar os endereços IP. por um período especificado, embora qualquer outra ação arbitrária (por exemplo, o envio de um email) também possa ser configurada. Fora da caixa O Fail2Ban vem com filtros para vários serviços (apache, courier, ssh, etc).

O uso de ferramentas como essa ajudará a limitar a exposição que seu sistema terá de suportar à medida que você continuar a fortalecê-lo. Mesmo depois de estar convencido de que seu sistema foi reforçado, você ainda pode continuar usando o Fail2Ban como parte de suas medidas de segurança.

Referências

• Crie poderosos firewalls do Linux com o Firewall Builder
• Exemplo de FireHOL
• Página principal do projeto do FirewallBuilder
• Exemplo básico de firewall / iptables

Use as regras do iptable para registrar as novas conexões, que também registrarão o udp.

iptables -I INPUT -m state --state NEW -j LOG --log-prefix "New inbound connection: "
iptables -I OUTPUT -m state --state NEW -j LOG --log-prefix "New outbound connection: "

Você pode especificar diferente --log-level para ter os logs em outro arquivo além de / var / log / messages (você precisará configurar o daemon syslog).

Eu acho que você deve ler os logs principais do aplicativo, pois alguns servidores têm uma atividade muito periódica, como meio-dia, fim de semana, fim de mês (trimestre, ano), para que você não perca uma importante atividade de rede do servidor.

Como o servidor é crítico, torna a matriz de fluxo de rede do servidor em uma boa planilha (origem IP, destino IP, protocolo, porta, aplicativo) que o ajudará a criar as regras.

Eu sei que isso não é um script e não é uma resposta para a pergunta do OP, mas é uma ideia minha que eu quero compartilhar com o OP.

Eu tenho todas as portas de escuta com:

netstat -an | egrep 'tcp .*LISTEN' | awk -F" " '{print $4}' | awk -F":" '{print $NF}'

Talvez isso possa te ajudar a escrever seu próprio script. :)

Você pode começar com algo assim:

netstat -n -l -p | egrep "^(tcp|tcp6|udp)" | grep LISTEN | sed -r 's!^(tcp|tcp6|udp)\s.*:([0-9]+).*LISTEN\s+.*/(.*)!iptables -A INPUT -p \1 --dport \2 -j ACCEPT # \3!'

e depois siga com

iptables -P INPUT DROP

ou

iptables -A INPUT -j REJECT --reject-with icmp-host-prohibited

O que a primeira linha faz é usar o netstat para listar os processos de atendimento e suas portas. Em seguida, ele gera linhas "iptables" para permitir cada uma dessas conexões de entrada. A pequena substituição do regex sed foi personalizada para a saída netstat no meu servidor, por isso pode exigir alguns ajustes para você. Quando funciona, você deve terminar com algo parecido com:

iptables -A INPUT -p tcp --dport 111 -j ACCEPT # rpcbind       
iptables -A INPUT -p tcp --dport 22 -j ACCEPT # sshd          
iptables -A INPUT -p tcp --dport 25 -j ACCEPT # master        
iptables -A INPUT -p tcp --dport 3306 -j ACCEPT # mysqld        
iptables -A INPUT -p tcp --dport 49476 -j ACCEPT # rpc.statd     
iptables -A INPUT -p tcp --dport 5432 -j ACCEPT # postgres.bin  
iptables -A INPUT -p tcp --dport 55371 -j ACCEPT # rpc.statd

Duas coisas importantes a serem observadas:

1) Essas regras não fazem nada para você até você colocar uma linha DROP ou REJECT no final ou tornar essa a política padrão para pacotes incomparáveis. Essas regras permitem pacotes, o que é discutível, se a política padrão permitir algo que não corresponda.

2) Essas regras são ambivalentes sobre o IP de origem . A partir do seu post original, parece que você deseja permitir que todos os seus clientes para usar o servidor, então, examinar os logs para obter fonte IP de ir com os portos de destino. Como não conheço uma ferramenta para fazer isso, esse script só impedirá as pessoas de criar novos serviços no servidor que escutam em outras portas ... o que é algo .