Procedure consigliate per l'uso degli archivi ZIP e TAR in .NET

Questo articolo illustra le procedure consigliate per l'uso degli archivi ZIP e TAR in .NET. Si apprenderà come scegliere l'API appropriata per lo scenario, usare i metodi pratici in modo efficace per l'input attendibile e gestire in modo sicuro gli archivi non attendibili per proteggersi da attacchi comuni, ad esempio gli attraversamenti di percorsi e le bombe zip.

.NET offre il supporto predefinito per due dei formati di archivio più comuni:

Scegliere l'API corretta

.NET offre due categorie di API di archiviazione. Selezionare la categoria corrispondente allo scenario.

Se si controlla l'origine di archiviazione (il proprio output di compilazione, backup noti), le API di comodità sono la scelta più semplice. Se l'archivio proviene da un'origine esterna (caricamenti, download, trasferimenti di rete), usare le API di streaming con i controlli di sicurezza descritti in questo articolo.

Caution

Gli archivi ZIP e TAR differiscono in modo significativo in ciò che archiviano. ZIP trasmette principalmente i file, mentre TAR trasmette una topologia completa del file system, inclusi i tipi di file, i collegamenti simbolici, i collegamenti rigidi, le autorizzazioni e altri metadati. Questa differenza ha importanti implicazioni per la sicurezza: la struttura più avanzata di TAR offre a un avversario più modi per influenzare il modo in cui i dati vengono rappresentati su disco, ben oltre i nomi file e il contenuto dei file. Prestare particolare attenzione durante l'elaborazione di archivi TAR non attendibili.

API di comodità (operazioni una tantum)

Usare queste API per creare o estrarre un intero archivio in una singola chiamata. Sono ideali per scenari semplici e attendibili.

Ideale per: flussi di lavoro semplici con input attendibile, script rapidi e strumenti di compilazione.

API di streaming (controllo voce per voce)

Utilizzare queste API per ottenere un controllo completo su ogni elemento di archivio. Sono essenziali per grandi archivi o input non attendibili.

Ideale per: archivi di grandi dimensioni, estrazione selettiva, input non attendibile ed elaborazione personalizzata.

Tip

Importare lo System.IO.Compression spazio dei nomi per accedere ai metodi di estensione su ZipArchive e ZipArchiveEntry.

Usare archivi attendibili

Quando l'origine dell'archivio è nota e attendibile, i metodi di convenienza offrono un percorso di estrazione in una sola riga:

  • ZipFile.ExtractToDirectory e TarFile.ExtractToDirectory validano automaticamente i percorsi di ingresso entro i limiti della directory di destinazione specificata. Questi controlli non garantiscono il contenimento sul disco: un junction preesistente o un collegamento simbolico nel percorso di destinazione può reindirizzare le scritture all'esterno di tale directory.

  • ZipFile.ExtractToDirectory dispone di sovraccarichi che di default non sovrascrivono i file esistenti. Tutti gli TarFile.ExtractToDirectory overload richiedono il overwriteFiles parametro, quindi è sempre necessario scegliere in modo esplicito.

  • Quando la sovrascrittura è abilitata durante l'estrazione ZIP, .NET estrae prima in un file temporaneo e sostituisce solo la destinazione dopo l'estrazione riuscita. In questo modo si evita un danneggiamento parziale se l'estrazione non riesce.

  • L'estrazione TAR gestisce la sovrascrittura in modo diverso: elimina il file esistente prima di scrivere la sostituzione. Se l'estrazione ha esito negativo dopo l'eliminazione (ad esempio, a causa di un errore di I/O o un'interruzione del processo), il file originale viene perso e la sostituzione potrebbe essere incompleta. Valutare la possibilità di eseguire il backup di file critici prima della sovrascrittura con l'estrazione tar.

Avvertimento

Usare i ExtractToDirectory metodi di utilità solo su input attendibili. Sia per ZIP che per TAR, la convalida del percorso offre solo un tentativo nei limiti del possibile di mantenere l'estrazione all'interno della directory di destinazione specificata, non una garanzia. Ad esempio, una giunzione preesistente o un collegamento simbolico nella directory di destinazione o una delle sue directory padre può reindirizzare le scritture anche quando i percorsi convalidati sembrano rimanere all'interno della destinazione. Per indicazioni, vedere Verificare i percorsi di destinazione per una nuova destinazione controllata dall'applicazione.

Questi helper inoltre non applicano limiti di dimensione, limiti di conteggio delle voci o altri criteri necessari per l'estrazione sicura di archivi non attendibili. Per applicare questi limiti, anche per l'input attendibile, usare l'approccio di streaming descritto in Gestire gli archivi non attendibili in modo sicuro. Le API di streaming non offrono una garanzia di contenimento: è necessario convalidare manualmente i percorsi e controllare la directory di destinazione.

Gestire gli archivi non attendibili in modo sicuro

