SHA-3

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 3 januari 2016; kontroller kräver 57 redigeringar .

SHA-3, Keccak
Utvecklare	Guido Bertoni, Joan Dymen , Mikael Pieters, Gilles Van Asche
Skapad	2008
publiceras	2008
Företrädare	SHA-2
Hash storlek	224, 256, 384, 512 (variabel, 0<d≤2 64 -1)
Antal omgångar	24 (standard)
Sorts	hash-funktion

SHA-3 ( Keccak - uttalas "kechak") är en hashalgoritm med variabel längd utvecklad av en grupp författare ledda av Joan Dymen , medförfattare till Rijndael , författare till MMB , SHARK , Noekeon , SQUARE och BaseKing chiffer . Den 2 oktober 2012 blev Keccak vinnaren av den kryptografiska algoritmtävlingen som hölls av US National Institute of Standards and Technology [1] . Den 5 augusti 2015 godkändes algoritmen och publicerades som en FIPS 202 [2] [3] standard . I programimplementering hävdar författarna 12,5 cykler per byte när de körs på en PC med en Intel Core 2-processor . Men i hårdvaruimplementeringar visade sig Keccak vara mycket snabbare än alla andra finalister. [fyra]

SHA-3-algoritmen är byggd på principen om en kryptografisk svamp (denna struktur av kryptografiska algoritmer föreslogs tidigare av författarna till Keccak-algoritmen) [5] .

Historik

Under 2004-2005 attackerades flera hashalgoritmer, inklusive allvarliga attacker som publicerades mot National Institute of Standards and Technology (NIST) SHA-1-algoritmen . Som svar höll NIST öppna workshops och utlyste den 2 november 2007 en tävling för att utveckla en ny hashalgoritm. Den 2 oktober 2012 blev Keccak-algoritmen vinnaren av tävlingen och standardiserades som den nya SHA-3-algoritmen [6] . Den 5 augusti 2015 godkändes algoritmen och publicerades som en FIPS 202 [2] [3] standard .

Algoritmen utvecklades av Guido Bertoni , Joan Dymen , Gilles Van Asche från STMicroelectronics och Mikael Pieters från NXP [7] .

Algoritmen är baserad på de tidigare Panama och RadioGatún [8] hashfunktionerna . Panama utvecklades av Dimen och Craig Clapp 1998, RadioGatún implementerades baserat på Panama av Dimen, Peters och Van Asche 2006 [8] .

Under tävlingen fick de tävlande göra ändringar i sin algoritm för att rätta till problem som upptäcktes. Ändringar gjorda i Keccak-algoritmen [9] [10] :

Antalet omgångar har utökats från 12+ till 12+2 $l$ $l$
Vaddering har ändrats från en komplex form till en enklare, som beskrivs nedan
Hastigheten r har höjts till säkerhetsgränsen (tidigare avrundat till närmaste potens av 2)

Algoritm

SHA-3- familjens hashfunktioner är baserade på konstruktionen av en kryptografisk svamp [5] , där data först "absorberas" i svampen, där det ursprungliga meddelandet utsätts för flerrunda permutationer , sedan resultatet "pressas ut" ur svampen. I "soak"-fasen summeras meddelandeblocken modulo 2 med en delmängd av tillståndet, varefter hela tillståndet transformeras med hjälp av permutationsfunktionen . Under "push"-steget läses utgångsblocken från samma delmängd av tillståndet modifierat av permutationsfunktionen . Storleken på den del av tillståndet som skrivs och läses kallas "hastighet" ( eng. rate ) och betecknas med , och storleken på den del som är orörd av inmatning/utgång kallas "kapacitet" ( eng. kapacitet ) och betecknas med . $M$ $f$ $Z$ $f$ $f$ $r$ $c$

Algoritmen för att erhålla hashfunktionsvärdet kan delas upp i flera steg [11] :

Det ursprungliga meddelandet är vadderat till en längdsträng som är en multipel av , med hjälp av utfyllnadsfunktionen (pad-funktion); $M$ $P$ $r$
Strängen är uppdelad i längdblock : ; $P$ $n$ $r$ ${\displaystyle P_{0},P_{1},...,P_{n-1))$
Soak: Varje block är vadderat med nollor till en bitlängdssträng och summeras modulo 2 till statussträngen , där är bitlängdssträngen ( = + ). Innan funktionen startar är alla element lika med noll. För varje nästa block är tillståndet den sträng som erhålls genom att applicera permutationsfunktionen på resultatet av föregående steg; $Pi}$ $b$ $S$ $S$ $b$ $b$ $r$ $c$ $S$ $f$
"Push-up": medan längden är mindre än ( - antalet bitar i resultatet av hashfunktionen), läggs de första bitarna av tillståndet till k, efter varje tillägg till k tillämpas permutationsfunktionen . Sedan trunkerad till bitlängd ; $Z$ $d$ $d$ $Z$ $r$ $S$ $S$ $f$ $Z$ $d$
En bitlängdssträng returneras som resultat. $Z$ $d$

