SKALE-3023 add infoServer

LevelDB.cpp

@@ -166,6 +166,14 @@ void LevelDB::writeDataUnique(const string & name, const string &value) {
 
 }
 
+stringstream LevelDB::getAllKeys() {
+
+}
+
+pair<string, uint64_t> LevelDB::getLastCreatedKey() {
+
+}
+
 
 LevelDB::LevelDB(string &filename) {
     leveldb::Options options;

LevelDB.h

@@ -26,10 +26,12 @@
 #define SGXWALLET_LEVELDB_H
 
 #include <memory>
+#include <sstream>
 #include <string>
 #include <mutex>
 #include <vector>
 #include "common.h"
+
 namespace leveldb {
     class DB;
     class Status;
@@ -66,9 +68,11 @@ public:
 
 public:
 
-
     shared_ptr<string> readString(const string& _key);
 
+    stringstream getAllKeys();
+
+    pair<string, uint64_t> getLastCreatedKey();
 
     void writeString(const string &key1, const string &value1);
 

Makefile.am

@@ -59,16 +59,16 @@ CLEANFILES = $(COMMON_ENCLAVE_SRC) secure_enclave.edl secure_enclave.signed.so
 
 ## The build target
 
-bin_PROGRAMS =  sgxwallet testw cert_util
+bin_PROGRAMS =  sgxwallet testw sgx_util
 
 
 ## You can't use $(wildcard ...) with automake so all source files
 ## have to be explicitly listed.
 ## have to be explicitly listed
 
-COMMON_SRC = InvalidStateException.cpp  Exception.cpp InvalidArgumentException.cpp Log.cpp  \
-             SGXWalletServer.cpp SGXRegistrationServer.cpp CSRManagerServer.cpp BLSCrypto.cpp \
-             ECDSACrypto.cpp \
+COMMON_SRC = InvalidStateException.cpp Exception.cpp InvalidArgumentException.cpp Log.cpp \
+             SGXWalletServer.cpp SGXRegistrationServer.cpp CSRManagerServer.cpp SGXInfoServer.cpp \
+             BLSCrypto.cpp ECDSACrypto.cpp \
              DKGCrypto.cpp ServerInit.cpp BLSPrivateKeyShareSGX.cpp LevelDB.cpp ServerDataChecker.cpp SEKManager.cpp \
              third_party/intel/sgx_stub.c third_party/intel/sgx_detect_linux.c third_party/intel/create_enclave.c third_party/intel/oc_alloc.c \
              ECDSAImpl.c TestUtils.cpp sgxwallet.c
@@ -111,8 +111,10 @@ nodist_testw_SOURCES=${nodist_sgxwallet_SOURCES}
 EXTRA_testw_DEPENDENCIES=${EXTRA_sgxwallet_DEPENDENCIES}
 testw_LDADD= ${sgxwallet_LDADD}
 
-cert_util_SOURCES= InvalidStateException.cpp  Exception.cpp InvalidArgumentException.cpp Log.cpp cert_util.cpp stubclient.cpp LevelDB.cpp SGXRegistrationServer.cpp CSRManagerServer.cpp
-cert_util_LDADD=-LlibBLS/deps/deps_inst/x86_or_x64/lib -Lleveldb/build -LlibBLS/build \
-                   -LlibBLS/build/libff/libff \
-                   -l:libbls.a -l:libleveldb.a \
-                   -l:libff.a -lgmp  -ljsonrpccpp-stub -ljsonrpccpp-server -ljsonrpccpp-client -ljsonrpccpp-common -ljsoncpp -lmicrohttpd -lgnutls -lgcrypt -lidn2 -lcurl -lssl -lcrypto -lz -lpthread -ldl
+sgx_util_SOURCES= InvalidStateException.cpp Exception.cpp InvalidArgumentException.cpp Log.cpp sgx_util.cpp stubclient.cpp LevelDB.cpp \
+                  SGXRegistrationServer.cpp CSRManagerServer.cpp SGXInfoServer.cpp
+
+sgx_util_LDADD= -LlibBLS/deps/deps_inst/x86_or_x64/lib -Lleveldb/build -LlibBLS/build \
+                -LlibBLS/build/libff/libff \
+                -l:libbls.a -l:libleveldb.a \
+                -l:libff.a -lgmp  -ljsonrpccpp-stub -ljsonrpccpp-server -ljsonrpccpp-client -ljsonrpccpp-common -ljsoncpp -lmicrohttpd -lgnutls -lgcrypt -lidn2 -lcurl -lssl -lcrypto -lz -lpthread -ldl

SGXInfoServer.cpp

+/*
+    Copyright (C) 2020-Present SKALE Labs
+
+    This file is part of sgxwallet.
+
+    sgxwallet is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    sgxwallet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with sgxwallet.  If not, see <https://www.gnu.org/licenses/>.
+
+    @file SGXInfoServer.cpp
+    @author Oleh Nikolaiev
+    @date 2020
+*/
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+
+#include <jsonrpccpp/server/connectors/httpserver.h>
+
+#include <stdio.h>
+
+#include "sgxwallet_common.h"
+
+#include "SGXException.h"
+#include "LevelDB.h"
+
+#include "SGXInfoServer.h"
+#include "LevelDB.h"
+
+#include "Log.h"
+#include "common.h"
+
+shared_ptr <SGXInfoServer> SGXInfoServer::server = nullptr;
+shared_ptr <HttpServer> SGXInfoServer::httpServer = nullptr;
+
+SGXInfoServer::SGXInfoServer(AbstractServerConnector &connector, serverVersion_t type)
+        : AbstractInfoServer(connector, type) {}
+
+Json::Value SGXInfoServer::getAllKeysInfo() {
+    Json::Value result;
+
+    try {
+        result["allKeys"] = LevelDB::getLevelDb()->getAllKeys().str();
+    } HANDLE_SGX_EXCEPTION(result)
+
+    RETURN_SUCCESS(result)
+}
+
+Json::Value SGXInfoServer::getLastCreatedKey() {
+    Json::Value result;
+
+    try {
+        pair<string, uint64_t> key = LevelDB::getLevelDb()->getLastCreatedKey();
+        result["keyName"] = key.first;
+        result["creationTime"] = key.second;
+    } HANDLE_SGX_EXCEPTION(result)
+
+    RETURN_SUCCESS(result)
+}
+
+Json::Value SGXInfoServer::getServerConfiguration() {
+    Json::Value result;
+
+    try {
+        result["autoConfirm"] = false;
+        result["logLevel"] = false;
+        result["enclaveLogLevel"] = false;
+        result["backupOption"] = false;
+        result["HTTPS"] = false;
+        result["autoSign"] = false;
+        result["createTestKeys"] = false;
+    } HANDLE_SGX_EXCEPTION(result)
+
+    RETURN_SUCCESS(result)
+}
+
+Json::Value SGXInfoServer::isKeyExist(const string& key) {
+    Json::Value result;
+
+    result["isExists"] = false;
+    try {
+        shared_ptr <string> keyPtr = LevelDB::getLevelDb()->readString(key);
+
+        if (keyPtr != nullptr) {
+            result["IsExist"] = true;
+        }
+    } HANDLE_SGX_EXCEPTION(result)
+
+    RETURN_SUCCESS(result)
+}
+
+int SGXInfoServer::initInfoServer() {
+    httpServer = make_shared<HttpServer>(BASE_PORT + 5);
+    server = make_shared<SGXInfoServer>(*httpServer, JSONRPC_SERVER_V2); // hybrid server (json-rpc 1.0 & 2.0)
+
+    if (!server->StartListening()) {
+        spdlog::error("Info server could not start listening on port {}", BASE_PORT + 5);
+        exit(-10);
+    } else {
+        spdlog::info("Info server started on port {}", BASE_PORT + 5);
+    }
+
+    return 0;
+}
+
+shared_ptr<SGXInfoServer> SGXInfoServer::getServer() {
+    CHECK_STATE(server);
+    return server;
+}

SGXInfoServer.h

+/*
+    Copyright (C) 2020-Present SKALE Labs
+
+    This file is part of sgxwallet.
+
+    sgxwallet is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    sgxwallet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with sgxwallet.  If not, see <https://www.gnu.org/licenses/>.
+
+    @file SGXInfoServer.h
+    @author Oleh Nikolaiev
+    @date 2020
+*/
+
+#ifndef SGXINFOSERVER_H
+#define SGXINFOSERVER_H
+
+#include <mutex>
+
+#include "abstractinfoserver.h"
+#include <jsonrpccpp/server/connectors/httpserver.h>
+
+using namespace jsonrpc;
+using namespace std;
+
+class SGXInfoServer : public AbstractInfoServer {
+    recursive_mutex m;
+
+    bool autoSign;
+
+    static shared_ptr <HttpServer> httpServer;
+
+    static shared_ptr <SGXInfoServer> server;
+
+public:
+
+    static shared_ptr <SGXInfoServer> getServer();
+
+    SGXInfoServer(AbstractServerConnector &connector, serverVersion_t type);
+
+    virtual Json::Value getAllKeysInfo();
+
+    virtual Json::Value getLastCreatedKey();
+
+    virtual Json::Value getServerConfiguration();
+
+    virtual Json::Value isKeyExist(const string& key);
+
+    static int initInfoServer();
+
+};
+
+#endif // SGXINFOSERVER_H

ServerInit.cpp

@@ -52,6 +52,7 @@
 #include "LevelDB.h"
 #include "SGXWalletServer.h"
 #include "SGXRegistrationServer.h"
+#include "SGXInfoServer.h"
 #include "SEKManager.h"
 #include "CSRManagerServer.h"
 #include "BLSCrypto.h"
@@ -199,7 +200,7 @@ void initAll(uint32_t _logLevel, bool _checkCert, bool _autoSign) {
         CHECK_STATE(sgxServerInited != 1)
         sgxServerInited = 1;
 
-        uint64_t  counter = 0;
+        uint64_t counter = 0;
 
         uint64_t initResult = 0;
         while ((initResult = initEnclave()) != 0 && counter < 10){
@@ -221,6 +222,8 @@ void initAll(uint32_t _logLevel, bool _checkCert, bool _autoSign) {
         } else {
             SGXWalletServer::initHttpServer();
         }
+        SGXInfoServer::initInfoServer();
+
         sgxServerInited = true;
     } catch (SGXException &_e) {
         spdlog::error(_e.getMessage());

abstractinfoserver.h

+/*
+    Copyright (C) 2020-Present SKALE Labs
+
+    This file is part of sgxwallet.
+
+    sgxwallet is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    sgxwallet is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with sgxwallet.  If not, see <https://www.gnu.org/licenses/>.
+
+    @file abstractinfoserver.h
+    @author Oleh Nikolaiev
+    @date 2020
+*/
+
+#ifndef ABSTRACTINFOSERVER_H
+#define ABSTRACTINFOSERVER_H
+
+#include <jsonrpccpp/server.h>
+#include <iostream>
+
+class AbstractInfoServer : public jsonrpc::AbstractServer<AbstractInfoServer>
+{
+public:
+  AbstractInfoServer(jsonrpc::AbstractServerConnector &conn, jsonrpc::serverVersion_t type = jsonrpc::JSONRPC_SERVER_V2) : jsonrpc::AbstractServer<AbstractInfoServer>(conn, type)
+  {
+    this->bindAndAddMethod(jsonrpc::Procedure("getAllKeysInfo", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, NULL), &AbstractInfoServer::getAllKeysInfoI);
+    this->bindAndAddMethod(jsonrpc::Procedure("getLastCreatedKey", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, NULL), &AbstractInfoServer::getLastCreatedKeyI);
+    this->bindAndAddMethod(jsonrpc::Procedure("getServerConfiguration", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT, NULL), &AbstractInfoServer::getServerConfigurationI);
+    this->bindAndAddMethod(jsonrpc::Procedure("isKeyExist", jsonrpc::PARAMS_BY_NAME, jsonrpc::JSON_OBJECT,"key",jsonrpc::JSON_STRING, NULL), &AbstractInfoServer::isKeyExistI);
+  }
+
+  inline virtual void getAllKeysInfoI(const Json::Value &request, Json::Value &response)
+  {
+      response = this->getAllKeysInfo();
+  }
+
+  inline virtual void getLastCreatedKeyI(const Json::Value &request, Json::Value &response)
+  {
+      response = this->getLastCreatedKey();
+  }
+
+  inline virtual void getServerConfigurationI(const Json::Value &request, Json::Value &response)
+  {
+      response = this->getServerConfiguration();
+  }
+
+  inline virtual void isKeyExistI(const Json::Value &request, Json::Value &response)
+  {
+    response = this->isKeyExist(request["key"].asString());
+  }
+
+
+  virtual Json::Value getAllKeysInfo() = 0;
+  virtual Json::Value getLastCreatedKey() = 0;
+  virtual Json::Value getServerConfiguration() = 0;
+  virtual Json::Value isKeyExist(const std::string& key) = 0;
+
+};
+
+#endif // ABSTRACTINFOSERVER_H

cert_util.cpp → sgx_util.cpp

@@ -16,7 +16,7 @@
     You should have received a copy of the GNU Affero General Public License
     along with sgxwallet.  If not, see <https://www.gnu.org/licenses/>.
 
-    @file cert_util.cpp
+    @file sgx_util.cpp
     @author Stan Kladko
     @date 2019
 */
@@ -44,6 +44,45 @@ void sign_by_hash(std::string & hash, int status){
   exit(0);
 }
 
+void getAllKeysInfo() {
+    jsonrpc::HttpClient client("http://localhost:1030");
+    StubClient c(client, jsonrpc::JSONRPC_CLIENT_V2);
+    std::cout << "Info client inited" << std::endl;
+    std::cout << c.getAllKeysInfo()["allKeys"] << std::endl;
+    exit(0);
+}
+
+void getLastCreatedKey() {
+    jsonrpc::HttpClient client("http://localhost:1030");
+    StubClient c(client, jsonrpc::JSONRPC_CLIENT_V2);
+    std::cout << "Info client inited" << std::endl;
+    Json::Value lastCreatedKey = c.getLastCreatedKey();
+    std::cout << "Last created key name: " << lastCreatedKey["keyName"] << std::endl;
+    std::cout << "Last created key creation time: " << lastCreatedKey["creationTime"] << std::endl;
+    exit(0);
+}
+
+void getServerConfiguration() {
+    jsonrpc::HttpClient client("http://localhost:1030");
+    StubClient c(client, jsonrpc::JSONRPC_CLIENT_V2);
+    std::cout << "Info client inited" << std::endl;
+    Json::Value response = c.getServerConfiguration();
+
+    exit(0);
+}
+
+void isKeyExists(const std::string& key) {
+    jsonrpc::HttpClient client("http://localhost:1030");
+    StubClient c(client, jsonrpc::JSONRPC_CLIENT_V2);
+    std::cout << "Info client inited" << std::endl;
+    if (c.isKeyExist(key)) {
+        std::cout << "Key with name " << key << "presents in server database.";
+    } else {
+        std::cout << "Key with name " << key << "does not exist in server's database.";
+    }
+    exit(0);
+}
+
 int main(int argc, char *argv[]) {
   int opt;
 

stubclient.h

@@ -263,55 +263,99 @@ class StubClient : public jsonrpc::Client
                 throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
         }
 
+        Json::Value getServerStatus()
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("getServerStatus",p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+
+        Json::Value getServerVersion() {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("getServerVersion",p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+
 
     ////CSRManagerServer
 
-  Json::Value getUnsignedCSRs() 
-  {
-    Json::Value p;
-    p = Json::nullValue;
-    Json::Value result = this->CallMethod("getUnsignedCSRs",p);
-    if (result.isObject())
-      return result;
-    else
-      throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
-  }
-
-
-
-    Json::Value signByHash(const std::string& hash, int status) 
-    {
-        Json::Value p;
-        p["hash"] = hash;
-        p["status"] = status;
-        Json::Value result = this->CallMethod("signByHash",p);
-        if (result.isObject())
+        Json::Value getUnsignedCSRs()
+        {
+          Json::Value p;
+          p = Json::nullValue;
+          Json::Value result = this->CallMethod("getUnsignedCSRs",p);
+          if (result.isObject())
             return result;
-        else
+          else
             throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
-    }
+        }
 
+        Json::Value signByHash(const std::string& hash, int status)
+        {
+            Json::Value p;
+            p["hash"] = hash;
+            p["status"] = status;
+            Json::Value result = this->CallMethod("signByHash",p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
 
-    Json::Value getServerStatus()
-    {
-        Json::Value p;
-        p = Json::nullValue;
-        Json::Value result = this->CallMethod("getServerStatus",p);
-        if (result.isObject())
-            return result;
-        else
-            throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
-    }
 
-    Json::Value getServerVersion() {
-        Json::Value p;
-        p = Json::nullValue;
-        Json::Value result = this->CallMethod("getServerVersion",p);
-        if (result.isObject())
-            return result;
-        else
-            throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
-    }
+        /// InfoServer
+
+        Json::Value getAllKeysInfo()
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("getAllKeysInfo", p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+
+        Json::Value getLastCreatedKey()
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("getLastCreatedKey", p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+
+        Json::Value getServerConfiguration()
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("getServerConfiguration", p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
+
+        Json::Value isKeyExist(const std::string& key)
+        {
+            Json::Value p;
+            p["keyName"] = key;
+            Json::Value result = this->CallMethod("isKeyExist", p);
+            if (result.isObject())
+                return result;
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
 
 };