SHA -2 - SHA-2

SHA-2 ( Secure Hash Algorithm 2 ) je sada kryptografických hashovacích funkcí navržených americkou národní bezpečnostní agenturou (NSA) a poprvé publikované v roce 2001. Jsou postaveny pomocí konstrukce Merkle – Damgård , z jednosměrné kompresní funkce sám byl postaven pomocí struktury Davies -Meyer ze specializované blokové šifry .

SHA-2 obsahuje významné změny oproti svému předchůdci SHA-1 . Rodina SHA-2 se skládá ze šesti hashovacích funkcí s digesty (hodnotami hash), které jsou 224, 256, 384 nebo 512 bitů: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA -512/256 . SHA-256 a SHA-512 jsou nové hashovací funkce počítané s osmi 32bitovými a 64bitovými slovy. Používají různá množství posunu a aditivní konstanty, ale jejich struktury jsou jinak prakticky identické, liší se pouze počtem kol. SHA-224 a SHA-384 jsou zkrácené verze SHA-256 a SHA-512, v tomto pořadí, vypočítané s různými počátečními hodnotami. SHA-512/224 a SHA-512/256 jsou také zkrácené verze SHA-512, ale počáteční hodnoty jsou generovány metodou popsanou v PUB 180-4 Federal Information Processing Standards (FIPS).

SHA-2 byl poprvé publikován Národním institutem pro standardy a technologie (NIST) jako federální standard USA (FIPS). Rodina algoritmů SHA-2 je patentována v americkém patentu 6829355. Spojené státy americké patent uvolnily pod licencí bez licenčních poplatků .

Od roku 2011 nejlepší veřejné útoky narušují odolnost před obrazem u 52 ze 64 nábojů SHA-256 nebo 57 z 80 nábojů SHA-512 a odolnost proti kolizi u 46 ze 64 nábojů SHA-256.

Hash standard

Jedna iterace v kompresní funkci rodiny SHA-2. Modré komponenty provádějí následující operace: Bitová rotace používá pro SHA-512 různé konstanty. Uvedená čísla jsou pro SHA-256. Červená je přídavná modulo 2 ³² pro SHA-256 nebo 2 ⁶⁴ pro SHA-512.
    ${\ displaystyle \ operatorname {Ch} (E, F, G) = (E \ land F) \ oplus (\ neg E \ land G)}$
    ${\ displaystyle \ operatorname {Ma} (A, B, C) = (A \ land B) \ oplus (A \ land C) \ oplus (B \ land C)}$
    ${\ Displaystyle \ Sigma _ {0} (A) = (A \! \ ggg \! 2) \ oplus (A \! \ ggg \! 13) \ oplus (A \! \ ggg \! 22)}$
    ${\ Displaystyle \ Sigma _ {1} (E) = (E \! \ ggg \! 6) \ oplus (E \! \ ggg \! 11) \ oplus (E \! \ ggg \! 25)}$

${\ displaystyle \ color {red} \ boxplus}$

S vydáním FIPS PUB 180-2 přidal NIST tři další hashovací funkce v rodině SHA. Algoritmy jsou souhrnně označovány jako SHA-2, pojmenované podle délky jejich digestu (v bitech): SHA-256, SHA-384 a SHA-512.

Algoritmy byly poprvé publikovány v roce 2001 v návrhu FIPS PUB 180-2, kdy byla přijata veřejná kontrola a komentáře. V srpnu 2002 se FIPS PUB 180-2 stal novým standardem Secure Hash , který nahradil FIPS PUB 180-1, který byl vydán v dubnu 1995. Aktualizovaný standard zahrnoval původní algoritmus SHA-1 s aktualizovaným technickým zápisem v souladu s popisem vnitřní fungování rodiny SHA-2.

V únoru 2004 bylo zveřejněno oznámení o změně pro FIPS PUB 180-2, které specifikuje další variantu SHA-224, definovanou tak, aby odpovídala délce klíče dvouklíčového Triple DES . V říjnu 2008 byl standard aktualizován v FIPS PUB 180-3, včetně SHA-224 z oznámení o změně, ale jinak neprováděl žádné zásadní změny standardu. Primární motivací pro aktualizaci standardu bylo přemístění bezpečnostních informací o hashovacích algoritmech a doporučení pro jejich použití do Special Publications 800-107 a 800-57. Podrobná testovací data a ukázkové přehledy zpráv byly také odstraněny ze standardu a poskytnuty jako samostatné dokumenty.

