SHA-2

Prévia do material em texto

SHA-2
Geral
Projetistas Agência de Segurança
Nacional
Primeira
publicação
2001
Séries (SHA-0), SHA-1, SHA-2,
SHA-3
Certificação FIPS PUB 180-4,
CRYPTREC, NESSIE
Detalhes
Tamanho do
resumo
224, 256, 384 ou 512 bits
Estrutura Construção Merkle–
Damgård
Rodadas 64 ou 80
Melhor criptanálise pública
Um ataque de 2011 quebra a resistência
de preimagem para 57 das 80 rodadas de
SHA-512, e 52 de 64 rodadas para SHA-
256. 
Ataques de pseudo-colisão contra até 46
rodadas de SHA-256.
SHA-2
Origem: Wikipédia, a enciclopédia livre.
SHA-2 é um conjunto de funções hash criptográficas projetadas pela NSA (Agência de
Segurança Nacional dos EUA).[1] SHA significa secure hash algorithm (algoritmo de hash
seguro). Funções hash criptográficas são operações matemáticas executadas em dados
digitais; comparando o hash computado (a saída de execução do algoritmo) a um valor de
hash conhecido e esperado, uma pessoa pode determinar a integridade dos dados. Por
exemplo, calcular o hash de um arquivo baixado e comparar o resultado com um resultado
hash publicado anteriormente pode mostrar se o download foi modificado ou
adulterado.[2] Um aspecto importante das funções hash criptográficas é a sua resistência à
colisão: ninguém deve ser capaz de encontrar dois valores de entrada diferentes que resultam
na mesma saída de hash.
SHA-2 inclui mudanças significativas de seu antecessor, SHA-1. A família SHA-2 é
composta por seis funções hash com resumos (valores de hash) que são de 224, 256, 384 ou
512 bits: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256.
SHA-256 e SHA-512 são funções hash inovadoras computadas com palavras de 32 bytes e
64 bytes, respectivamente. Eles usam quantidades de deslocamento e constantes aditivas
diferentes, mas as suas estruturas são praticamente idênticas, diferindo apenas no número de
rodadas. SHA-224 e SHA-384 são simplesmente versões truncadas das duas primeiras,
calculadas com valores iniciais diferentes. SHA-512/224 e SHA-512/256 também são
versões truncadas de SHA-512, mas os valores iniciais são gerados usando o método
descrito no FIPS PUB 180-4. SHA-2 foi publicada em 2001 pelo NIST como um padrão
federal dos Estados Unidos (FIPS). A família SHA-2 de algoritmos está patenteada em US
6829355. Os Estados Unidos lançou a patente sob uma licença livre de royalties.
Em 2005, surgiu um algoritmo para encontrar colisões SHA-1 em cerca de 2000 vezes menos etapas do que se pensava possível. Em 23 de fevereiro
de 2017, o grupo CWI Amsterdam e a Google anunciaram um ataque prático de colisão contra o SHA-1.[3]. A margem de segurança deixada por
SHA-1 é mais fraca do que a pretendida, e seu uso é, portanto, não recomendado para aplicações que dependem de resistência à colisão, tais
como assinaturas digitais. Embora SHA-2 tenha algumas semelhanças com o algoritmo SHA-1, esses ataques não foram estendidos com sucesso para
SHA-2. 
Atualmente, os melhores ataques públicos quebram a resistência à preimagem em 52 rodadas de SHA-256 ou 57 rodadas de SHA-512, e resistência
de colisão para 46 rodadas de SHA-256, como mostrado na seção Criptoanálise e validação abaixo.
Padrão hash
Aplicações
Criptoanálise e validação
Validação oficial
Exemplos de variantes SHA-2
Pseudocódigo
Comparação de funções SHA
Ver também
Referências
Ligações externas
Índice
Com a publicação do FIPS PUB 180-2, NIST acrescentou três
funções hash adicionais na família SHA. Os algoritmos são
conhecidos coletivamente como SHA-2, em homenagem a seus
comprimentos de resumo (em bits): SHA-256, SHA-384 e SHA-
512.
Os algoritmos foram publicadas pela primeira vez em 2001 no
projeto da FIPS PUB 180-2, no tempo em que opinião e
observações públicas eram aceitas. Em agosto de 2002, FIPS PUB
180-2 se tornou o novo Padrão de Hash Seguro, substituindo FIPS
PUB 180-1, que foi lançado em abril de 1995. A norma atualizada
incluía o algoritmo SHA-1 original, com a notação técnica
atualizada consistente com a descrição do funcionamento interno
da família SHA-2.
Em fevereiro de 2004, uma notificação de mudança foi publicada
por FIPS PUB 180-2, especificando uma variante adicional, SHA-
224, definida para coincidir com o comprimento da chave
da Triple DES de chave dupla. Em outubro de 2008, o padrão foi
atualizado no FIPS PUB 180-3, incluindo SHA-224 a partir da
notificação de mudança, mas sem fazer mudanças fundamentais
no padrão. A principal motivação para a atualização do padrão foi
a transferência de informações de segurança sobre os algoritmos
de hash e recomendações para a sua utilização para Publicações
Especiais 800-107 e 800-57. Os dados de testes detalhados e exemplos de resumos de mensagem também foram removidos do padrão, e fornecidos
como documentos separados.
Em janeiro de 2011, NIST publicou SP800-131A, que especificou um movimento a partir do mínimo de segurança atual de 80-bits (fornecido pelo
SHA-1) permitido para uso do governo federal até o final de 2013, com a segurança de 112 bits (fornecido pelo SHA-2), sendo requisito mínimo de
fato a partir daí, e o nível de segurança recomendado a partir da data de publicação.
Em março de 2012, o padrão foi atualizado no FIPS PUB 180-4, incluindo as funções de hash SHA-512/224 e SHA-512/256, e descrevendo um
método para gerar valores iniciais para as versões truncadas de SHA-512. Além disso, uma restrição ao preenchimento dos dados de entrada antes do
cálculo do hash foi removida, permitindo aos dados de hash a serem calculados simultaneamente com a geração de conteúdo, como um vídeo ou
áudio em tempo real. Preencher o bloco de dados final ainda deverá ocorrer antes da saída do hash.
Em julho de 2012, NIST revisou o SP800-57, que fornece orientações para a gestão de chaves criptográficas. A publicação não permite criação de
assinaturas digitais com um hash de segurança inferior a 112 bits a partir de 2013. A revisão anterior de 2007 especificava o ponto de corte para ser o
final de 2010. Em agosto de 2012, NIST revisou SP800-107 da mesma maneira.
A competição de funções hash do NIST selecionou uma nova função hash, SHA-3, em 2012. O algoritmo SHA-3 não é derivado de SHA-2.
A função hash SHA-2 é implementada em algumas aplicações de segurança e protocolos amplamente usados,
incluindo TLS e SSL, PGP, SSH, S/MIME, e IPsec.
SHA-256 é usado como parte do processo de autenticação de pacotes de software Debian GNU/Linux e no padrão DKIM de assinatura de
mensagens; SHA-512 é parte de um sistema para autenticar vídeos de arquivos do Tribunal Penal Internacional para o genocídio de Ruanda. SHA-
256 e SHA-512 foram propostos para utilização no DNSSEC. Fornecedores de Unix e Linux estão se movimentando para usar 256 e 512-bit SHA-2
para o cálculo de dispersão seguro de senhas.
Várias criptomoedas como Bitcoin usam SHA-256 para verificar transações e calculam a prova-de-trabalho ou prova-de-participação (do inglês,
proof of stake). A ascensão de chips aceleradores ASIC SHA-2 tem levado ao uso de esquemas de prova-de-trabalho baseados em scrypt.
Padrão hash
Uma iteração em uma função de compressão da família SHA-2. Os
componentes azuis fazem as seguintes operações: 
 
 
 
 
A rotação bit a bit usa constantes diferentes para a SHA-512. Os
números a seguir são para SHA-256. O vermelho é adição
módulo 232.
Aplicações
SHA-1 e SHA-2 são os algoritmos de hash seguros exigidos por lei para o uso em certas aplicações do Governo dos EUA, incluindo o uso dentro de
outros algoritmos e protocolos criptográficos, para a proteção da informação não-confidencial sensível. FIPS PUB 180-1 também incentivou adoção
e utilização de SHA-1 por organizações privadas e comerciais. SHA-1 está sendo reformada para a maioria dos usos do governo; o Instituto Nacional
de Padrões e Tecnologia diz: "As agências federais devem parar de usar SHA-1para ... aplicações que exigem resistência à colisão, logo que
possível, e devem usar a família SHA-2 de funções hash para estas aplicações depois de 2010" (ênfase original). A diretiva do NIST de que as
agências do governo dos EUA devem parar com os usos de SHA-1 depois de 2010 e a conclusão do SHA-3 podem acelerar o fim do uso de SHA-1.
As funções SHA-2 não são tão amplamente utilizadas como SHA-1, apesar de sua maior segurança. Razões podem incluir falta de suporte para SHA-
2 em sistemas que rodam o Windows XP SP2 ou versões posteriores, ou a falta de urgência percebida desde que colisões em SHA-1 ainda não foram
encontradas.
Para uma função hash em que L é o número de bits no resumo de mensagem, encontrar uma mensagem que corresponde a um dado resumo de
mensagem sempre pode ser feito usando uma busca de força bruta em 2L avaliações. Isto é chamado um ataque de preimagem e pode ou não ser
prático, dependendo de L e do ambiente de computação em particular. O segundo critério, encontrar duas mensagens diferentes que produzem o
mesmo resumo de mensagem, conhecido como uma colisão, requer, em média, apenas 2L/2 avaliações usando um ataque do aniversário.
Algumas das aplicações que usam hashes criptográficos, como o armazenamento de senha, só são minimamente afetados por um ataque de colisão.
Construindo uma senha que trabalha para uma determinada conta requer um ataque de preimagem, bem como o acesso ao hash da senha original
(normalmente num arquivo obscuro), o que pode ou não ser trivial. Inverter a encriptação da senha (por exemplo, para obter uma senha para tentar
usá-la contra a conta de um usuário em outro lugar) não é possível com esses ataques (no entanto, mesmo um hash de senha seguro não pode impedir
ataques de força bruta em senhas fracas).
No caso de assinatura de documentos, um invasor não pode simplesmente falsificar uma assinatura de um documento - o atacante existente teria que
produzir um par de documentos, um inócuo e um prejudicial, e obter o detentor da chave privada para assinar o documento inócuo. Há circunstâncias
concretas em que isso é possível; até o final de 2008, foi possível criar certificados SSL falsificados usando uma colisão em MD5.
O aumento do interesse na análise hash criptográfico durante a competição SHA-3 produziu vários novos ataques contra a família SHA-2, os
melhores são dados na tabela abaixo. Apenas os ataques de colisão são de complexidade prática; nenhum dos ataques se estendem para a função hash
com rodada completa.
No FSE 2012, pesquisadores da Sony fizeram uma apresentação sugerindo que ataques de pseudo-colisão poderiam ser estendidos para 52 rodadas
no SHA-256 e 57 rodadas no SHA-512 através da construção sobre o ataque de pseudo-preimagem biclique.
Criptoanálise e validação
Publicado em Ano Método de ataque Ataque Variante Rodadas Complexidade
New Collision Attacks Against 
Up To 24-step SHA-2[4] 2008 Deterministico Colisão
SHA-
256 24/64 2
28.5
SHA-
512 24/80 2
32.5
Preimages for step-reduced SHA-2[5] 2009 Encontro-no-meio Preimagem
SHA-
256
42/64 2251.7
43/64 2254.9
SHA-
512
42/80 2502.3
46/80 2511.5
Advanced meet-in-the-middle 
preimage attacks[6] 2010 Encontro-no-meio Preimagem
SHA-
256 42/64 2
248.4
SHA-
512 42/80 2
494.6
Higher-Order Differential Attack 
on Reduced SHA-256[7] 2011 Diferencial Pseudo-colisão
SHA-
256
46/64 2178
46/64 246
Bicliques for Preimages: Attacks on 
Skein-512 and the SHA-2 family[8] 2011 Biclique
Preimagem
SHA-
256 45/64 2
255.5
SHA-
512 50/80 2
511.5
Pseudo-
preimagem
SHA-
256 52/64 2
255
SHA-
512 57/80 2
511
Improving Local Collisions: New 
Attacks on Reduced SHA-256[9] 2013 Diferencial
Colisão SHA-256 31/64 2
65.5
Pseudo-colisão SHA-256 38/64 2
37
Branching Heuristics in Differential
Collision 
Search with Applications to SHA-
512[10]
2014 Diferencialheurístico Pseudo-colisão
SHA-
512 38/80 2
40.5
Implementações de todas as funções de segurança aprovadas pelo FIPS podem ser oficialmente validadas através do programa de CMVP, executado
conjuntamente pelo Instituto Nacional de Padrões e Tecnologia (NIST) e o Communications Security Establishment (CSE). Para verificação
informal, um pacote para gerar um elevado número de vetores de teste é disponibilizado para download no site do NIST; a verificação resultante no
entanto não substitui a validação formal CMVP, o que é exigido por lei para determinadas aplicações.
Em dezembro de 2013, já existiam mais de 1300 implementações validadas da SHA-256 e mais de 900 da SHA-512, com apenas 5 delas sendo
capazes de lidar com as mensagens com um comprimento em bits não-múltiplo de oito, suportando ambas as variantes (ver Lista de validação SHS).
Valores hash para palavra vazia:
SHA224("") 
0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f 
SHA256("") 
0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 
SHA384("") 
0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b 
SHA512("") 
0x 
cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a5
38327af927da3e 
SHA512/224("") 
0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 
Validação oficial
Exemplos de variantes SHA-2
SHA512/256("") 
0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a 
Até mesmo uma pequena mudança na mensagem irá (com probabilidade massiva) resultar em um hash bastante diferente, devido ao efeito avalanche.
Por exemplo, adicionando um ponto final ao final da frase:
SHA224("The quick brown fox jumps over the lazy dog") 
0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525 
SHA224("The quick brown fox jumps over the lazy dog.") 
0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c 
Segue o pseudocódigo para o algoritmo SHA-256. Note o grande acréscimo na mistura entre bits das w[16..63] palavras em comparação com
SHA-1.
Nota 1: Todas as variáveis são inteiros de 32 bits sem sinais e a adição é calculada módulo 232 
Nota 2: Para cada rodada, há uma constante da rodada k[i] e uma entrada no array de agendamento da mensagem w[i], 
0 ≤ i ≤ 63 
Nota 3: A compressão utiliza 8 variáveis funcionais, de a até h 
Nota 4: A convenção Big-endian é utilizada quando se está expressando constantes neste pseudocódigo, 
 e quando se analisar e transformar os dados de um bloco da mensagem em palavras, por exemplo, 
 a primeira palavra da mensagem de entrada "abc" após o preenchimento é 0x61626380 
