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 #include <openssl/ssl.h> 16 #include <gtest/gtest.h> 17 #include "signature_tools_log.h" 18 #include "options.h" 19 #include "sign_tool_service_impl.h" 20 #include "cert_tools.h" 21 #include "params_run_tool.h" 22 #include "localization_adapter.h" 23 #include "fs_digest_utils.h" 24 #include "constant.h" 25 #include <cstdio> 26 #include <cstring> 27 28 namespace OHOS { 29 namespace SignatureTools { 30 31 class GenerateCaTest : public testing::Test { 32 public: SetUpTestCase()33 static void SetUpTestCase() 34 { 35 }; TearDownTestCase()36 static void TearDownTestCase() 37 { 38 }; SetUp()39 void SetUp() 40 { 41 }; TearDown()42 void TearDown() 43 { 44 }; 45 }; 46 47 /** 48 * @tc.name: generate_sub_cert_to_file_test_004 49 * @tc.desc: Test function of GenerateSubCertToFile() interface for add error branch FAILED. 50 * @tc.type: FUNC 51 * @tc.require: SR000H63TL 52 */ 53 HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_004, testing::ext::TestSize.Level1) 54 { 55 std::shared_ptr<Options> params = std::make_shared<Options>(); 56 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 57 std::string keyAlias = "alias"; 58 std::string issuerkeyAlias = "oh-app1-key-v1"; 59 std::string keyAlg = "ECC"; 60 int keySize = 256; 61 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 62 char keystorePwd[] = "123456"; 63 std::string signAlg = "SHA384withECDSA"; 64 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 65 std::string issuer = ""; 66 char secret[] = "123456"; 67 char isksPwd[] = "123456"; 68 (*params)["keyPwd"] = secret; 69 (*params)["issuerKeystorePwd"] = isksPwd; 70 (*params)["keyAlias"] = keyAlias; 71 (*params)["keyAlg"] = keyAlg; 72 (*params)["keySize"] = keySize; 73 (*params)["keystoreFile"] = keystoreFile; 74 (*params)["keystorePwd"] = keystorePwd; 75 (*params)["signAlg"] = signAlg; 76 (*params)["subject"] = subject; 77 (*params)["issuer"] = issuer; 78 (*params)["issuerkeyAlias"] = issuerkeyAlias; 79 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 80 EVP_PKEY* keyPair = nullptr; 81 keyPair = adaptePtr->GetAliasKey(true); 82 EXPECT_NE(keyPair, nullptr); 83 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 84 EXPECT_NE(csr, nullptr); 85 X509* cert = CertTools::GenerateRootCertificate(keyPair, csr, params.get()); 86 EXPECT_NE(cert, nullptr); 87 bool ret = api->GenerateSubCertToFile(params.get(), keyPair); 88 EXPECT_EQ(ret, false); 89 } 90 /** 91 * @tc.name: generate_sub_cert_to_file_test_005 92 * @tc.desc: Test function of GenerateCaToFile() interface for error keyalias FAILED. 93 * @tc.type: FUNC 94 * @tc.require: SR000H63TL 95 */ 96 HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_005, testing::ext::TestSize.Level1) 97 { 98 std::shared_ptr<Options> params = std::make_shared<Options>(); 99 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 100 std::string keyAlias = "alias"; 101 std::string issuerkeyAlias = "oh-app1-key-v1"; 102 std::string keyAlg = "ECC"; 103 int keySize = 256; 104 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 105 char keystorePwd[] = "123456"; 106 std::string signAlg = "SHA384withECD"; 107 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 108 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 109 char secret[] = "123456"; 110 char ksPwd[] = "123456"; 111 char isksPwd[] = "123456"; 112 (*params)["keyPwd"] = secret; 113 (*params)["keystorePwd"] = ksPwd; 114 (*params)["issuerKeystorePwd"] = isksPwd; 115 (*params)["keyAlias"] = keyAlias; 116 (*params)["keyAlg"] = keyAlg; 117 (*params)["keySize"] = keySize; 118 (*params)["keystoreFile"] = keystoreFile; 119 (*params)["keystorePwd"] = keystorePwd; 120 (*params)["signAlg"] = signAlg; 121 (*params)["subject"] = subject; 122 (*params)["issuer"] = issuer; 123 (*params)["issuerkeyAlias"] = issuerkeyAlias; 124 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 125 EVP_PKEY* keyPair = nullptr; 126 keyPair = adaptePtr->GetAliasKey(true); 127 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 128 X509* cert = CertTools::GenerateRootCertificate(keyPair, csr, params.get()); 129 EXPECT_EQ(cert, nullptr); 130 bool ret = api->GenerateSubCertToFile(params.get(), keyPair); 131 EXPECT_EQ(ret, false); 132 } 133 134 /** 135 * @tc.name: generate_sub_cert_to_file_test_006 136 * @tc.desc: Test function of GenerateCaToFile() interface for error keystoreFile path FAILED. 137 * @tc.type: FUNC 138 * @tc.require: SR000H63TL 139 */ 140 HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_006, testing::ext::TestSize.Level1) 141 { 142 std::shared_ptr<Options> params = std::make_shared<Options>(); 143 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 144 std::string keyAlias = "alias"; 145 std::string issuerkeyAlias = "oh-app1-key-v1"; 146 std::string keyAlg = "ECC"; 147 int keySize = 256; 148 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 149 char keystorePwd[] = "123456"; 150 std::string signAlg = "SHA384withECD"; 151 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 152 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 153 char secret[] = "123456"; 154 char ksPwd[] = "123456"; 155 char isksPwd[] = "123456"; 156 (*params)["keyPwd"] = secret; 157 (*params)["keystorePwd"] = ksPwd; 158 (*params)["issuerKeystorePwd"] = isksPwd; 159 (*params)["keyAlias"] = keyAlias; 160 (*params)["keyAlg"] = keyAlg; 161 (*params)["keySize"] = keySize; 162 (*params)["keystoreFile"] = keystoreFile; 163 (*params)["keystorePwd"] = keystorePwd; 164 (*params)["signAlg"] = signAlg; 165 (*params)["subject"] = subject; 166 (*params)["issuer"] = issuer; 167 (*params)["issuerkeyAlias"] = issuerkeyAlias; 168 EVP_PKEY* keyPair = nullptr; 169 bool ret = api->GenerateSubCertToFile(params.get(), keyPair); 170 EXPECT_EQ(ret, false); 171 } 172 173 /** 174 * @tc.name: generate_sub_cert_to_file_test_007 175 * @tc.desc: Test function of GenerateCaToFile() interface for error keystoreFile path FAILED. 176 * @tc.type: FUNC 177 * @tc.require: SR000H63TL 178 */ 179 HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_007, testing::ext::TestSize.Level1) 180 { 181 std::shared_ptr<Options> params = std::make_shared<Options>(); 182 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 183 std::string keyAlias = "alias"; 184 std::string issuerkeyAlias = "oh-app1-key-v1"; 185 std::string keyAlg = "ECC"; 186 std::string signAlgorithm = "SHA256withECDSA"; 187 int keySize = 256; 188 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 189 char keystorePwd[] = "123456"; 190 std::string signAlg = "SHA384withECD"; 191 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 192 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 193 char secret[] = "123456"; 194 char ksPwd[] = "123456"; 195 char isksPwd[] = "123456"; 196 std::string outFile = "/datamt/test/generateCA/sub-ca-test.cer"; 197 (*params)["keyPwd"] = secret; 198 (*params)["keystorePwd"] = ksPwd; 199 (*params)["issuerKeystorePwd"] = isksPwd; 200 (*params)["keyAlias"] = keyAlias; 201 (*params)["keyAlg"] = keyAlg; 202 (*params)["keySize"] = keySize; 203 (*params)["keystoreFile"] = keystoreFile; 204 (*params)["keystorePwd"] = keystorePwd; 205 (*params)["signAlg"] = signAlg; 206 (*params)["subject"] = subject; 207 (*params)["issuer"] = issuer; 208 (*params)["signAlgorithm"] = signAlgorithm; 209 (*params)["issuerkeyAlias"] = issuerkeyAlias; 210 (*params)["outFile"] = outFile; 211 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 212 EVP_PKEY* keyPair = nullptr; 213 keyPair = adaptePtr->GetAliasKey(true); 214 bool ret = api->GenerateSubCertToFile(params.get(), keyPair); 215 EXPECT_EQ(ret, false); 216 } 217 218 /** 219 * @tc.name: set_cert_version_test_001 220 * @tc.desc: Test function of SetCertVersion() interface for set cert version FAILED. 221 * @tc.type: FUNC 222 * @tc.require: SR000H63TL 223 */ 224 HWTEST_F(GenerateCaTest, set_cert_version_test_001, testing::ext::TestSize.Level1) 225 { 226 X509* cert = nullptr; 227 bool res = CertTools::SetCertVersion(cert, 1); 228 EXPECT_EQ(res, false); 229 } 230 /** 231 * @tc.name: set_pubkey_and_sign_cert_test_001 232 * @tc.desc: Test function of SetPubkeyAndSignCert() interface for set cert pubey FAILED. 233 * @tc.type: FUNC 234 * @tc.require: SR000H63TL 235 */ 236 HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_001, testing::ext::TestSize.Level1) 237 { 238 std::shared_ptr<Options> params = std::make_shared<Options>(); 239 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 240 std::string keyAlias = "alias"; 241 std::string issuerkeyAlias = "oh-app1-key-v1"; 242 std::string keyAlg = "ECC"; 243 std::string signAlgorithm = "SHA256withECDSA"; 244 int keySize = 256; 245 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 246 char keystorePwd[] = "123456"; 247 std::string signAlg = "SHA384withECDSA"; 248 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 249 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 250 char secret[] = "123456"; 251 char ksPwd[] = "123456"; 252 char isksPwd[] = "123456"; 253 (*params)["keyPwd"] = secret; 254 (*params)["keystorePwd"] = ksPwd; 255 (*params)["issuerKeystorePwd"] = isksPwd; 256 (*params)["keyAlias"] = keyAlias; 257 (*params)["keyAlg"] = keyAlg; 258 (*params)["keySize"] = keySize; 259 (*params)["keystoreFile"] = keystoreFile; 260 (*params)["keystorePwd"] = keystorePwd; 261 (*params)["signAlg"] = signAlg; 262 (*params)["subject"] = subject; 263 (*params)["issuer"] = issuer; 264 (*params)["signAlgorithm"] = signAlgorithm; 265 (*params)["issuerkeyAlias"] = issuerkeyAlias; 266 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 267 EVP_PKEY* keyPair = nullptr; 268 keyPair = adaptePtr->GetAliasKey(true); 269 EXPECT_NE(keyPair, nullptr); 270 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlgorithm, subject); 271 EXPECT_NE(csr, nullptr); 272 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlgorithm, issuer); 273 EXPECT_NE(issuercsr, nullptr); 274 X509* cert = CertTools::GenerateRootCertificate(keyPair, csr, params.get()); 275 EXPECT_NE(cert, nullptr); 276 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get()); 277 EXPECT_NE(cert1, false); 278 } 279 280 281 /** 282 * @tc.name: set_pubkey_and_sign_cert_test_002 283 * @tc.desc: Test function of SetPubkeyAndSignCert() interface for sign cert FAILED. 284 * @tc.type: FUNC 285 * @tc.require: SR000H63TL 286 */ 287 HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_002, testing::ext::TestSize.Level1) 288 { 289 std::shared_ptr<Options> params = std::make_shared<Options>(); 290 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 291 std::string keyAlias = "alias"; 292 std::string issuerkeyAlias = "oh-app1-key-v1"; 293 std::string keyAlg = "ECC"; 294 std::string signAlgorithm = "SHA256withECDSA"; 295 int keySize = 256; 296 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 297 char keystorePwd[] = "123456"; 298 std::string signAlg = "SHA384withECDSA"; 299 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 300 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 301 char secret[] = "123456"; 302 char ksPwd[] = "123456"; 303 char isksPwd[] = "123456"; 304 (*params)["keyPwd"] = secret; 305 (*params)["keystorePwd"] = ksPwd; 306 (*params)["issuerKeystorePwd"] = isksPwd; 307 (*params)["keyAlias"] = keyAlias; 308 (*params)["keyAlg"] = keyAlg; 309 (*params)["keySize"] = keySize; 310 (*params)["keystoreFile"] = keystoreFile; 311 (*params)["keystorePwd"] = keystorePwd; 312 (*params)["signAlg"] = signAlg; 313 (*params)["subject"] = subject; 314 (*params)["issuer"] = issuer; 315 (*params)["signAlgorithm"] = signAlgorithm; 316 (*params)["issuerkeyAlias"] = issuerkeyAlias; 317 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 318 EVP_PKEY* keyPair = nullptr; 319 keyPair = adaptePtr->GetAliasKey(true); 320 EXPECT_NE(keyPair, nullptr); 321 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlgorithm, subject); 322 EXPECT_NE(csr, nullptr); 323 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlgorithm, issuer); 324 EXPECT_NE(issuercsr, nullptr); 325 X509* cert = nullptr; 326 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get()); 327 EXPECT_EQ(cert1, false); 328 EXPECT_EQ(cert, nullptr); 329 } 330 331 332 /** 333 * @tc.name: set_pubkey_and_sign_cert_test_003 334 * @tc.desc: Test function of SetPubkeyAndSignCert() interface with a empty csr FAILED. 335 * @tc.type: FUNC 336 * @tc.require: SR000H63TL 337 */ 338 HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_003, testing::ext::TestSize.Level1) 339 { 340 std::shared_ptr<Options> params = std::make_shared<Options>(); 341 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 342 std::string keyAlias = "alias"; 343 std::string issuerkeyAlias = "oh-app1-key-v1"; 344 std::string keyAlg = "ECC"; 345 int keySize = 256; 346 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 347 char keystorePwd[] = "123456"; 348 std::string signAlg = "SHA256withECDSA"; 349 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 350 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 351 char secret[] = "123456"; 352 char ksPwd[] = "123456"; 353 char isksPwd[] = "123456"; 354 (*params)["keyPwd"] = secret; 355 (*params)["keystorePwd"] = ksPwd; 356 (*params)["issuerKeystorePwd"] = isksPwd; 357 (*params)["keyAlias"] = keyAlias; 358 (*params)["keyAlg"] = keyAlg; 359 (*params)["keySize"] = keySize; 360 (*params)["keystoreFile"] = keystoreFile; 361 (*params)["keystorePwd"] = keystorePwd; 362 (*params)["signAlg"] = signAlg; 363 (*params)["subject"] = subject; 364 (*params)["issuer"] = issuer; 365 (*params)["issuerkeyAlias"] = issuerkeyAlias; 366 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 367 EVP_PKEY* keyPair = nullptr; 368 keyPair = adaptePtr->GetAliasKey(true); 369 X509_REQ* csr = X509_REQ_new(); 370 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 371 X509* cert = nullptr; 372 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get()); 373 EXPECT_EQ(cert1, false); 374 } 375 376 /** 377 * @tc.name: set_pubkey_and_sign_cert_test_004 378 * @tc.desc: Test function of SetPubkeyAndSignCert() interface with a null x509 cert FAILED. 379 * @tc.type: FUNC 380 * @tc.require: SR000H63TL 381 */ 382 HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_004, testing::ext::TestSize.Level1) 383 { 384 std::shared_ptr<Options> params = std::make_shared<Options>(); 385 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 386 std::string keyAlias = "alias"; 387 std::string issuerkeyAlias = "oh-app1-key-v1"; 388 std::string keyAlg = "ECC"; 389 int keySize = 256; 390 std::string keystoreFile = "/data/test/generateKeyPair/key.p12"; 391 char keystorePwd[] = "123456"; 392 std::string signAlg = "SHA256withECDSA"; 393 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 394 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 395 char secret[] = "123456"; 396 char ksPwd[] = "123456"; 397 char isksPwd[] = "123456"; 398 (*params)["keyPwd"] = secret; 399 (*params)["keystorePwd"] = ksPwd; 400 (*params)["issuerKeystorePwd"] = isksPwd; 401 (*params)["keyAlias"] = keyAlias; 402 (*params)["keyAlg"] = keyAlg; 403 (*params)["keySize"] = keySize; 404 (*params)["keystoreFile"] = keystoreFile; 405 (*params)["keystorePwd"] = keystorePwd; 406 (*params)["signAlg"] = signAlg; 407 (*params)["subject"] = subject; 408 (*params)["issuer"] = issuer; 409 (*params)["issuerkeyAlias"] = issuerkeyAlias; 410 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 411 EVP_PKEY* keyPair = nullptr; 412 keyPair = adaptePtr->GetAliasKey(true); 413 X509_REQ* csr = X509_REQ_new(); 414 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 415 X509* cert = nullptr; 416 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get()); 417 EXPECT_EQ(cert1, false); 418 } 419 420 /** 421 * @tc.name: set_pubkey_and_sign_cert_test_005 422 * @tc.desc: Test function of SetPubkeyAndSignCert() interface with a error issuercsr FAILED. 423 * @tc.type: FUNC 424 * @tc.require: SR000H63TL 425 */ 426 HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_005, testing::ext::TestSize.Level1) 427 { 428 std::shared_ptr<Options> params = std::make_shared<Options>(); 429 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 430 std::string keyAlias = "alias"; 431 std::string issuerkeyAlias = "oh-app1-key-v1"; 432 std::string keyAlg = "ECC"; 433 int keySize = 256; 434 std::string keystoreFile = "/data/test/generateKeyPair/key.p12"; 435 char keystorePwd[] = "123456"; 436 std::string signAlg = "SHA384withECDSA"; 437 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 438 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 439 char secret[] = "123456"; 440 char ksPwd[] = "123456"; 441 char isksPwd[] = "123456"; 442 (*params)["keyPwd"] = secret; 443 (*params)["keystorePwd"] = ksPwd; 444 (*params)["issuerKeystorePwd"] = isksPwd; 445 (*params)["keyAlias"] = keyAlias; 446 (*params)["keyAlg"] = keyAlg; 447 (*params)["keySize"] = keySize; 448 (*params)["keystoreFile"] = keystoreFile; 449 (*params)["keystorePwd"] = keystorePwd; 450 (*params)["signAlg"] = signAlg; 451 (*params)["subject"] = subject; 452 (*params)["issuer"] = issuer; 453 (*params)["issuerkeyAlias"] = issuerkeyAlias; 454 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 455 EVP_PKEY* keyPair = nullptr; 456 keyPair = adaptePtr->GetAliasKey(true); 457 X509_REQ* csr = X509_REQ_new(); 458 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 459 X509* cert = nullptr; 460 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get()); 461 EXPECT_EQ(cert1, false); 462 } 463 464 /** 465 * @tc.name: set_cert_serial_test_003 466 * @tc.desc: Test function of SetCertSubjectName() interface for SUCCESS. 467 * @tc.type: FUNC 468 * @tc.require: SR000H63TL 469 */ 470 HWTEST_F(GenerateCaTest, set_cert_serial_test_001, testing::ext::TestSize.Level1) 471 { 472 X509* cert = X509_new(); 473 X509_REQ* req = X509_REQ_new(); 474 bool res = CertTools::SetCertSubjectName(cert, req); 475 EXPECT_EQ(res, true); 476 } 477 478 /** 479 * @tc.name: set_cert_validity_test_001 480 * @tc.desc: Test function of SetCertValidityStartAndEnd() interface for SUCCESS. 481 * @tc.type: FUNC 482 * @tc.require: SR000H63TL 483 */ 484 HWTEST_F(GenerateCaTest, set_cert_validity_test_001, testing::ext::TestSize.Level1) 485 { 486 X509* cert = X509_new(); 487 bool res = CertTools::SetCertValidityStartAndEnd(cert, -1, 2); 488 X509_free(cert); 489 EXPECT_EQ(res, true); 490 } 491 492 493 /** 494 * @tc.name: X509_certverify_test_001 495 * @tc.desc: Test function of X509CertVerify() interface for verify cert SUCCESS. 496 * @tc.type: FUNC 497 * @tc.require: SR000H63TL 498 */ 499 HWTEST_F(GenerateCaTest, X509_certverify_test_001, testing::ext::TestSize.Level1) 500 { 501 X509* cert = X509_new(); 502 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 503 std::shared_ptr<Options> params = std::make_shared<Options>(); 504 std::string keyAlias = "alias"; 505 std::string issuerkeyAlias = "oh-app1-key-v1"; 506 char keyPwd[] = "123456"; 507 std::string keyAlg = "ECC"; 508 int keySize = 256; 509 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 510 char keystorePwd[] = "123456"; 511 std::string signAlg = "SHA384withECDSA"; 512 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 513 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 514 char secret[] = "123456"; 515 char ksPwd[] = "123456"; 516 char isksPwd[] = "123456"; 517 (*params)["keyPwd"] = secret; 518 (*params)["keystorePwd"] = ksPwd; 519 (*params)["issuerKeystorePwd"] = isksPwd; 520 (*params)["keyAlias"] = keyAlias; 521 (*params)["keyPwd"] = keyPwd; 522 (*params)["keyAlg"] = keyAlg; 523 (*params)["keySize"] = keySize; 524 (*params)["keystoreFile"] = keystoreFile; 525 (*params)["keystorePwd"] = keystorePwd; 526 (*params)["signAlg"] = signAlg; 527 (*params)["subject"] = subject; 528 (*params)["issuer"] = issuer; 529 (*params)["issuerkeyAlias"] = issuerkeyAlias; 530 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 531 EVP_PKEY* keyPair = nullptr; 532 keyPair = adaptePtr->GetAliasKey(true); 533 bool ret = api->X509CertVerify(cert, keyPair); 534 EXPECT_EQ(ret, true); 535 } 536 537 /** 538 * @tc.name: X509_certverify_test_002 539 * @tc.desc: Test function of X509CertVerify() interface with a no match key verify cert FAIL. 540 * @tc.type: FUNC 541 * @tc.require: SR000H63TL 542 */ 543 544 HWTEST_F(GenerateCaTest, X509_certverify_test_002, testing::ext::TestSize.Level1) 545 { 546 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 547 std::shared_ptr<Options> params = std::make_shared<Options>(); 548 X509* cert = X509_new(); 549 EVP_PKEY* keyPair = EVP_PKEY_new(); 550 bool ret = api->X509CertVerify(cert, keyPair); 551 EXPECT_NE(ret, false); 552 } 553 554 555 /** 556 * @tc.name: X509_certverify_test_003 557 * @tc.desc: Test function of X509CertVerify() with a match key verify cert SUCCESS. 558 * @tc.type: FUNC 559 * @tc.require: SR000H63TL 560 */ 561 HWTEST_F(GenerateCaTest, X509_certverify_test_003, testing::ext::TestSize.Level1) 562 { 563 std::shared_ptr<Options> params = std::make_shared<Options>(); 564 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 565 std::string keyAlias = "alias"; 566 std::string issuerkeyAlias = "oh-app1-key-v1"; 567 char keyPwd[] = "123456"; 568 std::string keyAlg = "ECC"; 569 int keySize = 256; 570 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 571 char keystorePwd[] = "123456"; 572 std::string signAlg = "SHA384withECDSA"; 573 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 574 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 575 char secret[] = "123456"; 576 char ksPwd[] = "123456"; 577 char isksPwd[] = "123456"; 578 (*params)["keyPwd"] = secret; 579 (*params)["keystorePwd"] = ksPwd; 580 (*params)["issuerKeystorePwd"] = isksPwd; 581 (*params)["keyAlias"] = keyAlias; 582 (*params)["keyPwd"] = keyPwd; 583 (*params)["keyAlg"] = keyAlg; 584 (*params)["keySize"] = keySize; 585 (*params)["keystoreFile"] = keystoreFile; 586 (*params)["keystorePwd"] = keystorePwd; 587 (*params)["signAlg"] = signAlg; 588 (*params)["subject"] = subject; 589 (*params)["issuer"] = issuer; 590 (*params)["issuerkeyAlias"] = issuerkeyAlias; 591 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 592 EVP_PKEY* keyPair = nullptr; 593 keyPair = adaptePtr->GetAliasKey(true); 594 EXPECT_NE(keyPair, nullptr); 595 X509* cert = X509_new(); 596 bool ret = api->X509CertVerify(cert, keyPair); 597 X509_free(cert); 598 EXPECT_EQ(ret, true); 599 } 600 601 /** 602 * @tc.name: isempty_test_001 603 * @tc.desc: Test function of IsEmpty() interface for judge empty SUCCESS. 604 * @tc.type: FUNC 605 * @tc.require: SR000H63TL 606 */ 607 HWTEST_F(GenerateCaTest, isempty_test_001, testing::ext::TestSize.Level1) 608 { 609 std::string cs = ""; 610 bool res = FileUtils::IsEmpty(cs); 611 EXPECT_EQ(res, true); 612 } 613 /** 614 * @tc.name: Read_File_By_Offset_And_Length_test_001 615 * @tc.desc: Test function of ReadInputByOffsetAndLength() interface for read SUCCESS. 616 * @tc.type: FUNC 617 * @tc.require: SR000H63TL 618 */ 619 HWTEST_F(GenerateCaTest, Read_File_By_Offset_And_Length_test_001, testing::ext::TestSize.Level1) 620 { 621 std::ifstream file("/data/test/generateKeyPair/keypair.p12"); 622 std::string ret("std::string& ret"); 623 int res = FileUtils::ReadFileByOffsetAndLength(file, 1, 50, ret); 624 EXPECT_EQ(res, 0); 625 } 626 /** 627 * @tc.name: Read_File_By_Offset_And_Length_test_002 628 * @tc.desc: Test function of ReadInputByOffsetAndLength() interface for read FAIL. 629 * @tc.type: FUNC 630 * @tc.require: SR000H63TL 631 */ 632 HWTEST_F(GenerateCaTest, Read_Input_By_Offset_And_Length_test_002, testing::ext::TestSize.Level1) 633 { 634 std::ifstream file("/data/test/"); 635 std::string ret("std::string& ret"); 636 int res = FileUtils::ReadInputByOffsetAndLength(file, 111, 2147483647, ret); 637 EXPECT_EQ(res, -1); 638 } 639 /** 640 * @tc.name: Read_File_By_Length_test_001 641 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface for read FAIL. 642 * @tc.type: FUNC 643 * @tc.require: SR000H63TL 644 */ 645 HWTEST_F(GenerateCaTest, Read_Input_By_Length_test_001, testing::ext::TestSize.Level1) 646 { 647 std::ifstream file("/data/test/"); 648 std::string ret("std::string& ret"); 649 int res = FileUtils::ReadInputByLength(file, 2147483647, ret); 650 EXPECT_EQ(res, -1); 651 } 652 /** 653 * @tc.name: Append_Write_File_ByOffset_To_File_test_001 654 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface for write FAIL. 655 * @tc.type: FUNC 656 * @tc.require: SR000H63TL 657 */ 658 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_001, testing::ext::TestSize.Level1) 659 { 660 std::ifstream file(""); 661 std::ofstream out(""); 662 bool res = FileUtils::AppendWriteFileByOffsetToFile(file, out, 10000, 100000); 663 EXPECT_EQ(res, false); 664 } 665 /** 666 * @tc.name: Append_Write_File_ByOffset_To_File_test_002 667 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface for write SUCCESS. 668 * @tc.type: FUNC 669 * @tc.require: SR000H63TL 670 */ 671 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_002, testing::ext::TestSize.Level1) 672 { 673 std::ifstream file("/data/test/generateKeyPair/keypair.p12"); 674 std::ofstream out("/data/test/generateKeyPair/test.txt"); 675 bool res = FileUtils::AppendWriteFileByOffsetToFile(file, out, 10, 100); 676 EXPECT_EQ(res, true); 677 } 678 /** 679 * @tc.name: Append_Write_File_ByOffset_To_File_test_003 680 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface for write FAIL. 681 * @tc.type: FUNC 682 * @tc.require: SR000H63TL 683 */ 684 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_003, testing::ext::TestSize.Level1) 685 { 686 std::ifstream file("/data/test/generateKeyPair/keypair.p12"); 687 std::ofstream out(""); 688 bool res = FileUtils::AppendWriteFileByOffsetToFile(file, out, 10, 100); 689 EXPECT_EQ(res, false); 690 } 691 /** 692 * @tc.name: Is_Runnable_File_test_001 693 * @tc.desc: Test function of IsRunnableFile() interface for judge file suffix FAIL. 694 * @tc.type: FUNC 695 * @tc.require: SR000H63TL 696 */ 697 HWTEST_F(GenerateCaTest, Is_Runnable_File_test_001, testing::ext::TestSize.Level1) 698 { 699 std::string name = ""; 700 bool res = FileUtils::IsRunnableFile(name); 701 EXPECT_EQ(res, false); 702 } 703 /** 704 * @tc.name: WriteByteToOutFile_test_001 705 * @tc.desc: Test function of WriteByteToOutFile() interface for write SUCCESS. 706 * @tc.type: FUNC 707 * @tc.require: SR000H63TL 708 */ 709 HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_001, testing::ext::TestSize.Level1) 710 { 711 std::string bytes = "587469"; 712 std::ofstream outFile("/data/test/test.txt"); 713 bool res = FileUtils::WriteByteToOutFile(bytes, outFile); 714 EXPECT_EQ(res, true); 715 } 716 /** 717 * @tc.name: WriteByteToOutFile_test_002 718 * @tc.desc: Test function of WriteByteToOutFile() interface for write FAIL. 719 * @tc.type: FUNC 720 * @tc.require: SR000H63TL 721 */ 722 HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_002, testing::ext::TestSize.Level1) 723 { 724 std::string bytes = ""; 725 std::ofstream outFile(""); 726 bool res = FileUtils::WriteByteToOutFile(bytes, outFile); 727 EXPECT_EQ(res, false); 728 } 729 /** 730 * @tc.name: ReadFile_test_002 731 * @tc.desc: Test function of ReadFile() interface for read file SUCCESS. 732 * @tc.type: FUNC 733 * @tc.require: SR000H63TL 734 */ 735 HWTEST_F(GenerateCaTest, ReadFile_test_002, testing::ext::TestSize.Level1) 736 { 737 std::string path = "/data/test/"; 738 std::string ret; 739 int res = FileUtils::ReadFile(path, ret); 740 EXPECT_EQ(res, 0); 741 } 742 /** 743 * @tc.name: WriteByteToOutFile_test_003 744 * @tc.desc: Test function of WriteByteToOutFile() interface for write SUCCESS. 745 * @tc.type: FUNC 746 * @tc.require: SR000H63TL 747 */ 748 HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_003, testing::ext::TestSize.Level1) 749 { 750 std::string bytes = "111"; 751 std::string outFile = "/data/test/test.txt"; 752 bool res = FileUtils::WriteByteToOutFile(bytes, outFile); 753 EXPECT_EQ(res, true); 754 } 755 /** 756 * @tc.name: WriteByteToOutFile_test_004 757 * @tc.desc: Test function of WriteByteToOutFile() interface for write FAIL. 758 * @tc.type: FUNC 759 * @tc.require: SR000H63TL 760 */ 761 HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_004, testing::ext::TestSize.Level1) 762 { 763 std::string bytes = "111"; 764 std::string outFile = ""; 765 int res = FileUtils::WriteByteToOutFile(bytes, outFile); 766 EXPECT_EQ(res, false); 767 } 768 /** 769 * @tc.name: ParsePkcs7Package_test_001 770 * @tc.desc: Test function of ParsePkcs7Package() interface for parse null p7b FAIL. 771 * @tc.type: FUNC 772 * @tc.require: SR000H63TL 773 */ 774 HWTEST_F(GenerateCaTest, ParsePkcs7Package_test_001, testing::ext::TestSize.Level1) 775 { 776 const unsigned char packageData[] = {0}; 777 Pkcs7Context pkcs7Context; 778 bool res = VerifyHapOpensslUtils::ParsePkcs7Package(packageData, 10, pkcs7Context); 779 EXPECT_EQ(res, false); 780 } 781 /** 782 * @tc.name: ParsePkcs7Package_test_002 783 * @tc.desc: Test function of ParsePkcs7Package() interface for parse error p7b FAIL. 784 * @tc.type: FUNC 785 * @tc.require: SR000H63TL 786 */ 787 HWTEST_F(GenerateCaTest, ParsePkcs7Package_test_002, testing::ext::TestSize.Level1) 788 { 789 const unsigned char packageData[] = {1, 1, 1, 1, 1}; 790 Pkcs7Context pkcs7Context; 791 bool res = VerifyHapOpensslUtils::ParsePkcs7Package(packageData, 10, pkcs7Context); 792 EXPECT_EQ(res, false); 793 } 794 /** 795 * @tc.name: GetCertChains_test_001 796 * @tc.desc: Test function of GetCertChains() interface for get certchain in p7b FAIL. 797 * @tc.type: FUNC 798 * @tc.require: SR000H63TL 799 */ 800 HWTEST_F(GenerateCaTest, GetCertChains_test_001, testing::ext::TestSize.Level1) 801 { 802 PKCS7* p7 = nullptr; 803 Pkcs7Context pkcs7Context; 804 bool ret = VerifyHapOpensslUtils::GetCertChains(p7, pkcs7Context); 805 EXPECT_EQ(ret, false); 806 } 807 /** 808 * @tc.name: GetCertChains_test_002 809 * @tc.desc: Test function of GetCertChains() interface for get certchain in p7b FAIL. 810 * @tc.type: FUNC 811 * @tc.require: SR000H63TL 812 */ 813 HWTEST_F(GenerateCaTest, GetCertChains_test_002, testing::ext::TestSize.Level1) 814 { 815 PKCS7* p7 = PKCS7_new(); 816 Pkcs7Context pkcs7Context; 817 bool ret = VerifyHapOpensslUtils::GetCertChains(p7, pkcs7Context); 818 PKCS7_free(p7); 819 EXPECT_EQ(ret, false); 820 } 821 822 /** 823 * @tc.name: set_bisic_constraints_patchlen_test_001 824 * @tc.desc: Test function of SetBisicConstraintsPathLen() interface for set ConstraintsPathLen in cert FAIL. 825 * @tc.type: FUNC 826 * @tc.require: SR000H63TL 827 */ 828 829 HWTEST_F(GenerateCaTest, set_bisic_constraints_patchlen_test_001, testing::ext::TestSize.Level1) 830 { 831 X509* cert = X509_new(); 832 Options options; 833 options[Options::BASIC_CONSTRAINTS_PATH_LEN] = 1; 834 bool cert1 = CertTools::SetBisicConstraintsPathLen(&options, cert); 835 EXPECT_NE(cert1, false); 836 } 837 838 /** 839 * @tc.name: sign_for_subcert_test_001 840 * @tc.desc: Test function of SignForSubCert() interface SUCCESS. 841 * @tc.type: FUNC 842 * @tc.require: SR000H63TL 843 */ 844 HWTEST_F(GenerateCaTest, sign_for_subcert_test_001, testing::ext::TestSize.Level1) 845 { 846 X509* cert = X509_new(); 847 std::shared_ptr<Options> params = std::make_shared<Options>(); 848 std::string keyAlias = "alias"; 849 std::string issuerkeyAlias = "oh-app1-key-v1"; 850 char keyPwd[] = "123456"; 851 std::string keyAlg = "ECC"; 852 int keySize = 256; 853 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 854 char keystorePwd[] = "123456"; 855 std::string signAlg = "SHA384withECDSA"; 856 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 857 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 858 char secret[] = "123456"; 859 char ksPwd[] = "123456"; 860 char isksPwd[] = "123456"; 861 (*params)["keyPwd"] = secret; 862 (*params)["keystorePwd"] = ksPwd; 863 (*params)["issuerKeystorePwd"] = isksPwd; 864 (*params)["keyAlias"] = keyAlias; 865 (*params)["keyPwd"] = keyPwd; 866 (*params)["keyAlg"] = keyAlg; 867 (*params)["keySize"] = keySize; 868 (*params)["keystoreFile"] = keystoreFile; 869 (*params)["keystorePwd"] = keystorePwd; 870 (*params)["signAlg"] = signAlg; 871 (*params)["subject"] = subject; 872 (*params)["issuer"] = issuer; 873 (*params)["issuerkeyAlias"] = issuerkeyAlias; 874 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 875 EVP_PKEY* keyPair = nullptr; 876 keyPair = adaptePtr->GetAliasKey(true); 877 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 878 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 879 bool cert1 = CertTools::SignForSubCert(cert, csr, issuercsr, keyPair, params.get()); 880 EXPECT_EQ(cert1, true); 881 } 882 883 884 /** 885 * @tc.name: sign_for_subcert_test_002 886 * @tc.desc: Test function of SignForSubCert() interface with a error keystoreFile path FAIL. 887 * @tc.type: FUNC 888 * @tc.require: SR000H63TL 889 */ 890 HWTEST_F(GenerateCaTest, sign_for_subcert_test_002, testing::ext::TestSize.Level1) 891 { 892 X509* cert = X509_new(); 893 std::shared_ptr<Options> params = std::make_shared<Options>(); 894 std::string keyAlias = "alias"; 895 std::string issuerkeyAlias = "oh-app1-key-v1"; 896 char keyPwd[] = "123456"; 897 std::string keyAlg = "ECC"; 898 int keySize = 256; 899 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 900 char keystorePwd[] = "123456"; 901 std::string signAlg = "SHA384withECDSA"; 902 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 903 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 904 char secret[] = "123456"; 905 char ksPwd[] = "123456"; 906 char isksPwd[] = "123456"; 907 (*params)["keyPwd"] = secret; 908 (*params)["keystorePwd"] = ksPwd; 909 (*params)["issuerKeystorePwd"] = isksPwd; 910 (*params)["keyAlias"] = keyAlias; 911 (*params)["keyPwd"] = keyPwd; 912 (*params)["keyAlg"] = keyAlg; 913 (*params)["keySize"] = keySize; 914 (*params)["keystoreFile"] = keystoreFile; 915 (*params)["keystorePwd"] = keystorePwd; 916 (*params)["signAlg"] = signAlg; 917 (*params)["subject"] = subject; 918 (*params)["issuer"] = issuer; 919 (*params)["issuerkeyAlias"] = issuerkeyAlias; 920 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 921 EVP_PKEY* keyPair = nullptr; 922 keyPair = adaptePtr->GetAliasKey(true); 923 EXPECT_NE(keyPair, nullptr); 924 X509_REQ* csr = X509_REQ_new(); 925 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 926 bool cert1 = CertTools::SignForSubCert(cert, csr, issuercsr, keyPair, params.get()); 927 EXPECT_EQ(cert1, false); 928 } 929 930 931 /** 932 * @tc.name: sign_for_subcert_test_003 933 * @tc.desc: Test function of SignForSubCert() interface for with a secret FAIL. 934 * @tc.type: FUNC 935 * @tc.require: SR000H63TL 936 */ 937 HWTEST_F(GenerateCaTest, sign_for_subcert_test_003, testing::ext::TestSize.Level1) 938 { 939 X509* cert = X509_new(); 940 std::shared_ptr<Options> params = std::make_shared<Options>(); 941 std::string keyAlias = "alias"; 942 std::string issuerkeyAlias = "oh-app1-key-v1"; 943 char keyPwd[] = "123456"; 944 std::string keyAlg = "ECC"; 945 int keySize = 256; 946 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 947 char keystorePwd[] = "123456"; 948 std::string signAlg = "SHA256withECDSA"; 949 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 950 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 951 char secret[] = "123456"; 952 char ksPwd[] = "123456"; 953 char isksPwd[] = "123456"; 954 (*params)["keyPwd"] = secret; 955 (*params)["keystorePwd"] = ksPwd; 956 (*params)["issuerKeystorePwd"] = isksPwd; 957 (*params)["keyAlias"] = keyAlias; 958 (*params)["keyPwd"] = keyPwd; 959 (*params)["keyAlg"] = keyAlg; 960 (*params)["keySize"] = keySize; 961 (*params)["keystoreFile"] = keystoreFile; 962 (*params)["keystorePwd"] = keystorePwd; 963 (*params)["signAlg"] = signAlg; 964 (*params)["subject"] = subject; 965 (*params)["issuer"] = issuer; 966 (*params)["issuerkeyAlias"] = issuerkeyAlias; 967 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 968 EVP_PKEY* keyPair = nullptr; 969 keyPair = adaptePtr->GetAliasKey(true); 970 EXPECT_NE(keyPair, nullptr); 971 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 972 X509_REQ* issuercsr = X509_REQ_new(); 973 bool cert1 = CertTools::SignForSubCert(cert, csr, issuercsr, keyPair, params.get()); 974 975 EXPECT_NE(cert1, false); 976 } 977 978 /** 979 * @tc.name: sign_for_subcert_test_004 980 * @tc.desc: Test function of SignForSubCert() interface for SUCCESS. 981 * @tc.type: FUNC 982 * @tc.require: SR000H63TL 983 */ 984 HWTEST_F(GenerateCaTest, sign_for_subcert_test_004, testing::ext::TestSize.Level1) 985 { 986 X509* cert = X509_new(); 987 std::shared_ptr<Options> params = std::make_shared<Options>(); 988 std::string keyAlias = "alias"; 989 std::string issuerkeyAlias = "oh-app1-key-v1"; 990 char keyPwd[] = "123456"; 991 std::string keyAlg = "ECC"; 992 int keySize = 256; 993 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 994 char keystorePwd[] = "123456"; 995 std::string signAlg = "SHA256withECDSA"; 996 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 997 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 998 char secret[] = "123456"; 999 char ksPwd[] = "123456"; 1000 char isksPwd[] = "123456"; 1001 (*params)["keyPwd"] = secret; 1002 (*params)["keystorePwd"] = ksPwd; 1003 (*params)["issuerKeystorePwd"] = isksPwd; 1004 (*params)["keyAlias"] = keyAlias; 1005 (*params)["keyPwd"] = keyPwd; 1006 (*params)["keyAlg"] = keyAlg; 1007 (*params)["keySize"] = keySize; 1008 (*params)["keystoreFile"] = keystoreFile; 1009 (*params)["keystorePwd"] = keystorePwd; 1010 (*params)["signAlg"] = signAlg; 1011 (*params)["subject"] = subject; 1012 (*params)["issuer"] = issuer; 1013 (*params)["issuerkeyAlias"] = issuerkeyAlias; 1014 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1015 EVP_PKEY* keyPair = nullptr; 1016 keyPair = adaptePtr->GetAliasKey(true); 1017 EXPECT_NE(keyPair, nullptr); 1018 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1019 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 1020 bool cert1 = CertTools::SignForSubCert(cert, csr, issuercsr, keyPair, params.get()); 1021 1022 EXPECT_EQ(cert1, true); 1023 } 1024 1025 /** 1026 * @tc.name: sign_for_subcert_test_005 1027 * @tc.desc: Test function of SignForSubCert() interface for SUCCESS. 1028 * @tc.type: FUNC 1029 * @tc.require: SR000H63TL 1030 */ 1031 HWTEST_F(GenerateCaTest, sign_for_subcert_test_005, testing::ext::TestSize.Level1) 1032 { 1033 X509* cert = X509_new(); 1034 std::shared_ptr<Options> params = std::make_shared<Options>(); 1035 std::string keyAlias = "alias"; 1036 std::string issuerkeyAlias = "oh-app1-key-v1"; 1037 char keyPwd[] = "123456"; 1038 std::string keyAlg = "ECC"; 1039 int keySize = 256; 1040 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 1041 char keystorePwd[] = "123456"; 1042 std::string signAlg = "SHA256withECDSA"; 1043 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 1044 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 1045 char secret[] = "123456"; 1046 char ksPwd[] = "123456"; 1047 char isksPwd[] = "123456"; 1048 (*params)["keyPwd"] = secret; 1049 (*params)["keystorePwd"] = ksPwd; 1050 (*params)["issuerKeystorePwd"] = isksPwd; 1051 (*params)["keyAlias"] = keyAlias; 1052 (*params)["keyPwd"] = keyPwd; 1053 (*params)["keyAlg"] = keyAlg; 1054 (*params)["keySize"] = keySize; 1055 (*params)["keystoreFile"] = keystoreFile; 1056 (*params)["keystorePwd"] = keystorePwd; 1057 (*params)["signAlg"] = signAlg; 1058 (*params)["subject"] = subject; 1059 (*params)["issuer"] = issuer; 1060 (*params)["issuerkeyAlias"] = issuerkeyAlias; 1061 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1062 EVP_PKEY* keyPair = nullptr; 1063 keyPair = adaptePtr->GetAliasKey(true); 1064 EXPECT_NE(keyPair, nullptr); 1065 X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1066 X509_REQ* issuercsr = CertTools::GenerateCsr(keyPair, signAlg, issuer); 1067 bool cert1 = CertTools::SignForSubCert(cert, csr, issuercsr, keyPair, params.get()); 1068 1069 EXPECT_EQ(cert1, true); 1070 } 1071 1072 /** 1073 * @tc.name: get_csr_test_001 1074 * @tc.desc: Test function of GetCsr() interface with empty params FAIL. 1075 * @tc.type: FUNC 1076 * @tc.require: SR000H63TL 1077 */ 1078 1079 HWTEST_F(GenerateCaTest, get_csr_test_001, testing::ext::TestSize.Level1) 1080 { 1081 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1082 std::string signAlg = ""; 1083 std::string subject = ""; 1084 EVP_PKEY* keyPair = nullptr; 1085 bool ret = api->GetCsr(keyPair, signAlg, subject); 1086 EXPECT_EQ(ret, false); 1087 } 1088 1089 /** 1090 * @tc.name: get_csr_test_002 1091 * @tc.desc: Test function of GetCsr() interface with a null key FAIL. 1092 * @tc.type: FUNC 1093 * @tc.require: SR000H63TL 1094 */ 1095 HWTEST_F(GenerateCaTest, get_csr_test_002, testing::ext::TestSize.Level1) 1096 { 1097 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1098 std::string signAlg = "SHA384withECDSA"; 1099 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 1100 EVP_PKEY* keyPair = nullptr; 1101 bool ret = api->GetCsr(keyPair, signAlg, subject); 1102 EXPECT_EQ(ret, false); 1103 } 1104 1105 /** 1106 * @tc.name: save_cert_to_file_test_002 1107 * @tc.desc: Test function of CertTools::SaveCertTofile() interface with a empty rootfile FAIL. 1108 * @tc.type: FUNC 1109 * @tc.require: SR000H63TL 1110 */ 1111 HWTEST_F(GenerateCaTest, save_cert_to_file_test_002, testing::ext::TestSize.Level1) 1112 { 1113 X509* cert = X509_new(); 1114 std::string rootoutFile = ""; 1115 bool ret = CertTools::SaveCertTofile(rootoutFile, cert); 1116 EXPECT_EQ(ret, false); 1117 } 1118 1119 /** 1120 * @tc.name: isempty_test_002 1121 * @tc.desc: Test function of IsEmpty() interface for FAIL. 1122 * @tc.type: FUNC 1123 * @tc.require: SR000H63TL 1124 */ 1125 HWTEST_F(GenerateCaTest, isempty_test_002, testing::ext::TestSize.Level1) 1126 { 1127 std::string cs = "1234"; 1128 bool res = FileUtils::IsEmpty(cs); 1129 EXPECT_EQ(res, false); 1130 } 1131 /** 1132 * @tc.name: write_test_001 1133 * @tc.desc: Test function of IsEmpty() interface with a error path FAIL. 1134 * @tc.type: FUNC 1135 * @tc.require: SR000H63TL 1136 */ 1137 HWTEST_F(GenerateCaTest, write_test_001, testing::ext::TestSize.Level1) 1138 { 1139 std::string cs = "1234"; 1140 int res = FileUtils::Write(cs, "/data/test/"); 1141 EXPECT_EQ(res, -103); 1142 } 1143 /** 1144 * @tc.name: read_test_001 1145 * @tc.desc: Test function of IsEmpty() interface with a null stream FAIL. 1146 * @tc.type: FUNC 1147 * @tc.require: SR000H63TL 1148 */ 1149 HWTEST_F(GenerateCaTest, read_test_001, testing::ext::TestSize.Level1) 1150 { 1151 std::string cs = "1234"; 1152 std::ifstream input; 1153 1154 int res = FileUtils::Read(input, cs); 1155 EXPECT_EQ(res, 0); 1156 } 1157 /** 1158 * @tc.name: Append_Write_File_ByOffset_To_File_test_004 1159 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface with a error path FAIL. 1160 * @tc.type: FUNC 1161 * @tc.require: SR000H63TL 1162 */ 1163 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_004, testing::ext::TestSize.Level1) 1164 { 1165 std::string file = "/data/test/"; 1166 std::ifstream in(file); 1167 std::ofstream out(""); 1168 bool res = FileUtils::AppendWriteFileByOffsetToFile(in, out, 10, 100); 1169 EXPECT_EQ(res, false); 1170 out.close(); 1171 in.close(); 1172 } 1173 /** 1174 * @tc.name: Append_Write_File_ByOffset_To_File_test_005 1175 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface SUCCESS. 1176 * @tc.type: FUNC 1177 * @tc.require: SR000H63TL 1178 */ 1179 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_005, testing::ext::TestSize.Level1) 1180 { 1181 std::string file = "/data/test/generateKeyPair/keypair.p12"; 1182 std::ifstream in(file); 1183 std::ofstream out("/data/test/generateKeyPair/test.txt"); 1184 bool res = FileUtils::AppendWriteFileByOffsetToFile(in, out, 10, 100); 1185 EXPECT_EQ(res, true); 1186 out.close(); 1187 in.close(); 1188 } 1189 /** 1190 * @tc.name: Append_Write_File_ByOffset_To_File_test_006 1191 * @tc.desc: Test function of AppendWriteFileByOffsetToFile() interface with a error path FAIL. 1192 * @tc.type: FUNC 1193 * @tc.require: SR000H63TL 1194 */ 1195 HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_006, testing::ext::TestSize.Level1) 1196 { 1197 std::string file = "/data/test/"; 1198 std::ifstream in(file); 1199 std::ofstream out("/data/test/generateKeyPair/test.txt"); 1200 bool res = FileUtils::AppendWriteFileByOffsetToFile(in, out, 10, 100); 1201 EXPECT_EQ(res, false); 1202 out.close(); 1203 in.close(); 1204 } 1205 1206 /** 1207 * @tc.name: Verify_Hap_test_001 1208 * @tc.desc: Test function of VerifyHapSigner() interface for hap type FAIL. 1209 * @tc.type: FUNC 1210 * @tc.require: SR000H63TL 1211 */ 1212 HWTEST_F(GenerateCaTest, Verify_Hap_test_001, testing::ext::TestSize.Level1) 1213 { 1214 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1215 std::shared_ptr<Options> params = std::make_shared<Options>(); 1216 std::string inForm = "zip"; 1217 (*params)["inForm"] = inForm; 1218 bool res = api->VerifyHapSigner(params.get()); 1219 EXPECT_EQ(res, false); 1220 } 1221 1222 /** 1223 * @tc.name: Verify_Hap_test_002 1224 * @tc.desc: Test function of VerifyHapSigner() interface for hap type FAIL. 1225 * @tc.type: FUNC 1226 * @tc.require: SR000H63TL 1227 */ 1228 HWTEST_F(GenerateCaTest, Verify_Hap_test_002, testing::ext::TestSize.Level1) 1229 { 1230 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1231 std::shared_ptr<Options> params = std::make_shared<Options>(); 1232 std::string inForm = "elf"; 1233 (*params)["inForm"] = inForm; 1234 bool res = api->VerifyHapSigner(params.get()); 1235 EXPECT_EQ(res, false); 1236 } 1237 1238 /** 1239 * @tc.name: Verify_Hap_test_003 1240 * @tc.desc: Test function of VerifyHapSigner() interface for hap type FAIL. 1241 * @tc.type: FUNC 1242 * @tc.require: SR000H63TL 1243 */ 1244 HWTEST_F(GenerateCaTest, Verify_Hap_test_003, testing::ext::TestSize.Level1) 1245 { 1246 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1247 std::shared_ptr<Options> params = std::make_shared<Options>(); 1248 std::string inForm = "bin"; 1249 (*params)["inForm"] = inForm; 1250 bool res = api->VerifyHapSigner(params.get()); 1251 EXPECT_EQ(res, false); 1252 } 1253 1254 /** 1255 * @tc.name: Verify_Hap_test_004 1256 * @tc.desc: Test function of VerifyHapSigner() interface for error type FAIL. 1257 * @tc.type: FUNC 1258 * @tc.require: SR000H63TL 1259 */ 1260 HWTEST_F(GenerateCaTest, Verify_Hap_test_004, testing::ext::TestSize.Level1) 1261 { 1262 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1263 std::shared_ptr<Options> params = std::make_shared<Options>(); 1264 std::string inForm = "mmmmm"; 1265 (*params)["inForm"] = inForm; 1266 bool res = api->VerifyHapSigner(params.get()); 1267 EXPECT_EQ(res, false); 1268 } 1269 1270 /** 1271 * @tc.name: generate_root_cert_to_flie_001 1272 * @tc.desc: Test function of GenerateRootCertToFile() interface with a null keypair FAIL. 1273 * @tc.type: FUNC 1274 * @tc.require: SR000H63TL 1275 */ 1276 HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_001, testing::ext::TestSize.Level1) 1277 { 1278 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1279 std::shared_ptr<Options> params = std::make_shared<Options>(); 1280 EVP_PKEY* keyPair = nullptr; 1281 std::string signAlg = "SHA384withECDSA"; 1282 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 1283 (*params)["signAlg"] = signAlg; 1284 (*params)["subject"] = subject; 1285 bool res = api->GenerateRootCertToFile(params.get(), keyPair); 1286 EXPECT_EQ(res, false); 1287 } 1288 1289 /** 1290 * @tc.name: generate_root_cert_to_flie_002 1291 * @tc.desc: Test function of GenerateRootCertToFile() interface with a empty subject FAIL. 1292 * @tc.type: FUNC 1293 * @tc.require: SR000H63TL 1294 */ 1295 HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_002, testing::ext::TestSize.Level1) 1296 { 1297 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1298 std::shared_ptr<Options> params = std::make_shared<Options>(); 1299 std::string keyAlias = "alias"; 1300 std::string issuerkeyAlias = "oh-app1-key-v1"; 1301 char keyPwd[] = "123456"; 1302 std::string keyAlg = "ECC"; 1303 int keySize = 256; 1304 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 1305 char keystorePwd[] = "123456"; 1306 std::string signAlg = "SHA384withECDSA"; 1307 std::string subject = ""; 1308 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 1309 char isksPwd[] = "123456"; 1310 (*params)["keystorePwd"] = keystorePwd; 1311 (*params)["issuerKeystorePwd"] = isksPwd; 1312 (*params)["keyAlias"] = keyAlias; 1313 (*params)["keyPwd"] = keyPwd; 1314 (*params)["keyAlg"] = keyAlg; 1315 (*params)["keySize"] = keySize; 1316 (*params)["keystoreFile"] = keystoreFile; 1317 (*params)["signAlg"] = signAlg; 1318 (*params)["subject"] = subject; 1319 (*params)["issuer"] = issuer; 1320 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1321 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1322 EVP_PKEY* keyPair = nullptr; 1323 keyPair = adaptePtr->GetAliasKey(true); 1324 bool res = api->GenerateRootCertToFile(params.get(), keyPair); 1325 EXPECT_EQ(res, false); 1326 } 1327 /** 1328 * @tc.name: generate_root_cert_to_flie_003 1329 * @tc.desc: Test function of GenerateRootCertToFile() interface with error keystoreFile path FAIL. 1330 * @tc.type: FUNC 1331 * @tc.require: SR000H63TL 1332 */ 1333 HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_003, testing::ext::TestSize.Level1) 1334 { 1335 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1336 std::shared_ptr<Options> params = std::make_shared<Options>(); 1337 std::string keyAlias = "alias"; 1338 std::string issuerkeyAlias = "oh-app1-key-v1"; 1339 char keyPwd[] = "123456"; 1340 std::string keyAlg = "ECC"; 1341 int keySize = 256; 1342 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 1343 char keystorePwd[] = "123456"; 1344 std::string signAlg = "SHA256withRSA"; 1345 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 1346 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 1347 char isksPwd[] = "123456"; 1348 (*params)["keystorePwd"] = keystorePwd; 1349 (*params)["issuerKeystorePwd"] = isksPwd; 1350 (*params)["keyAlias"] = keyAlias; 1351 (*params)["keyPwd"] = keyPwd; 1352 (*params)["keyAlg"] = keyAlg; 1353 (*params)["keySize"] = keySize; 1354 (*params)["keystoreFile"] = keystoreFile; 1355 (*params)["signAlg"] = signAlg; 1356 (*params)["subject"] = subject; 1357 (*params)["issuer"] = issuer; 1358 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1359 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1360 EVP_PKEY* keyPair = nullptr; 1361 keyPair = adaptePtr->GetAliasKey(true); 1362 bool res = api->GenerateRootCertToFile(params.get(), keyPair); 1363 EXPECT_EQ(res, false); 1364 } 1365 1366 /** 1367 * @tc.name: generate_root_cert_to_flie_004 1368 * @tc.desc: Test function of GenerateRootCertToFile() interface with a error issuerkeyAlias FAIL. 1369 * @tc.type: FUNC 1370 * @tc.require: SR000H63TL 1371 */ 1372 HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_004, testing::ext::TestSize.Level1) 1373 { 1374 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1375 std::shared_ptr<Options> params = std::make_shared<Options>(); 1376 std::string keyAlias = "alias"; 1377 std::string issuerkeyAlias = "oh-app1-key-v1"; 1378 char keyPwd[] = "123456"; 1379 std::string keyAlg = "ECC"; 1380 int keySize = 256; 1381 std::string keystoreFile = "/data/test/generateKeyPair/keypair.p12"; 1382 char keystorePwd[] = "123456"; 1383 std::string signAlg = "SHA384withECDSA"; 1384 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN= Openharmony Application CA"; 1385 std::string issuer = "C=CN,O=OpenHarmony_test,OU=OpenHarmony Community,CN= Openharmony Application SUB CA"; 1386 char isksPwd[] = "123456"; 1387 std::string outFile = "/datamt/test/generateCA/root-ca-test.cer"; 1388 (*params)["keystorePwd"] = keystorePwd; 1389 (*params)["issuerKeystorePwd"] = isksPwd; 1390 (*params)["keyAlias"] = keyAlias; 1391 (*params)["keyPwd"] = keyPwd; 1392 (*params)["keyAlg"] = keyAlg; 1393 (*params)["keySize"] = keySize; 1394 (*params)["keystoreFile"] = keystoreFile; 1395 (*params)["signAlg"] = signAlg; 1396 (*params)["subject"] = subject; 1397 (*params)["issuer"] = issuer; 1398 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1399 (*params)["outFile"] = outFile; 1400 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1401 EVP_PKEY* keyPair = nullptr; 1402 keyPair = adaptePtr->GetAliasKey(true); 1403 bool res = api->GenerateRootCertToFile(params.get(), keyPair); 1404 EXPECT_EQ(res, false); 1405 } 1406 1407 /** 1408 * @tc.name: out_put_mode_of_cert_001 1409 * @tc.desc: Test function of OutputModeOfCert() interface with a empty cert FAIL. 1410 * @tc.type: FUNC 1411 * @tc.require: SR000H63TL 1412 */ 1413 HWTEST_F(GenerateCaTest, out_put_mode_of_cert_001, testing::ext::TestSize.Level1) 1414 { 1415 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1416 std::shared_ptr<Options> params = std::make_shared<Options>(); 1417 X509* cert = X509_new(); 1418 std::string outFile = "/datamt/test/generateCA/sub-ca-test.cer"; 1419 (*params)["outFile"] = outFile; 1420 bool res = api->OutputModeOfCert(cert, params.get()); 1421 EXPECT_EQ(res, false); 1422 } 1423 1424 /** 1425 * @tc.name: generate_key_store_001 1426 * @tc.desc: Test function of GenerateKeyStore() interface with a empty keyalias FAIL. 1427 * @tc.type: FUNC 1428 * @tc.require: SR000H63TL 1429 */ 1430 HWTEST_F(GenerateCaTest, generate_key_store_001, testing::ext::TestSize.Level1) 1431 { 1432 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1433 std::shared_ptr<Options> params = std::make_shared<Options>(); 1434 std::string keyAlias = ""; 1435 (*params)["keyAlias"] = keyAlias; 1436 bool res = api->GenerateKeyStore(params.get()); 1437 EXPECT_EQ(res, false); 1438 } 1439 1440 /** 1441 * @tc.name: handle_issuer_key_alias_empty_001 1442 * @tc.desc: Test function of HandleIssuerKeyAliasEmpty() interface for RET_FAILED. 1443 * @tc.type: FUNC 1444 * @tc.require: SR000H63TL 1445 */ 1446 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_001, testing::ext::TestSize.Level1) 1447 { 1448 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1449 std::shared_ptr<Options> params = std::make_shared<Options>(); 1450 std::string keystoreFile = "/data/test/generateCA/other.p12"; 1451 std::string issuerKeystoreFile = "/data/test/generateCA/issuer.p12"; 1452 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1453 (*params)["keystoreFile"] = keystoreFile; 1454 int res = api->HandleIssuerKeyAliasEmpty(params.get()); 1455 EXPECT_EQ(res, RET_FAILED); 1456 } 1457 1458 /** 1459 * @tc.name: handle_issuer_key_alias_empty_002 1460 * @tc.desc: Test function of HandleIssuerKeyAliasEmpty() interface with a empty keystorepwd. 1461 * @tc.type: FUNC 1462 * @tc.require: SR000H63TL 1463 */ 1464 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_002, testing::ext::TestSize.Level1) 1465 { 1466 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1467 std::shared_ptr<Options> params = std::make_shared<Options>(); 1468 char keystorepwd[] = ""; 1469 char issuerstorepwd[] = "123456"; 1470 std::string keystoreFile = "/data/test/generateCA/other.p12"; 1471 std::string issuerKeystoreFile = "/data/test/generateCA/other.p12"; 1472 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1473 (*params)["keystoreFile"] = keystoreFile; 1474 (*params)["issuerKeystorePwd"] = issuerstorepwd; 1475 (*params)["keystorePwd"] = keystorepwd; 1476 int res = api->HandleIssuerKeyAliasEmpty(params.get()); 1477 EXPECT_EQ(res, RET_FAILED); 1478 } 1479 1480 /** 1481 * @tc.name: handle_issuer_key_alias_empty_003 1482 * @tc.desc: Test function of HandleIssuerKeyAliasEmpty() interface for RET_FAILED. 1483 * @tc.type: FUNC 1484 * @tc.require: SR000H63TL 1485 */ 1486 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_003, testing::ext::TestSize.Level1) 1487 { 1488 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1489 std::shared_ptr<Options> params = std::make_shared<Options>(); 1490 char keystorepwd[] = "234567"; 1491 char issuerstorepwd[] = "123456"; 1492 std::string keystoreFile = "/data/test/generateCA/other.p12"; 1493 std::string issuerKeystoreFile = "/data/test/generateCA/other.p12"; 1494 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1495 (*params)["keystoreFile"] = keystoreFile; 1496 (*params)["issuerKeystorePwd"] = issuerstorepwd; 1497 (*params)["keystorePwd"] = keystorepwd; 1498 int res = api->HandleIssuerKeyAliasEmpty(params.get()); 1499 EXPECT_EQ(res, RET_FAILED); 1500 } 1501 1502 /** 1503 * @tc.name: handle_issuer_key_alias_empty_004 1504 * @tc.desc: Test function of HandleIssuerKeyAliasEmpty() interface with a empty issuerKeystoreFile RET_OK. 1505 * @tc.type: FUNC 1506 * @tc.require: SR000H63TL 1507 */ 1508 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_004, testing::ext::TestSize.Level1) 1509 { 1510 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1511 std::shared_ptr<Options> params = std::make_shared<Options>(); 1512 std::string keystoreFile = "/data/test/generateCA/other.p12"; 1513 std::string issuerKeystoreFile = ""; 1514 char keystorepwd[] = "234567"; 1515 char issuerstorepwd[] = "123456"; 1516 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1517 (*params)["keystoreFile"] = keystoreFile; 1518 (*params)["issuerKeystorePwd"] = issuerstorepwd; 1519 (*params)["keystorePwd"] = keystorepwd; 1520 int res = api->HandleIssuerKeyAliasEmpty(params.get()); 1521 EXPECT_EQ(res, RET_OK); 1522 } 1523 /** 1524 * @tc.name: handle_issuer_key_alias_not_empty_001 1525 * @tc.desc: Test function of HandleIsserKeyAliasNotEmpty() interface with a empty issuerKeystoreFile RET_OK. 1526 * @tc.type: FUNC 1527 * @tc.require: SR000H63TL 1528 */ 1529 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_not_empty_001, testing::ext::TestSize.Level1) 1530 { 1531 std::shared_ptr<Options> params = std::make_shared<Options>(); 1532 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1533 std::string issuerKeystoreFile = ""; 1534 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1535 int res = api->HandleIsserKeyAliasNotEmpty(params.get()); 1536 EXPECT_EQ(res, RET_OK); 1537 } 1538 1539 /** 1540 * @tc.name: handle_issuer_key_alias_not_empty_002 1541 * @tc.desc: Test function of HandleIsserKeyAliasNotEmpty() interface with error path FAIL. 1542 * @tc.type: FUNC 1543 * @tc.require: SR000H63TL 1544 */ 1545 HWTEST_F(GenerateCaTest, handle_issuer_key_alias_not_empty_002, testing::ext::TestSize.Level1) 1546 { 1547 std::shared_ptr<Options> params = std::make_shared<Options>(); 1548 std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>(); 1549 std::string issuerKeystoreFile = "/data/test/generateCA/other.cer"; 1550 (*params)["issuerKeystoreFile"] = issuerKeystoreFile; 1551 int res = api->HandleIsserKeyAliasNotEmpty(params.get()); 1552 EXPECT_EQ(res, RET_FAILED); 1553 } 1554 1555 /** 1556 * @tc.name: generate_end_cert_001 1557 * @tc.desc: Test function of GenerateEndCert() interface for SUCCESS. 1558 * @tc.type: FUNC 1559 * @tc.require: SR000H63TL 1560 */ 1561 HWTEST_F(GenerateCaTest, generate_end_cert_001, testing::ext::TestSize.Level1) 1562 { 1563 std::shared_ptr<Options> params = std::make_shared<Options>(); 1564 std::string keyAlias = "oh-app1-key-v1"; 1565 std::string issuerkeyAlias = "oh-app-sign-srv-ca-key-v1"; 1566 char keyPwd[] = "123456"; 1567 std::string keyAlg = "ECC"; 1568 int keySize = 256; 1569 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12"; 1570 char keystorePwd[] = "123456"; 1571 std::string signAlg = "SHA384withECDSA"; 1572 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1573 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1574 char isksPwd[] = "123456"; 1575 std::string outfile = "/data/test/generateCA/app-release.cer"; 1576 (*params)["keystorePwd"] = keystorePwd; 1577 (*params)["issuerKeystorePwd"] = isksPwd; 1578 (*params)["keyAlias"] = keyAlias; 1579 (*params)["keyPwd"] = keyPwd; 1580 (*params)["keyAlg"] = keyAlg; 1581 (*params)["keySize"] = keySize; 1582 (*params)["keystoreFile"] = keystoreFile; 1583 (*params)["signAlg"] = signAlg; 1584 (*params)["subject"] = subject; 1585 (*params)["issuer"] = issuer; 1586 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1587 (*params)["outFile"] = outfile; 1588 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1589 EVP_PKEY* keyPair = nullptr; 1590 keyPair = adaptePtr->GetAliasKey(true); 1591 EVP_PKEY* issuerkeyPair = nullptr; 1592 adaptePtr->SetIssuerKeyStoreFile(true); 1593 issuerkeyPair = adaptePtr->GetIssuerKeyByAlias(); 1594 X509_REQ* csr = nullptr; 1595 csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1596 EXPECT_NE(csr, nullptr); 1597 bool ret = CertTools::GenerateEndCert(csr, issuerkeyPair, *adaptePtr, PROFILE_SIGNING_CAPABILITY, 1598 sizeof(PROFILE_SIGNING_CAPABILITY)); 1599 EXPECT_EQ(ret, true); 1600 } 1601 1602 /** 1603 * @tc.name: generate_end_cert_002 1604 * @tc.desc: Test function of GenerateEndCert() interface with error keyAlias FAILED. 1605 * @tc.type: FUNC 1606 * @tc.require: SR000H63TL 1607 */ 1608 HWTEST_F(GenerateCaTest, generate_end_cert_002, testing::ext::TestSize.Level1) 1609 { 1610 std::shared_ptr<Options> params = std::make_shared<Options>(); 1611 std::string keyAlias = "oh-app1-key-v1"; 1612 std::string issuerkeyAlias = "oh-app-sign-srv-ca-key-v1"; 1613 char keyPwd[] = "123456"; 1614 std::string keyAlg = "ECC"; 1615 int keySize = 256; 1616 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12"; 1617 char keystorePwd[] = "123456"; 1618 std::string signAlg = "SHA384withECDSA"; 1619 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release"; 1620 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA"; 1621 char isksPwd[] = "123456"; 1622 std::string outfile = "/data/test/generateCA/app-release.cer"; 1623 (*params)["keystorePwd"] = keystorePwd; 1624 (*params)["issuerKeystorePwd"] = isksPwd; 1625 (*params)["keyAlias"] = keyAlias; 1626 (*params)["keyPwd"] = keyPwd; 1627 (*params)["keyAlg"] = keyAlg; 1628 (*params)["keySize"] = keySize; 1629 (*params)["keystoreFile"] = keystoreFile; 1630 (*params)["signAlg"] = signAlg; 1631 (*params)["subject"] = subject; 1632 (*params)["issuer"] = issuer; 1633 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1634 (*params)["outFile"] = outfile; 1635 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1636 EVP_PKEY* keyPair = nullptr; 1637 keyPair = adaptePtr->GetAliasKey(true); 1638 EVP_PKEY* issuerkeyPair = nullptr; 1639 X509_REQ* csr = nullptr; 1640 csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1641 EXPECT_NE(csr, nullptr); 1642 bool ret = CertTools::GenerateEndCert(csr, issuerkeyPair, *adaptePtr, PROFILE_SIGNING_CAPABILITY, 1643 sizeof(PROFILE_SIGNING_CAPABILITY)); 1644 EXPECT_EQ(ret, false); 1645 } 1646 1647 /** 1648 * @tc.name: generate_end_cert_003 1649 * @tc.desc: Test function of GenerateEndCert() interface for SUCCESS. 1650 * @tc.type: FUNC 1651 * @tc.require: SR000H63TL 1652 */ 1653 HWTEST_F(GenerateCaTest, generate_end_cert_003, testing::ext::TestSize.Level1) 1654 { 1655 std::shared_ptr<Options> params = std::make_shared<Options>(); 1656 std::string keyAlias = "oh-profile1-key-v1"; 1657 std::string issuerkeyAlias = "oh-profile-sign-srv-ca-key-v1"; 1658 char keyPwd[] = "123456"; 1659 std::string keyAlg = "ECC"; 1660 int keySize = 256; 1661 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12"; 1662 char keystorePwd[] = "123456"; 1663 std::string signAlg = "SHA384withECDSA"; 1664 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Profile1 Release"; 1665 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Profile Signature Service CA"; 1666 char isksPwd[] = "123456"; 1667 std::string outfile = "/data/test/generateCA/app-release.cer"; 1668 (*params)["keystorePwd"] = keystorePwd; 1669 (*params)["issuerKeystorePwd"] = isksPwd; 1670 (*params)["keyAlias"] = keyAlias; 1671 (*params)["keyPwd"] = keyPwd; 1672 (*params)["keyAlg"] = keyAlg; 1673 (*params)["keySize"] = keySize; 1674 (*params)["keystoreFile"] = keystoreFile; 1675 (*params)["signAlg"] = signAlg; 1676 (*params)["subject"] = subject; 1677 (*params)["issuer"] = issuer; 1678 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1679 (*params)["outFile"] = outfile; 1680 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1681 EVP_PKEY* keyPair = nullptr; 1682 keyPair = adaptePtr->GetAliasKey(true); 1683 EVP_PKEY* issuerkeyPair = nullptr; 1684 adaptePtr->SetIssuerKeyStoreFile(true); 1685 issuerkeyPair = adaptePtr->GetIssuerKeyByAlias(); 1686 X509_REQ* csr = nullptr; 1687 csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1688 EXPECT_NE(csr, nullptr); 1689 bool ret = CertTools::GenerateEndCert(csr, issuerkeyPair, *adaptePtr, PROFILE_SIGNING_CAPABILITY, 1690 sizeof(PROFILE_SIGNING_CAPABILITY)); 1691 EXPECT_EQ(ret, true); 1692 } 1693 1694 /** 1695 * @tc.name: generate_end_cert_004 1696 * @tc.desc: Test function of GenerateEndCert() interface with a error issuerkeyAlias FAIL. 1697 * @tc.type: FUNC 1698 * @tc.require: SR000H63TL 1699 */ 1700 HWTEST_F(GenerateCaTest, generate_end_cert_004, testing::ext::TestSize.Level1) 1701 { 1702 std::shared_ptr<Options> params = std::make_shared<Options>(); 1703 std::string keyAlias = "oh-profile1-key-v1"; 1704 std::string issuerkeyAlias = "oh-profile-sign-srv-ca-key-v1"; 1705 char keyPwd[] = "123456"; 1706 std::string keyAlg = "ECC"; 1707 int keySize = 256; 1708 std::string keystoreFile = "/data/test/generateCA/OpenHarmony.p12"; 1709 char keystorePwd[] = "123456"; 1710 std::string signAlg = "SHA384withECDSA"; 1711 std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Profile1 Release"; 1712 std::string issuer = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Profile Signature Service CA"; 1713 char isksPwd[] = "123456"; 1714 std::string outfile = "/data/test/generateCA/app-release.cer"; 1715 (*params)["keystorePwd"] = keystorePwd; 1716 (*params)["issuerKeystorePwd"] = isksPwd; 1717 (*params)["keyAlias"] = keyAlias; 1718 (*params)["keyPwd"] = keyPwd; 1719 (*params)["keyAlg"] = keyAlg; 1720 (*params)["keySize"] = keySize; 1721 (*params)["keystoreFile"] = keystoreFile; 1722 (*params)["signAlg"] = signAlg; 1723 (*params)["subject"] = subject; 1724 (*params)["issuer"] = issuer; 1725 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1726 (*params)["outFile"] = outfile; 1727 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1728 EVP_PKEY* keyPair = nullptr; 1729 keyPair = adaptePtr->GetAliasKey(true); 1730 EVP_PKEY* issuerkeyPair = nullptr; 1731 X509_REQ* csr = nullptr; 1732 csr = CertTools::GenerateCsr(keyPair, signAlg, subject); 1733 EXPECT_NE(csr, nullptr); 1734 bool ret = CertTools::GenerateEndCert(csr, issuerkeyPair, *adaptePtr, PROFILE_SIGNING_CAPABILITY, 1735 sizeof(PROFILE_SIGNING_CAPABILITY)); 1736 EXPECT_EQ(ret, false); 1737 } 1738 1739 /** 1740 * @tc.name: issuer_key_store_file_001 1741 * @tc.desc: Test function of IssuerKeyStoreFile() interface for auto generate key FAIL. 1742 * @tc.type: FUNC 1743 * @tc.require: SR000H63TL 1744 */ 1745 HWTEST_F(GenerateCaTest, issuer_key_store_file_001, testing::ext::TestSize.Level1) 1746 { 1747 std::shared_ptr<Options> params = std::make_shared<Options>(); 1748 std::string keyAlias = "oh-app1-key-v123"; 1749 std::string issuerkeyAlias = "oh-app1-key-v122222"; 1750 char keyPwd[] = "123456"; 1751 std::string keyAlg = "ECC"; 1752 int keySize = 256; 1753 std::string keystoreFile = "/data/test/generateCA/OpenHarmony1.p12"; 1754 char keystorePwd[] = "123456"; 1755 (*params)["keyAlias"] = keyAlias; 1756 (*params)["keyPwd"] = keyPwd; 1757 (*params)["keyAlg"] = keyAlg; 1758 (*params)["keySize"] = keySize; 1759 (*params)["keystoreFile"] = keystoreFile; 1760 (*params)["keystorePwd"] = keystorePwd; 1761 (*params)["issuerKeyAlias"] = issuerkeyAlias; 1762 std::unique_ptr<LocalizationAdapter> adaptePtr = std::make_unique<LocalizationAdapter>(params.get()); 1763 EVP_PKEY* keyPair = nullptr; 1764 keyPair = adaptePtr->GetAliasKey(true); 1765 int ret = adaptePtr->IssuerKeyStoreFile(&keyPair, true); 1766 EXPECT_EQ(ret, RET_FAILED); 1767 } 1768 } 1769 }