Основи криптографічного захисту інформації

Размещено на http://www.allbest.ru/

МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ

ХАРКІВСЬКИЙ НАЦІОНАЛЬНИЙ УНІВЕРСИТЕТ РАДІОЕЛЕКТРОНІКИ

КАФЕДРА «ТЕЛЕКОМУНІКАЦІЙНІ СИСТЕМИ ТА МЕРЕЖІ»

ПОЯСНЮВАЛЬНА ЗАПИСКА

До курсового проекту по курсу:

«Основи криптографічного захисту інформації»

Виконала: Перевірила:

ст. гр. УІБ-13-1 Локтіонова А.С.

Мазниченко В. А.

Харків 2015

ТЕХНІЧНЕ ЗАВДАННЯ

Варіант завдання курсової роботи № 3

Вихідні дані, відповідні 15 варіанту:

1) Реалізувати мовою C ++ хеш-функції SHA- 2-256, SHA-2-384, SHA-2-512.

2) Перевірити коректність роботи функції з використанням тестових векторів.

3) Провести порівняльний аналіз використовуваних алгоритмів. Оцінити продуктивність програмної реалізації та криптографічний стійкість даних систем при їх реалізації. Зробити висновки.



РЕФЕРАТ

Пояснювальна записка до курсової роботи містить 35 сторінок; Малюнків 1; Таблиць; Надіслання.

Мета курсової роботи -вивчення можливостей шифрування інформації за допомогою сімейства SHA-2.

Об'єкт дослідження - криптографічні методи захисту інформації.

Предмет дослідження - криптографія з використанням хеш-функцій сімейства SHA-2.



ЗМІСТ

ВСТУП

1. ХЕШ-ФУНКЦІЯ SHA-2

2. ХАРАКТЕРИСТИКА ОСНОВНИХ ВАРІАНТІВ SHA-2 І SHA1

2.1 Алгоритм перетворення SHA-2

3. ОБЧИСЛЕННЯ ЦИФРОВОГО ВІДБИТКА

3.1 Обчислення цифрового відбитка у SHA-384

3.2 Обчислення цифрового відбитка у SHA- 256

3.3 Обчислення цифрового відбитка у SHA-512

ВИСНОВКИ

ПЕРЕЛІК ВИКОРИСТАНИХ ДЖЕРЕЛ



ВСТУП

На сучасному етапі розвитку обчислювальної техніки і можливості проведення криптоаналізу з використанням розподілених інформаційних систем, багатьом телекомунікаційним додаткам потрібні більш висока стійкість і відповідність використовуваних механізмів захисту (як шифрування, так і формування цифрових відбитків). Тому після введення нових стандартів шифрування (AES конкурс, Нессі) і переходу на більш високі розрядності чисел в асиметричної криптографії було прийнято рішення про зміну механізму вироблення цифрових відбитків і заміні стандарту Secure Hash Standard (FIPS 180-2). В результаті був розроблений набір алгоритмів SHA-2, який дозволяє формувати відбитки завдовжки 256 і 512 бітів (а також проміжні варіанти на їх основі: 224, 320 і 384 бітів). У стандарті FIPS-180-2 описується використання трьох варіантів SHA-2.



1. ХЕШ-ФУНКЦІЯ SHA-2

SHA-2 - збірна назва односторонніх хеш-функцій SHA-224, SHA-256, SHA-384 і SHA-512. Хеш-функції призначені для створення «відбитків» або «дайджестів» повідомлень довільної бітової довжини. Застосовуються в різних додатках або компонентах, пов'язаних із захистом інформації.

Рисунок 1.1 Схема однієї ітерації алгоритмів SHA-2

Початкове повідомлення після доповнення розбивається на блоки, кожен блок - на 16 слів. Алгоритм пропускає кожен блок повідомлення через цикл з 64-ма чи 80-ма ітераціями (раундами). На кожній ітерації 2 слова перетворюються, функцію перетворення задають інші слова. Результати обробки кожного блоку складаються, сума є значенням хеш-функції.

Алгоритм використовує такі бітові операції:

ѕ  - Конкатенація,

ѕ  - Додавання,

ѕ And - Побітове «І»,

