@CanalQb no YouTube

Como Realizar Busca Kangaroo em Chaves Bitcoin com Python e Curva secp256k1

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

Introdução à Busca Kangaroo em Chaves Bitcoin com Python

Neste artigo, apresentamos um exemplo prático de como realizar uma busca do tipo "kangaroo" para encontrar chaves privadas Bitcoin dentro de um intervalo específico, utilizando operações sobre a curva elíptica secp256k1. O código em Python faz uso da biblioteca bit para manipular chaves Bitcoin e implementa funções matemáticas essenciais para trabalhar com pontos na curva elíptica, como adição, duplicação e multiplicação escalar.

Parâmetros da Curva secp256k1

A curva secp256k1 é a base criptográfica do Bitcoin, definida pelos parâmetros:

• Gx e Gy: coordenadas do ponto gerador (gerador base).
• n: ordem do grupo gerado pelo ponto G.
• p: primo que define o campo finito.
• Bits: parâmetro relacionado ao tamanho do intervalo de busca.

Valores utilizados no código:

• Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
• Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
• n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
• p = 2²⁵⁶ - 2³² - 977
• Bits = 361

Chave Pública Comprimida e Endereço Alvo

O exemplo utiliza uma chave pública comprimida alvo e um endereço Bitcoin correspondentes para testar a busca:

• Chave pública comprimida: 03f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530
• Endereço Bitcoin alvo: 1PitScNLyp2HCygzadCh7FveTnfmpPbfp8

Intervalo de Busca Estimado

O intervalo definido para a busca é:

• Início: 0x20 (32 decimal)
• Fim: 0x3f (63 decimal)

Este intervalo pode ser ajustado conforme a necessidade para aumentar a abrangência da pesquisa.

Funções Matemáticas Essenciais

Para trabalhar com pontos na curva elíptica, o código inclui funções fundamentais:

• Inverse: cálculo do inverso modular, usado para operações aritméticas no campo finito.
• dblpt: duplicação de ponto na curva, necessária para a multiplicação escalar.
• addpt: soma de dois pontos distintos na curva.
• ptmul: multiplicação escalar de um ponto pela chave privada, base para gerar a chave pública.

Função para Descompressão de Chave Pública

Como a chave pública alvo está no formato comprimido, uma função converte esse formato para as coordenadas completas (x, y), essenciais para comparações e cálculos:

• getuncompressedpub(compressed_key) – converte chave comprimida em chave pública completa.

Processo de Busca Kangaroo

O objetivo é encontrar um valor kangarooPrivKey dentro do intervalo dado que satisfaça a condição para que a chave pública gerada corresponda ao endereço alvo. O cálculo é feito usando a fórmula:

RealPrivKey = kangarooPrivKey * 2^Bits + rangeBegin (mod n)

O script tenta cada valor no intervalo, gera o endereço correspondente e compara com o alvo, exibindo resultados parciais a cada 100 tentativas para acompanhar o progresso.

Exemplo Prático do Código

from bit import Key

# Parâmetros da curva secp256k1
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
p = 2**256 - 2**32 - 977
Bits = 361

pub_compressed = '03f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530'
target_address = '1PitScNLyp2HCygzadCh7FveTnfmpPbfp8'

rangeBegin = 0x20
rangeEnd = 0x3f

def inverse(x, p):
    inv1, inv2 = 1, 0
    while p != 1 and p != 0:
        quotient = x // p
        inv1, inv2 = inv2, inv1 - inv2 * quotient
        x, p = p, x % p
    return inv2

def dblpt(pt, p):
    if pt is None:
        return None
    (x, y) = pt
    if y == 0:
        return None
    slope = (3 * x * x) * pow(2 * y, p - 2, p)
    x_r = (slope * slope - 2 * x) % p
    y_r = (slope * (x - x_r) - y) % p
    return (x_r, y_r)

def addpt(p1, p2, p):
    if p1 is None: return p2
    if p2 is None: return p1
    (x1, y1) = p1
    (x2, y2) = p2
    if x1 == x2 and y1 == y2:
        return dblpt(p1, p)
    if x1 == x2:
        return None
    slope = ((y2 - y1) * pow(x2 - x1, p - 2, p)) % p
    x_r = (slope * slope - x1 - x2) % p
    y_r = (slope * (x1 - x_r) - y1) % p
    return (x_r, y_r)

def ptmul(pt, scalar, p):
    acc = None
    current = pt
    while scalar:
        if scalar & 1:
            acc = addpt(acc, current, p)
        current = dblpt(current, p)
        scalar >>= 1
    return acc

def getuncompressedpub(compressed_key):
    y_parity = int(compressed_key[:2], 16) - 2
    x = int(compressed_key[2:], 16)
    a = (pow(x, 3, p) + 7) % p
    y = pow(a, (p + 1) // 4, p)
    if y % 2 != y_parity:
        y = (-y) % p
    return (x, y)

print("Inicializando busca kangaroo para o endereço:", target_address)

(pubx, puby) = getuncompressedpub(pub_compressed)
print("Chave pública alvo (x):", hex(pubx))

for kangarooPrivKey in range(rangeBegin, rangeEnd + 1):
    RealPrivKey = (kangarooPrivKey * (2**Bits) + rangeBegin) % n
    key = Key.from_int(RealPrivKey)
    addr = key.address

    if addr == target_address:
        print("\n🚀 ENCONTRADO!")
        print("KangarooPrivKey:", hex(kangarooPrivKey))
        print("Chave privada (int):", hex(RealPrivKey))
        print("WIF:", key.to_wif())
        print("Endereço:", addr)
        break

    if kangarooPrivKey % 100 == 0:
        print(f"Testando {hex(kangarooPrivKey)} → {addr}")

else:
    print("\n❌ Não encontrado no intervalo definido.")

Considerações Finais

Este tutorial prático demonstra como aplicar técnicas matemáticas e a biblioteca bit para a busca e validação de chaves privadas Bitcoin. A busca kangaroo é uma das estratégias para explorar intervalos específicos, importante em pesquisas criptográficas e segurança.

Atenção: Este conteúdo é para fins educacionais. Investir em criptomoedas requer análise cuidadosa e compreensão dos riscos envolvidos. Nunca invista valores que não pode perder.

Para mais estudos sobre criptografia e Bitcoin, acompanhe fontes oficiais e documentações confiáveis.