Voltar aos artigos

O Ataque da ColdCard e como se proteger

Como uma única linha de pré-processador fez a ColdCard gerar chaves com 40 bits de entropia em vez de 128, e as três defesas contra esse tipo de ataque: passphrase, entropia gerada na mão e multisig com fabricantes diferentes.

Capa do artigo O Ataque da ColdCard e como se proteger

Introdução

Então atacaram a ColdCard? A hardwallet mais segura de todas, o padrão de ouro, a queridinha dos bitcoiners.

Mas como é possível? O aparelho chega na sua casa dentro de uma embalagem lacrada à prova de violação, com um número único impresso - gravado dentro do dispositivo lá na fábrica da CoinKite, na primeira vez que você liga, ele te manda conferir se os dois batem. O case da wallet é transparente, dá pra bater o olho diretamente na placa. No boot, o bootloader se recusa a rodar qualquer firmware que não esteja assinado pela CoinKite. Mas se ainda assim não quiser confiar, pode compilar o firmware e instalar você mesmo antes de usar a hardwallet. A luzinha de "genuíno" que acende ali não é acesa por software - quem controla ela é um circuito ligado direto no elemento seguro. Um chip feito pra que aquilo que você grava lá dentro não saia nunca mais - nem por software, nem por quem abre o aparelho e vai atrás dos bits com equipamento de laboratório. Não é como um dispositivo com memória comum, onde os dados podem ser extraídos do hardware. Elemento seguro é construído exatamente pra que isso não seja possível.

E na ColdCard são dois, de fabricantes diferentes, com a sua chave criptografada lá dentro de um jeito que nenhum dos chips sozinho consegue abrir. Errou o PIN? As tentativas são contadas em hardware.

Todas essas camadas protegem a sua chave depois que ela já existe. Interceptaram o pacote no correio, roubaram o aparelho da sua gaveta, tentaram trocar o firmware - pra tudo isso tem proteção. Mas o problema aconteceu no momento da geração da chave: com esse aparato todo intacto, da embalagem lacrada aos elementos seguros, a chave já nascia fraca. E contra chave fraca não tem camada pra furar.

No vídeo de hoje vamos entender qual foi a falha que possibilitou o ataque - olhando diretamente no código-fonte do firmware. Vamos entender:

  • Porque entropia é essencial pra proteger seus bitcoins
  • Porque um computador é, por definição, incapaz de sortear um número verdadeiramente aleatório
  • Como uma única linha de pré-processador transformou 128 bits de segurança em 40
  • O que poderia e deveria ter sido feito pela CoinKite pra evitar esse problema

Contra um ataque desse tipo existem três defesas, e a gente vai passar por cada uma delas:

  • Usar uma passphrase BIP-39, a tal "13ª palavra"
  • Gerar a sua própria entropia, na mão - assim a sua semente não depende do gerador de fabricante nenhum
  • Montar um multisig com dispositivos de fabricantes diferentes - pra que um fabricante errando feio não derrube o seu setup inteiro

Um disclaimer importante, esse não é mais um vídeo boring de tutorial explicando pela milionésima vez como montar uma carteira com passphrase ou como montar um setup multisig. Esse canal é sobre programação, e esse é um vídeo técnico, vou explicar boa parte de como o Bitcoin funciona pra conseguir explicar o ataque de forma clara e te mostrar como poderia ter sido evitado. Dito isso, bora pro vídeo.

Onde os seus bitcoins realmente moram

A primeira pergunta que surge é: mas como é que atacaram uma carteira que fica o tempo todo offline? Pra responder isso a gente precisa entender qual é o real papel de uma carteira de bitcoin. E por mais contraditório que possa parecer, não é guardar bitcoins.

Sim, carteira é um nome infeliz. Bitcoin não mora dentro de carteira nenhuma. O que existe é uma cadeia de transações replicada em milhares de nodos espalhados pelo mundo inteiro, e aquilo que você chama de "saldo" é só um conjunto de saídas de transações anteriores que ainda não foram gastas - as UTXOs, unspent transaction outputs.

Uma transação de Bitcoin não é transferir saldo de uma conta pra outra, como acontece no seu banco. Não existe conta. Não existe saldo guardado em campo nenhum. Uma transação consome saídas de transações anteriores e cria saídas novas. Não existe nada além disso.

A estrutura de uma transação

A estrutura de uma transação não é nada muito complicado. Abre com 4 bytes de versão. Vem um contador de entradas, e depois as entradas. Cada entrada tem quatro campos: o hash da transação anterior, que são 32 bytes; o índice da saída lá dentro dela, mais 4 bytes; o script de desbloqueio, com o tamanho dele na frente; e um campo de sequência, outros 4 bytes. Acabaram as entradas, vem um contador de saídas e as saídas. Cada saída tem apenas dois campos: o valor, 8 bytes contados em satoshis, e o script de bloqueio, também com o tamanho na frente. No fim, 4 bytes de locktime. E acabou. É isso que trafega pela rede quando você manda bitcoin pra alguém.

  version           4 bytes
  input_count       varint
    input[i]:
      txid          32 bytes   <- hash da transação anterior
      vout          4 bytes    <- índice da saída dentro dela
      scriptSig     tamanho + bytes
      sequence      4 bytes
  output_count      varint
    output[i]:
      value         8 bytes    <- em satoshis, little-endian
      scriptPubKey  tamanho + bytes
  locktime          4 bytes

O conceito de entradas e saídas pode confundir bastante, bora ver um exemplo de uma transação pra entender o que são as entradas e saídas na prática. Bob precisa realizar um pagamento de 0,1 btc pra Alice. Os bitcoins em posse de Bob estão trancados em saídas que ele consegue desbloquear. Bob cria uma transação com uma entrada apontando pra uma saída que contenha o valor a ser pago pra Alice, ou múltiplas entradas caso nenhuma saída sozinha tenha o valor a ser pago. Qualquer valor excedente é troco, isso entra como uma nova saída controlada por Bob, que pode vir a ser utilizada em transações futuras. A partir do momento em que essa transação for transmitida pra rede e minerada em um novo bloco, Alice será capaz de criar uma transação pra desbloquear o valor pago por Bob.

Diagrama de uma transação que consome as saídas UTXO A e UTXO B e cria saídas para Alice e Bob UTXO A UTXO B tx Alice Bob vin[0] vin[1] 0,1 BTC troco

Figura 1: Bob paga 0,1 BTC para Alice com duas entradas e recebe o troco

Em lugar nenhum dessa estrutura aparece a taxa. Ela é implícita - soma-se o valor de todas as saídas que as entradas apontam, aí subtrai a soma das saídas novas, a diferença é a taxa, que fica pro minerador como recompensa pela mineração do bloco.

O script

A saída contém o valor e um script de bloqueio - o campo scriptPubKey. Esse script é nada mais que um programa. Escrito em Script, a linguagem do próprio Bitcoin: baseada em pilha, estilo Forth, sem laços, sem recursão, deliberadamente não Turing-completa. E isso não é preguiça de quem projetou, é requisito: esse programa vai rodar em cada nodo da rede, pra sempre, toda vez que alguém revalidar a cadeia. Ninguém quer um laço infinito dentro da regra de consenso.

Pra gastar uma saída, a entrada da nova transação precisa fornecer o script de desbloqueio - o campo scriptSig - com os dados que fazem o script de bloqueio terminar com um valor verdadeiro no topo da pilha. Os dois rodam em sequência: executa primeiro o script de desbloqueio, a pilha que sobrou dele é entregue pra execução do script de bloqueio.

Um exemplo mínimo.

Vamos pro menor exemplo possível: um bloqueio que libera o dinheiro pra quem apresentar um número que, somado a 1, dá 42. Ou seja, quem calcular esse número pode gastar aquela saída.

