#ifdef NDEBUG
# undef NDEBUG
#endif
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "hydrogen.h"
static const char *ctx = "libtests";
static int
streq(const char *expected, const char *found)
{
if (strcmp(expected, found) != 0) {
fprintf(stderr, "Found: [%s]\n", found);
return 0;
}
return 1;
}
#define assert_streq(EXPECTED, FOUND) assert(streq((EXPECTED), (FOUND)))
static void
test_randombytes(void)
{
uint8_t dk[hydro_random_SEEDBYTES];
uint8_t tmp[10000];
unsigned long b = 0U;
unsigned long bp;
uint32_t x;
size_t i, j;
for (i = 0; i < 10000; i++) {
x = hydro_random_u32();
for (j = 0; j < sizeof x; j++) {
b += (x >> j) & 1;
}
}
assert(b > 18000 && b < 22000);
b = 0;
hydro_random_buf(tmp, sizeof tmp);
for (i = 0; i < 10000; i++) {
for (j = 0; j < sizeof tmp[0]; j++) {
b += (tmp[i] >> j) & 1;
}
}
assert(b > 4500 && b < 5500);
memcpy(dk, tmp, sizeof dk);
b = 0;
hydro_random_buf_deterministic(tmp, 10000, dk);
for (i = 0; i < 10000; i++) {
for (j = 0; j < sizeof tmp[0]; j++) {
b += (tmp[i] >> j) & 1;
}
}
assert(b > 4500 && b < 5500);
bp = b;
b = 0;
hydro_random_buf_deterministic(tmp, 10000, dk);
for (i = 0; i < 10000; i++) {
for (j = 0; j < sizeof tmp[0]; j++) {
b += (tmp[i] >> j) & 1;
}
}
assert(b == bp);
for (i = 0; i < 1000; i++) {
for (j = 1; j < 100; j++) {
x = hydro_random_uniform((uint32_t) j);
assert(x < j);
}
}
}
static void
test_hash(void)
{
hydro_hash_state st;
uint8_t dk[hydro_random_SEEDBYTES];
uint8_t h[100];
uint8_t key[hydro_hash_KEYBYTES];
#ifdef __TRUSTINSOFT_ANALYZER__
uint8_t msg[32];
#else
uint8_t msg[1000];
#endif
char hex[100 * 2 + 1];
size_t i;
memset(dk, 0, sizeof dk);
hydro_random_buf_deterministic(key, sizeof key, dk);
hydro_increment(dk, sizeof dk);
hydro_hash_init(&st, ctx, key);
for (i = 0; i <= sizeof msg; i++) {
hydro_random_buf_deterministic(msg, i, dk);
hydro_increment(dk, sizeof dk);
hydro_hash_update(&st, msg, i);
}
hydro_hash_final(&st, h, sizeof h);
hydro_bin2hex(hex, sizeof hex, h, sizeof h);
#ifndef __TRUSTINSOFT_ANALYZER__
assert_streq(
"e5d2beb77a039965850ee76327e06b2fa6cb5121db8038b11bce4641a9c4bd843658104bdf07342570bb5fd1d7"
"2c0d31a8981b47c718fddaffbd4171605c873cbaf921bb57988dd814f3a3fbef9799ff7c762705c4bf37ab2981"
"5981bf0d8833d60afe14",
hex);
#endif
hydro_hash_hash(h, sizeof h, msg, sizeof msg, ctx, key);
hydro_bin2hex(hex, sizeof hex, h, sizeof h);
#ifndef __TRUSTINSOFT_ANALYZER__
assert_streq(
"724bd8883df73320ffd70923cb997f9a99bc670c4d78887be4975add0099fbf489b266a85d1f56743062d60a05"
"590cbce47e45108367879bf4641cbaefe584e8618cbeb8c230ae956da22c7c5c4f11a8804ca576ec20fa5da239"
"dde3d03a6018383c21f5",
hex);
#endif
hydro_hash_hash(h, hydro_hash_BYTES, msg, sizeof msg, ctx, key);
hydro_bin2hex(hex, sizeof hex, h, hydro_hash_BYTES);
#ifndef __TRUSTINSOFT_ANALYZER__
assert_streq("7dfa45ce18210e2422fd658bf7beccb6e534e44f99ae359f4af3ba41af8ca463", hex);
#endif
hydro_hash_hash(h, hydro_hash_BYTES, msg, 13, ctx, key);
hydro_bin2hex(hex, sizeof hex, h, hydro_hash_BYTES);
#ifndef __TRUSTINSOFT_ANALYZER__
assert_streq("d57a9800549bb4bab6a06fa6e16e08aad68d7d4313fb69a81b9f5d5af375dbe7", hex);
#endif
}
static void
test_core(void)
{
uint8_t x[100];
uint8_t y[100];
uint8_t a[5] = { 1, 2, 3, 4, 5 };
uint8_t b[5] = { 1, 2, 3, 4, 5 };
char hex[201];
const char *hexf;
memset(x, 0xd0, sizeof x);
hydro_memzero(x, sizeof x);
assert(x[0] == 0);
assert(x[sizeof x - 1] == 0);
hydro_increment(x, sizeof x);
assert(x[0] == 1);
assert(x[sizeof x - 1] == 0);
x[0] = 0xff;
hydro_increment(x, sizeof x);
assert(x[0] == 0);
assert(x[1] == 1);
assert(x[sizeof x - 1] == 0);
assert(hydro_equal(a, b, sizeof a));
assert(!hydro_equal(a, a, sizeof a));
assert(hydro_compare(a, b, sizeof a) == 0);
assert(hydro_compare(a, a, sizeof a) == 0);
a[0]++;
assert(hydro_compare(a, b, sizeof a) == 1);
assert(hydro_compare(b, a, sizeof a) == -1);
hydro_random_buf(x, sizeof x);
assert(hydro_bin2hex(hex, sizeof hex, x, sizeof x) != NULL);
assert(hydro_hex2bin(y, 1, hex, sizeof hex, NULL, NULL) == -1);
assert(hydro_hex2bin(y, sizeof y, hex, sizeof hex, NULL, NULL) == -1);
assert(hydro_hex2bin(y, sizeof y, hex, sizeof hex - 1, NULL, NULL) == sizeof x);
assert(hydro_equal(x, y, sizeof x));
assert(hydro_hex2bin(x, sizeof x, "452a", 4, NULL, NULL) == 2);
assert(hydro_hex2bin(y, sizeof y, "#452a#", 6, "#", NULL) == 2);
assert(hydro_equal(x, y, sizeof x));
memcpy(hex, "#452a", sizeof "#452a");
assert(hydro_hex2bin(x, sizeof x, hex, 0, NULL, &hexf) == 0);
assert(hexf == hex);
assert(hydro_hex2bin(x, sizeof x, hex, sizeof "#452a", NULL, &hexf) == 0);
assert(hexf == hex);
assert(hydro_hex2bin(x, sizeof x, hex, sizeof "#452a", "#", &hexf) == 2);
assert(hexf == hex + 6);
}
static void
test_secretbox(void)
{
uint8_t key[hydro_secretbox_KEYBYTES];
uint8_t m[25];
uint8_t m2[25];
uint8_t c[hydro_secretbox_HEADERBYTES + 25];
uint8_t dk[hydro_random_SEEDBYTES];
uint8_t probe[hydro_secretbox_PROBEBYTES];
memset(dk, 0, sizeof dk);
hydro_random_buf_deterministic(m, sizeof m, dk);
hydro_increment(dk, sizeof dk);
hydro_random_buf_deterministic(key, sizeof key, dk);
hydro_increment(dk, sizeof dk);
hydro_secretbox_encrypt(c, m, sizeof m, 0, ctx, key);
assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == 0);
assert(hydro_equal(m, m2, sizeof m));
hydro_secretbox_probe_create(probe, c, sizeof c, ctx, key);
assert(hydro_secretbox_probe_verify(probe, c, sizeof c, ctx, key) == 0);
probe[0]++;
assert(hydro_secretbox_probe_verify(probe, c, sizeof c, ctx, key) == -1);
probe[0]--;
key[0]++;
assert(hydro_secretbox_probe_verify(probe, c, sizeof c, ctx, key) == -1);
key[0]--;
assert(hydro_secretbox_decrypt(m2, c, 0, 0, ctx, key) == -1);
assert(hydro_secretbox_decrypt(m2, c, 1, 0, ctx, key) == -1);
assert(hydro_secretbox_decrypt(m2, c, hydro_secretbox_HEADERBYTES, 0, ctx, key) == -1);
assert(hydro_secretbox_decrypt(m2, c, sizeof c, 1, ctx, key) == -1);
assert(!hydro_equal(m, m2, sizeof m));
key[0]++;
assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == -1);
key[0]--;
c[hydro_random_uniform(sizeof c)]++;
assert(hydro_secretbox_decrypt(m2, c, sizeof c, 0, ctx, key) == -1);
}
static void
test_kdf(void)
{
uint8_t key[hydro_kdf_KEYBYTES];
uint8_t dk[hydro_random_SEEDBYTES];
uint8_t subkey1[16];
uint8_t subkey2[16];
uint8_t subkey3[32];
uint8_t subkey4[50];
char subkey1_hex[16 * 2 + 1];
char subkey2_hex[16 * 2 + 1];
char subkey3_hex[32 * 2 + 1];
char subkey4_hex[50 * 2 + 1];
memset(dk, 0, sizeof dk);
hydro_random_buf_deterministic(key, sizeof key, dk);
hydro_kdf_derive_from_key(subkey1, sizeof subkey1, 1, ctx, key);
hydro_kdf_derive_from_key(subkey2, sizeof subkey2, 2, ctx, key);
hydro_kdf_derive_from_key(subkey3, sizeof subkey3, 0, ctx, key);
hydro_kdf_derive_from_key(subkey4, sizeof subkey4, 0, ctx, key);
hydro_bin2hex(subkey1_hex, sizeof subkey1_hex, subkey1, sizeof subkey1);
hydro_bin2hex(subkey2_hex, sizeof subkey2_hex, subkey2, sizeof subkey2);
hydro_bin2hex(subkey3_hex, sizeof subkey3_hex, subkey3, sizeof subkey3);
hydro_bin2hex(subkey4_hex, sizeof subkey4_hex, subkey4, sizeof subkey4);
assert_streq("af8019d3516d4ba6c80a7ea5a87e4d77", subkey1_hex);
assert_streq("af8c4cba4e1f36c293631cc7001717dd", subkey2_hex);
assert_streq("ff9345489dea1e4fe59194cea8794c9b0af9380c2d18c3ab38eeef2af95c1e26", subkey3_hex);
assert_streq(
"a8dd79ca19d604d1487b82d76b8d4ad4138a29dfaeeb207b99b2e5904e7855555bb94a76070fa71871df6ed911"
"661d99efec",
subkey4_hex);
}
static void
test_sign(void)
{
#ifdef __TRUSTINSOFT_ANALYZER__
uint8_t msg[32];
#else
uint8_t msg[500];
#endif
uint8_t sig[hydro_sign_BYTES];
hydro_sign_state st;
hydro_sign_keypair kp;
hydro_random_buf(msg, sizeof msg);
hydro_sign_keygen(&kp);
hydro_sign_create(sig, msg, sizeof msg, ctx, kp.sk);
assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == 0);
sig[0]++;
assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == -1);
sig[0]--;
sig[hydro_sign_BYTES - 1]++;
assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == -1);
sig[hydro_sign_BYTES - 1]--;
msg[0]++;
assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == -1);
msg[0]++;
hydro_sign_create(sig, msg, sizeof msg, ctx, kp.sk);
hydro_sign_init(&st, ctx);
hydro_sign_update(&st, msg, (sizeof msg) / 3);
hydro_sign_update(&st, msg + (sizeof msg) / 3, (sizeof msg) - (sizeof msg) / 3);
assert(hydro_sign_final_verify(&st, sig, kp.pk) == 0);
hydro_sign_init(&st, ctx);
hydro_sign_update(&st, msg, (sizeof msg) / 3);
hydro_sign_update(&st, msg + (sizeof msg) / 3, (sizeof msg) - (sizeof msg) / 3);
hydro_sign_final_create(&st, sig, kp.sk);
hydro_sign_init(&st, ctx);
hydro_sign_update(&st, msg, (sizeof msg) / 3);
hydro_sign_update(&st, msg + (sizeof msg) / 3, (sizeof msg) - (sizeof msg) / 3);
assert(hydro_sign_final_verify(&st, sig, kp.pk) == 0);
hydro_sign_init(&st, ctx);
hydro_sign_update(&st, msg, (sizeof msg) / 3);
hydro_sign_update(&st, msg + (sizeof msg) / 3, (sizeof msg) - (sizeof msg) / 3);
sig[0]++;
assert(hydro_sign_final_verify(&st, sig, kp.pk) == -1);
hydro_sign_create(sig, msg, 0, ctx, kp.sk);
assert(hydro_sign_verify(sig, msg, sizeof msg, ctx, kp.pk) == -1);
assert(hydro_sign_verify(sig, msg, 0, ctx, kp.pk) == 0);
}
static void
test_kx_n(void)
{
hydro_kx_keypair server_static_kp;
uint8_t psk[hydro_kx_PSKBYTES];
uint8_t packet1[hydro_kx_N_PACKET1BYTES];
hydro_kx_session_keypair kp_client;
hydro_kx_session_keypair kp_server;
hydro_kx_keygen(&server_static_kp);
hydro_random_buf(psk, sizeof psk);
hydro_kx_n_1(&kp_client, packet1, psk, server_static_kp.pk);
hydro_kx_n_2(&kp_server, packet1, psk, &server_static_kp);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
}
static void
test_kx_kk(void)
{
hydro_kx_state st_client;
hydro_kx_keypair client_static_kp;
hydro_kx_keypair server_static_kp;
uint8_t packet1[hydro_kx_KK_PACKET1BYTES];
uint8_t packet2[hydro_kx_KK_PACKET2BYTES];
hydro_kx_session_keypair kp_client;
hydro_kx_session_keypair kp_server;
hydro_kx_keygen(&client_static_kp);
hydro_kx_keygen(&server_static_kp);
hydro_kx_kk_1(&st_client, packet1, server_static_kp.pk, &client_static_kp);
hydro_kx_kk_2(&kp_server, packet2, packet1, client_static_kp.pk, &server_static_kp);
hydro_kx_kk_3(&st_client, &kp_client, packet2, &client_static_kp);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
}
static void
test_kx_xx(void)
{
hydro_kx_state st_client;
hydro_kx_state st_server;
hydro_kx_keypair client_static_kp;
hydro_kx_keypair server_static_kp;
uint8_t psk[hydro_kx_PSKBYTES];
uint8_t client_peer_pk[hydro_kx_PUBLICKEYBYTES];
uint8_t server_peer_pk[hydro_kx_PUBLICKEYBYTES];
uint8_t packet1[hydro_kx_XX_PACKET1BYTES];
uint8_t packet2[hydro_kx_XX_PACKET2BYTES];
uint8_t packet3[hydro_kx_XX_PACKET3BYTES];
hydro_kx_session_keypair kp_client;
hydro_kx_session_keypair kp_server;
hydro_kx_keygen(&client_static_kp);
hydro_kx_keygen(&server_static_kp);
hydro_kx_xx_1(&st_client, packet1, NULL);
hydro_kx_xx_2(&st_server, packet2, packet1, NULL, &server_static_kp);
hydro_kx_xx_3(&st_client, &kp_client, packet3, NULL, packet2, NULL, &client_static_kp);
hydro_kx_xx_4(&st_server, &kp_server, NULL, packet3, NULL);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
hydro_random_buf(psk, sizeof psk);
hydro_kx_xx_1(&st_client, packet1, psk);
hydro_kx_xx_2(&st_server, packet2, packet1, psk, &server_static_kp);
hydro_kx_xx_3(&st_client, &kp_client, packet3, client_peer_pk, packet2, psk, &client_static_kp);
hydro_kx_xx_4(&st_server, &kp_server, server_peer_pk, packet3, psk);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(client_peer_pk, server_static_kp.pk, hydro_kx_PUBLICKEYBYTES));
assert(hydro_equal(server_peer_pk, client_static_kp.pk, hydro_kx_PUBLICKEYBYTES));
}
static void
test_kx_nk(void)
{
hydro_kx_state st_client;
hydro_kx_keypair server_static_kp;
uint8_t psk[hydro_kx_PSKBYTES];
uint8_t packet1[hydro_kx_NK_PACKET1BYTES];
uint8_t packet2[hydro_kx_NK_PACKET2BYTES];
hydro_kx_session_keypair kp_client;
hydro_kx_session_keypair kp_server;
hydro_kx_keygen(&server_static_kp);
hydro_kx_nk_1(&st_client, packet1, NULL, server_static_kp.pk);
hydro_kx_nk_2(&kp_server, packet2, packet1, NULL, &server_static_kp);
hydro_kx_nk_3(&st_client, &kp_client, packet2);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
hydro_random_buf(psk, sizeof psk);
hydro_kx_nk_1(&st_client, packet1, psk, server_static_kp.pk);
hydro_kx_nk_2(&kp_server, packet2, packet1, psk, &server_static_kp);
hydro_kx_nk_3(&st_client, &kp_client, packet2);
assert(hydro_equal(kp_client.tx, kp_server.rx, hydro_kx_SESSIONKEYBYTES));
assert(hydro_equal(kp_client.rx, kp_server.tx, hydro_kx_SESSIONKEYBYTES));
}
static void
test_pwhash(void)
{
uint8_t master_key[hydro_pwhash_MASTERKEYBYTES];
uint8_t new_master_key[hydro_pwhash_MASTERKEYBYTES];
uint8_t stored[hydro_pwhash_STOREDBYTES];
uint8_t h[64];
uint8_t static_key[64];
char h_hex[2 * 64 + 1];
unsigned long long ops = 1000;
memset(master_key, 'x', sizeof master_key);
hydro_pwhash_deterministic(h, sizeof h, "test", sizeof "test" - 1, ctx, master_key, ops, 0, 1);
hydro_bin2hex(h_hex, sizeof h_hex, h, sizeof h);
if (ops == 1000) {
assert_streq(
"2f1a804a02f25066fd0688bf8b8e03dff3a3866958a9cf5883c459e602e232d38e3e488723f0b4a2bc61d2"
"0cb36a04a4d2eb18be99bc61870d72d7de5d67f237",
h_hex);
}
hydro_pwhash_keygen(master_key);
assert(hydro_pwhash_create(stored, "test", sizeof "test" - 1, master_key, ops, 0, 1) == 0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, master_key, ops, 0, 1) == 0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, master_key, ops * 2, 10, 10) ==
0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, master_key, ops / 2, 10, 10) ==
-1);
assert(hydro_pwhash_verify(stored, "Test", sizeof "Test" - 1, master_key, ops, 0, 1) == -1);
assert(hydro_pwhash_verify(stored, "test", sizeof "tes" - 1, master_key, ops, 0, 1) == -1);
assert(hydro_pwhash_derive_static_key(static_key, sizeof static_key, stored, "test",
sizeof "test" - 1, ctx, master_key, ops, 0, 1) == 0);
assert(hydro_pwhash_derive_static_key(static_key, sizeof static_key, stored, "Test",
sizeof "Test" - 1, ctx, master_key, ops, 0, 1) == -1);
assert(hydro_pwhash_reencrypt(stored, master_key, master_key) == 0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, master_key, ops, 0, 1) == 0);
hydro_pwhash_keygen(new_master_key);
assert(hydro_pwhash_reencrypt(stored, master_key, new_master_key) == 0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, master_key, ops, 0, 1) == -1);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, new_master_key, ops, 0, 1) == 0);
assert(hydro_pwhash_upgrade(stored, new_master_key, ops * 2, 0, 1) == 0);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, new_master_key, ops, 0, 1) == -1);
assert(hydro_pwhash_verify(stored, "test", sizeof "test" - 1, new_master_key, ops * 2, 0, 1) ==
0);
}
int
main(void)
{
#ifdef _MSC_VER
_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
#endif
int ret;
ret = hydro_init();
assert(ret == 0);
test_core();
test_hash();
test_kdf();
test_kx_n();
test_kx_kk();
test_kx_xx();
test_kx_nk();
test_pwhash();
test_randombytes();
test_secretbox();
test_sign();
return 0;
}