>/ MAC Spoofing na Prática: Construindo e Explorando um Firewall com Docker e Python_

Table of Contents

1 - Introdução: A Falsa Sensação de Segurança na Camada 2: 🛡️
#

Talvez você se lembre do caso de Aaron Swartz, um programador e hacktivista que acreditava no acesso livre à informação. Em 2010, Aaron utilizou técnicas como o MAC spoofing para acessar a rede do MIT (Massachusetts Institute of Technology) e, supostamente, baixar milhões de artigos acadêmicos da base de dados JSTOR. Independentemente da ética e das questões legais de suas ações, o caso de Aaron Swartz mostra de forma contundente uma verdade técnica: o endereço MAC, apesar de ser um identificador único de hardware na camada de enlace (ou Camada 2 no modelo OSI), pode ser facilmente falsificado.

E é exatamente essa técnica que exploraremos por aqui.

1.1 - O Que é Endereço MAC?
#

Endereços MAC (Media Access Control) são identificadores de hardware de 48 bits. Para entender melhor, pense neles como o “RG” de uma placa de rede (NIC - Network Interface Controller).

Os primeiros 24 bits (chamados OUI - Organizationally Unique Identifier) identificam o fabricante do dispositivo, e os 24 bits restantes são um valor único gerado pelo fabricante para aquela interface específica.

Exemplo de um endereço MAC:

00:1A:2B:3C:4D:5E

Tipos de Endereços MAC: Unicast, Multicast e Broadcast

Além de serem únicos para cada dispositivo, os endereços MAC também têm classificações que determinam como os pacotes de dados são entregues na rede local:

Unicast: Este é o tipo mais comum, onde o pacote de dados é enviado de um único remetente para um único destinatário. O endereço MAC de destino é o endereço específico de uma única interface de rede. Se o primeiro bit do segundo octeto do MAC for 0 (ex: 00:1A:2B…), é um endereço Unicast.
Multicast: Um pacote Multicast é enviado de um único remetente para um grupo específico de destinatários que estão “escutando” para aquele endereço Multicast. É usado para entrega eficiente de informações a múltiplos pontos de interesse sem sobrecarregar toda a rede (como faria um broadcast). Endereços Multicast têm o primeiro bit do segundo octeto do MAC como 1 (ex: 01:00:5E…).
Broadcast: Este é o tipo mais amplo, onde um pacote é enviado de um remetente para todos os dispositivos na mesma rede local. O endereço MAC de Broadcast é FF:FF:FF:FF:FF:FF. Todos os dispositivos na rede processam pacotes enviados para este endereço.

1.2 - O Que é MAC Spoofing?
#

Para falar da vulnerabilidade que permitiu casos como o de Aaron Swartz, precisamos entender o que é MAC Spoofing. Imagine que seu computador tem uma “identidade” na rede local. Essa identidade é o seu Endereço MAC, um número único “gravado” na sua placa de rede (NIC) durante a fabricação.

De acordo com o paper GIAC Security Essentials Certification do SANS Institute, MAC spoofing, ou falsificação de MAC, é essencialmente o roubo de identidade de um computador. Isso se refere à alteração do endereço MAC em uma placa NIC, seja por razões legítimas ou, como veremos, ilegítimas.

Como o MAC Spoofing é Realizado:
#

Embora o endereço MAC seja “gravado” na fábrica, a verdade é que ele pode ser alterado. Existem duas formas principais de fazer isso:

Hardware: Este método envolve alterar as configurações EEPROM da placa de rede. É um processo mais complexo, que exige mais conhecimento técnico e é menos comum em ataques, sendo mais utilizado por “usuários autorizados” para necessidades específicas de rede.
Software: Este é o método mais fácil e comum, e o que nos interessa aqui. Ferramentas e técnicas de software permitem que você mude o endereço MAC que sua placa de rede apresenta para a rede, sem tocar no hardware em si.

Hackers podem usar “sniffers” para capturar o tráfego da rede, extrair endereços MAC de dispositivos autorizados e, em seguida, configurar sua própria estação com um desses MACs falsificados.

Por Que o MAC Spoofing é Realizado (Usos):
#

O MAC spoofing pode ter usos legítimos, mas é mais frequentemente associado a razões não legítimas no contexto de segurança.

