SHAvite-3

SHAvite-3
Kehittäjät	Eli Biham tai Dunkelman
Luotu	2008
julkaistu	2009
Hash-koko	muuttuva, jopa 512 bittiä
Kierrosten lukumäärä	12 tai 16
Tyyppi	hash-toiminto

SHAvite-3 on israelilaisten kryptografien Eli Bihamin ja Orr Dunkelmanin kehittämä kryptografinen hajautustoiminto . Yksi neljästätoista kilpailutyöstä NIST :n sponsoroiman SHA-3- kilpailun toisella kierroksella . SHAvite-3 perustuu AES -komponenttien yhdistelmään HAIFA - kehyksen kanssa . Tämä hash-funktio käyttää kryptografisia primitiivejä, kuten Feistel-verkkoa ja Davis-Meier-rakennetta. Hajautusfunktioiden SHAvite-3-perhe sisältää kaksi algoritmia - SHAvite-3 256 ja SHAvite-3 512 [1] .

Otsikko

Toiminnon nimi SHAVite-3 lausutaan nimellä "shavait shalosh" ( hepreaksi shavait three ). Kirjoittajat antoivat sille nimen seuraavista syistä [2] :

Shavit on käännetty hepreasta komeetta - kehitetty hash-funktio on turvallinen ja nopea ( fr. vite );
Shavite - Shivan seuraaja - hindujumala;
numero 3 otsikossa - kaksi aikaisempaa versiota ei julkaistu.

Historia

SHAvite-3-algoritmi on suunniteltu erityisesti SHA-3-kilpailua varten . Hajautusfunktion vaatimuksiin kuului kyky saada 224, 256, 384 ja 512 bitin pituisia tiivistelmiä korvaamaan SHA-2- salausalgoritmien perhe [3] . SHAvite-3:n kirjoittajat ovat kehittäneet kaksi toimintoa: SHAvite-3 256 224, 256 bitin tiivistelmien luomiseen ja SHAvite-3 512 384 ja 512 bitin tiivistelmien luomiseen. Kilpailun ensimmäisen kierroksen tuloksena taustalla olevasta lohkosalausalgoritmista löytyi haavoittuvuus, joka ei kuitenkaan johtanut hash-funktion vaarantumiseen [4] [5] .

Kirjoittajat ehdottivat muutosta alun perin kilpailuun lähetettyyn versioon algoritmin turvallisuuden lisäämiseksi. Muutosta kutsuttiin viritetyksi versioksi ja se vaikutti sekä SHAvite-3 256 :een että SHAvite-3 512 :een [2] . Tätä seurasi virheenkorjaus AES-kierrostoiminnon toteutuksessa ja parannettu SHAvite-3 512 :n kryptografinen vahvuus lisäämällä kierrosten määrää 14:stä 16: een [6] . Funktio saavutti kryptografisten toimintojen kilpailun toiselle kierrokselle, mutta sitä ei päästetty finaaliin lohkosalauksen taustalla olevien S-laatikoiden alustuksen riittämättömän turvallisuuden vuoksi, mikä johti suhteellisen alhaiseen turvallisuustasoon 512:ssa. -bittinen versio [7] [8] [9] . Samaan aikaan hash-funktiolla oli suhteellisen alhainen suoritusnopeus [10] .

Suunnitteluominaisuudet

SHAVite-3:n hash-toiminnon ominaisuudet ovat [1] :

Pakkausfunktioiden iteraatiot hajautusfunktion saamiseksi tehdään käyttämällä HAIFA- algoritmia ;
algoritmin avulla voit saada mielivaltaisen pituisen hajautusarvon, joka ei ylitä 512 bittiä;
tukee suolaa ;
pakkaustoiminto on suunniteltu käyttämällä tunnettuja ja hyvin tutkittuja komponentteja: Feistel-verkkoa , AES - kierrosfunktioita ja lineaarisia takaisinkytkentäsiirtorekistereitä .

