trts_ecall.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480
  1. /*
  2. * Copyright (C) 2011-2018 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_memcpy.h"
  32. #include "thread_data.h"
  33. #include "global_data.h"
  34. #include "rts.h"
  35. #include "util.h"
  36. #include "xsave.h"
  37. #include "sgx_trts.h"
  38. #include "sgx_lfence.h"
  39. #include "sgx_spinlock.h"
  40. #include "global_init.h"
  41. #include "trts_internal.h"
  42. #include "trts_inst.h"
  43. #include "trts_emodpr.h"
  44. #include "metadata.h"
  45. # include "linux/elf_parser.h"
  46. # define GET_TLS_INFO elf_tls_info
  47. // is_ecall_allowed()
  48. // check the index in the dynamic entry table
  49. static sgx_status_t is_ecall_allowed(uint32_t ordinal)
  50. {
  51. if(ordinal >= g_ecall_table.nr_ecall)
  52. {
  53. return SGX_ERROR_INVALID_FUNCTION;
  54. }
  55. thread_data_t *thread_data = get_thread_data();
  56. sgx_lfence();
  57. if(thread_data->last_sp == thread_data->stack_base_addr)
  58. {
  59. // root ECALL, check the priv bits.
  60. if (g_ecall_table.ecall_table[ordinal].is_priv)
  61. return SGX_ERROR_ECALL_NOT_ALLOWED;
  62. return SGX_SUCCESS;
  63. }
  64. ocall_context_t *context = reinterpret_cast<ocall_context_t*>(thread_data->last_sp);
  65. if(context->ocall_flag != OCALL_FLAG)
  66. {
  67. // abort the enclave if ocall frame is invalid
  68. abort();
  69. }
  70. uintptr_t ocall_index = context->ocall_index;
  71. if(ocall_index >= g_dyn_entry_table.nr_ocall)
  72. {
  73. return SGX_ERROR_INVALID_FUNCTION;
  74. }
  75. return (g_dyn_entry_table.entry_table[ocall_index * g_ecall_table.nr_ecall + ordinal] ? SGX_SUCCESS : SGX_ERROR_ECALL_NOT_ALLOWED);
  76. }
  77. // get_func_addr()
  78. // Get the address of ecall function from the ecall table
  79. // Parameters:
  80. // [IN] ordinal - the index of the ecall function in the ecall table
  81. // Return Value:
  82. // non-zero - success
  83. // zero - fail
  84. //
  85. static sgx_status_t get_func_addr(uint32_t ordinal, void **addr)
  86. {
  87. sgx_status_t status = is_ecall_allowed(ordinal);
  88. if(SGX_SUCCESS != status)
  89. {
  90. return status;
  91. }
  92. *addr = const_cast<void *>(g_ecall_table.ecall_table[ordinal].ecall_addr);
  93. if(!sgx_is_within_enclave(*addr, 0))
  94. {
  95. return SGX_ERROR_UNEXPECTED;
  96. }
  97. return SGX_SUCCESS;
  98. }
  99. static bool is_utility_thread()
  100. {
  101. thread_data_t *thread_data = get_thread_data();
  102. if ((thread_data != NULL) && (thread_data->flags & SGX_UTILITY_THREAD))
  103. {
  104. return true;
  105. }
  106. return false;
  107. }
  108. typedef struct _tcs_node_t
  109. {
  110. uintptr_t tcs;
  111. struct _tcs_node_t *next;
  112. } tcs_node_t;
  113. static tcs_node_t *g_tcs_node = NULL;
  114. static uintptr_t g_tcs_cookie = 0;
  115. #define ENC_TCS_POINTER(x) (uintptr_t)(x) ^ g_tcs_cookie
  116. #define DEC_TCS_POINTER(x) (void *)((x) ^ g_tcs_cookie)
  117. // do_save_tcs()
  118. // Save tcs while function do_ecall_add_thread invoked.
  119. // Parameters:
  120. // [IN] ptcs - the tcs_t pointer which need to be saved
  121. // Return Value:
  122. // zero - success
  123. // non-zero - fail
  124. //
  125. static sgx_status_t do_save_tcs(void *ptcs)
  126. {
  127. if(!is_utility_thread())
  128. return SGX_ERROR_UNEXPECTED;
  129. if(unlikely(g_tcs_cookie == 0))
  130. {
  131. uintptr_t rand = 0;
  132. do
  133. {
  134. if(SGX_SUCCESS != sgx_read_rand((unsigned char *)&rand, sizeof(rand)))
  135. {
  136. return SGX_ERROR_UNEXPECTED;
  137. }
  138. } while(rand == 0);
  139. if(g_tcs_cookie == 0)
  140. {
  141. g_tcs_cookie = rand;
  142. }
  143. }
  144. tcs_node_t *tcs_node = (tcs_node_t *)malloc(sizeof(tcs_node_t));
  145. if(!tcs_node)
  146. {
  147. return SGX_ERROR_UNEXPECTED;
  148. }
  149. tcs_node->tcs = ENC_TCS_POINTER(ptcs);
  150. tcs_node->next = g_tcs_node;
  151. g_tcs_node = tcs_node;
  152. return SGX_SUCCESS;
  153. }
  154. // do_del_tcs()
  155. // Delete tcs from the global tcs list.
  156. // Parameters:
  157. // [IN] ptcs - the tcs_t pointer which need to be deleted
  158. // Return Value:
  159. // N/A
  160. //
  161. static void do_del_tcs(void *ptcs)
  162. {
  163. if(!is_utility_thread())
  164. return;
  165. if (g_tcs_node != NULL)
  166. {
  167. if (DEC_TCS_POINTER(g_tcs_node->tcs) == ptcs)
  168. {
  169. tcs_node_t *tmp = g_tcs_node;
  170. g_tcs_node = g_tcs_node->next;
  171. free(tmp);
  172. }
  173. else
  174. {
  175. tcs_node_t *tcs_node = g_tcs_node->next;
  176. tcs_node_t *pre_tcs_node = g_tcs_node;
  177. while (tcs_node != NULL)
  178. {
  179. if (DEC_TCS_POINTER(tcs_node->tcs) == ptcs)
  180. {
  181. pre_tcs_node->next = tcs_node->next;
  182. free(tcs_node);
  183. break;
  184. }
  185. pre_tcs_node = tcs_node;
  186. tcs_node = tcs_node->next;
  187. }
  188. }
  189. }
  190. }
  191. static volatile bool g_is_first_ecall = true;
  192. static volatile sgx_spinlock_t g_ife_lock = SGX_SPINLOCK_INITIALIZER;
  193. typedef sgx_status_t (*ecall_func_t)(void *ms);
  194. static sgx_status_t trts_ecall(uint32_t ordinal, void *ms)
  195. {
  196. sgx_status_t status = SGX_ERROR_UNEXPECTED;
  197. if (unlikely(g_is_first_ecall))
  198. {
  199. // The thread performing the global initialization cannot do a nested ECall
  200. thread_data_t *thread_data = get_thread_data();
  201. if (thread_data->last_sp != thread_data->stack_base_addr)
  202. { // nested ecall
  203. return SGX_ERROR_ECALL_NOT_ALLOWED;
  204. }
  205. sgx_spin_lock(&g_ife_lock);
  206. if (g_is_first_ecall)
  207. {
  208. #ifndef SE_SIM
  209. if(EDMM_supported)
  210. {
  211. //change back the page permission
  212. size_t enclave_start = (size_t)&__ImageBase;
  213. if((status = change_protection((void *)enclave_start)) != SGX_SUCCESS)
  214. {
  215. sgx_spin_unlock(&g_ife_lock);
  216. return status;
  217. }
  218. }
  219. #endif
  220. //invoke global object's construction
  221. init_global_object();
  222. g_is_first_ecall = false;
  223. }
  224. sgx_spin_unlock(&g_ife_lock);
  225. }
  226. void *addr = NULL;
  227. status = get_func_addr(ordinal, &addr);
  228. if(status == SGX_SUCCESS)
  229. {
  230. ecall_func_t func = (ecall_func_t)addr;
  231. sgx_lfence();
  232. status = func(ms);
  233. }
  234. return status;
  235. }
  236. extern "C" uintptr_t __stack_chk_guard;
  237. static void init_static_stack_canary(void *tcs)
  238. {
  239. size_t *canary = TCS2CANARY(tcs);
  240. *canary = (size_t)__stack_chk_guard;
  241. }
  242. sgx_status_t do_init_thread(void *tcs, bool enclave_init)
  243. {
  244. thread_data_t *thread_data = GET_PTR(thread_data_t, tcs, g_global_data.td_template.self_addr);
  245. #ifndef SE_SIM
  246. size_t saved_stack_commit_addr = thread_data->stack_commit_addr;
  247. bool thread_first_init = (saved_stack_commit_addr == 0) ? true : false;
  248. #endif
  249. size_t stack_guard = thread_data->stack_guard;
  250. size_t thread_flags = thread_data->flags;
  251. memcpy_s(thread_data, SE_PAGE_SIZE, const_cast<thread_data_t *>(&g_global_data.td_template), sizeof(thread_data_t));
  252. thread_data->last_sp += (size_t)tcs;
  253. thread_data->self_addr += (size_t)tcs;
  254. thread_data->stack_base_addr += (size_t)tcs;
  255. thread_data->stack_limit_addr += (size_t)tcs;
  256. thread_data->stack_commit_addr = thread_data->stack_limit_addr;
  257. thread_data->first_ssa_gpr += (size_t)tcs;
  258. thread_data->tls_array += (size_t)tcs;
  259. thread_data->tls_addr += (size_t)tcs;
  260. thread_data->last_sp -= (size_t)STATIC_STACK_SIZE;
  261. thread_data->stack_base_addr -= (size_t)STATIC_STACK_SIZE;
  262. thread_data->stack_guard = stack_guard;
  263. thread_data->flags = thread_flags;
  264. init_static_stack_canary(tcs);
  265. if (enclave_init)
  266. {
  267. thread_data->flags = SGX_UTILITY_THREAD;
  268. }
  269. #ifndef SE_SIM
  270. if (thread_first_init)
  271. {
  272. if (EDMM_supported && (enclave_init || is_dynamic_thread(tcs)))
  273. {
  274. uint32_t page_count = get_dynamic_stack_max_page();
  275. thread_data->stack_commit_addr += ((sys_word_t)page_count << SE_PAGE_SHIFT);
  276. }
  277. }
  278. else
  279. {
  280. thread_data->stack_commit_addr = saved_stack_commit_addr;
  281. }
  282. #endif
  283. uintptr_t tls_addr = 0;
  284. size_t tdata_size = 0;
  285. if(0 != GET_TLS_INFO(&__ImageBase, &tls_addr, &tdata_size))
  286. {
  287. return SGX_ERROR_UNEXPECTED;
  288. }
  289. if(tls_addr)
  290. {
  291. memset((void *)TRIM_TO_PAGE(thread_data->tls_addr), 0, ROUND_TO_PAGE(thread_data->self_addr - thread_data->tls_addr));
  292. memcpy_s((void *)(thread_data->tls_addr), thread_data->self_addr - thread_data->tls_addr, (void *)tls_addr, tdata_size);
  293. }
  294. return SGX_SUCCESS;
  295. }
  296. sgx_status_t do_ecall(int index, void *ms, void *tcs)
  297. {
  298. sgx_status_t status = SGX_ERROR_UNEXPECTED;
  299. if(ENCLAVE_INIT_DONE != get_enclave_state())
  300. {
  301. return status;
  302. }
  303. thread_data_t *thread_data = get_thread_data();
  304. if( (NULL == thread_data) || ((thread_data->stack_base_addr == thread_data->last_sp) && (0 != g_global_data.thread_policy)))
  305. {
  306. status = do_init_thread(tcs, false);
  307. if(0 != status)
  308. {
  309. return status;
  310. }
  311. }
  312. status = trts_ecall(index, ms);
  313. return status;
  314. }
  315. sgx_status_t do_ecall_add_thread(void *ms)
  316. {
  317. sgx_status_t status = SGX_ERROR_UNEXPECTED;
  318. if(!is_utility_thread())
  319. return status;
  320. struct ms_tcs *tcs = (struct ms_tcs*)ms;
  321. if (tcs == NULL)
  322. {
  323. return status;
  324. }
  325. if (!sgx_is_outside_enclave(tcs, sizeof(struct ms_tcs)))
  326. {
  327. abort();
  328. }
  329. const struct ms_tcs mtcs = *tcs;
  330. void* ptcs = mtcs.ptcs;
  331. if (ptcs == NULL)
  332. {
  333. return status;
  334. }
  335. __builtin_ia32_lfence();
  336. status = do_save_tcs(ptcs);
  337. if(SGX_SUCCESS != status)
  338. {
  339. return status;
  340. }
  341. status = do_add_thread(ptcs);
  342. if (SGX_SUCCESS != status)
  343. {
  344. do_del_tcs(ptcs);
  345. return status;
  346. }
  347. return status;
  348. }
  349. // do_uninit_enclave()
  350. // Run the global uninitialized functions when the enclave is destroyed.
  351. // Parameters:
  352. // [IN] tcs - used for running this task
  353. // Return Value:
  354. // zero - success
  355. // non-zero - fail
  356. //
  357. sgx_status_t do_uninit_enclave(void *tcs)
  358. {
  359. #ifndef SE_SIM
  360. if(is_dynamic_thread_exist() && !is_utility_thread())
  361. return SGX_ERROR_UNEXPECTED;
  362. #endif
  363. tcs_node_t *tcs_node = g_tcs_node;
  364. g_tcs_node = NULL;
  365. while (tcs_node != NULL)
  366. {
  367. if (DEC_TCS_POINTER(tcs_node->tcs) == tcs)
  368. {
  369. tcs_node_t *tmp = tcs_node;
  370. tcs_node = tcs_node->next;
  371. free(tmp);
  372. continue;
  373. }
  374. size_t start = (size_t)DEC_TCS_POINTER(tcs_node->tcs);
  375. size_t end = start + (1 << SE_PAGE_SHIFT);
  376. int rc = sgx_accept_forward(SI_FLAG_TRIM | SI_FLAG_MODIFIED, start, end);
  377. if(rc != 0)
  378. {
  379. return SGX_ERROR_UNEXPECTED;
  380. }
  381. tcs_node_t *tmp = tcs_node;
  382. tcs_node = tcs_node->next;
  383. free(tmp);
  384. }
  385. sgx_spin_lock(&g_ife_lock);
  386. if (!g_is_first_ecall)
  387. {
  388. uninit_global_object();
  389. }
  390. sgx_spin_unlock(&g_ife_lock);
  391. set_enclave_state(ENCLAVE_CRASHED);
  392. return SGX_SUCCESS;
  393. }
  394. extern sdk_version_t g_sdk_version;
  395. extern "C" sgx_status_t trts_mprotect(size_t start, size_t size, uint64_t perms)
  396. {
  397. int rc = -1;
  398. size_t page;
  399. sgx_status_t ret = SGX_SUCCESS;
  400. SE_DECLSPEC_ALIGN(sizeof(sec_info_t)) sec_info_t si;
  401. //Error return if start or size is not page-aligned or size is zero.
  402. if (!IS_PAGE_ALIGNED(start) || (size == 0) || !IS_PAGE_ALIGNED(size))
  403. return SGX_ERROR_INVALID_PARAMETER;
  404. if (g_sdk_version == SDK_VERSION_2_0)
  405. {
  406. ret = change_permissions_ocall(start, size, perms);
  407. if (ret != SGX_SUCCESS)
  408. return ret;
  409. }
  410. si.flags = perms|SI_FLAG_REG|SI_FLAG_PR;
  411. memset(&si.reserved, 0, sizeof(si.reserved));
  412. for(page = start; page < start + size; page += SE_PAGE_SIZE)
  413. {
  414. do_emodpe(&si, page);
  415. // If the target permission to set is RWX, no EMODPR, hence no EACCEPT.
  416. if ((perms & (SI_FLAG_W|SI_FLAG_X)) != (SI_FLAG_W|SI_FLAG_X))
  417. {
  418. rc = do_eaccept(&si, page);
  419. if(rc != 0)
  420. return (sgx_status_t)rc;
  421. }
  422. }
  423. return SGX_SUCCESS;
  424. }