Usos Não Legítimos (Maliciosos):

Roubo de Identidade e Entrada Não Autorizada: Um atacante pode se passar por um usuário autorizado alterando seu MAC, ganhando acesso a uma rede sem levantar suspeitas.
Ataques e Evasão de Segurança: Com uma nova identidade, o atacante pode lançar ataques (como negação de serviço) ou burlar controles de acesso. A alteração do MAC também ajuda a evadir sistemas de detecção de intrusão, tornando o atacante “invisível” por mais tempo.
Hijacking de Sessões: Similar ao IP spoofing, pode ser usado para tentar sequestrar uma sessão de comunicação.

Usos Legítimos (Autorizados):

Reconfiguração de Dispositivos: Mudar a função de um PC ou roteador.
Conexões Wireless: Para estabelecer certas conexões.
Troca de Equipamentos: Facilitar a troca de PCs conectados a um modem, evitando reconfigurações complexas.
Sistemas de Failover (Hot Backup): Usar o mesmo MAC do sistema primário para transições rápidas e sem interrupção.
Solução de Problemas e Testes: Debugar redes, testar ferramentas de gerenciamento ou sistemas de detecção de intrusão.

Em Pentesting, o MAC spoofing é uma ferramenta poderosa:

Permite especificar endereços MAC arbitrários para testes.
Pode ser usado para realizar scans indetectáveis, falsificando tanto o IP quanto o MAC de origem.
Útil para testar redirecionamento de tráfego, pontos de acesso e firewalls, além de adquirir informações de hosts remotos.

MAC Spoofing vs. IP Spoofing:

O MAC spoofing é frequentemente considerado o “primo mais sofisticado” do IP spoofing. Embora o IP spoofing receba mais atenção na mídia, o MAC spoofing é uma ferramenta mais versátil e poderosa para invadir uma rede ou para testes de penetração. Enquanto o IP spoofing foca em enviar dados de um endereço de origem falso sem necessariamente esperar uma resposta, o MAC spoofing geralmente busca assumir a identidade MAC de um dispositivo autorizado para se integrar e operar dentro da rede.

2 - Criando o MAC Changer em Python: 🐍
#

Uma das melhores formas de se aprender é praticando. Por isso, resolvi criar um MAC Changer simples em Python, mas bem útil para o aprendizado.

Usei Python por alguns motivos:

Prototipagem: É uma ótima linguagem para prototipar ideias rapidamente.
Facilidade: Sua sintaxe é limpa e intuitiva, facilitando o desenvolvimento.
Interação com Sistema Operacional: Possui uma ótima interação com o sistema operacional, especialmente usando módulos como subprocess.
Biblioteca Gigantesca: Tem uma biblioteca gigantesca para quase tudo o que você precisar.

Python possui um módulo chamado subprocess, que, em resumo, permite que você crie e gerencie novos processos, executando comandos e programas externos diretamente do script em Python.

2.1 - Dissecando o Script:
#

Não tem nada demais no script, mas ele cumpre o que foi proposto: trocar o MAC da nossa interface de rede.

Primeiro, utilizamos o módulo argparse para tornar o script mais profissional e configurável pela linha de comando. Isso nos permite especificar facilmente qual interface (-i ou –interface) queremos modificar e qual o novo endereço MAC (-m ou –mac) desejamos aplicar.

import subprocess
import argparse

def get_arguments():
    parser = argparse.ArgumentParser(
        prog='MAC CHANGER V1',
        description='Script que altera o MAC address do Linux'
    )
    parser.add_argument('-i', '--interface', 
                        type=str, 
                        dest='interface', 
                        help='Nome da Interface de rede', 
                        required=True)
    parser.add_argument('-m', '--mac', 
                        type=str, 
                        dest='new_mac', 
                        help='Novo MAC Address', 
                        required=True)
    return parser.parse_args()

def change_mac(interface, new_mac):
    print(f"[+] Alterando MAC address da interface {interface} para {new_mac}")
    # 1. Desativar a Interface: Necessário para que a alteração seja aplicada.
    subprocess.call(["ifconfig", interface, "down"])
    # 2. Alterar o Endereço MAC: Usamos 'hw ether' com 'ifconfig' para definir o novo MAC.
    subprocess.call(["ifconfig", interface, "hw", "ether", new_mac])
    # 3. Reativar a Interface: Trazemos a interface de volta ao ar com sua nova identidade.
    subprocess.call(["ifconfig", interface, "up"])