Algoritmi

AES-kierros

SHAVite-3 käyttää ytimessä AES-kierrosta [1] . Kierros määrittää toiminnot 128-bittiselle numerolle . 128-bittinen data jaetaan 16:ksi 8-bittiseksi lohkoksi, jonka jälkeen lohkot kirjoitetaan 4×4-matriisina. Jokainen matriisin elementti edustaa arvoa kentässä GF(2 8 ). Kierros koostuu operaatioiden SubBytes ( ), ShiftRows ( ), MixColumns ( ) ja lisäys modulo 2 peräkkäisestä soveltamisesta pyöreänäppäimellä . $x$ $SB$ $SR$ $MC$ ${\displaystyle-aliavain}$

A E S R o 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_{subkey}(x)=MC(SR(SB(x)))\oplus-aliavain} $AESRound_{subkey}(x)=MC(SR(SB(x)))\oplus-aliavain$

haifa

SHAvite-3 on rakennettu HAIFA-hajautustoimintojen iteraatiotilaan [1] . HAIFA asettaa säännöt, joilla viesti täytetään haluttuun pituuteen, pakataan erikoistoiminnolla ja tuloste pienennetään vaadittuun pituuteen. Siten tiivistefunktion laskenta SHAVite-3-algoritmilla koostuu useiden vaiheiden suorittamisesta peräkkäin: $C$

Viestin täyttäminen jonkin verran, jotta se voidaan jakaa samankokoisiin lohkoihin. Nimetään täydennetty viesti ; $M$ $PM$
Lisätyn viestin jakaminen samankokoisiin lohkoihin: ; $l$ $PM=(M_{1},M_{2},...,M_{l})$
Alkuarvo , jossa on tärkein aloitusarvo, on haluttu tiivistelmän koko; $h_{0}=C(MIV,m,0,0)$ $MIV$ $m$
Seuraavan arvon laskeminen kaavan mukaan, jossa on laskentahetkellä hajautettujen sanomabittien määrä mukaan lukien nykyinen lohko. Toisin sanoen pituus . Parametri on suola . Sovelluksissa, joissa suolan käyttöä ei vaadita, SHAvite-3:n kirjoittajat ehdottavat käyttämistä , samalla kun se mahdollistaa turvallisuuden heikkenemisen ja laskentanopeuden lisäämisen [1] ; $h_{i}=C(h_{i-1},M_{i},numBits,salt)$ $numBits$ $Hei}$ $numBits$ ${\näyttötyyli (M_{1},M_{2},...,M_{i})}$ $salt$ $salt=0$
Pienentämällä lopullinen arvo vaadittuun pituuteen , tämä on tulos hajautusfunktion laskemisesta. ${\displaystyle h_{l))$ $m$

Viestin valmistuminen

Jos alkuperäisen viestin koko on , haluttu hash - arvon koko on ja sen lohkon koko , jossa pakkaustoiminto toimii , niin viestin täyttö , jolla on pituus , pituuden kerrannaiseksi on suoritetaan seuraavassa järjestyksessä: $A$ $B$ $C$ $n$ $M$ $len(M)$ $n$

Viestin loppuun lisätään yksi bitti arvolla 1 , saamme ; $M$ ${\näyttötyyli (M,1)}$
Arvolle annetaan , joka on koodattu bitteinä: ; $A$ $a$ ${\näyttötyyli (M,1,A)}$
Arvolle annetaan , joka on koodattu bitteinä: ; $B$ $b$ ${\näyttötyyli (M,1,A,B)}$
Bitin 1 jälkeen lisätään minimimäärä nollia, joka on tarpeen, jotta vastaanotetun viestin pituudesta tulee :: n kerrannainen . Nollien lukumäärä voidaan laskea kaavalla: . $PM$ $n$ $PM=(M,1,0,...,0,A,B)$ $z=n-(len(M)+1+a+b)\ mod\ n$