Per l'input non attendibile, ovvero caricamenti utente, download di terze parti o trasferimenti di rete, iterate manualmente le voci e applicate i vostri propri controlli di sicurezza. Le sottosezioni seguenti descrivono cosa è necessario applicare e perché.

Applicare i limiti relativi alle dimensioni e al numero di voci

Né ZipArchive né TarReader limitano la dimensione totale non compressa o il numero di voci estratte, e lo stesso vale per i metodi pratici ExtractToDirectory. È necessario applicare questi limiti manualmente.

Importante

Un piccolo file compresso può espandersi fino a terabyte di dati, noto come bomba zip. Le bombe zip sono disponibili in due forme:

  • Piatto (non ricorsivo): Un singolo archivio contiene molte voci che, quando decompressi, espandono a una grande dimensione. DEFLATE ottiene rapporti fino a ~1032×, quindi 100 KB di dati compressi possono espandersi a ~100 MB. L'aumento del numero di voci o delle dimensioni delle voci produce terabyte di output in un singolo passaggio di estrazione. Queste bombe sono efficaci contro qualsiasi parser zip, incluso .NET.
  • Ricorsivo (annidato): Un archivio contiene archivi interni, ciascuno contenente più archivi, moltiplicando l'espansione a ogni livello. Il classico 42.zip usa cinque livelli di 16 file zip annidati per raggiungere 4,5 PB. Tuttavia, .NET ExtractToDirectory non estrae in modo ricorsivo gli archivi interni, li tratta come file opachi, quindi le bombe ricorsive non sono un problema a meno che il codice non apra nuovamente gli archivi estratti.

Applicare sempre limiti alle dimensioni decompresse e al numero di elementi durante l'estrazione di archivi non attendibili.

  • Applicare i limiti delle dimensioni per voce

    void SafeExtractEntry(ZipArchiveEntry entry, string destinationPath, long maxDecompressedSize)
    {
        // The runtime enforces that entry.Open() will never produce more than
        // entry.Length bytes, so checking the declared size is sufficient.
        if (entry.Length > maxDecompressedSize)
        {
            throw new InvalidOperationException(
                $"Entry '{entry.FullName}' declares size {entry.Length}, exceeding limit {maxDecompressedSize}.");
        }
    
        entry.ExtractToFile(destinationPath, overwrite: false);
    }
    
  • Tenere traccia delle dimensioni e del numero di voci di aggregazione

    void SafeExtractArchive(ZipArchive archive, string destinationDir,
        long maxTotalSize, int maxEntryCount)
    {
        // Flat zip bombs can contain many entries that each expand to large sizes.
        // Reject the archive early if the entry count exceeds your limit.
        if (archive.Entries.Count > maxEntryCount)
        {
            throw new InvalidOperationException("Archive contains an excessive number of entries.");
        }
    
        long totalExtracted = 0;
        foreach (ZipArchiveEntry entry in archive.Entries)
        {
            totalExtracted = checked(totalExtracted + entry.Length);
            if (totalExtracted > maxTotalSize)
            {
                throw new InvalidOperationException(
                    $"Archive total decompressed size exceeds the allowed limit of {maxTotalSize} bytes.");
            }
            // ... extract each entry with per-entry limits too
        }
    }
    

Tip

Lo stesso approccio si applica agli archivi TAR. Poiché i file TAR vengono letti voce per voce tramite GetNextEntry, tenere traccia delle dimensioni cumulative dei dati e del conteggio delle voci mentre si itera.

Convalidare i nomi di file

A seconda del file system, alcuni caratteri potrebbero non essere consentiti nei nomi file (o consentiti solo in determinate posizioni) o hanno un significato speciale. Le applicazioni devono verificare che i nomi estratti siano conformi a un modello accettabile.

Convalidare i percorsi di destinazione

Quando si utilizzano le API di streaming, si è responsabili di convalidare il percorso di destinazione di ciascuna voce. Non eseguono alcuna convalida del percorso.

Per ogni voce, risolvere la destinazione in un percorso assoluto e verificare che sia inclusa nella directory di destinazione:

void ValidatePaths(ZipArchive archive, string destinationDir)
{
    string fullDestDir = Path.GetFullPath(destinationDir);
    if (!fullDestDir.EndsWith(Path.DirectorySeparatorChar))
        fullDestDir += Path.DirectorySeparatorChar;

    foreach (ZipArchiveEntry entry in archive.Entries)
    {
        string destPath = Path.GetFullPath(Path.Join(fullDestDir, entry.FullName));

        if (!destPath.StartsWith(fullDestDir, StringComparison.Ordinal))
            throw new IOException(
                $"Entry '{entry.FullName}' would extract outside the destination directory.");
    }
}