if __name__=="__main__":
    args = get_arguments()
    change_mac(args.interface, args.new_mac)

O código é composto por três etapas sendo executadas através de chamadas ao subprocess.call para invocar o comando ifconfig (um clássico em sistemas Linux para configuração de interfaces):

Desativar a Interface (ifconfig down): Antes de mudar o endereço MAC, é essencial que a interface de rede esteja “abaixada”, ou seja, temporariamente desativada. Isso garante que o sistema possa aplicar a nova configuração sem conflitos.
Alterar o Endereço MAC (ifconfig hw ether ): Uma vez que a interface está “down”, o comando ifconfig é utilizado com as opções hw ether para definir o novo endereço MAC.
Reativar a Interface (ifconfig up): Após a alteração, a interface é “levantada” novamente, tornando-se ativa na rede com seu novo endereço MAC.

3 - Criando o Laboratório com Docker: 🐳
#

Recomendo fortemente a criação de laboratórios para testes quando o assunto é cibersegurança e redes. Até porque o script que criamos funciona em sistemas Linux; se você estiver no Windows, já sabe que a abordagem será diferente. E, outra coisa importante: você não vai querer mudar o MAC da sua própria máquina principal, certo? Acredito que não!

Poderíamos usar máquinas virtuais para isso, mas resolvi usar Docker. Por que? Ele é mais leve, me dá mais controle e é super descartável – o que é uma boa forma de aprender sobre redes em containers.

Alguns dos motivos que me fizeram escolher o Docker são:

Isolamento e Controle: Cada container é um ambiente isolado. Se algo der errado (o que é bem normal em testes de segurança!), não afeta seu host principal. É como uma caixa de areia segura para experimentos.
Facilidade de Criação e Destruição: É incrivelmente rápido subir e derrubar containers. Isso permite que façamos testes repetidos e descartemos o ambiente assim que terminamos, mantendo tudo limpo.
Reprodução Consistente: Garante que o ambiente de teste seja sempre o mesmo, não importa onde ou quando você o execute. Isso é vital para validar os resultados de um ataque e garantir que o experimento seja replicável.

3.1 - A Topologia da Rede
#

Para simular um cenário de rede real e testar nosso script de MAC spoofing, vamos criar uma rede customizada no Docker. Eu a chamarei de mac_test_net. Ela será do tipo “bridge”, o que faz com que atue como um switch virtual, conectando nossos containers e permitindo que se comuniquem.

No nosso laboratório, teremos três “máquinas” (containers), cada uma com um papel específico:

docker_server (O Alvo Protegido): Este é o nosso servidor “protegido”, rodando um serviço SSH e um firewall iptables que, em tese, só permite acesso de um MAC específico.
docker_simple_victim (A Vítima Legítima): Um container simples que serve apenas para ter seu endereço MAC descoberto e “roubado” pelo atacante.
docker_attacker (O Agente Malicioso): Nosso container de onde rodaremos o script de MAC changer e de onde partiremos com as tentativas de conexão SSH.

3.2 - Criando o Alvo: docker_server com Firewall IPTables
#

O docker_server precisa de duas coisas principais para nosso experimento: um serviço SSH para tentarmos acessar e um firewall iptables que fará a filtragem por MAC.

Usaremos um Dockerfile que se baseia em uma imagem Ubuntu. Dentro dele, instalaremos o OpenSSH e criaremos um usuário (docker_server) que usaremos para as tentativas de login. A mágica do firewall acontece através do script setup_iptables.sh, que será executado na inicialização do container.

A lógica do firewall é bem clara:

Bloqueio Padrão: Na corrente INPUT da tabela filter, qualquer conexão TCP que tente alcançar a porta 22 (SSH) será inicialmente descartada (DROP). Essa é a regra “default-deny” para o SSH – só entra quem é permitido.
Permissão Seletiva por MAC: Adicionaremos uma regra antes do bloqueio padrão que diz: “Se um pacote TCP chegar na porta 22 e o endereço MAC de origem for exatamente 02:42:0a:0a:00:03 (o MAC da nossa docker_simple_victim), então aceite (ACCEPT) a conexão.”