ѕ Or - Побітове «АБО»,

ѕ Xor - Виключне «АБО»,

ѕ Shr (Shift Right) - Логічний зсув вправо,

ѕ Rotr (Rotate Right) - Циклічний зсув вправо.

У наступній таблиці показані деякі технічні характеристики різних варіантів SHA-2. «Внутрішній стан» означає проміжну хеш-суму після обробки чергового блоку даних:

Табл. 1.1 Технічні характеристики SHA-2

Геш-функція	Довжина дайджесту повідомлення (біт)	Довжина внутрішнього стану (біт)	Довжина блоку (біт)	Максимальна довжина повідомлення (біт)	Довжина слова (біт)	Кількість ітерацій в циклі
SHA-256/224	256/224	256	512	2 64 - 1	32	64
SHA-512/384	512/384	512	1024	2 128 - 1	64	80

1.2 В 2003 році Гілберт і Хандшух досліджували SHA-2, але не знайшли будь-яких вразливостей^[6]. Проте в березні 2008 року індійські дослідники Сомітра Кумар Санада і Палаш Саркар опублікували знайдені ними колізії для 22 ітерацій SHA-256 і SHA-512 . У вересні того ж року вони представили метод конструювання колізій для усічених варіантів SHA-2 (21 ітерація)^[8].

Криптоаналіз геш-функції досліджує стійкість алгоритму, щонайменше, до наступних видів атак:

ѕ Знаходження колізій, тобто різних повідомлень з однаковим хешем.

ѕ Знаходження прообразу, тобто невідомого повідомлення за його гешем.

Від стійкості геш-функції до знаходження колізій залежить безпека електронного цифрового підпису з використанням цього геш-алгоритму. Від стійкості до знаходження прообразу залежить безпека зберігання хешів паролів для аутентифікації.

Зважаючи на алгоритмічну схожість SHA-2 зі SHA-1 і наявність в останньої потенційних вразливостей шукаються кращі альтернативи . Новий стандарт називатиметься SHA-3, його визначать на конкурсі, який проводитиме Національний інститут стандартів і технологій в 2008-2012 роках^[11].



2 ХАРАКТЕРИСТИКА ОСНОВНИХ ВАРІАНТІВ SHA-2

Табл. 2.1 Порівняльна характеристика основних варіантів SHA-2 и SHA-1

Алгоритми	Розмір повідомлення бітов	Розмір блока, бітов	Розмір слова, бітов	Довжина цифрового відбитка, бітов	Рівень безпеки, бітов
SHA-1		512	32	160	80
SHA-256		512	32	256	128
SHA-384		1024	64	384	192
SHA-512		1024	64	512	256

2.1 Алгоритм перетворення SHA-2

Операцією, яка передує безпосередньо перетворенням даних, є формування заповнювача. Для SHA-256 біти заповнювач формуються таким же чином, що і для SHA-1, а для SHA-384 і SHA-512 алгоритм незначно відрізняється:

ѕ визначаємо довжину повідомлення M, яка буде дорівнювати l бітів;

ѕ додаємо одиничний біт в кінець повідомлення, а потім k нульових бітів, де k - найменше невід'ємне рішення порівняння;

ѕ (2.1)

ѕ додаємо 128-бітовий блок, який еквівалентний числу l, вираженого з використанням двійкового представлення.

В результаті довжина доповненого вихідного повідомлення кратна 1024.

Для SHA-384 і SHA-512 доповнене повідомлення ділитися на N 1024-бітових блоку , ,..., .Такий блок виражається шістнадцятьма 64-бітовими блоками: перші 64 біта блоку повідомлення , наступні - і до .

Табл. 2.2 Шістнадцяткове уявлення констант SHA-2-512