Punti principali:

  • Path.GetFullPath() risolve segmenti relativi come ../ in un percorso assoluto.
  • Il StartsWith controllo garantisce che il percorso risolto sia ancora all'interno della destinazione.
  • Il separatore di directory finale in fullDestDir è fondamentale—senza di esso, un percorso come /safe-dir-evil/file corrisponderebbe in modo errato a /safe-dir.

Note

La validazione dei confini presuppone che la directory di destinazione stessa sia una directory reale sotto il proprio controllo. Se la directory di destinazione o una delle relative directory padre è già una giunzione o un collegamento simbolico, l'estrazione segue quel collegamento e scrive nella destinazione a cui punta, anche quando il percorso risolto di ciascun elemento sembra comunque rimanere all'interno della destinazione. Quando si gestiscono archivi non attendibili, estrarli in una nuova directory controllata dall'applicazione anziché in una directory già usata o scrivibile da terzi.

Avvertimento

Le seguenti API non forniscono alcuna protezione contro l'attraversamento del percorso. È necessario convalidare manualmente i percorsi prima di chiamarli.

Modello vulnerabile: NON USARE senza convalida:

void DangerousExtract(string extractDir)
{
    // ⚠️ DANGEROUS: entry.FullName could contain "../" sequences
    using ZipArchive archive = ZipFile.OpenRead("archive.zip");
    foreach (ZipArchiveEntry entry in archive.Entries)
    {
        string destinationPath = Path.Combine(extractDir, entry.FullName);
        entry.ExtractToFile(destinationPath, overwrite: true); // Might write outside of `extractDir`
    }
}

Gli archivi TAR supportano collegamenti simbolici e collegamenti rigidi, che introducono vettori di attacco oltre l'attraversamento del percorso di base:

  • Evasione dei collegamenti simbolici: Una voce di collegamento simbolico punta a un percorso arbitrario (ad esempio, /etc/), quindi una voce di file successiva relativa alla directory del collegamento simbolico scrive tramite il collegamento a tale posizione esterna.
  • Collegamento rigido al file sensibile: Una destinazione di collegamento rigido fa riferimento a un file all'esterno della directory di estrazione. Poiché un collegamento rigido condivide lo stesso inode dell'originale, qualsiasi codice che successivamente apre il collegamento rigido per la scrittura (ad esempio, con File.Create o File.WriteAllText) modifica il contenuto del file originale.

L'approccio più sicuro per gli archivi non attendibili consiste nell'ignorare completamente le voci di collegamento:

if (entry.EntryType is TarEntryType.SymbolicLink or TarEntryType.HardLink)
    continue; // Skip link entries for untrusted input

Se è necessario mantenere i collegamenti, verificare che la destinazione del collegamento venga risolta all'interno della directory di destinazione prima di crearla:

bool IsLinkTargetSafe(TarEntry entry, string fullDestDir)
{
    // A symlink with an absolute (rooted) target is resolved from the filesystem root, not from the extraction directory.
    if (Path.IsPathRooted(entry.LinkName))
        return false;

    if (!fullDestDir.EndsWith(Path.DirectorySeparatorChar))
        fullDestDir += Path.DirectorySeparatorChar;

    string resolvedTarget;

    if (entry.EntryType is TarEntryType.SymbolicLink)
    {
        // Symlink targets are relative to the symlink's own parent directory, or absolute.
        string entryDir = Path.GetDirectoryName(
            Path.GetFullPath(Path.Join(fullDestDir, entry.Name)))!;
        resolvedTarget = Path.GetFullPath(Path.Join(entryDir, entry.LinkName));
    }
    else
    {
        // Hard link targets are relative to the destination directory root.
        resolvedTarget = Path.GetFullPath(Path.Join(fullDestDir, entry.LinkName));
    }

    return resolvedTarget.StartsWith(fullDestDir, StringComparison.Ordinal);
}

Se il caso d'uso richiede l'estrazione di archivi con collegamenti rigidi, ma si desidera evitare collegamenti rigidi su disco, TarHardLinkMode.CopyContents copia il contenuto del file invece di creare un collegamento rigido. In questo modo si eliminano gli attacchi basati su collegamento rigido e si produce un output più portabile in Windows.

Per riferimento, TarFile.ExtractToDirectory convalida sia il percorso di ingresso che il percorso di destinazione del collegamento rispetto al limite della directory di destinazione. Se uno di essi viene risolto esternamente, viene lanciata un'eccezione IOException. TarEntry.ExtractToFile rifiuta interamente le voci di collegamenti simbolici e rigidi e genera InvalidOperationException.

Bit di autorizzazione di immissione (solo Unix)

Nei sistemi di tipo Unix, le API di convenienza applicano i bit di permesso dai metadati dell'archivio al file o alla directory estratti. Queste autorizzazioni potrebbero essere troppo ampie per lo scenario dell'applicazione. Nell'applicazione potrebbe essere necessario impedire l'estrazione di file con autorizzazioni eseguibili impostate. Per altre informazioni, vedere la sezione Autorizzazioni per i file Unix di questo articolo.

