text:
minimumMaxIC = 0.0
minimumSimJ = 0.25
minimumAsymSimJ = 0.2
thresholdAsymSimJ = 0.25
topN = 10
compare = HP,ZP
scoringMetrics = JACCARD


text:
minimumMaxIC = 0.0
minimumSimJ = 0.5
minimumAsymSimJ = 0.5
thresholdAsymSimJ = 0.5
topN = 10
compare = HP,MP
scoringMetrics = JACCARD

repo_name: obophenotype/upheno

repo_language: Makefile

mime_type: text/plain


text:
minimumMaxIC = 0.0
minimumSimJ = 0.25
minimumAsymSimJ = 0.2
thresholdAsymSimJ = 0.25
topN = 10
compare = HP,WBPhenotype
scoringMetrics = JACCARD


text:
__NOTE: when browsing the TSVs on GitHub, the right hand columns may appear truncated__

## Generated fuzzy matchings between ontologies

Use the following PURLs:

 * http://purl.obolibrary.org/obo/upheno/mappings/hp-to-zp-bestmatches.tsv
 * http://purl.obolibrary.org/obo/upheno/mappings/hp-to-mp-bestmatches.tsv
 * http://purl.obolibrary.org/obo/upheno/mappings/hp-to-wbphenotype-bestmatches.tsv

Columns:

 1. HP Class ID
 2. HP Class Label
 3. Other ontology class ID
 4. Other ontology class Label
 5. Fuzzy equivalence score
 5. Fuzzy SubClass score

Both scores range over 0 to 1.

Currently the fuzzy equivalence score is the Jaccard similarity:

    |Anc(C) /\ Anc(D)|
    ------------------
    |Anc(C) \/ Anc(D)|

The fuzzy SubClass score is a measure of how much the HP class is a subclass of the external class:

    |Anc(C) /\ Anc(D)|
    ------------------
         |Anc(D)|


text:
minimumMaxIC = 0.0
minimumSimJ = 0.25
minimumAsymSimJ = 0.2
thresholdAsymSimJ = 0.25
topN = 10
compare = ZP,HP
scoringMetrics = JACCARD


text:
######## SGX SDK Settings ########

SGX_SDK ?= /opt/intel/sgxsdk # Intel SGX directory
SGX_MODE ?= SW # HW or SW (Hardware or Simulation mode)
SGX_ARCH ?= x64 # x64 or x86
SGX_DEBUG ?= 1 # DEBUG MODE

# Find out whether 32 or 64 bit
ifeq ($(shell getconf LONG_BIT), 32)
	SGX_ARCH := x86
else ifeq ($(findstring -m32, $(CXXFLAGS)), -m32)
	SGX_ARCH := x86
endif

ifeq ($(SGX_ARCH), x86)
	SGX_COMMON_CFLAGS := -m32 # flag to compiler regarding 32 or 64 bit
	SGX_LIBRARY_PATH := $(SGX_SDK)/lib # SGX library path
	SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x86/sgx_sign # Tool for signing enclaves
	SGX_EDGER8R := $(SGX_SDK)/bin/x86/sgx_edger8r # Tool to create bridge routines
else
	SGX_COMMON_CFLAGS := -m64
	SGX_LIBRARY_PATH := $(SGX_SDK)/lib64
	SGX_ENCLAVE_SIGNER := $(SGX_SDK)/bin/x64/sgx_sign
	SGX_EDGER8R := $(SGX_SDK)/bin/x64/sgx_edger8r
endif

ifeq ($(SGX_DEBUG), 1)
ifeq ($(SGX_PRERELEASE), 1)
$(error Cannot set SGX_DEBUG and SGX_PRERELEASE at the same time!!)
endif
endif

ifeq ($(SGX_DEBUG), 1)
        SGX_COMMON_CFLAGS += -O0 -g # Add debug symbols, turn off optimisations
else
        SGX_COMMON_CFLAGS += -O2 # turn on optimisations
endif

######## App Settings ########

ifneq ($(SGX_MODE), HW)
	Urts_Library_Name := sgx_urts_sim
else
	Urts_Library_Name := sgx_urts
endif

App_Cpp_Files := App/App.cpp
App_Include_Paths := -IApp -I$(SGX_SDK)/include

App_C_Flags := $(SGX_COMMON_CFLAGS) -fPIC -Wno-attributes $(App_Include_Paths)

