BLD: implemented newTaskEncryptionKey in enclave

Author: lacabra

enclave/safetrace/app/src/enigma_types/mod.rs

@@ -1 +1,2 @@
 pub mod types;
+pub mod traits;

enclave/safetrace/app/src/keys_u.rs

@@ -1,8 +1,7 @@
 use crate::common_u::errors::EnclaveFailError;
-use enigma_types::{EnclaveReturn, PubKey};
 use failure::Error;
 use sgx_types::{sgx_enclave_id_t, sgx_status_t};
-//use enigma_types::{EnclaveReturn, PubKey, RawPointer};
+use crate::enigma_types::types::{EnclaveReturn};
 
 extern {
     pub fn ecall_get_user_key(
@@ -15,7 +14,7 @@ extern {
 }
 
 
-pub fn get_user_key(eid: sgx_enclave_id_t, user_pubkey: &PubKey) -> Result<(Box<[u8]>, [u8; 65]), Error> {
+pub fn get_user_key(eid: sgx_enclave_id_t, user_pubkey: &[u8; 64]) -> Result<(Box<[u8]>, [u8; 65]), Error> {
     let mut sig = [0u8; 65];
     let mut ret = EnclaveReturn::Success;
     let mut serialized_ptr = 0u64;

enclave/safetrace/app/src/main.rs

@@ -38,11 +38,11 @@ pub mod enigma_types;
 pub mod common_u;
 pub mod keys_u;
 pub mod networking;
+pub mod ocalls_u;
 
 use networking::{ipc_listener, IpcListener};
 use futures::Future;
-
-
+pub use ocalls_u::{ocall_save_to_memory};
 
 static ENCLAVE_FILE: &'static str = "enclave.signed.so";
 

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

@@ -28,7 +28,6 @@ impl IpcListener {
     }
 }
 
-//pub fn handle_message(request: Multipart, spid: &str, eid: sgx_enclave_id_t, retries: u32) -> Multipart {
 pub fn handle_message(request: Multipart, spid: &str, eid: sgx_enclave_id_t, retries: u32) -> Multipart {
     let mut responses = Multipart::new();
     for msg in request {
@@ -46,14 +45,14 @@ pub fn handle_message(request: Multipart, spid: &str, eid: sgx_enclave_id_t, ret
     responses
 }
 
+
 pub(self) mod handling {
     use crate::networking::messages::*;
     use crate::keys_u;
     use failure::Error;
     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;
 
@@ -64,6 +63,11 @@ pub(self) mod handling {
 
     type ResponseResult = Result<IpcResponse, Error>;
 
+    #[derive(Serialize, Deserialize)]
+    struct PubkeyResult {
+        pubkey: Vec<u8>
+    }
+
     pub fn get_enclave_report(eid: sgx_enclave_id_t, spid: &str, retries: u32) -> ResponseResult {
         let result = IpcResults::EnclaveReport { spid: spid.to_string() };
         Ok(IpcResponse::GetEnclaveReport { result })
@@ -77,19 +81,26 @@ pub(self) mod handling {
 
         let (msg, sig) = keys_u::get_user_key(eid, &user_pubkey)?;
 
-        let mut des = Deserializer::new(&msg[..]);
-        let res: Value = Deserialize::deserialize(&mut des).unwrap();
-        let pubkey = serde_json::from_value::<Vec<u8>>(res["pubkey"].clone())?;
+        // Enigma-core implementation used MessagePack, but rmp-serde is not available
+        // so replaced MessagePack serialization with plain JSON serialization
+        //let mut des = Deserializer::new(&msg[..]);
+        //let res: Value = Deserialize::deserialize(&mut des).unwrap();
+        //let pubkey = serde_json::from_value::<Vec<u8>>(res["pubkey"].clone())?;
+        //let pubkey = serde_json::from_slice::<Vec<u8>>(&msg)?;
+        let res = match str::from_utf8(&msg) {
+            Ok(v) => v,
+            Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
+        };
+
+        let pubkey: PubkeyResult = serde_json::from_str(res)?;
 
-        let result = IpcResults::DHKey {dh_key: pubkey.to_hex(), sig: sig.to_hex() };
-        //let result = IpcResults::DHKey {dh_key: _user_pubkey.to_string(), sig: _user_pubkey.to_string()};
+        let result = IpcResults::DHKey {taskPubKey: pubkey.pubkey.to_hex(), sig: sig.to_hex() };
 
         Ok(IpcResponse::NewTaskEncryptionKey { result })
     }
 
     // TODO
     //#[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();
@@ -102,7 +113,6 @@ pub(self) mod handling {
 
     // TODO
     //#[logfn(DEBUG)]
-    // pub fn compute_task(db: &mut DB, input: IpcTask, eid: sgx_enclave_id_t) -> ResponseResult {
     pub fn find_match( input: IpcInput, eid: sgx_enclave_id_t) -> ResponseResult {
         let result = IpcResults::FindMatch { status: Status::Passed };
         Ok(IpcResponse::FindMatch { result })

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

@@ -47,7 +47,7 @@ pub enum IpcResults {
     //EnclaveReport { #[serde(rename = "signingKey")] signing_key: String, report: String, signature: String },
     EnclaveReport { spid: String },
     #[serde(rename = "result")]
-    DHKey { dh_key: String, sig: String },
+    DHKey { taskPubKey: String, sig: String },
     AddPersonalData { status: Status },
     FindMatch { status: Status },
 }

enclave/safetrace/app/src/ocalls_u.rs

@@ -0,0 +1,10 @@
+use std::{ptr, slice};
+use enigma_types::traits::SliceCPtr;
+//use crate::esgx::general;
+
+#[no_mangle]
+pub unsafe extern "C" fn ocall_save_to_memory(data_ptr: *const u8, data_len: usize) -> u64 {
+    let data = slice::from_raw_parts(data_ptr, data_len).to_vec();
+    let ptr = Box::into_raw(Box::new(data.into_boxed_slice())) as *const u8;
+    ptr as u64
+}

enclave/safetrace/enclave/Cargo.toml

@@ -14,10 +14,18 @@ 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" }
+sgx_rand = { git = "https://github.com/apache/teaclave-sgx-sdk.git" }
+sgx_tseal = { git = "https://github.com/apache/teaclave-sgx-sdk.git" }
 
 [dependencies]
+arrayvec = { version = "0.4.10", default-features = false }
+rustc-hex = { version = "2.0.1", default-features = false }
 serde = { git = "https://github.com/mesalock-linux/serde-sgx", features = ["derive"] }
 serde_json = { git = "https://github.com/mesalock-linux/serde-json-sgx" }
+libsecp256k1 = { version = "0.2" }
+lazy_static = {version = "1.3.0", features = ["spin_no_std"] }
+tiny-keccak = { version = "1.4" }
+sha2 = { version = "0.8.0", default-features = false}
 
 [patch.'https://github.com/apache/teaclave-sgx-sdk.git']
 sgx_alloc = { path = "../../incubator-teaclave-sgx-sdk/sgx_alloc" }

enclave/safetrace/enclave/Enclave.edl

@@ -26,8 +26,6 @@ enclave {
     trusted {
         /* define ECALLs here. */
 
-        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(
@@ -36,4 +34,7 @@ enclave {
             [out] uint64_t* serialized_ptr
         );
     };
+    untrusted {
+        uint64_t ocall_save_to_memory([in, count=data_len] const uint8_t* data_ptr, size_t data_len);
+    };
 };

enclave/safetrace/enclave/src/data.rs

@@ -2,8 +2,7 @@ use sgx_types::*;
 use serde::{Serialize, Deserialize};
 use std::{slice};
 use std::string::String;
-use std::vec::Vec;
-use std::fmt;
+//use std::vec::Vec;
 
 // Structs
 #[derive(Serialize, Deserialize, Clone, Debug)]