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,280 +60,326 @@ 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) {
-  mpz_t t;
-  mpz_init(t);
+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);
 
-  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);
+        mpz_clear(t);
 
-  char * tmp = mpz_get_str(arr, base, t);
-  mpz_clear(t);
+        string output = tmp;
 
-  string output = tmp;
+        return output;
 
-  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 result;
-  result += ConvertToString(elem.X.c0);
-  result += delim;
-  result += ConvertToString(elem.X.c1);
-  result += delim;
-  result += ConvertToString(elem.Y.c0);
-  result += delim;
-  result += ConvertToString(elem.Y.c1);
-
-  return result;
+string ConvertG2ToString(const libff::alt_bn128_G2 &elem, int base = 10, const string &delim = ":") {
+    try {
+        string result;
+        result += ConvertToString(elem.X.c0);
+        result += delim;
+        result += ConvertToString(elem.X.c1);
+        result += delim;
+        result += ConvertToString(elem.Y.c0);
+        result += delim;
+        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();
-  string result;
-  for (size_t i = 0; i < _t; ++i) {
-     libff::alt_bn128_Fr cur_coef = libff::alt_bn128_Fr::random_element();
-
-     while (i == _t - 1 && cur_coef == libff::alt_bn128_Fr::zero()) {
-       cur_coef = libff::alt_bn128_Fr::random_element();
-     }
-     result += stringFromFr(cur_coef);
-     result += ":";
-  }
-  strncpy(secret, result.c_str(), result.length() + 1);
-
-  if (strlen(secret) == 0) {
-    return 1;
-  }
-
-  return 0;
+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();
+
+        while (i == _t - 1 && cur_coef == libff::alt_bn128_Fr::zero()) {
+            cur_coef = libff::alt_bn128_Fr::random_element();
+        }
+        result += stringFromFr(cur_coef);
+        result += ":";
+    }
+    strncpy(secret, result.c_str(), result.length() + 1);
+
+    if (strlen(secret) == 0) {
+        return 1;
+    }
+
+    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 value = libff::alt_bn128_Fr::zero();
+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();
-  for (unsigned i = 0; i < pol.size(); ++i) {
-     value += pol[i] * pow;
-     pow *= point;
-  }
+    libff::alt_bn128_Fr pow = libff::alt_bn128_Fr::one();
+    for (unsigned i = 0; i < pol.size(); ++i) {
+        value += pol[i] * pow;
+        pow *= point;
+    }
 
-  return value;
+    return value;
 }
 
-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);
-
-  for (size_t i = 0; i < _n; ++i) {
-    libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(i + 1), _t);
-    result += ConvertToString(secret_share);
-    result += ":";
-  }
-  strncpy(secret_shares, result.c_str(), result.length() + 1);
+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);
+
+    for (size_t i = 0; i < _n; ++i) {
+        libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(i + 1), _t);
+        result += ConvertToString(secret_share);
+        result += ":";
+    }
+    strncpy(secret_shares, result.c_str(), result.length() + 1);
 }
 
-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) {
-    return 1;
-  }
-
-  libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
-  string cur_share = ConvertToString(secret_share, 16);
-  int n_zeroes = 64 - cur_share.size();
-  cur_share.insert(0, n_zeroes, '0');
-
-  strncpy(s_share, cur_share.c_str(), cur_share.length() + 1);
-  return 0;
+int calc_secret_share(const char *decrypted_coeffs, char *s_share,
+                      unsigned _t, unsigned _n, unsigned ind) {
+
+    char symbol = ':';
+    vector <libff::alt_bn128_Fr> poly = SplitStringToFr(decrypted_coeffs, symbol);
+    if (poly.size() != _t) {
+        return 1;
+    }
+
+    libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
+    string cur_share = ConvertToString(secret_share, 16);
+    int n_zeroes = 64 - cur_share.size();
+    cur_share.insert(0, n_zeroes, '0');
+
+    strncpy(s_share, cur_share.c_str(), cur_share.length() + 1);
+    return 0;
 }
 
-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);
+void calc_secret_shareG2_old(const char *decrypted_coeffs, char *s_shareG2,
+                             unsigned _t, unsigned ind) {
+
+    char 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);
+    libff::alt_bn128_Fr secret_share = PolynomialValue(poly, libff::alt_bn128_Fr(ind), _t);
 
-  libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
+    libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
 
-  string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
+    string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
 
