1. O Incidente: O Gargalo e a Queda na Assinatura de Documentos

Imagine uma longa fila de pessoas esperando atendimento em um balcão, mas o atendente resolve parar tudo para fazer cálculos matemáticos extremamente complexos no papel no meio do expediente. A fila de requisições trava por completo. Esse foi o efeito do gargalo de processamento síncrono no Event Loop do Node.js.

Métricas do Incidente:

• Tempo de resposta do serviço: Saltou de 40ms para mais de 12.000ms sob estresse.
• Throughput da API: Queda de 95% na vazão de contratos processados.
• Escala do Dano: Mais de 15.000 contratos de crédito consignado travados na fila de assinatura.
• Perda Operacional: R$ 380 mil em multas de parceiros e custos de reprocessamento noturno de filas.

O fluxo original da fintech delegava a verificação de hash e assinatura criptográfica de PDFs a uma biblioteca legada em C++ vinculada via Node-addon bruto. O código continha furos graves do tipo Buffer Overflow e Use-After-Free (Módulo 02) ao lidar com buffers malformados na CPU. Reescrever uma base de código de 1,2 milhão de linhas de Java e Node.js em Rust do dia para a noite era financeiramente inviável. A solução pragmática foi a migração cirúrgica progressiva: reescrever apenas o core criptográfico em Rust e acoplá-lo ao ecossistema existente.

2. A Ponte de Integração: Rust ↔ Legado

Para interagir com o legado de forma segura, o código Rust exporta funções que seguem a convenção de chamadas do C (ABI C) usando `extern "C"` e anulando a otimização de nomes (`#[no_mangle]`):

// Código do Core em Rust (lib.rs):
use std::slice;

#[no_mangle]
pub extern "C" fn verify_signature_rust(data_ptr: *const u8, len: usize) -> i32 {
    if data_ptr.is_null() {
        return -1; // Proteção explícita na fronteira nativa!
    }
    
    // Convertemos o ponteiro bruto em uma fatia imutável segura de Rust
    let data = unsafe { slice::from_raw_parts(data_ptr, len) };
    
    // O core processa sem riscos de estouro de pilha
    if verify_internal(data) { 1 } else { 0 }
}

A Chamada a partir do C++ Legado: O legado declara a assinatura e carrega o arquivo `.so`/`.dll` gerado pelo Rust:

// Código da Ponte em C++:
extern "C" {
    int verify_signature_rust(const unsigned char* data_ptr, size_t len);
}

void process_pdf(const unsigned char* pdf_data, size_t length) {
    // Rust é invocado de forma nativa e isolada
    int result = verify_signature_rust(pdf_data, length);
    if (result != 1) {
        throw std::runtime_error("Assinatura Inválida");
    }
}

Blindagem das Invariantes de Memória: O código legado C/C++ pode "vazar" instabilidade enviando ponteiros nulos ou comprimentos (`len`) corrompidos para o Rust. Para mitigar isso, o wrapper Rust valida todas as entradas nas bordas do bloco `unsafe`, sanitizando ponteiros antes de convertê-los em fatias gerenciadas. Isso impede que acessos fora de limites corrompam a Heap estável do módulo seguro.

3. A Arquitetura Hexagonal Híbrida (Ports & Adapters)

Para estruturar a transição progressiva, desenhamos fronteiras lógicas estritas. O núcleo de Rust atua como a lógica central inalterada, enquanto o legado é empurrado para a periferia como adaptadores:

[Fluxo da Arquitetura Hexagonal Híbrida]
Requisicão HTTP ➔ Node.js Adapter ➔ Port (FFI C ABI) ➔ Core em Rust (Verificação Segura)

Ao mover o processamento criptográfico complexo de forma assíncrona para Rust usando threads separadas, o Event Loop do Node.js volta a respirar livremente para atender novas conexões concorrentes.

Métricas de Impacto da Migração Progressiva:

4. Mitigação Prática: Passo a Passo do Isolamento

1. Isolar o Ponto de Entrada: Separe as funções críticas que realizam IO e processamento de arquivos perigosos do restante do aplicativo em portas de infraestrutura dedicadas.
2. Validação das Pontes com Fuzzing: Use ferramentas de teste dinâmico (Módulo 06) injetando bytes aleatórios e payloads corrompidos na ponte FFI para garantir que o módulo Rust aborte conexões inválidas sem crashar o host.
3. Preparação para Sandboxing (Módulo 07): Estruture o binário FFI Rust de forma que ele possa rodar confinado dentro de uma microVM Firecracker ou eBPF, isolando as interfaces nativas dos dados gerais do sistema operacional.

5. Objeções Técnicas e Conexões

• Objeção: "Pontes FFI são complexas e podem gerar novos bugs." (Resposta: O mapeamento estrito usando ferramentas como `napi-rs` ou o Project Panama do Módulo 04 reduz drasticamente a taxa de erros humanos, mantendo tipagem segura entre as linguagens).
• Conexão Curricular: O design hexagonal híbrido protege a aplicação de ataques cibernéticos contra código antigo (Módulo 01), elimina bugs no heap (Módulo 02) com as garantias nativas de segurança do Rust (Módulo 03), substituindo pontes JNI inseguras (Módulo 04). Esse pipeline é verificado por fuzzing direcionado (Módulo 06) e isolado via sandboxing físico no fechamento da tese (Módulo 07).

Revisão de Linha de Frente (Checklist do Módulo 05)

• [ ] Isole os Gargalos de CPU: Identifique rotinas de criptografia, compressão ou parsing que bloqueiam a thread de execução da API e mova-as para Rust.
• [ ] Utilize Wrapper de Assinatura C: Proteja as interfaces FFI com #[no_mangle] e valide ponteiros brutos contra referências nulas.
• [ ] Restrinja Blocos Unsafe no Rust: Use blocos unsafe exclusivamente para deserializar dados de FFI, mantendo as rotinas internas puras.

— Anterior: Lição de Apoio 04: Nivelamento de JVM Off-Heap e Project Panama | Próximo: Lição de Apoio 05: Nivelamento de Integração Híbrida e FFI | Índice da série: Chamada e Índice.