name: O Funcionamento Interno das Carteiras de Bitcoin goal: Mergulhar nos princípios criptográficos que alimentam as carteiras de Bitcoin. objectives:

Definir as noções teóricas necessárias para entender os algoritmos criptográficos usados no Bitcoin.
Compreender completamente a construção de uma carteira determinística e hierárquica.
Saber como identificar e reduzir os riscos associados à gestão de uma carteira.
Entender os princípios das funções de hash, chaves criptográficas e assinaturas digitais.

Uma Jornada ao Coração das Carteiras de Bitcoin

Descubra os segredos das carteiras de Bitcoin determinísticas e hierárquicas com nosso curso CYP201! Seja você um usuário regular ou um entusiasta procurando aprofundar seu conhecimento, este curso oferece uma imersão completa no funcionamento dessas ferramentas que todos usamos diariamente.

Aprenda sobre os mecanismos das funções de hash, assinaturas digitais (ECDSA e Schnorr), frases mnemônicas, chaves criptográficas e a criação de endereços de recebimento, tudo isso enquanto explora estratégias avançadas de segurança.

Este treinamento não só o equipará com o conhecimento para entender a estrutura de uma carteira de Bitcoin, mas também o preparará para mergulhar mais fundo no mundo empolgante da criptografia.

Com uma pedagogia clara, mais de 60 diagramas explicativos e exemplos concretos, o CYP201 permitirá que você entenda de A a Z como sua carteira funciona, para que você possa navegar pelo universo do Bitcoin com confiança. Tome controle dos seus UTXOs hoje, entendendo como funcionam as carteiras HD!

Introdução

Introdução ao Curso

Bem-vindo ao curso CYP201, onde exploraremos em profundidade o funcionamento das carteiras HD de Bitcoin. Este curso é projetado para qualquer pessoa que queira entender os fundamentos técnicos do uso do Bitcoin, seja eles usuários casuais, entusiastas esclarecidos ou futuros especialistas.

O objetivo deste treinamento é dar-lhe as chaves para dominar as ferramentas que você usa diariamente. As carteiras HD de Bitcoin, que estão no coração da sua experiência de usuário, são baseadas em conceitos às vezes complexos, que tentaremos tornar acessíveis. Juntos, vamos desmistificá-los!

Antes de mergulharmos nos detalhes da construção e operação das carteiras de Bitcoin, começaremos com alguns capítulos sobre as primitivas criptográficas a saber para o que segue. Começaremos com funções de hash criptográficas, fundamentais tanto para as carteiras quanto para o próprio protocolo Bitcoin. Você descobrirá suas principais características, as funções específicas usadas no Bitcoin e, em um capítulo mais técnico, aprenderá em detalhes sobre o funcionamento da rainha das funções de hash: SHA256. CYP201

Em seguida, discutiremos o funcionamento dos algoritmos de assinatura digital que você usa todos os dias para proteger seus UTXOs. O Bitcoin usa dois: ECDSA e o protocolo Schnorr. Você aprenderá quais primitivas matemáticas subjazem a esses algoritmos e como eles garantem a segurança das transações.

Uma vez que tenhamos uma boa compreensão desses elementos de criptografia, finalmente passaremos para o coração do treinamento: carteiras determinísticas e hierárquicas! Primeiro, há uma seção dedicada a frases mnemônicas, essas sequências de 12 ou 24 palavras que permitem criar e restaurar suas carteiras. Você descobrirá como essas palavras são geradas a partir de uma fonte de entropia e como facilitam o uso do Bitcoin.

CYP201 O treinamento continuará com o estudo da frase-senha BIP39, a semente (não confundir com a frase mnemônica), o código da cadeia mestre e a chave mestra. Veremos em detalhes o que são esses elementos, seus respectivos papéis e como são calculados. CYP201

Finalmente, a partir da chave mestra, descobriremos como pares de chaves criptográficas são derivados de maneira determinística e hierárquica até os endereços de recebimento.

Este treinamento permitirá que você use seu software de carteira com confiança, ao mesmo tempo em que aprimora suas habilidades para identificar e mitigar riscos. Prepare-se para se tornar um verdadeiro especialista em carteiras Bitcoin!

Funções de Hash

Introdução às Funções de Hash

O primeiro tipo de algoritmos criptográficos usados no Bitcoin engloba as funções de hash. Elas desempenham um papel essencial em diferentes níveis do protocolo, mas também dentro das carteiras Bitcoin. Vamos descobrir juntos o que é uma função de hash e para que serve no Bitcoin.

Definição e Princípio do Hashing

Hashing é um processo que transforma informações de comprimento arbitrário em outra peça de informação de comprimento fixo por meio de uma função de hash criptográfica. Em outras palavras, uma função de hash recebe uma entrada de qualquer tamanho e a converte em uma impressão digital de tamanho fixo, chamada de "hash". O hash também pode ser referido às vezes como "digest", "condensado", ou "hashed".

Por exemplo, a função de hash SHA256 produz um hash de comprimento fixo de 256 bits. Assim, se usarmos a entrada "PlanB", uma mensagem de comprimento arbitrário, o hash gerado será a seguinte impressão digital de 256 bits:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Características das Funções de Hash

Essas funções de hash criptográficas têm várias características essenciais que as tornam particularmente úteis no contexto do Bitcoin e de outros sistemas computacionais:

Irreversibilidade (ou resistência à imagem prévia)
Resistência à adulteração (efeito avalanche)
Resistência à colisão
Resistência à segunda imagem prévia

1. Irreversibilidade (resistência à imagem prévia):

A irreversibilidade significa que é fácil calcular o hash a partir da informação de entrada, mas que o cálculo inverso, ou seja, encontrar a entrada a partir do hash, é praticamente impossível. Essa propriedade torna as funções de hash perfeitas para criar impressões digitais únicas sem comprometer a informação original.

No exemplo dado, obter o hash 24f1b9… sabendo a entrada "PlanB" é simples e rápido. No entanto, encontrar a mensagem "PlanB" apenas sabendo 24f1b9… é impossível.

Portanto, é impossível encontrar uma imagem prévia $m$ para um hash $h$ tal que $h = \text{HASH}(m)$ , onde $\text{HASH}$ é uma função de hash criptográfica.

2. Resistência à adulteração (efeito avalanche)

A segunda característica é a resistência à adulteração, também conhecida como efeito avalanche. Esta característica é observada em uma função de hash se uma pequena alteração na mensagem de entrada resulta em uma mudança radical no hash de saída. Se voltarmos ao nosso exemplo com a entrada "PlanB" e a função SHA256, vimos que o hash gerado é o seguinte:

24f1b93b68026bfc24f5c8265f287b4c940fb1664b0d75053589d7a4f821b688

Se fizermos uma alteração muito leve na entrada, usando desta vez "Planb", então simplesmente mudar de um "B" maiúsculo para um "b" minúsculo altera completamente o hash de saída do SHA256:

bb038b4503ac5d90e1205788b00f8f314583c5e22f72bec84b8735ba5a36df3f

Esta propriedade garante que até mesmo uma alteração menor da mensagem original é imediatamente detectável, pois não apenas muda uma pequena parte do hash, mas o hash inteiro. Isso pode ser de interesse em vários campos para verificar a integridade de mensagens, software ou até mesmo transações de Bitcoin.

3. Resistência à Colisão

A terceira característica é a resistência à colisão. Uma função de hash é resistente à colisão se for computacionalmente impossível encontrar 2 mensagens diferentes que produzam o mesmo hash a partir da função. Formalmente, é difícil encontrar duas mensagens distintas $m_1$ e $m_2$ tal que:

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

Na realidade, é matematicamente inevitável que existam colisões para funções de hash, porque o tamanho das entradas pode ser maior que o tamanho das saídas. Isso é conhecido como o princípio da gaveta de Dirichlet: se $n$ objetos são distribuídos em $m$ gavetas, com $m < n$ , então pelo menos uma gaveta necessariamente conterá dois ou mais objetos. Para uma função de hash, este princípio se aplica porque o número de mensagens possíveis é (quase) infinito, enquanto o número de hashes possíveis é finito ( $2^{256}$ no caso do SHA256).

Assim, esta característica não significa que não existam colisões para funções de hash, mas sim que uma boa função de hash torna a probabilidade de encontrar uma colisão negligenciável. Esta característica, por exemplo, já não é verificada nos algoritmos SHA-0 e SHA-1, predecessores do SHA-2, para os quais colisões foram encontradas. Essas funções são, portanto, agora desaconselhadas e muitas vezes consideradas obsoletas. Para uma função de hash de $n$ bits, a resistência à colisão é da ordem de $2^{\frac{n}{2}}$ , de acordo com o ataque de aniversário. Por exemplo, para SHA256 ( $n = 256$ ), a complexidade de encontrar uma colisão é da ordem de $2^{128}$ tentativas. Em termos práticos, isso significa que se passar $2^{128}$ mensagens diferentes pela função, é provável encontrar uma colisão.

4. Resistência à Segunda Pré-imagem

A resistência à segunda pré-imagem é outra característica importante das funções de hash. Ela afirma que, dado uma mensagem $m_1$ e seu hash $h$ , é computacionalmente inviável encontrar outra mensagem $m_2 \neq m_1$ tal que:

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

Portanto, a resistência à segunda pré-imagem é um pouco semelhante à resistência à colisão, exceto que aqui, o ataque é mais difícil porque o atacante não pode escolher livremente $m_1$ .

Aplicações de Funções Hash no Bitcoin

A função hash mais usada no Bitcoin é SHA256 ("Secure Hash Algorithm 256 bits"). Projetada no início dos anos 2000 pela NSA e padronizada pelo NIST, ela produz uma saída de hash de 256 bits.

Esta função é usada em muitos aspectos do Bitcoin. No nível do protocolo, ela está envolvida no mecanismo de Prova de Trabalho, onde é aplicada em duplo hash para buscar uma colisão parcial entre o cabeçalho de um bloco candidato, criado por um minerador, e o alvo de dificuldade. Se essa colisão parcial é encontrada, o bloco candidato torna-se válido e pode ser adicionado à blockchain.

SHA256 também é usado na construção de uma árvore de Merkle, que é notavelmente o acumulador usado para registrar transações em blocos. Esta estrutura também é encontrada no protocolo Utreexo, que permite reduzir o tamanho do Conjunto UTXO. Além disso, com a introdução do Taproot em 2021, SHA256 é explorado em MAST (Merkelised Alternative Script Tree), que permite revelar apenas as condições de gasto realmente usadas em um script, sem divulgar as outras opções possíveis. Ele também é usado no cálculo de identificadores de transação, na transmissão de pacotes pela rede P2P, em assinaturas eletrônicas... Finalmente, e isso é de particular interesse neste treinamento, SHA256 é usado no nível de aplicação para a construção de carteiras Bitcoin e a derivação de endereços.

Na maioria das vezes, quando você se depara com o uso de SHA256 no Bitcoin, será na verdade um duplo hash SHA256, notado "HASH256", que simplesmente consiste em aplicar SHA256 duas vezes sucessivamente: HASH256(m) = SHA256(SHA256(m))