Algoritmin lajikkeet

SHAvite-3-algoritmilla on kaksi lajiketta, jotka eroavat käytetystä pakkausfunktiosta ja tiivistelmän pituudesta [1] : $C$

SHAvite-3 256 käyttää pakkaustoimintoa ja mahdollistaa jopa 256 bitin pituisen hajautusarvon; $C_{256}$
SHAvite-3 512 käyttää pakkaustoimintoa ja mahdollistaa 257-512 bitin pituisen tiivisteen saamisen. $C_{512}$

Digest Generation

Jos alkuperäinen viesti on , ja haluat saada pituuden tiivistelmän , suorita seuraava toimintosarja: $M$ $1\leq m\leq 512$

Määritellään . Kutsutaan ensimmäistä tapausta ja toista - . Ensimmäisessä tapauksessa toisessa - . $w$ $1\leq m\leq 256$ $256<m\leq 512$ $w=256$ $w=512$
Etsi missä ; $h_{0}=C_{w}(MIV_{w},p,0,0)$ $MIV_{w}=C_{w}(0,0,0,0)$
Täytetään viesti kokoon, joka on =512 kerrannainen ensimmäisessä tapauksessa tai enintään =1024 toisessa tapauksessa. Tätä varten käytämme aiemmin kuvattua menettelyä, jossa lasketaan ensimmäisessä tapauksessa =64 ja toisessa =128. Molemmissa tapauksissa =16; $n$ $n$ $a$ $a$ $b$
Jaetaan pehmustettu viesti bittilohkoiksi ja lasketaan kaikki paitsi kaksi viimeistä. Jos alkuperäisen viestin pituus on sellainen, että sanoman loppuun lisäämisen seurauksena muodostuu lohko, joka ei sisällä yhtään alkuperäisen viestin bittiä, niin , . Muussa tapauksessa se lasketaan samoilla kaavoilla kuin edelliset , ja ; $MP$ $n$ $Hei}$ $h_{l-1}=C_{w}(t_{l-2},M_{l-1},len(M),suola)$ $h_{l}=C_{w}(t_{l-1},M_{l},0,suola)$ $h_{l-1}$ $Hei}$ $h_{l}=C_{w}(t_{l-1},M_{l},0,suola)$
Otetaan ensimmäinen osa . Tämä on vaadittu hash-arvo. $m$ ${\displaystyle h_{l))$

Funktiot ja $C_{256}$ $C_{512}$

Neljän bitin vektorit otetaan syötteeksi:

Ketjutusarvo, jonka koko =256 bittiä varten ( bittiä varten ); $m_{c}$ $C_{256}$ $m_{c}=512$ $C_{512}$
Viestilohko, jonka koko on =512 bittiä varten ( =1024 bittiä ); $n$ $C_{256}$ $n$ $C_{512}$
Suola , jonka koko = 256 bittiä ( =512 bittiä ); $s$ $C_{256}$ $s$ $C_{512}$
Bittilaskuri, jonka koko = 64 bittiä ( =128 bittiä ). $b$ $C_{256}$ $b$ $C_{512}$

Lähtö on vektori, jonka koko on 256 bittiä (512 bittiä ). $C_{256}$ $C_{512}$

Toteutuksessa käytetään Davis-Meyer -rakennetta . Tämä tarkoittaa, että ketjun arvo lasketaan uudelleen kaavojen ja vastaavasti [1] mukaisesti . $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))$

Toiminto

E^{256}

$E^{256}$ - 12-kierroksen lohkosalaus . Tämä lohkosalaus on Feistel-verkko , joka koostuu 12 Feistel-solusta. hyväksyy 256-bittisen tavallisen tekstin syötteenä . Se voidaan jakaa kahteen osaan, joista kumpikin on 128 bittiä. . Jokaisen kierroksen arvojen uudelleenlaskenta suoritetaan kaavan mukaan: . $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}))$