V lednu 2011 NIST publikoval SP800-131A, který specifikoval přechod z tehdy aktuálního minima 80bitového zabezpečení (poskytovaného SHA-1) povoleného pro použití federální vládou do konce roku 2013, na 112bitové zabezpečení (za předpokladu SHA-2), což je minimální požadavek (počínaje rokem 2014) a doporučený stupeň zabezpečení (počínaje datem vydání v roce 2011).

V březnu 2012 byl standard aktualizován ve FIPS PUB 180-4 přidáním hashovacích funkcí SHA-512/224 a SHA-512/256 a popisem metody pro generování počátečních hodnot pro zkrácené verze SHA-512. Kromě toho bylo odstraněno omezení vyplňování vstupních dat před výpočtem hash, což umožňuje počítat hash data současně s generováním obsahu, jako je video nebo audio feed v reálném čase. Před výstupem hashování musí stále dojít k vyplnění finálního bloku dat.

V červenci 2012 NIST revidoval SP800-57, který poskytuje pokyny pro správu kryptografických klíčů. Publikace neumožňovala vytváření digitálních podpisů s bezpečností hash nižší než 112 bitů po roce 2013. Předchozí revize z roku 2007 stanovila mezní hodnotu na konec roku 2010. V srpnu 2012 NIST stejným způsobem revidovala SP800-107.

Funkce soutěž NIST hash zvolení nového hashovací funkci SHA-3 , v roce 2012. SHA-3 algoritmus není odvozen od SHA-2.

Aplikace

Funkce hash SHA-2 je implementována v některých široce používaných bezpečnostních aplikacích a protokolech, včetně TLS a SSL , PGP , SSH , S/MIME a IPsec .

SHA-256 se účastní procesu autentizace softwarových balíků Debianu a standardu pro podepisování zpráv DKIM ; SHA-512 je součástí systému autentizace archivního videa z Mezinárodního trestního tribunálu pro rwandskou genocidu . SHA-256 a SHA-512 jsou navrženy pro použití v DNSSEC . Prodejci Unixu a Linuxu přecházejí na 256- a 512bitové SHA-2 pro bezpečné hašování hesel.

Několik cryptocurrencies , včetně Bitcoin , pouze SHA-256 pro ověření transakce a výpočet doklad o práci nebo doklad o sázce . Vzestup akceleračních čipů ASIC SHA-2 vedl k použití schémat proof-of-work na bázi scryptu .

SHA-1 a SHA-2 jsou algoritmy Secure Hash vyžadované zákonem pro použití v určitých vládních aplikacích USA , včetně použití v rámci jiných kryptografických algoritmů a protokolů, pro ochranu citlivých neutajovaných informací. FIPS PUB 180-1 také podpořil přijetí a používání SHA-1 soukromými a komerčními organizacemi. SHA-1 je vyřazován pro většinu vládních použití; americký národní institut pro standardy a technologie říká: „Federální agentury by měly přestat používat SHA-1 pro ... aplikace, které vyžadují odolnost proti kolizím, jakmile to bude praktické, a musí pro tyto aplikace po roce 2010 používat rodinu hashovacích funkcí SHA-2“ (důraz v originále). Doufalo se, že směrnice NIST, že americké vládní agentury musí přestat používat SHA-1 po roce 2010, urychlí migraci mimo SHA-1.

Funkce SHA-2 nebyly původně přijaty rychle, navzdory lepšímu zabezpečení než SHA-1. Mezi důvody může patřit nedostatečná podpora pro SHA-2 v systémech se systémem Windows XP SP2 nebo starším a nedostatek vnímané naléhavosti, protože kolize SHA-1 dosud nebyly nalezeny. Tým Google Chrome oznámil plán, aby jejich webový prohlížeč postupně přestal ctít certifikáty TLS závislé na SHA-1 v období od konce roku 2014 do začátku roku 2015. Podobně společnost Microsoft oznámila, že aplikace Internet Explorer a Edge přestanou ctít veřejné podpisy SHA-1 Certifikáty TLS z února 2017. Mozilla deaktivovala SHA-1 na začátku ledna 2016, ale po problémech s webovým uživatelským rozhraním některých modelů routerů a bezpečnostních zařízení jej musela dočasně znovu povolit prostřednictvím aktualizace Firefoxu .

