Prevenindo ataques de injeção em ASP.NET [Tradução]

Autor：Eve Cole Data da Última Atualização：2009-06-30 16:03:51

Fonte: MSDN
Tradução:

Escopo de aplicação do Yunzhongcheng BLOG:

ASP.NET versão 1.1
ASP.NET versão 2.0

Resumo:

Este texto apresenta principalmente como verificar a entrada do usuário para evitar ataques de injeção. É muito necessário verificar a entrada do usuário. Quase todos os ataques em nível de programa contêm métodos de entrada maliciosos

. itens de entrada são usados para proteger seu programa contra ataques de injeção. Você deve assumir que todas as entradas do usuário são maliciosas e garantir que todas as entradas do usuário sejam verificadas no lado do servidor. O uso da validação baseada no cliente pode reduzir o número de estadias da página. melhore o desempenho e melhore a experiência do usuário, mas não confie apenas nisso, porque a validação do lado do cliente pode ser facilmente enganada por hackers.

Para validar o conteúdo de entrada, você deve definir regras de entrada aceitáveis para cada campo de entrada. é fazer restrições com base no comprimento, intervalo, formato e tipo do campo de entrada. Usar uma lista de restrições de caracteres aceitáveis em vez de uma lista de caracteres ilegais para restringir a entrada. Usar restrições de lista de caracteres ilegais não é bom porque é quase impossível. para filtrar todas as entradas prejudiciais

Se você precisar aceitar a entrada de caracteres HTML, é melhor usar um método como HtmlEncode para codificá-lo com segurança antes de exibi-lo.

Conteúdo:

Visão geral

do objetivo

Implementação passo a passo

Etapa 1. Usando ASP. Verificação de solicitação NET.

Etapa 2. Use a entrada de restrição de direitos.

Etapa 3. Codifique a entrada não segura.

Etapa

Verifique se os erros do ASP.NET não são retornados ao cliente.

-------------------------------------------------- ------------------------------

Propósito:

Restrinja o comprimento, intervalo, formato e tipo da string de entrada.
Use a validação de solicitação para evitar ataques de injeção ao desenvolver programas ASP.NET.
Use controles de validação do ASP.NET para validação de entrada.
Codifique a saída insegura.
Evite ataques de injeção usando o padrão de conjunto de parâmetros de comando.
Evite que detalhes do erro sejam retornados ao cliente.
Visão geral:

você deve validar todas as entradas não confiáveis em seu aplicativo. Você deve assumir que todas as entradas do usuário são inválidas. Os usuários podem fornecer campos de formulário, strings de consulta, cookies de cliente e valores de ambiente do navegador no aplicativo, como strings de proxy do usuário e. Endereços IP, etc.

A validação de entrada fraca geralmente oferece oportunidades para ataques de injeção. A seguir estão métodos comuns de ataque que usam validação de entrada fraca ou nenhuma validação de entrada.

Injeção SQL. Se você usar valores de entrada do usuário para construir instruções SQL dinamicamente, o banco de dados poderá executar instruções SQL ofensivas e prejudiciais.
Os ataques de script entre sites exploram vulnerabilidades de validação de páginas da Web para injetar scripts do lado do cliente. Esses códigos são então enviados ao computador cliente confiável e interpretados e executados pelo navegador. o navegador não tem como saber que o código é prejudicial.
Acesso não autorizado a arquivos. Se o seu código aceitar entrada do chamador, um usuário mal-intencionado poderá ver as operações do seu arquivo e acessar arquivos protegidos ou usar o seu código para injetar dados ilegais.

Nota: Os ataques de injeção podem ser feitos usando conexões HTTP ou HTTPS Secure Socket Layer (SSL) As técnicas de criptografia de transporte não podem ser usadas para evitar ataques.

Os métodos comuns de validação de entrada são resumidos abaixo. , como caixas de texto e outros campos de entrada de formulário, parâmetros de string de consulta, cookies, variáveis do lado do servidor e parâmetros de método de rede. Observe que a estratégia de filtragem deve permitir apenas a entrada correta e rejeitar a entrada ilegal. melhor do que filtrar tudo É mais fácil detectar entradas ilegais, mas geralmente é difícil incluir todas as entradas ilegais

