test/crypto/dap_enc_iaes_test.c

-#include "dap_enc_iaes_test.h"
-
-void test_encode_decode()
-{
-    static size_t source_size = 0;
-
-    int step = 1 + (rand() % 20);
-    source_size += (size_t)step;
-
-    const char *kex_data = "123";
-    size_t kex_size = strlen(kex_data);
-    const size_t seed_size = 1 + (rand() % 1000);
-    uint8_t seed[seed_size];
-
-    generate_random_byte_array(seed, seed_size);
-
-    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_IAES, kex_data, kex_size, seed, seed_size, 0);
-
-    uint8_t source[source_size];
-    generate_random_byte_array(source, source_size);
-
-    uint8_t * buf_encrypted = NULL;
-    uint8_t * buf_decrypted = NULL;
-
-    size_t encrypted_size = key->enc(key, source,
-                                     source_size, (void**)&buf_encrypted);
-
-    size_t result_size = key->dec(key, buf_encrypted,
-                                  encrypted_size, (void**)&buf_decrypted);
-
-    dap_assert_PIF(source_size == result_size, "Check result decode size");
-
-    dap_assert_PIF(memcmp(source, buf_decrypted, source_size) == 0,
-                   "Check source and encode->decode data");
-
-    free(buf_encrypted);
-    free(buf_decrypted);
-    dap_enc_key_delete(key);
-
-    source_size++;
-}
-
-void test_encode_decode_fast(size_t count_steps)
-{
-    const size_t buf_size = 4096;
-    char buf_encrypt_out[buf_size];
-    char buf_decrypt_out[buf_size];
-
-    size_t source_size = 0;
-
-    const char *kex_data = "123";
-    size_t kex_size = strlen(kex_data);
-    const size_t seed_size = 1 + (rand() % 1000);
-    uint8_t seed[seed_size];
-
-    generate_random_byte_array(seed, seed_size);
-
-    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_IAES, kex_data, kex_size, seed, seed_size, 0);
-
-    for(size_t i = 1; i <= count_steps; i++) {
-        int step = 1;
-        source_size += (size_t)step;
-
-        uint8_t source[source_size];
-        generate_random_byte_array(source, source_size);
-
-        size_t enc_out_size = dap_enc_iaes256_cbc_encrypt_fast(key, source, source_size,
-                                                               buf_encrypt_out, buf_size);
-
-        size_t result_size = dap_enc_iaes256_cbc_decrypt_fast(key, buf_encrypt_out,
-                                                              enc_out_size, buf_decrypt_out, buf_size);
-
-
-        dap_assert_PIF(source_size == result_size, "Check result decode size");
-
-        dap_assert_PIF(memcmp(source, buf_decrypt_out, source_size) == 0,
-                       "Check source and encode->decode data");
-    }
-
-    dap_enc_key_delete(key);
-
-    dap_pass_msg("Encode and decode fast")
-}
-
-void init_test_case()
-{
-    srand((uint32_t)time(NULL));
-    dap_enc_key_init();
-}
-
-void cleanup_test_case()
-{
-    dap_enc_key_deinit();
-}
-
-void dap_enc_aes_tests_run()
-{
-    dap_print_module_name("dap_enc_aes");
-    init_test_case();
-
-    benchmark_mgs_time("Encode and decode 100 times", benchmark_test_time(test_encode_decode, 100));
-    benchmark_mgs_rate("Encode and decode", benchmark_test_rate(test_encode_decode, 1));
-
-    test_encode_decode_fast(100);
-
-    cleanup_test_case();
-}

test/crypto/dap_enc_iaes_test.h

-#pragma once
-#include "dap_enc_iaes.h"
-#include "dap_enc_key.h"
-#include "dap_test.h"
-#include "dap_test_generator.h"
-
-extern void dap_enc_aes_tests_run(void);

test/crypto/dap_enc_oaes_test.c

