JH

Aktuální verze stránky ještě nebyla zkontrolována zkušenými přispěvateli a může se výrazně lišit od verze recenzované 27. srpna 2017; kontroly vyžadují 14 úprav .

JH
Vývojáři	Wu Hongjun
zveřejněno	16. ledna 2011
Velikost hash	224, 256, 384, 512
Počet kol	42

JH je rodina čtyř kryptografických hašovacích funkcí : JH-224 , JH-256 , JH-384 a JH-512 .

Algoritmy těchto hašovacích funkcí se liší pouze hodnotou jednoho vnitřního parametru - délkou (v bitech) výstupní hodnoty (která je uvedena za pomlčkou v názvu). Později v článku, až budeme popisovat algoritmus, budu tento parametr pro pohodlí považovat za součást vstupních dat a budu mluvit o JH jako o jednom algoritmu nebo jedné hashovací funkci. $l_{hash}$

Hashovací funkce JH je jedním z pěti nejlepších finalistů ve druhém kole SHA-3 . Během této soutěže se to zlepšilo. Tento článek se zabývá aktuálně nejnovější verzí, kterou lze také nazvat JH42 (protože hlavní změnou bylo, že počet kol ve funkci komprese se stal 42). Datum vydání dokumentace je 16. ledna 2011.

Při hashování je vstupní zpráva doplněna a rozdělena na části, které jsou následně postupně zpracovávány tzv. kompresní funkcí. Tato funkce je ve specifikaci popsána obecně - tedy s proměnným parametrem d, jehož změnou můžete navrhovat hašovací funkce podobné JH (čím odolnější vůči kryptoměnám, tím větší d). V JH zpočátku d=8.

Při výběru finalisty soutěže SHA nehrají rozhodující roli kryptografické vlastnosti (ty jsou výborné pro všechny funkce), ale flexibilita a optimalita v softwarové a hardwarové implementaci. Na téma hardwarové implementace existuje mnoho studií, například [1] .

Algoritmus [2]

Upřesnění

K pojmenování prvků bitových vektorů

Budeme předpokládat, že všechny zde diskutované bitové vektory mají začátek a konec a bit umístěný na začátku ( vlevo ) je první , má pozici 0 a je považován za nejvýznamnější , respektive bit umístěný na end ( vpravo ) je poslední , má pozici s největším číslem , o jednu menší než je počet bitů ve vektoru, a je považován za nejméně významný .

Totéž, s výjimkou čísla pozice, bude znamenat pro vektory sestávající z bitových vektorů, například pro zprávu sestávající z bloků nebo blok sestávající z nibble. S číslem pozice libovolné složky bitového vektoru, sestávajícího z několika bitů, bude pro pohodlí vytvořen zmatek. Takže čísla pozic kousků v bloku budou začínat od nuly a čísla pozic bloků ve zprávě budou začínat od jedné ...

Příklad

Ve vektoru

8afd4h

první , nejvýznamnější kousíček se nachází vlevo - to je 8; poslední , nejméně významný kousek vpravo je 4.

Pokud je tato položka považována za bitový vektor a ne za nibble vektor, pak je ekvivalentní tomuto:

1000_1010_1111_1101_0100,

zde je první ( s číslem 0 , left , high ) bit 1 a poslední ( s číslem 19 , right , low ) je 0.

Zápis zřetězení

Nechť vektor sestává z po sobě jdoucích vektorů , pak bude tato skutečnost označena následovně: $A$ $A_1, A_2, \tečky, A_N$ $A=A_1||A_2|| \dots ||A_N$

Použité funkce jsou zobecněným případem

Jsou zde popsány funkce, které lze použít k sestavení algoritmů podobných JH změnou parametru $d$

S-box - S i(x)

Jedná se o funkci, která transformuje s-box (to znamená, že velikosti jeho vstupních a výstupních hodnot jsou stejné a rovny se 4 bitům). Algoritmus používá 2 takové funkce: a . Jejich tabulky hodnot jsou: $S_{1}$ $S_{0}$

$X$	0	jeden	2	3	čtyři	5	6	7	osm	9	A	b	C	d	E	F
$S_{0}(x)$	9	0	čtyři	b	d	C	3	F	jeden	A	2	6	7	5	osm	E
$S_{1}(x)$	3	C	6	d	5	7	jeden	9	F	2	0	čtyři	b	A	E	osm

Lineární transformace buněčných párů - L(A,B)

Tato funkce transformuje pár s-boxů (to znamená, že velikost jeho vstupních a výstupních hodnot je stejná a rovná se 8 bitům). Má nejvýstižnější zápis z hlediska konečných těles polynomů.

Uvažujme konečné pole polynomů nad stupněm nejvýše 3. To je izomorfní k poli ; ustanovme pro takové případy standard korespondence mezi tělesem polynomů a tělesem čísel: polynom bude odpovídat číslu rovnému hodnotě polynomu v . Zvolme pro toto pole polynomů následující primitivní polynom : $GF(2)$ $GF(2^{4})$ $x=2$

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

Pak, pokud považujeme za funkci, která transformuje 2 polynomy a čísla a písmena - jako polynomy, pak $LABORATOŘ)$

$L(A,B)=((5\odrážka A+2\odrážka B),(2\odrážka A+B))$ ,

kde " " a " " jsou operace násobení a sčítání v daném oboru polynomů. $\kulka$ $+$

Shuffle - P d

Funkce je složením tří jednodušších shufflů, které transformují pole bitových vektorů (to znamená, že velikosti jejich vstupních a výstupních hodnot jsou stejné a rovny bitům, kde je počet bitů v jednom prvku tohoto pole ): $P_d$ ${\displaystyle 2^{d))$ $2^{d}\times k$ $k$

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

Uvádíme algoritmy pro tato směšování, označující pro a (kde a jsou bitové vektory stejné velikosti pro všechny ) vstupní a výstupní vektory, v tomto pořadí: $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$ $B=B_{0}||B_{1}||\dots ||B_{2^{d}-1}$ $A_{i}$ $Bi}$ $i$

$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

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

Kruhová transformace - R d (A,C)

