SHAvite-3

SHAvite-3
Vývojáři	Eli Biham nebo Dunkelman
Vytvořeno	2008
zveřejněno	2009
Velikost hash	variabilní, až 512 bitů
Počet kol	12 nebo 16
Typ	hashovací funkce

SHAvite-3 je kryptografická hašovací funkce vyvinutá izraelskými kryptografy Eli Bihamem a Orrem Dunkelmanem . Jeden ze čtrnácti příspěvků ve druhém kole soutěže SHA-3 sponzorované organizací NIST . SHAvite-3 je založen na kombinaci komponent AES s rámcem HAIFA . Tato hašovací funkce využívá kryptografická primitiva, jako je Feistelova síť a Davis-Meierova konstrukce. Rodina hašovacích funkcí SHAvite-3 zahrnuje dva algoritmy – SHAvite-3 256 a SHAvite-3 512 [1] .

Název

Název funkce SHAVite-3 se vyslovuje jako „shavait shalosh“ ( hebrejsky ‏shavait tři ‏‎). Autoři to tak pojmenovali z následujících důvodů [2] :

Shavit je z hebrejštiny přeložen jako kometa – vyvinutá hašovací funkce je bezpečná a rychlá ( fr. vite );
Shavite – stoupenec Šivy – hinduistické božstvo;
číslo 3 v názvu - existovaly dvě předchozí verze, které nebyly zveřejněny.

Historie

Algoritmus SHAvite-3 byl speciálně navržen pro soutěž SHA-3 . Mezi požadavky na hashovací funkci patřila schopnost získat výtahy o délce 224, 256, 384 a 512 bitů, které by nahradily rodinu kryptografických algoritmů SHA-2 [3] . Autoři SHAvite-3 vyvinuli dvě funkce: SHAvite-3 256 pro generování 224, 256 bitových výtahů a SHAvite-3 512 pro generování 384 a 512 bitových výtahů. V důsledku prvního kola soutěže byla nalezena zranitelnost v základním algoritmu blokové šifry, která však nevedla ke kompromitaci hashovací funkce [4] [5] .

Autoři navrhli úpravu verze původně přihlášené do soutěže za účelem zvýšení bezpečnosti algoritmu. Změna se nazývala vylepšená verze a týkala se jak SHAvite-3 256 , tak SHAvite-3 512 [2] . Následovala oprava chyby v implementaci funkce AES round a zlepšená kryptografická síla SHAvite-3 512 zvýšením počtu kol ze 14 na 16 [6] . Funkce se dostala do druhého kola soutěže kryptografických funkcí, ale do finále nebyla připuštěna z důvodu nedostatečného zabezpečení inicializace S-boxů pod blokovou šifrou, což vedlo k relativně nízké úrovni zabezpečení v 512. -bitová verze [7] [8] [9] . Současně měla hašovací funkce relativně nízkou propustnost [10] .

Designové prvky

Funkce hashovací funkce SHAVite-3 jsou [1] :

iterace kompresních funkcí pro získání hashovací funkce se provádějí pomocí algoritmu HAIFA ;
algoritmus vám umožňuje získat hash libovolné délky, nepřesahující 512 bitů;
podporuje sůl ;
kompresní funkce je navržena pomocí dobře známých a dobře prostudovaných komponent: Feistelova síť , kruhové funkce AES a posuvné registry s lineární zpětnou vazbou .

Algoritmus

AES kolo

Ve svém jádru SHAVite-3 používá kolo AES [1] . Kolo definuje operace na 128bitovém čísle . 128bitová data jsou rozdělena do 16 bloků po 8 bitech, poté jsou bloky zapsány jako matice 4×4. Každý prvek matice představuje hodnotu v poli GF(2 8 ). Kolo se skládá ze sekvenční aplikace operací SubBytes ( ), ShiftRows ( ), MixColumns ( ) a sčítání modulo 2 pomocí kulaté klávesy . $X$ $SB$ $SR$ $MC$ $podklíč$

