@CanalQb no YouTube

Busca de Chave Privada Bitcoin com LCG e Python – Guia Completo

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

Busca de Chave Privada Bitcoin com LCG e Python

Este artigo apresenta um script Python que utiliza um Gerador Linear Congruente (LCG) para tentar encontrar uma chave privada Bitcoin correspondente a um endereço alvo na blockchain, utilizando a biblioteca Bit. A abordagem e o código são detalhados para ajudar desenvolvedores e entusiastas a entenderem o funcionamento dos algoritmos envolvidos e sua aplicação prática.

Introdução

A curva secp256k1 é a base da criptografia utilizada no Bitcoin, definindo parâmetros e limites para as chaves privadas. Encontrar uma chave privada que gere um endereço Bitcoin específico é uma tarefa computacionalmente complexa, mas pode ser ilustrada com técnicas de força bruta combinadas a geradores de números pseudoaleatórios, como o LCG.

Parâmetros do Problema

• Endereço alvo: 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG
• Limite da curva secp256k1 (n): 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
• Intervalo de busca: Entre 0x100000000000000000 e 0x1FFFFFFFFFFFFFFFFF

Como funciona o Gerador Linear Congruente (LCG)

O LCG é um método para gerar uma sequência de números pseudoaleatórios a partir de uma semente inicial. No script, ele é usado para iterar sobre possíveis valores de chaves privadas dentro do intervalo definido, conforme a fórmula:

seed = (MULTIPLIER * seed + INCREMENT) % MODULUS
value = START + seed

Os parâmetros são:

• MODULUS: o tamanho do intervalo de busca
• MULTIPLIER: 6364136223846793005
• INCREMENT: 1442695040888963407

Descrição do Script

O script executa o seguinte processo:

1. Verifica se há um arquivo de progresso com uma semente armazenada para retomar a busca.
2. Inicia a busca usando a semente inicial ou a semente recuperada.
3. Gera o próximo valor pseudoaleatório para criar uma possível chave privada dentro do intervalo permitido.
4. Converte o valor em bytes e tenta gerar o endereço Bitcoin correspondente.
5. Se o endereço gerado coincidir com o endereço alvo, imprime e salva o resultado.
6. Periodicamente salva o progresso para evitar perda de dados em buscas longas.

Exemplo de saída esperada

🎯 ENCONTRADO!
Chave Privada (hex): <chave_hexadecimal>
Valor decimal: <valor_inteiro>
WIF: <chave_wif>
Endereço: 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG

Considerações importantes

• Este método de busca é computacionalmente caro e não recomendado para tentativas reais de recuperação de chaves privadas, pois o espaço é imenso.
• A segurança do Bitcoin baseia-se exatamente na dificuldade de descobrir chaves privadas; portanto, investir em tentativas automáticas pode ser ineficaz e custoso.
• Para fins educacionais, este script exemplifica como funcionam os processos criptográficos de geração e validação de chaves e endereços Bitcoin.

Responsabilidade

Investir em criptomoedas ou tentar manipular chaves privadas envolve riscos. Sempre realize sua própria análise e evite aplicar dinheiro em métodos que não compreende totalmente.

Script Completo

import os
from bit import Key

# Alvo desejado
TARGET_ADDRESS = "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"

# Limite da curva secp256k1
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Intervalo de busca
START = 0x100000000000000000
END   = 0x1FFFFFFFFFFFFFFFFF
RANGE_SIZE = END - START

# Parâmetros do LCG
MODULUS = RANGE_SIZE
MULTIPLIER = 6364136223846793005
INCREMENT = 1442695040888963407

# Arquivo de progresso
PROGRESS_FILE = "progresso.txt"

# Carregar semente anterior ou começar do zero
if os.path.exists(PROGRESS_FILE):
    with open(PROGRESS_FILE, "r") as f:
        seed_raw = f.read().strip()
        seed = int(seed_raw, 16) if seed_raw.startswith("0x") else int(seed_raw)
    print(f"[🔁] Retomando do seed: {hex(seed)}")
else:
    seed = 123456789  # seed inicial padrão
    print(f"[🚀] Iniciando com seed padrão: {hex(seed)}")

# Loop de busca
attempts = 0
while True:
    attempts += 1

    # LCG passo
    seed = (MULTIPLIER * seed + INCREMENT) % MODULUS
    value = START + seed

    if not (1 <= value < N):
        continue

    private_key_bytes = value.to_bytes(32, 'big')

    try:
        key = Key.from_bytes(private_key_bytes)
        address = key.address

        if address == TARGET_ADDRESS:
            print("\n🎯 ENCONTRADO!")
            print(f"Chave Privada (hex): {private_key_bytes.hex()}")
            print(f"Valor decimal: {value}")
            print(f"WIF: {key.to_wif()}")
            print(f"Endereço: {address}")

            # Salvar resultado
            with open("resultado.txt", "w") as f:
                f.write("🎯 CHAVE ENCONTRADA!\n")
                f.write(f"Chave Privada (hex): {private_key_bytes.hex()}\n")
                f.write(f"Valor decimal: {value}\n")
                f.write(f"WIF: {key.to_wif()}\n")
                f.write(f"Endereço: {address}\n")

            break

        # A cada 10.000 tentativas, salva progresso
        if attempts % 10000 == 0:
            print(f"Tentativas: {attempts:,} | Último valor testado: {value}")
            with open(PROGRESS_FILE, "w") as f:
                f.write(hex(seed))

    except Exception as e:
        print(f"[!] Erro: {e}")

Para saber mais sobre a biblioteca Bit para manipulação de chaves Bitcoin em Python, visite o site oficial do desenvolvedor.