[+] Serealize->deserealize enc_key

CMakeLists.txt

@@ -6,6 +6,7 @@ add_definitions ("-D_GNU_SOURCE")
 
 set(CMAKE_C_FLAGS "-std=c11 -Wall -Wextra")
 
+add_definitions ("-DBUILD_DAP_TESTS")
 if(BUILD_DAP_TESTS)
     enable_testing()
     add_subdirectory(test)

crypto/dap_enc_iaes.c

@@ -32,6 +32,7 @@ void dap_enc_aes_key_delete(struct dap_enc_key *a_key)
 void dap_enc_aes_key_new(struct dap_enc_key * a_key)
 {
     a_key->_inheritor = DAP_NEW_Z(dap_enc_aes_key_t);
+    a_key->_inheritor_size = sizeof (dap_enc_aes_key_t);
     a_key->type = DAP_ENC_KEY_TYPE_AES;
     a_key->enc = dap_enc_iaes256_cbc_encrypt;
     a_key->dec = dap_enc_iaes256_cbc_decrypt;

crypto/dap_enc_key.c

@@ -94,6 +94,56 @@ void dap_enc_key_deinit()
 
 }
 
+/**
+ * @brief dap_enc_key_serealize
+ * @param key
+ * @return allocates dap_enc_key_serealize_t* dont remember use free()
+ */
+dap_enc_key_serealize_t* dap_enc_key_serealize(dap_enc_key_t * key)
+{
+    log_it(L_DEBUG, "serealize struct size : %d", sizeof (dap_enc_key_serealize_t));
+    dap_enc_key_serealize_t *result = DAP_NEW_Z(dap_enc_key_serealize_t);
+    result->priv_key_data_size = key->priv_key_data_size;
+    result->pub_key_data_size = key->pub_key_data_size;
+    result->last_used_timestamp = key->last_used_timestamp;
+    result->inheritor_size = key->_inheritor_size;
+    result->type = key->type;
+    memcpy(result->priv_key_data, key->priv_key_data, key->priv_key_data_size);
+    memcpy(result->pub_key_data, key->pub_key_data, key->pub_key_data_size);
+    memcpy(result->inheritor, key->_inheritor, key->_inheritor_size);
+
+    return result;
+}
+
+/**
+ * @brief dap_enc_key_deserealize
+ * @param buf
+ * @param buf_size
+ * @return allocates dap_enc_key_t*. Use dap_enc_key_delete for free memory
+ */
+dap_enc_key_t* dap_enc_key_deserealize(void *buf, size_t buf_size)
+{
+    if(buf_size != sizeof (dap_enc_key_serealize_t)) {
+        log_it(L_ERROR, "Key can't be deserealize. buf_size != sizeof (dap_enc_key_serealize_t)");
+        return NULL;
+    }
+    dap_enc_key_serealize_t *in_key = (dap_enc_key_serealize_t *)buf;
+    dap_enc_key_t *result = dap_enc_key_new(in_key->type);
+    result->last_used_timestamp = in_key->last_used_timestamp;
+    result->priv_key_data_size = in_key->priv_key_data_size;
+    result->pub_key_data_size = in_key->pub_key_data_size;
+    result->_inheritor_size = in_key->inheritor_size;
+    memcpy(result->priv_key_data, in_key->priv_key_data, result->priv_key_data_size);
+    memcpy(result->pub_key_data, in_key->pub_key_data, result->pub_key_data_size);
+
+    if(in_key->inheritor_size)
+        memcpy(result->_inheritor, in_key->inheritor, in_key->inheritor_size);
+    else
+        result->_inheritor = NULL;
+
+    return result;
+}
+
 /**
  * @brief dap_enc_key_new
  * @param a_key_type

crypto/dap_enc_key.h

@@ -116,7 +116,6 @@ typedef void (*dap_enc_callback_delete)(struct dap_enc_key*);
 typedef size_t (*dap_enc_callback_dataop_t)(struct dap_enc_key *key, const void *in,
                                             const size_t in_size,void ** out);
 
-
 typedef void (*dap_enc_callback_ptr_t)(struct dap_enc_key *, void *);
 typedef size_t (*dap_enc_callback_pptr_r_size_t)(struct dap_enc_key *, void **);
 typedef void (*dap_enc_callback_data_t)(struct dap_enc_key *, const void * , size_t);
@@ -135,12 +134,35 @@ typedef struct dap_enc_key{
     dap_enc_key_type_t type;
     dap_enc_callback_dataop_t enc;
     dap_enc_callback_dataop_t dec;
-    void * _inheritor;
+
+    void * _inheritor; // WARNING! Inheritor must have only serealizeble/deserializeble data (copy)
+    size_t _inheritor_size;
 } dap_enc_key_t;
 
+#define MAX_ENC_KEY_SIZE 16384
+#define MAX_INHERITOR_SIZE 2048
+
+// struct for serelization/deseralization keys in binary storage
+typedef struct dap_enc_key_serealize {
+    size_t priv_key_data_size;
+    size_t pub_key_data_size;
+    size_t inheritor_size;
+    time_t last_used_timestamp;
+    dap_enc_key_type_t type;
+
+    unsigned char priv_key_data[MAX_ENC_KEY_SIZE];
+    unsigned char pub_key_data[MAX_ENC_KEY_SIZE];
+    unsigned char inheritor[MAX_INHERITOR_SIZE];
+} dap_enc_key_serealize_t;
+
 int dap_enc_key_init(void);
 void dap_enc_key_deinit(void);
 
+
+dap_enc_key_serealize_t* dap_enc_key_serealize(dap_enc_key_t * key);
+dap_enc_key_t* dap_enc_key_deserealize(void *buf, size_t buf_size);
+
+// allocate memory for key struct
 dap_enc_key_t *dap_enc_key_new(dap_enc_key_type_t a_key_type);
 
 // default gen key

test/crypto/dap_enc_test.c

@@ -86,7 +86,7 @@ void test_key_transfer_msrln()
     /* generate Bob's response */
     dap_enc_key_t* bob_key = dap_enc_key_new(DAP_ENC_KEY_TYPE_MSRLN);
     bob_key->enc(bob_key, (unsigned char *) alice_msg, alice_msg_len,
-                         (void **) &bob_key->pub_key_data);
+                 (void **) &bob_key->pub_key_data);
     bob_msg = bob_key->pub_key_data;
     bob_msg_len = bob_key->pub_key_data_size;
 