A E S R Ó u n d s u b k E y ( X ) = M C ( S R ( S B ( X ) ) ) ⊕ s u b k E y {\displaystyle AESRound_{podklíč}(x)=MC(SR(SB(x)))\podklíč oplus} $AESRound_{podklíč}(x)=MC(SR(SB(x)))\podklíč oplus$

haifa

SHAvite-3 je postaven na iteračním režimu pro hašovací funkce HAIFA [1] . HAIFA nastavuje pravidla, podle kterých se zpráva doplní na požadovanou délku, zkomprimuje se speciální funkcí a výstupní hodnota se zkrátí na požadovanou délku. Výpočet hashovací funkce pomocí algoritmu SHAVite-3 tedy spočívá v provedení několika kroků za sebou: $C$

Vyplnění zprávy na určitou délku, aby ji bylo možné rozdělit na bloky stejné velikosti. Označme doplněnou zprávu ; $M$ $PM$
Rozdělení rozšířené zprávy na bloky stejné velikosti: ; $l$ $PM=(M_{1},M_{2},...,M_{l})$
Vezmeme-li nějakou počáteční hodnotu , kde je hlavní počáteční hodnota, je požadovaná velikost digestu; $h_{0}=C(MIV,m,0,0)$ $MIV$ $m$
Výpočet následné hodnoty podle vzorce , kde je počet bitů zprávy hashovaný časem výpočtu včetně aktuálního bloku. Jinými slovy délka . Parametrem je sůl . V aplikacích, kde není vyžadováno použití soli, navrhují autoři SHAvite-3 používat , přičemž umožňují snížení bezpečnosti a zvýšení výpočetní rychlosti [1] ; $h_{i}=C(h_{i-1},M_{i},numBits,salt)$ $numBits$ $Ahoj}$ $numBits$ $(M_{1},M_{2},...,M_{i})$ $salt$ $salt=0$
Zkrácení konečné hodnoty na požadovanou délku bude výsledkem výpočtu hashovací funkce. $h_{l}$ $m$

Dokončení zprávy

Pokud je velikost původní zprávy , požadovaná velikost hodnoty hash je , a velikost bloku , na kterém funkce komprese pracuje , pak je výplň zprávy , která má délku , na násobek délky . provádí v následujícím pořadí: $A$ $B$ $C$ $n$ $M$ $len(M)$ $n$

Jeden bit s hodnotou 1 je přidán na konec zprávy , dostaneme ; $M$ $(M,1)$
Hodnota je přiřazena , která je zakódována v bitech: ; $A$ $A$ $(M,1,A)$
Hodnota je přiřazena , která je zakódována v bitech: ; $B$ $b$ $(M,1,A,B)$
Po bitu 1 se vloží minimální počet nul, který je nutný k tomu, aby délka přijaté zprávy byla násobkem : . Počet nul lze vypočítat pomocí vzorce: . $PM$ $n$ $PM=(M,1,0,...,0,A,B)$ $z=n-(len(M)+1+a+b)\ mod\ n$

Odrůdy algoritmu

Algoritmus SHAvite-3 má dvě varianty, které se liší použitou kompresní funkcí a délkou digestu [1] : $C$

SHAvite-3 256 využívá funkci komprese a umožňuje získat hash dlouhý až 256 bitů; $C_{256}$
SHAvite-3 512 využívá funkci komprese a umožňuje získat hash o délce 257 až 512 bitů. $C_{512}$

Generování přehledu

Pokud je původní zpráva a chcete získat výtah délky , proveďte následující posloupnost akcí: $M$ $1\leq m\leq 512$

