[J-u-boot.git] / include / fsl_validate.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright 2015 Freescale Semiconductor, Inc.
 */

#ifndef _FSL_VALIDATE_H_
#define _FSL_VALIDATE_H_

#include <fsl_sec.h>
#include <fsl_sec_mon.h>
#include <command.h>
#include <linux/types.h>

#define WORD_SIZE 4

/* Minimum and maximum size of RSA signature length in bits */
#define KEY_SIZE       4096
#define KEY_SIZE_BYTES (KEY_SIZE/8)
#define KEY_SIZE_WORDS (KEY_SIZE_BYTES/(WORD_SIZE))

extern struct jobring jr;

/* Barker code size in bytes */
#define ESBC_BARKER_LEN	4	/* barker code length in ESBC uboot client */
				/* header */

/* No-error return values */
#define ESBC_VALID_HDR	0	/* header is valid */

/* Maximum number of SG entries allowed */
#define MAX_SG_ENTRIES	8

/* Different Header Struct for LS-CH3 */
#ifdef CONFIG_ESBC_HDR_LS
struct fsl_secboot_img_hdr {
	u8 barker[ESBC_BARKER_LEN];	/* barker code */
	u32 srk_tbl_off;
	struct {
		u8 num_srk;
		u8 srk_sel;
		u8 reserve;
	} len_kr;
	u8 ie_flag;

	u32 uid_flag;

	u32 psign;		/* signature offset */
	u32 sign_len;		/* length of the signature in bytes */

	u64 pimg64;		/* 64 bit pointer to ESBC Image */
	u32 img_size;		/* ESBC client image size in bytes */
	u32 ie_key_sel;

	u32 fsl_uid_0;
	u32 fsl_uid_1;
	u32 oem_uid_0;
	u32 oem_uid_1;
	u32 oem_uid_2;
	u32 oem_uid_3;
	u32 oem_uid_4;
	u32 reserved1[3];
};

#ifdef CONFIG_KEY_REVOCATION
/* Srk table and key revocation check */
#define UNREVOCABLE_KEY	8
#define ALIGN_REVOC_KEY 7
#define MAX_KEY_ENTRIES 8
#endif

#if defined(CONFIG_FSL_ISBC_KEY_EXT)
#define IE_FLAG_MASK 0x1
#define SCRATCH_IE_LOW_ADR 13
#define SCRATCH_IE_HIGH_ADR 14
#endif

#else /* CONFIG_ESBC_HDR_LS */

/*
 * ESBC uboot client header structure.
 * The struct contain the following fields
 * barker code
 * public key offset
 * pub key length
 * signature offset
 * length of the signature
 * ptr to SG table
 * no of entries in SG table
 * esbc ptr
 * size of esbc
 * esbc entry point
 * Scatter gather flag
 * UID flag
 * FSL UID
 * OEM UID
 * Here, pub key is modulus concatenated with exponent
 * of equal length
 */
struct fsl_secboot_img_hdr {
	u8 barker[ESBC_BARKER_LEN];	/* barker code */
	union {
		u32 pkey;		/* public key offset */
#ifdef CONFIG_KEY_REVOCATION
		u32 srk_tbl_off;
#endif
	};

	union {
		u32 key_len;		/* pub key length in bytes */
#ifdef CONFIG_KEY_REVOCATION
		struct {
			u32 srk_table_flag:8;
			u32 srk_sel:8;
			u32 num_srk:16;
		} len_kr;
#endif
	};

	u32 psign;		/* signature offset */
	u32 sign_len;		/* length of the signature in bytes */
	union {
		u32 psgtable;	/* ptr to SG table */
#ifndef CONFIG_ESBC_ADDR_64BIT
		u32 pimg;	/* ptr to ESBC client image */
#endif
	};
	union {
		u32 sg_entries;	/* no of entries in SG table */
		u32 img_size;	/* ESBC client image size in bytes */
	};
	u32 img_start;		/* ESBC client entry point */
	u32 sg_flag;		/* Scatter gather flag */
	u32 uid_flag;
	u32 fsl_uid_0;
	u32 oem_uid_0;
	u32 reserved1[2];
	u32 fsl_uid_1;
	u32 oem_uid_1;
	union {
		u32 reserved2[2];
#ifdef CONFIG_ESBC_ADDR_64BIT
		u64 pimg64;	/* 64 bit pointer to ESBC Image */
#endif
	};
	u32 ie_flag;
	u32 ie_key_sel;
};

