This is an automated email from the ASF dual-hosted git repository.
mssun pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/incubator-teaclave.git
The following commit(s) were added to refs/heads/develop by this push:
new 05cfee3 Implement better error propagation mechanism for binder/ipc
05cfee3 is described below
commit 05cfee338f5876df3e6a30da150eaf4da76065bc
Author: Mingshen Sun <[email protected]>
AuthorDate: Wed Feb 5 23:07:55 2020 -0800
Implement better error propagation mechanism for binder/ipc
---
binder/Cargo.toml | 2 ++
binder/src/binder.rs | 55 +++++++++++++++++++++---------
ipc/Cargo.toml | 1 +
ipc/src/channel/app_dep.rs | 34 +++++++++---------
ipc/src/channel/tee_dep.rs | 8 ++---
ipc/src/lib.rs | 16 +++++++--
ipc/src/macros.rs | 17 +++++----
services/access_control/app/Cargo.toml | 1 +
services/access_control/app/src/main.rs | 12 ++++---
services/access_control/enclave/src/lib.rs | 17 +++++----
services/authentication/app/Cargo.toml | 1 +
services/authentication/app/src/main.rs | 9 +++--
services/authentication/enclave/src/lib.rs | 27 +++++++--------
services/execution/app/Cargo.toml | 1 +
services/execution/app/src/main.rs | 11 ++++--
services/execution/enclave/src/lib.rs | 31 ++++++++++-------
services/frontend/app/Cargo.toml | 1 +
services/frontend/app/src/main.rs | 9 +++--
services/frontend/enclave/src/lib.rs | 17 +++++----
services/management/app/Cargo.toml | 1 +
services/management/app/src/main.rs | 9 +++--
services/management/enclave/src/lib.rs | 17 +++++----
services/storage/app/Cargo.toml | 1 +
services/storage/app/src/main.rs | 15 ++++----
services/storage/enclave/src/lib.rs | 20 ++++++-----
tests/functional_tests/app/Cargo.toml | 1 +
tests/functional_tests/app/src/main.rs | 10 ++++--
tests/functional_tests/enclave/src/lib.rs | 10 +++---
tests/integration_tests/app/Cargo.toml | 1 +
tests/integration_tests/app/src/main.rs | 25 ++++++++------
tests/integration_tests/enclave/src/lib.rs | 10 +++---
tests/scripts/functional_tests.py | 52 ++++++++++++++--------------
tests/unit_tests/app/Cargo.toml | 1 +
tests/unit_tests/app/src/main.rs | 11 ++++--
tests/unit_tests/enclave/src/lib.rs | 10 +++---
types/src/lib.rs | 14 +++++++-
utils/service_enclave_utils/Cargo.toml | 1 +
utils/service_enclave_utils/src/lib.rs | 8 ++---
38 files changed, 306 insertions(+), 181 deletions(-)
diff --git a/binder/Cargo.toml b/binder/Cargo.toml
index 0cbe149..209207c 100644
--- a/binder/Cargo.toml
+++ b/binder/Cargo.toml
@@ -12,8 +12,10 @@ env_logger = { version = "0.7.1" }
log = { version = "0.4.6" }
serde = { version = "1.0.92", features = ["derive"] }
serde_json = { version = "1.0.39" }
+thiserror = { version = "1.0.9" }
teaclave_ipc = { path = "../ipc" }
+teaclave_types = { path = "../types" }
sgx_types = { version = "1.1.0" }
sgx_urts = { version = "1.1.0", features = ["global_init"] }
diff --git a/binder/src/binder.rs b/binder/src/binder.rs
index d521174..7c3a70e 100644
--- a/binder/src/binder.rs
+++ b/binder/src/binder.rs
@@ -20,49 +20,69 @@ use sgx_urts::SgxEnclave;
use serde::{Deserialize, Serialize};
-use anyhow::Result;
use teaclave_ipc::channel::ECallChannel;
use teaclave_ipc::proto::{
ECallCommand, FinalizeEnclaveInput, FinalizeEnclaveOutput,
InitEnclaveInput, InitEnclaveOutput,
};
use teaclave_ipc::IpcSender;
+use teaclave_types::TeeServiceResult;
static ENCLAVE_FILE_SUFFIX: &str = "_enclave.signed.so";
+#[derive(thiserror::Error, Debug)]
+pub enum TeeBinderError {
+ #[error("IpcError")]
+ IpcError,
+ #[error("SgxError")]
+ SgxError(sgx_types::sgx_status_t),
+ #[error("TeeServiceError")]
+ TeeServiceError,
+}
+
pub struct TeeBinder {
enclave: SgxEnclave,
}
impl TeeBinder {
- pub fn new(name: &str, debug_launch: i32) -> Result<TeeBinder> {
- let enclave = create_sgx_enclave(&name, debug_launch)?;
+ pub fn new(name: &str) -> std::result::Result<TeeBinder, TeeBinderError> {
+ let enclave = if cfg!(production) {
+ create_sgx_enclave(&name, false)?
+ } else {
+ create_sgx_enclave(&name, true)?
+ };
debug!("EnclaveID: {}", enclave.geteid());
let tee = TeeBinder { enclave };
- let args_info = InitEnclaveInput::default();
- let _ret_info = tee.invoke::<InitEnclaveInput, InitEnclaveOutput>(
- ECallCommand::InitEnclave.into(),
- args_info,
+ let input = InitEnclaveInput::default();
+ let _ = tee.invoke::<InitEnclaveInput,
TeeServiceResult<InitEnclaveOutput>>(
+ ECallCommand::InitEnclave,
+ input,
)?;
Ok(tee)
}
- pub fn invoke<U, V>(&self, cmd: u32, args_info: U) -> Result<V>
+ pub fn invoke<U, V>(
+ &self,
+ command: ECallCommand,
+ input: U,
+ ) -> std::result::Result<V, TeeBinderError>
where
U: Serialize,
V: for<'de> Deserialize<'de>,
{
let mut channel = ECallChannel::new(self.enclave.geteid());
- channel.invoke::<U, V>(cmd, args_info)
+ channel
+ .invoke::<U, V>(command.into(), input)
+ .map_err(|_| TeeBinderError::IpcError)
}
pub fn finalize(&self) {
- let args_info = FinalizeEnclaveInput::default();
- match self.invoke::<FinalizeEnclaveInput, FinalizeEnclaveOutput>(
- ECallCommand::FinalizeEnclave.into(),
- args_info,
+ let input = FinalizeEnclaveInput::default();
+ match self.invoke::<FinalizeEnclaveInput,
TeeServiceResult<FinalizeEnclaveOutput>>(
+ ECallCommand::FinalizeEnclave,
+ input,
) {
Ok(_) => {}
Err(e) => info!("{:?}", e),
@@ -77,7 +97,10 @@ impl Drop for TeeBinder {
}
}
-fn create_sgx_enclave(enclave_name: &str, debug_launch: i32) ->
Result<SgxEnclave> {
+fn create_sgx_enclave(
+ enclave_name: &str,
+ debug_launch: bool,
+) -> std::result::Result<SgxEnclave, TeeBinderError> {
let mut launch_token: sgx_launch_token_t = [0; 1024]; // launch_token is
deprecated
let mut launch_token_updated: i32 = 0; // launch_token is deprecated
@@ -90,12 +113,12 @@ fn create_sgx_enclave(enclave_name: &str, debug_launch:
i32) -> Result<SgxEnclav
let enclave = SgxEnclave::create(
enclave_file,
- debug_launch,
+ debug_launch as i32,
&mut launch_token, // launch_token is deprecated
&mut launch_token_updated, // launch_token is deprecated
&mut misc_attr,
)
- .map_err(|_| anyhow::anyhow!("sgx error"))?;
+ .map_err(TeeBinderError::SgxError)?;
Ok(enclave)
}
diff --git a/ipc/Cargo.toml b/ipc/Cargo.toml
index 8f5af63..89274ef 100644
--- a/ipc/Cargo.toml
+++ b/ipc/Cargo.toml
@@ -19,6 +19,7 @@ serde = { version = "1.0.92", features = ["derive"] }
anyhow = { version = "1.0.26" }
serde_json = { version = "1.0.39" }
log = { version = "0.4.6" }
+thiserror = { version = "1.0.9" }
teaclave_ipc_attribute = { path = "./attribute" }
teaclave_types = { path = "../types" }
diff --git a/ipc/src/channel/app_dep.rs b/ipc/src/channel/app_dep.rs
index cd4d648..39f79e6 100644
--- a/ipc/src/channel/app_dep.rs
+++ b/ipc/src/channel/app_dep.rs
@@ -23,8 +23,8 @@ use serde::{Deserialize, Serialize};
use sgx_types::{sgx_enclave_id_t, sgx_status_t};
+use crate::IpcError;
use crate::IpcSender;
-use anyhow::{bail, Result};
use teaclave_types::EnclaveStatus;
// Delaration of ecall for App, the implementation is in TEE
@@ -59,7 +59,11 @@ impl ECallChannel {
}
}
- fn ecall_ipc_app_to_tee(&mut self, cmd: u32, request_payload: Vec<u8>) ->
Result<Vec<u8>> {
+ fn ecall_ipc_app_to_tee(
+ &mut self,
+ cmd: u32,
+ request_payload: Vec<u8>,
+ ) -> std::result::Result<Vec<u8>, IpcError> {
debug! {"ecall_ipc_app_to_tee: {:x}, {:x} bytes", cmd,
request_payload.len()};
let in_ptr: *const u8 = request_payload.as_ptr();
@@ -87,17 +91,15 @@ impl ECallChannel {
)
};
- /* Check sgx return values */
+ // Check sgx return values
if sgx_status != sgx_status_t::SGX_SUCCESS {
error!("ecall_ipc_entry_point, app sgx_error:{}", sgx_status);
- bail!(sgx_status);
+ return Err(IpcError::SgxError(sgx_status as i32));
}
- /*
- * Check rust logic return values
- * If out_buf is not big enough, realloc based on the returned
out_len
- * We only retry once for once invocation.
- */
+ // Check rust logic return values
+ // If out_buf is not big enough, realloc based on the returned
out_len
+ // We only retry once for once invocation.
if ecall_ret.is_err_ffi_outbuf() && !retried {
debug!(
"ecall_ipc_entry_point, expand app request buffer size:
{:?}",
@@ -110,13 +112,11 @@ impl ECallChannel {
continue;
}
- /*
- * Check rust logic return values
- * Transparent deliever the errors to outer logic.
- */
+ // Check rust logic return values
+ // Transparent deliever the errors to outer logic.
if ecall_ret.is_err() {
error!("ecall_ipc_entry_point, app api_error: {:?}",
ecall_ret);
- bail!("ecall error");
+ return Err(IpcError::EnclaveError(ecall_ret));
}
unsafe {
@@ -132,14 +132,14 @@ impl ECallChannel {
}
impl IpcSender for ECallChannel {
- fn invoke<U, V>(&mut self, cmd: u32, input: U) -> Result<V>
+ fn invoke<U, V>(&mut self, cmd: u32, input: U) -> std::result::Result<V,
IpcError>
where
U: Serialize,
V: for<'de> Deserialize<'de>,
{
- let request_payload = serde_json::to_vec(&input)?;
+ let request_payload = serde_json::to_vec(&input).map_err(|_|
IpcError::SerdeError)?;
let result_buf = self.ecall_ipc_app_to_tee(cmd, request_payload)?;
- let response: V = serde_json::from_slice(&result_buf)?;
+ let response: V = serde_json::from_slice(&result_buf).map_err(|_|
IpcError::SerdeError)?;
Ok(response)
}
}
diff --git a/ipc/src/channel/tee_dep.rs b/ipc/src/channel/tee_dep.rs
index 3302b22..2515616 100644
--- a/ipc/src/channel/tee_dep.rs
+++ b/ipc/src/channel/tee_dep.rs
@@ -37,13 +37,9 @@ impl IpcReceiver for ECallReceiver {
V: serde::Serialize,
X: IpcService<U, V>,
{
- debug!("from_slice");
let input: U = serde_json::from_slice(&input_payload)?;
-
- debug!("handle_invoke");
- let response = x.handle_invoke(input)?;
-
- debug!("to_vec");
+ let response: std::result::Result<V, teaclave_types::TeeServiceError> =
+ x.handle_invoke(input);
let response_payload = serde_json::to_vec(&response)?;
Ok(response_payload)
diff --git a/ipc/src/lib.rs b/ipc/src/lib.rs
index 6f80fb9..2a9f42a 100644
--- a/ipc/src/lib.rs
+++ b/ipc/src/lib.rs
@@ -36,7 +36,7 @@ use serde::{Deserialize, Serialize};
// Generic U: ArgmentsInfo type
// Generic V: ReturnInfo type
pub trait IpcSender {
- fn invoke<U, V>(&mut self, cmd: u32, input: U) -> Result<V>
+ fn invoke<U, V>(&mut self, cmd: u32, input: U) -> std::result::Result<V,
IpcError>
where
U: Serialize,
V: for<'de> Deserialize<'de>;
@@ -50,7 +50,7 @@ where
U: for<'de> Deserialize<'de>,
V: Serialize,
{
- fn handle_invoke(&self, input: U) -> Result<V>;
+ fn handle_invoke(&self, input: U) -> teaclave_types::TeeServiceResult<V>;
}
// Callee of an IPC function
@@ -66,6 +66,18 @@ pub trait IpcReceiver {
X: IpcService<U, V>;
}
+#[derive(thiserror::Error, Debug, Serialize, Deserialize)]
+pub enum IpcError {
+ #[error("SgxError")]
+ SgxError(i32),
+ #[error("EnclaveError")]
+ EnclaveError(teaclave_types::EnclaveStatus),
+ #[error("SerdeError")]
+ SerdeError,
+ #[error("TeeServiceError")]
+ TeeServiceError,
+}
+
pub mod channel;
pub mod macros;
pub mod proto;
diff --git a/ipc/src/macros.rs b/ipc/src/macros.rs
index aa5897a..e012d5e 100644
--- a/ipc/src/macros.rs
+++ b/ipc/src/macros.rs
@@ -35,7 +35,7 @@ macro_rules! register_ecall_handler {
// Declear a local trait, the [handle_ecall] attribute macro
// will help implement this trait and call user defined function.
trait HandleRequest<V> {
- fn handle(&self) -> anyhow::Result<V>;
+ fn handle(&self) -> teaclave_types::TeeServiceResult<V>;
}
struct ServeInstance<U, V>
@@ -65,7 +65,8 @@ macro_rules! register_ecall_handler {
U: HandleRequest<V> + for<'de> serde::Deserialize<'de>,
V: serde::Serialize,
{
- fn handle_invoke(&self, input: U) -> anyhow::Result<V> {
+ fn handle_invoke(&self, input: U) ->
teaclave_types::TeeServiceResult<V> {
+ log::debug!("handle_invoke");
input.handle()
}
}
@@ -113,21 +114,19 @@ macro_rules! register_ecall_handler {
if inner_len > out_max {
debug!("tee before copy out_buf check: out_max={:x} <
inner={:x}", out_max, inner_len);
- return teaclave_types::EnclaveStatus(0x0000_000c); // TODO:
Error::from(mesatee_core::ErrorKind::FFICallerOutBufferTooSmall).into();
+ return teaclave_types::EnclaveStatus(0x0000_000c);
}
- // you can use anything to fill out the output buf
- // another example could be found at crypto sample
- //
https://github.com/baidu/rust-sgx-sdk/blob/master/samplecode/crypto/enclave/src/lib.rs#L151
- // The following lines use a trick of "constructing a mutable
slice in place" using slice::from_raw_parts_mut
- // You can always use ptr::copy_nonoverlapping to copy a buffer to
the output pointer (see the above crypto sample)
+ // The following lines use a trick of "constructing a mutable slice
+ // in place" using slice::from_raw_parts_mut You can always use
+ // ptr::copy_nonoverlapping to copy a buffer to the output pointer
+ // (see the above crypto sample)
unsafe {
std::ptr::copy_nonoverlapping(inner_vec.as_ptr(), out_buf,
inner_len);
}
// out_len would be used in `set_len` in the untrusted app
// so out_len cannot be larger than out_max. Additional checks are
**required**.
- // TODO: Ok(()).into()
teaclave_types::EnclaveStatus::default()
}
}
diff --git a/services/access_control/app/Cargo.toml
b/services/access_control/app/Cargo.toml
index c3df477..79b88de 100644
--- a/services/access_control/app/Cargo.toml
+++ b/services/access_control/app/Cargo.toml
@@ -15,5 +15,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/access_control/app/src/main.rs
b/services/access_control/app/src/main.rs
index 5e16411..5bfbeb3 100644
--- a/services/access_control/app/src/main.rs
+++ b/services/access_control/app/src/main.rs
@@ -18,14 +18,14 @@
#[macro_use]
extern crate log;
-use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
-
use anyhow::Result;
use teaclave_binder::TeeBinder;
+use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -36,7 +36,11 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/services/access_control/enclave/src/lib.rs
b/services/access_control/enclave/src/lib.rs
index 883a24b..8ac92f7 100644
--- a/services/access_control/enclave/src/lib.rs
+++ b/services/access_control/enclave/src/lib.rs
@@ -23,7 +23,6 @@ extern crate sgx_tstd as std;
#[macro_use]
extern crate log;
-use anyhow::Result;
use std::prelude::v1::*;
use teaclave_attestation::{AttestationConfig, RemoteAttestation};
use teaclave_ipc::proto::{
@@ -37,13 +36,12 @@ use teaclave_proto::teaclave_access_control_service::{
use teaclave_rpc::config::SgxTrustedTlsServerConfig;
use teaclave_rpc::server::SgxTrustedTlsServer;
use teaclave_service_enclave_utils::ServiceEnclave;
+use teaclave_types::{TeeServiceError, TeeServiceResult};
mod acs;
mod service;
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
- debug!("handle_start_service");
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let listen_address =
args.config.internal_endpoints.access_control.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
let attestation =
RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
@@ -69,18 +67,25 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
error!("Service exit, error: {}.", e);
}
}
+ Ok(())
+}
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/services/authentication/app/Cargo.toml
b/services/authentication/app/Cargo.toml
index 6146a88..dd4a2bd 100644
--- a/services/authentication/app/Cargo.toml
+++ b/services/authentication/app/Cargo.toml
@@ -15,5 +15,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/authentication/app/src/main.rs
b/services/authentication/app/src/main.rs
index 3f259ad..5bfbeb3 100644
--- a/services/authentication/app/src/main.rs
+++ b/services/authentication/app/src/main.rs
@@ -21,10 +21,11 @@ extern crate log;
use anyhow::Result;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -35,7 +36,11 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/services/authentication/enclave/src/lib.rs
b/services/authentication/enclave/src/lib.rs
index 66682b7..33366da 100644
--- a/services/authentication/enclave/src/lib.rs
+++ b/services/authentication/enclave/src/lib.rs
@@ -23,7 +23,6 @@ extern crate sgx_tstd as std;
#[macro_use]
extern crate log;
-use anyhow::Result;
use rand::RngCore;
use std::prelude::v1::*;
use std::sync::Arc;
@@ -43,7 +42,7 @@ use teaclave_proto::teaclave_authentication_service::{
use teaclave_rpc::config::SgxTrustedTlsServerConfig;
use teaclave_rpc::server::SgxTrustedTlsServer;
use teaclave_service_enclave_utils::ServiceEnclave;
-use teaclave_types::EnclaveInfo;
+use teaclave_types::{EnclaveInfo, TeeServiceError, TeeServiceResult};
mod api_service;
mod internal_service;
@@ -114,9 +113,7 @@ fn start_api_endpoint(
}
}
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
- debug!("handle_start_service");
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let enclave_info = EnclaveInfo::verify_and_new(
args.config
.audit
@@ -148,13 +145,9 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
let api_listen_address =
args.config.api_endpoints.authentication.listen_address;
let internal_listen_address =
args.config.internal_endpoints.authentication.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
- let attestation = Arc::new(
- RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
- &ias_config.ias_key,
- &ias_config.ias_spid,
- ))
- .unwrap(),
- );
+ let attestation = Arc::new(RemoteAttestation::generate_and_endorse(
+ &AttestationConfig::ias(&ias_config.ias_key, &ias_config.ias_spid),
+ )?);
let database = user_db::Database::open()?;
let mut api_jwt_secret = vec![0; user_info::JWT_SECRET_LEN];
let mut rng = rand::thread_rng();
@@ -181,17 +174,23 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
api_endpoint_thread_handler.join().unwrap();
internal_endpoint_thread_handler.join().unwrap();
+ Ok(())
+}
+
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(_: &FinalizeEnclaveInput) ->
TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/services/execution/app/Cargo.toml
b/services/execution/app/Cargo.toml
index 00b36e0..a602063 100644
--- a/services/execution/app/Cargo.toml
+++ b/services/execution/app/Cargo.toml
@@ -18,5 +18,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/execution/app/src/main.rs
b/services/execution/app/src/main.rs
index 1f7395a..5bfbeb3 100644
--- a/services/execution/app/src/main.rs
+++ b/services/execution/app/src/main.rs
@@ -21,11 +21,13 @@ extern crate log;
use anyhow::Result;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
+
Ok(())
}
@@ -34,12 +36,17 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
fn run(tee: &TeeBinder) -> Result<()> {
start_enclave_service(tee)?;
+
Ok(())
}
diff --git a/services/execution/enclave/src/lib.rs
b/services/execution/enclave/src/lib.rs
index 086c733..76776af 100644
--- a/services/execution/enclave/src/lib.rs
+++ b/services/execution/enclave/src/lib.rs
@@ -27,8 +27,6 @@ extern crate log;
mod service;
-use anyhow::Result;
-
use teaclave_ipc::proto::{
ECallCommand, FinalizeEnclaveInput, FinalizeEnclaveOutput,
InitEnclaveInput, InitEnclaveOutput,
StartServiceInput, StartServiceOutput,
@@ -43,16 +41,9 @@ use teaclave_proto::teaclave_execution_service::{
};
use teaclave_rpc::config::SgxTrustedTlsServerConfig;
use teaclave_rpc::server::SgxTrustedTlsServer;
+use teaclave_types::{TeeServiceError, TeeServiceResult};
-register_ecall_handler!(
- type ECallCommand,
- (ECallCommand::StartService, StartServiceInput, StartServiceOutput),
- (ECallCommand::InitEnclave, InitEnclaveInput, InitEnclaveOutput),
- (ECallCommand::FinalizeEnclave, FinalizeEnclaveInput,
FinalizeEnclaveOutput),
-);
-
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let listen_address =
args.config.internal_endpoints.execution.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
let attestation =
RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
@@ -77,23 +68,37 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
error!("Service exit, error: {}.", e);
}
}
+ Ok(())
+}
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
info!("Worker started");
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
+register_ecall_handler!(
+ type ECallCommand,
+ (ECallCommand::StartService, StartServiceInput, StartServiceOutput),
+ (ECallCommand::InitEnclave, InitEnclaveInput, InitEnclaveOutput),
+ (ECallCommand::FinalizeEnclave, FinalizeEnclaveInput,
FinalizeEnclaveOutput),
+);
+
#[cfg(feature = "enclave_unit_test")]
pub mod tests {
diff --git a/services/frontend/app/Cargo.toml b/services/frontend/app/Cargo.toml
index 0b5c66d..971b2a3 100644
--- a/services/frontend/app/Cargo.toml
+++ b/services/frontend/app/Cargo.toml
@@ -15,5 +15,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/frontend/app/src/main.rs
b/services/frontend/app/src/main.rs
index 3f259ad..5bfbeb3 100644
--- a/services/frontend/app/src/main.rs
+++ b/services/frontend/app/src/main.rs
@@ -21,10 +21,11 @@ extern crate log;
use anyhow::Result;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -35,7 +36,11 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/services/frontend/enclave/src/lib.rs
b/services/frontend/enclave/src/lib.rs
index 4c1cc07..da27852 100644
--- a/services/frontend/enclave/src/lib.rs
+++ b/services/frontend/enclave/src/lib.rs
@@ -23,7 +23,6 @@ extern crate sgx_tstd as std;
#[macro_use]
extern crate log;
-use anyhow::Result;
use std::prelude::v1::*;
use teaclave_attestation::verifier;
use teaclave_attestation::{AttestationConfig, RemoteAttestation};
@@ -41,12 +40,11 @@ use teaclave_rpc::config::SgxTrustedTlsServerConfig;
use teaclave_rpc::endpoint::Endpoint;
use teaclave_rpc::server::SgxTrustedTlsServer;
use teaclave_service_enclave_utils::ServiceEnclave;
+use teaclave_types::{TeeServiceError, TeeServiceResult};
mod service;
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
- debug!("handle_start_service");
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let listen_address = args.config.api_endpoints.frontend.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
let attestation =
RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
@@ -93,18 +91,25 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
error!("Service exit, error: {}.", e);
}
}
+ Ok(())
+}
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/services/management/app/Cargo.toml
b/services/management/app/Cargo.toml
index 4e4832f..af7c251 100644
--- a/services/management/app/Cargo.toml
+++ b/services/management/app/Cargo.toml
@@ -15,5 +15,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/management/app/src/main.rs
b/services/management/app/src/main.rs
index 3f259ad..5bfbeb3 100644
--- a/services/management/app/src/main.rs
+++ b/services/management/app/src/main.rs
@@ -21,10 +21,11 @@ extern crate log;
use anyhow::Result;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -35,7 +36,11 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/services/management/enclave/src/lib.rs
b/services/management/enclave/src/lib.rs
index 2e897c6..9af1d48 100644
--- a/services/management/enclave/src/lib.rs
+++ b/services/management/enclave/src/lib.rs
@@ -23,7 +23,6 @@ extern crate sgx_tstd as std;
#[macro_use]
extern crate log;
-use anyhow::Result;
use std::prelude::v1::*;
use teaclave_attestation::{AttestationConfig, RemoteAttestation};
use teaclave_ipc::proto::{
@@ -37,12 +36,11 @@ use teaclave_proto::teaclave_management_service::{
use teaclave_rpc::config::SgxTrustedTlsServerConfig;
use teaclave_rpc::server::SgxTrustedTlsServer;
use teaclave_service_enclave_utils::ServiceEnclave;
+use teaclave_types::{TeeServiceError, TeeServiceResult};
mod service;
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
- debug!("handle_start_service");
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let listen_address =
args.config.internal_endpoints.management.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
let attestation =
RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
@@ -68,18 +66,25 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
error!("Service exit, error: {}.", e);
}
}
+ Ok(())
+}
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/services/storage/app/Cargo.toml b/services/storage/app/Cargo.toml
index 8e529fd..d76647c 100644
--- a/services/storage/app/Cargo.toml
+++ b/services/storage/app/Cargo.toml
@@ -15,5 +15,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/services/storage/app/src/main.rs b/services/storage/app/src/main.rs
index ac0130b..5bfbeb3 100644
--- a/services/storage/app/src/main.rs
+++ b/services/storage/app/src/main.rs
@@ -18,15 +18,14 @@
#[macro_use]
extern crate log;
-use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
-
use anyhow::Result;
use teaclave_binder::TeeBinder;
-use teaclave_config;
+use teaclave_ipc::proto::{ECallCommand, StartServiceInput, StartServiceOutput};
+use teaclave_types::TeeServiceResult;
-fn main() -> anyhow::Result<()> {
+fn main() -> Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -37,7 +36,11 @@ fn start_enclave_service(tee: &TeeBinder) -> Result<()> {
let config =
teaclave_config::RuntimeConfig::from_toml("runtime.config.toml")?;
let input = StartServiceInput { config };
let cmd = ECallCommand::StartService;
- let _ = tee.invoke::<StartServiceInput, StartServiceOutput>(cmd.into(),
input);
+ match tee.invoke::<StartServiceInput,
TeeServiceResult<StartServiceOutput>>(cmd, input) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/services/storage/enclave/src/lib.rs
b/services/storage/enclave/src/lib.rs
index d7fa949..f54b599 100644
--- a/services/storage/enclave/src/lib.rs
+++ b/services/storage/enclave/src/lib.rs
@@ -24,16 +24,13 @@ extern crate log;
use std::prelude::v1::*;
-use anyhow::Result;
-
use teaclave_ipc::proto::{
ECallCommand, FinalizeEnclaveInput, FinalizeEnclaveOutput,
InitEnclaveInput, InitEnclaveOutput,
StartServiceInput, StartServiceOutput,
};
-
use teaclave_ipc::{handle_ecall, register_ecall_handler};
-
use teaclave_service_enclave_utils::ServiceEnclave;
+use teaclave_types::{TeeServiceError, TeeServiceResult};
use rusty_leveldb::DB;
use teaclave_attestation::{AttestationConfig, RemoteAttestation};
@@ -48,9 +45,7 @@ use std::cell::RefCell;
use std::sync::mpsc::channel;
use std::thread;
-#[handle_ecall]
-fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput> {
- debug!("handle_start_service");
+fn start_service(args: &StartServiceInput) -> anyhow::Result<()> {
let listen_address = args.config.internal_endpoints.storage.listen_address;
let ias_config = args.config.ias.as_ref().unwrap();
let attestation =
RemoteAttestation::generate_and_endorse(&AttestationConfig::ias(
@@ -86,18 +81,25 @@ fn handle_start_service(args: &StartServiceInput) ->
Result<StartServiceOutput>
error!("Service exit, error: {}.", e);
}
}
+ Ok(())
+}
+#[handle_ecall]
+fn handle_start_service(args: &StartServiceInput) ->
TeeServiceResult<StartServiceOutput> {
+ start_service(args).map_err(|_| TeeServiceError::ServiceError)?;
Ok(StartServiceOutput::default())
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/tests/functional_tests/app/Cargo.toml
b/tests/functional_tests/app/Cargo.toml
index 76ffb97..03104b5 100644
--- a/tests/functional_tests/app/Cargo.toml
+++ b/tests/functional_tests/app/Cargo.toml
@@ -14,5 +14,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/tests/functional_tests/app/src/main.rs
b/tests/functional_tests/app/src/main.rs
index 4937d08..dd9ab4d 100644
--- a/tests/functional_tests/app/src/main.rs
+++ b/tests/functional_tests/app/src/main.rs
@@ -16,12 +16,14 @@
// under the License.
use anyhow;
+use log::error;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, RunTestInput, RunTestOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> anyhow::Result<()> {
env_logger::init();
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -29,7 +31,11 @@ fn main() -> anyhow::Result<()> {
fn start_enclave_unit_test_driver(tee: &TeeBinder) -> anyhow::Result<()> {
let cmd = ECallCommand::RunTest;
- let _ = tee.invoke::<RunTestInput, RunTestOutput>(cmd.into(),
RunTestInput);
+ match tee.invoke::<RunTestInput, TeeServiceResult<RunTestOutput>>(cmd,
RunTestInput) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/tests/functional_tests/enclave/src/lib.rs
b/tests/functional_tests/enclave/src/lib.rs
index b4b3106..c92d939 100644
--- a/tests/functional_tests/enclave/src/lib.rs
+++ b/tests/functional_tests/enclave/src/lib.rs
@@ -25,7 +25,6 @@ extern crate log;
use std::prelude::v1::*;
-use anyhow::Result;
use teaclave_types;
use teaclave_ipc::proto::{
@@ -35,6 +34,7 @@ use teaclave_ipc::proto::{
use teaclave_ipc::{handle_ecall, register_ecall_handler};
use teaclave_service_enclave_utils::ServiceEnclave;
use teaclave_test_utils::check_all_passed;
+use teaclave_types::TeeServiceResult;
mod teaclave_access_control_service;
mod teaclave_authentication_service;
@@ -43,7 +43,7 @@ mod teaclave_frontend_service;
mod teaclave_storage_service;
#[handle_ecall]
-fn handle_run_test(_args: &RunTestInput) -> Result<RunTestOutput> {
+fn handle_run_test(_args: &RunTestInput) -> TeeServiceResult<RunTestOutput> {
let ret = check_all_passed!(
teaclave_access_control_service::run_tests(),
teaclave_authentication_service::run_tests(),
@@ -57,13 +57,15 @@ fn handle_run_test(_args: &RunTestInput) ->
Result<RunTestOutput> {
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/tests/integration_tests/app/Cargo.toml
b/tests/integration_tests/app/Cargo.toml
index 9485345..10accdf 100644
--- a/tests/integration_tests/app/Cargo.toml
+++ b/tests/integration_tests/app/Cargo.toml
@@ -16,5 +16,6 @@ teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
teaclave_config = { path = "../../../config" }
teaclave_test_utils = { path = "../../test_utils" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/tests/integration_tests/app/src/main.rs
b/tests/integration_tests/app/src/main.rs
index ed3e53a..dd9ab4d 100644
--- a/tests/integration_tests/app/src/main.rs
+++ b/tests/integration_tests/app/src/main.rs
@@ -16,29 +16,32 @@
// under the License.
use anyhow;
+use log::error;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, RunTestInput, RunTestOutput};
-
-mod teaclave_config_tests;
+use teaclave_types::TeeServiceResult;
fn main() -> anyhow::Result<()> {
env_logger::init();
-
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
- run_app_integration_tests();
- start_enclave_integration_tests(&tee)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
+ run(&tee)?;
Ok(())
}
-fn start_enclave_integration_tests(tee: &TeeBinder) -> anyhow::Result<()> {
+fn start_enclave_unit_test_driver(tee: &TeeBinder) -> anyhow::Result<()> {
let cmd = ECallCommand::RunTest;
- tee.invoke::<RunTestInput, RunTestOutput>(cmd.into(), RunTestInput)?;
+ match tee.invoke::<RunTestInput, TeeServiceResult<RunTestOutput>>(cmd,
RunTestInput) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
-fn run_app_integration_tests() {
- let ret = teaclave_config_tests::run_tests();
- assert_eq!(ret, true);
+fn run(tee: &TeeBinder) -> anyhow::Result<()> {
+ start_enclave_unit_test_driver(tee)?;
+
+ Ok(())
}
diff --git a/tests/integration_tests/enclave/src/lib.rs
b/tests/integration_tests/enclave/src/lib.rs
index d4a49e2..1a82bb5 100644
--- a/tests/integration_tests/enclave/src/lib.rs
+++ b/tests/integration_tests/enclave/src/lib.rs
@@ -25,8 +25,8 @@ extern crate log;
use std::prelude::v1::*;
-use anyhow::Result;
use teaclave_types;
+use teaclave_types::TeeServiceResult;
use teaclave_ipc::proto::{
ECallCommand, FinalizeEnclaveInput, FinalizeEnclaveOutput,
InitEnclaveInput, InitEnclaveOutput,
@@ -42,7 +42,7 @@ mod teaclave_rpc;
mod teaclave_worker;
#[handle_ecall]
-fn handle_run_test(_args: &RunTestInput) -> Result<RunTestOutput> {
+fn handle_run_test(_args: &RunTestInput) -> TeeServiceResult<RunTestOutput> {
let ret = check_all_passed!(
rusty_leveldb_sgx::run_tests(),
protected_fs_rs::run_tests(),
@@ -55,13 +55,15 @@ fn handle_run_test(_args: &RunTestInput) ->
Result<RunTestOutput> {
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/tests/scripts/functional_tests.py
b/tests/scripts/functional_tests.py
index 4b6873c..9de5dfc 100755
--- a/tests/scripts/functional_tests.py
+++ b/tests/scripts/functional_tests.py
@@ -12,6 +12,7 @@ context = ssl._create_unverified_context()
def write_message(sock, message):
+ message = json.dumps(message)
message = message.encode()
sock.write(struct.pack(">Q", len(message)))
sock.write(message)
@@ -25,41 +26,42 @@ def read_message(sock):
class TestAuthenticationService(unittest.TestCase):
+ def setUp(self):
+ sock = socket.create_connection(authentication_service_address)
+ self.socket = context.wrap_socket(sock, server_hostname=hostname)
+
+ def tearDown(self):
+ self.socket.close()
+
def test_invalid_request(self):
user_id = "invalid_id"
user_password = "invalid_password"
- with socket.create_connection(authentication_service_address) as sock:
- with context.wrap_socket(sock, server_hostname=hostname) as ssock:
- message = {
- "invalid_request": "user_login",
- "id": user_id,
- "password": user_password
- }
- message = json.dumps(message)
- write_message(ssock, message)
+ message = {
+ "invalid_request": "user_login",
+ "id": user_id,
+ "password": user_password
+ }
+ write_message(self.socket, message)
- response = read_message(ssock)
- self.assertEqual(
- response, b'{"result":"err","request_error":"invalid
request"}')
+ response = read_message(self.socket)
+ self.assertEqual(
+ response, b'{"result":"err","request_error":"invalid request"}')
def test_login_permission_denied(self):
user_id = "invalid_id"
user_password = "invalid_password"
- with socket.create_connection(authentication_service_address) as sock:
- with context.wrap_socket(sock, server_hostname=hostname) as ssock:
- message = {
- "request": "user_login",
- "id": user_id,
- "password": user_password
- }
- message = json.dumps(message)
- write_message(ssock, message)
-
- response = read_message(ssock)
- self.assertEqual(
- response, b'{"result":"err","request_error":"permission
denied"}')
+ message = {
+ "request": "user_login",
+ "id": user_id,
+ "password": user_password
+ }
+ write_message(self.socket, message)
+
+ response = read_message(self.socket)
+ self.assertEqual(
+ response, b'{"result":"err","request_error":"permission denied"}')
if __name__ == '__main__':
diff --git a/tests/unit_tests/app/Cargo.toml b/tests/unit_tests/app/Cargo.toml
index cc9e0b7..cea003a 100644
--- a/tests/unit_tests/app/Cargo.toml
+++ b/tests/unit_tests/app/Cargo.toml
@@ -14,5 +14,6 @@ anyhow = { version = "1.0.26" }
teaclave_ipc = { path = "../../../ipc" }
teaclave_binder = { path = "../../../binder" }
+teaclave_types = { path = "../../../types" }
sgx_types = { version = "1.1.0" }
diff --git a/tests/unit_tests/app/src/main.rs b/tests/unit_tests/app/src/main.rs
index cb07272..dd9ab4d 100644
--- a/tests/unit_tests/app/src/main.rs
+++ b/tests/unit_tests/app/src/main.rs
@@ -16,13 +16,14 @@
// under the License.
use anyhow;
+use log::error;
use teaclave_binder::TeeBinder;
use teaclave_ipc::proto::{ECallCommand, RunTestInput, RunTestOutput};
+use teaclave_types::TeeServiceResult;
fn main() -> anyhow::Result<()> {
env_logger::init();
-
- let tee = TeeBinder::new(env!("CARGO_PKG_NAME"), 1)?;
+ let tee = TeeBinder::new(env!("CARGO_PKG_NAME"))?;
run(&tee)?;
Ok(())
@@ -30,7 +31,11 @@ fn main() -> anyhow::Result<()> {
fn start_enclave_unit_test_driver(tee: &TeeBinder) -> anyhow::Result<()> {
let cmd = ECallCommand::RunTest;
- let _ = tee.invoke::<RunTestInput, RunTestOutput>(cmd.into(),
RunTestInput);
+ match tee.invoke::<RunTestInput, TeeServiceResult<RunTestOutput>>(cmd,
RunTestInput) {
+ Err(e) => error!("{:?}", e),
+ Ok(Err(e)) => error!("{:?}", e),
+ _ => (),
+ }
Ok(())
}
diff --git a/tests/unit_tests/enclave/src/lib.rs
b/tests/unit_tests/enclave/src/lib.rs
index 74c5fae..942647d 100644
--- a/tests/unit_tests/enclave/src/lib.rs
+++ b/tests/unit_tests/enclave/src/lib.rs
@@ -24,8 +24,8 @@ extern crate log;
use std::prelude::v1::*;
-use anyhow::Result;
use teaclave_types;
+use teaclave_types::TeeServiceResult;
use teaclave_ipc::proto::{
ECallCommand, FinalizeEnclaveInput, FinalizeEnclaveOutput,
InitEnclaveInput, InitEnclaveOutput,
@@ -41,7 +41,7 @@ use teaclave_test_utils::check_all_passed;
use teaclave_worker;
#[handle_ecall]
-fn handle_run_test(_args: &RunTestInput) -> Result<RunTestOutput> {
+fn handle_run_test(_args: &RunTestInput) -> TeeServiceResult<RunTestOutput> {
let ret = check_all_passed!(
teaclave_storage_service_enclave::tests::run_tests(),
teaclave_access_control_service_enclave::tests::run_tests(),
@@ -57,13 +57,15 @@ fn handle_run_test(_args: &RunTestInput) ->
Result<RunTestOutput> {
}
#[handle_ecall]
-fn handle_init_enclave(_args: &InitEnclaveInput) -> Result<InitEnclaveOutput> {
+fn handle_init_enclave(_args: &InitEnclaveInput) ->
TeeServiceResult<InitEnclaveOutput> {
ServiceEnclave::init(env!("CARGO_PKG_NAME"))?;
Ok(InitEnclaveOutput::default())
}
#[handle_ecall]
-fn handle_finalize_enclave(_args: &FinalizeEnclaveInput) ->
Result<FinalizeEnclaveOutput> {
+fn handle_finalize_enclave(
+ _args: &FinalizeEnclaveInput,
+) -> TeeServiceResult<FinalizeEnclaveOutput> {
ServiceEnclave::finalize()?;
Ok(FinalizeEnclaveOutput::default())
}
diff --git a/types/src/lib.rs b/types/src/lib.rs
index c3f2a92..030ef41 100644
--- a/types/src/lib.rs
+++ b/types/src/lib.rs
@@ -22,7 +22,7 @@ pub use worker::*;
/// Status for Ecall
#[repr(C)]
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
pub struct EnclaveStatus(pub u32);
/// Status for Ocall
@@ -45,6 +45,18 @@ impl EnclaveStatus {
}
}
+#[derive(thiserror::Error, Debug, Serialize, Deserialize)]
+pub enum TeeServiceError {
+ #[error("SgxError")]
+ SgxError,
+ #[error("ServiceError")]
+ ServiceError,
+ #[error("CommandNotRegistered")]
+ CommandNotRegistered,
+}
+
+pub type TeeServiceResult<T> = std::result::Result<T, TeeServiceError>;
+
pub type SgxMeasurement = [u8; sgx_types::SGX_HASH_SIZE];
#[derive(Debug, Deserialize, Copy, Clone, Eq, PartialEq)]
diff --git a/utils/service_enclave_utils/Cargo.toml
b/utils/service_enclave_utils/Cargo.toml
index 233ac22..d4b6bd4 100644
--- a/utils/service_enclave_utils/Cargo.toml
+++ b/utils/service_enclave_utils/Cargo.toml
@@ -19,6 +19,7 @@ env_logger = { version = "0.7.1" }
log = { version = "0.4.6" }
teaclave_service_enclave_utils_proc_macro = { path = "./proc_macro" }
+teaclave_types = { path = "../../types" }
sgx_cov = { version = "1.1.0", optional = true }
sgx_trts = { version = "1.1.0", optional = true }
diff --git a/utils/service_enclave_utils/src/lib.rs
b/utils/service_enclave_utils/src/lib.rs
index 818ff6c..a8db3db 100644
--- a/utils/service_enclave_utils/src/lib.rs
+++ b/utils/service_enclave_utils/src/lib.rs
@@ -3,8 +3,6 @@
#[macro_use]
extern crate sgx_tstd as std;
-use anyhow::{bail, Result};
-
use log::debug;
use log::error;
use std::backtrace;
@@ -21,7 +19,7 @@ global_dtors_object! {
pub struct ServiceEnclave;
impl ServiceEnclave {
- pub fn init(name: &str) -> Result<()> {
+ pub fn init(name: &str) -> teaclave_types::TeeServiceResult<()> {
env_logger::init();
debug!("Enclave initializing");
@@ -30,13 +28,13 @@ impl ServiceEnclave {
.is_err()
{
error!("Cannot enable backtrace");
- bail!("ecall error");
+ return Err(teaclave_types::TeeServiceError::SgxError);
}
Ok(())
}
- pub fn finalize() -> Result<()> {
+ pub fn finalize() -> teaclave_types::TeeServiceResult<()> {
debug!("Enclave finalizing");
Ok(())
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
