SHA-3

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 3. januar 2016; checks kræver 57 redigeringer .

SHA-3, Keccak
Udviklere	Guido Bertoni, Joan Dymen , Mikael Pieters, Gilles Van Asche
Oprettet	2008
offentliggjort	2008
Forgænger	SHA-2
Hash størrelse	224, 256, 384, 512 (variabel, 0<d≤2 64 -1)
Antal runder	24 (standard)
Type	hash funktion

SHA-3 ( Keccak -udtales "kechak") er en hashing -algoritme med variabel længde udviklet af en gruppe forfattere ledet af Joan Dymen , medforfatter til Rijndael , forfatter til MMB , SHARK , Noekeon , SQUARE og BaseKing-cifre . Den 2. oktober 2012 blev Keccak vinderen af den kryptografiske algoritmekonkurrence afholdt af US National Institute of Standards and Technology [1] . Den 5. august 2015 blev algoritmen godkendt og offentliggjort som en FIPS 202 [2] [3] standard . I softwareimplementering hævder forfatterne 12,5 cyklusser pr. byte, når de udføres på en pc med en Intel Core 2-processor . Men i hardwareimplementeringer viste Keccak sig at være meget hurtigere end alle de andre finalister. [fire]

SHA-3-algoritmen er bygget på princippet om en kryptografisk svamp (denne struktur af kryptografiske algoritmer blev foreslået tidligere af forfatterne af Keccak-algoritmen) [5] .

Historie

I 2004-2005 blev adskillige hashing-algoritmer angrebet, herunder alvorlige angreb offentliggjort mod National Institute of Standards and Technology (NIST) SHA-1-algoritme . Som svar afholdt NIST åbne workshops og annoncerede den 2. november 2007 en konkurrence om at udvikle en ny hashing-algoritme. Den 2. oktober 2012 blev Keccak-algoritmen vinderen af konkurrencen og blev standardiseret som den nye SHA-3-algoritme [6] . Den 5. august 2015 blev algoritmen godkendt og offentliggjort som en FIPS 202 [2] [3] standard .

Algoritmen blev udviklet af Guido Bertoni , Joan Dymen , Gilles Van Asche fra STMicroelectronics og Mikael Pieters fra NXP [7] .

Algoritmen er baseret på de tidligere Panama og RadioGatún [8] hash-funktioner . Panama blev udviklet af Dimen og Craig Clapp i 1998, RadioGatún blev implementeret baseret på Panama af Dimen, Peters og Van Asche i 2006 [8] .

Under konkurrencen fik deltagerne lov til at foretage ændringer i deres algoritme for at rette op på problemer, der blev opdaget. Ændringer i Keccak-algoritmen [9] [10] :

Antallet af runder er øget fra 12+ til 12+2 $l$ $l$
Polstring er blevet ændret fra en kompleks form til en mere enkel, beskrevet nedenfor
Rate r er blevet øget til sikkerhedsgrænsen (tidligere rundet ned til nærmeste potens af 2)

Algoritme

Hash-funktionerne i SHA-3- familien er baseret på konstruktionen af en kryptografisk svamp [5] , hvor data først "absorberes" i svampen, hvor den oprindelige besked udsættes for multi-runde permutationer , derefter resultatet "klemmes" ud af svampen. I "soak"-fasen summeres meddelelsesblokkene modulo 2 med en delmængde af tilstanden, hvorefter hele tilstanden transformeres ved hjælp af permutationsfunktionen . Under "push"-stadiet læses udgangsblokkene fra den samme delmængde af tilstanden, der er modificeret af permutationsfunktionen . Størrelsen af den del af tilstanden, der skrives og læses, kaldes "hastigheden" ( eng. rate ) og er angivet med , og størrelsen af den del, der er uberørt af input/output, kaldes "kapaciteten" ( eng . kapacitet ) og er angivet med . $M$ $f$ $Z$ $f$ $f$ $r$ $c$

Algoritmen til at opnå hashfunktionsværdien kan opdeles i flere trin [11] :

