SHA-256 — что это такое простыми словами и как работает, функции и примеры алгоритма хеширования | blockchain24.pro

Sha-256 – что можно майнить

Все форки Bitcoin пошли по простому пути и используют тот же алгоритм хэширования. Сюда входят известные «альткоины»: Bitcoin Cash, Namecoin, Peercoin, Emercoin и сотни других, менее популярных.

Ethereum разработал собственную функцию Ethash, чтобы допустить к добыче только видеокарты (до момента полного переключения на Ethereum 2.0). Litecoin – Scrypt (в попытках быть резистентным к асикам). Современные криптовалюты предпочитают алгоритм Proof-of-Stake, в которых добыча криптовалют называется стейкингом. Традиционные Proof-of-Work вычисления становятся инвесторам всё менее интересными.

Что такое алгоритм хэширования и шифрования sha256 (sha 256 algorithm)?

Задача хэширования – превратить информацию в строку. Функция может принять данные неограниченного размера, даже 10 мегабайт текста из 1000 книг. Процесс хеширования происходит раундами (кругами) – так можно уместить в строку любой объем. Но расшифровать обратно уже не получится. Если кому-то удастся это сделать, то алгоритм автоматически потеряет смысл.

Задача шифрования – превратить информацию в условно хаотичный набор символов, расшифровать которые можно только с помощью ключа. Зашифрованный файл размером в 10 мегабайт будет занимать как минимум столько же места, что и является главным отличием его от хэширования: оно превращает любой объем данных в строку одинаковой длины.

Биткоин не использует шифрование. Приставка «крипто» (crypto – encrypt – шифровать) в его обозначении «криптовалюта», была присвоена ему только потому, что его алгоритм цифровой подписи использует методы, основанные на эллиптических кривых, что применяются в шифровании.

Вместо этого пользователь генерирует пару – открытый и закрытый ключ. Они связаны математически, и мы можем утверждать, что получить закрытый ключ из открытого – невозможно, что и подтверждает право владения BTC.

В блокчейне у всех транзакций есть неизрасходованные выходы (UTXO), а проще говоря – балансы. Они связаны с биткоин-адресами и мы можем просматривать их в сети публично. Имея на балансе 1 BTC, у вас есть закрытый ключ от открытого ключа с этим UTXO, а значит вы сможете подписать транзакцию и будет создан новый UTXO с передачей права на открытый ключ получателя.

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

Алгоритм удовлетворяет 4 ключевым требованиям:

• Детерминированный (для любого ввода вывод будет одинаковым)

• Уникальный (невозможно, чтобы 2 ввода привели к одинаковому выводу)

• Быстрый (в протоколе Bitcoin скорость примерно 140 Мбит/сек)

• Необратимый (исходное значение не может быть получено из полученного хэша)

Sha-256 «hello world». шаг 1. предварительная обработка

1. Преобразуем «hello world» в двоичный вид:

01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111
01110010 01101100 01100100

2. Добавим одну единицу:

01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111
01110010 01101100 01100100 1

3. Заполняем нулями до тех пор, пока данные не станут кратны 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

4. Добавим 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 00000000 01011000

Теперь у нас есть ввод, который всегда будет без остатка делиться на 512.

Алгоритм sha-2 в виде псевдокода

Если вы хотите посмотреть на все шаги, которые мы только что сделали, в виде псевдокода, то вот пример:

Пояснения:
 Все переменные беззнаковые, имеют размер 32 бита и при вычислениях суммируются по модулю 232
 message — исходное двоичное сообщение
 m — преобразованное сообщение

Инициализация переменных
 (первые 32 бита дробных частей квадратных корней первых восьми простых чисел [от 2 до 19]):
h0 := 0x6a09e667
h1 := 0xbb67ae85
h2 := 0x3c6ef372
h3 := 0xa54ff53a
h4 := 0x510e527f
h5 := 0x9b05688c
h6 := 0x1f83d9ab
h7 := 0x5be0cd19

