1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2012 The Chromium OS Authors.
4 *
5 * (C) Copyright 2011
6 * Joe Hershberger, National Instruments, joe.hershberger@ni.com
7 *
8 * (C) Copyright 2000
9 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
10 */
11
12 #ifndef USE_HOSTCC
13 #include <common.h>
14 #include <command.h>
15 #include <env.h>
16 #include <log.h>
17 #include <malloc.h>
18 #include <mapmem.h>
19 #include <hw_sha.h>
20 #include <asm/cache.h>
21 #include <asm/global_data.h>
22 #include <asm/io.h>
23 #include <linux/errno.h>
24 #include <u-boot/crc.h>
25 #else
26 #include "mkimage.h"
27 #include <time.h>
28 #endif /* !USE_HOSTCC*/
29
30 #include <hash.h>
31 #include <image.h>
32 #include <u-boot/crc.h>
33 #include <u-boot/sha1.h>
34 #include <u-boot/sha256.h>
35 #include <u-boot/sha512.h>
36 #include <u-boot/md5.h>
37
38 #if !defined(USE_HOSTCC) && defined(CONFIG_NEEDS_MANUAL_RELOC)
39 DECLARE_GLOBAL_DATA_PTR;
40 #endif
41
42 static void reloc_update(void);
43
44 #if defined(CONFIG_SHA1) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
hash_init_sha1(struct hash_algo * algo,void ** ctxp)45 static int hash_init_sha1(struct hash_algo *algo, void **ctxp)
46 {
47 sha1_context *ctx = malloc(sizeof(sha1_context));
48 sha1_starts(ctx);
49 *ctxp = ctx;
50 return 0;
51 }
52
hash_update_sha1(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)53 static int hash_update_sha1(struct hash_algo *algo, void *ctx, const void *buf,
54 unsigned int size, int is_last)
55 {
56 sha1_update((sha1_context *)ctx, buf, size);
57 return 0;
58 }
59
hash_finish_sha1(struct hash_algo * algo,void * ctx,void * dest_buf,int size)60 static int hash_finish_sha1(struct hash_algo *algo, void *ctx, void *dest_buf,
61 int size)
62 {
63 if (size < algo->digest_size)
64 return -1;
65
66 sha1_finish((sha1_context *)ctx, dest_buf);
67 free(ctx);
68 return 0;
69 }
70 #endif
71
72 #if defined(CONFIG_SHA256) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
hash_init_sha256(struct hash_algo * algo,void ** ctxp)73 static int hash_init_sha256(struct hash_algo *algo, void **ctxp)
74 {
75 sha256_context *ctx = malloc(sizeof(sha256_context));
76 sha256_starts(ctx);
77 *ctxp = ctx;
78 return 0;
79 }
80
hash_update_sha256(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)81 static int hash_update_sha256(struct hash_algo *algo, void *ctx,
82 const void *buf, unsigned int size, int is_last)
83 {
84 sha256_update((sha256_context *)ctx, buf, size);
85 return 0;
86 }
87
hash_finish_sha256(struct hash_algo * algo,void * ctx,void * dest_buf,int size)88 static int hash_finish_sha256(struct hash_algo *algo, void *ctx, void
89 *dest_buf, int size)
90 {
91 if (size < algo->digest_size)
92 return -1;
93
94 sha256_finish((sha256_context *)ctx, dest_buf);
95 free(ctx);
96 return 0;
97 }
98 #endif
99
100 #if defined(CONFIG_SHA384) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
hash_init_sha384(struct hash_algo * algo,void ** ctxp)101 static int hash_init_sha384(struct hash_algo *algo, void **ctxp)
102 {
103 sha512_context *ctx = malloc(sizeof(sha512_context));
104 sha384_starts(ctx);
105 *ctxp = ctx;
106 return 0;
107 }
108
hash_update_sha384(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)109 static int hash_update_sha384(struct hash_algo *algo, void *ctx,
110 const void *buf, unsigned int size, int is_last)
111 {
112 sha384_update((sha512_context *)ctx, buf, size);
113 return 0;
114 }
115
hash_finish_sha384(struct hash_algo * algo,void * ctx,void * dest_buf,int size)116 static int hash_finish_sha384(struct hash_algo *algo, void *ctx, void
117 *dest_buf, int size)
118 {
119 if (size < algo->digest_size)
120 return -1;
121
122 sha384_finish((sha512_context *)ctx, dest_buf);
123 free(ctx);
124 return 0;
125 }
126 #endif
127
128 #if defined(CONFIG_SHA512) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
hash_init_sha512(struct hash_algo * algo,void ** ctxp)129 static int hash_init_sha512(struct hash_algo *algo, void **ctxp)
130 {
131 sha512_context *ctx = malloc(sizeof(sha512_context));
132 sha512_starts(ctx);
133 *ctxp = ctx;
134 return 0;
135 }
136
hash_update_sha512(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)137 static int hash_update_sha512(struct hash_algo *algo, void *ctx,
138 const void *buf, unsigned int size, int is_last)
139 {
140 sha512_update((sha512_context *)ctx, buf, size);
141 return 0;
142 }
143
hash_finish_sha512(struct hash_algo * algo,void * ctx,void * dest_buf,int size)144 static int hash_finish_sha512(struct hash_algo *algo, void *ctx, void
145 *dest_buf, int size)
146 {
147 if (size < algo->digest_size)
148 return -1;
149
150 sha512_finish((sha512_context *)ctx, dest_buf);
151 free(ctx);
152 return 0;
153 }
154 #endif
155
156
hash_init_crc16_ccitt(struct hash_algo * algo,void ** ctxp)157 static int hash_init_crc16_ccitt(struct hash_algo *algo, void **ctxp)
158 {
159 uint16_t *ctx = malloc(sizeof(uint16_t));
160 *ctx = 0;
161 *ctxp = ctx;
162 return 0;
163 }
164
hash_update_crc16_ccitt(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)165 static int hash_update_crc16_ccitt(struct hash_algo *algo, void *ctx,
166 const void *buf, unsigned int size,
167 int is_last)
168 {
169 *((uint16_t *)ctx) = crc16_ccitt(*((uint16_t *)ctx), buf, size);
170 return 0;
171 }
172
hash_finish_crc16_ccitt(struct hash_algo * algo,void * ctx,void * dest_buf,int size)173 static int hash_finish_crc16_ccitt(struct hash_algo *algo, void *ctx,
174 void *dest_buf, int size)
175 {
176 if (size < algo->digest_size)
177 return -1;
178
179 *((uint16_t *)dest_buf) = *((uint16_t *)ctx);
180 free(ctx);
181 return 0;
182 }
183
hash_init_crc32(struct hash_algo * algo,void ** ctxp)184 static int hash_init_crc32(struct hash_algo *algo, void **ctxp)
185 {
186 uint32_t *ctx = malloc(sizeof(uint32_t));
187 *ctx = 0;
188 *ctxp = ctx;
189 return 0;
190 }
191
hash_update_crc32(struct hash_algo * algo,void * ctx,const void * buf,unsigned int size,int is_last)192 static int hash_update_crc32(struct hash_algo *algo, void *ctx,
193 const void *buf, unsigned int size, int is_last)
194 {
195 *((uint32_t *)ctx) = crc32(*((uint32_t *)ctx), buf, size);
196 return 0;
197 }
198
hash_finish_crc32(struct hash_algo * algo,void * ctx,void * dest_buf,int size)199 static int hash_finish_crc32(struct hash_algo *algo, void *ctx, void *dest_buf,
200 int size)
201 {
202 if (size < algo->digest_size)
203 return -1;
204
205 *((uint32_t *)dest_buf) = *((uint32_t *)ctx);
206 free(ctx);
207 return 0;
208 }
209
210 /*
211 * These are the hash algorithms we support. If we have hardware acceleration
212 * is enable we will use that, otherwise a software version of the algorithm.
213 * Note that algorithm names must be in lower case.
214 */
215 static struct hash_algo hash_algo[] = {
216 #ifdef CONFIG_SHA1
217 {
218 .name = "sha1",
219 .digest_size = SHA1_SUM_LEN,
220 .chunk_size = CHUNKSZ_SHA1,
221 #ifdef CONFIG_SHA_HW_ACCEL
222 .hash_func_ws = hw_sha1,
223 #else
224 .hash_func_ws = sha1_csum_wd,
225 #endif
226 #ifdef CONFIG_SHA_PROG_HW_ACCEL
227 .hash_init = hw_sha_init,
228 .hash_update = hw_sha_update,
229 .hash_finish = hw_sha_finish,
230 #else
231 .hash_init = hash_init_sha1,
232 .hash_update = hash_update_sha1,
233 .hash_finish = hash_finish_sha1,
234 #endif
235 },
236 #endif
237 #ifdef CONFIG_SHA256
238 {
239 .name = "sha256",
240 .digest_size = SHA256_SUM_LEN,
241 .chunk_size = CHUNKSZ_SHA256,
242 #ifdef CONFIG_SHA_HW_ACCEL
243 .hash_func_ws = hw_sha256,
244 #else
245 .hash_func_ws = sha256_csum_wd,
246 #endif
247 #ifdef CONFIG_SHA_PROG_HW_ACCEL
248 .hash_init = hw_sha_init,
249 .hash_update = hw_sha_update,
250 .hash_finish = hw_sha_finish,
251 #else
252 .hash_init = hash_init_sha256,
253 .hash_update = hash_update_sha256,
254 .hash_finish = hash_finish_sha256,
255 #endif
256 },
257 #endif
258 #ifdef CONFIG_SHA384
259 {
260 .name = "sha384",
261 .digest_size = SHA384_SUM_LEN,
262 .chunk_size = CHUNKSZ_SHA384,
263 #ifdef CONFIG_SHA512_HW_ACCEL
264 .hash_func_ws = hw_sha384,
265 #else
266 .hash_func_ws = sha384_csum_wd,
267 #endif
268 #if defined(CONFIG_SHA512_HW_ACCEL) && defined(CONFIG_SHA_PROG_HW_ACCEL)
269 .hash_init = hw_sha_init,
270 .hash_update = hw_sha_update,
271 .hash_finish = hw_sha_finish,
272 #else
273 .hash_init = hash_init_sha384,
274 .hash_update = hash_update_sha384,
275 .hash_finish = hash_finish_sha384,
276 #endif
277 },
278 #endif
279 #ifdef CONFIG_SHA512
280 {
281 .name = "sha512",
282 .digest_size = SHA512_SUM_LEN,
283 .chunk_size = CHUNKSZ_SHA512,
284 #ifdef CONFIG_SHA512_HW_ACCEL
285 .hash_func_ws = hw_sha512,
286 #else
287 .hash_func_ws = sha512_csum_wd,
288 #endif
289 #if defined(CONFIG_SHA512_HW_ACCEL) && defined(CONFIG_SHA_PROG_HW_ACCEL)
290 .hash_init = hw_sha_init,
291 .hash_update = hw_sha_update,
292 .hash_finish = hw_sha_finish,
293 #else
294 .hash_init = hash_init_sha512,
295 .hash_update = hash_update_sha512,
296 .hash_finish = hash_finish_sha512,
297 #endif
298 },
299 #endif
300 {
301 .name = "crc16-ccitt",
302 .digest_size = 2,
303 .chunk_size = CHUNKSZ,
304 .hash_func_ws = crc16_ccitt_wd_buf,
305 .hash_init = hash_init_crc16_ccitt,
306 .hash_update = hash_update_crc16_ccitt,
307 .hash_finish = hash_finish_crc16_ccitt,
308 },
309 {
310 .name = "crc32",
311 .digest_size = 4,
312 .chunk_size = CHUNKSZ_CRC32,
313 .hash_func_ws = crc32_wd_buf,
314 .hash_init = hash_init_crc32,
315 .hash_update = hash_update_crc32,
316 .hash_finish = hash_finish_crc32,
317 },
318 };
319
320 /* Try to minimize code size for boards that don't want much hashing */
321 #if defined(CONFIG_SHA256) || defined(CONFIG_CMD_SHA1SUM) || \
322 defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_CMD_HASH) || \
323 defined(CONFIG_SHA384) || defined(CONFIG_SHA512)
324 #define multi_hash() 1
325 #else
326 #define multi_hash() 0
327 #endif
328
reloc_update(void)329 static void reloc_update(void)
330 {
331 #if !defined(USE_HOSTCC) && defined(CONFIG_NEEDS_MANUAL_RELOC)
332 int i;
333 static bool done;
334
335 if (!done) {
336 done = true;
337 for (i = 0; i < ARRAY_SIZE(hash_algo); i++) {
338 hash_algo[i].name += gd->reloc_off;
339 hash_algo[i].hash_func_ws += gd->reloc_off;
340 hash_algo[i].hash_init += gd->reloc_off;
341 hash_algo[i].hash_update += gd->reloc_off;
342 hash_algo[i].hash_finish += gd->reloc_off;
343 }
344 }
345 #endif
346 }
347
hash_lookup_algo(const char * algo_name,struct hash_algo ** algop)348 int hash_lookup_algo(const char *algo_name, struct hash_algo **algop)
349 {
350 int i;
351
352 reloc_update();
353
354 for (i = 0; i < ARRAY_SIZE(hash_algo); i++) {
355 if (!strcmp(algo_name, hash_algo[i].name)) {
356 *algop = &hash_algo[i];
357 return 0;
358 }
359 }
360
361 debug("Unknown hash algorithm '%s'\n", algo_name);
362 return -EPROTONOSUPPORT;
363 }
364
hash_progressive_lookup_algo(const char * algo_name,struct hash_algo ** algop)365 int hash_progressive_lookup_algo(const char *algo_name,
366 struct hash_algo **algop)
367 {
368 int i;
369
370 reloc_update();
371
372 for (i = 0; i < ARRAY_SIZE(hash_algo); i++) {
373 if (!strcmp(algo_name, hash_algo[i].name)) {
374 if (hash_algo[i].hash_init) {
375 *algop = &hash_algo[i];
376 return 0;
377 }
378 }
379 }
380
381 debug("Unknown hash algorithm '%s'\n", algo_name);
382 return -EPROTONOSUPPORT;
383 }
384
385 #ifndef USE_HOSTCC
hash_parse_string(const char * algo_name,const char * str,uint8_t * result)386 int hash_parse_string(const char *algo_name, const char *str, uint8_t *result)
387 {
388 struct hash_algo *algo;
389 int ret;
390 int i;
391
392 ret = hash_lookup_algo(algo_name, &algo);
393 if (ret)
394 return ret;
395
396 for (i = 0; i < algo->digest_size; i++) {
397 char chr[3];
398
399 strncpy(chr, &str[i * 2], 2);
400 result[i] = simple_strtoul(chr, NULL, 16);
401 }
402
403 return 0;
404 }
405
hash_block(const char * algo_name,const void * data,unsigned int len,uint8_t * output,int * output_size)406 int hash_block(const char *algo_name, const void *data, unsigned int len,
407 uint8_t *output, int *output_size)
408 {
409 struct hash_algo *algo;
410 int ret;
411
412 ret = hash_lookup_algo(algo_name, &algo);
413 if (ret)
414 return ret;
415
416 if (output_size && *output_size < algo->digest_size) {
417 debug("Output buffer size %d too small (need %d bytes)",
418 *output_size, algo->digest_size);
419 return -ENOSPC;
420 }
421 if (output_size)
422 *output_size = algo->digest_size;
423 algo->hash_func_ws(data, len, output, algo->chunk_size);
424
425 return 0;
426 }
427
428 #if defined(CONFIG_CMD_HASH) || defined(CONFIG_CMD_SHA1SUM) || defined(CONFIG_CMD_CRC32)
429 /**
430 * store_result: Store the resulting sum to an address or variable
431 *
432 * @algo: Hash algorithm being used
433 * @sum: Hash digest (algo->digest_size bytes)
434 * @dest: Destination, interpreted as a hex address if it starts
435 * with * (or allow_env_vars is 0) or otherwise as an
436 * environment variable.
437 * @allow_env_vars: non-zero to permit storing the result to an
438 * variable environment
439 */
store_result(struct hash_algo * algo,const uint8_t * sum,const char * dest,int allow_env_vars)440 static void store_result(struct hash_algo *algo, const uint8_t *sum,
441 const char *dest, int allow_env_vars)
442 {
443 unsigned int i;
444 int env_var = 0;
445
446 /*
447 * If environment variables are allowed, then we assume that 'dest'
448 * is an environment variable, unless it starts with *, in which
449 * case we assume it is an address. If not allowed, it is always an
450 * address. This is to support the crc32 command.
451 */
452 if (allow_env_vars) {
453 if (*dest == '*')
454 dest++;
455 else
456 env_var = 1;
457 }
458
459 if (env_var) {
460 char str_output[HASH_MAX_DIGEST_SIZE * 2 + 1];
461 char *str_ptr = str_output;
462
463 for (i = 0; i < algo->digest_size; i++) {
464 sprintf(str_ptr, "%02x", sum[i]);
465 str_ptr += 2;
466 }
467 *str_ptr = '\0';
468 env_set(dest, str_output);
469 } else {
470 ulong addr;
471 void *buf;
472
473 addr = simple_strtoul(dest, NULL, 16);
474 buf = map_sysmem(addr, algo->digest_size);
475 memcpy(buf, sum, algo->digest_size);
476 unmap_sysmem(buf);
477 }
478 }
479
480 /**
481 * parse_verify_sum: Parse a hash verification parameter
482 *
483 * @algo: Hash algorithm being used
484 * @verify_str: Argument to parse. If it starts with * then it is
485 * interpreted as a hex address containing the hash.
486 * If the length is exactly the right number of hex digits
487 * for the digest size, then we assume it is a hex digest.
488 * Otherwise we assume it is an environment variable, and
489 * look up its value (it must contain a hex digest).
490 * @vsum: Returns binary digest value (algo->digest_size bytes)
491 * @allow_env_vars: non-zero to permit storing the result to an environment
492 * variable. If 0 then verify_str is assumed to be an
493 * address, and the * prefix is not expected.
494 * @return 0 if ok, non-zero on error
495 */
parse_verify_sum(struct hash_algo * algo,char * verify_str,uint8_t * vsum,int allow_env_vars)496 static int parse_verify_sum(struct hash_algo *algo, char *verify_str,
497 uint8_t *vsum, int allow_env_vars)
498 {
499 int env_var = 0;
500
501 /* See comment above in store_result() */
502 if (allow_env_vars) {
503 if (*verify_str == '*')
504 verify_str++;
505 else
506 env_var = 1;
507 }
508
509 if (!env_var) {
510 ulong addr;
511 void *buf;
512
513 addr = simple_strtoul(verify_str, NULL, 16);
514 buf = map_sysmem(addr, algo->digest_size);
515 memcpy(vsum, buf, algo->digest_size);
516 } else {
517 char *vsum_str;
518 int digits = algo->digest_size * 2;
519
520 /*
521 * As with the original code from sha1sum.c, we assume that a
522 * string which matches the digest size exactly is a hex
523 * string and not an environment variable.
524 */
525 if (strlen(verify_str) == digits)
526 vsum_str = verify_str;
527 else {
528 vsum_str = env_get(verify_str);
529 if (vsum_str == NULL || strlen(vsum_str) != digits) {
530 printf("Expected %d hex digits in env var\n",
531 digits);
532 return 1;
533 }
534 }
535
536 hash_parse_string(algo->name, vsum_str, vsum);
537 }
538 return 0;
539 }
540
hash_show(struct hash_algo * algo,ulong addr,ulong len,uint8_t * output)541 static void hash_show(struct hash_algo *algo, ulong addr, ulong len, uint8_t *output)
542 {
543 int i;
544
545 printf("%s for %08lx ... %08lx ==> ", algo->name, addr, addr + len - 1);
546 for (i = 0; i < algo->digest_size; i++)
547 printf("%02x", output[i]);
548 }
549
hash_command(const char * algo_name,int flags,struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])550 int hash_command(const char *algo_name, int flags, struct cmd_tbl *cmdtp,
551 int flag, int argc, char *const argv[])
552 {
553 ulong addr, len;
554
555 if ((argc < 2) || ((flags & HASH_FLAG_VERIFY) && (argc < 3)))
556 return CMD_RET_USAGE;
557
558 addr = simple_strtoul(*argv++, NULL, 16);
559 len = simple_strtoul(*argv++, NULL, 16);
560
561 if (multi_hash()) {
562 struct hash_algo *algo;
563 u8 *output;
564 uint8_t vsum[HASH_MAX_DIGEST_SIZE];
565 void *buf;
566
567 if (hash_lookup_algo(algo_name, &algo)) {
568 printf("Unknown hash algorithm '%s'\n", algo_name);
569 return CMD_RET_USAGE;
570 }
571 argc -= 2;
572
573 if (algo->digest_size > HASH_MAX_DIGEST_SIZE) {
574 puts("HASH_MAX_DIGEST_SIZE exceeded\n");
575 return 1;
576 }
577
578 output = memalign(ARCH_DMA_MINALIGN,
579 sizeof(uint32_t) * HASH_MAX_DIGEST_SIZE);
580
581 buf = map_sysmem(addr, len);
582 algo->hash_func_ws(buf, len, output, algo->chunk_size);
583 unmap_sysmem(buf);
584
585 /* Try to avoid code bloat when verify is not needed */
586 #if defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_SHA1SUM_VERIFY) || \
587 defined(CONFIG_HASH_VERIFY)
588 if (flags & HASH_FLAG_VERIFY) {
589 #else
590 if (0) {
591 #endif
592 if (parse_verify_sum(algo, *argv, vsum,
593 flags & HASH_FLAG_ENV)) {
594 printf("ERROR: %s does not contain a valid "
595 "%s sum\n", *argv, algo->name);
596 return 1;
597 }
598 if (memcmp(output, vsum, algo->digest_size) != 0) {
599 int i;
600
601 hash_show(algo, addr, len, output);
602 printf(" != ");
603 for (i = 0; i < algo->digest_size; i++)
604 printf("%02x", vsum[i]);
605 puts(" ** ERROR **\n");
606 return 1;
607 }
608 } else {
609 hash_show(algo, addr, len, output);
610 printf("\n");
611
612 if (argc) {
613 store_result(algo, output, *argv,
614 flags & HASH_FLAG_ENV);
615 }
616 unmap_sysmem(output);
617
618 }
619
620 /* Horrible code size hack for boards that just want crc32 */
621 } else {
622 ulong crc;
623 ulong *ptr;
624
625 crc = crc32_wd(0, (const uchar *)addr, len, CHUNKSZ_CRC32);
626
627 printf("CRC32 for %08lx ... %08lx ==> %08lx\n",
628 addr, addr + len - 1, crc);
629
630 if (argc >= 3) {
631 ptr = (ulong *)simple_strtoul(argv[0], NULL, 16);
632 *ptr = crc;
633 }
634 }
635
636 return 0;
637 }
638 #endif /* CONFIG_CMD_HASH || CONFIG_CMD_SHA1SUM || CONFIG_CMD_CRC32) */
639 #endif /* !USE_HOSTCC */
640