Kryptoanalýza a validace

U hashovací funkce, pro kterou L je počet bitů v souhrnu zpráv , lze nalezení zprávy, která odpovídá danému souhrnu zpráv, vždy provést pomocí vyhledávání hrubou silou při hodnocení 2 ^L. Toto se nazývá útok před obrazem a může, ale nemusí být praktické v závislosti na L a konkrétním výpočetním prostředí. Druhé kritérium, nalezení dvou různých zpráv, které produkují stejný souhrn zpráv, známé jako kolize , vyžaduje v průměru pouze 2 hodnocení ^{L /2} pomocí narozeninového útoku .

Některé aplikace, které používají kryptografické hashování, například úložiště hesel, jsou kolizním útokem ovlivněny jen minimálně . Vytvoření hesla, které funguje pro daný účet, vyžaduje útok před obrazem a také přístup k hašování původního hesla (obvykle v shadowsouboru), které může, ale nemusí být triviální. Obrácení šifrování hesla (např. Pro získání hesla k vyzkoušení proti účtu uživatele jinde) není útoky umožněno. (Ani bezpečný hash hesel však nemůže zabránit útokům hrubou silou na slabá hesla .)

V případě podpisu dokumentu nemohl útočník jednoduše zfalšovat podpis ze stávajícího dokumentu - útočník by musel předložit dvojici dokumentů, jeden neškodný a jeden poškozující, a přimět držitele soukromého klíče k podepsání neškodného dokumentu. Existují praktické okolnosti, za nichž je to možné; do konce roku 2008 bylo možné vytvářet padělané certifikáty SSL pomocí kolize MD5, kterou by akceptovaly široce používané webové prohlížeče.

Zvýšený zájem o analýzu kryptografických hashů během soutěže SHA-3 přineslo několik nových útoků na rodinu SHA-2, z nichž nejlepší jsou uvedeny v tabulce níže. Prakticky složité jsou pouze kolizní útoky; žádný z útoků se nevztahuje na plnou kulatou hashovací funkci.

Na FSE 2012 vědci ze společnosti Sony přednesli prezentaci, která naznačuje, že pseudo-kolizní útoky by mohly být prodlouženy na 52 ran na SHA-256 a 57 kol na SHA-512 stavěním na dvoustranném pseudo- preimage útoku.

Oficiální ověření

Implementace všech bezpečnostních funkcí schválených FIPS lze oficiálně ověřit prostřednictvím programu CMVP , který společně provozují Národní institut pro standardy a technologie (NIST) a Komunikační bezpečnostní zařízení (CSE). Pro neformální ověření je na webu NIST k dispozici ke stažení balíček pro generování vysokého počtu testovacích vektorů; výsledné ověření však nenahrazuje formální ověření CMVP, které je u určitých aplikací vyžadováno zákonem.

V prosinci 2013 existuje více než 1300 ověřených implementací SHA-256 a více než 900 SHA-512, přičemž pouze 5 z nich je schopno zpracovávat zprávy s délkou v bitech, která není násobkem osmi, přičemž podporují obě varianty.

Testovací vektory

Hodnoty hash prázdného řetězce (tj. Vstupní text nulové délky).

SHA224("")
0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
SHA256("")
0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
SHA384("")
0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
SHA512("")
0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
SHA512/224("")
0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4
SHA512/256("")
0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a

I malá změna ve zprávě bude (s drtivou pravděpodobností) mít za následek většinou jiný hash, kvůli lavinovému efektu . Například přidání tečky na konec následující věty změní téměř polovinu (111 z 224) bitů v hash:

SHA224("The quick brown fox jumps over the lazy dog")
0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525
SHA224("The quick brown fox jumps over the lazy dog.")
0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c

Pseudo kód

Následuje pseudokód pro algoritmus SHA-256. Všimněte si velkého nárůstu míchání mezi bity w[16..63]slov ve srovnání s SHA-1.

Note 1: All variables are 32 bit unsigned integers and addition is calculated modulo 232
Note 2: For each round, there is one round constant k[i] and one entry in the message schedule array w[i], 0 ≤ i ≤ 63
Note 3: The compression function uses 8 working variables, a through h
Note 4: Big-endian convention is used when expressing the constants in this pseudocode,
    and when parsing message block data from bytes to words, for example,
    the first word of the input message "abc" after padding is 0x61626380