Esempi di estrazione sicura completi

Combinare la convalida dell'attraversamento del percorso, i limiti delle dimensioni, i limiti del numero di voci e la gestione dei collegamenti in un singolo ciclo di estrazione.

  • ZIP

    Il metodo seguente estrae un archivio ZIP applicando tutti i controlli di sicurezza consigliati:

    void SafeExtractZip(string archivePath, string destinationDir,
        long maxTotalSize, long maxEntrySize, int maxEntryCount)
    {
        // Resolve the destination to an absolute path and ensure it ends with a
        // directory separator. This trailing separator is essential — without it,
        // the StartsWith check below could be tricked by paths like
        // "/safe-dir-evil/" matching "/safe-dir".
        string fullDestDir = Path.GetFullPath(destinationDir);
        if (!fullDestDir.EndsWith(Path.DirectorySeparatorChar))
            fullDestDir += Path.DirectorySeparatorChar;
    
        Directory.CreateDirectory(fullDestDir);
    
        using var archive = new ZipArchive(File.OpenRead(archivePath), ZipArchiveMode.Read);
    
        // Check the entry count up front. ZIP central directory is read eagerly,
        // so archive.Entries.Count is available immediately without iterating.
        if (archive.Entries.Count > maxEntryCount)
            throw new InvalidOperationException("Archive contains too many entries.");
    
        long totalSize = 0;
        foreach (ZipArchiveEntry entry in archive.Entries)
        {
            // Enforce per-entry and cumulative size limits using the declared uncompressed size.
            totalSize += entry.Length;
            if (entry.Length > maxEntrySize)
                throw new InvalidOperationException(
                    $"Entry '{entry.FullName}' exceeds per-entry size limit.");
            if (totalSize > maxTotalSize)
                throw new InvalidOperationException("Archive exceeds total size limit.");
    
            // The entry Name can contain arbitrary characters. Some characters might not be
            // allowed on certain filesystems or have a special meaning. Applications should
            // apply their own policies regarding allowed filenames. ValidateName is a placeholder
            // for such a policy.
            if (!ValidateName(entry.FullName))
            {
                throw new IOException($"Entry name '{entry.FullName}' is not allowed.");
            }
    
            // ExternalAttributes carry permission bits for Unix platforms. Clearing the
            // attributes enforces extraction with default file permissions.
            entry.ExternalAttributes = 0;
    
            // Resolve the full destination path using Path.GetFullPath, which
            // normalizes away any "../" segments. Then verify the result still
            // starts with the destination directory.
            string destPath = Path.GetFullPath(Path.Join(fullDestDir, entry.FullName));
            if (!destPath.StartsWith(fullDestDir, StringComparison.Ordinal))
                throw new IOException(
                    $"Entry '{entry.FullName}' would extract outside the destination.");
    
            // By convention, directory entries in ZIP archives have names ending
            // in '/'. Path.GetFileName returns empty for these, so we use that
            // to distinguish directories from files.
            if (string.IsNullOrEmpty(Path.GetFileName(destPath)))
            {
                Directory.CreateDirectory(destPath);
            }
            else
            {
                // Create the parent directory and any missing intermediate directories.
                Directory.CreateDirectory(Path.GetDirectoryName(destPath)!);
                entry.ExtractToFile(destPath, overwrite: false);
            }
        }
    }
    
  • TAR

    L'estrazione TAR è diversa da ZIP per diversi aspetti: le voci vengono lette in sequenza (non esiste una directory centrale), le voci di collegamento richiedono una gestione esplicita e DataStream deve essere consumato prima di passare alla voce successiva.

    void SafeExtractTar(Stream archiveStream, string destinationDir,
        long maxTotalSize, long maxEntrySize, int maxEntryCount)
    {
        // Same trailing-separator technique as the ZIP example.
        string fullDestDir = Path.GetFullPath(destinationDir);
        if (!fullDestDir.EndsWith(Path.DirectorySeparatorChar))
            fullDestDir += Path.DirectorySeparatorChar;
    
        Directory.CreateDirectory(fullDestDir);
    
        using var reader = new TarReader(archiveStream);
        TarEntry? entry;
        long totalSize = 0;
        int entryCount = 0;
    
        // TAR has no central directory — entries are read one at a time.
        // GetNextEntry() returns null when the archive is exhausted.
        while ((entry = reader.GetNextEntry()) is not null)
        {
            if (++entryCount > maxEntryCount)
                throw new InvalidOperationException("Archive contains too many entries.");
    
            if (entry.Length > maxEntrySize)
                throw new InvalidOperationException(
                    $"Entry '{entry.Name}' exceeds per-entry size limit.");
            totalSize += entry.Length;
            if (totalSize > maxTotalSize)
                throw new InvalidOperationException("Archive exceeds total size limit.");
    
            // Allow-list of entry types to process. Any type not listed here is
            // silently skipped. We exclude symlinks, hard links (which can
            // escape the destination), and metadata types
            // (GlobalExtendedAttributes, ExtendedAttributes, LongLink, and
            // LongPath) that contain no file data.
            TarEntryType[] allowedTypes =
            [
                TarEntryType.RegularFile,
                TarEntryType.V7RegularFile,
                TarEntryType.ContiguousFile,
                TarEntryType.Directory
            ];
    
            if (!allowedTypes.Contains(entry.EntryType))
                continue;
    
            // The entry Name can contain arbitrary characters. Some characters might not be
            // allowed on certain filesystems or have a special meaning. Applications should
            // apply their own policies regarding allowed filenames. ValidateName is a placeholder
            // for such a policy.
            if (!ValidateName(entry.Name))
            {
                throw new IOException($"Entry name '{entry.Name}' is not allowed.");
            }
    
            // Mask the entry's permission bits to a safe subset.
            // This subset depends on your application's needs.
            const UnixFileMode PermittedFileModes =
                UnixFileMode.UserRead | UnixFileMode.UserWrite |
                UnixFileMode.GroupRead |
                UnixFileMode.OtherRead;
    
            const UnixFileMode PermittedDirectoryModes =
                PermittedFileModes |
                UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute;
    
            if (entry.EntryType == TarEntryType.Directory)
            {
                entry.Mode &= PermittedDirectoryModes;
            }
            else
            {
                entry.Mode &= PermittedFileModes;
            }
    
            // Normalize and validate the path, same as the ZIP example.
            string destPath = Path.GetFullPath(Path.Join(fullDestDir, entry.Name));
            if (!destPath.StartsWith(fullDestDir, StringComparison.Ordinal))
                throw new IOException(
                    $"Entry '{entry.Name}' would extract outside the destination.");
    
            if (entry.EntryType is TarEntryType.Directory)
            {
                Directory.CreateDirectory(destPath);
            }
            else
            {
                // Create the parent directory and any missing intermediate directories.
                Directory.CreateDirectory(Path.GetDirectoryName(destPath)!);
                entry.ExtractToFile(destPath, overwrite: false);
            }
        }
    }
    

