Chaves Estendidas

Ruby

require 'openssl' # HMAC
require 'ecdsa'   # sudo gem install ecdsa

# ----
# Semente
# ----
seed = "67f93560761e20617de26e0cb84f7234aaf373ed2e66295c3d7397e6d7ebe882ea396d5d293808b0defd7edd2babd4c091ad942e6a9351e6d075a29d4df872af"
puts "seed: #{seed}"
puts

# --------------------
# Gerar Chaves Mestras
# --------------------
hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA512.new, "Bitcoin seed", [seed].pack("H*"))
master_private_key = hmac[0..63]
master_chain_code = hmac[64..-1]

master_public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(master_private_key.to_i(16))
master_public_key = ECDSA::Format::PointOctetString.encode(master_public_key, compression: true).unpack("H*")[0]

puts "master_chain_code:  #{master_chain_code}"
puts "master_private_key: #{master_private_key}"
puts "master_public_key:  #{master_public_key}"
puts

# --------------------------
# Chave Privada Estendida Filha
# --------------------------
parent_private_key = master_private_key
parent_chain_code  = master_chain_code
i = 0

# Normal
if i < 2**31
    point = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(parent_private_key.to_i(16))
    point = ECDSA::Format::PointOctetString.encode(point, compression: true).unpack("H*")[0]
    data = [point].pack("H*") + [i].pack("N")
end

# Endurecida
if i >= 2**31
  data = ["00"].pack("H*") + [parent_private_key].pack("H*") + [i].pack("N")
end

key = [parent_chain_code].pack("H*")
hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA512.new, key, data)
il = hmac[0..63]
ir = hmac[64..-1]

child_chain_code = ir

if child_chain_code.to_i(16) >= ECDSA::Group::Secp256k1.order
    raise "O chain code é maior que a ordem da curva. Tente o próximo índice."
end

child_private_key = (il.to_i(16) + parent_private_key.to_i(16)) % ECDSA::Group::Secp256k1.order
child_private_key = child_private_key.to_s(16).rjust(64, '0')

if child_private_key.to_i(16) == 0
    raise "A chave privada filha é zero. Tente o próximo índice."
end

child_public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(child_private_key.to_i(16))
child_public_key = ECDSA::Format::PointOctetString.encode(child_public_key, compression: true).unpack("H*")[0]

puts "child_chain_code:   #{child_chain_code}"
puts "child_private_key:  #{child_private_key}"
puts "child_public_key:   #{child_public_key}"
puts

# -------------------------
# Chave Pública Estendida Filha
# -------------------------
parent_public_key = master_public_key
parent_chain_code = master_chain_code
i = 0

if i >= 2**31
    raise "Não é possível criar chaves públicas filhas endurecidas a partir de chaves públicas pai."
end

key = [parent_chain_code].pack("H*")
data = [parent_public_key].pack("H*") + [i].pack("N")

hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA512.new, key, data)
il = hmac[0..63]
ir = hmac[64..-1]

child_chain_code = hmac[64..-1]

if il.to_i(16) >= ECDSA::Group::Secp256k1.order
    raise "O resultado do digest é maior que a ordem da curva. Tente o próximo índice."
end

point_hmac   = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(il.to_i(16))
point_public = ECDSA::Format::PointOctetString.decode([parent_public_key].pack("H*"), ECDSA::Group::Secp256k1)
point = point_hmac.add_to_point(point_public)

if (point == ECDSA::Group::Secp256k1.infinity)
    raise "O ponto da chave pública filha está no ponto de infinito. Tente o próximo índice."
end

child_public_key = ECDSA::Format::PointOctetString.encode(point, compression: true).unpack("H*")[0]

puts "child_chain_code:   #{child_chain_code}"
puts "child_public_key:   #{child_public_key}"
puts

# --------------------------
# Serialização de Chave Estendida
# --------------------------
require 'digest'

def create_fingerprint(parent_public_key)
    hash160 = Digest::RMD160.digest(Digest::SHA256.digest([parent_public_key].pack("H*")))
    fingerprint = hash160[0...4].unpack("H*").join
    return fingerprint