-#include "dap_enc_oaes_test.h"
-
-static void test_encode_decode(int count_steps)
-{
-    size_t source_size = 0;
-
-    for(int i = 1; i <= count_steps; i++) {
-        int step = 1 + (rand() % 20);
-        source_size += (size_t) step;
-
-        size_t seed_size = 16;
-        uint8_t seed[seed_size];
-
-        size_t kex_size = 32;
-        uint8_t kex[kex_size];
-
-        generate_random_byte_array(seed, seed_size);
-        generate_random_byte_array(kex, kex_size);
-
-        dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_OAES, kex, kex_size, seed, seed_size, 32);
-
-        uint8_t source[source_size];
-        generate_random_byte_array(source, source_size);
-
-        uint8_t * buf_encrypted = NULL;
-        uint8_t * buf_decrypted = NULL;
-
-        size_t encrypted_size = key->enc(key, source, source_size, (void**) &buf_encrypted);
-
-        size_t result_size = key->dec(key, buf_encrypted, encrypted_size, (void**) &buf_decrypted);
-
-        dap_assert_PIF(source_size == result_size, "Check result decode size");
-
-        dap_assert_PIF(memcmp(source, buf_decrypted, source_size) == 0,
-                "Check source and encode->decode data");
-
-        free(buf_encrypted);
-        free(buf_decrypted);
-        dap_enc_key_delete(key);
-    }
-
-    dap_pass_msg("Encode and decode");
-}
-
-static void test_encode_decode_fast(int count_steps)
-{
-    const size_t buf_size = 4096;
-    char buf_encrypt_out[buf_size];
-    char buf_decrypt_out[buf_size];
-
-    size_t source_size = 0;
-
-    size_t seed_size = 16;
-    uint8_t seed[seed_size];
-
-    size_t kex_size = 32;
-    uint8_t kex[kex_size];
-
-    generate_random_byte_array(seed, seed_size);
-    generate_random_byte_array(kex, kex_size);
-
-    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_OAES, kex, kex_size, NULL, 0, 32);
-
-    for(int i = 1; i <= count_steps; i++) {
-        int step = 1 + (rand() % 20);
-        source_size += (size_t) step;
-
-        uint8_t source[source_size];
-        generate_random_byte_array(source, source_size);
-
-        size_t enc_out_size = dap_enc_oaes_encrypt_fast(key, source, source_size, buf_encrypt_out, buf_size);
-
-        size_t result_size = dap_enc_oaes_decrypt_fast(key, buf_encrypt_out, enc_out_size, buf_decrypt_out, buf_size);
-
-        dap_assert_PIF(source_size == result_size, "Check result decode size");
-
-        dap_assert_PIF(memcmp(source, buf_decrypt_out, source_size) == 0,
-                "Check source and encode->decode data");
-    }
-
-    dap_enc_key_delete(key);
-    dap_pass_msg("Encode and decode fast");
-}
-
-
-
-static void init_test_case()
-{
-    srand((uint32_t) time(NULL));
-    dap_enc_key_init();
-}
-
-static void cleanup_test_case()
-{
-    dap_enc_key_deinit();
-}
-
-void dap_enc_oaes_tests_run()
-{
-    dap_print_module_name("dap_enc_oaes");
-    init_test_case();
-
-    test_encode_decode(50);
-    test_encode_decode_fast(100);
-
-    cleanup_test_case();
-}

test/crypto/dap_enc_picnic_test.c

-#include "dap_test_generator.h"
+#include "rand/dap_rand.h"
 #include "dap_enc_picnic_test.h"
 #include "../sig_picnic/picnic.h"
 
@@ -8,18 +8,18 @@ static void test_signing_verifying(void)
     size_t seed_size = sizeof(int);
     uint8_t seed[seed_size];
 
-    generate_random_byte_array(seed, seed_size);
+    randombytes(seed, seed_size);
 
     dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_PICNIC, NULL, 0, seed, seed_size, 0);
 
     size_t max_signature_size = dap_enc_picnic_calc_signature_size(key);
     uint8_t* sig = calloc(max_signature_size, 1);
 
-    int step = 1 + (rand() % 20);
+    int step = 1 + random_uint32_t( 20);
     source_size += (size_t) step;
 
     uint8_t source[source_size];
-    generate_random_byte_array(source, source_size);
+    randombytes(source, source_size);
 
     size_t siglen = key->enc_na(key, source, source_size, sig, max_signature_size);
     dap_assert_PIF(siglen > 0, "Signing message");

test/crypto/dap_enc_picnic_test.h

@@ -2,6 +2,6 @@
 #include "dap_enc_picnic.h"
 #include "dap_enc_key.h"
 #include "dap_test.h"
-//#include "dap_test_generator.h"
+//#include "rand/dap_rand.h"
 
 void dap_enc_picnic_tests_run(void);

