/third_party/crashpad/crashpad/util/ios/ios_intermediate_dump_reader_test.cc

// Copyright 2021 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "util/ios/ios_intermediate_dump_reader.h"

#include <fcntl.h>
#include <mach/vm_map.h>

#include "base/posix/eintr_wrapper.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "test/errors.h"
#include "test/scoped_temp_dir.h"
#include "util/file/filesystem.h"
#include "util/ios/ios_intermediate_dump_data.h"
#include "util/ios/ios_intermediate_dump_format.h"
#include "util/ios/ios_intermediate_dump_list.h"
#include "util/ios/ios_intermediate_dump_writer.h"

namespace crashpad {
namespace test {
namespace {

using Key = internal::IntermediateDumpKey;
using Result = internal::IOSIntermediateDumpReaderInitializeResult;
using internal::IOSIntermediateDumpWriter;

class IOSIntermediateDumpReaderTest : public testing::Test {
 protected:
  // testing::Test:

  void SetUp() override {
    path_ = temp_dir_.path().Append("dump_file");
    fd_ = base::ScopedFD(HANDLE_EINTR(
        ::open(path_.value().c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644)));
    ASSERT_GE(fd_.get(), 0) << ErrnoMessage("open");

    writer_ = std::make_unique<IOSIntermediateDumpWriter>();
    ASSERT_TRUE(writer_->Open(path_));
    ASSERT_TRUE(IsRegularFile(path_));
    dump_interface_.Initialize(path_);
  }

  void TearDown() override {
    ASSERT_TRUE(writer_->Close());
    fd_.reset();
    writer_.reset();
    EXPECT_FALSE(IsRegularFile(path_));
  }

  int fd() { return fd_.get(); }

  const base::FilePath& path() const { return path_; }
  const auto& dump_interface() const { return dump_interface_; }

  std::unique_ptr<IOSIntermediateDumpWriter> writer_;

 private:
  base::ScopedFD fd_;
  ScopedTempDir temp_dir_;
  base::FilePath path_;
  internal::IOSIntermediateDumpFilePath dump_interface_;
};

TEST_F(IOSIntermediateDumpReaderTest, ReadNoFile) {
  internal::IOSIntermediateDumpReader reader;
  internal::IOSIntermediateDumpFilePath dump_interface;
  EXPECT_FALSE(dump_interface.Initialize(base::FilePath()));
  EXPECT_FALSE(IsRegularFile(path()));
}

TEST_F(IOSIntermediateDumpReaderTest, ReadEmptyFile) {
  internal::IOSIntermediateDumpReader reader;
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kFailure);
  EXPECT_FALSE(IsRegularFile(path()));
}

TEST_F(IOSIntermediateDumpReaderTest, ReadHelloWorld) {
  std::string hello_world("hello world.");
  EXPECT_TRUE(
      LoggingWriteFile(fd(), hello_world.c_str(), hello_world.length()));
  internal::IOSIntermediateDumpReader reader;
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kIncomplete);
  EXPECT_FALSE(IsRegularFile(path()));

  const auto root_map = reader.RootMap();
  EXPECT_TRUE(root_map->empty());
}

TEST_F(IOSIntermediateDumpReaderTest, FuzzTestCases) {
  constexpr uint8_t fuzz1[] = {0x6,
                               0x5,
                               0x0,
                               0xff,
                               0xff,
                               0xfd,
                               0x1,
                               0xff,
                               0xff,
                               0xff,
                               0xff,
                               0xff,
                               0xfd,
                               0x1,
                               0x7,
                               0x16};

  internal::IOSIntermediateDumpByteArray dump_interface(fuzz1, sizeof(fuzz1));
  internal::IOSIntermediateDumpReader reader;
  EXPECT_EQ(reader.Initialize(dump_interface), Result::kIncomplete);
  const auto root_map = reader.RootMap();
  EXPECT_TRUE(root_map->empty());
}

TEST_F(IOSIntermediateDumpReaderTest, WriteBadPropertyDataLength) {
  internal::IOSIntermediateDumpReader reader;
  IOSIntermediateDumpWriter::CommandType command_type =
      IOSIntermediateDumpWriter::CommandType::kRootMapStart;
  EXPECT_TRUE(LoggingWriteFile(fd(), &command_type, sizeof(command_type)));

  command_type = IOSIntermediateDumpWriter::CommandType::kProperty;
  EXPECT_TRUE(LoggingWriteFile(fd(), &command_type, sizeof(command_type)));
  Key key = Key::kVersion;
  EXPECT_TRUE(LoggingWriteFile(fd(), &key, sizeof(key)));
  uint8_t value = 1;
  size_t value_length = 999999;
  EXPECT_TRUE(LoggingWriteFile(fd(), &value_length, sizeof(size_t)));
  EXPECT_TRUE(LoggingWriteFile(fd(), &value, sizeof(value)));
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kIncomplete);
  EXPECT_FALSE(IsRegularFile(path()));

  const auto root_map = reader.RootMap();
  EXPECT_TRUE(root_map->empty());
  const auto version_data = root_map->GetAsData(Key::kVersion);
  EXPECT_EQ(version_data, nullptr);
}