På grund av det faktum att tillståndet innehåller ytterligare bitar, är algoritmen resistent mot meddelandeförlängningsattacken , som SHA-1- och SHA-2- algoritmerna är mottagliga för . $c$

I SHA-3 är ett tillstånd en matris med 5 × 5 ord med längd = 64 bitar, för totalt 5 × 5 × 64 = 1600 bitar. Även i Keccak kan längder lika med mindre potenser av 2 (från = 1 till = 32) användas. $S$ $w$ $w$ $w$ $w$

Tillägg

För att det ursprungliga meddelandet M ska delas upp i block med längden r krävs utfyllnad . SHA-3 använder mönstret pad10*1 [11] : en 1 läggs till meddelandet, följt av 0 eller fler nollbitar (upp till r-1 ), och en 1 i slutet.

r-1 nollbitar kan läggas till när det sista meddelandeblocket är r-1 bitar långt. Detta block är vadderat med en, nästa block kommer att bestå av r-1 nollor och en.

Två 1-bitar läggs också till om längden på det ursprungliga meddelandet M är delbart med r [11] . I detta fall läggs ett block till meddelandet, som börjar och slutar med ettor, mellan vilka det finns r-2 nollbitar. Detta är nödvändigt så att för ett meddelande som slutar med en sekvens av bitar som i utfyllnadsfunktionen, och för ett meddelande utan dessa bitar, är hash-värdena olika.

Den första 1 biten är nödvändig så att resultaten av hashfunktionen från meddelanden som skiljer sig åt med flera nollbitar i slutet är olika [11] .

Permutationsfunktionen

Permutationsfunktionen som används i SHA-3 inkluderar exklusiv OR (XOR) , bitvis AND (AND) och bitvis negation (NOT) . Funktionen definieras för strängar med längd-potens 2 . I den huvudsakliga implementeringen av SHA-3 ( ). ${\displaystyle w=2^{l))$ $w=64$ $l=6$

Tillståndet kan representeras som en tredimensionell matris med storleken 5 × 5 × . Då är matriselementet statusradbiten . $S$ $A$ $w$ $A[i][j][k]$ $(5i+j)\ gånger w+k$ $S$

Funktionen innehåller flera steg: , , , , , som utförs i flera omgångar [11] . Vid varje steg betecknar vi ingångsmatrisen A, utmatrisen A'. $\theta$ $\rho$ $\pi$ $\chi$ $\iota$

Steg $\theta$

För alla och , sådan att , , vi sätter $i$ $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}}]$

För alla , så att , , , $(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]$

Steg $\rho$

För alla , så att $k$ $0\leqslant k<w$ $A'[0,0,k]=A[0,0,k]$

Låt i början . För 0 till 23: $(i,j)=(1,0)$ $t$

För alla , så att $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)))$

Steg $\pi$

För alla , så att , , $(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]$

Steg $\chi$

För alla , så att , , $(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])$

Steg $\iota$

Vi introducerar en extra funktion , där ingången är ett heltal och utgången är en bit. $rc(t)$ $t$

Algoritm

rc(t)

Om , returneras 1 $t{\bmod {2}}55=0$
Låta $R=[10000000]$
För i från 1 till t mod 255:
1. R = 0 || R
2. $R[0]=R[0]\oplus R[8]$
3. $R[4]=R[4]\oplus R[8]$
4. $R[5]=R[5]\oplus R[8]$
5. $R[6]=R[6]\oplus R[8]$
6. $R=Trunc_{8}[R]$
Returnerar $R[0]$ $.$

Algoritm

\iota (A,i_{r})

$i_{r}$ - runt nummer.