Verifique o conteúdo de entrada através dos seguintes aspectos:

Restrições Verifique se a entrada é do tipo, comprimento de caracteres, formato e intervalo corretos. Os controles de validação do ASP.NET podem ser aplicados para restringir a entrada de controle do servidor.
Rejeitar. Detecte entradas de dados prejudiciais conhecidas e rejeite-as.
Filtragem. Às vezes, você desejará filtrar as partes da entrada do usuário que representam riscos de segurança. Por exemplo, se seu aplicativo permitir entrada de formato livre, como campos de memorando, você permitirá certas tags HTML seguras, como <b>, <i. > e outras tags HTML.

Resumo da etapa

Proteja seu aplicativo ASP.NET contra ataques de injeção seguindo estas etapas:

Etapa 1. Use a verificação de solicitação ASP.NET.
Etapa 2. Restringir a entrada.
Etapa 3. Codifique a saída insegura.
Etapa 4. Use parâmetros de comando para instruções de consulta SQL.
Etapa 5. Verifique se as informações de erro do ASP.NET não vazaram para o cliente.

Os capítulos a seguir discutirão essas etapas em detalhes.

Etapa 1. Usar a validação de solicitação do ASP.NET

Por padrão, a validação de solicitação do ASP.NET 1.1 e 2.0 verifica se os dados enviados ao servidor contêm elementos de marcação HTML e caracteres reservados. de inserir scripts no programa. A validação da solicitação será comparada com uma lista de strings potencialmente ameaçadoras e, se uma exceção for encontrada, ela lançará uma exceção do tipo HttpRequestValidationException.

Você pode fazer isso em seu arquivo web.config por < Add activateRequest=. "false" no elemento pages> ou defina ValidateRequest = "false" no elemento @Pages de uma página separada para desabilitar esse recurso.

Se desejar desabilitar a validação de solicitação, você pode desabilitá-lo apenas nas páginas onde for necessário. Por exemplo, se você incluir um campo na página do programa que aceita entrada no formato HTML,

certifique-se de que o recurso de validação de solicitação esteja ativado no arquivo Machine.config

. O recurso de validação de solicitação está habilitado por padrão no ASP.NET. pode fazer isso no arquivo Machine.config.comments Você verá as seguintes configurações padrão

Certifique-se de não ter modificado as configurações padrão no Machine.config do seu servidor e no arquivo Web. config.

Testar validação de solicitação ASP.NET

Você pode testar o efeito da validação de solicitação Crie uma página ASP.NET e desative a validação de solicitação definindo ValidateRequest = "fasle" da seguinte maneira:

<%@ Language="C#" ValidateRequest="false" %>
<html>
<script runat="servidor">
void btnSubmit_Click(Remetente do objeto, EventArgs e)
{
// Se ValidateRequest for falso, então 'hello' será exibido
// Se ValidateRequest for verdadeiro, então o ASP.NET retorna uma exceção
Response.Write(txtString.Text);
}
</script>
<corpo>
<form id="form1" runat="servidor">
<asp:TextBox id="txtString" runat="servidor"
Text="<script>alert('olá');</script>" />
<asp:Button id="btnSubmit" runat="servidor" OnClick="btnSubmit_Click"
Text="Enviar" />
</form>
</body>
</html>

Quando você executa a página, "Hello" é exibido em uma caixa de mensagem porque o script no txtString é executado e processado pelo navegador do cliente.

Se você definir ValidateRequest = "true" ou remover o atributo da página ValidateRequest, validação de solicitação ASP .NET. rejeitará a entrada do script e gerará uma mensagem de erro como a mostrada abaixo.

Um valor Request.Form potencialmente perigoso foi detectado no cliente (txtString="<script>alert('hello").

Tenha cuidado para não confiar apenas na função de verificação de solicitação, mas use-a apenas como um método de orientação para verificação personalizada.

Etapa 2.

Para restringir a entrada, use o seguinte método:

Use a validação de entrada do lado do servidor. Não confie na validação do lado do cliente, pois ela pode ser facilmente ignorada. Use a validação do lado do cliente para reduzir o número de rejeições de página, melhorar o desempenho e melhorar a experiência do usuário.
Valide o comprimento, o intervalo, o formato e o tipo da entrada. Certifique-se de que o conteúdo da entrada esteja correto e atenda aos requisitos.
Use tipos de dados fortes. Especifique um tipo como Inteiro ou Duplo para entrada numérica. Especifique o tipo de dados String para entrada de caracteres.

Para validar campos de entrada de controle HTML em um formulário, execute a

validação

no código do lado do servidor. Usar o tipo de expressão regular Regex pode ajudar a restringir a entrada de caracteres.

Para validar campos de string como nome, endereço, fax e número de certidão de nascimento, use expressões regulares.
Restringe o intervalo aceitável de caracteres.
Habilite regras de formatação. Por exemplo, campos baseados em padrões, como ID fiscal, CEP e CEP, exigem padrões de caracteres especificados.
Verifique o comprimento.

Use o controle de validação de expressão regular (RegularExpresionValidator)

Para usar o controle de validação de expressão regular, você precisa definir o nome do controle a ser verificado (ControlToValidate), a expressão de validação (ValidationExpression) e a mensagem de erro (ErrorMessage). exemplo abaixo.

No código acima, uma expressão regular é usada para limitar o nome de entrada a letras (letras maiúsculas e minúsculas são permitidas), espaços, elipses de nome único como O'Dell e pontos. Além disso, o comprimento dos caracteres de entrada é limitado a 40 caracteres. Caracteres.

Observe que o controle de validação de expressão regular (RegularExpressionValidator) adicionará automaticamente o sinal de intercalação (^) e o cifrão ($) como delimitadores iniciais e finais. Se você não os adicionou na expressão personalizada, é melhor adicioná-los. Adicionar delimitadores é apenas para permitir que sua expressão obtenha a parte dos dados que você deseja.

Use a classe de expressão regular (Classe Regex)

se você não estiver usando controles do lado do servidor (o que significa que você não pode usar controles de validação) ou se precisar de outro For. fontes de campo de entrada diferentes de campos de formulário (como parâmetros de string de consulta e cookies), você pode usar uma classe de expressão regular (classe Regex

Use a classe de expressão regular

para importar o namespace System.Text.RegularExpressions adicionando uma instrução com o uso)

prefixo.
Certifique-se de que a expressão regular contenha "^" e "$" (no início da string, no final da string).
Chame o método IsMatch da classe Regex. A seguir está um exemplo de código.

//Método de instância:
Regex reg = new Regex(@"^[a-zA-Z'.s]{1,40}$");
Response.Write(reg.IsMatch(txtName.Text));

// Método estático:
if (!Regex.IsMatch(txtNome.Texto,@"^[a-zA-Z'.s]{1,40}$"))
{
// O nome não corresponde à expressão
}

Se não for possível armazenar em cache expressões regulares usadas com frequência, você deverá usar o método estático IsMatch para melhorar o desempenho e evitar a criação desnecessária de objetos.

Validando campos numéricos

. Na maioria dos casos, você deve validar a entrada numérica e os intervalos. Use controles de servidor para verificar a entrada e o intervalo de. campos numéricos, use o controle RangeValidator. RangeValidator oferece suporte a dados de moeda, data, número inteiro, precisão dupla e tipo string.

Para usar o controle RangeValidator, você precisa definir o nome do controle (ControlToValidate), tipo (Type) e valor mínimo (MinimumValue. ), valor máximo (MaximumValue) e propriedades de mensagem de erro (ErrorMessage). Aqui está o exemplo de código:

<asp:RangeValidator
ID="RangeValidator1"
Runat = "servidor"
ErrorMessage="Intervalo inválido. O número deve estar entre 0 e 255."
ControlToValidate = "rangeInput"
Valor Máximo="255"
ValorMínimo="0" Type="Inteiro" />