Pra entender esse exemplo precisamos conhecer o básico da linguagem Script. Em termos gerais, é uma linguagem pra manipular uma pilha, pilha é uma estrutura de dados LIFO (Last In, First Out) - o último a entrar é o primeiro a sair. É exatamente como uma pilha funciona no mundo real, quando você empilha um conjunto de objetos um sobre o outro, se quiser remover algo sem desfazer a pilha, é sempre o último. As operações básicas são:

  • push pra empilhar um elemento
  • pop pra remover o elemento do topo, ou seja, desempilhar
  • top pra consultar o elemento do topo sem desempilhar
  • size pra consultar quantos elementos a pilha tem

Na linguagem Script essas operações são feitas por meio de operadores, por exemplo:

  • OP_ seguido de um número, ou apenas o número diretamente, faz push do número na pilha
  • OP_ADD desempilha dois elementos, faz a soma, e empilha de volta o resultado
  • OP_EQUAL desempilha dois elementos, faz a comparação de igualdade, e empilha 1 se verdadeiro, 0 se falso

Com apenas esses 3 operadores já é possível resolver o exemplo. Aqui vamos usar apenas números, mas a linguagem Script permite manipular quaisquer dados representáveis por bytes: podem ser números, hashes, chaves públicas, qualquer coisa.

Aqui, o script de bloqueio deve esperar um número que somado a 1 resulte em 42:

  OP_1 OP_ADD 42 OP_EQUAL

A execução começa da esquerda pra direita, mas o programa está incompleto, vai empilhar 1, e o OP_ADD não vai ter 2 elementos pra desempilhar, terminando a execução em erro. Isso se dá porque estamos executando apenas o script de bloqueio - precisamos executar primeiro o de desbloqueio. Já sabemos que o número que somado a 1 resulta em 42 é 41, então o script completo fica 41 OP_1 OP_ADD 42 OP_EQUAL. Agora sim, empilhamos 41, depois 1, agora o operador OP_ADD tem 2 elementos para desempilhar, a soma é 42, empilhamos o resultado, logo na sequência empilhamos o 42 do script de bloqueio, e por fim chegamos ao operador OP_EQUAL, desempilhamos os dois 42. O resultado da comparação é verdadeiro, empilhamos 1, término do programa com 1 no topo da pilha significa que o script executou com sucesso.

Isso significa que pra poder gastar essa saída basta ser capaz de informar 41 pra desbloquear o script. Não tem identidade envolvida. A rede não sabe quem você é, não tem cadastro, não tem login, não tem recuperação de senha. Cada nodo da rede pega os bytes que você apresentou, roda o programa, e olha o topo da pilha. Só isso. Na prática, um script solto desse formato hoje é considerado não-padrão - os nodos nem repassam a transação que cria uma saída dessas - e se uma saída assim estivesse na cadeia, o primeiro bot que lesse o script levava o dinheiro em segundos. Mas o mecanismo é exatamente esse.

Agora o script mais comum de todos. A esmagadora maioria das saídas do Bitcoin usa uma variação de um único problema: apresente uma assinatura que só poderia ter sido produzida por quem conhece a chave privada desta chave pública, o P2PKH - pay to public key hash. Na forma clássica o script de bloqueio são cinco elementos: OP_DUP, OP_HASH160, os 20 bytes do hash de uma chave pública, OP_EQUALVERIFY e OP_CHECKSIG. E o de desbloqueio são dois: uma assinatura e uma chave pública.

  bloqueio:      OP_DUP OP_HASH160 <hash_da_pubkey> OP_EQUALVERIFY OP_CHECKSIG
  desbloqueio:   <assinatura> <pubkey>

Aqui temos novos operadores da linguagem Script:

  • OP_DUP duplica o valor do topo da pilha, faz isso com uma operação pop pra obter o valor do topo da pilha, seguido de duas operações push do valor obtido
  • OP_HASH160 desempilha um elemento, e empilha o hash de 160 bits desse elemento
  • OP_EQUALVERIFY faz o mesmo que OP_EQUAL seguido de OP_VERIFY que verifica se o topo da pilha é true, caso não seja o programa termina com falha
  • OP_CHECKSIG desempilha 2 elementos, a chave pública e a assinatura, verifica que a assinatura fornecida é válida pro hash daquela transação e pra chave pública fornecida no script

Esse script vai empilhar a assinatura e a chave pública do script de desbloqueio. Aí duplica a chave pública e gera o hash dela. Empilha o hash do script de bloqueio. Desempilha os 2 hashes e compara. Diferentes? Aborta a execução, transação inválida, fim de papo. Caso sejam iguais, continua, agora sobraram na pilha a assinatura e a chave pública, exatamente o que o OP_CHECKSIG precisa pra verificar se a assinatura é válida.

Esse script requer uma assinatura digital e uma chave pública, ambas dependem da geração de uma chave privada, justamente o processo que gerou todo o problema da ColdCard. Mas afinal o que é uma chave privada? Um número grande. Um inteiro de 256 bits. A chave pública é derivada desse número por uma operação da curva secp256k1 que tem uma propriedade crucial pra segurança: é fácil num sentido e inviável no outro. Da chave privada pra chave pública é trivial. Da chave pública de volta pra chave privada, impossível de fazer com o modelo de computação que temos hoje. E é essa assimetria que sustenta o resto: assinar exige a chave privada, verificar exige só a pública - e a assinatura prova que você conhecia a privada sem nunca precisar revelar ela pra ninguém.

Isso significa que a sua chave privada não é emitida por ninguém. Não tem cadastro, não tem servidor, não tem "criação de conta". Gerar uma chave privada é sortear um número de 256 bits. Ponto final. É exatamente por isso que uma carteira consegue funcionar 100% offline - e foi exatamente aqui que a ColdCard falhou.

Hoje a maior parte das saídas não usa mais o P2PKH que a gente acabou de ver. Os formatos de script evoluíram bastante desde então, cada mudança resolveu problemas reais de tamanho, custo e privacidade. Mas a estrutura permanece a mesma: um script de bloqueio na saída, um script de desbloqueio na entrada, e uma assinatura válida como condição pra destravar o valor.

A partir disso você pode criar uma transação, assinar, e transmitir pra um nodo qualquer. Esse nodo valida sozinho: confere se as entradas apontam pra saídas que existem e que ainda não foram gastas, e executa cada script exatamente do jeito que acabamos de ver. Executou com sucesso? A transação entra na mempool desse nodo e é repassada pros nodos conectados a ele. Os mineradores pegam transações da mempool, montam um bloco candidato, e ficam variando um campo do cabeçalho até o hash desse cabeçalho cair abaixo de um alvo numérico. Não tem atalho - a única estratégia conhecida é tentar. É a proof-of-work: um bloco custa caro pra produzir e é instantâneo de verificar. Achou, propaga. E aí todo full node da rede revalida tudo de novo, por conta própria, incluindo o seu script.

Ou seja: ninguém precisa confiar em você, ninguém precisa te conhecer, ninguém precisa nem saber que você existe. Gastar um bitcoin é satisfazer o script de bloqueio da saída que você quer gastar. Não é "ser o dono", não é "estar autenticado" - é fazer aquele programa devolver verdadeiro. No caso mais comum de todos, o singlesig, satisfazer esse programa quer dizer exatamente uma coisa: produzir uma assinatura válida, o que depende exclusivamente de conhecer a chave privada. Se você quer ser o dono de seus bitcoins, ter propriedade sobre eles, a única forma é gerar uma chave forte e mantê-la segura.

E é por isso que se sua chave privada é fraca, o atacante não precisa invadir a sua ColdCard pra te atacar. Não precisa de rede, não precisa furar elemento seguro nenhum, não precisa nem saber que você existe. Ele precisa satisfazer o script de bloqueio que protege as suas saídas - e enquanto esse script for o singlesig, isso quer dizer uma coisa só: a sua chave privada.

O atacante chuta um número, deriva a chave pública, calcula o hash, monta os endereços iniciais, consulta uma blockchain que é pública e está aberta pra qualquer um ver. Tem saldo? Assina e leva. Tudo isso roda na máquina dele, offline em relação a você, no ritmo que a GPU dele aguentar. Não tem PIN, não tem "três tentativas e bloqueia", não tem atraso exponencial, não tem nada disso - porque nada disso mora na blockchain. Mora no seu dispositivo, e nesse caso o dispositivo não está no caminho.

