МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ

РОССИЙСКОЙ ФЕДЕРАЦИИ
ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ АВТОНОМНОЕ
ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ ВЫСШЕГО
ОБРАЗОВАНИЯ
«СЕВАСТОПОЛЬСКИЙ ГОСУДАРСТВЕННЫЙ
УНИВЕРСИТЕТ»

Институт информационных технологий

Кафедра «Информационная безопасность»

Пояснительная записка
к РГР по дисциплине
«Защита программ и данных»

на тему Исследование принципа работы хэш-функции sha-256

Выполнил: студент 2 курса, группы ИБ/б-21-2-о

направления подготовки 10.03.01 «Информационная безопасность»

профиль Защита программ и данных

Мыльников Виталий Александрович

(фамилия, имя, отчество студента)

Руководитель Лихолоб П.Г., к.т.н., доцент каф. ИБ

(фамилия, инициалы, степень, звание, должность) (подпись)

Дата допуска к защите « » 2022г.

Зав. кафедрой ИБ М.И. Ожиганова
(подпись) (инициалы, фамилия)

г. Севастополь
2022 г.
 МИНИСТЕРСТВО НАУКИ И ВЫСШЕГО ОБРАЗОВАНИЯ
РОССИЙСКОЙ ФЕДЕРАЦИИ
ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ АВТОНОМНОЕ ОБРАЗОВАТЕЛЬНОЕ
УЧРЕЖДЕНИЕ ВЫСШЕГО ОБРАЗОВАНИЯ
«СЕВАСТОПОЛЬСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРИТЕТ»

Институт радиоэлектроники и информационной безопасности

Кафедра «Информационная безопасность»
Направление подготовки/специальность 10.03.01 – «Информационная безопасность»
(код и наименование)

Профиль/специализация Организация и технология защиты информации

УТВЕРЖДАЮ
Заведующий кафедрой
«Информационная безопасность»
М.И. Ожиганова
(подпись) (инициалы, фамилия)
«____»__________________202__года

З А Д А Н И Е
на курсовую работу

по дисциплине: «Защита программ и данных»

студенту Мыльников Виталий Александрович

(фамилия, имя, отчество)

1. Тема работы (проекта) Исследование принципа работы хэш-функции sha-256 и ее

сравнение с другими хэш-функции

руководитель работы (проекта) Лихолоб П.Г., к.т.н., доцент кафедры ИБ

(фамилия, имя, отчество, степень, звание, должность)

2. Срок подачи студентом работы (проекта) 01.12.2022 г.

3. Входные данные к работе (проекту)
Предмет: Исследование принципа работы хэш-функции sha-256
Объект: хэш-функция sha-256
1. Исследовать структуру алгоритма 2. Привести описание алгоритма, мат. модель и блок-
схему 3. Изучить правовое поле использования алгоритма

4. Содержание пояснительной записки (перечень вопросов, которые нужно разработать)

Введение
1 Метод хэширования SHA-2, алгоритм хэширования sha-256
2 Описание и математическая модель алгоритма
3 Исследование и тестирование алгоритма
2
Заключение
Список использованных источников
5. Перечень иллюстративного (графического) материала Презентация в Beamer
стековые диаграммы, математические модели, блок-схемы алгоритмов, результаты
выполнения программы
6. Консультанты разделов работы (проекта)
Подпись, дата
Фамилия, инициалы и должность
Раздел задание задание
консультанта
выдал принял
1 Лихолоб П., доцент кафедры ИБ
2
3

7. Дата выдачи задания « 03 » октября 2022 г.

КАЛЕНДАРНЫЙ ПЛАН

Срок
№ Название этапов Примечание
выполнения
п/п работы (проекта)
этапов работы
1 Сбор и анализ материала 03.10 – 14.10
2 3й раздел курсового проекта описание программ,
параметров запуска,
02.10 – 20.10
входных данных,
полученного результата.
3 2й раздел курсового проекта описание программ виде
структурной схемы;
14.10 – 10.11
описание программ в виде
блок-схемы алгоритма.
4 1й раздел курсового проекта описание правового поля
для использования
исследуемых программных
прототипов и данных;
08.10 – 17.11
описание применяемой в
программе математической
модели математического
аппарата, принципов.
5 Оформление пояснительной записки 08.10 – 01.12 Согласно ГОСТ 2.105
6 Оформление графического материала 08.10 – 07.12

Студент Мыльников В.А.

(подпись) (фамилия и инициалы)

Руководитель работы (проекта) Лихолоб П.Г.

(подпись) (фамилия и инициалы)

3
 СОДЕРЖАНИЕ

