add mrenclave to service start log

Signed-off-by: Jun Kimura <jun.kimura@datachain.jp>

Author: bluele

Cargo.lock

@@ -2,7 +2,7 @@ use crate::enclave::EnclaveLoader;
 use crate::opts::{EnclaveOpts, Opts};
 use anyhow::Result;
 use clap::Parser;
-use enclave_api::{Enclave, EnclaveProtoAPI};
+use enclave_api::{Enclave, EnclaveInfo, EnclaveProtoAPI};
 use host::store::transaction::CommitStore;
 use log::*;
 use service::{run_service, AppService};
@@ -49,7 +49,8 @@ impl ServiceCmd {
                 let addr = cmd.address.parse()?;
                 let enclave =
                     enclave_loader.load(opts, cmd.enclave.path.as_ref(), cmd.enclave.is_debug())?;
-
+                let metadata = enclave.metadata()?;
+                let mrenclave = metadata.mrenclave().to_hex_string();
                 let mut rb = Builder::new_multi_thread();
                 let rb = if let Some(threads) = cmd.threads {
                     rb.worker_threads(threads)
@@ -59,7 +60,7 @@ impl ServiceCmd {
                 let rt = Arc::new(rb.enable_all().build()?);
                 let srv = AppService::new(opts.get_home(), enclave);
 
-                info!("start service: addr={addr}");
+                info!("start service: addr={addr} mrenclave={mrenclave}");
                 run_service(srv, rt, addr)
             }
         }

app/src/commands/service.rs

@@ -1,6 +1,7 @@
 use crate::errors::Result;
 use keymanager::EnclaveKeyManager;
-use sgx_types::{metadata::metadata_t, sgx_enclave_id_t, SgxResult};
+use lcp_types::EnclaveMetadata;
+use sgx_types::{sgx_enclave_id_t, SgxResult};
 use sgx_urts::SgxEnclave;
 use std::path::PathBuf;
 use std::sync::{Arc, RwLock};
@@ -54,7 +55,7 @@ pub trait EnclaveInfo: Sync + Send {
     /// `get_eid` returns the enclave id
     fn get_eid(&self) -> sgx_enclave_id_t;
     /// `metadata` returns the metadata of the enclave
-    fn metadata(&self) -> SgxResult<metadata_t>;
+    fn metadata(&self) -> SgxResult<EnclaveMetadata>;
     /// `is_debug` returns true if the enclave is in debug mode
     fn is_debug(&self) -> bool;
     /// `get_key_manager` returns a key manager for Enclave Keys
@@ -67,7 +68,7 @@ impl<S: CommitStore> EnclaveInfo for Enclave<S> {
         self.sgx_enclave.geteid()
     }
     /// `metadata` returns the metadata of the enclave
-    fn metadata(&self) -> SgxResult<metadata_t> {
+    fn metadata(&self) -> SgxResult<EnclaveMetadata> {
         host::sgx_get_metadata(&self.path)
     }
     /// `is_debug` returns true if the enclave is in debug mode

modules/enclave-api/src/enclave.rs

@@ -10,6 +10,7 @@ log = "0.4.8"
 once_cell = "1.15.0"
 bincode = { version = "2.0.0-rc.3", default-features = false, features = ["serde", "alloc"] }
 
+lcp-types = { path = "../types" }
 ocall-commands = { path = "../ocall-commands" }
 ocall-handler = { path = "../ocall-handler", default-features = false }
 

modules/host/Cargo.toml

@@ -1,7 +1,13 @@
+use lcp_types::EnclaveMetadata;
 use sgx_types::{metadata::metadata_t, *};
 use sgx_urts::SgxEnclave;
 use std::{ffi::CString, mem::MaybeUninit, path::PathBuf};
 
+/// Create an enclave with the given path and debug flag
+///
+/// # Arguments
+/// - `path`: path to the enclave binary
+/// - `debug`: debug flag
 pub fn create_enclave(path: impl Into<PathBuf>, debug: bool) -> SgxResult<SgxEnclave> {
     let mut launch_token: sgx_launch_token_t = [0; 1024];
     let mut launch_token_updated: i32 = 0;
@@ -18,7 +24,11 @@ pub fn create_enclave(path: impl Into<PathBuf>, debug: bool) -> SgxResult<SgxEnc
     )
 }
 
-pub fn sgx_get_metadata(path: impl Into<PathBuf>) -> SgxResult<metadata_t> {
+/// Get the metadata of an enclave from the given path
+///
+/// # Arguments
+/// - `path`: path to the enclave binary
+pub fn sgx_get_metadata(path: impl Into<PathBuf>) -> SgxResult<EnclaveMetadata> {
     let path = path.into();
     let enclave_path = CString::new(path.as_os_str().to_str().unwrap()).unwrap();
     let (metadata, status) = unsafe {
@@ -27,7 +37,7 @@ pub fn sgx_get_metadata(path: impl Into<PathBuf>) -> SgxResult<metadata_t> {
         (metadata, status)
     };
     if status == sgx_status_t::SGX_SUCCESS {
-        Ok(metadata)
+        Ok(metadata.into())
     } else {
         Err(status)
     }

modules/host/src/enclave.rs

@@ -9,7 +9,7 @@ pub use height::Height;
 pub use host::ClientId;
 /// re-export
 pub use lcp_proto as proto;
-pub use sgx::Mrenclave;
+pub use sgx::{EnclaveMetadata, Mrenclave};
 pub use time::{nanos_to_duration, Time, MAX_UNIX_TIMESTAMP_NANOS};
 pub use transmuter::{deserialize_bytes, serialize_bytes, BytesTransmuter};
 

modules/types/src/lib.rs

@@ -1,8 +1,9 @@
 use crate::{prelude::*, TypeError};
 use core::fmt::Display;
 use core::ops::Deref;
-use sgx_types::{sgx_measurement_t, SGX_HASH_SIZE};
+use sgx_types::{metadata::metadata_t, sgx_measurement_t, SGX_HASH_SIZE};
 
+/// MRENCLAVE is a measurement of the enclave
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct Mrenclave(pub [u8; SGX_HASH_SIZE]);
 
@@ -60,3 +61,32 @@ impl Mrenclave {
         Ok(Self(bytes))
     }
 }
+
+/// EnclaveMetadata is the metadata of an enclave
+pub struct EnclaveMetadata(metadata_t);
+
+impl Deref for EnclaveMetadata {
+    type Target = metadata_t;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl From<metadata_t> for EnclaveMetadata {
+    fn from(metadata: metadata_t) -> Self {
+        Self(metadata)
+    }
+}
+
+impl From<EnclaveMetadata> for metadata_t {
+    fn from(metadata: EnclaveMetadata) -> Self {
+        metadata.0
+    }
+}
+
+impl EnclaveMetadata {
+    /// Get the MRENCLAVE of the enclave from the metadata
+    pub fn mrenclave(&self) -> Mrenclave {
+        self.enclave_css.body.enclave_hash.m.into()
+    }
+}