name: Внутреннее устройство биткойн-кошельков goal: Погрузиться в криптографические принципы, лежащие в основе биткойн-кошельков. objectives:

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

Путешествие в сердце биткойн-кошельков

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

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

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

С ясной педагогикой, более чем 60 пояснительными диаграммами и конкретными примерами, CYP201 позволит вам понять от А до Я, как работает ваш кошелек, чтобы вы могли с уверенностью навигировать во вселенной биткойна. Возьмите контроль над своими UTXO сегодня, понимая, как функционируют HD кошельки!

Введение

Введение в курс

Добро пожаловать на курс CYP201, где мы подробно исследуем работу HD биткойн-кошельков. Этот курс предназначен для всех, кто хочет понять технические основы использования биткойна, будь то случайные пользователи, просвещенные энтузиасты или будущие эксперты.

Цель этого обучения - дать вам ключи к освоению инструментов, которыми вы пользуетесь каждый день. HD биткойн-кошельки, которые находятся в сердце вашего пользовательского опыта, основаны на иногда сложных концепциях, которые мы постараемся сделать доступными. Вместе мы развеем эти тайны!

Прежде чем погружаться в детали конструкции и работы биткойн-кошельков, мы начнем с нескольких глав о криптографических примитивах, которые необходимо знать для дальнейшего. Мы начнем с криптографических хеш-функций, фундаментальных как для кошельков, так и для самого протокола биткойна. Вы узнаете их основные характеристики, конкретные функции, используемые в биткойне, и в более технической главе подробно узнаете о работе королевы хеш-функций: SHA256. CYP201

Далее мы обсудим работу алгоритмов цифровой подписи, которые вы используете каждый день для защиты ваших UTXO. Биткойн использует два: ECDSA и протокол Schnorr. Вы узнаете, какие математические примитивы лежат в основе этих алгоритмов и как они обеспечивают безопасность транзакций.

После того как мы хорошо разберемся с этими элементами криптографии, мы наконец перейдем к сердцу обучения: детерминированным и иерархическим кошелькам! Сначала будет раздел, посвященный мнемоническим фразам, этим последовательностям из 12 или 24 слов, которые позволяют вам создавать и восстанавливать ваши кошельки. Вы узнаете, как эти слова генерируются из источника энтропии и как они облегчают использование биткойна.

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

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

Это обучение позволит вам с уверенностью использовать программное обеспечение вашего кошелька, улучшая ваши навыки для идентификации и снижения рисков. Подготовьтесь стать настоящим экспертом в области Bitcoin кошельков!

Хеш-функции

Введение в хеш-функции

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

Определение и принцип хеширования

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

Например, хеш-функция SHA256 производит хеш фиксированной длины 256 бит. Таким образом, если мы используем вход "PlanB", сообщение произвольной длины, сгенерированный хеш будет следующим 256-битным отпечатком:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Характеристики хеш-функций

Эти криптографические хеш-функции имеют несколько существенных характеристик, которые делают их особенно полезными в контексте Bitcoin и других компьютерных систем:

Необратимость (или устойчивость к нахождению прообраза)
Устойчивость к изменениям (эффект лавины)
Устойчивость к коллизиям
Устойчивость ко второму прообразу

1. Необратимость (устойчивость к нахождению прообраза):

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

В данном примере, получение хеша 24f1b9… зная вход "PlanB" просто и быстро. Однако, найти сообщение "PlanB" зная только 24f1b9… невозможно.

Таким образом, невозможно найти прообраз $m$ для хеша $h$ так, чтобы $h = \text{HASH}(m)$ , где $\text{HASH}$ является криптографической хеш-функцией.

2. Устойчивость к изменениям (эффект лавины)

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

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Если мы сделаем очень незначительное изменение во входных данных, используя на этот раз "Planb", то простое изменение "B" на строчную "b" полностью изменяет выходной хеш SHA256:

bb038b4503ac5d90e1205788b00f8f314583c5e22f72bec84b8735ba5a36df3f

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

3. Устойчивость к коллизиям

Третьей характеристикой является устойчивость к коллизиям. Хеш-функция считается устойчивой к коллизиям, если вычислительно невозможно найти 2 разных сообщения, которые производят одинаковый хеш-вывод из функции. Формально, сложно найти два различных сообщения $m_1$ и $m_2$ так, что:

 $\text{HASH}(m_1) = \text{HASH}(m_2)$

На практике математически неизбежно, что для хеш-функций существуют коллизии, поскольку размер входных данных может быть больше размера выходных данных. Это известно как принцип ящиков Дирихле: если $n$ объектов распределены по $m$ ящикам, при условии, что $m < n$ , то по крайней мере один ящик обязательно будет содержать два или более объектов. Для хеш-функции этот принцип применим, потому что количество возможных сообщений (почти) бесконечно, в то время как количество возможных хешей конечно ( $2^{256}$ в случае SHA256).

Таким образом, эта характеристика не означает, что для хеш-функций не существует коллизий, а скорее, что хорошая хеш-функция делает вероятность нахождения коллизии пренебрежимо малой. Например, эта характеристика уже не подтверждается для алгоритмов SHA-0 и SHA-1, предшественников SHA-2, для которых были найдены коллизии. Эти функции, следовательно, теперь не рекомендуются и часто считаются устаревшими. Для хеш-функции из $n$ бит устойчивость к коллизиям имеет порядок $2^{\frac{n}{2}}$ , в соответствии с атакой по методу дней рождения. Например, для SHA256 ( $n = 256$ ) сложность нахождения коллизии имеет порядок $2^{128}$ попыток. На практике это означает, что если через функцию пройдет $2^{128}$ различных сообщений, вероятно, будет найдена коллизия.

4. Устойчивость к второму прообразу

Устойчивость к второму прообразу - еще одна важная характеристика хеш-функций. Она утверждает, что, имея сообщение $m_1$ и его хеш $h$ , вычислительно невозможно найти другое сообщение $m_2 \neq m_1$ , так что:

 $\text{HASH}(m_1) = \text{HASH}(m_2)$

Таким образом, устойчивость к второму прообразу в некотором смысле похожа на устойчивость к коллизиям, за исключением того, что здесь атака более сложная, потому что атакующий не может свободно выбирать $m_1$ .

Применение хеш-функций в Bitcoin

Наиболее используемая хеш-функция в Bitcoin — это SHA256 ("Secure Hash Algorithm 256 bits" — "Безопасный хеш-алгоритм, 256 бит"). Разработанная в начале 2000-х годов Агентством национальной безопасности (NSA) и стандартизированная Национальным институтом стандартов и технологий (NIST), она производит 256-битный хеш-вывод.

Эта функция используется во многих аспектах Bitcoin. На уровне протокола она участвует в механизме Proof-of-Work, где применяется двойное хеширование для поиска частичного столкновения между заголовком кандидата блока, созданного майнером, и целевым значением сложности. Если это частичное столкновение найдено, кандидат блок становится действительным и может быть добавлен в блокчейн.

SHA256 также используется при построении дерева Меркла, которое является аккумулятором, используемым для записи транзакций в блоках. Эта структура также найдена в протоколе Utreexo, который позволяет уменьшить размер набора UTXO. Кроме того, с введением Taproot в 2021 году, SHA256 используется в MAST (Merkelised Alternative Script Tree), что позволяет раскрывать только условия расходования, действительно использованные в скрипте, не раскрывая другие возможные варианты. Она также используется в расчете идентификаторов транзакций, при передаче пакетов по P2P-сети, в электронных подписях... Наконец, и это особенно интересно в рамках этого обучения, SHA256 используется на уровне приложений для построения кошельков Bitcoin и производства адресов.

Чаще всего, когда вы сталкиваетесь с использованием SHA256 в Bitcoin, это будет фактически двойной хеш SHA256, обозначаемый как "HASH256", который просто состоит из двукратного последовательного применения SHA256: HASH256(m) = SHA256(SHA256(m))

Эта практика двойного хеширования добавляет дополнительный уровень безопасности против определенных потенциальных атак, хотя одиночный SHA256 сегодня считается криптографически безопасным.

Другая хеш-функция, доступная в языке Script и используемая для получения адресов, — это функция RIPEMD160. Эта функция производит 160-битный хеш (таким образом, короче, чем SHA256). Обычно она сочетается с SHA256 для формирования функции HASH160:

 $\text{HASH160}(m) = \text{RIPEMD160}(\text{SHA256}(m))$

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

Наконец, только на уровне приложений иногда также используется функция SHA512, которая косвенно играет роль в производстве ключей для кошельков. Эта функция очень похожа на SHA256 в своей работе; обе принадлежат к одной семье SHA2, но SHA512 производит, как указывает ее название, 512-битный хеш, в сравнении с 256 битами для SHA256. Мы подробно рассмотрим ее использование в следующих главах.

Теперь вы знаете основные аспекты о хеш-функциях для дальнейшего изучения. В следующей главе я предлагаю подробнее рассмотреть работу функции, которая находится в самом сердце Bitcoin: SHA256. Мы разберем ее, чтобы понять, как она достигает описанных здесь характеристик. Следующая глава будет довольно длинной и технической, но она не является обязательной для продолжения обучения. Так что, если у вас возникнут трудности с пониманием, не беспокойтесь и переходите непосредственно к следующей главе, которая будет гораздо более доступной.

Внутреннее устройство SHA256