Den originale besked udfyldes til en streng med længde, der er et multiplum af , ved hjælp af udfyldningsfunktionen (pad-funktion); $M$ $P$ $r$
Snoren er opdelt i blokke af længde : ; $P$ $n$ $r$ ${\displaystyle P_{0},P_{1},...,P_{n-1))$
Soak: Hver blok er polstret med nuller til en bitlængdestreng og summeret modulo 2 til statusstrengen , hvor er bitlængdestrengen ( = + ). Før funktionen starter, er alle elementer lig med nul. For hver næste blok er tilstanden den streng, der opnås ved at anvende permutationsfunktionen på resultatet af det foregående trin; $P_{i}$ $b$ $S$ $S$ $b$ $b$ $r$ $c$ $S$ $f$
"Push-up": mens længden er mindre end ( - antallet af bits i resultatet af hashfunktionen), tilføjes de første bits af tilstanden til k, efter hver tilføjelse til k , anvendes permutationsfunktionen . Derefter afkortet til bitlængde ; $Z$ $d$ $d$ $Z$ $r$ $S$ $S$ $f$ $Z$ $d$
En bitlængdestreng returneres som resultat. $Z$ $d$

På grund af det faktum, at tilstanden indeholder yderligere bit, er algoritmen modstandsdygtig over for beskedforlængende angreb , som SHA-1- og SHA-2- algoritmerne er modtagelige for . $c$

I SHA-3 er en tilstand en matrix på 5 × 5 ord med længde = 64 bit, i alt 5 × 5 × 64 = 1600 bit. Også i Keccak kan længder svarende til mindre potenser på 2 (fra = 1 til = 32) bruges. $S$ $w$ $w$ $w$ $w$

Tillæg

For at den oprindelige besked M kan opdeles i blokke med længden r , kræves udfyldning . SHA-3 bruger pad10*1 [11] mønsteret: en 1 tilføjes til beskeden, efterfulgt af 0 eller flere nul bits (op til r-1 ), og en 1 i slutningen.

r-1 nul bit kan tilføjes, når den sidste meddelelsesblok er r-1 bit lang. Denne blok er polstret med en, den næste blok vil bestå af r-1 nuller og en.

To 1-bit tilføjes også, hvis længden af den oprindelige besked M er delelig med r [11] . I dette tilfælde tilføjes en blok til meddelelsen, der starter og slutter med enere, mellem hvilke der er r-2 nul bits. Dette er nødvendigt, så for en meddelelse, der slutter med en sekvens af bit som i padding-funktionen, og for en meddelelse uden disse bits, er hash-værdierne forskellige.

Den første 1 bit er nødvendig, så resultaterne af hash-funktionen fra meddelelser, der adskiller sig med flere nulbit i slutningen, er forskellige [11] .

Permutationsfunktionen

Permutationsfunktionen, der bruges i SHA-3, inkluderer eksklusiv OR (XOR) , bitwise AND (AND) og bitwise negation (NOT) . Funktionen er defineret for strenge med længde-potens 2 . I hovedimplementeringen af SHA-3 ( ). ${\displaystyle w=2^{l))$ $w=64$ $l=6$

Tilstanden kan repræsenteres som et tredimensionelt array med størrelsen 5 × 5 × . Så er array-elementet statuslinjebitten . $S$ $EN$ $w$ $A[i][j][k]$ $(5i+j)\ gange w+k$ $S$

Funktionen indeholder flere trin: , , , , , som udføres i flere omgange [11] . Ved hvert trin betegner vi input-arrayet A, output-arrayet A'. $\theta$ $\rho$ $\pi$ $\chi$ $\iota$

Trin $\theta$

For alle og , sådan at , , vi sætter $jeg$ $k$ $0\leqslant i<5$ $0\leqslant k<w$

$C(i,k)=A[i,0,k]\oplus A[i,1,k]\oplus A[i,2,k]\oplus A[i,3,k]\oplus A[i,4,k]$

$D(i,k)=C[(i-1){\bmod {5}},k]\oplus C[(i+1){\bmod {5}},(k-1){ \bmod{w}}]$

For alle , sådan at , , , $(i,j,k)$ $0\leqslant i<5$ $0\leqslant j<5$ $0\leqslant k<w$

$A'[i,j,k]=A[i,j,k]\oplus D[i,k]$

Trin $\rho$

For alle , sådan at $k$ $0\leqslant k<w$ $A'[0,0,k]=A[0,0,k]$

