WikiSort.ru - Не сортированное

Функция ${\displaystyle F_{k}^{3}}$

Функция ${\displaystyle F_{k}^{3}(x)}$ принимает на вход 128-битный текст ${\displaystyle x}$ и 384-битный ключ ${\displaystyle k}$ , который получается объединением трех 128-битных ключей ${\displaystyle k=(k^{0},k^{1},k^{2})}$ . Она заключается в троекратном применении раунда AES: ${\displaystyle F_{(k_{i}^{0},k_{i}^{1},k_{i}^{2})}^{3}(x)=AESRound_{0}(AESRound_{k_{i}^{2}}(AESRound_{k_{i}^{1}}(x\oplus k_{i}^{0})))}$ . Входной вектор ${\displaystyle x}$ складывается по модулю 2 с ключом ${\displaystyle k_{i}^{0}}$ , к результату применяются три раунда AES с разными ключами в следующем порядке: раунд AES с ключом ${\displaystyle k_{i}^{1}}$ , ещё один раунд AES с ключом ${\displaystyle k_{i}^{2}}$ , последний раунд с ключом 0 (128 бит).

Генерация ключей для ${\displaystyle E^{256}}$

Для вычисления функции ${\displaystyle E^{256}}$ требуется по три 128-битных ключа в каждом из 12 раундов. Для этого используется алгоритм генерации ключей из одного ключа. В качестве единственного ключа, из которого впоследствии будут созданы 36, используется совокупность блока сообщения (512 бит), соли (256 бит) и битового счетчика (64 бита). В алгоритме все операции производятся над 4-байтными значениями. Введем следующие обозначения:

• ${\displaystyle msg[0],...,msg[15]}$  — блок сообщения;
• ${\displaystyle cnt[0],cnt[1]}$  — битовый счетчик;
• ${\displaystyle salt[0],...,salt[7]}$  — соль.

В результате работы алгоритма получаем 144 значения (также 4-байтных):

• ${\displaystyle rk[0],...,rk[143]}$

// Алгоритм генерации ключей для E^256 на языках C/C++

// Первые 16 значений результирующего массива 
// проинициализировать исходным сообщением
for (int i = 0; i < 16; i++) rk[i] = msg[i];
int i = 16;
for (int k = 0; k < 4; k++) {
    uint32_t t[4];
    // Нелинейный шаг
    for (int r = 0; r < 2; r++) {
        // Выполнить раунд AES с ключем 0 над 128-битным значением,
        // которое является суммой по модулю 2 ранее вычисленных элеменов 
        // массива rk и соли (0-127 биты).
        // 128-битный результат записать в массив t
        AESRound0(
            rk[i-15]^salt[0], rg[i-14]^salt[1], rk[i-13]^salt[2], rk[i-16]^salt[3], 
            &t[0], &t[1], &t[2], &t[3]
        );
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 16) { rk[16] ^= cnt[0]; rk[17] ^= ~cnt[1]; }
        if (i == 56) { rk[16] ^= cnt[1]; rk[17] ^= ~cnt[0]; }
        i += 4;
        // Такой же раунд AES, как и ранее, 
        // но с оставшейся частью соли (128-255 биты)
        AESRound0(
            rk[i-15]^salt[4], rg[i-14]^salt[5], rk[i-13]^salt[6], rk[i-16]^salt[7], 
            &t[0], &t[1], &t[2], &t[3]
        );
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 84) { rk[86] ^= cnt[1]; rk[87] ^= ~cnt[0]; }
        if (i == 124) { rk[124] ^= cnt[0]; rk[127] ^= ~cnt[1]; }
        i += 4;
    }
    // Линейный шаг
    for (int r = 0; r != 16; ++r) {
        rk[i] = rk[i-16] ^ rk[i-3];
        i += 1;
    }
}

Представленный выше алгоритм — модифицированная авторами версия. Единственное отличие от изначально отправленного на конкурс SHA-3 варианта — наличие операций побитового отрицания «~» счетчика${\displaystyle (cnt[0],cnt[1])}$ . Отрицание было добавлено, чтобы увеличить криптографическую стойкость хеш-функции. Наличие таких операций дает гарантию, что по крайней мере 4 из 8 байт счетчика будут ненулевыми^[2].

Ключи ${\displaystyle RK_{i}=(k_{i}^{0},k_{i}^{1},k_{i}^{2})}$ для вычисления функции ${\displaystyle E^{256}}$ получаются из ${\displaystyle rk[0],...,rk[143]}$ следующим образом:${\displaystyle k_{i}^{j}=(rk[y_{i}^{j}],rk[y_{i}^{j}+1],rk[y_{i}^{j}+2],rk[y_{i}^{j}+3])}$ , где ${\displaystyle y_{i}^{j}=12*i+4*j}$ , ${\displaystyle i\in [0,12),j\in [0,2)}$ .

Функция ${\displaystyle F_{k}^{4}}$