Considerazioni sulla memoria e sulle prestazioni

Comprendere come .NET gestisce la memoria per le operazioni ZIP e TAR consente di evitare problemi imprevisti con archivi di grandi dimensioni o non attendibili.

Utilizzo della memoria ZipArchive

Non usare ZipArchiveMode.Update per archivi di grandi dimensioni o non attendibili. Quando si apre un ZipArchive in modalità Update e si chiama Open o OpenAsync su una voce, i dati non compressi vengono caricati in un oggetto MemoryStream per supportare le modifiche in situ. L'accesso ai metadati delle voci , ad esempio FullName, Lengtho ExternalAttributes, non attiva la decompressione. Per archivi di grandi dimensioni o dannosi, l'apertura dei flussi di contenuto di immissione può causare OutOfMemoryException. Controllare Length prima di chiamare Open per evitare di decomprimere voci di dimensioni inaspettatamente grandi.

Inoltre, quando si apre un oggetto ZipArchive in ZipArchiveMode.Read modalità con un flusso non visualizzabile (ad esempio, un flusso di rete), il runtime memorizza nel buffer l'intero contenuto dell'archivio in memoria per consentire la ricerca tramite la directory centrale.

Raccomandazione: Usare la modalità Update solo per archivi che si conoscono essere abbastanza piccoli da adattarsi alla memoria. ZipArchiveMode.Read e ZipArchiveMode.Create sono modalità più sicure perché trasmettono i dati di immissione in streaming anziché memorizzarli interamente nel buffer in memoria. Per modificare un archivio di grandi dimensioni, aprire l'originale in Read modalità , creare un nuovo archivio in Create modalità e copiare in modo selettivo le voci:

void StreamingModify()
{
    // ✅ Streaming approach for large archives
    using var input = new ZipArchive(File.OpenRead("large.zip"), ZipArchiveMode.Read);
    using var output = new ZipArchive(File.Create("modified.zip"), ZipArchiveMode.Create);

    foreach (var entry in input.Entries)
    {
        if (ShouldKeep(entry))
        {
            var newEntry = output.CreateEntry(entry.FullName);
            using var src = entry.Open();
            using var dst = newEntry.Open();
            src.CopyTo(dst);
        }
    }
}

bool ShouldKeep(ZipArchiveEntry entry) => true;

Modello di streaming TAR

System.Formats.Tar.TarReader legge le voci una alla volta e non memorizza nel buffer l'intero archivio. Tuttavia, per i flussi non visualizzabili, ogni voce TarEntry.DataStream è valida solo fino alla chiamata successiva TarReader.GetNextEntry . Se è necessario conservare i dati di immissione, copiarli immediatamente in un elemento separato MemoryStream che rimane valido dopo l'avanzamento.