Lad i begyndelsen . For 0 til 23: $(i,j)=(1,0)$ $t$

For alle , sådan at $k$ $0\leqslant k<w$ $A'[i,j,k]=A[i,j,(k-(t+1)(t+2)/2){\bmod {w))]$
$(i,j)=(j,(2i+3j){\bmod {5)))$

Trin $\pi$

For alle , sådan at , , $(i,j,k)$ $0\leqslant i<5$ $0\leqslant j<5$ $0\leqslant k<w$

$A'[i,j,k]=A[(i+3j){\bmod {5)),i,k]$

Trin $\chi$

For alle , sådan at , , $(i,j,k)$ $0\leqslant i<5$ $0\leqslant j<5$

$A'[i,j,k]=A[i,j,k]\oplus ((A[(i+1){\bmod {5)),j,k]\oplus 1)\cdot A[(i+2){\bmod {5}},j,k])$

Trin $\iota$

Vi introducerer en ekstra funktion , hvor input er et heltal og output er lidt. $rc(t)$ $t$

Algoritme

rc(t)

Hvis , returneres 1 $t{\bmod {2}}55=0$
Lade $R=[10000000]$
For i fra 1 til t mod 255:
1. R = 0 || R
2. $R[0]=R[0]\plus R[8]$
3. $R[4]=R[4]\plus R[8]$
4. $R[5]=R[5]\plus R[8]$
5. $R[6]=R[6]\plus R[8]$
6. $R=Trunc_{8}[R]$
Vender tilbage $R[0]$ $.$

Algoritme

\iota (A,i_{r})

$i_{r}$ - rundt tal.

For alle , sådan at , , $(i,j,k)$ $0\leqslant i<5$ $0\leqslant j<5$ $0\leqslant k<w$ $A'[i,j,k]=A[i,j,k]$
Lade være en matrix af længde fyldt med nuller. $RC$ $w$
For 0 til : $jeg$ $l$ $RC[2^{i}-1]=rc(i+7i_{r})$
For alle , sådan at $k$ $0\leqslant k<w$ $A'[0,0,k]=A'[0,0,k]\oplus RC[k]$

Permutationsalgoritme

Oversættelse af en streng til et array $S$ $EN$
For fra til $i_{r}$ ${\displaystyle 12+2l-n_{r))$ $12+2l-1$ $A'=\iota (\chi (\pi (\rho (\theta (A)))),i_{r})$
Konvertering af et array til en længdestreng $EN'$ $S'$ $b$

Hashing-meddelelser af vilkårlig længde

Grundlaget for algoritmens kompressionsfunktion er funktionen f, som udfører blandingen af algoritmens interne tilstand. Tilstanden (lad os betegne det A) er repræsenteret som et 5×5 array , hvis elementer er 64-bit ord initialiseret med nul bit (det vil sige størrelsen af tilstanden er 1600 bit). Funktionen f udfører 24 runder, i hver af hvilke følgende handlinger udføres:

C[x] = A[x, 0] A[x, 1] A[x, 2] A[x, 3] A[x, 4], x = 0…4;

\plus

\plus

\plus

\plus

D[x] = C[x - 1] (С[x + 1] >>> 1), x = 0...4;

\plus

A[x, y] = A[x, y] D[x], x = 0...4, y = 0...4;

\plus

B[y, 2x + 3y] = A[x, y] >>> r[x, y], x = 0...4, y = 0...4; A[x, y] = B[x, y] (~B[x + 1, y] & B[x + 2, y]), x = 0…4, y = 0…4,

\plus

Hvor:

B er et midlertidigt array, der i struktur ligner tilstandsarrayet; C og D er midlertidige arrays, der hver indeholder fem 64-bit ord; r er et array, der definerer mængden af cyklisk skift for hvert tilstandsord; ~x er det bitvise komplement af x ; og operationer på array-indekser udføres modulo 5.

Ud over ovenstående operationer pålægger XOR-operationen i hver runde også en rundekonstant på ordet A[0, 0].

Før komprimeringsfunktionen udføres, overlejres driften af XORing af fragmenter af den originale meddelelse med fragmenterne af den oprindelige tilstand. Resultatet behandles af f- funktionen . Denne overlejring udgør sammen med komprimeringsfunktionen udført for hver blok af inputdata den "absorberende" fase af den kryptografiske svamp.

