bip32.h File Reference

#include "btc.h"
#include "chain.h"
#include <stdint.h>

Go to the source code of this file.

Data Structures
struct	btc_hdnode

Macros
#define	BTC_BIP32_CHAINCODE_SIZE   32
#define	btc_hdnode_private_ckd_prime(X, I)   btc_hdnode_private_ckd((X), ((I) | 0x80000000))

Functions
LIBBTC_API btc_bool	btc_hdnode_public_ckd (btc_hdnode *inout, uint32_t i)
LIBBTC_API btc_bool	btc_hdnode_from_seed (const uint8_t *seed, int seed_len, btc_hdnode *out)
LIBBTC_API btc_bool	btc_hdnode_private_ckd (btc_hdnode *inout, uint32_t i)
LIBBTC_API void	btc_hdnode_fill_public_key (btc_hdnode *node)
LIBBTC_API void	btc_hdnode_serialize_public (const btc_hdnode *node, const btc_chain *chain, char *str, int strsize)
LIBBTC_API void	btc_hdnode_serialize_private (const btc_hdnode *node, const btc_chain *chain, char *str, int strsize)
LIBBTC_API btc_bool	btc_hdnode_deserialize (const char *str, const btc_chain *chain, btc_hdnode *node)
LIBBTC_API btc_bool	btc_hd_generate_key (btc_hdnode *node, const char *keypath, const uint8_t *privkeymaster, const uint8_t *chaincode)
	derive btc_hdnode including private key from master private key More...

Macro Definition Documentation

#define BTC_BIP32_CHAINCODE_SIZE   32

Copyright (c) 2013-2014 Tomas Dzetkulic Copyright (c) 2013-2014 Pavol Rusnak Copyright (c) 2015 Douglas J. Bakkumk Copyright (c) 2015 Jonas Schnelli

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Definition at line 39 of file bip32.h.

Referenced by btc_hd_generate_key(), btc_hdnode_deserialize(), btc_hdnode_from_seed(), btc_hdnode_private_ckd(), btc_hdnode_public_ckd(), and btc_hdnode_serialize().

#define btc_hdnode_private_ckd_prime	(		X,
			I
	)		btc_hdnode_private_ckd((X), ((I) | 0x80000000))

Definition at line 52 of file bip32.h.

Referenced by btc_hd_generate_key().

Function Documentation

LIBBTC_API btc_bool btc_hd_generate_key	(	btc_hdnode *	node,
		const char *	keypath,
		const uint8_t *	privkeymaster,
		const uint8_t *	chaincode
	)

derive btc_hdnode including private key from master private key

Definition at line 245 of file bip32.c.

References BTC_BIP32_CHAINCODE_SIZE, BTC_ECKEY_PKEY_LENGTH, btc_hdnode_fill_public_key(), btc_hdnode_private_ckd(), btc_hdnode_private_ckd_prime, btc_hdnode::chain_code, btc_hdnode::child_num, btc_hdnode::depth, btc_hdnode::fingerprint, btc_hdnode::private_key, and strlens.

{
    static char delim[] = "/";
    static char prime[] = "phH\'";
    static char digits[] = "0123456789";
    uint64_t idx = 0;
    assert(strlens(keypath) < 1024);
    char* pch, *kp = malloc(strlens(keypath) + 1);

    if (!kp) {
        return false;
    }

    if (strlens(keypath) < strlens("m/")) {
        goto err;
    }

    memset(kp, 0, strlens(keypath) + 1);
    memcpy(kp, keypath, strlens(keypath));

    if (kp[0] != 'm' || kp[1] != '/') {
        goto err;
    }

    node->depth = 0;
    node->child_num = 0;
    node->fingerprint = 0;
    memcpy(node->chain_code, chaincode, BTC_BIP32_CHAINCODE_SIZE);
    memcpy(node->private_key, privkeymaster, BTC_ECKEY_PKEY_LENGTH);
    btc_hdnode_fill_public_key(node);

    pch = strtok(kp + 2, delim);
    while (pch != NULL) {
        size_t i = 0;
        int prm = 0;
        for (; i < strlens(pch); i++) {
            if (strchr(prime, pch[i])) {
                if (i != strlens(pch) - 1) {
                    goto err;
                }
                prm = 1;
            } else if (!strchr(digits, pch[i])) {
                goto err;
            }
        }

        idx = strtoull(pch, NULL, 10);
        if (idx > UINT32_MAX) {
            goto err;
        }

        if (prm) {
            if (btc_hdnode_private_ckd_prime(node, idx) != true) {
                goto err;
            }
        } else {
            if (btc_hdnode_private_ckd(node, idx) != true) {
                goto err;
            }
        }
        pch = strtok(NULL, delim);
    }
    free(kp);
    return true;

err:
    free(kp);
    return false;
}

LIBBTC_API btc_bool btc_hdnode_deserialize	(	const char *	str,
		const btc_chain *	chain,
		btc_hdnode *	node
	)

