Aktivera Stöd för BinaryFormatter Urklipp (rekommenderas inte)

Försiktighet

BinaryFormatter support rekommenderas inte. Använd den bara som en tillfällig migreringsbrygga för äldre program som inte omedelbart kan migrera till de nya typsäkra API:erna. Den här metoden medför betydande säkerhetsrisker.

Den här artikeln visar hur du konfigurerar begränsat BinaryFormatter stöd för Åtgärder för Urklipp i Windows Forms i .NET 10. När BinaryFormatter togs bort från körningen i .NET 9 på grund av säkerhetsrisker, återställer du begränsad funktionalitet via explicit konfiguration för äldre program som behöver tid att migrera.

Fullständig migreringsvägledning till de nya typsäkra API:erna finns i Windows Forms Urklipp och DataObject-ändringar i .NET 10.

Viktigt!

Det här innehållet gäller endast för moderna .NET och inte .NET Framework, om inget annat anges.

Förutsättningar

Granska följande begrepp innan du fortsätter:

• Hur ditt program för närvarande använder BinaryFormatter i Urklippsåtgärder.
• Säkerhetsproblemen som ledde till borttagningen av BinaryFormatter.
• Din tidslinje för migrering till de nya api:erna för urklipp med typskydd.

Mer information finns i följande artiklar:

• Deserialiseringsrisker vid användning av BinaryFormatter och relaterade typer
• Migreringsguide för BinaryFormatter

Säkerhetsvarningar och risker

BinaryFormatter är i sig osäker och inaktuell av följande skäl:

• Sårbarheter för godtycklig kodkörning: Angripare kan köra skadlig kod under deserialiseringen och utsätta programmet för fjärrattacker.
• Överbelastningsattacker: Skadliga urklippsdata kan förbruka överdrivet mycket minne eller CPU-resurser, vilket kan orsaka krascher eller instabilitet.
• Risker för informationsläckage: Angripare kan extrahera känsliga uppgifter från minnet.
• Inga säkerhetsgränser: Formatet är i grunden osäkert och konfigurationsinställningarna kan inte skydda det.

Aktivera endast det här stödet som en tillfällig brygga när du uppdaterar programmet för att använda de nya typsäkra API:erna.

Installera kompatibilitetspaketet

Lägg till det kompatibilitetspaket BinaryFormatter som inte stöds i projektet. Det här paketet tillhandahåller nödvändigt körningsstöd för BinaryFormatter åtgärder:

<ItemGroup>
  <PackageReference Include="System.Runtime.Serialization.Formatters" Version="10.0.0*-*"/>
</ItemGroup>

Anmärkning

Det här paketet har markerats som inte stöds och är inaktuellt. Använd den endast för tillfällig kompatibilitet under migreringen.

Aktivera osäker serialisering i projektet

Ange egenskapen EnableUnsafeBinaryFormatterSerialization till true i projektfilen. Den här egenskapen instruerar kompilatorn att tillåta BinaryFormatter användning:

<PropertyGroup>
  <TargetFramework>net10.0</TargetFramework>
  <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
</PropertyGroup>

Utan den här inställningen genererar programmet kompileringsfel när det försöker använda BinaryFormatter API:er.

Konfigurera Windows Forms-körningsväxeln

Skapa eller uppdatera programmets fil för att aktivera den Windows Forms-specifika Urklippsväxeln runtimeconfig.json . Den här konfigurationen gör att Urklippsåtgärder kan återgå till BinaryFormatter när det behövs:

{
  "runtimeOptions": {
    "configProperties": {
      "Windows.ClipboardDragDrop.EnableUnsafeBinaryFormatterSerialization": true
    }
  }
}

Viktigt!

Utan denna specifika körningsväxel kommer urklippshanteringen inte att återgå till BinaryFormatter även om allmänt serialiseringsstöd är aktiverat. Den här växeln krävs specifikt för urklippsfunktionaliteten i Windows Forms och WPF.

Implementera säkerhetsfokuserade typlösare

Även med BinaryFormatter aktiverad implementerar du typlösare för att begränsa deserialisering till explicit godkända typer. Typlösare ger ditt enda skydd mot skadliga nyttolastattacker.

Skapa en säker typupplösare

// Create a security-focused type resolver
private static Type SecureTypeResolver(TypeName typeName)
{
    // Explicit allow-list of permitted types—add only what you need
    var allowedTypes = new Dictionary<string, Type>
    {
        ["MyApp.Person"] = typeof(Person),
        ["MyApp.AppSettings"] = typeof(AppSettings),
        ["System.String"] = typeof(string),
        ["System.Int32"] = typeof(int),
        // Add only the specific types your application requires
    };

    // Only allow explicitly listed types - exact string match required
    if (allowedTypes.TryGetValue(typeName.FullName, out Type allowedType))
    {
        return allowedType;
    }

    // Reject any type not in the allow-list with clear error message
    throw new InvalidOperationException(
        $"Type '{typeName.FullName}' is not permitted for clipboard deserialization");
}

