seL4 ICS Gateway Demo

Um projeto de pesquisa defensiva em segurança que compara arquiteturas protocol-break vs packet-forwarding para proteger sistemas de controle industrial contra ataques cibernéticos.

Documentação:

Arquitetura de Rede - Diagramas de rede e fluxo de tráfego

Arquitetura de Contêineres - Relações entre contêineres Docker

Explicações de CVE - Detalhes de vulnerabilidades e mecanismos de ataque

Motivação da Pesquisa

Os sistemas modernos de ICS/SCADA enfrentam ataques sofisticados como o FrostyGoop, que teve como alvo sistemas ucranianos de aquecimento distrital via Modbus TCP em janeiro de 2024, deixando mais de 600 residências sem aquecimento durante temperaturas abaixo de zero. As soluções de segurança tradicionais (firewalls, IDS) usam arquiteturas packet-forwarding que inspecionam o tráfego em linha, mas mantêm uma única conexão TCP de ponta a ponta.

Este projeto demonstra uma alternativa: um gateway protocol-break usando o microkernel seL4 formalmente verificado. Ao encerrar conexões TCP e validar a semântica do protocolo antes de estabelecer novas conexões com os dispositivos protegidos, essa arquitetura oferece garantias de segurança mais fortes.

Principais Descobertas

Arquitetura

┌─────────────────────────────────────────────────────────────────────────────┐
│ Docker Network: ics-untrusted (192.168.96.0/24)                             │
│                                                                             │
│   ┌───────────────────────┐       ┌───────────────────────┐                │
│   │ seL4 Gateway          │       │ Snort IDS             │                │
│   │ Port 502              │       │ Port 503              │                │
│   │                       │       │                       │                │
│   │ • Protocol-break      │       │ • Packet-forwarding   │                │
│   │ • TCP termination     │       │ • Inline inspection   │                │
│   │ • Length validation   │       │ • Rule-based detection│                │
│   └───────────┬───────────┘       └───────────┬───────────┘                │
│               │                               │                             │
├───────────────┼───────────────────────────────┼─────────────────────────────┤
│ Docker Network: ics-protected (192.168.95.0/24)                             │
│               │                               │                             │
│               └───────────────┬───────────────┘                             │
│                               ▼                                             │
│               ┌───────────────────────────────┐                             │
│               │ PLC (District Heating)        │                             │
│               │ Vulnerable libmodbus 3.1.2    │                             │
│               │ Port 5020 (direct access)     │                             │
│               └───────────────────────────────┘                             │
└─────────────────────────────────────────────────────────────────────────────┘

Início Rápido

Pré-requisitos

Docker e Docker Compose v2
Imagem do kernel do gateway seL4 (fornecida pelo usuário)
~4GB de RAM para QEMU

1. Adicionar Imagem do seL4

# Place your seL4 kernel image at:
gateway/sel4-image/capdl-loader-image-arm-qemu-arm-virt

2. Compilar e Executar

# Build all containers
sudo docker compose build

# Start individual containers
sudo docker compose up plc        # PLC only
sudo docker compose up gateway    # seL4 gateway + PLC
sudo docker compose up snort      # Snort IDS + PLC

# Start all
sudo docker compose up

3. Testar Conexões

# Through seL4 gateway (protected - protocol-break)
echo -ne '\x00\x01\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01' | nc localhost 502 | xxd

# Through Snort IDS (protected - packet-forwarding)
echo -ne '\x00\x01\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01' | nc localhost 503 | xxd

# Direct to PLC (unprotected - vulnerable)
echo -ne '\x00\x01\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01' | nc localhost 5020 | xxd

Mapeamento de Portas

Nota: O PLC padrão agora executa no modo CVE-2022-0367 com ASAN. Use --profile cve14462 para testes do CVE-2019-14462.

Demonstrações de Vulnerabilidades

CVE-2019-14462: Estouro de Buffer no Heap do libmodbus

O PLC usa a libmodbus 3.1.2 intencionalmente vulnerável. O ataque explora campos de comprimento MBAP confiáveis:

# Start PLC in CVE-2019-14462 mode
sudo docker compose --profile cve14462 up plc-14462

# Build attack tools
cd cve_tools && make

# Attack unprotected PLC (crashes)
./cve_14462_attack 127.0.0.1 5022

# Attack through seL4 (BLOCKED)
./cve_14462_attack 127.0.0.1 502

# Attack through Snort (DETECTED by Quickdraw rules)
./cve_14462_attack 127.0.0.1 503

CVE-2022-0367: Subfluxo de Buffer no Heap do libmodbus

Um bug de verificação de limites em modbus_mapping_new_start_address() permite subfluxo de heap por meio do código de função 0x17 (Write and Read Registers):

# Default PLC runs in CVE-2022-0367 mode with ASAN
sudo docker compose up plc

# Build attack tools
cd cve_tools && make

# Attack PLC - ASAN will detect heap-buffer-overflow
./cve_0367_attack 127.0.0.1 5020

