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 <fcntl.h> 18 #include <functional> 19 #include <gtest/gtest.h> 20 #include <iostream> 21 #include <memory> 22 #include <sys/mman.h> 23 #include <sys/stat.h> 24 #include <unistd.h> 25 #include "log.h" 26 #include "pkg_algorithm.h" 27 #include "pkg_gzipfile.h" 28 #include "pkg_manager.h" 29 #include "pkg_manager_impl.h" 30 #include "pkg_test.h" 31 #include "pkg_utils.h" 32 #include "securec.h" 33 34 using namespace std; 35 using namespace Hpackage; 36 using namespace Updater; 37 using namespace testing::ext; 38 39 namespace UpdaterUt { 40 constexpr auto WINDOWBITS = -15; // 32kb window; negative to indicate a raw stream. 41 constexpr auto MEMLEVEL = 8; // the default value. 42 constexpr auto STRATEGY = Z_DEFAULT_STRATEGY; 43 constexpr uint16_t HEADER_CRC = 0x02; /* bit 1 set: CRC16 for the gzip header */ 44 constexpr uint16_t EXTRA_FIELD = 0x04; /* bit 2 set: extra field present */ 45 constexpr uint16_t ORIG_NAME = 0x08; /* bit 3 set: original file name present */ 46 constexpr uint16_t COMMENT = 0x10; /* bit 4 set: file comment present */ 47 constexpr uint32_t DEFAULT_LOCAK_DIGEST = 32; 48 constexpr uint32_t TEST_FILE_VERSION = 1000; 49 constexpr uint32_t TEST_DECOMPRESS_GZIP_OFFSET = 2; 50 constexpr int32_t LZ4F_MAX_BLOCKID = 7; 51 constexpr int32_t ZIP_MAX_LEVEL = 9; 52 53 class TestPkgStream : public PkgStreamImpl { 54 public: TestPkgStream(PkgManager::PkgManagerPtr pkgManager,std::string fileName)55 explicit TestPkgStream(PkgManager::PkgManagerPtr pkgManager, std::string fileName) 56 : PkgStreamImpl(pkgManager, fileName) {} ~TestPkgStream()57 virtual ~TestPkgStream() {} 58 Read(const PkgBuffer & buff,size_t start,size_t size,size_t & readLen)59 int32_t Read(const PkgBuffer &buff, size_t start, size_t size, size_t &readLen) override 60 { 61 return PkgStreamImpl::Read(buff, start, size, readLen); 62 } Write(const PkgBuffer & ptr,size_t size,size_t start)63 int32_t Write(const PkgBuffer &ptr, size_t size, size_t start) override 64 { 65 return PKG_SUCCESS; 66 } Seek(long int sizeT,int whence)67 int32_t Seek(long int sizeT, int whence) override 68 { 69 return PKG_SUCCESS; 70 } Flush(size_t size)71 int32_t Flush(size_t size) override 72 { 73 return PKG_SUCCESS; 74 } GetFileName() const75 const std::string GetFileName() const override 76 { 77 return ""; 78 } GetFileLength()79 size_t GetFileLength() override 80 { 81 return 0; 82 } 83 }; 84 85 class PkgMangerTest : public PkgTest { 86 public: PkgMangerTest()87 PkgMangerTest() {} ~PkgMangerTest()88 ~PkgMangerTest() override {} 89 TestStreamProcess(const PkgBuffer & ptr,size_t size,size_t start,bool isFinish,const void * context)90 static int TestStreamProcess(const PkgBuffer &ptr, size_t size, size_t start, bool isFinish, 91 const void *context) 92 { 93 PKG_LOGI("TestStreamProcess size %zu, start %zu finish %d", size, start, isFinish); 94 return PKG_SUCCESS; 95 } 96 GetUpgradePkgInfo(UpgradePkgInfo & pkgInfo,std::vector<std::pair<std::string,ComponentInfo>> & files)97 void GetUpgradePkgInfo(UpgradePkgInfo &pkgInfo, std::vector<std::pair<std::string, ComponentInfo>> &files) 98 { 99 pkgInfo.softwareVersion = "100.100.100.100"; 100 pkgInfo.date = "2021-02-02"; 101 pkgInfo.time = "21:23:49"; 102 pkgInfo.productUpdateId = "555.555.100.555"; 103 pkgInfo.pkgInfo.entryCount = testFileNames_.size(); 104 pkgInfo.pkgInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 105 pkgInfo.pkgInfo.signMethod = PKG_SIGN_METHOD_RSA; 106 pkgInfo.pkgInfo.pkgType = PKG_PACK_TYPE_UPGRADE; 107 pkgInfo.updateFileVersion = TEST_FILE_VERSION; 108 std::string filePath; 109 uint16_t componentInfoId = 100; 110 files.resize(testFileNames_.size()); 111 for (uint32_t i = 0; i < testFileNames_.size(); i++) { 112 filePath = TEST_PATH_FROM; 113 filePath += testFileNames_[i].c_str(); 114 files[i].first = filePath; 115 116 ComponentInfo* info = &files[i].second; 117 int ret = BuildFileDigest(*info->digest, sizeof(info->digest), filePath); 118 EXPECT_EQ(ret, PKG_SUCCESS); 119 info->fileInfo.identity = testFileNames_[i]; 120 info->fileInfo.unpackedSize = GetFileSize(filePath); 121 info->fileInfo.packedSize = info->fileInfo.unpackedSize; 122 info->fileInfo.packMethod = PKG_COMPRESS_METHOD_NONE; 123 info->fileInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 124 info->version = "2.2.2.2"; 125 info->id = componentInfoId; 126 info->resType = 0; 127 info->type = 0; 128 info->originalSize = info->fileInfo.unpackedSize; 129 info->compFlags = 0; 130 } 131 } TestPackagePack()132 int TestPackagePack() 133 { 134 PKG_LOGI("\n\n ************* TestPackagePack %s \r\n", testPackageName.c_str()); 135 UpgradePkgInfo pkgInfo; 136 std::vector<std::pair<std::string, ComponentInfo>> files; 137 GetUpgradePkgInfo(pkgInfo, files); 138 std::string packagePath = TEST_PATH_TO; 139 packagePath += testPackageName; 140 int32_t ret = pkgManager_->CreatePackage(packagePath, "", &pkgInfo.pkgInfo, files); 141 EXPECT_EQ(ret, PKG_INVALID_FILE); 142 ret = pkgManager_->CreatePackage(packagePath, GetTestPrivateKeyName(0), &pkgInfo.pkgInfo, files); 143 EXPECT_EQ(ret, PKG_SUCCESS); 144 return 0; 145 } 146 TestPackagePackFileNotExist()147 int TestPackagePackFileNotExist() 148 { 149 PKG_LOGI("\n\n ************* TestPackagePackFileNotExist %s \r\n", testPackageName.c_str()); 150 UpgradePkgInfo pkgInfo; 151 std::vector<std::pair<std::string, ComponentInfo>> files; 152 GetUpgradePkgInfo(pkgInfo, files); 153 std::string packagePath = TEST_PATH_TO; 154 packagePath += testPackageName; 155 156 // 修改成错误的路径 157 files[0].first = "sssssssssss"; 158 int32_t ret = pkgManager_->CreatePackage(packagePath, GetTestPrivateKeyName(0), &pkgInfo.pkgInfo, files); 159 EXPECT_EQ(ret, PKG_INVALID_FILE); 160 return 0; 161 } 162 TestPackagePackParamInvalid()163 int TestPackagePackParamInvalid() 164 { 165 PKG_LOGI("\n\n ************* TestPackagePackParamInvalid %s \r\n", testPackageName.c_str()); 166 std::vector<std::pair<std::string, ComponentInfo>> files; 167 std::string packagePath = TEST_PATH_TO; 168 packagePath += testPackageName; 169 int32_t ret = pkgManager_->CreatePackage(packagePath, GetTestPrivateKeyName(0), nullptr, files); 170 EXPECT_EQ(ret, PKG_INVALID_PARAM); 171 return 0; 172 } 173 TestPkgStreamImpl()174 int TestPkgStreamImpl() 175 { 176 std::string path = TEST_PATH_TO + testCombinePkgName; 177 std::unique_ptr<TestPkgStream> stream = std::make_unique<TestPkgStream>(pkgManager_, path); 178 EXPECT_NE(stream, nullptr); 179 constexpr size_t buffSize = 10; 180 uint8_t buff[buffSize]; 181 size_t size = sizeof(buff); 182 size_t start = 0; 183 size_t readLen = 0; 184 PkgBuffer buffer(buff, sizeof(buff)); 185 int ret = ((PkgStreamPtr)(stream.get()))->Read(buffer, start, size, readLen); 186 EXPECT_EQ(0, ret); 187 PkgBuffer data = {}; 188 ret = ((PkgStreamPtr)(stream.get()))->GetBuffer(data); 189 EXPECT_EQ(0, ret); 190 191 ret = ((PkgStreamPtr)(stream.get()))->GetStreamType(); 192 EXPECT_EQ(PkgStream::PkgStreamType_Read, ret); 193 194 return 0; 195 } 196 TestInvalidStream()197 int TestInvalidStream() 198 { 199 std::string packagePath = TEST_PATH_TO; 200 packagePath += testPackageName; 201 auto stream = std::make_unique<FileStream>(pkgManager_, testPackageName, nullptr, 0); 202 size_t start = 0; 203 size_t readLen = 0; 204 size_t bufferSize = 10; 205 PkgBuffer buffer(bufferSize); 206 int ret = stream->Read(buffer, start, bufferSize, readLen); 207 EXPECT_EQ(PKG_INVALID_STREAM, ret); 208 return 0; 209 } 210 TestRead()211 int TestRead() 212 { 213 constexpr size_t buffSize = 8; 214 int index = 7; 215 uint8_t buffValue = 100; 216 uint8_t buff[buffSize] = {0}; 217 buff[index] = buffValue; 218 ReadLE64(buff); 219 return 0; 220 } 221 TestCheckFile()222 int TestCheckFile() 223 { 224 std::string filePath = TEST_PATH_TO; 225 filePath += "/4444/"; 226 int ret = CheckFile(filePath); 227 EXPECT_EQ(ret, 0); 228 return 0; 229 } 230 TestGetCurrPath()231 int TestGetCurrPath() 232 { 233 std::string path = GetCurrPath(); 234 if (path == "./") { 235 EXPECT_EQ(1, 0); 236 } 237 return 0; 238 } 239 TestCreatePackageInvalidFile()240 int TestCreatePackageInvalidFile() 241 { 242 UpgradePkgInfo pkgInfo; 243 size_t testSize = 100; 244 uint16_t componentInfoId = 100; 245 std::vector<std::pair<std::string, ComponentInfo>> files; 246 GetUpgradePkgInfo(pkgInfo, files); 247 ComponentInfo info; 248 info.fileInfo.identity = "aaaaaaaa"; 249 info.fileInfo.unpackedSize = testSize; 250 info.fileInfo.packedSize = testSize; 251 info.fileInfo.packMethod = PKG_COMPRESS_METHOD_NONE; 252 info.fileInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 253 info.version = "2.2.2.2"; 254 info.id = componentInfoId; 255 info.resType = 0; 256 info.type = 0; 257 info.originalSize = testSize; 258 info.compFlags = 0; 259 std::string packagePath = TEST_PATH_TO; 260 packagePath += testPackageName; 261 files.push_back(std::pair<std::string, ComponentInfo>("/qqqqqq", info)); 262 int ret = pkgManager_->CreatePackage(packagePath, GetTestPrivateKeyName(0), &pkgInfo.pkgInfo, files); 263 EXPECT_EQ(ret, PKG_INVALID_FILE); 264 return 0; 265 } 266 TestCreatePackageInvalidSignMethod()267 int TestCreatePackageInvalidSignMethod() 268 { 269 UpgradePkgInfo pkgInfo; 270 std::vector<std::pair<std::string, ComponentInfo>> files; 271 GetUpgradePkgInfo(pkgInfo, files); 272 std::string packagePath = TEST_PATH_TO; 273 packagePath += testPackageName; 274 uint8_t signMethodIndex = 10; 275 pkgInfo.pkgInfo.signMethod = PKG_SIGN_METHOD_RSA + signMethodIndex; 276 int ret = pkgManager_->CreatePackage(packagePath, GetTestPrivateKeyName(0), &pkgInfo.pkgInfo, files); 277 EXPECT_NE(ret, 0); 278 return 0; 279 } 280 TestLz4PackageInvalidFile()281 int TestLz4PackageInvalidFile() 282 { 283 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 284 EXPECT_NE(pkgManager_, nullptr); 285 286 std::vector<std::pair<std::string, Lz4FileInfo>> files; 287 Lz4FileInfo file; 288 file.fileInfo.identity = testPackageName; 289 file.fileInfo.packMethod = PKG_COMPRESS_METHOD_ZIP; 290 file.fileInfo.digestMethod = PKG_DIGEST_TYPE_CRC; 291 files.push_back(std::pair<std::string, Lz4FileInfo>("fileName", file)); 292 PkgInfo pkgInfo; 293 pkgInfo.signMethod = PKG_SIGN_METHOD_RSA; 294 pkgInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 295 pkgInfo.pkgType = PKG_PACK_TYPE_GZIP; 296 std::string fileName = TEST_PATH_TO; 297 fileName += testGZipPackageName; 298 int ret = pkgManager_->CreatePackage(fileName, "", &pkgInfo, files); 299 EXPECT_EQ(ret, PKG_INVALID_FILE); 300 ret = pkgManager_->CreatePackage(fileName, GetTestPrivateKeyName(0), nullptr, files); 301 EXPECT_EQ(ret, PKG_INVALID_PARAM); 302 ret = pkgManager_->CreatePackage(fileName, GetTestPrivateKeyName(0), &pkgInfo, files); 303 EXPECT_EQ(ret, PKG_INVALID_FILE); 304 return 0; 305 } 306 TestLz4PackageInvalidPkgType()307 int TestLz4PackageInvalidPkgType() 308 { 309 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 310 EXPECT_NE(pkgManager_, nullptr); 311 312 std::vector<std::pair<std::string, Lz4FileInfo>> files; 313 Lz4FileInfo file; 314 file.fileInfo.identity = testPackageName; 315 file.fileInfo.packMethod = PKG_COMPRESS_METHOD_ZIP; 316 file.fileInfo.digestMethod = PKG_DIGEST_TYPE_CRC; 317 files.push_back(std::pair<std::string, Lz4FileInfo>("fileName", file)); 318 PkgInfo pkgInfo; 319 pkgInfo.signMethod = PKG_SIGN_METHOD_RSA; 320 pkgInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 321 uint8_t pkgTypeIndex = 100; 322 pkgInfo.pkgType = PKG_PACK_TYPE_GZIP + pkgTypeIndex; 323 std::string fileName = TEST_PATH_TO; 324 fileName += testGZipPackageName; 325 int ret = pkgManager_->CreatePackage(fileName, GetTestPrivateKeyName(0), &pkgInfo, files); 326 EXPECT_EQ(ret, PKG_INVALID_FILE); 327 return 0; 328 } 329 TestZipPackageInvalidFile()330 int TestZipPackageInvalidFile() 331 { 332 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 333 EXPECT_NE(pkgManager_, nullptr); 334 335 std::vector<std::pair<std::string, ZipFileInfo>> files; 336 for (auto name : testFileNames_) { 337 ZipFileInfo file; 338 file.fileInfo.identity = name; 339 file.fileInfo.packMethod = PKG_COMPRESS_METHOD_ZIP; 340 file.fileInfo.digestMethod = PKG_DIGEST_TYPE_CRC; 341 files.push_back(std::pair<std::string, ZipFileInfo>("55555555555", file)); 342 } 343 PkgInfo pkgInfo; 344 pkgInfo.signMethod = PKG_SIGN_METHOD_RSA; 345 pkgInfo.digestMethod = PKG_DIGEST_TYPE_SHA256; 346 pkgInfo.pkgType = PKG_PACK_TYPE_ZIP; 347 std::string fileName = TEST_PATH_TO; 348 fileName += testZipPackageName; 349 int ret = pkgManager_->CreatePackage(fileName, "", &pkgInfo, files); 350 EXPECT_EQ(ret, PKG_INVALID_FILE); 351 ret = pkgManager_->CreatePackage(fileName, GetTestPrivateKeyName(0), nullptr, files); 352 EXPECT_EQ(ret, PKG_INVALID_PARAM); 353 ret = pkgManager_->CreatePackage(fileName, GetTestPrivateKeyName(0), &pkgInfo, files); 354 EXPECT_EQ(ret, PKG_INVALID_FILE); 355 return 0; 356 } 357 TestLoadPackageFail()358 int TestLoadPackageFail() 359 { 360 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 361 EXPECT_NE(pkgManager_, nullptr); 362 std::vector<std::string> components; 363 std::string fileName = TEST_PATH_TO; 364 fileName += "testZipPackageName.aaa"; 365 int32_t ret = pkgManager_->LoadPackage(fileName, GetTestCertName(0), components); 366 EXPECT_EQ(ret, PKG_INVALID_FILE); 367 return 0; 368 } 369 TestDecompressLz4plus(Hpackage::Lz4FileInfo & lz4Info)370 void TestDecompressLz4plus(Hpackage::Lz4FileInfo &lz4Info) 371 { 372 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 373 EXPECT_NE(pkgManager_, nullptr); 374 int8_t compressionLevel = 2; 375 lz4Info.fileInfo.identity = "Lz4"; 376 lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4; 377 lz4Info.fileInfo.digestMethod = PKG_DIGEST_TYPE_NONE; 378 lz4Info.compressionLevel = compressionLevel; 379 lz4Info.blockSizeID = 0; 380 lz4Info.contentChecksumFlag = 0; 381 lz4Info.blockIndependence = 0; 382 } 383 TestDecompressLz4(Hpackage::Lz4FileInfo & lz4Info,std::vector<uint8_t> & uncompressedData,std::vector<uint8_t> & digest)384 int TestDecompressLz4(Hpackage::Lz4FileInfo &lz4Info, 385 std::vector<uint8_t> &uncompressedData, std::vector<uint8_t> &digest) 386 { 387 std::string testFileName = TEST_PATH_FROM + "../diffpatch/PatchLz4test_new.lz4"; 388 size_t fileSize = GetFileSize(testFileName); 389 int32_t fd = open(testFileName.c_str(), O_RDWR); 390 PKG_CHECK(fd > 0, return -1, "Can not open file "); 391 392 size_t uncompressedDataSize = 1024; 393 uncompressedData.resize(uncompressedDataSize); 394 PkgManager::StreamPtr stream = nullptr; 395 pkgManager_->CreatePkgStream(stream, "Lz4", 396 [&](const PkgBuffer &buffer, size_t size, size_t start, bool isFinish, const void* context) -> int { 397 (void)isFinish; 398 (void)context; 399 (void)size; 400 (void)start; 401 (void)buffer; 402 size_t oldSize = uncompressedData.size(); 403 if ((start + size) > uncompressedData.size()) { 404 uncompressedData.resize(oldSize * ((start + size) / oldSize + 1)); 405 } 406 EXPECT_GE(memcpy_s(uncompressedData.data() + start, size, buffer.buffer, size), 0); 407 return PKG_SUCCESS; 408 }, nullptr); 409 410 std::unique_ptr<Hpackage::PkgStream, std::function<void(Hpackage::PkgManager::StreamPtr)>> outStream(stream, 411 [&](Hpackage::PkgManager::StreamPtr stream) { 412 pkgManager_->ClosePkgStream(stream); 413 }); 414 PKG_CHECK(outStream != nullptr, close(fd); return -1, "Can not create stream "); 415 416 void* mappedData = mmap(nullptr, fileSize, PROT_READ, MAP_SHARED, fd, 0); 417 PKG_CHECK(mappedData != MAP_FAILED, close(fd); return -2, "Can not mmap "); 418 419 size_t addrOffset = 4; 420 TestDecompressLz4plus(lz4Info); 421 Hpackage::PkgBuffer buffer(static_cast<uint8_t*>(mappedData) + addrOffset, fileSize); 422 int32_t ret = pkgManager_->DecompressBuffer(&lz4Info.fileInfo, buffer, outStream.get()); 423 424 // 生成摘要，检查数据完整 425 SHA256_CTX sha256Ctx = {}; 426 SHA256_Init(&sha256Ctx); 427 SHA256_Update(&sha256Ctx, static_cast<const uint8_t*>(mappedData), lz4Info.fileInfo.packedSize + 4); 428 SHA256_Final(digest.data(), &sha256Ctx); 429 430 munmap(mappedData, fileSize); 431 close(fd); 432 PKG_CHECK(ret == 0, return -1, "Can not decompress buff "); 433 PKG_LOGE("GetLz4UncompressedData packedSize:%zu unpackedSize:%zu fileSize: %zu", 434 lz4Info.fileInfo.packedSize, lz4Info.fileInfo.unpackedSize, fileSize); 435 return 0; 436 } 437 TestDecompressGzipInitFile(Hpackage::ZipFileInfo & zipInfo,size_t & offset,size_t & fileSize,void * mappedData)438 void TestDecompressGzipInitFile(Hpackage::ZipFileInfo &zipInfo, size_t &offset, 439 size_t &fileSize, void *mappedData) 440 { 441 int32_t zipMethod = 8; 442 int32_t zipLevel = 4; 443 zipInfo.fileInfo.identity = "gzip"; 444 zipInfo.fileInfo.packMethod = PKG_COMPRESS_METHOD_GZIP; 445 zipInfo.fileInfo.digestMethod = PKG_DIGEST_TYPE_NONE; 446 zipInfo.method = zipMethod; 447 zipInfo.level = zipLevel; 448 zipInfo.memLevel = MEMLEVEL; 449 zipInfo.windowBits = WINDOWBITS; 450 zipInfo.strategy = STRATEGY; 451 452 auto buffer = reinterpret_cast<uint8_t*>(mappedData); 453 auto header = reinterpret_cast<GZipHeader*>(mappedData); 454 // 有扩展头信息 455 if (header->flags & EXTRA_FIELD) { 456 uint16_t extLen = ReadLE16(buffer + offset); 457 offset += sizeof(uint16_t) + extLen; 458 } 459 if (header->flags & ORIG_NAME) { 460 std::string fileName; 461 PkgFile::ConvertBufferToString(fileName, {buffer + offset, fileSize - offset}); 462 offset += fileName.size() + 1; 463 } 464 if (header->flags & COMMENT) { 465 std::string comment; 466 PkgFile::ConvertBufferToString(comment, {buffer + offset, fileSize - offset}); 467 offset += comment.size() + 1; 468 } 469 if (header->flags & HEADER_CRC) { // 暂不校验 470 offset += TEST_DECOMPRESS_GZIP_OFFSET; 471 } 472 return; 473 } 474 TestDecompressGzip(Hpackage::ZipFileInfo & zipInfo,std::vector<uint8_t> & uncompressedData,std::vector<uint8_t> & digest)475 int TestDecompressGzip(Hpackage::ZipFileInfo &zipInfo, std::vector<uint8_t> &uncompressedData, 476 std::vector<uint8_t> &digest) 477 { 478 std::string testFileName = TEST_PATH_FROM + "../applypatch/TestDecompressGzip.new.gz"; 479 size_t fileSize = GetFileSize(testFileName); 480 size_t uncompressedDataSize = 1024; 481 int fd = open(testFileName.c_str(), O_RDWR); 482 if (fd < 0) { 483 return -1; 484 } 485 uncompressedData.resize(uncompressedDataSize); 486 PkgManager::StreamPtr stream = nullptr; 487 pkgManager_->CreatePkgStream(stream, "Gzip", 488 [&](const PkgBuffer &buffer, size_t size, size_t start, bool isFinish, const void* context) -> int { 489 (void)isFinish; 490 (void)context; 491 (void)size; 492 (void)start; 493 (void)buffer; 494 size_t oldSize = uncompressedData.size(); 495 if ((start + size) > uncompressedData.size()) { 496 uncompressedData.resize(oldSize * ((start + size) / oldSize + 1)); 497 } 498 EXPECT_GE(memcpy_s(uncompressedData.data() + start, size, buffer.buffer, size), 0); 499 return PKG_SUCCESS; 500 }, nullptr); 501 502 std::unique_ptr<Hpackage::PkgStream, std::function<void(Hpackage::PkgManager::StreamPtr)>> outStream(stream, 503 [&](Hpackage::PkgManager::StreamPtr stream) { 504 pkgManager_->ClosePkgStream(stream); 505 }); 506 PKG_CHECK(outStream != nullptr, close(fd); return -1, "Can not create stream "); 507 508 void* mappedData = mmap(nullptr, fileSize, PROT_READ, MAP_SHARED, fd, 0); 509 PKG_CHECK(mappedData != MAP_FAILED, close(fd); return -2, "Can not mmap "); 510 511 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 512 EXPECT_NE(pkgManager_, nullptr); 513 size_t offset = 10; 514 TestDecompressGzipInitFile(zipInfo, offset, fileSize, mappedData); 515 516 Hpackage::PkgBuffer data(reinterpret_cast<uint8_t*>(mappedData) + offset, fileSize); 517 int32_t ret = pkgManager_->DecompressBuffer(&zipInfo.fileInfo, data, outStream.get()); 518 519 // 生成摘要，检查数据完整 520 SHA256_CTX sha256Ctx = {}; 521 SHA256_Init(&sha256Ctx); 522 SHA256_Update(&sha256Ctx, reinterpret_cast<const uint8_t*>(mappedData) + offset, zipInfo.fileInfo.packedSize); 523 SHA256_Final(digest.data(), &sha256Ctx); 524 525 munmap(mappedData, fileSize); 526 close(fd); 527 PKG_CHECK(ret == 0, return -1, "Can not decompress buff "); 528 PKG_LOGE("GetGZipUncompressedData packedSize:%zu unpackedSize:%zu", 529 zipInfo.fileInfo.packedSize, zipInfo.fileInfo.unpackedSize); 530 531 return 0; 532 } 533 TestCompressBuffer(Hpackage::FileInfo & info,std::vector<uint8_t> uncompressedData,std::vector<uint8_t> digest)534 int TestCompressBuffer(Hpackage::FileInfo &info, std::vector<uint8_t> uncompressedData, 535 std::vector<uint8_t> digest) 536 { 537 pkgManager_ = static_cast<PkgManagerImpl*>(PkgManager::GetPackageInstance()); 538 EXPECT_NE(pkgManager_, nullptr); 539 // 生成摘要，检查数据完整 540 SHA256_CTX sha256Ctx = {}; 541 SHA256_Init(&sha256Ctx); 542 PkgManager::StreamPtr stream = nullptr; 543 pkgManager_->CreatePkgStream(stream, "Gzip", 544 [&](const PkgBuffer &ptr, size_t size, size_t start, bool isFinish, const void* context) -> int { 545 (void)isFinish; 546 (void)context; 547 (void)size; 548 (void)start; 549 (void)ptr; 550 SHA256_Update(&sha256Ctx, ptr.buffer, size); 551 return PKG_SUCCESS; 552 }, nullptr); 553 554 std::unique_ptr<Hpackage::PkgStream, std::function<void(Hpackage::PkgManager::StreamPtr)>> outStream(stream, 555 [&](Hpackage::PkgManager::StreamPtr stream) { 556 pkgManager_->ClosePkgStream(stream); 557 }); 558 PKG_CHECK(outStream != nullptr, return -1, "Can not create stream "); 559 Hpackage::PkgBuffer buffer(uncompressedData.data(), info.unpackedSize); 560 int32_t ret = pkgManager_->CompressBuffer(&info, buffer, outStream.get()); 561 PKG_LOGE("GetGZipUncompressedData packedSize:%zu unpackedSize:%zu", 562 info.packedSize, info.unpackedSize); 563 PKG_CHECK(ret == 0, return -1, "Fail to CompressBuffer"); 564 std::vector<uint8_t> localDigest(DEFAULT_LOCAK_DIGEST); 565 SHA256_Final(localDigest.data(), &sha256Ctx); 566 ret = memcmp(localDigest.data(), digest.data(), localDigest.size()); 567 PKG_LOGE("digest cmp result %d", ret); 568 return ret; 569 } 570 TestReadWriteLENull()571 void TestReadWriteLENull() 572 { 573 uint8_t *buff = nullptr; 574 WriteLE16(buff, 0); 575 uint16_t ret16 = ReadLE16(buff); 576 EXPECT_EQ(ret16, 0); 577 WriteLE32(buff, 0); 578 uint32_t ret32 = ReadLE32(buff); 579 EXPECT_EQ(ret32, 0); 580 uint64_t ret64 = ReadLE64(buff); 581 EXPECT_EQ(ret64, 0); 582 } 583 }; 584 585 HWTEST_F(PkgMangerTest, TestGZipBuffer, TestSize.Level1) 586 { 587 PkgMangerTest test; 588 Hpackage::ZipFileInfo zipInfo; 589 std::vector<uint8_t> digest(32); 590 std::vector<uint8_t> uncompressedData; 591 EXPECT_EQ(0, test.TestDecompressGzip(zipInfo, uncompressedData, digest)); 592 int32_t ret = 0; 593 for (int32_t i = 0; i < ZIP_MAX_LEVEL; i++) { 594 zipInfo.level = i; 595 ret = test.TestCompressBuffer(zipInfo.fileInfo, uncompressedData, digest); 596 if (ret == 0) { 597 break; 598 } 599 } 600 EXPECT_EQ(0, ret); 601 uncompressedData.clear(); 602 } 603 604 HWTEST_F(PkgMangerTest, TestLz4Buffer, TestSize.Level1) 605 { 606 PkgMangerTest test; 607 Hpackage::Lz4FileInfo lz4Info; 608 std::vector<uint8_t> digest(32); 609 std::vector<uint8_t> uncompressedData; 610 EXPECT_EQ(0, test.TestDecompressLz4(lz4Info, uncompressedData, digest)); 611 int32_t ret = 0; 612 for (int32_t i = 0; i < LZ4F_MAX_BLOCKID; i++) { 613 lz4Info.compressionLevel = 2; 614 lz4Info.blockSizeID = i; 615 ret = test.TestCompressBuffer(lz4Info.fileInfo, uncompressedData, digest); 616 if (ret == 0) { 617 break; 618 } 619 } 620 EXPECT_EQ(0, ret); 621 uncompressedData.clear(); 622 } 623 624 HWTEST_F(PkgMangerTest, TestInvalidCreatePackage, TestSize.Level1) 625 { 626 PkgMangerTest test; 627 EXPECT_EQ(0, test.TestPackagePack()); 628 EXPECT_EQ(0, test.TestPackagePackFileNotExist()); 629 EXPECT_EQ(0, test.TestPackagePackParamInvalid()); 630 } 631 632 HWTEST_F(PkgMangerTest, TestPkgStreamImpl, TestSize.Level1) 633 { 634 PkgMangerTest test; 635 EXPECT_EQ(0, test.TestPkgStreamImpl()); 636 } 637 638 HWTEST_F(PkgMangerTest, TestInvalidStream, TestSize.Level1) 639 { 640 PkgMangerTest test; 641 EXPECT_EQ(0, test.TestInvalidStream()); 642 } 643 644 HWTEST_F(PkgMangerTest, TestRead, TestSize.Level1) 645 { 646 PkgMangerTest test; 647 EXPECT_EQ(0, test.TestRead()); 648 } 649 650 HWTEST_F(PkgMangerTest, TestCheckFile, TestSize.Level1) 651 { 652 PkgMangerTest test; 653 EXPECT_EQ(0, test.TestCheckFile()); 654 } 655 656 HWTEST_F(PkgMangerTest, TestCreatePackageFail, TestSize.Level1) 657 { 658 PkgMangerTest test; 659 EXPECT_EQ(0, test.TestCreatePackageInvalidFile()); 660 EXPECT_EQ(0, test.TestCreatePackageInvalidSignMethod()); 661 EXPECT_EQ(0, test.TestLz4PackageInvalidFile()); 662 EXPECT_EQ(0, test.TestLz4PackageInvalidPkgType()); 663 EXPECT_EQ(0, test.TestZipPackageInvalidFile()); 664 } 665 666 HWTEST_F(PkgMangerTest, TestLoadPackageFail, TestSize.Level1) 667 { 668 PkgMangerTest test; 669 EXPECT_EQ(0, test.TestLoadPackageFail()); 670 } 671 672 HWTEST_F(PkgMangerTest, TestReadWriteLENull, TestSize.Level1) 673 { 674 PkgMangerTest test; 675 test.TestReadWriteLENull(); 676 } 677 } 678