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 29static 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 165static 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 310static 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 456static 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 475static 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 528static 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 580static 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 633int32_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 687int32_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 739int32_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}