Interested Article - JH

JH — семейство из четырёх криптографических хеш-функций : JH-224 , JH-256 , JH-384 и JH-512 .

Алгоритмы этих хеш-функций отличаются только значением одного внутреннего параметра — длины (в битах) $l_{hash}$ выходного значения (которая и указана после дефиса в названии). Далее в статье при описании алгоритма я буду считать этот параметр частью входных данных для удобства, говоря о JH, как об одном алгоритме или одной хеш-функции.

Хеш-функция JH входит в пятёрку финалистов второго тура SHA-3 . В процессе этого конкурса она была улучшена. В статье рассматривается последняя на данный момент версия, которую также можно назвать JH42 (так как главное изменение состояло в том, что число раундов в функции компрессии стало равно 42). Дата выхода документации по ней — 16 января 2011 года.

При хешировании входное сообщение дополняется и разделяется на части, которые далее последовательно обрабатываются так называемой функцией компрессии. Эта функция описана в спецификации в общем виде — то есть с переменным параметром d, меняя который можно конструировать JH-подобные хеш-функции (тем более криптостойкие, чем больше d). В JH исходно d=8.

При выборе финалиста в конкурсе SHA решающую роль играют не криптографические характеристики (они у всех функций отличные), а гибкость и оптимальность в программной и аппаратной реализации. На тему аппаратной реализации существует много исследований, например .

Алгоритм

Уточнения

О названии элементов битовых векторов

Будем считать, что у всех обсуждаемых тут битовых векторов есть начало и конец , причём бит, расположенный в начале ( слева ) является первым , имеет позицию 0 и считается наиболее значимым , соответственно, бит, расположенный в конце ( справа ), является последним , имеет позицию с наибольшим номером , на один меньшим, чем число разрядов вектора, и считается наименее значимым .

То же самое, за исключением номера позиции, будем подразумевать для векторов, состоящих из битовых векторов, например, для сообщения, состоящего из блоков, или блока, состоящего из полубайтов. С номером же позиции какой-либо составной части битового вектора, состоящей из нескольких бит, будет путаница, создаваемая для удобства. Так, номера позиций полубайтов в блоке будут начинаться с нуля, а номера позиций блоков в сообщении — с единицы…

Пример

В векторе

8afd4h

первый , наиболее значимый полубайт расположен слева – это 8; последний , наименее значимый полубайт расположен справа – это 4.

Если эту запись рассматривать, как битовый вектор, а не как полубайтовый, то она эквивалентна такой:

1000_1010_1111_1101_0100,

тут первый ( с номером 0 , левый , старший ) бит - 1, а последний ( с номером 19 , правый , младший ) - 0.

Обозначение конкатенации

Пусть вектор $A$ состоит из последовательно идущих векторов $A_{1},A_{2},\dots ,A_{N}$ , тогда этот факт будет обозначаться так: $A=A_{1}||A_{2}||\dots ||A_{N}$

Используемые функции — обобщённый случай

Здесь описаны функции, с помощью которых можно строить JH-подобные алгоритмы, меняя параметр $d$

S-box — S _i(x)

Это функция, преобразующая s-блок (то есть размеры её входного и выходного значений одинаковы и равны 4 битам). В алгоритме используются 2 таких функции: $S_{1}$ и $S_{0}$ . Их таблицы значений такие:

$x$	0	1	2	3	4	5	6	7	8	9	a	b	c	d	e	f
$S_{0}(x)$	9	0	4	b	d	c	3	f	1	a	2	6	7	5	8	e
$S_{1}(x)$	3	c	6	d	5	7	1	9	f	2	0	4	b	a	e	8

Линейное преобразование пар ячеек — L(A,B)

Эта функция преобразует пару s-блоков (то есть размеры её входного и выходного значений одинаковы и равны 8 битам). Наиболее лаконичную запись она имеет в терминах конечных полей многочленов.

Рассмотрим конечное поле многочленов над $GF(2)$ степени не выше 3-й. Оно изоморфно полю $GF(2^{4})$ ; установим стандартное для таких случаев соответствие межу полем многочленов и полем чисел: многочлен будет соответствовать числу, равному значению многочлена при $x=2$ . Выберем для этого поля многочленов следующий примитивный многочлен :

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

