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 OptionsCmdTest : 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: Options_test_001 54 * @tc.desc: get char* type value, and do type checking. 55 * @tc.type: FUNC 56 * @tc.require: 57 */ 58 HWTEST_F(OptionsCmdTest, Options_test_001, testing::ext::TestSize.Level1) 59 { 60 std::shared_ptr<Options> params = std::make_shared<Options>(); 61 char keyPwd[] = "123456"; 62 (*params)["keyPwd"] = keyPwd; 63 64 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 65 char* strPrt = adaptePtr->options->GetChars(Options::KEY_RIGHTS); 66 EXPECT_NE(strPrt, nullptr); 67 } 68 69 /* 70 * @tc.name: Options_test_002 71 * @tc.desc: get string type value, and do type checking. 72 * @tc.type: FUNC 73 * @tc.require: 74 */ 75 HWTEST_F(OptionsCmdTest, Options_test_002, testing::ext::TestSize.Level1) 76 { 77 std::shared_ptr<Options> params = std::make_shared<Options>(); 78 std::string keyAlias = "oh-app1-key-v1"; 79 (*params)["keyAlias"] = keyAlias; 80 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 81 std::string strPrt = adaptePtr->options->GetString(Options::KEY_ALIAS); 82 83 EXPECT_NE(strPrt, ""); 84 } 85 86 /* 87 * @tc.name: Options_test_003 88 * @tc.desc: get two-parameter string type value, and do type checking. 89 * @tc.type: FUNC 90 * @tc.require: 91 */ 92 HWTEST_F(OptionsCmdTest, Options_test_003, testing::ext::TestSize.Level1) 93 { 94 std::shared_ptr<Options> params = std::make_shared<Options>(); 95 std::string keyAlias = "oh-app1-key-v1"; 96 std::string str = "test"; 97 (*params)["keyAlias"] = keyAlias; 98 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 99 std::string strPrt = adaptePtr->options->GetString(Options::KEY_ALIAS, str); 100 101 if (strPrt == keyAlias) { 102 EXPECT_EQ(strPrt, keyAlias); 103 } else if (strPrt == str) { 104 EXPECT_EQ(strPrt, str); 105 } else { 106 EXPECT_EQ(strPrt, keyAlias); 107 } 108 } 109 110 /* 111 * @tc.name: Options_test_004 112 * @tc.desc: get Int type value, and do type checking. 113 * @tc.type: FUNC 114 * @tc.require: 115 */ 116 HWTEST_F(OptionsCmdTest, Options_test_004, testing::ext::TestSize.Level1) 117 { 118 std::shared_ptr<Options> params = std::make_shared<Options>(); 119 int keySize = 256; 120 (*params)["keySize"] = keySize; 121 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 122 int size = adaptePtr->options->GetInt(Options::KEY_SIZE); 123 124 EXPECT_NE(size, 0); 125 } 126 127 /* 128 * @tc.name: Options_test_005 129 * @tc.desc: Check for equality. 130 * @tc.type: FUNC 131 * @tc.require: 132 */ 133 HWTEST_F(OptionsCmdTest, Options_test_005, testing::ext::TestSize.Level1) 134 { 135 std::shared_ptr<Options> params = std::make_shared<Options>(); 136 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 137 std::string issuerkeystoreFile = "./generateKeyPair/OpenHarmony.p12"; 138 139 (*params)["keystoreFile"] = keystoreFile; 140 (*params)["issuerkeystoreFile"] = issuerkeystoreFile; 141 142 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 143 EXPECT_EQ(adaptePtr->options->Equals(Options::KEY_STORE_FILE, Options::ISSUER_KEY_STORE_FILE), false); 144 } 145 146 /* 147 * @tc.name: Options_test_006 148 * @tc.desc: Check for presence. 149 * @tc.type: FUNC 150 * @tc.require: 151 */ 152 HWTEST_F(OptionsCmdTest, Options_test_006, testing::ext::TestSize.Level1) 153 { 154 std::shared_ptr<Options> params = std::make_shared<Options>(); 155 156 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 157 std::string issuerkeystoreFile = "./generateKeyPair/OpenHarmony.p12"; 158 159 (*params)["keystoreFile"] = keystoreFile; 160 (*params)["issuerkeystoreFile"] = issuerkeystoreFile; 161 162 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 163 EXPECT_EQ(adaptePtr->options->Required({ Options::KEY_STORE_FILE, Options::ISSUER_KEY_STORE_FILE }), false); 164 } 165 /* 166 * @tc.name: Options_test_007 167 * @tc.desc: Check whether it is empty. 168 * @tc.type: FUNC 169 * @tc.require: 170 */ 171 HWTEST_F(OptionsCmdTest, Options_test_007, testing::ext::TestSize.Level1) 172 { 173 std::shared_ptr<Options> params = std::make_shared<Options>(); 174 std::string str = ""; 175 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 176 EXPECT_EQ(adaptePtr->options->IsEmpty(str), true); 177 } 178 179 /* 180 * @tc.name: Options_test_008 181 * @tc.desc: get string type value, and do type checking. 182 * @tc.type: FUNC 183 * @tc.require: 184 */ 185 HWTEST_F(OptionsCmdTest, Options_test_008, testing::ext::TestSize.Level1) 186 { 187 std::shared_ptr<Options> params = std::make_shared<Options>(); 188 std::string keyAlias = "oh-app1-key-v1"; 189 (*params)["keyAlias"]; 190 191 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 192 std::string strPrt = adaptePtr->options->GetString(Options::KEY_ALIAS); 193 EXPECT_EQ(strPrt, ""); 194 } 195 196 /* 197 * @tc.name: Options_test_009 198 * @tc.desc: get string type value, and do type checking. 199 * @tc.type: FUNC 200 * @tc.require: 201 */ 202 HWTEST_F(OptionsCmdTest, Options_test_009, testing::ext::TestSize.Level1) 203 { 204 std::shared_ptr<Options> params = std::make_shared<Options>(); 205 std::string keyAlias = "oh-app1-key-v1"; 206 (*params)["keyAlias"] = keyAlias; 207 208 std::string strPrt = params->GetString(Options::KEY_STORE_FILE); 209 EXPECT_EQ(strPrt, ""); 210 } 211 212 /* 213 * @tc.name: Options_test_010 214 * @tc.desc: get string type value, and do type checking. 215 * @tc.type: FUNC 216 * @tc.require: 217 */ 218 HWTEST_F(OptionsCmdTest, Options_test_010, testing::ext::TestSize.Level1) 219 { 220 std::shared_ptr<Options> params = std::make_shared<Options>(); 221 std::string keyAlias = "oh-app1-key-v1"; 222 char keyPwd[] = "123456"; 223 224 (*params)["keyAlias"] = keyAlias; 225 (*params)["keyPwd"] = keyPwd; 226 std::string strPrt = params->GetString(Options::KEY_RIGHTS); 227 EXPECT_EQ(strPrt, ""); 228 } 229 230 /* 231 * @tc.name: Options_test_011 232 * @tc.desc: get two-parameter string type value, and do type checking. 233 * @tc.type: FUNC 234 * @tc.require: 235 */ 236 HWTEST_F(OptionsCmdTest, Options_test_011, testing::ext::TestSize.Level1) 237 { 238 std::shared_ptr<Options> params = std::make_shared<Options>(); 239 240 std::string keyAlias = "oh-app1-key-v1"; 241 char keyPwd[] = "123456"; 242 std::string str = "abcd"; 243 244 (*params)["keyAlias"] = keyAlias; 245 (*params)["keyPwd"] = keyPwd; 246 std::string strPrt = params->GetString(Options::KEY_RIGHTS, str); 247 EXPECT_EQ(strPrt, str); 248 } 249 250 /* 251 * @tc.name: Options_test_012 252 * @tc.desc: get two-parameter string type value, and do type checking. 253 * @tc.type: FUNC 254 * @tc.require: 255 */ 256 HWTEST_F(OptionsCmdTest, Options_test_012, testing::ext::TestSize.Level1) 257 { 258 std::shared_ptr<Options> params = std::make_shared<Options>(); 259 260 std::string keyAlias = ""; 261 char keyPwd[] = "123456"; 262 std::string str = "abcd"; 263 264 (*params)["keyAlias"] = keyAlias; 265 (*params)["keyPwd"] = keyPwd; 266 std::string strPrt = params->GetString(Options::KEY_ALIAS, str); 267 EXPECT_EQ(strPrt, str); 268 } 269 270 /* 271 * @tc.name: Options_test_013 272 * @tc.desc: Check if required parameters exist. 273 * @tc.type: FUNC 274 * @tc.require: 275 */ 276 HWTEST_F(OptionsCmdTest, Options_test_013, testing::ext::TestSize.Level1) 277 { 278 std::shared_ptr<Options> params = std::make_shared<Options>(); 279 280 std::string keyAlias = "oh-app1-key-v1"; 281 std::string signAlg = "SHA256withECDSA"; 282 std::string outForm = "cert"; 283 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 284 285 (*params)["keyAlias"] = keyAlias; 286 (*params)["signAlg"] = signAlg; 287 (*params)["outForm"] = outForm; 288 (*params)["keystoreFile"] = keystoreFile; 289 bool ret = params->Required({ Options::KEY_ALIAS, Options::SIGN_ALG, Options::OUT_FORM, Options::KEY_STORE_FILE }); 290 EXPECT_EQ(ret, true); 291 } 292 293 /* 294 * @tc.name: Options_test_014 295 * @tc.desc: Check if required parameters exist. 296 * @tc.type: FUNC 297 * @tc.require: 298 */ 299 HWTEST_F(OptionsCmdTest, Options_test_014, testing::ext::TestSize.Level1) 300 { 301 std::shared_ptr<Options> params = std::make_shared<Options>(); 302 bool ret = params->Required({ "" }); 303 EXPECT_EQ(ret, true); 304 } 305 306 /* 307 * @tc.name: Options_test_015 308 * @tc.desc: Check if required parameters exist. 309 * @tc.type: FUNC 310 * @tc.require: 311 */ 312 HWTEST_F(OptionsCmdTest, Options_test_015, testing::ext::TestSize.Level1) 313 { 314 std::shared_ptr<Options> params = std::make_shared<Options>(); 315 std::string keyAlias = "oh-app1-key-v1"; 316 317 (*params)["inFile"] = keyAlias; 318 bool ret = params->Required({ Options::KEY_ALIAS }); 319 EXPECT_EQ(ret, false); 320 } 321 322 /* 323 * @tc.name: Options_test_016 324 * @tc.desc: Check whether the algorithm is in ECC format. 325 * @tc.type: FUNC 326 * @tc.require: 327 */ 328 HWTEST_F(OptionsCmdTest, Options_test_016, testing::ext::TestSize.Level1) 329 { 330 std::string keyAlg = "ECC"; 331 EXPECT_EQ(CmdUtil::JudgeAlgType(keyAlg), true); 332 } 333 334 /* 335 * @tc.name: Options_test_017 336 * @tc.desc: Check whether the algorithm length is 256 or 384. 337 * @tc.type: FUNC 338 * @tc.require: 339 */ 340 HWTEST_F(OptionsCmdTest, Options_test_017, testing::ext::TestSize.Level1) 341 { 342 int size = 256; 343 EXPECT_EQ(CmdUtil::JudgeSize(size), true); 344 } 345 346 /* 347 * @tc.name: Options_test_018 348 * @tc.desc: Write command line arguments to map. 349 * @tc.type: FUNC 350 * @tc.require: 351 */ 352 HWTEST_F(OptionsCmdTest, Options_test_018, testing::ext::TestSize.Level1) 353 { 354 char arg0[] = ""; 355 char arg1[] = "generate-keypair"; 356 char arg2[] = "-keyAlias"; 357 char arg3[] = "oh-app1-key-v1"; 358 char arg4[] = "-keyPwd"; 359 char arg5[] = "123456"; 360 char arg6[] = "-keyAlg"; 361 char arg7[] = "ECC"; 362 char arg8[] = "-keySize"; 363 char arg9[] = "NIST-P-384"; 364 char arg10[] = "-keystoreFile"; 365 char arg11[] = "./generateKeyPair/OpenHarmony.p12"; 366 char arg12[] = "-keystorePwd"; 367 char arg13[] = "123456"; 368 char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 }; 369 int argc = 14; 370 371 CmdUtil cmdUtil; 372 ParamsSharedPtr param = std::make_shared<Params>(); 373 bool ret = cmdUtil.Convert2Params(argv, argc, param); 374 375 EXPECT_EQ(ret, true); 376 } 377 378 /* 379 * @tc.name: Options_test_019 380 * @tc.desc: Gets command line arguments. 381 * @tc.type: FUNC 382 * @tc.require: 383 */ 384 HWTEST_F(OptionsCmdTest, Options_test_019, testing::ext::TestSize.Level1) 385 { 386 char argv[][100] = { "generate-keypair", 387 "-keyAlias", "oh-app1-key-v1", 388 "-keyPwd", "123456", 389 "-keyAlg", "ECC", 390 "-keySize", "NIST-P-384", 391 "-keystoreFile", "./generateKeyPair/OpenHarmony.p12", 392 "-keystorePwd", "123456" 393 }; 394 395 ParamsSharedPtr param = std::make_shared<Params>(); 396 param->SetMethod(argv[1]); 397 ParamsTrustList params_trust_list; 398 std::vector<std::string> trustList = params_trust_list.GetTrustList(argv[1]); 399 EXPECT_EQ(trustList.empty(), true); 400 } 401 402 /* 403 * @tc.name: Options_test_020 404 * @tc.desc: Check whether the file format is p12 or jks. 405 * @tc.type: FUNC 406 * @tc.require: 407 */ 408 HWTEST_F(OptionsCmdTest, Options_test_020, testing::ext::TestSize.Level1) 409 { 410 std::shared_ptr<Options> params = std::make_shared<Options>(); 411 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 412 (*params)["keystoreFile"] = keystoreFile; 413 414 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 415 EXPECT_EQ(FileUtils::ValidFileType(adaptePtr->options->GetString(Options::KEY_STORE_FILE), 416 { "p12", "jks" }), true); 417 } 418 419 /* 420 * @tc.name: Options_test_021 421 * @tc.desc: Checks whether the type is legal. 422 * @tc.type: FUNC 423 * @tc.require: 424 */ 425 HWTEST_F(OptionsCmdTest, Options_test_021, testing::ext::TestSize.Level1) 426 { 427 std::string str = ""; 428 bool ret = CmdUtil::VerifyTypes(str); 429 430 EXPECT_EQ(ret, false); 431 } 432 433 /* 434 * @tc.name: Options_test_022 435 * @tc.desc: The sign-app module checks whether the inFile module is a valid path. 436 * @tc.type: FUNC 437 * @tc.require: 438 */ 439 HWTEST_F(OptionsCmdTest, Options_test_022, testing::ext::TestSize.Level1) 440 { 441 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 442 std::shared_ptr<Options> params = std::make_shared<Options>(); 443 444 std::string mode = "abcd"; 445 std::string keyAlias = "oh-app1-key-v1"; 446 char keyPwd[] = "123456"; 447 std::string signCode = "1"; 448 std::string signAlg = "SHA384withECDSA"; 449 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 450 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 451 std::string inFile = "OpenHarmonyDamage.p12"; 452 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 453 char keystorePwd[] = "123456"; 454 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 455 456 (*params)["mode"] = mode; 457 (*params)["keyAlias"] = keyAlias; 458 (*params)["keyPwd"] = keyPwd; 459 (*params)["signCode"] = signCode; 460 (*params)["signAlg"] = signAlg; 461 (*params)["appCertFile"] = appCertFile; 462 (*params)["profileFile"] = profileFile; 463 (*params)["inFile"] = inFile; 464 (*params)["keystoreFile"] = keystoreFile; 465 (*params)["keystorePwd"] = keystorePwd; 466 (*params)["outFile"] = outFile; 467 468 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 469 EXPECT_EQ(ret, false); 470 } 471 472 /* 473 * @tc.name: Options_test_023 474 * @tc.desc: The sign-app module checks if inform is a valid parameter. 475 * @tc.type: FUNC 476 * @tc.require: 477 */ 478 HWTEST_F(OptionsCmdTest, Options_test_023, testing::ext::TestSize.Level1) 479 { 480 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 481 std::shared_ptr<Options> params = std::make_shared<Options>(); 482 483 std::string mode = "localSign"; 484 std::string keyAlias = "oh-app1-key-v1"; 485 char keyPwd[] = "123456"; 486 std::string signCode = "1"; 487 std::string signAlg = "SHA384withECDSA"; 488 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 489 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 490 std::string inFile = "OpenHarmonyDamage.p12"; 491 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 492 char keystorePwd[] = "123456"; 493 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 494 std::string inform = "abcd"; 495 496 (*params)["mode"] = mode; 497 (*params)["keyAlias"] = keyAlias; 498 (*params)["keyPwd"] = keyPwd; 499 (*params)["signCode"] = signCode; 500 (*params)["signAlg"] = signAlg; 501 (*params)["appCertFile"] = appCertFile; 502 (*params)["profileFile"] = profileFile; 503 (*params)["inFile"] = inFile; 504 (*params)["keystoreFile"] = keystoreFile; 505 (*params)["keystorePwd"] = keystorePwd; 506 (*params)["outFile"] = outFile; 507 (*params)["inForm"] = inform; 508 509 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 510 EXPECT_EQ(ret, false); 511 } 512 513 /* 514 * @tc.name: Options_test_024 515 * @tc.desc: The sign-app module checks if signAlg is a valid parameter. 516 * @tc.type: FUNC 517 * @tc.require: 518 */ 519 HWTEST_F(OptionsCmdTest, Options_test_024, testing::ext::TestSize.Level1) 520 { 521 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 522 std::shared_ptr<Options> params = std::make_shared<Options>(); 523 524 std::string mode = "localSign"; 525 std::string keyAlias = "oh-app1-key-v1"; 526 char keyPwd[] = "123456"; 527 std::string signCode = "1"; 528 std::string signAlg = "SHA384w"; 529 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 530 std::string profileFile = ""; 531 std::string inFile = "OpenHarmonyDamage.p12"; 532 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 533 char keystorePwd[] = "123456"; 534 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 535 std::string inform = "elf"; 536 537 (*params)["mode"] = mode; 538 (*params)["keyAlias"] = keyAlias; 539 (*params)["keyPwd"] = keyPwd; 540 (*params)["signCode"] = signCode; 541 (*params)["signAlg"] = signAlg; 542 (*params)["appCertFile"] = appCertFile; 543 (*params)["profileFile"] = profileFile; 544 (*params)["inFile"] = inFile; 545 (*params)["keystoreFile"] = keystoreFile; 546 (*params)["keystorePwd"] = keystorePwd; 547 (*params)["outFile"] = outFile; 548 (*params)["inForm"] = inform; 549 550 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 551 EXPECT_EQ(ret, false); 552 } 553 554 /* 555 * @tc.name: Options_test_025 556 * @tc.desc: The sign-app module executes the branch with profileSigned = "1". 557 * @tc.type: FUNC 558 * @tc.require: 559 */ 560 HWTEST_F(OptionsCmdTest, Options_test_025, testing::ext::TestSize.Level1) 561 { 562 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 563 std::shared_ptr<Options> params = std::make_shared<Options>(); 564 565 std::string mode = "localSign"; 566 std::string keyAlias = "oh-app1-key-v1"; 567 char keyPwd[] = "123456"; 568 std::string signCode = "1"; 569 std::string signAlg = "SHA384withECDSA"; 570 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 571 std::string profileFile = "./generateKeyPair/signed-profile.txt"; 572 std::string inFile = "OpenHarmonyDamage.p12"; 573 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 574 char keystorePwd[] = "123456"; 575 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 576 std::string profileSigned = "1"; 577 578 (*params)["mode"] = mode; 579 (*params)["keyAlias"] = keyAlias; 580 (*params)["keyPwd"] = keyPwd; 581 (*params)["signCode"] = signCode; 582 (*params)["signAlg"] = signAlg; 583 (*params)["appCertFile"] = appCertFile; 584 (*params)["profileFile"] = profileFile; 585 (*params)["inFile"] = inFile; 586 (*params)["keystoreFile"] = keystoreFile; 587 (*params)["keystorePwd"] = keystorePwd; 588 (*params)["outFile"] = outFile; 589 (*params)["profileSigned"] = profileSigned; 590 591 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 592 EXPECT_EQ(ret, false); 593 } 594 595 /* 596 * @tc.name: Options_test_026 597 * @tc.desc: The sign-app module executes the branch with profileSigned = "0". 598 * @tc.type: FUNC 599 * @tc.require: 600 */ 601 HWTEST_F(OptionsCmdTest, Options_test_026, testing::ext::TestSize.Level1) 602 { 603 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 604 std::shared_ptr<Options> params = std::make_shared<Options>(); 605 606 std::string mode = "localSign"; 607 std::string keyAlias = "oh-app1-key-v1"; 608 char keyPwd[] = "123456"; 609 std::string signCode = "1"; 610 std::string signAlg = "SHA384withECDSA"; 611 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 612 std::string profileFile = "./generateKeyPair/signed-profile.txt"; 613 std::string inFile = "OpenHarmonyDamage.p12"; 614 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 615 char keystorePwd[] = "123456"; 616 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 617 std::string profileSigned = "0"; 618 619 (*params)["mode"] = mode; 620 (*params)["keyAlias"] = keyAlias; 621 (*params)["keyPwd"] = keyPwd; 622 (*params)["signCode"] = signCode; 623 (*params)["signAlg"] = signAlg; 624 (*params)["appCertFile"] = appCertFile; 625 (*params)["profileFile"] = profileFile; 626 (*params)["inFile"] = inFile; 627 (*params)["keystoreFile"] = keystoreFile; 628 (*params)["keystorePwd"] = keystorePwd; 629 (*params)["outFile"] = outFile; 630 (*params)["profileSigned"] = profileSigned; 631 632 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 633 EXPECT_EQ(ret, false); 634 } 635 636 /* 637 * @tc.name: Options_test_027 638 * @tc.desc: sign-app module parameter validation. 639 * @tc.type: FUNC 640 * @tc.require: 641 */ 642 HWTEST_F(OptionsCmdTest, Options_test_027, testing::ext::TestSize.Level1) 643 { 644 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 645 std::shared_ptr<Options> params = std::make_shared<Options>(); 646 647 std::string mode = "localSign"; 648 std::string keyAlias = "oh-app1-key-v1"; 649 char keyPwd[] = "123456"; 650 std::string signCode = "1"; 651 std::string signAlg = "SHA384withECDSA"; 652 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 653 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 654 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 655 char keystorePwd[] = "123456"; 656 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 657 658 (*params)["mode"] = mode; 659 (*params)["keyAlias"] = keyAlias; 660 (*params)["keyPwd"] = keyPwd; 661 (*params)["signCode"] = signCode; 662 (*params)["signAlg"] = signAlg; 663 (*params)["appCertFile"] = appCertFile; 664 (*params)["profileFile"] = profileFile; 665 (*params)["keystoreFile"] = keystoreFile; 666 (*params)["keystorePwd"] = keystorePwd; 667 (*params)["outFile"] = outFile; 668 669 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 670 EXPECT_EQ(ret, false); 671 } 672 673 /* 674 * @tc.name: Options_test_028 675 * @tc.desc: sign-app module parameter validation. 676 * @tc.type: FUNC 677 * @tc.require: 678 */ 679 HWTEST_F(OptionsCmdTest, Options_test_028, testing::ext::TestSize.Level1) 680 { 681 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 682 std::shared_ptr<Options> params = std::make_shared<Options>(); 683 684 std::string mode = "localSign"; 685 std::string keyAlias = "oh-app1-key-v1"; 686 char keyPwd[] = "123456"; 687 std::string signCode = "1"; 688 std::string signAlg = "SHA384withECDSA"; 689 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 690 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 691 std::string inFile = "OpenHarmonyDamage.p12"; 692 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 693 char keystorePwd[] = "123456"; 694 695 (*params)["mode"] = mode; 696 (*params)["keyAlias"] = keyAlias; 697 (*params)["keyPwd"] = keyPwd; 698 (*params)["signCode"] = signCode; 699 (*params)["signAlg"] = signAlg; 700 (*params)["appCertFile"] = appCertFile; 701 (*params)["profileFile"] = profileFile; 702 (*params)["inFile"] = inFile; 703 (*params)["keystoreFile"] = keystoreFile; 704 (*params)["keystorePwd"] = keystorePwd; 705 706 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 707 EXPECT_EQ(ret, false); 708 } 709 710 /* 711 * @tc.name: Options_test_029 712 * @tc.desc: sign-app module parameter validation. 713 * @tc.type: FUNC 714 * @tc.require: 715 */ 716 HWTEST_F(OptionsCmdTest, Options_test_029, testing::ext::TestSize.Level1) 717 { 718 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 719 std::shared_ptr<Options> params = std::make_shared<Options>(); 720 721 std::string mode = "localSign"; 722 std::string keyAlias = "oh-app1-key-v1"; 723 char keyPwd[] = "123456"; 724 std::string signCode = "1"; 725 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 726 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 727 std::string inFile = "OpenHarmonyDamage.p12"; 728 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 729 char keystorePwd[] = "123456"; 730 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 731 732 (*params)["mode"] = mode; 733 (*params)["keyAlias"] = keyAlias; 734 (*params)["keyPwd"] = keyPwd; 735 (*params)["signCode"] = signCode; 736 (*params)["appCertFile"] = appCertFile; 737 (*params)["profileFile"] = profileFile; 738 (*params)["inFile"] = inFile; 739 (*params)["keystoreFile"] = keystoreFile; 740 (*params)["keystorePwd"] = keystorePwd; 741 (*params)["outFile"] = outFile; 742 743 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 744 EXPECT_EQ(ret, false); 745 } 746 747 /* 748 * @tc.name: Options_test_030 749 * @tc.desc: sign-app module parameter validation. 750 * @tc.type: FUNC 751 * @tc.require: 752 */ 753 HWTEST_F(OptionsCmdTest, Options_test_030, testing::ext::TestSize.Level1) 754 { 755 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 756 std::shared_ptr<Options> params = std::make_shared<Options>(); 757 758 std::string mode = "localSign"; 759 std::string keyAlias = "oh-app1-key-v1"; 760 char keyPwd[] = "123456"; 761 std::string signCode = "1"; 762 std::string signAlg = "SHA384withECDSA"; 763 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 764 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 765 std::string inFile = "OpenHarmonyDamage.p12"; 766 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 767 char keystorePwd[] = "123456"; 768 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 769 770 (*params)["mode"] = mode; 771 (*params)["keyAlias"] = keyAlias; 772 (*params)["keyPwd"] = keyPwd; 773 (*params)["signCode"] = signCode; 774 (*params)["signAlg"] = signAlg; 775 (*params)["appCertFile"] = appCertFile; 776 (*params)["profileFile"] = profileFile; 777 (*params)["inFile"] = inFile; 778 (*params)["keystoreFile"] = keystoreFile; 779 (*params)["keystorePwd"] = keystorePwd; 780 (*params)["outFile"] = outFile; 781 782 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 783 EXPECT_EQ(ret, false); 784 } 785 786 /* 787 * @tc.name: Options_test_031 788 * @tc.desc: sign-app module parameter validation. 789 * @tc.type: FUNC 790 * @tc.require: 791 */ 792 HWTEST_F(OptionsCmdTest, Options_test_031, testing::ext::TestSize.Level1) 793 { 794 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 795 std::shared_ptr<Options> params = std::make_shared<Options>(); 796 797 std::string mode = "remoteSign"; 798 std::string keyAlias = "oh-app1-key-v1"; 799 char keyPwd[] = "123456"; 800 std::string signCode = "1"; 801 std::string signAlg = "SHA384withECDSA"; 802 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 803 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 804 std::string inFile = "OpenHarmonyDamage.p12"; 805 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 806 char keystorePwd[] = "123456"; 807 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 808 809 (*params)["mode"] = mode; 810 (*params)["keyAlias"] = keyAlias; 811 (*params)["keyPwd"] = keyPwd; 812 (*params)["signCode"] = signCode; 813 (*params)["signAlg"] = signAlg; 814 (*params)["appCertFile"] = appCertFile; 815 (*params)["profileFile"] = profileFile; 816 (*params)["inFile"] = inFile; 817 (*params)["keystoreFile"] = keystoreFile; 818 (*params)["keystorePwd"] = keystorePwd; 819 (*params)["outFile"] = outFile; 820 821 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 822 EXPECT_EQ(ret, false); 823 } 824 825 /* 826 * @tc.name: Options_test_032 827 * @tc.desc: sign-app module parameter validation. 828 * @tc.type: FUNC 829 * @tc.require: 830 */ 831 HWTEST_F(OptionsCmdTest, Options_test_032, testing::ext::TestSize.Level1) 832 { 833 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 834 std::shared_ptr<Options> params = std::make_shared<Options>(); 835 836 std::string mode = "remoteResign"; 837 std::string keyAlias = "oh-app1-key-v1"; 838 char keyPwd[] = "123456"; 839 std::string signCode = "1"; 840 std::string signAlg = "SHA384withECDSA"; 841 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 842 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 843 std::string inFile = "OpenHarmonyDamage.p12"; 844 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 845 char keystorePwd[] = "123456"; 846 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 847 848 (*params)["mode"] = mode; 849 (*params)["keyAlias"] = keyAlias; 850 (*params)["keyPwd"] = keyPwd; 851 (*params)["signCode"] = signCode; 852 (*params)["signAlg"] = signAlg; 853 (*params)["appCertFile"] = appCertFile; 854 (*params)["profileFile"] = profileFile; 855 (*params)["inFile"] = inFile; 856 (*params)["keystoreFile"] = keystoreFile; 857 (*params)["keystorePwd"] = keystorePwd; 858 (*params)["outFile"] = outFile; 859 860 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 861 EXPECT_EQ(ret, false); 862 } 863 864 /* 865 * @tc.name: Options_test_033 866 * @tc.desc: Checks whether the type is legal. 867 * @tc.type: FUNC 868 * @tc.require: 869 */ 870 HWTEST_F(OptionsCmdTest, Options_test_033, testing::ext::TestSize.Level1) 871 { 872 std::string str = "clientAuthentication"; 873 bool ret = CmdUtil::VerifyType(str); 874 875 EXPECT_EQ(ret, true); 876 } 877 878 /* 879 * @tc.name: Options_test_034 880 * @tc.desc: Checks whether the type is legal. 881 * @tc.type: FUNC 882 * @tc.require: 883 */ 884 HWTEST_F(OptionsCmdTest, Options_test_034, testing::ext::TestSize.Level1) 885 { 886 std::string supportTypes = "abc,cba"; 887 std::string inputtype = "abc"; 888 bool ret = CmdUtil::VerifyType(inputtype, supportTypes); 889 890 EXPECT_EQ(ret, true); 891 } 892 893 /* 894 * @tc.name: Options_test_035 895 * @tc.desc: Checks whether the type is legal. 896 * @tc.type: FUNC 897 * @tc.require: 898 */ 899 HWTEST_F(OptionsCmdTest, Options_test_035, testing::ext::TestSize.Level1) 900 { 901 std::string supportTypes = "abc,cba"; 902 std::string inputtype = "cba"; 903 bool ret = CmdUtil::VerifyType(inputtype, supportTypes); 904 905 EXPECT_EQ(ret, true); 906 } 907 908 /* 909 * @tc.name: Options_test_036 910 * @tc.desc: sign-app module parameter validation. 911 * @tc.type: FUNC 912 * @tc.require: 913 */ 914 HWTEST_F(OptionsCmdTest, Options_test_036, testing::ext::TestSize.Level1) 915 { 916 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 917 std::shared_ptr<Options> params = std::make_shared<Options>(); 918 919 std::string mode = "remoteResign"; 920 std::string keyAlias = "oh-app1-key-v1"; 921 char keyPwd[] = "123456"; 922 std::string signCode = "1"; 923 std::string signAlg = "SHA384withECDSA"; 924 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 925 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 926 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 927 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 928 char keystorePwd[] = "123456"; 929 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 930 931 (*params)["mode"] = mode; 932 (*params)["keyAlias"] = keyAlias; 933 (*params)["keyPwd"] = keyPwd; 934 (*params)["signCode"] = signCode; 935 (*params)["signAlg"] = signAlg; 936 (*params)["appCertFile"] = appCertFile; 937 (*params)["profileFile"] = profileFile; 938 (*params)["inFile"] = inFile; 939 (*params)["keystoreFile"] = keystoreFile; 940 (*params)["keystorePwd"] = keystorePwd; 941 (*params)["outFile"] = outFile; 942 943 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 944 EXPECT_EQ(ret, false); 945 } 946 947 /* 948 * @tc.name: Options_test_037 949 * @tc.desc: sign-app module parameter validation. 950 * @tc.type: FUNC 951 * @tc.require: 952 */ 953 HWTEST_F(OptionsCmdTest, Options_test_037, testing::ext::TestSize.Level1) 954 { 955 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 956 std::shared_ptr<Options> params = std::make_shared<Options>(); 957 958 std::string mode = "remoteResign"; 959 std::string keyAlias = "oh-app1-key-v1"; 960 char keyPwd[] = "123456"; 961 std::string signCode = "1"; 962 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 963 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 964 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 965 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 966 char keystorePwd[] = "123456"; 967 968 (*params)["mode"] = mode; 969 (*params)["keyAlias"] = keyAlias; 970 (*params)["keyPwd"] = keyPwd; 971 (*params)["signCode"] = signCode; 972 (*params)["appCertFile"] = appCertFile; 973 (*params)["profileFile"] = profileFile; 974 (*params)["inFile"] = inFile; 975 (*params)["keystoreFile"] = keystoreFile; 976 (*params)["keystorePwd"] = keystorePwd; 977 978 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 979 EXPECT_EQ(ret, false); 980 } 981 982 /* 983 * @tc.name: Options_test_038 984 * @tc.desc: sign-app module parameter validation. 985 * @tc.type: FUNC 986 * @tc.require: 987 */ 988 HWTEST_F(OptionsCmdTest, Options_test_038, testing::ext::TestSize.Level1) 989 { 990 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 991 std::shared_ptr<Options> params = std::make_shared<Options>(); 992 993 std::string mode = "remoteResign"; 994 std::string keyAlias = "oh-app1-key-v1"; 995 char keyPwd[] = "123456"; 996 std::string signCode = "1"; 997 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 998 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 999 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1000 char keystorePwd[] = "123456"; 1001 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1002 1003 (*params)["mode"] = mode; 1004 (*params)["keyAlias"] = keyAlias; 1005 (*params)["keyPwd"] = keyPwd; 1006 (*params)["signCode"] = signCode; 1007 (*params)["appCertFile"] = appCertFile; 1008 (*params)["profileFile"] = profileFile; 1009 (*params)["keystoreFile"] = keystoreFile; 1010 (*params)["keystorePwd"] = keystorePwd; 1011 (*params)["outFile"] = outFile; 1012 1013 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1014 EXPECT_EQ(ret, false); 1015 } 1016 1017 /* 1018 * @tc.name: Options_test_039 1019 * @tc.desc: sign-app module parameter validation. 1020 * @tc.type: FUNC 1021 * @tc.require: 1022 */ 1023 HWTEST_F(OptionsCmdTest, Options_test_039, testing::ext::TestSize.Level1) 1024 { 1025 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1026 std::shared_ptr<Options> params = std::make_shared<Options>(); 1027 1028 std::string mode = "remoteResign"; 1029 std::string keyAlias = "oh-app1-key-v1"; 1030 char keyPwd[] = "123456"; 1031 std::string signCode = "1"; 1032 std::string signAlg = "SHA384withECDSA"; 1033 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 1034 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 1035 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1036 char keystorePwd[] = "123456"; 1037 1038 (*params)["mode"] = mode; 1039 (*params)["keyAlias"] = keyAlias; 1040 (*params)["keyPwd"] = keyPwd; 1041 (*params)["signCode"] = signCode; 1042 (*params)["signAlg"] = signAlg; 1043 (*params)["appCertFile"] = appCertFile; 1044 (*params)["profileFile"] = profileFile; 1045 (*params)["keystoreFile"] = keystoreFile; 1046 (*params)["keystorePwd"] = keystorePwd; 1047 1048 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1049 EXPECT_EQ(ret, false); 1050 } 1051 1052 /* 1053 * @tc.name: Options_test_040 1054 * @tc.desc: sign-app module parameter validation. 1055 * @tc.type: FUNC 1056 * @tc.require: 1057 */ 1058 HWTEST_F(OptionsCmdTest, Options_test_040, testing::ext::TestSize.Level1) 1059 { 1060 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1061 std::shared_ptr<Options> params = std::make_shared<Options>(); 1062 1063 std::string keyAlias = "oh-app1-key-v1"; 1064 char keyPwd[] = "123456"; 1065 std::string signCode = "1"; 1066 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 1067 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 1068 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1069 char keystorePwd[] = "123456"; 1070 1071 (*params)["keyAlias"] = keyAlias; 1072 (*params)["keyPwd"] = keyPwd; 1073 (*params)["signCode"] = signCode; 1074 (*params)["appCertFile"] = appCertFile; 1075 (*params)["profileFile"] = profileFile; 1076 (*params)["keystoreFile"] = keystoreFile; 1077 (*params)["keystorePwd"] = keystorePwd; 1078 1079 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1080 EXPECT_EQ(ret, false); 1081 } 1082 1083 /* 1084 * @tc.name: Options_test_041 1085 * @tc.desc: sign-app module parameter validation. 1086 * @tc.type: FUNC 1087 * @tc.require: 1088 */ 1089 HWTEST_F(OptionsCmdTest, Options_test_041, testing::ext::TestSize.Level1) 1090 { 1091 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1092 std::shared_ptr<Options> params = std::make_shared<Options>(); 1093 1094 std::string mode = ""; 1095 std::string keyAlias = "oh-app1-key-v1"; 1096 char keyPwd[] = "123456"; 1097 std::string signCode = "1"; 1098 std::string signAlg = ""; 1099 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 1100 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 1101 std::string inFile = ""; 1102 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1103 char keystorePwd[] = "123456"; 1104 std::string outFile = ""; 1105 1106 (*params)["mode"] = mode; 1107 (*params)["keyAlias"] = keyAlias; 1108 (*params)["keyPwd"] = keyPwd; 1109 (*params)["signCode"] = signCode; 1110 (*params)["signAlg"] = signAlg; 1111 (*params)["appCertFile"] = appCertFile; 1112 (*params)["profileFile"] = profileFile; 1113 (*params)["inFile"] = inFile; 1114 (*params)["keystoreFile"] = keystoreFile; 1115 (*params)["keystorePwd"] = keystorePwd; 1116 (*params)["outFile"] = outFile; 1117 1118 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1119 EXPECT_EQ(ret, false); 1120 } 1121 1122 /* 1123 * @tc.name: Options_test_042 1124 * @tc.desc: sign-app module parameter validation. 1125 * @tc.type: FUNC 1126 * @tc.require: 1127 */ 1128 HWTEST_F(OptionsCmdTest, Options_test_042, testing::ext::TestSize.Level1) 1129 { 1130 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1131 std::shared_ptr<Options> params = std::make_shared<Options>(); 1132 1133 std::string mode = "remoteResign"; 1134 std::string keyAlias = "oh-app1-key-v1"; 1135 char keyPwd[] = "123456"; 1136 std::string signCode = "1"; 1137 std::string signAlg = "SHA384withECDSA"; 1138 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 1139 std::string profileFile = "./generateKeyPair/signed-profile.p7b"; 1140 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1141 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1142 char keystorePwd[] = "123456"; 1143 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1144 std::string inForm = "abcd"; 1145 std::string profileSigned = "1"; 1146 1147 (*params)["mode"] = mode; 1148 (*params)["keyAlias"] = keyAlias; 1149 (*params)["keyPwd"] = keyPwd; 1150 (*params)["signCode"] = signCode; 1151 (*params)["signAlg"] = signAlg; 1152 (*params)["appCertFile"] = appCertFile; 1153 (*params)["profileFile"] = profileFile; 1154 (*params)["inFile"] = inFile; 1155 (*params)["keystoreFile"] = keystoreFile; 1156 (*params)["keystorePwd"] = keystorePwd; 1157 (*params)["outFile"] = outFile; 1158 (*params)["inForm"] = inForm; 1159 (*params)["profileSigned"] = profileSigned; 1160 1161 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1162 EXPECT_EQ(ret, false); 1163 } 1164 1165 /* 1166 * @tc.name: Options_test_043 1167 * @tc.desc: sign-app module parameter validation. 1168 * @tc.type: FUNC 1169 * @tc.require: 1170 */ 1171 HWTEST_F(OptionsCmdTest, Options_test_043, testing::ext::TestSize.Level1) 1172 { 1173 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1174 std::shared_ptr<Options> params = std::make_shared<Options>(); 1175 1176 std::string mode = "remoteResign"; 1177 std::string keyAlias = "oh-app1-key-v1"; 1178 char keyPwd[] = "123456"; 1179 std::string signCode = "1"; 1180 std::string signAlg = "SHA384withECDSA"; 1181 std::string appCertFile = "./generateKeyPair/app-release1.pem"; 1182 std::string profileFile = "./generateKeyPair/profile.json"; 1183 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1184 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1185 char keystorePwd[] = "123456"; 1186 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1187 std::string inForm = "abcd"; 1188 std::string profileSigned = "0"; 1189 1190 (*params)["mode"] = mode; 1191 (*params)["keyAlias"] = keyAlias; 1192 (*params)["keyPwd"] = keyPwd; 1193 (*params)["signCode"] = signCode; 1194 (*params)["signAlg"] = signAlg; 1195 (*params)["appCertFile"] = appCertFile; 1196 (*params)["profileFile"] = profileFile; 1197 (*params)["inFile"] = inFile; 1198 (*params)["keystoreFile"] = keystoreFile; 1199 (*params)["keystorePwd"] = keystorePwd; 1200 (*params)["outFile"] = outFile; 1201 (*params)["inForm"] = inForm; 1202 (*params)["profileSigned"] = profileSigned; 1203 1204 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1205 EXPECT_EQ(ret, false); 1206 } 1207 1208 /* 1209 * @tc.name: Options_test_044 1210 * @tc.desc: generate-app-cert module parameter inspection. 1211 * @tc.type: FUNC 1212 * @tc.require: 1213 */ 1214 HWTEST_F(OptionsCmdTest, Options_test_044, testing::ext::TestSize.Level1) 1215 { 1216 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1217 std::shared_ptr<Options> params = std::make_shared<Options>(); 1218 1219 std::string keyAlias = "oh-app1-key-v1"; 1220 char keyPwd[] = "123456"; 1221 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1222 std::string issuerKeyAlias = "abcd"; 1223 std::string subject = "abcd"; 1224 std::string signAlg = "SHA256withECDSA"; 1225 std::string outForm = "cert"; 1226 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1227 char keystorePwd[] = "123456"; 1228 std::string outFile = "./generateKeyPair/app1.txt"; 1229 1230 (*params)["keyAlias"] = keyAlias; 1231 (*params)["keyPwd"] = keyPwd; 1232 (*params)["issuer"] = issuer; 1233 (*params)["issuerKeyAlias"] = issuerKeyAlias; 1234 (*params)["signAlg"] = signAlg; 1235 (*params)["subject"] = subject; 1236 (*params)["outForm"] = outForm; 1237 (*params)["keystoreFile"] = keystoreFile; 1238 (*params)["keystorePwd"] = keystorePwd; 1239 (*params)["outFile"] = outFile; 1240 1241 bool ret = ParamsRunTool::CheckEndCertArguments(*params); 1242 EXPECT_EQ(ret, false); 1243 } 1244 1245 /* 1246 * @tc.name: Options_test_045 1247 * @tc.desc: sign-app module parameter validation. 1248 * @tc.type: FUNC 1249 * @tc.require: 1250 */ 1251 HWTEST_F(OptionsCmdTest, Options_test_045, testing::ext::TestSize.Level1) 1252 { 1253 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1254 std::shared_ptr<Options> params = std::make_shared<Options>(); 1255 1256 std::string mode = "remoteResign"; 1257 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1258 std::string outFile = "./generateKeyPair/test A/abc"; 1259 std::string signAlg = "SHA384withECDSA"; 1260 1261 (*params)["mode"] = mode; 1262 (*params)["inFile"] = inFile; 1263 (*params)["outFile"] = outFile; 1264 (*params)["signAlg"] = signAlg; 1265 1266 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1267 EXPECT_EQ(ret, false); 1268 } 1269 1270 /* 1271 * @tc.name: Options_test_046 1272 * @tc.desc: sign-app module parameter validation. 1273 * @tc.type: FUNC 1274 * @tc.require: 1275 */ 1276 HWTEST_F(OptionsCmdTest, Options_test_046, testing::ext::TestSize.Level1) 1277 { 1278 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1279 std::shared_ptr<Options> params = std::make_shared<Options>(); 1280 1281 std::string mode = "remoteSign"; 1282 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1283 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1284 std::string signAlg = "SHA384withECDSA"; 1285 1286 (*params)["mode"] = mode; 1287 (*params)["inFile"] = inFile; 1288 (*params)["outFile"] = outFile; 1289 (*params)["signAlg"] = signAlg; 1290 1291 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1292 EXPECT_EQ(ret, false); 1293 } 1294 1295 /* 1296 * @tc.name: Options_test_047 1297 * @tc.desc: sign-app module parameter validation. 1298 * @tc.type: FUNC 1299 * @tc.require: 1300 */ 1301 HWTEST_F(OptionsCmdTest, Options_test_047, testing::ext::TestSize.Level1) 1302 { 1303 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1304 std::shared_ptr<Options> params = std::make_shared<Options>(); 1305 1306 std::string mode = "abc"; 1307 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1308 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1309 std::string signAlg = "SHA384withECDSA"; 1310 1311 (*params)["mode"] = mode; 1312 (*params)["inFile"] = inFile; 1313 (*params)["outFile"] = outFile; 1314 (*params)["signAlg"] = signAlg; 1315 1316 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1317 EXPECT_EQ(ret, false); 1318 } 1319 1320 /* 1321 * @tc.name: Options_test_048 1322 * @tc.desc: sign-app module parameter validation. 1323 * @tc.type: FUNC 1324 * @tc.require: 1325 */ 1326 HWTEST_F(OptionsCmdTest, Options_test_048, testing::ext::TestSize.Level1) 1327 { 1328 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1329 std::shared_ptr<Options> params = std::make_shared<Options>(); 1330 1331 std::string mode = "localSign"; 1332 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1333 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1334 std::string signAlg = "SHA384withECDSA"; 1335 1336 (*params)["mode"] = mode; 1337 (*params)["inFile"] = inFile; 1338 (*params)["outFile"] = outFile; 1339 (*params)["signAlg"] = signAlg; 1340 1341 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1342 EXPECT_EQ(ret, false); 1343 } 1344 1345 /* 1346 * @tc.name: Options_test_049 1347 * @tc.desc: sign-app module parameter validation. 1348 * @tc.type: FUNC 1349 * @tc.require: 1350 */ 1351 HWTEST_F(OptionsCmdTest, Options_test_049, testing::ext::TestSize.Level1) 1352 { 1353 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1354 std::shared_ptr<Options> params = std::make_shared<Options>(); 1355 1356 std::string mode = "localSign"; 1357 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1358 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1359 std::string signAlg = "SHA384withECDSA"; 1360 std::string keystoreFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1361 std::string keyAlias = "oh-app1-key-v1"; 1362 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1363 1364 (*params)["mode"] = mode; 1365 (*params)["inFile"] = inFile; 1366 (*params)["outFile"] = outFile; 1367 (*params)["signAlg"] = signAlg; 1368 (*params)["keystoreFile"] = keystoreFile; 1369 (*params)["keyAlias"] = keyAlias; 1370 (*params)["appCertFile"] = appCertFile; 1371 1372 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1373 EXPECT_EQ(ret, false); 1374 } 1375 1376 /* 1377 * @tc.name: Options_test_050 1378 * @tc.desc: sign-app module parameter validation. 1379 * @tc.type: FUNC 1380 * @tc.require: 1381 */ 1382 HWTEST_F(OptionsCmdTest, Options_test_050, testing::ext::TestSize.Level1) 1383 { 1384 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1385 std::shared_ptr<Options> params = std::make_shared<Options>(); 1386 1387 std::string mode = "localSign"; 1388 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1389 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1390 std::string signAlg = "SHA385withECDSA"; 1391 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1392 std::string keyAlias = "oh-app1-key-v1"; 1393 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1394 std::string profileFile = "./generateKeyPair/profile.json"; 1395 std::string inForm = ""; 1396 1397 (*params)["mode"] = mode; 1398 (*params)["inFile"] = inFile; 1399 (*params)["outFile"] = outFile; 1400 (*params)["signAlg"] = signAlg; 1401 (*params)["keystoreFile"] = keystoreFile; 1402 (*params)["keyAlias"] = keyAlias; 1403 (*params)["appCertFile"] = appCertFile; 1404 (*params)["profileFile"] = profileFile; 1405 (*params)["inForm"] = inForm; 1406 1407 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1408 EXPECT_EQ(ret, false); 1409 } 1410 1411 /* 1412 * @tc.name: Options_test_051 1413 * @tc.desc: sign-app module parameter validation. 1414 * @tc.type: FUNC 1415 * @tc.require: 1416 */ 1417 HWTEST_F(OptionsCmdTest, Options_test_051, testing::ext::TestSize.Level1) 1418 { 1419 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1420 std::shared_ptr<Options> params = std::make_shared<Options>(); 1421 1422 std::string mode = "localSign"; 1423 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1424 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1425 std::string signAlg = "SHA384withECDSA"; 1426 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1427 std::string keyAlias = "oh-app1-key-v1"; 1428 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1429 std::string inForm = "elf"; 1430 1431 (*params)["mode"] = mode; 1432 (*params)["inFile"] = inFile; 1433 (*params)["outFile"] = outFile; 1434 (*params)["signAlg"] = signAlg; 1435 (*params)["keystoreFile"] = keystoreFile; 1436 (*params)["keyAlias"] = keyAlias; 1437 (*params)["appCertFile"] = appCertFile; 1438 (*params)["inForm"] = inForm; 1439 1440 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1441 EXPECT_EQ(ret, false); 1442 } 1443 1444 /* 1445 * @tc.name: Options_test_052 1446 * @tc.desc: sign-app module parameter validation. 1447 * @tc.type: FUNC 1448 * @tc.require: 1449 */ 1450 HWTEST_F(OptionsCmdTest, Options_test_052, testing::ext::TestSize.Level1) 1451 { 1452 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1453 std::shared_ptr<Options> params = std::make_shared<Options>(); 1454 1455 std::string mode = "localSign"; 1456 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1457 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1458 std::string signAlg = "SHA384withECDSA"; 1459 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1460 std::string keyAlias = "oh-app1-key-v1"; 1461 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1462 std::string profileFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1463 std::string profileSigned = "1"; 1464 1465 (*params)["mode"] = mode; 1466 (*params)["inFile"] = inFile; 1467 (*params)["outFile"] = outFile; 1468 (*params)["signAlg"] = signAlg; 1469 (*params)["keystoreFile"] = keystoreFile; 1470 (*params)["keyAlias"] = keyAlias; 1471 (*params)["appCertFile"] = appCertFile; 1472 (*params)["profileSigned"] = profileSigned; 1473 (*params)["profileFile"] = profileFile; 1474 1475 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1476 EXPECT_EQ(ret, false); 1477 } 1478 1479 /* 1480 * @tc.name: Options_test_053 1481 * @tc.desc: sign-app module keystoreFile parameter validation. 1482 * @tc.type: FUNC 1483 * @tc.require: 1484 */ 1485 HWTEST_F(OptionsCmdTest, Options_test_053, testing::ext::TestSize.Level1) 1486 { 1487 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1488 std::shared_ptr<Options> params = std::make_shared<Options>(); 1489 1490 std::string mode = "localSign"; 1491 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1492 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1493 std::string signAlg = "SHA384withECDSA"; 1494 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1495 std::string keyAlias = "oh-app1-key-v1"; 1496 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1497 std::string profileFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1498 std::string profileSigned = "1"; 1499 1500 (*params)["mode"] = mode; 1501 (*params)["inFile"] = inFile; 1502 (*params)["outFile"] = outFile; 1503 (*params)["signAlg"] = signAlg; 1504 (*params)["keystoreFile"] = keystoreFile; 1505 (*params)["keyAlias"] = keyAlias; 1506 (*params)["appCertFile"] = appCertFile; 1507 (*params)["profileSigned"] = profileSigned; 1508 (*params)["profileFile"] = profileFile; 1509 1510 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1511 EXPECT_EQ(ret, false); 1512 } 1513 1514 /* 1515 * @tc.name: Options_test_054 1516 * @tc.desc: sign-app module inForm parameter validation. 1517 * @tc.type: FUNC 1518 * @tc.require: 1519 */ 1520 HWTEST_F(OptionsCmdTest, Options_test_054, testing::ext::TestSize.Level1) 1521 { 1522 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1523 std::shared_ptr<Options> params = std::make_shared<Options>(); 1524 1525 std::string mode = "localSign"; 1526 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1527 std::string outFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1528 std::string signAlg = "SHA384withECDSA"; 1529 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1530 std::string keyAlias = "oh-app1-key-v1"; 1531 std::string appCertFile = "./generateKeyPair/app-profile.p7b"; 1532 std::string profileFile = "./generateKeyPair/app-profile.p7b"; 1533 std::string profileSigned = "1"; 1534 std::string inForm = "abc"; 1535 1536 (*params)["mode"] = mode; 1537 (*params)["inFile"] = inFile; 1538 (*params)["outFile"] = outFile; 1539 (*params)["signAlg"] = signAlg; 1540 (*params)["keystoreFile"] = keystoreFile; 1541 (*params)["keyAlias"] = keyAlias; 1542 (*params)["appCertFile"] = appCertFile; 1543 (*params)["profileSigned"] = profileSigned; 1544 (*params)["profileFile"] = profileFile; 1545 (*params)["inForm"] = inForm; 1546 1547 bool ret = ParamsRunTool::RunSignApp(params.get(), *api); 1548 EXPECT_EQ(ret, false); 1549 } 1550 1551 /* 1552 * @tc.name: Options_test_055 1553 * @tc.desc: generate-ca module keystoreFile parameter validation. 1554 * @tc.type: FUNC 1555 * @tc.require: 1556 */ 1557 HWTEST_F(OptionsCmdTest, Options_test_055, testing::ext::TestSize.Level1) 1558 { 1559 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1560 std::shared_ptr<Options> params = std::make_shared<Options>(); 1561 1562 std::string keyAlias = "oh-root-ca-key-v1"; 1563 char keyPwd[] = "123456"; 1564 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Root CA"; 1565 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 1566 int validity = 365; 1567 std::string signAlg = "SHA384withECDSA"; 1568 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1569 char keystorePwd[] = "123456"; 1570 std::string outFile = "./generateKeyPair/root-ca1.cer"; 1571 std::string keyAlg = "ECC"; 1572 int keySize = 384; 1573 1574 (*params)["keyAlias"] = keyAlias; 1575 (*params)["keyPwd"] = keyPwd; 1576 (*params)["subject"] = subject; 1577 (*params)["signAlg"] = signAlg; 1578 (*params)["keystoreFile"] = keystoreFile; 1579 (*params)["keystorePwd"] = keystorePwd; 1580 (*params)["outFile"] = outFile; 1581 (*params)["keyAlg"] = keyAlg; 1582 (*params)["keySize"] = keySize; 1583 (*params)["validity"] = validity; 1584 (*params)["issuer"] = issuer; 1585 1586 bool ret = ParamsRunTool::RunCa(params.get(), *api); 1587 EXPECT_EQ(ret, false); 1588 } 1589 1590 /* 1591 * @tc.name: Options_test_056 1592 * @tc.desc: generate-cert module keystoreFile parameter validation. 1593 * @tc.type: FUNC 1594 * @tc.require: 1595 */ 1596 HWTEST_F(OptionsCmdTest, Options_test_056, testing::ext::TestSize.Level1) 1597 { 1598 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1599 std::shared_ptr<Options> params = std::make_shared<Options>(); 1600 1601 std::string keyAlias = "oh-profile1-key-v1"; 1602 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1603 std::string issuerKeyAlias = "oh-profile-sign-srv-ca-key-v1"; 1604 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1605 std::string keyUsage = "digitalSignature"; 1606 std::string signAlg = "SHA384withECDSA"; 1607 std::string keystoreFile = "./generateKeyPair/abc/OpenHarmonyDamage.p12"; 1608 std::string outFile = "./generateKeyPair/general.cer"; 1609 1610 1611 (*params)["keyAlias"] = keyAlias; 1612 (*params)["issuer"] = issuer; 1613 (*params)["issuerKeyAlias"] = issuerKeyAlias; 1614 (*params)["subject"] = subject; 1615 (*params)["signAlg"] = signAlg; 1616 (*params)["keystoreFile"] = keystoreFile; 1617 (*params)["outFile"] = outFile; 1618 (*params)["keyUsage"] = keyUsage; 1619 1620 bool ret = ParamsRunTool::RunCert(params.get(), *api); 1621 EXPECT_EQ(ret, false); 1622 } 1623 1624 /* 1625 * @tc.name: Options_test_057 1626 * @tc.desc: generate-cert module keystoreFile parameter validation. 1627 * @tc.type: FUNC 1628 * @tc.require: 1629 */ 1630 HWTEST_F(OptionsCmdTest, Options_test_057, testing::ext::TestSize.Level1) 1631 { 1632 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1633 std::shared_ptr<Options> params = std::make_shared<Options>(); 1634 1635 std::string keyAlias = "oh-profile1-key-v1"; 1636 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1637 std::string issuerKeyAlias = "oh-profile-sign-srv-ca-key-v1"; 1638 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1639 std::string keyUsage = "digitalSignature"; 1640 std::string signAlg = "SHA384withECDSA"; 1641 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1642 std::string outFile = "./generateKeyPair/general.cer"; 1643 1644 1645 (*params)["keyAlias"] = keyAlias; 1646 (*params)["issuer"] = issuer; 1647 (*params)["issuerKeyAlias"] = issuerKeyAlias; 1648 (*params)["subject"] = subject; 1649 (*params)["signAlg"] = signAlg; 1650 (*params)["keystoreFile"] = keystoreFile; 1651 (*params)["outFile"] = outFile; 1652 (*params)["keyUsage"] = keyUsage; 1653 1654 bool ret = ParamsRunTool::RunCert(params.get(), *api); 1655 EXPECT_EQ(ret, false); 1656 } 1657 1658 /* 1659 * @tc.name: Options_test_058 1660 * @tc.desc: generate-app-cert module keystoreFile parameter validation. 1661 * @tc.type: FUNC 1662 * @tc.require: 1663 */ 1664 HWTEST_F(OptionsCmdTest, Options_test_058, testing::ext::TestSize.Level1) 1665 { 1666 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1667 std::shared_ptr<Options> params = std::make_shared<Options>(); 1668 1669 std::string keyAlias = "oh-app1-key-v1"; 1670 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1671 std::string issuerKeyAlias = "oh-app-sign-srv-ca-key-v1"; 1672 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1673 std::string signAlg = "SHA384withECDSA"; 1674 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1675 std::string outFile = "./generateKeyPair/app-release1.pem"; 1676 1677 (*params)["keyAlias"] = keyAlias; 1678 (*params)["issuer"] = issuer; 1679 (*params)["issuerKeyAlias"] = issuerKeyAlias; 1680 (*params)["subject"] = subject; 1681 (*params)["signAlg"] = signAlg; 1682 (*params)["keystoreFile"] = keystoreFile; 1683 (*params)["outFile"] = outFile; 1684 1685 bool ret = ParamsRunTool::RunAppCert(params.get(), *api); 1686 EXPECT_EQ(ret, false); 1687 } 1688 1689 /* 1690 * @tc.name: Options_test_059 1691 * @tc.desc: generate-app-cert module issuerKeystoreFile parameter validation. 1692 * @tc.type: FUNC 1693 * @tc.require: 1694 */ 1695 HWTEST_F(OptionsCmdTest, Options_test_059, testing::ext::TestSize.Level1) 1696 { 1697 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1698 std::shared_ptr<Options> params = std::make_shared<Options>(); 1699 1700 std::string keyAlias = "oh-app1-key-v1"; 1701 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1702 std::string issuerKeyAlias = "oh-app-sign-srv-ca-key-v1"; 1703 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1704 std::string signAlg = "SHA384withECDSA"; 1705 std::string keystoreFile = "./generateKeyPair/OpenHarmony.p12"; 1706 std::string outFile = "./generateKeyPair/app-release1.pem"; 1707 std::string issuerKeystoreFile = "./generateKeyPair/app-profile.p7b"; 1708 1709 (*params)["keyAlias"] = keyAlias; 1710 (*params)["issuer"] = issuer; 1711 (*params)["issuerKeyAlias"] = issuerKeyAlias; 1712 (*params)["subject"] = subject; 1713 (*params)["signAlg"] = signAlg; 1714 (*params)["keystoreFile"] = keystoreFile; 1715 (*params)["outFile"] = outFile; 1716 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1717 1718 bool ret = ParamsRunTool::RunAppCert(params.get(), *api); 1719 EXPECT_EQ(ret, false); 1720 } 1721 1722 /* 1723 * @tc.name: Options_test_060 1724 * @tc.desc: generate-app-cert module keystoreFile parameter validation. 1725 * @tc.type: FUNC 1726 * @tc.require: 1727 */ 1728 HWTEST_F(OptionsCmdTest, Options_test_060, testing::ext::TestSize.Level1) 1729 { 1730 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1731 std::shared_ptr<Options> params = std::make_shared<Options>(); 1732 std::string keystoreFile = "./generateKeyPair/abc/OpenHarmony.p12"; 1733 (*params)["keystoreFile"] = keystoreFile; 1734 bool ret = ParamsRunTool::RunAppCert(params.get(), *api); 1735 EXPECT_EQ(ret, false); 1736 } 1737 1738 /* 1739 * @tc.name: Options_test_061 1740 * @tc.desc: generate-csr module keystoreFile parameter validation. 1741 * @tc.type: FUNC 1742 * @tc.require: 1743 */ 1744 HWTEST_F(OptionsCmdTest, Options_test_061, testing::ext::TestSize.Level1) 1745 { 1746 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1747 std::shared_ptr<Options> params = std::make_shared<Options>(); 1748 1749 std::string keyAlias = "oh-app1-key-v1"; 1750 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1751 std::string signAlg = "SHA256withECDSA"; 1752 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1753 std::string outFile = "./generateKeyPair/oh-app1-key-v1.csr"; 1754 1755 (*params)["keyAlias"] = keyAlias; 1756 (*params)["subject"] = subject; 1757 (*params)["signAlg"] = signAlg; 1758 (*params)["keystoreFile"] = keystoreFile; 1759 (*params)["outFile"] = outFile; 1760 1761 bool ret = ParamsRunTool::RunCsr(params.get(), *api); 1762 EXPECT_EQ(ret, false); 1763 } 1764 1765 /* 1766 * @tc.name: Options_test_062 1767 * @tc.desc: sign-profile module keystoreFile parameter validation. 1768 * @tc.type: FUNC 1769 * @tc.require: 1770 */ 1771 HWTEST_F(OptionsCmdTest, Options_test_062, testing::ext::TestSize.Level1) 1772 { 1773 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1774 std::shared_ptr<Options> params = std::make_shared<Options>(); 1775 1776 std::string mode = "localSign"; 1777 std::string inFile = "./generateKeyPair/profile.json"; 1778 std::string signAlg = "SHA384withECDSA"; 1779 std::string outFile = "./generateKeyPair/signed-profile.txt"; 1780 std::string keyAlias = "abc"; 1781 std::string keystoreFile = "./generateKeyPair/app-profile.p7b"; 1782 std::string profileCertFile = "./generateKeyPair/OpenHarmony.p12"; 1783 1784 (*params)["mode"] = mode; 1785 (*params)["inFile"] = inFile; 1786 (*params)["signAlg"] = signAlg; 1787 (*params)["outFile"] = outFile; 1788 (*params)["keyAlias"] = keyAlias; 1789 (*params)["keystoreFile"] = keystoreFile; 1790 (*params)["profileCertFile"] = profileCertFile; 1791 1792 bool ret = ParamsRunTool::RunSignProfile(params.get(), *api); 1793 EXPECT_EQ(ret, false); 1794 } 1795 1796 /* 1797 * @tc.name: Options_test_063 1798 * @tc.desc: verify-profile module inFile parameter validation. 1799 * @tc.type: FUNC 1800 * @tc.require: 1801 */ 1802 HWTEST_F(OptionsCmdTest, Options_test_063, testing::ext::TestSize.Level1) 1803 { 1804 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1805 std::shared_ptr<Options> params = std::make_shared<Options>(); 1806 1807 std::string inFile = "./generateKeyPair/OpenHarmony.p12"; 1808 std::string outFile = "./generateKeyPair/VerifyResult.json"; 1809 1810 (*params)["inFile"] = inFile; 1811 (*params)["outFile"] = outFile; 1812 1813 bool ret = ParamsRunTool::RunVerifyProfile(params.get(), *api); 1814 EXPECT_EQ(ret, false); 1815 } 1816 1817 /* 1818 * @tc.name: Options_test_064 1819 * @tc.desc: verify-app module inFile parameter validation. 1820 * @tc.type: FUNC 1821 * @tc.require: 1822 */ 1823 HWTEST_F(OptionsCmdTest, Options_test_064, testing::ext::TestSize.Level1) 1824 { 1825 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1826 std::shared_ptr<Options> params = std::make_shared<Options>(); 1827 1828 std::string inFile = "./generateKeyPair/OpenHarmonyDamage.p12"; 1829 (*params)["inFile"] = inFile; 1830 bool ret = ParamsRunTool::RunVerifyApp(params.get(), *api); 1831 EXPECT_EQ(ret, false); 1832 } 1833 1834 /* 1835 * @tc.name: Options_test_065 1836 * @tc.desc: verify-profile module inFile parameter validation. 1837 * @tc.type: FUNC 1838 * @tc.require: 1839 */ 1840 HWTEST_F(OptionsCmdTest, Options_test_065, testing::ext::TestSize.Level1) 1841 { 1842 std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>(); 1843 std::shared_ptr<Options> params = std::make_shared<Options>(); 1844 1845 std::string inFile = "./generateKeyPair/abc/OpenHarmonyDamage.p12"; 1846 std::string outCertChain = "abc"; 1847 std::string outProfile = "abc"; 1848 (*params)["inFile"] = inFile; 1849 (*params)["outCertChain"] = outCertChain; 1850 (*params)["outProfile"] = outProfile; 1851 bool ret = ParamsRunTool::RunVerifyApp(params.get(), *api); 1852 EXPECT_EQ(ret, false); 1853 } 1854 1855 /* 1856 * @tc.name: Options_test_067 1857 * @tc.desc: Remove the white space. 1858 * @tc.type: FUNC 1859 * @tc.require: 1860 */ 1861 HWTEST_F(OptionsCmdTest, Options_test_067, testing::ext::TestSize.Level1) 1862 { 1863 std::string str = " 123456 "; 1864 std::string params = StringUtils::Trim(str); 1865 EXPECT_EQ(params, "123456"); 1866 } 1867 1868 /* 1869 * @tc.name: Options_test_068 1870 * @tc.desc: Gets the first command line argument. 1871 * @tc.type: FUNC 1872 * @tc.require: 1873 */ 1874 HWTEST_F(OptionsCmdTest, Options_test_068, testing::ext::TestSize.Level1) 1875 { 1876 char argv[][100] = { "generate-keypair", 1877 "-keyAlias", "oh-app1-key-v1", 1878 "-keyPwd", "123456", 1879 "-keyAlg", "ECC", 1880 "-keySize", "NIST-P-384", 1881 "-keystoreFile", "./generateKeyPair/OpenHarmony.p12", 1882 "-keystorePwd", "123456" 1883 }; 1884 1885 ParamsSharedPtr param = std::make_shared<Params>(); 1886 param->SetMethod(argv[1]); 1887 EXPECT_EQ(param->GetMethod().empty(), false); 1888 } 1889 1890 /* 1891 * @tc.name: Options_test_069 1892 * @tc.desc: Gets the first command line argument. 1893 * @tc.type: FUNC 1894 * @tc.require: 1895 */ 1896 HWTEST_F(OptionsCmdTest, Options_test_069, testing::ext::TestSize.Level1) 1897 { 1898 std::string signatureAlgorithm = ParamConstants::HAP_SIG_ALGORITHM_SHA384_ECDSA; 1899 SignatureAlgorithmHelper out; 1900 bool ret = Params::GetSignatureAlgorithm(signatureAlgorithm, out); 1901 EXPECT_EQ(ret, true); 1902 } 1903 1904 /* 1905 * @tc.name: Options_test_070 1906 * @tc.desc: Gets the first command line argument. 1907 * @tc.type: FUNC 1908 * @tc.require: 1909 */ 1910 HWTEST_F(OptionsCmdTest, Options_test_070, testing::ext::TestSize.Level1) 1911 { 1912 std::string signatureAlgorithm = "123456"; 1913 SignatureAlgorithmHelper out; 1914 bool ret = Params::GetSignatureAlgorithm(signatureAlgorithm, out); 1915 EXPECT_EQ(ret, false); 1916 } 1917 } // namespace SignatureTools 1918 } // namespace OHOS