SHA-2

Az SHA-2 ( Secure Hash Algorithm ) egy hash függvénycsalád , amelyet az Egyesült Államok Nemzetbiztonsági Ügynöksége (NSA) tervezett, az SHA-1 és SHA-0 függvények mintájára , amelyek maguk is erősen inspirálták Ron Rivest MD4 funkcióját . (amely párhuzamos MD5-t adott ). Amint azt a Nemzeti Szabványügyi és Technológiai Intézet (NIST) leírta , magában foglalja az SHA-256 és SHA-512 függvényeket, amelyek algoritmusai hasonlóak, de különböző szóméretekkel működnek (32 bit az SHA-256-nál és 64 bit az SHA-512-nél. ), Az SHA-224 és az SHA-384, amelyek lényegében az előzőek csonka kimenettel rendelkező változatai, és újabban az SHA-512/256 és SHA-512/224, amelyek az SHA-512 csonka változatai. Az utolsó utótag a hash bitjeinek számát jelzi.

Az SHA-2 család, az SHA-256, az SHA-384 és az SHA-512 algoritmusait az SHA1 vállalat az Egyesült Államok szokásos szövetségi kormányaként ( Federal Information Processing Standard ) írja le és publikálja a FIPS 180 -2-ben (Secure Hash Standard) 2002-től (a hozzászólások előkészítése 2001-ben készült). Az SHA-224 funkció egy kicsit később kerül hozzáadásra. A legújabb verzió a mai napig, FIPS 180-4 (Secure Hash szabvány) időpontokat2012. március és hozzáteszi az SHA-512/256 és az SHA-512/224 funkciókat.

2005 - ben kiemelték az SHA-1 biztonsági problémáit : van egy elméleti támadás az ütközések kutatásához, amely lényegesen gyorsabb, mint a hash funkciók elleni általános születésnapi támadás . Noha az SHA-2 algoritmus megegyezik az SHA-1 algoritmusával, ezek a támadások jelenleg nem terjeszthetők ki az SHA-2-re. A NIST azonban versenyt tartott egy új hash függvény, az SHA-3 kiválasztására . 2012 végén a verseny eredményeként egy új funkciócsaládot választottak, amelynek kialakítása nagyon különbözik az SHA-1-től és az SHA-2-től. Az új funkciócsaládot egy másik lehetséges választásként mutatják be, ez legalábbis egyelőre nem kérdőjelezi meg az SHA-2 használatát.

Leírás

Mint minden hash függvény, az SHA-2 funkciók is tetszőleges méretű üzenetet vesznek be bemenetként, annak korlátozásával (minden elméleti értékkel), és eredményt (úgynevezett " hash ", hash , kondenzátum vagy akár ujjlenyomat ...) rögzített méret. A kivonat méretét az utótag jelzi: 224 bit az SHA-224, 256 bit az SHA-256, 384 bit az SHA-384 és 512 bit az SHA-512 esetében.

Az SHA-2 család algoritmusai nagyon hasonlóak, alapvetően két különböző funkció létezik, az SHA-256 és az SHA-512, a többiek az egyik vagy a másik variációi. Az SHA-256 és SHA-512 függvények felépítése azonos, de különböznek a használt szavak és blokkok méretétől. Ez a szerkezet meglehetősen hasonlít az SHA-1 szerkezetéhez, de egy kicsit összetettebb és elkerüli bizonyos ismert gyengeségeket. Általánosabban kapcsolódik a hash funkciók családjához, amelyet Ron Rivest MD4 és MD5 ihletett . Primitívnek találjuk az n rögzített nagyságú egész számok összeadását , azaz a modulo 2 n összeadást , egy nemlineáris műveletet (a lineáris algebra értelmében ) a Booleans F 2 területén , valamint a bitenkénti műveleteket (xor és mások).

A család minden funkciójához hasonlóan (kivéve az SHA-3-at, amely szivacsfunkción alapul ) iteratív sémát követnek, amely a Merkle-Damgård felépítését követi (véglegesítési művelet nélkül). Az iterált tömörítési funkciónak két fix méretű bemenete van, a második bemenet ugyanolyan méretű, mint a függvény kimenete:

a feldolgozandó üzenet felosztásával nyert adatok mérete 512 bit az SHA-256, az SHA-224 és 1024 bit az SHA-512 és SHA-384 esetében,
a tömörítési függvény eredménye az előző iterációban (256 bit az SHA-256 és SHA-224 esetében, 512 bit az SHA-512 és SHA-384 esetében).

