v0.1.0 (C++20 / Native JSI)

Seguridad Zero-Trust para React Native

Librería criptográfica de grado empresarial compilada nativamente. Firmas DPoP asimétricas y limpieza de memoria estricta (Zeroization) operando por debajo del motor V8/Hermes mediante JSI Bridge.

Integración Nativa Segura

A diferencia de otras librerías NPM que mantienen material criptográfico expuesto en la memoria del recolector de basura de JS, Ghost Ledger SDK opera un motor C++ nativo que destruye el material mediante SecureZeroMemory inmediatamente después de firmar la transacción.

  • Firmas Ed25519 y RSA-2048
  • Telemetría de Integridad de Ledger
  • Comunicación síncrona vía React Native Nitro / JSI
cpp/VolatileQueue.hpp
// Secure hardware wipe (Zeroization)
void VolatileQueue::activeZeroization() {
    std::lock_guard<std::mutex> lock(mutex_);
    
    #ifdef _WIN32
    SecureZeroMemory(arena_, size_);
    #else
    explicit_bzero(arena_, size_);
    #endif
    
    telemetryEngine.recordEvent(
        TelemetryEventType::ZEROIZATION_TRIGGERED, 
        0x00
    );
}

Arquitectura de Seguridad Core

Basado en 6 pilares fundamentales para proteger la integridad de las transacciones bajo un entorno de memoria volátil y hostil.

Volatile RAM Ledger

Las peticiones son serializadas a binario y encoladas en un ledger estático C++ en memoria física. Cada bloque se enlaza criptográficamente con SHA-256.

Deterministic Zeroization

Borrado activo mediante std::fill y SecureZeroMemory inmediatamente después del despacho o expiración del TTL para evitar fugas al Heap JS.

Integrity Watchdog

Motor en background que detecta manipulación dinámica (inyección o corrupción de memoria). Congela la ejecución y preserva evidencia.

Dynamic DPoP Proofs

Generación y firma efímera de Pruebas de Posesión (DPoP - RFC 9449) usando WebCrypto para no sobrecargar el core C++.

Transport Agnostic

Desacoplado de la red vía el patrón Command. Adaptadores nativos para Fetch, Axios o GraphQL incluidos.

Pure JS Mock Mode

Soporte nativo para fallback engine sin JSI. Ideal para pipelines de CI/CD, web y testing de componentes sin hardware real.

Flujo Operativo In-Memory

El ciclo de vida en tiempo de ejecución de una petición segura sigue un flujo estricto para garantizar la resiliencia criptográfica:

  1. La aplicación (App) invoca executeRequest() en el GhostClientCore.
  2. Se verifica la integridad de la memoria. Si el Ledger ha sido comprometido (ej. inyección de código o memory dump), se lanza inmediatamente un IntegrityBreachError.
  3. Si el entorno es seguro, se comprueba la conexión a red:
    • Online: Se adjunta la prueba DPoP efímera y se despacha la petición al NetworkAdapter. Al recibir éxito, se ejecuta el borrado seguro en hardware (SecureZeroMemory) sobre los buffers para no dejar rastros en memoria, y se retorna la respuesta.
    • Offline o HTTP 503: La petición se encola en el ledger volátil (MemoryQueue). El núcleo C++ enlaza criptográficamente el payload mediante un encadenamiento SHA-256 (hash Hn) e inicia un zeroize de variables temporales, retornando una Promesa pendiente a la aplicación que se resolverá automáticamente en la reconexión.

Ejemplos de Uso Conceptuales

Inyección de Dependencias (CryptoProvider)

Para mantener la librería agnóstica a la arquitectura específica de React Native (Expo vs Bare), requerimos inyectar un proveedor criptográfico. Todos los ejemplos asumen que has inyectado react-native-quick-crypto en la propiedad cryptoProvider para máxima velocidad C++.

1. Setup Básico (Queue & Replay)
import { GhostClientCore, FetchAdapter } from '@vesper-core/ghost-ledger';
import NetInfo from '@react-native-community/netinfo';