test/crypto/dap_enc_ringct20_test.c

+#include "dap_enc_ringct20_test.h"
+#include "dap_enc_ringct20.h"
+#include "ringct20/ringct20_params.h"
+#include "rand/dap_rand.h"
+
+
+static void test_signing_verifying2(void)
+{
+    size_t source_size = 1 + random_uint32_t(20);
+    uint8_t * source = DAP_NEW_SIZE(uint8_t, source_size);
+    randombytes(source, source_size);
+    size_t seed_size = sizeof(uint8_t);
+    uint8_t seed[seed_size];
+
+    randombytes(seed, seed_size);
+
+    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_RINGCT20, NULL, 0, seed, seed_size, 0);
+
+    const int allpbknum = 100;
+    void *allpbk_buf = NULL;
+    ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
+    if (! ringct20_params_init( p, RINGCT20_MINSEC))
+    {
+        ringct20_params_free(p);
+        return;
+    }
+
+    size_t allpbk_size = CRUTCH_gen_pbk_list(p, &allpbk_buf, allpbknum);
+    key->getallpbkList(key, allpbk_buf,allpbk_size);
+
+    size_t max_signature_size = dap_enc_ringct20_calc_signature_size();
+    uint8_t* sig = calloc(max_signature_size, 1);
+
+
+
+    size_t siglen = key->enc_na(key, source, source_size, sig, max_signature_size);
+    dap_assert_PIF(siglen > 0, "Signing message");
+
+//Extract aList//CRUTCH
+    uint8_t *sigdata = (uint8_t*)*(int*)(sig + 4);
+//    for(int i = 0; i < 16; ++i)
+//        printf("%.2x ", sigdata[i]);
+//    printf(" = sig_extract\n"); fflush(stdout);
+    uint32_t unpacked_size = 0;
+    //unpack sec_kind
+    //memcpy(sec_kind, sigdata + unpacked_size, sizeof(DAP_RINGCT20_SIGN_SECURITY));
+    unpacked_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
+    //unpack wLen
+    int wLen;
+    memcpy(&wLen, sigdata + unpacked_size, sizeof(wLen));
+//    printf("wLen = %x\n", wLen);fflush(stdout);
+    unpacked_size += sizeof(wLen);
+    //unpack a_list
+    size_t poly_size = 896;
+    size_t pbk_size = 4 + poly_size;
+    uint8_t *pbkList_buf = DAP_NEW_SIZE(uint8_t, pbk_size*wLen);
+    for(int i = 0; i < wLen; ++i)
+    {
+        *(int*)(pbkList_buf + i*pbk_size + 0) = 0;//kind CRUTCH
+        memcpy(pbkList_buf + i*pbk_size + 4, sigdata + unpacked_size, poly_size);
+        unpacked_size += poly_size;
+    }
+//Extrackt aList
+
+   // size_t verify = key->dec_na(key, source, source_size, sig, siglen);
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[i]);
+//    printf(" = pbkList_buf\n"); fflush(stdout);
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[pbk_size+i]);
+//    printf(" = pbkList_buf\n"); fflush(stdout);
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[pbk_size*2+i]);
+//    printf(" = pbkList_buf\n"); fflush(stdout);
+
+    size_t verify = key->dec_na_ext(key, source, source_size, sig, siglen,pbkList_buf,wLen);
+//Corrupt pbkList
+    int numpbk = 3;
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", ((uint8_t*)allpbk_buf)[numpbk*pbk_size + i]);
+//    printf(" = allpbk\n"); fflush(stdout);
+    memcpy(pbkList_buf, allpbk_buf + numpbk*pbk_size, pbk_size);//Replace first pbk key with random pbk key
+
+//Corrupt pbkList
+
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[i]);
+//    printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[i+pbk_size]);
+//    printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+//    for(int i = 0; i < 32; ++i)
+//        printf("%.2x ", pbkList_buf[i+2*pbk_size]);
+//    printf(" = corrupt pbkList_buf\n"); fflush(stdout);
+    size_t verify_corrupt_sign = key->dec_na_ext(key, source, source_size, sig, siglen,pbkList_buf,wLen);
+
+    //printf("verify = %d, verify_corrupt_sign = %d\n", verify, verify_corrupt_sign);fflush(stdout);
+    dap_assert_PIF(!verify, "Verifying signature");
+    dap_assert_PIF(verify_corrupt_sign, "to Reject Corrupt signature");
+
+    ringct20_signature_delete((ringct20_signature_t*)sig);
+
+    DAP_DELETE(allpbk_buf);
+    ringct20_params_free(p);
+    DAP_DELETE(source);
+    free(sig);
+    dap_enc_key_delete(key);
+}
+
+//DEBUG TO USE IT get back:dap_enc_sig_ringct20_get_sign_with_pb_list,//dap_enc_sig_ringct20_get_sign,
+static void test_signing_verifying(void)
+{
+
+    size_t source_size = 1 + random_uint32_t(20);
+    uint8_t * source = DAP_NEW_SIZE(uint8_t, source_size);
+    randombytes(source, source_size);
+    size_t seed_size = sizeof(uint8_t);
+    uint8_t seed[seed_size];
+
+    randombytes(seed, seed_size);
+
+    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_RINGCT20, NULL, 0, seed, seed_size, 0);
+
+    size_t max_signature_size = dap_enc_ringct20_calc_signature_size();
+    uint8_t* sig = calloc(max_signature_size, 1);
+
+
+
+    size_t siglen = key->enc_na(key, source, source_size, sig, max_signature_size);
+    dap_assert_PIF(siglen > 0, "Signing message");
+
+    size_t verify = key->dec_na(key, source, source_size, sig, siglen);
+
+    dap_assert_PIF(!verify, "Verifying signature");
+
+    ringct20_signature_delete((ringct20_signature_t*)sig);
+    DAP_DELETE(source);
+    free(sig);
+    dap_enc_key_delete(key);
+}
+
+static void init_test_case()
+{
+    srand((uint32_t) time(NULL));
+    dap_enc_key_init();
+}
+
+static void cleanup_test_case()
+{
+    dap_enc_key_deinit();
+}
+
+void dap_enc_ringct20_tests_run(const int times)
+{
+    dap_print_module_name("dap_enc_ringct20");
+    init_test_case();
+    char print_buf[512];
+    sprintf_s(print_buf, 512, "Signing and verifying message %d time", times);
+
+    benchmark_mgs_time(print_buf, benchmark_test_time(test_signing_verifying2, times));
+
+    cleanup_test_case();
+}
+

