1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2013, Google Inc.
12 DECLARE_GLOBAL_DATA_PTR
;
13 #endif /* !USE_HOSTCC*/
15 #include <u-boot/rsa.h>
16 #include <u-boot/rsa-checksum.h>
18 #define IMAGE_MAX_HASHED_NODES 100
22 void image_set_host_blob(void *blob
)
26 void *image_get_host_blob(void)
32 struct checksum_algo checksum_algos
[] = {
35 .checksum_len
= SHA1_SUM_LEN
,
36 .der_len
= SHA1_DER_LEN
,
37 .der_prefix
= sha1_der_prefix
,
39 .calculate_sign
= EVP_sha1
,
41 .calculate
= hash_calculate
,
45 .checksum_len
= SHA256_SUM_LEN
,
46 .der_len
= SHA256_DER_LEN
,
47 .der_prefix
= sha256_der_prefix
,
49 .calculate_sign
= EVP_sha256
,
51 .calculate
= hash_calculate
,
56 struct crypto_algo crypto_algos
[] = {
59 .key_len
= RSA2048_BYTES
,
61 .add_verify_data
= rsa_add_verify_data
,
66 .key_len
= RSA4096_BYTES
,
68 .add_verify_data
= rsa_add_verify_data
,
74 struct padding_algo padding_algos
[] = {
77 .verify
= padding_pkcs_15_verify
,
79 #ifdef CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT
82 .verify
= padding_pss_verify
,
84 #endif /* CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT */
87 struct checksum_algo
*image_get_checksum_algo(const char *full_name
)
92 for (i
= 0; i
< ARRAY_SIZE(checksum_algos
); i
++) {
93 name
= checksum_algos
[i
].name
;
94 /* Make sure names match and next char is a comma */
95 if (!strncmp(name
, full_name
, strlen(name
)) &&
96 full_name
[strlen(name
)] == ',')
97 return &checksum_algos
[i
];
103 struct crypto_algo
*image_get_crypto_algo(const char *full_name
)
108 /* Move name to after the comma */
109 name
= strchr(full_name
, ',');
114 for (i
= 0; i
< ARRAY_SIZE(crypto_algos
); i
++) {
115 if (!strcmp(crypto_algos
[i
].name
, name
))
116 return &crypto_algos
[i
];
122 struct padding_algo
*image_get_padding_algo(const char *name
)
129 for (i
= 0; i
< ARRAY_SIZE(padding_algos
); i
++) {
130 if (!strcmp(padding_algos
[i
].name
, name
))
131 return &padding_algos
[i
];
138 * fit_region_make_list() - Make a list of image regions
140 * Given a list of fdt_regions, create a list of image_regions. This is a
141 * simple conversion routine since the FDT and image code use different
145 * @fdt_regions: Pointer to FDT regions
146 * @count: Number of FDT regions
147 * @region: Pointer to image regions, which must hold @count records. If
148 * region is NULL, then (except for an SPL build) the array will be
150 * @return: Pointer to image regions
152 struct image_region
*fit_region_make_list(const void *fit
,
153 struct fdt_region
*fdt_regions
, int count
,
154 struct image_region
*region
)
158 debug("Hash regions:\n");
159 debug("%10s %10s\n", "Offset", "Size");
162 * Use malloc() except in SPL (to save code size). In SPL the caller
163 * must allocate the array.
165 #ifndef CONFIG_SPL_BUILD
167 region
= calloc(sizeof(*region
), count
);
171 for (i
= 0; i
< count
; i
++) {
172 debug("%10x %10x\n", fdt_regions
[i
].offset
,
173 fdt_regions
[i
].size
);
174 region
[i
].data
= fit
+ fdt_regions
[i
].offset
;
175 region
[i
].size
= fdt_regions
[i
].size
;
181 static int fit_image_setup_verify(struct image_sign_info
*info
,
182 const void *fit
, int noffset
, int required_keynode
,
186 const char *padding_name
;
188 if (fdt_totalsize(fit
) > CONFIG_FIT_SIGNATURE_MAX_SIZE
) {
189 *err_msgp
= "Total size too large";
193 if (fit_image_hash_get_algo(fit
, noffset
, &algo_name
)) {
194 *err_msgp
= "Can't get hash algo property";
198 padding_name
= fdt_getprop(fit
, noffset
, "padding", NULL
);
200 padding_name
= RSA_DEFAULT_PADDING_NAME
;
202 memset(info
, '\0', sizeof(*info
));
203 info
->keyname
= fdt_getprop(fit
, noffset
, "key-name-hint", NULL
);
204 info
->fit
= (void *)fit
;
205 info
->node_offset
= noffset
;
206 info
->name
= algo_name
;
207 info
->checksum
= image_get_checksum_algo(algo_name
);
208 info
->crypto
= image_get_crypto_algo(algo_name
);
209 info
->padding
= image_get_padding_algo(padding_name
);
210 info
->fdt_blob
= gd_fdt_blob();
211 info
->required_keynode
= required_keynode
;
212 printf("%s:%s", algo_name
, info
->keyname
);
214 if (!info
->checksum
|| !info
->crypto
) {
215 *err_msgp
= "Unknown signature algorithm";
222 int fit_image_check_sig(const void *fit
, int noffset
, const void *data
,
223 size_t size
, int required_keynode
, char **err_msgp
)
225 struct image_sign_info info
;
226 struct image_region region
;
231 if (fit_image_setup_verify(&info
, fit
, noffset
, required_keynode
,
235 if (fit_image_hash_get_value(fit
, noffset
, &fit_value
,
237 *err_msgp
= "Can't get hash value property";
244 if (info
.crypto
->verify(&info
, ®ion
, 1, fit_value
, fit_value_len
)) {
245 *err_msgp
= "Verification failed";
252 static int fit_image_verify_sig(const void *fit
, int image_noffset
,
253 const char *data
, size_t size
, const void *sig_blob
,
261 /* Process all hash subnodes of the component image node */
262 fdt_for_each_subnode(noffset
, fit
, image_noffset
) {
263 const char *name
= fit_get_name(fit
, noffset
, NULL
);
265 if (!strncmp(name
, FIT_SIG_NODENAME
,
266 strlen(FIT_SIG_NODENAME
))) {
267 ret
= fit_image_check_sig(fit
, noffset
, data
,
279 if (noffset
== -FDT_ERR_TRUNCATED
|| noffset
== -FDT_ERR_BADSTRUCTURE
) {
280 err_msg
= "Corrupted or truncated tree";
284 return verified
? 0 : -EPERM
;
287 printf(" error!\n%s for '%s' hash node in '%s' image node\n",
288 err_msg
, fit_get_name(fit
, noffset
, NULL
),
289 fit_get_name(fit
, image_noffset
, NULL
));
293 int fit_image_verify_required_sigs(const void *fit
, int image_noffset
,
294 const char *data
, size_t size
, const void *sig_blob
,
297 int verify_count
= 0;
301 /* Work out what we need to verify */
303 sig_node
= fdt_subnode_offset(sig_blob
, 0, FIT_SIG_NODENAME
);
305 debug("%s: No signature node found: %s\n", __func__
,
306 fdt_strerror(sig_node
));
310 fdt_for_each_subnode(noffset
, sig_blob
, sig_node
) {
311 const char *required
;
314 required
= fdt_getprop(sig_blob
, noffset
, "required", NULL
);
315 if (!required
|| strcmp(required
, "image"))
317 ret
= fit_image_verify_sig(fit
, image_noffset
, data
, size
,
320 printf("Failed to verify required signature '%s'\n",
321 fit_get_name(sig_blob
, noffset
, NULL
));
333 int fit_config_check_sig(const void *fit
, int noffset
, int required_keynode
,
336 char * const exc_prop
[] = {"data"};
337 const char *prop
, *end
, *name
;
338 struct image_sign_info info
;
339 const uint32_t *strings
;
347 debug("%s: fdt=%p, conf='%s', sig='%s'\n", __func__
, gd_fdt_blob(),
348 fit_get_name(fit
, noffset
, NULL
),
349 fit_get_name(gd_fdt_blob(), required_keynode
, NULL
));
351 if (fit_image_setup_verify(&info
, fit
, noffset
, required_keynode
,
355 if (fit_image_hash_get_value(fit
, noffset
, &fit_value
,
357 *err_msgp
= "Can't get hash value property";
361 /* Count the number of strings in the property */
362 prop
= fdt_getprop(fit
, noffset
, "hashed-nodes", &prop_len
);
363 end
= prop
? prop
+ prop_len
: prop
;
364 for (name
= prop
, count
= 0; name
< end
; name
++)
368 *err_msgp
= "Can't get hashed-nodes property";
372 if (prop
&& prop_len
> 0 && prop
[prop_len
- 1] != '\0') {
373 *err_msgp
= "hashed-nodes property must be null-terminated";
377 /* Add a sanity check here since we are using the stack */
378 if (count
> IMAGE_MAX_HASHED_NODES
) {
379 *err_msgp
= "Number of hashed nodes exceeds maximum";
383 /* Create a list of node names from those strings */
384 char *node_inc
[count
];
386 debug("Hash nodes (%d):\n", count
);
387 for (name
= prop
, i
= 0; name
< end
; name
+= strlen(name
) + 1, i
++) {
388 debug(" '%s'\n", name
);
389 node_inc
[i
] = (char *)name
;
393 * Each node can generate one region for each sub-node. Allow for
394 * 7 sub-nodes (hash-1, signature-1, etc.) and some extra.
396 max_regions
= 20 + count
* 7;
397 struct fdt_region fdt_regions
[max_regions
];
399 /* Get a list of regions to hash */
400 count
= fdt_find_regions(fit
, node_inc
, count
,
401 exc_prop
, ARRAY_SIZE(exc_prop
),
402 fdt_regions
, max_regions
- 1,
403 path
, sizeof(path
), 0);
405 *err_msgp
= "Failed to hash configuration";
409 *err_msgp
= "No data to hash";
412 if (count
>= max_regions
- 1) {
413 *err_msgp
= "Too many hash regions";
417 /* Add the strings */
418 strings
= fdt_getprop(fit
, noffset
, "hashed-strings", NULL
);
421 * The strings region offset must be a static 0x0.
422 * This is set in tool/image-host.c
424 fdt_regions
[count
].offset
= fdt_off_dt_strings(fit
);
425 fdt_regions
[count
].size
= fdt32_to_cpu(strings
[1]);
429 /* Allocate the region list on the stack */
430 struct image_region region
[count
];
432 fit_region_make_list(fit
, fdt_regions
, count
, region
);
433 if (info
.crypto
->verify(&info
, region
, count
, fit_value
,
435 *err_msgp
= "Verification failed";
442 static int fit_config_verify_sig(const void *fit
, int conf_noffset
,
443 const void *sig_blob
, int sig_offset
)
450 /* Process all hash subnodes of the component conf node */
451 fdt_for_each_subnode(noffset
, fit
, conf_noffset
) {
452 const char *name
= fit_get_name(fit
, noffset
, NULL
);
454 if (!strncmp(name
, FIT_SIG_NODENAME
,
455 strlen(FIT_SIG_NODENAME
))) {
456 ret
= fit_config_check_sig(fit
, noffset
, sig_offset
,
468 if (noffset
== -FDT_ERR_TRUNCATED
|| noffset
== -FDT_ERR_BADSTRUCTURE
) {
469 err_msg
= "Corrupted or truncated tree";
473 return verified
? 0 : -EPERM
;
476 printf(" error!\n%s for '%s' hash node in '%s' config node\n",
477 err_msg
, fit_get_name(fit
, noffset
, NULL
),
478 fit_get_name(fit
, conf_noffset
, NULL
));
482 int fit_config_verify_required_sigs(const void *fit
, int conf_noffset
,
483 const void *sig_blob
)
488 /* Work out what we need to verify */
489 sig_node
= fdt_subnode_offset(sig_blob
, 0, FIT_SIG_NODENAME
);
491 debug("%s: No signature node found: %s\n", __func__
,
492 fdt_strerror(sig_node
));
496 fdt_for_each_subnode(noffset
, sig_blob
, sig_node
) {
497 const char *required
;
500 required
= fdt_getprop(sig_blob
, noffset
, "required", NULL
);
501 if (!required
|| strcmp(required
, "conf"))
503 ret
= fit_config_verify_sig(fit
, conf_noffset
, sig_blob
,
506 printf("Failed to verify required signature '%s'\n",
507 fit_get_name(sig_blob
, noffset
, NULL
));
515 int fit_config_verify(const void *fit
, int conf_noffset
)
517 return fit_config_verify_required_sigs(fit
, conf_noffset
,