Pojďme definovat . Nazvěme první případ a druhý - . V prvním případě , ve druhém - . $w$ $1\leq m\leq 256$ $256<m\leq 512$ $w=256$ $w=512$
Najít kde ; $h_{0}=C_{w}(MIV_{w},m,0,0)$ $MIV_{w}=C_{w}(0,0,0,0)$
Vyplňte zprávu na velikost, která je násobkem =512 v prvním případě nebo až =1024 ve druhém. K tomu použijeme výše popsaný postup , kdy v prvním případě počítáme =64 a ve druhém =128. V obou případech =16; $n$ $n$ $A$ $A$ $b$
Rozdělme vyplněnou zprávu na bloky bitů a vypočítejme všechny kromě posledních dvou. Pokud je délka původní zprávy taková, že se v důsledku přidání zprávy na konec vytvoří blok, který neobsahuje jediný bit původní zprávy, pak , . Jinak se počítá podle stejných vzorců jako předchozí , a ; $MP$ $n$ $Ahoj}$ $h_{l-1}=C_{w}(h_{l-2},M_{l-1},len(M),sůl)$ $h_{l}=C_{w}(h_{l-1},M_{l},0,sůl)$ $h_{l-1}$ $Ahoj}$ $h_{l}=C_{w}(h_{l-1},M_{l},0,sůl)$
Vezměme si první kousek . Toto je požadovaná hodnota hash. $m$ $h_{l}$

Funkce a $C_{256}$ $C_{512}$

Jako vstup se berou čtyři bitové vektory:

Hodnota řetězení s velikostí =256 bitů pro ( bitů pro ); $m_{c}$ $C_{256}$ $m_{c}=512$ $C_{512}$
Blok zpráv o velikosti =512 bitů pro ( =1024 bitů pro ); $n$ $C_{256}$ $n$ $C_{512}$
Sůl o velikosti =256 bitů pro ( =512 bitů pro ); $s$ $C_{256}$ $s$ $C_{512}$
Bitový čítač o velikosti =64 bitů pro ( =128 bitů pro ). $b$ $C_{256}$ $b$ $C_{512}$

Výstupem je vektor o velikosti 256 bitů pro (512 bitů pro ). $C_{256}$ $C_{512}$

Pro realizaci je použita konstrukce Davis-Meyer . To znamená, že hodnota řetězce je přepočítána podle vzorců , resp. [1] . $C_{256}$ $C_{512}$ $h_{i}=E^{256}{(h_{i-1})}\oplus {h_{i-1))$ $h_{i}=E^{512}{(h_{i-1})}\oplus {h_{i-1))$

Funkce

E^{256}

$E^{256}$ - 12kolová bloková šifra . Tato bloková šifra je Feistelova síť , která se skládá z 12 Feistelových buněk. jako vstup přijímá 256bitový prostý text . Lze jej rozdělit na dvě části po 128 bitech. . Přepočet hodnot v každém kole se provádí podle vzorce: . $E^{256}$ $P$ $L_0$ $R_{0}$ $P=(L_{0},R_{0})$ $(L_{i+1},R_{i+1})=(R_{i},L_{i}\oplus F_{RK_{i))^{3}(R_{i}))$

Zde je vektor tří klíčů, odlišných pro každé kolo, a je to nějaká funkce. V důsledku toho lze návratovou hodnotu vypočítat: . $RK_{i}=(k_{i}^{0},k_{i}^{1},k_{i}^{2})$ $F^{3}$ $E^{256}=(L_{12},R_{12})$

Funkce

{\displaystyle F_{k}^{3))

Funkce přijímá jako vstup 128bitový text a 384bitový klíč , který se získá kombinací tří 128bitových klíčů . Skládá se z aplikace kola AES třikrát: . Vstupní vektor je přidán modulo 2 s klíčem a na výsledek jsou aplikována tři kola AES s různými klíči v následujícím pořadí: kolo AES s klíčem , další kolo AES s klíčem , poslední kolo s klíčem 0 (128 bitů). $F_{k}^{3}(x)$ $X$ $k$ $k=(k^{0},k^{1},k^{2})$ $F_{(k_{i}^{0},k_{i}^{1},k_{i}^{2})}^{3}(x)=AESRound_{0}(AESRound_{k_ {i}^{2}}(AESRound_{k_{i}^{1}}(x\oplus k_{i}^{0})))$ $X$ ${\displaystyle k_{i}^{0))$ ${\displaystyle k_{i}^{1))$ ${\displaystyle k_{i}^{2))$

