Articoli approfonditi sulla tecnologia che plasma il futuro.

Vulnerabilità regex Ruby: il case folding Unicode morde

Sette vulnerabilità in regex e conversione delle maiuscole in Ruby mostrano perché il case folding Unicode è pericoloso. Ecco come auditare il codice.

Un blocco di caratteri tipografici a rilievo che si divide in due blocchi più piccoli sopra un vassoio da tipografo
Un carattere che diventa due è tutto il bug: la s aspra tedesca in maiuscolo diventa SS e i calcoli sul buffer vanno a rotoli.

Un'app Rails normalizza gli indirizzi email chiamando upcase prima di salvarli, come consigliano mille tutorial. Un utente si registra come mueller@straße.example con un modulo che, da qualche parte lungo la pipeline, ha deciso che Windows-1252 fosse una codifica perfettamente valida. La chiamata a upcase trasforma la ß finale in SS — due byte dove prima ce n'era uno — e scrive uno di quei byte oltre la fine di un buffer nello heap. Non è un'ipotesi. È una ricostruzione plausibile di una delle sette vulnerabilità di regex e conversione delle maiuscole in Ruby che il core team ha appena corretto, diverse delle quali hanno proof of concept funzionanti per l'esecuzione di codice remoto.

L'advisory è uscito insieme a tre release d'emergenza — Ruby 4.0.10, 3.4.13 e 3.3.14 — ed è un utile caso di studio su una verità più profonda: la conversione delle maiuscole sembra l'operazione più semplice di una libreria di stringhe ed è in realtà una delle più pericolose. È il punto in cui la vasta specifica Unicode incontra codice C vecchio di decenni, e proprio in quella giuntura crescono gli overflow dello heap.

Sette bug, due sottosistemi, una sola causa radice

I sette advisory (tracciati tramite identificativi GHSA mentre i numeri CVE attendono nella coda di assegnazione) si raggruppano in due famiglie. Due riguardano la conversione delle maiuscole in String: un overflow del buffer nello heap di un byte e un integer overflow che a cascata produce un overflow nello heap. Cinque riguardano il motore delle espressioni regolari di Ruby: un double free durante la compilazione del pattern, un integer overflow durante la compilazione, una lettura fuori dai limiti nel matching case-insensitive, una lettura fuori dai limiti nel matching case-insensitive dei backreference e un heap buffer overflow in Regexp#to_s.

Notate cosa li unisce. Non è codice scritto con leggerezza nel senso solito — il core C di Ruby è vecchio, collaudato e sottoposto a fuzzing intensivo. È che entrambi i sottosistemi implementano la semantica Unicode delle maiuscole e minuscole, e quella semantica è una trappola. Il matching di regex case-insensitive richiede di applicare il case folding sia al pattern sia all'input, il che significa che il motore usa le stesse tabelle di mapping pericolose di String#upcase, solo su un percorso più caldo e con più influenza di un attaccante sugli input. I backreference in modalità case-insensitive devono confrontare sottostringhe ripiegate. Regexp#to_s deve riemettere il testo sorgente di un pattern insieme alle sue opzioni, dimensionando un buffer per una ricostruzione che a sua volta coinvolge logica sensibile alle maiuscole. Ognuno di questi percorsi di codice deve rispondere alla stessa domanda, ingannevolmente difficile: quanto sarà grande questa stringa dopo che ne cambio le maiuscole?

Ruby 3.3 riceve la correzione perché è ancora in manutenzione di sicurezza. Ruby 3.2 e le versioni precedenti sono end of life e non ricevono nulla — se siete su una di queste, questo advisory è la vostra scadenza per la migrazione, non un semplice avviso.

Breve storia di una conversione andata storta

In ASCII, cambiare maiuscole e minuscole è un bit flip. Ventisei coppie di lettere, uno a uno, che preserva la lunghezza e non dipende dalla locale. toupper() dal C dell'era K&R incarna l'intera idea in una sola tabella di lookup. È il modello mentale che la maggior parte di noi porta con sé da adulti, ed è il modello incorporato nella logica di dimensionamento dei buffer in tutto il codice C del mondo. È anche sbagliato per praticamente ogni sistema di scrittura oltre il latino di base.