Esta prática de duplo hash adiciona uma camada extra de segurança contra certos ataques potenciais, mesmo que um único SHA256 seja hoje considerado criptograficamente seguro.

Outra função de hash disponível na linguagem Script e usada para derivar endereços de recebimento é a função RIPEMD160. Esta função produz um hash de 160 bits (portanto, mais curto que SHA256). Geralmente, ela é combinada com SHA256 para formar a função HASH160:

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

Esta combinação é usada para gerar hashes mais curtos, notavelmente na criação de certos endereços Bitcoin que representam hashes de chaves ou hashes de script, bem como para produzir impressões digitais de chaves.

Finalmente, apenas no nível de aplicação, a função SHA512 às vezes também é usada, que indiretamente desempenha um papel na derivação de chaves para carteiras. Esta função é muito semelhante ao SHA256 em sua operação; ambos pertencem à mesma família SHA2, mas SHA512 produz, como seu nome indica, um hash de 512 bits, comparado a 256 bits para SHA256. Detalharemos seu uso nos próximos capítulos.

Agora você conhece os conceitos básicos essenciais sobre funções de hash para o que segue. No próximo capítulo, proponho descobrir em mais detalhes o funcionamento da função que está no coração do Bitcoin: SHA256. Vamos dissecá-la para entender como ela alcança as características que descrevemos aqui. Este próximo capítulo é bastante longo e técnico, mas não é essencial para seguir o restante do treinamento. Então, se você tiver dificuldade em entendê-lo, não se preocupe e passe diretamente para o capítulo seguinte, que será muito mais acessível.

O Funcionamento Interno do SHA256

905eb320-f15b-5fb6-8d2d-5bb447337deb Anteriormente, vimos que as funções de hashing possuem características importantes que justificam seu uso no Bitcoin. Vamos agora examinar os mecanismos internos dessas funções de hashing que lhes conferem essas propriedades, e para fazer isso, proponho dissecar o funcionamento do SHA256. As funções SHA256 e SHA512 pertencem à mesma família SHA2. Seu mecanismo é baseado em uma construção específica chamada construção de Merkle-Damgård. RIPEMD160 também usa esse mesmo tipo de construção.

Como lembrete, temos uma mensagem de tamanho arbitrário como entrada para o SHA256, e vamos passá-la pela função para obter um hash de 256 bits como saída.

Pré-processamento da entrada

Para começar, precisamos preparar nossa mensagem de entrada $m$ para que ela tenha um comprimento padrão que seja múltiplo de 512 bits. Esta etapa é crucial para o funcionamento adequado do algoritmo posteriormente. Para fazer isso, começamos com a etapa de bits de preenchimento. Primeiro, adicionamos um bit separador 1 à mensagem, seguido por um certo número de bits 0. O número de bits 0 adicionados é calculado para que o comprimento total da mensagem após essa adição seja congruente a 448 módulo 512. Assim, o comprimento $L$ da mensagem com os bits de preenchimento é igual a:

 $L \equiv 448 \mod 512$

$\text{mod}$ , para módulo, é uma operação matemática que, entre dois inteiros, retorna o resto da divisão euclidiana do primeiro pelo segundo. Por exemplo: $16 \mod 5 = 1$ . É uma operação amplamente utilizada em criptografia.

Aqui, a etapa de preenchimento garante que, após adicionar os 64 bits na próxima etapa, o comprimento total da mensagem equalizada será um múltiplo de 512 bits. Se a mensagem inicial tem um comprimento de $M$ bits, o número ( $N$ ) de bits 0 a ser adicionado é assim:

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

Por exemplo, se a mensagem inicial for de 950 bits, o cálculo seria o seguinte:

 $\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*}$

Assim, teríamos 9 0s além do separador 1. Nossos bits de preenchimento a serem adicionados diretamente após nossa mensagem $M$ seriam assim:

1000 0000 00

Após adicionar os bits de preenchimento à nossa mensagem $M$ , também adicionamos uma representação de 64 bits do comprimento original da mensagem $M$ , expressa em binário. Isso permite que a função de hash seja sensível à ordem dos bits e ao comprimento da mensagem. Se voltarmos ao nosso exemplo com uma mensagem inicial de 950 bits, convertemos o número decimal 950 para binário, o que nos dá 1110 1101 10. Completamos esse número com zeros na base para fazer um total de 64 bits. No nosso exemplo, isso resulta em:

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

Este tamanho de preenchimento é adicionado seguindo o preenchimento de bits. Portanto, a mensagem após nosso pré-processamento consiste em três partes:

A mensagem original $M$ ;
Um bit 1 seguido por vários bits 0 para formar o preenchimento de bits;
Uma representação de 64 bits do comprimento de $M$ para formar o preenchimento com o tamanho.

Inicialização de Variáveis

SHA256 usa oito variáveis de estado inicial, denotadas de $A$ a $H$ , cada uma de 32 bits. Essas variáveis são inicializadas com constantes específicas, que são as partes fracionárias das raízes quadradas dos primeiros oito números primos. Usaremos esses valores subsequentemente durante o processo de hash:

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

SHA256 também usa outras 64 constantes, denotadas de $K_0$ a $K_{63}$ , que são as partes fracionárias das raízes cúbicas dos primeiros 64 números primos:

 $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}$

Divisão da Entrada

Agora que temos uma entrada equalizada, vamos agora avançar para a fase principal de processamento do algoritmo SHA256: a função de compressão. Esta etapa é muito importante, pois é principalmente o que confere à função hash suas propriedades criptográficas que estudamos no capítulo anterior.

Primeiro, começamos dividindo nossa mensagem equalizada (resultado das etapas de pré-processamento) em vários blocos $P$ de 512 bits cada. Se nossa mensagem equalizada tem um tamanho total de $n \times 512$ bits, teremos, portanto, $n$ blocos, cada um de 512 bits. Cada bloco de 512 bits será processado individualmente pela função de compressão, que consiste em 64 rodadas de operações sucessivas. Vamos nomear esses blocos $P_1$ , $P_2$ , $P_3$ ...

Operações Lógicas

Antes de explorar a função de compressão em detalhes, é importante entender as operações lógicas básicas usadas nela. Essas operações, baseadas na álgebra booleana, operam no nível de bit. As operações lógicas básicas usadas são:

Conjunção (AND): denotada $\land$ , corresponde a um "E" lógico.
Disjunção (OR): denotada $\lor$ , corresponde a um "OU" lógico.
Negação (NOT): denotada $\lnot$ , corresponde a um "NÃO" lógico.

A partir dessas operações básicas, podemos definir operações mais complexas, como o "OU Exclusivo" (XOR) denotado $\oplus$ , que é amplamente usado em criptografia. Cada operação lógica pode ser representada por uma tabela verdade, que indica o resultado para todas as combinações possíveis de valores de entrada binários (dois operandos $p$ e $q$ ). Para XOR ( $\oplus$ ):

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

Para AND ( $\land$ ):

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

Para NOT ( $\lnot p$ ):

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

Vamos pegar um exemplo para entender a operação de XOR ao nível de bit. Se temos dois números binários em 6 bits:

$a = 101100$
$b = 001000$

Então:

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

Aplicando XOR bit a bit:

Posição do Bit	$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

O resultado é, portanto, $100100$ .

Além das operações lógicas, a função de compressão usa operações de deslocamento de bits, que desempenharão um papel essencial na difusão de bits no algoritmo.

Primeiro, há a operação de deslocamento lógico para a direita, denotada $ShR_n(x)$ , que desloca todos os bits de $x$ para a direita por $n$ posições, preenchendo os bits vagos à esquerda com zeros.

Por exemplo, para $x = 101100001$ (em 9 bits) e $n = 4$ :

 $ShR_4(101100001) = 000010110$

Esquematicamente, a operação de deslocamento para a direita pode ser vista assim:

CYP201 Outra operação usada no SHA256 para manipulação de bits é a rotação circular à direita, denotada $RotR_n(x)$ , que desloca os bits de $x$ para a direita por $n$ posições, reinserindo os bits deslocados no início da string. Por exemplo, para $x = 101100001$ (em 9 bits) e $n = 4$ :

 $RotR_4(101100001) = 000110110$

Esquematicamente, a operação de rotação circular à direita pode ser vista assim:

Função de Compressão

Agora que entendemos as operações básicas, vamos examinar a função de compressão SHA256 em detalhes.

Na etapa anterior, dividimos nossa entrada em várias peças de 512 bits $P$ . Para cada bloco de 512 bits $P$ , temos:

As palavras da mensagem $W_i$ : para $i$ de 0 a 63.
As constantes $K_i$ : para $i$ de 0 a 63, definidas na etapa anterior.
As variáveis de estado $A, B, C, D, E, F, G, H$ : inicializadas com os valores da etapa anterior. As primeiras 16 palavras, $W_0$ até $W_{15}$ , são extraídas diretamente do bloco processado de 512 bits $P$ . Cada palavra $W_i$ consiste em 32 bits consecutivos do bloco. Então, por exemplo, pegamos nossa primeira peça de entrada $P_1$ , e a dividimos em pedaços menores de 32 bits que chamamos de palavras. As próximas 48 palavras ( $W_{16}$ até $W_{63}$ ) são geradas usando a seguinte fórmula:

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

Com:

$\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)$

Neste caso, $x$ é igual a $W_{i-15}$ para $\sigma_0(x)$ e $W_{i-2}$ para $\sigma_1(x)$ .

Uma vez que determinamos todas as palavras $W_i$ para nossa peça de 512 bits, podemos prosseguir para a função de compressão, que consiste em realizar 64 rodadas.

CYP201 Para cada rodada $i$ de 0 a 63, temos três tipos diferentes de entradas. Primeiro, o $W_i$ que acabamos de determinar, consistindo parcialmente de nossa peça de mensagem $P_n$ . Em seguida, as 64 constantes $K_i$ . Finalmente, usamos as variáveis de estado $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ e $H$ , que evoluirão ao longo do processo de hashing e serão modificadas a cada função de compressão. No entanto, para a primeira peça $P_1$ , usamos as constantes iniciais dadas anteriormente. Então, realizamos as seguintes operações em nossas entradas:

Função $\Sigma_0$ :

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

Função $\Sigma_1$ :

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

Função $Ch$ ("Escolha"):

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

Função $Maj$ ("Maioria"):

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

Em seguida, calculamos 2 variáveis temporárias:

$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}$

A seguir, atualizamos as variáveis de estado da seguinte forma:

 $\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}$

O diagrama a seguir representa uma rodada da função de compressão SHA256 como acabamos de descrever:

As setas indicam o fluxo de dados;
As caixas representam as operações realizadas;
O $+$ cercado representa a adição módulo $2^{32}$ .

Já podemos observar que esta rodada produz novas variáveis de estado $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ e $H$ . Essas novas variáveis servirão como entrada para a próxima rodada, que por sua vez produzirá novas variáveis $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ e $H$ , a serem usadas na rodada seguinte. Esse processo continua até a 64ª rodada. Após as 64 rodadas, atualizamos os valores iniciais das variáveis de estado adicionando-os aos valores finais ao final da rodada 64:

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