Тогда, если рассматривать $L(A,B)$ , как функцию, преобразующую 2 многочлена, а числа и буквы — как многочлены, то

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

где « $\bullet$ » и « $+$ » — операции умножения и сложения в данном поле многочленов.

Перемешивание — P _d

Функция $P_{d}$ является композицией трёх более простых перемешиваний, преобразующих массив из $2^{d}$ битовых векторов (то есть размеры их входных и выходных значений одинаковы и равны $2^{d}\times k$ битам, где $k$ — число бит в одном элементе этого массива):

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

Приведем алгоритмы этих перемешиваний, обозначив за $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$ и $B=B_{0}||B_{1}||\dots ||B_{2^{d}-1}$ (где $A_{i}$ и $B_{i}$ — битовые векторы одинакового размера для всех $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

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}

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

end

Преобразование-раунд — R _d (A,C)

На вход подается $2^{d+2}$ - мерный вектор $A$ . Выход — $2^{d+2}$ - мерный вектор. Так же на вход подается $2^{d}$ -битная константа $C$ .

Вектор $A$ представляется в виде массива из $2^{d}$ полубайт: $A=A_{0}||A_{1}||\dots ||A_{2^{d}-1}$ .

Потом над каждым полубайтом $A_{i}$ производится преобразование $S_{0}$ или $S_{1}$ в зависимости от значения $C_{i}$ (если $C_{i}=0$ , то $S_{0}$ , иначе — $S_{1}$ )

Далее над каждой парой вида $(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}))$ .

И в конце концов результаты опять группируются в вектор, биты которого подвергаются перемешиванию $P_{d}$ .

Это выражается в виде формулы:

$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 )}||\dots ||L{\Big (}S_{C_{2^{d}-2}}(A_{2^{d}-2}),S_{C_{2^{d}-1}}(A_{2^{d}-1}){\Big )}{\bigg )}$

Преобразование E _d

На входе $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}

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}

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

end