Unicode definisce migliaia di mapping di maiuscole e minuscole, e una fetta significativa non è uno-a-uno. La s aspra tedesca (ß) diventa SS in maiuscolo. La legatura ff diventa FF. Le legature armene si espandono. Il greco ha la sigma dipendente dal contesto — σ contro ς in fine di parola — quindi un folding corretto dipende dai caratteri circostanti. Il turco e l'azero hanno il problema della i con e senza puntino, dove i diventa İ in maiuscolo e ı diventa I, cosa che ha notoriamente mandato in crisi di tutto, dalle app Java al strtoupper di PHP nelle locale turche. E al cherokee sono state aggiunte retroattivamente le lettere minuscole nel 2015 con Unicode 8.0, trasformando uno script senza maiuscole e minuscole in uno che le ha, e invalidando ipotesi nel software di tutto il mondo.

Le codifiche legacy peggiorano le cose. Windows-1252 ha un byte per la ß minuscola (0xDF) ma nessun byte per una ipotetica versione maiuscola — perché storicamente il tedesco nel testo corrente non ne ha mai usata una; si scriveva SS. Quindi, quando una routine di conversione su una stringa Windows-1252 incontra ß e la sostituisce correttamente con SS, la stringa cresce di un byte. Le analisi approfondite circolate dopo l'advisory suggeriscono che sia esattamente questo l'overflow di un byte: il loop di conversione sembra verificare lo spazio disponibile nel buffer un carattere alla volta, quindi una ß posta come ultimo carattere di una stringa dimensionata con precisione produce una S vagante scritta oltre l'allocazione. Un overflow di un byte con una S controllata dall'attaccante è una primitiva di exploit fastidiosa e poco pratica — ma l'advisory conferma che esistono PoC che ottengono RCE, quindi qualcuno ha fatto il lavoro di heap grooming.

La conversione delle maiuscole e minuscole non è una biiezione, non preserva la lunghezza, non è indipendente dalla locale e non è rappresentabile in ogni codifica. Il codice che assume il contrario è una vulnerabilità che aspetta un fuzzer.

Perché il motore delle regex è la preoccupazione maggiore

Il motore di regex di Ruby è Onigmo, un fork di Oniguruma, ed è un pezzo di software davvero impressionante — gestisce decine di codifiche, il case folding Unicode completo, lookbehind, gruppi con nome e backreference, tutto in C, con una stratificazione che risale alla fine degli anni '90. Quella stratificazione è il problema. Il matching case-insensitive in Onigmo significa che ogni punto di confronto può eseguire logica di folding, e il folding cambia le lunghezze, quindi la contabilità tra offset del pattern, offset della stringa e confini del match è davvero intricata. Due dei bug corretti sono letture fuori dai limiti proprio in questo meccanismo — uno nel matching case-insensitive in generale, uno specificamente nel matching case-insensitive dei backreference, dove il motore confronta una sottostringa catturata in precedenza (ripiegata) con la posizione corrente.

Il modello di sfruttamento conta però più degli interni. Tre dei cinque bug delle regex si attivano durante la compilazione del pattern, e l'advisory è esplicito su chi è esposto: le applicazioni che compilano pattern controllati dall'attaccante. Verrebbe da pensare che sia raro. Non lo è. Ogni casella di ricerca avvolta in Regexp.new(query), ogni regola di validazione configurabile caricata da un database, ogni livello di parsing dei log o di routing che costruisce pattern da file di configurazione controllati da un operatore (o da un tenant compromesso) — è un percorso di compilazione raggiungibile da input ostile. Fino a questo advisory, il caso peggiore per la compilazione di un pattern ostile era un ReDoS: un pattern con backtracking catastrofico che blocca una CPU. Fastidioso, ma recuperabile. Ora il caso peggiore è la corruzione della memoria con PoC di RCE. È un rischio qualitativamente diverso per la stessa riga di codice che avete in produzione da anni.

C'è uno schema qui che vale la pena nominare: la specifica dice una cosa, il C ne dice un'altra, e il divario è sfruttabile. Ne abbiamo già parlato — il divario tra specifica e implementazione è dove si nascondono i bug — e le tabelle di case folding di Unicode sono una delle specifiche più ricche che si possa chiedere a un programmatore C di implementare. Le tabelle cambiano tra le versioni di Unicode, le regole di special casing hanno sotto-clausole, e chi ha scritto il codice di dimensionamento del buffer nel 2003 lavorava su un Unicode più piccolo e semplice di quello in cui arrivano oggi le vostre stringhe.

L'integer overflow: quattro gigabyte diventano sei byte