end

def hash256(hex)
    binary = [hex].pack("H*")
    hash1 = Digest::SHA256.digest(binary)
    hash2 = Digest::SHA256.digest(hash1)
    result = hash2.unpack("H*")[0]
    return result
end

def checksum(hex)
    hash = hash256(hex)
    return hash[0...8]
end

def base58_encode(hex)
    chars = %w[
      1 2 3 4 5 6 7 8 9
    A B C D E F G H   J K L M N   P Q R S T U V W X Y Z
    a b c d e f g h i j k   m n o p q r s t u v w x y z
    ]
    base = chars.length

    i = hex.to_i(16)
    buffer = String.new

    while i > 0
        remainder = i % base
        i = i / base
        buffer = chars[remainder] + buffer
    end

    leading_zero_bytes = (hex.match(/^([0]+)/) ? $1 : '').size / 2

    ("1"*leading_zero_bytes) + buffer
end

parent_public_key = master_public_key

chain_code  = child_chain_code
private_key = child_private_key

version     = "0488ade4"
depth       = "01"
fingerprint = create_fingerprint(parent_public_key)
childnumber = "00000000"
chain_code  = chain_code
key         = "00" + private_key

serialized = version + depth + fingerprint + childnumber + chain_code + key
extended_private_key = base58_encode(serialized + checksum(serialized))

puts "extended_private_key: #{extended_private_key}"

PHP

<?php
// Nota: Requer https://github.com/Bit-Wasp/secp256k1-php

// ------------------
// Seed para Chave Mestra
// ------------------

$seed = "67f93560761e20617de26e0cb84f7234aaf373ed2e66295c3d7397e6d7ebe882ea396d5d293808b0defd7edd2babd4c091ad942e6a9351e6d075a29d4df872af";
echo "seed: $seed".PHP_EOL;
echo PHP_EOL;

// Hasheie através de HMAC-SHA512 e divida em duas metades
//
//             seed
//              |
//            |----|
//            |HMAC|
//            |----|
//              |
// |    priv    | chain code |
//
$hmac = hash_hmac("sha512", hex2bin($seed), "Bitcoin seed"); // algo, data, key, raw_output (opcional)
$master_private_key = substr($hmac, 0, 64); // primeira metade é a chave privada
$master_chain_code = substr($hmac, 64);     // segunda metade é o chain code
//
// m (priv, chain_code)
//
echo "master_chain_code:  $master_chain_code".PHP_EOL;
echo "master_private_key: $master_private_key".PHP_EOL;

// Use matemática de curva elíptica para ir da chave privada para a chave pública
//
// priv -> pub
//
$context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); // define contexto da curva
$point = null; secp256k1_ec_pubkey_create($context, $point, hex2bin($master_private_key)); // obtém o ponto da chave pública
$serialized = ''; secp256k1_ec_pubkey_serialize($context, $serialized, $point, SECP256K1_EC_COMPRESSED); // serializa para chave pública comprimida
$master_public_key = bin2hex($serialized);

//
// m (priv, pub, chain_code)
//
echo "master_public_key:  $master_public_key".PHP_EOL;
echo PHP_EOL;

// ---------------------------------------------------------
// Chave Privada Estendida Pai para Chave Privada Estendida Filha (m/0)
// ---------------------------------------------------------
// m (priv, pub, chain code)
// |
// m/0 (priv, pub, chain code)
$parent_private_key = $master_private_key; // obtém chave privada do pai
$parent_chain_code  = $master_chain_code;   // obtém chain code do pai
$i = 0;                                    // índice desta filha em relação ao pai

// Filha Normal (chave pública estendida pode derivar suas chaves públicas)
if ($i < 2**31) { // primeira metade dos índices possíveis são filhas normais
    // Obtém o ponto da chave pública para a chave privada pai
    $parent_public_key = $master_public_key; // você pode derivar isto da chave privada pai usando matemática de curva elíptica
    // Os 'data' para o próximo HMAC são a chave pública pai + índice
    //  data = | chave pública pai (33 bytes) | i (4 bytes) |
    $data = pack("H*", $parent_public_key).pack("N", $i);
}