Se não estiver usando um controle de servidor, você poderá concluir a verificação de intervalo de números convertendo o valor de entrada em um número inteiro e validando-o. Por exemplo, para verificar se um número inteiro é legal, use o novo método Int32.TryParse fornecido pelo ASP.NET 2.0 para converter o valor de entrada no tipo de variável System.Int32. Este método retornará false se a conversão falhar.

Int32i;
if (Int32.TryParse(txtInput.Text, out i) == falso)
{
//Falha na conversão
}

Se você estiver usando uma versão anterior do ASP.NET, poderá usar o método Int32.Parse ou Convert.ToInt32 em um bloco try/catch e manipular o FormatException que é lançado quando a conversão falha

. from HTML O tipo e o intervalo do tipo inteiro da caixa de texto.

<%@ Page Language="C#" %>

void Page_Load(objeto remetente, EventArgs e)
{
if (Request.RequestType == "POST")
{
int eu;
if (Int32.TryParse(Request.Form["integerTxt"], out i) == true)
{
// TryParse retorna verdadeiro se a conversão for bem-sucedida
se ((0 <= i && i <= 255) == verdadeiro)
{
Response.Write("Dados de entrada são válidos.");
}
outro
Response.Write("Dados de entrada estão fora do intervalo");
}
outro
Response.Write("Os dados de entrada não são um número inteiro");
}
}

</script>

<html>
<corpo>
<form id="form1" action="NumericInput.aspx" método="post">
<div>
Insira um número inteiro entre 0 e 255:
<input name="integerTxt" type="texto" />
<input name="Enviar" type="enviar" value="enviar" />
</div>
</form>
</body>
</html>

Validando Campos de Data

Você precisa verificar se os campos de data são do tipo correto. Na maioria dos casos, você também precisará verificar seu intervalo, como verificar se eles estão no futuro ou no passado. para capturar um valor de entrada de data e se desejar que o valor esteja dentro de um intervalo específico, você pode usar o controle de validação de intervalo (RangeValidator) e definir seu tipo permitido para o tipo Data. Este controle permite especificar um período de tempo especial. definindo o momento inicial. Se precisar usar o horário de hoje como referência para verificar, como verificar se um horário está no futuro ou no passado, você pode usar o controle de validação CustomValidator.
Usar o controle CustomValidator para validar uma data requer a configuração das propriedades ControlToValidate e ErrorMessage e a especificação de um método lógico de validação personalizado no evento OnServerValidate.

<%@ Page Language="C#" %>

void ValidateDateInFuture(fonte do objeto, argumentos ServerValidateEventArgs)
{
DateTime dt;

// Verifica se há uma data válida e se a data está no futuro
if ((DateTime.TryParse(args.Value, out dt) == false) ||
(dt <= DateTime.Today))
{
args.IsValid = falso;
}
}

</script>

Observe que o código acima usa o método DateTime.TryParse, que é um novo método fornecido pelo ASP.NET 2.0.

Para filtrar campos de texto livres

para filtrar a entrada, você precisa garantir que a entrada insegura não seja tratada como código.

permite

que o usuário Os dados no banco de dados compartilhado não possam ser lidos. Primeiro, você precisa filtrar os dados para que não sejam perigosos na saída. Use o método HttpUtility.HtmlEncode para primeiro codificar o valor de entrada.

Adicione os seguintes campos ao elemento da página @Page ValidateRequest = "false" para desabilitar a validação de solicitação ASP.NET Use o método HtmlEncode para codificar a string de entrada Use o objeto StringBuilder e chame seu método Replace para substituir o HTML nos caracteres. O código a seguir fornece Aqui está um exemplo dessa abordagem. Esta página desativa a validação de solicitação ASP.NET definindo ValidateRequest = "fasle". Sua codificação HTML permite o uso de tags <b> e <i> para exibir formatação de texto simples. .

<%@ Page Language="C#" ValidateRequest="false"%>

void submitBtn_Click(object sender, EventArgs e)
{
// Codifica a entrada da string
StringBuilder sb = new StringBuilder(
HttpUtility.HtmlEncode(htmlInputTxt.Text));
// Permitir seletivamente e <i>
sb.Replace("<b>", "<b>");
sb.Replace("</b>", "");
sb.Replace("<i>", "<i>");
sb.Replace("</i>", "");
Response.Write(sb.ToString());
}
</script>