Definition at line 216 of file bip32.c.

References btc_chain::b58prefix_bip32_privkey, btc_chain::b58prefix_bip32_pubkey, btc_base58_decode_check(), BTC_BIP32_CHAINCODE_SIZE, BTC_ECKEY_COMPRESSED_LENGTH, BTC_ECKEY_PKEY_LENGTH, btc_hdnode_fill_public_key(), btc_hdnode::chain_code, btc_hdnode::child_num, btc_hdnode::depth, btc_hdnode::fingerprint, btc_hdnode::private_key, btc_hdnode::public_key, and read_be().

{
    uint8_t node_data[strlen(str)];
    memset(node, 0, sizeof(btc_hdnode));
    size_t outlen = 0;

    outlen = btc_base58_decode_check(str, node_data, sizeof(node_data));
    if (!outlen) {
        return false;
    }
    uint32_t version = read_be(node_data);
    if (version == chain->b58prefix_bip32_pubkey) { // public node
        memcpy(node->public_key, node_data + 45, BTC_ECKEY_COMPRESSED_LENGTH);
    } else if (version == chain->b58prefix_bip32_privkey) { // private node
        if (node_data[45]) {                                // invalid data
            return false;
        }
        memcpy(node->private_key, node_data + 46, BTC_ECKEY_PKEY_LENGTH);
        btc_hdnode_fill_public_key(node);
    } else {
        return false; // invalid version
    }
    node->depth = node_data[4];
    node->fingerprint = read_be(node_data + 5);
    node->child_num = read_be(node_data + 9);
    memcpy(node->chain_code, node_data + 13, BTC_BIP32_CHAINCODE_SIZE);
    return true;
}

LIBBTC_API void btc_hdnode_fill_public_key

(

btc_hdnode *

node

)

Definition at line 178 of file bip32.c.

References BTC_ECKEY_COMPRESSED_LENGTH, ecc_get_pubkey(), btc_hdnode::private_key, and btc_hdnode::public_key.

Referenced by btc_hd_generate_key(), btc_hdnode_deserialize(), btc_hdnode_from_seed(), and btc_hdnode_private_ckd().

{
    size_t outsize = BTC_ECKEY_COMPRESSED_LENGTH;
    ecc_get_pubkey(node->private_key, node->public_key, &outsize, true);
}

LIBBTC_API btc_bool btc_hdnode_from_seed	(	const uint8_t *	seed,
		int	seed_len,
		btc_hdnode *	out
	)

Definition at line 61 of file bip32.c.

References BTC_BIP32_CHAINCODE_SIZE, BTC_ECKEY_PKEY_LENGTH, btc_hdnode_fill_public_key(), btc_hdnode::chain_code, btc_hdnode::child_num, btc_hdnode::depth, ecc_verify_privatekey(), btc_hdnode::fingerprint, hmac_sha512(), and btc_hdnode::private_key.

{
    uint8_t I[BTC_ECKEY_PKEY_LENGTH + BTC_BIP32_CHAINCODE_SIZE];
    memset(out, 0, sizeof(btc_hdnode));
    out->depth = 0;
    out->fingerprint = 0x00000000;
    out->child_num = 0;
    hmac_sha512((const uint8_t*)"Bitcoin seed", 12, seed, seed_len, I);
    memcpy(out->private_key, I, BTC_ECKEY_PKEY_LENGTH);

    if (!ecc_verify_privatekey(out->private_key)) {
        memset(I, 0, sizeof(I));
        return false;
    }

    memcpy(out->chain_code, I + BTC_ECKEY_PKEY_LENGTH, BTC_BIP32_CHAINCODE_SIZE);
    btc_hdnode_fill_public_key(out);
    memset(I, 0, sizeof(I));
    return true;
}

LIBBTC_API btc_bool btc_hdnode_private_ckd	(	btc_hdnode *	inout,
		uint32_t	i
	)

Definition at line 124 of file bip32.c.

References BTC_BIP32_CHAINCODE_SIZE, BTC_ECKEY_COMPRESSED_LENGTH, BTC_ECKEY_PKEY_LENGTH, btc_hdnode_fill_public_key(), btc_hdnode::chain_code, btc_hdnode::child_num, btc_hdnode::depth, ecc_private_key_tweak_add(), ecc_verify_privatekey(), btc_hdnode::fingerprint, hmac_sha512(), btc_hdnode::private_key, btc_hdnode::public_key, ripemd160(), sha256_Raw(), and write_be().

Referenced by btc_hd_generate_key().