// Filha Endurecida (chave pública estendida não pode derivar suas chaves públicas)
if ($i >= 2**31 ) { // segunda metade dos índices possíveis são filhas endurecidas
    //  data = | 00 | chave privada pai (32 bytes) | i (4 bytes) |
    $data = pack("H*", "00").pack("H*", $master_private_key).pack("N", $i);
}

// Coloque data (chave pública ou privada) e chain code através de HMAC-SHA512
$hmac = hash_hmac("sha512", $data, hex2bin($parent_chain_code)); // algo, data, key
$left = substr($hmac, 0, 64);
$right = substr($hmac, 64);

// Chain code filho é o lado direito do HMAC-SHA512
// m
// |
// m/0 (chain code)
$child_chain_code = $right;
echo "child_chain_code:   $child_chain_code".PHP_EOL;

// Verifica se o chain code filho é válido (não maior que o número de pontos na curva)
if (hexdec($child_chain_code) >= 115792089237316195423570985008687907852837564279074904382605163141518161494337) {
    throw new Exception("Chain code filho é maior ou igual à ordem da curva elíptica. Tente o próximo índice.");
}

// Calcula a chave privada filha (lado esquerdo do hmac + chave privada pai) % ordem
function bchexdec($hex) { // função utilitária para trabalhar com adição de grandes números hexadecimais
    if(strlen($hex) == 1) {
        return hexdec($hex);
    } else {
        $remain = substr($hex, 0, -1);
        $last = substr($hex, -1);
        return bcadd(bcmul(16, bchexdec($remain)), hexdec($last));
    }
}

function bcdechex($dec) { // função utilitária para converter grande inteiro de volta para hexadecimal
    $last = bcmod($dec, 16);
    $remain = bcdiv(bcsub($dec, $last), 16);

    if($remain == 0) {
        return dechex($last);
    } else {
        return bcdechex($remain).dechex($last);
    }
}

// chave privada filha = (left + chave privada pai) % ordem
// m
// |
// m/0 (priv)
$add = bcadd(bchexdec($left), bchexdec($parent_private_key)); // adiciona lado esquerdo do hmac à chave privada pai
$mod = bcmod($add, "115792089237316195423570985008687907852837564279074904382605163141518161494337"); // módulo pela ordem da curva
$child_private_key = str_pad(bcdechex($mod), 64, "0", STR_PAD_LEFT); // garante 64 caracteres (preenche com zeros)

// Verifica se a chave privada filha é válida (diferente de zero)
if (hexdec($child_private_key === 0)) {
    throw new Exception("Chave privada filha é zero (então é inválida). Tente o próximo índice.");
}
echo "child_private_key:  $child_private_key".PHP_EOL;

// calcula a chave pública filha correspondente a partir desta chave privada filha
// m
// |
// m/0 (pub)
$context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); // define contexto da curva
$point = null; secp256k1_ec_pubkey_create($context, $point, hex2bin($child_private_key)); // obtém o ponto da chave pública
$serialized = ''; secp256k1_ec_pubkey_serialize($context, $serialized, $point, SECP256K1_EC_COMPRESSED); // serializa para chave pública comprimida
$child_public_key = bin2hex($serialized);
echo "child_public_key:   $child_public_key".PHP_EOL; // nota: pode precisar preencher hex
echo PHP_EOL;

// -------------------------------------------------------
// Chave Pública Estendida Pai para Chave Pública Estendida Filha (m/0)
// -------------------------------------------------------
// m -------- p (pub, chain code)
//            |
//            p/0 (pub, chain code)
$parent_public_key = $master_public_key; // obtém chave pública do pai
$parent_chain_code = $master_chain_code; // obtém chain code do pai
$i = 0;                                  // índice desta filha em relação ao pai

// Verifica se você não está tentando criar uma chave pública filha endurecida
if ($i >= 2**31) {
    throw new Exception("Não é possível criar uma chave pública filha estendida endurecida. Filhas endurecidas de chave privada estendida são privadas.");
}