Vstupem je -rozměrný vektor . Výstupem je rozměrový vektor. Do vstupu je také přivedena -bitová konstanta . $2^{d+2}$ $A$ $2^{d+2}$ ${\displaystyle 2^{d))$ $C$

Vektor je reprezentován jako pole kousků: . $A$ ${\displaystyle 2^{d))$ $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$

Poté se každý kousíček převede nebo v závislosti na hodnotě (if , then , jinak - ) $A_{i}$ $S_{0}$ $S_{1}$ $C_{i}$ $C_{i}=0$ $S_{0}$ $S_{1}$

Dále je na každém páru formuláře provedena lineární transformace . $(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}))$

A nakonec se výsledky opět seskupí do vektoru, jehož bity se zamíchají . $P_d$

To je vyjádřeno jako vzorec:

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

Transformace E d

Na vstupu je rozměrový vektor . Nejprve přichází počáteční seskupení: $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

Dále je výsledkem tohoto seskupení aplikované kruhové transformace s konstantami, které se mění z kola na kolo. Počáteční hodnota proměnné je uvedena jako celočíselná část čísla , tzn. $B$ $6\krát (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

Poté dojde ke konečnému rozdělení skupiny, obrácené k původnímu:

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

Kde $G_{d}^{-1}:G_{d}(G_{d}^{-1}(B))\ekviv B$

Jako pseudokód:

$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

Takto,

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

$C_{i}=R_{d-2}(C_{i-1},0),~i=1\tečky 6(d-1),~C_{0}=\left\lfloor ({ \sqrt {2}}-1)\krát 2^{2^{d}}\pravé\rpodlaží$

Konvoluční funkce F d (H,M)

Vstupem je -bitový vektor a -bitový vektor . Nejprve je transformován bitovým sčítáním první poloviny tohoto vektoru s , poté je transformován výsledek a nakonec je výsledek transformován bitovým sčítáním jeho druhé poloviny s vektorem . $2^{d+2}$ $H$ $2^{d+1}$ $M$ $H$ $M$ $E_d$ $M$

Zapišme si to ve formě vzorců. Dovolit být první (nejvyšší) polovina vektoru , a nechat být druhá. Nechte také funkce a vraťte levou a pravou polovinu , resp. Pak ${\displaystyle H_{left))$ $H$ $H_{right}$ $E_{d-left}(A)$ $E_{d-right}(A)$ $E_{d}(A)$

$F_d(H,M)=E_{d-vlevo}\Velký((H_{vlevo}\oplus M)||H_{vpravo}\Velký)||\bigg(E_{d-vpravo}\Velký((H_ {left}\oplus M)||H_{vpravo}\Velký)\oplus M\bigg)$

Použité funkce - přizpůsobení hardwarové implementaci při d=8

Konkrétní provedení do značné míry závisí na parametrech jako je např

Požadovaný výkon
Požadovaná velikost
Žádoucí technologie
Požadovaná spotřeba energie
Požadovaná odolnost proti hluku
Požadovaná hodnota

Bez nastavení těchto parametrů tedy přizpůsobení není možné. Uvedu popis převodu pomocí bitových operací běžných v návrhu hardwaru a také některé konstanty, které se mohou hodit, pokud neexistuje žádné výrazné omezení velikosti obvodu. $L$

Vyjádření převodu L pomocí jednoduchých operací s bity

Nechte tedy $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 .$

kde " " je operace XOR. $\oplus$

Nechť vstupní a výstupní vektory lin_trans_in[0:7], lin_trans_out[0:7]resp

kód verilog přiřadit 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 ' lin_0 : 3 } , 1 ' lin_b0 : } = lin_trans_in [ 0 : 3 ] ^ { lin_trans_out [ 1 : 3 ], lin_trans_out [ 0 ]} ^ { 2 'b0 , lin_trans_out [ 0 ], 1 'b0 }; Konstanty H 0 pro různé l hash

Neboť budeme mít, resp. $l_{hash}=~512, ~384, ~256, ~224$

kód verilog 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 ; Konstanty C zaokrouhlí R 8

$C_{i}=R_{6}(C_{i-1},0),~i=1\tečky 42,~C_{0}=\left\lfloor ({\sqrt {2))- 1)\krát 2^{256}\pravé\rpatro$

Představme je jako pole, $C_{i+1}=$ round_const[i][0:255]

kód verilog 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 ; Okusujte pozice po zamíchání P 8

Vstupem nechť je 1024bitový vektor — pole 256 4bitových vektorů: a výstup je , pak . To znamená, že první nibble výstupního vektoru se bude rovnat nibble vstupního vektoru s číslem pozice (0 až 255) obsaženým v prvním bajtu konstanty , druhý nibble výstupního vektoru bude roven nibble. vstupního vektoru s číslem pozice obsaženým ve druhém bajtu atd. . $P_8$ $A=A_1||A_2||\tečky||A_{256}$ $B=B_1||B_2||\tečky||B_{256}$ $B_{i}=A_{permut\_pose[i*8-1-:8]}$ $B$ $A$ permut_pose[0:2047]permut_pose[0:2047]

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

Použité funkce - přizpůsobení softwarové implementaci při d=8

Podstatou této úpravy je minimalizace počtu operací pomocí operací s co nejdelšími operandy. Technologie, jako je například SIMD , SSE2 , AVX , to umožňují .

příklady implementace v C

Pro vysvětlení, jak funkce fungují, a také pro zobrazení kulatých konstant budou uvedeny části kódu C [3] . Po spojení do jednoho souboru a doplněném main()níže uvedenou funkcí se zkompilují [4] ; výsledný program implementuje funkci . $E_8$

