Пошаговый обзор того, как работает SHA-256
12 мая 2022 г.Как работает SHA-256, шаг за шагом
SHA-2 (Secure Hash Algorithm 2), частью которого является SHA-256, является одним из самых популярных хеш-алгоритмов вокруг. Криптографический хэш, также часто называемый «дайджестом», «отпечатком пальца» или «подписью», представляет собой почти совершенно уникальную строку символов, сгенерированную из отдельного фрагмента входного текста. Например, SHA-256 создает 256-битную (32-байтовую) подпись.
Далее в этой статье мы разберем каждый шаг [криптографического алгоритма] SHA 256 (/cryptography/what-is-cryptography/) и рассмотрим реальный пример вручную.
Что такое хэш-функция?
Как мы упоминали выше, хэш-функция генерирует «отпечаток пальца» для заданной входной строки. Например, если бы мы хэшировали весь текст серии Дж. Р. Р. Толкиена «Властелин колец» с использованием алгоритма SHA 256, мы бы получили 256-битный вывод, почти уникальный для текста этой книги. Если бы мы изменили хотя бы одну букву в книге, выходной хэш был бы сильно другим.
Стоит отметить, что мы говорим, что вывод хэша «почти уникален», потому что существует конечное количество выходных строк, в конце концов, в выводе всего 256 бит. Однако количество возможных входных данных бесконечно, что означает, что некоторые входные данные будут хешироваться для одного и того же вывода. Когда это происходит, это называется «столкновение», и это почти невозможно. В конце концов, в SHA-256 есть 2^256 возможных выходов. Позвольте мне записать это число для вас:
115 792 089 237 316 195 423 570 985 008 687 907 853 269 984 665 640 564 039 457 584 007 913 129 639 936 возможных выходов для SHA-256
Три основных назначения хеш-функции:
- Для детерминированного скремблирования данных
- Чтобы принять ввод произвольной длины и вывести результат фиксированной длины
- Необратимо манипулировать данными. Вход не может быть получен из вывода
SHA-2 — очень известное и мощное семейство хеш-функций, потому что, как и следовало ожидать, оно служит всем целям, упомянутым выше.
Семейство SHA-2 и SHA-256
SHA-2 — это алгоритм, обобщенное представление о том, как хешировать данные. У SHA-2 есть несколько вариантов, все они используют один и тот же алгоритм, но разные константы. SHA-256, например, устанавливает дополнительные константы, которые определяют поведение алгоритма SHA-2, одна из этих констант — размер вывода, 256. 256 и 512 в SHA-256 и SHA-512 относятся к соответствующему размеру дайджеста. в битах.
Семейство SHA-2 и SHA-1
SHA-2 является преемником хеш-функции SHA-1 и остается одной из самых сильных хэш-функций, используемых сегодня. SHA-256, в отличие от SHA-1, не был скомпрометирован. По этой причине в наши дни действительно нет причин использовать SHA-1, это небезопасно. Гибкость выходного размера (224, 256, 512 и т. д.) также позволяет SHA-2 хорошо сочетаться с популярными KDF и шифрами, такими как AES-256. aes-256-шифр/).
Официальное признание NIST
SHA-256 официально определен в Национальном институте стандартов и технологий [FIPS 180-4] (http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html). Наряду со стандартизацией и формализацией идет список [тестовых векторов] (http://csrc.nist.gov/groups/ST/toolkit/examples.html#aHashing), которые позволяют разработчикам убедиться, что они правильно реализовали алгоритм.
SHA-2 известен своей безопасностью (он не сломался, как SHA-1) и скоростью. В случаях, когда ключи не генерируются, например, при майнинге биткойнов, быстрый алгоритм хэширования, такой как SHA-2, часто имеет преимущество.
Пошаговый хэш SHA-256 «hello world»
Шаг 1 - Предварительная обработка
- Преобразование «hello world» в двоичный файл:
01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100
- Добавить одну 1:
01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100 1
- Дополнять нулями, пока данные не будут кратны 512, минус 64 бита (448 бит в нашем случае):
01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
- Добавьте 64 бита в конец, где 64 бита представляют собой целое число big-endian, представляющее длину исходного ввода в двоичном формате. В нашем случае 88 или в двоичном формате «1011000».
`01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 0000100100
Теперь у нас есть ввод, который всегда будет без остатка делиться на 512.
Шаг 2. Инициализация хеш-значений (h)
Теперь мы создаем 8 хеш-значений. Это жестко закодированные константы, представляющие первые 32 бита дробных частей квадратных корней первых 8 простых чисел: 2, 3, 5, 7, 11, 13, 17, 19.
ч0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19
Шаг 3 - Инициализация констант раунда (k)
Как и в шаге 2, мы создаем некоторые константы (Узнайте больше о константах и о том, когда их использовать здесь). На этот раз их 64. Каждое значение (0–63) — это первые 32 бита дробных частей кубических корней первых 64 простых чисел (2–311).
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
Шаг 4 - Цикл чанка
Следующие шаги будут выполняться для каждого 512-битного «фрагмента» данных из нашего ввода. В нашем случае из-за того, что «hello world» такое короткое, у нас есть только один фрагмент. На каждой итерации цикла мы будем изменять хеш-значения h0-h7, которые будут конечным результатом.
Шаг 5 - Создать расписание сообщений (w)
- Скопируйте входные данные из шага 1 в новый массив, где каждая запись представляет собой 32-битное слово:
01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000001011000
- Добавьте еще 48 слов, инициализированных нулем, чтобы получился массив w[0…63]
01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000001011000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
- Измените обнуленные индексы в конце массива, используя следующий алгоритм:
- Для i из w[16…63]:
- s0 = (w[i-15] поворот вправо 7) xor (w[i-15] поворот вправо 18) xor (w[i-15] сдвиг вправо 3)
- s1 = (w[i- 2] правый поворот 17) xor (w[i- 2] правый поворот 19) xor (w[i- 2] правый сдвиг 10)
- w[i] = w[i-16] + s0 + w[i-7] + s1
Давайте сделаем w[16], чтобы увидеть, как это работает:
w[1] поворот вправо 7:
01101111001000000111011101101111 -> 11011110110111100100000011101110
w[1] поворот вправо 18:
01101111001000000111011101101111 -> 00011101110110111101101111001000
w[1] сдвиг вправо 3:
01101111001000000111011101101111 -> 00001101111001000000111011101101
s0 = 11011110110111100100000011101110 XOR 00011101110110111101101111001000 XOR 00001101111001000000111011101101
s0 = 11001110111000011001010111001011
w[14] поворот вправо 17:
00000000000000000000000000000000 -> 0000000000000000000000000000000000
w[14] поворот вправо19:
00000000000000000000000000000000 -> 0000000000000000000000000000000000
w[14] сдвиг вправо 10:
00000000000000000000000000000000 -> 0000000000000000000000000000000000
s1 = 00000000000000000000000000000000 XOR 0000000000000000000000000000000000 XOR 00000000000000000000000000000000000
s1 = 000000000000000000000000000000000
ш[16] = ш[0] + с0 + ш[9] + с1
w[16] = 01101000011001010110110001101100 + 11001110111000011001010111001011 + 0000000000000000000000000000000000 + 000000000000000000000000000000000000
// сложение вычисляется по модулю 2^32
w[16] = 00110111010001110000001000110111
Это оставляет нам 64 слова в расписании сообщений (w):
01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000000000000
000000000000000000000000000000000 000000000000000000000000001011000
00110111010001110000001000110111 10000110110100001100000000110001
11010011101111010001000100001011 01111000001111110100011110000010
00101010100100000111110011101101 01001011001011110111110011001001
00110001111000011001010001011101 10001001001101100100100101100100
01111111011110100000011011011010 11000001011110011010100100111010
10111011111010001111011001010101 00001100000110101110001111100110
10110000111111100000110101111101 01011111011011100101010110010011
00000000100010011001101101010010 00000111111100011100101010010100
00111011010111111110010111010110 01101000011001010110001011100110
11001000010011100000101010011110 00000110101011111001101100100101
10010010111011110110010011010111 01100011111110010101111001011010
11100011000101100110011111010111 10000100001110111101111000010110
11101110111011001010100001011011 10100000010011111111001000100001
11111001000110001010110110111000 00010100101010001001001000011001
00010000100001000101001100011101 01100000100100111110000011001101
10000011000000110101111111101001 11010101101011100111100100111000
00111001001111110000010110101101 11111011010010110001101111101111
11101011011101011111111100101001 01101010001101101001010100110100
00100010111111001001110011011000 10101001011101000000110100101011
01100000110011110011100010000101 11000100101011001001100000111010
00010001010000101111110110101101 10110000101100000001110111011001
10011000111100001100001101101111 01110010000101111011100000011110
10100010110101000110011110011010 00000001000011111001100101111011
11111100000101110100111100001010 11000010110000101110101100010110
Шаг 6 - Сжатие
- Инициализируйте переменные a, b, c, d, e, f, g, h и установите их равными текущим значениям хэша соответственно. h0, h1, h2, h3, h4, h5, h6, h7
- Запустите цикл сжатия. Цикл сжатия изменит значения a…h. Цикл сжатия выглядит следующим образом:
- для я от 0 до 63
- S1 = (e правый поворот 6) xor (e правый поворот 11) xor (e правый поворот 25)
- ch = (e и f) xor ((не e) и g)
- temp1 = h + S1 + ch + k[i] + w[i]
- S0 = (правый поворот 2) xor (правый поворот 13) xor (правый поворот 22)
- maj = (a и b) xor (a и c) xor (b и c)
- темп2 := S0 + основной
- ч = г
- г = ф
- ф = е
- е = д + темп1
- д = с
- с = б
- б = а
- а = темп1 + темп2
Пройдем первую итерацию, все сложения вычисляются по модулю 2^32:
а = 0x6a09e667 = 01101010000010011110011001100111
б = 0xbb67ae85 = 10111011011001111010111010000101
с = 0x3c6ef372 = 00111100011011101111001101110010
д = 0xa54ff53a = 10100101010011111111010100111010
е = 0x510e527f = 01010001000011100101001001111111
f = 0x9b05688c = 10011011000001010110100010001100
г = 0x1f83d9ab = 00011111100000111101100110101011
ч = 0x5be0cd19 = 01011011111000001100110100011001
e правый поворот 6:
01010001000011100101001001111111 -> 11111101010001000011100101001001
e правый поворот 11:
01010001000011100101001001111111 -> 01001111111010100010000111001010
e правый поворот 25:
01010001000011100101001001111111 -> 10000111001010010011111110101000
S1 = 11111101010001000011100101001001 XOR 010011111111010100010000111001010 XOR 10000111001010010011111110101000
S1 = 00110101100001110010011100101011
д и е:
01010001000011100101001001111111
& 10011011000001010110100010001100 =
00010001000001000100000000001100
примечание:
01010001000011100101001001111111 -> 10101110111100011010110110000000
(не e) и g:
10101110111100011010110110000000
& 00011111100000111101100110101011 =
00001110100000011000100110000000
ch = (e и f) xor ((не e) и g)
= 00010001000001000100000000001100 xor 00001110100000011000100110000000
= 00011111100001011100100110001100
// k[i] — константа округления
// w[i] — партия
temp1 = h + S1 + ch + k[i] + w[i]
temp1 = 01011011111000001100110100011001 + 00110101100111100111100101011 + 00011111100111110011110001100 + 0100001101101111111111000 + 0110100110010101110110110010111111000 + 0110100110010101101101110010111111000 + 011010011001010110110111100101111111 000 + 011010011001010110110110110011111111000.
темп1 = 01011011110111010101100111010100
правый поворот 2:
01101010000010011110011001100111 -> 110110101000001001111100110011001
правый поворот 13:
01101010000010011110011001100111 -> 00110011001110110101000001001111
поворот вправо 22:
01101010000010011110011001100111 -> 00100111100110011001110110101000
S0 = 11011010100000100111100110011001 XOR 00110011001110110101000001001111 XOR 00100111100110011001110110101000
S0 = 11001110001000001011010001111110
а и б:
01101010000010011110011001100111
& 10111011011001111010111010000101 =
00101010000000011010011000000101
а и в:
01101010000010011110011001100111
& 00111100011011101111001101110010 =
00101000000010001110001001100010
б и в:
10111011011001111010111010000101
& 00111100011011101111001101110010 =
00111000011001101010001000000000
maj = (a и b) xor (a и c) xor (b и c)
= 00101010000000011010011000000101 xor 00101000000010001110001001100010 xor 00111000011001101010001000000000
= 00111010011011111110011001100111
темп2 = S0 + май
= 11001110001000001011010001111110 + 00111010011011111110011001100111
= 00001000100100001001101011100101
ч = 00011111100000111101100110101011
г = 10011011000001010110100010001100
f = 01010001000011100101001001111111
е = 10100101010011111111010100111010 + 01011011110111010101100111010100
= 00000001001011010100111100001110
д = 00111100011011101111001101110010
с = 10111011011001111010111010000101
б = 01101010000010011110011001100111
а = 01011011110111010101100111010100 + 00001000100100001001101011100101
= 011001000110110111111010010111001
Весь этот расчет выполняется еще 63 раза с изменением переменных a-h. Мы не будем делать это вручную, но у нас будет эндер с:
h0 = 6A09E667 = 01101010000010011110011001100111
h1 = BB67AE85 = 10111011011001111010111010000101
h2 = 3C6EF372 = 00111100011011101111001101110010
h3 = A54FF53A = 10100101010011111111010100111010
h4 = 510E527F = 01010001000011100101001001111111
h5 = 9B05688C = 10011011000001010110100010001100
h6 = 1F83D9AB = 00011111100000111101100110101011
h7 = 5BE0CD19 = 01011011111000001100110100011001
а = 4F434152 = 01001111010000110100000101010010
б = D7E58F83 = 11010111111001011000111110000011
с = 68BF5F65 = 01101000101111110101111101100101
д = 352DB6C0 = 00110101001011011011011011000000
е = 73769D64 = 01110011011101101001110101100100
f = DF4E1862 = 11011111010011100001100001100010
г = 71051E01 = 01110001000001010001111000000001
ч = 870F00D0 = 10000111000011110000000011010000
Шаг 7 - Изменить окончательные значения
После цикла сжатия, но все еще в цикле chunk, мы изменяем хеш-значения, добавляя к ним соответствующие переменные, a-h. Как обычно, все сложения выполняются по модулю 2^32.
h0 = h0 + a = 10111001010011010010011110111001
h1 = h1 + b = 10010011010011010011111000001000
h2 = h2 + c = 10100101001011100101001011010111
h3 = h3 + d = 11011010011111011010101111111010
h4 = h4 + e = 11000100100001001110111111100011
h5 = h5 + f = 01111010010100111000000011101110
h6 = h6 + g = 10010000100010001111011110101100
h7 = h7 + h = 11100010111011111100110111101001
Шаг 8 - Объединить окончательный хэш
И последнее, но не менее важное: соедините их все вместе, подойдет простая конкатенация строк.
дайджест = h0 добавить h1 добавить h2 добавить h3 добавить h4 добавить h5 добавить h6 добавить h7
= B94D27B9934D3E08A52E52D7DA7DABFAC484EFE37A5380EE9088F7ACE2EFCDE9
Готово! Мы прошли каждый шаг (за исключением некоторых итераций) SHA-256 в мучительных деталях :)
Я рад, что вы зашли так далеко! Пошаговое изучение алгоритма SHA-256 — это не совсем прогулка по парку. Однако изучение основ, лежащих в основе веб-безопасности, может стать огромным благом для вашей карьеры специалиста по информатике, так что продолжайте в том же духе!
Псевдокод
Если вы хотите увидеть все шаги, которые мы только что сделали выше, в виде псевдокода, то вот он, прямо из WikiPedia:
Примечание 1. Все переменные представляют собой 32-битные целые числа без знака, а сложение вычисляется по модулю 232.
Примечание 2. Для каждого раунда существует одна константа раунда k[i] и одна запись в массиве расписания сообщений w[i], 0 ≤ i ≤ 63.
Примечание 3: Функция сжатия использует 8 рабочих переменных, от a до h.
Примечание 4. При выражении констант в этом псевдокоде используется соглашение с обратным порядком байтов.
и при разборе данных блока сообщений из байтов в слова, например,
первое слово входного сообщения "abc" после заполнения равно 0x61626380
Инициализировать хеш-значения:
(первые 32 бита дробных частей квадратных корней первых 8 простых чисел 2..19):
ч0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19
Инициализировать массив круглых констант:
(первые 32 бита дробных частей кубических корней первых 64 простых чисел 2..311):
к[0..63] :=
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
Предварительная обработка (заполнение):
начать с исходного сообщения длиной L бит
добавить один бит «1»
добавить K «0» битов, где K — минимальное число >= 0 такое, что L + 1 + K + 64 кратно 512
добавить L как 64-битное целое число с обратным порядком байтов, в результате чего общая длина постобработки будет кратна 512 битам.
Обработайте сообщение последовательными 512-битными порциями:
разбить сообщение на 512-битные куски
для каждого куска
создать массив расписания сообщений с 64 элементами w[0..63] из 32-битных слов
(Начальные значения в w[0..63] не имеют значения, поэтому многие реализации обнуляют их здесь)
скопировать фрагмент в первые 16 слов w[0..15] массива расписания сообщений
Расширьте первые 16 слов до оставшихся 48 слов w[16..63] массива расписания сообщений:
для меня от 16 до 63
s0 := (w[i-15] поворот вправо 7) xor (w[i-15] поворот вправо 18) xor (w[i-15] сдвиг вправо 3)
s1 := (w[i- 2] поворот вправо 17) xor (w[i- 2] поворот вправо 19) xor (w[i- 2] сдвиг вправо 10)
w[i] := w[i-16] + s0 + w[i-7] + s1
Инициализировать рабочие переменные текущим значением хеша:
a := h0
б := ч1
с := h2
д := ч3
е := h4
ф := h5
г := h6
ч := ч7
Основной цикл функции сжатия:
для я от 0 до 63
S1 := (e правый поворот 6) xor (e правый поворот 11) xor (e правый поворот 25)
ch := (e и f) xor ((не e) и g)
temp1 := h + S1 + ch + k[i] + w[i]
S0 := (правый поворот 2) xor (правый поворот 13) xor (правый поворот 22)
maj := (a и b) xor (a и c) xor (b и c)
темп2 := S0 + основной
ч := г
г := е
е := е
е := д + темп1
д := с
с := б
б := а
а := темп1 + темп2
Добавьте сжатый фрагмент к текущему значению хеша:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + с
h3 := h3 + d
h4 := h4 + е
h5 := h5 + f
h6 := h6 + г
h7 := h7 + h
Произведите окончательное значение хеш-функции (с прямым порядком байтов):
дайджест := хэш := h0 добавить h1 добавить h2 добавить h3 добавить h4 добавить h5 добавить h6 добавить h7
Также опубликовано [Здесь] (https://blog.boot.dev/cryptography/how-sha-2-works-step-by-step-sha-256/)
© Boot.dev 2022 | Карта сайта | Партнеры | [Детская площадка] (https://boot.dev/playground/go) | Условия использования | Конфиденциальность | Контакт | Часто задаваемые вопросы
Оригинал