1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <cstring>
17#include <gtest/gtest.h>
18#include <iostream>
19#include <memory>
20#include "log.h"
21#include "pkg_algo_deflate.h"
22#include "pkg_algo_lz4.h"
23#include "pkg_algorithm.h"
24#include "pkg_algo_sign.h"
25#include "pkg_manager.h"
26#include "pkg_test.h"
27
28using namespace std;
29using namespace Hpackage;
30using namespace Updater;
31using namespace testing::ext;
32
33namespace UpdaterUt {
34constexpr size_t BUFFER_LEN = 10;
35class PkgAlgoUnitTest : public PkgTest {
36public:
37    PkgAlgoUnitTest() {}
38    ~PkgAlgoUnitTest() override {}
39
40    int TestCrcDigest() const
41    {
42        std::unique_ptr<Crc32Algorithm> algo = std::make_unique<Crc32Algorithm>();
43        EXPECT_NE(algo, nullptr);
44        int ret = algo->Init();
45        EXPECT_EQ(0, ret);
46        uint8_t buff[BUFFER_LEN] = {1};
47        PkgBuffer crcBuffer(buff, sizeof(buff));
48        ret = algo->Update(crcBuffer, sizeof(buff));
49        EXPECT_EQ(0, ret);
50        uint32_t crc = 0;
51        PkgBuffer crcResult(reinterpret_cast<uint8_t *>(&crc), sizeof(crc));
52        ret = algo->Final(crcResult);
53        EXPECT_EQ(0, ret);
54
55        uint32_t crc2 = 0;
56        crcResult = {reinterpret_cast<uint8_t *>(&crc2), sizeof(crc)};
57        ret = algo->Calculate(crcResult, crcBuffer, sizeof(buff));
58        EXPECT_EQ(0, ret);
59        EXPECT_EQ(crc, crc2);
60        return ret;
61    }
62
63    int TestHash256Digest() const
64    {
65        std::unique_ptr<Sha256Algorithm> algo = std::make_unique<Sha256Algorithm>();
66        EXPECT_NE(algo, nullptr);
67        int ret = algo->Init();
68        EXPECT_EQ(0, ret);
69        uint8_t buff[BUFFER_LEN] = {1};
70        PkgBuffer buffer(buff, sizeof(buff));
71        ret = algo->Update(buffer, sizeof(buff));
72        EXPECT_EQ(0, ret);
73        size_t bufferSize = 32;
74        PkgBuffer dig(bufferSize);
75        ret = algo->Final(dig);
76        EXPECT_EQ(0, ret);
77        ret = algo->Calculate(dig, buffer, sizeof(buff));
78        EXPECT_EQ(0, ret);
79        return ret;
80    }
81
82    int TestHash384Digest() const
83    {
84        std::unique_ptr<Sha384Algorithm> algo = std::make_unique<Sha384Algorithm>();
85        EXPECT_NE(algo, nullptr);
86        int ret = algo->Init();
87        EXPECT_EQ(0, ret);
88        uint8_t buff[BUFFER_LEN] = {1};
89        PkgBuffer buffer384(buff, sizeof(buff));
90        ret = algo->Update(buffer384, sizeof(buff));
91        EXPECT_EQ(0, ret);
92        size_t bufferSize = 64;
93        PkgBuffer dig(bufferSize);
94        ret = algo->Final(dig);
95        EXPECT_EQ(0, ret);
96        ret = algo->Calculate(dig, buffer384, sizeof(buff));
97        EXPECT_EQ(0, ret);
98        return ret;
99    }
100
101    int TestInvalidParam() const
102    {
103        constexpr int8_t invalidType = 100;
104        constexpr size_t digestLen = 32;
105        constexpr int16_t magicNumber = 256;
106        int ret = DigestAlgorithm::GetDigestLen(invalidType);
107        EXPECT_EQ(0, ret);
108        ret = DigestAlgorithm::GetSignatureLen(invalidType);
109        EXPECT_EQ(magicNumber, ret);
110
111        DigestAlgorithm::DigestAlgorithmPtr algorithm = PkgAlgorithmFactory::GetDigestAlgorithm(invalidType);
112        EXPECT_NE(nullptr, algorithm);
113        algorithm->Init();
114        uint8_t dig2[digestLen];
115        PkgBuffer buffer(dig2, sizeof(dig2));
116        algorithm->Update(buffer, sizeof(dig2));
117        algorithm->Final(buffer);
118
119        SignAlgorithm::SignAlgorithmPtr sign = PkgAlgorithmFactory::GetSignAlgorithm(TEST_PATH_FROM, invalidType, 0);
120        EXPECT_EQ(nullptr, sign);
121
122        PkgAlgorithm::PkgAlgorithmPtr algo = PkgAlgorithmFactory::GetAlgorithm(nullptr);
123        EXPECT_EQ(nullptr, algo);
124        FileInfo config;
125        config.packMethod = invalidType;
126        algo = PkgAlgorithmFactory::GetAlgorithm(nullptr);
127        EXPECT_EQ(nullptr, algo);
128        EXPECT_EQ(nullptr, sign);
129
130        return 0;
131    }
132
133private:
134    std::string testPackageName = "test_ecc_package.zip";
135    std::vector<std::string> testFileNames_ = {
136        "loadScript.us",
137        "registerCmd.us",
138        "test_function.us",
139        "test_if.us",
140        "test_logic.us",
141        "test_math.us",
142        "test_native.us",
143        "testscript.us",
144        "Verse-script.us",
145        "libcrypto.a"
146    };
147};
148
149HWTEST_F(PkgAlgoUnitTest, TestHash256Digest, TestSize.Level1)
150{
151    PkgAlgoUnitTest test;
152    EXPECT_EQ(0, test.TestCrcDigest());
153    EXPECT_EQ(0, test.TestHash256Digest());
154    EXPECT_EQ(0, test.TestHash384Digest());
155}
156
157HWTEST_F(PkgAlgoUnitTest, TestInvalid, TestSize.Level1)
158{
159    PkgAlgoUnitTest test;
160    EXPECT_EQ(0, test.TestInvalidParam());
161}
162
163HWTEST_F(PkgAlgoUnitTest, TestPkgAlgoDeflate, TestSize.Level1)
164{
165    ZipFileInfo info {};
166    PkgAlgoDeflate a1(info);
167    Lz4FileInfo config {};
168    PkgAlgorithmLz4 a2(config);
169    PkgAlgorithmBlockLz4 a3(config);
170    VerifyAlgorithm a4("aa", 0);
171    SignAlgorithmRsa a5("bb", 0);
172    SignAlgorithmEcc a6("cc", 0);
173    // just for executing these destructor
174    PkgAlgoDeflate *a7 = new PkgAlgoDeflate(info);
175    delete a7;
176    PkgAlgorithmLz4 *a8 = new PkgAlgorithmLz4(config);
177    delete a8;
178    PkgAlgorithmBlockLz4 *a9 = new PkgAlgorithmBlockLz4(config);
179    delete a9;
180    VerifyAlgorithm *a10 = new VerifyAlgorithm("aa", 0);
181    delete a10;
182    SignAlgorithmRsa *a11 = new SignAlgorithmRsa("bb", 0);
183    delete a11;
184    SignAlgorithmEcc *a12 = new SignAlgorithmEcc("cc", 0);
185    std::vector<uint8_t> b1;
186    std::vector<uint8_t> b2;
187    int32_t ret = a12->VerifyDigest(b1, b2);
188    delete a12;
189    EXPECT_EQ(ret, PKG_INVALID_SIGNATURE);
190}
191}
192