Add some additional tests for HKDF and Salsa20/12

.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

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 \

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

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

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

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