test/crypto/dap_enc_oaes_test.h → test/crypto/dap_enc_ringct20_test.h

 #pragma once
-#include "dap_enc_oaes.h"
 #include "dap_enc_key.h"
 #include "dap_test.h"
-#include "dap_test_generator.h"
 
-void dap_enc_oaes_tests_run(void);
+void dap_enc_ringct20_tests_run(const int);

test/crypto/dap_enc_sig_bliss_test.h

@@ -2,6 +2,6 @@
 #include "dap_enc_bliss.h"
 #include "dap_enc_key.h"
 #include "dap_test.h"
-#include "dap_test_generator.h"
+#include "rand/dap_rand.h"
 
 void dap_enc_sig_bliss_tests_run(void);

test/crypto/dap_enc_sign_multi_test.c

+#include "dap_enc_sign_multi_test.h"
+#include "dap_test.h"
+#include "rand/dap_rand.h"
+#include "dap_sign.h"
+
+#define SIGNATURE_TYPE_COUNT 4
+#define KEYS_TOTAL_COUNT 10
+
+static void test_signing_verifying(void)
+{
+    size_t seed_size = sizeof(uint8_t);
+    uint8_t seed[seed_size];
+
+    randombytes(seed, seed_size);
+
+    dap_enc_key_type_t key_type_arr[SIGNATURE_TYPE_COUNT] = {\
+             DAP_ENC_KEY_TYPE_SIG_TESLA,\
+             DAP_ENC_KEY_TYPE_SIG_BLISS,\
+             DAP_ENC_KEY_TYPE_SIG_DILITHIUM,\
+             DAP_ENC_KEY_TYPE_SIG_PICNIC};
+    int step;
+    dap_enc_key_t* key[KEYS_TOTAL_COUNT];
+    for (int i = 0; i < KEYS_TOTAL_COUNT; i++) {
+        step = random_uint32_t( SIGNATURE_TYPE_COUNT);
+        key[i] = dap_enc_key_new_generate(key_type_arr[step], NULL, 0, seed, seed_size, 0);
+    }
+    step = 1 + random_uint32_t( 2000);
+    size_t source_size = (size_t) step;
+
+    uint8_t *source = DAP_NEW_SIZE(uint8_t, source_size);
+    randombytes(source, source_size);
+
+    dap_multi_sign_params_t *params = dap_multi_sign_params_make(SIG_TYPE_MULTI_CHAINED, KEYS_TOTAL_COUNT, 5,\
+                                                                 key[0], key[1], key[2], key[3], key[4], key[5],\
+                                                                 key[6], key[7], key[8], key[9], 3, 5, 7, 1, 10);
+    dap_assert_PIF(params, "Creating multi-sign parameters");
+
+    dap_multi_sign_t *sign = dap_multi_sign_create(params, source, source_size);
+    dap_assert_PIF(sign, "Signing message");
+
+    size_t serialized_size = 0;
+    uint8_t *serialized_sign = dap_multi_sign_serialize(sign, &serialized_size);
+    dap_assert_PIF(serialized_sign, "Serializing signature");
+
+    dap_multi_sign_t *deserialized_sign = dap_multi_sign_deserialize(SIG_TYPE_MULTI_CHAINED, serialized_sign, serialized_size);
+    dap_assert_PIF(deserialized_sign, "Deserializing signature");
+
+    int verify = dap_multi_sign_verify(deserialized_sign, source, source_size);
+    dap_assert_PIF(verify == 1, "Verifying signature");
+
+    dap_multi_sign_delete(deserialized_sign);
+    dap_multi_sign_delete(sign);
+    dap_multi_sign_params_delete(params);
+    DAP_DELETE(serialized_sign);
+    DAP_DELETE(source);
+    for (int i = 0; i < KEYS_TOTAL_COUNT; i++) {
+        dap_enc_key_delete(key[i]);
+    }
+}
+
+static void init_test_case()
+{
+    srand((uint32_t) time(NULL));
+}
+
+
+void dap_enc_multi_sign_tests_run()
+{
+    dap_print_module_name("dap_enc_sign_multi");
+    init_test_case();
+
+    benchmark_mgs_time("Signing and verifying message 1 time", benchmark_test_time(test_signing_verifying, 1));
+}