428a2f98d728ae22	7137449123ef65cd	b5c0fbcfec4d3b2f	e9b5dba58189dbbc
3956c25bf348b538	59f111f1b605d019	923f82a4af194f9b	ab1c5ed5da6d8118
d807aa98a3030242	12835b0145706fbe	243185be4ee4b28c	550c7dc3d5ffb4e2
72be5d74f27b896f	80deb1fe3b1696b1	9bdc06a725c71235	c19bf174cf692694
e49b69c19ef14ad2	efbe4786384f25e3	0fc19dc68b8cd5b5	240ca1cc77ac9c65
2de92c6f592b0275	4a7484aa6ea6e483	5cb0a9dcbd41fbd4	76f988da831153b5
983e5152ee66dfab	a831c66d2db43210	b00327c898fb213f	bf597fc7beef0ee4
c6e00bf33da88fc2	d5a79147930aa725	06ca6351e003826f	142929670a0e6e70
27b70a8546d22ffc	2e1b21385c26c926	4d2c6dfc5ac42aed	53380d139d95b3df
650a73548baf63de	766a0abb3c77b2a8	81c2c92e47edaee6	92722c851482353b
a2bfe8a14cf10364	a81a664bbc423001	c24b8b70d0f89791	c76c51a30654be30
d192e819d6ef5218	d69906245565a910	f40e35855771202a	106aa07032bbd1b8
19a4c116b8d2d0c8	1e376c085141ab53	2748774cdf8eeb99	34b0bcb5e19b48a8
391c0cb3c5c95a63	4ed8aa4ae3418acb	5b9cca4f7763e373	682e6ff3d6b2b8a3
748f82ee5defb2fc	78a5636f43172f60	84c87814a1f0ab72	8cc702081a6439ec
90befffa23631e28	a4506cebde82bde9	bef9a3f7b2c67915	c67178f2e372532b
ca273eceea26619c	d186b8c721c0c207	eada7dd6cde0eb1e	f57d4f7fee6ed178
06f067aa72176fba	0a637dc5a2c898a6	113f9804bef90dae	1b710b35131c471b
28db77f523047d84	32caab7b40c72493	3c9ebe0a15c9bebc	431d67c49c100d4c
4cc5d4becb3e42b6	597f299cfc657e2a	5fcb6fab3ad6faec	6c44198c4a475817

Потім встановлюємо початкове значення хеша Розмір і кількість слів у залежить від розміру цифрового відбитка:

SHA-256:

= 0x6a09e667, = 0xbb67ae85, = 0x3c6ef372, = 0xa54ff53a,

= 0x510e527f, = 0x9b05688c, = 0x1f83d9ab, = 0x5be0cd19.

Ці слова представляють перші тридцять два біта дробової частини кубічних коренів перших 8 простих чисел.

SHA-512:

= 0x6a09e667f3bcc908, = 0xbb67ae8584caa73b,

= 0x3c6ef372fe94f82b, = 0xa54ff53a5f1d36f1,

= 0x510e527fade682d1, = 0x9b05688c2b3e6c1f,

= 0x1f83d9abfb41bd6b, = 0x5be0cd19137e2179.

Ці слова представляють перші 64 біта дробової частини кубічних коренів перших 8 простих чисел.

SHA-256 использует последовательность из 64 32-битовых слов , ,..., . Эти слова представляют первые тридцать два бита дробной части кубических корней первых 64 простых чисел.

Табл. 2.3 Шістнадцяткове уявлення констант SHA-256

428a2f98	71374491	b5c0fbcf	e9b5dba5	3956c25b	59f111f1	923f82a4	ab1c5ed5
d807aa98	12835b01	243185be	550c7dc3	72be5d74	80deb1fe	9bdc06a7	c19bf174
e49b69c1	efbe4786	0fc19dc6	240ca1cc	2de92c6f	4a7484aa	5cb0a9dc	76f988da
983e5152	a831c66d	b00327c8	bf597fc7	c6e00bf3	d5a79147	06ca6351	14292967
27b70a85	2e1b2138	4d2c6dfc	53380d13	650a7354	766a0abb	81c2c92e	92722c85
a2bfe8a1	a81a664b	c24b8b70	c76c51a3	d192e819	d6990624	f40e3585	106aa070
19a4c116	1e376c08	2748774c	34b0bcb5	391c0cb3	4ed8aa4a	5b9cca4f	682e6ff3
748f82ee	78a5636f	84c87814	8cc70208	90befffa	a4506ceb	bef9a3f7	c67178f2