Il secondo bug sulle stringhe è una bella illustrazione di un modo diverso di fallire: aritmetica delle lunghezze a 32 bit in un mondo a 64 bit. Questo proof of concept, circolato pubblicamente dopo l'advisory, usa Shift_JIS e una stringa di oltre quattro gigabyte:

str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}"   # 4294967302
new_str = str.downcase
puts new_str.bytesize   # 6 on unpatched builds (!)
puts new_str.bytes      # [130, 160, 97, 97, 97, 97]

Entra una stringa di 4.294.967.302 byte, e il risultato del downcase riporta una dimensione di 6. Da qualche parte nel percorso di conversione una lunghezza è stata calcolata o troncata tramite un tipo a 32 bit: 2³² + 6 è andato in overflow fino a 6, e l'allocazione o la copia successiva è stata dimensionata di conseguenza — una classica pipeline da integer overflow a overflow dello heap. Quattro gigabyte sembrano un input assurdo, ma ricordate che le stringhe in un processo in esecuzione non devono arrivare dalla rete in un unico pezzo: vengono costruite a partire da chunk, da decompressione, da concatenazioni nei job di importazione e nei parser di file. Un attaccante che può influenzare quanti dati si accumulano in una stringa, e poi far chiamare downcase su di essa, controlla entrambe le metà di questo bug.

Entrambi i bug sulle stringhe condividono una lezione architetturale con il bug dell'asterisco di Alpine, vecchio di un decennio: il codice pericoloso sta su un percorso che nessuno considera una superficie d'attacco. Nessuno fa threat modeling di upcase. Ed è proprio per questo che questi bug sopravvivono per anni — stavano in percorsi che gli esseri umani non auditano e che, fino a poco tempo fa, i fuzzer non raggiungevano con sufficiente intelligenza da costruire stringhe multi-byte codificate in modo valido.

Sono state le macchine a trovare questi bug, e questo cambia i conti

Guardate i ringraziamenti. Quattro dei sette advisory citano Stephan Lipp di Ada Logics — la società dietro gran parte dello sviluppo degli harness di OSS-Fuzz — e Anthropic. È un esperto di infrastruttura di fuzzing abbinato a un modello di AI, e non è il primo advisory recente con questa firma. La genealogia merita di essere apprezzata: il fuzzing è iniziato con Barton Miller che nel 1990 lanciava dati casuali sulle utility Unix, è diventato più intelligente con la mutazione guidata dalla copertura di AFL nel 2013, si è industrializzato con OSS-Fuzz che martella continuamente i progetti open source dal 2016, e ora ha acquisito uno strato capace di ragionare sul codice — costruire una stringa Shift_JIS da 4 GiB o un buffer Windows-1252 che termina con ß richiede di comprendere la validità delle codifiche e l'aritmetica delle lunghezze, non solo di mutare byte.

Un braccio di scansione meccanico ispeziona schede perforate su un nastro trasportatore, una delle quali brilla
Il fuzzing guidato dalla copertura unito al ragionamento dei modelli linguistici sta auditando codice C vecchio più velocemente di quanto gli esseri umani abbiano mai potuto fare.

L'implicazione strategica taglia in entrambe le direzioni. I difensori ottengono un auditing continuo e instancabile di codebase che nessun team potrebbe permettersi di rivedere a mano. Ma la stessa capacità è disponibile a chiunque abbia un modello e della potenza di calcolo, e non tutti presentano advisory. L'epoca comoda in cui un bug di corruzione della memoria in un percorso di codice oscuro poteva contare su anni di vita indisturbata sta finendo; l'economia di trovarli è crollata. Ho già sostenuto che gli scanner basati su AI stanno riscuotendo il nostro debito tecnico, e questa è la ricevuta: un runtime di linguaggio usato da milioni di persone, trovato carente non da un ricercatore annoiato con un weekend libero ma da una pipeline automatica che continuerà semplicemente a girare.

La mia posizione: questo rafforza il caso dei linguaggi memory-safe, ma non nel modo superficiale in cui il dibattito di solito lo inquadra. Riscrivere Onigmo in Rust non avrebbe risolto la logica — un case folding che cambia la lunghezza della stringa resta un rischio a livello di specifica, e la domanda sulla dimensione del buffer va comunque risolta correttamente. Ciò che la memory safety elimina è il gradiente delle conseguenze. Il bug di logica diventa un panic, un risultato sbagliato, una richiesta fallita — non una RCE. Non è poco: è la differenza tra un incidente e un comunicato di disservizio.

