JH

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2017. augusztus 27-én felülvizsgált verziótól ; az ellenőrzések 14 szerkesztést igényelnek .

JH
Fejlesztők	Wu Hongjun
közzétett	2011. január 16
Hash méret	224, 256, 384, 512
A körök száma	42

A JH négy kriptográfiai hash függvény családja : JH-224 , JH-256 , JH-384 és JH-512 .

Ezeknek a hash-függvényeknek az algoritmusai csak egy belső paraméter értékében különböznek - a kimeneti érték hosszában (bitekben) (amely a névben a kötőjel után látható). A cikk későbbi részében, az algoritmus ismertetésekor, a kényelem kedvéért ezt a paramétert a bemeneti adatok részének tekintem, a JH-ról mint egy algoritmusról vagy egy hash függvényről beszélek. $l_{hash}$

A JH hash függvény egyike az öt legjobb döntősnek az SHA-3 második fordulójában . A verseny során javították. Ez a cikk a pillanatnyi legfrissebb verzióval foglalkozik, amelyet JH42 -nek is nevezhetünk (mivel a fő változás az volt, hogy a tömörítési függvényben a körök száma 42 lett). A dokumentáció megjelenési dátuma 2011. január 16.

Kivonatoláskor a bemeneti üzenetet kiegészítik és részekre osztják, amelyeket az úgynevezett tömörítési függvény szekvenciálisan feldolgoz. Ezt a függvényt a specifikáció általánosan leírja - vagyis egy d változó paraméterrel, melynek megváltoztatásával JH-szerű hash függvényeket tervezhet (minél kriptoellenállóbb, annál nagyobb d). JH-ban kezdetben d=8.

Az SHA verseny döntősének kiválasztásánál nem a kriptográfiai jellemzők (minden funkcióra kiválóak), hanem a szoftveres és hardveres implementáció rugalmassága és optimalitása a döntő szerep. A hardveres implementáció témájában számos tanulmány létezik, például [1] .

Algoritmus [2]

Pontosítások

A bitvektorok elemeinek elnevezéséről

Feltételezzük , hogy az itt tárgyalt összes bitvektornak van eleje és vége , és az elején ( bal oldalon ) található bit az első , 0 pozíciójú és a legjelentősebbnek tekinthető , illetve a end ( jobb oldalon ) az utolsó , a legnagyobb számú pozícióval rendelkezik , eggyel kevesebb, mint a vektor biteinek száma, és a legkevésbé szignifikánsnak tekinthető .

Ugyanez a pozíciószám kivételével a bitvektorokból álló vektorokra vonatkozik, például egy blokkokból álló üzenetre vagy egy nibble-ből álló blokkra. A több bitből álló bitvektor bármely komponensének pozíciószáma a kényelem kedvéért zavart okoz. Tehát egy blokkban lévő nibble-ek pozíciószáma nullától, az üzenet blokkjainak pozíciószáma pedig egytől kezdődik ...

Példa

vektorban

8afd4h

az első , legjelentősebb rágcsálás a bal oldalon található - ez a 8; az utolsó , legkisebb jelentőségű rágcsálás a jobb oldalon a 4.

Ha ezt a bejegyzést bitvektornak tekintjük, és nem nibble vektornak, akkor ez egyenértékű ezzel:

1000_1010_1111_1101_0100,

itt az első ( 0-s számmal , balra , magas ) bit 1, az utolsó ( 19-es számmal , jobbra , alacsonyra ) 0.

Összefűzési jelölés

Hagyja, hogy a vektor egymást követő vektorokból álljon, akkor ezt a tényt a következőképpen jelöljük: $A$ $A_1, A_2, \pontok, A_N$ $A=A_1||A_2|| \dots ||A_N$

A használt függvények általánosított esetek

Itt ismertetjük azokat a függvényeket, amelyek segítségével a paraméter megváltoztatásával JH-szerű algoritmusokat lehet felépíteni $d$

S-box - S i(x)

Ez egy olyan függvény, amely átalakítja az s-boxot (azaz a bemeneti és kimeneti értékeinek mérete megegyezik és 4 bittel egyenlő). Az algoritmus 2 ilyen függvényt használ: és . Értéktáblázatuk a következő: $S_{1}$ $S_{0}$

$x$	0	egy	2	3	négy	5	6	7	nyolc	9	a	b	c	d	e	f
$S_{0}(x)$	9	0	négy	b	d	c	3	f	egy	a	2	6	7	5	nyolc	e
$S_{1}(x)$	3	c	6	d	5	7	egy	9	f	2	0	négy	b	a	e	nyolc

Sejtpárok lineáris transzformációja - L(A,B)

Ez a funkció egy pár s-boxot alakít át (azaz a bemeneti és kimeneti értékeinek mérete megegyezik és 8 bittel egyenlő). Ez a legtömörebb jelöléssel rendelkezik a polinomok véges mezői tekintetében.

Tekintsük a polinomok véges mezőjét legfeljebb 3 fok felett. Izomorf a mezővel ; hozzunk létre egy szabványt az ilyen esetekre a polinomok mezője és a számmező közötti megfelelést: a polinom egy olyan számnak felel meg, amely megegyezik a polinom értékével . Ehhez a polinommezőhöz válasszuk a következő primitív polinomot : $GF(2)$ $GF(2^{4})$ $x=2$

$x^{4}+x+1$ .

Ekkor, ha olyan függvénynek tekintünk, amely 2 polinomot, valamint számokat és betűket - polinomoknak transzformál, akkor $LABOR)$

$L(A,B)=((5\bullet A+2\bullet B),(2\bullet A+B))$ ,

ahol " " és " " a szorzás és az összeadás műveletei egy adott polinommezőben. $\golyó$ $+$

Shuffle - P d

A függvény három egyszerűbb keverés összetétele, amelyek bitvektorok tömbjét alakítják át (azaz a bemeneti és kimeneti értékük mérete megegyezik a bitekkel, ahol a bitek száma ennek a tömbnek egy elemében ): $P_d$ ${\2. megjelenítési stílus^{d))$ $2^{d}\times k$ $k$

$P_{d}(A)=\phi _{d}(P'_{d}(\pi _{d}(A)))$

Bemutatjuk ezeknek a keveréseknek az algoritmusait, jelölve a bemeneti és kimeneti vektorokat, illetve ( ahol és a bitvektorok azonos méretűek minden esetén): $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$ $B=B_{0}||B_{1}||\dots ||B_{2^{d}-1}$ $A_{i}$ $Kettős}$ $én$

$B=\pi _{d}(A)$ :

for~i=0~~to~2^{d-2}-1~~begin

B_{4i+0}=A_{4i+0}

B_{4i+1}=A_{4i+1}

B_{4i+2}=A_{4i+3}

B_{4i+3}=A_{4i+2}

end

$B=P'_{d}(A)$ :

for~i=0~~to~2^{d-1}-1~~begin

{\displaystyle B_{i}=A_{2i))

B_{i+2^{d-1}}=A_{2i+1}

end

$B=\phi _{d}(A)$ :

for~i=0~~to~2^{d-2}-1~~begin

{\displaystyle B_{2i}=A_{2i))

B_{2i+1}=A_{2i+1}

B_{2^{d-1}+2i}=A_{2^{d-1}+2i+1}

{\displaystyle B_{2^{d-1}+2i+1}=A_{2^{d-1}+2i))

end

Round-Transform - R d (A,C)

A bemenet egy -dimenziós vektor . A kimenet egy dimenziós vektor. Egy bitkonstans is bekerül a bemenetbe . $2^{d+2}$ $A$ $2^{d+2}$ ${\2. megjelenítési stílus^{d))$ $C$

A vektort nibble -ek tömbjeként ábrázoljuk : . $A$ ${\2. megjelenítési stílus^{d))$ $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$

Ezután minden nibble konvertálódik vagy az értéktől függően (ha , akkor , egyébként - ) $A_{i}$ $S_{0}$ $S_{1}$ $C_{i}$ $C_{i}=0$ $S_{0}$ $S_{1}$

Továbbá minden egyes űrlappáron lineáris transzformációt hajtunk végre . $(S_{C_{2i}}(A_{2i}),S_{C_{2i+1}}(A_{2i+1}))$ $L(S_{C_{2i}}(A_{2i}),S_{C_{2i+1}}(A_{2i+1}))$

És a végén az eredményeket ismét egy vektorba csoportosítják, amelynek bitjeit megkeveri . $P_d$

Ezt képlet formájában fejezzük ki:

${\displaystyle R_{d}(A,C)=P_{d}{\bigg (}L{\Big (}S_{C_{0))(A_{0}),S_{C_{1))( A_{1}){\Big )}||L{\Big (}S_{C_{2}}(A_{2}),S_{C_{3}}(A_{3}){\Big )} ||\pontok ||L{\Big (}S_{C_{2^{d}-2}}(A_{2^{d}-2}),S_{C_{2^{d}-1} }(A_{2^{d}-1}){\Big )}{\bigg )))$

Átalakítás E d

A bemeneten egy dimenziós vektor található . Először jön a kezdeti csoportosítás: $2^{d+2}$ $A$