Далее к результату $B$ этой группировки применяется $6\times (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

Далее происходит конечная разгруппировка, обратная начальной:

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

Где $G_{d}^{-1}:G_{d}(G_{d}^{-1}(B))\equiv B$

В виде псевдокода:

$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

Таким образом,

$E_{d}(A)=G^{-1}(R_{d}(R_{d}(R_{d}(\dots (R_{d}(G_{d}(A)),C_{1})\dots ),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$

Функция свёртки F _d (H,M)

На входе $2^{d+2}$ -битный вектор $H$ и $2^{d+1}$ -битный вектор $M$ . Сначала $H$ преобразуется путём побитового сложения первой половины этого вектора с $M$ , потом над результатом выполняется преобразование $E_{d}$ и наконец результат преобразуется путём побитового сложения его второй половины с вектором $M$ .

Запишем это в виде формул. Пусть $H_{left}$ — первая (старшая) половина вектора $H$ , а $H_{right}$ — вторая. Пусть также функции $E_{d-left}(A)$ и $E_{d-right}(A)$ возвращают левую и правую половины $E_{d}(A)$ соответственно. Тогда

$F_{d}(H,M)=E_{d-left}{\Big (}(H_{left}\oplus M)||H_{right}{\Big )}||{\bigg (}E_{d-right}{\Big (}(H_{left}\oplus M)||H_{right}{\Big )}\oplus M{\bigg )}$

Используемые функции — адаптация к аппаратной реализации при d=8

Конкретная реализация во многом зависит от таких параметров, как

Желательное быстродействие
Желательный размер
Желательная технология
Желательное энергопотребление
Желательная помехоустойчивость
Желательная стоимость

Поэтому без задания этих параметров адаптация невозможна. Я дам описание преобразования $L$ с помощью обычных для аппаратной разработки побитовых операций, а также некоторые константы, которые могут пригодиться, если нет существенного ограничения по размерам схемы.

Выражение преобразования L через простые операции с битами

Пусть $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}.$

где « $\oplus$ » — операция «исключающее или».

Пусть входной и выходной векторы lin_trans_in[0:7] и lin_trans_out[0:7] соответственно, тогда

verilog-код

assign 
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:3]=lin_trans_in[0:3] ^ {lin_trans_out[1:3],lin_trans_out[0]} ^ {2'b0,lin_trans_out[0],1'b0};

Константы H ₀ при разных l _hash

Для $l_{hash}=~512,~384,~256,~224$ будем иметь соответственно:

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'h2dfedd62f99a98acae7cacd619d634e7a4831005bc301216b86038c6c966149466d9899f2580706fce9ea31b1d9b1adc11e8325f7b366e10f994857f02fa06c11b4f1b5cd8c840b397f6a17f6e738099dcdf93a5adeaa3d3a431e8dec9539a6822b4a98aec86a1e4d574ac959ce56cf015960deab5ab2bbf9611dcf0dd64ea6e;

Константы C раундов R ₈

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

Представим их в виде массива, $C_{i+1}=$ round_const[i][0:255]

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'he6113be617f45f3de53cff03919a94c32c927b093ac8f23b47f7189aadb9bc67,
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'habd06c52ed58ff091205d0f627574c8cbc1fe7cf79210f5a2286f6e23a27efa0,
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'h3ca6cdd788a5bdc5ef2dceeb16bca31e0a0d2c7e9921b6f71d33e25dd2f3cf53,
round_const[39][0:255]=256'hf72578721db56bf8f49538b0ae6ea470c2fb1339dd26333f135f7def45376ec0,
round_const[40][0:255]=256'he449a03eab359e34095f8b4b55cd7ac7c0ec6510f2c4cc79fa6b1fee6b18c59e,
round_const[41][0:255]=256'h73bd6978c59f2b219449b36770fb313fbe2da28f6b04275f071a1b193dde2072;

Позиции полубайтов после перемешивания P ₈

Пусть на вход $P_{8}$ поступил 1024-битный вектор — массив из 256-ти 4-битных векторов: $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$ с номером позиции (от 0 до 255), содержащемся в первом байте константы permut_pose[0:2047] , второй полубайт выходного вектора — полубайту входного вектора с номером позиции, содержащемся во втором байте permut_pose[0:2047] , и т. д.

verilog-код

assign 
permut_pose[0:2047]=2048'h00030407080b0c0f10131417181b1c1f20232427282b2c2f30333437383b3c3f40434447484b4c4f50535457585b5c5f60636467686b6c6f70737477787b7c7f80838487888b8c8f90939497989b9c9fa0a3a4a7a8abacafb0b3b4b7b8bbbcbfc0c3c4c7c8cbcccfd0d3d4d7d8dbdcdfe0e3e4e7e8ebeceff0f3f4f7f8fbfcff020106050a090e0d121116151a191e1d222126252a292e2d323136353a393e3d424146454a494e4d525156555a595e5d626166656a696e6d727176757a797e7d828186858a898e8d929196959a999e9da2a1a6a5aaa9aeadb2b1b6b5bab9bebdc2c1c6c5cac9cecdd2d1d6d5dad9dedde2e1e6e5eae9eeedf2f1f6f5faf9fefd;

Используемые функции — адаптация к программной реализации при d=8

Суть этой адаптации заключается в минимизации числа операций путём использования операций с как можно более длинными операндами. Сделать это позволяют такие технологии, как, например, SIMD , SSE2 , AVX .

примеры реализации на языке C

Для пояснения работы функций, а также для того, чтобы показать константы раундов, будут приводиться куски кода на C . Будучи соединёнными в один файл и дополненными функцией main() , приведённой ниже, они компилируются ; полученная программа реализует функцию $E_{8}$ .

предварительные объявления на C

#include <emmintrin.h>
#include <stdlib.h>
#include <stdio.h>

typedef __m128i  word128;   /*word128 defines a 128-bit SSE2 word*/

/*define data alignment for different C compilers*/
#if defined(__GNUC__)
      #define DATA_ALIGN16(x) x __attribute__ ((aligned(16)))
#else
      #define DATA_ALIGN16(x) __declspec(align(16)) x
#endif

/*The following defines operations on 128-bit word(s)*/
#define CONSTANT(b)   _mm_set1_epi8((b))          /*set each byte in a 128-bit register to be "b"*/

#define XOR(x,y)      _mm_xor_si128((x),(y))      /*XOR(x,y) = x ^ y, where x and y are two 128-bit word*/
#define AND(x,y)      _mm_and_si128((x),(y))      /*AND(x,y) = x & y, where x and y are two 128-bit word*/
#define ANDNOT(x,y)   _mm_andnot_si128((x),(y))   /*ANDNOT(x,y) = (!x) & y, where x and y are two 128-bit word*/
#define OR(x,y)       _mm_or_si128((x),(y))       /*OR(x,y)  = x | y, where x and y are two 128-bit word*/

#define SHR1(x)       _mm_srli_epi16((x), 1)      /*SHR1(x)  = x >> 1, where x is a 128 bit word*/
#define SHR2(x)       _mm_srli_epi16((x), 2)      /*SHR2(x)  = x >> 2, where x is a 128 bit word*/
#define SHR4(x)       _mm_srli_epi16((x), 4)      /*SHR4(x)  = x >> 4, where x is a 128 bit word*/
#define SHR8(x)       _mm_slli_epi16((x), 8)      /*SHR8(x)  = x >> 8, where x is a 128 bit word*/
#define SHR16(x)      _mm_slli_epi32((x), 16)     /*SHR16(x) = x >> 16, where x is a 128 bit word*/
#define SHR32(x)      _mm_slli_epi64((x), 32)     /*SHR32(x) = x >> 32, where x is a 128 bit word*/
#define SHR64(x)      _mm_slli_si128((x), 8)      /*SHR64(x) = x >> 64, where x is a 128 bit word*/

#define SHL1(x)       _mm_slli_epi16((x), 1)      /*SHL1(x)  = x << 1, where x is a 128 bit word*/
#define SHL2(x)       _mm_slli_epi16((x), 2)    /*SHL2(x)  = x << 2, where x is a 128 bit word*/
#define SHL4(x)       _mm_slli_epi16((x), 4)    /*SHL4(x)  = x << 4, where x is a 128 bit word*/
#define SHL8(x)       _mm_srli_epi16((x), 8)    /*SHL8(x)  = x << 8, where x is a 128 bit word*/
#define SHL16(x)      _mm_srli_epi32((x), 16)   /*SHL16(x) = x << 16, where x is a 128 bit word*/
#define SHL32(x)      _mm_srli_epi64((x), 32)   /*SHL32(x) = x << 32, where x is a 128 bit word*/
#define SHL64(x)      _mm_srli_si128((x), 8)    /*SHL64(x) = x << 64, where x is a 128 bit word*/

Пример функции main()

int main()
{
	int j;
	void* e8_out;
	
	//here can be any constant you like to use for 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,0,0,0,0};
		

	e8_out=(void*)calloc(9,sizeof(word128));

	//16 byte allignment - important!
	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("\ninput\n");
	for (j = 0; j < 128; j++)
		printf("%.2x",(char)(*((char*)e8_out+j)) & 0xff);

	E8((word128*)e8_out);

        //out must be equal
        //2dfedd62f99a98acae7cacd619d634e7a4831005bc301216b86038c6c966149466d9899f2580706fce9ea31b1d9b1adc11e8325f7b366e10f994857f02fa06c11b4f1b5cd8c840b397f6a17f6e738099dcdf93a5adeaa3d3a431e8dec9539a6822b4a98aec86a1e4d574ac959ce56cf015960deab5ab2bbf9611dcf0dd64ea6e
	printf("\noutput\n");
	for (j = 0; j < 128; j++)
		printf("%.2x",(char)(*((char*)e8_out+j)) & 0xff);
	
	return(0);
}

Функция SBox

Преобразует четыре 128-битных вектора в зависимости от 128-битной константы. То есть

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

Алгоритм таков. Введём ещё 128-битную переменную t и проинициализируем переменные начальными значениями

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

тогда последовательность присваиваний следующая:

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

возможная реализация на C

/*Sbox implements S0 and S1, selected by a constant bit*/
#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));           \
     }

- описание используемых макросов см. в блоке

Функция LinTrans

Преобразует восемь 128-битных переменных. Пусть $(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}$

возможная реализация на C

/*The MDS code*/
#define LIN_TRANS(word)     \
      word[1] = XOR(word[1],word[2]);           \
      word[3] = XOR(word[3],word[4]);           \
      word[5] = XOR(XOR(word[5],word[6]),word[0]);   \
      word[7] = XOR(word[7],word[0]);           \
      word[0] = XOR(word[0],word[3]);           \
      word[2] = XOR(word[2],word[5]);           \
      word[4] = XOR(XOR(word[4],word[7]),word[1]);   \
      word[6] = XOR(word[6],word[1]);

В коде для удобства дальнейшего использования $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])