Antes que isso soe como se qualquer um pudesse sacar bitcoin dos outros chutando número: não pode. Esse chute só tem chance se o espaço de busca for pequeno. Uma chave que nasceu com 128 bits de entropia, deixa o atacante com 2^128 candidatos pela frente - um número de 39 dígitos. Pra ter noção do tamanho disso: pega todos os grãos de areia de todas as praias do planeta - que é algo na casa dos sete quintilhões - agora imagina que cada grãozinho desses é um computador testando um bilhão de chaves por segundo. Todos eles juntos, em paralelo, ainda levariam mais de mil anos pra varrer 2^128 possibilidades. E olha que derivar uma chave pública custa muito mais do que testar um palpite qualquer, então na prática seria ainda pior pro atacante. Não existe força bruta contra entropia de verdade - não tem GPU, não tem cluster, não tem orçamento estatal que dê conta.

A única coisa que separa esse atacante dos seus bitcoins é quantos números ele teria que testar, a magnitude desse número depende da entropia da sua chave. Estar offline protege contra uma classe inteira de ataques - malware, exfiltração de dados, comando remoto. Mas não protege contra uma chave que já nasceu fraca.

Entropia: por que um computador não sabe sortear

Joga uma moeda pro alto. Enquanto está no ar existem dois resultados possíveis, e não tem como você saber qual vai sair. O tamanho dessa incerteza é 1 bit. No vídeo sobre por que computadores só entendem 0s e 1s a gente viu que um bit é a menor unidade de informação que existe, uma escolha entre duas alternativas - é exatamente isso aqui: cara ou coroa.

Agora joga duas moedas. Os resultados possíveis viram quatro, a incerteza vira 2 bits - uma escolha pra cada moeda. Três moedas, oito resultados, 3 bits. Cada bit novo dobra a quantidade de resultados possíveis. Com 8 bits são 256 resultados, 1 byte. Com 128 bits são 2^128 resultados.

k bits de entropia representam 2^k candidatos possíveis. Cada bit a mais dobra o trabalho pro atacante, cada bit a menos corta pela metade. É por isso que uma semente com 40 bits em vez de 128 não é uma diferença de três vezes - é uma diferença de 2^88 vezes. É isso que separa "inviável até o fim do universo" de "roda num fim de semana".

Moeda gera um bit por lançamento, podemos otimizar isso com dados. A matemática aqui é simples, pra um dado de seis lados qual é o x da fórmula 2^x = 6? Basta aplicar log2 no lado direito. Ou seja, cada rolagem de um dado de seis lados resulta em 2,585 bits de entropia. Mas não é tão simples assim, isso só vale se os seis lados do dado forem igualmente prováveis, e dado nenhum é perfeito. Pega aquele dadinho de plástico que vem junto com jogo de tabuleiro. É moldado, tem os cantos arredondados, os pontinhos dele são furos cavados na superfície e depois pintados. Pensa o que acontece com a face do número 6: são seis furos, seis pedacinhos de material a menos, aquela face é a mais leve do dado, como consequência tende a parar virada pra cima. O dado é viciado.

Cálculo de x em 2 elevado a x igual a 6, que dá cerca de 2,585 bits por rolagem 2x = 6 log2(2x) = log2(6) x = log2(6) x ≈ 2,585 bits / rolagem

Figura 2: Quantos bits de entropia cabem numa rolagem de dado

Aí cada rolagem entrega menos entropia do que a conta promete. Você acha que juntou 128 bits em 50 rolagens, e juntou bem menos. A diferença toda vai pro bolso do atacante, ele não vai testar possibilidades em ordem aleatória - vai começar pelas mais prováveis. Seu dado puxa pro 6? Ele testa primeiro as sequências cheias de 6.

O dado correto pra isso é o de cassino. É usinado com tolerância minúscula e tem os cantos vivos, não arredondados. Os pontos não são furos: são preenchidos com material da mesma densidade do corpo do dado, então as faces ficam lisas e o peso fica distribuído igualmente. Não é frescura de cassino - é o único jeito de garantir que os seis lados são mesmo equivalentes. E o jeito de rolar também conta: joga com força numa superfície dura e deixa o dado rolar por aí, em vez de largar o dado de dois centímetros de altura sempre do mesmo jeito. Repetir exatamente o mesmo gesto é repetir o mesmo processo físico.

"Mas isso é coisa de paranoico, estamos em 2026, por que não gerar esses números com o auxílio de um computador ao invés de ter todo esse trabalho?" Acontece que um computador é uma máquina determinística. Essa é a definição dele: uma máquina de estados finita onde, dado o mesmo estado inicial e a mesma entrada, a saída é sempre exatamente a mesma. Se não fosse assim, você não conseguiria nem compilar um programa duas vezes e obter o mesmo binário. Determinismo não é defeito do computador. É design.

E é exatamente por isso que um computador, sozinho, não consegue produzir um número aleatório. Von Neumann colocou isso da forma mais elegante possível em um simpósio, publicado em forma de artigo em 1951 na coletânea Monte Carlo Method do National Bureau of Standards americano com o título: Various Techniques Used in Connection with Random Digits. Nesse artigo Von Neumann apresenta o método do meio-do-quadrado para a geração de números pseudo-aleatórios, logo na primeira página ele diz: "qualquer um que considere métodos aritméticos de produzir dígitos aleatórios está, obviamente, em estado de pecado".

Knuth dedica o capítulo 3 inteiro do segundo volume do The Art of Computer Programming - o Seminumerical Algorithms - a números aleatórios. Abre a seção 3.1 com uma história maravilhosa: ele tentou escrever o gerador mais aleatório possível, um algoritmo que fazia escolhas malucas e imprevisíveis a cada passo. O gerador convergiu rapidinho pro número 6065038420 e ficou repetindo ele pra sempre. A lição que ele tira é que números aleatórios não devem ser gerados por um método escolhido aleatoriamente. É preciso alguma teoria.

O que um computador consegue fazer é gerar números pseudo-aleatórios. Um PRNG - pseudorandom number generator - é uma função que mantém um estado interno e, a cada chamada, embaralha esse estado e devolve um pedaço dele. A sequência produzida parece aleatória: passa em testes estatísticos, tem boa distribuição, não tem padrão visível. Mas ela é 100% determinada pelo estado inicial: a semente. Mesma semente, mesma sequência. Sempre.

A saída de um algoritmo determinístico não pode ter mais entropia do que a entrada dele. Se a semente tem 40 bits de entropia, a sequência inteira tem 40 bits. Não importa se você gera 32 bytes, 32 megabytes, ou se passa tudo por SHA-256 dez mil vezes. Você pode espalhar a entropia, pode disfarçar ela, pode fazer a saída parecer perfeitamente uniforme - mas você não cria entropia do nada. Basta pegar a mesma semente e repetir o exato mesmo processo.

TRNG: onde a aleatoriedade de verdade entra

Bacana, mas então de onde vem a aleatoriedade de verdade?

De fora do computador. De fenômenos físicos. É pra isso que existe o TRNG - true random number generator, ou gerador de números aleatórios verdadeiro. A diferença do TRNG pro PRNG é que ele não calcula nada, ele apenas mede. Mede algum fenômeno físico que ninguém consegue prever nem repetir. O exemplo mais comum é o ruído térmico. Todo componente eletrônico acima do zero absoluto tem elétrons se agitando por causa do calor, essa agitação produz uma tensão minúscula que fica variando sozinha, sem padrão nenhum. O circuito mede essa variação e transforma em bits. Qual fenômeno exatamente cada fabricante escolhe muda de chip pra chip. O que importa é que a fonte está fora da lógica do programa: não existe fórmula, não existe estado inicial, não tem como rodar de novo e obter o mesmo resultado.

Dentro de uma hardwallet isso é um pedaço de silício. O chip principal da ColdCard, um STM32 da ST, traz um bloco de hardware dedicado só pra isso, separado do processador que roda o firmware. Ele fica ali medindo o ruído e entregando bytes quando solicitado.

