Caricare una foto del profilo, allegare un documento o importare un file CSV sono operazioni comuni in moltissime applicazioni web. Dal punto di vista dell'utente sembrano funzionalità semplici, ma dal punto di vista della sicurezza introducono una serie di rischi che non dovrebbero essere sottovalutati.
Il problema non è consentire il caricamento di file in sé. Il rischio nasce quando l'applicazione si fida troppo dei dati ricevuti, salva i file in posizioni inadeguate o permette che vengano interpretati ed eseguiti dal server.
Un sistema di upload progettato male può causare esposizione di informazioni, attacchi contro altri utenti, consumo eccessivo delle risorse o, nei casi più gravi, compromissione del server.
Vediamo quali controlli sono importanti per realizzare un upload di file sicuro e come verificare le configurazioni di un'applicazione esistente.
Perché il caricamento dei file è una superficie d'attacco
Quando un utente invia un file, l'applicazione riceve dati che possono essere stati creati e modificati liberamente.
Il nome del file, l'estensione, i metadati e persino il tipo dichiarato nella richiesta possono essere falsificati. Inoltre, un file apparentemente innocuo può contenere dati malformati, contenuti attivi o strutture progettate per sfruttare vulnerabilità nel software che lo elabora.
Per questo motivo, non è sufficiente verificare che l'utente abbia selezionato un'immagine o un documento con l'estensione corretta.
L'applicazione deve stabilire quali file accettare, verificarne le caratteristiche, limitarne le dimensioni e conservarli in modo da impedire che diventino un rischio per il sistema.
1. Non fidarsi dell'estensione del file
Uno degli errori più comuni consiste nel controllare soltanto il nome del file.
Per esempio, un'applicazione potrebbe accettare qualsiasi file che termini con .jpg, presumendo che si tratti necessariamente di un'immagine.
In realtà, l'estensione è soltanto una parte del nome e non garantisce il contenuto effettivo del file.
Anche l'header Content-Type inviato dal browser non è una prova affidabile: il client può dichiarare un tipo diverso da quello reale.
Una validazione più robusta dovrebbe combinare diversi controlli:
- elenco ristretto delle estensioni consentite;
- verifica del tipo effettivo del file tramite strumenti appropriati;
- controlli sulla struttura e sulla validità del contenuto;
- limiti sulle dimensioni;
- eventuale scansione antimalware, in base al rischio e al tipo di file.
Per le immagini, può essere utile decodificare il contenuto con una libreria affidabile e, quando possibile, ricodificarlo in un formato previsto dall'applicazione. Questo può rimuovere metadati indesiderati e strutture non necessarie, pur non sostituendo gli altri controlli.
2. Impedire l'esecuzione dei file caricati
Un rischio particolarmente importante riguarda le applicazioni che salvano i file caricati all'interno di una directory pubblica del sito.
Se il server web interpreta alcuni file come codice eseguibile e la configurazione consente l'esecuzione nella directory di upload, un file malevolo potrebbe diventare un punto d'ingresso.
La soluzione preferibile è conservare i file caricati in una posizione che non consenta l'esecuzione di codice.
Quando devono essere scaricati dagli utenti, l'applicazione può servirli attraverso un endpoint dedicato, verificando i permessi prima di restituire il contenuto.
Se i file vengono conservati in una directory pubblica, occorre configurare il server in modo da impedire l'esecuzione di script e verificare che tale protezione sia effettiva anche nelle sottodirectory.
È importante non affidarsi esclusivamente a regole basate sul nome del file: configurazioni errate o differenze tra server possono produrre comportamenti inattesi.
3. Generare nomi di file sicuri
Utilizzare direttamente il nome ricevuto dal client può introdurre problemi di sicurezza e gestione.
Un nome potrebbe contenere sequenze inattese, caratteri speciali o riferimenti a percorsi differenti. Se viene utilizzato senza adeguate precauzioni, può favorire vulnerabilità di tipo path traversal o causare sovrascritture accidentali.
Una soluzione consiste nel generare un identificativo interno univoco e conservare separatamente il nome originale, se serve mostrarlo all'utente.
Per esempio, invece di salvare un documento usando direttamente il nome inviato dal browser, l'applicazione potrebbe assegnargli un identificativo casuale e registrare nel database l'associazione con l'utente proprietario.
Questo approccio aiuta a evitare collisioni, semplifica la gestione dei permessi e riduce la dipendenza dai nomi forniti dall'esterno.
Il nome originale, se conservato, deve essere trattato come dato non attendibile anche quando viene mostrato in una pagina web o inserito nei log.
4. Prevenire il path traversal
Il path traversal è una vulnerabilità che può verificarsi quando dati controllati dall'utente vengono utilizzati per costruire percorsi del filesystem senza una validazione adeguata.
Nel contesto degli upload, il problema può riguardare sia il percorso in cui il file viene salvato sia quello utilizzato successivamente per recuperarlo.
L'applicazione non dovrebbe permettere al client di scegliere liberamente la directory di destinazione. Il percorso deve essere determinato dal server, all'interno di una posizione autorizzata.
Quando è necessario gestire percorsi dinamici, occorre normalizzarli e verificare che la destinazione finale rimanga all'interno della directory prevista. Anche in questo caso è preferibile usare identificativi generati dal server invece di costruire percorsi direttamente a partire dall'input.
5. Limitare dimensioni e quantità dei file
Un upload può essere utilizzato per consumare spazio disco, memoria, CPU o capacità di elaborazione.
Un file molto grande potrebbe saturare lo spazio disponibile. Un archivio compresso di dimensioni ridotte potrebbe espandersi fino a occupare molto più spazio. Un documento malformato potrebbe richiedere risorse eccessive durante l'elaborazione.
Per ridurre questi rischi è opportuno definire:
- dimensione massima per ogni file;
- numero massimo di file per richiesta;
- quota di spazio per utente;
- limiti sulla frequenza dei caricamenti;
- timeout e limiti di risorse per le elaborazioni;
- controlli sui file compressi, quando supportati.
I limiti devono essere applicati anche a livello di server web e infrastruttura, non soltanto nell'interfaccia grafica.
Se un'applicazione elabora archivi, immagini ad alta risoluzione o documenti complessi, deve considerare anche il costo dell'elaborazione successiva al caricamento.
6. Attenzione a SVG, HTML e altri formati attivi
Non tutti i formati che sembrano documenti o immagini sono equivalenti dal punto di vista della sicurezza.
Alcuni formati possono contenere markup, riferimenti esterni o elementi attivi che, se serviti o visualizzati nel contesto sbagliato, possono introdurre rischi per gli utenti.
Un file SVG, per esempio, è basato su XML e può includere funzionalità che richiedono particolare attenzione. Anche HTML, XML e documenti complessi possono diventare pericolosi se vengono elaborati o visualizzati senza controlli appropriati.
Se l'applicazione non ha una reale necessità di accettare questi formati, è spesso preferibile escluderli.
Quando sono indispensabili, occorre stabilire come verranno elaborati e serviti, evitare di inserirli direttamente nel contesto del sito principale senza protezioni e valutare la conversione in formati più semplici.
7. Proteggere i file privati
Non tutti i file caricati devono essere pubblici.
Fatture, documenti personali, contratti e allegati di assistenza possono contenere informazioni riservate. Anche se il file non è eseguibile, renderlo accessibile a chiunque conosca l'URL può costituire una violazione della riservatezza.
L'applicazione dovrebbe verificare l'autorizzazione dell'utente prima di consentire il download.
È importante controllare che:
- l'identificativo del file non sia l'unica barriera di sicurezza;
- un utente non possa scaricare file appartenenti a un altro account;
- i link temporanei abbiano scadenze e permessi appropriati;
- le directory private non siano esposte accidentalmente dal server;
- i backup dei file siano protetti con controlli equivalenti.
Un URL difficile da indovinare non sostituisce un vero controllo di accesso.
8. Come gestire l'upload in un'applicazione PHP
In PHP, i file caricati tramite un modulo vengono normalmente resi disponibili attraverso la variabile superglobale $_FILES.
Un errore da evitare è spostare immediatamente il file nella directory pubblica senza averne controllato l'esito del caricamento, le dimensioni e il tipo.
Un esempio minimale di controlli iniziali può essere il seguente:
<?php
if (!isset($_FILES['documento'])) {
http_response_code(400);
exit('File mancante.');
}
$file = $_FILES['documento'];
if ($file['error'] !== UPLOAD_ERR_OK) {
http_response_code(400);
exit('Caricamento non riuscito.');
}
$maxSize = 5 * 1024 * 1024; // 5 MB
if ($file['size'] <= 0 || $file['size'] > $maxSize) {
http_response_code(400);
exit('Dimensione non consentita.');
}
$finfo = new finfo(FILEINFO_MIME_TYPE);
$mime = $finfo->file($file['tmp_name']);
$allowedTypes = [
'image/jpeg' => 'jpg',
'image/png' => 'png',
];
if (!isset($allowedTypes[$mime])) {
http_response_code(400);
exit('Formato non consentito.');
}
// Proseguire con la validazione del contenuto,
// i controlli sui permessi e il salvataggio sicuro.
Questo frammento mostra soltanto alcuni controlli iniziali: non è un sistema di upload completo e non va considerato sufficiente da solo per la produzione.
In una reale implementazione occorre anche verificare l'autorizzazione dell'utente, la struttura del file, l'eventuale corrispondenza tra estensione e formato, la generazione del nome, la destinazione di salvataggio e le regole del server. Per le immagini può essere utile una ricodifica tramite una libreria affidabile.
È inoltre importante configurare correttamente i limiti PHP, come upload_max_filesize e post_max_size, insieme ai limiti del server web e dell'applicazione.
9. Checklist per verificare la sicurezza degli upload
Se gestisci un sito web o un'applicazione che permette di caricare file, puoi partire da questi controlli:
- [ ] Sono accettati soltanto i formati realmente necessari?
- [ ] Il tipo del file viene verificato sul server?
- [ ] Esistono limiti di dimensione, quantità e frequenza?
- [ ] I nomi dei file vengono generati o normalizzati in modo sicuro?
- [ ] Il percorso di salvataggio è controllato dall'applicazione?
- [ ] I file non possono essere eseguiti come codice?
- [ ] I file privati richiedono un'autorizzazione prima del download?
- [ ] I formati attivi o complessi vengono esclusi oppure gestiti con precauzioni specifiche?
- [ ] Le directory di upload e i relativi backup sono protetti?
- [ ] Sono previsti log, monitoraggio e procedure per eliminare file sospetti?
Questi controlli dovrebbero essere ripetuti quando si modificano il codice di upload, la configurazione del server o le librerie che elaborano i file.
Conclusione
Un caricamento sicuro richiede molto più di un controllo sull'estensione. Validazione del contenuto, limiti sulle risorse, nomi sicuri, archiviazione protetta e autorizzazioni sono elementi essenziali per ridurre i rischi.
Con MiHakero puoi analizzare i domini, le applicazioni web, le API e i servizi pubblici alla ricerca di esposizioni e configurazioni problematiche rilevabili dall'esterno. Per verificare la sicurezza completa delle funzionalità di upload è importante affiancare l'analisi esterna a test applicativi autorizzati e a una revisione dei controlli implementati sul server.