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
33namespace OHOS {
34namespace SignatureTools {
35
36class ProcessCmdTest : public testing::Test {
37public:
38    static void SetUpTestCase()
39    {
40    };
41    static void TearDownTestCase()
42    {
43    };
44    void SetUp()
45    {
46    };
47    void TearDown()
48    {
49    };
50};
51
52/*
53 * @tc.name: processcmd_test_001
54 * @tc.desc: The ProcessCmd function is executed to generate the key pair.
55 * @tc.type: FUNC
56 * @tc.require:
57 */
58HWTEST_F(ProcessCmdTest, processcmd_test_001, testing::ext::TestSize.Level1)
59{
60    char arg0[] = "";
61    char arg1[] = "generate-keypair";
62    char arg2[] = "-keyAlias";
63    char arg3[] = "oh-app1-key-v1";
64    char arg4[] = "-keyPwd";
65    char arg5[] = "123456";
66    char arg6[] = "-keyAlg";
67    char arg7[] = "ECC";
68    char arg8[] = "-keySize";
69    char arg9[] = "NIST-P-384";
70    char arg10[] = "-keystoreFile";
71    char arg11[] = "./generateKeyPair/OpenHarmony.p12";
72    char arg12[] = "-keystorePwd";
73    char arg13[] = "123456";
74    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
75
76    int argc = 14;
77    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
78
79    EXPECT_EQ(ret, false);
80}
81
82/*
83 * @tc.name: processcmd_test_002
84 * @tc.desc: Test typing empty characters and printing the help document.
85 * @tc.type: FUNC
86 * @tc.require:
87 */
88HWTEST_F(ProcessCmdTest, processcmd_test_002, testing::ext::TestSize.Level1)
89{
90    char arg0[] = "";
91    char arg1[] = "";
92    char* argv[] = { arg0, arg1 };
93
94    int argc = 2;
95    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
96
97    EXPECT_EQ(ret, true);
98}
99
100/*
101 * @tc.name: processcmd_test_003
102 * @tc.desc: View the help documentation.
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106HWTEST_F(ProcessCmdTest, processcmd_test_003, testing::ext::TestSize.Level1)
107{
108    char arg0[] = "";
109    char arg1[] = "-h";
110    char* argv[] = { arg0, arg1 };
111
112    int argc = 2;
113    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
114
115    EXPECT_EQ(ret, true);
116}
117
118/*
119 * @tc.name: processcmd_test_004
120 * @tc.desc: Print version number.
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124HWTEST_F(ProcessCmdTest, processcmd_test_004, testing::ext::TestSize.Level1)
125{
126    char arg0[] = "";
127    char arg1[] = "-v";
128    char* argv[] = { arg0, arg1 };
129
130    int argc = 2;
131    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
132
133    EXPECT_EQ(ret, true);
134}
135
136/*
137 * @tc.name: processcmd_test_005
138 * @tc.desc: Check that the value command-line argument is empty.
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142HWTEST_F(ProcessCmdTest, processcmd_test_005, testing::ext::TestSize.Level1)
143{
144    char arg0[] = "";
145    char arg1[] = "generate-keypair";
146    char arg2[] = "-keyAlias";
147    char arg3[] = "";
148    char* argv[] = { arg0, arg1, arg2, arg3 };
149
150    int argc = 4;
151    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
152
153    EXPECT_EQ(ret, false);
154}
155
156/*
157 * @tc.name: processcmd_test_006
158 * @tc.desc: Checks whether the first argument of key has -.
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162HWTEST_F(ProcessCmdTest, processcmd_test_006, testing::ext::TestSize.Level1)
163{
164    char arg0[] = "";
165    char arg1[] = "generate-keypair";
166    char arg2[] = "";
167    char arg3[] = "";
168    char* argv[] = { arg0, arg1, arg2, arg3 };
169
170    int argc = 4;
171    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
172
173    EXPECT_EQ(ret, false);
174}
175
176/*
177 * @tc.name: processcmd_test_007
178 * @tc.desc: Check whether the key algorithm is NIST-P-384 or NIST-P-256.
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182HWTEST_F(ProcessCmdTest, processcmd_test_007, testing::ext::TestSize.Level1)
183{
184    char arg0[] = "";
185    char arg1[] = "generate-keypair";
186    char arg2[] = "-keyAlias";
187    char arg3[] = "oh-app1-key-v1";
188    char arg4[] = "-keyPwd";
189    char arg5[] = "123456";
190    char arg6[] = "-keyAlg";
191    char arg7[] = "ECC";
192    char arg8[] = "-keySize";
193    char arg9[] = "NIST-P-385";
194    char arg10[] = "-keystoreFile";
195    char arg11[] = "./generateKeyPair/OpenHarmony.p12";
196    char arg12[] = "-keystorePwd";
197    char arg13[] = "123456";
198    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6,
199                     arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
200
201    int argc = 14;
202    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
203
204    EXPECT_EQ(ret, false);
205}
206
207/*
208 * @tc.name: processcmd_test_008
209 * @tc.desc: Checks whether the argument is in the trusted list.
210 * @tc.type: FUNC
211 * @tc.require:
212 */
213HWTEST_F(ProcessCmdTest, processcmd_test_008, testing::ext::TestSize.Level1)
214{
215    char arg0[] = "";
216    char arg1[] = "generate-keypair";
217    char arg2[] = "-keyAlias";
218    char arg3[] = "oh-app1-key-v1";
219    char arg4[] = "-keyPwd";
220    char arg5[] = "123456";
221    char arg6[] = "-keyAlg";
222    char arg7[] = "ECC";
223    char arg8[] = "-keySize";
224    char arg9[] = "NIST-P-257";
225    char arg10[] = "-keystoreFile";
226    char arg11[] = "./generateKeyPair/OpenHarmony.p12";
227    char arg12[] = "-keystorePwd";
228    char arg13[] = "123456";
229    char arg14[] = "-extKeyUsageCritical";
230    char arg15[] = "false";
231    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7,
232                     arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15 };
233
234    int argc = 16;
235    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
236
237    EXPECT_EQ(ret, false);
238}
239
240/*
241* @tc.name: processcmd_test_009
242* @tc.desc: Checks whether the last value of the command argument is null.
243* @tc.type: FUNC
244* @tc.require:
245*/
246HWTEST_F(ProcessCmdTest, processcmd_test_009, testing::ext::TestSize.Level1)
247{
248    char arg0[] = "";
249    char arg1[] = "generate-cert";
250    char arg2[] = "-keyAlias";
251    char arg3[] = "oh-profile1-key-v1";
252    char arg4[] = "-keyPwd";
253    char arg5[] = "123456";
254    char arg6[] = "-issuer";
255    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
256    char arg8[] = "-issuerKeyAlias";
257    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
258    char arg10[] = "-subject";
259    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
260    char arg12[] = "-validity";
261    char arg13[] = "365";
262    char arg14[] = "-signAlg";
263    char arg15[] = "SHA384withECDSA";
264    char arg16[] = "-keystoreFile";
265    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
266    char arg18[] = "-keystorePwd";
267    char arg19[] = "123456";
268    char arg20[] = "-outFile";
269    char arg21[] = "./generateKeyPair/general.cer";
270    char arg22[] = "-keyPwd";
271    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
272                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22 };
273    int argc = 23;
274    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
275
276    EXPECT_EQ(ret, false);
277}
278
279/*
280* @tc.name: processcmd_test_010
281* @tc.desc: Check that the required parameters of the generate-cert module are met.
282* @tc.type: FUNC
283* @tc.require:
284*/
285HWTEST_F(ProcessCmdTest, processcmd_test_010, testing::ext::TestSize.Level1)
286{
287    char arg0[] = "";
288    char arg1[] = "generate-cert";
289    char arg2[] = "-keyAlias";
290    char arg3[] = "oh-profile1-key-v1";
291    char arg4[] = "-keyPwd";
292    char arg5[] = "123456";
293    char arg6[] = "-issuer";
294    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
295    char arg8[] = "-issuerKeyAlias";
296    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
297    char arg10[] = "-subject";
298    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
299    char arg12[] = "-validity";
300    char arg13[] = "365";
301    char arg14[] = "-signAlg";
302    char arg15[] = "SHA384withECDSA";
303    char arg16[] = "-keystoreFile";
304    char arg17[] = "/mnt/d/file/0613test/OpenHarmony.p12";
305    char arg18[] = "-keystorePwd";
306    char arg19[] = "123456";
307    char arg20[] = "-outFile";
308    char arg21[] = "/mnt/d/file/0613test/general.cer";
309    char arg22[] = "-basicConstraintsPathLen";
310    char arg23[] = "0";
311    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
312                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
313    int argc = 24;
314
315    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
316
317    EXPECT_EQ(ret, false);
318}
319
320/*
321* @tc.name: processcmd_test_011
322* @tc.desc: Check that the required parameters of the sign-app module are met.
323* @tc.type: FUNC
324* @tc.require:
325*/
326HWTEST_F(ProcessCmdTest, processcmd_test_011, testing::ext::TestSize.Level1)
327{
328    char arg0[] = "";
329    char arg1[] = "sign-app";
330    char arg2[] = "-profileSigned";
331    char arg3[] = "1";
332    char* argv[] = { arg0, arg1, arg2, arg3 };
333    int argc = 4;
334
335    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
336
337    EXPECT_EQ(ret, false);
338}
339
340/*
341* @tc.name: processcmd_test_012
342* @tc.desc: Check if the -profileSigned parameter in sign-app is [1,0, true, false, TRUE, FALSE].
343* @tc.type: FUNC
344* @tc.require:
345*/
346HWTEST_F(ProcessCmdTest, processcmd_test_012, testing::ext::TestSize.Level1)
347{
348    char arg0[] = "";
349    char arg1[] = "sign-app";
350    char arg2[] = "-profileSigned";
351    char arg3[] = "abcd";
352    char* argv[] = { arg0, arg1, arg2, arg3 };
353    int argc = 4;
354
355    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
356
357    EXPECT_EQ(ret, false);
358}
359
360/*
361* @tc.name: processcmd_test_013
362* @tc.desc: Check that the output file path exists.
363* @tc.type: FUNC
364* @tc.require:
365*/
366HWTEST_F(ProcessCmdTest, processcmd_test_013, testing::ext::TestSize.Level1)
367{
368    char arg0[] = "";
369    char arg1[] = "generate-keypair";
370    char arg2[] = "-keyAlias";
371    char arg3[] = "oh-app1-key-v1";
372    char arg4[] = "-keyPwd";
373    char arg5[] = "123456";
374    char arg6[] = "-keyAlg";
375    char arg7[] = "ECC";
376    char arg8[] = "-keySize";
377    char arg9[] = "NIST-P-256";
378    char arg10[] = "-keystoreFile";
379    char arg11[] = "./aabc123/OpenHarmony.p12";
380    char arg12[] = "-keystorePwd";
381    char arg13[] = "123456";
382    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
383    int argc = 14;
384
385    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
386
387    EXPECT_EQ(ret, false);
388}
389
390/*
391* @tc.name: processcmd_test_014
392* @tc.desc: Check if the keystore file is in 'p12' or 'JKS' file format.
393* @tc.type: FUNC
394* @tc.require:
395*/
396HWTEST_F(ProcessCmdTest, processcmd_test_014, 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-256";
408    char arg10[] = "-keystoreFile";
409    char arg11[] = "./generateKeyPair";
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    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
416
417    EXPECT_EQ(ret, false);
418}
419
420/*
421* @tc.name: processcmd_test_015
422* @tc.desc: Check if the signature algorithm is SHA3256withECDSA or SHA384withECDSA.
423* @tc.type: FUNC
424* @tc.require:
425*/
426HWTEST_F(ProcessCmdTest, processcmd_test_015, testing::ext::TestSize.Level1)
427{
428    char arg0[] = "";
429    char arg1[] = "sign-app";
430    char arg2[] = "-signAlg";
431    char arg3[] = "abcd";
432    char* argv[] = { arg0, arg1, arg2, arg3 };
433    int argc = 4;
434
435    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
436
437    EXPECT_EQ(ret, false);
438}
439
440/*
441* @tc.name: processcmd_test_016
442* @tc.desc: Check if the signature algorithm is SHA3256withECDSA or SHA384withECDSA.
443* @tc.type: FUNC
444* @tc.require:
445*/
446HWTEST_F(ProcessCmdTest, processcmd_test_016, testing::ext::TestSize.Level1)
447{
448    char arg0[] = "";
449    char arg1[] = "sign-app";
450    char arg2[] = "-signAlg";
451    char arg3[] = "SHA384withECDSA";
452    char* argv[] = { arg0, arg1, arg2, arg3 };
453    int argc = 4;
454
455    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
456
457    EXPECT_EQ(ret, false);
458}
459
460/*
461* @tc.name: processcmd_test_017
462* @tc.desc: Check that the -inForm value is formatted correct.
463* @tc.type: FUNC
464* @tc.require:
465*/
466HWTEST_F(ProcessCmdTest, processcmd_test_017, testing::ext::TestSize.Level1)
467{
468    char arg0[] = "";
469    char arg1[] = "verify-app";
470    char arg2[] = "-inForm";
471    char arg3[] = "abcd";
472    char* argv[] = { arg0, arg1, arg2, arg3 };
473    int argc = 4;
474
475    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
476
477    EXPECT_EQ(ret, false);
478}
479
480/*
481* @tc.name: processcmd_test_018
482* @tc.desc: Check that the -outForm argument is correctly formatted.
483* @tc.type: FUNC
484* @tc.require:
485*/
486HWTEST_F(ProcessCmdTest, processcmd_test_018, testing::ext::TestSize.Level1)
487{
488    char arg0[] = "";
489    char arg1[] = "generate-app-cert";
490    char arg2[] = "-outForm";
491    char arg3[] = "abcd";
492    char* argv[] = { arg0, arg1, arg2, arg3 };
493    int argc = 4;
494
495    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
496
497    EXPECT_EQ(ret, false);
498}
499
500/*
501* @tc.name: processcmd_test_019
502* @tc.desc: Check the generate-app-cert module for required parameters.
503* @tc.type: FUNC
504* @tc.require:
505*/
506HWTEST_F(ProcessCmdTest, processcmd_test_019, testing::ext::TestSize.Level1)
507{
508    char arg0[] = "";
509    char arg1[] = "generate-app-cert";
510    char* argv[] = { arg0, arg1 };
511    int argc = 2;
512
513    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
514
515    EXPECT_EQ(ret, false);
516}
517
518/*
519 * @tc.name: processcmd_test_020
520 * @tc.desc: Printing help documents.
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524HWTEST_F(ProcessCmdTest, processcmd_test_020, testing::ext::TestSize.Level1)
525{
526    char arg0[] = "";
527    char arg1[] = "-help";
528    char* argv[] = { arg0, arg1 };
529    int argc = 2;
530    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
531
532    EXPECT_EQ(ret, true);
533}
534
535/*
536 * @tc.name: processcmd_test_021
537 * @tc.desc: Print version number.
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541HWTEST_F(ProcessCmdTest, processcmd_test_021, testing::ext::TestSize.Level1)
542{
543    char arg0[] = "";
544    char arg1[] = "-version";
545    char* argv[] = { arg0, arg1 };
546    int argc = 2;
547    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
548
549    EXPECT_EQ(ret, true);
550}
551
552/*
553 * @tc.name: processcmd_test_022
554 * @tc.desc: Print help documentation when an empty command is passed.
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558HWTEST_F(ProcessCmdTest, processcmd_test_022, testing::ext::TestSize.Level1)
559{
560    bool ret = ParamsRunTool::ProcessCmd(nullptr, 5);
561    EXPECT_EQ(ret, true);
562}
563
564/*
565 * @tc.name: processcmd_test_023
566 * @tc.desc: Check whether keyUsageCritical parameter for [ 1, 0, true, false, true, false ].
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570HWTEST_F(ProcessCmdTest, processcmd_test_023, testing::ext::TestSize.Level1)
571{
572    char arg0[] = "";
573    char arg1[] = "generate-cert";
574    char arg2[] = "-keyAlias";
575    char arg3[] = "oh-profile1-key-v1";
576    char arg4[] = "-keyPwd";
577    char arg5[] = "123456";
578    char arg6[] = "-issuer";
579    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
580    char arg8[] = "-issuerKeyAlias";
581    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
582    char arg10[] = "-subject";
583    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
584    char arg12[] = "-validity";
585    char arg13[] = "365";
586    char arg14[] = "-signAlg";
587    char arg15[] = "SHA384withECDSA";
588    char arg16[] = "-keystoreFile";
589    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
590    char arg18[] = "-keystorePwd";
591    char arg19[] = "123456";
592    char arg20[] = "-outFile";
593    char arg21[] = "./generateKeyPair/general.cer";
594    char arg22[] = "-keyUsageCritical";
595    char arg23[] = "TRUE";
596    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
597                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
598    int argc = 24;
599
600    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
601
602    EXPECT_EQ(ret, false);
603}
604
605/*
606 * @tc.name: processcmd_test_024
607 * @tc.desc: Check whether keyUsageCritical parameter for [ 1, 0, true, false, true, false ].
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611HWTEST_F(ProcessCmdTest, processcmd_test_024, testing::ext::TestSize.Level1)
612{
613    char arg0[] = "";
614    char arg1[] = "generate-cert";
615    char arg2[] = "-keyAlias";
616    char arg3[] = "oh-profile1-key-v1";
617    char arg4[] = "-keyPwd";
618    char arg5[] = "123456";
619    char arg6[] = "-issuer";
620    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
621    char arg8[] = "-issuerKeyAlias";
622    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
623    char arg10[] = "-subject";
624    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
625    char arg12[] = "-validity";
626    char arg13[] = "365";
627    char arg14[] = "-signAlg";
628    char arg15[] = "SHA384withECDSA";
629    char arg16[] = "-keystoreFile";
630    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
631    char arg18[] = "-keystorePwd";
632    char arg19[] = "123456";
633    char arg20[] = "-outFile";
634    char arg21[] = "./generateKeyPair/general.cer";
635    char arg22[] = "-keyUsageCritical";
636    char arg23[] = "true";
637    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
638                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
639    int argc = 24;
640
641    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
642
643    EXPECT_EQ(ret, false);
644}
645
646/*
647 * @tc.name: processcmd_test_025
648 * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
649 * @tc.type: FUNC
650 * @tc.require:
651 */
652HWTEST_F(ProcessCmdTest, processcmd_test_025, testing::ext::TestSize.Level1)
653{
654    char arg0[] = "";
655    char arg1[] = "generate-cert";
656    char arg2[] = "-keyAlias";
657    char arg3[] = "oh-profile1-key-v1";
658    char arg4[] = "-keyPwd";
659    char arg5[] = "123456";
660    char arg6[] = "-issuer";
661    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
662    char arg8[] = "-issuerKeyAlias";
663    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
664    char arg10[] = "-subject";
665    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
666    char arg12[] = "-validity";
667    char arg13[] = "365";
668    char arg14[] = "-signAlg";
669    char arg15[] = "SHA384withECDSA";
670    char arg16[] = "-keystoreFile";
671    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
672    char arg18[] = "-keystorePwd";
673    char arg19[] = "123456";
674    char arg20[] = "-outFile";
675    char arg21[] = "./generateKeyPair/general.cer";
676    char arg22[] = "-extKeyUsageCritical";
677    char arg23[] = "1";
678    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
679                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
680    int argc = 24;
681
682    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
683
684    EXPECT_EQ(ret, false);
685}
686
687/*
688 * @tc.name: processcmd_test_026
689 * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693HWTEST_F(ProcessCmdTest, processcmd_test_026, testing::ext::TestSize.Level1)
694{
695    char arg0[] = "";
696    char arg1[] = "generate-cert";
697    char arg2[] = "-keyAlias";
698    char arg3[] = "oh-profile1-key-v1";
699    char arg4[] = "-keyPwd";
700    char arg5[] = "123456";
701    char arg6[] = "-issuer";
702    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
703    char arg8[] = "-issuerKeyAlias";
704    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
705    char arg10[] = "-subject";
706    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
707    char arg12[] = "-validity";
708    char arg13[] = "365";
709    char arg14[] = "-signAlg";
710    char arg15[] = "SHA384withECDSA";
711    char arg16[] = "-keystoreFile";
712    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
713    char arg18[] = "-keystorePwd";
714    char arg19[] = "123456";
715    char arg20[] = "-outFile";
716    char arg21[] = "./generateKeyPair/general.cer";
717    char arg22[] = "-extKeyUsageCritical";
718    char arg23[] = "true";
719    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
720                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
721    int argc = 24;
722
723    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
724
725    EXPECT_EQ(ret, false);
726}
727
728/*
729 * @tc.name: processcmd_test_027
730 * @tc.desc: Check whether extKeyUsageCritical parameter for [ 1, 0, true, false, true, false ].
731 * @tc.type: FUNC
732 * @tc.require:
733 */
734HWTEST_F(ProcessCmdTest, processcmd_test_027, testing::ext::TestSize.Level1)
735{
736    char arg0[] = "";
737    char arg1[] = "generate-cert";
738    char arg2[] = "-keyAlias";
739    char arg3[] = "oh-profile1-key-v1";
740    char arg4[] = "-keyPwd";
741    char arg5[] = "123456";
742    char arg6[] = "-issuer";
743    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
744    char arg8[] = "-issuerKeyAlias";
745    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
746    char arg10[] = "-subject";
747    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
748    char arg12[] = "-validity";
749    char arg13[] = "365";
750    char arg14[] = "-signAlg";
751    char arg15[] = "SHA384withECDSA";
752    char arg16[] = "-keystoreFile";
753    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
754    char arg18[] = "-keystorePwd";
755    char arg19[] = "123456";
756    char arg20[] = "-outFile";
757    char arg21[] = "./generateKeyPair/general.cer";
758    char arg22[] = "-extKeyUsageCritical";
759    char arg23[] = "TRUE";
760    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
761                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
762    int argc = 24;
763
764    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
765
766    EXPECT_EQ(ret, false);
767}
768
769/*
770 * @tc.name: processcmd_test_028
771 * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
772 * @tc.type: FUNC
773 * @tc.require:
774 */
775HWTEST_F(ProcessCmdTest, processcmd_test_028, testing::ext::TestSize.Level1)
776{
777    char arg0[] = "";
778    char arg1[] = "generate-cert";
779    char arg2[] = "-keyAlias";
780    char arg3[] = "oh-profile1-key-v1";
781    char arg4[] = "-keyPwd";
782    char arg5[] = "123456";
783    char arg6[] = "-issuer";
784    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
785    char arg8[] = "-issuerKeyAlias";
786    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
787    char arg10[] = "-subject";
788    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
789    char arg12[] = "-validity";
790    char arg13[] = "365";
791    char arg14[] = "-signAlg";
792    char arg15[] = "SHA384withECDSA";
793    char arg16[] = "-keystoreFile";
794    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
795    char arg18[] = "-keystorePwd";
796    char arg19[] = "123456";
797    char arg20[] = "-outFile";
798    char arg21[] = "./generateKeyPair/general.cer";
799    char arg22[] = "-basicConstraints";
800    char arg23[] = "TRUE";
801    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
802                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
803    int argc = 24;
804
805    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
806
807    EXPECT_EQ(ret, false);
808}
809
810/*
811 * @tc.name: processcmd_test_029
812 * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
813 * @tc.type: FUNC
814 * @tc.require:
815 */
816HWTEST_F(ProcessCmdTest, processcmd_test_029, testing::ext::TestSize.Level1)
817{
818    char arg0[] = "";
819    char arg1[] = "generate-cert";
820    char arg2[] = "-keyAlias";
821    char arg3[] = "oh-profile1-key-v1";
822    char arg4[] = "-keyPwd";
823    char arg5[] = "123456";
824    char arg6[] = "-issuer";
825    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
826    char arg8[] = "-issuerKeyAlias";
827    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
828    char arg10[] = "-subject";
829    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
830    char arg12[] = "-validity";
831    char arg13[] = "365";
832    char arg14[] = "-signAlg";
833    char arg15[] = "SHA384withECDSA";
834    char arg16[] = "-keystoreFile";
835    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
836    char arg18[] = "-keystorePwd";
837    char arg19[] = "123456";
838    char arg20[] = "-outFile";
839    char arg21[] = "./generateKeyPair/general.cer";
840    char arg22[] = "-basicConstraints";
841    char arg23[] = "1";
842    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
843                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
844    int argc = 24;
845
846    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
847
848    EXPECT_EQ(ret, false);
849}
850
851/*
852 * @tc.name: processcmd_test_030
853 * @tc.desc: Check whether basicConstraints parameter for [ 1, 0, true, false, true, false ].
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857HWTEST_F(ProcessCmdTest, processcmd_test_030, testing::ext::TestSize.Level1)
858{
859    char arg0[] = "";
860    char arg1[] = "generate-cert";
861    char arg2[] = "-keyAlias";
862    char arg3[] = "oh-profile1-key-v1";
863    char arg4[] = "-keyPwd";
864    char arg5[] = "123456";
865    char arg6[] = "-issuer";
866    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
867    char arg8[] = "-issuerKeyAlias";
868    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
869    char arg10[] = "-subject";
870    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
871    char arg12[] = "-validity";
872    char arg13[] = "365";
873    char arg14[] = "-signAlg";
874    char arg15[] = "SHA384withECDSA";
875    char arg16[] = "-keystoreFile";
876    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
877    char arg18[] = "-keystorePwd";
878    char arg19[] = "123456";
879    char arg20[] = "-outFile";
880    char arg21[] = "./generateKeyPair/general.cer";
881    char arg22[] = "-basicConstraints";
882    char arg23[] = "true";
883    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
884                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
885    int argc = 24;
886
887    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
888
889    EXPECT_EQ(ret, false);
890}
891
892/*
893 * @tc.name: processcmd_test_031
894 * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898HWTEST_F(ProcessCmdTest, processcmd_test_031, testing::ext::TestSize.Level1)
899{
900    char arg0[] = "";
901    char arg1[] = "generate-cert";
902    char arg2[] = "-keyAlias";
903    char arg3[] = "oh-profile1-key-v1";
904    char arg4[] = "-keyPwd";
905    char arg5[] = "123456";
906    char arg6[] = "-issuer";
907    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
908    char arg8[] = "-issuerKeyAlias";
909    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
910    char arg10[] = "-subject";
911    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
912    char arg12[] = "-validity";
913    char arg13[] = "365";
914    char arg14[] = "-signAlg";
915    char arg15[] = "SHA384withECDSA";
916    char arg16[] = "-keystoreFile";
917    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
918    char arg18[] = "-keystorePwd";
919    char arg19[] = "123456";
920    char arg20[] = "-outFile";
921    char arg21[] = "./generateKeyPair/general.cer";
922    char arg22[] = "-basicConstraintsCritical";
923    char arg23[] = "true";
924    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
925                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
926    int argc = 24;
927
928    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
929
930    EXPECT_EQ(ret, false);
931}
932
933/*
934 * @tc.name: processcmd_test_032
935 * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
936 * @tc.type: FUNC
937 * @tc.require:
938 */
939HWTEST_F(ProcessCmdTest, processcmd_test_032, testing::ext::TestSize.Level1)
940{
941    char arg0[] = "";
942    char arg1[] = "generate-cert";
943    char arg2[] = "-keyAlias";
944    char arg3[] = "oh-profile1-key-v1";
945    char arg4[] = "-keyPwd";
946    char arg5[] = "123456";
947    char arg6[] = "-issuer";
948    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
949    char arg8[] = "-issuerKeyAlias";
950    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
951    char arg10[] = "-subject";
952    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
953    char arg12[] = "-validity";
954    char arg13[] = "365";
955    char arg14[] = "-signAlg";
956    char arg15[] = "SHA384withECDSA";
957    char arg16[] = "-keystoreFile";
958    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
959    char arg18[] = "-keystorePwd";
960    char arg19[] = "123456";
961    char arg20[] = "-outFile";
962    char arg21[] = "./generateKeyPair/general.cer";
963    char arg22[] = "-basicConstraintsCritical";
964    char arg23[] = "TRUE";
965    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
966                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
967    int argc = 24;
968
969    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
970
971    EXPECT_EQ(ret, false);
972}
973
974/*
975 * @tc.name: processcmd_test_033
976 * @tc.desc: Check whether basicConstraintsCritical parameter for [ 1, 0, true, false, true, false ].
977 * @tc.type: FUNC
978 * @tc.require:
979 */
980HWTEST_F(ProcessCmdTest, processcmd_test_033, testing::ext::TestSize.Level1)
981{
982    char arg0[] = "";
983    char arg1[] = "generate-cert";
984    char arg2[] = "-keyAlias";
985    char arg3[] = "oh-profile1-key-v1";
986    char arg4[] = "-keyPwd";
987    char arg5[] = "123456";
988    char arg6[] = "-issuer";
989    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
990    char arg8[] = "-issuerKeyAlias";
991    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
992    char arg10[] = "-subject";
993    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
994    char arg12[] = "-validity";
995    char arg13[] = "365";
996    char arg14[] = "-signAlg";
997    char arg15[] = "SHA384withECDSA";
998    char arg16[] = "-keystoreFile";
999    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
1000    char arg18[] = "-keystorePwd";
1001    char arg19[] = "123456";
1002    char arg20[] = "-outFile";
1003    char arg21[] = "./generateKeyPair/general.cer";
1004    char arg22[] = "-basicConstraintsCritical";
1005    char arg23[] = "1";
1006    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
1007                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
1008    int argc = 24;
1009
1010    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1011
1012    EXPECT_EQ(ret, false);
1013}
1014
1015/*
1016 * @tc.name: processcmd_test_034
1017 * @tc.desc: Check whether basicConstraintsCa parameter for [ 1, 0, true, false, true, false ].
1018 * @tc.type: FUNC
1019 * @tc.require:
1020 */
1021HWTEST_F(ProcessCmdTest, processcmd_test_034, testing::ext::TestSize.Level1)
1022{
1023    char arg0[] = "";
1024    char arg1[] = "generate-cert";
1025    char arg2[] = "-keyAlias";
1026    char arg3[] = "oh-profile1-key-v1";
1027    char arg4[] = "-keyPwd";
1028    char arg5[] = "123456";
1029    char arg6[] = "-issuer";
1030    char arg7[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=Application Signature Service CA";
1031    char arg8[] = "-issuerKeyAlias";
1032    char arg9[] = "oh-profile-sign-srv-ca-key-v1";
1033    char arg10[] = "-subject";
1034    char arg11[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
1035    char arg12[] = "-validity";
1036    char arg13[] = "365";
1037    char arg14[] = "-signAlg";
1038    char arg15[] = "SHA384withECDSA";
1039    char arg16[] = "-keystoreFile";
1040    char arg17[] = "./generateKeyPair/OpenHarmony.p12";
1041    char arg18[] = "-keystorePwd";
1042    char arg19[] = "123456";
1043    char arg20[] = "-outFile";
1044    char arg21[] = "./generateKeyPair/general.cer";
1045    char arg22[] = "-basicConstraintsCa";
1046    char arg23[] = "1";
1047    char* argv[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12,
1048                     arg13, arg14, arg15, arg16, arg17, arg18, arg19, arg20, arg21, arg22, arg23 };
1049    int argc = 24;
1050
1051    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1052
1053    EXPECT_EQ(ret, false);
1054}
1055
1056/*
1057 * @tc.name: processcmd_test_035
1058 * @tc.desc: Check that the inFile argument is correct.
1059 * @tc.type: FUNC
1060 * @tc.require:
1061 */
1062HWTEST_F(ProcessCmdTest, processcmd_test_035, testing::ext::TestSize.Level1)
1063{
1064    std::shared_ptr<Options> params = std::make_shared<Options>();
1065    std::string inFile = "./generateKeyPair";
1066    (*params)["inFile"] = inFile;
1067    bool ret = CmdUtil::UpdateParamForCheckInFile(params.get(), {Options::IN_FILE});
1068
1069    EXPECT_EQ(ret, false);
1070}
1071
1072/*
1073 * @tc.name: processcmd_test_036
1074 * @tc.desc: Check that the inFile argument is correct.
1075 * @tc.type: FUNC
1076 * @tc.require:
1077 */
1078HWTEST_F(ProcessCmdTest, processcmd_test_036, testing::ext::TestSize.Level1)
1079{
1080    std::shared_ptr<Options> params = std::make_shared<Options>();
1081    std::string inFile = "generateKeyPair";
1082    (*params)["inFile"] = inFile;
1083    bool ret = CmdUtil::UpdateParamForCheckOutFile(params.get(), {Options::IN_FILE});
1084
1085    EXPECT_EQ(ret, true);
1086}
1087
1088/*
1089 * @tc.name: processcmd_test_037
1090 * @tc.desc: Check that the profileSigned argument is correct.
1091 * @tc.type: FUNC
1092 * @tc.require:
1093 */
1094HWTEST_F(ProcessCmdTest, processcmd_test_037, testing::ext::TestSize.Level1)
1095{
1096    char arg0[] = "";
1097    char arg1[] = "sign-app";
1098    char arg2[] = "-profileSigned";
1099    char arg3[] = "0";
1100    char* argv[] = {arg0, arg1, arg2, arg3};
1101    int argc = 4;
1102
1103    bool ret = ParamsRunTool::ProcessCmd(argv, argc);
1104
1105    EXPECT_EQ(ret, false);
1106}
1107} // namespace SignatureTools
1108} // namespace OHOS