test/crypto/dap_enc_sign_multi_test.h

+#pragma once
+
+void dap_enc_multi_sign_tests_run();

test/crypto/dap_enc_tesla_test.c

-#include "dap_test_generator.h"
+#include "rand/dap_rand.h"
 #include "dap_enc_tesla_test.h"
 //#include "../sig_tesla/tesla_params.h"
 
@@ -8,18 +8,18 @@ static void test_signing_verifying(void)
     size_t seed_size = sizeof(uint8_t);
     uint8_t seed[seed_size];
 
-    generate_random_byte_array(seed, seed_size);
+    randombytes(seed, seed_size);
 
     dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_SIG_TESLA, NULL, 0, seed, seed_size, 0);
 
     size_t max_signature_size = dap_enc_tesla_calc_signature_size();
     uint8_t* sig = calloc(max_signature_size, 1);
 
-    int step = 1 + (rand() % 20);
+    int step = 1 + random_uint32_t( 20);
     source_size += (size_t) step;
 
     uint8_t source[source_size];
-    generate_random_byte_array(source, source_size);
+    randombytes(source, source_size);
 
     size_t siglen = key->enc_na(key, source, source_size, sig, max_signature_size);
     dap_assert_PIF(siglen > 0, "Signing message");

test/crypto/dap_enc_test.c

@@ -2,7 +2,7 @@
 #include "dap_common.h"
 #include "dap_enc_test.h"
 #include "dap_test.h"
-#include "dap_test_generator.h"
+#include "rand/dap_rand.h"
 #include "dap_enc_key.h"
 #include "dap_enc_base64.h"
 #include "dap_enc_bliss.h"
@@ -10,54 +10,167 @@
 #include "dap_enc_tesla.h"
 #include "dap_enc_dilithium.h"
 #include "dap_enc.h"
+#include "dap_test.h"
 
 #define TEST_SER_FILE_NAME "keystorage.txt"