SHA-384 и SHA-512 використовують таку ж послідовність 80 64-битовых слів , , ..., . Ці слова представляють перші 64 біта дробової частини кубічних коренів перших 80 простих чисел.

Для SHA-512 схема буде схожою, але використовує інші базові функції перетворення

SHA-512.

= 0x6a09e667f3bcc908, = 0xbb67ae8584caa73b,

= 0x3c6ef372fe94f82b, = 0xa54ff53a5f1d36f1,

= 0x510e527fade682d1, = 0x9b05688c2b3e6c1f,

= 0x1f83d9abfb41bd6b, = 0x5be0cd19137e2179.

Ці слова виходять шляхом взяття перших 64 бітів двійкового представлення дробової частини квадратних коренів перших восьми простих чисел.



3. ОБЧИСЛЕННЯ ЦИФРОВОГО ВІДБИТКА

3.1 Обчислення цифрового відбитка у SHA-384

Алгоритм хешування SHA-384 може бути використаний для отримання цифрового відбитка повідомлення , що має довжину l бітів, де Алгоритм аналогічний SHA-512, за винятком двох моментів:

Початкове хеш-значення складається з восьми 64-бітових слів

= cbbb9d5dc1059ed8 = 629a292a367cd507 = 9159015a3070dd17 = 152fecd8f70e5939

= 67332667ffc00b31 = 8eb44a8768581511 = db0c2e0d64f98fa7 = 47b5481dbefa4fa4

Ці слова виходять шляхом взяття перших 64 бітів дрібних частин квадратних коренів з дев'ятого по шістнадцяте просте число.

384-бітовий цифровий відбиток виходить шляхом «обрізки» кінцевого значення хеша для SHA-512:

.

3.2 Обчислення цифрового відбитка у SHA- 256

інформація захист криптографічний

Після установки початкового значення хеша запускається ітеративний алгоритм обробки та стиснення вхідних даних.

Алгоритм обчислення цифрового відбитка в SHA-256 виглядає наступним чином:

Крок 1. Підготовка допоміжних змінних на основі повідомлення , i-й блок повідомлення за допомогою наведеного далі алгоритму перетворюється з 16 слів розміром в 32 розряда (с М₀⁽ⁱ⁾ по М₁₅⁽ⁱ⁾) в 64 слова розміром 32 розряда (с W₀ по W₆₃):

(3.1)

де,

- 32-бітні блоки;

W_t - повідомлення;

(х) - базова функція перетворення, яку використовує SHA-256:

;

- базова функція перетворення, яку використовує SHA-256:

;

ROTR^k (х) - обертання (циклічний зсув) вправо слова х на k бітових позицій;

SHR^k (х) - зсув вправо слова x на k бітових позицій.

Крок 2. Ініціалізація восьми робочих змінних , , , , , , и для -го проміжного значення хешу:

, , , , , , , , (3.6)

де:- вісім 32-бітних слова.

Крок 3. Нелінійні перетворення блоків (елементарна операція) (64 рази):

;

;, (3.2)

де,

K _t - константи;

-базова функція перетворення,

;

- базовая функція перетворення , .

, (3.3)

де,

- базова функція перетворення,

;

- базовая функція перетворення, .

; ; ; ; ; ; ; .

Крок 4. Вычисление i-го проміжного значення хешу :

; ; ; ;

; ; ; ;

Після повторення кроків N разів (т.е. полної обробки M^(N)) результуючий 256-бітовий цифровий відбиток повідомлення M формується як

(8 слов * 32 бита = 256 бит),

де || - оператор конкантенації.

Рисунок 3.1- Схема обчислення цифрового відбитка в SHA-256

В алгоритмі використовуються наступні базові функції перетворення:

,

,

,

,

,

де,

- обертання вправо слова x на k бітових позицій;

- зрушення вправо слова x на k бітових позицій.

3.3 Обчислення цифрового відбитка у SHA-512

Після установки початкового значения хэша запускається ітеративний алгоритм обробки та стиснення вихідних даних, який однаковий для SHA- 384 і SHA -512 .

Алгоритм обчислення цифрового відбитка в SHA-512 виглядає наступним чином:

Крок 1. Підготовка допоміжних змінних на основі повідомлення :

(3.4)

де,

