CA2301: No llamar a BinaryFormatter.Deserialize sin establecer primero BinaryFormatter.Binder

Artículo
04/07/2023

Propiedad	Value
Identificador de la regla	CA2301
Título	No llamar a BinaryFormatter.Deserialize sin establecer primero BinaryFormatter.Binder
Categoría	Seguridad
La corrección interrumpe o no interrumpe	Poco problemático
Habilitado de forma predeterminada en .NET 8	No

Causa

Se llamó a un método de deserialización System.Runtime.Serialization.Formatters.Binary.BinaryFormatter o se hizo referencia a él sin la propiedad Binder establecida.

De forma predeterminada, esta regla analiza todo el código base, pero esto es configurable.

Advertencia

Restringir los tipos con un SerializationBinder no puede evitar todos los ataques. Para obtener más información, vea Guía de seguridad de BinaryFormatter.

Descripción de la regla

Los deserializadores no seguros son vulnerables al deserializar datos que no son de confianza. Un atacante podría modificar los datos serializados para incluir tipos inesperados a fin de insertar objetos con efectos secundarios malintencionados. Un ataque contra un deserializador inseguro podría, por ejemplo, ejecutar comandos en el sistema operativo subyacente, comunicarse a través de la red o eliminar archivos.

Esta regla busca llamadas o referencias al método de deserialización System.Runtime.Serialization.Formatters.Binary.BinaryFormatter, cuando BinaryFormatter no tiene su Binder establecido. Si quiere impedir la deserialización con BinaryFormatter independientemente de la propiedad Binder, deshabilite esta regla y CA2302 y habilite la regla CA2300.

Cómo corregir infracciones

En su lugar, use un serializador seguro y no permita que un atacante especifique un tipo arbitrario para deserializar. Para obtener más información, vea Alternativas preferidas.
Proteja los datos serializados contra alteraciones. Después de la serialización, firme criptográficamente los datos serializados. Antes de la deserialización, valide la firma criptográfica. Proteja la clave criptográfica para que no se revele y diseñe rotaciones de clave.
Esta opción hace que el código sea vulnerable a ataques por denegación de servicio y posibles ataques de ejecución remota de código en el futuro. Para obtener más información, vea Guía de seguridad de BinaryFormatter. Restrinja los tipos deserializados. Implemente un elemento System.Runtime.Serialization.SerializationBinder personalizado. Antes de la deserialización, establezca la propiedad Binder en una instancia del elemento SerializationBinder personalizado en todas las rutas de acceso del código. En el método BindToType invalidado, si el tipo es inesperado, inicie una excepción para detener la deserialización.

Cuándo suprimir las advertencias

BinaryFormatter no es seguro y no se puede convertir en seguro.

Configuración del código para analizar

Use las opciones siguientes para configurar en qué partes del código base se va a ejecutar esta regla.

Exclusión de símbolos específicos
Exclusión de tipos específicos y sus tipos derivados

Puede configurar estas opciones solo para esta regla, para todas las reglas a las que se aplica o para todas las reglas de esta categoría (Seguridad) a las que se aplica. Para más información, vea Opciones de configuración de reglas de calidad de código.

Exclusión de símbolos específicos

Puede excluir símbolos específicos, como tipos y métodos, del análisis. Por ejemplo, para especificar que la regla no se debe ejecutar en ningún código dentro de los tipos con el nombre MyType, agregue el siguiente par clave-valor a un archivo .editorconfig en el proyecto:

dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType

Formatos de nombre de símbolo permitidos en el valor de opción (separados por |):

Solo nombre de símbolo (incluye todos los símbolos con el nombre, con independencia del tipo contenedor o el espacio de nombres).
Nombres completos en el formato de id. de documentación del símbolo. Cada nombre de símbolo necesita un prefijo de tipo símbolo, como M: para los métodos, T: para los tipos y N: para los espacios de nombres.
.ctor para los constructores y .cctor para los constructores estáticos.

Ejemplos:

Valor de la opción	Resumen
`dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType`	Coincide con todos los símbolos denominados `MyType`.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType1\|MyType2`	Coincide con todos los símbolos denominados `MyType1` o `MyType2`.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS.MyType.MyMethod(ParamType)`	Coincide con un método `MyMethod` concreto con la signatura completa especificada.
`dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS1.MyType1.MyMethod1(ParamType)\|M:NS2.MyType2.MyMethod2(ParamType)`	Coincide con los métodos `MyMethod1` y `MyMethod2` concretos con las signaturas completas especificadas.

Exclusión de tipos específicos y sus tipos derivados

Puede excluir tipos específicos y sus tipos derivados del análisis. Por ejemplo, para especificar que la regla no se debe ejecutar en ningún método dentro de los tipos con el nombre MyType y sus tipos derivados, agregue el siguiente par clave-valor a un archivo .editorconfig en el proyecto:

dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType

Formatos de nombre de símbolo permitidos en el valor de opción (separados por |):

Solo nombre de tipo (incluye todos los tipos con el nombre, con independencia del tipo contenedor o el espacio de nombres).
Nombres completos en el formato de identificador de documentación del símbolo, con un prefijo T: opcional.

Ejemplos:

Valor de la opción	Resumen
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType`	Coincide con todos los tipos denominados `MyType` y todos sus tipos derivados.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType1\|MyType2`	Coincide con todos los tipos denominados `MyType1` o `MyType2`, y todos sus tipos derivados.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS.MyType`	Coincide con un tipo `MyType` específico con el nombre completo dado y todos sus tipos derivados.
`dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS1.MyType1\|M:NS2.MyType2`	Coincide con los tipos `MyType1` y `MyType2` específicos con los correspondientes nombres completos y todos sus tipos derivados.

Ejemplos de pseudocódigo

Infracción

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
public class BookRecord
{
    public string Title { get; set; }
    public AisleLocation Location { get; set; }
}

[Serializable]
public class AisleLocation
{
    public char Aisle { get; set; }
    public byte Shelf { get; set; }
}

public class ExampleClass
{
    public BookRecord DeserializeBookRecord(byte[] bytes)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        using (MemoryStream ms = new MemoryStream(bytes))
        {
            return (BookRecord) formatter.Deserialize(ms);
        }
    }
}

Imports System
Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary

<Serializable()>
Public Class BookRecord
    Public Property Title As String
    Public Property Location As AisleLocation
End Class

<Serializable()>
Public Class AisleLocation
    Public Property Aisle As Char
    Public Property Shelf As Byte
End Class

Public Class ExampleClass
    Public Function DeserializeBookRecord(bytes As Byte()) As BookRecord
        Dim formatter As BinaryFormatter = New BinaryFormatter()
        Using ms As MemoryStream = New MemoryStream(bytes)
            Return CType(formatter.Deserialize(ms), BookRecord)
        End Using
    End Function
End Class

Solución

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class BookRecordSerializationBinder : SerializationBinder
{
    public override Type BindToType(string assemblyName, string typeName)
    {
        // One way to discover expected types is through testing deserialization
        // of **valid** data and logging the types used.

        ////Console.WriteLine($"BindToType('{assemblyName}', '{typeName}')");

        if (typeName == "BookRecord")
        {
            return typeof(BookRecord);
        }
        else if (typeName == "AisleLocation")
        {
            return typeof(AisleLocation);
        }
        else
        {
            throw new ArgumentException("Unexpected type", nameof(typeName));
        }
    }
}

[Serializable]
public class BookRecord
{
    public string Title { get; set; }
    public AisleLocation Location { get; set; }
}

[Serializable]
public class AisleLocation
{
    public char Aisle { get; set; }
    public byte Shelf { get; set; }
}

public class ExampleClass
{
    public BookRecord DeserializeBookRecord(byte[] bytes)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        formatter.Binder = new BookRecordSerializationBinder();
        using (MemoryStream ms = new MemoryStream(bytes))
        {
            return (BookRecord) formatter.Deserialize(ms);
        }
    }
}

Imports System
Imports System.IO
Imports System.Runtime.Serialization
Imports System.Runtime.Serialization.Formatters.Binary

Public Class BookRecordSerializationBinder
    Inherits SerializationBinder

    Public Overrides Function BindToType(assemblyName As String, typeName As String) As Type
        ' One way to discover expected types is through testing deserialization
        ' of **valid** data and logging the types used.

        'Console.WriteLine($"BindToType('{assemblyName}', '{typeName}')")

        If typeName = "BinaryFormatterVB.BookRecord" Then
            Return GetType(BookRecord)
        Else If typeName = "BinaryFormatterVB.AisleLocation" Then
            Return GetType(AisleLocation)
        Else
            Throw New ArgumentException("Unexpected type", NameOf(typeName))
        End If
    End Function
End Class

<Serializable()>
Public Class BookRecord
    Public Property Title As String
    Public Property Location As AisleLocation
End Class

<Serializable()>
Public Class AisleLocation
    Public Property Aisle As Char
    Public Property Shelf As Byte
End Class

Public Class ExampleClass
    Public Function DeserializeBookRecord(bytes As Byte()) As BookRecord
        Dim formatter As BinaryFormatter = New BinaryFormatter()
        formatter.Binder = New BookRecordSerializationBinder()
        Using ms As MemoryStream = New MemoryStream(bytes)
            Return CType(formatter.Deserialize(ms), BookRecord)
        End Using
    End Function
End Class

CA2300: No usar el deserializador no seguro BinaryFormatter

CA2302: Asegurarse de que BinaryFormatter.Binder está establecido antes de llamar a BinaryFormatter.Deserialize

CA2301: No llamar a BinaryFormatter.Deserialize sin establecer primero BinaryFormatter.Binder

Causa

Descripción de la regla

Cómo corregir infracciones

Cuándo suprimir las advertencias

Configuración del código para analizar

Exclusión de símbolos específicos

Exclusión de tipos específicos y sus tipos derivados

Ejemplos de pseudocódigo

Infracción

Solución

Comentarios

Recursos adicionales

CA2301: No llamar a BinaryFormatter.Deserialize sin establecer primero BinaryFormatter.Binder

Causa

Descripción de la regla

Cómo corregir infracciones

Cuándo suprimir las advertencias

Configuración del código para analizar

Exclusión de símbolos específicos

Exclusión de tipos específicos y sus tipos derivados

Ejemplos de pseudocódigo

Infracción

Solución

Reglas relacionadas

Comentarios

Recursos adicionales