+void test_encypt_decrypt(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
+{
+    dap_print_module_name(dap_enc_get_type_name(key_type));
+    const int max_source_size = 10000;
+    int time_beg = get_cur_time_msec();
+
+
+
+    for(int i = 0; i < count_steps; i++) {
+        size_t source_size = 0;
+        const size_t seed_size = 16;
+        uint8_t seed[seed_size];
+
+        const size_t kex_size = 32;
+        uint8_t kex[kex_size];
+        randombytes(seed, seed_size);
+        randombytes(kex, kex_size);
+
+        dap_enc_key_t* key = dap_enc_key_new_generate(key_type, kex, kex_size, seed, seed_size, cipher_key_size);
+        source_size = 1 + random_uint32_t(max_source_size);
+
+        uint8_t *source = DAP_NEW_SIZE(uint8_t, source_size);
+
+        randombytes(source, source_size);//randombase64(source, source_size);
+        uint8_t * buf_encrypted = NULL;
+        uint8_t * buf_decrypted = NULL;
+
+
+        size_t encrypted_size = key->enc(key, source, source_size, (void**) &buf_encrypted);
+        size_t result_size = key->dec(key, buf_encrypted, encrypted_size, (void**) &buf_decrypted);
+
+        dap_assert_PIF(source_size == result_size, "Check result decode size");
+
+        dap_assert_PIF(memcmp(source, buf_decrypted, source_size) == 0,
+                "Check source and encode->decode data");
+
+        DAP_DELETE(source);
+        DAP_DELETE(buf_encrypted);
+        DAP_DELETE(buf_decrypted);
+        dap_enc_key_delete(key);
+    }
+    int time_end = get_cur_time_msec();
+    char pass_msg_buf[256];
+    sprintf_s(pass_msg_buf, 256, "Encode and decode      %d times T = %f (%f per once)", count_steps, (time_end - time_beg)/1000.0,(time_end - time_beg)/1000.0/count_steps);
+    dap_pass_msg(pass_msg_buf);
+
+}
+
+void test_encypt_decrypt_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size)
+{
+    const int max_source_size = 10000;
+    dap_print_module_name(dap_enc_get_type_name(key_type));
+    char buf_encrypt_out[max_source_size+128];
+    char buf_decrypt_out[max_source_size];
+    int time_beg = get_cur_time_msec();
+
+
+    size_t seed_size = 16;
+    uint8_t seed[seed_size];
+
+    size_t kex_size = 32;
+    uint8_t kex[kex_size];
+
+    randombytes(seed, seed_size);
+    randombytes(kex, kex_size);
+
+    dap_enc_key_t* key = dap_enc_key_new_generate(key_type, kex, kex_size, seed, seed_size, cipher_key_size);
+
+    size_t source_size = 0;
+
+    for(int i = 0; i < count_steps; i++) {
+        source_size = 1 + random_uint32_t(max_source_size);
+
+        uint8_t *source = DAP_NEW_SIZE(uint8_t,source_size + 0);
+        randombytes(source, source_size);//randombase64(source, source_size);
+
+
+        size_t encrypted_size = key->enc_na(key, source, source_size, buf_encrypt_out, max_source_size+128);
+
+        size_t result_size = key->dec_na(key, buf_encrypt_out, encrypted_size, buf_decrypt_out, max_source_size);
+
+
+
+        dap_assert_PIF(source_size == result_size, "Check result decode size");
+
+        dap_assert_PIF(memcmp(source, buf_decrypt_out, source_size) == 0,
+                "Check source and encode->decode data");
+        DAP_DELETE(source);
+    }
+
+    dap_enc_key_delete(key);
+    int time_end = get_cur_time_msec();
+    char pass_msg_buf[256];
+    sprintf_s(pass_msg_buf, 256, "Encode and decode fast %d times T = %f (%f per once)", count_steps, (time_end - time_beg)/1000.0,(time_end - time_beg)/1000.0/count_steps);
+    dap_pass_msg(pass_msg_buf);
+}
+
 
 static void _encrypt_decrypt(enum dap_enc_key_type key_type,
                              enum dap_enc_data_type data_type,
                              size_t count_steps)
 {
     size_t source_size = 1;
-
+    const int MAX_SEED_SIZE = 100;
+    uint8_t seed[MAX_SEED_SIZE];
     for (size_t i = 0; i < count_steps; i++) {
-        int step = 1 + (rand() % 20);
-        source_size += (size_t)step;
+        source_size = 1 + random_uint32_t(2000);
 
         const char *kex_data = "123";
         size_t kex_size = strlen(kex_data);
-        const size_t seed_size = 1 + (rand() % 1000);
-        uint8_t seed[seed_size];
-
-        generate_random_byte_array(seed, seed_size);
-
+        const size_t seed_size = 1 + random_uint32_t(MAX_SEED_SIZE-1);
+
+        randombytes(seed, seed_size);
+//        printf("i = %d ss = %d, ss=%d\n",i, source_size,seed_size );fflush(stdout);
+        uint8_t *source = DAP_NEW_SIZE(uint8_t, source_size);
+//        printf(".");fflush(stdout);
+        randombytes(source, source_size);
+//        printf(".");fflush(stdout);
         dap_enc_key_t* key = dap_enc_key_new_generate(key_type, kex_data, kex_size, seed, seed_size, 0);
+//        printf(".");fflush(stdout);
 
-
-        uint8_t source[source_size];
         size_t encrypt_buff_size = dap_enc_code_out_size(key, source_size, data_type);
-        uint8_t encrypt_result[encrypt_buff_size];
-
-        generate_random_byte_array(source, source_size);
-
+        uint8_t *encrypt_result = DAP_NEW_SIZE(uint8_t, encrypt_buff_size);
+//        printf(".");fflush(stdout);
         size_t encrypted_size = dap_enc_code(key, source,
                                              source_size,
                                              encrypt_result,
                                              encrypt_buff_size,
                                              data_type);
-
+//        printf(".");fflush(stdout);
         size_t min_decode_buff_size = dap_enc_decode_out_size(key, encrypt_buff_size, data_type);
-        uint8_t decode_result[min_decode_buff_size];
+//        printf(".");fflush(stdout);
+        uint8_t *decode_result = DAP_NEW_SIZE(uint8_t, min_decode_buff_size);
+//        printf(".");fflush(stdout);
         size_t out_size = dap_enc_decode(key,
                                          encrypt_result,
                                          encrypted_size,
                                          decode_result,
                                          min_decode_buff_size,
                                          data_type);
+//        printf("source_size = %d, out_size = %d, min_decode_buff_size = %d, encrypt_buff_size = %d, encrypted_size = %d\n",
+//               source_size, out_size,min_decode_buff_size, encrypt_buff_size, encrypted_size);
+//        printf("%.2x%.2x\n", source[0], source[1]);
+//        printf(".");fflush(stdout);
 
         dap_assert_PIF(source_size == out_size, "Check result decode size");
 
+//        printf(".");fflush(stdout);
         dap_assert_PIF(memcmp(source, decode_result, source_size) == 0, "Check source and encode->decode data");
+//        printf(".");fflush(stdout);
+//#ifdef xxxxx
+
+
 
+//#endif
+        DAP_DELETE(decode_result);
+        DAP_DELETE(encrypt_result);
+        DAP_DELETE(source);
         dap_enc_key_delete(key);
     }
 }