905eb320-f15b-5fb6-8d2d-5bb447337deb Мы ранее видели, что хеш-функции обладают важными характеристиками, которые оправдывают их использование в Bitcoin. Давайте теперь рассмотрим внутренние механизмы этих хеш-функций, которые придают им эти свойства, и для этого я предлагаю разобрать принцип работы SHA256. Функции SHA256 и SHA512 принадлежат к одной и той же семье SHA2. Их механизм основан на специфической конструкции, называемой конструкцией Меркла-Дамгора. RIPEMD160 также использует этот же тип конструкции.

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

Предварительная обработка входных данных

Для начала нам нужно подготовить наше входное сообщение $m$ так, чтобы его длина была стандартной и кратной 512 битам. Этот шаг критически важен для правильной работы алгоритма в дальнейшем. Для этого мы начинаем с шага добавления битов заполнения. Сначала мы добавляем к сообщению разделительный бит 1, за которым следует определенное количество битов 0. Количество добавляемых битов 0 рассчитывается так, чтобы общая длина сообщения после этого добавления была сравнима с 448 по модулю 512. Таким образом, длина $L$ сообщения с битами заполнения равна:

 $L \equiv 448 \mod 512$

$\text{mod}$ , для модуля, - это математическая операция, которая между двумя целыми числами возвращает остаток от Евклидова деления первого на второе. Например: $16 \mod 5 = 1$ . Это операция широко используется в криптографии.

Здесь шаг заполнения гарантирует, что после добавления 64 бит в следующем шаге общая длина выровненного сообщения будет кратной 512 битам. Если исходное сообщение имеет длину $M$ бит, то количество ( $N$ ) добавляемых битов 0 таково:

 $N = (448 - (M + 1) \mod 512) \mod 512$

Например, если исходное сообщение составляет 950 бит, расчет будет следующим:

 $\begin{align*} M & = 950 \\ M + 1 & = 951 \\ (M + 1) \mod 512 & = 951 \mod 512 \\ & = 951 - 512 \cdot \left\lfloor \frac{951}{512} \right\rfloor \\ & = 951 - 512 \cdot 1 \\ & = 951 - 512 \\ & = 439 \\ \\ 448 - (M + 1) \mod 512 & = 448 - 439 \\ & = 9 \\ \\ N & = (448 - (M + 1) \mod 512) \mod 512 \\ N & = 9 \mod 512 \\ & = 9 \end{align*}$

Таким образом, у нас было бы 9 битов 0 в дополнение к разделителю 1. Наши биты заполнения, которые должны быть добавлены непосредственно после нашего сообщения $M$ , таковы:

1000 0000 00

После добавления битов заполнения к нашему сообщению $M$ , мы также добавляем 64-битное представление исходной длины сообщения $M$ , выраженное в двоичном виде. Это позволяет хеш-функции быть чувствительной к порядку битов и длине сообщения. Если вернуться к нашему примеру с исходным сообщением из 950 бит, мы конвертируем десятичное число 950 в двоичное, что дает нам 1110 1101 10. Мы дополняем это число нулями в основании, чтобы получить в сумме 64 бита. В нашем примере это будет выглядеть так:

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 1011 0110

Этот размер дополнения добавляется в соответствии с дополнением битами. Таким образом, сообщение после нашей предварительной обработки состоит из трех частей:

Исходное сообщение $M$ ;
Бит 1, за которым следует несколько бит 0, чтобы сформировать дополнение битами;
64-битное представление длины $M$ для формирования дополнения с размером.

Инициализация переменных

SHA256 использует восемь начальных переменных состояния, обозначенных $A$ до $H$ , каждая из 32 бит. Эти переменные инициализируются специфическими константами, которые являются дробными частями квадратных корней из первых восьми простых чисел. Мы будем использовать эти значения в последующем процессе хеширования:

$A = 0x6a09e667$
$B = 0xbb67ae85$
$C = 0x3c6ef372$
$D = 0xa54ff53a$
$E = 0x510e527f$
$F = 0x9b05688c$
$G = 0x1f83d9ab$
$H = 0x5be0cd19$

SHA256 также использует 64 другие константы, обозначенные $K_0$ до $K_{63}$ , которые являются дробными частями кубических корней из первых 64 простых чисел:

 $K[0 \ldots 63] = \begin{pmatrix} 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 \end{pmatrix}$

Разделение входных данных

Теперь, когда у нас есть уравненный вход, мы перейдем к основной фазе обработки алгоритма SHA256: функции сжатия. Этот шаг очень важен, так как именно он придает хеш-функции криптографические свойства, которые мы изучали в предыдущей главе.

Сначала мы начинаем с разделения нашего уравненного сообщения (результат предварительной обработки) на несколько блоков $P$ по 512 бит каждый. Если наше уравненное сообщение имеет общий размер $n \times 512$ бит, у нас будет $n$ блоков, каждый по 512 бит. Каждый 512-битный блок будет обрабатываться индивидуально функцией сжатия, которая состоит из 64 раундов последовательных операций. Назовем эти блоки $P_1$ , $P_2$ , $P_3$ ...

Логические операции

Прежде чем подробно изучать функцию сжатия, важно понимать основные логические операции, используемые в ней. Эти операции, основанные на булевой алгебре, работают на уровне битов. Основные логические операции, используемые:

Конъюнкция (И): обозначается $\land$ , соответствует логическому "И".
Дизъюнкция (ИЛИ): обозначается $\lor$ , соответствует логическому "ИЛИ".
Отрицание (НЕТ): обозначается $\lnot$ , соответствует логическому "НЕТ".

Из этих базовых операций мы можем определить более сложные операции, такие как "Исключающее ИЛИ" (XOR) обозначается $\oplus$ , которое широко используется в криптографии. Каждую логическую операцию можно представить с помощью таблицы истинности, которая указывает результат для всех возможных комбинаций двоичных входных значений (два операнда $p$ и $q$ ). Для XOR ( $\oplus$ ):

$p$	$q$	$p \oplus q$
0	0	0
0	1	1
1	0	1
1	1	0

Для И ( $\land$ ):

$p$	$q$	$p \land q$
0	0	0
0	1	0
1	0	0
1	1	1

Для НЕ ( $\lnot p$ ):

$p$	$\lnot p$
0	1
1	0

Давайте рассмотрим пример, чтобы понять операцию XOR на уровне битов. Если у нас есть два двоичных числа на 6 бит:

$a = 101100$
$b = 001000$

Тогда:

 $a \oplus b = 101100 \oplus 001000 = 100100$

Применяя XOR по битам:

Позиция бита	$a$	$b$	$a \oplus b$
1	1	0	1
2	0	0	0
3	1	1	0
4	1	0	1
5	0	0	0
6	0	0	0

В результате получается $100100$ .

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

Во-первых, есть операция логического сдвига вправо, обозначаемая $ShR_n(x)$ , которая сдвигает все биты $x$ вправо на $n$ позиций, заполняя освободившиеся биты слева нулями.

Например, для $x = 101100001$ (на 9 битах) и $n = 4$ :

 $ShR_4(101100001) = 000010110$

Схематически операцию сдвига вправо можно представить так:

CYP201 Другая операция, используемая в SHA256 для манипуляции с битами, - это правый циклический сдвиг, обозначаемый $RotR_n(x)$ , который сдвигает биты $x$ вправо на $n$ позиций, возвращая сдвинутые биты в начало строки. Например, для $x = 101100001$ (на 9 битах) и $n = 4$ :

 $RotR_4(101100001) = 000110110$

Схематически операцию правого циклического сдвига можно представить так:

Функция сжатия

Теперь, когда мы поняли основные операции, давайте подробнее рассмотрим функцию сжатия SHA256.

На предыдущем этапе мы разделили наш вход на несколько 512-битных блоков $P$ . Для каждого 512-битного блока $P$ у нас есть:

Слова сообщения $W_i$ : для $i$ от 0 до 63.
Константы $K_i$ : для $i$ от 0 до 63, определенные на предыдущем этапе.
Переменные состояния $A, B, C, D, E, F, G, H$ : инициализированные значениями с предыдущего шага. Первые 16 слов, $W_0$ до $W_{15}$ , напрямую извлекаются из обработанного 512-битного блока $P$ . Каждое слово $W_i$ состоит из 32 последовательных битов блока. Так, например, мы берем наш первый кусок входных данных $P_1$ и далее делим его на меньшие 32-битные части, которые мы называем словами. Следующие 48 слов ( $W_{16}$ до $W_{63}$ ) генерируются с использованием следующей формулы:

 $W_i = W_{i-16} + \sigma*0(W_{i-15}) + W_{i-7} + \sigma_1(W_{i-2}) \mod 2^{32}$

Где:

$\sigma_0(x) = RotR_7(x) \oplus RotR_{18}(x) \oplus ShR_3(x)$
$\sigma_1(x) = RotR_{17}(x) \oplus RotR_{19}(x) \oplus ShR_{10}(x)$

В данном случае $x$ равно $W_{i-15}$ для $\sigma_0(x)$ и $W_{i-2}$ для $\sigma_1(x)$ .

Как только мы определили все слова $W_i$ для нашего 512-битного куска, мы можем перейти к функции сжатия, которая состоит из выполнения 64 раундов.

CYP201 На каждом раунде $i$ от 0 до 63 у нас есть три разных типа входных данных. Во-первых, $W_i$ , которые мы только что определили, частично состоящие из нашего куска сообщения $P_n$ . Затем, 64 константы $K_i$ . Наконец, мы используем переменные состояния $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ и $H$ , которые будут изменяться в процессе хеширования и модифицироваться с каждой функцией сжатия. Однако для первого куска $P_1$ мы используем начальные константы, данные ранее. Затем мы выполняем следующие операции над нашими входными данными:

Функция $\Sigma_0$ :

 $\Sigma*0(A) = RotR_2(A) \oplus RotR_{13}(A) \oplus RotR\_{22}(A)$

Функция $\Sigma_1$ :

 $\Sigma*1(E) = RotR_6(E) \oplus RotR_{11}(E) \oplus RotR\_{25}(E)$

Функция $Ch$ ("Выбор"):

 $Ch(E, F, G) = (E \land F) \oplus (\lnot E \land G)$

Функция $Maj$ ("Большинство"):

 $Maj(A, B, C) = (A \land B) \oplus (A \land C) \oplus (B \land C)$

Затем мы вычисляем 2 временные переменные:

$temp1$ :

 $temp1 = H + \Sigma_1(E) + Ch(E, F, G) + K_i + W_i \mod 2^{32}$

$temp2$ :

 $temp2 = \Sigma_0(A) + Maj(A, B, C) \mod 2^{32}$

Далее мы обновляем переменные состояния следующим образом:

 $\begin{cases} H = G \\ G = F \\ F = E \\ E = D + temp1 \mod 2^{32} \\ D = C \\ C = B \\ B = A \\ A = temp1 + temp2 \mod 2^{32} \end{cases}$

Следующая диаграмма представляет один раунд функции сжатия SHA256, который мы только что описали:

Стрелки указывают направление потока данных;
Блоки представляют выполняемые операции;
Знак $+$ в окружении обозначает сложение по модулю $2^{32}$ .

Мы уже можем наблюдать, что этот раунд выдает новые состояния переменных $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ и $H$ . Эти новые переменные будут служить входными данными для следующего раунда, который, в свою очередь, произведет новые переменные $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ и $H$ , которые будут использоваться для следующего раунда. Этот процесс продолжается до 64-го раунда. После 64 раундов мы обновляем исходные значения состояний переменных, добавляя к ним их конечные значения в конце 64-го раунда:

 $\begin{cases} A = A_{\text{initial}} + A \mod 2^{32} \\ B = B_{\text{initial}} + B \mod 2^{32} \\ C = C_{\text{initial}} + C \mod 2^{32} \\ D = D_{\text{initial}} + D \mod 2^{32} \\ E = E_{\text{initial}} + E \mod 2^{32} \\ F = F_{\text{initial}} + F \mod 2^{32} \\ G = G_{\text{initial}} + G \mod 2^{32} \\ H = H_{\text{initial}} + H \mod 2^{32} \end{cases}$

Эти новые значения переменных $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ и $H$ будут служить исходными значениями для следующего блока, $P_2$ . Для этого блока $P_2$ мы повторяем тот же процесс сжатия с 64 раундами, затем обновляем переменные для блока $P_3$ и так далее до последнего блока нашего выровненного ввода.

После обработки всех блоков сообщений мы конкатенируем конечные значения переменных $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ и $H$ , чтобы сформировать конечный 256-битный хеш нашей хеш-функции:

 $\text{Hash} = A \Vert B \Vert C \Vert D \Vert E \Vert F \Vert G \Vert H$

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

Обоснование криптографических свойств

Но как же эта функция обладает необратимостью, устойчивостью к коллизиям и защитой от вмешательства?

Что касается защиты от вмешательства, то понять это довольно просто. Выполняется так много вычислений каскадом, которые зависят как от ввода, так и от констант, что даже малейшее изменение исходного сообщения полностью меняет пройденный путь и, таким образом, полностью меняет выходной хеш. Это то, что называется эффектом лавины. Это свойство частично обеспечивается смешиванием промежуточных состояний с исходными состояниями для каждого куска. Далее, когда обсуждается криптографическая хеш-функция, термин "обратимость" обычно не используется. Вместо этого мы говорим о "устойчивости к нахождению прообраза", что означает, что для любого данного $y$ трудно найти такой $x$ , что $h(x) = y$ . Эта устойчивость к нахождению прообраза обеспечивается алгебраической сложностью и сильной нелинейностью операций, выполняемых в функции сжатия, а также потерей определенной информации в процессе. Например, для данного результата сложения по модулю существует несколько возможных операндов:$$ 3+2 \mod 10 = 5 \ 7+8 \mod 10 = 5 \ 5+10 \mod 10 = 5

 $В этом примере, зная только используемый модуль (10) и результат (5), нельзя с уверенностью определить, какие именно операнды использовались в сложении. Говорят, что существует несколько конгруэнтностей по модулю 10. Для операции XOR мы сталкиваемся с той же проблемой. Помните таблицу истинности для этой операции: любой 1-битный результат может быть определен двумя разными конфигурациями входных данных, которые имеют абсолютно одинаковую вероятность быть правильными значениями. Следовательно, нельзя с уверенностью определить операнды XOR, зная только его результат. Если мы увеличим размер операндов XOR, количество возможных входных данных, зная только результат, увеличивается экспоненциально. Более того, XOR часто используется вместе с другими операциями на уровне битов, такими как операция $\text{RotR}$, которые добавляют еще больше возможных интерпретаций к результату. Функция сжатия также использует операцию $\text{ShR}$. Эта операция удаляет часть базовой информации, которую затем невозможно восстановить. Опять же, нет алгебраического способа обратить эту операцию. Все эти однонаправленные операции с потерей информации используются очень часто в функциях сжатия. Количество возможных входных данных для данного выхода таким образом почти бесконечно, и каждая попытка обратного расчета приведет к уравнениям с очень большим количеством неизвестных, которое будет экспоненциально увеличиваться на каждом шаге. Наконец, для характеристики устойчивости к коллизиям в игру вступают несколько параметров. Предварительная обработка исходного сообщения играет существенную роль. Без этой предварительной обработки может быть легче найти коллизии на функции. Хотя теоретически коллизии существуют (из-за принципа Дирихле), структура хеш-функции в сочетании с упомянутыми свойствами делает вероятность нахождения коллизии крайне низкой. Для того чтобы хеш-функция была устойчива к коллизиям, важно, чтобы: - Результат был непредсказуемым: Любая предсказуемость может быть использована для более быстрого нахождения коллизий, чем при атаке методом грубой силы. Функция обеспечивает, что каждый бит выходных данных зависит нетривиальным образом от входных данных. Другими словами, функция разработана так, чтобы каждый бит конечного результата имел независимую вероятность быть 0 или 1, даже если на практике эта независимость не абсолютна. - Распределение хешей псевдослучайно: Это обеспечивает равномерное распределение хешей. - Размер хеша значителен: чем больше возможное пространство для результатов, тем сложнее найти коллизию. Криптографы разрабатывают эти функции, оценивая лучшие возможные атаки для нахождения коллизий, затем корректируя параметры, чтобы сделать эти атаки неэффективными. ### Конструкция Меркла-Дамгора Структура SHA256 основана на конструкции Меркла-Дамгора, которая позволяет преобразовать функцию сжатия в хеш-функцию, способную обрабатывать сообщения произвольной длины. Это именно то, что мы видели в этой главе. Однако некоторые старые хеш-функции, такие как SHA1 или MD5, использующие эту конкретную конструкцию, уязвимы к атакам на расширение длины. Это техника, которая позволяет атакующему, знающему хеш сообщения $M$ и длину $M$ (не зная само сообщение), вычислить хеш сообщения $M'$, сформированного путем конкатенации $M$ с дополнительным содержимым. SHA256, хотя и использует тот же тип конструкции, теоретически устойчив к этому типу атаки, в отличие от SHA1 и MD5. Это может объяснить загадку двойного хеширования, реализованного в Bitcoin Сатоши Накамото. Чтобы избежать этого типа атаки, Сатоши мог предпочесть использовать двойной SHA256:$

