arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-11-30 11:28:21 +00:00
Code Issues Releases Wiki Activity
31e05edca7
trezor-firmware/tests.c

2022 lines
107 KiB
C
Raw Normal View History

use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
/**
fix copyright headers
2014-05-22 18:54:58 +00:00
* Copyright (c) 2013-2014 Tomas Dzetkulic
* Copyright (c) 2013-2014 Pavol Rusnak
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
*
* 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.
*/
#include <check.h>
#include <stdint.h>
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
#include <stdio.h>
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
#include <stdlib.h>
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
#include <string.h>
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
#include <time.h>
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
replace blowfish with rijndael
2013-10-10 12:58:59 +00:00
#include "aes.h"
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
#include "bignum.h"
replace base58 implementation
2014-12-23 00:17:58 +00:00
#include "base58.h"
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
#include "bip32.h"
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
#include "bip39.h"
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
#include "ecdsa.h"
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
#include "pbkdf2.h"
scalar_mult based on Jacobian representation This version of scalar_mult should be faster and much better against side-channel attacks. Except bn_inverse and bn_mod all functions are constant time. bn_inverse is only used in the last step and its input is randomized. The function bn_mod is only taking extra time in 2^32/2^256 cases, so in practise it should not occur at all. The input to bn_mod is also depending on the random value. There is secret dependent array access in scalar_multiply, so cache may be an issue.
2015-03-17 16:41:41 +00:00
#include "rand.h"
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
#include "sha2.h"
make pubkey validation optional, extract options to separate header
2014-07-07 18:14:15 +00:00
#include "options.h"
ed25519 support
2016-04-22 15:47:48 +00:00
#include "curves.h"
Add support for NIST256P1 elliptic curve This enables SSH ECDSA public key authentication.
2015-05-27 14:48:57 +00:00
#include "secp256k1.h"
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
#include "nist256p1.h"
add testcase for ed25519
2016-04-25 11:03:26 +00:00
#include "ed25519.h"
add script parsing functions
2016-05-16 12:43:09 +00:00
#include "script.h"
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
uint8_t *fromhex(const char *str)
{
add testcase for ed25519
2016-04-25 11:03:26 +00:00
static uint8_t buf[256];
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
uint8_t c;
add speed benchmark (secp256k1 vs ed25519)
2016-04-26 00:14:47 +00:00
for (size_t i = 0; i < strlen(str) / 2; i++) {
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
c = 0;
if (str[i*2] >= '0' && str[i*2] <= '9') c += (str[i*2] - '0') << 4;
if (str[i*2] >= 'a' && str[i*2] <= 'f') c += (10 + str[i*2] - 'a') << 4;
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
if (str[i*2] >= 'A' && str[i*2] <= 'F') c += (10 + str[i*2] - 'A') << 4;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
if (str[i*2+1] >= '0' && str[i*2+1] <= '9') c += (str[i*2+1] - '0');
if (str[i*2+1] >= 'a' && str[i*2+1] <= 'f') c += (10 + str[i*2+1] - 'a');
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
if (str[i*2+1] >= 'A' && str[i*2+1] <= 'F') c += (10 + str[i*2+1] - 'A');
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
buf[i] = c;
}
return buf;
}
Make CMakeLists.txt build tests
2014-07-16 18:39:02 +00:00
char *tohex(const uint8_t *bin, size_t l)
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
{
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
char *buf = (char *)malloc(l * 2 + 1);
static char digits[] = "0123456789abcdef";
add speed benchmark (secp256k1 vs ed25519)
2016-04-26 00:14:47 +00:00
for (size_t i = 0; i < l; i++) {
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
buf[i*2 ] = digits[(bin[i] >> 4) & 0xF];
buf[i*2+1] = digits[bin[i] & 0xF];
}
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
buf[l * 2] = 0;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
return buf;
}
#define _ck_assert_mem(X, Y, L, OP) do { \
const void* _ck_x = (X); \
const void* _ck_y = (Y); \
size_t _ck_l = (L); \
ck_assert_msg(0 OP memcmp(_ck_y, _ck_x, _ck_l), \
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
"Assertion '"#X#OP#Y"' failed: "#X"==\"%s\", "#Y"==\"%s\"", tohex(_ck_x, _ck_l), tohex(_ck_y, _ck_l)); \
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
} while (0)
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
#define ck_assert_mem_eq(X, Y, L) _ck_assert_mem(X, Y, L, ==)
#define ck_assert_mem_ne(X, Y, L) _ck_assert_mem(X, Y, L, !=)
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
replace base58 implementation
2014-12-23 00:17:58 +00:00
// from https://github.com/bitcoin/bitcoin/blob/master/src/test/data/base58_keys_valid.json
START_TEST(test_base58)
{
static const char *base58_vector[] = {
"0065a16059864a2fdbc7c99a4723a8395bc6f188eb", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i",
"0574f209f6ea907e2ea48f74fae05782ae8a665257", "3CMNFxN1oHBc4R1EpboAL5yzHGgE611Xou",
"6f53c0307d6851aa0ce7825ba883c6bd9ad242b486", "mo9ncXisMeAoXwqcV5EWuyncbmCcQN4rVs",
"c46349a418fc4578d10a372b54b45c280cc8c4382f", "2N2JD6wb56AfK4tfmM6PwdVmoYk2dCKf4Br",
"80eddbdc1168f1daeadbd3e44c1e3f8f5a284c2029f78ad26af98583a499de5b19", "5Kd3NBUAdUnhyzenEwVLy9pBKxSwXvE9FMPyR4UKZvpe6E3AgLr",
"8055c9bccb9ed68446d1b75273bbce89d7fe013a8acd1625514420fb2aca1a21c401", "Kz6UJmQACJmLtaQj5A3JAge4kVTNQ8gbvXuwbmCj7bsaabudb3RD",
"ef36cb93b9ab1bdabf7fb9f2c04f1b9cc879933530ae7842398eef5a63a56800c2", "9213qJab2HNEpMpYNBa7wHGFKKbkDn24jpANDs2huN3yi4J11ko",
"efb9f4892c9e8282028fea1d2667c4dc5213564d41fc5783896a0d843fc15089f301", "cTpB4YiyKiBcPxnefsDpbnDxFDffjqJob8wGCEDXxgQ7zQoMXJdH",
"006d23156cbbdcc82a5a47eee4c2c7c583c18b6bf4", "1Ax4gZtb7gAit2TivwejZHYtNNLT18PUXJ",
"05fcc5460dd6e2487c7d75b1963625da0e8f4c5975", "3QjYXhTkvuj8qPaXHTTWb5wjXhdsLAAWVy",
"6ff1d470f9b02370fdec2e6b708b08ac431bf7a5f7", "n3ZddxzLvAY9o7184TB4c6FJasAybsw4HZ",
"c4c579342c2c4c9220205e2cdc285617040c924a0a", "2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
"80a326b95ebae30164217d7a7f57d72ab2b54e3be64928a19da0210b9568d4015e", "5K494XZwps2bGyeL71pWid4noiSNA2cfCibrvRWqcHSptoFn7rc",
"807d998b45c219a1e38e99e7cbd312ef67f77a455a9b50c730c27f02c6f730dfb401", "L1RrrnXkcKut5DEMwtDthjwRcTTwED36thyL1DebVrKuwvohjMNi",
"efd6bca256b5abc5602ec2e1c121a08b0da2556587430bcf7e1898af2224885203", "93DVKyFYwSN6wEo3E2fCrFPUp17FtrtNi2Lf7n4G3garFb16CRj",
"efa81ca4e8f90181ec4b61b6a7eb998af17b2cb04de8a03b504b9e34c4c61db7d901", "cTDVKtMGVYWTHCb1AFjmVbEbWjvKpKqKgMaR3QJxToMSQAhmCeTN",
"007987ccaa53d02c8873487ef919677cd3db7a6912", "1C5bSj1iEGUgSTbziymG7Cn18ENQuT36vv",
"0563bcc565f9e68ee0189dd5cc67f1b0e5f02f45cb", "3AnNxabYGoTxYiTEZwFEnerUoeFXK2Zoks",
"6fef66444b5b17f14e8fae6e7e19b045a78c54fd79", "n3LnJXCqbPjghuVs8ph9CYsAe4Sh4j97wk",
"c4c3e55fceceaa4391ed2a9677f4a4d34eacd021a0", "2NB72XtkjpnATMggui83aEtPawyyKvnbX2o",
"80e75d936d56377f432f404aabb406601f892fd49da90eb6ac558a733c93b47252", "5KaBW9vNtWNhc3ZEDyNCiXLPdVPHCikRxSBWwV9NrpLLa4LsXi9",
"808248bd0375f2f75d7e274ae544fb920f51784480866b102384190b1addfbaa5c01", "L1axzbSyynNYA8mCAhzxkipKkfHtAXYF4YQnhSKcLV8YXA874fgT",
"ef44c4f6a096eac5238291a94cc24c01e3b19b8d8cef72874a079e00a242237a52", "927CnUkUbasYtDwYwVn2j8GdTuACNnKkjZ1rpZd2yBB1CLcnXpo",
"efd1de707020a9059d6d3abaf85e17967c6555151143db13dbb06db78df0f15c6901", "cUcfCMRjiQf85YMzzQEk9d1s5A4K7xL5SmBCLrezqXFuTVefyhY7",
"00adc1cc2081a27206fae25792f28bbc55b831549d", "1Gqk4Tv79P91Cc1STQtU3s1W6277M2CVWu",
"05188f91a931947eddd7432d6e614387e32b244709", "33vt8ViH5jsr115AGkW6cEmEz9MpvJSwDk",
"6f1694f5bc1a7295b600f40018a618a6ea48eeb498", "mhaMcBxNh5cqXm4aTQ6EcVbKtfL6LGyK2H",
"c43b9b3fd7a50d4f08d1a5b0f62f644fa7115ae2f3", "2MxgPqX1iThW3oZVk9KoFcE5M4JpiETssVN",
"80091035445ef105fa1bb125eccfb1882f3fe69592265956ade751fd095033d8d0", "5HtH6GdcwCJA4ggWEL1B3jzBBUB8HPiBi9SBc5h9i4Wk4PSeApR",
"80ab2b4bcdfc91d34dee0ae2a8c6b6668dadaeb3a88b9859743156f462325187af01", "L2xSYmMeVo3Zek3ZTsv9xUrXVAmrWxJ8Ua4cw8pkfbQhcEFhkXT8",
"efb4204389cef18bbe2b353623cbf93e8678fbc92a475b664ae98ed594e6cf0856", "92xFEve1Z9N8Z641KQQS7ByCSb8kGjsDzw6fAmjHN1LZGKQXyMq",
"efe7b230133f1b5489843260236b06edca25f66adb1be455fbd38d4010d48faeef01", "cVM65tdYu1YK37tNoAyGoJTR13VBYFva1vg9FLuPAsJijGvG6NEA",
"00c4c1b72491ede1eedaca00618407ee0b772cad0d", "1JwMWBVLtiqtscbaRHai4pqHokhFCbtoB4",
"05f6fe69bcb548a829cce4c57bf6fff8af3a5981f9", "3QCzvfL4ZRvmJFiWWBVwxfdaNBT8EtxB5y",
"6f261f83568a098a8638844bd7aeca039d5f2352c0", "mizXiucXRCsEriQCHUkCqef9ph9qtPbZZ6",
"c4e930e1834a4d234702773951d627cce82fbb5d2e", "2NEWDzHWwY5ZZp8CQWbB7ouNMLqCia6YRda",
"80d1fab7ab7385ad26872237f1eb9789aa25cc986bacc695e07ac571d6cdac8bc0", "5KQmDryMNDcisTzRp3zEq9e4awRmJrEVU1j5vFRTKpRNYPqYrMg",
"80b0bbede33ef254e8376aceb1510253fc3550efd0fcf84dcd0c9998b288f166b301", "L39Fy7AC2Hhj95gh3Yb2AU5YHh1mQSAHgpNixvm27poizcJyLtUi",
"ef037f4192c630f399d9271e26c575269b1d15be553ea1a7217f0cb8513cef41cb", "91cTVUcgydqyZLgaANpf1fvL55FH53QMm4BsnCADVNYuWuqdVys",
"ef6251e205e8ad508bab5596bee086ef16cd4b239e0cc0c5d7c4e6035441e7d5de01", "cQspfSzsgLeiJGB2u8vrAiWpCU4MxUT6JseWo2SjXy4Qbzn2fwDw",
"005eadaf9bb7121f0f192561a5a62f5e5f54210292", "19dcawoKcZdQz365WpXWMhX6QCUpR9SY4r",
"053f210e7277c899c3a155cc1c90f4106cbddeec6e", "37Sp6Rv3y4kVd1nQ1JV5pfqXccHNyZm1x3",
"6fc8a3c2a09a298592c3e180f02487cd91ba3400b5", "myoqcgYiehufrsnnkqdqbp69dddVDMopJu",
"c499b31df7c9068d1481b596578ddbb4d3bd90baeb", "2N7FuwuUuoTBrDFdrAZ9KxBmtqMLxce9i1C",
"80c7666842503db6dc6ea061f092cfb9c388448629a6fe868d068c42a488b478ae", "5KL6zEaMtPRXZKo1bbMq7JDjjo1bJuQcsgL33je3oY8uSJCR5b4",
"8007f0803fc5399e773555ab1e8939907e9badacc17ca129e67a2f5f2ff84351dd01", "KwV9KAfwbwt51veZWNscRTeZs9CKpojyu1MsPnaKTF5kz69H1UN2",
"efea577acfb5d1d14d3b7b195c321566f12f87d2b77ea3a53f68df7ebf8604a801", "93N87D6uxSBzwXvpokpzg8FFmfQPmvX4xHoWQe3pLdYpbiwT5YV",
"ef0b3b34f0958d8a268193a9814da92c3e8b58b4a4378a542863e34ac289cd830c01", "cMxXusSihaX58wpJ3tNuuUcZEQGt6DKJ1wEpxys88FFaQCYjku9h",
"001ed467017f043e91ed4c44b4e8dd674db211c4e6", "13p1ijLwsnrcuyqcTvJXkq2ASdXqcnEBLE",
"055ece0cadddc415b1980f001785947120acdb36fc", "3ALJH9Y951VCGcVZYAdpA3KchoP9McEj1G",
0, 0,
};
const char **raw = base58_vector;
const char **str = base58_vector + 1;
uint8_t rawn[34];
char strn[53];
int r;
while (*raw && *str) {
int len = strlen(*raw) / 2;
memcpy(rawn, fromhex(*raw), len);
r = base58_encode_check(rawn, len, strn, sizeof(strn));
tests: fix signedness error
2015-07-29 18:49:00 +00:00
ck_assert_int_eq((size_t)r, strlen(*str) + 1);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ck_assert_str_eq(strn, *str);
r = base58_decode_check(strn, rawn, len);
ck_assert_int_eq(r, len);
ck_assert_mem_eq(rawn, fromhex(*raw), len);
raw += 2; str += 2;
}
}
END_TEST
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// test vector 1 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_vector_1)
{
added deserialization
2014-05-20 22:15:55 +00:00
HDNode node, node2, node3;
char str[112];
int r;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// init m
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16, SECP256K1_NAME, &node);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m]
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x00000000);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508"), 32);
ck_assert_mem_eq(node.private_key, fromhex("e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0339a36013301597daef41fbe593a02cc513d0b55527ec2df1050e2e8ff49c85c2"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0']
implement public child key derivation
2014-01-14 13:35:13 +00:00
hdnode_private_ckd_prime(&node, 0);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x3442193e);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141"), 32);
ck_assert_mem_eq(node.private_key, fromhex("edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea"), 32);
ck_assert_mem_eq(node.public_key, fromhex("035a784662a4a20a65bf6aab9ae98a6c068a81c52e4b032c0fb5400c706cfccc56"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0'/1]
implement public child key derivation
2014-01-14 13:35:13 +00:00
hdnode_private_ckd(&node, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x5c1bd648);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19"), 32);
ck_assert_mem_eq(node.private_key, fromhex("3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03501e454bf00751f24b1b489aa925215d66af2234e3891c3b21a52bedb3cd711c"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0'/1/2']
implement public child key derivation
2014-01-14 13:35:13 +00:00
hdnode_private_ckd_prime(&node, 2);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xbef5a2f9);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"), 32);
ck_assert_mem_eq(node.private_key, fromhex("cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0357bfe1e341d01c69fe5654309956cbea516822fba8a601743a012a7896ee8dc2"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0'/1/2'/2]
implement public child key derivation
2014-01-14 13:35:13 +00:00
hdnode_private_ckd(&node, 2);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xee7ab90c);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"), 32);
ck_assert_mem_eq(node.private_key, fromhex("0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02e8445082a72f29b75ca48748a914df60622a609cacfce8ed0e35804560741d29"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0'/1/2'/2/1000000000]
implement public child key derivation
2014-01-14 13:35:13 +00:00
hdnode_private_ckd(&node, 1000000000);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xd880d7d8);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"), 32);
ck_assert_mem_eq(node.private_key, fromhex("471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8"), 32);
ck_assert_mem_eq(node.public_key, fromhex("022a471424da5e657499d1ff51cb43c47481a03b1e77f951fe64cec9f5a48f7011"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
}
END_TEST
// test vector 2 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_vector_2)
{
added deserialization
2014-05-20 22:15:55 +00:00
HDNode node, node2, node3;
char str[112];
implement public child key derivation
2014-01-14 13:35:13 +00:00
int r;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// init m
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"), 64, SECP256K1_NAME, &node);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m]
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x00000000);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("60499f801b896d83179a4374aeb7822aaeaceaa0db1f85ee3e904c4defbd9689"), 32);
ck_assert_mem_eq(node.private_key, fromhex("4b03d6fc340455b363f51020ad3ecca4f0850280cf436c70c727923f6db46c3e"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03cbcaa9c98c877a26977d00825c956a238e8dddfbd322cce4f74b0b5bd6ace4a7"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0]
implement public child key derivation
2014-01-14 13:35:13 +00:00
r = hdnode_private_ckd(&node, 0);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xbd16bee5);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"), 32);
ck_assert_mem_eq(node.private_key, fromhex("abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f15ac7e1e"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22a98d12ea"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0/2147483647']
implement public child key derivation
2014-01-14 13:35:13 +00:00
r = hdnode_private_ckd_prime(&node, 2147483647);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x5a61ff8e);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"), 32);
ck_assert_mem_eq(node.private_key, fromhex("877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18fd52e6e93"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03c01e7425647bdefa82b12d9bad5e3e6865bee0502694b94ca58b666abc0a5c3b"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0/2147483647'/1]
implement public child key derivation
2014-01-14 13:35:13 +00:00
r = hdnode_private_ckd(&node, 1);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xd8ab4937);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"), 32);
ck_assert_mem_eq(node.private_key, fromhex("704addf544a06e5ee4bea37098463c23613da32020d604506da8c0518e1da4b7"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03a7d1d856deb74c508e05031f9895dab54626251b3806e16b4bd12e781a7df5b9"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0/2147483647'/1/2147483646']
implement public child key derivation
2014-01-14 13:35:13 +00:00
r = hdnode_private_ckd_prime(&node, 2147483646);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x78412e3a);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"), 32);
ck_assert_mem_eq(node.private_key, fromhex("f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b247d6a2d"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02d2b36900396c9282fa14628566582f206a5dd0bcc8d5e892611806cafb0301f0"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// [Chain m/0/2147483647'/1/2147483646'/2]
implement public child key derivation
2014-01-14 13:35:13 +00:00
r = hdnode_private_ckd(&node, 2);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0x31a507b8);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"), 32);
ck_assert_mem_eq(node.private_key, fromhex("bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a4842125ac23"), 32);
ck_assert_mem_eq(node.public_key, fromhex("024d902e1a2fc7a8755ab5b694c575fce742c48d9ff192e63df5193e4c7afe1f9c"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_private(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
ck_assert_mem_eq(&node, &node2, sizeof(HDNode));
replace base58 implementation
2014-12-23 00:17:58 +00:00
hdnode_serialize_public(&node, str, sizeof(str));
added deserialization
2014-05-20 22:15:55 +00:00
ck_assert_str_eq(str, "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
r = hdnode_deserialize(str, &node2); ck_assert_int_eq(r, 0);
memcpy(&node3, &node, sizeof(HDNode));
memset(&node3.private_key, 0, 32);
ck_assert_mem_eq(&node2, &node3, sizeof(HDNode));
implement public child key derivation
2014-01-14 13:35:13 +00:00
// init m
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"), 64, SECP256K1_NAME, &node);
implement public child key derivation
2014-01-14 13:35:13 +00:00
// test public derivation
// [Chain m/0]
r = hdnode_public_ckd(&node, 0);
ck_assert_int_eq(r, 1);
compute fingerprints
2014-01-14 14:29:46 +00:00
ck_assert_int_eq(node.fingerprint, 0xbd16bee5);
implement public child key derivation
2014-01-14 13:35:13 +00:00
ck_assert_mem_eq(node.chain_code, fromhex("f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"), 32);
ck_assert_mem_eq(node.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02fc9e5af0ac8d9b3cecfe2a888e2117ba3d089d8585886c9c826b6b22a98d12ea"), 33);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
}
END_TEST
new test to compare private and public branch of bip32
2014-02-21 19:30:22 +00:00
START_TEST(test_bip32_compare)
{
HDNode node1, node2, node3;
int i, r;
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node1);
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node2);
fix bug in unoptimized branch of code
2014-07-03 08:16:19 +00:00
for (i = 0; i < 100; i++) {
new test to compare private and public branch of bip32
2014-02-21 19:30:22 +00:00
memcpy(&node3, &node1, sizeof(HDNode));
r = hdnode_private_ckd(&node1, i); ck_assert_int_eq(r, 1);
r = hdnode_public_ckd(&node2, i); ck_assert_int_eq(r, 1);
r = hdnode_public_ckd(&node3, i); ck_assert_int_eq(r, 1);
ck_assert_int_eq(node1.depth, node2.depth);
ck_assert_int_eq(node1.depth, node3.depth);
ck_assert_int_eq(node1.fingerprint, node2.fingerprint);
ck_assert_int_eq(node1.fingerprint, node3.fingerprint);
ck_assert_int_eq(node1.child_num, node2.child_num);
ck_assert_int_eq(node1.child_num, node3.child_num);
ck_assert_mem_eq(node1.chain_code, node2.chain_code, 32);
ck_assert_mem_eq(node1.chain_code, node3.chain_code, 32);
ck_assert_mem_eq(node2.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node3.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node1.public_key, node2.public_key, 33);
ck_assert_mem_eq(node1.public_key, node3.public_key, 33);
}
}
END_TEST
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
START_TEST(test_bip32_cache_1)
implement BIP32 cache
2015-01-26 18:09:00 +00:00
{
HDNode node1, node2;
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
int i, r;
implement BIP32 cache
2015-01-26 18:09:00 +00:00
// test 1 .. 8
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node1);
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node2);
implement BIP32 cache
2015-01-26 18:09:00 +00:00
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
uint32_t ii[] = {0x80000001, 0x80000002, 0x80000003, 0x80000004, 0x80000005, 0x80000006, 0x80000007, 0x80000008};
implement BIP32 cache
2015-01-26 18:09:00 +00:00
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
for (i = 0; i < 8; i++) {
r = hdnode_private_ckd(&node1, ii[i]); ck_assert_int_eq(r, 1);
}
implement BIP32 cache
2015-01-26 18:09:00 +00:00
r = hdnode_private_ckd_cached(&node2, ii, 8); ck_assert_int_eq(r, 1);
ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node1);
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node2);
implement BIP32 cache
2015-01-26 18:09:00 +00:00
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
// test 1 .. 7, 20
implement BIP32 cache
2015-01-26 18:09:00 +00:00
ii[7] = 20;
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
for (i = 0; i < 8; i++) {
r = hdnode_private_ckd(&node1, ii[i]); ck_assert_int_eq(r, 1);
}
implement BIP32 cache
2015-01-26 18:09:00 +00:00
r = hdnode_private_ckd_cached(&node2, ii, 8); ck_assert_int_eq(r, 1);
ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));
// test different root node
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("000000002ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node1);
hdnode_from_seed(fromhex("000000002ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &node2);
implement BIP32 cache
2015-01-26 18:09:00 +00:00
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
for (i = 0; i < 8; i++) {
r = hdnode_private_ckd(&node1, ii[i]); ck_assert_int_eq(r, 1);
implement BIP32 cache
2015-01-26 18:09:00 +00:00
}
r = hdnode_private_ckd_cached(&node2, ii, 8); ck_assert_int_eq(r, 1);
ck_assert_mem_eq(&node1, &node2, sizeof(HDNode));
}
END_TEST
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
START_TEST(test_bip32_cache_2)
{
HDNode nodea[9], nodeb[9];
int i, j, r;
for (j = 0; j < 9; j++) {
Updated tests
2016-04-20 08:43:53 +00:00
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &(nodea[j]));
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, SECP256K1_NAME, &(nodeb[j]));
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
}
uint32_t ii[] = {0x80000001, 0x80000002, 0x80000003, 0x80000004, 0x80000005, 0x80000006, 0x80000007, 0x80000008};
for (j = 0; j < 9; j++) {
// non cached
for (i = 1; i <= j; i++) {
r = hdnode_private_ckd(&(nodea[j]), ii[i - 1]); ck_assert_int_eq(r, 1);
}
// cached
r = hdnode_private_ckd_cached(&(nodeb[j]), ii, j); ck_assert_int_eq(r, 1);
}
ck_assert_mem_eq(&(nodea[0]), &(nodeb[0]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[1]), &(nodeb[1]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[2]), &(nodeb[2]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[3]), &(nodeb[3]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[4]), &(nodeb[4]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[5]), &(nodeb[5]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[6]), &(nodeb[6]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[7]), &(nodeb[7]), sizeof(HDNode));
ck_assert_mem_eq(&(nodea[8]), &(nodeb[8]), sizeof(HDNode));
}
END_TEST
ed25519 support
2016-04-22 15:47:48 +00:00
START_TEST(test_bip32_nist_seed)
{
HDNode node;
// init m
hdnode_from_seed(fromhex("a7305bc8df8d0951f0cb224c0e95d7707cbdf2c6ce7e8d481fec69c7ff5e9446"), 32, NIST256P1_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.private_key, fromhex("3b8c18469a4634517d6d0b65448f8e6c62091b45540a1743c5846be55d47d88f"), 32);
ck_assert_mem_eq(node.chain_code, fromhex("7762f9729fed06121fd13f326884c82f59aa95c57ac492ce8c9654e60efd130c"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0383619fadcde31063d8c5cb00dbfe1713f3e6fa169d8541a798752a1c1ca0cb20"), 33);
// init m
hdnode_from_seed(fromhex("aa305bc8df8d0951f0cb29ad4568d7707cbdf2c6ce7e8d481fec69c7ff5e9446"), 32, NIST256P1_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.chain_code, fromhex("a81d21f36f987fa0be3b065301bfb6aa9deefbf3dfef6744c37b9a4abc3c68f1"), 32);
ck_assert_mem_eq(node.private_key, fromhex("0e49dc46ce1d8c29d9b80a05e40f5d0cd68cbf02ae98572186f5343be18084bf"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03aaa4c89acd9a98935330773d3dae55122f3591bac4a40942681768de8df6ba63"), 33);
}
END_TEST
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
START_TEST(test_bip32_nist_vector_1)
{
HDNode node;
// init m
hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16, NIST256P1_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.chain_code, fromhex("beeb672fe4621673f722f38529c07392fecaa61015c80c34f29ce8b41b3cb6ea"), 32);
ck_assert_mem_eq(node.private_key, fromhex("612091aaa12e22dd2abef664f8a01a82cae99ad7441b7ef8110424915c268bc2"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0266874dc6ade47b3ecd096745ca09bcd29638dd52c2c12117b11ed3e458cfa9e8"), 33);
// [Chain m/0']
hdnode_private_ckd_prime(&node, 0);
ck_assert_int_eq(node.fingerprint, 0xbe6105b5);
ck_assert_mem_eq(node.chain_code, fromhex("3460cea53e6a6bb5fb391eeef3237ffd8724bf0a40e94943c98b83825342ee11"), 32);
ck_assert_mem_eq(node.private_key, fromhex("6939694369114c67917a182c59ddb8cafc3004e63ca5d3b84403ba8613debc0c"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0384610f5ecffe8fda089363a41f56a5c7ffc1d81b59a612d0d649b2d22355590c"), 33);
// [Chain m/0'/1]
hdnode_private_ckd(&node, 1);
ck_assert_int_eq(node.fingerprint, 0x9b02312f);
ck_assert_mem_eq(node.chain_code, fromhex("4187afff1aafa8445010097fb99d23aee9f599450c7bd140b6826ac22ba21d0c"), 32);
ck_assert_mem_eq(node.private_key, fromhex("284e9d38d07d21e4e281b645089a94f4cf5a5a81369acf151a1c3a57f18b2129"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03526c63f8d0b4bbbf9c80df553fe66742df4676b241dabefdef67733e070f6844"), 33);
// [Chain m/0'/1/2']
hdnode_private_ckd_prime(&node, 2);
ck_assert_int_eq(node.fingerprint, 0xb98005c1);
ck_assert_mem_eq(node.chain_code, fromhex("98c7514f562e64e74170cc3cf304ee1ce54d6b6da4f880f313e8204c2a185318"), 32);
ck_assert_mem_eq(node.private_key, fromhex("694596e8a54f252c960eb771a3c41e7e32496d03b954aeb90f61635b8e092aa7"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0359cf160040778a4b14c5f4d7b76e327ccc8c4a6086dd9451b7482b5a4972dda0"), 33);
// [Chain m/0'/1/2'/2]
hdnode_private_ckd(&node, 2);
ck_assert_int_eq(node.fingerprint, 0x0e9f3274);
ck_assert_mem_eq(node.chain_code, fromhex("ba96f776a5c3907d7fd48bde5620ee374d4acfd540378476019eab70790c63a0"), 32);
ck_assert_mem_eq(node.private_key, fromhex("5996c37fd3dd2679039b23ed6f70b506c6b56b3cb5e424681fb0fa64caf82aaa"), 32);
ck_assert_mem_eq(node.public_key, fromhex("029f871f4cb9e1c97f9f4de9ccd0d4a2f2a171110c61178f84430062230833ff20"), 33);
// [Chain m/0'/1/2'/2/1000000000]
hdnode_private_ckd(&node, 1000000000);
ck_assert_int_eq(node.fingerprint, 0x8b2b5c4b);
ck_assert_mem_eq(node.chain_code, fromhex("b9b7b82d326bb9cb5b5b121066feea4eb93d5241103c9e7a18aad40f1dde8059"), 32);
ck_assert_mem_eq(node.private_key, fromhex("21c4f269ef0a5fd1badf47eeacebeeaa3de22eb8e5b0adcd0f27dd99d34d0119"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02216cd26d31147f72427a453c443ed2cde8a1e53c9cc44e5ddf739725413fe3f4"), 33);
}
END_TEST
START_TEST(test_bip32_nist_vector_2)
{
HDNode node;
int r;
// init m
hdnode_from_seed(fromhex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"), 64, NIST256P1_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.chain_code, fromhex("96cd4465a9644e31528eda3592aa35eb39a9527769ce1855beafc1b81055e75d"), 32);
ck_assert_mem_eq(node.private_key, fromhex("eaa31c2e46ca2962227cf21d73a7ef0ce8b31c756897521eb6c7b39796633357"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02c9e16154474b3ed5b38218bb0463e008f89ee03e62d22fdcc8014beab25b48fa"), 33);
// [Chain m/0]
r = hdnode_private_ckd(&node, 0);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x607f628f);
ck_assert_mem_eq(node.chain_code, fromhex("84e9c258bb8557a40e0d041115b376dd55eda99c0042ce29e81ebe4efed9b86a"), 32);
ck_assert_mem_eq(node.private_key, fromhex("d7d065f63a62624888500cdb4f88b6d59c2927fee9e6d0cdff9cad555884df6e"), 32);
ck_assert_mem_eq(node.public_key, fromhex("039b6df4bece7b6c81e2adfeea4bcf5c8c8a6e40ea7ffa3cf6e8494c61a1fc82cc"), 33);
// [Chain m/0/2147483647']
r = hdnode_private_ckd_prime(&node, 2147483647);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x946d2a54);
ck_assert_mem_eq(node.chain_code, fromhex("f235b2bc5c04606ca9c30027a84f353acf4e4683edbd11f635d0dcc1cd106ea6"), 32);
ck_assert_mem_eq(node.private_key, fromhex("96d2ec9316746a75e7793684ed01e3d51194d81a42a3276858a5b7376d4b94b9"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02f89c5deb1cae4fedc9905f98ae6cbf6cbab120d8cb85d5bd9a91a72f4c068c76"), 33);
// [Chain m/0/2147483647'/1]
r = hdnode_private_ckd(&node, 1);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x218182d8);
ck_assert_mem_eq(node.chain_code, fromhex("7c0b833106235e452eba79d2bdd58d4086e663bc8cc55e9773d2b5eeda313f3b"), 32);
ck_assert_mem_eq(node.private_key, fromhex("974f9096ea6873a915910e82b29d7c338542ccde39d2064d1cc228f371542bbc"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03abe0ad54c97c1d654c1852dfdc32d6d3e487e75fa16f0fd6304b9ceae4220c64"), 33);
// [Chain m/0/2147483647'/1/2147483646']
r = hdnode_private_ckd_prime(&node, 2147483646);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x931223e4);
ck_assert_mem_eq(node.chain_code, fromhex("5794e616eadaf33413aa309318a26ee0fd5163b70466de7a4512fd4b1a5c9e6a"), 32);
ck_assert_mem_eq(node.private_key, fromhex("da29649bbfaff095cd43819eda9a7be74236539a29094cd8336b07ed8d4eff63"), 32);
ck_assert_mem_eq(node.public_key, fromhex("03cb8cb067d248691808cd6b5a5a06b48e34ebac4d965cba33e6dc46fe13d9b933"), 33);
// [Chain m/0/2147483647'/1/2147483646'/2]
r = hdnode_private_ckd(&node, 2);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x956c4629);
ck_assert_mem_eq(node.chain_code, fromhex("3bfb29ee8ac4484f09db09c2079b520ea5616df7820f071a20320366fbe226a7"), 32);
ck_assert_mem_eq(node.private_key, fromhex("bb0a77ba01cc31d77205d51d08bd313b979a71ef4de9b062f8958297e746bd67"), 32);
ck_assert_mem_eq(node.public_key, fromhex("020ee02e18967237cf62672983b253ee62fa4dd431f8243bfeccdf39dbe181387f"), 33);
// init m
hdnode_from_seed(fromhex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"), 64, NIST256P1_NAME, &node);
// test public derivation
// [Chain m/0]
r = hdnode_public_ckd(&node, 0);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x607f628f);
ck_assert_mem_eq(node.chain_code, fromhex("84e9c258bb8557a40e0d041115b376dd55eda99c0042ce29e81ebe4efed9b86a"), 32);
ck_assert_mem_eq(node.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node.public_key, fromhex("039b6df4bece7b6c81e2adfeea4bcf5c8c8a6e40ea7ffa3cf6e8494c61a1fc82cc"), 33);
}
END_TEST
START_TEST(test_bip32_nist_compare)
{
HDNode node1, node2, node3;
int i, r;
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, NIST256P1_NAME, &node1);
hdnode_from_seed(fromhex("301133282ad079cbeb59bc446ad39d333928f74c46997d3609cd3e2801ca69d62788f9f174429946ff4e9be89f67c22fae28cb296a9b37734f75e73d1477af19"), 64, NIST256P1_NAME, &node2);
for (i = 0; i < 100; i++) {
memcpy(&node3, &node1, sizeof(HDNode));
r = hdnode_private_ckd(&node1, i); ck_assert_int_eq(r, 1);
r = hdnode_public_ckd(&node2, i); ck_assert_int_eq(r, 1);
r = hdnode_public_ckd(&node3, i); ck_assert_int_eq(r, 1);
ck_assert_int_eq(node1.depth, node2.depth);
ck_assert_int_eq(node1.depth, node3.depth);
ck_assert_int_eq(node1.fingerprint, node2.fingerprint);
ck_assert_int_eq(node1.fingerprint, node3.fingerprint);
ck_assert_int_eq(node1.child_num, node2.child_num);
ck_assert_int_eq(node1.child_num, node3.child_num);
ck_assert_mem_eq(node1.chain_code, node2.chain_code, 32);
ck_assert_mem_eq(node1.chain_code, node3.chain_code, 32);
ck_assert_mem_eq(node2.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node3.private_key, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
ck_assert_mem_eq(node1.public_key, node2.public_key, 33);
ck_assert_mem_eq(node1.public_key, node3.public_key, 33);
}
}
END_TEST
BIP-32 without gaps, prepare non-ecdsa curves * Split ecdsa_curve into curve_info and ecdsa_curve to support bip32 on curves that don't have a ecdsa_curve. * Don't fail in key derivation but retry with a new hash. * Adapted test case accordingly
2016-04-22 12:48:24 +00:00
START_TEST(test_bip32_nist_repeat)
New test case for a bip32 hole in nist256
2016-04-20 18:30:10 +00:00
{
HDNode node, node2;
int r;
// init m
hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16, NIST256P1_NAME, &node);
// [Chain m/28578']
r = hdnode_private_ckd_prime(&node, 28578);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0xbe6105b5);
ck_assert_mem_eq(node.chain_code, fromhex("e94c8ebe30c2250a14713212f6449b20f3329105ea15b652ca5bdfc68f6c65c2"), 32);
ck_assert_mem_eq(node.private_key, fromhex("06f0db126f023755d0b8d86d4591718a5210dd8d024e3e14b6159d63f53aa669"), 32);
ck_assert_mem_eq(node.public_key, fromhex("02519b5554a4872e8c9c1c847115363051ec43e93400e030ba3c36b52a3e70a5b7"), 33);
memcpy(&node2, &node, sizeof(HDNode));
r = hdnode_private_ckd(&node2, 33941);
BIP-32 without gaps, prepare non-ecdsa curves * Split ecdsa_curve into curve_info and ecdsa_curve to support bip32 on curves that don't have a ecdsa_curve. * Don't fail in key derivation but retry with a new hash. * Adapted test case accordingly
2016-04-22 12:48:24 +00:00
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node2.fingerprint, 0x3e2b7bc6);
ck_assert_mem_eq(node2.chain_code, fromhex("9e87fe95031f14736774cd82f25fd885065cb7c358c1edf813c72af535e83071"), 32);
ck_assert_mem_eq(node2.private_key, fromhex("092154eed4af83e078ff9b84322015aefe5769e31270f62c3f66c33888335f3a"), 32);
ck_assert_mem_eq(node2.public_key, fromhex("0235bfee614c0d5b2cae260000bb1d0d84b270099ad790022c1ae0b2e782efe120"), 33);
New test case for a bip32 hole in nist256
2016-04-20 18:30:10 +00:00
memcpy(&node2, &node, sizeof(HDNode));
memset(&node2.private_key, 0, 32);
r = hdnode_public_ckd(&node2, 33941);
BIP-32 without gaps, prepare non-ecdsa curves * Split ecdsa_curve into curve_info and ecdsa_curve to support bip32 on curves that don't have a ecdsa_curve. * Don't fail in key derivation but retry with a new hash. * Adapted test case accordingly
2016-04-22 12:48:24 +00:00
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node2.fingerprint, 0x3e2b7bc6);
ck_assert_mem_eq(node2.chain_code, fromhex("9e87fe95031f14736774cd82f25fd885065cb7c358c1edf813c72af535e83071"), 32);
ck_assert_mem_eq(node2.public_key, fromhex("0235bfee614c0d5b2cae260000bb1d0d84b270099ad790022c1ae0b2e782efe120"), 33);
New test case for a bip32 hole in nist256
2016-04-20 18:30:10 +00:00
}
END_TEST
Test vectors for ed25519 + BIP-0032 / SLIP-0010
2016-04-23 21:42:53 +00:00
// test vector 1 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_ed25519_vector_1)
{
HDNode node;
// init m
hdnode_from_seed(fromhex("000102030405060708090a0b0c0d0e0f"), 16, ED25519_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.chain_code, fromhex("90046a93de5380a72b5e45010748567d5ea02bbf6522f979e05c0d8d8ca9fffb"), 32);
ck_assert_mem_eq(node.private_key, fromhex("2b4be7f19ee27bbf30c667b642d5f4aa69fd169872f8fc3059c08ebae2eb19e7"), 32);
ck_assert_mem_eq(node.public_key, fromhex("00a4b2856bfec510abab89753fac1ac0e1112364e7d250545963f135f2a33188ed"), 33);
// [Chain m/0']
hdnode_private_ckd_prime(&node, 0);
ck_assert_int_eq(node.fingerprint, 0xddebc675);
ck_assert_mem_eq(node.chain_code, fromhex("8b59aa11380b624e81507a27fedda59fea6d0b779a778918a2fd3590e16e9c69"), 32);
ck_assert_mem_eq(node.private_key, fromhex("68e0fe46dfb67e368c75379acec591dad19df3cde26e63b93a8e704f1dade7a3"), 32);
ck_assert_mem_eq(node.public_key, fromhex("008c8a13df77a28f3445213a0f432fde644acaa215fc72dcdf300d5efaa85d350c"), 33);
// [Chain m/0'/1']
hdnode_private_ckd_prime(&node, 1);
ck_assert_int_eq(node.fingerprint, 0x13dab143);
ck_assert_mem_eq(node.chain_code, fromhex("a320425f77d1b5c2505a6b1b27382b37368ee640e3557c315416801243552f14"), 32);
ck_assert_mem_eq(node.private_key, fromhex("b1d0bad404bf35da785a64ca1ac54b2617211d2777696fbffaf208f746ae84f2"), 32);
ck_assert_mem_eq(node.public_key, fromhex("001932a5270f335bed617d5b935c80aedb1a35bd9fc1e31acafd5372c30f5c1187"), 33);
// [Chain m/0'/1'/2']
hdnode_private_ckd_prime(&node, 2);
ck_assert_int_eq(node.fingerprint, 0xebe4cb29);
ck_assert_mem_eq(node.chain_code, fromhex("2e69929e00b5ab250f49c3fb1c12f252de4fed2c1db88387094a0f8c4c9ccd6c"), 32);
ck_assert_mem_eq(node.private_key, fromhex("92a5b23c0b8a99e37d07df3fb9966917f5d06e02ddbd909c7e184371463e9fc9"), 32);
ck_assert_mem_eq(node.public_key, fromhex("00ae98736566d30ed0e9d2f4486a64bc95740d89c7db33f52121f8ea8f76ff0fc1"), 33);
// [Chain m/0'/1'/2'/2']
hdnode_private_ckd_prime(&node, 2);
ck_assert_int_eq(node.fingerprint, 0x316ec1c6);
ck_assert_mem_eq(node.chain_code, fromhex("8f6d87f93d750e0efccda017d662a1b31a266e4a6f5993b15f5c1f07f74dd5cc"), 32);
ck_assert_mem_eq(node.private_key, fromhex("30d1dc7e5fc04c31219ab25a27ae00b50f6fd66622f6e9c913253d6511d1e662"), 32);
ck_assert_mem_eq(node.public_key, fromhex("008abae2d66361c879b900d204ad2cc4984fa2aa344dd7ddc46007329ac76c429c"), 33);
// [Chain m/0'/1'/2'/2'/1000000000']
hdnode_private_ckd_prime(&node, 1000000000);
ck_assert_int_eq(node.fingerprint, 0xd6322ccd);
ck_assert_mem_eq(node.chain_code, fromhex("68789923a0cac2cd5a29172a475fe9e0fb14cd6adb5ad98a3fa70333e7afa230"), 32);
ck_assert_mem_eq(node.private_key, fromhex("8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793"), 32);
ck_assert_mem_eq(node.public_key, fromhex("003c24da049451555d51a7014a37337aa4e12d41e485abccfa46b47dfb2af54b7a"), 33);
}
END_TEST
// test vector 2 from https://en.bitcoin.it/wiki/BIP_0032_TestVectors
START_TEST(test_bip32_ed25519_vector_2)
{
HDNode node;
int r;
// init m
hdnode_from_seed(fromhex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542"), 64, ED25519_NAME, &node);
// [Chain m]
ck_assert_int_eq(node.fingerprint, 0x00000000);
ck_assert_mem_eq(node.chain_code, fromhex("ef70a74db9c3a5af931b5fe73ed8e1a53464133654fd55e7a66f8570b8e33c3b"), 32);
ck_assert_mem_eq(node.private_key, fromhex("171cb88b1b3c1db25add599712e36245d75bc65a1a5c9e18d76f9f2b1eab4012"), 32);
ck_assert_mem_eq(node.public_key, fromhex("008fe9693f8fa62a4305a140b9764c5ee01e455963744fe18204b4fb948249308a"), 33);
// [Chain m/0']
r = hdnode_private_ckd_prime(&node, 0);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x31981b50);
ck_assert_mem_eq(node.chain_code, fromhex("0b78a3226f915c082bf118f83618a618ab6dec793752624cbeb622acb562862d"), 32);
ck_assert_mem_eq(node.private_key, fromhex("1559eb2bbec5790b0c65d8693e4d0875b1747f4970ae8b650486ed7470845635"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0086fab68dcb57aa196c77c5f264f215a112c22a912c10d123b0d03c3c28ef1037"), 33);
// [Chain m/0'/2147483647']
r = hdnode_private_ckd_prime(&node, 2147483647);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x1e9411b1);
ck_assert_mem_eq(node.chain_code, fromhex("138f0b2551bcafeca6ff2aa88ba8ed0ed8de070841f0c4ef0165df8181eaad7f"), 32);
ck_assert_mem_eq(node.private_key, fromhex("ea4f5bfe8694d8bb74b7b59404632fd5968b774ed545e810de9c32a4fb4192f4"), 32);
ck_assert_mem_eq(node.public_key, fromhex("005ba3b9ac6e90e83effcd25ac4e58a1365a9e35a3d3ae5eb07b9e4d90bcf7506d"), 33);
// [Chain m/0'/2147483647'/1']
r = hdnode_private_ckd_prime(&node, 1);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0xfcadf38c);
ck_assert_mem_eq(node.chain_code, fromhex("73bd9fff1cfbde33a1b846c27085f711c0fe2d66fd32e139d3ebc28e5a4a6b90"), 32);
ck_assert_mem_eq(node.private_key, fromhex("3757c7577170179c7868353ada796c839135b3d30554bbb74a4b1e4a5a58505c"), 32);
ck_assert_mem_eq(node.public_key, fromhex("002e66aa57069c86cc18249aecf5cb5a9cebbfd6fadeab056254763874a9352b45"), 33);
// [Chain m/0'/2147483647'/1'/2147483646']
r = hdnode_private_ckd_prime(&node, 2147483646);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0xaca70953);
ck_assert_mem_eq(node.chain_code, fromhex("0902fe8a29f9140480a00ef244bd183e8a13288e4412d8389d140aac1794825a"), 32);
ck_assert_mem_eq(node.private_key, fromhex("5837736c89570de861ebc173b1086da4f505d4adb387c6a1b1342d5e4ac9ec72"), 32);
ck_assert_mem_eq(node.public_key, fromhex("00e33c0f7d81d843c572275f287498e8d408654fdf0d1e065b84e2e6f157aab09b"), 33);
// [Chain m/0'/2147483647'/1'/2147483646'/2']
r = hdnode_private_ckd_prime(&node, 2);
ck_assert_int_eq(r, 1);
ck_assert_int_eq(node.fingerprint, 0x422c654b);
ck_assert_mem_eq(node.chain_code, fromhex("5d70af781f3a37b829f0d060924d5e960bdc02e85423494afc0b1a41bbe196d4"), 32);
ck_assert_mem_eq(node.private_key, fromhex("551d333177df541ad876a60ea71f00447931c0a9da16f227c11ea080d7391b8d"), 32);
ck_assert_mem_eq(node.public_key, fromhex("0047150c75db263559a70d5778bf36abbab30fb061ad69f69ece61a72b0cfa4fc0"), 33);
}
END_TEST
Added Unit test, fixed one corner case.
2016-04-25 20:24:44 +00:00
START_TEST(test_ecdsa_signature)
{
int res;
uint8_t digest[32];
uint8_t pubkey[65];
const ecdsa_curve *curve = &secp256k1;
// sha2(sha2("\x18Bitcoin Signed Message:\n\x0cHello World!"))
memcpy(digest, fromhex("de4e9524586d6fce45667f9ff12f661e79870c4105fa0fb58af976619bb11432"), 32);
// r = 2: Four points should exist
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000020123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 0);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("043fc5bf5fec35b6ffe6fd246226d312742a8c296bfa57dd22da509a2e348529b7ddb9faf8afe1ecda3c05e7b2bda47ee1f5a87e952742b22afca560b29d972fcf"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000020123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 1);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("0456d8089137b1fd0d890f8c7d4a04d0fd4520a30b19518ee87bd168ea12ed8090329274c4c6c0d9df04515776f2741eeffc30235d596065d718c3973e19711ad0"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000020123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 2);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("04cee0e740f41aab39156844afef0182dea2a8026885b10454a2d539df6f6df9023abfcb0f01c50bef3c0fa8e59a998d07441e18b1c60583ef75cc8b912fb21a15"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000020123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 3);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("0490d2bd2e9a564d6e1d8324fc6ad00aa4ae597684ecf4abea58bdfe7287ea4fa72968c2e5b0b40999ede3d7898d94e82c3f8dc4536a567a4bd45998c826a4c4b2"), 65);
memcpy(digest, fromhex("0000000000000000000000000000000000000000000000000000000000000000"), 32);
// r = 7: No point P with P.x = 7, but P.x = (order + 7) exists
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000070123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 2);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("044d81bb47a31ffc6cf1f780ecb1e201ec47214b651650867c07f13ad06e12a1b040de78f8dbda700f4d3cd7ee21b3651a74c7661809699d2be7ea0992b0d39797"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000070123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 3);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("044d81bb47a31ffc6cf1f780ecb1e201ec47214b651650867c07f13ad06e12a1b0bf21870724258ff0b2c32811de4c9ae58b3899e7f69662d41815f66c4f2c6498"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000070123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 0);
ck_assert_int_eq(res, 1);
memcpy(digest, fromhex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 32);
// r = 1: Two points P with P.x = 1, but P.x = (order + 7) doesn't exist
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000010123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 0);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("045d330b2f89dbfca149828277bae852dd4aebfe136982cb531a88e9e7a89463fe71519f34ea8feb9490c707f14bc38c9ece51762bfd034ea014719b7c85d2871b"), 65);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000010123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 1);
ck_assert_int_eq(res, 0);
ck_assert_mem_eq(pubkey, fromhex("049e609c3950e70d6f3e3f3c81a473b1d5ca72739d51debdd80230ae80cab05134a94285375c834a417e8115c546c41da83a263087b79ef1cae25c7b3c738daa2b"), 65);
// r = 0 is always invalid
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000010123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 2);
ck_assert_int_eq(res, 1);
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000000123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 0);
ck_assert_int_eq(res, 1);
// r >= order is always invalid
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd03641410123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 0);
ck_assert_int_eq(res, 1);
// check that overflow of r is handled
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("000000000000000000000000000000014551231950B75FC4402DA1722FC9BAEE0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), digest, 2);
ck_assert_int_eq(res, 1);
// s = 0 is always invalid
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000"), digest, 0);
ck_assert_int_eq(res, 1);
// s >= order is always invalid
res = ecdsa_verify_digest_recover(curve, pubkey, fromhex("0000000000000000000000000000000000000000000000000000000000000002fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), digest, 0);
ck_assert_int_eq(res, 1);
}
END_TEST
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
#define test_deterministic(KEY, MSG, K) do { \
replace SHA256/SHA512 prefix with sha256/sha512 (OpenSSL clash)
2014-02-19 20:26:42 +00:00
sha256_Raw((uint8_t *)MSG, strlen(MSG), buf); \
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = generate_k_rfc6979(curve, &k, fromhex(KEY), buf); \
simplify rfc6979 tests
2013-10-08 20:59:36 +00:00
ck_assert_int_eq(res, 0); \
bn_write_be(&k, buf); \
ck_assert_mem_eq(buf, fromhex(K), 32); \
} while (0)
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
START_TEST(test_rfc6979)
{
replace infinite loops with loops with counters
2013-09-27 13:55:55 +00:00
int res;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
bignum256 k;
uint8_t buf[32];
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
const ecdsa_curve *curve = &secp256k1;
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
simplify rfc6979 tests
2013-10-08 20:59:36 +00:00
test_deterministic("cca9fbcc1b41e5a95d369eaa6ddcff73b61a4efaa279cfc6567e8daa39cbaf50", "sample", "2df40ca70e639d89528a6b670d9d48d9165fdc0febc0974056bdce192b8e16a3");
test_deterministic("0000000000000000000000000000000000000000000000000000000000000001", "Satoshi Nakamoto", "8f8a276c19f4149656b280621e358cce24f5f52542772691ee69063b74f15d15");
test_deterministic("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140", "Satoshi Nakamoto", "33a19b60e25fb6f4435af53a3d42d493644827367e6453928554f43e49aa6f90");
test_deterministic("f8b8af8ce3c7cca5e300d33939540c10d45ce001b8f252bfbc57ba0342904181", "Alan Turing", "525a82b70e67874398067543fd84c83d30c175fdc45fdeee082fe13b1d7cfdf1");
test_deterministic("0000000000000000000000000000000000000000000000000000000000000001", "All those moments will be lost in time, like tears in rain. Time to die...", "38aa22d72376b4dbc472e06c3ba403ee0a394da63fc58d88686c611aba98d6b3");
test_deterministic("e91671c46231f833a6406ccbea0e3e392c76c167bac1cb013f6f1013980455c2", "There is a computer disease that anybody who works with computers knows about. It's a very serious disease and it interferes completely with the work. The trouble with computers is that you 'play' with them!", "1f4b84c23a86a221d233f2521be018d9318639d5b8bbd6374a8a59232d16ad3d");
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
}
END_TEST
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
START_TEST(test_sign_speed)
{
remove der encoding, introduce 33/65 bytes pubkeys, 64 bytes signature
2013-09-23 19:09:42 +00:00
uint8_t sig[64], priv_key[32], msg[256];
use -Wextra
2014-02-08 18:12:07 +00:00
size_t i;
int res;
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
for (i = 0; i < sizeof(msg); i++) {
msg[i] = i * 1103515245;
}
add test speed for nist256p1 curve as well
2016-04-25 22:17:13 +00:00
const ecdsa_curve *curve = &secp256k1;
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
clock_t t = clock();
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
memcpy(priv_key, fromhex("c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"), 32);
for (i = 0 ; i < 250; i++) {
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_sign(curve, priv_key, msg, sizeof(msg), sig, 0);
optimize computations
2013-09-27 13:42:52 +00:00
ck_assert_int_eq(res, 0);
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
}
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
memcpy(priv_key, fromhex("509a0382ff5da48e402967a671bdcde70046d07f0df52cff12e8e3883b426a0a"), 32);
for (i = 0 ; i < 250; i++) {
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_sign(curve, priv_key, msg, sizeof(msg), sig, 0);
optimize computations
2013-09-27 13:42:52 +00:00
ck_assert_int_eq(res, 0);
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
}
add test speed for nist256p1 curve as well
2016-04-25 22:17:13 +00:00
printf("SECP256k1 signing speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
curve = &nist256p1;
t = clock();
memcpy(priv_key, fromhex("c55ece858b0ddd5263f96810fe14437cd3b5e1fbd7c6a2ec1e031f05e86d8bd5"), 32);
for (i = 0 ; i < 250; i++) {
res = ecdsa_sign(curve, priv_key, msg, sizeof(msg), sig, 0);
ck_assert_int_eq(res, 0);
}
memcpy(priv_key, fromhex("509a0382ff5da48e402967a671bdcde70046d07f0df52cff12e8e3883b426a0a"), 32);
for (i = 0 ; i < 250; i++) {
res = ecdsa_sign(curve, priv_key, msg, sizeof(msg), sig, 0);
ck_assert_int_eq(res, 0);
}
printf("NIST256p1 signing speed: %0.2f sig/s\n", 500.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
}
END_TEST
START_TEST(test_verify_speed)
{
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
uint8_t sig[64], pub_key33[33], pub_key65[65], msg[256];
use -Wextra
2014-02-08 18:12:07 +00:00
size_t i;
int res;
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
for (i = 0; i < sizeof(msg); i++) {
msg[i] = i * 1103515245;
}
add test speed for nist256p1 curve as well
2016-04-25 22:17:13 +00:00
const ecdsa_curve *curve = &secp256k1;
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
clock_t t = clock();
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
memcpy(sig, fromhex("88dc0db6bc5efa762e75fbcc802af69b9f1fcdbdffce748d403f687f855556e610ee8035414099ac7d89cff88a3fa246d332dfa3c78d82c801394112dda039c2"), 64);
memcpy(pub_key33, fromhex("024054fd18aeb277aeedea01d3f3986ff4e5be18092a04339dcf4e524e2c0a0974"), 33);
memcpy(pub_key65, fromhex("044054fd18aeb277aeedea01d3f3986ff4e5be18092a04339dcf4e524e2c0a09746c7083ed2097011b1223a17a644e81f59aa3de22dac119fd980b36a8ff29a244"), 65);
make pubkey validation optional, extract options to separate header
2014-07-07 18:14:15 +00:00
for (i = 0 ; i < 25; i++) {
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_verify(curve, pub_key65, sig, msg, sizeof(msg));
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
ck_assert_int_eq(res, 0);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_verify(curve, pub_key33, sig, msg, sizeof(msg));
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
ck_assert_int_eq(res, 0);
}
memcpy(sig, fromhex("067040a2adb3d9deefeef95dae86f69671968a0b90ee72c2eab54369612fd524eb6756c5a1bb662f1175a5fa888763cddc3a07b8a045ef6ab358d8d5d1a9a745"), 64);
memcpy(pub_key33, fromhex("03ff45a5561a76be930358457d113f25fac790794ec70317eff3b97d7080d45719"), 33);
memcpy(pub_key65, fromhex("04ff45a5561a76be930358457d113f25fac790794ec70317eff3b97d7080d457196235193a15778062ddaa44aef7e6901b781763e52147f2504e268b2d572bf197"), 65);
make pubkey validation optional, extract options to separate header
2014-07-07 18:14:15 +00:00
for (i = 0 ; i < 25; i++) {
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_verify(curve, pub_key65, sig, msg, sizeof(msg));
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
ck_assert_int_eq(res, 0);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_verify(curve, pub_key33, sig, msg, sizeof(msg));
remove der encoding, introduce 33/65 bytes pubkeys, 64 bytes signature
2013-09-23 19:09:42 +00:00
ck_assert_int_eq(res, 0);
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
}
verify now supports compressed keys
2013-09-24 13:54:36 +00:00
add test speed for nist256p1 curve as well
2016-04-25 22:17:13 +00:00
printf("SECP256k1 verifying speed: %0.2f sig/s\n", 100.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
curve = &nist256p1;
t = clock();
memcpy(sig, fromhex("7ed26b02c7e9664baaaa1e6ab64b3350c65ff685a7502863f357029c21c92a0dd7f2ae56d229262a8c7e97a0bfe1e7f9fd80c29df97355afa52ca07b507cecb9"), 64);
memcpy(pub_key33, fromhex("035662d692de519699000c7f5f04b2714e6a7f358c567fbcc001107ab86e4a7dea"), 33);
memcpy(pub_key65, fromhex("045662d692de519699000c7f5f04b2714e6a7f358c567fbcc001107ab86e4a7dea40523030e793724473d3cd60e436cbfc0a6e4ac5a5d0b340c5d637c6c870c00f"), 65);
for (i = 0 ; i < 25; i++) {
res = ecdsa_verify(curve, pub_key65, sig, msg, sizeof(msg));
//ck_assert_int_eq(res, 0);
res = ecdsa_verify(curve, pub_key33, sig, msg, sizeof(msg));
//ck_assert_int_eq(res, 0);
}
memcpy(sig, fromhex("6e13956f4227e66264dfcd92cf40b3b253622e96b1e1030392c0b06d9570f725dd1542164a481c0342ceb0b575f3516df536b7b90da57c381dfbd1aac6138c0b"), 64);
memcpy(pub_key33, fromhex("034b17f6b5c42b1be32c09f49056ee793e67f3ff42058123ce72fffc61d7236bc2"), 33);
memcpy(pub_key65, fromhex("044b17f6b5c42b1be32c09f49056ee793e67f3ff42058123ce72fffc61d7236bc29b6c29cbbbb2681d2b2e9c699cde8e591650d02bf4bb577ec53fd229442882e5"), 65);
for (i = 0 ; i < 25; i++) {
res = ecdsa_verify(curve, pub_key65, sig, msg, sizeof(msg));
//ck_assert_int_eq(res, 0);
res = ecdsa_verify(curve, pub_key33, sig, msg, sizeof(msg));
//ck_assert_int_eq(res, 0);
}
printf("NIST256p1 verifying speed: %0.2f sig/s\n", 100.0f / ((float)(clock() - t) / CLOCKS_PER_SEC));
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
}
END_TEST
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
// test vectors from http://www.inconteam.com/software-development/41-encryption/55-aes-test-vectors
START_TEST(test_aes)
add blowfish algo with tests
2013-10-07 19:10:39 +00:00
{
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
aes_encrypt_ctx ctxe;
aes_decrypt_ctx ctxd;
rename aes_ctr_counter_inc to aes_ctr_cbuf_inc and move it to aes_modes.c
2014-06-07 12:13:05 +00:00
uint8_t ibuf[16], obuf[16], iv[16], cbuf[16];
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
const char **ivp, **plainp, **cipherp;
// ECB
static const char *ecb_vector[] = {
// plain cipher
"6bc1bee22e409f96e93d7e117393172a", "f3eed1bdb5d2a03c064b5a7e3db181f8",
"ae2d8a571e03ac9c9eb76fac45af8e51", "591ccb10d410ed26dc5ba74a31362870",
"30c81c46a35ce411e5fbc1191a0a52ef", "b6ed21b99ca6f4f9f153e7b1beafed1d",
"f69f2445df4f9b17ad2b417be66c3710", "23304b7a39f9f3ff067d8d8f9e24ecc7",
0, 0,
};
plainp = ecb_vector;
cipherp = ecb_vector + 1;
while (*plainp && *cipherp) {
// encrypt
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(ibuf, fromhex(*plainp), 16);
aes_ecb_encrypt(ibuf, obuf, 16, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
// decrypt
aes_decrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxd);
memcpy(ibuf, fromhex(*cipherp), 16);
aes_ecb_decrypt(ibuf, obuf, 16, &ctxd);
ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
plainp += 2; cipherp += 2;
}
// CBC
static const char *cbc_vector[] = {
// iv plain cipher
"000102030405060708090A0B0C0D0E0F", "6bc1bee22e409f96e93d7e117393172a", "f58c4c04d6e5f1ba779eabfb5f7bfbd6",
"F58C4C04D6E5F1BA779EABFB5F7BFBD6", "ae2d8a571e03ac9c9eb76fac45af8e51", "9cfc4e967edb808d679f777bc6702c7d",
"9CFC4E967EDB808D679F777BC6702C7D", "30c81c46a35ce411e5fbc1191a0a52ef", "39f23369a9d9bacfa530e26304231461",
"39F23369A9D9BACFA530E26304231461", "f69f2445df4f9b17ad2b417be66c3710", "b2eb05e2c39be9fcda6c19078c6a9d1b",
0, 0, 0,
};
ivp = cbc_vector;
plainp = cbc_vector + 1;
cipherp = cbc_vector + 2;
while (*plainp && *cipherp) {
// encrypt
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*plainp), 16);
aes_cbc_encrypt(ibuf, obuf, 16, iv, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
// decrypt
aes_decrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxd);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*cipherp), 16);
aes_cbc_decrypt(ibuf, obuf, 16, iv, &ctxd);
ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
ivp += 3; plainp += 3; cipherp += 3;
}
add blowfish algo with tests
2013-10-07 19:10:39 +00:00
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
// CFB
static const char *cfb_vector[] = {
"000102030405060708090A0B0C0D0E0F", "6bc1bee22e409f96e93d7e117393172a", "DC7E84BFDA79164B7ECD8486985D3860",
"DC7E84BFDA79164B7ECD8486985D3860", "ae2d8a571e03ac9c9eb76fac45af8e51", "39ffed143b28b1c832113c6331e5407b",
"39FFED143B28B1C832113C6331E5407B", "30c81c46a35ce411e5fbc1191a0a52ef", "df10132415e54b92a13ed0a8267ae2f9",
"DF10132415E54B92A13ED0A8267AE2F9", "f69f2445df4f9b17ad2b417be66c3710", "75a385741ab9cef82031623d55b1e471",
0, 0, 0,
};
ivp = cfb_vector;
plainp = cfb_vector + 1;
cipherp = cfb_vector + 2;
while (*plainp && *cipherp) {
// encrypt
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*plainp), 16);
aes_cfb_encrypt(ibuf, obuf, 16, iv, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
// decrypt (uses encryption)
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*cipherp), 16);
aes_cfb_decrypt(ibuf, obuf, 16, iv, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
ivp += 3; plainp += 3; cipherp += 3;
}
replace blowfish with rijndael
2013-10-10 12:58:59 +00:00
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
// OFB
static const char *ofb_vector[] = {
"000102030405060708090A0B0C0D0E0F", "6bc1bee22e409f96e93d7e117393172a", "dc7e84bfda79164b7ecd8486985d3860",
"B7BF3A5DF43989DD97F0FA97EBCE2F4A", "ae2d8a571e03ac9c9eb76fac45af8e51", "4febdc6740d20b3ac88f6ad82a4fb08d",
"E1C656305ED1A7A6563805746FE03EDC", "30c81c46a35ce411e5fbc1191a0a52ef", "71ab47a086e86eedf39d1c5bba97c408",
"41635BE625B48AFC1666DD42A09D96E7", "f69f2445df4f9b17ad2b417be66c3710", "0126141d67f37be8538f5a8be740e484",
0, 0, 0,
};
ivp = ofb_vector;
plainp = ofb_vector + 1;
cipherp = ofb_vector + 2;
while (*plainp && *cipherp) {
// encrypt
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*plainp), 16);
aes_ofb_encrypt(ibuf, obuf, 16, iv, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
// decrypt (uses encryption)
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
memcpy(iv, fromhex(*ivp), 16);
memcpy(ibuf, fromhex(*cipherp), 16);
aes_ofb_decrypt(ibuf, obuf, 16, iv, &ctxe);
ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
ivp += 3; plainp += 3; cipherp += 3;
}
replace blowfish with rijndael
2013-10-10 12:58:59 +00:00
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
// CTR
static const char *ctr_vector[] = {
// plain cipher
"6bc1bee22e409f96e93d7e117393172a", "601ec313775789a5b7a7f504bbf3d228",
"ae2d8a571e03ac9c9eb76fac45af8e51", "f443e3ca4d62b59aca84e990cacaf5c5",
"30c81c46a35ce411e5fbc1191a0a52ef", "2b0930daa23de94ce87017ba2d84988d",
"f69f2445df4f9b17ad2b417be66c3710", "dfc9c58db67aada613c2dd08457941a6",
0, 0,
};
// encrypt
plainp = ctr_vector;
cipherp = ctr_vector + 1;
rename aes_ctr_counter_inc to aes_ctr_cbuf_inc and move it to aes_modes.c
2014-06-07 12:13:05 +00:00
memcpy(cbuf, fromhex("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), 16);
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
while (*plainp && *cipherp) {
memcpy(ibuf, fromhex(*plainp), 16);
rename aes_ctr_counter_inc to aes_ctr_cbuf_inc and move it to aes_modes.c
2014-06-07 12:13:05 +00:00
aes_ctr_encrypt(ibuf, obuf, 16, cbuf, aes_ctr_cbuf_inc, &ctxe);
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
ck_assert_mem_eq(obuf, fromhex(*cipherp), 16);
plainp += 2; cipherp += 2;
}
// decrypt (uses encryption)
plainp = ctr_vector;
cipherp = ctr_vector + 1;
rename aes_ctr_counter_inc to aes_ctr_cbuf_inc and move it to aes_modes.c
2014-06-07 12:13:05 +00:00
memcpy(cbuf, fromhex("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"), 16);
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
aes_encrypt_key256(fromhex("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"), &ctxe);
while (*plainp && *cipherp) {
memcpy(ibuf, fromhex(*cipherp), 16);
rename aes_ctr_counter_inc to aes_ctr_cbuf_inc and move it to aes_modes.c
2014-06-07 12:13:05 +00:00
aes_ctr_decrypt(ibuf, obuf, 16, cbuf, aes_ctr_cbuf_inc, &ctxe);
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
ck_assert_mem_eq(obuf, fromhex(*plainp), 16);
plainp += 2; cipherp += 2;
}
add blowfish algo with tests
2013-10-07 19:10:39 +00:00
}
END_TEST
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
// test vectors from https://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors
START_TEST(test_pbkdf2_hmac_sha256)
{
uint8_t k[40], s[40];
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha256((uint8_t *)"password", 8, s, 4, 1, k);
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
ck_assert_mem_eq(k, fromhex("120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b"), 32);
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha256((uint8_t *)"password", 8, s, 4, 2, k);
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
ck_assert_mem_eq(k, fromhex("ae4d0c95af6b46d32d0adff928f06dd02a303f8ef3c251dfd6e2d85a95474c43"), 32);
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha256((uint8_t *)"password", 8, s, 4, 4096, k);
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
ck_assert_mem_eq(k, fromhex("c5e478d59288c841aa530db6845c4c8d962893a001ce4e11a4963873aa98134a"), 32);
strcpy((char *)s, "saltSALTsaltSALTsaltSALTsaltSALTsalt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha256((uint8_t *)"passwordPASSWORDpassword", 3*8, s, 9*4, 4096, k);
ck_assert_mem_eq(k, fromhex("348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c4e2a1fb8dd53e1"), 32);
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
}
END_TEST
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
// test vectors from http://stackoverflow.com/questions/15593184/pbkdf2-hmac-sha-512-test-vectors
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
START_TEST(test_pbkdf2_hmac_sha512)
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
{
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
uint8_t k[64], s[40];
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha512((uint8_t *)"password", 8, s, 4, 1, k);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
ck_assert_mem_eq(k, fromhex("867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce"), 64);
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha512((uint8_t *)"password", 8, s, 4, 2, k);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
ck_assert_mem_eq(k, fromhex("e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e"), 64);
strcpy((char *)s, "salt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha512((uint8_t *)"password", 8, s, 4, 4096, k);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
ck_assert_mem_eq(k, fromhex("d197b1b33db0143e018b12f3d1d1479e6cdebdcc97c5c0f87f6902e072f457b5143f30602641b3d55cd335988cb36b84376060ecd532e039b742a239434af2d5"), 64);
strcpy((char *)s, "saltSALTsaltSALTsaltSALTsaltSALTsalt");
simplify pbkdf2 (support only klen == hashlen) and split it
2016-04-30 22:50:12 +00:00
pbkdf2_hmac_sha512((uint8_t *)"passwordPASSWORDpassword", 3*8, s, 9*4, 4096, k);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
ck_assert_mem_eq(k, fromhex("8c0511f4c6e597c6ac6315d8f0362e225f3c501495ba23b868c005174dc4ee71115b59f9e60cd9532fa33e0f75aefe30225c583a186cd82bd4daea9724a3d3b8"), 64);
}
END_TEST
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
START_TEST(test_mnemonic)
{
static const char *vectors[] = {
"00000000000000000000000000000000",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"legal winner thank year wave sausage worth useful legal winner thank yellow",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"80808080808080808080808080808080",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"ffffffffffffffffffffffffffffffff",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"000000000000000000000000000000000000000000000000",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"808080808080808080808080808080808080808080808080",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"ffffffffffffffffffffffffffffffffffffffffffffffff",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"0000000000000000000000000000000000000000000000000000000000000000",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"8080808080808080808080808080808080808080808080808080808080808080",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f",
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
implement public child key derivation
2014-01-14 13:35:13 +00:00
"dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad",
"77c2b00716cec7213839159e404db50d",
"jelly better achieve collect unaware mountain thought cargo oxygen act hood bridge",
"b5b6d0127db1a9d2226af0c3346031d77af31e918dba64287a1b44b8ebf63cdd52676f672a290aae502472cf2d602c051f3e6f18055e84e4c43897fc4e51a6ff",
"b63a9c59a6e641f288ebc103017f1da9f8290b3da6bdef7b",
"renew stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
"9248d83e06f4cd98debf5b6f010542760df925ce46cf38a1bdb4e4de7d21f5c39366941c69e1bdbf2966e0f6e6dbece898a0e2f0a4c2b3e640953dfe8b7bbdc5",
"3e141609b97933b66a060dcddc71fad1d91677db872031e85f4c015c5e7e8982",
"dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic",
"ff7f3184df8696d8bef94b6c03114dbee0ef89ff938712301d27ed8336ca89ef9635da20af07d4175f2bf5f3de130f39c9d9e8dd0472489c19b1a020a940da67",
"0460ef47585604c5660618db2e6a7e7f",
"afford alter spike radar gate glance object seek swamp infant panel yellow",
"65f93a9f36b6c85cbe634ffc1f99f2b82cbb10b31edc7f087b4f6cb9e976e9faf76ff41f8f27c99afdf38f7a303ba1136ee48a4c1e7fcd3dba7aa876113a36e4",
"72f60ebac5dd8add8d2a25a797102c3ce21bc029c200076f",
"indicate race push merry suffer human cruise dwarf pole review arch keep canvas theme poem divorce alter left",
"3bbf9daa0dfad8229786ace5ddb4e00fa98a044ae4c4975ffd5e094dba9e0bb289349dbe2091761f30f382d4e35c4a670ee8ab50758d2c55881be69e327117ba",
"2c85efc7f24ee4573d2b81a6ec66cee209b2dcbd09d8eddc51e0215b0b68e416",
"clutch control vehicle tonight unusual clog visa ice plunge glimpse recipe series open hour vintage deposit universe tip job dress radar refuse motion taste",
"fe908f96f46668b2d5b37d82f558c77ed0d69dd0e7e043a5b0511c48c2f1064694a956f86360c93dd04052a8899497ce9e985ebe0c8c52b955e6ae86d4ff4449",
"eaebabb2383351fd31d703840b32e9e2",
"turtle front uncle idea crush write shrug there lottery flower risk shell",
"bdfb76a0759f301b0b899a1e3985227e53b3f51e67e3f2a65363caedf3e32fde42a66c404f18d7b05818c95ef3ca1e5146646856c461c073169467511680876c",
"7ac45cfe7722ee6c7ba84fbc2d5bd61b45cb2fe5eb65aa78",
"kiss carry display unusual confirm curtain upgrade antique rotate hello void custom frequent obey nut hole price segment",
"ed56ff6c833c07982eb7119a8f48fd363c4a9b1601cd2de736b01045c5eb8ab4f57b079403485d1c4924f0790dc10a971763337cb9f9c62226f64fff26397c79",
"4fa1a8bc3e6d80ee1316050e862c1812031493212b7ec3f3bb1b08f168cabeef",
"exile ask congress lamp submit jacket era scheme attend cousin alcohol catch course end lucky hurt sentence oven short ball bird grab wing top",
"095ee6f817b4c2cb30a5a797360a81a40ab0f9a4e25ecd672a3f58a0b5ba0687c096a6b14d2c0deb3bdefce4f61d01ae07417d502429352e27695163f7447a8c",
"18ab19a9f54a9274f03e5209a2ac8a91",
"board flee heavy tunnel powder denial science ski answer betray cargo cat",
"6eff1bb21562918509c73cb990260db07c0ce34ff0e3cc4a8cb3276129fbcb300bddfe005831350efd633909f476c45c88253276d9fd0df6ef48609e8bb7dca8",
"18a2e1d81b8ecfb2a333adcb0c17a5b9eb76cc5d05db91a4",
"board blade invite damage undo sun mimic interest slam gaze truly inherit resist great inject rocket museum chief",
"f84521c777a13b61564234bf8f8b62b3afce27fc4062b51bb5e62bdfecb23864ee6ecf07c1d5a97c0834307c5c852d8ceb88e7c97923c0a3b496bedd4e5f88a9",
"15da872c95a13dd738fbf50e427583ad61f18fd99f628c417a61cf8343c90419",
"beyond stage sleep clip because twist token leaf atom beauty genius food business side grid unable middle armed observe pair crouch tonight away coconut",
"b15509eaa2d09d3efd3e006ef42151b30367dc6e3aa5e44caba3fe4d3e352e65101fbdb86a96776b91946ff06f8eac594dc6ee1d3e82a42dfe1b40fef6bcc3fd",
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
0,
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
0,
0,
};
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
const char **a, **b, **c, *m;
uint8_t seed[64];
a = vectors;
b = vectors + 1;
c = vectors + 2;
while (*a && *b && *c) {
m = mnemonic_from_data(fromhex(*a), strlen(*a) / 2);
ck_assert_str_eq(m, *b);
add progress_callback to mnemonic/pbkdf2 functions
2014-03-11 19:09:15 +00:00
mnemonic_to_seed(m, "TREZOR", seed, 0);
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
ck_assert_mem_eq(seed, fromhex(*c), strlen(*c) / 2);
implement bip39 cache
2016-01-19 14:11:57 +00:00
#if USE_BIP39_CACHE
// try second time to check whether caching results work
mnemonic_to_seed(m, "TREZOR", seed, 0);
ck_assert_mem_eq(seed, fromhex(*c), strlen(*c) / 2);
#endif
reworked bip39 including tests
2013-11-25 21:46:54 +00:00
a += 3; b += 3; c += 3;
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
}
}
END_TEST
add mnemonic_check function
2014-03-12 19:45:51 +00:00
START_TEST(test_mnemonic_check)
{
static const char *vectors_ok[] = {
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
"legal winner thank year wave sausage worth useful legal winner thank yellow",
"letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
"jelly better achieve collect unaware mountain thought cargo oxygen act hood bridge",
"renew stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
"dignity pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic",
"afford alter spike radar gate glance object seek swamp infant panel yellow",
"indicate race push merry suffer human cruise dwarf pole review arch keep canvas theme poem divorce alter left",
"clutch control vehicle tonight unusual clog visa ice plunge glimpse recipe series open hour vintage deposit universe tip job dress radar refuse motion taste",
"turtle front uncle idea crush write shrug there lottery flower risk shell",
"kiss carry display unusual confirm curtain upgrade antique rotate hello void custom frequent obey nut hole price segment",
"exile ask congress lamp submit jacket era scheme attend cousin alcohol catch course end lucky hurt sentence oven short ball bird grab wing top",
"board flee heavy tunnel powder denial science ski answer betray cargo cat",
"board blade invite damage undo sun mimic interest slam gaze truly inherit resist great inject rocket museum chief",
"beyond stage sleep clip because twist token leaf atom beauty genius food business side grid unable middle armed observe pair crouch tonight away coconut",
0,
};
static const char *vectors_fail[] = {
"above abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
"above winner thank year wave sausage worth useful legal winner thank yellow",
"above advice cage absurd amount doctor acoustic avoid letter advice cage above",
"above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
"above abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
"above winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
"above advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
"above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
"above abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
"above winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
"above advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
"above zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
"above better achieve collect unaware mountain thought cargo oxygen act hood bridge",
"above stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
"above pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic",
"above alter spike radar gate glance object seek swamp infant panel yellow",
"above race push merry suffer human cruise dwarf pole review arch keep canvas theme poem divorce alter left",
"above control vehicle tonight unusual clog visa ice plunge glimpse recipe series open hour vintage deposit universe tip job dress radar refuse motion taste",
"above front uncle idea crush write shrug there lottery flower risk shell",
"above carry display unusual confirm curtain upgrade antique rotate hello void custom frequent obey nut hole price segment",
"above ask congress lamp submit jacket era scheme attend cousin alcohol catch course end lucky hurt sentence oven short ball bird grab wing top",
"above flee heavy tunnel powder denial science ski answer betray cargo cat",
"above blade invite damage undo sun mimic interest slam gaze truly inherit resist great inject rocket museum chief",
"above stage sleep clip because twist token leaf atom beauty genius food business side grid unable middle armed observe pair crouch tonight away coconut",
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
"winner thank year wave sausage worth useful legal winner thank yellow",
"advice cage absurd amount doctor acoustic avoid letter advice cage above",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong",
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
"winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
"advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when",
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
"winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
"advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
"better achieve collect unaware mountain thought cargo oxygen act hood bridge",
"stay biology evidence goat welcome casual join adapt armor shuffle fault little machine walk stumble urge swap",
"pass list indicate nasty swamp pool script soccer toe leaf photo multiply desk host tomato cradle drill spread actor shine dismiss champion exotic",
"alter spike radar gate glance object seek swamp infant panel yellow",
"race push merry suffer human cruise dwarf pole review arch keep canvas theme poem divorce alter left",
"control vehicle tonight unusual clog visa ice plunge glimpse recipe series open hour vintage deposit universe tip job dress radar refuse motion taste",
"front uncle idea crush write shrug there lottery flower risk shell",
"carry display unusual confirm curtain upgrade antique rotate hello void custom frequent obey nut hole price segment",
"ask congress lamp submit jacket era scheme attend cousin alcohol catch course end lucky hurt sentence oven short ball bird grab wing top",
"flee heavy tunnel powder denial science ski answer betray cargo cat",
"blade invite damage undo sun mimic interest slam gaze truly inherit resist great inject rocket museum chief",
"stage sleep clip because twist token leaf atom beauty genius food business side grid unable middle armed observe pair crouch tonight away coconut",
0,
};
const char **m;
int r;
m = vectors_ok;
while (*m) {
r = mnemonic_check(*m);
ck_assert_int_eq(r, 1);
m++;
}
m = vectors_fail;
while (*m) {
r = mnemonic_check(*m);
ck_assert_int_eq(r, 0);
m++;
}
}
END_TEST
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
START_TEST(test_address)
{
replace base58 implementation
2014-12-23 00:17:58 +00:00
char address[36];
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
uint8_t pub_key[65];
memcpy(pub_key, fromhex("0226659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "139MaMHp3Vjo8o4x8N1ZLWEtovLGvBsg6s");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mhfJsQNnrXB3uuYZqvywARTDfuvyjg4RBh");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "MxiimznnxsqMfLKTQBL8Z2PoY9jKpjgkCu");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LMNJqZbe89yrPbm7JVzrcXJf28hZ1rKPaH");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("025b1654a0e78d28810094f6c5a96b8efb8a65668b578f170ac2b1f83bc63ba856"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "19Ywfm3witp6C1yBMy4NRYHY2347WCRBfQ");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mp4txp8vXvFLy8So5Y2kFTVrt2epN6YzdP");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "N58JsQYveGueiZDgdnNwe4SSkGTAToutAY");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LTmtvyMmoZ49SpfLY73fhZMJEFRPdyohKh");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("03433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7fe"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "1FWE2bn3MWhc4QidcF6AvEWpK77sSi2cAP");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mv2BKes2AY8rqXCFKp4Yk9j9B6iaMfWRLN");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "NB5bEFH2GtoAawy8t4Qk8kfj3LWvQs3MhB");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LZjBHp5sSAwfKDQnnP5UCFaaXKV9YheGxQ");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("03aeb03abeee0f0f8b4f7a5d65ce31f9570cef9f72c2dd8a19b4085a30ab033d48"), 33);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "1yrZb8dhdevoqpUEGi2tUccUEeiMKeLcs");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mgVoreDcWf6BaxJ5wqgQiPpwLEFRLSr8U8");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "MwZDmEdcd1kVLP4yW62c6zmXCU3mNbveDo");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LLCopoSTnHtz4eWdQQhLAVgNgT1zTi4QBK");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"), 65);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "194SZbL75xCCGBbKtMsyWLE5r9s2V6mhVM");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "moaPreR5tydT3J4wbvrMLFSQi9TjPCiZc6");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "N4domEq61LHkniqqABCYirNzaPG5NRU8GH");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LTHPpodwAcSFWzHV4VsGnMHr4NEJajMnKX");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("0498010f8a687439ff497d3074beb4519754e72c4b6220fb669224749591dde416f3961f8ece18f8689bb32235e436874d2174048b86118a00afbd5a4f33a24f0f"), 65);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "1A2WfBD4BJFwYHFPc5KgktqtbdJLBuVKc4");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mpYTxEJ2zKhCKPj1KeJ4ap4DTcu39T3uzD");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "N5bsrpi36gMW4pVtsteFyQzoKrhPE7nkxK");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LUFTvPWtFxVzo5wYnDJz2uueoqfcMYiuxH");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
memcpy(pub_key, fromhex("04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf19b77a4d"), 65);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_address(pub_key, 0, address, sizeof(address)); ck_assert_str_eq(address, "19J81hrPnQxg9UGx45ibTieCkb2ttm8CLL");
ecdsa_get_address(pub_key, 111, address, sizeof(address)); ck_assert_str_eq(address, "mop5JkwNbSPvvakZmegyHdrXcadbjLazww");
ecdsa_get_address(pub_key, 52, address, sizeof(address)); ck_assert_str_eq(address, "N4sVDMMNho4Eg1XTKu3AgEo7UpRwq3aNbn");
ecdsa_get_address(pub_key, 48, address, sizeof(address)); ck_assert_str_eq(address, "LTX5GvADs5CjQGy7EDhtjjhxxoQB2Uhicd");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
}
END_TEST
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
START_TEST(test_pubkey_validity)
{
uint8_t pub_key[65];
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
curve_point pub;
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
int res;
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
const ecdsa_curve *curve = &secp256k1;
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
memcpy(pub_key, fromhex("0226659c1cf7321c178c07437150639ff0c5b7679c7ea195253ed9abda2e081a37"), 33);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("025b1654a0e78d28810094f6c5a96b8efb8a65668b578f170ac2b1f83bc63ba856"), 33);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("03433f246a12e6486a51ff08802228c61cf895175a9b49ed4766ea9a9294a3c7fe"), 33);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("03aeb03abeee0f0f8b4f7a5d65ce31f9570cef9f72c2dd8a19b4085a30ab033d48"), 33);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("0496e8f2093f018aff6c2e2da5201ee528e2c8accbf9cac51563d33a7bb74a016054201c025e2a5d96b1629b95194e806c63eb96facaedc733b1a4b70ab3b33e3a"), 65);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("0498010f8a687439ff497d3074beb4519754e72c4b6220fb669224749591dde416f3961f8ece18f8689bb32235e436874d2174048b86118a00afbd5a4f33a24f0f"), 65);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf19b77a4d"), 65);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 1);
memcpy(pub_key, fromhex("04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2a59ebddbdac9e87b816307a7ed5b826b8f40b92719086238e1bebf00000000"), 65);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 0);
memcpy(pub_key, fromhex("04f80490839af36d13701ec3f9eebdac901b51c362119d74553a3c537faff31b17e2a59ebddbdac9e87b816307a7ed5b8211111111111111111111111111111111"), 65);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 0);
memcpy(pub_key, fromhex("00"), 1);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
res = ecdsa_read_pubkey(curve, pub_key, &pub);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
ck_assert_int_eq(res, 0);
}
END_TEST
use new base58 code for address functions, add function for obtaining wif
2014-05-22 20:25:08 +00:00
START_TEST(test_wif)
{
uint8_t priv_key[32];
char wif[53];
memcpy(priv_key, fromhex("1111111111111111111111111111111111111111111111111111111111111111"), 32);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_wif(priv_key, 0x80, wif, sizeof(wif)); ck_assert_str_eq(wif, "KwntMbt59tTsj8xqpqYqRRWufyjGunvhSyeMo3NTYpFYzZbXJ5Hp");
ecdsa_get_wif(priv_key, 0xEF, wif, sizeof(wif)); ck_assert_str_eq(wif, "cN9spWsvaxA8taS7DFMxnk1yJD2gaF2PX1npuTpy3vuZFJdwavaw");
use new base58 code for address functions, add function for obtaining wif
2014-05-22 20:25:08 +00:00
memcpy(priv_key, fromhex("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"), 32);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_wif(priv_key, 0x80, wif, sizeof(wif)); ck_assert_str_eq(wif, "L4ezQvyC6QoBhxB4GVs9fAPhUKtbaXYUn8YTqoeXwbevQq4U92vN");
ecdsa_get_wif(priv_key, 0xEF, wif, sizeof(wif)); ck_assert_str_eq(wif, "cV1ysqy3XUVSsPeKeugH2Utm6ZC1EyeArAgvxE73SiJvfa6AJng7");
use new base58 code for address functions, add function for obtaining wif
2014-05-22 20:25:08 +00:00
memcpy(priv_key, fromhex("47f7616ea6f9b923076625b4488115de1ef1187f760e65f89eb6f4f7ff04b012"), 32);
replace base58 implementation
2014-12-23 00:17:58 +00:00
ecdsa_get_wif(priv_key, 0x80, wif, sizeof(wif)); ck_assert_str_eq(wif, "KydbzBtk6uc7M6dXwEgTEH2sphZxSPbmDSz6kUUHi4eUpSQuhEbq");
ecdsa_get_wif(priv_key, 0xEF, wif, sizeof(wif)); ck_assert_str_eq(wif, "cPzbT6tbXyJNWY6oKeVabbXwSvsN6qhTHV8ZrtvoDBJV5BRY1G5Q");
use new base58 code for address functions, add function for obtaining wif
2014-05-22 20:25:08 +00:00
}
END_TEST
rework ecdsa_address_to_hash160 into ecdsa_address_decode
2014-01-31 14:26:51 +00:00
START_TEST(test_address_decode)
introduce ecdsa_address_to_hash160
2014-01-30 19:34:05 +00:00
{
rework ecdsa_address_to_hash160 into ecdsa_address_decode
2014-01-31 14:26:51 +00:00
int res;
uint8_t decode[21];
// byte 0 : address type
// bytes 1-20 : pubkey hash 160
res = ecdsa_address_decode("1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("00c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);
res = ecdsa_address_decode("myTPjxggahXyAzuMcYp5JTkbybANyLsYBW", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("6fc4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);
res = ecdsa_address_decode("NEWoeZ6gh4CGvRgFAoAGh4hBqpxizGT6gZ", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("34c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);
res = ecdsa_address_decode("LdAPi7uXrLLmeh7u57pzkZc3KovxEDYRJq", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("30c4c5d791fcb4654a1ef5e03fe0ad3d9c598f9827"), 21);
res = ecdsa_address_decode("1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("0079fbfc3f34e7745860d76137da68f362380c606c"), 21);
res = ecdsa_address_decode("mrdwvWkma2D6n9mGsbtkazedQQuoksnqJV", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("6f79fbfc3f34e7745860d76137da68f362380c606c"), 21);
res = ecdsa_address_decode("N7hMq7AmgNsQXaYARrEwybbDGei9mcPNqr", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("3479fbfc3f34e7745860d76137da68f362380c606c"), 21);
res = ecdsa_address_decode("LWLwtfycqf1uFqypLAug36W4kdgNwrZdNs", decode);
ck_assert_int_eq(res, 1);
ck_assert_mem_eq(decode, fromhex("3079fbfc3f34e7745860d76137da68f362380c606c"), 21);
// invalid char
res = ecdsa_address_decode("1JwSSubhmg6i000jtyqhUYYH7bZg3Lfy1T", decode);
ck_assert_int_eq(res, 0);
// invalid address
res = ecdsa_address_decode("1111Subhmg6iPtRjtyqhUYYH7bZg3Lfy1T", decode);
ck_assert_int_eq(res, 0);
introduce ecdsa_address_to_hash160
2014-01-30 19:34:05 +00:00
}
END_TEST
add ecdsa_sig_to_der
2014-02-02 21:01:43 +00:00
START_TEST(test_ecdsa_der)
{
fix typos
2014-04-01 17:44:53 +00:00
uint8_t sig[64], der[72];
add ecdsa_sig_to_der
2014-02-02 21:01:43 +00:00
int res;
memcpy(sig, fromhex("9a0b7be0d4ed3146ee262b42202841834698bb3ee39c24e7437df208b8b70771"), 32);
memcpy(sig + 32, fromhex("2b79ab1e7736219387dffe8d615bbdba87e11477104b867ef47afed1a5ede781"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 71);
ck_assert_mem_eq(der, fromhex("30450221009a0b7be0d4ed3146ee262b42202841834698bb3ee39c24e7437df208b8b7077102202b79ab1e7736219387dffe8d615bbdba87e11477104b867ef47afed1a5ede781"), 71);
memcpy(sig, fromhex("6666666666666666666666666666666666666666666666666666666666666666"), 32);
memcpy(sig + 32, fromhex("7777777777777777777777777777777777777777777777777777777777777777"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 70);
ck_assert_mem_eq(der, fromhex("30440220666666666666666666666666666666666666666666666666666666666666666602207777777777777777777777777777777777777777777777777777777777777777"), 70);
memcpy(sig, fromhex("6666666666666666666666666666666666666666666666666666666666666666"), 32);
memcpy(sig + 32, fromhex("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 71);
ck_assert_mem_eq(der, fromhex("304502206666666666666666666666666666666666666666666666666666666666666666022100eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"), 71);
memcpy(sig, fromhex("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"), 32);
memcpy(sig + 32, fromhex("7777777777777777777777777777777777777777777777777777777777777777"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 71);
ck_assert_mem_eq(der, fromhex("3045022100eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee02207777777777777777777777777777777777777777777777777777777777777777"), 71);
memcpy(sig, fromhex("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"), 32);
memcpy(sig + 32, fromhex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 72);
ck_assert_mem_eq(der, fromhex("3046022100eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee022100ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), 72);
fix ecdsa_sig_to_der
2014-02-08 14:55:03 +00:00
memcpy(sig, fromhex("0000000000000000000000000000000000000000000000000000000000000066"), 32);
memcpy(sig + 32, fromhex("0000000000000000000000000000000000000000000000000000000000000077"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 8);
ck_assert_mem_eq(der, fromhex("3006020166020177"), 8);
memcpy(sig, fromhex("0000000000000000000000000000000000000000000000000000000000000066"), 32);
memcpy(sig + 32, fromhex("00000000000000000000000000000000000000000000000000000000000000ee"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 9);
ck_assert_mem_eq(der, fromhex("3007020166020200ee"), 9);
memcpy(sig, fromhex("00000000000000000000000000000000000000000000000000000000000000ee"), 32);
memcpy(sig + 32, fromhex("0000000000000000000000000000000000000000000000000000000000000077"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 9);
ck_assert_mem_eq(der, fromhex("3007020200ee020177"), 9);
memcpy(sig, fromhex("00000000000000000000000000000000000000000000000000000000000000ee"), 32);
memcpy(sig + 32, fromhex("00000000000000000000000000000000000000000000000000000000000000ff"), 32);
res = ecdsa_sig_to_der(sig, der);
ck_assert_int_eq(res, 10);
ck_assert_mem_eq(der, fromhex("3008020200ee020200ff"), 10);
add ecdsa_sig_to_der
2014-02-02 21:01:43 +00:00
}
END_TEST
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
static void test_codepoints_curve(const ecdsa_curve *curve) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
int i, j;
bignum256 a;
curve_point p, p1;
for (i = 0; i < 64; i++) {
for (j = 0; j < 8; j++) {
bn_zero(&a);
a.val[(4*i)/30] = (2*j+1) << (4*i % 30);
bn_normalize(&a);
// note that this is not a trivial test. We add 64 curve
// points in the table to get that particular curve point.
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
scalar_multiply(curve, &a, &p);
ck_assert_mem_eq(&p, &curve->cp[i][j], sizeof(curve_point));
bn_zero(&p.y); // test that point_multiply curve, is not a noop
point_multiply(curve, &a, &curve->G, &p);
ck_assert_mem_eq(&p, &curve->cp[i][j], sizeof(curve_point));
// mul 2 test. this should catch bugs
bn_lshift(&a);
bn_mod(&a, &curve->order);
p1 = curve->cp[i][j];
point_double(curve, &p1);
// note that this is not a trivial test. We add 64 curve
// points in the table to get that particular curve point.
scalar_multiply(curve, &a, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &p1, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_zero(&p.y); // test that point_multiply curve, is not a noop
point_multiply(curve, &a, &curve->G, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &p1, sizeof(curve_point));
}
}
}
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
START_TEST(test_codepoints) {
test_codepoints_curve(&secp256k1);
test_codepoints_curve(&nist256p1);
}
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
END_TEST
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
static void test_mult_border_cases_curve(const ecdsa_curve *curve) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
bignum256 a;
curve_point p;
curve_point expected;
bn_zero(&a); // a == 0
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
scalar_multiply(curve, &a, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert(point_is_infinity(&p));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
point_multiply(curve, &a, &p, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert(point_is_infinity(&p));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
point_multiply(curve, &a, &curve->G, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert(point_is_infinity(&p));
Cleaned up bignum code 1. Fixed bn_multiply_step to handle small primes. 2. Removed many calls to bn_mod to prevent side-channel leakage.
2015-07-23 20:00:54 +00:00
bn_addi(&a, 1); // a == 1
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
scalar_multiply(curve, &a, &p);
ck_assert_mem_eq(&p, &curve->G, sizeof(curve_point));
point_multiply(curve, &a, &curve->G, &p);
ck_assert_mem_eq(&p, &curve->G, sizeof(curve_point));
bn_subtract(&curve->order, &a, &a); // a == -1
expected = curve->G;
bn_subtract(&curve->prime, &expected.y, &expected.y);
scalar_multiply(curve, &a, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
point_multiply(curve, &a, &curve->G, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_subtract(&curve->order, &a, &a);
Cleaned up bignum code 1. Fixed bn_multiply_step to handle small primes. 2. Removed many calls to bn_mod to prevent side-channel leakage.
2015-07-23 20:00:54 +00:00
bn_addi(&a, 1); // a == 2
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
expected = curve->G;
point_add(curve, &expected, &expected);
scalar_multiply(curve, &a, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
point_multiply(curve, &a, &curve->G, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_subtract(&curve->order, &a, &a); // a == -2
expected = curve->G;
point_add(curve, &expected, &expected);
bn_subtract(&curve->prime, &expected.y, &expected.y);
scalar_multiply(curve, &a, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
point_multiply(curve, &a, &curve->G, &p);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p, &expected, sizeof(curve_point));
}
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
START_TEST(test_mult_border_cases) {
test_mult_border_cases_curve(&secp256k1);
test_mult_border_cases_curve(&nist256p1);
}
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
END_TEST
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
static void test_scalar_mult_curve(const ecdsa_curve *curve) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
int i;
// get two "random" numbers
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bignum256 a = curve->G.x;
bignum256 b = curve->G.y;
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
curve_point p1, p2, p3;
for (i = 0; i < 1000; i++) {
/* test distributivity: (a + b)G = aG + bG */
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_mod(&a, &curve->order);
bn_mod(&b, &curve->order);
scalar_multiply(curve, &a, &p1);
scalar_multiply(curve, &b, &p2);
bn_addmod(&a, &b, &curve->order);
bn_mod(&a, &curve->order);
scalar_multiply(curve, &a, &p3);
point_add(curve, &p1, &p2);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p2, &p3, sizeof(curve_point));
// new "random" numbers
a = p3.x;
b = p3.y;
}
}
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
START_TEST(test_scalar_mult) {
test_scalar_mult_curve(&secp256k1);
test_scalar_mult_curve(&nist256p1);
}
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
END_TEST
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
static void test_point_mult_curve(const ecdsa_curve *curve) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
int i;
// get two "random" numbers and a "random" point
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bignum256 a = curve->G.x;
bignum256 b = curve->G.y;
curve_point p = curve->G;
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
curve_point p1, p2, p3;
for (i = 0; i < 200; i++) {
/* test distributivity: (a + b)P = aP + bP */
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_mod(&a, &curve->order);
bn_mod(&b, &curve->order);
point_multiply(curve, &a, &p, &p1);
point_multiply(curve, &b, &p, &p2);
bn_addmod(&a, &b, &curve->order);
bn_mod(&a, &curve->order);
point_multiply(curve, &a, &p, &p3);
point_add(curve, &p1, &p2);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p2, &p3, sizeof(curve_point));
// new "random" numbers and a "random" point
a = p1.x;
b = p1.y;
p = p3;
}
}
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
START_TEST(test_point_mult) {
test_point_mult_curve(&secp256k1);
test_point_mult_curve(&nist256p1);
}
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
END_TEST
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
static void test_scalar_point_mult_curve(const ecdsa_curve *curve) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
int i;
// get two "random" numbers
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bignum256 a = curve->G.x;
bignum256 b = curve->G.y;
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
curve_point p1, p2;
for (i = 0; i < 200; i++) {
/* test commutativity and associativity:
* a(bG) = (ab)G = b(aG)
*/
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_mod(&a, &curve->order);
bn_mod(&b, &curve->order);
scalar_multiply(curve, &a, &p1);
point_multiply(curve, &b, &p1, &p1);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
scalar_multiply(curve, &b, &p2);
point_multiply(curve, &a, &p2, &p2);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p1, &p2, sizeof(curve_point));
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
bn_multiply(&a, &b, &curve->order);
bn_mod(&b, &curve->order);
scalar_multiply(curve, &b, &p2);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
ck_assert_mem_eq(&p1, &p2, sizeof(curve_point));
// new "random" numbers
a = p1.x;
b = p1.y;
}
}
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
START_TEST(test_scalar_point_mult) {
test_scalar_point_mult_curve(&secp256k1);
test_scalar_point_mult_curve(&nist256p1);
}
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
END_TEST
add ecdsa_sig_to_der
2014-02-02 21:01:43 +00:00
add testcase for ed25519
2016-04-25 11:03:26 +00:00
START_TEST(test_ed25519) {
// test vectors from https://github.com/torproject/tor/blob/master/src/test/ed25519_vectors.inc
static const char *vectors[] = {
"26c76712d89d906e6672dafa614c42e5cb1caac8c6568e4d2493087db51f0d36", // secret
"c2247870536a192d142d056abefca68d6193158e7c1a59c1654c954eccaff894", // public
"d23188eac3773a316d46006fa59c095060be8b1a23582a0dd99002a82a0662bd246d8449e172e04c5f46ac0d1404cebe4aabd8a75a1457aa06cae41f3334f104", // selfsig
"fba7a5366b5cb98c2667a18783f5cf8f4f8d1a2ce939ad22a6e685edde85128d",
"1519a3b15816a1aafab0b213892026ebf5c0dc232c58b21088d88cb90e9b940d",
"3a785ac1201c97ee5f6f0d99323960d5f264c7825e61aa7cc81262f15bef75eb4fa5723add9b9d45b12311b6d403eb3ac79ff8e4e631fc3cd51e4ad2185b200b",
"67e3aa7a14fac8445d15e45e38a523481a69ae35513c9e4143eb1c2196729a0e",
"081faa81992e360ea22c06af1aba096e7a73f1c665bc8b3e4e531c46455fd1dd",
"cf431fd0416bfbd20c9d95ef9b723e2acddffb33900edc72195dea95965d52d888d30b7b8a677c0bd8ae1417b1e1a0ec6700deadd5d8b54b6689275e04a04509",
"d51385942033a76dc17f089a59e6a5a7fe80d9c526ae8ddd8c3a506b99d3d0a6",
"73cfa1189a723aad7966137cbffa35140bb40d7e16eae4c40b79b5f0360dd65a",
"2375380cd72d1a6c642aeddff862be8a5804b916acb72c02d9ed052c1561881aa658a5af856fcd6d43113e42f698cd6687c99efeef7f2ce045824440d26c5d00",
"5c8eac469bb3f1b85bc7cd893f52dc42a9ab66f1b02b5ce6a68e9b175d3bb433",
"66c1a77104d86461b6f98f73acf3cd229c80624495d2d74d6fda1e940080a96b",
"2385a472f599ca965bbe4d610e391cdeabeba9c336694b0d6249e551458280be122c2441dd9746a81bbfb9cd619364bab0df37ff4ceb7aefd24469c39d3bc508",
"eda433d483059b6d1ff8b7cfbd0fe406bfb23722c8f3c8252629284573b61b86",
"d21c294db0e64cb2d8976625786ede1d9754186ae8197a64d72f68c792eecc19",
"e500cd0b8cfff35442f88008d894f3a2fa26ef7d3a0ca5714ae0d3e2d40caae58ba7cdf69dd126994dad6be536fcda846d89dd8138d1683cc144c8853dce7607",
"4377c40431c30883c5fbd9bc92ae48d1ed8a47b81d13806beac5351739b5533d",
"c4d58b4cf85a348ff3d410dd936fa460c4f18da962c01b1963792b9dcc8a6ea6",
"d187b9e334b0050154de10bf69b3e4208a584e1a65015ec28b14bcc252cf84b8baa9c94867daa60f2a82d09ba9652d41e8dde292b624afc8d2c26441b95e3c0e",
"c6bbcce615839756aed2cc78b1de13884dd3618f48367a17597a16c1cd7a290b",
"95126f14d86494020665face03f2d42ee2b312a85bc729903eb17522954a1c4a",
"815213640a643d198bd056e02bba74e1c8d2d931643e84497adf3347eb485079c9afe0afce9284cdc084946b561abbb214f1304ca11228ff82702185cf28f60d",
0,
0,
0,
};
const char **ssk, **spk, **ssig;
ssk = vectors;
spk = vectors + 1;
ssig = vectors + 2;
ed25519_public_key pk;
ed25519_secret_key sk;
ed25519_signature sig;
while (*ssk && *spk && *ssig) {
memcpy(sk, fromhex(*ssk), 32);
ed25519_publickey(sk, pk);
ck_assert_mem_eq(pk, fromhex(*spk), 32);
ed25519_sign(pk, 32, sk, pk, sig);
ck_assert_mem_eq(sig, fromhex(*ssig), 64);
ssk += 3;
spk += 3;
ssig += 3;
}
}
END_TEST
add script parsing functions
2016-05-16 12:43:09 +00:00
START_TEST(test_output_script) {
static const char *vectors[] = {
"76A914010966776006953D5567439E5E39F86A0D273BEE88AC", "16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM",
"A914010966776006953D5567439E5E39F86A0D273BEE87", "31nVrspaydBz8aMpxH9WkS2DuhgqS1fCuG",
"0014010966776006953D5567439E5E39F86A0D273BEE", "p2xtZoXeX5X8BP8JfFhQK2nD3emtjch7UeFm",
"00200102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20", "7XhPD7te3C6CVKnJWUhrTJbFTwudhHqfrjpS59AS6sMzL4RYFiCNg",
0, 0,
};
const char **scr, **adr;
scr = vectors;
adr = vectors + 1;
char address[60];
while (*scr && *adr) {
int r = script_output_to_address(fromhex(*scr), strlen(*scr)/2, address, 60);
ck_assert_int_eq(r, strlen(*adr) + 1);
ck_assert_str_eq(address, *adr);
scr += 2;
adr += 2;
}
}
END_TEST
add testcase for ed25519
2016-04-25 11:03:26 +00:00
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
// define test suite and cases
Suite *test_suite(void)
{
renamed to trezor-crypto, modified readme
2013-10-08 12:18:35 +00:00
Suite *s = suite_create("trezor-crypto");
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
TCase *tc;
replace base58 implementation
2014-12-23 00:17:58 +00:00
tc = tcase_create("base58");
tcase_add_test(tc, test_base58);
suite_add_tcase(s, tc);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
tc = tcase_create("bip32");
tcase_add_test(tc, test_bip32_vector_1);
tcase_add_test(tc, test_bip32_vector_2);
new test to compare private and public branch of bip32
2014-02-21 19:30:22 +00:00
tcase_add_test(tc, test_bip32_compare);
add one more bip32_cache test
2015-03-04 14:43:14 +00:00
tcase_add_test(tc, test_bip32_cache_1);
tcase_add_test(tc, test_bip32_cache_2);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
suite_add_tcase(s, tc);
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
tc = tcase_create("bip32-nist");
ed25519 support
2016-04-22 15:47:48 +00:00
tcase_add_test(tc, test_bip32_nist_seed);
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
tcase_add_test(tc, test_bip32_nist_vector_1);
tcase_add_test(tc, test_bip32_nist_vector_2);
tcase_add_test(tc, test_bip32_nist_compare);
BIP-32 without gaps, prepare non-ecdsa curves * Split ecdsa_curve into curve_info and ecdsa_curve to support bip32 on curves that don't have a ecdsa_curve. * Don't fail in key derivation but retry with a new hash. * Adapted test case accordingly
2016-04-22 12:48:24 +00:00
tcase_add_test(tc, test_bip32_nist_repeat);
Unit tests for the NIST256P1 curve
2016-04-20 13:13:40 +00:00
suite_add_tcase(s, tc);
Test vectors for ed25519 + BIP-0032 / SLIP-0010
2016-04-23 21:42:53 +00:00
tc = tcase_create("bip32-ed25519");
tcase_add_test(tc, test_bip32_ed25519_vector_1);
tcase_add_test(tc, test_bip32_ed25519_vector_2);
suite_add_tcase(s, tc);
Added Unit test, fixed one corner case.
2016-04-25 20:24:44 +00:00
tc = tcase_create("ecdsa");
tcase_add_test(tc, test_ecdsa_signature);
suite_add_tcase(s, tc);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
tc = tcase_create("rfc6979");
tcase_add_test(tc, test_rfc6979);
suite_add_tcase(s, tc);
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
tc = tcase_create("speed");
tcase_add_test(tc, test_sign_speed);
tcase_add_test(tc, test_verify_speed);
suite_add_tcase(s, tc);
introduce ecdsa_address_to_hash160
2014-01-30 19:34:05 +00:00
tc = tcase_create("address");
add testcases for address generation fix bug for version != 0 process uncompressed pubkeys as well
2014-01-27 18:57:44 +00:00
tcase_add_test(tc, test_address);
suite_add_tcase(s, tc);
rework ecdsa_address_to_hash160 into ecdsa_address_decode
2014-01-31 14:26:51 +00:00
tc = tcase_create("address_decode");
tcase_add_test(tc, test_address_decode);
introduce ecdsa_address_to_hash160
2014-01-30 19:34:05 +00:00
suite_add_tcase(s, tc);
use new base58 code for address functions, add function for obtaining wif
2014-05-22 20:25:08 +00:00
tc = tcase_create("wif");
tcase_add_test(tc, test_wif);
suite_add_tcase(s, tc);
add ecdsa_sig_to_der
2014-02-02 21:01:43 +00:00
tc = tcase_create("ecdsa_der");
tcase_add_test(tc, test_ecdsa_der);
suite_add_tcase(s, tc);
update AES code to support different modes of operation, add unittests
2014-06-07 11:38:56 +00:00
tc = tcase_create("aes");
tcase_add_test(tc, test_aes);
add blowfish algo with tests
2013-10-07 19:10:39 +00:00
suite_add_tcase(s, tc);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
tc = tcase_create("pbkdf2");
split pbkdf2 into pbkdf2_hmac_sha256 and pbkdf2_hmac_sha512
2014-10-30 00:35:13 +00:00
tcase_add_test(tc, test_pbkdf2_hmac_sha256);
tcase_add_test(tc, test_pbkdf2_hmac_sha512);
use PBKDF2 for BIP39, add unit tests
2013-12-09 15:21:42 +00:00
suite_add_tcase(s, tc);
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
tc = tcase_create("bip39");
tcase_add_test(tc, test_mnemonic);
add mnemonic_check function
2014-03-12 19:45:51 +00:00
tcase_add_test(tc, test_mnemonic_check);
bip39 implementation with unit tests
2013-11-08 00:24:47 +00:00
suite_add_tcase(s, tc);
Tests for public key validity check.
2014-07-07 13:13:36 +00:00
tc = tcase_create("pubkey_validity");
tcase_add_test(tc, test_pubkey_validity);
suite_add_tcase(s, tc);
New Unit Tests - Added unit tests for the NIST curve. - Fix some missing bn_mod in unit tests. - New tests for tricky 2 (2j+1) 2^{4i} exponents.
2015-08-05 19:42:40 +00:00
tc = tcase_create("codepoints");
tcase_add_test(tc, test_codepoints);
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
suite_add_tcase(s, tc);
tc = tcase_create("mult_border_cases");
tcase_add_test(tc, test_mult_border_cases);
suite_add_tcase(s, tc);
tc = tcase_create("scalar_mult");
tcase_add_test(tc, test_scalar_mult);
suite_add_tcase(s, tc);
tc = tcase_create("point_mult");
tcase_add_test(tc, test_point_mult);
suite_add_tcase(s, tc);
tc = tcase_create("scalar_point_mult");
tcase_add_test(tc, test_scalar_point_mult);
suite_add_tcase(s, tc);
add testcase for ed25519
2016-04-25 11:03:26 +00:00
tc = tcase_create("ed25519");
tcase_add_test(tc, test_ed25519);
suite_add_tcase(s, tc);
add script parsing functions
2016-05-16 12:43:09 +00:00
tc = tcase_create("script");
tcase_add_test(tc, test_output_script);
suite_add_tcase(s, tc);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
return s;
}
// run suite
use more warnings from trezor-mcu
2014-07-07 19:34:54 +00:00
int main(void)
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
{
int number_failed;
Suite *s = test_suite();
SRunner *sr = srunner_create(s);
move speed tests to unit testing suite
2013-09-22 10:42:35 +00:00
srunner_run_all(sr, CK_VERBOSE);
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
number_failed = srunner_ntests_failed(sr);
srunner_free(sr);
use curly braces in if block
2015-04-11 18:01:45 +00:00
if (number_failed == 0) {
Added new tests for point multiplication
2015-04-11 10:48:24 +00:00
printf("PASSED ALL TESTS\n");
use curly braces in if block
2015-04-11 18:01:45 +00:00
}
use unit tests via Check instead of small test programs
2013-09-21 15:41:02 +00:00
return number_failed;
}
Reference in New Issue Copy Permalink