Pro firmware, esse bloco todo aparece como uma função. O código pede "me dá 32 bits aleatórios", a função devolve 32 bits, e a carteira segue a vida. Uma chamada, uma linha. Essa função é a fronteira entre o mundo físico e o software: de um lado alguém mediu ruído, do outro chegou um número. Olhando só pro número, o firmware não tem como saber de que lado ele veio. 32 bits medidos e 32 bits calculados são indistinguíveis.

O problema do TRNG é que é lento e entrega pouca coisa por vez, então ninguém fica pedindo tudo direto dele: na prática se mede uma vez pra usar o resultado como semente, a partir dessa semente um algoritmo criptográfico pode gerar quantos bytes forem necessários. Esse gerador é o DRBG - deterministic random bit generator. É um PRNG bem construído pra esse caso de uso, com uma semente que veio de medição física. Não cria entropia, apenas espalha a que recebeu. Se a semente medida valia 256 bits, é isso que a saída vale, gere ela um byte ou um gigabyte.

Gerando entropia na mão: dados, moedas e o preço de errar

Mas caso você não queira confiar no TRNG de nenhum fabricante, o caminho é gerar a entropia por conta própria.

Já vimos que um dado não-viciado de seis lados pode entregar 2,585 bits por rolagem. Pra chegar em 128 bits você precisa de 128 / 2,585 = 49,5, ou seja, no mínimo 50 rolagens. Uma moeda dá 1 bit por lançamento, então 128 lançamentos pra 128 bits.

Mas antes de sair jogando dados, vamos entender os riscos pra poder mitigá-los.

O problema do dadinho viciado a gente já discutiu, dado de precisão resolve, e na dúvida, role mais vezes do que o mínimo pra chegar nos bits que deseja, lembrando que 50 rolagens são pra obter 128 bits de entropia, se quer uma seed de 24 palavras, precisa do dobro de bits, do dobro de rolagens.

Dado viciado é só a ponta do iceberg, restam todos os problemas da pecinha que rola o dado: você.

Pra começar tem o humano fingindo ser dado, esse é o pior de todos, se você "rolar" os dados de cabeça, ou digitar uma sequência que parece aleatória, a entropia real despenca, um atacante que modele a distribuição típica de humanos pode quebrar sua chave. Não existe aleatoriedade dentro da sua cabeça.

Mesmo usando dados de qualidade você pode estragar tudo de várias maneiras. Uma delas é criando regras no meio do processo, o pior é que nem parece um problema - parece bom senso. Você rola o dado e ele não cai deitado. Para inclinado, apoiado na parede, escorado num livro, meio em cima do outro dado. E aí? Vale a face que está mais pra cima? Rola de novo? Você olha, decide na hora, e segue a vida. Só que quem decidiu ali não foi o dado. Foi você.

E isso altera a conta. Os 2,585 bits por rolagem valem sob duas condições: as seis faces igualmente prováveis, e o resultado entrando na sequência seja ele qual for. No instante em que existe uma decisão sua depois de ver como o dado caiu, você virou um filtro no meio do caminho.

Por isso a regra precisa ser escrita antes da primeira rolagem, não inventada na trigésima. Dado inclinado, ilegível ou fora da superfície? Não conta, rola de novo. Saiu número repetido? Anota. Três 6s seguidos em 50 rolagens é absolutamente comum, e rolar de novo porque "não parece aleatório" é exatamente o que estraga a aleatoriedade. Perdeu a conta ou digitou errado? Nada de corrigir de memória: ou você repete aquela entrada, ou recomeça do zero.

Mas aí você tem 5 dados, e não quer jogar apenas 1 por vez, ao invés de 50 rolagens, quer jogar os 5 de uma vez, e em 10 arremessos tá feito. Só que agora cada arremesso tem duas coisas sorteadas: os números e a ordem entre eles. Os cinco dados não caem numerados na mesa. Quem decide qual é o primeiro é você. O jeito mais natural do mundo é ler do menor pro maior, ou digitar na ordem que o olho for pegando. Mas ao fazer isso você perde entropia. Não errou uma rolagem sequer, não tem dado viciado nenhum na mesa - e mesmo assim perdeu entropia.

A ordem tem que ser decidida antes do primeiro arremesso, e tem que ser uma ordem que não faça ideia do resultado. Cinco dados de cores diferentes, lidos sempre na mesma sequência de cores. Ou cinco quadradinhos marcados na bandeja, um dado em cada. Tanto faz, mas tem que ter uma regra.

Entropia manual é uma ferramenta excelente, e é a única que não depende de você confiar em fabricante. Mas ela transfere mais responsabilidade pra você. Feita errado, é pior do que um bom TRNG.

A briga que reescreveu o firmware

Antes de falar do bug propriamente dito, precisamos voltar no tempo - porque esse bug não caiu do céu, foi consequência direta de uma decisão de negócio.

Até 2020, o firmware da ColdCard era licenciado como GPLv3. Software livre de verdade: qualquer um podia pegar, estudar, modificar e redistribuir, desde que mantivesse a mesma licença.

Em 28 de julho de 2020, a Foundation Devices, do Zach Herbert, anunciou a Passport - uma hardwallet construída em cima do firmware GPLv3 da ColdCard. Legal, permitido, e literalmente o propósito da licença.

Dois dias depois, em 30 de julho de 2020, NVK, CEO da CoinKite, foi pro Twitter dizer que se arrependia profundamente de ter escolhido a GPLv3 pra ColdCard. Que agora tinha um concorrente com "ZERO contribuições, em código ou financeiramente". Que era "um clone que só troca a interface". A discussão azedou rápido - "parasitas", "golpe de afinidade", e por aí vai. O Zach respondeu com uma carta aberta apontando que a Passport tinha hardware completamente diferente - outra bateria, outra câmera, outra tela, outro teclado - e que bootloader idêntico era tecnicamente impossível.

Em novembro de 2020, a CoinKite começou a trocar a licença: saindo GPLv3, entrando MIT + Commons Clause. O FAQ da própria Commons Clause diz, com todas as letras, que software sob ela não é open source. Você pode ler o código, pode compilar, pode até conferir que o binário compilado localmente é idêntico ao distribuído pela CoinKite - mas não pode vender nada derivado. A CoinKite até mesmo parou de chamar o produto de "open source" e passou a chamar de "verificável" no seu próprio site.

Só que trocar a licença não basta. Quer se livrar da GPL? Tem que arrancar todo o código GPL de dentro do produto. E o firmware da ColdCard dependia da trezor-crypto, que é GPL.

Foi isso que gerou o commit de 1º de março de 2021, assinado por Peter D. Gray - o CTO da CoinKite - com a mensagem "First pass w/ libNgU". Olha o tamanho da coisa:

commit b18723dddb6d751c39978e4364b56b2414f68b47
Author: Peter D. Gray <peter@conalgo.com>
Date:   Mon Mar 1 09:03:03 2021 -0500

    First pass w/ libNgU

 COPYING                       |  674 --------------
 external/crypto               |    1 -
 external/modcryptocurrency    |    1 -
 external/libngu               |    1 +
 ... 120 arquivos alterados

674 linhas removidas do arquivo COPYING, que é o texto da GPL. E os submódulos crypto e modcryptocurrency - a trezor-crypto - saindo, e no lugar deles uma biblioteca nova, a libngu, escrita pela própria CoinKite.

Um refactor gigante, na camada mais crítica do produto, motivado não por necessidade técnica mas por uma briga de licenciamento. Agora dá uma olhada no que isso fez com a geração da seed:

--- a/shared/seed.py
+++ b/shared/seed.py
-from ckcc import rng_bytes
-from random import rng, shuffle
+import ngu, uctypes, bip39, random

 async def make_new_wallet():
     # always full 24-word (256 bit) entropy
-    seed = bytearray(32)
-    rng_bytes(seed)
+    seed = random.bytes(32)

     assert len(set(seed)) > 4       # TRNG failure

-    # hash to mitigate bias in TRNG
-    seed = tcc.sha256(seed).digest()
+    # hash to mitigate possible bias in TRNG
+    seed = ngu.hash.sha256s(seed)

