Perigos ocultos das funções hash: ataques de extensão de comprimento e riscos de segurança do lado do servidor

Introdução

Length Extension Attack é um ataque relacionado às propriedades de certos tipos de funções hash (como MD5, SHA-1 e SHA-2). Em termos simples, este ataque explora o fato de que conhecendo H(mensagem) e o comprimento da mensagem, podemos facilmente calcular H(mensagem || preenchimento || extensão) sem conhecer a mensagem em si. Onde "||" representa conexão, "preenchimento" é adicionado de acordo com as disposições da função hash.

Isso ocorre porque essas funções hash usam uma estrutura Merkle-Damgård, que divide a entrada em blocos, e o hash de cada bloco depende do hash do bloco anterior. Isso significa que uma vez calculado o hash de uma determinada mensagem, temos um estado a partir do qual podemos começar e adicionar mais blocos.

Um modo de verificação do lado do servidor

Para facilitar a descrição do cenário de vulnerabilidade, primeiro assumimos que existe tal modo de autenticação do lado do servidor, ou seja, quando o usuário tentar fazer login, o servidor passará um hash específico baseado no ID, nome e endereço do usuário. uma chave de 30 dígitos conhecida apenas pelo servidor. O algoritmo gera um valor hash e o envia ao cliente. Posteriormente, quando o cliente tentar acessar algumas interfaces específicas, como a interface para modificar as permissões do usuário, o servidor irá regenerar o hash para verificação com base no ID da função, nome da função, permissões da função e a mesma chave de 30 dígitos do front -fim POST. Se o hash carregado for consistente com o hash gerado pelo servidor, a verificação será considerada aprovada e as novas permissões de função serão gravadas no banco de dados.

Para facilitar o entendimento, aqui estão alguns códigos simples escritos conforme a descrição como exemplos:

Pensando além da autoridade

Devido a vulnerabilidades no modo de verificação, um invasor pode ignorar a verificação de permissão reconstruindo a solicitação de transação sem conhecer a SecretKey. A ideia central de um ataque não autorizado é explorar as características dos ataques de expansão de comprimento. O invasor primeiro precisa obter o valor hash original e calcular o comprimento dos dados originais por meio de um algoritmo iterativo simples. Uma vez obtidas essas informações, parâmetros adicionais não autorizados podem ser adicionados aos dados originais e o mesmo algoritmo de hash pode ser usado para gerar hashes maliciosos.

Princípio do ataque de extensão de comprimento

O ataque de extensão de comprimento ocorre devido ao mecanismo interno de algumas funções hash. Essas funções primeiro dividem os dados em pedaços de comprimento fixo antes de processar os dados de entrada e, em seguida, preenchem o final de cada pedaço para atender a requisitos específicos. Esse design permite que um invasor construa um novo valor de hash efetivo preenchendo e anexando novos dados enquanto conhece o valor de hash e o comprimento da mensagem original.

Veja o SHA-256, por exemplo, que funciona em blocos de 512 bits. Para dados cujo comprimento não seja múltiplo de 512 bits, é necessário preenchimento. Suas regras de preenchimento são as seguintes:

1. Adicione um bit “1” no final dos dados;