A tömörítési függvény bemenetei fel vannak osztva

32 bites szavakkal az SHA-256 és az SHA-224 esetében,
64 bites szavakkal az SHA-512 és az SHA-384 esetében.

A tömörítési funkció ugyanazt a műveletet többször megismétli, az egyik kerek vagy kerek , 64 kör az SHA-256, az SHA-80 fordulat 512-ig. Minden fordulat primitív módon magában foglalja a rögzített méretű egész számok összeadását, azaz a modulo 2 32 vagy a modulo 2 64 összeadást , a bitenkénti műveleteket: logikai műveleteket, eltolásokat a bitek egy részének elvesztésével és körkörös eltolásokkal , és előre definiált konstansokat. , az inicializáláshoz is használják.

Feldolgozás előtt az üzenetet kitöltéssel töltik ki, így annak hossza a tömörítési függvény által feldolgozott blokk méretének a többszöröse. A párnázás magában foglalja a feldolgozandó szó hosszát (bináris formában): ez a Merkle-Damgård ( (en) Merkle-Damgård erősítése ) megerősítése , amely lehetővé teszi a hash-funkció ütközésekkel szembeni ellenállásának csökkentését ehhez. a tömörítési függvény. Ezt a hosszúságot a párnázás végén tárolják az SHA-256 esetében 64 bit (mint az SHA-1 esetében), az SHA-512 esetében pedig több mint 128 bitet, ami „korlátozza” a továbbítandó üzenetek méretét. az SHA-256 (és az SHA-224) esetében 2 64 bit, az SHA-512 (és az SHA-384) esetében pedig 2128 bit.

SHA-256

Az SHA-256 funkció 2002-ben az információfeldolgozás szövetségi szabványává válik ( a NIST FIPS ). 256 bites kivonatot készít . Az SHA-256 jellemzői a következők:

üzenetméret: maximum 2 64 bit
blokk mérete: 512 bit
szóméret: 32 bit
kivonat mérete: 256 bit
várható biztonsági szint (ütközések): 2 128 bit ( születésnapi támadás )
fordulatok száma (tömörítési funkció): 64

Algoritmus

Az algoritmus két szakaszra bontható

Előkészítés: az üzenetet az üzenet méretét tartalmazó kitöltéssel egészítik ki (Merkle-Damgård megerősítése), hogy az 512 bites blokkokra bontható;
Az emésztés kiszámítása a tömörítési függvény iterációjával az üzenet felosztásával kapott blokk szekvencián (Merkle-Damgård iteratív sémája).

Szimbólumok és használt kifejezések Beállítások

a, b, c, ..., h = működő változók (ebben az esetben w-bites szavak), amelyeket a hash kiszámításakor használnak

$H ^ {(i)}$ = a # i hash érték. a hash kezdeti értéke. az utolsó hash érték. $H ^ {(0)}$ $H ^ {(N)}$

$H_j ^ {(i)}$ = szó (w bit) # j hash értéke # i, ahol az i hash érték legjelentősebb szava (balra). $H_0 ^ {(i)}$

$K_t$ = a hash kiszámításánál használt iteratív állandók a t értéke szerint

k = az üzenethez hozzáadott 0-k száma az előfeldolgozás során (komplementer)
l = az M üzenet hossza, bitekben
m = a blokkban található bitek száma, azaz 512 bit
M = a feldolgozandó üzenet = blokk n ° i (m bit), üzenet M = szó (w bit) n ° j, blokk (m bit) n ° i, üzenet M n = a szóra alkalmazandó eltolási vagy forgatási bitek száma, ha bináris függvénnyel társul N = blokkok száma az M üzenetben szereplő m bitek T- kiegészítése után T = ideiglenes változó , w-bites szó, amelyet hash kiszámításához használunk w = a szóban lévő bitek száma, azaz 32 bit. = az üzenetből levezetett táblázat sz
$M ^ {(i)}$
$M_j ^ {(i)}$

$W_t$

Szimbólumok

Az itt használt hexadecimális jelölés a következő lesz: $\ mbox {0x}$

példa:

H_0 ^ {(0)} = \ mbox {0x12ab34ef}