#ifdef CONFIG_KEY_REVOCATION
/* Srk table and key revocation check */
#define SRK_FLAG	0x01
#define UNREVOCABLE_KEY	4
#define ALIGN_REVOC_KEY 3
#define MAX_KEY_ENTRIES 4
#endif

#if defined(CONFIG_FSL_ISBC_KEY_EXT)
#define IE_FLAG_MASK 0xFFFFFFFF
#endif

#endif /* CONFIG_ESBC_HDR_LS */


#if defined(CONFIG_FSL_ISBC_KEY_EXT)
struct ie_key_table {
	u32 key_len;
	u8 pkey[2 * KEY_SIZE_BYTES];
};

struct ie_key_info {
	uint32_t key_revok;
	uint32_t num_keys;
	struct ie_key_table ie_key_tbl[32];
};
#endif

#ifdef CONFIG_KEY_REVOCATION
struct srk_table {
	u32 key_len;
	u8 pkey[2 * KEY_SIZE_BYTES];
};
#endif

/*
 * SG table.
 */
#if defined(CONFIG_FSL_TRUST_ARCH_v1) && defined(CONFIG_FSL_CORENET)
/*
 * This struct contains the following fields
 * length of the segment
 * source address
 */
struct fsl_secboot_sg_table {
	u32 len;		/* length of the segment in bytes */
	u32 src_addr;		/* ptr to the data segment */
};
#else
/*
 * This struct contains the following fields
 * length of the segment
 * Destination Target ID
 * source address
 * destination address
 */
struct fsl_secboot_sg_table {
	u32 len;
	u32 trgt_id;
	u32 src_addr;
	u32 dst_addr;
};
#endif

/* ESBC global structure.
 * Data to be used across verification of different images.
 * Stores following Data:
 * IE Table
 */
struct fsl_secboot_glb {
#if defined(CONFIG_FSL_ISBC_KEY_EXT)
	uintptr_t ie_addr;
	struct ie_key_info ie_tbl;
#endif
};
/*
 * ESBC private structure.
 * Private structure used by ESBC to store following fields
 * ESBC client key
 * ESBC client key hash
 * ESBC client Signature
 * Encoded hash recovered from signature
 * Encoded hash of ESBC client header plus ESBC client image
 */
struct fsl_secboot_img_priv {
	uint32_t hdr_location;
	uintptr_t ie_addr;
	u32 key_len;
	struct fsl_secboot_img_hdr hdr;

	u8 img_key[2 * KEY_SIZE_BYTES];	/* ESBC client key */
	u8 img_key_hash[32];	/* ESBC client key hash */

#ifdef CONFIG_KEY_REVOCATION
	struct srk_table srk_tbl[MAX_KEY_ENTRIES];
#endif
	u8 img_sign[KEY_SIZE_BYTES];		/* ESBC client signature */

	u8 img_encoded_hash[KEY_SIZE_BYTES];	/* EM wrt RSA PKCSv1.5  */
						/* Includes hash recovered after
						 * signature verification
						 */

	u8 img_encoded_hash_second[KEY_SIZE_BYTES];/* EM' wrt RSA PKCSv1.5 */
						/* Includes hash of
						 * ESBC client header plus
						 * ESBC client image
						 */

	struct fsl_secboot_sg_table sgtbl[MAX_SG_ENTRIES];	/* SG table */
	uintptr_t ehdrloc;	/* ESBC Header location */
	uintptr_t *img_addr_ptr;	/* ESBC Image Location */
	uint32_t img_size;	/* ESBC Image Size */
};

int do_esbc_halt(cmd_tbl_t *cmdtp, int flag, int argc,
				char * const argv[]);

