Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Overflow no EVP_EncodeBlock do OpenSSL: 5 Mitos Testados

O overflow no EVP_EncodeBlock do OpenSSL (CVSS 9.8) mostra como APIs de codificação base64 escapam à revisão de segurança. Cinco mitos, testados.

Um funil gigante despeja cubos brilhantes num pequeno copo transbordando.
EVP_EncodeBlock confia que quem chamou dimensionou o copo corretamente — ele nunca verifica.

Uma função que só transforma bytes em texto base64 acabou de receber uma pontuação CVSS de 9.8. O overflow de buffer no EVP_EncodeBlock do OpenSSL — catalogado como CVE-2026-121481 — é aquele tipo de bug que parece tedioso até você perceber que a codificação base64 está por baixo do tratamento de certificados, clientes HTTP, autenticação em proxies e metade do código de cola da sua infraestrutura. A correção em si levou quatro commits e uma discussão acalorada entre os mantenedores sobre como deveria ser, afinal, um retorno de erro.

A discussão em torno deste CVE é um presente para quem se importa com design de APIs, porque expõe uma pilha de suposições que engenheiros fazem sobre funções de codificação — suposições que continuam produzindo a mesma classe de bug ao longo de décadas e em várias bibliotecas. Vamos pegar cinco das crenças mais comuns e confrontá-las com o que realmente aconteceu.

Como o Buffer Overflow no EVP_EncodeBlock Realmente Funciona

A codificação base64 infla os dados: cada três bytes de entrada viram quatro caracteres de saída. Assim, o tamanho da saída é 4 * ((n + 2) / 3), mais um para o terminador NUL se você quiser uma string C. A EVP_EncodeBlock() do OpenSSL obriga o chamador a calcular esse tamanho e alocar o buffer de destino. A função recebe o ponteiro de entrada, o ponteiro de saída e o tamanho da entrada — como um int. Ela nunca fica sabendo quão grande é o buffer de saída, então não consegue validar nada. Ela simplesmente escreve.

Agora faça a conta. O maior int é 2.147.483.647. Quando o tamanho da entrada ultrapassa (INT_MAX / 4) * 3 — ou seja, 1.610.612.733 bytes, cerca de 1,6 GB — o cálculo interno do tamanho estoura um inteiro de 32 bits com sinal. A aritmética de tamanho dá a volta, a noção da função sobre onde a saída termina deixa de corresponder à realidade, e você tem escritas além do fim de qualquer buffer que o chamador alocou. O chamador, seguindo a fórmula documentada, fez a mesma conta estourando, então os dois lados podem discordar catastroficamente sobre quanto espaço existe.

A correção upstream adicionou uma guarda: rejeitar entradas em que dlen > (INT_MAX / 4) * 3, além de buffers NULL e tamanhos negativos. Se você encapsular esta API — e deveria encapsulá-la — a verificação também deve estar na sua fronteira:

#include <limits.h>
#include <stddef.h>
#include <openssl/evp.h>
/*
* Mirrors the upstream guard: refuse inputs whose encoded size
* cannot be represented in an int, and verify the destination
* capacity ourselves since the API never sees it.
*/
int b64_encode_checked(const unsigned char *in, size_t n,
unsigned char *out, size_t out_cap)
{
size_t need;
if (in == NULL || n > ((size_t)INT_MAX / 4) * 3)
return -1;
need = ((n + 2) / 3) * 4 + 1;   /* +1 for the NUL terminator */
if (out == NULL || out_cap < need)
return -1;
if (EVP_EncodeBlock(out, in, (int)n) < 0)
return -1;
return 0;
}

Repare no que essa API obriga você a fazer: reimplementar, no chamador, a fórmula interna de tamanho da biblioteca, corretamente, para sempre. Esse contrato é a verdadeira vulnerabilidade. O overflow é apenas o ponto em que o contrato finalmente quebrou.

Mito 1: “Decodificadores são a superfície de ataque, codificadores são chatos”

