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