ssize_t read(int fd, void *buf, size_t count)
{
sgx_stub_info *stub = (sgx_stub_info *)STUB_ADDR;
int tmp_len;
ssize_t rt;
int i;
rt = 0;
for (i = 0; i < count / SGXLIB_MAX_ARG + 1; i++) {
stub->fcode = FUNC_READ;
stub->out_arg1 = fd;
if (i == count / SGXLIB_MAX_ARG)
tmp_len = (int)count % SGXLIB_MAX_ARG;
else
tmp_len = SGXLIB_MAX_ARG;
stub->out_arg2 = tmp_len;
sgx_exit(stub->trampoline);
memcpy((uint8_t *)buf + i * SGXLIB_MAX_ARG, stub->in_data1, tmp_len);
rt += stub->in_arg1;
}
return rt;
}
void enclave_main()
{
global_var = 'a';
sgx_puts((char *)&global_var);
sgx_print_hex((unsigned long)global_var);
sgx_exit(NULL);
}
void sgx_debug(char msg[])
{
size_t size = sgx_strlen(msg);
sgx_stub_info_tp *stub = (sgx_stub_info_tp *)STUB_ADDR_TP;
stub->fcode = FUNC_DEBUG;
sgx_memcpy(stub->out_data1, msg, size);
sgx_exit(stub->trampoline);
}
void sgx_print_bytes(char *s, size_t n)
{
sgx_stub_info_tp *stub = (sgx_stub_info_tp *)STUB_ADDR_TP;
stub->fcode = FUNC_PRINT_BYTES;
sgx_memcpy(stub->out_data1, s, n);
stub->out_arg1 = n;
sgx_exit(stub->trampoline);
}
void enclave_main()
{
sgx_debug("qsort test\n");
sgx_qsort(values, 6, sizeof(int), compare);
sgx_printf("%d %d %d %d %d %d\n", values[0], values[1], values[2], values[3], values[4], values[5]);
sgx_exit(NULL);
}
void enclave_main()
{
int a[30000];
for(int i=0; i<30000; i++)
a[i] = 1;
sgx_puts("test stack\n");
sgx_exit(NULL);
}
int puts(const char *s)
{
sgx_stub_info *stub = (sgx_stub_info *)STUB_ADDR;
stub->fcode = FUNC_PUTS;
memcpy(stub->out_data1, s, strlen(s));
sgx_exit(stub->trampoline);
return stub->in_arg1;
}
int listen(int fd, int backlog)
{
sgx_stub_info *stub = (sgx_stub_info *)STUB_ADDR;
stub->fcode = FUNC_LISTEN;
stub->out_arg1 = fd;
stub->out_arg2 = backlog;
sgx_exit(stub->trampoline);
return stub->in_arg1;
}
int connect(int fd, const struct sockaddr *addr, socklen_t len)
{
sgx_stub_info *stub = (sgx_stub_info *)STUB_ADDR;
stub->fcode = FUNC_CONNECT;
stub->out_arg1 = fd;
memcpy(stub->out_data1, addr, len);
stub->out_arg2 = len;
sgx_exit(stub->trampoline);
return stub->in_arg1;
}
void enclave_main()
{
int challenger_port = 8024, ret;
ret = sgx_intra_attest_target(challenger_port);
if(ret == 1) {
puts("Intra Attestaion Success!");
} else {
puts("Intra Attestation Fail!");
}
sgx_exit(NULL);
}
struct tm *sgx_gmtime(const time_t *timep)
{
sgx_stub_info_tp *stub = (sgx_stub_info_tp *)STUB_ADDR_TP;
struct tm temp_tm;
stub->fcode = FUNC_GMTIME;
stub->out_arg4 = *timep;
sgx_exit(stub->trampoline);
sgx_memcpy(&temp_tm, &stub->in_tm, sizeof(struct tm));
return &temp_tm;
}
void enclave_main()
{
int target_port, ret;
char *conf = "../user/demo/simple-intra-attest-target.conf";
target_port = 8024;
ret = sgx_intra_attest_challenger(target_port, conf);
if(ret == 1) {
puts("Intra Attestaion Success!");
} else {
puts("Intra Attestation Fail!");
}
sgx_exit(NULL);
}
void enclave_main()
{
int i;
srand(time(NULL));
for (i = 0; i < N_OBJ; i++) {
int type = rand() % N_TYPE;
int size = 0;
switch (type) {
case MEM_TYPE_SMALL:
size = rand() % (3*SIZE_SMALL) + SIZE_SMALL;
break;
case MEM_TYPE_LARGE:
case MEM_TYPE_MID:
size = rand() % (3*SIZE_MID) + SIZE_MID;
break;
/*
case MEM_TYPE_LARGE:
size = rand() % (3*SIZE_LARGE) + SIZE_LARGE;
break;
*/
default:
exit(1);
}
obj[i].buf = (unsigned long)malloc(size);
obj[i].size = size;
}
quickSort(obj, 0, N_OBJ-1);
for (i = 1; i < N_OBJ; i++) {
unsigned long boundary = obj[i-1].buf + (unsigned long)obj[i-1].size;
if (boundary > obj[i].buf)
printf("Err: %lx > %lx\n", boundary, obj[i].buf);
}
printf("Malloc test pass\n");
sgx_exit(NULL);
}
void enclave_main()
{
struct sockaddr_in sa;
SSL* ssl;
X509* server_cert;
SSLeay_add_ssl_algorithms();
SSL_load_error_strings();
SSL_CTX* ctx = SSL_CTX_new (SSLv23_method());
char* filename = "output.pem";
int sd = socket (AF_INET, SOCK_STREAM, 0);//create socket
if (sd!=-1 && ctx!=NULL)
{
memset (&sa, '\0', sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_addr.s_addr = inet_addr ("216.58.219.206"); /* Server IP */
sa.sin_port = htons (443); /* Server Port number */
if (connect(sd, (struct sockaddr*) &sa, sizeof(sa)) != -1)
{
ssl = SSL_new (ctx);
if (ssl!=NULL)
{
SSL_set_fd(ssl, sd);
int err = SSL_connect(ssl);
if (err!=-1)
{
server_cert = SSL_get_peer_certificate(ssl);
if (server_cert!=NULL)
{
BIO * bio_out = BIO_new_file(filename, "w");
if (bio_out)
{
X509_print(bio_out, server_cert); //parsed
PEM_write_bio_X509(bio_out, server_cert);
BIO_free(bio_out);
printf("Done writing to %s\n", filename);
}
X509_free (server_cert);
}
else {
printf("No cert found!\n");
}
}
SSL_free (ssl);
}
close(sd);//close socket
}
else {
printf("Connection error %s\n", strerror(errno));
}
}
else{
printf("Can't open socket");
}
SSL_CTX_free (ctx);
sgx_exit(NULL);
}
void enclave_start()
{
enclave_main();
sgx_exit(NULL);
}
void enclave_main()
{
SSL_METHOD *method;
SSL_CTX *ctx;
BIO *bio_cert;
BIO *bio_pkey;
X509 *cert = NULL;
EVP_PKEY *pkey = NULL;
int port = 5566;
int srvr_fd;
int clnt_fd;
struct sockaddr_in addr;
// Initialize ssl
SSL_library_init();
// Initialize ctx
OpenSSL_add_all_algorithms();
method = TLSv1_2_server_method();
ctx = SSL_CTX_new(method);
// Load certificate
bio_cert = BIO_new(BIO_s_mem());
BIO_puts(bio_cert, cert_s);
cert = PEM_read_bio_X509(bio_cert, NULL, 0, NULL);
if (cert == NULL) {
sgx_debug("cert is NULL");
} else {
sgx_debug("cert is not NULL");
}
bio_pkey = BIO_new(BIO_s_mem());
BIO_puts(bio_pkey, pkey_s);
pkey = PEM_read_bio_PrivateKey(bio_pkey, NULL, 0, NULL);
if (pkey == NULL) {
sgx_debug("key is NULL\n");
} else {
sgx_debug("key is not NULL\n");
}
if (SSL_CTX_use_certificate(ctx, cert) <= 0) {
sgx_debug("SSL_CTX_use_certificate failed\n");
//sgx_exit(NULL);
} else {
sgx_debug("SSL_CTX_use_certificate succeeded\n");
}
if (SSL_CTX_use_PrivateKey(ctx, pkey) <= 0) {
sgx_debug("SSL_CTX_use_PrivateKey failed\n");
//sgx_exit(NULL);
} else {
sgx_debug("SSL_CTX_use_PrivateKey succeeded\n");
}
SSL_CTX_set_ecdh_auto(ctx, 1);
SSL_CTX_set_options(ctx, SSL_OP_SINGLE_ECDH_USE);
srvr_fd = sgx_socket(PF_INET, SOCK_STREAM, 0);
if (srvr_fd == -1) {
sgx_exit(NULL);
}
sgx_memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = sgx_htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
if (sgx_bind(srvr_fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
sgx_exit(NULL);
}
if (sgx_listen(srvr_fd, 10) != 0) {
sgx_exit(NULL);
}
while (1) {
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
SSL *ssl;
int sd;
int bytes;
char buf[256];
const char* echo="<html><body><pre>%s</pre></body></html>\n\n";
clnt_fd = sgx_accept(srvr_fd, (struct sockaddr *)&addr, &len);
if (clnt_fd < 0) {
sgx_puts("ERROR on accept\n");
continue;
}
ssl = SSL_new(ctx);
SSL_set_fd(ssl, clnt_fd);
if (SSL_accept(ssl) == -1)
sgx_puts("SSL accept failed\n");
else {
sgx_puts("SSL accept succeeded\n");
bytes = SSL_read(ssl, buf, sizeof(buf));
if (bytes > 0) {
buf[bytes] = 0;
sgx_puts(buf);
char msg[] = "Successfully connected\n";
SSL_write(ssl, msg, sgx_strlen(msg));
}
}
sd = SSL_get_fd(ssl);
//SSL_free(ssl);
sgx_close(sd);
//sgx_close(clnt_fd);
}
sgx_close(srvr_fd);
sgx_exit(NULL);
}