Tässä on kolmen avaimen vektori, joka on erilainen jokaisella kierroksella, ja se on jokin funktio. Tuloksena palautusarvo voidaan laskea: . $RK_{i}=(k_{i}^{0},k_{i}^{1},k_{i}^{2})$ $F^{3}$ $E^{256}=(L_{12},R_{12})$

Toiminto

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

Funktio ottaa syötteeksi 128-bittisen tekstin ja 384-bittisen avaimen , joka saadaan yhdistämällä kolme 128-bittistä avainta . Se koostuu AES-kierroksen soveltamisesta kolme kertaa: . Syöttövektoriin lisätään modulo 2 avaimella , ja tulokseen sovelletaan kolme AES-kierrosta eri avaimilla seuraavassa järjestyksessä: AES-kierros avaimella , toinen AES-kierros avaimella , viimeinen kierros avaimella 0 (128 bittiä). $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))$

Avaimen luominen kohteelle

E^{256}

Toiminnon laskemiseen tarvitaan kolme 128-bittistä avainta jokaisella 12 kierroksella. Tätä varten käytetään algoritmia avainten luomiseksi yhdestä avaimesta. Yhtenä avaimena, josta myöhemmin muodostetaan 36, käytetään viestilohkon (512 bittiä), suolan (256 bittiä) ja bittilaskurin (64 bittiä) yhdistelmää. Algoritmissa kaikki toiminnot suoritetaan 4-tavuisille arvoille. Otetaan käyttöön seuraava merkintä: $E^{256}$

$msg[0],...,msg[15]$ — viestilohko;
$cnt[0],cnt[1]$ - bittilaskuri;
$salt[0],...,salt[7]$ - suola.

Algoritmin tuloksena saamme 144 arvoa (myös 4-tavuinen):

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

// Avaimen luontialgoritmi E^256:lle C/C++:ssa // Alusta saadun taulukon ensimmäiset 16 arvoa alkuperäisellä viestillä kohteelle ( int i = 0 ; i < 16 ; i ++ ) rk [ i ] = msg [ i ]; int i = 16 ; for ( int k = 0 ; k < 4 ; k ++ ) { uint32_t t [ 4 ]; // Epälineaarinen askel kohteelle ( int r = 0 ; r < 2 ; r ++ ) { // Suorita AES-kierros avaimella 0 128-bittiselle arvolle // joka on rk-taulukon aiemmin laskettujen // elementtien ja suolan (bitit 0-127) modulo-2 summa . // Kirjoita 128-bittinen tulos taulukkoon t AESRound0 ( rk [ i -15 ] ^ suola [ 0 ], rg [ i -14 ] ^ suola [ 1 ], rk [ i -13 ] ^ suola [ 2 ], rk [ i -16 ] ^ suola [ 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 ; // Sama AES-kierros kuin ennen // mutta muulla suolalla (128-255 bittiä) AESRound0 ( rk [ i -15 ] ^ suola [ 4 ], rg [ i -14 ] ^ suola [ 5 ], rk [ i -13 ] ^ suola [ 6 ], rk [ i -16 ] ^ suola [ 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 ; } // Lineaarinen askel for ( int r = 0 ; r != 16 ; ++ r ) { rk [ i ] = rk [ i -16 ] ^ rk [ i -3 ]; i += 1 ; } }

Yllä esitetty algoritmi on tekijöiden muunnelma versio. Ainoa ero alun perin SHA-3- kilpailuun lähetetystä versiosta on laskurin bittikohtaisten negatiivisten toimintojen "~" läsnäolo . Negaatio on lisätty lisäämään hash-funktion kryptografista vahvuutta . Tällaisten toimintojen olemassaolo takaa, että vähintään 4 laskurin 8 tavusta on nollasta poikkeavia [2] . $(cnt[0],cnt[1])$

Näppäimet funktion laskemiseen saadaan seuraavista: , missä , . $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)$

Toiminto

E^{512}

