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#include "cms_utils.h"
35
36using  nlohmann::json;
37
38namespace OHOS {
39namespace SignatureTools {
40
41// sign profile使用的全局参数
42static const std::string SIGN_PROFILE_MODE = "localSign";
43static const std::string SIGN_PROFILE_KEY_ALIAS = "oh-profile1-key-v1";
44static const std::string SIGN_PROFILE_PROFILE_CERT_FILE = "./signProfile/profile-release1.pem";
45static const std::string SIGN_PROFILE_SIGN_ALG = "SHA384withECDSA";
46static const std::string SIGN_PROFILE_KEY_STORE_FILE = "./signProfile/ohtest.p12";
47static const std::string SIGN_PROFILE_OUT_FILE = "./signProfile/signed-profile.p7b";
48static const std::string SIGN_PROFILE_IN_FILE = "./signProfile/profile.json";
49
50static const std::string SIGN_PROFILE_CERT_PEM = "./signProfile/profile-release1-cert.pem";
51static const std::string SIGN_PROFILE_REVERSE_PEM = "./signProfile/profile-release1-reverse.pem";
52static const std::string SIGN_PROFILE_DOUBLE_CERT_PEM = "./signProfile/profile-release1-invalid_cert_chain.pem";
53static const std::string SIGN_PROFILE_TMP_P7B = "./signProfile/tmp.p7b";
54
55// verify profile 使用的全局参数
56static const std::string VERIFY_PROFILE_IN_FILE = "./signProfile/app1-profile1.p7b";
57static const std::string VERIFY_PROFILE_OUT_FILE = "./signProfile/VerifyResult.json";
58// sign app 使用全局参数
59static const std::string SIGN_APP_MODE = "localSign";
60static const std::string SIGN_APP_KEY_ALIAS = "oh-app1-key-v1";
61static const std::string SIGN_APP_APP_CERT_FILE = "./signProfile/app-release1.pem";
62static const std::string SIGN_APP_PROFILE_FILE = "./signProfile/app1-profile1.p7b";
63static const std::string SIGN_APP_IN_FILE = "./signProfile/unsigned.hap";
64static const std::string SIGN_APP_IN_FILE_TXT = "./signProfile/unsigned.txt";
65static const std::string SIGN_APP_SIGN_ALG = "SHA256withECDSA";
66static const std::string SIGN_APP_KEY_STORE_FILE = "./signProfile/ohtest.p12";
67static const std::string SIGN_APP_OUT_FILE = "./signProfile/signed.hap";
68
69class ProfileTest : public testing::Test {
70public:
71    static void SetUpTestCase(void);
72    static void TearDownTestCase(void);
73    void SetUp()override;
74    void TearDown()override;
75};
76void ProfileTest::SetUpTestCase(void)
77{
78    std::filesystem::copy(SIGN_APP_IN_FILE_TXT, SIGN_APP_IN_FILE);
79}
80
81void ProfileTest::TearDownTestCase(void)
82{
83    std::filesystem::remove(SIGN_APP_IN_FILE);
84}
85
86void ProfileTest::SetUp()
87{
88}
89
90void ProfileTest::TearDown()
91{
92}
93
94/**
95 * @tc.name: profile_test004
96 * @tc.desc: Test function of Pkcs7Generator::GenerateSignedData() failed for empty content.
97 * @tc.size: MEDIUM
98 * @tc.type: FUNC
99 * @tc.level Level 1
100 * @tc.require: SR000H63TL
101 */
102HWTEST_F(ProfileTest, profile_test004, testing::ext::TestSize.Level1)
103{
104    std::string content;
105    SignerConfig* config = nullptr;
106    std::string ret;
107    std::shared_ptr<Pkcs7Generator> generator = std::make_shared<BCPkcs7Generator>();
108    int result = generator->GenerateSignedData(content, config, ret);
109    EXPECT_TRUE(result <= 0);
110}
111
112/**
113 * @tc.name: profile_test005
114 * @tc.desc: Test function of Pkcs7Generator::GenerateSignedData() failed for nullptr config.
115 * @tc.size: MEDIUM
116 * @tc.type: FUNC
117 * @tc.level Level 1
118 * @tc.require: SR000H63TL
119 */
120HWTEST_F(ProfileTest, profile_test005, testing::ext::TestSize.Level1)
121{
122    std::string content = "hello,world";
123    SignerConfig* config = nullptr;
124    std::string ret;
125    std::shared_ptr<Pkcs7Generator> generator = std::make_shared<BCPkcs7Generator>();
126    int result = generator->GenerateSignedData(content, config, ret);
127    EXPECT_TRUE(result <= 0);
128}
129
130/**
131 * @tc.name: profile_test006
132 * @tc.desc: Test function of Pkcs7Generator::GenerateSignedData() failed for nullptr signer.
133 * @tc.size: MEDIUM
134 * @tc.type: FUNC
135 * @tc.level Level 1
136 * @tc.require: SR000H63TL
137 */
138HWTEST_F(ProfileTest, profile_test006, testing::ext::TestSize.Level1)
139{
140    Options options;
141    options[Options::MODE] = SIGN_APP_MODE;
142    options[Options::KEY_ALIAS] = SIGN_APP_KEY_ALIAS;
143    options[Options::APP_CERT_FILE] = SIGN_APP_APP_CERT_FILE;
144    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
145    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
146    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
147    options[Options::KEY_STORE_FILE] = "";
148    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
149    char keyStorePwd[] = "123456";
150    char keypwd[] = "123456";
151    options[Options::KEY_RIGHTS] = keyStorePwd;
152    options[Options::KEY_STORE_RIGHTS] = keypwd;
153
154    // config设置算法 signer
155    SignerConfig config;
156    config.SetOptions(&options);
157    SignatureAlgorithmHelper algClass;
158    std::vector<SignatureAlgorithmHelper> sigs;
159    sigs.resize(1);
160    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA256;
161    config.SetSignatureAlgorithms(sigs);
162
163    std::string content = "digest content";
164    std::string signedData;
165    std::shared_ptr<Pkcs7Generator> pkcs7Generator = std::make_shared<BCPkcs7Generator>();
166    int result = pkcs7Generator->GenerateSignedData(content, &config, signedData);
167    EXPECT_TRUE(result < 0);
168}
169
170/**
171 * @tc.name: profile_test007
172 * @tc.desc: Test function of Pkcs7Generator::GenerateSignedData() failed for generate pkcs7 block.
173 * @tc.size: MEDIUM
174 * @tc.type: FUNC
175 * @tc.level Level 1
176 * @tc.require: SR000H63TL
177 */
178HWTEST_F(ProfileTest, profile_test007, testing::ext::TestSize.Level1)
179{
180    Options options;
181    options[Options::MODE] = SIGN_APP_MODE;
182    options[Options::KEY_ALIAS] = SIGN_APP_KEY_ALIAS;
183    options[Options::APP_CERT_FILE] = SIGN_APP_APP_CERT_FILE;
184    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
185    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
186    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
187    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
188    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
189    char keyStorePwd[] = "123456";
190    char keypwd[] = "123456";
191    options[Options::KEY_RIGHTS] = keyStorePwd;
192    options[Options::KEY_STORE_RIGHTS] = keypwd;
193
194    // config设置算法 signer
195    SignerConfig config;
196    config.SetOptions(&options);
197    SignatureAlgorithmHelper algClass;
198    std::vector<SignatureAlgorithmHelper> sigs;
199    sigs.resize(1);
200    sigs[0].m_id = SignatureAlgorithmId::DSA_WITH_SHA512;
201    config.SetSignatureAlgorithms(sigs);
202
203    std::string content = "digest content";
204    std::string signedData;
205    std::shared_ptr<Pkcs7Generator> pkcs7Generator = std::make_shared<BCPkcs7Generator>();
206    int result = pkcs7Generator->GenerateSignedData(content, &config, signedData);
207    EXPECT_TRUE(result < 0);
208}
209
210/**
211 * @tc.name: profile_test008
212 * @tc.desc: Test function of Pkcs7Generator::GenerateSignedData() failed for invalid certchain.
213 * @tc.size: MEDIUM
214 * @tc.type: FUNC
215 * @tc.level Level 1
216 * @tc.require: SR000H63TL
217 */
218HWTEST_F(ProfileTest, profile_test008, testing::ext::TestSize.Level1)
219{
220    Options options;
221    options[Options::MODE] = SIGN_APP_MODE;
222    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
223    options[Options::APP_CERT_FILE] = SIGN_PROFILE_DOUBLE_CERT_PEM;
224    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
225    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
226    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
227    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
228    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
229    char keyStorePwd[] = "123456";
230    char keypwd[] = "123456";
231    options[Options::KEY_RIGHTS] = keyStorePwd;
232    options[Options::KEY_STORE_RIGHTS] = keypwd;
233
234    // config设置算法 signer
235    SignerConfig config;
236    config.SetOptions(&options);
237    SignatureAlgorithmHelper algClass;
238    std::vector<SignatureAlgorithmHelper> sigs;
239    sigs.resize(1);
240    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA256;
241    config.SetSignatureAlgorithms(sigs);
242
243    std::string content = "digest content";
244    std::string signedData;
245    std::shared_ptr<Pkcs7Generator> pkcs7Generator = std::make_shared<BCPkcs7Generator>();
246    int result = pkcs7Generator->GenerateSignedData(content, &config, signedData);
247    EXPECT_TRUE(result < 0);
248}
249
250/**
251 * @tc.name: profile_test009
252 * @tc.desc: Test function of SignedDataGenerator::GenerateSignedData() failed for invalid sigAlg.
253 * @tc.size: MEDIUM
254 * @tc.type: FUNC
255 * @tc.level Level 1
256 * @tc.require: SR000H63TL
257 */
258HWTEST_F(ProfileTest, profile_test009, testing::ext::TestSize.Level1)
259{
260    Options options;
261    options[Options::MODE] = SIGN_APP_MODE;
262    options[Options::KEY_ALIAS] = SIGN_APP_KEY_ALIAS;
263    options[Options::APP_CERT_FILE] = SIGN_APP_APP_CERT_FILE;
264    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
265    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
266    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
267    options[Options::KEY_STORE_FILE] = SIGN_APP_KEY_STORE_FILE;
268    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
269    char keyStorePwd[] = "123456";
270    char keypwd[] = "123456";
271    options[Options::KEY_RIGHTS] = keyStorePwd;
272    options[Options::KEY_STORE_RIGHTS] = keypwd;
273
274    // config设置算法 signer
275    SignerConfig config;
276    config.SetOptions(&options);
277    SignatureAlgorithmHelper algClass;
278    std::vector<SignatureAlgorithmHelper> sigs;
279    sigs.resize(1);
280    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA512;
281    config.SetSignatureAlgorithms(sigs);
282
283    std::string content = "digest content";
284    std::string signedData;
285    std::shared_ptr<BCSignedDataGenerator> signedDataGenerator =
286        std::make_shared<BCSignedDataGenerator>();
287    signedDataGenerator->SetOwnerId(OWNERID_OID);
288    int result = signedDataGenerator->GenerateSignedData(content, &config, signedData);
289    EXPECT_TRUE(result < 0);
290}
291
292/**
293 * @tc.name: profile_test010
294 * @tc.desc: Test function of SignedDataGenerator::GenerateSignedData() failed for invalid certchain.
295 * @tc.size: MEDIUM
296 * @tc.type: FUNC
297 * @tc.level Level 1
298 * @tc.require: SR000H63TL
299 */
300HWTEST_F(ProfileTest, profile_test010, testing::ext::TestSize.Level1)
301{
302    Options options;
303    options[Options::MODE] = SIGN_APP_MODE;
304    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
305    options[Options::APP_CERT_FILE] = SIGN_PROFILE_DOUBLE_CERT_PEM;
306    options[Options::PROFILE_FILE] = SIGN_APP_PROFILE_FILE;
307    options[Options::IN_FILE] = SIGN_APP_IN_FILE;
308    options[Options::SIGN_ALG] = SIGN_APP_SIGN_ALG;
309    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
310    options[Options::OUT_FILE] = SIGN_APP_OUT_FILE;
311    char keyStorePwd[] = "123456";
312    char keypwd[] = "123456";
313    options[Options::KEY_RIGHTS] = keyStorePwd;
314    options[Options::KEY_STORE_RIGHTS] = keypwd;
315
316    // config设置算法 signer
317    SignerConfig config;
318    config.SetOptions(&options);
319    SignatureAlgorithmHelper algClass;
320    std::vector<SignatureAlgorithmHelper> sigs;
321    sigs.resize(1);
322    sigs[0].m_id = SignatureAlgorithmId::ECDSA_WITH_SHA256;
323    config.SetSignatureAlgorithms(sigs);
324
325    std::string content = "digest content";
326    std::string signedData;
327    std::shared_ptr<BCSignedDataGenerator> signedDataGenerator =
328        std::make_shared<BCSignedDataGenerator>();
329    signedDataGenerator->SetOwnerId("ownerID str");
330    int result = signedDataGenerator->GenerateSignedData(content, &config, signedData);
331    EXPECT_TRUE(result < 0);
332}
333
334/**
335 * @tc.name: profile_test011
336 * @tc.desc: Test function of Pkcs7Data::Verify() failed for invalid certchain.
337 * @tc.size: MEDIUM
338 * @tc.type: FUNC
339 * @tc.level Level 1
340 * @tc.require: SR000H63TL
341 */
342HWTEST_F(ProfileTest, profile_test011, testing::ext::TestSize.Level1)
343{
344    std::string content = "signed content data";
345    Options options;
346    char keyStorePwd[] = "123456";
347    char keypwd[] = "123456";
348    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
349    options[Options::MODE] = SIGN_PROFILE_MODE;
350    options[Options::PROFILE_CERT_FILE] = SIGN_PROFILE_PROFILE_CERT_FILE;
351    options[Options::SIGN_ALG] = SIGN_PROFILE_SIGN_ALG;
352    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
353    options[Options::OUT_FILE] = SIGN_PROFILE_OUT_FILE;
354    options[Options::IN_FILE] = SIGN_PROFILE_IN_FILE;
355    options[Options::KEY_RIGHTS] = keypwd;
356    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
357
358    LocalizationAdapter adapter(&options);
359    SignerFactory factory;
360    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
361    PKCS7Data p7;
362    std::string p7b;
363    PKCS7* pkcs7 = nullptr;
364    int result = p7.Sign(content, signer, "SHA384withECDSA", p7b);
365    EXPECT_EQ(result, 0);
366    const unsigned char* p = reinterpret_cast<const unsigned char*>(p7b.data());
367    pkcs7 = d2i_PKCS7(nullptr, &p, static_cast<long>(p7b.size()));
368    STACK_OF(X509)* certs = pkcs7->d.sign->cert;
369    int num = 1;
370    while (sk_X509_num(certs) > num) {
371        X509* cert = sk_X509_delete(certs, sk_X509_num(certs) - 1);
372        X509_free(cert);
373    }
374    sk_X509_push(certs, sk_X509_value(certs, 0));
375    X509_up_ref(sk_X509_value(certs, 0));
376    unsigned char* out = nullptr;
377    int len = 0;
378    len = i2d_PKCS7(pkcs7, &out);
379    p7b.assign(out, out + len);
380    result = p7.Parse(p7b);
381    EXPECT_EQ(result, 0);
382    result = p7.Verify();
383    PKCS7_free(pkcs7);
384    EXPECT_TRUE(result < 0);
385}
386
387/**
388 * @tc.name: profile_test013
389 * @tc.desc: Test function of Pkcs7Data::Verify() failed for invalid certchain.
390 * @tc.size: MEDIUM
391 * @tc.type: FUNC
392 * @tc.level Level 1
393 * @tc.require: SR000H63TL
394 */
395HWTEST_F(ProfileTest, profile_test013, testing::ext::TestSize.Level1)
396{
397    std::string content = "signed content data";
398    Options options;
399    char keyStorePwd[] = "123456";
400    char keypwd[] = "123456";
401    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
402    options[Options::MODE] = SIGN_PROFILE_MODE;
403    options[Options::PROFILE_CERT_FILE] = SIGN_PROFILE_PROFILE_CERT_FILE;
404    options[Options::SIGN_ALG] = SIGN_PROFILE_SIGN_ALG;
405    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
406    options[Options::OUT_FILE] = SIGN_PROFILE_OUT_FILE;
407    options[Options::IN_FILE] = SIGN_PROFILE_IN_FILE;
408    options[Options::KEY_RIGHTS] = keypwd;
409    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
410
411    LocalizationAdapter adapter(&options);
412    SignerFactory factory;
413    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
414    PKCS7Data p7;
415    std::string p7b;
416    PKCS7* pkcs7 = nullptr;
417    int result = p7.Sign(content, signer, "SHA384withECDSA", p7b);
418    EXPECT_EQ(result, 0);
419    const unsigned char* p = reinterpret_cast<const unsigned char*>(p7b.data());
420    pkcs7 = d2i_PKCS7(nullptr, &p, static_cast<long>(p7b.size()));
421    STACK_OF(X509)* certs = pkcs7->d.sign->cert;
422    sk_X509_delete(certs, 2);
423    unsigned char* out = nullptr;
424    int len = 0;
425    len = i2d_PKCS7(pkcs7, &out);
426    p7b.assign(out, out + len);
427    result = p7.Parse(p7b);
428    EXPECT_EQ(result, 0);
429    result = p7.Verify();
430    PKCS7_free(pkcs7);
431    EXPECT_TRUE(result < 0);
432}
433
434/**
435 * @tc.name: profile_test014
436 * @tc.desc: Test function of Pkcs7Data::Verify() failed for invalid certchain.
437 * @tc.size: MEDIUM
438 * @tc.type: FUNC
439 * @tc.level Level 1
440 * @tc.require: SR000H63TL
441 */
442HWTEST_F(ProfileTest, profile_test014, testing::ext::TestSize.Level1)
443{
444    std::string content = "signed content data";
445    Options options;
446    char keyStorePwd[] = "123456";
447    char keypwd[] = "123456";
448    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
449    options[Options::MODE] = SIGN_PROFILE_MODE;
450    options[Options::PROFILE_CERT_FILE] = SIGN_PROFILE_PROFILE_CERT_FILE;
451    options[Options::SIGN_ALG] = SIGN_PROFILE_SIGN_ALG;
452    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
453    options[Options::OUT_FILE] = SIGN_PROFILE_OUT_FILE;
454    options[Options::IN_FILE] = SIGN_PROFILE_IN_FILE;
455    options[Options::KEY_RIGHTS] = keypwd;
456    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
457
458    LocalizationAdapter adapter(&options);
459    SignerFactory factory;
460    std::shared_ptr<Signer> signer = factory.GetSigner(adapter);
461    PKCS7Data p7;
462    std::string p7b;
463    PKCS7* pkcs7 = nullptr;
464    int result = p7.Sign(content, signer, "SHA384withECDSA", p7b);
465    EXPECT_EQ(result, 0);
466    const unsigned char* p = reinterpret_cast<const unsigned char*>(p7b.data());
467    pkcs7 = d2i_PKCS7(nullptr, &p, static_cast<long>(p7b.size()));
468    STACK_OF(X509)* certs = pkcs7->d.sign->cert;
469    sk_X509_delete(certs, 2);
470    sk_X509_push(certs, sk_X509_value(certs, 1));
471    X509_up_ref(sk_X509_value(certs, 1));
472    PKCS7Data::PrintCertChainSub(certs);
473    unsigned char* out = nullptr;
474    int len = 0;
475    len = i2d_PKCS7(pkcs7, &out);
476    p7b.assign(out, out + len);
477    result = p7.Parse(p7b);
478    PKCS7Data::PrintCertChainSub(certs);
479    EXPECT_EQ(result, 0);
480    result = p7.Verify();
481    PKCS7_free(pkcs7);
482    EXPECT_TRUE(result < 0);
483}
484
485/**
486 * @tc.name: profile_test015
487 * @tc.desc: Test function of Provision operator ==() interface .
488 * @tc.size: MEDIUM
489 * @tc.type: FUNC
490 * @tc.level Level 1
491 * @tc.require: SR000H63TL
492 */
493HWTEST_F(ProfileTest, profile_test015, testing::ext::TestSize.Level1)
494{
495    ProfileInfo* info = nullptr;
496    ProfileInfo info2;
497    info = &info2;
498    info2 = *info;
499    EXPECT_EQ(info2.profileBlockLength, info->profileBlockLength);
500}
501
502/**
503 * @tc.name: profile_test016
504 * @tc.desc: Test function of CmsUtils::VerifySignDataWithUnsignedDataDigest() failed for not matched unsigned data.
505 * @tc.size: MEDIUM
506 * @tc.type: FUNC
507 * @tc.level Level 1
508 * @tc.require: SR000H63TL
509 */
510HWTEST_F(ProfileTest, profile_test016, testing::ext::TestSize.Level1)
511{
512    Options options;
513    std::string mode = SIGN_PROFILE_MODE;
514    std::string keyAlias = SIGN_PROFILE_KEY_ALIAS;
515    std::string profileCertFile = SIGN_PROFILE_PROFILE_CERT_FILE;
516    std::string signAlg = SIGN_PROFILE_SIGN_ALG;
517    std::string keystoreFile = SIGN_PROFILE_KEY_STORE_FILE;
518    std::string outFile = SIGN_PROFILE_OUT_FILE;
519    std::string inFile = SIGN_PROFILE_IN_FILE;
520    char keyStorePwd[] = "123456";
521    char keypwd[] = "123456";
522    options[Options::KEY_ALIAS] = keyAlias;
523    options[Options::MODE] = mode;
524    options[Options::PROFILE_CERT_FILE] = profileCertFile;
525    options[Options::SIGN_ALG] = signAlg;
526    options[Options::KEY_STORE_FILE] = keystoreFile;
527    options[Options::OUT_FILE] = outFile;
528    options[Options::IN_FILE] = inFile;
529    options[Options::KEY_RIGHTS] = keypwd;
530    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
531
532    LocalizationAdapter adapter(&options);
533    std::string content = "json content";
534    std::string ret;
535    int result = ProfileSignTool::GenerateP7b(adapter, content, ret);
536    EXPECT_EQ(result, 0);
537    std::vector<int8_t> signedData(ret.begin(), ret.end());
538    std::string data = "hello,world";
539    std::vector<int8_t> unsignedData(data.begin(), data.end());
540    EXPECT_EQ(CmsUtils::VerifySignDataWithUnsignedDataDigest(unsignedData, signedData), false);
541}
542
543/**
544 * @tc.name: profile_test017
545 * @tc.desc: Test function of PKCS7Data::SortX509Stack() failed for cert count is 0.
546 * @tc.size: MEDIUM
547 * @tc.type: FUNC
548 * @tc.level Level 1
549 * @tc.require: SR000H63TL
550 */
551HWTEST_F(ProfileTest, test017, testing::ext::TestSize.Level1)
552{
553    STACK_OF(X509)* certs = sk_X509_new(nullptr);
554    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
555    sk_X509_free(certs);
556}
557
558/**
559 * @tc.name: profile_test019
560 * @tc.desc: Test function of PKCS7Data::PrintCertChainSub() interface for SUCCESS.
561 * @tc.size: MEDIUM
562 * @tc.type: FUNC
563 * @tc.level Level 1
564 * @tc.require: SR000H63TL
565 */
566HWTEST_F(ProfileTest, profile_test019, testing::ext::TestSize.Level1)
567{
568    STACK_OF(X509)* certs = nullptr;
569    PKCS7Data::PrintCertChainSub(certs);
570    EXPECT_EQ(certs, nullptr);
571}
572
573/**
574 * @tc.name: profile_test020
575 * @tc.desc: Test function of PKCS7Data::GetASN1Time() failed for nullptr asn1_time.
576 * @tc.size: MEDIUM
577 * @tc.type: FUNC
578 * @tc.level Level 1
579 * @tc.require: SR000H63TL
580 */
581HWTEST_F(ProfileTest, profile_test020, testing::ext::TestSize.Level1)
582{
583    ASN1_TIME* time = nullptr;
584    std::string result = PKCS7Data::GetASN1Time(time);
585    EXPECT_TRUE(result.empty());
586}
587
588/**
589 * @tc.name: profile_test021
590 * @tc.desc: Test function of PKCS7Data::SortX509Stack() failed for invalide certs.
591 * @tc.size: MEDIUM
592 * @tc.type: FUNC
593 * @tc.level Level 1
594 * @tc.require: SR000H63TL
595 */
596HWTEST_F(ProfileTest, profile_test021, testing::ext::TestSize.Level1)
597{
598    STACK_OF(X509)* certs = nullptr;
599    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
600}
601
602/**
603 * @tc.name: profile_test022
604 * @tc.desc: Test function of ParseProfile() interface for SUCCESS.
605 * @tc.size: MEDIUM
606 * @tc.type: FUNC
607 * @tc.level Level 1
608 * @tc.require: SR000H63TL
609 */
610HWTEST_F(ProfileTest, profile_test022, testing::ext::TestSize.Level1)
611{
612    std::string  provision = "{\"bundle-info\":{\"app-feature\":\"hos_system_app\",\"bundle-n"
613        "ame\":\"com.OpenHarmony.app.test\",\"developer-id\":\"OpenHarmony\",\"development-certi"
614        "ficate\":\"-----BEGIN CERTIFICATE-----\\n"
615        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
616        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
617        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
618        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
619        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
620        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
621        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
622        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
623        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
624        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
625        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
626        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
627        "-----END CERTIFICATE-----\\n"
628        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":[\"69C7505BE341BDA594"
629        "8C3C0CB44ABCD530296054159EFE0BD16A16CD0129CC42\",\"7EED06506FCE6325EB2E2FAA019458B856"
630        "AB10493A6718C7679A73F958732865\"]},\"issuer\":\"pki_internal\",\"permissions\":{\"rest"
631        "ricted-permissions\":[\"\"]},\"type\":\"debug\",\"uuid\":\"fe686e1b-3770-4824-a938-961"
632        "b140a7c98\",\"validity\":{\"not-after\":1705127532,\"not-before\":\"1610519532\"},\"ve"
633        "rsion-code\":1,\"version-name\":\"1.0.0\"}";
634    ProfileInfo info;
635    AppProvisionVerifyResult result = ParseProfile(provision, info);
636    EXPECT_EQ(result, AppProvisionVerifyResult::PROVISION_OK);
637}
638
639/**
640 * @tc.name: profile_test023
641 * @tc.desc: Test function of ParseProfile() interface for SUCCESS.
642 * @tc.size: MEDIUM
643 * @tc.type: FUNC
644 * @tc.level Level 1
645 * @tc.require: SR000H63TL
646 */
647HWTEST_F(ProfileTest, profile_test023, testing::ext::TestSize.Level1)
648{
649    std::string  provision = "{\"bundle-info\":{\"app-feature\":\"hos_system_app\",\"bundle-nam"
650        "e\":\"com.OpenHarmony.app.test\",\"developer-id\":\"OpenHarmony\",\"development-certi"
651        "ficate\":\"-----BEGIN CERTIFICATE-----\\n"
652        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
653        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
654        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
655        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
656        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
657        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
658        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
659        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
660        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
661        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
662        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
663        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
664        "-----END CERTIFICATE-----\\n"
665        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":[\"69C7505BE341BDA5948C"
666        "3C0CB44ABCD530296054159EFE0BD16A16CD0129CC42\",\"7EED06506FCE6325EB2E2FAA019458B856AB1"
667        "0493A6718C7679A73F958732865\"]},\"issuer\":\"pki_internal\",\"permissions\":{\"restric"
668        "ted-permissions\":[\"\"]},\"type\":\"debug\",\"uuid\":\"fe686e1b-3770-4824-a938-961b14"
669        "0a7c98\",\"validity\":{\"name\":\"weixing\"},\"version-code\":1,\"version-name\":\"1.0.0\"}";
670    ProfileInfo info;
671    AppProvisionVerifyResult result = ParseProfile(provision, info);
672    EXPECT_EQ(result, AppProvisionVerifyResult::PROVISION_OK);
673}
674
675/**
676 * @tc.name: profile_test024
677 * @tc.desc: Test function of ParseProvision() interface for SUCCESS.
678 * @tc.size: MEDIUM
679 * @tc.type: FUNC
680 * @tc.level Level 1
681 * @tc.require: SR000H63TL
682 */
683HWTEST_F(ProfileTest, profile_test024, testing::ext::TestSize.Level1)
684{
685    std::string  provision = "{\"app-distribution-type\": \"app_gallery\",\"bundle-info\":{\"app-"
686        "feature\":\"hos_system_app\",\"bundle-name\":\"com.OpenHarmony.app.test\",\"developer-id\":\"O"
687        "penHarmony\",\"distribution-certificate\":\"-----BEGIN CERTIFICATE-----\\n"
688        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
689        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
690        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
691        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
692        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
693        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
694        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
695        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
696        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
697        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
698        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
699        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
700        "-----END CERTIFICATE-----\\n"
701        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":[\"69C7505BE341BDA5948C3C0CB"
702        "44ABCD530296054159EFE0BD16A16CD0129CC42\",\"7EED06506FCE6325EB2E2FAA019458B856AB10493A6718C76"
703        "79A73F958732865\"]},\"issuer\":\"pki_internal\",\"permissions\":{\"restricted-permissions\":"
704        "[\"\"]},\"type\":\"release\",\"uuid\":\"fe686e1b-3770-4824-a938-961b140a7c98\",\"validity\":"
705        "{\"not-after\":1705127532,\"not-before\":1610519532},\"version-code\":1,\"version-name\":\"1.0.0\"}";
706    ProfileInfo info;
707    AppProvisionVerifyResult result = ParseProvision(provision, info);
708    EXPECT_EQ(result, AppProvisionVerifyResult::PROVISION_OK);
709}
710
711/**
712 * @tc.name: profile_test027
713 * @tc.desc: Test function of ParseProvision() interface for SUCCESS.
714 * @tc.size: MEDIUM
715 * @tc.type: FUNC
716 * @tc.level Level 1
717 * @tc.require: SR000H63TL
718 */
719HWTEST_F(ProfileTest, profile_test027, testing::ext::TestSize.Level1)
720{
721    std::string  provision = "{\"app-distribution-type\": \"app_gallery\","
722        "\"bundle-info\":{\"app-feature\":\"hos_system_app\",\"bundle-name\":"
723        "\"com.OpenHarmony.app.test\",\"developer-id\":\"OpenHarmony\","
724        "\"distribution-certificate\":\"-----BEGIN CERTIFICATE-----\\n"
725        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
726        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
727        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
728        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
729        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
730        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
731        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
732        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
733        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
734        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
735        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
736        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
737        "-----END CERTIFICATE-----\\n"
738        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":["
739        "\"69C7505BE341BDA5948C3C0CB44ABCD530296054159EFE0BD16A16CD0129CC42\","
740        "\"7EED06506FCE6325EB2E2FAA019458B856AB10493A6718C7679A73F958732865\"]},"
741        "\"issuer\":\"pki_internal\",\"permissions\":{\"restricted-permissions"
742        "\":[\"\"]},\"type\":\"release\",\"uuid\":\"\",\"validity\":{\"not-after"
743        "\":1705127532,\"not-before\":1610519532},\"version-code\":1,\"version-name\":\"1.0.0\"}";
744    ProfileInfo info;
745    AppProvisionVerifyResult result = ParseProvision(provision, info);
746    EXPECT_EQ(result, AppProvisionVerifyResult::PROVISION_OK);
747}
748
749/**
750 * @tc.name: profile_test028
751 * @tc.desc: Test function of ParseProvision() interface for SUCCESS.
752 * @tc.size: MEDIUM
753 * @tc.type: FUNC
754 * @tc.level Level 1
755 * @tc.require: SR000H63TL
756 */
757HWTEST_F(ProfileTest, profile_test028, testing::ext::TestSize.Level1)
758{
759    std::string  provision = "{\"app-distribution-type\": \"app_gallery\","
760        "\"bundle-info\":{\"app-feature\":\"hos_system_app\",\"bundle-name\":"
761        "\"com.OpenHarmony.app.test\",\"developer-id\":\"OpenHarmony\","
762        "\"distribution-certificate\":\"-----BEGIN CERTIFICATE-----\\n"
763        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
764        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
765        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
766        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
767        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
768        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
769        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
770        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
771        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
772        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
773        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
774        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
775        "-----END CERTIFICATE-----\\n"
776        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":["
777        "\"69C7505BE341BDA5948C3C0CB44ABCD530296054159EFE0BD16A16CD0129CC42\","
778        "\"7EED06506FCE6325EB2E2FAA019458B856AB10493A6718C7679A73F958732865\"]},"
779        "\"issuer\":\"pki_internal\",\"permissions\":{\"restricted-permissions"
780        "\":[\"\"]},\"type\":\"release\",\"uuid\":\"\",\"validity\":{\"not-after"
781        "\":1705127532,\"not-before\":1610519532},\"version-code\":1,\"version-name\":\"1.0.0\"}";
782    ProfileInfo info;
783    AppProvisionVerifyResult result = ParseProvision(provision, info);
784    EXPECT_EQ(result, AppProvisionVerifyResult::PROVISION_OK);
785}
786
787/**
788 * @tc.name: profile_test029
789 * @tc.desc: Test function of RunSignApp() failed for invalid json.
790 * @tc.size: MEDIUM
791 * @tc.type: FUNC
792 * @tc.level Level 1
793 * @tc.require: SR000H63TL
794 */
795HWTEST_F(ProfileTest, profile_test029, testing::ext::TestSize.Level1)
796{
797    std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
798    std::shared_ptr<Options> params = std::make_shared<Options>();
799    char keyPwd[] = "123456";
800    char keystorePwd[] = "123456";
801    std::string  provision = "{\"app-distribution-type\": \"app_gallery\",\"bundle-info\":{\"app-"
802        "feature\":\"hos_system_app\",\"bundle-name\":\"com.OpenHarmony.app.test\",\"developer-id\":\"O"
803        "penHarmony\",\"distribution-certificate\":\"-----BEGIN CERTIFICATE-----\\n"
804        "MIICMzCCAbegAwIBAgIEaOC/zDAMBggqhkjOPQQDAwUAMGMxCzAJBgNVBAYTAkNO\\n"
805        "MRQwEgYDVQQKEwtPcGVuSGFybW9ueTEZMBcGA1UECxMQT3Blbkhhcm1vbnkgVGVh\\n"
806        "bTEjMCEGA1UEAxMaT3Blbkhhcm1vbnkgQXBwbGljYXRpb24gQ0EwHhcNMjEwMjAy\\n"
807        "MTIxOTMxWhcNNDkxMjMxMTIxOTMxWjBoMQswCQYDVQQGEwJDTjEUMBIGA1UEChML\\n"
808        "T3Blbkhhcm1vbnkxGTAXBgNVBAsTEE9wZW5IYXJtb255IFRlYW0xKDAmBgNVBAMT\\n"
809        "H09wZW5IYXJtb255IEFwcGxpY2F0aW9uIFJlbGVhc2UwWTATBgcqhkjOPQIBBggq\\n"
810        "hkjOPQMBBwNCAATbYOCQQpW5fdkYHN45v0X3AHax12jPBdEDosFRIZ1eXmxOYzSG\\n"
811        "JwMfsHhUU90E8lI0TXYZnNmgM1sovubeQqATo1IwUDAfBgNVHSMEGDAWgBTbhrci\\n"
812        "FtULoUu33SV7ufEFfaItRzAOBgNVHQ8BAf8EBAMCB4AwHQYDVR0OBBYEFPtxruhl\\n"
813        "cRBQsJdwcZqLu9oNUVgaMAwGCCqGSM49BAMDBQADaAAwZQIxAJta0PQ2p4DIu/ps\\n"
814        "LMdLCDgQ5UH1l0B4PGhBlMgdi2zf8nk9spazEQI/0XNwpft8QAIwHSuA2WelVi/o\\n"
815        "zAlF08DnbJrOOtOnQq5wHOPlDYB4OtUzOYJk9scotrEnJxJzGsh/\\n"
816        "-----END CERTIFICATE-----\\n"
817        "\"},\"debug-info\":{\"device-id-type\":\"udid\",\"device-ids\":[\"69C7505BE341BDA5948C3C0CB"
818        "44ABCD530296054159EFE0BD16A16CD0129CC42\",\"7EED06506FCE6325EB2E2FAA019458B856AB10493A6718C76"
819        "79A73F958732865\"]},\"issuer\":\"pki_internal\",\"permissions\":{\"restricted-permissions\":"
820        "[\"\"]},\"type\":\"release\",\"uuid\":\"fe686e1b-3770-4824-a938-961b140a7c98\",\"validity\":"
821        "{\"not-after\":1705127532,\"not-before\":1610519532},\"version-code\":1,\"version-name\":\"1.0.0\"}";
822    FileUtils::Write(provision, VERIFY_PROFILE_OUT_FILE);
823    (*params)["mode"] = SIGN_APP_MODE;
824    (*params)["keyAlias"] = SIGN_APP_KEY_ALIAS;
825    (*params)["signAlg"] = SIGN_APP_SIGN_ALG;
826    (*params)["appCertFile"] = SIGN_APP_APP_CERT_FILE;
827    (*params)["profileFile"] = VERIFY_PROFILE_OUT_FILE;
828    (*params)["inFile"] = SIGN_APP_IN_FILE;
829    (*params)["keystoreFile"] = SIGN_APP_KEY_STORE_FILE;
830    (*params)["outFile"] = SIGN_APP_OUT_FILE;
831    (*params)["keyPwd"] = keyPwd;
832    (*params)["keystorePwd"] = keystorePwd;
833    (*params)["inForm"] = std::string("zip");
834    (*params)["profileSigned"] = std::string("0");
835    (*params)["signCode"] = std::string("0");
836
837    bool ret = ParamsRunTool::RunSignApp(params.get(), *api);
838    EXPECT_EQ(ret, true);
839}
840
841static void GenerateTmpP7b()
842{
843    Options options;
844    char keyStorePwd[] = "123456";
845    char keypwd[] = "123456";
846    options[Options::KEY_ALIAS] = SIGN_PROFILE_KEY_ALIAS;
847    options[Options::MODE] = SIGN_PROFILE_MODE;
848    options[Options::PROFILE_CERT_FILE] = SIGN_PROFILE_DOUBLE_CERT_PEM;
849    options[Options::SIGN_ALG] = SIGN_PROFILE_SIGN_ALG;
850    options[Options::KEY_STORE_FILE] = SIGN_PROFILE_KEY_STORE_FILE;
851    options[Options::OUT_FILE] = SIGN_PROFILE_OUT_FILE;
852    options[Options::IN_FILE] = SIGN_PROFILE_IN_FILE;
853    options[Options::KEY_RIGHTS] = keypwd;
854    options[Options::KEY_STORE_RIGHTS] = keyStorePwd;
855
856    LocalizationAdapter adapter(&options);
857    std::string  provision = "45";
858    std::string ret;
859    int result = ProfileSignTool::GenerateP7b(adapter, provision, ret);
860    FileUtils::Write(ret, SIGN_PROFILE_TMP_P7B);
861    EXPECT_TRUE(result < 0);
862}
863
864/**
865 * @tc.name: profile_test030
866 * @tc.desc: Test function of RunSignApp() failed for invalid p7b.
867 * @tc.size: MEDIUM
868 * @tc.type: FUNC
869 * @tc.level Level 1
870 * @tc.require: SR000H63TL
871 */
872HWTEST_F(ProfileTest, profile_test030, testing::ext::TestSize.Level1)
873{
874    GenerateTmpP7b();
875    std::unique_ptr<SignToolServiceImpl> api = std::make_unique<SignToolServiceImpl>();
876    std::shared_ptr<Options> params = std::make_shared<Options>();
877    char keyPwd[] = "123456";
878    char keystorePwd[] = "123456";
879    (*params)["mode"] = SIGN_APP_MODE;
880    (*params)["keyAlias"] = SIGN_APP_KEY_ALIAS;
881    (*params)["signAlg"] = SIGN_APP_SIGN_ALG;
882    (*params)["appCertFile"] = SIGN_APP_APP_CERT_FILE;
883    (*params)["profileFile"] = SIGN_PROFILE_TMP_P7B;
884    (*params)["inFile"] = SIGN_APP_IN_FILE;
885    (*params)["keystoreFile"] = SIGN_APP_KEY_STORE_FILE;
886    (*params)["outFile"] = SIGN_APP_OUT_FILE;
887    (*params)["keyPwd"] = keyPwd;
888    (*params)["keystorePwd"] = keystorePwd;
889    (*params)["inForm"] = std::string("zip");
890    (*params)["profileSigned"] = std::string("1");
891    (*params)["signCode"] = std::string("0");
892
893    bool ret = ParamsRunTool::RunSignApp(params.get(), *api);
894    EXPECT_FALSE(ret);
895}
896
897static STACK_OF(X509)* ReadCerts(const std::string& path)
898{
899    X509* cert = nullptr;
900    BIO* in = nullptr;
901    STACK_OF(X509)* certs = nullptr;
902    certs = sk_X509_new(nullptr);
903    if (certs == nullptr)
904        goto err;
905    in = BIO_new_file(path.c_str(), "rb");
906    if (in == nullptr)
907        goto err;
908    while ((cert = PEM_read_bio_X509(in, nullptr, nullptr, nullptr)))
909    {
910        sk_X509_push(certs, cert);
911    }
912    BIO_free(in);
913    return certs;
914err:
915    BIO_free(in);
916    sk_X509_pop_free(certs, X509_free);
917    return nullptr;
918}
919
920/**
921 * @tc.name: profile_test031
922 * @tc.desc: Test function of SortX509Stack() failed for invalid certchain.
923 * @tc.size: MEDIUM
924 * @tc.type: FUNC
925 * @tc.level Level 1
926 * @tc.require: SR000H63TL
927 */
928HWTEST_F(ProfileTest, profile_test031, testing::ext::TestSize.Level1)
929{
930    STACK_OF(X509)* certs = ReadCerts(SIGN_PROFILE_CERT_PEM);
931    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
932    sk_X509_pop_free(certs, X509_free);
933}
934
935/**
936 * @tc.name: profile_test032
937 * @tc.desc: Test function of SortX509Stack() failed for invalid certchain.
938 * @tc.size: MEDIUM
939 * @tc.type: FUNC
940 * @tc.level Level 1
941 * @tc.require: SR000H63TL
942 */
943HWTEST_F(ProfileTest, profile_test032, testing::ext::TestSize.Level1)
944{
945    STACK_OF(X509)* certs = ReadCerts(SIGN_PROFILE_PROFILE_CERT_FILE);
946    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) == 0);
947    X509* entityCert = sk_X509_value(certs, 0);
948    X509* entityCopy = X509_dup(entityCert);
949    X509* root = sk_X509_pop(certs);
950    X509* middle = sk_X509_pop(certs);
951    X509_free(root);
952    X509_free(middle);
953    sk_X509_insert(certs, entityCopy, 0);
954    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
955    sk_X509_pop_free(certs, X509_free);
956}
957
958/**
959 * @tc.name: profile_test033
960 * @tc.desc: Test function of SortX509Stack() failed for invalid certchain.
961 * @tc.size: MEDIUM
962 * @tc.type: FUNC
963 * @tc.level Level 1
964 * @tc.require: SR000H63TL
965 */
966HWTEST_F(ProfileTest, profile_test033, testing::ext::TestSize.Level1)
967{
968    STACK_OF(X509)* certs = ReadCerts(SIGN_PROFILE_PROFILE_CERT_FILE);
969    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) == 0);
970    X509* root = sk_X509_pop(certs);
971    X509_free(root);
972    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
973    sk_X509_pop_free(certs, X509_free);
974}
975
976/**
977 * @tc.name: profile_test030
978 * @tc.desc: Test function of SortX509Stack() interface failed for invalid certchain.
979 * @tc.size: MEDIUM
980 * @tc.type: FUNC
981 * @tc.level Level 1
982 * @tc.require: SR000H63TL
983 */
984HWTEST_F(ProfileTest, profile_test034, testing::ext::TestSize.Level1)
985{
986    STACK_OF(X509)* certs = ReadCerts(SIGN_PROFILE_PROFILE_CERT_FILE);
987    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) == 0);
988    X509* root = sk_X509_pop(certs);
989    X509* middle = sk_X509_pop(certs);
990    X509* entity = sk_X509_pop(certs);
991    X509_free(entity);
992    sk_X509_insert(certs, middle, 0);
993    sk_X509_insert(certs, X509_dup(middle), 0);
994    sk_X509_insert(certs, root, 0);
995    EXPECT_TRUE(PKCS7Data::SortX509Stack(certs) < 0);
996    sk_X509_pop_free(certs, X509_free);
997}
998}
999}
1000