BurnerNet

Cliente HTTP antiforense de confiança zero. Elimina segredos. Rompe rastros. CPR em um Tanque Stealth. 👻

BurnerNet é um cliente HTTP antiforense em C++20. Oferece uma API fluente, semelhante ao CPR, para aplicativos que não podem confiar totalmente na máquina local—eliminando fisicamente segredos da RAM e rompendo rastros de execução para esconder sua lógica de scanners e depuradores.

Oferece padrões familiares e compatíveis com o host para HTTP comum e um perfil Hardened explícito para ambientes hostis. Ambos os caminhos favorecem clientes de curta duração; a confiança avançada permanece de propriedade do aplicativo.

Quer proteger os payloads baixados pelo BurnerNet? Confira o RipStop Codec para desembaralhamento de ativos em memória.

Princípios • Introdução • Caminhos de Integração • Realidade de Segurança

De relance

Por que usar

Use BurnerNet quando um cliente HTTP normal é confiável demais para o seu ambiente.

Ajuda quando você deseja:

• manter clientes de requisição de curta duração em vez de compartilhar um transporte global
• reduzir a dependência de DNS local e outros padrões do host
• buscar tokens, certificados e segredos de verificação apenas quando necessário
• manter a lógica de verificação de resposta em seu próprio código de aplicativo
• reduzir strings de texto simples e metadados óbvios em builds endurecidos

Para quem é

BurnerNet se adequa a projetos como:

• aplicativos de desktop Windows com requisições de alta segurança para autenticação, licenciamento ou atualizações
• código embarcado ou injetado executando em um host no qual você não confia totalmente
• ferramentas que desejam verificações de transporte mais rigorosas sem abrir mão de uma API C++ fluente

Stack Padrão vs BurnerNet

Resultados Defensivos

• Arquitetura de Memória Sem Fantasmas: BurnerNet usa um Prefix-Size Scrubber personalizado para interceptar os caminhos internos de alocação de memória do libcurl e fluxos baseados em OpenSSL. Buffers de transporte sensíveis são limpos ao sair do tempo de vida gerenciado pelo BurnerNet. Essa higiene é verificada tanto no Windows quanto no Linux nas configurações auditadas descritas na documentação.
• Limpeza de Stack-Frame: Após cada requisição, a biblioteca limpa proativamente sua própria pilha de threads (limpeza High-Water Mark). Isso visa destruir fragmentos efêmeros de transporte antes que o controle retorne ao seu aplicativo.
• Heap em Movimento: A combinação de transportes descartáveis e cabeçalhos de metadados alinhados cria alta dispersão no espaço de endereçamento, tornando a memória do processo imprevisível e resistente a mapeamento estável de ponteiros.
• Estado de requisição de curta duração: BurnerNet é projetado em torno de clientes descartáveis, em vez de transportes singleton de todo o processo.
• Menos confiança no host: Suporte a DoH, suporte a chaves fixadas e auditoria de transporte ajudam a reduzir a dependência de padrões locais comprometidos.
• Menor exposição de texto simples: Callbacks de provedor e utilitários de limpeza segura reduzem o tempo de vida de certificados, chaves, tokens e outros buffers sensíveis.
• Verificação de propriedade do aplicativo: A verificação de resposta permanece em seu código através de WithResponseVerifier(...) em vez de ser hardcoded em uma biblioteca compartilhada.
• Impressão digital estática mais difícil: builds endurecidos podem definir BURNERNET_DIAGNOSTIC_STRINGS=0 para que ErrorCodeToString(...) retorne valores estáveis E<número> sem incorporar nomes de erro simbólicos.
• Opções de implantação com importação leve: BURNERNET_HARDEN_IMPORTS=1 pode resolver dependências de runtime dinamicamente em vez de anunciá-las diretamente na tabela de importações, usando o caminho KernelResolver do BurnerNet no Windows.
• Isolamento de Pilha de Chamadas (Async Handoff): Quando ativado via .WithStackIsolation(true), a biblioteca executa o ciclo de vida do transporte em uma thread de trabalho destacada. Isso pode romper fisicamente a pilha de chamadas do chamador e reduzir o rastreamento top-down direto da lógica do aplicativo.

Furtividade Verificada

BurnerNet não apenas alega um modo endurecido com importação leve; também inclui notas de auditoria para configurações testadas específicas. Em uma auditoria Windows x64 Release com BURNERNET_HARDEN_IMPORTS=ON:

• Apagão IAT: Nenhuma entrada para libcurl.dll, ws2_32.dll, bcrypt.dll ou crypt32.dll foi observada no binário auditado.
• Apagão de Memória: Varreduras forenses (Cheat Engine "All Strings") falharam em descobrir URLs ou cabeçalhos canários sensíveis no heap ou stack do processo.
• Cegueira do Depurador: Testes integrados verificam que a biblioteca desencadeia uma "Mudança de Identidade". O Tomador de Decisão (seu aplicativo) e o Transportador (BurnerNet) operam em IDs de Thread distintas, reduzindo o rastreamento top-down durante sessões de depuração ao vivo.
• Ruído para Sinal: A biblioteca visa higiene forense dentro de sua autoridade de limpeza, reconhecendo as "sombras" remanescentes no sistema operacional e ambiente de runtime.

Detalhes e metodologia da auditoria:

• docs/BINARY_STEALTH_AUDIT.md

Introdução

Caminho mais rápido:

• Adicione BurnerNet ao seu build com CMake ou Visual Studio source-drop.
• Inclua <burner/net.h>.
• Crie um cliente de stack, envie uma requisição e deixe-o sair do escopo.

