@CanalQb no YouTube

Geração Aleatória de Chaves Bitcoin com Validação por Endereço

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

Como Gerar Chaves Bitcoin Aleatórias e Validadas em Python

Este conteúdo explora a criação e validação de chaves privadas Bitcoin utilizando um algoritmo em Python com a biblioteca bit. O objetivo é identificar chaves cuja conversão resulta em endereços que correspondam a critérios específicos, como prefixos ou endereços-alvo conhecidos.

Entendendo o Objetivo do Script

O script gera chaves privadas com padrões binários controlados, valida sua estrutura, converte para o formato hexadecimal, e finalmente testa os endereços gerados a partir dessas chaves. O foco está na aleatoriedade e controle de entropia, evitando padrões fáceis de prever, como longas repetições de bits.

Bibliotecas Utilizadas

• bit: gera chaves privadas e converte para WIF.
• random: cria padrões binários aleatórios.
• time: garante que cada sequência seja baseada em um timestamp exclusivo.
• os e sys: gerenciamento de arquivos e reinicialização controlada.

Lógica de Geração das Chaves

A chave binária gerada possui 70 bits, onde o primeiro bit é sempre ‘1’ (evitando números inválidos). Em seguida, 33 bits '1' adicionais são distribuídos aleatoriamente nas posições restantes:

seq = ['0'] * 70
seq[0] = '1'
indices = random.sample(range(1, 70), 33)
for idx in indices:
    seq[idx] = '1'

Essa abordagem gera milhares de combinações únicas e evita padrões binários repetitivos como “000000” ou “111111”.

Validação e Conversão

Após a geração de uma sequência binária válida, o script:

1. Converte o binário para hexadecimal com 64 caracteres.
2. Gera uma chave privada com Key.from_hex().
3. Extrai o endereço Bitcoin correspondente (key.address).
4. Converte a chave para WIF para importação em carteiras Bitcoin.

Filtro e Salvamento de Resultados

• Se o endereço começa com “19”, ele é armazenado no arquivo 19.txt.
• Se o endereço corresponder ao alvo (ex: 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG), a chave é salva com WIF em chaves_wif_enderecos.txt.

Este tipo de pesquisa é frequentemente utilizado em estudos de segurança de chaves e testes de vulnerabilidade. Embora encontrar um endereço específico por tentativa e erro seja computacionalmente impraticável em contextos reais, essa abordagem serve como ferramenta educacional sobre como funciona a conversão de chaves privadas em endereços.

Exemplo de Saída no Terminal

45: 101000110101001... - 1HvWj... 
🎯 78: 110100100... 34 bits - L1eZ... - 19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG

Considerações Finais

Este projeto demonstra como criar scripts robustos para geração de chaves Bitcoin aleatórias e filtragem por critérios. Ele pode ser útil para desenvolvedores, pesquisadores em segurança e estudantes de blockchain.

Aviso: Este conteúdo tem caráter educacional. Não utilize chaves geradas sem conhecimento profundo. Investimentos em criptomoedas devem ser baseados em autoanálise e compreensão individual dos riscos envolvidos.

Referências e Ferramentas Oficiais

• bit – Biblioteca Python para Bitcoin
• Wallet Import Format – Wiki Bitcoin

import os
import sys
from bit import Key
import binascii
import random
import time
loop = 1000
def validar_sequencia(seq):
    # Verifica se há sequências de zeros ou uns maiores que 5
    return '000000' not in seq and '111111' not in seq and '00' in seq

def gerar_sequencias_randomizadas():
    # Lista para armazenar sequências válidas
    sequencias_validas = set()  # Usamos um conjunto para evitar duplicatas
    
    while len(sequencias_validas) < loop + 1:  # Limite de 101 sequências válidas
        # Usa o tempo atual em milissegundos como semente para gerar números aleatórios
        timestamp = int(time.time() * 1000)  # Timestamp em milissegundos
        random.seed(timestamp)  # Define a semente para o gerador de números aleatórios
        
        # Gera uma sequência aleatória
        seq = ['0'] * 70
        seq[0] = '1'  # Garantir que o primeiro elemento é '1'
        
        # Posiciona aleatoriamente 33 uns adicionais
        indices = random.sample(range(1, 70), 33)
        for idx in indices:
            seq[idx] = '1'
        seq = ''.join(seq)
        
        # Verificar validade
        if validar_sequencia(seq):
            sequencias_validas.add(seq)
    
    return list(sequencias_validas)

sequencias = gerar_sequencias_randomizadas()

# Endereço a ser procurado
endereco_desejado = '19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG'

# Percorre as sequências 
for i, seq in enumerate(sequencias):
    # Converte a chave binária para hexadecimal
    hex_key = hex(int(seq, 2))[2:].zfill(64)  # Remove o prefixo '0x' e ajusta o tamanho

    # Cria uma chave privada usando a biblioteca bit
    key = Key.from_hex(hex_key)

    # Obtém o formato WIF da chave privada
    wif = key.to_wif()
    address = key.address  # Corrigido para chamar address como propriedade
    print(f"{i+1}: {seq} - {address}", end='\r') 
    
    # Verifica se o endereço começa com "19"
    if address.startswith("19"):
        # Salva no arquivo '19.txt'
        with open('19.txt', 'a') as f:
            f.write(f"{i+1};{seq};{address}\n")
    
    # Verifica se o endereço é o desejado
    if address == endereco_desejado:
        # Quando encontrar o endereço desejado, abre o arquivo para salvar
        with open('chaves_wif_enderecos.txt', 'a') as f:
            # Salva WIF e endereço no arquivo
            f.write(f"Sequência {i+1}: {seq} - WIF: {wif} - Endereço: {address}\n")
        
        # Exibe a sequência, WIF e endereço no console
        print(f"{i+1}: {seq} {seq.count('1')} - {wif} - {address}")
        break
        sys.exit(1)
    
    # Condição para reiniciar o script (exemplo: a cada 100 iterações)
    if i > 0 and i % loop == 0: 
        time.sleep(2)  # Aguarda um pouco antes de reiniciar o script
        sys.exit(0)  # Finaliza o script de maneira controlada para reiniciar com script1.py