Inicializar os valores hash: 
(primeiros 32 bits das partes fracionárias das raízes quadradas dos primeiros 8 primos 2..19): 
h0 := 0x6a09e667 
h1 := 0xbb67ae85 
h2 := 0x3c6ef372 
h3 := 0xa54ff53a 
h4 := 0x510e527f 
h5 := 0x9b05688c 
h6 := 0x1f83d9ab 
h7 := 0x5be0cd19 
Inicializar o array das constantes da rodada: 
(primeiros 32 bits das partes fracionárias das raízes cúbicas dos primeiros 64 primos 2..311): 
k[0..63] := 
 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 
 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 
 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 
 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 
 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 
 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 
 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 
 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 
Pre-processamento: 
anexar o bit '1' à mensagem 
anexar k bits '0', onde k é omenor número >= 0 tal que o tamanho da mensagem resultante (módulo 512 em bits) seja 
448. 
anexar o tamanho da mensagem (sem o bit '1' ou preenchimento), em bits, como inteiros big-endians de 64 bits 
 (isso vai tornar o tamanho pós processado inteiro em um múltiplo de 512 bits) 
Processar a mensagem em successivos pedaços de 512 bits: 
quebrar a mensagem em pedaços de 512 bits 
para cada pedaço 
 criar um array de mensagens de 64 espaços w[0..63] de palavras de 32 bits 
 (Os valores iniciais em w[0..63] não importam, muitas implementações os zeram nesse ponto 
 copiar o pedaço nas primeiras 16 palavras w[0..15] do array agendado de mensagens 
 Estender as primeiras palavras de 16 bits nas 48 palavras restantes w[16..63] do array: 
 para i de 16 to 63 
 s0 := (w[i-15] rotacionarparadireita 7) xor (w[i-15] rotacionarparadireita 18) xor (w[i-15] 
deslicarparadireita 3) 
 s1 := (w[i-2] rotacionarparadireita 17) xor (w[i-2] rotacionarparadireita 19) xor (w[i-2] 
deslocarparadireita 10) 
 w[i] := w[i-16] + s0 + w[i-7] + s1 
 Inicializar variáveis funcionais para o valor atual de hash: 
 a := h0 
 b := h1 
 c := h2 
 d := h3 
 e := h4 
Pseudocódigo
 f := h5 
 g := h6 
 h := h7 
 Laço principal da função de compressão: 
 para i de 0 até 63 
 S1 := (e rotacionarparadireita 6) xor (e rotacionarparadireita 11) xor (e rotacionarparadireita 25) 
 ch := (e e f) xor ((não e) e g) 
 temp1 := h + S1 + ch + k[i] + w[i] 
 S0 := (a rotacionarparadireita 2) xor (a rotacionarparadireita 13) xor (a rotacionarparadireita 22) 
 maj := (a e b) xor (a e c) xor (b e c) 
 temp2 := S0 + maj 
 h := g 
 g := f 
 f := e 
 e := d + temp1 
 d := c 
 c := b 
 b := a 
 a := temp1 + temp2 
 Adicionar o pedaço comprimido ao valor atual de hash: 
 h0 := h0 + a 
 h1 := h1 + b 
 h2 := h2 + c 
 h3 := h3 + d 
 h4 := h4 + e 
 h5 := h5 + f 
 h6 := h6 + g 
 h7 := h7 + h 
Produzir o valor final do hash (big-endian): 
digest := hash := h0 anexar h1 anexar h2 anexar h3 anexar h4 anexar h5 anexar h6 anexar h7 
A computação dos valores ch e maj pode ser otimizada da mesma maneira como é descrita para SHA-1.
SHA-224 é idêntica à SHA-256, exceto que:
os valores hash iniciais de h0 até h7 são diferentes, e
a saída e construída omitindo-se h7.
Valores iniciahs do valor hash de SHA-224 (em big endian): 
(Os segundos 32 bits das partes fracionárias das raízes quadradas do 9º até o 16º primos 23..53) 
h[0..7] := 
 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 
SHA-512 é idêntica em relação à estrutura a SHA-256, mas,
A mensagem é quebrada em pedaços de 512 bits.
Os valores hash iniciais e constantes de rodada são estendidos até 64 bits.
Há 80 rodadas em vez de 64,
O array de escalonamento da mensagem w tem 80 palavras de 64 bits em vez de 64 palavras de 32 bits,
Para estender o array w, o laço é de 16 até 79 em vez de 16 até 63,
As constantes de rodada são baseadas nos primeiros 80 primos 2..409,
O tamanho de palavra usado para os cálculos é de 64 bits,
O tamanho anexado da mensagem (antes do pré-processamento), em bits, é um inteiro de 128 bits em big-endian, e
As quantidades de deslocamentos e rotações são diferentes.
Valores iniciais do hash SHA-512 (em big-endian): 
h[0..7] := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 
 0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179 
Constantes da rodada SHA-512: 
k[0..79] := [ 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 
 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 
 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 
 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 
 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 
 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 
 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 
 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 
 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 
 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 
 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 
 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 
 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 
 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 
 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 
 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817] 
SHA-512 Soma & Sigma: 
S0 := (a rotacionarparadireita 28) xor (a rotacionarparadireita 34) xor (a rotacionarparadireita 39) 
S1 := (e rotacionarparadireita 14) xor (e rotacionarparadireita 18) xor (e rotacionarparadireita 41) 
s0 := (w[i-15] rotacionarparadireita 1) xor (w[i-15] rotacionarparadireita 8) xor (w[i-15] rotacionarparadireita 
7) 
s1 := (w[i-2] rotacionarparadireita 19) xor (w[i-2] rotacionarparadireita 61) xor (w[i-2] rotacionarparadireita 6) 
SHA-384 é idêntica a SHA-512, exceto que:
os valores iniciais de h0 até h7 são diferentes (tirados do 9º até o 16º primo), e
a saída é construída omitindo-se h6 e h7.
Valores hash iniciais SHA-384 (em big-endian): 
h[0..7] := 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939, 
 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4 
SHA-512/t é idêntica à SHA-512 exceto que:
os valores iniciais de h0 até h7 são dados pela função de geração SHA-512/t IV,
a saída é construída truncando-se a concatenação deh0 até h7 em t bits,
t igual a 384 não é permitido, em vez disso, SHA-384 deve ser utilizado como especificado, e
valores t de 224 e 256 são especialmente mencionados como apovados.
A função de geração SHA-512/t IV avalia um SHA-512 modificado na palavra em ASCII "SHA-512/t", substituído com a representação decimal de t.
A SHA-512 modificada é a mesma que SHA-512, exceto que seus valores iniciais de h0 até h7 foram XORados com a constante
hexadecimal 0xa5a5a5a5a5a5a5a5.
Comparação de funções SHA
Na tabela abaixo, estado interno significa a "soma do hash interno" após cada compressão de bloco de dados.
Comparação de funções SHA
Algoritmo e
variantes
Tamanho
da saída 
(bits)
Tamanho
do
estado
interno 
(bits)
Tamanho
do bloco 
(bits)
Tamanho
máximo de
mensagem 
(bits)
Rodadas Operações Segurança (bits)
Performance
Exemplo 
(MiB/s)
MD5 (como
referencia) 128
128 
(4 × 32) 512 2
64 − 1 64
And, Xor,
Rot, 
Add (mod
232), 
Or
<64 
(colisões
encontradas)
335
SHA-0 160 160 (5 × 32) 512 2
64 − 1 80
And, Xor,
Rot, 
Add (mod
232), 
Or
<80 
(colisões
encontradas)
-
SHA-1 160 160 (5 × 32) 512 2
64 − 1 80
<80 
(ataque
teórico[11]
em 261
operações)
192
SHA-
2
SHA-224 
SHA-256
224 
256
256 
(8 × 32) 512 2
64 − 1 64And, Xor,
Rot, 
Add (mod
232), 
Or, Shr
112 
128 139
SHA-384 
SHA-512 
SHA-
512/224 
SHA-
512/256
384 
512 
224 
256
512 
(8 × 64) 1024 2
128 − 1 80
And, Xor,
Rot, 
Add (mod
264), 
Or, Shr
192 
256 
112 
128
154
SHA-
3
SHA3-224 
SHA3-256 
SHA3-384 
SHA3-512
224 
256 
384 
512 1600 
(5 × 5 ×
64)
1152 
1088 
832 
576
Ilimitado 24
And, Xor,
Rot, 
Not
112 
128 
192 
256
-
SHAKE128
SHAKE256
d
(arbitrario)
d
(arbitrario)
1344 
1088
min (d/2,
128) 
min (d/2,
256)
-
Na coluna operações bit a bit, "rot" significa girar sem transporte, e "shr" significa deslocamento lógico para a direita. Todos estes algoritmos
utilizam adição modular de alguma forma, exceto para SHA-3.
Os números de desempenho acima foram para uma aplicação de thread única em um AMD Opteron 8354 rodando a 2,2 GHz sob o Linux em modo
de 64 bits, e servem apenas como um ponto grosseiro para comparação geral. Medidas de desempenho mais detalhadas sobre arquiteturas de
processadores modernos são dados na tabela abaixo.
Arquitetura de
CPU Frequência Algoritmo
Tamanho das
palavras (bits)
Cyclos/byte
x86
MiB/s
x86
Cycles/byte
x86-64
MiB/s
x86-64
Intel Ivy Bridge 3.5 GHz
SHA-256 32-bit 16.80 199 13.05 256
SHA-512 64-bit 43.66 76 8.48 394
AMD Piledriver 3.8 GHz
SHA-256 32-bit 22.87 158 18.47 196
SHA-512 64-bit 88.36 41 12.43 292
Os números de desempenho com a etiqueta 'x86' estavam em execução usando o código de 32 bits em processadores de 64 bits, enquanto que os
números dos x86-64 'são código nativo de 64 bits'. Enquanto SHA-256 foi projetada para cálculos de 32 bits, ela se beneficia de código otimizado
para processadores de 64 bits. Implementações de SHA-512 de 32 bits são significativamente mais lentas do que as suas contrapartidas de 64 bits.
Variantes de ambos os algoritmos com diferentes tamanhos de saída irão executar da mesma forma, uma vez que as funções de compressão e
expansão de mensagem são idênticas, e apenas os valores iniciais de hash e de saída são de diferentes tamanhos. As melhores implementações de
MD5 e SHA-1 realizam entre 4,5 e 6 ciclos por byte em processadores modernos.
O teste foi realizado pela Universidade de Illinois em Chicago, em seu sistema hydra8 executando um Intel Xeon E3-1275 V2 a uma velocidade de
clock de 3,5 GHz, e em seu sistema hydra9 executando um A10-5800K AMD com uma velocidade de clock de 3,8 GHz. Os ciclos referenciados por
byte velocidades acima são o desempenho médio de um algoritmo de resumo deu ma mensagem de 4.096 bytes usando o software de
referenciamento criptográfico Supercop. O desempenho MiB/s é extrapolado a partir da velocidade do clock da CPU em um único núcleo, o
desempenho no mundo real pode variar devido a uma variedade de fatores.
SHA-3
SHA-1
MD5
MD4
 
SHA-256 hash calculator (http://www.xorbin.com/tools/sha256-hash-calculator) (em inglês)
Windows PKI Blog (http://blogs.technet.com/b/pki/archive/2011/02/08/common-questions-about-sha2-and-windows.aspx) (em
inglês)
SHA Algorithms Explained (http://blogs.technet.com/b/pki/archive/2011/02/08/common-questions-about-sha2-and-windows.aspx)
(em inglês)
An Illustrated Guide to Cryptographic Hashes (http://www.unixwiz.net/techtips/iguide-crypto-hashes.html) (em inglês)
CSRC Cryptographic Toolkit (https://web.archive.org/web/20070113064108/http://csrc.nist.gov/CryptoToolkit/tkhash.html) – Site
oficial do NIST para os Padrões de Hashes Seguros (em inglês)
FIPS 180-4: Secure Hash Standard (SHS) (http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf) (PDF, 1.7 MB) – Versão
atual do Padrão de Hash Seguro (SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512), March 2012 (em inglês)
RFC 3174 (com amostra de implementação em C) (em inglês)
Entrevista com Yiqun Lisa Yin falando do ataque sobre SHA-1 (https://www.zdnet.com/news/fixing-a-hole-in-security/141588) (em
inglês)
Explicação de ataques bem sucedidos sobre SHA-1 (http://www.heise-online.co.uk/security/Hash-cracked--/features/75686) (3
pages, 2006) (em inglês)
Pesquisa de Criptografia – Colisão Hash Q&A (http://www.cryptography.com/cnews/hash.html) (em inglês)
1. «Cryptanalysis of SHA-1 - Schneier on Security» (https://www.
schneier.com/blog/archives/2005/02/cryptanalysis_o.html).
www.schneier.com. Consultado em 9 de agosto de 2015
2. «NIST.gov - Computer Security Division - Computer Security
Resource Center» (https://web.archive.org/web/20110625054
822/http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html)
. csrc.nist.gov. Consultado em 9 de agosto de 2015.
Arquivado do original (http://csrc.nist.gov/groups/ST/toolkit/se
cure_hashing.html) em 25 de junho de 2011
3. «Announcing the first SHA1 collision» (https://security.googleb
log.com/2017/02/announcing-first-sha1-collision.html). Google
Online Security Blog. 23 de fevereiro de 2017
4. Somitra Kumar Sanadhya and Palash Sarkar (2008). «New
Collision Attacks Against Up To 24-step SHA-2» (http://eprint.i
acr.org/2008/270.pdf) (PDF). IACR Cryptology ePrint Archive.
2008:270
5. Kazumaro Aoki, Jian Guo, Krystian Matusiewicz, Yu Sasaki,
and Lei Wang (2009). «Preimages for step-reduced SHA-2»
(http://link.springer.com/chapter/10.1007%2F978-3-642-10366
-7_34). Springer Berlin Heidelberg. Advances in Cryptology -
ASIACRYPT 2009. Lecture Notes in Computer Science. 5912:
578–597. ISBN 978-3-642-10366-7. ISSN 0302-9743 (https://
www.worldcat.org/issn/0302-9743). doi:10.1007/978-3-642-
10366-7_34 (https://dx.doi.org/10.1007%2F978-3-642-10366-
7_34)
6. Jian Guo, San Ling, Christian Rechberger, and Huaxiong
Wang (2010). «Advanced meet-in-the-middle preimage
attacks: First results on full Tiger, and improved results on
MD4 and SHA-2» (http://eprint.iacr.org/2010/016.pdf) (PDF).
Springer Berlin Heidelberg. Advances in Cryptology -
ASIACRYPT 2010. Lecture Notes in Computer Science. 6477:
56–75. ISBN 978-3-642-17373-8. ISSN 0302-9743 (https://ww
w.worldcat.org/issn/0302-9743). doi:10.1007/978-3-642-
17373-8_4 (https://dx.doi.org/10.1007%2F978-3-642-17373-8
_4)
7. Mario Lamberger and Florian Mendel (2011). «Higher-Order
Differential Attack on Reduced SHA-256» (http://eprint.iacr.or
g/2011/037.pdf) (PDF). IACR Cryptology ePrint Archive.
2011:37
8. Dmitry Khovratovich, Christian Rechberger and Alexandra
Savelieva (2011). «Bicliques for Preimages: Attacks on Skein-
512 and the SHA-2 family» (http://eprint.iacr.org/2011/286.pdf)
(PDF). IACR Cryptology ePrint Archive. 2011:286
9. Florian Mendel, Tomislav Nad, Martin Schläffer (2013).
«Improving Local Collisions: New Attacks on Reduced SHA-
256» (https://online.tugraz.at/tug_online/voe_main2.getvolltex
t?pCurrPk=69018). Springer Berlin Heidelberg. Advances in
Cryptology – EUROCRYPT 2013. Lecture Notes in Computer
Science. 7881: 262-278. ISBN 978-3-642-38348-9.
ISSN 0302-9743 (https://www.worldcat.org/issn/0302-9743).
doi:10.1007/978-3-642-38348-9_16 (https://dx.doi.org/10.100
7%2F978-3-642-38348-9_16) line feed character character in
|autor= at position 16 (ajuda)
10. Maria Eichlseder and Florian Mendel and Martin Schläffer
(2014). «Branching Heuristics in Differential Collision Search
with Applications to SHA-512» (http://eprint.iacr.org/2014/302.
pdf) (PDF). IACR Cryptology ePrint Archive. 2014:302
11. http://2012.sharcs.org/slides/stevens.pdf
Ver também
Referências
Ligações externas
Online crack sobre Hash SHA1 usando Rainbow tables (http://www.OnlineHashcrack.com) (em inglês)
Hash Site do Projeto: Criptoanálise de SHA-1 baseada em software and hardware (https://web.archive.org/web/20181103112717/
http://hashproject.eu/) (em inglês)
SHA-2 (https://dmoztools.net/Science/Math/Applications/Communication_Theory/Cryptography/Algorithms/Message_Digests)no
DMOZ (em inglês)
Lecture on SHA-1 (https://www.youtube.com/watch?v=5q8q4PhN0cw) no YouTube by Christof Paar (http://www.emsec.rub.de/chai
r/_staff/christof-paar/) (em inglês)
Obtida de "https://pt.wikipedia.org/w/index.php?title=SHA-2&oldid=55203721"
Esta página foi editada pela última vez às 20h02min de 19 de maio de 2019.
Este texto é disponibilizado nos termos da licença Atribuição-CompartilhaIgual 3.0 Não Adaptada (CC BY-SA 3.0) da Creative
Commons; pode estar sujeito a condições adicionais. Para mais detalhes, consulte as condições de utilização.