TEST_F(IOSIntermediateDumpReaderTest, InvalidArrayInArray) {
  internal::IOSIntermediateDumpReader reader;
  {
    IOSIntermediateDumpWriter::ScopedRootMap scopedRoot(writer_.get());
    IOSIntermediateDumpWriter::ScopedArray threadArray(writer_.get(),
                                                       Key::kThreads);
    IOSIntermediateDumpWriter::ScopedArray innerThreadArray(writer_.get(),
                                                            Key::kModules);

    // Write version last, so it's not parsed.
    int8_t version = 1;
    writer_->AddProperty(Key::kVersion, &version);
  }
  EXPECT_TRUE(writer_->Close());
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kIncomplete);
  EXPECT_FALSE(IsRegularFile(path()));

  const auto root_map = reader.RootMap();
  EXPECT_FALSE(root_map->empty());
  const auto version_data = root_map->GetAsData(Key::kVersion);
  EXPECT_EQ(version_data, nullptr);
}

TEST_F(IOSIntermediateDumpReaderTest, InvalidPropertyInArray) {
  internal::IOSIntermediateDumpReader reader;

  {
    IOSIntermediateDumpWriter::ScopedRootMap scopedRoot(writer_.get());
    IOSIntermediateDumpWriter::ScopedArray threadArray(writer_.get(),
                                                       Key::kThreads);

    // Write version last, so it's not parsed.
    int8_t version = 1;
    writer_->AddProperty(Key::kVersion, &version);
  }
  EXPECT_TRUE(writer_->Close());
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kIncomplete);
  EXPECT_FALSE(IsRegularFile(path()));

  const auto root_map = reader.RootMap();
  EXPECT_FALSE(root_map->empty());
  const auto version_data = root_map->GetAsData(Key::kVersion);
  EXPECT_EQ(version_data, nullptr);
}

TEST_F(IOSIntermediateDumpReaderTest, ReadValidData) {
  internal::IOSIntermediateDumpReader reader;
  uint8_t version = 1;
  {
    IOSIntermediateDumpWriter::ScopedRootMap scopedRoot(writer_.get());
    EXPECT_TRUE(writer_->AddProperty(Key::kVersion, &version));
    {
      IOSIntermediateDumpWriter::ScopedArray threadArray(
          writer_.get(), Key::kThreadContextMemoryRegions);
      IOSIntermediateDumpWriter::ScopedArrayMap threadMap(writer_.get());

      std::string random_data("random_data");
      EXPECT_TRUE(writer_->AddProperty(Key::kThreadContextMemoryRegionAddress,
                                       &version));
      EXPECT_TRUE(writer_->AddProperty(Key::kThreadContextMemoryRegionData,
                                       random_data.c_str(),
                                       random_data.length()));
    }

    {
      IOSIntermediateDumpWriter::ScopedMap map(writer_.get(),
                                               Key::kProcessInfo);
      pid_t p_pid = getpid();
      EXPECT_TRUE(writer_->AddProperty(Key::kPID, &p_pid));
    }
  }

  EXPECT_TRUE(writer_->Close());
  EXPECT_EQ(reader.Initialize(dump_interface()), Result::kSuccess);
  EXPECT_FALSE(IsRegularFile(path()));

  auto root_map = reader.RootMap();
  EXPECT_FALSE(root_map->empty());
  version = -1;
  const auto version_data = root_map->GetAsData(Key::kVersion);
  ASSERT_NE(version_data, nullptr);
  EXPECT_TRUE(version_data->GetValue<uint8_t>(&version));
  EXPECT_EQ(version, 1);

  const auto process_info = root_map->GetAsMap(Key::kProcessInfo);
  ASSERT_NE(process_info, nullptr);
  const auto pid_data = process_info->GetAsData(Key::kPID);
  ASSERT_NE(pid_data, nullptr);
  pid_t p_pid = -1;
  EXPECT_TRUE(pid_data->GetValue<pid_t>(&p_pid));
  ASSERT_EQ(p_pid, getpid());

  const auto thread_context_memory_regions =
      root_map->GetAsList(Key::kThreadContextMemoryRegions);
  EXPECT_EQ(thread_context_memory_regions->size(), 1UL);
  for (const auto& region : *thread_context_memory_regions) {
    const auto data = region->GetAsData(Key::kThreadContextMemoryRegionData);
    ASSERT_NE(data, nullptr);
    // Load as string.
    EXPECT_EQ(data->GetString(), "random_data");

    // Load as bytes.
    auto bytes = data->bytes();
    vm_size_t data_size = bytes.size();
    EXPECT_EQ(data_size, 11UL);

    const char* data_bytes = reinterpret_cast<const char*>(bytes.data());
    EXPECT_EQ(std::string(data_bytes, data_size), "random_data");
  }

  const auto system_info = root_map->GetAsMap(Key::kSystemInfo);
  EXPECT_EQ(system_info, nullptr);
}

}  // namespace
}  // namespace test
}  // namespace crashpad