$B=G_{d}(A)$ :

for~i=0~~to~2^{d-1}-1~~begin

B_{8i+0}=A_{i+128\times 0}

B_{8i+1}=A_{i+128\times 2}

{\displaystyle B_{8i+2}=A_{i+128\times 4))

B_{8i+3}=A_{i+128\times 6}

B_{8i+4}=A_{i+128\times 1}

B_{8i+5}=A_{i+128\times 3}

B_{8i+6}=A_{i+128\times 5}

{\displaystyle B_{8i+7}=A_{i+128\times 7))

end

Ezután ennek a csoportosításnak az eredménye a kör-transzformációk alkalmazása körről körre változó állandókkal. A változó kezdőértékét a szám egész részeként adjuk meg , azaz. $B$ $6\szer(d-1)$ $R_{d}(B,C)$ $C$ $({\sqrt {2}}-1)\times 2^{2^{d}}$

$C=\left\lfloor ({\sqrt {2}}-1)\times 2^{2^{d}}\right\rfloor$ :

for~i=1~~to~6\times (d-1)~~begin

C=R_{d-2}(C,0)

B=R_{d}(B,C)

end

Ezután megtörténik a végső csoportbontás, a kezdetinek a fordítottja :

$B_{fin}=G_{d}^{-1}(B)$ ,

Ahol $G_{d}^{-1}:G_{d}(G_{d}^{-1}(B))\equiv B$

Pszeudokódként:

$B_{fin}=G_{d}^{-1}(B)$ :

for~i=0~~to~2^{d-1}-1~~begin

B_{fin~i+128\times 0}=B_{8i+0}

B_{fin~i+128\times 2}=B_{8i+1}

B_{fin~i+128\times 4}=B_{8i+2}

B_{fin~i+128\times 6}=B_{8i+3}

B_{fin~i+128\times 1}=B_{8i+4}

B_{fin~i+128\times 3}=B_{8i+5}

B_{fin~i+128\times 5}=B_{8i+6}

B_{fin~i+128\times 7}=B_{8i+7}

end

Ily módon

$E_{d}(A)=G^{-1}(R_{d}(R_{d}(R_{d}(\dots (R_{d}(G_{d}(A)),)), C_{1})\pontok ),C_{6(d-1)-1}),C_{6(d-1)}))$

$C_{i}=R_{d-2}(C_{i-1},0),~i=1\dots 6(d-1),~C_{0}=\left\lfloor ({ \sqrt {2}}-1)\times 2^{2^{d}}\right\rfloor$

Az F d (H,M) konvolúciós függvény

A bemenet egy -bit vektor és -bit vektor . Először ennek a vektornak az első felének bitenkénti összeadásával transzformáljuk -val , majd az eredményt transzformáljuk , végül az eredményt a második felének bitenkénti hozzáadásával transzformáljuk a vektorral . $2^{d+2}$ $H$ $2^{d+1}$ $M$ $H$ $M$ $E_d$ $M$

Írjuk fel képletek formájában. Legyen a vektor első (legmagasabb) fele , és legyen a második. Legyen a függvények is , és adjuk vissza a bal és jobb felét , ill. Akkor ${\displaystyle H_{balra))$ $H$ $H_{right}$ $E_{d-left}(A)$ $E_{d-right}(A)$ $E_{d}(A)$

$F_d(H,M)=E_{d-bal}\Big((H_{bal}\oplus M)||H_{jobb}\Big)||\bigg(E_{d-jobb}\Big((H_) {bal}\oplus M)||H_{jobbra}\Big)\oplus M\bigg)$

Felhasznált függvények - adaptáció a hardveres megvalósításhoz d=8-nál

A konkrét megvalósítás nagymértékben függ olyan paraméterektől, mint pl

Kívánt teljesítmény
Kívánt méret
Kívánatos technológia
Kívánt energiafogyasztás
A kívánt zajvédelem
Kívánt érték

Ezért ezen paraméterek beállítása nélkül az adaptáció nem lehetséges. Leírom az átalakítást a hardvertervezésben megszokott bitenkénti műveletek felhasználásával, valamint néhány konstanssal, amelyek jól jöhetnek, ha nincs jelentős korlátozás az áramkör méretét illetően. $L$

L konvertálásának kifejezése egyszerű műveletekkel biteken

Akkor hagyd $L(A,B)=C_{0}||C_{1}||C_{2}||C_{3}||D_{0}||D_{1}||D_{2} ||D_{3},$

$D_0 = B_0 \oplus A_1 ;$

$D_1 = B_1 \oplus A_2 ;$

$D_2 = B_2 \oplus A_3 \oplus A_0 ;$

$D_3 = B_3\oplus A_0 ;$

$C_0 = A_0 \oplus D_1 ;$

$C_1 = A_1 \oplus D_2 ;$

$C_2 = A_2 \oplus D_3 \oplus D_0 ;$

$C_3 = A_3\oplus D_0 .$

ahol " " az XOR művelet. $\oplus$

Legyen a bemeneti és kimeneti vektorok lin_trans_in[0:7], lin_trans_out[0:7]illetve, akkor

verilog kód hozzárendelni lin_trans_out [ 4 : 7 ] = lin_trans_in [ 4 : 7 ] ^ { lin_trans_in [ 1 : 3 ], lin_trans_in [ 0 ] } ^ { 2 'b0 , lin_trans_in [ 0 ], 1 'b0 }, lin_trans_out [ ] 0_trans_out 3 = lin_transz_in [ 0 : 3 ] ^ { lin_transz_out [ 1 : 3 ], lin_transz_out [ 0 ]} ^ { 2 'b0 , lin_trans_out [ 0 ], 1 'b0 }; H 0 konstansok különböző l hashekhez

Nálunk ugyanis rendre: $l_{hash}=~512, ~384, ~256, ~224$

verilog kód assign hash_0_512 [ 0 : 1023 ] = 1024'h6fd14b963e00aa17636a2e057a15d5438a225e8d0c97ef0be9341259f2b3c361891da0c1536f801e2aa9056bea2b6d80588eccdb2075baa6a90f3a76baf83bf70169e60541e34a6946b58a8e2e6fe65a1047a7d0c1843c243b6e71b12d5ac199cf57f6ec9db1f856a706887c5716b156e3c2fcdfe68517fb545a4678cc8cdd4b , hash_0_384 [ 0 : 1023 ] = 1024'h481e3bc6d813398a6d3b5e894ade879b63faea68d480ad2e3324cb21480f826798aec84d9082b928d45dea304111424936f555b2924847ecc72d0a93baf43ce1569b7f8a27db454c9ef4bd496397af0e589fc27d26aa80cd80c88b8c9deb2eda8a7981e8f8d5373af43967adddd17a71a9b4d3bda475d39497643fba9842737f , hash_0_256 [ 0 : 1023 ] = 1024'heb98a3412c20d3eb92cdbe7b9cb245c11c93519160d4c7fa260082d67e508a03a4239e267726b945e0fb1a48d41a9477cdb5ab26026b177a56f024420fff2fa871a396897f2e4d751d144908f77de262277695f776248f9487d5b6574780296c5c5e272dac8e0d6c518450c657057a0f7be4d367702412ea89e3ab13d31cd769 , hash_0_224 [ 0 : 1023 ] = 1024'h2dfedd62f99a98acae7cacd619d634e7a4831005bc301216b86038c6c966149466d9899f2580706fce9ea31b 1d9b1adc11e8325f7b366e10f994857f02fa06c11b4f1b5cd8c840b397f6a17f6e738099dcdf93a5adeaa3d3a431e8dec9539a6822b4a98aec86a1e4d574ac959ce56cf015960deab5ab2bbf9611dcf0dd64ea6e ; Konstansok C körök R 8

$C_{i}=R_{6}(C_{i-1},0),~i=1\pontok 42,~C_{0}=\left\lfloor ({\sqrt {2))- 1)\times 2^{256}\right\rfloor$

Ábrázoljuk őket tömbként, $C_{i+1}=$ round_const[i][0:255]

