@CanalQb no YouTube

Gerador de Chaves Bitcoin: Entropia, WIF e Validação SECP256k1

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

Gerador de Chaves Bitcoin com Verificação de Entropia e WIF

Este artigo apresenta um código em Python para gerar chaves privadas Bitcoin, validá-las com base na curva SECP256k1, medir a entropia binária e converter resultados para o formato WIF (Wallet Import Format). Desenvolvido com foco em segurança e padrões técnicos, o script inclui: controle de progresso, ruptura ao encontrar um endereço-alvo e limpeza de memória com gc.collect(). Ideal para desenvolvedores, pesquisadores e entusiastas de criptografia avançada.

Bibliotecas e Ferramentas Utilizadas

• math: cálculo de entropia com log2.
• gc: gestão de memória para evitar vazamentos.
• random e time: geração de números aleatórios com semente baseada em nanossegundos.
• bit: biblioteca para manipulação de chaves Bitcoin (criador: bit).

Casos de Uso e Fluxo do Script

1. Carrega o valor anterior de progresso (arquivo progresso.txt).
2. Define intervalos binários de 75‑bits fixos: valores mínimo e máximo.
3. No loop principal: atualiza sementes aleatórias para cada iteração.
4. Calcula número de partes a gerar: ia + ab, onde ia vem de leitura, ab é acumulador.
5. Gera intervalos binários aleatórios e filtra aqueles com padrão adequado (validar_sequencia evita sequências repetitivas).
6. Mede entropia da parte inicial (calculate_binary_entropy).
7. Se entropia entre 0.9 e 1, converte para inteiro; cria objeto Key, extrai wif e address.
8. Procura por endereço alvo “19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG”.
9. Se encontrado, salva dados em achou.txt, exibe mensagem de interrupção e finaliza.
10. Salva progresso periodicamente (a cada 100 000 loops) e reinicia ciclo após um milhão de tentativas.
11. Utiliza gc.collect() para liberar memória e prevenir uso excessivo.

Funções e Algoritmos Principais

1. validar_sequencia(seq)

Filtra sequências binárias com muitos bits repetidos: evitando “000000”, “111111”, e exigindo ao menos um padrão “00”. Isso reduz repetição e aumenta aleatoriedade real.

2. calculate_binary_entropy(bits)

Calcula entropia binária com frequência relativa de 0s e 1s:

• Remove zeros à esquerda (lstrip("0")).
• Conta ocorrências de 0 e 1.
• Usa fórmula Shannon:
  entropy = –∑ p·log₂(p).
• Retorna valor entre 0.0 e 1.0 (máxima aleatoriedade).

3. Progresso e Persistência

Funções salvar_progresso e ler_progresso preservam o valor de ia, permitindo reinício sem perda de dados em casos de interrupção ou falha.

Como Interpretar os Resultados

• Entropia próxima de 1: alta aleatoriedade.
• WIF: formato útil para importar no Bitcoin Core ou carteiras compatíveis.
• Address: o endereço Bitcoin gerado.
• Intervalo binário: sequência utilizada para gerar chave.

Exemplo de Saída

12345 linhas em 12345: 1001010110... - Wif: L1aW4... - 1BitcoinAddr...
…Loop: 2000000  
Progresso salvo no loop 2000000  
Reiniciando loop...
🎯 Achou!

Impacto da Entropia na SegurançaBTC

Alta entropia significa chaves menos previsíveis e mais resistentes à ataques por força bruta. A filtragem de padrões repetitivos (>6 zeros ou uns) evita geração de chaves fracas, essenciais para segurança real em blockchain.

Nota de Responsabilidade

Aviso: este conteúdo é educativo e técnico. Não utilize ou transfira fundos para chaves geradas sem entender completamente os riscos. Realize sua própria análise antes de aplicar em ambientes reais ou investimentos.

Recursos e Referências Oficiais

• Biblioteca bit
• Wallet Import Format – Wiki Bitcoin
• Repositório Oficial de BIPs

import math
import gc
import random
import time
from bit import Key

def validar_sequencia(seq):
    return '000000' not in seq and '111111' not in seq and '00' in seq

def calculate_binary_entropy(bits):
    """Calcula a entropia binária usando a contagem de bits '0' e '1'."""
    bits = bits.lstrip("0")
    bit_counts = {'0': bits.count('0'), '1': bits.count('1')}
    total_bits = len(bits)

    if bit_counts['0'] == 0 or bit_counts['1'] == 0:
        return 0.0

    probabilities = [bit_counts[b] / total_bits for b in '01']
    entropy = -sum(p * math.log2(p) for p in probabilities)
    return entropy

def salvar_progresso(ia):
    with open('progresso.txt', 'w') as f:
        f.write(str(ia))

def ler_progresso():
    try:
        with open('progresso.txt', 'r') as f:
            return int(f.read())
    except FileNotFoundError:
        return 1

inicio_bin = '100000000000000000000000000000000000000000000000000000000000000000000'
fim_bin = '111111111111111111111111111111111111111111111111111111111111111111111'

ab = 0 

ia = ler_progresso()
ab = 0

while True:
    random.seed(time.time_ns())
    ab += ia
    quantidade_de_partes = ia + ab

    inicio = int(inicio_bin, 2)
    fim = int(fim_bin, 2) + 1

    if quantidade_de_partes == 0:
        for parte_inicio in range(inicio, fim + 1):
            parte_fim = parte_inicio
            intervalo_binario = (bin(parte_inicio)[2:], bin(parte_fim)[2:])

            entropy = calculate_binary_entropy(intervalo_binario[0])
            int_key = int(intervalo_binario[0], 2)
            key = Key.from_int(int_key)
            wif = key.to_wif()
            target = key.address  
            hex_key = key.to_bytes().hex()

            print(f" {quantidade_de_partes} Parte: \t{intervalo_binario[0]} - Entropia: {entropy} - Wif: {wif} - {target}", end='\r')

    else:
        intervalos = []
        for _ in range(quantidade_de_partes):
            parte_inicio = random.randint(inicio, fim - 2)
            parte_fim = random.randint(parte_inicio + 1, fim - 1)
            intervalo_binario = (bin(parte_inicio)[2:], bin(parte_fim)[2:])
            intervalos.append(intervalo_binario)

        wif = "-"
        target = "-"
        ini = "-"

        for idx, (ini, fin) in enumerate(intervalos):
            if not validar_sequencia(ini):
                continue

            entropy = calculate_binary_entropy(ini)
            if 0.9 < entropy < 1:
                int_key = int(ini, 2)
                key = Key.from_int(int_key)
                wif = key.to_wif()
                target = key.address

                if target == '19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG':
                    print('\nAchou!')

                    salvar_progresso(ia + 1)

                    with open('achou.txt', 'a') as f:
                        f.write(f"Loop: {ia}\n")
                        f.write(f"Chave binária: {ini}\n")
                        f.write(f"Entropia: {entropy}\n")
                        f.write(f"WIF: {wif}\n")
                        f.write(f"Endereço: {target}\n")
                        f.write('-' * 60 + '\n')
                    break

    print(f"{ab} linhas em {quantidade_de_partes}: {ini} - Wif: {wif} - {target}", end='\r')

    if ia % 100000 == 0:
        salvar_progresso(ia + 1)
        print(f"\nProgresso salvo no loop {ia}")

    if ia >= 1000000:
        ia = 1
        ab = 0
        salvar_progresso(ia)
        print("\nReiniciando loop...")

    else:
        ia += 1  # incremento manual

    gc.collect()