Tämä toiminto toteutetaan analogisesti :n kanssa , mutta hyväksyy syötteenä 512-bittisen pelkkää tekstiä , joka esitetään 4 osana $E^{256}$ $P$

128 bittiä: . Uudelleenlaskenta suoritetaan 14 kierroksen kaavan mukaan (päivitetyssä versiossa kirjoittajat ehdottivat 16 kierroksen käyttöä [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})$

Toiminto

F_{k}^{4}

Se hyväksyy 128 bitin tekstiä ja 512-bittisen avaimen syötteenä . Laskettu 4 AES-kierrokseksi. . $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}))))$

Avaimen luominen kohteelle

E^{512}

Funktio vaatii kahdeksan 128-bittistä avainta kullakin 14 kierroksella funktion laskemiseksi . Avaimia on yhteensä 112. Ne perustuvat viestilohkoon (1024 bittiä), suolaan (512 bittiä) ja bittilaskuriin (128 bittiä). Kaikki toiminnot suoritetaan 4-tavuisilla arvoilla. Otetaan käyttöön seuraava merkintä: $E^{512}$

$msg[0],...,msg[31]$ - viestilohko
$cnt[0],...,cnt[3]$ - bittilaskuri
$salt[0],...,salt[15]$ - suola

Algoritmin tuloksena saamme 448 arvoa (4 tavua):

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

// Avaimen luontialgoritmi E^512:lle C/C++:ssa // Alusta saadun taulukon ensimmäiset 32 arvoa alkuperäisellä viestillä kohteelle ( int i = 0 ; i < 32 ; i ++ ) rk [ i ] = msg [ i ]; int i = 32 ; for ( int k = 0 ; k < 7 ; k ++ ) { uint32_t t [ 4 ]; // Epälineaarinen askel (7 kertaa) for ( int r = 0 ; r < 2 ; r ++ ) { AESRound0 ( rk [ i -31 ] ^ suola [ 0 ], rg [ i -30 ] ^ suola [ 1 ], rk [ i -29 ] ^ suola [ 2 ], rk [ i -32 ] ^ suola [ 3 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES-kierros avaimella 0, suola 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 ] ^ suola [ 4 ], rg [ i -30 ] ^ suola [ 5 ], rk [ i -29 ] ^ suola [ 6 ], rk [ i -32 ] ^ suola [ 7 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES-kierros avaimella 0, suola 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 ] ^ suola [ 8 ], rg [ i -30 ] ^ suola [ 9 ], rk [ i -29 ] ^ suola [ 10 ], rk [ i -32 ] ^ suola [ 11 ], & t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES-kierros avaimella 0, suola 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 ] ^ suola [ 12 ], rg [ i -30 ] ^ suola [ 13 ], rk [ i -29 ] ^ suola [ 14 ], rk [ i -32 ] ^ suola [ 15 ] ja t [ 0 ], & t [ 1 ], & t [ 2 ], & t [ 3 ]); // AES-kierros avaimella 0, suola 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 ) tauko ; // älä ota 7. lineaarista askelta // Lineaarinen askel (6 kertaa) for ( int r = 0 ; r != 32 ; ++ r ) { rk [ i ] = rk [ i -32 ] ^ rk [ i -7 ]; i += 1 ; } }

Tässä, kuten 256-bittisessä versiossa, ainoa ero parannetun version ja alun perin SHA-3-kilpailuun lähetetyn version välillä on bittikohtaisten EI "~"-toimintojen läsnäolo ennen laskuriarvoja. Tällaisten toimintojen olemassaolo takaa, että vähintään 4 laskurin 16 tavusta on nollasta poikkeavia [2] . $(cnt[0],cnt[1],cnt[2],cnt[3])$

Lisäksi avaimet funktion laskemiseen saadaan seuraavista: , missä , . $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)$

Suorituskyky

Taulukossa on vertailutietoa algoritmien nopeuksista [1] .