Введение 5
1 МЕТОД ХЭШИРОВАНИЯ SHA-2, АЛГОРИТМ ХЭШИРОВАНИЯ SHA-256.
6
1.1 Хэш-функция основные теоретические положения 6
1.2 SHA-2 и SHA-256 6
1.3 Правовое регулирование использования SHA-256 8
2 ОПИСАНИЕ И МАТЕМАТИЧЕСКАЯ МОДЕЛЬ АЛГОРИТМА 10
2.1 Описание алгоритма 10
2.2 Математическая модель 12
3 ТЕСТИРОВАНИЕ АЛГОРИТМА ХЭШИРОВАНИЯ SHA-256 16
3.1 Исследование работоспособности проекта 16
3.2 Сравнение работы исследуемого алгоритма хэширования с другими
17
Заключение 23

Список информационных источников 24

Приложение А 26

Приложение Б 30
Приложение В 31

4
 ВВЕДЕНИЕ

Хэш-функции широко распространены в современном

программировании, хэши используются во многих сферах, от аутентификации
до обнаружения попытки взлома. Хэширование – это односторонний процесс,
который трансформирует входные данные в строку, имеющую фиксированную
длину. Сегодня существует огромное количество алгоритмов хэширования, где
в основе каждого находится своя определенная хэш-функция. Хэширование
сегодня используется во множестве различных сферах, например, выработка
цифровой подписи, верификация пароля, для проверки целостности
информации, подтверждение авторского права.
Существует множество семейств алгоритмов хэширования, которые
включают в себя различные хэш-функции, в данной работе рассматривается
хэш-функция, SHA-256, относящаяся к семейству SHA-2. Данный метод
хэширования до сих пор используется правительством и гражданским
управлением США. Также с его помощью производится генерация хэшей в
сети биткоин. Сегодня SHA-256 генерирует максимально надежные строки
таким образом, что их невозможно расшифровать.
Цель работы: исследовать принцип работы хэш-функции sha-256.
Задачи:
1. «исследовать структуру алгоритма»;
2. «привести описание алгоритма, математическую модель, блок-схему
алгоритма»;
3. «изучить правовое поле использования алгоритма».
В данной работе указаны предмет и объект исследования:
Предмет исследования: исследование принципа работы хэш-функции SHA-
256.
Объект исследования: хэш-функция SHA-256.

5
 Работа изложена на 25 страницах основного текста, включающего 17
рисунков, 3 таблицы, 3 листинга кода, список литературных источников из 13
наименований, 3 приложения.

6
 1 МЕТОД ХЭШИРОВАНИЯ SHA-2, АЛГОРИТМ ХЭШИРОВАНИЯ
SHA-256.
1.1 Хэш-функция основные теоретические положения

Хэш-функция — функция, которая осуществляет преобразование массива

входных данных произвольной длины в выходную битовую строку
установленной длины, выполняемое определённым алгоритмом. [1]
Хэширование — преобразование, производимое хеш-функцией. [1]
В общем случае (согласно принципу Дирихле) нет однозначного
соответствия между хеш-кодом и исходными данными. Возвращаемые хеш-
функцией значения менее разнообразны, чем значения входного массива. [2]
Коллизия — случай, при котором хеш-функция преобразует более чем
один массив входных данных в одинаковые сводки. [2]
Оценка качества хэш-функций производится по вероятности
возникновения коллизий. [2]
Хэш-сумма — результат выполнения хэш-функции. Иными словами, это
сообщение из набора чисел и букв с фиксированной битовой длиной
независящей от изначального объёма информации. [3]
Множество алгоритмов отличаются друг от друга различными
свойствами. Примеры некоторых свойств:

 разрядность;
 вычислительная сложность;
 криптостойкость.[3]

1.2 SHA-2 и SHA-256

SHA-2 — семейство алгоритмов с одним принципом хеширования

данных. SHA-256 устанавливает дополнительные постоянные, определяющие
7
поведение алгоритма SHA-2. Одной из таких констант является размер вывода.
«256» и «512» относятся к соответствующим размерам выходных данных в
битах. [1]
Исходное сообщение после дополнения разбивается на блоки, которые, в
свою очередь — на 16 слов. Далее каждый блок пропускается алгоритмом через
цикл с 64-мя или 80 итерациями (раундами). На каждой итерации 2 слова
преобразуются, функцию преобразования задают остальные слова. Результаты
обработки складываются, сумма является значением хеш-функции. [1]
Алгоритм использует следующие битовые операции:
 || — Конкатенация,
 + — Сложение,
 and — Побитовое «И»,
 or — Побитовое «ИЛИ»,
 xor — Исключающее «ИЛИ»,
 shr (Shift Right) — Логический сдвиг вправо,
 rotr (Rotate Right) — Циклический сдвиг вправо.
