1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "hks_test_cipher.h"
16 #include "hks_api.h"
17 #include "hks_param.h"
18 #include "hks_test_api_performance.h"
19 #include "hks_test_common.h"
20 #include "hks_test_log.h"
21
22 #define DEFAULT_AES_CIPHER_PLAIN_SIZE 1000
23 #define AES_DEFAULT_GCM_NONCE_LENGTH 12
24 #define AES_DEFAULT_AAD_LEN 4
25 #define DEFAULT_AES_LOCAL_PARAM_SET_OUT_SIZE 256
26 #define AES_LOCAL_KEY_SIZE_128 16
27 #define AES_LOCAL_KEY_SIZE_256 32
28
29 static const struct HksTestCipherParams g_testCipherParams[] = {
30 /* success: local aes256-gcm-none */
31 { 0, HKS_SUCCESS, { false, 0, false, 0 },
32 {
33 true, /* genKey params */
34 true, HKS_ALG_AES,
35 true, HKS_AES_KEY_SIZE_256,
36 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
37 false, 0,
38 true, HKS_PADDING_NONE,
39 true, HKS_MODE_GCM,
40 true, HKS_STORAGE_TEMP
41 },
42 { false, 0 },
43 {
44 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
45 true, HKS_ALG_AES,
46 true, HKS_KEY_PURPOSE_ENCRYPT,
47 false, 0,
48 true, HKS_PADDING_NONE,
49 true, HKS_MODE_GCM,
50 false, 0,
51 true, AES_DEFAULT_GCM_NONCE_LENGTH,
52 true, AES_DEFAULT_AAD_LEN,
53 true, false
54 },
55 {
56 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
57 true, HKS_ALG_AES,
58 true, HKS_KEY_PURPOSE_DECRYPT,
59 false, 0,
60 true, HKS_PADDING_NONE,
61 true, HKS_MODE_GCM,
62 false, 0,
63 true, AES_DEFAULT_GCM_NONCE_LENGTH,
64 true, AES_DEFAULT_AAD_LEN,
65 true, false
66 },
67 {
68 true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
69 {
70 true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
71 {
72 true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
73 {
74 true, AES_LOCAL_KEY_SIZE_256, true, AES_LOCAL_KEY_SIZE_256 }
75 },
76
77 /* success: aes256-gcm-none */
78 { 1, HKS_SUCCESS, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
79 {
80 true, /* genKey params */
81 true, HKS_ALG_AES,
82 true, HKS_AES_KEY_SIZE_256,
83 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
84 false, 0,
85 true, HKS_PADDING_NONE,
86 true, HKS_MODE_GCM,
87 false, 0
88 },
89 { false, 0 },
90 {
91 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
92 true, HKS_ALG_AES,
93 true, HKS_KEY_PURPOSE_ENCRYPT,
94 false, 0,
95 true, HKS_PADDING_NONE,
96 true, HKS_MODE_GCM,
97 false, 0,
98 true, AES_DEFAULT_GCM_NONCE_LENGTH,
99 true, AES_DEFAULT_AAD_LEN
100 },
101 {
102 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
103 true, HKS_ALG_AES,
104 true, HKS_KEY_PURPOSE_DECRYPT,
105 false, 0,
106 true, HKS_PADDING_NONE,
107 true, HKS_MODE_GCM,
108 false, 0,
109 true, AES_DEFAULT_GCM_NONCE_LENGTH,
110 true, AES_DEFAULT_AAD_LEN
111 },
112 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
113 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
114 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
115 { false, 0, false, 0 }
116 },
117 /* success: local aes256-gcm-none, aad not set */
118 { 2, HKS_SUCCESS, { false, 0, false, 0 },
119 {
120 true, /* genKey params */
121 true, HKS_ALG_AES,
122 true, HKS_AES_KEY_SIZE_256,
123 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
124 false, 0,
125 true, HKS_PADDING_NONE,
126 true, HKS_MODE_GCM,
127 true, HKS_STORAGE_TEMP
128 },
129 { false, 0 },
130 {
131 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
132 true, HKS_ALG_AES,
133 true, HKS_KEY_PURPOSE_ENCRYPT,
134 false, 0,
135 true, HKS_PADDING_NONE,
136 true, HKS_MODE_GCM,
137 false, 0,
138 true, AES_DEFAULT_GCM_NONCE_LENGTH,
139 false, 0,
140 true, false
141 },
142 {
143 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
144 true, HKS_ALG_AES,
145 true, HKS_KEY_PURPOSE_DECRYPT,
146 false, 0,
147 true, HKS_PADDING_NONE,
148 true, HKS_MODE_GCM,
149 false, 0,
150 true, AES_DEFAULT_GCM_NONCE_LENGTH,
151 false, 0,
152 true, false
153 },
154 {
155 true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
156 {
157 true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
158 {
159 true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
160 {
161 true, AES_LOCAL_KEY_SIZE_256, true, AES_LOCAL_KEY_SIZE_256 }
162 },
163 };
164
165 static const struct HksTestEncryptParams g_testEncryptParams[] = {
166 /* aes gcm nonce not set */
167 { 0, HKS_ERROR_CHECK_GET_NONCE_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
168 {
169 true, /* genKey params */
170 true, HKS_ALG_AES,
171 true, HKS_AES_KEY_SIZE_256,
172 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
173 false, 0,
174 true, HKS_PADDING_NONE,
175 true, HKS_MODE_GCM
176 },
177 { 0 },
178 {
179 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
180 true, HKS_ALG_AES,
181 true, HKS_KEY_PURPOSE_ENCRYPT,
182 false, 0,
183 true, HKS_PADDING_NONE,
184 true, HKS_MODE_GCM,
185 false, 0,
186 false, 0,
187 true, AES_DEFAULT_AAD_LEN,
188 false, true
189 },
190 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
191 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
192 { false, 0, false, 0 }
193 },
194
195 /* aes gcm nonce size invalid */
196 { 1, HKS_ERROR_INVALID_NONCE, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
197 {
198 true, /* genKey params */
199 true, HKS_ALG_AES,
200 true, HKS_AES_KEY_SIZE_256,
201 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
202 false, 0,
203 true, HKS_PADDING_NONE,
204 true, HKS_MODE_GCM
205 },
206 { 0 },
207 {
208 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
209 true, HKS_ALG_AES,
210 true, HKS_KEY_PURPOSE_ENCRYPT,
211 false, 0,
212 true, HKS_PADDING_NONE,
213 true, HKS_MODE_GCM,
214 false, 0,
215 true, AES_DEFAULT_GCM_NONCE_LENGTH - 1,
216 true, AES_DEFAULT_AAD_LEN,
217 false, true
218 },
219 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
220 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
221 { false, 0, false, 0 }
222 },
223
224 /* aes gcm aad not set */
225 { 2, HKS_SUCCESS, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
226 {
227 true, /* genKey params */
228 true, HKS_ALG_AES,
229 true, HKS_AES_KEY_SIZE_256,
230 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
231 false, 0,
232 true, HKS_PADDING_NONE,
233 true, HKS_MODE_GCM
234 },
235 { 0 },
236 {
237 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
238 true, HKS_ALG_AES,
239 true, HKS_KEY_PURPOSE_ENCRYPT,
240 false, 0,
241 true, HKS_PADDING_NONE,
242 true, HKS_MODE_GCM,
243 false, 0,
244 true, AES_DEFAULT_GCM_NONCE_LENGTH,
245 false, 0,
246 false, true
247 },
248 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
249 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
250 { false, 0, false, 0 }
251 },
252 /* aes gcm inSize == 0 */
253 { 3, HKS_ERROR_INVALID_ARGUMENT, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
254 {
255 true, /* genKey params */
256 true, HKS_ALG_AES,
257 true, HKS_AES_KEY_SIZE_256,
258 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
259 false, 0,
260 true, HKS_PADDING_NONE,
261 true, HKS_MODE_GCM
262 },
263 { 0 },
264 {
265 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
266 true, HKS_ALG_AES,
267 true, HKS_KEY_PURPOSE_ENCRYPT,
268 false, 0,
269 true, HKS_PADDING_NONE,
270 true, HKS_MODE_GCM,
271 false, 0,
272 true, AES_DEFAULT_GCM_NONCE_LENGTH,
273 true, AES_DEFAULT_AAD_LEN,
274 false, true
275 },
276 { true, 0, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
277 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
278 { false, 0, false, 0 }
279 },
280
281 /* aes gcm outSize too small */
282 { 4, HKS_ERROR_BUFFER_TOO_SMALL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
283 {
284 true, /* genKey params */
285 true, HKS_ALG_AES,
286 true, HKS_AES_KEY_SIZE_256,
287 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
288 false, 0,
289 true, HKS_PADDING_NONE,
290 true, HKS_MODE_GCM },
291 { 0 },
292 {
293 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
294 true, HKS_ALG_AES,
295 true, HKS_KEY_PURPOSE_ENCRYPT,
296 false, 0,
297 true, HKS_PADDING_NONE,
298 true, HKS_MODE_GCM,
299 false, 0,
300 true, AES_DEFAULT_GCM_NONCE_LENGTH,
301 true, AES_DEFAULT_AAD_LEN,
302 false, true
303 },
304 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
305 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 - 1, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 - 1 },
306 { false, 0, false, 0 }
307 },
308 };
309
310 static const struct HksTestDecryptParams g_testDecryptParams[] = {
311 /* aes gcm nonce not set */
312 { 0, HKS_ERROR_CHECK_GET_NONCE_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
313 {
314 true, /* genKey params */
315 true, HKS_ALG_AES,
316 true, HKS_AES_KEY_SIZE_256,
317 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
318 false, 0,
319 true, HKS_PADDING_NONE,
320 true, HKS_MODE_GCM
321 },
322 { 0 },
323 {
324 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
325 true, HKS_ALG_AES,
326 true, HKS_KEY_PURPOSE_DECRYPT,
327 false, 0,
328 true, HKS_PADDING_NONE,
329 true, HKS_MODE_GCM,
330 false, 0,
331 false, AES_DEFAULT_GCM_NONCE_LENGTH,
332 true, AES_DEFAULT_AAD_LEN,
333 false, true
334 },
335 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
336 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
337 { false, 0, false, 0 }
338 },
339
340 /* aes gcm nonce size invalid */
341 { 1, HKS_ERROR_INVALID_NONCE, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
342 {
343 true, /* genKey params */
344 true, HKS_ALG_AES,
345 true, HKS_AES_KEY_SIZE_256,
346 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
347 false, 0,
348 true, HKS_PADDING_NONE,
349 true, HKS_MODE_GCM
350 },
351 { 0 },
352 {
353 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
354 true, HKS_ALG_AES,
355 true, HKS_KEY_PURPOSE_DECRYPT,
356 false, 0,
357 true, HKS_PADDING_NONE,
358 true, HKS_MODE_GCM,
359 false, 0,
360 true, AES_DEFAULT_GCM_NONCE_LENGTH - 1,
361 true, AES_DEFAULT_AAD_LEN,
362 false, true
363 },
364 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
365 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
366 { false, 0, false, 0 }
367 },
368
369 /* aes gcm aad not set */
370 { 2, HKS_ERROR_CHECK_GET_AAD_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
371 {
372 true, /* genKey params */
373 true, HKS_ALG_AES,
374 true, HKS_AES_KEY_SIZE_256,
375 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
376 false, 0,
377 true, HKS_PADDING_NONE,
378 true, HKS_MODE_GCM
379 },
380 { 0 },
381 {
382 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
383 true, HKS_ALG_AES,
384 true, HKS_KEY_PURPOSE_DECRYPT,
385 false, 0,
386 true, HKS_PADDING_NONE,
387 true, HKS_MODE_GCM,
388 false, 0,
389 true, AES_DEFAULT_GCM_NONCE_LENGTH,
390 false, 0,
391 false, true
392 },
393 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
394 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
395 { false, 0, false, 0 }
396 },
397 /* aes gcm inSize <= 16 */
398 { 3, HKS_ERROR_INVALID_ARGUMENT, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
399 {
400 true, /* genKey params */
401 true, HKS_ALG_AES,
402 true, HKS_AES_KEY_SIZE_256,
403 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
404 false, 0,
405 true, HKS_PADDING_NONE,
406 true, HKS_MODE_GCM
407 },
408 { 0 },
409 {
410 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
411 true, HKS_ALG_AES,
412 true, HKS_KEY_PURPOSE_DECRYPT,
413 false, 0,
414 true, HKS_PADDING_NONE,
415 true, HKS_MODE_GCM,
416 false, 0,
417 true, AES_DEFAULT_GCM_NONCE_LENGTH,
418 true, AES_DEFAULT_AAD_LEN,
419 false, true
420 },
421 { true, 16, true, 16 },
422 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
423 { false, 0, false, 0 }
424 },
425
426 /* aes gcm outSize too small */
427 { 4, HKS_ERROR_BUFFER_TOO_SMALL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
428 {
429 true, /* genKey params */
430 true, HKS_ALG_AES,
431 true, HKS_AES_KEY_SIZE_256,
432 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
433 false, 0,
434 true, HKS_PADDING_NONE,
435 true, HKS_MODE_GCM
436 },
437 { 0 },
438 {
439 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
440 true, HKS_ALG_AES,
441 true, HKS_KEY_PURPOSE_DECRYPT,
442 false, 0,
443 true, HKS_PADDING_NONE,
444 true, HKS_MODE_GCM,
445 false, 0,
446 true, AES_DEFAULT_GCM_NONCE_LENGTH,
447 true, AES_DEFAULT_AAD_LEN,
448 false, true
449 },
450 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
451 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 - 1, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 -1 },
452 { false, 0, false, 0 }
453 },
454 };
455
ConstructDataToBlob(struct HksBlob ** inData,struct HksBlob ** outData,const struct HksTestBlobParams * inTextParams,const struct HksTestBlobParams * outTextParams)456 static int32_t ConstructDataToBlob(struct HksBlob **inData, struct HksBlob **outData,
457 const struct HksTestBlobParams *inTextParams, const struct HksTestBlobParams *outTextParams)
458 {
459 int32_t ret = TestConstuctBlob(inData,
460 inTextParams->blobExist,
461 inTextParams->blobSize,
462 inTextParams->blobDataExist,
463 inTextParams->blobDataSize);
464 HKS_TEST_ASSERT(ret == 0);
465
466 ret = TestConstuctBlob(outData,
467 outTextParams->blobExist,
468 outTextParams->blobSize,
469 outTextParams->blobDataExist,
470 outTextParams->blobDataSize);
471 HKS_TEST_ASSERT(ret == 0);
472 return ret;
473 }
474
Encrypt(struct CipherEncryptStructure * encryptStruct)475 static int32_t Encrypt(struct CipherEncryptStructure *encryptStruct)
476 {
477 int32_t ret;
478 struct HksParamSet *encryptParamSet = NULL;
479
480 if (encryptStruct->cipherParms->cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
481 struct TestRsaCipherParamSet rsaCipherParamStructure = {
482 &encryptParamSet,
483 encryptStruct->cipherParms->paramSetExist,
484 encryptStruct->cipherParms->setAlg, encryptStruct->cipherParms->alg,
485 encryptStruct->cipherParms->setPurpose, encryptStruct->cipherParms->purpose,
486 encryptStruct->cipherParms->setDigest, encryptStruct->cipherParms->digest,
487 encryptStruct->cipherParms->setPadding, encryptStruct->cipherParms->padding
488 };
489 ret = TestConstructRsaCipherParamSet(&rsaCipherParamStructure);
490 } else {
491 uint32_t ivSize = encryptStruct->cipherParms->ivSize;
492 uint32_t nonceSize = encryptStruct->cipherParms->nonceSize;
493 uint32_t aadSize = encryptStruct->cipherParms->aadSize;
494 if (ivSize != 0) {
495 ret = TestConstuctBlob(encryptStruct->ivData, true, ivSize, true, ivSize);
496 HKS_TEST_ASSERT(ret == 0);
497 }
498 if (nonceSize != 0) {
499 ret = TestConstuctBlob(encryptStruct->nonceData, true, nonceSize, true, nonceSize);
500 HKS_TEST_ASSERT(ret == 0);
501 }
502 if (aadSize != 0) {
503 ret = TestConstuctBlob(encryptStruct->aadData, true, aadSize, true, aadSize);
504 HKS_TEST_ASSERT(ret == 0);
505 }
506 struct AesCipherParamSetStructure enParamStruct = {
507 &encryptParamSet,
508 encryptStruct->cipherParms->paramSetExist,
509 encryptStruct->cipherParms->setAlg, encryptStruct->cipherParms->alg,
510 encryptStruct->cipherParms->setPurpose, encryptStruct->cipherParms->purpose,
511 encryptStruct->cipherParms->setPadding, encryptStruct->cipherParms->padding,
512 encryptStruct->cipherParms->setBlockMode, encryptStruct->cipherParms->mode,
513 encryptStruct->cipherParms->setIv, *(encryptStruct->ivData),
514 encryptStruct->cipherParms->setNonce, *(encryptStruct->nonceData),
515 encryptStruct->cipherParms->setAad, *(encryptStruct->aadData),
516 encryptStruct->cipherParms->setIsKeyAlias, encryptStruct->cipherParms->isKeyAlias
517 };
518 ret = TestConstructAesCipherParamSet(&enParamStruct);
519 HKS_TEST_ASSERT(ret == 0);
520 }
521
522 ret = HksEncryptRun(encryptStruct->keyAlias, encryptParamSet, encryptStruct->plainData, encryptStruct->cipherData,
523 encryptStruct->performTimes);
524 HksFreeParamSet(&encryptParamSet);
525 return ret;
526 }
527
DecryptCipher(struct CipherDecryptStructure * decryptStruct)528 static int32_t DecryptCipher(struct CipherDecryptStructure *decryptStruct)
529 {
530 int32_t ret = TestConstuctBlob(decryptStruct->decryptedData,
531 decryptStruct->cipherParms->decryptedTextParams.blobExist,
532 decryptStruct->cipherParms->decryptedTextParams.blobSize,
533 decryptStruct->cipherParms->decryptedTextParams.blobDataExist,
534 decryptStruct->cipherParms->decryptedTextParams.blobDataSize);
535 HKS_TEST_ASSERT(ret == 0);
536
537 struct HksParamSet *decryptParamSet = NULL;
538 if (decryptStruct->cipherParms->decryptParamSetParams.cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
539 struct TestRsaCipherParamSet rsaDeCipherParamStructure = {
540 &decryptParamSet,
541 decryptStruct->cipherParms->decryptParamSetParams.paramSetExist,
542 decryptStruct->cipherParms->decryptParamSetParams.setAlg,
543 decryptStruct->cipherParms->decryptParamSetParams.alg,
544 decryptStruct->cipherParms->decryptParamSetParams.setPurpose,
545 decryptStruct->cipherParms->decryptParamSetParams.purpose,
546 decryptStruct->cipherParms->decryptParamSetParams.setDigest,
547 decryptStruct->cipherParms->decryptParamSetParams.digest,
548 decryptStruct->cipherParms->decryptParamSetParams.setPadding,
549 decryptStruct->cipherParms->decryptParamSetParams.padding
550 };
551 ret = TestConstructRsaCipherParamSet(&rsaDeCipherParamStructure);
552 } else {
553 struct AesCipherParamSetStructure deParamStruct = {
554 &decryptParamSet,
555 decryptStruct->cipherParms->decryptParamSetParams.paramSetExist,
556 decryptStruct->cipherParms->decryptParamSetParams.setAlg,
557 decryptStruct->cipherParms->decryptParamSetParams.alg,
558 decryptStruct->cipherParms->decryptParamSetParams.setPurpose,
559 decryptStruct->cipherParms->decryptParamSetParams.purpose,
560 decryptStruct->cipherParms->decryptParamSetParams.setPadding,
561 decryptStruct->cipherParms->decryptParamSetParams.padding,
562 decryptStruct->cipherParms->decryptParamSetParams.setBlockMode,
563 decryptStruct->cipherParms->decryptParamSetParams.mode,
564 decryptStruct->cipherParms->decryptParamSetParams.setIv, decryptStruct->ivData,
565 decryptStruct->cipherParms->decryptParamSetParams.setNonce, decryptStruct->nonceData,
566 decryptStruct->cipherParms->decryptParamSetParams.setAad, decryptStruct->aadData,
567 decryptStruct->cipherParms->decryptParamSetParams.setIsKeyAlias,
568 decryptStruct->cipherParms->decryptParamSetParams.isKeyAlias
569 };
570 ret = TestConstructAesCipherParamSet(&deParamStruct);
571 HKS_TEST_ASSERT(ret == 0);
572 }
573
574 ret = HksDecryptRun(decryptStruct->keyAlias, decryptParamSet, decryptStruct->cipherData,
575 *(decryptStruct->decryptedData), decryptStruct->performTimes);
576 HksFreeParamSet(&decryptParamSet);
577 return ret;
578 }
579
Decrypt(struct OnlyDecryptStructure * onlyDecryptStruct)580 static int32_t Decrypt(struct OnlyDecryptStructure *onlyDecryptStruct)
581 {
582 struct HksParamSet *decryptParamSet = NULL;
583 int32_t ret;
584 if (onlyDecryptStruct->cipherParms->cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
585 struct TestRsaCipherParamSet rsaCipherParamStructure = {
586 &decryptParamSet,
587 onlyDecryptStruct->cipherParms->paramSetExist,
588 onlyDecryptStruct->cipherParms->setAlg, onlyDecryptStruct->cipherParms->alg,
589 onlyDecryptStruct->cipherParms->setPurpose, onlyDecryptStruct->cipherParms->purpose,
590 onlyDecryptStruct->cipherParms->setDigest, onlyDecryptStruct->cipherParms->digest,
591 onlyDecryptStruct->cipherParms->setPadding, onlyDecryptStruct->cipherParms->padding
592 };
593 ret = TestConstructRsaCipherParamSet(&rsaCipherParamStructure);
594 } else {
595 uint32_t ivSize = onlyDecryptStruct->cipherParms->ivSize;
596 uint32_t nonceSize = onlyDecryptStruct->cipherParms->nonceSize;
597 uint32_t aadSize = onlyDecryptStruct->cipherParms->aadSize;
598 if (ivSize != 0) {
599 ret = TestConstuctBlob(onlyDecryptStruct->ivData, true, ivSize, true, ivSize);
600 HKS_TEST_ASSERT(ret == 0);
601 }
602 if (nonceSize != 0) {
603 ret = TestConstuctBlob(onlyDecryptStruct->nonceData, true, nonceSize, true, nonceSize);
604 HKS_TEST_ASSERT(ret == 0);
605 }
606 if (aadSize != 0) {
607 ret = TestConstuctBlob(onlyDecryptStruct->aadData, true, aadSize, true, aadSize);
608 HKS_TEST_ASSERT(ret == 0);
609 }
610 struct AesCipherParamSetStructure onlyDeParamStruct = {
611 &decryptParamSet,
612 onlyDecryptStruct->cipherParms->paramSetExist,
613 onlyDecryptStruct->cipherParms->setAlg, onlyDecryptStruct->cipherParms->alg,
614 onlyDecryptStruct->cipherParms->setPurpose, onlyDecryptStruct->cipherParms->purpose,
615 onlyDecryptStruct->cipherParms->setPadding, onlyDecryptStruct->cipherParms->padding,
616 onlyDecryptStruct->cipherParms->setBlockMode, onlyDecryptStruct->cipherParms->mode,
617 onlyDecryptStruct->cipherParms->setIv, *(onlyDecryptStruct->ivData),
618 onlyDecryptStruct->cipherParms->setNonce, *(onlyDecryptStruct->nonceData),
619 onlyDecryptStruct->cipherParms->setAad, *(onlyDecryptStruct->aadData),
620 onlyDecryptStruct->cipherParms->setIsKeyAlias, onlyDecryptStruct->cipherParms->isKeyAlias
621 };
622 ret = TestConstructAesCipherParamSet(&onlyDeParamStruct);
623 }
624 HKS_TEST_ASSERT(ret == 0);
625
626 ret = HksDecryptRun(onlyDecryptStruct->keyAlias, decryptParamSet, onlyDecryptStruct->cipherData,
627 onlyDecryptStruct->decryptedData, onlyDecryptStruct->performTimes);
628 HksFreeParamSet(&decryptParamSet);
629 return ret;
630 }
631
632
BaseTestCipher(uint32_t times,uint32_t index,uint32_t performTimes)633 int32_t BaseTestCipher(uint32_t times, uint32_t index, uint32_t performTimes)
634 {
635 /* 1. generate key */
636 struct HksBlob *keyAlias = NULL;
637 int32_t ret;
638 if ((g_testCipherParams[index].genKeyParamSetParams.setKeyStorageFlag) &&
639 g_testCipherParams[index].genKeyParamSetParams.keyStorageFlag == HKS_STORAGE_TEMP) {
640 ret = GenerateLocalRandomKey(&keyAlias, &g_testCipherParams[index].localKeyParams);
641 } else {
642 ret = HuksGenerateKey(&keyAlias, &g_testCipherParams[index].keyAliasParams,
643 &g_testCipherParams[index].genKeyParamSetParams, &g_testCipherParams[index].genKeyParamSetParamsOut);
644 }
645 HKS_TEST_ASSERT(ret == 0);
646 struct HksBlob *plainData = NULL;
647 struct HksBlob *cipherData = NULL;
648 ret = ConstructDataToBlob(&plainData, &cipherData,
649 &g_testCipherParams[index].plainTextParams, &g_testCipherParams[index].cipherTextParams);
650 HKS_TEST_ASSERT(ret == 0);
651 struct HksBlob *ivData = NULL;
652 struct HksBlob *nonceData = NULL;
653 struct HksBlob *aadData = NULL;
654 /* 2. encrypt */
655 struct CipherEncryptStructure testEncryptStruct = {
656 keyAlias, &g_testCipherParams[index].encryptParamSetParams,
657 plainData, cipherData, &ivData, &nonceData, &aadData, performTimes
658 };
659 ret = Encrypt(&testEncryptStruct);
660 HKS_TEST_ASSERT(ret == g_testCipherParams[index].expectResult);
661
662 /* 3. decrypt */
663 struct HksBlob *decryptedData = NULL;
664 struct CipherDecryptStructure testDecryptStruct = {
665 keyAlias, &g_testCipherParams[index], cipherData,
666 &decryptedData, ivData, nonceData, aadData, performTimes
667 };
668 ret = DecryptCipher(&testDecryptStruct);
669 HKS_TEST_ASSERT(ret == g_testCipherParams[index].expectResult);
670
671 HKS_TEST_ASSERT(plainData->size == decryptedData->size);
672 HKS_TEST_ASSERT(memcmp(plainData->data, decryptedData->data, plainData->size) == 0);
673 if (!((g_testCipherParams[index].genKeyParamSetParams.setKeyStorageFlag) &&
674 g_testCipherParams[index].genKeyParamSetParams.keyStorageFlag == HKS_STORAGE_TEMP)) {
675 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
676 }
677 TestFreeBlob(&keyAlias);
678 TestFreeBlob(&plainData);
679 TestFreeBlob(&cipherData);
680 TestFreeBlob(&decryptedData);
681 TestFreeBlob(&ivData);
682 TestFreeBlob(&nonceData);
683 TestFreeBlob(&aadData);
684 return (ret != g_testCipherParams[index].expectResult);
685 }
686
BaseTestEncrypt(uint32_t times,uint32_t index,uint32_t performTimes)687 int32_t BaseTestEncrypt(uint32_t times, uint32_t index, uint32_t performTimes)
688 {
689 /* 1. generate key */
690 struct HksBlob *keyAlias = NULL;
691 int32_t ret;
692 if (g_testEncryptParams[index].encryptParamSetParams.setIsKeyAlias &&
693 !g_testEncryptParams[index].encryptParamSetParams.isKeyAlias) {
694 ret = GenerateLocalRandomKey(&keyAlias, &g_testEncryptParams[index].localKeyParams);
695 } else {
696 if (g_testEncryptParams[index].keyAliasParams.blobExist) {
697 ret = HuksGenerateKey(&keyAlias, &g_testEncryptParams[index].keyAliasParams,
698 &g_testEncryptParams[index].genKeyParamSetParams, NULL);
699 } else {
700 ret = TestConstuctBlob(&keyAlias,
701 g_testEncryptParams[index].encryptAliasParams.blobExist,
702 g_testEncryptParams[index].encryptAliasParams.blobSize,
703 g_testEncryptParams[index].encryptAliasParams.blobDataExist,
704 g_testEncryptParams[index].encryptAliasParams.blobDataSize);
705 }
706 }
707 HKS_TEST_ASSERT(ret == 0);
708
709 struct HksBlob *plainData = NULL;
710 struct HksBlob *cipherData = NULL;
711 ret = ConstructDataToBlob(&plainData, &cipherData,
712 &g_testEncryptParams[index].inDataParams, &g_testEncryptParams[index].outDataParams);
713 HKS_TEST_ASSERT(ret == 0);
714
715 struct HksBlob *ivData = NULL;
716 struct HksBlob *nonceData = NULL;
717 struct HksBlob *aadData = NULL;
718 /* 2. encrypt */
719 struct CipherEncryptStructure encryptStruct = {
720 keyAlias, &g_testEncryptParams[index].encryptParamSetParams, plainData, cipherData, &ivData,
721 &nonceData, &aadData, performTimes
722 };
723 ret = Encrypt(&encryptStruct);
724 HKS_TEST_ASSERT(ret == g_testEncryptParams[index].expectResult);
725
726 /* 4. delete key */
727 if (g_testEncryptParams[index].keyAliasParams.blobExist) {
728 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
729 }
730 TestFreeBlob(&keyAlias);
731 TestFreeBlob(&plainData);
732 TestFreeBlob(&cipherData);
733 TestFreeBlob(&ivData);
734 TestFreeBlob(&nonceData);
735 TestFreeBlob(&aadData);
736 return (ret != g_testEncryptParams[index].expectResult);
737 }
738
BaseTestDecrypt(uint32_t times,uint32_t index,uint32_t performTimes)739 int32_t BaseTestDecrypt(uint32_t times, uint32_t index, uint32_t performTimes)
740 {
741 /* 1. generate key */
742 struct HksBlob *keyAlias = NULL;
743 int32_t ret;
744 if (g_testDecryptParams[index].decryptParamSetParams.setIsKeyAlias &&
745 !g_testDecryptParams[index].decryptParamSetParams.isKeyAlias) {
746 ret = GenerateLocalRandomKey(&keyAlias, &g_testDecryptParams[index].localKeyParams);
747 } else {
748 if (g_testDecryptParams[index].keyAliasParams.blobExist) {
749 ret = HuksGenerateKey(&keyAlias, &g_testDecryptParams[index].keyAliasParams,
750 &g_testDecryptParams[index].genKeyParamSetParams, NULL);
751 } else {
752 ret = TestConstuctBlob(&keyAlias,
753 g_testDecryptParams[index].decryptAliasParams.blobExist,
754 g_testDecryptParams[index].decryptAliasParams.blobSize,
755 g_testDecryptParams[index].decryptAliasParams.blobDataExist,
756 g_testDecryptParams[index].decryptAliasParams.blobDataSize);
757 }
758 }
759 HKS_TEST_ASSERT(ret == 0);
760
761 struct HksBlob *cipherData = NULL;
762 struct HksBlob *decryptedData = NULL;
763 ret = ConstructDataToBlob(&cipherData, &decryptedData,
764 &g_testDecryptParams[index].inDataParams, &g_testDecryptParams[index].outDataParams);
765 HKS_TEST_ASSERT(ret == 0);
766
767 struct HksBlob *ivData = NULL;
768 struct HksBlob *nonceData = NULL;
769 struct HksBlob *aadData = NULL;
770 /* 3. encrypt */
771 struct OnlyDecryptStructure onlyDecryptStruct = {
772 keyAlias, &g_testDecryptParams[index].decryptParamSetParams, cipherData, decryptedData, &ivData,
773 &nonceData, &aadData, performTimes
774 };
775 ret = Decrypt(&onlyDecryptStruct);
776 HKS_TEST_ASSERT(ret == g_testDecryptParams[index].expectResult);
777
778 /* 4. delete key */
779 if (g_testDecryptParams[index].keyAliasParams.blobExist) {
780 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
781 }
782 TestFreeBlob(&keyAlias);
783 TestFreeBlob(&decryptedData);
784 TestFreeBlob(&cipherData);
785 TestFreeBlob(&ivData);
786 TestFreeBlob(&nonceData);
787 TestFreeBlob(&aadData);
788 return (ret != g_testDecryptParams[index].expectResult);
789 }