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