-  strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
+    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){
-    mpz_clear(share);
-    return 1;
-  }
 
-  char arr[mpz_sizeinbase (share, 10) + 2];
-  char * share_str = mpz_get_str(arr, 10, share);
+    mpz_t share;
+    mpz_init(share);
+    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);
 
-  libff::alt_bn128_Fr secret_share(share_str);
+    libff::alt_bn128_Fr secret_share(share_str);
 
-  libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
+    libff::alt_bn128_G2 secret_shareG2 = secret_share * libff::alt_bn128_G2::one();
 
-  secret_shareG2.to_affine_coordinates();
+    secret_shareG2.to_affine_coordinates();
 
-  string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
+    string secret_shareG2_str = ConvertG2ToString(secret_shareG2);
 
-  strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
+    strncpy(s_shareG2, secret_shareG2_str.c_str(), secret_shareG2_str.length() + 1);
 
-  mpz_clear(share);
+    mpz_clear(share);
 
-  return 0;
+    return 0;
 }
 
-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);
-  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() ;
-    pub_share.to_affine_coordinates();
-    string pub_share_str = ConvertG2ToString(pub_share);
-    result += pub_share_str + ",";
-  }
-  strncpy(public_shares, result.c_str(), result.length());
-  return 0;
+int calc_public_shares(const char *decrypted_coeffs, char *public_shares,
+                       unsigned _t) {
+
+    // calculate for each node a list of public shares
+    string result;
+    char 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();
+        pub_share.to_affine_coordinates();
+        string pub_share_str = ConvertG2ToString(pub_share);
+        result += pub_share_str + ",";
+    }
+    strncpy(public_shares, result.c_str(), result.length());
+    return 0;
 }
 
-string ConvertHexToDec(string hex_str){
-  mpz_t dec;
-  mpz_init(dec);
+string ConvertHexToDec(string hex_str) {
+    mpz_t dec;
+    mpz_init(dec);
 
-  if (mpz_set_str(dec, hex_str.c_str(), 16) == -1){
-    mpz_clear(dec);
-    return "false";
-  }
+    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);
+    mpz_clear(dec);
 
-  return result;
+    return result;
 }
 
-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();
+int Verification(char *public_shares, mpz_t decr_secret_share, int _t, int ind) {
+    string pub_shares_str = public_shares;
 
-  vector<libff::alt_bn128_G2> pub_shares;
-  uint64_t share_length = 256;
-  uint8_t coord_length = 64;
 
-  for (size_t i = 0; i < _t; ++i) {
-    libff::alt_bn128_G2 pub_share;
+    vector <libff::alt_bn128_G2> pub_shares;
+    uint64_t share_length = 256;
+    uint8_t coord_length = 64;
 
-    uint64_t pos0 = share_length * i;
-    string x_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0, coord_length));
-    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"){
-      return 2;
-    }
-    pub_share.X.c0 = libff::alt_bn128_Fq(x_c0_str.c_str());
-    pub_share.X.c1 = libff::alt_bn128_Fq(x_c1_str.c_str());
-    pub_share.Y.c0 = libff::alt_bn128_Fq(y_c0_str.c_str());
-    pub_share.Y.c1 = libff::alt_bn128_Fq(y_c1_str.c_str());
-    pub_share.Z = libff::alt_bn128_Fq2::one();
+    for (size_t i = 0; i < _t; ++i) {
+        libff::alt_bn128_G2 pub_share;
+
+        uint64_t pos0 = share_length * i;
+        string x_c0_str = ConvertHexToDec(pub_shares_str.substr(pos0, coord_length));
+        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") {
+            return 2;
+        }
+        pub_share.X.c0 = libff::alt_bn128_Fq(x_c0_str.c_str());
+        pub_share.X.c1 = libff::alt_bn128_Fq(x_c1_str.c_str());
+        pub_share.Y.c0 = libff::alt_bn128_Fq(y_c0_str.c_str());
+        pub_share.Y.c1 = libff::alt_bn128_Fq(y_c1_str.c_str());
+        pub_share.Z = libff::alt_bn128_Fq2::one();
 
-    pub_shares.push_back(pub_share);
-  }
+        pub_shares.push_back(pub_share);
+    }
 
-  libff::alt_bn128_G2 val = libff::alt_bn128_G2::zero();
-   for (int i = 0; i < _t; ++i) {
-    val = val + power(libff::alt_bn128_Fr(ind + 1), i) * pub_shares[i];
-   }
+    libff::alt_bn128_G2 val = libff::alt_bn128_G2::zero();
+    for (int i = 0; i < _t; ++i) {
+        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);
+    libff::alt_bn128_Fr sshare(tmp);
 