int fsl_secboot_validate(uintptr_t haddr, char *arg_hash_str,
	uintptr_t *img_addr_ptr);
int fsl_secboot_blob_encap(cmd_tbl_t *cmdtp, int flag, int argc,
	char * const argv[]);
int fsl_secboot_blob_decap(cmd_tbl_t *cmdtp, int flag, int argc,
	char * const argv[]);

int fsl_check_boot_mode_secure(void);
int fsl_setenv_chain_of_trust(void);

/*
 * This function is used to validate the main U-boot binary from
 * SPL just before passing control to it using QorIQ Trust
 * Architecture header (appended to U-boot image).
 */
void spl_validate_uboot(uint32_t hdr_addr, uintptr_t img_addr);
#endif
Commit	Line	Data
83d290c5	1	/* SPDX-License-Identifier: GPL-2.0+ */
47151e4b	2	/*
47151e4b	3	* Copyright 2015 Freescale Semiconductor, Inc.
47151e4b	4	*/
	5
	6	#ifndef _FSL_VALIDATE_H_
	7	#define _FSL_VALIDATE_H_
	8
	9	#include <fsl_sec.h>
	10	#include <fsl_sec_mon.h>
	11	#include <command.h>
	12	#include <linux/types.h>
	13
	14	#define WORD_SIZE 4
	15
	16	/* Minimum and maximum size of RSA signature length in bits */
	17	#define KEY_SIZE 4096
	18	#define KEY_SIZE_BYTES (KEY_SIZE/8)
	19	#define KEY_SIZE_WORDS (KEY_SIZE_BYTES/(WORD_SIZE))
	20
	21	extern struct jobring jr;
	22
47151e4b	23	/* Barker code size in bytes */
	24	#define ESBC_BARKER_LEN 4 /* barker code length in ESBC uboot client */
	25	/* header */
	26
	27	/* No-error return values */
	28	#define ESBC_VALID_HDR 0 /* header is valid */
	29
	30	/* Maximum number of SG entries allowed */
	31	#define MAX_SG_ENTRIES 8
	32
fd6dbc98 SJ	33	/* Different Header Struct for LS-CH3 */
	34	#ifdef CONFIG_ESBC_HDR_LS
	35	struct fsl_secboot_img_hdr {
	36	u8 barker[ESBC_BARKER_LEN]; /* barker code */
	37	u32 srk_tbl_off;
	38	struct {
	39	u8 num_srk;
	40	u8 srk_sel;
	41	u8 reserve;
fd6dbc98	42	} len_kr;
ac55dadb	43	u8 ie_flag;
fd6dbc98 SJ	44
	45	u32 uid_flag;
	46
	47	u32 psign; /* signature offset */
	48	u32 sign_len; /* length of the signature in bytes */
	49
	50	u64 pimg64; /* 64 bit pointer to ESBC Image */
	51	u32 img_size; /* ESBC client image size in bytes */
	52	u32 ie_key_sel;
	53
	54	u32 fsl_uid_0;
	55	u32 fsl_uid_1;
	56	u32 oem_uid_0;
	57	u32 oem_uid_1;
	58	u32 oem_uid_2;
	59	u32 oem_uid_3;
	60	u32 oem_uid_4;
	61	u32 reserved1[3];
	62	};
	63
	64	#ifdef CONFIG_KEY_REVOCATION
	65	/* Srk table and key revocation check */
	66	#define UNREVOCABLE_KEY 8
	67	#define ALIGN_REVOC_KEY 7
	68	#define MAX_KEY_ENTRIES 8
	69	#endif
	70
ac55dadb UA	71	#if defined(CONFIG_FSL_ISBC_KEY_EXT)
	72	#define IE_FLAG_MASK 0x1
	73	#define SCRATCH_IE_LOW_ADR 13
	74	#define SCRATCH_IE_HIGH_ADR 14
	75	#endif
fd6dbc98 SJ	76
	77	#else /* CONFIG_ESBC_HDR_LS */
	78
