chore: provide instructions for testing in README.md (#5)

We provide reproducible instructions for running and testing a simple WASM binary inside of an SGX enclave.  For convenience we rely upon [rust-sgx-sdk-dev-env] to set up the development environment.

* chore: clean out the template README.md file

* chore: initial instructions; set default C/C++ compiler in the makefile

The default compilers are set to `clang` and `clang++` respectively.
Instructions for alternatively using `gcc` and `g++` are included.

* chore: add forgotten detail in README.md regarding `rustup`

* fix(Makefile): fix typo; add spacing for readability

* fix(README.md): correct typo

* fix(README): add missing instruction

Co-authored-by: Bill Guo <billguo99@gmail.com>

* fix(README): add missing context

[rust-sgx-sdk-dev-env]: https://github.com/PiDelport/rust-sgx-sdk-dev-env

Co-authored-by: Bill Guo <billguo99@gmail.com>

Author: jdvlio

Makefile

@@ -1,5 +1,8 @@
 # Dummy makefile, will call the host and enclave makefile when requested.
 
+CC ?= clang
+CXX ?= clang++
+
 SRC_U = app/
 SRC_T = enclave/
 SRC_WASM= get-median-wasm/

README.md

@@ -1,70 +1,88 @@
-# Rust SGX - Template project
-==================================
+# NTC - WASM component
 
-### This is a template project to start developing with the Rust SGX SDK (https://github.com/apache/incubator-teaclave-sgx-sdk/) easily.
+### Requirements
 
-You will find in its template:
-- Makefiles to build your project easily, and link the ```SGX EDL C``` generated files to your Rust SGX projects
-- The file ```buildenv.mk``` that contains compilation rules when building enclave. No need to specify anymore where this file is located.
-- The file ```build.rs``` already configured to build the app/host part properly.
-- The file rust-toolchain, so we can force the use of one specific toolchain (```nightly-2020-10-25``` in this case)
-- ```Cargo/Xargo.toml``` files to set up your project easily. All the dependencies you might need has been added.
+- Operating system:
+    - Recommended: Ubuntu 20.04 (LTS)
+- Packages:
+    - `make`
+    - `clang` (recommended) or `gcc`
+    - `cmake`
+    - `autoconf`
+    - `libtool`
+- Snaps:
+    - `docker`
+- Rust toolchain:
+    - See [#rust-ecosystem]
 
-You can find those files in this template: 
+### Rust ecosystem
 
+Install `rustup` as described at [rustup.rs](https://rustup.rs/).  If you did
+not explicitly select `nightly` as your default toolchain then do so now
 ```
-|-- app/
-|   |-- src/
-|       |-- main.rs
-|   |-- Cargo.toml
-|   |-- Makefile
-|   |-- build.rs
-|   +-- rust-toolchain
-|-- enclave/
-|   |-- src/
-|       |-- lib.rs
-|   |-- Cargo.toml
-|   |-- Enclave.config.xml
-|   |-- Enclave.edl
-|   |-- Enclave.lds
-|   |-- Makefile
-|   |-- Xargo.toml
-|   +-- rust-toolchain
-|-- Makefile
-+-- buildenv.mk
+$ rustup install nightly
+```
+followed by
+```
+$ rustup default nightly
 ```
 
-## Setting up your project
+You will now have the `cargo` build tool, as well as the nigtly `rustc` compiler
+installed on your system and may now continue setting up your environment.
 
-You need to follow a few steps to use this template properly:
-- Add your ```.rs``` files to the ```src/``` folders (```lib.rs``` / your enclave source code goes in ```enclave/src```, your host/app source code goes in ```app/src```), or modify the ```.rs``` files already included with the project
-- Add your own ```Enclave.edl``` file, or modify the one joined in the project.
-- Change the ```Cargo.toml (or/and Xargo.toml if you want to use Xargo)``` files depending on of your needs (adding/removing dependencies).
-    - Be careful if you want to change the library name on the ```Cargo.toml``` file (enclave part), you will need to reflect this change on the enclave ```Makefile```, more specifically on the ```ENCLAVE_CARGO_LIB``` variable, and on the ```lib.rs``` file.
-    - If you need to change the app/host name, please make sure to edit the host ```Makefile```, and change the variable ```APP_U```.
+### Environment
 
-## Build your project
+**NOTE:** If you opted to install `gcc` as your compiler, make sure you run
+```
+export CC=gcc; export CXX=g++
+```
+Otherwise you may safely continue.
 
-### Before starting the building process, please make sure you downloaded the Rust SGX SDK repository, we're going to need the EDL and headers files joined in the SDK.
+The Rust and Intel SGX SDKs need to be installed and the
+relevant environment variables need to be set.  In order to facilitate this, we
+use the convenience scripts provided at [rust-sgx-sdk-env].
 
-Once you downloaded the Rust SGX SDK, you have multiple ways to start the building process: 
-- Run this command: ```CUSTOM_EDL_PATH=~/teaenclave/edl CUSTOM_COMMON_PATH=~/teaenclave/common make``` (replace ```~/teaenclave``` by the actual SDK location)
-- You can also run the command export (```export CUSTOM_EDL_PATH=~/teaenclave/edl```), and specify the variables before calling make. It is advised to add this command on your ```.bashrc``` file (if you use bash), or your favorite shell configuration file.
+1. Make sure the `docker` daemon is running, otherwise start it with
+   ```
+   $ systemctl start snap.docker.dockerd
+   ```
+2. In order to run the scripts as a non-root user, follow the
+   [docker-postinstall](post-installation instructions) set out in the Docker
+   documentation (note, in particular, that a restart may be necessary).
+3. Clone the repository at [rust-sgx-sdk-env]
+   ```
+   $ git clone https://github.com/PiDelport/rust-sgx-sdk-dev-env
+   ```
+   and `cd` into it.
+4. Run the latest "prepare" script:
+   ```
+   $ ./prepare-1.1.14-intel-2.15.1.sh
+   ```
+5. Finally, assuming `bash` is the current shell, source the environment file in
+   the top level of the repository:
+   ```
+   $ source environment
+   ```
 
-### By default, your project will be compiled in hardware mode. If you wish to compile your project in software/simulation mode, you will need to specify it, either by adding ```SGX_MODE=SW``` before make, or by setting the SGX_MODE variable environment to SW.
+### Instructions
 
-### Cargo is used by default when compiling, but you can also use Xargo either by adding ```XARGO_SGX=1``` before make, or by setting the XARGO_SGX variable environment to 1. You will also need to specify Xargo library path with XARGO_PATH.
+1. Before proceeding, make sure your [environment is set up](#environment)
+   properly.
+2. Clone the project repository
+    ```
+    $ git clone https://github.com/ntls-io/wasm-exec-sgx
+    ```
+   and `cd` into it.
+3. Run `make all` to compile the entire project.
+4. To run the main application, change to bin/ and execute the following:
+     ```
+    ./app
+    ```
+5. In order to test the provided Wasm binary, change the current directory to
+   the `wasmi-impl` subdirectory and execute the following:
+    ```
+    cargo test
+    ```
 
-### The makefile has those commands available: 
-- make (will compile everything)
-- make host (will only compile the host part)
-- make enclave (will only compile the enclave part)
-- make clean (will clean the objects/C edl files generated)
-- make clean_host (will clean the objects/C edl files generated for the host only)
-- make clean_enclave (will clean the objects/C edl files generated for the enclave only)
-- make fclean (will clean objects/C edl files and the binaries, plus calling cargo clean for everything)
-- make fclean_host (will clean objects/C edl files and the binaries, plus calling cargo clean for the host only)
-- make fclean_enclave (will clean objects/C edl files and the binaries, plus calling cargo clean for the enclave only)
-- make re (re as relink, will clean everything then compile everything again)
-- make re_host (re as relink, will clean the host part then compile it again)
-- make re_enclave (re as relink, will clean the enclave part then compile it again)
+[docker-postinstall]: https://docs.docker.com/engine/install/linux-postinstall/
+[rust-sgx-sdk-env]: https://github.com/PiDelport/rust-sgx-sdk-dev-env