]> git.ipfire.org Git - people/ms/u-boot.git/blame - board/freescale/common/fsl_validate.c
projects / people / ms / u-boot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.denx.de/u-boot-sunxi
[people/ms/u-boot.git] / board / freescale / common / fsl_validate.c
CommitLineData
47151e4b 1/*
2 * Copyright 2015 Freescale Semiconductor, Inc.
3 *
4 * SPDX-License-Identifier: GPL-2.0+
5 */
6
7#include <common.h>
9d922450 8#include <dm.h>
47151e4b 9#include <fsl_validate.h>
10#include <fsl_secboot_err.h>
11#include <fsl_sfp.h>
12#include <fsl_sec.h>
13#include <command.h>
14#include <malloc.h>
47151e4b 15#include <u-boot/rsa-mod-exp.h>
16#include <hash.h>
17#include <fsl_secboot_err.h>
73fb5838 18#ifdef CONFIG_ARCH_LS1021A
47151e4b 19#include <asm/arch/immap_ls102xa.h>
20#endif
21
22#define SHA256_BITS 256
23#define SHA256_BYTES (256/8)
24#define SHA256_NIBBLES (256/4)
25#define NUM_HEX_CHARS (sizeof(ulong) * 2)
26
94ba5e41
AB		 27#define CHECK_KEY_LEN(key_len) (((key_len) == 2 * KEY_SIZE_BYTES / 4) || \
28 ((key_len) == 2 * KEY_SIZE_BYTES / 2) || \
29 ((key_len) == 2 * KEY_SIZE_BYTES))
ac55dadb
UA		 30#if defined(CONFIG_FSL_ISBC_KEY_EXT)
31/* Global data structure */
32static struct fsl_secboot_glb glb;
33#endif
94ba5e41 34
47151e4b 35/* This array contains DER value for SHA-256 */
36static const u8 hash_identifier[] = { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60,
37 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05, 0x00,
38 0x04, 0x20
39 };
40
41static u8 hash_val[SHA256_BYTES];
fd6dbc98
SJ		 42
43#ifdef CONFIG_ESBC_HDR_LS
44/* New Barker Code for LS ESBC Header */
45static const u8 barker_code[ESBC_BARKER_LEN] = { 0x12, 0x19, 0x20, 0x01 };
46#else
47151e4b 47static const u8 barker_code[ESBC_BARKER_LEN] = { 0x68, 0x39, 0x27, 0x81 };
fd6dbc98 48#endif
47151e4b 49
50void branch_to_self(void) __attribute__ ((noreturn));
51
52/*
53 * This function will put core in infinite loop.
54 * This will be called when the ESBC can not proceed further due
55 * to some unknown errors.
56 */
57void branch_to_self(void)
58{
59 printf("Core is in infinite loop due to errors.\n");
60self:
61 goto self;
62}
63
64#if defined(CONFIG_FSL_ISBC_KEY_EXT)
65static u32 check_ie(struct fsl_secboot_img_priv *img)
66{
ac55dadb 67 if (img->hdr.ie_flag & IE_FLAG_MASK)
47151e4b 68 return 1;
69
70 return 0;
71}
72
73/* This function returns the CSF Header Address of uboot
74 * For MPC85xx based platforms, the LAW mapping for NOR
75 * flash changes in uboot code. Hence the offset needs
76 * to be calculated and added to the new NOR flash base
77 * address
78 */
79#if defined(CONFIG_MPC85xx)
7bcb0eb2 80int get_csf_base_addr(u32 *csf_addr, u32 *flash_base_addr)
47151e4b 81{
82 struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
83 u32 csf_hdr_addr = in_be32(&gur->scratchrw[0]);
84 u32 csf_flash_offset = csf_hdr_addr & ~(CONFIG_SYS_PBI_FLASH_BASE);
7bcb0eb2 85 u32 flash_addr, addr;
47151e4b 86 int found = 0;
87 int i = 0;
88
89 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
90 flash_addr = flash_info[i].start[0];
91 addr = flash_info[i].start[0] + csf_flash_offset;
92 if (memcmp((u8 *)addr, barker_code, ESBC_BARKER_LEN) == 0) {
7bcb0eb2 93 debug("Barker found on addr %x\n", addr);
47151e4b 94 found = 1;
95 break;
96 }
97 }
98
99 if (!found)
100 return -1;
101
102 *csf_addr = addr;
103 *flash_base_addr = flash_addr;
104
105 return 0;
106}
107#else
108/* For platforms like LS1020, correct flash address is present in
109 * the header. So the function reqturns flash base address as 0
110 */
7bcb0eb2 111int get_csf_base_addr(u32 *csf_addr, u32 *flash_base_addr)
47151e4b 112{
113 struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
114 u32 csf_hdr_addr = in_be32(&gur->scratchrw[0]);
115
9711f528
AB		 116 if (memcmp((u8 *)(uintptr_t)csf_hdr_addr,
117 barker_code, ESBC_BARKER_LEN))
47151e4b 118 return -1;
119
120 *csf_addr = csf_hdr_addr;
121 *flash_base_addr = 0;
122 return 0;
123}
124#endif
125
ac55dadb
UA		 126#if defined(CONFIG_ESBC_HDR_LS)
127static int get_ie_info_addr(uintptr_t *ie_addr)
128{
129 struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR);
130 /* For LS-CH3, the address of IE Table is
131 * stated in Scratch13 and scratch14 of DCFG.
132 * Bootrom validates this table while validating uboot.
133 * DCFG is LE*/
134 *ie_addr = in_le32(&gur->scratchrw[SCRATCH_IE_HIGH_ADR - 1]);
135 *ie_addr = *ie_addr << 32;
136 *ie_addr |= in_le32(&gur->scratchrw[SCRATCH_IE_LOW_ADR - 1]);
137 return 0;
138}
139#else /* CONFIG_ESBC_HDR_LS */
140static int get_ie_info_addr(uintptr_t *ie_addr)
47151e4b 141{
142 struct fsl_secboot_img_hdr *hdr;
143 struct fsl_secboot_sg_table *sg_tbl;
7bcb0eb2 144 u32 flash_base_addr, csf_addr;
47151e4b 145
146 if (get_csf_base_addr(&csf_addr, &flash_base_addr))
147 return -1;
148
9711f528 149 hdr = (struct fsl_secboot_img_hdr *)(uintptr_t)csf_addr;
47151e4b 150
151 /* For SoC's with Trust Architecture v1 with corenet bus
152 * the sg table field in CSF header has absolute address
153 * for sg table in memory. In other Trust Architecture,
154 * this field specifies the offset of sg table from the
155 * base address of CSF Header
156 */
157#if defined(CONFIG_FSL_TRUST_ARCH_v1) && defined(CONFIG_FSL_CORENET)
158 sg_tbl = (struct fsl_secboot_sg_table *)
7bcb0eb2 159 (((u32)hdr->psgtable & ~(CONFIG_SYS_PBI_FLASH_BASE)) +
47151e4b 160 flash_base_addr);
161#else
9711f528 162 sg_tbl = (struct fsl_secboot_sg_table *)(uintptr_t)(csf_addr +
7bcb0eb2 163 (u32)hdr->psgtable);
47151e4b 164#endif
165
166 /* IE Key Table is the first entry in the SG Table */
167#if defined(CONFIG_MPC85xx)
ac55dadb
UA		 168 *ie_addr = (uintptr_t)((sg_tbl->src_addr &
169 ~(CONFIG_SYS_PBI_FLASH_BASE)) +
170 flash_base_addr);
47151e4b 171#else
ac55dadb 172 *ie_addr = (uintptr_t)sg_tbl->src_addr;
47151e4b 173#endif
174
ac55dadb 175 debug("IE Table address is %lx\n", *ie_addr);
47151e4b 176 return 0;
177}
ac55dadb 178#endif /* CONFIG_ESBC_HDR_LS */
47151e4b 179#endif
180
181#ifdef CONFIG_KEY_REVOCATION
182/* This function checks srk_table_flag in header and set/reset srk_flag.*/
183static u32 check_srk(struct fsl_secboot_img_priv *img)
184{
fd6dbc98 185#ifdef CONFIG_ESBC_HDR_LS
ac55dadb
UA		 186 /* In LS, No SRK Flag as SRK is always present if IE not present*/
187#if defined(CONFIG_FSL_ISBC_KEY_EXT)
188 return !check_ie(img);
189#endif
fd6dbc98
SJ		 190 return 1;
191#else
47151e4b 192 if (img->hdr.len_kr.srk_table_flag & SRK_FLAG)
193 return 1;
194
195 return 0;
fd6dbc98 196#endif
47151e4b 197}
198
199/* This function returns ospr's key_revoc values.*/
200static u32 get_key_revoc(void)
201{
202 struct ccsr_sfp_regs *sfp_regs = (void *)(CONFIG_SYS_SFP_ADDR);
203 return (sfp_in32(&sfp_regs->ospr) & OSPR_KEY_REVOC_MASK) >>
204 OSPR_KEY_REVOC_SHIFT;
205}
206
207/* This function checks if selected key is revoked or not.*/
208static u32 is_key_revoked(u32 keynum, u32 rev_flag)
209{
210 if (keynum == UNREVOCABLE_KEY)
211 return 0;
212
213 if ((u32)(1 << (ALIGN_REVOC_KEY - keynum)) & rev_flag)
214 return 1;
215
216 return 0;
217}
218
94ba5e41
AB		 219/* It read validates srk_table key lengths.*/
220static u32 read_validate_srk_tbl(struct fsl_secboot_img_priv *img)
47151e4b 221{
222 int i = 0;
94ba5e41
AB		 223 u32 ret, key_num, key_revoc_flag, size;
224 struct fsl_secboot_img_hdr *hdr = &img->hdr;
225 void *esbc = (u8 *)(uintptr_t)img->ehdrloc;
226
227 if ((hdr->len_kr.num_srk == 0) ||
228 (hdr->len_kr.num_srk > MAX_KEY_ENTRIES))
229 return ERROR_ESBC_CLIENT_HEADER_INVALID_SRK_NUM_ENTRY;
230
231 key_num = hdr->len_kr.srk_sel;
232 if (key_num == 0 || key_num > hdr->len_kr.num_srk)
233 return ERROR_ESBC_CLIENT_HEADER_INVALID_KEY_NUM;
234
235 /* Get revoc key from sfp */
236 key_revoc_flag = get_key_revoc();
237 ret = is_key_revoked(key_num, key_revoc_flag);
238 if (ret)
239 return ERROR_ESBC_CLIENT_HEADER_KEY_REVOKED;
240
241 size = hdr->len_kr.num_srk * sizeof(struct srk_table);
242
243 memcpy(&img->srk_tbl, esbc + hdr->srk_tbl_off, size);
244
245 for (i = 0; i < hdr->len_kr.num_srk; i++) {
246 if (!CHECK_KEY_LEN(img->srk_tbl[i].key_len))
47151e4b 247 return ERROR_ESBC_CLIENT_HEADER_INV_SRK_ENTRY_KEYLEN;
248 }
94ba5e41
AB		 249
250 img->key_len = img->srk_tbl[key_num - 1].key_len;
251
252 memcpy(&img->img_key, &(img->srk_tbl[key_num - 1].pkey),
253 img->key_len);
254
47151e4b 255 return 0;
256}
257#endif
258
fd6dbc98 259#ifndef CONFIG_ESBC_HDR_LS
94ba5e41
AB		 260static u32 read_validate_single_key(struct fsl_secboot_img_priv *img)
261{
262 struct fsl_secboot_img_hdr *hdr = &img->hdr;
263 void *esbc = (u8 *)(uintptr_t)img->ehdrloc;
264
265 /* check key length */
266 if (!CHECK_KEY_LEN(hdr->key_len))
267 return ERROR_ESBC_CLIENT_HEADER_KEY_LEN;
268
269 memcpy(&img->img_key, esbc + hdr->pkey, hdr->key_len);
270
271 img->key_len = hdr->key_len;
272
273 return 0;
274}
fd6dbc98 275#endif /* CONFIG_ESBC_HDR_LS */
94ba5e41
AB		 276
277#if defined(CONFIG_FSL_ISBC_KEY_EXT)
ac55dadb
UA		 278
279static void install_ie_tbl(uintptr_t ie_tbl_addr,
280 struct fsl_secboot_img_priv *img)
281{
282 /* Copy IE tbl to Global Data */
283 memcpy(&glb.ie_tbl, (u8 *)ie_tbl_addr, sizeof(struct ie_key_info));
284 img->ie_addr = (uintptr_t)&glb.ie_tbl;
285 glb.ie_addr = img->ie_addr;
286}
287
94ba5e41
AB		 288static u32 read_validate_ie_tbl(struct fsl_secboot_img_priv *img)
289{
290 struct fsl_secboot_img_hdr *hdr = &img->hdr;
291 u32 ie_key_len, ie_revoc_flag, ie_num;
292 struct ie_key_info *ie_info;
293
ac55dadb
UA		 294 if (!img->ie_addr) {
295 if (get_ie_info_addr(&img->ie_addr))
296 return ERROR_IE_TABLE_NOT_FOUND;
297 else
298 install_ie_tbl(img->ie_addr, img);
299 }
300
94ba5e41
AB		 301 ie_info = (struct ie_key_info *)(uintptr_t)img->ie_addr;
302 if (ie_info->num_keys == 0 || ie_info->num_keys > 32)
303 return ERROR_ESBC_CLIENT_HEADER_INVALID_IE_NUM_ENTRY;
304
305 ie_num = hdr->ie_key_sel;
306 if (ie_num == 0 || ie_num > ie_info->num_keys)
307 return ERROR_ESBC_CLIENT_HEADER_INVALID_IE_KEY_NUM;
308
309 ie_revoc_flag = ie_info->key_revok;
310 if ((u32)(1 << (ie_num - 1)) & ie_revoc_flag)
311 return ERROR_ESBC_CLIENT_HEADER_IE_KEY_REVOKED;
312
313 ie_key_len = ie_info->ie_key_tbl[ie_num - 1].key_len;
314
315 if (!CHECK_KEY_LEN(ie_key_len))
316 return ERROR_ESBC_CLIENT_HEADER_INV_IE_ENTRY_KEYLEN;
317
318 memcpy(&img->img_key, &(ie_info->ie_key_tbl[ie_num - 1].pkey),
319 ie_key_len);
320
321 img->key_len = ie_key_len;
322 return 0;
323}
324#endif
325
326
47151e4b 327/* This function return length of public key.*/
328static inline u32 get_key_len(struct fsl_secboot_img_priv *img)
329{
330 return img->key_len;
331}
332
333/*
334 * Handles the ESBC uboot client header verification failure.
335 * This function handles all the errors which might occur in the
336 * parsing and checking of ESBC uboot client header. It will also
337 * set the error bits in the SEC_MON.
338 */
339static void fsl_secboot_header_verification_failure(void)
340{
47151e4b 341 struct ccsr_sfp_regs *sfp_regs = (void *)(CONFIG_SYS_SFP_ADDR);
47151e4b 342
343 /* 29th bit of OSPR is ITS */
344 u32 its = sfp_in32(&sfp_regs->ospr) >> 2;
345
b259732d
SG		 346 if (its == 1)
347 set_sec_mon_state(HPSR_SSM_ST_SOFT_FAIL);
348 else
349 set_sec_mon_state(HPSR_SSM_ST_NON_SECURE);
47151e4b 350
351 printf("Generating reset request\n");
352 do_reset(NULL, 0, 0, NULL);
c4666cf6
SJ		 353 /* If reset doesn't coocur, halt execution */
354 do_esbc_halt(NULL, 0, 0, NULL);
47151e4b 355}
356
357/*
358 * Handles the ESBC uboot client image verification failure.
359 * This function handles all the errors which might occur in the
360 * public key hash comparison and signature verification of
361 * ESBC uboot client image. It will also
362 * set the error bits in the SEC_MON.
363 */
364static void fsl_secboot_image_verification_failure(void)
365{
47151e4b 366 struct ccsr_sfp_regs *sfp_regs = (void *)(CONFIG_SYS_SFP_ADDR);
47151e4b 367
6ec9aef2 368 u32 its = (sfp_in32(&sfp_regs->ospr) & ITS_MASK) >> ITS_BIT;
47151e4b 369
b259732d
SG		 370 if (its == 1) {
371 set_sec_mon_state(HPSR_SSM_ST_SOFT_FAIL);
372
373 printf("Generating reset request\n");
374 do_reset(NULL, 0, 0, NULL);
375 /* If reset doesn't coocur, halt execution */
376 do_esbc_halt(NULL, 0, 0, NULL);
377
378 } else {
379 set_sec_mon_state(HPSR_SSM_ST_NON_SECURE);
47151e4b 380 }
381}
382
383static void fsl_secboot_bootscript_parse_failure(void)
384{
385 fsl_secboot_header_verification_failure();
386}
387
388/*
389 * Handles the errors in esbc boot.
390 * This function handles all the errors which might occur in the
391 * esbc boot phase. It will call the appropriate api to log the
392 * errors and set the error bits in the SEC_MON.
393 */
394void fsl_secboot_handle_error(int error)
395{
70f9661c 396#ifndef CONFIG_SPL_BUILD
47151e4b 397 const struct fsl_secboot_errcode *e;
398
399 for (e = fsl_secboot_errcodes; e->errcode != ERROR_ESBC_CLIENT_MAX;
400 e++) {
401 if (e->errcode == error)
402 printf("ERROR :: %x :: %s\n", error, e->name);
403 }
70f9661c
RG		 404#else
405 printf("ERROR :: %x\n", error);
406#endif
47151e4b 407
856b2846
AB		 408 /* If Boot Mode is secure, transition the SNVS state and issue
409 * reset based on type of failure and ITS setting.
410 * If Boot mode is non-secure, return from this function.
411 */
412 if (fsl_check_boot_mode_secure() == 0)
413 return;
414
47151e4b 415 switch (error) {
416 case ERROR_ESBC_CLIENT_HEADER_BARKER:
417 case ERROR_ESBC_CLIENT_HEADER_IMG_SIZE:
418 case ERROR_ESBC_CLIENT_HEADER_KEY_LEN:
419 case ERROR_ESBC_CLIENT_HEADER_SIG_LEN:
420 case ERROR_ESBC_CLIENT_HEADER_KEY_LEN_NOT_TWICE_SIG_LEN:
421 case ERROR_ESBC_CLIENT_HEADER_KEY_MOD_1:
422 case ERROR_ESBC_CLIENT_HEADER_KEY_MOD_2:
423 case ERROR_ESBC_CLIENT_HEADER_SIG_KEY_MOD:
424 case ERROR_ESBC_CLIENT_HEADER_SG_ESBC_EP:
425 case ERROR_ESBC_CLIENT_HEADER_SG_ENTIRES_BAD:
fd6dbc98 426 case ERROR_KEY_TABLE_NOT_FOUND:
47151e4b 427#ifdef CONFIG_KEY_REVOCATION
428 case ERROR_ESBC_CLIENT_HEADER_KEY_REVOKED:
429 case ERROR_ESBC_CLIENT_HEADER_INVALID_SRK_NUM_ENTRY:
430 case ERROR_ESBC_CLIENT_HEADER_INVALID_KEY_NUM:
431 case ERROR_ESBC_CLIENT_HEADER_INV_SRK_ENTRY_KEYLEN:
432#endif
433#if defined(CONFIG_FSL_ISBC_KEY_EXT)
434 /*@fallthrough@*/
435 case ERROR_ESBC_CLIENT_HEADER_IE_KEY_REVOKED:
436 case ERROR_ESBC_CLIENT_HEADER_INVALID_IE_NUM_ENTRY:
437 case ERROR_ESBC_CLIENT_HEADER_INVALID_IE_KEY_NUM:
438 case ERROR_ESBC_CLIENT_HEADER_INV_IE_ENTRY_KEYLEN:
439 case ERROR_IE_TABLE_NOT_FOUND:
440#endif
441 fsl_secboot_header_verification_failure();
442 break;
443 case ERROR_ESBC_SEC_RESET:
444 case ERROR_ESBC_SEC_DEQ:
445 case ERROR_ESBC_SEC_ENQ:
446 case ERROR_ESBC_SEC_DEQ_TO:
447 case ERROR_ESBC_SEC_JOBQ_STATUS:
448 case ERROR_ESBC_CLIENT_HASH_COMPARE_KEY:
449 case ERROR_ESBC_CLIENT_HASH_COMPARE_EM:
450 fsl_secboot_image_verification_failure();
451 break;
452 case ERROR_ESBC_MISSING_BOOTM:
453 fsl_secboot_bootscript_parse_failure();
454 break;
455 case ERROR_ESBC_WRONG_CMD:
456 default:
457 branch_to_self();
458 break;
459 }
460}
461
462static void fsl_secblk_handle_error(int error)
463{
464 switch (error) {
465 case ERROR_ESBC_SEC_ENQ:
466 fsl_secboot_handle_error(ERROR_ESBC_SEC_ENQ);
467 break;
468 case ERROR_ESBC_SEC_DEQ:
469 fsl_secboot_handle_error(ERROR_ESBC_SEC_DEQ);
470 break;
471 case ERROR_ESBC_SEC_DEQ_TO:
472 fsl_secboot_handle_error(ERROR_ESBC_SEC_DEQ_TO);
473 break;
474 default:
475 printf("Job Queue Output status %x\n", error);
476 fsl_secboot_handle_error(ERROR_ESBC_SEC_JOBQ_STATUS);
477 break;
478 }
479}
480
481/*
482 * Calculate hash of key obtained via offset present in ESBC uboot
483 * client hdr. This function calculates the hash of key which is obtained
484 * through offset present in ESBC uboot client header.
485 */
486static int calc_img_key_hash(struct fsl_secboot_img_priv *img)
487{
488 struct hash_algo *algo;
489 void *ctx;
490 int i, srk = 0;
491 int ret = 0;
492 const char *algo_name = "sha256";
493
494 /* Calculate hash of the esbc key */
495 ret = hash_progressive_lookup_algo(algo_name, &algo);
496 if (ret)
497 return ret;
498
499 ret = algo->hash_init(algo, &ctx);
500 if (ret)
501 return ret;
502
503 /* Update hash for ESBC key */
504#ifdef CONFIG_KEY_REVOCATION
505 if (check_srk(img)) {
506 ret = algo->hash_update(algo, ctx,
9711f528
AB		 507 (u8 *)(uintptr_t)(img->ehdrloc + img->hdr.srk_tbl_off),
508 img->hdr.len_kr.num_srk * sizeof(struct srk_table), 1);
47151e4b 509 srk = 1;
510 }
511#endif
512 if (!srk)
513 ret = algo->hash_update(algo, ctx,
514 img->img_key, img->key_len, 1);
515 if (ret)
516 return ret;
517
518 /* Copy hash at destination buffer */
519 ret = algo->hash_finish(algo, ctx, hash_val, algo->digest_size);
520 if (ret)
521 return ret;
522
523 for (i = 0; i < SHA256_BYTES; i++)
524 img->img_key_hash[i] = hash_val[i];
525
526 return 0;
527}
528
529/*
530 * Calculate hash of ESBC hdr and ESBC. This function calculates the
531 * single hash of ESBC header and ESBC image. If SG flag is on, all
532 * SG entries are also hashed alongwith the complete SG table.
533 */
534static int calc_esbchdr_esbc_hash(struct fsl_secboot_img_priv *img)
535{
536 struct hash_algo *algo;
537 void *ctx;
538 int ret = 0;
539 int key_hash = 0;
540 const char *algo_name = "sha256";
541
542 /* Calculate the hash of the ESBC */
543 ret = hash_progressive_lookup_algo(algo_name, &algo);
544 if (ret)
545 return ret;
546
547 ret = algo->hash_init(algo, &ctx);
548 /* Copy hash at destination buffer */
549 if (ret)
550 return ret;
551
552 /* Update hash for CSF Header */
553 ret = algo->hash_update(algo, ctx,
554 (u8 *)&img->hdr, sizeof(struct fsl_secboot_img_hdr), 0);
555 if (ret)
556 return ret;
557
558 /* Update the hash with that of srk table if srk flag is 1
559 * If IE Table is selected, key is not added in the hash
560 * If neither srk table nor IE key table available, add key
561 * from header in the hash calculation
562 */
563#ifdef CONFIG_KEY_REVOCATION
564 if (check_srk(img)) {
565 ret = algo->hash_update(algo, ctx,
9711f528
AB		 566 (u8 *)(uintptr_t)(img->ehdrloc + img->hdr.srk_tbl_off),
567 img->hdr.len_kr.num_srk * sizeof(struct srk_table), 0);
47151e4b 568 key_hash = 1;
569 }
570#endif
571#if defined(CONFIG_FSL_ISBC_KEY_EXT)
572 if (!key_hash && check_ie(img))
573 key_hash = 1;
574#endif
fd6dbc98
SJ		 575#ifndef CONFIG_ESBC_HDR_LS
576/* No single key support in LS ESBC header */
577 if (!key_hash) {
47151e4b 578 ret = algo->hash_update(algo, ctx,
579 img->img_key, img->hdr.key_len, 0);
fd6dbc98
SJ		 580 key_hash = 1;
581 }
582#endif
47151e4b 583 if (ret)
584 return ret;
fd6dbc98
SJ		 585 if (!key_hash)
586 return ERROR_KEY_TABLE_NOT_FOUND;
47151e4b 587
588 /* Update hash for actual Image */
589 ret = algo->hash_update(algo, ctx,
85bb3896 590 (u8 *)(*(img->img_addr_ptr)), img->img_size, 1);
47151e4b 591 if (ret)
592 return ret;
593
594 /* Copy hash at destination buffer */
595 ret = algo->hash_finish(algo, ctx, hash_val, algo->digest_size);
596 if (ret)
597 return ret;
598
599 return 0;
600}
601
602/*
603 * Construct encoded hash EM' wrt PKCSv1.5. This function calculates the
604 * pointers for padding, DER value and hash. And finally, constructs EM'
605 * which includes hash of complete CSF header and ESBC image. If SG flag
606 * is on, hash of SG table and entries is also included.
607 */
608static void construct_img_encoded_hash_second(struct fsl_secboot_img_priv *img)
609{
610 /*
611 * RSA PKCSv1.5 encoding format for encoded message is below
612 * EM = 0x0 || 0x1 || PS || 0x0 || DER || Hash
613 * PS is Padding String
614 * DER is DER value for SHA-256
615 * Hash is SHA-256 hash
616 * *********************************************************
617 * representative points to first byte of EM initially and is
618 * filled with 0x0
619 * representative is incremented by 1 and second byte is filled
620 * with 0x1
621 * padding points to third byte of EM
622 * digest points to full length of EM - 32 bytes
623 * hash_id (DER value) points to 19 bytes before pDigest
624 * separator is one byte which separates padding and DER
625 */
626
627 size_t len;
628 u8 *representative;
629 u8 *padding, *digest;
630 u8 *hash_id, *separator;
631 int i;
632
633 len = (get_key_len(img) / 2) - 1;
634 representative = img->img_encoded_hash_second;
635 representative[0] = 0;
636 representative[1] = 1; /* block type 1 */
637
638 padding = &representative[2];
639 digest = &representative[1] + len - 32;
640 hash_id = digest - sizeof(hash_identifier);
641 separator = hash_id - 1;
642
643 /* fill padding area pointed by padding with 0xff */
644 memset(padding, 0xff, separator - padding);
645
646 /* fill byte pointed by separator */
647 *separator = 0;
648
649 /* fill SHA-256 DER value pointed by HashId */
650 memcpy(hash_id, hash_identifier, sizeof(hash_identifier));
651
652 /* fill hash pointed by Digest */
653 for (i = 0; i < SHA256_BYTES; i++)
654 digest[i] = hash_val[i];
655}
656
657/*
658 * Reads and validates the ESBC client header.
659 * This function reads key and signature from the ESBC client header.
660 * If Scatter/Gather flag is on, lengths and offsets of images
661 * present as SG entries are also read. This function also checks
662 * whether the header is valid or not.
663 */
664static int read_validate_esbc_client_header(struct fsl_secboot_img_priv *img)
665{
47151e4b 666 struct fsl_secboot_img_hdr *hdr = &img->hdr;
9711f528 667 void *esbc = (u8 *)(uintptr_t)img->ehdrloc;
47151e4b 668 u8 *k, *s;
94ba5e41
AB		 669 u32 ret = 0;
670
47151e4b 671 int key_found = 0;
672
673 /* check barker code */
674 if (memcmp(hdr->barker, barker_code, ESBC_BARKER_LEN))
675 return ERROR_ESBC_CLIENT_HEADER_BARKER;
676
b055a0fd
AB		 677 /* If Image Address is not passed as argument to function,
678 * then Address and Size must be read from the Header.
679 */
85bb3896 680 if (*(img->img_addr_ptr) == 0) {
b055a0fd 681 #ifdef CONFIG_ESBC_ADDR_64BIT
85bb3896 682 *(img->img_addr_ptr) = hdr->pimg64;
b055a0fd 683 #else
85bb3896 684 *(img->img_addr_ptr) = hdr->pimg;
b055a0fd
AB		 685 #endif
686 }
687
47151e4b 688 if (!hdr->img_size)
689 return ERROR_ESBC_CLIENT_HEADER_IMG_SIZE;
690
b055a0fd
AB		 691 img->img_size = hdr->img_size;
692
47151e4b 693 /* Key checking*/
694#ifdef CONFIG_KEY_REVOCATION
695 if (check_srk(img)) {
94ba5e41 696 ret = read_validate_srk_tbl(img);
47151e4b 697 if (ret != 0)
698 return ret;
47151e4b 699 key_found = 1;
700 }
701#endif
702
703#if defined(CONFIG_FSL_ISBC_KEY_EXT)
704 if (!key_found && check_ie(img)) {
94ba5e41
AB		 705 ret = read_validate_ie_tbl(img);
706 if (ret != 0)
707 return ret;
47151e4b 708 key_found = 1;
709 }
710#endif
fd6dbc98
SJ		 711#ifndef CONFIG_ESBC_HDR_LS
712/* Single Key Feature not available in LS ESBC Header */
47151e4b 713 if (key_found == 0) {
94ba5e41
AB		 714 ret = read_validate_single_key(img);
715 if (ret != 0)
716 return ret;
47151e4b 717 key_found = 1;
718 }
fd6dbc98
SJ		 719#endif
720 if (!key_found)
721 return ERROR_KEY_TABLE_NOT_FOUND;
47151e4b 722
723 /* check signaure */
724 if (get_key_len(img) == 2 * hdr->sign_len) {
725 /* check signature length */
726 if (!((hdr->sign_len == KEY_SIZE_BYTES / 4) ||
727 (hdr->sign_len == KEY_SIZE_BYTES / 2) ||
728 (hdr->sign_len == KEY_SIZE_BYTES)))
729 return ERROR_ESBC_CLIENT_HEADER_SIG_LEN;
730 } else {
731 return ERROR_ESBC_CLIENT_HEADER_KEY_LEN_NOT_TWICE_SIG_LEN;
732 }
733
734 memcpy(&img->img_sign, esbc + hdr->psign, hdr->sign_len);
fd6dbc98
SJ		 735/* No SG support in LS-CH3 */
736#ifndef CONFIG_ESBC_HDR_LS
47151e4b 737 /* No SG support */
738 if (hdr->sg_flag)
739 return ERROR_ESBC_CLIENT_HEADER_SG;
fd6dbc98 740#endif
47151e4b 741
742 /* modulus most significant bit should be set */
743 k = (u8 *)&img->img_key;
744
745 if ((k[0] & 0x80) == 0)
746 return ERROR_ESBC_CLIENT_HEADER_KEY_MOD_1;
747
748 /* modulus value should be odd */
749 if ((k[get_key_len(img) / 2 - 1] & 0x1) == 0)
750 return ERROR_ESBC_CLIENT_HEADER_KEY_MOD_2;
751
752 /* Check signature value < modulus value */
753 s = (u8 *)&img->img_sign;
754
755 if (!(memcmp(s, k, hdr->sign_len) < 0))
756 return ERROR_ESBC_CLIENT_HEADER_SIG_KEY_MOD;
757
758 return ESBC_VALID_HDR;
759}
760
761static inline int str2longbe(const char *p, ulong *num)
762{
763 char *endptr;
764 ulong tmp;
765
766 if (!p) {
767 return 0;
768 } else {
769 tmp = simple_strtoul(p, &endptr, 16);
770 if (sizeof(ulong) == 4)
771 *num = cpu_to_be32(tmp);
772 else
773 *num = cpu_to_be64(tmp);
774 }
775
776 return *p != '\0' && *endptr == '\0';
777}
6629261d
AB		 778/* Function to calculate the ESBC Image Hash
779 * and hash from Digital signature.
780 * The Two hash's are compared to yield the
781 * result of signature validation.
782 */
783static int calculate_cmp_img_sig(struct fsl_secboot_img_priv *img)
784{
785 int ret;
786 uint32_t key_len;
787 struct key_prop prop;
788#if !defined(USE_HOSTCC)
789 struct udevice *mod_exp_dev;
790#endif
791 ret = calc_esbchdr_esbc_hash(img);
792 if (ret)
793 return ret;
794
795 /* Construct encoded hash EM' wrt PKCSv1.5 */
796 construct_img_encoded_hash_second(img);
797
798 /* Fill prop structure for public key */
799 memset(&prop, 0, sizeof(struct key_prop));
800 key_len = get_key_len(img) / 2;
801 prop.modulus = img->img_key;
802 prop.public_exponent = img->img_key + key_len;
803 prop.num_bits = key_len * 8;
804 prop.exp_len = key_len;
805
806 ret = uclass_get_device(UCLASS_MOD_EXP, 0, &mod_exp_dev);
807 if (ret) {
808 printf("RSA: Can't find Modular Exp implementation\n");
809 return -EINVAL;
810 }
811
812 ret = rsa_mod_exp(mod_exp_dev, img->img_sign, img->hdr.sign_len,
813 &prop, img->img_encoded_hash);
814 if (ret)
815 return ret;
816
817 /*
818 * compare the encoded messages EM' and EM wrt RSA PKCSv1.5
819 * memcmp returns zero on success
820 * memcmp returns non-zero on failure
821 */
822 ret = memcmp(&img->img_encoded_hash_second, &img->img_encoded_hash,
823 img->hdr.sign_len);
824
825 if (ret)
826 return ERROR_ESBC_CLIENT_HASH_COMPARE_EM;
827
828 return 0;
829}
ac55dadb
UA		 830/* Function to initialize img priv and global data structure
831 */
832static int secboot_init(struct fsl_secboot_img_priv **img_ptr)
833{
834 *img_ptr = malloc(sizeof(struct fsl_secboot_img_priv));
835
836 struct fsl_secboot_img_priv *img = *img_ptr;
837
838 if (!img)
839 return -ENOMEM;
840 memset(img, 0, sizeof(struct fsl_secboot_img_priv));
841
842#if defined(CONFIG_FSL_ISBC_KEY_EXT)
843 if (glb.ie_addr)
844 img->ie_addr = glb.ie_addr;
845#endif
846 return 0;
847}
848
849
85bb3896
SJ		 850/* haddr - Address of the header of image to be validated.
851 * arg_hash_str - Option hash string. If provided, this
1cc0a9f4 852 * overrides the key hash in the SFP fuses.
85bb3896 853 * img_addr_ptr - Optional pointer to address of image to be validated.
1cc0a9f4 854 * If non zero addr, this overrides the addr of image in header,
85bb3896
SJ		 855 * otherwise updated to image addr in header.
856 * Acts as both input and output of function.
857 * This pointer shouldn't be NULL.
858 */
b055a0fd 859int fsl_secboot_validate(uintptr_t haddr, char *arg_hash_str,
85bb3896 860 uintptr_t *img_addr_ptr)
47151e4b 861{
862 struct ccsr_sfp_regs *sfp_regs = (void *)(CONFIG_SYS_SFP_ADDR);
863 ulong hash[SHA256_BYTES/sizeof(ulong)];
864 char hash_str[NUM_HEX_CHARS + 1];
47151e4b 865 struct fsl_secboot_img_priv *img;
866 struct fsl_secboot_img_hdr *hdr;
867 void *esbc;
868 int ret, i, hash_cmd = 0;
869 u32 srk_hash[8];
47151e4b 870
bc71f926
AB		 871 if (arg_hash_str != NULL) {
872 const char *cp = arg_hash_str;
47151e4b 873 int i = 0;
874
875 if (*cp == '0' && *(cp + 1) == 'x')
876 cp += 2;
877
878 /* The input string expected is in hex, where
879 * each 4 bits would be represented by a hex
880 * sha256 hash is 256 bits long, which would mean
881 * num of characters = 256 / 4
882 */
883 if (strlen(cp) != SHA256_NIBBLES) {
884 printf("%s is not a 256 bits hex string as expected\n",
bc71f926 885 arg_hash_str);
47151e4b 886 return -1;
887 }
888
889 for (i = 0; i < sizeof(hash)/sizeof(ulong); i++) {
890 strncpy(hash_str, cp + (i * NUM_HEX_CHARS),
891 NUM_HEX_CHARS);
892 hash_str[NUM_HEX_CHARS] = '\0';
893 if (!str2longbe(hash_str, &hash[i])) {
894 printf("%s is not a 256 bits hex string ",
bc71f926 895 arg_hash_str);
47151e4b 896 return -1;
897 }
898 }
899
900 hash_cmd = 1;
901 }
902
ac55dadb
UA		 903 ret = secboot_init(&img);
904 if (ret)
905 goto exit;
47151e4b 906
b055a0fd 907 /* Update the information in Private Struct */
47151e4b 908 hdr = &img->hdr;
bc71f926 909 img->ehdrloc = haddr;
85bb3896 910 img->img_addr_ptr = img_addr_ptr;
b055a0fd 911 esbc = (u8 *)img->ehdrloc;
47151e4b 912
913 memcpy(hdr, esbc, sizeof(struct fsl_secboot_img_hdr));
914
915 /* read and validate esbc header */
916 ret = read_validate_esbc_client_header(img);
917
918 if (ret != ESBC_VALID_HDR) {
919 fsl_secboot_handle_error(ret);
920 goto exit;
921 }
922
923 /* SRKH present in SFP */
924 for (i = 0; i < NUM_SRKH_REGS; i++)
925 srk_hash[i] = srk_in32(&sfp_regs->srk_hash[i]);
926
927 /*
928 * Calculate hash of key obtained via offset present in
929 * ESBC uboot client hdr
930 */
931 ret = calc_img_key_hash(img);
932 if (ret) {
933 fsl_secblk_handle_error(ret);
934 goto exit;
935 }
936
937 /* Compare hash obtained above with SRK hash present in SFP */
938 if (hash_cmd)
939 ret = memcmp(&hash, &img->img_key_hash, SHA256_BYTES);
940 else
941 ret = memcmp(srk_hash, img->img_key_hash, SHA256_BYTES);
942
943#if defined(CONFIG_FSL_ISBC_KEY_EXT)
944 if (!hash_cmd && check_ie(img))
945 ret = 0;
946#endif
947
948 if (ret != 0) {
949 fsl_secboot_handle_error(ERROR_ESBC_CLIENT_HASH_COMPARE_KEY);
950 goto exit;
951 }
952
6629261d 953 ret = calculate_cmp_img_sig(img);
47151e4b 954 if (ret) {
6629261d 955 fsl_secboot_handle_error(ret);
47151e4b 956 goto exit;
957 }
958
47151e4b 959exit:
ac55dadb
UA		 960 /* Free Img as it was malloc'ed*/
961 free(img);
bc71f926 962 return ret;
47151e4b 963}
"Das U-Boot" Source Tree