| 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 é 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 dehash seguro). Funções hash criptográficas são operações matemáticas executadas em dados digitais; comparando ohash 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 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.
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 3DES 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 novafunçã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 deautenticaçã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.
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-1 para ... 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 oWindows 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 queL é 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 em2L avaliações. Isto é chamado um ataque de preimagem e pode ou não ser prático, dependendo deL 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, apenas2L/2 avaliações usando umataque 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.
| 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 | 228.5 |
| SHA-512 | 24/80 | 232.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 | 2248.4 |
| SHA-512 | 42/80 | 2494.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 | 2255.5 |
| SHA-512 | 50/80 | 2511.5 | ||||
| Pseudo-preimagem | SHA-256 | 52/64 | 2255 | |||
| SHA-512 | 57/80 | 2511 | ||||
| Improving Local Collisions: New Attacks on Reduced SHA-256[9] | 2013 | Diferencial | Colisão | SHA-256 | 31/64 | 265.5 |
| Pseudo-colisão | SHA-256 | 38/64 | 237 | |||
| Branching Heuristics in Differential Collision Search with Applications to SHA-512[10] | 2014 | Diferencial heurístico | Pseudo-colisão | SHA-512 | 38/80 | 240.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 d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fSHA256("")0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855SHA384("")0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bSHA512("")0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3eSHA512/224("")0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4SHA512/256("")0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967aAté mesmo uma pequena mudança na mensagem irá (com probabilidade massiva) resultar em um hash bastante diferente, devido aoefeito avalanche. Por exemplo, adicionando um ponto final ao final da frase:
SHA224("The quick brown fox jumps over the lazy dog")0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525SHA224("The quick brown fox jumps over the lazy dog.")0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cSegue 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 232Nota 2: Para cada rodada, há uma constante da rodada k[i] e uma entrada no array de agendamento da mensagem w[i], 0 ≤ i ≤ 63Nota 3: A compressão utiliza 8 variáveis funcionais, de a até hNota 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 := 0x6a09e667h1 := 0xbb67ae85h2 := 0x3c6ef372h3 := 0xa54ff53ah4 := 0x510e527fh5 := 0x9b05688ch6 := 0x1f83d9abh7 := 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' à mensagemanexar k bits '0', onde k é o menor 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), embits, 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 bitspara 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 ide 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 f := h5 g := h6 h := h7
Laço principal da função de compressão:para ide 0 até 63 S1 := (erotacionarparadireita 6)xor (erotacionarparadireita 11)xor (erotacionarparadireita 25) ch := (ee f)xor ((não e)e g) temp1 := h+ S1+ ch+ k[i]+ w[i] S0 := (arotacionarparadireita 2)xor (arotacionarparadireita 13)xor (arotacionarparadireita 22) maj := (ae b)xor (ae c)xor (be 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 := h0anexar h1anexar h2anexar h3anexar h4anexar h5anexar h6anexar 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:
h0 até h7 são diferentes, eh7.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,
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 := (arotacionarparadireita 28)xor (arotacionarparadireita 34)xor (arotacionarparadireita 39)S1 := (erotacionarparadireita 14)xor (erotacionarparadireita 18)xor (erotacionarparadireita 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:
h0 atéh7 são diferentes (tirados do 9º até o 16º primo), eh6 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:
h0 até h7 são dados pelafunção de geraçãoSHA-512/t IV,h0 atéh7 em t bits,A função de geração SHA-512/t IV avalia umSHA-512 modificado na palavra em ASCII "SHA-512/t", substituído com a representação decimal det. 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.
Na tabela abaixo, estado interno significa a "soma do hash interno" após cada compressão de bloco de dados.
| 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 | 264 − 1 | 64 | And, Xor, Rot, Add (mod 232), Or | <64 (colisões encontradas) | 335 | |
| SHA-0 | 160 | 160 (5 × 32) | 512 | 264 − 1 | 80 | And, Xor, Rot, Add (mod 232), Or | <80 (colisões encontradas) | - | |
| SHA-1 | 160 | 160 (5 × 32) | 512 | 264 − 1 | 80 | <80 (ataque teórico[11] em 261 operações) | 192 | ||
| SHA-2 | SHA-224 SHA-256 | 224 256 | 256 (8 × 32) | 512 | 264 − 1 | 64 | And, 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 | 2128 − 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/bytex86 | MiB/s x86 | Cycles/bytex86-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 umIntel 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.
|autor= at position 16 (ajuda) !CS1 manut: Nomes múltiplos: lista de autores (link)