dopředná prohlášení v C #include <emmintrin.h> #include <stdlib.h> #include <stdio.h> typedef __m128i slovo128 ; /*word128 definuje 128bitové slovo SSE2*/ /*definovat zarovnání dat pro různé kompilátory C*/ #if define(__GNUC__) #define DATA_ALIGN16(x) x __attribute__ ((aligned(16))) #else #define DATA_ALIGN16(x) __declspec(align(16)) x #endif /*Následující definice definuje operace se 128bitovými slovy*/ #define CONSTANT(b) _mm_set1_epi8((b)) /*nastaví každý bajt ve 128bitovém registru na "b"*/ #define XOR(x,y) _mm_xor_si128((x),(y)) /*XOR(x,y) = x ^ y, kde x a y jsou dvě 128bitová slova*/ #define AND(x,y) _mm_and_si128((x),(y)) /*AND(x,y) = x & y, kde x a y jsou dvě 128bitová slova*/ #define ANDNOT(x,y) _mm_andnot_si128((x),(y)) /*ANDNOT(x,y) = (!x) & y, kde x a y jsou dvě 128bitová slova*/ #define OR(x,y) _mm_nebo_si128((x),(y)) /*OR(x,y) = x | y, kde x a y jsou dvě 128bitová slova*/ #define SHR1(x) _mm_srli_epi16((x), 1) /*SHR1(x) = x >> 1, kde x je 128bitové slovo*/ #define SHR2(x) _mm_srli_epi16(x), 2) /*SHR2(x) = x >> 2, kde x je 128bitové slovo*/ #define SHR4(x) _mm_srli_epi16(x), 4) /*SHR4(x) = x >> 4, kde x je 128bitové slovo*/ #define SHR8(x) _mm_slli_epi16(x), 8) /*SHR8(x) = x >> 8, kde x je 128bitové slovo*/ #define SHR16(x) _mm_slli_epi32((x), 16) /*SHR16(x) = x >> 16, kde x je 128bitové slovo*/ #define SHR32(x) _mm_slli_epi64((x), 32) /*SHR32(x) = x >> 32, kde x je 128bitové slovo*/ #define SHR64(x) _mm_slli_si128((x), 8) /*SHR64(x) = x >> 64, kde x je 128bitové slovo*/ #define SHL1(x) _mm_slli_epi16(x), 1) /*SHL1(x) = x << 1, kde x je 128bitové slovo*/ #define SHL2(x) _mm_slli_epi16(x), 2) /*SHL2(x) = x << 2, kde x je 128bitové slovo*/ #define SHL4(x) _mm_slli_epi16(x), 4) /*SHL4(x) = x << 4, kde x je 128bitové slovo*/ #define SHL8(x) _mm_srli_epi16(x), 8) /*SHL8(x) = x << 8, kde x je 128bitové slovo*/ #define SHL16(x) _mm_srli_epi32((x), 16) /*SHL16(x) = x << 16, kde x je 128bitové slovo*/ #define SHL32(x) _mm_srli_epi64((x), 32) /*SHL32(x) = x << 32, kde x je 128bitové slovo*/ #define SHL64(x) _mm_srli_si128((x), 8) /*SHL64(x) = x << 64, kde x je 128bitové slovo*/ příklad funkce main(). int main () { int j ; void * e8_out ; //zde může být jakákoli konstanta, kterou chcete použít pro kontrolní znak E8 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 ( word128 )); //16 byte zarovnání - důležité! e8_out = ( void * )((( int ) e8_out ) + 16 - ((( int ) e8_out ) & 15 )); pro ( j = 0 ; j < 128 ; j ++ ) * (( char * ) e8_out + j ) = e8_in [ j ]; printf ( " \n vstup \n " ); pro ( j = 0 ; j < 128 ; j ++ ) printf ( "%.2x" ,( char )( * (( char * ) e8_out + j )) & 0xff ); E8 (( word128 * ) e8_out ); //out must be equal //2dfedd62f99a98acae7cacd619d634e7a4831005bc301216b86038c6c966149466d9899f2580706fce9ea31b1d9b1adc11e8325f7b366e10f994857f02fa06c11b4f1b5cd8c840b397f6a17f6e738099dcdf93a5adeaa3d3a431e8dec9539a6822b4a98aec86a1e4d574ac959ce56cf015960deab5ab2bbf9611dcf0dd64ea6e printf ( " \n output \n " ); pro ( j = 0 ; j < 128 ; j ++ ) printf ( "%.2x" ,( char )( * (( char * ) e8_out + j )) & 0xff ); návrat ( 0 ); } Funkce SBox

Převede čtyři 128bitové vektory v závislosti na 128bitové konstantě. To znamená

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

Algoritmus je tento. Zaveďme další 128bitovou proměnnou t a inicializujme proměnné počátečními hodnotami

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

pak pořadí úkolů je následující:

${\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$

možná implementace v C /*Sbox implementuje S0 a S1, vybrané pomocí konstantního bitu*/ #define S_BOX(m0,m1,m2,m3,cnst) { \ word128 t; \ m3 = XOR(m3,CONSTANT(0xff)); \ m0 = XOR(m0,ANDNOT(m2,cnst)); \ t = XOR(cnst,AND(m0,m1)); \ m0 = XOR(m0,AND(m3,m2)); \ m3 = XOR(m3,ANDNOT(m1,m2)); \ m1 = XOR(m1,AND(m0,m2)); \ m2 = XOR(m2,ANDNOT(m3,m0)); \ m0 = XOR(m0,OR(m1,m3)); \ m3 = XOR(m3,AND(m1,m2)); \ m2 = XOR(m2,t); \ m1 = XOR(m1,AND(t,m0)); \ }

- viz popis maker použitých v bloku "dopředné deklarace v C"

Funkce LinTrans

Převede osm 128bitových proměnných. Nechte tedy $(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$

možná implementace v C /*Kód MDS*/ #define LIN_TRANS(slovo) \ slovo[1] = XOR(slovo[1],slovo[2]); \ slovo[3] = XOR(slovo[3],slovo[4]); \ slovo[5] = XOR(XOR(slovo[5],slovo[6]),slovo[0]); \ slovo[7] = XOR(slovo[7],slovo[0]); \ slovo[0] = XOR(slovo[0],slovo[3]); \ slovo[2] = XOR(slovo[2],slovo[5]); \ slovo[4] = XOR(XOR(slovo[4],slovo[7]),slovo[1]); \ slovo[6] = XOR(slovo[6],slovo[1]);

V kódu pro pohodlí dalšího použití odpovídá ${\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])

- viz popis maker použitých v bloku "dopředné deklarace v C"

Permutační funkce

Převede 128bitovou proměnnou v závislosti na celočíselné konstantě . Tato funkce není optimalizována pro použití 128bitových proměnných, ale je vyžadována pro použití s ostatními funkcemi v této části. $n:~6\geq n\geq 0$

Nechte kde . Algoritmus pro získání čísla je následující: $b=Permutace(a,n)$ ${\displaystyle b=b_{0}||b_{1}||\dots ||b_{127},a=a_{0}||a_{1}||\tečky ||a_{127))$ $b$

$b=a$ :

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

Vyměnit \Big((b_{2\krát 2^n\krát i+0}||b_{2\krát 2^n\krát i+1}||\tečky||b_{2\krát 2^n\ krát i+2^n-1}),~(b_{2\krát 2^n\krát i+2^n+0}||b_{2\krát 2^n\krát i+2^n+1 }||\tečky||b_{2\krát 2^n\krát i+2^n+2^n-1})\Velký)

end

Zde záznam znamená takový úsek algoritmu, po kterém proměnná nabývá hodnoty, kterou měla proměnná , a proměnná nabývá hodnoty, kterou měla proměnná . $Swap(p,q)$ $p$ $q$ $q$ $p$

možná implementace v C /*Následující definice definuje operace se 128bitovými slovy*/ #define SWAP0(x) OR(SHR1(AND(x),CONSTANT(0xaa))),SHL1(AND(x),CONSTANT(0x55)))) /*záměna bitu 2i za bit 2i+1 128-bit x */ #define SWAP1(x) OR(SHR2(AND(x),CONSTANT(0xcc))),SHL2(AND(x),CONSTANT(0x33)))) /*záměna bitu 4i||4i+1 s bitem 4i+2||4i+3 ze 128bitových x */ #define SWAP2(x) OR(SHR4(AND(x),CONSTANT(0xf0))),SHL4(AND((x),CONSTANT(0xf)))) /*prohození bitů 8i||8i+1|| 8i+2||8i+3 s bity 8i+4||8i+5||8i+6||8i+7 ze 128bitového x */ #define SWAP3(x) OR(SHR8(x),SHL8(x)) /*prohození bitů 16i||16i+1||...||16i+7 s bity 16i+8||16i+9|| ...||16i+15 ze 128bitových x */ #define SWAP4(x) OR(SHR16(x),SHL16(x)) /*záměna bitů 32i||32i+1||...||32i+15 s bity 32i+16||32i+17|| ...||32i+31 ze 128bitového x */ #define SWAP5(x) _mm_shuffle_epi32((x),_MM_SHUFFLE(2,3,0,1)) /*záměna bitů 64i||64i+1||...||64i+31 s bity 64i+32|| 64i+33||...||64i+63 ze 128bitového x*/ #define SWAP6(x) _mm_shuffle_epi32((x),_MM_SHUFFLE(1,0,3,2)) /*prohození bitů 128i||128i+1||...||128i+63 s bity 128i+64|| 128i+65||...||128i+127 ze 128bitového x*/ #define STORE(x,p) _mm_store_si128((__m128i *)(p), (x)) /*uloží 128bitové slovo x do adresy paměti p, kde p je násobek 16 bajtů*/ #define LOAD(p) _mm_load_si128((__m128i *)(p)) /*načtení 16 bajtů z adresy paměti p, vrátí 128bitové slovo, kde p je násobek 16 bajtů*/ #define PERMUTATION(slovo,n) \ slovo[1] = SWAP##n(slovo[1]); slovo[3] = SWAP##n(slovo[3]); slovo[5] = SWAP##n(slovo[5]); slovo[7] = SWAP##n(slovo[7]);

- viz popis maker použitých v bloku "dopředné deklarace v C"

Funkce E 8 přizpůsobená pro softwarovou implementaci

Převede 1024bitový vektor. Shoduje se s funkcí popsanou ve zobecněném případě (v tom smyslu, že pokud se hodnoty argumentů shodují, shodují se hodnoty funkcí). Vstupem nechť je 1024bitový vektor. Představme si to jako sadu 8 128bitových proměnných: . Po následujících transformacích budou výstupním vektorem: $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 }^{even})

(x_{1},x_{3},x_{5},x_{7})=SBox(x_{1},x_{3},x_{5},x_{7},C_{r }^{lichý})

(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}=Permutace(x_{1},r{\bmod {7)))

x_{3}=Permutace(x_{3},r{\bmod {7)))

x_{5}=Permutace(x_{5},r{\bmod {7)))

x_{7}=Permutace(x_{7},r{\bmod {7)))

end

Použité 128bitové konstanty jsou specifikovány takto: $C_{r}^{odd}=C_{r}^{1}||C_{r}^{3}||\dots ||C_{r}^{255},~C_{r} ^{even}=C_{r}^{0}||C_{r}^{2}||\tečky ||C_{r}^{254},~C_{r}=R_{6}(C_ {r-1},0),~r=1\tečky 42,~C_{0}=\left\lfloor ({\sqrt {2}}-1)\times 2^{256}\right\rfloor$

