]>
Commit | Line | Data |
---|---|---|
460408ef SG |
1 | /* |
2 | * Copyright (c) 2012 The Chromium OS Authors. | |
3 | * | |
4 | * (C) Copyright 2011 | |
5 | * Joe Hershberger, National Instruments, joe.hershberger@ni.com | |
6 | * | |
7 | * (C) Copyright 2000 | |
8 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or | |
11 | * modify it under the terms of the GNU General Public License as | |
12 | * published by the Free Software Foundation; either version 2 of | |
13 | * the License, or (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
23 | * MA 02111-1307 USA | |
24 | */ | |
25 | ||
26 | #include <common.h> | |
27 | #include <command.h> | |
1f9c9280 | 28 | #include <hw_sha.h> |
460408ef SG |
29 | #include <hash.h> |
30 | #include <sha1.h> | |
31 | #include <sha256.h> | |
bd091b67 | 32 | #include <asm/io.h> |
6f907b42 | 33 | #include <asm/errno.h> |
460408ef SG |
34 | |
35 | /* | |
36 | * These are the hash algorithms we support. Chips which support accelerated | |
218da0f3 SG |
37 | * crypto could perhaps add named version of these algorithms here. Note that |
38 | * algorithm names must be in lower case. | |
460408ef SG |
39 | */ |
40 | static struct hash_algo hash_algo[] = { | |
1f9c9280 AS |
41 | /* |
42 | * CONFIG_SHA_HW_ACCEL is defined if hardware acceleration is | |
43 | * available. | |
44 | */ | |
45 | #ifdef CONFIG_SHA_HW_ACCEL | |
46 | { | |
47 | "sha1", | |
48 | SHA1_SUM_LEN, | |
49 | hw_sha1, | |
50 | CHUNKSZ_SHA1, | |
51 | }, { | |
52 | "sha256", | |
53 | SHA256_SUM_LEN, | |
54 | hw_sha256, | |
55 | CHUNKSZ_SHA256, | |
56 | }, | |
57 | #endif | |
d20a40de SG |
58 | /* |
59 | * This is CONFIG_CMD_SHA1SUM instead of CONFIG_SHA1 since otherwise | |
60 | * it bloats the code for boards which use SHA1 but not the 'hash' | |
61 | * or 'sha1sum' commands. | |
62 | */ | |
63 | #ifdef CONFIG_CMD_SHA1SUM | |
460408ef | 64 | { |
218da0f3 | 65 | "sha1", |
460408ef SG |
66 | SHA1_SUM_LEN, |
67 | sha1_csum_wd, | |
68 | CHUNKSZ_SHA1, | |
69 | }, | |
d20a40de | 70 | #define MULTI_HASH |
460408ef SG |
71 | #endif |
72 | #ifdef CONFIG_SHA256 | |
73 | { | |
218da0f3 | 74 | "sha256", |
460408ef SG |
75 | SHA256_SUM_LEN, |
76 | sha256_csum_wd, | |
77 | CHUNKSZ_SHA256, | |
78 | }, | |
d20a40de | 79 | #define MULTI_HASH |
460408ef | 80 | #endif |
d20a40de | 81 | { |
218da0f3 | 82 | "crc32", |
d20a40de SG |
83 | 4, |
84 | crc32_wd_buf, | |
85 | CHUNKSZ_CRC32, | |
86 | }, | |
460408ef SG |
87 | }; |
88 | ||
d20a40de SG |
89 | #if defined(CONFIG_HASH_VERIFY) || defined(CONFIG_CMD_HASH) |
90 | #define MULTI_HASH | |
91 | #endif | |
92 | ||
93 | /* Try to minimize code size for boards that don't want much hashing */ | |
94 | #ifdef MULTI_HASH | |
95 | #define multi_hash() 1 | |
96 | #else | |
97 | #define multi_hash() 0 | |
98 | #endif | |
99 | ||
460408ef SG |
100 | /** |
101 | * store_result: Store the resulting sum to an address or variable | |
102 | * | |
103 | * @algo: Hash algorithm being used | |
104 | * @sum: Hash digest (algo->digest_size bytes) | |
105 | * @dest: Destination, interpreted as a hex address if it starts | |
d5b76673 SG |
106 | * with * (or allow_env_vars is 0) or otherwise as an |
107 | * environment variable. | |
108 | * @allow_env_vars: non-zero to permit storing the result to an | |
109 | * variable environment | |
460408ef SG |
110 | */ |
111 | static void store_result(struct hash_algo *algo, const u8 *sum, | |
d5b76673 | 112 | const char *dest, int allow_env_vars) |
460408ef SG |
113 | { |
114 | unsigned int i; | |
d5b76673 | 115 | int env_var = 0; |
460408ef | 116 | |
d5b76673 SG |
117 | /* |
118 | * If environment variables are allowed, then we assume that 'dest' | |
119 | * is an environment variable, unless it starts with *, in which | |
120 | * case we assume it is an address. If not allowed, it is always an | |
121 | * address. This is to support the crc32 command. | |
122 | */ | |
123 | if (allow_env_vars) { | |
124 | if (*dest == '*') | |
125 | dest++; | |
126 | else | |
127 | env_var = 1; | |
128 | } | |
460408ef | 129 | |
d5b76673 | 130 | if (env_var) { |
460408ef SG |
131 | char str_output[HASH_MAX_DIGEST_SIZE * 2 + 1]; |
132 | char *str_ptr = str_output; | |
133 | ||
134 | for (i = 0; i < algo->digest_size; i++) { | |
135 | sprintf(str_ptr, "%02x", sum[i]); | |
136 | str_ptr += 2; | |
137 | } | |
138 | str_ptr = '\0'; | |
139 | setenv(dest, str_output); | |
d5b76673 | 140 | } else { |
bd091b67 SG |
141 | ulong addr; |
142 | void *buf; | |
d5b76673 | 143 | |
bd091b67 SG |
144 | addr = simple_strtoul(dest, NULL, 16); |
145 | buf = map_sysmem(addr, algo->digest_size); | |
146 | memcpy(buf, sum, algo->digest_size); | |
147 | unmap_sysmem(buf); | |
460408ef SG |
148 | } |
149 | } | |
150 | ||
151 | /** | |
152 | * parse_verify_sum: Parse a hash verification parameter | |
153 | * | |
154 | * @algo: Hash algorithm being used | |
155 | * @verify_str: Argument to parse. If it starts with * then it is | |
156 | * interpreted as a hex address containing the hash. | |
157 | * If the length is exactly the right number of hex digits | |
158 | * for the digest size, then we assume it is a hex digest. | |
159 | * Otherwise we assume it is an environment variable, and | |
160 | * look up its value (it must contain a hex digest). | |
161 | * @vsum: Returns binary digest value (algo->digest_size bytes) | |
d5b76673 SG |
162 | * @allow_env_vars: non-zero to permit storing the result to an environment |
163 | * variable. If 0 then verify_str is assumed to be an | |
164 | * address, and the * prefix is not expected. | |
460408ef SG |
165 | * @return 0 if ok, non-zero on error |
166 | */ | |
d5b76673 SG |
167 | static int parse_verify_sum(struct hash_algo *algo, char *verify_str, u8 *vsum, |
168 | int allow_env_vars) | |
460408ef | 169 | { |
d5b76673 SG |
170 | int env_var = 0; |
171 | ||
172 | /* See comment above in store_result() */ | |
173 | if (allow_env_vars) { | |
174 | if (*verify_str == '*') | |
175 | verify_str++; | |
176 | else | |
177 | env_var = 1; | |
178 | } | |
179 | ||
180 | if (env_var) { | |
bd091b67 SG |
181 | ulong addr; |
182 | void *buf; | |
460408ef | 183 | |
bd091b67 SG |
184 | addr = simple_strtoul(verify_str, NULL, 16); |
185 | buf = map_sysmem(addr, algo->digest_size); | |
186 | memcpy(vsum, buf, algo->digest_size); | |
460408ef SG |
187 | } else { |
188 | unsigned int i; | |
189 | char *vsum_str; | |
190 | int digits = algo->digest_size * 2; | |
191 | ||
192 | /* | |
193 | * As with the original code from sha1sum.c, we assume that a | |
194 | * string which matches the digest size exactly is a hex | |
195 | * string and not an environment variable. | |
196 | */ | |
197 | if (strlen(verify_str) == digits) | |
198 | vsum_str = verify_str; | |
199 | else { | |
200 | vsum_str = getenv(verify_str); | |
201 | if (vsum_str == NULL || strlen(vsum_str) != digits) { | |
202 | printf("Expected %d hex digits in env var\n", | |
203 | digits); | |
204 | return 1; | |
205 | } | |
206 | } | |
207 | ||
208 | for (i = 0; i < algo->digest_size; i++) { | |
209 | char *nullp = vsum_str + (i + 1) * 2; | |
210 | char end = *nullp; | |
211 | ||
212 | *nullp = '\0'; | |
213 | vsum[i] = simple_strtoul(vsum_str + (i * 2), NULL, 16); | |
214 | *nullp = end; | |
215 | } | |
216 | } | |
217 | return 0; | |
218 | } | |
219 | ||
220 | static struct hash_algo *find_hash_algo(const char *name) | |
221 | { | |
222 | int i; | |
223 | ||
224 | for (i = 0; i < ARRAY_SIZE(hash_algo); i++) { | |
218da0f3 | 225 | if (!strcmp(name, hash_algo[i].name)) |
460408ef SG |
226 | return &hash_algo[i]; |
227 | } | |
228 | ||
229 | return NULL; | |
230 | } | |
231 | ||
232 | static void show_hash(struct hash_algo *algo, ulong addr, ulong len, | |
233 | u8 *output) | |
234 | { | |
235 | int i; | |
236 | ||
237 | printf("%s for %08lx ... %08lx ==> ", algo->name, addr, addr + len - 1); | |
238 | for (i = 0; i < algo->digest_size; i++) | |
239 | printf("%02x", output[i]); | |
240 | } | |
241 | ||
6f907b42 SG |
242 | int hash_block(const char *algo_name, const void *data, unsigned int len, |
243 | uint8_t *output, int *output_size) | |
244 | { | |
245 | struct hash_algo *algo; | |
246 | ||
247 | algo = find_hash_algo(algo_name); | |
248 | if (!algo) { | |
249 | debug("Unknown hash algorithm '%s'\n", algo_name); | |
250 | return -EPROTONOSUPPORT; | |
251 | } | |
252 | if (output_size && *output_size < algo->digest_size) { | |
253 | debug("Output buffer size %d too small (need %d bytes)", | |
254 | *output_size, algo->digest_size); | |
255 | return -ENOSPC; | |
256 | } | |
257 | if (output_size) | |
258 | *output_size = algo->digest_size; | |
259 | algo->hash_func_ws(data, len, output, algo->chunk_size); | |
260 | ||
261 | return 0; | |
262 | } | |
263 | ||
d5b76673 | 264 | int hash_command(const char *algo_name, int flags, cmd_tbl_t *cmdtp, int flag, |
460408ef SG |
265 | int argc, char * const argv[]) |
266 | { | |
460408ef | 267 | ulong addr, len; |
460408ef SG |
268 | |
269 | if (argc < 2) | |
270 | return CMD_RET_USAGE; | |
271 | ||
d5b76673 SG |
272 | addr = simple_strtoul(*argv++, NULL, 16); |
273 | len = simple_strtoul(*argv++, NULL, 16); | |
274 | ||
d20a40de SG |
275 | if (multi_hash()) { |
276 | struct hash_algo *algo; | |
277 | u8 output[HASH_MAX_DIGEST_SIZE]; | |
278 | u8 vsum[HASH_MAX_DIGEST_SIZE]; | |
bd091b67 | 279 | void *buf; |
460408ef | 280 | |
d20a40de SG |
281 | algo = find_hash_algo(algo_name); |
282 | if (!algo) { | |
283 | printf("Unknown hash algorithm '%s'\n", algo_name); | |
284 | return CMD_RET_USAGE; | |
285 | } | |
286 | argc -= 2; | |
287 | ||
288 | if (algo->digest_size > HASH_MAX_DIGEST_SIZE) { | |
289 | puts("HASH_MAX_DIGEST_SIZE exceeded\n"); | |
290 | return 1; | |
291 | } | |
460408ef | 292 | |
bd091b67 SG |
293 | buf = map_sysmem(addr, len); |
294 | algo->hash_func_ws(buf, len, output, algo->chunk_size); | |
295 | unmap_sysmem(buf); | |
460408ef | 296 | |
d20a40de | 297 | /* Try to avoid code bloat when verify is not needed */ |
460408ef | 298 | #ifdef CONFIG_HASH_VERIFY |
d20a40de | 299 | if (flags & HASH_FLAG_VERIFY) { |
460408ef | 300 | #else |
d20a40de | 301 | if (0) { |
460408ef | 302 | #endif |
d20a40de SG |
303 | if (!argc) |
304 | return CMD_RET_USAGE; | |
305 | if (parse_verify_sum(algo, *argv, vsum, | |
d5b76673 | 306 | flags & HASH_FLAG_ENV)) { |
d20a40de SG |
307 | printf("ERROR: %s does not contain a valid " |
308 | "%s sum\n", *argv, algo->name); | |
309 | return 1; | |
310 | } | |
311 | if (memcmp(output, vsum, algo->digest_size) != 0) { | |
312 | int i; | |
460408ef | 313 | |
d20a40de SG |
314 | show_hash(algo, addr, len, output); |
315 | printf(" != "); | |
316 | for (i = 0; i < algo->digest_size; i++) | |
317 | printf("%02x", vsum[i]); | |
318 | puts(" ** ERROR **\n"); | |
319 | return 1; | |
320 | } | |
321 | } else { | |
460408ef | 322 | show_hash(algo, addr, len, output); |
d20a40de SG |
323 | printf("\n"); |
324 | ||
325 | if (argc) { | |
326 | store_result(algo, output, *argv, | |
327 | flags & HASH_FLAG_ENV); | |
328 | } | |
460408ef | 329 | } |
d20a40de SG |
330 | |
331 | /* Horrible code size hack for boards that just want crc32 */ | |
460408ef | 332 | } else { |
d20a40de SG |
333 | ulong crc; |
334 | ulong *ptr; | |
335 | ||
336 | crc = crc32_wd(0, (const uchar *)addr, len, CHUNKSZ_CRC32); | |
337 | ||
338 | printf("CRC32 for %08lx ... %08lx ==> %08lx\n", | |
339 | addr, addr + len - 1, crc); | |
460408ef | 340 | |
d20a40de SG |
341 | if (argc > 3) { |
342 | ptr = (ulong *)simple_strtoul(argv[3], NULL, 16); | |
343 | *ptr = crc; | |
d5b76673 | 344 | } |
460408ef SG |
345 | } |
346 | ||
347 | return 0; | |
348 | } |