- 64-бітові блоки;

W_t - повідомлення;

(х) - базова функція перетворення, яку використовує SHA-512:

(х) = ;

- базова функція перетворення, яку використовує SHA-512:

= ;

ROTR^k (х) - обертання (циклічний зсув) вправо слова на бітових позицій;

SHR^k (х) - зсув вправо слова на бітових позицій.

Крок 2. Ініціалізація восьми робочих змінних , , , , , , та -м проміжним значенням хеша: , , , ,,,,. (3.5)

где: - вісім 64-бітних слова.

Крок 3. Нелінійні перетворення блоків (елементарна операція) (80 разів):

, (3.6)

де,

- константи;

- базовая функція перетворення,

= .

), (3.7)

де,

- базовая функція перетворення, .

; ; ; ; ; ; ; .

Тут базові функції перетворення та аналогічні SHA-256, але використовують 64-бітові слова в якості параметрів і виходу.

Крок 4. Обчислювання i-го проміжного значення хеша :

; ; ; ;

; ; ; . (3.13)

Після повторення шагів разів (т.е. повної обробки M^(N)) результуючий хеш для M формується як

(8 слів * 64 біта = 512 біт) ,

де || - оператор конкантенації.

Після повторення кроків раз (т.б. повної обробки ) результуючий хеш для формуєтся як

,

де оператор конкатенації (сцеплення). Тут базові функції перетворення і аналогічні SHA-256, але використовують 64-бітові слова в якості параметрів і виходу. Усі інші функції визначаються наступним чином:

,

,

,

,

де,

- обертання вправо слова на бітовых позицій,

а - зсув вправо слова на бітових позицій.

Схема розрахунків елементарної операції для SHA-256 представлена на рис. 3.1. Для SHA-512 схема буде схожою, але використовуючою інші базові функції перетворення.



ВИСНОВКИ

Всі три SHA-2 основані на одних і тих же операціях, із зростанням довжини хешу зменшується ймовірність колізії, в іншому вони сильно схожі. 256-бітна версія оперує 32 -бітовимі цілими і обробляє блоки даних в 512 біт, старші версії - 64-бітними цілими і блоками в 1024 біт. Так само в старших версіях більше раундів через більшу блоку, відрізняються і максимальні довжини хешіруемих повідомлень (у старших версій значно більше). Але навіть 264 біт (для 256- бітної версії) цілком прийнятна довжина, достатня для майже будь-яких (якщо не будь-яких) завдань.

SHA-2 частково засновані на ненадійною SHA-1, тому можуть містити уразливості, проте їх поки не знайшли, найефективніші атаки розкривають 21 раунд (з 64 для 256 і 80 для старших).

Всі чотири алгоритма значно відрізняються числом бітів рівня безпеки, що робить можливим вибирати шифрующие і хешірующіе перетворення еквівалентними по стійкості. При цьому слід зауважити, що в перетвореннях SHA-1 і SHA-256 оперують 32-бітовими словами, а SHA-384 і SHA-512 оперують 64-бітовими словами.



ПЕРЕЛІК ВИКОРИСТАНИХ ДЖЕРЕЛ

1. Персиков А.В., Поповський В.В. Основи криптографічного захисту інформації в телекомунікаційних системах. Частина 2. - Х .: Компанія СМІТ, 2010. - 296 с

2. Брюс Шнайер.Прікладная криптографія 2-е видання. Протоколи, алгоритми і вихідні тексти на мові С.

3. Нечаєв В. І. Елементи криптографії.



ДОДАТОК А

ПРОГРАМНИЙ КОД АЛГОРИТМА SHA-2

// SHA-2.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "SHA2_256.h"

#include "SHA2_384.h"

#include "SHA2_512.h"

#include <cassert> // библиотека assert'а

#include <cstring> // сишные строки

#include <intrin.h> // https://msdn.microsoft.com/ru-ru/library/26td21ds.aspx , используются функции перекодировки в little-endian формат чисел

#include <sstream> // строковые потоки

#include <iostream> // ввод-вывод

std::string toHex(unsigned char *data, int len) // преобраз-ование "сырого" хеша в шестнадцатиричное представление

