loader.cpp 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795
  1. /*
  2. * Copyright (C) 2011-2016 Intel Corporation. All rights reserved.
  3. *
  4. * Redistribution and use in source and binary forms, with or without
  5. * modification, are permitted provided that the following conditions
  6. * are met:
  7. *
  8. * * Redistributions of source code must retain the above copyright
  9. * notice, this list of conditions and the following disclaimer.
  10. * * Redistributions in binary form must reproduce the above copyright
  11. * notice, this list of conditions and the following disclaimer in
  12. * the documentation and/or other materials provided with the
  13. * distribution.
  14. * * Neither the name of Intel Corporation nor the names of its
  15. * contributors may be used to endorse or promote products derived
  16. * from this software without specific prior written permission.
  17. *
  18. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29. *
  30. */
  31. #include "se_wrapper.h"
  32. #include "se_error_internal.h"
  33. #include "arch.h"
  34. #include "util.h"
  35. #include "loader.h"
  36. #include "se_page_attr.h"
  37. #include "enclave.h"
  38. #include "enclave_creator.h"
  39. #include "routine.h"
  40. #include "sgx_attributes.h"
  41. #include "se_vendor.h"
  42. #include "se_detect.h"
  43. #include "binparser.h"
  44. #include <assert.h>
  45. #include <vector>
  46. #include <algorithm>
  47. #define __STDC_FORMAT_MACROS
  48. #include <inttypes.h>
  49. #include <sys/mman.h>
  50. // enclave creator instance
  51. extern EnclaveCreator* g_enclave_creator;
  52. EnclaveCreator* get_enclave_creator(void)
  53. {
  54. return g_enclave_creator;
  55. }
  56. CLoader::CLoader(uint8_t *mapped_file_base, BinParser &parser)
  57. : m_mapped_file_base(mapped_file_base)
  58. , m_enclave_id(0)
  59. , m_start_addr(NULL)
  60. , m_metadata(NULL)
  61. , m_parser(parser)
  62. {
  63. memset(&m_secs, 0, sizeof(m_secs));
  64. }
  65. CLoader::~CLoader()
  66. {
  67. }
  68. sgx_enclave_id_t CLoader::get_enclave_id() const
  69. {
  70. return m_enclave_id;
  71. }
  72. const void* CLoader::get_start_addr() const
  73. {
  74. return m_start_addr;
  75. }
  76. const std::vector<tcs_t *>& CLoader::get_tcs_list() const
  77. {
  78. return m_tcs_list;
  79. }
  80. const secs_t& CLoader::get_secs() const
  81. {
  82. return m_secs;
  83. }
  84. void* CLoader::get_symbol_address(const char * const symbol)
  85. {
  86. uint64_t rva = m_parser.get_symbol_rva(symbol);
  87. if(0 == rva)
  88. return NULL;
  89. return GET_PTR(void, m_start_addr, rva);
  90. }
  91. int CLoader::build_mem_region(const section_info_t &sec_info)
  92. {
  93. int ret = SGX_SUCCESS;
  94. uint64_t offset = 0;
  95. sec_info_t sinfo;
  96. memset(&sinfo, 0, sizeof(sinfo));
  97. // Build pages of the section that are contain initialized data. Each page
  98. // needs to be added individually as the page may hold relocation data, in
  99. // which case the page needs to be marked writable.
  100. while(offset < sec_info.raw_data_size)
  101. {
  102. uint64_t rva = sec_info.rva + offset;
  103. uint64_t size = MIN((SE_PAGE_SIZE - PAGE_OFFSET(rva)), (sec_info.raw_data_size - offset));
  104. sinfo.flags = sec_info.flag;
  105. if (is_relocation_page(rva, sec_info.bitmap))
  106. sinfo.flags = sec_info.flag | SI_FLAG_W;
  107. if (size == SE_PAGE_SIZE)
  108. ret = build_pages(rva, size, sec_info.raw_data + offset, sinfo, ADD_EXTEND_PAGE);
  109. else
  110. ret = build_partial_page(rva, size, sec_info.raw_data + offset, sinfo, ADD_EXTEND_PAGE);
  111. if(SGX_SUCCESS != ret)
  112. return ret;
  113. // The only time we aren't guaranteed to advance the offset by a full
  114. // page is when the rva to be added starts in the middle of a page, as
  115. // offset is always advanced to the next page boundary. The only case
  116. // where the rva can start in the middle of the page is for the initial
  117. // rva, i.e. offset == 0.
  118. offset += (offset == 0) ? size : SE_PAGE_SIZE;
  119. }
  120. // Add any remaining uninitialized data. We can call build_pages directly
  121. // even if there are partial pages since the source is null, i.e. everything
  122. // is filled with '0'. Uninitialied data cannot be a relocation table, ergo
  123. // there is no need to check the relocation bitmap.
  124. if(sec_info.virtual_size > offset)
  125. {
  126. uint64_t rva = sec_info.rva + offset;
  127. size_t size = (size_t)(ROUND_TO_PAGE(sec_info.virtual_size - offset));
  128. sinfo.flags = sec_info.flag;
  129. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  130. return ret;
  131. }
  132. return SGX_SUCCESS;
  133. }
  134. int CLoader::build_sections(vector<uint8_t> *bitmap)
  135. {
  136. int ret = SGX_SUCCESS;
  137. std::vector<Section*> sections = m_parser.get_sections();
  138. uint64_t max_rva =0;
  139. Section* last_section = NULL;
  140. for(unsigned int i = 0; i < sections.size() ; i++)
  141. {
  142. if((last_section != NULL) &&
  143. (ROUND_TO_PAGE(last_section->virtual_size() + last_section->get_rva()) < ROUND_TO_PAGE(ROUND_TO_PAGE(last_section->virtual_size()) + last_section->get_rva())) &&
  144. (ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size()) < (sections[i]->get_rva() & (~(SE_PAGE_SIZE - 1)))))
  145. {
  146. size_t size = SE_PAGE_SIZE;
  147. sec_info_t sinfo;
  148. memset(&sinfo, 0, sizeof(sinfo));
  149. sinfo.flags = last_section->get_si_flags();
  150. uint64_t rva = ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size());
  151. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  152. return ret;
  153. }
  154. if(sections[i]->get_rva() > max_rva)
  155. {
  156. max_rva = sections[i]->get_rva();
  157. last_section = sections[i];
  158. }
  159. section_info_t sec_info = { sections[i]->raw_data(), sections[i]->raw_data_size(), sections[i]->get_rva(), sections[i]->virtual_size(), sections[i]->get_si_flags(), bitmap };
  160. if(SGX_SUCCESS != (ret = build_mem_region(sec_info)))
  161. return ret;
  162. }
  163. if((last_section != NULL) &&
  164. (ROUND_TO_PAGE(last_section->virtual_size() + last_section->get_rva()) < ROUND_TO_PAGE(ROUND_TO_PAGE(last_section->virtual_size()) + last_section->get_rva())))
  165. {
  166. size_t size = SE_PAGE_SIZE;
  167. sec_info_t sinfo;
  168. memset(&sinfo, 0, sizeof(sinfo));
  169. sinfo.flags = last_section->get_si_flags();
  170. uint64_t rva = ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size());
  171. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  172. return ret;
  173. }
  174. return SGX_SUCCESS;
  175. }
  176. int CLoader::build_partial_page(const uint64_t rva, const uint64_t size, const void *source, const sec_info_t &sinfo, const uint32_t attr)
  177. {
  178. // RVA may or may not be aligned.
  179. uint64_t offset = PAGE_OFFSET(rva);
  180. // Initialize the page with '0', this serves as both the padding at the start
  181. // of the page (if it's not aligned) as well as the fill for any unitilized
  182. // bytes at the end of the page, e.g. .bss data.
  183. uint8_t page_data[SE_PAGE_SIZE];
  184. memset(page_data, 0, SE_PAGE_SIZE);
  185. // The amount of raw data may be less than the number of bytes on the page,
  186. // but that portion of page_data has already been filled (see above).
  187. memcpy_s(&page_data[offset], (size_t)(SE_PAGE_SIZE - offset), source, (size_t)size);
  188. // Add the page, trimming the start address to make it page aligned.
  189. return build_pages(TRIM_TO_PAGE(rva), SE_PAGE_SIZE, page_data, sinfo, attr);
  190. }
  191. int CLoader::build_pages(const uint64_t start_rva, const uint64_t size, const void *source, const sec_info_t &sinfo, const uint32_t attr)
  192. {
  193. int ret = SGX_SUCCESS;
  194. uint64_t offset = 0;
  195. uint64_t rva = start_rva;
  196. assert(IS_PAGE_ALIGNED(start_rva) && IS_PAGE_ALIGNED(size));
  197. while(offset < size)
  198. {
  199. //call driver to add page;
  200. if(SGX_SUCCESS != (ret = get_enclave_creator()->add_enclave_page(ENCLAVE_ID_IOCTL, GET_PTR(void, source, 0), rva, sinfo, attr)))
  201. {
  202. //if add page failed , we should remove enclave somewhere;
  203. return ret;
  204. }
  205. offset += SE_PAGE_SIZE;
  206. rva += SE_PAGE_SIZE;
  207. }
  208. return SGX_SUCCESS;
  209. }
  210. int CLoader::build_context(const uint64_t start_rva, layout_entry_t *layout)
  211. {
  212. int ret = SGX_ERROR_UNEXPECTED;
  213. uint8_t added_page[SE_PAGE_SIZE];
  214. sec_info_t sinfo;
  215. memset(&sinfo, 0, sizeof(sinfo));
  216. uint64_t rva = start_rva + layout->rva;
  217. assert(IS_PAGE_ALIGNED(rva));
  218. if (layout->content_offset)
  219. {
  220. // assume TCS is only 1 page
  221. if(layout->si_flags == SI_FLAGS_TCS)
  222. {
  223. memset(added_page, 0, SE_PAGE_SIZE);
  224. memcpy_s(added_page, SE_PAGE_SIZE, GET_PTR(uint8_t, m_metadata, layout->content_offset), layout->content_size);
  225. tcs_t *ptcs = reinterpret_cast<tcs_t*>(added_page);
  226. ptcs->ossa += rva;
  227. ptcs->ofs_base += rva;
  228. ptcs->ogs_base += rva;
  229. m_tcs_list.push_back(GET_PTR(tcs_t, m_start_addr, rva));
  230. sinfo.flags = layout->si_flags;
  231. if(SGX_SUCCESS != (ret = build_pages(rva, layout->page_count << SE_PAGE_SHIFT, added_page, sinfo, layout->attributes)))
  232. {
  233. return ret;
  234. }
  235. }
  236. else // guard page should not have content_offset != 0
  237. {
  238. section_info_t sec_info = {GET_PTR(uint8_t, m_metadata, layout->content_offset), layout->content_size, rva, layout->page_count << SE_PAGE_SHIFT, layout->si_flags, NULL};
  239. if(SGX_SUCCESS != (ret = build_mem_region(sec_info)))
  240. {
  241. return ret;
  242. }
  243. }
  244. }
  245. else if (layout->si_flags != SI_FLAG_NONE)
  246. {
  247. sinfo.flags = layout->si_flags;
  248. void *source = NULL;
  249. if(layout->content_size)
  250. {
  251. for(uint32_t *p = (uint32_t *)added_page; p < GET_PTR(uint32_t, added_page, SE_PAGE_SIZE); p++)
  252. {
  253. *p = layout->content_size;
  254. }
  255. source = added_page;
  256. }
  257. if(SGX_SUCCESS != (ret = build_pages(rva, layout->page_count << SE_PAGE_SHIFT, source, sinfo, layout->attributes)))
  258. {
  259. return ret;
  260. }
  261. }
  262. return SGX_SUCCESS;
  263. }
  264. int CLoader::build_contexts(layout_t *layout_start, layout_t *layout_end, uint64_t delta)
  265. {
  266. int ret = SGX_ERROR_UNEXPECTED;
  267. for(layout_t *layout = layout_start; layout < layout_end; layout++)
  268. {
  269. if (!IS_GROUP_ID(layout->group.id))
  270. {
  271. if(SGX_SUCCESS != (ret = build_context(delta, &layout->entry)))
  272. {
  273. return ret;
  274. }
  275. }
  276. else
  277. {
  278. uint64_t step = 0;
  279. for(uint32_t j = 0; j < layout->group.load_times; j++)
  280. {
  281. step += layout->group.load_step;
  282. if(SGX_SUCCESS != (ret = build_contexts(&layout[-layout->group.entry_count], layout, step)))
  283. {
  284. return ret;
  285. }
  286. }
  287. }
  288. }
  289. return SGX_SUCCESS;
  290. }
  291. int CLoader::build_secs(sgx_attributes_t * const secs_attr, sgx_misc_attribute_t * const misc_attr)
  292. {
  293. memset(&m_secs, 0, sizeof(secs_t)); //should set resvered field of secs as 0.
  294. //create secs structure.
  295. m_secs.base = 0; //base is allocated by driver. set it as 0
  296. m_secs.size = m_metadata->enclave_size;
  297. m_secs.misc_select = misc_attr->misc_select;
  298. memcpy_s(&m_secs.attributes, sizeof(m_secs.attributes), secs_attr, sizeof(m_secs.attributes));
  299. m_secs.ssa_frame_size = m_metadata->ssa_frame_size;
  300. EnclaveCreator *enclave_creator = get_enclave_creator();
  301. if(NULL == enclave_creator)
  302. return SGX_ERROR_UNEXPECTED;
  303. int ret = enclave_creator->create_enclave(&m_secs, &m_enclave_id, &m_start_addr, is_ae(&m_metadata->enclave_css));
  304. if(SGX_SUCCESS == ret)
  305. {
  306. SE_TRACE(SE_TRACE_NOTICE, "enclave start address = %p, size = %x\n", m_start_addr, m_metadata->enclave_size);
  307. }
  308. return ret;
  309. }
  310. int CLoader::build_image(SGXLaunchToken * const lc, sgx_attributes_t * const secs_attr, le_prd_css_file_t *prd_css_file, sgx_misc_attribute_t * const misc_attr)
  311. {
  312. int ret = SGX_SUCCESS;
  313. if(SGX_SUCCESS != (ret = build_secs(secs_attr, misc_attr)))
  314. {
  315. SE_TRACE(SE_TRACE_WARNING, "build secs failed\n");
  316. return ret;
  317. };
  318. // read reloc bitmap before patch the enclave file
  319. // If load_enclave_ex try to load the enclave for the 2nd time,
  320. // the enclave image is already patched, and parser cannot read the information.
  321. // For linux, there's no map conflict. We assume load_enclave_ex will not do the retry.
  322. vector<uint8_t> bitmap;
  323. if(!m_parser.get_reloc_bitmap(bitmap))
  324. return SGX_ERROR_INVALID_ENCLAVE;
  325. // patch enclave file
  326. patch_entry_t *patch_start = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset);
  327. patch_entry_t *patch_end = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset + m_metadata->dirs[DIR_PATCH].size);
  328. for(patch_entry_t *patch = patch_start; patch < patch_end; patch++)
  329. {
  330. memcpy_s(GET_PTR(void, m_parser.get_start_addr(), patch->dst), patch->size, GET_PTR(void, m_metadata, patch->src), patch->size);
  331. }
  332. //build sections, copy export function table as well;
  333. if(SGX_SUCCESS != (ret = build_sections(&bitmap)))
  334. {
  335. SE_TRACE(SE_TRACE_WARNING, "build sections failed\n");
  336. goto fail;
  337. }
  338. // build heap/thread context
  339. if (SGX_SUCCESS != (ret = build_contexts(GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset),
  340. GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size),
  341. 0)))
  342. {
  343. SE_TRACE(SE_TRACE_WARNING, "build heap/thread context failed\n");
  344. goto fail;
  345. }
  346. //initialize Enclave
  347. ret = get_enclave_creator()->init_enclave(ENCLAVE_ID_IOCTL, const_cast<enclave_css_t *>(&m_metadata->enclave_css), lc, prd_css_file);
  348. if(SGX_SUCCESS != ret)
  349. {
  350. SE_TRACE(SE_TRACE_WARNING, "init_enclave failed\n");
  351. goto fail;
  352. }
  353. return SGX_SUCCESS;
  354. fail:
  355. get_enclave_creator()->destroy_enclave(ENCLAVE_ID_IOCTL);
  356. return ret;
  357. }
  358. bool CLoader::is_metadata_buffer(uint32_t offset, uint32_t size)
  359. {
  360. if((offsetof(metadata_t, data) > offset) || (offset >= m_metadata->size))
  361. {
  362. return false;
  363. }
  364. uint32_t end = offset + size;
  365. if ((end < offset) || (end < size) || (end > m_metadata->size))
  366. {
  367. return false;
  368. }
  369. return true;
  370. }
  371. bool CLoader::is_enclave_buffer(uint64_t offset, uint64_t size)
  372. {
  373. if(offset >= m_metadata->enclave_size)
  374. {
  375. return false;
  376. }
  377. uint64_t end = offset + size;
  378. if ((end < offset) || (end < size) || (end > m_metadata->enclave_size))
  379. {
  380. return false;
  381. }
  382. return true;
  383. }
  384. // is_relocation_page returns true if the specified RVA is a writable relocation page based on the bitmap.
  385. bool CLoader::is_relocation_page(const uint64_t rva, vector<uint8_t> *bitmap)
  386. {
  387. if(bitmap && bitmap->size())
  388. {
  389. uint64_t page_frame = rva >> SE_PAGE_SHIFT;
  390. //NOTE:
  391. // Current enclave size is not beyond 64G, so the type-casting from (uint64>>15) to (size_t) is OK.
  392. // In the future, if the max enclave size is extended to beyond (1<<49), this type-casting will not work.
  393. // It only impacts the enclave signing process. (32bit signing tool to sign 64 bit enclaves)
  394. return ((*bitmap)[(size_t)(page_frame / 8)] & (1 << (page_frame % 8)));
  395. }
  396. return false;
  397. }
  398. int CLoader::validate_layout_table()
  399. {
  400. layout_t *layout_start = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset);
  401. layout_t *layout_end = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size);
  402. vector<pair<uint64_t, uint64_t>> rva_vector;
  403. for (layout_t *layout = layout_start; layout < layout_end; layout++)
  404. {
  405. if(!IS_GROUP_ID(layout->entry.id)) // layout entry
  406. {
  407. rva_vector.push_back(make_pair(layout->entry.rva, layout->entry.page_count << SE_PAGE_SHIFT));
  408. if(layout->entry.content_offset)
  409. {
  410. if(false == is_metadata_buffer(layout->entry.content_offset, layout->entry.content_size))
  411. {
  412. return SGX_ERROR_INVALID_METADATA;
  413. }
  414. }
  415. }
  416. else // layout group
  417. {
  418. if (layout->group.entry_count > (uint32_t)(PTR_DIFF(layout, layout_start)/sizeof(layout_t)))
  419. {
  420. return SGX_ERROR_INVALID_METADATA;
  421. }
  422. uint64_t load_step = 0;
  423. for(uint32_t i = 0; i < layout->group.load_times; i++)
  424. {
  425. load_step += layout->group.load_step;
  426. if(load_step > m_metadata->enclave_size)
  427. {
  428. return SGX_ERROR_INVALID_METADATA;
  429. }
  430. for(layout_entry_t *entry = &layout[-layout->group.entry_count].entry; entry < &layout->entry; entry++)
  431. {
  432. if(IS_GROUP_ID(entry->id))
  433. {
  434. return SGX_ERROR_INVALID_METADATA;
  435. }
  436. rva_vector.push_back(make_pair(entry->rva + load_step, entry->page_count << SE_PAGE_SHIFT));
  437. // no need to check integer overflow for entry->rva + load_step, because
  438. // entry->rva and load_step are less than enclave_size, whose size is no more than 37 bit
  439. }
  440. }
  441. }
  442. }
  443. sort(rva_vector.begin(), rva_vector.end());
  444. for (vector<pair<uint64_t, uint64_t>>::iterator it = rva_vector.begin(); it != rva_vector.end(); it++)
  445. {
  446. if(!IS_PAGE_ALIGNED(it->first))
  447. {
  448. return SGX_ERROR_INVALID_METADATA;
  449. }
  450. if(false == is_enclave_buffer(it->first, it->second))
  451. {
  452. return SGX_ERROR_INVALID_METADATA;
  453. }
  454. if((it+1) != rva_vector.end())
  455. {
  456. if((it->first+it->second) > (it+1)->first)
  457. {
  458. return SGX_ERROR_INVALID_METADATA;
  459. }
  460. }
  461. }
  462. return SGX_SUCCESS;
  463. }
  464. int CLoader::validate_patch_table()
  465. {
  466. patch_entry_t *patch_start = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset);
  467. patch_entry_t *patch_end = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset + m_metadata->dirs[DIR_PATCH].size);
  468. for(patch_entry_t *patch = patch_start; patch < patch_end; patch++)
  469. {
  470. if(false == is_metadata_buffer(patch->src, patch->size))
  471. {
  472. return SGX_ERROR_INVALID_METADATA;
  473. }
  474. if(false == is_enclave_buffer(patch->dst, patch->size))
  475. {
  476. return SGX_ERROR_INVALID_METADATA;
  477. }
  478. }
  479. return SGX_SUCCESS;
  480. }
  481. int CLoader::validate_metadata()
  482. {
  483. if(!m_metadata)
  484. return SGX_ERROR_INVALID_METADATA;
  485. uint64_t version = META_DATA_MAKE_VERSION(MAJOR_VERSION,MINOR_VERSION );
  486. //if the version of metadata does NOT match the version of metadata in urts, we should NOT launch enclave.
  487. if(m_metadata->version != version)
  488. {
  489. SE_TRACE(SE_TRACE_WARNING, "Mismatch between the metadata urts required and the metadata in use.\n");
  490. return SGX_ERROR_INVALID_VERSION;
  491. }
  492. if(m_metadata->size > sizeof(metadata_t))
  493. {
  494. return SGX_ERROR_INVALID_METADATA;
  495. }
  496. if(m_metadata->tcs_policy > TCS_POLICY_UNBIND)
  497. return SGX_ERROR_INVALID_METADATA;
  498. if(m_metadata->ssa_frame_size < SSA_FRAME_SIZE_MIN || m_metadata->ssa_frame_size > SSA_FRAME_SIZE_MAX)
  499. return SGX_ERROR_INVALID_METADATA;
  500. uint64_t size = m_metadata->enclave_size;
  501. if(size > m_parser.get_enclave_max_size())
  502. {
  503. return SGX_ERROR_INVALID_METADATA;
  504. }
  505. while ((size != 0) && ((size & 1) != 1))
  506. {
  507. size = size >> 1;
  508. }
  509. if(size != 1)
  510. {
  511. return SGX_ERROR_INVALID_METADATA;
  512. }
  513. // check dirs
  514. for(uint32_t i = 0; i < DIR_NUM; i++)
  515. {
  516. if(false == is_metadata_buffer(m_metadata->dirs[i].offset, m_metadata->dirs[i].size))
  517. {
  518. return SGX_ERROR_INVALID_METADATA;
  519. }
  520. }
  521. // check layout table
  522. int status = validate_layout_table();
  523. if(SGX_SUCCESS != status)
  524. {
  525. return status;
  526. }
  527. // check patch table
  528. status = validate_patch_table();
  529. if(SGX_SUCCESS != status)
  530. {
  531. return status;
  532. }
  533. return SGX_SUCCESS;
  534. }
  535. bool CLoader::is_ae(const enclave_css_t *enclave_css)
  536. {
  537. assert(NULL != enclave_css);
  538. if(INTEL_VENDOR_ID == enclave_css->header.module_vendor
  539. && AE_PRODUCT_ID == enclave_css->body.isv_prod_id)
  540. return true;
  541. return false;
  542. }
  543. int CLoader::load_enclave(SGXLaunchToken *lc, int debug, const metadata_t *metadata, le_prd_css_file_t *prd_css_file, sgx_misc_attribute_t *misc_attr)
  544. {
  545. int ret = SGX_SUCCESS;
  546. sgx_misc_attribute_t sgx_misc_attr;
  547. memset(&sgx_misc_attr, 0, sizeof(sgx_misc_attribute_t));
  548. m_metadata = metadata;
  549. ret = validate_metadata();
  550. if(SGX_SUCCESS != ret)
  551. {
  552. SE_TRACE(SE_TRACE_ERROR, "The metadata setting is not correct\n");
  553. return ret;
  554. }
  555. ret = get_enclave_creator()->get_misc_attr(&sgx_misc_attr, const_cast<metadata_t *>(m_metadata), lc, debug);
  556. if(SGX_SUCCESS != ret)
  557. {
  558. return ret;
  559. }
  560. ret = build_image(lc, &sgx_misc_attr.secs_attr, prd_css_file, &sgx_misc_attr);
  561. //return platform capability if fail. Otherwise, return secs.attr.
  562. if(SGX_SUCCESS == ret)
  563. {
  564. if(misc_attr)
  565. {
  566. memcpy_s(misc_attr, sizeof(sgx_misc_attribute_t), &sgx_misc_attr, sizeof(sgx_misc_attribute_t));
  567. //When run here EINIT success, so SGX_FLAGS_INITTED should be set by ucode. uRTS align it with EINIT instruction.
  568. misc_attr->secs_attr.flags |= SGX_FLAGS_INITTED;
  569. }
  570. }
  571. else
  572. {
  573. if(misc_attr)
  574. {
  575. sgx_misc_attribute_t plat_cap;
  576. memset(&plat_cap, 0, sizeof(plat_cap));
  577. get_enclave_creator()->get_plat_cap(&plat_cap);
  578. memcpy_s(misc_attr, sizeof(sgx_misc_attribute_t), &plat_cap, sizeof(sgx_misc_attribute_t));
  579. }
  580. }
  581. return ret;
  582. }
  583. int CLoader::load_enclave_ex(SGXLaunchToken *lc, bool debug, const metadata_t *metadata, le_prd_css_file_t *prd_css_file, sgx_misc_attribute_t *misc_attr)
  584. {
  585. unsigned int ret = SGX_SUCCESS, map_conflict_count = 3;
  586. bool retry = true;
  587. while (retry)
  588. {
  589. ret = this->load_enclave(lc, debug, metadata, prd_css_file, misc_attr);
  590. switch(ret)
  591. {
  592. //If CreateEnclave failed due to power transition, we retry it.
  593. case SGX_ERROR_ENCLAVE_LOST: //caused by loading enclave while power transition occurs
  594. break;
  595. //If memroy map conflict occurs, we only retry 3 times.
  596. case SGX_ERROR_MEMORY_MAP_CONFLICT:
  597. if(0 == map_conflict_count)
  598. retry = false;
  599. else
  600. map_conflict_count--;
  601. break;
  602. //We don't re-load enclave due to other error code.
  603. default:
  604. retry = false;
  605. break;
  606. }
  607. }
  608. return ret;
  609. }
  610. int CLoader::destroy_enclave()
  611. {
  612. return get_enclave_creator()->destroy_enclave(ENCLAVE_ID_IOCTL);
  613. }
  614. int CLoader::set_memory_protection()
  615. {
  616. uint64_t rva = 0;
  617. uint64_t len = 0;
  618. uint64_t last_section_end = 0;
  619. unsigned int i = 0;
  620. int ret = 0;
  621. //for sections
  622. std::vector<Section*> sections = m_parser.get_sections();
  623. for(i = 0; i < sections.size() ; i++)
  624. {
  625. //require the sec_info.rva be page aligned, we need handle the first page.
  626. //the first page;
  627. uint64_t offset = (sections[i]->get_rva() & (SE_PAGE_SIZE -1));
  628. uint64_t size = SE_PAGE_SIZE - offset;
  629. //the raw data may be smaller than the size, we get the min of them
  630. if(sections[i]->raw_data_size() < size)
  631. size = sections[i]->raw_data_size();
  632. len = SE_PAGE_SIZE;
  633. //if there is more pages, then calc the next paged aligned pages
  634. if((sections[i]->virtual_size() + offset) > SE_PAGE_SIZE)
  635. {
  636. uint64_t raw_data_size = sections[i]->raw_data_size() - size;
  637. //we need use (SE_PAGE_SIZE - offset), because (SE_PAGE_SIZE - offset) may larger than size
  638. uint64_t virtual_size = sections[i]->virtual_size() - (SE_PAGE_SIZE - offset);
  639. len += ROUND_TO_PAGE(raw_data_size);
  640. if(ROUND_TO_PAGE(virtual_size) > ROUND_TO_PAGE(raw_data_size))
  641. {
  642. len += ROUND_TO_PAGE(virtual_size) - ROUND_TO_PAGE(raw_data_size);
  643. }
  644. }
  645. rva = TRIM_TO_PAGE(sections[i]->get_rva()) + (uint64_t)m_start_addr;
  646. ret = mprotect((void*)rva, (size_t)len, (int)(sections[i]->get_si_flags()&SI_MASK_MEM_ATTRIBUTE));
  647. if(ret != 0)
  648. {
  649. SE_TRACE(SE_TRACE_WARNING, "section[%d]:mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%" PRIu64 ") failed\n",
  650. i, rva, len, (sections[i]->get_si_flags()));
  651. return SGX_ERROR_UNEXPECTED;
  652. }
  653. //there is a gap between sections, need to set those to NONE access
  654. if(last_section_end != 0)
  655. {
  656. ret = mprotect((void*)last_section_end, (size_t)(rva - last_section_end), (int)(SI_FLAG_NONE & SI_MASK_MEM_ATTRIBUTE));
  657. if(ret != 0)
  658. {
  659. SE_TRACE(SE_TRACE_WARNING, "set protection for gap before section[%d]:mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%" PRIu64 ") failed\n",
  660. i, last_section_end, rva - last_section_end, SI_FLAG_NONE);
  661. return SGX_ERROR_UNEXPECTED;
  662. }
  663. }
  664. last_section_end = rva + len;
  665. }
  666. ret = set_context_protection(GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset),
  667. GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size),
  668. 0);
  669. if (SGX_SUCCESS != ret)
  670. {
  671. return ret;
  672. }
  673. return SGX_SUCCESS;
  674. }
  675. int CLoader::set_context_protection(layout_t *layout_start, layout_t *layout_end, uint64_t delta)
  676. {
  677. int ret = SGX_ERROR_UNEXPECTED;
  678. for(layout_t *layout = layout_start; layout < layout_end; layout++)
  679. {
  680. if (!IS_GROUP_ID(layout->group.id))
  681. {
  682. int prot = 0 ;
  683. if(layout->entry.attributes == SI_FLAG_NONE)
  684. {
  685. prot = SI_FLAG_NONE & SI_MASK_MEM_ATTRIBUTE;
  686. }
  687. else
  688. {
  689. prot = SI_FLAGS_RW & SI_MASK_MEM_ATTRIBUTE;
  690. }
  691. ret = mprotect(GET_PTR(void, m_start_addr, layout->entry.rva + delta),
  692. (size_t)(layout->entry.page_count << SE_PAGE_SHIFT),
  693. prot);
  694. if(ret != 0)
  695. {
  696. SE_TRACE(SE_TRACE_WARNING, "mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%d) failed\n",
  697. (uint64_t)m_start_addr + layout->entry.rva + delta,
  698. (uint64_t)(layout->entry.page_count << SE_PAGE_SHIFT),
  699. prot);
  700. return SGX_ERROR_UNEXPECTED;
  701. }
  702. }
  703. else
  704. {
  705. uint64_t step = 0;
  706. for(uint32_t j = 0; j < layout->group.load_times; j++)
  707. {
  708. step += layout->group.load_step;
  709. if(SGX_SUCCESS != (ret = set_context_protection(&layout[-layout->group.entry_count], layout, step)))
  710. {
  711. return ret;
  712. }
  713. }
  714. }
  715. }
  716. return SGX_SUCCESS;
  717. }