CA5389: Lägg inte till arkivobjektets sökväg till målfilens systemsökväg

Artikel
02/15/2024

Property	Värde
Regel-ID	CA5389
Title	Lägg inte till arkivobjektets sökväg till målfilens systemsökväg
Kategori	Säkerhet
Korrigeringen är icke-bakåtkompatibel	Icke-icke-bryta
Aktiverad som standard i .NET 9	Nej

Orsak

En icke-sanerad källfilsökväg används som målfilsökväg i någon av följande parametrar:

parameter för destinationFileName metoden ZipFileExtensions.ExtractToFile
parameter för path metoden File.Open
parameter för path metoden File.OpenWrite
parameter för path metoden File.Create
parameter för path konstruktor för FileStream
parameter för fileName konstruktor för FileInfo

Som standard analyserar den här regeln hela kodbasen, men detta kan konfigureras.

Regelbeskrivning

Filsökvägen kan vara relativ och kan leda till filsystemåtkomst utanför den förväntade målsökvägen för filsystemet, vilket leder till skadliga konfigurationsändringar och fjärrkodkörning via lay-and-wait-teknik.

Så här åtgärdar du överträdelser

Använd inte källfilsökvägen för att konstruera målfilens sökväg eller kontrollera att det sista tecknet på extraheringssökvägen är katalogavgränsarens tecken.

När du ska ignorera varningar

Du kan ignorera den här varningen om källsökvägen alltid kommer från en betrodd källa.

Ignorera en varning

Om du bara vill förhindra en enda överträdelse lägger du till förprocessordirektiv i källfilen för att inaktivera och aktiverar sedan regeln igen.

#pragma warning disable CA5389
// The code that's violating the rule is on this line.
#pragma warning restore CA5389

Om du vill inaktivera regeln för en fil, mapp eller ett projekt anger du dess allvarlighetsgrad till none i konfigurationsfilen.

[*.{cs,vb}]
dotnet_diagnostic.CA5389.severity = none

Mer information finns i Så här utelämnar du kodanalysvarningar.

Konfigurera kod för analys

Använd följande alternativ för att konfigurera vilka delar av kodbasen som regeln ska köras på.

Exkludera specifika symboler
Exkludera specifika typer och deras härledda typer

Du kan konfigurera dessa alternativ för bara den här regeln, för alla regler som den gäller för eller för alla regler i den här kategorin (säkerhet) som den gäller för. Mer information finns i Konfigurationsalternativ för kodkvalitetsregel.

Exkludera specifika symboler

Du kan exkludera specifika symboler, till exempel typer och metoder, från analys. Om du till exempel vill ange att regeln inte ska köras på någon kod inom typer med namnet MyTypelägger du till följande nyckel/värde-par i en .editorconfig-fil i projektet:

dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType

Tillåtna symbolnamnformat i alternativvärdet (avgränsade med |):

Endast symbolnamn (innehåller alla symboler med namnet, oavsett vilken typ eller namnrymd som innehåller).
Fullständigt kvalificerade namn i symbolens dokumentations-ID-format. Varje symbolnamn kräver ett symboltypprefix, till exempel M: för metoder, T: för typer och N: för namnområden.
.ctor för konstruktorer och .cctor statiska konstruktorer.

Exempel:

Alternativvärde	Sammanfattning
`dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType`	Matchar alla symboler med namnet `MyType`.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType1\|MyType2`	Matchar alla symboler med namnet antingen `MyType1` eller `MyType2`.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS.MyType.MyMethod(ParamType)`	Matchar en specifik metod `MyMethod` med den angivna fullständigt kvalificerade signaturen.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS1.MyType1.MyMethod1(ParamType)\|M:NS2.MyType2.MyMethod2(ParamType)`	Matchar specifika metoder `MyMethod1` och `MyMethod2` med respektive fullständigt kvalificerade signaturer.

Exkludera specifika typer och deras härledda typer

Du kan exkludera specifika typer och deras härledda typer från analys. Om du till exempel vill ange att regeln inte ska köras på några metoder inom typer som heter MyType och deras härledda typer lägger du till följande nyckel/värde-par i en .editorconfig-fil i projektet:

dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType

Tillåtna symbolnamnformat i alternativvärdet (avgränsade med |):

Skriv endast namn (innehåller alla typer med namnet, oavsett vilken typ eller namnrymd som innehåller).
Fullständigt kvalificerade namn i symbolens dokumentations-ID-format, med ett valfritt T: prefix.

Exempel:

Alternativvärde	Sammanfattning
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType`	Matchar alla typer med namnet `MyType` och alla deras härledda typer.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType1\|MyType2`	Matchar alla typer med namnet antingen `MyType1` eller `MyType2` och alla deras härledda typer.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS.MyType`	Matchar en specifik typ `MyType` med ett angivet fullständigt kvalificerat namn och alla dess härledda typer.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS1.MyType1\|M:NS2.MyType2`	Matchar specifika typer `MyType1` och `MyType2` med respektive fullständigt kvalificerade namn och alla deras härledda typer.

Exempel

Följande kodfragment illustrerar det mönster som identifieras av den här regeln.

Kränkning:

using System.IO.Compression;

class TestClass
{
    public void TestMethod(ZipArchiveEntry zipArchiveEntry)
    {
        zipArchiveEntry.ExtractToFile(zipArchiveEntry.FullName);
    }
}

Lösning:

using System;
using System.IO;
using System.IO.Compression;

class Program
{
    static void Main(string[] args)
    {
        string zipPath = @".\result.zip";

        Console.WriteLine("Provide path where to extract the zip file:");
        string extractPath = Console.ReadLine();

        // Normalizes the path.
        extractPath = Path.GetFullPath(extractPath);

        // Ensures that the last character on the extraction path
        // is the directory separator char.
        // Without this, a malicious zip file could try to traverse outside of the expected
        // extraction path.
        if (!extractPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
            extractPath += Path.DirectorySeparatorChar;

        using (ZipArchive archive = ZipFile.OpenRead(zipPath))
        {
            foreach (ZipArchiveEntry entry in archive.Entries)
            {
                if (entry.FullName.EndsWith(".txt", StringComparison.OrdinalIgnoreCase))
                {
                    // Gets the full path to ensure that relative segments are removed.
                    string destinationPath = Path.GetFullPath(Path.Combine(extractPath, entry.FullName));

                    // Ordinal match is safest, case-sensitive volumes can be mounted within volumes that
                    // are case-insensitive.
                    if (destinationPath.StartsWith(extractPath, StringComparison.Ordinal))
                        entry.ExtractToFile(destinationPath);
                }
            }
        }
    }
}

Dela via