SKALE-3951 add new message types to ZMQ server

Makefile.am

@@ -70,7 +70,10 @@ bin_PROGRAMS = sgxwallet testw sgx_util
 ## have to be explicitly listed
 
 
-COMMON_SRC = SGXException.cpp ExitHandler.cpp ZMQClient.cpp BLSSignRspMessage.cpp ECDSASignRspMessage.cpp ECDSASignReqMessage.cpp BLSSignReqMessage.cpp ZMQMessage.cpp ZMQServer.cpp ServerWorker.cpp InvalidStateException.cpp Exception.cpp InvalidArgumentException.cpp Log.cpp  \
+COMMON_SRC = SGXException.cpp ExitHandler.cpp zmq_src/ZMQClient.cpp zmq_src/BLSSignRspMessage.cpp \
+             zmq_src/ECDSASignRspMessage.cpp zmq_src/ECDSASignReqMessage.cpp zmq_src/BLSSignReqMessage.cpp \
+             zmq_src/ZMQMessage.cpp zmq_src/ZMQServer.cpp zmq_src/ServerWorker.cpp \
+             InvalidStateException.cpp Exception.cpp InvalidArgumentException.cpp Log.cpp  \
              SGXWalletServer.cpp SGXRegistrationServer.cpp CSRManagerServer.cpp BLSCrypto.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 \
@@ -110,18 +113,20 @@ sgxwallet_LDADD=-l$(SGX_URTS_LIB) -l$(SGX_UAE_SERVICE_LIB) -LlibBLS/deps/deps_in
    -ljsonrpccpp-stub -ljsonrpccpp-server -ljsonrpccpp-client -ljsonrpccpp-common -ljsoncpp -lmicrohttpd \
    -lboost_system -lboost_thread -lgnutls -lgcrypt -lidn2 -lcurl -lssl -lcrypto -lz -lpthread -lstdc++fs
 
-
 testw_SOURCES=testw.cpp $(COMMON_SRC)
 nodist_testw_SOURCES=${nodist_sgxwallet_SOURCES}
 EXTRA_testw_DEPENDENCIES=${EXTRA_sgxwallet_DEPENDENCIES}
-testw_LDADD= ${sgxwallet_LDADD}
+testw_LDADD=${sgxwallet_LDADD}
 
-sgx_util_SOURCES= SGXException.cpp ExitHandler.cpp InvalidStateException.cpp Exception.cpp InvalidArgumentException.cpp Log.cpp sgx_util.cpp stubclient.cpp LevelDB.cpp SGXRegistrationServer.cpp CSRManagerServer.cpp
+sgx_util_SOURCES=SGXException.cpp ExitHandler.cpp InvalidStateException.cpp Exception.cpp \
+                InvalidArgumentException.cpp Log.cpp sgx_util.cpp stubclient.cpp LevelDB.cpp \
+                SGXRegistrationServer.cpp CSRManagerServer.cpp
 
 sgx_util_LDADD=-LlibBLS/deps/deps_inst/x86_or_x64/lib -Lleveldb/build -LlibBLS/build \
                    -LlibBLS/build/libff/libff \
                    -Llibzmq/build/lib/ \
                    -l:libzmq.a \
                    -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
+                   -l:libff.a -lgmp -ljsonrpccpp-stub -ljsonrpccpp-server -ljsonrpccpp-client -ljsonrpccpp-common \
+                   -ljsoncpp -lmicrohttpd -lgnutls -lgcrypt -lidn2 -lcurl -lssl -lcrypto -lz -lpthread -ldl
 

ServerInit.cpp

@@ -58,7 +58,7 @@
 #include "BLSCrypto.h"
 #include "ServerInit.h"
 #include "SGXException.h"
-#include "ZMQServer.h"
+#include "zmq_src/ZMQServer.h"
 #include "SGXWalletServer.hpp"
 
 uint32_t enclaveLogLevel = 0;

TestUtils.cpp

@@ -42,7 +42,7 @@
 #include "SGXWalletServer.hpp"
 
 #include "catch.hpp"
-#include "ZMQClient.h"
+#include "zmq_src/ZMQClient.h"
 #include "BLSSigShare.h"
 #include "BLSSigShareSet.h"
 #include "BLSPublicKeyShare.h"

TestUtils.h

@@ -27,8 +27,6 @@
 #include <dkg/dkg.h>
 #include <jsonrpccpp/server/connectors/httpserver.h>
 #include <libff/algebra/curves/alt_bn128/alt_bn128_pp.hpp>
-// #include <libff/algebra/exponentiation/exponentiation.hpp>
-// #include <libff/algebra/fields/fp.hpp>
 #include <dkg/dkg.h>
 #include "sgxwallet_common.h"
 #include "third_party/intel/create_enclave.h"