# Three configuration modes - Debug, prerelease, release
#   Debug - Macro DEBUG enabled.
#   Prerelease - Macro NDEBUG and EDEBUG enabled.
#   Release - Macro NDEBUG enabled.
ifeq ($(SGX_DEBUG), 1)
        App_C_Flags += -DDEBUG -UNDEBUG -UEDEBUG
else ifeq ($(SGX_PRERELEASE), 1)
        App_C_Flags += -DNDEBUG -DEDEBUG -UDEBUG
else
        App_C_Flags += -DNDEBUG -UEDEBUG -UDEBUG
endif

App_Cpp_Flags := $(App_C_Flags) -std=c++11
App_Link_Flags := $(SGX_COMMON_CFLAGS) -L$(SGX_LIBRARY_PATH) -l$(Urts_Library_Name) -lpthread

ifneq ($(SGX_MODE), HW)
	App_Link_Flags += -lsgx_uae_service_sim
else
	App_Link_Flags += -lsgx_uae_service
endif

App_Cpp_Objects := $(App_Cpp_Files:.cpp=.o) App/ocalls.o

App_Name := app

######## Enclave Settings ########

ifneq ($(SGX_MODE), HW)
	Trts_Library_Name := sgx_trts_sim
	Service_Library_Name := sgx_tservice_sim
else
	Trts_Library_Name := sgx_trts
	Service_Library_Name := sgx_tservice
endif
Crypto_Library_Name := sgx_tcrypto

Enclave_Cpp_Files := Enclave/Enclave.cpp Enclave/sqlite3.c
Enclave_Include_Paths := -IEnclave -I$(SGX_SDK)/include -I$(SGX_SDK)/include/tlibc -I$(SGX_SDK)/include/libcxx

Enclave_C_Flags := $(SGX_COMMON_CFLAGS) -nostdinc -fvisibility=hidden -fpie -ffunction-sections -fdata-sections -fstack-protector-strong
Enclave_C_Flags += $(Enclave_Include_Paths)
Enclave_Cpp_Flags := $(Enclave_C_Flags) -std=c++11 -nostdinc++

# To generate a proper enclave, it is recommended to follow below guideline to link the trusted libraries:
#    1. Link sgx_trts with the `--whole-archive' and `--no-whole-archive' options,
#       so that the whole content of trts is included in the enclave.
#    2. For other libraries, you just need to pull the required symbols.
#       Use `--start-group' and `--end-group' to link these libraries.
# Do NOT move the libraries linked with `--start-group' and `--end-group' within `--whole-archive' and `--no-whole-archive' options.
# Otherwise, you may get some undesirable errors.
Enclave_Link_Flags := $(SGX_COMMON_CFLAGS) -Wl,--no-undefined -nostdlib -nodefaultlibs -nostartfiles -L$(SGX_LIBRARY_PATH) \
	-Wl,--whole-archive -l$(Trts_Library_Name) -Wl,--no-whole-archive \
	-Wl,--start-group -lsgx_tstdc -lsgx_tcxx -l$(Crypto_Library_Name) -l$(Service_Library_Name) -Wl,--end-group \
	-Wl,-Bstatic -Wl,-Bsymbolic -Wl,--no-undefined \
	-Wl,-pie,-eenclave_entry -Wl,--export-dynamic  \
	-Wl,--defsym,__ImageBase=0 -Wl,--gc-sections   \
	-Wl,--version-script=Enclave/Enclave.lds

Enclave_Cpp_Objects := Enclave/Enclave.o Enclave/sqlite3.o Enclave/ocall_interface.o

Enclave_Name := enclave.so
Signed_Enclave_Name := enclave.signed.so
Enclave_Config_File := Enclave/Enclave.config.xml

ifeq ($(SGX_MODE), HW)
ifeq ($(SGX_DEBUG), 1)
	Build_Mode = HW_DEBUG
else ifeq ($(SGX_PRERELEASE), 1)
	Build_Mode = HW_PRERELEASE
else
	Build_Mode = HW_RELEASE
endif
else
ifeq ($(SGX_DEBUG), 1)
	Build_Mode = SIM_DEBUG
else ifeq ($(SGX_PRERELEASE), 1)
	Build_Mode = SIM_PRERELEASE
else
	Build_Mode = SIM_RELEASE
endif
endif

##### TARGETS #####

.PHONY: all run