-  libff::alt_bn128_G2  val2 = sshare * libff::alt_bn128_G2::one();
+    libff::alt_bn128_G2 val2 = sshare * libff::alt_bn128_G2::one();
 
-  memset(public_shares, 0, strlen(public_shares));
-  strncpy(public_shares, tmp, strlen(tmp));
+    memset(public_shares, 0, strlen(public_shares));
+    strncpy(public_shares, tmp, strlen(tmp));
 
-  val.to_affine_coordinates();
-  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());
+    val.to_affine_coordinates();
+    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());
 
-  return (val == sshare * libff::alt_bn128_G2::one());
+    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);
-  if (mpz_set_str(skey, skey_hex, 16) == -1) {
-    mpz_clear(skey);
-    return 1;
-  }
 
-  char skey_dec[mpz_sizeinbase (skey, 10) + 2];
-  mpz_get_str(skey_dec, 10, skey);
+    mpz_t skey;
+    mpz_init(skey);
+    if (mpz_set_str(skey, skey_hex, 16) == -1) {
+        mpz_clear(skey);
+        return 1;
+    }
+
+    char skey_dec[mpz_sizeinbase(skey, 10) + 2];
+    mpz_get_str(skey_dec, 10, skey);
 
-  libff::alt_bn128_Fr bls_skey(skey_dec);
+    libff::alt_bn128_Fr bls_skey(skey_dec);
 
-  libff::alt_bn128_G2 public_key = bls_skey * libff::alt_bn128_G2::one();
-  public_key.to_affine_coordinates();
+    libff::alt_bn128_G2 public_key = bls_skey * libff::alt_bn128_G2::one();
+    public_key.to_affine_coordinates();
 
-  string result = ConvertG2ToString(public_key);
+    string result = ConvertG2ToString(public_key);
 
-  strncpy(pub_key, result.c_str(), result.length());
+    strncpy(pub_key, result.c_str(), result.length());
 
-  mpz_clear(skey);
+    mpz_clear(skey);
 
-  return 0;
+    return 0;
 }

secure_enclave/EnclaveCommon.cpp

@@ -36,66 +36,101 @@
 
 using namespace std;
 
