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
32namespace OHOS {
33namespace SignatureTools {
34
35class GenerateCsrTest : public testing::Test {
36public:
37    static void SetUpTestCase(void)
38    {
39    };
40    static void TearDownTestCase()
41    {
42    };
43    void SetUp()
44    {
45    };
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 */
59HWTEST_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 */
87HWTEST_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 */
127HWTEST_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 */
154HWTEST_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 */
182HWTEST_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 */
210HWTEST_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 */
238HWTEST_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 */
266HWTEST_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 */
294HWTEST_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 */
321HWTEST_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 */
350HWTEST_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 */
375HWTEST_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 */
401HWTEST_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 */
426HWTEST_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 */
440HWTEST_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 */
469HWTEST_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 */
481HWTEST_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 */
493HWTEST_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 */
518HWTEST_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 */
543HWTEST_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 */
567HWTEST_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 */
592HWTEST_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 */
611HWTEST_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 */
623HWTEST_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 */
642HWTEST_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 */
655HWTEST_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 */
680HWTEST_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 */
701HWTEST_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 */
716HWTEST_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 */
730HWTEST_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 */
743HWTEST_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 */
767HWTEST_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 */
791HWTEST_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 */
815HWTEST_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 */
839HWTEST_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 */
852HWTEST_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 */
878HWTEST_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 */
893HWTEST_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 */
908HWTEST_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 */
926HWTEST_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