Generování klíče pro

E^{256}

Pro výpočet funkce jsou zapotřebí tři 128bitové klíče v každém z 12 kol. K tomu se používá algoritmus pro generování klíčů z jednoho klíče. Jako jediný klíč, ze kterého se následně vygeneruje 36, je použita kombinace bloku zpráv (512 bitů), salt (256 bitů) a bitového čítače (64 bitů). V algoritmu jsou všechny operace prováděny na 4bajtových hodnotách. Představme si následující zápis: $E^{256}$

$msg[0],...,msg[15]$ — blok zpráv;
$cnt[0],cnt[1]$ — počítadlo bitů;
$salt[0],...,salt[7]$ - sůl.

V důsledku algoritmu získáme 144 hodnot (také 4bajtové):

$rk[0],...,rk[143]$

// Algoritmus generování klíče pro E^256 v C/C++ // Inicializuje prvních 16 hodnot výsledného pole počáteční zprávou pro ( int i = 0 ; i < 16 ; i ++ ) rk [ i ] = msg [ i ]; int i = 16 ; for ( int k = 0 ; k < 4 ; k ++ ) { uint32_t t [ 4 ]; // Nelineární krok pro ( int r = 0 ; r < 2 ; r ++ ) { // Proveďte kolo AES s klíčem 0 na 128bitové hodnotě // což je součet modulo-2 dříve vypočítaných // prvků pole rk a soli (bity 0-127). // Zapište 128bitový výsledek do pole t AESRound0 ( rk [ i -15 ] ^ sůl [ 0 ], rg [ i -14 ] ^ sůl [ 1 ], rk [ i -13 ] ^ sůl [ 2 ], rk [ i -16 ] ^ sůl [ 3 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ] ); for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j - 4 ]; if ( i == 16 ) { rk [ 16 ] ^= cnt [ 0 ]; rk [ 17 ] ^= ~ cnt [ 1 ]; } if ( i == 56 ) { rk [ 16 ] ^= cnt [ 1 ]; rk [ 17 ] ^= ~ cnt [ 0 ]; } i + = 4 ; // Stejné kolo AES jako předtím // ale se zbytkem soli (128-255 bitů) AESRound0 ( rk [ i -15 ] ^ sůl [ 4 ], rg [ i -14 ] ^ sůl [ 5 ], rk [ i -13 ] ^ sůl [ 6 ], rk [ i -16 ] ^ sůl [ 7 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ] ); for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j - 4 ]; if ( i == 84 ) { rk [ 86 ] ^= cnt [ 1 ]; rk [ 87 ] ^= ~ cnt [ 0 ]; } if ( i == 124 ) { rk [ 124 ] ^= cnt [ 0 ]; rk [ 127 ] ^= ~ cnt [ 1 ]; } i + = 4 ; } // Lineární krok pro ( int r = 0 ; r != 16 ; ++ r ) { rk [ i ] = rk [ i -16 ] ^ rk [ i -3 ]; i + = 1 ; } }

Algoritmus uvedený výše je upravená verze autorů. Jediný rozdíl od verze původně předložené do soutěže SHA-3 je přítomnost bitových negačních operací „~“ čítače . Negace byla přidána, aby se zvýšila kryptografická síla hashovací funkce. Přítomnost takových operací zaručuje, že alespoň 4 z 8 bajtů čítače budou nenulové [2] . $(cnt[0],cnt[1])$

