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
28 using namespace std;
29 using namespace Hpackage;
30 using namespace Updater;
31 using namespace testing::ext;
32
33 namespace UpdaterUt {
34 constexpr size_t BUFFER_LEN = 10;
35 class PkgAlgoUnitTest : public PkgTest {
36 public:
PkgAlgoUnitTest()37 PkgAlgoUnitTest() {}
38 ~PkgAlgoUnitTest() override {}
39
TestCrcDigest() const40 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
TestHash256Digest() const63 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
TestHash384Digest() const82 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
TestInvalidParam() const101 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
133 private:
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
HWTEST_F(PkgAlgoUnitTest, TestHash256Digest, TestSize.Level1)149 HWTEST_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
HWTEST_F(PkgAlgoUnitTest, TestInvalid, TestSize.Level1)157 HWTEST_F(PkgAlgoUnitTest, TestInvalid, TestSize.Level1)
158 {
159 PkgAlgoUnitTest test;
160 EXPECT_EQ(0, test.TestInvalidParam());
161 }
162
HWTEST_F(PkgAlgoUnitTest, TestPkgAlgoDeflate, TestSize.Level1)163 HWTEST_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