@@ -149,10 +262,10 @@ static void test_serealize_deserealize(dap_enc_key_type_t key_type)
 {
     const char *kex_data = "1234567890123456789012345678901234567890";//"123";
     size_t kex_size = strlen(kex_data);
-    const size_t seed_size = 1 + (rand() % 1000);
+    const size_t seed_size = 1 + random_uint32_t( 1000);
     uint8_t seed[seed_size];
 
-    generate_random_byte_array(seed, seed_size);
+    randombytes(seed, seed_size);
 
 //  for key_type==DAP_ENC_KEY_TYPE_OAES must be: key_size=[16|24|32] and kex_size>=key_size
     dap_enc_key_t* key = dap_enc_key_new_generate(key_type, kex_data, kex_size, seed, seed_size, 32);
@@ -224,9 +337,9 @@ static void test_serealize_deserealize_pub_priv(dap_enc_key_type_t key_type)
 {
     const char *kex_data = "1234567890123456789012345678901234567890"; //"123";
     size_t kex_size = strlen(kex_data);
-    const size_t seed_size = 1 + (rand() % 1000);
+    const size_t seed_size = 1 + random_uint32_t( 1000);
     uint8_t seed[seed_size];
-    generate_random_byte_array(seed, seed_size);
+    randombytes(seed, seed_size);
 
     // Generate key
     dap_enc_key_t* key = dap_enc_key_new_generate(key_type, kex_data, kex_size, seed, seed_size, 32);
@@ -257,11 +370,11 @@ static void test_serealize_deserealize_pub_priv(dap_enc_key_type_t key_type)
     dap_assert(key->pub_key_data_size == key2->pub_key_data_size, "Pub key data size");
     dap_pass_msg("Key serealize->deserealize");
 
-    size_t source_size = 10 + (rand() % 20);
+    size_t source_size = 10 + random_uint32_t( 20);
     uint8_t source_buf[source_size];
     size_t sig_buf_size = 0;
     uint8_t *sig_buf = NULL;
-    generate_random_byte_array(source_buf, source_size);
+    randombytes(source_buf, source_size);
 
     // encode by key
     int is_sig = 0, is_vefify = 0;
@@ -285,7 +398,7 @@ static void test_serealize_deserealize_pub_priv(dap_enc_key_type_t key_type)
             is_sig = 1;
         break;
     case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
-        sig_buf_size = dap_enc_dilithium_calc_signature_size();
+        sig_buf_size = dap_enc_dilithium_calc_signature_unserialized_size();
         sig_buf = calloc(sig_buf_size, 1);
         if(key->enc_na(key, source_buf, source_size, sig_buf, sig_buf_size) > 0)
             is_sig = 1;
@@ -341,9 +454,9 @@ static void test_serealize_deserealize_pub_priv(dap_enc_key_type_t key_type)
 void dap_enc_tests_run() {
     dap_print_module_name("dap_enc");
     init_test_case();
-    test_encode_decode_raw(50);
-    test_encode_decode_raw_b64(50);
-    test_encode_decode_raw_b64_url_safe(50);
+    test_encode_decode_raw(500);
+    test_encode_decode_raw_b64(500);
+    test_encode_decode_raw_b64_url_safe(500);
     test_key_transfer_msrln();
     dap_print_module_name("dap_enc serealize->deserealize IAES");
     test_serealize_deserealize(DAP_ENC_KEY_TYPE_IAES);

test/crypto/dap_enc_test.h

 #pragma once
+#include "dap_enc_key.h"
+void test_encypt_decrypt(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
+void test_encypt_decrypt_fast(int count_steps, const dap_enc_key_type_t key_type, const int cipher_key_size);
 
 void dap_enc_tests_run(void);

test/crypto/main.c

-#include "dap_enc_iaes_test.h"
-#include "dap_enc_oaes_test.h"
 #include "dap_enc_base64_test.h"
 #include "dap_enc_base58_test.h"
 #include "dap_enc_test.h"
@@ -9,23 +7,50 @@
 #include "dap_enc_picnic_test.h"
 #include "dap_enc_tesla_test.h"
 #include "dap_enc_dilithium_test.h"
+#include "dap_enc_ringct20_test.h"
+#include "dap_enc_sign_multi_test.h"
 #include "rand/dap_rand.h"
 
 #include "dap_common.h"
 
 int main(void)
 {
-    // switch off debug info from library
+ // switch off debug info from library
     dap_log_level_set(L_CRITICAL);
-    dap_enc_aes_tests_run();
-    dap_enc_oaes_tests_run();
+
+    const int  test_numbers = 100;
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_SALSA2012,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_SALSA2012,  32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_SALSA2012,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_GOST_OFB,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_GOST_OFB,  32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_GOST_OFB,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_KUZN_OFB,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_KUZN_OFB,  32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_KUZN_OFB,  32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_KUZN_OFB,  32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_BF_CBC,     0);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_BF_CBC,     0);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_BF_OFB,     0);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_BF_OFB,     0);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_IAES,       32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_IAES,       32);
+    test_encypt_decrypt      (test_numbers, DAP_ENC_KEY_TYPE_OAES,       32);
+    test_encypt_decrypt_fast (test_numbers, DAP_ENC_KEY_TYPE_OAES,       32);
+    dap_enc_ringct20_tests_run(test_numbers);
+    return 0;
+    dap_enc_tests_run();
+
+
+    dap_enc_picnic_tests_run();
+    dap_enc_sig_bliss_tests_run();
+    dap_enc_dilithium_tests_run();
+
     dap_enc_base64_tests_run();
     dap_enc_base58_tests_run();
     dap_enc_msrln_tests_run();
-    dap_enc_tests_run();
-    dap_enc_sig_bliss_tests_run();
     dap_enc_defeo_tests_run();
     dap_enc_tesla_tests_run();
-    dap_enc_picnic_tests_run();
-    dap_enc_dilithium_tests_run();
+    dap_enc_multi_sign_tests_run();
+
 }