@@ -112,6 +112,93 @@ static void cleanup_test_case()
     dap_enc_key_deinit();
 }
 
+#define TEST_SER_FILE_NAME "keystorage.txt"
+static void _write_key_in_file(dap_enc_key_serealize_t* key,
+                               const char* file_name)
+{
+    FILE *f = fopen(TEST_SER_FILE_NAME, "w");
+    dap_assert(f, "Can't create file");
+    fwrite(key, sizeof (dap_enc_key_serealize_t), 1, f);
+    fclose(f);
+}
+
+dap_enc_key_serealize_t* _read_key_from_file(const char* file_name)
+{
+    FILE *f = fopen(TEST_SER_FILE_NAME, "r");
+    dap_assert(f, "Can't open key file");
+    dap_enc_key_serealize_t* resut_key = calloc(1, sizeof(dap_enc_key_serealize_t));
+    fread(resut_key, sizeof(dap_enc_key_serealize_t), 1, f);
+    fclose(f);
+
+    return resut_key;
+}
+
+static void test_serealize_deserealize()
+{
+    const char *kex_data = "123";
+    size_t kex_size = strlen(kex_data);
+    const size_t seed_size = 1 + (rand() % 1000);
+    uint8_t seed[seed_size];
+
+    generate_random_byte_array(seed, seed_size);
+
+    dap_enc_key_t* key = dap_enc_key_new_generate(DAP_ENC_KEY_TYPE_AES, kex_data, kex_size, seed, seed_size, 0);
+    dap_enc_key_serealize_t* serealize_key = dap_enc_key_serealize(key);
+    _write_key_in_file(serealize_key, TEST_SER_FILE_NAME);
+    dap_enc_key_serealize_t* deserealize_key = _read_key_from_file(TEST_SER_FILE_NAME);
+    dap_assert(memcmp(serealize_key, deserealize_key, sizeof(dap_enc_key_serealize_t)) == 0,
+               "dap_enc_key_serealize_t equals");
+
+    dap_enc_key_t* key2 = dap_enc_key_deserealize(deserealize_key, sizeof (*deserealize_key));
+
+    dap_assert(key->type == key2->type, "Key type");
+    dap_assert(key->last_used_timestamp == key2->last_used_timestamp,
+               "Last used timestamp");
+    dap_assert(key->priv_key_data_size == key2->priv_key_data_size, "Priv key data size");
+    dap_assert(key->pub_key_data_size == key2->pub_key_data_size, "Pub key data size");
+
+    dap_assert(memcmp(key->priv_key_data, key2->priv_key_data, key2->priv_key_data_size) == 0,
+               "Priv key data");
+
+    if(key->pub_key_data_size) {
+        dap_assert(memcmp(key->pub_key_data, key2->pub_key_data, key2->pub_key_data_size) == 0,
+                   "Pub key data");
+    }
+    dap_assert(key->enc == key2->enc, "Enc callback");
+    dap_assert(key->dec == key2->dec, "Dec callback");
+
+    const char* source = "simple test";
+    size_t source_size = strlen(source);
+
+    uint8_t * encrypt_result = NULL;
+    uint8_t * decode_result = NULL;
+
+    size_t encrypted_size = dap_enc_code(key2, source,
+                                         source_size,
+                                         (void**)&encrypt_result,
+                                         DAP_ENC_DATA_TYPE_RAW);
+
+    size_t decode_size = dap_enc_decode(key,
+                                     encrypt_result,
+                                     encrypted_size,
+                                     (void**)&decode_result,
+                                     DAP_ENC_DATA_TYPE_RAW);
+
+    dap_assert_PIF(source_size == decode_size, "Check result decode size");
+
+    dap_assert_PIF(memcmp(source, decode_result, source_size) == 0,
+                   "Check source and encode->decode data");
+
+    free(encrypt_result);
+    free(decode_result);
+    free(serealize_key);
+    free(deserealize_key);
+    dap_enc_key_delete(key);
+    dap_enc_key_delete(key2);
+
+    dap_pass_msg("Key serealize->deserealize");
+}
+
 void dap_enc_tests_run() {
     dap_print_module_name("dap_enc");
     init_test_case();
@@ -119,5 +206,6 @@ void dap_enc_tests_run() {
     test_encode_decode_raw_b64(50);
     test_encode_decode_raw_b64_url_safe(50);
     test_key_transfer_msrln();
+    test_serealize_deserealize();
     cleanup_test_case();
 }