- описание используемых макросов см. в блоке

Функция Permutation

Преобразует 128-битную переменную в зависимости от целой константы $n:~6\geq n\geq 0$ . Эта функция не оптимизируется для использования 128-битных переменных, однако для совместного использования с другими функциями из этого раздела она необходима.

Пусть $b=Permutation(a,n)$ , $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

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

end

Здесь запись $Swap(p,q)$ означает такой участок алгоритма, после которого переменная $p$ принимает значение, которое было у переменной $q$ , а переменная $q$ принимает значение, которое было у переменной $p$ .

возможная реализация на C

/*The following defines operations on 128-bit word(s)*/
#define SWAP0(x)      OR(SHR1(AND((x),CONSTANT(0xaa))),SHL1(AND((x),CONSTANT(0x55))))  /*swapping bit 2i with bit 2i+1 of the 128-bit x */
#define SWAP1(x)      OR(SHR2(AND((x),CONSTANT(0xcc))),SHL2(AND((x),CONSTANT(0x33))))  /*swapping bit 4i||4i+1 with bit 4i+2||4i+3 of the 128-bit x */
#define SWAP2(x)      OR(SHR4(AND((x),CONSTANT(0xf0))),SHL4(AND((x),CONSTANT(0xf))))   /*swapping bits 8i||8i+1||8i+2||8i+3 with bits 8i+4||8i+5||8i+6||8i+7 of the 128-bit x */
#define SWAP3(x)      OR(SHR8(x),SHL8(x))                          /*swapping bits 16i||16i+1||...||16i+7 with bits 16i+8||16i+9||...||16i+15 of the 128-bit x */
#define SWAP4(x)     OR(SHR16(x),SHL16(x))                        /*swapping bits 32i||32i+1||...||32i+15 with bits 32i+16||32i+17||...||32i+31 of the 128-bit x */
#define SWAP5(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(2,3,0,1))  /*swapping bits 64i||64i+1||...||64i+31 with bits 64i+32||64i+33||...||64i+63 of the 128-bit x*/
#define SWAP6(x)     _mm_shuffle_epi32((x),_MM_SHUFFLE(1,0,3,2))  /*swapping bits 128i||128i+1||...||128i+63 with bits 128i+64||128i+65||...||128i+127 of the 128-bit x*/
#define STORE(x,p)    _mm_store_si128((__m128i *)(p), (x))         /*store the 128-bit word x into memeory address p, where p is the multile of 16 bytes*/
#define LOAD(p)       _mm_load_si128((__m128i *)(p))               /*load 16 bytes from the memory address p, return a 128-bit word, where p is the multile of 16 bytes*/