-thread_local  uint8_t decryptedDkgPoly[DKG_BUFER_LENGTH];
-
-uint8_t* getThreadLocalDecryptedDkgPoly() {
+thread_local uint8_t decryptedDkgPoly[DKG_BUFER_LENGTH];
 
+uint8_t *getThreadLocalDecryptedDkgPoly() {
     return decryptedDkgPoly;
 }
 
 
 string *stringFromKey(libff::alt_bn128_Fr *_key) {
-    mpz_t t;
-    mpz_init(t);
+    try {
+        mpz_t t;
+        mpz_init(t);
 
-    _key->as_bigint().to_mpz(t);
+        _key->as_bigint().to_mpz(t);
 
-    char arr[mpz_sizeinbase(t, 10) + 2];
+        char arr[mpz_sizeinbase(t, 10) + 2];
 
-    char *tmp = mpz_get_str(arr, 10, t);
-    mpz_clear(t);
+        char *tmp = mpz_get_str(arr, 10, t);
+        mpz_clear(t);
 
-    return new string(tmp);
+        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) {
-    mpz_t t;
-    mpz_init(t);
+    try {
+        mpz_t t;
+        mpz_init(t);
 
-    _fq->as_bigint().to_mpz(t);
+        _fq->as_bigint().to_mpz(t);
 
-    char arr[mpz_sizeinbase(t, 10) + 2];
+        char arr[mpz_sizeinbase(t, 10) + 2];
 
-    char *tmp = mpz_get_str(arr, 10, t);
-    mpz_clear(t);
+        char *tmp = mpz_get_str(arr, 10, t);
+        mpz_clear(t);
 
-    return new string(tmp);
+        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) {
-    _g1->to_affine_coordinates();
 
-    auto sX = stringFromFq(&_g1->X);
-    auto sY = stringFromFq(&_g1->Y);
+    try {
+        _g1->to_affine_coordinates();
 
-    auto sG1 = new string(*sX + ":" + *sY);
+        auto sX = stringFromFq(&_g1->X);
+        auto sY = stringFromFq(&_g1->Y);
 
-    delete (sX);
-    delete (sY);
+        auto sG1 = new string(*sX + ":" + *sY);
 
-    return sG1;
-}
+        delete (sX);
+        delete (sY);
 
-libff::alt_bn128_Fr *keyFromString(const char *_keyStringHex) {
-    mpz_t skey;
-    mpz_init(skey);
-    mpz_set_str(skey, _keyStringHex, 16);
+        return sG1;
 
-    char skey_dec[mpz_sizeinbase (skey, 10) + 2];
-    mpz_get_str(skey_dec, 10, skey);
-    mpz_clear(skey);
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return nullptr;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return nullptr;
+    }
 
-    return new libff::alt_bn128_Fr(skey_dec);
+}
+
+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);
+
+        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,37 +143,47 @@ void enclave_init() {
 }
 
 bool enclave_sign(const char *_keyString, const char *_hashXString, const char *_hashYString,
-          char* sig) {
-    auto key = keyFromString(_keyString);
+                  char *sig) {
+    try {
+        auto key = keyFromString(_keyString);
 
-    if (key == nullptr) {
-        throw exception();
-    }
+        if (key == nullptr) {
+            throw invalid_argument("Null key");
+        }
 
-    libff::alt_bn128_Fq hashX(_hashXString);
-    libff::alt_bn128_Fq hashY(_hashYString);
-    libff::alt_bn128_Fq hashZ = 1;
+        libff::alt_bn128_Fq hashX(_hashXString);
+        libff::alt_bn128_Fq hashY(_hashYString);
+        libff::alt_bn128_Fq hashZ = 1;
 
-    libff::alt_bn128_G1 hash(hashX, hashY, hashZ);
+        libff::alt_bn128_G1 hash(hashX, hashY, hashZ);
 
-    libff::alt_bn128_G1 sign = key->as_bigint() * hash;
+        libff::alt_bn128_G1 sign = key->as_bigint() * hash;
 
-    delete key;
+        delete key;
 
-    sign.to_affine_coordinates();
+        sign.to_affine_coordinates();
 
-    auto r = stringFromG1(&sign);
+        auto r = stringFromG1(&sign);
 
-    memset(sig, 0, BUF_LEN);
+        memset(sig, 0, BUF_LEN);
 
-    strncpy(sig, r->c_str(), BUF_LEN);
+        strncpy(sig, r->c_str(), BUF_LEN);
 
-    delete r;
+        delete r;
+
+        return true;
+
+    } catch (exception &e) {
+        LOG_ERROR(e.what());
+        return false;
+    } catch (...) {
+        LOG_ERROR("Unknown throwable");
+        return false;
+    }
 
-    return true;
 }
 
-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'};
 
@@ -151,17 +196,17 @@ void  carray2Hex(const unsigned char *d, int _len, char* _hexArray) {
 }
 
 int char2int(char _input) {
-  if (_input >= '0' && _input <= '9')
-    return _input - '0';
-  if (_input >= 'A' && _input <= 'F')
-    return _input - 'A' + 10;
-  if (_input >= 'a' && _input <= 'f')
-    return _input - 'a' + 10;
-  return -1;
+    if (_input >= '0' && _input <= '9')
+        return _input - '0';
+    if (_input >= 'A' && _input <= 'F')
+        return _input - 'A' + 10;
+    if (_input >= 'a' && _input <= 'f')
+        return _input - 'a' + 10;
+    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,34 +228,36 @@ bool hex2carray2(const char * _hex, uint64_t  *_bin_len,
     return true;
 }
 
-bool hex2carray(const char * _hex, uint64_t  *_bin_len,
-                uint8_t* _bin ) {
-  int len = strnlen(_hex, 2 * BUF_LEN);
+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)
-    return false;
+    if (len == 0 && len % 2 == 1)
+        return false;
 
-  *_bin_len = len / 2;
+    *_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]);
+    for (int i = 0; i < len / 2; i++) {
+        int high = char2int((char) _hex[i * 2]);
+        int low = char2int((char) _hex[i * 2 + 1]);
 
-    if (high < 0 || low < 0) {
-      return false;
-    }
+        if (high < 0 || low < 0) {
+            return false;
+        }
 
-    _bin[i] = (unsigned char) (high * 16 + low);
-  }
+        _bin[i] = (unsigned char) (high * 16 + low);
+    }
 
-  return true;
+    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);
 };