---

@CanalQb no YouTube

---

Geração de Chaves Bitcoin com Entropia em Python

---

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

---

Geração de Chaves Bitcoin com Entropia em Python

A geração segura de chaves privadas é um dos fundamentos da segurança no universo das criptomoedas. Este artigo apresenta um script avançado em Python que utiliza matemática aplicada, curva elíptica SECP256k1, entropia binária e validação criptográfica para gerar chaves privadas, convertê-las em formato WIF (Wallet Import Format) e derivar endereços públicos Bitcoin válidos.

Conceitos Envolvidos

Este script envolve diversos conceitos importantes:

• Curvas elípticas (SECP256k1): utilizadas no algoritmo ECDSA para Bitcoin;
• Entropia binária: medida de aleatoriedade útil para avaliar a segurança da chave gerada;
• Base58Check: formato de codificação utilizado para gerar chaves WIF e endereços;
• Compressão de chave pública: otimização usada para reduzir o tamanho do endereço sem perder segurança;
• Validação da chave pública: confirmação matemática de que o ponto pertence à curva SECP256k1.

Sobre o Script

O código começa definindo uma chave privada inicial e gera, de forma incremental, novos valores multiplicando-a por índices aleatórios dentro de um intervalo pré-definido. Para cada iteração:

1. Calcula a chave pública correspondente por multiplicação escalar na curva elíptica;
2. Converte a chave pública em um endereço Bitcoin usando RIPEMD160 e SHA256;
3. Calcula a entropia binária da chave privada gerada;
4. Valida a chave pública e imprime informações relevantes, como bit lengths e valores codificados.

Código Python Completo

import math
import random
import base58
import hashlib
from ecdsa import SECP256k1
import time

random.seed(int(time.time() * 1000))

private_key_hex = '100000000000000000'.zfill(64)
private_key = int(private_key_hex, 16)
curve_order = SECP256k1.order()
interval_end = (2 * private_key) - 1

def calcular_entropia_binaria(numero):
    bin_str = bin(numero)[2:].zfill(256)
    total = len(bin_str)
    count_1 = bin_str.count('1')
    count_0 = total - count_1
    p1 = count_1 / total
    p0 = count_0 / total
    entropia = 0
    if p0 > 0:
        entropia -= p0 * math.log2(p0)
    if p1 > 0:
        entropia -= p1 * math.log2(p1)
    return entropia, bin_str

def private_key_to_wif(private_key_hex):
    if private_key_hex.startswith('0x'):
        private_key_hex = private_key_hex[2:]
    if len(private_key_hex) != 64:
        raise ValueError("A chave privada deve ter 64 caracteres hexadecimais.")
    extended_key = '80' + private_key_hex + '01'
    key_bytes = bytes.fromhex(extended_key)
    checksum = hashlib.sha256(hashlib.sha256(key_bytes).digest()).digest()[:4]
    return base58.b58encode(key_bytes + checksum).decode('utf-8')

def scalar_multiplication(private_key, scalar):
    G = SECP256k1.generator
    return G * (private_key * scalar)

def validate_public_key(x, y):
    curve = SECP256k1.curve
    p = curve.p()
    return (y * y) % p == (x * x * x + 7) % p

def public_key_to_address(pub_key):
    x, y = pub_key
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    pub_key_compressed = prefix + x.to_bytes(32, 'big')
    sha256 = hashlib.sha256(pub_key_compressed).digest()
    ripemd160 = hashlib.new('ripemd160', sha256).digest()
    network_byte = b'\x00' + ripemd160
    checksum = hashlib.sha256(hashlib.sha256(network_byte).digest()).digest()[:4]
    return base58.b58encode(network_byte + checksum).decode('utf-8')

def format_private_key(private_key):
    private_key = private_key % curve_order
    return format(private_key, 'x').zfill(64)

def generate_indices(interval_end):
    while True:
        yield random.randint(1, interval_end)

index_generator = generate_indices(interval_end)
for i in index_generator:
    pub_point = scalar_multiplication(private_key, i)
    if pub_point is None:
        print(f"Iteração {i}: Ponto público inválido.")
        continue

    x, y = pub_point.x(), pub_point.y()
    address = public_key_to_address((x, y))
    wif = private_key_to_wif(format_private_key(private_key))
    chave_privada_atual = private_key * i
    entropia, binario = calcular_entropia_binaria(chave_privada_atual)
    chave_privada_formatada = format_private_key(chave_privada_atual)

    print(f" {chave_privada_formatada} 📊 Entropia: {entropia:.6f}")

    if entropia >= 0.8:
        print(f"Iteração {i}")
        if validate_public_key(x, y):
            print(f"  ✅ Chave pública válida")
        else:
            print(f"  ❌ Chave pública inválida")

        print(f"  📌 Entropia (bits usados) ")
        print(f"    - Private key: {(chave_privada_atual).bit_length()} bits")
        print(f"    - Public key x: {x.bit_length()} bits")
        print(f"    - Public key y: {y.bit_length()} bits")

        print(f"  🔐 Private key: {chave_privada_formatada}")
        print(f"  🧾 WIF: {wif}")
        print(f"  🏷️ Address: {address}")
        print(f"  🔢 Binário: '{binario}'")
        print(f"  📊 Entropia: {entropia:.6f}")
        print("-" * 60)

        if address == "19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG":
            print("🎯 Endereço alvo encontrado!")
            break

Validação e Segurança

A função validate_public_key() garante que o ponto gerado pertence à curva SECP256k1, evitando erros críticos no uso real de carteiras. Além disso, a entropia binária serve como métrica de aleatoriedade, permitindo maior confiança na força da chave.

Considerações Importantes

Esse tipo de script é útil para testes, aprendizado e experimentos com criptografia. Não deve ser utilizado para atacar redes ou carteiras reais. Para usos em produção ou investimentos reais, utilize bibliotecas auditadas e conhecidas, como a bit.

Aviso: Sempre faça sua própria análise (autoanálise) antes de investir ou aplicar qualquer tecnologia em ambiente real. Nunca opere com criptomoedas sem pleno entendimento dos riscos envolvidos.