#define PERMUTATION(word,n)         \
      word[1] = SWAP##n(word[1]); word[3] = SWAP##n(word[3]); word[5] = SWAP##n(word[5]); word[7] = SWAP##n(word[7]);

- описание используемых макросов см. в блоке

Функция E ₈ , адаптированная к программной реализации

Преобразует 1024-битный вектор. Совпадает с функцией $E_{8}$ , описанной в обобщённом случае (в том смысле, что при совпадении значений аргументов совпадают значения функций). Пусть на вход поступил 1024-битный вектор. Представим его в виде набора 8-ми 128-битных переменных: $(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}^{odd})

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

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

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

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

end

Использующиеся 128-битные константы задаются следующим образом: $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\dots 42,~C_{0}=\left\lfloor ({\sqrt {2}}-1)\times 2^{256}\right\rfloor$

возможная реализация на C

/*42 round constants, each round constant is 32-byte (256-bit)*/
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,0x4e,0x9f,0x4f,0xc5,0xc3,0xd1,0x2b,0x40},
{0xea,0x98,0x3a,0xe0,0x5c,0x45,0xfa,0x9c,0x3,0xc5,0xd2,0x99,0x66,0xb2,0x99,0x9a,0x66,0x2,0x96,0xb4,0xf2,0xbb,0x53,0x8a,0xb5,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,0x95,0x1d,0x6f,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,0xaa,0x78,0x50,0x3f,0x1a,0xbf,0xd2,0x41,0x0,0x91,0xd3},
{0x42,0x2d,0x5a,0xd,0xf6,0xcc,0x7e,0x90,0xdd,0x62,0x9f,0x9c,0x92,0xc0,0x97,0xce,0x18,0x5c,0xa7,0xb,0xc7,0x2b,0x44,0xac,0xd1,0xdf,0x65,0xd6,0x63,0xc6,0xfc,0x23},
{0x97,0x6e,0x6c,0x3,0x9e,0xe0,0xb8,0x1a,0x21,0x5,0x45,0x7e,0x44,0x6c,0xec,0xa8,0xee,0xf1,0x3,0xbb,0x5d,0x8e,0x61,0xfa,0xfd,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,0x8a,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,0xe4,0x88,0xbc,0x82,0xb8,0x0,0x1e,0x98,0xa6,0xa3,0xf4},
{0x8e,0xf4,0x8f,0x33,0xa9,0xa3,0x63,0x15,0xaa,0x5f,0x56,0x24,0xd5,0xb7,0xf9,0x89,0xb6,0xf1,0xed,0x20,0x7c,0x5a,0xe0,0xfd,0x36,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,0x9d,0xad,0x81,0xaf,0xd8,0x5a,0x9f},
{0xa7,0x5,0x6,0x67,0xee,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,0xf1,0x9e,0x86,0x76,0x72,0x81,0x50,0x60,0x8d,0xd4,0x7e,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,0x55,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,0x44,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,0x20,0xe7,0x74,0xfe,0x43,0xe8,0x23,0xd4,0x87,0x8a},
{0x7d,0x29,0xe8,0xa3,0x92,0x76,0x94,0xf2,0xdd,0xcb,0x7a,0x9,0x9b,0x30,0xd9,0xc1,0x1d,0x1b,0x30,0xfb,0x5b,0xdc,0x1b,0xe0,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,0xd3,0x39,0x45,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,0x46,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,0x7b,0xd1,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,0xe4,0x4,0x6b,0xba,0xf6,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,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,0x3a,0xdb,0xa8,0xfa,0xc3,0x3b,0x4d,0x32,0x83,0x2c,0x83},
{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,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,0x5b,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,0x6d,0x6c,0x34,0xa5,0x50,0xb8,0x28,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,0x67,0xbb,0xd1,0x3c,0x2,0xe8,0x43,0xb0},
{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,0x44,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,0x86,0x60,0x4d,0x46,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,0x16,0x7e,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,0xcc,0xe6,0xa6,0xf3,0x17,0xa,0x75,0x5},
{0xb1,0x76,0x81,0xd9,0x13,0x32,0x6c,0xce,0x3c,0x17,0x52,0x84,0xf8,0x5,0xa2,0x62,0xf4,0x2b,0xcb,0xb3,0x78,0x47,0x15,0x47,0xff,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,0xf8,0x6f,0xa3,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,0xec,0x7c,0xab,0x27,0xb0,0x7e,0x53,0x8d,0x7d,0xda,0xaa,0x3e,0xa8,0xde},
{0xaa,0x25,0xce,0x93,0xbd,0x2,0x69,0xd8,0x5a,0xf6,0x43,0xfd,0x1a,0x73,0x8,0xf9,0xc0,0x5f,0xef,0xda,0x17,0x4a,0x19,0xa5,0x97,0x4d,0x66,0x33,0x4c,0xfd,0x21,0x6a},
{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}};