[1]
Алгоритм преобразует информацию в 256-битный код, который состоит
из 64 букв или цифр, которые составляются случайным образом. В результате
получаются почти уникальные комбинации. SHA-256 один из самых
безопасных алгоритмов, за счёт невозможности обратного преобразования. [3]

В следующей таблице продемонстрированы некоторые характеристики

варианта SHA-256 (Таблица 1).
Таблица 1 – характеристика алгоритма sha-256 [2].
Хэш- Длина Длина Длина Максимальная Длина
функция сообщения внутреннего блока длина слова (бит)
(бит) состояния (бит) сообщения
(бит) (бит)
SHA-256 256 256 512 264 − 1 32
8
 1.3 Правовое регулирование использования SHA-256

Регулятором в сфере хэш-функций в Российской Федерации выступает

Федеральная служба безопасности. [4]
Ввоз и вывоз шифровальных средств осуществляется только при
включении соответствующей нотификации или при наличии лицензии. [5]
В соответствии с постановлением правительства Российской Федерации
от 16 апреля 2012 г. №313 г. Москва «Об утверждении Положения о
лицензировании деятельности по разработке, производству, распространению
шифровальных (криптографических) средств, информационных систем и
телекоммуникационных систем, защищенных с использованием шифровальных
(криптографических) средств, выполнению работ, оказанию услуг в области
шифрования информации, техническому обслуживанию шифровальных
(криптографических) средств, информационных систем и
телекоммуникационных систем, защищенных с использованием шифровальных
(криптографических) средств (за исключением случая, если техническое
обслуживание шифровальных (криптографических) средств, информационных
систем и телекоммуникационных систем, защищенных с использованием
шифровальных (криптографических) средств, осуществляется для обеспечения
собственных нужд юридического лица или индивидуального
предпринимателя)» разработка, производство и распространение
криптографических средств подлежит лицензированию. [5]
Для разработки и использования криптографических (шифровальных)
средств требуется специализированная лицензия. Для ее получения необходим
следующий перечень документов:
‒ заявление о выдаче лицензии и его электронная копия;
‒ копия внешнеторгового договора (контракта), приложения и (или)
дополнения к нему (для разовой лицензии), а в случае отсутствия
9
внешнеторгового договора (контракта) — копия иного документа,
подтверждающего намерения сторон;
‒ сведения о постановке заявителя на учет в налоговом органе или о
государственной регистрации;
‒ сведения о наличии лицензии на осуществление лицензируемого вида
деятельности на территории России;
‒ заключение (разрешительный документ) ЦЛСЗ ФСБ России;
‒ уведомление заявителя об отсутствии в составе ввозимых шифровальных
(криптографических) средств радиоэлектронных средств и (или)
высокочастотных устройств гражданского назначения (для их ввоза
предусмотрена иная процедура).
[6]
Заключение выдается при подаче следующих документов:
‒ проект заключения (разрешительного документа), оформленный в
соответствии с методическими указаниями по заполнению единой формы
заключения (разрешительного документа) на ввоз, вывоз и транзит отдельных
товаров, включенных в Единый перечень товаров, к которым применяются
запреты или ограничения на ввоз или вывоз государствами — членами
Таможенного союза в рамках Евразийского экономического сообщества в
торговле с третьими странами, утвержденными Решением Коллегии
Евразийской экономической комиссии;
‒ техническая документация на шифровальное (криптографическое)
средство (представление исходных кодов не является обязательным, отказ
заявителя в представлении исходных кодов не является основанием для отказа
в выдаче заключения (разрешительного документа)).
[6]

10
 2 ОПИСАНИЕ И МАТЕМАТИЧЕСКАЯ МОДЕЛЬ АЛГОРИТМА.
2.1 Описание алгоритма

В данной работе будет описана программа хэш-функции sha-256, на

примере репозитория python-sha-256 из GitHub от пользователя keanemind[7].
Полный листинг кода представлен в приложении А.
Вначале происходит инициализация начального ключа.
Листинг 1 – Инициализация начального ключа
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
]

Далее происходит padding это добавление нескольких дополнительных

битов к сообщению, так что длина ровно на 64 бита меньше кратного 512. Во
время сложения первый бит должен быть единицей, а остальная его часть
должна быть заполнена нулями. Далее происходит вычисление длины
заполнения. Появляется возможность добавить 64 бита данных, чтобы
конечный открытый текст был кратен 512. Также можно вычислить эти 64 бита
символов, применив модуль к исходному открытому тексту без заполнения.
Участок кода с выполнением заполнения и его длины представлен на
листинге 2
Листинг 2 – Участок программы, где происходит выполнение padding.

11
 # Padding