Esses novos valores de $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ e $H$ servirão como os valores iniciais para o próximo bloco, $P_2$ . Para este bloco $P_2$ , replicamos o mesmo processo de compressão com 64 rodadas, depois atualizamos as variáveis para o bloco $P_3$ , e assim por diante até o último bloco de nossa entrada equalizada.

Após processar todos os blocos de mensagem, concatenamos os valores finais das variáveis $A$ , $B$ , $C$ , $D$ , $E$ , $F$ , $G$ e $H$ para formar o hash final de 256 bits de nossa função de hash:

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

Cada variável é um inteiro de 32 bits, então sua concatenação sempre resulta em um resultado de 256 bits, independentemente do tamanho da nossa entrada de mensagem para a função de hash.

Justificação das Propriedades Criptográficas

Mas então, como essa função é irreversível, resistente a colisões e resistente a adulterações?

Para a resistência a adulterações, é bastante simples de entender. São realizados tantos cálculos em cascata, que dependem tanto da entrada quanto das constantes, que a menor modificação da mensagem inicial muda completamente o caminho tomado, e assim, muda completamente o hash de saída. Isso é o que se chama de efeito avalanche. Essa propriedade é parcialmente assegurada pela mistura dos estados intermediários com os estados iniciais para cada peça. A seguir, ao discutir uma função de hash criptográfica, o termo "irreversibilidade" geralmente não é usado. Em vez disso, falamos sobre "resistência à pré-imagem", que especifica que para qualquer $y$ dado, é difícil encontrar um $x$ tal que $h(x) = y$ . Esta resistência à pré-imagem é garantida pela complexidade algébrica e pela forte não-linearidade das operações realizadas na função de compressão, bem como pela perda de certas informações no processo. Por exemplo, para um dado resultado de uma adição módulo, existem vários operandos possíveis:$$ 3+2 \mod 10 = 5 \ 7+8 \mod 10 = 5 \ 5+10 \mod 10 = 5

 $Neste exemplo, sabendo apenas o módulo usado (10) e o resultado (5), não se pode determinar com certeza quais são os operandos corretos usados na adição. Diz-se que existem múltiplas congruências módulo 10. Para a operação XOR, enfrentamos o mesmo problema. Lembre-se da tabela verdade para esta operação: qualquer saída de 1 bit pode ser determinada por duas configurações de entrada diferentes que têm exatamente a mesma probabilidade de serem os valores corretos. Portanto, não se pode determinar com certeza os operandos de um XOR sabendo apenas seu resultado. Se aumentarmos o tamanho dos operandos do XOR, o número de entradas possíveis sabendo apenas o resultado aumenta exponencialmente. Além disso, o XOR é frequentemente usado junto com outras operações a nível de bit, como a operação $\text{RotR}$, que adiciona ainda mais possíveis interpretações ao resultado. A função de compressão também usa a operação $\text{ShR}$. Esta operação remove uma parte da informação básica, que depois se torna impossível de recuperar. Mais uma vez, não há meios algébricos para reverter esta operação. Todas essas operações unidirecionais e de perda de informação são usadas muito frequentemente em funções de compressão. O número de entradas possíveis para uma saída dada é quase infinito, e cada tentativa de cálculo reverso levaria a equações com um número muito alto de incógnitas, que aumentaria exponencialmente a cada etapa. Finalmente, para a característica de resistência à colisão, vários parâmetros entram em jogo. O pré-processamento da mensagem original desempenha um papel essencial. Sem este pré-processamento, poderia ser mais fácil encontrar colisões na função. Embora, teoricamente, colisões existam (devido ao princípio da casa dos pombos), a estrutura da função de hash, combinada com as propriedades mencionadas, torna a probabilidade de encontrar uma colisão extremamente baixa. Para que uma função de hash seja resistente à colisão, é essencial que: - A saída seja imprevisível: Qualquer previsibilidade pode ser explorada para encontrar colisões mais rapidamente do que com um ataque de força bruta. A função garante que cada bit da saída dependa de uma maneira não trivial da entrada. Em outras palavras, a função é projetada de modo que cada bit do resultado final tenha uma probabilidade independente de ser 0 ou 1, mesmo que esta independência não seja absoluta na prática. - A distribuição dos hashes seja pseudo-aleatória: Isso garante que os hashes sejam uniformemente distribuídos. - O tamanho do hash seja substancial: quanto maior o espaço possível para resultados, mais difícil é encontrar uma colisão. Os criptógrafos projetam essas funções avaliando os melhores ataques possíveis para encontrar colisões, ajustando então os parâmetros para tornar esses ataques ineficazes. ### Construção de Merkle-Damgård A estrutura do SHA256 é baseada na construção de Merkle-Damgård, que permite transformar uma função de compressão em uma função de hash que pode processar mensagens de comprimento arbitrário. É exatamente isso que vimos neste capítulo. No entanto, algumas funções de hash antigas como SHA1 ou MD5, que usam essa construção específica, são vulneráveis a ataques de extensão de comprimento. Esta é uma técnica que permite a um atacante que conhece o hash de uma mensagem $M$ e o comprimento de $M$ (sem conhecer a própria mensagem) calcular o hash de uma mensagem $M'$ formada pela concatenação de $M$ com conteúdo adicional. SHA256, mesmo utilizando o mesmo tipo de construção, é teoricamente resistente a este tipo de ataque, ao contrário de SHA1 e MD5. Isso pode explicar o mistério da dupla hash implementada em todo o Bitcoin por Satoshi Nakamoto. Para evitar esse tipo de ataque, Satoshi pode ter preferido usar um duplo SHA256:$

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

 $Isso aumenta a segurança contra ataques potenciais relacionados à construção de Merkle-Damgård, mas não aumenta a segurança do processo de hash em termos de resistência à colisão. Além disso, mesmo que SHA256 fosse vulnerável a este tipo de ataque, isso não teria um impacto sério, pois todos os casos de uso de funções de hash no Bitcoin envolvem dados públicos. No entanto, o ataque de extensão de comprimento só seria útil para um atacante se os dados hashados fossem privados e o usuário tivesse usado a função de hash como um mecanismo de autenticação para esses dados, semelhante a um MAC. Assim, a implementação da dupla hash permanece um mistério no design do Bitcoin. Agora que examinamos em detalhes o funcionamento das funções de hash, particularmente SHA256, que é amplamente utilizado no Bitcoin, vamos focar mais especificamente nos algoritmos de derivação criptográfica usados no nível de aplicação, especialmente para derivar as chaves para sua carteira. ## Os algoritmos usados para derivação <chapterId>cc668121-7789-5e99-bf5e-1ba085f4f5f2</chapterId> No Bitcoin, no nível de aplicação, além das funções de hash, algoritmos de derivação criptográfica são usados para gerar dados seguros a partir de entradas iniciais. Embora esses algoritmos dependam de funções de hash, eles servem a propósitos diferentes, especialmente em termos de autenticação e geração de chaves. Esses algoritmos retêm algumas das características das funções de hash, como irreversibilidade, resistência a adulteração e resistência a colisões. Em carteiras de Bitcoin, principalmente 2 algoritmos de derivação são usados: - **HMAC (*Código de Autenticação de Mensagem Baseado em Hash*)** - **PBKDF2 (*Função de Derivação de Chave Baseada em Senha 2*)** Vamos explorar juntos o funcionamento e o papel de cada um deles. ### HMAC-SHA512 HMAC é um algoritmo criptográfico que calcula um código de autenticação com base em uma combinação de uma função de hash e uma chave secreta. O Bitcoin usa HMAC-SHA512, a variante do HMAC que usa a função de hash SHA512. Já vimos no capítulo anterior que SHA512 faz parte da mesma família de funções de hash que SHA256, mas produz uma saída de 512 bits. Aqui está seu esquema geral de operação com $m$ sendo a mensagem de entrada e $K$ uma chave secreta: ![CYP201](/courses/cyp201/assets/fr/011.webp) Vamos estudar em mais detalhes o que acontece nesta caixa preta HMAC-SHA512. A função HMAC-SHA512 com: - $m$: a mensagem de tamanho arbitrário escolhida pelo usuário (primeira entrada); - $K$: a chave secreta arbitrária escolhida pelo usuário (segunda entrada); - $K'$: a chave $K$ ajustada ao tamanho $B$ dos blocos da função de hash (1024 bits para SHA512, ou 128 bytes); - $\text{SHA512}$: a função de hash SHA512; - $\oplus$: a operação XOR (ou exclusivo); - $\Vert$: o operador de concatenação, ligando cadeias de bits de ponta a ponta; - $\text{opad}$: constante composta pelo byte $0x5c$ repetido 128 vezes - $\text{ipad}$: constante composta pelo byte $0x36$ repetido 128 vezes Antes de calcular o HMAC, é necessário igualar a chave e as constantes de acordo com o tamanho do bloco $B$. Por exemplo, se a chave $K$ for menor que 128 bytes, ela é preenchida com zeros até atingir o tamanho $B$. Se $K$ for maior que 128 bytes, ela é comprimida usando SHA512, e então zeros são adicionados até que atinja 128 bytes. Desta forma, obtém-se uma chave equalizada denominada $K'$. Os valores de $\text{opad}$ e $\text{ipad}$ são obtidos repetindo seu byte base ($0x5c$ para $\text{opad}$, $0x36$ para $\text{ipad}$) até que o tamanho $B$ seja alcançado. Assim, com $B = 128$ bytes, temos:$

\text{opad} = \underbrace{0x5c5c\ldots5c}_{128 , \text{bytes}}

 $Uma vez feito o pré-processamento, o algoritmo HMAC-SHA512 é definido pela seguinte equação:$

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

 $Esta equação é dividida nos seguintes passos: - XOR da chave ajustada $K'$ com $\text{ipad}$ para obter $\text{iKpad}$; - XOR da chave ajustada $K'$ com $\text{opad}$ para obter $\text{oKpad}$; - Concatenar $\text{iKpad}$ com a mensagem $m$. - Fazer o hash deste resultado com SHA512 para obter um hash intermediário $H_1$. - Concatenar $\text{oKpad}$ com $H_1$. - Fazer o hash deste resultado com SHA512 para obter o resultado final $H_2$. Estes passos podem ser resumidos esquematicamente da seguinte forma: ![CYP201](/courses/cyp201/assets/fr/012.webp) O HMAC é usado no Bitcoin notavelmente para a derivação de chaves em carteiras HD (Hierarchical Deterministic) (falaremos sobre isso com mais detalhes nos próximos capítulos) e como um componente do PBKDF2. ### PBKDF2 PBKDF2 (*Password-Based Key Derivation Function 2*) é um algoritmo de derivação de chave projetado para aumentar a segurança de senhas. O algoritmo aplica uma função pseudo-aleatória (aqui HMAC-SHA512) em uma senha e um sal criptográfico, e então repete esta operação um certo número de vezes para produzir uma chave de saída. No Bitcoin, o PBKDF2 é usado para gerar a semente de uma carteira HD a partir de uma frase mnemônica e uma passphrase (mas falaremos sobre isso com mais detalhes nos próximos capítulos). O processo do PBKDF2 é o seguinte, com: - $m$: a frase mnemônica do usuário; - $s$: a passphrase opcional para aumentar a segurança (campo vazio se não houver passphrase); - $n$: o número de iterações da função, no nosso caso, são 2048. A função PBKDF2 é definida iterativamente. Cada iteração pega o resultado da anterior, passa-o pelo HMAC-SHA512 e combina os resultados sucessivos para produzir a chave final:$

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

