Overflow in EVP_EncodeBlock di OpenSSL: 5 miti, testati
Il buffer overflow in EVP_EncodeBlock di OpenSSL (CVSS 9.8) mostra come le API di encoding base64 sfuggano ai controlli. Cinque miti sulla sicurezza, testati.

Una funzione che non fa altro che trasformare byte in testo base64 ha appena ottenuto un punteggio CVSS di 9.8. Il buffer overflow in EVP_EncodeBlock di OpenSSL — tracciato come CVE-2026-121481 — è il tipo di bug che sembra noioso finché non ti rendi conto che la codifica base64 sta alla base della gestione dei certificati, dei client HTTP, dell'autenticazione proxy e di metà del codice di collegamento della tua infrastruttura. La correzione in sé ha richiesto quattro commit e una discussione piuttosto accesa tra i maintainer su come dovrebbe essere, in realtà, un valore di ritorno di errore.
La discussione attorno a questa CVE è un regalo per chiunque si occupi di design delle API, perché fa emergere una serie di assunzioni che gli ingegneri fanno sulle funzioni di codifica — assunzioni che continuano a produrre la stessa classe di bug da decenni e in più librerie. Prendiamo cinque delle credenze più comuni e confrontiamole con quello che è successo davvero.
Come funziona davvero il buffer overflow di EVP_EncodeBlock
La codifica base64 gonfia i dati: ogni tre byte in input diventano quattro caratteri in output. Quindi la dimensione dell'output è 4 * ((n + 2) / 3), più uno per il terminatore NUL se si vuole una stringa C. EVP_EncodeBlock() di OpenSSL costringe il chiamante a calcolare quella dimensione e ad allocare il buffer di destinazione. La funzione riceve il puntatore di input, il puntatore di output e la lunghezza dell'input — come int. Non sa mai quanto sia grande il buffer di output, quindi non può validare nulla. Scrive e basta.
Ora facciamo i conti. Il più grande int è 2.147.483.647. Quando la lunghezza dell'input supera (INT_MAX / 4) * 3 — cioè 1.610.612.733 byte, circa 1,6 GB — il calcolo interno della dimensione va in overflow su un intero con segno a 32 bit. L'aritmetica sulle lunghezze si avvolge, l'idea della funzione su dove finisce l'output non corrisponde più alla realtà, e si ottengono scritture oltre la fine di qualunque buffer abbia allocato il chiamante. Il chiamante, seguendo la formula documentata, ha fatto lo stesso calcolo in overflow, quindi i due lati possono non essere d'accordo in modo catastrofico su quanto spazio esista.
La correzione upstream ha aggiunto un controllo: rifiutare gli input in cui dlen > (INT_MAX / 4) * 3, insieme ai buffer NULL e alle lunghezze negative. Se incapsuli questa API — e dovresti farlo — il controllo va messo anche al tuo confine:
#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;
}
Nota cosa impone questa API: reimplementare la formula interna di dimensionamento della libreria, nel chiamante, in modo corretto, per sempre. Questo contratto è la vera vulnerabilità. L'overflow è solo il punto in cui il contratto alla fine si è rotto.
Mito 1: «I decoder sono la superficie d'attacco, gli encoder sono noiosi»
La cultura delle revisioni di sicurezza ha un forte pregiudizio: il parsing è pericoloso, la serializzazione è contabilità. I decoder consumano byte ostili, quindi vengono sottoposti a fuzzing, audit e riscritti in linguaggi memory-safe. Gli encoder producono output, e l'output sembra sicuro. Questa convinzione è sbagliata in un modo specifico e ripetibile: i bug degli encoder si annidano nel calcolo della dimensione dell'output, e quella matematica è considerata affidabile da entrambi i lati della chiamata.
Il pattern si ripete. Il thread della PR stesso fa notare che CVE-2026-121481 assomiglia a CVE-2021-23840, un precedente overflow in OpenSSL nelle funzioni EVP update, dove un calcolo di lunghezza andava in overflow con input enormi. E base64, in particolare, ha un peso qui — quando il decoder Base64 di OpenJDK ha trasformato 65 byte in esecuzione di codice remoto, abbiamo raccontato come un codec «banale» sia diventato una primitiva RCE. I decoder ottengono CVE per aver accettato input errati; gli encoder ottengono CVE per aver calcolato in modo errato input validi. Sono della stessa specie: aritmetica su lunghezze influenzate dall'attaccante.
Verdetto: sfatato. Se il tuo modello di minaccia si ferma al parser, hai lasciato aperta la porta sul retro mentre sorvegliavi quella principale.
Mito 2: «Un CVSS 9.8 significa lasciare tutto stanotte»
Qui vorrei un po' difendere gli scettici. Un 9.8 su un encoder che richiede un input da 1,6 GB non è Heartbleed. Da nessuna parte nell'handshake TLS c'è codifica base64 di dati in blocco — i certificati viaggiano come DER dentro TLS, non come PEM. Perché questo ti colpisca, dati non fidati devono arrivare a EVP_EncodeBlock() (o a un chiamante interno come base64encode() nel client HTTP di OpenSSL) su una scala superiore a 1,6 GB. Un campo di protocollo con un prefisso di lunghezza a 16 bit non potrà mai arrivarci.
Ma definirlo «sintetico» lo sottovaluta. Il segnalatore ha dimostrato un percorso reale da riga di comando: passare un valore enorme di -proxy_pass a openssl s_client, fornito tramite una variabile d'ambiente per aggirare i limiti degli argomenti della shell, e alcune configurazioni — i motori GOST accettano password sovradimensionate di default — lo codificheranno in base64 senza problemi per una richiesta CONNECT al proxy. Non è una curiosità da laboratorio: è uno strumento standard che esegue un'autenticazione proxy standard con una variabile d'ambiente standard.
La mia posizione: considera il CVSS come misura della funzione e il tuo call graph come misura della tua esposizione. Prima di programmare una finestra di patch d'emergenza, cerca nel codice e nelle dipendenze chi codifica effettivamente cosa e quanto può diventare grande l'input. Poi applica comunque la patch — solo nell'ordine giusto. Verdetto: mezza verità. Il punteggio è reale, ma il panico dovrebbe essere proporzionale alla raggiungibilità, e la raggiungibilità è una domanda a cui solo il tuo codice può rispondere.
Mito 3: «La correzione è facile — basta restituire un codice di errore»
Questa è la mia parte preferita dell'intera storia, perché l'overflow era la parte semplice. La parte difficile è stata decidere cosa dovesse fare EVP_EncodeBlock() al riguardo — e i maintainer non sono riusciti a mettersi d'accordo.
La patch originale restituiva -1 per input non validi, in linea con il livello di compatibilità di wolfSSL e con i percorsi di errore esistenti in EVP_DecodeBlock(). Le obiezioni sono arrivate subito. Un maintainer temeva che i chiamanti di terze parti facessero il cast del valore di ritorno a size_t senza controllare — e con quel cast -1 diventa SIZE_MAX, che è probabilmente peggio dell'overflow che si voleva evitare. Allora restituiamo 0? Però 0 è già un successo legittimo: codificare zero byte restituisce zero. Come ha detto un maintainer, era già stato scottato per aver sollevato un errore in un caso di successo. Allora usiamo OPENSSL_assert(), ha proposto un altro — crasha alla violazione del contratto e documenta la precondizione. A cui un maintainer senior ha risposto, senza giri di parole: un assert dentro una libreria è «un DoS che aspetta di accadere».
Ogni opzione era cattiva, e ciascuna per un motivo diverso: -1 rompe i cast unsigned, 0 si scontra con il successo, l'assert trasforma un errore logico in un crash controllabile dall'attaccante. È quello che succede quando la semantica degli errori di un'API non è mai stata progettata, ma solo ereditata. È il divario tra specifica e implementazione nella sua forma più pura — la documentazione diceva «restituisce il numero di byte codificati», e nessuno aveva mai scritto cosa succede quando la codifica è impossibile.
Altri due dettagli dal thread meritano attenzione. Primo, un revisore ha notato che la patch iniziale rifiutava incondizionatamente f == NULL — ma codificare un buffer vuoto con puntatore di input NULL e dlen == 0 aveva sempre funzionato, e le applicazioni reali ci facevano affidamento. Anche la validazione «ovviamente corretta» ha rotto un caso limite legittimo. Secondo, un revisore ha cercato nei call site quelli che non controllano il valore di ritorno e li ha trovati dentro OpenSSL stessa: PEM_SignFinal() e NETSCAPE_SPKI_b64_encode(). Rendere una funzione improvvisamente fallibile non serve a nulla se i suoi chiamanti sono stati scritti quando non poteva fallire. Verdetto: sfatato, a fondo. La semantica degli errori è design dell'API, e riadattarla è chirurgia, non una patch.