47151e4b	79	/*
	80	* ESBC uboot client header structure.
	81	* The struct contain the following fields
	82	* barker code
	83	* public key offset
	84	* pub key length
	85	* signature offset
	86	* length of the signature
	87	* ptr to SG table
	88	* no of entries in SG table
	89	* esbc ptr
	90	* size of esbc
	91	* esbc entry point
	92	* Scatter gather flag
	93	* UID flag
	94	* FSL UID
	95	* OEM UID
	96	* Here, pub key is modulus concatenated with exponent
	97	* of equal length
	98	*/
	99	struct fsl_secboot_img_hdr {
	100	u8 barker[ESBC_BARKER_LEN]; /* barker code */
	101	union {
	102	u32 pkey; /* public key offset */
	103	#ifdef CONFIG_KEY_REVOCATION
	104	u32 srk_tbl_off;
	105	#endif
	106	};
	107
	108	union {
	109	u32 key_len; /* pub key length in bytes */
	110	#ifdef CONFIG_KEY_REVOCATION
	111	struct {
	112	u32 srk_table_flag:8;
	113	u32 srk_sel:8;
	114	u32 num_srk:16;
	115	} len_kr;
	116	#endif
	117	};
	118
	119	u32 psign; /* signature offset */
	120	u32 sign_len; /* length of the signature in bytes */
	121	union {
7bcb0eb2	122	u32 psgtable; /* ptr to SG table */
9711f528	123	#ifndef CONFIG_ESBC_ADDR_64BIT
7bcb0eb2	124	u32 pimg; /* ptr to ESBC client image */
9711f528	125	#endif
47151e4b	126	};
	127	union {
	128	u32 sg_entries; /* no of entries in SG table */
	129	u32 img_size; /* ESBC client image size in bytes */
	130	};
7bcb0eb2	131	u32 img_start; /* ESBC client entry point */
47151e4b	132	u32 sg_flag; /* Scatter gather flag */
	133	u32 uid_flag;
	134	u32 fsl_uid_0;
	135	u32 oem_uid_0;
	136	u32 reserved1[2];
	137	u32 fsl_uid_1;
	138	u32 oem_uid_1;
9711f528 AB	139	union {
	140	u32 reserved2[2];
	141	#ifdef CONFIG_ESBC_ADDR_64BIT
	142	u64 pimg64; /* 64 bit pointer to ESBC Image */
	143	#endif
	144	};
47151e4b	145	u32 ie_flag;
	146	u32 ie_key_sel;
	147	};
	148
fd6dbc98 SJ	149	#ifdef CONFIG_KEY_REVOCATION
	150	/* Srk table and key revocation check */
	151	#define SRK_FLAG 0x01
	152	#define UNREVOCABLE_KEY 4
	153	#define ALIGN_REVOC_KEY 3
	154	#define MAX_KEY_ENTRIES 4
	155	#endif
	156
ac55dadb UA	157	#if defined(CONFIG_FSL_ISBC_KEY_EXT)
	158	#define IE_FLAG_MASK 0xFFFFFFFF
	159	#endif
	160
fd6dbc98 SJ	161	#endif /* CONFIG_ESBC_HDR_LS */
	162
	163
47151e4b	164	#if defined(CONFIG_FSL_ISBC_KEY_EXT)
	165	struct ie_key_table {
	166	u32 key_len;
	167	u8 pkey[2 * KEY_SIZE_BYTES];
	168	};
	169
	170	struct ie_key_info {
	171	uint32_t key_revok;
	172	uint32_t num_keys;
	173	struct ie_key_table ie_key_tbl[32];
	174	};
	175	#endif
	176
	177	#ifdef CONFIG_KEY_REVOCATION
	178	struct srk_table {
	179	u32 key_len;
	180	u8 pkey[2 * KEY_SIZE_BYTES];
	181	};
	182	#endif
	183
	184	/*
	185	* SG table.
	186	*/
	187	#if defined(CONFIG_FSL_TRUST_ARCH_v1) && defined(CONFIG_FSL_CORENET)
	188	/*
	189	* This struct contains the following fields
	190	* length of the segment
	191	* source address
	192	*/
	193	struct fsl_secboot_sg_table {
	194	u32 len; /* length of the segment in bytes */
7bcb0eb2	195	u32 src_addr; /* ptr to the data segment */
47151e4b	196	};
	197	#else
	198	/*
	199	* This struct contains the following fields
	200	* length of the segment
	201	* Destination Target ID
	202	* source address
	203	* destination address
	204	*/
	205	struct fsl_secboot_sg_table {
	206	u32 len;
	207	u32 trgt_id;
7bcb0eb2 AB	208	u32 src_addr;
7bcb0eb2 AB	209	u32 dst_addr;
47151e4b	210	};
	211	#endif
	212