' Create a security-focused type resolver
Private Shared Function SecureTypeResolver(typeName As TypeName) As Type
    ' Explicit allow-list of permitted types—add only what you need
    Dim allowedTypes As New Dictionary(Of String, Type) From {
        {"MyApp.Person", GetType(Person)},
        {"MyApp.AppSettings", GetType(AppSettings)},
        {"System.String", GetType(String)},
        {"System.Int32", GetType(Integer)}
    } ' Add only the specific types your application requires

    ' Only allow explicitly listed types - exact string match required
    Dim allowedType As Type = Nothing
    If allowedTypes.TryGetValue(typeName.FullName, allowedType) Then
        Return allowedType
    End If

    ' Reject any type not in the allow-list with clear error message
    Throw New InvalidOperationException(
        $"Type '{typeName.FullName}' is not permitted for clipboard deserialization")
End Function

Användning av typlösaren med urklippsåtgärder

// Use the resolver with clipboard operations
private static Type SecureTypeResolver(TypeName typeName)
{
    // Implementation from SecureTypeResolver example
    // ... (allow-list implementation here)
    throw new InvalidOperationException($"Type '{typeName.FullName}' is not permitted");
}

public static void UseSecureTypeResolver()
{
    // Retrieve legacy data using the secure type resolver
    if (Clipboard.TryGetData("LegacyData", SecureTypeResolver, out MyCustomType data))
    {
        ProcessLegacyData(data);
    }
    else
    {
        Console.WriteLine("No compatible data found on clipboard");
    }
}

' Use the resolver with clipboard operations
Private Shared Function SecureTypeResolver(typeName As TypeName) As Type
    ' Implementation from SecureTypeResolver example
    ' ... (allow-list implementation here)
    Throw New InvalidOperationException($"Type '{typeName.FullName}' is not permitted")
End Function

Public Shared Sub UseSecureTypeResolver()
    ' Retrieve legacy data using the secure type resolver
    Dim data As MyCustomType = Nothing
    If Clipboard.TryGetData("LegacyData", AddressOf SecureTypeResolver, data) Then
        ProcessLegacyData(data)
    Else
        Console.WriteLine("No compatible data found on clipboard")
    End If
End Sub

Säkerhetsriktlinjer för typlösare

Följ dessa viktiga säkerhetsriktlinjer när du implementerar typlösare:

Använda explicita tillåtna listor

• Avvisa som standard: Tillåt endast explicit listade typer.
• Inga jokertecken: Undvik mönstermatchning eller namnområdesbaserade behörigheter.
• Exakt matchning: Kräv exakta strängmatchningar för typnamn.

Verifiera alla ingångsdata

• Validering av typnamn: Kontrollera att typnamnen matchar förväntade format.
• Sammansättningsbegränsningar: Begränsa typer till kända, betrodda sammansättningar.
• Versionskontroll: Överväg versionsspecifika typbegränsningar.

Hantera okända typer på ett säkert sätt

• Utlösa undantag: Kasta alltid för obehöriga typer.
• Loggförsök: Överväg att logga obehöriga åtkomstförsök.
• Rensa felmeddelanden: Ange specifika avslagsorsaker för felsökning.

Regelbundet underhåll

• Granska regelbundet: Granska och uppdatera listan över tillåtna typer.
• Ta bort oanvända typer: Eliminera behörigheter för typer som inte längre behövs.
• Dokumentbeslut: Underhålla tydlig dokumentation om varför varje typ är tillåten.

Testa konfigurationen

När du har konfigurerat BinaryFormatter supporten testar du programmet så att det fungerar korrekt:

1. Verifiera urklippsoperationer: Testa både lagring och hämtning av data med dina anpassade typer.
2. Testtypslösare: Bekräfta att obehöriga typer avvisas korrekt.
3. Övervaka säkerheten: Håll utkik efter oväntade typupplösningsförsök.
4. Prestandatestning: Se till att typlösaren inte påverkar prestanda avsevärt.

