Come gestisci i caricamenti di file in modo sicuro?

Question

Accepted Answer

**Il caricamento di file** è una funzionalità comune ma un rischio di sicurezza significativo — i file dannosi possono portare all'esecuzione di codice, alla distribuzione di malware o al compromesso del sistema. Proteggere i caricamenti richiede la convalida dei tipi di file, delle dimensioni e del contenuto, l'archiviazione sicura dei file e il loro servizio accurato.

## I rischi del caricamento di file

```text
Allowing users to upload files is dangerous if not secured:
  ✗ MALICIOUS executable/script files → could run on the server (e.g. uploading a web
    shell / script that gets executed → server compromise)
  ✗ MALWARE distribution (files served to other users)
  ✗ Oversized files → denial of service (disk/memory exhaustion)
  ✗ Path traversal in filenames (../../) → overwrite system files
  ✗ Files with misleading types/content (a .jpg that's actually a script)
```

## Proteggere i caricamenti di file

```text
✓ VALIDATE file TYPE → check the actual CONTENT/MIME (not just the extension, which lies);
  ALLOWLIST permitted types (don't blocklist); reject everything else
✓ LIMIT file SIZE → prevent resource exhaustion (max upload size)
✓ Don't execute uploads → store OUTSIDE the web root; never serve from an executable
  directory; serve via a handler (not directly executable)
✓ RENAME files (random/generated names) → avoid path traversal and overwrites; sanitize
  filenames
✓ SCAN for malware where appropriate; set correct Content-Type/Content-Disposition when serving
✓ Use separate storage/domain or object storage (S3) for user files; access controls
```

## Perché è importante

Comprendere la gestione sicura del caricamento di file è importante perché **il caricamento di file è una funzionalità comune con rischi di sicurezza significativi**, quindi gestirli in modo sicuro è essenziale, rendendo questa una conoscenza di sicurezza pratica preziosa.

Consenti agli utenti di caricare file introduce pericoli seri: **file eseguibili/script dannosi** che potrebbero essere eseguiti sul server (come una web shell che porta al compromesso completo del server — un rischio grave), distribuzione di malware ad altri utenti, denial of service da file di grandi dimensioni, **path traversal** nei nomi file (sovrascrittura di file di sistema), e file con tipi fuorvianti (un .jpg che è in realtà uno script).

Questi rendono i caricamenti di file non protetti una funzionalità pericolosa e comunemente sfruttata.

Comprendere come **proteggere i caricamenti** è la conoscenza pratica chiave: **convalidare il tipo di file in base al contenuto effettivo/MIME** (non solo l'estensione, che può essere ingannosa) e **creare una lista di indirizzi IP consentiti** per i tipi consentiti, **limitare la dimensione del file** (prevenendo l'esaurimento delle risorse), crucialmente **non eseguire i caricamenti** (archiviarli al di fuori della radice web e non servire mai da una directory eseguibile — prevenendo lo scenario pericoloso di esecuzione del codice), **rinominare i file** con nomi generati e disinfettare i nomi file (prevenendo path traversal e sovrascritture), scansionare il malware ove appropriato, impostare i tipi di contenuto corretti durante il servizio, e utilizzare spazio di archiviazione separato (come object storage) con controlli di accesso.

Queste misure affrontano i rischi specifici dei caricamenti.

Poiché il caricamento di file è una funzionalità comune con rischi significativi e gravi (in particolare il compromesso del server tramite caricamenti eseguibili) e proteggerli richiede misure specifiche (convalida di tipo/dimensione, archiviazione non eseguibile, ridenominazione, servizio accurato), e poiché la comprensione di questo è essenziale per qualsiasi applicazione con caricamenti, comprendere la gestione sicura del caricamento di file è una conoscenza di sicurezza preziosa e praticamente rilevante — importante per la funzionalità comune e rischiosa dei caricamenti, affrontando vulnerabilità gravi (esecuzione del codice, path traversal, DoS) con difese specifiche, e conoscenza essenziale per qualsiasi sviluppatore che costruisce funzionalità di caricamento.