Exemplo mínimo:

#include <iostream>

#include <burner/net.h>

int main() {
    burner::net::Client client;
    if (!client.IsReady()) {
        std::cerr << burner::net::ErrorCodeToString(client.InitError()) << '\n';
        return 1;
    }

    const auto response = client
        .Get("https://example.com")
        .WithHeader("Accept", "text/html")
        .WithTimeoutSeconds(10)
        .Send();

    if (!response.TransportOk()) {
        std::cerr << burner::net::ErrorCodeToString(response.transport_error) << '\n';
        return 1;
    }

    std::cout << "HTTP " << response.status_code << '\n';
    return 0;
}

Client usa padrões Standard: CA do sistema, DNS e proxy com verificação de peer TLS e hostname ativada. WithCasualDefaults() permanece disponível como um alias de compatibilidade Standard.

Para tráfego crítico de segurança, use o perfil Hardened. Build() rejeita controles ausentes antes de qualquer requisição:

auto secure = burner::net::ClientBuilder(burner::net::ClientProfile::Hardened)
    .WithMtlsProvider(ProvideMtlsCredentials)
    .WithSecurityPolicy(AppSecurityPolicy{})
    .WithDnsFallback(burner::net::DnsMode::Doh,
                     "https://resolver.example/dns-query",
                     "Primary DoH")
    .AllowSystemDns(true) // fallback explícito, após DoH
    .WithResponseVerifier(VerifySignedResponse)
    .Build();

Hardened exige verificação de peer e hostname, isolamento de stack, roteamento DoH primeiro, um verificador de resposta do aplicativo e um ponto de montagem de confiança de propriedade do aplicativo. Credenciais WithMtls(...) persistentes são rejeitadas; use WithMtlsProvider(...).

Caminhos de Integração

1. CMake Padrão

Use quando seu projeto downstream já usa CMake e você deseja o caminho mais limpo com gerenciamento de dependências.

Documentação:

• docs/CMAKE_INTEGRATION.md
• examples/cmake-consumer/README.md

2. Visual Studio Source-Drop

Use quando seu ambiente é MSBuild-first ou você deseja compilar BurnerNet diretamente dentro do seu .vcxproj.

Documentação:

• docs/VISUAL_STUDIO_INTEGRATION.md
• examples/vs-consumer/README.md

3. Importações de Runtime Endurecidas

Use quando você deseja reduzir a exposição óbvia de dependências de runtime e está preparado para gerenciar o carregamento de bootstrap explicitamente.

Ative:

• BURNERNET_HARDEN_IMPORTS=1
• Usa o caminho KernelResolver do BurnerNet no Windows para suportar uma pegada de runtime com menos importações

Referência:

• docs/USAGE_BEST_PRACTICES.md
• docs/CMAKE_INTEGRATION.md
• docs/VISUAL_STUDIO_INTEGRATION.md

Suporte a Linux: BurnerNet fornece paridade forense completa (Limpeza de Memória e Isolamento de Stack) no Linux. Veja docs/LINUX_USAGE.md para instruções de build.

Notas de Uso

Padrões recomendados:

• trate clientes como transportes descartáveis
• separe tráfego de alta confiança e de menor confiança em clientes diferentes
• use callbacks de provedor para material mTLS, tokens de portador e segredos de verificação de resposta
• mantenha regras de negócio e âncoras de confiança em seu aplicativo

Exemplos e Documentação

Exemplos:

• examples/01_basic_usage.cpp
• examples/02_zero_trust_pipeline.cpp
• examples/03_custom_security_policy.cpp
• examples/04_bootstrap_runtime.cpp
• examples/05_mtls_usage.cpp
• examples/06_hmac_custom_verifier.cpp

Documentação:

• PRINCIPLES.md
• docs/USAGE_BEST_PRACTICES.md
• docs/CMAKE_INTEGRATION.md
• docs/VISUAL_STUDIO_INTEGRATION.md
• docs/LINUX_USAGE.md

Requisitos

• C++20
• Windows x64/x86 ou Linux (GCC 13+ / Clang 15+)
• cabeçalhos libcurl 7.87.0+ e OpenSSL
• Guia Linux: Veja docs/LINUX_USAGE.md

Realidade de Segurança e a Defesa de Caixa Branca

BurnerNet é uma camada de endurecimento projetada para elevar o custo de um ataque a um nível profissional. Operamos sob o princípio de que a furtividade deve ser arquitetural, não apenas superficial.

Um atacante pode contornar BurnerNet se tiver o código-fonte? O conhecimento do código-fonte do BurnerNet não é, por si só, uma chave mestra para todo aplicativo downstream. BurnerNet segue o Princípio de Kerckhoffs: a biblioteca é projetada para que suas âncoras de confiança específicas do aplicativo (segredos HMAC, chaves fixadas, lógica de UI, hooks de política) permaneçam de propriedade do aplicativo. Conhecer a camada de transporte não produz automaticamente uma bypass universal do seu fluxo de segurança específico.

• Furtividade como Atraso: O endurecimento força atacantes a saírem de ferramentas padrão convenientes e entrarem em análise tediosa em nível de instrução.
• Dados como a Raiz: Use Dependência Funcional (Princípio 6) para garantir que seu aplicativo esteja literalmente quebrado sem dados fornecidos pelo servidor.
• A Vantagem Fantasma: Quando um atacante encontra sua lógica de requisição, o Isolamento de Stack e a Limpeza de Memória já destruíram as evidências forenses de que precisam.