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; }