arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-12-24 23:38:09 +00:00
Code Issues Releases Wiki Activity

crypto: split hdnode_deserialize into hdnode_deserialize_{public,private}

Browse Source
This commit is contained in:
Pavol Rusnak 2020-04-06 16:28:02 +00:00
parent a7806d08d7
commit ff706eb70b
No known key found for this signature in database
GPG Key ID: 91F3B339B9A02A3D
4 changed files with 147 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
crypto/bip32.c
View File

@ -824,7 +824,7 @@ int hdnode_get_shared_key(const HDNode *node, const uint8_t *peer_public_key,
} }
static int hdnode_serialize(const HDNode *node, uint32_t fingerprint, static int hdnode_serialize(const HDNode *node, uint32_t fingerprint,
uint32_t version, char use_public, char *str, uint32_t version, bool use_private, char *str,
int strsize) { int strsize) {
uint8_t node_data[78] = {0}; uint8_t node_data[78] = {0};
write_be(node_data, version); write_be(node_data, version);
@ -832,11 +832,11 @@ static int hdnode_serialize(const HDNode *node, uint32_t fingerprint,
write_be(node_data + 5, fingerprint); write_be(node_data + 5, fingerprint);
write_be(node_data + 9, node->child_num); write_be(node_data + 9, node->child_num);
memcpy(node_data + 13, node->chain_code, 32); memcpy(node_data + 13, node->chain_code, 32);
if (use_public) { if (use_private) {
memcpy(node_data + 45, node->public_key, 33);
} else {
node_data[45] = 0; node_data[45] = 0;
memcpy(node_data + 46, node->private_key, 32); memcpy(node_data + 46, node->private_key, 32);
} else {
memcpy(node_data + 45, node->public_key, 33);
} }
int ret = base58_encode_check(node_data, sizeof(node_data), int ret = base58_encode_check(node_data, sizeof(node_data),
node->curve->hasher_base58, str, strsize); node->curve->hasher_base58, str, strsize);
@ -846,18 +846,18 @@ static int hdnode_serialize(const HDNode *node, uint32_t fingerprint,
int hdnode_serialize_public(const HDNode *node, uint32_t fingerprint, int hdnode_serialize_public(const HDNode *node, uint32_t fingerprint,
uint32_t version, char *str, int strsize) { uint32_t version, char *str, int strsize) {
return hdnode_serialize(node, fingerprint, version, 1, str, strsize); return hdnode_serialize(node, fingerprint, version, false, str, strsize);
} }
int hdnode_serialize_private(const HDNode *node, uint32_t fingerprint, int hdnode_serialize_private(const HDNode *node, uint32_t fingerprint,
uint32_t version, char *str, int strsize) { uint32_t version, char *str, int strsize) {
return hdnode_serialize(node, fingerprint, version, 0, str, strsize); return hdnode_serialize(node, fingerprint, version, true, str, strsize);
} }
// check for validity of curve point in case of public data not performed // check for validity of curve point in case of public data not performed
int hdnode_deserialize(const char *str, uint32_t version_public, static int hdnode_deserialize(const char *str, uint32_t version,
uint32_t version_private, const char *curve, bool use_private, const char *curve, HDNode *node,
HDNode *node, uint32_t *fingerprint) { uint32_t *fingerprint) {
uint8_t node_data[78] = {0}; uint8_t node_data[78] = {0};
memzero(node, sizeof(HDNode)); memzero(node, sizeof(HDNode));
node->curve = get_curve_by_name(curve); node->curve = get_curve_by_name(curve);
@ -865,18 +865,20 @@ int hdnode_deserialize(const char *str, uint32_t version_public,
sizeof(node_data)) != sizeof(node_data)) { sizeof(node_data)) != sizeof(node_data)) {
return -1; return -1;
} }
uint32_t version = read_be(node_data); uint32_t ver = read_be(node_data);
if (version == version_public) { if (ver != version) {
memzero(node->private_key, sizeof(node->private_key)); return -3; // invalid version
memcpy(node->public_key, node_data + 45, 33); }
} else if (version == version_private) { // private node if (use_private) {
if (node_data[45]) { // invalid data // invalid data
if (node_data[45]) {
return -2; return -2;
} }
memcpy(node->private_key, node_data + 46, 32); memcpy(node->private_key, node_data + 46, 32);
memzero(node->public_key, sizeof(node->public_key)); memzero(node->public_key, sizeof(node->public_key));
} else { } else {
return -3; // invalid version memzero(node->private_key, sizeof(node->private_key));
memcpy(node->public_key, node_data + 45, 33);
} }
node->depth = node_data[4]; node->depth = node_data[4];
if (fingerprint) { if (fingerprint) {
@ -887,6 +889,18 @@ int hdnode_deserialize(const char *str, uint32_t version_public,
return 0; return 0;
} }
int hdnode_deserialize_public(const char *str, uint32_t version,
const char *curve, HDNode *node,
uint32_t *fingerprint) {
return hdnode_deserialize(str, version, false, curve, node, fingerprint);
}
int hdnode_deserialize_private(const char *str, uint32_t version,
const char *curve, HDNode *node,
uint32_t *fingerprint) {
return hdnode_deserialize(str, version, true, curve, node, fingerprint);
}
const curve_info *get_curve_by_name(const char *curve_name) { const curve_info *get_curve_by_name(const char *curve_name) {
if (curve_name == 0) { if (curve_name == 0) {
return 0; return 0;

10
crypto/bip32.h
View File

@ -133,9 +133,13 @@ int hdnode_serialize_public(const HDNode *node, uint32_t fingerprint,
int hdnode_serialize_private(const HDNode *node, uint32_t fingerprint, int hdnode_serialize_private(const HDNode *node, uint32_t fingerprint,
uint32_t version, char *str, int strsize); uint32_t version, char *str, int strsize);
int hdnode_deserialize(const char *str, uint32_t version_public, int hdnode_deserialize_public(const char *str, uint32_t version,
uint32_t version_private, const char *curve, const char *curve, HDNode *node,
HDNode *node, uint32_t *fingerprint); uint32_t *fingerprint);
int hdnode_deserialize_private(const char *str, uint32_t version,
const char *curve, HDNode *node,
uint32_t *fingerprint);
void hdnode_get_address_raw(HDNode *node, uint32_t version, uint8_t *addr_raw); void hdnode_get_address_raw(HDNode *node, uint32_t version, uint8_t *addr_raw);
void hdnode_get_address(HDNode *node, uint32_t version, char *addr, void hdnode_get_address(HDNode *node, uint32_t version, char *addr,

217
crypto/tests/test_check.c
View File

@ -1167,8 +1167,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqji" "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqji"
"ChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi"); "ChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
@ -1177,8 +1177,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2" "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2"
"gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8"); "gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1209,8 +1209,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4" "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4"
"cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7"); "cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1218,8 +1218,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP" "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP"
"6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw"); "6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1250,8 +1250,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSx" "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSx"
"qu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs"); "qu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1259,8 +1259,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFH" "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFH"
"KkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ"); "KkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1291,8 +1291,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptW" "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptW"
"mT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM"); "mT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1300,8 +1300,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgq" "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgq"
"FJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5"); "FJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1332,8 +1332,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Ty" "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Ty"
"h8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334"); "h8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1341,8 +1341,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJ" "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJ"
"AyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV"); "AyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1373,8 +1373,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8" "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8"
"kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76"); "kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1382,8 +1382,8 @@ START_TEST(test_bip32_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNT" "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNT"
"EcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"); "EcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1430,8 +1430,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGds" "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGds"
"o3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U"); "o3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1439,8 +1439,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSC" "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSC"
"Gu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB"); "Gu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1472,8 +1472,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT" "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT"
"3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt"); "3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1481,8 +1481,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGm" "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGm"
"XUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH"); "XUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1514,8 +1514,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYE" "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYE"
"eEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9"); "eEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1523,8 +1523,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ" "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ"
"85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a"); "85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1556,8 +1556,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd" "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd"
"25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef"); "25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1565,8 +1565,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5Ew" "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5Ew"
"VvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon"); "VvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1598,8 +1598,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz" "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz"
"7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc"); "7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1607,8 +1607,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJ" "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJ"
"bZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL"); "bZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1640,8 +1640,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw" "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw"
"7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j"); "7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1649,8 +1649,8 @@ START_TEST(test_bip32_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLF" "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLF"
"bdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt"); "bdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1712,8 +1712,8 @@ START_TEST(test_bip32_vector_3) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7" "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7"
"KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6"); "KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1721,8 +1721,8 @@ START_TEST(test_bip32_vector_3) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhR" "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhR"
"oP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13"); "oP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -1738,8 +1738,8 @@ START_TEST(test_bip32_vector_3) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu" "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu"
"2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L"); "2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_private(str, VERSION_PRIVATE, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -1747,8 +1747,8 @@ START_TEST(test_bip32_vector_3) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrAD" "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrAD"
"WgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y"); "WgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
r = hdnode_deserialize(str, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, r = hdnode_deserialize_public(str, VERSION_PUBLIC, SECP256K1_NAME, &node2,
&node2, NULL); NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2716,8 +2716,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3hCznBesA6jBtmoyVFPfyMSZ1qYZ3WdjdebquvkEfmRfxC9VFEFi2YD" "dprv3hCznBesA6jBtmoyVFPfyMSZ1qYZ3WdjdebquvkEfmRfxC9VFEFi2YD"
"aJqHnx7uGe75eGSa3Mn3oHK11hBW7KZUrPxwbCPBmuCi1nwm182s"); "aJqHnx7uGe75eGSa3Mn3oHK11hBW7KZUrPxwbCPBmuCi1nwm182s");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
@ -2727,8 +2727,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZ9169KDAEUnyoBhjjmT2VaEodr6pUTDoqCEAeqgbfr2JfkB88BbK77j" "dpubZ9169KDAEUnyoBhjjmT2VaEodr6pUTDoqCEAeqgbfr2JfkB88BbK77j"
"bTYbcYXb2FVz7DKBdW4P618yd51MwF8DjKVopSbS7Lkgi6bowX5w"); "bTYbcYXb2FVz7DKBdW4P618yd51MwF8DjKVopSbS7Lkgi6bowX5w");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2759,8 +2759,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3kUQDBztdyjKuwnaL3hfKYpT7W6X2huYH5d61YSWFBebSYwEBHAXJkC" "dprv3kUQDBztdyjKuwnaL3hfKYpT7W6X2huYH5d61YSWFBebSYwEBHAXJkC"
"pQ7rvMAxPzKqxVCGLvBqWvGxXjAyMJsV1XwKkfnQCM9KctC8k8bk"); "pQ7rvMAxPzKqxVCGLvBqWvGxXjAyMJsV1XwKkfnQCM9KctC8k8bk");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2769,8 +2769,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZCGVaKZBiMo7pMgLaZm1qmchjWenTeVcUdFQkTNsFGFEA6xs4EW8PKi" "dpubZCGVaKZBiMo7pMgLaZm1qmchjWenTeVcUdFQkTNsFGFEA6xs4EW8PKi"
"qYqP7HBAitt9Hw16VQkQ1tjsZQSHNWFc6bEK6bLqrbco24FzBTY4"); "qYqP7HBAitt9Hw16VQkQ1tjsZQSHNWFc6bEK6bLqrbco24FzBTY4");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2801,8 +2801,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3nRtCZ5VAoHW4RUwQgRafSNRPUDFrmsgyY71A5eoZceVfuyL9SbZe2r" "dprv3nRtCZ5VAoHW4RUwQgRafSNRPUDFrmsgyY71A5eoZceVfuyL9SbZe2r"
"cbwDW2UwpkEniE4urffgbypegscNchPajWzy9QS4cRxF8QYXsZtq"); "cbwDW2UwpkEniE4urffgbypegscNchPajWzy9QS4cRxF8QYXsZtq");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2811,8 +2811,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZEDyZgdnFBMHxqNhfCUwBfAg1UmXHiTmB5jKtzbAZhF8PTzy2PwAicN" "dpubZEDyZgdnFBMHxqNhfCUwBfAg1UmXHiTmB5jKtzbAZhF8PTzy2PwAicN"
"dkg1CmW6TARxQeUbgC7nAQenJts4YoG3KMiqcjsjgeMvwLc43w6C"); "dkg1CmW6TARxQeUbgC7nAQenJts4YoG3KMiqcjsjgeMvwLc43w6C");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2843,8 +2843,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3pYtkZK168vgrU38gXkUSjHQ2LGpEUzQ9fXrR8fGUR59YviSnm6U82X" "dprv3pYtkZK168vgrU38gXkUSjHQ2LGpEUzQ9fXrR8fGUR59YviSnm6U82X"
"jQYhpJEUPnVcC9bguJBQU5xVM4VFcDHu9BgScGPA6mQMH4bn5Cth"); "jQYhpJEUPnVcC9bguJBQU5xVM4VFcDHu9BgScGPA6mQMH4bn5Cth");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2853,8 +2853,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZGLz7gsJAWzUksvtw3opxx5eeLq5fRaUMDABA3bdUVfnGUk5fiS5Cc3" "dpubZGLz7gsJAWzUksvtw3opxx5eeLq5fRaUMDABA3bdUVfnGUk5fiS5Cc3"
"kZGTjWtYr3jrEavQQnAF6jv2WCpZtFX4uFgifXqev6ED1TM9rTCB"); "kZGTjWtYr3jrEavQQnAF6jv2WCpZtFX4uFgifXqev6ED1TM9rTCB");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2885,8 +2885,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3r7zqYFjT3NiNzdnwGxGpYh6S1TJCp1zA6mSEGaqLBJFnCB94cRMp7Y" "dprv3r7zqYFjT3NiNzdnwGxGpYh6S1TJCp1zA6mSEGaqLBJFnCB94cRMp7Y"
"YLR49aTZHZ7ya1CXwQJ6rodKeU9NgQTxkPSK7pzgZRgjYkQ7rgJh"); "YLR49aTZHZ7ya1CXwQJ6rodKeU9NgQTxkPSK7pzgZRgjYkQ7rgJh");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2895,8 +2895,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZHv6Cfp2XRSWHQXZBo1dLmVM421Zdkc4MePkyBXCLFttVkCmwZkxth4" "dpubZHv6Cfp2XRSWHQXZBo1dLmVM421Zdkc4MePkyBXCLFttVkCmwZkxth4"
"ZV9PzkFP3DtD5xcVq2CPSYpJMWMaoxu1ixz4GNZFVcE2xnHP6chJ"); "ZV9PzkFP3DtD5xcVq2CPSYpJMWMaoxu1ixz4GNZFVcE2xnHP6chJ");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2927,8 +2927,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3tJXnTDSb3uE6Euo6WvvhFKfBMNfxuJt5smqyPoHEoomoBMQyhYoQSK" "dprv3tJXnTDSb3uE6Euo6WvvhFKfBMNfxuJt5smqyPoHEoomoBMQyhYoQSK"
"JAHWtWxmuqdUVb8q9J2NaTkF6rYm6XDrSotkJ55bM21fffa7VV97"); "JAHWtWxmuqdUVb8q9J2NaTkF6rYm6XDrSotkJ55bM21fffa7VV97");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2937,8 +2937,8 @@ START_TEST(test_bip32_decred_vector_1) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZL6d9amjfRy1zeoZM2zHDU7uoMvwPqtxHRQAiJjeEtQQWjP3retQV1q" "dpubZL6d9amjfRy1zeoZM2zHDU7uoMvwPqtxHRQAiJjeEtQQWjP3retQV1q"
"KJyzUd6ZJNgbJGXjtc5pdoBcTTYTLoxQzvV9JJCzCjB2eCWpRf8T"); "KJyzUd6ZJNgbJGXjtc5pdoBcTTYTLoxQzvV9JJCzCjB2eCWpRf8T");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -2989,8 +2989,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3hCznBesA6jBtPKJbQTxRZAKG2gyj8tZKEPaCsV4e9YYFBAgRP2eTSP" "dprv3hCznBesA6jBtPKJbQTxRZAKG2gyj8tZKEPaCsV4e9YYFBAgRP2eTSP"
"Aeu4r8dTMt9q51j2Vdt5zNqj7jbtovvocrP1qLj6WUTLF9xYQt4y"); "Aeu4r8dTMt9q51j2Vdt5zNqj7jbtovvocrP1qLj6WUTLF9xYQt4y");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -2999,8 +2999,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZ9169KDAEUnynoD4qvXJwmxZt3FFA5UdWn1twnRReE9AxjCKJLNFY1u" "dpubZ9169KDAEUnynoD4qvXJwmxZt3FFA5UdWn1twnRReE9AxjCKJLNFY1u"
"BoegbFmwzA4Du7yqnu8tLivhrCCH6P3DgBS1HH5vmf8MpNXvvYT9"); "BoegbFmwzA4Du7yqnu8tLivhrCCH6P3DgBS1HH5vmf8MpNXvvYT9");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -3032,8 +3032,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3jMy45BuuDETfxi59P8NTSjHPrNVq4wPRfLgRd57923L2hosj5NUEqi" "dprv3jMy45BuuDETfxi59P8NTSjHPrNVq4wPRfLgRd57923L2hosj5NUEqi"
"LYQ4i7fJtUpiXZLr2wUeToJY2Tm5sCpAJdajEHDmieVJiPQNXwu9"); "LYQ4i7fJtUpiXZLr2wUeToJY2Tm5sCpAJdajEHDmieVJiPQNXwu9");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -3042,8 +3042,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZBA4RCkCybJFaNbqPuBiyfXY1rvmG1XTdCy1AY1U96dxkFqWc2i5KRE" "dpubZBA4RCkCybJFaNbqPuBiyfXY1rvmG1XTdCy1AY1U96dxkFqWc2i5KRE"
"Mh7NYPpy7ZPMhdpFMAesex3JdFDfX4J5FEW3HjSacqEYPfwb9Cj7"); "Mh7NYPpy7ZPMhdpFMAesex3JdFDfX4J5FEW3HjSacqEYPfwb9Cj7");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -3075,8 +3075,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3mgHPRgK838mLK6T1p6WeBoJoJtXA1pGTHjqFuyHekcM7UTuER8fGwe" "dprv3mgHPRgK838mLK6T1p6WeBoJoJtXA1pGTHjqFuyHekcM7UTuER8fGwe"
"RRsoLqSuHa98uskVPnJnfWZEBUC1AVmXnSCPDvUFKydXNnnPHTuQ"); "RRsoLqSuHa98uskVPnJnfWZEBUC1AVmXnSCPDvUFKydXNnnPHTuQ");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -3085,8 +3085,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZDUNkZEcCRCZEizDGL9sAQbZRKSnaxQLeqN9zpueeqCyq2VY7NUGMXA" "dpubZDUNkZEcCRCZEizDGL9sAQbZRKSnaxQLeqN9zpueeqCyq2VY7NUGMXA"
"SacsK96S8XzNjq3YgFgwLtj8MJBToW6To9U5zxuazEyh89bjR1xA"); "SacsK96S8XzNjq3YgFgwLtj8MJBToW6To9U5zxuazEyh89bjR1xA");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -3118,8 +3118,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3oFqwZZ9bJcUmhAeJyyshvrTWtrAsHfcRYQbEzNiiH5nGvM6wVTDn6w" "dprv3oFqwZZ9bJcUmhAeJyyshvrTWtrAsHfcRYQbEzNiiH5nGvM6wVTDn6w"
"oQEz92b2EHTYZBtLi82jKEnxSouA3cVaW8YWBsw5c3f4mwAhA3d2"); "oQEz92b2EHTYZBtLi82jKEnxSouA3cVaW8YWBsw5c3f4mwAhA3d2");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -3128,8 +3128,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZF3wJh7SfggGg74QZW3EE9ei8uQSJEFgd62uyuK5iMgQzUNjpSnprgT" "dpubZF3wJh7SfggGg74QZW3EE9ei8uQSJEFgd62uyuK5iMgQzUNjpSnprgT"
"pYz3d6Q3fXXtEEXQqpzWcP4LUVuXFsgA8JKt1Hot5kyUk4pPRhDz"); "pYz3d6Q3fXXtEEXQqpzWcP4LUVuXFsgA8JKt1Hot5kyUk4pPRhDz");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -3161,8 +3161,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3qF3177i87wMirg6sraDvqty8yZg6THpXFPSXuM5AShBiiUQbq8FhSZ" "dprv3qF3177i87wMirg6sraDvqty8yZg6THpXFPSXuM5AShBiiUQbq8FhSZ"
"DGkYmBNR3RKfBrxzkKDBpsRFJfTnQfLsvpPPqRnakat6hHQA43X9"); "DGkYmBNR3RKfBrxzkKDBpsRFJfTnQfLsvpPPqRnakat6hHQA43X9");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -3171,8 +3171,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZH38NEg1CW19dGZs8NdaT4hDkz7wXPstio1mGpHSAXHpSGW3UnTrn25" "dpubZH38NEg1CW19dGZs8NdaT4hDkz7wXPstio1mGpHSAXHpSGW3UnTrn25"
"ERT1Mp8ae5GMoQHMbgQiPrChMXQMdx3UqS8YqFkT1pqait8fY92u"); "ERT1Mp8ae5GMoQHMbgQiPrChMXQMdx3UqS8YqFkT1pqait8fY92u");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
@ -3204,8 +3204,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dprv3s15tfqzxhw8Kmo7RBEqMeyvC7uGekLniSmvbs3bckpxQ6ks1KKqfmH" "dprv3s15tfqzxhw8Kmo7RBEqMeyvC7uGekLniSmvbs3bckpxQ6ks1KKqfmH"
"144Jgh3PLxkyZRcS367kp7DrtUmnG16NpnsoNhxSXRgKbJJ7MUQR"); "144Jgh3PLxkyZRcS367kp7DrtUmnG16NpnsoNhxSXRgKbJJ7MUQR");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_private(str, DECRED_VERSION_PRIVATE,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
hdnode_fill_public_key(&node2); hdnode_fill_public_key(&node2);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode)); ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
@ -3214,19 +3214,18 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZJoBFoQJ35zvEBgsfhJBssnAp8TY5gvruzQFLmyxcqRb7enVtGfSkLo" "dpubZJoBFoQJ35zvEBgsfhJBssnAp8TY5gvruzQFLmyxcqRb7enVtGfSkLo"
"2CkAZJMpa6T2fx6fUtvTgXtUvSVgAZ56bEwGxQsToeZfFV8VadE1"); "2CkAZJMpa6T2fx6fUtvTgXtUvSVgAZ56bEwGxQsToeZfFV8VadE1");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode)); memcpy(&node3, &node, sizeof(HDNode));
memzero(&node3.private_key, 32); memzero(&node3.private_key, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode)); ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
// init m // init m
hdnode_deserialize( hdnode_deserialize_public(
"dpubZF4LSCdF9YKZfNzTVYhz4RBxsjYXqms8AQnMBHXZ8GUKoRSigG7kQnKiJt5pzk93Q8Fx" "dpubZF4LSCdF9YKZfNzTVYhz4RBxsjYXqms8AQnMBHXZ8GUKoRSigG7kQnKiJt5pzk93Q8Fx"
"cdVBEkQZruSXduGtWnkwXzGnjbSovQ97dCxqaXc", "cdVBEkQZruSXduGtWnkwXzGnjbSovQ97dCxqaXc",
DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, SECP256K1_DECRED_NAME, DECRED_VERSION_PUBLIC, SECP256K1_DECRED_NAME, &node, NULL);
&node, NULL);
// test public derivation // test public derivation
// [Chain m/0] // [Chain m/0]
@ -3249,8 +3248,8 @@ START_TEST(test_bip32_decred_vector_2) {
ck_assert_str_eq(str, ck_assert_str_eq(str,
"dpubZHJs2Z3PtHbbpaXQCi5wBKPhU8tC5ztBKUYBCYNGKk8eZ1EmBs3MhnL" "dpubZHJs2Z3PtHbbpaXQCi5wBKPhU8tC5ztBKUYBCYNGKk8eZ1EmBs3MhnL"
"JbxHFMAahGnDnZT7qZxC7AXKP8PB6BDNUZgkG77moNMRmXyQ6s6s"); "JbxHFMAahGnDnZT7qZxC7AXKP8PB6BDNUZgkG77moNMRmXyQ6s6s");
r = hdnode_deserialize(str, DECRED_VERSION_PUBLIC, DECRED_VERSION_PRIVATE, r = hdnode_deserialize_public(str, DECRED_VERSION_PUBLIC,
SECP256K1_DECRED_NAME, &node2, NULL); SECP256K1_DECRED_NAME, &node2, NULL);
ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node2, &node, sizeof(HDNode)); ck_assert_mem_eq(&node2, &node, sizeof(HDNode));
} }

5
crypto/tools/xpubaddrgen.c
View File

@ -7,14 +7,13 @@
#include "ecdsa.h" #include "ecdsa.h"
#define VERSION_PUBLIC 0x0488b21e #define VERSION_PUBLIC 0x0488b21e
#define VERSION_PRIVATE 0x0488ade4
void process_job(uint32_t jobid, const char *xpub, uint32_t change, void process_job(uint32_t jobid, const char *xpub, uint32_t change,
uint32_t from, uint32_t to) { uint32_t from, uint32_t to) {
HDNode node, child; HDNode node, child;
if (change > 1 || to <= from || if (change > 1 || to <= from ||
hdnode_deserialize(xpub, VERSION_PUBLIC, VERSION_PRIVATE, SECP256K1_NAME, hdnode_deserialize_public(xpub, VERSION_PUBLIC, SECP256K1_NAME, &node,
&node, NULL) != 0) { NULL) != 0) {
printf("%d error\n", jobid); printf("%d error\n", jobid);
return; return;
} }