Det er værd at bemærke, at f -funktionen kun bruger operationer, der er resistente over for side-kanal datalækageangreb.

Den resulterende hashværdi beregnes under squeezing-fasen af den kryptografiske svamp, som også er baseret på f -funktionen beskrevet ovenfor . Mulige hash-størrelser er 224, 256, 384 og 512 bit.

Indstillinger

Den originale Keccak-algoritme har mange justerbare parametre [11] for at give den optimale balance mellem kryptografisk styrke og hastighed for en specifik anvendelse af algoritmen på en specifik platform. Justerbare værdier er: størrelsen af datablokken, størrelsen af algoritmetilstanden, antallet af runder i f() -funktionen og andre.

Under National Institute of Standards and Technology hashing-konkurrence havde deltagerne ret til at justere deres algoritmer for at løse problemer. Så der blev foretaget nogle ændringer i Keccak: antallet af runder blev øget fra 18 til 24 for at øge sikkerhedsmarginen.

Forfatterne af Keccak har etableret en række priser for præstationer i kryptoanalysen af denne algoritme.

Den version af algoritmen, der blev vedtaget som den endelige SHA-3-standard, har et par mindre forskelle fra Keccaks oprindelige indsendelse til konkurrencen. Især nogle parametre var begrænsede (langsomme tilstande c=768 og c=1024 blev droppet), herunder for at øge ydeevnen [12] [13] [14] [15] . Standarden introducerede også "funktioner med et udvidet resultat" (XOF, Extendable Output Functions) SHAKE128 og SHAKE256, for hvilke det blev nødvendigt at supplere den hashed-meddelelse med et " suffiks " på 2 eller 4 bit, afhængigt af funktionstypen .

Fungere	Formel
SHA3-224( M )	Keccak[448]( M \|\|01, 224)
SHA3-256( M )	Keccak[512]( M \|\|01, 256)
SHA3-384( M )	Keccak[768]( M \|\|01, 384)
SHA3-512( M )	Keccak[1024]( M \|\|01, 512)
SHAKE128( M , d )	Keccak[256]( M \|\|1111, d )
SHAKE256( M , d )	Keccak[512]( M \|\|1111, d )

Yderligere funktioner

I december 2016 offentliggjorde US National Institute of Standards and Technology et nyt dokument, NIST SP.800-185 [16] , der beskriver yderligere funktioner baseret på SHA-3:

Fungere	Beskrivelse
cSHAKE128( X , L , N , S )	Parametriseret version af SHAKE
cSHAKE256( X , L , N , S )	Parametriseret version af SHAKE
KMAC128( K , X , L , S )	Imiteret indsats baseret på Keccak
KMAC256( K , X , L , S )
KMACXOF128( K , X , L , S )
KMACXOF256( K , X , L , S )
TupleHash128( X , L , S )	Hashing en tuple af strenge
TupleHash256( X , L , S )
TupleHashXOF128( X , L , S )
TupleHashXOF256( X , L , S )
ParallelHash128( X , B , L , S )	Parallellerbar hash-funktion baseret på Keccak
ParallelHash256( X , B , L , S )
ParallelHashXOF128( X , B , L , S )
ParallelHashXOF256( X , B , L , S )

Test vektorer

Værdier af forskellige hash-varianter fra en tom streng.

SHA3-224("") 6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7 SHA3-256("") a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a SHA3-384("") 0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004 SHA3-512("") a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f5050b165d5050b165d5cd2c165d5050b165d5050b165d5050165d5050165d5050165d9 SHAKE128("", 256) 7f9c2ba4e88f827d616045507605853ed73b8093f6efbc88eb1a6eacfa66ef26 SHAKE256("", 512) 46b9dd2b0ba88d13233b3feb743eeb243fcd52ea62b81b82b50c27646ed5762fd75dc4ddd8c0f200cb05019d67b592f4864329bc2c429bc2c429bc2c429bc2c429b

En lille ændring i meddelelsen resulterer i en stor ændring i hashværdien på grund af lavineeffekten , som vist i følgende eksempler:

SHA3-224(" Den hurtige brune ræv hopper over den dovne hund ") d15dadceaa4d5d7bb3b48f446421d542e08ad8887305e28d58335795 SHA3-224("Den hurtige brune ræv hopper over den dovne hund . ") 2d0708903833afabdd232a20201176e8b58c5be8a6fe74265ac54db0 SHA3-256("Den hurtige brune ræv hopper over den dovne hund") 69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04 SHA3-256("Den hurtige brune ræv hopper over den dovne hund . ") a80f839cd4f83f6c3dafc87feae470045e4eb0d366397d5c6ce34ba1739f734d SHA3-384("Den hurtige brune ræv hopper over den dovne hund") 7063465e08a93bce31cd89d2e3ca8f602498696e253592ed26f07bf7e703cf328581e1471a7ba7ab119b1a9ebdf8be41 SHA3-384("Den hurtige brune ræv hopper over den dovne hund . ") 1a34d81695b622df178bc74df7124fe12fac0f64ba5250b78b99c1273d4b080168e10652894ecad5f1f4d5b965437fb9 SHA3-512("Den hurtige brune ræv hopper over den dovne hund") 01dedd5de4ef14642445ba5f5b97c15e47b9ad931326e4b0727cd94cefc44fff23f07bf543139939b49128caf436dc1bdee596dc1bdee594fcb5048b404fcb400f200f400f400f200f2000f SHA3-512("Den hurtige brune ræv hopper over den dovne hund . ") 18f4f4bd419603f95538837003d9d254c26c23765565162247483f65c50303597bc9ce4d289f21d1c2f1f458828e330506d38bae4e3d34e34e34e30506b8e3e4e34e3e3e3056b8e3e4e34e3e3056b8ba SHAKE128("Den hurtige brune ræv hopper over den dovne hund", 256) f4202e3c5852f9182a0430fd8144f0a74b95e7417ecae17db0f8cfeed0e3e66e SHAKE128("Den hurtige brune ræv hopper over den dovne dof " , 256) 853f4538be0db9621a6cea659a06c1107b1f83f02b13d18297bd39d7411cf10c

Krypteringsanalyse

Resultaterne af kryptoanalyse under konkurrencen [4] .

Mål	Angrebstype	Afslut	Mulighed	CF opkald	Hukommelse
hash funktion	kollision	160	r = {240, 640, 1440}, c=160 1, 2 omgange
hash funktion	At finde prototypen	80	r = {240, 640, 1440}, c=160 1, 2 omgange
Permutationer	angrebsdiskriminerende	Alle	24 runder	$2^{1579}$
Permutationer	differentiel ejendom	Alle	8 runder	$2^{491.47}$
hash funktion	angrebsdiskriminerende	224, 256	4 runder	$2^{25}$
hash funktion	kollision	224, 256	2 omgange	$2^{{33}}$
hash funktion	At finde den anden prototype	224, 256	2 omgange	$2^{{33}}$	$2^{29}$
hash funktion	At finde den anden prototype	512	6 runder	$2^{506}$	$2^{176}$
hash funktion	At finde den anden prototype	512	7 runder	$2^{507}$	$2^{320}$
hash funktion	At finde den anden prototype	512	8 runder	$2^{511.5}$	$2^{508}$
hash funktion	kollision	224, 256	4 runder

Noter