length = len(message) * 8 # len(message) is number of
BYTES!!!
message.append(0x80)
while (len(message) * 8 + 64) % 512 != 0:
message.append(0x00)
message += length.to_bytes(8, 'big') # pad to 8 bytes or 64
bits
assert (len(message) * 8) % 512 == 0, "Padding did not
complete properly!"

Блок-схема указанного выше листинга представлена на рисунке 1:

Рисунок 1 – Блок-схема программы выполнения padding.

После этого идет инициализация буферов, где идет инициализация

значений по умолчанию для восьми буферов, которые будут использоваться в
раундах.
Ниже показан листинг участка кода с выполнением инициализации
буферов
12
Листинг 3 – Инициализация буфера
h0 = 0x6a09e667
h1 = 0xbb67ae85
h2 = 0x3c6ef372
h3 = 0xa54ff53a
h5 = 0x9b05688c
h4 = 0x510e527f
h6 = 0x1f83d9ab
h7 = 0x5be0cd19

Следующий шаг, это происходят вычисления, после которых идут

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

2.2 Математическая модель

В данной части раздела будет представлена и описана математическая

модель хэш-функции sha-256.
На рисунке 1 представлена математическая модель (схема работы) хэш-
функции sha-256.

13
 Рисунок 1 – Математическая модель (схема работы) хэш-функции sha-256

На рисунке 2 представлена схема того, как происходит заполнение битов

и вычисление их длины.

Рисунок 2 – Схема работы заполнения битов и вычисления их длины [8]

Далее происходит инициализация буфера. Пример инициализации буфера

приведен на рисунке 3

14
 Рисунок 3 – Пример инициализации буфера [8]
Далее все сообщение разбивается на несколько блоков по 512 бит в
каждом. Он подвергает каждый блок 64 раундам работы, при этом выходные
данные каждого блока служат входными данными для следующего блока. Весь
процесс заключается в следующем. На рисунке 4 представлены схема работы
сжатия функции.

15
 Рисунок 4 – схема работы сжатия функции [8]

В то время как значение K[i] во всех этих раундах предварительно

инициализировано, W[i] – еще один входной сигнал, который вычисляется
индивидуально для каждого блока, в зависимости от количества итераций,
обрабатываемых в данный момент. [8]
Вывод алгоритма происходит так: с каждой итерацией конечный
результат блока служит входом для следующего блока. Весь цикл повторяется
до тех пор, пока он не дойдет до последнего 512-битного блока, и тогда он
будет считать его выходные данные окончательным хэш-дайджестом. Этот
дайджест будет иметь длину 256 бит, согласно названию этого алгоритма. [8]
Таким образом, в данном разделе был описан алгоритм вычисления хэша,
хэш-функцией sha-256 и приведена математическая модель. Далее будет
приведено описание работоспособности изучаемого алгоритма и сравнение его
с другими хэш-функциями.

16
 3 ТЕСТИРОВАНИЕ АЛГОРИТМА ХЭШИРОВАНИЯ SHA-256
3.1 Исследование работоспособности проекта

Для проведения исследования работоспособности был взят репозиторий

GitHub и запущен в программе Visual Studio Code. Было обнаружено, что в
данном проекте имеются все этапы алгоритма вычисления хэша методом sha-
256.
Далее программой было вычислено 5 хэшей для 5 различных строк, а
также было определенно время вычисления хэша для каждой строки. Ниже
приведены результаты вычисления хэшей для строк – Vitaliy, Vitaliy1, Vitaliy12,
Vitaliy123, Vitaliy1234.

Рисунок 5 – Сгенерированный хэш для строки Vitaliy

Рисунок 6 – Сгенерированный хэш для строки Vitaliy1

Рисунок 7 – Сгенерированный хэш для строки Vitaliy12

Рисунок 8 – Сгенерированный хэш для строки Vitaliy123

Рисунок 9 – Сгенерированный хэш для строки Vitaliy1234

Из показанных выше рисунков, видно, что все хэш-суммы обладают

одинаковой длинной и приблизительно одинаковой скоростью вычисления,
17
равной 0,001 секунды. В следующем разделе приведены результаты сравнения
работы этой хэш-функции с двумя другими.

3.2 Сравнение работы исследуемого алгоритма хэширования с другими

Для сравнения, было взято два алгоритма хэширования – SHA-1 и SHA-

384. Начнем сравнение с описания алгоритма SHA-1 и SHA-256. Алгоритм
SHA1 относится к криптографической хэш-функции, предложенной
Агентством национальной безопасности Соединенных Штатов. Он принимает
входные данные и выдает на выходе 160-битное хэш-значение. Кроме того,
выходные данные, создаваемые этой функцией, преобразуются в
шестнадцатеричное число длиной 40 цифр. Он известен как Федеральный
стандарт обработки информации США [9]. Также для алгоритма SHA-1 была
создана коллизия (две части разрозненных данных создают одно и то же хэш-
значение) [10]. В то время как для алгоритма sha-1 существует 264 возможных
комбинаций, то для sha-256 – 2256 [10].
Таблица сравнения этих алгоритмов по некоторым параметрам
представлена ниже (Таблица 2).

