blob: 10dff7ddb0e7fd40b8a8444677a3db4438f14860 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Simon Glass460408e2012-12-05 14:46:36 +00002/*
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.
Simon Glass460408e2012-12-05 14:46:36 +000010 */
11
Ruchika Gupta2dd90022015-01-23 16:01:58 +053012#ifndef USE_HOSTCC
Simon Glass460408e2012-12-05 14:46:36 +000013#include <common.h>
14#include <command.h>
Simon Glass9fb625c2019-08-01 09:46:51 -060015#include <env.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060016#include <log.h>
Hung-ying Tyanbf007eb2014-03-03 12:19:28 +010017#include <malloc.h>
Joe Hershberger0eb25b62015-03-22 17:08:59 -050018#include <mapmem.h>
Akshay Saraswat1f9c9282013-03-20 21:00:58 +000019#include <hw_sha.h>
Simon Glass90526e92020-05-10 11:39:56 -060020#include <asm/cache.h>
Simon Glass401d1c42020-10-30 21:38:53 -060021#include <asm/global_data.h>
Simon Glassbd091b62013-02-24 17:33:31 +000022#include <asm/io.h>
Masahiro Yamada1221ce42016-09-21 11:28:55 +090023#include <linux/errno.h>
Simon Glass3db71102019-11-14 12:57:16 -070024#include <u-boot/crc.h>
Ruchika Gupta2dd90022015-01-23 16:01:58 +053025#else
26#include "mkimage.h"
27#include <time.h>
Ruchika Gupta2dd90022015-01-23 16:01:58 +053028#endif /* !USE_HOSTCC*/
29
30#include <hash.h>
Simon Glass4d72caa2020-05-10 11:40:01 -060031#include <image.h>
Ruchika Gupta2dd90022015-01-23 16:01:58 +053032#include <u-boot/crc.h>
33#include <u-boot/sha1.h>
34#include <u-boot/sha256.h>
Reuben Dowled16b38f2020-04-16 17:36:52 +120035#include <u-boot/sha512.h>
Ruchika Gupta2dd90022015-01-23 16:01:58 +053036#include <u-boot/md5.h>
Simon Glass460408e2012-12-05 14:46:36 +000037
T Karthik Reddy10088fb2019-03-16 15:23:01 +053038#if !defined(USE_HOSTCC) && defined(CONFIG_NEEDS_MANUAL_RELOC)
39DECLARE_GLOBAL_DATA_PTR;
40#endif
41
42static void reloc_update(void);
43
Tom Rini78eda892017-08-14 16:38:07 -040044#if defined(CONFIG_SHA1) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
Hung-ying Tyanbf007eb2014-03-03 12:19:28 +010045static 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
53static 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
60static 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
Tom Rini78eda892017-08-14 16:38:07 -040072#if defined(CONFIG_SHA256) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
Hung-ying Tyanbf007eb2014-03-03 12:19:28 +010073static 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
81static 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
88static 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
Joel Stanleya479f102021-02-17 13:50:42 +1030100#if defined(CONFIG_SHA384) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
Reuben Dowled16b38f2020-04-16 17:36:52 +1200101static 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
109static 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
116static 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
Joel Stanleya479f102021-02-17 13:50:42 +1030128#if defined(CONFIG_SHA512) && !defined(CONFIG_SHA_PROG_HW_ACCEL)
Reuben Dowled16b38f2020-04-16 17:36:52 +1200129static 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
137static 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
144static 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
Reuben Dowled16b38f2020-04-16 17:36:52 +1200150 sha512_finish((sha512_context *)ctx, dest_buf);
151 free(ctx);
152 return 0;
153}
154#endif
155
156
Philipp Tomsich51c23452018-11-25 19:22:19 +0100157static 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
165static 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
173static 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
Hung-ying Tyanbf007eb2014-03-03 12:19:28 +0100184static 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
192static 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
199static 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
Simon Glass460408e2012-12-05 14:46:36 +0000210/*
Tom Rini78eda892017-08-14 16:38:07 -0400211 * 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.
Simon Glass460408e2012-12-05 14:46:36 +0000214 */
215static struct hash_algo hash_algo[] = {
Ruchika Gupta46fe2c02015-01-23 16:01:57 +0530216#ifdef CONFIG_SHA1
Simon Glass460408e2012-12-05 14:46:36 +0000217 {
Tom Rini78eda892017-08-14 16:38:07 -0400218 .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
Simon Glass460408e2012-12-05 14:46:36 +0000235 },
236#endif
237#ifdef CONFIG_SHA256
238 {
Tom Rini78eda892017-08-14 16:38:07 -0400239 .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
Simon Glass460408e2012-12-05 14:46:36 +0000256 },
257#endif
Reuben Dowled16b38f2020-04-16 17:36:52 +1200258#ifdef CONFIG_SHA384
259 {
260 .name = "sha384",
261 .digest_size = SHA384_SUM_LEN,
262 .chunk_size = CHUNKSZ_SHA384,
Joel Stanleya479f102021-02-17 13:50:42 +1030263#ifdef CONFIG_SHA_HW_ACCEL
264 .hash_func_ws = hw_sha384,
265#else
Reuben Dowled16b38f2020-04-16 17:36:52 +1200266 .hash_func_ws = sha384_csum_wd,
Joel Stanleya479f102021-02-17 13:50:42 +1030267#endif
268#ifdef 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
Reuben Dowled16b38f2020-04-16 17:36:52 +1200273 .hash_init = hash_init_sha384,
274 .hash_update = hash_update_sha384,
275 .hash_finish = hash_finish_sha384,
Joel Stanleya479f102021-02-17 13:50:42 +1030276#endif
Reuben Dowled16b38f2020-04-16 17:36:52 +1200277 },
278#endif
279#ifdef CONFIG_SHA512
280 {
281 .name = "sha512",
282 .digest_size = SHA512_SUM_LEN,
283 .chunk_size = CHUNKSZ_SHA512,
Joel Stanleya479f102021-02-17 13:50:42 +1030284#ifdef CONFIG_SHA_HW_ACCEL
285 .hash_func_ws = hw_sha512,
286#else
Reuben Dowled16b38f2020-04-16 17:36:52 +1200287 .hash_func_ws = sha512_csum_wd,
Joel Stanleya479f102021-02-17 13:50:42 +1030288#endif
289#ifdef 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
Reuben Dowled16b38f2020-04-16 17:36:52 +1200294 .hash_init = hash_init_sha512,
295 .hash_update = hash_update_sha512,
296 .hash_finish = hash_finish_sha512,
Joel Stanleya479f102021-02-17 13:50:42 +1030297#endif
Reuben Dowled16b38f2020-04-16 17:36:52 +1200298 },
299#endif
Simon Glassd20a40d2013-02-24 20:30:22 +0000300 {
Philipp Tomsich51c23452018-11-25 19:22:19 +0100301 .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 {
Tom Rini78eda892017-08-14 16:38:07 -0400310 .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,
Simon Glassd20a40d2013-02-24 20:30:22 +0000317 },
Simon Glass460408e2012-12-05 14:46:36 +0000318};
319
Simon Glassd20a40d2013-02-24 20:30:22 +0000320/* Try to minimize code size for boards that don't want much hashing */
Daniel Thompson221a9492017-05-19 17:26:58 +0100321#if defined(CONFIG_SHA256) || defined(CONFIG_CMD_SHA1SUM) || \
Reuben Dowled16b38f2020-04-16 17:36:52 +1200322 defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_CMD_HASH) || \
323 defined(CONFIG_SHA384) || defined(CONFIG_SHA512)
Simon Glassd20a40d2013-02-24 20:30:22 +0000324#define multi_hash() 1
325#else
326#define multi_hash() 0
327#endif
328
T Karthik Reddy10088fb2019-03-16 15:23:01 +0530329static 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
Ruchika Gupta2dd90022015-01-23 16:01:58 +0530348int hash_lookup_algo(const char *algo_name, struct hash_algo **algop)
349{
350 int i;
351
T Karthik Reddy10088fb2019-03-16 15:23:01 +0530352 reloc_update();
353
Ruchika Gupta2dd90022015-01-23 16:01:58 +0530354 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
365int hash_progressive_lookup_algo(const char *algo_name,
366 struct hash_algo **algop)
367{
368 int i;
369
T Karthik Reddy10088fb2019-03-16 15:23:01 +0530370 reloc_update();
371
Ruchika Gupta2dd90022015-01-23 16:01:58 +0530372 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
Stefan Roese8f0b1e22015-05-18 14:08:24 +0200386int 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
Tom Rini48ad68d2016-01-05 08:47:48 -0500406int 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)
Simon Glass460408e2012-12-05 14:46:36 +0000429/**
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
Simon Glassd5b76672013-02-24 17:33:26 +0000435 * 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
Simon Glass460408e2012-12-05 14:46:36 +0000439 */
Simon Glass04819a42014-06-12 07:24:41 -0600440static void store_result(struct hash_algo *algo, const uint8_t *sum,
Simon Glassd5b76672013-02-24 17:33:26 +0000441 const char *dest, int allow_env_vars)
Simon Glass460408e2012-12-05 14:46:36 +0000442{
443 unsigned int i;
Simon Glassd5b76672013-02-24 17:33:26 +0000444 int env_var = 0;
Simon Glass460408e2012-12-05 14:46:36 +0000445
Simon Glassd5b76672013-02-24 17:33:26 +0000446 /*
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 }
Simon Glass460408e2012-12-05 14:46:36 +0000458
Simon Glassd5b76672013-02-24 17:33:26 +0000459 if (env_var) {
Simon Glass460408e2012-12-05 14:46:36 +0000460 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 }
Jeroen Hofstee8b9cc862014-06-09 11:02:02 +0200467 *str_ptr = '\0';
Simon Glass382bee52017-08-03 12:22:09 -0600468 env_set(dest, str_output);
Simon Glassd5b76672013-02-24 17:33:26 +0000469 } else {
Simon Glassbd091b62013-02-24 17:33:31 +0000470 ulong addr;
471 void *buf;
Simon Glassd5b76672013-02-24 17:33:26 +0000472
Simon Glassbd091b62013-02-24 17:33:31 +0000473 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);
Simon Glass460408e2012-12-05 14:46:36 +0000477 }
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)
Simon Glassd5b76672013-02-24 17:33:26 +0000491 * @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.
Simon Glass460408e2012-12-05 14:46:36 +0000494 * @return 0 if ok, non-zero on error
495 */
Simon Glass04819a42014-06-12 07:24:41 -0600496static int parse_verify_sum(struct hash_algo *algo, char *verify_str,
497 uint8_t *vsum, int allow_env_vars)
Simon Glass460408e2012-12-05 14:46:36 +0000498{
Simon Glassd5b76672013-02-24 17:33:26 +0000499 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
Nikolay Dimitrov3ef46a92014-12-12 20:01:23 +0200509 if (!env_var) {
Simon Glassbd091b62013-02-24 17:33:31 +0000510 ulong addr;
511 void *buf;
Simon Glass460408e2012-12-05 14:46:36 +0000512
Simon Glassbd091b62013-02-24 17:33:31 +0000513 addr = simple_strtoul(verify_str, NULL, 16);
514 buf = map_sysmem(addr, algo->digest_size);
515 memcpy(vsum, buf, algo->digest_size);
Simon Glass460408e2012-12-05 14:46:36 +0000516 } else {
Simon Glass460408e2012-12-05 14:46:36 +0000517 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 {
Simon Glass00caae62017-08-03 12:22:12 -0600528 vsum_str = env_get(verify_str);
Simon Glass460408e2012-12-05 14:46:36 +0000529 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
Stefan Roese8f0b1e22015-05-18 14:08:24 +0200536 hash_parse_string(algo->name, vsum_str, vsum);
Simon Glass460408e2012-12-05 14:46:36 +0000537 }
538 return 0;
539}
540
Tom Rini48ad68d2016-01-05 08:47:48 -0500541static void hash_show(struct hash_algo *algo, ulong addr, ulong len, uint8_t *output)
Simon Glass460408e2012-12-05 14:46:36 +0000542{
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
Simon Glass09140112020-05-10 11:40:03 -0600550int hash_command(const char *algo_name, int flags, struct cmd_tbl *cmdtp,
551 int flag, int argc, char *const argv[])
Simon Glass460408e2012-12-05 14:46:36 +0000552{
Simon Glass460408e2012-12-05 14:46:36 +0000553 ulong addr, len;
Simon Glass460408e2012-12-05 14:46:36 +0000554
Nikolay Dimitrov3ef46a92014-12-12 20:01:23 +0200555 if ((argc < 2) || ((flags & HASH_FLAG_VERIFY) && (argc < 3)))
Simon Glass460408e2012-12-05 14:46:36 +0000556 return CMD_RET_USAGE;
557
Simon Glassd5b76672013-02-24 17:33:26 +0000558 addr = simple_strtoul(*argv++, NULL, 16);
559 len = simple_strtoul(*argv++, NULL, 16);
560
Simon Glassd20a40d2013-02-24 20:30:22 +0000561 if (multi_hash()) {
562 struct hash_algo *algo;
Breno Limad7af2ba2018-01-17 10:03:45 -0200563 u8 *output;
Simon Glass04819a42014-06-12 07:24:41 -0600564 uint8_t vsum[HASH_MAX_DIGEST_SIZE];
Simon Glassbd091b62013-02-24 17:33:31 +0000565 void *buf;
Simon Glass460408e2012-12-05 14:46:36 +0000566
Hung-ying Tyanbf007eb2014-03-03 12:19:28 +0100567 if (hash_lookup_algo(algo_name, &algo)) {
Simon Glassd20a40d2013-02-24 20:30:22 +0000568 printf("Unknown hash algorithm '%s'\n", algo_name);
Simon Glass460408e2012-12-05 14:46:36 +0000569 return CMD_RET_USAGE;
Simon Glassd20a40d2013-02-24 20:30:22 +0000570 }
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
Breno Limad7af2ba2018-01-17 10:03:45 -0200578 output = memalign(ARCH_DMA_MINALIGN,
579 sizeof(uint32_t) * HASH_MAX_DIGEST_SIZE);
580
Simon Glassbd091b62013-02-24 17:33:31 +0000581 buf = map_sysmem(addr, len);
582 algo->hash_func_ws(buf, len, output, algo->chunk_size);
583 unmap_sysmem(buf);
Simon Glassd20a40d2013-02-24 20:30:22 +0000584
585 /* Try to avoid code bloat when verify is not needed */
Daniel Thompson221a9492017-05-19 17:26:58 +0100586#if defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_SHA1SUM_VERIFY) || \
587 defined(CONFIG_HASH_VERIFY)
Simon Glassd20a40d2013-02-24 20:30:22 +0000588 if (flags & HASH_FLAG_VERIFY) {
589#else
590 if (0) {
591#endif
Simon Glassd20a40d2013-02-24 20:30:22 +0000592 if (parse_verify_sum(algo, *argv, vsum,
Simon Glassd5b76672013-02-24 17:33:26 +0000593 flags & HASH_FLAG_ENV)) {
Simon Glassd20a40d2013-02-24 20:30:22 +0000594 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;
Simon Glass460408e2012-12-05 14:46:36 +0000600
Simon Glass31890ae2014-06-02 22:04:49 -0600601 hash_show(algo, addr, len, output);
Simon Glassd20a40d2013-02-24 20:30:22 +0000602 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 {
Simon Glass31890ae2014-06-02 22:04:49 -0600609 hash_show(algo, addr, len, output);
Simon Glassd20a40d2013-02-24 20:30:22 +0000610 printf("\n");
Simon Glass460408e2012-12-05 14:46:36 +0000611
Simon Glassd20a40d2013-02-24 20:30:22 +0000612 if (argc) {
613 store_result(algo, output, *argv,
614 flags & HASH_FLAG_ENV);
615 }
Breno Limad7af2ba2018-01-17 10:03:45 -0200616 unmap_sysmem(output);
617
Simon Glassd20a40d2013-02-24 20:30:22 +0000618 }
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
Tom Rini4b756b02013-11-07 07:39:48 -0500630 if (argc >= 3) {
631 ptr = (ulong *)simple_strtoul(argv[0], NULL, 16);
Simon Glassd20a40d2013-02-24 20:30:22 +0000632 *ptr = crc;
Simon Glassd5b76672013-02-24 17:33:26 +0000633 }
Simon Glass460408e2012-12-05 14:46:36 +0000634 }
635
636 return 0;
637}
Simon Glassd70f9192017-05-17 09:05:34 -0600638#endif /* CONFIG_CMD_HASH || CONFIG_CMD_SHA1SUM || CONFIG_CMD_CRC32) */
639#endif /* !USE_HOSTCC */