Tá tudo aí, em poucas linhas. O ckcc.rng_bytes() era o módulo em C da própria CoinKite, que lia o registrador do TRNG do chip diretamente. Ele saiu, e entrou o random.bytes() da libNgu. O comentário continua dizendo "TRNG". O assert continua dizendo "TRNG failure". Só que a partir desse commit, nenhum bit da seed vinha mais do TRNG.

Mas aí você deve estar pensando, como é que isso não foi pego no code-review? Não foi porque não teve, não teve sequer pull request, foi push direto pra master. Você não ouviu errado, a empresa mais respeitada do mercado alterou a parte mais crítica do seu produto, sem testes, e sem revisão - eles são bons demais pra perder tempo com esse tipo de coisa.

O bug, camada por camada

Esse bug é um daqueles complicados, não tem um único lugar pra olhar. Ele está entre três lugares. Vamos entender uma camada por vez.

Camada 1: a configuração da placa.

A ColdCard usa MicroPython, e todo board de MicroPython tem um arquivo mpconfigboard.h com as opções daquela placa. Esse arquivo foi configurado pra desligar o RNG do MicroPython, com um comentário dizendo que existe uma implementação própria:

  // stm32/COLDCARD/mpconfigboard.h
  // We have our own version of this code.
  #define MICROPY_HW_ENABLE_RNG       (0)

Camada 2: o RNG da própria CoinKite.

E de fato, essa implementação existe, em stm32/COLDCARD/rng.c, com um cabeçalho que diz "baseado no rng.c do MicroPython, mas mais paranoico":

  // stm32/COLDCARD/rng.c
  static uint32_t rng_get_or_fault(void)
  {
      rng_init();

      uint32_t start = HAL_GetTick();
      while (!(RNG->SR & RNG_SR_DRDY)) {
          if (HAL_GetTick() - start >= RNG_TIMEOUT_MS) {
              // hardware failure... do not return anything!
              mp_raise_OSError(MP_EFAULT);
          }
      }

      last_value = RNG->DR;
      return last_value;
  }

Lê o hardware, e se não responder em 10ms, lança uma exceção em vez de devolver lixo. É de fato melhor que a implementação do MicroPython que retorna 0 em caso de falha.

Mas olha o static na definição. Essa função é privada do arquivo, nunca é exportada. O arquivo exporta funções como random32() e random_buffer(). Mas nunca rng_get().

Camada 3: o fallback do MicroPython.

Enquanto isso, o MicroPython, no arquivo ports/stm32/rng.c, faz exatamente o que a CoinKite queria com a configuração em mpconfigboard.h, desabilita o seu RNG:

  // external/micropython/ports/stm32/rng.c
  #if MICROPY_HW_ENABLE_RNG

  uint32_t rng_get(void) {
      // ... lê RNG->DR do hardware ...
      return RNG->DR;
  }

  #else // MICROPY_HW_ENABLE_RNG

  // For MCUs that don't have an RNG we still need to provide a rng_get()
  // function, eg for lwIP and random.seed().  A pseudo-RNG is not really
  // ideal but we go with it for now, seeding with numbers which will be
  // somewhat different each time.

  // Yasmarang random number generator by Ilya Levin
  STATIC uint32_t pyb_rng_yasmarang(void) {
      static bool seeded = false;
      static uint32_t pad = 0, n = 0, d = 0;
      static uint8_t dat = 0;

      if (!seeded) {
          seeded = true;
          rtc_init_finalise();
          pad = *(uint32_t *)MP_HAL_UNIQUE_ID_ADDRESS ^ SysTick->VAL;
          n = RTC->TR;
          d = RTC->SSR;
      }

      pad += dat + d * n;
      pad = (pad << 3) + (pad >> 29);
      n = pad | 2;
      d ^= (pad << 31) + (pad >> 1);
      dat ^= (char)pad ^ (d >> 8) ^ 1;

      return pad ^ (d << 5) ^ (pad >> 18) ^ (dat << 1);
  }

  uint32_t rng_get(void) {
      return pyb_rng_yasmarang();
  }

  #endif

Mas repara bem no que acontece quando o RNG do MicroPython é desligado, não é que o símbolo rng_get() não é exportado, é, mas com a implementação de um PRNG chamado Yasmarang. No comentário da função é explicado que mesmo placas que não possuem um TRNG à disposição precisam de gerador de números aleatórios. Isso significa que se o rng_get() da ColdCard tivesse sido exportado corretamente, o linker geraria um erro de símbolo duplicado, e a solução precisaria ser revista. Essa implementação do MicroPython é perfeitamente aceitável, roda em dezenas de microcontroladores, nunca foi pensada pra criptografia, e isso não é um problema, quem precisar usar pra criptografia é que tem a responsabilidade de se preocupar com isso.

Camada 4: a trava que não travou.

Aqui é onde todas as peças se encaixam, ou melhor, desencaixam. Na libNgu, no arquivo ngu/random.c, tem uma trava esperando que o RNG do MicroPython esteja habilitado, contradizendo a configuração definida no firmware:

  // external/libngu/ngu/random.c
  #ifdef MICROPY_PY_STM
  // ports/stm32/rng.c
  extern uint32_t rng_get(void);
  # define CHIP_TRNG_SETUP()
  # define CHIP_TRNG_32()         rng_get()

  # ifndef MICROPY_HW_ENABLE_RNG
  # error "get a HW TRNG plz"
  # endif
  #endif

E o pior de tudo é que essa trava está escrita errada. #ifndef quer dizer "se este símbolo não estiver definido". Só que o símbolo estava definido, como 0, lá na configuração da placa. 0 em C é um valor falso, mas pro pré-processador, definido é definido. Ele não olha pro valor.

O que o desenvolvedor queria ali era um #if !:

  # if !MICROPY_HW_ENABLE_RNG
  # error "get a HW TRNG plz"
  # endif

É gritante pra qualquer desenvolvedor com o mínimo de experiência que esse código foi escrito às pressas sem qualquer tipo de teste. O cliente da lib, a ColdCard, desabilita intencionalmente o RNG do MicroPython pra fornecer uma implementação própria, que nunca é fornecida. Por outro lado, a lib responsável por usar o RNG não espera uma implementação externa, espera que o RNG do MicroPython esteja habilitado, e até tenta forçar isso com uma trava, que nunca foi disparada porque foi escrita incorretamente.

Agora você tá aí pensando, mas meu Deus, isso é muito frágil, qualquer errinho besta é capaz de quebrar tudo. Bem, é pra isso que existem testes automatizados, mas guenta aí que vamos chegar lá.

Agora vamos fazer o caminho completo. A libNgu declara extern uint32_t rng_get(void) e chama a função. O arquivo da CoinKite - o bom, o paranoico - não exporta esse símbolo. O do MicroPython exporta, e como a flag é zero, o que ele exporta é o Yasmarang. O linker faz o trabalho dele: acha um único símbolo rng_get() no projeto inteiro, resolve, e pronto. Zero erros. Zero avisos.

O mais cruel é que as duas funções têm exatamente a mesma assinatura. uint32_t rng_get(void). Não existe nada, em nenhuma etapa do build, que consiga distinguir uma da outra. O compilador não tem como saber que uma lê ruído térmico enquanto que a outra não. Pra ele, são dois inteiros de 32 bits.

Lembra do vídeo de C, quando eu falei que o compilador te avisa quando você chama uma função que não foi declarada? Pois é, aqui o problema é o oposto. A função estava declarada, o protótipo batia perfeitamente, e o linker achou uma implementação válida. Do ponto de vista de tipos, está tudo certo. Só que é a implementação errada, de um repositório diferente, escolhida por acidente.

Agora vamos olhar mais no detalhe pra implementação do Yasmarang, porque é aqui que os 40 bits aparecem:

  • MP_HAL_UNIQUE_ID_ADDRESS é o ID único do chip. Fixo pra sempre naquele dispositivo. Não é secreto - em vários casos aparece no número de série USB.
  • SysTick->VAL é um contador que dá a volta muito rápido. Uns 80 mil valores possíveis no Mk3, 120 mil nos modelos novos.
  • RTC->TR é o relógio do chip. 86.400 possibilidades.
  • RTC->SSR é a fração de segundo. 256 valores.