Таблица констант
(первые 32 бита дробных частей кубических корней первых 64 простых чисел [от 2 до 311]):
k[ 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

Предварительная обработка:
m := message ǁ [единичный бит]
m := m ǁ [k нулевых бит], где k — наименьшее неотрицательное число, такое что 
                 (L   1   K) mod 512 = 448, где L — число бит в сообщении (сравнима по модулю 512 c 448)
m := m ǁ Длина(message) — длина исходного сообщения в битах в виде 64-битного числа
            с порядком байтов от старшего к младшему

Далее сообщение обрабатывается последовательными порциями по 512 бит:
разбить сообщение на куски по 512 бит
для каждого куска
    разбить кусок на 16 слов длиной 32 бита (с порядком байтов от старшего к младшему внутри слова): w[ 0..15 ]


    Сгенерировать дополнительные 48 слов:
    для i от 16 до 63
        s0 := (w[i-15] rightrotate  7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift  3)
        s1 := (w[i- 2] rightrotate 17) xor (w[i- 2] rightrotate 19) xor (w[i- 2] rightshift 10)
        w[i] := w[i-16]   s0   w[i-7]   s1

    Инициализация вспомогательных переменных:
    a := h0
    b := h1
    c := h2
    d := h3
    e := h4
    f := h5
    g := h6
    h := h7

    Основной цикл:
    для i от 0 до 63
        S1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
        ch := (e and f) xor ((not e) and g)
        temp1 := h   S1   ch   k[i]   w[i]
        S0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
        maj := (a and b) xor (a and c) xor (b and c)
        temp2 := S0   maj
 
        h := g
        g := f
        f := e
        e := d   temp1
        d := c
        c := b
        b := a
        a := temp1   temp2

    Добавить полученные значения к ранее вычисленному результату:
    h0 := h0   a
    h1 := h1   b
    h2 := h2   c
    h3 := h3   d
    h4 := h4   e
    h5 := h5   f
    h6 := h6   g
    h7 := h7   h

Получить итоговое значение хеша SHA-2:
digest := hash := h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7

Перевод статьи «How SHA-2 Works Step-By-Step (SHA-256)»

Древо меркла

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

Корень Меркла добавляется в функцию наоборот. Например: b7a0c5014ae6ecb…707a42516e94899073 вместо 37099849e61524…019efbce6ea4105c0a7b.

Как работает майнинг на кодировке sha-256?

В интернете есть сайты с конвертацией любого текста с помощью функции SHA-256. Можно попробовать сделать это самому. 

Например, слово «Hello»: 185f8db32271fe25f561a…a518007d1764826381969.

Выходная строка неизменна, это отличает хэширование от шифрования. Если другой человек с другого устройства введёт «Hello», он получит ту же строку.

Bitcoin использует двойное хеширование. Полученный хэш, он пропускает повторно через SHA-256. Это нужно во избежание атаки «дней рождения», хотя вероятность её невелика.

Например, вводим полученный хэш от «Hello»: 185f8db32271fe25f561a…da518007d1764826381969 = 52c87cd40ccfbd78…d4c3684ed60f6513e8d16077e5b8e.

По такому принципу собирается и обрабатывается целый ряд данных. Результат – блокчейн. Цепочка блоков, образно растущая вверх. Нижние блоки невозможно достать и подменить, не разрушив при этом всё строение сети.

Криптоанализ и проверка

Для хеш-функции, для которой L – количество битов в дайджесте сообщения , поиск сообщения, которое соответствует заданному дайджесту сообщения, всегда можно выполнить с помощью поиска методом грубой силы в 2 L оценок.

Это называется атакой по прообразу и может быть практичным или непрактичным в зависимости от L и конкретной вычислительной среды. Второй критерий, обнаружение двух разных сообщений, которые производят один и тот же дайджест сообщения, известный как коллизия , требует в среднем только 2 оценок L / 2 с использованием атаки дня рождения .

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

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

В случае подписания документа злоумышленник не может просто подделать подпись существующего документа – злоумышленник должен будет предъявить пару документов, один безобидный и один опасный, и заставить держателя закрытого ключа подписать безобидный документ.

Повышенный интерес к криптографическому анализу хешей во время соревнований SHA-3 привел к появлению нескольких новых атак на семейство SHA-2, лучшие из которых приведены в таблице ниже. Только атаки столкновения имеют практическую сложность; ни одна из атак не распространяется на хеш-функцию полного раунда.

На FSE 2021 исследователи Sony выступили с презентацией, в которой предлагалось расширить возможности псевдоколлизионных атак до 52 раундов на SHA-256 и 57 раундов на SHA-512, опираясь на атаку с использованием псевдопрообраза biclique .

Метка времени (timestamp)

В формате системы Unix, количество секунд от начала эпохи (1 января 1970, 00:00).

Принимается сетью, только если число больше медианы временных штампов последних 11 блоков, и меньше медианы штампов, что возвращают подключённые ноды (скорректированное сетью время) 2 часа. 

Биткоин использует беззнаковое целое число для метки времени, поэтому «проблема 2038 года» откладывается еще на 68 лет.

Пример: c6f5d64b.

Нонс (nonce)

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

Мы взяли 5 известных значений, описанных выше и теперь можем начать подставлять nonce в функцию, покуда не будет найден хэш, меньше таргета. 

1, 2, 3… 40348, 40349… 168437213, 168437214, 168437215…

Когда нонс подойдёт, и мы получим хэш-значение меньше таргета, установленного сетью, новый блок будет найден. Майнер может добавить в него избранные транзакции (не превышая допустимый размер блока: 1,5 МБ) забетонировать их в нём и получить за это комиссию.

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

Обзор

Хеш-функция, Также известна как хэш-функция или хеш-функция. Хеш-функция – это общедоступная функция, которая может отображать сообщение M любой длины в более короткое и фиксированное значение H (M). H (M) называется хеш-значением, хеш-значением (хеш-значением) и хеш-значением или сообщением. Дайджест.

Его функциональное выражение: h = H (m)

Независимо от того, в каком цифровом формате вводятся данные или насколько велик файл, на выходе получается битовая строка фиксированной длины. В качестве примера возьмем алгоритм Sh256, используемый Биткойном. Независимо от того, какой файл данных вводится, на выходе будет 256 бит.

Алгоритм хеширования

Преобразуйте URL-адрес A в число 1. URL B, преобразованный в число 2.

Адрес веб-сайта X преобразуется в число N. По индексу N в качестве нижнего индекса можно быстро найти информацию об адресе веб-сайта X. Этот процесс преобразования представляет собой алгоритм хеширования.

Например, здесь десять тысяч песен, дайте вам новую песню X и попросите вас подтвердить, входит ли эта песня в эти десять тысяч песен.

Несомненно, сравнивать 10 000 песен одну за другой – это очень медленно. Но если есть способ сжать каждую часть данных 10000 песен в число (называемое хеш-кодом), а затем получить 10000 чисел, тогда используйте тот же алгоритм для вычисления кода новой песни X, посмотрите, если код песни X находится в предыдущих десяти тысячах номеров, вы можете узнать, входит ли песня X в десять тысяч песен.

Например, если вы хотите организовать 10 000 песен, простой алгоритм хеширования должен использовать количество байтов жесткого диска, занятого песней, в качестве хэш-кода. В этом случае вы можете сделать 10 000 песен «отсортировать по размеру», а затем встретить новую песню, просто проверьте, совпадает ли количество байтов новой песни с одной из существующих 10 000 песен. Если количество байтов равно То же самое, мы знаем, входит ли новая песня в число 10 000 песен.

Надежный алгоритм хеширования должен удовлетворять:

Для заданных данных M легко вычислить хеш-значение X = F (M);

Обратно вычислить M по X сложно;

Трудно найти M и N такие, что F (N) = F (M)

Обобщите характеристики хэш-шифрования：

1. Легко сжимать: для ввода x любого размера длина хэш-значения очень мала.В практических приложениях длина хеш-значения, генерируемого функцией H, является фиксированной.

2. Легко вычислить: для любого сообщения легче вычислить его хеш-значение.

3. Необратимый: для данного значения хэша трудно найти обратное хеш-значение, которое невозможно вычислить. Учитывая некоторую хеш-функцию H и хеш-значение H (M), вычислить M невозможно. Таким образом, исходное значение ввода не может быть отменено хеш-выводом. Это основа безопасности хэш-функции.

4. Устойчивость к коллизиям: идеальная хеш-функция не содержит коллизий, но этого трудно добиться при разработке реального алгоритма.
   Существует два типа сопротивления столкновениям: первый – слабое сопротивление столкновениям, то есть для данного сообщения невозможно найти другое сообщение с вычислительной точки зрения, а другой – сильное сопротивление столкновениям. , то есть для любой пары разных сообщений это также невозможно с вычислительной точки зрения.

5. Высокая чувствительность: это с точки зрения битов, что означает, что изменение входа на 1 бит вызовет изменение 1/2 бита. Любое изменение сообщения M приведет к изменению хэш-значения H (M). То есть, если ввод немного отличается, вывод после операции хеширования должен быть другим.

Хеш-шифрование нельзя взломатьВ 2004 году профессор Ван Сяоюнь анонсировал ключевую технологию взлома хеш-функции на Международной конференции по криптографии.

Оборудование для майнинга

В сравнении с алгоритмом RandomX Monero (только CPU), SHA-256 майнинг не может быть устойчив к ASIC или GPU.

Для добычи BTC может использоваться любой процессор. В гонке за скоростью перебора хэшей выигрывают ASIC майнеры (интегральные схемы особого назначения), спроектированные специально под задачу добычи Bitcoin. Самые популярные производители: Bitmain, MicroBT.

Особенности sha-256

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

Далее её можно использовать в своих целях, наделяя особенностями. Например Bitcoin сделал двойное SHA-256.

Официальная проверка

Реализация всех функций безопасности, утвержденных FIPS, может быть официально подтверждена с помощью программы CMVP , совместно управляемой Национальным институтом стандартов и технологий (NIST) и организацией по обеспечению безопасности связи (CSE).

По состоянию на декабрь 2021 года существует более 1300 проверенных реализаций SHA-256 и более 900 SHA-512, при этом только 5 из них способны обрабатывать сообщения с длиной в битах, не кратной восьми, при поддержке обоих вариантов.

Предисловие

Наиболее часто используемым алгоритмом шифрования среди всех алгоритмов шифрования является хеш-шифрование. Алгоритмы шифрования, с которыми многие люди впервые сталкиваются, такие как MD5 и SHA1, являются типичными алгоритмами хеш-шифрования, а хеш-шифрование используется не только для шифрования паролей, но Существует множество применений, таких как извлечение резюме контента, генерация подписей, сравнение документов, цепочка блоков и так далее. В этой статье подробно рассказывается о шифровании хэшей и рассказывается о классе инструментов хеш-шифрования.

Приложения

Хэш-функция SHA-2 реализована в некоторых широко используемых приложениях и протоколах безопасности, включая TLS и SSL , PGP , SSH , S / MIME и IPsec .

SHA-256 участвует в процессе аутентификации программных пакетов Debian и в стандарте подписи сообщений DKIM ; SHA-512 является частью системы проверки подлинности архивного видео Международного уголовного трибунала по геноциду в Руанде .

Несколько криптовалют , включая биткойн , используют SHA-256 для проверки транзакций и расчета доказательства работы или подтверждения доли . Повышение СИС SHA-2 ускорительных чипов привело к использованию Scrypt -На схем корректуры из-работы.

SHA-1 и SHA-2 – это алгоритмы безопасного хеширования, необходимые по закону для использования в определенных государственных приложениях США , включая использование в других криптографических алгоритмах и протоколах, для защиты конфиденциальной несекретной информации.

FIPS PUB 180-1 также поощрял принятие и использование SHA-1 частными и коммерческими организациями. SHA-1 выводится из эксплуатации для большинства государственных нужд; Национальный институт стандартов и технологий США заявляет: «Федеральные агентства должны прекратить использование SHA-1 для … приложений, требующих защиты от коллизий, как можно скорее, и должны использовать семейство хэш-функций SHA-2 для этих приложений после 2021 года». (курсив в оригинале).

Первоначально функции SHA-2 не были быстро приняты, несмотря на лучшую безопасность, чем SHA-1. Причины могут включать отсутствие поддержки SHA-2 в системах под управлением Windows XP SP2 или более ранней версии, а также отсутствие ощущаемой срочности, поскольку коллизии SHA-1 еще не были обнаружены.

Команда Google Chrome объявила о плане постепенного прекращения поддержки сертификатов TLS, зависящих от SHA-1, в их браузере в период с конца 2021 по начало 2021 года. Точно так же Microsoft объявила, что Internet Explorer и Edge перестанут поддерживать общедоступные сертификаты SHA-1.

Сертификаты TLS от февраля 2021 года. Mozilla отключила SHA-1 в начале января 2021 года, но пришлось временно повторно включить его с помощью обновления Firefox после проблем с веб-интерфейсом пользователя некоторых моделей маршрутизаторов и устройств безопасности .

Список криптовалют на sha-256

Отсортированы по размеру капитализации.

• Bitcoin
• Bitcoin Cash
• Bitcoin SV
• Bitcoin Diamond
• BitcoinV
• Namecoin
• ILCoin
• EmerCoin
• Unobtanium
• Litecoin Cash
• Amoveo
• Freicoin
• Bean Cash
• I0Coin
• ADAMANT Messenger
• Internet Of People
• IXCoin
• Sakura Bloom
• Ultimate Secure Cash
• Qbao
• TerraCoin
• Swing
• PRISM
• Sprouts
• Neutron
• Incakoin
• ZetaCoin
• Nubits
• BitTokens
• TRBO
• И ещё сотни с капитализацией менее 100 тыс. $

Сравнение функций sha

В таблице ниже внутреннее состояние означает «внутреннюю хеш-сумму» после каждого сжатия блока данных.

В столбце поразрядных операций «Rot» обозначает вращение без переноса , а «Shr» обозначает логический сдвиг вправо . Все эти алгоритмы в той или иной мере используют модульное сложение, за исключением SHA-3.

Более подробные измерения производительности на современных архитектурах процессоров приведены в таблице ниже.

Номера производительности с пометкой «x86» выполнялись с использованием 32-битного кода на 64-битных процессорах, тогда как номера «x86-64» – это собственный 64-битный код. Хотя SHA-256 предназначен для 32-битных вычислений, он действительно выигрывает от кода, оптимизированного для 64-битных процессоров на архитектуре x86.

32-битные реализации SHA-512 значительно медленнее своих 64-битных аналогов. Варианты обоих алгоритмов с разными размерами вывода будут работать одинаково, поскольку функции раскрытия и сжатия сообщений идентичны, и различаются только начальные значения хеш-функции и размеры вывода. Лучшие реализации MD5 и SHA-1 выполняют от 4,5 до 6 циклов на байт на современных процессорах.

Тестирование проводилось Иллинойским университетом в Чикаго на их системе Hydra8, работающей на Intel Xeon E3-1275 V2 с тактовой частотой 3,5 ГГц, и на их системе Hydra9 с APU AMD A10-5800K с тактовой частотой 3,8 ГГц. Указанные выше скорости циклов на байт являются средней производительностью алгоритма, обрабатывающего сообщение размером 4096 байт с использованием программного обеспечения для криптографического тестирования SUPERCOP.

Сравнение хеш-шифрования и симметричного / асимметричного шифрования

в основном имеет следующие отличия:

1. Хешированный пароль необратим, поэтому исходный текст не может быть получен из зашифрованного текста, в то время как симметричное / асимметричное шифрование может;
2. В большинстве случаев для шифрования хеш-паролей ключ не требуется (кроме HMAC), тогда как для симметричного / асимметричного шифрования требуется;
3. Независимо от того, является ли хеш-шифрование короткими или длинными данными, длина зашифрованного текста, полученного после шифрования, является фиксированной, а симметричный / асимметричный обычно пропорционален длине исходного текста;
4. Шифрование хэша может конфликтовать. Хотя теоретическое шифрование хешей невозможно, это всего лишь теория. Профессор Ван Сяоюнь ранее предлагал метод коллизий. Для симметричного / асимметричного результата дешифрования зашифрованного текста с помощью ключа должен быть уникальным;

Стандарт хеширования

Одна итерация функции сжатия семейства SHA-2. Синие компоненты выполняют следующие операции: Побитовое вращение использует разные константы для SHA-512. Приведены числа для SHA-256. Красный – это сложение по модулю 2

³² для SHA-256 или 2 ⁶⁴ для SHA-512.
Ch⁡(E,F,грамм)знак равно(E∧F)⊕(¬E∧грамм){ displaystyle operatorname {Ch} (E, F, G) = (E land F) oplus ( neg E land G)}
Ма⁡(А,B,C)знак равно(А∧B)⊕(А∧C)⊕(B∧C){ Displaystyle OperatorName {Ma} (A, B, C) = (A земля B) oplus (A land C) oplus (B land C)}
Σ0(А)знак равно(А⋙2)⊕(А⋙13)⊕(А⋙22){ Displaystyle Sigma _ {0} (A) = (A ! ggg ! 2) oplus (A ! ggg ! 13) oplus (A ! ggg ! 22)}
Σ1(E)знак равно(E⋙6)⊕(E⋙11)⊕(E⋙25){ Displaystyle Sigma _ {1} (E) = (E ! ggg ! 6) oplus (E ! ggg ! 11) oplus (E ! ggg ! 25)}

⊞{ displaystyle color {красный} boxplus}

С публикацией FIPS PUB 180-2 NIST добавил три дополнительных хэш-функции в семейство SHA. Все алгоритмы известны как SHA-2, названные в соответствии с длиной их дайджеста (в битах): SHA-256, SHA-384 и SHA-512.

Таргет (target)

Сложность следующей цели. Пересчитывается каждые 2021 блоков (примерно 2 недели). Если хэшрейт в сети будет расти, увеличится и количество нулей в таргете искомого хеша, что потребует перебора большего количества хэшей при майнинге криптовалюты. И наоборот, уменьшение желающих участвовать в добыче BTC и валидации блоков, уменьшает сложность и «снижает» таргет. За 1 цикл не может быть изменён более чем в х4 раза.

Например таргет генезис блока был 00000000ffff00000000000000…00000, в 2021 уже 0000000000000529b10000000…00000, в 2021 – 00000000000000000049500d0…00000, а в 2021 – 0000000000000000000cdf6f00…00000. Судя по количеству нулей, можно легко наблюдать рост сложности.

Помещается в функцию тоже в компактном 4-байтном формате вида: f2c9749a.

Тестовые векторы

Хеш-значения пустой строки (т. Е. Входного текста нулевой длины).

SHA224("")
0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
SHA256("")
0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
SHA384("")
0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b
SHA512("")
0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e
SHA512/224("")
0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4
SHA512/256("")
0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a

Даже небольшое изменение в сообщении (с огромной вероятностью) приведет в основном к другому хешу из-за эффекта лавины . Например, добавление точки в конец следующего предложения изменяет почти половину (111 из 224) бит в хеш-коде:

SHA224("The quick brown fox jumps over the lazy dog")
0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525
SHA224("The quick brown fox jumps over the lazy dog.")
0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c

Хэш предыдущего блока

Скрепляет блокчейн, гарантируя, что следующий блок будет ссылаться на прежде подтверждённый.

Вводится наоборот. Например: 05c2ddc616d1b90…0000000000000000 вместо оригинального 000000000000000…346f13a009b1d616cdd2c50. 

Зеркальное отражение строки избавляет алгоритм от потери детализации. Чем больше значений, тем меньше вероятность того, что сложность окажется слишком трудной или слишком лёгкой.

Шаг 3. инициализация округлённых констант (k)

Создадим ещё немного констант, на этот раз их 64. Каждое значение — это первые 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

Шаг 5. создаём очередь сообщений (w)

1. Копируем входные данные из шага 1 в новый массив, где каждая запись является 32-битным словом:

01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000001011000

2. Добавляем ещё 48 слов, инициализированных нулями, чтобы получить массив w[0…63]:

01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000001011000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
...
...
00000000000000000000000000000000 00000000000000000000000000000000

3. Изменяем нулевые индексы в конце массива, используя следующий алгоритм:

• For i from w[16…63]:
  • s0 = (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] righthift 3)
  • s1 = (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor (w[i-2] righthift 10)
  • w [i] = w[i-16] s0 w[i-7] s1

Давайте посмотрим, как это работает для w[16]:

w[1] rightrotate 7:
  01101111001000000111011101101111 -> 11011110110111100100000011101110
w[1] rightrotate 18:
  01101111001000000111011101101111 -> 00011101110110111101101111001000
w[1] rightshift 3:
  01101111001000000111011101101111 -> 00001101111001000000111011101101

s0 = 11011110110111100100000011101110 XOR 00011101110110111101101111001000 XOR 00001101111001000000111011101101

s0 = 11001110111000011001010111001011

w[14] rightrotate 17:
  00000000000000000000000000000000 -> 00000000000000000000000000000000
w[14] rightrotate19:
  00000000000000000000000000000000 -> 00000000000000000000000000000000
w[14] rightshift 10:
  00000000000000000000000000000000 -> 00000000000000000000000000000000

s1 = 00000000000000000000000000000000 XOR 00000000000000000000000000000000 XOR 00000000000000000000000000000000

s1 = 00000000000000000000000000000000

w[16] = w[0]   s0   w[9]   s1

w[16] = 01101000011001010110110001101100   11001110111000011001010111001011   00000000000000000000000000000000   00000000000000000000000000000000

// сложение рассчитывается по модулю 2^32

w[16] = 00110111010001110000001000110111

Это оставляет нам 64 слова в нашей очереди сообщений (w):

01101000011001010110110001101100 01101111001000000111011101101111
01110010011011000110010010000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000000000000
00000000000000000000000000000000 00000000000000000000000001011000
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. цикл сжатия

1. Инициализируем переменные a, b, c, d, e, f, g, h и установим их равными текущим значениям хеша соответственно. h0, h1, h2, h3, h4, h5, h6, h7.
2. Запустим цикл сжатия, который будет изменять значения a…h . Цикл выглядит следующим образом:

• for i from 0 to 63
  • S1 = (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
  • ch = (e and f) xor ((not e) and g)
  • temp1 = h S1 ch k[i] w[i]
  • S0 = (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
  • maj = (a and b) xor (a and c) xor (b and c)
  • temp2 := S0 maj
  • h = g
  • g = f
  • f = e
  • e = d temp1
  • d = c
  • c = b
  • b = a
  • a = temp1 temp2

Давайте пройдём первую итерацию. Сложение рассчитывается по модулю 2^32:

a = 0x6a09e667 = 01101010000010011110011001100111
b = 0xbb67ae85 = 10111011011001111010111010000101
c = 0x3c6ef372 = 00111100011011101111001101110010
d = 0xa54ff53a = 10100101010011111111010100111010
e = 0x510e527f = 01010001000011100101001001111111
f = 0x9b05688c = 10011011000001010110100010001100
g = 0x1f83d9ab = 00011111100000111101100110101011
h = 0x5be0cd19 = 01011011111000001100110100011001

e rightrotate 6:
  01010001000011100101001001111111 -> 11111101010001000011100101001001
e rightrotate 11:
  01010001000011100101001001111111 -> 01001111111010100010000111001010
e rightrotate 25:
  01010001000011100101001001111111 -> 10000111001010010011111110101000
S1 = 11111101010001000011100101001001 XOR 01001111111010100010000111001010 XOR 10000111001010010011111110101000
S1 = 00110101100001110010011100101011

e and f:
    01010001000011100101001001111111
  & 10011011000001010110100010001100 =
    00010001000001000100000000001100
not e:
  01010001000011100101001001111111 -> 10101110111100011010110110000000
(not e) and g:
    10101110111100011010110110000000
  & 00011111100000111101100110101011 =
    00001110100000011000100110000000
ch = (e and f) xor ((not e) and g)
   = 00010001000001000100000000001100 xor 00001110100000011000100110000000
   = 00011111100001011100100110001100

// k[i] is the round constant
// w[i] is the batch
temp1 = h   S1   ch   k[i]   w[i]
temp1 = 01011011111000001100110100011001   00110101100001110010011100101011   00011111100001011100100110001100   1000010100010100010111110011000   01101000011001010110110001101100
temp1 = 01011011110111010101100111010100

a rightrotate 2:
  01101010000010011110011001100111 -> 11011010100000100111100110011001
a rightrotate 13:
  01101010000010011110011001100111 -> 00110011001110110101000001001111
a rightrotate 22:
  01101010000010011110011001100111 -> 00100111100110011001110110101000
S0 = 11011010100000100111100110011001 XOR 00110011001110110101000001001111 XOR 00100111100110011001110110101000
S0 = 11001110001000001011010001111110

a and b:
    01101010000010011110011001100111
  & 10111011011001111010111010000101 =
    00101010000000011010011000000101
a and c:
    01101010000010011110011001100111
  & 00111100011011101111001101110010 =
    00101000000010001110001001100010
b and c:
    10111011011001111010111010000101
  & 00111100011011101111001101110010 =
    00111000011001101010001000000000
maj = (a and b) xor (a and c) xor (b and c)
    = 00101010000000011010011000000101 xor 00101000000010001110001001100010 xor 00111000011001101010001000000000 
    = 00111010011011111110011001100111

temp2 = S0   maj
      = 11001110001000001011010001111110   00111010011011111110011001100111
      = 00001000100100001001101011100101

h = 00011111100000111101100110101011
g = 10011011000001010110100010001100
f = 01010001000011100101001001111111
e = 10100101010011111111010100111010   01011011110111010101100111010100
  = 00000001001011010100111100001110
d = 00111100011011101111001101110010
c = 10111011011001111010111010000101
b = 01101010000010011110011001100111
a = 01011011110111010101100111010100   00001000100100001001101011100101
  = 01100100011011011111010010111001

Все расчёты выполняются ещё 63 раза, изменяя переменные а…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

a = 4F434152 = 001001111010000110100000101010010
b = D7E58F83 = 011010111111001011000111110000011
c = 68BF5F65 = 001101000101111110101111101100101
d = 352DB6C0 = 000110101001011011011011011000000
e = 73769D64 = 001110011011101101001110101100100
f = DF4E1862 = 011011111010011100001100001100010
g = 71051E01 = 001110001000001010001111000000001
h = 870F00D0 = 010000111000011110000000011010000

Шаг 7. изменяем окончательные значения

После цикла сжатия, но ещё внутри основного цикла, мы модифицируем значения хеша, добавляя к ним соответствующие переменные 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