Essa configuração reflete um erro comum de segurança: confiar cegamente na filtragem de Camada 2. Para que o iptables possa manipular as regras de rede no container, precisamos garantir que o docker_server seja executado com a capacidade –cap-add=NET_ADMIN.

Dockerfile para docker_server:
#

# docker_server/Dockerfile
FROM ubuntu:latest

# Define variáveis de ambiente para o usuário
ARG USER_NAME=docker_server
ARG USER_UID=1001
ARG USER_GID=1001

# Evita que o apt faça perguntas interativas durante a instalação
ENV DEBIAN_FRONTEND=noninteractive

# Atualiza a lista de pacotes e instala as ferramentas necessárias:
# - net-tools, iproute2, curl: Ferramentas de rede básicas
# - iptables: Para o firewall
# - python3, sudo: Para o script de iptables e permissões
# - openssh-server: O servidor SSH que vamos proteger
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    net-tools \
    iproute2 \
    iptables \
    python3 \
    sudo \
    curl \
    openssh-server \
    && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Cria o grupo e o usuário não-root 'docker_server'
# Este será o usuário que você usará para tentar logar via SSH
# O usuário é adicionado ao grupo 'sudo' e configurado para não pedir senha
RUN groupadd -g ${USER_GID} ${USER_NAME} && \
    useradd -u ${USER_UID} -g ${USER_GID} -m -s /bin/bash ${USER_NAME} && \
    echo "${USER_NAME} ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/${USER_NAME} && \
    chmod 0440 /etc/sudoers.d/${USER_NAME}

# Configurações do Servidor SSH:
# - PermitRootLogin yes: Permite que o root faça login (apenas para teste!)
# - PasswordAuthentication yes: Permite login por senha (mais fácil para o teste)
# - UsePAM no: Desabilita PAM para simplificar, já que não temos um sistema PAM completo.
# - StrictModes no: Evita problemas de permissão com chaves SSH se houver.
RUN sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
    sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config && \
    sed -i 's/UsePAM yes/UsePAM no/' /etc/ssh/sshd_config && \
    sed -i 's/#StrictModes yes/StrictModes no/' /etc/ssh/sshd_config

# ---- NOVA LINHA DE CORREÇÃO: Cria o diretório /var/run/sshd explicitamente ----
# Alguns sistemas esperam /var/run/sshd e não apenas /run/sshd (que é um link simbólico)
RUN mkdir -p /var/run/sshd

# Define uma senha para o usuário 'docker_server' (para o teste de SSH)
RUN echo "${USER_NAME}:senha123" | chpasswd

# Define o diretório de trabalho padrão para o usuário.
WORKDIR /home/${USER_NAME}

# Copia o script de configuração do IPTables para dentro do container
COPY setup_iptables.sh .
# Garante que o script seja executável
RUN chmod +x setup_iptables.sh

# Gera as chaves SSH do host (essencial para o sshd iniciar)
RUN ssh-keygen -A

# Expõe a porta 22 (SSH)
EXPOSE 22

# O SSHD e o script de IPTables precisam de privilégios de root para funcionar corretamente.
USER root

# ---- NOVA LINHA CMD PARA INICIAR SSHD DE FORMA MAIS ROBUSTA ----
# Garante que o script de iptables seja executado E que o sshd seja o processo principal.
# O 'sh -c' é mais flexível aqui.
CMD ["/bin/sh", "-c", "/home/docker_server/setup_iptables.sh && /usr/sbin/sshd -D"]

Script setup_iptables.sh:
#

#!/bin/bash
# docker_vuln/setup_iptables.sh

echo "Configurando IPTables para o servidor docker_vuln (SSH)..."

# 1. Limpa todas as regras de firewall existentes (ESSENCIAL PARA GARANTIR UM ESTADO LIMPO)
sudo iptables -F         # Limpa todas as regras das cadeias padrão
sudo iptables -X         # Deleta cadeias não-padrão
sudo iptables -Z         # Zera os contadores de pacotes/bytes

# 2. Permite o tráfego de loopback (comunicação interna do próprio container)
sudo iptables -A INPUT -i lo -j ACCEPT

# 3. Permite o tráfego ICMP (ping) para que você possa testar a conectividade básica
sudo iptables -A INPUT -p icmp -j ACCEPT

