source/Utility/ZipFile.cpp

//===-- ZipFile.cpp -------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Utility/ZipFile.h"
#include "lldb/Utility/DataBuffer.h"
#include "lldb/Utility/FileSpec.h"
#include "llvm/Support/Endian.h"

using namespace lldb_private;
using namespace llvm::support;

namespace {

// Zip headers.
// https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT

// The end of central directory record.
struct EocdRecord {
  static constexpr char kSignature[] = {0x50, 0x4b, 0x05, 0x06};
  char signature[sizeof(kSignature)];
  unaligned_uint16_t disks;
  unaligned_uint16_t cd_start_disk;
  unaligned_uint16_t cds_on_this_disk;
  unaligned_uint16_t cd_records;
  unaligned_uint32_t cd_size;
  unaligned_uint32_t cd_offset;
  unaligned_uint16_t comment_length;
};

// Logical find limit for the end of central directory record.
const size_t kEocdRecordFindLimit =
    sizeof(EocdRecord) +
    std::numeric_limits<decltype(EocdRecord::comment_length)>::max();

// Central directory record.
struct CdRecord {
  static constexpr char kSignature[] = {0x50, 0x4b, 0x01, 0x02};
  char signature[sizeof(kSignature)];
  unaligned_uint16_t version_made_by;
  unaligned_uint16_t version_needed_to_extract;
  unaligned_uint16_t general_purpose_bit_flag;
  unaligned_uint16_t compression_method;
  unaligned_uint16_t last_modification_time;
  unaligned_uint16_t last_modification_date;
  unaligned_uint32_t crc32;
  unaligned_uint32_t compressed_size;
  unaligned_uint32_t uncompressed_size;
  unaligned_uint16_t file_name_length;
  unaligned_uint16_t extra_field_length;
  unaligned_uint16_t comment_length;
  unaligned_uint16_t file_start_disk;
  unaligned_uint16_t internal_file_attributes;
  unaligned_uint32_t external_file_attributes;
  unaligned_uint32_t local_file_header_offset;
};
// Immediately after CdRecord,
// - file name (file_name_length)
// - extra field (extra_field_length)
// - comment (comment_length)

// Local file header.
struct LocalFileHeader {
  static constexpr char kSignature[] = {0x50, 0x4b, 0x03, 0x04};
  char signature[sizeof(kSignature)];
  unaligned_uint16_t version_needed_to_extract;
  unaligned_uint16_t general_purpose_bit_flag;
  unaligned_uint16_t compression_method;
  unaligned_uint16_t last_modification_time;
  unaligned_uint16_t last_modification_date;
  unaligned_uint32_t crc32;
  unaligned_uint32_t compressed_size;
  unaligned_uint32_t uncompressed_size;
  unaligned_uint16_t file_name_length;
  unaligned_uint16_t extra_field_length;
};
// Immediately after LocalFileHeader,
// - file name (file_name_length)
// - extra field (extra_field_length)
// - file data (should be compressed_size == uncompressed_size, page aligned)

const EocdRecord *FindEocdRecord(lldb::DataBufferSP zip_data) {
  // Find backward the end of central directory record from the end of the zip
  // file to the find limit.
  const uint8_t *zip_data_end = zip_data->GetBytes() + zip_data->GetByteSize();
  const uint8_t *find_limit = zip_data_end - kEocdRecordFindLimit;
  const uint8_t *p = zip_data_end - sizeof(EocdRecord);
  for (; p >= zip_data->GetBytes() && p >= find_limit; p--) {
    auto eocd = reinterpret_cast<const EocdRecord *>(p);
    if (::memcmp(eocd->signature, EocdRecord::kSignature,
                 sizeof(EocdRecord::kSignature)) == 0) {
      // Found the end of central directory. Sanity check the values.
      if (eocd->cd_records * sizeof(CdRecord) > eocd->cd_size ||
          zip_data->GetBytes() + eocd->cd_offset + eocd->cd_size > p)
        return nullptr;

      // This is a valid end of central directory record.
      return eocd;
    }
  }
  return nullptr;
}

bool GetFile(lldb::DataBufferSP zip_data, uint32_t local_file_header_offset,
             lldb::offset_t &file_offset, lldb::offset_t &file_size) {
  auto local_file_header = reinterpret_cast<const LocalFileHeader *>(
      zip_data->GetBytes() + local_file_header_offset);
  // The signature should match.
  if (::memcmp(local_file_header->signature, LocalFileHeader::kSignature,
               sizeof(LocalFileHeader::kSignature)) != 0)
    return false;

  auto file_data = reinterpret_cast<const uint8_t *>(local_file_header + 1) +
                   local_file_header->file_name_length +
                   local_file_header->extra_field_length;
  // File should be uncompressed.
  if (local_file_header->compressed_size !=
      local_file_header->uncompressed_size)
    return false;

  // This file is valid. Return the file offset and size.
  file_offset = file_data - zip_data->GetBytes();
  file_size = local_file_header->uncompressed_size;
  return true;
}

bool FindFile(lldb::DataBufferSP zip_data, const EocdRecord *eocd,
              const llvm::StringRef file_path, lldb::offset_t &file_offset,
              lldb::offset_t &file_size) {
  // Find the file from the central directory records.
  auto cd = reinterpret_cast<const CdRecord *>(zip_data->GetBytes() +
                                               eocd->cd_offset);
  size_t cd_records = eocd->cd_records;
  for (size_t i = 0; i < cd_records; i++) {
    // The signature should match.
    if (::memcmp(cd->signature, CdRecord::kSignature,
                 sizeof(CdRecord::kSignature)) != 0)
      return false;

    // Sanity check the file name values.
    auto file_name = reinterpret_cast<const char *>(cd + 1);
    size_t file_name_length = cd->file_name_length;
    if (file_name + file_name_length >= reinterpret_cast<const char *>(eocd) ||
        file_name_length == 0)
      return false;

    // Compare the file name.
    if (file_path == llvm::StringRef(file_name, file_name_length)) {
      // Found the file.
      return GetFile(zip_data, cd->local_file_header_offset, file_offset,
                     file_size);
    } else {
      // Skip to the next central directory record.
      cd = reinterpret_cast<const CdRecord *>(
          reinterpret_cast<const char *>(cd) + sizeof(CdRecord) +
          cd->file_name_length + cd->extra_field_length + cd->comment_length);
      // Sanity check the pointer.
      if (reinterpret_cast<const char *>(cd) >=
          reinterpret_cast<const char *>(eocd))
        return false;
    }
  }

  return false;
}

} // end anonymous namespace

bool ZipFile::Find(lldb::DataBufferSP zip_data, const llvm::StringRef file_path,
                   lldb::offset_t &file_offset, lldb::offset_t &file_size) {
  const EocdRecord *eocd = FindEocdRecord(zip_data);
  if (!eocd)
    return false;

  return FindFile(zip_data, eocd, file_path, file_offset, file_size);
}