diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index a699a5375042be453fc834d578fe03ceae117cdf..37d56d723403da0cf77a056649be676b50807dbd 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -21,7 +21,7 @@ linux-amd64-tests:
before_script: /opt/buildtools/prepare_environment.sh amd64-linux
script:
- mkdir build
- - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON && make -j$(nproc) && ctest --verbose
+ - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON -DBUILD_WITH_ECDSA=ON && make -j$(nproc) && ctest --verbose
linux-arm32v7-tests:
extends: .tests
@@ -29,7 +29,7 @@ linux-arm32v7-tests:
before_script: /opt/buildtools/prepare_environment.sh arm32v7-linux
script:
- mkdir build
- - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON && make -j$(nproc) && ctest --verbose
+ - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON -DBUILD_WITH_ECDSA=ON && make -j$(nproc) && ctest --verbose
linux-arm64v8-tests:
extends: .tests
@@ -37,7 +37,7 @@ linux-arm64v8-tests:
before_script: /opt/buildtools/prepare_environment.sh arm64-linux
script:
- mkdir build
- - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON && make -j$(nproc) && ctest --verbose
+ - cd build && cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_DAP_SDK_TESTS=ON -DBUILD_GLOBAL_DB_TEST=ON -DBUILD_WITH_GDB_DRIVER_SQLITE=ON -DBUILD_WITH_ECDSA=ON && make -j$(nproc) && ctest --verbose
windows-tests:
extends: .tests
diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt
index 4d408e91b57659a44c1246aed036d478480c2857..f92ce856db27eb1ee246d9fa5c163c63657a780f 100755
--- a/crypto/CMakeLists.txt
+++ b/crypto/CMakeLists.txt
@@ -127,9 +127,10 @@ file( GLOB CRYPTO_SRCS
${SPHINCS_SRCS}
)
-if (BUILD_WITH_TPS_TEST)
+if (BUILD_WITH_TPS_TEST OR BUILD_WITH_ECDSA)
file (GLOB ECDSA_SRC src/sig_ecdsa/*.c)
set (CRYPTO_SRCS ${CRYPTO_SRCS} ${ECDSA_SRC})
+ add_definitions("-DDAP_ECDSA")
else()
list (FILTER CRYPTO_SRCS EXCLUDE REGEX ".*ecdsa.c")
endif()
@@ -161,7 +162,7 @@ file( GLOB CRYPTO_HEADERS
${SPHINCS_HEADERS}
include/*.h
)
-if (BUILD_WITH_TPS_TEST)
+if (BUILD_WITH_TPS_TEST OR BUILD_WITH_ECDSA)
file (GLOB ECDSA_HDR src/sig_ecdsa/*.h)
set (CRYPTO_HEADERS ${CRYPTO_HEADERS} ${ECDSA_HDR})
else()
@@ -184,7 +185,7 @@ file( GLOB XKCP_SRCS
set( CRYPTO_INCLUDE_PRIVATE src/seed src/rand src/iaes src/oaes src/sha3 src/msrln src/sig_bliss src/sig_tesla src/sig_picnic src/sig_dilithium src/falcon src/sig_shipovnik src/sig_shipovnik/streebog src/sphincsplus src include)
add_subdirectory (src/Kyber/crypto_kem/kyber512/optimized/)
-if (BUILD_WITH_TPS_TEST)
+if (BUILD_WITH_TPS_TEST OR BUILD_WITH_ECDSA)
add_subdirectory (${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/secp256k1/ ${CMAKE_CURRENT_BINARY_DIR}/secp256k1)
endif()
@@ -446,7 +447,7 @@ endif()
target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/json-c)
target_link_libraries(dap_crypto dap_core dap_crypto_kyber512 dap_json-c)
-if (BUILD_WITH_TPS_TEST)
+if (BUILD_WITH_TPS_TEST OR BUILD_WITH_ECDSA)
target_link_libraries(dap_crypto secp256k1)
endif()
@@ -455,7 +456,7 @@ if(UNIX)
endif()
target_include_directories(dap_crypto PUBLIC ../3rdparty/shishua)
-if (BUILD_WITH_TPS_TEST)
+if (BUILD_WITH_TPS_TEST OR BUILD_WITH_ECDSA)
target_include_directories(dap_crypto PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/secp256k1/include)
target_include_directories(dap_crypto PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/secp256k1/src)
endif()
diff --git a/crypto/include/dap_enc_ecdsa.h b/crypto/include/dap_enc_ecdsa.h
index 8731cab10221c921782ddf0af631113c271b4a7e..e92c4a7a5cf53c57f1e86fc3573de6b1e0635054 100755
--- a/crypto/include/dap_enc_ecdsa.h
+++ b/crypto/include/dap_enc_ecdsa.h
@@ -21,10 +21,10 @@ int dap_enc_sig_ecdsa_get_sign(struct dap_enc_key* key, const void* msg, const s
int dap_enc_sig_ecdsa_verify_sign(struct dap_enc_key* key, const void* msg, const size_t msg_size, void* signature,
const size_t signature_size);
-uint8_t *dap_enc_sig_ecdsa_write_signature(const void* a_sign, dap_enc_key_t *a_key, size_t *a_sign_out);
-uint8_t *dap_enc_sig_ecdsa_write_public_key(const void *a_key, size_t *a_buflen_out);
-void* dap_enc_sig_ecdsa_read_signature(const uint8_t *a_buf, dap_enc_key_t *a_key, size_t a_buflen);
-void* dap_enc_sig_ecdsa_read_public_key(const uint8_t *a_buf, dap_enc_key_t *a_key, size_t a_buflen);
+uint8_t *dap_enc_sig_ecdsa_write_signature(const void* a_sign, size_t *a_sign_out);
+uint8_t *dap_enc_sig_ecdsa_write_public_key(const void *a_public_key, size_t *a_buflen_out);
+void* dap_enc_sig_ecdsa_read_signature(const uint8_t *a_buf, size_t a_buflen);
+void* dap_enc_sig_ecdsa_read_public_key(const uint8_t *a_buf, size_t a_buflen);
DAP_STATIC_INLINE uint64_t dap_enc_sig_ecdsa_ser_key_size(UNUSED_ARG const void *a_in) {
return ECDSA_PRIVATE_KEY_SIZE;
diff --git a/crypto/include/dap_enc_key.h b/crypto/include/dap_enc_key.h
index 51f981c6d51e68ae6243493b30fdc1f6a0695615..205feba8d7bf6545a9a59418035932554d644d5a 100755
--- a/crypto/include/dap_enc_key.h
+++ b/crypto/include/dap_enc_key.h
@@ -192,9 +192,7 @@ typedef void (*dap_enc_callback_size_t)(dap_enc_key_t *, size_t);
typedef void (*dap_enc_callback_str_t)(dap_enc_key_t *, const char*);
typedef char * (*dap_enc_callback_r_str_t)(dap_enc_key_t *);
typedef uint8_t * (*dap_enc_callback_serialize_t)(const void *, size_t *);
-typedef uint8_t * (*dap_enc_callback_serialize_ex_t)(const void*, dap_enc_key_t*, size_t*);
typedef void * (*dap_enc_callback_deserialize_t)(const uint8_t *, size_t);
-typedef void * (*dap_enc_callback_deserialize_ex_t)(const uint8_t*, dap_enc_key_t*, size_t);
typedef size_t (*dap_enc_callback_calc_out_size)(const size_t);
typedef size_t (*dap_enc_get_allpbk_list) (dap_enc_key_t *a_key, const void *allpbk_list, const int allpbk_num);
@@ -209,7 +207,6 @@ typedef struct dap_enc_key {
byte_t * shared_key;
};
-
size_t pub_key_data_size;
//unsigned char * pub_key_data; // can be null if enc symmetric
void * pub_key_data; // can be null if enc symmetric
@@ -228,9 +225,9 @@ typedef struct dap_enc_key {
dap_enc_gen_alice_shared_key gen_alice_shared_key;
dap_enc_gen_bob_shared_key gen_bob_shared_key;
- void *pbkListdata;
- size_t pbkListsize;
- dap_enc_get_allpbk_list getallpbkList;
+ void *pbk_list_data; // todo use only in ringct20, move to _inheritor?
+ size_t pbk_list_size;
+ dap_enc_get_allpbk_list get_all_pbk_list;
void * _pvt; // PVT part of the object
@@ -263,7 +260,6 @@ typedef struct dap_enc_key_callbacks{
dap_enc_gen_alice_shared_key gen_alice_shared_key;
dap_enc_callback_serialize_t ser_sign;
- dap_enc_callback_serialize_ex_t ser_sign_ex;
dap_enc_callback_serialize_t ser_priv_key;
dap_enc_callback_serialize_t ser_pub_key;
dap_enc_callback_key_size_t ser_pub_key_size;
@@ -271,10 +267,8 @@ typedef struct dap_enc_key_callbacks{
dap_enc_callback_deserialize_t deser_sign;
- dap_enc_callback_deserialize_ex_t deser_sign_ex;
dap_enc_callback_deserialize_t deser_priv_key;
dap_enc_callback_deserialize_t deser_pub_key;
- dap_enc_callback_deserialize_ex_t deser_pub_key_ex;
dap_enc_callback_key_size_t deser_sign_size;
dap_enc_callback_key_size_t deser_pub_key_size;
dap_enc_callback_key_size_t deser_priv_key_size;
@@ -297,17 +291,16 @@ void dap_enc_key_deinit(void);
const char *dap_enc_get_type_name(dap_enc_key_type_t a_key_type);
dap_enc_key_type_t dap_enc_key_type_find_by_name(const char *a_name);
-size_t dap_enc_key_get_enc_size(dap_enc_key_t * a_key, const size_t a_buf_in_size);
-size_t dap_enc_key_get_dec_size(dap_enc_key_t * a_key, const size_t a_buf_in_size);
+size_t dap_enc_key_get_enc_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size);
+size_t dap_enc_key_get_dec_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size);
size_t dap_enc_calc_signature_unserialized_size(dap_enc_key_t *a_key);
-uint8_t* dap_enc_key_serialize_sign(dap_enc_key_t *a_key, uint8_t *a_sign, size_t *a_sign_len);
-uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_t *a_key, uint8_t *a_sign, size_t *a_sign_len);
+uint8_t* dap_enc_key_serialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len);
+uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len);
uint8_t* dap_enc_key_serialize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_out);
uint8_t* dap_enc_key_serialize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_out);
int dap_enc_key_deserialize_priv_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen);
int dap_enc_key_deserialize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen);
-int dap_enc_key_deserialize_pub_key_old(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen);
uint8_t *dap_enc_key_serialize(dap_enc_key_t *a_key, size_t *a_buflen);
dap_enc_key_t* dap_enc_key_deserialize(const void *buf, size_t a_buf_size);
diff --git a/crypto/src/dap_cert_file.c b/crypto/src/dap_cert_file.c
index 76f2ab9336a8739e530a8cf8967c5ae62fe01cb3..ed03cb6d1727777d1194ff9268e1472748776eb2 100755
--- a/crypto/src/dap_cert_file.c
+++ b/crypto/src/dap_cert_file.c
@@ -33,7 +33,7 @@
#define LOG_TAG "dap_cert_file"
-static const char s_key_inheritor[] = "Inheritor";
+static const char s_key_inheritor[] = "inheritor";
/**
* @brief dap_cert_file_save
@@ -117,14 +117,25 @@ void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t
l_mem_shift += sizeof(uint32_t);
dap_cert_metadata_type_t l_meta_type = (dap_cert_metadata_type_t)a_data[l_mem_shift++];
const uint8_t *l_value = &a_data[l_mem_shift];
- l_mem_shift += l_value_size;
uint16_t l_tmp16;
uint32_t l_tmp32;
uint64_t l_tmp64;
switch (l_meta_type) {
case DAP_CERT_META_STRING:
case DAP_CERT_META_SIGN:
+ break;
case DAP_CERT_META_CUSTOM:
+ if(!strcmp(l_key_str, s_key_inheritor)) {
+ if (a_cert->enc_key->_inheritor) {
+ log_it(L_DEBUG, "Few inheritor records in cert metadata");
+ break;
+ }
+ DAP_NEW_Z_SIZE_RET(a_cert->enc_key->_inheritor, byte_t, l_value_size, NULL);
+ a_cert->enc_key->_inheritor_size = l_value_size;
+ a_cert->enc_key->_inheritor = DAP_DUP_SIZE(a_data + l_mem_shift, a_cert->enc_key->_inheritor_size);
+ l_mem_shift += l_value_size;
+ continue;
+ }
break;
default:
switch (l_value_size) {
@@ -160,6 +171,7 @@ void dap_cert_deserialize_meta(dap_cert_t *a_cert, const uint8_t *a_data, size_t
return;
}
}
+ l_mem_shift += l_value_size;
l_meta_arr[l_meta_items_count++] = l_new_meta;
}
if(l_meta_items_count){
diff --git a/crypto/src/dap_enc.c b/crypto/src/dap_enc.c
index b19e8bc6c1a69884e5354bc172e9357bdf015aec..eeb636c011e165638b20e6797f09e6019374640d 100755
--- a/crypto/src/dap_enc.c
+++ b/crypto/src/dap_enc.c
@@ -76,7 +76,7 @@ bool dap_enc_debug_more()
*/
size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
- size_t raw_encode_data_size = dap_enc_key_get_enc_size(a_key, a_buf_in_size);
+ size_t raw_encode_data_size = dap_enc_key_get_enc_size(a_key->type, a_buf_in_size);
if(raw_encode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
@@ -95,7 +95,7 @@ size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, d
*/
size_t dap_enc_decode_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
- size_t raw_decode_data_size = dap_enc_key_get_dec_size(a_key, a_buf_in_size);
+ size_t raw_decode_data_size = dap_enc_key_get_dec_size(a_key->type, a_buf_in_size);
if(raw_decode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
diff --git a/crypto/src/dap_enc_GOST.c b/crypto/src/dap_enc_GOST.c
index c1a13cf063275386f614e30a5fdb16462f9d21fa..b776387c5652fd5afed8bf82eb711864143f714e 100644
--- a/crypto/src/dap_enc_GOST.c
+++ b/crypto/src/dap_enc_GOST.c
@@ -31,9 +31,9 @@ void dap_enc_gost_key_delete(struct dap_enc_key *a_key)
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
- //DAP_DELETE(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
}
- //a_key->priv_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
//------GOST_OFB-----------
void dap_enc_gost_ofb_key_new(struct dap_enc_key * a_key)
diff --git a/crypto/src/dap_enc_SEED.c b/crypto/src/dap_enc_SEED.c
index 65ce0dfedb04d2e069d27f94edf5759168227791..e2a12b89d01969205fac9a32529714c06c755d7c 100644
--- a/crypto/src/dap_enc_SEED.c
+++ b/crypto/src/dap_enc_SEED.c
@@ -39,9 +39,9 @@ void dap_enc_seed_key_delete(struct dap_enc_key *a_key)
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
- //DAP_DELETE(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
}
- //a_key->priv_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
//------SEED_OFB-----------
void dap_enc_seed_ofb_key_new(struct dap_enc_key * a_key)
diff --git a/crypto/src/dap_enc_bf.c b/crypto/src/dap_enc_bf.c
index 2a5b78d8fb6861cf6ce31f602a207e9f7b1f6fe8..b1d67fff466d71e5be484a2cbc2c8f8cb54c998f 100644
--- a/crypto/src/dap_enc_bf.c
+++ b/crypto/src/dap_enc_bf.c
@@ -37,7 +37,7 @@ void dap_enc_bf_key_delete(struct dap_enc_key *a_key)
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
- //DAP_DELETE(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
}
a_key->priv_key_data_size = 0;
}
diff --git a/crypto/src/dap_enc_bliss.c b/crypto/src/dap_enc_bliss.c
index 85ef70b97388287f9a2876914ac1623a6dff3ae6..00dda51169856ce0c9367bf711db5837d8b6bb8d 100755
--- a/crypto/src/dap_enc_bliss.c
+++ b/crypto/src/dap_enc_bliss.c
@@ -131,12 +131,16 @@ int dap_enc_sig_bliss_verify_sign(dap_enc_key_t * key, const void * msg,
void dap_enc_sig_bliss_key_delete(dap_enc_key_t *key)
{
dap_return_if_pass(!key);
- if(key->priv_key_data)
+ if(key->priv_key_data) {
bliss_b_private_key_delete(key->priv_key_data);
- if(key->pub_key_data)
+ key->priv_key_data = NULL;
+ }
+ if(key->pub_key_data) {
bliss_b_public_key_delete(key->pub_key_data);
- key->priv_key_data = NULL;
- key->pub_key_data = NULL;
+ key->pub_key_data = NULL;
+ }
+ key->priv_key_data_size = 0;
+ key->pub_key_data_size = 0;
}
/* Serialize a signature */
diff --git a/crypto/src/dap_enc_dilithium.c b/crypto/src/dap_enc_dilithium.c
index 15bdadbbc10375659cd0e5469708da68c064d93c..16054a5591253cce092baf8b22131f0a024305d2 100755
--- a/crypto/src/dap_enc_dilithium.c
+++ b/crypto/src/dap_enc_dilithium.c
@@ -95,6 +95,8 @@ void dap_enc_sig_dilithium_key_delete(dap_enc_key_t *a_key)
a_key->pub_key_data = NULL;
a_key->priv_key_data = NULL;
+ a_key->pub_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
/* Serialize a signature */
diff --git a/crypto/src/dap_enc_ecdsa.c b/crypto/src/dap_enc_ecdsa.c
index 97f6e1afefbef9b29e1a5b3e6d496fbcefa379af..6267346851b6a77f3bb36e150282cac96a4f77de 100644
--- a/crypto/src/dap_enc_ecdsa.c
+++ b/crypto/src/dap_enc_ecdsa.c
@@ -8,8 +8,6 @@
#define LOG_TAG "dap_enc_sig_ecdsa"
-
-
static enum DAP_ECDSA_SIGN_SECURITY _ecdsa_type = ECDSA_MIN_SIZE; // by default
@@ -18,6 +16,27 @@ static enum DAP_ECDSA_SIGN_SECURITY _ecdsa_type = ECDSA_MIN_SIZE; // by default
// _ecdsa_type = type;
//}
+static ecdsa_context_t *s_context_create(unsigned int a_flags)
+{
+ ecdsa_context_t *l_ret = secp256k1_context_create(a_flags);
+ unsigned char l_random_seed[32];
+ randombytes(l_random_seed, sizeof(l_random_seed));
+ if (secp256k1_context_randomize(l_ret, l_random_seed) != 1) {
+ log_it(L_ERROR, "Error creating ECDSA context");
+ secp256k1_context_destroy(l_ret);
+ return NULL;
+ }
+ return l_ret;
+}
+
+DAP_STATIC_INLINE void s_sha256_hashing(const unsigned char *a_data, size_t a_data_size, unsigned char *a_out)
+{
+ secp256k1_sha256 l_hasher;
+ secp256k1_sha256_initialize(&l_hasher);
+ secp256k1_sha256_write(&l_hasher, a_data, a_data_size);
+ secp256k1_sha256_finalize(&l_hasher, a_out);
+}
+
void dap_enc_sig_ecdsa_key_new(dap_enc_key_t *a_key) {
*a_key = (dap_enc_key_t) {
.type = DAP_ENC_KEY_TYPE_SIG_ECDSA,
@@ -28,150 +47,159 @@ void dap_enc_sig_ecdsa_key_new(dap_enc_key_t *a_key) {
-void dap_enc_sig_ecdsa_key_new_generate(dap_enc_key_t * key, UNUSED_ARG const void *kex_buf,
- UNUSED_ARG size_t kex_size, UNUSED_ARG const void * seed, UNUSED_ARG size_t seed_size,
+void dap_enc_sig_ecdsa_key_new_generate(dap_enc_key_t *a_key, UNUSED_ARG const void *kex_buf,
+ UNUSED_ARG size_t kex_size, const void *a_seed, size_t a_seed_size,
UNUSED_ARG size_t key_size)
{
- unsigned char randomize[32];
- randombytes(randomize, sizeof(randomize));
- int retcode = 0;
-
- ecdsa_context_t* ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
- retcode = secp256k1_context_randomize(ctx, randomize);
- assert(retcode);
+// sanity check
+ dap_return_if_pass(!a_key);
+// memory alloc
+ DAP_NEW_Z_RET(a_key->priv_key_data, ecdsa_private_key_t, NULL);
+ DAP_NEW_Z_RET(a_key->pub_key_data, ecdsa_public_key_t, a_key->priv_key_data);
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_NONE);
+ if (!l_ctx) {
+ log_it(L_ERROR, "Error creating ECDSA context in generating key pair");
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
+ return;
+ }
+// keypair generate
+ if(a_seed && a_seed_size > 0) {
+ s_sha256_hashing((const unsigned char *)a_seed, a_seed_size, (unsigned char *)a_key->priv_key_data);
+ if (!secp256k1_ec_seckey_verify(l_ctx, (const unsigned char*)a_key->priv_key_data)) {
+ log_it(L_ERROR, "Error verify ECDSA private key");
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
+ goto clean_and_ret;
+ }
+ } else {
+ do {
+ randombytes(a_key->priv_key_data, sizeof(ecdsa_private_key_t));
+ } while ( !secp256k1_ec_seckey_verify(l_ctx, (const unsigned char*)a_key->priv_key_data) );
+ }
- key->_inheritor = ctx;
- key->_inheritor_size = secp256k1_context_preallocated_size(SECP256K1_CONTEXT_NONE);
//not sure we need this for ECDSA
//dap_enc_sig_ecdsa_set_type(ECDSA_MAX_SPEED)
-
- key->priv_key_data = DAP_NEW(ecdsa_private_key_t);
- key->priv_key_data_size = sizeof(ecdsa_private_key_t);
- do {
- randombytes(key->priv_key_data, key->priv_key_data_size);
- } while( !secp256k1_ec_seckey_verify(ctx, (const unsigned char*)key->priv_key_data) );
-
- key->pub_key_data = DAP_NEW(ecdsa_public_key_t);
- key->pub_key_data_size = sizeof(ecdsa_public_key_t);
- retcode = secp256k1_ec_pubkey_create( ctx, (ecdsa_public_key_t*)key->pub_key_data, (const unsigned char*)key->priv_key_data );
- assert(retcode);
-
- if(retcode != 1) {
+
+ if(secp256k1_ec_pubkey_create(l_ctx, (ecdsa_public_key_t*)a_key->pub_key_data, (const unsigned char*)a_key->priv_key_data) != 1) {
log_it(L_CRITICAL, "Error generating ECDSA key pair");
- secp256k1_context_destroy(ctx);
- DAP_DEL_MULTY(key->priv_key_data, key->pub_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
+ goto clean_and_ret;
}
+ a_key->priv_key_data_size = sizeof(ecdsa_private_key_t);
+ a_key->pub_key_data_size = sizeof(ecdsa_public_key_t);
+clean_and_ret:
+ secp256k1_context_destroy(l_ctx);
}
-int dap_enc_sig_ecdsa_get_sign(struct dap_enc_key* key, const void* msg, const size_t msg_size, void* signature, const size_t signature_size)
+int dap_enc_sig_ecdsa_get_sign(struct dap_enc_key *l_key, const void *a_msg, const size_t a_msg_size, void *a_sig, const size_t a_sig_size)
{
- if (signature_size != sizeof(ecdsa_signature_t)) {
- log_it(L_ERROR, "Invalid ecdsa signature size");
- return 1;
- }
- if (key->priv_key_data_size != sizeof(ecdsa_private_key_t)) {
- log_it(L_ERROR, "Invalid ecdsa key");
- return 2;
- }
- unsigned char randomize[32];
- randombytes(randomize, sizeof(randomize));
-
- int retcode = secp256k1_context_randomize(key->_inheritor, randomize);
- assert(retcode);
-
- ecdsa_private_key_t *privateKey = key->priv_key_data;
- ecdsa_signature_t *sig = signature;
- secp256k1_sha256 hasher;
- byte_t msghash[32] = { '\0' };
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, msg, msg_size);
- secp256k1_sha256_finalize(&hasher, msghash);
- retcode = secp256k1_ecdsa_sign(key->_inheritor, sig, msghash, privateKey->data, NULL, NULL) - 1;
- if ( retcode )
+// sanity check
+ dap_return_val_if_pass(!l_key, -1);
+ dap_return_val_if_pass_err(a_sig_size != sizeof(ecdsa_signature_t), -2, "Invalid ecdsa signature size");
+ dap_return_val_if_pass_err(l_key->priv_key_data_size != sizeof(ecdsa_private_key_t), -3, "Invalid ecdsa private key size");
+// msg hashing
+ byte_t l_msghash[32] = { '\0' };
+ s_sha256_hashing(a_msg, a_msg_size, l_msghash);
+// context create
+ int l_ret = 0;
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_SIGN);
+ if (!l_ctx || secp256k1_ecdsa_sign(l_ctx, (ecdsa_signature_t *)a_sig, l_msghash, l_key->priv_key_data, NULL, NULL) != 1) {
log_it(L_ERROR, "Failed to sign message");
- return retcode;
+ l_ret = -4;
+ }
+ secp256k1_context_destroy(l_ctx);
+ return l_ret;
}
-int dap_enc_sig_ecdsa_verify_sign(struct dap_enc_key* key, const void* msg, const size_t msg_size, void* signature, const size_t signature_size)
+int dap_enc_sig_ecdsa_verify_sign(struct dap_enc_key *l_key, const void *a_msg, const size_t a_msg_size, void *a_sig, const size_t a_sig_size)
{
- if (signature_size != sizeof(ecdsa_signature_t)) {
- log_it(L_ERROR, "Invalid ecdsa signature size");
- return 1;
- }
- if (key->pub_key_data_size != sizeof(ecdsa_public_key_t)) {
- log_it(L_ERROR, "Invalid ecdsa key");
- return 2;
- }
- ecdsa_public_key_t *publicKey = key->pub_key_data;
- ecdsa_signature_t *sig = signature;
- secp256k1_sha256 hasher;
- byte_t msghash[32] = { '\0' };
- secp256k1_sha256_initialize(&hasher);
- secp256k1_sha256_write(&hasher, msg, msg_size);
- secp256k1_sha256_finalize(&hasher, msghash);
- int retcode = secp256k1_ecdsa_verify(key->_inheritor, (const secp256k1_ecdsa_signature*)sig, msghash, publicKey) - 1;
- if ( retcode )
+// sanity check
+ dap_return_val_if_pass(!l_key, -1);
+ dap_return_val_if_pass_err(a_sig_size != sizeof(ecdsa_signature_t), -2, "Invalid ecdsa signature size");
+ dap_return_val_if_pass_err(l_key->pub_key_data_size != sizeof(ecdsa_public_key_t), -3, "Invalid ecdsa public key size");
+// msg hashing
+ byte_t l_msghash[32] = { '\0' };
+ s_sha256_hashing(a_msg, a_msg_size, l_msghash);
+// context create
+ int l_ret = 0;
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_VERIFY);
+ if (!l_ctx || secp256k1_ecdsa_verify(l_ctx, (const ecdsa_signature_t*)a_sig, l_msghash, (ecdsa_public_key_t *)l_key->pub_key_data) != 1) {
log_it(L_ERROR, "Failed to verify signature");
- return retcode;
+ l_ret = -4;
+ }
+ secp256k1_context_destroy(l_ctx);
+ return l_ret;
}
-uint8_t* dap_enc_sig_ecdsa_write_public_key(const void* a_key, size_t* a_buflen_out)
+uint8_t *dap_enc_sig_ecdsa_write_public_key(const void *a_public_key, size_t *a_buflen_out)
{
- dap_return_val_if_fail_err(a_key, NULL, "Invalid arg");
- dap_enc_key_t* l_key = (dap_enc_key_t*)a_key;
- byte_t *l_buf = DAP_NEW_SIZE(byte_t, ECDSA_PKEY_SERIALIZED_SIZE);
- if (!l_buf) {
- log_it(L_CRITICAL, "Memory allocation error");
- return NULL;
- }
+ dap_return_val_if_pass(!a_public_key, NULL);
+ byte_t *l_buf = NULL;
+ DAP_NEW_Z_SIZE_RET_VAL(l_buf, byte_t, ECDSA_PKEY_SERIALIZED_SIZE, NULL, NULL);
+
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_NONE);
+
size_t l_len = ECDSA_PKEY_SERIALIZED_SIZE;
- if ( 1 != secp256k1_ec_pubkey_serialize( (const ecdsa_context_t*)l_key->_inheritor, l_buf, &l_len,
- (const ecdsa_public_key_t*)l_key->pub_key_data, SECP256K1_EC_UNCOMPRESSED ) )
- {
+ if (
+ !l_ctx ||
+ secp256k1_ec_pubkey_serialize( l_ctx, l_buf, &l_len, (const ecdsa_public_key_t*)a_public_key, SECP256K1_EC_UNCOMPRESSED) != 1 ||
+ l_len != ECDSA_PKEY_SERIALIZED_SIZE
+ ) {
log_it(L_CRITICAL, "Failed to serialize pkey");
- DAP_DELETE(l_buf);
- return NULL;
+ DAP_DEL_Z(l_buf);
+ goto clean_and_ret;
}
- assert(l_len == ECDSA_PKEY_SERIALIZED_SIZE);
if (a_buflen_out)
*a_buflen_out = ECDSA_PKEY_SERIALIZED_SIZE;
+clean_and_ret:
+ secp256k1_context_destroy(l_ctx);
return l_buf;
}
-void* dap_enc_sig_ecdsa_read_public_key(const uint8_t* a_buf, dap_enc_key_t *a_key, size_t a_buflen) {
- dap_return_val_if_fail_err(a_buf && a_key && a_buflen == ECDSA_PKEY_SERIALIZED_SIZE, NULL, "Invalid args");
- if ( !a_key->pub_key_data )
- a_key->pub_key_data = DAP_NEW(ecdsa_public_key_t);
- a_key->pub_key_data_size = sizeof(ecdsa_public_key_t);
- return secp256k1_ec_pubkey_parse( (const ecdsa_context_t*)a_key->_inheritor,
- (ecdsa_public_key_t*)a_key->pub_key_data,
- a_buf, a_buflen ) == 1
- ? a_key->pub_key_data : ( log_it(L_CRITICAL, "Failed to deserialize pkey"), NULL );
+void *dap_enc_sig_ecdsa_read_public_key(const uint8_t* a_buf, size_t a_buflen) {
+// sanity check
+ dap_return_val_if_pass(!a_buf || a_buflen != ECDSA_PKEY_SERIALIZED_SIZE, NULL);
+// memory alloc
+ ecdsa_public_key_t *l_public_key = NULL;
+ DAP_NEW_Z_RET_VAL(l_public_key, ecdsa_public_key_t, NULL, NULL);
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_NONE);
+ if (!l_ctx || secp256k1_ec_pubkey_parse(l_ctx, l_public_key, a_buf, a_buflen ) != 1) {
+ log_it(L_CRITICAL, "Failed to deserialize pkey");
+ DAP_DEL_Z(l_public_key);
+ }
+ secp256k1_context_destroy(l_ctx);
+ return l_public_key;
}
-uint8_t *dap_enc_sig_ecdsa_write_signature(const void *a_sign, dap_enc_key_t *a_key, size_t *a_sign_len)
+uint8_t *dap_enc_sig_ecdsa_write_signature(const void *a_sign, size_t *a_sign_len)
{
- dap_return_val_if_fail_err(a_sign && a_key && a_sign_len, NULL, "Invalid args");
- byte_t *l_buf = DAP_NEW_SIZE(byte_t, sizeof(ecdsa_signature_t));
- if (!l_buf) {
- log_it(L_CRITICAL, "Memory allocation error");
- return NULL;
+ dap_return_val_if_pass(!a_sign || !a_sign_len, NULL);
+ byte_t *l_ret = NULL;
+ DAP_NEW_Z_SIZE_RET_VAL(l_ret, byte_t, sizeof(ecdsa_signature_t), NULL, NULL);
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_NONE);
+ if (!l_ctx || secp256k1_ecdsa_signature_serialize_compact(l_ctx, l_ret, (const ecdsa_signature_t*)a_sign) != 1) {
+ log_it(L_ERROR, "Failed to serialize sign");
+ DAP_DEL_Z(l_ret);
}
- return secp256k1_ecdsa_signature_serialize_compact( (const ecdsa_context_t*)a_key->_inheritor,
- l_buf, (const ecdsa_signature_t*)a_sign ) == 1
- ? l_buf : ( DAP_DELETE(l_buf), log_it(L_ERROR, "Failed to serialize sign"), NULL );
+ secp256k1_context_destroy(l_ctx);
+ return l_ret;
}
-void* dap_enc_sig_ecdsa_read_signature(const uint8_t* a_buf, dap_enc_key_t *a_key, size_t a_buflen)
+void *dap_enc_sig_ecdsa_read_signature(const uint8_t *a_buf, size_t a_buflen)
{
- dap_return_val_if_fail_err(a_buf && a_key && a_buflen == sizeof(ecdsa_signature_t), NULL, "Invalid args");
- ecdsa_signature_t *l_ret = DAP_NEW(ecdsa_signature_t);
- if (!l_ret) {
- log_it(L_CRITICAL, "Memory allocation error");
- return NULL;
+ dap_return_val_if_pass(!a_buf || a_buflen != sizeof(ecdsa_signature_t), NULL);
+ ecdsa_signature_t *l_ret = NULL;
+ DAP_NEW_Z_RET_VAL(l_ret, ecdsa_signature_t, NULL, NULL);
+
+ ecdsa_context_t *l_ctx = s_context_create(SECP256K1_CONTEXT_NONE);
+ if (!l_ctx || secp256k1_ecdsa_signature_parse_compact(l_ctx, l_ret, a_buf) != 1) {
+ log_it(L_ERROR, "Failed to deserialize sign");
+ DAP_DEL_Z(l_ret);
}
- return secp256k1_ecdsa_signature_parse_compact((const ecdsa_context_t*)a_key->_inheritor, l_ret, a_buf) == 1
- ? l_ret : ( DAP_DELETE(l_ret), log_it(L_ERROR, "Failed to deserialize sign"), NULL );
+ secp256k1_context_destroy(l_ctx);
+ return l_ret;
}
void dap_enc_sig_ecdsa_signature_delete(void *a_sig){
@@ -179,18 +207,23 @@ void dap_enc_sig_ecdsa_signature_delete(void *a_sig){
memset_safe(((ecdsa_signature_t *)a_sig)->data, 0, ECDSA_SIG_SIZE);
}
-void dap_enc_sig_ecdsa_private_key_delete(void* privateKey) {
- dap_return_if_pass(!privateKey);
- memset_safe( ((ecdsa_private_key_t*)privateKey)->data, 0, ECDSA_PRIVATE_KEY_SIZE);
+void dap_enc_sig_ecdsa_private_key_delete(void *a_private_key) {
+ dap_return_if_pass(!a_private_key);
+ memset_safe( ((ecdsa_private_key_t*)a_private_key)->data, 0, ECDSA_PRIVATE_KEY_SIZE);
+ DAP_DELETE(a_private_key);
}
-void dap_enc_sig_ecdsa_public_key_delete(void* publicKey) {
- dap_return_if_pass(!publicKey);
- memset_safe( ((ecdsa_public_key_t*)publicKey)->data, 0, ECDSA_PUBLIC_KEY_SIZE);
+void dap_enc_sig_ecdsa_public_key_delete(void *a_public_key) {
+ dap_return_if_pass(!a_public_key);
+ memset_safe( ((ecdsa_public_key_t*)a_public_key)->data, 0, ECDSA_PUBLIC_KEY_SIZE);
+ DAP_DELETE(a_public_key);
}
void dap_enc_sig_ecdsa_private_and_public_keys_delete(dap_enc_key_t* a_key) {
dap_enc_sig_ecdsa_private_key_delete(a_key->priv_key_data);
dap_enc_sig_ecdsa_public_key_delete(a_key->pub_key_data);
- secp256k1_context_destroy((ecdsa_context_t*)a_key->_inheritor);
+ a_key->pub_key_data = NULL;
+ a_key->priv_key_data = NULL;
+ a_key->pub_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
\ No newline at end of file
diff --git a/crypto/src/dap_enc_falcon.c b/crypto/src/dap_enc_falcon.c
index 42d9b25740508d4957ed9a7d58cb49a5794178ed..3c2c28141f3f51a30a34acca3e4f736da5f53ece 100644
--- a/crypto/src/dap_enc_falcon.c
+++ b/crypto/src/dap_enc_falcon.c
@@ -223,6 +223,8 @@ void dap_enc_sig_falcon_key_delete(dap_enc_key_t *key)
falcon_private_and_public_keys_delete((falcon_private_key_t *)key->priv_key_data, (falcon_public_key_t *)key->pub_key_data);
key->priv_key_data = NULL;
key->pub_key_data = NULL;
+ key->priv_key_data_size = 0;
+ key->pub_key_data_size = 0;
}
// Serialize a public key into a buffer.
diff --git a/crypto/src/dap_enc_iaes.c b/crypto/src/dap_enc_iaes.c
index db79a68d2a589542590ca7ea869c6e1511fdbf5f..86462ff382ea767b874e6eddbca6516ea5c713e0 100755
--- a/crypto/src/dap_enc_iaes.c
+++ b/crypto/src/dap_enc_iaes.c
@@ -21,7 +21,10 @@ typedef struct dap_enc_aes_key {
void dap_enc_aes_key_delete(struct dap_enc_key *a_key)
{
- free(a_key->_inheritor);
+ DAP_DEL_Z(a_key->_inheritor);
+ DAP_DEL_Z(a_key->priv_key_data);
+ a_key->_inheritor_size = 0;
+ a_key->priv_key_data_size = 0;
//No need any specific actions
}
diff --git a/crypto/src/dap_enc_key.c b/crypto/src/dap_enc_key.c
index 481d33e631e5e2e3c790a5bb151e507432d2b13a..cf85bda0fd6f0cb53c81c845a943c4a260c77cdf 100755
--- a/crypto/src/dap_enc_key.c
+++ b/crypto/src/dap_enc_key.c
@@ -40,7 +40,7 @@
#include "dap_enc_kyber.h"
#include "dap_enc_sphincsplus.h"
#include "dap_enc_multisign.h"
-#ifdef DAP_TPS_TEST
+#ifdef DAP_ECDSA
#include "dap_enc_ecdsa.h"
#endif
#include "dap_enc_shipovnik.h"
@@ -370,7 +370,7 @@ dap_enc_key_callbacks_t s_callbacks[]={
[DAP_ENC_KEY_TYPE_SIG_ECDSA]={
.name = "SIG_ECDSA",
-#ifdef DAP_TPS_TEST
+#ifdef DAP_ECDSA
.enc = NULL,
.dec = NULL,
.enc_na = NULL,
@@ -392,13 +392,13 @@ dap_enc_key_callbacks_t s_callbacks[]={
.sign_get = dap_enc_sig_ecdsa_get_sign,
.sign_verify = dap_enc_sig_ecdsa_verify_sign,
- .ser_sign_ex = dap_enc_sig_ecdsa_write_signature,
+ .ser_sign = dap_enc_sig_ecdsa_write_signature,
.ser_pub_key = dap_enc_sig_ecdsa_write_public_key,
.ser_priv_key_size = dap_enc_sig_ecdsa_ser_key_size,
.ser_pub_key_size = dap_enc_sig_ecdsa_ser_pkey_size,
- .deser_sign_ex = dap_enc_sig_ecdsa_read_signature,
- .deser_pub_key_ex = dap_enc_sig_ecdsa_read_public_key,
+ .deser_sign = dap_enc_sig_ecdsa_read_signature,
+ .deser_pub_key = dap_enc_sig_ecdsa_read_public_key,
.deser_priv_key_size = dap_enc_sig_ecdsa_deser_key_size,
.deser_pub_key_size = dap_enc_sig_ecdsa_deser_pkey_size,
.deser_sign_size = dap_enc_sig_ecdsa_signature_size
@@ -609,22 +609,25 @@ void dap_enc_key_deinit()
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
-uint8_t *dap_enc_key_serialize_sign(dap_enc_key_t *a_key, uint8_t *a_sign, size_t *a_sign_len)
+uint8_t *dap_enc_key_serialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
uint8_t *l_data = NULL;
- switch (a_key->type) {
+ switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
case DAP_ENC_KEY_TYPE_SIG_TESLA:
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA:
case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
- l_data = s_callbacks[a_key->type].ser_sign(a_sign, a_sign_len);
- break;
- case DAP_ENC_KEY_TYPE_SIG_ECDSA:
- l_data = s_callbacks[a_key->type].ser_sign_ex(a_sign, a_key, a_sign_len);
+ if (!s_callbacks[a_key_type].ser_sign) {
+ log_it(L_ERROR, "No callback for signature serialize to %s enc key", dap_enc_get_type_name(a_key_type));
+ return NULL;
+ }
+ l_data = s_callbacks[a_key_type].ser_sign(a_sign, a_sign_len);
break;
default:
+ dap_return_val_if_pass(!a_sign || !a_sign_len || !(*a_sign_len), NULL);
DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, *a_sign_len, NULL, NULL);
memcpy(l_data, a_sign, *a_sign_len);
}
@@ -639,27 +642,31 @@ uint8_t *dap_enc_key_serialize_sign(dap_enc_key_t *a_key, uint8_t *a_sign, size_
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
-uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_t *a_key, uint8_t *a_sign, size_t *a_sign_len)
+uint8_t* dap_enc_key_deserialize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
//todo: why are we changing a_sign_len after we have already used it in a function call?
+ dap_return_val_if_pass(!a_sign_len, NULL);
uint8_t *l_data = NULL;
- switch (a_key->type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
- case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
- l_data = s_callbacks[a_key->type].deser_sign(a_sign, *a_sign_len);
- *a_sign_len = s_callbacks[a_key->type].deser_sign_size(NULL);
- break;
- case DAP_ENC_KEY_TYPE_SIG_ECDSA:
- l_data = s_callbacks[a_key->type].deser_sign_ex(a_sign, a_key, *a_sign_len);
- break;
- default:
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, *a_sign_len, NULL, NULL);
- memcpy(l_data, a_sign, *a_sign_len);
+ switch (a_key_type) {
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+ case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
+ if (!s_callbacks[a_key_type].deser_sign || !s_callbacks[a_key_type].deser_sign_size) {
+ log_it(L_ERROR, "No callback for signature deserialize to %s enc key", dap_enc_get_type_name(a_key_type));
+ return NULL;
+ }
+ l_data = s_callbacks[a_key_type].deser_sign(a_sign, *a_sign_len);
+ *a_sign_len = s_callbacks[a_key_type].deser_sign_size(NULL);
+ break;
+ default:
+ dap_return_val_if_pass(!a_sign || !(*a_sign_len), NULL);
+ DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, *a_sign_len, NULL, NULL);
+ memcpy(l_data, a_sign, *a_sign_len);
}
return l_data;
}
@@ -677,18 +684,22 @@ uint8_t* dap_enc_key_serialize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_o
dap_return_val_if_pass(!a_key || !a_key->priv_key_data_size, NULL);
uint8_t *l_data = NULL;
switch (a_key->type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- l_data = s_callbacks[a_key->type].ser_priv_key(a_key->priv_key_data, a_buflen_out);
- break;
- default:
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->priv_key_data_size, NULL, NULL);
- memcpy(l_data, a_key->priv_key_data, a_key->priv_key_data_size);
- if(a_buflen_out)
- *a_buflen_out = a_key->priv_key_data_size;
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ if (!s_callbacks[a_key->type].ser_priv_key) {
+ log_it(L_ERROR, "No callback for private key serialize to %s enc key", dap_enc_get_type_name(a_key->type));
+ return NULL;
+ }
+ l_data = s_callbacks[a_key->type].ser_priv_key(a_key->priv_key_data, a_buflen_out);
+ break;
+ default:
+ DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->priv_key_data_size, NULL, NULL);
+ memcpy(l_data, a_key->priv_key_data, a_key->priv_key_data_size);
+ if(a_buflen_out)
+ *a_buflen_out = a_key->priv_key_data_size;
}
return l_data;
}
@@ -707,21 +718,23 @@ uint8_t* dap_enc_key_serialize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_ou
// func work
uint8_t *l_data = NULL;
switch (a_key->type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- l_data = s_callbacks[a_key->type].ser_pub_key(a_key->pub_key_data, a_buflen_out);
- break;
- case DAP_ENC_KEY_TYPE_SIG_ECDSA:
- l_data = s_callbacks[a_key->type].ser_pub_key(a_key, a_buflen_out);
- break;
- default:
- DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->pub_key_data_size, NULL, NULL);
- memcpy(l_data, a_key->pub_key_data, a_key->pub_key_data_size);
- if(a_buflen_out)
- *a_buflen_out = a_key->pub_key_data_size;
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ if (!s_callbacks[a_key->type].ser_pub_key) {
+ log_it(L_ERROR, "No callback for public key serialize to %s enc key", dap_enc_get_type_name(a_key->type));
+ return NULL;
+ }
+ l_data = s_callbacks[a_key->type].ser_pub_key(a_key->pub_key_data, a_buflen_out);
+ break;
+ default:
+ DAP_NEW_Z_SIZE_RET_VAL(l_data, uint8_t, a_key->pub_key_data_size, NULL, NULL);
+ memcpy(l_data, a_key->pub_key_data, a_key->pub_key_data_size);
+ if(a_buflen_out)
+ *a_buflen_out = a_key->pub_key_data_size;
}
return l_data;
}
@@ -739,28 +752,43 @@ int dap_enc_key_deserialize_priv_key(dap_enc_key_t *a_key, const uint8_t *a_buf,
dap_return_val_if_pass(!a_key || !a_buf, -1);
// func work
switch (a_key->type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- if (a_key->priv_key_data)
- s_callbacks[a_key->type].del_priv_key(a_key->priv_key_data);
- a_key->priv_key_data = s_callbacks[a_key->type].deser_priv_key(a_buf, a_buflen);
- if(!a_key->priv_key_data) {
- a_key->priv_key_data_size = 0;
- return -2;
- }
- a_key->priv_key_data_size = s_callbacks[a_key->type].deser_priv_key_size(NULL);
- break;
- default:
- DAP_DEL_Z(a_key->priv_key_data);
- a_key->priv_key_data_size = a_buflen;
- DAP_NEW_Z_SIZE_RET_VAL(a_key->priv_key_data, uint8_t, a_key->priv_key_data_size, -1, NULL);
- memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
- dap_enc_key_update(a_key);
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ if (!s_callbacks[a_key->type].deser_priv_key) {
+ log_it(L_ERROR, "No callback for private key deserialize to %s enc key", dap_enc_get_type_name(a_key->type));
+ return -2;
+ }
+ if (a_key->priv_key_data) {
+ if (!s_callbacks[a_key->type].del_priv_key) {
+ log_it(L_WARNING, "No callback for private key delete to %s enc key. LEAKS CAUTION!", dap_enc_get_type_name(a_key->type));
+ DAP_DELETE(a_key->priv_key_data);
+ } else {
+ s_callbacks[a_key->type].del_priv_key(a_key->priv_key_data);
+ }
+ }
+ a_key->priv_key_data = s_callbacks[a_key->type].deser_priv_key(a_buf, a_buflen);
+ if(!a_key->priv_key_data) {
+ a_key->priv_key_data_size = 0;
+ return -3;
+ }
+ if (!s_callbacks[a_key->type].deser_priv_key_size) {
+ log_it(L_DEBUG, "No callback for private key deserialize size calc to %s enc key", dap_enc_get_type_name(a_key->type));
+ a_key->priv_key_data_size = a_buflen;
+ } else {
+ a_key->priv_key_data_size = s_callbacks[a_key->type].deser_priv_key_size(NULL);
+ }
+ break;
+ default:
+ DAP_DEL_Z(a_key->priv_key_data);
+ a_key->priv_key_data_size = a_buflen;
+ DAP_NEW_Z_SIZE_RET_VAL(a_key->priv_key_data, uint8_t, a_key->priv_key_data_size, -4, NULL);
+ memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
}
+ dap_enc_key_update(a_key);
return 0;
}
@@ -769,7 +797,7 @@ int dap_enc_key_deserialize_priv_key(dap_enc_key_t *a_key, const uint8_t *a_buf,
* @param a_key
* @param a_buf
* @param a_buflen_out
- * @return 0 Ok, -1 error
+ * @return 0 Ok, other error
*/
int dap_enc_key_deserialize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen)
{
@@ -777,38 +805,45 @@ int dap_enc_key_deserialize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf,
dap_return_val_if_pass(!a_key || !a_buf, -1);
// func work
switch (a_key->type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- if(s_callbacks[a_key->type].del_pub_key == NULL || s_callbacks[a_key->type].deser_pub_key == NULL)
- return -2;
-
- if (a_key->pub_key_data)
- s_callbacks[a_key->type].del_pub_key(a_key->pub_key_data);
-
- a_key->pub_key_data = s_callbacks[a_key->type].deser_pub_key(a_buf, a_buflen);
- if(!a_key->pub_key_data) {
- a_key->pub_key_data_size = 0;
- return -1;
- }
- a_key->pub_key_data_size = s_callbacks[a_key->type].deser_pub_key_size(NULL);
- break;
- case DAP_ENC_KEY_TYPE_SIG_ECDSA:
- if(s_callbacks[a_key->type].del_pub_key == NULL)
- return -2;
- s_callbacks[a_key->type].del_pub_key(a_key->pub_key_data);
- a_key->pub_key_data = s_callbacks[a_key->type].deser_pub_key_ex(a_buf, a_key, a_buflen);
- break;
- default:
- DAP_DEL_Z(a_key->pub_key_data);
- a_key->pub_key_data_size = a_buflen;
- DAP_NEW_Z_SIZE_RET_VAL(a_key->pub_key_data, uint8_t, a_key->pub_key_data_size, -1, NULL);
- memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
- dap_enc_key_update(a_key);
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA:
+ //case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ if (!s_callbacks[a_key->type].deser_pub_key) {
+ log_it(L_ERROR, "No callback for public key deserialize to %s enc key", dap_enc_get_type_name(a_key->type));
+ return -2;
+ }
+
+ if (a_key->pub_key_data) {
+ if (!s_callbacks[a_key->type].del_pub_key) {
+ log_it(L_WARNING, "No callback for public key delete to %s enc key. LEAKS CAUTION!", dap_enc_get_type_name(a_key->type));
+ DAP_DELETE(a_key->pub_key_data);
+ } else {
+ s_callbacks[a_key->type].del_pub_key(a_key->pub_key_data);
+ }
+ }
+ a_key->pub_key_data = s_callbacks[a_key->type].deser_pub_key(a_buf, a_buflen);
+ if(!a_key->pub_key_data) {
+ a_key->pub_key_data_size = 0;
+ return -3;
+ }
+ if (!s_callbacks[a_key->type].deser_pub_key_size) {
+ log_it(L_DEBUG, "No callback for public key deserialize size calc to %s enc key", dap_enc_get_type_name(a_key->type));
+ a_key->pub_key_data_size = a_buflen;
+ } else {
+ a_key->pub_key_data_size = s_callbacks[a_key->type].deser_pub_key_size(NULL);
+ }
+ break;
+ default:
+ DAP_DEL_Z(a_key->pub_key_data);
+ a_key->pub_key_data_size = a_buflen;
+ DAP_NEW_Z_SIZE_RET_VAL(a_key->pub_key_data, uint8_t, a_key->pub_key_data_size, -1, NULL);
+ memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
}
+ dap_enc_key_update(a_key);
return 0;
}
@@ -993,7 +1028,7 @@ size_t dap_enc_ser_priv_key_size (dap_enc_key_t *a_key)
if(s_callbacks[a_key->type].ser_priv_key_size) {
return s_callbacks[a_key->type].ser_priv_key_size(a_key->priv_key_data);
}
- log_it(L_WARNING, "No callback for key private size calculate");
+ log_it(L_WARNING, "No callback for private key size calculate to %s enc key", dap_enc_get_type_name(a_key->type));
return a_key->priv_key_data_size;
}
@@ -1010,7 +1045,7 @@ size_t dap_enc_ser_pub_key_size(dap_enc_key_t *a_key)
if(s_callbacks[a_key->type].ser_pub_key_size) {
return s_callbacks[a_key->type].ser_pub_key_size(a_key->priv_key_data);
}
- log_it(L_WARNING, "No callback for key public size calculate");
+ log_it(L_WARNING, "No callback for public key size calculate to %s enc key", dap_enc_get_type_name(a_key->type));
return a_key->pub_key_data_size;
}
@@ -1022,7 +1057,7 @@ int dap_enc_gen_key_public(dap_enc_key_t *a_key, void *a_output)
if(s_callbacks[a_key->type].gen_key_public) {
return s_callbacks[a_key->type].gen_key_public(a_key, a_output);
}
- log_it(L_ERROR, "No callback for key public generate action");
+ log_it(L_ERROR, "No callback for key public generate action to %s enc key", dap_enc_get_type_name(a_key->type));
return -2;
}
@@ -1037,17 +1072,21 @@ void dap_enc_key_signature_delete(dap_enc_key_type_t a_key_type, uint8_t *a_sig_
dap_return_if_pass(DAP_ENC_KEY_TYPE_INVALID == a_key_type || !a_sig_buf);
// func work
switch (a_key_type) {
- case DAP_ENC_KEY_TYPE_SIG_BLISS:
- case DAP_ENC_KEY_TYPE_SIG_TESLA:
- case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
- case DAP_ENC_KEY_TYPE_SIG_FALCON:
- case DAP_ENC_KEY_TYPE_SIG_ECDSA:
- case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
- case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
- s_callbacks[a_key_type].del_sign(a_sig_buf);
- break;
- default:
- break;
+ case DAP_ENC_KEY_TYPE_SIG_BLISS:
+ case DAP_ENC_KEY_TYPE_SIG_TESLA:
+ case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
+ case DAP_ENC_KEY_TYPE_SIG_FALCON:
+ case DAP_ENC_KEY_TYPE_SIG_ECDSA:
+ case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
+ case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
+ if (!s_callbacks[a_key_type].del_sign) {
+ log_it(L_WARNING, "No callback for signature delete to %s enc key. LEAKS CAUTION!", dap_enc_get_type_name(a_key_type));
+ break;
+ }
+ s_callbacks[a_key_type].del_sign(a_sig_buf);
+ break;
+ default:
+ break;
}
DAP_DEL_Z(a_sig_buf);
}
@@ -1064,10 +1103,10 @@ void dap_enc_key_delete(dap_enc_key_t * a_key)
if(s_callbacks[a_key->type].delete_callback) {
s_callbacks[a_key->type].delete_callback(a_key);
} else {
- log_it(L_ERROR, "delete callback is null. Can be leak memory!");
+ log_it(L_WARNING, "No callback for key delete to %s enc key. LEAKS CAUTION!", dap_enc_get_type_name(a_key->type));
+ DAP_DEL_MULTY(a_key->pub_key_data, a_key->priv_key_data, a_key->_inheritor, a_key->pbk_list_data, a_key);
}
- /* a_key->_inheritor must be cleaned in delete_callback func */
- DAP_DEL_MULTY(a_key->pub_key_data, a_key->priv_key_data, a_key);
+ DAP_DELETE(a_key);
}
/**
@@ -1076,15 +1115,12 @@ void dap_enc_key_delete(dap_enc_key_t * a_key)
* @param a_buf_in_size in buf size to calc
* @return calced size or 0
*/
-size_t dap_enc_key_get_enc_size(dap_enc_key_t *a_key, const size_t a_buf_in_size)
+size_t dap_enc_key_get_enc_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size)
{
-// sanity check
- dap_return_val_if_pass(!a_key, 0);
-// func work
- if(s_callbacks[a_key->type].enc_out_size) {
- return s_callbacks[a_key->type].enc_out_size(a_buf_in_size);
+ if(s_callbacks[a_key_type].enc_out_size) {
+ return s_callbacks[a_key_type].enc_out_size(a_buf_in_size);
}
- log_it(L_ERROR, "enc_out_size not realize for current key type");
+ log_it(L_ERROR, "No callback for enc_out_size to %s enc key", dap_enc_get_type_name(a_key_type));
return 0;
}
@@ -1094,15 +1130,12 @@ size_t dap_enc_key_get_enc_size(dap_enc_key_t *a_key, const size_t a_buf_in_size
* @param a_buf_in_size in buf size to calc
* @return calced size or 0
*/
-size_t dap_enc_key_get_dec_size(dap_enc_key_t *a_key, const size_t a_buf_in_size)
+size_t dap_enc_key_get_dec_size(dap_enc_key_type_t a_key_type, const size_t a_buf_in_size)
{
-// sanity check
- dap_return_val_if_pass(!a_key, 0);
-// func work
- if(s_callbacks[a_key->type].dec_out_size) {
- return s_callbacks[a_key->type].dec_out_size(a_buf_in_size);
+ if(s_callbacks[a_key_type].dec_out_size) {
+ return s_callbacks[a_key_type].dec_out_size(a_buf_in_size);
}
- log_it(L_ERROR, "dec_out_size not realize for current key type");
+ log_it(L_ERROR, "No callback for dec_out_size to %s enc key", dap_enc_get_type_name(a_key_type));
return 0;
}
@@ -1113,8 +1146,8 @@ const char *dap_enc_get_type_name(dap_enc_key_type_t a_key_type)
return s_callbacks[a_key_type].name;
}
}
- log_it(L_WARNING, "name was not set for key type %d", a_key_type);
- return 0;
+ log_it(L_WARNING, "Name was not set for key type %d", a_key_type);
+ return "UNDEFINED";
}
dap_enc_key_type_t dap_enc_key_type_find_by_name(const char * a_name){
@@ -1123,7 +1156,7 @@ dap_enc_key_type_t dap_enc_key_type_find_by_name(const char * a_name){
if(l_current_key_name && !strcmp(a_name, l_current_key_name))
return i;
}
- log_it(L_WARNING, "no key type with name %s", a_name);
+ log_it(L_WARNING, "No key type with name %s", a_name);
return DAP_ENC_KEY_TYPE_INVALID;
}
@@ -1132,7 +1165,6 @@ size_t dap_enc_calc_signature_unserialized_size(dap_enc_key_t *a_key)
{
// sanity check
dap_return_val_if_pass(!a_key, 0);
- size_t l_sign_size = 0;
switch (a_key->type){
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
case DAP_ENC_KEY_TYPE_SIG_BLISS:
@@ -1143,14 +1175,19 @@ size_t dap_enc_calc_signature_unserialized_size(dap_enc_key_t *a_key)
case DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK:
case DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS:
case DAP_ENC_KEY_TYPE_SIG_MULTI_CHAINED:
- l_sign_size = s_callbacks[a_key->type].deser_sign_size(a_key);
- break;
+ if (!s_callbacks[a_key->type].deser_sign_size) {
+ log_it(L_ERROR, "No callback for signature deserialize size calc to %s enc key", dap_enc_get_type_name(a_key->type));
+ break;
+ }
+ return s_callbacks[a_key->type].deser_sign_size(a_key);
#ifdef DAP_PQRL
- case DAP_ENC_KEY_TYPE_SIG_PQLR_DILITHIUM: l_sign_size = dap_pqlr_dilithium_calc_signature_size(a_key); break;
+ case DAP_ENC_KEY_TYPE_SIG_PQLR_DILITHIUM: return dap_pqlr_dilithium_calc_signature_size(a_key); break;
#endif
- default : return 0;
+ default :
+ log_it(L_ERROR, "Can't signature deserialize size calc to %s enc key", dap_enc_get_type_name(a_key->type));
+ return 0;
}
- return l_sign_size;
+ return 0;
}
/**
diff --git a/crypto/src/dap_enc_kyber.c b/crypto/src/dap_enc_kyber.c
index de7aba71b6524443722cc7cf8711805668fc5410..6263463d6ed49e2cbdeed17959ebec3ee389033d 100644
--- a/crypto/src/dap_enc_kyber.c
+++ b/crypto/src/dap_enc_kyber.c
@@ -73,7 +73,11 @@ void dap_enc_kyber512_key_generate(dap_enc_key_t *a_key, UNUSED_ARG const void *
void dap_enc_kyber512_key_delete(dap_enc_key_t *a_key)
{
dap_return_if_pass(!a_key);
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
DAP_DEL_Z(a_key->_inheritor);
+ a_key->priv_key_data_size = 0;
+ a_key->pub_key_data_size = 0;
a_key->_inheritor_size = 0;
}
diff --git a/crypto/src/dap_enc_msrln.c b/crypto/src/dap_enc_msrln.c
index a8aef5daa6875e0ddf529d439addb923c4846373..037b25d6aa0c975cf070512ce55a9f6ed2e57406 100755
--- a/crypto/src/dap_enc_msrln.c
+++ b/crypto/src/dap_enc_msrln.c
@@ -161,6 +161,10 @@ void dap_enc_msrln_key_new_from_data_public(UNUSED_ARG dap_enc_key_t *a_key, UNU
void dap_enc_msrln_key_delete(dap_enc_key_t *a_key)
{
dap_return_if_pass(!a_key);
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
+ a_key->priv_key_data_size = 0;
+ a_key->pub_key_data_size = 0;
}
/**
diff --git a/crypto/src/dap_enc_newhope.c b/crypto/src/dap_enc_newhope.c
index c3fc433f4d2a3737174ac96e69edfe5d85a88a00..f9aa999a2db6b4a6d1a6931b0bdc55c4518a5cbe 100644
--- a/crypto/src/dap_enc_newhope.c
+++ b/crypto/src/dap_enc_newhope.c
@@ -148,7 +148,11 @@ size_t dap_enc_newhope_gen_alice_shared_key(dap_enc_key_t *a_alice_key, UNUSED_A
void dap_enc_newhope_kem_key_delete(dap_enc_key_t *a_key)
{
dap_return_if_pass(!a_key);
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
DAP_DEL_Z(a_key->_inheritor);
- a_key->_inheritor_size= 0;
+ a_key->priv_key_data_size = 0;
+ a_key->pub_key_data_size = 0;
+ a_key->_inheritor_size = 0;
}
diff --git a/crypto/src/dap_enc_oaes.c b/crypto/src/dap_enc_oaes.c
index c7e8e3a57a9fc55785f4d6f48d3fb558e4141622..f96be26b1e8d3ccf91f7737c0a7947fb0bb24d34 100755
--- a/crypto/src/dap_enc_oaes.c
+++ b/crypto/src/dap_enc_oaes.c
@@ -38,6 +38,7 @@ void dap_enc_oaes_key_delete(struct dap_enc_key *a_key)
if(ctx) {
oaes_free(&ctx); // free(a_key->_inheritor);
a_key->_inheritor_size = 0;
+ a_key->_inheritor = NULL;
}
}
diff --git a/crypto/src/dap_enc_picnic.c b/crypto/src/dap_enc_picnic.c
index b4e71de2b89c2d65902e04ca7afc60ef3df32ee1..0c3e894bc49b974e245a03a44769de373e81439b 100755
--- a/crypto/src/dap_enc_picnic.c
+++ b/crypto/src/dap_enc_picnic.c
@@ -61,14 +61,12 @@ void dap_enc_sig_picnic_key_new(dap_enc_key_t *key) {
void dap_enc_sig_picnic_key_delete(dap_enc_key_t *key)
{
- if(key->_inheritor_size > 0)
- free(key->_inheritor);
- key->_inheritor = NULL;
- key->_inheritor_size = 0;
- // free memory will be in dap_enc_key_delete()
- //picnic_keypair_delete((picnic_privatekey_t*) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data);
+ DAP_DEL_Z(key->priv_key_data);
+ DAP_DEL_Z(key->pub_key_data);
+ DAP_DEL_Z(key->_inheritor);
key->priv_key_data_size = 0;
key->pub_key_data_size = 0;
+ key->_inheritor_size = 0;
}
void dap_enc_sig_picnic_update(dap_enc_key_t *a_key)
diff --git a/crypto/src/dap_enc_ringct20.c b/crypto/src/dap_enc_ringct20.c
index 8b89dec35d50b4506dfd81330b56705dd4fa18ea..3b4ffede2592e63b95eb44fd1e3468d7c46369ca 100644
--- a/crypto/src/dap_enc_ringct20.c
+++ b/crypto/src/dap_enc_ringct20.c
@@ -202,7 +202,7 @@ return 0;
size_t CRUTCH_gen_pbk_list(const ringct20_param_t *p, void **pbklist, const int pbknum)
{
size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
- size_t pbklistsize = size_pbkkey*pbknum;
+ size_t pbk_list_size = size_pbkkey*pbknum;
//get a list of some pbk
{
poly_ringct20 pbk_poly;
@@ -217,7 +217,7 @@ size_t CRUTCH_gen_pbk_list(const ringct20_param_t *p, void **pbklist, const int
}
free(Stmp);
}
- return pbklistsize;
+ return pbk_list_size;
}
int CRUTCH_get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi, const int wLen)
{
@@ -564,17 +564,17 @@ void dap_enc_sig_ringct20_key_new(struct dap_enc_key *key) {
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_get_sign_with_pb_list;//dap_enc_sig_ringct20_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_verify_sign;
key->dec_na_ext = (dap_enc_callback_dataop_na_ext_t) dap_enc_sig_ringct20_verify_sign_with_pbk_list;//dap_enc_sig_ringct20_verify_sign;
- key->getallpbkList = (dap_enc_get_allpbk_list) dap_enc_sig_ringct20_getallpbk;
- key->pbkListsize = 0;
- key->pbkListdata = NULL;
+ key->get_all_pbk_list = (dap_enc_get_allpbk_list) dap_enc_sig_ringct20_getallpbk;
+ key->pbk_list_size = 0;
+ key->pbk_list_data = NULL;
}
size_t dap_enc_sig_ringct20_getallpbk(dap_enc_key_t *key, const void *allpbk_list, const int allpbk_list_size)
{
- key->pbkListdata = DAP_NEW_SIZE(uint8_t, allpbk_list_size);
- memcpy(key->pbkListdata, allpbk_list, allpbk_list_size);
- key->pbkListsize= allpbk_list_size;
+ key->pbk_list_data = DAP_NEW_SIZE(uint8_t, allpbk_list_size);
+ memcpy(key->pbk_list_data, allpbk_list, allpbk_list_size);
+ key->pbk_list_size= allpbk_list_size;
return 0;
}
@@ -637,7 +637,7 @@ int ringct20_crypto_sign_with_pbk_list( ringct20_signature_t *sig, const unsigne
}
if(filled_pbk_num < wLen)
{
- log_it(L_ERROR, "RINGCT20: not enough pbkeys use CRUTCH_gen_pbk_list and key->getallpbkList");
+ log_it(L_ERROR, "RINGCT20: not enough pbkeys use CRUTCH_gen_pbk_list and key->get_all_pbk_list");
DAP_DELETE(aList);
DAP_DELETE(S);
return -1;
@@ -699,7 +699,7 @@ size_t dap_enc_sig_ringct20_get_sign_with_pb_list(struct dap_enc_key * a_key, co
return 0;
}
- if(!ringct20_crypto_sign_with_pbk_list((ringct20_signature_t *) signature, (const unsigned char *) msg, msg_size, a_key->priv_key_data, a_key->pbkListdata, a_key->pbkListsize))
+ if(!ringct20_crypto_sign_with_pbk_list((ringct20_signature_t *) signature, (const unsigned char *) msg, msg_size, a_key->priv_key_data, a_key->pbk_list_data, a_key->pbk_list_size))
return signature_size;
else
return 0;
@@ -744,13 +744,14 @@ size_t dap_enc_sig_ringct20_verify_sign_with_pbk_list(struct dap_enc_key * a_key
void dap_enc_sig_ringct20_key_delete(struct dap_enc_key * a_key)
{
- if(a_key->pbkListsize)
- {
- DAP_DELETE(a_key->pbkListdata);
- a_key->pbkListsize = 0;
- }
ringct20_private_and_public_keys_delete((ringct20_private_key_t *) a_key->priv_key_data,
(ringct20_public_key_t *) a_key->pub_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->pub_key_data);
+ DAP_DEL_Z(a_key->pbk_list_data);
+ a_key->priv_key_data_size = 0;
+ a_key->pub_key_data_size = 0;
+ a_key->pbk_list_size = 0;
}
size_t dap_enc_ringct20_calc_signature_size(void)
diff --git a/crypto/src/dap_enc_salsa2012.c b/crypto/src/dap_enc_salsa2012.c
index 23c101faa037fb6a72c867143bfea3ec2daae20d..aea7bd457b28e841e525eb0c27dda8730912b561 100644
--- a/crypto/src/dap_enc_salsa2012.c
+++ b/crypto/src/dap_enc_salsa2012.c
@@ -53,12 +53,12 @@ void dap_enc_salsa2012_key_generate(struct dap_enc_key * a_key, const void *kex_
*/
void dap_enc_salsa2012_key_delete(struct dap_enc_key *a_key)
{
- if(a_key->priv_key_data != NULL)
+ if(a_key->priv_key_data)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
- //DAP_DELETE(a_key->priv_key_data);
+ DAP_DEL_Z(a_key->priv_key_data);
}
- //a_key->priv_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
//------SALSA2012-----------
diff --git a/crypto/src/dap_enc_shipovnik.c b/crypto/src/dap_enc_shipovnik.c
index eb424f2e9f917741e63f0d0da3f6fbe7995ed36a..00b952fff9af2259e2d05fa89aa6c4604784d581 100644
--- a/crypto/src/dap_enc_shipovnik.c
+++ b/crypto/src/dap_enc_shipovnik.c
@@ -65,16 +65,22 @@ void dap_enc_sig_shipovnik_signature_delete(void *a_sig){
void dap_enc_sig_shipovnik_private_key_delete(void* privateKey) {
dap_return_if_fail(!!privateKey);
memset_safe((uint8_t*)privateKey, 0, SHIPOVNIK_SECRETKEYBYTES);
+ DAP_DELETE(privateKey);
}
void dap_enc_sig_shipovnik_public_key_delete(void* publicKey) {
dap_return_if_fail(!!publicKey);
memset_safe((uint8_t*)publicKey, 0, SHIPOVNIK_PUBLICKEYBYTES);
+ DAP_DELETE(publicKey);
}
void dap_enc_sig_shipovnik_private_and_public_keys_delete(dap_enc_key_t *a_key) {
dap_enc_sig_shipovnik_private_key_delete(a_key->priv_key_data);
dap_enc_sig_shipovnik_public_key_delete(a_key->pub_key_data);
+ a_key->priv_key_data = NULL;
+ a_key->pub_key_data = NULL;
+ a_key->priv_key_data_size = 0;
+ a_key->pub_key_data_size = 0;
}
diff --git a/crypto/src/dap_enc_sphincsplus.c b/crypto/src/dap_enc_sphincsplus.c
index fae53738624b852c2c78701b1c4ad8e91bf0bdb2..bb72fce10e64b0e6a075581f08cfe7b8797bf2e1 100644
--- a/crypto/src/dap_enc_sphincsplus.c
+++ b/crypto/src/dap_enc_sphincsplus.c
@@ -183,6 +183,8 @@ void dap_enc_sig_sphincsplus_key_delete(dap_enc_key_t *a_key)
a_key->pub_key_data = NULL;
a_key->priv_key_data = NULL;
+ a_key->pub_key_data_size = 0;
+ a_key->priv_key_data_size = 0;
}
/* Serialize a private key. */
diff --git a/crypto/src/dap_enc_tesla.c b/crypto/src/dap_enc_tesla.c
index 83bf1c512e2b3f803b9bb34436998caef19b3565..4f5a1318a19239cb06f49512b189e296132ba500 100755
--- a/crypto/src/dap_enc_tesla.c
+++ b/crypto/src/dap_enc_tesla.c
@@ -97,6 +97,8 @@ void dap_enc_sig_tesla_key_delete(dap_enc_key_t *key)
tesla_private_and_public_keys_delete(key->priv_key_data, key->pub_key_data);
key->priv_key_data = NULL;
key->pub_key_data = NULL;
+ key->priv_key_data_size = 0;
+ key->pub_key_data_size = 0;
}
/* Serialize a signature */
diff --git a/crypto/src/dap_sign.c b/crypto/src/dap_sign.c
index 5be93fe47f59c68671d89ba4f938bc9fa9a06231..11501a8b9649b4da2a2a72c1fa886a82b492b781 100755
--- a/crypto/src/dap_sign.c
+++ b/crypto/src/dap_sign.c
@@ -247,7 +247,7 @@ dap_sign_t * dap_sign_create(dap_enc_key_t *a_key, const void * a_data,
return NULL;
} else {
size_t l_sign_ser_size = l_sign_unserialized_size;
- uint8_t *l_sign_ser = dap_enc_key_serialize_sign(a_key, l_sign_unserialized, &l_sign_ser_size);
+ uint8_t *l_sign_ser = dap_enc_key_serialize_sign(a_key->type, l_sign_unserialized, &l_sign_ser_size);
if ( l_sign_ser ){
dap_sign_t *l_ret = NULL;
DAP_NEW_Z_SIZE_RET_VAL(l_ret, dap_sign_t, sizeof(dap_sign_hdr_t) + l_sign_ser_size + l_pub_key_size, NULL, l_sign_unserialized, l_pub_key, l_sign_ser);
@@ -373,7 +373,10 @@ dap_enc_key_t *dap_sign_to_enc_key(dap_sign_t * a_chain_sign)
uint8_t *l_pkey = dap_sign_get_pkey(a_chain_sign, &l_pkey_size);
dap_enc_key_t * l_ret = dap_enc_key_new(l_type);
// deserialize public key
- dap_enc_key_deserialize_pub_key(l_ret, l_pkey, l_pkey_size);
+ if (dap_enc_key_deserialize_pub_key(l_ret, l_pkey, l_pkey_size)) {
+ log_it(L_ERROR, "Error in enc pub key deserialize");
+ DAP_DEL_Z(l_ret);
+ }
return l_ret;
}
@@ -404,7 +407,7 @@ int dap_sign_verify(dap_sign_t *a_chain_sign, const void *a_data, const size_t a
size_t l_sign_data_size = a_chain_sign->header.sign_size;
// deserialize signature
- uint8_t *l_sign_data = dap_enc_key_deserialize_sign(l_key, l_sign_data_ser, &l_sign_data_size);
+ uint8_t *l_sign_data = dap_enc_key_deserialize_sign(l_key->type, l_sign_data_ser, &l_sign_data_size);
if ( !l_sign_data ){
log_it(L_WARNING,"Incorrect signature, can't deserialize signature's data");
diff --git a/crypto/test/crypto/dap_enc_benchmark_test.c b/crypto/test/crypto/dap_enc_benchmark_test.c
index ee17257ac1f4069550763c91c8e86de82155dc92..7ce2e6af6466f4a2ef7e8c3cfa1b259a65ac74f9 100644
--- a/crypto/test/crypto/dap_enc_benchmark_test.c
+++ b/crypto/test/crypto/dap_enc_benchmark_test.c
@@ -16,7 +16,7 @@ dap_enc_key_type_t s_key_type_arr[] = {
// DAP_ENC_KEY_TYPE_SIG_PICNIC,
DAP_ENC_KEY_TYPE_SIG_FALCON,
DAP_ENC_KEY_TYPE_SIG_SPHINCSPLUS,
-#ifdef DAP_TPS_TEST
+#ifdef DAP_ECDSA
DAP_ENC_KEY_TYPE_SIG_ECDSA,
#endif
DAP_ENC_KEY_TYPE_SIG_SHIPOVNIK };
@@ -276,7 +276,7 @@ static int s_sign_verify_tests_run(int 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_TPS_TEST
+#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);
diff --git a/crypto/test/crypto/dap_enc_ringct20_test.c b/crypto/test/crypto/dap_enc_ringct20_test.c
index ddd1fd3908664215031a3bbf5b912caab5913a71..2894fdd0201595929fe386eb59c45d402d30e004 100644
--- a/crypto/test/crypto/dap_enc_ringct20_test.c
+++ b/crypto/test/crypto/dap_enc_ringct20_test.c
@@ -423,7 +423,7 @@ static void test_signing_verifying2(void)
}
size_t allpbk_size = CRUTCH_gen_pbk_list(p, &allpbk_buf, allpbknum);
- key->getallpbkList(key, allpbk_buf,allpbk_size);
+ key->get_all_pbk_list(key, allpbk_buf,allpbk_size);
size_t max_signature_size = dap_enc_ringct20_calc_signature_size();
uint8_t* sig = calloc(max_signature_size, 1);
diff --git a/crypto/test/crypto/dap_enc_test.c b/crypto/test/crypto/dap_enc_test.c
index fa9a9433cf1de5516446f8717dd6940171824140..29af80450d2a43d838c306130cc63d1e4ae26acf 100755
--- a/crypto/test/crypto/dap_enc_test.c
+++ b/crypto/test/crypto/dap_enc_test.c
@@ -330,8 +330,8 @@ static void test_serialize_deserialize_pub_priv(dap_enc_key_type_t key_type)
// create new key2
dap_enc_key_t *key2 = dap_enc_key_new(key_type);
// Deserialize key2
- dap_enc_key_deserialize_pub_key(key2, l_data_pub_read, l_data_pub_size);
- dap_enc_key_deserialize_priv_key(key2, l_data_priv_read, l_data_priv_size);
+ dap_assert(!dap_enc_key_deserialize_pub_key(key2, l_data_pub_read, l_data_pub_size), "Pub key deserialize");
+ dap_assert(!dap_enc_key_deserialize_priv_key(key2, l_data_priv_read, l_data_priv_size), "Priv key deserialize");
DAP_DEL_MULTY(l_data_pub, l_data_pub_read, l_data_priv, l_data_priv_read);
@@ -369,9 +369,9 @@ static void test_serialize_deserialize_pub_priv(dap_enc_key_type_t key_type)
// serialize & deserialize signature
size_t sig_buf_len = sig_buf_size;
- uint8_t *l_sign_tmp = dap_enc_key_serialize_sign(key2, sig_buf, &sig_buf_len);
+ uint8_t *l_sign_tmp = dap_enc_key_serialize_sign(key2->type, sig_buf, &sig_buf_len);
dap_enc_key_signature_delete(key_type, sig_buf);
- sig_buf = dap_enc_key_deserialize_sign(key2, l_sign_tmp, &sig_buf_len);
+ sig_buf = dap_enc_key_deserialize_sign(key2->type, l_sign_tmp, &sig_buf_len);
DAP_DELETE(l_sign_tmp);
dap_assert_PIF(sig_buf, "Check serialize->deserialize signature");
@@ -420,7 +420,7 @@ void dap_enc_tests_run() {
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_TPS_TEST
+#ifdef DAP_ECDSA
dap_print_module_name("dap_enc serialize->deserialize ECDSA");
test_serialize_deserialize(DAP_ENC_KEY_TYPE_SIG_ECDSA, false);
#endif
@@ -443,7 +443,7 @@ void dap_enc_tests_run() {
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_TPS_TEST
+#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
diff --git a/global-db/dap_global_db.c b/global-db/dap_global_db.c
index 15ed9304c10670af4d83885454e193f3d0acff07..604aa1f4c8a02197cd20eef2c9969ba3d2143814 100644
--- a/global-db/dap_global_db.c
+++ b/global-db/dap_global_db.c
@@ -1169,6 +1169,7 @@ int dap_global_db_set_multiple_zc(const char *a_group, dap_global_db_obj_t *a_va
return DAP_GLOBAL_DB_RC_CRITICAL;
}
l_msg->values = a_values;
+ l_msg->value_is_pinned = false;
l_msg->values_count = a_values_count;
l_msg->callback_arg = a_arg;
l_msg->callback_results = a_callback;
@@ -1190,19 +1191,12 @@ int dap_global_db_set_multiple_zc(const char *a_group, dap_global_db_obj_t *a_va
*/
static void s_msg_opcode_set_multiple_zc(struct queue_io_msg * a_msg)
{
- int l_ret = -1;
+ int l_ret = 0;
size_t i=0;
if(a_msg->values_count>0) {
dap_store_obj_t l_store_obj = {};
- l_ret = 0;
for(; i < a_msg->values_count && l_ret == 0 ; i++ ) {
- l_store_obj.flags = a_msg->values[i].is_pinned ? DAP_GLOBAL_DB_RECORD_PINNED : 0;
- l_store_obj.key = a_msg->values[i].key;
- l_store_obj.group = a_msg->group;
- l_store_obj.value = a_msg->values[i].value;
- l_store_obj.value_len = a_msg->values[i].value_len;
- l_store_obj.timestamp = a_msg->values[i].timestamp;
- l_ret = s_store_obj_apply(a_msg->dbi, &l_store_obj);
+ l_ret = s_set_sync_with_ts(a_msg->dbi, a_msg->group, a_msg->values[i].key, a_msg->values[i].value, a_msg->values[i].value_len, a_msg->value_is_pinned, a_msg->values[i].timestamp);
}
}
if(a_msg->callback_results) {
diff --git a/global-db/dap_global_db_driver_sqlite.c b/global-db/dap_global_db_driver_sqlite.c
index ce7c1a1a747372661a61f447628cb40e483b8b66..f3932950df707e569e76aa80d576e6649eed09f5 100644
--- a/global-db/dap_global_db_driver_sqlite.c
+++ b/global-db/dap_global_db_driver_sqlite.c
@@ -222,8 +222,8 @@ static conn_list_item_t *s_db_sqlite_get_connection(bool a_trans)
return NULL;
}
s_db_sqlite_prepare_connection(s_conn->conn);
- log_it(L_DEBUG, "SQL connection #%d is created @%p", s_conn->idx, s_conn);
s_conn->idx = l_conn_idx++;
+ log_it(L_DEBUG, "SQL connection #%d is created @%p", s_conn->idx, s_conn);
s_conn_list = dap_list_append(s_conn_list, s_conn);
pthread_rwlock_unlock(&s_conn_list_rwlock);
}
@@ -748,9 +748,9 @@ static dap_store_obj_t* s_db_sqlite_read_store_obj(const char *a_group, const ch
// data forming
size_t l_count_out = 0;
int l_ret_code = 0;
- for (l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt);l_ret_code == SQLITE_ROW && l_count_out < l_count; ++l_count_out) {
- l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt);
- }
+ for (l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt);
+ l_ret_code == SQLITE_ROW && l_count_out < l_count;
+ ++l_count_out, l_ret_code = s_db_sqlite_fill_one_item(a_group, l_ret + l_count_out, l_stmt)) {}
if(l_ret_code != SQLITE_DONE) {
log_it(L_ERROR, "SQLite read error %d(%s)", sqlite3_errcode(l_conn->conn), sqlite3_errmsg(l_conn->conn));
}
diff --git a/global-db/test/dap_global_db_test.c b/global-db/test/dap_global_db_test.c
index f8fd213ed0be30bc71e1251ec6e9583e24c01dc5..e07a1eb34fa11c3d2609703f27370a81e5d0743f 100644
--- a/global-db/test/dap_global_db_test.c
+++ b/global-db/test/dap_global_db_test.c
@@ -42,7 +42,6 @@ typedef struct __dap_test_record__ {
#define DAP_DB$SZ_DATA 8192
#define DAP_DB$SZ_KEY 64
#define DAP_DB$SZ_HOLES 3
-#define DAP_DB$SZ_THREADS 3
#define DAP_DB$T_GROUP "group.zero"
#define DAP_DB$T_GROUP_WRONG "group.wrong"
#define DAP_DB$T_GROUP_NOT_EXISTED "group.not.existed"
@@ -589,18 +588,20 @@ void *s_test_thread(void *a_arg)
void s_test_multithread(size_t a_count)
{
- pthread_t *l_threads = DAP_NEW_Z_COUNT(pthread_t, DAP_DB$SZ_THREADS);
+ uint32_t l_thread_count = 2;
+ log_it(L_INFO, "Test with %u threads", l_thread_count);
+ pthread_t *l_threads = DAP_NEW_Z_COUNT(pthread_t, l_thread_count);
- for (size_t i = 0; i < DAP_DB$SZ_THREADS; ++i) {
+ for (uint32_t i = 0; i < l_thread_count; ++i) {
pthread_create(l_threads + i, NULL, s_test_thread_rewrite_records, &a_count);
}
- for (size_t i = 0; i < DAP_DB$SZ_THREADS; ++i) {
+ for (uint32_t i = 0; i < l_thread_count; ++i) {
pthread_join(l_threads[i], NULL);
}
- for (size_t i = 0; i < DAP_DB$SZ_THREADS; ++i) {
+ for (uint32_t i = 0; i < l_thread_count; ++i) {
pthread_create(l_threads + i, NULL, s_test_thread, &a_count);
}
- for (size_t i = 0; i < DAP_DB$SZ_THREADS; ++i) {
+ for (uint32_t i = 0; i < l_thread_count; ++i) {
pthread_join(l_threads[i], NULL);
}
DAP_DEL_Z(l_threads);
diff --git a/net/stream/stream/dap_stream_pkt.c b/net/stream/stream/dap_stream_pkt.c
index 0e1700cf0559c4865e7324a14517a22c6c8f5604..9dd55fbb20a323d89fe5bf9af3f3401c4914dffa 100644
--- a/net/stream/stream/dap_stream_pkt.c
+++ b/net/stream/stream/dap_stream_pkt.c
@@ -118,7 +118,7 @@ size_t dap_stream_pkt_write_unsafe(dap_stream_t *a_stream, uint8_t a_type, const
static _Thread_local char s_pkt_buf[DAP_STREAM_PKT_FRAGMENT_SIZE + sizeof(dap_stream_pkt_hdr_t) + 0x40] = { 0 };
a_stream->is_active = true;
dap_enc_key_t *l_key = a_stream->session->key;
- size_t l_full_size = dap_enc_key_get_enc_size(l_key, a_data_size) + sizeof(dap_stream_pkt_hdr_t);
+ size_t l_full_size = dap_enc_key_get_enc_size(l_key->type, a_data_size) + sizeof(dap_stream_pkt_hdr_t);
dap_stream_pkt_hdr_t *l_pkt_hdr = (dap_stream_pkt_hdr_t*)s_pkt_buf;
*l_pkt_hdr = (dap_stream_pkt_hdr_t) { .size = dap_enc_code( l_key, a_data, a_data_size, s_pkt_buf + sizeof(*l_pkt_hdr),
l_full_size - sizeof(*l_pkt_hdr), DAP_ENC_DATA_TYPE_RAW ),
@@ -142,7 +142,7 @@ size_t dap_stream_pkt_write_mt(dap_worker_t * a_w,dap_events_socket_uuid_t a_es_
{
#ifdef DAP_EVENTS_CAPS_IOCP
static _Thread_local char s_pkt_buf[DAP_STREAM_PKT_FRAGMENT_SIZE + sizeof(dap_stream_pkt_hdr_t) + 0x40] = { 0 };
- size_t l_full_size = dap_enc_key_get_enc_size(a_key, a_data_size) + sizeof(dap_stream_pkt_hdr_t);
+ size_t l_full_size = dap_enc_key_get_enc_size(a_key->type, a_data_size) + sizeof(dap_stream_pkt_hdr_t);
dap_stream_pkt_hdr_t *l_pkt_hdr = (dap_stream_pkt_hdr_t*)s_pkt_buf;
*l_pkt_hdr = (dap_stream_pkt_hdr_t) { .size = dap_enc_code( a_key, a_data, a_data_size, s_pkt_buf + sizeof(*l_pkt_hdr),
l_full_size - sizeof(*l_pkt_hdr), DAP_ENC_DATA_TYPE_RAW ) };