/*the round function of E8 */
#define ROUND_FUNCTION(word,n,r)\
	S_BOX(((word)[0]),((word)[2]),((word)[4]),((word)[6]),(LOAD(E8_bitslice_roundconstant[r]))) \
	S_BOX(((word)[1]),((word)[3]),((word)[5]),((word)[7]),(LOAD(E8_bitslice_roundconstant[r]+16))) \
	LIN_TRANS(word) \
	PERMUTATION((word),n)

void E8(word128 *word){
    int i;
    for (i = 0; i < 42; i = i+7) {
        ROUND_FUNCTION(word,0,i)
        ROUND_FUNCTION(word,1,i+1)
        ROUND_FUNCTION(word,2,i+2)
        ROUND_FUNCTION(word,3,i+3)
        ROUND_FUNCTION(word,4,i+4)
        ROUND_FUNCTION(word,5,i+5)
        ROUND_FUNCTION(word,6,i+6)
    }
}

- описание используемых макросов см. в подразделах выше.

Исходные данные

Входной параметр

$l_{hash}$ — длина хэша (число бит в выходном векторе хеш-функции).

Может принимать только следующие значения:

224, 256, 384 и 512;

напомним, что данная статья, строго говоря, описывает семейство из 4-х хеш-функций.

Входное сообщение