Avvertimento

Evitare di usare TarReader.GetNextEntry con copyContents: true su archivi non attendibili, poiché alloca una quantità di memoria potenzialmente elevata per consentire a MemoryStream di contenere il contenuto dell'elemento. Passa copyContents: false e verifica la dimensione dell'elemento prima di materializzare manualmente il contenuto.

void TarStreamingRead(Stream archiveStream, string destDir)
{
    using var reader = new TarReader(archiveStream);
    TarEntry? entry;
    while ((entry = reader.GetNextEntry()) is not null)
    {
        if (entry.DataStream is not null)
        {
            // DataStream is only valid until the next GetNextEntry() call,
            // so consume
            string destPath = Path.Join(destDir, entry.Name);
            using var fileStream = File.Create(destPath);
            entry.DataStream.CopyTo(fileStream);

            // Alternatively, you can copy the entry contents into
            // in a separate MemoryStream that remains valid after advancing:
            if (entry.Length < 1_000_000) // Example limit
            {
                MemoryStream memoryStream = new MemoryStream();
                entry.DataStream.CopyTo(memoryStream);
                // memoryStream can be used after GetNextEntry() is called again
            }
        }
    }
}

Sicurezza dei thread

System.IO.Compression.ZipArchive, System.Formats.Tar.TarReader e System.Formats.Tar.TarWriter non sono thread-safe. Non accedere a un'istanza da più thread contemporaneamente. Se è necessario leggere più archivi in parallelo, aprire un'istanza separata per ogni thread. Per la scrittura, sincronizzare l'accesso esternamente: più scrittori non possono accedere in sicurezza al medesimo file di archivio contemporaneamente.

Considerazioni relative alla piattaforma

Il comportamento dell'archivio può variare tra Windows e Unix. Tenere presenti queste differenze durante la scrittura di codice multipiattaforma.

Autorizzazioni per i file Unix

  • ZIP: Le autorizzazioni Unix vengono archiviate nei 16 bit superiori di ZipArchiveEntry.ExternalAttributes. Quando si estrae su Unix tramite ExtractToDirectory o ExtractToFile, il runtime ripristina le autorizzazioni di proprietà (lettura/scrittura/esecuzione per utente/gruppo/altro), soggetto al processo umask. SetUID, SetGID e StickyBit vengono rimossi. Le autorizzazioni non vengono applicate se i bit superiori sono zero. Ciò si verifica quando il file ZIP è stato creato in Windows, perché .NET in Windows imposta DefaultFileExternalAttributes su 0. In Windows questi attributi vengono sempre ignorati durante l'estrazione.
  • TAR: La TarEntry.Mode proprietà rappresenta UnixFileMode e può archiviare tutti i 12 bit di autorizzazione (lettura/scrittura/esecuzione per utente/gruppo/altro, più SetUID, SetGID e StickyBit). Quando si estrae su Unix tramite ExtractToDirectory o ExtractToFile, il runtime applica solo i 9 bit di proprietà (rwx per user/group/other), soggetti al processo umask. SetUID, SetGID e StickyBit vengono rimossi per motivi di sicurezza.

Quando si elaborano archivi non attendibili, tenere presente che i file estratti potrebbero avere autorizzazioni eseguibili impostate dall'autore dell'archivio. Gli archivi non attendibili potrebbero contenere file eseguibili dannosi. Poiché ZipArchiveEntry.ExternalAttributes e TarEntry.Mode sono scrivibili, è possibile modificarli prima dell'estrazione:

foreach (ZipArchiveEntry entry in archive.Entries)
{
    // Unset the external attributes to force extraction with default Unix permission bits.
    entry.ExternalAttributes = 0;

    // .. other validation omitted for brevity

    Directory.CreateDirectory(Path.GetDirectoryName(destPath)!);
    entry.ExtractToFile(destPath, overwrite: false);
}

const UnixFileMode PermittedFileModes =
    UnixFileMode.UserRead | UnixFileMode.UserWrite |
    UnixFileMode.GroupRead |
    UnixFileMode.OtherRead;

const UnixFileMode PermittedDirectoryModes =
    PermittedFileModes |
    UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute;

while ((entry = reader.GetNextEntry()) is not null)
{
    if (entry.EntryType == TarEntryType.Directory)
    {
        entry.Mode &= PermittedDirectoryModes;
    }
    else
    {
        entry.Mode &= PermittedFileModes;
    }
}

Tipi di voce speciali (TAR)

I dispositivi a blocchi, i dispositivi carattere e le FIFO possono essere creati solo su Unix. L'estrazione di questi in Windows genera un'eccezione. I privilegi elevati sono necessari per creare voci del dispositivo a blocchi e caratteri.

La purificazione dei nomi di file è diversa dalla piattaforma

