start over

/*

 * (C) Copyright 2008 Semihalf

 *

 * SPDX-License-Identifier:	GPL-2.0+

 */

#ifndef __FDT_HOST_H__

#define __FDT_HOST_H__

/* Make sure to include u-boot version of libfdt include files */

#include "../include/libfdt.h"

#include "../include/fdt_support.h"

/**

 * fdt_remove_unused_strings() - Remove any unused strings from an FDT

 *

 * This creates a new device tree in @new with unused strings removed. The

 * called can then use fdt_pack() to minimise the space consumed.

 *

 * @old:	Old device tree blog

 * @new:	Place to put new device tree blob, which must be as large as

 *		@old

 * @return

 *	0, on success

 *	-FDT_ERR_BADOFFSET, corrupt device tree

 *	-FDT_ERR_NOSPACE, out of space, which should not happen unless there

 *		is something very wrong with the device tree input

 */

int fdt_remove_unused_strings(const void *old, void *new);

int fit_check_sign(const void *working_fdt, const void *key);

#endif /* __FDT_HOST_H__ */

/*

 * (C) Copyright 2014

 * DENX Software Engineering

 * Heiko Schocher <hs@denx.de>

 *

 * Based on:

 * (C) Copyright 2008 Semihalf

 *

 * (C) Copyright 2000-2004

 * DENX Software Engineering

 * Wolfgang Denk, wd@denx.de

 *

 * Updated-by: Prafulla Wadaskar <prafulla@marvell.com>

 *		FIT image specific code abstracted from mkimage.c

 *		some functions added to address abstraction

 *

 * All rights reserved.

 *

 * SPDX-License-Identifier:	GPL-2.0+

 */

#include "mkimage.h"

#include "fit_common.h"

#include <image.h>

#include <u-boot/crc.h>

void usage(char *cmdname)

{

	fprintf(stderr, "Usage: %s -f fit file -k key file\n"

			 "          -f ==> set fit file which should be checked'\n"

			 "          -k ==> set key file which contains the key'\n",

		cmdname);

	exit(EXIT_FAILURE);

}

int main(int argc, char **argv)

{

	int ffd = -1;

	int kfd = -1;

	struct stat fsbuf;

	struct stat ksbuf;

	void *fit_blob;

	char *fdtfile = NULL;

	char *keyfile = NULL;

	char cmdname[256];

	int ret;

	void *key_blob;

	int c;

	strncpy(cmdname, *argv, sizeof(cmdname) - 1);

	cmdname[sizeof(cmdname) - 1] = '\0';

	while ((c = getopt(argc, argv, "f:k:")) != -1)

		switch (c) {

		case 'f':

			fdtfile = optarg;

			break;

		case 'k':

			keyfile = optarg;

			break;

		default:

			usage(cmdname);

			break;

	}

	if (!fdtfile) {

		fprintf(stderr, "%s: Missing fdt file\n", *argv);

		usage(*argv);

	}

	if (!keyfile) {

		fprintf(stderr, "%s: Missing key file\n", *argv);

		usage(*argv);

	}

	ffd = mmap_fdt(cmdname, fdtfile, 0, &fit_blob, &fsbuf, false);

	if (ffd < 0)

		return EXIT_FAILURE;

	kfd = mmap_fdt(cmdname, keyfile, 0, &key_blob, &ksbuf, false);

	if (kfd < 0)

		return EXIT_FAILURE;

	image_set_host_blob(key_blob);

	ret = fit_check_sign(fit_blob, key_blob);

	if (!ret) {

		ret = EXIT_SUCCESS;

		fprintf(stderr, "Signature check OK\n");

	} else {

		ret = EXIT_FAILURE;

		fprintf(stderr, "Signature check Bad (error %d)\n", ret);

	}

	(void) munmap((void *)fit_blob, fsbuf.st_size);

	(void) munmap((void *)key_blob, ksbuf.st_size);

	close(ffd);

	close(kfd);

	exit(ret);

}

