diff --git a/.gitignore b/.gitignore index 7fd65e21..b8bd68a2 100644 --- a/.gitignore +++ b/.gitignore @@ -130,6 +130,7 @@ test/default/hash_sha3512 test/default/ipcrypt test/default/kdf test/default/kdf_hkdf +test/default/kdf_hkdf2 test/default/keygen test/default/kem test/default/kem_mlkem768 @@ -173,6 +174,7 @@ test/default/stream test/default/stream2 test/default/stream3 test/default/stream4 +test/default/stream5 test/default/verify1 test/default/xchacha20 test/default/xof_shake128 diff --git a/test/default/Makefile.am b/test/default/Makefile.am index 6790cfb1..eba3068a 100644 --- a/test/default/Makefile.am +++ b/test/default/Makefile.am @@ -50,6 +50,7 @@ EXTRA_DIST = \ ipcrypt.exp \ kdf.exp \ kdf_hkdf.exp \ + kdf_hkdf2.exp \ kem.exp \ kem_mlkem768.exp \ kem_xwing.exp \ @@ -93,6 +94,7 @@ EXTRA_DIST = \ stream2.exp \ stream3.exp \ stream4.exp \ + stream5.exp \ verify1.exp \ xchacha20.exp \ xof_shake128.exp \ @@ -147,6 +149,7 @@ DISTCLEANFILES = \ ipcrypt.res \ kdf.res \ kdf_hkdf.res \ + kdf_hkdf2.res \ kem.res \ kem_mlkem768.res \ kem_xwing.res \ @@ -190,6 +193,7 @@ DISTCLEANFILES = \ stream2.res \ stream3.res \ stream4.res \ + stream5.res \ verify1.res \ xchacha20.res \ xof_shake128.res \ @@ -438,6 +442,9 @@ kdf_LDADD = $(TESTS_LDADD) kdf_hkdf_SOURCE = cmptest.h kdf_hkdf.c kdf_hkdf_LDADD = $(TESTS_LDADD) +kdf_hkdf2_SOURCE = cmptest.h kdf_hkdf2.c +kdf_hkdf2_LDADD = $(TESTS_LDADD) + kem_SOURCE = cmptest.h kem.c kem_LDADD = $(TESTS_LDADD) @@ -567,6 +574,9 @@ stream3_LDADD = $(TESTS_LDADD) stream4_SOURCE = cmptest.h stream4.c stream4_LDADD = $(TESTS_LDADD) +stream5_SOURCE = cmptest.h stream5.c +stream5_LDADD = $(TESTS_LDADD) + verify1_SOURCE = cmptest.h verify1.c verify1_LDADD = $(TESTS_LDADD) @@ -592,7 +602,9 @@ TESTS_TARGETS += \ core_ristretto255 \ core_ristretto255_h2c \ kdf_hkdf \ + kdf_hkdf2 \ pwhash_scrypt \ + stream5 \ pwhash_scrypt_ll \ scalarmult_ed25519 \ scalarmult_ristretto255 \ diff --git a/test/default/kdf_hkdf2.c b/test/default/kdf_hkdf2.c new file mode 100644 index 00000000..b1d78ab4 --- /dev/null +++ b/test/default/kdf_hkdf2.c @@ -0,0 +1,135 @@ + +#define TEST_NAME "kdf_hkdf2" +#include "cmptest.h" + +static void +tv_kdf_hkdf_incremental(void) +{ + unsigned char *master_key; + size_t master_key_len = 66; + unsigned char *salt; + size_t salt_len = 77; + char *context; + size_t context_len = 88; + unsigned char prk_oneshot[crypto_kdf_hkdf_sha512_KEYBYTES]; + unsigned char prk_incremental[crypto_kdf_hkdf_sha512_KEYBYTES]; + unsigned char prk256_oneshot[crypto_kdf_hkdf_sha256_KEYBYTES]; + unsigned char prk256_incremental[crypto_kdf_hkdf_sha256_KEYBYTES]; + unsigned char out_oneshot[99]; + unsigned char out_incremental[99]; + char hex[99 * 2 + 1]; + size_t i; + + master_key = (unsigned char *) sodium_malloc(master_key_len); + salt = (unsigned char *) sodium_malloc(salt_len); + context = (char *) sodium_malloc(context_len); + for (i = 0; i < master_key_len; i++) { + master_key[i] = (unsigned char) i; + } + for (i = 0; i < salt_len; i++) { + salt[i] = (unsigned char) ~i; + } + for (i = 0; i < context_len; i++) { + context[i] = (unsigned char) (i + 111); + } + + crypto_kdf_hkdf_sha512_extract(prk_oneshot, salt, salt_len, + master_key, master_key_len); + + { + crypto_kdf_hkdf_sha512_state state; + + crypto_kdf_hkdf_sha512_extract_init(&state, salt, salt_len); + crypto_kdf_hkdf_sha512_extract_update(&state, master_key, + master_key_len); + crypto_kdf_hkdf_sha512_extract_final(&state, prk_incremental); + } + assert(memcmp(prk_oneshot, prk_incremental, sizeof prk_oneshot) == 0); + printf("sha512 incremental (single update): ok\n"); + + { + crypto_kdf_hkdf_sha512_state state; + + crypto_kdf_hkdf_sha512_extract_init(&state, salt, salt_len); + for (i = 0; i < master_key_len; i++) { + crypto_kdf_hkdf_sha512_extract_update(&state, &master_key[i], 1); + } + crypto_kdf_hkdf_sha512_extract_final(&state, prk_incremental); + } + assert(memcmp(prk_oneshot, prk_incremental, sizeof prk_oneshot) == 0); + printf("sha512 incremental (byte-by-byte): ok\n"); + + { + crypto_kdf_hkdf_sha512_state state; + unsigned char prk_null_salt_oneshot[crypto_kdf_hkdf_sha512_KEYBYTES]; + unsigned char prk_null_salt_incr[crypto_kdf_hkdf_sha512_KEYBYTES]; + + crypto_kdf_hkdf_sha512_extract(prk_null_salt_oneshot, NULL, 0, + master_key, master_key_len); + crypto_kdf_hkdf_sha512_extract_init(&state, NULL, 0); + crypto_kdf_hkdf_sha512_extract_update(&state, master_key, + master_key_len); + crypto_kdf_hkdf_sha512_extract_final(&state, prk_null_salt_incr); + assert(memcmp(prk_null_salt_oneshot, prk_null_salt_incr, + sizeof prk_null_salt_oneshot) == 0); + } + printf("sha512 incremental (null salt): ok\n"); + + crypto_kdf_hkdf_sha512_expand(out_oneshot, 99, context, context_len, + prk_oneshot); + crypto_kdf_hkdf_sha512_expand(out_incremental, 99, context, context_len, + prk_incremental); + assert(memcmp(out_oneshot, out_incremental, 99) == 0); + printf("sha512 expand consistency: ok\n"); + + sodium_bin2hex(hex, sizeof hex, prk_oneshot, sizeof prk_oneshot); + printf("sha512 prk: %s\n", hex); + + crypto_kdf_hkdf_sha256_extract(prk256_oneshot, salt, salt_len, + master_key, master_key_len); + + { + crypto_kdf_hkdf_sha256_state state; + size_t half = master_key_len / 2; + + crypto_kdf_hkdf_sha256_extract_init(&state, salt, salt_len); + crypto_kdf_hkdf_sha256_extract_update(&state, master_key, half); + crypto_kdf_hkdf_sha256_extract_update(&state, master_key + half, + master_key_len - half); + crypto_kdf_hkdf_sha256_extract_final(&state, prk256_incremental); + } + assert(memcmp(prk256_oneshot, prk256_incremental, + sizeof prk256_oneshot) == 0); + printf("sha256 incremental (two chunks): ok\n"); + + { + crypto_kdf_hkdf_sha256_state state; + unsigned char prk_null_oneshot[crypto_kdf_hkdf_sha256_KEYBYTES]; + unsigned char prk_null_incr[crypto_kdf_hkdf_sha256_KEYBYTES]; + + crypto_kdf_hkdf_sha256_extract(prk_null_oneshot, NULL, 0, + master_key, master_key_len); + crypto_kdf_hkdf_sha256_extract_init(&state, NULL, 0); + crypto_kdf_hkdf_sha256_extract_update(&state, master_key, + master_key_len); + crypto_kdf_hkdf_sha256_extract_final(&state, prk_null_incr); + assert(memcmp(prk_null_oneshot, prk_null_incr, + sizeof prk_null_oneshot) == 0); + } + printf("sha256 incremental (null salt): ok\n"); + + sodium_bin2hex(hex, sizeof hex, prk256_oneshot, sizeof prk256_oneshot); + printf("sha256 prk: %s\n", hex); + + sodium_free(context); + sodium_free(salt); + sodium_free(master_key); +} + +int +main(void) +{ + tv_kdf_hkdf_incremental(); + + return 0; +} diff --git a/test/default/kdf_hkdf2.exp b/test/default/kdf_hkdf2.exp new file mode 100644 index 00000000..fd84bbee --- /dev/null +++ b/test/default/kdf_hkdf2.exp @@ -0,0 +1,8 @@ +sha512 incremental (single update): ok +sha512 incremental (byte-by-byte): ok +sha512 incremental (null salt): ok +sha512 expand consistency: ok +sha512 prk: 2502bc897dc1b23f9f2d8c35d519c5280ea960bf9154ebb07d377a12a81a4794ea8bdc0cb6ec59ab3303f5cbd713027825715f8af2ac0203e560fd2e55f4ff2b +sha256 incremental (two chunks): ok +sha256 incremental (null salt): ok +sha256 prk: 8c3725c0ea8e14106d8c342887ccd1218cc205acecd8095ae1efc099ec195e7e diff --git a/test/default/stream5.c b/test/default/stream5.c new file mode 100644 index 00000000..e96f93c3 --- /dev/null +++ b/test/default/stream5.c @@ -0,0 +1,79 @@ + +#define TEST_NAME "stream5" +#include "cmptest.h" + +static const unsigned char key[crypto_stream_salsa2012_KEYBYTES] = { + 0x1b, 0x27, 0x55, 0x64, 0x73, 0xe9, 0x85, 0xd4, + 0x62, 0xcd, 0x51, 0x19, 0x7a, 0x9a, 0x46, 0xc7, + 0x60, 0x09, 0x54, 0x9e, 0xac, 0x64, 0x74, 0xf2, + 0x06, 0xc4, 0xee, 0x08, 0x44, 0xf6, 0x83, 0x89 +}; + +static const unsigned char nonce[crypto_stream_salsa2012_NONCEBYTES] = { + 0x69, 0x69, 0x6e, 0xe9, 0x55, 0xb6, 0x2b, 0x73 +}; + +int +main(void) +{ + unsigned char h[32]; + char hex[2 * 64 + 1]; + unsigned char *output; + unsigned char *m; + int i; + + output = (unsigned char *) sodium_malloc(4096); + m = (unsigned char *) sodium_malloc(4096); + + crypto_stream_salsa2012(output, 4096, nonce, key); + crypto_hash_sha256(h, output, 4096); + sodium_bin2hex(hex, sizeof hex, h, sizeof h); + printf("%s\n", hex); + + memset(m, 0, 4096); + crypto_stream_salsa2012_xor(m, m, 4096, nonce, key); + assert(memcmp(m, output, 4096) == 0); + printf("xor_zero: ok\n"); + + for (i = 0; i < 4096; i++) { + m[i] = (unsigned char) i; + } + crypto_stream_salsa2012_xor(output, m, 4096, nonce, key); + crypto_stream_salsa2012_xor(output, output, 4096, nonce, key); + assert(memcmp(output, m, 4096) == 0); + printf("xor_roundtrip: ok\n"); + + for (i = 0; i < 64; i++) { + memset(output, 0xdb, 64); + crypto_stream_salsa2012(output, (unsigned long long) i, nonce, key); + sodium_bin2hex(hex, sizeof hex, output, 64); + printf("%s\n", hex); + } + + memset(output, 0xaa, 64); + crypto_stream_salsa2012(output, 0, nonce, key); + assert(output[0] == 0xaa); + printf("zero_len: ok\n"); + + { + unsigned char k2[crypto_stream_salsa2012_KEYBYTES]; + int all_zero; + + crypto_stream_salsa2012_keygen(k2); + all_zero = sodium_is_zero(k2, sizeof k2); + assert(all_zero == 0); + } + printf("keygen: ok\n"); + + assert(crypto_stream_salsa2012_keybytes() == crypto_stream_salsa2012_KEYBYTES); + assert(crypto_stream_salsa2012_noncebytes() == crypto_stream_salsa2012_NONCEBYTES); + assert(crypto_stream_salsa2012_messagebytes_max() > 0U); + assert(crypto_stream_salsa2012_keybytes() == 32U); + assert(crypto_stream_salsa2012_noncebytes() == 8U); + printf("constants: ok\n"); + + sodium_free(m); + sodium_free(output); + + return 0; +} diff --git a/test/default/stream5.exp b/test/default/stream5.exp new file mode 100644 index 00000000..6ec4b5d5 --- /dev/null +++ b/test/default/stream5.exp @@ -0,0 +1,70 @@ +ae87e8a917fc7bf23d983fd2777f3a6c08d9cbf977ba2d8d10dd336f6b585083 +xor_zero: ok +xor_roundtrip: ok +dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +54dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e6dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e67138dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd2dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd214dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495aedbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08eadbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f0dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a8dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85fdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f34dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349ddbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d3dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b600dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001bdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cddbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc5dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56edbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f1dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15edbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7ddbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da3dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e631dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e63197dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e631972998dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985edbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e0733dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338edbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e05dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055adbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71dbdbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a7147dbdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bdbdbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1dbdbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f2dbdbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269dbdbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269fedbdbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2dbdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2abdbdbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab98dbdbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab9855dbdbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab985519dbdbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab985519cddbdbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab985519cd1adbdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab985519cd1a3cdbdb +5464e671385cd21495ae08ea32f003a85f349dc8d305b6001b66cdc56eacf1f15e7da359e6319729985e07338e055a71477bd1f269feb2ab985519cd1a3ca9db +zero_len: ok +keygen: ok +constants: ok