@@ -41,7 +39,7 @@
 #include <sgx_tcrypto.h>
 #include "stubclient.h"
 #include <jsonrpccpp/server/connectors/httpserver.h>
-#include "ZMQClient.h"
+#include "zmq_src/ZMQClient.h"
 #include "abstractstubserver.h"
 
 using namespace std;

sgxwall.cpp

@@ -36,7 +36,7 @@
 
 #include "TestUtils.h"
 
-#include "ZMQServer.h"
+#include "zmq_src/ZMQServer.h"
 
 #include "testw.h"
 #include "sgxwall.h"

testw.cpp

@@ -57,8 +57,8 @@
 
 #include "SGXRegistrationServer.h"
 #include "SGXWalletServer.h"
-#include "ZMQClient.h"
-#include "ZMQServer.h"
+#include "zmq_src/ZMQClient.h"
+#include "zmq_src/ZMQServer.h"
 #include "sgxwallet.h"
 #include "TestUtils.h"
 #include "testw.h"

ZMQMessage.cpp → zmq_src/ZMQMessage.cpp

@@ -51,9 +51,6 @@ string ZMQMessage::getStringRapid(const char *_name) {
     return (*d)[_name].GetString();
 };
 
-
-
-
 shared_ptr <ZMQMessage> ZMQMessage::parse(const char *_msg,
                                           size_t _size, bool _isRequest,
                                           bool _verifySig) {
@@ -130,7 +127,6 @@ shared_ptr <ZMQMessage> ZMQMessage::parse(const char *_msg,
         }
     }
 