2. Adicione um certo número de bits "0" para que o comprimento do módulo de dados 512 seja igual a 448 (para detalhes, consulte [1] ）；

3. Adicione um bloco longo de 64 bits no final para representar o comprimento dos dados originais.

Resumindo, um "1" seguido de m "0"s, mais um número inteiro de 64 ou 128 bits, é anexado ao final da mensagem para produzir uma mensagem de preenchimento de comprimento 512*n. O número inteiro anexado é o comprimento da mensagem original. A mensagem de preenchimento é então processada pela função hash em n blocos de 512 bits.

Método de construção

Neste exemplo, usaremos o código mencionado na imagem acima como um cenário específico, onde a string de dados é data="user_id=1&user_name=aa" e a chave é SecretKey="Length_extension\ _attack\ _segredo". O servidor analisará o campo de dados nos dados carregados e analisará os parâmetros necessários user_id e user_name por meio do delimitador &. Se o campo role existir, o servidor também obterá o valor deste campo. O servidor então faz o hash de todos os campos com o SecretKey e os compara com o hash de verificação carregado. Se os valores de hash forem consistentes, os parâmetros são considerados em conformidade com as regras e usados diretamente.

Primeiro, fazemos login na interface loginHandler para obter o valor hash hash="37d310d3465506486431fb2c2eb163f0f470479703f66dc9e5fdead8a3390c68" gerado usando SHA-256 com base em dados e SecretKey.

A seguir, exploraremos como é difícil decifrar. Tomando nossa situação de teste como exemplo, de acordo com o princípio do ataque de extensão de comprimento, desde que conheçamos o comprimento de H (mensagem) e da mensagem, podemos adicionar novos dados por meio do ataque de extensão de comprimento. A mensagem original = SecretKey + dados, agora já temos H (mensagem) em mãos, só precisamos saber o comprimento da mensagem para construir um novo valor de hash. Como SecretKey é uma chave de 30 bits, o comprimento real da mensagem pode ser conhecido após apenas 30 iterações. Portanto, podemos construir facilmente um novo valor de hash. Como precisamos usar permissões de administrador, precisamos unir o campo malicioso "&role=admin" nos dados originais.

Podemos usar o recurso de ataque de extensão de comprimento para adicionar novos dados e gerar um novo valor de hash sem conhecer o SecretKey. Uma biblioteca que já implementa esta funcionalidade é usada aqui [2] para concluir o teste. Em seguida, use a ferramenta para gerar um novo valor de hash.

Como a verificação da interface de adminActionHandler verifica o hash com base no usuário_id, nome de usuário e função carregados, os dados que carregamos neste momento são usuário_id=1, usuário_name=aa\x80\x00\x00\x00 \ x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x70 e role=admin, conforme mostrado na figura a seguir:

O valor do hash é 84ae4ae437eeabf3bd8a26294392770b86f64a81998194156ac003d58a21acd0. Depois disso, você pode chamar a interface adminActionHandler. Após receber os dados, o servidor irá comparar o hash carregado com sha256 (SecretKey + fakeData). Após passar na verificação, algumas operações confidenciais serão realizadas. Dessa forma, usamos com sucesso o ataque de extensão de comprimento para contornar a verificação do lado do servidor e realizar operações não autorizadas.

Outros cenários de ataque possíveis

1. Verificação de integridade do arquivo: Se a integridade do arquivo for verificada concatenando a chave e o conteúdo do arquivo e, em seguida, fazendo hash, um invasor poderá expandir o arquivo e gerar um hash válido, ignorando assim a verificação de integridade ;

**2. Segurança de aplicações Web: **Em aplicações Web, se uma função hash vulnerável a ataques de extensão de comprimento for usada para verificar os dados enviados pelos usuários, os invasores poderão tirar vantagem disso para enviar dados maliciosos;

3.Assinaturas digitais: Em alguns esquemas de assinatura digital, se a assinatura for gerada concatenando a chave privada e a mensagem e depois fazendo hash, é possível que um invasor expanda a mensagem e gere uma assinatura válida;

**4. Armazenamento de senha: **Embora incomum, se a senha for armazenada concatenando uma chave (como um salt) e a senha e, em seguida, fazendo hash, um invasor pode tentar quebrá-la usando uma senha de ataque de extensão de comprimento.

Como prevenir

1. Escolha uma função hash que não seja suscetível a ataques de extensão de comprimento, como SHA-3;

**2. Use HMAC: **HMAC requer uma chave e uma mensagem como entrada. O resultado da saída depende tanto da chave quanto da mensagem, portanto o invasor não pode realizar um ataque de extensão de comprimento sem conhecer a chave.

**3. Fortaleça a verificação de autoridade: **Adicione etapas adicionais de verificação de autoridade no lado do servidor, como o uso de autenticação multifator.

A seguir estão as características de alguns algoritmos Hash comumente usados:

| Algoritmo | Resistência à colisão | Ataque de colisão com prefixo selecionado | Resistência à pré-imagem | Ataque de extensão de comprimento | | --- | --- | --- | --- | --- | | MD5 | 2^18 | 2^39 | 2^123,4 | Vulnerável | | SHA-1 | 2^61,2 | 2^63,4 | 2^160 | Vulnerável | | SHA-256 (SHA-2) | 2^65,5 | - | 2^254,9 | Vulnerável| | SHA-512 (SHA-2) | 2^32,5 | - | 2^511,5 | Vulnerável| | SHA-3 | 2^50 | - | Desconhecido | Não vulnerável | | BLAKE2s | 2^112 | - | 2^241 | Não vulnerável| | BLAKE2b | 2^224 | - | 2^481 | Não vulnerável |

Conclusão

Uma defesa eficaz contra ataques de extensão de comprimento é usar funções hash imunes a tais ataques, como SHA-3 e BLAKE2. Além disso, também pode ser protegido através da estrutura HMAC (código de autenticação de mensagem com hash com chave). Estas medidas podem melhorar eficazmente a segurança do sistema e garantir a integridade dos dados e a estabilidade das aplicações.

Link de referência:

[1]

[2]