↑ NIST udvælger vinder af Secure Hash Algorithm (SHA-3) konkurrence . Hentet 3. oktober 2012. Arkiveret fra originalen 5. oktober 2012. (ubestemt)
↑ 1 2 NIST frigiver SHA-3 Cryptographic Hash Standard . Hentet 21. januar 2016. Arkiveret fra originalen 17. august 2015. (ubestemt)
↑ 1 2 NIST-manuskriptpublikationssøgning . Hentet 21. januar 2016. Arkiveret fra originalen 12. august 2015. (ubestemt)
↑ 1 2 Shu-jen Chang, Ray Perlner, William E. Burr, Meltem Sonmez Turan, John M. Kelsey. Tredje runde rapport af SHA-3 Cryptographic Hash Algorithm Competition . - doi : 10.6028/nist.ir.7896 .
↑ 1 2 Keccak Team . keccak.team. Dato for adgang: 15. december 2017. Arkiveret fra originalen 16. december 2017.
↑ SHA-3-projekt - Hash-funktioner | CSRC . csrc.nist.gov. Hentet 7. november 2017. Arkiveret fra originalen 20. november 2017. (ubestemt)
↑ NIST udvælger vinder af Secure Hash Algorithm (SHA-3) konkurrence . NIST (2. oktober 2012). Hentet 2. oktober 2012. Arkiveret fra originalen 30. april 2017. (ubestemt)
↑ 1 2 Guido Bertoni, Joan Daemen, Michaël Peeters, Gilles Van Assche. Vejen fra Panama til Keccak via RadioGatún // Symmetrisk kryptografi / Helena Handschuh, Stefan Lucks, Bart Preneel, Phillip Rogaway. - Dagstuhl, Tyskland: Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, Tyskland, 2009. Arkiveret fra originalen den 22. december 2017.
↑ Keccak Team . keccak.team. Hentet 12. november 2017. Arkiveret fra originalen 13. november 2017.
↑ Keccak Team . keccak.team. Hentet 12. november 2017. Arkiveret fra originalen 13. november 2017.
↑ 1 2 3 4 5 6 Morris J. Dworkin. SHA-3 Standard: Permutationsbaseret Hash og Udvidbare Output-funktioner . - doi : 10.6028/nist.fips.202 .
↑ Vil Keccak = SHA-3? (1. oktober 2013). Dato for adgang: 20. december 2013. Arkiveret fra originalen 30. januar 2014. (ubestemt)
↑ Hvad pokker sker der med NIST's kryptografiske standard, SHA-3? (engelsk) (24. september 2013). Arkiveret fra originalen den 25. januar 2014. Hentet 20. december 2013.
↑ Ja, det er Keccak! (4. oktober 2013). Hentet 20. december 2013. Arkiveret fra originalen 8. december 2013. (ubestemt) - svarerklæring fra forfatterne af Keccak
↑ Keccak svampefunktionsfamilien (17. januar 2011). Hentet 30. september 2015. Arkiveret fra originalen 12. september 2015. (ubestemt) — ændring i udfyldningsalgoritmen i 3. runde af konkurrencen
↑ SHA-3-afledte funktioner: cSHAKE, KMAC, TupleHash og ParallelHash . Hentet 31. oktober 2017. Arkiveret fra originalen 31. oktober 2017. (ubestemt)

Links

NIST udvælger vinder af Secure Hash Algorithm (SHA-3)-konkurrence Arkiveret 5. oktober 2012 på Wayback Machine / NIST, oktober 2012
Keccak svampefunktionsfamilien Arkiveret 12. oktober 2016 på Wayback Machine / Noekeon hjemmeside, 2015-10-15 - Officiel side for Keccak hash- funktionen
Keccak Hash-funktion og svampekonstruktion som en universel kryptoprimitiv Arkiveret 23. juni 2013 på Wayback Machine , pgpru.com , 2010-2013
SHA-3 Standard: Permutationsbaseret Hash og Udvidbare Output-funktioner | NIST Arkiveret 17. september 2017 på Wayback Machine

Implementeringer:

Softwareressourcer . _ https://keccak.team/ . Keccak-holdet. Dato for adgang: 6. december 2017. Arkiveret fra originalen 7. december 2017.
Java-implementering , Pitaya

Hash funktioner
generelle formål	Adler-32 CRC Fletcher kontrolsum FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hash Tree jenkins hash hash sum
Kryptografisk	Stribog GOST R 34,11-94 Bælte BLAKE bmw CubeHash EKKO edonkey2k FSB Fuge 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 Hud Snefru Tiger Whirlpool
Nøglegenereringsfunktioner	bcrypt PBKDF2 krypt Argon 2 Lyra2
Tjek nummer ( sammenligning )	Tjek sum Verhouffs algoritme Månen algoritme Damm algoritme Stregkode bankkonti bankkort ER I SNILS OKPO TIN OKATO ISBN OGRN og OGRNIP VIN
Hashes	Sammenligning af checknumre Autentificeringsprotokoller Stregkode sammenligning Kryptografi Magnet link Merkle signatur ed2k URNE