# Default target "all" is to build
ifeq ($(Build_Mode), HW_RELEASE)
all: .config_$(Build_Mode)_$(SGX_ARCH) $(App_Name) $(Enclave_Name)
	@echo "The project has been built in release hardware mode."
	@echo "Please sign the $(Enclave_Name) first with your signing key before you run the $(App_Name) to launch and access the enclave."
	@echo "To sign the enclave use the command:"
	@echo "   $(SGX_ENCLAVE_SIGNER) sign -key <your key> -enclave $(Enclave_Name) -out <$(Signed_Enclave_Name)> -config $(Enclave_Config_File)"
	@echo "You can also sign the enclave using an external signing tool."
	@echo "To build the project in simulation mode set SGX_MODE=SIM. To build the project in prerelease mode set SGX_PRERELEASE=1 and SGX_MODE=HW."
else
all: .config_$(Build_Mode)_$(SGX_ARCH) $(App_Name) $(Signed_Enclave_Name)
ifeq ($(Build_Mode), HW_DEBUG)
	@echo "The project has been built in debug hardware mode."
else ifeq ($(Build_Mode), SIM_DEBUG)
	@echo "The project has been built in debug simulation mode."
else ifeq ($(Build_Mode), HW_PRERELEASE)
	@echo "The project has been built in pre-release hardware mode."
else ifeq ($(Build_Mode), SIM_PRERELEASE)
	@echo "The project has been built in pre-release simulation mode."
else
	@echo "The project has been built in release simulation mode."
endif
endif

# Build and run project
run: all
ifneq ($(Build_Mode), HW_RELEASE)
	$(CURDIR)/$(App_Name)
	@echo "RUN  =>  $(App_Name) [$(SGX_MODE)|$(SGX_ARCH), OK]"
endif

######## App Objects ########

# Genereate untrusted brigde routines (Enclave_u.c and Enclave_u.h) using .edl file
App/Enclave_u.c: $(SGX_EDGER8R) Enclave/Enclave.edl
	cd App && $(SGX_EDGER8R) --untrusted ../Enclave/Enclave.edl --search-path ../Enclave --search-path $(SGX_SDK)/include
	@echo "GEN  =>  $@"

# Compile untrusted brigde routines
App/Enclave_u.o: App/Enclave_u.c
	$(CC) $(App_C_Flags) -DSGX_UNTRUSTED -c $< -o $@
	@echo "CC   <=  $<"

# Compile ocalls
App/ocalls.o: App/ocalls.c
	$(CC) $(App_C_Flags) -c $< -o $@
	@echo "CC   <=  $<"

# Compile untrusted Application
App/%.o: App/%.cpp
	$(CXX) $(App_Cpp_Flags) -c $< -o $@
	@echo "CXX  <=  $<"

# Link and generate main Application executable
$(App_Name): App/Enclave_u.o App/ocalls.o $(App_Cpp_Objects)
	$(CXX) $^ -o $@ $(App_Link_Flags)
	@echo "LINK =>  $@"

.config_$(Build_Mode)_$(SGX_ARCH):
	rm -f .config_* $(App_Name) $(Enclave_Name) $(Signed_Enclave_Name) $(App_Cpp_Objects) App/Enclave_u.* $(Enclave_Cpp_Objects) Enclave/Enclave_t.*
	@touch .config_$(Build_Mode)_$(SGX_ARCH)

######## Enclave Objects ########

# Genereate trusted brigde routines (Enclave_t.c and Enclave_t.h) using .edl file
Enclave/Enclave_t.c: $(SGX_EDGER8R) Enclave/Enclave.edl
	cd Enclave && $(SGX_EDGER8R) --trusted ../Enclave/Enclave.edl --search-path ../Enclave --search-path $(SGX_SDK)/include
	@echo "GEN  =>  $@"

# Compile trusted brigde routines
Enclave/Enclave_t.o: Enclave/Enclave_t.c
	$(CC) $(Enclave_C_Flags) -c $< -o $@
	@echo "CC   <=  $<"

# Compile trusted Enclave
Enclave/Enclave.o: Enclave/Enclave.cpp
	$(CXX) $(Enclave_Cpp_Flags) -c $< -o $@
	@echo "CXX  <=  $<"

# Preprocess sqlite3
Enclave/sqlite3.i: Enclave/sqlite3.c
	$(CC) -I$(SGX_SDK)/include -DSQLITE_THREADSAFE=0 -E $< -o $@
	@echo "CC-Preprocess  <=  $<"

# Compile sqlite3
Enclave/sqlite3.o: Enclave/sqlite3.i Enclave/sqlite3.c
	$(CC) $(Enclave_C_Flags) -DSQLITE_THREADSAFE=0 -c $< -o $@
	@echo "CC  <=  $<"