verilog kód assign round_const [ 0 ][ 0 : 255 ] = 256'h6a09e667f3bcc908b2fb1366ea957d3e3adec17512775099da2f590b0667322a , round_const [ 1 ][ 0 : 255 ] = 256'hbb896bf05955abcd5281828d66e7d99ac4203494f89bf12817deb43288712231 , round_const [ 2 ][ 0 : 255 ] = 256'h1836e76b12d79c55118a1139d2417df52a2021225ff6350063d88e5f1f91631c , round_const [ 3 ][ 0 : 255 ] = 256'h263085a7000fa9c3317c6ca8ab65f7a7713cf4201060ce886af855a90d6a4eed , round_const [ 4 ][ 0 : 255 ] = 256'h1cebafd51a156aeb62a11fb3be2e14f60b7e48de85814270fd62e97614d7b441 , round_const [ 5 ][ 0 : 255 ] = 256'he5564cb574f7e09c75e2e244929e9549279ab224a28e445d57185e7d7a09fdc1 , round_const [ 6 ][ 0 : 255 ] = 256'h5820f0f0d764cff3a5552a5e41a82b9eff6ee0aa615773bb07e8603424c3cf8a , round_const [ 7 ][ 0 : 255 ] = 256'hb126fb741733c5bfcef6f43a62e8e5706a26656028aa897ec1ea4616ce8fd510 , round_const [ 8 ][ 0 : 255 ] = 256'hdbf0de32bca77254bb4f562581a3bc991cf94f225652c27f14eae958ae6aa616 , round_const [ 9 ][ 0 : 255 ] = 256'he6113be617f45f3de53cff03919a94 c32c927b093ac8f23b47f7189aadb9bc67 , round_const [ 10 ][ 0 : 255 ] = 256'h80d0d26052ca45d593ab5fb3102506390083afb5ffe107dacfcba7dbe601a12b , round_const [ 11 ][ 0 : 255 ] = 256'h43af1c76126714dfa950c368787c81ae3beecf956c85c962086ae16e40ebb0b4 , round_const [ 12 ][ 0 : 255 ] = 256'h9aee8994d2d74a5cdb7b1ef294eed5c1520724dd8ed58c92d3f0e174b0c32045 , round_const [ 13 ][ 0 : 255 ] = 256'h0b2aa58ceb3bdb9e1eef66b376e0c565d5d8fe7bacb8da866f859ac521f3d571 , round_const [ 14 ][ 0 : 255 ] = 256'h7a1523ef3d970a3a9b0b4d610e02749d37b8d57c1885fe4206a7f338e8356866 , round_const [ 15 ][ 0 : 255 ] = 256'h2c2db8f7876685f2cd9a2e0ddb64c9d5bf13905371fc39e0fa86e1477234a297 , round_const [ 16 ][ 0 : 255 ] = 256'h9df085eb2544ebf62b50686a71e6e828dfed9dbe0b106c9452ceddff3d138990 , round_const [ 17 ][ 0 : 255 ] = 256'he6e5c42cb2d460c9d6e4791a1681bb2e222e54558eb78d5244e217d1bfcf5058 , round_const [ 18 ][ 0 : 255 ] = 256'h8f1f57e44e126210f00763ff57da208a5093b8ff7947534a4c260a17642f72b2 , round_const [ 19 ][ 0 : 255 ] = 256'hae4ef4792ea148608cf116cb2bff66e8fc74811266cd641112cd17801ed38b59 , round_const [ 20 ][ 0 : 255 ] = 256'h91a744efbf68b192d0549b608bdb3191fc12a0e83543cec5f882250b244f78e4 , round_const [ 21 ][ 0 : 255 ] = 256'h4b5d27d3368f9c17d4b2a2b216c7e74e7714d2cc03e1e44588cd9936de74357c , round_const [ 22 ][ 0 : 255 ] = 256'h0ea17cafb8286131bda9e3757b3610aa3f77a6d0575053fc926eea7e237df289 , round_const [ 23 ][ 0 : 255 ] = 256'h848af9f57eb1a616e2c342c8cea528b8a95a5d16d9d87be9bb3784d0c351c32b , round_const [ 24 ][ 0 : 255 ] = 256'hc0435cc3654fb85dd9335ba91ac3dbde1f85d567d7ad16f9de6e009bca3f95b5 , round_const [ 25 ][ 0 : 255 ] = 256'h927547fe5e5e45e2fe99f1651ea1cbf097dc3a3d40ddd21cee260543c288ec6b , round_const [ 26 ][ 0 : 255 ] = 256'hc117a3770d3a34469d50dfa7db020300d306a365374fa828c8b780ee1b9d7a34 , round_const [ 27 ][ 0 : 255 ] = 256'h8ff2178ae2dbe5e872fac789a34bc228debf54a882743caad14f3a550fdbe68f , round_const [ 28 ][ 0 : 255 ] = 256'habd06c52ed58ff091205d0f627574c8cbc1fe7cf79210f5a2286f6 e23a27efa0 , round_const [ 29 ][ 0 : 255 ] = 256'h631f4acb8d3ca4253e301849f157571d3211b6c1045347befb7c77df3c6ca7bd , round_const [ 30 ][ 0 : 255 ] = 256'hae88f2342c23344590be2014fab4f179fd4bf7c90db14fa4018fcce689d2127b , round_const [ 31 ][ 0 : 255 ] = 256'h93b89385546d71379fe41c39bc602e8b7c8b2f78ee914d1f0af0d437a189a8a4 , round_const [ 32 ][ 0 : 255 ] = 256'h1d1e036abeef3f44848cd76ef6baa889fcec56cd7967eb909a464bfc23c72435 , round_const [ 33 ][ 0 : 255 ] = 256'ha8e4ede4c5fe5e88d4fb192e0a0821e935ba145bbfc59c2508282755a5df53a5 , round_const [ 34 ][ 0 : 255 ] = 256'h8e4e37a3b970f079ae9d22a499a714c875760273f74a9398995d32c05027d810 , round_const [ 35 ][ 0 : 255 ] = 256'h61cfa42792f93b9fde36eb163e978709fafa7616ec3c7dad0135806c3d91a21b , round_const [ 36 ][ 0 : 255 ] = 256'hf037c5d91623288b7d0302c1b941b72676a943b372659dcd7d6ef408a11b40c0 , round_const [ 37 ][ 0 : 255 ] = 256'h2a306354ca3ea90b0e97eaebcea0a6d7c6522399e885c613de824922c892c490 , round_const [ 38 ][ 0 : 255 ] = 256'h3ca6cdd788a5bd c5ef2dceeb16bca31e0a0d2c7e9921b6f71d33e25dd2f3cf53 , round_const [ 39 ][ 0 : 255 ] = 256'hf72578721db56bf8f49538b0ae6ea470c2fb1339dd26333f135f7def45376ec0 , round_const [ 40 ][ 0 : 255 ] = 256'he449a03eab359e34095f8b4b55cd7ac7c0ec6510f2c4cc79fa6b1fee6b18c59e , round_const [ 41 ][ 0 : 255 ] = 256'h73bd6978c59f2b219449b36770fb313fbe2da28f6b04275f071a1b193dde2072 ; Rágcsálási pozíciók keverés után P 8

Legyen a bemenet egy 1024 bites vektor — egy 256 4 bites vektorból álló tömb: , a kimenet pedig , akkor . Ez azt jelenti, hogy a kimeneti vektor első nibble-je egyenlő lesz a konstans első bájtjában található (0-tól 255-ig terjedő) bemeneti vektor nibble-jével, a kimeneti vektor második nibble-je pedig egyenlő lesz a nibble-vel. a második bájtban található pozíciószámú bemeneti vektor , stb. $P_8$ $A=A_1||A_2||\dots||A_{256}$ $B=B_1||B_2||\dots||B_{256}$ $B_{i}=A_{permut\_pose[i*8-1-:8]}$ $B$ $A$ permut_pose[0:2047]permut_pose[0:2047]

verilog kód assign permut_pose [ 0 : 2047 ] = 2048'h00030407080b0c0f10131417181b1c1f20232427282b2c2f30333437383b3c3f40434447484b4c4f50535457585b5c5f60636467686b6c6f70737477787b7c7f80838487888b8c8f90939497989b9c9fa0a3a4a7a8abacafb0b3b4b7b8bbbcbfc0c3c4c7c8cbcccfd0d3d4d7d8dbdcdfe0e3e4e7e8ebeceff0f3f4f7f8fbfcff020106050a090e0d121116151a191e1d222126252a292e2d323136353a393e3d424146454a494e4d525156555a595e5d626166656a696e6d727176757a797e7d828186858a898e8d929196959a999e9da2a1a6a5aaa9aeadb2b1b6b5bab9bebdc2c1c6c5cac9cecdd2d1d6d5dad9dedde2e1e6e5eae9eeedf2f1f6f5faf9fefd ;

Felhasznált függvények - adaptáció a szoftver implementációjához d=8-nál

Ennek az adaptációnak az a lényege, hogy a lehető leghosszabb operandusú műveletek használatával minimalizáljuk a műveletek számát. Az olyan technológiák, mint például a SIMD , SSE2 , AVX lehetővé teszik ezt .

megvalósítási példák C-ben

A függvények működésének magyarázatához, valamint a kerek konstansok megjelenítéséhez a C kód darabjait adjuk meg [3] . Egy fájlba egyesítve és az main()alábbi függvénnyel kiegészítve lefordítják [4] ; az eredményül kapott program a függvényt valósítja meg . $E_8$

