1 /*
2 * Copyright (c) 2020 - 2024 Renesas Electronics Corporation and/or its affiliates
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 /***********************************************************************************************************************
8 * Includes <System Includes> , "Project Includes"
9 ***********************************************************************************************************************/
10 #include "hw_sce_ra_private.h"
11 #include "bsp_api.h"
12 #include <stdint.h>
13
14 /***********************************************************************************************************************
15 * Macro definitions
16 ***********************************************************************************************************************/
17
18 /* Waitting time to make sure calculation is finished
19 * Refer to Table 1.3 Numbers of Clock Cycles Required for Processing in the CCM Mode
20 * Waiting time for 91 Clock Cycles Required for Processing in the CCM Mode with PCLKB 32MHz
21 * Note: waiting for 91 clock cycles is still not enough for encryption of AES-CCM 256 bits key length.
22 * Must be to 120 clock cycles.
23 * */
24 #define HW_SCE_AES_CCM_WAITING_CYCLES (120U)
25 #define HW_SCE_FREQUENCY_IN_HZ (1000000U)
26
27 /***********************************************************************************************************************
28 * Typedef definitions
29 ***********************************************************************************************************************/
30
31 /***********************************************************************************************************************
32 * Imported global variables and functions
33 ***********************************************************************************************************************/
34
35 extern void HW_SCE_AesCcmEncryptKeyOperation(uint32_t * InData_KeyIndex,
36 uint32_t InData_KeyType,
37 uint32_t * InData_IV,
38 uint32_t InData_IVLength);
39
40 extern void HW_SCE_AesCcmDecryptKeyOperation(uint32_t * InData_KeyIndex,
41 uint32_t InData_KeyType,
42 uint32_t * InData_IV,
43 uint32_t InData_IVLength);
44
45 extern void HW_SCE_AesCcmEncryptCounterGenerate(uint32_t InData_TextLength,
46 uint32_t InData_Hdrlen,
47 uint32_t InData_MacLength,
48 uint32_t InData_IVLength);
49
50 extern void HW_SCE_AesCcmEncryptInputAssociatedData(uint32_t * InData_Header, uint32_t InData_Hdrlen);
51
52 extern void HW_SCE_AesCcmDecryptInputAssociatedData(uint32_t * InData_Header, uint32_t InData_Hdrlen);
53
54 extern void HW_SCE_AesCcmEncryptPlaintextInputInit();
55
56 extern void HW_SCE_AesCcmEncryptGenerateTag(uint32_t * OutData_MAC);
57
58 extern void hw_aes_ccm_decrypt_init(uint32_t indata_cmd);
59
60 /***********************************************************************************************************************
61 * Exported global variables
62 ***********************************************************************************************************************/
63
64 /***********************************************************************************************************************
65 * Private global variables and functions
66 ***********************************************************************************************************************/
67
68 static uint8_t InputData_DataA[SIZE_AES_GCM_IN_DATA_AAD_LEN_BYTES] = {0};
69 static uint8_t InputData_IV_GCM[SIZE_AES_GCM_IN_DATA_IV_GCM_LEN_BYTES] = {0};
70 static uint8_t InputData_IV_GCM_LEN_BYTES = 0;
71
change_endian_long(uint32_t a)72 uint32_t change_endian_long (uint32_t a)
73 {
74 return __REV(a);
75 }
76
77 /***********************************************************************************************************************
78 * Function Name: hw_aes_set_key
79 * Description : This function move the key from specified address (1st arg "key" to AES peripheral register with define
80 * length (2nd arg "KeyLen")
81 * Arguments : key : key data area
82 * KeyLen : key length in bits
83 * Return Value : None
84 ***********************************************************************************************************************/
hw_aes_set_key(uint8_t * key,uint32_t KeyLen)85 void hw_aes_set_key (uint8_t * key, uint32_t KeyLen)
86 {
87 uint16_t * ptr = (uint16_t *) key;
88
89 if (KeyLen > SIZE_AES_192BIT_KEYLEN_BYTES)
90 {
91 R_AES_B->AESKEY7.AESKEYH = *ptr;
92 R_AES_B->AESKEY7.AESKEYL = *(ptr + 1);
93 R_AES_B->AESKEY6.AESKEYH = *(ptr + 2);
94 R_AES_B->AESKEY6.AESKEYL = *(ptr + 3);
95 ptr += 4;
96 }
97
98 if (KeyLen > SIZE_AES_128BIT_KEYLEN_BYTES)
99 {
100 R_AES_B->AESKEY5.AESKEYH = *ptr;
101 R_AES_B->AESKEY5.AESKEYL = *(ptr + 1);
102 R_AES_B->AESKEY4.AESKEYH = *(ptr + 2);
103 R_AES_B->AESKEY4.AESKEYL = *(ptr + 3);
104 ptr += 4;
105 }
106
107 R_AES_B->AESKEY3.AESKEYH = *ptr;
108 R_AES_B->AESKEY3.AESKEYL = *(ptr + 1);
109 R_AES_B->AESKEY2.AESKEYH = *(ptr + 2);
110 R_AES_B->AESKEY2.AESKEYL = *(ptr + 3);
111 R_AES_B->AESKEY1.AESKEYH = *(ptr + 4);
112 R_AES_B->AESKEY1.AESKEYL = *(ptr + 5);
113 R_AES_B->AESKEY0.AESKEYH = *(ptr + 6);
114 R_AES_B->AESKEY0.AESKEYL = *(ptr + 7);
115 }
116
117 /***********************************************************************************************************************
118 * Function Name: hw_aes_set_iv
119 * Description : This function move Initialize vector from specified address (1st arg. "iv") to AES register.
120 * Arguments : iv : Initialization vector area (16 byte)
121 * Return Value : None
122 ***********************************************************************************************************************/
hw_aes_set_iv(uint8_t * initialize_vector)123 void hw_aes_set_iv (uint8_t * initialize_vector)
124 {
125 uint16_t * p_in = (uint16_t *) initialize_vector;
126
127 R_AES_B->AESIV3.AESIVH = *p_in;
128 R_AES_B->AESIV3.AESIVL = *(p_in + 1);
129 R_AES_B->AESIV2.AESIVH = *(p_in + 2);
130 R_AES_B->AESIV2.AESIVL = *(p_in + 3);
131 R_AES_B->AESIV1.AESIVH = *(p_in + 4);
132 R_AES_B->AESIV1.AESIVL = *(p_in + 5);
133 R_AES_B->AESIV0.AESIVH = *(p_in + 6);
134 R_AES_B->AESIV0.AESIVL = *(p_in + 7);
135 }
136
137 /***********************************************************************************************************************
138 * Function Name: hw_aes_set_plaintext
139 * Description : This function move input data from specified address(1st arg. "ptext") to AES Data Input register.
140 * Arguments : ptext : Input data area (block * 16bytes)
141 * Return Value : None
142 ***********************************************************************************************************************/
hw_aes_set_plaintext(uint8_t * ptext)143 static void hw_aes_set_plaintext (uint8_t * ptext)
144 {
145 uint16_t * p_in = (uint16_t *) ptext;
146
147 R_AES_B->AESIDAT3.AESIDATH = *p_in;
148 R_AES_B->AESIDAT3.AESIDATL = *(p_in + 1);
149 R_AES_B->AESIDAT2.AESIDATH = *(p_in + 2);
150 R_AES_B->AESIDAT2.AESIDATL = *(p_in + 3);
151 R_AES_B->AESIDAT1.AESIDATH = *(p_in + 4);
152 R_AES_B->AESIDAT1.AESIDATL = *(p_in + 5);
153 R_AES_B->AESIDAT0.AESIDATH = *(p_in + 6);
154 R_AES_B->AESIDAT0.AESIDATL = *(p_in + 7);
155 }
156
157 /***********************************************************************************************************************
158 * Function Name: hw_aes_get_ciphertext
159 * Description : This function move AES register output to specified address (1st arg. "output").
160 * Arguments : output : output data area (block * 16bytes)
161 * Return Value : None
162 ***********************************************************************************************************************/
hw_aes_get_ciphertext(uint8_t * output)163 static void hw_aes_get_ciphertext (uint8_t * output)
164 {
165 uint16_t * ptr;
166 ptr = (uint16_t *) output;
167
168 *ptr = R_AES_B->AESODAT3.AESODATH;
169 *(ptr + 1) = R_AES_B->AESODAT3.AESODATL;
170 *(ptr + 2) = R_AES_B->AESODAT2.AESODATH;
171 *(ptr + 3) = R_AES_B->AESODAT2.AESODATL;
172 *(ptr + 4) = R_AES_B->AESODAT1.AESODATH;
173 *(ptr + 5) = R_AES_B->AESODAT1.AESODATL;
174 *(ptr + 6) = R_AES_B->AESODAT0.AESODATH;
175 *(ptr + 7) = R_AES_B->AESODAT0.AESODATL;
176 }
177
hw_aes_start(uint8_t * input,uint8_t * output,uint32_t block)178 void hw_aes_start (uint8_t * input, uint8_t * output, uint32_t block)
179 {
180 uint8_t * ptr;
181 uint8_t * ptr_out;
182 uint32_t block_ctr = 0;
183
184 ptr = input;
185 ptr_out = output;
186 block_ctr = 0;
187 do
188 {
189 hw_aes_set_plaintext(ptr);
190 R_AES_B->AESDCNTL |= R_AES_AESDCNTL_CALCULATE_START;
191
192 while ((R_AES_B->AESSTSL & R_AES_AESSTSL_BIT_5) != 0)
193 {
194 ;
195 }
196
197 if ((R_AES_B->AESSTSL & R_AES_AESSTSL_CALCULATE_COMPLETED) != 0)
198 {
199 hw_aes_get_ciphertext(ptr_out);
200 R_AES_B->AESSTSCL = R_AES_AESSTSCL_DATA_CLEAN;
201 R_AES_B->AESDCNTL = 0;
202 }
203
204 ptr += 16;
205 ptr_out += 16;
206 block_ctr++;
207 } while (block_ctr < block);
208 }
209
210 /***********************************************************************************************************************
211 * Function Name: hw_aes_ccm_mode_start
212 * Description : This function move input data from specified address(1st arg. "input") to AES Data Input register
213 * and move AES register output to specified address(2nd arg. "output").
214 * In case 1st arg. "input" is NULL, this function move AES register output to "output" only.
215 * In case 2nd arg. "output" is NULL, this function move input data from "input" to AES Data Input register only.
216 * Arguments : input : Input data area (block * 16bytes)
217 * output: Output data area (block * 16bytes)
218 * Return Value : None
219 ***********************************************************************************************************************/
hw_aes_ccm_mode_start(uint8_t * input,uint8_t * output,uint32_t block)220 void hw_aes_ccm_mode_start (uint8_t * input, uint8_t * output, uint32_t block)
221 {
222 uint32_t block_ctr;
223 uint32_t system_clock_freq_mhz = R_FSP_SystemClockHzGet(FSP_PRIV_CLOCK_PCLKB) / HW_SCE_FREQUENCY_IN_HZ;
224
225 /* Round up the frequency to a whole number */
226 uint32_t delay_us = (HW_SCE_AES_CCM_WAITING_CYCLES + system_clock_freq_mhz - 1) / system_clock_freq_mhz;
227
228 for (block_ctr = 0; block_ctr < block; block_ctr++)
229 {
230 if (NULL != input)
231 {
232 hw_aes_set_plaintext(input);
233 R_AES_B->AESDCNTL |= R_AES_AESDCNTL_CALCULATE_START;
234 R_BSP_SoftwareDelay(delay_us, BSP_DELAY_UNITS_MICROSECONDS);
235 }
236
237 if (NULL != output)
238 {
239 hw_aes_get_ciphertext(output);
240 output += SIZE_AES_BLOCK_BYTES;
241 }
242
243 input += SIZE_AES_BLOCK_BYTES;
244 }
245 }
246
HW_SCE_GenerateAes128RandomKeyIndexSub(uint32_t * OutData_KeyIndex)247 fsp_err_t HW_SCE_GenerateAes128RandomKeyIndexSub (uint32_t * OutData_KeyIndex)
248 {
249 FSP_PARAMETER_NOT_USED(OutData_KeyIndex);
250
251 return FSP_ERR_UNSUPPORTED;
252 }
253
HW_SCE_GenerateAes192RandomKeyIndexSub(uint32_t * OutData_KeyIndex)254 fsp_err_t HW_SCE_GenerateAes192RandomKeyIndexSub (uint32_t * OutData_KeyIndex)
255 {
256 FSP_PARAMETER_NOT_USED(OutData_KeyIndex);
257
258 return FSP_ERR_UNSUPPORTED;
259 }
260
HW_SCE_GenerateAes256RandomKeyIndexSub(uint32_t * OutData_KeyIndex)261 fsp_err_t HW_SCE_GenerateAes256RandomKeyIndexSub (uint32_t * OutData_KeyIndex)
262 {
263 FSP_PARAMETER_NOT_USED(OutData_KeyIndex);
264
265 return FSP_ERR_UNSUPPORTED;
266 }
267
HW_SCE_Aes192EncryptDecryptInitSub(const uint32_t * InData_Cmd,const uint32_t * InData_KeyIndex,const uint32_t * InData_IV)268 fsp_err_t HW_SCE_Aes192EncryptDecryptInitSub (const uint32_t * InData_Cmd,
269 const uint32_t * InData_KeyIndex,
270 const uint32_t * InData_IV)
271 {
272 #if RM_TINYCRYPT_PORT_CFG_PARAM_CHECKING_ENABLE
273 if ((InData_Cmd == (const uint32_t *) 0) ||
274 (InData_KeyIndex == (const uint32_t *) 0) ||
275 (InData_IV == (const uint32_t *) 0))
276 {
277 return FSP_ERR_CRYPTO_SCE_FAIL;
278 }
279 #endif
280
281 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_192BIT_KEYLEN_BYTES);
282 hw_aes_set_iv((uint8_t *) InData_IV);
283 switch (change_endian_long(*InData_Cmd))
284 {
285 case SCE_AES_IN_DATA_CMD_CTR_ENCRYPTION_DECRYPTION:
286 {
287 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
288 R_AES_B->AESCNTL = R_AES_AESCNTL_CTR_192_ENC;
289 break;
290 }
291
292 case SCE_AES_IN_DATA_CMD_ECB_ENCRYPTION:
293 {
294 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
295 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_192_ENC;
296 break;
297 }
298
299 case SCE_AES_IN_DATA_CMD_ECB_DECRYPTION:
300 {
301 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
302 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_192_DEC;
303 break;
304 }
305
306 case SCE_AES_IN_DATA_CMD_CBC_ENCRYPTION:
307 {
308 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
309 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_192_ENC;
310 break;
311 }
312
313 case SCE_AES_IN_DATA_CMD_CBC_DECRYPTION:
314 {
315 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
316 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_192_DEC;
317 break;
318 }
319 }
320
321 return FSP_SUCCESS;
322 }
323
HW_SCE_Aes192EncryptDecryptUpdateSub(const uint32_t * InData_Text,uint32_t * OutData_Text,const uint32_t MAX_CNT)324 void HW_SCE_Aes192EncryptDecryptUpdateSub (const uint32_t * InData_Text, uint32_t * OutData_Text,
325 const uint32_t MAX_CNT)
326 {
327 hw_aes_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
328 }
329
HW_SCE_Aes192EncryptDecryptFinalSub(void)330 fsp_err_t HW_SCE_Aes192EncryptDecryptFinalSub (void)
331 {
332 while ((R_AES_B->AESSTSL & R_AES_AESSTSL_BIT_5) != 0)
333 {
334 ;
335 }
336
337 if ((R_AES_B->AESSTSL & R_AES_AESSTSL_CALCULATE_COMPLETED) != 0)
338 {
339 R_AES_B->AESSTSCL = R_AES_AESSTSCL_DATA_CLEAN;
340 R_AES_B->AESDCNTL = 0;
341 }
342
343 return FSP_SUCCESS;
344 }
345
HW_SCE_Aes128EncryptDecryptInitSub(const uint32_t * InData_KeyType,const uint32_t * InData_Cmd,const uint32_t * InData_KeyIndex,const uint32_t * InData_IV)346 fsp_err_t HW_SCE_Aes128EncryptDecryptInitSub (const uint32_t * InData_KeyType,
347 const uint32_t * InData_Cmd,
348 const uint32_t * InData_KeyIndex,
349 const uint32_t * InData_IV)
350 {
351 FSP_PARAMETER_NOT_USED(InData_KeyType);
352 #if RM_TINYCRYPT_PORT_CFG_PARAM_CHECKING_ENABLE
353 if ((InData_Cmd == (const uint32_t *) 0) ||
354 (InData_KeyIndex == (const uint32_t *) 0) ||
355 (InData_IV == (const uint32_t *) 0))
356 {
357 return FSP_ERR_CRYPTO_SCE_FAIL;
358 }
359 #endif
360
361 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_128BIT_KEYLEN_BYTES);
362 hw_aes_set_iv((uint8_t *) InData_IV);
363 switch (change_endian_long(*InData_Cmd))
364 {
365 case SCE_AES_IN_DATA_CMD_CTR_ENCRYPTION_DECRYPTION:
366 {
367 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
368 R_AES_B->AESCNTL = R_AES_AESCNTL_CTR_128_ENC;
369 break;
370 }
371
372 case SCE_AES_IN_DATA_CMD_ECB_ENCRYPTION:
373 {
374 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
375 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_128_ENC;
376 break;
377 }
378
379 case SCE_AES_IN_DATA_CMD_ECB_DECRYPTION:
380 {
381 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
382 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_128_DEC;
383 break;
384 }
385
386 case SCE_AES_IN_DATA_CMD_CBC_ENCRYPTION:
387 {
388 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
389 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_128_ENC;
390 break;
391 }
392
393 case SCE_AES_IN_DATA_CMD_CBC_DECRYPTION:
394 {
395 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
396 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_128_DEC;
397 break;
398 }
399 }
400
401 return FSP_SUCCESS;
402 }
403
HW_SCE_Aes128EncryptDecryptUpdateSub(const uint32_t * InData_Text,uint32_t * OutData_Text,const uint32_t MAX_CNT)404 void HW_SCE_Aes128EncryptDecryptUpdateSub (const uint32_t * InData_Text, uint32_t * OutData_Text,
405 const uint32_t MAX_CNT)
406 {
407 hw_aes_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
408 }
409
HW_SCE_Aes128EncryptDecryptFinalSub(void)410 fsp_err_t HW_SCE_Aes128EncryptDecryptFinalSub (void)
411 {
412 while ((R_AES_B->AESSTSL & R_AES_AESSTSL_BIT_5) != 0)
413 {
414 ;
415 }
416
417 if ((R_AES_B->AESSTSL & R_AES_AESSTSL_CALCULATE_COMPLETED) != 0)
418 {
419 R_AES_B->AESSTSCL = R_AES_AESSTSCL_DATA_CLEAN;
420 R_AES_B->AESDCNTL = 0;
421 }
422
423 return FSP_SUCCESS;
424 }
425
HW_SCE_Aes256EncryptDecryptInitSub(const uint32_t * InData_KeyType,const uint32_t * InData_Cmd,const uint32_t * InData_KeyIndex,const uint32_t * InData_IV)426 fsp_err_t HW_SCE_Aes256EncryptDecryptInitSub (const uint32_t * InData_KeyType,
427 const uint32_t * InData_Cmd,
428 const uint32_t * InData_KeyIndex,
429 const uint32_t * InData_IV)
430 {
431 FSP_PARAMETER_NOT_USED(InData_KeyType);
432 #if RM_TINYCRYPT_PORT_CFG_PARAM_CHECKING_ENABLE
433 if ((InData_Cmd == (const uint32_t *) 0) ||
434 (InData_KeyIndex == (const uint32_t *) 0) ||
435 (InData_IV == (const uint32_t *) 0))
436 {
437 return FSP_ERR_CRYPTO_SCE_FAIL;
438 }
439 #endif
440
441 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_256BIT_KEYLEN_BYTES);
442 hw_aes_set_iv((uint8_t *) InData_IV);
443 switch (change_endian_long(*InData_Cmd))
444 {
445 case SCE_AES_IN_DATA_CMD_CTR_ENCRYPTION_DECRYPTION:
446 {
447 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
448 R_AES_B->AESCNTL = R_AES_AESCNTL_CTR_256_ENC;
449 break;
450 }
451
452 case SCE_AES_IN_DATA_CMD_ECB_ENCRYPTION:
453 {
454 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
455 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_256_ENC;
456 break;
457 }
458
459 case SCE_AES_IN_DATA_CMD_ECB_DECRYPTION:
460 {
461 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
462 R_AES_B->AESCNTL = R_AES_AESCNTL_ECB_256_DEC;
463 break;
464 }
465
466 case SCE_AES_IN_DATA_CMD_CBC_ENCRYPTION:
467 {
468 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
469 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_256_ENC;
470 break;
471 }
472
473 case SCE_AES_IN_DATA_CMD_CBC_DECRYPTION:
474 {
475 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_2;
476 R_AES_B->AESCNTL = R_AES_AESCNTL_CBC_256_DEC;
477 break;
478 }
479 }
480
481 return FSP_SUCCESS;
482 }
483
HW_SCE_Aes256EncryptDecryptUpdateSub(const uint32_t * InData_Text,uint32_t * OutData_Text,const uint32_t MAX_CNT)484 void HW_SCE_Aes256EncryptDecryptUpdateSub (const uint32_t * InData_Text, uint32_t * OutData_Text,
485 const uint32_t MAX_CNT)
486 {
487 hw_aes_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
488 }
489
HW_SCE_Aes256EncryptDecryptFinalSub(void)490 fsp_err_t HW_SCE_Aes256EncryptDecryptFinalSub (void)
491 {
492 while ((R_AES_B->AESSTSL & R_AES_AESSTSL_BIT_5) != 0)
493 {
494 ;
495 }
496
497 if ((R_AES_B->AESSTSL & R_AES_AESSTSL_CALCULATE_COMPLETED) != 0)
498 {
499 R_AES_B->AESSTSCL = R_AES_AESSTSCL_DATA_CLEAN;
500 R_AES_B->AESDCNTL = 0;
501 }
502
503 return FSP_SUCCESS;
504 }
505
HW_SCE_Aes128GcmEncryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)506 fsp_err_t HW_SCE_Aes128GcmEncryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
507 {
508 FSP_PARAMETER_NOT_USED(InData_KeyType);
509 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_128_ENC;
510 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_128BIT_KEYLEN_BYTES);
511 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
512 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
513 memcpy(&InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
514
515 return FSP_SUCCESS;
516 }
517
HW_SCE_Aes128GcmEncryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)518 void HW_SCE_Aes128GcmEncryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
519 {
520 FSP_PARAMETER_NOT_USED(MAX_CNT);
521 if (InData_DataA != 0)
522 {
523 memcpy(&InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
524 }
525 }
526
HW_SCE_Aes128GcmEncryptUpdateTransitionSub(void)527 void HW_SCE_Aes128GcmEncryptUpdateTransitionSub (void)
528 {
529 }
530
HW_SCE_Aes128GcmEncryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)531 void HW_SCE_Aes128GcmEncryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
532 {
533 FSP_PARAMETER_NOT_USED(InData_Text);
534 FSP_PARAMETER_NOT_USED(OutData_Text);
535 FSP_PARAMETER_NOT_USED(MAX_CNT);
536 }
537
HW_SCE_Aes128GcmEncryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * OutData_Text,uint32_t * OutData_DataT)538 fsp_err_t HW_SCE_Aes128GcmEncryptFinalSub (uint32_t * InData_Text,
539 uint32_t * InData_DataALen,
540 uint32_t * InData_TextLen,
541 uint32_t * OutData_Text,
542 uint32_t * OutData_DataT)
543 {
544 fsp_err_t status;
545 status = hw_gcm_calculation((uint8_t *) InData_Text,
546 (uint8_t *) OutData_Text,
547 *InData_TextLen,
548 (uint8_t *) OutData_DataT,
549 &InputData_IV_GCM[0],
550 InputData_IV_GCM_LEN_BYTES,
551 &InputData_DataA[0],
552 *InData_DataALen);
553
554 return status;
555 }
556
HW_SCE_Aes128GcmDecryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)557 fsp_err_t HW_SCE_Aes128GcmDecryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
558 {
559 FSP_PARAMETER_NOT_USED(InData_KeyType);
560 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_128_DEC;
561 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_128BIT_KEYLEN_BYTES);
562 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
563 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
564 memcpy(&InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
565
566 return FSP_SUCCESS;
567 }
568
HW_SCE_Aes128GcmDecryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)569 void HW_SCE_Aes128GcmDecryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
570 {
571 FSP_PARAMETER_NOT_USED(MAX_CNT);
572 if (InData_DataA != 0)
573 {
574 memcpy(&InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
575 }
576 }
577
HW_SCE_Aes128GcmDecryptUpdateTransitionSub(void)578 void HW_SCE_Aes128GcmDecryptUpdateTransitionSub (void)
579 {
580 }
581
HW_SCE_Aes128GcmDecryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)582 void HW_SCE_Aes128GcmDecryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
583 {
584 FSP_PARAMETER_NOT_USED(InData_Text);
585 FSP_PARAMETER_NOT_USED(OutData_Text);
586 FSP_PARAMETER_NOT_USED(MAX_CNT);
587 }
588
HW_SCE_Aes128GcmDecryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataT,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * InData_DataTLen,uint32_t * OutData_Text)589 fsp_err_t HW_SCE_Aes128GcmDecryptFinalSub (uint32_t * InData_Text,
590 uint32_t * InData_DataT,
591 uint32_t * InData_DataALen,
592 uint32_t * InData_TextLen,
593 uint32_t * InData_DataTLen,
594 uint32_t * OutData_Text)
595 {
596 uint8_t Tag[16];
597 uint8_t temp;
598 fsp_err_t status;
599 uint8_t Target_Tag[16] = {0};
600 memcpy(&Target_Tag[0], InData_DataT, (uint8_t) *InData_DataTLen);
601
602 status = hw_gcm_calculation((uint8_t *) InData_Text,
603 (uint8_t *) OutData_Text,
604 *InData_TextLen,
605 &Tag[0],
606 &InputData_IV_GCM[0],
607 InputData_IV_GCM_LEN_BYTES,
608 &InputData_DataA[0],
609 *InData_DataALen);
610 if (status != FSP_SUCCESS)
611 {
612 return FSP_ERR_CRYPTO_UNKNOWN;
613 }
614
615 /* Athentication Tag Verification*/
616 if ((uint8_t) *InData_DataTLen != 0)
617 {
618 for (uint8_t iLoop = 0; iLoop < (uint8_t) *InData_DataTLen; iLoop++)
619 {
620 temp = Target_Tag[iLoop];
621 if (temp != Tag[iLoop])
622 {
623 status = FSP_ERR_INVALID_ARGUMENT;
624 break;
625 }
626 }
627
628 if (status == FSP_ERR_INVALID_ARGUMENT)
629 {
630 memset(OutData_Text, 0, *InData_TextLen);
631
632 return FSP_ERR_CRYPTO_UNKNOWN;
633 }
634 }
635
636 return FSP_SUCCESS;
637 }
638
HW_SCE_Aes192GcmEncryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)639 fsp_err_t HW_SCE_Aes192GcmEncryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
640 {
641 FSP_PARAMETER_NOT_USED(InData_KeyType);
642 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_192_ENC;
643 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_192BIT_KEYLEN_BYTES);
644 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
645 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
646 memcpy(&InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
647
648 return FSP_SUCCESS;
649 }
650
HW_SCE_Aes192GcmEncryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)651 void HW_SCE_Aes192GcmEncryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
652 {
653 FSP_PARAMETER_NOT_USED(MAX_CNT);
654 if (InData_DataA != 0)
655 {
656 memcpy(&InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
657 }
658 }
659
HW_SCE_Aes192GcmEncryptUpdateTransitionSub(void)660 void HW_SCE_Aes192GcmEncryptUpdateTransitionSub (void)
661 {
662 }
663
HW_SCE_Aes192GcmEncryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)664 void HW_SCE_Aes192GcmEncryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
665 {
666 FSP_PARAMETER_NOT_USED(InData_Text);
667 FSP_PARAMETER_NOT_USED(OutData_Text);
668 FSP_PARAMETER_NOT_USED(MAX_CNT);
669 }
670
HW_SCE_Aes192GcmEncryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * OutData_Text,uint32_t * OutData_DataT)671 fsp_err_t HW_SCE_Aes192GcmEncryptFinalSub (uint32_t * InData_Text,
672 uint32_t * InData_DataALen,
673 uint32_t * InData_TextLen,
674 uint32_t * OutData_Text,
675 uint32_t * OutData_DataT)
676 {
677 fsp_err_t status;
678 status = hw_gcm_calculation((uint8_t *) InData_Text,
679 (uint8_t *) OutData_Text,
680 *InData_TextLen,
681 (uint8_t *) OutData_DataT,
682 &InputData_IV_GCM[0],
683 InputData_IV_GCM_LEN_BYTES,
684 &InputData_DataA[0],
685 *InData_DataALen);
686
687 return status;
688 }
689
HW_SCE_Aes192GcmDecryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)690 fsp_err_t HW_SCE_Aes192GcmDecryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
691 {
692 FSP_PARAMETER_NOT_USED(InData_KeyType);
693 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_192_DEC;
694 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_192BIT_KEYLEN_BYTES);
695 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
696 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
697 memcpy(&InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
698
699 return FSP_SUCCESS;
700 }
701
HW_SCE_Aes192GcmDecryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)702 void HW_SCE_Aes192GcmDecryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
703 {
704 FSP_PARAMETER_NOT_USED(MAX_CNT);
705 if (InData_DataA != 0)
706 {
707 memcpy(&InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
708 }
709 }
710
HW_SCE_Aes192GcmDecryptUpdateTransitionSub(void)711 void HW_SCE_Aes192GcmDecryptUpdateTransitionSub (void)
712 {
713 }
714
HW_SCE_Aes192GcmDecryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)715 void HW_SCE_Aes192GcmDecryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
716 {
717 FSP_PARAMETER_NOT_USED(InData_Text);
718 FSP_PARAMETER_NOT_USED(OutData_Text);
719 FSP_PARAMETER_NOT_USED(MAX_CNT);
720 }
721
HW_SCE_Aes192GcmDecryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataT,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * InData_DataTLen,uint32_t * OutData_Text)722 fsp_err_t HW_SCE_Aes192GcmDecryptFinalSub (uint32_t * InData_Text,
723 uint32_t * InData_DataT,
724 uint32_t * InData_DataALen,
725 uint32_t * InData_TextLen,
726 uint32_t * InData_DataTLen,
727 uint32_t * OutData_Text)
728 {
729 uint8_t Tag[16];
730 uint8_t temp;
731 fsp_err_t status;
732 uint8_t Target_Tag[16] = {0};
733 memcpy(&Target_Tag[0], InData_DataT, (uint8_t) *InData_DataTLen);
734
735 status = hw_gcm_calculation((uint8_t *) InData_Text,
736 (uint8_t *) OutData_Text,
737 *InData_TextLen,
738 &Tag[0],
739 &InputData_IV_GCM[0],
740 InputData_IV_GCM_LEN_BYTES,
741 &InputData_DataA[0],
742 *InData_DataALen);
743 if (status != FSP_SUCCESS)
744 {
745 return FSP_ERR_CRYPTO_UNKNOWN;
746 }
747
748 /* Athentication Tag Verification*/
749 if (*InData_DataTLen != 0)
750 {
751 for (uint32_t iLoop = 0; iLoop < (uint8_t) *InData_DataTLen; iLoop++)
752 {
753 temp = Target_Tag[iLoop];
754 if (temp != Tag[iLoop])
755 {
756 status = FSP_ERR_INVALID_ARGUMENT;
757 break;
758 }
759 }
760
761 if (status == FSP_ERR_INVALID_ARGUMENT)
762 {
763 memset(OutData_Text, 0, *InData_TextLen);
764
765 return FSP_ERR_CRYPTO_UNKNOWN;
766 }
767 }
768
769 return FSP_SUCCESS;
770 }
771
HW_SCE_Aes256GcmEncryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)772 fsp_err_t HW_SCE_Aes256GcmEncryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
773 {
774 FSP_PARAMETER_NOT_USED(InData_KeyType);
775 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_256_ENC;
776 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_256BIT_KEYLEN_BYTES);
777 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
778 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
779 memcpy(&InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
780
781 return FSP_SUCCESS;
782 }
783
HW_SCE_Aes256GcmEncryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)784 void HW_SCE_Aes256GcmEncryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
785 {
786 FSP_PARAMETER_NOT_USED(MAX_CNT);
787 if (InData_DataA != 0)
788 {
789 memcpy(&InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
790 }
791 }
792
HW_SCE_Aes256GcmEncryptUpdateTransitionSub(void)793 void HW_SCE_Aes256GcmEncryptUpdateTransitionSub (void)
794 {
795 }
796
HW_SCE_Aes256GcmEncryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)797 void HW_SCE_Aes256GcmEncryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
798 {
799 FSP_PARAMETER_NOT_USED(InData_Text);
800 FSP_PARAMETER_NOT_USED(OutData_Text);
801 FSP_PARAMETER_NOT_USED(MAX_CNT);
802 }
803
HW_SCE_Aes256GcmEncryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * OutData_Text,uint32_t * OutData_DataT)804 fsp_err_t HW_SCE_Aes256GcmEncryptFinalSub (uint32_t * InData_Text,
805 uint32_t * InData_DataALen,
806 uint32_t * InData_TextLen,
807 uint32_t * OutData_Text,
808 uint32_t * OutData_DataT)
809 {
810 fsp_err_t status;
811 status = hw_gcm_calculation((uint8_t *) InData_Text,
812 (uint8_t *) OutData_Text,
813 *InData_TextLen,
814 (uint8_t *) OutData_DataT,
815 &InputData_IV_GCM[0],
816 InputData_IV_GCM_LEN_BYTES,
817 &InputData_DataA[0],
818 *InData_DataALen);
819
820 return status;
821 }
822
HW_SCE_Aes256GcmDecryptInitSub(uint32_t * InData_KeyType,uint32_t * InData_KeyIndex,uint32_t * InData_IV)823 fsp_err_t HW_SCE_Aes256GcmDecryptInitSub (uint32_t * InData_KeyType, uint32_t * InData_KeyIndex, uint32_t * InData_IV)
824 {
825 FSP_PARAMETER_NOT_USED(InData_KeyType);
826 R_AES_B->AESCNTL = R_AES_AESCNTL_GCM_256_DEC;
827 hw_aes_set_key((uint8_t *) InData_KeyIndex, SIZE_AES_256BIT_KEYLEN_BYTES);
828 R_AES_B->AESDCNTL = R_AES_AESDCNTL_BIT_2_3_MODE_1;
829 InputData_IV_GCM_LEN_BYTES = (uint8_t) *((unsigned int *) InData_KeyIndex + SCE_AES_GCM_IN_DATA_IV_LEN_LOC);
830 memcpy((uint8_t *) &InputData_IV_GCM[0], (uint8_t *) InData_IV, InputData_IV_GCM_LEN_BYTES);
831
832 return FSP_SUCCESS;
833 }
834
HW_SCE_Aes256GcmDecryptUpdateAADSub(uint32_t * InData_DataA,uint32_t MAX_CNT)835 void HW_SCE_Aes256GcmDecryptUpdateAADSub (uint32_t * InData_DataA, uint32_t MAX_CNT)
836 {
837 FSP_PARAMETER_NOT_USED(MAX_CNT);
838 if (InData_DataA != 0)
839 {
840 memcpy((uint8_t *) &InputData_DataA[0], (uint8_t *) InData_DataA, sizeof(InputData_DataA));
841 }
842 }
843
HW_SCE_Aes256GcmDecryptUpdateTransitionSub(void)844 void HW_SCE_Aes256GcmDecryptUpdateTransitionSub (void)
845 {
846 }
847
HW_SCE_Aes256GcmDecryptUpdateSub(uint32_t * InData_Text,uint32_t * OutData_Text,uint32_t MAX_CNT)848 void HW_SCE_Aes256GcmDecryptUpdateSub (uint32_t * InData_Text, uint32_t * OutData_Text, uint32_t MAX_CNT)
849 {
850 FSP_PARAMETER_NOT_USED(InData_Text);
851 FSP_PARAMETER_NOT_USED(OutData_Text);
852 FSP_PARAMETER_NOT_USED(MAX_CNT);
853 }
854
HW_SCE_Aes256GcmDecryptFinalSub(uint32_t * InData_Text,uint32_t * InData_DataT,uint32_t * InData_DataALen,uint32_t * InData_TextLen,uint32_t * InData_DataTLen,uint32_t * OutData_Text)855 fsp_err_t HW_SCE_Aes256GcmDecryptFinalSub (uint32_t * InData_Text,
856 uint32_t * InData_DataT,
857 uint32_t * InData_DataALen,
858 uint32_t * InData_TextLen,
859 uint32_t * InData_DataTLen,
860 uint32_t * OutData_Text)
861 {
862 uint8_t Tag[16];
863 uint8_t temp;
864 fsp_err_t status;
865 uint8_t Target_Tag[16] = {0};
866 memcpy(&Target_Tag[0], InData_DataT, (uint8_t) *InData_DataTLen);
867
868 status = hw_gcm_calculation((uint8_t *) InData_Text,
869 (uint8_t *) OutData_Text,
870 *InData_TextLen,
871 &Tag[0],
872 &InputData_IV_GCM[0],
873 InputData_IV_GCM_LEN_BYTES,
874 InputData_DataA,
875 *InData_DataALen);
876 if (status != 0)
877 {
878 return FSP_ERR_CRYPTO_UNKNOWN;
879 }
880
881 /* Athentication Tag Verification*/
882 if (*InData_DataTLen != 0)
883 {
884 for (uint32_t iLoop = 0; iLoop < (uint8_t) *InData_DataTLen; iLoop++)
885 {
886 temp = Target_Tag[iLoop];
887 if (temp != Tag[iLoop])
888 {
889 status = FSP_ERR_INVALID_ARGUMENT;
890 break;
891 }
892 }
893
894 if (status == FSP_ERR_INVALID_ARGUMENT)
895 {
896 memset(OutData_Text, 0, *InData_TextLen);
897
898 return FSP_ERR_CRYPTO_UNKNOWN;
899 }
900 }
901
902 return FSP_SUCCESS;
903 }
904
HW_SCE_Aes128CcmEncryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)905 fsp_err_t HW_SCE_Aes128CcmEncryptInitSub (const uint32_t InData_KeyType[],
906 const uint32_t InData_DataType[],
907 const uint32_t InData_Cmd[],
908 const uint32_t InData_TextLen[],
909 const uint32_t InData_KeyIndex[],
910 const uint32_t InData_IV[],
911 const uint32_t InData_Header[],
912 const uint32_t InData_SeqNum[],
913 const uint32_t Header_Len)
914 {
915 FSP_PARAMETER_NOT_USED(InData_KeyType);
916 FSP_PARAMETER_NOT_USED(InData_DataType);
917 FSP_PARAMETER_NOT_USED(InData_SeqNum);
918
919 uint32_t InData_IVLen = InData_Cmd[0];
920 uint32_t InData_MACLen = InData_Cmd[1];
921
922 /* Apply key operations */
923 HW_SCE_AesCcmEncryptKeyOperation((uint32_t *) InData_KeyIndex,
924 SIZE_AES_128BIT_KEYLEN_BYTES,
925 (uint32_t *) InData_IV,
926 InData_IVLen);
927
928 /* Formatting function and counter generation function */
929 HW_SCE_AesCcmEncryptCounterGenerate(*InData_TextLen, Header_Len, InData_MACLen, InData_IVLen);
930
931 /* Apply formating function with associated data */
932 HW_SCE_AesCcmEncryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
933
934 /* Plaintext input initialization */
935 HW_SCE_AesCcmEncryptPlaintextInputInit();
936
937 return FSP_SUCCESS;
938 }
939
HW_SCE_Aes192CcmEncryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)940 fsp_err_t HW_SCE_Aes192CcmEncryptInitSub (const uint32_t InData_KeyType[],
941 const uint32_t InData_DataType[],
942 const uint32_t InData_Cmd[],
943 const uint32_t InData_TextLen[],
944 const uint32_t InData_KeyIndex[],
945 const uint32_t InData_IV[],
946 const uint32_t InData_Header[],
947 const uint32_t InData_SeqNum[],
948 const uint32_t Header_Len)
949 {
950 FSP_PARAMETER_NOT_USED(InData_KeyType);
951 FSP_PARAMETER_NOT_USED(InData_DataType);
952 FSP_PARAMETER_NOT_USED(InData_SeqNum);
953
954 uint32_t InData_IVLen = InData_Cmd[0];
955 uint32_t InData_MACLen = InData_Cmd[1];
956
957 /* Apply key operations */
958 HW_SCE_AesCcmEncryptKeyOperation((uint32_t *) InData_KeyIndex,
959 SIZE_AES_192BIT_KEYLEN_BYTES,
960 (uint32_t *) InData_IV,
961 InData_IVLen);
962
963 /* Formatting function and counter generation function */
964 HW_SCE_AesCcmEncryptCounterGenerate(*InData_TextLen, Header_Len, InData_MACLen, InData_IVLen);
965
966 /* Apply formating function with associated data */
967 HW_SCE_AesCcmEncryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
968
969 /* Plaintext input initialization */
970 HW_SCE_AesCcmEncryptPlaintextInputInit();
971
972 return FSP_SUCCESS;
973 }
974
HW_SCE_Aes256CcmEncryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)975 fsp_err_t HW_SCE_Aes256CcmEncryptInitSub (const uint32_t InData_KeyType[],
976 const uint32_t InData_DataType[],
977 const uint32_t InData_Cmd[],
978 const uint32_t InData_TextLen[],
979 const uint32_t InData_KeyIndex[],
980 const uint32_t InData_IV[],
981 const uint32_t InData_Header[],
982 const uint32_t InData_SeqNum[],
983 const uint32_t Header_Len)
984 {
985 FSP_PARAMETER_NOT_USED(InData_KeyType);
986 FSP_PARAMETER_NOT_USED(InData_DataType);
987 FSP_PARAMETER_NOT_USED(InData_SeqNum);
988
989 uint32_t InData_IVLen = InData_Cmd[0];
990 uint32_t InData_MACLen = InData_Cmd[1];
991
992 /* Apply key operations */
993 HW_SCE_AesCcmEncryptKeyOperation((uint32_t *) InData_KeyIndex,
994 SIZE_AES_256BIT_KEYLEN_BYTES,
995 (uint32_t *) InData_IV,
996 InData_IVLen);
997
998 /* Formatting function and counter generation function */
999 HW_SCE_AesCcmEncryptCounterGenerate(*InData_TextLen, Header_Len, InData_MACLen, InData_IVLen);
1000
1001 /* Apply formating function with associated data */
1002 HW_SCE_AesCcmEncryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
1003
1004 /* Plaintext input initialization */
1005 HW_SCE_AesCcmEncryptPlaintextInputInit();
1006
1007 return FSP_SUCCESS;
1008 }
1009
HW_SCE_Aes128CcmEncryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1010 void HW_SCE_Aes128CcmEncryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1011 {
1012 hw_aes_ccm_mode_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
1013 }
1014
HW_SCE_Aes192CcmEncryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1015 void HW_SCE_Aes192CcmEncryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1016 {
1017 hw_aes_ccm_mode_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
1018 }
1019
HW_SCE_Aes256CcmEncryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1020 void HW_SCE_Aes256CcmEncryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1021 {
1022 hw_aes_ccm_mode_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
1023 }
1024
HW_SCE_Aes128CcmEncryptFinalSub(const uint32_t InData_Text[],uint32_t OutData_Text[],uint32_t OutData_MAC[])1025 fsp_err_t HW_SCE_Aes128CcmEncryptFinalSub (const uint32_t InData_Text[], uint32_t OutData_Text[],
1026 uint32_t OutData_MAC[])
1027 {
1028 FSP_PARAMETER_NOT_USED(InData_Text);
1029 FSP_PARAMETER_NOT_USED(OutData_Text);
1030
1031 /* Generate tag */
1032 HW_SCE_AesCcmEncryptGenerateTag(OutData_MAC);
1033
1034 return FSP_SUCCESS;
1035 }
1036
HW_SCE_Aes192CcmEncryptFinalSub(const uint32_t InData_Text[],uint32_t OutData_Text[],uint32_t OutData_MAC[])1037 fsp_err_t HW_SCE_Aes192CcmEncryptFinalSub (const uint32_t InData_Text[], uint32_t OutData_Text[],
1038 uint32_t OutData_MAC[])
1039 {
1040 FSP_PARAMETER_NOT_USED(InData_Text);
1041 FSP_PARAMETER_NOT_USED(OutData_Text);
1042
1043 /* Generate tag */
1044 HW_SCE_AesCcmEncryptGenerateTag(OutData_MAC);
1045
1046 return FSP_SUCCESS;
1047 }
1048
HW_SCE_Aes256CcmEncryptFinalSub(const uint32_t InData_Text[],uint32_t OutData_Text[],uint32_t OutData_MAC[])1049 fsp_err_t HW_SCE_Aes256CcmEncryptFinalSub (const uint32_t InData_Text[], uint32_t OutData_Text[],
1050 uint32_t OutData_MAC[])
1051 {
1052 FSP_PARAMETER_NOT_USED(InData_Text);
1053 FSP_PARAMETER_NOT_USED(OutData_Text);
1054
1055 /* Generate tag */
1056 HW_SCE_AesCcmEncryptGenerateTag(OutData_MAC);
1057
1058 return FSP_SUCCESS;
1059 }
1060
HW_SCE_Aes128CcmDecryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_MACLength[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)1061 fsp_err_t HW_SCE_Aes128CcmDecryptInitSub (const uint32_t InData_KeyType[],
1062 const uint32_t InData_DataType[],
1063 const uint32_t InData_Cmd[],
1064 const uint32_t InData_TextLen[],
1065 const uint32_t InData_MACLength[],
1066 const uint32_t InData_KeyIndex[],
1067 const uint32_t InData_IV[],
1068 const uint32_t InData_Header[],
1069 const uint32_t InData_SeqNum[],
1070 const uint32_t Header_Len)
1071 {
1072 FSP_PARAMETER_NOT_USED(InData_KeyType);
1073 FSP_PARAMETER_NOT_USED(InData_DataType);
1074 FSP_PARAMETER_NOT_USED(InData_Cmd);
1075 FSP_PARAMETER_NOT_USED(InData_SeqNum);
1076 uint32_t InData_IVLen = InData_Cmd[0];
1077
1078 if (*InData_DataType == 0)
1079 {
1080 FSP_PARAMETER_NOT_USED(InData_Header);
1081
1082 /* Apply key operations */
1083 uint8_t A_InData_IV[SIZE_AES_BLOCK_BYTES] = {0};
1084 memcpy(&A_InData_IV[SIZE_AES_BLOCK_BYTES - InData_IVLen], InData_IV, InData_IVLen);
1085 HW_SCE_AesCcmDecryptKeyOperation((uint32_t *) InData_KeyIndex,
1086 *InData_KeyType,
1087 (uint32_t *) A_InData_IV,
1088 SIZE_AES_128BIT_KEYLEN_BYTES);
1089
1090 /* Formatting function and counter generation function */
1091 HW_SCE_AesCcmDecryptCounterGenerate((*InData_TextLen - *InData_MACLength),
1092 Header_Len,
1093 *InData_MACLength,
1094 InData_IVLen);
1095 }
1096 else
1097 {
1098 FSP_PARAMETER_NOT_USED(InData_TextLen);
1099 FSP_PARAMETER_NOT_USED(InData_MACLength);
1100 FSP_PARAMETER_NOT_USED(InData_KeyIndex);
1101 FSP_PARAMETER_NOT_USED(InData_IV);
1102
1103 /* Apply formating function with associated data */
1104 HW_SCE_AesCcmDecryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
1105 }
1106
1107 return FSP_SUCCESS;
1108 }
1109
HW_SCE_Aes192CcmDecryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_MACLength[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)1110 fsp_err_t HW_SCE_Aes192CcmDecryptInitSub (const uint32_t InData_KeyType[],
1111 const uint32_t InData_DataType[],
1112 const uint32_t InData_Cmd[],
1113 const uint32_t InData_TextLen[],
1114 const uint32_t InData_MACLength[],
1115 const uint32_t InData_KeyIndex[],
1116 const uint32_t InData_IV[],
1117 const uint32_t InData_Header[],
1118 const uint32_t InData_SeqNum[],
1119 const uint32_t Header_Len)
1120 {
1121 FSP_PARAMETER_NOT_USED(InData_KeyType);
1122 FSP_PARAMETER_NOT_USED(InData_DataType);
1123 FSP_PARAMETER_NOT_USED(InData_Cmd);
1124 FSP_PARAMETER_NOT_USED(InData_SeqNum);
1125 uint32_t InData_IVLen = InData_Cmd[0];
1126
1127 if (*InData_DataType == 0)
1128 {
1129 FSP_PARAMETER_NOT_USED(InData_Header);
1130
1131 /* Apply key operations */
1132 uint8_t A_InData_IV[SIZE_AES_BLOCK_BYTES] = {0};
1133 memcpy(&A_InData_IV[SIZE_AES_BLOCK_BYTES - InData_IVLen], InData_IV, InData_IVLen);
1134 HW_SCE_AesCcmDecryptKeyOperation((uint32_t *) InData_KeyIndex,
1135 *InData_KeyType,
1136 (uint32_t *) A_InData_IV,
1137 SIZE_AES_128BIT_KEYLEN_BYTES);
1138
1139 /* Formatting function and counter generation function */
1140 HW_SCE_AesCcmDecryptCounterGenerate((*InData_TextLen - *InData_MACLength),
1141 Header_Len,
1142 *InData_MACLength,
1143 InData_IVLen);
1144 }
1145 else
1146 {
1147 FSP_PARAMETER_NOT_USED(InData_TextLen);
1148 FSP_PARAMETER_NOT_USED(InData_MACLength);
1149 FSP_PARAMETER_NOT_USED(InData_KeyIndex);
1150 FSP_PARAMETER_NOT_USED(InData_IV);
1151
1152 /* Apply formating function with associated data */
1153 HW_SCE_AesCcmDecryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
1154 }
1155
1156 return FSP_SUCCESS;
1157 }
1158
HW_SCE_Aes256CcmDecryptInitSub(const uint32_t InData_KeyType[],const uint32_t InData_DataType[],const uint32_t InData_Cmd[],const uint32_t InData_TextLen[],const uint32_t InData_MACLength[],const uint32_t InData_KeyIndex[],const uint32_t InData_IV[],const uint32_t InData_Header[],const uint32_t InData_SeqNum[],const uint32_t Header_Len)1159 fsp_err_t HW_SCE_Aes256CcmDecryptInitSub (const uint32_t InData_KeyType[],
1160 const uint32_t InData_DataType[],
1161 const uint32_t InData_Cmd[],
1162 const uint32_t InData_TextLen[],
1163 const uint32_t InData_MACLength[],
1164 const uint32_t InData_KeyIndex[],
1165 const uint32_t InData_IV[],
1166 const uint32_t InData_Header[],
1167 const uint32_t InData_SeqNum[],
1168 const uint32_t Header_Len)
1169 {
1170 FSP_PARAMETER_NOT_USED(InData_KeyType);
1171 FSP_PARAMETER_NOT_USED(InData_DataType);
1172 FSP_PARAMETER_NOT_USED(InData_Cmd);
1173 FSP_PARAMETER_NOT_USED(InData_SeqNum);
1174 uint32_t InData_IVLen = InData_Cmd[0];
1175
1176 if (*InData_DataType == 0)
1177 {
1178 FSP_PARAMETER_NOT_USED(InData_Header);
1179
1180 /* Apply key operations */
1181 uint8_t A_InData_IV[SIZE_AES_BLOCK_BYTES] = {0};
1182 memcpy(&A_InData_IV[SIZE_AES_BLOCK_BYTES - InData_IVLen], InData_IV, InData_IVLen);
1183 HW_SCE_AesCcmDecryptKeyOperation((uint32_t *) InData_KeyIndex,
1184 InData_KeyType[0],
1185 (uint32_t *) A_InData_IV,
1186 SIZE_AES_128BIT_KEYLEN_BYTES);
1187
1188 /* Formatting function and counter generation function */
1189 HW_SCE_AesCcmDecryptCounterGenerate((*InData_TextLen - *InData_MACLength),
1190 Header_Len,
1191 *InData_MACLength,
1192 InData_IVLen);
1193 }
1194 else
1195 {
1196 FSP_PARAMETER_NOT_USED(InData_TextLen);
1197 FSP_PARAMETER_NOT_USED(InData_MACLength);
1198 FSP_PARAMETER_NOT_USED(InData_KeyIndex);
1199 FSP_PARAMETER_NOT_USED(InData_IV);
1200
1201 /* Apply formating function with associated data */
1202 HW_SCE_AesCcmDecryptInputAssociatedData((uint32_t *) InData_Header, Header_Len);
1203 }
1204
1205 return FSP_SUCCESS;
1206 }
1207
HW_SCE_Aes128CcmDecryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1208 void HW_SCE_Aes128CcmDecryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1209 {
1210 /* CTR decryption */
1211 hw_aes_ccm_decrypt_init(SCE_AES_IN_DATA_CMD_CCM_DEC_CTR_DECRYPT);
1212 hw_aes_ccm_mode_start((uint8_t *) InData_Text, (uint8_t *) OutData_Text, MAX_CNT / 4);
1213 }
1214
HW_SCE_Aes192CcmDecryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1215 void HW_SCE_Aes192CcmDecryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1216 {
1217 HW_SCE_Aes128CcmDecryptUpdateSub(InData_Text, OutData_Text, MAX_CNT);
1218 }
1219
HW_SCE_Aes256CcmDecryptUpdateSub(const uint32_t InData_Text[],uint32_t OutData_Text[],const uint32_t MAX_CNT)1220 void HW_SCE_Aes256CcmDecryptUpdateSub (const uint32_t InData_Text[], uint32_t OutData_Text[], const uint32_t MAX_CNT)
1221 {
1222 HW_SCE_Aes128CcmDecryptUpdateSub(InData_Text, OutData_Text, MAX_CNT);
1223 }
1224
HW_SCE_Aes128CcmDecryptFinalSub(const uint32_t InData_Text[],const uint32_t InData_TextLen[],const uint32_t InData_MAC[],const uint32_t InData_MACLength[],uint32_t OutData_Text[])1225 fsp_err_t HW_SCE_Aes128CcmDecryptFinalSub (const uint32_t InData_Text[],
1226 const uint32_t InData_TextLen[],
1227 const uint32_t InData_MAC[],
1228 const uint32_t InData_MACLength[],
1229 uint32_t OutData_Text[])
1230 {
1231 fsp_err_t err = FSP_SUCCESS;
1232 bool mac_unaligned = !HW_32BIT_ALIGNED((uint32_t) &InData_Text[0]);
1233 bool dst_unaligned = !HW_32BIT_ALIGNED((uint32_t) &OutData_Text[0]);
1234 uint32_t payload_len = *InData_TextLen - *InData_MACLength;
1235 uint32_t block_num = HW_AES_DATA_FIT_TO_BLOCK_SIZE(payload_len) /
1236 SIZE_AES_BLOCK_BYTES;
1237 uint32_t payload_remain = HW_AES_DATA_GET_LAST_REMAINS(payload_len);
1238 uint8_t Yr[SIZE_AES_BLOCK_BYTES] = {0};
1239 uint8_t Tag[SIZE_AES_BLOCK_BYTES] = {0};
1240 uint8_t LSB_C_Tlen[SIZE_AES_BLOCK_BYTES] = {0};
1241
1242 FSP_PARAMETER_NOT_USED(InData_Text);
1243
1244 /* Formatting function for payload */
1245 /* SCE AES hardware configuration for formatting function for payload */
1246 hw_aes_ccm_decrypt_init(SCE_AES_IN_DATA_CMD_CCM_DEC_FORMAT_PAYLOAD);
1247 if ((true == dst_unaligned) || (true == mac_unaligned))
1248 {
1249 uint32_t data_tmp[SIZE_AES_BLOCK_BYTES / 4];
1250 uint8_t * p_buf_in = (uint8_t *) OutData_Text;
1251 uint8_t * p_local_in = (uint8_t *) data_tmp;
1252 uint32_t index;
1253
1254 for (index = 0; index < block_num; index++)
1255 {
1256 memset(p_local_in, 0, SIZE_AES_BLOCK_BYTES);
1257 memcpy(p_local_in, p_buf_in, SIZE_AES_BLOCK_BYTES);
1258 hw_aes_ccm_mode_start(p_local_in, NULL, SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1259 p_buf_in += SIZE_AES_BLOCK_BYTES;
1260 }
1261
1262 if (payload_remain)
1263 {
1264 p_local_in = (uint8_t *) data_tmp;
1265 memset(p_local_in, 0, SIZE_AES_BLOCK_BYTES);
1266 memcpy(p_local_in, p_buf_in, payload_remain);
1267 hw_aes_ccm_mode_start(p_local_in, NULL, SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1268 }
1269
1270 hw_aes_ccm_mode_start(NULL, &Yr[0], SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1271
1272 if (true == mac_unaligned)
1273 {
1274 p_local_in = (uint8_t *) data_tmp;
1275 memset(p_local_in, 0, SIZE_AES_BLOCK_BYTES);
1276 memcpy(p_local_in, (uint8_t *) InData_MAC, *InData_MACLength);
1277 memcpy(&LSB_C_Tlen[0], p_local_in, *InData_MACLength);
1278 }
1279 else
1280 {
1281 memcpy(&LSB_C_Tlen[0], InData_MAC, *InData_MACLength);
1282 }
1283 }
1284 else
1285 {
1286 /* Out is uint32_t aligned */
1287 uint8_t * p_buf_in = (uint8_t *) OutData_Text;
1288 if (block_num)
1289 {
1290 hw_aes_ccm_mode_start((uint8_t *) p_buf_in, (uint8_t *) NULL, block_num);
1291 p_buf_in += block_num * SIZE_AES_BLOCK_BYTES;
1292 }
1293
1294 if (payload_remain)
1295 {
1296 uint32_t InOut_DataTmp[SIZE_AES_BLOCK_BYTES / sizeof(uint32_t)];
1297 memset(InOut_DataTmp, 0, SIZE_AES_BLOCK_BYTES);
1298 memcpy(InOut_DataTmp, p_buf_in, payload_remain);
1299 hw_aes_ccm_mode_start((uint8_t *) InOut_DataTmp,
1300 (uint8_t *) NULL,
1301 SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1302 }
1303
1304 hw_aes_ccm_mode_start(NULL, &Yr[0], SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1305
1306 memcpy(&LSB_C_Tlen[0], InData_MAC, *InData_MACLength);
1307 }
1308
1309 /* SCE AES hardware configuration for TAG generation */
1310 hw_aes_ccm_decrypt_init(SCE_AES_IN_DATA_CMD_CCM_DEC_GENERATE_TAG);
1311 hw_aes_ccm_mode_start((uint8_t *) &LSB_C_Tlen[0], (uint8_t *) &Tag[0], SIZE_AES_BLOCK_BYTES / SIZE_AES_BLOCK_BYTES);
1312
1313 if (0 != memcmp(Tag, Yr, *InData_MACLength))
1314 {
1315 err = FSP_ERR_CRYPTO_SCE_VERIFY_FAIL;
1316 }
1317
1318 return err;
1319 }
1320
HW_SCE_Aes192CcmDecryptFinalSub(const uint32_t InData_Text[],const uint32_t InData_TextLen[],const uint32_t InData_MAC[],const uint32_t InData_MACLength[],uint32_t OutData_Text[])1321 fsp_err_t HW_SCE_Aes192CcmDecryptFinalSub (const uint32_t InData_Text[],
1322 const uint32_t InData_TextLen[],
1323 const uint32_t InData_MAC[],
1324 const uint32_t InData_MACLength[],
1325 uint32_t OutData_Text[])
1326 {
1327 fsp_err_t err = FSP_SUCCESS;
1328 err = HW_SCE_Aes128CcmDecryptFinalSub(InData_Text, InData_TextLen, InData_MAC, InData_MACLength, OutData_Text);
1329
1330 return err;
1331 }
1332
HW_SCE_Aes256CcmDecryptFinalSub(const uint32_t InData_Text[],const uint32_t InData_TextLen[],const uint32_t InData_MAC[],const uint32_t InData_MACLength[],uint32_t OutData_Text[])1333 fsp_err_t HW_SCE_Aes256CcmDecryptFinalSub (const uint32_t InData_Text[],
1334 const uint32_t InData_TextLen[],
1335 const uint32_t InData_MAC[],
1336 const uint32_t InData_MACLength[],
1337 uint32_t OutData_Text[])
1338 {
1339 fsp_err_t err = FSP_SUCCESS;
1340 err = HW_SCE_Aes128CcmDecryptFinalSub(InData_Text, InData_TextLen, InData_MAC, InData_MACLength, OutData_Text);
1341
1342 return err;
1343 }
1344