možná implementace v C /*42 zaokrouhlovacích konstant, každá zaokrouhlovací konstanta je 32bajtová (256bitová)*/ DATA_ALIGN16 ( const unsigned char E8_bitslice_roundconstant [ 42 ][ 32 ]) = { { 0x72 , 0xd5 , 0xde , 0xa2 , 0xdf , 0x15 , 0xf8 , 0x67 , 0x7b , 0x84 , 0x15 , 0xa , 0xb7 , 0x23 , 0x4d , 0x5a , 0x6 , 0x5a, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x4d, 0x5, 0x4d, 0x5, 0x4d, 0x4d , 0x4d , 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x. 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6 , 0xf6 , 0xf6 , 0xf6 , 0xf6 , 0xc , 0xc , 0xb , 0xb , 0xb , 0x9f , 0xb , 0xf , 0xf , 0xf6 { 0xea , 0x98 , 0x3a , 0xe0 , 0x5c , 0x45 , 0xfa , 0x9c , 0xc5 , 0xd2 , 0x99 , 0x66 , 0xb2 , 0x99 , 0x9a , 0x96 , 0xb4 , 0x53 , 0xbb, 0x53, 0xbb, 0x53, 0xbb, 0x53, 0xbb, 0x53, 0xbb, 0x53, 0xbb, 0xf2, 0xbb, 0xf2, 0xbb, 0xf2, 0xbb , 0xf2 , 0xbb , 0xf2 , 0xbb , 0xf2 , 0xbb , 0xb . , 0x56 , 0x14 , 0x1a , 0x88 , 0xdb , 0xa2 , 0x31 }, { 0x3 , 0xa3 , 0x5a , 0x5c , 0x9a , 0x19 , 0xe , 0xdb , 0xb2 , 0xb2 , 0xa , 0x87 , 0xc1 , 0x44 , 0x10 , 0x1c , 0x5 , 0x84 , 0x9 . , 0x84 , 0x9 . , 0x84 , 0x1 , 0x84, 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 , 0x37 , 0xaa , 0x37 , 0xaa , 0x37 , 0x5, 0x37, 0x5, 0x37 , 0xbb , 0x37, 0xbb, 0x37, 0x3, 0x3, 0x3 , 0x3 , 0x . , 0x1a , 0xbf , 0xd2 , 0x41 , 0x0 , 0x91 , 0xd3 }, { 0x42 , 0x2d , 0x5a , 0xd , 0xf6 , 0xcc , 0x7e , 0x90 , 0xd , 0x62 , 0x9f , 0x9c , 0x92 , 0xc0 , 0x97 , 0xce , 0x18 , 0x5c , 0xc7 , 0x2b , 0x44 , 0x2b, 0x44, 0x2b , 0x44, 0x2b, 0x44, 0x2, 0X14, 0x2, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2b, 0xc7, 0x2, 0xC7, 0x2, 0xC7, 0x2, 0xC7, 0x2, 0xC7, 0x2, 0xC7, 0x2, 0xC7 , 0x2, 0xc7 , 0x2 . , 0xdf , 0x65 , 0xd6 , 0x63 , 0xc6 , 0xfc , 0x23 }, { 0x97 , 0x6e , 0x6c , 0x3 , 0x9e0 , 0xb8 , 0x1a , 0x21 , 0x5 , 0x45 , 0x7e , 0x44 , 0x6c , 0x8 , 0x61 , 0x8e , 0x61 , 0x8e, 0x61, 0x8e, 0xf1 , 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e , 0x8e , 0x8e , 0x8e , 0x8e , 0x8e , 0x . , 0x96 , 0x97 , 0xb2 , 0x94 , 0x83 , 0x81 , 0x97 }, { 0x4a , 0x8e , 0x85 , 0x37 , 0xdb , 0x3 , 0x30 , 0x2f , 0x2a , 0x67 , 0x8D , 0x2D , 0xfb , 0x9f , 0x6a , 0x95 , 0x8a , 0xfe , 0x73 , 0x81 , 0xf8 , 0xb8 , 0x69 , 0x6c , 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 , 0x6f , 0xa7 , 0x8f , 0x1, 0x88, 0xt, 0x8, 0X4, 0x8, 0X4, 0X4, 0X4, 0X4, 0X4, 0X4, 0X4, 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0X4 , 0XI , 0X4 , 0XI , 0X4 , 0XTR , 0xb8 , 0x0 , 0x1e , 0x98 , 0xa6 , 0xa3 , 0xf4 }, { 0x8e , 0xf4 , 0x8f , 0x33 , 0xa9 , 0xa3 , 0x63 , 0x15 , 0xa , 0x5f , 0x56 , 0x24 , 0xd5 , 0xf7 , 0xE0 , 0x5, 0xf, 0x5, 0XF, 0xd, 0xd , 0xd , 0xd , 0xd , 0XFD , 0XFD , 0XFD , 0XFD , 0x7, 0XE0, 0x7. , 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 , 0xf9 , 0xf9 , 0x74 , 0x6f , 0x4 , 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4 , 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x81 , 0x . , 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 , 0x7 , 0x26 , 0xc6 , 0x80 , 0x10 , 0x3f , 0xe0 , 0xa0 , 0x7e , 0x6f , 0xc6 , 0x7e , 0x48 , 0x7b }, { 0xd , 0x55 , 0xa , 0xa5 , 0x4a , 0xf8 , 0xa4 , 0xc0 , 0x91 , 0xe3 , 0xe7 , 0x9f , 0x97 , 0x8e , 0xd4 , 0x8e , 0xd4 , 0x8D , 0xd4 , 0x8D , 0xd4 , 0x8D , 0xd4 , 0x8 . _ , 0x9e , 0x5a , 0x41 , 0xf3 , 0xe5 , 0xb0 , 0x62 } , { 0xfc , 0x9f , 0x1f , 0xec , 0x40 , 0x54 , 0x20 , 0x7a , 0xe3 , 0xe4 , 0x1a , 0x0 , 0xce , 0xf4 , 0xc9 , 0xd , 0x9d , 0xf4 , 0x95, 0x9d, 0xd, 0x9d, 0x9, 0x9, 0xl, 0x9, 0x9, 0x9, 0x9, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95 , 0x95 , 0x95 , 0x95 , 0x95 , 0x95 . , 0xd. , 0x2e , 0x7e , 0x11 , 0x24 , 0xc3 , 0x54 , 0xa5 }, { 0x5b , 0xdf , 0x72 , 0x28 , 0xbd , 0xfe , 0x6e , 0x28 , 0x78 , 0x7c , 0xf , 0xd , 0xee , 0xee , 0xee , 0xee , 0xee , 0xd3 , 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0X2, 0xd3, 0X2, 0X2, 0X2, 0X2, 0X2 , 0X2, 0X2 , 0X2 , 0X2 , 0X2 , 0X2, 0X2, 0X. , 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, 0x2, 0xb9, 0x9, 0x9 , 0x9 , 0x9 , 0x9 , 0x9, 0x9, 0x9, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5, 0x5 , 0x5 , 0x5, 0x51, 0x4 , 0X51 , 0x4 , 0x51 , 0x1, 0x5 , 0X51 , 0x1 , 0x. , 0x, 0x, 0x , 0xfe , 0x43 , 0xe8 , 0x23 , 0xd4 , 0x87 , 0x8a }, { 0x7d , 0x29 , 0xe8 , 0xa3 , 0x92 , 0x76 , 0x94 , 0xf2 , 0xdd , 0xcb , 0x7a , 0x9 , 0xda , 0xd9 , 0xda , 0xd0 , 0x1A, 0xD0, 0x1, 0xd0, 0x1, 0xd0, 0x1 , 0xd0 , 0xD0 , 0X0 , 0xD0 , 0xD0 , 0xD0 , 0xd , 0xd9 . , 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 , 0xd3 , 0xbb , 0xd3 , 0xbb, 0xd3, 0xbb, 0xd3, 0x3, 0xd3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3 , 0X3 , 0X3 , 0X3 . , 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 , 0x95 , 0xe9 , 0x3b , 0x8e , 0x36 , 0x4f , 0x2f , 0x98 , 0x4a } , { 0x88 , 0x40 , 0x1d , 0x63 , 0xa0 , 0x6c , 0xf6 , 0x15 , 0x47 , 0xc1 , 0x44 , 0x4b , 0x87, 0x52 , 0xaf , 0xff , 0x7e , 0xbb , 0x4a , 0xf1 , 0xe2 , 0xa , 0xc6 , 0x30 , 0x30 , 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 , 0x16 , 0x33 , 0xe9 , 0x6 , 0x58, 0x9a , 0x94, 0x6, 0x84, 0x6f, 0x84, 0x6f, 0x84, 0x6f, 0x84, 0x6f, 0x84, 0x6f , 0x84 , 0x6f, 0x84, 0x6f, 0xC2, 0x6f, 0X84, 0x6f, 0xC2, 0x6f , 0xC2 , 0x6f , 0xC2 , 0x6f , 0xC2 , 0x6 , 0xC2 , 0x6 , 0xc2 , 0x6 , 0xc2 , 0x . , 0xce , 0xac , 0x7f , 0xa0 , 0xd1 , 0x85 , 0x18 }, { 0x32 , 0x59 , 0x5b , 0xa1 , 0x8d , 0xdd , 0xd3 , 0x10, 0x9a, 0x1c, 0xc0 , 0xAA , 0xa5 , 0x6b , 0x4, 0x6, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4, 0x4 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6, 0x6 , 0x6 , 0x6, 0x6, 0x6, 0x6, 0x6 , 0x6 , 0x . , 0xca , 0x19 , 0xab , 0xb , 0x56 , 0xee , 0x7e }, { 0x1f , 0xb1 , 0x79 , 0xea , 0xa9 , 0x28 , 0x21 , 0x74 , 0xe9 , 0xbd , 0xf7 , 0x35 , 0x3b , 0xd3 , 0x7 , 0xd , 0x50, 0xd, 0x50 , 0xd, 0x5, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3 , 0xd3, 0xd3, 0xd3, 0xd3, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75 , 0x75 , 0x75 , 0x75 , 0x75, 0x75, 0x75, 0x75, 0x75, 0x75 , 0x75 , 0x75 . , 0x , 0x46 , 0xc2 , 0xfe , 0xa3 , 0x7d , 0x70 , 0x1 }, { 0xf7 , 0x35 , 0xc1 , 0xaf , 0x98 , 0xa4 , 0xd8 , 0x42 , 0x78 , 0xed , 0xec , 0x20 , 0x9e , 0x6b , 0xdb , 0xdb , 0xdb , 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xya, 0XA, 0xa. a, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa , 0xa8 , 0xa , 0xa , 0xa , 0xa , 0xa , 0xa8 , 0xa8 , 0xc3 , 0x4x , 3x , 0x3 , 0x4x , 3 , 3x { 0xa7 , 0x40 , 0x3b , 0x1f , 0x1c , 0x27 , 0x47 , 0xf3 , 0x59 , 0x40 , 0xf0 , 0x6c , 0xd2 , 0x21 , 0xdf , 0x21 , 0xdf , 0x21 , 0xs4 , 0x2d , 0x4, 0x21, 0xdf, 0x21 , 0xdf , 0x21 , 0x4 , 0x2d , 0x4 . , 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 , 0x88 , 0x4f , 0x4f , 0x , 0xb0 , 0x5c , 0x55 , 0xf8 , 0xba , 0xbc , 0x4c }, { 0xe3 , 0xbb , 0x3b , 0x99 , 0xf3 , 0x87 , 0x94 , 0x7b , 0x75 , 0xda , 0xf4 , 0xd6 , 0x72 , 0xdc, 0x34, 0xb3, 0x3, 0xdc, 0x34, 0xb3, 0xb3, 0xdc, 0x3, 0xdc, 0xb3, 0xdc, 0xb3, 0xdc, 0XB3, 0xdc, 0xdc, 0XB3, 0xdc, 0xdc, 0XB3, 0xdc, 0XB3, 0xdc, 0XB. , 0xb3, 0xb3, 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0xb3 , 0x34 , 0xa5 , 0x50 , 0xb8 , 0x28 , 0xdb , 0x71 }, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb. { 0xf8 , 0x61 , 0xe2 , 0xf2 , 0x10 , 0x8d , 0x51 , 0x2a , 0xe3 , 0xdb , 0x64 , 0x33 , 0x59 , 0xdd , 0x75 , 0xfc, 0x1c, 0xc, 0x43, 0xce, 0x43, 0xce, 0x43, 0xe, 0x43, 0x4, 0x43, 0x4, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x. 0xa2, 0xa2 , 0xa , 0xa2 , 0xa , 0xa2 , 0xa , 0xa2 , 0xa2 , 0xa2 , 0xa2 , 0xa , 0xa2 , 0x , 0xa2 , 0x , 0xdx1 , 0xe , 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x { 0x33 , 0xa , 0x5b , 0xca , 0x88 , 0x29 , 0xa1 , 0x75 , 0x7f , 0x34 , 0x19 , 0x4d , 0xb4 , 0x16 , 0x53 , 0x3b , 0x94 , 0x79 , 0x4, 0x79, 0x4, 0x79, 0x4, 0x79, 0x4, 0x79, 0x4, 0x4, 0x4, 0xc3, 0x4 , 0xc3 , 0x4 , 0xc3 , 0x4 , 0xc3 , 0x4 . , 0x74 , 0x75 , 0xd7 , 0xb6 , 0xee , 0xaf , 0x3f }, { 0xea , 0xa8 , 0xd4 , 0xf7 , 0xbe , 0x1a , 0x39 , 0x21 , 0x5c , 0xf4 , 0x7e , 0x9 , 0x4c , 0x23, 0x27 , 0xa3 , 0xba , 0x32, 0x3, 0xba , 0xba , 0xba , 0xba , 0xba , 0xba , 0xba , 0xba , 0xba , 0xba . , 0xa3 , 0x17 , 0x4a , 0x6d , 0xa6 , 0xd5 , 0xad }, { 0xb5 , 0x1d , 0x3e , 0xa6 , 0xAF , 0xf2 , 0xc9 , 0x8 , 0x3d , 0x3d , 0x98 , 0x72 , 0x4b , 0x60 , 0x86 , 0x60 , 0x86, 0x86, 0x86, 0x60, 0x86, 0x60, 0x60, 0x60, 0x60, 0x72 , 0x60 , 0x72 , 0x60 , 0x72 , 0x3c , 0x72 , 0x3c , 0x60 . , 0xe2 , 0x3e , 0xcc , 0x8 , 0x6e , 0xc7 , 0xf6 }, { 0x2f , 0x98 , 0x33 , 0xb3 , 0xb1 , 0xbc , 0x76 , 0x2b , 0xd6 , 0x66 , 0xa5 , 0xef , 0xc4 , 0xd , 0xc1, 0xd4, 0xc1, 0xd4, 0xc1, 0xd4, 0xc1, 0xd4, 0xc1, 0xd4, 0xs1, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0xd4 , 0x . , 0xee , 0x82 , 0x15 , 0xbc , 0xef , 0x21 , 0x63 }, { 0xfd , 0xc1 , 0x4e , 0xd , 0xf4 , 0x53 , 0xc9 , 0x69 , 0xa7 , 0x7d , 0x5a , 0xc4 , 0x6, 0x58, 0x58, 0x26, 0x1, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6 , 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6, 0x6 , 0x6, 0x6, 0x6, 0x6, 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6 , 0x6, 0x6. , 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 , 0x32 , 0x32, 0x32, 0x32, 0x32, 0x32, 0xf2, 0x9, 0xf2, 0X98, 0xf2, 0X98, 0xf2, 0X98, 0xf2, 0X98, 0xf2, 0X98, 0xf2, 0X16, 0xf2, 0X16, 0xf2, 0X16 , 0xf2 , 0X16 , 0xf2 , 0X16 , 0X . , 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 , 0x15 , 0x47 , 0x15 , 0x47 , 0x15, 0x47 , 0x15 , 0x47 , 0x15, 0x47 , 0x15 , 0x47 , 0x15 , 0x47 , 0x . , 0x46 , 0x54 , 0x82 , 0x23 , 0x93 , 0x6a , 0x48 }, { 0x38 , 0xdf , 0x58 , 0x7 , 0x4e , 0x5e , 0x65 , 0xf2 , 0xfc , 0x7c , 0x89 , 0xfc , 0xca , 0xc , 0xc , 0xc, 0xca, 0xb, 0xca, 0xc, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca , 0xca, 0XC0, 0XC0, 0XC0, 0XC0, 0XCA, 0XC0, 0XCA, 0XC0, 0XCA, 0XCA, 0XCA , 0XCA , 0XCA, 0XCA , 0XCA , 0XCA , 0XCA , 0XCA , 0XCA , 0XCA , 0XCA , 0XCA , 0X . , 0x40 , 0x9 , 0xa2 , 0x30 , 0x78 , 0x47 , 0x4e }, { 0x65 , 0xa0 , 0xee , 0x39 , 0xd1 , 0xf7 , 0x38 , 0x83 , 0xF7 , 0x5e , 0xe9 , 0x37 , 0xe4 , 0x2c , 0x3a , 0xbd , 0x21 , 0x26 , 0x1 , 0x13 , 0x1, 0x13 , 0x1, 0x13 , 0x1 , 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1 , 0x . , 0x44 , 0xed , 0xd1 , 0xef , 0x9f , 0xde , 0xe7 }, { 0x8b , 0xa0 , 0xdf , 0x15 , 0x76 , 0x25 , 0xd9 , 0x3c , 0x85 , 0xf7 , 0xf6 , 0x12 , 0X5 , 0x2 , 0xb0 , 0x27 , 0X5 , 0X27, 0X5, 0X27, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5 , 0X5, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5, 0X5 , 0X5, 0X5 , 0X5, 0X5 , 0X5 , 0X5 , 0X5 , 0X5 , 0X5 , 0XB0 , 0x8d , 0x7d , 0xda , 0xaa , 0x3e , 0xa8 , 0xde }, { 0xaa , 0x25 , 0xce , 0x93 , 0xbd , 0x2 , 0x69 , 0xd8 , 0x43 , 0x43 , 0xfd , 0x4a , 0xa5 , 0xa5, 0xa5, 0x19, 0xa5, 0x19, 0xa5, 0x19, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0XA5, 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 , 0XA5, 0XA5, 0XA5 , 0XA5 , 0XA5, 0XA5, 0XA5, 0XA5, 0XA5, 0X. , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0xa , 0xa5 , 0x , 0x4d , 0x66 , 0x4d , 0x66 , 0x4 0x33 , { 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 }}; /*kruhová funkce E8 */ #define ROUND_FUNCTION(slovo,n,r)\ S_BOX(((slovo)[0]),((slovo)[2]),((slovo)[4]),((slovo)[6]),( LOAD(E8_bitslice_roundconstant[r]))) \ S_BOX(((slovo)[1]),((slovo)[3]),((slovo)[5]),((slovo)[7]),(LOAD (E8_bitslice_roundconstant[r]+16))) \ LIN_TRANS(slovo) \ PERMUTATION((slovo),n) void E8 ( slovo128 * slovo ){ int i ; for ( i = 0 ; i < 42 ; i = i + 7 ) { ROUND_FUNCTION ( slovo , 0 , i ) ROUND_FUNCTION ( slovo , 1 , i + 1 ) ROUND_FUNCTION ( slovo , 2 , i + 2 ) ROUND_FUNCTION ( slovo , 3 , i + 3 ) ROUND_FUNCTION ( slovo , 4 , i + 4 ) ROUND_FUNCTION ( slovo , 5 , i + 5 ) ROUND_FUNCTION ( slovo , 6 , i + 6 ) } }

- viz popis použitých maker v podsekcích výše.

Počáteční údaje

Vstupní parametr

$l_{hash}$ — délka hash (počet bitů ve výstupním vektoru hašovací funkce).

Může nabývat pouze následujících hodnot:

224, 256, 384 a 512;

Připomeňme, že tento článek, přísně vzato, popisuje rodinu 4 hashovacích funkcí. Vstupní zpráva

Představuje číslo — délku zprávy a bitový vektor (if ). I když s výpočtem nejsou žádné potíže . $L$ $M_{0}$ $L\neq 0$ $L=0$ $JH(M_{0})$

Algoritmus pro výpočet JH(M 0 )

1) Doplnění vstupního vektoru

Připojení dalších bitů ke zprávě na konci. Děje se tak ve třech fázích:

M_{0}

1.1) Doplněk jednotek. Připojení jednoho bitu na konec zprávy. 1.2) Nulová výplň. Připojení na konec zprávy, doplněné jedním, nula bitů v počtu kusů.

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

1.3) Výplň s délkou zprávy. Připojení na konec zprávy, doplněné jedničkou a nulami, 128 bitů, které obsahuje délku původní zprávy (například pokud , pak bude sčítání vypadat takto: ).

