BLD: serializing data into the enclave

Author: lacabra

enclave/safetrace/app/src/networking/ipc_listener.rs

@@ -1,10 +1,11 @@
 use crate::networking::messages::*;
-use sgx_types::sgx_enclave_id_t;
+use sgx_types::{sgx_enclave_id_t, sgx_status_t};
 use futures::{Future, Stream};
 use std::sync::Arc;
 use tokio_zmq::prelude::*;
 use tokio_zmq::{Error, Multipart, Rep};
 
+
 pub struct IpcListener {
     _context: Arc<zmq::Context>,
     rep_future: Box<dyn Future<Item = Rep, Error = Error>>,
@@ -49,13 +50,17 @@ pub(self) mod handling {
     use crate::networking::messages::*;
     use crate::keys_u;
     use failure::Error;
-    use sgx_types::sgx_enclave_id_t;
+    use sgx_types::{sgx_enclave_id_t, sgx_status_t};
     use hex::{FromHex, ToHex};
     use std::str;
     use rmp_serde::Deserializer;
     use serde::Deserialize;
     use serde_json::Value;
 
+    extern {
+    fn ecall_add_personal_data(eid: sgx_enclave_id_t, ret: *mut sgx_status_t,
+                     some_string: *const u8, len: usize) -> sgx_status_t;
+    }
 
     type ResponseResult = Result<IpcResponse, Error>;
 
@@ -86,6 +91,11 @@ pub(self) mod handling {
     //#[logfn(DEBUG)]
     // pub fn compute_task(db: &mut DB, input: IpcTask, eid: sgx_enclave_id_t) -> ResponseResult {
     pub fn add_personal_data( input: IpcInput, eid: sgx_enclave_id_t) -> ResponseResult {
+        let mut ret = sgx_status_t::SGX_SUCCESS;
+        let data = serde_json::to_string(&input).unwrap();
+
+        unsafe { ecall_add_personal_data(eid, &mut ret as *mut sgx_status_t, data.as_ptr() as * const u8, data.len()) };
+
         let result = IpcResults::AddPersonalData { status: Status::Passed };
         Ok(IpcResponse::AddPersonalData { result })
     }

enclave/safetrace/enclave/Cargo.toml

@@ -14,6 +14,11 @@ default = []
 sgx_types = { git = "https://github.com/apache/teaclave-sgx-sdk.git" }
 sgx_tstd = { git = "https://github.com/apache/teaclave-sgx-sdk.git", features = ["backtrace"] }
 sgx_trts = { git = "https://github.com/apache/teaclave-sgx-sdk.git" }
+
+[dependencies]
+serde = { git = "https://github.com/mesalock-linux/serde-sgx", features = ["derive"] }
+serde_json = { git = "https://github.com/mesalock-linux/serde-json-sgx" }
+
 [patch.'https://github.com/apache/teaclave-sgx-sdk.git']
 sgx_alloc = { path = "../../incubator-teaclave-sgx-sdk/sgx_alloc" }
 sgx_build_helper = { path = "../../incubator-teaclave-sgx-sdk/sgx_build_helper" }

enclave/safetrace/enclave/Enclave.edl

@@ -28,6 +28,8 @@ enclave {
 
         public sgx_status_t say_something([in, size=len] const uint8_t* some_string, size_t len);
 
+        public sgx_status_t ecall_add_personal_data([in, size=len] const uint8_t* some_string, size_t len);
+
         public sgx_status_t ecall_get_user_key(
             [out] uint8_t sig[65],
             [in] uint8_t pubkey[64],

enclave/safetrace/enclave/src/data.rs

@@ -0,0 +1,42 @@
+use sgx_types::*;
+use serde::{Serialize, Deserialize};
+use std::{slice};
+use std::string::String;
+use std::vec::Vec;
+use std::fmt;
+
+// Structs
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct GeolocationTime {
+    lat: i32,
+    lng: i32,
+    startTS: i32,
+    endTS: i32
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct Request {
+    encryptedUserId: String,
+    encryptedData: String,
+    userPubKey: String
+}
+
+pub fn ecall_add_personal_data_internal(data_json: *const u8, some_len: usize)  -> sgx_status_t {
+
+    let str_slice = unsafe { slice::from_raw_parts(data_json, some_len) };
+
+    // Input sanitised in EngimaJS to object type
+    let mut request: Request = serde_json::from_slice(str_slice).unwrap();
+
+    // Read from the state
+    // let mut data = Self::get_data();
+    // Append
+    // data.append(&mut array);
+    // Write back to the state
+    // write_state!(DATASET => data);
+
+    // Ocall to normal world for output
+    println!("Received Data: {:?}", &request);
+
+    sgx_status_t::SGX_SUCCESS
+}

enclave/safetrace/enclave/src/lib.rs

@@ -30,8 +30,17 @@ use sgx_types::*;
 use std::string::String;
 use std::vec::Vec;
 use std::io::{self, Write};
-use std::slice;
+use std::{slice};
 
+extern crate serde;
+extern crate serde_json;
+
+
+mod data;
+mod keys_t;
+
+use keys_t::ecall_get_user_key_internal;
+use data::ecall_add_personal_data_internal;
 
 #[no_mangle]
 pub extern "C" fn say_something(some_string: *const u8, some_len: usize) -> sgx_status_t {
@@ -66,16 +75,22 @@ pub extern "C" fn say_something(some_string: *const u8, some_len: usize) -> sgx_
 
 
 #[no_mangle]
-pub extern "C" fn ecall_get_user_key(sig: &mut [u8; 65], user_pubkey: &[u8; 64], serialized_ptr: *mut u64) -> sgx_status_t {
+pub unsafe extern "C" fn ecall_get_user_key(sig: &mut [u8; 65], user_pubkey: &[u8; 64], serialized_ptr: *mut u64) -> sgx_status_t {
     println!("Get User Key called inside envlave");
-    // let msg = match ecall_get_user_key_internal(sig, user_pubkey) {
-    //     Ok(msg) => msg,
-    //     Err(e) => return e.into(),
-    // };
+    let msg = match ecall_get_user_key_internal(sig, user_pubkey) {
+        Ok(msg) => msg,
+        Err(e) => return e,
+    };
     // *serialized_ptr = match ocalls_t::save_to_untrusted_memory(&msg[..]) {
     //     Ok(ptr) => ptr,
     //     Err(e) => return e.into(),
     // };
     // EnclaveReturn::Success
     sgx_status_t::SGX_SUCCESS
+}
+
+#[no_mangle]
+pub extern "C" fn ecall_add_personal_data(data_string: *const u8, data_len: usize) -> sgx_status_t {
+    ecall_add_personal_data_internal(data_string, data_len);
+    sgx_status_t::SGX_SUCCESS
 }