Merge pull request #142 from skalenetwork/SKALE-3067-cleanup3

Skale 3067 cleanup3

ECDSACrypto.cpp

@@ -67,6 +67,7 @@ vector <string> genECDSAKey() {
     vector <string> keys(3);
 
     vector<char> hexEncrKey(BUF_LEN * 2, 0);
+
     carray2Hex(encr_pr_key.data(), enc_len, hexEncrKey.data());
     keys.at(0) = hexEncrKey.data();
     keys.at(1) = string(pub_key_x.data()) + string(pub_key_y.data());

intel-sgx-ssl @ 8dc9f547

-Subproject commit f980b79f086b27b187bb696de1d7b99a0988859b
+Subproject commit 8dc9f547c612010ea0b6257d86bcbd4ff7149565

libBLS @ 78ea56c3

-Subproject commit 6c863ecc15eb5580e469f6b7f59817fdd08da1d1
+Subproject commit 78ea56c3b5251e9d840ef65705bb2c5f8f193662

linux-sgx-driver @ 95eaa6f6

-Subproject commit b0a445ba09e96e1d0507487e5c496485a9cf3742
+Subproject commit 95eaa6f6693cd86c35e10a22b4f8e483373c987c

secure_enclave/AESUtils.c

@@ -63,6 +63,16 @@ int AES_encrypt(char *message, uint8_t *encr_message, uint64_t encrLen) {
 
 int AES_decrypt(uint8_t *encr_message, uint64_t length, char *message, uint64_t msgLen) {
 
+    if (!message) {
+        LOG_ERROR("Null message in AES_encrypt");
+        return -1;
+    }
+
+    if (!encr_message) {
+        LOG_ERROR("Null encr message in AES_encrypt");
+        return -2;
+    }
+
 
   if (length < SGX_AESGCM_MAC_SIZE + SGX_AESGCM_IV_SIZE) {
       LOG_ERROR("length < SGX_AESGCM_MAC_SIZE - SGX_AESGCM_IV_SIZE");

secure_enclave/DHDkg.c

@@ -23,12 +23,16 @@
 
 #include <stdlib.h>
 #include <stdbool.h>
+
 #ifdef USER_SPACE
 #include <gmp.h>
 #else
+
 #include <../tgmp-build/include/sgx_tgmp.h>
+
 #endif
 
+#include "EnclaveConstants.h"
 #include "DomainParameters.h"
 #include "Curves.h"
 #include "Point.h"
@@ -38,144 +42,227 @@
 #include "EnclaveCommon.h"
 #include <string.h>
 
-void gen_session_key(char *skey_str, char* pb_keyB, char* common_key) {
-    char* pb_keyB_x = (char*)calloc(65, 1);
+int gen_session_key(char *skey_str, char *pb_keyB, char *common_key) {
+
+    int ret = -1;
+
+    LOG_INFO(__FUNCTION__);
+
+    SAFE_CHAR_BUF(pb_keyB_x, 65);SAFE_CHAR_BUF(pb_keyB_y, 65);
+
+
+    mpz_t skey;
+    mpz_init(skey);
+    point pub_keyB = point_init();
+    point session_key = point_init();
+
+
+    if (!common_key) {
+        LOG_ERROR("gen_session_key: Null common_key");
+        goto clean;
+    }
+
+    common_key[0] = 0;
+
+    if (!skey_str) {
+        LOG_ERROR("gen_session_key: Null skey_str");
+        goto clean;
+    }
+
+    if (!pb_keyB) {
+        LOG_ERROR("gen_session_key: Null skey_str");
+        goto clean;
+    }
+
     strncpy(pb_keyB_x, pb_keyB, 64);
     pb_keyB_x[64] = 0;
 
-    char* pb_keyB_y = (char*)calloc(65,1);
     strncpy(pb_keyB_y, pb_keyB + 64, 64);
     pb_keyB_y[64] = 0;
 
-    domain_parameters curve = domain_parameters_init();
-    domain_parameters_load_curve(curve, secp256k1);
-
-    mpz_t skey;
-    mpz_init(skey);
     mpz_set_str(skey, skey_str, 16);
 
-    point pub_keyB = point_init();
     point_set_hex(pub_keyB, pb_keyB_x, pb_keyB_y);
 
-    point session_key = point_init();
     point_multiplication(session_key, skey, pub_keyB, curve);
 
-    char arr_x[mpz_sizeinbase (session_key->x, 16) + 2];
+    SAFE_CHAR_BUF(arr_x, BUF_LEN);
     mpz_get_str(arr_x, 16, session_key->x);
     int n_zeroes = 64 - strlen(arr_x);
-    for ( int i = 0; i < n_zeroes; i++){
-      common_key[i] = '0';
+    for (int i = 0; i < n_zeroes; i++) {
+        common_key[i] = '0';
     }
     strncpy(common_key + n_zeroes, arr_x, strlen(arr_x));
     common_key[64] = 0;
 
+    ret = 0;
+
+    clean:
     mpz_clear(skey);
     point_clear(pub_keyB);
     point_clear(session_key);
-    domain_parameters_clear(curve);
-    free(pb_keyB_x);
-    free(pb_keyB_y);
+
+    return ret;
+
 }
 
-void session_key_recover(const char *skey_str, const char* sshare, char* common_key) {
-    char* pb_keyB_x = (char*)calloc(65, 1);
+int session_key_recover(const char *skey_str, const char *sshare, char *common_key) {
+
+    int ret = -1;
+
+    if (!common_key) {
+        LOG_ERROR("session_key_recover: Null common_key");
+        goto clean;
+    }
+
+    common_key[0] = 0;
+
+    if (!skey_str) {
+        LOG_ERROR("session_key_recover: Null skey_str");
+        goto clean;
+    }
+
+    if (!sshare) {
+        LOG_ERROR("session_key_recover: Null sshare");
+        goto clean;
+    }
+
+
+    SAFE_CHAR_BUF(pb_keyB_x, 65);
     strncpy(pb_keyB_x, sshare + 64, 64);
     pb_keyB_x[64] = 0;
 
-    char* pb_keyB_y = (char*)calloc(65, 1);
+    SAFE_CHAR_BUF(pb_keyB_y, 65);
     strncpy(pb_keyB_y, sshare + 128, 64);
     pb_keyB_y[64] = 0;
 
-    domain_parameters curve = domain_parameters_init();
-    domain_parameters_load_curve(curve, secp256k1);
-
     mpz_t skey;
     mpz_init(skey);
-    if (mpz_set_str(skey, skey_str, 16) == -1) {
-        common_key = NULL;
-
-        mpz_clear(skey);
-        domain_parameters_clear(curve);
-        free(pb_keyB_x);
-        free(pb_keyB_y);
+    point pub_keyB = point_init();
+    point session_key = point_init();
 
-        return;
+    if (mpz_set_str(skey, skey_str, 16) == -1) {
+        goto clean;
     }
 
-    point pub_keyB = point_init();
     point_set_hex(pub_keyB, pb_keyB_x, pb_keyB_y);
-
-    point session_key = point_init();
     point_multiplication(session_key, skey, pub_keyB, curve);
 
-    char arr_x[mpz_sizeinbase (session_key->x, 16) + 2];
+    SAFE_CHAR_BUF(arr_x, BUF_LEN);
+
     mpz_get_str(arr_x, 16, session_key->x);
     int n_zeroes = 64 - strlen(arr_x);
-    for ( int i = 0; i < n_zeroes; i++){
+    for (int i = 0; i < n_zeroes; i++) {
         common_key[i] = '0';
     }
     strncpy(common_key + n_zeroes, arr_x, strlen(arr_x));
 
+    ret = 0;
+
+    clean:
     mpz_clear(skey);
     point_clear(pub_keyB);
     point_clear(session_key);
-    domain_parameters_clear(curve);
-    free(pb_keyB_x);
-    free(pb_keyB_y);
+
+    return  ret;
 }
 
-void xor_encrypt(char* key, char* message, char* cypher) {
-   uint8_t cypher_bin[33];
+int xor_encrypt(char *key, char *message, char *cypher) {
 
-   uint8_t* key_bin = (uint8_t*)calloc(33,1);
-   uint64_t key_length;
-   if (!hex2carray(key, &key_length, key_bin)){
-     cypher = NULL;
-     free(key_bin);
-     return;
-   }
+    int ret = -1;
 
-   uint64_t msg_length;
-   uint8_t msg_bin[33];
-   if (!hex2carray(message, &msg_length, msg_bin)){
-     cypher = NULL;
-     free(key_bin);
-     return;
-   }
+    if (!cypher) {
+        LOG_ERROR("xor_encrypt: null cypher");
+        goto clean;
+    }
 
-   for (int i = 0; i < 32; i++){
-     cypher_bin[i] = msg_bin[i] ^ key_bin[i];
-   }
+    if (!key) {
+        LOG_ERROR("xor_encrypt: null key");
+        goto clean;
+    }
 
-   carray2Hex(cypher_bin, 32, cypher);
+    if (!message) {
+        LOG_ERROR("xor_encrypt: null message");
+        goto clean;
+    }
 
-   free(key_bin);
-}
+    SAFE_CHAR_BUF(cypher_bin, 33);
+    SAFE_CHAR_BUF(key_bin, 33);
+
+    uint64_t key_length;
 
-void xor_decrypt(char* key, char* cypher, char* message) {
+    if (!hex2carray(key, &key_length, key_bin)) {
+        goto clean;
+    }
+
+    uint64_t msg_length;
     uint8_t msg_bin[33];
+    if (!hex2carray(message, &msg_length, msg_bin)) {
+        goto clean;
+    }
+
+    for (int i = 0; i < 32; i++) {
+        cypher_bin[i] = msg_bin[i] ^ key_bin[i];
+    }
+
+    carray2Hex(cypher_bin, 32, cypher);
+
+    ret = 0;
+
+    clean:
+    ;
+
+    return ret;
+
+}
+
+int xor_decrypt(char *key, char *cypher, char *message) {
+
+    int ret = -1;
+
+    if (!cypher) {
+        LOG_ERROR("xor_encrypt: null cypher");
+        goto clean;
+    }
+
+    if (!key) {
+        LOG_ERROR("xor_encrypt: null key");
+        goto clean;
+    }
+
+    if (!message) {
+        LOG_ERROR("xor_encrypt: null message");
+        goto clean;
+    }
+
+
+    SAFE_CHAR_BUF(msg_bin,33);
+
+    SAFE_CHAR_BUF(key_bin,33)
 
-    uint8_t* key_bin = (uint8_t*)calloc(33,1);
     uint64_t key_length;
-    if (!hex2carray(key, &key_length, key_bin)){
-      message = NULL;
-      free(key_bin);
-      return;
+    if (!hex2carray(key, &key_length, key_bin)) {
+        goto clean;
     }
 
     uint64_t cypher_length;
-    uint8_t cypher_bin[33];
-    if (!hex2carray(cypher, &cypher_length, cypher_bin)){
-      message = NULL;
-      free(key_bin);
-      return;
+
+    SAFE_CHAR_BUF(cypher_bin, 33);
+    if (!hex2carray(cypher, &cypher_length, cypher_bin)) {
+        goto clean;
     }
 
-    for (int i = 0; i < 32; i++){
+    for (int i = 0; i < 32; i++) {
         msg_bin[i] = cypher_bin[i] ^ key_bin[i];
     }
 
     carray2Hex(msg_bin, 32, message);
 
-    free(key_bin);
+    ret = 0;
+
+    clean:
+    ;
+
+    return ret;
+
 }

secure_enclave/DHDkg.h

@@ -24,12 +24,12 @@
 #ifndef SGXD_DRIVE_KEY_DKG_H
 #define SGXD_DRIVE_KEY_DKG_H
 
-void gen_session_key(char* skey, char* pub_keyB, char* common_key);
+int gen_session_key(char* skey, char* pub_keyB, char* common_key);
 
-void session_key_recover(const char *skey_str, const char* sshare, char* common_key);
+int session_key_recover(const char *skey_str, const char* sshare, char* common_key);
 
-void xor_encrypt(char* key, char* message, char* cypher);
+int xor_encrypt(char* key, char* message, char* cypher);
 
-void xor_decrypt(char* key, char* cypher, char* message);
+int xor_decrypt(char* key, char* cypher, char* message);
 
 #endif //SGXD_DRIVE_KEY_DKG_H

secure_enclave/DKGUtils.cpp

@@ -47,58 +47,79 @@ using namespace std;
 
 string stringFromFr(const libff::alt_bn128_Fr &_el) {
 
+    string ret = "";
+    mpz_t t;
+    mpz_init(t);
+
+
     try {
 
-        mpz_t t;
-        mpz_init(t);
 
         _el.as_bigint().to_mpz(t);
 
-        char arr[mpz_sizeinbase(t, 10) + 2];
+        SAFE_CHAR_BUF(arr, BUF_LEN);
 
         char *tmp = mpz_get_str(arr, 10, t);
-        mpz_clear(t);
 
-        return string(tmp);
+
+        ret = string(tmp);
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return "";
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return "";
+        goto clean;
     }
+
+    clean:
+
+    mpz_clear(t);
+
+    return ret;
 }
 
 template<class T>
 string ConvertToString(const T &field_elem, int base = 10) {
+
+    string ret;
+
+    mpz_t t;
+    mpz_init(t);
+
     try {
-        mpz_t t;
-        mpz_init(t);
 
         field_elem.as_bigint().to_mpz(t);
 
-        char arr[mpz_sizeinbase(t, base) + 2];
+        SAFE_CHAR_BUF(arr, BUF_LEN);
 
         char *tmp = mpz_get_str(arr, base, t);
-        mpz_clear(t);
 
-        string output = tmp;
 
-        return output;
+        ret = string(tmp);
+
+        goto clean;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return "";
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return "";
+        goto clean;
     }
+
+    clean:
+    mpz_clear(t);
+    return ret;
+
 }
 
 string ConvertG2ToString(const libff::alt_bn128_G2 &elem, int base = 10, const string &delim = ":") {
+
+    string result = "";
+
     try {
-        string result;
+
         result += ConvertToString(elem.X.c0);
         result += delim;
         result += ConvertToString(elem.X.c1);
@@ -107,23 +128,28 @@ string ConvertG2ToString(const libff::alt_bn128_G2 &elem, int base = 10, const s
         result += delim;
         result += ConvertToString(elem.Y.c1);
 
-        return result;
+        goto clean;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return nullptr;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return nullptr;
+        goto clean;
     }
+
+    clean:
+    return result;
 }
 
 vector <libff::alt_bn128_Fr> SplitStringToFr(const char *coeffs, const char symbol) {
 
-    vector <libff::alt_bn128_Fr> tokens;
+    vector <libff::alt_bn128_Fr> result;
+    string str(coeffs);
+    string delim;
+
     try {
-        string str(coeffs);
-        string delim;
+
         delim.push_back(symbol);
 
         size_t prev = 0, pos = 0;
@@ -133,25 +159,31 @@ vector <libff::alt_bn128_Fr> SplitStringToFr(const char *coeffs, const char symb
             string token = str.substr(prev, pos - prev);
             if (!token.empty()) {
                 libff::alt_bn128_Fr coeff(token.c_str());
-                tokens.push_back(coeff);
+                result.push_back(coeff);
             }
             prev = pos + delim.length();
         } while (pos < str.length() && prev < str.length());
 
-        return tokens;
+        goto clean;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return tokens;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return tokens;
+        goto clean;
     }
+
+    clean:
+    return result;
 }
 
 int gen_dkg_poly(char *secret, unsigned _t) {
+
+    int status = 1;
+    string result;
+
     try {
-        string result;
         for (size_t i = 0; i < _t; ++i) {
             libff::alt_bn128_Fr cur_coef = libff::alt_bn128_Fr::random_element();
 
@@ -164,42 +196,47 @@ int gen_dkg_poly(char *secret, unsigned _t) {
         strncpy(secret, result.c_str(), result.length() + 1);
 
         if (strlen(secret) == 0) {
-            return 1;
+            goto clean;
         }
 
-        return 0;
+        status = 0;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return 1;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return 1;
+        goto clean;
     }
 
+    clean:
+    return status;
+
 }
 
 libff::alt_bn128_Fr PolynomialValue(const vector <libff::alt_bn128_Fr> &pol, libff::alt_bn128_Fr point, unsigned _t) {
 
-
-    libff::alt_bn128_Fr value = libff::alt_bn128_Fr::zero();
+    libff::alt_bn128_Fr result = libff::alt_bn128_Fr::zero();
 
     try {
 
         libff::alt_bn128_Fr pow = libff::alt_bn128_Fr::one();
         for (unsigned i = 0; i < pol.size(); ++i) {
-            value += pol[i] * pow;
+            result += pol[i] * pow;
             pow *= point;
         }
 
-        return value;
+        goto clean;
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return value;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return value;
+        goto clean;
     }
+
+    clean:
+    return result;
 }
 
 void calc_secret_shares(const char *decrypted_coeffs,
@@ -233,11 +270,13 @@ void calc_secret_shares(const char *decrypted_coeffs,
 int calc_secret_share(const char *decrypted_coeffs, char *s_share,
                       unsigned _t, unsigned _n, unsigned ind) {
 
+    int result = 1;
+
     try {
         char symbol = ':';
         vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
         if (poly.size() != _t) {
-            return 1;
+            goto clean;
         }
 
         libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
@@ -246,15 +285,19 @@ int calc_secret_share(const char *decrypted_coeffs, char *s_share,
         cur_share.insert(0, n_zeroes, '0');
 
         strncpy(s_share, cur_share.c_str(), cur_share.length() + 1);
-        return 0;
+        result = 0;
+        goto clean;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return 1;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return 1;
+        goto clean;
     }
+
+    clean:
+    return result;
 }
 
 void calc_secret_shareG2_old(const char *decrypted_coeffs, char *s_shareG2,
@@ -281,17 +324,20 @@ void calc_secret_shareG2_old(const char *decrypted_coeffs, char *s_shareG2,
 
 int calc_secret_shareG2(const char *s_share, char *s_shareG2) {
 
+    int result = 1;
+
+    mpz_t share;
+    mpz_init(share);
 
     try {
 
-        mpz_t share;
-        mpz_init(share);
+
         if (mpz_set_str(share, s_share, 16) == -1) {
-            mpz_clear(share);
-            return 1;
+            goto clean;
         }
 
-        char arr[mpz_sizeinbase(share, 10) + 2];
+        SAFE_CHAR_BUF(arr, BUF_LEN);
+
         char *share_str = mpz_get_str(arr, 10, share);
 
         libff::alt_bn128_Fr secret_share(share_str);
@@ -303,18 +349,22 @@ int calc_secret_shareG2(const char *s_share, char *s_shareG2) {
         string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
 
         strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
-
-        mpz_clear(share);
-
-        return 0;
+        result = 0;
+        goto clean;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return 1;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return 1;
+        goto clean;
     }
+
+    clean:
+
+    mpz_clear(share);
+    return result;
+
 }
 
 int calc_public_shares(const char *decrypted_coeffs, char *public_shares,

secure_enclave/EnclaveCommon.cpp

@@ -44,93 +44,117 @@ uint8_t *getThreadLocalDecryptedDkgPoly() {
 
 
 string *stringFromKey(libff::alt_bn128_Fr *_key) {
-    try {
-        mpz_t t;
-        mpz_init(t);
+    string *ret = nullptr;
+    mpz_t t;
+    mpz_init(t);
 
-        _key->as_bigint().to_mpz(t);
+    SAFE_CHAR_BUF(arr, BUF_LEN);
 
-        char arr[mpz_sizeinbase(t, 10) + 2];
+    try {
+        _key->as_bigint().to_mpz(t);
 
         char *tmp = mpz_get_str(arr, 10, t);
-        mpz_clear(t);
 
-        return new string(tmp);
+        if (!tmp) {
+            LOG_ERROR("stringFromKey: mpz_get_str failed");
+            goto clean;
+        }
+        ret = new string(tmp);
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return nullptr;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return nullptr;
+        goto clean;
     }
+
+    clean:
+    mpz_clear(t);
+    return ret;
 }
 
 string *stringFromFq(libff::alt_bn128_Fq *_fq) {
-    try {
-        mpz_t t;
-        mpz_init(t);
 
-        _fq->as_bigint().to_mpz(t);
-
-        char arr[mpz_sizeinbase(t, 10) + 2];
+    string *ret = nullptr;
+    mpz_t t;
+    mpz_init(t);SAFE_CHAR_BUF(arr, BUF_LEN);
 
+    try {
+        _fq->as_bigint().to_mpz(t);
         char *tmp = mpz_get_str(arr, 10, t);
-        mpz_clear(t);
-
-        return new string(tmp);
+        ret = new string(tmp);
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return nullptr;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return nullptr;
+        goto clean;
     }
+
+    clean:
+    mpz_clear(t);
+    return ret;
 }
 
 string *stringFromG1(libff::alt_bn128_G1 *_g1) {
 
+    string *sX = nullptr;
+    string *sY = nullptr;
+    string *ret = nullptr;
+
+
     try {
         _g1->to_affine_coordinates();
 
         auto sX = stringFromFq(&_g1->X);
-        auto sY = stringFromFq(&_g1->Y);
 
-        auto sG1 = new string(*sX + ":" + *sY);
+        if (!sX) {
+            goto clean;
+        }
 
-        delete (sX);
-        delete (sY);
+        auto sY = stringFromFq(&_g1->Y);
+
+        if (!sY) {
+            goto clean;
+        }
 
-        return sG1;
+        ret = new string(*sX + ":" + *sY);
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return nullptr;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return nullptr;
+        goto clean;
     }
 
+    clean:
+
+    SAFE_FREE(sX);
+    SAFE_FREE(sY);
+
+    return ret;
+
 }
 
 libff::alt_bn128_Fr *keyFromString(const char *_keyStringHex) {
-    try {
-        mpz_t skey;
-        mpz_init(skey);
-        mpz_set_str(skey, _keyStringHex, 16);
 
-        char skey_dec[mpz_sizeinbase(skey, 10) + 2];
-        mpz_get_str(skey_dec, 10, skey);
-        mpz_clear(skey);
+    mpz_t skey;
+    mpz_init(skey);SAFE_CHAR_BUF(skey_dec, BUF_LEN);
+    libff::alt_bn128_Fr *ret = nullptr;
 
-        return new libff::alt_bn128_Fr(skey_dec);
 
-    } catch (exception &e) {
-        LOG_ERROR(e.what());
-        return nullptr;
-    } catch (...) {
-        LOG_ERROR("Unknown throwable");
-        return nullptr;
-    }
+    mpz_set_str(skey, _keyStringHex, 16);
+    mpz_get_str(skey_dec, 10, skey);
+
+    ret = new libff::alt_bn128_Fr(skey_dec);
+
+    goto clean;
+
+    clean:
+
+    mpz_clear(skey);
+    return ret;
 }
 
 int inited = 0;
@@ -149,11 +173,39 @@ void enclave_init() {
 
 bool enclave_sign(const char *_keyString, const char *_hashXString, const char *_hashYString,
                   char *sig) {
+
+    bool ret = false;
+
+    libff::alt_bn128_Fr* key = nullptr;
+    string * r = nullptr;
+
+
+    if (!_keyString) {
+        LOG_ERROR("Null key string");
+        goto clean;
+    }
+
+    if (!_hashXString) {
+        LOG_ERROR("Null hashX");
+        goto clean;
+    }
+
+    if (!_hashYString) {
+        LOG_ERROR("Null hashY");
+        goto clean;
+    }
+
+    if (!sig) {
+        LOG_ERROR("Null sig");
+        goto clean;
+    }
+
     try {
         auto key = keyFromString(_keyString);
 
-        if (key == nullptr) {
-            throw invalid_argument("Null key");
+        if (!key) {
+            LOG_ERROR("Null key");
+            goto clean;
         }
 
         libff::alt_bn128_Fq hashX(_hashXString);
@@ -164,8 +216,6 @@ bool enclave_sign(const char *_keyString, const char *_hashXString, const char *
 
         libff::alt_bn128_G1 sign = key->as_bigint() * hash;
 
-        delete key;
-
         sign.to_affine_coordinates();
 
         auto r = stringFromG1(&sign);
@@ -174,21 +224,25 @@ bool enclave_sign(const char *_keyString, const char *_hashXString, const char *
 
         strncpy(sig, r->c_str(), BUF_LEN);
 
-        delete r;
-
-        return true;
+        ret =  true;
 
     } catch (exception &e) {
         LOG_ERROR(e.what());
-        return false;
+        goto clean;
     } catch (...) {
         LOG_ERROR("Unknown throwable");
-        return false;
+        goto clean;
     }
 
+    clean:
+
+    SAFE_DELETE(key);
+    SAFE_DELETE(r);
+    return ret;
+
 }
 
-void carray2Hex(const unsigned char *d, int _len, char* _hexArray) {
+void carray2Hex(const unsigned char *d, int _len, char *_hexArray) {
     char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 

secure_enclave/EnclaveCommon.h

@@ -64,5 +64,9 @@ extern unsigned char* globalRandom;
 
 extern domain_parameters curve;
 
+#define SAFE_FREE(__X__) if (__X__) {free(__X__); __X__ = NULL;}
+#define SAFE_DELETE(__X__) if (__X__) {delete(__X__); __X__ = NULL;}
+#define SAFE_CHAR_BUF(__X__, __Y__)  ;char __X__ [ __Y__ ]; memset(__X__, 0, __Y__);
+
 
 #endif //SGXWALLET_ENCLAVECOMMON_H