# --- REGRA CRUCIAL: Define qual MAC tem permissão para acessar o SSH ---
# Este MAC deve ser o MAC da sua futura máquina 'docker_legit'.
MAC_DA_MAQUINA_LEGITIMA="02:42:0A:0A:00:03" # <-- DEFINA O MAC DA SUA 'docker_legit' AQUI!

echo "MAC permitido para acesso SSH na porta 22: $MAC_DA_MAQUINA_LEGITIMA"

# 4. Permite acesso SSH (porta 22) APENAS se a origem do pacote for o MAC_DA_MAQUINA_LEGITIMA
sudo iptables -A INPUT -p tcp --dport 22 -m mac --mac-source "$MAC_DA_MAQUINA_LEGITIMA" -j ACCEPT

# 5. Permite conexões já estabelecidas (essencial para que as respostas do SSH voltem)
sudo iptables -A INPUT -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

# 6. REGRA DE BLOQUEIO PADRÃO: Bloqueia TODO o resto do tráfego TCP na porta 22
# Qualquer outro MAC, ou tráfego não explicitamente permitido, será DROPPADO aqui.
sudo iptables -A INPUT -p tcp --dport 22 -j DROP

echo "IPTables configurado com sucesso."

# O 'exec "$@"' no CMD do Dockerfile garante que o sshd seja o processo principal.
# Este script apenas configura e sai.
exec "$@"

3.3 - Criando o Atacante e a Vítima:
#

Para completar nosso cenário de teste, precisamos dos outros dois containers: o docker_attacker e o docker_simple_victim.

docker_attacker: Este container será a base para o nosso atacante. Ele será construído a partir de uma imagem Ubuntu e terá as ferramentas necessárias para o ataque instaladas: arp-scan (para descobrir IPs e MACs na rede), python3 e sudo. Para que nosso script de MAC changer funcione, o container docker_attacker também precisará ser executado com a capacidade –privileged, pois a alteração do MAC é uma operação de baixo nível que exige privilégios elevados.

Dockerfile para docker_attacker:
#

# docker_attack/Dockerfile
# Usa a imagem base do Ubuntu na versão 'rolling'
FROM ubuntu

# Define variáveis de ambiente para o usuário
ARG USER_NAME=docker_attacker
ARG USER_UID=1001
ARG USER_GID=1001

# Evita que o apt faça perguntas interativas durante a instalação
ENV DEBIAN_FRONTEND=noninteractive

# Atualiza a lista de pacotes e instala as ferramentas CLI que você precisa
# Inclui 'sudo' para o usuário não-root poder executar comandos como root
# ADICIONADO: arp-scan, nmap (para descoberta de rede) e openssh-client (para SSH)
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    htop \
    curl \
    git \
    sudo \
    python3 \
    python3-pip \
    net-tools \
    iproute2 \
    arp-scan \
    nmap \
    openssh-client \
    && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Cria o grupo e o usuário não-root com os IDs especificados
# Adiciona o usuário ao grupo 'sudo' e configura para não pedir senha ao usar sudo
RUN groupadd -g ${USER_GID} ${USER_NAME} && \
    useradd -u ${USER_UID} -g ${USER_GID} -m -s /bin/bash ${USER_NAME} && \
    echo "${USER_NAME} ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/${USER_NAME} && \
    chmod 0440 /etc/sudoers.d/${USER_NAME}

# Define o diretório de trabalho padrão para o usuário não-root
WORKDIR /home/${USER_NAME}

# Copia o script MAC changer para o diretório de trabalho do usuário
# Certifique-se de que seu script Python esteja no mesmo diretório que este Dockerfile
COPY mac_changer_script.py .

# Troca para o usuário não-root.
USER ${USER_NAME}

# Comando padrão que será executado quando o contêiner iniciar sem um comando específico.
# Isso te dá acesso direto ao shell Bash do 'meuusuario'.
CMD ["bash"]

docker_victim: Este é o container mais simples de todos. Ele terá apenas o necessário para existir na rede e obter um endereço MAC. Seu único propósito é ter seu MAC descoberto pelo docker_attacker, servindo como a “identidade” a ser falsificada.

Dockerfile para docker_simple_victim:
#