/*

 * (C) Copyright 2014

 * DENX Software Engineering

 * Heiko Schocher <hs@denx.de>

 *

 * (C) Copyright 2008 Semihalf

 *

 * (C) Copyright 2000-2004

 * DENX Software Engineering

 * Wolfgang Denk, wd@denx.de

 *

 * Updated-by: Prafulla Wadaskar <prafulla@marvell.com>

 *		FIT image specific code abstracted from mkimage.c

 *		some functions added to address abstraction

 *

 * All rights reserved.

 *

 * SPDX-License-Identifier:	GPL-2.0+

 */

#include "imagetool.h"

#include "mkimage.h"

#include "fit_common.h"

#include <image.h>

#include <u-boot/crc.h>

int fit_verify_header(unsigned char *ptr, int image_size,

			struct image_tool_params *params)

{

	return fdt_check_header(ptr);

}

int fit_check_image_types(uint8_t type)

{

	if (type == IH_TYPE_FLATDT)

		return EXIT_SUCCESS;

	else

		return EXIT_FAILURE;

}

int mmap_fdt(const char *cmdname, const char *fname, size_t size_inc,

	     void **blobp, struct stat *sbuf, bool delete_on_error)

{

	void *ptr;

	int fd;

	/* Load FIT blob into memory (we need to write hashes/signatures) */

	fd = open(fname, O_RDWR | O_BINARY);

	if (fd < 0) {

		fprintf(stderr, "%s: Can't open %s: %s\n",

			cmdname, fname, strerror(errno));

		goto err;

	}

	if (fstat(fd, sbuf) < 0) {

		fprintf(stderr, "%s: Can't stat %s: %s\n",

			cmdname, fname, strerror(errno));

		goto err;

	}

	if (size_inc) {

		sbuf->st_size += size_inc;

		if (ftruncate(fd, sbuf->st_size)) {

			fprintf(stderr, "%s: Can't expand %s: %s\n",

				cmdname, fname, strerror(errno));

		goto err;

		}

	}

	errno = 0;

	ptr = mmap(0, sbuf->st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

	if ((ptr == MAP_FAILED) || (errno != 0)) {

		fprintf(stderr, "%s: Can't read %s: %s\n",

			cmdname, fname, strerror(errno));

		goto err;

	}

	/* check if ptr has a valid blob */

	if (fdt_check_header(ptr)) {

		fprintf(stderr, "%s: Invalid FIT blob\n", cmdname);

		goto err;

	}

	/* expand if needed */

	if (size_inc) {

		int ret;

		ret = fdt_open_into(ptr, ptr, sbuf->st_size);

		if (ret) {

			fprintf(stderr, "%s: Cannot expand FDT: %s\n",

				cmdname, fdt_strerror(ret));

			goto err;

		}

	}

	*blobp = ptr;

	return fd;

err:

	if (fd >= 0)

		close(fd);

	if (delete_on_error)

		unlink(fname);

	return -1;

}

/*

 * (C) Copyright 2014

 *

 * SPDX-License-Identifier:	GPL-2.0+

 */

#ifndef _FIT_COMMON_H_

#define _FIT_COMMON_H_

#include "imagetool.h"

#include "mkimage.h"

#include <image.h>

int fit_verify_header(unsigned char *ptr, int image_size,

			struct image_tool_params *params);

int fit_check_image_types(uint8_t type);

/**

 * Map an FDT into memory, optionally increasing its size

 *

 * @cmdname:	Tool name (for displaying with error messages)

 * @fname:	Filename containing FDT

 * @size_inc:	Amount to increase size by (0 = leave it alone)

 * @blobp:	Returns pointer to FDT blob

 * @sbuf:	File status information is stored here

 * @delete_on_error:	true to delete the file if we get an error

 * @return 0 if OK, -1 on error.

 */

int mmap_fdt(const char *cmdname, const char *fname, size_t size_inc,

	     void **blobp, struct stat *sbuf, bool delete_on_error);

#endif /* _FIT_COMMON_H_ */