\text{HASH256}(m) = \text{SHA256}(\text{SHA256}(m))

 $Это повышает безопасность против потенциальных атак, связанных с конструкцией Меркла-Дамгора, но это не увеличивает безопасность процесса хеширования с точки зрения устойчивости к коллизиям. Более того, даже если бы SHA256 был уязвим к этому типу атаки, это не имело бы серьезного влияния, так как все случаи использования хеш-функций в Bitcoin включают публичные данные. Однако атака на расширение длины могла бы быть полезной для атакующего только в том случае, если бы хешированные данные были приватными и пользователь использовал хеш-функцию в качестве механизма аутентификации этих данных, аналогично MAC. Таким образом, реализация двойного хеширования остается загадкой в дизайне Bitcoin. Теперь, когда мы подробно рассмотрели принцип работы хеш-функций, особенно SHA256, которая широко используется в Bitcoin, мы более конкретно сосредоточимся на криптографических алгоритмах производных, используемых на уровне приложений, особенно для получения ключей для вашего кошелька. ## Алгоритмы, используемые для производных <chapterId>cc668121-7789-5e99-bf5e-1ba085f4f5f2</chapterId> На уровне приложений в Bitcoin, помимо хеш-функций, используются криптографические алгоритмы производных для генерации защищенных данных из исходных входных данных. Хотя эти алгоритмы опираются на хеш-функции, они служат разным целям, особенно в плане аутентификации и генерации ключей. Эти алгоритмы сохраняют некоторые характеристики хеш-функций, такие как необратимость, устойчивость к подделке и устойчивость к коллизиям. В кошельках Bitcoin в основном используются 2 алгоритма производных: - **HMAC (_Hash-based Message Authentication Code_)** - **PBKDF2 (_Password-Based Key Derivation Function 2_)** Мы вместе изучим функционирование и роль каждого из них. ### HMAC-SHA512 HMAC - это криптографический алгоритм, который вычисляет код аутентификации на основе комбинации хеш-функции и секретного ключа. Bitcoin использует HMAC-SHA512, вариант HMAC, который использует хеш-функцию SHA512. Мы уже видели в предыдущей главе, что SHA512 является частью той же семьи хеш-функций, что и SHA256, но производит 512-битный вывод. Вот его общая схема работы с $m$ в качестве входного сообщения и $K$ секретного ключа: ![CYP201](/courses/cyp201/assets/fr/011.webp) Давайте подробнее рассмотрим, что происходит в этой черной коробке HMAC-SHA512. Функция HMAC-SHA512 с: - $m$: произвольно выбранное пользователем сообщение (первый вход); - $K$: произвольно выбранный пользователем секретный ключ (второй вход); - $K'$: ключ $K$, скорректированный до размера $B$ блоков хеш-функции (1024 бита для SHA512, или 128 байт); - $\text{SHA512}$: хеш-функция SHA512; - $\oplus$: операция XOR (исключающее или); - $\Vert$: оператор конкатенации, соединяющий битовые строки встык; - $\text{opad}$: константа, состоящая из байта $0x5c$, повторяющегося 128 раз; - $\text{ipad}$: константа, состоящая из байта $0x36$, повторяющегося 128 раз. Перед расчетом HMAC необходимо выровнять ключ и константы в соответствии с размером блока $B$. Например, если ключ $K$ короче 128 байтов, он дополняется нулями до размера $B$. Если $K$ длиннее 128 байтов, он сжимается с использованием SHA512, а затем добавляются нули до достижения 128 байтов. Таким образом, получается выровненный ключ $K'$. Значения $\text{opad}$ и $\text{ipad}$ получаются путем повторения их базового байта ($0x5c$ для $\text{opad}$, $0x36$ для $\text{ipad}$) до достижения размера $B$. Таким образом, при $B = 128$ байтах, мы имеем:$

\text{opad} = \underbrace{0x5c5c\ldots5c}_{128 , \text{байтов}}

 $После предварительной обработки алгоритм HMAC-SHA512 определяется следующим уравнением:$

\text {HMAC-SHA512}_K(m) = \text{SHA512} \left( (K' \oplus \text{opad}) \parallel \text{SHA512} \left( (K' \oplus \text{ipad}) \parallel m \right) \right)

 $Это уравнение разбивается на следующие шаги: - Применить XOR к скорректированному ключу $K'$ с $\text{ipad}$, чтобы получить $\text{iKpad}$; - Применить XOR к скорректированному ключу $K'$ с $\text{opad}$, чтобы получить $\text{oKpad}$; - Конкатенировать $\text{iKpad}$ с сообщением $m$. - Хешировать этот результат с помощью SHA512, чтобы получить промежуточный хеш $H_1$. - Конкатенировать $\text{oKpad}$ с $H_1$. - Хешировать этот результат с помощью SHA512, чтобы получить окончательный результат $H_2$. Эти шаги можно схематически изобразить следующим образом: ![CYP201](/courses/cyp201/assets/fr/012.webp) HMAC используется в Bitcoin, в частности, для производства ключей в HD (иерархически детерминированных) кошельках (об этом мы поговорим более подробно в следующих главах) и как компонент PBKDF2. ### PBKDF2 PBKDF2 (_Password-Based Key Derivation Function 2_) — это алгоритм производства ключей на основе пароля, предназначенный для повышения безопасности паролей. Алгоритм применяет псевдослучайную функцию (в данном случае HMAC-SHA512) к паролю и криптографической соли, а затем повторяет эту операцию определенное количество раз, чтобы произвести выходной ключ. В Bitcoin PBKDF2 используется для генерации сида HD кошелька из мнемонической фразы и парольной фразы (но об этом мы поговорим более подробно в следующих главах). Процесс PBKDF2 следующий, с: - $m$: мнемоническая фраза пользователя; - $s$: необязательная парольная фраза для повышения безопасности (пустое поле, если парольная фраза отсутствует); - $n$: количество итераций функции, в нашем случае это 2048. Функция PBKDF2 определяется итеративно. Каждая итерация берет результат предыдущей, пропускает его через HMAC-SHA512 и объединяет последовательные результаты для производства конечного ключа:$

\text{PBKDF2}(m, s) = \text{HMAC-SHA512}^{2048}(m, s)

y^2 = x^3 + ax + b

 $### secp256k1 Для использования ECDSA или Schnorr необходимо выбрать параметры эллиптической кривой, то есть значения $a$ и $b$ в уравнении кривой. Существуют различные стандарты эллиптических кривых, которые считаются криптографически безопасными. Наиболее известной является кривая _secp256r1_, определенная и рекомендованная NIST (_Национальным институтом стандартов и технологий_). Тем не менее, Сатоши Накамото, изобретатель Bitcoin, решил не использовать эту кривую. Причина этого выбора неизвестна, но некоторые считают, что он предпочел найти альтернативу, поскольку параметры этой кривой потенциально могли содержать заднюю дверь. Вместо этого протокол Bitcoin использует стандартную кривую **_secp256k1_**. Эта кривая определена параметрами $a = 0$ и $b = 7$. Ее уравнение, следовательно, имеет вид:$

y^2 = x^3 + 7

 $Ее графическое представление над полем действительных чисел выглядит так: ![CYP201](/courses/cyp201/assets/fr/015.webp) Однако в криптографии мы работаем с конечными множествами чисел. Более конкретно, мы работаем в конечном поле $\mathbb{F}_p$, которое является полем целых чисел по модулю простого числа $p$. **Определение**: Простое число - это натуральное целое число, большее или равное 2, которое имеет только два различных положительных целочисленных делителя: 1 и само себя. Например, число 7 является простым числом, поскольку его можно разделить только на 1 и 7. С другой стороны, число 8 не является простым, потому что его можно разделить на 1, 2, 4 и 8. В Bitcoin простое число $p$, используемое для определения конечного поля, очень велико. Оно выбрано таким образом, что порядок поля (то есть количество элементов в $\mathbb{F}_p$) достаточно велик, чтобы обеспечить криптографическую безопасность. Используемое простое число $p$: ```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` В десятичной записи это соответствует:$

p = 2^{256} - 2^{32} - 977

 $Таким образом, уравнение нашей эллиптической кривой на самом деле:$

y^2 \equiv x^3 + 7 \mod p

 $Учитывая, что эта кривая определена над конечным полем $\mathbb{F}_p$, она больше не напоминает непрерывную кривую, а скорее дискретное множество точек. Например, вот как выглядит кривая, используемая в Bitcoin, для очень маленького $p = 17$: ![CYP201](/courses/cyp201/assets/fr/016.webp) В этом примере я намеренно ограничил конечное поле $p = 17$ в образовательных целях, но нужно представлять, что используемое в Bitcoin намного больше, почти $2^{256}$. Мы используем конечное поле целых чисел по модулю $p$, чтобы обеспечить точность операций на кривой. Действительно, эллиптические кривые над полем действительных чисел подвержены неточностям из-за ошибок округления во время вычислительных расчетов. Если выполняется множество операций на кривой, эти ошибки накапливаются, и конечный результат может быть неверным или трудно воспроизводимым. Исключительное использование положительных целых чисел обеспечивает идеальную точность расчетов и, таким образом, воспроизводимость результата. Математика эллиптических кривых над конечными полями аналогична той, что над полем действительных чисел, с адаптацией, что все операции выполняются по модулю $p$. Для упрощения объяснений мы будем продолжать в следующих главах иллюстрировать концепции, используя кривую, определенную над действительными числами, имея в виду, что на практике кривая определена над конечным полем. Если вы хотите узнать больше о математических основах современной криптографии, я также рекомендую проконсультироваться с этим другим курсом на Plan ₿ Network: https://planb.network/courses/d2fd9fc0-d9ed-4a87-9fa3-0fdbb3937e28 ## Вычисление публичного ключа из приватного ключа <chapterId>fcb2bd58-5dda-5ecf-bb8f-ad1a0561ab4a</chapterId> Как было показано ранее, алгоритмы цифровой подписи в Bitcoin основаны на паре приватного и публичного ключей, которые математически связаны. Давайте вместе исследуем, в чем состоит эта математическая связь и как они генерируются. ### Приватный ключ Приватный ключ - это просто случайное или псевдослучайное число. В случае с Bitcoin, это число имеет размер 256 бит. Таким образом, теоретическое количество возможностей для приватного ключа Bitcoin составляет $2^{256}$. **Примечание**: "Псевдослучайное число" - это число, которое обладает свойствами, близкими к свойствам действительно случайного числа, но генерируется детерминированным алгоритмом. Однако на практике на нашей эллиптической кривой secp256k1 существует только $n$ различных точек, где $n$ - порядок генераторной точки $G$ кривой. Мы увидим позже, чему соответствует это число, но просто запомните, что действительный приватный ключ - это целое число между $1$ и $n-1$, учитывая, что $n$ - это число, близкое к, но немного меньшее, чем $2^{256}$. Следовательно, существуют некоторые 256-битные числа, которые не являются допустимыми для использования в качестве приватного ключа в Bitcoin, а именно, все числа между $n$ и $2^{256}$. Если генерация случайного числа (приватного ключа) дает значение $k$ такое, что $k \geq n$, оно считается недействительным, и должно быть сгенерировано новое случайное значение. Таким образом, количество возможностей для приватного ключа Bitcoin составляет примерно $n$, что является числом, близким к $1.158 \times 10^{77}$. Это число настолько велико, что если вы выберете приватный ключ случайным образом, статистически почти невозможно получить приватный ключ другого пользователя. Чтобы дать вам представление о масштабе, количество возможных приватных ключей в Bitcoin приблизительно равно количеству оценочных атомов в наблюдаемой вселенной. Как мы увидим в следующих главах, сегодня большинство приватных ключей, используемых в Bitcoin, не генерируются случайным образом, а являются результатом детерминированного вывода из мнемонической фразы, самой по себе псевдослучайной (это знаменитая фраза из 12 или 24 слов). Эта информация ничего не меняет в использовании алгоритмов подписи, таких как ECDSA, но помогает сфокусировать наше популяризирование на Bitcoin. Для продолжения объяснения приватный ключ будет обозначаться строчной буквой $k$. ### Публичный ключ Публичный ключ - это точка на эллиптической кривой, обозначаемая заглавной буквой $K$, и вычисляется из приватного ключа $k$. Эта точка $K$ представлена парой координат $(x, y)$ на эллиптической кривой, каждая координата является целым числом по модулю $p$, простым числом, определяющим конечное поле $\mathbb{F}_p$. На практике несжатый публичный ключ представлен 512 битами (или 64 байтами), соответствующими двум 256-битным числам ($x$ и $y$), расположенным друг за другом. Эти числа - абсцисса ($x$) и ордината ($y$) нашей точки на secp256k1. Если добавить префикс, публичный ключ в сумме составляет 520 бит. Однако также возможно представить публичный ключ в сжатой форме, используя только 33 байта (264 бита), сохраняя только абсциссу $x$ нашей точки на кривой и байт, указывающий четность $y$. Это то, что известно как сжатый публичный ключ. Я расскажу об этом подробнее в последних главах этого обучения. Но что вам нужно запомнить, так это то, что публичный ключ $K$ - это точка, описываемая $x$ и $y$. Для вычисления точки $K$, соответствующей нашему публичному ключу, мы используем операцию скалярного умножения на эллиптических кривых, определенную как повторное сложение ($k$ раз) генераторной точки $G$:$