{

// функции хеширвоания возвращают хеш в виде последовательности 64/32 битных чисел, по сути в виде последовательности бит, // а для удобного вывода и сравнения с тестовыми векторами нужно текстовое, 16ричное представление

std::stringstream str; // сюда будем записывать в hex'е полученный результат

for (int i = 0; i < len; i++)

{

str.width(2); // ширина поля вывода в поток 8 символов

str.fill('0'); // дополнить поле 0ми до нужной ширины при необходимости

str << std::hex << (unsigned int)data[i]; // вывод 16ричного представления в поток

}

return str.str(); // возвращаем его содержимое в виде строки

}

void test_256()

{

SHA2_256 sha;

char data[] = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; // хешируемое сообщение

uint32 hash[256 / 8 / 4]; // память под хеш

sha.digest(data, sizeof(data) - 1, hash); // вычисляем хеш

std::stringstream str; // сюда будем записывать в hex'е полученный результат

for (int i = 0; i < 256 / 8 / 4; i++)

{

str.width(8); // ширина поля 8 символов (32биное число в 16й системе занимает 8 символов)

str.fill('0'); // дополнить 0ми при необходимости

str << std::hex << hash[i];

}

assert(str.str() == "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"); // сравниваем с примером из стандарта

}

void test_384()

{

SHA2_384 sha;

char data[] = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";

uint64 hash[384 / 8 / 8]; // основные отличия от предыдущей функции будет в увеличении массива под хеш и ширины поля под число, в сотальном все сильно похоже

sha.digest(data, sizeof(data) - 1, hash);

std::stringstream str;

for (int i = 0; i < 384 / 8 / 8; i++)

{

str.width(16);

str.fill('0');

str << std::hex << hash[i];

}

assert(str.str() == "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039");

}

void test_512()

{

SHA2_512 sha;

char data[] = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";

uint64 hash[512 / 8 / 8];

sha.digest(data, sizeof(data) - 1, hash);

std::stringstream str;

for (int i = 0; i < 512 / 8 / 8; i++)

{

str.width(16);

str.fill('0');

str << std::hex << hash[i];

}

assert(str.str() == "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");

}

int _tmain(int argc, _TCHAR* argv[])

{

test_256(); // три аналогичных теста для разных длин

test_384();

test_512();

char msg[1024]; // буфер под сообщение

std::cout << "Enter msg:> ";

std::cin >> msg;

SHA2_256 sha256; // объекты хешей

SHA2_384 sha384;

SHA2_512 sha512;

unsigned char hash[512 / 8]; // хеш

sha256.digest(msg, strlen(msg), hash); // хешируем

std::cout << "SHA256: " << toHex(hash, 256 / 8) << std::endl; // выводим

sha384.digest(msg, strlen(msg), hash);

std::cout << "SHA384: " << toHex(hash, 384 / 8) << std::endl;

sha512.digest(msg, strlen(msg), hash);

std::cout << "SHA512: " << toHex(hash, 512 / 8) << std::endl;

system("pause");

return 0;

}

ПРОГРАМНИЙ КОД АЛГОРИРТМУ SHA-256.

#include "stdafx.h"

#include "SHA2_256.h"

#include <cstring>

#include <intrin.h>

const uint32 initH[8] = { 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };

const uint32 K[] = {

0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,

0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,

0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,

0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,

0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,

0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,

0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,

0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2

};

SHA2_256::SHA2_256()

{

}

uint32 rotr(uint32 x, int n)

{

return (x >> n) | (x << (32 - n));

}

void SHA2_256::update(uint32 block[512 / sizeof(uint32) / 8])

{

uint32 w[64];

memcpy(w, block, 512 / 8);

for (int i = 0; i < 16; i++)

w[i] = _byteswap_ulong(w[i]);

for (int i = 16; i < 64; i++)

{

uint32 s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3),

s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10);

w[i] = w[i - 16] + s0 + w[i - 7] + s1;

}

uint32 state[8];

memcpy(state, h, sizeof(state));

uint32 &a = state[0],

&b = state[1],

&c = state[2],

&d = state[3],

&e = state[4],

&f = state[5],

&g = state[6],

&h = state[7];

for (int i = 0; i < 64; i++)

