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 };
118
119 static const struct HksTestEncryptParams g_testEncryptParams[] = {
120 /* aes gcm nonce not set */
121 { 0, HKS_ERROR_CHECK_GET_NONCE_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
122 {
123 true, /* genKey params */
124 true, HKS_ALG_AES,
125 true, HKS_AES_KEY_SIZE_256,
126 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
127 false, 0,
128 true, HKS_PADDING_NONE,
129 true, HKS_MODE_GCM
130 },
131 { 0 },
132 {
133 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
134 true, HKS_ALG_AES,
135 true, HKS_KEY_PURPOSE_ENCRYPT,
136 false, 0,
137 true, HKS_PADDING_NONE,
138 true, HKS_MODE_GCM,
139 false, 0,
140 false, 0,
141 true, AES_DEFAULT_AAD_LEN,
142 false, true
143 },
144 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
145 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
146 { false, 0, false, 0 }
147 },
148
149 /* aes gcm nonce size invalid */
150 { 1, HKS_ERROR_INVALID_NONCE, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
151 {
152 true, /* genKey params */
153 true, HKS_ALG_AES,
154 true, HKS_AES_KEY_SIZE_256,
155 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
156 false, 0,
157 true, HKS_PADDING_NONE,
158 true, HKS_MODE_GCM
159 },
160 { 0 },
161 {
162 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
163 true, HKS_ALG_AES,
164 true, HKS_KEY_PURPOSE_ENCRYPT,
165 false, 0,
166 true, HKS_PADDING_NONE,
167 true, HKS_MODE_GCM,
168 false, 0,
169 true, AES_DEFAULT_GCM_NONCE_LENGTH - 1,
170 true, AES_DEFAULT_AAD_LEN,
171 false, true
172 },
173 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
174 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
175 { false, 0, false, 0 }
176 },
177
178 /* aes gcm aad not set */
179 { 2, HKS_ERROR_CHECK_GET_AAD_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
180 {
181 true, /* genKey params */
182 true, HKS_ALG_AES,
183 true, HKS_AES_KEY_SIZE_256,
184 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
185 false, 0,
186 true, HKS_PADDING_NONE,
187 true, HKS_MODE_GCM
188 },
189 { 0 },
190 {
191 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
192 true, HKS_ALG_AES,
193 true, HKS_KEY_PURPOSE_ENCRYPT,
194 false, 0,
195 true, HKS_PADDING_NONE,
196 true, HKS_MODE_GCM,
197 false, 0,
198 true, AES_DEFAULT_GCM_NONCE_LENGTH,
199 false, 0,
200 false, true
201 },
202 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
203 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
204 { false, 0, false, 0 }
205 },
206 /* aes gcm inSize == 0 */
207 { 3, HKS_ERROR_INVALID_ARGUMENT, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
208 {
209 true, /* genKey params */
210 true, HKS_ALG_AES,
211 true, HKS_AES_KEY_SIZE_256,
212 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
213 false, 0,
214 true, HKS_PADDING_NONE,
215 true, HKS_MODE_GCM
216 },
217 { 0 },
218 {
219 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
220 true, HKS_ALG_AES,
221 true, HKS_KEY_PURPOSE_ENCRYPT,
222 false, 0,
223 true, HKS_PADDING_NONE,
224 true, HKS_MODE_GCM,
225 false, 0,
226 true, AES_DEFAULT_GCM_NONCE_LENGTH,
227 true, AES_DEFAULT_AAD_LEN,
228 false, true
229 },
230 { true, 0, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
231 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 },
232 { false, 0, false, 0 }
233 },
234
235 /* aes gcm outSize too small */
236 { 4, HKS_ERROR_BUFFER_TOO_SMALL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
237 {
238 true, /* genKey params */
239 true, HKS_ALG_AES,
240 true, HKS_AES_KEY_SIZE_256,
241 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
242 false, 0,
243 true, HKS_PADDING_NONE,
244 true, HKS_MODE_GCM },
245 { 0 },
246 {
247 HKS_TEST_CIPHER_TYPE_AES, true, /* encrypt params */
248 true, HKS_ALG_AES,
249 true, HKS_KEY_PURPOSE_ENCRYPT,
250 false, 0,
251 true, HKS_PADDING_NONE,
252 true, HKS_MODE_GCM,
253 false, 0,
254 true, AES_DEFAULT_GCM_NONCE_LENGTH,
255 true, AES_DEFAULT_AAD_LEN,
256 false, true
257 },
258 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
259 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 - 1, true, DEFAULT_AES_CIPHER_PLAIN_SIZE + 16 - 1 },
260 { false, 0, false, 0 }
261 },
262 };
263
264 static const struct HksTestDecryptParams g_testDecryptParams[] = {
265 /* aes gcm nonce not set */
266 { 0, HKS_ERROR_CHECK_GET_NONCE_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
267 {
268 true, /* genKey params */
269 true, HKS_ALG_AES,
270 true, HKS_AES_KEY_SIZE_256,
271 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
272 false, 0,
273 true, HKS_PADDING_NONE,
274 true, HKS_MODE_GCM
275 },
276 { 0 },
277 {
278 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
279 true, HKS_ALG_AES,
280 true, HKS_KEY_PURPOSE_DECRYPT,
281 false, 0,
282 true, HKS_PADDING_NONE,
283 true, HKS_MODE_GCM,
284 false, 0,
285 false, AES_DEFAULT_GCM_NONCE_LENGTH,
286 true, AES_DEFAULT_AAD_LEN,
287 false, true
288 },
289 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
290 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
291 { false, 0, false, 0 }
292 },
293
294 /* aes gcm nonce size invalid */
295 { 1, HKS_ERROR_INVALID_NONCE, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
296 {
297 true, /* genKey params */
298 true, HKS_ALG_AES,
299 true, HKS_AES_KEY_SIZE_256,
300 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
301 false, 0,
302 true, HKS_PADDING_NONE,
303 true, HKS_MODE_GCM
304 },
305 { 0 },
306 {
307 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
308 true, HKS_ALG_AES,
309 true, HKS_KEY_PURPOSE_DECRYPT,
310 false, 0,
311 true, HKS_PADDING_NONE,
312 true, HKS_MODE_GCM,
313 false, 0,
314 true, AES_DEFAULT_GCM_NONCE_LENGTH - 1,
315 true, AES_DEFAULT_AAD_LEN,
316 false, true
317 },
318 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
319 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
320 { false, 0, false, 0 }
321 },
322
323 /* aes gcm aad not set */
324 { 2, HKS_ERROR_CHECK_GET_AAD_FAIL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
325 {
326 true, /* genKey params */
327 true, HKS_ALG_AES,
328 true, HKS_AES_KEY_SIZE_256,
329 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
330 false, 0,
331 true, HKS_PADDING_NONE,
332 true, HKS_MODE_GCM
333 },
334 { 0 },
335 {
336 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
337 true, HKS_ALG_AES,
338 true, HKS_KEY_PURPOSE_DECRYPT,
339 false, 0,
340 true, HKS_PADDING_NONE,
341 true, HKS_MODE_GCM,
342 false, 0,
343 true, AES_DEFAULT_GCM_NONCE_LENGTH,
344 false, 0,
345 false, true
346 },
347 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
348 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
349 { false, 0, false, 0 }
350 },
351 /* aes gcm inSize <= 16 */
352 { 3, HKS_ERROR_INVALID_ARGUMENT, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
353 {
354 true, /* genKey params */
355 true, HKS_ALG_AES,
356 true, HKS_AES_KEY_SIZE_256,
357 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
358 false, 0,
359 true, HKS_PADDING_NONE,
360 true, HKS_MODE_GCM
361 },
362 { 0 },
363 {
364 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
365 true, HKS_ALG_AES,
366 true, HKS_KEY_PURPOSE_DECRYPT,
367 false, 0,
368 true, HKS_PADDING_NONE,
369 true, HKS_MODE_GCM,
370 false, 0,
371 true, AES_DEFAULT_GCM_NONCE_LENGTH,
372 true, AES_DEFAULT_AAD_LEN,
373 false, true
374 },
375 { true, 16, true, 16 },
376 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 },
377 { false, 0, false, 0 }
378 },
379
380 /* aes gcm outSize too small */
381 { 4, HKS_ERROR_BUFFER_TOO_SMALL, { true, DEFAULT_KEY_ALIAS_SIZE, true, DEFAULT_KEY_ALIAS_SIZE },
382 {
383 true, /* genKey params */
384 true, HKS_ALG_AES,
385 true, HKS_AES_KEY_SIZE_256,
386 true, HKS_KEY_PURPOSE_ENCRYPT | HKS_KEY_PURPOSE_DECRYPT,
387 false, 0,
388 true, HKS_PADDING_NONE,
389 true, HKS_MODE_GCM
390 },
391 { 0 },
392 {
393 HKS_TEST_CIPHER_TYPE_AES, true, /* decrypt params */
394 true, HKS_ALG_AES,
395 true, HKS_KEY_PURPOSE_DECRYPT,
396 false, 0,
397 true, HKS_PADDING_NONE,
398 true, HKS_MODE_GCM,
399 false, 0,
400 true, AES_DEFAULT_GCM_NONCE_LENGTH,
401 true, AES_DEFAULT_AAD_LEN,
402 false, true
403 },
404 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE, true, DEFAULT_AES_CIPHER_PLAIN_SIZE },
405 { true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 - 1, true, DEFAULT_AES_CIPHER_PLAIN_SIZE - 16 -1 },
406 { false, 0, false, 0 }
407 },
408 };
409
ConstructDataToBlob(struct HksBlob ** inData,struct HksBlob ** outData,const struct HksTestBlobParams * inTextParams,const struct HksTestBlobParams * outTextParams)410 static int32_t ConstructDataToBlob(struct HksBlob **inData, struct HksBlob **outData,
411 const struct HksTestBlobParams *inTextParams, const struct HksTestBlobParams *outTextParams)
412 {
413 int32_t ret = TestConstuctBlob(inData,
414 inTextParams->blobExist,
415 inTextParams->blobSize,
416 inTextParams->blobDataExist,
417 inTextParams->blobDataSize);
418 HKS_TEST_ASSERT(ret == 0);
419
420 ret = TestConstuctBlob(outData,
421 outTextParams->blobExist,
422 outTextParams->blobSize,
423 outTextParams->blobDataExist,
424 outTextParams->blobDataSize);
425 HKS_TEST_ASSERT(ret == 0);
426 return ret;
427 }
428
Encrypt(struct CipherEncryptStructure * encryptStruct)429 static int32_t Encrypt(struct CipherEncryptStructure *encryptStruct)
430 {
431 int32_t ret;
432 struct HksParamSet *encryptParamSet = NULL;
433
434 if (encryptStruct->cipherParms->cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
435 struct TestRsaCipherParamSet rsaCipherParamStructure = {
436 &encryptParamSet,
437 encryptStruct->cipherParms->paramSetExist,
438 encryptStruct->cipherParms->setAlg, encryptStruct->cipherParms->alg,
439 encryptStruct->cipherParms->setPurpose, encryptStruct->cipherParms->purpose,
440 encryptStruct->cipherParms->setDigest, encryptStruct->cipherParms->digest,
441 encryptStruct->cipherParms->setPadding, encryptStruct->cipherParms->padding
442 };
443 ret = TestConstructRsaCipherParamSet(&rsaCipherParamStructure);
444 } else {
445 uint32_t ivSize = encryptStruct->cipherParms->ivSize;
446 uint32_t nonceSize = encryptStruct->cipherParms->nonceSize;
447 uint32_t aadSize = encryptStruct->cipherParms->aadSize;
448 if (ivSize != 0) {
449 ret = TestConstuctBlob(encryptStruct->ivData, true, ivSize, true, ivSize);
450 HKS_TEST_ASSERT(ret == 0);
451 }
452 if (nonceSize != 0) {
453 ret = TestConstuctBlob(encryptStruct->nonceData, true, nonceSize, true, nonceSize);
454 HKS_TEST_ASSERT(ret == 0);
455 }
456 if (aadSize != 0) {
457 ret = TestConstuctBlob(encryptStruct->aadData, true, aadSize, true, aadSize);
458 HKS_TEST_ASSERT(ret == 0);
459 }
460 struct AesCipherParamSetStructure enParamStruct = {
461 &encryptParamSet,
462 encryptStruct->cipherParms->paramSetExist,
463 encryptStruct->cipherParms->setAlg, encryptStruct->cipherParms->alg,
464 encryptStruct->cipherParms->setPurpose, encryptStruct->cipherParms->purpose,
465 encryptStruct->cipherParms->setPadding, encryptStruct->cipherParms->padding,
466 encryptStruct->cipherParms->setBlockMode, encryptStruct->cipherParms->mode,
467 encryptStruct->cipherParms->setIv, *(encryptStruct->ivData),
468 encryptStruct->cipherParms->setNonce, *(encryptStruct->nonceData),
469 encryptStruct->cipherParms->setAad, *(encryptStruct->aadData),
470 encryptStruct->cipherParms->setIsKeyAlias, encryptStruct->cipherParms->isKeyAlias
471 };
472 ret = TestConstructAesCipherParamSet(&enParamStruct);
473 HKS_TEST_ASSERT(ret == 0);
474 }
475
476 ret = HksEncryptRun(encryptStruct->keyAlias, encryptParamSet, encryptStruct->plainData, encryptStruct->cipherData,
477 encryptStruct->performTimes);
478 HksFreeParamSet(&encryptParamSet);
479 return ret;
480 }
481
DecryptCipher(struct CipherDecryptStructure * decryptStruct)482 static int32_t DecryptCipher(struct CipherDecryptStructure *decryptStruct)
483 {
484 int32_t ret = TestConstuctBlob(decryptStruct->decryptedData,
485 decryptStruct->cipherParms->decryptedTextParams.blobExist,
486 decryptStruct->cipherParms->decryptedTextParams.blobSize,
487 decryptStruct->cipherParms->decryptedTextParams.blobDataExist,
488 decryptStruct->cipherParms->decryptedTextParams.blobDataSize);
489 HKS_TEST_ASSERT(ret == 0);
490
491 struct HksParamSet *decryptParamSet = NULL;
492 if (decryptStruct->cipherParms->decryptParamSetParams.cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
493 struct TestRsaCipherParamSet rsaDeCipherParamStructure = {
494 &decryptParamSet,
495 decryptStruct->cipherParms->decryptParamSetParams.paramSetExist,
496 decryptStruct->cipherParms->decryptParamSetParams.setAlg,
497 decryptStruct->cipherParms->decryptParamSetParams.alg,
498 decryptStruct->cipherParms->decryptParamSetParams.setPurpose,
499 decryptStruct->cipherParms->decryptParamSetParams.purpose,
500 decryptStruct->cipherParms->decryptParamSetParams.setDigest,
501 decryptStruct->cipherParms->decryptParamSetParams.digest,
502 decryptStruct->cipherParms->decryptParamSetParams.setPadding,
503 decryptStruct->cipherParms->decryptParamSetParams.padding
504 };
505 ret = TestConstructRsaCipherParamSet(&rsaDeCipherParamStructure);
506 } else {
507 struct AesCipherParamSetStructure deParamStruct = {
508 &decryptParamSet,
509 decryptStruct->cipherParms->decryptParamSetParams.paramSetExist,
510 decryptStruct->cipherParms->decryptParamSetParams.setAlg,
511 decryptStruct->cipherParms->decryptParamSetParams.alg,
512 decryptStruct->cipherParms->decryptParamSetParams.setPurpose,
513 decryptStruct->cipherParms->decryptParamSetParams.purpose,
514 decryptStruct->cipherParms->decryptParamSetParams.setPadding,
515 decryptStruct->cipherParms->decryptParamSetParams.padding,
516 decryptStruct->cipherParms->decryptParamSetParams.setBlockMode,
517 decryptStruct->cipherParms->decryptParamSetParams.mode,
518 decryptStruct->cipherParms->decryptParamSetParams.setIv, decryptStruct->ivData,
519 decryptStruct->cipherParms->decryptParamSetParams.setNonce, decryptStruct->nonceData,
520 decryptStruct->cipherParms->decryptParamSetParams.setAad, decryptStruct->aadData,
521 decryptStruct->cipherParms->decryptParamSetParams.setIsKeyAlias,
522 decryptStruct->cipherParms->decryptParamSetParams.isKeyAlias
523 };
524 ret = TestConstructAesCipherParamSet(&deParamStruct);
525 HKS_TEST_ASSERT(ret == 0);
526 }
527
528 ret = HksDecryptRun(decryptStruct->keyAlias, decryptParamSet, decryptStruct->cipherData,
529 *(decryptStruct->decryptedData), decryptStruct->performTimes);
530 HksFreeParamSet(&decryptParamSet);
531 return ret;
532 }
533
Decrypt(struct OnlyDecryptStructure * onlyDecryptStruct)534 static int32_t Decrypt(struct OnlyDecryptStructure *onlyDecryptStruct)
535 {
536 struct HksParamSet *decryptParamSet = NULL;
537 int32_t ret;
538 if (onlyDecryptStruct->cipherParms->cipherType == HKS_TEST_CIPHER_TYPE_RSA) {
539 struct TestRsaCipherParamSet rsaCipherParamStructure = {
540 &decryptParamSet,
541 onlyDecryptStruct->cipherParms->paramSetExist,
542 onlyDecryptStruct->cipherParms->setAlg, onlyDecryptStruct->cipherParms->alg,
543 onlyDecryptStruct->cipherParms->setPurpose, onlyDecryptStruct->cipherParms->purpose,
544 onlyDecryptStruct->cipherParms->setDigest, onlyDecryptStruct->cipherParms->digest,
545 onlyDecryptStruct->cipherParms->setPadding, onlyDecryptStruct->cipherParms->padding
546 };
547 ret = TestConstructRsaCipherParamSet(&rsaCipherParamStructure);
548 } else {
549 uint32_t ivSize = onlyDecryptStruct->cipherParms->ivSize;
550 uint32_t nonceSize = onlyDecryptStruct->cipherParms->nonceSize;
551 uint32_t aadSize = onlyDecryptStruct->cipherParms->aadSize;
552 if (ivSize != 0) {
553 ret = TestConstuctBlob(onlyDecryptStruct->ivData, true, ivSize, true, ivSize);
554 HKS_TEST_ASSERT(ret == 0);
555 }
556 if (nonceSize != 0) {
557 ret = TestConstuctBlob(onlyDecryptStruct->nonceData, true, nonceSize, true, nonceSize);
558 HKS_TEST_ASSERT(ret == 0);
559 }
560 if (aadSize != 0) {
561 ret = TestConstuctBlob(onlyDecryptStruct->aadData, true, aadSize, true, aadSize);
562 HKS_TEST_ASSERT(ret == 0);
563 }
564 struct AesCipherParamSetStructure onlyDeParamStruct = {
565 &decryptParamSet,
566 onlyDecryptStruct->cipherParms->paramSetExist,
567 onlyDecryptStruct->cipherParms->setAlg, onlyDecryptStruct->cipherParms->alg,
568 onlyDecryptStruct->cipherParms->setPurpose, onlyDecryptStruct->cipherParms->purpose,
569 onlyDecryptStruct->cipherParms->setPadding, onlyDecryptStruct->cipherParms->padding,
570 onlyDecryptStruct->cipherParms->setBlockMode, onlyDecryptStruct->cipherParms->mode,
571 onlyDecryptStruct->cipherParms->setIv, *(onlyDecryptStruct->ivData),
572 onlyDecryptStruct->cipherParms->setNonce, *(onlyDecryptStruct->nonceData),
573 onlyDecryptStruct->cipherParms->setAad, *(onlyDecryptStruct->aadData),
574 onlyDecryptStruct->cipherParms->setIsKeyAlias, onlyDecryptStruct->cipherParms->isKeyAlias
575 };
576 ret = TestConstructAesCipherParamSet(&onlyDeParamStruct);
577 }
578 HKS_TEST_ASSERT(ret == 0);
579
580 ret = HksDecryptRun(onlyDecryptStruct->keyAlias, decryptParamSet, onlyDecryptStruct->cipherData,
581 onlyDecryptStruct->decryptedData, onlyDecryptStruct->performTimes);
582 HksFreeParamSet(&decryptParamSet);
583 return ret;
584 }
585
586
BaseTestCipher(uint32_t times,uint32_t index,uint32_t performTimes)587 int32_t BaseTestCipher(uint32_t times, uint32_t index, uint32_t performTimes)
588 {
589 /* 1. generate key */
590 struct HksBlob *keyAlias = NULL;
591 int32_t ret;
592 if ((g_testCipherParams[index].genKeyParamSetParams.setKeyStorageFlag) &&
593 g_testCipherParams[index].genKeyParamSetParams.keyStorageFlag == HKS_STORAGE_TEMP) {
594 ret = GenerateLocalRandomKey(&keyAlias, &g_testCipherParams[index].localKeyParams);
595 } else {
596 ret = GenerateKey(&keyAlias, &g_testCipherParams[index].keyAliasParams,
597 &g_testCipherParams[index].genKeyParamSetParams, &g_testCipherParams[index].genKeyParamSetParamsOut);
598 }
599 HKS_TEST_ASSERT(ret == 0);
600 struct HksBlob *plainData = NULL;
601 struct HksBlob *cipherData = NULL;
602 ret = ConstructDataToBlob(&plainData, &cipherData,
603 &g_testCipherParams[index].plainTextParams, &g_testCipherParams[index].cipherTextParams);
604 HKS_TEST_ASSERT(ret == 0);
605 struct HksBlob *ivData = NULL;
606 struct HksBlob *nonceData = NULL;
607 struct HksBlob *aadData = NULL;
608 /* 2. encrypt */
609 struct CipherEncryptStructure testEncryptStruct = {
610 keyAlias, &g_testCipherParams[index].encryptParamSetParams,
611 plainData, cipherData, &ivData, &nonceData, &aadData, performTimes
612 };
613 ret = Encrypt(&testEncryptStruct);
614 HKS_TEST_ASSERT(ret == g_testCipherParams[index].expectResult);
615
616 /* 3. decrypt */
617 struct HksBlob *decryptedData = NULL;
618 struct CipherDecryptStructure testDecryptStruct = {
619 keyAlias, &g_testCipherParams[index], cipherData,
620 &decryptedData, ivData, nonceData, aadData, performTimes
621 };
622 ret = DecryptCipher(&testDecryptStruct);
623 HKS_TEST_ASSERT(ret == g_testCipherParams[index].expectResult);
624
625 HKS_TEST_ASSERT(plainData->size == decryptedData->size);
626 HKS_TEST_ASSERT(memcmp(plainData->data, decryptedData->data, plainData->size) == 0);
627 if (!((g_testCipherParams[index].genKeyParamSetParams.setKeyStorageFlag) &&
628 g_testCipherParams[index].genKeyParamSetParams.keyStorageFlag == HKS_STORAGE_TEMP)) {
629 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
630 }
631 TestFreeBlob(&keyAlias);
632 TestFreeBlob(&plainData);
633 TestFreeBlob(&cipherData);
634 TestFreeBlob(&decryptedData);
635 TestFreeBlob(&ivData);
636 TestFreeBlob(&nonceData);
637 TestFreeBlob(&aadData);
638 return (ret != g_testCipherParams[index].expectResult);
639 }
640
BaseTestEncrypt(uint32_t times,uint32_t index,uint32_t performTimes)641 int32_t BaseTestEncrypt(uint32_t times, uint32_t index, uint32_t performTimes)
642 {
643 /* 1. generate key */
644 struct HksBlob *keyAlias = NULL;
645 int32_t ret;
646 if (g_testEncryptParams[index].encryptParamSetParams.setIsKeyAlias &&
647 !g_testEncryptParams[index].encryptParamSetParams.isKeyAlias) {
648 ret = GenerateLocalRandomKey(&keyAlias, &g_testEncryptParams[index].localKeyParams);
649 } else {
650 if (g_testEncryptParams[index].keyAliasParams.blobExist) {
651 ret = GenerateKey(&keyAlias, &g_testEncryptParams[index].keyAliasParams,
652 &g_testEncryptParams[index].genKeyParamSetParams, NULL);
653 } else {
654 ret = TestConstuctBlob(&keyAlias,
655 g_testEncryptParams[index].encryptAliasParams.blobExist,
656 g_testEncryptParams[index].encryptAliasParams.blobSize,
657 g_testEncryptParams[index].encryptAliasParams.blobDataExist,
658 g_testEncryptParams[index].encryptAliasParams.blobDataSize);
659 }
660 }
661 HKS_TEST_ASSERT(ret == 0);
662
663 struct HksBlob *plainData = NULL;
664 struct HksBlob *cipherData = NULL;
665 ret = ConstructDataToBlob(&plainData, &cipherData,
666 &g_testEncryptParams[index].inDataParams, &g_testEncryptParams[index].outDataParams);
667 HKS_TEST_ASSERT(ret == 0);
668
669 struct HksBlob *ivData = NULL;
670 struct HksBlob *nonceData = NULL;
671 struct HksBlob *aadData = NULL;
672 /* 2. encrypt */
673 struct CipherEncryptStructure encryptStruct = {
674 keyAlias, &g_testEncryptParams[index].encryptParamSetParams, plainData, cipherData, &ivData,
675 &nonceData, &aadData, performTimes
676 };
677 ret = Encrypt(&encryptStruct);
678 HKS_TEST_ASSERT(ret == g_testEncryptParams[index].expectResult);
679
680 /* 4. delete key */
681 if (g_testEncryptParams[index].keyAliasParams.blobExist) {
682 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
683 }
684 TestFreeBlob(&keyAlias);
685 TestFreeBlob(&plainData);
686 TestFreeBlob(&cipherData);
687 TestFreeBlob(&ivData);
688 TestFreeBlob(&nonceData);
689 TestFreeBlob(&aadData);
690 return (ret != g_testEncryptParams[index].expectResult);
691 }
692
BaseTestDecrypt(uint32_t times,uint32_t index,uint32_t performTimes)693 int32_t BaseTestDecrypt(uint32_t times, uint32_t index, uint32_t performTimes)
694 {
695 /* 1. generate key */
696 struct HksBlob *keyAlias = NULL;
697 int32_t ret;
698 if (g_testDecryptParams[index].decryptParamSetParams.setIsKeyAlias &&
699 !g_testDecryptParams[index].decryptParamSetParams.isKeyAlias) {
700 ret = GenerateLocalRandomKey(&keyAlias, &g_testDecryptParams[index].localKeyParams);
701 } else {
702 if (g_testDecryptParams[index].keyAliasParams.blobExist) {
703 ret = GenerateKey(&keyAlias, &g_testDecryptParams[index].keyAliasParams,
704 &g_testDecryptParams[index].genKeyParamSetParams, NULL);
705 } else {
706 ret = TestConstuctBlob(&keyAlias,
707 g_testDecryptParams[index].decryptAliasParams.blobExist,
708 g_testDecryptParams[index].decryptAliasParams.blobSize,
709 g_testDecryptParams[index].decryptAliasParams.blobDataExist,
710 g_testDecryptParams[index].decryptAliasParams.blobDataSize);
711 }
712 }
713 HKS_TEST_ASSERT(ret == 0);
714
715 struct HksBlob *cipherData = NULL;
716 struct HksBlob *decryptedData = NULL;
717 ret = ConstructDataToBlob(&cipherData, &decryptedData,
718 &g_testDecryptParams[index].inDataParams, &g_testDecryptParams[index].outDataParams);
719 HKS_TEST_ASSERT(ret == 0);
720
721 struct HksBlob *ivData = NULL;
722 struct HksBlob *nonceData = NULL;
723 struct HksBlob *aadData = NULL;
724 /* 3. encrypt */
725 struct OnlyDecryptStructure onlyDecryptStruct = {
726 keyAlias, &g_testDecryptParams[index].decryptParamSetParams, cipherData, decryptedData, &ivData,
727 &nonceData, &aadData, performTimes
728 };
729 ret = Decrypt(&onlyDecryptStruct);
730 HKS_TEST_ASSERT(ret == g_testDecryptParams[index].expectResult);
731
732 /* 4. delete key */
733 if (g_testDecryptParams[index].keyAliasParams.blobExist) {
734 HKS_TEST_ASSERT(HksDeleteKey(keyAlias, NULL) == 0);
735 }
736 TestFreeBlob(&keyAlias);
737 TestFreeBlob(&decryptedData);
738 TestFreeBlob(&cipherData);
739 TestFreeBlob(&ivData);
740 TestFreeBlob(&nonceData);
741 TestFreeBlob(&aadData);
742 return (ret != g_testDecryptParams[index].expectResult);
743 }