CA2153: Evite lidar com exceções de estado corrompido

Motivo

Exceções de estado corrompidas (CSEs) indicam que existe corrupção de memória em seu processo. Detetá-los em vez de permitir que o processo falhe pode levar a vulnerabilidades de segurança se um invasor puder colocar uma exploração na região de memória corrompida.

Descrição da regra

CSE indica que o estado de um processo foi corrompido e não foi detetado pelo sistema. No cenário de estado corrompido, um manipulador geral só captura a exceção se você marcar seu método com o System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute atributo. Por padrão, o Common Language Runtime (CLR) não invoca manipuladores catch para CSEs.

A opção mais segura é permitir que o processo falhe sem capturar esses tipos de exceções. Até mesmo o código de registro pode permitir que invasores explorem bugs de corrupção de memória.

Esse aviso é acionado ao capturar CSEs com um manipulador geral que captura todas as exceções, por exemplo, catch (System.Exception e) ou catch sem nenhum parâmetro de exceção.

Como corrigir violações

Para resolver esse aviso, siga um destes procedimentos:

• Remova o HandleProcessCorruptedStateExceptionsAttribute atributo. Isto reverte para o comportamento padrão em tempo de execução, onde os CSEs não são passados para os handlers de captura.

• Remova o manipulador de captura geral em preferência aos manipuladores que capturam tipos de exceção específicos. Isso pode incluir CSEs, supondo que o código do manipulador possa manipulá-los com segurança (raro).

• Relance o CSE no manipulador de exceções, que passa a exceção para o chamador e deve resultar no encerramento do processo em execução.

Quando suprimir avisos

Não suprima um aviso desta regra.

Exemplo de pseudocódigo

Violação

O pseudocódigo a seguir ilustra o padrão detetado por essa regra.

[HandleProcessCorruptedStateExceptions]
// Method that handles CSE exceptions.
void TestMethod1()
{
    try
    {
        FileStream fileStream = new FileStream("name", FileMode.Create);
    }
    catch (Exception e)
    {
        // Handle exception.
    }
}

Solução 1 - remover o atributo

Remover o atributo HandleProcessCorruptedStateExceptionsAttribute garante que as exceções de estado corrompido não sejam tratadas pelo seu método.

void TestMethod1()
{
    try
    {
        FileStream fileStream = new FileStream("name", FileMode.Create);
    }
    catch (Exception e)
    {
        // Handle exception.
    }
}

Solução 2 - capturar exceções específicas

Remova o manipulador de captura geral e capture apenas tipos de exceção específicos.

void TestMethod1()
{
    try
    {
        FileStream fileStream = new FileStream("name", FileMode.Create);
    }
    catch (IOException e)
    {
        // Handle IOException.
    }
    catch (UnauthorizedAccessException e)
    {
        // Handle UnauthorizedAccessException.
    }
}

Solução 3 - lançar novamente

Relancem a exceção.

[HandleProcessCorruptedStateExceptions]
void TestMethod1()
{
    try
    {
        FileStream fileStream = new FileStream("name", FileMode.Create);
    }
    catch (Exception e)
    {
        // Rethrow the exception.
        throw;
    }
}