Представляет собой число — длину сообщения $L$ и битовый вектор $M_{0}$ (если $L\neq 0$ ). Даже если $L=0$ никаких трудностей для вычисления $JH(M_{0})$ не возникает.

Алгоритм вычисления JH(M ₀ )

1) Дополнение входного вектора

Присоединение к сообщению

M_{0}

дополнительных бит в конце. Происходит в три этапа:

1.1)Дополнение единицей.

Присоединение к концу сообщения единичного бита.

1.2)Дополнение нулями.

Присоединение к концу сообщения, дополненного единицей, нулевых бит в количестве

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

штук.

1.3)Дополнение длиной сообщения.

Присоединение к концу сообщения, дополненного единицей и нулями, 128 бит, в которых записана длина исходного сообщения (например, если

L=2

, то добавка будет выглядеть так:

0\dots 010

).

В итоге получится дополненное сообщение

M

с длиной, кратной

512

.

2) Свёртка дополненного входного вектора функцией $F_{8}$

M

разбивается на блоки по

512

бит. Обозначим за

N

число таких блоков.

Свёртка происходит за

N

итераций. На

i

-той итерации на вход

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})=\dots =F_{8}(\dots (H_{-1},M_{0})\dots )

.

H_{-1}

и

M_{0}

выбираются так: первые

16

бит

H_{-1}

равны входному параметру

l_{hash}

— размеру выходного хэша (для

l_{hash}

, равных

512,~324,~256

или

224

это соответственно 0200h, 0180h, 0100h или 00e0h), а остальные биты

H_{-1}

и все биты

M_{0}

задаются равными

0

.

3) Выборка хэша из выхода функции $F_{8}$

Из

1024

-битного вектора

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

, полученного на выходе

F_{8}

на последней итерации свёртки дополненного входного сообщения, выбираются последние

l_{hash}

бит:

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

Криптоанализ

См. также

Примечания

сравнение финалистов второго тура SHA по параметрам реализации на различных ПЛИС от 23 августа 2011 на Wayback Machine
алгоритм взят здесь: от 10 ноября 2011 на Wayback Machine
Эти куски взяты по адресу от 4 декабря 2011 на Wayback Machine и изменены для ясности и простоты.
При использовании компилятора gcc для того, чтобы он подразумевал возможность использования дополнительных командных наборов, поддерживаемых процессором, типа SSE2 , в командную строку при компиляции можно добавить опцию -march=native (например "gcc -o prog prog.c -Wall -march=native" ).

Ссылки

документация, актуальная в ноябре 2011 года
- от 10 ноября 2011 на Wayback Machine
варианты исходных кодов на VHDL моделей электронных устройств, реализующих JH:
варианты исходных кодов на C, реализующих JH:
- от 4 ноября 2011 на Wayback Machine
- от 11 августа 2011 на Wayback Machine
- от 4 декабря 2011 на Wayback Machine
страница автора для поддержки JH
- от 4 декабря 2011 на Wayback Machine
ссылки на исследования криптоаналитиков и архивы файлов, отправлявшиеся на конкурс SHA-3
ссылки на архивы с исходными кодами на VHDL (и сопутствующими файлами) моделей электронных устройств, реализующих алгоритмы хеш-функций, прошедших во второй тур SHA-3
ссылки на исследования характеристик электронных устройств (реализованных на ПЛИС), реализующих алгоритмы хеш-функций, прошедших в финал второго тура SHA-3

[1] сравнение финалистов второго тура SHA по параметрам реализации на различных ПЛИС от 23 августа 2011 на Wayback Machine

[2] алгоритм взят здесь: от 10 ноября 2011 на Wayback Machine

[3] Эти куски взяты по адресу от 4 декабря 2011 на Wayback Machine и изменены для ясности и простоты.

