zircon/system/ulib/zbitl/test/checking-tests.cc

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <lib/zbitl/checking.h>
#include <lib/zbitl/view.h>

#include <gtest/gtest.h>

// Meant for fitx::result<std::string_view>.
#define EXPECT_IS_OK(result) \
  EXPECT_TRUE(result.is_ok()) << "unexpected error: " << result.error_value().data()
#define EXPECT_IS_ERROR(result) EXPECT_TRUE(result.is_error())
// Meant for fitx::result<zbitl::View::Error>.
#define EXPECT_VIEW_IS_OK(result) \
  EXPECT_TRUE(result.is_ok()) << "unexpected error: " << result.error_value().zbi_error

namespace {

using ByteView = std::basic_string_view<const uint8_t>;

constexpr uint32_t kKernelType = 1u;
constexpr uint32_t kBootfsType = 2u;
constexpr uint32_t kMiscType = 3u;

static constexpr zbi_header_t kValidItemHeader = {
    .length = ZBI_ALIGNMENT,
    .flags = ZBI_FLAG_VERSION | ZBI_FLAG_CRC32,
    .magic = ZBI_ITEM_MAGIC,
    .crc32 = 123,
};

static constexpr zbi_header_t kValidContainerHeader = ZBI_CONTAINER_HEADER(0);

inline void CheckTwoItemZbi(uint32_t type1, uint32_t type2, bool expect_ok) {
  constexpr size_t kPayloadSize = ZBI_ALIGNMENT;
  struct TwoItemZbi {
    struct Item {
      alignas(ZBI_ALIGNMENT) zbi_header_t header;
      uint8_t payload[kPayloadSize];
    };
    alignas(ZBI_ALIGNMENT) zbi_header_t header;
    Item items[2];
  };

  const TwoItemZbi contents = {
      .header = ZBI_CONTAINER_HEADER(sizeof(contents.items)),
      .items =
          {
              {
                  .header = zbitl::SanitizeHeader({.type = type1, .length = kPayloadSize}),
              },
              {
                  .header = zbitl::SanitizeHeader({.type = type2, .length = kPayloadSize}),
              },
          },
  };

  ByteView bytes(reinterpret_cast<const uint8_t*>(&contents), sizeof(contents));
  zbitl::View<ByteView> zbi(bytes);
  auto result = zbitl::CheckComplete(zbi, kKernelType, kBootfsType);
  if (expect_ok) {
    EXPECT_IS_OK(result);
  } else {
    EXPECT_IS_ERROR(result);
  }
  EXPECT_VIEW_IS_OK(zbi.take_error());
}

// The set of states of interest here is the product of
//  * kernel item states = { first, present but not first, not present }
// with
//  * bootfs item states = { present, not present }
// Only (first, present) should result in a complete ZBI (all else being
// equal).
TEST(ZbitlCompletenessTest, CompleteZbi) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kKernelType, kBootfsType, true));
}

TEST(ZbitlCompletenessTest, BootfsMissing) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kKernelType, kMiscType, false));
}

TEST(ZbitlCompletenessTest, KernelNotFirst) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kBootfsType, kKernelType, false));
}

TEST(ZbitlCompletenessTest, KernelNotFirstAndBootfsMissing) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kMiscType, kKernelType, false));
}

TEST(ZbitlCompletenessTest, KernelMissing) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kMiscType, kBootfsType, false));
}

TEST(ZbitlCompletenessTest, KernelAndBootfsMissing) {
  ASSERT_NO_FATAL_FAILURE(CheckTwoItemZbi(kMiscType, kMiscType, false));
}

TEST(ZbitlHeaderTest, ItemMagicAndFlagsMissing) {
  // * Item fits, but magic, required flags and CRC are unset.
  // Expectation: failure.
  zbi_header_t header = kValidItemHeader;
  header.flags = 0u;
  header.magic = 0u;
  header.crc32 = 0u;

  EXPECT_IS_ERROR(zbitl::CheckItemHeader(header));
}

TEST(ZbitlHeaderTest, ValidItemHeader) {
  // * Item fits, magic is correct, and required flags and CRC are set.
  // Expectation: success.
  EXPECT_IS_OK(zbitl::CheckItemHeader(kValidItemHeader));
}

TEST(ZbitlHeaderTest, ItemCrcIsMissing) {
  // * Item fits, magic is correct, required flags are set, and CRC is missing.
  // Expectation: failure.
  zbi_header_t header = kValidItemHeader;
  header.flags = ZBI_ITEM_NO_CRC32;
  EXPECT_IS_OK(zbitl::CheckItemHeader(header));
}

TEST(ZbitlHeaderTest, ItemFlagsMissing) {
  // * Item fits, magic is correct, required flags are missing, and CRC is set.
  // Expectation: failure.
  zbi_header_t header = kValidItemHeader;
  header.flags = 0u;
  EXPECT_IS_ERROR(zbitl::CheckItemHeader(header));
}

TEST(ZbitlHeaderTest, ValidContainerHeader) {
  EXPECT_IS_OK(zbitl::CheckContainerHeader(kValidContainerHeader));
}

TEST(ZbitlHeaderTest, ContainerMagicMissing) {
  // A container header requires both item and container magic to be set.
  {
    zbi_header_t header = kValidContainerHeader;
    header.magic = 0u;
    EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
  }
  {
    zbi_header_t header = kValidContainerHeader;
    header.extra = 0u;  // Holds container magic
    EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
  }
}

TEST(ZbitlHeaderTest, ContainerFlagsMissing) {
  zbi_header_t header = kValidContainerHeader;
  header.flags = 0u;
  EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
}

TEST(ZbitlHeaderTest, BadContainerType) {
  // Must be ZBI_TYPE_CONTAINER.
  zbi_header_t header = kValidContainerHeader;
  header.type = ZBI_TYPE_IMAGE_ARGS;
  EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
}

TEST(ZbitlHeaderTest, ContainerCrc) {
  // No CRC flag must be set.
  zbi_header_t header = kValidContainerHeader;
  header.flags |= ZBI_FLAG_CRC32;
  EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
}

TEST(ZbitlHeaderTest, UnalignedContainerLength) {
  // Must be ZBI_ALIGNMENT-aligned.
  zbi_header_t header = kValidContainerHeader;
  header.length = ZBI_ALIGNMENT - 1;
  EXPECT_IS_ERROR(zbitl::CheckContainerHeader(header));
}

}  // namespace