nyilatkozatok továbbítása C-ben #include <emmintrin.h> #include <stdlib.h> #include <stdio.h> typedef __m128i word128 ; /*word128 egy 128 bites SSE2 szót*/ /*adatigazítás meghatározása a különböző C-fordítókhoz*/ #if meghatározva(__GNUC__) #define DATA_ALIGN16(x) x __attribute__ ((aligned(16))) #else #define DATA_ALIGN16(x) __declspec(align(16)) x #endif /*Az alábbiak a 128 bites szó(k)on határozzák meg a műveleteket*/ #define CONSTANT(b) _mm_set1_epi8((b)) /*egy 128 bites regiszter minden bájtjának beállítása "b"-re*/ #define XOR(x,y) _mm_xor_si128((x),(y)) /*XOR(x,y) = x ^ y, ahol x és y két 128 bites szó*/ #define AND(x,y) _mm_and_si128((x),(y)) /*AND(x,y) = x & y, ahol x és y két 128 bites szó*/ #define ANDNOT(x,y) _mm_andnot_si128((x),(y)) /*ANDNOT(x,y) = (!x) & y, ahol x és y két 128 bites szó*/ #define VAGY(x,y) _mm_vagy_si128((x),(y)) /*VAGY(x,y) = x | y, ahol x és y két 128 bites szó*/ #define SHR1(x) _mm_srli_epi16((x), 1) /*SHR1(x) = x >> 1, ahol x egy 128 bites szó*/ #define SHR2(x) _mm_srli_epi16((x), 2) /*SHR2(x) = x >> 2, ahol x egy 128 bites szó*/ #define SHR4(x) _mm_srli_epi16((x), 4) /*SHR4(x) = x >> 4, ahol x egy 128 bites szó*/ #define SHR8(x) _mm_slli_epi16((x), 8) /*SHR8(x) = x >> 8, ahol x egy 128 bites szó*/ #define SHR16(x) _mm_slli_epi32((x), 16) /*SHR16(x) = x >> 16, ahol x egy 128 bites szó*/ #define SHR32(x) _mm_slli_epi64((x), 32) /*SHR32(x) = x >> 32, ahol x egy 128 bites szó*/ #define SHR64(x) _mm_slli_si128((x), 8) /*SHR64(x) = x >> 64, ahol x egy 128 bites szó*/ #define SHL1(x) _mm_slli_epi16((x), 1) /*SHL1(x) = x << 1, ahol x egy 128 bites szó*/ #define SHL2(x) _mm_slli_epi16((x), 2) /*SHL2(x) = x << 2, ahol x egy 128 bites szó*/ #define SHL4(x) _mm_slli_epi16((x), 4) /*SHL4(x) = x << 4, ahol x egy 128 bites szó*/ #define SHL8(x) _mm_srli_epi16((x), 8) /*SHL8(x) = x << 8, ahol x egy 128 bites szó*/ #define SHL16(x) _mm_srli_epi32((x), 16) /*SHL16(x) = x << 16, ahol x egy 128 bites szó*/ #define SHL32(x) _mm_srli_epi64((x), 32) /*SHL32(x) = x << 32, ahol x egy 128 bites szó*/ #define SHL64(x) _mm_srli_si128((x), 8) /*SHL64(x) = x << 64, ahol x egy 128 bites szó*/ main() függvény példa int main () { int j ; érvénytelen * e8_out ; //itt tetszőleges konstans lehet használni az E8 check char e8_in [ 128 ] = { 0 , 0xe0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 _ _ , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 _ _ , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 _ _ , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 _ _ , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 }; e8_out = ( void * ) calloc ( 9 , sizeof ( szó128 )); //16 bájtos igazítás - fontos! e8_out = ( void * )((( int ) e8_out ) + 16 - ((( int ) e8_out ) & 15 )); for ( j = 0 ; j < 128 ; j ++ ) * (( char * ) e8_out + j ) = e8_in [ j ]; printf ( " \n bemenet \n " ); for ( j = 0 ; j < 128 ; j ++ ) printf ( "%.2x" ,( char )( * (( char * ) e8_out + j )) & 0xff ); E8 (( szó128 * ) e8_out ); //out must be equal //2dfedd62f99a98acae7cacd619d634e7a4831005bc301216b86038c6c966149466d9899f2580706fce9ea31b1d9b1adc11e8325f7b366e10f994857f02fa06c11b4f1b5cd8c840b397f6a17f6e738099dcdf93a5adeaa3d3a431e8dec9539a6822b4a98aec86a1e4d574ac959ce56cf015960deab5ab2bbf9611dcf0dd64ea6e printf ( " \n output \n " ); for ( j = 0 ; j < 128 ; j ++ ) printf ( "%.2x" ,( char )( * (( char * ) e8_out + j )) & 0xff ); visszatérés ( 0 ); } SBox funkció

Négy 128 bites vektort konvertál egy 128 bites állandótól függően. Azaz

$(x_{0},x_{1},x_{2},x_{3})=SBox(x_{00},x_{10},x_{20},x_{30},c)$

Az algoritmus ez. Vezessünk be egy másik 128 bites t változót, és inicializáljuk a változókat kezdeti értékekkel

$(x_{0},x_{1},x_{2},x_{3})=(x_{00},x_{10},x_{20},x_{30})$ ,

akkor a feladatok sorrendje a következő:

${\displaystyle x_{3}=\neg x_{3))$
$x_0 = x_0 \oplus (c~\&~(\neg x_2))$
$t~~ = c~ \oplus (x_0 ~\&~x_1)$
$x_0 = x_0 \oplus (x_2 ~\&~x_3)$
$x_3 = x_3 \oplus ((\neg x_1)~\&~x_2)$
$x_1 = x_1 \oplus (x_0 ~\&~x_2)$
$x_2 = x_2 \oplus (x_0 ~\&~(\neg x_3))$
$x_0 = x_0 \oplus (x_1|x_3)$
$x_3 = x_3 \oplus (x_1 ~\&~x_2)$
$x_1 = x_1 \oplus (t~\&~x_0)$
$x_2 = x_2 \oplus t$

lehetséges megvalósítás C-ben /*Az Sbox az S0-t és az S1-et valósítja meg, állandó bittel kiválasztva*/ #define S_BOX(m0,m1,m2,m3,cnst) { \ szó128 t; \ m3 = XOR(m3,CONSTANT(0xff)); \ m0 = XOR(m0,ÉS NEM(m2,cnst)); \ t = XOR(cnst,ÉS(m0,m1)); \ m0 = XOR(m0,ÉS(m3,m2)); \ m3 = XOR(m3,ÉS NEM(m1,m2)); \ m1 = XOR(m1,ÉS(m0,m2)); \ m2 = XOR(m2,ÉS NEM(m3,m0)); \ m0 = XOR(m0,OR(m1,m3)); \ m3 = XOR(m3,ÉS(m1,m2)); \ m2 = XOR(m2,t); \ m1 = XOR(m1,ÉS(t,m0)); \ }

- lásd a "deklarációk továbbítása C-ben" blokkban használt makrók leírását

LinTrans függvény

Nyolc 128 bites változót alakít át. Akkor hagyd $(b_{0},b_{1},b_{2},b_{3},b_{4},b_{5},b_{6},b_{7})=LinTrans(a_{0 },a_{1},a_{2},a_{3},a_{4},a_{5},a_{6},a_{7})$

$b_4 = a_4 \oplus a_1$

$b_5 = a_5 \oplus a_2$

$b_6 = a_6 \oplus a_3 \oplus a_0$

$b_7 = a_7 \oplus a_0$

$b_0 = a_0 \oplus b_5$

$b_1 = a_1\oplus b_6$

$b_2 = a_2 \oplus b_7 \oplus b_4$

$b_3 = a_3\oplus b_4$

lehetséges megvalósítás C-ben /*Az MDS kód*/ #define LIN_TRANS(szó) \ szó[1] = XOR(szó[1],szó[2]); \ szó[3] = XOR(szó[3],szó[4]); \ szó[5] = XOR(XOR(szó[5],szó[6]),szó[0]); \ szó[7] = XOR(szó[7],szó[0]); \ szó[0] = XOR(szó[0],szó[3]); \ szó[2] = XOR(szó[2],szó[5]); \ szó[4] = XOR(XOR(szó[4],szó[7]),szó[1]); \ szó[6] = XOR(szó[6],szó[1]);

A kódban a további használat kényelme érdekében megfelel ${\displaystyle a_{0},a_{1},a_{2},a_{3},a_{4},a_{5},a_{6},a_{7))$ (word[0],word[2],word[4],word[6],word[1],word[3],word[5],word[7])

- lásd a "deklarációk továbbítása C-ben" blokkban használt makrók leírását

Permutációs függvény

Egy 128 bites változót konvertál egy egész állandótól függően . Ez a funkció nem 128 bites változók használatára van optimalizálva, de szükséges az ebben a szakaszban szereplő többi funkcióhoz. $n:~6\geq n\geq 0$

Hadd hol . A számok megszerzésének algoritmusa a következő: $b=Permutáció(a,n)$ ${\displaystyle b=b_{0}||b_{1}||\dots ||b_{127},a=a_{0}||a_{1}||\dots ||a_{127))$ $b$

$b=a$ :

for~i=0~~to~{\frac {128}{2\times 2^{n))}-1~~begin

Csere \Big((b_{2\times 2^n\times i+0}||b_{2\times 2^n\times i+1}||\dots||b_{2\times 2^n\ i+2^n-1}),~(b_{2\szer 2^n\szer i+2^n+0}||b_{2\szer 2^n\szor i+2^n+1 }||\dots||b_{2\times 2^n\times i+2^n+2^n-1})\Big)