Initialize hash values:
(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
h0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19

Initialize array of round constants:
(first 32 bits of the fractional parts of the cube roots of the first 64 primes 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-processing (Padding):
begin with the original message of length L bits
append a single '1' bit
append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512
append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits
such that the bits in the message are L 1 00..<K 0's>..00 <L as 64 bit integer> = k*512 total bits

Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
    create a 64-entry message schedule array w[0..63] of 32-bit words
    (The initial values in w[0..63] don't matter, so many implementations zero them here)
    copy chunk into first 16 words w[0..15] of the message schedule array

    Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array:
    for i from 16 to 63
        s0 := (w[i-15] rightrotate  7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift  3)
        s1 := (w[i- 2] rightrotate 17) xor (w[i- 2] rightrotate 19) xor (w[i- 2] rightshift 10)
        w[i] := w[i-16] + s0 + w[i-7] + s1

    Initialize working variables to current hash value:
    a := h0
    b := h1
    c := h2
    d := h3
    e := h4
    f := h5
    g := h6
    h := h7

    Compression function main loop:
    for i from 0 to 63
        S1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
        ch := (e and f) xor ((not e) and g)
        temp1 := h + S1 + ch + k[i] + w[i]
        S0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
        maj := (a and b) xor (a and c) xor (b and c)
        temp2 := S0 + maj
 
        h := g
        g := f
        f := e
        e := d + temp1
        d := c
        c := b
        b := a
        a := temp1 + temp2

    Add the compressed chunk to the current hash value:
    h0 := h0 + a
    h1 := h1 + b
    h2 := h2 + c
    h3 := h3 + d
    h4 := h4 + e
    h5 := h5 + f
    h6 := h6 + g
    h7 := h7 + h

Produce the final hash value (big-endian):
digest := hash := h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7

Výpočet hodnot cha majlze optimalizovat stejným způsobem, jak je popsáno pro SHA-1 .

SHA-224 je identický s SHA-256, kromě toho, že:

• počáteční hodnoty hash h0až h7jsou různé, a
• výstup je konstruován vynecháním h7.

SHA-224 initial hash values (in big endian):
(The second 32 bits of the fractional parts of the square roots of the 9th through 16th primes 23..53)
h[0..7] :=
    0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4

SHA-512 má stejnou strukturu jako SHA-256, ale:

• zpráva je rozdělena na 1024bitové bloky,
• počáteční hodnoty hash a kulaté konstanty jsou rozšířeny na 64 bitů,
• místo 64 je 80 nábojů,
• pole plánu zpráv w má 80 64bitových slov namísto 64 32bitových slov,
• pro rozšíření pole plánu zpráv w je smyčka od 16 do 79 namísto od 16 do 63,
• kruhové konstanty jsou založeny na prvních 80 prvočíslech 2..409,
• velikost slova použitá pro výpočty je 64 bitů dlouhá,
• připojená délka zprávy (před předzpracováním) v bitech je 128bitové big-endianové celé číslo a
• použité hodnoty posunu a otočení jsou různé.

SHA-512 initial hash values (in big-endian):

h[0..7] := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 
           0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179

SHA-512 round constants:

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 Sum & Sigma:

S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)

s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)

SHA-384 je identický s SHA-512, kromě toho, že:

• počáteční hodnoty hash h0prostřednictvím h7jsou odlišné (převzato od 9. do 16. připraví), a
• výstup je konstruován vynecháním h6a h7.

SHA-384 initial hash values (in big-endian):

h[0..7] := 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939, 
           0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4

SHA-512/t je identický s SHA-512 s tím rozdílem, že:

• počáteční hodnoty hash h0až h7jsou dány funkcí generování IV SHA-512 / t ,
• výstup je konstruován zkrácením zřetězení h0skrz h7na t bitů,
• t rovno 384 není povoleno, místo toho by měl být použit SHA-384, jak je uvedeno, a
• Jako schválené jsou zvláště uvedeny hodnoty t 224 a 256.

Funkce generování SHA-512/ t IV vyhodnocuje upravený SHA-512 na ASCII řetězci "SHA-512/ t ", nahrazený desetinnou reprezentací t . Modifikovaná SHA-512 je stejný jako SHA-512 s výjimkou jeho počáteční hodnoty h0prostřednictvím h7nabízejí vždy po XORed s hexadecimálním konstantou 0xa5a5a5a5a5a5a5a5.

Ukázkovou implementaci C pro SHA-2 rodinu hashovacích funkcí najdete v RFC 6234.

Porovnání funkcí SHA

V níže uvedené tabulce vnitřní stav znamená „vnitřní součet hash“ po každé kompresi datového bloku.

Ve sloupci bitových operací „Rot“ znamená otočit no carry a „Shr“ znamená pravý logický posun . Všechny tyto algoritmy používají určitým způsobem modulární sčítání kromě SHA-3.

Podrobnější měření výkonu na moderních architekturách procesorů jsou uvedena v tabulce níže.

Čísla výkonu označená 'x86' byla spuštěna pomocí 32bitového kódu na 64bitových procesorech, zatímco čísla 'x86-64' jsou nativní 64bitový kód. Přestože je SHA-256 navržen pro 32bitové výpočty, těží z kódu optimalizovaného pro 64bitové procesory na architektuře x86. 32bitové implementace SHA-512 jsou výrazně pomalejší než jejich 64bitové protějšky. Varianty obou algoritmů s různými výstupními velikostmi budou fungovat podobně, protože funkce rozšíření a komprese zpráv jsou totožné a liší se pouze počáteční hodnoty hash a výstupní velikosti. Nejlepší implementace MD5 a SHA-1 provádějí mezi 4,5 a 6 cykly na bajt na moderních procesorech.

Testování provedla University of Illinois v Chicagu na svém systému hydra8 s procesorem Intel Xeon E3-1275 V2 s taktem 3,5 GHz a na systému hydra9 s procesorem AMD A10-5800K APU s taktem 3,8 GHz. Uvedené rychlosti cyklů na bajt výše jsou mediánem výkonu algoritmu trávícího 4 096 bajtů zprávy pomocí softwaru SUPERCOP pro kryptografický benchmarking. Výkon MiB/s je extrapolován z taktovací rychlosti CPU na jednom jádru; výkon v reálném světě se bude lišit v důsledku řady faktorů.

Implementace

Níže je uveden seznam kryptografických knihoven, které podporují SHA-2:

• Botan
• Skákací hrad
• Cryptlib
• Crypto ++
• Libgcrypt
• Mbed TLS
• libsodium
• Kopřiva
• LibreSSL
• OpenSSL
• GnuTLS
• wolfSSL

Hardwarovou akceleraci zajišťují následující rozšíření procesoru:

• Rozšíření Intel SHA : K dispozici u některých procesorů Intel a AMD x86.
• VIA PadLock
• Rozšíření kryptografie ARMv8

Viz také

• Porovnání kryptografických hashovacích funkcí
• Porovnání knihoven kryptografie
• Shrnutí zabezpečení funkce hash
• Hashcash
• HMAC
• Mezinárodní asociace pro kryptologický výzkum (IACR)
• sha1sum( sha224sum, sha256sum, sha384sumA sha512sum) příkazy
• Důvěryhodné časové razítko

Reference

Další čtení

externí odkazy

• Popisy SHA-256, SHA-384 a SHA-512 od NIST
• SHA-2 Checker -SHAChecker pro kontrolu něčí kompatibility SSL pro SHA-2
• Specifikace standardu Secure Hash (SHS) -Návrh pro navrhovaný SHS (SHA-0)
• Secure Hash Standard (SHS) -Navrhovaný SHS (SHA-0)
• CSRC Cryptographic Toolkit - oficiální stránka NIST pro standard Secure Hash
• FIPS PUB 180-4: Secure Hash Standard (SHS) ( PDF , 834 KB) -Aktuální verze Secure Hash Standard (SHA-1, SHA-224, SHA-256, SHA-384 a SHA-512), srpen 2015
• Testovací vektory pro SHA-256/384/512 z projektu NESSIE
• Testovací vektory na SHA-1, SHA-2 z místa NIST
• NIST Cryptographic Hash Project -soutěž SHA-3
• RFC  3874 : "224bitová jednosměrná hashovací funkce: SHA-224"
• RFC  6234 : „US Secure Hash Algorithms (SHAC and SHA-based HMAC and HKDF)“; obsahuje ukázku implementace C.