Klávesy pro výpočet funkce jsou získány z následujících: , kde , . $RK_{i}=(k_{i}^{0},k_{i}^{1},k_{i}^{2})$ $E^{256}$ $rk[0],...,rk[143]$ $k_{i}^{j}=(rk[y_{i}^{j}],rk[y_{i}^{j}+1],rk[y_{i}^{j}+ 2],rk[y_{i}^{j}+3])$ $y_{i}^{j}=12*i+4*j$ $i\in [0,12),j\in [0,2)$

Funkce

E^{512}

Tato funkce je implementována analogicky s , ale přijímá 512bitový prostý text jako vstup , který je reprezentován jako 4 části podle $E^{256}$ $P$

128 bitů: . Přepočet se provádí podle vzorce na 14 kol (v aktualizované verzi autoři navrhli použít 16 kol [6] ). . $P=(L_{0},A_{0},B_{0},R_{0})$ $(L_{i+1},A_{i+1},B_{i+1},R_{i+1})=(R_{i},L_{i}\oplus F_{RK_{0 ,i}}^{4}(A_{i}),A_{i},B_{i}\oplus F_{RK_{1,i}}^{4}(R_{i}))$ $E^{512}=(L_{14},A_{14},B_{14},R_{14})$

Funkce

{\displaystyle F_{k}^{4))

Jako vstup přijímá 128 bitů textu a 512 bitový klíč . Počítáno jako 4 kola AES. . $X$ $k=(k^{0},k^{1},k^{2},k^{3})$ $F_{(k_{i}^{0},k_{i}^{1},k_{i}^{2},k_{i}^{3})}^{4}(x) =AESRound_{0}(AESRound_{k_{i}^{3}}(AESRound_{k_{i}^{2}}(AESRound_{k_{i}^{1}}(x\oplus k_{i}^ {0}))))$

Generování klíče pro

E^{512}

Funkce vyžaduje osm 128bitových klíčů v každém ze 14 kol k výpočtu funkce . Celkem je k dispozici 112 klíčů. Jsou založeny na bloku zpráv (1024 bitů), soli (512 bitů) a bitovém čítači (128 bitů). Všechny operace se provádějí na 4bajtových hodnotách. Představme si následující zápis: $E^{512}$

$msg[0],...,msg[31]$ - blok zpráv
$cnt[0],...,cnt[3]$ - počítadlo bitů
$salt[0],...,salt[15]$ - sůl

V důsledku algoritmu získáme 448 hodnot (4bajtové):

$rk[0],...,rk[447]$

