• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <memory>
17 #include <cstdlib>
18 
19 #include "gtest/gtest.h"
20 #include "openssl/x509.h"
21 #include "options.h"
22 #include "sign_tool_service_impl.h"
23 #include "cert_tools.h"
24 #include "params_run_tool.h"
25 #include "file_utils.h"
26 #include "hash_utils.h"
27 #include "constant.h"
28 #include "securec.h"
29 #include "file_data_source.h"
30 #include "byte_buffer_data_source.h"
31 
32 namespace OHOS {
33 namespace SignatureTools {
34 
35 class GenerateCsrTest : public testing::Test {
36 public:
SetUpTestCase(void)37     static void SetUpTestCase(void)
38     {
39     };
TearDownTestCase()40     static void TearDownTestCase()
41     {
42     };
SetUp()43     void SetUp()
44     {
45     };
TearDown()46     void TearDown()
47     {
48     };
49 };
50 
51 /**
52  * @tc.name: generate_csr_test_001
53  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
54  * @tc.size: MEDIUM
55  * @tc.type: FUNC
56  * @tc.level Level 1
57  * @tc.require: SR000H63TL
58  */
59 HWTEST_F(GenerateCsrTest, generate_csr_test_001, testing::ext::TestSize.Level1) // 已有p12直接生成csr
60 {
61     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
62     std::shared_ptr<Options> params = std::make_shared<Options>();
63 
64     char keyPwd[] = "123456";
65     char keystorePwd[] = "123456";
66 
67     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
68     (*params)["keyPwd"] = keyPwd;
69     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
70     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
71     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
72     (*params)["keystorePwd"] = keystorePwd;
73     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-1.csr");
74 
75     bool ret = api->GenerateCsr(params.get());
76     EXPECT_EQ(ret, true);
77 }
78 
79 /**
80  * @tc.name: generate_csr_test_002
81  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
82  * @tc.size: MEDIUM
83  * @tc.type: FUNC
84  * @tc.level Level 1
85  * @tc.require: SR000H63TL
86  */
87 HWTEST_F(GenerateCsrTest, generate_csr_test_002, testing::ext::TestSize.Level1) // 生成p12并用于生成csr
88 {
89     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
90     std::shared_ptr<Options> params = std::make_shared<Options>();
91 
92     (*params)["keyAlias"] = std::string("oh-app1-key-v2");
93     (*params)["keyAlg"] = std::string("ECC");
94     (*params)["keySize"] = 256;
95     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest2.p12");
96 
97     {
98         char keyPwd[] = "keyPwdChars";
99         char keystorePwd[] = "keystorePwdChars";
100         (*params)["keyPwd"] = keyPwd;
101         (*params)["keystorePwd"] = keystorePwd;
102         bool ret = api->GenerateKeyStore(params.get());
103         EXPECT_EQ(ret, true);
104     }
105 
106     {
107         char keyPwd[] = "keyPwdChars";
108         char keystorePwd[] = "keystorePwdChars";
109         (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App2 Release");
110         (*params)["signAlg"] = std::string(SIGN_ALG_SHA384);
111         (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-2.csr");
112         (*params)["keyPwd"] = keyPwd;
113         (*params)["keystorePwd"] = keystorePwd;
114         bool ret = api->GenerateCsr(params.get());
115         EXPECT_EQ(ret, true);
116     }
117 }
118 
119 /**
120  * @tc.name: generate_csr_test_003
121  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
122  * @tc.size: MEDIUM
123  * @tc.type: FUNC
124  * @tc.level Level 1
125  * @tc.require: SR000H63TL
126  */
127 HWTEST_F(GenerateCsrTest, generate_csr_test_003, testing::ext::TestSize.Level1) // 已有p12直接生成csr但必选参数缺失如subject
128 {
129     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
130     std::shared_ptr<Options> params = std::make_shared<Options>();
131 
132     char keyPwd[] = "123456";
133     char keystorePwd[] = "123456";
134 
135     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
136     (*params)["keyPwd"] = keyPwd;
137     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
138     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
139     (*params)["keystorePwd"] = keystorePwd;
140     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-3.csr");
141 
142     bool ret = api->GenerateCsr(params.get());
143     EXPECT_EQ(ret, false);
144 }
145 
146 /**
147  * @tc.name: generate_csr_test_004
148  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
149  * @tc.size: MEDIUM
150  * @tc.type: FUNC
151  * @tc.level Level 1
152  * @tc.require: SR000H63TL
153  */
154 HWTEST_F(GenerateCsrTest, generate_csr_test_004, testing::ext::TestSize.Level1) // 已有p12直接生成csr但subject参数字符串格式无效
155 {
156     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
157     std::shared_ptr<Options> params = std::make_shared<Options>();
158 
159     char keyPwd[] = "123456";
160     char keystorePwd[] = "123456";
161 
162     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
163     (*params)["keyPwd"] = keyPwd;
164     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OpenHarmony Community,CN=App1 Release");
165     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
166     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
167     (*params)["keystorePwd"] = keystorePwd;
168     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-4.csr");
169 
170     bool ret = api->GenerateCsr(params.get());
171     EXPECT_EQ(ret, false);
172 }
173 
174 /**
175  * @tc.name: generate_csr_test_005
176  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
177  * @tc.size: MEDIUM
178  * @tc.type: FUNC
179  * @tc.level Level 1
180  * @tc.require: SR000H63TL
181  */
182 HWTEST_F(GenerateCsrTest, generate_csr_test_005, testing::ext::TestSize.Level1) // 已有p12直接生成csr但subject参数格式无效
183 {
184     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
185     std::shared_ptr<Options> params = std::make_shared<Options>();
186 
187     char keyPwd[] = "123456";
188     char keystorePwd[] = "123456";
189 
190     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
191     (*params)["keyPwd"] = keyPwd;
192     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,ABC=OpenHarmony Community,CN=App1 Release");
193     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
194     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
195     (*params)["keystorePwd"] = keystorePwd;
196     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-5.csr");
197 
198     bool ret = api->GenerateCsr(params.get());
199     EXPECT_EQ(ret, false);
200 }
201 
202 /**
203  * @tc.name: generate_csr_test_006
204  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
205  * @tc.size: MEDIUM
206  * @tc.type: FUNC
207  * @tc.level Level 1
208  * @tc.require: SR000H63TL
209  */
210 HWTEST_F(GenerateCsrTest, generate_csr_test_006, testing::ext::TestSize.Level1) // 已有p12直接生成csr但keyAlias错误
211 {
212     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
213     std::shared_ptr<Options> params = std::make_shared<Options>();
214 
215     char keyPwd[] = "123456";
216     char keystorePwd[] = "123456";
217 
218     (*params)["keyAlias"] = std::string("oh-app1-key-v6");
219     (*params)["keyPwd"] = keyPwd;
220     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
221     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
222     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
223     (*params)["keystorePwd"] = keystorePwd;
224     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-6.csr");
225 
226     bool ret = api->GenerateCsr(params.get());
227     EXPECT_EQ(ret, false);
228 }
229 
230 /**
231  * @tc.name: generate_csr_test_007
232  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
233  * @tc.size: MEDIUM
234  * @tc.type: FUNC
235  * @tc.level Level 1
236  * @tc.require: SR000H63TL
237  */
238 HWTEST_F(GenerateCsrTest, generate_csr_test_007, testing::ext::TestSize.Level1) // 已有p12直接生成csr但keystorePwd错误
239 {
240     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
241     std::shared_ptr<Options> params = std::make_shared<Options>();
242 
243     char keyPwd[] = "123456";
244     char keystorePwd[] = "654321";
245 
246     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
247     (*params)["keyPwd"] = keyPwd;
248     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
249     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
250     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
251     (*params)["keystorePwd"] = keystorePwd;
252     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-7.csr");
253 
254     bool ret = api->GenerateCsr(params.get());
255     EXPECT_EQ(ret, false);
256 }
257 
258 /**
259  * @tc.name: generate_csr_test_008
260  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
261  * @tc.size: MEDIUM
262  * @tc.type: FUNC
263  * @tc.level Level 1
264  * @tc.require: SR000H63TL
265  */
266 HWTEST_F(GenerateCsrTest, generate_csr_test_008, testing::ext::TestSize.Level1) // 已有p12直接生成csr但signAlg错误
267 {
268     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
269     std::shared_ptr<Options> params = std::make_shared<Options>();
270 
271     char keyPwd[] = "123456";
272     char keystorePwd[] = "123456";
273 
274     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
275     (*params)["keyPwd"] = keyPwd;
276     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
277     (*params)["signAlg"] = std::string("SHA256");
278     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
279     (*params)["keystorePwd"] = keystorePwd;
280     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-8.csr");
281 
282     bool ret = api->GenerateCsr(params.get());
283     EXPECT_EQ(ret, false);
284 }
285 
286 /**
287  * @tc.name: generate_csr_test_009
288  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
289  * @tc.size: MEDIUM
290  * @tc.type: FUNC
291  * @tc.level Level 1
292  * @tc.require: SR000H63TL
293  */
294 HWTEST_F(GenerateCsrTest, generate_csr_test_009, testing::ext::TestSize.Level1) // 已有p12直接生成csr不输出到文件
295 {
296     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
297     std::shared_ptr<Options> params = std::make_shared<Options>();
298 
299     char keyPwd[] = "123456";
300     char keystorePwd[] = "123456";
301 
302     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
303     (*params)["keyPwd"] = keyPwd;
304     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
305     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
306     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
307     (*params)["keystorePwd"] = keystorePwd;
308 
309     bool ret = api->GenerateCsr(params.get());
310     EXPECT_EQ(ret, true);
311 }
312 
313 /**
314  * @tc.name: generate_csr_test_010
315  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
316  * @tc.size: MEDIUM
317  * @tc.type: FUNC
318  * @tc.level Level 1
319  * @tc.require: SR000H63TL
320  */
321 HWTEST_F(GenerateCsrTest, generate_csr_test_010, testing::ext::TestSize.Level1) // 已有p12直接生成csr但路径错误
322 {
323     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
324     std::shared_ptr<Options> params = std::make_shared<Options>();
325 
326     char keyPwd[] = "123456";
327     char keystorePwd[] = "123456";
328 
329     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
330     (*params)["keyPwd"] = keyPwd;
331     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
332     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
333     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
334     (*params)["keystorePwd"] = keystorePwd;
335     (*params)["outFile"] = std::string("/d/test/resource/oh-app1-key-10.csr");
336 
337     bool ret = api->GenerateCsr(params.get());
338     EXPECT_EQ(ret, false);
339 }
340 
341 
342 /**
343  * @tc.name: generate_csr_test_011
344  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
345  * @tc.size: MEDIUM
346  * @tc.type: FUNC
347  * @tc.level Level 1
348  * @tc.require: SR000H63TL
349  */
350 HWTEST_F(GenerateCsrTest, generate_csr_test_011, testing::ext::TestSize.Level1) // 必选参数缺失keystoreFile, keystorePwd
351 {
352     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
353     std::shared_ptr<Options> params = std::make_shared<Options>();
354 
355     char keyPwd[] = "123456";
356 
357     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
358     (*params)["keyPwd"] = keyPwd;
359     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
360     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
361     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-11.csr");
362 
363     bool ret = api->GenerateCsr(params.get());
364     EXPECT_EQ(ret, false);
365 }
366 
367 /**
368  * @tc.name: generate_csr_test_012
369  * @tc.desc: Test function of SignToolServiceImpl::GenerateCsr() interface for SUCCESS.
370  * @tc.size: MEDIUM
371  * @tc.type: FUNC
372  * @tc.level Level 1
373  * @tc.require: SR000H63TL
374  */
375 HWTEST_F(GenerateCsrTest, generate_csr_test_012, testing::ext::TestSize.Level1) // 已有p12直接生成csr
376 {
377     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
378     std::shared_ptr<Options> params = std::make_shared<Options>();
379 
380     char keyPwd[] = "123456";
381     char keystorePwd[] = "123456";
382 
383     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
384     (*params)["keyPwd"] = keyPwd;
385     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
386     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
387     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
388     (*params)["keystorePwd"] = keystorePwd;
389     (*params)["outFile"] = std::string("/data/test/generateCsr/oh-app1-key-12.csr");
390 
391     bool ret = api->GenerateCsr(params.get());
392     EXPECT_EQ(ret, true);
393 }
394 
395 /**
396  * @tc.name: generate_csr_test_013
397  * @tc.desc: Test function of CertTools::GenerateCsr() interface for SUCCESS.
398  * @tc.type: FUNC
399  * @tc.require: SR000H63TL
400  */
401 HWTEST_F(GenerateCsrTest, generate_csr_test_013, testing::ext::TestSize.Level1)
402 {
403     int keySize = 256;
404     std::string algorithm = "ECC";
405     std::string signAlgorithm = SIGN_ALG_SHA256;
406     std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
407     std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
408     EVP_PKEY* keyPair = keyStoreHelper->GenerateKeyPair(algorithm, keySize);
409     EXPECT_NE(keyPair, nullptr);
410     if (!keyPair) {
411         X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlgorithm, subject);
412         EXPECT_NE(csr, nullptr);
413         if (csr) {
414             X509_REQ_free(csr);
415         }
416         EVP_PKEY_free(keyPair);
417     }
418 }
419 
420 /**
421  * @tc.name: generate_csr_test_014
422  * @tc.desc: Test function of CertTools::GenerateCsr() interface for SUCCESS.
423  * @tc.type: FUNC
424  * @tc.require: SR000H63TL
425  */
426 HWTEST_F(GenerateCsrTest, generate_csr_test_014, testing::ext::TestSize.Level1)
427 {
428     std::string signAlgorithm = SIGN_ALG_SHA256;
429     std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
430     X509_REQ* csr = CertTools::GenerateCsr(nullptr, signAlgorithm, subject);
431     EXPECT_EQ(csr, nullptr);
432 }
433 
434 /**
435  * @tc.name: csr_to_string_test_001
436  * @tc.desc: Test function of CertTools::CsrToString() interface for SUCCESS.
437  * @tc.type: FUNC
438  * @tc.require: SR000H63TL
439  */
440 HWTEST_F(GenerateCsrTest, csr_to_string_test_001, testing::ext::TestSize.Level1)
441 {
442     int keySize = 256;
443     std::string algorithm = "ECC";
444     std::string signAlgorithm = SIGN_ALG_SHA256;
445     std::string subject = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release";
446     std::shared_ptr<KeyStoreHelper> keyStoreHelper = std::make_shared<KeyStoreHelper>();
447     EVP_PKEY* keyPair = keyStoreHelper->GenerateKeyPair(algorithm, keySize);
448 
449     EXPECT_NE(keyPair, nullptr);
450 
451     if (keyPair) {
452         X509_REQ* csr = CertTools::GenerateCsr(keyPair, signAlgorithm, subject);
453         EXPECT_NE(csr, nullptr);
454         if (csr) {
455             std::string csrStr = CertTools::CsrToString(csr);
456             EXPECT_NE(csrStr.size(), 0U);
457             X509_REQ_free(csr);
458         }
459         EVP_PKEY_free(keyPair);
460     }
461 }
462 
463 /**
464  * @tc.name: csr_to_string_test_002
465  * @tc.desc: Test function of CertTools::CsrToString() interface for SUCCESS.
466  * @tc.type: FUNC
467  * @tc.require: SR000H63TL
468  */
469 HWTEST_F(GenerateCsrTest, csr_to_string_test_002, testing::ext::TestSize.Level1)
470 {
471     std::string csrStr = CertTools::CsrToString(nullptr);
472     EXPECT_EQ(csrStr, "");
473 }
474 
475 /**
476  * @tc.name: output_string_test_001
477  * @tc.desc: Test function of SignToolServiceImpl::OutputString() interface for SUCCESS.
478  * @tc.type: FUNC
479  * @tc.require: SR000H63TL
480  */
481 HWTEST_F(GenerateCsrTest, output_string_test_001, testing::ext::TestSize.Level1)
482 {
483     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
484     EXPECT_EQ(api->OutputString("hello world", "/data/test/generateCsr/output_string.txt"), true);
485 }
486 
487 /**
488  * @tc.name: run_csr_test_001
489  * @tc.desc: Test function of ParamsRunTool::RunCsr() interface for SUCCESS.
490  * @tc.type: FUNC
491  * @tc.require: SR000H63TL
492  */
493 HWTEST_F(GenerateCsrTest, run_csr_test_001, testing::ext::TestSize.Level1)
494 {
495     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
496     std::shared_ptr<Options> params = std::make_shared<Options>();
497 
498     char keyPwd[] = "123456";
499     char keystorePwd[] = "123456";
500 
501     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
502     (*params)["keyPwd"] = keyPwd;
503     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
504     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
505     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
506     (*params)["keystorePwd"] = keystorePwd;
507 
508     bool ret = ParamsRunTool::RunCsr(params.get(), *api);
509     EXPECT_EQ(ret, true);
510 }
511 
512 /**
513  * @tc.name: run_csr_test_002
514  * @tc.desc: Test function of ParamsRunTool::RunCsr() interface for SUCCESS.
515  * @tc.type: FUNC
516  * @tc.require: SR000H63TL
517  */
518 HWTEST_F(GenerateCsrTest, run_csr_test_002, testing::ext::TestSize.Level1)
519 {
520     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
521     std::shared_ptr<Options> params = std::make_shared<Options>();
522 
523     char keyPwd[] = "123456";
524     char keystorePwd[] = "123456";
525 
526     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
527     (*params)["keyPwd"] = keyPwd;
528     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
529     (*params)["signAlg"] = std::string("SHA256");
530     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
531     (*params)["keystorePwd"] = keystorePwd;
532 
533     bool ret = ParamsRunTool::RunCsr(params.get(), *api);
534     EXPECT_EQ(ret, false);
535 }
536 
537 /**
538  * @tc.name: run_csr_test_003
539  * @tc.desc: Test function of ParamsRunTool::RunCsr() interface for SUCCESS.
540  * @tc.type: FUNC
541  * @tc.require: SR000H63TL
542  */
543 HWTEST_F(GenerateCsrTest, run_csr_test_003, testing::ext::TestSize.Level1)
544 {
545     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
546     std::shared_ptr<Options> params = std::make_shared<Options>();
547 
548     char keyPwd[] = "123456";
549     char keystorePwd[] = "123456";
550 
551     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
552     (*params)["keyPwd"] = keyPwd;
553     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
554     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
555     (*params)["keystorePwd"] = keystorePwd;
556 
557     bool ret = ParamsRunTool::RunCsr(params.get(), *api);
558     EXPECT_EQ(ret, false);
559 }
560 
561 /**
562  * @tc.name: run_csr_test_004
563  * @tc.desc: Test function of ParamsRunTool::RunCsr() interface for SUCCESS.
564  * @tc.type: FUNC
565  * @tc.require: SR000H63TL
566  */
567 HWTEST_F(GenerateCsrTest, run_csr_test_004, testing::ext::TestSize.Level1)
568 {
569     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
570     std::shared_ptr<Options> params = std::make_shared<Options>();
571 
572     char keyPwd[] = "123456";
573     char keystorePwd[] = "123456";
574 
575     (*params)["keyAlias"] = std::string("oh-app1-key-v1");
576     (*params)["keyPwd"] = keyPwd;
577     (*params)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
578     (*params)["signAlg"] = std::string(SIGN_ALG_SHA256);
579     (*params)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p11");
580     (*params)["keystorePwd"] = keystorePwd;
581 
582     bool ret = ParamsRunTool::RunCsr(params.get(), *api);
583     EXPECT_EQ(ret, false);
584 }
585 
586 /**
587  * @tc.name: build_dn_test_001
588  * @tc.desc: Test function of BuildDN() interface for SUCCESS.
589  * @tc.type: FUNC
590  * @tc.require: SR000H63TL
591  */
592 HWTEST_F(GenerateCsrTest, build_dn_test_001, testing::ext::TestSize.Level1)
593 {
594     X509_REQ* csr = X509_REQ_new();
595     EXPECT_NE(csr, nullptr);
596     if (csr) {
597         X509_NAME* name = BuildDN("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release", csr);
598         EXPECT_NE(name, nullptr);
599         if (name) {
600             X509_NAME_free(name);
601         }
602     }
603 }
604 
605 /**
606  * @tc.name: check_dn_test_001
607  * @tc.desc: Test function of g_checkDn() interface for SUCCESS.
608  * @tc.type: FUNC
609  * @tc.require: SR000H63TL
610  */
611 HWTEST_F(GenerateCsrTest, check_dn_test_001, testing::ext::TestSize.Level1)
612 {
613     std::vector<pair<std::string, std::string>> pairs;
614     EXPECT_EQ(g_checkDn("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release", pairs), 0);
615 }
616 
617 /**
618  * @tc.name: split_string_test_001
619  * @tc.desc: Test function of StringUtils::SplitString() interface for SUCCESS.
620  * @tc.type: FUNC
621  * @tc.require: SR000H63TL
622  */
623 HWTEST_F(GenerateCsrTest, split_string_test_001, testing::ext::TestSize.Level1)
624 {
625     std::string str = "0:0:0:0";
626     std::vector<std::string> vec = StringUtils::SplitString(str, ':');
627     EXPECT_EQ(vec.size(), 4U);
628     if (vec.size() == 4) {
629         EXPECT_EQ(vec[0].size(), 1U);
630         if (vec[0].size() == 1U) {
631             EXPECT_EQ(vec[0][0], '0');
632         }
633     }
634 }
635 
636 /**
637  * @tc.name: trim_test_001
638  * @tc.desc: Test function of StringUtils::Trim() interface for SUCCESS.
639  * @tc.type: FUNC
640  * @tc.require: SR000H63TL
641  */
642 HWTEST_F(GenerateCsrTest, trim_test_001, testing::ext::TestSize.Level1)
643 {
644     std::string str = " \n\r\f\va \n\r\f\v";
645     std::string str1 = StringUtils::Trim(str);
646     EXPECT_EQ(str1.size(), 1U);
647 }
648 
649 /**
650  * @tc.name: call_generators_test_001
651  * @tc.desc: Test function of ParamsRunTool::CallGenerators() interface for SUCCESS.
652  * @tc.type: FUNC
653  * @tc.require: SR000H63TL
654  */
655 HWTEST_F(GenerateCsrTest, call_generators_test_001, testing::ext::TestSize.Level1)
656 {
657     ParamsSharedPtr params = std::make_shared<Params>();
658     params->SetMethod(GENERATE_CSR);
659     Options* options = params->GetOptions();
660     std::shared_ptr<SignToolServiceImpl> api = std::make_shared<SignToolServiceImpl>();
661 
662     char keyPwd[] = "123456";
663     char keystorePwd[] = "123456";
664     (*options)["keyAlias"] = std::string("oh-app1-key-v1");
665     (*options)["keyPwd"] = keyPwd;
666     (*options)["subject"] = std::string("C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release");
667     (*options)["signAlg"] = std::string(SIGN_ALG_SHA256);
668     (*options)["keystoreFile"] = std::string("/data/test/generateCsr/ohtest.p12");
669     (*options)["keystorePwd"] = keystorePwd;
670 
671     EXPECT_EQ(ParamsRunTool::CallGenerators(params, *api), true);
672 }
673 
674 /**
675  * @tc.name: process_cmd_test_001
676  * @tc.desc: Test function of ParamsRunTool::ProcessCmd() interface for SUCCESS.
677  * @tc.type: FUNC
678  * @tc.require: SR000H63TL
679  */
680 HWTEST_F(GenerateCsrTest, process_cmd_test_001, testing::ext::TestSize.Level1)
681 {
682     char arg0[] = "", arg1[] = "generate-csr", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
683         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
684         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
685         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
686         arg12[] = "-keyPwd", arg13[] = "123456";
687     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
688     arg7[SIGN_ALG_SHA256.size()] = '\0';
689     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
690     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13 };
691     EXPECT_EQ(ParamsRunTool::ProcessCmd(args, sizeof(args) / sizeof((char*)arg0)), true);
692     delete[] arg7;
693 }
694 
695 /**
696  * @tc.name: process_cmd_test_003
697  * @tc.desc: Test function of ParamsRunTool::ProcessCmd() interface for SUCCESS.
698  * @tc.type: FUNC
699  * @tc.require: SR000H63TL
700  */
701 HWTEST_F(GenerateCsrTest, process_cmd_test_003, testing::ext::TestSize.Level1)
702 {
703     char arg0[] = "", arg1[] = "-h", arg2[] = "";
704     char* args[] = { arg0, arg1 };
705     EXPECT_EQ(ParamsRunTool::ProcessCmd(args, sizeof(args) / sizeof((char*)arg0)), true);
706     char* args1[] = { arg0, arg2 };
707     EXPECT_EQ(ParamsRunTool::ProcessCmd(args, sizeof(args1) / sizeof((char*)arg0)), true);
708 }
709 
710 /**
711  * @tc.name: process_cmd_test_004
712  * @tc.desc: Test function of ParamsRunTool::ProcessCmd() interface for SUCCESS.
713  * @tc.type: FUNC
714  * @tc.require: SR000H63TL
715  */
716 HWTEST_F(GenerateCsrTest, process_cmd_test_004, testing::ext::TestSize.Level1)
717 {
718     char arg0[] = "", arg1[] = "-v";
719     char* args[] = { arg0, arg1 };
720     ParamsRunTool::Version();
721     EXPECT_EQ(ParamsRunTool::ProcessCmd(args, sizeof(args) / sizeof((char*)arg0)), true);
722 }
723 
724 /**
725  * @tc.name: is_valid_file_test_001
726  * @tc.desc: Test function of FileUtils::IsValidFile() interface for SUCCESS.
727  * @tc.type: FUNC
728  * @tc.require: SR000H63TL
729  */
730 HWTEST_F(GenerateCsrTest, is_valid_file_test_001, testing::ext::TestSize.Level1)
731 {
732     EXPECT_EQ(FileUtils::IsValidFile("/data/test/generateCsr/ohtest.p12"), true);
733     EXPECT_EQ(FileUtils::IsValidFile("/data/test/generateCsr/ohtest.p11"), false);
734     EXPECT_EQ(FileUtils::IsValidFile("/data/test/generateCsr/"), false);
735 }
736 
737 /**
738  * @tc.name: convert2params_test_001
739  * @tc.desc: Test function of CmdUtil::Convert2Params() interface for SUCCESS.
740  * @tc.type: FUNC
741  * @tc.require: SR000H63TL
742  */
743 HWTEST_F(GenerateCsrTest, convert2params_test_001, testing::ext::TestSize.Level1)
744 {
745     char arg0[] = "", arg1[] = "generate-csr", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
746         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
747         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
748         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
749         arg12[] = "-keyPwd", arg13[] = "123456";
750     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
751     arg7[SIGN_ALG_SHA256.size()] = '\0';
752     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
753     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
754         arg11, arg12, arg13 };
755     ParamsSharedPtr param = std::make_shared<Params>();
756     CmdUtil cmdUtil;
757     EXPECT_EQ(cmdUtil.Convert2Params(args, sizeof(args) / sizeof((char*)arg0), param), true);
758     delete[] arg7;
759 }
760 
761 /**
762  * @tc.name: convert2params_test_002
763  * @tc.desc: Test function of CmdUtil::Convert2Params() interface for SUCCESS.
764  * @tc.type: FUNC
765  * @tc.require: SR000H63TL
766  */
767 HWTEST_F(GenerateCsrTest, convert2params_test_002, testing::ext::TestSize.Level1)
768 {
769     char arg0[] = "", arg1[] = "generate", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
770         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
771         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
772         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
773         arg12[] = "-keyPwd", arg13[] = "123456";
774     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
775     arg7[SIGN_ALG_SHA256.size()] = '\0';
776     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
777     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
778         arg11, arg12, arg13 };
779     ParamsSharedPtr param = std::make_shared<Params>();
780     CmdUtil cmdUtil;
781     EXPECT_EQ(cmdUtil.Convert2Params(args, sizeof(args) / sizeof((char*)arg0), param), false);
782     delete[] arg7;
783 }
784 
785 /**
786  * @tc.name: convert2params_test_003
787  * @tc.desc: Test function of CmdUtil::Convert2Params() interface for SUCCESS.
788  * @tc.type: FUNC
789  * @tc.require: SR000H63TL
790  */
791 HWTEST_F(GenerateCsrTest, convert2params_test_003, testing::ext::TestSize.Level1)
792 {
793     char arg0[] = "", arg1[] = "generate-csr", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
794         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
795         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
796         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
797         arg12[] = "-keyPwd", arg13[] = "123456", arg14[] = "-signcode";
798     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
799     arg7[SIGN_ALG_SHA256.size()] = '\0';
800     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
801     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
802         arg11, arg12, arg13, arg14 };
803     ParamsSharedPtr param = std::make_shared<Params>();
804     CmdUtil cmdUtil;
805     EXPECT_EQ(cmdUtil.Convert2Params(args, sizeof(args) / sizeof((char*)arg0), param), false);
806     delete[] arg7;
807 }
808 
809 /**
810  * @tc.name: convert2params_test_004
811  * @tc.desc: Test function of CmdUtil::Convert2Params() interface for SUCCESS.
812  * @tc.type: FUNC
813  * @tc.require: SR000H63TL
814  */
815 HWTEST_F(GenerateCsrTest, convert2params_test_004, testing::ext::TestSize.Level1)
816 {
817     char arg0[] = "", arg1[] = "generate-csr", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
818         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
819         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
820         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
821         arg12[] = "-keyPwd", arg13[] = "123456", arg14[] = "";
822     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
823     arg7[SIGN_ALG_SHA256.size()] = '\0';
824     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
825     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
826         arg11, arg12, arg13, arg14 };
827     ParamsSharedPtr param = std::make_shared<Params>();
828     CmdUtil cmdUtil;
829     EXPECT_EQ(cmdUtil.Convert2Params(args, sizeof(args) / sizeof((char*)arg0), param), false);
830     delete[] arg7;
831 }
832 
833 /**
834  * @tc.name: get_method_test_001
835  * @tc.desc: Test function of Params::GetMethod() interface for SUCCESS.
836  * @tc.type: FUNC
837  * @tc.require: SR000H63TL
838  */
839 HWTEST_F(GenerateCsrTest, get_method_test_001, testing::ext::TestSize.Level1)
840 {
841     Params params;
842     params.SetMethod("test");
843     EXPECT_EQ(params.GetMethod(), "test");
844 }
845 
846 /**
847  * @tc.name: dispatch_params_test_001
848  * @tc.desc: Test function of ParamsRunTool::DispatchParams() interface for SUCCESS.
849  * @tc.type: FUNC
850  * @tc.require: SR000H63TL
851  */
852 HWTEST_F(GenerateCsrTest, dispatch_params_test_001, testing::ext::TestSize.Level1)
853 {
854     char arg0[] = "", arg1[] = "generate-csr", arg2[] = "-keyAlias", arg3[] = "oh-app1-key-v1",
855         arg4[] = "-subject", arg5[] = "C=CN,O=OpenHarmony,OU=OpenHarmony Community,CN=App1 Release",
856         arg6[] = "-signAlg", arg8[] = "-keystoreFile",
857         arg9[] = "/data/test/generateCsr/ohtest.p12", arg10[] = "-keystorePwd", arg11[] = "123456",
858         arg12[] = "-keyPwd", arg13[] = "123456";
859     char* arg7 = new char[SIGN_ALG_SHA256.size() + 1]();
860     arg7[SIGN_ALG_SHA256.size()] = '\0';
861     EXPECT_EQ(memcpy_s(arg7, SIGN_ALG_SHA256.size(), SIGN_ALG_SHA256.c_str(), SIGN_ALG_SHA256.size()), 0);
862     char* args[] = { arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10,
863         arg11, arg12, arg13 };
864     ParamsSharedPtr param = std::make_shared<Params>();
865     CmdUtil cmdUtil;
866     EXPECT_EQ(cmdUtil.Convert2Params(args, sizeof(args) / sizeof((char*)arg0), param), true);
867     std::shared_ptr<SignToolServiceImpl> service_api = std::make_shared<SignToolServiceImpl>();
868     EXPECT_EQ(ParamsRunTool::DispatchParams(param, *service_api), true);
869     delete[] arg7;
870 }
871 
872 /**
873  * @tc.name: get_hash_algs_id_test_001
874  * @tc.desc: Test function of HashUtils::GetHashAlgsId() interface for SUCCESS.
875  * @tc.type: FUNC
876  * @tc.require: SR000H63TL
877  */
878 HWTEST_F(GenerateCsrTest, get_hash_algs_id_test_001, testing::ext::TestSize.Level1)
879 {
880     HashUtils::GetHashAlgsId("SHA-224");
881     HashUtils::GetHashAlgsId("SHA-384");
882     HashUtils::GetHashAlgsId("SHA-512");
883     int ret = HashUtils::GetHashAlgsId("SHA-1024");
884     EXPECT_EQ(ret, 0);
885 }
886 
887 /**
888  * @tc.name: get_hash_algs_name_test_001
889  * @tc.desc: Test function of HashUtils::GetHashAlgName() interface for SUCCESS.
890  * @tc.type: FUNC
891  * @tc.require: SR000H63TL
892  */
893 HWTEST_F(GenerateCsrTest, get_hash_algs_name_test_001, testing::ext::TestSize.Level1)
894 {
895     HashUtils::GetHashAlgName(5);
896     HashUtils::GetHashAlgName(7);
897     HashUtils::GetHashAlgName(8);
898     std::string ret = HashUtils::GetHashAlgName(9);
899     EXPECT_EQ(ret, "");
900 }
901 
902 /**
903  * @tc.name: read_data_and_digest_update_test_001
904  * @tc.desc: Test function of FileDataSource::ReadDataAndDigestUpdate() interface for SUCCESS.
905  * @tc.type: FUNC
906  * @tc.require: SR000H63TL
907  */
908 HWTEST_F(GenerateCsrTest, read_data_and_digest_update_test_001, testing::ext::TestSize.Level1)
909 {
910     HashUtils::GetDigestFromBytes({}, 1, "");
911     HashUtils::GetDigestFromBytes({ 'a' }, 0, "");
912 
913     RandomAccessFile file;
914     FileDataSource src(file, 0, 0, 0);
915     DigestParameter param;
916     bool ret = src.ReadDataAndDigestUpdate(param, -1);
917     EXPECT_EQ(ret, false);
918 }
919 
920 /**
921  * @tc.name: read_data_and_digest_update_test_002
922  * @tc.desc: Test function of ByteBufferDataSource::ReadDataAndDigestUpdate() interface for SUCCESS.
923  * @tc.type: FUNC
924  * @tc.require: SR000H63TL
925  */
926 HWTEST_F(GenerateCsrTest, read_data_and_digest_update_test_002, testing::ext::TestSize.Level1)
927 {
928     ByteBuffer buffer;
929     ByteBufferDataSource src(buffer);
930     DigestParameter param;
931     bool ret = src.ReadDataAndDigestUpdate(param, -1);
932     EXPECT_EQ(ret, false);
933 }
934 
935 } // namespace SignatureTools
936 } // namespace OHOS