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