Branch data Line data Source code
1 : : /*
2 : : * PSA hashing layer on top of Mbed TLS software crypto
3 : : */
4 : : /*
5 : : * Copyright The Mbed TLS Contributors
6 : : * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
7 : : */
8 : :
9 : : #include "common.h"
10 : :
11 : : #if defined(MBEDTLS_PSA_CRYPTO_C)
12 : :
13 : : #include <psa/crypto.h>
14 : : #include "psa_crypto_core.h"
15 : : #include "psa_crypto_hash.h"
16 : :
17 : : #include <mbedtls/error.h>
18 : : #include <string.h>
19 : :
20 : : #if defined(MBEDTLS_PSA_BUILTIN_HASH)
21 : 342 : psa_status_t mbedtls_psa_hash_abort(
22 : : mbedtls_psa_hash_operation_t *operation)
23 : : {
24 [ - + - - ]: 342 : switch (operation->alg) {
25 : : case 0:
26 : : /* The object has (apparently) been initialized but it is not
27 : : * in use. It's ok to call abort on such an object, and there's
28 : : * nothing to do. */
29 : : break;
30 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_MD5)
31 : : case PSA_ALG_MD5:
32 : : mbedtls_md5_free(&operation->ctx.md5);
33 : : break;
34 : : #endif
35 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160)
36 : : case PSA_ALG_RIPEMD160:
37 : : mbedtls_ripemd160_free(&operation->ctx.ripemd160);
38 : : break;
39 : : #endif
40 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1)
41 : : case PSA_ALG_SHA_1:
42 : : mbedtls_sha1_free(&operation->ctx.sha1);
43 : : break;
44 : : #endif
45 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224)
46 : 0 : case PSA_ALG_SHA_224:
47 : 0 : mbedtls_sha256_free(&operation->ctx.sha256);
48 : 0 : break;
49 : : #endif
50 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256)
51 : 342 : case PSA_ALG_SHA_256:
52 : 342 : mbedtls_sha256_free(&operation->ctx.sha256);
53 : 342 : break;
54 : : #endif
55 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384)
56 : : case PSA_ALG_SHA_384:
57 : : mbedtls_sha512_free(&operation->ctx.sha512);
58 : : break;
59 : : #endif
60 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512)
61 : : case PSA_ALG_SHA_512:
62 : : mbedtls_sha512_free(&operation->ctx.sha512);
63 : : break;
64 : : #endif
65 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224)
66 : : case PSA_ALG_SHA3_224:
67 : : #endif
68 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256)
69 : : case PSA_ALG_SHA3_256:
70 : : #endif
71 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384)
72 : : case PSA_ALG_SHA3_384:
73 : : #endif
74 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
75 : : case PSA_ALG_SHA3_512:
76 : : #endif
77 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224) || \
78 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256) || \
79 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384) || \
80 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
81 : : mbedtls_sha3_free(&operation->ctx.sha3);
82 : : break;
83 : : #endif
84 : : default:
85 : : return PSA_ERROR_BAD_STATE;
86 : : }
87 : 342 : operation->alg = 0;
88 : 342 : return PSA_SUCCESS;
89 : : }
90 : :
91 : 342 : psa_status_t mbedtls_psa_hash_setup(
92 : : mbedtls_psa_hash_operation_t *operation,
93 : : psa_algorithm_t alg)
94 : : {
95 : 342 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
96 : :
97 : : /* A context must be freshly initialized before it can be set up. */
98 [ + - ]: 342 : if (operation->alg != 0) {
99 : : return PSA_ERROR_BAD_STATE;
100 : : }
101 : :
102 [ - + - ]: 342 : switch (alg) {
103 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_MD5)
104 : : case PSA_ALG_MD5:
105 : : mbedtls_md5_init(&operation->ctx.md5);
106 : : ret = mbedtls_md5_starts(&operation->ctx.md5);
107 : : break;
108 : : #endif
109 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160)
110 : : case PSA_ALG_RIPEMD160:
111 : : mbedtls_ripemd160_init(&operation->ctx.ripemd160);
112 : : ret = mbedtls_ripemd160_starts(&operation->ctx.ripemd160);
113 : : break;
114 : : #endif
115 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1)
116 : : case PSA_ALG_SHA_1:
117 : : mbedtls_sha1_init(&operation->ctx.sha1);
118 : : ret = mbedtls_sha1_starts(&operation->ctx.sha1);
119 : : break;
120 : : #endif
121 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224)
122 : 0 : case PSA_ALG_SHA_224:
123 : 0 : mbedtls_sha256_init(&operation->ctx.sha256);
124 : 0 : ret = mbedtls_sha256_starts(&operation->ctx.sha256, 1);
125 : 0 : break;
126 : : #endif
127 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256)
128 : 342 : case PSA_ALG_SHA_256:
129 : 342 : mbedtls_sha256_init(&operation->ctx.sha256);
130 : 342 : ret = mbedtls_sha256_starts(&operation->ctx.sha256, 0);
131 : 342 : break;
132 : : #endif
133 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384)
134 : : case PSA_ALG_SHA_384:
135 : : mbedtls_sha512_init(&operation->ctx.sha512);
136 : : ret = mbedtls_sha512_starts(&operation->ctx.sha512, 1);
137 : : break;
138 : : #endif
139 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512)
140 : : case PSA_ALG_SHA_512:
141 : : mbedtls_sha512_init(&operation->ctx.sha512);
142 : : ret = mbedtls_sha512_starts(&operation->ctx.sha512, 0);
143 : : break;
144 : : #endif
145 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224)
146 : : case PSA_ALG_SHA3_224:
147 : : mbedtls_sha3_init(&operation->ctx.sha3);
148 : : ret = mbedtls_sha3_starts(&operation->ctx.sha3, MBEDTLS_SHA3_224);
149 : : break;
150 : : #endif
151 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256)
152 : : case PSA_ALG_SHA3_256:
153 : : mbedtls_sha3_init(&operation->ctx.sha3);
154 : : ret = mbedtls_sha3_starts(&operation->ctx.sha3, MBEDTLS_SHA3_256);
155 : : break;
156 : : #endif
157 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384)
158 : : case PSA_ALG_SHA3_384:
159 : : mbedtls_sha3_init(&operation->ctx.sha3);
160 : : ret = mbedtls_sha3_starts(&operation->ctx.sha3, MBEDTLS_SHA3_384);
161 : : break;
162 : : #endif
163 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
164 : : case PSA_ALG_SHA3_512:
165 : : mbedtls_sha3_init(&operation->ctx.sha3);
166 : : ret = mbedtls_sha3_starts(&operation->ctx.sha3, MBEDTLS_SHA3_512);
167 : : break;
168 : : #endif
169 : 0 : default:
170 : 0 : return PSA_ALG_IS_HASH(alg) ?
171 [ # # ]: 0 : PSA_ERROR_NOT_SUPPORTED :
172 : : PSA_ERROR_INVALID_ARGUMENT;
173 : : }
174 [ + - ]: 342 : if (ret == 0) {
175 : 342 : operation->alg = alg;
176 : : } else {
177 : 0 : mbedtls_psa_hash_abort(operation);
178 : : }
179 : 342 : return mbedtls_to_psa_error(ret);
180 : : }
181 : :
182 : 0 : psa_status_t mbedtls_psa_hash_clone(
183 : : const mbedtls_psa_hash_operation_t *source_operation,
184 : : mbedtls_psa_hash_operation_t *target_operation)
185 : : {
186 [ # # # # ]: 0 : switch (source_operation->alg) {
187 : : case 0:
188 : : return PSA_ERROR_BAD_STATE;
189 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_MD5)
190 : : case PSA_ALG_MD5:
191 : : mbedtls_md5_clone(&target_operation->ctx.md5,
192 : : &source_operation->ctx.md5);
193 : : break;
194 : : #endif
195 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160)
196 : : case PSA_ALG_RIPEMD160:
197 : : mbedtls_ripemd160_clone(&target_operation->ctx.ripemd160,
198 : : &source_operation->ctx.ripemd160);
199 : : break;
200 : : #endif
201 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1)
202 : : case PSA_ALG_SHA_1:
203 : : mbedtls_sha1_clone(&target_operation->ctx.sha1,
204 : : &source_operation->ctx.sha1);
205 : : break;
206 : : #endif
207 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224)
208 : 0 : case PSA_ALG_SHA_224:
209 : 0 : mbedtls_sha256_clone(&target_operation->ctx.sha256,
210 : : &source_operation->ctx.sha256);
211 : 0 : break;
212 : : #endif
213 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256)
214 : 0 : case PSA_ALG_SHA_256:
215 : 0 : mbedtls_sha256_clone(&target_operation->ctx.sha256,
216 : : &source_operation->ctx.sha256);
217 : 0 : break;
218 : : #endif
219 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384)
220 : : case PSA_ALG_SHA_384:
221 : : mbedtls_sha512_clone(&target_operation->ctx.sha512,
222 : : &source_operation->ctx.sha512);
223 : : break;
224 : : #endif
225 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512)
226 : : case PSA_ALG_SHA_512:
227 : : mbedtls_sha512_clone(&target_operation->ctx.sha512,
228 : : &source_operation->ctx.sha512);
229 : : break;
230 : : #endif
231 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224)
232 : : case PSA_ALG_SHA3_224:
233 : : #endif
234 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256)
235 : : case PSA_ALG_SHA3_256:
236 : : #endif
237 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384)
238 : : case PSA_ALG_SHA3_384:
239 : : #endif
240 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
241 : : case PSA_ALG_SHA3_512:
242 : : #endif
243 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224) || \
244 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256) || \
245 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384) || \
246 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
247 : : mbedtls_sha3_clone(&target_operation->ctx.sha3,
248 : : &source_operation->ctx.sha3);
249 : : break;
250 : : #endif
251 : 0 : default:
252 : 0 : (void) source_operation;
253 : 0 : (void) target_operation;
254 : 0 : return PSA_ERROR_NOT_SUPPORTED;
255 : : }
256 : :
257 : 0 : target_operation->alg = source_operation->alg;
258 : 0 : return PSA_SUCCESS;
259 : : }
260 : :
261 : 650 : psa_status_t mbedtls_psa_hash_update(
262 : : mbedtls_psa_hash_operation_t *operation,
263 : : const uint8_t *input,
264 : : size_t input_length)
265 : : {
266 : 650 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
267 : :
268 [ - + - ]: 650 : switch (operation->alg) {
269 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_MD5)
270 : : case PSA_ALG_MD5:
271 : : ret = mbedtls_md5_update(&operation->ctx.md5,
272 : : input, input_length);
273 : : break;
274 : : #endif
275 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160)
276 : : case PSA_ALG_RIPEMD160:
277 : : ret = mbedtls_ripemd160_update(&operation->ctx.ripemd160,
278 : : input, input_length);
279 : : break;
280 : : #endif
281 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1)
282 : : case PSA_ALG_SHA_1:
283 : : ret = mbedtls_sha1_update(&operation->ctx.sha1,
284 : : input, input_length);
285 : : break;
286 : : #endif
287 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224)
288 : 0 : case PSA_ALG_SHA_224:
289 : 0 : ret = mbedtls_sha256_update(&operation->ctx.sha256,
290 : : input, input_length);
291 : 0 : break;
292 : : #endif
293 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256)
294 : 650 : case PSA_ALG_SHA_256:
295 : 650 : ret = mbedtls_sha256_update(&operation->ctx.sha256,
296 : : input, input_length);
297 : 650 : break;
298 : : #endif
299 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384)
300 : : case PSA_ALG_SHA_384:
301 : : ret = mbedtls_sha512_update(&operation->ctx.sha512,
302 : : input, input_length);
303 : : break;
304 : : #endif
305 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512)
306 : : case PSA_ALG_SHA_512:
307 : : ret = mbedtls_sha512_update(&operation->ctx.sha512,
308 : : input, input_length);
309 : : break;
310 : : #endif
311 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224)
312 : : case PSA_ALG_SHA3_224:
313 : : #endif
314 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256)
315 : : case PSA_ALG_SHA3_256:
316 : : #endif
317 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384)
318 : : case PSA_ALG_SHA3_384:
319 : : #endif
320 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
321 : : case PSA_ALG_SHA3_512:
322 : : #endif
323 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224) || \
324 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256) || \
325 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384) || \
326 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
327 : : ret = mbedtls_sha3_update(&operation->ctx.sha3,
328 : : input, input_length);
329 : : break;
330 : : #endif
331 : : default:
332 : : (void) input;
333 : : (void) input_length;
334 : : return PSA_ERROR_BAD_STATE;
335 : : }
336 : :
337 : 650 : return mbedtls_to_psa_error(ret);
338 : : }
339 : :
340 : 342 : psa_status_t mbedtls_psa_hash_finish(
341 : : mbedtls_psa_hash_operation_t *operation,
342 : : uint8_t *hash,
343 : : size_t hash_size,
344 : : size_t *hash_length)
345 : : {
346 : 342 : psa_status_t status;
347 : 342 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
348 [ - + ]: 342 : size_t actual_hash_length = PSA_HASH_LENGTH(operation->alg);
349 : :
350 : : /* Fill the output buffer with something that isn't a valid hash
351 : : * (barring an attack on the hash and deliberately-crafted input),
352 : : * in case the caller doesn't check the return status properly. */
353 : 342 : *hash_length = hash_size;
354 : : /* If hash_size is 0 then hash may be NULL and then the
355 : : * call to memset would have undefined behavior. */
356 [ + - ]: 342 : if (hash_size != 0) {
357 : 342 : memset(hash, '!', hash_size);
358 : : }
359 : :
360 [ - + ]: 342 : if (hash_size < actual_hash_length) {
361 : 0 : status = PSA_ERROR_BUFFER_TOO_SMALL;
362 : 0 : goto exit;
363 : : }
364 : :
365 [ - + - ]: 342 : switch (operation->alg) {
366 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_MD5)
367 : : case PSA_ALG_MD5:
368 : : ret = mbedtls_md5_finish(&operation->ctx.md5, hash);
369 : : break;
370 : : #endif
371 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160)
372 : : case PSA_ALG_RIPEMD160:
373 : : ret = mbedtls_ripemd160_finish(&operation->ctx.ripemd160, hash);
374 : : break;
375 : : #endif
376 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1)
377 : : case PSA_ALG_SHA_1:
378 : : ret = mbedtls_sha1_finish(&operation->ctx.sha1, hash);
379 : : break;
380 : : #endif
381 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224)
382 : 0 : case PSA_ALG_SHA_224:
383 : 0 : ret = mbedtls_sha256_finish(&operation->ctx.sha256, hash);
384 : 0 : break;
385 : : #endif
386 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256)
387 : 342 : case PSA_ALG_SHA_256:
388 : 342 : ret = mbedtls_sha256_finish(&operation->ctx.sha256, hash);
389 : 342 : break;
390 : : #endif
391 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384)
392 : : case PSA_ALG_SHA_384:
393 : : ret = mbedtls_sha512_finish(&operation->ctx.sha512, hash);
394 : : break;
395 : : #endif
396 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512)
397 : : case PSA_ALG_SHA_512:
398 : : ret = mbedtls_sha512_finish(&operation->ctx.sha512, hash);
399 : : break;
400 : : #endif
401 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224)
402 : : case PSA_ALG_SHA3_224:
403 : : #endif
404 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256)
405 : : case PSA_ALG_SHA3_256:
406 : : #endif
407 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384)
408 : : case PSA_ALG_SHA3_384:
409 : : #endif
410 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
411 : : case PSA_ALG_SHA3_512:
412 : : #endif
413 : : #if defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_224) || \
414 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_256) || \
415 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_384) || \
416 : : defined(MBEDTLS_PSA_BUILTIN_ALG_SHA3_512)
417 : : ret = mbedtls_sha3_finish(&operation->ctx.sha3, hash, hash_size);
418 : : break;
419 : : #endif
420 : : default:
421 : : (void) hash;
422 : : return PSA_ERROR_BAD_STATE;
423 : : }
424 : 342 : status = mbedtls_to_psa_error(ret);
425 : :
426 : 342 : exit:
427 [ + - ]: 342 : if (status == PSA_SUCCESS) {
428 : 342 : *hash_length = actual_hash_length;
429 : : }
430 : : return status;
431 : : }
432 : :
433 : 34 : psa_status_t mbedtls_psa_hash_compute(
434 : : psa_algorithm_t alg,
435 : : const uint8_t *input,
436 : : size_t input_length,
437 : : uint8_t *hash,
438 : : size_t hash_size,
439 : : size_t *hash_length)
440 : : {
441 : 34 : mbedtls_psa_hash_operation_t operation = MBEDTLS_PSA_HASH_OPERATION_INIT;
442 : 34 : psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
443 : 34 : psa_status_t abort_status = PSA_ERROR_CORRUPTION_DETECTED;
444 : :
445 : 34 : *hash_length = hash_size;
446 : 34 : status = mbedtls_psa_hash_setup(&operation, alg);
447 [ - + ]: 34 : if (status != PSA_SUCCESS) {
448 : 0 : goto exit;
449 : : }
450 : 34 : status = mbedtls_psa_hash_update(&operation, input, input_length);
451 [ - + ]: 34 : if (status != PSA_SUCCESS) {
452 : 0 : goto exit;
453 : : }
454 : 34 : status = mbedtls_psa_hash_finish(&operation, hash, hash_size, hash_length);
455 : 34 : if (status != PSA_SUCCESS) {
456 : : goto exit;
457 : : }
458 : :
459 : 34 : exit:
460 : 34 : abort_status = mbedtls_psa_hash_abort(&operation);
461 [ - + ]: 34 : if (status == PSA_SUCCESS) {
462 : : return abort_status;
463 : : } else {
464 : 0 : return status;
465 : : }
466 : :
467 : : }
468 : : #endif /* MBEDTLS_PSA_BUILTIN_HASH */
469 : :
470 : : #endif /* MBEDTLS_PSA_CRYPTO_C */
|