Mito 4: «Nessuno passa un gigabyte in un encoder base64»
L'intuizione è che base64 serva per cose piccole: certificati, chiavi, token brevi. E in gran parte è vero. Ma i sistemi moderni hanno silenziosamente iniziato a gestire blob enormi che vengono codificati di continuo — documenti di attestazione, risposte SAML, manifest delle immagini dei container, credenziali proxy, payload di webhook che qualche middlebox decide di ricodificare. Il riproduttore di questa CVE non era esotico: era una password, passata tramite una variabile d'ambiente, su un percorso di codice che codifica le credenziali per un proxy HTTP. Nulla di quella pipeline è stato progettato pensando a un limite di 1,6 GB, perché nessuno lo ha mai scritto da nessuna parte.
C'è anche un'abitudine architetturale che peggiora le cose: le API di codifica one-shot spingono a leggere l'intero payload in memoria prima di trasformarlo. OpenSSL offre alternative in streaming — EVP_EncodeInit(), EVP_EncodeUpdate(), EVP_EncodeFinal() — che elaborano i dati a blocchi ed evitano l'intero problema del «calcolare in anticipo la dimensione totale dell'output». Lo streaming costa un oggetto di contesto e un ciclo. Ciò che ottieni è che nessuna singola lunghezza deve essere allo stesso tempo influenzata dall'attaccante e considerata affidabile. Verdetto: sfatato. Gli input crescono finché non raggiungono un limite, e se quel limite è un overflow di intero con segno, il limite ti trova.
Mito 5: «I nostri fuzzer lo avrebbero scoperto»
No, e vale la pena capire perché. I fuzzer guidati dalla copertura come libFuzzer usano di default lunghezze massime di input misurate in kilobyte — 4096 byte di serie. Un bug che richiede 1,6 miliardi di byte di input non è solo improbabile da trovare; è completamente fuori dallo spazio di ricerca. Potresti fare fuzzing di EVP_EncodeBlock() per un secolo senza sfiorare mai l'overflow, perché il comportamento interessante esiste solo a una scala che il fuzzer non raggiungerà mai.
La soluzione non è input di fuzzing più grandi — nessuno vuole allocare 1,6 GB a ogni iterazione del fuzzer. La soluzione è testare l'aritmetica separatamente dalla codifica. Estrai il calcolo della dimensione e martella i suoi confini con semplici unit test:
#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;
}
Poi aggiungi un controllo differenziale a dimensioni moderate: calcola la lunghezza attesa dell'output con la tua formula lato chiamante, codifica, e verifica che la funzione abbia scritto esattamente quel numero di byte e non uno di più. Esegui tutto sotto AddressSanitizer con input di qualche centinaio di megabyte in CI — abbastanza grandi da esercitare i cicli ampi, abbastanza piccoli da finire prima di pranzo. Il fuzzing resta lo strumento giusto per la logica a livello di byte del codec; non è mai stato lo strumento giusto per l'overflow di interi su larga scala, e confondere questi due compiti è il motivo per cui bug come questo sopravvivono a un decennio di fuzzing continuo. Verdetto: sfatato.
Come verificare un'API di encoding prima che verifichi te
Che tu stia revisionando l'uso di OpenSSL nel tuo codice o valutando il percorso di codifica di una qualsiasi libreria, le stesse poche domande individuano l'intera classe di bug:
- Chi calcola la dimensione dell'output? Se lo fa il chiamante con una formula non banale, i due lati possono divergere. Preferisci API che ricevono la capacità di output come parametro e falliscono in modo pulito quando è insufficiente.
- Quale tipo intero trasporta le lunghezze? Un parametro di lunghezza
intè un limite di 2 GB con un bit di segno attaccato.size_tnon rende impossibile l'overflow, ma sposta il limite oltre il bordo di qualunque buffer che puoi davvero allocare su una macchina a 64 bit. - Cosa succede con zero, al confine e uno oltre? Input vuoto, esattamente
(INT_MAX/4)*3, e quel valore più uno sono i tre casi di test che contano. - Una funzione è diventata di recente fallibile? Se una patch ha aggiunto ritorni di errore a qualcosa che prima non poteva fallire, cerca ogni call site. I ritorni non controllati trasformano un bug corretto in uno silenzioso.
- Esiste una variante in streaming? Le API a blocchi encode/update/final eliminano la necessità di qualunque singola lunghezza totale affidabile.
Vado oltre sul primo punto: qualunque API che obbliga il chiamante a replicare la formula interna di dimensionamento della libreria è una fabbrica di bug, e il settore dovrebbe smettere di costruirle. Il chiamato conosce il fattore di espansione, le regole di padding e la convenzione del terminatore. Costringere ogni chiamante a ricalcolare 4 * ((n + 2) / 3) + 1 garantisce che qualcuno, da qualche parte, lo sbagli — o lo faccia giusto in un tipo troppo piccolo.

La conclusione su base64 e oltre
CVE-2026-121481 scomparirà dai feed entro una settimana, ma la classe di bug no. Le funzioni di codifica stanno nel punto cieco della revisione di sicurezza: considerate affidabili con le lunghezze, esentate dal fuzzing su larga scala e avvolte in API il cui comportamento di errore non è mai stato specificato. I maintainer di OpenSSL hanno speso più parole discutendo se restituire -1, 0 o andare in crash che sull'overflow stesso — e hanno fatto bene, perché è la parte con cui ogni chiamante a valle dovrà convivere per anni.
Quindi: applica la patch, certo, ma anche cerca. Trova i tuoi call site di encoding, controlla chi calcola la dimensione del buffer, verifica che i valori di ritorno siano davvero controllati e sposta tutto ciò che gestisce dati massivi non fidati verso un'API in streaming. Il prossimo 9.8 in un encoder è già nascosto nella formula di qualcuno, in attesa di un input abbastanza grande da trovarlo.


