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 <chrono>
16#include <thread>
17#include <string>
18#include <filesystem>
19
20#include "gtest/gtest.h"
21#include "options.h"
22#include "sign_tool_service_impl.h"
23#include "nlohmann/json.hpp"
24#include "signer_factory.h"
25#include "profile_sign_tool.h"
26#include "params_run_tool.h"
27#include "pkcs7_data.h"
28#include "signer_config.h"
29#include "local_signer.h"
30#include "bc_pkcs7_generator.h"
31#include "bc_signeddata_generator.h"
32#include "profile_verify.h"
33#include "constant.h"
34
35using  nlohmann::json;
36
37namespace OHOS {
38namespace SignatureTools {
39
40// sign profile使用的全局参数
41static const std::string SIGN_PROFILE_MODE = "localSign";
42static const std::string SIGN_PROFILE_KEY_ALIAS = "oh-profile1-key-v1";
43static const std::string SIGN_PROFILE_PROFILE_CERT_FILE = "./signProfile/profile-release1.pem";
44static const std::string SIGN_PROFILE_SIGN_ALG = "SHA384withECDSA";
45static const std::string SIGN_PROFILE_KEY_STORE_FILE = "./signProfile/ohtest.p12";
46static const std::string SIGN_PROFILE_OUT_FILE = "./signProfile/signed-profile.p7b";
47static const std::string SIGN_PROFILE_IN_FILE = "./signProfile/profile.json";
48// verify profile 使用的全局参数
49static const std::string VERIFY_PROFILE_IN_FILE = "./signProfile/signed-profile.p7b";
50static const std::string VERIFY_PROFILE_OUT_FILE = "./signProfile/VerifyResult.json";
51// sign app 使用全局参数
52static const std::string SIGN_APP_MODE = "localSign";
53static const std::string SIGN_APP_KEY_ALIAS = "oh-app1-key-v1";
54static const std::string SIGN_APP_APP_CERT_FILE = "./signProfile/app-release1.pem";
55static const std::string SIGN_APP_PROFILE_FILE = "./signProfile/signed-profile.p7b";
56static const std::string SIGN_APP_IN_FILE = "./signProfile/unsigned.hap";
57static const std::string SIGN_APP_IN_FILE_TXT = "./signProfile/unsigned.txt";
58static const std::string SIGN_APP_SIGN_ALG = "SHA256withECDSA";
59static const std::string SIGN_APP_KEY_STORE_FILE = "./signProfile/ohtest.p12";
60static const std::string SIGN_APP_OUT_FILE = "./signProfile/signed.hap";
61
62class SignProfileTest : public testing::Test {
63public:
64    static void SetUpTestCase(void);
65
66    static void TearDownTestCase(void);
67
68    void SetUp()override;
69
70    void TearDown()override;
71};
72
73void SignProfileTest::SetUpTestCase(void)
74{
75    std::filesystem::copy(SIGN_APP_IN_FILE_TXT, SIGN_APP_IN_FILE);
76}
77
78void SignProfileTest::TearDownTestCase(void)
79{
80    std::filesystem::remove(SIGN_APP_IN_FILE);
81}
82
83void SignProfileTest::SetUp()
84{
85}
86
87void SignProfileTest::TearDown()
88{
89}
90
91/**
92    * @tc.name: run_sign_profile_test001
93    * @tc.desc: Test function of HapSignTool::RunSignProfile() interface for SUCCESS.
94    * @tc.size: MEDIUM
95    * @tc.type: FUNC
96    * @tc.level Level 1
97    * @tc.require: SR000H63TL
98    */
99HWTEST_F(SignProfileTest, run_sign_profile_test001, testing::ext::TestSize.Level1)
100{
101    Options options;
102    std::string mode = SIGN_PROFILE_MODE;
103    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
104    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
105    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
106    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
107    std::string outFile = SIGN_PROFILE_OUT_FILE;
108    std::string inFile = SIGN_PROFILE_IN_FILE;
109    char keyStorePwd[] = "123456";
110    char keypwd[] = "123456";
111    options[Options::KEY_ALIAS] = keyAlias;
112    options[Options::MODE] = mode;
113    options[Options::PROFILE_CERT_FILE] = profileCertFile;
114    options[Options::SIGN_ALG] = signAlg;
115    options[Options::KEY_STORE_FILE] = keystoreFile;
116    options[Options::OUT_FILE] = outFile;
117    options[Options::IN_FILE] = inFile;
118    options[Options::KEY_RIGHTS] = keypwd;
119    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
120
121    LocalizationAdapter adapter(&options);
122    SignToolServiceImpl api;
123    bool result = ParamsRunTool::RunSignProfile(&options, api);
124    EXPECT_EQ(result, true);
125}
126
127/**
128    * @tc.name: sign_profile_test001
129    * @tc.desc: Test function of SignToolServiceImpl::SignProfile() interface for SUCCESS.
130    * @tc.size: MEDIUM
131    * @tc.type: FUNC
132    * @tc.level Level 1
133    * @tc.require: SR000H63TL
134    */
135HWTEST_F(SignProfileTest, sign_profile_test001, testing::ext::TestSize.Level1)
136{
137    Options options;
138    std::string mode = SIGN_PROFILE_MODE;
139    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
140    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
141    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
142    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
143    std::string outFile = SIGN_PROFILE_OUT_FILE;
144    std::string inFile = SIGN_PROFILE_IN_FILE;
145    char keyStorePwd[] = "123456";
146    char keypwd[] = "123456";
147    char pwd[] = "123456";
148    options[Options::KEY_ALIAS] = keyAlias;
149    options[Options::MODE] = mode;
150    options[Options::PROFILE_CERT_FILE] = profileCertFile;
151    options[Options::SIGN_ALG] = signAlg;
152    options[Options::KEY_STORE_FILE] = keystoreFile;
153    options[Options::OUT_FILE] = outFile;
154    options[Options::IN_FILE] = inFile;
155    options[Options::KEY_RIGHTS] = keypwd;
156    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
157
158    LocalizationAdapter adapter(&options);
159    SignToolServiceImpl api;
160    bool result = api.SignProfile(&options);
161    EXPECT_EQ(result, true);
162    // 密钥匿名错误 失败
163    options[Options::KEY_ALIAS] = std::string("oh-profile1-key-v2");
164    std::copy(pwd, pwd + 7, keypwd);
165    std::copy(pwd, pwd + 7, keyStorePwd);
166    result = api.SignProfile(&options);
167    options[Options::KEY_ALIAS] = std::string("oh-profile1-key-v1");
168    EXPECT_EQ(result, false);
169    // 使用SHAwithECDSA256签名算法 成功
170    options[Options::SIGN_ALG] = std::string("SHA256withECDSA");
171    std::copy(pwd, pwd + 7, keypwd);
172    std::copy(pwd, pwd + 7, keyStorePwd);
173    result = api.SignProfile(&options);
174    options[Options::SIGN_ALG] = std::string("SHA384withECDSA");
175    EXPECT_EQ(result, true);
176}
177
178/**
179    * @tc.name: get_provision_content_test001
180    * @tc.desc: Test function of SignToolServiceImpl::GetProvisionContent() interface for SUCCESS.
181    * @tc.size: MEDIUM
182    * @tc.type: FUNC
183    * @tc.level Level 1
184    * @tc.require: SR000H63TL
185    */
186HWTEST_F(SignProfileTest, get_provision_content_test001, testing::ext::TestSize.Level1)
187{
188    std::string ret;
189    const std::string provisionFilePath = SIGN_PROFILE_IN_FILE;
190    SignToolServiceImpl::GetProvisionContent(provisionFilePath, ret);
191    EXPECT_TRUE(ret.size() > 0);
192}
193
194/**
195* @tc.name: parse_provision_test001
196* @tc.desc: Test function of ParseProvision() interface for SUCCESS.
197* @tc.size: MEDIUM
198* @tc.type: FUNC
199* @tc.level Level 1
200* @tc.require: SR000H63TL
201*/
202HWTEST_F(SignProfileTest, parse_provision_test001, testing::ext::TestSize.Level1)
203{
204    std::string bytes;
205    FileUtils::ReadFile(SIGN_PROFILE_IN_FILE, bytes);
206    ProfileInfo provision;
207    AppProvisionVerifyResult result = ParseProvision(bytes, provision);
208    EXPECT_TRUE(result == PROVISION_OK);
209}
210
211/**
212    * @tc.name: generate_p7b_test001
213    * @tc.desc: Test function of ProfileSignTool::GenerateP7b() interface for SUCCESS.
214    * @tc.size: MEDIUM
215    * @tc.type: FUNC
216    * @tc.level Level 1
217    * @tc.require: SR000H63TL
218    */
219HWTEST_F(SignProfileTest, generate_p7b_test001, testing::ext::TestSize.Level1)
220{
221    Options options;
222    std::string mode = SIGN_PROFILE_MODE;
223    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
224    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
225    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
226    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
227    std::string outFile = SIGN_PROFILE_OUT_FILE;
228    std::string inFile = SIGN_PROFILE_IN_FILE;
229    char keyStorePwd[] = "123456";
230    char keypwd[] = "123456";
231    options[Options::KEY_ALIAS] = keyAlias;
232    options[Options::MODE] = mode;
233    options[Options::PROFILE_CERT_FILE] = profileCertFile;
234    options[Options::SIGN_ALG] = signAlg;
235    options[Options::KEY_STORE_FILE] = keystoreFile;
236    options[Options::OUT_FILE] = outFile;
237    options[Options::IN_FILE] = inFile;
238    options[Options::KEY_RIGHTS] = keypwd;
239    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
240
241    LocalizationAdapter adapter(&options);
242    std::string content = "json content";
243    int result = ProfileSignTool::GenerateP7b(adapter, content, content);
244    EXPECT_TRUE(result == 0);
245}
246
247/**
248    * @tc.name: print_cert_chain_sub_test001
249    * @tc.desc: Test function of PKCS7Data::PrintCertChainSub() interface for SUCCESS.
250    * @tc.size: MEDIUM
251    * @tc.type: FUNC
252    * @tc.level Level 1
253    * @tc.require: SR000H63TL
254    */
255HWTEST_F(SignProfileTest, print_cert_chain_sub_test001, testing::ext::TestSize.Level1)
256{
257    Options options;
258    std::string mode = SIGN_PROFILE_MODE;
259    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
260    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
261    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
262    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
263    std::string outFile = SIGN_PROFILE_OUT_FILE;
264    std::string inFile = SIGN_PROFILE_IN_FILE;
265    char keyStorePwd[] = "123456";
266    char keypwd[] = "123456";
267    options[Options::KEY_ALIAS] = keyAlias;
268    options[Options::MODE] = mode;
269    options[Options::PROFILE_CERT_FILE] = profileCertFile;
270    options[Options::SIGN_ALG] = signAlg;
271    options[Options::KEY_STORE_FILE] = keystoreFile;
272    options[Options::OUT_FILE] = outFile;
273    options[Options::IN_FILE] = inFile;
274    options[Options::KEY_RIGHTS] = keypwd;
275    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
276
277    LocalizationAdapter adapter(&options);
278    SignerFactory factory;
279    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
280    STACK_OF(X509)* certs = signer->GetCertificates();
281    PKCS7Data::PrintCertChainSub(certs);
282    int ret = PKCS7Data::SortX509Stack(certs);
283    EXPECT_EQ(ret, RET_OK);
284}
285
286/**
287* @tc.name: run_verify_profile_test001
288* @tc.desc: Test function of HapSignTool::RunVerifyProfile() interface for SUCCESS.
289* @tc.size: MEDIUM
290* @tc.type: FUNC
291* @tc.level Level 1
292* @tc.require: SR000H63TL
293*/
294HWTEST_F(SignProfileTest, run_verify_profile_test001, testing::ext::TestSize.Level1)
295{
296    Options options;
297    options[Options::IN_FILE] = VERIFY_PROFILE_IN_FILE;
298    options[Options::OUT_FILE] = VERIFY_PROFILE_OUT_FILE;
299    SignToolServiceImpl api;
300    bool ret = ParamsRunTool::RunVerifyProfile(&options, api);
301    EXPECT_EQ(ret, true);
302}
303
304/**
305* @tc.name: run_sign_profile_test001
306* @tc.desc: Test function of SignToolServiceImpl::VerifyProfile() interface for SUCCESS json写入OUT_FILE.
307* @tc.size: MEDIUM
308* @tc.type: FUNC
309* @tc.level Level 1
310* @tc.require: SR000H63TL
311*/
312HWTEST_F(SignProfileTest, verify_profile_test001, testing::ext::TestSize.Level1)
313{
314    Options options;
315    options[Options::IN_FILE] = VERIFY_PROFILE_IN_FILE;
316    options[Options::OUT_FILE] = VERIFY_PROFILE_OUT_FILE;
317    bool result = false;
318    SignToolServiceImpl api;
319    result = api.VerifyProfile(&options);
320    EXPECT_TRUE(result);
321}
322
323
324/**
325    * @tc.name: run_sign_profile_test001
326    * @tc.desc: Test function of SignToolServiceImpl::VerifyProfile() interface for SUCCESS 验证成功打印json到控制台.
327    * @tc.size: MEDIUM
328    * @tc.type: FUNC
329    * @tc.level Level 1
330    * @tc.require: SR000H63TL
331    */
332HWTEST_F(SignProfileTest, verify_profile_test002, testing::ext::TestSize.Level1)
333{
334    Options options;
335    options[Options::IN_FILE] = VERIFY_PROFILE_IN_FILE;
336    options[Options::OUT_FILE] = VERIFY_PROFILE_OUT_FILE;
337    bool result = false;
338    SignToolServiceImpl api;
339    result = api.VerifyProfile(&options);
340    EXPECT_TRUE(result);
341}
342
343/**
344* @tc.name: parse_test001
345* @tc.desc: Test function of PKCS7Data::Parse() interface for SUCCESS .
346* @tc.size: MEDIUM
347* @tc.type: FUNC
348* @tc.level Level 1
349* @tc.require: SR000H63TL
350*/
351HWTEST_F(SignProfileTest, parse_test001, testing::ext::TestSize.Level1)
352{
353    std::string p7b;
354    FileUtils::ReadFile(VERIFY_PROFILE_IN_FILE, p7b);
355    PKCS7Data p7;
356    int result = p7.Parse(p7b);
357    EXPECT_EQ(result, 0);
358}
359
360/**
361    * @tc.name: parse_test001
362    * @tc.desc: Test function of PKCS7Data::Parse() interface for SUCCESS .
363    * @tc.size: MEDIUM
364    * @tc.type: FUNC
365    * @tc.level Level 1
366    * @tc.require: SR000H63TL
367    */
368HWTEST_F(SignProfileTest, parse_test002, testing::ext::TestSize.Level1)
369{
370    std::string p7b;
371    FileUtils::ReadFile(VERIFY_PROFILE_IN_FILE, p7b);
372    PKCS7Data p7;
373    std::vector<int8_t> p7b_(p7b.begin(), p7b.end());
374    int result = p7.Parse(p7b_);
375    EXPECT_EQ(result, 0);
376}
377
378/**
379    * @tc.name: parse_test001
380    * @tc.desc: Test function of PKCS7Data::Sign() interface for SUCCESS .
381    * @tc.size: MEDIUM
382    * @tc.type: FUNC
383    * @tc.level Level 1
384    * @tc.require: SR000H63TL
385    */
386HWTEST_F(SignProfileTest, sign_test001, testing::ext::TestSize.Level1)
387{
388    std::string content = "signed content data";
389    Options options;
390    std::string mode = SIGN_PROFILE_MODE;
391    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
392    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
393    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
394    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
395    std::string outFile = SIGN_PROFILE_OUT_FILE;
396    std::string inFile = SIGN_PROFILE_IN_FILE;
397    char keyStorePwd[] = "123456";
398    char keypwd[] = "123456";
399    options[Options::KEY_ALIAS] = keyAlias;
400    options[Options::MODE] = mode;
401    options[Options::PROFILE_CERT_FILE] = profileCertFile;
402    options[Options::SIGN_ALG] = signAlg;
403    options[Options::KEY_STORE_FILE] = keystoreFile;
404    options[Options::OUT_FILE] = outFile;
405    options[Options::IN_FILE] = inFile;
406    options[Options::KEY_RIGHTS] = keypwd;
407    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
408
409    LocalizationAdapter adapter(&options);
410    SignerFactory factory;
411    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
412    PKCS7Data p7;
413    std::string p7b;
414    int result = p7.Sign(content, signer, "SHA384withECDSA", p7b);
415    EXPECT_EQ(result, 0);
416}
417
418/**
419    * @tc.name: parse_test001
420    * @tc.desc: Test function of PKCS7Data::Sign() interface for SUCCESS .数据分离
421    * @tc.size: MEDIUM
422    * @tc.type: FUNC
423    * @tc.level Level 1
424    * @tc.require: SR000H63TL
425    */
426HWTEST_F(SignProfileTest, sign_test002, testing::ext::TestSize.Level1)
427{
428    std::string content = "signed content data";
429    Options options;
430    std::string mode = SIGN_PROFILE_MODE;
431    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
432    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
433    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
434    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
435    std::string outFile = SIGN_PROFILE_OUT_FILE;
436    std::string inFile = SIGN_PROFILE_IN_FILE;
437    char keyStorePwd[] = "123456";
438    char keypwd[] = "123456";
439    options[Options::KEY_ALIAS] = keyAlias;
440    options[Options::MODE] = mode;
441    options[Options::PROFILE_CERT_FILE] = profileCertFile;
442    options[Options::SIGN_ALG] = signAlg;
443    options[Options::KEY_STORE_FILE] = keystoreFile;
444    options[Options::OUT_FILE] = outFile;
445    options[Options::IN_FILE] = inFile;
446    options[Options::KEY_RIGHTS] = keypwd;
447    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
448
449    LocalizationAdapter adapter(&options);
450    SignerFactory factory;
451    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
452    PKCS7Data p7(PKCS7_DETACHED_FLAGS);
453    std::string p7b;
454    int result = p7.Sign(content, signer, "SHA384withECDSA", p7b);
455    EXPECT_EQ(result, 0);
456}
457
458/**
459    * @tc.name: parse_test001
460    * @tc.desc: Test function of PKCS7Data::Verify() interface for SUCCESS .数据分离
461    * @tc.size: MEDIUM
462    * @tc.type: FUNC
463    * @tc.level Level 1
464    * @tc.require: SR000H63TL
465    */
466HWTEST_F(SignProfileTest, verify_test001, testing::ext::TestSize.Level1)
467{
468    std::string p7b;
469    FileUtils::ReadFile(VERIFY_PROFILE_IN_FILE, p7b);
470    PKCS7Data p7;
471    int result = p7.Parse(p7b);
472    // 验证
473    result = p7.Verify();
474    EXPECT_EQ(result, 0);
475}
476/**
477    * @tc.name: get_original_raw_data_test001
478    * @tc.desc: Test function of PKCS7Data::GetOriginalRawData() interface for SUCCESS .
479    * @tc.size: MEDIUM
480    * @tc.type: FUNC
481    * @tc.level Level 1
482    * @tc.require: SR000H63TL
483    */
484HWTEST_F(SignProfileTest, get_original_raw_data_test001, testing::ext::TestSize.Level1)
485{
486    std::string p7b;
487    FileUtils::ReadFile(VERIFY_PROFILE_IN_FILE, p7b);
488    PKCS7Data p7;
489    int result = p7.Parse(p7b);
490    std::string provision;
491    result = p7.GetContent(provision);
492    EXPECT_EQ(result, 0);
493}
494
495/**
496    * @tc.name: get_signer_test001
497    * @tc.desc: Test function of SignerFactory::GetSigner() interface for SUCCESS .
498    * @tc.size: MEDIUM
499    * @tc.type: FUNC
500    * @tc.level Level 1
501    * @tc.require: SR000H63TL
502    */
503HWTEST_F(SignProfileTest, get_signer_test001, testing::ext::TestSize.Level1)
504{
505    Options options;
506    std::string mode = SIGN_PROFILE_MODE;
507    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
508    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
509    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
510    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
511    std::string outFile = SIGN_PROFILE_OUT_FILE;
512    std::string inFile = SIGN_PROFILE_IN_FILE;
513    char keyStorePwd[] = "123456";
514    char keypwd[] = "123456";
515    options[Options::KEY_ALIAS] = keyAlias;
516    options[Options::MODE] = mode;
517    options[Options::PROFILE_CERT_FILE] = profileCertFile;
518    options[Options::SIGN_ALG] = signAlg;
519    options[Options::KEY_STORE_FILE] = keystoreFile;
520    options[Options::OUT_FILE] = outFile;
521    options[Options::IN_FILE] = inFile;
522    options[Options::KEY_RIGHTS] = keypwd;
523    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
524
525    LocalizationAdapter adapter(&options);
526    SignerFactory factory;
527    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
528    EXPECT_TRUE(signer != NULL);
529}
530
531/**
532    * @tc.name: get_crls_test001
533    * @tc.desc: Test function of LocalSigner::GetCrls() interface for SUCCESS .
534    * @tc.size: MEDIUM
535    * @tc.type: FUNC
536    * @tc.level Level 1
537    * @tc.require: SR000H63TL
538    */
539HWTEST_F(SignProfileTest, get_crls_test001, testing::ext::TestSize.Level1)
540{
541    Options options;
542    std::string mode = SIGN_PROFILE_MODE;
543    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
544    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
545    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
546    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
547    std::string outFile = SIGN_PROFILE_OUT_FILE;
548    std::string inFile = SIGN_PROFILE_IN_FILE;
549    char keyStorePwd[] = "123456";
550    char keypwd[] = "123456";
551    options[Options::KEY_ALIAS] = keyAlias;
552    options[Options::MODE] = mode;
553    options[Options::PROFILE_CERT_FILE] = profileCertFile;
554    options[Options::SIGN_ALG] = signAlg;
555    options[Options::KEY_STORE_FILE] = keystoreFile;
556    options[Options::OUT_FILE] = outFile;
557    options[Options::IN_FILE] = inFile;
558    options[Options::KEY_RIGHTS] = keypwd;
559    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
560
561    LocalizationAdapter adapter(&options);
562    SignerFactory factory;
563    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
564    STACK_OF(X509_CRL)* crls = signer->GetCrls();
565    EXPECT_TRUE(crls == NULL);
566}
567
568/**
569    * @tc.name: get_certificates_test001
570    * @tc.desc: Test function of LocalSigner::GetCertificates() interface for SUCCESS .
571    * @tc.size: MEDIUM
572    * @tc.type: FUNC
573    * @tc.level Level 1
574    * @tc.require: SR000H63TL
575    */
576HWTEST_F(SignProfileTest, get_certificates_test001, testing::ext::TestSize.Level1)
577{
578    Options options;
579    std::string mode = SIGN_PROFILE_MODE;
580    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
581    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
582    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
583    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
584    std::string outFile = SIGN_PROFILE_OUT_FILE;
585    std::string inFile = SIGN_PROFILE_IN_FILE;
586    char keyStorePwd[] = "123456";
587    char keypwd[] = "123456";
588    options[Options::KEY_ALIAS] = keyAlias;
589    options[Options::MODE] = mode;
590    options[Options::PROFILE_CERT_FILE] = profileCertFile;
591    options[Options::SIGN_ALG] = signAlg;
592    options[Options::KEY_STORE_FILE] = keystoreFile;
593    options[Options::OUT_FILE] = outFile;
594    options[Options::IN_FILE] = inFile;
595    options[Options::KEY_RIGHTS] = keypwd;
596    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
597
598    LocalizationAdapter adapter(&options);
599    SignerFactory factory;
600    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
601    STACK_OF(X509)* certs = signer->GetCertificates();
602    EXPECT_TRUE(certs != NULL);
603}
604
605/**
606    * @tc.name: generate_signeddata_test001
607    * @tc.desc: Test function of BCSignedDataGenerator::GenerateSignedData() interface for SUCCESS .set ownerid and
608    * @tc.size: MEDIUM
609    * @tc.type: FUNC
610    * @tc.level Level 1
611    * @tc.require: SR000H63TL
612    */
613HWTEST_F(SignProfileTest, generate_signeddata_test001, testing::ext::TestSize.Level1)
614{
615    Options options;
616    options[Options::MODE] = SIGN_APP_MODE;
617    options[Options::KEY_ALIAS] = SIGN_APP_KEY_ALIAS;
618    options[Options::APP_CERT_FILE] = SIGN_APP_APP_CERT_FILE;
619    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
620    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
621    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
622    options[Options::KEY_STORE_FILE] = SIGN_APP_KEY_STORE_FILE;
623    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
624    char keyStorePwd[] = "123456";
625    char keypwd[] = "123456";
626    options[Options::KEY_RIGHTS] = keyStorePwd;
627    options[Options::KEY_STORE_RIGHTS] = keypwd;
628
629    // config设置算法 signer
630    SignerConfig config;
631    config.SetOptions(&options);
632    SignatureAlgorithmHelper algClass;
633    std::vector<SignatureAlgorithmHelper> sigs;
634    sigs.resize(1);
635    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA256;
636    config.SetSignatureAlgorithms(sigs);
637
638    std::string content = "digest content";
639    std::string signedData;
640    std::shared_ptr<BCSignedDataGenerator> signedDataGenerator =
641        std::make_shared<BCSignedDataGenerator>();
642    signedDataGenerator->SetOwnerId(OWNERID_OID);
643    int result = signedDataGenerator->GenerateSignedData(content, &config, signedData);
644    EXPECT_EQ(result, 0);
645}
646
647/**
648    * @tc.name: generate_signeddata_test002
649    * @tc.desc: Test function of BCPkcs7Generator::GenerateSignedData() interface for SUCCESS
650    * @tc.size: MEDIUM
651    * @tc.type: FUNC
652    * @tc.level Level 1
653    * @tc.require: SR000H63TL
654    */
655HWTEST_F(SignProfileTest, generate_signeddata_test002, testing::ext::TestSize.Level1)
656{
657    Options options;
658    options[Options::MODE] = SIGN_APP_MODE;
659    options[Options::KEY_ALIAS] = SIGN_APP_KEY_ALIAS;
660    options[Options::APP_CERT_FILE] = SIGN_APP_APP_CERT_FILE;
661    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
662    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
663    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
664    options[Options::KEY_STORE_FILE] = SIGN_APP_KEY_STORE_FILE;
665    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
666    char keyStorePwd[] = "123456";
667    char keypwd[] = "123456";
668    options[Options::KEY_RIGHTS] = keyStorePwd;
669    options[Options::KEY_STORE_RIGHTS] = keypwd;
670
671    // config设置算法 signer
672    SignerConfig config;
673    config.SetOptions(&options);
674    SignatureAlgorithmHelper algClass;
675    std::vector<SignatureAlgorithmHelper> sigs;
676    sigs.resize(1);
677    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA256;
678    config.SetSignatureAlgorithms(sigs);
679
680    std::string content = "digest content";
681    std::string signedData;
682    std::shared_ptr<Pkcs7Generator> pkcs7Generator = std::make_shared<BCPkcs7Generator>();
683    int result = pkcs7Generator->GenerateSignedData(content, &config, signedData);
684    EXPECT_EQ(result, 0);
685}
686/**
687    * @tc.name: run_sign_app_test001
688    * @tc.desc: Test function of HapSignTool::RunSignApp() interface for SUCCESS.
689    * @tc.size: MEDIUM
690    * @tc.type: FUNC
691    * @tc.level Level 1
692    * @tc.require: SR000H63TL
693*/
694HWTEST_F(SignProfileTest, run_sign_app_test001, testing::ext::TestSize.Level1)
695{
696    std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
697    std::shared_ptr<Options> params = std::make_shared<Options>();
698
699    char keyPwd[] = "123456";
700    char keystorePwd[] = "123456";
701
702    (*params)["mode"] = SIGN_APP_MODE;
703    (*params)["keyAlias"] = SIGN_APP_KEY_ALIAS;
704    (*params)["signAlg"] = SIGN_APP_SIGN_ALG;
705    (*params)["appCertFile"] = SIGN_APP_APP_CERT_FILE;
706    (*params)["profileFile"] = SIGN_APP_PROFILE_FILE;
707    (*params)["inFile"] = SIGN_APP_IN_FILE;
708    (*params)["keystoreFile"] = SIGN_APP_KEY_STORE_FILE;
709    (*params)["outFile"] = SIGN_APP_OUT_FILE;
710    (*params)["keyPwd"] = keyPwd;
711    (*params)["keystorePwd"] = keystorePwd;
712    (*params)["inForm"] = std::string("zip");
713    (*params)["profileSigned"] = std::string("1");
714    (*params)["signCode"] = std::string("1");
715
716    bool ret = ParamsRunTool::RunSignApp(params.get(), *api);
717    EXPECT_EQ(ret, true);
718}
719
720
721/**
722    * @tc.name: run_sign_app_test002
723    * @tc.desc: Test function of HapSignTool::RunSignApp() interface for SUCCESS.
724    * @tc.size: MEDIUM
725    * @tc.type: FUNC
726    * @tc.level Level 1
727    * @tc.require: SR000H63TL
728*/
729HWTEST_F(SignProfileTest, run_sign_app_test002, testing::ext::TestSize.Level1)
730{
731    std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
732    std::shared_ptr<Options> params = std::make_shared<Options>();
733
734    char keyPwd[] = "123456";
735    char keystorePwd[] = "123456";
736
737    (*params)["mode"] = SIGN_APP_MODE;
738    (*params)["keyAlias"] = SIGN_APP_KEY_ALIAS;
739    (*params)["signAlg"] = SIGN_APP_SIGN_ALG;
740    (*params)["appCertFile"] = SIGN_APP_APP_CERT_FILE;
741    (*params)["profileFile"] = SIGN_APP_PROFILE_FILE;
742    (*params)["inFile"] = SIGN_APP_IN_FILE;
743    (*params)["keystoreFile"] = SIGN_APP_KEY_STORE_FILE;
744    (*params)["outFile"] = SIGN_APP_OUT_FILE;
745    (*params)["keyPwd"] = keyPwd;
746    (*params)["keystorePwd"] = keystorePwd;
747    (*params)["inForm"] = std::string("zip");
748    (*params)["profileSigned"] = std::string("0");
749    (*params)["signCode"] = std::string("0");
750
751    bool ret = ParamsRunTool::RunSignApp(params.get(), *api);
752    EXPECT_EQ(ret, false);
753}
754
755}
756}