// Coloca data (chave pública pai + i) e chain code através de HMAC-SHA512
$hmac = hash_hmac("sha512", pack("H*", $parent_public_key).pack("N", $i), hex2bin($parent_chain_code)); // mesmos dados de quando se cria chave privada estendida filha normal
$left = substr($hmac, 0, 64);
$right = substr($hmac, 64);

// Chain code filho é o lado direito do HMAC-SHA512
// m -------- p
//            |
//            |p/0 (chain code)
$child_chain_code = $right;
echo "child_chain_code:   $child_chain_code".PHP_EOL;

// Verifica se o chain code filho é válido (não maior ou igual ao número de pontos na curva)
if (hexdec($child_chain_code) >= 115792089237316195423570985008687907852837564279074904382605163141518161494337) {
    throw new Exception("Chain code filho é maior ou igual à ordem da curva elíptica. Tente o próximo índice.");
}

// Calcula a chave pública filha: ponto(chave pública pai) + hmac left
// m -------- p
//            |
//            |p/0 (pub)

// ponto (chave pública pai)
$context = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);                 // define contexto da curva
$point_public = null; secp256k1_ec_pubkey_parse($context, $point_public, hex2bin($parent_public_key));  // ponto(chave pública pai)

// adiciona ponto(hmac left) ao ponto(chave pública pai)
secp256k1_ec_pubkey_tweak_add($context, $point_public, hex2bin($left)); // adiciona hmac left ao ponto da chave pública pai
$add = ''; secp256k1_ec_pubkey_serialize($context, $add, $point_public, SECP256K1_EC_COMPRESSED); // serializa para chave comprimida
$child_public_key = unpack("H*", $add)[1];
echo "child_public_key:   $child_public_key".PHP_EOL;
echo PHP_EOL;

// ----------------------
// Serializar Chave Estendida
// ----------------------
$parent_public_key = $master_public_key; // necessário para criar fingerprint

$chain_code = $child_chain_code;
$private_key = $child_private_key;

// | version | depth  | parent fingerprint |  index  | chain code | key (private or public) |
// | 4 bytes | 1 byte |      4 bytes       | 4 bytes |  32 bytes  |        33 bytes         |  = 78 bytes

function create_fingerprint($parent_public_key) {
    $hash160 = hash("ripemd160", hash("sha256", hex2bin($parent_public_key), true)); // hash160 da chave pública pai
    return substr($hash160, 0, 8); // retorna primeiros 4 bytes (8 caracteres hex)
}

$version     = "0488ade4";               // 0488ade4 = privada (xprv), 0488b21e = pública (xpub)
$depth       = "01";                     // quantas vezes esta filha foi derivada da chave mestra (0 = chave mestra)
$fingerprint = create_fingerprint($parent_public_key); // fingerprint da chave pai
$index       = "00000000";               // índice desta chave filha em relação ao pai (string hexadecimal de 4 bytes)
$chain_code  = $chain_code;              // chain code para esta chave
$key         = "00".$private_key;        // chave privada ou pública para serializar (prefixo 0x00 para privada)

// Serializa os dados
$serialized = $version.$depth.$fingerprint.$index.$chain_code.$key;

// Cria um checksum (hasheia duas vezes com sha256 e pega os primeiros 4 bytes)
$checksum = substr(hash("sha256", hash("sha256", hex2bin($serialized), true)), 0, 8);

// Codifica em Base58 o serializado+checksum
function base58_encode($hex){
    $base58chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

    if (strlen($hex) == 0) {
        return '';
    }

    // Converte a string hex para um inteiro base10
    $num = gmp_strval(gmp_init($hex, 16), 58);

    // Verifica se o número não é apenas 0 - o que seria todo padding.
    if ($num != '0') {
        $num = strtr($num, '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv', $base58chars);
    }
    else {
        $num = '';
    }

    // Preenche os 1's iniciais
    $pad = '';
    $n = 0;
    while (substr($hex, $n, 2) == '00') {
        $pad .= '1';
        $n += 2;
    }

    return $pad . $num;
}

$master_extended_private_key = base58_encode($serialized.$checksum);
echo "master_extended_private_key: $master_extended_private_key".PHP_EOL;