{

uint32 sum0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22),

Ma = (a & b) ^ (a & c) ^ (b & c),

t2 = sum0 + Ma,

sum1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25),

Ch = (e & f) ^ ((~e) & g),

t1 = h + sum1 + Ch + K[i] + w[i];

for (int i = 7; i > 0; i--)

state[i] = state[i - 1];

e += t1;

a = t1 + t2;

}

for (int i = 0; i < 8; i++)

this->h[i] += state[i];

}

void SHA2_256::digest(void *buf, uint64 len, void *out)

{

memcpy(h, initH, sizeof(h));

int count = len * 8 / 448 + ((len * 8 + 1 < 448) ? 0 : 1);

if (count == 0)

count = 1;

int n = count * 512 / 8 / 4;

uint32 *data = new uint32[n];

uint32 *p = data;

memset(data, 0, n * 4);

memcpy(data, buf, len);

((unsigned char*)data)[len] = 1 << 7;

len = _byteswap_uint64(len * 8);

memcpy(data + n - 2, &len, 8);

for (int i = 0; i < count; i++)

{

update(data);

data += 512 / 8 / 4;

}

memcpy(out, h, 8 * 4);

delete[] p;

}

SHA2_256::~SHA2_256()

{

}



ПРОГРАМНИЙ КОД АЛГОРИТМУ SHA-512

#include "stdafx.h"

#include "SHA2_512.h"

#include <cstring>

#include <intrin.h>

const uint64 k[] = // массив констант алгоритма

{

0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817

};

// начальное состояние алгоритма

const uint64 initH[] = { 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1, 0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179 };

SHA2_512::SHA2_512()

{

}

SHA2_512::~SHA2_512()

{

}

inline uint64 rotr(uint64 x, int n) // циклическое вращение вправо 64юитного целого

{

return (x >> n) | (x << (64 - n));

}

void SHA2_512::update(uint64 block[1024 / sizeof(uint64) / 8]) // обработка 1024 битового блока

{

// ШАГ 1.

uint64 w[80]; // расписание

memcpy(w, block, 1024 / 8); // копируем данные в начало, это Wi от 0-го до 15 включительно

for (int i = 0; i < 16; i++)

w[i] = _byteswap_uint64(w[i]); // переводим их в little-endian формат (требование стандарта)

for (int i = 16; i < 80; i++) // разворачиваем остальные элементы расписания, все по формулам из стандарта

{

uint64 s0 = rotr(w[i - 15], 1) ^ rotr(w[i - 15], 8) ^ (w[i - 15] >> 7),

s1 = rotr(w[i - 2], 19) ^ rotr(w[i - 2], 61) ^ (w[i - 2] >> 6);

w[i] = w[i - 16] + s0 + w[i - 7] + s1;

}

//ШАГ 2.

uint64 state[8]; // локальная копия состояния

memcpy(state, h, sizeof(state));

uint64 &a = state[0], // сокрашенные ссылки на элементы состояния

&b = state[1],

&c = state[2],

&d = state[3],

&e = state[4],

&f = state[5],

&g = state[6],

&h = state[7];

//ШАГ 3

for (int i = 0; i < 80; i++) // 80 раундов преобразования, аналогично, все по формулам

{

uint64 sum0 = rotr(a, 28) ^ rotr(a, 34) ^ rotr(a,39), // нулевая сумма

Ma = (a & b) ^ (a & c) ^ (b & c), // мажоритарная функция, Maj (a,b,c) в твоей теории

t2 = sum0 + Ma,

sum1 = rotr(e, 14) ^ rotr(e, 18) ^ rotr(e, 41), // первая сумма

Ch = (e & f) ^ ((~e) & g), // Ch(e,f,g) в теории

t1 = h + sum1 + Ch + k[i] + w[i];

for (int i = 7; i > 0; i--) // сдвиг состояния

state[i] = state[i - 1];

e += t1; // и добавление данных

a = t1 + t2;

}

// ШАГ 4

for (int i = 0; i < 8; i++) // добавляем полученное состояние к состояних хеша

this->h[i] += state[i];

}

void SHA2_512::digest(void *buf, uint64 len, void *out) // подсчет хеша любой строки