$\ ék$ = bináris művelet ÉS = bináris művelet OR = bináris művelet XOR = bináris kiegészítés = összeadás modulo = bináris eltolás balra, ahol úgy kapjuk meg, hogy eltávolítjuk az x n bal bal bitjét, és n nullát adunk jobbra. = bináris eltolás jobbra, ahol úgy kapjuk meg, hogy eltávolítjuk az x n jobb bitjét, és n nullát adunk balra.
$\ vee$
$\ oplus$
$\ nem$
$+$ $2 ^ w$
$<<$ $x << n$
$>>$ $x >> n$

Szóműveletek

Az alkalmazott műveletek a következők:

a 32 bites szavak bitenkénti műveletei (lásd: # A használt jelölések szimbólumai );
a modulo $2 32$ összeadásnak megfelelő szavakkal végzett művelet , vagyis az $X$ és $Y$ természetes számot képviselő két $x$ és $y$ szó ( $0 \leq$ $X$ $<2$ $32$ és $0 \leq$ $Y$ $<2$ $32$ ) $z = x + y$ összege a $Z$ egész bináris ábrázolása oly módon, hogy $Z$ $=$ $X$ $+$ $Y$ $mod 2$ $32$ , $0 \leq$ $Z$ $<2$ $32$ ,
a jobb biteltolásos művelet , ahol x egy 32 bites szó, és a következő: ${\ displaystyle SHR ^ {n} (x)}$ ${\ displaystyle 0 \ leq n <32}$ ${\ displaystyle SHR ^ {n} (x) = x >> n}$ ;
a bináris óramutató járásával megegyező irányú forgatási művelet , ahol x egy 32 bites szó, és a következő: ${\ displaystyle ROTR ^ {n} (x)}$ ${\ displaystyle 0 \ leq n <32}$ ${\ displaystyle ROTR ^ {n} (x) = (x >> n) \ vee (x << (32-n))}$ .

Funkciók és állandók Funkciók

Ez a szakasz a kivonatértékek kiszámításakor használt funkciókat ismerteti. Az SHA-256 6 logikai függvényt használ az x, y, z megjegyzéssel ellátott 32 bites szavakon. Ezeknek a függvényeknek az eredménye egy új 32 bites szókimenet.

$Ch (x, y, z) = (x \ ék y) \ oplus (\ lnot x \ ék z)$

$Shift (x, y, z) = (x \ ék y) \ oplus (x \ wedge z) \ oplus (y \ wedge z)$

$\ Sigma _ {0} ^ {{\ {256 \}}} (x) = ROTR ^ {2} (x) \ oplus ROTR ^ {{13}} (x) \ oplus ROTR ^ {{22}} ( x)$

$\ Sigma _ {1} ^ {{\ {256 \}}} (x) = ROTR ^ {6} (x) \ oplus ROTR ^ {{11}} (x) \ oplus ROTR ^ {{25}} ( x)$

$\ sigma _ {0} ^ {{\ {256 \}}} (x) = ROTR ^ {7} (x) \ oplus ROTR ^ {{18}} (x) \ oplus SHR ^ {3} (x)$

$\ sigma _ {1} ^ {{\ {256 \}}} (x) = ROTR ^ {{17}} (x) \ oplus ROTR ^ {{19}} (x) \ oplus SHR ^ {{10} } (x)$

Állandóak

Az SHA-256 a 32 bites szavak 64 állandó értékét használja, megjegyezve . Ezek a számok jelzik az első 32 bit a tizedes rész a harmadfokú gyökerei az első 64 fő számokat . A következő értékeket hexadecimális jelöléssel fejezzük ki (16. alap). $K_ {0} ^ {{\ {256 \}}}, K_ {1} ^ {{\ {256 \}}}, ..., K _ {{63}} ^ {{\ {256 \}} } ~$

$K _ {{0}} ^ {{\ {256 \}}}, ..., K _ {{7}} ^ {{\ {256 \}}}$	0x428a2f98	0x71374491	0xb5c0fbcf	0xe9b5dba5	0x3956c25b	0x59f111f1	0x923f82a4	0xab1c5ed5
$K _ {{8}} ^ {{\ {256 \}}}, ..., K _ {{15}} ^ {{\ {256 \}}}$	0xd807aa98	0x12835b01	0x243185be	0x550c7dc3	0x72be5d74	0x80deb1fe	0x9bdc06a7	0xc19bf174
$K _ {{16}} ^ {{\ {256 \}}}, ..., K _ {{23}} ^ {{\ {256 \}}}$	0xe49b69c1	0xefbe4786	0x0fc19dc6	0x240ca1cc	0x2de92c6f	0x4a7484aa	0x5cb0a9dc	0x76f988da
$K _ {{24}} ^ {{\ {256 \}}}, ..., K _ {{31}} ^ {{\ {256 \}}}$	0x983e5152	0xa831c66d	0xb00327c8	0xbf597fc7	0xc6e00bf3	0xd5a79147	0x06ca6351	0x14292967
$K _ {{32}} ^ {{\ {256 \}}}, ..., K _ {{39}} ^ {{\ {256 \}}}$	0x27b70a85	0x2e1b2138	0x4d2c6dfc	0x53380d13	0x650a7354	0x766a0abb	0x81c2c92e	0x92722c85
$K _ {{40}} ^ {{\ {256 \}}}, ..., K _ {{47}} ^ {{\ {256 \}}}$	0xa2bfe8a1	0xa81a664b	0xc24b8b70	0xc76c51a3	0xd192e819	0xd6990624	0xf40e3585	0x106aa070
$K _ {{48}} ^ {{\ {256 \}}}, ..., K _ {{55}} ^ {{\ {256 \}}}$	0x19a4c116	0x1e376c08	0x2748774c	0x34b0bcb5	0x391c0cb3	0x4ed8aa4a	0x5b9cca4f	0x682e6ff3
$K _ {{56}} ^ {{\ {256 \}}}, ..., K _ {{63}} ^ {{\ {256 \}}}$	0x748f82ee	0x78a5636f	0x84c87814	0x8cc70208	0x90befffa	0xa4506ceb	0xbef9a3f7	0xc67178f2

Előkezelés

Ez a művelet három lépésben zajlik: töltse ki az M üzenetet, ossza fel az eredményt blokkokra és inicializálja a kivonatolási értékeket. $H ^ {(0)} ~$

Lekvár

Ez magában foglalja az M üzenet kitöltését úgy, hogy annak mérete 512 bit többszöröse legyen. A tölteléket használja a bináris ábrázolása egész szám $L$ , amely a hossza bitben az üzenet M ( Merkle-Damgård megerősítés ). Ehhez hozzáadjuk egymás után:

egy bit 1-re állítva az M üzenet végén ,
$k$ 0 bit töltelék, ahol $k$ a legkisebb természetes egész szám, amely kielégíti $l + 1 + k \equiv 448 mod 512$
egy 64 bites blokk, amely megadja az $l$ bináris ábrázolását .

Példák:

A M = "abc", L = 3 × 8 = 24 bit, k ≡ 448 - (24 + 1) ≡ 423 mod 512 , így K = 423 ;
- hozzáadjuk M-hez
  - először kicsit 1-nél,
  - majd 423 bit 0-nál,
  - akkor 64 bit, amely binárisan 24, azaz "0000 ... 0000 0001 1000"
ezután kap egy befejezett üzenetet, amelynek hossza az 512 bit legkisebb többszöröse, mint az M kezdeti hossza .
Az M a bit hosszúságú , k ≡ 448 - (500 + 1) ≡ -53 mod 512 ; ezért k = 512 - 53 = 459 ; l=500{\ displaystyle l = 500} ${\ displaystyle l = 500}$
- hozzáadjuk M-hez
  - először kicsit 1-nél,
  - majd 459 bit 0-nál,
  - akkor 64 bit 500-at jelent bináris formában, azaz "0000 ... 0000 0001 1111 0100"
ezután egy befejezett üzenetet kapunk, amelynek hossza nagyobb, mint 512 bit, az M kezdeti hosszánál nagyobb 512 bit legközelebbi többszöröséhez .

Tömbökbe vágás

Az elkészült üzenet N 512 bites blokkra van felosztva . Ezután minden 512 bites blokkot 16, 32 bites szóra osztunk, megjegyezzük . $M ^ {(1)}, M ^ {(2)}, ..., M ^ {(N)} ~$ ${\ displaystyle \ forall i \ itt: [1, N], \ \ M_ {0} ^ {(i)}, M_ {1} ^ {(i)}, ..., M_ {15} ^ {(i )}}$

Inicializálás

A következő nyolc változóhoz a kezdeti értékeket az alábbiak szerint rendeljük hozzá:

$H_ {0} ^ {{(0)}} = {\ mbox {0x6a09e667}}$
$H_ {1} ^ {{(0)}} = {\ mbox {0xbb67ae85}}$
$H_ {2} ^ {{(0)}} = {\ mbox {0x3c6ef372}}$
$H_ {3} ^ {{(0)}} = {\ mbox {0xa54ff53a}}$
$H_ {4} ^ {{(0)}} = {\ mbox {0x510e527f}}$
$H_ {5} ^ {{(0)}} = {\ mbox {0x9b05688c}}$
$H_ {6} ^ {{(0)}} = {\ mbox {0x1f83d9ab}}$
$H_ {7} ^ {{(0)}} = {\ mbox {0x5be0cd19}}$

Az emésztés (hash) kiszámítása

Ehhez a kezeléshez fogjuk használni

egy 64 szóból álló táblázat, megjegyezve $W_ {0}, W_ {1}, ..., W _ {{63}} ~$
nyolc minősített változó $a, b, c, d, e, f, g, h ~$
nyolc változó, amelyek a hash értékeket tartalmazzák, korábban feljegyezték és inicializálták $H_0 ^ {(i)}$ $H_0 ^ {(0)}$

Ezek a változók ismételten új hash értékeket tartalmaznak, hogy végül tartalmazzák az M emésztését .

H ^ {(i)} ~

H ^ {(N)} ~

két változó, megjegyzett , 32 bites szó. $T_ {1} {\ mbox {és}} T_ {2}$

Az M N blokkját egymás után dolgozzuk fel a következő lépések szerint

I = 1-től N-ig
{

1. Kitöltjük a 0-tól 63-ig terjedő t táblázatot

W_t

W_ {t} = \ balra \ {{\ kezdődik {mátrix} M_ {t} ^ {{(i)}}, és 0 \ leq t \ leq 15 \\\\\ sigma _ {1} ^ {{\ {256 \}}} \ balra (W _ {{t-2}} \ jobbra) + W _ {{t-7}} + \ sigma _ {0} ^ {{\ {256 \}}} \ balra (W_ {{t-15}} \ jobbra) + W _ {{t-16}} és 16 \ leq t \ leq 63 \ end {mátrix}} \ right.

2. Az a, b, c, d, e, f, g és h értékeket inicializáljuk az előző kör hash értékeivel

a = H_0 ^ {(i-1)} ~

b = H_1 ^ {(i-1)} ~

c = H_2 ^ {(i-1)} ~

d = H_3 ^ {(i-1)} ~

e = H_4 ^ {(i-1)} ~

f = H_ {5} ^ {{(i-1)}} ~

g = H_ {6} ^ {{(i-1)}} ~

h = H_ {7} ^ {{(i-1)}} ~

3. 0-tól 63-ig t {

T_ {1} = h + \ Sigma _ {1} ^ {{\ {256 \}}} (e) + Ch (e, f, g) + K_ {t} ^ {{\ {256 \}}} + W_ {t} ~

T_ {2} = \ Sigma _ {0} ^ {{\ {256 \}}} (a) + Shift (a, b, c) ~

h = g ~

g = f ~

f = e ~

e = d + T_ {1} ~

d = c ~

c = b ~

b = a ~

a = T_ {1} + T_ {2} ~

} 4. Közbenső hash értékek kiszámítása

H_ {0} ^ {{(i)}} = a + H_ {0} ^ {{(i-1)}}

H_ {1} ^ {{(i)}} = b + H_ {1} ^ {{(i-1)}}

H_ {2} ^ {{(i)}} = c + H_ {2} ^ {{(i-1)}}

H_ {3} ^ {{(i)}} = d + H_ {3} ^ {{(i-1)}}

H_ {4} ^ {{(i)}} = e + H_ {4} ^ {{(i-1)}}

H_ {5} ^ {{(i)}} = f + H_ {5} ^ {{(i-1)}}

H_ {6} ^ {{(i)}} = g + H_ {6} ^ {{(i-1)}}

H_ {7} ^ {{(i)}} = h + H_ {7} ^ {{(i-1)}}

}

Miután megismételte a fenti négy lépést az M üzenet N blokkjaira (vagyis feldolgozás után ), az M 256 bites emésztését az értékek összefűzésével kapjuk meg $M ^ {(N)} ~$

H_ {0} ^ {{(N)}} || H_ {1} ^ {{(N)}} || H_ {2} ^ {{(N)}} || H_ {3} ^ {{( N)}} || H_ {4} ^ {{(N)}} || H_ {5} ^ {{(N)}} || H_ {6} ^ {{(N)}} || H_ { 7} ^ {{(N)}}

SHA-224

Az SHA-224 funkciót először 2004-ben adták ki. A kimenet (hash, “hash” vagy hash) 224 bit . Kifejezetten olyan ujjlenyomat létrehozására tervezték, amelynek mérete négy, egyenként 56 bites DES billentyűnek felel meg . Az algoritmus az SHA-256 algoritmusa, csak eltérésekkel

különböző értékek az inicializáláshoz (h0,…, h7 változók);
kimenet 224 bitre csonkolva (az első 7 változó h0,…, h6 tartalmának összefűzése).

SHA-512

Az SHA-512 funkció az SHA-256-mal együtt jelent meg, és így válik 2002-ben az információfeldolgozás szövetségi szabványává ( FIPS a NIST ). 512 bites kivonatot készít .

Az algoritmus nagyon hasonlít az SHA-256 algoritmusához, de fontos különbség van a feldolgozott adatok méretében: a blokk mérete 1024 bit (nem 512 bit), és az algoritmus 64 bites szavakon (a szó-memória) működik sok modern processzor mérete). Különösen az ezeken a processzorokon optimalizált számtani műveleteket hajtják végre 64 biten.

Az algoritmus felépítése megegyezik az SHA-256 szerkezetével, de

az üzenet 1024 bites blokkokra van felosztva;
a megjelenő számok (h0,…, h7, konstansok ...) 64 biten vannak, és az összeadás modulo 2 64 ;
az inicializálások és az állandók értéke különbözik (szükségszerűen 64 és nem 32 bit esetén);
a tömörítési funkció 80 fordulatot használ (64 helyett);
a töltési szakaszban hozzáadott üzenet (bináris formátumban ) hossza ( Merkle-Damgård megerősítése ) 128 bites egész szám (big-endian) és nem 64 bites, ami korlátozza az üzenet maximális elméleti méretét 2 128 bit 2 64 bit helyett ;
a kör alakú eltolások és az eltolások értékét módosítják a szavak új hosszának figyelembevétele érdekében.

SHA-384

Az SHA-384 funkció megjelent az SHA-256 és az SHA-512 mellett. 384 bites kivonatot készít . Az SHA-512 algoritmusa csak eltéréseket mutat

különböző értékek az inicializáláshoz (h0,…, h7 változók);
csonka 384 bites kimenet (az első 6 h0,…, h5 változó tartalmának összefűzése).

Rejtjel megfejtés

Az SHA-256 lett az új ajánlott szabvány a kriptográfiai hasításhoz az MD5 és SHA-1 elleni támadások után . Az SHA család többi tagja viszonylag titkosítatlan volt az SHA-0 és az SHA-1 - hez képest . A 2003 , Helena Handschuh és Henri Gilbert elemzést tett közzé SHA-256, 384 és 512. A tanulmány azt mutatja, hogy más tagjai SHA nem érinti a támadásokat, hogy már bizonyított más hash függvények ( MD4 , MD5 és SHA-1 többek között). A lineáris kriptanalízis és differenciál nem érvényes.

Másrészt a két kriptológus kiemelte a módosított verziók jelentős gyengeségeit. Ha megváltoztatjuk az állandókat vagy az inicializálási paramétereket, hogy szimmetrikusak legyenek, miközben a moduláris összeadást XOR-ra cseréljük , kapunk egy kivonatot, amely szimmetrikus ujjlenyomatot eredményez, ha a bemeneti üzenet is szimmetrikus.

Hivatkozások

lásd a NIST Secure Hashing oldalt

Lásd is

Bibliográfia

(en) Henri Gilbert, Helena Handschuh: Az SHA-256 és a nővérek biztonsági elemzése . Válogatott területek a kriptográfiában 2003: 175-193
A NIST Secure Hash Standard egymást követő verziói az SHA-2 megjelenésétől kezdve (lásd még a Secure Hasash oldalt )
- A FIPS 180-2 verziója2001. augusztus
- A FIPS 180-3 végleges verziója2008. október
- FIPS 180-4 2012. március

Kapcsolódó cikkek

Külső linkek

Online számológép Karakterláncok kódolása a leggyakrabban használt hash függvények segítségével.
(en) Számológép, amely online SHA-256-ot generál
(en) Számológép, amely online SHA-512-et generál
(fr) Nyílt forráskódú implementáció a C ++ nyelven Az algoritmus összes változatát tartalmazza.