@CanalQb no YouTube

Dividindo Intervalos de Endereços Bitcoin com Python

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

Como Dividir Grandes Intervalos de Endereços Bitcoin com Python

Quando trabalhamos com grandes intervalos de chaves privadas no contexto de Bitcoin, é essencial adotar técnicas eficientes para dividir esse espaço de busca. O script abaixo demonstra como dividir um intervalo de endereços potenciais em blocos menores, salvando os resultados em um arquivo CSV e utilizando psutil para monitoramento de memória.

Objetivo do Script

O código em Python tem como objetivo principal calcular todos os endereços possíveis entre um intervalo de valores (representados como inteiros), dividindo este intervalo em blocos gerenciáveis e exportando os dados para análise futura. Esta técnica é útil em estudos criptográficos, blockchain forensics, e geração de carteiras Bitcoin para testes e auditorias.

Bibliotecas Utilizadas

• psutil: monitora a memória disponível do sistema.
• gc: libera memória entre blocos, aumentando a eficiência.
• csv: grava os blocos calculados em um arquivo .csv.

Funções Principais do Script

1. Calcular Endereços Possíveis

Calcula o total de valores possíveis dentro de um intervalo numérico:

def calcular_enderecos_possiveis(inicio, fim):
    num_enderecos = fim - inicio + 1
    print(f"Existem {num_enderecos} endereços possíveis com 69 bits de entropia.")
    return num_enderecos

2. Dividir o Intervalo em Blocos

Divide os endereços entre início e fim em blocos com tamanho definido (ex: 1 quatrilhão):

def dividir_blocos(inicio, fim, tamanho_bloco):
    blocos = []
    num_enderecos = fim - inicio + 1
    num_blocos = num_enderecos // tamanho_bloco
    if num_enderecos % tamanho_bloco != 0:
        num_blocos += 1
    for i in range(num_blocos):
        bloco_inicio = inicio + i * tamanho_bloco
        bloco_fim = min(bloco_inicio + tamanho_bloco - 1, fim)
        blocos.append((bloco_inicio, bloco_fim))
    return blocos

3. Impressão e Liberação de Memória

Após imprimir os blocos gerados, a função chama gc.collect() para liberar memória:

def imprimir_blocos(blocos):
    for i, bloco in enumerate(blocos):
        print(f"Bloco {i+1}: Endereços de {bloco[0]} a {bloco[1]}")
        gc.collect()

4. Exportar para CSV

O script exporta todos os blocos para um arquivo chamado enderecos_blocos.csv:

def salvar_em_csv(blocos, arquivo_csv):
    with open(arquivo_csv, mode='w', newline='') as file:
        writer = csv.writer(file)
        writer.writerow(["Bloco", "Inicio", "Fim"])
        for i, bloco in enumerate(blocos):
            writer.writerow([i+1, bloco[0], bloco[1]])

Verificação de Memória RAM

Antes de iniciar o processo, o script exibe a memória disponível usando o módulo psutil:

memoria_disponivel = psutil.virtual_memory().available
memoria_disponivel_mb = memoria_disponivel / (1024 ** 2)
print(f"Memória disponível: {memoria_disponivel_mb:.2f} MB")

Configuração Inicial

O intervalo utilizado corresponde a um espaço de 69 bits:

• Início: 295147905179352825856
• Fim: 590295810358705651711
• Tamanho de bloco: 1 quatrilhão (10¹⁵)

Conclusão

Esse tipo de abordagem é ideal para dividir tarefas de alto custo computacional em partes menores, especialmente em projetos relacionados a blockchain ou pesquisa de chaves. O script ainda demonstra boas práticas como uso de garbage collection e monitoramento de memória, evitando sobrecarga do sistema.

Atenção: Este conteúdo é educativo. O uso de técnicas de geração ou análise de chaves deve ser feito com total compreensão dos riscos. Jamais armazene ativos reais em chaves geradas para fins de teste. O julgamento individual é essencial antes de tomar qualquer decisão envolvendo ativos digitais.

Referências

• psutil – Monitoramento de recursos
• csv – Leitura e gravação de arquivos CSV

import psutil
import gc
import csv

# Função que calcula os endereços possíveis entre o intervalo de início e fim
def calcular_enderecos_possiveis(inicio, fim):
    """
    Calcula o número total de endereços possíveis entre o intervalo dado (início e fim).
    """
    num_enderecos = fim - inicio + 1
    print(f"Existem {num_enderecos} endereços possíveis com 69 bits de entropia.")
    return num_enderecos

# Função que divide os endereços possíveis entre o intervalo de início e fim em blocos de tamanho especificado
def dividir_blocos(inicio, fim, tamanho_bloco):
    """
    Divide o intervalo entre 'inicio' e 'fim' em blocos de tamanho especificado.
    """
    num_enderecos = fim - inicio + 1
    blocos = []
    num_blocos = num_enderecos // tamanho_bloco
    if num_enderecos % tamanho_bloco != 0:
        num_blocos += 1  # Se houver sobra, adiciona um bloco extra

    for i in range(num_blocos): 
        bloco_inicio = inicio + i * tamanho_bloco
        bloco_fim = bloco_inicio + tamanho_bloco - 1
        if bloco_fim > fim:
            bloco_fim = fim
        blocos.append((bloco_inicio, bloco_fim))
    
    return blocos

# Função para imprimir os blocos e liberar memória após cada bloco
def imprimir_blocos(blocos):
    """
    Imprime os blocos de endereços e libera a memória após cada bloco.
    """
    for i, bloco in enumerate(blocos):
        bloco_inicio, bloco_fim = bloco
        print(f"Bloco {i+1}: Endereços de {bloco_inicio} a {bloco_fim}")
        gc.collect()  # Libera memória

# Função para salvar os blocos em um arquivo CSV
def salvar_em_csv(blocos, arquivo_csv):
    """
    Salva os blocos de endereços no arquivo CSV.
    """
    with open(arquivo_csv, mode='w', newline='') as file:
        writer = csv.writer(file)
        writer.writerow(["Bloco", "Inicio", "Fim"])  # Cabeçalho
        for i, bloco in enumerate(blocos):
            writer.writerow([i+1, bloco[0], bloco[1]])
    print(f"\n[+] Blocos salvos no arquivo {arquivo_csv}")

# Função principal
def main():
    # Define o intervalo (como decimal)
    inicio = int(295147905179352825856)
    fim = int(590295810358705651711)

    # Define o tamanho do bloco: 1 quatrilhão
    tamanho_bloco = 10**15

    # Verifica a quantidade de memória disponível
    memoria_disponivel = psutil.virtual_memory().available
    memoria_disponivel_mb = memoria_disponivel / (1024 ** 2)
    
    print(f"\n[+] Estimativa de memória disponível: {memoria_disponivel_mb:.2f} MB")
    print(f"[+] Dividindo os endereços entre {inicio} e {fim} em blocos de {tamanho_bloco} endereços.")

    # Calcula o número total de endereços
    calcular_enderecos_possiveis(inicio, fim)

    # Divide os endereços em blocos
    blocos = dividir_blocos(inicio, fim, tamanho_bloco)

    # Imprime os blocos
    imprimir_blocos(blocos)

    # Salva os blocos em um arquivo CSV
    salvar_em_csv(blocos, "enderecos_blocos.csv")

# Corrigido o nome da verificação do main
if __name__ == "__main__":
    main()