diff --git a/core/test/dap_config_test.c b/core/test/dap_config_test.c
index 38744b0ecd7e03c302d4834ee074b9b7b49d0785..96d3fc49ea67597fef4df3e784f45f052a31eeaa 100755
--- a/core/test/dap_config_test.c
+++ b/core/test/dap_config_test.c
@@ -119,7 +119,7 @@ void test_get_bool_default()
void test_array_str()
{
uint16_t arraySize;
- char ** result_arr = dap_config_get_array_str(config, "server_options", "str_arr", &arraySize);
+ const char **result_arr = dap_config_get_array_str(config, "server_options", "str_arr", &arraySize);
dap_assert(result_arr != NULL, "Get array str from config");
dap_assert(arraySize == STR_ARR_LEN, "Check array length");
@@ -131,7 +131,7 @@ void test_array_str()
void test_array_int() {
uint16_t arraySize;
- char ** result_arr = dap_config_get_array_str(config, "server_options", "int_arr", &arraySize);
+ const char **result_arr = dap_config_get_array_str(config, "server_options", "int_arr", &arraySize);
dap_assert(result_arr != NULL, "Get array int");
dap_assert(arraySize == INT_ARR_LEN, "Check array int length");
diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt
index c97a8ec2919f74e29f2ecf17e25414a001795c3b..3f2bfa6ca0d5495c3ca7af51bf33fe4403e4884e 100755
--- a/crypto/CMakeLists.txt
+++ b/crypto/CMakeLists.txt
@@ -119,8 +119,6 @@ file( GLOB CRYPTO_SRCS
src/sig_tesla/*.c
src/sig_picnic/*.c
src/sig_dilithium/*.c
- src/sig_shipovnik/*.c
- src/sig_shipovnik/streebog/*.c
src/ringct20/*.c
src/falcon/*.c
${SPHINCS_BASE_SRCS}
@@ -139,6 +137,17 @@ else()
list (FILTER CRYPTO_SRCS EXCLUDE REGEX ".*ecdsa.c")
endif()
+if (BUILD_WITH_SHIPOVNIK)
+ file (GLOB SHIPOVNIK_SRC
+ src/sig_shipovnik/*.c
+ src/sig_shipovnik/streebog/*.c
+ )
+ set (CRYPTO_SRCS ${CRYPTO_SRCS} ${SHIPOVNIK_SRC})
+ add_definitions("-DDAP_SHIPOVNIK")
+else()
+ list (FILTER CRYPTO_SRCS EXCLUDE REGEX ".*shipovnik.c")
+endif()
+
get_filename_component(full_path_src ${CMAKE_CURRENT_SOURCE_DIR}/src/sig_shipovnik/streebog/gost3411-2012.c ABSOLUTE)
list(REMOVE_ITEM CRYPTO_SRCS "${full_path_src}")
@@ -155,8 +164,6 @@ file( GLOB CRYPTO_HEADERS
src/msrln/*.h
src/newhope/*.h
src/sig_bliss/*.h
- src/sig_shipovnik/*.h
- src/sig_shipovnik/streebog/*.h
src/sig_tesla/*.h
src/sig_picnic/*.h
src/sig_dilithium/*.h
@@ -173,6 +180,16 @@ else()
list (FILTER CRYPTO_HEADERS EXCLUDE REGEX ".*ecdsa.h")
endif()
+if (BUILD_WITH_SHIPOVNIK)
+ file (GLOB SHIPOVNIK_HDR
+ src/sig_shipovnik/*.h
+ src/sig_shipovnik/streebog/*.h
+ )
+ set (CRYPTO_HEADERS ${CRYPTO_HEADERS} ${SHIPOVNIK_HDR})
+else()
+ list (FILTER CRYPTO_HEADERS EXCLUDE REGEX ".*shipovnik.h")
+endif()
+
set_source_files_properties(src/sig_picnic/picnic_impl.c PROPERTIES COMPILE_FLAGS -Wno-stringop-overflow)
diff --git a/crypto/include/dap_cert.h b/crypto/include/dap_cert.h
index 5c3f82cb32e7ed070a2fb36d285e5d1dc18e650c..a2f7f0a7bc2005daff15a8a3b3b550cf0e443cf1 100755
--- a/crypto/include/dap_cert.h
+++ b/crypto/include/dap_cert.h
@@ -63,9 +63,7 @@ extern "C" {
int dap_cert_init();
-DAP_STATIC_INLINE const char *dap_cert_get_str_recommended_sign(){
- return "sig_dil\nsig_falcon\nsig_sphincs\nsig_shipovnik\n";
-}
+const char *dap_cert_get_str_recommended_sign();
dap_cert_t *dap_cert_new(const char *a_name);
int dap_cert_add(dap_cert_t *a_cert);
diff --git a/crypto/src/dap_cert.c b/crypto/src/dap_cert.c
index 64331a984df40cc65ed0aac5e179571782ec994f..9044414eea734c8d56c2a1514e1bacfa3199afe8 100755
--- a/crypto/src/dap_cert.c
+++ b/crypto/src/dap_cert.c
@@ -956,3 +956,11 @@ dap_enc_key_t *dap_cert_get_keys_from_certs(dap_cert_t **a_certs, size_t a_count
DAP_DELETE(l_keys);
return l_ret;
}
+
+DAP_INLINE const char *dap_cert_get_str_recommended_sign(){
+ return "sig_dil\nsig_falcon\nsig_sphincs\n"
+#ifdef DAP_SHIPOVNIK
+ "sig_shipovnik\n"
+#endif
+ ;
+}
\ No newline at end of file
diff --git a/crypto/src/dap_enc_key.c b/crypto/src/dap_enc_key.c
index 8b8eb7f4b6fe2052828042e8e5d3bfd393d9d3c4..d07154bc2c65d14459fce6ec0fae588dc378691a 100755
--- a/crypto/src/dap_enc_key.c
+++ b/crypto/src/dap_enc_key.c
@@ -40,11 +40,13 @@
#include "dap_enc_kyber.h"
#include "dap_enc_sphincsplus.h"
#include "dap_enc_multisign.h"
+#include "dap_enc_ringct20.h"
#ifdef DAP_ECDSA
#include "dap_enc_ecdsa.h"
#endif
+#ifdef DAP_SHIPOVNIK
#include "dap_enc_shipovnik.h"
-#include "dap_enc_ringct20.h"
+#endif
#ifdef DAP_PQRL
#include "dap_pqrl.h"
#endif
@@ -409,6 +411,7 @@ dap_enc_key_callbacks_t s_callbacks[]={
[DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK]={
.name = "SIG_SHIPOVNIK",
+#ifdef DAP_SHIPOVNIK
.enc = NULL,
.dec = NULL,
.enc_na = NULL,
@@ -436,6 +439,7 @@ dap_enc_key_callbacks_t s_callbacks[]={
.deser_priv_key_size = dap_enc_sig_shipovnik_deser_key_size,
.deser_pub_key_size = dap_enc_sig_shipovnik_deser_pkey_size,
.deser_sign_size = dap_enc_sig_shipovnik_deser_sign_size
+#endif
},
diff --git a/crypto/src/dap_enc_shipovnik.c b/crypto/src/dap_enc_shipovnik.c
index ccd5230bbe304929e0cffe9998b59a7b91d06bc2..de117f9b75382e8df8b6acd3d1796c6758175b59 100644
--- a/crypto/src/dap_enc_shipovnik.c
+++ b/crypto/src/dap_enc_shipovnik.c
@@ -1,9 +1,7 @@
-#include <assert.h>
-#include <inttypes.h>
-#include <string.h>
#include "dap_enc_shipovnik.h"
#include "dap_common.h"
#include "rand/dap_rand.h"
+#include "fips202.h"
#include "sig_shipovnik/shipovnik_params.h"
#define LOG_TAG "dap_enc_sig_shipovnik"
@@ -21,14 +19,21 @@ void dap_enc_sig_shipovnik_key_new(dap_enc_key_t *a_key) {
}
void dap_enc_sig_shipovnik_key_new_generate(dap_enc_key_t * key, UNUSED_ARG const void *kex_buf,
- UNUSED_ARG size_t kex_size, const void * seed, size_t seed_size,
+ UNUSED_ARG size_t kex_size, const void *seed, size_t seed_size,
UNUSED_ARG size_t key_size)
{
- key->priv_key_data_size =SHIPOVNIK_SECRETKEYBYTES;
+ DAP_NEW_Z_SIZE_RET(key->priv_key_data, void, SHIPOVNIK_SECRETKEYBYTES, NULL);
+ DAP_NEW_Z_SIZE_RET(key->pub_key_data, void, SHIPOVNIK_PUBLICKEYBYTES, key->priv_key_data);
+ key->priv_key_data_size = SHIPOVNIK_SECRETKEYBYTES;
key->pub_key_data_size = SHIPOVNIK_PUBLICKEYBYTES;
- key->priv_key_data = malloc(key->priv_key_data_size);
- key->pub_key_data = malloc(key->pub_key_data_size);
- shipovnik_generate_keys(key->priv_key_data,key->pub_key_data);
+ if (!seed || !seed_size) {
+ log_it(L_DEBUG, "Generate key with random seed");
+ shipovnik_generate_keys(key->priv_key_data, key->pub_key_data);
+ } else {
+ uint32_t l_seed_buf[N_shipovnik] = { 0 };
+ shake256((unsigned char *)l_seed_buf, sizeof(l_seed_buf), seed, seed_size);
+ shipovnik_generate_keys_with_seed(key->priv_key_data, key->pub_key_data, l_seed_buf);
+ }
}
int dap_enc_sig_shipovnik_get_sign(struct dap_enc_key* key, const void* msg, const size_t msg_size, void* signature, const size_t signature_size)
@@ -44,7 +49,7 @@ int dap_enc_sig_shipovnik_get_sign(struct dap_enc_key* key, const void* msg, con
}
size_t l_size = 0;
shipovnik_sign(key->priv_key_data, msg, msg_size, signature, &l_size);
- return signature_size ? 0 : ( log_it(L_ERROR, "Failed to sign message"), -1 );
+ return l_size ? 0 : ( log_it(L_ERROR, "Failed to sign message"), -1 );
}
int dap_enc_sig_shipovnik_verify_sign(struct dap_enc_key* key, const void* msg, const size_t msg_size, void* signature, const size_t signature_size)
diff --git a/crypto/src/dap_enc_sphincsplus.c b/crypto/src/dap_enc_sphincsplus.c
index 2c6a1d031217da34ba596c3e0f5fde941d8f6bd5..d62b94e5e25afb9973e357c266652b413b1242f8 100644
--- a/crypto/src/dap_enc_sphincsplus.c
+++ b/crypto/src/dap_enc_sphincsplus.c
@@ -89,9 +89,7 @@ int dap_enc_sig_sphincsplus_get_sign(dap_enc_key_t *a_key, const void *a_msg_in,
DAP_NEW_Z_SIZE_RET_VAL(l_sign->sig_data, uint8_t, dap_enc_sig_sphincsplus_crypto_sign_bytes(), -3, NULL);
l_sign->sig_params = l_skey->params;
- int l_ret = sphincsplus_crypto_sign_signature(l_sign->sig_data, &l_sign->sig_len, (const unsigned char *)a_msg_in, a_msg_size, l_skey->data);
-
- return l_ret;
+ return sphincsplus_crypto_sign_signature(l_sign->sig_data, &l_sign->sig_len, (const unsigned char *)a_msg_in, a_msg_size, l_skey->data);
}
size_t dap_enc_sig_sphincsplus_get_sign_msg(dap_enc_key_t *a_key, const void *a_msg, const size_t a_msg_size,
diff --git a/crypto/src/dap_sign.c b/crypto/src/dap_sign.c
index ede92e8dc0c8d441808c96ae71424096d17d4f8a..e104ab530dce7dac4fddfe82c0bda5034171ea9a 100755
--- a/crypto/src/dap_sign.c
+++ b/crypto/src/dap_sign.c
@@ -83,7 +83,9 @@ dap_sign_type_t dap_sign_type_from_key_type( dap_enc_key_type_t a_key_type)
#ifdef DAP_ECDSA
case DAP_ENC_KEY_TYPE_SIG_ECDSA: l_sign_type.type = SIG_TYPE_ECDSA; break;
#endif
+#ifdef DAP_SHIPOVNIK
case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK: l_sign_type.type = SIG_TYPE_SHIPOVNIK; break;
+#endif
case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED: l_sign_type.type = SIG_TYPE_MULTI_CHAINED; break;
default: l_sign_type.raw = 0;
}
@@ -107,7 +109,9 @@ dap_enc_key_type_t dap_sign_type_to_key_type(dap_sign_type_t a_chain_sign_type
#ifdef DAP_ECDSA
case SIG_TYPE_ECDSA: return DAP_ENC_KEY_TYPE_SIG_ECDSA;
#endif
+#ifdef DAP_SHIPOVNIK
case SIG_TYPE_SHIPOVNIK: return DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK;
+#endif
case SIG_TYPE_MULTI_CHAINED: return DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED;
default: return DAP_ENC_KEY_TYPE_INVALID;
}
@@ -133,7 +137,9 @@ const char * dap_sign_type_to_str(dap_sign_type_t a_chain_sign_type)
#ifdef DAP_ECDSA
case SIG_TYPE_ECDSA: return "sig_ecdsa";
#endif
+#ifdef DAP_SHIPOVNIK
case SIG_TYPE_SHIPOVNIK: return "sig_shipovnik";
+#endif
case SIG_TYPE_MULTI_COMBINED: return "sig_multi_combined";
case SIG_TYPE_MULTI_CHAINED: return "sig_multi_chained";
default: return "UNDEFINED";//DAP_ENC_KEY_TYPE_NULL;
@@ -166,8 +172,10 @@ dap_sign_type_t dap_sign_type_from_str(const char * a_type_str)
} else if ( !dap_strcmp (a_type_str, "sig_ecdsa") ) {
l_sign_type.type = SIG_TYPE_ECDSA;
#endif
+#ifdef DAP_SHIPOVNIK
} else if ( !dap_strcmp (a_type_str, "sig_shipovnik") ) {
l_sign_type.type = SIG_TYPE_SHIPOVNIK;
+#endif
} else if ( !dap_strcmp (a_type_str,"sig_multi_chained") ){
l_sign_type.type = SIG_TYPE_MULTI_CHAINED;
// } else if ( !dap_strcmp (a_type_str,"sig_multi_combined") ){
@@ -215,7 +223,9 @@ int dap_sign_create_output(dap_enc_key_t *a_key, const void * a_data, const size
#ifdef DAP_ECDSA
case DAP_ENC_KEY_TYPE_SIG_ECDSA:
#endif
+#ifdef DAP_SHIPOVNIK
case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+#endif
case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
return a_key->sign_get(a_key, a_data, a_data_size, a_output, *a_output_size);
@@ -459,7 +469,9 @@ int dap_sign_verify(dap_sign_t *a_chain_sign, const void *a_data, const size_t a
#ifdef DAP_ECDSA
case DAP_ENC_KEY_TYPE_SIG_ECDSA:
#endif
+#ifdef DAP_SHIPOVNIK
case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+#endif
case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
l_ret = l_key->sign_verify(l_key, l_verify_data, l_verify_data_size, l_sign_data, l_sign_data_size);
break;
@@ -590,5 +602,8 @@ DAP_INLINE const char *dap_sign_get_str_recommended_types(){
#ifdef DAP_ECDSA
"sig_ecdsa\n"
#endif
- "sig_sphincs\nsig_shipovnik\nsig_multi_chained\n";
+#ifdef DAP_SHIPOVNIK
+ "sig_shipovnik\n"
+#endif
+ "sig_sphincs\nsig_multi_chained\n";
}
\ No newline at end of file
diff --git a/crypto/src/sig_shipovnik/genvector.c b/crypto/src/sig_shipovnik/genvector.c
index b73147faa1357608bbeb5a785c112b8afb89b71e..ccb4b898fa0d34e6e3b562c28ec65cc6c9f1e2bf 100644
--- a/crypto/src/sig_shipovnik/genvector.c
+++ b/crypto/src/sig_shipovnik/genvector.c
@@ -99,3 +99,14 @@ void gen_vector(uint16_t *s) {
uint64_t buf[N_shipovnik];
shuffle(entropy, s, buf, N_shipovnik);
}
+
+void gen_vector_with_seed(uint16_t *s, uint32_t *seed) {
+
+ memset(s + W_shipovnik, 0, sizeof(uint16_t) * (N_shipovnik - W_shipovnik));
+ for (size_t i = 0; i < W_shipovnik; ++i) {
+ s[i] = 1;
+ }
+
+ uint64_t buf[N_shipovnik];
+ shuffle(seed, s, buf, N_shipovnik);
+}
diff --git a/crypto/src/sig_shipovnik/genvector.h b/crypto/src/sig_shipovnik/genvector.h
index 2177ad255e1ea639dca3149c69c0ba7bb7e57532..c2868a1f1d73df2bc85031cf74e53468a96b64b9 100644
--- a/crypto/src/sig_shipovnik/genvector.h
+++ b/crypto/src/sig_shipovnik/genvector.h
@@ -42,3 +42,10 @@ void shuffle(const uint32_t *p, uint16_t *pi, uint64_t *buf, size_t len);
* @param[out] s buffer to be filled. Should have size at least 'N'.
*/
void gen_vector(uint16_t *s);
+
+/**
+ * @brief Generate random binary vector.
+ * @param[in] seed seed array. Should have size at least 'N'.
+ * @param[out] s buffer to be filled. Should have size at least 'N'.
+ */
+void gen_vector_with_seed(uint16_t *s, uint32_t *seed);
diff --git a/crypto/src/sig_shipovnik/shipovnik.c b/crypto/src/sig_shipovnik/shipovnik.c
index b92a3a3ff78f10bceeee14492e4ea66e06e66568..befaf4310191fca496a64f68f99fa112b30c0240 100644
--- a/crypto/src/sig_shipovnik/shipovnik.c
+++ b/crypto/src/sig_shipovnik/shipovnik.c
@@ -48,6 +48,17 @@ void shipovnik_generate_keys(uint8_t *sk, uint8_t *pk) {
syndrome(H_PRIME, sk, pk);
}
+void shipovnik_generate_keys_with_seed(uint8_t *sk, uint8_t *pk, uint32_t *seed) {
+ ALLOC_ON_STACK(uint16_t, s, N_shipovnik);
+ gen_vector_with_seed(s, seed);
+ for (size_t i = 0; i < N_shipovnik; ++i) {
+ size_t j = i / 8;
+ sk[j] <<= 1;
+ sk[j] |= s[i] & 1;
+ }
+ syndrome(H_PRIME, sk, pk);
+}
+
#define SIGMA_Y_SIZE (SIGMA_PACKED_BYTES + SHIPOVNIK_PUBLICKEYBYTES)
void shipovnik_sign(const uint8_t *sk, const uint8_t *msg, size_t msg_len,
diff --git a/crypto/src/sig_shipovnik/shipovnik.h b/crypto/src/sig_shipovnik/shipovnik.h
index 6286b4ba1c8631c603e5ecbfdb686dee6c33dcf3..637c18c325de82703d668896d75342153481414e 100644
--- a/crypto/src/sig_shipovnik/shipovnik.h
+++ b/crypto/src/sig_shipovnik/shipovnik.h
@@ -40,6 +40,16 @@
*/
void shipovnik_generate_keys(uint8_t *sk, uint8_t *pk);
+/**
+ * @brief Generates secret key and public key with prepared seed array.
+ * @param[in] s prepared seed array, of size N_shipovnik
+ * @param[out] sk Contiguous array to receive secret key, of size
+ * `SHIPOVNIK_SECRETKEYBYTES`.
+ * @param[out] pk Contiguous array to receive public key, of size
+ * `SHIPOVNIK_PUBLICKEYBYTES`.
+ */
+void shipovnik_generate_keys_with_seed(uint8_t *sk, uint8_t *pk, uint32_t *s);
+
/**
* @brief Generates signature for given message according to secret key.
*
diff --git a/crypto/test/crypto/dap_enc_benchmark_test.c b/crypto/test/crypto/dap_enc_benchmark_test.c
index 651f31cee77f4deb26206d54dea58d25855babe7..814bfb99fc719a79faf8284281c8995a46a62998 100644
--- a/crypto/test/crypto/dap_enc_benchmark_test.c
+++ b/crypto/test/crypto/dap_enc_benchmark_test.c
@@ -5,38 +5,22 @@
#include "rand/dap_rand.h"
#define LOG_TAG "dap_crypto_benchmark_tests"
-//#define SIGNATURE_TYPE_COUNT 7
-#define SIGN_COUNT 5
#define KEYS_TOTAL_COUNT 10
-dap_enc_key_type_t s_key_type_arr[] = {
- DAP_ENC_KEY_TYPE_SIG_TESLA,
- DAP_ENC_KEY_TYPE_SIG_BLISS,
- DAP_ENC_KEY_TYPE_SIG_DILITHIUM,
- // DAP_ENC_KEY_TYPE_SIG_PICNIC,
- DAP_ENC_KEY_TYPE_SIG_FALCON,
- DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS,
-#ifdef DAP_ECDSA
- DAP_ENC_KEY_TYPE_SIG_ECDSA,
-#endif
- DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK };
-
/*--------------------------TRANSFER TEST BLOCK--------------------------*/
-static int s_transfer_test(dap_enc_key_type_t a_key_type, int a_times, int *a_gen_time, int *a_alice_shared, int *a_bob_shared)
+static void s_transfer_test(dap_enc_key_type_t a_key_type, int a_times, int *a_gen_time, int *a_alice_shared, int *a_bob_shared)
{
- int l_ret = 0;
dap_enc_key_t **l_alice_keys = NULL;
dap_enc_key_t **l_bob_keys = NULL;
- DAP_NEW_Z_COUNT_RET_VAL(l_alice_keys, dap_enc_key_t*, a_times, 1, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_bob_keys, dap_enc_key_t*, a_times, 1, l_alice_keys);
+ DAP_NEW_Z_COUNT_RET(l_alice_keys, dap_enc_key_t*, a_times, NULL);
+ DAP_NEW_Z_COUNT_RET(l_bob_keys, dap_enc_key_t*, a_times, l_alice_keys);
int l_t1 = get_cur_time_msec();
for (int i = 0; i < a_times; ++i) {
l_alice_keys[i] = dap_enc_key_new_generate(a_key_type, NULL, 0, NULL, 0, 0);
dap_assert_PIF(l_alice_keys[i], "Key generate");
- l_ret |= !l_alice_keys[i];
}
int l_t2 = get_cur_time_msec();
@@ -47,7 +31,6 @@ static int s_transfer_test(dap_enc_key_type_t a_key_type, int a_times, int *a_ge
l_bob_keys[i] = dap_enc_key_new(a_key_type);
l_bob_keys[i]->pub_key_data_size = l_bob_keys[i]->gen_bob_shared_key(l_bob_keys[i], l_alice_keys[i]->pub_key_data, l_alice_keys[i]->pub_key_data_size, (void**)&l_bob_keys[i]->pub_key_data);
dap_assert_PIF(l_bob_keys[i]->pub_key_data_size, "Bob shared key gen");
- l_ret |= !l_bob_keys[i]->pub_key_data_size;
}
l_t2 = get_cur_time_msec();
*a_bob_shared = l_t2 - l_t1;
@@ -62,22 +45,19 @@ static int s_transfer_test(dap_enc_key_type_t a_key_type, int a_times, int *a_ge
for(int i = 0; i < a_times; ++i) {
int l_cmp = memcmp(l_alice_keys[i]->shared_key, l_bob_keys[i]->shared_key, l_alice_keys[i]->shared_key_size);
dap_assert_PIF(!l_cmp, "Session keys equals");
- l_ret |= l_cmp;
dap_enc_key_delete(l_alice_keys[i]);
dap_enc_key_delete(l_bob_keys[i]);
}
DAP_DEL_MULTY(l_alice_keys, l_bob_keys);
- return l_ret;
}
-static int s_transfer_test_benchmark(const char *a_name, dap_enc_key_type_t a_key_type, int a_times) {
+static void s_transfer_test_benchmark(const char *a_name, dap_enc_key_type_t a_key_type, int a_times) {
dap_print_module_name(a_name);
- int l_ret = 0;
int l_gen_time = 0;
int l_alice_shared = 0;
int l_bob_shared = 0;
- l_ret |= s_transfer_test(a_key_type, a_times, &l_gen_time, &l_alice_shared, &l_bob_shared);
+ s_transfer_test(a_key_type, a_times, &l_gen_time, &l_alice_shared, &l_bob_shared);
char l_msg[120] = {0};
sprintf(l_msg, "Key gen %d times", a_times);
@@ -86,14 +66,12 @@ static int s_transfer_test_benchmark(const char *a_name, dap_enc_key_type_t a_ke
benchmark_mgs_time(l_msg, l_bob_shared);
sprintf(l_msg, "Alice shared key gen %d times", a_times);
benchmark_mgs_time(l_msg, l_alice_shared);
- return l_ret;
}
/*-----------------------------------------------------------------------*/
/*------------------SIGNING AND VERIFICATION TEST BLOCK------------------*/
-static int s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a_sig_time, int *a_verify_time)
+static void s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a_sig_time, int *a_verify_time)
{
- int l_ret = 0;
size_t seed_size = sizeof(uint8_t);
uint8_t seed[sizeof(uint8_t)];
randombytes(seed, seed_size);
@@ -105,26 +83,25 @@ static int s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a
size_t max_signature_size = dap_sign_create_output_unserialized_calc_size(l_key_temp, 0);
dap_enc_key_delete(l_key_temp);
- DAP_NEW_Z_COUNT_RET_VAL(l_signs, uint8_t*, a_times, 1, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_source, uint8_t*, a_times, 1, l_signs);
- DAP_NEW_Z_COUNT_RET_VAL(l_keys, dap_enc_key_t*, a_times, 1, l_source, l_signs);
+ DAP_NEW_Z_COUNT_RET(l_signs, uint8_t*, a_times, NULL);
+ DAP_NEW_Z_COUNT_RET(l_source, uint8_t*, a_times, l_signs);
+ DAP_NEW_Z_COUNT_RET(l_keys, dap_enc_key_t*, a_times, l_source, l_signs);
int l_t1 = 0;
*a_sig_time = 0;
- int l_sig_type_count = sizeof(s_key_type_arr) / sizeof(*s_key_type_arr);
for (int i = 0; i < a_times; ++i) {
randombytes(seed, seed_size);
// used only in multisign
dap_enc_key_type_t l_key[KEYS_TOTAL_COUNT];
for (int j = 0; j < KEYS_TOTAL_COUNT; j++) {
- int l_step = random_uint32_t(l_sig_type_count);
- l_key[j] = s_key_type_arr[l_step];
+ int l_step = random_uint32_t(c_keys_count);
+ l_key[j] = c_key_type_arr[l_step];
}
// ----------
- DAP_NEW_Z_SIZE_RET_VAL(l_signs[i], uint8_t, max_signature_size, 1, NULL);
+ DAP_NEW_Z_SIZE_RET(l_signs[i], uint8_t, max_signature_size, NULL);
l_source_size[i] = 1 + random_uint32_t(20);
- DAP_NEW_Z_SIZE_RET_VAL(l_source[i], uint8_t, l_source_size[i], 1, NULL);
+ DAP_NEW_Z_SIZE_RET(l_source[i], uint8_t, l_source_size[i], NULL);
randombytes(l_source[i], l_source_size[i]);
l_t1 = get_cur_time_msec();
@@ -139,7 +116,6 @@ static int s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a
}
*a_sig_time += get_cur_time_msec() - l_t1;
dap_assert_PIF(!l_signed, "Signing message");
- l_ret |= l_signed;
}
l_t1 = get_cur_time_msec();
@@ -153,7 +129,6 @@ static int s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a
l_verified = l_keys[i]->sign_verify(l_keys[i], &l_hash, sizeof(l_hash), l_signs[i], max_signature_size);
}
dap_assert_PIF(!l_verified, "Verifying signature");
- l_ret |= l_verified;
}
*a_verify_time = get_cur_time_msec() - l_t1;
//memory free
@@ -163,36 +138,33 @@ static int s_sign_verify_test(dap_enc_key_type_t a_key_type, int a_times, int *a
DAP_DELETE(l_source[i]);
}
DAP_DEL_MULTY(l_signs, l_source, l_keys);
- return l_ret;
}
-static int s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, int *a_sig_time, int *a_verify_time)
+static void s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, int *a_sig_time, int *a_verify_time)
{
- int l_ret = 0;
size_t seed_size = sizeof(uint8_t);
uint8_t seed[seed_size];
dap_sign_t **l_signs = NULL;
uint8_t **l_source = NULL;
size_t l_source_size[a_times];
- DAP_NEW_Z_COUNT_RET_VAL(l_signs, dap_sign_t*, a_times, 1, NULL);
- DAP_NEW_Z_COUNT_RET_VAL(l_source, uint8_t*, a_times, 1, l_signs);
+ DAP_NEW_Z_COUNT_RET(l_signs, dap_sign_t*, a_times, NULL);
+ DAP_NEW_Z_COUNT_RET(l_source, uint8_t*, a_times, l_signs);
int l_t1 = 0;
*a_sig_time = 0;
- int l_sig_type_count = sizeof(s_key_type_arr) / sizeof(*s_key_type_arr);
for (int i = 0; i < a_times; ++i) {
randombytes(seed, seed_size);
// used only in multisign
dap_enc_key_type_t l_key[KEYS_TOTAL_COUNT];
for (int j = 0; j < KEYS_TOTAL_COUNT; j++) {
- int l_step = random_uint32_t(l_sig_type_count);
- l_key[j] = s_key_type_arr[l_step];
+ int l_step = random_uint32_t(c_keys_count);
+ l_key[j] = c_key_type_arr[l_step];
}
// ----------
l_source_size[i] = 1 + random_uint32_t(20);
- DAP_NEW_Z_SIZE_RET_VAL(l_source[i], uint8_t, l_source_size[i], 1, NULL);
+ DAP_NEW_Z_SIZE_RET(l_source[i], uint8_t, l_source_size[i], NULL);
randombytes(l_source[i], l_source_size[i]);
l_t1 = get_cur_time_msec();
@@ -207,7 +179,6 @@ static int s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, in
*a_sig_time += get_cur_time_msec() - l_t1;
dap_assert_PIF(l_signs[i], "Signing message and serialize");
- l_ret |= !l_signs[i];
dap_enc_key_delete(key);
}
@@ -222,7 +193,6 @@ static int s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, in
l_verified = dap_sign_verify(l_signs[i], &l_hash, sizeof(l_hash));
}
dap_assert_PIF(!l_verified, "Deserialize and verifying signature");
- l_ret |= l_verified;
}
*a_verify_time = get_cur_time_msec() - l_t1;
@@ -230,16 +200,14 @@ static int s_sign_verify_ser_test(dap_enc_key_type_t a_key_type, int a_times, in
DAP_DEL_MULTY(l_signs[i], l_source[i]);
}
DAP_DEL_MULTY(l_signs, l_source);
- return l_ret;
}
-static int s_sign_verify_test_becnhmark(const char *a_name, dap_enc_key_type_t a_key_type, int a_times) {
+static void s_sign_verify_test_becnhmark(const char *a_name, dap_enc_key_type_t a_key_type, int a_times) {
dap_print_module_name(a_name);
- int l_ret = 0;
int l_sig_time = 0;
int l_verify_time = 0;
- l_ret |= s_sign_verify_test(a_key_type, a_times, &l_sig_time, &l_verify_time);
+ s_sign_verify_test(a_key_type, a_times, &l_sig_time, &l_verify_time);
char l_msg[120] = {0};
sprintf(l_msg, "Signing message %d times", a_times);
@@ -247,50 +215,36 @@ static int s_sign_verify_test_becnhmark(const char *a_name, dap_enc_key_type_t a
sprintf(l_msg, "Verifying message %d times", a_times);
benchmark_mgs_time(l_msg, l_verify_time);
- l_ret |= s_sign_verify_ser_test(a_key_type, a_times, &l_sig_time, &l_verify_time);
+ s_sign_verify_ser_test(a_key_type, a_times, &l_sig_time, &l_verify_time);
sprintf(l_msg, "Signing message with serialization %d times", a_times);
benchmark_mgs_time(l_msg, l_sig_time);
sprintf(l_msg, "Verifying message with serialization %d times", a_times);
benchmark_mgs_time(l_msg, l_verify_time);
- return l_ret;
}
/*-----------------------------------------------------------------------*/
-static int s_transfer_tests_run(int a_times)
+static void s_transfer_tests_run(int a_times)
{
- int l_ret = 0;
dap_init_test_case();
- l_ret |= s_transfer_test_benchmark("NEWHOPE", DAP_ENC_KEY_TYPE_RLWE_NEWHOPE_CPA_KEM, a_times);
- l_ret |= s_transfer_test_benchmark("KYBER512", DAP_ENC_KEY_TYPE_KEM_KYBER512, a_times);
- l_ret |= s_transfer_test_benchmark("MSRLN", DAP_ENC_KEY_TYPE_MSRLN, a_times);
+ s_transfer_test_benchmark("NEWHOPE", DAP_ENC_KEY_TYPE_RLWE_NEWHOPE_CPA_KEM, a_times);
+ s_transfer_test_benchmark("KYBER512", DAP_ENC_KEY_TYPE_KEM_KYBER512, a_times);
+ s_transfer_test_benchmark("MSRLN", DAP_ENC_KEY_TYPE_MSRLN, a_times);
dap_cleanup_test_case();
- return l_ret;
}
-static int s_sign_verify_tests_run(int a_times)
+static void s_sign_verify_tests_run(int a_times)
{
- int l_ret = 0;
dap_init_test_case();
- // s_sign_verify_test_becnhmark("PICNIC", DAP_ENC_KEY_TYPE_SIG_PICNIC, a_times);
- l_ret |= s_sign_verify_test_becnhmark("TESLA", DAP_ENC_KEY_TYPE_SIG_TESLA, a_times);
- l_ret |= s_sign_verify_test_becnhmark("BLISS", DAP_ENC_KEY_TYPE_SIG_BLISS, a_times);
- l_ret |= s_sign_verify_test_becnhmark("DILITHIUM", DAP_ENC_KEY_TYPE_SIG_DILITHIUM, a_times);
- l_ret |= s_sign_verify_test_becnhmark("FALCON", DAP_ENC_KEY_TYPE_SIG_FALCON, a_times);
- l_ret |= s_sign_verify_test_becnhmark("SPHINCSPLUS", DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS, a_times);
-#ifdef DAP_ECDSA
- l_ret |= s_sign_verify_test_becnhmark("ECDSA", DAP_ENC_KEY_TYPE_SIG_ECDSA, a_times);
-#endif
- l_ret |= s_sign_verify_test_becnhmark("SHIPOVNIK", DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK, a_times);
- l_ret |= s_sign_verify_test_becnhmark("MULTISIGN", DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED, a_times);
+ for (size_t i = 0; i < c_keys_count; ++i) {
+ s_sign_verify_test_becnhmark(s_key_type_to_str(c_key_type_arr[i]), c_key_type_arr[i], a_times);
+ }
+ s_sign_verify_test_becnhmark("MULTISIGN", DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED, a_times);
dap_cleanup_test_case();
- return l_ret;
}
-int dap_enc_benchmark_tests_run(int a_times)
+void dap_enc_benchmark_tests_run(int a_times)
{
- int l_ret = 0;
- l_ret |= s_transfer_tests_run(a_times);
- l_ret |= s_sign_verify_tests_run(a_times);
- return l_ret;
+ s_transfer_tests_run(a_times);
+ s_sign_verify_tests_run(a_times);
}
diff --git a/crypto/test/crypto/dap_enc_benchmark_test.h b/crypto/test/crypto/dap_enc_benchmark_test.h
index 929d8e62c5a1d7464e72b0dcc9dccef83d152e46..3af77069f0f3f5f9c7531f5d1db90eda8320a025 100644
--- a/crypto/test/crypto/dap_enc_benchmark_test.h
+++ b/crypto/test/crypto/dap_enc_benchmark_test.h
@@ -1,3 +1,3 @@
#pragma once
-int dap_enc_benchmark_tests_run(int a_times);
\ No newline at end of file
+void dap_enc_benchmark_tests_run(int a_times);
\ No newline at end of file
diff --git a/crypto/test/crypto/dap_enc_multithread_test.c b/crypto/test/crypto/dap_enc_multithread_test.c
index f85bd6756ce7f9fef14c003448828e2e92ac277a..4f004882d6cc32f4f48421240be8dba1b6cd059f 100644
--- a/crypto/test/crypto/dap_enc_multithread_test.c
+++ b/crypto/test/crypto/dap_enc_multithread_test.c
@@ -127,14 +127,17 @@ int dap_enc_multithread_tests_run(int a_times)
s_test_multithread("Falcon", s_test_thread_falcon, a_times);
dap_pass_msg("Falcon multithread tests");
- s_test_multithread("ECDSA", s_test_thread_ecdsa, a_times);
- dap_pass_msg("ECDSA multithread tests");
-
s_test_multithread("Sphincs plus", s_test_thread_sphincs, a_times);
dap_pass_msg("Sphincs plus multithread tests");
+#ifdef DAP_ECDSA
+ s_test_multithread("ECDSA", s_test_thread_ecdsa, a_times);
+ dap_pass_msg("ECDSA multithread tests");
+#endif
+#ifdef DAP_SHIPOVNIK
s_test_multithread("Shipovnik", s_test_thread_shipovnik, a_times);
dap_pass_msg("Shipovnik plus multithread tests");
+#endif
dap_cleanup_test_case();
return 0;
}
diff --git a/crypto/test/crypto/dap_enc_test.c b/crypto/test/crypto/dap_enc_test.c
index d38bf5fd0cea58359ca1571935de8b64fbd3b6ef..f4b734b3408c9048e98e2872b9d92dc4dee4ee07 100755
--- a/crypto/test/crypto/dap_enc_test.c
+++ b/crypto/test/crypto/dap_enc_test.c
@@ -7,6 +7,23 @@
#include "dap_enc.h"
#define LOG_TAG "dap_crypto_enc_tests"
+#define DAP_CHAIN_ATOM_MAX_SIZE (256 * 1024) // 256 KB
+
+const dap_enc_key_type_t c_key_type_arr[] = {
+ DAP_ENC_KEY_TYPE_SIG_TESLA,
+ DAP_ENC_KEY_TYPE_SIG_BLISS,
+ DAP_ENC_KEY_TYPE_SIG_DILITHIUM,
+ // DAP_ENC_KEY_TYPE_SIG_PICNIC,
+ DAP_ENC_KEY_TYPE_SIG_FALCON,
+ DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS,
+#ifdef DAP_ECDSA
+ DAP_ENC_KEY_TYPE_SIG_ECDSA,
+#endif
+#ifdef DAP_SHIPOVNIK
+ DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK
+#endif
+ };
+const size_t c_keys_count = sizeof(c_key_type_arr) / sizeof(dap_enc_key_type_t);
int get_cur_time_msec();
@@ -218,6 +235,98 @@ void* _read_key_from_file(const char* file_name, size_t key_size)
return resut_key;
}
+static void test_key_generate_by_seed(dap_enc_key_type_t a_key_type)
+{
+ const size_t seed_size = 1 + random_uint32_t( 1000);
+ uint8_t seed[seed_size];
+ randombytes(seed, seed_size);
+
+ size_t
+ l_priv_key_data_size_1 = 0,
+ l_priv_key_data_size_2 = 0,
+ l_priv_key_data_size_3 = 0,
+ l_priv_key_data_size_4 = 0,
+ l_priv_key_data_size_5 = 0,
+ l_pub_key_data_size_1 = 0,
+ l_pub_key_data_size_2 = 0,
+ l_pub_key_data_size_3 = 0,
+ l_pub_key_data_size_4 = 0,
+ l_pub_key_data_size_5 = 0;
+
+ dap_enc_key_t* l_key_1 = dap_enc_key_new_generate(a_key_type, NULL, 0, seed, seed_size, 0);
+ dap_enc_key_t* l_key_2 = dap_enc_key_new_generate(a_key_type, NULL, 0, seed, seed_size, 0);
+ dap_enc_key_t* l_key_3 = dap_enc_key_new_generate(a_key_type, NULL, 0, NULL, seed_size, 0);
+ dap_enc_key_t* l_key_4 = dap_enc_key_new_generate(a_key_type, NULL, 0, seed, 0, 0);
+ dap_enc_key_t* l_key_5 = dap_enc_key_new_generate(a_key_type, NULL, 0, NULL, 0, 0);
+
+
+ uint8_t *l_priv_key_data_1 = dap_enc_key_serialize_priv_key(l_key_1, &l_priv_key_data_size_1);
+ uint8_t *l_priv_key_data_2 = dap_enc_key_serialize_priv_key(l_key_2, &l_priv_key_data_size_2);
+ uint8_t *l_priv_key_data_3 = dap_enc_key_serialize_priv_key(l_key_3, &l_priv_key_data_size_3);
+ uint8_t *l_priv_key_data_4 = dap_enc_key_serialize_priv_key(l_key_4, &l_priv_key_data_size_4);
+ uint8_t *l_priv_key_data_5 = dap_enc_key_serialize_priv_key(l_key_5, &l_priv_key_data_size_5);
+
+ uint8_t *l_pub_key_data_1 = dap_enc_key_serialize_pub_key(l_key_1, &l_pub_key_data_size_1);
+ uint8_t *l_pub_key_data_2 = dap_enc_key_serialize_pub_key(l_key_2, &l_pub_key_data_size_2);
+ uint8_t *l_pub_key_data_3 = dap_enc_key_serialize_pub_key(l_key_3, &l_pub_key_data_size_3);
+ uint8_t *l_pub_key_data_4 = dap_enc_key_serialize_pub_key(l_key_4, &l_pub_key_data_size_4);
+ uint8_t *l_pub_key_data_5 = dap_enc_key_serialize_pub_key(l_key_5, &l_pub_key_data_size_5);
+
+ dap_assert_PIF(l_priv_key_data_size_1 && l_pub_key_data_size_1 &&
+ l_priv_key_data_size_2 && l_pub_key_data_size_2 &&
+ l_priv_key_data_size_3 && l_pub_key_data_size_3 &&
+ l_priv_key_data_size_4 && l_pub_key_data_size_4 &&
+ l_priv_key_data_size_5 && l_pub_key_data_size_5 &&
+
+ l_priv_key_data_1 && l_pub_key_data_1 &&
+ l_priv_key_data_2 && l_pub_key_data_2 &&
+ l_priv_key_data_3 && l_pub_key_data_3 &&
+ l_priv_key_data_4 && l_pub_key_data_4 &&
+ l_priv_key_data_5 && l_pub_key_data_5,
+ "Priv and pub data serialisation");
+
+ dap_assert_PIF(l_priv_key_data_size_1 == l_priv_key_data_size_2, "Equal priv_key_data_size");
+ dap_assert_PIF(l_priv_key_data_size_1 == l_priv_key_data_size_3, "Equal priv_key_data_size");
+ dap_assert_PIF(l_priv_key_data_size_1 == l_priv_key_data_size_4, "Equal priv_key_data_size");
+ dap_assert_PIF(l_priv_key_data_size_1 == l_priv_key_data_size_5, "Equal priv_key_data_size");
+
+ dap_assert_PIF(l_pub_key_data_size_1 == l_pub_key_data_size_2, "Equal pub_key_data_size");
+ dap_assert_PIF(l_pub_key_data_size_1 == l_pub_key_data_size_3, "Equal pub_key_data_size");
+ dap_assert_PIF(l_pub_key_data_size_1 == l_pub_key_data_size_4, "Equal pub_key_data_size");
+ dap_assert_PIF(l_pub_key_data_size_1 == l_pub_key_data_size_5, "Equal pub_key_data_size");
+
+ dap_assert_PIF(!memcmp(l_priv_key_data_1, l_priv_key_data_2, l_priv_key_data_size_1), "Equal priv_key_data with same seed");
+ dap_assert_PIF(memcmp(l_priv_key_data_1, l_priv_key_data_3, l_priv_key_data_size_1), "Different priv_key_data with not same seed");
+ dap_assert_PIF(memcmp(l_priv_key_data_1, l_priv_key_data_4, l_priv_key_data_size_1), "Different priv_key_data with not same seed");
+ dap_assert_PIF(memcmp(l_priv_key_data_1, l_priv_key_data_5, l_priv_key_data_size_1), "Different priv_key_data with not same seed");
+
+ dap_assert_PIF(memcmp(l_priv_key_data_3, l_priv_key_data_4, l_priv_key_data_size_1), "Different priv_key_data without seed");
+ dap_assert_PIF(memcmp(l_priv_key_data_3, l_priv_key_data_5, l_priv_key_data_size_1), "Different priv_key_data without seed");
+ dap_assert_PIF(memcmp(l_priv_key_data_4, l_priv_key_data_5, l_priv_key_data_size_1), "Different priv_key_data without seed");
+
+ dap_assert_PIF(!memcmp(l_pub_key_data_1, l_pub_key_data_2, l_pub_key_data_size_1), "Equal pub_key_data with same seed");
+ dap_assert_PIF(memcmp(l_pub_key_data_1, l_pub_key_data_3, l_pub_key_data_size_1), "Different pub_key_data with not same seed");
+ dap_assert_PIF(memcmp(l_pub_key_data_1, l_pub_key_data_4, l_pub_key_data_size_1), "Different pub_key_data with not same seed");
+ dap_assert_PIF(memcmp(l_pub_key_data_1, l_pub_key_data_5, l_pub_key_data_size_1), "Different pub_key_data with not same seed");
+
+ dap_assert_PIF(memcmp(l_pub_key_data_3, l_pub_key_data_4, l_pub_key_data_size_1), "Different pub_key_data without seed");
+ dap_assert_PIF(memcmp(l_pub_key_data_3, l_pub_key_data_5, l_pub_key_data_size_1), "Different pub_key_data without seed");
+ dap_assert_PIF(memcmp(l_pub_key_data_4, l_pub_key_data_5, l_pub_key_data_size_1), "Different pub_key_data without seed");
+
+ dap_enc_key_delete(l_key_1);
+ dap_enc_key_delete(l_key_2);
+ dap_enc_key_delete(l_key_3);
+ dap_enc_key_delete(l_key_4);
+ dap_enc_key_delete(l_key_5);
+
+ DAP_DEL_MULTY( l_priv_key_data_1, l_pub_key_data_1,
+ l_priv_key_data_2, l_pub_key_data_2,
+ l_priv_key_data_3, l_pub_key_data_3,
+ l_priv_key_data_4, l_pub_key_data_4,
+ l_priv_key_data_5, l_pub_key_data_5);
+ dap_assert(true, s_key_type_to_str(a_key_type));
+}
+
/**
* @key_type may be DAP_ENC_KEY_TYPE_IAES, DAP_ENC_KEY_TYPE_OAES
*/
@@ -375,6 +484,7 @@ static void test_serialize_deserialize_pub_priv(dap_enc_key_type_t key_type)
DAP_DELETE(l_sign_tmp);
dap_assert_PIF(sig_buf, "Check serialize->deserialize signature");
+ dap_assert(sig_buf_len < DAP_CHAIN_ATOM_MAX_SIZE, "Check signature size"); // if fail new sign, recheck define in cellframe-sdk
// decode by key2
switch (key_type) {
@@ -408,46 +518,29 @@ void dap_enc_tests_run() {
test_encode_decode_raw(500);
test_encode_decode_raw_b64(500);
test_encode_decode_raw_b64_url_safe(500);
- dap_print_module_name("dap_enc serialize->deserialize BLISS");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_BLISS, false);
- dap_print_module_name("dap_enc serialize->deserialize PICNIC");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_PICNIC, false);
- dap_print_module_name("dap_enc serialize->deserialize TESLA");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_TESLA, false);
- dap_print_module_name("dap_enc serialize->deserialize DILITHIUM");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_DILITHIUM, false);
- dap_print_module_name("dap_enc serialize->deserialize FALCON");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_FALCON, false);
- dap_print_module_name("dap_enc serialize->deserialize SPHINCSPLUS");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS, false);
-#ifdef DAP_ECDSA
- dap_print_module_name("dap_enc serialize->deserialize ECDSA");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_ECDSA, false);
-#endif
+
+ dap_print_module_name("key generate by seed");
+ for (size_t i = 0; i < c_keys_count; ++i) {
+ test_key_generate_by_seed(c_key_type_arr[i]);
+ }
+
+ for (size_t i = 0; i < c_keys_count; ++i) {
+ char l_module_name[128] = { 0 };
+ snprintf(l_module_name, sizeof(l_module_name) - 1, "dap_enc serialize->deserialize %s", s_key_type_to_str(c_key_type_arr[i]));
+ dap_print_module_name(l_module_name);
+ test_serialize_deserialize(c_key_type_arr[i], false);
+ }
+
dap_print_module_name("dap_enc serialize->deserialize IAES");
test_serialize_deserialize(DAP_ENC_KEY_TYPE_IAES, true);
- dap_print_module_name("dap_enc serialize->deserialize SHIPOVNIK");
- test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK, false);
dap_print_module_name("dap_enc serialize->deserialize OAES");
test_serialize_deserialize(DAP_ENC_KEY_TYPE_OAES, true);
- dap_print_module_name("dap_enc_sig serialize->deserialize BLISS");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_BLISS);
- dap_print_module_name("dap_enc_sig serialize->deserialize PICNIC");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_PICNIC);
- dap_print_module_name("dap_enc_sig serialize->deserialize TESLA");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_TESLA);
- dap_print_module_name("dap_enc_sig serialize->deserialize DILITHIUM");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_DILITHIUM);
- dap_print_module_name("dap_enc_sig serialize->deserialize FALCON");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_FALCON);
- dap_print_module_name("dap_enc_sig serialize->deserialize SPHINCSPLUS");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS);
-#ifdef DAP_ECDSA
- dap_print_module_name("dap_enc_sig serialize->deserialize ECDSA");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_ECDSA);
-#endif
- dap_print_module_name("dap_enc_sig serialize->deserialize SHIPOVNIK");
- test_serialize_deserialize_pub_priv(DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK);
+ for (size_t i = 0; i < c_keys_count; ++i) {
+ char l_module_name[128] = { 0 };
+ snprintf(l_module_name, sizeof(l_module_name) - 1, "dap_enc_sig serialize->deserialize %s", s_key_type_to_str(c_key_type_arr[i]));
+ dap_print_module_name(l_module_name);
+ test_serialize_deserialize_pub_priv(c_key_type_arr[i]);
+ }
dap_cleanup_test_case();
}
\ No newline at end of file
diff --git a/crypto/test/crypto/dap_enc_test.h b/crypto/test/crypto/dap_enc_test.h
index 23f9f5f6c114206a64ffd000b96dfcfaa7897773..6dfa02529fda6655e7c108cbabea2e7f12320527 100755
--- a/crypto/test/crypto/dap_enc_test.h
+++ b/crypto/test/crypto/dap_enc_test.h
@@ -1,9 +1,33 @@
#pragma once
#include "dap_enc_key.h"
+
+extern const dap_enc_key_type_t c_key_type_arr[];
+extern const size_t c_keys_count;
+
+DAP_STATIC_INLINE const char *s_key_type_to_str(dap_enc_key_type_t a_signe_key_type)
+{
+ switch (a_signe_key_type) {
+ case DAP_ENC_KEY_TYPE_SIG_TESLA: return "TESLA";
+ case DAP_ENC_KEY_TYPE_SIG_BLISS: return "BLISS";
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM: return "DILITHIUM";
+ case DAP_ENC_KEY_TYPE_SIG_PICNIC: return "PICNIC";
+ case DAP_ENC_KEY_TYPE_SIG_FALCON: return "FALCON";
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS: return "SPHINCSPLUS";
+#ifdef DAP_ECDSA
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA: return "ECDSA";
+#endif
+#ifdef DAP_SHIPOVNIK
+ case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK: return "SHIPOVNIK";
+#endif
+ default: return "UNDEFINED";//DAP_ENC_KEY_TYPE_NULL;
+ }
+
+}
+
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);
-int dap_enc_benchmark_tests_run(int a_times);
+void dap_enc_benchmark_tests_run(int a_times);
void dap_init_test_case();
void dap_cleanup_test_case();
\ No newline at end of file
diff --git a/global-db/dap_global_db_cluster.c b/global-db/dap_global_db_cluster.c
index 508c7da86aedc66e805c3ba357f6203cebb9204d..51c17b1ba080f8e2c8612eaf540eb825254e01c7 100644
--- a/global-db/dap_global_db_cluster.c
+++ b/global-db/dap_global_db_cluster.c
@@ -148,7 +148,8 @@ dap_global_db_cluster_t *dap_global_db_cluster_add(dap_global_db_instance_t *a_d
DL_APPEND(a_dbi->clusters, l_cluster);
if (dap_strcmp(DAP_STREAM_CLUSTER_LOCAL, a_mnemonim))
dap_proc_thread_timer_add(NULL, s_gdb_cluster_sync_timer_callback, l_cluster, 1000);
- log_it(L_INFO, "Successfully added GlobalDB cluster ID %s for group mask %s", dap_guuid_to_hex_str(a_guuid), a_group_mask);
+ log_it(L_INFO, "Successfully added GlobalDB cluster ID %s for group mask %s, TTL %s",
+ dap_guuid_to_hex_str(a_guuid), a_group_mask, l_cluster->ttl ? dap_itoa(l_cluster->ttl) : "unlimited");
return l_cluster;
}
diff --git a/io/dap_context.c b/io/dap_context.c
index c2ac6741799125cab63a5fede46db714aae00600..db352198212efec227f9495da4de81fc89891c2a 100644
--- a/io/dap_context.c
+++ b/io/dap_context.c
@@ -349,6 +349,7 @@ static void *s_context_thread(void *a_arg)
pthread_cond_destroy(&l_context->started_cond);
pthread_mutex_destroy(&l_context->started_mutex);
DAP_DELETE(l_context);
+ DAP_DELETE(l_msg);
return NULL;
}
diff --git a/io/dap_events_socket.c b/io/dap_events_socket.c
index 7598e9b4f5a81e26b340fb4e772251131603021e..1bb6c32a5d9091adf481133af8a0641830c5cb7b 100644
--- a/io/dap_events_socket.c
+++ b/io/dap_events_socket.c
@@ -1309,14 +1309,20 @@ void dap_events_socket_set_readable_unsafe_ex(dap_events_socket_t *a_es, bool a_
case DESCRIPTOR_TYPE_SOCKET_LISTENING:
case DESCRIPTOR_TYPE_SOCKET_LOCAL_LISTENING:
- if ( (a_es->socket2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET )
+ if ( (a_es->socket2 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET ) {
log_it(L_ERROR, "Failed to create socket for accept()'ing, errno %d", WSAGetLastError());
- else {
- l_err = pfnAcceptEx( a_es->socket, a_es->socket2, (LPVOID)(a_es->buf_in), 0,
- sizeof(SOCKADDR_STORAGE) + 16, sizeof(SOCKADDR_STORAGE) + 16,
- &bytes, (OVERLAPPED*)ol ) ? ERROR_SUCCESS : WSAGetLastError();
- func = "AcceptEx";
+ break;
+ }
+ u_long l_option = 1;
+ if ( setsockopt(a_es->socket2, SOL_SOCKET, SO_REUSEADDR, (const char*)&l_option, sizeof(int)) < 0 ) {
+ _set_errno( WSAGetLastError() );
+ log_it(L_ERROR, "setsockopt(SO_REUSEADDR) on socket %d failed, error %d: \"%s\"",
+ a_es->socket2, errno, dap_strerror(errno));
}
+ l_err = pfnAcceptEx( a_es->socket, a_es->socket2, (LPVOID)(a_es->buf_in), 0,
+ sizeof(SOCKADDR_STORAGE) + 16, sizeof(SOCKADDR_STORAGE) + 16,
+ &bytes, (OVERLAPPED*)ol ) ? ERROR_SUCCESS : WSAGetLastError();
+ func = "AcceptEx";
break;
case DESCRIPTOR_TYPE_FILE:
diff --git a/io/dap_proc_thread.c b/io/dap_proc_thread.c
index e8fab8317f409e2740f0f2200ae6a38584260ef1..26d5041323e3cec43b915944d526d13a53214717 100644
--- a/io/dap_proc_thread.c
+++ b/io/dap_proc_thread.c
@@ -37,9 +37,31 @@ static dap_proc_thread_t *s_threads = NULL;
static int s_context_callback_started(dap_context_t *a_context, void *a_arg);
static int s_context_callback_stopped(dap_context_t *a_context, void *a_arg);
+/**
+ * @brief add and run context to thread
+ * @param a_thread alocated thread memory
+ * @param a_cpu_id cpu id to thread assign
+ * @return result of dap_context_run (0 all OK)
+ */
+
+int dap_proc_thread_create(dap_proc_thread_t *a_thread, int a_cpu_id)
+{
+ dap_return_val_if_pass(!a_thread || a_thread->context, -1);
+
+ a_thread->context = dap_context_new(DAP_CONTEXT_TYPE_PROC_THREAD);
+ a_thread->context->_inheritor = a_thread;
+ int l_ret = dap_context_run(a_thread->context, a_cpu_id, DAP_CONTEXT_POLICY_TIMESHARING,
+ DAP_CONTEXT_PRIORITY_NORMAL, DAP_CONTEXT_FLAG_WAIT_FOR_STARTED,
+ s_context_callback_started, s_context_callback_stopped, a_thread);
+ if (l_ret) {
+ log_it(L_CRITICAL, "Create thread failed with code %d", l_ret);
+ }
+ return l_ret;
+}
+
/**
* @brief dap_proc_thread_init
- * @param a_cpu_count 0 means autodetect
+ * @param a_threads_count 0 means autodetect
* @return
*/
@@ -50,19 +72,11 @@ int dap_proc_thread_init(uint32_t a_threads_count)
return -1;
}
s_threads = DAP_NEW_Z_SIZE(dap_proc_thread_t, sizeof(dap_proc_thread_t) * s_threads_count);
- for (uint32_t i = 0; i < s_threads_count; i++) {
- dap_proc_thread_t *l_thread = s_threads + i;
- l_thread->context = dap_context_new(DAP_CONTEXT_TYPE_PROC_THREAD);
- l_thread->context->_inheritor = l_thread;
- int l_ret = dap_context_run(l_thread->context, i, DAP_CONTEXT_POLICY_TIMESHARING,
- DAP_CONTEXT_PRIORITY_NORMAL, DAP_CONTEXT_FLAG_WAIT_FOR_STARTED,
- s_context_callback_started, s_context_callback_stopped, l_thread);
- if (l_ret) {
- log_it(L_CRITICAL, "Create thread failed with code %d", l_ret);
- return l_ret;
- }
+ int l_ret = 0;
+ for (uint32_t i = 0; i < s_threads_count && !l_ret; ++i) {
+ l_ret = dap_proc_thread_create(s_threads + i, i);
}
- return 0;
+ return l_ret;
}
/**
@@ -167,7 +181,8 @@ int dap_proc_thread_loop(dap_context_t *a_context)
!(l_item = s_proc_queue_pull(l_thread, &l_item_priority)))
pthread_cond_wait(&l_thread->queue_event, &l_thread->queue_lock);
pthread_mutex_unlock(&l_thread->queue_lock);
- debug_if(g_debug_reactor, L_DEBUG, "Call callback %p with arg %p on thread %p",
+ if (l_item)
+ debug_if(g_debug_reactor, L_DEBUG, "Call callback %p with arg %p on thread %p",
l_item->callback, l_item->callback_arg, l_thread);
if (!a_context->signal_exit &&
l_item->callback(l_item->callback_arg))
diff --git a/io/include/dap_proc_thread.h b/io/include/dap_proc_thread.h
index 0ba6823228090592d8a4733fe4dfa0eb7f6faebe..716b273fe83134ea9a1ef6e9703765996297dde4 100644
--- a/io/include/dap_proc_thread.h
+++ b/io/include/dap_proc_thread.h
@@ -61,6 +61,7 @@ typedef struct dap_proc_thread {
#define DAP_PROC_THREAD(a) (dap_proc_thread_t *)((a)->_inheritor);
+int dap_proc_thread_create(dap_proc_thread_t *a_thread, int a_cpu_id);
int dap_proc_thread_init(uint32_t a_threads_count);
void dap_proc_thread_deinit();
int dap_proc_thread_loop(dap_context_t *a_context);
diff --git a/net/link_manager/dap_link_manager.c b/net/link_manager/dap_link_manager.c
index 04467ee8bf1121ea77c94a1153b06db8f9575e43..12ee05a34405ac775b7c0227d3ffb0f1d55c5aaa 100644
--- a/net/link_manager/dap_link_manager.c
+++ b/net/link_manager/dap_link_manager.c
@@ -245,7 +245,7 @@ void dap_link_manager_deinit()
DL_FOREACH_SAFE(s_link_manager->nets, it, tmp)
dap_link_manager_remove_net(((dap_managed_net_t *)it->data)->id);
pthread_rwlock_destroy(&s_link_manager->links_lock);
- DAP_DELETE(s_link_manager);
+ DAP_DEL_Z(s_link_manager);
}
/**
diff --git a/net/server/notify_server/src/dap_notify_srv.c b/net/server/notify_server/src/dap_notify_srv.c
index b894b2216091e941607f339312eece1a67544c7b..e8d82ded1754e269bd81f2550bb1580c41573329 100644
--- a/net/server/notify_server/src/dap_notify_srv.c
+++ b/net/server/notify_server/src/dap_notify_srv.c
@@ -205,25 +205,26 @@ int dap_notify_server_send_f_mt(const char *a_format, ...)
*/
static void s_notify_server_callback_queue(dap_events_socket_t * a_es, void * a_arg)
{
+ size_t l_str_len = a_arg ? strlen((char*)a_arg) : 0;
+ if ( !l_str_len )
+ return;
pthread_rwlock_rdlock(&s_notify_server_clients_mutex);
dap_events_socket_handler_hh_t * l_socket_handler = NULL,* l_tmp = NULL;
- HASH_ITER(hh, s_notify_server_clients, l_socket_handler, l_tmp){
+ HASH_ITER(hh, s_notify_server_clients, l_socket_handler, l_tmp) {
uint32_t l_worker_id = l_socket_handler->worker_id;
- if(l_worker_id>= dap_events_thread_get_count()){
+ if ( l_worker_id >= dap_events_thread_get_count() ) {
log_it(L_ERROR,"Wrong worker id %u for send_inter() function", l_worker_id);
continue;
}
- size_t l_str_len = a_arg? strlen((char*)a_arg): 0;
- if(l_str_len){
+ char *l_arg =
#ifdef DAP_EVENTS_CAPS_IOCP
- dap_events_socket_write_mt( dap_events_worker_get(l_worker_id),
- l_socket_handler->uuid, a_arg, l_str_len + 1 );
+ a_arg;
#else
- dap_events_socket_write_inter(a_es->worker->queue_es_io_input[l_worker_id],
- l_socket_handler->uuid,
- a_arg, l_str_len + 1);
+ DAP_DUP_SIZE(a_arg, l_str_len + 1);
#endif
- }
+
+ dap_events_socket_write_mt( dap_events_worker_get(l_worker_id),
+ l_socket_handler->uuid, l_arg, l_str_len + 1 );
}
pthread_rwlock_unlock(&s_notify_server_clients_mutex);
DAP_DELETE(a_arg);