end

Itt a bejegyzés az algoritmus egy olyan szakaszát jelenti, amely után a változó azt az értéket veszi fel, amivel a változó rendelkezett , a változó pedig azt az értéket, amivel a változó rendelkezett . $Swap(p,q)$ $p$ $q$ $q$ $p$

lehetséges megvalósítás C-ben /*Az alábbiak a 128 bites szó(k)on határozzák meg a műveleteket*/ #define SWAP0(x) VAGY(SHR1(AND((x),CONSTANT(0xaa))),SHL1(AND((x),CONSTANT(0x55)))) /*a 2i bit felcserélése a 2i+1 bittel 128 bites x */ #define SWAP1(x) VAGY(SHR2(AND((x),CONSTANT(0xcc))),SHL2(AND((x),CONSTANT(0x33)))) /*a 4i bit felcserélése||4i+1 bittel 4i+2||4i+3 a 128 bites x-ből */ #define SWAP2(x) VAGY(SHR4(AND((x),CONSTANT(0xf0))),SHL4(AND((x),CONSTANT(0xf)))) /*bitek felcserélése 8i||8i+1|| 8i+2||8i+3 8i+4||8i+5||8i+6||8i+7 bittel a 128 bites x-ből */ #define SWAP3(x) VAGY(SHR8(x),SHL8(x)) /*16i||16i+1||...||16i+7 bitek 16i+8||16i+9|| ...||16i+15 a 128 bites x-ből */ #define SWAP4(x) VAGY(SHR16(x),SHL16(x)) /*bitek cseréje 32i||32i+1||...||32i+15 bitekkel 32i+16||32i+17|| ...||32i+31 a 128 bites x-ből */ #define SWAP5(x) _mm_shuffle_epi32((x),_MM_SHUFFLE(2,3,0,1)) /*a bitek cseréje 64i||64i+1||...||64i+31 bitekkel 64i+32|| 64i+33||...||64i+63 a 128 bites x*/ közül #define SWAP6(x) _mm_shuffle_epi32((x),_MM_SHUFFLE(1,0,3,2)) /*bitek cseréje 128i||128i+1||...||128i+63 bitekkel 128i+64|| 128i+65||...||128i+127/128 bites x*/ #define STORE(x,p) _mm_store_si128((__m128i *)(p), (x)) /*a 128 bites x szó tárolása a p memóriacímben, ahol p a 16 bájt többszöröse*/ #define LOAD(p) _mm_load_si128((__m128i *)(p)) /*16 bájt betöltése a p memóriacímből, visszaad egy 128 bites szót, ahol p a 16 bájt többszöröse*/ #define PERMUTUÁCIÓ(szó,n) \ szó[1] = CSATLAKOZTATÁS##n(szó[1]); szó[3] = SWAP##n(szó[3]); szó[5] = SWAP##n(szó[5]); szó[7] = SWAP##n(szó[7]);

- lásd a "deklarációk továbbítása C-ben" blokkban használt makrók leírását

Az E 8 funkció szoftveres megvalósításhoz adaptálva

1024 bites vektort alakít át. Egybeesik az általánosított esetben leírt függvénnyel (abban az értelemben, hogy ha az argumentumok értékei egyeznek, akkor a függvények értékei egybeesnek). Legyen a bemenet egy 1024 bites vektor. Képzeljük el 8 128 bites változó halmazaként: . A következő átalakítások után ezek lesznek a kimeneti vektorok: $E_8$ $(x_{0},x_{1},x_{2},x_{3},x_{4},x_{5},x_{6},x_{7})$

for~r=0~~to~41~~begin

(x_{0},x_{2},x_{4},x_{6})=SBox(x_{0},x_{2},x_{4},x_{6},C_{r }^{akár})

(x_{1},x_{3},x_{5},x_{7})=SBox(x_{1},x_{3},x_{5},x_{7},C_{r }^{páratlan})

(x_{0},x_{2},x_{4},x6_{,}x_{1},x_{3},x_{5},x_{7})=LinTrans(x_{0} ,x_{2},x_{4},x_{6},x_{1},x_{3},x_{5},x_{7})

x_{1}=Permutáció(x_{1},r{\bmod {7)))

x_{3}=Permutáció(x_{3},r{\bmod {7)))

x_{5}=Permutáció(x_{5},r{\bmod {7)))

x_{7}=Permutáció(x_{7},r{\bmod {7)))

end

A használt 128 bites állandók a következők: $C_{r}^{odd}=C_{r}^{1}||C_{r}^{3}||\dots ||C_{r}^{255},~C_{r} ^{even}=C_{r}^{0}||C_{r}^{2}||\dots ||C_{r}^{254},~C_{r}=R_{6}(C_ {r-1},0),~r=1\pontok 42,~C_{0}=\left\lfloor ({\sqrt {2}}-1)\times 2^{256}\right\rfloor$

