loader.cpp 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789
  1. /*
  2. * Copyright (C) 2011-2017 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. // is_relocation_page returns true if the specified RVA is a writable relocation page based on the bitmap.
  92. bool CLoader::is_relocation_page(const uint64_t rva, vector<uint8_t> *bitmap)
  93. {
  94. uint64_t page_frame = rva >> SE_PAGE_SHIFT;
  95. //NOTE:
  96. // Current enclave size is not beyond 128G, so the type-casting from (uint64>>15) to (size_t) is OK.
  97. // In the future, if the max enclave size is extended to beyond (1<<49), this type-casting will not work.
  98. // It only impacts the enclave signing process. (32bit signing tool to sign 64 bit enclaves)
  99. size_t index = (size_t)(page_frame / 8);
  100. if(bitmap && (index < bitmap->size()))
  101. {
  102. return ((*bitmap)[index] & (1 << (page_frame % 8)));
  103. }
  104. return false;
  105. }
  106. int CLoader::build_mem_region(const section_info_t &sec_info)
  107. {
  108. int ret = SGX_SUCCESS;
  109. uint64_t offset = 0;
  110. sec_info_t sinfo;
  111. memset(&sinfo, 0, sizeof(sinfo));
  112. // Build pages of the section that are contain initialized data. Each page
  113. // needs to be added individually as the page may hold relocation data, in
  114. // which case the page needs to be marked writable.
  115. while(offset < sec_info.raw_data_size)
  116. {
  117. uint64_t rva = sec_info.rva + offset;
  118. uint64_t size = MIN((SE_PAGE_SIZE - PAGE_OFFSET(rva)), (sec_info.raw_data_size - offset));
  119. sinfo.flags = sec_info.flag;
  120. if(is_relocation_page(rva, sec_info.bitmap))
  121. sinfo.flags = sec_info.flag | SI_FLAG_W;
  122. if (size == SE_PAGE_SIZE)
  123. ret = build_pages(rva, size, sec_info.raw_data + offset, sinfo, ADD_EXTEND_PAGE);
  124. else
  125. ret = build_partial_page(rva, size, sec_info.raw_data + offset, sinfo, ADD_EXTEND_PAGE);
  126. if(SGX_SUCCESS != ret)
  127. return ret;
  128. // only the first time that rva may be not page aligned
  129. offset += SE_PAGE_SIZE - PAGE_OFFSET(rva);
  130. }
  131. assert(IS_PAGE_ALIGNED(sec_info.rva + offset));
  132. // Add any remaining uninitialized data. We can call build_pages directly
  133. // even if there are partial pages since the source is null, i.e. everything
  134. // is filled with '0'. Uninitialied data cannot be a relocation table, ergo
  135. // there is no need to check the relocation bitmap.
  136. if(sec_info.virtual_size > offset)
  137. {
  138. uint64_t rva = sec_info.rva + offset;
  139. size_t size = (size_t)(ROUND_TO_PAGE(sec_info.virtual_size - offset));
  140. sinfo.flags = sec_info.flag;
  141. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  142. return ret;
  143. }
  144. return SGX_SUCCESS;
  145. }
  146. int CLoader::build_sections(vector<uint8_t> *bitmap)
  147. {
  148. int ret = SGX_SUCCESS;
  149. std::vector<Section*> sections = m_parser.get_sections();
  150. uint64_t max_rva =0;
  151. Section* last_section = NULL;
  152. for(unsigned int i = 0; i < sections.size() ; i++)
  153. {
  154. if((last_section != NULL) &&
  155. (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())) &&
  156. (ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size()) < (sections[i]->get_rva() & (~(SE_PAGE_SIZE - 1)))))
  157. {
  158. size_t size = SE_PAGE_SIZE;
  159. sec_info_t sinfo;
  160. memset(&sinfo, 0, sizeof(sinfo));
  161. sinfo.flags = last_section->get_si_flags();
  162. uint64_t rva = ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size());
  163. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  164. return ret;
  165. }
  166. if(sections[i]->get_rva() > max_rva)
  167. {
  168. max_rva = sections[i]->get_rva();
  169. last_section = sections[i];
  170. }
  171. 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 };
  172. if(SGX_SUCCESS != (ret = build_mem_region(sec_info)))
  173. return ret;
  174. }
  175. if((last_section != NULL) &&
  176. (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())))
  177. {
  178. size_t size = SE_PAGE_SIZE;
  179. sec_info_t sinfo;
  180. memset(&sinfo, 0, sizeof(sinfo));
  181. sinfo.flags = last_section->get_si_flags();
  182. uint64_t rva = ROUND_TO_PAGE(last_section->get_rva() + last_section->virtual_size());
  183. if(SGX_SUCCESS != (ret = build_pages(rva, size, 0, sinfo, ADD_EXTEND_PAGE)))
  184. return ret;
  185. }
  186. return SGX_SUCCESS;
  187. }
  188. 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)
  189. {
  190. // RVA may or may not be aligned.
  191. uint64_t offset = PAGE_OFFSET(rva);
  192. // Initialize the page with '0', this serves as both the padding at the start
  193. // of the page (if it's not aligned) as well as the fill for any unitilized
  194. // bytes at the end of the page, e.g. .bss data.
  195. uint8_t page_data[SE_PAGE_SIZE];
  196. memset(page_data, 0, SE_PAGE_SIZE);
  197. // The amount of raw data may be less than the number of bytes on the page,
  198. // but that portion of page_data has already been filled (see above).
  199. memcpy_s(&page_data[offset], (size_t)(SE_PAGE_SIZE - offset), source, (size_t)size);
  200. // Add the page, trimming the start address to make it page aligned.
  201. return build_pages(TRIM_TO_PAGE(rva), SE_PAGE_SIZE, page_data, sinfo, attr);
  202. }
  203. 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)
  204. {
  205. int ret = SGX_SUCCESS;
  206. uint64_t offset = 0;
  207. uint64_t rva = start_rva;
  208. assert(IS_PAGE_ALIGNED(start_rva) && IS_PAGE_ALIGNED(size));
  209. while(offset < size)
  210. {
  211. //call driver to add page;
  212. if(SGX_SUCCESS != (ret = get_enclave_creator()->add_enclave_page(ENCLAVE_ID_IOCTL, GET_PTR(void, source, 0), rva, sinfo, attr)))
  213. {
  214. //if add page failed , we should remove enclave somewhere;
  215. return ret;
  216. }
  217. offset += SE_PAGE_SIZE;
  218. rva += SE_PAGE_SIZE;
  219. }
  220. return SGX_SUCCESS;
  221. }
  222. int CLoader::build_context(const uint64_t start_rva, layout_entry_t *layout)
  223. {
  224. int ret = SGX_ERROR_UNEXPECTED;
  225. uint8_t added_page[SE_PAGE_SIZE];
  226. sec_info_t sinfo;
  227. memset(&sinfo, 0, sizeof(sinfo));
  228. uint64_t rva = start_rva + layout->rva;
  229. assert(IS_PAGE_ALIGNED(rva));
  230. if (layout->content_offset)
  231. {
  232. // assume TCS is only 1 page
  233. if(layout->si_flags == SI_FLAGS_TCS)
  234. {
  235. memset(added_page, 0, SE_PAGE_SIZE);
  236. memcpy_s(added_page, SE_PAGE_SIZE, GET_PTR(uint8_t, m_metadata, layout->content_offset), layout->content_size);
  237. tcs_t *ptcs = reinterpret_cast<tcs_t*>(added_page);
  238. ptcs->ossa += rva;
  239. ptcs->ofs_base += rva;
  240. ptcs->ogs_base += rva;
  241. m_tcs_list.push_back(GET_PTR(tcs_t, m_start_addr, rva));
  242. sinfo.flags = layout->si_flags;
  243. if(SGX_SUCCESS != (ret = build_pages(rva, (uint64_t)layout->page_count << SE_PAGE_SHIFT, added_page, sinfo, layout->attributes)))
  244. {
  245. return ret;
  246. }
  247. }
  248. else // guard page should not have content_offset != 0
  249. {
  250. section_info_t sec_info = {GET_PTR(uint8_t, m_metadata, layout->content_offset), layout->content_size, rva, (uint64_t)layout->page_count << SE_PAGE_SHIFT, layout->si_flags, NULL};
  251. if(SGX_SUCCESS != (ret = build_mem_region(sec_info)))
  252. {
  253. return ret;
  254. }
  255. }
  256. }
  257. else if (layout->si_flags != SI_FLAG_NONE)
  258. {
  259. sinfo.flags = layout->si_flags;
  260. void *source = NULL;
  261. if(layout->content_size)
  262. {
  263. for(uint32_t *p = (uint32_t *)added_page; p < GET_PTR(uint32_t, added_page, SE_PAGE_SIZE); p++)
  264. {
  265. *p = layout->content_size;
  266. }
  267. source = added_page;
  268. }
  269. if(SGX_SUCCESS != (ret = build_pages(rva, (uint64_t)layout->page_count << SE_PAGE_SHIFT, source, sinfo, layout->attributes)))
  270. {
  271. return ret;
  272. }
  273. }
  274. return SGX_SUCCESS;
  275. }
  276. int CLoader::build_contexts(layout_t *layout_start, layout_t *layout_end, uint64_t delta)
  277. {
  278. int ret = SGX_ERROR_UNEXPECTED;
  279. for(layout_t *layout = layout_start; layout < layout_end; layout++)
  280. {
  281. if (!IS_GROUP_ID(layout->group.id))
  282. {
  283. if(SGX_SUCCESS != (ret = build_context(delta, &layout->entry)))
  284. {
  285. return ret;
  286. }
  287. }
  288. else
  289. {
  290. uint64_t step = 0;
  291. for(uint32_t j = 0; j < layout->group.load_times; j++)
  292. {
  293. step += layout->group.load_step;
  294. if(SGX_SUCCESS != (ret = build_contexts(&layout[-layout->group.entry_count], layout, step)))
  295. {
  296. return ret;
  297. }
  298. }
  299. }
  300. }
  301. return SGX_SUCCESS;
  302. }
  303. int CLoader::build_secs(sgx_attributes_t * const secs_attr, sgx_misc_attribute_t * const misc_attr)
  304. {
  305. memset(&m_secs, 0, sizeof(secs_t)); //should set resvered field of secs as 0.
  306. //create secs structure.
  307. m_secs.base = 0; //base is allocated by driver. set it as 0
  308. m_secs.size = m_metadata->enclave_size;
  309. m_secs.misc_select = misc_attr->misc_select;
  310. memcpy_s(&m_secs.attributes, sizeof(m_secs.attributes), secs_attr, sizeof(m_secs.attributes));
  311. m_secs.ssa_frame_size = m_metadata->ssa_frame_size;
  312. EnclaveCreator *enclave_creator = get_enclave_creator();
  313. if(NULL == enclave_creator)
  314. return SGX_ERROR_UNEXPECTED;
  315. int ret = enclave_creator->create_enclave(&m_secs, &m_enclave_id, &m_start_addr, is_ae(&m_metadata->enclave_css));
  316. if(SGX_SUCCESS == ret)
  317. {
  318. SE_TRACE(SE_TRACE_NOTICE, "enclave start address = %p, size = %x\n", m_start_addr, m_metadata->enclave_size);
  319. }
  320. return ret;
  321. }
  322. 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)
  323. {
  324. int ret = SGX_SUCCESS;
  325. if(SGX_SUCCESS != (ret = build_secs(secs_attr, misc_attr)))
  326. {
  327. SE_TRACE(SE_TRACE_WARNING, "build secs failed\n");
  328. return ret;
  329. };
  330. // read reloc bitmap before patch the enclave file
  331. // If load_enclave_ex try to load the enclave for the 2nd time,
  332. // the enclave image is already patched, and parser cannot read the information.
  333. // For linux, there's no map conflict. We assume load_enclave_ex will not do the retry.
  334. vector<uint8_t> bitmap;
  335. if(!m_parser.get_reloc_bitmap(bitmap))
  336. return SGX_ERROR_INVALID_ENCLAVE;
  337. // patch enclave file
  338. patch_entry_t *patch_start = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset);
  339. patch_entry_t *patch_end = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset + m_metadata->dirs[DIR_PATCH].size);
  340. for(patch_entry_t *patch = patch_start; patch < patch_end; patch++)
  341. {
  342. memcpy_s(GET_PTR(void, m_parser.get_start_addr(), patch->dst), patch->size, GET_PTR(void, m_metadata, patch->src), patch->size);
  343. }
  344. //build sections, copy export function table as well;
  345. if(SGX_SUCCESS != (ret = build_sections(&bitmap)))
  346. {
  347. SE_TRACE(SE_TRACE_WARNING, "build sections failed\n");
  348. goto fail;
  349. }
  350. // build heap/thread context
  351. if (SGX_SUCCESS != (ret = build_contexts(GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset),
  352. GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size),
  353. 0)))
  354. {
  355. SE_TRACE(SE_TRACE_WARNING, "build heap/thread context failed\n");
  356. goto fail;
  357. }
  358. //initialize Enclave
  359. ret = get_enclave_creator()->init_enclave(ENCLAVE_ID_IOCTL, const_cast<enclave_css_t *>(&m_metadata->enclave_css), lc, prd_css_file);
  360. if(SGX_SUCCESS != ret)
  361. {
  362. SE_TRACE(SE_TRACE_WARNING, "init_enclave failed\n");
  363. goto fail;
  364. }
  365. return SGX_SUCCESS;
  366. fail:
  367. get_enclave_creator()->destroy_enclave(ENCLAVE_ID_IOCTL, m_secs.size);
  368. return ret;
  369. }
  370. bool CLoader::is_metadata_buffer(uint32_t offset, uint32_t size)
  371. {
  372. if((offsetof(metadata_t, data) > offset) || (offset >= m_metadata->size))
  373. {
  374. return false;
  375. }
  376. uint32_t end = offset + size;
  377. if ((end < offset) || (end < size) || (end > m_metadata->size))
  378. {
  379. return false;
  380. }
  381. return true;
  382. }
  383. bool CLoader::is_enclave_buffer(uint64_t offset, uint64_t size)
  384. {
  385. if(offset >= m_metadata->enclave_size)
  386. {
  387. return false;
  388. }
  389. uint64_t end = offset + size;
  390. if ((end < offset) || (end < size) || (end > m_metadata->enclave_size))
  391. {
  392. return false;
  393. }
  394. return true;
  395. }
  396. int CLoader::validate_layout_table()
  397. {
  398. layout_t *layout_start = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset);
  399. layout_t *layout_end = GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size);
  400. vector<pair<uint64_t, uint64_t>> rva_vector;
  401. for (layout_t *layout = layout_start; layout < layout_end; layout++)
  402. {
  403. if(!IS_GROUP_ID(layout->entry.id)) // layout entry
  404. {
  405. rva_vector.push_back(make_pair(layout->entry.rva, (uint64_t)layout->entry.page_count << SE_PAGE_SHIFT));
  406. if(layout->entry.content_offset)
  407. {
  408. if(false == is_metadata_buffer(layout->entry.content_offset, layout->entry.content_size))
  409. {
  410. return SGX_ERROR_INVALID_METADATA;
  411. }
  412. }
  413. }
  414. else // layout group
  415. {
  416. if (layout->group.entry_count > (uint32_t)(PTR_DIFF(layout, layout_start)/sizeof(layout_t)))
  417. {
  418. return SGX_ERROR_INVALID_METADATA;
  419. }
  420. uint64_t load_step = 0;
  421. for(uint32_t i = 0; i < layout->group.load_times; i++)
  422. {
  423. load_step += layout->group.load_step;
  424. if(load_step > m_metadata->enclave_size)
  425. {
  426. return SGX_ERROR_INVALID_METADATA;
  427. }
  428. for(layout_entry_t *entry = &layout[-layout->group.entry_count].entry; entry < &layout->entry; entry++)
  429. {
  430. if(IS_GROUP_ID(entry->id))
  431. {
  432. return SGX_ERROR_INVALID_METADATA;
  433. }
  434. rva_vector.push_back(make_pair(entry->rva + load_step, (uint64_t)entry->page_count << SE_PAGE_SHIFT));
  435. // no need to check integer overflow for entry->rva + load_step, because
  436. // entry->rva and load_step are less than enclave_size, whose size is no more than 37 bit
  437. }
  438. }
  439. }
  440. }
  441. sort(rva_vector.begin(), rva_vector.end());
  442. for (vector<pair<uint64_t, uint64_t>>::iterator it = rva_vector.begin(); it != rva_vector.end(); it++)
  443. {
  444. if(!IS_PAGE_ALIGNED(it->first))
  445. {
  446. return SGX_ERROR_INVALID_METADATA;
  447. }
  448. if(false == is_enclave_buffer(it->first, it->second))
  449. {
  450. return SGX_ERROR_INVALID_METADATA;
  451. }
  452. if((it+1) != rva_vector.end())
  453. {
  454. if((it->first+it->second) > (it+1)->first)
  455. {
  456. return SGX_ERROR_INVALID_METADATA;
  457. }
  458. }
  459. }
  460. return SGX_SUCCESS;
  461. }
  462. int CLoader::validate_patch_table()
  463. {
  464. patch_entry_t *patch_start = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset);
  465. patch_entry_t *patch_end = GET_PTR(patch_entry_t, m_metadata, m_metadata->dirs[DIR_PATCH].offset + m_metadata->dirs[DIR_PATCH].size);
  466. for(patch_entry_t *patch = patch_start; patch < patch_end; patch++)
  467. {
  468. if(false == is_metadata_buffer(patch->src, patch->size))
  469. {
  470. return SGX_ERROR_INVALID_METADATA;
  471. }
  472. if(false == is_enclave_buffer(patch->dst, patch->size))
  473. {
  474. return SGX_ERROR_INVALID_METADATA;
  475. }
  476. }
  477. return SGX_SUCCESS;
  478. }
  479. int CLoader::validate_metadata()
  480. {
  481. if(!m_metadata)
  482. return SGX_ERROR_INVALID_METADATA;
  483. uint64_t version = META_DATA_MAKE_VERSION(MAJOR_VERSION,MINOR_VERSION );
  484. //if the version of metadata does NOT match the version of metadata in urts, we should NOT launch enclave.
  485. if(m_metadata->version != version)
  486. {
  487. SE_TRACE(SE_TRACE_WARNING, "Mismatch between the metadata urts required and the metadata in use.\n");
  488. return SGX_ERROR_INVALID_VERSION;
  489. }
  490. if(m_metadata->size > sizeof(metadata_t))
  491. {
  492. return SGX_ERROR_INVALID_METADATA;
  493. }
  494. if(m_metadata->tcs_policy > TCS_POLICY_UNBIND)
  495. return SGX_ERROR_INVALID_METADATA;
  496. if(m_metadata->ssa_frame_size < SSA_FRAME_SIZE_MIN || m_metadata->ssa_frame_size > SSA_FRAME_SIZE_MAX)
  497. return SGX_ERROR_INVALID_METADATA;
  498. uint64_t size = m_metadata->enclave_size;
  499. if(size > m_parser.get_enclave_max_size())
  500. {
  501. return SGX_ERROR_INVALID_METADATA;
  502. }
  503. while ((size != 0) && ((size & 1) != 1))
  504. {
  505. size = size >> 1;
  506. }
  507. if(size != 1)
  508. {
  509. return SGX_ERROR_INVALID_METADATA;
  510. }
  511. // check dirs
  512. for(uint32_t i = 0; i < DIR_NUM; i++)
  513. {
  514. if(false == is_metadata_buffer(m_metadata->dirs[i].offset, m_metadata->dirs[i].size))
  515. {
  516. return SGX_ERROR_INVALID_METADATA;
  517. }
  518. }
  519. // check layout table
  520. int status = validate_layout_table();
  521. if(SGX_SUCCESS != status)
  522. {
  523. return status;
  524. }
  525. // check patch table
  526. status = validate_patch_table();
  527. if(SGX_SUCCESS != status)
  528. {
  529. return status;
  530. }
  531. return SGX_SUCCESS;
  532. }
  533. bool CLoader::is_ae(const enclave_css_t *enclave_css)
  534. {
  535. assert(NULL != enclave_css);
  536. if(INTEL_VENDOR_ID == enclave_css->header.module_vendor
  537. && AE_PRODUCT_ID == enclave_css->body.isv_prod_id)
  538. return true;
  539. return false;
  540. }
  541. 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)
  542. {
  543. int ret = SGX_SUCCESS;
  544. sgx_misc_attribute_t sgx_misc_attr;
  545. memset(&sgx_misc_attr, 0, sizeof(sgx_misc_attribute_t));
  546. m_metadata = metadata;
  547. ret = validate_metadata();
  548. if(SGX_SUCCESS != ret)
  549. {
  550. SE_TRACE(SE_TRACE_ERROR, "The metadata setting is not correct\n");
  551. return ret;
  552. }
  553. ret = get_enclave_creator()->get_misc_attr(&sgx_misc_attr, const_cast<metadata_t *>(m_metadata), lc, debug);
  554. if(SGX_SUCCESS != ret)
  555. {
  556. return ret;
  557. }
  558. ret = build_image(lc, &sgx_misc_attr.secs_attr, prd_css_file, &sgx_misc_attr);
  559. // Update misc_attr with secs.attr upon success.
  560. if(SGX_SUCCESS == ret)
  561. {
  562. if(misc_attr)
  563. {
  564. memcpy_s(misc_attr, sizeof(sgx_misc_attribute_t), &sgx_misc_attr, sizeof(sgx_misc_attribute_t));
  565. //When run here EINIT success, so SGX_FLAGS_INITTED should be set by ucode. uRTS align it with EINIT instruction.
  566. misc_attr->secs_attr.flags |= SGX_FLAGS_INITTED;
  567. }
  568. }
  569. return ret;
  570. }
  571. 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)
  572. {
  573. unsigned int ret = SGX_SUCCESS, map_conflict_count = 3;
  574. bool retry = true;
  575. while (retry)
  576. {
  577. ret = this->load_enclave(lc, debug, metadata, prd_css_file, misc_attr);
  578. switch(ret)
  579. {
  580. //If CreateEnclave failed due to power transition, we retry it.
  581. case SGX_ERROR_ENCLAVE_LOST: //caused by loading enclave while power transition occurs
  582. break;
  583. //If memroy map conflict occurs, we only retry 3 times.
  584. case SGX_ERROR_MEMORY_MAP_CONFLICT:
  585. if(0 == map_conflict_count)
  586. retry = false;
  587. else
  588. map_conflict_count--;
  589. break;
  590. //We don't re-load enclave due to other error code.
  591. default:
  592. retry = false;
  593. break;
  594. }
  595. }
  596. return ret;
  597. }
  598. int CLoader::destroy_enclave()
  599. {
  600. return get_enclave_creator()->destroy_enclave(ENCLAVE_ID_IOCTL, m_secs.size);
  601. }
  602. int CLoader::set_memory_protection()
  603. {
  604. uint64_t rva = 0;
  605. uint64_t len = 0;
  606. uint64_t last_section_end = 0;
  607. unsigned int i = 0;
  608. int ret = 0;
  609. //for sections
  610. std::vector<Section*> sections = m_parser.get_sections();
  611. for(i = 0; i < sections.size() ; i++)
  612. {
  613. //require the sec_info.rva be page aligned, we need handle the first page.
  614. //the first page;
  615. uint64_t offset = (sections[i]->get_rva() & (SE_PAGE_SIZE -1));
  616. uint64_t size = SE_PAGE_SIZE - offset;
  617. //the raw data may be smaller than the size, we get the min of them
  618. if(sections[i]->raw_data_size() < size)
  619. size = sections[i]->raw_data_size();
  620. len = SE_PAGE_SIZE;
  621. //if there is more pages, then calc the next paged aligned pages
  622. if((sections[i]->virtual_size() + offset) > SE_PAGE_SIZE)
  623. {
  624. uint64_t raw_data_size = sections[i]->raw_data_size() - size;
  625. //we need use (SE_PAGE_SIZE - offset), because (SE_PAGE_SIZE - offset) may larger than size
  626. uint64_t virtual_size = sections[i]->virtual_size() - (SE_PAGE_SIZE - offset);
  627. len += ROUND_TO_PAGE(raw_data_size);
  628. if(ROUND_TO_PAGE(virtual_size) > ROUND_TO_PAGE(raw_data_size))
  629. {
  630. len += ROUND_TO_PAGE(virtual_size) - ROUND_TO_PAGE(raw_data_size);
  631. }
  632. }
  633. rva = TRIM_TO_PAGE(sections[i]->get_rva()) + (uint64_t)m_start_addr;
  634. ret = mprotect((void*)rva, (size_t)len, (int)(sections[i]->get_si_flags()&SI_MASK_MEM_ATTRIBUTE));
  635. if(ret != 0)
  636. {
  637. SE_TRACE(SE_TRACE_WARNING, "section[%d]:mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%" PRIu64 ") failed\n",
  638. i, rva, len, (sections[i]->get_si_flags()));
  639. return SGX_ERROR_UNEXPECTED;
  640. }
  641. //there is a gap between sections, need to set those to NONE access
  642. if(last_section_end != 0)
  643. {
  644. ret = mprotect((void*)last_section_end, (size_t)(rva - last_section_end), (int)(SI_FLAG_NONE & SI_MASK_MEM_ATTRIBUTE));
  645. if(ret != 0)
  646. {
  647. SE_TRACE(SE_TRACE_WARNING, "set protection for gap before section[%d]:mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%" PRIu64 ") failed\n",
  648. i, last_section_end, rva - last_section_end, SI_FLAG_NONE);
  649. return SGX_ERROR_UNEXPECTED;
  650. }
  651. }
  652. last_section_end = rva + len;
  653. }
  654. ret = set_context_protection(GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset),
  655. GET_PTR(layout_t, m_metadata, m_metadata->dirs[DIR_LAYOUT].offset + m_metadata->dirs[DIR_LAYOUT].size),
  656. 0);
  657. if (SGX_SUCCESS != ret)
  658. {
  659. return ret;
  660. }
  661. return SGX_SUCCESS;
  662. }
  663. int CLoader::set_context_protection(layout_t *layout_start, layout_t *layout_end, uint64_t delta)
  664. {
  665. int ret = SGX_ERROR_UNEXPECTED;
  666. for(layout_t *layout = layout_start; layout < layout_end; layout++)
  667. {
  668. if (!IS_GROUP_ID(layout->group.id))
  669. {
  670. int prot = 0 ;
  671. if(layout->entry.si_flags == SI_FLAG_NONE)
  672. {
  673. prot = SI_FLAG_NONE & SI_MASK_MEM_ATTRIBUTE;
  674. }
  675. else
  676. {
  677. prot = SI_FLAGS_RW & SI_MASK_MEM_ATTRIBUTE;
  678. }
  679. ret = mprotect(GET_PTR(void, m_start_addr, layout->entry.rva + delta),
  680. (size_t)layout->entry.page_count << SE_PAGE_SHIFT,
  681. prot);
  682. if(ret != 0)
  683. {
  684. SE_TRACE(SE_TRACE_WARNING, "mprotect(rva=%" PRIu64 ", len=%" PRIu64 ", flags=%d) failed\n",
  685. (uint64_t)m_start_addr + layout->entry.rva + delta,
  686. (uint64_t)layout->entry.page_count << SE_PAGE_SHIFT,
  687. prot);
  688. return SGX_ERROR_UNEXPECTED;
  689. }
  690. }
  691. else
  692. {
  693. uint64_t step = 0;
  694. for(uint32_t j = 0; j < layout->group.load_times; j++)
  695. {
  696. step += layout->group.load_step;
  697. if(SGX_SUCCESS != (ret = set_context_protection(&layout[-layout->group.entry_count], layout, step)))
  698. {
  699. return ret;
  700. }
  701. }
  702. }
  703. }
  704. return SGX_SUCCESS;
  705. }