[4] При использовании компилятора gcc для того, чтобы он подразумевал возможность использования дополнительных командных наборов, поддерживаемых процессором, типа SSE2 , в командную строку при компиляции можно добавить опцию -march=native (например "gcc -o prog prog.c -Wall -march=native" ).

Хеш-функции
Общего назначения	Adler-32 CRC Контрольная сумма Флетчера FNV MurmurHash2 PJW-32 TTH - Дерево хешей Jenkins hash Хеш-сумма
Криптографические	ГОСТ Р 34.11-94 Стрибог BelT BLAKE Blue Midnight Wish CubeHash ECHO Edonkey2k FSB Fugue Grøstl HAVAL Hamsi Kupyna LM-хеш Luffa MASH-1 MD2 MD4 MD5 MD6 N-Hash RIPEMD-128 RIPEMD-160 RIPEMD-256 RIPEMD-320 SHA-1 SHA-2 SHA-3 (Keccak) SHABAL SHAvite-3 SIMD SWIFFT Skein Snefru Tiger Whirlpool
Функции формирования ключа	bcrypt PBKDF2 scrypt Argon2 Lyra2
Контрольное число ( сравнение )	Контрольная сумма Алгоритм Верхуффа Алгоритм Дамма Алгоритм Луна Штрих-код Банковских счетов Банковских карт ISIN СНИЛС ОКПО ИНН ОКАТО ISBN ОГРН и ОГРНИП VIN
Применение хешей	Сравнение контрольных чисел Коллизия хеш-функции Протоколы аутентификации Сравнение штрихкодов Криптография Magnet-ссылка Подпись Меркла ed2k URN

Алгоритм

Уточнения

О названии элементов битовых векторов

Обозначение конкатенации

Используемые функции — обобщённый случай

S-box — .mw-parser-output .ts-math{white-space:nowrap;font-family:times,serif,palatino linotype,new athena unicode,athena,gentium,code2000;font-size:120%} S i(x)

Линейное преобразование пар ячеек — L(A,B)

Перемешивание — P d

Преобразование-раунд — R d (A,C)

Преобразование E d

Функция свёртки F d (H,M)

Используемые функции — адаптация к аппаратной реализации при d=8

Выражение преобразования L через простые операции с битами

Константы H 0 при разных l hash

Константы C раундов R 8

Позиции полубайтов после перемешивания P 8

Используемые функции — адаптация к программной реализации при d=8

примеры реализации на языке C

Функция SBox

Функция LinTrans

Функция Permutation

Функция E 8 , адаптированная к программной реализации

Исходные данные

Входной параметр

Входное сообщение

Алгоритм вычисления JH(M 0 )

Криптоанализ

См. также

Примечания

Ссылки

Сегрия

Липшиц, Жак

Пэктусан

Same as JH

Сегрия

Липшиц, Жак

Пэктусан

Лаврентий (Стреза)

Двенадцатая поправка к Конституции США

Войсковой старшина

Курдистан

Улица Станиславского (Москва)

Гранкин, Сергей Юрьевич

Крелин, Юлий Зусманович

Лоскутный переулок

Вертеба

FDDI

Борисов, Сергей Борисович

Сербское имя

Мот, Флоран

12 июня

Харрисон, Билли

Тынковка

Исламский фундаментализм

Локхарт Стэдиум

Синдром Конна

Фруассар, Жан

31 августа

Сена, Лев Аронович

Мармолехо

Круонисская ГАЭС

Невелева, Светлана Леонидовна

Антигорит

1981 год

Бронхоэктатическая болезнь

Городские населённые пункты Томской области

Пинакоциты

Китайский веслонос

Фракийский язык

Йота (кириллица)

1161 год

Знамение (икона)

Чародейки

Список доменов верхнего уровня

Курение каннабиса

Макларен (автогоночная команда)

Велес Сарсфилд

Кинф

Айтматов, Чингиз Торекулович

Радио и телевидение Брунея

S-box — S _i(x)

Перемешивание — P _d

Преобразование-раунд — R _d (A,C)

Преобразование E _d

Функция свёртки F _d (H,M)

Константы H ₀ при разных l _hash

Константы C раундов R ₈

Позиции полубайтов после перемешивания P ₈

Функция E ₈ , адаптированная к программной реализации

Алгоритм вычисления JH(M ₀ )