lehetséges megvalósítás C-ben /*42 körkonstans, minden körállandó 32 bájtos (256 bites)*/ DATA_ALIGN16 ( const unsigned char E8_bitslice_roundconstant [ 42 ][ 32 ]) = { { 0x72 , 0xd5 , 0xde , 0xa2 , 0xdf , 0x15 , 0xf8 , 0x67 , 0x7b , 0x84 , 0x15 , 0xa , 0xb7 , 0x23 , 0x15 , 0x57 , 0x81 , 0xab , 0xd6, 0x90, 0x4d, 0x5a, 0x87, 0xf6, 0xf6 . _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ { 0xea , 0x98 , 0x3a , 0xe0 , 0x5c , 0x45 , 0xfa , 0x9c , 0xc5 , 0xd2 , 0x99 , 0x66 , 0xb2 , 0x99 , 0x9a , 0x66 , 0x2 , 0x96 , 0xb4 , 0xf2 , 0xbb, 0xbb, 0x66, 0x8a, 0xb4, 0xf2, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb , 0xbb , 0xbb , 0xbb , 0xbb , 0xbb . , 0x56 , 0x14 , 0x1a , 0x88 , 0xdb , 0xa2 , 0x31 }, { 0x3 , 0xa3 , 0x5a , 0x5c , 0x9a , 0x19 , 0xe , 0xdb , 0x40 , 0x3f , 0xb2 , 0xa , 0x87 , 0xc1 , 0x44 , 0x10 , 0x1c , 0x5 , 0x19 , 0x80 , 0x84 , 0x9e , 0x1c, 0x5, 0x19, 0x80, 0x84, 0x9e, 0x1c, 0x5, 0x19, 0x80, 0x84, 0x9e, 0x1c , 0x5, 0x19, 0x80, 0x84, 0x9e, 0x9. , 0x1d , 0x1d , 0x1 , 0x33 , 0xeb , 0xad , 0x5e , 0xe7 , 0xcd , 0xdc }, { 0x10 , 0xba , 0x13 , 0x92 , 0x2 , 0xbf , 0x6b , 0x41 , 0xdc , 0x78 , 0x65 , 0x15 , 0xf7 , 0xBB , 0x27 , 0xd0 , 0xa , 0x2c , 0x81 , 0x39 , 0x37 , 0xa , 0xa _ _ _ _ , 0x1a , 0xbf , 0xd2 , 0x41 , 0x0 , 0x91 , 0xd3 }, { 0x42 , 0x2d , 0x5a , 0xd , 0xf6 , 0xCC , 0x7e , 0x90 , 0xd , 0x62 , 0x9f , 0x9c , 0x92 , 0xc0 , 0x97 , 0xcce , 0x18 , 0x5c , 0xa7 , 0xb , 0xc7 , 0x2b , 0x4444444444444444 . _ _ _ , 0xdf , 0x65 , 0xd6 , 0x63 , 0xc6 , 0xfc , 0x23 }, { 0x97 , 0x6e , 0x6c , 0x3 , 0x9e0 , 0xb8 , 0x1a , 0x21 , 0x5 , 0x45 , 0x7e , 0x44 , 0x6c , 0xeca , 0xa8 , 0xee , 0xf1 , 0x3 , 0xbb , 0x5d , 0x8e , 0x61 , 0xfa , 0xfdd . _ , 0x96 , 0x97 , 0xb2 , 0x94 , 0x83 , 0x81 , 0x97 }, { 0x4a , 0x8e , 0x85 , 0x37 , 0xdb , 0x3 , 0x30 , 0x2f , 0x2a , 0x67 , 0x8d , 0x2d , 0xfb , 0x9f, 0x6a , 0x95 , 0x8a , 0x73 , 0x73 , 0x81 , 0xf8 , 0x95 , 0x6a , 0x73 , 0x8c. , 0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x , 0x , 0x , 0xc7 , 0x72 , 0x46 , 0xc0 , 0x7f , 0x42 , 0x14 }, { 0xc5 , 0xf4 , 0x15 , 0x8f , 0xbd , 0xc7 , 0x5e , 0xc4 , 0x75 , 0x44 , 0x6f , 0xa7 , 0x8f , 0x11 , 0xBB , 0x80 , 0x52 , 0xde , 0x75 , 0xb7 , 0xae , 0xe4e4 , 0x88888888 . _ _ _ , 0xb8 , 0x0 , 0x1e , 0x98 , 0xa6 , 0xa3 , 0xf4 }, { 0x8e , 0xf4 , 0x8f , 0x33 , 0xa9 , 0xa3 , 0x63 , 0x15 , 0xa , 0x5f , 0x56 , 0x24 , 0xd5 , 0xb7 , 0xf9 , 0x89, 0xb6, 0xf1, 0xd, 0x20 , 0x7c, 0x5a, 0xd , 0xd, 0xd, 0x20, 0x7c, 0x5a, 0xe0, 0xd , 0xd, 0x20, 0x7c, 0x5a, 0xe0 , 0xd, 0xd, 0x20, 0xd , 0xd , 0xd, 0xd , 0xd , 0xd , 0xd, 0xd, 0xd. , 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd , 0xfd , 0xfd , 0xca , 0xe9 , 0x5a , 0x6 , 0x42 , 0x2c , 0x36 }, { 0xce , 0x29 , 0x35 , 0x43 , 0x4e , 0xfe , 0x98 , 0x3d , 0x53 , 0x3a , 0xf9 , 0x74 , 0x73 , 0x9a , 0x4b , 0xa7 , 0xd0 , 0xf5 , 0x1f , 0x59 , 0x6f , 0x4e , 0x81 , 0x86 , 0xe , 0xe 0xe, 0xe 0xe , 0xe , 0x9d , 0xad , 0x81 , 0xaf , 0xd8 , 0x5a , 0x9f }, { 0xa7 , 0x5 , 0x6 , 0x67 , 0xe , 0x34 , 0x62 , 0x6a , 0x8b , 0xb , 0x28 , 0xbe , 0x6e , 0xb9 , 0x17 , 0x27 , 0x47 , 0x74 , 0x26 , 0xc6 , 0x80 , 0x10 , 0x10 , 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 , 0x10 . , 0xa0 , 0x7e , 0x6f , 0xc6 , 0x7e , 0x48 , 0x7b }, { 0xd , 0x55 , 0xa , 0xa5 , 0x4a , 0xf8 , 0xa4 , 0xc0 , 0x91 , 0xe3 , 0xe7 , 0x9f , 0x97, 0x8e , 0xf1 , 0x9e, 0x86 , 0x76, 0x72, 0x81 , 0x60, 0x9e, 0x76 , 0x76, 0x72, 0x81, 0x60 , 0x8d , 0xd4, 0x76, 0x72, 0x81, 0x60 , 0x8d, 0xd4 , 0x76, 0x72 , 0x81, 0x60 , 0x8d , 0xd4 , 0x76 , 0x72 , 0x81 , 0x60 , 0x8d , 0xd4d4d4d4 . . , 0x9e , 0x5a , 0x41 , 0xf3 , 0xe5 , 0xb0 , 0x62 }, { 0xfc , 0x9f , 0x1f , 0xec , 0x40 , 0x54 , 0x20 , 0x7a , 0xe3 , 0xe4 , 0x1a , 0x0 , 0xce , 0xf4 , 0xc9 , 0x84 , 0x4f , 0xd7 , 0x94, 0xf5 , 0x9d , 0xfa , 0x95 , 0xd8 , 0xd8 , 0xd. , 0x2e , 0x7e , 0x11 , 0x24 , 0xc3 , 0x54 , 0xa5 }, { 0x5b , 0xdf , 0x72 , 0x28 , 0xbd , 0xfe , 0x6e , 0x28 , 0x78 , 0xf5 , 0x7f , 0xe2 , 0xf , 0xa5 , 0xc4 , 0xb2 , 0x5 , 0x89 , 0x7c , 0xEF , 0XEE , 0x49 , 0xd3, 0x2e, 0x2e , 0x2e, 0x2e, 0x2e , 0x2e , 0x , 0x7e , 0x93 , 0x85 , 0xeb , 0x28 , 0x59 , 0x7f }, { 0x70 , 0x5f , 0x69 , 0x37 , 0xb3 , 0x24 , 0x31 , 0x4a , 0x5e , 0x86 , 0x28 , 0xf1 , 0x1d , 0xd6 , 0xe4 , 0x65 , 0xc7 , 0x1b , 0x77 , 0x4 , 0x51 , 0xb9 . _ _ _ _ , 0x, 0x, 0x , 0xfe , 0x43 , 0xe8 , 0x23 , 0xd4 , 0x87 , 0x8a }, { 0x7d , 0x29 , 0xe8 , 0xa3 , 0x92 , 0x76 , 0x94 , 0xf2 , 0xdd , 0xcb , 0x7a , 0x9 , 0x9b , 0xd9 , 0xc1 , 0x1d , 0x1b , 0xfb , 0x5b , 0xdc , 0xda _ _ _ _ _ _ _ _ , 0x24 , 0x49 , 0x4f , 0xf2 , 0x9c , 0x82 , 0xbf }, { 0xa4 , 0xe7 , 0xba , 0x31 , 0xb4 , 0x70 , 0xbf , 0xff , 0xd , 0x32, 0x44, 0x5 , 0xde, 0xf8 , 0xbc , 0x48, 0x3b, 0xae , 0xfc, 0x32, 0x53 , 0xbb, 0xbb, 0xbb, 0xd3 , 0xae, 0xfc , 0x32, 0x53, 0xbb , 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb , 0xbb, 0xbb, 0xd3 , 0xae, 0xfc, 0x32 , 0x53 , 0xbb, 0xbb, 0xd3 , 0xae , 0xfc , 0x32 , 0x53 , 0xbb , 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb , 0xbb , 0xd3 . , 0x , 0x9f , 0xc3 , 0xc1 , 0xe0 , 0x29 , 0x8b , 0xa0 }, { 0xe5 , 0xc9 , 0x5 , 0xfd , 0xf7 , 0xae , 0x9 , 0xf , 0x94 , 0x70 , 0x34 , 0x12 , 0x42 , 0x90 , 0xf1 , 0x34 , 0xa2 , 0x71 , 0xb7 , 0x1 , 0xe3 , 0x44 , 0xed , 0xed , 0xed , 0x. . , 0x3b , 0x8e , 0x36 , 0x4f , 0x2f , 0x98 , 0x4a }, { 0x88 , 0x40 , 0x1d , 0x63 , 0xa0 , 0x6c, 0xf6, 0x15 , 0x47 , 0xc1 , 0x44 , 0x4b , 0x87 , 0x52 , 0xaf , 0x7e , 0xbb , 0x4a , 0xf1 , 0xe2 , 0xaf , 0x7e , 0xbb , 0x4a , 0xf1 , 0xe2 , 0xa , 0xa . , 0x3 , 0x70 , 0xb6 , 0xc5 , 0xcc , 0x6e , 0x8c , 0xe6 }, { 0xa4 , 0xd5 , 0xa4 , 0x56 , 0xbd , 0x4f , 0xca , 0x0 , 0xda , 0x9d , 0x84 , 0x4b , 0xc8 , 0x3e , 0x18 , 0xae , 0x73 , 0x57 , 0xce , 0x45 , 0x30 , 0x64 , 0xd1 , 0xad , 0xe8 , 0xa6 , 0xce , 0x68 , 0x14 , 0x5c , 0x25 , 0x67 }, { 0xa3 , 0xda , 0x8c , 0xf2 , 0xcb , 0xe , 0xe1 , 0x16 , 0x33 , 0xe9 , 0x6 , 0x58 , 0x9a , 0x94, 0x99, 0x9a, 0x1f, 0x60, 0xb2, 0x20 , 0xc2, 0x6f, 0x84 , 0x84, 0x7, 0x7, 0x7, 0x84, 0x84, 0x7, 0x7, 0x7, 0x84, 0x7, 0x7, 0x7, 0x84, 0x7, 0x7, 0x84, 0x84, 0x7, 0x7, 0x84, 0x84, 0x7, 0x84, 0x84, 0x84 , 0x84 , 0x84 , 0x84 , 0x84 , 0x84 , 0x84 , 0x84 , 0x84 , 0x84 . , 0xce , 0xac , 0x7f , 0xa0 , 0xd1 , 0x85 , 0x18 }, { 0x32 , 0x59 , 0x5b , 0xa1 , 0x8d , 0xdd , 0x19 , 0xd3 , 0x50 , 0x9a , 0x1c , 0xc0 , 0xaa , 0xa5 , 0xb4 , 0x46 , 0x9f , 0x3d , 0x63 , 0x67 , 0x67 , 0x4, 0x4 , 0x6b , 0x6b , 0x6b . , 0xca , 0x19 , 0xab , 0xb , 0x56 , 0xee , 0x7e }, { 0x1f , 0xb1 , 0x79 , 0xea , 0xa9 , 0x28 , 0x21 , 0x74 , 0xe9 , 0xbd , 0xf7 , 0x35 , 0x3b , 0x36 , 0x51 , 0xee , 0x1d , 0x57 , 0xac , 0x5a , 0x75 , 0x50 , 0xd3 , 0x76 , 0x3a , 0x , 0x46 , 0xc2 , 0xfe , 0xa3 , 0x7d , 0x70 , 0x1 }, { 0xf7 , 0x35 , 0xc1 , 0xaf , 0x98 , 0xa4 , 0xd8 , 0x42 , 0x78 , 0xed , 0xec , 0x20 , 0x9e , 0x6b , 0x67 , 0x79 , 0x41 , 0x83, 0x63, 0x15, 0xea, 0xa 0xa , 0xa, 0xa, 0xa , 0xa , 0xa , 0xa , 0xa , 0xa8 , 0xa , 0xa , 0xa , 0xa , 0xa , 0xa8 , 0xc3 , 0xa8 , 0xc3 , 0x3b { 0xa7 , 0x40 , 0x3b , 0x1f , 0x1c , 0x27 , 0x47 , 0xf3 , 0x59 , 0x40 , 0xf0 , 0x34 , 0xb7 , 0x2d , 0x76 , 0x9a , 0xe7 , 0x3e , 0x4e , 0x6c , 0xd2 , 0x21 , 0x4f , 0xfd , 0xb8 , 0xfd , 0x8d , 0x39 , 0xdc , 0x57 , 0x59 , 0xef }, { 0x8d , 0x9b , 0xc , 0x49 , 0x2b , 0x49 , 0xeb , 0xda , 0x5b , 0xa2 , 0xd7 , 0x49 , 0x68, 0xf3 , 0x70 , 0xd , 0x7d , 0x3b , 0xae , 0xd0 , 0x7a , 0x8d , 0x55 , 0x84 , 0xf5 , 0xf5 , 0xa5 , 0xe9 , 0xf0 , 0xe4 , 0xf8 , 0x8e , 0x65 }, { 0xa0 , 0xb8 , 0xa2 , 0xf4 , 0x36 , 0x10 , 0x3b , 0x53 , 0xc , 0xa8 , 0x7 , 0x9e , 0x75 , 0x3e , 0xec , 0x5a , 0x91 , 0x68 , 0x94 , 0x92 , 0x56 , 0xe8 , 0x88888888 . _ , 0x , 0xb0 , 0x5c , 0x55 , 0xf8 , 0xba , 0xbc , 0x4c }, { 0xe3 , 0xbb , 0x3b , 0x99 , 0xf3 , 0x87 , 0x94 , 0x7b , 0x75 , 0xda , 0xf4 , 0xd6 , 0x72 , 0x6b, 0x1c, 0x5d, 0x64, 0xae, 0xac, 0x28, 0xdc, 0x34, 0xb3, 0xb3, 0xb3 , 0xb3, 0xb3, 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0x34 , 0xa5 , 0xb8 , 0xb8, 0x28, 0xdb, 0xdb, 0x71}, 0xb8, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0x71}, 0xb8 , 0x28 , 0xdb , 0xdb , 0x71 }, 0xb8, 0x28, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0x71} { 0xf8 , 0x61 , 0xe2 , 0xf2 , 0x10 , 0x8d , 0x51 , 0x2a , 0xe3 , 0xdb , 0x64 , 0x33 , 0x59 , 0xdd , 0x75 , 0xfc, 0x1c, 0xac, 0xbc, 0xf1, 0x43, 0xce, 0x3f, 0xa2, 0xa2 . _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ { 0x33 , 0xa , 0x5b , 0xca , 0x88 , 0x29 , 0xa1 , 0x75 , 0x7f , 0x34 , 0x19 , 0x4d , 0xb4 , 0x16 , 0x53 , 0x5c , 0x92 , 0x3b , 0x94 , 0xc3 , 0xe , 0x79 , 0x4d , 0x1e , 0x79 , 0x74 , 0x75 , 0xd7 , 0xb6 , 0xee , 0xaf , 0x3f }, { 0xea , 0xa8 , 0xd4 , 0xf7 , 0xbe , 0x1a , 0x39 , 0x21 , 0x5c , 0xf4 , 0x7e , 0x9 , 0x4c , 0x23 , 0x27 , 0x51 , 0x26 , 0xa3 , 0x24 , 0x53 , 0xba , 0x32 , 0x3c , 0xd2 , 0xd , 0xa3 , 0x17 , 0x4a , 0x6d , 0xa6 , 0xd5 , 0xad }, { 0xb5 , 0x1d , 0x3e , 0xa6 , 0xaf , 0xf2 , 0xc9 , 0x8 , 0x83 , 0x59 , 0x3d , 0x98 , 0x91 , 0x6b , 0x3c , 0x56, 0x4c, 0xf8 , 0x7c, 0xa1, 0x72 , 0x56, 0x60 , 0x4c, 0x7c, 0xa1, 0x72, 0x86, 0x60 , 0x60, 0x6d , 0x4d , 0xa1 , 0x72 , 0x86 , 0x60 , 0x66d . , 0xe2 , 0x3e , 0xcc , 0x8 , 0x6e , 0xc7 , 0xf6 }, { 0x2f , 0x98 , 0x33 , 0xb3 , 0xb1 , 0xbc , 0x76 , 0x5e , 0x2b , 0xd6 , 0x66 , 0xa5 , 0xef , 0xc4 , 0xe6 , 0x2a , 0x6 , 0xf4 , 0xb6 , 0xe8 , 0xbe , 0xc1 , 0xd4 , 0x36 , 0x74 , 0xee , 0x82 , 0x15 , 0xbc , 0xef , 0x21 , 0x63 }, { 0xfd , 0xc1 , 0x4e , 0xd , 0xf4 , 0x53 , 0xc9 , 0x69 , 0xa7 , 0x7d , 0x5a , 0xc4 , 0x6 , 0x58 , 0x58 , 0x26 , 0x7e , 0xc1 , 0x14 , 0x16 , 0x6 , 0xe0 , 0xfa , 0xfa, 0x16 , 0x7e , 0x7 , 0x90 , 0xaf , 0x3d , 0x28 , 0x63 , 0x9d , 0x3f }, { 0xd2 , 0xc9 , 0xf2 , 0xe3 , 0x0 , 0x9b , 0xd2 , 0xc , 0x5f , 0xaa , 0xce , 0x30 , 0xb7 , 0xd4 , 0xc , 0x30 , 0x74 , 0x2a , 0x51 , 0x16 , 0xf2 , 0xe0 , 0x32 , 0x98 , 0xd , 0xeb , 0x30 , 0xd8 , 0xe3 , 0xce , 0xf8 , 0x9a }, { 0x4b , 0xc5 , 0x9e , 0x7b , 0xb5 , 0xf1 , 0x79 , 0x92 , 0xff , 0x51 , 0xe6 , 0x6e , 0x4 , 0x86 , 0x68 , 0xd3 , 0x9b , 0x23 , 0x4D , 0x57 , 0xe6 , 0x96 , 0x67 , 0x31 , 0xc , 0xe6 , 0xa6 , 0xf3 , 0x17 , 0xa , 0x75 , 0x5 }, { 0xb1 , 0x76 , 0x81 , 0xd9 , 0x13 , 0x32 , 0x6c , 0xce , 0x3c , 0x17 , 0x52 , 0x84 , 0xf8 , 0xa2 , 0x62 , 0xf4 , 0x2b , 0xcb , 0xb3 , 0x78 , 0x47 , 0x15 , 0x47 , 0xffffffffff _ _ , 0x46 , 0x54 , 0x82 , 0x23 , 0x93 , 0x6a , 0x48 }, { 0x38 , 0xdf , 0x58 , 0x7 , 0x4e , 0x5e , 0x65 , 0x65 , 0xf2 , 0xfc , 0x7c , 0x89 , 0xfc , 0x86 , 0x50 , 0x8e , 0x31 , 0x70 , 0x2e , 0x44 , 0xd0 , 0xb , 0xca , 0x86 , 0xf0 , 0x40 , 0x9 , 0xa2 , 0x30 , 0x78 , 0x47 , 0x4e }, { 0x65 , 0xa0 , 0xee , 0x39 , 0xd1 , 0xf7 , 0x38 , 0x83 , 0xf7 , 0x5e , 0xe9 , 0x37 , 0xe4 , 0x2c , 0x3a , 0xbd , 0x21 , 0x97 , 0xb2 , 0x26 , 0x1 , 0x13 , 0x13 , 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13 , 0x13 . , 0x44 , 0xed , 0xd1 , 0xef , 0x9f , 0xde , 0xe7 }, { 0x8b , 0xa0 , 0xdf , 0x15 , 0x76 , 0x25 , 0x92 , 0xd9 , 0x3c , 0x85, 0xf7 , 0xf6 , 0x12 , 0xdc , 0x42 , 0xbe , 0xd8, 0xa7 , 0x7, 0x7c, 0xab, 0x2, 0x27, 0x7, 0x27, 0x7 , 0x7 , 0x7 , 0x7, 0x7 , 0x7 , 0x7, 0x7 , 0x7 , 0x7 , 0x7 , 0x7 , 0x7 , 0x7 , 0x7 , 0x27 . , 0x8d , 0x7d , 0xda , 0xaa , 0x3e , 0xa8 , 0xde }, { 0xaa , 0x25 , 0xce , 0x93 , 0xbd , 0x2 , 0x69 , 0xd8 , 0x5a , 0xf6 , 0x43 , 0xfd , 0x1a , 0x73, 0xf9 , 0xc0 , 0x5f, 0xef, 0xda, 0x17, 0x4a, 0x19, 0xa5, 0xaf, 0xda, 0x17, 0x4a, 0x19, 0xa5, 0xa, 0xda, 0xda , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0x , 0x4d , 0x66 , 0x4d , 0x66 , 0x3x21d , { 0x35 , 0xb4 , 0x98 , 0x31 , 0xdb , 0x41 , 0x15 , 0x70 , 0xea , 0x1e , 0xf , 0xbb , 0xed , 0xcd , 0x54 , 0x9b , 0x9a , 0xd0 , 0x63 , 0xa1 , 0x51 , 0x97 , 0x40 , 0x72 , 0xf6 . , 0x75 , 0x9d , 0xbf , 0x91 , 0x47 , 0x6f , 0xe2 }}; /*az E8 kerek függvénye */ #define ROUND_FUNCTION(szó,n,r)\ S_BOX(((szó)[0]),((szó)[2]),((szó)[4]),((szó)[6]),( LOAD(E8_bitslice_roundconstant[r]))) \ S_BOX(((szó)[1]),((szó)[3]),((szó)[5]),((szó)[7]),(LOAD (E8_bitslice_roundconstant[r]+16))) \ LIN_TRANS(szó) \ PERMUTATION((szó),n) void E8 ( szó128 * szó ){ int i ; for ( i = 0 ; i < 42 ; i = i + 7 ) { ROUND_FUNCTION ( szó , 0 , i ) ROUND_FUNCTION ( szó , 1 , i + 1 ) ROUND_FUNCTION ( szó , 2 , i + 2 ) ROUND_FUNCTION ( szó , 3 , i + 3 ) ROUND_FUNCTION ( szó , 4 , i + 4 ) ROUND_FUNCTION ( szó , 5 , i + 5 ) ROUND_FUNCTION ( szó , 6 , i + 6 ) } }

- lásd a fenti alfejezetekben használt makrók leírását.

Kiinduló adatok

Bemeneti paraméter

$l_{hash}$ — hash hossza (bitek száma a hash függvény kimeneti vektorában).

Csak a következő értékeket veheti fel:

224, 256, 384 és 512;

Emlékezzünk vissza, hogy ez a cikk szigorúan véve egy 4 hash-függvény családját írja le. Üzenet bevitele

Számot jelöl – az üzenet hossza és a bitvektor (ha ). Még akkor is , ha nem okoz nehézséget a számítás . $L$ $M_{0}$ $L\neq 0$ $L=0$ $JH(M_{0})$

Algoritmus a JH(M 0 )

1) A bemeneti vektor komplementere