# Preprocess sqlite3
Enclave/ocall_interface.i: Enclave/ocall_interface.c
	$(CC) -I$(SGX_SDK)/include -E $< -o $@
	@echo "CC-Preprocess  <=  $<"

# Compile ocall_interface
Enclave/ocall_interface.o: Enclave/ocall_interface.i Enclave/Enclave_t.c
	$(CC) $(Enclave_C_Flags) -c $< -o $@
	@echo "CC  <=  $<"

# Link and generate Enclave shared library/executable
$(Enclave_Name): Enclave/Enclave_t.o $(Enclave_Cpp_Objects)
	$(CXX) $^ -o $@ $(Enclave_Link_Flags)
	@echo "LINK =>  $@"

$(Signed_Enclave_Name): $(Enclave_Name)
	$(SGX_ENCLAVE_SIGNER) sign -key Enclave/Enclave_private.pem -enclave $(Enclave_Name) -out $@ -config $(Enclave_Config_File)
	@echo "SIGN =>  $@"

.PHONY: clean

clean:
	rm -f .config_* $(App_Name) $(Enclave_Name) $(Signed_Enclave_Name) $(App_Cpp_Objects) App/Enclave_u.* $(Enclave_Cpp_Objects) Enclave/Enclave_t.* Enclave/sqlite3.i Enclave/ocall_interface.i

repo_language: C

mime_type: text/x-c++


text:
# SGX_SQLite
SQLite database inside a secure Intel SGX enclave (Linux).

You can execute your SQL statements securely. The official SQLite library ("sqlite.c", "sqlite.h") is entirely loaded into an enclave.
However, if you want to save your database (i.e. not in-memory database) it will save *.db file without any encryption yet. (need to implement data sealing in the future)

SQLite Version - 3.19.3

The project started from "SampleEnclave" provided by Intel SGX SDK. Later, I've added official SQLite library, and then redirected all system calls to ocalls (untrusted part).
You can track the development from scratch by viewing all commits.

This project may act as guide on how to port C applications inside Intel SGX enclave on Linux.

# Prerequisites:
* Ubuntu* Desktop-16.04-LTS 64bits
* Intel SGX SDK, SGX Driver, SGX PSW from https://github.com/01org/linux-sgx
* 6th Generation Intel(R) Core(TM) Processor or newer (only if you want to run it in hardware mode, otherwise run in software/simulation mode)

