burner-net

# 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](https://github.com/Krixx1337/ripstop-codec) para desembaralhamento de ativos em memória.

[Princípios](https://github.com/krixx1337/burner-net/blob/main/PRINCIPLES.md) • [Introdução](#getting-started) • [Caminhos de Integração](#integration-paths) • [Realidade de Segurança](#security-reality--the-white-box-defense)

## De relance

| Área | BurnerNet |
| :--- | :--- |
| **Idioma** | C++20 |
| **Plataforma** | Windows x64/x86 (**Primeira Classe**), Linux (Verificado) |
| **Transporte** | HTTP(S) baseado em `libcurl` |
| **Higiene de memória** | Utilitários de limpeza segura e alocadores de limpeza |
| **Higiene forense** | Limpeza automatizada de heap/stack em todo o estado de transporte gerenciado pelo BurnerNet |
| **Análise Dinâmica** | O isolamento da pilha de chamadas pode romper o vínculo entre consumidor e transporte |
| **Endurecimento de build** | Remoção opcional de strings de diagnóstico, literais ofuscados, metadados reduzidos do runtime C++ em builds endurecidos |
| **Endurecimento de runtime** | Suporte a DoH, segredos baseados em provedores e controles de confiança mais rígidos |
| **Integração** | CMake ou Visual Studio source-drop |

## 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

| Preocupação | Stack HTTP típico | BurnerNet |
| :--- | :--- | :--- |
| **Tempo de vida do cliente** | Frequentemente compartilhado e de longa duração | Projetado para clientes descartáveis e escopo de rajada |
| **Valores sensíveis** | Segredos geralmente permanecem em configuração ou memória por mais tempo que o necessário | Callbacks de provedor os obtêm próximo ao uso |
| **DNS e confiança** | Geralmente herda o resolvedor local e os padrões do host | Suporta controles de confiança mais rigorosos, incluindo fallback DoH e chaves fixadas |
| **Verificação** | Verificações de integridade específicas do aplicativo são frequentemente adicionadas depois | Construído para trabalhar com hooks de verificação de pré-voo, transporte e resposta |

## 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](https://github.com/krixx1337/burner-net/blob/main/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:

```cpp
#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:

```cpp
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](https://github.com/krixx1337/burner-net/blob/main/docs/CMAKE_INTEGRATION.md)
- [examples/cmake-consumer/README.md](https://github.com/krixx1337/burner-net/blob/main/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](https://github.com/krixx1337/burner-net/blob/main/docs/VISUAL_STUDIO_INTEGRATION.md)
- [examples/vs-consumer/README.md](https://github.com/krixx1337/burner-net/blob/main/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](https://github.com/krixx1337/burner-net/blob/main/docs/USAGE_BEST_PRACTICES.md)
- [docs/CMAKE_INTEGRATION.md](https://github.com/krixx1337/burner-net/blob/main/docs/CMAKE_INTEGRATION.md)
- [docs/VISUAL_STUDIO_INTEGRATION.md](https://github.com/krixx1337/burner-net/blob/main/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](https://github.com/krixx1337/burner-net/blob/main/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](https://github.com/krixx1337/burner-net/blob/main/examples/01_basic_usage.cpp)
- [examples/02_zero_trust_pipeline.cpp](https://github.com/krixx1337/burner-net/blob/main/examples/02_zero_trust_pipeline.cpp)
- [examples/03_custom_security_policy.cpp](https://github.com/krixx1337/burner-net/blob/main/examples/03_custom_security_policy.cpp)
- [examples/04_bootstrap_runtime.cpp](https://github.com/krixx1337/burner-net/blob/main/examples/04_bootstrap_runtime.cpp)
- [examples/05_mtls_usage.cpp](https://github.com/krixx1337/burner-net/blob/main/examples/05_mtls_usage.cpp)
- [examples/06_hmac_custom_verifier.cpp](https://github.com/krixx1337/burner-net/blob/main/examples/06_hmac_custom_verifier.cpp)

Documentação:
- [PRINCIPLES.md](https://github.com/krixx1337/burner-net/blob/main/PRINCIPLES.md)
- [docs/USAGE_BEST_PRACTICES.md](https://github.com/krixx1337/burner-net/blob/main/docs/USAGE_BEST_PRACTICES.md)
- [docs/CMAKE_INTEGRATION.md](https://github.com/krixx1337/burner-net/blob/main/docs/CMAKE_INTEGRATION.md)
- [docs/VISUAL_STUDIO_INTEGRATION.md](https://github.com/krixx1337/burner-net/blob/main/docs/VISUAL_STUDIO_INTEGRATION.md)
- [docs/LINUX_USAGE.md](https://github.com/krixx1337/burner-net/blob/main/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](https://github.com/krixx1337/burner-net/blob/main/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.