Принимает на вход 128 бит текста ${\displaystyle x}$ и 512-битный ключ ${\displaystyle k=(k^{0},k^{1},k^{2},k^{3})}$ . Вычисляется как 4 раунда AES. ${\displaystyle F_{(k_{i}^{0},k_{i}^{1},k_{i}^{2},k_{i}^{3})}^{4}(x)=AESRound_{0}(AESRound_{k_{i}^{3}}(AESRound_{k_{i}^{2}}(AESRound_{k_{i}^{1}}(x\oplus k_{i}^{0}))))}$ .

Генерация ключей для ${\displaystyle E^{512}}$

Для вычисления функции ${\displaystyle E^{512}}$ требуется по восемь 128-битных ключей в каждом из 14 раундов. Всего — 112 ключей. Они составляются на основе блока сообщения (1024 бита), соли (512 бит) и битового счетчика (128 бита). Все операции производятся над 4-байтными значениями. Введем следующие обозначения:

• ${\displaystyle msg[0],...,msg[31]}$  — блок сообщения
• ${\displaystyle cnt[0],...,cnt[3]}$  — битовый счетчик
• ${\displaystyle salt[0],...,salt[15]}$  — соль

В результате работы алгоритма получаем 448 значений (4-байтных):

• ${\displaystyle rk[0],...,rk[447]}$

// Алгоритм генерации ключей для E^512 на языках C/C++

// Первые 32 значений результирующего массива 
// проинициализировать исходным сообщением
for (int i = 0; i < 32; i++) rk[i] = msg[i];
int i = 32;
for (int k = 0; k < 7; k++) {
    uint32_t t[4];
    // Нелинейный шаг (7 раз)
    for (int r = 0; r < 2; r++) {
        AESRound0(
            rk[i-31]^salt[0], rg[i-30]^salt[1], rk[i-29]^salt[2], rk[i-32]^salt[3], 
            &t[0], &t[1], &t[2], &t[3]); // Раунд AES с ключем 0, соль 0-3
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 32) { rk[32] ^= cnt[0]; rk[33] ^= cnt[1]; 
                       rk[34]^= cnt[2]; rk[35] ^= ~cnt[3]; }
        i += 4;
        AESRound0(
            rk[i-31]^salt[4], rg[i-30]^salt[5], rk[i-29]^salt[6], rk[i-32]^salt[7], 
            &t[0], &t[1], &t[2], &t[3]); // Раунд AES с ключем 0, соль 4-7
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 164) { rk[164] ^= cnt[3]; rk[165] ^= cnt[2];
                        rk[166] ^= cnt[1]; rk[167] ^= ~cnt[0]; }
        i += 4;
        AESRound0(
            rk[i-31]^salt[8], rg[i-30]^salt[9], rk[i-29]^salt[10], rk[i-32]^salt[11], 
            &t[0], &t[1], &t[2], &t[3]); // Раунд AES с ключем 0, соль 8-11
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 440) { rk[440] ^= cnt[1]; rk[441] ^= cnt[0]; 
                        rk[442]^= cnt[3]; rk[443] ^= ~cnt[2]; }
        i += 4;
        AESRound0(
            rk[i-31]^salt[12], rg[i-30]^salt[13], rk[i-29]^salt[14], rk[i-32]^salt[15], 
            &t[0], &t[1], &t[2], &t[3]); // Раунд AES с ключем 0, соль 12-15
        for (int j = 0; j < 4; j++) rk[i+j] = t[j] ^ rk[i+j-4];
        if (i == 316) { rk[316] ^= cnt[2]; rk[317] ^= cnt[3];
                        rk[318] ^= cnt[0]; rk[319] ^= ~cnt[1]; }
        i += 4;
    }
    if (k == 6) break; // не совершать 7 линейный шаг
    // Линейный шаг (6 раз)
    for (int r = 0; r != 32; ++r) {
        rk[i] = rk[i-32] ^ rk[i-7];
        i += 1;
    }
}

Здесь, как и в 256-битной версии, единственное отличие улучшенной версии от первоначально отправленной на конкурс SHA-3 — наличие операций побитового НЕ «~» перед значениями счетчика. Наличие таких операций дает гарантию, что по крайней мере 4 из 16 байт счетчика ${\displaystyle (cnt[0],cnt[1],cnt[2],cnt[3])}$ будут ненулевыми^[2].

Далее ключи ${\displaystyle RK_{p,i}=(k_{p,i}^{0},k_{p,i}^{1},k_{p,i}^{2},k_{p,i}^{3})}$ для вычисления функции ${\displaystyle E^{512}}$ получаются из ${\displaystyle rk[0],...,rk[447]}$ следующим образом:${\displaystyle k_{p,i}^{j}=(rk[y_{p,i}^{j}],rk[y_{p,i}^{j}+1],rk[y_{p,i}^{j}+2],rk[y_{p,i}^{j}+3])}$ , где ${\displaystyle y_{p,i}^{j}=32*i+16*p+4*j}$ , ${\displaystyle i\in [0,14),p\in [0,2),j\in [0,4)}$ .