[Assignment-7] Flake + App base
Some checks failed
Latex Build / build-latex (Assignment 4 - Protokollsicherheit (Praxis)) (push) Failing after 8s
Latex Build / build-latex (Assignment 5 - Software Security - Teil 1) (push) Failing after 7s
Latex Build / build-latex (Assignment 6 - Software Security - Teil 2) (push) Failing after 7s
Latex Build / build-latex (Assignment 4 - Protokollsicherheit (Praxis)) (pull_request) Failing after 6s
Latex Build / build-latex (Assignment 5 - Software Security - Teil 1) (pull_request) Failing after 7s
Latex Build / build-latex (Assignment 6 - Software Security - Teil 2) (pull_request) Failing after 7s
Some checks failed
Latex Build / build-latex (Assignment 4 - Protokollsicherheit (Praxis)) (push) Failing after 8s
Latex Build / build-latex (Assignment 5 - Software Security - Teil 1) (push) Failing after 7s
Latex Build / build-latex (Assignment 6 - Software Security - Teil 2) (push) Failing after 7s
Latex Build / build-latex (Assignment 4 - Protokollsicherheit (Praxis)) (pull_request) Failing after 6s
Latex Build / build-latex (Assignment 5 - Software Security - Teil 1) (pull_request) Failing after 7s
Latex Build / build-latex (Assignment 6 - Software Security - Teil 2) (pull_request) Failing after 7s
- Add Assignment-7 to flake.nix - Implement basic framework of app - Implement proxy subcommand (mostly) - Implement basics of intermediary subcommand
This commit is contained in:
parent
ad8bb7a762
commit
7e62822d0c
GPG key ID:
B471A1AF06C895FD
23 changed files with 615 additions and 10 deletions
|
|
@ -1,81 +0,0 @@
|
|||
# Makefile for building the application
|
||||
# Use:
|
||||
# make - compiles both release and test binaries
|
||||
# make release - compiles and runs the release binary
|
||||
# make test - compiles and runs the test binary
|
||||
# make clean - deletes all binaries in build/bin
|
||||
# make cleaner - deltes the whole build directory
|
||||
|
||||
# Compiler
|
||||
CC = clang
|
||||
CFLAGS = -Wall -Wextra -Werror
|
||||
LDFLAGS =
|
||||
|
||||
# Directories
|
||||
SRC_DIR = src
|
||||
LIB_DIR = lib
|
||||
TEST_DIR = test
|
||||
APP_DIR = $(SRC_DIR)/app
|
||||
ENCLAVE_DIR = $(SRC_DIR)/enclave
|
||||
BUILD_DIR = build
|
||||
OBJ_DIR = $(BUILD_DIR)/obj
|
||||
BIN_DIR = $(BUILD_DIR)/bin
|
||||
|
||||
# Source files
|
||||
LIB_SRCS = $(wildcard $(LIB_DIR)/*.c)
|
||||
APP_SRCS = $(wildcard $(APP_DIR)/*.c) $(wildcard $(ENCLAVE_DIR)/*.c)
|
||||
TEST_SRCS = $(wildcard $(TEST_DIR)/*.c)
|
||||
|
||||
# Object files
|
||||
LIB_OBJS = $(LIB_SRCS:$(LIB_DIR)/%.c=$(OBJ_DIR)/lib/%.o)
|
||||
APP_OBJS = $(APP_SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/src/%.o)
|
||||
TEST_OBJS = $(TEST_SRCS:$(TEST_DIR)/%.c=$(OBJ_DIR)/test/%.o)
|
||||
|
||||
# Binaries
|
||||
RELEASE_BIN = $(BIN_DIR)/release
|
||||
TEST_BIN = $(BIN_DIR)/test
|
||||
|
||||
$(RELEASE_BIN): $(LIB_OBJS) $(APP_OBJS)
|
||||
@mkdir -p $(BIN_DIR)
|
||||
@$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
|
||||
|
||||
$(TEST_BIN): $(LIB_OBJS) $(TEST_OBJS)
|
||||
@mkdir -p $(BIN_DIR)
|
||||
@$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^
|
||||
|
||||
$(OBJ_DIR)/lib/%.o: $(LIB_DIR)/%.c
|
||||
@mkdir -p $(dir $@)
|
||||
@$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(OBJ_DIR)/src/%.o: $(SRC_DIR)/%.c
|
||||
@mkdir -p $(dir $@)
|
||||
@$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
$(OBJ_DIR)/test/%.o: $(TEST_DIR)/%.c
|
||||
@mkdir -p $(dir $@)
|
||||
@$(CC) $(CFLAGS) -c -o $@ $<
|
||||
|
||||
# Targets
|
||||
.PHONY: all clean release test
|
||||
|
||||
all: release test
|
||||
|
||||
release: $(RELEASE_BIN) run_release
|
||||
|
||||
run_release:
|
||||
@echo "RUNNING RELEASE"
|
||||
@./$(RELEASE_BIN)
|
||||
|
||||
test: $(TEST_BIN) run_test
|
||||
|
||||
run_test:
|
||||
@echo "RUNNING TESTS"
|
||||
@./$(TEST_BIN)
|
||||
|
||||
clean:
|
||||
@echo "Deleting binaries"
|
||||
@rm -rf $(BIN_DIR)
|
||||
|
||||
cleaner:
|
||||
@echo "Deleting builds"
|
||||
@rm -rf $(BUILD_DIR)
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
|
||||
#include <stdio.h>
|
||||
|
||||
int main() {
|
||||
printf("Hello World");
|
||||
}
|
||||
|
||||
|
|
@ -1,266 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* * Neither the name of Intel Corporation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h> /* vsnprintf */
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "Enclave.h"
|
||||
#include "Enclave_t.h"
|
||||
#include <sgx_tseal.h>
|
||||
#include <sgx_error.h>
|
||||
#include <sgx_tcrypto.h>
|
||||
|
||||
#ifndef SK_SIZE
|
||||
#define SK_SIZE SGX_ECP256_KEY_SIZE
|
||||
#endif
|
||||
|
||||
#ifndef PK_SIZE
|
||||
#define PK_SIZE 2*SK_SIZE
|
||||
#endif
|
||||
|
||||
#ifndef SI_SIZE
|
||||
#define SI_SIZE 2*SK_SIZE
|
||||
#endif
|
||||
|
||||
int get_sealed_size() {
|
||||
return sgx_calc_sealed_data_size(PK_SIZE, SK_SIZE);
|
||||
}
|
||||
|
||||
int get_signature_size() {
|
||||
return SI_SIZE;
|
||||
}
|
||||
|
||||
int get_public_key_size() {
|
||||
return PK_SIZE;
|
||||
}
|
||||
|
||||
int get_private_key_size() {
|
||||
return SK_SIZE;
|
||||
}
|
||||
|
||||
sgx_status_t seal_key_pair(sgx_ec256_private_t *private, sgx_ec256_public_t *public, uint8_t **sealed, uint32_t sealed_size) {
|
||||
// invalid parameter handling
|
||||
if((private == NULL) || (public == NULL))
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
|
||||
// allocate temporary buffers on stack
|
||||
uint8_t pk[PK_SIZE] = {0};
|
||||
uint8_t sk[SK_SIZE] = {0};
|
||||
|
||||
// copy key pair into buffers
|
||||
memcpy(pk, public->gx, PK_SIZE);
|
||||
memcpy(sk, private->r, SK_SIZE);
|
||||
|
||||
// calculate needed size
|
||||
uint32_t size = get_sealed_size();
|
||||
if(size > sealed_size) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// seal keypair
|
||||
return sgx_seal_data(PK_SIZE, (const uint8_t *)pk, SK_SIZE, (const uint8_t *)sk, size, (sgx_sealed_data_t *) *sealed);
|
||||
}
|
||||
|
||||
sgx_status_t unseal_key_pair(const uint8_t *sealed, sgx_ec256_private_t *private, sgx_ec256_public_t *public) {
|
||||
// invalid parameter handling
|
||||
if(sealed == NULL) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// allocate temporary buffers on stack
|
||||
uint8_t pk[PK_SIZE] = {0};
|
||||
uint8_t sk[SK_SIZE] = {0};
|
||||
|
||||
// calculate public_key size and return error for unexpected results
|
||||
uint32_t pk_size = sgx_get_add_mac_txt_len((const sgx_sealed_data_t *)sealed);
|
||||
uint32_t sk_size = sgx_get_encrypt_txt_len((const sgx_sealed_data_t *)sealed);
|
||||
if ((pk_size != PK_SIZE) || (sk_size != SK_SIZE)) {
|
||||
return SGX_ERROR_UNEXPECTED;
|
||||
}
|
||||
|
||||
// unseal ecc key pair
|
||||
sgx_status_t status = sgx_unseal_data((const sgx_sealed_data_t *)sealed, pk, &pk_size, sk, &sk_size);
|
||||
if (status != SGX_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
// copy buffers into key structs
|
||||
if(public != NULL) {
|
||||
memcpy(public->gx, pk, PK_SIZE);
|
||||
}
|
||||
if (private != NULL) {
|
||||
memcpy(private->r, sk, SK_SIZE);
|
||||
}
|
||||
|
||||
// return success
|
||||
return status;
|
||||
}
|
||||
|
||||
sgx_status_t get_public_key(const uint8_t *sealed, uint32_t sealed_size, uint8_t *gx, uint32_t gx_size, uint8_t *gy, uint32_t gy_size) {
|
||||
// invalid parameter handling
|
||||
if((sealed == NULL) || (sealed_size == 0)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// unseal public key
|
||||
sgx_status_t status;
|
||||
sgx_ec256_public_t public;
|
||||
if((status = unseal_key_pair(sealed, NULL, &public)) != SGX_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
// copy public key into return buffers
|
||||
if((gx != NULL) && (gy != NULL)) {
|
||||
memcpy(gx, public.gx, SK_SIZE);
|
||||
memcpy(gy, public.gy, SK_SIZE);
|
||||
}
|
||||
|
||||
// return success
|
||||
return status;
|
||||
}
|
||||
|
||||
sgx_status_t sign_firmware(const uint8_t *data, uint32_t data_size, uint8_t *sealed, uint32_t sealed_size, uint8_t *signature, uint32_t signature_size) {
|
||||
// invalid parameter handling
|
||||
if((data == NULL) || (data_size == 0)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
} else if((sealed == NULL) || (sealed_size == 0)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// declare need structures
|
||||
sgx_ecc_state_handle_t ecc_handle;
|
||||
sgx_ec256_private_t private;
|
||||
sgx_ec256_public_t public;
|
||||
|
||||
// open ecc handle
|
||||
sgx_status_t status;
|
||||
if((status = sgx_ecc256_open_context(&ecc_handle)) != SGX_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
// try unseal keypair
|
||||
sgx_status_t seal_status;
|
||||
if(seal_status = unseal_key_pair(sealed, &private, NULL) != SGX_SUCCESS) {
|
||||
if((status = sgx_ecc256_create_key_pair(&private, &public, ecc_handle)) != SGX_SUCCESS) {
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
// create signature
|
||||
sgx_ec256_signature_t ecc_signature;
|
||||
if((status = sgx_ecdsa_sign(data, data_size, &private, &ecc_signature, ecc_handle)) != SGX_SUCCESS) {
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return status;
|
||||
}
|
||||
|
||||
// TODO: possible wrong endianess for other programms
|
||||
// copy signature to return buffer
|
||||
if((signature == NULL) || (signature_size == 0)) {
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
memcpy(signature, ecc_signature.x, SI_SIZE);
|
||||
|
||||
// seal the key
|
||||
if((seal_status != SGX_SUCCESS) && (sealed != NULL)) {
|
||||
seal_status = seal_key_pair(&private, &public, &sealed, sealed_size);
|
||||
}
|
||||
|
||||
// close ecc handle and return success
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return seal_status;
|
||||
}
|
||||
|
||||
sgx_status_t verify_firmware(const uint8_t *data, uint32_t data_size, const uint8_t *sealed, uint32_t sealed_size, const uint8_t *public_key, uint32_t public_key_size, const uint8_t *signature, uint32_t signature_size) {
|
||||
// invalid parameter handling
|
||||
if((data == NULL) || (data_size == 0)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
} else if(((sealed == NULL) || (sealed_size == 0)) && ((public_key == NULL) || (public_key_size == 0))) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
} else if((sealed != NULL) && (public_key != NULL)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
} else if((signature == NULL) || (signature_size == 0)) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// declare need structures
|
||||
sgx_ec256_signature_t ecc_signature;
|
||||
sgx_ecc_state_handle_t ecc_handle;
|
||||
sgx_ec256_public_t public;
|
||||
|
||||
// invalid signature
|
||||
if(signature_size > SI_SIZE) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// open ecc handle
|
||||
sgx_status_t status;
|
||||
if((status = sgx_ecc256_open_context(&ecc_handle)) != SGX_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
// copy signature into struct
|
||||
memcpy(ecc_signature.x, signature, SI_SIZE);
|
||||
|
||||
// verify signature from staff or enclave
|
||||
if(public_key != NULL) {
|
||||
// invalid public key
|
||||
if(public_key_size != PK_SIZE) {
|
||||
return SGX_ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// copy public key into struct
|
||||
memcpy(public.gx, public_key, PK_SIZE);
|
||||
} else {
|
||||
// unseal public key
|
||||
if(unseal_key_pair(sealed, NULL, &public) != SGX_SUCCESS) {
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return SGX_ERROR_UNEXPECTED;
|
||||
}
|
||||
}
|
||||
|
||||
// verify signature
|
||||
uint8_t result;
|
||||
sgx_status_t verification_status = sgx_ecdsa_verify((const uint8_t *)data, data_size, (const sgx_ec256_public_t *)&public, (const sgx_ec256_signature_t *)&ecc_signature, &result, ecc_handle);
|
||||
|
||||
// handle failed verification process
|
||||
if(verification_status != SGX_SUCCESS) {
|
||||
result = verification_status;
|
||||
}
|
||||
|
||||
// close handle and return result
|
||||
sgx_ecc256_close_context(ecc_handle);
|
||||
return result;
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
<EnclaveConfiguration>
|
||||
<ProdID>0</ProdID>
|
||||
<ISVSVN>0</ISVSVN>
|
||||
<StackMaxSize>0x400000</StackMaxSize>
|
||||
<HeapMaxSize>0x1000000</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>
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* * Neither the name of Intel Corporation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Enclave.edl - Top EDL file. */
|
||||
|
||||
enclave {
|
||||
|
||||
/* Import ECALL/OCALL from sub-directory EDLs.
|
||||
* [from]: specifies the location of EDL file.
|
||||
* [import]: specifies the functions to import,
|
||||
* [*]: implies to import all functions.
|
||||
*/
|
||||
|
||||
trusted {
|
||||
public int get_sealed_size();
|
||||
public int get_signature_size();
|
||||
public int get_public_key_size();
|
||||
public int get_private_key_size();
|
||||
public sgx_status_t get_public_key([in, size=sealed_size]const uint8_t *sealed, uint32_t sealed_size, [out, size=gx_size]uint8_t *gx, uint32_t gx_size, [out, size=gx_size]uint8_t *gy, uint32_t gy_size);
|
||||
public sgx_status_t sign_firmware([in, size=data_size]const uint8_t *data, uint32_t data_size, [in, out, size=sealed_size]uint8_t *sealed, uint32_t sealed_size, [out, size=signature_size]uint8_t *signature, uint32_t signature_size);
|
||||
public sgx_status_t verify_firmware([in, size=data_size]const uint8_t *data, uint32_t data_size, [in, size=sealed_size]const uint8_t *sealed, uint32_t sealed_size, [in, size=public_key_size]const uint8_t *public_key, uint32_t public_key_size, [in, size=signature_size]const uint8_t *signature, uint32_t signature_size);
|
||||
};
|
||||
|
||||
/*
|
||||
* ocall_print_string - invokes OCALL to display string buffer inside the enclave.
|
||||
* [in]: copy the string buffer to App outside.
|
||||
* [string]: specifies 'str' is a NULL terminated buffer.
|
||||
*/
|
||||
untrusted {
|
||||
|
||||
};
|
||||
};
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
* * Neither the name of Intel Corporation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _ENCLAVE_H_
|
||||
#define _ENCLAVE_H_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <assert.h>
|
||||
#include <sgx_error.h>
|
||||
|
||||
int get_sealed_size();
|
||||
int get_signature_size();
|
||||
int get_public_key_size();
|
||||
int get_private_key_size();
|
||||
|
||||
sgx_status_t get_public_key(const uint8_t *sealed, const uint32_t sealed_size, uint8_t *gx, uint32_t gx_size, uint8_t *gy, uint32_t gy_size);
|
||||
sgx_status_t sign_firmware(const uint8_t *data, uint32_t data_size, uint8_t *sealed, uint32_t sealed_size, uint8_t *signature, uint32_t signature_size);
|
||||
sgx_status_t verify_firmware(const uint8_t *data, uint32_t data_size, const uint8_t *sealed, uint32_t sealed_size, const uint8_t *public_key, uint32_t public_key_size, const uint8_t *signature, uint32_t signature_size);
|
||||
|
||||
#endif /* !_ENCLAVE_H_ */
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
#include "framework_test.h"
|
||||
|
||||
bool test_function_true() {
|
||||
return assert_true(false, "Test function true");
|
||||
}
|
||||
|
||||
bool test_function_false() {
|
||||
return assert_false(false, "Reason why it failed");
|
||||
}
|
||||
|
||||
void framework_test() {
|
||||
start_tests("Test Group Name");
|
||||
run_test("Test Name", test_function_true);
|
||||
run_test("Test Name", test_function_false);
|
||||
end_tests();
|
||||
}
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
#ifndef CRYPTO_FRAMEWORK_TEST_H
|
||||
#define CRYPTO_FRAMEWORK_TEST_H
|
||||
|
||||
#include "mini_test.h"
|
||||
|
||||
void framework_test();
|
||||
|
||||
#endif //CRYPTO_FRAMEWORK_TEST_H
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
|
||||
#include "framework_test.h"
|
||||
|
||||
int main() {
|
||||
// Tests
|
||||
framework_test();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
#include "mini_test.h"
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdbool.h>
|
||||
#include <time.h>
|
||||
|
||||
#define RESET_COLOR "\x1b[0m"
|
||||
#define RED_COLOR "\x1b[31m"
|
||||
#define GREEN_COLOR "\x1b[32m"
|
||||
#define ORANGE_COLOR "\x1b[33m"
|
||||
#define BEGIN_FAT_TEXT "\033[1m"
|
||||
#define END_FAT_TEXT "\033[0m"
|
||||
|
||||
static int total_tests = 0;
|
||||
static int passed_tests = 0;
|
||||
static char *group;
|
||||
|
||||
void start_tests(char *group_name) {
|
||||
group = group_name;
|
||||
total_tests = 0;
|
||||
passed_tests = 0;
|
||||
printf("Starting tests " BEGIN_FAT_TEXT "%s" END_FAT_TEXT "...\n", group);
|
||||
}
|
||||
|
||||
void end_tests() {
|
||||
if (passed_tests == total_tests) {
|
||||
printf(GREEN_COLOR "[%d/%d] Tests passed" RESET_COLOR "\n", passed_tests, total_tests);
|
||||
} else if (passed_tests == 0) {
|
||||
printf(RED_COLOR "[%d/%d] Tests passed" RESET_COLOR "\n", passed_tests, total_tests);
|
||||
} else {
|
||||
printf(ORANGE_COLOR "[%d/%d] Tests passed" RESET_COLOR "\n", passed_tests, total_tests);
|
||||
}
|
||||
}
|
||||
|
||||
void run_test(const char *test_name, bool (*test_fn)(void)) {
|
||||
total_tests++;
|
||||
printf("\tTesting %s... ", test_name);
|
||||
clock_t start, end;
|
||||
start = clock();
|
||||
bool result = test_fn();
|
||||
end = clock();
|
||||
double time_passed = ((double)(end - start)) / CLOCKS_PER_SEC;
|
||||
if (result) {
|
||||
printf(GREEN_COLOR "[✓] %.4fs" RESET_COLOR "\n", time_passed);
|
||||
passed_tests++;
|
||||
} else {
|
||||
printf(RED_COLOR "" RESET_COLOR "\n");
|
||||
}
|
||||
}
|
||||
|
||||
bool assert_true(bool condition, const char *message, ...) {
|
||||
if (!condition) {
|
||||
printf(RED_COLOR "[X] Assertion failed: " RESET_COLOR);
|
||||
va_list args;
|
||||
va_start(args, message);
|
||||
vprintf(message, args);
|
||||
va_end(args);
|
||||
printf(" ");
|
||||
}
|
||||
return condition;
|
||||
}
|
||||
|
||||
bool assert_false(bool condition, const char *message, ...) {
|
||||
if (condition) {
|
||||
printf(RED_COLOR "[X] Assertion failed: " RESET_COLOR);
|
||||
va_list args;
|
||||
va_start(args, message);
|
||||
vprintf(message, args);
|
||||
va_end(args);
|
||||
printf(" ");
|
||||
}
|
||||
return !condition;
|
||||
}
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
#ifndef CRYPTO_MINI_TEST_H
|
||||
#define CRYPTO_MINI_TEST_H
|
||||
#include <stdbool.h>
|
||||
|
||||
void start_tests(char *group_name);
|
||||
|
||||
void end_tests();
|
||||
|
||||
void run_test(const char *tests_name, bool (*test_fn)(void));
|
||||
|
||||
bool assert_true(bool condition, const char *message, ...);
|
||||
|
||||
bool assert_false(bool condition, const char *message, ...);
|
||||
|
||||
#endif //CRYPTO_MINI_TEST_H
|
||||
Loading…
Add table
Add a link
Reference in a new issue