K = k \cdot G

 $где: - $k$ - приватный ключ (случайное целое число между $1$ и $n-1$); - $G$ является генерирующей точкой эллиптической кривой, используемой всеми участниками сети Bitcoin; - $\cdot$ представляет скалярное умножение на эллиптической кривой, что эквивалентно добавлению точки $G$ к самой себе $k$ раз. Тот факт, что эта точка $G$ общая для всех публичных ключей в Bitcoin, позволяет нам быть уверенными, что один и тот же приватный ключ $k$ всегда даст нам один и тот же публичный ключ $K$: ![CYP201](/courses/cyp201/assets/fr/017.webp) Основная характеристика этой операции заключается в том, что она является односторонней функцией. Легко вычислить публичный ключ $K$, зная приватный ключ $k$ и генерирующую точку $G$, но практически невозможно вычислить приватный ключ $k$, зная только публичный ключ $K$ и генерирующую точку $G$. Нахождение $k$ из $K$ и $G$ сводится к решению задачи дискретного логарифмирования на эллиптических кривых, математически сложной задаче, для которой не известен эффективный алгоритм. Даже самые мощные современные калькуляторы не способны решить эту задачу за разумное время. ![CYP201](/courses/cyp201/assets/fr/018.webp) ### Сложение и удвоение точек на эллиптических кривых Концепция сложения на эллиптических кривых определяется геометрически. Если у нас есть две точки $P$ и $Q$ на кривой, операция $P + Q$ вычисляется путем проведения линии, проходящей через $P$ и $Q$. Эта линия обязательно пересечет кривую в третьей точке $R'$. Затем мы берем зеркальное отображение этой точки относительно оси x, чтобы получить точку $R$, которая является результатом сложения:$

P + Q = R

 $Графически это можно представить следующим образом: ![CYP201](/courses/cyp201/assets/fr/019.webp) Для удвоения точки, то есть операции $P + P$, мы проводим касательную к кривой в точке $P$. Эта касательная пересекает кривую в другой точке $S'$. Затем мы берем зеркальное отображение этой точки относительно оси x, чтобы получить точку $S$, которая является результатом удвоения:$

2P = S

 $Графически это показано как: ![CYP201](/courses/cyp201/assets/fr/020.webp) Используя эти операции сложения и удвоения, мы можем выполнить скалярное умножение точки на целое число $k$, обозначаемое как $kP$, выполняя повторные удвоения и сложения. Например, предположим, что мы выбрали приватный ключ $k = 4$. Чтобы вычислить ассоциированный публичный ключ, мы выполняем:$

K = k \cdot G = 4G

 $Графически это соответствует выполнению серии сложений и удвоений: - Вычислите $2G$, удвоив $G$. - Вычислите $4G$, удвоив $2G$. ![CYP201](/courses/cyp201/assets/fr/021.webp) Если мы хотим, например, вычислить точку $3G$, сначала мы должны вычислить точку $2G$, удвоив точку $G$, затем добавить $G$ и $2G$. Чтобы добавить $G$ и $2G$, просто проведите линию, соединяющую эти две точки, извлеките уникальную точку $-3G$ на пересечении этой линии и эллиптической кривой, а затем определите $3G$ как противоположность $-3G$. У нас будет:$

G + G = 2G

2G + G = 3G

 $Графически это будет представлено следующим образом: ![CYP201](/courses/cyp201/assets/fr/022.webp) ### Однонаправленная Функция Благодаря этим операциям мы можем понять, почему легко получить публичный ключ из приватного ключа, но обратный процесс практически невозможен. Давайте вернемся к нашему упрощенному примеру. Имея приватный ключ $k = 4$. Чтобы вычислить соответствующий публичный ключ, мы выполняем:$

K = k \cdot G = 4G

 $Таким образом, мы смогли легко вычислить публичный ключ $K$, зная $k$ и $G$. Теперь, если кто-то знает только публичный ключ $K$, он сталкивается с проблемой дискретного логарифма: найти $k$ такое, что $K = k \cdot G$. Эта проблема считается сложной, потому что нет эффективного алгоритма для ее решения на эллиптических кривых. Это обеспечивает безопасность алгоритмов ECDSA и Schnorr. Конечно, в этом упрощенном примере с $k = 4$, было бы возможно найти $k$ методом проб и ошибок, так как количество возможностей невелико. Однако на практике в Bitcoin $k$ является 256-битным целым числом, что делает количество возможностей астрономически большим (примерно $1.158 \times 10^{77}$). Поэтому невозможно найти $k$ методом грубой силы. ## Подписание Приватным Ключом <chapterId>bb07826f-826e-5905-b307-3d82001fb778</chapterId> Теперь, когда вы знаете, как получить публичный ключ из приватного ключа, вы уже можете получать биткоины, используя эту пару ключей в качестве условия для расходования. Но как их потратить? Чтобы потратить биткоины, вам нужно разблокировать _scriptPubKey_, прикрепленный к вашему UTXO, чтобы доказать, что вы действительно его законный владелец. Для этого вы должны произвести подпись $s$, соответствующую публичному ключу $K$, присутствующему в _scriptPubKey_, используя приватный ключ $k$, который изначально использовался для вычисления $K$. Таким образом, цифровая подпись является неопровержимым доказательством того, что вы владеете приватным ключом, ассоциированным с заявленным публичным ключом. ### Параметры Эллиптической Кривой Для выполнения цифровой подписи все участники должны сначала договориться о параметрах используемой эллиптической кривой. В случае с Bitcoin параметры **secp256k1** следующие: Конечное поле $\mathbb{Z}_p$ определяется как:$

p = 2^{256} - 2^{32} - 977

 $```text p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` $p$ является очень большим простым числом, немного меньшим $2^{256}$. Эллиптическая кривая $y^2 = x^3 + ax + b$ над $\mathbb{Z}_p$ определяется как:$

a = 0, \quad b = 7

 $Точка-генератор или начальная точка $G$: ```text G = 0x0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 ``` Это число является сжатой формой, которая дает только абсциссу точки $G$. Префикс `02` в начале определяет, какое из двух значений с этой абсциссой $x$ должно использоваться в качестве генерирующей точки. Порядок $n$ точки $G$ (количество существующих точек) и кофактор $h$: ```text n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 ``` $n$ - это очень большое число, немного меньшее, чем $p$.$

h=1

 $$h$ - это кофактор или количество подгрупп. Я не буду подробно останавливаться на том, что это представляет, поскольку это довольно сложно, и в случае с Bitcoin, нам не нужно это учитывать, так как он равен $1$. Вся эта информация является общедоступной и известной всем участникам. Благодаря этому пользователи могут создавать цифровую подпись и проверять её. ### Подпись с использованием ECDSA Алгоритм ECDSA позволяет пользователю подписать сообщение с использованием своего личного ключа таким образом, что любой, кто знает соответствующий публичный ключ, может проверить действительность подписи, без раскрытия личного ключа. В контексте Bitcoin, сообщение, которое нужно подписать, зависит от выбранного пользователем _sighash_. Именно _sighash_ определяет, какие части транзакции покрываются подписью. Об этом я расскажу подробнее в следующей главе. Вот шаги для создания подписи ECDSA: Сначала мы вычисляем хеш ($e$) сообщения, которое нужно подписать. Сообщение $m$ таким образом проходит через криптографическую хеш-функцию, обычно SHA256 или двойной SHA256 в случае с Bitcoin:$