y^2 = x^3 + ax + b

 $### secp256k1 Para usar ECDSA ou Schnorr, deve-se escolher os parâmetros da curva elíptica, isto é, os valores de $a$ e $b$ na equação da curva. Existem diferentes padrões de curvas elípticas que são reputados como seguros criptograficamente. O mais conhecido é a curva *secp256r1*, definida e recomendada pelo NIST (*National Institute of Standards and Technology*). Apesar disso, Satoshi Nakamoto, o inventor do Bitcoin, optou por não usar essa curva. A razão dessa escolha é desconhecida, mas alguns acreditam que ele preferiu encontrar uma alternativa porque os parâmetros dessa curva poderiam potencialmente conter uma porta dos fundos. Em vez disso, o protocolo Bitcoin usa a curva padrão ***secp256k1***. Esta curva é definida pelos parâmetros $a = 0$ e $b = 7$. Sua equação é, portanto:$

y^2 = x^3 + 7

 $Sua representação gráfica sobre o campo dos números reais é assim: ![CYP201](/courses/cyp201/assets/fr/015.webp) No entanto, em criptografia, trabalhamos com conjuntos finitos de números. Mais especificamente, trabalhamos no campo finito $\mathbb{F}_p$, que é o campo dos inteiros módulo um número primo $p$. **Definição**: Um número primo é um inteiro natural maior ou igual a 2 que possui apenas dois divisores inteiros positivos distintos: 1 e ele mesmo. Por exemplo, o número 7 é um número primo, pois só pode ser dividido por 1 e 7. Por outro lado, o número 8 não é primo porque pode ser dividido por 1, 2, 4 e 8. No Bitcoin, o número primo $p$ usado para definir o campo finito é muito grande. É escolhido de tal forma que a ordem do campo (ou seja, o número de elementos em $\mathbb{F}_p$) seja suficientemente grande para garantir a segurança criptográfica. O número primo $p$ usado é: ```txt p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` Na notação decimal, isso corresponde a:$

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

 $Assim, a equação da nossa curva elíptica é na verdade:$

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

 $Dado que esta curva é definida sobre o campo finito $\mathbb{F}_p$, ela não se assemelha mais a uma curva contínua, mas sim a um conjunto discreto de pontos. Por exemplo, aqui está como a curva usada no Bitcoin parece para um $p$ muito pequeno, $p = 17$: ![CYP201](/courses/cyp201/assets/fr/016.webp) Neste exemplo, limitei intencionalmente o campo finito a $p = 17$ por razões educacionais, mas deve-se imaginar que o usado no Bitcoin é imensamente maior, quase $2^{256}$. Usamos um campo finito de inteiros módulo $p$ para garantir a precisão das operações na curva. De fato, curvas elípticas sobre o campo dos números reais estão sujeitas a imprecisões devido a erros de arredondamento durante cálculos computacionais. Se muitas operações são realizadas na curva, esses erros se acumulam e o resultado final pode ser incorreto ou difícil de reproduzir. O uso exclusivo de inteiros positivos garante a precisão perfeita dos cálculos e, assim, a reprodutibilidade do resultado. A matemática das curvas elípticas sobre campos finitos é análoga àquela sobre o campo dos números reais, com a adaptação de que todas as operações são realizadas módulo $p$. Para simplificar as explicações, continuaremos nos capítulos seguintes a ilustrar conceitos usando uma curva definida sobre números reais, mantendo em mente que, na prática, a curva é definida sobre um campo finito. Se você deseja aprender mais sobre os fundamentos matemáticos da criptografia moderna, também recomendo consultar este outro curso na Plan ₿ Network: https://planb.network/courses/d2fd9fc0-d9ed-4a87-9fa3-0fdbb3937e28 ## Calculando a Chave Pública a partir da Chave Privada <chapterId>fcb2bd58-5dda-5ecf-bb8f-ad1a0561ab4a</chapterId> Como visto anteriormente, os algoritmos de assinatura digital no Bitcoin são baseados em um par de chaves privadas e públicas que estão matematicamente vinculadas. Vamos explorar juntos qual é esse vínculo matemático e como elas são geradas. ### A Chave Privada A chave privada é simplesmente um número aleatório ou pseudoaleatório. No caso do Bitcoin, esse número tem 256 bits de tamanho. O número de possibilidades para uma chave privada do Bitcoin é, portanto, teoricamente $2^{256}$. **Nota**: Um "número pseudoaleatório" é um número que possui propriedades próximas às de um número verdadeiramente aleatório, mas é gerado por um algoritmo determinístico. No entanto, na prática, existem apenas $n$ pontos distintos na nossa curva elíptica secp256k1, onde $n$ é a ordem do ponto gerador $G$ da curva. Veremos mais tarde a que este número corresponde, mas simplesmente lembre-se de que uma chave privada válida é um inteiro entre $1$ e $n-1$, sabendo que $n$ é um número próximo, mas ligeiramente menor que $2^{256}$. Portanto, existem alguns números de 256 bits que não são válidos para se tornarem uma chave privada no Bitcoin, especificamente, todos os números entre $n$ e $2^{256}$. Se a geração do número aleatório (a chave privada) produzir um valor $k$ tal que $k \geq n$, ele é considerado inválido, e um novo valor aleatório deve ser gerado. O número de possibilidades para uma chave privada de Bitcoin é, portanto, cerca de $n$, que é um número próximo a $1.158 \times 10^{77}$. Este número é tão grande que, se você escolher uma chave privada aleatoriamente, é estatisticamente quase impossível cair em uma chave privada de outro usuário. Para lhe dar uma ideia da escala, o número de chaves privadas possíveis no Bitcoin é de uma ordem de magnitude próxima à do número estimado de átomos no universo observável. Como veremos nos próximos capítulos, hoje, a maioria das chaves privadas usadas no Bitcoin não são geradas aleatoriamente, mas são o resultado da derivação determinística de uma frase mnemônica, ela mesma pseudoaleatória (esta é a famosa frase de 12 ou 24 palavras). Esta informação não muda nada para o uso de algoritmos de assinatura como o ECDSA, mas ajuda a refocar nossa popularização no Bitcoin. Para a continuação da explicação, a chave privada será denotada pela letra minúscula $k$. ### A Chave Pública A chave pública é um ponto na curva elíptica, denotado pela letra maiúscula $K$, e é calculada a partir da chave privada $k$. Este ponto $K$ é representado por um par de coordenadas $(x, y)$ na curva elíptica, cada coordenada sendo um inteiro módulo $p$, o número primo que define o campo finito $\mathbb{F}_p$. Na prática, uma chave pública não comprimida é representada por 512 bits (ou 64 bytes), correspondendo a dois números de 256 bits ($x$ e $y$) colocados lado a lado. Estes números são a abscissa ($x$) e a ordenada ($y$) do nosso ponto na secp256k1. Se adicionarmos o prefixo, a chave pública totaliza 520 bits. No entanto, também é possível representar a chave pública de forma comprimida usando apenas 33 bytes (264 bits) mantendo apenas a abscissa $x$ do nosso ponto na curva e um byte indicando a paridade de $y$. Isso é o que se conhece como uma chave pública comprimida. Falarei mais sobre isso nos últimos capítulos deste treinamento. Mas o que você precisa lembrar é que uma chave pública $K$ é um ponto descrito por $x$ e $y$. Para calcular o ponto $K$ que corresponde à nossa chave pública, usamos a operação de multiplicação escalar em curvas elípticas, definida como uma adição repetida ($k$ vezes) do ponto gerador $G$:$

K = k \cdot G

 $onde: - $k$ é a chave privada (um inteiro aleatório entre $1$ e $n-1$); - $G$ é o ponto gerador da curva elíptica usado por todos os participantes da rede Bitcoin; - $\cdot$ representa a multiplicação escalar na curva elíptica, que é equivalente a adicionar o ponto $G$ a si mesmo $k$ vezes. O fato de que este ponto $G$ é comum a todas as chaves públicas no Bitcoin nos permite ter certeza de que a mesma chave privada $k$ sempre nos dará a mesma chave pública $K$: ![CYP201](/courses/cyp201/assets/fr/017.webp) A principal característica desta operação é que ela é uma função unidirecional. É fácil calcular a chave pública $K$ conhecendo a chave privada $k$ e o ponto gerador $G$, mas é praticamente impossível calcular a chave privada $k$ conhecendo apenas a chave pública $K$ e o ponto gerador $G$. Encontrar $k$ a partir de $K$ e $G$ equivale a resolver o problema do logaritmo discreto em curvas elípticas, um problema matematicamente difícil para o qual não se conhece algoritmo eficiente. Mesmo os calculadores mais poderosos atuais são incapazes de resolver este problema em um tempo razoável. ![CYP201](/courses/cyp201/assets/fr/018.webp) ### Adição e Dobramento de Pontos em Curvas Elípticas O conceito de adição em curvas elípticas é definido geometricamente. Se temos dois pontos $P$ e $Q$ na curva, a operação $P + Q$ é calculada desenhando uma linha que passa por $P$ e $Q$. Esta linha necessariamente intersectará a curva em um terceiro ponto $R'$. Em seguida, tomamos a imagem espelhada deste ponto em relação ao eixo x para obter o ponto $R$, que é o resultado da adição:$

P + Q = R

 $Graficamente, isso pode ser representado da seguinte forma: ![CYP201](/courses/cyp201/assets/fr/019.webp) Para o dobramento de um ponto, isto é, a operação $P + P$, desenhamos a tangente à curva no ponto $P$. Esta tangente intersecta a curva em outro ponto $S'$. Em seguida, tomamos a imagem espelhada deste ponto em relação ao eixo x para obter o ponto $S$, que é o resultado do dobramento:$

2P = S

 $Graficamente, isso é mostrado como: ![CYP201](/courses/cyp201/assets/fr/020.webp) Usando essas operações de adição e dobramento, podemos realizar a multiplicação escalar de um ponto por um inteiro $k$, denotado $kP$, realizando dobramentos e adições repetidas. Por exemplo, suponha que escolhemos uma chave privada $k = 4$. Para calcular a chave pública associada, realizamos:$

K = k \cdot G = 4G

 $Graficamente, isso corresponde a realizar uma série de adições e dobramentos: - Calcular $2G$ dobrando $G$. - Calcular $4G$ dobrando $2G$. ![CYP201](/courses/cyp201/assets/fr/021.webp) Se desejarmos, por exemplo, calcular o ponto $3G$, devemos primeiro calcular o ponto $2G$ dobrando o ponto $G$, depois adicionar $G$ e $2G$. Para adicionar $G$ e $2G$, basta desenhar a linha conectando esses dois pontos, recuperar o ponto único $-3G$ na interseção entre esta linha e a curva elíptica, e então determinar $3G$ como o oposto de $-3G$. Teremos:$