För alla , så att , , $(i,j,k)$ $0\leqslant i<5$ $0\leqslant j<5$ $0\leqslant k<w$ $A'[i,j,k]=A[i,j,k]$
Låta vara en längdmatris fylld med nollor. $RC$ $w$
För 0 till : $i$ $l$ $RC[2^{i}-1]=rc(i+7i_{r})$
För alla , så att $k$ $0\leqslant k<w$ $A'[0,0,k]=A'[0,0,k]\oplus RC[k]$

Permutationsalgoritm

Översättning av en sträng till en array $S$ $A$
För från till $i_{r}$ ${\displaystyle 12+2l-n_{r))$ $12+2l-1$ $A'=\iota (\chi (\pi (\rho (\theta (A)))),i_{r})$
Konvertera en array till en längdsträng $A'$ $S'$ $b$

Hashing meddelanden av godtycklig längd

Grunden för algoritmens komprimeringsfunktion är funktionen f, som utför blandningen av algoritmens interna tillstånd. Tillståndet (låt oss beteckna det A) representeras som en 5×5 array , vars element är 64-bitars ord initierade med noll bitar (det vill säga storleken på tillståndet är 1600 bitar). Funktionen f utför 24 omgångar, i var och en av vilka följande åtgärder utförs:

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

Var:

B är en temporär uppsättning liknande tillståndsuppsättningen till strukturen; C och D är temporära arrayer som innehåller fem 64-bitars ord vardera; r är en matris som definierar mängden cyklisk skiftning för varje tillståndsord; ~x är det bitvisa komplementet av x ; och operationer på arrayindex utförs modulo 5.

Förutom ovanstående operationer, i varje omgång, lägger XOR-operationen också en rundkonstant på ordet A[0, 0].

Innan komprimeringsfunktionen exekveras, överlagras operationen av XORing av fragment av det ursprungliga meddelandet med fragmenten av initialtillståndet. Resultatet bearbetas av f- funktionen . Detta överlägg, tillsammans med komprimeringsfunktionen som utförs för varje block av indata, utgör den "absorberande" fasen av den kryptografiska svampen.

Det är värt att notera att f -funktionen endast använder operationer som är resistenta mot sidokanaldataläckageattacker.

Det resulterande hashvärdet beräknas under klämfasen av den kryptografiska svampen, som också är baserad på f- funktionen som beskrivs ovan . Möjliga hashstorlekar är 224, 256, 384 och 512 bitar.

Inställningar

Den ursprungliga Keccak-algoritmen har många justerbara parametrar [11] för att ge den optimala balansen mellan kryptografisk styrka och hastighet för en specifik tillämpning av algoritmen på en specifik plattform. Justerbara värden är: storleken på datablocket, storleken på algoritmtillståndet, antalet rundor i f() -funktionen och andra.

Under National Institute of Standards and Technology hashingtävling hade deltagarna rätt att justera sina algoritmer för att lösa problem. Så några ändringar gjordes i Keccak: antalet omgångar ökades från 18 till 24 för att öka säkerhetsmarginalen.

Författarna till Keccak har etablerat ett antal priser för prestationer i kryptoanalysen av denna algoritm.

Den version av algoritmen som antogs som den slutliga SHA-3-standarden har några mindre skillnader från Keccaks ursprungliga bidrag till tävlingen. I synnerhet var vissa parametrar begränsade (långsamma lägen c=768 och c=1024 togs bort), inklusive för att öka prestandan [12] [13] [14] [15] . Standarden introducerade också "funktioner med utökat resultat" (XOF, Extendable Output Functions) SHAKE128 och SHAKE256, för vilka det blev nödvändigt att komplettera det hashade meddelandet med ett " suffix " på 2 eller 4 bitar, beroende på typ av funktion .

Fungera	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 )

Ytterligare funktioner

I december 2016 publicerade US National Institute of Standards and Technology ett nytt dokument, NIST SP.800-185 [16] , som beskriver ytterligare funktioner baserade på SHA-3:

Fungera	Beskrivning
cSHAKE128( X , L , N , S )	Parameteriserad version av SHAKE
cSHAKE256( X , L , N , S )	Parameteriserad version av SHAKE
KMAC128( K , X , L , S )	Imitationsinlägg baserat på Keccak
KMAC256( K , X , L , S )
KMACXOF128( K , X , L , S )
KMACXOF256( K , X , L , S )
TupleHash128( X , L , S )	Hashing en tupel av strängar
TupleHash256( X , L , S )
TupleHashXOF128( X , L , S )
TupleHashXOF256( X , L , S )
ParallelHash128( X , B , L , S )	Parallelliserbar hashfunktion baserad på Keccak
ParallelHash256( X , B , L , S )
ParallelHashXOF128( X , B , L , S )
ParallelHashXOF256( X , B , L , S )