e = \text{HASH}(m)

 $Далее, мы вычисляем nonce. В криптографии nonce - это просто число, генерируемое случайным или псевдослучайным образом, которое используется только один раз. То есть, каждый раз, когда создается новая цифровая подпись с этой парой ключей, очень важно использовать другой nonce, иначе это может поставить под угрозу безопасность личного ключа. Поэтому достаточно определить случайное и уникальное целое число $r$ так, чтобы $1 \leq r \leq n-1$, где $n$ - порядок генерирующей точки $G$ эллиптической кривой. Затем мы вычисляем точку $R$ на эллиптической кривой с координатами $(x_R, y_R)$ так, что:$

R = r \cdot G

 $Мы извлекаем значение абсциссы точки $R$ ($x_R$). Это значение представляет первую часть подписи. И, наконец, мы вычисляем вторую часть подписи $s$ следующим образом:$

s = r^{-1} \left( e + k \cdot x_R \right) \mod n

 $где: - $r^{-1}$ - это модульный обратный к $r$ по модулю $n$, то есть целое число такое, что $r \cdot r^{-1} \equiv 1 \mod n$; - $k$ - личный ключ пользователя; - $e$ - хеш сообщения; - $n$ - порядок генерирующей точки $G$ эллиптической кривой. Подпись затем просто является конкатенацией $x_R$ и $s$:$

\text{SIG} = x_R \Vert s

 $### Проверка подписи ECDSA Для проверки подписи $(x_R, s)$ любой, кто знает публичный ключ $K$ и параметры эллиптической кривой, может поступить следующим образом: Сначала проверьте, что $x_R$ и $s$ находятся в интервале $[1, n-1]$. Это гарантирует, что подпись соответствует математическим ограничениям эллиптической группы. Если это не так, верификатор немедленно отклоняет подпись как недействительную. Затем вычислите хеш сообщения:$

e = \text{HASH}(m)

 $Вычислите модульный обратный к $s$ по модулю $n$:$

s^{-1} \mod n

 $Вычислите два скалярных значения $u_1$ и $u_2$ следующим образом:$

\begin{align*} u_1 &= e \cdot s^{-1} \mod n \ u_2 &= x_R \cdot s^{-1} \mod n \end{align*}

 $И, наконец, вычислите точку $V$ на эллиптической кривой так, чтобы:$

V = u_1 \cdot G + u_2 \cdot K

 $Подпись является действительной только если $x_V \equiv x_R \mod n$, где $x_V$ — это $x$-координата точки $V$. Действительно, объединяя $u_1 \cdot G$ и $u_2 \cdot K$, получается точка $V$, которая, если подпись действительна, должна соответствовать точке $R$, использованной во время подписи (по модулю $n$). ### Подпись с использованием протокола Шнорра Схема подписи Шнорра является альтернативой ECDSA и предлагает множество преимуществ. Ее использование на Bitcoin стало возможным с 2021 года и введением Taproot с шаблонами скриптов P2TR. Как и ECDSA, схема Шнорра позволяет подписывать сообщение с использованием закрытого ключа таким образом, что подпись может быть проверена любым, кто знает соответствующий открытый ключ. В случае с Шнорром используется точно такая же кривая, как и в ECDSA, с теми же параметрами. Однако открытые ключи представлены немного иначе по сравнению с ECDSA. Действительно, они обозначаются только $x$-координатой точки на эллиптической кривой. В отличие от ECDSA, где сжатые открытые ключи представлены 33 байтами (с байтом префикса, указывающим четность $y$), Шнорр использует 32-байтовые открытые ключи, соответствующие только $x$-координате точки $K$, и предполагается, что $y$ по умолчанию четное. Это упрощенное представление уменьшает размер подписей и облегчает определенные оптимизации в алгоритмах верификации. Открытый ключ тогда является $x$-координатой точки $K$:$

\text{pk} = K_x

 $Первый шаг для генерации подписи - хеширование сообщения. Но в отличие от ECDSA, это делается с другими значениями, и используется маркированная хеш-функция, чтобы избежать коллизий в разных контекстах. Маркированная хеш-функция просто включает добавление произвольной метки к входным данным хеш-функции наряду с данными сообщения. ![CYP201](/courses/cyp201/assets/fr/023.webp) Помимо сообщения, в маркированную функцию также передаются $x$-координата открытого ключа $K_x$, а также точка $R$, вычисленная из nonce $r$ ($R=r \cdot G$), который сам является уникальным целым числом для каждой подписи, вычисляемым детерминированно из закрытого ключа и сообщения, чтобы избежать уязвимостей, связанных с повторным использованием nonce. Как и для открытого ключа, для описания точки сохраняется только $x$-координата точки nonce $R_x$. Результат этого хеширования, обозначенный $e$, называется "вызовом":$

e = \text{HASH}(\text{``BIP0340/challenge''}, R_x \Vert K_x \Vert m) \mod n

 $Здесь $\text{HASH}$ - это хеш-функция SHA256, а $\text{``BIP0340/challenge''}$ - это специфический тег для хеширования. Наконец, параметр $s$ рассчитывается следующим образом из приватного ключа $k$, nonce $r$ и вызова $e$:$

s = (r + e \cdot k) \mod n

 $Тогда подпись просто является парой $Rx$ и $s$.$

\text{SIG} = R_x \Vert s

 $### Проверка подписи Шнорра Проверка подписи Шнорра проще, чем проверка подписи ECDSA. Вот шаги для проверки подписи $(R_x, s)$ с использованием публичного ключа $K_x$ и сообщения $m$: Сначала мы проверяем, что $K_x$ является действительным целым числом и меньше $p$. Если это так, мы извлекаем соответствующую точку на кривой, при этом $K_y$ является четным. Также мы извлекаем $R_x$ и $s$, разделяя подпись $\text{SIG}$. Затем мы проверяем, что $R_x < p$ и $s < n$ (порядок кривой). Далее, мы рассчитываем вызов $e$ таким же образом, как и источник подписи:$

e = \text{HASH}(\text{``BIP0340/challenge''}, R_x \Vert K_x \Vert m) \mod n

 $Затем мы рассчитываем опорную точку на кривой следующим образом:$

R' = s \cdot G - e \cdot K

 $Наконец, мы проверяем, что $R'_x = R_x$. Если две координаты x совпадают, то подпись $(R_x, s)$ действительно является валидной с публичным ключом $K_x$. ### Почему это работает? Подписывающий рассчитал $s = r + e \cdot k \mod n$, так что $R' = s \cdot G - e \cdot K$ должен быть равен исходной точке $R$, потому что:$

s \cdot G = (r + e \cdot k) \cdot G = r \cdot G + e \cdot k \cdot G

 $Поскольку $K = k \cdot G$, у нас есть $e \cdot k \cdot G = e \cdot K$. Таким образом:$

R' = r \cdot G = R

 $Следовательно, у нас есть:$

R'_x = R_x

\text{CS} = \frac{\text{ENT}}{32}

 $где $\text{ENT}$ представляет длину энтропии в битах, а $\text{CS}$ - длину контрольной суммы в битах. Например, для энтропии 256 бит первые 8 бит хеша берутся для формирования контрольной суммы:$

\text{CS} = \frac{256}{32} = 8 \text{ бит}

 $После расчета контрольной суммы она конкатенируется с энтропией для получения расширенной битовой последовательности, обозначаемой как $\text{ENT} \Vert \text{CS}$ ("конкатенация" означает поставить одно за другим). ![CYP201](/courses/cyp201/assets/fr/036.webp) ### Соответствие между энтропией и мнемонической фразой Количество слов в мнемонической фразе зависит от размера исходной энтропии, как показано в следующей таблице с: - $\text{ENT}$: размер в битах энтропии; - $\text{CS}$: размер в битах контрольной суммы; - $w$: количество слов в итоговой мнемонической фразе.$