// Algoritmus generování klíče pro E^512 v C/C++ // Inicializuje prvních 32 hodnot výsledného pole počáteční zprávou pro ( int i = 0 ; i < 32 ; i ++ ) rk [ i ] = msg [ i ]; int i = 32 ; for ( int k = 0 ; k < 7 ; k ++ ) { uint32_t t [ 4 ]; // Nelineární krok (7krát) pro ( int r = 0 ; r < 2 ; r ++ ) { AESRound0 ( rk [ i -31 ] ^ sůl [ 0 ], rg [ i -30 ] ^ sůl [ 1 ], rk [ i -29 ] ^ sůl [ 2 ], rk [ i -32 ] ^ sůl [ 3 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES zaokrouhlí s klíčem 0, salt 0-3 for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j -4 ]; if ( i == 32 ) { rk [ 32 ] ^= cnt [ 0 ]; rk [ 33 ] ^= cnt [ 1 ]; rk [ 34 ] ^= cnt [ 2 ]; rk [ 35 ] ^= ~ cnt [ 3 ]; } i + = 4 ; AESRound0 ( rk [ i -31 ] ^ sůl [ 4 ], rg [ i -30 ] ^ sůl [ 5 ], rk [ i -29 ] ^ sůl [ 6 ], rk [ i -32 ] ^ sůl [ 7 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES zaokrouhlí s klíčem 0, salt 4-7 for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j -4 ]; if ( i == 164 ) { rk [ 164 ] ^= cnt [ 3 ]; rk [ 165 ] ^= cnt [ 2 ]; rk [ 166 ] ^= cnt [ 1 ]; rk [ 167 ] ^= ~ cnt [ 0 ]; } i + = 4 ; AESRound0 ( rk [ i -31 ] ^ sůl [ 8 ], rg [ i -30 ] ^ sůl [ 9 ], rk [ i -29 ] ^ sůl [ 10 ], rk [ i -32 ] ^ sůl [ 11 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES zaokrouhluje klíč 0, sůl 8-11 for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j -4 ]; if ( i == 440 ) { rk [ 440 ] ^= cnt [ 1 ]; rk [ 441 ] ^= cnt [ 0 ]; rk [ 442 ] ^= cnt [ 3 ]; rk [ 443 ] ^= ~ cnt [ 2 ]; } i + = 4 ; AESRound0 ( rk [ i -31 ] ^ sůl [ 12 ], rg [ i -30 ] ^ sůl [ 13 ], rk [ i -29 ] ^ sůl [ 14 ], rk [ i -32 ] ^ sůl [ 15 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES zaokrouhlí s klíčem 0, salt 12-15 for ( int j = 0 ; j < 4 ; j ++ ) rk [ i + j ] = t [ j ] ^ rk [ i + j -4 ]; if ( i == 316 ) { rk [ 316 ] ^= cnt [ 2 ]; rk [ 317 ] ^= cnt [ 3 ]; rk [ 318 ] ^= cnt [ 0 ]; rk [ 319 ] ^= ~ cnt [ 1 ]; } i + = 4 ; } if ( k == 6 ) break ; // nedělat 7. lineární krok // Lineární krok (6krát) pro ( int r = 0 ; r != 32 ; ++ r ) { rk [ i ] = rk [ i -32 ] ^ rk [ i -7 ]; i + = 1 ; } }

Zde, stejně jako ve 256bitové verzi, je jediným rozdílem mezi vylepšenou verzí a tou původně předloženou do soutěže SHA-3 přítomnost bitových operací NOT "~" před hodnotami čítače. Přítomnost takových operací zaručuje, že alespoň 4 ze 16 bajtů čítače budou nenulové [2] . $(cnt[0],cnt[1],cnt[2],cnt[3])$

Dále jsou klávesy pro výpočet funkce získány z následujících: , kde , . $RK_{p,i}=(k_{p,i}^{0},k_{p,i}^{1},k_{p,i}^{2},k_{p,i} ^{3})$ $E^{512}$ $rk[0],...,rk[447]$ $k_{p,i}^{j}=(rk[y_{p,i}^{j}],rk[y_{p,i}^{j}+1],rk[y_{p ,i}^{j}+2],rk[y_{p,i}^{j}+3])$ $y_{p,i}^{j}=32*i+16*p+4*j$ $i\in [0,14),p\in [0,2),j\in [0,4)$

Výkon

Tabulka uvádí srovnávací údaje o rychlosti algoritmů [1] .

Algoritmus	Rychlost (cykly/bajt)
Algoritmus	32 bit	64 bit
MD5	7.4	8.8
SHA-1	9.8	9.5
SHA-256	28.8	25.3
SHA-512	77,8	16.9
SHAVite-3 256 (změnit)	35.3	26.7
SHAVite-3 256 (cca)	26.6	18.6
SHAVite-3 256 (s nástrojem AES)	< 8	< 8
SHAVite-3 512 (změnit)	55,0	38.2
SHAVite-3 512 (cca)	35.3	28.4
SHAvite-3 512 (s nástrojem AES)	< 12	< 12

Funkci lze implementovat i hardwarově.

Délka	Technika	Velikost	Šířka pásma
256	ASIC	10,3 kg brány	7,6 Mbps
		55,0 kg brány	604,4 Mbps
	FPGA	510 plátků	1,7 Mbps
		3585	872,3 Mbps