G + G = 2G

2G + G = 3G

 $Graficamente, isso seria representado da seguinte forma: ![CYP201](/courses/cyp201/assets/fr/022.webp) ### Função Unidirecional Graças a essas operações, podemos entender por que é fácil derivar uma chave pública a partir de uma chave privada, mas o inverso é praticamente impossível. Vamos voltar ao nosso exemplo simplificado. Com uma chave privada $k = 4$. Para calcular a chave pública associada, realizamos:$

K = k \cdot G = 4G

 $Assim, fomos capazes de calcular facilmente a chave pública $K$ conhecendo $k$ e $G$. Agora, se alguém conhece apenas a chave pública $K$, enfrenta o problema do logaritmo discreto: encontrar $k$ tal que $K = k \cdot G$. Este problema é considerado difícil porque não existe um algoritmo eficiente para resolvê-lo em curvas elípticas. Isso garante a segurança dos algoritmos ECDSA e Schnorr. Claro, neste exemplo simplificado com $k = 4$, seria possível encontrar $k$ por tentativa e erro, já que o número de possibilidades é baixo. No entanto, na prática no Bitcoin, $k$ é um inteiro de 256 bits, tornando o número de possibilidades astronomicamente grande (cerca de $1.158 \times 10^{77}$). Portanto, é inviável encontrar $k$ por força bruta. ## Assinando com a Chave Privada <chapterId>bb07826f-826e-5905-b307-3d82001fb778</chapterId> Agora que você sabe como derivar uma chave pública a partir de uma chave privada, você já pode receber bitcoins usando esse par de chaves como condição de gasto. Mas como gastá-los? Para gastar bitcoins, você precisará desbloquear o _scriptPubKey_ anexado ao seu UTXO para provar que você é de fato seu legítimo proprietário. Para fazer isso, você deve produzir uma assinatura $s$ que corresponda à chave pública $K$ presente no _scriptPubKey_ usando a chave privada $k$ que foi inicialmente usada para calcular $K$. A assinatura digital é, portanto, prova irrefutável de que você está na posse da chave privada associada à chave pública que você reivindica. ### Parâmetros da Curva Elíptica Para realizar uma assinatura digital, todos os participantes devem primeiro concordar com os parâmetros da curva elíptica usada. No caso do Bitcoin, os parâmetros do **secp256k1** são os seguintes: O campo finito $\mathbb{Z}_p$ definido por:$

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

 $```txt p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F ``` $p$ é um número primo muito grande, ligeiramente menor que $2^{256}$. A curva elíptica $y^2 = x^3 + ax + b$ sobre $\mathbb{Z}_p$ definida por:$

a = 0, \quad b = 7

 $O ponto gerador ou ponto de origem $G$: ```txt G = 0x0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 ``` Este número é a forma comprimida que fornece apenas a abscissa do ponto $G$. O prefixo `02` no início determina qual dos dois valores com esta abscissa $x$ deve ser usado como o ponto gerador. A ordem $n$ de $G$ (o número de pontos existentes) e o cofator $h$: ```txt n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 ``` $n$ é um número muito grande, ligeiramente menor que $p$.$

h=1

 $$h$ é o cofator ou o número de subgrupos. Não vou me aprofundar no que isso representa aqui, pois é bastante complexo, e no caso do Bitcoin, não precisamos levar isso em conta, já que é igual a $1$. Todas essas informações são públicas e conhecidas por todos os participantes. Graças a elas, os usuários podem fazer uma assinatura digital e verificá-la. ### Assinatura com ECDSA O algoritmo ECDSA permite que um usuário assine uma mensagem usando sua chave privada, de tal forma que qualquer pessoa que conheça a chave pública correspondente possa verificar a validade da assinatura, sem que a chave privada seja revelada. No contexto do Bitcoin, a mensagem a ser assinada depende do _sighash_ escolhido pelo usuário. É este _sighash_ que determinará quais partes da transação são cobertas pela assinatura. Falarei mais sobre isso no próximo capítulo. Aqui estão os passos para gerar uma assinatura ECDSA: Primeiro, calculamos o hash ($e$) da mensagem que precisa ser assinada. A mensagem $m$ é, portanto, passada por uma função de hash criptográfica, geralmente SHA256 ou duplo SHA256 no caso do Bitcoin:$

e = \text{HASH}(m)

 $Em seguida, calculamos um nonce. Em criptografia, um nonce é simplesmente um número gerado de maneira aleatória ou pseudoaleatória que é usado apenas uma vez. Ou seja, cada vez que uma nova assinatura digital é feita com este par de chaves, será muito importante usar um nonce diferente, caso contrário, comprometerá a segurança da chave privada. Portanto, é suficiente determinar um inteiro aleatório e único $r$ tal que $1 \leq r \leq n-1$, onde $n$ é a ordem do ponto gerador $G$ da curva elíptica. Então, calcularemos o ponto $R$ na curva elíptica com as coordenadas $(x_R, y_R)$ tal que:$

R = r \cdot G

 $Extraímos o valor da abscissa do ponto $R$ ($x_R$). Este valor representa a primeira parte da assinatura. E, finalmente, calculamos a segunda parte da assinatura $s$ desta maneira:$

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

 $onde: - $r^{-1}$ é o inverso modular de $r$ módulo $n$, ou seja, um inteiro tal que $r \cdot r^{-1} \equiv 1 \mod n$; - $k$ é a chave privada do usuário; - $e$ é o hash da mensagem; - $n$ é a ordem do ponto gerador $G$ da curva elíptica. A assinatura é então simplesmente a concatenação de $x_R$ e $s$:$

\text{SIG} = x_R \Vert s

 $### Verificação da Assinatura ECDSA Para verificar uma assinatura $(x_R, s)$, qualquer pessoa que conheça a chave pública $K$ e os parâmetros da curva elíptica pode proceder da seguinte maneira: Primeiro, verifique se $x_R$ e $s$ estão dentro do intervalo $[1, n-1]$. Isso garante que a assinatura respeita as restrições matemáticas do grupo elíptico. Se não for o caso, o verificador rejeita imediatamente a assinatura como inválida. Em seguida, calcule o hash da mensagem:$

e = \text{HASH}(m)

 $Calcule o inverso modular de $s$ módulo $n$:$

s^{-1} \mod n

 $Calcule dois valores escalares $u_1$ e $u_2$ desta forma:$

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

 $E finalmente, calcule o ponto $V$ na curva elíptica tal que:$

V = u_1 \cdot G + u_2 \cdot K

 $A assinatura é válida apenas se $x_V \equiv x_R \mod n$, onde $x_V$ é a coordenada $x$ do ponto $V$. De fato, combinando $u_1 \cdot G$ e $u_2 \cdot K$, obtém-se um ponto $V$ que, se a assinatura for válida, deve corresponder ao ponto $R$ usado durante a assinatura (módulo $n$). ### Assinatura com o Protocolo Schnorr O esquema de assinatura Schnorr é uma alternativa ao ECDSA que oferece muitas vantagens. Tem sido possível usá-lo no Bitcoin desde 2021 e a introdução do Taproot, com os padrões de script P2TR. Como o ECDSA, o esquema Schnorr permite assinar uma mensagem usando uma chave privada, de tal forma que a assinatura possa ser verificada por qualquer pessoa que conheça a chave pública correspondente. No caso do Schnorr, a mesma curva que o ECDSA é usada com os mesmos parâmetros. No entanto, as chaves públicas são representadas de forma ligeiramente diferente em comparação com o ECDSA. De fato, elas são designadas apenas pela coordenada $x$ do ponto na curva elíptica. Ao contrário do ECDSA, onde chaves públicas comprimidas são representadas por 33 bytes (com o byte de prefixo indicando a paridade de $y$), Schnorr usa chaves públicas de 32 bytes, correspondendo apenas à coordenada $x$ do ponto $K$, e presume-se que $y$ seja par por padrão. Esta representação simplificada reduz o tamanho das assinaturas e facilita certas otimizações nos algoritmos de verificação. A chave pública é então a coordenada $x$ do ponto $K$:$

\text{pk} = K_x

 $O primeiro passo para gerar uma assinatura é fazer o hash da mensagem. Mas, ao contrário do ECDSA, isso é feito com outros valores e uma função de hash rotulada é usada para evitar colisões em diferentes contextos. Uma função de hash rotulada simplesmente envolve adicionar um rótulo arbitrário às entradas da função de hash junto com os dados da mensagem. ![CYP201](/courses/cyp201/assets/fr/023.webp) Além da mensagem, a coordenada $x$ da chave pública $K_x$, bem como um ponto $R$ calculado a partir do nonce $r$ ($R=r \cdot G$) que é ele mesmo um inteiro único para cada assinatura, calculado deterministicamente a partir da chave privada e da mensagem para evitar vulnerabilidades relacionadas à reutilização de nonce, também são passados para a função rotulada. Assim como para a chave pública, apenas a coordenada $x$ do ponto nonce $R_x$ é retida para descrever o ponto. O resultado deste hash, notado $e$, é chamado de "desafio": e = \text{HASH}(\text{``BIP0340/challenge''}, R_x \Vert K_x \Vert m) \mod n$$ Aqui, $\text{HASH}$ é a função de hash SHA256, e $\text{``BIP0340/challenge''}$ é a tag específica para o hashing. Finalmente, o parâmetro $s$ é calculado desta maneira a partir da chave privada $k$, do nonce $r$ e do desafio $e$:$

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

 $A assinatura é então simplesmente o par $Rx$ e $s$.$

\text{SIG} = R_x \Vert s

 $### Verificação da Assinatura Schnorr A verificação de uma assinatura Schnorr é mais simples do que a de uma assinatura ECDSA. Aqui estão os passos para verificar a assinatura $(R_x, s)$ com a chave pública $K_x$ e a mensagem $m$: Primeiro, verificamos se $K_x$ é um inteiro válido e menor que $p$. Se for o caso, recuperamos o ponto correspondente na curva com $K_y$ sendo par. Também extraímos $R_x$ e $s$ separando a assinatura $\text{SIG}$. Então, verificamos que $R_x < p$ e $s < n$ (a ordem da curva). Em seguida, calculamos o desafio $e$ da mesma maneira que o emissor da assinatura:$

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

 $Depois, calculamos um ponto de referência na curva desta maneira:$

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

 $Finalmente, verificamos se $R'_x = R_x$. Se as duas coordenadas x coincidirem, então a assinatura $(R_x, s)$ é de fato válida com a chave pública $K_x$. ### Por que isso funciona? O signatário calculou $s = r + e \cdot k \mod n$, então $R' = s \cdot G - e \cdot K$ deve ser igual ao ponto original $R$, porque:$

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

 $Como $K = k \cdot G$, temos $e \cdot k \cdot G = e \cdot K$. Assim:$