E depois disso, nada mais entra. A variável seeded vira true, e o gerador roda determinístico pra sempre.

A cereja: o reseed de 32 bits

Nos modelos mais recentes, Mk4, Mk5 e Q tinha uma proteção extra: misturar entropia dos dois elementos seguros do dispositivo no gerador de números aleatórios durante o boot:

  # shared/mk4.py
  def rng_seeding():
      # seed our RNG with entropy from secure elements
      import callgate, ngu, ustruct

      a = callgate.read_rng(1)        # SE1
      b = callgate.read_rng(2)        # SE2

      n = ngu.hash.sha256d(a+b)
      n, = ustruct.unpack('I', n[0:4])

      ngu.random.reseed(n)
  // stm32/mk4-bootloader/dispatch.c
  case 26: {
      // Read some random bytes from various sources, like SE's.
      REQUIRE_OUT(33);

      switch(arg2) {
          case 1:         // for SE1
              // secure, any MitM will be detected
              ae_setup();
              ae_secure_random(&buf_io[1]);
              buf_io[0] = 32;
              break;

          case 2:         // for SE2
              // secure, requires knowledge of pairing secret
              se2_read_rng(&buf_io[1]);
              buf_io[0] = 8;
              break;

          default:
              rv = ERANGE;
              break;
      }

      break;
  }

A variável a armazena 32 bytes de entropia retornada do primeiro elemento seguro, a variável b armazena mais 8 bytes retornados pelo segundo. Isso são 320 bits de entropia, logo em seguida calcula um SHA-256 duplo disso, e extrai um inteiro de 32 bits. A partir do momento em que apenas 32 bits são utilizados, não importa que 320 bits tenham sido usados na entrada, o espaço de busca foi reduzido pra todas as possibilidades que cabem em 32 bits, é por isso que a segurança extra vai de 40 pra apenas 72 bits, e nada além disso.

Pra entender como esses 32 bits eram utilizados precisamos ver como a libNgu gerava um número aleatório. Lembra que a lib "forçava" o RNG do MicroPython estar ligado por meio da função rng_get()? Então, a geração de números aleatórios não era feita diretamente por essa função, mas sim pela my_random_bytes() que chamava rng_get() por meio da macro CHIP_TRNG_32, fazia um XOR disso com my_yasmarang() - a implementação do Yasmarang replicada dentro da libNgu. A intenção é clara e faz sentido, pega o que veio do TRNG e faz XOR com um PRNG. Um XOR entre uma fonte boa e uma previsível continua sendo pelo menos tão bom quanto a fonte boa. Só que a fonte boa nunca esteve lá. Na prática, o que rodava era um XOR entre dois PRNGs. E um deles semeado com constantes hardcoded no arquivo-fonte, iguais em todos os dispositivos do mundo, visíveis pra qualquer um que abrisse o GitHub.

  // external/libngu/ngu/random.c
  static uint32_t yasmarang_pad = 0x0a8ce26f, yasmarang_n = 69, yasmarang_d = 233;
  static uint8_t yasmarang_dat = 0;

  void my_random_bytes(uint8_t *dest, uint32_t count)
  {
      uint32_t last = 0;

      while(count) {
          uint32_t chip = CHIP_TRNG_32();

          if(chip == last) {
              // maybe TRNG is not clocked? Fail hard
              mp_raise_OSError(MP_EFAULT);
          }
          last = chip;

          chip ^= my_yasmarang();
          ...
      }
  }

Os 32 bits do reseed eram usados pra sobrescrever uma das quatro variáveis de estado do Yasmarang. As outras três - n, d e dat - continuavam com o que estavam.

  // external/libngu/ngu/random.c
  STATIC mp_obj_t random_reseed(mp_obj_t arg)
  {
      yasmarang_pad = mp_obj_get_int_truncated(arg);

      return mp_const_none;
  }

Por que ninguém viu isso em cinco anos

Agora chegou o momento de falarmos dos testes. Um software crítico como esse, que lida com a proteção do patrimônio dos seus usuários, tinha como obrigação ter ampla cobertura de testes. Vimos comentários no código do tipo: vamos substituir essa implementação por uma nossa, só que mais paranoica. O primeiro lugar em que eles precisavam ser paranoicos era nos testes.

Mas não é que não existia nenhum teste, eles existiam e passavam. Dá uma olhada no test_random.py da libNgu:

  # external/libngu/ngu/ngu_tests/test_random.py
  import ngu

  for trial in range(100):
      v = [ngu.random.uint32() for i in range(100)]
      assert len(v) == len(set(v)), 'bad luck, try again'
      assert max(v) > 0x80000000
      assert min(v) < 0x80000000

  for ln in range(1, 700):
      b = ngu.random.bytes(ln)
      assert len(b) == ln

  for trial in range(100):
      b = ngu.random.bytes(4096)
      assert min(b) < 0x10
      assert max(b) > 0xe0

  for trial in range(1000):
      b = ngu.random.uniform(100)
      assert 0 <= b < 100

  for mx in range(10, 2000, 73):
      got = set()
      for nsamples in range(mx*10):
          got.add(ngu.random.uniform(mx))
      assert (len(got)*100.0/mx) >= 97

  # api test only; can't verify results
  ngu.random.reseed(123)

  print('PASS - test_random')

Confere que os valores não se repetem, que cobrem a faixa toda, que os bytes usam o intervalo inteiro de 0x00 a 0xff, e que a distribuição uniforme cobre 97% do espaço. É um teste estatístico.

Passa perfeitamente com o Yasmarang. Claro que passa. Passar em teste estatístico é exatamente o que um PRNG faz. Essa é a definição de "pseudo-aleatório": produzir uma sequência determinística que é estatisticamente indistinguível de uma aleatória. O teste não estava quebrado, mas estava testando a propriedade errada. Isso pode ser pior do que nenhum teste, porque ele produz confiança com aquele PASS - test_random verde no terminal, toda vez que a build rodava.

A pergunta certa nunca foi "esses bytes parecem aleatórios?". Essa pergunta é impossível de responder por observação. A pergunta certa é: esses bytes vieram do hardware? Isso não se testa olhando pra saída, se testa olhando pro caminho de execução do código.

Os testes que deveriam existir desde o primeiro dia

A geração de chave é o caminho crítico de uma hardwallet, se falhar, falha silenciosamente e afeta todos os usuários sem possibilidade de recuperação, chave que nasceu fraca não tem recuperação a não ser jogar fora e criar uma nova, forte. Isso significa que a cobertura de testes da geração de chaves deveria ser grande, e revisada constantemente.

Eu nem precisei gastar tempo analisando o código e escrevendo testes pra te provar que é possível garantir o funcionamento correto do software, a própria CoinKite fez isso depois do ataque.

A primeira correção foi fazer o build falhar. O arquivo random_backend.h foi adicionado na libNgu pra validar a seleção de entropia:

  // external/libngu/ngu/random_backend.h
  #elif defined(MICROPY_PY_STM)
  # if MICROPY_HW_ENABLE_RNG != 1 && NGU_STM32_EXTERNAL_RNG_GET != 1
  #  error "MICROPY_HW_ENABLE_RNG=1 or NGU_STM32_EXTERNAL_RNG_GET=1 required"
  # endif

  extern uint32_t rng_get(void);
  ...
  #else
  # error "No hardware or OS entropy source is defined for this target"
  #endif

Duas correções aqui, primeiro o uso de #if ! ao invés de #ifndef. Mas além disso, agora a libNgu corretamente aceita outra implementação de RNG que não apenas o do MicroPython, que é justamente o que a ColdCard precisa. Desabilitar a do MicroPython e fornecer a sua própria.

