Como Calcular Entropia e Converter Chaves Hexadecimais para WIF em Python

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

Como Calcular Entropia e Converter Chaves Hexadecimais para WIF em Python

Este artigo apresenta um script Python completo que realiza cálculos de entropia para chaves em formato hexadecimal, além de converter essas chaves para o formato WIF (Wallet Import Format), muito utilizado em criptografia e Bitcoin.

Introdução

A entropia é uma medida da aleatoriedade de uma sequência de bits, importante para avaliar a segurança de chaves criptográficas. A conversão para WIF facilita o uso das chaves em carteiras Bitcoin. Este guia detalha as funções necessárias para manipular esses dados, utilizando a biblioteca bit.

Dependências Necessárias

Python 3.x
Biblioteca bit: instale com pip install bit
Biblioteca padrão csv e math

Funções do Script

1. Contagem precisa de bits '1' em uma string hexadecimal

Converte cada caractere hexadecimal para ASCII e conta o número de bits 1:

def calcular_bits_1_preciso(hexadecimais):
    soma_total_bits_1 = 0
    hex_cleaned = hexadecimais.strip("'")
    for char in hex_cleaned:
        try:
            valor_ascii = ord(char)
            binario = format(valor_ascii, '08b')
            soma_total_bits_1 += binario.count('1')
        except Exception as e:
            print(f"Erro ao processar caractere '{char}': {e}")
            continue
    return soma_total_bits_1

2. Redução iterativa de um número até um dígito

Usado para simplificar valores:

def reduzir_digitos(numero):
    while numero >= 10:
        numero = sum(int(digito) for digito in str(numero))
    return numero

3. Conversão de hexadecimal para bits

def hex_to_bits(hex_string):
    bin_string = bin(int(hex_string, 16))[2:].zfill(len(hex_string) * 4)
    return bin_string

4. Cálculo da entropia binária

Calcula entropia com base na frequência dos bits 0 e 1:

def calculate_binary_entropy(bits):
    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

5. Cálculo da entropia geral da sequência de bits

def calculate_entropy(bits):
    bit_counts = {'0': bits.count('0'), '1': bits.count('1')}
    total_bits = len(bits)
    probabilities = [bit_counts['0'] / total_bits, bit_counts['1'] / total_bits]
    entropy = -sum(p * math.log2(p) for p in probabilities if p > 0)
    return entropy

6. Conversão de chave hexadecimal para WIF

Usando a biblioteca bit para converter a chave privada hexadecimal para o formato WIF:

def hex_to_wif(hex_private_key):
    try:
        key = Key.from_hex(hex_private_key)
        return key.to_wif()
    except Exception as e:
        print(f"Erro ao converter para WIF: {e}")
        return "Erro"

7. Contagem dos bits significativos na chave

def count_bits(hex_string):
    bits = hex_to_bits(hex_string).zfill(64)
    significant_bits = len(bits.lstrip('0'))
    return significant_bits

Processamento do Arquivo CSV

O script lê um arquivo CSV com colunas contendo chaves em hexadecimal, realiza os cálculos de entropia e conversões, e grava os resultados em um arquivo de saída.

Exemplo de execução principal:

def ler_csv_e_calcular_entropia(caminho, caminho_saida):
    with open(caminho, newline='', encoding='utf-8-sig') as csvfile:
        reader = csv.reader(csvfile, delimiter=';')
        with open(caminho_saida, mode='w', newline='', encoding='utf-8-sig') as outfile:
            writer = csv.writer(outfile, delimiter=';')

            writer.writerow([
                '#', 'Private Key Range', 'Private Key', 'Public Key', 'Bitcoin',
                'Decimal 1', 'Decimal 2', 'Decimal 3',
                'Entropia 1', 'Entropia 2', 'Entropia 3',
                'Entropia Binário 1', 'Entropia Binário 2', 'Entropia Binário 3',
                'Binário 1', 'Binário 2', 'Binário 3', 'WIF 1', 'WIF 2', 'WIF 3',
                'contabithex1', 'contabithex2', 'contabithex3',
                'reduzint1', 'reduzint2', 'reduzint3',
                'final_vs_pr', 'final_divide_inicio', 'final_divide_inicio_divide_pr', 'privatekey_divide_final_divide_inicio_divide_pr'
            ])

            for i, linha in enumerate(reader):
                if i == 0:
                    continue

                linha_limpa = [campo.strip().strip("'") for campo in linha]
                if len(linha_limpa) < 4:
                    continue

                hex1 = linha_limpa[1].zfill(64)
                hex2 = linha_limpa[2].zfill(64)
                hex3 = linha_limpa[3].zfill(64)

                try:
                    if 'Private Key Range' in [hex1, hex2, hex3]:
                        continue

                    bits1 = hex_to_bits(hex1)
                    bits2 = hex_to_bits(hex2)
                    bits3 = hex_to_bits(hex3)

                    ent1 = calculate_entropy(bits1)
                    ent2 = calculate_entropy(bits2)
                    ent3 = calculate_entropy(bits3)

                    ent_bin1 = calculate_binary_entropy(bits1)
                    ent_bin2 = calculate_binary_entropy(bits2)
                    ent_bin3 = calculate_binary_entropy(bits3)

                    wif1 = hex_to_wif(hex1)
                    wif2 = hex_to_wif(hex2)
                    wif3 = hex_to_wif(hex3)

                    bits_count1 = calcular_bits_1_preciso(linha_limpa[1])
                    bits_count2 = calcular_bits_1_preciso(linha_limpa[2])
                    bits_count3 = calcular_bits_1_preciso(linha_limpa[3])

                    reduz1 = reduzir_digitos(int(hex1, 16))
                    reduz2 = reduzir_digitos(int(hex2, 16))
                    reduz3 = reduzir_digitos(int(hex3, 16))

                    final_vs_pr = int(hex3, 16) * int(hex2, 16)
                    final_divide_inicio = final_vs_pr / int(hex1, 16)
                    final_divide_inicio_divide_pr = final_divide_inicio / int(hex2, 16)
                    privatekey_divide_final_divide_inicio_divide_pr = int(hex2, 16) / final_divide_inicio_divide_pr

                except ValueError:
                    ent1 = ent2 = ent3 = ent_bin1 = ent_bin2 = ent_bin3 = 0.0
                    wif1 = wif2 = wif3 = "Erro"
                    bits_count1 = bits_count2 = bits_count3 = 0
                    final_vs_pr = final_divide_inicio = final_divide_inicio_divide_pr = privatekey_divide_final_divide_inicio_divide_pr = 0

                linha_para_printar = [
                    linha_limpa[0],
                    f"'{hex1}",
                    f"'{hex2}",
                    f"'{hex3}",
                    *linha_limpa[4:],
                    f"'{int(hex1, 16)}", f"'{int(hex2, 16)}", f"'{int(hex3, 16)}",
                    f"{ent1:.6f}".replace('.', ','),
                    f"{ent2:.6f}".replace('.', ','),
                    f"{ent3:.6f}".replace('.', ','),
                    f"{ent_bin1:.6f}".replace('.', ','),
                    f"{ent_bin2:.6f}".replace('.', ','),
                    f"{ent_bin3:.6f}".replace('.', ','),
                    f"'{bits1.lstrip('0')}",
                    f"'{bits2.lstrip('0')}",
                    f"'{bits3.lstrip('0')}",
                    wif1,
                    wif2,
                    wif3,
                    bits_count1,
                    bits_count2,
                    bits_count3,
                    reduz1,
                    reduz2,
                    reduz3,
                    final_vs_pr,
                    final_divide_inicio,
                    final_divide_inicio_divide_pr,
                    privatekey_divide_final_divide_inicio_divide_pr
                ]

                writer.writerow(linha_para_printar)
                print(linha_para_printar)

if __name__ == "__main__":
    ler_csv_e_calcular_entropia("pr.csv", "prentropia.csv")

Considerações Finais

Este script é útil para quem trabalha com segurança da informação, criptografia e desenvolvimento de carteiras digitais Bitcoin. A entropia ajuda a validar a qualidade das chaves geradas, enquanto a conversão para WIF permite uso prático em ferramentas compatíveis.

Atenção: Sempre avalie individualmente os riscos antes de manipular ou investir recursos baseados em chaves criptográficas. Use este script para aprendizado e análise técnica, não como conselho financeiro.

Formulário de contato

Como Calcular Entropia e Converter Chaves Hexadecimais para WIF em Python