Come auditare la propria esposizione

Partite dall'ovvio e lavorate verso l'esterno. Aggiornate a 4.0.10, 3.4.13 o 3.3.14 — Onigmo è incorporato nella build di Ruby, quindi non c'è una libreria separata da patchare; il runtime è la patch. Poi auditate il codice dell'applicazione per le due forme pericolose: stringhe influenzate dall'attaccante che finiscono in operazioni di conversione del case, e pattern influenzati dall'attaccante che finiscono in Regexp.new o Regexp.compile.

  • Smettete di compilare l'input utente in pattern. Se gli utenti forniscono termini di ricerca, fateli passare da Regexp.escape. Se hanno davvero bisogno della potenza delle regex, mettete davanti una allowlist e un timeout stretto — e sappiate che il timeout aiuta contro il ReDoS, non contro la corruzione della memoria.
  • Normalizzate le codifiche al confine di fiducia. I due bug sulle stringhe dipendono da codifiche esotiche (Windows-1252, Shift_JIS). Se la vostra app parla solo UTF-8, dichiaratelo ai bordi: forzate o transcodificate la codifica in ingresso e rifiutate ciò che non si converte in modo pulito.
  • Preferite il confronto case-insensitive alla conversione delle maiuscole. a.casecmp?(b) pone una domanda; a.upcase == b.upcase alloca due nuove stringhe nella codifica dichiarata dall'input. L'API di confronto ha una superficie semantica molto più piccola.
  • Cercate upcase, downcase, swapcase e capitalize nei dati non fidati. Ogni punto di chiamata è un posto in cui vive un'assunzione sulla lunghezza. Lo stesso vale per qualsiasi estensione C che avete scritto e che fa una propria logica di case: quelle non beneficiano affatto delle correzioni del core team.
  • Fate fuzzing su ciò che possedete. Ruby stesso è sottoposto a fuzzing da OSS-Fuzz, ma le vostre estensioni C no. AFL++ o libFuzzer con ASan troveranno nel vostro codice le stesse classi di bug che le macchine hanno appena trovato in Ruby.
  • Conoscete lo stato di manutenzione del vostro runtime. Ruby 3.2 è end of life e non ha ricevuto queste correzioni. «Funziona ancora» non è una postura di sicurezza quando il flusso di patch si è fermato.

Un confronto prima e dopo per il caso più comune — normalizzare username o email per i controlli di unicità:

# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end

Nulla di tutto questo vi rende sicuri su un runtime non aggiornato — per quello serve l'upgrade. Ma queste abitudini riducono la classe di bug che la vostra applicazione può ereditare dal livello sottostante, e rendono il vostro codice onesto sul fatto che il testo non è byte.

Lucchetti su un banco da lavoro, uno aperto sotto una lente d'ingrandimento accanto a attrezzi di precisione
Auditare la propria esposizione: le serrature che non avete installato voi contano comunque come vostre.

La lezione più profonda per i runtime dei linguaggi

C'è la tentazione di archiviare tutto sotto 'il C è pericoloso, altro che novità', e le risposte superficiali all'advisory hanno fatto esattamente questo. Ma io andrei oltre. Questi sette bug non riguardano davvero il C — riguardano il disallineamento tra uno standard di internazionalizzazione in evoluzione e assunzioni implementative congelate. Unicode continuerà ad aggiungere script e a perfezionare i mapping. Ogni runtime di linguaggio al mondo ha codice di conversione delle maiuscole scritto su qualche versione passata di quelle tabelle, dimensionato su qualche passata comprensione di quanto una stringa possa crescere. Ruby è stato colto impreparato questo mese; la prossima volta toccherà al motore di regex, al case folder o alla routine di normalizzazione di qualcun altro.

La conclusione pratica è trattare la trasformazione del testo come un confine di sicurezza, non come una funzione di utilità. Tutto ciò che ri-codifica, cambia il case, normalizza o applica il folding è un parser, e i parser sono dove vivono i bug di memoria. La conclusione storica — quella che trovo davvero soddisfacente da nerd di linguaggi — è che l'umile ß tedesca, una lettera con cui i tipografi lottano dai tempi del Fraktur, può ancora attraversare sei secoli di storia tipografica e scrivere un byte oltre la fine di un buffer nello heap. Il linguaggio non è mai stato semplice. Abbiamo solo costruito le nostre macchine partendo dal presupposto che lo fosse.