# What's Included
* **App/** - directory for untrusted part of the application
  * **App.cpp** - main file for our app
  * **ocalls.c** - implementations of untrusted ocalls in C
* **Enclave/** - directory for trusted part of the application
  * **Enclave.config.xml** - enclave config file (same as in SampleEnclave from Intel)
  * **Enclave.cpp** - implementations of trusted ecalls in C++
  * **Enclave.edl** - enclave interface file for declarations of all ecalls and ocalls
  * **Enclave.lds** - lds file (same as in SampleEnclave from Intel)
  * **Enclave_private.pem** - enclave private key (same as in SampleEnclave from Intel)
  * **ocall_interface.c** - implementations of redirected system calls from sqlite3.c (not all syscalls implemented)
  * **sqlite3.c** - official SQLite amalgamation (made minor changes to correctly redirect syscalls - see commit history)
  * **sqlite3.h** - official SQLite amalgamation (unchanged)
* **ocall_types.h** - declarations of some stdlib types for need for edl file (since stlib is untrusted)

# Building
`make` for simple simulation mode (unsecure)

`make SGX_MODE=HW SGX_DEBUG=0 SGX_PRERELEASE=1` for hardware mode in pre-release mode

`make SGX_MODE=HW SGX_DEBUG=0 SGX_PRERELEASE=0` for hardware mode in a secure release mode (but you need to sign your enclave first)

# Running
`./app test.db` to create test.db


text:
#ifndef _OCALL_TYPES_H_
#define _OCALL_TYPES_H_

// Divide system definitions into trusted and untrusted part for ocalls type declarations
#ifdef SGX_UNTRUSTED
// For untrusted part take standard library headers
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#else
// For trusted part copy required standard library declarations from stdlib headers

// For ocall_interface.c do not redefine these types, otherwise define
#ifndef DO_NOT_REDEFINE_FOR_OCALL

typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned int mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef __off_t off_t;
typedef long int __syscall_slong_t;

struct stat
{
    __dev_t st_dev;
    __ino_t st_ino;
    __nlink_t st_nlink;
    __mode_t st_mode;
    __uid_t st_uid;
    __gid_t st_gid;
    int __pad0;
    __dev_t st_rdev;
    __off_t st_size;
    __blksize_t st_blksize;
    __blkcnt_t st_blocks;
    __time_t st_atim;
    __time_t st_mtim;
    __time_t st_ctim;
    __syscall_slong_t __glibc_reserved[3];
};

#endif // DO_NOT_REDEFINE_FOR_OCALL_INTERFACE

#endif // SGX_UNTRUSTED

#endif // _OCALL_TYPES_H_


text:
enclave.so
{
    global:
        g_global_data_sim;
        g_global_data;
        enclave_entry;
        g_peak_heap_used;
    local:
        *;
};


text:
#include "Enclave_t.h" // Headers for trusted part (autogenerated by edger8r)
#include "sqlite3.h"
#include <string>

sqlite3* db; // Database connection object

// SQLite callback function for printing results
static int callback(void *NotUsed, int argc, char **argv, char **azColName){
    int i;
    for(i = 0; i < argc; i++){
        std::string azColName_str = azColName[i];
        std::string argv_str = (argv[i] ? argv[i] : "NULL");
        ocall_print_string((azColName_str + " = " + argv_str + "\n").c_str());
    }
    ocall_print_string("\n");
    return 0;
}

void ecall_opendb(const char *dbname){
    int rc; // For return status of SQLite
    rc = sqlite3_open(dbname, &db); // Opening database
    if (rc) {
        ocall_println_string("SQLite error - can't open database connection: ");
        ocall_println_string(sqlite3_errmsg(db));
        return;
    }
    ocall_print_string("Enclave: Created database connection to ");
    ocall_println_string(dbname);
}

void ecall_execute_sql(const char *sql){
    int rc;
    char *zErrMsg = 0;
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    if (rc) {
        ocall_print_string("SQLite error: ");
        ocall_println_string(sqlite3_errmsg(db));
        return;
    }
}

void ecall_closedb(){
    sqlite3_close(db);
    ocall_println_string("Enclave: Closed database connection");
}


text:
enclave {
    from "sgx_tstdc.edl" import *;
    include "../ocall_types.h" // Need to import some type declartions from stdlib

    trusted {
        public void ecall_opendb([in, string] const char *dbname); // open SQLite connection to dbname
        public void ecall_execute_sql([in, string] const char *sql); // Execute SQL statement inside enclave
        public void ecall_closedb(void); // close SQLite db connection
    };

    untrusted {
        void ocall_println_string([in, string] const char *str);
        void ocall_print_string([in, string] const char *str);
        void ocall_print_error([in, string] const char *str);

        int ocall_lstat([in, string] const char *path, [in, out, size=size] struct stat *buf, size_t size) propagate_errno;
        int ocall_stat([in, string] const char *path, [in, out, size=size] struct stat *buf, size_t size);
        int ocall_fstat(int fd, [in, out, size=size] struct stat* buf, size_t size);
        int ocall_ftruncate(int fd, off_t length);

        char* ocall_getcwd([out, size=size] char *buf, size_t size) propagate_errno;
        int ocall_getpid(void);
        int ocall_getuid(void);
        char* ocall_getenv([in, string] const char *name);

        int ocall_open64([in, string] const char *filename, int flags, mode_t mode);
        int ocall_close(int fd);
        off_t ocall_lseek64(int fd, off_t offset, int whence) propagate_errno;
        int ocall_read(int fd, [out, size=count] void *buf, size_t count) propagate_errno;
        int ocall_write(int fd, [in, size=count] const void *buf, size_t count) propagate_errno;
        int ocall_fsync(int fd);
        int ocall_fcntl(int fd, int cmd, [in, size=size] void* arg, size_t size) propagate_errno;
        int ocall_unlink([in, string] const char *pathname);
    };
};


text:
<EnclaveConfiguration>
  <ProdID>0</ProdID>
  <ISVSVN>0</ISVSVN>
  <StackMaxSize>0x40000</StackMaxSize>
  <HeapMaxSize>0x100000</HeapMaxSize>
  <TCSNum>10</TCSNum>
  <TCSPolicy>1</TCSPolicy>
  <!-- Recommend changing 'DisableDebug' to 1 to make the enclave undebuggable for enclave release -->
  <DisableDebug>0</DisableDebug>
  <MiscSelect>0</MiscSelect>
  <MiscMask>0xFFFFFFFF</MiscMask>
</EnclaveConfiguration>


text:
-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----