tests/futility/test_misc.c

/* Copyright 2025 The ChromiumOS Authors
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "unit_tests.h"
#include "updater.h"
#include "cgptlib_internal.h"
#include "file_type.h"
#include "futility_options.h"
#include "host_misc.h"
#include <sys/mman.h>

#define IMAGE_MAIN	 GET_WORK_COPY_TEST_DATA_FILE_PATH("image.bin")
#define FILE_TEMP	 GET_WORK_COPY_TEST_DATA_FILE_PATH("file-temp")
#define FILE_SMALL	 GET_WORK_COPY_TEST_DATA_FILE_PATH("file-small")
#define FILE_NONEXISTENT GET_WORK_COPY_TEST_DATA_FILE_PATH("nonexistent")
#define FILE_READONLY	 GET_WORK_COPY_TEST_DATA_FILE_PATH("read-only")

const char small_data[] = "small";
#define FILE_SMALL_SIZE (ARRAY_SIZE(small_data) - 1)

static enum unit_result prepare_test_data(void)
{
	UNIT_TEST_BEGIN;

	UNIT_ASSERT(system("rm -rf " WORK_COPY_TEST_DATA_DIR) == 0);
	UNIT_ASSERT(system("mkdir -p " WORK_COPY_TEST_DATA_DIR) == 0);

	UNIT_ASSERT(futil_copy_file(GET_SOURCE_TEST_DATA_FILE_PATH("image-steelix.bin"),
				    IMAGE_MAIN) != -1);
	UNIT_ASSERT(vb2_write_file(FILE_SMALL, small_data, FILE_SMALL_SIZE) == VB2_SUCCESS);
	remove(FILE_NONEXISTENT);
	UNIT_ASSERT(system("touch " FILE_READONLY) == 0);
	UNIT_ASSERT(system("chmod 444 " FILE_READONLY) == 0);

unit_cleanup:
	UNIT_TEST_RETURN;
}

static enum unit_result test_gbb(void)
{
	UNIT_TEST_BEGIN;
	struct firmware_image image = {0};
	FmapAreaHeader *ah = NULL;
	uint8_t *ptr = NULL;
	uint32_t maxlen;
	struct vb2_gbb_header *gbb, good_gbb = {0};
	char *str = NULL;

	UNIT_ASSERT(load_firmware_image(&image, IMAGE_MAIN, NULL) == 0);
	ptr = fmap_find_by_name(image.data, image.size, image.fmap_header, "GBB", &ah);
	UNIT_ASSERT(ptr != NULL);
	gbb = (struct vb2_gbb_header *)ptr;
	good_gbb = *gbb;

	TEST_EQ(ft_recognize_gbb(ptr, ah->area_size), FILE_TYPE_GBB,
		"File type recognize GBB: correct");
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, &maxlen), 1,
		"Futil valid GBB header: correct");

	TEST_EQ(ft_recognize_gbb(ptr, sizeof(struct vb2_gbb_header) - 1), FILE_TYPE_UNKNOWN,
		"File type recognize GBB: too small");
	TEST_EQ(futil_valid_gbb_header(gbb, gbb->header_size - 1, NULL), 0,
		"Futil valid GBB header: too small");

	memset(gbb->signature, 0, sizeof(gbb->signature));
	TEST_EQ(ft_recognize_gbb(ptr, ah->area_size), FILE_TYPE_UNKNOWN,
		"File type recognize GBB: invalid signature");
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid signature");

	*gbb = good_gbb;
	gbb->major_version = UINT16_MAX;
	TEST_EQ(ft_recognize_gbb(ptr, ah->area_size), FILE_TYPE_UNKNOWN,
		"File type recognize GBB: invalid major version");
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid major version");

	*gbb = good_gbb;
	gbb->header_size = ah->area_size + 1;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid header_size");

	*gbb = good_gbb;
	gbb->hwid_offset = EXPECTED_VB2_GBB_HEADER_SIZE - 1;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid hwid_offset");

	*gbb = good_gbb;
	gbb->hwid_offset = ah->area_size + 1;
	gbb->hwid_size = 0;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid hwid_offset or hwid_size");

	*gbb = good_gbb;
	gbb->rootkey_offset = ah->area_size + 1;
	gbb->rootkey_size = 0;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid rootkey_offset or rootkey_size");

	*gbb = good_gbb;
	gbb->bmpfv_offset = ah->area_size + 1;
	gbb->bmpfv_size = 0;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid bmpfv_offset or bmpfv_size");

	*gbb = good_gbb;
	gbb->recovery_key_offset = EXPECTED_VB2_GBB_HEADER_SIZE - 1;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid recovery_key_offset");

	*gbb = good_gbb;
	gbb->recovery_key_size = ah->area_size + 1;
	gbb->recovery_key_offset = EXPECTED_VB2_GBB_HEADER_SIZE;
	TEST_EQ(futil_valid_gbb_header(gbb, ah->area_size, NULL), 0,
		"Futil valid GBB header: invalid recovery_key_offset or recovery_key_offset");

	*gbb = good_gbb;
	str = calloc(1, gbb->hwid_size + 2);
	UNIT_ASSERT(str != NULL);
	memset(str, 'X', gbb->hwid_size + 1);
	TEST_EQ(futil_set_gbb_hwid(gbb, str), -1, "Futil set GBB HWID: too big");
	free(str);

	*gbb = good_gbb;
	str = (char *)"M";
	TEST_EQ(futil_set_gbb_hwid(gbb, str), 0, "Futil set GBB HWID: valid");
	TEST_EQ(strncmp((char *)gbb + gbb->hwid_offset, str, 2), 0, "Verifying");

	*gbb = good_gbb;
	gbb->minor_version = 1;
	str = (char *)"N";
	TEST_EQ(futil_set_gbb_hwid(gbb, str), 0, "Futil set GBB HWID: minor < 2");
	TEST_EQ(strncmp((char *)gbb + gbb->hwid_offset, str, 2), 0, "Verifying");

	str = NULL;
unit_cleanup:
	free_firmware_image(&image);
	UNIT_TEST_RETURN;
}

static enum unit_result test_futil_file_helpers(void)
{
	UNIT_TEST_BEGIN;
	int fd = -1;

	TEST_EQ(futil_copy_file(FILE_SMALL, FILE_TEMP), FILE_SMALL_SIZE,
		"Futil copy file: valid");
	TEST_NEQ(futil_copy_file(FILE_NONEXISTENT, FILE_TEMP), 0,
		 "Futil copy file: nonexistent");
	TEST_NEQ(futil_copy_file(FILE_TEMP, FILE_READONLY), 0, "Futil copy file: invalid");

	TEST_EQ(futil_open_file(FILE_TEMP, &fd, FILE_RW), FILE_ERR_NONE, "Futil open file: rw");
	TEST_TRUE(fd >= 0, "Verifying fd");
	TEST_EQ(futil_close_file(fd), FILE_ERR_NONE, "Futil close file: rw");
	TEST_EQ(futil_open_file(FILE_NONEXISTENT, &fd, FILE_RW), FILE_ERR_OPEN,
		"Futil open file: rw nonexistent");

	fd = -1;
	TEST_EQ(futil_open_file(FILE_TEMP, &fd, FILE_RO), FILE_ERR_NONE, "Futil open file: ro");
	TEST_TRUE(fd >= 0, "Verifying fd");
	TEST_EQ(futil_close_file(fd), FILE_ERR_NONE, "Futil close file: ro");
	TEST_EQ(futil_open_file(FILE_NONEXISTENT, &fd, FILE_RO), FILE_ERR_OPEN,
		"Futil open file: ro nonexistent");

	fd = -1;
	UNIT_ASSERT(futil_open_file(FILE_TEMP, &fd, FILE_RW) == FILE_ERR_NONE);
	TEST_TRUE(fd >= 0, "Verifying fd");
	UNIT_ASSERT(futil_close_file(fd) == FILE_ERR_NONE);
	TEST_EQ(futil_close_file(fd), FILE_ERR_CLOSE, "Futil close file: invalid");

unit_cleanup:
	UNIT_TEST_RETURN;
}

static enum unit_result test_files_mmap(void)
{
	UNIT_TEST_BEGIN;
	int fd = -1;
	uint8_t *data = NULL;
	uint32_t size = 0;

	TEST_EQ(futil_map_file(-1, FILE_RO, &data, &size), FILE_ERR_STAT,
		"Futil map file: invalid fd");

	fd = -1;
	data = NULL;
	size = 0;
	UNIT_ASSERT(futil_open_file(FILE_TEMP, &fd, FILE_RO) == FILE_ERR_NONE);
	TEST_TRUE(fd >= 0, "Verifying fd");
	TEST_EQ(futil_map_file(fd, FILE_RO, &data, &size), FILE_ERR_NONE, "Futil map file");
	TEST_EQ(futil_unmap_file(fd, FILE_RO, data, size), FILE_ERR_NONE, "Futil unmap file");
	UNIT_ASSERT(futil_close_file(fd) == FILE_ERR_NONE);

	fd = -1;
	data = NULL;
	size = 0;
	TEST_NEQ(futil_open_and_map_file(FILE_NONEXISTENT, &fd, FILE_RO, &data, &size),
		 FILE_ERR_NONE, "Futil open and map file: nonexistent");

	fd = -1;
	data = NULL;
	size = 0;
	TEST_EQ(futil_open_and_map_file(FILE_TEMP, &fd, FILE_RO, &data, &size), FILE_ERR_NONE,
		"Futil open and map file");
	TEST_TRUE(fd >= 0, "Verifying fd");
	TEST_EQ(futil_unmap_and_close_file(fd, FILE_RO, data, size), FILE_ERR_NONE,
		"Futil unmap and close file");
	TEST_NEQ(futil_unmap_and_close_file(fd, FILE_RO, data, size), FILE_ERR_NONE,
		 "Futil unmap and close file: invalid fd");

unit_cleanup:
	UNIT_TEST_RETURN;
}

static enum unit_result test_misc(void)
{
	UNIT_TEST_BEGIN;
	size_t len = 4096;
	uint8_t *ptr = malloc(4096);
	GptHeader *h = (GptHeader *)(ptr + 512);
	uint8_t *data = (uint8_t *)strdup("test");

	UNIT_ASSERT(ptr != NULL && data != NULL);

	/* Pretend we have a valid GPT. */
	memcpy(h->signature, GPT_HEADER_SIGNATURE2, GPT_HEADER_SIGNATURE_SIZE);
	h->revision = GPT_HEADER_REVISION;
	h->size = MIN_SIZE_OF_HEADER + 1;
	h->header_crc32 = HeaderCrc(h);

	TEST_EQ(ft_recognize_gpt(ptr, len), FILE_TYPE_CHROMIUMOS_DISK,
		"File type recognize GPT: valid");

	memcpy(h->signature, "12345678", GPT_HEADER_SIGNATURE_SIZE);
	TEST_EQ(ft_recognize_gpt(ptr, len), FILE_TYPE_UNKNOWN,
		"File type recognize GPT: invalid signature");
	memcpy(h->signature, GPT_HEADER_SIGNATURE2, GPT_HEADER_SIGNATURE_SIZE);

	h->revision = ~GPT_HEADER_REVISION;
	TEST_EQ(ft_recognize_gpt(ptr, len), FILE_TYPE_UNKNOWN,
		"File type recognize GPT: invalid revision");
	h->revision = GPT_HEADER_REVISION;

	h->size = MAX_SIZE_OF_HEADER + 1;
	TEST_EQ(ft_recognize_gpt(ptr, len), FILE_TYPE_UNKNOWN,
		"File type recognize GPT: invalid size");
	h->size = MIN_SIZE_OF_HEADER + 1;

	h->header_crc32 = ~h->header_crc32; /* To change the checksum. */
	TEST_EQ(ft_recognize_gpt(ptr, len), FILE_TYPE_UNKNOWN,
		"File type recognize GPT: invalid crc32");

	len = strlen((char *)data);

	TEST_NEQ(write_to_file("test", FILE_READONLY, data, len), 0,
		 "Write to file: invalid file");
	TEST_EQ(write_to_file("test", FILE_TEMP, data, 0), 0, "Write to file: zero bytes");
	TEST_EQ(write_to_file("test", FILE_TEMP, data, len), 0, "Write to file: valid");

unit_cleanup:
	free(data);
	free(ptr);
	UNIT_TEST_RETURN;
}

int main(int argc, char *argv[])
{
	if (prepare_test_data() == UNIT_FAIL) {
		ERROR("Failed to prepare data.\n");
		return 1;
	}

	test_gbb();
	test_futil_file_helpers();
	test_files_mmap();
	test_misc();

	return !gTestSuccess;
}