public static void TestBinaryFormatterConfiguration()
{
    // Test data to verify configuration
    var testPerson = new Person { Name = "Test User", Age = 30 };

    try
    {
        // Test storing data (this should work with proper configuration)
        Clipboard.SetData("TestPerson", testPerson);
        Console.WriteLine("Successfully stored test data on clipboard");

        // Test retrieving with type resolver
        if (Clipboard.TryGetData("TestPerson", SecureTypeResolver, out Person retrievedPerson))
        {
            Console.WriteLine($"Successfully retrieved: {retrievedPerson.Name}, Age: {retrievedPerson.Age}");
        }
        else
        {
            Console.WriteLine("Failed to retrieve test data");
        }

        // Test that unauthorized types are rejected
        try
        {
            Clipboard.TryGetData("TestPerson", UnauthorizedTypeResolver, out Person _);
            Console.WriteLine("ERROR: Unauthorized type was not rejected!");
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine($"SUCCESS: Unauthorized type properly rejected - {ex.Message}");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Configuration test failed: {ex.Message}");
    }
}

private static Type SecureTypeResolver(TypeName typeName)
{
    var allowedTypes = new Dictionary<string, Type>
    {
        ["ClipboardExamples.Person"] = typeof(Person),
    };

    if (allowedTypes.TryGetValue(typeName.FullName, out Type allowedType))
    {
        return allowedType;
    }

    throw new InvalidOperationException($"Type '{typeName.FullName}' is not permitted");
}

private static Type UnauthorizedTypeResolver(TypeName typeName)
{
    // Intentionally restrictive resolver to test rejection
    throw new InvalidOperationException($"No types are permitted by this test resolver");
}

Public Shared Sub TestBinaryFormatterConfiguration()
    ' Test data to verify configuration
    Dim testPerson As New Person With {.Name = "Test User", .Age = 30}

    Try
        ' Test storing data (this should work with proper configuration)
        Clipboard.SetData("TestPerson", testPerson)
        Console.WriteLine("Successfully stored test data on clipboard")

        ' Test retrieving with type resolver
        Dim retrievedPerson As Person = Nothing
        If Clipboard.TryGetData("TestPerson", AddressOf SecureTypeResolver, retrievedPerson) Then
            Console.WriteLine($"Successfully retrieved: {retrievedPerson.Name}, Age: {retrievedPerson.Age}")
        Else
            Console.WriteLine("Failed to retrieve test data")
        End If

        ' Test that unauthorized types are rejected
        Try
            Dim testResult As Person = Nothing
            Clipboard.TryGetData("TestPerson", AddressOf UnauthorizedTypeResolver, testResult)
            Console.WriteLine("ERROR: Unauthorized type was not rejected!")
        Catch ex As InvalidOperationException
            Console.WriteLine($"SUCCESS: Unauthorized type properly rejected - {ex.Message}")
        End Try

    Catch ex As Exception
        Console.WriteLine($"Configuration test failed: {ex.Message}")
    End Try
End Sub

Private Shared Function SecureTypeResolver(typeName As TypeName) As Type
    Dim allowedTypes As New Dictionary(Of String, Type) From {
        {"ClipboardExamples.Person", GetType(Person)}
    }

    Dim allowedType As Type = Nothing
    If allowedTypes.TryGetValue(typeName.FullName, allowedType) Then
        Return allowedType
    End If

    Throw New InvalidOperationException($"Type '{typeName.FullName}' is not permitted")
End Function

Private Shared Function UnauthorizedTypeResolver(typeName As TypeName) As Type
    ' Intentionally restrictive resolver to test rejection
    Throw New InvalidOperationException($"No types are permitted by this test resolver")
End Function

Planera migreringsstrategin

Stöd BinaryFormatter ger tillfällig kompatibilitet, men utveckla en migreringsplan för att gå över till de nya typsäkra API:erna:

1. Identifiera användning: Katalogisera alla Urklippsåtgärder med hjälp av anpassade typer.
2. Prioritera migrering: Fokusera på de mest säkerhetskänsliga åtgärderna först.
3. Uppdatera stegvis: Migrera en åtgärd i taget för att minska risken.
4. Testa noggrant: Se till att nya implementeringar ger motsvarande funktioner.
5. Ta bort BinaryFormatter: Inaktivera stöd när migreringen är klar.

Rensa resurser

När du har migrerat till de nya api:erna för urklipp med typsäkerhet tar du bort konfigurationen BinaryFormatter för att förbättra säkerheten:

1. Ta bort paketreferensen System.Runtime.Serialization.Formatters .
2. Ta bort egenskapen EnableUnsafeBinaryFormatterSerialization från projektfilen.
3. Ta bort inställningen Windows.ClipboardDragDrop.EnableUnsafeBinaryFormatterSerialization från din runtimeconfig.json.
4. Ta bort typlösarimplementeringar som inte längre behövs.

Relaterat innehåll

• Ändringar i Urklipp och Dataobjekt i .NET 10
• Så här lägger du till data i Urklipp
• Hämta data från Urklipp
• Migreringsguide för BinaryFormatter
• Deserialiseringsrisker vid användning av BinaryFormatter och relaterade typer