# Attack with custom parameters
./cve_0367_attack 127.0.0.1 5020 88 0x4141  # Corrupt tab_registers pointer
./cve_0367_attack 127.0.0.1 5020 72 0xFFFF  # Corrupt nb_registers

# Attack through seL4 (BLOCKED - address validation)
./cve_0367_attack 127.0.0.1 502

# Attack through Snort (DETECTED by custom rules)
./cve_0367_attack 127.0.0.1 503

Detalhes Técnicos:

O servidor usa start_registers=100; os endereços válidos são 100-109
O ataque envia write_address < 100, causando um índice de array negativo
O subfluxo de heap pode corromper campos da estrutura mb_mapping, incluindo ponteiros

CVE-2022-20685: DoS no Preprocessador Modbus do Snort

O Snort 2.9.18 tem um estouro de inteiro em seu preprocessador Modbus que causa um loop infinito, bloqueando completamente todo o tráfego que passa pelo IDS:

# 1. Verify Snort is working (should return Modbus response)
echo -ne '\x00\x01\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01' | nc -w 2 localhost 503 | xxd

# 2. Attack the Snort IDS
./cve_20685_attack 127.0.0.1 503

# 3. Verify Snort is frozen (should timeout with NO response)
echo -ne '\x00\x01\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01' | nc -w 5 localhost 503 | xxd

# 4. Check Snort CPU (should be 100%)
sudo docker exec ics-snort top -b -n 1 | grep snort

# 5. seL4 is IMMUNE (no Modbus preprocessor to exploit)
./cve_20685_attack 127.0.0.1 502  # No effect on seL4

# 6. Restart Snort after demo
sudo docker compose restart snort

Por que isso é devastador: O Snort usa o modo inline NFQUEUE, o que significa que os pacotes ficam retidos na fila do kernel até que o Snort retorne um veredito. Quando o Snort trava, nenhum veredito é retornado e TODO o tráfego para - não apenas a cegueira do IDS, mas a negação completa de serviço.

CVE-2024-1086: Escalonamento de Privilégios no Kernel Linux

Um use-after-free no netfilter nf_tables do Linux (kernels v5.14-v6.6) permite a fuga de contêiner:

# Check if host is vulnerable
uname -r  # Vulnerable: v5.14 - v6.6 (before patches)

# The exploit is available at:
ls cve_tools/cve-2024-1086/

Por que isso importa: Os contêineres Docker compartilham o kernel do host. Se um atacante comprometer o Snort (por exemplo, via CVE-2022-20685), ele poderá usar o CVE-2024-1086 para escapar do contêiner e obter root no host. O seL4 é imune porque executa um microkernel mínimo, e não o Linux.

Scripts de Demonstração

# Full demo with 4 quadrants (PLC, seL4, Snort, User terminal)
./scripts/demo.sh

# Snort-only demo with 3 panes (PLC, Snort, User terminal)
./scripts/demo-snort.sh

Experimento de Comparação Completo

# Run automated comparison
./scripts/run_comparison.sh

Perfis de Regras do Snort

Várias configurações do Snort estão disponíveis para avaliar a eficiência de detecção:

# Run Snort with specific profile
sudo docker compose --profile snort-talos up

# Compare detection efficiency
sudo docker compose --profile snort-quickdraw up -d
./cve_tools/cve_0367_attack 127.0.0.1 503  # Test detection
sudo docker compose --profile snort-quickdraw down

sudo docker compose --profile snort-combined up -d
./cve_tools/cve_0367_attack 127.0.0.1 503  # Test detection
sudo docker compose --profile snort-combined down

Comparação de Cobertura de Regras

Protocol-Break vs Packet-Forwarding

Packet-Forwarding (IDS/IPS Tradicional)

Client ────TCP────► Snort ────TCP────► PLC
          (same connection flows through)

Conexão TCP única de ponta a ponta
O atacante pode manipular o estado TCP
O IDS pode ser atacado (CVE-2022-20685)
Requer assinaturas para cada variante de ataque

Protocol-Break (seL4 Gateway)

Client ────TCP1────► seL4 ────TCP2────► PLC
              (terminates, validates, new connection)

Duas conexões TCP independentes
O cliente não pode influenciar o estado TCP do PLC
Validação antes que qualquer dado chegue ao PLC
Captura classes inteiras de entrada malformada

Componentes

Ferramentas de CVE

Simulação do PLC

O PLC simula um controlador de aquecimento distrital com suporte a múltiplos mestres (arquitetura thread-por-cliente, típica de PLCs modernos).

Modos do PLC

Modo	Serviço	Porta	Descrição
CVE-2022-0367	`plc` (padrão)

# Default mode (CVE-2022-0367 with ASAN)
sudo docker compose up plc

# CVE-2019-14462 mode
sudo docker compose --profile cve14462 up plc-14462

Registradores Modbus

