Fix test

BLSCrypto.cpp

@@ -306,7 +306,7 @@ bool sign_aes(const char* _encryptedKeyHex, const char* _hashHex, size_t _t, siz
 bool bls_sign(const char* _encryptedKeyHex, const char* _hashHex, size_t _t, size_t _n, size_t _signerIndex,
               char* _sig) {
 
-  if (!is_aes){
+  if (!encryptKeys){
     return sign(_encryptedKeyHex, _hashHex, _t, _n, _signerIndex, _sig);
   }
   else{
@@ -326,7 +326,7 @@ char* encryptBLSKeyShare2Hex(int *errStatus, char *err_string, const char *_key)
     //status = encrypt_key(eid, errStatus, errMsg, keyArray, encryptedKey, &encryptedLen);
     status = encrypt_key_aes(eid, errStatus, errMsg->data(), keyArray->data(), encryptedKey->data(), &encryptedLen);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("errStatus is {}",*errStatus);
       spdlog::info(" errMsg is ", errMsg->data() );
     }

DKGCrypto.cpp

@@ -83,7 +83,7 @@ string gen_dkg_poly( int _t){
 
     uint32_t enc_len = 0;
 
-    if (!is_aes)
+    if (!encryptKeys)
       status = gen_dkg_secret (eid, &err_status, errMsg.data(), encrypted_dkg_secret.data(), &enc_len, _t);
     else
       status = gen_dkg_secret_aes (eid, &err_status, errMsg.data(), encrypted_dkg_secret.data(), &enc_len, _t);
@@ -91,13 +91,13 @@ string gen_dkg_poly( int _t){
         throw RPCException(-666, errMsg.data() ) ;
     }
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("gen_dkg_secret, status {}", err_status, " err msg ", errMsg.data());
       spdlog::info("in DKGCrypto encr len is {}", enc_len);
     }
 
     uint64_t length = DKG_MAX_SEALED_LEN;
-    if (is_aes){
+    if (encryptKeys){
       length = enc_len;
     }
 
@@ -118,7 +118,7 @@ vector <vector<string>> get_verif_vect(const char* encryptedPolyHex, int t, int
   //char errMsg1[BUF_LEN];
   int err_status = 0;
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     // cerr << "got encr poly " << encryptedPolyHex << endl;
     spdlog::info("got encr poly size {}", char_traits<char>::length(encryptedPolyHex));
   }
@@ -137,7 +137,7 @@ vector <vector<string>> get_verif_vect(const char* encryptedPolyHex, int t, int
       throw RPCException(INVALID_HEX, "Invalid encryptedPolyHex");
   }
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     //cerr << "hex_encr_poly is " << encryptedPolyHex << std::endl;
     spdlog::info("hex_encr_poly length is {}", strlen(encryptedPolyHex));
     spdlog::info("enc len {}", enc_len);
@@ -148,7 +148,7 @@ vector <vector<string>> get_verif_vect(const char* encryptedPolyHex, int t, int
 
   uint32_t len = 0;
 
-  if (!is_aes)
+  if (!encryptKeys)
     status = get_public_shares(eid, &err_status, errMsg1, encr_dkg_poly, len, public_shares, t, n);
   else {
 
@@ -158,7 +158,7 @@ vector <vector<string>> get_verif_vect(const char* encryptedPolyHex, int t, int
     throw RPCException(-666, errMsg1 );
   }
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("err msg is {}", errMsg1);
 
     spdlog::info("public_shares:");
@@ -200,7 +200,7 @@ string get_secret_shares(const string& polyName, const char* encryptedPolyHex, c
 
   std::cerr << "enc_len is " << enc_len << std::endl;
 
-  if (!is_aes)
+  if (!encryptKeys)
     status = set_encrypted_dkg_poly(eid, &err_status, errMsg1, encr_dkg_poly);
   else
     status = set_encrypted_dkg_poly_aes(eid, &err_status, errMsg1, encr_dkg_poly, &enc_len);
@@ -226,11 +226,11 @@ string get_secret_shares(const string& polyName, const char* encryptedPolyHex, c
     char pubKeyB[129];
     strncpy(pubKeyB, pub_keyB.c_str(), 128);
     pubKeyB[128] = 0;
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("pubKeyB is {}", pub_keyB);
     }
 
-    if (!is_aes)
+    if (!encryptKeys)
       get_encr_sshare(eid, &err_status, errMsg1, encrypted_skey, &dec_len,
                    cur_share, s_shareG2, pubKeyB, t, n, i + 1 );
     else
@@ -239,14 +239,14 @@ string get_secret_shares(const string& polyName, const char* encryptedPolyHex, c
     if (err_status != 0){
       throw RPCException(-666, errMsg1);
     }
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("cur_share is {}", cur_share);
     }
 
     result += cur_share;
 
     //uint32_t enc_len = BUF_LEN;
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("dec len is {}", dec_len);
     }
 
@@ -257,17 +257,17 @@ string get_secret_shares(const string& polyName, const char* encryptedPolyHex, c
     string DHKey_name = "DKG_DH_KEY_" + polyName + "_" + to_string(i) + ":";
 
     cerr << "hexEncr DH Key: " << hexEncrKey << endl;
-    writeDataToDB(DHKey_name, hexEncrKey);
+    SGXWalletServer::writeDataToDB(DHKey_name, hexEncrKey);
 
     string shareG2_name = "shareG2_" + polyName + "_" + to_string(i) + ":";
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("name to write to db is {}", DHKey_name);
       spdlog::info("name to write to db is {}", shareG2_name);
       spdlog::info("s_shareG2: {}", s_shareG2);
     }
-    writeDataToDB(shareG2_name, s_shareG2);
+    SGXWalletServer::writeDataToDB(shareG2_name, s_shareG2);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("errMsg: {}", errMsg1);
       // cerr << "iteration " << i <<" result length is " << result.length() << endl ;
       // cerr << "iteration " << i <<" share length is " << strlen(cur_share) << endl;
@@ -295,7 +295,7 @@ bool VerifyShares(const char* publicShares, const char* encr_sshare, const char
         throw RPCException(INVALID_HEX, "Invalid encryptedPolyHex");
     }
     int result;
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       cerr << "encryptedKeyHex " << encryptedKeyHex << endl;
       cerr << "dec_key_len " << dec_key_len << endl;
       cerr << "encr_sshare length is " << strlen(encr_sshare) << endl;
@@ -307,7 +307,7 @@ bool VerifyShares(const char* publicShares, const char* encr_sshare, const char
     strncpy(pshares, publicShares, strlen(publicShares) );
 
 
-    if (!is_aes)
+    if (!encryptKeys)
       dkg_verification(eid, &err_status, errMsg1, pshares, encr_sshare, encr_key, dec_key_len, t, ind, &result);
     else
       dkg_verification_aes(eid, &err_status, errMsg1, pshares, encr_sshare, encr_key, dec_key_len, t, ind, &result);
@@ -316,7 +316,7 @@ bool VerifyShares(const char* publicShares, const char* encr_sshare, const char
       throw RPCException(INVALID_HEX, "Invalid public shares");
     }
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("errMsg1: {}", errMsg1);
       spdlog::info("result is: {}", result);
     }
@@ -327,7 +327,7 @@ bool VerifyShares(const char* publicShares, const char* encr_sshare, const char
 }
 
 bool CreateBLSShare( const string& blsKeyName, const char * s_shares, const char * encryptedKeyHex){
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("ENTER CreateBLSShare");
   }
  // char* errMsg1 = (char*) calloc(1024,1);
@@ -346,7 +346,7 @@ bool CreateBLSShare( const string& blsKeyName, const char * s_shares, const char
   uint32_t enc_bls_len = 0;
 
   //cerr << "BEFORE create_bls_key IN ENCLAVE " << endl;
-  if (!is_aes)
+  if (!encryptKeys)
     create_bls_key(eid, &err_status, errMsg1, s_shares, encr_key, dec_key_len, encr_bls_key, &enc_bls_len);
   else
     create_bls_key_aes(eid, &err_status, errMsg1, s_shares, encr_key, dec_key_len, encr_bls_key, &enc_bls_len);
@@ -365,8 +365,8 @@ bool CreateBLSShare( const string& blsKeyName, const char * s_shares, const char
       //cerr << "enc_bls_len " << enc_bls_len << endl;
     carray2Hex(encr_bls_key, enc_bls_len, hexBLSKey);
    // cerr << "BEFORE WRITE BLS KEY TO DB" << endl;
-    writeDataToDB(blsKeyName, hexBLSKey);
-    if (DEBUG_PRINT) {
+    SGXWalletServer::writeDataToDB(blsKeyName, hexBLSKey);
+    if (printDebugInfo) {
       spdlog::info("hexBLSKey length is {}", char_traits<char>::length(hexBLSKey));
       spdlog::info("bls key {}", blsKeyName, " is ", hexBLSKey );
     }
@@ -389,11 +389,11 @@ vector<string> GetBLSPubKey(const char * encryptedKeyHex){
     }
 
     char pub_key[320];
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("dec_key_len is {}", dec_key_len);
     }
 
-    if (!is_aes)
+    if (!encryptKeys)
       get_bls_pub_key(eid, &err_status, errMsg1, encr_key, dec_key_len, pub_key);
     else
       get_bls_pub_key_aes(eid, &err_status, errMsg1, encr_key, dec_key_len, pub_key);
@@ -403,7 +403,7 @@ vector<string> GetBLSPubKey(const char * encryptedKeyHex){
     }
     vector<string> pub_key_vect = SplitString(pub_key, ':');
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("errMsg1 is {}", errMsg1);
       spdlog::info("pub key is ");
       for (int i = 0; i < 4; i++)
@@ -418,8 +418,8 @@ string decrypt_DHKey(const string& polyName, int ind){
   int err_status = 0;
 
   string DH_key_name = polyName + "_" + to_string(ind) + ":";
-  shared_ptr<string> hexEncrKey_ptr = readFromDb(DH_key_name, "DKG_DH_KEY_");
-  if (DEBUG_PRINT) {
+  shared_ptr<string> hexEncrKey_ptr = SGXWalletServer::readFromDb(DH_key_name, "DKG_DH_KEY_");
+  if (printDebugInfo) {
     spdlog::info("encr DH key is {}", *hexEncrKey_ptr);
   }
 
@@ -430,14 +430,14 @@ string decrypt_DHKey(const string& polyName, int ind){
   if (!hex2carray(hexEncrKey_ptr->c_str(), &DH_enc_len, encrypted_DHkey)){
      throw RPCException(INVALID_HEX, "Invalid hexEncrKey");
   }
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("encr DH key length is {}", DH_enc_len);
     spdlog::info("hex encr DH key length is {}", hexEncrKey_ptr->length());
   }
 
   char DHKey[ECDSA_SKEY_LEN];
 
-  if ( !is_aes)
+  if ( !encryptKeys)
     decrypt_key(eid, &err_status, errMsg1.data(), encrypted_DHkey, DH_enc_len, DHKey);
   else
     decrypt_key_aes(eid, &err_status, errMsg1.data(), encrypted_DHkey, DH_enc_len, DHKey);

ECDSACrypto.cpp

@@ -51,7 +51,7 @@ std::vector<std::string> gen_ecdsa_key(){
   char *pub_key_y = (char *)calloc(1024, 1);
   uint32_t enc_len = 0;
 
-  if ( !is_aes)
+  if ( !encryptKeys)
      status = generate_ecdsa_key(eid, &err_status, errMsg, encr_pr_key, &enc_len, pub_key_x, pub_key_y );
   else
      status = generate_ecdsa_key_aes(eid, &err_status, errMsg, encr_pr_key, &enc_len, pub_key_x, pub_key_y );
@@ -61,7 +61,7 @@ std::vector<std::string> gen_ecdsa_key(){
     throw RPCException(status, errMsg) ;
   }
   std::vector<std::string> keys(3);
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     std::cerr << "account key is " << errMsg << std::endl;
     std::cerr << "enc_len is " << enc_len << std::endl;
    // std::cerr << "enc_key is "  << std::endl;
@@ -77,7 +77,7 @@ std::vector<std::string> gen_ecdsa_key(){
 
 
   unsigned long seed = rand_gen();
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("seed is {}", seed);
     std::cerr << "strlen is " << strlen(hexEncrKey) << std::endl;
   }
@@ -122,7 +122,7 @@ std::string get_ecdsa_pubkey(const char* encryptedKeyHex){
     throw RPCException(INVALID_HEX, "Invalid encryptedKeyHex");
   }
 
-  if ( !is_aes)
+  if ( !encryptKeys)
    status = get_public_ecdsa_key(eid, &err_status, errMsg, encr_pr_key, enc_len, pub_key_x, pub_key_y );
   else status = get_public_ecdsa_key_aes(eid, &err_status, errMsg, encr_pr_key, enc_len, pub_key_x, pub_key_y );
   if (err_status != 0){
@@ -130,7 +130,7 @@ std::string get_ecdsa_pubkey(const char* encryptedKeyHex){
   }
   std::string pubKey = std::string(pub_key_x) + std::string(pub_key_y);//concatPubKeyWith0x(pub_key_x, pub_key_y);//
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("enc_len is {}", enc_len);
     spdlog::info("pubkey is {}", pubKey);
     spdlog::info("pubkey length is {}", pubKey.length());
@@ -162,20 +162,20 @@ std::vector<std::string> ecdsa_sign_hash(const char* encryptedKeyHex, const char
       throw RPCException(INVALID_HEX, "Invalid encryptedKeyHex");
   }
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("encryptedKeyHex: {}", encryptedKeyHex);
     spdlog::info("HASH: {}", hashHex);
     spdlog::info("encrypted len: {}", dec_len);
   }
 
-  if (!is_aes)
+  if (!encryptKeys)
    status = ecdsa_sign1(eid, &err_status, errMsg, encr_key, ECDSA_ENCR_LEN, (unsigned char*)hashHex, signature_r, signature_s, &signature_v, base );
   else status = ecdsa_sign_aes(eid, &err_status, errMsg, encr_key, dec_len, (unsigned char*)hashHex, signature_r, signature_s, &signature_v, base );
   if ( err_status != 0){
     throw RPCException(-666, errMsg ) ;
   }
 
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
     spdlog::info("signature r in  ecdsa_sign_hash: {}", signature_r);
     spdlog::info("signature s in  ecdsa_sign_hash: {}", signature_s);
   }

LevelDB.cpp

@@ -62,7 +62,7 @@ std::shared_ptr<string> LevelDB::readString(const string &_key) {
 
     auto status = db->Get(readOptions, _key, &*result);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("key to read from db: {}",_key );
       //std::cerr << "key to read from db: " << _key << std::endl;
     }
@@ -83,7 +83,7 @@ void LevelDB::writeString(const string &_key, const string &_value) {
 
     throwExceptionOnError(status);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
         spdlog::info("written key: {}",_key );
        // std::cerr << "written key " << _key  << std::endl;
     }
@@ -100,7 +100,7 @@ void LevelDB::deleteDHDKGKey (const string &_key) {
 
     throwExceptionOnError(status);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("key deleted: {}",full_key );
       //std::cerr << "key deleted " << full_key << std::endl;
     }
@@ -130,7 +130,7 @@ void LevelDB::deleteKey(const string &_key){
 
     throwExceptionOnError(status);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("key deleted: {}",_key );
       // std::cerr << "key deleted " << _key << std::endl;
     }
@@ -219,7 +219,7 @@ void LevelDB::writeDataUnique(const string & Name, const string &value) {
   }
 
   writeString(key, value);
-  if (DEBUG_PRINT) {
+  if (printDebugInfo) {
       spdlog::info("{}",Name, " is written to db");
     //std::cerr << Name << " is written to db " << std::endl;
   }

SEKManager.cpp

@@ -231,7 +231,7 @@ void init_SEK(){
     gen_SEK();
   }
   else{
-    if (DEBUG_PRINT)
+    if (printDebugInfo)
       spdlog::info("going to set SEK from db" );
     set_SEK(encr_SEK_ptr);
   }

SGXRegistrationServer.cpp

@@ -46,44 +46,37 @@
 #include "spdlog/spdlog.h"
 #include "common.h"
 
-int DEBUG_PRINT = 0;
-int is_sgx_https = 1;
-int is_aes = 1;
+int printDebugInfo = 0;
+int useHTTPS = 1;
+int encryptKeys = 0;
 bool autoconfirm = false;
 
-SGXRegistrationServer *regs = nullptr;
-HttpServer *hs2 = nullptr;
-
-bool cert_created = false;
-
-void set_cert_created1(bool b){
-  sleep(10);
-  cert_created = b;
-}
+SGXRegistrationServer *registrationServer = nullptr;
+HttpServer *httpServer2 = nullptr;
 
 SGXRegistrationServer::SGXRegistrationServer(AbstractServerConnector &connector,
-                                 serverVersion_t type, bool auto_sign)
-    : AbstractRegServer(connector, type), is_cert_created(false), cert_auto_sign(auto_sign) {}
+                                             serverVersion_t type, bool _autoSign)
+        : AbstractRegServer(connector, type), isCertCreated(false), autoSign(_autoSign) {}
 
 
-Json::Value signCertificateImpl(const string& csr, bool auto_sign = false){
+Json::Value signCertificateImpl(const string &_csr, bool _autoSign = false) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
-  try{
+    try {
         spdlog::info("enter signCertificateImpl");
 
         string status = "1";
-    string hash = cryptlite::sha256::hash_hex(csr);
-    if ( !auto_sign) {
+        string hash = cryptlite::sha256::hash_hex(_csr);
+        if (!_autoSign) {
             string db_key = "CSR:HASH:" + hash;
-      LevelDB::getCsrStatusDb()->writeDataUnique(db_key, csr);
+            LevelDB::getCsrStatusDb()->writeDataUnique(db_key, _csr);
         }
 
-    if (auto_sign) {
+        if (_autoSign) {
             string csr_name = "cert/" + hash + ".csr";
             ofstream outfile(csr_name);
-      outfile << csr << endl;
+            outfile << _csr << endl;
             outfile.close();
             if (access(csr_name.c_str(), F_OK) != 0) {
                 throw RPCException(FILE_NOT_FOUND, "Csr does not exist");
@@ -91,11 +84,10 @@ Json::Value signCertificateImpl(const string& csr, bool auto_sign = false){
 
             string genCert = "cd cert && ./create_client_cert " + hash;
 
-      if (system(genCert.c_str()) == 0){
+            if (system(genCert.c_str()) == 0) {
                 spdlog::info("CLIENT CERTIFICATE IS SUCCESSFULLY GENERATED");
                 status = "0";
-      }
-      else{
+            } else {
                 spdlog::info("CLIENT CERTIFICATE GENERATION FAILED");
                 string status_db_key = "CSR:HASH:" + hash + "STATUS:";
                 LevelDB::getCsrStatusDb()->writeDataUnique(status_db_key, to_string(FAIL_TO_CREATE_CERTIFICATE));
@@ -120,19 +112,19 @@ Json::Value signCertificateImpl(const string& csr, bool auto_sign = false){
     return result;
 }
 
-Json::Value GetSertificateImpl(const string& hash){
+Json::Value GetSertificateImpl(const string &hash) {
     Json::Value result;
 
     string cert;
-  try{
+    try {
         string db_key = "CSR:HASH:" + hash + "STATUS:";
         shared_ptr<string> status_str_ptr = LevelDB::getCsrStatusDb()->readString(db_key);
-    if (status_str_ptr == nullptr){
+        if (status_str_ptr == nullptr) {
             throw RPCException(KEY_SHARE_DOES_NOT_EXIST, "Data with this name does not exist in csr db");
         }
         int status = atoi(status_str_ptr->c_str());
 
-    if ( status == 0){
+        if (status == 0) {
             string crt_name = "cert/" + hash + ".crt";
             //if (access(crt_name.c_str(), F_OK) == 0){
             ifstream infile(crt_name);
@@ -148,12 +140,11 @@ Json::Value GetSertificateImpl(const string& hash){
 
                 infile.close();
                 string remove_crt = "cd cert && rm -rf " + hash + ".crt && rm -rf " + hash + ".csr";
-          if(system(remove_crt.c_str()) == 0){
+                if (system(remove_crt.c_str()) == 0) {
                     //cerr << "cert removed" << endl;
                     spdlog::info(" cert removed ");
 
-          }
-          else{
+                } else {
                     spdlog::info(" cert was not removed ");
                 }
 
@@ -173,25 +164,24 @@ Json::Value GetSertificateImpl(const string& hash){
 }
 
 
-Json::Value SGXRegistrationServer::signCertificate(const string& csr){
+Json::Value SGXRegistrationServer::signCertificate(const string &csr) {
     spdlog::info("Enter signCertificate ");
     lock_guard<recursive_mutex> lock(m);
-  return signCertificateImpl(csr, cert_auto_sign);
+    return signCertificateImpl(csr, autoSign);
 }
 
-Json::Value SGXRegistrationServer::getCertificate(const string& hash){
+Json::Value SGXRegistrationServer::getCertificate(const string &hash) {
     lock_guard<recursive_mutex> lock(m);
     return GetSertificateImpl(hash);
 }
 
-void SGXRegistrationServer::set_cert_created(bool b){
+void SGXRegistrationServer::set_cert_created(bool b) {
     sleep(100);
-  is_cert_created = b;
+    isCertCreated = b;
 }
 
 
-
-int init_registration_server(bool sign_automatically) {
+int initRegistrationServer(bool _autoSign) {
 
 //  string certPath = "cert/SGXCACertificate.crt";
 //  string keyPath = "cert/SGXCACertificate.key";
@@ -210,20 +200,19 @@ int init_registration_server(bool sign_automatically) {
 //    }
 //  }
 
-  hs2 = new HttpServer(BASE_PORT + 1);
-  regs = new SGXRegistrationServer(*hs2,
-                                 JSONRPC_SERVER_V2, sign_automatically); // hybrid server (json-rpc 1.0 & 2.0)
+    httpServer2 = new HttpServer(BASE_PORT + 1);
+    registrationServer = new SGXRegistrationServer(*httpServer2,
+                                                   JSONRPC_SERVER_V2,
+                                                   _autoSign); // hybrid server (json-rpc 1.0 & 2.0)
 
-  if (!regs->StartListening()) {
+    if (!registrationServer->StartListening()) {
         spdlog::info("Registration server could not start listening");
         exit(-1);
-  }
-  else {
+    } else {
         spdlog::info("Registration server started on port {}", BASE_PORT + 1);
     }
 
 
-
     return 0;
 }
 

SGXRegistrationServer.h

@@ -33,14 +33,12 @@ using namespace std;
 
 class SGXRegistrationServer: public AbstractRegServer {
   std::recursive_mutex m;
-  bool is_cert_created;
-  bool cert_auto_sign;
-
-  //std::string hash;
+  bool isCertCreated;
+  bool autoSign;
 
 public:
 
-  SGXRegistrationServer(AbstractServerConnector &connector, serverVersion_t type, bool auto_sign = false);
+  SGXRegistrationServer(AbstractServerConnector &connector, serverVersion_t type, bool _autoSign = false);
 
   void set_cert_created(bool b);
 
@@ -50,7 +48,7 @@ public:
 };
 
 
-extern int init_registration_server(bool sign_automatically = false);
+extern int initRegistrationServer(bool _autoSign = false);
 
 
 

SGXWalletServer.cpp

@@ -46,27 +46,26 @@
 #include "common.h"
 
 
-
-bool isStringDec( string & str){
-  auto res = find_if_not(str.begin(), str.end(), [](char c)->bool{
+bool isStringDec(string &_str) {
+    auto res = find_if_not(_str.begin(), _str.end(), [](char c) -> bool {
         return isdigit(c);
     });
-  return !str.empty() && res == str.end();
+    return !_str.empty() && res == _str.end();
 }
 
 
 SGXWalletServer *s = nullptr;
-HttpServer *hs = nullptr;
+HttpServer *httpServer = nullptr;
 
-SGXWalletServer::SGXWalletServer(AbstractServerConnector &connector,
-                                 serverVersion_t type)
-        : AbstractStubServer(connector, type) {}
+SGXWalletServer::SGXWalletServer(AbstractServerConnector &_connector,
+                                 serverVersion_t _type)
+        : AbstractStubServer(_connector, _type) {}
 
-void debug_print(){
+void SGXWalletServer::printDB() {
     cout << "HERE ARE YOUR KEYS: " << endl;
-  class MyVisitor: public LevelDB::KeyVisitor {
+    class MyVisitor : public LevelDB::KeyVisitor {
     public:
-    virtual void visitDBKey(const char* _data){
+        virtual void visitDBKey(const char *_data) {
             cout << _data << endl;
         }
     };
@@ -76,21 +75,20 @@ void debug_print(){
     LevelDB::getLevelDb()->visitKeys(&v, 100000000);
 }
 
-int init_https_server(bool check_certs) {
+int SGXWalletServer::initHttpsServer(bool _checkCerts) {
 
     string rootCAPath = string(SGXDATA_FOLDER) + "cert_data/rootCA.pem";
     string keyCAPath = string(SGXDATA_FOLDER) + "cert_data/rootCA.key";
 
-  if (access(rootCAPath.c_str(), F_OK) != 0 || access(keyCAPath.c_str(), F_OK) != 0){
+    if (access(rootCAPath.c_str(), F_OK) != 0 || access(keyCAPath.c_str(), F_OK) != 0) {
         spdlog::info("YOU DO NOT HAVE ROOT CA CERTIFICATE");
         spdlog::info("ROOT CA CERTIFICATE IS GOING TO BE CREATED");
 
         string genRootCACert = "cd cert && ./create_CA";
 
-    if (system(genRootCACert.c_str()) == 0){
+        if (system(genRootCACert.c_str()) == 0) {
             spdlog::info("ROOT CA CERTIFICATE IS SUCCESSFULLY GENERATED");
-    }
-    else{
+        } else {
             spdlog::info("ROOT CA CERTIFICATE GENERATION FAILED");
             exit(-1);
         }
@@ -99,40 +97,38 @@ int init_https_server(bool check_certs) {
     string certPath = string(SGXDATA_FOLDER) + "cert_data/SGXServerCert.crt";
     string keyPath = string(SGXDATA_FOLDER) + "cert_data/SGXServerCert.key";
 
-  if (access(certPath.c_str(), F_OK) != 0 || access(certPath.c_str(), F_OK) != 0){
+    if (access(certPath.c_str(), F_OK) != 0 || access(certPath.c_str(), F_OK) != 0) {
         spdlog::info("YOU DO NOT HAVE SERVER CERTIFICATE");
         spdlog::info("SERVER CERTIFICATE IS GOING TO BE CREATED");
 
         string genCert = "cd cert && ./create_server_cert";
 
-    if (system(genCert.c_str()) == 0){
+        if (system(genCert.c_str()) == 0) {
             spdlog::info("SERVER CERTIFICATE IS SUCCESSFULLY GENERATED");
-    }
-    else{
+        } else {
             spdlog::info("SERVER CERTIFICATE GENERATION FAILED");
             exit(-1);
         }
     }
 
-  hs = new HttpServer(BASE_PORT, certPath, keyPath, rootCAPath, check_certs, 64);
-  s = new SGXWalletServer(*hs,
+    httpServer = new HttpServer(BASE_PORT, certPath, keyPath, rootCAPath, _checkCerts, 64);
+    s = new SGXWalletServer(*httpServer,
                             JSONRPC_SERVER_V2); // hybrid server (json-rpc 1.0 & 2.0)
 
     if (!s->StartListening()) {
         spdlog::info("SGX Server could not start listening");
         exit(-1);
-  }
-  else{
+    } else {
         spdlog::info("SGX Server started on port {}", BASE_PORT);
     }
     return 0;
 }
 
 
-int init_http_server() { //without ssl
+int SGXWalletServer::initHttpServer() { //without ssl
 
-  hs = new HttpServer(BASE_PORT + 3);
-  s = new SGXWalletServer(*hs,
+    httpServer = new HttpServer(BASE_PORT + 3);
+    s = new SGXWalletServer(*httpServer,
                             JSONRPC_SERVER_V2); // hybrid server (json-rpc 1.0 & 2.0)
     if (!s->StartListening()) {
         spdlog::info("Server could not start listening");
@@ -142,7 +138,7 @@ int init_http_server() { //without ssl
 }
 
 Json::Value
-importBLSKeyShareImpl(const string &_keyShare, const string &_keyShareName, int t, int n, int index) {
+SGXWalletServer::importBLSKeyShareImpl(const string &_keyShare, const string &_keyShareName, int t, int n, int index) {
     Json::Value result;
 
     int errStatus = UNKNOWN_ERROR;
@@ -155,9 +151,7 @@ importBLSKeyShareImpl(const string &_keyShare, const string &_keyShareName, int
     char *encryptedKeyShareHex = nullptr;
 
     try {
-//        if ( !checkName(_keyShare, "BLS_KEY")){
-//          throw RPCException(INVALID_POLY_NAME, "Invalid BLSKey name");
-//        }
+
         encryptedKeyShareHex = encryptBLSKeyShare2Hex(&errStatus, errMsg, _keyShare.c_str());
 
         if (encryptedKeyShareHex == nullptr) {
@@ -170,7 +164,7 @@ importBLSKeyShareImpl(const string &_keyShare, const string &_keyShareName, int
 
         result["encryptedKeyShare"] = string(encryptedKeyShareHex);
 
-        writeKeyShare(_keyShareName, encryptedKeyShareHex, index, n , t);
+        writeKeyShare(_keyShareName, encryptedKeyShareHex, index, n, t);
 
     } catch (RPCException &_e) {
         result["status"] = _e.status;
@@ -184,7 +178,8 @@ importBLSKeyShareImpl(const string &_keyShare, const string &_keyShareName, int
     return result;
 }
 
-Json::Value blsSignMessageHashImpl(const string &keyShareName, const string &messageHash,int t, int n, int signerIndex) {
+Json::Value
+SGXWalletServer::blsSignMessageHashImpl(const string &keyShareName, const string &messageHash, int t, int n, int signerIndex) {
     Json::Value result;
     result["status"] = -1;
     result["errorMessage"] = "Unknown server error";
@@ -192,21 +187,21 @@ Json::Value blsSignMessageHashImpl(const string &keyShareName, const string &mes
 
     char *signature = (char *) calloc(BUF_LEN, 1);
 
-    shared_ptr <string> value = nullptr;
+    shared_ptr<string> value = nullptr;
 
     try {
-      if ( !checkName(keyShareName, "BLS_KEY")){
+        if (!checkName(keyShareName, "BLS_KEY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid BLSKey name");
         }
         string cutHash = messageHash;
-      if (cutHash[0] == '0' && (cutHash[1] == 'x'||cutHash[1] == 'X')){
+        if (cutHash[0] == '0' && (cutHash[1] == 'x' || cutHash[1] == 'X')) {
             cutHash.erase(cutHash.begin(), cutHash.begin() + 2);
         }
-      while (cutHash[0] == '0'){
+        while (cutHash[0] == '0') {
             cutHash.erase(cutHash.begin(), cutHash.begin() + 1);
         }
 
-      if ( !checkHex(cutHash)){
+        if (!checkHex(cutHash)) {
             throw RPCException(INVALID_HEX, "Invalid hash");
         }
 
@@ -242,7 +237,7 @@ Json::Value blsSignMessageHashImpl(const string &keyShareName, const string &mes
 }
 
 
-Json::Value importECDSAKeyImpl(const string &key, const string &keyName) {
+Json::Value SGXWalletServer::importECDSAKeyImpl(const string &_key, const string &_keyName) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
@@ -251,7 +246,7 @@ Json::Value importECDSAKeyImpl(const string &key, const string &keyName) {
 }
 
 
-Json::Value generateECDSAKeyImpl() {
+Json::Value SGXWalletServer::generateECDSAKeyImpl() {
 
     Json::Value result;
     result["status"] = 0;
@@ -260,18 +255,18 @@ Json::Value generateECDSAKeyImpl() {
 
     spdlog::info("Calling method generateECDSAKey");
 
-    vector<string>keys;
+    vector<string> keys;
 
     try {
         keys = gen_ecdsa_key();
 
-        if (keys.size() == 0 ) {
+        if (keys.size() == 0) {
             throw RPCException(UNKNOWN_ERROR, "key was not generated");
         }
 
         string keyName = "NEK:" + keys.at(2);
 
-        if (DEBUG_PRINT) {
+        if (printDebugInfo) {
             spdlog::info("write encr key {}", keys.at(0));
             spdlog::info("keyname length is {}", keyName.length());
             spdlog::info("key name generated: {}", keyName);
@@ -292,7 +287,7 @@ Json::Value generateECDSAKeyImpl() {
     return result;
 }
 
-Json::Value renameECDSAKeyImpl(const string& KeyName, const string& tempKeyName){
+Json::Value SGXWalletServer::renameECDSAKeyImpl(const string &KeyName, const string &tempKeyName) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
@@ -300,21 +295,21 @@ Json::Value renameECDSAKeyImpl(const string& KeyName, const string& tempKeyName)
 
     try {
 
-    string prefix = tempKeyName.substr(0,8);
+        string prefix = tempKeyName.substr(0, 8);
         if (prefix != "tmp_NEK:") {
             throw RPCException(UNKNOWN_ERROR, "wrong temp key name");
         }
-    prefix = KeyName.substr(0,12);
+        prefix = KeyName.substr(0, 12);
         if (prefix != "NEK_NODE_ID:") {
             throw RPCException(UNKNOWN_ERROR, "wrong key name");
         }
         string postfix = KeyName.substr(12, KeyName.length());
-    if (!isStringDec(postfix)){
+        if (!isStringDec(postfix)) {
             throw RPCException(UNKNOWN_ERROR, "wrong key name");
         }
 
         shared_ptr<string> key_ptr = readFromDb(tempKeyName);
-    cerr << "new key name is " << KeyName <<endl;
+        cerr << "new key name is " << KeyName << endl;
         writeDataToDB(KeyName, *key_ptr);
         LevelDB::getLevelDb()->deleteTempNEK(tempKeyName);
 
@@ -328,7 +323,7 @@ Json::Value renameECDSAKeyImpl(const string& KeyName, const string& tempKeyName)
 }
 
 
-Json::Value ecdsaSignMessageHashImpl(int base, const string &_keyName, const string &messageHash) {
+Json::Value SGXWalletServer::ecdsaSignMessageHashImpl(int base, const string &_keyName, const string &messageHash) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
@@ -338,42 +333,42 @@ Json::Value ecdsaSignMessageHashImpl(int base, const string &_keyName, const str
 
     vector<string> sign_vect(3);
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
         spdlog::info("entered ecdsaSignMessageHashImpl {}", messageHash, "length {}", messageHash.length());
     }
 
     try {
 
         string cutHash = messageHash;
-      if (cutHash[0] == '0' && (cutHash[1] == 'x'||cutHash[1] == 'X')){
+        if (cutHash[0] == '0' && (cutHash[1] == 'x' || cutHash[1] == 'X')) {
             cutHash.erase(cutHash.begin(), cutHash.begin() + 2);
         }
-      while (cutHash[0] == '0'){
+        while (cutHash[0] == '0') {
             cutHash.erase(cutHash.begin(), cutHash.begin() + 1);
         }
 
-      if (DEBUG_PRINT) {
+        if (printDebugInfo) {
             spdlog::info("Hash handled  {}", cutHash);
         }
 
-      if ( !checkECDSAKeyName(_keyName)){
+        if (!checkECDSAKeyName(_keyName)) {
             throw RPCException(INVALID_ECDSA_KEY_NAME, "Invalid ECDSA key name");
         }
-      if ( !checkHex(cutHash)){
+        if (!checkHex(cutHash)) {
             throw RPCException(INVALID_HEX, "Invalid hash");
         }
-      if ( base <= 0 || base > 32){
+        if (base <= 0 || base > 32) {
             throw RPCException(-22, "Invalid base");
         }
 
-      shared_ptr<string> key_ptr = readFromDb(_keyName,"");
+        shared_ptr<string> key_ptr = readFromDb(_keyName, "");
 
         sign_vect = ecdsa_sign_hash(key_ptr->c_str(), cutHash.c_str(), base);
-      if (sign_vect.size() != 3 ){
+        if (sign_vect.size() != 3) {
             throw RPCException(INVALID_ECSDA_SIGNATURE, "Invalid ecdsa signature");
         }
 
-      if (DEBUG_PRINT) {
+        if (printDebugInfo) {
             spdlog::info("got signature_s  {}", sign_vect.at(2));
         }
 
@@ -390,7 +385,7 @@ Json::Value ecdsaSignMessageHashImpl(int base, const string &_keyName, const str
     return result;
 }
 
-Json::Value getPublicECDSAKeyImpl(const string& keyName){
+Json::Value SGXWalletServer::getPublicECDSAKeyImpl(const string &keyName) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
@@ -401,12 +396,12 @@ Json::Value getPublicECDSAKeyImpl(const string& keyName){
     string Pkey;
 
     try {
-         if ( !checkECDSAKeyName(keyName)){
+        if (!checkECDSAKeyName(keyName)) {
             throw RPCException(INVALID_ECDSA_KEY_NAME, "Invalid ECDSA key name");
         }
         shared_ptr<string> key_ptr = readFromDb(keyName);
-         Pkey = get_ecdsa_pubkey( key_ptr->c_str());
-         if (DEBUG_PRINT) {
+        Pkey = get_ecdsa_pubkey(key_ptr->c_str());
+        if (printDebugInfo) {
             spdlog::info("PublicKey {}", Pkey);
             spdlog::info("PublicKey length {}", Pkey.length());
         }
@@ -420,7 +415,7 @@ Json::Value getPublicECDSAKeyImpl(const string& keyName){
     return result;
 }
 
-Json::Value generateDKGPolyImpl(const string& polyName, int t) {
+Json::Value SGXWalletServer::generateDKGPolyImpl(const string &polyName, int t) {
 
     Json::Value result;
     result["status"] = 0;
@@ -430,10 +425,11 @@ Json::Value generateDKGPolyImpl(const string& polyName, int t) {
     string encrPolyHex;
 
     try {
-      if ( !checkName(polyName, "POLY")){
-        throw RPCException(INVALID_POLY_NAME, "Invalid polynomial name, it should be like POLY:SCHAIN_ID:1:NODE_ID:1:DKG_ID:1");
+        if (!checkName(polyName, "POLY")) {
+            throw RPCException(INVALID_POLY_NAME,
+                               "Invalid polynomial name, it should be like POLY:SCHAIN_ID:1:NODE_ID:1:DKG_ID:1");
         }
-      if ( t <= 0 || t > 32){
+        if (t <= 0 || t > 32) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid parameter t ");
         }
         encrPolyHex = gen_dkg_poly(t);
@@ -449,18 +445,18 @@ Json::Value generateDKGPolyImpl(const string& polyName, int t) {
     return result;
 }
 
-Json::Value getVerificationVectorImpl(const string& polyName, int t, int n) {
+Json::Value SGXWalletServer::getVerificationVectorImpl(const string &polyName, int t, int n) {
 
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
 
-  vector <vector<string>> verifVector;
+    vector<vector<string>> verifVector;
     try {
-    if ( !checkName(polyName, "POLY")){
+        if (!checkName(polyName, "POLY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid polynomial name");
         }
-    if( !check_n_t(t, n)){
+        if (!check_n_t(t, n)) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid parameters: n or t ");
         }
 
@@ -469,9 +465,9 @@ Json::Value getVerificationVectorImpl(const string& polyName, int t, int n) {
         verifVector = get_verif_vect(encr_poly_ptr->c_str(), t, n);
         //cerr << "verif vect size " << verifVector.size() << endl;
 
-    for ( int i = 0; i < t; i++){
+        for (int i = 0; i < t; i++) {
             vector<string> cur_coef = verifVector.at(i);
-      for ( int j = 0; j < 4; j++ ){
+            for (int j = 0; j < 4; j++) {
                 result["verificationVector"][i][j] = cur_coef.at(j);
             }
         }
@@ -486,29 +482,29 @@ Json::Value getVerificationVectorImpl(const string& polyName, int t, int n) {
     return result;
 }
 
-Json::Value getSecretShareImpl(const string& polyName, const Json::Value& publicKeys, int t, int n){
+Json::Value SGXWalletServer::getSecretShareImpl(const string &polyName, const Json::Value &publicKeys, int t, int n) {
     spdlog::info("enter getSecretShareImpl");
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
 
     try {
-        if (publicKeys.size() != (uint64_t) n){
+        if (publicKeys.size() != (uint64_t) n) {
             throw RPCException(INVALID_DKG_PARAMS, "wrong number of public keys");
         }
-        if ( !checkName(polyName, "POLY")){
+        if (!checkName(polyName, "POLY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid polynomial name");
         }
-        if( !check_n_t(t, n)){
+        if (!check_n_t(t, n)) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid DKG parameters: n or t ");
         }
 
         shared_ptr<string> encr_poly_ptr = readFromDb(polyName);
 
         vector<string> pubKeys_vect;
-        for ( int i = 0; i < n ; i++) {
-            std::cerr << "publicKeys " << i << " is " << publicKeys[i].asString() <<std::endl;
-            if ( !checkHex(publicKeys[i].asString(), 64)){
+        for (int i = 0; i < n; i++) {
+            std::cerr << "publicKeys " << i << " is " << publicKeys[i].asString() << std::endl;
+            if (!checkHex(publicKeys[i].asString(), 64)) {
                 throw RPCException(INVALID_HEX, "Invalid public key");
             }
             pubKeys_vect.push_back(publicKeys[i].asString());
@@ -528,8 +524,8 @@ Json::Value getSecretShareImpl(const string& polyName, const Json::Value& public
     return result;
 }
 
-Json::Value dkgVerificationImpl(const string& publicShares, const string& ethKeyName,
-                                  const string& SecretShare, int t, int n, int ind){
+Json::Value SGXWalletServer::dkgVerificationImpl(const string &publicShares, const string &ethKeyName,
+                                const string &SecretShare, int t, int n, int ind) {
 
     spdlog::info("enter dkgVerificationImpl");
 
@@ -540,22 +536,22 @@ Json::Value dkgVerificationImpl(const string& publicShares, const string& ethKey
 
     try {
 
-    if ( !checkECDSAKeyName(ethKeyName)){
+        if (!checkECDSAKeyName(ethKeyName)) {
             throw RPCException(INVALID_ECDSA_KEY_NAME, "Invalid ECDSA key name");
         }
-    if( !check_n_t(t, n) || ind > n || ind < 0){
+        if (!check_n_t(t, n) || ind > n || ind < 0) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid DKG parameters: n or t ");
         }
-    if ( !checkHex(SecretShare, SECRET_SHARE_NUM_BYTES)){
+        if (!checkHex(SecretShare, SECRET_SHARE_NUM_BYTES)) {
             throw RPCException(INVALID_HEX, "Invalid Secret share");
         }
-    if (publicShares.length() != (uint64_t ) 256 * t){
+        if (publicShares.length() != (uint64_t) 256 * t) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid length of public shares");
         }
 
         shared_ptr<string> encryptedKeyHex_ptr = readFromDb(ethKeyName);
 
-    if ( !VerifyShares(publicShares.c_str(), SecretShare.c_str(), encryptedKeyHex_ptr->c_str(), t, n, ind )){
+        if (!VerifyShares(publicShares.c_str(), SecretShare.c_str(), encryptedKeyHex_ptr->c_str(), t, n, ind)) {
             result["result"] = false;
         }
 
@@ -569,7 +565,8 @@ Json::Value dkgVerificationImpl(const string& publicShares, const string& ethKey
     return result;
 }
 
-Json::Value createBLSPrivateKeyImpl(const string & blsKeyName, const string& ethKeyName, const string& polyName, const string & SecretShare, int t, int n){
+Json::Value SGXWalletServer::createBLSPrivateKeyImpl(const string &blsKeyName, const string &ethKeyName, const string &polyName,
+                                    const string &SecretShare, int t, int n) {
 
     spdlog::info("createBLSPrivateKeyImpl entered");
 
@@ -579,43 +576,42 @@ Json::Value createBLSPrivateKeyImpl(const string & blsKeyName, const string& eth
 
     try {
 
-    if (SecretShare.length() != (uint64_t ) n * 192){
+        if (SecretShare.length() != (uint64_t) n * 192) {
             spdlog::info("wrong length of secret shares - {}", SecretShare.length());
             spdlog::info("secret shares - {}", SecretShare);
             throw RPCException(INVALID_SECRET_SHARES_LENGTH, "Invalid secret share length");
         }
-    if ( !checkECDSAKeyName(ethKeyName)){
+        if (!checkECDSAKeyName(ethKeyName)) {
             throw RPCException(INVALID_ECDSA_KEY_NAME, "Invalid ECDSA key name");
         }
-    if ( !checkName(polyName, "POLY")){
+        if (!checkName(polyName, "POLY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid polynomial name");
         }
-    if ( !checkName(blsKeyName, "BLS_KEY")){
+        if (!checkName(blsKeyName, "BLS_KEY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid BLS key name");
         }
-    if( !check_n_t(t, n)){
+        if (!check_n_t(t, n)) {
             throw RPCException(INVALID_DKG_PARAMS, "Invalid DKG parameters: n or t ");
         }
         vector<string> sshares_vect;
-    if (DEBUG_PRINT) {
+        if (printDebugInfo) {
             spdlog::info("secret shares from json are - {}", SecretShare);
         }
 
         shared_ptr<string> encryptedKeyHex_ptr = readFromDb(ethKeyName);
 
         bool res = CreateBLSShare(blsKeyName, SecretShare.c_str(), encryptedKeyHex_ptr->c_str());
-     if (res){
+        if (res) {
             spdlog::info("BLS KEY SHARE CREATED ");
-     }
-     else {
+        } else {
             throw RPCException(-122, "Error while creating BLS key share");
         }
 
-     for ( int i = 0; i < n; i++){
+        for (int i = 0; i < n; i++) {
             string name = polyName + "_" + to_string(i) + ":";
-       LevelDB::getLevelDb() -> deleteDHDKGKey(name);
+            LevelDB::getLevelDb()->deleteDHDKGKey(name);
             string shareG2_name = "shareG2_" + polyName + "_" + to_string(i) + ":";
-       LevelDB::getLevelDb() -> deleteKey(shareG2_name);
+            LevelDB::getLevelDb()->deleteKey(shareG2_name);
         }
 
     } catch (RPCException &_e) {
@@ -628,25 +624,25 @@ Json::Value createBLSPrivateKeyImpl(const string & blsKeyName, const string& eth
     return result;
 }
 
-Json::Value getBLSPublicKeyShareImpl(const string & blsKeyName){
+Json::Value SGXWalletServer::getBLSPublicKeyShareImpl(const string &blsKeyName) {
 
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
 
     try {
-      if ( !checkName(blsKeyName, "BLS_KEY")){
+        if (!checkName(blsKeyName, "BLS_KEY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid BLSKey name");
         }
         shared_ptr<string> encryptedKeyHex_ptr = readFromDb(blsKeyName);
-      if (DEBUG_PRINT) {
+        if (printDebugInfo) {
             spdlog::info("encr_bls_key_share is {}", *encryptedKeyHex_ptr);
             spdlog::info("length is {}", encryptedKeyHex_ptr->length());
             //cerr << "encr_bls_key_share is " << *encryptedKeyHex_ptr << endl;
             // cerr << "length is " << encryptedKeyHex_ptr->length() << endl;
         }
         vector<string> public_key_vect = GetBLSPubKey(encryptedKeyHex_ptr->c_str());
-      for ( uint8_t i = 0; i < 4; i++) {
+        for (uint8_t i = 0; i < 4; i++) {
             result["blsPublicKeyShare"][i] = public_key_vect.at(i);
         }
 
@@ -661,12 +657,12 @@ Json::Value getBLSPublicKeyShareImpl(const string & blsKeyName){
     return result;
 }
 
-Json::Value complaintResponseImpl(const string& polyName, int ind){
+Json::Value SGXWalletServer::complaintResponseImpl(const string &polyName, int ind) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
     try {
-    if ( !checkName(polyName, "POLY")){
+        if (!checkName(polyName, "POLY")) {
             throw RPCException(INVALID_POLY_NAME, "Invalid polynomial name");
         }
         string shareG2_name = "shareG2_" + polyName + "_" + to_string(ind) + ":";
@@ -687,14 +683,14 @@ Json::Value complaintResponseImpl(const string& polyName, int ind){
 
 }
 
-Json::Value multG2Impl(const string& x){
+Json::Value SGXWalletServer::multG2Impl(const string &x) {
     Json::Value result;
     result["status"] = 0;
     result["errorMessage"] = "";
     try {
         spdlog::info("multG2Impl try ");
         vector<string> xG2_vect = mult_G2(x);
-        for ( uint8_t i = 0; i < 4; i++) {
+        for (uint8_t i = 0; i < 4; i++) {
             result["x*G2"][i] = xG2_vect.at(i);
         }
 
@@ -707,14 +703,14 @@ Json::Value multG2Impl(const string& x){
     return result;
 }
 
-Json::Value isPolyExistsImpl(const string& polyName){
+Json::Value SGXWalletServer::isPolyExistsImpl(const string &polyName) {
     Json::Value result;
     try {
         std::shared_ptr<std::string> poly_str_ptr = LevelDB::getLevelDb()->readString(polyName);
         result["IsExist"] = true;
         result["status"] = 0;
         result["errorMessage"] = "";
-    if (poly_str_ptr == nullptr){
+        if (poly_str_ptr == nullptr) {
             result["IsExist"] = false;
             result["status"] = 0;
             result["errorMessage"] = "";
@@ -729,7 +725,7 @@ Json::Value isPolyExistsImpl(const string& polyName){
     return result;
 }
 
-Json::Value getServerStatusImpl() {
+Json::Value SGXWalletServer::getServerStatusImpl() {
 
     Json::Value result;
     result["status"] = 0;
@@ -739,45 +735,48 @@ Json::Value getServerStatusImpl() {
 }
 
 
-Json::Value SGXWalletServer::generateDKGPoly(const string& polyName, int t){
+Json::Value SGXWalletServer::generateDKGPoly(const string &polyName, int t) {
     spdlog::info("entered generateDKGPoly");
     lock_guard<recursive_mutex> lock(m);
     return generateDKGPolyImpl(polyName, t);
 }
 
-Json::Value SGXWalletServer::getVerificationVector(const string& polyName, int t, int n){
+Json::Value SGXWalletServer::getVerificationVector(const string &polyName, int t, int n) {
     lock_guard<recursive_mutex> lock(m);
     return getVerificationVectorImpl(polyName, t, n);
 }
 
-Json::Value SGXWalletServer::getSecretShare(const string& polyName, const Json::Value& publicKeys, int t, int n){
+Json::Value SGXWalletServer::getSecretShare(const string &polyName, const Json::Value &publicKeys, int t, int n) {
     lock_guard<recursive_mutex> lock(m);
     return getSecretShareImpl(polyName, publicKeys, t, n);
 }
 
-Json::Value  SGXWalletServer::dkgVerification( const string& publicShares, const string& ethKeyName, const string& SecretShare, int t, int n, int index){
+Json::Value
+SGXWalletServer::dkgVerification(const string &publicShares, const string &ethKeyName, const string &SecretShare, int t,
+                                 int n, int index) {
     lock_guard<recursive_mutex> lock(m);
     return dkgVerificationImpl(publicShares, ethKeyName, SecretShare, t, n, index);
 }
 
-Json::Value SGXWalletServer::createBLSPrivateKey(const string & blsKeyName, const string& ethKeyName, const string& polyName, const string& SecretShare, int t, int n){
+Json::Value
+SGXWalletServer::createBLSPrivateKey(const string &blsKeyName, const string &ethKeyName, const string &polyName,
+                                     const string &SecretShare, int t, int n) {
     lock_guard<recursive_mutex> lock(m);
     return createBLSPrivateKeyImpl(blsKeyName, ethKeyName, polyName, SecretShare, t, n);
 }
 
-Json::Value SGXWalletServer::getBLSPublicKeyShare(const string & blsKeyName){
+Json::Value SGXWalletServer::getBLSPublicKeyShare(const string &blsKeyName) {
     lock_guard<recursive_mutex> lock(m);
     return getBLSPublicKeyShareImpl(blsKeyName);
 }
 
 
-
 Json::Value SGXWalletServer::generateECDSAKey() {
     lock_guard<recursive_mutex> lock(m);
     return generateECDSAKeyImpl();
 }
 
-Json::Value SGXWalletServer::renameECDSAKey(const string& KeyName, const string& tempKeyName){
+Json::Value SGXWalletServer::renameECDSAKey(const string &KeyName, const string &tempKeyName) {
     lock_guard<recursive_mutex> lock(m);
     return renameECDSAKeyImpl(KeyName, tempKeyName);
 }
@@ -788,21 +787,21 @@ Json::Value SGXWalletServer::getPublicECDSAKey(const string &_keyName) {
 }
 
 
-Json::Value SGXWalletServer::ecdsaSignMessageHash(int base, const string &_keyName, const string &messageHash ) {
+Json::Value SGXWalletServer::ecdsaSignMessageHash(int base, const string &_keyName, const string &messageHash) {
     lock_guard<recursive_mutex> lock(m);
     spdlog::info("entered ecdsaSignMessageHash");
-  if (DEBUG_PRINT) {
+    if (printDebugInfo) {
         spdlog::info("MessageHash first {}", messageHash);
     }
-  return ecdsaSignMessageHashImpl(base,_keyName, messageHash);
+    return ecdsaSignMessageHashImpl(base, _keyName, messageHash);
 }
 
 
 Json::Value
-SGXWalletServer::importBLSKeyShare(const string &_keyShare, const string &_keyShareName, int t, int n,
+SGXWalletServer::importBLSKeyShare(const string &_keyShare, const string &_keyShareName, int _t, int _n,
                                    int index) {
     lock_guard<recursive_mutex> lock(m);
-    return importBLSKeyShareImpl(_keyShare, _keyShareName, t, n, index );
+    return importBLSKeyShareImpl(_keyShare, _keyShareName, _t, _n, index);
 }
 
 Json::Value SGXWalletServer::blsSignMessageHash(const string &keyShareName, const string &messageHash, int t, int n,
@@ -816,17 +815,17 @@ Json::Value SGXWalletServer::importECDSAKey(const string &key, const string &key
     return importECDSAKeyImpl(key, keyName);
 }
 
-Json::Value SGXWalletServer::complaintResponse(const string& polyName, int ind){
+Json::Value SGXWalletServer::complaintResponse(const string &polyName, int ind) {
     lock_guard<recursive_mutex> lock(m);
     return complaintResponseImpl(polyName, ind);
 }
 
-Json::Value SGXWalletServer::multG2(const string& x){
+Json::Value SGXWalletServer::multG2(const string &x) {
     lock_guard<recursive_mutex> lock(m);
     return multG2Impl(x);
 }
 
-Json::Value SGXWalletServer::isPolyExists(const string& polyName){
+Json::Value SGXWalletServer::isPolyExists(const string &polyName) {
     lock_guard<recursive_mutex> lock(m);
     return isPolyExistsImpl(polyName);
 }
@@ -836,7 +835,7 @@ Json::Value SGXWalletServer::getServerStatus() {
     return getServerStatusImpl();
 }
 
-shared_ptr<string> readFromDb(const string & name, const string & prefix) {
+shared_ptr<string> SGXWalletServer::readFromDb(const string &name, const string &prefix) {
 
     auto dataStr = LevelDB::getLevelDb()->readString(prefix + name);
 
@@ -847,7 +846,7 @@ shared_ptr<string> readFromDb(const string & name, const string & prefix) {
     return dataStr;
 }
 
-shared_ptr<string> readKeyShare(const string &_keyShareName) {
+shared_ptr<string> SGXWalletServer::readKeyShare(const string &_keyShareName) {
 
     auto keyShareStr = LevelDB::getLevelDb()->readString("BLSKEYSHARE:" + _keyShareName);
 
@@ -859,7 +858,7 @@ shared_ptr<string> readKeyShare(const string &_keyShareName) {
 
 }
 
-void writeKeyShare(const string &_keyShareName, const string &value, int index, int n, int t) {
+void SGXWalletServer::writeKeyShare(const string &_keyShareName, const string &value, int index, int n, int t) {
 
     Json::Value val;
     Json::FastWriter writer;
@@ -880,7 +879,7 @@ void writeKeyShare(const string &_keyShareName, const string &value, int index,
     LevelDB::getLevelDb()->writeString(key, value);
 }
 
-void writeDataToDB(const string & Name, const string &value) {
+void SGXWalletServer::writeDataToDB(const string &Name, const string &value) {
     Json::Value val;
     Json::FastWriter writer;
 
@@ -895,7 +894,7 @@ void writeDataToDB(const string & Name, const string &value) {
     }
 
     LevelDB::getLevelDb()->writeString(key, value);
-  if (DEBUG_PRINT) {
+    if (printDebugInfo) {
         spdlog::info("{} ", Name, " is written to db ");
     }
 }

SGXWalletServer.h

@@ -31,9 +31,6 @@
 #endif
 
 
-EXTERNC int init_https_server(bool check_certs );
-EXTERNC int init_http_server();
-
 
 
 

SGXWalletServer.hpp

@@ -25,72 +25,116 @@
 #define SGXWALLET_SGXWALLETSERVER_HPP
 
 
-
-
 #include "abstractstubserver.h"
 #include <mutex>
 
 
-
 using namespace jsonrpc;
 using namespace std;
 
 class SGXWalletServer : public AbstractStubServer {
 
 
-    SGXWalletServer* server = nullptr;
+    SGXWalletServer *server = nullptr;
     std::recursive_mutex m;
 
 public:
-    SGXWalletServer(AbstractServerConnector &connector, serverVersion_t type);
+    SGXWalletServer(AbstractServerConnector &_connector, serverVersion_t _type);
+
+    virtual Json::Value
+    importBLSKeyShare(const std::string &_keyShare, const std::string &_keyShareName, int _t, int _n, int index);
+
+    virtual Json::Value
+    blsSignMessageHash(const std::string &keyShareName, const std::string &messageHash, int t, int n, int signerIndex);
 
-    virtual Json::Value importBLSKeyShare(const std::string& keyShare, const std::string& keyShareName, int t, int n, int index);
-    virtual Json::Value blsSignMessageHash(const std::string& keyShareName, const std::string& messageHash, int t, int n, int signerIndex);
+    virtual Json::Value importECDSAKey(const std::string &key, const std::string &keyName);
 
-    virtual Json::Value importECDSAKey(const std::string& key, const std::string& keyName);
     virtual Json::Value generateECDSAKey();
-    virtual Json::Value renameECDSAKey(const std::string& KeyName, const std::string& tempKeyName);
-    virtual Json::Value ecdsaSignMessageHash(int base, const std::string& keyShareName, const std::string& messageHash);
-    virtual Json::Value getPublicECDSAKey(const std::string& keyName);
-
-    virtual Json::Value generateDKGPoly(const std::string& polyName, int t);
-    virtual Json::Value getVerificationVector(const std::string& polyName, int t, int n);
-    virtual Json::Value getSecretShare(const std::string& polyName, const Json::Value& publicKeys, int t, int n);
-    virtual Json::Value dkgVerification(const std::string& publicShares, const std::string& ethKeyName, const std::string& SecretShare, int t, int n, int index);
-    virtual Json::Value createBLSPrivateKey(const std::string & blsKeyName, const std::string& ethKeyName, const std::string& polyName, const std::string & SecretShare, int t, int n);
-    virtual Json::Value getBLSPublicKeyShare(const std::string & blsKeyName);
-    virtual Json::Value complaintResponse(const std::string& polyName, int ind);
-    virtual Json::Value multG2(const std::string & x);
-    virtual Json::Value isPolyExists(const std::string& polyName);
+
+    virtual Json::Value renameECDSAKey(const std::string &KeyName, const std::string &tempKeyName);
+
+    virtual Json::Value ecdsaSignMessageHash(int base, const std::string &keyShareName, const std::string &messageHash);
+
+    virtual Json::Value getPublicECDSAKey(const std::string &keyName);
+
+    virtual Json::Value generateDKGPoly(const std::string &polyName, int t);
+
+    virtual Json::Value getVerificationVector(const std::string &polyName, int t, int n);
+
+    virtual Json::Value getSecretShare(const std::string &polyName, const Json::Value &publicKeys, int t, int n);
+
+    virtual Json::Value
+    dkgVerification(const std::string &publicShares, const std::string &ethKeyName, const std::string &SecretShare,
+                    int t, int n, int index);
+
+    virtual Json::Value
+    createBLSPrivateKey(const std::string &blsKeyName, const std::string &ethKeyName, const std::string &polyName,
+                        const std::string &SecretShare, int t, int n);
+
+    virtual Json::Value getBLSPublicKeyShare(const std::string &blsKeyName);
+
+    virtual Json::Value complaintResponse(const std::string &polyName, int ind);
+
+    virtual Json::Value multG2(const std::string &x);
+
+    virtual Json::Value isPolyExists(const std::string &polyName);
+
     virtual Json::Value getServerStatus();
 
-};
+    static shared_ptr<string> readFromDb(const string &name, const string &prefix = "");
 
-shared_ptr<string> readFromDb(const string & name, const string & prefix = "");
-void writeDataToDB(const string & Name, const string &value);
+    static void writeDataToDB(const string &Name, const string &value);
 
-void writeKeyShare(const string &_keyShareName, const string &value, int index, int n, int t);
-shared_ptr<std::string> readKeyShare(const string& _keyShare);
+    static void writeKeyShare(const string &_keyShareName, const string &value, int index, int n, int t);
 
-Json::Value importBLSKeyShareImpl(const std::string& keyShare, const std::string& keyShareName, int t, int n, int index);
-Json::Value blsSignMessageHashImpl(const std::string& keyShareName, const std::string& messageHash, int t, int n, int signerIndex);
+    static shared_ptr<std::string> readKeyShare(const string &_keyShare);
 
-Json::Value importECDSAKeyImpl(const std::string& key, const std::string& keyName);
-Json::Value generateECDSAKeyImpl();
-Json::Value renameECDSAKeyImpl(const std::string& KeyName, const std::string& tempKeyName);
-Json::Value ecdsaSignMessageHashImpl(int base, const std::string& keyName, const std::string& messageHash);
-Json::Value getPublicECDSAKeyImpl(const std::string& keyName);
+    static Json::Value
+    importBLSKeyShareImpl(const std::string &keyShare, const std::string &keyShareName, int t, int n, int index);
 
-Json::Value generateDKGPolyImpl(const std::string& polyName, int t);
-Json::Value getVerificationVectorImpl(const std::string& polyName, int t, int n);
-Json::Value getSecretShareImpl(const std::string& polyName, const Json::Value& publicKeys, int t, int n);
-Json::Value dkgVerificationImpl(const std::string& publicShares, const std::string& ethKeyName, const std::string& SecretShare, int t, int n, int index);
-Json::Value createBLSPrivateKeyImpl(const std::string & blsKeyName, const std::string& ethKeyName, const std::string& polyName, const std::string & SecretShare, int t, int n);
-Json::Value getBLSPublicKeyShareImpl(const std::string & blsKeyName);
-Json::Value complaintResponseImpl(const std::string& polyName, int ind);
-Json::Value multG2Impl(const std::string & x);
-Json::Value isPolyExistsImpl(const std::string& polyName);
+    static Json::Value
+    blsSignMessageHashImpl(const std::string &keyShareName, const std::string &messageHash, int t, int n,
+                           int signerIndex);
 
-Json::Value getServerStatusImpl();
+    static Json::Value importECDSAKeyImpl(const std::string &_key, const std::string &_keyName);
+
+    static Json::Value generateECDSAKeyImpl();
+
+    static Json::Value renameECDSAKeyImpl(const std::string &KeyName, const std::string &tempKeyName);
+
+    static Json::Value ecdsaSignMessageHashImpl(int base, const std::string &keyName, const std::string &messageHash);
+
+    static Json::Value getPublicECDSAKeyImpl(const std::string &keyName);
+
+    static Json::Value generateDKGPolyImpl(const std::string &polyName, int t);
+
+    static Json::Value getVerificationVectorImpl(const std::string &polyName, int t, int n);
+
+    static Json::Value getSecretShareImpl(const std::string &polyName, const Json::Value &publicKeys, int t, int n);
+
+    static Json::Value
+    dkgVerificationImpl(const std::string &publicShares, const std::string &ethKeyName, const std::string &SecretShare,
+                        int t, int n, int index);
+
+    static Json::Value
+    createBLSPrivateKeyImpl(const std::string &blsKeyName, const std::string &ethKeyName, const std::string &polyName,
+                            const std::string &SecretShare, int t, int n);
+
+    static Json::Value getBLSPublicKeyShareImpl(const std::string &blsKeyName);
+
+    static Json::Value complaintResponseImpl(const std::string &polyName, int ind);
+
+    static Json::Value multG2Impl(const std::string &x);
+
+    static Json::Value isPolyExistsImpl(const std::string &polyName);
+
+    static Json::Value getServerStatusImpl();
+
+    static void printDB();
+
+    static int initHttpServer();
+
+    static int initHttpsServer(bool _checkCerts);
+};
 
 #endif //SGXWALLET_SGXWALLETSERVER_HPP
\ No newline at end of file

ServerInit.cpp

@@ -64,6 +64,7 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
+#include "SGXWalletServer.hpp"
 #include "SGXWALLET_VERSION"
 
 //#include <system>
@@ -95,7 +96,7 @@ void init_enclave() {
     }
 #endif
 
-    if ( DEBUG_PRINT) {
+    if ( printDebugInfo) {
       spdlog::info("SGX_DEBUG_FLAG = {}", SGX_DEBUG_FLAG);
     }
 
@@ -121,7 +122,7 @@ void init_enclave() {
         exit(1);
     }
 
-    if (DEBUG_PRINT) {
+    if (printDebugInfo) {
       spdlog::info("libtgmp initialized");
       //fprintf(stderr, "libtgmp initialized\n");
     }
@@ -144,13 +145,13 @@ void init_all(bool check_cert, bool sign_automatically, void (*SEK_func)()) {
 
     sgxServerInited = 1;
 
-    if (is_sgx_https) {
-      init_https_server(check_cert);
-      init_registration_server(sign_automatically);
+    if (useHTTPS) {
+        SGXWalletServer::initHttpsServer(check_cert);
+        initRegistrationServer(sign_automatically);
       init_csrmanager_server();
     }
     else {
-      init_http_server();
+        SGXWalletServer::initHttpServer();
     }
 
     //std::cerr << "enclave inited" << std::endl;

docker/start.sh

@@ -20,7 +20,7 @@ if [ "$1" = -t ]; then
   ./testw [is_poly_test]
   ./testw [AES-encrypt-decrypt]
 ./testw [ecdsa_api_test]
-./testw [dkg-encr_sshares]
+#./testw [dkg-encr_sshares]
  ./testw [bls_sign]
 ./testw [many_threads_test]
   ./testw [aes_dkg]

sgxwallet.c

@@ -67,7 +67,7 @@ int main(int argc, char *argv[]) {
     exit(1);
   }
 
-  is_aes = 0;  
+    encryptKeys = 0;
 
   while ((opt = getopt(argc, argv, "cshd0aby")) != -1) {
     switch (opt) {
@@ -91,13 +91,13 @@ int main(int argc, char *argv[]) {
       sign_automatically = true;
       break;
     case 'd':
-      DEBUG_PRINT = 1;
+        printDebugInfo = 1;
       break;
     case '0':
-      is_sgx_https = 0;
+        useHTTPS = 0;
      break;
     case 'a':
-      is_aes = 0;
+        encryptKeys = 0;
       break;
     case 'b':
       SEK_initializer = enter_SEK;

sgxwallet_common.h

@@ -35,9 +35,9 @@
 
 
 
-extern int DEBUG_PRINT;
-extern int is_sgx_https;
-extern int is_aes;
+extern int printDebugInfo;
+extern int useHTTPS;
+extern int encryptKeys;
 extern bool autoconfirm;
 
 #define BUF_LEN 1024

testw.cpp

@@ -121,8 +121,8 @@ char *encryptTestKey() {
 
 
 TEST_CASE("BLS key encrypt", "[bls-key-encrypt]") {
-    DEBUG_PRINT = 1;
-    is_sgx_https = 0;
+    printDebugInfo = 1;
+    useHTTPS = 0;
     autoconfirm = true;
     init_all(false, true, init_SEK);
     auto key = encryptTestKey();
@@ -134,8 +134,8 @@ TEST_CASE("BLS key encrypt", "[bls-key-encrypt]") {
 TEST_CASE("BLS key encrypt/decrypt", "[bls-key-encrypt-decrypt]") {
     {
 
-        DEBUG_PRINT = 1;
-        is_sgx_https = 0;
+        printDebugInfo = 1;
+        useHTTPS = 0;
         autoconfirm = true;
 
         init_all(false, true, init_SEK);
@@ -549,8 +549,8 @@ string ConvertDecToHex(string dec, int numBytes = 32) {
 
 
 TEST_CASE("BLS_DKG test", "[bls_dkg]") {
-    is_sgx_https = 0;
-    DEBUG_PRINT = 1;
+    useHTTPS = 0;
+    printDebugInfo = 1;
     cerr << "test started" << endl;
     init_all(false, true, init_SEK);
     cerr << "Server inited" << endl;
@@ -683,7 +683,7 @@ TEST_CASE("BLS_DKG test", "[bls_dkg]") {
 TEST_CASE("API test", "[api_test]") {
     autoconfirm = true;
     //DEBUG_PRINT = 1;
-    is_sgx_https = 0;
+    useHTTPS = 0;
     //cerr << __GNUC__ << endl;
     cerr << "API test started" << endl;
     init_all(false, true, init_SEK);
@@ -789,7 +789,7 @@ TEST_CASE("API test", "[api_test]") {
 
 TEST_CASE("getServerStatus test", "[getServerStatus_test]") {
     autoconfirm = true;
-    is_sgx_https = 0;
+    useHTTPS = 0;
     init_all(false, true, init_SEK);
     HttpClient client("http://localhost:1029");
     StubClient c(client, JSONRPC_CLIENT_V2);
@@ -911,9 +911,9 @@ void SendRPCRequest() {
 
 TEST_CASE("ManySimultaneousThreads", "[many_threads_test]") {
     autoconfirm = true;
-    is_sgx_https = 0;
-    DEBUG_PRINT = 1;
-    is_aes = 1;
+    useHTTPS = 0;
+    printDebugInfo = 1;
+    encryptKeys = 1;
 
     init_all(false, true, init_SEK);
 
@@ -932,9 +932,9 @@ TEST_CASE("ManySimultaneousThreads", "[many_threads_test]") {
 
 TEST_CASE("ecdsa API test", "[ecdsa_api_test]") {
     autoconfirm = true;
-    DEBUG_PRINT = 1;
-    is_sgx_https = 0;
-    is_aes = 1;
+    printDebugInfo = 1;
+    useHTTPS = 0;
+    encryptKeys = 1;
 
     cerr << "ecdsa_api_test started" << endl;
     init_all(false, true, init_SEK);
@@ -984,8 +984,8 @@ TEST_CASE("ecdsa API test", "[ecdsa_api_test]") {
 
 TEST_CASE("dkg API test", "[dkg_api_test]") {
     autoconfirm = true;
-    DEBUG_PRINT = 1;
-    is_sgx_https = 0;
+    printDebugInfo = 1;
+    useHTTPS = 0;
 
     cerr << "dkg_api_test started" << endl;
     init_all(false, true, init_SEK);
@@ -1062,8 +1062,8 @@ TEST_CASE("dkg API test", "[dkg_api_test]") {
 
 TEST_CASE("isPolyExists test", "[is_poly_test]") {
     autoconfirm = true;
-    DEBUG_PRINT = 1;
-    is_sgx_https = 0;
+    printDebugInfo = 1;
+    useHTTPS = 0;
 
     cerr << "is_poly_test started" << endl;
     init_all(false, true, init_SEK);
@@ -1091,9 +1091,9 @@ TEST_CASE("isPolyExists test", "[is_poly_test]") {
 
 TEST_CASE("AES_DKG test", "[aes_dkg]") {
     autoconfirm = true;
-    is_sgx_https = 0;
-    DEBUG_PRINT = 1;
-    is_aes = 1;
+    useHTTPS = 0;
+    printDebugInfo = 1;
+    encryptKeys = 1;
 
     reset_db();
 
@@ -1223,9 +1223,9 @@ TEST_CASE("AES_DKG test", "[aes_dkg]") {
 
 TEST_CASE("bls_sign_api test", "[bls_sign]") {
     autoconfirm = true;
-    is_sgx_https = 0;
-    DEBUG_PRINT = 1;
-    is_aes = 1;
+    useHTTPS = 0;
+    printDebugInfo = 1;
+    encryptKeys = 1;
 
     cerr << "test started" << endl;
     init_all(false, true, init_SEK);
@@ -1258,8 +1258,8 @@ TEST_CASE("bls_sign_api test", "[bls_sign]") {
 TEST_CASE("AES encrypt/decrypt", "[AES-encrypt-decrypt]") {
     {
         autoconfirm = true;
-        DEBUG_PRINT = 1;
-        is_sgx_https = 0;
+        printDebugInfo = 1;
+        useHTTPS = 0;
 
         init_all(false, true, init_SEK);
         //init_enclave();