Validar o valor da string de consulta

Validar o comprimento, intervalo, formato e tipo de uma string de consulta Normalmente, você usa uma expressão regular combinada para realizar as seguintes tarefas:

Restringir valores de entrada Definir verificações de intervalo explícitas Especifique o tipo de entrada e converta-o para ASP.NET. platform O tipo a seguir trata quaisquer exceções causadas por conversões de tipo O exemplo de código a seguir demonstra o uso da classe Regex para validar a sequência de nomes passada na sequência de consulta.

void Page_Load(objeto remetente, EventArgs e)
{
if (!System.Text.RegularExpressions.Regex.IsMatch(
Request.QueryString["Nome"], @"^[a-zA-Z'.s]{1,40}$"))
Response.Write("Parâmetro de nome inválido");
outro
Response.Write("Nome é " + Request.QueryString["Nome"]);
}

Validar valores de cookies

Os valores armazenados em cookies como strings de consulta podem ser facilmente modificados pelo usuário. Valide também o comprimento, intervalo, formato e tipo desses valores.

Valide os endereços

arquivo e URL.

nomes, endereço do arquivo ou caminho de armazenamento do arquivo, você precisa verificar se eles estão no formato correto e se apontam para um local válido de acordo com a situação real do seu programa. Se esta verificação falhar, seu programa pode ser solicitado por engano para acessar. o arquivo.

Verifique o caminho do arquivo

para evitar que seu programa seja explorado por usuários para acessar arquivos, evite que ele aceite arquivos ou caminhos de arquivo inseridos por código escrito pelo usuário. Por exemplo:

Se você aceitar nomes de arquivo de entrada, use o método System. Método .IO.Path.GetFileName para obter o nome completo do arquivo. Se for necessário, aceita um caminho de arquivo de entrada e usa System.IO.Path.GetFullPath para obter o caminho completo do arquivo. .

Se você usar o método MapPath para mapear um diretório virtual fornecido para um diretório físico no servidor, use uma versão sobrecarregada do método Request.MapPath com um parâmetro bool para evitar o mapeamento entre aplicativos.

tentar
{
string mapeadaPath = Request.MapPath( inputPath.Text,
Request.ApplicationPath, falso);
}
pegar(HttpException)
{
//Tentativa de mapeamento entre aplicativos
}

O parâmetro false final impedirá o mapeamento entre aplicativos. Isso significa que os usuários não têm permissão para usar a sintaxe "..." para fornecer um caminho ilegal que não esteja dentro do diretório virtual especificado.

Se você usar controles de servidor, poderá usar o método Control.MapPathSecure para obter o endereço do diretório real correspondente ao diretório virtual.
O método Control.MapPathSecure lança uma HttpException ao acessar um arquivo não autorizado. Para obter mais informações, consulte a introdução do método Control.MapPathSecure na documentação do .NET Framework.

Usando segurança de acesso de código para limitar a entrada e saída de arquivos

Os administradores podem limitar a capacidade de um programa de ler e gravar arquivos no diretório virtual onde ele reside, definindo sua credibilidade como "média". O mecanismo de segurança do código .NET garante que o programa não tenha nenhum direito de acesso a arquivos fora do diretório virtual onde está localizado.

Para definir o nível de confiança de um aplicativo como "médio", você pode adicionar:

< nível de confiança = "Médio". />

Verificar URL

Você pode usar expressões regulares como as seguintes para corresponder URLs

^(?:http|https|ftp)://[a-zA-Z0-9 .-]+(?::d. {1,5})?(?:[A-Za-z0-9.;:@&=+$,? /]|%u[0-9A-Fa- f]{4}|%[0-9A-Fa-f]{2})*$

Isso apenas restringe o formato de entrada e não verifica se ele é aceitável no aplicativo dentro do escopo do seu aplicativo. ele é válido no contexto do seu aplicativo. Por exemplo, seu aplicativo se comunica com o servidor especificado.

Etapa 3. Codifique o código inseguro

