void test_utils()
{
char hash[] = "28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1";
uint8_t *hash_bin = utils_hex_to_uint8(hash);
char *new = utils_uint8_to_hex(hash_bin, 32);
assert(strncmp(new, hash, 64) == 0);
uint64_t bigint = 0xFFFFFFFFFFFFFFFF;
char vint[255];
int outlen;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 16);
assert(strncmp("ffffffffffffffffff", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 2);
assert(strncmp("fa", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 4);
assert(strncmp("fdfa0f", vint, outlen) == 0);
memset(vint, 0, 255);
bigint = 0xFFFFA;
utils_uint64_to_varint(vint, &outlen, bigint);
assert(outlen = 8);
assert(strncmp("fefaff0f00", vint, outlen) == 0);
char varint0[] = "fa";
utils_varint_to_uint64(varint0, &bigint);
assert(bigint == 250);
char varint1[] = "ffffffffffffffffff";
utils_varint_to_uint64(varint1, &bigint);
assert(bigint == 0xFFFFFFFFFFFFFFFF);
char varint2[] = "fdfa0f";
utils_varint_to_uint64(varint2, &bigint);
assert(bigint == 4090);
char varint3[] = "fefaff0f00";
utils_varint_to_uint64(varint3, &bigint);
assert(bigint == 1048570);
unsigned char data[] = {0x00, 0xFF, 0x00, 0xAA, 0x00, 0xFF, 0x00, 0xAA};
char hex[sizeof(data)*2+1];
utils_bin_to_hex(data, sizeof(data), hex);
assert(strcmp(hex, "00ff00aa00ff00aa") == 0);
unsigned char data2[sizeof(data)];
utils_hex_to_bin(hex, data2, strlen(hex), &outlen);
assert(outlen == 8);
assert(memcmp(data, data2, outlen) == 0);
}
void test_ecc()
{
unsigned char r_buf[32];
memset(r_buf, 0, 32);
random_init();
while (btc_ecc_verify_privatekey(r_buf) == 0) {
random_bytes(r_buf, 32, 0);
}
memset(r_buf, 0xFF, 32);
u_assert_int_eq(btc_ecc_verify_privatekey(r_buf), 0); //secp256k1 overflow
uint8_t pub_key33[33], pub_key33_invalid[33], pub_key65[65], pub_key65_invalid[65];
memcpy(pub_key33, utils_hex_to_uint8("02fcba7ecf41bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f"), 33);
memcpy(pub_key33_invalid, utils_hex_to_uint8("999999999941bc7e1be4ee122d9d22e3333671eb0a3a87b5cdf099d59874e1940f"), 33);
memcpy(pub_key65, utils_hex_to_uint8("044054fd18aeb277aeedea01d3f3986ff4e5be18092a04339dcf4e524e2c0a09746c7083ed2097011b1223a17a644e81f59aa3de22dac119fd980b36a8ff29a244"), 65);
memcpy(pub_key65_invalid, utils_hex_to_uint8("044054fd18aeb277aeedea01d3f3986ff4e5be18092a04339dcf4e524e2c0a09746c7083ed2097011b1223a17a644e81f59aa3de22dac119fd980b39999f29a244"), 65);
u_assert_int_eq(btc_ecc_verify_pubkey(pub_key33, 1), 1);
u_assert_int_eq(btc_ecc_verify_pubkey(pub_key65, 0), 1);
u_assert_int_eq(btc_ecc_verify_pubkey(pub_key33_invalid, 1), 0);
u_assert_int_eq(btc_ecc_verify_pubkey(pub_key65_invalid, 0), 0);
btc_key key;
btc_privkey_init(&key);
assert(btc_privkey_is_valid(&key) == 0);
btc_privkey_gen(&key);
uint8_t* hash = utils_hex_to_uint8((const char*)"26db47a48a10b9b0b697b793f5c0231aa35fe192c9d063d7b03a55e3c302850a");
unsigned char sig[74];
size_t outlen = 74;
btc_key_sign_hash(&key, hash, sig, &outlen);
uint8_t sigcomp[64];
unsigned char sigder[74];
size_t sigderlen = 74;
u_assert_int_eq(btc_ecc_der_to_compact(sig, outlen, sigcomp), true);
u_assert_int_eq(btc_ecc_compact_to_der_normalized(sigcomp, sigder, &sigderlen), true);
u_assert_int_eq(outlen, sigderlen);
u_assert_int_eq(memcmp(sig,sigder,sigderlen), 0);
}
void test_base58check()
{
const char** raw = base58_vector;
const char** str = base58_vector + 1;
uint8_t rawn[96];
char strn[53];
while (*raw && *str) {
size_t len = strlen(*raw) / 2;
memcpy(rawn, utils_hex_to_uint8(*raw), len);
int r = btc_base58_encode_check(rawn, len, strn, sizeof(strn));
assert(r == (int)strlen(*str) + 1);
assert(strcmp(strn, *str) == 0);
r = btc_base58_decode_check(strn, rawn, sizeof(rawn));
assert(r == (int)len + 4);
raw += 2;
str += 2;
}
const char** i_cmd = base58_invalid_vector;
const char** i_raw = base58_invalid_vector + 1;
uint8_t i_rawn[2048];
while (*i_raw && *i_cmd) {
size_t len = strlen(*i_raw) / 2;
memcpy(i_rawn, utils_hex_to_uint8(*i_raw), len);
unsigned char outbuf[1024];
int r = 0;
if (strncmp(*i_cmd, "ec", 2) == 0)
r = btc_base58_encode_check(i_rawn, len, strn, sizeof(strn));
else
r = btc_base58_decode_check(*i_raw, outbuf, sizeof(outbuf));
assert(r == 0);
i_raw += 2;
i_cmd += 2;
}
}
void test_bitcoin_hash()
{
const char data[] = "cea946542b91ca50e2afecba73cf546ce1383d82668ecb6265f79ffaa07daa49abb43e21a19c6b2b15c8882b4bc01085a8a5b00168139dcb8f4b2bbe22929ce196d43532898d98a3b0ea4d63112ba25e724bb50711e3cf55954cf30b4503b73d785253104c2df8c19b5b63e92bd6b1ff2573751ec9c508085f3f206c719aa4643776bf425344348cbf63f1450389";
const char expected[] = "52aa8dd6c598d91d580cc446624909e52a076064ffab67a1751f5758c9f76d26";
uint8_t* digest_expected;
digest_expected = utils_hex_to_uint8(expected);
uint8_t hashout[32];
btc_hash((const unsigned char *)data, strlen(data), hashout);
assert(memcmp(hashout, digest_expected, 32) == 0);
}
void test_serialize()
{
char hex0[] = "28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c1";
char hex1[] = "28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c2";
char hex2[] = "28969cdfa74a12c82f3bad960b0b000aca2ac329deea5c2328ebc6f2ba9802c3";
uint8_t* hash0 = malloc(32);
uint8_t* hash1 = malloc(32);
uint8_t* hash2 = malloc(32);
memcpy(hash0, utils_hex_to_uint8(hex0), 32);
memcpy(hash1, utils_hex_to_uint8(hex1), 32);
memcpy(hash2, utils_hex_to_uint8(hex2), 32);
vector* vec = vector_new(5, free);
vector_add(vec, hash0);
vector_add(vec, hash1);
vector_add(vec, hash2);
cstring* s = cstr_new_sz(200);
ser_u256_vector(s, vec);
vector_free(vec, true);
vector* vec2 = vector_new(0, NULL);
struct const_buffer buf = {s->str, s->len};
deser_u256_vector(&vec2, &buf);
vector_free(vec2, true);
cstr_free(s, true);
cstring* s2 = cstr_new_sz(200);
ser_u16(s2, 0xAAFF);
ser_u32(s2, 0xDDBBAAFF);
ser_u64(s2, 0x99FF99FFDDBBAAFF);
ser_varlen(s2, 10);
ser_varlen(s2, 1000);
ser_varlen(s2, 100000000);
ser_str(s2, "test", 4);
cstring* s3 = cstr_new("foo");
ser_varstr(s2, s3);
cstr_free(s3, true);
// ser_varlen(s2, (uint64_t)0x9999999999999999); // uint64 varlen is not supported right now
struct const_buffer buf2 = {s2->str, s2->len};
uint16_t num0;
deser_u16(&num0, &buf2);
assert(num0 == 43775); //0xAAFF
uint32_t num1;
deser_u32(&num1, &buf2);
assert(num1 == 3720063743); //0xDDBBAAFF
uint64_t num2;
deser_u64(&num2, &buf2);
assert(num2 == 0x99FF99FFDDBBAAFF); //0x99FF99FFDDBBAAFF
uint32_t num3;
deser_varlen(&num3, &buf2);
assert(num3 == 10);
deser_varlen(&num3, &buf2);
assert(num3 == 1000);
deser_varlen(&num3, &buf2);
assert(num3 == 100000000);
char strbuf[255];
deser_str(strbuf, &buf2, 255);
assert(strncmp(strbuf, "test", 4) == 0);
cstring* deser_test = cstr_new_sz(0);
deser_varstr(&deser_test, &buf2);
assert(strncmp(deser_test->str, "foo", 3) == 0);
cstr_free(deser_test, true);
cstr_free(s2, true);
}
// Encrypted storage
static int memory_eeprom_crypt(const uint8_t *write_b, uint8_t *read_b,
const int32_t addr)
{
int enc_len, dec_len;
char *enc, *dec, enc_r[MEM_PAGE_LEN * 4 + 1] = {0};
if (read_b) {
enc = aes_cbc_b64_encrypt((unsigned char *)utils_uint8_to_hex(read_b, MEM_PAGE_LEN),
MEM_PAGE_LEN * 2, &enc_len, PASSWORD_MEMORY);
if (!enc) {
goto err;
}
memcpy(enc_r, enc, enc_len);
free(enc);
}
if (write_b) {
char enc_w[MEM_PAGE_LEN * 4 + 1] = {0};
enc = aes_cbc_b64_encrypt((unsigned char *)utils_uint8_to_hex(write_b, MEM_PAGE_LEN),
MEM_PAGE_LEN * 2, &enc_len, PASSWORD_MEMORY);
if (!enc) {
goto err;
}
memcpy(enc_w, enc, enc_len);
free(enc);
if (memory_eeprom((uint8_t *)enc_w, (uint8_t *)enc_r, addr,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN, (uint8_t *)enc_r + MEM_PAGE_LEN,
addr + MEM_PAGE_LEN, MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN * 2,
(uint8_t *)enc_r + MEM_PAGE_LEN * 2, addr + MEM_PAGE_LEN * 2,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom((uint8_t *)enc_w + MEM_PAGE_LEN * 3,
(uint8_t *)enc_r + MEM_PAGE_LEN * 3, addr + MEM_PAGE_LEN * 3,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
} else {
if (memory_eeprom(NULL, (uint8_t *)enc_r, addr, MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN, addr + MEM_PAGE_LEN,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN * 2, addr + MEM_PAGE_LEN * 2,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
if (memory_eeprom(NULL, (uint8_t *)enc_r + MEM_PAGE_LEN * 3, addr + MEM_PAGE_LEN * 3,
MEM_PAGE_LEN) == STATUS_ERROR) {
goto err;
}
}
dec = aes_cbc_b64_decrypt((unsigned char *)enc_r, MEM_PAGE_LEN * 4, &dec_len,
PASSWORD_MEMORY);
if (!dec) {
goto err;
}
memcpy(read_b, utils_hex_to_uint8(dec), MEM_PAGE_LEN);
memset(dec, 0, dec_len);
free(dec);
utils_clear_buffers();
return STATUS_SUCCESS;
err:
utils_clear_buffers();
return STATUS_ERROR;
}