R' = r \cdot G = R

 $Portanto, temos:$

R'_x = R_x

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

 $onde $\text{ENT}$ representa o comprimento da entropia em bits, e $\text{CS}$ o comprimento do checksum em bits. Por exemplo, para uma entropia de 256 bits, os primeiros 8 bits do hash são tomados para formar o checksum:$

\text{CS} = \frac{256}{32} = 8 \text{ bits}

 $Uma vez calculado o checksum, ele é concatenado com a entropia para obter uma sequência de bits estendida notada $\text{ENT} \Vert \text{CS}$ ("concatenar" significa colocar um ao lado do outro). ![CYP201](/courses/cyp201/assets/fr/036.webp) ### Correspondência entre a Entropia e a Frase Mnemônica O número de palavras na frase mnemônica depende do tamanho da entropia inicial, como ilustrado na tabela a seguir com: - $\text{ENT}$: o tamanho em bits da entropia; - $\text{CS}$: o tamanho em bits do checksum; - $w$: o número de palavras na frase mnemônica final.$

\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}

 $Por exemplo, para uma entropia de 256 bits, o resultado $\text{ENT} \Vert \text{CS}$ é de 264 bits e gera uma frase mnemônica de 24 palavras. ### Conversão da Sequência Binária em uma Frase Mnemônica A sequência de bits $\text{ENT} \Vert \text{CS}$ é então dividida em segmentos de 11 bits. Cada segmento de 11 bits, uma vez convertido para decimal, corresponde a um número entre 0 e 2047, que designa a posição de uma palavra [em uma lista de 2048 palavras padronizadas pelo 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) Por exemplo, para uma entropia de 128 bits, o checksum é de 4 bits, e assim a sequência total mede 132 bits. Ela é dividida em 12 segmentos de 11 bits (os bits laranjas designam o checksum): ![CYP201](/courses/cyp201/assets/fr/038.webp) Cada segmento é então convertido em um número decimal que representa uma palavra na lista. Por exemplo, o segmento binário `01011010001` é equivalente em decimal a `721`. Ao adicionar 1 para alinhar com a indexação da lista (que começa em 1 e não 0), isso dá o rank da palavra `722`, que é "*focus*" na lista. ![CYP201](/courses/cyp201/assets/fr/039.webp) Esta correspondência é repetida para cada um dos 12 segmentos, a fim de obter uma frase de 12 palavras. ![CYP201](/courses/cyp201/assets/fr/040.webp) ### Características da Lista de Palavras BIP39 Uma particularidade da lista de palavras BIP39 é que nenhuma palavra compartilha as mesmas quatro primeiras letras na mesma ordem com outra palavra. Isso significa que anotar apenas as quatro primeiras letras de cada palavra é suficiente para salvar a frase mnemônica. Isso pode ser interessante para economizar espaço, especialmente para aqueles que desejam gravá-la em um suporte de metal. Esta lista de 2048 palavras existe em vários idiomas. Estas não são simples traduções, mas palavras distintas para cada idioma. No entanto, é fortemente recomendado manter a versão em inglês, pois as versões em outros idiomas geralmente não são suportadas pelo software de carteira. ### Qual Comprimento Escolher para Sua Frase Mnemônica? Para determinar o comprimento ótimo da sua frase mnemônica, deve-se considerar a segurança real que ela proporciona. Uma frase de 12 palavras garante 128 bits de segurança, enquanto uma frase de 24 palavras oferece 256 bits. No entanto, essa diferença no nível de segurança da frase não melhora a segurança geral de uma carteira Bitcoin, pois as chaves privadas derivadas dessa frase só se beneficiam de 128 bits de segurança. De fato, como vimos anteriormente, as chaves privadas do Bitcoin são geradas a partir de números aleatórios (ou derivadas de uma fonte aleatória) variando entre $1$ e $n-1$, onde $n$ representa a ordem do ponto gerador $G$ da curva secp256k1, um número ligeiramente menor que $2^{256}$. Pode-se, portanto, pensar que essas chaves privadas oferecem 256 bits de segurança. No entanto, sua segurança reside na dificuldade de encontrar uma chave privada a partir de sua chave pública associada, uma dificuldade estabelecida pelo problema matemático do logaritmo discreto em curvas elípticas (*ECDLP*). Até o momento, o algoritmo mais conhecido para resolver esse problema é o algoritmo rho de Pollard, que reduz o número de operações necessárias para quebrar uma chave para a raiz quadrada de seu tamanho. Para chaves de 256 bits, como as usadas no Bitcoin, o algoritmo rho de Pollard reduz assim a complexidade para $2^{128}$ operações:$

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

 $Portanto, considera-se que uma chave privada usada no Bitcoin oferece 128 bits de segurança. Como resultado, escolher uma frase de 24 palavras não proporciona proteção adicional para a carteira, pois 256 bits de segurança na frase são inúteis se as chaves derivadas só oferecem 128 bits de segurança. Para ilustrar esse princípio, é como ter uma casa com duas portas: uma porta de madeira antiga e uma porta reforçada. No caso de um arrombamento, a porta reforçada não seria útil, já que o intruso passaria pela porta de madeira. Esta é uma situação análoga aqui. Uma frase de 12 palavras, que também oferece 128 bits de segurança, é, portanto, atualmente suficiente para proteger seus bitcoins contra qualquer tentativa de roubo. Enquanto o algoritmo de assinatura digital não mudar para usar chaves maiores ou depender de um problema matemático diferente do ECDLP, uma frase de 24 palavras permanece supérflua. Além disso, uma frase mais longa aumenta o risco de perda durante o backup: um backup que é duas vezes mais curto é sempre mais fácil de gerenciar. Para ir além e aprender concretamente como gerar manualmente uma frase mnemônica de teste, aconselho você a descobrir este tutorial: https://planb.network/tutorials/wallet/backup/generate-mnemonic-phrase-47507d90-e6af-4cac-b01b-01a14d7a8228 Antes de continuar com a derivação da carteira a partir desta frase mnemônica, vou apresentar a você, no capítulo seguinte, a passphrase BIP39, pois ela desempenha um papel no processo de derivação, e está no mesmo nível que a frase mnemônica. ## A passphrase <chapterId>6a51b397-f3b5-5084-b151-cef94bc9b93f</chapterId> Como acabamos de ver, as carteiras HD são geradas a partir de uma frase mnemônica tipicamente consistindo de 12 ou 24 palavras. Esta frase é muito importante porque permite a restauração de todas as chaves de uma carteira em caso de perda do seu dispositivo físico (como uma carteira de hardware, por exemplo). No entanto, ela constitui um único ponto de falha, porque se for comprometida, um atacante poderia roubar todos os bitcoins. É aqui que a passphrase BIP39 entra em jogo. ### O que é uma passphrase BIP39? A passphrase é uma senha opcional, que você pode escolher livremente, que é adicionada à frase mnemônica no processo de derivação da chave para aumentar a segurança da carteira. Cuidado, a passphrase não deve ser confundida com o código PIN da sua carteira de hardware ou a senha usada para desbloquear o acesso à sua carteira no seu computador. Ao contrário de todos esses elementos, a passphrase desempenha um papel na derivação das chaves da sua carteira. **Isso significa que sem ela, você nunca será capaz de recuperar seus bitcoins.** A passphrase trabalha em conjunto com a frase mnemônica, modificando a semente da qual as chaves são geradas. Assim, mesmo que alguém obtenha sua frase de 12 ou 24 palavras, sem a passphrase, não podem acessar seus fundos. Usar uma passphrase essencialmente cria uma nova carteira com chaves distintas. Modificar (mesmo que levemente) a passphrase gerará uma carteira diferente. ![CYP201](/courses/cyp201/assets/fr/041.webp) ### Por que você deve usar uma passphrase? A passphrase é arbitrária e pode ser qualquer combinação de caracteres escolhida pelo usuário. Usar uma passphrase, portanto, oferece várias vantagens. Primeiramente, reduz todos os riscos associados ao comprometimento da frase mnemônica exigindo um segundo fator para acessar os fundos (roubo, acesso à sua casa, etc.). Em seguida, pode ser usada estrategicamente para criar uma carteira isca, para enfrentar restrições físicas para roubar seus fundos como o infame "_ataque da chave inglesa de $5_". Neste cenário, a ideia é ter uma carteira sem passphrase contendo apenas uma pequena quantidade de bitcoins, o suficiente para satisfazer um potencial agressor, enquanto se tem uma carteira oculta. Esta última usa a mesma frase mnemônica mas é protegida com uma passphrase adicional. Finalmente, o uso de uma passphrase é interessante quando se deseja controlar a aleatoriedade da geração da semente da carteira HD. ### Como escolher uma boa passphrase? Para que a passphrase seja eficaz, ela deve ser suficientemente longa e aleatória. Assim como uma senha forte, recomendo escolher uma passphrase que seja o mais longa e aleatória possível, com uma diversidade de letras, números e símbolos para tornar qualquer ataque de força bruta impossível. É também importante salvar corretamente essa passphrase, da mesma forma que a frase mnemônica. **Perdê-la significa perder o acesso aos seus bitcoins**. Eu aconselho fortemente contra tentar lembrá-la apenas de cor, pois isso aumenta de forma irrazoável o risco de perda. O ideal é anotá-la em um meio físico (papel ou metal) separado da frase mnemônica. Este backup deve, obviamente, ser armazenado em um local diferente de onde sua frase mnemônica está guardada para evitar que ambos sejam comprometidos simultaneamente. ![CYP201](/courses/cyp201/assets/fr/042.webp) Na seção seguinte, descobriremos como esses dois elementos na base da sua carteira — a frase mnemônica e a passphrase — são usados para derivar os pares de chaves usados no *scriptPubKey* que bloqueiam seus UTXOs. # Criação de Carteiras Bitcoin <partId>9c25e767-7eae-50b8-8c5f-679d8fc83bab</partId> ## Criação da Semente e Chave Mestra <chapterId>63093760-2010-5691-8d0e-9a04732ae557</chapterId> Uma vez que a frase mnemônica e a passphrase opcional são geradas, o processo de derivação de uma carteira Bitcoin HD pode começar. A frase mnemônica é primeiro convertida em uma semente que constitui a base de todas as chaves da carteira. ![CYP201](/courses/cyp201/assets/fr/043.webp) ### A Semente de uma Carteira HD O padrão BIP39 define a semente como uma sequência de 512 bits, que serve como ponto de partida para a derivação de todas as chaves de uma carteira HD. A semente é derivada da frase mnemônica e da possível passphrase usando o algoritmo **PBKDF2** (*Password-Based Key Derivation Function 2*) que já discutimos no capítulo 3.3. Nesta função de derivação, usaremos os seguintes parâmetros: - $m$ : a frase mnemônica; - $p$ : uma passphrase opcional escolhida pelo usuário para aumentar a segurança da semente. Se não houver passphrase, este campo é deixado em branco; - $\text{PBKDF2}$ : a função de derivação com $\text{HMAC-SHA512}$ e $2048$ iterações; - $s$: a semente da carteira de 512 bits. Independentemente do comprimento da frase mnemônica escolhida (132 bits ou 264 bits), a função PBKDF2 sempre produzirá uma saída de 512 bits, e a semente, portanto, sempre será deste tamanho. ### Esquema de Derivação da Semente com PBKDF2 A seguinte equação ilustra a derivação da semente a partir da frase mnemônica e da passphrase:$

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

 $![CYP201](/courses/cyp201/assets/fr/044.webp) O valor da semente é assim influenciado pelo valor da frase mnemônica e da passphrase. Ao mudar a passphrase, obtém-se uma semente diferente. No entanto, com a mesma frase mnemônica e passphrase, a mesma semente é sempre gerada, já que o PBKDF2 é uma função determinística. Isso garante que os mesmos pares de chaves possam ser recuperados através de nossos backups. **Nota:** No linguajar comum, o termo "semente" muitas vezes se refere, por uso indevido da linguagem, à frase mnemônica. De fato, na ausência de uma passphrase, uma é simplesmente a codificação da outra. No entanto, como vimos, na realidade técnica das carteiras, a semente e a frase mnemônica são de fato dois elementos distintos. Agora que temos nossa semente, podemos continuar com a derivação de nossa carteira Bitcoin. ### A Chave Mestra e o Código da Cadeia Mestra Uma vez obtida a semente, o próximo passo na derivação de uma carteira HD envolve o cálculo da chave privada mestra e do código da cadeia mestra, que representarão a profundidade 0 da nossa carteira. Para obter a chave privada mestra e o código da cadeia mestra, a função HMAC-SHA512 é aplicada à semente, usando uma chave fixa "*Bitcoin Seed*" idêntica para todos os usuários do Bitcoin. Esta constante é escolhida para garantir que as derivações de chave sejam específicas para o Bitcoin. Aqui estão os elementos: - $\text{HMAC-SHA512}$: a função de derivação; - $s$: a semente da carteira de 512 bits; - $\text{"Bitcoin Seed"}$: a constante de derivação comum para todas as carteiras Bitcoin.$

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

 $O resultado desta função é, portanto, de 512 bits. Ele é então dividido em 2 partes: - Os 256 bits à esquerda formam a **chave privada mestra**; - Os 256 bits à direita formam o **código da cadeia mestra**. Matematicamente, esses dois valores podem ser notados da seguinte forma, com $k_M$ sendo a chave privada mestra e $C_M$ o código da cadeia mestra:$

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)

 $Neste cálculo, observamos que nossa função HMAC recebe dois inputs: primeiro, o código de cadeia pai, e depois a concatenação do índice com a chave pública associada à chave privada pai. A chave pública pai é usada aqui porque estamos procurando derivar uma chave filho normal, não uma endurecida. Agora temos um $\text{hash}$ de 64 bytes que dividiremos em 2 partes de 32 bytes cada: $h_1$ e $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $A chave privada filho $k_{\text{CHD}}^n$ é então calculada da seguinte forma:$

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

 $Neste cálculo, a operação $\text{parse256}(h_1)$ consiste em interpretar os primeiros 32 bytes do $\text{hash}$ como um inteiro de 256 bits. Esse número é então adicionado à chave privada pai, tudo tomado modulo $n$ para permanecer dentro da ordem da curva elíptica, como vimos na seção 3 sobre assinaturas digitais. Assim, para derivar uma chave privada filha normal, embora a chave pública pai seja usada como base para cálculo nas entradas da função HMAC-SHA512, é sempre necessário ter a chave privada pai para finalizar o cálculo. A partir desta chave privada filha, é possível derivar a chave pública correspondente aplicando ECDSA ou Schnorr. Desta forma, obtemos um par completo de chaves. Então, a segunda parte do $\text{hash}$ é simplesmente interpretada como sendo o código de cadeia para o par de chaves filho que acabamos de derivar:$