18
 Таблица 2 – Сравнение алгоритмов sha-1 и sha-256 [10]
Хеш- Длина Длина Длин Максимальн Длин Количеств Найденны
функци дайджест внутреннег а ая длина а о е
я а о блока сообщения слова итераций коллизии
сообщени состояния (бит) (бит) (бит) в цикле
я (бит) (бит)
64 52
SHA-1 160 160 512 2 −1 32 80 (4 Есть. 2
группы из операций
20
итераций)
64
SHA- 256 256 512 2 −1 32 64 Нет
256

Сравнив два алгоритма по указанным в таблице, можно определить

преимущества sha-256 алгоритма, так как у sha-256 не обнаружено коллизий,
длина дайджеста и внутреннего состояния больше на 96 бит.
Реализация алгоритма sha-1 была взята на интернет-ресурсе GitHub.
Листинг программы sha-1 показан в приложении Б. Ниже представлено
сравнение работы алгоритмов sha-1 и sha-256.
На рисунке 10 показан сгенерированный программой алгоритма sha-256
хеш и время его вычисления:

Рисунок 10 – Сгенерированный хэш для строки Vitaliy123 и время его

вычисления

Рисунок 11 – Сгенерированный хэш для строки Vitaliy1234 и время его

вычисления

19
 Для просмотра работы sha-1 был взят репозиторий GitHub [11]. На
рисунке 12 изображены результаты хэширования sha-1 и вычисление времени
работы алгоритма:

Рисунок 12 – Сгенерированный хэш для строки Vitaliy123 и время его

вычисления

Рисунок 13 – Сгенерированный хэш для строки Vitaliy1234 и время его

вычисления

Как можно заметить, длина хэшей отличается, хэш, сгенерированный

методом sha-256 длиннее, чем хэш, сгенерированный sha-1. Также, время
вычисления отчисляется на приблизительно на 3 секунды.
Функция SHA-384 работает с размером слова 64 бита. Вначале текст
дополняется так, чтобы его длина была кратна 1024. Процедура дополнения
аналогична: добавляется 1, затем столько нулей, что длина текста станет на 128
меньше, нежели кратная 1024, а затем 128-битовое представление длины
исходного текста. Стартовый вектор хеширования задается следующим
образом: берутся первые 64 бита дробных частей квадратных корней первых 8
простых чисел. Далее исходный текст разбивается на блоки по 1024 бита,
однако в качестве стартового вектора хеширования берутся первые 64 бита
квадратных корней простых чисел с девятого по шестнадцатое. Далее выход
функции обрезается до 384 левых бит, и эти биты берутся в качестве значения
функции хеширования SHA-384 [12].
20
 Ниже приведена таблица сравнения алгоритмов sha-256 и sha-384 по
нескольким параметрам (Таблица 3).

21
 Таблица 3 – Сравнение sha-256 и sha-384 алгоритмов хеширования [1]
Хеш- Длина Длина Длин Максимальна Длин Количеств Найденны
функци дайджест внутреннег а я длина а о е
я а о блока сообщения слова итераций коллизии
сообщени состояния (бит) (бит) (бит) в цикле
я (бит) (бит)
64
SHA- 256 256 512 2 −1 32 64 Нет
256
128
SHA- 384 512 1024 2 −1 64 80 Нет
384

Исходя из данных, приведенных в таблице, можно определить, что

алгоритм хэширования sha-384 обладает большим преимуществом над sha-256.
Далее будут приведены результаты сравнения работы проектов данных
алгоритмов. Листинг программы sha-384 показан в приложении В.
На рисунке 14 показан сгенерированный программой алгоритма sha-256
хеш и время его вычисления:

Рисунок 14 – Сгенерированный хэш для строки Vitaliy123 и время его

вычисления

Рисунок 15 – Сгенерированный хэш для строки Vitaliy1234 и время его

вычисления

Для просмотра работы sha-384 был взят репозиторий GitHub [14]. На

рисунке 16 изображены результаты хэширования sha-384 и вычисление
времени работы алгоритма:

22
 Рисунок 16 – Сгенерированный хэш для строки Vitaliy123 методом sha-384 и
время его вычисления

Рисунок 17 – Сгенерированный хэш для строки Vitaliy1234 методом sha-384 и

время его вычисления

Из результатов работы алгоритмов видно, что хэш, сгенерированный

