frontendfacile.it — terminal/bin/blog

20 novembre 2026

Se hai messo qualcosa online dal 2015, probabilmente stai già convivendo con una vulnerabilità critica

Supply-chain via CDN, RCE in Java su Base64 e una falla storica in Nginx: tre classi di incidenti che cambiano le priorità operative (anche per chi fa “solo” frontend).

In pochi giorni sono emerse tre storie diverse ma legate dallo stesso filo: la superficie d’attacco moderna non è più “il tuo codice”, ma tutto ciò che gli sta attorno. Un tool di A/B testing trasformato in vettore malware, una RCE in Java innescabile con una stringa Base64 malformata (su specifiche CPU) e un bug in Nginx annidato nel flow control da anni. Vediamo i meccanismi tecnici, cosa significano per chi sviluppa e deploya web app, e quali check pratici mettere subito in backlog.

Negli ultimi anni abbiamo interiorizzato un’idea: se aggiorno le dipendenze e configuro bene TLS, sono ragionevolmente a posto. La realtà è più scomoda. Gran parte del rischio sta nella supply-chain operativa: CDN di terze parti, tool marketing inseriti “solo per un test”, reverse proxy dati per scontati, runtime che includono ottimizzazioni low-level difficili da osservare.

Qui sotto metto in fila tre casi emblematici (e soprattutto le lezioni tecniche che conviene portarci a casa), con indicazioni pratiche per capire se il tuo stack potrebbe essere esposto.


1) Quando il JavaScript “di marketing” diventa un malware router

Molti siti integrano strumenti di A/B testing e personalizzazione (per esperimenti, conversion rate, funnel). Il pattern è quasi sempre lo stesso:

  • includi uno snippet nel frontend;
  • lo snippet carica risorse da una CDN del fornitore;
  • il fornitore gestisce le varianti e ti consegna JavaScript dinamico.

Se quel fornitore ha una falla che consente a un attaccante di iniettare codice nei progetti di altri clienti, l’effetto è devastante: la CDN “legittima” diventa un canale di distribuzione malware su scala.

Perché è così pericoloso (anche lato frontend)

  • Il codice arriva da un dominio considerato affidabile (spesso già in allowlist).
  • L’iniezione si esegue nel contesto del tuo sito: può leggere DOM, intercettare input, manipolare pagamenti, fare redirect, installare skimmer.
  • Le difese tradizionali (WAF, patching backend, segmentazione) spesso non vedono nulla: è traffico web normale con JS apparentemente “atteso”.

Mitigazioni che valgono davvero

  1. Riduci terze parti “eseguibili”: tutto ciò che carica JS dinamico è superficie d’attacco.
  2. CSP rigorosa (Content-Security-Policy):
    • evita unsafe-inline quando possibile;
    • limita script-src a pochi origin;
    • valuta strict-dynamic se sai cosa stai facendo.
  3. Subresource Integrity (SRI): funziona bene con asset versionati e immutabili; è difficile con script generati dinamicamente, ed è un segnale: se non puoi mettere SRI, stai accettando un rischio maggiore.
  4. Isola i tag: dove possibile carica certe terze parti in sandbox (iframe) o via server-side proxy con validazioni.
  5. Monitoraggio: alert su cambi improvvisi di payload serviti da terze parti (hashing/allowlist) e su anomalie di rete dal browser.

2) Java e Base64: quando un’ottimizzazione in assembly apre la porta alla RCE

A volte una vulnerabilità non nasce in “Java il linguaggio”, ma nell’implementazione concreta della JVM, specialmente quando entra in gioco codice ottimizzato per hardware moderno.

Il caso interessante: una falla nella decodifica Base64 che, su certe piattaforme CPU, usa una versione ottimizzata (con istruzioni vettoriali) al posto dell’implementazione standard. Con input appositamente costruiti (stringhe corte e padding anomalo), l’algoritmo può finire a scrivere oltre i limiti di un buffer prima di concludere che l’input è invalido.

Se l’applicazione decodifica Base64 da input non fidati (spoiler: succede continuamente: header, token, payload, upload, API), una scrittura fuori bounds è una classica strada verso:

  • crash (DoS),
  • leak di memoria,
  • fino a remote code execution in condizioni sfruttabili.

Implicazione per chi fa prodotti web

Anche se sei “solo frontend”, se lavori su una web app moderna stai sempre dentro un ecosistema in cui:

  • gateway/API decodificano token,
  • servizi interni processano blob Base64,
  • CI/CD produce e valida artefatti.

