feat(exec_enclave): add sample function scaffolding

Co-authored-by: Pi Delport <[email protected]>

Author: longtomjr

rtc_exec_enclave/Cargo.lock

@@ -15,6 +15,7 @@ cbindgen = "0.19.0"
 
 # See "Pinning SGX dependencies" in HACKING.md
 [target.'cfg(not(target_env = "sgx"))'.dependencies]
+sgx_tcrypto = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk.git", rev = "b9d1bda" }
 sgx_types = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk.git", rev = "b9d1bda", features = ["extra_traits"] }
 sgx_tstd = { git = "https://github.com/apache/incubator-teaclave-sgx-sdk.git", rev = "b9d1bda", features = ["backtrace"] }
 

rtc_exec_enclave/Cargo.toml

@@ -3,8 +3,55 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![deny(clippy::mem_forget)]
 
+mod sample_functions;
+mod types;
+
 #[cfg(not(target_env = "sgx"))]
 extern crate sgx_tstd as std;
 
+use std::boxed::Box;
+use std::vec;
+
 pub use rtc_tenclave::dh::*;
 pub use rtc_tenclave::enclave::*;
+
+use crate::types::*;
+
+pub struct Token {
+    binary_hash: [u8; 32],
+}
+
+#[allow(clippy::result_unit_err)]
+pub fn request_execution(token: Token, _params: ()) -> Result<Box<[u8]>, ()> {
+    let exec_module = match get_module_by_id(token.binary_hash) {
+        Some(val) => val,
+        None => return Err(()),
+    };
+    let data = get_data(&token);
+
+    // as_ptr() does not take ownership, so the data will be dropped at the end of this function
+    let result = unsafe { exec_module.call(data.as_ptr(), data.len()) };
+
+    match result {
+        Ok(val) => Ok(val),
+        // XXX: The error handling here should take into account the Traps from WASM once we call
+        // WASM functions
+        Err(_) => Err(()),
+    }
+}
+
+// XXX: This is placeholder until we completed the data retrieval flow and know what values
+// we need to pass through to the data enclave
+fn get_data(_token: &Token) -> Box<[u8]> {
+    vec![123; 43].into_boxed_slice()
+}
+
+// XXX: The implementation is only for the sample functions currently
+pub(crate) fn get_module_by_id(module_id: [u8; 32]) -> Option<Box<dyn ExecModule>> {
+    use sample_functions::*;
+    match module_id {
+        SHA256_HASH_MODULE_ID => Some(Box::new(Sha256HashModule)),
+        MEDIAN_MODULE_ID => Some(Box::new(MedianModule)),
+        _ => None,
+    }
+}

rtc_exec_enclave/src/lib.rs

@@ -0,0 +1,37 @@
+use crate::types::*;
+use core::slice;
+
+pub(crate) trait SampleExecModule {
+    fn call_safe(&self, dataset: &[u8]) -> ExecResult;
+}
+
+impl<T> ExecModule for T
+where
+    T: SampleExecModule,
+{
+    unsafe fn call(&self, dataset_ptr: *const u8, dataset_len: usize) -> ExecResult {
+        let dataset = unsafe { slice::from_raw_parts(dataset_ptr, dataset_len) };
+        self.call_safe(dataset)
+    }
+}
+
+pub(crate) const SHA256_HASH_MODULE_ID: [u8; 32] = [1u8; 32];
+pub(crate) struct Sha256HashModule;
+
+impl SampleExecModule for Sha256HashModule {
+    fn call_safe(&self, dataset: &[u8]) -> ExecResult {
+        match sgx_tcrypto::rsgx_sha256_slice(dataset) {
+            Ok(res) => Ok(res.to_vec().into_boxed_slice()),
+            Err(_) => Err(()),
+        }
+    }
+}
+
+pub(crate) const MEDIAN_MODULE_ID: [u8; 32] = [2u8; 32];
+pub(crate) struct MedianModule;
+
+impl SampleExecModule for MedianModule {
+    fn call_safe(&self, _dataset: &[u8]) -> ExecResult {
+        todo!()
+    }
+}

rtc_exec_enclave/src/sample_functions.rs

@@ -0,0 +1,9 @@
+use std::boxed::Box;
+
+pub(crate) type CallReturnValue = Box<[u8]>;
+
+pub(crate) type ExecResult = core::result::Result<CallReturnValue, ()>;
+
+pub(crate) trait ExecModule {
+    unsafe fn call(&self, dataset_ptr: *const u8, dataset_len: usize) -> ExecResult;
+}