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 */
HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_005, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_006, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_sub_cert_to_file_test_007, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_cert_version_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_002, testing::ext::TestSize.Level1)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 EXPECT_EQ(cert, nullptr);
327 bool cert1 = CertTools::SetPubkeyAndSignCert(cert, issuercsr, csr, keyPair, params.get());
328 EXPECT_EQ(cert1, false);
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 */
HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_pubkey_and_sign_cert_test_005, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_cert_serial_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, set_cert_validity_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, X509_certverify_test_001, testing::ext::TestSize.Level1)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
HWTEST_F(GenerateCaTest, X509_certverify_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, X509_certverify_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, isempty_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Read_File_By_Offset_And_Length_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Read_Input_By_Offset_And_Length_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Read_Input_By_Length_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Is_Runnable_File_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, ReadFile_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, WriteByteToOutFile_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, ParsePkcs7Package_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, ParsePkcs7Package_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, GetCertChains_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, GetCertChains_test_002, testing::ext::TestSize.Level1)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
HWTEST_F(GenerateCaTest, set_bisic_constraints_patchlen_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, sign_for_subcert_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, sign_for_subcert_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, sign_for_subcert_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, sign_for_subcert_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, sign_for_subcert_test_005, testing::ext::TestSize.Level1)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
HWTEST_F(GenerateCaTest, get_csr_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, get_csr_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, save_cert_to_file_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, isempty_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, write_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, read_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_005, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Append_Write_File_ByOffset_To_File_test_006, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Verify_Hap_test_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Verify_Hap_test_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Verify_Hap_test_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, Verify_Hap_test_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_root_cert_to_flie_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, out_put_mode_of_cert_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_key_store_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_empty_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_not_empty_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, handle_issuer_key_alias_not_empty_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_end_cert_001, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_end_cert_002, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_end_cert_003, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, generate_end_cert_004, testing::ext::TestSize.Level1)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 */
HWTEST_F(GenerateCaTest, issuer_key_store_file_001, testing::ext::TestSize.Level1)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 }