Testa vektorer

Värden av olika hashvarianter från en tom sträng.

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

En liten förändring i meddelandet resulterar i en stor förändring av hashvärdet på grund av lavineffekten , som visas i följande exempel:

SHA3-224(" Den kvicka bruna räven hoppar över den lata hunden ") d15dadceaa4d5d7bb3b48f446421d542e08ad8887305e28d58335795 SHA3-224("Den kvicka bruna räven hoppar över den lata hunden . ") 2d0708903833afabdd232a20201176e8b58c5be8a6fe74265ac54db0 SHA3-256("Den kvicka bruna räven hoppar över den lata hunden") 69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04 SHA3-256("Den kvicka bruna räven hoppar över den lata hunden . ") a80f839cd4f83f6c3dafc87feae470045e4eb0d366397d5c6ce34ba1739f734d SHA3-384("Den kvicka bruna räven hoppar över den lata hunden") 7063465e08a93bce31cd89d2e3ca8f602498696e253592ed26f07bf7e703cf328581e1471a7ba7ab119b1a9ebdf8be41 SHA3-384("Den kvicka bruna räven hoppar över den lata hunden . ") 1a34d81695b622df178bc74df7124fe12fac0f64ba5250b78b99c1273d4b080168e10652894ecad5f1f4d5b965437fb9 SHA3-512("Den kvicka bruna räven hoppar över den lata hunden") 01dedd5de4ef14642445ba5f5b97c15e47b9ad931326e4b0727cd94cefc44fff23f07bf543139939b49128caf436dc1bdee594fc40408b2000f4000fb2000000000000000000000001 SHA3-512("Den kvicka bruna räven hoppar över den lata hunden . ") 18f4f4bd419603f95538837003d9d254c26c23765565162247483f65c50303597bc9ce4d289f21d1c2f1f458828e230506d38ba046b18e35046b18e3506b18e35046b18e35046b18e35046b18e35046b18e35046b18e30546b18e30506b18e3054b1b SHAKE128("Den kvicka bruna räven hoppar över den lata hunden", 256) f4202e3c5852f9182a0430fd8144f0a74b95e7417ecae17db0f8cfeed0e3e66e SHAKE128("Den kvicka bruna räven hoppar över den lata do f ", 256) 853f4538be0db9621a6cea659a06c1107b1f83f02b13d18297bd39d7411cf10c

Kryptanalys

Resultaten av kryptoanalys under tävlingen [4] .

Mål	Attack typ	Utgång	Alternativ	CF-samtal	Minne
hash-funktion	kollision	160	r = {240, 640, 1440}, c=160 1, 2 omgångar
hash-funktion	Att hitta prototypen	80	r = {240, 640, 1440}, c=160 1, 2 omgångar
Permutationer	attack-diskriminator	Allt	24 omgångar	$2^{1579}$
Permutationer	differentiell egendom	Allt	8 omgångar	$2^{491.47}$
hash-funktion	attack-diskriminator	224, 256	4 omgångar	$2^{25}$
hash-funktion	kollision	224, 256	2 omgångar	$2^{{33}}$
hash-funktion	Hittar den andra prototypen	224, 256	2 omgångar	$2^{{33}}$	$2^{29}$
hash-funktion	Hittar den andra prototypen	512	6 omgångar	$2^{506}$	$2^{176}$
hash-funktion	Hittar den andra prototypen	512	7 omgångar	$2^{507}$	$2^{320}$
hash-funktion	Hittar den andra prototypen	512	8 omgångar	$2^{511.5}$	$2^{508}$
hash-funktion	kollision	224, 256	4 omgångar

Anteckningar