\begin{array}{|c|c|c|c|} \hline \text{ENT} & \text{CS} & \text{ENT} \Vert \text{CS} & w \ \hline 128 & 4 & 132 & 12 \ 160 & 5 & 165 & 15 \ 192 & 6 & 198 & 18 \ 224 & 7 & 231 & 21 \ 256 & 8 & 264 & 24 \ \hline \end{array}

 $Например, для энтропии 256 бит результат $\text{ENT} \Vert \text{CS}$ составляет 264 бита и дает мнемоническую фразу из 24 слов. ### Преобразование бинарной последовательности в мнемоническую фразу Битовая последовательность $\text{ENT} \Vert \text{CS}$ затем делится на сегменты по 11 бит. Каждый 11-битный сегмент, после преобразования в десятичное число, соответствует числу между 0 и 2047, которое обозначает позицию слова [в списке из 2048 слов, стандартизированном BIP39](https://github.com/Planb-Network/bitcoin-educational-content/blob/dev/resources/bet/bip39-wordlist//courses/cyp201/assets/BIP39-WORDLIST.pdf). ![CYP201](/courses/cyp201/assets/fr/037.webp) Например, для 128-битной энтропии контрольная сумма составляет 4 бита, и таким образом, общая последовательность измеряется в 132 бита. Она делится на 12 сегментов по 11 бит (оранжевые биты обозначают контрольную сумму): ![CYP201](/courses/cyp201/assets/fr/038.webp) Каждый сегмент затем преобразуется в десятичное число, которое представляет слово из списка. Например, двоичный сегмент `01011010001` в десятичной системе эквивалентен `721`. Добавляя 1 для соответствия индексации списка (которая начинается с 1, а не с 0), мы получаем ранг слова `722`, что соответствует слову "*focus*" в списке. ![CYP201](/courses/cyp201/assets/fr/039.webp) Это соответствие повторяется для каждого из 12 сегментов, чтобы получить фразу из 12 слов. ![CYP201](/courses/cyp201/assets/fr/040.webp) ### Особенности списка слов BIP39 Особенность списка слов BIP39 заключается в том, что ни одно слово не делится теми же первыми четырьмя буквами в том же порядке с другим словом. Это означает, что достаточно записать только первые четыре буквы каждого слова, чтобы сохранить мнемоническую фразу. Это может быть интересно для экономии места, особенно для тех, кто хочет выгравировать её на металлической основе. Список из 2048 слов существует на нескольких языках. Это не простые переводы, а отдельные слова для каждого языка. Однако настоятельно рекомендуется придерживаться английской версии, так как версии на других языках обычно не поддерживаются программным обеспечением для кошельков. ### Какую длину выбрать для вашей мнемонической фразы? Чтобы определить оптимальную длину вашей мнемонической фразы, необходимо учитывать фактическую безопасность, которую она обеспечивает. Фраза из 12 слов обеспечивает 128 бит безопасности, в то время как фраза из 24 слов предлагает 256 бит. Однако это различие в безопасности на уровне фразы не улучшает общую безопасность биткойн-кошелька, поскольку производные от этой фразы приватные ключи получают только 128 бит безопасности. Действительно, как мы видели ранее, приватные ключи биткойна генерируются из случайных чисел (или производятся из случайного источника) в диапазоне от $1$ до $n-1$, где $n$ представляет порядок генераторной точки $G$ кривой secp256k1, число немного меньше $2^{256}$. Можно было бы подумать, что эти приватные ключи обеспечивают 256 бит безопасности. Однако их безопасность заключается в сложности нахождения приватного ключа по его ассоциированному публичному ключу, сложность, установленная математической проблемой дискретного логарифма на эллиптических кривых (*ECDLP*). На сегодняшний день лучший известный алгоритм для решения этой проблемы - алгоритм ро Полларда, который сокращает количество операций, необходимых для взлома ключа, до квадратного корня из его размера. Для 256-битных ключей, таких как те, что используются в Bitcoin, алгоритм ро Полларда таким образом сокращает сложность до $2^{128}$ операций:$

O(\sqrt{2^{256}}) = O(2^{128})

s = \text{PBKDF2}_{\text{HMAC-SHA512}}(m, p, 2048)

 $![CYP201](/courses/cyp201/assets/fr/044.webp) Таким образом, значение сида зависит от значения мнемонической фразы и парольной фразы. Изменяя парольную фразу, получается другой сид. Однако, при использовании одной и той же мнемонической фразы и парольной фразы, всегда генерируется один и тот же сид, поскольку PBKDF2 является детерминированной функцией. Это гарантирует, что те же пары ключей могут быть восстановлены через наши резервные копии. **Примечание:** В обиходе термин "сид" часто используется, по ошибке, для обозначения мнемонической фразы. Действительно, в отсутствие парольной фразы одно является просто кодировкой другого. Однако, как мы видели, в технической реальности кошельков, сид и мнемоническая фраза действительно являются двумя различными элементами. Теперь, когда у нас есть наш сид, мы можем продолжить с получением нашего Биткоин кошелька. ### Мастер-ключ и мастер-код цепочки После получения сида следующим шагом в создании HD-кошелька является расчет мастер-приватного ключа и мастер-кода цепочки, которые будут представлять уровень 0 нашего кошелька. Для получения мастер-приватного ключа и мастер-кода цепочки к сиду применяется функция HMAC-SHA512, используя фиксированный ключ "*Bitcoin Seed*", идентичный для всех пользователей Bitcoin. Эта константа выбрана для того, чтобы производные ключи были специфичны для Bitcoin. Вот элементы: - $\text{HMAC-SHA512}$: функция производства; - $s$: 512-битный сид кошелька; - $\text{"Bitcoin Seed"}$: общая константа производства для всех Bitcoin-кошельков.$

\text{output} = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)

 $Таким образом, выход этой функции составляет 512 бит. Затем он делится на 2 части: - Левые 256 бит формируют **мастер-приватный ключ**; - Правые 256 бит формируют **мастер-код цепочки**. Математически эти два значения могут быть обозначены следующим образом, где $k_M$ является мастер-приватным ключом, а $C_M$ - мастер-кодом цепочки:$

k_M = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)_{[:256]}

C_M = \text{HMAC-SHA512}(\text{"Bitcoin Seed"}, s)_{[256:]}

\text{hash} = \text{HMAC-SHA512}(C_{\text{PAR}}, G \cdot k_{\text{PAR}} \Vert i)

 $В этом расчете мы видим, что наша функция HMAC принимает два входа: сначала родительский код цепочки, а затем конкатенацию индекса с публичным ключом, связанным с родительским приватным ключом. Здесь используется родительский публичный ключ, поскольку мы стремимся произвести обычный дочерний ключ, а не усиленный. Теперь у нас есть 64-байтный $\text{hash}$, который мы разделим на 2 части по 32 байта каждая: $h_1$ и $h_2$:$

\text{hash} = h_1 \Vert h_2

h1 = \text{hash}_{[:32]} \quad, \quad h2 = \text{hash}_{[32:]}

 $Затем дочерний приватный ключ $k_{\text{CHD}}^n$ рассчитывается следующим образом:$

k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n

 $В этом расчете операция $\text{parse256}(h_1)$ состоит из интерпретации первых 32 байтов $\text{hash}$ как 256-битного целого числа. Это число затем добавляется к родительскому закрытому ключу, все берется по модулю $n$, чтобы оставаться в пределах порядка эллиптической кривой, как мы видели в разделе 3 о цифровых подписях. Таким образом, для получения обычного дочернего закрытого ключа, хотя родительский открытый ключ используется как основа для расчета во входных данных функции HMAC-SHA512, всегда необходимо иметь родительский закрытый ключ для завершения расчета. Из этого дочернего закрытого ключа можно получить соответствующий открытый ключ, применив ECDSA или Schnorr. Таким образом, мы получаем полную пару ключей. Затем вторая часть $\text{hash}$ просто интерпретируется как код цепочки для только что полученной пары дочерних ключей:$

C_{\text{CHD}} = h_2

 $Вот схематическое представление общего процесса получения: ![CYP201](/courses/cyp201/assets/fr/050.webp) Для **усиленного дочернего ключа** ($i \geq 2^{31}$) расчет $\text{hash}$ происходит следующим образом:$

hash = \text{HMAC-SHA512}(C_{\text{PAR}}, 0x00 \Vert k_{\text{PAR}} \Vert i)

 $В этом расчете мы видим, что наша функция HMAC принимает два входа: сначала код цепочки родителя, а затем конкатенацию индекса с родительским закрытым ключом. Здесь используется родительский закрытый ключ, поскольку мы стремимся получить усиленный дочерний ключ. Кроме того, в начало ключа добавляется байт, равный `0x00`, чтобы его длина соответствовала длине сжатого открытого ключа. Таким образом, у нас есть 64-байтный $\text{hash}$, который мы разделим на 2 части по 32 байта каждая: $h_1$ и $h_2$:$

\text{hash} = h_1 \Vert h_2

h_1 = \text{hash}[:32] \quad, \quad h_2 = \text{hash}[32:]

 $Затем дочерний закрытый ключ $k_{\text{CHD}}^h$ рассчитывается следующим образом:$

k_{\text{CHD}}^h = \text{parse256}(h_1) + k_{\text{PAR}} \mod n

 $Далее мы просто интерпретируем вторую часть $\text{hash}$ как код цепочки для только что полученной пары дочерних ключей:$

C_{\text{CHD}} = h_2

 $Вот схематическое представление общего процесса получения: ![CYP201](/courses/cyp201/assets/fr/051.webp) Мы видим, что обычное получение и усиленное получение функционируют одинаково, с этим отличием: обычное получение использует родительский открытый ключ в качестве входа для функции HMAC, в то время как усиленное получение использует родительский закрытый ключ. #### Получение дочернего открытого ключа из родительского открытого ключа Если мы знаем только родительский публичный ключ $K_{\text{PAR}}$ и связанный с ним код цепочки $C_{\text{PAR}}$, то есть расширенный публичный ключ, возможно получить дочерние публичные ключи $K_{\text{CHD}}^n$, но только для обычных (не усиленных) дочерних ключей. Этот принцип, в частности, позволяет отслеживать движения по счету в Bitcoin-кошельке с помощью `xpub` (_только для просмотра_). Для выполнения этого расчета мы вычислим $\text{hash}$ с индексом $i < 2^{31}$ (обычное производное):$

\text{hash} = \text{HMAC-SHA512}(C_{\text{PAR}}, K_{\text{PAR}} \Vert i)

 $В этом расчете мы видим, что наша функция HMAC принимает два входа: сначала код цепочки родителя, затем конкатенацию индекса с родительским публичным ключом. Таким образом, у нас есть $hash$ из 64 байтов, который мы разделим на 2 части по 32 байта каждая: $h_1$ и $h_2$:$

\text{hash} = h_1 \Vert h_2

h_1 = \text{hash}[:32] \quad, \quad h_2 = \text{hash}[32:]

 $Затем дочерний публичный ключ $K_{\text{CHD}}^n$ рассчитывается следующим образом:$