Se você inserir texto em uma página da Web, use o método HttpUtility.HtmlEncode para codificá-lo. Se o texto vier da entrada do usuário, de um banco de dados ou de um arquivo local, certifique-se de sempre fazer isso.

Da mesma forma, se você escrever uma URL que contenha caracteres inseguros porque eles vêm de Para conteúdo de entrada do usuário, bancos de dados, etc., use o.

Método

HttpUtility.UrlEncode

para codificar

Para evitar a codificação antes de armazenar os dados, o que pode danificar os dados armazenados, certifique-se de codificá-los nas etapas posteriores possíveis ao exibi-los

. com strings textuais especiais para representar esses símbolos e evita que o navegador os interprete como tags HTML. Por exemplo, "<" é substituído por < " (dois pontos) é substituído por " Essas tags são exibidas como texto inofensivo.

<%@ Page Language="C#" ValidateRequest="false" %>

Para ver o efeito da codificação HTML, crie um diretório virtual e coloque os arquivos mencionados nele, execute esta página, insira algum código HTML na caixa de texto e clique no botão enviar. Por exemplo, a seguinte entrada é exibida como normal. text.

Execute o script e diga olá <script>alert('hello');</script>

Se você remover a chamada ao método HtmlEncode e simplesmente inserir o conteúdo do texto, o navegador executará o código e exibirá uma caixa de prompt.

Usar o método UrlEncode não é seguro Codificar o endereço URL

Se você precisar obter os parâmetros da URL com a parte de entrada do usuário, o que pode trazer certos riscos de segurança, use o método HttpUtility.UrlEncode para codificar a string de endereço

. ;

Etapa 4. SQL A instrução usa o método de parâmetro de comando

Para evitar ataques de injeção, use o método de parâmetro SQL. Se você usar a coleção de parâmetro, o conteúdo de entrada será tratado como um. valor de texto, e o banco de dados não será executado. Um benefício adicional de usar o método de conjunto de parâmetros é que você pode limitar estritamente o tipo e o comprimento da entrada. a exceção será acionada.

Ao chamar um procedimento armazenado, use o conjunto de parâmetros

abaixo. O trecho de código demonstra um exemplo de uso de conjuntos de parâmetros ao chamar um procedimento armazenado.

SqlDataAdapter meuComando = new SqlDataAdapter("AuthorLogin",
minhaConexão);
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure;
SqlParameter parm = myCommand.SelectCommand.Parameters.Add(
"@LoginId", SqlDbType.VarChar, 11);
parm.Value = Login.Texto;

Use conjuntos de parâmetros ao criar suas próprias instruções SQL.

Se você não puder usar procedimentos armazenados, ainda poderá usar conjuntos de parâmetros, consulte o código abaixo.

SqlDataAdapter meuComando = new SqlDataAdapter(
"SELECT au_lname, au_fname FROM Autores WHERE au_id = @au_id", myConnection);
SQLParameter parm = myCommand.SelectCommand.Parameters.Add(
"@au_id",SqlDbType.VarChar, 11);
Parm.Value = Login.Texto;

Para obter mais informações sobre como evitar ataques de injeção de SQL, consulte Como proteger contra injeção de SQL no ASP.NET,

etapa 5. Para verificar se as mensagens de erro do ASP.NET não são retornadas ao cliente,

você pode usar o elemento <customErrors>. . Para configurar o cliente, mensagens de erro gerais devem ser retornadas ao cliente pelo mecanismo de detecção de erros do programa.

Confirme se você alterou o atributo mode em web.config para "remoteOnly", o exemplo a seguir é

<customErrors mode =

"remoteOnly">

Depois de instalar um programa ASP.NET, você pode especificar a página de mensagem de erro do cliente da seguinte maneira.

Para

obter

recursos adicionais, consulte os tópicos relacionados:

Como usar expressões regulares para restringir a entrada no ASP.NET

PS: Finalmente terminei de ler. Estou tão cansado. Na verdade, essas frases são muito simples se você olhar para elas. Esta é a primeira vez que faço uma tradução. Por favor, me perdoe se a tradução não estiver boa, obrigado.