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 
35 using  nlohmann::json;
36 
37 namespace OHOS {
38 namespace SignatureTools {
39 
40 // sign profile使用的全局参数
41 static const std::string SIGN_PROFILE_MODE = "localSign";
42 static const std::string SIGN_PROFILE_KEY_ALIAS = "oh-profile1-key-v1";
43 static const std::string SIGN_PROFILE_PROFILE_CERT_FILE = "./signProfile/profile-release1.pem";
44 static const std::string SIGN_PROFILE_SIGN_ALG = "SHA384withECDSA";
45 static const std::string SIGN_PROFILE_KEY_STORE_FILE = "./signProfile/ohtest.p12";
46 static const std::string SIGN_PROFILE_OUT_FILE = "./signProfile/signed-profile.p7b";
47 static const std::string SIGN_PROFILE_IN_FILE = "./signProfile/profile.json";
48 // verify profile 使用的全局参数
49 static const std::string VERIFY_PROFILE_IN_FILE = "./signProfile/signed-profile.p7b";
50 static const std::string VERIFY_PROFILE_OUT_FILE = "./signProfile/VerifyResult.json";
51 // sign app 使用全局参数
52 static const std::string SIGN_APP_MODE = "localSign";
53 static const std::string SIGN_APP_KEY_ALIAS = "oh-app1-key-v1";
54 static const std::string SIGN_APP_APP_CERT_FILE = "./signProfile/app-release1.pem";
55 static const std::string SIGN_APP_PROFILE_FILE = "./signProfile/signed-profile.p7b";
56 static const std::string SIGN_APP_IN_FILE = "./signProfile/unsigned.hap";
57 static const std::string SIGN_APP_IN_FILE_TXT = "./signProfile/unsigned.txt";
58 static const std::string SIGN_APP_SIGN_ALG = "SHA256withECDSA";
59 static const std::string SIGN_APP_KEY_STORE_FILE = "./signProfile/ohtest.p12";
60 static const std::string SIGN_APP_OUT_FILE = "./signProfile/signed.hap";
61 
62 class SignProfileTest : public testing::Test {
63 public:
64     static void SetUpTestCase(void);
65 
66     static void TearDownTestCase(void);
67 
68     void SetUp()override;
69 
70     void TearDown()override;
71 };
72 
SetUpTestCase(void)73 void SignProfileTest::SetUpTestCase(void)
74 {
75     std::filesystem::copy(SIGN_APP_IN_FILE_TXT, SIGN_APP_IN_FILE);
76 }
77 
TearDownTestCase(void)78 void SignProfileTest::TearDownTestCase(void)
79 {
80     std::filesystem::remove(SIGN_APP_IN_FILE);
81 }
82 
SetUp()83 void SignProfileTest::SetUp()
84 {
85 }
86 
TearDown()87 void 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     */
HWTEST_F(SignProfileTest, run_sign_profile_test001, testing::ext::TestSize.Level1)99 HWTEST_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     */
HWTEST_F(SignProfileTest, sign_profile_test001, testing::ext::TestSize.Level1)135 HWTEST_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     */
HWTEST_F(SignProfileTest, get_provision_content_test001, testing::ext::TestSize.Level1)186 HWTEST_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 */
HWTEST_F(SignProfileTest, parse_provision_test001, testing::ext::TestSize.Level1)202 HWTEST_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     */
HWTEST_F(SignProfileTest, generate_p7b_test001, testing::ext::TestSize.Level1)219 HWTEST_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     */
HWTEST_F(SignProfileTest, print_cert_chain_sub_test001, testing::ext::TestSize.Level1)255 HWTEST_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 */
HWTEST_F(SignProfileTest, run_verify_profile_test001, testing::ext::TestSize.Level1)294 HWTEST_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 */
HWTEST_F(SignProfileTest, verify_profile_test001, testing::ext::TestSize.Level1)312 HWTEST_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     */
HWTEST_F(SignProfileTest, verify_profile_test002, testing::ext::TestSize.Level1)332 HWTEST_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 */
HWTEST_F(SignProfileTest, parse_test001, testing::ext::TestSize.Level1)351 HWTEST_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     */
HWTEST_F(SignProfileTest, parse_test002, testing::ext::TestSize.Level1)368 HWTEST_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     */
HWTEST_F(SignProfileTest, sign_test001, testing::ext::TestSize.Level1)386 HWTEST_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     */
HWTEST_F(SignProfileTest, sign_test002, testing::ext::TestSize.Level1)426 HWTEST_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     */
HWTEST_F(SignProfileTest, verify_test001, testing::ext::TestSize.Level1)466 HWTEST_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     */
HWTEST_F(SignProfileTest, get_original_raw_data_test001, testing::ext::TestSize.Level1)484 HWTEST_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     */
HWTEST_F(SignProfileTest, get_signer_test001, testing::ext::TestSize.Level1)503 HWTEST_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     */
HWTEST_F(SignProfileTest, get_crls_test001, testing::ext::TestSize.Level1)539 HWTEST_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     */
HWTEST_F(SignProfileTest, get_certificates_test001, testing::ext::TestSize.Level1)576 HWTEST_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     */
HWTEST_F(SignProfileTest, generate_signeddata_test001, testing::ext::TestSize.Level1)613 HWTEST_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     */
HWTEST_F(SignProfileTest, generate_signeddata_test002, testing::ext::TestSize.Level1)655 HWTEST_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 */
HWTEST_F(SignProfileTest, run_sign_app_test001, testing::ext::TestSize.Level1)694 HWTEST_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 */
HWTEST_F(SignProfileTest, run_sign_app_test002, testing::ext::TestSize.Level1)729 HWTEST_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 }