diff --git a/enclave/core/sgx/globals.c b/enclave/core/sgx/globals.c index a286398c67..7591286a49 100644 --- a/enclave/core/sgx/globals.c +++ b/enclave/core/sgx/globals.c @@ -127,6 +127,8 @@ extern volatile const oe_sgx_enclave_properties_t oe_enclave_properties_sgx; static volatile uint64_t _enclave_rva; static volatile uint64_t _reloc_rva; static volatile uint64_t _reloc_size; +static volatile uint64_t _blob_rva; +static volatile uint64_t _blob_size; #endif @@ -196,6 +198,39 @@ size_t __oe_get_reloc_size() #endif } +/* +**============================================================================== +** +** blob boundaries: +** +**============================================================================== +*/ + +const void* __oe_get_blob_base() +{ + const unsigned char* base = __oe_get_enclave_base(); + +#if defined(__linux__) + return base + _blob_rva; +#else +#error "unsupported" +#endif +} + +const void* __oe_get_blob_end() +{ + return (const uint8_t*)__oe_get_blob_base() + __oe_get_blob_size(); +} + +size_t __oe_get_blob_size() +{ +#if defined(__linux__) + return _blob_size; +#else +#error "unsupported" +#endif +} + /* **============================================================================== ** diff --git a/enclave/core/sgx/linux/threadlocal.c b/enclave/core/sgx/linux/threadlocal.c index 1bb133c54c..2196a3c1a7 100644 --- a/enclave/core/sgx/linux/threadlocal.c +++ b/enclave/core/sgx/linux/threadlocal.c @@ -363,7 +363,8 @@ void __cxa_thread_atexit(void (*destructor)(void*), void* object) oe_result_t oe_thread_local_cleanup(td_t* td) { /* OE thread local clean up not required in SW mode for SGXLKL */ - if (td->simulate) return OE_OK; + if (td->simulate) + return OE_OK; /* Call tls atexit functions in reverse order*/ if (_tls_atexit_functions) diff --git a/host/sgx/loadelf.c b/host/sgx/loadelf.c index 18e81b903b..16959f1fbe 100644 --- a/host/sgx/loadelf.c +++ b/host/sgx/loadelf.c @@ -407,7 +407,8 @@ static oe_result_t _calculate_size( const oe_enclave_image_t* image, size_t* image_size) { - *image_size = image->image_size + image->reloc_size; + *image_size = image->image_size + image->reloc_size + + oe_round_up_to_page_size(image->blob_size); return OE_OK; } @@ -444,6 +445,8 @@ static oe_result_t _unload(oe_enclave_image_t* image) ** ** [RELOCATION-PAGES]: ** +** [BLOB-PAGES]: flags=reg|r content=(.oeblob section) +** ** [HEAP-PAGES]: flags=reg|w|r content=0x00000000 ** ** [THREAD-PAGES]: @@ -512,6 +515,68 @@ static oe_result_t _add_relocation_pages( return result; } +static oe_result_t _add_blob_pages( + oe_sgx_load_context_t* context, + uint64_t enclave_addr, + const void* blob_data, + const size_t blob_size, + uint64_t* vaddr) +{ + oe_result_t result = OE_UNEXPECTED; + + if (!context || !vaddr) + OE_RAISE(OE_INVALID_PARAMETER); + + /* Add any blob pages as regular-read-only pages. */ + if (blob_data && blob_size) + { + const uint8_t* p = (const uint8_t*)blob_data; + size_t n = blob_size; + + /* Add whole pages. */ + while (n > OE_PAGE_SIZE) + { + const uint64_t addr = enclave_addr + *vaddr; + const uint64_t src = (uint64_t)p; + const uint64_t flags = SGX_SECINFO_REG | SGX_SECINFO_R; + const bool extend = true; + + OE_CHECK(oe_sgx_load_enclave_data( + context, enclave_addr, addr, src, flags, extend)); + + (*vaddr) += OE_PAGE_SIZE; + + /* Advance to the next page. */ + p += OE_PAGE_SIZE; + n -= OE_PAGE_SIZE; + } + + /* Add remaining bytes. */ + if (n) + { + uint8_t page[OE_PAGE_SIZE]; + const uint64_t addr = enclave_addr + *vaddr; + const uint64_t src = (uint64_t)page; + const uint64_t flags = SGX_SECINFO_REG | SGX_SECINFO_R; + const bool extend = true; + + /* Copy remaining bytes followed by zero-padding. */ + memcpy(page, p, n); + memset(page + n, 0, OE_PAGE_SIZE - n); + + OE_CHECK(oe_sgx_load_enclave_data( + context, enclave_addr, addr, src, flags, extend)); + + (*vaddr) += OE_PAGE_SIZE; + } + } + + result = OE_OK; + +done: + return result; +} + static oe_result_t _add_segment_pages( oe_sgx_load_context_t* context, uint64_t enclave_addr, @@ -595,6 +660,14 @@ static oe_result_t _add_pages( image->reloc_size, vaddr)); + /* Add the .oeblob section pages if any. */ + OE_CHECK(_add_blob_pages( + context, + enclave->addr, + image->u.elf.blob_data, + image->blob_size, + vaddr)); + result = OE_OK; done: @@ -679,16 +752,25 @@ static oe_result_t _patch(oe_enclave_image_t* image, size_t enclave_end) OE_CHECK(_get_symbol_rva(image, "_enclave_rva", &enclave_rva)); OE_CHECK(_set_uint64_t_symbol_value(image, "_enclave_rva", enclave_rva)); + /* Keep track of the current rva starting at the end of image. */ + size_t rva = image->image_size; + /* reloc right after image */ - oeprops->image_info.reloc_rva = image->image_size; + oeprops->image_info.reloc_rva = rva; oeprops->image_info.reloc_size = image->reloc_size; OE_CHECK( _set_uint64_t_symbol_value(image, "_reloc_rva", image->image_size)); OE_CHECK( _set_uint64_t_symbol_value(image, "_reloc_size", image->reloc_size)); + rva += image->reloc_size; + + /* blob right after reloc */ + OE_CHECK(_set_uint64_t_symbol_value(image, "_blob_rva", rva)); + OE_CHECK(_set_uint64_t_symbol_value(image, "_blob_size", image->blob_size)); + rva += oe_round_up_to_page_size(image->blob_size); - /* heap right after image */ - oeprops->image_info.heap_rva = image->image_size + image->reloc_size; + /* heap right after blob */ + oeprops->image_info.heap_rva = rva; if (image->tdata_size) { @@ -788,6 +870,19 @@ oe_result_t oe_load_elf_enclave_image( 0) OE_RAISE(OE_FAILURE); + /* Save pointer to blob data and blob size */ + { + elf64_t* elf = &image->u.elf.elf; + unsigned char* data; + size_t size; + + if (elf64_find_section(elf, ".oeblob", &data, &size) == 0) + { + image->u.elf.blob_data = data; + image->blob_size = size; + } + } + if (oe_get_current_logging_level() >= OE_LOG_LEVEL_VERBOSE) _dump_relocations(image->u.elf.reloc_data, image->reloc_size); diff --git a/include/openenclave/internal/globals.h b/include/openenclave/internal/globals.h index b4a60cfcf7..aa7e64d8ab 100644 --- a/include/openenclave/internal/globals.h +++ b/include/openenclave/internal/globals.h @@ -20,6 +20,11 @@ const void* __oe_get_reloc_base(void); const void* __oe_get_reloc_end(void); size_t __oe_get_reloc_size(void); +/* blob data (from the .oeblob section) */ +const void* __oe_get_blob_base(void); +const void* __oe_get_blob_end(void); +size_t __oe_get_blob_size(void); + /* Heap */ const void* __oe_get_heap_base(void); const void* __oe_get_heap_end(void); diff --git a/include/openenclave/internal/load.h b/include/openenclave/internal/load.h index d268730a39..32ce4e090d 100644 --- a/include/openenclave/internal/load.h +++ b/include/openenclave/internal/load.h @@ -50,6 +50,7 @@ typedef struct _oe_enclave_elf_image oe_elf_segment_t* segments; size_t num_segments; void* reloc_data; + void* blob_data; } oe_enclave_elf_image_t; typedef struct _oe_enclave_pe_image @@ -81,6 +82,9 @@ struct _oe_enclave_image /* size of relocation */ size_t reloc_size; + /* size of blob section */ + size_t blob_size; + /* Thread-local storage .tdata section */ uint64_t tdata_rva; uint64_t tdata_size; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index def98d4f52..b81274defd 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -27,6 +27,7 @@ add_subdirectory(tools) if (OE_SGX) add_subdirectory(cpuid) add_subdirectory(aesm) + add_subdirectory(blob) add_subdirectory(debugger) add_subdirectory(host_verify) add_subdirectory(switchless) diff --git a/tests/blob/CMakeLists.txt b/tests/blob/CMakeLists.txt new file mode 100644 index 0000000000..3c6b38687d --- /dev/null +++ b/tests/blob/CMakeLists.txt @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +add_subdirectory(host) +add_subdirectory(enc) + +set(BLOB ${CMAKE_CURRENT_SOURCE_DIR}/enc/blob.txt) + +add_test(tests/blob + ${CMAKE_CURRENT_BINARY_DIR}/host/blob_host + ${CMAKE_CURRENT_BINARY_DIR}/enc/blob_enc_with_blob + ${BLOB}) diff --git a/tests/blob/README.md b/tests/blob/README.md new file mode 100644 index 0000000000..0bf9d26ecb --- /dev/null +++ b/tests/blob/README.md @@ -0,0 +1,22 @@ +blob test +========= + +This test verifies the .oeblob section loading feature. Enclave image files may +optionally include an .oeblob section. If present, the section is loaded and +measured during enclave loading. Enclaves may access this section at runtime +with the following functions. + +``` +extern const void* __oe_get_blob_base(void); +extern size_t __oe_get_blob_size(void); +``` + +This test uses the **objcopy** command to add an .oeblob section. For example: + +``` +$ objcopy --add-section .oeblob=blob.txt --set-section-flags .oeblob=noload,readonly blob_enc blob_enc_with_blob +``` + +The host program loads the **blob_enc_with_blob** enclave and then passes it +a copy of the blob file. The enclave compares the expected blob contents with +the actual contents of the .oeblob section. diff --git a/tests/blob/blob.edl b/tests/blob/blob.edl new file mode 100644 index 0000000000..306fab9432 --- /dev/null +++ b/tests/blob/blob.edl @@ -0,0 +1,10 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +enclave +{ + trusted + { + public void test_blob([in, size=size] const void* data, size_t size); + }; +}; diff --git a/tests/blob/enc/CMakeLists.txt b/tests/blob/enc/CMakeLists.txt new file mode 100644 index 0000000000..609fb5d4bb --- /dev/null +++ b/tests/blob/enc/CMakeLists.txt @@ -0,0 +1,37 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +##============================================================================== +## +## Rules to create blob_enc and blob_with_blob +## +##============================================================================== + +oeedl_file(../blob.edl enclave gen) + +add_enclave(TARGET blob_enc + UUID a72d9831-4c4b-461d-bf83-e4d3d58cc40b SOURCES enc.c ${gen}) + +target_include_directories(blob_enc PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) + +target_link_libraries(blob_enc oelibc) + +##============================================================================== +## +## Rules to create the enclave with the .oeblob section +## +##============================================================================== + +set(ENCLAVE_IN ${CMAKE_CURRENT_BINARY_DIR}/blob_enc) +set(ENCLAVE_OUT ${ENCLAVE_IN}_with_blob) +set(BLOB ${CMAKE_CURRENT_SOURCE_DIR}/blob.txt) + +add_custom_command( + OUTPUT ${ENCLAVE_OUT} + DEPENDS ${ENCLAVE_IN} + COMMAND objcopy + --add-section .oeblob=${BLOB} + --set-section-flags .oeblob=noload,readonly + ${ENCLAVE_IN} ${ENCLAVE_OUT}) + +add_custom_target(add_blob ALL DEPENDS ${ENCLAVE_OUT}) diff --git a/tests/blob/enc/blob.txt b/tests/blob/enc/blob.txt new file mode 100644 index 0000000000..ae98636013 --- /dev/null +++ b/tests/blob/enc/blob.txt @@ -0,0 +1,88 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. +4zRIvM82HFO8WVXfo+i8hgW9mUbH8G5hAO9xwotMbTH07LeaFFmUWgy5/zc8/8MY +1351EcNEDx09AICHZGxy2e4Kt5EMsmE6kvZAeikTvhCpYN9Qo3pXrkVL2pFDSgJ+ +S2vrtp7FvTILJRI3zovsQ7EGyeMJWVLgMeRFOU0Qvnv3nzbjRClZw+nvbDQQYXwd +GlQskt56l+Ov5Z2227H+TAx7Eay0B/yUCws9Uy2vYbhwLqaq31AZJaIFavtIZBKN +DXkNeNPqz4pM5uNWV7AdO3VHZjhpWsiQAjxIll8qRl0BjzxUlRajQXU7WDVqx5H1 +lWUQVBWiygGeA+91o+txdOvigp2dpKAj3LSSK4o1UBVp+yhjfUuvQbhFLkHCYxr7 +bRDSOKidyFC3LmRjUHweI3WZ1gXg11ouYMb2bscTk7Yhl/xaeDna9qZpeivdowjy +KwMjg7e/mA0HHIlpTy4zEbgs8wN4QlGq4QVzIXSQN9HGx/LVEljGf98IQNesfhVx +XJh5/ecXtfOQ7+hmu2EbCt39w9istBae+tVxf34q8cOqytYE48ha+h5uU5SOsY2h +xRJZCNfG9ddZiMxwgl3PcbhGH+67lQ5sutB9FXscYc5mS1K+nXBLEo1JJxB8uRSs +W3/GeCd30uJcMKS3rFJ+sl06Eup5T4uyQkVw3MzUFf8rV9+qr5+t09rvPMie/zXF +r6Daf9B409TgFLfbJ1OTd/XPVHqvpIurY8F5mnfUtGBdVtfsXyum1omejY8SuIoN +W2JF8JeqLrpuOEkp77+gUrqiiFETyPSSBwFXy6k+gspph4sMxdRvq5UH5xTTL3yv +/GC4e4fUhYo1kxpDVmUyECS5hqrx76mXlSnYbh9aCsL96QwPiCH+UMTiQ72zYEpp +ZTHK5dfKGRmR8ZCGjCvQaaAAPs20P5ZEsHDBpYXewJalGhNDxK17tdum5yeKcpu7 +3h7iItePrVOHUuiS+hsqgzNtWD59tIi45uBcnLk3IXvNo0ijltn22wDuIcnLn/7H +3PW9q70+yq8fpmvrYI5T9wWpu2+Y5FRfPMe3/IKn4OKo9a6QsMvtfwX04zMOQKzC +hFOEWTD2lmaf2Yi/oMNwK0b5aK6Z3GOaHqQkbx3bSxATB5cKVYluKa0fgsmpM91v +Geg/25zy5L2agsoV+P5vnm7awkYM9XbFYr38iff4W2ja6NAHpEEJ2iKe47o3Kgme +wi1YQcQn8JZLLMJ1QxMpYghgcJKbEtvZ+2s4z2DAWBcWMXDISO7rJDzuEDmBI4c2 +8SELLKthcnyshMp0BGNYntaBKTNTivdwfAIVKdHb66NAZcdgrHw1xUI7N6IBhZUW +G9Nl62pm0KturUEWQJ7vq86tHVw3Clpi9qQDGHn3VdwtC5aADGJkl6VGeC2oQ1Hp +96N91RH/oLYnlAN3PpU2qZc0rAA16GVOQpUTOPe27NURcZf16ek0gdxSSTS8/stO +4aBRQCuZvpl47bzP5RSidcADXmeWj/Y6963NT8Yj6QdNvQ4A/bmDEbCyEG0uRMJr +fRcD49IqIxkMimeLVNUMR8z3ceCDlb/tEZKptscrbYb4InGcipRscv8OwUxmZHIo +t0UUPRAqF8kQGPEbGBN7dyn2qYVzsNG9p9Z9Vn0AKW1lBwwUzZJ3YztCViTf+iWp +BQmKyrbnURgm8oaCc+dambHnb76zZpJdfVKyRov02ElQlo1Gdi59r7+Na6fugFQD +l+xHUy9bohILmpb5M6+Jra8ZoOdzBZ3KHrx63SXhAAyyuWZ8ZS1rj/0C80Dys4KT +1jbqeGlLz/W038n+tYwtl1jd8H6A/H227w4IgB33OPH+Ilj6jgtTBBFP7ZvgSJ04 +NKVUYC8C22h2HGodhhfnA+GiVuUe4SDa2mhnJ9xj2C3YNOB7hB+eLXPVuv8I2pKf +zxpqdF3QNHxylZdzXCiyJWsGFU+jZOLMwl2AmSxpToTc7mlqraxWJ0b6V/RhQC8g +eHEfr2mRMoJkdepQ+L8EopKvVeL9AyOmtq0k3z8iU5rJ8/9qUo16jh+DVWbyxSjq +wUJINGTcQQpSi0/tHtQkqKbXkUb99EcbK+/oBcA+5iNjGsRVNvH/CvNNHy58P3UM +idfQKrEfqDyE8mBN/zkzgNSCxkKcqdrpf9+NFXxhJ11a7TKyJsbFU6kJiFoLaW8E +ghxRsGKIjSBHx8ucxwr7ZFjCsId5zTTC6GwgtPDnNI97esDv2a6QmKVmr60mxHu6 +XfY2vQj7zpA8drCS9p6orElgF4efT6lP9bzF8rdlBTpJk9SaABiiQzIJcjAPudi6 +VxiYmRHgB0mvu6NIaIGvwjYriO+rKeql3NxRkWKKlQk/k7FQ7NanRycSTCUAoJ75 +JAlGf90J8DyDL+DPM5WYq+WMPmnZW3CMrbbJScVS+HPqYB/8s10e3eaj/ZRkPI8T +ovjz0w1qRlMDq2+ZdxQrNhDD6bOCj5Eu0EtyNIk3tWbVGAr7zlg7Ou6ioXNEqFme +P6EWGG4gs+wXeU/V8EQO5IZ6jqsqmNznqaxmACtA4Dwp8YjMRYvvyGMq2SnWO0xE +AuD5fP1m4LtRdX9WWGe2AiPGI5MyoUa07a5pbCx7SuBMt1oI/qlQrnNwoQ54S01o +fhe7dOPfdoNJITiRMmzAT7xjrvlzen1FLuEW+l3eqCu5uwE/TTaklYyfvZ/HW245 +V06hdbthMoQ81zihEvMatWGvkqXx6Zj73LYNSzOhgSg+L2mP3iPTgQFPAs7nlPws +P03+8taBgOy7uOzrbKyFSXv8hoKCvvczRFu2OK37P9bgBm6UZb6TelUbpWEbmivx +VdVeoHlOrd2GRmvVZqD1/TrDzaYDXa+rzhhpa7jfgAFBkFwur1A08pL0dF7UEDdn +0I5D4IzQod94OEMDHjQSypdH7twEDV9ACMTRhNqEA99BUE43M/M8YgNUj/cbv9Ym +YOsZfuqX/n+hwtbJeWzroWBOUYsRhapBIDYBIjkcxY96rb2CmsOSUkw6qa5kWIZz +7tSMFgyOfsbT0pmwX3+VSDwaI7V06g4mY74ghR9ofnoFTFuHMuIL+T/OSA/MHAGU +BFleJcz1j8Zk+UEtbdOg+VCySN1xyLJy4UDzn27ry/s4NEHH2ycfTnMLUZ5MC0Bf +Y93N0BGpDS45HqhADI9Lij9XvuVmrU7o2g9rbD8fWv3WgWiyega73JBU+n4hQ0bB +AtGLGd8uzC4n87M90tKaaUS50BGne4l+n6bYZhnLciu80wlpoKOdcs+yA9kqPKt4 +ca261A/Acc9bwoRocCHU9d1OJAJlGRI1bXnGGycQGBjLcz5o16crlhJUsDFHd11F +Bdj44sPwJKUGkNZIhSlfp3U7NkM88CSH88Z6DE+tfWWi16d0CpYBUZuC0TgKY+CL +FapaP8osmJjLggJXmHqoWtsDHahY9anF8M+Mwq2EQXuzkLPUCORtZqUK4DcnOySg +kxTteSYQc/G14AVhGQ5DENiCjQqyNjf9P2t3b+L9Lb/GPAw3SnAn/+wAn98TiNYc +RFjGC3/Ux/ydFK3qSCcIyp8SHtneC3LW749DB7ZwrKCcEjeoZGID5+bYnCkWBpKa +aR2K9i4ZgLw/atZlbfjfjNnwmjbNlcdpaS+dQhXvl4EfCt71crx/6IzxKcYm0yog +QvWPR6ChB4vPaCShl4IUadHL6fFgU/zDTTKxHb+zk1ZJDjBD0gzm3z6bk5XinGRF +hef3LI2oUdFkrlP4kA9v6x8H2aLCZ9bdIcobeqGnZKoUGWbJHx4sHMB5i6v+fFlZ +uRyh0z3wug4gWPn3iVXUyR0HihZEJ+/0CRJhV/KeONl/9QQ5Al61WHnd3hI9d+Ma +upIrQ2BeZOeNbNmszczklrC2C7By4GbhqMv9klYMBYj2Ymg4/5JLG85aCew/otVE +x5+kv0Rxa5RaamKpoglJQslKL2DMRk6At+gmyrCUTq9Kh+QKv/npDpXMcktI6F57 +ykcOsc0/pGZEpbaC/I7iYfff298C5oIQPoEmZ6mTKGxSGUFTt3yYSPNVGOf92ENF +ihaeBmXrFy7eRQV9noY2dO5dI0o8FXV4i1JO1jJYXbAE4ywq0CyWPRPi4EJldLgE +Ez4AY8lIcPBG5hfMjr1+Zk0+DrX4uRmf9/zQx0REaVZvJk1dXb4mXJUgapums+Fv +HFQi0DncTi7v4NUuq3iTWIjzEIjm+TDhb3seZx2ZIIAzQP/88+WtWhqXWz5VBYXI +KonH9m78NQsVg4WvTx+8xNYk6so+AOFHcAxSnNyurXKIcn4MdcKB8rbf25o9uASo +9tCrOw+ZWua7oSzEIeJ20ZftNEsVItMzc68eWoms9CFEHt9FW1eKCLl5Nng6Tejj +ENwJY88UrQkgl0sX+Fc0I6wY71wUg/Hd5cy0YcaRYSiCRMHp4IBg2Xz0HzWtGCJ9 +R3ro6wwVYDRSQqeDPkDZWYGJQ9KqiiS9eY5Fkw2ykVA7gHldUISdC5afXboNjGuM +aO/6P3tedzHOGBM8Du30BLyFc7yjdGoa9S4PlTO3fHXy9GSKVoBhKKyeR3MVLiFa +2HFQhuwwDbc9Z9J7mShPGb/dEhq+GML8fkXWy132BU6N11ma7DjHf8l3VPvXrLWU +XexZTETYN3z+ZOELMcGfS6agbzO4x0puEdnQ5A68fVBtfpg7hy4r7stKe1fEjCy3 +xZha+GSYJF7Oe33JJeuWHhIY2tQXRomFN6RHinyNjKEWKGhoPmnURg11MWtqn7x+ +NxKJ6zjcCcOWku4k6HB5VPrFXOw/tmURQLgyJNyWBRLp4XSANJDXewhTUhL/yaHY +s+dVN7I6zP45/ATxz9kzWfAi22fjTJLSvxDU6o1rSLNQ/u9QO05gOfEakpb/m1DZ +C8uuKPb/4u60sRENzZ95lcmw4XjtDk4mzo7KjtuOU1PGA29at99bObrOqHm/awUc +uxYbRjrcnQ7WbLHN1DZ9MnhEGD71WOL3zuCQmapHnLDiCIwclJV+g056xjOPpzF0 +rlDhu4JjwzjfaI3fTzJl9UcqwNgNOdbPhLVXjiy4K/hb13e6iBsoTB+7GcIJDuF6 +sE11GUxj8PYeOzlA7+aBRHgxDBb2qc9qMav6ZxaTHB+V+h4PoFQzCDF52jQrXZUA +eP3ieJJRs7WsI0reQdNgr5Oz+JgYSw/9rJM19c1Euqww26lqwyxDrbttFZKqrqRE +/I1jWVKyoT/6v1qoe9iKJlFEkrZrpbTk5Kr+0KG49iTjIdOlOH8Qn9wYv89F0PKw +VjOizjvsPxw5mTRAkISx4O9ATNdZZ641mxeBh2tji1ucYt/m5HWLfQOExg5dRnHw +Kd4Xehq90Pde5s7mIcLXQyx5PFTR0N7d+5hMwmGxUggvJuv6X1c7APimq7biYqTq +YFJLgT/mU418QfO2ja6/F0iKQYilr+g38Nk5YCcy+kGSDQ4ohlpaeMN44LJzid7u +XINpjFmtRXqInE050g== diff --git a/tests/blob/enc/enc.c b/tests/blob/enc/enc.c new file mode 100644 index 0000000000..39704cefdf --- /dev/null +++ b/tests/blob/enc/enc.c @@ -0,0 +1,36 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +#include +#include +#include +#include +#include "blob_t.h" + +void test_blob(const void* data, size_t size) +{ + extern const void* __oe_get_blob_base(void); + extern size_t __oe_get_blob_size(void); + const void* blob_data; + size_t blob_size; + + blob_data = __oe_get_blob_base(); + blob_size = __oe_get_blob_size(); + + OE_TEST(data != NULL); + OE_TEST(blob_data != NULL); + OE_TEST(blob_size == size); + OE_TEST(memcmp(blob_data, data, size) == 0); + + printf("%.*s\n", (int)blob_size, blob_data); + + oe_host_printf("=== passed all tests (enclave)\n"); +} + +OE_SET_ENCLAVE_SGX( + 1, /* ProductID */ + 1, /* SecurityVersion */ + true, /* AllowDebug */ + 1024, /* HeapPageCount */ + 1024, /* StackPageCount */ + 2); /* TCSCount */ diff --git a/tests/blob/host/CMakeLists.txt b/tests/blob/host/CMakeLists.txt new file mode 100644 index 0000000000..5a1f27b708 --- /dev/null +++ b/tests/blob/host/CMakeLists.txt @@ -0,0 +1,10 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +oeedl_file(../blob.edl host gen) + +add_executable(blob_host host.c ${gen}) + +target_include_directories(blob_host PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) + +target_link_libraries(blob_host oehostapp) diff --git a/tests/blob/host/host.c b/tests/blob/host/host.c new file mode 100644 index 0000000000..4b89610c6f --- /dev/null +++ b/tests/blob/host/host.c @@ -0,0 +1,45 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +#include +#include +#include +#include +#include +#include +#include "blob_u.h" + +int main(int argc, const char* argv[]) +{ + const char* arg0 = argv[0]; + oe_result_t result; + oe_enclave_t* enclave; + const uint32_t flags = oe_get_create_flags(); + const oe_enclave_type_t type = OE_ENCLAVE_TYPE_SGX; + void* data; + size_t size; + + if (argc != 3) + { + fprintf(stderr, "Usage: %s ENCLAVE_PATH BLOB_FILE\n", arg0); + return 1; + } + + result = oe_create_blob_enclave(argv[1], type, flags, NULL, 0, &enclave); + OE_TEST(result == OE_OK); + + result = __oe_load_file(argv[2], 0, &data, &size); + OE_TEST(result == OE_OK); + + result = test_blob(enclave, data, size); + OE_TEST(result == OE_OK); + + result = oe_terminate_enclave(enclave); + OE_TEST(result == OE_OK); + + free(data); + + printf("=== passed all tests (host)\n"); + + return 0; +}