↑ NIST utser vinnare av tävlingen Secure Hash Algorithm (SHA-3) . Hämtad 3 oktober 2012. Arkiverad från originalet 5 oktober 2012. (obestämd)
↑ 1 2 NIST släpper SHA-3 Cryptographic Hash Standard . Hämtad 21 januari 2016. Arkiverad från originalet 17 augusti 2015. (obestämd)
↑ 1 2 NIST-manuskriptpublikationssökning . Hämtad 21 januari 2016. Arkiverad från originalet 12 augusti 2015. (obestämd)
↑ 1 2 Shu-jen Chang, Ray Perlner, William E. Burr, Meltem Sonmez Turan, John M. Kelsey. Tredje omgångens rapport av SHA-3 Cryptographic Hash Algorithm Competition . - doi : 10.6028/nist.ir.7896 .
↑ 1 2 Keccak Team . keccak.team. Datum för åtkomst: 15 december 2017. Arkiverad från originalet 16 december 2017.
↑ SHA-3-projekt - Hashfunktioner | CSRC . csrc.nist.gov. Hämtad 7 november 2017. Arkiverad från originalet 20 november 2017. (obestämd)
↑ NIST utser vinnare av tävlingen Secure Hash Algorithm (SHA-3) . NIST (2 oktober 2012). Hämtad 2 oktober 2012. Arkiverad från originalet 30 april 2017. (obestämd)
↑ 1 2 Guido Bertoni, Joan Daemen, Michaël Peeters, Gilles Van Assche. Vägen från Panama till Keccak via RadioGatún // Symmetric Cryptography / Helena Handschuh, Stefan Lucks, Bart Preneel, Phillip Rogaway. - Dagstuhl, Tyskland: Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, Tyskland, 2009. Arkiverad från originalet den 22 december 2017.
↑ Keccak Team . keccak.team. Hämtad 12 november 2017. Arkiverad från originalet 13 november 2017.
↑ Keccak Team . keccak.team. Hämtad 12 november 2017. Arkiverad från originalet 13 november 2017.
↑ 1 2 3 4 5 6 Morris J. Dworkin. SHA-3-standard: Permutationsbaserade hash- och förlängningsbara utdatafunktioner . - doi : 10.6028/nist.fips.202 .
↑ Kommer Keccak = SHA-3? (1 oktober 2013). Datum för åtkomst: 20 december 2013. Arkiverad från originalet 30 januari 2014. (obestämd)
↑ Vad i helvete händer med NIST:s kryptografiska standard, SHA-3? (engelska) (24 september 2013). Arkiverad från originalet den 25 januari 2014. Hämtad 20 december 2013.
↑ Ja, det här är Keccak! (4 oktober 2013). Hämtad 20 december 2013. Arkiverad från originalet 8 december 2013. (obestämd) - svar uttalande från författarna till Keccak
↑ Keccak svampfunktionsfamiljen (17 januari 2011). Hämtad 30 september 2015. Arkiverad från originalet 12 september 2015. (obestämd) — Ändring av fyllningsalgoritmen i den tredje omgången av tävlingen
↑ SHA-3 härledda funktioner: cSHAKE, KMAC, TupleHash och ParallelHash . Hämtad 31 oktober 2017. Arkiverad från originalet 31 oktober 2017. (obestämd)

Länkar

NIST utser vinnare av Secure Hash Algorithm (SHA-3)-tävlingen Arkiverad 5 oktober 2012 på Wayback Machine / NIST, oktober 2012
Keccak-svampfunktionsfamiljen Arkiverad 12 oktober 2016 på Wayback Machine / Noekeon-webbplatsen, 2015-10-15 - Officiell sida för Keccak- hashfunktionen
Keccak Hash Function and Sponge Construction som en universell kryptoprimitiv Arkiverad 23 juni 2013 på Wayback Machine , pgpru.com , 2010-2013
SHA-3-standard: Permutationsbaserad hash- och förlängningsbar utgångsfunktion | NIST Arkiverad 17 september 2017 på Wayback Machine

Implementeringar:

Programvaruresurser . _ https://keccak.team/ . Keccak-laget. Datum för åtkomst: 6 december 2017. Arkiverad från originalet 7 december 2017.
Java-implementering , Pitaya

Hash-funktioner
generell mening	Adler-32 CRC Fletcher kontrollsumma FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH - Hashträd jenkins hash hash summa
Kryptografisk	Stribog GOST R 34,11-94 Bälte BLAKE bmw CubeHash EKO edonkey2k FSB Fuga Grostl HAVAL Hamsi J H 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 Bubbelpool
Nyckelgenereringsfunktioner	bcrypt PBKDF2 kryptera Argon 2 Lyra2
Kontrollnummer ( jämförelse )	Kontrollera summan Verhouffs algoritm Månen algoritm Jävla algoritm Streckkod bankkonton bankkort ÄR I SNILS OKPO TENN OKATO ISBN OGRN och OGRNIP VIN
Hashes	Jämförelse av checknummer Autentiseringsprotokoll Streckkodsjämförelse Kryptografi Magnet länk Merkle signatur ed2k URNA