функцией sha-384 длиннее, чем хэш, сгенерированный функцией sha-256.
Таким образом, в результате работы проекта и сравнении его результатов
с другими, было определено, что хэш-функция sha-256, более надежен, чем
SHA-1, но уступает хэш-функции sha-384 в нескольких параметрах, указанных
в данном разделе.

23
 ЗАКЛЮЧЕНИЕ

В результате расчетно-графической работы был изучен принцип работы

хэш-функции sha-256, проведено сравнение с хэш-функциями sha-1 и sha-384.
В результате всех описаний и проведенных тестирований, было изучено, что
алгоритм хэш-функции sha-256 до сих пор является актуальным и пока не
уступает своим конкурентам.

В заключение можно отметить, что хэш-функция SHA256 является

широко используемым криптографическим инструментом, который играет
решающую роль в обеспечении безопасности передачи и хранения данных. Его
математические свойства и дизайн делают его устойчивым к атакам и
способным выдержать испытание временем. Однако, как и в случае с любым
криптографическим алгоритмом, важно постоянно отслеживать и оценивать его
эффективность перед лицом достижений в области технологий и
потенциальных уязвимостей. В конечном счете, изучение хэш-функции SHA-
256 и ее применения в различных областях помогает углубить наше понимание
сложной и постоянно развивающейся области кибербезопасности.

24
 Список информационных источников

1. Пошагово объясняем, как работает алгоритм хеширования SHA-2 (SHA-

256) // Тпрогер URL: https://tproger.ru/translations/sha-2-step-by-step/ (дата
обращения: 23.11.2022).
2. SHA-2 // Википедия URL: https://ru.wikipedia.org/wiki/SHA-2 (дата
обращения: 23.11.2022).
3. Хеширование // Академик URL: https://dic.academic.ru/dic.nsf/ruwiki/78851
(дата обращения: 23.11.2022).
4. Чудеса хеширования // Касперский дейли URL:
https://www.kaspersky.ru/blog/the-wonders-of-hashing/3633/ (дата обращения:
23.11.2022).
5. Хеширование и шифрование: в чем разница? // Нэтворк гуру URL:
https://networkguru.ru/heshirovanie-i-shifrovanie/#:~:text=Хеширование
%20широко%20используется%20для%20безопасного%20хранения%20паролей
%2C%20чтобы,доступа%20к%20серверу%20или%20похищения%20файла%20с
%20паролями (дата обращения: 23.11.2022).
6. Обзор законодательства Российской Федерации в сфере информационной
безопасности — Часть 6: Криптография // Диджитал репорт URL:
https://digital.report/zakonodatelstvo-rossii-kriptografiya/ (дата обращения:
23.11.2022).
7. Алгоритм sha-256 // ГитХаб URL: https://github.com/keanemind/python-sha-
256 (дата обращения: 23.11.2022).
8. A Definitive Guide to Learn The SHA-256 (Secure Hash Algorithms) //
Симпли лёрн URL:
https://www.simplilearn.com/tutorials/cyber-security-tutorial/sha-256-algorithm
(дата обращения: 23.11.2022).
9. Разница между алгоритмами хэширования SHA-1, SHA-2 и SHA-256 //
Хешед аут URL: https://www.thesslstore.com/blog/difference-sha-1-sha-2-sha-256-
hash-algorithms/ (дата обращения: 23.11.2022).
25
10. Сравнение алгоритмов хэширования: MD5, SHA-1, SHA-2 и SHA-3 // Код
сигнинг URL: https://codesigningstore.com/hash-algorithm-comparison (дата
обращения: 23.11.2022).
11. Password_Hashing_breaker // ГитХаб URL: https://github.com/Terranova-
Python/Password_Hashing_breaker (дата обращения: 23.11.2022).
12. SHA384_Onsite // ГитХаб URL:
https://github.com/shankarjp/SHA384_Onsite (дата обращения: 23.11.2022).

26
 Приложение А
Листинг программы

"""This Python module is an implementation of the SHA-256

algorithm.
From https://github.com/keanemind/Python-SHA-256"""
import time
start_time = time.time()
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
]
def generate_hash(message: bytearray) -> bytearray:
"""Return a SHA-256 hash from the message passed.
The argument should be a bytes, bytearray, or
string object."""
if isinstance(message, str):
message = bytearray(message, 'ascii')
elif isinstance(message, bytes):
message = bytearray(message)
elif not isinstance(message, bytearray):
raise TypeError
# Padding
length = len(message) * 8 # len(message) is number of BYTES!!!
message.append(0x80)
while (len(message) * 8 + 64) % 512 != 0:
message.append(0x00)
message += length.to_bytes(8, 'big') # pad to 8 bytes or 64
bits
assert (len(message) * 8) % 512 == 0, "Padding did not
complete properly!"
# Parsing
blocks = [] # contains 512-bit chunks of message
for i in range(0, len(message), 64): # 64 bytes is 512 bits
blocks.append(message[i:i+64])
# Setting Initial Hash Value
h0 = 0x6a09e667