Em seguida, desceram ao nível de compilação pra garantir que o PRNG Yasmarang não seja incluído no binário - não vou entrar nos detalhes de sintaxe do makefile, mas basicamente eles trocam o objeto compilado do rng.c do MicroPython por um objeto vazio. O sistema de build do MicroPython espera que aquele arquivo-objeto exista, então ele existe - só que sem nenhum símbolo dentro. O -D no topo redefine o nome do Yasmarang pra um nome inválido em C, se aquele arquivo for compilado por algum outro caminho, quebra a compilação - hífens não são permitidos em nomes em C.

  # stm32/COLDCARD/mpconfigboard.mk
  # Do not compile MicroPython's fallback PRNG.  The board-specific rng.c
  # provides rng_get(), and this empty object satisfies the upstream object list.
  $(BUILD)/rng.o: CFLAGS += -Dpyb_rng_yasmarang=error-do-not-want-this
  $(BUILD)/rng.o:
        $(ECHO) "SKIP stm32/rng.c"
        $(Q)$(CC) $(CFLAGS) -x c -c /dev/null -o $@

E agora adicionam uint32_t rng_get(void) { return rng_get_or_fault(); } no arquivo deles, exportando o símbolo que faltava desde 2018.

Após a compilação, o binário produzido é verificado pra garantir que o rng.o do MicroPython não define nenhum símbolo, e que o rng.o da placa define rng_get() como símbolo global.

  # stm32/shared.mk
  NM = arm-none-eabi-nm
  .PHONY: rng-code-check
  rng-code-check:
        @upstream_symbols="$$($(NM) --defined-only $(BUILD_DIR)/rng.o)" || exit $$?; \
        if test -n "$$upstream_symbols"; then \
                echo "ERROR: micropython's stm32/rng.o must not define any symbols"; \
                exit 1; \
        fi; \
        board_symbols="$$($(NM) --defined-only \
                $(BUILD_DIR)/boards/$(BOARD)/rng.o)" || exit $$?; \
        if ! printf '%s\n' "$$board_symbols" \
                | grep -Eq '^[[:xdigit:]]+[[:space:]]+T[[:space:]]+rng_get$$'; then \
                echo "ERROR: board rng.o does not define global rng_get"; \
                exit 1; \
        fi

O nm é uma ferramenta que lista os símbolos de um arquivo-objeto. A primeira parte é simples de entender, verifica que a saída é vazia pra garantir que o rng.o do MicroPython não tem nenhum símbolo exportado. Na segunda parte espera uma saída e faz uma busca via regex. Pra entender como funciona vamos rodar o nm em um hello world qualquer:

  // hello.c
  #include <stdio.h>
  #include <stdint.h>

  static uint32_t rng_get_or_fault(void)
  {
      return 4;
  }

  uint32_t rng_get(void)
  {
      return rng_get_or_fault();
  }

  int main(void)
  {
      printf("Hello, world! %u\n", rng_get());
      return 0;
  }

Primeiro, geramos o arquivo-objeto com o gcc:

  $ gcc -c hello.c -o hello.o

Agora rodamos o nm:

  $ nm hello.o
  0000000000000016 T main
                   U printf
  000000000000000b T rng_get
  0000000000000000 t rng_get_or_fault

A saída é um conjunto de linhas com os símbolos do programa, o número no início de cada linha representa a posição do símbolo no arquivo-objeto, a letra do meio é o tipo do símbolo. Nesse exemplo, temos T e U. U significa undefined, ou seja, o símbolo não está em nenhuma seção desse arquivo, e de fato, a função printf() não é definida no arquivo hello.o. T representa uma seção de código, minúsculo significa que é um símbolo local, maiúsculo global. Antes comentei que static tornava uma função privada ao arquivo, aqui comprovamos isso, rng_get_or_fault() produz t minúsculo, enquanto que rng_get() produz T maiúsculo.

Agora conseguimos destrinchar o regex: ^[[:xdigit:]]+[[:space:]]+T[[:space:]]+rng_get$$

Está buscando por um símbolo exportado chamado rng_get, se não for encontrado para tudo e gera erro.

O parâmetro --defined-only apenas omite os símbolos undefined:

  $ nm --defined-only hello.o
  0000000000000016 T main
  000000000000000b T rng_get
  0000000000000000 t rng_get_or_fault

Por fim, usaram objdump pra verificar a cadeia de chamadas completa:

  # stm32/shared.mk
        libngu_random="$(BUILD_DIR)/libngu/random.o"; \
        random_bytes_refs="$$($(OBJDUMP) -r -j .text.random_bytes \
                "$$libngu_random")" || exit $$?; \
        if ! printf '%s\n' "$$random_bytes_refs" \
                | grep -Eq '[[:space:]]R_ARM_(THM_)?CALL[[:space:]]+my_random_bytes([+-].*)?$$'; then \
                echo "ERROR: ngu.random.bytes does not call my_random_bytes"; \
                printf '%s\n' "$$random_bytes_refs"; \
                exit 1; \
        fi; \
        # my_random_bytes   ->  checked_chip_trng_read
        # checked_chip_trng_read -> rng_get

Pra garantir em tempo de execução que o TRNG está de fato funcionando, adicionaram um auto-teste que executa durante o boot da hardwallet:

  // stm32/COLDCARD_MK4/rng.c
  void rng_selftest(void)
  {
      rng_init();

      // Espera no nível de registrador pela primeira palavra: prova que
      // entropia está fluindo.
      uint32_t start = HAL_GetTick();
      while(!(RNG->SR & RNG_SR_DRDY)) {
          if(HAL_GetTick() - start >= RNG_TIMEOUT_MS) {
              __fatal_error("rng: no entropy");
          }
      }

      rng_count = 0;
      rng_count_active = true;

      // descarta essas palavras de aquecimento
      for(int i = 0; i < 8; i++) {
          (void)rng_get();
      }

      rng_count_active = false;

      if(rng_count != 8) {
          // rng_get() não passou pelo caminho de leitura do hardware:
          // deve ter resolvido para uma implementação não-hardware
          __fatal_error("rng: bad linkage");
      }
  }

O teste arma um contador dentro da função de leitura do hardware, chama rng_get() oito vezes, e confere se o contador chegou em oito. Se a função resolver pra qualquer outro caminho, o contador vai ficar em zero, e o dispositivo não liga.

Não é de hoje que é prática na indústria de desenvolvimento de software a escrita de testes automatizados, não interessa se você usa TDD, ou se escreve os testes todos depois, mas você escreve os fucking testes, principalmente pros caminhos críticos do código que acabou de implementar. No mínimo, deveria ter um teste pra verificar que a trava forçando o TRNG do MicroPython de fato funcionava, e é um teste muuito mais simples destes que acabamos de ver. Basta compilar o programa e verificar que o erro acontece.

Pra te provar isso, clonei a libNgu bugada na minha máquina, e adicionei esse test_rng_guard.sh, um shellscript que simplesmente compila o programa e testa os 3 cenários básicos:

  • deve compilar sem problemas quando o TRNG do MicroPython estiver ligado
  • deve gerar erro quando a variável que habilita o TRNG for omitida ou for passada como falso

E voilà, quando a variável tem o valor falso o teste falha, pra corrigir basta abrir o arquivo, trocar #ifndef por #if !, e pronto, todos os cenários passam.

  # external/libngu/test-rng-guard/test_rng_guard.sh
  # Unit test for the RNG guard in ngu/random.c, from libngu's side: no
  # MicroPython, no board. The guard only looks at two macros, so the test sets
  # them by hand, and MicroPython's headers are empty stand-ins (stubs/py/).
  #
  # On an STM32 MicroPython build (MICROPY_PY_STM), the guard must stop the
  # build unless MicroPython's hardware RNG is enabled.
  #
  # usage: test-rng-guard/test_rng_guard.sh   (from any directory)

  HERE=$(cd "$(dirname "$0")" && pwd)
  RANDOM_C="$HERE/../ngu/random.c"
  result=0

  # Runs only the preprocessor (-E) on the real random.c and prints what
  # happened: "fires" if the guard's #error stopped it, "compiles" if it went
  # through, "error" if something else broke. -U__linux__: the host defines it,
  # an STM32 doesn't.
  preprocess() {
      errors=$(gcc -E -I"$HERE/stubs" -U__linux__ -DMICROPY_PY_STM "$@" \
                   "$RANDOM_C" 2>&1 >/dev/null)
      status=$?

      if echo "$errors" | grep -q "get a HW TRNG plz"; then
          echo fires
      elif [ $status -eq 0 ]; then
          echo compiles
      else
          echo error
      fi
  }

  check() {
      name="$1"; expected="$2"; shift 2
      got=$(preprocess "$@")

      if [ "$got" = "$expected" ]; then
          echo "PASS - $name"
      else
          echo "FAIL - $name: expected '$expected', got '$got'"
          result=1
      fi
  }

  check "RNG enabled (=1)"   compiles -DMICROPY_HW_ENABLE_RNG=1
  check "RNG undefined"      fires
  check "RNG disabled (=0)"  fires    -DMICROPY_HW_ENABLE_RNG=0

  exit $result