Algoritmi	Nopeus (sykliä/tavu)
Algoritmi	32-bittinen	64-bittinen
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 (muutos)	35.3	26.7
SHAVite-3 256 (noin)	26.6	18.6
SHAVite-3 256 (AES-työkalulla)	<8	<8
SHAVite-3 512 (muutos)	55,0	38.2
SHAVite-3 512 (noin)	35.3	28.4
SHAvite-3 512 (AES-työkalulla)	< 12	< 12

Toiminto voidaan toteuttaa myös laitteistossa.

Pituus	Tekniikka	Koko	Kaistanleveys
256	ASIC	10,3 kg	7,6 Mbps
		55,0 kg	604,4 Mbps
	FPGA	510 viipaletta	1,7 Mbps
		3585	872,3 Mbps
512	ASIC	18,5 kg	4,7 Mbps
		81 kiloa	907,7 Mbps
	FPGA	895 viipaletta	1,0 Mbps
		7170 viipaletta	1,12 Gbps

Taulukossa näkyvät tiedot perustuvat AES:n laitteistototeutukseen vuonna 2005, suorituskyky voi tällä hetkellä olla parempi [1] .

Muistiinpanot

↑ 1 2 3 4 5 6 7 8 9 Eli Biham, Orr Dunkelman. SHAVite-3 Hash Function . cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (31. lokakuuta 2008). Haettu 2. marraskuuta 2016. Arkistoitu alkuperäisestä 19. elokuuta 2019. (määrätön)
↑ 1 2 3 4 Eli Biham, Orr Dunkelman. SHAVite-3 Hash Function. Muokattu versio . cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (23.11.2009). Käyttöpäivä: 21. joulukuuta 2013. Arkistoitu alkuperäisestä 23. syyskuuta 2015. (määrätön)
↑ Richard F. Kayser. Ilmoitetaan pyyntö ehdokasalgoritmien nimittämiseksi uudelle kryptografiselle hajautusalgoritmiperheelle (SHA-3) // Federal Register. - 2007. - 2. marraskuuta ( nide 72 , nro 212 ). - P. 62212-62220 . — ISSN 0097-6326 . Arkistoitu alkuperäisestä 31. maaliskuuta 2011.
↑ Thomas Peyrin. NIST-postituslistalla oleva viesti löydetystä haavoittuvuudesta . NIST-postituslista . NIST Computer Security Resource Center (19. tammikuuta 2009). Haettu 2. marraskuuta 2016. Arkistoitu alkuperäisestä 25. joulukuuta 2016. (määrätön)
↑ Paul Souradyuti. VIRALLINEN KOMMENTTI: SHAVIte-3 . NIST-postituslista . NIST Computer Security Resource Center (16. kesäkuuta 2009). Haettu 2. marraskuuta 2016. Arkistoitu alkuperäisestä 19. joulukuuta 2016. (määrätön)
↑ 1 2 Eli Biham, Orr Dunkelman. SHAVite-3:n päivitykset . cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (23. elokuuta 2010). Käyttöpäivä: 21. joulukuuta 2013. Arkistoitu alkuperäisestä 23. syyskuuta 2015. (määrätön)
↑ Mridul Nandi, Souradyuti Paul. NIST-postituslistalla oleva viesti löydetystä haavoittuvuudesta . NIST-postituslista . NIST Computer Security Resource Center (18. kesäkuuta 2009). Haettu 2. marraskuuta 2016. Arkistoitu alkuperäisestä 25. joulukuuta 2016. (määrätön)
↑ Gauravaram P. , Leurent G. , Mendel F. , Naya-Plasencia M. , Peyrin T. , Rechberger C. , Schläffer M. SHAvite-3-512:n 10-kierroksen hajautus- ja täyden pakkausfunktion kryptaanalyysi ) // Progress in Cryptology - AFRICACRYPT 2010 : Kolmas kansainvälinen kryptologiakonferenssi Afrikassa, Stellenbosch, Etelä-Afrikka, 3.-6.5.2010. Proceedings / D. J. Bernstein , T. Lange - Berliini , Heidelberg , New York, NY , Lontoo [jne.] : 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. Hyökkäykset hash-funktioihin perustuen yleistettyyn Feisteliin: Sovellus supistettuihin Lesamnta- ja SHAvite-3₅₁₂ -alueisiin // Valitut alueet kryptografiassa , Ontario, Kanada, 12.-13. elokuuta 2010, Revised Selected Papers / A. Biryukov , G. Gong , D. Stinson - Berliini , Heidelberg , New York, NY , Lontoo [jne.] : 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 et ai. Tilaraportti SHA-3 Cryptographic Hash Algorithm Competition -kilpailun toisesta kierroksesta . csrc.nist.gov . NIST Computer Security Resource Center (2011). Käyttöpäivä: 21. joulukuuta 2013. Arkistoitu alkuperäisestä 15. helmikuuta 2013. (määrätön)

