@CanalQb no YouTube

Como Converter Chaves Hexadecimais para Casascius Mini com Base58

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

Conversão de Chaves Hexadecimais para Casascius Mini com Base58

Este artigo apresenta uma explicação detalhada sobre como converter uma chave privada em formato hexadecimal para o formato Casascius Mini, utilizando a codificação Base58. O conteúdo inclui o código-fonte em Python com validações e exemplos, sendo ideal para entusiastas de criptografia e desenvolvedores interessados em tecnologias como Bitcoin.

Entendendo o Base58

A codificação Base58 é amplamente utilizada no ecossistema Bitcoin para representar dados binários de forma legível, sem incluir caracteres ambíguos como 0 (zero), O (letra o), I (i maiúsculo) e l (L minúsculo). O objetivo é tornar os dados mais seguros contra erros de digitação ou visualização.

O que é a Casascius Mini?

A Casascius Mini é um tipo de chave privada condensada, com 30 caracteres codificados em Base58. Ela foi popularizada por casas de moedas físicas de Bitcoin. Sua conversão segura entre hexadecimal e Base58 é essencial para evitar perdas de fundos.

Funções em Python para Conversão

Segue abaixo um exemplo funcional em Python que realiza as conversões entre hexadecimal e Casascius Mini:

import hashlib

BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

def hex_to_base58(hex_string):
    """Converte uma string hexadecimal para base58 (Casascius Mini)"""
    if len(hex_string) != 64:
        raise ValueError("A chave hexadecimal deve ter exatamente 64 caracteres (32 bytes).")

    num = int(hex_string, 16)
    base58_string = ""

    while num > 0:
        num, remainder = divmod(num, 58)
        print(f"DEBUG: num={num}, remainder={remainder}, base58_char={BASE58[remainder]}")
        try:
            base58_string = BASE58[remainder] + base58_string
        except IndexError:
            print(f"❌ Erro crítico: remainder fora do intervalo! remainder = {remainder}")
            return None

    while len(base58_string) < 30:
        base58_string = BASE58[0] + base58_string

    return base58_string

def base58_to_hex(base58_string):
    """Converte uma chave Casascius Mini (base58) para hexadecimal"""
    num = 0
    for char in base58_string:
        num *= 58
        num += BASE58.index(char)

    hex_string = hex(num)[2:].zfill(64)
    return hex_string

Função para Geração e Validação

def GenerateKeys():
    tipo_chave = input(
        "Escolha Privatekey ou a Casascius Mini\nDigite 1 para hexadecimal ou 2 para Casascius Mini: ").strip()

    if tipo_chave == "1":
        chave_privada_original_hex = input(
            "Digite a chave privada no formato hexadecimal (até 64 caracteres): ").strip().lower()

        if len(chave_privada_original_hex) < 64:
            chave_privada_original_hex = chave_privada_original_hex.zfill(64)

        if len(chave_privada_original_hex) != 64:
            print("Erro: A chave hexadecimal deve ter exatamente 64 caracteres.")
            return

        casascius_30 = hex_to_base58(chave_privada_original_hex)
        print("Chave Privada Original (hex):", chave_privada_original_hex)
        print("Casascius Mini 30:", casascius_30)

        chave_privada_descompactada_hex = base58_to_hex(casascius_30)
        print("Chave Privada Descompactada (hex):", chave_privada_descompactada_hex)

        assert chave_privada_original_hex == chave_privada_descompactada_hex, \
            "Erro: A chave descompactada não é a mesma que a original."
        print("✅ A chave privada descompactada corresponde à chave original.")

    elif tipo_chave == "2":
        casascius_input = input("Digite a chave Casascius Mini (30 caracteres): ").strip()

        if len(casascius_input) != 30:
            print("Erro: A chave Casascius Mini deve ter exatamente 30 caracteres.")
            return

        chave_privada_original_hex = base58_to_hex(casascius_input)
        print("Chave Privada Original (hex):", chave_privada_original_hex)

        casascius_30 = hex_to_base58(chave_privada_original_hex)
        print("Casascius Mini 30:", casascius_30)

        chave_privada_descompactada_hex = base58_to_hex(casascius_30)
        print("Chave Privada Descompactada (hex):", chave_privada_descompactada_hex)

        assert chave_privada_original_hex == chave_privada_descompactada_hex, \
            "Erro: A chave descompactada não é a mesma que a original."
        print("✅ A chave privada descompactada corresponde à chave original.")

    else:
        print("Opção inválida. Por favor, digite 1 ou 2.")

GenerateKeys()

Exemplo de Uso

Suponha que você tenha a seguinte chave hexadecimal:

6f1b8f7c3ac89e71a4db30cc3c34256f6a1b8f7c3ac89e71a4db30cc3c34256f

Ao executar a função hex_to_base58(), você obterá a chave em formato Casascius Mini. Em seguida, pode reverter usando base58_to_hex() para garantir que os dados sejam idênticos ao original.

Considerações de Segurança

Ao manipular chaves privadas, sempre tenha em mente os seguintes pontos:

• Evite armazenar ou compartilhar chaves privadas em ambientes inseguros.
• Utilize computadores offline ou air-gapped para esse tipo de operação, se possível.
• Verifique sempre se a conversão entre formatos preserva a integridade da chave.

Fontes e Créditos

Este artigo utiliza conceitos abertos da comunidade Bitcoin. Você pode aprender mais sobre Base58 no site oficial do Bitcoin: https://en.bitcoin.it/wiki/Base58Check_encoding.

Aviso: Este conteúdo é educativo e técnico. Cada pessoa deve fazer sua própria análise antes de manipular ou converter qualquer tipo de chave. Não compartilhe chaves privadas publicamente.