Initial enclave-runner

Author: raoulstrackx

fortanix-vme/Cargo.lock

@@ -0,0 +1,5 @@
+[workspace]
+members = [
+    "enclave-runner",
+    "fortanix-vme-abi",
+]

fortanix-vme/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "enclave-runner"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+fortanix-vme-abi = { path = "../fortanix-vme-abi" }
+serde = { version = "1.0", features = ["derive"] }
+serde_cbor = { version = "0.10" }

fortanix-vme/enclave-runner/Cargo.toml

@@ -0,0 +1 @@
+pub mod server;

fortanix-vme/enclave-runner/src/lib.rs

@@ -0,0 +1,6 @@
+use enclave_runner::server::Server;
+
+fn main() {
+    let server = Server::new();
+    server.run().expect("Server failed");
+}

fortanix-vme/enclave-runner/src/main.rs

@@ -0,0 +1,64 @@
+use std::thread;
+use std::io::{Error as IoError, ErrorKind as IoErrorKind, Write};
+use std::net::{Shutdown, TcpListener, TcpStream};
+use fortanix_vme_abi::{self, Error, Response, Request};
+
+pub struct Server {
+    port: u16,
+}
+
+impl Server {
+    pub fn new() -> Self {
+        Server {
+            port: fortanix_vme_abi::SERVER_PORT,
+        }
+    }
+
+    fn read_request(stream: &mut TcpStream) -> Result<Request, Error> {
+        // Blocks until a full `Request` object is received
+        let mut deser = serde_cbor::Deserializer::from_reader(stream).into_iter::<Request>();
+        let req = deser
+                    .next()
+                    .ok_or(Error::ReadFailed)?
+                    .map_err(|e| Error::DeserializationError(e))?;
+        Ok(req)
+    }
+
+    fn handle_client(stream: &mut TcpStream) -> Result<(), IoError> {
+        let request = Self::read_request(stream).map_err(|_e| IoError::new(IoErrorKind::InvalidInput, "Failed to read request"))?;
+        let response = match request {
+            Request::Connect{ addr } => {
+                println!("Received connect request to : {:?}", addr);
+                Response::Connected {
+                    port: 42,
+                    local_addr: "local".to_string(),
+                    peer_addr: "peer".to_string()
+                }
+            },
+        };
+        stream.write(&response.serialize().unwrap())?;
+        Ok(())
+    }
+
+    pub fn run(&self) -> std::io::Result<()> {
+        let listener = TcpListener::bind(format!("127.0.0.1:{}", self.port))?;
+
+        for stream in listener.incoming() {
+            let result = stream
+                .map_err(|e| format!("Failed to connect to client: {}", e))
+                .map(|mut stream| thread::Builder::new()
+                    .spawn(move || {
+                        if let Err(e) = Self::handle_client(&mut stream) {
+                            eprintln!("Error handling connection: {}, shutting connection down", e);
+                            let _ = stream.shutdown(Shutdown::Both);
+                        }
+                    }).map_err(|_| "Launch failed"));
+
+            if let Err(e) = result {
+                eprintln!("Error: {}", e);
+            }
+        }
+        Ok(())
+    }
+}
+

fortanix-vme/enclave-runner/src/server.rs

@@ -0,0 +1,41 @@
+use fortanix_vme_abi::{self, Response, Request};
+use std::thread;
+use std::io::{Error as IoError, Read, Write};
+use std::net::TcpStream;
+use std::time::Duration;
+
+const READ_BUFF_SIZE: usize = 10;
+
+fn read_from_stream(stream: &mut TcpStream) -> Result<Vec<u8>, IoError> {
+    let mut buff = Vec::new();
+    buff.resize(READ_BUFF_SIZE, 0);
+    let n = stream.read(&mut buff)?;
+    buff.resize(n, 0);
+    if n == READ_BUFF_SIZE {
+        buff.append(&mut read_from_stream(stream)?);
+    }
+    Ok(buff)
+}
+
+fn read_response(stream: &mut TcpStream) -> Result<Response, IoError> {
+    let response = read_from_stream(stream)?;
+    Ok(Response::deserialize(&response).unwrap())
+}
+
+#[test]
+fn test_connect() {
+    let _ = thread::spawn(|| {
+        let server = enclave_runner::server::Server::new();
+        server.run().unwrap();
+    });
+    thread::sleep(Duration::from_millis(1000));
+    let mut runner = TcpStream::connect(format!("localhost:{}", fortanix_vme_abi::SERVER_PORT)).unwrap();
+    let connect = Request::Connect {
+        addr: "google.com".to_string(),
+    };
+    let buf = connect.serialize().unwrap();
+
+    runner.write(&buf).unwrap();
+    let response = read_response(&mut runner).unwrap();
+    println!("response = {:?}", response);
+}

fortanix-vme/enclave-runner/tests/enclave-runner.rs

@@ -0,0 +1,19 @@
+[package]
+name = "fortanix-vme-abi"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
+alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
+compiler_builtins = { version = "0.1.0", optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+serde_cbor = { version = "0.10", default-features = false, features = ["alloc"] }
+
+[features]
+default = ["std"]
+docs = []
+rustc-dep-of-std = ["core", "alloc", "compiler_builtins/rustc-dep-of-std"]
+std = []

fortanix-vme/fortanix-vme-abi/Cargo.toml

@@ -0,0 +1,71 @@
+#![no_std]
+#![allow(unused)]
+
+extern crate alloc;
+
+#[cfg(feature="std")]
+extern crate std;
+
+use core::fmt::{self, Display};
+use serde_cbor::Serializer;
+use serde_cbor::ser::SliceWrite;
+use alloc::vec::Vec;
+use alloc::string::String;
+use serde::{Deserialize, Serialize};
+#[cfg(feature="std")]
+use std::io;
+
+pub const SERVER_PORT: u16 = 1024;
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Request {
+    Connect {
+        addr: String,
+    },
+}
+
+impl Request{
+    pub fn serialize(&self) -> Result<Vec<u8>, Error> {
+        serde_cbor::ser::to_vec(self).map_err(|e| Error::SerializationError(e))
+    }
+
+    pub fn deserialize(req: &Vec<u8>) -> Result<Self, Error> {
+        serde_cbor::from_slice(req).map_err(|e| Error::DeserializationError(e))
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Response {
+    Connected {
+        port: u16,
+        local_addr: String,
+        peer_addr: String,
+    },
+}
+
+impl Response {
+    pub fn serialize(&self) -> Result<Vec<u8>, Error> {
+        serde_cbor::ser::to_vec(self).map_err(|e| Error::SerializationError(e))
+    }
+
+    pub fn deserialize(res: &Vec<u8>) -> Result<Self, Error> {
+        serde_cbor::from_slice(res).map_err(|e| Error::DeserializationError(e))
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    DeserializationError(serde_cbor::Error),
+    ReadFailed,
+    SerializationError(serde_cbor::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::DeserializationError(_e) => write!(f, "Deserialization failed"),
+            Error::ReadFailed               => write!(f, "Read failed"),
+            Error::SerializationError(_e)   => write!(f, "Serialization failed"),
+        }
+    }
+}

fortanix-vme/fortanix-vme-abi/src/lib.rs

@@ -0,0 +1,10 @@
+#!/bin/bash -ex
+repo_root=$(readlink -f $(dirname "${BASH_SOURCE[0]}")/../../../)
+cd ${repo_root}/fortanix-vme
+
+source ci-common.sh
+compile
+
+eif=$(mktemp /tmp/$name.eif.XXXXX)
+elf2eif ${elf} ${eif}
+eif_runner ${eif} ${out} ${err}