Un bug così non è “roba da backend”: è un rischio di piattaforma.

Mitigazioni pratiche

  • Inventario runtime: sai che versione di Java gira in produzione? Sai su quali CPU?
  • Patch management aggressivo su runtime e immagini base.
  • Defensive parsing: dove controlli tu il codice applicativo, valida dimensioni e formato prima di chiamare decoders, imponi limiti stringenti e timeouts.
  • Riduci la superficie di input: non accettare Base64 “ovunque”, non lasciarlo passare in log/telemetria senza limiti.

3) Nginx e il bug “antico”: flow control, underflow/overflow e RCE

Nginx è spesso percepito come “solido per definizione”: usato ovunque, auditato, battle-tested. Proprio per questo è facile che resti nella configurazione iniziale per anni.

La vulnerabilità qui nasce in una logica di flow control: per non inondare il client, il server rispetta un meccanismo di “credito” (quanti byte può inviare). Il protocollo impone un tetto (es. 2GB). Il bug sta nel modo in cui Nginx gestisce il credito quando una richiesta viene cancellata: il credito non usato viene “rimborsato” alla connessione senza riapplicare correttamente il cap.

A quel punto si entra nel territorio classico delle vulnerabilità C:

  • il contatore supera il massimo,
  • controlli fatti con sottrazioni su interi unsigned possono andare in underflow (wrap-around),
  • e più avanti un altro pezzo di codice interpreta lo stesso valore in modo diverso (es. come signed), portando a lunghezze negative e copie fuori buffer.

Da lì, lo sfruttamento segue un copione noto:

  • leak di memoria per capire layout e indirizzi,
  • overwrite di puntatori/funzioni chiamate in eventi (es. chiusura connessione),
  • esecuzione di codice controllato dall’attaccante.

In scenari reali, una RCE su Nginx può essere combinata con vulnerabilità di escalation sul sistema operativo per ottenere privilegi più alti.

Cosa significa per chi deploya web app

  • Se ti fidi di un reverse proxy come “cintura di sicurezza”, una RCE sul proxy è il peggiore dei casi: è davanti a tutto.
  • Anche se l’exploit pubblico richiede condizioni “pesanti” (molti dati su una singola connessione, timing, ecc.), non è un motivo per ignorare patch e mitigazioni: gli attori più capaci adattano.

Mitigazioni pratiche

  • Aggiorna Nginx e verifica la versione effettiva in produzione (non solo quella dichiarata nei repo).
  • Metti un proxy/edge davanti (CDN, WAF, rate limiting) e limita connessioni lunghe/anomale; non è una patch, ma riduce sfruttabilità.
  • Hardening del processo: esegui Nginx con privilegi minimi, limita filesystem, usa container con seccomp/apparmor, disabilita ciò che non serve.
  • Osservabilità: log e metriche su connessioni con volumi anomali, reset frequenti, pattern di cancel/request strani.

Come capire se “sei coinvolto” (checklist rapida)

Senza trasformare tutto in paranoia, ci sono tre domande che dovresti poter rispondere in pochi minuti:

  1. Quali script terzi carica il mio frontend in produzione?
    • Da quali domini?
    • Sono versionati e verificabili (SRI) o dinamici?
  2. Qual è la mia catena di reverse proxy?
    • CDN → WAF → Nginx/Ingress → app? Chi gestisce cosa?
    • Che versione gira davvero sugli ambienti?
  3. Che runtime eseguono i servizi critici?
    • Versione Java/Node/.NET, immagini base, CPU target.

Se non hai risposte certe, non è un problema “di sicurezza”: è un problema di operatività.


Sintesi: la lezione che conviene portarsi a casa

Il punto non è che “internet è pericolosa” (lo è sempre stata), ma che oggi gli incidenti più impattanti nascono dove siamo più rilassati:

  • JavaScript di terze parti servito da CDN fidate,
  • ottimizzazioni di runtime e hardware che nessuno controlla nei dettagli,
  • componenti infrastrutturali considerati intoccabili perché diffusi.

L’implicazione pratica è chiara: oltre alle patch applicative, servono inventario, riduzione delle dipendenze eseguibili, CSP/SRI dove possibile, e un processo di aggiornamento continuo su proxy e runtime. Se hai deployato qualcosa dal 2015 in poi, la domanda non è “se” sei esposto a una di queste classi di rischio, ma quanto velocemente riesci a scoprirlo e reagire.

Stile del sito

Scegli il tuo ambiente.