Home | History | Annotate | Download | only in bsdiff 
      1 // Copyright 2017 The Chromium OS Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "bsdiff/patch_reader.h"
      6 
      7 #include <unistd.h>
      8 
      9 #include <algorithm>
     10 #include <limits>
     11 #include <string>
     12 #include <vector>
     13 
     14 #include <gtest/gtest.h>
     15 
     16 #include "bsdiff/brotli_compressor.h"
     17 #include "bsdiff/bz2_compressor.h"
     18 #include "bsdiff/utils.h"
     19 
     20 namespace {
     21 
     22 void EncodeInt64(int64_t x, uint8_t* buf) {
     23   uint64_t y = x < 0 ? (1ULL << 63ULL) - x : x;
     24   for (int i = 0; i < 8; ++i) {
     25     buf[i] = y & 0xff;
     26     y /= 256;
     27   }
     28 }
     29 
     30 }  // namespace
     31 
     32 namespace bsdiff {
     33 
     34 class PatchReaderTest : public testing::Test {
     35  protected:
     36   void CompressData() {
     37     for (size_t i = 0; i < diff_data_.size(); i++) {
     38       uint8_t buf[24];
     39       EncodeInt64(diff_data_[i].size(), buf);
     40       EncodeInt64(extra_data_[i].size(), buf + 8);
     41       EncodeInt64(offset_increment_[i], buf + 16);
     42       EXPECT_TRUE(ctrl_stream_->Write(buf, sizeof(buf)));
     43       EXPECT_TRUE(diff_stream_->Write(
     44           reinterpret_cast<const uint8_t*>(diff_data_[i].data()),
     45           diff_data_[i].size()));
     46       EXPECT_TRUE(extra_stream_->Write(
     47           reinterpret_cast<const uint8_t*>(extra_data_[i].data()),
     48           extra_data_[i].size()));
     49     }
     50     EXPECT_TRUE(ctrl_stream_->Finish());
     51     EXPECT_TRUE(diff_stream_->Finish());
     52     EXPECT_TRUE(extra_stream_->Finish());
     53   }
     54 
     55   void ConstructPatchHeader(int64_t ctrl_size,
     56                             int64_t diff_size,
     57                             int64_t new_size,
     58                             std::vector<uint8_t>* patch_data) {
     59     EXPECT_EQ(static_cast<size_t>(8), patch_data->size());
     60     // Encode the header.
     61     uint8_t buf[24];
     62     EncodeInt64(ctrl_size, buf);
     63     EncodeInt64(diff_size, buf + 8);
     64     EncodeInt64(new_size, buf + 16);
     65     std::copy(buf, buf + sizeof(buf), std::back_inserter(*patch_data));
     66   }
     67 
     68   void ConstructPatchData(std::vector<uint8_t>* patch_data) {
     69     ConstructPatchHeader(ctrl_stream_->GetCompressedData().size(),
     70                          diff_stream_->GetCompressedData().size(),
     71                          new_file_size_, patch_data);
     72 
     73     // Concatenate the three streams into one patch.
     74     std::copy(ctrl_stream_->GetCompressedData().begin(),
     75               ctrl_stream_->GetCompressedData().end(),
     76               std::back_inserter(*patch_data));
     77     std::copy(diff_stream_->GetCompressedData().begin(),
     78               diff_stream_->GetCompressedData().end(),
     79               std::back_inserter(*patch_data));
     80     std::copy(extra_stream_->GetCompressedData().begin(),
     81               extra_stream_->GetCompressedData().end(),
     82               std::back_inserter(*patch_data));
     83   }
     84 
     85   void VerifyPatch(const std::vector<uint8_t>& patch_data) {
     86     BsdiffPatchReader patch_reader;
     87     EXPECT_TRUE(patch_reader.Init(patch_data.data(), patch_data.size()));
     88     EXPECT_EQ(new_file_size_, patch_reader.new_file_size());
     89     // Check that the decompressed data matches what we wrote.
     90     for (size_t i = 0; i < diff_data_.size(); i++) {
     91       ControlEntry control_entry(0, 0, 0);
     92       EXPECT_TRUE(patch_reader.ParseControlEntry(&control_entry));
     93       EXPECT_EQ(diff_data_[i].size(), control_entry.diff_size);
     94       EXPECT_EQ(extra_data_[i].size(), control_entry.extra_size);
     95       EXPECT_EQ(offset_increment_[i], control_entry.offset_increment);
     96 
     97       uint8_t buffer[128] = {};
     98       EXPECT_TRUE(patch_reader.ReadDiffStream(buffer, diff_data_[i].size()));
     99       EXPECT_EQ(0, memcmp(buffer, diff_data_[i].data(), diff_data_[i].size()));
    100       EXPECT_TRUE(patch_reader.ReadExtraStream(buffer, extra_data_[i].size()));
    101       EXPECT_EQ(0,
    102                 memcmp(buffer, extra_data_[i].data(), extra_data_[i].size()));
    103     }
    104     EXPECT_TRUE(patch_reader.Finish());
    105   }
    106 
    107   // Helper function to check that invalid headers are detected. This method
    108   // creates a new header with the passed |ctrl_size|, |diff_size| and
    109   // |new_size| and appends after the header |compressed_size| bytes of extra
    110   // zeros. It then expects that initializing a PatchReader with this will fail.
    111   void InvalidHeaderTestHelper(int64_t ctrl_size,
    112                                int64_t diff_size,
    113                                int64_t new_size,
    114                                size_t compressed_size) {
    115     std::vector<uint8_t> patch_data;
    116     std::copy(kBSDF2MagicHeader, kBSDF2MagicHeader + 5,
    117               std::back_inserter(patch_data));
    118     patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    119     patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    120     patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    121     ConstructPatchHeader(ctrl_size, diff_size, new_size, &patch_data);
    122     patch_data.resize(patch_data.size() + compressed_size);
    123 
    124     BsdiffPatchReader patch_reader;
    125     EXPECT_FALSE(patch_reader.Init(patch_data.data(), patch_data.size()))
    126         << "Where ctrl_size=" << ctrl_size << " diff_size=" << diff_size
    127         << " new_size=" << new_size << " compressed_size=" << compressed_size;
    128   }
    129 
    130   size_t new_file_size_{500};
    131   std::vector<std::string> diff_data_{"HelloWorld", "BspatchPatchTest",
    132                                       "BspatchDiffData"};
    133   std::vector<std::string> extra_data_{"HelloWorld!", "BZ2PatchReaderSmoke",
    134                                        "BspatchExtraData"};
    135   std::vector<int64_t> offset_increment_{100, 200, 300};
    136 
    137   // The compressor streams.
    138   std::unique_ptr<CompressorInterface> ctrl_stream_{nullptr};
    139   std::unique_ptr<CompressorInterface> diff_stream_{nullptr};
    140   std::unique_ptr<CompressorInterface> extra_stream_{nullptr};
    141 };
    142 
    143 TEST_F(PatchReaderTest, PatchReaderLegacyFormatSmoke) {
    144   ctrl_stream_.reset(new BZ2Compressor());
    145   diff_stream_.reset(new BZ2Compressor());
    146   extra_stream_.reset(new BZ2Compressor());
    147 
    148   CompressData();
    149 
    150   std::vector<uint8_t> patch_data;
    151   std::copy(kLegacyMagicHeader, kLegacyMagicHeader + 8,
    152             std::back_inserter(patch_data));
    153   ConstructPatchData(&patch_data);
    154 
    155   VerifyPatch(patch_data);
    156 }
    157 
    158 TEST_F(PatchReaderTest, PatchReaderNewFormatSmoke) {
    159   // Compress the data with one bz2 and two brotli compressors.
    160   ctrl_stream_.reset(new BZ2Compressor());
    161   diff_stream_.reset(new BrotliCompressor(11));
    162   extra_stream_.reset(new BrotliCompressor(11));
    163 
    164   CompressData();
    165 
    166   std::vector<uint8_t> patch_data;
    167   std::copy(kBSDF2MagicHeader, kBSDF2MagicHeader + 5,
    168             std::back_inserter(patch_data));
    169   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBZ2));
    170   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    171   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    172   ConstructPatchData(&patch_data);
    173 
    174   VerifyPatch(patch_data);
    175 }
    176 
    177 TEST_F(PatchReaderTest, InvalidHeaderTest) {
    178   // Negative values are not allowed.
    179   InvalidHeaderTestHelper(-1, 0, 20, 50);
    180   InvalidHeaderTestHelper(30, -3, 20, 50);
    181   InvalidHeaderTestHelper(30, 8, -20, 50);
    182 
    183   // Values larger than the patch size are also not allowed for ctrl and diff,
    184   // or for the sum of both.
    185   InvalidHeaderTestHelper(30, 5, 20, 10);  // 30 > 10
    186   InvalidHeaderTestHelper(5, 30, 20, 10);  // 30 > 10
    187   InvalidHeaderTestHelper(30, 5, 20, 32);  // 30 + 5 > 32
    188 
    189   // Values that overflow int64 are also not allowed when used combined
    190   const int64_t kMax64 = std::numeric_limits<int64_t>::max();
    191   InvalidHeaderTestHelper(kMax64 - 5, 5, 20, 20);
    192   InvalidHeaderTestHelper(5, kMax64 - 5, 20, 20);
    193 
    194   // 2 * (kMax64 - 5) + sizeof(header) is still positive due to overflow, but
    195   // the patch size is too small.
    196   InvalidHeaderTestHelper(kMax64 - 5, kMax64 - 5, 20, 20);
    197 }
    198 
    199 TEST_F(PatchReaderTest, InvalidCompressionHeaderTest) {
    200   std::vector<uint8_t> patch_data;
    201   std::copy(kBSDF2MagicHeader, kBSDF2MagicHeader + 5,
    202             std::back_inserter(patch_data));
    203   // Set an invalid compression value.
    204   patch_data.push_back(99);
    205   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    206   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    207   ConstructPatchHeader(10, 10, 10, &patch_data);
    208   patch_data.resize(patch_data.size() + 30);
    209 
    210   BsdiffPatchReader patch_reader;
    211   EXPECT_FALSE(patch_reader.Init(patch_data.data(), patch_data.size()));
    212 }
    213 
    214 TEST_F(PatchReaderTest, InvalidControlEntryTest) {
    215   // Check that negative diff and extra values in a control entry are not
    216   // allowed.
    217   ctrl_stream_.reset(new BZ2Compressor());
    218   diff_stream_.reset(new BrotliCompressor(11));
    219   extra_stream_.reset(new BrotliCompressor(11));
    220 
    221   // Encode the header.
    222   uint8_t buf[24];
    223   EncodeInt64(-10, buf);
    224   EncodeInt64(0, buf + 8);
    225   EncodeInt64(0, buf + 16);
    226   ctrl_stream_->Write(buf, sizeof(buf));
    227 
    228   CompressData();
    229 
    230   std::vector<uint8_t> patch_data;
    231   std::copy(kBSDF2MagicHeader, kBSDF2MagicHeader + 5,
    232             std::back_inserter(patch_data));
    233   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBZ2));
    234   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    235   patch_data.push_back(static_cast<uint8_t>(CompressorType::kBrotli));
    236   ConstructPatchData(&patch_data);
    237 
    238   BsdiffPatchReader patch_reader;
    239   EXPECT_TRUE(patch_reader.Init(patch_data.data(), patch_data.size()));
    240   ControlEntry control_entry(0, 0, 0);
    241   EXPECT_FALSE(patch_reader.ParseControlEntry(&control_entry));
    242 }
    243 
    244 }  // namespace bsdiff
    245