További bitek csatolása az üzenethez a végén. Ez három szakaszban történik:

M_{0}

1.1) Mértékegység-kiegészítő. Egyetlen bit csatolása az üzenet végéhez. 1.2) Nulla párnázás. Csatolás az üzenet végére, eggyel párnázott, nulla bit a darabszámban.

383+(-L{\bmod {5}}12)

1.3) Kitöltés az üzenet hosszával. Az üzenet végéhez csatolva, eggyel és nullákkal kitömve, 128 bit, amely tartalmazza az eredeti üzenet hosszát (pl. ha , akkor a kiegészítés így fog kinézni: ).

L=2

0\dots 010

Az eredmény egy kiterjesztett üzenet , amelynek hossza többszöröse .

M

512

2) A függvény által kibővített bemeneti vektor konvolúciója ${\displaystyle F_{8))$

M

bitekkel blokkokra van osztva . Jelölje az ilyen blokkok számával.

512

N

A konvolúció iterációkban történik. A -edik iterációnál az üzenet -edik -bites blokkja és az előző iterációnál számított érték kerül bevitelre. Létezik egy nulla iteráció is, amelynél a és -ból számítanak ki . Így rendelkezünk:

N

én

{\displaystyle F_{8))

én

512

M_{i}

M

H_{i-1}=F_{8}(H_{i-2},M_{i-1})

