Serviços expostos x linguagens seguras

Serviços expostos x linguagens seguras

Há algum tempo comecei um pequeno projeto com a ajuda do Claude: um forwarder MQTT com links redundantes. Não prossegui com ele, mas uma coisa me chamou a atenção logo de saída. Ao discutir a implementação, a IA perguntou: "Go ou Rust?". C e C++ nem entraram na conversa.

Pareceu por um momento que o Claude leu minha mente! Foram justamente as linguagens que eu cogitei, mas na verdade já tinha forte preferência por Go, que conheço melhor, é muito mais ergonômica, e tem velocidade mais que suficiente para a tarefa.

Se até a IA "sabe" que um serviço exposto à Internet não deveria ser escrito em C, por que os humanos ainda insistem? Minha opinião é que todo serviço exposto à rede deveria estar sendo escrito em linguagem segura, de preferência de alto nível, há pelo menos uma década. Não interessa se é mais lenta.

A IA não sabe nada que nós não saibamos

Na verdade, a IA não descobriu nada. Ela apenas reflete o consenso que já está escrito por aí. Os números são públicos há anos: cerca de 70% das vulnerabilidades graves encontradas no Chromium e nos produtos Microsoft são de segurança de memória: buffer overflow, use-after-free, double free etc. NSA, CISA e até a Casa Branca publicaram recomendações nesse sentido entre 2022 e 2024.

Ou seja, o problema não é falta de conhecimento. É de custo e de incentivo.

Por que C e C++ continuam aí

Legado. OpenSSL, nginx, BIND, o kernel, o firmware do seu roteador. Tudo isso existe, funciona, e foi "auditado pelo tempo". Reescrever custa caro e introduz bugs novos. Ninguém é promovido por reescrever algo que já funciona.

Embarcados. Num microcontrolador com dezenas de kilobytes de RAM, as opções reais são C ou Rust embarcado, que ainda está amadurecendo. E muito do que está exposto à Internet roda justamente nesse tipo de hardware.

Incentivos. A falha de segurança é uma externalidade: quem paga pela invasão é o cliente, não o fornecedor. Isso só começa a mudar com regulação, como o Cyber Resilience Act europeu.

Cultura. O mito do desempenho e a otimização prematura. Todo mundo quer tirar o máximo do hardware, o que é compreensível, mas temerário quando se trata de serviços expostos à Internet. A depender da criticalidade do serviço, é preferível que seja 1000 vezes mais lento, porém resistente a ataques presentes e futuros.

Segurança de memória não é tudo

É justo reconhecer: o Log4Shell aconteceu em Java. SQL injection, falhas de autenticação e ataques à cadeia de suprimentos (como o backdoor do xz) não dependem da linguagem. Uma linguagem segura elimina uma classe de bugs, não todos. Acontece que essa classe é a maior delas, e a mais fácil de evitar.

E a migração funciona mesmo sem reescrever tudo. No Android, a fração de vulnerabilidades de memória caiu de 76% em 2019 para 24% em 2024, principalmente porque o código novo passou a ser escrito em Rust e Kotlin. O código antigo em C++ continuou lá. Parece uma estratégia realista: código novo exposto à rede, só em linguagem segura.

Dogfooding: linguagens deveriam implementar a si mesmas

Aqui entra uma crítica às próprias linguagens "seguras". Um serviço em Python passa, por baixo, por OpenSSL, zlib, libxml2 e libc. A linguagem segura no topo reduz a superfície de ataque, mas não a elimina. Muitas linguagens de alto nível são, na prática, uma cola para bibliotecas C. Isso é inclusive parte do sucesso do Python (numpy, cryptography, lxml).

Os bons exemplos existem. O Go tem TLS escrito em Go puro, sem OpenSSL; no Linux faz syscalls diretamente, sem passar pela libc; e o próprio compilador é escrito em Go. Um binário Go exposto à rede tem pouquíssimo C embaixo dele. Java tem TLS próprio, e Rust tem o rustls.

Não dá para chegar a zero. Primitivas criptográficas precisam rodar em tempo constante, o que é difícil de garantir com GC e JIT, então até o Go usa assembly em alguns pontos. E sempre haverá alguma fronteira com o sistema operacional. Mas o objetivo deveria ser um núcleo inseguro pequeno, isolado e auditável, não uma fundação inteira de C. Rust deixa isso explícito com a palavra-chave unsafe: dá para dar um grep e auditar cada ocorrência. Já um wrapper sobre uma biblioteca C de meio milhão de linhas herda toda a superfície de ataque dela.

Paradigma: imutabilidade e processos isolados

Não sou praticante de Elixir/Erlang, aprendi a teoria, mas ela não me empolgou o suficiente para largar de Python e Go em meus projetos pessoais. O ponto é que há ideias ali que outras linguagens deveriam copiar. Imutabilidade por padrão, e principalmente os processos leves isolados, cada um com seu próprio heap e GC.

Chego mesmo a pensar que se deveria ressuscitar técnicas paleolíticas como inetd e criar subprocessos para atender requisições de rede. Subprocessos do sistema operacional mesmo. É lento, mas garante um nível de isolamento bem alto. É uma forma "burra" de recriar o que o Erlang oferece, mas limita o raio de qualquer estrago.

O Go copiou a leveza, mas não o isolamento: entre goroutines, a memória é compartilhada. O mantra "não comunique compartilhando memória" é só uma convenção. Ao menos é uma convenção ergonômica e realmente posta em uso.