A cultura de revisão de segurança tem um viés forte: parsing é perigoso, serialização é contabilidade. Decodificadores consomem bytes hostis, então são fuzzados, auditados e reescritos em linguagens com segurança de memória. Codificadores produzem saída, e saída parece segura. Essa crença está errada de um jeito específico e repetível: bugs em codificadores vivem no cálculo do tamanho da saída, e essa conta é confiada pelos dois lados da chamada.

O padrão se repete. A thread do PR até observa que o CVE-2026-121481 se parece com o CVE-2021-23840, um overflow anterior do OpenSSL nas funções de update do EVP, em que um cálculo de tamanho estourava com entradas enormes. E base64 especificamente tem história aqui — quando o decodificador Base64 do OpenJDK transformou 65 bytes em execução remota de código, nós cobrimos como um codec “trivial” virou uma primitiva de RCE. Decodificadores ganham CVEs por aceitar entrada ruim; codificadores ganham CVEs por calcular errado entrada boa. São da mesma espécie: aritmética sobre tamanhos influenciados por atacantes.

Veredito: furado. Se o seu modelo de ameaças para no parser, você deixou a porta dos fundos aberta enquanto vigiava a da frente.

Mito 2: “CVSS 9.8 significa largar tudo esta noite”

Aqui vou defender um pouco os céticos. Um 9.8 em um codificador que precisa de uma entrada de 1,6 GB não é o Heartbleed. Não existe codificação base64 de dados em massa em lugar nenhum do handshake TLS — certificados trafegam como DER dentro do TLS, não como PEM. Para isso machucar você, dados não confiáveis precisam chegar a EVP_EncodeBlock() (ou a um chamador interno como base64encode() no cliente HTTP do OpenSSL) em uma escala acima de 1,6 GB. Um campo de protocolo com prefixo de tamanho de 16 bits nunca chega lá.

Mas “sintético” também subestima o caso. O relator demonstrou um caminho real de linha de comando: passar um valor enorme de -proxy_pass para o openssl s_client, fornecido por uma variável de ambiente para contornar os limites de argumentos do shell, e certas configurações — engines GOST aceitam senhas grandes por padrão — vão codificá-lo em base64 sem reclamar para uma requisição CONNECT de proxy. Isso não é uma curiosidade de laboratório; é uma ferramenta padrão fazendo autenticação de proxy padrão com uma variável de ambiente padrão.

Minha posição: trate o CVSS como medida da função, e o seu grafo de chamadas como medida da sua exposição. Antes de agendar uma janela de patch de emergência, faça grep no seu código e nas suas dependências para ver quem de fato codifica o quê e até que tamanho a entrada pode chegar. Depois aplique o patch mesmo assim — só que na ordem certa. Veredito: meia verdade. A pontuação é real, mas o pânico deve ser proporcional à alcançabilidade, e alcançabilidade é uma pergunta que só o seu código consegue responder.

Mito 3: “A correção é fácil — basta retornar um código de erro”

Esta é a minha parte favorita da história, porque o overflow foi a parte simples. A parte difícil foi decidir o que a EVP_EncodeBlock() deveria fazer a respeito — e os mantenedores não conseguiram chegar a um acordo.

O patch original retornava -1 para entradas inválidas, seguindo a camada de compatibilidade do wolfSSL e os caminhos de falha já existentes na EVP_DecodeBlock(). A resistência veio imediatamente. Um mantenedor se preocupou com chamadores de terceiros que convertem o valor de retorno para size_t sem verificar — e -1 vira SIZE_MAX nessa conversão, o que é discutivelmente pior do que o overflow que previne. Então retornar 0? Só que 0 já é um sucesso legítimo: codificar zero bytes retorna zero. Como disse um mantenedor, ele já tinha se queimado por levantar erro num caso de sucesso. Use então OPENSSL_assert(), sugeriu outro — derrube o processo na violação do contrato e documente a pré-condição. Ao que um mantenedor sênior respondeu, sem rodeios: um assert dentro de uma biblioteca é “um DoS esperando para acontecer”.

