rpmb.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2014, Staubli Faverges
  4. * Pierre Aubert
  5. *
  6. * eMMC- Replay Protected Memory Block
  7. * According to JEDEC Standard No. 84-A441
  8. */
  9. #include <config.h>
  10. #include <common.h>
  11. #include <log.h>
  12. #include <memalign.h>
  13. #include <mmc.h>
  14. #include <sdhci.h>
  15. #include <u-boot/sha256.h>
  16. #include "mmc_private.h"
  17. /* Request codes */
  18. #define RPMB_REQ_KEY 1
  19. #define RPMB_REQ_WCOUNTER 2
  20. #define RPMB_REQ_WRITE_DATA 3
  21. #define RPMB_REQ_READ_DATA 4
  22. #define RPMB_REQ_STATUS 5
  23. /* Response code */
  24. #define RPMB_RESP_KEY 0x0100
  25. #define RPMB_RESP_WCOUNTER 0x0200
  26. #define RPMB_RESP_WRITE_DATA 0x0300
  27. #define RPMB_RESP_READ_DATA 0x0400
  28. /* Error codes */
  29. #define RPMB_OK 0
  30. #define RPMB_ERR_GENERAL 1
  31. #define RPMB_ERR_AUTH 2
  32. #define RPMB_ERR_COUNTER 3
  33. #define RPMB_ERR_ADDRESS 4
  34. #define RPMB_ERR_WRITE 5
  35. #define RPMB_ERR_READ 6
  36. #define RPMB_ERR_KEY 7
  37. #define RPMB_ERR_CNT_EXPIRED 0x80
  38. #define RPMB_ERR_MSK 0x7
  39. /* Sizes of RPMB data frame */
  40. #define RPMB_SZ_STUFF 196
  41. #define RPMB_SZ_MAC 32
  42. #define RPMB_SZ_DATA 256
  43. #define RPMB_SZ_NONCE 16
  44. #define SHA256_BLOCK_SIZE 64
  45. /* Error messages */
  46. static const char * const rpmb_err_msg[] = {
  47. "",
  48. "General failure",
  49. "Authentication failure",
  50. "Counter failure",
  51. "Address failure",
  52. "Write failure",
  53. "Read failure",
  54. "Authentication key not yet programmed",
  55. };
  56. /* Structure of RPMB data frame. */
  57. struct s_rpmb {
  58. unsigned char stuff[RPMB_SZ_STUFF];
  59. unsigned char mac[RPMB_SZ_MAC];
  60. unsigned char data[RPMB_SZ_DATA];
  61. unsigned char nonce[RPMB_SZ_NONCE];
  62. unsigned int write_counter;
  63. unsigned short address;
  64. unsigned short block_count;
  65. unsigned short result;
  66. unsigned short request;
  67. };
  68. static int mmc_set_blockcount(struct mmc *mmc, unsigned int blockcount,
  69. bool is_rel_write)
  70. {
  71. struct mmc_cmd cmd = {0};
  72. cmd.cmdidx = MMC_CMD_SET_BLOCK_COUNT;
  73. cmd.cmdarg = blockcount & 0x0000FFFF;
  74. if (is_rel_write)
  75. cmd.cmdarg |= 1 << 31;
  76. cmd.resp_type = MMC_RSP_R1;
  77. return mmc_send_cmd(mmc, &cmd, NULL);
  78. }
  79. static int mmc_rpmb_request(struct mmc *mmc, const struct s_rpmb *s,
  80. unsigned int count, bool is_rel_write)
  81. {
  82. struct mmc_cmd cmd = {0};
  83. struct mmc_data data;
  84. struct sdhci_host *host = mmc->priv;
  85. int ret;
  86. ret = mmc_set_blockcount(mmc, count, is_rel_write);
  87. if (ret) {
  88. #ifdef CONFIG_MMC_RPMB_TRACE
  89. printf("%s:mmc_set_blockcount-> %d\n", __func__, ret);
  90. #endif
  91. return 1;
  92. }
  93. cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
  94. cmd.cmdarg = 0;
  95. cmd.resp_type = MMC_RSP_R1;
  96. if (host->quirks & SDHCI_QUIRK_BROKEN_R1B)
  97. cmd.resp_type = MMC_RSP_R1;
  98. data.src = (const char *)s;
  99. data.blocks = 1;
  100. data.blocksize = MMC_MAX_BLOCK_LEN;
  101. data.flags = MMC_DATA_WRITE;
  102. ret = mmc_send_cmd(mmc, &cmd, &data);
  103. if (ret) {
  104. #ifdef CONFIG_MMC_RPMB_TRACE
  105. printf("%s:mmc_send_cmd-> %d\n", __func__, ret);
  106. #endif
  107. return 1;
  108. }
  109. return 0;
  110. }
  111. static int mmc_rpmb_response(struct mmc *mmc, struct s_rpmb *s,
  112. unsigned short expected)
  113. {
  114. struct mmc_cmd cmd = {0};
  115. struct mmc_data data;
  116. int ret;
  117. ret = mmc_set_blockcount(mmc, 1, false);
  118. if (ret) {
  119. #ifdef CONFIG_MMC_RPMB_TRACE
  120. printf("%s:mmc_set_blockcount-> %d\n", __func__, ret);
  121. #endif
  122. return -1;
  123. }
  124. cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
  125. cmd.cmdarg = 0;
  126. cmd.resp_type = MMC_RSP_R1;
  127. data.dest = (char *)s;
  128. data.blocks = 1;
  129. data.blocksize = MMC_MAX_BLOCK_LEN;
  130. data.flags = MMC_DATA_READ;
  131. ret = mmc_send_cmd(mmc, &cmd, &data);
  132. if (ret) {
  133. #ifdef CONFIG_MMC_RPMB_TRACE
  134. printf("%s:mmc_send_cmd-> %d\n", __func__, ret);
  135. #endif
  136. return -1;
  137. }
  138. /* Check the response and the status */
  139. if (be16_to_cpu(s->request) != expected) {
  140. #ifdef CONFIG_MMC_RPMB_TRACE
  141. printf("%s:response= %x\n", __func__,
  142. be16_to_cpu(s->request));
  143. #endif
  144. return -1;
  145. }
  146. ret = be16_to_cpu(s->result);
  147. if (ret) {
  148. printf("%s %s\n", rpmb_err_msg[ret & RPMB_ERR_MSK],
  149. (ret & RPMB_ERR_CNT_EXPIRED) ?
  150. "Write counter has expired" : "");
  151. }
  152. /* Return the status of the command */
  153. return ret;
  154. }
  155. static int mmc_rpmb_status(struct mmc *mmc, unsigned short expected)
  156. {
  157. ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
  158. memset(rpmb_frame, 0, sizeof(struct s_rpmb));
  159. rpmb_frame->request = cpu_to_be16(RPMB_REQ_STATUS);
  160. if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
  161. return -1;
  162. /* Read the result */
  163. return mmc_rpmb_response(mmc, rpmb_frame, expected);
  164. }
  165. static void rpmb_hmac(unsigned char *key, unsigned char *buff, int len,
  166. unsigned char *output)
  167. {
  168. sha256_context ctx;
  169. int i;
  170. unsigned char k_ipad[SHA256_BLOCK_SIZE];
  171. unsigned char k_opad[SHA256_BLOCK_SIZE];
  172. sha256_starts(&ctx);
  173. /* According to RFC 4634, the HMAC transform looks like:
  174. SHA(K XOR opad, SHA(K XOR ipad, text))
  175. where K is an n byte key.
  176. ipad is the byte 0x36 repeated blocksize times
  177. opad is the byte 0x5c repeated blocksize times
  178. and text is the data being protected.
  179. */
  180. for (i = 0; i < RPMB_SZ_MAC; i++) {
  181. k_ipad[i] = key[i] ^ 0x36;
  182. k_opad[i] = key[i] ^ 0x5c;
  183. }
  184. /* remaining pad bytes are '\0' XOR'd with ipad and opad values */
  185. for ( ; i < SHA256_BLOCK_SIZE; i++) {
  186. k_ipad[i] = 0x36;
  187. k_opad[i] = 0x5c;
  188. }
  189. sha256_update(&ctx, k_ipad, SHA256_BLOCK_SIZE);
  190. sha256_update(&ctx, buff, len);
  191. sha256_finish(&ctx, output);
  192. /* Init context for second pass */
  193. sha256_starts(&ctx);
  194. /* start with outer pad */
  195. sha256_update(&ctx, k_opad, SHA256_BLOCK_SIZE);
  196. /* then results of 1st hash */
  197. sha256_update(&ctx, output, RPMB_SZ_MAC);
  198. /* finish up 2nd pass */
  199. sha256_finish(&ctx, output);
  200. }
  201. int mmc_rpmb_get_counter(struct mmc *mmc, unsigned long *pcounter)
  202. {
  203. int ret;
  204. ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
  205. /* Fill the request */
  206. memset(rpmb_frame, 0, sizeof(struct s_rpmb));
  207. rpmb_frame->request = cpu_to_be16(RPMB_REQ_WCOUNTER);
  208. if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
  209. return -1;
  210. /* Read the result */
  211. ret = mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_WCOUNTER);
  212. if (ret)
  213. return ret;
  214. *pcounter = be32_to_cpu(rpmb_frame->write_counter);
  215. return 0;
  216. }
  217. int mmc_rpmb_set_key(struct mmc *mmc, void *key)
  218. {
  219. ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
  220. /* Fill the request */
  221. memset(rpmb_frame, 0, sizeof(struct s_rpmb));
  222. rpmb_frame->request = cpu_to_be16(RPMB_REQ_KEY);
  223. memcpy(rpmb_frame->mac, key, RPMB_SZ_MAC);
  224. if (mmc_rpmb_request(mmc, rpmb_frame, 1, true))
  225. return -1;
  226. /* read the operation status */
  227. return mmc_rpmb_status(mmc, RPMB_RESP_KEY);
  228. }
  229. int mmc_rpmb_read(struct mmc *mmc, void *addr, unsigned short blk,
  230. unsigned short cnt, unsigned char *key)
  231. {
  232. ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
  233. int i;
  234. for (i = 0; i < cnt; i++) {
  235. /* Fill the request */
  236. memset(rpmb_frame, 0, sizeof(struct s_rpmb));
  237. rpmb_frame->address = cpu_to_be16(blk + i);
  238. rpmb_frame->request = cpu_to_be16(RPMB_REQ_READ_DATA);
  239. if (mmc_rpmb_request(mmc, rpmb_frame, 1, false))
  240. break;
  241. /* Read the result */
  242. if (mmc_rpmb_response(mmc, rpmb_frame, RPMB_RESP_READ_DATA))
  243. break;
  244. /* Check the HMAC if key is provided */
  245. if (key) {
  246. unsigned char ret_hmac[RPMB_SZ_MAC];
  247. rpmb_hmac(key, rpmb_frame->data, 284, ret_hmac);
  248. if (memcmp(ret_hmac, rpmb_frame->mac, RPMB_SZ_MAC)) {
  249. printf("MAC error on block #%d\n", i);
  250. break;
  251. }
  252. }
  253. /* Copy data */
  254. memcpy(addr + i * RPMB_SZ_DATA, rpmb_frame->data, RPMB_SZ_DATA);
  255. }
  256. return i;
  257. }
  258. int mmc_rpmb_write(struct mmc *mmc, void *addr, unsigned short blk,
  259. unsigned short cnt, unsigned char *key)
  260. {
  261. ALLOC_CACHE_ALIGN_BUFFER(struct s_rpmb, rpmb_frame, 1);
  262. unsigned long wcount;
  263. int i;
  264. for (i = 0; i < cnt; i++) {
  265. if (mmc_rpmb_get_counter(mmc, &wcount)) {
  266. printf("Cannot read RPMB write counter\n");
  267. break;
  268. }
  269. /* Fill the request */
  270. memset(rpmb_frame, 0, sizeof(struct s_rpmb));
  271. memcpy(rpmb_frame->data, addr + i * RPMB_SZ_DATA, RPMB_SZ_DATA);
  272. rpmb_frame->address = cpu_to_be16(blk + i);
  273. rpmb_frame->block_count = cpu_to_be16(1);
  274. rpmb_frame->write_counter = cpu_to_be32(wcount);
  275. rpmb_frame->request = cpu_to_be16(RPMB_REQ_WRITE_DATA);
  276. /* Computes HMAC */
  277. rpmb_hmac(key, rpmb_frame->data, 284, rpmb_frame->mac);
  278. if (mmc_rpmb_request(mmc, rpmb_frame, 1, true))
  279. break;
  280. /* Get status */
  281. if (mmc_rpmb_status(mmc, RPMB_RESP_WRITE_DATA))
  282. break;
  283. }
  284. return i;
  285. }
  286. static int send_write_mult_block(struct mmc *mmc, const struct s_rpmb *frm,
  287. unsigned short cnt)
  288. {
  289. struct mmc_cmd cmd = {
  290. .cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK,
  291. .resp_type = MMC_RSP_R1,
  292. };
  293. struct mmc_data data = {
  294. .src = (const void *)frm,
  295. .blocks = cnt,
  296. .blocksize = sizeof(*frm),
  297. .flags = MMC_DATA_WRITE,
  298. };
  299. return mmc_send_cmd(mmc, &cmd, &data);
  300. }
  301. static int send_read_mult_block(struct mmc *mmc, struct s_rpmb *frm,
  302. unsigned short cnt)
  303. {
  304. struct mmc_cmd cmd = {
  305. .cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK,
  306. .resp_type = MMC_RSP_R1,
  307. };
  308. struct mmc_data data = {
  309. .dest = (void *)frm,
  310. .blocks = cnt,
  311. .blocksize = sizeof(*frm),
  312. .flags = MMC_DATA_READ,
  313. };
  314. return mmc_send_cmd(mmc, &cmd, &data);
  315. }
  316. static int rpmb_route_write_req(struct mmc *mmc, struct s_rpmb *req,
  317. unsigned short req_cnt, struct s_rpmb *rsp,
  318. unsigned short rsp_cnt)
  319. {
  320. int ret;
  321. /*
  322. * Send the write request.
  323. */
  324. ret = mmc_set_blockcount(mmc, req_cnt, true);
  325. if (ret)
  326. return ret;
  327. ret = send_write_mult_block(mmc, req, req_cnt);
  328. if (ret)
  329. return ret;
  330. /*
  331. * Read the result of the request.
  332. */
  333. ret = mmc_set_blockcount(mmc, 1, false);
  334. if (ret)
  335. return ret;
  336. memset(rsp, 0, sizeof(*rsp));
  337. rsp->request = cpu_to_be16(RPMB_REQ_STATUS);
  338. ret = send_write_mult_block(mmc, rsp, 1);
  339. if (ret)
  340. return ret;
  341. ret = mmc_set_blockcount(mmc, 1, false);
  342. if (ret)
  343. return ret;
  344. return send_read_mult_block(mmc, rsp, 1);
  345. }
  346. static int rpmb_route_read_req(struct mmc *mmc, struct s_rpmb *req,
  347. unsigned short req_cnt, struct s_rpmb *rsp,
  348. unsigned short rsp_cnt)
  349. {
  350. int ret;
  351. /*
  352. * Send the read request.
  353. */
  354. ret = mmc_set_blockcount(mmc, 1, false);
  355. if (ret)
  356. return ret;
  357. ret = send_write_mult_block(mmc, req, 1);
  358. if (ret)
  359. return ret;
  360. /*
  361. * Read the result of the request.
  362. */
  363. ret = mmc_set_blockcount(mmc, rsp_cnt, false);
  364. if (ret)
  365. return ret;
  366. return send_read_mult_block(mmc, rsp, rsp_cnt);
  367. }
  368. static int rpmb_route_frames(struct mmc *mmc, struct s_rpmb *req,
  369. unsigned short req_cnt, struct s_rpmb *rsp,
  370. unsigned short rsp_cnt)
  371. {
  372. unsigned short n;
  373. /*
  374. * If multiple request frames are provided, make sure that all are
  375. * of the same type.
  376. */
  377. for (n = 1; n < req_cnt; n++)
  378. if (req[n].request != req->request)
  379. return -EINVAL;
  380. switch (be16_to_cpu(req->request)) {
  381. case RPMB_REQ_KEY:
  382. if (req_cnt != 1 || rsp_cnt != 1)
  383. return -EINVAL;
  384. return rpmb_route_write_req(mmc, req, req_cnt, rsp, rsp_cnt);
  385. case RPMB_REQ_WRITE_DATA:
  386. if (!req_cnt || rsp_cnt != 1)
  387. return -EINVAL;
  388. return rpmb_route_write_req(mmc, req, req_cnt, rsp, rsp_cnt);
  389. case RPMB_REQ_WCOUNTER:
  390. if (req_cnt != 1 || rsp_cnt != 1)
  391. return -EINVAL;
  392. return rpmb_route_read_req(mmc, req, req_cnt, rsp, rsp_cnt);
  393. case RPMB_REQ_READ_DATA:
  394. if (req_cnt != 1 || !req_cnt)
  395. return -EINVAL;
  396. return rpmb_route_read_req(mmc, req, req_cnt, rsp, rsp_cnt);
  397. default:
  398. debug("Unsupported message type: %d\n",
  399. be16_to_cpu(req->request));
  400. return -EINVAL;
  401. }
  402. }
  403. int mmc_rpmb_route_frames(struct mmc *mmc, void *req, unsigned long reqlen,
  404. void *rsp, unsigned long rsplen)
  405. {
  406. /*
  407. * Whoever crafted the data supplied to this function knows how to
  408. * format the PRMB frames and which response is expected. If
  409. * there's some unexpected mismatch it's more helpful to report an
  410. * error immediately than trying to guess what was the intention
  411. * and possibly just delay an eventual error which will be harder
  412. * to track down.
  413. */
  414. void *rpmb_data = NULL;
  415. int ret;
  416. if (reqlen % sizeof(struct s_rpmb) || rsplen % sizeof(struct s_rpmb))
  417. return -EINVAL;
  418. if (!IS_ALIGNED((uintptr_t)req, ARCH_DMA_MINALIGN)) {
  419. /* Memory alignment is required by MMC driver */
  420. rpmb_data = malloc(reqlen);
  421. if (!rpmb_data)
  422. return -ENOMEM;
  423. memcpy(rpmb_data, req, reqlen);
  424. req = rpmb_data;
  425. }
  426. ret = rpmb_route_frames(mmc, req, reqlen / sizeof(struct s_rpmb),
  427. rsp, rsplen / sizeof(struct s_rpmb));
  428. free(rpmb_data);
  429. return ret;
  430. }