Linkit

Eli Biham, Orr Dunkelman. SHAVite-3:n virallinen sivu. Arkistoitu 12. marraskuuta 2013 osoitteessa Wayback Machine cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (tarkistettu 9.12.2016)
Eli Biham, Orr Dunkelman. SHAvite-3 Specification (Alkuperäinen versio) Arkistoitu 27. marraskuuta 2020 Wayback Machinen cs.technion.ac.il osoitteeseen . Tietojenkäsittelytieteen laitos, Technion (julkaistu 1.2.2009, vahvistettu 12.9.2016)
Eli Biham, Orr Dunkelman. SHAvite-3 Specification (Enhanced Version) Arkistoitu 23. syyskuuta 2015 osoitteessa Wayback Machine cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (julkaistu 23.11.2009, vahvistettu 12.9.2016)
Eli Biham, Orr Dunkelman. SHAvite-3-päivitykset arkistoitu 23. syyskuuta 2015 Wayback Machineen cs.technion.ac.il . Tietojenkäsittelytieteen laitos, Technion (julkaistu 23.8.2010, vahvistettu 12.9.2016)
NIST-sivusto. SHA-3 Algorithm Contest Arkistoitu 5. toukokuuta 2010 Wayback Machinessa csrc.nist.gov . NIST Computer Security Resource Center. (päivitetty 14.9.2016, tarkistettu 12.9.2016)
Regenscheid A. et ai. SHA-3-algoritmin kilpailun ensimmäisen kierroksen tulos Arkistoitu 29. joulukuuta 2009 Wayback Machinessa csrc.nist.gov . NIST Computer Security Resource Center. (julkaistu 2009, tarkistettu 12.09.2016)
Turan MS et ai. SHA-3-algoritmin kilpailun toisen kierroksen tulos Arkistoitu 15. helmikuuta 2013 Wayback Machinessa csrc.nist.gov . NIST Computer Security Resource Center. (julkaistu 2011, tarkistettu 12.09.2016)

Hash-funktiot
yleinen tarkoitus	Adler-32 CRC Fletcherin tarkistussumma FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hash Tree jenkins hash hash summa
Kryptografinen	Stribog GOST R 34.11-94 Vyö BLAKE BMW CubeHash KAIKU edonkey2k FSB Fuuga 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 Iho Snefru Tiikeri Whirlpool
Avainten luontitoiminnot	bcrypt PBKDF2 scrypt Argon 2 Lyra 2
Tarkista numero ( vertailu )	Tarkista summa Verhouffin algoritmi Kuun algoritmi Damm-algoritmi Viivakoodi pankkitilit pankkikortit ISIN SNILS OKPO TINA OKATO ISBN OGRN ja OGRNIP VIN
Hashes	Sekkinumeroiden vertailu Todennusprotokollat Viivakoodin vertailu Kryptografia Magneettilinkki Merklen allekirjoitus ed2k UURNA