const client = GhostClientCore.getInstance({
  cryptoProvider: myQuickCryptoProvider,
  networkResolver: async () => (await NetInfo.fetch()).isConnected ?? false,
  networkAdapter: new FetchAdapter(),
  defaultTTL: 60000
});

// Trapped in C++ RAM if network drops
const res = client.executeRequest('tx_101', {
  method: 'POST', url: '/v1/ledger', body: myPayload
});

// Synchronous replay after reconnection
await client.processSynchronizedQueue(async () => true);
2. Integración con Axios
import { GhostClientCore, AxiosAdapter } from '@vesper-core/ghost-ledger';
import axios from 'axios';
import NetInfo from '@react-native-community/netinfo';

const client = GhostClientCore.getInstance({
  cryptoProvider: myQuickCryptoProvider,
  networkResolver: async () => (await NetInfo.fetch()).isConnected ?? false,
  networkAdapter: new AxiosAdapter({ axiosInstance: axios.create() }),
  errorTrapping: { freezeOn503_504: true }
});

client.executeRequest('tx_102', { 
  method: 'POST', 
  url: '/api/ledger/degraded', 
  body: myPayload 
});
3. Integración con Fetch
import { GhostClientCore, FetchAdapter } from '@vesper-core/ghost-ledger';
import NetInfo from '@react-native-community/netinfo';

const client = GhostClientCore.getInstance({
  cryptoProvider: myQuickCryptoProvider,
  networkResolver: async () => (await NetInfo.fetch()).isConnected ?? false,
  networkAdapter: new FetchAdapter()
});

client.executeRequest('tx_103', { 
  method: 'GET', 
  url: 'https://api.yourdomain.com/v1/data' 
});
4. Integración con GraphQL
import { GhostClientCore, GraphQLAdapter } from '@vesper-core/ghost-ledger';
import NetInfo from '@react-native-community/netinfo';

const client = GhostClientCore.getInstance({
  cryptoProvider: myQuickCryptoProvider,
  networkResolver: async () => (await NetInfo.fetch()).isConnected ?? false,
  networkAdapter: new GraphQLAdapter({ 
    endpoint: 'https://api.yourdomain.com/graphql' 
  })
});

client.executeRequest('tx_104', {
  method: 'POST',
  url: '',
  body: new TextEncoder().encode(JSON.stringify({ 
    query: 'mutation { createTx(amount: 1500) }' 
  }))
});

Integración Rápida (React Native)

Protege los datos sensibles de tu app cuando falla la red. @vesper-core/ghost-ledger requiere Nitro Modules para ejecutar C++ de alto rendimiento.

App.tsx
import { GhostClientCore, FetchAdapter, encodeJsonBody } from '@vesper-core/ghost-ledger';
import QuickCrypto from 'react-native-quick-crypto';
import NetInfo from '@react-native-community/netinfo';

// 1. Initialize Core connecting to Nitro Modules
const client = GhostClientCore.getInstance({
  cryptoProvider: {
    getRandomBytes: (n) => QuickCrypto.randomBytes(n),
    sha256: async (d) => new Uint8Array(QuickCrypto.createHash('sha256').update(d).digest())
  },
  networkResolver: async () => (await NetInfo.fetch()).isConnected ?? false,
  networkAdapter: new FetchAdapter(),
  // Enable Telemetry (Optional)
  telemetry: {
    apiKey: 'YOUR_API_KEY',
    bundleId: 'com.your.app',
    endpoint: 'https://vesper-ingestion.onrender.com/api/v1/support/telemetry'
  }
});

// 2. Execute Requests safely (Payload hash-chained if network fails)
const response = await client.executeRequest('tx_123', {
  method: 'POST',
  url: 'https://api.yourdomain.com/v1/secure-endpoint',
  body: encodeJsonBody({ amount: 1500, currency: 'USD' })
});