ac55dadb UA	213	/* ESBC global structure.
ac55dadb UA	214	* Data to be used across verification of different images.
1e994e2f	215	* Stores following Data:
ac55dadb UA	216	* IE Table
	217	*/
	218	struct fsl_secboot_glb {
	219	#if defined(CONFIG_FSL_ISBC_KEY_EXT)
	220	uintptr_t ie_addr;
	221	struct ie_key_info ie_tbl;
	222	#endif
	223	};
47151e4b	224	/*
	225	* ESBC private structure.
	226	* Private structure used by ESBC to store following fields
	227	* ESBC client key
	228	* ESBC client key hash
	229	* ESBC client Signature
	230	* Encoded hash recovered from signature
	231	* Encoded hash of ESBC client header plus ESBC client image
	232	*/
	233	struct fsl_secboot_img_priv {
	234	uint32_t hdr_location;
ac55dadb	235	uintptr_t ie_addr;
47151e4b	236	u32 key_len;
	237	struct fsl_secboot_img_hdr hdr;
	238
	239	u8 img_key[2 * KEY_SIZE_BYTES]; /* ESBC client key */
	240	u8 img_key_hash[32]; /* ESBC client key hash */
	241
	242	#ifdef CONFIG_KEY_REVOCATION
	243	struct srk_table srk_tbl[MAX_KEY_ENTRIES];
	244	#endif
	245	u8 img_sign[KEY_SIZE_BYTES]; /* ESBC client signature */
	246
	247	u8 img_encoded_hash[KEY_SIZE_BYTES]; /* EM wrt RSA PKCSv1.5 */
	248	/* Includes hash recovered after
	249	* signature verification
	250	*/
	251
	252	u8 img_encoded_hash_second[KEY_SIZE_BYTES];/* EM' wrt RSA PKCSv1.5 */
	253	/* Includes hash of
	254	* ESBC client header plus
	255	* ESBC client image
	256	*/
	257
	258	struct fsl_secboot_sg_table sgtbl[MAX_SG_ENTRIES]; /* SG table */
b055a0fd	259	uintptr_t ehdrloc; /* ESBC Header location */
85bb3896	260	uintptr_t img_addr_ptr; / ESBC Image Location */
b055a0fd	261	uint32_t img_size; /* ESBC Image Size */
47151e4b	262	};
47151e4b	263
c4666cf6 SJ	264	int do_esbc_halt(cmd_tbl_t *cmdtp, int flag, int argc,
	265	char * const argv[]);
	266
b055a0fd	267	int fsl_secboot_validate(uintptr_t haddr, char *arg_hash_str,
85bb3896	268	uintptr_t *img_addr_ptr);
47151e4b	269	int fsl_secboot_blob_encap(cmd_tbl_t *cmdtp, int flag, int argc,
	270	char * const argv[]);
	271	int fsl_secboot_blob_decap(cmd_tbl_t *cmdtp, int flag, int argc,
	272	char * const argv[]);
	273
d0412885 AB	274	int fsl_check_boot_mode_secure(void);
d0412885 AB	275	int fsl_setenv_chain_of_trust(void);
8f01397b SG	276
	277	/*
	278	* This function is used to validate the main U-boot binary from
	279	* SPL just before passing control to it using QorIQ Trust
	280	* Architecture header (appended to U-boot image).
	281	*/
	282	void spl_validate_uboot(uint32_t hdr_addr, uintptr_t img_addr);
47151e4b	283	#endif