SKALE-2454-add-logs-to-enclave

BLSCrypto.cpp

@@ -321,7 +321,7 @@ char *encryptBLSKeyShare2Hex(int *errStatus, char *err_string, const char *_key)
     unsigned int encryptedLen = 0;
 
     //status = encrypt_key(eid, errStatus, errMsg, keyArray, encryptedKey, &encryptedLen);
-    status = encrypt_key_aes(eid, errStatus, errMsg->data(), keyArray->data(), encryptedKey->data(), &encryptedLen);
+    status = trustedEncryptKeyAES(eid, errStatus, errMsg->data(), keyArray->data(), encryptedKey->data(), &encryptedLen);
 
     spdlog::debug("errStatus is {}", *errStatus);
     spdlog::debug(" errMsg is ", errMsg->data());
@@ -361,7 +361,7 @@ char *decryptBLSKeyShareFromHex(int *errStatus, char *errMsg, const char *_encry
     char *plaintextKey = (char *) calloc(BUF_LEN, 1);
 
     //status = decrypt_key(eid, errStatus, errMsg, decoded, decodedLen, plaintextKey);
-    status = decrypt_key_aes(eid, errStatus, errMsg, decoded, decodedLen, plaintextKey);
+    status = trustedDecryptKeyAES(eid, errStatus, errMsg, decoded, decodedLen, plaintextKey);
 
     if (status != SGX_SUCCESS) {
         return nullptr;

DKGCrypto.cpp

@@ -380,7 +380,7 @@ string decryptDHKey(const string &polyName, int ind) {
     if (!encryptKeys)
         decrypt_key(eid, &errStatus, errMsg1.data(), encryptedDHKey, dhEncLen, DHKey);
     else
-        decrypt_key_aes(eid, &errStatus, errMsg1.data(), encryptedDHKey, dhEncLen, DHKey);
+        trustedDecryptKeyAES(eid, &errStatus, errMsg1.data(), encryptedDHKey, dhEncLen, DHKey);
     if (errStatus != 0) {
         throw SGXException(/*ERROR_IN_ENCLAVE*/ errStatus, "decrypt key failed in enclave");
     }

SEKManager.cpp

@@ -53,7 +53,7 @@ void create_test_key(){
 
   std::string key = TEST_VALUE;
 
-  status = encrypt_key_aes(eid, &errStatus, errMsg.data(), key.c_str(), encrypted_key, &enc_len);
+  status = trustedEncryptKeyAES(eid, &errStatus, errMsg.data(), key.c_str(), encrypted_key, &enc_len);
   if ( status != 0){
     std::cerr << "encrypt test key failed with status " << status << std::endl;
     throw SGXException(status, errMsg.data()) ;
@@ -104,7 +104,7 @@ bool check_SEK(std::string SEK){
       throw SGXException(status, errMsg.data());
     }
 
-    status = decrypt_key_aes(eid, &err_status, errMsg.data(), encr_test_key.data(), len, decr_key.data());
+    status = trustedDecryptKeyAES(eid, &err_status, errMsg.data(), encr_test_key.data(), len, decr_key.data());
     if (status != SGX_SUCCESS || err_status != 0){
       spdlog::error("failed to decrypt test key" );
       spdlog::error(errMsg.data());

secure_enclave/secure_enclave.c

@@ -1218,7 +1218,7 @@ void trustedEcdsaSignAES(int *errStatus, char *err_string, uint8_t *encrypted_ke
 
 }
 
-void encrypt_key_aes(int *errStatus, char *err_string, const char *key,
+void trustedEncryptKeyAES(int *errStatus, char *err_string, const char *key,
                      uint8_t *encrypted_key, uint32_t *enc_len) {
 
     //init();
@@ -1274,7 +1274,7 @@ void encrypt_key_aes(int *errStatus, char *err_string, const char *key,
     *errStatus = 0;
 }
 
-void decrypt_key_aes(int *errStatus, char *err_string, uint8_t *encrypted_key,
+void trustedDecryptKeyAES(int *errStatus, char *err_string, uint8_t *encrypted_key,
                      uint32_t enc_len, char *key) {
 
     init();

secure_enclave/secure_enclave.edl

@@ -212,14 +212,14 @@ enclave {
                                 [user_check] uint8_t* sig_v,
                                 int base);
 
-                public void encrypt_key_aes (
+                public void trustedEncryptKeyAES (
                                 [user_check] int *errStatus,
                                 [out, count = SMALL_BUF_SIZE] char* err_string,
                                 [in, count = SMALL_BUF_SIZE] const char* key,
                                 [out, count = SMALL_BUF_SIZE] uint8_t* encrypted_key,
                                 [user_check] uint32_t *enc_len);
 
-                public void decrypt_key_aes (
+                public void trustedDecryptKeyAES (
                                 [user_check] int *errStatus,
                                 [out, count = SMALL_BUF_SIZE] char* err_string,
                                 [in, count = SMALL_BUF_SIZE] uint8_t* encrypted_key,

testw.cpp

@@ -1153,13 +1153,13 @@ TEST_CASE("AES encrypt/decrypt", "[AES-encrypt-decrypt]") {
     string key = "123456789";
     vector<uint8_t> encrypted_key(BUF_LEN, 0);
 
-    status = encrypt_key_aes(eid, &errStatus, errMsg.data(), key.c_str(), encrypted_key.data(), &enc_len);
+    status = trustedEncryptKeyAES(eid, &errStatus, errMsg.data(), key.c_str(), encrypted_key.data(), &enc_len);
 
     REQUIRE(status == 0);
 
 
     vector<char> decr_key(BUF_LEN, 0);
-    status = decrypt_key_aes(eid, &errStatus, errMsg.data(), encrypted_key.data(), enc_len, decr_key.data());
+    status = trustedDecryptKeyAES(eid, &errStatus, errMsg.data(), encrypted_key.data(), enc_len, decr_key.data());
 
     REQUIRE(status == 0);