1 /* 2 * Copyright (c) 2024-2024 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 16 #include <gtest/gtest.h> 17 #include "signature_tools_log.h" 18 #include "options.h" 19 #include "sign_tool_service_impl.h" 20 #include "localization_adapter.h" 21 #include "openssl/ssl.h" 22 #include "openssl/pem.h" 23 #include "openssl/err.h" 24 #include "p12_local.h" 25 #include "cmd_util.h" 26 #include "file_utils.h" 27 #include "params_run_tool.h" 28 #include "constant.h" 29 #include "params.h" 30 #include "params_trust_list.h" 31 #include "param_constants.h" 32 33 namespace OHOS { 34 namespace SignatureTools { 35 36 class GenerateKeyPairTest : public testing::Test { 37 public: SetUpTestCase()38 static void SetUpTestCase() 39 { 40 }; TearDownTestCase()41 static void TearDownTestCase() 42 { 43 }; SetUp()44 void SetUp() 45 { 46 }; TearDown()47 void TearDown() 48 { 49 }; 50 }; 51 52 /* 53 * @tc.name: generate_keypair_test_001 54 * @tc.desc: Generate a key pair and load it into the keystore. 55 * @tc.type: FUNC 56 * @tc.require: 57 */ 58 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_001, testing::ext::TestSize.Level1) 59 { 60 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 61 std::shared_ptr<Options> params = std::make_shared<Options>(); 62 63 std::string keyAlias = "oh-app1-key-v1"; 64 char keyPwd[] = "123456"; 65 std::string keyAlg = "ECC"; 66 int keySize = 256; 67 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 68 char keystorePwd[] = "123456"; 69 70 (*params)["keyAlias"] = keyAlias; 71 (*params)["keyPwd"] = keyPwd; 72 (*params)["keyAlg"] = keyAlg; 73 (*params)["keySize"] = keySize; 74 (*params)["keystoreFile"] = keystoreFile; 75 (*params)["keystorePwd"] = keystorePwd; 76 77 bool ret = api->GenerateKeyStore(params.get()); 78 EXPECT_EQ(ret, false); 79 } 80 81 /* 82 * @tc.name: generate_keypair_test_002 83 * @tc.desc: If you search for a key pair in the keystore using an alias, 84 * @the key pair pointer is returned on success, and NULL is returned on failure. 85 * @tc.type: FUNC 86 * @tc.require: 87 */ 88 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_002, testing::ext::TestSize.Level1) 89 { 90 std::shared_ptr<Options> params = std::make_shared<Options>(); 91 92 std::string keyAlias = "oh-app1-key-v1"; 93 char keyPwd[] = "123456"; 94 std::string keyAlg = "ECC"; 95 int keySize = 256; 96 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 97 char keystorePwd[] = "123456"; 98 99 (*params)["keyAlias"] = keyAlias; 100 (*params)["keyPwd"] = keyPwd; 101 (*params)["keyAlg"] = keyAlg; 102 (*params)["keySize"] = keySize; 103 (*params)["keystoreFile"] = keystoreFile; 104 (*params)["keystorePwd"] = keystorePwd; 105 106 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 107 108 int status = adaptePtr->IsAliasExist(adaptePtr->options->GetString(Options::KEY_ALIAS)); 109 EXPECT_EQ(status, 0); 110 } 111 112 /* 113 * @tc.name: generate_keypair_test_003 114 * @tc.desc: Generate a key pair and load it into the keystore. 115 * @tc.type: FUNC 116 * @tc.require: 117 */ 118 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_003, testing::ext::TestSize.Level1) 119 { 120 std::shared_ptr<Options> params = std::make_shared<Options>(); 121 std::string keyAlias = "oh-app1-key-v1"; 122 char keyPwd[] = "123456"; 123 std::string keyAlg = "ECC"; 124 int keySize = 256; 125 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 126 char keystorePwd[] = "123456"; 127 (*params)["keyAlias"] = keyAlias; 128 (*params)["keyPwd"] = keyPwd; 129 (*params)["keyAlg"] = keyAlg; 130 (*params)["keySize"] = keySize; 131 (*params)["keystoreFile"] = keystoreFile; 132 (*params)["keystorePwd"] = keystorePwd; 133 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 134 EVP_PKEY* keyPair = nullptr; 135 keyPair = adaptePtr->GetAliasKey(true); 136 EXPECT_NE(keyPair, nullptr); 137 } 138 139 /* 140 * @tc.name: generate_keypair_test_004 141 * @tc.desc: Generate key pair. 142 * @tc.type: FUNC 143 * @tc.require: 144 */ 145 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_004, testing::ext::TestSize.Level1) 146 { 147 std::shared_ptr<Options> params = std::make_shared<Options>(); 148 149 std::string keyAlg = "ECC"; 150 int keySize = 256; 151 152 (*params)["keyAlg"] = keyAlg; 153 (*params)["keySize"] = keySize; 154 155 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 156 157 EVP_PKEY* keyPair = nullptr; 158 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE); 159 keyPair = adaptePtr->keyStoreHelper->GenerateKeyPair(adaptePtr->options->GetString(Options::KEY_ALG), 160 adaptePtr->options->GetInt(Options::KEY_SIZE)); 161 EXPECT_NE(keyPair, nullptr); 162 } 163 164 /* 165 * @tc.name: generate_keypair_test_005 166 * @tc.desc: Load the key pair into the file. 167 * @tc.type: FUNC 168 * @tc.require: 169 */ 170 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_005, testing::ext::TestSize.Level1) 171 { 172 std::shared_ptr<Options> params = std::make_shared<Options>(); 173 174 std::string keyAlias = "oh-app1-key-v1"; 175 char keyPwd[] = "123456"; 176 std::string keyAlg = "ECC"; 177 int keySize = 256; 178 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 179 char keystorePwd[] = "123456"; 180 181 (*params)["keyAlias"] = keyAlias; 182 (*params)["keyPwd"] = keyPwd; 183 (*params)["keyAlg"] = keyAlg; 184 (*params)["keySize"] = keySize; 185 (*params)["keystoreFile"] = keystoreFile; 186 (*params)["keystorePwd"] = keystorePwd; 187 188 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 189 190 EVP_PKEY* keyPair = nullptr; 191 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE); 192 keyPair = adaptePtr->keyStoreHelper->GenerateKeyPair(adaptePtr->options->GetString(Options::KEY_ALG), 193 adaptePtr->options->GetInt(Options::KEY_SIZE)); 194 int ret = adaptePtr->keyStoreHelper->WriteKeyStore(keyPair, keyStorePath, 195 adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS), 196 adaptePtr->options->GetString(Options::KEY_ALIAS), 197 adaptePtr->options->GetChars(Options::KEY_RIGHTS)); 198 EXPECT_NE(ret, RET_FAILED); 199 } 200 201 /* 202 * @tc.name: generate_keypair_test_006 203 * @tc.desc: Read the key pair from the file by alias. 204 * @tc.type: FUNC 205 * @tc.require: 206 */ 207 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_006, testing::ext::TestSize.Level1) 208 { 209 std::shared_ptr<Options> params = std::make_shared<Options>(); 210 211 std::string keyAlias = "oh-app1-key-v1"; 212 char keyPwd[] = "123456"; 213 std::string keyAlg = "ECC"; 214 int keySize = 256; 215 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 216 char keystorePwd[] = "123456"; 217 218 (*params)["keyAlias"] = keyAlias; 219 (*params)["keyPwd"] = keyPwd; 220 (*params)["keyAlg"] = keyAlg; 221 (*params)["keySize"] = keySize; 222 (*params)["keystoreFile"] = keystoreFile; 223 (*params)["keystorePwd"] = keystorePwd; 224 225 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 226 227 EVP_PKEY* keyPair = nullptr; 228 std::string keyStorePath = adaptePtr->options->GetString(Options::KEY_STORE_FILE); 229 adaptePtr->keyStoreHelper->ReadKeyStore(keyStorePath, adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS), 230 adaptePtr->options->GetString(Options::KEY_ALIAS), 231 adaptePtr->options->GetChars(Options::KEY_RIGHTS), &keyPair); 232 EXPECT_NE(keyPair, nullptr); 233 } 234 235 /* 236 * @tc.name: generate_keypair_test_007 237 * @tc.desc: reset passwords. 238 * @tc.type: FUNC 239 * @tc.require: 240 */ 241 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_007, testing::ext::TestSize.Level1) 242 { 243 std::shared_ptr<Options> params = std::make_shared<Options>(); 244 245 char keyPwd[] = "123456"; 246 char keystorePwd[] = "123456"; 247 char issuerKeyPwd[] = "123456"; 248 char issuerkeystorePwd[] = "123456"; 249 250 (*params)["keyPwd"] = keyPwd; 251 (*params)["keystorePwd"] = keystorePwd; 252 (*params)["issuerKeyPwd"] = issuerKeyPwd; 253 (*params)["issuerKeystorePwd"] = issuerkeystorePwd; 254 255 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 256 257 std::string str = ""; 258 adaptePtr->ResetPwd(); 259 EXPECT_EQ(adaptePtr->options->GetChars(Options::KEY_RIGHTS), str); 260 EXPECT_EQ(adaptePtr->options->GetChars(Options::KEY_STORE_RIGHTS), str); 261 EXPECT_EQ(adaptePtr->options->GetChars(Options::ISSUER_KEY_RIGHTS), str); 262 EXPECT_EQ(adaptePtr->options->GetChars(Options::ISSUER_KEY_STORE_RIGHTS), str); 263 } 264 265 /* 266 * @tc.name: generate_keypair_test_008 267 * @tc.desc: Generate a key pair and load it into the keystore. 268 * @tc.type: FUNC 269 * @tc.require: 270 */ 271 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_008, testing::ext::TestSize.Level1) 272 { 273 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 274 std::shared_ptr<Options> params = std::make_shared<Options>(); 275 276 std::string keyAlias = "aaa"; 277 char keyPwd[] = "123456"; 278 std::string keyAlg = "ECC"; 279 int keySize = 385; 280 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 281 char keystorePwd[] = "123456"; 282 283 (*params)["keyAlias"] = keyAlias; 284 (*params)["keyPwd"] = keyPwd; 285 (*params)["keyAlg"] = keyAlg; 286 (*params)["keySize"] = keySize; 287 (*params)["keystoreFile"] = keystoreFile; 288 (*params)["keystorePwd"] = keystorePwd; 289 290 bool ret = api->GenerateKeyStore(params.get()); 291 EXPECT_EQ(ret, false); 292 } 293 294 /* 295 * @tc.name: generate_keypair_test_009 296 * @tc.desc: Generate a key pair and load it into the keystore. 297 * @tc.type: FUNC 298 * @tc.require: 299 */ 300 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_009, testing::ext::TestSize.Level1) 301 { 302 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 303 std::shared_ptr<Options> params = std::make_shared<Options>(); 304 305 std::string keyAlias = "oh-app1-key-v1"; 306 char keyPwd[] = "123456909"; 307 std::string keyAlg = "ECC"; 308 int keySize = 385; 309 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 310 char keystorePwd[] = "123456"; 311 312 (*params)["keyAlias"] = keyAlias; 313 (*params)["keyPwd"] = keyPwd; 314 (*params)["keyAlg"] = keyAlg; 315 (*params)["keySize"] = keySize; 316 (*params)["keystoreFile"] = keystoreFile; 317 (*params)["keystorePwd"] = keystorePwd; 318 319 bool ret = api->GenerateKeyStore(params.get()); 320 EXPECT_EQ(ret, false); 321 } 322 323 /* 324 * @tc.name: generate_keypair_test_010 325 * @tc.desc: Write the keypair to the keystore file. 326 * @tc.type: FUNC 327 * @tc.require: 328 */ 329 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_010, testing::ext::TestSize.Level1) 330 { 331 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 332 std::shared_ptr<Options> params = std::make_shared<Options>(); 333 KeyStoreHelper keystorehelper; 334 335 std::string keyAlias = "oh-app1-key-v1"; 336 char keyPwd[] = "123456"; 337 std::string keyAlg = "ECC"; 338 int keySize = 256; 339 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 340 char keystorePwd[] = "1234563333"; 341 342 (*params)["keyAlias"] = keyAlias; 343 (*params)["keyPwd"] = keyPwd; 344 (*params)["keyAlg"] = keyAlg; 345 (*params)["keySize"] = keySize; 346 (*params)["keystoreFile"] = keystoreFile; 347 (*params)["keystorePwd"] = keystorePwd; 348 349 EVP_PKEY* keyPair = keystorehelper.GenerateKeyPair(keyAlg, keySize); 350 351 int ret = keystorehelper.WriteKeyStore(keyPair, keystoreFile, keystorePwd, keyAlias, keyPwd); 352 EXPECT_EQ(ret, RET_FAILED); 353 } 354 355 /* 356 * @tc.name: generate_keypair_test_011 357 * @tc.desc: The key pair is read from the P12 file by alias. 358 * @tc.type: FUNC 359 * @tc.require: 360 */ 361 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_011, testing::ext::TestSize.Level1) 362 { 363 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 364 std::shared_ptr<Options> params = std::make_shared<Options>(); 365 KeyStoreHelper keystorehelper; 366 367 std::string keyAlias = "oh-app1-key-v1"; 368 char keyPwd[] = "123456"; 369 std::string keyAlg = "ECC"; 370 int keySize = 256; 371 std::string keystoreFile = "./generateKeyPair/OpenHarmony99999.p12"; 372 char keystorePwd[] = "123456"; 373 374 (*params)["keyAlias"] = keyAlias; 375 (*params)["keyPwd"] = keyPwd; 376 (*params)["keyAlg"] = keyAlg; 377 (*params)["keySize"] = keySize; 378 (*params)["keystoreFile"] = keystoreFile; 379 (*params)["keystorePwd"] = keystorePwd; 380 381 EVP_PKEY* keyPair = nullptr; 382 383 int ret = keystorehelper.ReadKeyStore(keystoreFile, keystorePwd, keyAlias, keyPwd, &keyPair); 384 EXPECT_EQ(ret, RET_FAILED); 385 } 386 387 /* 388 * @tc.name: generate_keypair_test_012 389 * @tc.desc: Generate a key pair and load it into the keystore. 390 * @tc.type: FUNC 391 * @tc.require: 392 */ 393 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_012, testing::ext::TestSize.Level1) 394 { 395 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 396 std::shared_ptr<Options> params = std::make_shared<Options>(); 397 398 std::string keyAlias = "oh-app1-key-v1"; 399 std::string keyAlg = "ECC"; 400 int keySize = 256; 401 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 402 403 (*params)["keyAlias"] = keyAlias; 404 (*params)["keyAlg"] = keyAlg; 405 (*params)["keySize"] = keySize; 406 (*params)["keystoreFile"] = keystoreFile; 407 408 bool ret = api->GenerateKeyStore(params.get()); 409 EXPECT_EQ(ret, false); 410 } 411 412 /* 413 * @tc.name: generate_keypair_test_013 414 * @tc.desc: Generate a key pair and load it into the keystore. 415 * @tc.type: FUNC 416 * @tc.require: 417 */ 418 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_013, testing::ext::TestSize.Level1) 419 { 420 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 421 std::shared_ptr<Options> params = std::make_shared<Options>(); 422 423 std::string keyAlias = "oh-app1-key-v1"; 424 char keyPwd[] = ""; 425 std::string keyAlg = "ECC"; 426 int keySize = 256; 427 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 428 char keystorePwd[] = ""; 429 430 (*params)["keyAlias"] = keyAlias; 431 (*params)["keyPwd"] = keyPwd; 432 (*params)["keyAlg"] = keyAlg; 433 (*params)["keySize"] = keySize; 434 (*params)["keystoreFile"] = keystoreFile; 435 (*params)["keystorePwd"] = keystorePwd; 436 437 bool ret = api->GenerateKeyStore(params.get()); 438 EXPECT_EQ(ret, false); 439 } 440 441 /* 442 * @tc.name: generate_keypair_test_014 443 * @tc.desc: Generate a key pair and load it into the keystore. 444 * @tc.type: FUNC 445 * @tc.require: 446 */ 447 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_014, testing::ext::TestSize.Level1) 448 { 449 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 450 std::shared_ptr<Options> params = std::make_shared<Options>(); 451 452 std::string keyAlias = "oh-app1-key-v1"; 453 std::string keyAlg = "ECC"; 454 int keySize = 256; 455 std::string keystoreFile = "./generateKeyPair/OpenHarmony1.p12"; 456 457 (*params)["keyAlias"] = keyAlias; 458 (*params)["keyAlg"] = keyAlg; 459 (*params)["keySize"] = keySize; 460 (*params)["keystoreFile"] = keystoreFile; 461 462 bool ret = api->GenerateKeyStore(params.get()); 463 EXPECT_EQ(ret, true); 464 } 465 466 /* 467 * @tc.name: generate_keypair_test_015 468 * @tc.desc: Create a p12 keystore. 469 * @tc.type: FUNC 470 * @tc.require: 471 */ 472 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_015, testing::ext::TestSize.Level1) 473 { 474 X509* cert = X509_new(); 475 PKCS12* p12 = nullptr; 476 EVP_PKEY* keypair = nullptr; 477 KeyStoreHelper keyhelper; 478 479 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12"; 480 char storePwd[] = "123456"; 481 std::string alias = "oh-app1-key-v1"; 482 char keyPwd[] = "123456"; 483 484 keypair = keyhelper.GenerateKeyPair("ECC", 256); 485 keyhelper.InitX509(*cert, *keypair); 486 487 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert); 488 int ret = keyhelper.FindKeyPair(p12, "", nullptr, nullptr, nullptr, ""); 489 EXPECT_EQ(ret, RET_FAILED); 490 } 491 492 /* 493 * @tc.name: generate_keypair_test_016 494 * @tc.desc: Generate a key pair and load it into the keystore. 495 * @tc.type: FUNC 496 * @tc.require: 497 */ 498 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_016, testing::ext::TestSize.Level1) 499 { 500 X509* cert = X509_new(); 501 PKCS12* p12 = nullptr; 502 EVP_PKEY* keypair = nullptr; 503 KeyStoreHelper keyhelper; 504 505 std::string keyStorePath = "./generateKeyPair/OpenHarmony11.p12"; 506 char storePwd[] = "123456"; 507 std::string alias = "oh-app1-key-v1"; 508 char keyPwd[] = "123456"; 509 510 keypair = keyhelper.GenerateKeyPair("ECC", 256); 511 int ret = keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert); 512 EXPECT_EQ(ret, RET_FAILED); 513 } 514 515 /* 516 * @tc.name: generate_keypair_test_017 517 * @tc.desc: Keystore password parsing. 518 * @tc.type: FUNC 519 * @tc.require: 520 */ 521 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_017, testing::ext::TestSize.Level1) 522 { 523 KeyStoreHelper keyhelper; 524 int ret = keyhelper.Pkcs12PasswordParse(nullptr, nullptr, ""); 525 EXPECT_EQ(ret, RET_FAILED); 526 } 527 528 /* 529 * @tc.name: generate_keypair_test_018 530 * @tc.desc: Generate a key pair and load it into the keystore. 531 * @tc.type: FUNC 532 * @tc.require: 533 */ 534 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_018, testing::ext::TestSize.Level1) 535 { 536 X509* cert = X509_new(); 537 PKCS12* p12 = nullptr; 538 EVP_PKEY* keypair = nullptr; 539 KeyStoreHelper keyhelper; 540 541 std::string keyStorePath = "./generateKeyPair/OpenHarmonyDamage.p12"; 542 char storePwd[] = "123456"; 543 std::string alias = "oh-app1-key-v1"; 544 char keyPwd[] = "123456"; 545 546 keypair = keyhelper.GenerateKeyPair("ECC", 256); 547 keyhelper.InitX509(*cert, *keypair); 548 int ret = keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert); 549 EXPECT_EQ(ret, RET_FAILED); 550 } 551 552 /* 553 * @tc.name: generate_keypair_test_019 554 * @tc.desc: Keystore password parsing. 555 * @tc.type: FUNC 556 * @tc.require: 557 */ 558 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_019, testing::ext::TestSize.Level1) 559 { 560 X509* cert = X509_new(); 561 PKCS12* p12 = nullptr; 562 EVP_PKEY* keypair = nullptr; 563 KeyStoreHelper keyhelper; 564 565 std::string keyStorePath = "./generateKeyPair/OpenHarmonyNullpwd.p12"; 566 std::string alias = "oh-app1-key-v1"; 567 568 keypair = keyhelper.GenerateKeyPair("ECC", 256); 569 keyhelper.InitX509(*cert, *keypair); 570 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), nullptr, nullptr, alias.c_str(), keypair, cert); 571 int ret = keyhelper.Pkcs12PasswordParse(p12, nullptr, ""); 572 EXPECT_EQ(ret, RET_OK); 573 } 574 575 /* 576 * @tc.name: generate_keypair_test_020 577 * @tc.desc: Keystore password parsing. 578 * @tc.type: FUNC 579 * @tc.require: 580 */ 581 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_020, testing::ext::TestSize.Level1) 582 { 583 X509* cert = X509_new(); 584 PKCS12* p12 = nullptr; 585 EVP_PKEY* keypair = nullptr; 586 KeyStoreHelper keyhelper; 587 588 std::string keyStorePath = "./generateKeyPair/OpenHarmonyNullpwd.p12"; 589 char storePwd[] = ""; 590 std::string alias = "oh-app1-key-v1"; 591 char keyPwd[] = ""; 592 593 keypair = keyhelper.GenerateKeyPair("ECC", 256); 594 keyhelper.InitX509(*cert, *keypair); 595 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert); 596 int ret = keyhelper.Pkcs12PasswordParse(p12, nullptr, ""); 597 EXPECT_EQ(ret, RET_OK); 598 } 599 600 /* 601 * @tc.name: generate_keypair_test_021 602 * @tc.desc: Generate a key pair. 603 * @tc.type: FUNC 604 * @tc.require: 605 */ 606 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_021, testing::ext::TestSize.Level1) 607 { 608 KeyStoreHelper keyhelper; 609 EVP_PKEY* keypair = keyhelper.GenerateKeyPair("", 256); 610 EXPECT_EQ(keypair, nullptr); 611 } 612 613 /* 614 * @tc.name: generate_keypair_test_022 615 * @tc.desc: Create a pkcs12 file. 616 * @tc.type: FUNC 617 * @tc.require: 618 */ 619 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_022, testing::ext::TestSize.Level1) 620 { 621 KeyStoreHelper keyhelper; 622 PKCS12* p12 = nullptr; 623 p12 = keyhelper.CreatePKCS12(nullptr, nullptr, nullptr, nullptr, nullptr, 0, 0, 0, 0, 0, nullptr); 624 EXPECT_EQ(p12, nullptr); 625 } 626 627 /* 628 * @tc.name: generate_keypair_test_023 629 * @tc.desc: Generate a key pair. 630 * @tc.type: FUNC 631 * @tc.require: 632 */ 633 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_023, testing::ext::TestSize.Level1) 634 { 635 KeyStoreHelper keyhelper; 636 EVP_PKEY* keypair = keyhelper.GenerateKeyPair("ECC", 0); 637 EXPECT_EQ(keypair, nullptr); 638 } 639 640 /* 641 * @tc.name: generate_keypair_test_024 642 * @tc.desc: Call the SetNidMac() function. 643 * @tc.type: FUNC 644 * @tc.require: 645 */ 646 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_024, testing::ext::TestSize.Level1) 647 { 648 int nidKey = 1; 649 int iter = 1; 650 int maIter = 1; 651 KeyStoreHelper keyhelper; 652 keyhelper.SetNidMac(nidKey, iter, maIter); 653 EXPECT_NE(nidKey, 1); 654 } 655 656 /* 657 * @tc.name: generate_keypair_test_025 658 * @tc.desc: Call the SetNidMac() function. 659 * @tc.type: FUNC 660 * @tc.require: 661 */ 662 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_025, testing::ext::TestSize.Level1) 663 { 664 int nidKey = 0; 665 int iter = 0; 666 int macIter = 0; 667 KeyStoreHelper keyhelper; 668 keyhelper.SetNidMac(nidKey, iter, macIter); 669 EXPECT_EQ(macIter, 146); 670 } 671 672 /* 673 * @tc.name: generate_keypair_test_026 674 * @tc.desc: Set the public key into the pkcs12 structure. 675 * @tc.type: FUNC 676 * @tc.require: 677 */ 678 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_026, testing::ext::TestSize.Level1) 679 { 680 KeyStoreHelper keyhelper; 681 int ret = keyhelper.SetCertPkcs12(nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr, 0, 0, nullptr); 682 EXPECT_EQ(ret, RET_OK); 683 } 684 685 /* 686 * @tc.name: generate_keypair_test_027 687 * @tc.desc: Set the public key into the pkcs12 structure. 688 * @tc.type: FUNC 689 * @tc.require: 690 */ 691 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_027, testing::ext::TestSize.Level1) 692 { 693 KeyStoreHelper keyhelper; 694 X509* cert = X509_new(); 695 int ret = keyhelper.SetCertPkcs12(cert, nullptr, nullptr, nullptr, -2, nullptr, nullptr, 0, 0, nullptr); 696 EXPECT_EQ(ret, RET_FAILED); 697 } 698 699 /* 700 * @tc.name: generate_keypair_test_028 701 * @tc.desc: Set the private key into the pkcs12 structure. 702 * @tc.type: FUNC 703 * @tc.require: 704 */ 705 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_028, testing::ext::TestSize.Level1) 706 { 707 KeyStoreHelper keyhelper; 708 int ret = keyhelper.SetPkeyPkcs12(nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, 0, 0, nullptr, 0); 709 EXPECT_EQ(ret, RET_OK); 710 } 711 712 /* 713 * @tc.name: generate_keypair_test_029 714 * @tc.desc: Create a p12 file. 715 * @tc.type: FUNC 716 * @tc.require: 717 */ 718 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_029, testing::ext::TestSize.Level1) 719 { 720 X509* cert = X509_new(); 721 PKCS12* p12 = nullptr; 722 EVP_PKEY* keypair = nullptr; 723 KeyStoreHelper keyhelper; 724 STACK_OF(PKCS7)* safes = nullptr; 725 726 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12"; 727 char storePwd1[] = "99999"; 728 std::string alias = "oh-app1-key-v1"; 729 char keyPwd[] = ""; 730 731 keypair = keyhelper.GenerateKeyPair("ECC", 256); 732 keyhelper.InitX509(*cert, *keypair); 733 p12 = keyhelper.CreatePKCS12(storePwd1, keyPwd, nullptr, keypair, cert, 0, -2, -2, -1, 0, &safes); 734 EXPECT_EQ(p12, nullptr); 735 } 736 737 /* 738 * @tc.name: generate_keypair_test_030 739 * @tc.desc: Create a p12 file. 740 * @tc.type: FUNC 741 * @tc.require: 742 */ 743 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_030, testing::ext::TestSize.Level1) 744 { 745 X509* cert = X509_new(); 746 PKCS12* p12 = nullptr; 747 EVP_PKEY* keypair = nullptr; 748 KeyStoreHelper keyhelper; 749 STACK_OF(PKCS7)* safes = nullptr; 750 751 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12"; 752 char storePwd1[] = "99999"; 753 std::string alias = "oh-app1-key-v1"; 754 char keyPwd[] = ""; 755 756 keypair = keyhelper.GenerateKeyPair("ECC", 256); 757 keyhelper.InitX509(*cert, *keypair); 758 p12 = keyhelper.CreatePKCS12(storePwd1, keyPwd, nullptr, keypair, cert, -2, 0, 0, -1, 0, &safes); 759 EXPECT_EQ(p12, nullptr); 760 } 761 762 /* 763 * @tc.name: generate_keypair_test_031 764 * @tc.desc: Find the key pair by alias. 765 * @tc.type: FUNC 766 * @tc.require: 767 */ 768 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_031, testing::ext::TestSize.Level1) 769 { 770 X509* cert = X509_new(); 771 PKCS12* p12 = nullptr; 772 EVP_PKEY* keypair = nullptr; 773 KeyStoreHelper keyhelper; 774 775 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12"; 776 char storePwd[] = "123456"; 777 std::string alias = "oh-app1-key-v1"; 778 char keyPwd[] = "123456"; 779 780 keypair = keyhelper.GenerateKeyPair("ECC", 256); 781 keyhelper.InitX509(*cert, *keypair); 782 783 keyhelper.CreatePKCS12(&p12, keyStorePath.c_str(), storePwd, keyPwd, alias.c_str(), keypair, cert); 784 p12->authsafes = PKCS7_new(); 785 int ret = keyhelper.FindKeyPair(p12, "", nullptr, nullptr, nullptr, ""); 786 EXPECT_EQ(ret, RET_FAILED); 787 } 788 789 /* 790 * @tc.name: generate_keypair_test_032 791 * @tc.desc: Write the keypair to the keystore file. 792 * @tc.type: FUNC 793 * @tc.require: 794 */ 795 HWTEST_F(GenerateKeyPairTest, generate_keypair_test_032, testing::ext::TestSize.Level1) 796 { 797 KeyStoreHelper keyhelper; 798 799 std::string keyStorePath = "./generateKeyPair/OpenHarmony.p12"; 800 char storePwd[] = "123456"; 801 std::string alias = "oh-app1-key-v1"; 802 char keyPwd[] = "123456"; 803 804 int ret = keyhelper.WriteKeyStore(nullptr, keyStorePath, storePwd, alias, keyPwd); 805 EXPECT_EQ(ret, RET_FAILED); 806 } 807 } // namespace SignatureTools 808 } // namespace OHOS