Loading AI tools
zestaw kryptograficznych funkcji skrótu Z Wikipedii, wolnej encyklopedii
SHA-2 – zestaw kryptograficznych funkcji skrótu (SHA-224, SHA-256, SHA-384, SHA-512) zaprojektowany przez National Security Agency (NSA) i opublikowany w 2001 roku przez National Institute of Standards and Technology (NIST) jako Federalny standard przetwarzania informacji rządu Stanów Zjednoczonych. SHA oznacza Secure Hash Algorithm. SHA-2 zawiera szereg zmian odróżniających go od poprzednika SHA-1. SHA-2 składa się z zestawu czterech funkcji dających skróty wielkości 224, 256, 384 lub 512 bitów.
![]() | |
Rodzaj algorytmu | |
---|---|
Data stworzenia | |
Autorzy | |
Wielkość bloku wyjściowego |
224/256 lub 384/512 [bit] |
Liczba rund |
64 lub 80 |
W roku 2005 zostały zidentyfikowane luki w bezpieczeństwie SHA-1, stwierdzono, że jest zbyt słaby i byłyby pożądane silniejsze funkcje skrótu[1]. Chociaż SHA-2 wykazuje pewne podobieństwo do algorytmu SHA-1, ataki te nie zostały skutecznie rozszerzone na SHA-2.
W 2012 roku wyłoniony został nowy standard SHA-3.
NIST opublikował cztery dodatkowe funkcje skrótu z rodziny SHA, nazwane według ich długości skrótu (w bitach): SHA-224, SHA-256, SHA-384 i SHA-512. Algorytmy są zbiorczo określane jako SHA-2.
Algorytmy zostały opublikowane w 2001 roku w projekcie FIPS PUB 180-2, w którym to czasie zostały zaakceptowane przegląd i uwagi. FIPS PUB 180-2, który obejmuje również SHA-1, został wydany jako oficjalny standard w roku 2002. W lutym 2004 r. został opublikowany zapis o zmianie FIPS PUB 180-2, określając dodatkowy wariant, SHA-224, zdefiniowany w celu dopasowania do długości klucza dwóch kluczowych Triple DES. Warianty te są opatentowane w (US 6829355) Device for and method of one-way cryptographic hashing. (ang.). W Stanach Zjednoczonych ukazał się patent na mocy licencji royalty free[2].
SHA-256 i SHA-512 są nowatorskimi funkcjami skrótu liczonymi odpowiednio na 32- i 64-bitowych słowach. Używają różnych ilości przesunięcia i dodatkowych stałych, ale ich struktury są poza tym praktycznie identyczne, różnią się tylko liczbą rund. SHA-224 i SHA-384 są po prostu obciętymi wersjami dwóch pierwszych, obliczone z różnych wartości początkowych.
Funkcje SHA-2 wypierają przestarzałe SHA-1 szczególnie po tym, jak w 2017 roku została opracowana pierwsza praktyczna metoda generowania kolizji SHA-1[3]. SHA-256 służy do uwierzytelniania pakietów Debian oraz standardu podpisywania wiadomości DKIM; SHA-512 jest częścią systemu uwierzytelniania archiwalnych nagrań video z Międzynarodowym Trybunałem Karnym w ludobójstwie w Rwandzie[4]. SHA-256 i SHA-512 są proponowane do wykorzystania w DNSSEC[5]. Dostawcy Uniksa i Linuksa zmierzają do korzystania z 256- i 512-bitowego SHA-2 do bezpiecznego hashowania hasła[6]. Dyrektywa NIST mówi, że amerykańskie agencje rządowe muszą przestać używać SHA-1 po 2010 r.[7], a zakończenie prac nad SHA-3, może przyspieszyć migrację od SHA-1.
Obecnie najlepsze publiczne ataki łamią 41 z 64 rund SHA-256 lub 46 z 80 rund SHA-512, jak opisano w sekcji „Kryptoanaliza i walidacja” poniżej[8].
W tabeli poniżej wewnętrzny stan oznacza „wewnętrzną sumę hash” po każdej kompresji bloku danych.
Algorytm i wariant |
Rozmiar wyjścia (bity) | Wewnętrzny rozmiar stanu (bity) | Rozmiar bloku (bitów) | Maksymalny rozmiar wiadomości (bitów) | Rozmiar słowa (bity) | Rundy | Operacje | Znalezione Kolizje | Przykładowa wydajność (MB/s) | ||
---|---|---|---|---|---|---|---|---|---|---|---|
32b[9] | 64b[10] | ||||||||||
SHA-0 | 160 | 160 | 512 | 264−1 | 32 | 80 | +,and,or,xor,rot | Tak | – | – | |
SHA-1 | 160 | 160 | 512 | 264−1 | 32 | 80 | +,and,or,xor,rot | Tak[11] | 153 | 192 | |
SHA-2 | SHA-256/224 | 256/224 | 256 | 512 | 264−1 | 32 | 64 | +,and,or,xor,shr,rot | Brak | 111 | 139 |
SHA-512/384 | 512/384 | 512 | 1024 | 2128−1 | 64 | 80 | +,and,or,xor,shr,rot | Brak | 99 | 154 |
Przedstawiona w tabeli wydajność służy do celów porównawczych. Testy przeprowadzano na platformie Intel Core 2 1,83 GHz z systemem Windows Vista w trybie 32-bitowym (dla wersji 32-bitowej) oraz AMD Opteron 8354 2,2 GHz z systemem Linux (dla wersji 64-bitowej).
Funkcja skrótu SHA-2 jest realizowana w niektórych powszechnie używanych aplikacjach bezpieczeństwa i protokołach, w tym TLS i SSL, PGP, SSH, S/MIME, Bitcoin i IPsec.
SHA-1 i SHA-2 są bezpiecznymi algorytmami wymaganymi przepisami prawa do stosowania w niektórych aplikacjach rządu Stanów Zjednoczonych, w tym do stosowania w innych algorytmach kryptograficznych i protokołach w celu ochrony poufnych informacji. FIPS PUB 180-1 zachęca również do wdrażania i stosowania SHA-1 przez organizacje prywatne i komercyjne. SHA-1 przestaje się już używać do większości zastosowań rządu; amerykański Narodowy Instytut Standaryzacji i Technologii zaleca: „Agencje federalne powinny jak najszybciej przestać używać SHA-1 do ... zastosowań wymagających odporności na kolizje, natomiast po 2010 muszą używać rodziny funkcji skrótu SHA-2 do tych zastosowań” (podkreślenie w oryginale)[12].
Dla funkcji skrótu znalezienie wiadomości, która odpowiada podanemu skrótowi, nazywa się atakiem preimage. Dla funkcji zwracającej skróty o długości L bitów może być on zawsze wykonany przy użyciu wyszukiwania brute force w 2L próbach, a jego praktyczność zależy od wielkości L i konkretnego środowiska komputerowego. Drugi rodzaj ataku, czyli znalezienie dwóch różnych wiadomości o tym samym skrócie, znany jest jako kolizja. Zużywa on średnio tylko 2L/2 obliczeń funkcji przy wykorzystaniu ataku urodzinowego.
Aplikacje używające skrótów kryptograficznych w zastosowaniach takich jak przechowywanie haseł są tylko w minimalnym stopniu narażone na atak kolizji. Wytworzenie hasła, które działa na danym koncie, wymaga ataku preimage, jak również dostępu do hasha z oryginalnego hasła (zwykle w pliku shadow
), co może, ale nie musi, być trywialne. Odwrócenie szyfrowania haseł (np. do uzyskania hasła, aby spróbować wejść na konto użytkownika w innym miejscu) nie jest możliwe przez takie ataki (jednak nawet bezpieczny hash hasła nie może zapobiec skutecznym atakom brute-force na słabe hasła).
W przypadku podpisywania dokumentów, ataku kolizji nie da się użyć do uzyskania fałszywego podpisu istniejącego dokumentu. Atakujący musi wyprodukować parę dokumentów o tym samym skrócie: niewinny i szkodliwy, i nakłonić posiadacza klucza prywatnego do podpisania nieszkodliwego dokumentu. Istnieją praktyczne okoliczności, w których jest to możliwe, np. do końca 2008 roku udało się stworzyć fałszywe certyfikaty SSL za pomocą kolizji MD5[13].
Istnieją dwa ataki preimage typu meet-in-the-middle przeciw SHA-2 ze zmniejszoną liczbą rund. Pierwszy atakuje SHA-256 z 41 rundami (zamiast 64) ze złożonością czasową 2253,5 i złożonością miejsca 216 oraz SHA-512 z 46 rundami (zamiast 80) w czasie 2511,5 i z miejscem 23[14]. Drugi atakuje 42-rundowe SHA-256 ze złożonością czasową 2251,7 i złożonością miejsca 212 oraz 42-rundowe SHA-512 w czasie 2502 i z miejscem 222[15].
Wdrożenie wszystkich zatwierdzonych przez FIPS funkcji bezpieczeństwa może być oficjalnie zatwierdzone przez program CMVP, wspólnie przez National Institute of Standards and Technology (NIST) oraz Communications Security Establishment (CSE). Dla nieformalnej weryfikacji, pakiet do tworzenia dużej liczby wektorów testowych jest udostępniony do pobrania na stronie NIST; wynikowa weryfikacja jednak nie zastępuje w żaden sposób formalnego potwierdzenia CMVP, które jest wymagane przez prawo do pewnych zastosowań.
Hash pustego łańcucha:
SHA224("") 0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f SHA256("") 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 SHA384("") 0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b SHA512("") 0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
Nawet niewielka zmiana w wiadomości (z przeważającym prawdopodobieństwem) da w wyniku bardzo różniący się hash ze względu na efekt lawinowy . Na przykład dodanie kropki do końca zdania:
SHA224("The quick brown fox jumps over the lazy dog") 0x730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525 SHA224("The quick brown fox jumps over the lazy dog.") 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c
SHA256("The quick brown fox jumps over the lazy dog") 0xd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592 SHA256("The quick brown fox jumps over the lazy dog.") 0xef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c
SHA384("The quick brown fox jumps over the lazy dog") 0xca737f1014a48f4c0b6dd43cb177b0afd9e5169367544c494011e3317dbf9a509cb1e5dc1e85a941bbee3d7f2afbc9b1 SHA384("The quick brown fox jumps over the lazy dog.") 0xed892481d8272ca6df370bf706e4d7bc1b5739fa2177aae6c50e946678718fc67a7af2819a021c2fc34e91bdb63409d7
SHA512("The quick brown fox jumps over the lazy dog") 0x07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6 SHA512("The quick brown fox jumps over the lazy dog.") 0x91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bbc6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed
Pseudokod dla algorytmu SHA-256 jest następujący. Zauważmy wielki wzrost mieszania bitów w[16..63]
słowa w stosunku do SHA-1.
Uwaga 1: Wszystkie zmienne są podpisane 32 bitowe bez znaku i przy obliczaniu zawijają się modulo 232 Uwaga 2: Wszystkie stałe w tym pseudokodzie są w big endian Inicjowanie zmiennych (Pierwsze 32 bity ułamkowych części pierwiastków kwadratowych 8 pierwszych liczb pierwszych 2 .. 19): h [0 .. 7]: = 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 Inicjacja tablicy stałych rund (Pierwsze 32 bity ułamkowych części pierwiastka sześciennego pierwszych 64 liczb pierwszych 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 Obróbka wstępna: dołącz bit '1 'do wiadomości dołącz k bitów '0', gdzie k jest minimalną liczbą>=0 taką, że w wyniku długość wiadomości (w bitach) mod 512 jest 448 dołącz długość wiadomości (przed wstępnego przetwarzaniem), w bitach, jako 64-bitową całkowitą big-endian Obróbka wiadomości w kolejnych 512-bitowych kawałkach: podziel wiadomość na 512-bitowe kawałki dla każdego kawałka podziel kawałek na szesnaście 32-bitowych słów big-endian w [0..15] Rozszerz szesnaście 32-bitowych słów na sześćdziesiąt cztery 32-bitowe słowa: 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 Inicjalizuj wartość skrótu dla tego kawałka: a := h0 b := h1 c := h2 d := h3 e := h4 f := h5 g := h6 h := h7 Pętla główna: 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) t1 := 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) t2 := s0 + maj h := g g := f f := e e := d + t1 d := c c := b b := a a := t1 + t2 Dodaj ten hash kawałka do bieżącego rezultatu: h0: = h0 + a h1: = h1 + b h2: = h2 + c h3: = h3 + d h4: = h4 + e h5: = h5 + f h6: = h6 + g h7: = h7 + h Wyprodukuj ostateczną wartość skrótu (big-endian): digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
Obliczanie wartości ch
i maj
może być zoptymalizowane w taki sam sposób, jak opisano dla SHA-1.
SHA-224 jest identyczne z SHA-256, z wyjątkiem:
h0
do h7
są odmienne, ih7
.Oto początkowe wartości zmiennych (w big endian): (Drugie 32 bity ułamkowej części pierwiastków kwadratowych od 9. do 16. liczby pierwszej 23 .. 53) h[0..7] := 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
SHA-512 jest identyczne w konstrukcji, ale:
SHA-384 jest identyczny z SHA-512, z wyjątkiem:
h0
do h7
są odmienne (wzięte od 9. do 16. liczby pierwszej), ah6
i h7
.Funkcji SHA mieszania można znaleźć w wielu współczesnych językach programowania, takich jak Java[16], Python[17], PHP[18], Perl[19], C#[20] i R[21].
crypto
zawierająca darmowe i otwarte implementacje SHA-1, SHA-224, SHA-256, SHA-384 i SHA-512Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.