512	ASIC	18,5 kg	4,7 Mbps
		81Kgates	907,7 Mbps
	FPGA	895 plátků	1,0 Mbps
		7170 plátků	1,12 Gbps

V tabulce jsou uvedeny údaje založené na hardwarové implementaci AES v roce 2005, výkon v současnosti může být lepší [1] .

Poznámky

↑ 1 2 3 4 5 6 7 8 9 Eli Biham, Orr Dunkelman. Hashovací funkce SHAVite-3 . cs.technion.ac.il . Katedra informatiky, Technion (31. října 2008). Získáno 2. listopadu 2016. Archivováno z originálu 19. srpna 2019. (neurčitý)
↑ 1 2 3 4 Eli Biham, Orr Dunkelman. Hashovací funkce SHAVite-3. Vylepšená verze . cs.technion.ac.il . Katedra informatiky, Technion (23. listopadu 2009). Datum přístupu: 21. prosince 2013. Archivováno z originálu 23. září 2015. (neurčitý)
↑ Richard F. Kayser. Oznamujeme žádost o nominace kandidátských algoritmů pro novou rodinu kryptografických hashovacích algoritmů (SHA-3) // Federal Register. - 2007. - 2. listopadu ( roč. 72 , č. 212 ). - S. 62212-62220 . — ISSN 0097-6326 . Archivováno z originálu 31. března 2011.
↑ Thomas Peyrin. Zpráva na mailing listu NIST o nalezené zranitelnosti . NIST mailing list . NIST Computer Security Resource Center (19. ledna 2009). Získáno 2. listopadu 2016. Archivováno z originálu 25. prosince 2016. (neurčitý)
↑ Paul Souradyuti. OFICIÁLNÍ KOMENTÁŘ: SHAVite-3 . NIST mailing list . NIST Computer Security Resource Center (16. června 2009). Staženo 2. listopadu 2016. Archivováno z originálu 19. prosince 2016. (neurčitý)
↑ 1 2 Eli Biham, Orr Dunkelman. Aktualizace na SHAVite-3 . cs.technion.ac.il . Katedra informatiky, Technion (23. srpna 2010). Datum přístupu: 21. prosince 2013. Archivováno z originálu 23. září 2015. (neurčitý)
↑ Mridul Nandi, Souradyuti Paul. Zpráva na mailing listu NIST o nalezené zranitelnosti . NIST mailing list . NIST Computer Security Resource Center (18. června 2009). Získáno 2. listopadu 2016. Archivováno z originálu 25. prosince 2016. (neurčitý)
↑ Gauravaram P. , Leurent G. , Mendel F. , Naya-Plasencia M. , Peyrin T. , Rechberger C. , Schläffer M. Cryptanalysis of the 10-Round Hash and Full Compression Function of SHAvite-3-512 // Progress in Cryptology - AFRICACRYPT 2010 : Third International Conference on Cryptology in Africa, Stellenbosch, South Africa, 3-6 May 2010. Proceedings / D. J. Bernstein , T. Lange - Berlin , Heidelberg , New York, NY , London [ etc.] : Springer Berlin Heidelberg , 2010. - S. 419-436. - ( Lecture Notes in Computer Science ; Vol. 6055) - ISBN 978-3-642-12677-2 - ISSN 0302-9743 ; 1611-3349 – doi:10.1007/978-3-642-12678-9_25
↑ Bouillaguet C. , Dunkelman O. , Leurent G. , Fouque P. Útoky na hashovací funkce založené na zobecněném Feistelu: Aplikace na Reduced-Round Lesamnta a SHAvite-3₅₁₂ // Vybrané oblasti v kryptografii : 17. mezinárodní seminář Waterloo, SACloo , Ontario, Kanada, 12. – 13. srpna 2010, Revised Selected Papers / A. Biryukov , G. Gong , D. Stinson - Berlín , Heidelberg , New York, NY , Londýn [atd.] : Springer Science+ Business Media , 2011. - S. 18-35. — 411 s. - ( Lecture Notes in Computer Science ; Vol. 6544) - ISBN 978-3-642-19573-0 - ISSN 0302-9743 ; 1611-3349 – doi:10.1007/978-3-642-19574-7
↑ Meltem Sonmez Turan a kol. Zpráva o stavu druhého kola soutěže o kryptografický hash algoritmus SHA-3 . csrc.nist.gov . NIST Computer Security Resource Center (2011). Datum přístupu: 21. prosince 2013. Archivováno z originálu 15. února 2013. (neurčitý)

