Merge pull request #171 from skalenetwork/SKALE-3222

SKALE-3222-clean-memory-sanitizer-warnings

BLSCrypto.cpp

@@ -49,6 +49,9 @@
 
 
 string *FqToString(libff::alt_bn128_Fq *_fq) {
+
+    CHECK_STATE(_fq);
+
     mpz_t t;
     mpz_init(t);
 
@@ -72,10 +75,17 @@ int char2int(char _input) {
     return -1;
 }
 
-void carray2Hex(const unsigned char *d, int _len, char *_hexArray) {
+void carray2Hex(const unsigned char *d, uint64_t _len, char *_hexArray,
+                uint64_t _hexArrayLen) {
+
+    CHECK_STATE(d);
+    CHECK_STATE(_hexArray);
+
     char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 
+    CHECK_STATE(_hexArrayLen > 2 * _len);
+
     for (int j = 0; j < _len; j++) {
         _hexArray[j * 2] = hexval[((d[j] >> 4) & 0xF)];
         _hexArray[j * 2 + 1] = hexval[(d[j]) & 0x0F];
@@ -84,31 +94,23 @@ void carray2Hex(const unsigned char *d, int _len, char *_hexArray) {
     _hexArray[_len * 2] = 0;
 }
 
-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;
 
-    *_bin_len = len / 2;
+bool hex2carray(const char *_hex, uint64_t *_bin_len,
+                 uint8_t *_bin, uint64_t _max_length) {
 
-    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;
-        }
+    CHECK_STATE(_hex);
+    CHECK_STATE(_bin);
+    CHECK_STATE(_bin_len)
 
-        _bin[i] = (unsigned char) (high * 16 + low);
-    }
 
-    return true;
-}
+    int len = strnlen(_hex, 2 * _max_length + 1);
+
+    CHECK_STATE(len != 2 * _max_length + 1);
+
+    CHECK_STATE(len <= 2 * _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)
         return false;
@@ -131,13 +133,19 @@ bool hex2carray2(const char *_hex, uint64_t *_bin_len,
 
 bool sign(const char *_encryptedKeyHex, const char *_hashHex, size_t _t, size_t _n, size_t _signerIndex,
           char *_sig) {
+
+
+    CHECK_STATE(_encryptedKeyHex);
+    CHECK_STATE(_hashHex);
+    CHECK_STATE(_sig);
+
     auto keyStr = make_shared<string>(_encryptedKeyHex);
 
     auto hash = make_shared<array<uint8_t, 32>>();
 
     uint64_t binLen;
 
-    if (!hex2carray(_hashHex, &binLen, hash->data())) {
+    if (!hex2carray(_hashHex, &binLen, hash->data(), hash->size())) {
         throw SGXException(INVALID_HEX, "Invalid hash");
     }
 
@@ -153,11 +161,16 @@ bool sign(const char *_encryptedKeyHex, const char *_hashHex, size_t _t, size_t
 }
 
 bool sign_aes(const char *_encryptedKeyHex, const char *_hashHex, size_t _t, size_t _n, char *_sig) {
+
+    CHECK_STATE(_encryptedKeyHex);
+    CHECK_STATE(_hashHex);
+    CHECK_STATE(_sig);
+
     auto hash = make_shared<array<uint8_t, 32>>();
 
     uint64_t binLen;
 
-    if (!hex2carray(_hashHex, &binLen, hash->data())) {
+    if (!hex2carray(_hashHex, &binLen, hash->data(), hash->size())) {
         throw SGXException(INVALID_HEX, "Invalid hash");
     }
 
@@ -193,7 +206,7 @@ bool sign_aes(const char *_encryptedKeyHex, const char *_hashHex, size_t _t, siz
 
     SAFE_UINT8_BUF(encryptedKey,BUF_LEN);
 
-    bool result = hex2carray(_encryptedKeyHex, &sz, encryptedKey);
+    bool result = hex2carray(_encryptedKeyHex, &sz, encryptedKey, BUF_LEN);
 
     if (!result) {
         BOOST_THROW_EXCEPTION(invalid_argument("Invalid hex encrypted key"));
@@ -240,9 +253,9 @@ string encryptBLSKeyShare2Hex(int *errStatus, char *err_string, const char *_key
 
     HANDLE_TRUSTED_FUNCTION_ERROR(status, *errStatus, errMsg.data());
 
-    string result(2 * BUF_LEN, '\0');
+    SAFE_CHAR_BUF(resultBuf, 2 * BUF_LEN + 1);
 
-    carray2Hex(encryptedKey->data(), encryptedLen, &result.front());
+    carray2Hex(encryptedKey->data(), encryptedLen, resultBuf, 2 * BUF_LEN + 1);
 
-    return result;
+    return string(resultBuf);
 }

BLSCrypto.h

@@ -38,13 +38,10 @@ EXTERNC bool bls_sign(const char* encryptedKeyHex, const char* hashHex, size_t t
 
 EXTERNC int char2int(char _input);
 
-EXTERNC void  carray2Hex(const unsigned char *d, int _len, char* _hexArray);
+EXTERNC void  carray2Hex(const unsigned char *d, uint64_t , char* _hexArray,
+                         uint64_t _hexArrayLen);
 EXTERNC bool hex2carray(const char * _hex, uint64_t  *_bin_len,
-                        uint8_t* _bin );
-EXTERNC bool hex2carray2(const char * _hex, uint64_t  *_bin_len,
-                 uint8_t* _bin, const int _max_length );
-
-
+                 uint8_t* _bin, uint64_t _max_length );
 
 std::string encryptBLSKeyShare2Hex(int *errStatus, char *err_string, const char *_key);
 

BLSPrivateKeyShareSGX.cpp

@@ -140,7 +140,8 @@ string BLSPrivateKeyShareSGX::signWithHelperSGXstr(
 
     SAFE_UINT8_BUF(encryptedKey, BUF_LEN);
 
-    bool result = hex2carray(encryptedKeyHex->c_str(), &sz, encryptedKey);
+    bool result = hex2carray(encryptedKeyHex->c_str(), &sz, encryptedKey,
+                             BUF_LEN);
 
     if (!result) {
         spdlog::error("Invalid hex encrypted key");

DKGCrypto.cpp

@@ -146,9 +146,9 @@ string gen_dkg_poly(int _t) {
 
     uint64_t length = enc_len;;
 
-    vector<char> hexEncrPoly(2 * length + 1, 0);
+    vector<char> hexEncrPoly(BUF_LEN, 0);
     CHECK_STATE(encrypted_dkg_secret.size() >= length);
-    carray2Hex(encrypted_dkg_secret.data(), length, hexEncrPoly.data());
+    carray2Hex(encrypted_dkg_secret.data(), length, hexEncrPoly.data(), BUF_LEN);
     string result(hexEncrPoly.data());
 
     return result;
@@ -168,7 +168,7 @@ vector <vector<string>> get_verif_vect(const char *encryptedPolyHex, int t, int
 
     vector <uint8_t> encrDKGPoly(2 * BUF_LEN, 0);
 
-    if (!hex2carray2(encryptedPolyHex, &encLen, encrDKGPoly.data(), 6100)) {
+    if (!hex2carray(encryptedPolyHex, &encLen, encrDKGPoly.data(), 6100)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedPolyHex");
     }
 
@@ -197,12 +197,13 @@ getSecretShares(const string &_polyName, const char *_encryptedPolyHex, const ve
 
     vector<char> hexEncrKey(BUF_LEN, 0);
     vector<char> errMsg1(BUF_LEN, 0);
+    vector <uint8_t> encrDKGPoly(BUF_LEN, 0);
     int errStatus = 0;
     uint64_t encLen = 0;
 
-    vector <uint8_t> encrDKGPoly(BUF_LEN, 0);
 
-    if (!hex2carray2(_encryptedPolyHex, &encLen, encrDKGPoly.data(), 6100)) {
+
+    if (!hex2carray(_encryptedPolyHex, &encLen, encrDKGPoly.data(), BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedPolyHex");
     }
 
@@ -234,7 +235,7 @@ getSecretShares(const string &_polyName, const char *_encryptedPolyHex, const ve
         result += string(currentShare.data());
 
         spdlog::debug("dec len is {}", decLen);
-        carray2Hex(encryptedSkey.data(), decLen, hexEncrKey.data());
+        carray2Hex(encryptedSkey.data(), decLen, hexEncrKey.data(), BUF_LEN);
         string dhKeyName = "DKG_DH_KEY_" + _polyName + "_" + to_string(i) + ":";
 
         spdlog::debug("hexEncr DH Key: { }", hexEncrKey.data());
@@ -266,7 +267,7 @@ verifyShares(const char *publicShares, const char *encr_sshare, const char *encr
     int result = 0;
 
     SAFE_UINT8_BUF(encr_key, BUF_LEN);
-    if (!hex2carray(encryptedKeyHex, &decKeyLen, encr_key)) {
+    if (!hex2carray(encryptedKeyHex, &decKeyLen, encr_key, BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedPolyHex");
     }
 
@@ -295,7 +296,7 @@ bool createBLSShare(const string &blsKeyName, const char *s_shares, const char *
     uint64_t decKeyLen;
     SAFE_UINT8_BUF(encr_bls_key,BUF_LEN);
     SAFE_UINT8_BUF(encr_key,BUF_LEN);
-    if (!hex2carray(encryptedKeyHex, &decKeyLen, encr_key)) {
+    if (!hex2carray(encryptedKeyHex, &decKeyLen, encr_key, BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedKeyHex");
     }
 
@@ -308,7 +309,7 @@ bool createBLSShare(const string &blsKeyName, const char *s_shares, const char *
 
     SAFE_CHAR_BUF(hexBLSKey,2 * BUF_LEN)
 
-    carray2Hex(encr_bls_key, enc_bls_len, hexBLSKey);
+    carray2Hex(encr_bls_key, enc_bls_len, hexBLSKey, 2 * BUF_LEN);
 
     SGXWalletServer::writeDataToDB(blsKeyName, hexBLSKey);
 
@@ -321,12 +322,12 @@ vector <string> getBLSPubKey(const char *encryptedKeyHex) {
     CHECK_STATE(encryptedKeyHex);
 
     vector<char> errMsg1(BUF_LEN, 0);
-    int errStatus = 0;
 
-    uint64_t decKeyLen;
+    int errStatus = 0;
+    uint64_t decKeyLen = 0;
 
     SAFE_UINT8_BUF(encrKey, BUF_LEN);
-    if (!hex2carray(encryptedKeyHex, &decKeyLen, encrKey)) {
+    if (!hex2carray(encryptedKeyHex, &decKeyLen, encrKey, BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedKeyHex");
     }
 
@@ -406,7 +407,7 @@ string decryptDHKey(const string &polyName, int ind) {
 
     uint64_t dhEncLen = 0;
     SAFE_UINT8_BUF(encryptedDHKey, BUF_LEN);
-    if (!hex2carray(hexEncrKeyPtr->c_str(), &dhEncLen, encryptedDHKey)) {
+    if (!hex2carray(hexEncrKeyPtr->c_str(), &dhEncLen, encryptedDHKey, BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid hexEncrKey");
     }
     spdlog::debug("encr DH key length is {}", dhEncLen);

ECDSACrypto.cpp

@@ -66,16 +66,17 @@ vector <string> genECDSAKey() {
 
     vector<char> hexEncrKey(BUF_LEN * 2, 0);
 
-    carray2Hex(encr_pr_key.data(), enc_len, hexEncrKey.data());
+    carray2Hex(encr_pr_key.data(), enc_len, hexEncrKey.data(),
+               BUF_LEN * 2);
     keys.at(0) = hexEncrKey.data();
     keys.at(1) = string(pub_key_x.data()) + string(pub_key_y.data());
 
     vector<unsigned char> randBuffer(32, 0);
     fillRandomBuffer(randBuffer);
 
-    vector<char> rand_str(64, 0);
+    vector<char> rand_str(BUF_LEN, 0);
 
-    carray2Hex(randBuffer.data(), 32, rand_str.data());
+    carray2Hex(randBuffer.data(), 32, rand_str.data(), BUF_LEN);
 
     keys.at(2) = rand_str.data();
 
@@ -93,7 +94,8 @@ string getECDSAPubKey(const std::string& _encryptedKeyHex) {
     int errStatus = 0;
     uint64_t enc_len = 0;
 
-    if (!hex2carray(_encryptedKeyHex.c_str(), &enc_len, encrPrKey.data())) {
+    if (!hex2carray(_encryptedKeyHex.c_str(), &enc_len, encrPrKey.data(),
+                    BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedKeyHex");
     }
 
@@ -177,7 +179,8 @@ vector <string> ecdsaSignHash(const std::string& encryptedKeyHex, const char *ha
 
     string pubKeyStr = "";
 
-    if (!hex2carray(encryptedKeyHex.c_str(), &decLen, encryptedKey.data())) {
+    if (!hex2carray(encryptedKeyHex.c_str(), &decLen, encryptedKey.data(),
+                    BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encryptedKeyHex");
     }
 

SEKManager.cpp

@@ -64,7 +64,7 @@ void create_test_key() {
 
     vector<char> hexEncrKey(2 * enc_len + 1, 0);
 
-    carray2Hex(encrypted_key, enc_len, hexEncrKey.data());
+    carray2Hex(encrypted_key, enc_len, hexEncrKey.data(), 2 * enc_len + 1);
 
     LevelDB::getLevelDb()->writeDataUnique("TEST_KEY", hexEncrKey.data());
 }
@@ -75,7 +75,8 @@ shared_ptr <vector<uint8_t>> check_and_set_SEK(const string &SEK) {
     vector <uint8_t> encr_test_key(BUF_LEN, 0);
     uint64_t len;
 
-    if (!hex2carray(test_key_ptr->c_str(), &len, encr_test_key.data())) {
+    if (!hex2carray(test_key_ptr->c_str(), &len, encr_test_key.data(),
+                    BUF_LEN)) {
         spdlog::error("Corrupt test key is LevelDB");
         exit(-1);
     }
@@ -131,7 +132,7 @@ void gen_SEK() {
 
     vector<char> hexEncrKey(2 * enc_len + 1, 0);
 
-    carray2Hex(encrypted_SEK.data(), enc_len, hexEncrKey.data());
+    carray2Hex(encrypted_SEK.data(), enc_len, hexEncrKey.data(), 2 * enc_len + 1);
 
     ofstream sek_file(BACKUP_PATH);
     sek_file.clear();
@@ -171,7 +172,8 @@ void setSEK(shared_ptr <string> hex_encrypted_SEK) {
 
     uint64_t len = 0;
 
-    if (!hex2carray(hex_encrypted_SEK->c_str(), &len, encrypted_SEK)) {
+    if (!hex2carray(hex_encrypted_SEK->c_str(), &len, encrypted_SEK,
+                    BUF_LEN)) {
         throw SGXException(INVALID_HEX, "Invalid encrypted SEK Hex");
     }
 
@@ -219,7 +221,8 @@ void enter_SEK() {
 
     vector<char> hexEncrKey(BUF_LEN, 0);
 
-    carray2Hex(encrypted_SEK->data(), encrypted_SEK->size(), hexEncrKey.data());
+    carray2Hex(encrypted_SEK->data(), encrypted_SEK->size(), hexEncrKey.data(),
+               BUF_LEN);
 
     spdlog::info("Got sealed storage encryption key.");
 

TestUtils.cpp

@@ -32,6 +32,7 @@
 #include "third_party/intel/create_enclave.h"
 #include "secure_enclave_u.h"
 #include "third_party/intel/sgx_detect.h"
+#include "third_party/spdlog/spdlog.h"
 #include <gmp.h>
 #include <sgx_urts.h>
 #include <stdio.h>
@@ -218,7 +219,7 @@ void TestUtils::sendRPCRequest() {
 
     auto hash_arr = make_shared < array < uint8_t, 32 >> ();
     uint64_t binLen;
-    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data())) {
+    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data(), 32)) {
         throw SGXException(INVALID_HEX, "Invalid hash");
     }
 
@@ -351,7 +352,7 @@ void TestUtils::doDKG(StubClient &c, int n, int t,
 
     auto hash_arr = make_shared<array<uint8_t, 32 >>();
     uint64_t binLen;
-    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data())) {
+    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data(), 32)) {
         throw SGXException(INVALID_HEX, "Invalid hash");
     }
 

common.h

@@ -52,9 +52,26 @@ inline std::string className(const std::string &prettyFunction) {
 
 #define __CLASS_NAME__ className( __PRETTY_FUNCTION__ )
 
+#include <execinfo.h>
+
+inline void print_stack() {
+    void *array[10];
+    size_t size;
+
+    // get void*'s for all entries on the stack
+    size = backtrace(array, 10);
+
+    // print out all the frames to stderr
+    fprintf(stderr, "Error: signal \n");
+    backtrace_symbols_fd(array, size, STDERR_FILENO);
+    exit(1);
+}
+
+
 #define CHECK_STATE(_EXPRESSION_) \
     if (!(_EXPRESSION_)) { \
         auto __msg__ = std::string("State check failed::") + #_EXPRESSION_ +  " " + std::string(__FILE__) + ":" + std::to_string(__LINE__); \
+        print_stack();                                \
         throw InvalidStateException(__msg__, __CLASS_NAME__);}
 
 

testw.cpp

@@ -649,7 +649,7 @@ TEST_CASE_METHOD(TestFixture, "AES_DKG test", "[aes-dkg]") {
 
     uint64_t binLen;
 
-    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data())) {
+    if (!hex2carray(hash.c_str(), &binLen, hash_arr->data(), 32)) {
         throw SGXException(INVALID_HEX, "Invalid hash");
     }