In Windows, quando si usa ExtractToDirectory, il runtime sostituisce i caratteri di controllo e "*:<>?| con caratteri di sottolineatura nei nomi delle voci. In Unix vengono sostituiti solo i caratteri Null. Le voci di archivio con nomi come file:name.txt vengono rinominate in file_name.txt in Windows ma estratte as-is in Unix. Le API per singolo elemento (Open(), ExtractToFile()) non eseguono alcuna sanitizzazione dei nomi, quindi quando vengono utilizzate con nomi di elementi provenienti da archivi non attendibili, convalidare il nome e il percorso prima di eseguire l'estrazione (come illustrato nella sezione Convalida percorsi di destinazione).

Integrità dei dati

Gli archivi ZIP e TAR usano controlli di integrità diversi. ZIP archivia i valori CRC-32 per i dati di immissione. TAR archivia un checksum per ogni intestazione.

A partire da .NET 11, il runtime convalida automaticamente i valori ZIP CRC-32 durante la lettura delle voci ZIP. Quando si legge il flusso di dati di una voce fino al completamento, il runtime confronta il valore CRC-32 calcolato dei dati decompressi rispetto al valore archiviato nell'archivio. Se i valori non corrispondono, viene generata un'eccezione InvalidDataException . A partire da .NET 11, il runtime convalida anche i checksum dell'intestazione TAR durante la lettura delle intestazioni di voce TAR.

Note

Nelle versioni precedenti a .NET 11, il runtime non ha convalidato i valori ZIP CRC-32 in lettura. Il runtime ha calcolato i valori CRC-32 durante la scrittura di voci ZIP per l'archiviazione nell'archivio, ma non le ha verificate durante l'estrazione. Se si fa riferimento a un runtime precedente a .NET 11, le voci ZIP danneggiate o manomesse potrebbero essere accettate automaticamente.

CRC-32 non è un hash crittografico, ma rileva il danneggiamento accidentale, ma non protegge da manomissioni intenzionali da un utente malintenzionato sofisticato.

Metadati non attendibili

Commenti ZIP e campi aggiuntivi

  • I commenti di archiviazione e immissione sono stringhe arbitrarie. Se l'applicazione visualizza o elabora i commenti, purificarli in modo appropriato.
  • I campi aggiuntivi sono coppie di chiavi e valori binarie associate a ciascuna voce. Il runtime preserva campi aggiuntivi sconosciuti e dati rimanenti durante la lettura e la scrittura di archivi in modalità ZipArchiveMode.Update, trasportandoli esattamente come sono. Se l'applicazione legge o interpreta campi aggiuntivi, convalidarne il contenuto.
  • Codifica dei nomi delle voci di ingresso: durante la scrittura, il runtime utilizza ASCII per i nomi delle voci che contengono solo caratteri stampabili ASCII (32-126) e UTF-8 (con il flag di codifica della lingua attivato) per i nomi che includono altri caratteri. Quando si legge senza una codifica personalizzata, le voci, indipendentemente dalla presenza dell'indicatore di codifica della lingua, vengono decodificate come UTF-8 (che inoltre decodifica correttamente anche l'ASCII). Usare il parametro entryNameEncoding su ZipArchive per eseguire l'override della codifica quando necessario, ma tenere presente che l'override influisce in modo uniforme su tutte le voci.
  • Gli attributi estesi PAX (PaxTarEntry.ExtendedAttributes) sono un set arbitrario e fornito dall'archivio di stringhe chiave-valore. Una voce PAX può contenere molti attributi e i singoli valori possono essere di grandi dimensioni. Il formato usa anche questi attributi per eseguire l'override dei campi di intestazione standard, ad esempio il percorso di immissione, il nome del collegamento e le dimensioni. Considerarli come input non attendibili: se l'applicazione legge o agisce su attributi estesi, convalidarne il contenuto e impostare limiti sul numero di processi e su quanto possono essere grandi.
  • I nomi di collegamento (TarEntry.LinkName) nelle voci di collegamento simbolico e hard link sono percorsi forniti dall'archivio. Convalidarli nello stesso modo in cui si convalidano i nomi delle voci. Vedere Gestire collegamenti simbolici e hard link (TAR).

Considerazioni sulla crittografia (.NET 11+)

.NET 11 aggiunge il supporto per la lettura e la scrittura di archivi ZIP crittografati. Le sottosezioni seguenti illustrano come scegliere un metodo di crittografia, leggere le voci crittografate e usare archivi crittografati con le API utili.

Note

Il supporto della crittografia ZIP (ZipCrypto e WinZip AES) è una novità di .NET 11.

L'enumerazione ZipEncryptionMethod specifica il metodo di crittografia:

Value Descrizione
None Nessuna crittografia.
ZipCrypto Crittografia ZIP obsoleta. Usare solo per la compatibilità con le versioni precedenti, vulnerabile agli attacchi in testo non crittografato noti.
Aes128 WinZip AES-128.
Aes192 WinZip AES-192.
Aes256 WinZip AES-256. Consigliata: opzione più sicura disponibile.
Unknown Restituito quando la voce usa un metodo di crittografia che .NET non supporta.