K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}

 $Если $\text{parse256}(h_1) \geq n$ (порядок эллиптической кривой) или если $K_{\text{CHD}}^n$ является точкой на бесконечности, производное является недействительным, и должен быть выбран другой индекс. В этом расчете операция $\text{parse256}(h_1)$ включает интерпретацию первых 32 байтов $\text{hash}$ как 256-битное целое число. Это число используется для расчета точки на эллиптической кривой через сложение и удвоение от точки генератора $G$. Эта точка затем добавляется к родительскому публичному ключу для получения обычного дочернего публичного ключа. Таким образом, для получения обычного дочернего публичного ключа необходимы только родительский публичный ключ и код цепочки родителя; родительский приватный ключ никогда не участвует в этом процессе, в отличие от расчета дочернего приватного ключа, который мы видели ранее. Далее, код цепочки дочернего элемента просто:$

C_{\text{CHD}} = h_2

 $Вот схематическое представление общего производного: ![CYP201](/courses/cyp201/assets/fr/052.webp) ### Соответствие между дочерними публичными и приватными ключами Вопрос, который может возникнуть, это как обычный дочерний публичный ключ, полученный из родительского публичного ключа, может соответствовать обычному дочернему приватному ключу, полученному из соответствующего родительского приватного ключа. Эта связь точно обеспечивается свойствами эллиптических кривых. Действительно, для получения обычного дочернего публичного ключа применяется HMAC-SHA512 тем же способом, но его вывод используется по-другому: - **Обычный дочерний приватный ключ**: $k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n$ - **Обычный дочерний публичный ключ**: $K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}$ Благодаря операциям сложения и удвоения на эллиптической кривой, оба метода дают согласованные результаты: публичный ключ, полученный из дочернего приватного ключа, идентичен дочернему публичному ключу, полученному напрямую из родительского публичного ключа. ### Сводка типов производных Для обобщения, вот различные возможные типы производных:$

\begin{array}{|c|c|c|c|} \hline \rightarrow & \text{PAR} & \text{CHD} & \text{n/h} \ \hline k_{\text{PAR}} \rightarrow k_{\text{CHD}} & k_{\text{PAR}} & { k_{\text{CHD}}^n, k_{\text{CHD}}^h } & { n, h } \ k_{\text{PAR}} \rightarrow K_{\text{CHD}} & k_{\text{PAR}} & { K_{\text{CHD}}^n, K_{\text{CHD}}^h } & { n, h } \ K_{\text{PAR}} \rightarrow k_{\text{CHD}} & K_{\text{PAR}} & \times & \times \ K_{\text{PAR}} \rightarrow K_{\text{CHD}} & K_{\text{PAR}} & K_{\text{CHD}}^n & n \ \hline \end{array}

i = 44 + 2^{31} = 2,147,483,692

 $В шестнадцатеричной системе это `0x8000002C`. Теперь, когда мы поняли основные принципы путей производства, давайте рассмотрим пример! Вот путь производства для адреса получения Bitcoin:$

m / 84' / 0' / 1' / 0 / 7

\text{HASH160}(K) = \text{RIPEMD160}(\text{SHA256}(K))

 $Сначала мы пропускаем ключ через SHA256: ```text SHA256(K) = C489EBD66E4103B3C4B5EAFF462B92F5847CA2DCE0825F4997C7CF57DF35BF3A ``` Затем мы пропускаем результат через RIPEMD160: ```text RIPEMD160(SHA256(K)) = 9F81322CC88622CA4CCB2A52A21E2888727AA535 ``` Мы получили 160-битный хеш публичного ключа, который составляет то, что называется полезной нагрузкой адреса. Эта полезная нагрузка представляет собой центральную и наиболее важную часть адреса. Она также используется в _scriptPubKey_ для блокировки UTXO. Однако, чтобы сделать эту полезную нагрузку более удобной для использования людьми, к ней добавляются метаданные. Следующий шаг включает кодирование этого хеша в группы по 5 бит в десятичной системе. Это преобразование в десятичные числа будет полезно для конвертации в _bech32_, используемый адресами после SegWit. Таким образом, 160-битный двоичный хеш делится на 32 группы по 5 бит:$

\begin{array}{|c|c|} \hline \text{5 bits} & \text{Decimal} \ \hline 10011 & 19 \ 11110 & 30 \ 00000 & 0 \ 10011 & 19 \ 00100 & 4 \ 01011 & 11 \ 00110 & 6 \ 01000 & 8 \ 10000 & 16 \ 11000 & 24 \ 10001 & 17 \ 01100 & 12 \ 10100 & 20 \ 10011 & 19 \ 00110 & 6 \ 01011 & 11 \ 00101 & 5 \ 01001 & 9 \ 01001 & 9 \ 01010 & 10 \ 00100 & 4 \ 00111 & 7 \ 10001 & 17 \ 01000 & 8 \ 10001 & 17 \ 00001 & 1 \ 11001 & 25 \ 00111 & 7 \ 10101 & 21 \ 00101 & 5 \ 00101 & 5 \ 10101 & 21 \ \hline \end{array}

\begin{array}{|c|c|c|c|c|c|c|c|c|} \hline & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 \ \hline +0 & q & p & z & r & y & 9 & x & 8 \ \hline +8 & g & f & 2 & t & v & d & w & 0 \ \hline +16 & s & 3 & j & n & 5 & 4 & k & h \ \hline +24 & c & e & 6 & m & u & a & 7 & l \ \hline \end{array}

P' = P + tG

 $Где $G$ - генератор эллиптической кривой, используемой. Эта операция производит новый публичный ключ, производный от оригинального ключа, сохраняя при этом криптографические свойства, позволяющие его использовать. Если вам не нужно добавлять альтернативные скрипты (траты исключительно через _ключевой путь_), вы можете сгенерировать адрес Taproot, основанный только на публичном ключе, находящемся на глубине 5 вашего кошелька. В этом случае необходимо создать неиспользуемый скрипт для _скриптового пути_, чтобы удовлетворить требованиям структуры. Затем корректировка $t$ рассчитывается путем применения функции хеширования с тегом, **`TapTweak`**, к внутреннему публичному ключу $P$:$

t = \text{H}_{\text{TapTweak}}(P)

 $где: - **$\text{H}_{\text{TapTweak}}$** - это хеш-функция SHA256 с тегом `TapTweak`. Если вы не знакомы с тем, что такое хеш-функция с тегом, я приглашаю вас ознакомиться с разделом 3.3; - $P$ - это внутренний публичный ключ, представленный в его сжатом 256-битном формате, использующий только координату $x$. Публичный ключ Taproot $Q$ затем рассчитывается путем добавления корректировки $t$, умноженной на генератор эллиптической кривой $G$, к внутреннему публичному ключу $P$:$

Q = P + t \cdot G

\text{h}{\text{leaf}} = \text{H}{\text{TapLeaf}} (v \Vert sz \Vert S)

 $С: - $v$: номер версии скрипта (по умолчанию `0xC0` для Taproot); - $sz$: размер скрипта, закодированный в формате _CompactSize_; - $S$: скрипт. Различные хеши скриптов ($\text{h}_{\text{leaf}}$) сначала сортируются в лексикографическом порядке. Затем они конкатенируются попарно и передаются через функцию хеширования с тегом `TapBranch`. Этот процесс повторяется итеративно для пошагового построения дерева Меркла:$

\text{h}{\text{branch}} = \text{H}{\text{TapBranch}}(\text{h}{\text{leaf1}} \Vert \text{h}{\text{leaf2}})

 $Затем мы продолжаем конкатенацию результатов попарно, передавая их на каждом шаге через функцию хеширования с тегом `TapBranch`, пока не получим корень дерева Меркла: ![CYP201](/courses/cyp201/assets/fr/066.webp) После вычисления корня Меркля $h_{\text{root}}$ можно рассчитать tweak. Для этого внутренний публичный ключ кошелька $P$ объединяется с корнем $h_{\text{root}}$, а результат пропускается через помеченную хеш-функцию `TapTweak`:$

t = \text{H}{\text{TapTweak}}(P \Vert h{\text{root}})

 $Наконец, как и раньше, публичный ключ Taproot $Q$ получается добавлением внутреннего публичного ключа $P$ к произведению tweak $t$ на генераторную точку $G$:$

Q = P + t \cdot G

 $Далее генерация адреса выполняется тем же процессом, используя сырой публичный ключ $Q$ в качестве полезной нагрузки, вместе с некоторыми дополнительными метаданными. Затем генерация адреса следует тому же процессу, используя сырой публичный ключ \(Q\) в качестве полезной нагрузки, сопровождаемой некоторыми дополнительными метаданными. И вот мы достигли конца этого курса CYP201. Если вы нашли этот курс полезным, я был бы очень благодарен, если бы вы уделили несколько минут, чтобы дать ему хорошую оценку в следующей главе оценки. Не стесняйтесь также делиться им с вашими близкими или в ваших социальных сетях. Наконец, если вы хотите получить ваш диплом по этому курсу, вы можете сдать итоговый экзамен сразу после главы оценки. # Заключительный раздел <partId>58111408-b734-54db-9ea7-0d5b67f99f99</partId> ## Отзывы & Оценки <chapterId>0cd71541-a7fd-53db-b66a-8611b6a28b04</chapterId> <isCourseReview>true</isCourseReview> ## Финальный экзамен <chapterId>a53ea27d-0f84-56cd-b37c-a66210a4b31d</chapterId> <isCourseExam>true</isCourseExam> ## Заключение <chapterId>d291428b-3cfa-5394-930e-4b514be82d5a</chapterId> <isCourseConclusion>true</isCourseConclusion>$