SKALE-3067-cleanup-sgx

secure_enclave/DKGUtils.cpp

@@ -26,7 +26,9 @@
 #ifdef USER_SPACE
 #include <gmp.h>
 #else
+
 #include <../tgmp-build/include/sgx_tgmp.h>
+
 #endif
 
 #include <../SCIPR/libff/algebra/curves/alt_bn128/alt_bn128_pp.hpp>
@@ -37,12 +39,16 @@
 #include "EnclaveConstants.h"
 #include <cstdio>
 #include <stdio.h>
-
+#include "EnclaveCommon.h"
 #include "DHDkg.h"
 
+
 using namespace std;
 
-string stringFromFr(const libff::alt_bn128_Fr& _el) {
+string stringFromFr(const libff::alt_bn128_Fr &_el) {
+
+    try {
+
     mpz_t t;
     mpz_init(t);
 
@@ -54,25 +60,44 @@ string stringFromFr(const libff::alt_bn128_Fr& _el) {
     mpz_clear(t);
 
     return string(tmp);
+
+    } catch (exception& e) {
+        LOG_ERROR(e.what());
+        return "";
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return "";
+    }
 }
 
-template<class T> string ConvertToString(const T& field_elem, int base = 10) {
+template<class T>
+string ConvertToString(const T &field_elem, int base = 10) {
+    try {
         mpz_t t;
         mpz_init(t);
 
         field_elem.as_bigint().to_mpz(t);
 
-  char arr[mpz_sizeinbase (t, base) + 2];
+        char arr[mpz_sizeinbase(t, base) + 2];
 
-  char * tmp = mpz_get_str(arr, base, t);
+        char *tmp = mpz_get_str(arr, base, t);
         mpz_clear(t);
 
         string output = tmp;
 
         return output;
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return "";
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return "";
+    }
 }
 
-string ConvertG2ToString(const libff::alt_bn128_G2 & elem, int base = 10, const string& delim = ":") {
+string ConvertG2ToString(const libff::alt_bn128_G2 &elem, int base = 10, const string &delim = ":") {
+    try {
         string result;
         result += ConvertToString(elem.X.c0);
         result += delim;
@@ -83,32 +108,48 @@ string ConvertG2ToString(const libff::alt_bn128_G2 & elem, int base = 10, const
         result += ConvertToString(elem.Y.c1);
 
         return result;
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
 }
 
-vector<libff::alt_bn128_Fr> SplitStringToFr(const char* coeffs, const char symbol) {
+vector <libff::alt_bn128_Fr> SplitStringToFr(const char *coeffs, const char symbol) {
+    vector <libff::alt_bn128_Fr> tokens;
+    try {
     string str(coeffs);
     string delim;
     delim.push_back(symbol);
-    vector<libff::alt_bn128_Fr> tokens;
+
     size_t prev = 0, pos = 0;
-    do
-    {
+    do {
         pos = str.find(delim, prev);
         if (pos == string::npos) pos = str.length();
-        string token = str.substr(prev, pos-prev);
+        string token = str.substr(prev, pos - prev);
         if (!token.empty()) {
             libff::alt_bn128_Fr coeff(token.c_str());
             tokens.push_back(coeff);
         }
         prev = pos + delim.length();
-    }
-    while (pos < str.length() && prev < str.length());
+    } while (pos < str.length() && prev < str.length());
+
+    return tokens;
 
+    } catch (exception& e) {
+        LOG_ERROR(e.what());
+        return tokens;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
         return tokens;
+    }
 }
 
-int gen_dkg_poly( char* secret, unsigned _t ) {
-  libff::init_alt_bn128_params();
+int gen_dkg_poly(char *secret, unsigned _t) {
+    try {
     string result;
     for (size_t i = 0; i < _t; ++i) {
         libff::alt_bn128_Fr cur_coef = libff::alt_bn128_Fr::random_element();
@@ -126,9 +167,18 @@ int gen_dkg_poly( char* secret, unsigned _t ) {
     }
 
     return 0;
+
+    } catch (exception& e) {
+        LOG_ERROR(e.what());
+        return 1;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return 1;
+    }
+
 }
 
-libff::alt_bn128_Fr PolynomialValue(const vector<libff::alt_bn128_Fr>& pol, libff::alt_bn128_Fr point, unsigned _t) {
+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 pow = libff::alt_bn128_Fr::one();
@@ -140,12 +190,13 @@ libff::alt_bn128_Fr PolynomialValue(const vector<libff::alt_bn128_Fr>& pol, libf
     return value;
 }
 
-void calc_secret_shares(const char* decrypted_coeffs, char * secret_shares,      // calculates secret shares in base 10 to a string secret_shares,
+void calc_secret_shares(const char *decrypted_coeffs,
+                        char *secret_shares,      // calculates secret shares in base 10 to a string secret_shares,
                         unsigned _t, unsigned _n) {                                                 // separated by ":"
     // calculate for each node a list of secret values that will be used for verification
     string result;
     char symbol = ':';
-  vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
+    vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
 
     for (size_t i = 0; i < _n; ++i) {
         libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(i + 1), _t);
@@ -155,12 +206,12 @@ void calc_secret_shares(const char* decrypted_coeffs, char * secret_shares,
     strncpy(secret_shares, result.c_str(), result.length() + 1);
 }
 
-int calc_secret_share(const char* decrypted_coeffs, char * s_share,
+int calc_secret_share(const char *decrypted_coeffs, char *s_share,
                       unsigned _t, unsigned _n, unsigned ind) {
-  libff::init_alt_bn128_params();
+
     char symbol = ':';
-  vector<libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
-  if ( poly.size() != _t) {
+    vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
+    if (poly.size() != _t) {
         return 1;
     }
 
@@ -173,11 +224,11 @@ int calc_secret_share(const char* decrypted_coeffs, char * s_share,
     return 0;
 }
 
-void calc_secret_shareG2_old(const char* decrypted_coeffs, char * s_shareG2,
+void calc_secret_shareG2_old(const char *decrypted_coeffs, char *s_shareG2,
                              unsigned _t, unsigned ind) {
-  libff::init_alt_bn128_params();
+
     char symbol = ':';
-  vector<libff::alt_bn128_Fr> poly =  SplitStringToFr(decrypted_coeffs, symbol);
+    vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
 
     libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
 
@@ -188,18 +239,18 @@ void calc_secret_shareG2_old(const char* decrypted_coeffs, char * s_shareG2,
     strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
 }
 
-int calc_secret_shareG2(const char* s_share, char * s_shareG2) {
-  libff::init_alt_bn128_params();
+int calc_secret_shareG2(const char *s_share, char *s_shareG2) {
+
 
     mpz_t share;
     mpz_init(share);
-  if (mpz_set_str(share, s_share, 16) == -1){
+    if (mpz_set_str(share, s_share, 16) == -1) {
         mpz_clear(share);
         return 1;
     }
 
-  char arr[mpz_sizeinbase (share, 10) + 2];
-  char * share_str = mpz_get_str(arr, 10, share);
+    char arr[mpz_sizeinbase(share, 10) + 2];
+    char *share_str = mpz_get_str(arr, 10, share);
 
     libff::alt_bn128_Fr secret_share(share_str);
 
@@ -216,18 +267,18 @@ int calc_secret_shareG2(const char* s_share, char * s_shareG2) {
     return 0;
 }
 
-int calc_public_shares(const char* decrypted_coeffs, char * public_shares,
+int calc_public_shares(const char *decrypted_coeffs, char *public_shares,
                        unsigned _t) {
-  libff::init_alt_bn128_params();
+
     // calculate for each node a list of public shares
     string result;
     char symbol = ':';
-  vector<libff::alt_bn128_Fr> poly =  SplitStringToFr(decrypted_coeffs, symbol);
+    vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
     if (poly.size() != _t) {
         return 1;
     }
     for (size_t i = 0; i < _t; ++i) {
-    libff::alt_bn128_G2 pub_share = poly.at(i) * libff::alt_bn128_G2::one() ;
+        libff::alt_bn128_G2 pub_share = poly.at(i) * libff::alt_bn128_G2::one();
         pub_share.to_affine_coordinates();
         string pub_share_str = ConvertG2ToString(pub_share);
         result += pub_share_str + ",";
@@ -236,28 +287,28 @@ int calc_public_shares(const char* decrypted_coeffs, char * public_shares,
     return 0;
 }
 
-string ConvertHexToDec(string hex_str){
+string ConvertHexToDec(string hex_str) {
     mpz_t dec;
     mpz_init(dec);
 
-  if (mpz_set_str(dec, hex_str.c_str(), 16) == -1){
+    if (mpz_set_str(dec, hex_str.c_str(), 16) == -1) {
         mpz_clear(dec);
         return "false";
     }
 
-  char arr[mpz_sizeinbase (dec, 10) + 2];
-  char * result = mpz_get_str(arr, 10, dec);
+    char arr[mpz_sizeinbase(dec, 10) + 2];
+    char *result = mpz_get_str(arr, 10, dec);
 
     mpz_clear(dec);
 
     return result;
 }
 
-int Verification( char * public_shares, mpz_t decr_secret_share, int _t, int ind ) {
+int Verification(char *public_shares, mpz_t decr_secret_share, int _t, int ind) {
     string pub_shares_str = public_shares;
-  libff::init_alt_bn128_params();
 
-  vector<libff::alt_bn128_G2> pub_shares;
+
+    vector <libff::alt_bn128_G2> pub_shares;
     uint64_t share_length = 256;
     uint8_t coord_length = 64;
 
@@ -269,7 +320,7 @@ int Verification( char * public_shares, mpz_t decr_secret_share, int _t, int ind
         string x_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + coord_length, coord_length));
         string y_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 2 * coord_length, coord_length));
         string y_c1_str = ConvertHexToDec(pub_shares_str.substr(pos0 + 3 * coord_length, coord_length));
-    if (x_c0_str == "false" || x_c1_str == "false" || y_c0_str == "false" || y_c1_str == "false"){
+        if (x_c0_str == "false" || x_c1_str == "false" || y_c0_str == "false" || y_c1_str == "false") {
             return 2;
         }
         pub_share.X.c0 = libff::alt_bn128_Fq(x_c0_str.c_str());
@@ -286,8 +337,8 @@ int Verification( char * public_shares, mpz_t decr_secret_share, int _t, int ind
         val = val + power(libff::alt_bn128_Fr(ind + 1), i) * pub_shares[i];
     }
 
-  char arr[mpz_sizeinbase (decr_secret_share, 10) + 2];
-  char * tmp = mpz_get_str(arr, 10, decr_secret_share);
+    char arr[mpz_sizeinbase(decr_secret_share, 10) + 2];
+    char *tmp = mpz_get_str(arr, 10, decr_secret_share);
 
     libff::alt_bn128_Fr sshare(tmp);
 
@@ -300,13 +351,14 @@ int Verification( char * public_shares, mpz_t decr_secret_share, int _t, int ind
     val2.to_affine_coordinates();
     strncpy(public_shares, ConvertToString(val.X.c0).c_str(), ConvertToString(val.X.c0).length());
     strncpy(public_shares + ConvertToString(val.X.c0).length(), ":", 1);
-  strncpy(public_shares + ConvertToString(val.X.c0).length() + 1, ConvertToString(val2.X.c0).c_str(), ConvertToString(val2.X.c0).length());
+    strncpy(public_shares + ConvertToString(val.X.c0).length() + 1, ConvertToString(val2.X.c0).c_str(),
+            ConvertToString(val2.X.c0).length());
 
     return (val == sshare * libff::alt_bn128_G2::one());
 }
 
-int calc_bls_public_key(char* skey_hex, char* pub_key) {
-  libff::init_alt_bn128_params();
+int calc_bls_public_key(char *skey_hex, char *pub_key) {
+
 
     mpz_t skey;
     mpz_init(skey);
@@ -315,7 +367,7 @@ int calc_bls_public_key(char* skey_hex, char* pub_key) {
         return 1;
     }
 
-  char skey_dec[mpz_sizeinbase (skey, 10) + 2];
+    char skey_dec[mpz_sizeinbase(skey, 10) + 2];
     mpz_get_str(skey_dec, 10, skey);
 
     libff::alt_bn128_Fr bls_skey(skey_dec);

secure_enclave/EnclaveCommon.cpp

@@ -38,13 +38,13 @@ using namespace std;
 
 thread_local uint8_t decryptedDkgPoly[DKG_BUFER_LENGTH];
 
-uint8_t* getThreadLocalDecryptedDkgPoly() {
-
+uint8_t *getThreadLocalDecryptedDkgPoly() {
     return decryptedDkgPoly;
 }
 
 
 string *stringFromKey(libff::alt_bn128_Fr *_key) {
+    try {
         mpz_t t;
         mpz_init(t);
 
@@ -56,9 +56,17 @@ string *stringFromKey(libff::alt_bn128_Fr *_key) {
         mpz_clear(t);
 
         return new string(tmp);
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
 }
 
 string *stringFromFq(libff::alt_bn128_Fq *_fq) {
+    try {
         mpz_t t;
         mpz_init(t);
 
@@ -70,9 +78,18 @@ string *stringFromFq(libff::alt_bn128_Fq *_fq) {
         mpz_clear(t);
 
         return new string(tmp);
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
 }
 
 string *stringFromG1(libff::alt_bn128_G1 *_g1) {
+
+    try {
         _g1->to_affine_coordinates();
 
         auto sX = stringFromFq(&_g1->X);
@@ -84,18 +101,36 @@ string *stringFromG1(libff::alt_bn128_G1 *_g1) {
         delete (sY);
 
         return sG1;
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
+
 }
 
 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];
+        char skey_dec[mpz_sizeinbase(skey, 10) + 2];
         mpz_get_str(skey_dec, 10, skey);
         mpz_clear(skey);
 
         return new libff::alt_bn128_Fr(skey_dec);
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
 }
 
 int inited = 0;
@@ -108,11 +143,12 @@ void enclave_init() {
 }
 
 bool enclave_sign(const char *_keyString, const char *_hashXString, const char *_hashYString,
-          char* sig) {
+                  char *sig) {
+    try {
         auto key = keyFromString(_keyString);
 
         if (key == nullptr) {
-        throw exception();
+            throw invalid_argument("Null key");
         }
 
         libff::alt_bn128_Fq hashX(_hashXString);
@@ -136,9 +172,18 @@ bool enclave_sign(const char *_keyString, const char *_hashXString, const char *
         delete r;
 
         return true;
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return false;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return false;
+    }
+
 }
 
-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'};
 
@@ -160,8 +205,8 @@ int char2int(char _input) {
     return -1;
 }
 
-bool hex2carray2(const char * _hex, uint64_t  *_bin_len,
-                 uint8_t* _bin, const int _max_length ) {
+bool hex2carray2(const char *_hex, uint64_t *_bin_len,
+                 uint8_t *_bin, const int _max_length) {
     int len = strnlen(_hex, _max_length);
 
     if (len == 0 && len % 2 == 1)
@@ -170,8 +215,8 @@ bool hex2carray2(const char * _hex, uint64_t  *_bin_len,
     *_bin_len = len / 2;
 
     for (int i = 0; i < len / 2; i++) {
-        int high = char2int((char)_hex[i * 2]);
-        int low = char2int((char)_hex[i * 2 + 1]);
+        int high = char2int((char) _hex[i * 2]);
+        int low = char2int((char) _hex[i * 2 + 1]);
 
         if (high < 0 || low < 0) {
             return false;
@@ -183,8 +228,8 @@ bool hex2carray2(const char * _hex, uint64_t  *_bin_len,
     return true;
 }
 
-bool hex2carray(const char * _hex, uint64_t  *_bin_len,
-                uint8_t* _bin ) {
+bool hex2carray(const char *_hex, uint64_t *_bin_len,
+                uint8_t *_bin) {
     int len = strnlen(_hex, 2 * BUF_LEN);
 
     if (len == 0 && len % 2 == 1)
@@ -193,8 +238,8 @@ bool hex2carray(const char * _hex, uint64_t  *_bin_len,
     *_bin_len = len / 2;
 
     for (int i = 0; i < len / 2; i++) {
-    int high = char2int((char)_hex[i * 2]);
-    int low = char2int((char)_hex[i * 2 + 1]);
+        int high = char2int((char) _hex[i * 2]);
+        int low = char2int((char) _hex[i * 2 + 1]);
 
         if (high < 0 || low < 0) {
             return false;
@@ -206,11 +251,13 @@ bool hex2carray(const char * _hex, uint64_t  *_bin_len,
     return true;
 }
 
-enum log_level {L_TRACE = 0, L_DEBUG = 1, L_INFO = 2, L_WARNING = 3,  L_ERROR = 4 };
+enum log_level {
+    L_TRACE = 0, L_DEBUG = 1, L_INFO = 2, L_WARNING = 3, L_ERROR = 4
+};
 
 uint32_t globalLogLevel_ = 2;
 
-void logMsg(log_level _level, const char* _msg) {
+void logMsg(log_level _level, const char *_msg) {
     if (_level < globalLogLevel_)
         return;
 
@@ -225,19 +272,19 @@ void logMsg(log_level _level, const char* _msg) {
 }
 
 
-EXTERNC void LOG_INFO(const char* _msg) {
+EXTERNC void LOG_INFO(const char *_msg) {
     logMsg(L_INFO, _msg);
 };
-EXTERNC void LOG_WARN(const char* _msg) {
+EXTERNC void LOG_WARN(const char *_msg) {
     logMsg(L_WARNING, _msg);
 };
 
-EXTERNC void LOG_ERROR(const char* _msg) {
+EXTERNC void LOG_ERROR(const char *_msg) {
     logMsg(L_ERROR, _msg);
 };
-EXTERNC void LOG_DEBUG(const char* _msg) {
+EXTERNC void LOG_DEBUG(const char *_msg) {
     logMsg(L_DEBUG, _msg);
 };
-EXTERNC void LOG_TRACE(const char* _msg) {
+EXTERNC void LOG_TRACE(const char *_msg) {
     logMsg(L_TRACE, _msg);
 };