{

memcpy(h, initH, sizeof(h)); // инициализируем состояние хеша

int count = len * 8 / (1024 - 128) + ((len * 8 + 1 < (1024 - 128)) ? 0 : 1); // количество блоков, кривая, сложная формула, но рабочая

if (count == 0) // не может быть 0 блоков

count = 1;

int n = count * 1024 / sizeof(uint64) / 8; // количество 64 битовых целых, что бы удержать count блоков

uint64 *data = new uint64[n]; // блоки

uint64 *tmp = data;

memset(data, 0, n * 8); // зануляем

memcpy(data, buf, len); // в начало записываем данные

((unsigned char*)data)[len] = 1 << 7; // 1 бит сразу после данных

len = _byteswap_uint64(len * 8); // длина как 64 битное little endian число

memcpy(data + n - 1, &len, 8); // записываем в конец последнего блока

for (int i = 0; i < count; i++) // цикл по блокам

{

update(data); // обрабатываем блок

data += 1024 / sizeof(uint64) / 8; // двигаем рамку считывания

}

memcpy(out, h, 8 * 8); // в выходной буфер записываем состояние после всех итераций

delete[] tmp;

}



ПРОГРАМНИЙ КОД АЛГОРИТМУ SHA-384

#include "stdafx.h"

#include "SHA2_384.h"

#include <cstring>

#include <intrin.h>

const uint64 k[] =

{

0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817

};

const uint64 initH[] = { 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939, 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4 };

SHA2_384::SHA2_384()

{

}

SHA2_384::~SHA2_384()

{

}

inline uint64 rotr(uint64 x, int n)

{

return (x >> n) | (x << (64 - n));

}

void SHA2_384::update(uint64 block[1024 / sizeof(uint64) / 8])

{

uint64 w[80];

memcpy(w, block, 1024 / 8);

for (int i = 0; i < 16; i++)

w[i] = _byteswap_uint64(w[i]);

for (int i = 16; i < 80; i++)

{

uint64 s0 = rotr(w[i - 15], 1) ^ rotr(w[i - 15], 8) ^ (w[i - 15] >> 7),

s1 = rotr(w[i - 2], 19) ^ rotr(w[i - 2], 61) ^ (w[i - 2] >> 6);

w[i] = w[i - 16] + s0 + w[i - 7] + s1;

}

uint64 state[8];

memcpy(state, h, sizeof(state));

uint64 &a = state[0],

&b = state[1],

&c = state[2],

&d = state[3],

&e = state[4],

&f = state[5],

&g = state[6],

&h = state[7];

for (int i = 0; i < 80; i++)

{

uint64 sum0 = rotr(a, 28) ^ rotr(a, 34) ^ rotr(a, 39),

Ma = (a & b) ^ (a & c) ^ (b & c),

t2 = sum0 + Ma,

sum1 = rotr(e, 14) ^ rotr(e, 18) ^ rotr(e, 41),

Ch = (e & f) ^ ((~e) & g),

t1 = h + sum1 + Ch + k[i] + w[i];

for (int i = 7; i > 0; i--)

state[i] = state[i - 1];

e += t1;

a = t1 + t2;

}

for (int i = 0; i < 8; i++)

this->h[i] += state[i];

}

void SHA2_384::digest(void *buf, uint64 len, void *out)

{

memcpy(h, initH, sizeof(h));

int count = len * 8 / (1024 - 128) + ((len * 8 + 1 < (1024 - 128)) ? 0 : 1);

if (count == 0)

count = 1;

int n = count * 1024 / sizeof(uint64) / 8;

uint64 *data = new uint64[n];

uint64 *tmp = data;

memset(data, 0, n * 8);

memcpy(data, buf, len);

((unsigned char*)data)[len] = 1 << 7;

len = _byteswap_uint64(len * 8);

memcpy(data + n - 1, &len, 8);

for (int i = 0; i < count; i++)

{

update(data);

data += 1024 / sizeof(uint64) / 8;

}

memcpy(out, h, 6 * 8); // здесь записываем не все состояние, а только 6 из 8 элементов

delete[] tmp;

}

Размещено на Allbest.ru

...