C_{\text{CHD}} = h_2

 $Aqui está uma representação esquemática da derivação geral: ![CYP201](/courses/cyp201/assets/fr/050.webp) Para uma **chave filha endurecida** ($i \geq 2^{31}$), o cálculo do $\text{hash}$ é o seguinte:$

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

 $Neste cálculo, observamos que nossa função HMAC recebe dois inputs: primeiro, o código de cadeia pai, e depois a concatenação do índice com a chave privada pai. A chave privada pai é usada aqui porque estamos procurando derivar uma chave filha endurecida. Além disso, um byte igual a `0x00` é adicionado no início da chave. Esta operação iguala seu comprimento para corresponder ao de uma chave pública comprimida. Então, agora temos um $\text{hash}$ de 64 bytes que dividiremos em 2 partes de 32 bytes cada: $h_1$ e $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $A chave privada filha $k_{\text{CHD}}^h$ é então calculada da seguinte forma:$

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

 $Em seguida, simplesmente interpretamos a segunda parte do $\text{hash}$ como sendo o código de cadeia para o par de chaves filho que acabamos de derivar:$

C_{\text{CHD}} = h_2

 $Aqui está uma representação esquemática da derivação geral: ![CYP201](/courses/cyp201/assets/fr/051.webp) Podemos ver que a derivação normal e a derivação endurecida funcionam da mesma maneira, com esta diferença: a derivação normal usa a chave pública pai como entrada para a função HMAC, enquanto a derivação endurecida usa a chave privada pai. #### Derivando uma chave pública filha a partir de uma chave pública pai Se conhecemos apenas a chave pública pai $K_{\text{PAR}}$ e o código de cadeia associado $C_{\text{PAR}}$, isto é, uma chave pública estendida, é possível derivar chaves públicas filhas $K_{\text{CHD}}^n$, mas apenas para chaves filhas normais (não endurecidas). Este princípio permite notavelmente monitorar os movimentos de uma conta em uma carteira Bitcoin a partir do `xpub` (_somente visualização_). Para realizar este cálculo, vamos computar o $\text{hash}$ com um índice $i < 2^{31}$ (derivação normal):$

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

 $Neste cálculo, observamos que nossa função HMAC recebe dois inputs: primeiro o código de cadeia pai, depois a concatenação do índice com a chave pública pai. Então, agora temos um $hash$ de 64 bytes que vamos dividir em 2 partes de 32 bytes cada: $h_1$ e $h_2$:$

\text{hash} = h_1 \Vert h_2

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

 $A chave pública filha $K_{\text{CHD}}^n$ é então calculada da seguinte forma:$

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

 $Se $\text{parse256}(h_1) \geq n$ (ordem da curva elíptica) ou se $K_{\text{CHD}}^n$ é o ponto no infinito, a derivação é inválida, e outro índice deve ser escolhido. Neste cálculo, a operação $\text{parse256}(h_1)$ envolve interpretar os primeiros 32 bytes do $\text{hash}$ como um inteiro de 256 bits. Este número é usado para calcular um ponto na curva elíptica através da adição e duplicação a partir do ponto gerador $G$. Este ponto é então adicionado à chave pública pai para obter a chave pública filha normal. Assim, para derivar uma chave pública filha normal, apenas a chave pública pai e o código de cadeia pai são necessários; a chave privada pai nunca entra neste processo, ao contrário do cálculo da chave privada filha que vimos anteriormente. A seguir, o código de cadeia filha é simplesmente:$

C_{\text{CHD}} = h_2

 $Aqui está uma representação esquemática da derivação geral: ![CYP201](/courses/cyp201/assets/fr/052.webp) ### Correspondência entre chaves públicas e privadas filhas Uma questão que pode surgir é como uma chave pública filha normal derivada de uma chave pública pai pode corresponder a uma chave privada filha normal derivada da chave privada pai correspondente. Este link é precisamente garantido pelas propriedades das curvas elípticas. De fato, para derivar uma chave pública filha normal, o HMAC-SHA512 é aplicado da mesma maneira, mas seu output é usado de forma diferente: - **Chave privada filha normal**: $k_{\text{CHD}}^n = \text{parse256}(h_1) + k_{\text{PAR}} \mod n$ - **Chave pública filha normal**: $K_{\text{CHD}}^n = G \cdot \text{parse256}(h_1) + K_{\text{PAR}}$ Graças às operações de adição e duplicação na curva elíptica, ambos os métodos produzem resultados consistentes: a chave pública derivada da chave privada filha é idêntica à chave pública filha derivada diretamente da chave pública pai. ### Resumo dos tipos de derivação Para resumir, aqui estão os diferentes tipos possíveis de derivações:$

