wiki:linux:comandos:comando_iptables

Table of Contents

Exemplos do comando iptables

Exemplos do comando iptables

Nível Básico

Listar todas as regras atuais de firewall:
1. ```
sudo iptables -L
```
2. Lista as regras de firewall atuais em todas as tabelas e cadeias (`INPUT`, `OUTPUT`, `FORWARD`).

Permitir todas as conexões de saída (OUT):
1. ```
sudo iptables -P OUTPUT ACCEPT
```
2. Define a política padrão para o tráfego de saída como `ACCEPT` (permitir todas as conexões de saída).

Bloquear todo o tráfego de entrada (IN):
1. ```
sudo iptables -P INPUT DROP
```
2. Define a política padrão para o tráfego de entrada como `DROP`, bloqueando todas as conexões de entrada.

Permitir tráfego de entrada SSH (porta 22):
1. ```
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
```
2. Permite conexões de entrada no protocolo TCP pela porta `22` (usada para SSH).

Bloquear um endereço IP específico:
1. ```
sudo iptables -A INPUT -s 192.168.1.100 -j DROP
```
2. Bloqueia todo o tráfego de entrada do IP `192.168.1.100`.

Remover uma regra específica:
1. ```
sudo iptables -D INPUT -s 192.168.1.100 -j DROP
```
2. Remove a regra que bloqueia o IP `192.168.1.100`.

Salvar as regras de firewall atuais:
1. ```
sudo iptables-save > /etc/iptables/rules.v4
```
2. Salva as regras de firewall atuais no arquivo `/etc/iptables/rules.v4` (pode variar conforme a distribuição).

Nível Intermediário

Permitir o tráfego HTTP (porta 80) e HTTPS (porta 443):
1. ```
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
```
  <br>

sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

Permite conexões de entrada nas portas `80` (HTTP) e `443` (HTTPS) para servidores web.

Permitir o tráfego de entrada da rede local (LAN):
1. ```
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT
```
2. Permite todo o tráfego de entrada da rede local `192.168.1.0/24`.

Logar pacotes antes de bloqueá-los:

sudo iptables -A INPUT -s 192.168.1.100 -j LOG --log-prefix "IP Bloqueado: "

<br>

sudo iptables -A INPUT -s 192.168.1.100 -j DROP

Registra no log os pacotes de entrada do IP `192.168.1.100` antes de bloqueá-los.

Bloquear ping (ICMP echo-request):
1. ```
sudo iptables -A INPUT -p icmp --icmp-type echo-request -j DROP
```
2. Bloqueia pacotes `ping` (ICMP `echo-request`) para que a máquina não responda a `ping`.

Limitar o número de conexões SSH (máximo de 3 tentativas por minuto):

sudo iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --set

<br>

sudo iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --update --seconds 60 --hitcount 3 -j DROP

Limita as tentativas de conexão SSH a 3 por minuto por IP, para evitar ataques de força bruta.

Redirecionar portas localmente (ex.: 8080 para 80):
1. ```
sudo iptables -t nat -A PREROUTING -p tcp --dport 8080 -j REDIRECT --to-port 80
```
2. Redireciona o tráfego da porta `8080` para a porta `80` no servidor local.

Nível Avançado

Bloquear tráfego de um país específico usando GeoIP:
1. ```
sudo iptables -A INPUT -m geoip --src-cc CN -j DROP
```
2. Bloqueia todo o tráfego de entrada originado da China (código de país `CN`), usando o módulo `geoip`.

Limitar o tráfego de entrada por taxa (Rate Limiting):
1. ```
sudo iptables -A INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT
```
2. Limita o tráfego de entrada na porta `80` para `25` pacotes por minuto, com um burst máximo de `100`.

Permitir o tráfego de retorno e conexões estabelecidas:
1. ```
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
```
2. Permite o tráfego de pacotes de retorno ou conexões já estabelecidas.

Bloquear um intervalo de endereços IP:
1. ```
sudo iptables -A INPUT -m iprange --src-range 192.168.1.100-192.168.1.200 -j DROP
```
2. Bloqueia o tráfego de entrada para o intervalo de IPs `192.168.1.100` a `192.168.1.200`.

Usar um conjunto de regras baseado no horário:
1. ```
sudo iptables -A INPUT -p tcp --dport 22 -m time --timestart 09:00 --timestop 17:00 --days Mon,Tue,Wed,Thu,Fri -j ACCEPT
```
2. Permite o tráfego SSH (porta `22`) apenas durante o horário comercial (09:00 às 17:00) de segunda a sexta.

Criar um contador de pacotes para monitorar tráfego:
1. ```
sudo iptables -A INPUT -p tcp --dport 80 -m state --state NEW -j ACCEPT -m comment --comment "Contador HTTP"
```
2. Adiciona uma regra de contagem para monitorar as novas conexões HTTP e registrar informações sobre o tráfego.

Nível Especializado

Criar regras para NAT (mascaramento de IPs):
1. ```
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
```
2. Configura NAT (mascaramento de IPs) na interface `eth0`, para compartilhar a conexão com a internet.

Criação de um port knocking básico:
1. Primeira porta:

sudo iptables -A INPUT -p tcp --dport 7000 -m recent --name knock1 --set -j DROP

Segunda porta (habilita a regra após a primeira tentativa):

sudo iptables -A INPUT -p tcp --dport 8000 -m recent --name knock1 --rcheck -m recent --name knock2 --set -j DROP

Terceira porta (habilita acesso SSH após sequência correta):

sudo iptables -A INPUT -p tcp --dport 9000 -m recent --name knock2 --rcheck -j ACCEPT

Implementa port knocking simples: acesso SSH só é permitido após tentativas de conexão nas portas `7000`, `8000`, e `9000` em sequência.

Configurar iptables como firewall de estado (stateful firewall):
1. ```
sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP
```
  <br>

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

Configura o iptables como firewall de estado, permitindo apenas conexões válidas e estabelecidas, e bloqueando pacotes inválidos.

Bloquear pacotes fragmentados:
1. ```
sudo iptables -A INPUT -f -j DROP
```
2. Bloqueia pacotes fragmentados, uma técnica comum usada em ataques de rede.

Bloquear tráfego de IPs com base em listas negras (blacklist):
1. ```
sudo iptables -A INPUT -m set --match-set blacklist src -j DROP
```
2. Usa um conjunto de IPs (blacklist) e bloqueia o tráfego de qualquer IP listado.

Criar uma cadeia personalizada e redirecionar pacotes para ela:
1. ```
sudo iptables -N MINHACHAINA
```
  <br>

sudo iptables -A INPUT -p tcp --dport 1234 -j MINHACHAINA

<br>

    <code>sudo iptables -A MINHACHAINA -s 192.168.1.100 -j ACCEPT</code><br>
    <code>sudo iptables -A MINHACHAINA -j DROP</code>
  - Cria uma cadeia personalizada chamada `MINHACHAINA` e redireciona pacotes da porta `1234` para essa cadeia, onde são filtrados por IP.

Criar regras para mitigação de ataques DDoS (DoS):
1. ```
sudo iptables -A INPUT -p tcp --syn -m limit --limit 1/s --limit-burst 3 -j ACCEPT
```
2. Limita o número de pacotes SYN recebidos para mitigar ataques de negação de serviço.