H_{0}

H_{-1}

M_{0}

H = H_N = F_8(H_{N-1},M_N) = F_8(F_8(H_{N-2},M_{N-1}),M_N) =\pontok= F_8(\pontok(H_{-1) },M_0)\pontok)

H_{-1}

és a következőképpen vannak kiválasztva: az első bitek egyenlőek a bemeneti paraméterrel – a kimeneti hash méretével (a esetén 0200h, 0180h, 0100h vagy 00e0h), a fennmaradó bitek és az összes bit pedig egyenlő .

M_{0}

16

H_{-1}

l_{hash}

l_{hash}

512, ~324, ~256

224

H_{-1}

M_{0}

0

3) Hash lekérése a függvény kimenetéből ${\displaystyle F_{8))$

A kitömött bemeneti üzenet konvolúciójának utolsó iterációjában a kimeneten kapott -bit vektorból az utolsó bitek kerülnek kiválasztásra:

1024

{\displaystyle H_{N}=H_{N}^{0}||H_{N}^{1}||\dots ||H_{N}^{1023))

{\displaystyle F_{8))

l_{hash}

JH(M_{0})=H_{N}^{1023+1-l_{hash}}||H_{N}^{1023+2-l_{hash}}||\dots ||H_ {N}^{1023}

Kriptanalízis

Lásd még

Jegyzetek

↑ SHA 2. forduló döntőseinek összehasonlítása megvalósítási paraméterek szerint különböző FPGA-kon http://www.ecrypt.eu.org/hash2011/proceedings/hash2011_07.pdf Archiválva : 2011. augusztus 23. a Wayback Machine -nél
↑ algoritmus innen származik: http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_round3.pdf Archiválva : 2011. november 10. a Wayback Machine -nél
↑ Ezek a részletek a http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_sse2_opt64.h webhelyről származnak, archiválva 2011. december 4-én a Wayback Machine -nél , és az áttekinthetőség és az egyszerűség kedvéért módosították.
↑ A gcc fordító használatakor, hogy az magában foglalja a processzor által támogatott további parancskészletek, például az SSE2 használatának lehetőségét, fordításkor a parancssorba egy opciót -march=native(például "gcc -o prog prog.c -Wall -march=native", ) adhatunk.

Linkek

a dokumentáció 2011 novemberétől érvényes
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_round3.pdf Archiválva : 2011. november 10. a Wayback Machine -nél
forráskódok változatai a JH-t megvalósító elektronikus eszközök VHDL-modelljein:
a C forráskódok JH-t megvalósító változatai:
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_ref.h Archiválva : 2011. november 4. a Wayback Machine -nél
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_bitslice_ref64.h Archiválva : 2011. augusztus 11. a Wayback Machine -nél
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_sse2_opt64.h Archiválva : 2011. december 4. a Wayback Machine -nél
szerzői oldal a JH támogatáshoz
- http://www3.ntu.edu.sg/home/wuhj/research/jh/index.html Archiválva : 2011. december 4. a Wayback Machine -nél
linkek az SHA-3 versenyre beküldött kriptoanalitikus kutatásokhoz és fájlarchívumokhoz
- http://ehash.iaik.tugraz.at/wiki/JH
hivatkozások olyan archívumokhoz, amelyek VHDL-ben található forráskódokkal (és a kísérő fájlokkal) olyan elektronikus eszközök modelljeit tartalmazzák, amelyek az SHA-3 második fordulójában átment hash függvény algoritmusokat alkalmaznak
- http://cryptography.gmu.edu/athena/index.php?id=source_codes
linkek az SHA-3 második fordulójának döntőjébe jutott (FPGA-kon megvalósított) elektronikus eszközök jellemzőit vizsgáló tanulmányokhoz, amelyek hash függvény algoritmusokat valósítanak meg
- http://ehash.iaik.tugraz.at/wiki/SHA-3_Hardware_Implementations
- https://web.archive.org/web/20120628192806/http://rijndael.ece.vt.edu/sha3/publications.html

Hash függvények
Általános rendeltetésű	Adler-32 CRC Fletcher ellenőrző összeg FNV MurmurHash2 MurmurHash2A MurmurHash3 PJW-32 TTH – Hash Tree jenkins hash hash összeg
Kriptográfia	Stribog GOST R 34.11-94 Öv BLAKE BMW CubeHash VISSZHANG edonkey2k FSB Fúga 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 Bőr Snefru Tigris Örvény
Kulcsgenerálási funkciók	bcrypt PBKDF2 scrypt Argon2 Lyra2
Csekkszám ( összehasonlítás )	Ellenőrző összeg Verhouff algoritmusa Hold algoritmus Damm algoritmus Vonalkód bankszámlák bankkártyák VAN SNILS OKPO ÓN OKATO ISBN OGRN és OGRNIP VIN
Hashes	A csekkszámok összehasonlítása Hitelesítési protokollok Vonalkód összehasonlítás Kriptográfia Mágneses kapcsolat Merkle aláírása ed2k URNA