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