Esse teste define o arquivo a ser testado na variável RANDOM_C.

A função preprocess usa o gcc pra rodar apenas o pré-processador, onde diretivas como #if e #ifndef são avaliadas, retorna fires se o erro get a HW TRNG plz é gerado, e compiles caso retorne sem erros. A função check recebe dois parâmetros, name e expected, chama preprocess passando o restante dos parâmetros - neste caso apenas o argumento com -D. E por fim faz um assert do retorno de preprocess com expected.

Assinar, revisitado

Mas e por que mesmo sem gerar entropia manual, nem todo mundo que estava com ColdCard vulnerável perdeu fundos? A resposta é passphrase ou multisig ou as duas coisas juntas.

A passphrase entra logo após a geração da chave privada. Mas imagina a complicação de armazenar em segurança uma coisa dessas, estamos falando de um número de 128 ou 256 bits. Pensa no processo de recuperação de carteira tendo que digitar um trem desses. Memorizar então, esquece. A BIP-39 veio pra resolver esse problema, ela transforma a chave privada de 128 ou 256 bits em 12 ou 24 palavras. Possui um mecanismo de checksum pra tentar identificar erros caso alguma palavra errada seja usada.

As 12 ou 24 palavras passam pela função PBKDF2-HMAC-SHA512, com 2048 iterações. Além das palavras essa função recebe um salt, por padrão é utilizado o texto mnemonic. Qualquer alteração no salt produz um resultado completamente diferente. É aqui que entra o conceito de passphrase, também conhecida como a "13ª palavra": ela é concatenada no fim desse salt. Sem passphrase, é só mnemonic. Com passphrase, é mnemonic seguido do que você digitou - o resultado que sai do outro lado não tem nada a ver com o anterior. Mesmas palavras, passphrases diferentes, carteiras diferentes, cada uma com os seus próprios endereços. Só que aqui não tem mais checksum nenhum pra te salvar, qualquer passphrase gera uma carteira válida. Então é de extrema importância fazer backup, e testar. Backup não testado é apenas uma esperança. Teste a recuperação da carteira com valores pequenos, já pensou errar um caractere da passphrase na hora de fazer o backup e nunca mais conseguir recuperar a carteira com todos os seus bitcoins comprometidos nela?

Diagrama em que as palavras e o salt entram no PBKDF2, que gera a seed; o salt é mnemonic mais a passphrase palavras PBKDF2 seed salt "mnemonic" + passphrase

Figura 3: A passphrase entra no salt do PBKDF2

Diagrama em que as mesmas palavras geram a carteira A com a passphrase A e a carteira B com a passphrase B palavras carteira A carteira B passphrase A passphrase B

Figura 4: As mesmas palavras com passphrases diferentes

Já vimos que o script de bloqueio mais comum é o P2PKH: exige uma assinatura válida de uma chave pública específica. Mas o script é um programa, nada no protocolo Bitcoin diz que esse é o único tipo de script válido. Poderia exigir duas assinaturas, ou três de cinco, ou qualquer outro esquema que possa ser codificado em um script. Essa flexibilidade sempre esteve no Bitcoin, desde a sua criação.

O multisig é isso, um script que diz: este valor só pode ser gasto apresentando M assinaturas válidas, de um conjunto de N chaves públicas previamente definidas. Dois de três, três de cinco, o que você quiser.

Por exemplo, o script pra um multisig 2 de 3 fica OP_2 seguido das 3 chaves públicas seguido de OP_3 e OP_CHECKMULTISIG:

  OP_2 <pubkey_A> <pubkey_B> <pubkey_C> OP_3 OP_CHECKMULTISIG

Pra desbloquear esse script basta fornecer 2 assinaturas válidas pra 2 das 3 chaves públicas.

Por isso quem tinha multisig bem feito, mesmo com uma das chaves geradas por uma ColdCard vulnerável não perdeu fundos. O atacante quebrou uma das suas chaves? Hora de refazer o multisig, mas sem pânico, sem correria, porque você ainda está protegido pela outra chave. Mas e se eu gerei um esquema multisig com 3 ColdCards? Aí cê me quebra. O ponto de fazer um esquema multisig é justamente pra aumentar a camada de proteção contra um ponto único de falha. Use hardwallets diferentes, esquemas de geração de chaves diferentes. Se alguma for comprometida, seus bitcoins continuam seguros, e você pode refazer o seu setup com calma, analisar onde errou e melhorar.

Mas e como eu sei que uma das minhas chaves foi comprometida? Você pode criar carteiras canário - o termo vem dos canários utilizados nas minas de carvão. O ar das minas pode conter gases tóxicos como o monóxido de carbono, esses gases não têm cor nem cheiro, aí pode ser tarde demais pra sair da mina com vida. Passarinhos respiram muito mais rápido que humanos, seus pulmões são muito mais eficientes pra conseguirem voar, o efeito do gás é muito mais rápido neles, quando começavam a ficar mais agitados ou caíam era um sinal pros mineiros darem no pé. No bitcoin, a ideia é criar uma carteira singlesig pra cada uma das carteiras participando do esquema multisig, basta enviar um saldo pequeno pra cada uma delas, se esse saldo for limpo, você sabe que aquela chave foi comprometida e que precisa refazer o multisig.

Diagrama com as chaves A, B e C ligadas aos seus canários; a chave B está circulada e o canário B riscado chave A canário A chave B canário B chave C canário C

Figura 5: Uma carteira canário para cada chave do multisig

Não vou entrar em detalhes técnicos do multisig: xpubs, descriptor, etc. Já tem muito conteúdo na internet sobre como fazer. O ponto aqui foi te mostrar todas as maneiras de se proteger de um ataque como esse: antes de qualquer coisa, não confie a geração das suas chaves a terceiros. Tem medo de gerar a própria entropia? No mínimo use uma passphrase forte, faça backup, teste o backup. E idealmente crie um esquema multisig com fabricantes diferentes.

Conclusão

O ataque da ColdCard não foi um ataque à criptografia do Bitcoin, não foi malware, não foi phishing, não foi invasão. A criptografia funcionou perfeitamente. Foi um erro de integração de build, na fronteira entre três repositórios, que fez o linker escolher a função errada entre duas com a mesma assinatura. Um refactor gigante na camada mais crítica do produto motivado por uma briga de licenciamento, entrou sem revisão. E os testes não verificavam o caminho mais crítico do sistema.

Entropia é o que protege seus bitcoins. Se ela é fraca, nada mais salva - nem estar offline, nem elemento seguro, nem marca famosa de hardwallet. Por isso a defesa que funciona não é escolher o fabricante mais confiável, é montar um setup que sobrevive ao seu fabricante favorito estar em problemas. São as três defesas que a gente viu: passphrase, entropia física em pelo menos uma das chaves, e multisig com dispositivos de fabricantes diferentes. E a defesa contra você mesmo: testar o seu setup pra garantir que funciona.

Se gostou do vídeo, deixa seu like, se inscreve no canal pra não perder os próximos vídeos, ativa o sino das notificações, e se tiver sugestões de assuntos, deixa aí nos comentários.

Don't trust, verify!

Obrigado pela leitura.Ver mais artigos