Odkazy

Eli Biham, Orr Dunkelman. Oficiální stránka SHAVite-3. Archivováno 12. listopadu 2013 na Wayback Machine cs.technion.ac.il . Katedra informatiky, Technion (kontrolováno 9. 12. 2016)
Eli Biham, Orr Dunkelman. Specifikace SHAvite-3 (původní verze) Archivováno 27. listopadu 2020 na Wayback Machine cs.technion.ac.il . Katedra informatiky, Technion (zveřejněno 2. 1. 2009, ověřeno 12. 9. 2016)
Eli Biham, Orr Dunkelman. Specifikace SHAvite-3 (rozšířená verze) Archivováno 23. září 2015 na Wayback Machine cs.technion.ac.il . Ústav informatiky, Technion (zveřejněno 23. 11. 2016, ověřeno 12. 9. 2016)
Eli Biham, Orr Dunkelman. Aktualizace SHAvite-3 Archivovány 23. září 2015 na Wayback Machine cs.technion.ac.il . Katedra informatiky, Technion (zveřejněno 23. 8. 2010, ověřeno 12. 9. 2016)
stránky NIST. SHA-3 Algorithm Contest Archivováno 5. května 2010 na Wayback Machine csrc.nist.gov . Centrum počítačových bezpečnostních zdrojů NIST. (aktualizováno 14.09.2016, zkontrolováno 12.9.2016)
Regenscheid A. a kol. Výsledek prvního kola soutěže na algoritmus SHA-3 Archivováno 29. prosince 2009 na Wayback Machine csrc.nist.gov . Centrum počítačových bezpečnostních zdrojů NIST. (publikováno 2009, zkontrolováno 12.9.2016)
Turan MS a kol. Výsledek druhého kola soutěže na algoritmus SHA-3 Archivováno 15. února 2013 na Wayback Machine csrc.nist.gov . Centrum počítačových bezpečnostních zdrojů NIST. (zveřejněno 2011, zkontrolováno 12.9.2016)

Hashovací funkce
obecný účel	Adler-32 CRC Fletcherův kontrolní součet FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hash Tree jenkins hash hash sum
Kryptografický	Stribog GOST R 34.11-94 Pás BLAKE bmw CubeHash ECHO edonkey2k FSB Fuga Grostl HAVAL Hamsi JH Kupyna LM hash Luffa MD2 MD4 MD5 MD6 N-hash RIPEMD-128 RIPEMD-160 RIPEMD-256 RIPEMD-320 SHA-1 SHA-2 keccak (SHA-3) SHABAL SHAvite-3 SIMD SWIFFT Kůže Snefru Tygr vířivá vana
Funkce generování klíčů	bcrypt PBKDF2 scrypt Argon2 Lyra2
Kontrolní číslo ( srovnání )	Kontrolní součet Verhouffův algoritmus Algoritmus Měsíce Sakra algoritmus čárový kód bankovní účty bankovních karet ISIN SNILS OKPO CÍN OKATO ISBN OGRN a OGRNIP VIN
Hashe	Porovnání kontrolních čísel Autentizační protokoly Porovnání čárových kódů Kryptografie Magnetický odkaz Merkle podpis ed2k URNA