mbedtls_backend_aes.c 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213
  1. /**
  2. * Copyright (c) 2018 - 2020, Nordic Semiconductor ASA
  3. *
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without modification,
  7. * are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. *
  12. * 2. Redistributions in binary form, except as embedded into a Nordic
  13. * Semiconductor ASA integrated circuit in a product or a software update for
  14. * such product, must reproduce the above copyright notice, this list of
  15. * conditions and the following disclaimer in the documentation and/or other
  16. * materials provided with the distribution.
  17. *
  18. * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
  19. * contributors may be used to endorse or promote products derived from this
  20. * software without specific prior written permission.
  21. *
  22. * 4. This software, with or without modification, must only be used with a
  23. * Nordic Semiconductor ASA integrated circuit.
  24. *
  25. * 5. Any software provided in binary form under this license must not be reverse
  26. * engineered, decompiled, modified and/or disassembled.
  27. *
  28. * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
  29. * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30. * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
  31. * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
  32. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  34. * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  37. * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38. *
  39. */
  40. #include "sdk_common.h"
  41. #if NRF_MODULE_ENABLED(NRF_CRYPTO)
  42. /*lint -save -e????*/
  43. #include "mbedtls/md.h"
  44. #include "mbedtls/aes.h"
  45. #include "mbedtls/cipher.h"
  46. /*lint -restore*/
  47. #include "nrf_crypto_error.h"
  48. #include "mbedtls_backend_aes.h"
  49. #if NRF_MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES)
  50. /* macro changing bits to bytes */
  51. #define BITS_TO_BYTES(bits) ((bits)>>3)
  52. #define BACKEND_ERROR_CHECK(error) \
  53. do { \
  54. if ((error) != 0) \
  55. { \
  56. return result_get((error)); \
  57. } \
  58. } while (0);
  59. /**@internal @brief Type declarations of templates matching all possible context sizes
  60. * for this backend.
  61. */
  62. typedef struct
  63. {
  64. nrf_crypto_aes_internal_context_t header; /**< Common header for context. */
  65. nrf_crypto_backend_aes_ctx_t backend; /**< Backend-specific internal context. */
  66. uint32_t context[1]; /**< AES context internal to mbed TLS. */
  67. } nrf_crypto_backend_mbedtls_aes_any_context_t;
  68. /**@internal @brief Type declarations of templates matching all possible context sizes
  69. * for this backend.
  70. */
  71. typedef union
  72. {
  73. nrf_crypto_backend_mbedtls_aes_any_context_t any; /**< Common for all contexts. */
  74. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  75. nrf_crypto_backend_aes_ecb_context_t ecb;
  76. #endif
  77. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  78. nrf_crypto_backend_aes_cbc_context_t cbc;
  79. #endif
  80. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  81. nrf_crypto_backend_aes_ctr_context_t ctr;
  82. #endif
  83. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  84. nrf_crypto_backend_aes_cfb_context_t cfb;
  85. #endif
  86. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  87. nrf_crypto_backend_aes_cbc_mac_context_t cbc_mac;
  88. #endif
  89. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  90. nrf_crypto_backend_aes_cmac_context_t cmac;
  91. #endif
  92. } nrf_crypto_backend_mbedtls_aes_context_t;
  93. static ret_code_t result_get(int error)
  94. {
  95. ret_code_t ret_val;
  96. switch (error)
  97. {
  98. case 0:
  99. ret_val = NRF_SUCCESS;
  100. break;
  101. case MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH:
  102. ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
  103. break;
  104. case MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA:
  105. ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
  106. break;
  107. case MBEDTLS_ERR_CIPHER_ALLOC_FAILED:
  108. ret_val = NRF_ERROR_CRYPTO_ALLOC_FAILED;
  109. break;
  110. case MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE:
  111. ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
  112. break;
  113. case MBEDTLS_ERR_MD_BAD_INPUT_DATA:
  114. ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
  115. break;
  116. default:
  117. ret_val = NRF_ERROR_CRYPTO_INTERNAL;
  118. break;
  119. }
  120. return ret_val;
  121. }
  122. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  123. static ret_code_t backend_cmac_init(nrf_crypto_backend_aes_cmac_context_t * const p_cmac_ctx)
  124. {
  125. int error;
  126. mbedtls_cipher_type_t cipher_type;
  127. mbedtls_cipher_info_t const * p_cipher_info;
  128. mbedtls_cipher_init(&p_cmac_ctx->context);
  129. switch (p_cmac_ctx->header.p_info->key_size)
  130. {
  131. case NRF_CRYPTO_KEY_SIZE_128:
  132. cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
  133. break;
  134. case NRF_CRYPTO_KEY_SIZE_192:
  135. cipher_type = MBEDTLS_CIPHER_AES_192_ECB;
  136. break;
  137. case NRF_CRYPTO_KEY_SIZE_256:
  138. cipher_type = MBEDTLS_CIPHER_AES_256_ECB;
  139. break;
  140. default:
  141. return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
  142. }
  143. p_cipher_info = mbedtls_cipher_info_from_type(cipher_type);
  144. if (p_cipher_info == NULL)
  145. {
  146. return NRF_ERROR_CRYPTO_INTERNAL;
  147. }
  148. error = mbedtls_cipher_setup(&p_cmac_ctx->context, p_cipher_info);
  149. BACKEND_ERROR_CHECK(error);
  150. return NRF_SUCCESS;
  151. }
  152. #endif
  153. static ret_code_t backend_mbedtls_init(void * const p_context, nrf_crypto_operation_t operation)
  154. {
  155. ret_code_t ret_val = NRF_SUCCESS;
  156. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  157. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  158. switch (p_ctx->any.header.p_info->key_size)
  159. {
  160. case NRF_CRYPTO_KEY_SIZE_128:
  161. case NRF_CRYPTO_KEY_SIZE_192:
  162. case NRF_CRYPTO_KEY_SIZE_256:
  163. break;
  164. default:
  165. return NRF_ERROR_CRYPTO_KEY_SIZE;
  166. }
  167. switch (p_ctx->any.header.p_info->mode)
  168. {
  169. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  170. case NRF_CRYPTO_AES_MODE_CBC:
  171. case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
  172. VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
  173. NRF_ERROR_CRYPTO_INVALID_PARAM);
  174. memset(&p_ctx->cbc.backend, 0, sizeof(p_ctx->cbc.backend));
  175. mbedtls_aes_init(&p_ctx->cbc.context);
  176. break;
  177. #endif
  178. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  179. case NRF_CRYPTO_AES_MODE_CTR:
  180. VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
  181. NRF_ERROR_CRYPTO_INVALID_PARAM);
  182. memset(&p_ctx->ctr.backend, 0, sizeof(p_ctx->ctr.backend));
  183. mbedtls_aes_init(&p_ctx->ctr.context);
  184. break;
  185. #endif
  186. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  187. case NRF_CRYPTO_AES_MODE_CFB:
  188. VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
  189. NRF_ERROR_CRYPTO_INVALID_PARAM);
  190. memset(&p_ctx->cfb.backend, 0, sizeof(p_ctx->cfb.backend));
  191. mbedtls_aes_init(&p_ctx->cfb.context);
  192. break;
  193. #endif
  194. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  195. case NRF_CRYPTO_AES_MODE_ECB:
  196. case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
  197. VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
  198. NRF_ERROR_CRYPTO_INVALID_PARAM);
  199. memset(&p_ctx->ecb.backend, 0, sizeof(p_ctx->ecb.backend));
  200. mbedtls_aes_init(&p_ctx->ecb.context);
  201. break;
  202. #endif
  203. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  204. case NRF_CRYPTO_AES_MODE_CBC_MAC:
  205. case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
  206. VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
  207. memset(&p_ctx->cbc_mac.backend, 0, sizeof(p_ctx->cbc_mac.backend));
  208. mbedtls_aes_init(&p_ctx->cbc_mac.context);
  209. break;
  210. #endif
  211. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  212. case NRF_CRYPTO_AES_MODE_CMAC:
  213. VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
  214. ret_val = backend_cmac_init(&p_ctx->cmac);
  215. break;
  216. #endif
  217. default:
  218. ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
  219. break;
  220. }
  221. p_ctx->any.backend.operation = operation;
  222. return ret_val;
  223. }
  224. static ret_code_t backend_mbedtls_uninit(void * const p_context)
  225. {
  226. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  227. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  228. switch (p_ctx->any.header.p_info->mode)
  229. {
  230. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  231. case NRF_CRYPTO_AES_MODE_CBC:
  232. case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
  233. mbedtls_aes_free(&p_ctx->cbc.context);
  234. break;
  235. #endif
  236. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  237. case NRF_CRYPTO_AES_MODE_CTR:
  238. mbedtls_aes_free(&p_ctx->ctr.context);
  239. break;
  240. #endif
  241. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  242. case NRF_CRYPTO_AES_MODE_CFB:
  243. mbedtls_aes_free(&p_ctx->cfb.context);
  244. break;
  245. #endif
  246. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  247. case NRF_CRYPTO_AES_MODE_ECB:
  248. case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
  249. mbedtls_aes_free(&p_ctx->ecb.context);
  250. break;
  251. #endif
  252. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  253. case NRF_CRYPTO_AES_MODE_CBC_MAC:
  254. case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
  255. mbedtls_aes_free(&p_ctx->cbc_mac.context);
  256. break;
  257. #endif
  258. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  259. case NRF_CRYPTO_AES_MODE_CMAC:
  260. mbedtls_cipher_free(&p_ctx->cmac.context);
  261. break;
  262. #endif
  263. default:
  264. return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
  265. }
  266. return NRF_SUCCESS;
  267. }
  268. static ret_code_t backend_mbedtls_key_set(void * const p_context, uint8_t * p_key)
  269. {
  270. int error;
  271. ret_code_t ret_val;
  272. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  273. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  274. switch (p_ctx->any.header.p_info->mode)
  275. {
  276. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  277. case NRF_CRYPTO_AES_MODE_CBC:
  278. case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
  279. if (p_ctx->cbc.backend.operation == NRF_CRYPTO_ENCRYPT)
  280. {
  281. error = mbedtls_aes_setkey_enc(&p_ctx->cbc.context,
  282. (uint8_t const *)p_key,
  283. p_ctx->cbc.header.p_info->key_size);
  284. }
  285. else
  286. {
  287. error = mbedtls_aes_setkey_dec(&p_ctx->cbc.context,
  288. (uint8_t const *)p_key,
  289. p_ctx->cbc.header.p_info->key_size);
  290. }
  291. break;
  292. #endif
  293. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  294. case NRF_CRYPTO_AES_MODE_CTR:
  295. /* Due to the nature of CFB / CTR, you should use the same key schedule for both
  296. encryption and decryption.*/
  297. error = mbedtls_aes_setkey_enc(&p_ctx->ctr.context,
  298. (uint8_t const *)p_key,
  299. p_ctx->ctr.header.p_info->key_size);
  300. break;
  301. #endif
  302. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  303. case NRF_CRYPTO_AES_MODE_CFB:
  304. /* Due to the nature of CFB / CTR, you should use the same key schedule for both
  305. encryption and decryption.*/
  306. error = mbedtls_aes_setkey_enc(&p_ctx->cfb.context,
  307. (uint8_t const *)p_key,
  308. p_ctx->cfb.header.p_info->key_size);
  309. break;
  310. #endif
  311. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  312. case NRF_CRYPTO_AES_MODE_ECB:
  313. case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
  314. if (p_ctx->ecb.backend.operation == NRF_CRYPTO_ENCRYPT)
  315. {
  316. error = mbedtls_aes_setkey_enc(&p_ctx->ecb.context,
  317. (uint8_t const *)p_key,
  318. p_ctx->ecb.header.p_info->key_size);
  319. }
  320. else
  321. {
  322. error = mbedtls_aes_setkey_dec(&p_ctx->ecb.context,
  323. (uint8_t const *)p_key,
  324. p_ctx->ecb.header.p_info->key_size);
  325. }
  326. break;
  327. #endif
  328. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  329. case NRF_CRYPTO_AES_MODE_CBC_MAC:
  330. case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
  331. error = mbedtls_aes_setkey_enc(&p_ctx->cbc_mac.context,
  332. (uint8_t const *)p_key,
  333. p_ctx->cbc_mac.header.p_info->key_size);
  334. break;
  335. #endif
  336. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  337. case NRF_CRYPTO_AES_MODE_CMAC:
  338. error = mbedtls_cipher_cmac_starts(&p_ctx->cmac.context,
  339. p_key,
  340. p_ctx->cmac.header.p_info->key_size);
  341. break;
  342. #endif
  343. default:
  344. return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
  345. }
  346. ret_val = result_get(error);
  347. return ret_val;
  348. }
  349. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC) || \
  350. NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR) || \
  351. NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB) || \
  352. NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  353. static ret_code_t backend_mbedtls_iv_set(void * const p_context, uint8_t * p_iv)
  354. {
  355. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  356. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  357. memcpy(&p_ctx->any.backend.iv[0], p_iv, sizeof(p_ctx->any.backend.iv));
  358. return NRF_SUCCESS;
  359. }
  360. static ret_code_t backend_mbedtls_iv_get(void * const p_context, uint8_t * p_iv)
  361. {
  362. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  363. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  364. memcpy(p_iv, p_ctx->any.backend.iv, sizeof(p_ctx->any.backend.iv));
  365. return NRF_SUCCESS;
  366. }
  367. #endif
  368. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  369. /* Function extending mbedtls_aes_crypt_ecb functionality. It allows to process more than 1
  370. data block. It is returning MBEDTLS error type. */
  371. static int backend_mbedtls_ecb_crypt(nrf_crypto_backend_aes_ecb_context_t * const p_ctx,
  372. uint8_t * p_text_in,
  373. uint8_t * p_text_out,
  374. size_t text_size)
  375. {
  376. int error = 0;
  377. size_t crypted_text = 0;
  378. if ((text_size & 0x0F) != 0)
  379. {
  380. return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
  381. }
  382. while (crypted_text < text_size)
  383. {
  384. error = mbedtls_aes_crypt_ecb(&p_ctx->context,
  385. (int)p_ctx->backend.operation,
  386. p_text_in + crypted_text,
  387. p_text_out + crypted_text);
  388. if (error != 0)
  389. {
  390. break;
  391. }
  392. crypted_text += NRF_CRYPTO_AES_BLOCK_SIZE;
  393. }
  394. return error;
  395. }
  396. #endif
  397. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  398. static int backend_mbedtls_cbc_mac_update(void * const p_context,
  399. uint8_t * p_data_in,
  400. size_t data_size,
  401. uint8_t * p_data_out)
  402. {
  403. int error = 0;
  404. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  405. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  406. for (size_t i = 0; i < data_size; i += NRF_CRYPTO_AES_BLOCK_SIZE)
  407. {
  408. error = mbedtls_aes_crypt_cbc(&p_ctx->cbc_mac.context,
  409. MBEDTLS_AES_ENCRYPT,
  410. NRF_CRYPTO_AES_BLOCK_SIZE,
  411. p_ctx->cbc_mac.backend.iv,
  412. (uint8_t const *)p_data_in + i,
  413. p_data_out);
  414. if (error != 0)
  415. {
  416. return error;
  417. }
  418. }
  419. return error;
  420. }
  421. static ret_code_t backend_mbedtls_cbc_mac_finalize(void * const p_context,
  422. uint8_t * p_data_in,
  423. size_t data_size,
  424. uint8_t * p_data_out,
  425. size_t * p_data_out_size)
  426. {
  427. int error;
  428. if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
  429. {
  430. return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
  431. }
  432. /* this function does not support padding */
  433. if ((data_size & 0xF) != 0)
  434. {
  435. return NRF_ERROR_CRYPTO_INPUT_LENGTH;
  436. }
  437. error = backend_mbedtls_cbc_mac_update(p_context, p_data_in, data_size, p_data_out);
  438. BACKEND_ERROR_CHECK(error);
  439. *p_data_out_size = NRF_CRYPTO_AES_BLOCK_SIZE;
  440. return NRF_SUCCESS;
  441. }
  442. static ret_code_t backend_mbedtls_cbc_mac_padding_finalize(void * const p_context,
  443. uint8_t * p_data_in,
  444. size_t data_size,
  445. uint8_t * p_data_out,
  446. size_t * p_data_out_size)
  447. {
  448. ret_code_t ret_val;
  449. uint8_t padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
  450. uint8_t msg_ending = (uint8_t)(data_size & (size_t)0x0F);
  451. if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
  452. {
  453. /* output buffer too small */
  454. return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
  455. }
  456. data_size -= msg_ending;
  457. if (data_size > 0)
  458. {
  459. ret_val = backend_mbedtls_cbc_mac_update(p_context,
  460. p_data_in,
  461. data_size,
  462. p_data_out);
  463. VERIFY_SUCCESS(ret_val);
  464. }
  465. ret_val = padding_pkcs7_add(&padding_buffer[0],
  466. p_data_in + data_size,
  467. msg_ending);
  468. VERIFY_SUCCESS(ret_val);
  469. ret_val = backend_mbedtls_cbc_mac_finalize(p_context,
  470. &padding_buffer[0],
  471. NRF_CRYPTO_AES_BLOCK_SIZE,
  472. p_data_out,
  473. p_data_out_size);
  474. VERIFY_SUCCESS(ret_val);
  475. return ret_val;
  476. }
  477. #endif
  478. static ret_code_t backend_mbedtls_update(void * const p_context,
  479. uint8_t * p_data_in,
  480. size_t data_size,
  481. uint8_t * p_data_out)
  482. {
  483. int error;
  484. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  485. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  486. switch (p_ctx->any.header.p_info->mode)
  487. {
  488. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  489. case NRF_CRYPTO_AES_MODE_CBC:
  490. case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
  491. error = mbedtls_aes_crypt_cbc(&p_ctx->cbc.context,
  492. (int)p_ctx->cbc.backend.operation,
  493. data_size,
  494. p_ctx->cbc.backend.iv,
  495. (uint8_t const *)p_data_in,
  496. p_data_out);
  497. break;
  498. #endif
  499. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  500. case NRF_CRYPTO_AES_MODE_CTR:
  501. {
  502. size_t nc_off = 0;
  503. uint8_t stream_block[NRF_CRYPTO_AES_BLOCK_SIZE];
  504. error = mbedtls_aes_crypt_ctr(&p_ctx->ctr.context,
  505. data_size,
  506. &nc_off,
  507. p_ctx->ctr.backend.iv,
  508. stream_block,
  509. (uint8_t const *)p_data_in,
  510. p_data_out);
  511. break;
  512. }
  513. #endif
  514. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  515. case NRF_CRYPTO_AES_MODE_CFB:
  516. error = mbedtls_aes_crypt_cfb8(&p_ctx->cfb.context,
  517. (int)p_ctx->cfb.backend.operation,
  518. data_size,
  519. p_ctx->cfb.backend.iv,
  520. (uint8_t const *)p_data_in,
  521. p_data_out);
  522. break;
  523. #endif
  524. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  525. case NRF_CRYPTO_AES_MODE_ECB:
  526. case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
  527. error = backend_mbedtls_ecb_crypt(&p_ctx->ecb, p_data_in, p_data_out, data_size);
  528. break;
  529. #endif
  530. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  531. case NRF_CRYPTO_AES_MODE_CBC_MAC:
  532. case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
  533. error = backend_mbedtls_cbc_mac_update(p_context, p_data_in, data_size, p_data_out);
  534. break;
  535. #endif
  536. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  537. case NRF_CRYPTO_AES_MODE_CMAC:
  538. error = mbedtls_cipher_cmac_update(&p_ctx->cmac.context,
  539. p_data_in,
  540. data_size);
  541. break;
  542. #endif
  543. default:
  544. return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
  545. }
  546. BACKEND_ERROR_CHECK(error);
  547. return NRF_SUCCESS;
  548. }
  549. static ret_code_t backend_mbedtls_finalize(void * const p_context,
  550. uint8_t * p_data_in,
  551. size_t data_size,
  552. uint8_t * p_data_out,
  553. size_t * p_data_out_size)
  554. {
  555. ret_code_t ret_val;
  556. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  557. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  558. if (*p_data_out_size < data_size)
  559. {
  560. return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
  561. }
  562. /* data is not multiple of 16 bytes */
  563. if ((data_size & 0x0F) != 0)
  564. {
  565. if ((p_ctx->any.header.p_info->mode != NRF_CRYPTO_AES_MODE_CTR) &&
  566. (p_ctx->any.header.p_info->mode != NRF_CRYPTO_AES_MODE_CFB))
  567. {
  568. /* There are separate handlers for AES modes with padding and for MAC modes. */
  569. return NRF_ERROR_CRYPTO_INPUT_LENGTH;
  570. }
  571. }
  572. ret_val = backend_mbedtls_update(p_context, p_data_in, data_size, p_data_out);
  573. VERIFY_SUCCESS(ret_val);
  574. *p_data_out_size = data_size;
  575. return ret_val;
  576. }
  577. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  578. static ret_code_t backend_mbedtls_cmac_finalize(void * const p_context,
  579. uint8_t * p_data_in,
  580. size_t data_size,
  581. uint8_t * p_data_out,
  582. size_t * p_data_out_size)
  583. {
  584. int error;
  585. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  586. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  587. if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
  588. {
  589. return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
  590. }
  591. error = mbedtls_cipher_cmac_update(&p_ctx->cmac.context, p_data_in, data_size);
  592. BACKEND_ERROR_CHECK(error);
  593. error = mbedtls_cipher_cmac_finish(&p_ctx->cmac.context, p_data_out);
  594. BACKEND_ERROR_CHECK(error);
  595. *p_data_out_size = NRF_CRYPTO_AES_BLOCK_SIZE;
  596. return NRF_SUCCESS;
  597. }
  598. #endif
  599. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC) || \
  600. NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  601. static ret_code_t backend_mbedtls_padding_finalize(void * const p_context,
  602. uint8_t * p_data_in,
  603. size_t data_size,
  604. uint8_t * p_data_out,
  605. size_t * p_data_out_size)
  606. {
  607. ret_code_t ret_val;
  608. size_t buff_out_size;
  609. uint8_t padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
  610. uint8_t msg_ending = (uint8_t)(data_size & (size_t)0x0F);
  611. nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
  612. (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
  613. if (p_ctx->any.backend.operation == NRF_CRYPTO_DECRYPT)
  614. {
  615. ret_val = backend_mbedtls_finalize(p_context,
  616. p_data_in,
  617. data_size,
  618. p_data_out,
  619. p_data_out_size);
  620. VERIFY_SUCCESS(ret_val);
  621. ret_val = padding_pkcs7_remove(p_data_out,
  622. p_data_out_size);
  623. return ret_val;
  624. }
  625. /* -------------- ENCRYPTION --------------*/
  626. data_size -= msg_ending;
  627. if (*p_data_out_size < (data_size + NRF_CRYPTO_AES_BLOCK_SIZE))
  628. {
  629. /* no space for padding */
  630. return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
  631. }
  632. if (data_size > 0)
  633. {
  634. /* Encrypt 16 byte blocks */
  635. ret_val = backend_mbedtls_update(p_context,
  636. p_data_in,
  637. data_size,
  638. p_data_out);
  639. VERIFY_SUCCESS(ret_val);
  640. }
  641. ret_val = padding_pkcs7_add(&padding_buffer[0],
  642. p_data_in + data_size,
  643. msg_ending);
  644. VERIFY_SUCCESS(ret_val);
  645. buff_out_size = *p_data_out_size - data_size;
  646. ret_val = backend_mbedtls_finalize(p_context,
  647. &padding_buffer[0],
  648. NRF_CRYPTO_AES_BLOCK_SIZE,
  649. p_data_out + data_size,
  650. &buff_out_size);
  651. VERIFY_SUCCESS(ret_val);
  652. *p_data_out_size = buff_out_size + data_size;
  653. return ret_val;
  654. }
  655. #endif
  656. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
  657. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_info =
  658. {
  659. .mode = NRF_CRYPTO_AES_MODE_CBC,
  660. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  661. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  662. .init_fn = backend_mbedtls_init,
  663. .uninit_fn = backend_mbedtls_uninit,
  664. .key_set_fn = backend_mbedtls_key_set,
  665. .iv_set_fn = backend_mbedtls_iv_set,
  666. .iv_get_fn = backend_mbedtls_iv_get,
  667. .update_fn = backend_mbedtls_update,
  668. .finalize_fn = backend_mbedtls_finalize
  669. };
  670. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_192_info =
  671. {
  672. .mode = NRF_CRYPTO_AES_MODE_CBC,
  673. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  674. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  675. .init_fn = backend_mbedtls_init,
  676. .uninit_fn = backend_mbedtls_uninit,
  677. .key_set_fn = backend_mbedtls_key_set,
  678. .iv_set_fn = backend_mbedtls_iv_set,
  679. .iv_get_fn = backend_mbedtls_iv_get,
  680. .update_fn = backend_mbedtls_update,
  681. .finalize_fn = backend_mbedtls_finalize
  682. };
  683. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_256_info =
  684. {
  685. .mode = NRF_CRYPTO_AES_MODE_CBC,
  686. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  687. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  688. .init_fn = backend_mbedtls_init,
  689. .uninit_fn = backend_mbedtls_uninit,
  690. .key_set_fn = backend_mbedtls_key_set,
  691. .iv_set_fn = backend_mbedtls_iv_set,
  692. .iv_get_fn = backend_mbedtls_iv_get,
  693. .update_fn = backend_mbedtls_update,
  694. .finalize_fn = backend_mbedtls_finalize
  695. };
  696. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_pad_pkcs7_info =
  697. {
  698. .mode = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
  699. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  700. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  701. .init_fn = backend_mbedtls_init,
  702. .uninit_fn = backend_mbedtls_uninit,
  703. .key_set_fn = backend_mbedtls_key_set,
  704. .iv_set_fn = backend_mbedtls_iv_set,
  705. .iv_get_fn = backend_mbedtls_iv_get,
  706. .update_fn = backend_mbedtls_update,
  707. .finalize_fn = backend_mbedtls_padding_finalize
  708. };
  709. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_192_pad_pkcs7_info =
  710. {
  711. .mode = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
  712. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  713. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  714. .init_fn = backend_mbedtls_init,
  715. .uninit_fn = backend_mbedtls_uninit,
  716. .key_set_fn = backend_mbedtls_key_set,
  717. .iv_set_fn = backend_mbedtls_iv_set,
  718. .iv_get_fn = backend_mbedtls_iv_get,
  719. .update_fn = backend_mbedtls_update,
  720. .finalize_fn = backend_mbedtls_padding_finalize
  721. };
  722. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_256_pad_pkcs7_info =
  723. {
  724. .mode = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
  725. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  726. .context_size = sizeof(nrf_crypto_backend_aes_cbc_context_t),
  727. .init_fn = backend_mbedtls_init,
  728. .uninit_fn = backend_mbedtls_uninit,
  729. .key_set_fn = backend_mbedtls_key_set,
  730. .iv_set_fn = backend_mbedtls_iv_set,
  731. .iv_get_fn = backend_mbedtls_iv_get,
  732. .update_fn = backend_mbedtls_update,
  733. .finalize_fn = backend_mbedtls_padding_finalize
  734. };
  735. #endif
  736. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
  737. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_128_info =
  738. {
  739. .mode = NRF_CRYPTO_AES_MODE_CTR,
  740. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  741. .context_size = sizeof(nrf_crypto_backend_aes_ctr_context_t),
  742. .init_fn = backend_mbedtls_init,
  743. .uninit_fn = backend_mbedtls_uninit,
  744. .key_set_fn = backend_mbedtls_key_set,
  745. .iv_set_fn = backend_mbedtls_iv_set,
  746. .iv_get_fn = backend_mbedtls_iv_get,
  747. .update_fn = backend_mbedtls_update,
  748. .finalize_fn = backend_mbedtls_finalize
  749. };
  750. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_192_info =
  751. {
  752. .mode = NRF_CRYPTO_AES_MODE_CTR,
  753. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  754. .context_size = sizeof(nrf_crypto_backend_aes_ctr_context_t),
  755. .init_fn = backend_mbedtls_init,
  756. .uninit_fn = backend_mbedtls_uninit,
  757. .key_set_fn = backend_mbedtls_key_set,
  758. .iv_set_fn = backend_mbedtls_iv_set,
  759. .iv_get_fn = backend_mbedtls_iv_get,
  760. .update_fn = backend_mbedtls_update,
  761. .finalize_fn = backend_mbedtls_finalize
  762. };
  763. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_256_info =
  764. {
  765. .mode = NRF_CRYPTO_AES_MODE_CTR,
  766. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  767. .context_size = sizeof(nrf_crypto_backend_aes_ctr_context_t),
  768. .init_fn = backend_mbedtls_init,
  769. .uninit_fn = backend_mbedtls_uninit,
  770. .key_set_fn = backend_mbedtls_key_set,
  771. .iv_set_fn = backend_mbedtls_iv_set,
  772. .iv_get_fn = backend_mbedtls_iv_get,
  773. .update_fn = backend_mbedtls_update,
  774. .finalize_fn = backend_mbedtls_finalize
  775. };
  776. #endif
  777. // CFB
  778. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
  779. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_128_info =
  780. {
  781. .mode = NRF_CRYPTO_AES_MODE_CFB,
  782. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  783. .context_size = sizeof(nrf_crypto_backend_aes_cfb_context_t),
  784. .init_fn = backend_mbedtls_init,
  785. .uninit_fn = backend_mbedtls_uninit,
  786. .key_set_fn = backend_mbedtls_key_set,
  787. .iv_set_fn = backend_mbedtls_iv_set,
  788. .iv_get_fn = backend_mbedtls_iv_get,
  789. .update_fn = backend_mbedtls_update,
  790. .finalize_fn = backend_mbedtls_finalize
  791. };
  792. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_192_info =
  793. {
  794. .mode = NRF_CRYPTO_AES_MODE_CFB,
  795. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  796. .context_size = sizeof(nrf_crypto_backend_aes_cfb_context_t),
  797. .init_fn = backend_mbedtls_init,
  798. .uninit_fn = backend_mbedtls_uninit,
  799. .key_set_fn = backend_mbedtls_key_set,
  800. .iv_set_fn = backend_mbedtls_iv_set,
  801. .iv_get_fn = backend_mbedtls_iv_get,
  802. .update_fn = backend_mbedtls_update,
  803. .finalize_fn = backend_mbedtls_finalize
  804. };
  805. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_256_info =
  806. {
  807. .mode = NRF_CRYPTO_AES_MODE_CFB,
  808. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  809. .context_size = sizeof(nrf_crypto_backend_aes_cfb_context_t),
  810. .init_fn = backend_mbedtls_init,
  811. .uninit_fn = backend_mbedtls_uninit,
  812. .key_set_fn = backend_mbedtls_key_set,
  813. .iv_set_fn = backend_mbedtls_iv_set,
  814. .iv_get_fn = backend_mbedtls_iv_get,
  815. .update_fn = backend_mbedtls_update,
  816. .finalize_fn = backend_mbedtls_finalize
  817. };
  818. #endif
  819. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
  820. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_info =
  821. {
  822. .mode = NRF_CRYPTO_AES_MODE_ECB,
  823. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  824. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  825. .init_fn = backend_mbedtls_init,
  826. .uninit_fn = backend_mbedtls_uninit,
  827. .key_set_fn = backend_mbedtls_key_set,
  828. .iv_set_fn = NULL,
  829. .iv_get_fn = NULL,
  830. .update_fn = backend_mbedtls_update,
  831. .finalize_fn = backend_mbedtls_finalize
  832. };
  833. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_192_info =
  834. {
  835. .mode = NRF_CRYPTO_AES_MODE_ECB,
  836. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  837. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  838. .init_fn = backend_mbedtls_init,
  839. .uninit_fn = backend_mbedtls_uninit,
  840. .key_set_fn = backend_mbedtls_key_set,
  841. .iv_set_fn = NULL,
  842. .iv_get_fn = NULL,
  843. .update_fn = backend_mbedtls_update,
  844. .finalize_fn = backend_mbedtls_finalize
  845. };
  846. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_256_info =
  847. {
  848. .mode = NRF_CRYPTO_AES_MODE_ECB,
  849. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  850. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  851. .init_fn = backend_mbedtls_init,
  852. .uninit_fn = backend_mbedtls_uninit,
  853. .key_set_fn = backend_mbedtls_key_set,
  854. .iv_set_fn = NULL,
  855. .iv_get_fn = NULL,
  856. .update_fn = backend_mbedtls_update,
  857. .finalize_fn = backend_mbedtls_finalize
  858. };
  859. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_pad_pkcs7_info =
  860. {
  861. .mode = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
  862. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  863. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  864. .init_fn = backend_mbedtls_init,
  865. .uninit_fn = backend_mbedtls_uninit,
  866. .key_set_fn = backend_mbedtls_key_set,
  867. .iv_set_fn = NULL,
  868. .iv_get_fn = NULL,
  869. .update_fn = backend_mbedtls_update,
  870. .finalize_fn = backend_mbedtls_padding_finalize
  871. };
  872. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_192_pad_pkcs7_info =
  873. {
  874. .mode = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
  875. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  876. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  877. .init_fn = backend_mbedtls_init,
  878. .uninit_fn = backend_mbedtls_uninit,
  879. .key_set_fn = backend_mbedtls_key_set,
  880. .iv_set_fn = NULL,
  881. .iv_get_fn = NULL,
  882. .update_fn = backend_mbedtls_update,
  883. .finalize_fn = backend_mbedtls_padding_finalize
  884. };
  885. nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_256_pad_pkcs7_info =
  886. {
  887. .mode = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
  888. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  889. .context_size = sizeof(nrf_crypto_backend_aes_ecb_context_t),
  890. .init_fn = backend_mbedtls_init,
  891. .uninit_fn = backend_mbedtls_uninit,
  892. .key_set_fn = backend_mbedtls_key_set,
  893. .iv_set_fn = NULL,
  894. .iv_get_fn = NULL,
  895. .update_fn = backend_mbedtls_update,
  896. .finalize_fn = backend_mbedtls_padding_finalize
  897. };
  898. #endif
  899. // CBC MAC
  900. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
  901. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_info =
  902. {
  903. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC,
  904. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  905. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  906. .init_fn = backend_mbedtls_init,
  907. .uninit_fn = backend_mbedtls_uninit,
  908. .key_set_fn = backend_mbedtls_key_set,
  909. .iv_set_fn = backend_mbedtls_iv_set,
  910. .iv_get_fn = backend_mbedtls_iv_get,
  911. .update_fn = backend_mbedtls_update,
  912. .finalize_fn = backend_mbedtls_cbc_mac_finalize
  913. };
  914. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_192_info =
  915. {
  916. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC,
  917. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  918. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  919. .init_fn = backend_mbedtls_init,
  920. .uninit_fn = backend_mbedtls_uninit,
  921. .key_set_fn = backend_mbedtls_key_set,
  922. .iv_set_fn = backend_mbedtls_iv_set,
  923. .iv_get_fn = backend_mbedtls_iv_get,
  924. .update_fn = backend_mbedtls_update,
  925. .finalize_fn = backend_mbedtls_cbc_mac_finalize
  926. };
  927. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_256_info =
  928. {
  929. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC,
  930. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  931. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  932. .init_fn = backend_mbedtls_init,
  933. .uninit_fn = backend_mbedtls_uninit,
  934. .key_set_fn = backend_mbedtls_key_set,
  935. .iv_set_fn = backend_mbedtls_iv_set,
  936. .iv_get_fn = backend_mbedtls_iv_get,
  937. .update_fn = backend_mbedtls_update,
  938. .finalize_fn = backend_mbedtls_cbc_mac_finalize
  939. };
  940. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_pad_pkcs7_info =
  941. {
  942. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
  943. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  944. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  945. .init_fn = backend_mbedtls_init,
  946. .uninit_fn = backend_mbedtls_uninit,
  947. .key_set_fn = backend_mbedtls_key_set,
  948. .iv_set_fn = backend_mbedtls_iv_set,
  949. .iv_get_fn = backend_mbedtls_iv_get,
  950. .update_fn = backend_mbedtls_update,
  951. .finalize_fn = backend_mbedtls_cbc_mac_padding_finalize
  952. };
  953. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_192_pad_pkcs7_info =
  954. {
  955. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
  956. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  957. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  958. .init_fn = backend_mbedtls_init,
  959. .uninit_fn = backend_mbedtls_uninit,
  960. .key_set_fn = backend_mbedtls_key_set,
  961. .iv_set_fn = backend_mbedtls_iv_set,
  962. .iv_get_fn = backend_mbedtls_iv_get,
  963. .update_fn = backend_mbedtls_update,
  964. .finalize_fn = backend_mbedtls_cbc_mac_padding_finalize
  965. };
  966. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_256_pad_pkcs7_info =
  967. {
  968. .mode = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
  969. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  970. .context_size = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
  971. .init_fn = backend_mbedtls_init,
  972. .uninit_fn = backend_mbedtls_uninit,
  973. .key_set_fn = backend_mbedtls_key_set,
  974. .iv_set_fn = backend_mbedtls_iv_set,
  975. .iv_get_fn = backend_mbedtls_iv_get,
  976. .update_fn = backend_mbedtls_update,
  977. .finalize_fn = backend_mbedtls_cbc_mac_padding_finalize
  978. };
  979. #endif
  980. // CMAC
  981. #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
  982. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_128_info =
  983. {
  984. .mode = NRF_CRYPTO_AES_MODE_CMAC,
  985. .key_size = NRF_CRYPTO_KEY_SIZE_128,
  986. .context_size = sizeof(nrf_crypto_backend_aes_cmac_context_t),
  987. .init_fn = backend_mbedtls_init,
  988. .uninit_fn = backend_mbedtls_uninit,
  989. .key_set_fn = backend_mbedtls_key_set,
  990. .iv_set_fn = NULL,
  991. .iv_get_fn = NULL,
  992. .update_fn = backend_mbedtls_update,
  993. .finalize_fn = backend_mbedtls_cmac_finalize
  994. };
  995. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_192_info =
  996. {
  997. .mode = NRF_CRYPTO_AES_MODE_CMAC,
  998. .key_size = NRF_CRYPTO_KEY_SIZE_192,
  999. .context_size = sizeof(nrf_crypto_backend_aes_cmac_context_t),
  1000. .init_fn = backend_mbedtls_init,
  1001. .uninit_fn = backend_mbedtls_uninit,
  1002. .key_set_fn = backend_mbedtls_key_set,
  1003. .iv_set_fn = NULL,
  1004. .iv_get_fn = NULL,
  1005. .update_fn = backend_mbedtls_update,
  1006. .finalize_fn = backend_mbedtls_cmac_finalize
  1007. };
  1008. nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_256_info =
  1009. {
  1010. .mode = NRF_CRYPTO_AES_MODE_CMAC,
  1011. .key_size = NRF_CRYPTO_KEY_SIZE_256,
  1012. .context_size = sizeof(nrf_crypto_backend_aes_cmac_context_t),
  1013. .init_fn = backend_mbedtls_init,
  1014. .uninit_fn = backend_mbedtls_uninit,
  1015. .key_set_fn = backend_mbedtls_key_set,
  1016. .iv_set_fn = NULL,
  1017. .iv_get_fn = NULL,
  1018. .update_fn = backend_mbedtls_update,
  1019. .finalize_fn = backend_mbedtls_cmac_finalize
  1020. };
  1021. #endif
  1022. #endif // #if NRF_MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES)
  1023. #endif // MODULE_ENABLED(NRF_CRYPTO)