Cada opção era ruim, e cada uma por um motivo diferente: -1 quebra conversões sem sinal, 0 colide com sucesso, e o assert transforma um erro de lógica em uma queda controlada pelo atacante. É o que acontece quando o contrato de erros de uma API nunca foi projetado, apenas herdado. É a lacuna entre especificação e implementação em sua forma mais pura — a documentação dizia “retorna o número de bytes codificados”, e ninguém nunca tinha escrito o que acontece quando a codificação é impossível.

Mais dois detalhes da thread merecem atenção. Primeiro, um revisor percebeu que o patch inicial rejeitava f == NULL incondicionalmente — mas codificar um buffer vazio com ponteiro de entrada NULL e dlen == 0 sempre tinha funcionado, e aplicações reais dependiam disso. Até a validação “obviamente correta” quebrou um caso de borda legítimo. Segundo, um revisor fez grep por chamadas que não verificam o valor de retorno e as encontrou dentro do próprio OpenSSL: PEM_SignFinal() e NETSCAPE_SPKI_b64_encode(). Tornar uma função recém-falível não adianta nada se os chamadores foram escritos numa época em que ela não podia falhar. Veredito: furado, completamente. Semântica de erro é design de API, e remendá-la é cirurgia, não um patch.

Uma linha férrea se divide em três caminhos divergentes na neblina do entardecer.
Retornar -1, retornar 0 ou assert: cada ramo do debate sobre a correção trazia seu próprio perigo.

Mito 4: “Ninguém alimenta um gigabyte num codificador base64”

A intuição aqui é que base64 serve para coisas pequenas: certificados, chaves, tokens curtos. E na maior parte isso é verdade. Mas sistemas modernos cresceram silenciosamente com blobs enormes que são codificados o tempo todo — documentos de atestação, respostas SAML, manifestos de imagens de contêiner, credenciais de proxy, payloads de webhook que algum middlebox decide recodificar. O reprodutor deste CVE não era exótico: era uma senha, entregue por uma variável de ambiente, num caminho de código que codifica credenciais para um proxy HTTP. Nada naquele pipeline foi projetado pensando num teto de 1,6 GB, porque ninguém escreveu esse teto em lugar nenhum.

Há também um hábito arquitetural que piora isso: APIs de codificação de uma só vez incentivam ler o payload inteiro para a memória antes de transformá-lo. O OpenSSL tem alternativas em streaming — EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal() — que processam os dados em pedaços e contornam todo o problema de “calcular o tamanho total da saída de antemão”. Streaming custa um objeto de contexto e um loop. O que ele compra é que nenhum tamanho único precisa ser ao mesmo tempo influenciado pelo atacante e confiável. Veredito: furado. As entradas crescem até bater num limite, e se esse limite for um estouro de inteiro com sinal, o limite encontra você.

Mito 5: “Nossos fuzzers teriam pego isso”

Não teriam, e vale entender por quê. Fuzzers guiados por cobertura, como o libFuzzer, usam por padrão tamanhos máximos de entrada medidos em quilobytes — 4096 bytes de fábrica. Um bug que exige 1,6 bilhão de bytes de entrada não é apenas improvável de ser encontrado; ele está totalmente fora do espaço de busca. Você poderia fazer fuzzing do EVP_EncodeBlock() por um século sem tocar no overflow, porque o comportamento interessante só existe numa escala que o fuzzer nunca visitará.

A solução não é entradas de fuzzing maiores — ninguém quer alocar 1,6 GB por iteração de fuzzing. A solução é testar a aritmética separadamente da codificação. Extraia o cálculo do tamanho e teste intensamente sua fronteira com testes unitários simples:

#include <assert.h>
#include <limits.h>
/* Mirrors the upstream guard, computed in a wide type. */
static int encoded_len_fits_int(long long dlen)
{
return dlen >= 0 && dlen <= ((long long)INT_MAX / 4) * 3;
}
int main(void)
{
long long limit = ((long long)INT_MAX / 4) * 3; /* 1,610,612,733 */
assert(encoded_len_fits_int(0));
assert(encoded_len_fits_int(limit));
assert(!encoded_len_fits_int(limit + 1));
assert(!encoded_len_fits_int(-1));
/* The encoded size at the limit must itself fit in an int. */
assert(4 * ((limit + 2) / 3) <= INT_MAX);
return 0;
}

Depois, adicione uma verificação diferencial com tamanhos moderados: calcule o comprimento esperado da saída com a sua fórmula do lado do chamador, codifique, e afirme que a função escreveu exatamente esse número de bytes e nem um a mais. Rode tudo sob o AddressSanitizer com entradas de algumas centenas de megabytes no CI — grandes o suficiente para exercitar os loops largos, pequenas o suficiente para terminar antes do almoço. Fuzzing continua sendo a ferramenta certa para a lógica byte a byte do codec; apenas nunca foi a ferramenta certa para overflow de inteiro em escala, e confundir essas duas tarefas é como bugs assim sobrevivem a uma década de fuzzing contínuo. Veredito: furado.

Como Auditar uma API de Codificação Antes que Ela Audite Você

Esteja você revisando o uso do OpenSSL no seu próprio código ou avaliando o caminho de codificação de qualquer biblioteca, as mesmas poucas perguntas pegam toda essa classe de bug:

  • Quem calcula o tamanho da saída? Se o chamador faz isso com uma fórmula não trivial, os dois lados podem divergir. Prefira APIs que recebem a capacidade de saída como parâmetro e falham de forma limpa quando ela é insuficiente.
  • Que tipo de inteiro carrega os tamanhos? Um parâmetro de tamanho int é um teto de 2 GB com um bit de sinal acoplado. size_t não torna o overflow impossível, mas empurra o teto para além da borda de qualquer buffer que você consiga alocar numa máquina de 64 bits.
  • O que acontece com zero, na fronteira e um além dela? Entrada vazia, exatamente (INT_MAX/4)*3, e esse valor mais um são os três casos de teste que importam.
  • A função tornou-se falível recentemente? Se um patch adicionou retornos de erro a algo que antes não podia falhar, faça grep em cada chamada. Retornos não verificados transformam um bug corrigido em um bug silencioso.
  • Existe uma variante em streaming? APIs fragmentadas de encode/update/final eliminam a necessidade de qualquer tamanho total confiável único.

Vou além no primeiro ponto: qualquer API que obriga o chamador a replicar a fórmula interna de tamanho da biblioteca é uma fábrica de bugs, e a indústria deveria parar de construí-las. O callee conhece o fator de expansão, as regras de padding e a convenção do terminador. Forçar cada chamador a rederivar 4 * ((n + 2) / 3) + 1 garante que alguém, em algum lugar, vai errar — ou vai acertar num tipo pequeno demais.

Uma lupa inspeciona blocos brilhantes numa esteira; um deles está rachado.
Auditorias de codificadores devem focar na matemática do tamanho, não apenas no embaralhamento de bytes.

A Conclusão para Base64 e Além

O CVE-2026-121481 vai sair dos feeds em uma semana, mas a classe de bug não vai. Funções de codificação ficam no ponto cego da revisão de segurança: confiam em tamanhos, são dispensadas de fuzzing em escala e ficam embrulhadas em APIs cujo comportamento de erro nunca foi especificado. Os mantenedores do OpenSSL gastaram mais palavras discutindo se deveriam retornar -1, 0 ou travar do que sobre o próprio overflow — e fizeram bem, porque essa é a parte com que todo chamador downstream vai conviver por anos.

Então: aplique o patch, sim, mas também faça grep. Encontre suas chamadas de codificação, verifique quem calcula o tamanho do buffer, confirme que os retornos são de fato verificados e mova tudo que lida com dados em massa não confiáveis para uma API de streaming. O próximo 9.8 num codificador já está na fórmula de tamanho de alguém, esperando uma entrada grande o bastante para encontrá-lo.