BurnerNet

Cliente HTTP antirforense y de confianza cero. Borra secretos. Corta rastros. RCP en un tanque sigiloso. 👻

BurnerNet es un cliente HTTP antirforense en C++20. Proporciona una API fluida, similar a CPR, para aplicaciones que no pueden confiar plenamente en la máquina local: borra físicamente los secretos de la RAM y corta los rastros de ejecución para ocultar tu lógica de escáneres y depuradores.

Ofrece valores predeterminados familiares compatibles con el host para HTTP ordinario y un perfil Hardened explícito para entornos hostiles. Ambos caminos favorecen clientes de corta duración; la confianza avanzada sigue siendo propiedad de la aplicación.

¿Buscas proteger las cargas descargadas por BurnerNet? Prueba RipStop Codec para desencriptar activos en memoria.

Principios • Primeros Pasos • Rutas de Integración • Realidad de Seguridad

De un Vistazo

Por Qué Usarlo

Usa BurnerNet cuando un cliente HTTP normal sea demasiado confiado para tu entorno.

Ayuda cuando quieres:

• mantener clientes de solicitud de corta duración en lugar de compartir un transporte global
• reducir la dependencia del DNS local y otros valores predeterminados del host
• obtener tokens, certificados y secretos de verificación solo cuando sea necesario
• mantener la lógica de verificación de respuestas en tu propio código de aplicación
• reducir cadenas de texto plano evidentes y metadatos en compilaciones endurecidas

Para Quién Es

BurnerNet se adapta a proyectos como:

• aplicaciones de escritorio Windows con autenticación de alto valor, licencias o solicitudes de actualización
• código incrustado o inyectado que se ejecuta en un host en el que no confías plenamente
• herramientas que desean controles de transporte más estrictos sin renunciar a una API C++ fluida

Pila Estándar vs BurnerNet

Resultados Defensivos

• Arquitectura de Memoria Cero-Fantasma: BurnerNet utiliza un Prefijo-Tamaño Scrubber personalizado para enganchar las rutas internas de asignación de memoria de los flujos libcurl y con respaldo OpenSSL. Los buffers de transporte sensibles se borran cuando salen de la vida gestionada por BurnerNet. Esta higiene se verifica tanto en Windows como en Linux dentro de las configuraciones auditadas descritas en la documentación.
• Barrido de Marcos de Pila: Después de cada solicitud, la biblioteca limpia proactivamente su propia pila de hilos (limpieza de marca de agua alta). Esto está destinado a destruir fragmentos de transporte efímeros antes de que el control regrese a tu aplicación.
• Heap de Objetivo Móvil: La combinación de transportes desechables y encabezados de metadatos alineados crea una alta dispersión del espacio de direcciones, haciendo que la memoria del proceso sea impredecible y resistente al mapeo estable de punteros.
• Estado de solicitud de corta duración: BurnerNet está diseñado en torno a clientes desechables en lugar de transportes singleton a nivel de proceso.
• Menos confianza en el host: El soporte DoH, el soporte de clave fijada y la auditoría de transporte ayudan a reducir la dependencia de valores predeterminados locales comprometidos.
• Menor exposición de texto plano: Las devoluciones de llamada del proveedor y las utilidades de borrado seguro reducen la vida útil de certificados, claves, tokens y otros buffers sensibles.
• Verificación propiedad de la aplicación: La verificación de respuestas permanece en tu código a través de WithResponseVerifier(...) en lugar de estar codificada en una biblioteca compartida.
• Huella estática más difícil: las compilaciones endurecidas pueden establecer BURNERNET_DIAGNOSTIC_STRINGS=0 para que ErrorCodeToString(...) devuelva valores estables E<número> sin incrustar nombres de error simbólicos.
• Opciones de implementación ligeras en importaciones: BURNERNET_HARDEN_IMPORTS=1 puede resolver dependencias de tiempo de ejecución dinámicamente en lugar de anunciarlas directamente en la tabla de importación, utilizando la ruta KernelResolver de BurnerNet en Windows.
• Aislamiento de Pila de Llamadas (Transferencia Asíncrona): Cuando se habilita mediante .WithStackIsolation(true), la biblioteca ejecuta el ciclo de vida del transporte en un hilo de trabajo separado. Esto puede cortar físicamente la pila de llamadas del llamante y reducir el rastreo directo de arriba a abajo de la lógica de la aplicación.

Sigilo Verificado

BurnerNet no solo afirma tener un modo endurecido ligero en importaciones; también incluye notas de auditoría para configuraciones probadas específicas. En una auditoría de Windows x64 Release con BURNERNET_HARDEN_IMPORTS=ON:

• Apagón IAT: No se observaron entradas para libcurl.dll, ws2_32.dll, bcrypt.dll o crypt32.dll en el binario auditado.
• Oscurecimiento de memoria: Los escaneos forenses (Cheat Engine "All Strings") no lograron descubrir URLs canarias sensibles ni encabezados en el heap o stack del proceso.
• Ceguera del Depurador: Las pruebas integradas verifican que la biblioteca desencadena un "Cambio de Identidad". El Tomador de Decisiones (tu app) y el Transportador (BurnerNet) operan en IDs de Hilo distintos, reduciendo el rastreo de arriba a abajo durante sesiones de depuración en vivo.
• Ruido a Señal: La biblioteca apunta a la higiene forense dentro de su autoridad de borrado, reconociendo "sombras" restantes a nivel de sistema en el SO y el entorno de ejecución.

Detalles y metodología de auditoría:

• docs/BINARY_STEALTH_AUDIT.md

Primeros Pasos

Ruta más rápida:

• Añade BurnerNet a tu compilación con CMake o volcado de fuente de Visual Studio.
• Incluye <burner/net.h>.
• Crea un cliente de pila, envía una solicitud, luego déjalo salir del ámbito.

Ejemplo 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 valores predeterminados Estándar: CA del sistema, DNS y proxy con verificación de par TLS y nombre de host habilitada. WithCasualDefaults() sigue disponible como un alias de compatibilidad Estándar.

Para tráfico crítico de seguridad, usa el perfil Hardened. Build() rechaza controles faltantes antes de cualquier solicitud:

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) // explicit fallback, after DoH
    .WithResponseVerifier(VerifySignedResponse)
    .Build();

Hardened requiere verificación de par y nombre de host, aislamiento de pila, enrutamiento primero DoH, un verificador de respuestas de la aplicación y un montaje de confianza propiedad de la aplicación. Las credenciales persistentes WithMtls(...) son rechazadas; usa WithMtlsProvider(...).

Rutas de Integración

1. CMake Estándar

Úsalo cuando tu proyecto descendente ya usa CMake y quieres la ruta más limpia gestionada por dependencias.

Documentación:

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

2. Volcado de Fuente de Visual Studio

Úsalo cuando tu entorno sea principalmente MSBuild o quieras que BurnerNet se compile directamente dentro de tu .vcxproj.

Documentación:

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

3. Importaciones Endurecidas en Tiempo de Ejecución

Úsalo cuando quieras reducir la exposición obvia de dependencias en tiempo de ejecución y estés preparado para gestionar la carga de arranque explícitamente.

Habilitar:

• BURNERNET_HARDEN_IMPORTS=1
• Usa la ruta KernelResolver de BurnerNet en Windows para soportar una huella de tiempo de ejecución más ligera en importaciones.

Referencia:

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

Soporte Linux: BurnerNet proporciona paridad forense completa (Borrado de Memoria y Aislamiento de Pila) en Linux. Consulta docs/LINUX_USAGE.md para instrucciones de compilación.

Notas de Uso

Valores predeterminados recomendados:

• tratar a los clientes como transportes desechables
• separar el tráfico de alta confianza y baja confianza en diferentes clientes
• usar devoluciones de llamada de proveedor para material mTLS, tokens de portador y secretos de verificación de respuestas
• mantener las reglas de negocio y anclajes de confianza en tu aplicación

Ejemplos y Documentación

Ejemplos:

• 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

Documentación:

• 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 o Linux (GCC 13+ / Clang 15+)
• libcurl 7.87.0+ y encabezados OpenSSL
• Guía Linux: Consulta docs/LINUX_USAGE.md

Realidad de Seguridad y la Defensa de Caja Blanca

BurnerNet es una capa de endurecimiento diseñada para elevar el costo del ataque a un nivel profesional. Operamos bajo el principio de que el sigilo debe ser arquitectónico, no solo superficial.

¿Puede un atacante eludir BurnerNet si tiene el código fuente?

El conocimiento del código fuente de BurnerNet no es, por sí mismo, una llave maestra para todas las aplicaciones descendentes. BurnerNet sigue el Principio de Kerckhoffs: la biblioteca está diseñada para que tus anclajes de confianza específicos de la aplicación (secretos HMAC, claves fijadas, lógica de UI, hooks de política) sigan siendo propiedad de la aplicación. Conocer la capa de transporte no produce automáticamente una elusión universal de tu flujo de seguridad específico.

• Sigilo como Retraso: El endurecimiento obliga a los atacantes a salir de las herramientas de conveniencia estándar y entrar en un tedioso análisis a nivel de instrucción.
• Datos como Raíz: Usa Dependencia Funcional (Principio 6) para asegurar que tu aplicación está literalmente rota sin los datos proporcionados por el servidor.
• La Ventaja Fantasma: Para cuando un atacante encuentra tu lógica de solicitud, el Aislamiento de Pila y el Borrado de Memoria ya han destruido la evidencia forense que necesitan.