sandbox.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2018 Linaro Limited
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <sandboxtee.h>
  8. #include <tee.h>
  9. #include <tee/optee_ta_avb.h>
  10. #include <tee/optee_ta_rpc_test.h>
  11. #include <tee/optee_ta_scp03.h>
  12. #include "optee/optee_msg.h"
  13. #include "optee/optee_private.h"
  14. /*
  15. * The sandbox tee driver tries to emulate a generic Trusted Exectution
  16. * Environment (TEE) with the Trusted Applications (TA) OPTEE_TA_AVB and
  17. * OPTEE_TA_RPC_TEST available.
  18. */
  19. static const u32 pstorage_max = 16;
  20. /**
  21. * struct ta_entry - TA entries
  22. * @uuid: UUID of an emulated TA
  23. * @open_session Called when a session is openened to the TA
  24. * @invoke_func Called when a function in the TA is to be invoked
  25. *
  26. * This struct is used to register TAs in this sandbox emulation of a TEE.
  27. */
  28. struct ta_entry {
  29. struct tee_optee_ta_uuid uuid;
  30. u32 (*open_session)(struct udevice *dev, uint num_params,
  31. struct tee_param *params);
  32. u32 (*invoke_func)(struct udevice *dev,
  33. u32 func, uint num_params,
  34. struct tee_param *params);
  35. };
  36. static int get_msg_arg(struct udevice *dev, uint num_params,
  37. struct tee_shm **shmp, struct optee_msg_arg **msg_arg)
  38. {
  39. int rc;
  40. struct optee_msg_arg *ma;
  41. rc = __tee_shm_add(dev, OPTEE_MSG_NONCONTIG_PAGE_SIZE, NULL,
  42. OPTEE_MSG_GET_ARG_SIZE(num_params), TEE_SHM_ALLOC,
  43. shmp);
  44. if (rc)
  45. return rc;
  46. ma = (*shmp)->addr;
  47. memset(ma, 0, OPTEE_MSG_GET_ARG_SIZE(num_params));
  48. ma->num_params = num_params;
  49. *msg_arg = ma;
  50. return 0;
  51. }
  52. void *optee_alloc_and_init_page_list(void *buf, ulong len,
  53. u64 *phys_buf_ptr)
  54. {
  55. /*
  56. * An empty stub is added just to fix linking issues.
  57. * This function isn't supposed to be called in sandbox
  58. * setup, otherwise replace this with a proper
  59. * implementation from optee/core.c
  60. */
  61. return NULL;
  62. }
  63. #if defined(CONFIG_OPTEE_TA_SCP03) || defined(CONFIG_OPTEE_TA_AVB)
  64. static u32 get_attr(uint n, uint num_params, struct tee_param *params)
  65. {
  66. if (n >= num_params)
  67. return TEE_PARAM_ATTR_TYPE_NONE;
  68. return params[n].attr;
  69. }
  70. static u32 check_params(u8 p0, u8 p1, u8 p2, u8 p3, uint num_params,
  71. struct tee_param *params)
  72. {
  73. u8 p[] = { p0, p1, p2, p3 };
  74. uint n;
  75. for (n = 0; n < ARRAY_SIZE(p); n++)
  76. if (p[n] != get_attr(n, num_params, params))
  77. goto bad_params;
  78. for (; n < num_params; n++)
  79. if (get_attr(n, num_params, params))
  80. goto bad_params;
  81. return TEE_SUCCESS;
  82. bad_params:
  83. printf("Bad param attrs\n");
  84. return TEE_ERROR_BAD_PARAMETERS;
  85. }
  86. #endif
  87. #ifdef CONFIG_OPTEE_TA_SCP03
  88. static u32 pta_scp03_open_session(struct udevice *dev, uint num_params,
  89. struct tee_param *params)
  90. {
  91. /*
  92. * We don't expect additional parameters when opening a session to
  93. * this TA.
  94. */
  95. return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  96. TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  97. num_params, params);
  98. }
  99. static u32 pta_scp03_invoke_func(struct udevice *dev, u32 func, uint num_params,
  100. struct tee_param *params)
  101. {
  102. u32 res;
  103. static bool enabled;
  104. switch (func) {
  105. case PTA_CMD_ENABLE_SCP03:
  106. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  107. TEE_PARAM_ATTR_TYPE_NONE,
  108. TEE_PARAM_ATTR_TYPE_NONE,
  109. TEE_PARAM_ATTR_TYPE_NONE,
  110. num_params, params);
  111. if (res)
  112. return res;
  113. if (!enabled) {
  114. enabled = true;
  115. } else {
  116. }
  117. if (params[0].u.value.a)
  118. return TEE_SUCCESS;
  119. default:
  120. return TEE_ERROR_NOT_SUPPORTED;
  121. }
  122. }
  123. #endif
  124. #ifdef CONFIG_OPTEE_TA_AVB
  125. static u32 ta_avb_open_session(struct udevice *dev, uint num_params,
  126. struct tee_param *params)
  127. {
  128. /*
  129. * We don't expect additional parameters when opening a session to
  130. * this TA.
  131. */
  132. return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  133. TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  134. num_params, params);
  135. }
  136. static u32 ta_avb_invoke_func(struct udevice *dev, u32 func, uint num_params,
  137. struct tee_param *params)
  138. {
  139. struct sandbox_tee_state *state = dev_get_priv(dev);
  140. struct env_entry e, *ep;
  141. char *name;
  142. u32 res;
  143. uint slot;
  144. u64 val;
  145. char *value;
  146. u32 value_sz;
  147. switch (func) {
  148. case TA_AVB_CMD_READ_ROLLBACK_INDEX:
  149. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  150. TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
  151. TEE_PARAM_ATTR_TYPE_NONE,
  152. TEE_PARAM_ATTR_TYPE_NONE,
  153. num_params, params);
  154. if (res)
  155. return res;
  156. slot = params[0].u.value.a;
  157. if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
  158. printf("Rollback index slot out of bounds %u\n", slot);
  159. return TEE_ERROR_BAD_PARAMETERS;
  160. }
  161. val = state->ta_avb_rollback_indexes[slot];
  162. params[1].u.value.a = val >> 32;
  163. params[1].u.value.b = val;
  164. return TEE_SUCCESS;
  165. case TA_AVB_CMD_WRITE_ROLLBACK_INDEX:
  166. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  167. TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  168. TEE_PARAM_ATTR_TYPE_NONE,
  169. TEE_PARAM_ATTR_TYPE_NONE,
  170. num_params, params);
  171. if (res)
  172. return res;
  173. slot = params[0].u.value.a;
  174. if (slot >= ARRAY_SIZE(state->ta_avb_rollback_indexes)) {
  175. printf("Rollback index slot out of bounds %u\n", slot);
  176. return TEE_ERROR_BAD_PARAMETERS;
  177. }
  178. val = (u64)params[1].u.value.a << 32 | params[1].u.value.b;
  179. if (val < state->ta_avb_rollback_indexes[slot])
  180. return TEE_ERROR_SECURITY;
  181. state->ta_avb_rollback_indexes[slot] = val;
  182. return TEE_SUCCESS;
  183. case TA_AVB_CMD_READ_LOCK_STATE:
  184. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT,
  185. TEE_PARAM_ATTR_TYPE_NONE,
  186. TEE_PARAM_ATTR_TYPE_NONE,
  187. TEE_PARAM_ATTR_TYPE_NONE,
  188. num_params, params);
  189. if (res)
  190. return res;
  191. params[0].u.value.a = state->ta_avb_lock_state;
  192. return TEE_SUCCESS;
  193. case TA_AVB_CMD_WRITE_LOCK_STATE:
  194. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  195. TEE_PARAM_ATTR_TYPE_NONE,
  196. TEE_PARAM_ATTR_TYPE_NONE,
  197. TEE_PARAM_ATTR_TYPE_NONE,
  198. num_params, params);
  199. if (res)
  200. return res;
  201. if (state->ta_avb_lock_state != params[0].u.value.a) {
  202. state->ta_avb_lock_state = params[0].u.value.a;
  203. memset(state->ta_avb_rollback_indexes, 0,
  204. sizeof(state->ta_avb_rollback_indexes));
  205. }
  206. return TEE_SUCCESS;
  207. case TA_AVB_CMD_READ_PERSIST_VALUE:
  208. res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
  209. TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
  210. TEE_PARAM_ATTR_TYPE_NONE,
  211. TEE_PARAM_ATTR_TYPE_NONE,
  212. num_params, params);
  213. if (res)
  214. return res;
  215. name = params[0].u.memref.shm->addr;
  216. value = params[1].u.memref.shm->addr;
  217. value_sz = params[1].u.memref.size;
  218. e.key = name;
  219. e.data = NULL;
  220. hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
  221. if (!ep)
  222. return TEE_ERROR_ITEM_NOT_FOUND;
  223. value_sz = strlen(ep->data) + 1;
  224. memcpy(value, ep->data, value_sz);
  225. return TEE_SUCCESS;
  226. case TA_AVB_CMD_WRITE_PERSIST_VALUE:
  227. res = check_params(TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
  228. TEE_PARAM_ATTR_TYPE_MEMREF_INPUT,
  229. TEE_PARAM_ATTR_TYPE_NONE,
  230. TEE_PARAM_ATTR_TYPE_NONE,
  231. num_params, params);
  232. if (res)
  233. return res;
  234. name = params[0].u.memref.shm->addr;
  235. value = params[1].u.memref.shm->addr;
  236. value_sz = params[1].u.memref.size;
  237. e.key = name;
  238. e.data = NULL;
  239. hsearch_r(e, ENV_FIND, &ep, &state->pstorage_htab, 0);
  240. if (ep)
  241. hdelete_r(e.key, &state->pstorage_htab, 0);
  242. e.key = name;
  243. e.data = value;
  244. hsearch_r(e, ENV_ENTER, &ep, &state->pstorage_htab, 0);
  245. if (!ep)
  246. return TEE_ERROR_OUT_OF_MEMORY;
  247. return TEE_SUCCESS;
  248. default:
  249. return TEE_ERROR_NOT_SUPPORTED;
  250. }
  251. }
  252. #endif /* OPTEE_TA_AVB */
  253. #ifdef CONFIG_OPTEE_TA_RPC_TEST
  254. static u32 ta_rpc_test_open_session(struct udevice *dev, uint num_params,
  255. struct tee_param *params)
  256. {
  257. /*
  258. * We don't expect additional parameters when opening a session to
  259. * this TA.
  260. */
  261. return check_params(TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  262. TEE_PARAM_ATTR_TYPE_NONE, TEE_PARAM_ATTR_TYPE_NONE,
  263. num_params, params);
  264. }
  265. static void fill_i2c_rpc_params(struct optee_msg_arg *msg_arg, u64 bus_num,
  266. u64 chip_addr, u64 xfer_flags, u64 op,
  267. struct tee_param_memref memref)
  268. {
  269. msg_arg->params[0].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
  270. msg_arg->params[1].attr = OPTEE_MSG_ATTR_TYPE_VALUE_INPUT;
  271. msg_arg->params[2].attr = OPTEE_MSG_ATTR_TYPE_RMEM_INOUT;
  272. msg_arg->params[3].attr = OPTEE_MSG_ATTR_TYPE_VALUE_OUTPUT;
  273. /* trigger I2C services of TEE supplicant */
  274. msg_arg->cmd = OPTEE_MSG_RPC_CMD_I2C_TRANSFER;
  275. msg_arg->params[0].u.value.a = op;
  276. msg_arg->params[0].u.value.b = bus_num;
  277. msg_arg->params[0].u.value.c = chip_addr;
  278. msg_arg->params[1].u.value.a = xfer_flags;
  279. /* buffer to read/write data */
  280. msg_arg->params[2].u.rmem.shm_ref = (ulong)memref.shm;
  281. msg_arg->params[2].u.rmem.size = memref.size;
  282. msg_arg->params[2].u.rmem.offs = memref.shm_offs;
  283. msg_arg->num_params = 4;
  284. }
  285. static u32 ta_rpc_test_invoke_func(struct udevice *dev, u32 func,
  286. uint num_params,
  287. struct tee_param *params)
  288. {
  289. struct tee_shm *shm;
  290. struct tee_param_memref memref_data;
  291. struct optee_msg_arg *msg_arg;
  292. int chip_addr, bus_num, op, xfer_flags;
  293. int res;
  294. res = check_params(TEE_PARAM_ATTR_TYPE_VALUE_INPUT,
  295. TEE_PARAM_ATTR_TYPE_MEMREF_INOUT,
  296. TEE_PARAM_ATTR_TYPE_NONE,
  297. TEE_PARAM_ATTR_TYPE_NONE,
  298. num_params, params);
  299. if (res)
  300. return TEE_ERROR_BAD_PARAMETERS;
  301. bus_num = params[0].u.value.a;
  302. chip_addr = params[0].u.value.b;
  303. xfer_flags = params[0].u.value.c;
  304. memref_data = params[1].u.memref;
  305. switch (func) {
  306. case TA_RPC_TEST_CMD_I2C_READ:
  307. op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_RD;
  308. break;
  309. case TA_RPC_TEST_CMD_I2C_WRITE:
  310. op = OPTEE_MSG_RPC_CMD_I2C_TRANSFER_WR;
  311. break;
  312. default:
  313. return TEE_ERROR_NOT_SUPPORTED;
  314. }
  315. /*
  316. * Fill params for an RPC call to tee supplicant
  317. */
  318. res = get_msg_arg(dev, 4, &shm, &msg_arg);
  319. if (res)
  320. goto out;
  321. fill_i2c_rpc_params(msg_arg, bus_num, chip_addr, xfer_flags, op,
  322. memref_data);
  323. /* Make an RPC call to tee supplicant */
  324. optee_suppl_cmd(dev, shm, 0);
  325. res = msg_arg->ret;
  326. out:
  327. tee_shm_free(shm);
  328. return res;
  329. }
  330. #endif /* CONFIG_OPTEE_TA_RPC_TEST */
  331. static const struct ta_entry ta_entries[] = {
  332. #ifdef CONFIG_OPTEE_TA_AVB
  333. { .uuid = TA_AVB_UUID,
  334. .open_session = ta_avb_open_session,
  335. .invoke_func = ta_avb_invoke_func,
  336. },
  337. #endif
  338. #ifdef CONFIG_OPTEE_TA_RPC_TEST
  339. { .uuid = TA_RPC_TEST_UUID,
  340. .open_session = ta_rpc_test_open_session,
  341. .invoke_func = ta_rpc_test_invoke_func,
  342. },
  343. #endif
  344. #ifdef CONFIG_OPTEE_TA_SCP03
  345. { .uuid = PTA_SCP03_UUID,
  346. .open_session = pta_scp03_open_session,
  347. .invoke_func = pta_scp03_invoke_func,
  348. },
  349. #endif
  350. };
  351. static void sandbox_tee_get_version(struct udevice *dev,
  352. struct tee_version_data *vers)
  353. {
  354. struct tee_version_data v = {
  355. .gen_caps = TEE_GEN_CAP_GP | TEE_GEN_CAP_REG_MEM,
  356. };
  357. *vers = v;
  358. }
  359. static int sandbox_tee_close_session(struct udevice *dev, u32 session)
  360. {
  361. struct sandbox_tee_state *state = dev_get_priv(dev);
  362. if (!state->ta || state->session != session)
  363. return -EINVAL;
  364. state->session = 0;
  365. state->ta = NULL;
  366. return 0;
  367. }
  368. static const struct ta_entry *find_ta_entry(u8 uuid[TEE_UUID_LEN])
  369. {
  370. struct tee_optee_ta_uuid u;
  371. uint n;
  372. tee_optee_ta_uuid_from_octets(&u, uuid);
  373. for (n = 0; n < ARRAY_SIZE(ta_entries); n++)
  374. if (!memcmp(&u, &ta_entries[n].uuid, sizeof(u)))
  375. return ta_entries + n;
  376. return NULL;
  377. }
  378. static int sandbox_tee_open_session(struct udevice *dev,
  379. struct tee_open_session_arg *arg,
  380. uint num_params, struct tee_param *params)
  381. {
  382. struct sandbox_tee_state *state = dev_get_priv(dev);
  383. const struct ta_entry *ta;
  384. if (state->ta) {
  385. printf("A session is already open\n");
  386. return -EBUSY;
  387. }
  388. ta = find_ta_entry(arg->uuid);
  389. if (!ta) {
  390. printf("Cannot find TA\n");
  391. arg->ret = TEE_ERROR_ITEM_NOT_FOUND;
  392. arg->ret_origin = TEE_ORIGIN_TEE;
  393. return 0;
  394. }
  395. arg->ret = ta->open_session(dev, num_params, params);
  396. arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;
  397. if (!arg->ret) {
  398. state->ta = (void *)ta;
  399. state->session = 1;
  400. arg->session = state->session;
  401. } else {
  402. printf("Cannot open session, TA returns error\n");
  403. }
  404. return 0;
  405. }
  406. static int sandbox_tee_invoke_func(struct udevice *dev,
  407. struct tee_invoke_arg *arg,
  408. uint num_params, struct tee_param *params)
  409. {
  410. struct sandbox_tee_state *state = dev_get_priv(dev);
  411. struct ta_entry *ta = state->ta;
  412. if (!arg->session) {
  413. printf("Missing session\n");
  414. return -EINVAL;
  415. }
  416. if (!ta) {
  417. printf("TA session not available\n");
  418. return -EINVAL;
  419. }
  420. if (arg->session != state->session) {
  421. printf("Session mismatch\n");
  422. return -EINVAL;
  423. }
  424. arg->ret = ta->invoke_func(dev, arg->func, num_params, params);
  425. arg->ret_origin = TEE_ORIGIN_TRUSTED_APP;
  426. return 0;
  427. }
  428. static int sandbox_tee_shm_register(struct udevice *dev, struct tee_shm *shm)
  429. {
  430. struct sandbox_tee_state *state = dev_get_priv(dev);
  431. state->num_shms++;
  432. return 0;
  433. }
  434. static int sandbox_tee_shm_unregister(struct udevice *dev, struct tee_shm *shm)
  435. {
  436. struct sandbox_tee_state *state = dev_get_priv(dev);
  437. state->num_shms--;
  438. return 0;
  439. }
  440. static int sandbox_tee_remove(struct udevice *dev)
  441. {
  442. struct sandbox_tee_state *state = dev_get_priv(dev);
  443. hdestroy_r(&state->pstorage_htab);
  444. return 0;
  445. }
  446. static int sandbox_tee_probe(struct udevice *dev)
  447. {
  448. struct sandbox_tee_state *state = dev_get_priv(dev);
  449. /*
  450. * With this hastable we emulate persistent storage,
  451. * which should contain persistent values
  452. * between different sessions/command invocations.
  453. */
  454. if (!hcreate_r(pstorage_max, &state->pstorage_htab))
  455. return TEE_ERROR_OUT_OF_MEMORY;
  456. return 0;
  457. }
  458. static const struct tee_driver_ops sandbox_tee_ops = {
  459. .get_version = sandbox_tee_get_version,
  460. .open_session = sandbox_tee_open_session,
  461. .close_session = sandbox_tee_close_session,
  462. .invoke_func = sandbox_tee_invoke_func,
  463. .shm_register = sandbox_tee_shm_register,
  464. .shm_unregister = sandbox_tee_shm_unregister,
  465. };
  466. static const struct udevice_id sandbox_tee_match[] = {
  467. { .compatible = "sandbox,tee" },
  468. {},
  469. };
  470. U_BOOT_DRIVER(sandbox_tee) = {
  471. .name = "sandbox_tee",
  472. .id = UCLASS_TEE,
  473. .of_match = sandbox_tee_match,
  474. .ops = &sandbox_tee_ops,
  475. .priv_auto = sizeof(struct sandbox_tee_state),
  476. .probe = sandbox_tee_probe,
  477. .remove = sandbox_tee_remove,
  478. };