\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}

 $Para resumir, até agora você aprendeu a criar os elementos básicos da carteira HD: a frase mnemônica, a semente e, então, a chave mestra e o código da cadeia mestre. Você também descobriu como derivar pares de chaves filhas neste capítulo. No próximo capítulo, exploraremos como essas derivações são organizadas em carteiras Bitcoin e qual estrutura seguir para obter concretamente os endereços de recebimento, bem como os pares de chaves usados no _scriptPubKey_ e _scriptSig_. ## Estrutura da Carteira e Caminhos de Derivação <chapterId>34e1bbda-67de-5493-b268-1fded8d67689</chapterId> A estrutura hierárquica das carteiras HD no Bitcoin permite a organização de pares de chaves de várias maneiras. A ideia é derivar, a partir da chave privada mestre e do código da cadeia mestre, vários níveis de profundidade. Cada nível adicionado corresponde à derivação de um par de chaves filha de um par de chaves pai. Com o tempo, diferentes BIPs introduziram padrões para esses caminhos de derivação, visando padronizar seu uso em diferentes softwares. Então, neste capítulo, descobriremos o significado de cada nível de derivação em carteiras HD, de acordo com esses padrões. ### As Profundidades de Derivação de uma Carteira HD Os caminhos de derivação são organizados em camadas de profundidade, variando da profundidade 0, que representa a chave mestre e o código da cadeia mestre, até camadas de subníveis para derivar endereços usados para bloquear UTXOs. Os BIPs (_Propostas de Melhoria do Bitcoin_) definem os padrões para cada camada, o que ajuda a harmonizar práticas em diferentes softwares de gestão de carteiras. Um caminho de derivação, portanto, refere-se à sequência de índices usados para derivar chaves filhas de uma chave mestre. **Profundidade 0: Chave Mestre (BIP32)** Esta profundidade corresponde à chave privada mestre da carteira e ao código da cadeia mestre. É representada pela notação $m/$. **Profundidade 1: Propósito (BIP43)** O objetivo determina a estrutura lógica de derivação. Por exemplo, um endereço P2WPKH terá $/84'/$ na profundidade 1 (de acordo com o BIP84), enquanto um endereço P2TR terá $/86'/$ (de acordo com o BIP86). Esta camada facilita a compatibilidade entre carteiras ao indicar números de índice correspondentes aos números BIP. Em outras palavras, uma vez que você tenha a chave mestra e o código da cadeia mestre, estes servem como um par de chaves pai para derivar um par de chaves filho. O índice usado nesta derivação pode ser, por exemplo, $/84'/$ se a carteira for destinada a usar scripts do tipo SegWit v0. Este par de chaves está então na profundidade 1. Seu papel não é bloquear bitcoins, mas simplesmente servir como um ponto de passagem na hierarquia de derivação. **Profundidade 2: Tipo de Moeda (BIP44)** A partir do par de chaves na profundidade 1, uma nova derivação é realizada para obter o par de chaves na profundidade 2. Esta profundidade permite diferenciar contas Bitcoin de outras criptomoedas dentro da mesma carteira. Cada moeda tem um índice único para garantir a compatibilidade entre carteiras multi-moedas. Por exemplo, para Bitcoin, o índice é $/0'/$ (ou `0x80000000` em notação hexadecimal). Índices de moedas são escolhidos na faixa de $2^{31}$ a $2^{32}-1$ para garantir derivação reforçada. Para dar outros exemplos, aqui estão os índices de algumas moedas: - $1'$ (`0x80000001`) para bitcoins de testnet; - $2'$ (`0x80000002`) para Litecoin; - $60'$ (`0x8000003c`) para Ethereum... **Profundidade 3: Conta (BIP32)** Cada carteira pode ser dividida em várias contas, numeradas a partir de $2^{31}$, e representadas na profundidade 3 por $/0'/$ para a primeira conta, $/1'/$ para a segunda, e assim por diante. Geralmente, quando se refere a uma chave estendida `xpub`, refere-se a chaves nesta profundidade de derivação. Esta separação em diferentes contas é opcional. Tem como objetivo simplificar a organização da carteira para os usuários. Na prática, muitas vezes apenas uma conta é usada, geralmente a primeira por padrão. No entanto, em alguns casos, se deseja claramente distinguir pares de chaves para diferentes usos, isso pode ser útil. Por exemplo, é possível criar uma conta pessoal e uma conta profissional a partir da mesma semente, com grupos completamente distintos de chaves a partir desta profundidade de derivação. **Profundidade 4: Cadeia (BIP32)** Cada conta definida na profundidade 3 é então estruturada em duas cadeias: - **A cadeia externa**: Nesta cadeia, o que são conhecidos como endereços "públicos" são derivados. Estes endereços de recebimento são destinados a bloquear UTXOs provenientes de transações externas (ou seja, originadas do consumo de UTXOs que não pertencem a você). Simplificando, esta cadeia externa é usada sempre que se deseja receber bitcoins. Quando você clica em "_receber_" no software da sua carteira, é sempre um endereço da cadeia externa que é oferecido a você. Esta cadeia é representada por um par de chaves derivado com o índice $/0/$. - **A cadeia interna (troco)**: Esta cadeia é reservada para endereços de recebimento que bloqueiam bitcoins provenientes do consumo de UTXOs que pertencem a você, em outras palavras, endereços de troco. É identificada pelo índice $/1/$. **Profundidade 5: Índice de Endereço (BIP32)** Finalmente, a profundidade 5 representa o último passo da derivação na carteira. Embora seja tecnicamente possível continuar indefinidamente, os padrões atuais param aqui. Nesta profundidade final, os pares de chaves que serão realmente usados para bloquear e desbloquear os UTXOs são derivados. Cada índice permite distinguir entre pares de chaves irmãs: assim, o primeiro endereço de recebimento usará o índice $/0/$, o segundo o índice $/1/$, e assim por diante. ![CYP201](/courses/cyp201/assets/fr/053.webp) ### Notação dos Caminhos de Derivação O caminho de derivação é escrito separando cada nível com uma barra ($/$). Cada barra indica, assim, uma derivação de um par de chaves pai ($k_{\text{PAR}}$, $K_{\text{PAR}}$, $C_{\text{PAR}}$) para um par de chaves filho ($k_{\text{CHD}}$, $K_{\text{CHD}}$, $C_{\text{CHD}}$). O número anotado em cada profundidade corresponde ao índice usado para derivar esta chave de seus pais. O apóstrofo ($'$) às vezes colocado à direita do índice indica uma derivação endurecida ($k_{\text{CHD}}^h$, $K_{\text{CHD}}^h$). Às vezes, este apóstrofo é substituído por um $h$. Na ausência de um apóstrofo ou $h$, trata-se, portanto, de uma derivação normal ($k_{\text{CHD}}^n$, $K_{\text{CHD}}^n$). Como vimos nos capítulos anteriores, os índices de chaves endurecidas começam de $2^{31}$, ou `0x80000000` em hexadecimal. Portanto, quando um índice é seguido por um apóstrofo em um caminho de derivação, $2^{31}$ deve ser adicionado ao número indicado para obter o valor real usado na função HMAC-SHA512. Por exemplo, se o caminho de derivação especifica $/44'/$, o índice real será:$

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

 $Em hexadecimal, isso é `0x8000002C`. Agora que entendemos os princípios principais dos caminhos de derivação, vamos tomar um exemplo! Aqui está o caminho de derivação para um endereço de recebimento Bitcoin:$

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

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

 $Primeiro, passamos a chave por SHA256: ```txt SHA256(K) = C489EBD66E4103B3C4B5EAFF462B92F5847CA2DCE0825F4997C7CF57DF35BF3A ``` Em seguida, passamos o resultado por RIPEMD160: ```txt RIPEMD160(SHA256(K)) = 9F81322CC88622CA4CCB2A52A21E2888727AA535 ``` Obtivemos um hash de 160 bits da chave pública, que constitui o que é chamado de payload do endereço. Este payload representa a parte central e mais importante do endereço. Ele também é usado no _scriptPubKey_ para bloquear os UTXOs. No entanto, para tornar este payload mais facilmente utilizável por humanos, metadados são adicionados a ele. O próximo passo envolve codificar este hash em grupos de 5 bits em decimal. Esta transformação decimal será útil para conversão em _bech32_, usado por endereços pós-SegWit. O hash binário de 160 bits é, assim, dividido em 32 grupos de 5 bits:$

\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

 $Onde $G$ é o gerador da curva elíptica usada. Esta operação produz uma nova chave pública derivada da chave original, mantendo propriedades criptográficas que permitem seu uso. Se você não precisa adicionar scripts alternativos (gastando exclusivamente através do _caminho da chave_), você pode gerar um endereço Taproot baseado unicamente na chave pública presente no nível 5 da sua carteira. Neste caso, é necessário criar um script não gastável para o _caminho do script_, a fim de satisfazer os requisitos da estrutura. O ajuste $t$ é então calculado aplicando uma função de hash etiquetada, **`TapTweak`**, na chave pública interna $P$:$

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

 $onde: - **$\text{H}_{\text{TapTweak}}$** é uma função de hash SHA256 etiquetada com a tag `TapTweak`. Se você não está familiarizado com o que é uma função de hash etiquetada, convido você a consultar o capítulo 3.3; - $P$ é a chave pública interna, representada em seu formato comprimido de 256 bits, usando apenas a coordenada $x$. A chave pública Taproot $Q$ é então calculada adicionando o ajuste $t$, multiplicado pelo gerador da curva elíptica $G$, à chave pública interna $P$:$

Q = P + t \cdot G

 $Uma vez que a chave pública Taproot $Q$ é obtida, podemos gerar o endereço de recebimento correspondente. Diferentemente de outros formatos, os endereços Taproot não são estabelecidos em um hash da chave pública. Portanto, a chave $Q$ é inserida diretamente no endereço, de maneira bruta. Para começar, extraímos a coordenada $x$ do ponto $Q$ para obter uma chave pública comprimida. Neste payload, um checksum é calculado usando códigos BCH, como com endereços SegWit v0. No entanto, o programa usado para endereços Taproot difere ligeiramente. De fato, após a introdução do formato _bech32_ com SegWit, um bug foi descoberto: quando o último caractere de um endereço é um `p`, inserir ou remover `q`s logo antes deste `p` não torna o checksum inválido. Embora este bug não tenha consequências no SegWit v0 (graças a uma restrição de tamanho), ele poderia representar um problema no futuro. Este bug foi, portanto, corrigido para endereços Taproot, e o novo formato corrigido é chamado "_bech32m_". O endereço Taproot é gerado codificando a coordenada $x$ de $Q$ no formato _bech32m_, com os seguintes elementos: - **O HRP (_Human Readable Part_)**: `bc`, para indicar a rede principal do Bitcoin; - **A versão**: `1` para indicar Taproot / SegWit v1; - **O checksum**. O endereço final terá, portanto, o formato: ``` bc1p[Qx][checksum] ``` Por outro lado, se você deseja adicionar scripts alternativos além de gastar com a chave pública interna (_caminho do script_), o cálculo do endereço de recebimento será ligeiramente diferente. Você precisará incluir o hash dos scripts alternativos no cálculo do ajuste. No Taproot, cada script alternativo, localizado no final da árvore de Merkle, é chamado de "folha". Uma vez que os diferentes scripts alternativos são escritos, você deve passá-los individualmente por uma função de hash etiquetada `TapLeaf`, acompanhada de alguns metadados:$

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

 $Com: - $v$: o número da versão do script (padrão `0xC0` para Taproot); - $sz$: o tamanho do script codificado no formato _CompactSize_; - $S$: o script. Os diferentes hashes de script ($\text{h}_{\text{leaf}}$) são primeiramente ordenados em ordem lexicográfica. Em seguida, eles são concatenados em pares e passados através de uma função de hash etiquetada `TapBranch`. Esse processo é repetido iterativamente para construir, passo a passo, a árvore de Merkle:$

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

 $Continuamos então concatenando os resultados dois a dois, passando-os a cada etapa pela função de hash etiquetada `TapBranch`, até obtermos a raiz da árvore de Merkle: ![CYP201](/courses/cyp201/assets/fr/066.webp) Uma vez calculada a raiz de Merkle $h_{\text{root}}$, podemos calcular o tweak. Para isso, concatenamos a chave pública interna da carteira $P$ com a raiz $h_{\text{root}}$ e passamos o resultado pela função hash marcada `TapTweak`:$

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

 $Finalmente, como antes, a chave pública Taproot $Q$ é obtida somando a chave pública interna $P$ ao produto do tweak $t$ pelo ponto gerador $G$:$

Q = P + t \cdot G

 $A geração do endereço segue então o mesmo processo, utilizando a chave pública bruta $Q$ como carga útil, juntamente com alguns metadados adicionais. E é isso! Chegamos ao fim deste curso CYP201. Se você achou este curso útil, ficaria muito grato se você pudesse dedicar alguns momentos para dar uma boa avaliação no capítulo de avaliação a seguir. Sinta-se livre também para compartilhá-lo com seus entes queridos ou em suas redes sociais. Finalmente, se você deseja obter seu diploma para este curso, você pode fazer o exame final logo após o capítulo de avaliação. # Seção final <partId>58111408-b734-54db-9ea7-0d5b67f99f99</partId> ## Avaliações & Notas <chapterId>0cd71541-a7fd-53db-b66a-8611b6a28b04</chapterId> <isCourseReview>true</isCourseReview> ## Exame final <chapterId>a53ea27d-0f84-56cd-b37c-a66210a4b31d</chapterId> <isCourseExam>true</isCourseExam> ## Conclusão <chapterId>d291428b-3cfa-5394-930e-4b514be82d5a</chapterId> <isCourseConclusion>true</isCourseConclusion>$