# docker_victim/Dockerfile
FROM ubuntu:latest

# Instala um pacote básico para que o container não saia imediatamente
# E ferramentas de rede para debugging se precisar
RUN apt-get update && apt-get install -y iputils-ping net-tools && \
    apt-get clean && rm -rf /var/lib/apt/lists/*

# Comando que mantém o container rodando indefinidamente pois não tem nenhum serviço em exec.
CMD ["tail", "-f", "/dev/null"]

4 - A Demonstração: Executando o Ataque na Prática: 🧑🏻‍💻
#

Agora vamos testar se toda nossa teoria se põe em prática, simulando o ataque (mesmo que simples) no laboratório Docker. Prepare-se, porque a hora da verdade chegou!

4.1 - Preparando o Terreno: Subindo os Containers
#

Primeiro, precisamos garantir que nossa rede Docker e todos os containers estejam prontos. Imagine que você já tem os Dockerfiles e o script mac_changer_script.py organizados em seus respectivos diretórios.

Crie a Rede Docker:
#

Vamos começar criando a rede personalizada, definindo um range de IPs para ela.

# --driver bridge: Usa o modo de rede "bridge", que cria uma rede isolada onde os containers podem se comunicar entre si.
# --subnet 10.10.0.0/24: Define o bloco de rede que o Docker usará para atribuir IPs aos containers (ex: 10.10.0.0 a 10.10.0.255).
# --ip-range 10.10.0.0/24: Especifica o pool de IPs dentro do subnet que o Docker pode alocar.
docker network create --driver bridge --subnet 10.10.0.0/24 --ip-range 10.10.0.0/24 mac_test_net

Construa as Imagens Docker:
#

Navegue até o diretório onde você salvou os Dockerfiles para o docker_server, docker_attacker e docker_victim, e construa as imagens.

# O ponto final (.) no comando `docker build` indica que o contexto da build é o diretório atual.
# Ou seja, o Docker vai procurar o Dockerfile e os arquivos necessários (como o script de IPTables ou o script Python)
# dentro da pasta onde você está executando o comando.

# Na pasta do Dockerfile do docker_server
docker build -t docker_server_image .

# Na pasta do Dockerfile do docker_attacker
docker build -t docker_attacker_image .

# Na pasta do Dockerfile do docker_simple_victim
docker build -t docker_simple_victim_image .

Inicie os Containers:
#

Agora, vamos iniciar os containers. Preste atenção nas flags, pois elas são cruciais para o funcionamento do nosso lab:

--privileged: Para o container atacante, que é necessário para permitir que ele manipule as interfaces de rede de baixo nível, como a alteração do MAC address.
--cap-add=NET_ADMIN: Para o container servidor, para que ele possa usar o iptables e configurar as regras de firewall.
--mac-address: Para a vítima, a flag permite definir um MAC específico para o container ao iniciá-lo, o que é ótimo para nosso teste, pois garantimos que o MAC usado no setup_iptables.sh (do servidor) seja exatamente o mesmo da vítima.

# Iniciar o servidor com o firewall
docker run -d --name docker_server --network mac_test_net --cap-add=NET_ADMIN docker_server_image

# Iniciar a vítima (com o MAC que você usou no script iptables do servidor!)
docker run -d --name docker_victim --network mac_test_net --mac-address 02:42:0A:0A:00:03 docker_victim_image

# Iniciar o atacante
docker run -d --name docker_attacker --network mac_test_net --privileged docker_attacker_image

4.2 - O Reconhecimento: Descobrindo o MAC da Vítima
#

Obviamente, sabemos o MAC da vítima, pois o setamos manualmente no comando de docker run (e no script iptables.sh). Porém, como é um laboratório, tudo bem! Mas em um cenário real, você precisaria descobrir esse MAC. Aqui vai uma das formas mais comuns de se fazer isso:

Com o laboratório montado, o primeiro passo do atacante em um cenário real seria o reconhecimento. Precisamos descobrir qual o endereço MAC da docker_simple_victim, que é a máquina “autorizada” pelo firewall do docker_server.

Acessar o Atacante: Entre no shell do container docker_attacker.

docker exec -it docker_attacker bash

Localizar o IP + MAC de todos na rede com arp-scan: Dentro do docker_attacker, vamos usar o arp-scan para escanear a rede e encontrar os IPs e MACs dos dispositivos conectados.

arp-scan -l

A saída mostrará todos os dispositivos na rede mac_test_net. Procure pelo IP correspondente ao docker_victim e anote o endereço MAC dele. Provavelmente, será algo como 10.10.0.3 com o MAC 02:42:0A:0A:00:03 (ou similar, dependendo do Docker e da ordem de inicialização).

Exemplo de Saída (simplificada):

Interface: eth0, datalink type: EN10MB (Ethernet)
...
10.10.0.2      02:42:0a:0a:00:02   (Unknown)   # docker_server
10.10.0.3      02:42:0a:0a:00:03   (Unknown)   # docker_simple_victim (este é o que queremos!)
...

IMPORTANTE: Se o MAC da docker_victim que você definiu no setup_iptables.sh (do servidor) for diferente do MAC real da docker_victim (que você acabou de descobrir ou setou no docker run), o firewall não vai funcionar como esperado. Verifique se eles são os mesmos! Se precisar, edite o setup_iptables.sh e reconstrua/reinicie o docker_server para que o MAC permitido seja o correto.

4.3 - Testando o Acesso Inicial (Antes do Spoofing)
#

Vamos tentar acessar o docker_server via SSH antes de fazer o spoofing. Isso é para provar que o firewall está funcionando e bloqueando as conexões do nosso atacante.

Tentativa de SSH (Falha Esperada): No terminal do docker_attacker, tente conectar ao docker_server usando o IP 10.10.0.2.

ssh [email protected]

Você receberá uma mensagem ou a conexão vai simplesmente “travar” e depois retornar com um erro de Connection timed out ou Connection refused. Isso confirma que o firewall no docker_server está fazendo seu trabalho, bloqueando acessos de MACs não autorizados.

4.4 - O Ataque: MAC Spoofing em Execução
#

Agora é a hora do nosso script Python ser usado. Usaremos o MAC que descobrimos (ou definimos) da docker_victim para o nosso docker_attacker se passar por ela.

Executar o MAC Changer: Ainda no terminal do docker_attacker, execute o nosso script mac_changer_script.py, passando a interface de rede do atacante (geralmente eth0 ou ensX) e o MAC da vítima.

Para descobrir a interface no container, você pode usar ip a ou ifconfig. Provavelmente, será eth0.

# Sintaxe: python3 mac_changer_script.py -i <interface> -m <MAC_DA_VITIMA>
# Pode ser necessario usar sudo
python3 mac_changer_script.py -i eth0 -m 02:42:0a:0a:00:03

O script imprimirá mensagens indicando que o MAC está sendo alterado.

Verificando a Alteração: Você pode verificar se o MAC foi alterado com o comando:

ifconfig eth0

A saída deverá mostrar o novo MAC address para a interface eth0.

4.5 - Bypass: Acessando o Servidor com o MAC Falsificado
#

Com o MAC alterado, nosso atacante agora tem a “identidade” da docker_victim. Vamos tentar o SSH novamente.

Tentativa de SSH (Sucesso Esperado): No mesmo terminal do docker_attacker (agora com o MAC spoofado), tente conectar ao docker_server via SSH novamente.

ssh [email protected]

Se tudo correu bem, você será solicitado pela senha (que definimos como senha123 no Dockerfile do docker_server). Após inserir a senha, você deverá ter acesso ao shell do docker_server!

Isso prova que, ao assumir o MAC de um dispositivo autorizado, nosso atacante conseguiu burlar a regra de firewall baseada em MAC. É um exemplo claro de como a segurança baseada apenas em Camada 2 é frágil.

4.6 - Limpando o Laboratório
#

Depois de testar, uma boa prática limpar os containers e a rede Docker para evitar lixo no seu sistema.

# Sair do terminal do atacante se ainda estiver dentro
exit

# Parar e remover os containers
docker stop docker_server docker_victim docker_attacker
docker rm docker_server docker_victim docker_attacker

# Remover a rede Docker
docker network rm mac_test_net

# Opcional: Remover as imagens (se não for usá-las mais e quiser liberar espaço)
docker rmi docker_server_image docker_victim_image docker_attacker_image

5 - Conclusão: A Fragilidade da Camada 2 e Nossas Ferramentas: 🔧
#

Chegamos ao fim do guia. Apesar de parecer uma boa ideia, a segurança baseada apenas no MAC Address na Camada 2 é bem frágil. Nosso laboratório simples com Docker provou isso na prática: um atacante pode facilmente “roubar” a identidade de uma máquina legítima e burlar um firewall que só olha para o MAC.

5.1 - Resumo da Nossa Stack:
#

Neste guia, exploramos o MAC Spoofing usando as seguintes ferramentas e conceitos:

Python: Nossa escolha para criar o mac_changer_script.py, aproveitando sua simplicidade e o poder do módulo subprocess para interagir com o sistema.
Docker: Essencial para montar um laboratório leve, isolado e descartável, ideal para testar cenários de rede sem bagunçar a máquina principal.
IPTables: Usado no docker_server para simular um firewall que filtra o acesso via SSH baseado no MAC de origem, sendo o nosso “alvo” de bypass.
Comandos Linux (ifconfig, arp-scan, ssh): As ferramentas base para o reconhecimento e a interação com as interfaces de rede dentro dos containers.

5.2 - Como se Proteger (Medidas Simples de Mitigação):
#

Para evitar ser vítima de ataques como o MAC Spoofing:

Autenticação de Rede (802.1X): Não deixe a rede liberar o acesso só pelo MAC. Exija que usuários e dispositivos se autentiquem de verdade.
Filtragem de IP e Porta: Use firewalls que filtrem também por endereço IP e por porta. Assim, mesmo com o MAC falsificado, o atacante ainda precisaria ter o IP certo e tentar a porta correta.
Inspeção de ARP (DAI): Configure seus switches para validar os pacotes ARP, dificultando que MACs ou IPs falsificados circulem na sua rede.
Segmentação de Rede (VLANs): Divida sua rede em partes menores (VLANs). Se alguém invadir uma parte, ele fica contido ali, sem acesso ao resto.
Monitoramento: Tenha sistemas que detectem coisas estranhas na rede, como MACs que mudam do nada ou IPs com vários MACs diferentes.
Senhas Fortes e MFA: Se o atacante passar pelas camadas de rede, ele ainda vai bater de frente com a senha. E com a Autenticação Multifator (MFA), a vida dele fica ainda mais difícil.

Continue aprendendo e testando!

Link para o Repositorio no Github

scriptJohnmns/mac_spoofing_lab_docker

Este repositório contém um laboratório prático para demonstrar como o MAC Spoofing pode ser usado para burlar firewalls que dependem apenas do endereço MAC na Camada 2.

Dockerfile

Author

ScriptJohn_

Apenas um cara que sofre de ‘pcismo’ e gosta de cybersegurança

1 - Introdução: A Falsa Sensação de Segurança na Camada 2: 🛡️ #

1.1 - O Que é Endereço MAC? #

1.2 - O Que é MAC Spoofing? #

Como o MAC Spoofing é Realizado: #

Por Que o MAC Spoofing é Realizado (Usos): #

2 - Criando o MAC Changer em Python: 🐍 #

2.1 - Dissecando o Script: #

3 - Criando o Laboratório com Docker: 🐳 #

3.1 - A Topologia da Rede #

3.2 - Criando o Alvo: docker_server com Firewall IPTables #

Dockerfile para docker_server: #

Script setup_iptables.sh: #

3.3 - Criando o Atacante e a Vítima: #

Dockerfile para docker_attacker: #

Dockerfile para docker_simple_victim: #

4 - A Demonstração: Executando o Ataque na Prática: 🧑🏻‍💻 #

4.1 - Preparando o Terreno: Subindo os Containers #

Crie a Rede Docker: #

Construa as Imagens Docker: #

Inicie os Containers: #

4.2 - O Reconhecimento: Descobrindo o MAC da Vítima #

4.3 - Testando o Acesso Inicial (Antes do Spoofing) #

4.4 - O Ataque: MAC Spoofing em Execução #

4.5 - Bypass: Acessando o Servidor com o MAC Falsificado #

4.6 - Limpando o Laboratório #

5 - Conclusão: A Fragilidade da Camada 2 e Nossas Ferramentas: 🔧 #

5.1 - Resumo da Nossa Stack: #

5.2 - Como se Proteger (Medidas Simples de Mitigação): #