Como Validar e Gerar Frases Mnemônicas Bitcoin com Python

Sempre crie uma frase de segurança única para jogos, testnets ou airdrops e evite usar sua carteira principal.

Como Validar e Gerar Frases Mnemônicas Bitcoin Usando Python

Este artigo apresenta um guia completo para validar e gerar frases mnemônicas compatíveis com o padrão BIP-39 para Bitcoin, utilizando a biblioteca bip_utils em Python. Além disso, mostramos como armazenar frases válidas em banco de dados SQLite para posterior consulta e análise.

O Que São Frases Mnemônicas?

As frases mnemônicas são sequências de palavras que representam uma chave privada de maneira legível, facilitando a recuperação e o backup de carteiras Bitcoin. Essas frases seguem um padrão padronizado, garantindo segurança e interoperabilidade.

Importando Bibliotecas Essenciais

Para o funcionamento do script, são utilizadas as bibliotecas bip_utils para geração e validação da frase mnemônica, sqlite3 para persistência dos dados e itertools para manipulação de combinações de palavras.

Funções Principais do Script

Carregar palavras: Lê o arquivo palavras.txt contendo o dicionário de palavras para gerar frases mnemônicas.
Salvar frase válida: Armazena no banco SQLite as frases consideradas válidas, criando a tabela caso ela não exista.
Obter última frase salva: Permite retomar o processamento a partir da última frase válida encontrada.
Verificar mnemônica: Valida a frase, gera a chave privada, chave pública e endereço Bitcoin associados, além de controlar contadores de frases válidas e inválidas.
Gerar frases: Gera combinações únicas de 12 palavras para validação contínua, iniciando a partir da última frase salva.

Exemplo Completo do Código em Python

from bip_utils import Bip39SeedGenerator, Bip44, Bip44Coins
from bip_utils.utils.mnemonic import MnemonicChecksumError
import itertools
import sys
import sqlite3

d_contador = 0
c_contador = 0
ultima_frase = ""

def carregar_palavras():
    try:
        with open('palavras.txt', 'r') as f:
            palavras = f.read().splitlines()
        return palavras
    except FileNotFoundError:
        print("Arquivo 'palavras.txt' não encontrado.")
        return []

def salvar_frase_no_banco(frase):
    try:
        conn = sqlite3.connect('mnemonicas.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS frases
                          (id INTEGER PRIMARY KEY AUTOINCREMENT, frase TEXT)''')
        cursor.execute('''INSERT INTO frases (frase) VALUES (?)''', (frase,))
        conn.commit()
        conn.close()
        print("Frase salva no banco de dados.")
    except sqlite3.Error as e:
        print(f"Erro ao salvar frase no banco de dados: {e}")

def obter_ultima_frase():
    global ultima_frase
    try:
        conn = sqlite3.connect('mnemonicas.db')
        cursor = conn.cursor()
        cursor.execute('''SELECT frase FROM frases ORDER BY id DESC LIMIT 1''')
        row = cursor.fetchone()
        if row:
            ultima_frase = row[0]
        conn.close()
    except sqlite3.Error as e:
        print(f"Erro ao consultar o banco de dados: {e}")

def verificar_mnemonica(frase):
    global d_contador, c_contador
    try:
        seed_bytes = Bip39SeedGenerator(frase).Generate()
        bip44 = Bip44.FromSeed(seed_bytes, Bip44Coins.BITCOIN)
        private_key = bip44.PrivateKey().Raw().ToHex()
        private_key_wif = bip44.PrivateKey().ToWif()
        public_key = bip44.PublicKey().RawCompressed().ToHex()
        address = bip44.PublicKey().ToAddress()
        print(address)
        c_contador += 1
        if c_contador % 100000 == 0:
            print(f"Frase válida #{c_contador}: {frase}")
            salvar_frase_no_banco(frase)
        if address == "1K4ezpLybootYF23TM4a8Y4NyP7auysnRo":
            print(f"Frase válida #{c_contador}: {frase}")
            print(f"Chave Privada (Hexadecimal): {private_key}")
            print(f"Chave Privada (WIF): {private_key_wif}")
            print(f"Chave Pública (Hexadecimal): {public_key}")
            print(f"Endereço Bitcoin: {address}\n")
            sys.exit()
    except MnemonicChecksumError:
        d_contador += 1

def gerar_frases():
    palavras = carregar_palavras()
    if not palavras:
        return
    obter_ultima_frase()
    combinacoes_ultimas_palavras = itertools.permutations(palavras, 12)
    if ultima_frase:
        for combinacao in combinacoes_ultimas_palavras:
            frasecompleta = ' '.join(combinacao)
            if frasecompleta == ultima_frase:
                print(f"Continuando a partir da última frase salva: {frasecompleta}")
                break
    for combinacao in combinacoes_ultimas_palavras:
        frasecompleta = ' '.join(combinacao)
        verificar_mnemonica(frasecompleta)

if __name__ == "__main__":
    gerar_frases()

Considerações Finais

Este script é uma ferramenta educativa para entender o funcionamento interno das frases mnemônicas e seu uso no Bitcoin. É importante reforçar que a manipulação de chaves privadas e mnemônicas reais deve ser feita com extrema cautela para evitar perda de fundos ou comprometimento de segurança.

Não utilize este código em ambientes de produção sem o devido conhecimento técnico e teste rigoroso.

Formulário de contato

Como Validar e Gerar Frases Mnemônicas Bitcoin com Python - 1K4ezpLybootYF23TM4a8Y4NyP7auysnRo