{
    uint8_t data[1 + BTC_ECKEY_PKEY_LENGTH + 4];
    uint8_t I[BTC_ECKEY_PKEY_LENGTH + BTC_BIP32_CHAINCODE_SIZE];
    uint8_t fingerprint[BTC_BIP32_CHAINCODE_SIZE];
    uint8_t p[BTC_ECKEY_PKEY_LENGTH], z[BTC_ECKEY_PKEY_LENGTH];

    if (i & 0x80000000) { // private derivation
        data[0] = 0;
        memcpy(data + 1, inout->private_key, BTC_ECKEY_PKEY_LENGTH);
    } else { // public derivation
        memcpy(data, inout->public_key, BTC_ECKEY_COMPRESSED_LENGTH);
    }
    write_be(data + BTC_ECKEY_COMPRESSED_LENGTH, i);

    sha256_Raw(inout->public_key, BTC_ECKEY_COMPRESSED_LENGTH, fingerprint);
    ripemd160(fingerprint, 32, fingerprint);
    inout->fingerprint = (fingerprint[0] << 24) + (fingerprint[1] << 16) +
                         (fingerprint[2] << 8) + fingerprint[3];

    memset(fingerprint, 0, sizeof(fingerprint));
    memcpy(p, inout->private_key, BTC_ECKEY_PKEY_LENGTH);

    hmac_sha512(inout->chain_code, BTC_BIP32_CHAINCODE_SIZE, data, sizeof(data), I);
    memcpy(inout->chain_code, I + BTC_ECKEY_PKEY_LENGTH, BTC_BIP32_CHAINCODE_SIZE);
    memcpy(inout->private_key, I, BTC_ECKEY_PKEY_LENGTH);

    memcpy(z, inout->private_key, BTC_ECKEY_PKEY_LENGTH);

    int failed = 0;
    if (!ecc_verify_privatekey(z)) {
        failed = 1;
        return false;
    }

    memcpy(inout->private_key, p, BTC_ECKEY_PKEY_LENGTH);
    if (!ecc_private_key_tweak_add(inout->private_key, z)) {
        failed = 1;
    }

    if (!failed) {
        inout->depth++;
        inout->child_num = i;
        btc_hdnode_fill_public_key(inout);
    }

    memset(data, 0, sizeof(data));
    memset(I, 0, sizeof(I));
    memset(p, 0, sizeof(p));
    memset(z, 0, sizeof(z));
    return true;
}

LIBBTC_API btc_bool btc_hdnode_public_ckd	(	btc_hdnode *	inout,
		uint32_t	i
	)

Definition at line 83 of file bip32.c.

References BTC_BIP32_CHAINCODE_SIZE, BTC_ECKEY_COMPRESSED_LENGTH, btc_hdnode::chain_code, btc_hdnode::child_num, btc_hdnode::depth, ecc_public_key_tweak_add(), btc_hdnode::fingerprint, hmac_sha512(), btc_hdnode::private_key, btc_hdnode::public_key, ripemd160(), sha256_Raw(), and write_be().

{
    uint8_t data[1 + 32 + 4];
    uint8_t I[32 + BTC_BIP32_CHAINCODE_SIZE];
    uint8_t fingerprint[32];

    if (i & 0x80000000) { // private derivation
        return false;
    } else { // public derivation
        memcpy(data, inout->public_key, BTC_ECKEY_COMPRESSED_LENGTH);
    }
    write_be(data + BTC_ECKEY_COMPRESSED_LENGTH, i);

    sha256_Raw(inout->public_key, BTC_ECKEY_COMPRESSED_LENGTH, fingerprint);
    ripemd160(fingerprint, 32, fingerprint);
    inout->fingerprint = (fingerprint[0] << 24) + (fingerprint[1] << 16) + (fingerprint[2] << 8) + fingerprint[3];

    memset(inout->private_key, 0, 32);

    int failed = 0;
    hmac_sha512(inout->chain_code, 32, data, sizeof(data), I);
    memcpy(inout->chain_code, I + 32, BTC_BIP32_CHAINCODE_SIZE);


    if (!ecc_public_key_tweak_add(inout->public_key, I))
        failed = false;

    if (!failed) {
        inout->depth++;
        inout->child_num = i;
    }

    // Wipe all stack data.
    memset(data, 0, sizeof(data));
    memset(I, 0, sizeof(I));
    memset(fingerprint, 0, sizeof(fingerprint));

    return failed ? false : true;
}

LIBBTC_API void btc_hdnode_serialize_private	(	const btc_hdnode *	node,
		const btc_chain *	chain,
		char *	str,
		int	strsize
	)

Definition at line 209 of file bip32.c.

References btc_chain::b58prefix_bip32_privkey, and btc_hdnode_serialize().

{
    btc_hdnode_serialize(node, chain->b58prefix_bip32_privkey, 0, str, strsize);
}

LIBBTC_API void btc_hdnode_serialize_public	(	const btc_hdnode *	node,
		const btc_chain *	chain,
		char *	str,
		int	strsize
	)

Definition at line 203 of file bip32.c.

References btc_chain::b58prefix_bip32_pubkey, and btc_hdnode_serialize().

{
    btc_hdnode_serialize(node, chain->b58prefix_bip32_pubkey, 1, str, strsize);
}