27
 Приложение А
Продолжение листинга
h1 = 0xbb67ae85
h2 = 0x3c6ef372
h3 = 0xa54ff53a
h5 = 0x9b05688c
h4 = 0x510e527f
h6 = 0x1f83d9ab
h7 = 0x5be0cd19
# SHA-256 Hash Computation
for message_block in blocks:
# Prepare message schedule
message_schedule = []
for t in range(0, 64):
if t <= 15:
# adds the t'th 32 bit word of the block,
# starting from leftmost word
# 4 bytes at a time
message_schedule.append(bytes(message_block[t*4:
(t*4)+4]))
else:
term1 = _sigma1(int.from_bytes(message_schedule[t-
2], 'big'))
term2 = int.from_bytes(message_schedule[t-7],
'big')
term3 = _sigma0(int.from_bytes(message_schedule[t-
15], 'big'))
term4 = int.from_bytes(message_schedule[t-16],
'big')
# append a 4-byte byte object
schedule = ((term1 + term2 + term3 + term4) %
2**32).to_bytes(4, 'big')
message_schedule.append(schedule)
assert len(message_schedule) == 64
# Initialize working variables
a = h0
b = h1
c = h2
d = h3
e = h4
f = h5
g = h6
h = h7
# Iterate for t=0 to 63
for t in range(64):
t1 = ((h + _capsigma1(e) + _ch(e, f, g) + K[t] +
int.from_bytes(message_schedule[t], 'big')) %
2**32)
t2 = (_capsigma0(a) + _maj(a, b, c)) % 2**32
h = g
g = f
28
 Приложение А
Продолжение листинга
f = e
e = (d + t1) % 2**32
d = c
c = b
b = a
a = (t1 + t2) % 2**32
# Compute intermediate hash value
h0 = (h0 + a) % 2**32
h1 = (h1 + b) % 2**32
h2 = (h2 + c) % 2**32
h3 = (h3 + d) % 2**32
h4 = (h4 + e) % 2**32
h5 = (h5 + f) % 2**32
h6 = (h6 + g) % 2**32
h7 = (h7 + h) % 2**32
return ((h0).to_bytes(4, 'big') + (h1).to_bytes(4, 'big') +
(h2).to_bytes(4, 'big') + (h3).to_bytes(4, 'big') +
(h4).to_bytes(4, 'big') + (h5).to_bytes(4, 'big') +
(h6).to_bytes(4, 'big') + (h7).to_bytes(4, 'big'))
def _sigma0(num: int):
"""As defined in the specification."""
num = (_rotate_right(num, 7) ^
_rotate_right(num, 18) ^
(num >> 3))
return num
def _sigma1(num: int):
"""As defined in the specification."""
num = (_rotate_right(num, 17) ^
_rotate_right(num, 19) ^
(num >> 10))
return num
def _capsigma0(num: int):
"""As defined in the specification."""
num = (_rotate_right(num, 2) ^
_rotate_right(num, 13) ^
_rotate_right(num, 22))
return num
def _capsigma1(num: int):
"""As defined in the specification."""
num = (_rotate_right(num, 6) ^
_rotate_right(num, 11) ^
_rotate_right(num, 25))
return num
def _ch(x: int, y: int, z: int):
"""As defined in the specification."""
return (x & y) ^ (~x & z)
def _maj(x: int, y: int, z: int):
"""As defined in the specification."""
return (x & y) ^ (x & z) ^ (y & z)
29
 Приложение А
Окончание листинга
def _rotate_right(num: int, shift: int, size: int = 32):
"""Rotate an integer right."""
return (num >> shift) | (num << size - shift)
if __name__ == "__main__":
print(generate_hash("Vitaliy123").hex())
print("--- %s seconds ---" % (time.time() - start_time))

30
 Приложение Б
Листинг программы
import hashlib
import time
start_time = time.time()
password = input('Input the Password to Hash: ')
print('\nsha-1:\n')
setpass = bytes(password, 'utf-8')
hash_object = hashlib.sha1(setpass)
guess_pw = hash_object.hexdigest()
print(guess_pw)
print("--- %s seconds ---" % (time.time() - start_time))

31
 Приложение В
