1460408efSSimon Glass /* 2460408efSSimon Glass * Copyright (c) 2012 The Chromium OS Authors. 3460408efSSimon Glass * 4460408efSSimon Glass * (C) Copyright 2011 5460408efSSimon Glass * Joe Hershberger, National Instruments, joe.hershberger@ni.com 6460408efSSimon Glass * 7460408efSSimon Glass * (C) Copyright 2000 8460408efSSimon Glass * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 9460408efSSimon Glass * 101a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 11460408efSSimon Glass */ 12460408efSSimon Glass 132dd90027SRuchika Gupta #ifndef USE_HOSTCC 14460408efSSimon Glass #include <common.h> 15460408efSSimon Glass #include <command.h> 16bf007ebbSHung-ying Tyan #include <malloc.h> 170eb25b61SJoe Hershberger #include <mapmem.h> 181f9c9280SAkshay Saraswat #include <hw_sha.h> 19bd091b67SSimon Glass #include <asm/io.h> 201221ce45SMasahiro Yamada #include <linux/errno.h> 212dd90027SRuchika Gupta #else 222dd90027SRuchika Gupta #include "mkimage.h" 232dd90027SRuchika Gupta #include <time.h> 242dd90027SRuchika Gupta #include <image.h> 252dd90027SRuchika Gupta #endif /* !USE_HOSTCC*/ 262dd90027SRuchika Gupta 272dd90027SRuchika Gupta #include <hash.h> 282dd90027SRuchika Gupta #include <u-boot/crc.h> 292dd90027SRuchika Gupta #include <u-boot/sha1.h> 302dd90027SRuchika Gupta #include <u-boot/sha256.h> 312dd90027SRuchika Gupta #include <u-boot/md5.h> 32460408efSSimon Glass 3378eda89eSTom Rini #if defined(CONFIG_SHA1) && !defined(CONFIG_SHA_PROG_HW_ACCEL) 34bf007ebbSHung-ying Tyan static int hash_init_sha1(struct hash_algo *algo, void **ctxp) 35bf007ebbSHung-ying Tyan { 36bf007ebbSHung-ying Tyan sha1_context *ctx = malloc(sizeof(sha1_context)); 37bf007ebbSHung-ying Tyan sha1_starts(ctx); 38bf007ebbSHung-ying Tyan *ctxp = ctx; 39bf007ebbSHung-ying Tyan return 0; 40bf007ebbSHung-ying Tyan } 41bf007ebbSHung-ying Tyan 42bf007ebbSHung-ying Tyan static int hash_update_sha1(struct hash_algo *algo, void *ctx, const void *buf, 43bf007ebbSHung-ying Tyan unsigned int size, int is_last) 44bf007ebbSHung-ying Tyan { 45bf007ebbSHung-ying Tyan sha1_update((sha1_context *)ctx, buf, size); 46bf007ebbSHung-ying Tyan return 0; 47bf007ebbSHung-ying Tyan } 48bf007ebbSHung-ying Tyan 49bf007ebbSHung-ying Tyan static int hash_finish_sha1(struct hash_algo *algo, void *ctx, void *dest_buf, 50bf007ebbSHung-ying Tyan int size) 51bf007ebbSHung-ying Tyan { 52bf007ebbSHung-ying Tyan if (size < algo->digest_size) 53bf007ebbSHung-ying Tyan return -1; 54bf007ebbSHung-ying Tyan 55bf007ebbSHung-ying Tyan sha1_finish((sha1_context *)ctx, dest_buf); 56bf007ebbSHung-ying Tyan free(ctx); 57bf007ebbSHung-ying Tyan return 0; 58bf007ebbSHung-ying Tyan } 59bf007ebbSHung-ying Tyan #endif 60bf007ebbSHung-ying Tyan 6178eda89eSTom Rini #if defined(CONFIG_SHA256) && !defined(CONFIG_SHA_PROG_HW_ACCEL) 62bf007ebbSHung-ying Tyan static int hash_init_sha256(struct hash_algo *algo, void **ctxp) 63bf007ebbSHung-ying Tyan { 64bf007ebbSHung-ying Tyan sha256_context *ctx = malloc(sizeof(sha256_context)); 65bf007ebbSHung-ying Tyan sha256_starts(ctx); 66bf007ebbSHung-ying Tyan *ctxp = ctx; 67bf007ebbSHung-ying Tyan return 0; 68bf007ebbSHung-ying Tyan } 69bf007ebbSHung-ying Tyan 70bf007ebbSHung-ying Tyan static int hash_update_sha256(struct hash_algo *algo, void *ctx, 71bf007ebbSHung-ying Tyan const void *buf, unsigned int size, int is_last) 72bf007ebbSHung-ying Tyan { 73bf007ebbSHung-ying Tyan sha256_update((sha256_context *)ctx, buf, size); 74bf007ebbSHung-ying Tyan return 0; 75bf007ebbSHung-ying Tyan } 76bf007ebbSHung-ying Tyan 77bf007ebbSHung-ying Tyan static int hash_finish_sha256(struct hash_algo *algo, void *ctx, void 78bf007ebbSHung-ying Tyan *dest_buf, int size) 79bf007ebbSHung-ying Tyan { 80bf007ebbSHung-ying Tyan if (size < algo->digest_size) 81bf007ebbSHung-ying Tyan return -1; 82bf007ebbSHung-ying Tyan 83bf007ebbSHung-ying Tyan sha256_finish((sha256_context *)ctx, dest_buf); 84bf007ebbSHung-ying Tyan free(ctx); 85bf007ebbSHung-ying Tyan return 0; 86bf007ebbSHung-ying Tyan } 87bf007ebbSHung-ying Tyan #endif 88bf007ebbSHung-ying Tyan 89bf007ebbSHung-ying Tyan static int hash_init_crc32(struct hash_algo *algo, void **ctxp) 90bf007ebbSHung-ying Tyan { 91bf007ebbSHung-ying Tyan uint32_t *ctx = malloc(sizeof(uint32_t)); 92bf007ebbSHung-ying Tyan *ctx = 0; 93bf007ebbSHung-ying Tyan *ctxp = ctx; 94bf007ebbSHung-ying Tyan return 0; 95bf007ebbSHung-ying Tyan } 96bf007ebbSHung-ying Tyan 97bf007ebbSHung-ying Tyan static int hash_update_crc32(struct hash_algo *algo, void *ctx, 98bf007ebbSHung-ying Tyan const void *buf, unsigned int size, int is_last) 99bf007ebbSHung-ying Tyan { 100bf007ebbSHung-ying Tyan *((uint32_t *)ctx) = crc32(*((uint32_t *)ctx), buf, size); 101bf007ebbSHung-ying Tyan return 0; 102bf007ebbSHung-ying Tyan } 103bf007ebbSHung-ying Tyan 104bf007ebbSHung-ying Tyan static int hash_finish_crc32(struct hash_algo *algo, void *ctx, void *dest_buf, 105bf007ebbSHung-ying Tyan int size) 106bf007ebbSHung-ying Tyan { 107bf007ebbSHung-ying Tyan if (size < algo->digest_size) 108bf007ebbSHung-ying Tyan return -1; 109bf007ebbSHung-ying Tyan 110bf007ebbSHung-ying Tyan *((uint32_t *)dest_buf) = *((uint32_t *)ctx); 111bf007ebbSHung-ying Tyan free(ctx); 112bf007ebbSHung-ying Tyan return 0; 113bf007ebbSHung-ying Tyan } 114bf007ebbSHung-ying Tyan 115460408efSSimon Glass /* 11678eda89eSTom Rini * These are the hash algorithms we support. If we have hardware acceleration 11778eda89eSTom Rini * is enable we will use that, otherwise a software version of the algorithm. 11878eda89eSTom Rini * Note that algorithm names must be in lower case. 119460408efSSimon Glass */ 120460408efSSimon Glass static struct hash_algo hash_algo[] = { 12146fe2c04SRuchika Gupta #ifdef CONFIG_SHA1 122460408efSSimon Glass { 12378eda89eSTom Rini .name = "sha1", 12478eda89eSTom Rini .digest_size = SHA1_SUM_LEN, 12578eda89eSTom Rini .chunk_size = CHUNKSZ_SHA1, 12678eda89eSTom Rini #ifdef CONFIG_SHA_HW_ACCEL 12778eda89eSTom Rini .hash_func_ws = hw_sha1, 12878eda89eSTom Rini #else 12978eda89eSTom Rini .hash_func_ws = sha1_csum_wd, 13078eda89eSTom Rini #endif 13178eda89eSTom Rini #ifdef CONFIG_SHA_PROG_HW_ACCEL 13278eda89eSTom Rini .hash_init = hw_sha_init, 13378eda89eSTom Rini .hash_update = hw_sha_update, 13478eda89eSTom Rini .hash_finish = hw_sha_finish, 13578eda89eSTom Rini #else 13678eda89eSTom Rini .hash_init = hash_init_sha1, 13778eda89eSTom Rini .hash_update = hash_update_sha1, 13878eda89eSTom Rini .hash_finish = hash_finish_sha1, 13978eda89eSTom Rini #endif 140460408efSSimon Glass }, 141460408efSSimon Glass #endif 142460408efSSimon Glass #ifdef CONFIG_SHA256 143460408efSSimon Glass { 14478eda89eSTom Rini .name = "sha256", 14578eda89eSTom Rini .digest_size = SHA256_SUM_LEN, 14678eda89eSTom Rini .chunk_size = CHUNKSZ_SHA256, 14778eda89eSTom Rini #ifdef CONFIG_SHA_HW_ACCEL 14878eda89eSTom Rini .hash_func_ws = hw_sha256, 14978eda89eSTom Rini #else 15078eda89eSTom Rini .hash_func_ws = sha256_csum_wd, 15178eda89eSTom Rini #endif 15278eda89eSTom Rini #ifdef CONFIG_SHA_PROG_HW_ACCEL 15378eda89eSTom Rini .hash_init = hw_sha_init, 15478eda89eSTom Rini .hash_update = hw_sha_update, 15578eda89eSTom Rini .hash_finish = hw_sha_finish, 15678eda89eSTom Rini #else 15778eda89eSTom Rini .hash_init = hash_init_sha256, 15878eda89eSTom Rini .hash_update = hash_update_sha256, 15978eda89eSTom Rini .hash_finish = hash_finish_sha256, 16078eda89eSTom Rini #endif 161460408efSSimon Glass }, 162460408efSSimon Glass #endif 163d20a40deSSimon Glass { 16478eda89eSTom Rini .name = "crc32", 16578eda89eSTom Rini .digest_size = 4, 16678eda89eSTom Rini .chunk_size = CHUNKSZ_CRC32, 16778eda89eSTom Rini .hash_func_ws = crc32_wd_buf, 16878eda89eSTom Rini .hash_init = hash_init_crc32, 16978eda89eSTom Rini .hash_update = hash_update_crc32, 17078eda89eSTom Rini .hash_finish = hash_finish_crc32, 171d20a40deSSimon Glass }, 172460408efSSimon Glass }; 173460408efSSimon Glass 174d20a40deSSimon Glass /* Try to minimize code size for boards that don't want much hashing */ 175221a949eSDaniel Thompson #if defined(CONFIG_SHA256) || defined(CONFIG_CMD_SHA1SUM) || \ 176221a949eSDaniel Thompson defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_CMD_HASH) 177d20a40deSSimon Glass #define multi_hash() 1 178d20a40deSSimon Glass #else 179d20a40deSSimon Glass #define multi_hash() 0 180d20a40deSSimon Glass #endif 181d20a40deSSimon Glass 1822dd90027SRuchika Gupta int hash_lookup_algo(const char *algo_name, struct hash_algo **algop) 1832dd90027SRuchika Gupta { 1842dd90027SRuchika Gupta int i; 1852dd90027SRuchika Gupta 1862dd90027SRuchika Gupta for (i = 0; i < ARRAY_SIZE(hash_algo); i++) { 1872dd90027SRuchika Gupta if (!strcmp(algo_name, hash_algo[i].name)) { 1882dd90027SRuchika Gupta *algop = &hash_algo[i]; 1892dd90027SRuchika Gupta return 0; 1902dd90027SRuchika Gupta } 1912dd90027SRuchika Gupta } 1922dd90027SRuchika Gupta 1932dd90027SRuchika Gupta debug("Unknown hash algorithm '%s'\n", algo_name); 1942dd90027SRuchika Gupta return -EPROTONOSUPPORT; 1952dd90027SRuchika Gupta } 1962dd90027SRuchika Gupta 1972dd90027SRuchika Gupta int hash_progressive_lookup_algo(const char *algo_name, 1982dd90027SRuchika Gupta struct hash_algo **algop) 1992dd90027SRuchika Gupta { 2002dd90027SRuchika Gupta int i; 2012dd90027SRuchika Gupta 2022dd90027SRuchika Gupta for (i = 0; i < ARRAY_SIZE(hash_algo); i++) { 2032dd90027SRuchika Gupta if (!strcmp(algo_name, hash_algo[i].name)) { 2042dd90027SRuchika Gupta if (hash_algo[i].hash_init) { 2052dd90027SRuchika Gupta *algop = &hash_algo[i]; 2062dd90027SRuchika Gupta return 0; 2072dd90027SRuchika Gupta } 2082dd90027SRuchika Gupta } 2092dd90027SRuchika Gupta } 2102dd90027SRuchika Gupta 2112dd90027SRuchika Gupta debug("Unknown hash algorithm '%s'\n", algo_name); 2122dd90027SRuchika Gupta return -EPROTONOSUPPORT; 2132dd90027SRuchika Gupta } 2142dd90027SRuchika Gupta 2152dd90027SRuchika Gupta #ifndef USE_HOSTCC 2168f0b1e24SStefan Roese int hash_parse_string(const char *algo_name, const char *str, uint8_t *result) 2178f0b1e24SStefan Roese { 2188f0b1e24SStefan Roese struct hash_algo *algo; 2198f0b1e24SStefan Roese int ret; 2208f0b1e24SStefan Roese int i; 2218f0b1e24SStefan Roese 2228f0b1e24SStefan Roese ret = hash_lookup_algo(algo_name, &algo); 2238f0b1e24SStefan Roese if (ret) 2248f0b1e24SStefan Roese return ret; 2258f0b1e24SStefan Roese 2268f0b1e24SStefan Roese for (i = 0; i < algo->digest_size; i++) { 2278f0b1e24SStefan Roese char chr[3]; 2288f0b1e24SStefan Roese 2298f0b1e24SStefan Roese strncpy(chr, &str[i * 2], 2); 2308f0b1e24SStefan Roese result[i] = simple_strtoul(chr, NULL, 16); 2318f0b1e24SStefan Roese } 2328f0b1e24SStefan Roese 2338f0b1e24SStefan Roese return 0; 2348f0b1e24SStefan Roese } 2358f0b1e24SStefan Roese 23648ad68deSTom Rini int hash_block(const char *algo_name, const void *data, unsigned int len, 23748ad68deSTom Rini uint8_t *output, int *output_size) 23848ad68deSTom Rini { 23948ad68deSTom Rini struct hash_algo *algo; 24048ad68deSTom Rini int ret; 24148ad68deSTom Rini 24248ad68deSTom Rini ret = hash_lookup_algo(algo_name, &algo); 24348ad68deSTom Rini if (ret) 24448ad68deSTom Rini return ret; 24548ad68deSTom Rini 24648ad68deSTom Rini if (output_size && *output_size < algo->digest_size) { 24748ad68deSTom Rini debug("Output buffer size %d too small (need %d bytes)", 24848ad68deSTom Rini *output_size, algo->digest_size); 24948ad68deSTom Rini return -ENOSPC; 25048ad68deSTom Rini } 25148ad68deSTom Rini if (output_size) 25248ad68deSTom Rini *output_size = algo->digest_size; 25348ad68deSTom Rini algo->hash_func_ws(data, len, output, algo->chunk_size); 25448ad68deSTom Rini 25548ad68deSTom Rini return 0; 25648ad68deSTom Rini } 25748ad68deSTom Rini 25848ad68deSTom Rini #if defined(CONFIG_CMD_HASH) || defined(CONFIG_CMD_SHA1SUM) || defined(CONFIG_CMD_CRC32) 259460408efSSimon Glass /** 260460408efSSimon Glass * store_result: Store the resulting sum to an address or variable 261460408efSSimon Glass * 262460408efSSimon Glass * @algo: Hash algorithm being used 263460408efSSimon Glass * @sum: Hash digest (algo->digest_size bytes) 264460408efSSimon Glass * @dest: Destination, interpreted as a hex address if it starts 265d5b76673SSimon Glass * with * (or allow_env_vars is 0) or otherwise as an 266d5b76673SSimon Glass * environment variable. 267d5b76673SSimon Glass * @allow_env_vars: non-zero to permit storing the result to an 268d5b76673SSimon Glass * variable environment 269460408efSSimon Glass */ 27004819a4fSSimon Glass static void store_result(struct hash_algo *algo, const uint8_t *sum, 271d5b76673SSimon Glass const char *dest, int allow_env_vars) 272460408efSSimon Glass { 273460408efSSimon Glass unsigned int i; 274d5b76673SSimon Glass int env_var = 0; 275460408efSSimon Glass 276d5b76673SSimon Glass /* 277d5b76673SSimon Glass * If environment variables are allowed, then we assume that 'dest' 278d5b76673SSimon Glass * is an environment variable, unless it starts with *, in which 279d5b76673SSimon Glass * case we assume it is an address. If not allowed, it is always an 280d5b76673SSimon Glass * address. This is to support the crc32 command. 281d5b76673SSimon Glass */ 282d5b76673SSimon Glass if (allow_env_vars) { 283d5b76673SSimon Glass if (*dest == '*') 284d5b76673SSimon Glass dest++; 285d5b76673SSimon Glass else 286d5b76673SSimon Glass env_var = 1; 287d5b76673SSimon Glass } 288460408efSSimon Glass 289d5b76673SSimon Glass if (env_var) { 290460408efSSimon Glass char str_output[HASH_MAX_DIGEST_SIZE * 2 + 1]; 291460408efSSimon Glass char *str_ptr = str_output; 292460408efSSimon Glass 293460408efSSimon Glass for (i = 0; i < algo->digest_size; i++) { 294460408efSSimon Glass sprintf(str_ptr, "%02x", sum[i]); 295460408efSSimon Glass str_ptr += 2; 296460408efSSimon Glass } 2978b9cc866SJeroen Hofstee *str_ptr = '\0'; 298382bee57SSimon Glass env_set(dest, str_output); 299d5b76673SSimon Glass } else { 300bd091b67SSimon Glass ulong addr; 301bd091b67SSimon Glass void *buf; 302d5b76673SSimon Glass 303bd091b67SSimon Glass addr = simple_strtoul(dest, NULL, 16); 304bd091b67SSimon Glass buf = map_sysmem(addr, algo->digest_size); 305bd091b67SSimon Glass memcpy(buf, sum, algo->digest_size); 306bd091b67SSimon Glass unmap_sysmem(buf); 307460408efSSimon Glass } 308460408efSSimon Glass } 309460408efSSimon Glass 310460408efSSimon Glass /** 311460408efSSimon Glass * parse_verify_sum: Parse a hash verification parameter 312460408efSSimon Glass * 313460408efSSimon Glass * @algo: Hash algorithm being used 314460408efSSimon Glass * @verify_str: Argument to parse. If it starts with * then it is 315460408efSSimon Glass * interpreted as a hex address containing the hash. 316460408efSSimon Glass * If the length is exactly the right number of hex digits 317460408efSSimon Glass * for the digest size, then we assume it is a hex digest. 318460408efSSimon Glass * Otherwise we assume it is an environment variable, and 319460408efSSimon Glass * look up its value (it must contain a hex digest). 320460408efSSimon Glass * @vsum: Returns binary digest value (algo->digest_size bytes) 321d5b76673SSimon Glass * @allow_env_vars: non-zero to permit storing the result to an environment 322d5b76673SSimon Glass * variable. If 0 then verify_str is assumed to be an 323d5b76673SSimon Glass * address, and the * prefix is not expected. 324460408efSSimon Glass * @return 0 if ok, non-zero on error 325460408efSSimon Glass */ 32604819a4fSSimon Glass static int parse_verify_sum(struct hash_algo *algo, char *verify_str, 32704819a4fSSimon Glass uint8_t *vsum, int allow_env_vars) 328460408efSSimon Glass { 329d5b76673SSimon Glass int env_var = 0; 330d5b76673SSimon Glass 331d5b76673SSimon Glass /* See comment above in store_result() */ 332d5b76673SSimon Glass if (allow_env_vars) { 333d5b76673SSimon Glass if (*verify_str == '*') 334d5b76673SSimon Glass verify_str++; 335d5b76673SSimon Glass else 336d5b76673SSimon Glass env_var = 1; 337d5b76673SSimon Glass } 338d5b76673SSimon Glass 3393ef46a99SNikolay Dimitrov if (!env_var) { 340bd091b67SSimon Glass ulong addr; 341bd091b67SSimon Glass void *buf; 342460408efSSimon Glass 343bd091b67SSimon Glass addr = simple_strtoul(verify_str, NULL, 16); 344bd091b67SSimon Glass buf = map_sysmem(addr, algo->digest_size); 345bd091b67SSimon Glass memcpy(vsum, buf, algo->digest_size); 346460408efSSimon Glass } else { 347460408efSSimon Glass char *vsum_str; 348460408efSSimon Glass int digits = algo->digest_size * 2; 349460408efSSimon Glass 350460408efSSimon Glass /* 351460408efSSimon Glass * As with the original code from sha1sum.c, we assume that a 352460408efSSimon Glass * string which matches the digest size exactly is a hex 353460408efSSimon Glass * string and not an environment variable. 354460408efSSimon Glass */ 355460408efSSimon Glass if (strlen(verify_str) == digits) 356460408efSSimon Glass vsum_str = verify_str; 357460408efSSimon Glass else { 35800caae6dSSimon Glass vsum_str = env_get(verify_str); 359460408efSSimon Glass if (vsum_str == NULL || strlen(vsum_str) != digits) { 360460408efSSimon Glass printf("Expected %d hex digits in env var\n", 361460408efSSimon Glass digits); 362460408efSSimon Glass return 1; 363460408efSSimon Glass } 364460408efSSimon Glass } 365460408efSSimon Glass 3668f0b1e24SStefan Roese hash_parse_string(algo->name, vsum_str, vsum); 367460408efSSimon Glass } 368460408efSSimon Glass return 0; 369460408efSSimon Glass } 370460408efSSimon Glass 37148ad68deSTom Rini static void hash_show(struct hash_algo *algo, ulong addr, ulong len, uint8_t *output) 372460408efSSimon Glass { 373460408efSSimon Glass int i; 374460408efSSimon Glass 375460408efSSimon Glass printf("%s for %08lx ... %08lx ==> ", algo->name, addr, addr + len - 1); 376460408efSSimon Glass for (i = 0; i < algo->digest_size; i++) 377460408efSSimon Glass printf("%02x", output[i]); 378460408efSSimon Glass } 379460408efSSimon Glass 380d5b76673SSimon Glass int hash_command(const char *algo_name, int flags, cmd_tbl_t *cmdtp, int flag, 381460408efSSimon Glass int argc, char * const argv[]) 382460408efSSimon Glass { 383460408efSSimon Glass ulong addr, len; 384460408efSSimon Glass 3853ef46a99SNikolay Dimitrov if ((argc < 2) || ((flags & HASH_FLAG_VERIFY) && (argc < 3))) 386460408efSSimon Glass return CMD_RET_USAGE; 387460408efSSimon Glass 388d5b76673SSimon Glass addr = simple_strtoul(*argv++, NULL, 16); 389d5b76673SSimon Glass len = simple_strtoul(*argv++, NULL, 16); 390d5b76673SSimon Glass 391d20a40deSSimon Glass if (multi_hash()) { 392d20a40deSSimon Glass struct hash_algo *algo; 393*d7af2baaSBreno Lima u8 *output; 39404819a4fSSimon Glass uint8_t vsum[HASH_MAX_DIGEST_SIZE]; 395bd091b67SSimon Glass void *buf; 396d20a40deSSimon Glass 397bf007ebbSHung-ying Tyan if (hash_lookup_algo(algo_name, &algo)) { 398460408efSSimon Glass printf("Unknown hash algorithm '%s'\n", algo_name); 399460408efSSimon Glass return CMD_RET_USAGE; 400460408efSSimon Glass } 401460408efSSimon Glass argc -= 2; 402460408efSSimon Glass 403460408efSSimon Glass if (algo->digest_size > HASH_MAX_DIGEST_SIZE) { 404460408efSSimon Glass puts("HASH_MAX_DIGEST_SIZE exceeded\n"); 405460408efSSimon Glass return 1; 406460408efSSimon Glass } 407460408efSSimon Glass 408*d7af2baaSBreno Lima output = memalign(ARCH_DMA_MINALIGN, 409*d7af2baaSBreno Lima sizeof(uint32_t) * HASH_MAX_DIGEST_SIZE); 410*d7af2baaSBreno Lima 411bd091b67SSimon Glass buf = map_sysmem(addr, len); 412bd091b67SSimon Glass algo->hash_func_ws(buf, len, output, algo->chunk_size); 413bd091b67SSimon Glass unmap_sysmem(buf); 414460408efSSimon Glass 415460408efSSimon Glass /* Try to avoid code bloat when verify is not needed */ 416221a949eSDaniel Thompson #if defined(CONFIG_CRC32_VERIFY) || defined(CONFIG_SHA1SUM_VERIFY) || \ 417221a949eSDaniel Thompson defined(CONFIG_HASH_VERIFY) 418d5b76673SSimon Glass if (flags & HASH_FLAG_VERIFY) { 419460408efSSimon Glass #else 420460408efSSimon Glass if (0) { 421460408efSSimon Glass #endif 422d5b76673SSimon Glass if (parse_verify_sum(algo, *argv, vsum, 423d5b76673SSimon Glass flags & HASH_FLAG_ENV)) { 424d20a40deSSimon Glass printf("ERROR: %s does not contain a valid " 425d20a40deSSimon Glass "%s sum\n", *argv, algo->name); 426460408efSSimon Glass return 1; 427460408efSSimon Glass } 428460408efSSimon Glass if (memcmp(output, vsum, algo->digest_size) != 0) { 429460408efSSimon Glass int i; 430460408efSSimon Glass 43131890ae2SSimon Glass hash_show(algo, addr, len, output); 432460408efSSimon Glass printf(" != "); 433460408efSSimon Glass for (i = 0; i < algo->digest_size; i++) 434460408efSSimon Glass printf("%02x", vsum[i]); 435460408efSSimon Glass puts(" ** ERROR **\n"); 436460408efSSimon Glass return 1; 437460408efSSimon Glass } 438460408efSSimon Glass } else { 43931890ae2SSimon Glass hash_show(algo, addr, len, output); 440460408efSSimon Glass printf("\n"); 441460408efSSimon Glass 442d5b76673SSimon Glass if (argc) { 443d5b76673SSimon Glass store_result(algo, output, *argv, 444d5b76673SSimon Glass flags & HASH_FLAG_ENV); 445d5b76673SSimon Glass } 446*d7af2baaSBreno Lima unmap_sysmem(output); 447*d7af2baaSBreno Lima 448460408efSSimon Glass } 449460408efSSimon Glass 450d20a40deSSimon Glass /* Horrible code size hack for boards that just want crc32 */ 451d20a40deSSimon Glass } else { 452d20a40deSSimon Glass ulong crc; 453d20a40deSSimon Glass ulong *ptr; 454d20a40deSSimon Glass 455d20a40deSSimon Glass crc = crc32_wd(0, (const uchar *)addr, len, CHUNKSZ_CRC32); 456d20a40deSSimon Glass 457d20a40deSSimon Glass printf("CRC32 for %08lx ... %08lx ==> %08lx\n", 458d20a40deSSimon Glass addr, addr + len - 1, crc); 459d20a40deSSimon Glass 4604b756b01STom Rini if (argc >= 3) { 4614b756b01STom Rini ptr = (ulong *)simple_strtoul(argv[0], NULL, 16); 462d20a40deSSimon Glass *ptr = crc; 463d20a40deSSimon Glass } 464d20a40deSSimon Glass } 465d20a40deSSimon Glass 466460408efSSimon Glass return 0; 467460408efSSimon Glass } 468d70f919eSSimon Glass #endif /* CONFIG_CMD_HASH || CONFIG_CMD_SHA1SUM || CONFIG_CMD_CRC32) */ 469d70f919eSSimon Glass #endif /* !USE_HOSTCC */ 470