
Write-up e proof of concept per CVE-2026-113872: crash del processo multer async fileFilter (DoS)
fileFilter asincrono di multerUna singola richiesta di upload non autenticata può mandare in crash l'intero processo Node.js di qualsiasi
app Express che utilizza multer con un
fileFilter asincrono. La richiesta riceve persino prima una normale risposta 400;
il processo muore qualche centinaio di millisecondi dopo.
| CVE | CVE-2026-113872 |
| Avviso GitHub | GHSA-q7qp-rjg7-q26m |
| Pacchetto | multer (npm) |
| Interessato | >= 2.0.0 < 2.5.0 |
| Corretto in | 2.5.0 |
| Gravità | Alta — 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) |
| Tipo | Denial of Service (eccezione non gestita) — CWE-248, CWE-404 |
| Segnalatore | Santiago Habib (@santihabib) |
| Correzione di | Ulises Gascón, Sebastián Beltrán (maintainer di expressjs/multer) |
Questo repository è un write-up di una vulnerabilità che ho segnalato e che ora è divulgata pubblicamente e corretta. Il proof of concept prende di mira una release corretta, così i difensori possono confermare la propria esposizione e verificare la correzione. Aggiorna a
[email protected]o successivo.
Sei interessato se tutte le seguenti condizioni sono vere:
2.0.0 a 2.4.0;fileFilter chiama la sua callback in modo asincrono — cioè dopo un await,
un setTimeout, una query al database, una chiamata HTTP, una scansione antivirus, ecc.;.array(), .fields(), .any()).Il motore di storage (disco, memoria, S3, …) e il limits configurato non fanno
alcuna differenza. Un fileFilter completamente sincrono non è interessato.
npm install multer@^2.5.0
Mantenere fileFilter sincrono e spostare qualsiasi validazione asincrona in un gestore di route che viene eseguito dopo che multer ha terminato l'analisi.
poc/
├── server.js # tiny Express app: memory storage + async fileFilter
├── client.js # sends one crafted multipart request
└── check.js # runs the server in a child process and reports if it survived
cd poc
npm install express [email protected] # vulnerable
node check.js
Output atteso rispetto a una versione vulnerabile:
[server] listening on 31046
[client] HTTP 400 rejected
[check] VULNERABLE: server process exited with code 1 (Error: Unexpected end of form)
Ora rispetto alla versione corretta:
npm install [email protected]
node check.js
[server] listening on 32000
[client] HTTP 400 rejected
[check] NOT VULNERABLE: server is still running
Stesso payload, stessa risposta 400 — ma su 2.5.0 il processo resta attivo.
multer non analizza da sé i corpi multipart. Convoglia la richiesta in busboy e reagisce ai suoi eventi:
req ──pipe──▶ busboy ──'file'──▶ fileStream ──▶ storage engine
│
fileFilter(req, file, cb) ← your code, may be async
Per ogni parte di file, busboy crea un Readable (fileStream) ed emette 'file'.
multer chiede al tuo fileFilter se accettarlo. Finché non viene chiamato cb, nessuno
legge quel flusso di file.
Tre elementi dello stato di multer sono rilevanti:
errorOccured — un latch impostato dal primo errore; gli abort successivi diventano no-op.pendingWrites — conta i file che sono stati accettati e vengono memorizzati.
Un file il cui fileFilter è ancora in sospeso non viene conteggiato.done(err) — termina la richiesta: rimuove la pipe di busboy, chiama next(err), e un
setImmediate dopo chiama busboy.removeAllListeners().Quando busboy spinge i dati del file in un flusso che nessuno sta leggendo, push()
restituisce false. Invece di fallire, busboy parcheggia il proprio callback di scrittura all'interno
del flusso di file e attende che qualcuno lo legga. Nel frattempo, il resto del corpo
continua ad arrivare e si accumula non analizzato nel buffer interno di busboy.
Il callback parcheggiato viene rilasciato solo quando il flusso di file viene letto di nuovo — a quel punto busboy svuota il proprio buffer e continua l'analisi.
Quando un errore precedente termina la richiesta, done() rimuove la pipe di busboy e pianifica
removeAllListeners(). Ma unpipe non svuota ciò che busboy ha già bufferizzato,
e quando un fileFilter ancora in sospeso chiama infine il callback, multer esegue:
if (errorOccured) {
appender.removePlaceholder(placeholder)
return fileStream.resume() // ← reads the parked stream → busboy resumes
}
Quindi dopo il teardown, è resume() a risvegliare il parser.
Due parti di file, entrambe con filtri asincroni. La prima rifiuta dopo 100 ms; la seconda
accetta dopo 300 ms. Il secondo file è più grande di fileHwm (16 KiB), e il body
termina senza un boundary di chiusura.
| Tempo | Evento |
|---|---|
| t0 | busboy emette 'file' due volte; entrambi i filtri in sospeso; pendingWrites == 0. |
| t1 | Il file 2 riempie il suo stream → busboy sospende il suo write callback; il resto del body rimane bufferizzato. |
| t2 | req termina; la pipe chiama busboy.end(); la finalizzazione attende dietro la write sospesa. |
| 100 ms | Il filtro 1 rifiuta → senza nulla in sospeso, viene eseguito done(err) → il client riceve 400. |
| tick successivo | setImmediate rimuove i listener di busboy — busboy ora non ha alcun listener 'error'. |
| 300 ms | Il filtro 2 richiama; errorOccured è impostato, quindi multer chiama fileStream.resume(). |
| 300 ms+ | busboy svuota il suo buffer e finalizza un body troncato → Error('Unexpected end of form'). |
| 300 ms++ | Node emette quell'errore su busboy; nessuno è in ascolto → eccezione non gestita → il processo termina. |
In produzione questo si presenta così: "la richiesta ha restituito un 400 pulito, e poi il server si è riavviato senza motivo." Quel ritardo tra la risposta e il crash è ciò che rende difficile la diagnosi.
Un'idea precedente era far lanciare un'eccezione a busboy dopo il teardown con un header di parte
malformato. Quel percorso è sicuro: l'errore viene lanciato sincronamente dall'interno di
FileStream._read, che Node avvolge in un try/catch e riemette sullo stream
del file — e multer mantiene un listener su ogni stream di file. Il fallimento di _final è
diverso: viene consegnato tramite il callback Writable di busboy su un tick successivo,
emesso su busboy stesso, dove il listener è già stato rimosso.
multer 2.5.0 mantiene un listener di errore no-op su busboy dopo il teardown, così un errore tardivo
non può più diventare un'eccezione non gestita
(commit 80a2d9d):
setImmediate(() => {
busboy.removeAllListeners()
// Keep an error listener so a late busboy error after teardown cannot
// crash the process; the request has already finished.
busboy.on('error', function () {})
})
La richiesta termina comunque con 400; la differenza è che il processo sopravvive.