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