Gerador de Chaves Bitcoin com Verificação de Endereço

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

Gerador de Chaves Privadas Bitcoin com Validação de Endereço

Este projeto em Python é um gerador de chaves privadas para Bitcoin que trabalha com intervalos binários e busca um endereço-alvo específico. Ele oferece suporte à verificação de padrões binários, salvamento de progresso e geração de WIFs e endereços Bitcoin válidos utilizando a biblioteca bit.

⚙️ Funcionalidades do Script

Geração aleatória de chaves privadas dentro de intervalos personalizados.
Conversão de chaves para formato WIF e derivação de endereços Bitcoin.
Verificação automática contra um endereço-alvo informado.
Salvamento de progresso para retomada posterior.
Forçamento de padrões binários opcionais como “10001”.

🔐 Sobre a Curva Elíptica SECP256k1

O Bitcoin utiliza a curva elíptica secp256k1 para derivar endereços públicos a partir de chaves privadas. A ordem do grupo dessa curva é:

115792089237316195423570985008687907852837564279074904382605163141518161494337

Este valor define os limites válidos para uma chave privada. O script garante que os valores gerados estejam dentro desse limite.

📂 Explicação dos Principais Componentes

1. Salvamento de Progresso

Permite que você continue a varredura de onde parou, salvando o índice em hexadecimal no arquivo progresso.txt.

2. Geração de Chave com Padrão

É possível forçar a inclusão do padrão binário 10001 dentro da chave privada. Isso pode ser útil em testes ou experimentações com algoritmos otimizados.

3. Conversão e Verificação

O script usa a biblioteca bit para gerar WIFs e endereços Bitcoin a partir da chave privada gerada. Caso o endereço corresponda ao endereço-alvo, os dados são salvos automaticamente no arquivo chave_encontrada.txt.

🧠 Observações Importantes

Atenção: O processo de encontrar uma chave que corresponda a um endereço Bitcoin específico por tentativa e erro é computacionalmente inviável e é classificado como ataque de chave privada, o que não é recomendado fora de contextos educacionais ou experimentais.

Este conteúdo é meramente educacional e visa demonstrar como funcionam algoritmos de geração de chaves na blockchain. Jamais utilize esse tipo de ferramenta para tentar acessar carteiras que não são suas. E lembre-se: investir ou explorar sistemas que você não compreende plenamente pode resultar em perdas. Faça sempre uma autoanálise antes de qualquer ação.

🧪 Exemplo de Execução


target_address = '19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG'
inicio_bin = '1000000000000000000000000000000000000000000000000000000000000000'
fim_bin = '1111111111111111111111111111111111111111111111111111111111111111'
gerar_wif_e_enderecos_unicos(inicio_bin, fim_bin, target_address)

🧬 Código Completo do Projeto

import secrets
from bit import Key

GROUP_ORDER = 115792089237316195423570985008687907852837564279074904382605163141518161494337

def salvar_progresso(indice_atual):
    with open("progresso.txt", "w") as f:
        f.write(hex(indice_atual))

def carregar_progresso():
    try:
        with open("progresso.txt", "r") as f:
            progresso_hex = f.read().strip()
            return int(progresso_hex, 16) if progresso_hex else 0
    except FileNotFoundError:
        return 0

def gerar_chave_unica(inicio, fim, forcar_padrao=False):
    while True:
        chave_aleatoria = secrets.randbelow(fim - inicio + 1) + inicio
        if forcar_padrao:
            binario = format(chave_aleatoria, '064b')
            if '10001' in binario:
                return chave_aleatoria
        return chave_aleatoria

def gerar_wif_e_endereco(chave_privada):
    chave = Key.from_int(chave_privada)
    return chave.to_wif(), chave.address

def salvar_wif_em_arquivo(chave_wif, endereco):
    with open("chave_encontrada.txt", "w") as f:
        f.write(f"WIF: {chave_wif}\nEndereço: {endereco}\n")
    print("Chave WIF e Endereço salvos em 'chave_encontrada.txt'.")

def gerar_wif_e_enderecos_unicos(inicio_bin, fim_bin, target_address):
    inicio = int(inicio_bin, 2)
    fim = int(fim_bin, 2)
    
    if inicio < 0 or fim >= GROUP_ORDER:
        print(f"Intervalo inválido! Deve estar entre 0 e {GROUP_ORDER-1}.")
        return None, None

    inicio_atual = carregar_progresso()
    total_iteracoes = fim - inicio + 1

    for i in range(inicio_atual, fim + 1):
        if i % 100 == 0:
            chave_privada = gerar_chave_unica(inicio, fim, forcar_padrao=True)
        else:
            chave_privada = gerar_chave_unica(inicio, fim)

        chave_wif, endereco = gerar_wif_e_endereco(chave_privada)
        binario_64 = format(chave_privada, '064b')
        print(f"Procurando... Binário: {binario_64} | WIF: {chave_wif} | Endereço: {endereco}", end="\r")

        if endereco == target_address:
            print(f"\nEndereço encontrado! Binário: {binario_64} | WIF: {chave_wif} - Endereço: {endereco}")
            salvar_wif_em_arquivo(chave_wif, endereco)
            return chave_wif, endereco

        salvar_progresso(i)

        if i % (total_iteracoes // 10) == 0:
            print(f"Limpeza de memória aos {i} passos...")

    print("\nEndereço não encontrado no intervalo especificado.")
    return None, None

Formulário de contato

Gerador de Chaves Bitcoin com Verificação de Endereço