Листинг программы
#SHA-384 Hash Function
import time
start_time = time.time()
def leftrotate_64(x, c):
x &= 0xFFFFFFFFFFFFFFFF
return ((x << c) | (x >> (64 - c))) & 0xFFFFFFFFFFFFFFFF
def rightrotate_64(x, c):
x &= 0xFFFFFFFFFFFFFFFF
return ((x >> c) | (x << (64 - c))) & 0xFFFFFFFFFFFFFFFF
def leftshift(x, c):
return x << c
def rightshift(x, c):
return x >> c
class SHA384():
def __init__(self):
self.block_size = 96
self.digest_size = 48
h0 = 0xcbbb9d5dc1059ed8
h1 = 0x629a292a367cd507
h2 = 0x9159015a3070dd17
h3 = 0x152fecd8f70e5939
h4 = 0x67332667ffc00b31
h5 = 0x8eb44a8768581511
h6 = 0xdb0c2e0d64f98fa7
h7 = 0x47b5481dbefa4fa4
self.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,

32
 Приложение В
Продолжение листинга
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
]
self.hash_pieces = [h0, h1, h2, h3, h4, h5, h6, h7]

def update(self, arg):

h0, h1, h2, h3, h4, h5, h6, h7 = self.hash_pieces
data = bytearray(arg)
orig_len_in_bits = (8 * len(data)) &
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
data.append(0x80)
while len(data) % 128 != 112:
data.append(0)
data += orig_len_in_bits.to_bytes(16, byteorder='big')
for a in range(0, len(data), 128):
group = data[a : a + 128]
w = [0 for i in range(80)]
for i in range(16):
w[i] = int.from_bytes(group[8*i : 8*i + 8],
byteorder='big')
for j in range(16, 80):
s0 = (rightrotate_64(w[j-15], 1) ^
rightrotate_64(w[j-15], 8) ^ rightshift(w[j-15], 7)) &
0xFFFFFFFFFFFFFFFF
s1 = (rightrotate_64(w[j-2], 19) ^
rightrotate_64(w[j-2], 61) ^ rightshift(w[j-2], 6)) &
0xFFFFFFFFFFFFFFFF
w[j] = (w[j-16] + s0 + w[j-7] + s1) &
0xFFFFFFFFFFFFFFFF
a, b, c, d, e, f, g, h = h0, h1, h2, h3, h4, h5, h6,
h7
for m in range(80):
S1 = (rightrotate_64(e, 14) ^ rightrotate_64(e,
18) ^ rightrotate_64(e, 41)) & 0xFFFFFFFFFFFFFFFF
ch = ((e & f) ^ ((~e) & g)) & 0xFFFFFFFFFFFFFFFF
temp1 = (h + S1 + ch + self.k[m] + w[m]) &
0xFFFFFFFFFFFFFFFF
S0 = (rightrotate_64(a, 28) ^ rightrotate_64(a,
34) ^ rightrotate_64(a, 39)) & 0xFFFFFFFFFFFFFFFF
maj = ((a & b) ^ (a & c) ^ (b & c)) &
0xFFFFFFFFFFFFFFFF
33
 Приложение В
Окончание листинга
temp2 = (S0 + maj) & 0xFFFFFFFFFFFFFFFF
new_a = (temp1 + temp2) & 0xFFFFFFFFFFFFFFFF
new_e = (d + temp1) & 0xFFFFFFFFFFFFFFFF
a, b, c, d, e, f, g, h = new_a, a, b, c, new_e, e,
f, g
h0 = (h0 + a) & 0xFFFFFFFFFFFFFFFF
h1 = (h1 + b) & 0xFFFFFFFFFFFFFFFF
h2 = (h2 + c) & 0xFFFFFFFFFFFFFFFF
h3 = (h3 + d) & 0xFFFFFFFFFFFFFFFF
h4 = (h4 + e) & 0xFFFFFFFFFFFFFFFF
h5 = (h5 + f) & 0xFFFFFFFFFFFFFFFF
h6 = (h6 + g) & 0xFFFFFFFFFFFFFFFF
h7 = (h7 + h) & 0xFFFFFFFFFFFFFFFF
self.hash_pieces = [h0, h1, h2, h3, h4, h5, h6, h7]
def digest(self):
hash_pieces_without_6_and_7 = self.hash_pieces[:-2]
return sum(leftshift(x, 64*i) for i, x in
enumerate(hash_pieces_without_6_and_7[::-1]))

def hexdigest(self):
digest = self.digest()
raw = digest.to_bytes(self.digest_size, byteorder='big')
format_str = '{:0' + str(2 * self.digest_size) + 'x}'
return format_str.format(int.from_bytes(raw,
byteorder='big'))
def main():
string = input("Enter String : ")
h = SHA384()
data = bytes(string, encoding='utf8')
h.update(data)
print(f"Hash : {h.hexdigest()}")
main()
print("--- %s seconds ---" % (time.time() - start_time))

34