-
     shared_ptr <ZMQMessage> result;
 
     if (_isRequest) {
@@ -141,30 +137,175 @@ shared_ptr <ZMQMessage> ZMQMessage::parse(const char *_msg,
 }
 
 shared_ptr <ZMQMessage> ZMQMessage::buildRequest(string &_type, shared_ptr <rapidjson::Document> _d) {
-    if (_type == ZMQMessage::BLS_SIGN_REQ) {
-        return make_shared<BLSSignReqMessage>(_d);
-    } else if (_type == ZMQMessage::ECDSA_SIGN_REQ) {
-        return
-                make_shared<ECDSASignReqMessage>(_d);
-    } else {
-        BOOST_THROW_EXCEPTION(SGXException(-301, "Incorrect zmq message type: " +
-                                                 string(_type)));
+    Requests r;
+    try {
+        int t = requests.at( _type.c_str() );
+        r = static_cast<Requests>(t);
+    } catch ( std::out_of_range& ) {
+        BOOST_THROW_EXCEPTION(SGXException(-301, "Incorrect zmq message type: " + string(_type)));
+    }
+
+    shared_ptr<ZMQMessage> ret = nullptr;
+
+    switch (r) {
+        case ENUM_BLS_SIGN_REQ:
+            ret = make_shared<BLSSignReqMessage>(_d);
+            break;
+        case ENUM_ECDSA_SIGN_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_IMPORT_BLS_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_IMPORT_ECDSA_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GENERATE_ECDSA_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_PUBLIC_ECDSA_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GENERATE_DKG_POLY_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_VV_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_SECRET_SHARE_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_DKG_VERIFY_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_CREATE_BLS_PRIVATE_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_BLS_PUBLIC_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_ALL_BLS_PUBLIC_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_COMPLAINT_RESPONSE_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_MULT_G2_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_IS_POLY_EXISTS_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_SERVER_STATUS_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_GET_SERVER_VERSION_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        case ENUM_DELETE_BLS_KEY_REQ:
+            ret = make_shared<ECDSASignReqMessage>(_d);
+            break;
+        default:
+            break;
     }
+
+    return ret;
 }
 
 shared_ptr <ZMQMessage> ZMQMessage::buildResponse(string &_type, shared_ptr <rapidjson::Document> _d) {
-    if (_type == ZMQMessage::BLS_SIGN_RSP) {
-        return
-                make_shared<BLSSignRspMessage>(_d);
-    } else if (_type == ZMQMessage::ECDSA_SIGN_RSP) {
-        return
-                make_shared<ECDSASignRspMessage>(_d);
-    } else {
+    Responses r;
+    try {
+        int t = responses.at( _type.c_str() );
+        r = static_cast<Responses>(t);
+    } catch ( std::out_of_range& ) {
         BOOST_THROW_EXCEPTION(InvalidStateException("Incorrect zmq message request type: " + string(_type),
                                                     __CLASS_NAME__)
         );
     }
+
+    shared_ptr<ZMQMessage> ret = nullptr;
+
+    switch (r) {
+        case ENUM_BLS_SIGN_RSP:
+            ret = make_shared<BLSSignRspMessage>(_d);
+            break;
+        case ENUM_ECDSA_SIGN_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_IMPORT_BLS_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_IMPORT_ECDSA_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GENERATE_ECDSA_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_PUBLIC_ECDSA_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GENERATE_DKG_POLY_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_VV_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_SECRET_SHARE_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_DKG_VERIFY_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_CREATE_BLS_PRIVATE_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_BLS_PUBLIC_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_ALL_BLS_PUBLIC_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_COMPLAINT_RESPONSE_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_MULT_G2_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_IS_POLY_EXISTS_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_SERVER_STATUS_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_GET_SERVER_VERSION_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        case ENUM_DELETE_BLS_KEY_RSP:
+            ret = make_shared<ECDSASignRspMessage>(_d);
+            break;
+        default:
+            break;
+    }
+
+    return ret;
 }
 
-cache::lru_cache<string, pair < EVP_PKEY * , X509 *>>
-ZMQMessage::verifiedCerts(256);
\ No newline at end of file
+cache::lru_cache<string, pair < EVP_PKEY * , X509 *>> ZMQMessage::verifiedCerts(256);
+
+const std::map<const char *, int> ZMQMessage::responses {
+    {BLS_SIGN_REQ, 0}, {ECDSA_SIGN_REQ, 1}, {IMPORT_BLS_REQ, 2}, {IMPORT_ECDSA_REQ, 3},
+    {GENERATE_ECDSA_REQ, 4}, {GET_PUBLIC_ECDSA_REQ, 5}, {GENERATE_DKG_POLY_REQ, 6},
+    {GET_VV_REQ, 7}, {GET_SECRET_SHARE_REQ, 8}, {DKG_VERIFY_REQ, 9},
+    {CREATE_BLS_PRIVATE_REQ, 10}, {GET_BLS_PUBLIC_REQ, 11}, {GET_ALL_BLS_PUBLIC_REQ, 12},
+    {COMPLAINT_RESPONSE_REQ, 13}, {MULT_G2_REQ, 14}, {IS_POLY_EXISTS_REQ, 15},
+    {GET_SERVER_STATUS_REQ, 16}, {GET_SERVER_VERSION_REQ, 17}, {DELETE_BLS_KEY_REQ, 18}
+};
+
+const std::map<const char *, int> ZMQMessage::requests {
+    {BLS_SIGN_RSP, 0}, {ECDSA_SIGN_RSP, 1}, {IMPORT_BLS_RSP, 2}, {IMPORT_ECDSA_RSP, 3},
+    {GENERATE_ECDSA_RSP, 4}, {GET_PUBLIC_ECDSA_RSP, 5}, {GENERATE_DKG_POLY_RSP, 6},
+    {GET_VV_RSP, 7}, {GET_SECRET_SHARE_RSP, 8}, {DKG_VERIFY_RSP, 9},
+    {CREATE_BLS_PRIVATE_RSP, 10}, {GET_BLS_PUBLIC_RSP, 11}, {GET_ALL_BLS_PUBLIC_RSP, 12},
+    {COMPLAINT_RESPONSE_RSP, 13}, {MULT_G2_RSP, 14}, {IS_POLY_EXISTS_RSP, 15},
+    {GET_SERVER_STATUS_RSP, 16}, {GET_SERVER_VERSION_RSP, 17}, {DELETE_BLS_KEY_RSP, 18}
+};

ZMQMessage.h → zmq_src/ZMQMessage.h

@@ -52,19 +52,60 @@ class ZMQMessage {
 
     static cache::lru_cache<string, pair<EVP_PKEY*, X509*>> verifiedCerts;
 
-protected:
-
-
 public:
 
-
     static constexpr const char *BLS_SIGN_REQ = "BLSSignReq";
     static constexpr const char *BLS_SIGN_RSP = "BLSSignRsp";
     static constexpr const char *ECDSA_SIGN_REQ = "ECDSASignReq";
     static constexpr const char *ECDSA_SIGN_RSP = "ECDSASignRsp";
-
-    explicit ZMQMessage(shared_ptr<rapidjson::Document> &_d) : d(_d) {
-    };
+    static constexpr const char *IMPORT_BLS_REQ = "importBLSReq";
+    static constexpr const char *IMPORT_BLS_RSP = "importBLSRps";
+    static constexpr const char *IMPORT_ECDSA_REQ = "importECDSAReq";
+    static constexpr const char *IMPORT_ECDSA_RSP = "importECDSARsp";
+    static constexpr const char *GENERATE_ECDSA_REQ = "generateECDSAReq";
+    static constexpr const char *GENERATE_ECDSA_RSP = "generateECDSARsp";
+    static constexpr const char *GET_PUBLIC_ECDSA_REQ = "getPublicECDSAReq";
+    static constexpr const char *GET_PUBLIC_ECDSA_RSP = "getPublicECDSARsp";
+    static constexpr const char *GENERATE_DKG_POLY_REQ = "generateDKGPolyReq";
+    static constexpr const char *GENERATE_DKG_POLY_RSP = "generateDKGPolyRsp";
+    static constexpr const char *GET_VV_REQ = "getVerificationVectorReq";
+    static constexpr const char *GET_VV_RSP = "getVerificationVectorRsp";
+    static constexpr const char *GET_SECRET_SHARE_REQ = "getSecretShareReq";
+    static constexpr const char *GET_SECRET_SHARE_RSP = "getSecretShareRsp";
+    static constexpr const char *DKG_VERIFY_REQ = "dkgVerificationReq";
+    static constexpr const char *DKG_VERIFY_RSP = "dkgVerificationRsp";
+    static constexpr const char *CREATE_BLS_PRIVATE_REQ = "createBLSPrivateReq";
+    static constexpr const char *CREATE_BLS_PRIVATE_RSP = "createBLSPrivateRsp";
+    static constexpr const char *GET_BLS_PUBLIC_REQ = "getBLSPublicReq";
+    static constexpr const char *GET_BLS_PUBLIC_RSP = "getBLSPublicRsp";
+    static constexpr const char *GET_ALL_BLS_PUBLIC_REQ = "getAllBLSPublicReq";
+    static constexpr const char *GET_ALL_BLS_PUBLIC_RSP = "getAllBLSPublicRsp";
+    static constexpr const char *COMPLAINT_RESPONSE_REQ = "complaintResponseReq";
+    static constexpr const char *COMPLAINT_RESPONSE_RSP = "complaintResponseRsp";
+    static constexpr const char *MULT_G2_REQ = "multG2Req";
+    static constexpr const char *MULT_G2_RSP = "multG2Rsp";
+    static constexpr const char *IS_POLY_EXISTS_REQ = "isPolyExistsReq";
+    static constexpr const char *IS_POLY_EXISTS_RSP = "isPolyExistsRsp";
+    static constexpr const char *GET_SERVER_STATUS_REQ = "getServerStatusReq";
+    static constexpr const char *GET_SERVER_STATUS_RSP = "getServerStatusRsp";
+    static constexpr const char *GET_SERVER_VERSION_REQ = "getServerVersionReq";
+    static constexpr const char *GET_SERVER_VERSION_RSP = "getServerVersionRsp";
+    static constexpr const char *DELETE_BLS_KEY_REQ = "deleteBLSKeyReq";
+    static constexpr const char *DELETE_BLS_KEY_RSP = "deleteBLSKeyRsp";
+
+    static const std::map<const char *, int> requests;
+    static const std::map<const char *, int> responses;
+
+    enum Requests { ENUM_BLS_SIGN_REQ, ENUM_ECDSA_SIGN_REQ, ENUM_IMPORT_BLS_REQ, ENUM_IMPORT_ECDSA_REQ, ENUM_GENERATE_ECDSA_REQ, ENUM_GET_PUBLIC_ECDSA_REQ,
+                    ENUM_GENERATE_DKG_POLY_REQ, ENUM_GET_VV_REQ, ENUM_GET_SECRET_SHARE_REQ, ENUM_DKG_VERIFY_REQ, ENUM_CREATE_BLS_PRIVATE_REQ,
+                    ENUM_GET_BLS_PUBLIC_REQ, ENUM_GET_ALL_BLS_PUBLIC_REQ, ENUM_COMPLAINT_RESPONSE_REQ, ENUM_MULT_G2_REQ, ENUM_IS_POLY_EXISTS_REQ,
+                    ENUM_GET_SERVER_STATUS_REQ, ENUM_GET_SERVER_VERSION_REQ, ENUM_DELETE_BLS_KEY_REQ };
+    enum Responses { ENUM_BLS_SIGN_RSP, ENUM_ECDSA_SIGN_RSP, ENUM_IMPORT_BLS_RSP, ENUM_IMPORT_ECDSA_RSP, ENUM_GENERATE_ECDSA_RSP, ENUM_GET_PUBLIC_ECDSA_RSP,
+                    ENUM_GENERATE_DKG_POLY_RSP, ENUM_GET_VV_RSP, ENUM_GET_SECRET_SHARE_RSP, ENUM_DKG_VERIFY_RSP, ENUM_CREATE_BLS_PRIVATE_RSP,
+                    ENUM_GET_BLS_PUBLIC_RSP, ENUM_GET_ALL_BLS_PUBLIC_RSP, ENUM_COMPLAINT_RESPONSE_RSP, ENUM_MULT_G2_RSP, ENUM_IS_POLY_EXISTS_RSP,
+                    ENUM_GET_SERVER_STATUS_RSP, ENUM_GET_SERVER_VERSION_RSP, ENUM_DELETE_BLS_KEY_RSP };
+
+    explicit ZMQMessage(shared_ptr<rapidjson::Document> &_d) : d(_d) {};
 
     string getStringRapid(const char *_name);