More return code variants for some possible exceptions on Enclave() creation

src/common/enclave_interface_types.h

@@ -21,6 +21,18 @@ enum CreateNodeStatus
 
   /** One of the input buffers is not located outside of the enclave memory */
   MemoryNotOutsideEnclave = 5,
+
+  /** Enclave initialisation failed */
+  EnclaveInitFailed = 6,
+
+  /** Open Enclave Verifier initialisation failed */
+  OEVerifierInitFailed = 7,
+
+  /** Open Enclave Attester initialisation failed */
+  OEAttesterInitFailed = 8,
+
+  /** OpenSSL RDRAND Init Failed */
+  OpenSSLRDRANDInitFailed = 9
 };
 
 constexpr char const* create_node_result_to_str(CreateNodeStatus result)

src/ds/ccf_exception.h

@@ -31,4 +31,28 @@ namespace ccf
   private:
     std::string result;
   };
+
+  class ccf_oe_attester_init_error : public ccf_logic_error
+  {
+  public:
+    ccf_oe_attester_init_error(const std::string& what_arg) :
+      ccf_logic_error(what_arg)
+    {}
+  };
+
+  class ccf_oe_verifier_init_error : public ccf_logic_error
+  {
+  public:
+    ccf_oe_verifier_init_error(const std::string& what_arg) :
+      ccf_logic_error(what_arg)
+    {}
+  };
+
+  class ccf_openssl_rdrand_init_error : public ccf_logic_error
+  {
+  public:
+    ccf_openssl_rdrand_init_error(const std::string& what_arg) :
+      ccf_logic_error(what_arg)
+    {}
+  };
 };

src/enclave/enclave.h

@@ -98,7 +98,7 @@ namespace enclave
         ENGINE_set_default(rdrand_engine, ENGINE_METHOD_RAND) != 1)
       {
         ENGINE_free(rdrand_engine);
-        throw std::runtime_error(
+        throw ccf::ccf_openssl_rdrand_init_error(
           "could not initialize RDRAND engine for OpenSSL");
       }
 

src/enclave/main.cpp

@@ -2,6 +2,7 @@
 // Licensed under the Apache 2.0 License.
 #include "ccf/version.h"
 #include "common/enclave_interface_types.h"
+#include "ds/ccf_exception.h"
 #include "ds/json.h"
 #include "ds/logger.h"
 #include "enclave.h"
@@ -143,9 +144,29 @@ extern "C"
 #ifdef DEBUG_CONFIG
     reserved_memory = new uint8_t[ec->debug_config.memory_reserve_startup];
 #endif
+    enclave::Enclave* enclave;
 
-    auto enclave = new enclave::Enclave(
-      ec, cc.signature_intervals, cc.consensus_config, cc.curve_id);
+    try
+    {
+      enclave = new enclave::Enclave(
+        ec, cc.signature_intervals, cc.consensus_config, cc.curve_id);
+    }
+    catch (const ccf::ccf_oe_attester_init_error&)
+    {
+      return CreateNodeStatus::OEAttesterInitFailed;
+    }
+    catch (const ccf::ccf_oe_verifier_init_error&)
+    {
+      return CreateNodeStatus::OEVerifierInitFailed;
+    }
+    catch (const ccf::ccf_openssl_rdrand_init_error&)
+    {
+      return CreateNodeStatus::OpenSSLRDRANDInitFailed;
+    }
+    catch (const std::exception&)
+    {
+      return CreateNodeStatus::EnclaveInitFailed;
+    }
 
     if (!enclave->create_new_node(
           start_type,

src/enclave/oe_init.h

@@ -7,6 +7,7 @@
 #else
 #  include <openenclave/host_verify.h>
 #endif
+#include "ds/ccf_exception.h"
 
 namespace ccf
 {
@@ -17,7 +18,7 @@ namespace ccf
       auto rc = oe_attester_initialize();
       if (rc != OE_OK)
       {
-        throw std::logic_error(fmt::format(
+        throw std::ccf_oe_attester_init_error(fmt::format(
           "Failed to initialise evidence attester: {}", oe_result_str(rc)));
       }
     }
@@ -26,7 +27,7 @@ namespace ccf
       auto rc = oe_verifier_initialize();
       if (rc != OE_OK)
       {
-        throw std::logic_error(fmt::format(
+        throw ccf::ccf_oe_verifier_init_error(fmt::format(
           "Failed to initialise evidence verifier: {}", oe_result_str(rc)));
       }
     }