No modo CVE-2022-0367, os registradores estão nos endereços 100-109 (use o endereço 40101 em ferramentas SCADA):

Aviso de Segurança

Este projeto contém código intencionalmente vulnerável para pesquisa defensiva em segurança. A libmodbus 3.1.2 vulnerável e o Snort 2.9.18 estão incluídos para demonstrar conceitos de segurança.

Não implante componentes desprotegidos em ambientes de produção.

Referências

Vulnerabilidades

CVE-2019-14462 - Estouro de buffer no heap do libmodbus (comprimento MBAP)
CVE-2022-0367 - Subfluxo de buffer no heap do libmodbus (start_address)
CVE-2022-20685 - DoS no preprocessador Modbus do Snort
CVE-2024-1086 - Escalonamento de privilégios no nf_tables do kernel Linux

Pesquisa em Segurança

Claroty Team82 - Análise do CVE-2022-20685 do Snort
libmodbus Issue #614 - Divulgação do CVE-2022-0367
CVE-2024-1086 PoC - Exploit de kernel com taxa de sucesso de 99,4%

Recursos ICS/SCADA

seL4 Microkernel - Microkernel formalmente verificado
Digital Bond Quickdraw - Regras Snort ICS/SCADA padrão da indústria
Dragos FrostyGoop Report - Análise de malware ICS (ataque à Ucrânia em jan. de 2024)
The Record - FrostyGoop - 600 residências ucranianas sem aquecimento

Licença

Apenas para pesquisa defensiva autorizada em segurança e fins educacionais.

CVE-2019-14462	BLOQUEADO (validação de comprimento)	DETECTADO (regras Quickdraw)
CVE-2022-0367	BLOQUEADO (validação de endereço)	DETECTADO (regras personalizadas)
CVE-2022-20685	IMUNE (sem preprocessador)	VULNERÁVEL (DoS no IDS)
CVE-2024-1086	IMUNE (sem kernel Linux)	VULNERÁVEL (compartilha o kernel do host)
Variantes desconhecidas	BLOQUEADO (validação estrutural)	NÃO DETECTADO (sem assinatura)
Ataques de estado TCP	BLOQUEADO (conexão encerrada)	Possível
Superfície de ataque	~1.000 linhas de código (microkernel)	~500.000 linhas de código (Linux + Snort)

502	Cliente → seL4 → PLC	Protocol-break	Valida a estrutura Modbus
503	Cliente → Snort → PLC	Packet-forwarding	IDS baseado em regras
5020	Cliente → PLC (ASAN)	Direto	Modo CVE-2022-0367
5022	Cliente → PLC	Direto	Modo CVE-2019-14462 (perfil: cve14462)

default	`docker compose up snort`	12	Quickdraw (padrão da indústria)
quickdraw	`--profile snort-quickdraw`	12	Apenas Digital Bond Quickdraw
talos	`--profile snort-talos`	40	Estilo Talos com palavras-chave `modbus_func`
modbus	`--profile snort-modbus`	13	Apenas regras personalizadas de detecção de CVE
combined	`--profile snort-combined`	65	Todas as regras combinadas

CVE-2019-14462 (comprimento MBAP)	✅	✅	✅
CVE-2022-0367 (subfluxo de heap)	❌	✅	✅
CVE-2022-20685 (DoS no Snort)	❌	✅	✅
Operações de escrita	❌	✅	✅
Reconhecimento	✅	✅	✅
Códigos de função DoS	✅	✅	❌

`gateway/`	Contêiner do gateway seL4 (QEMU + kernel seL4)
`snort/`	IDS Snort 2.9.18 com vários perfis de regras (vulnerável ao CVE-2022-20685)
`plc/`	Simulação de aquecimento distrital (libmodbus 3.1.2 vulnerável, modo CVE-2022-0367)
`cve_tools/`	Ferramentas de ataque para demonstrações de CVE
`scripts/`	Scripts utilitários e de experimentos
`docs/`	Documentação com diagramas Mermaid (Rede, Contêineres, CVEs)

sel4-ics-gateway-demo

Mais Populares

`cve_14462_attack`	libmodbus	Estouro de buffer no heap via incompatibilidade de comprimento MBAP
`cve_0367_attack`	libmodbus	Subfluxo de heap via endereço de escrita inválido (FC 0x17)
`cve_20685_attack`	Snort	Loop infinito no preprocessador Modbus (DoS)
`cve-2024-1086/`	Kernel Linux	Escalonamento de privilégios via nf_tables (fuga de contêiner)

100	HR[0]	Temperatura interna (°C ÷10)	R
101	HR[1]	Comando da válvula (0-100%)	R/W
102	HR[2]	Setpoint de temperatura (°C ÷10)	R/W
103	HR[3]	Modo (0=Manual, 1=Auto)	R/W
104	HR[4]	Temperatura externa (°C ÷10)	R
105-109	HR[5-9]	Status, posição, temperatura de alimentação, tempo de operação, potência	R