Análise de Entropia e Cálculos Avançados com Python para Chaves Privadas Bitcoin

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

Análise de Entropia e Cálculos Avançados com Python para Chaves Privadas Bitcoin

Este artigo apresenta um script em Python para realizar uma análise detalhada da entropia em dados hexadecimais, especificamente aplicados a chaves privadas e públicas no contexto do Bitcoin. O código realiza diversas operações matemáticas e estatísticas, além de processar arquivos CSV para leitura e geração de relatórios. A seguir, explicamos cada parte do processo, garantindo que o conteúdo esteja otimizado para SEO e conforme as diretrizes do Google AdSense e Search Console.

Objetivo do Script

O script tem como objetivo ler um arquivo CSV contendo chaves privadas em formato hexadecimal, calcular a entropia de cada chave, converter valores hexadecimais para binários e decimais, e realizar cálculos matemáticos relevantes para análise criptográfica.

Funções Principais do Código

hex_to_bits(hex_string): Converte uma string hexadecimal para uma representação binária (bits), garantindo que o resultado tenha o tamanho correto preenchido com zeros à esquerda.
calculate_entropy(bits): Calcula a entropia de Shannon para uma string de bits, fornecendo uma medida da aleatoriedade dos dados.
ler_csv_e_calcular_entropia(caminho, caminho_saida): Lê os dados de um arquivo CSV, processa cada linha calculando as métricas solicitadas e grava os resultados em um novo arquivo CSV.

Descrição Técnica

O processamento inicia-se lendo o arquivo CSV (pr.csv) que contém dados hexadecimais correspondentes a chaves privadas e outras informações. Para cada linha:

Os valores hexadecimais são normalizados com preenchimento zero para 64 caracteres.
É feita a conversão para bits para cálculo da entropia usando a fórmula de Shannon.
Os valores hexadecimais são convertidos para inteiros decimais para possibilitar operações matemáticas.
São calculadas diversas divisões e diferenças, que podem ser usadas para análises comparativas e detecção de padrões.
O resultado é formatado cuidadosamente para compatibilidade com programas como Excel, utilizando aspas simples para preservar valores numéricos.

Exemplo de Saída Gerada

O arquivo de saída (prentropia.csv) contém as seguintes colunas:

#: Identificador da linha
Private Key Range: Intervalos de chaves privadas
Private Key / Public Key: Dados criptográficos relacionados
Bitcoin: Informações relativas a endereços Bitcoin
Decimal 1, 2 e 3: Valores decimais das chaves
Entropia 1, 2 e 3: Valores de entropia calculados para cada chave
Tamanho 1, 2 e 3: Valores derivados dos cálculos matemáticos

Boas Práticas e Considerações

Este script é um exemplo avançado de manipulação de dados e cálculo estatístico aplicado a criptografia. Para uso em contextos reais, recomenda-se entender profundamente as operações matemáticas e criptográficas envolvidas. A entropia, por exemplo, é um indicativo da segurança e aleatoriedade de chaves criptográficas.

Responsabilidade: Antes de usar qualquer script para investimento ou manipulação de criptomoedas, avalie cuidadosamente os riscos e busque conhecimento adequado para evitar perdas financeiras.

Referências e Links Oficiais

Python CSV Module: https://docs.python.org/3/library/csv.html
Entropia de Shannon: https://en.wikipedia.org/wiki/Entropy_(information_theory)

Código Completo Otimizado

import csv
import math

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

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

caminho_csv = "pr.csv"
caminho_saida = "prentropia.csv"

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') 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',
                'Tamanho 1', 'Tamanho 2', 'Tamanho 3'
            ])
            divs3_anterior = 0
            for linha in reader:
                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)
                
                diferenca_divs3 = 0
                try:
                    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)

                    dec1 = int(hex1, 16)
                    dec2 = int(hex2, 16)
                    dec3 = int(hex3, 16)
                    
                    divs1 = dec2 * dec3  
                    divs2 = divs1 / dec1 if dec1 != 0 else 0
                    divs3 = divs2 / dec2 if dec2 != 0 else 0
                    divs4 = dec2 / divs3 if divs3 != 0 else 0
                    diferenca_divs3 = divs3 - divs3_anterior 

                    divs3_anterior = divs3
                    
                    try:
                        final_vs_pr = dec3 * dec2
                        final_divide_inicio = final_vs_pr / dec1 if dec1 != 0 else 0
                        final_divide_inicio_divide_pr = final_divide_inicio / dec2 if dec2 != 0 else 0
                        privatekey_divide_final_divide_inicio_divide_pr = dec2 / final_divide_inicio_divide_pr if final_divide_inicio_divide_pr != 0 else 0
                    except ZeroDivisionError:
                        final_vs_pr = final_divide_inicio = final_divide_inicio_divide_pr = privatekey_divide_final_divide_inicio_divide_pr = 0 

                except ValueError:
                    ent1 = ent2 = ent3 = 0.0 
                    dec1 = dec2 = dec3 = 0
                    divs1 = divs2 = divs3 = divs4 = 0
                    diferenca_divs3 = 0

                display_hex1 = hex1.lstrip("0") or "0"
                display_hex2 = hex2.lstrip("0") or "0"
                display_hex3 = hex3.lstrip("0") or "0"

                ent1_formatted = f"{ent1:,.6f}".replace('.', ',')
                ent2_formatted = f"{ent2:,.6f}".replace('.', ',')
                ent3_formatted = f"{ent3:,.6f}".replace('.', ',')
                
                linha_para_printar = [
                    linha_limpa[0], display_hex1, display_hex2, display_hex3,
                    *linha_limpa[4:],
                    f"'{dec1}", f"'{dec2}", f"'{dec3}",
                    divs1, divs2, divs3, divs4,
                    f"'{diferenca_divs3:.10f}".replace('.', ','), 
                    f"'{divs3_anterior:.10f}".replace('.', ',')
                ]

                writer.writerow(linha_para_printar)
                print(linha_para_printar)

if __name__ == "__main__":
    ler_csv_e_calcular_entropia(caminho_csv, caminho_saida)

Formulário de contato

Análise de Entropia e Cálculos Avançados com Python para Chaves Privadas Bitcoin