L=2

0\dots 010

Výsledkem je rozšířená zpráva s délkou, která je násobkem .

M

512

2) Konvoluce rozšířeného vstupního vektoru funkcí ${\displaystyle F_{8))$

M

je rozdělena do bloků po bitech. Označte počtem takových bloků.

512

N

Konvoluce probíhá v iteracích. Při -té iteraci se zadá -tý -bitový blok zprávy a hodnota vypočítaná v předchozí iteraci. Existuje také nulová iterace, při které se počítá od a . Máme tedy:

N

i

{\displaystyle F_{8))

i

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) =\tečky= F_8(\tečky(H_{-1) },M_0)\tečky)

H_{-1}

a volí se následovně: první bity se rovnají vstupnímu parametru — velikosti výstupního hashe (pro , rovná se 0200h, 0180h, 0100h nebo 00e0h, v tomto pořadí) a zbývající bity a všechny bity jsou nastaveny na hodnotu .

M_{0}

16

H_{-1}

l_{hash}

l_{hash}

512, ~324, ~256

224

H_{-1}

M_{0}

0

3) Načtení hash z výstupu funkce ${\displaystyle F_{8))$

Z -bitového vektoru získaného na výstupu při poslední iteraci konvoluce vyplněné vstupní zprávy se vyberou poslední bity:

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}}||\tečky ||H_ {N}^{1023}