Scegliere AES-256 per i nuovi archivi

Quando si creano voci crittografate, preferite Aes256 sempre. ZipCrypto è un metodo legacy con punti deboli crittografici noti e non deve essere usato per la sicurezza, usarlo solo quando si interagisce con gli strumenti che non supportano WinZip AES.

string password = "your-password-here";

// ⚠️ Weak encryption — use only for backward compatibility
archive.CreateEntry("file.txt", password, ZipEncryptionMethod.ZipCrypto);

// ✅ Prefer AES-256
archive.CreateEntry("file.txt", password, ZipEncryptionMethod.Aes256);

Leggere gli elementi crittografati

Usare ZipArchiveEntry.EncryptionMethod per controllare il metodo di crittografia e fornire una password a Open:

using ZipArchive archive = ZipFile.OpenRead("encrypted.zip");

foreach (ZipArchiveEntry entry in archive.Entries)
{
    if (entry.EncryptionMethod == ZipEncryptionMethod.Unknown)
    {
        // Unsupported encryption method, skip this entry
        continue;
    }

    using Stream stream = entry.Open("myPassword");
    // ... read the decrypted data
}

Importante

ZipArchive non garantisce l'integrità di un archivio o delle relative voci. Se l'applicazione richiede garanzie di integrità, stabilirle tramite un canale attendibile separato prima dell'estrazione.

Il runtime non garantisce che il codice HMAC (Hash-Based Message Authentication Code) incorporato in una voce WinZip AES venga convalidato. Ad esempio, la convalida potrebbe non essere eseguita se non si legge il flusso di dati fino alla fine o se l'input è malformato. Leggere il flusso alla fine per consentire l'esecuzione della convalida, ma non considerare tale passaggio come garanzia di integrità. Il runtime può restituire tutti i dati immessi all'applicazione prima del completamento della convalida.

Il tentativo di aprire un elemento utilizzante un metodo di crittografia non supportato (ZipEncryptionMethod.Unknown) genera NotSupportedException.

Metodi pratici con la crittografia

I nuovi tipi di opzione consentono di passare una password e un metodo di crittografia alle API di praticità:

// Extract an encrypted archive
ZipFile.ExtractToDirectory("encrypted.zip", destDir, new ZipExtractionOptions
{
    Password = "myPassword".AsMemory(),
    OverwriteFiles = false
});

// Create an encrypted archive
ZipFile.CreateFromDirectory(sourceDir, "encrypted.zip", new ZipFileCreationOptions
{
    Password = "myPassword".AsMemory(),
    EncryptionMethod = ZipEncryptionMethod.Aes256,
    CompressionLevel = CompressionLevel.Optimal
});

Elenco di controllo delle procedure consigliate

Prima di distribuire il codice che gestisce gli archivi da origini non attendibili, verificare di aver risolto ognuna delle operazioni seguenti:

  • Iterazione manuale: Non usare ExtractToDirectory per l'input non attendibile: effettua manualmente l'iterazione delle voci per imporre tutti i limiti.
  • Attraversamento del percorso: Convalidare tutti i percorsi di destinazione con Path.GetFullPath() + StartsWith().
  • Caratteri speciali nei nomi: Verificare che i nomi delle voci siano conformi ai criteri definiti dall'applicazione.
  • Bombe di decompressione: Applicare limiti alle dimensioni decompresse (per elemento e totale) e al numero di elementi.
  • Attacchi symlink/hardlink (TAR): Convalidare che le destinazioni dei collegamenti si risolvano all'interno della destinazione prevista, o ignorare interamente le voci di collegamento.
  • Autorizzazioni Unix: Convalidare i bit di autorizzazione di ogni voce. Ignora le voci con autorizzazioni eccessivamente ampie oppure maschera/modifica i bit di autorizzazione indesiderati prima dell'estrazione.
  • Limiti di memoria: Evitare ZipArchiveMode.Update di archiviare grandi archivi non attendibili. Evitare la modalità ZipArchiveMode.Read con flussi non ricercabili da origini non attendibili.
  • Thread safety: Non condividere istanze di ZipArchive, System.Formats.Tar.TarReader, o System.Formats.Tar.TarWriter tra thread.
  • Metadati non attendibili: Considerare i nomi delle voci, i nomi dei collegamenti, i commenti, i campi aggiuntivi ZIP e gli attributi estesi TAR PAX come input non attendibile. Convalidarli e impostare limiti prima della visualizzazione o dell'elaborazione.
  • Comportamento di sovrascrittura: Il valore predefinito è overwrite: false.
  • Eliminazione delle risorse: Eliminare sempre System.IO.Compression.ZipArchive, TarReader, TarWriter e i relativi flussi.