Evasião Avançada de EDR via Spoofing de Telemetria de IA e Sandboxing WASM. O Project Onyx é um pipeline PoC de Red Team projetado para demonstrar técnicas avançadas de evasão contra sistemas EDR modernos. Ele se afasta da ofuscação tradicional baseada em assinaturas em direção à camuflagem comportamental e ao keying ambiental estrito.
Evasão Avançada de EDR via Spoofing de Telemetria de IA e Sandboxing WASM. O Project Onyx é um pipeline de Red Team PoC projetado para demonstrar técnicas avançadas de evasão contra sistemas EDR modernos. Ele se afasta da ofuscação tradicional baseada em assinaturas em direção à camuflagem comportamental e ao chaveamento ambiental estrito.
Este Projeto é uma pesquisa de red team como prova de conceito, estudando um pipeline de execução multicamadas não convencional. A arquitetura encadeia cinco técnicas distintas: camuflagem de telemetria de IA, chaveamento ambiental vinculado ao hardware, esteganografia em pesos ONNX, sandboxing WebAssembly em memória e C2 Dead-Drop via atualizações de modelo por downlink --> em uma única cadeia de entrega funcional.
O Project Onyx não afirma ser um bypass funcional de sistemas EDR de produção. Trata-se de um esboço arquitetural: cada componente é implementado e funcional como parte da cadeia, mas cada camada exigiria pesquisa dedicada para se tornar significativa contra defesas do mundo real.O Project Onyx é melhor compreendido como um ponto de partida estruturado para esse tipo de exploração. O payload em tempo de execução é intencionalmente limitado a um beacon de heartbeat, permitindo que todo o pipeline seja examinado sem incluir comportamento destrutivo ou de pós-exploração.
onnxruntime da Microsoft. Isso torna o artefato ONNX uma parte ativa do pipeline, em vez de um arquivo decorativo como o pequeno MLP anterior.MachineGuid do alvo, do Volume Serial Number e do SID do usuário atual.wasm3. O aplicativo host em C++ atua apenas como um carregador e ponte de API, expondo funções seguras do host ao sandbox WASM.float32 do ONNX. O host extrai esse cofre de pesos dos bytes do modelo incorporado, o autentica e somente então recupera o material de chave de demonstração.heartbeat_ack e set_status, demonstrando a viabilidade do canal sem permitir execução arbitrária de comandos.
Consulte docs/architecture.md para o esboço técnico COMPLETO de ponta a ponta. (Recomendo, para um melhor entendimento).
e também todo o processo: meus erros, os conceitos e ideias que considerei ao longo do caminho e os tradeoffs arquiteturais que enfrentei ao construir o Project Onyx --> Medium
Este projeto foi criado exclusivamente para fins educacionais, pesquisa em segurança e operações autorizadas de Red Team.
As técnicas demonstradas neste repositório (Project Onyx) têm a intenção de ajudar profissionais de segurança a compreender métodos avançados de evasão e a melhorar as defesas de endpoint (EDR/XDR).
Não use este software em qualquer sistema ou rede que você não possua ou para o qual não tenha permissão explícita e por escrito para testar.
O autor deste projeto (X-3306) não assume nenhuma responsabilidade e não é responsável por qualquer uso indevido, dano ou atividades ilegais causadas pelo uso deste software. Ao baixar, compilar ou usar este código, você concorda em assumir total responsabilidade por suas ações.
DiagnosticsTool.cpp - Host Windows em C++ e integração Wasm3/ONNX.DiagnosticsTool.rc / resource.h - bindings de recursos para os ativos gerados.build.py - auxiliar para fingerprinting, geração de isca ONNX, incorporação do cofre de pesos, compatibilidade do cofre de metadados, C2 Dead-Drop via atualizações de modelo por downlink e criptografia WASM.wasm_license_module/ - código-fonte Rust para o módulo de heartbeat WebAssembly.wasm3/source/ - fonte Wasm3 mínima incluída (vendored) exigida pela compilação CMake.assets/README2.md - formatos dos ativos gerados.docs/architecture.md - cadeia completa de runtime e notas de arquitetura.Instale estes itens no Windows antes de compilar:
Dependências do Python:
py -m pip install onnx numpy cryptography
Alvo Rust:
rustup target add wasm32-unknown-unknown
O arquivo CMake espera uma árvore de fonte/compilação do ONNX Runtime em ./onnxruntime e
vincula as bibliotecas de componentes estáticos a partir de:
onnxruntime/build/Windows/Release/Releaseonnxruntime/build/Windows/Release/vcpkg_installed/x64-windows-static-md/libA partir de um PowerShell de Desenvolvedor para VS 2022, compile o ONNX Runtime assim:
git clone --recursive https://github.com/microsoft/onnxruntime.git onnxruntime
.\onnxruntime\build.bat --config Release --parallel --compile_no_warning_as_error --skip_tests --build_shared_lib --use_vcpkg --cmake_extra_defines VCPKG_TARGET_TRIPLET=x64-windows-static-md onnxruntime_BUILD_UNIT_TESTS=OFF
O onnxruntime.dll gerado não é distribuído com o Project Onyx. O Project Onyx
vincula os arquivos .lib dos componentes estáticos e o executável final não deve listar
onnxruntime.dll em dumpbin /DEPENDENTS.
Obtenha o hash de fingerprint para o dispositivo Windows atual:
python build.py fingerprint --show-components
Use a segunda linha impressa como o valor de --trigger.
Compile o módulo Rust WebAssembly:
cargo build --manifest-path wasm_license_module/Cargo.toml --target wasm32-unknown-unknown --release
Gere assets/model.onnx e assets/license_module.wasm.aes:
python build.py build `
--trigger "<64-char lowercase fingerprint hash>" `
--secret "<exactly-32-demo-key-chars>" `
--model-output assets/model.onnx `
--wasm-input wasm_license_module/target/wasm32-unknown-unknown/release/wasm_license_module.wasm `
--wasm-output assets/license_module.wasm.aes
Verifique os cofres ONNX:
python build.py verify --trigger "<64-char lowercase fingerprint hash>" --model assets/model.onnx
O comando de verificação checa tanto o cofre de metadados legado quanto o cofre oculto de pesos ONNX. Ambos devem desbloquear o mesmo material de chave de demonstração de 32 caracteres.
O transportador padrão é o SqueezeNet 1.0 opset 12:
onnxmodelzoo/squeezenet1.0-12assets/base/squeezenet1.0-12.onnxdata_0, float[1, 3, 224, 224]softmaxout_1, float[1, 1000, 1, 1]Baixe ou verifique o modelo base incluído:
python build.py fetch-model
O build.py build copia este modelo real, adiciona os metadados do Project Onyx, incorpora o
cofre de pesos ONNX autenticado nos LSBs do inicializador float32 e grava o modelo de
referência final em assets/model.onnx.
O downlink adicional é uma extensão de pesquisa para testar se uma atualização normal de modelo ONNX pode transportar um sinal de controle autenticado e minúsculo como uma PoC simples. Ele é deliberadamente limitado a duas diretivas seguras:
heartbeat_ack - altera o status de heartbeat do runtime para heartbeat_ack.set_status - altera o status de heartbeat do runtime para uma string segura
escolhida pelo operador, como lab_downlink_ack.Crie um modelo de atualização de laboratório:
python build.py downlink-build `
--trigger "<64-char lowercase fingerprint hash>" `
--reference-model assets/model.onnx `
--output assets/downlink_update.onnx `
--command set_status `
--status lab_C2_test `
--expires-unix 4102444800 `
--cover-seed 2026 `
--cover-fraction 0.08 `
--cover-noise-scale 0.00004
Verifique-o antes do uso:
python build.py downlink-verify `
--trigger "<64-char lowercase fingerprint hash>" `
--reference-model assets/model.onnx `
--model assets/downlink_update.onnx
Aponte-o para um artefato de modelo HTTPS bruto, por exemplo, um ativo de release público:
$env:PROJECT_ONYX_DOWNLINK_MODEL_URL = "https://huggingface.co/<profile>/<repo>/resolve/main/downlink_update.onnx"
.\build\Release\ProjectOnyx.exe
Ou use webhook Slack/Teams:
O Project Onyx não incorpora uma URL de webhook real. Para execuções de laboratório autorizadas, defina:
A variável deve estar visível para o processo que inicia ProjectOnyx.exe. Se
você der um duplo clique no executável, defina-a primeiro como uma variável de ambiente
do usuário ou do sistema, depois abra um novo terminal ou reinicie o Explorer E execute o host nativo com um modelo de atualização local:
$env:PROJECT_ONYX_DOWNLINK_MODEL_PATH = "$($PWD.Path)\assets\downlink_update.onnx"; $env:PROJECT_ONYX_SLACK_WEBHOOK_URL = "https://hooks.slack.com/services/..."; .\build\Release\ProjectOnyx.exe
(Você também pode usar o Teams)
O runtime realiza uma única busca/leitura na inicialização. Ele não faz polling, não persiste, não executa código baixado nem processa comandos arbitrários. Atualizações de modelo inválidas, expiradas, não relacionadas ou não autenticadas são ignoradas.
Opções de verificação do runtime:
$env:PROJECT_ONYX_ONNX_TELEMETRY_PASSES = "24"
$env:PROJECT_ONYX_REQUIRE_ONNX_TELEMETRY = "1"
$env:PROJECT_ONYX_LAB_OUTPUT_PATH = "$($PWD.Path)\assets\lab_heartbeat.json"
PROJECT_ONYX_ONNX_TELEMETRY_PASSES controla quantas inferências reais do ONNX Runtime
são executadas antes de o caminho de desbloqueio do cofre continuar. PROJECT_ONYX_REQUIRE_ONNX_TELEMETRY=1
transforma falhas de telemetria em falhas graves, o que é útil ao validar
que o estágio ONNX não está sendo ignorado. PROJECT_ONYX_LAB_OUTPUT_PATH grava
o JSON final de heartbeat em um arquivo local para verificação em laboratório, sem exigir
um webhook.
Este repositório inclui um modelo de referência SqueezeNet real porque ele é pequeno o suficiente para o GitHub e ainda assim é uma rede neural treinada legítima. Para um artefato de pesquisa mais robusto, crie um modelo atualizado por meio de fine-tuning real ou de outro processo normal de manutenção de modelo. O embedder de downlink pode então restringir suas alterações de bits aos pesos que já mudaram em relação ao modelo de referência. Essa é a versão prática da ideia de "esconder dentro do ruído do fine-tuning", link para o projeto paralelo completo: https://github.com/X-3306/ONNXStego
Para validação rápida em laboratório, o downlink-build pode sintetizar uma
atualização de cobertura aleatória com semente, semelhante a um fine-tuning, a partir do modelo de
referência. Isso comprova a mecânica de ponta a ponta e oferece pesos candidatos
naturais para o registro LSB, MAS não substitui a avaliação empírica em uma tarefa,
conjunto de dados e procedimento de fine-tuning reais.
Configure e compile o executável de release:
cmake -S . -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Release
O executável final é:
build\Release\ProjectOnyx.exe
Verificação opcional de dependências:
& "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.44.35207\bin\Hostx64\x64\dumpbin.exe" /DEPENDENTS build\Release\ProjectOnyx.exe
Esperado: nenhuma dependência de onnxruntime.dll.
A demonstração não inclui persistência, escalonamento de privilégios, acesso a credenciais,
movimento lateral, execução arbitrária de comandos, comportamento destrutivo ou tokens
privados de webhook embutidos. O módulo WebAssembly está restrito a formatar e
retornar um JSON de heartbeat como uma PoC simples. O downlink adicional de atualização de modelo
só pode alterar o status de heartbeat por meio da whitelist heartbeat_ack / set_status.
Se você tiver ideias interessantes para este projeto, sinta-se à vontade para entrar em contato: [email protected]