Kryptoanalýza

Viz také

Poznámky

↑ srovnání finalistů 2. kola SHA podle implementačních parametrů na různých FPGA http://www.ecrypt.eu.org/hash2011/proceedings/hash2011_07.pdf Archivováno 23. srpna 2011 na Wayback Machine
↑ Algoritmus převzat odtud: http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_round3.pdf Archivováno 10. listopadu 2011 na Wayback Machine
↑ Tyto úryvky jsou převzaty z http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_sse2_opt64.h Archivovány 4. prosince 2011 na Wayback Machine a upraveny pro srozumitelnost a jednoduchost.
↑ Při použití kompilátoru gcc lze do příkazového řádku při kompilaci přidat volbu (například , ) , aby z něj vyplývala možnost použití dalších sad příkazů podporovaných procesorem, jako je SSE2 .-march=native"gcc -o prog prog.c -Wall -march=native"

Odkazy

dokumentace aktuální k listopadu 2011
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_round3.pdf Archivováno 10. listopadu 2011 na Wayback Machine
varianty zdrojových kódů na VHDL modelech elektronických zařízení, které implementují JH:
varianty zdrojových kódů C implementující JH:
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_ref.h Archivováno 4. listopadu 2011 na Wayback Machine
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_bitslice_ref64.h Archivováno 11. srpna 2011 na Wayback Machine
- http://www3.ntu.edu.sg/home/wuhj/research/jh/jh_sse2_opt64.h Archivováno 4. prosince 2011 na Wayback Machine
stránku autora pro podporu JH
- http://www3.ntu.edu.sg/home/wuhj/research/jh/index.html Archivováno 4. prosince 2011 na Wayback Machine
odkazy na výzkum kryptoanalytik a archivy souborů předložené do soutěže SHA-3
- http://ehash.iaik.tugraz.at/wiki/JH
odkazy na archivy se zdrojovými kódy ve VHDL (a doprovodné soubory) modelů elektronických zařízení, které implementují algoritmy hashovacích funkcí, které prošly do druhého kola SHA-3
- http://cryptography.gmu.edu/athena/index.php?id=source_codes
odkazy na studie charakteristik elektronických zařízení (implementovaných na FPGA), které implementují algoritmy hashovacích funkcí, které prošly do finále druhého kola SHA-3
- http://ehash.iaik.tugraz.at/wiki/SHA-3_Hardware_Implementations
- https://web.archive.org/web/20120628192806/http://rijndael.ece.vt.edu/sha3/publications.html

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