]> git.zerfleddert.de Git - proxmark3-svn/blame - common/mbedtls/entropy.c
cleaning up uart_posix.c
[proxmark3-svn] / common / mbedtls / entropy.c
CommitLineData
700d8687
OM
1/*
2 * Entropy accumulator implementation
3 *
4 * Copyright (C) 2006-2016, ARM Limited, All Rights Reserved
5 * SPDX-License-Identifier: GPL-2.0
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * This file is part of mbed TLS (https://tls.mbed.org)
22 */
23
24#if !defined(MBEDTLS_CONFIG_FILE)
25#include "mbedtls/config.h"
26#else
27#include MBEDTLS_CONFIG_FILE
28#endif
29
30#if defined(MBEDTLS_ENTROPY_C)
31
32#if defined(MBEDTLS_TEST_NULL_ENTROPY)
33#warning "**** WARNING! MBEDTLS_TEST_NULL_ENTROPY defined! "
34#warning "**** THIS BUILD HAS NO DEFINED ENTROPY SOURCES "
35#warning "**** THIS BUILD IS *NOT* SUITABLE FOR PRODUCTION USE "
36#endif
37
38#include "mbedtls/entropy.h"
39#include "mbedtls/entropy_poll.h"
40#include "mbedtls/platform_util.h"
41
42#include <string.h>
43
44#if defined(MBEDTLS_FS_IO)
45#include <stdio.h>
46#endif
47
48#if defined(MBEDTLS_ENTROPY_NV_SEED)
49#include "mbedtls/platform.h"
50#endif
51
52#if defined(MBEDTLS_SELF_TEST)
53#if defined(MBEDTLS_PLATFORM_C)
54#include "mbedtls/platform.h"
55#else
56#include <stdio.h>
57#define mbedtls_printf printf
58#endif /* MBEDTLS_PLATFORM_C */
59#endif /* MBEDTLS_SELF_TEST */
60
61#if defined(MBEDTLS_HAVEGE_C)
62#include "mbedtls/havege.h"
63#endif
64
65#define ENTROPY_MAX_LOOP 256 /**< Maximum amount to loop before error */
66
67void mbedtls_entropy_init( mbedtls_entropy_context *ctx )
68{
69 ctx->source_count = 0;
70 memset( ctx->source, 0, sizeof( ctx->source ) );
71
72#if defined(MBEDTLS_THREADING_C)
73 mbedtls_mutex_init( &ctx->mutex );
74#endif
75
76 ctx->accumulator_started = 0;
77#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
78 mbedtls_sha512_init( &ctx->accumulator );
79#else
80 mbedtls_sha256_init( &ctx->accumulator );
81#endif
82#if defined(MBEDTLS_HAVEGE_C)
83 mbedtls_havege_init( &ctx->havege_data );
84#endif
85
86 /* Reminder: Update ENTROPY_HAVE_STRONG in the test files
87 * when adding more strong entropy sources here. */
88
89#if defined(MBEDTLS_TEST_NULL_ENTROPY)
90 mbedtls_entropy_add_source( ctx, mbedtls_null_entropy_poll, NULL,
91 1, MBEDTLS_ENTROPY_SOURCE_STRONG );
92#endif
93
94#if !defined(MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES)
95#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
96 mbedtls_entropy_add_source( ctx, mbedtls_platform_entropy_poll, NULL,
97 MBEDTLS_ENTROPY_MIN_PLATFORM,
98 MBEDTLS_ENTROPY_SOURCE_STRONG );
99#endif
100#if defined(MBEDTLS_TIMING_C)
101 mbedtls_entropy_add_source( ctx, mbedtls_hardclock_poll, NULL,
102 MBEDTLS_ENTROPY_MIN_HARDCLOCK,
103 MBEDTLS_ENTROPY_SOURCE_WEAK );
104#endif
105#if defined(MBEDTLS_HAVEGE_C)
106 mbedtls_entropy_add_source( ctx, mbedtls_havege_poll, &ctx->havege_data,
107 MBEDTLS_ENTROPY_MIN_HAVEGE,
108 MBEDTLS_ENTROPY_SOURCE_STRONG );
109#endif
110#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
111 mbedtls_entropy_add_source( ctx, mbedtls_hardware_poll, NULL,
112 MBEDTLS_ENTROPY_MIN_HARDWARE,
113 MBEDTLS_ENTROPY_SOURCE_STRONG );
114#endif
115#if defined(MBEDTLS_ENTROPY_NV_SEED)
116 mbedtls_entropy_add_source( ctx, mbedtls_nv_seed_poll, NULL,
117 MBEDTLS_ENTROPY_BLOCK_SIZE,
118 MBEDTLS_ENTROPY_SOURCE_STRONG );
119 ctx->initial_entropy_run = 0;
120#endif
121#endif /* MBEDTLS_NO_DEFAULT_ENTROPY_SOURCES */
122}
123
124void mbedtls_entropy_free( mbedtls_entropy_context *ctx )
125{
126#if defined(MBEDTLS_HAVEGE_C)
127 mbedtls_havege_free( &ctx->havege_data );
128#endif
129#if defined(MBEDTLS_THREADING_C)
130 mbedtls_mutex_free( &ctx->mutex );
131#endif
132#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
133 mbedtls_sha512_free( &ctx->accumulator );
134#else
135 mbedtls_sha256_free( &ctx->accumulator );
136#endif
137#if defined(MBEDTLS_ENTROPY_NV_SEED)
138 ctx->initial_entropy_run = 0;
139#endif
140 ctx->source_count = 0;
141 mbedtls_platform_zeroize( ctx->source, sizeof( ctx->source ) );
142 ctx->accumulator_started = 0;
143}
144
145int mbedtls_entropy_add_source( mbedtls_entropy_context *ctx,
146 mbedtls_entropy_f_source_ptr f_source, void *p_source,
147 size_t threshold, int strong )
148{
149 int idx, ret = 0;
150
151#if defined(MBEDTLS_THREADING_C)
152 if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
153 return( ret );
154#endif
155
156 idx = ctx->source_count;
157 if( idx >= MBEDTLS_ENTROPY_MAX_SOURCES )
158 {
159 ret = MBEDTLS_ERR_ENTROPY_MAX_SOURCES;
160 goto exit;
161 }
162
163 ctx->source[idx].f_source = f_source;
164 ctx->source[idx].p_source = p_source;
165 ctx->source[idx].threshold = threshold;
166 ctx->source[idx].strong = strong;
167
168 ctx->source_count++;
169
170exit:
171#if defined(MBEDTLS_THREADING_C)
172 if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
173 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
174#endif
175
176 return( ret );
177}
178
179/*
180 * Entropy accumulator update
181 */
182static int entropy_update( mbedtls_entropy_context *ctx, unsigned char source_id,
183 const unsigned char *data, size_t len )
184{
185 unsigned char header[2];
186 unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE];
187 size_t use_len = len;
188 const unsigned char *p = data;
189 int ret = 0;
190
191 if( use_len > MBEDTLS_ENTROPY_BLOCK_SIZE )
192 {
193#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
194 if( ( ret = mbedtls_sha512_ret( data, len, tmp, 0 ) ) != 0 )
195 goto cleanup;
196#else
197 if( ( ret = mbedtls_sha256_ret( data, len, tmp, 0 ) ) != 0 )
198 goto cleanup;
199#endif
200 p = tmp;
201 use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
202 }
203
204 header[0] = source_id;
205 header[1] = use_len & 0xFF;
206
207 /*
208 * Start the accumulator if this has not already happened. Note that
209 * it is sufficient to start the accumulator here only because all calls to
210 * gather entropy eventually execute this code.
211 */
212#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
213 if( ctx->accumulator_started == 0 &&
214 ( ret = mbedtls_sha512_starts_ret( &ctx->accumulator, 0 ) ) != 0 )
215 goto cleanup;
216 else
217 ctx->accumulator_started = 1;
218 if( ( ret = mbedtls_sha512_update_ret( &ctx->accumulator, header, 2 ) ) != 0 )
219 goto cleanup;
220 ret = mbedtls_sha512_update_ret( &ctx->accumulator, p, use_len );
221#else
222 if( ctx->accumulator_started == 0 &&
223 ( ret = mbedtls_sha256_starts_ret( &ctx->accumulator, 0 ) ) != 0 )
224 goto cleanup;
225 else
226 ctx->accumulator_started = 1;
227 if( ( ret = mbedtls_sha256_update_ret( &ctx->accumulator, header, 2 ) ) != 0 )
228 goto cleanup;
229 ret = mbedtls_sha256_update_ret( &ctx->accumulator, p, use_len );
230#endif
231
232cleanup:
233 mbedtls_platform_zeroize( tmp, sizeof( tmp ) );
234
235 return( ret );
236}
237
238int mbedtls_entropy_update_manual( mbedtls_entropy_context *ctx,
239 const unsigned char *data, size_t len )
240{
241 int ret;
242
243#if defined(MBEDTLS_THREADING_C)
244 if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
245 return( ret );
246#endif
247
248 ret = entropy_update( ctx, MBEDTLS_ENTROPY_SOURCE_MANUAL, data, len );
249
250#if defined(MBEDTLS_THREADING_C)
251 if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
252 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
253#endif
254
255 return( ret );
256}
257
258/*
259 * Run through the different sources to add entropy to our accumulator
260 */
261static int entropy_gather_internal( mbedtls_entropy_context *ctx )
262{
263 int ret, i, have_one_strong = 0;
264 unsigned char buf[MBEDTLS_ENTROPY_MAX_GATHER];
265 size_t olen;
266
267 if( ctx->source_count == 0 )
268 return( MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
269
270 /*
271 * Run through our entropy sources
272 */
273 for( i = 0; i < ctx->source_count; i++ )
274 {
275 if( ctx->source[i].strong == MBEDTLS_ENTROPY_SOURCE_STRONG )
276 have_one_strong = 1;
277
278 olen = 0;
279 if( ( ret = ctx->source[i].f_source( ctx->source[i].p_source,
280 buf, MBEDTLS_ENTROPY_MAX_GATHER, &olen ) ) != 0 )
281 {
282 goto cleanup;
283 }
284
285 /*
286 * Add if we actually gathered something
287 */
288 if( olen > 0 )
289 {
290 if( ( ret = entropy_update( ctx, (unsigned char) i,
291 buf, olen ) ) != 0 )
292 return( ret );
293 ctx->source[i].size += olen;
294 }
295 }
296
297 if( have_one_strong == 0 )
298 ret = MBEDTLS_ERR_ENTROPY_NO_STRONG_SOURCE;
299
300cleanup:
301 mbedtls_platform_zeroize( buf, sizeof( buf ) );
302
303 return( ret );
304}
305
306/*
307 * Thread-safe wrapper for entropy_gather_internal()
308 */
309int mbedtls_entropy_gather( mbedtls_entropy_context *ctx )
310{
311 int ret;
312
313#if defined(MBEDTLS_THREADING_C)
314 if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
315 return( ret );
316#endif
317
318 ret = entropy_gather_internal( ctx );
319
320#if defined(MBEDTLS_THREADING_C)
321 if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
322 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
323#endif
324
325 return( ret );
326}
327
328int mbedtls_entropy_func( void *data, unsigned char *output, size_t len )
329{
330 int ret, count = 0, i, done;
331 mbedtls_entropy_context *ctx = (mbedtls_entropy_context *) data;
332 unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
333
334 if( len > MBEDTLS_ENTROPY_BLOCK_SIZE )
335 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
336
337#if defined(MBEDTLS_ENTROPY_NV_SEED)
338 /* Update the NV entropy seed before generating any entropy for outside
339 * use.
340 */
341 if( ctx->initial_entropy_run == 0 )
342 {
343 ctx->initial_entropy_run = 1;
344 if( ( ret = mbedtls_entropy_update_nv_seed( ctx ) ) != 0 )
345 return( ret );
346 }
347#endif
348
349#if defined(MBEDTLS_THREADING_C)
350 if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
351 return( ret );
352#endif
353
354 /*
355 * Always gather extra entropy before a call
356 */
357 do
358 {
359 if( count++ > ENTROPY_MAX_LOOP )
360 {
361 ret = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED;
362 goto exit;
363 }
364
365 if( ( ret = entropy_gather_internal( ctx ) ) != 0 )
366 goto exit;
367
368 done = 1;
369 for( i = 0; i < ctx->source_count; i++ )
370 if( ctx->source[i].size < ctx->source[i].threshold )
371 done = 0;
372 }
373 while( ! done );
374
375 memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
376
377#if defined(MBEDTLS_ENTROPY_SHA512_ACCUMULATOR)
378 /*
379 * Note that at this stage it is assumed that the accumulator was started
380 * in a previous call to entropy_update(). If this is not guaranteed, the
381 * code below will fail.
382 */
383 if( ( ret = mbedtls_sha512_finish_ret( &ctx->accumulator, buf ) ) != 0 )
384 goto exit;
385
386 /*
387 * Reset accumulator and counters and recycle existing entropy
388 */
389 mbedtls_sha512_free( &ctx->accumulator );
390 mbedtls_sha512_init( &ctx->accumulator );
391 if( ( ret = mbedtls_sha512_starts_ret( &ctx->accumulator, 0 ) ) != 0 )
392 goto exit;
393 if( ( ret = mbedtls_sha512_update_ret( &ctx->accumulator, buf,
394 MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
395 goto exit;
396
397 /*
398 * Perform second SHA-512 on entropy
399 */
400 if( ( ret = mbedtls_sha512_ret( buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
401 buf, 0 ) ) != 0 )
402 goto exit;
403#else /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
404 if( ( ret = mbedtls_sha256_finish_ret( &ctx->accumulator, buf ) ) != 0 )
405 goto exit;
406
407 /*
408 * Reset accumulator and counters and recycle existing entropy
409 */
410 mbedtls_sha256_free( &ctx->accumulator );
411 mbedtls_sha256_init( &ctx->accumulator );
412 if( ( ret = mbedtls_sha256_starts_ret( &ctx->accumulator, 0 ) ) != 0 )
413 goto exit;
414 if( ( ret = mbedtls_sha256_update_ret( &ctx->accumulator, buf,
415 MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
416 goto exit;
417
418 /*
419 * Perform second SHA-256 on entropy
420 */
421 if( ( ret = mbedtls_sha256_ret( buf, MBEDTLS_ENTROPY_BLOCK_SIZE,
422 buf, 0 ) ) != 0 )
423 goto exit;
424#endif /* MBEDTLS_ENTROPY_SHA512_ACCUMULATOR */
425
426 for( i = 0; i < ctx->source_count; i++ )
427 ctx->source[i].size = 0;
428
429 memcpy( output, buf, len );
430
431 ret = 0;
432
433exit:
434 mbedtls_platform_zeroize( buf, sizeof( buf ) );
435
436#if defined(MBEDTLS_THREADING_C)
437 if( mbedtls_mutex_unlock( &ctx->mutex ) != 0 )
438 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
439#endif
440
441 return( ret );
442}
443
444#if defined(MBEDTLS_ENTROPY_NV_SEED)
445int mbedtls_entropy_update_nv_seed( mbedtls_entropy_context *ctx )
446{
447 int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
448 unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
449
450 /* Read new seed and write it to NV */
451 if( ( ret = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
452 return( ret );
453
454 if( mbedtls_nv_seed_write( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
455 return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
456
457 /* Manually update the remaining stream with a separator value to diverge */
458 memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
459 ret = mbedtls_entropy_update_manual( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE );
460
461 return( ret );
462}
463#endif /* MBEDTLS_ENTROPY_NV_SEED */
464
465#if defined(MBEDTLS_FS_IO)
466int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
467{
468 int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
469 FILE *f;
470 unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
471
472 if( ( f = fopen( path, "wb" ) ) == NULL )
473 return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
474
475 if( ( ret = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
476 goto exit;
477
478 if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) != MBEDTLS_ENTROPY_BLOCK_SIZE )
479 {
480 ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
481 goto exit;
482 }
483
484 ret = 0;
485
486exit:
487 mbedtls_platform_zeroize( buf, sizeof( buf ) );
488
489 fclose( f );
490 return( ret );
491}
492
493int mbedtls_entropy_update_seed_file( mbedtls_entropy_context *ctx, const char *path )
494{
495 int ret = 0;
496 FILE *f;
497 size_t n;
498 unsigned char buf[ MBEDTLS_ENTROPY_MAX_SEED_SIZE ];
499
500 if( ( f = fopen( path, "rb" ) ) == NULL )
501 return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
502
503 fseek( f, 0, SEEK_END );
504 n = (size_t) ftell( f );
505 fseek( f, 0, SEEK_SET );
506
507 if( n > MBEDTLS_ENTROPY_MAX_SEED_SIZE )
508 n = MBEDTLS_ENTROPY_MAX_SEED_SIZE;
509
510 if( fread( buf, 1, n, f ) != n )
511 ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
512 else
513 ret = mbedtls_entropy_update_manual( ctx, buf, n );
514
515 fclose( f );
516
517 mbedtls_platform_zeroize( buf, sizeof( buf ) );
518
519 if( ret != 0 )
520 return( ret );
521
522 return( mbedtls_entropy_write_seed_file( ctx, path ) );
523}
524#endif /* MBEDTLS_FS_IO */
525
526#if defined(MBEDTLS_SELF_TEST)
527#if !defined(MBEDTLS_TEST_NULL_ENTROPY)
528/*
529 * Dummy source function
530 */
531static int entropy_dummy_source( void *data, unsigned char *output,
532 size_t len, size_t *olen )
533{
534 ((void) data);
535
536 memset( output, 0x2a, len );
537 *olen = len;
538
539 return( 0 );
540}
541#endif /* !MBEDTLS_TEST_NULL_ENTROPY */
542
543#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
544
545static int mbedtls_entropy_source_self_test_gather( unsigned char *buf, size_t buf_len )
546{
547 int ret = 0;
548 size_t entropy_len = 0;
549 size_t olen = 0;
550 size_t attempts = buf_len;
551
552 while( attempts > 0 && entropy_len < buf_len )
553 {
554 if( ( ret = mbedtls_hardware_poll( NULL, buf + entropy_len,
555 buf_len - entropy_len, &olen ) ) != 0 )
556 return( ret );
557
558 entropy_len += olen;
559 attempts--;
560 }
561
562 if( entropy_len < buf_len )
563 {
564 ret = 1;
565 }
566
567 return( ret );
568}
569
570
571static int mbedtls_entropy_source_self_test_check_bits( const unsigned char *buf,
572 size_t buf_len )
573{
574 unsigned char set= 0xFF;
575 unsigned char unset = 0x00;
576 size_t i;
577
578 for( i = 0; i < buf_len; i++ )
579 {
580 set &= buf[i];
581 unset |= buf[i];
582 }
583
584 return( set == 0xFF || unset == 0x00 );
585}
586
587/*
588 * A test to ensure hat the entropy sources are functioning correctly
589 * and there is no obvious failure. The test performs the following checks:
590 * - The entropy source is not providing only 0s (all bits unset) or 1s (all
591 * bits set).
592 * - The entropy source is not providing values in a pattern. Because the
593 * hardware could be providing data in an arbitrary length, this check polls
594 * the hardware entropy source twice and compares the result to ensure they
595 * are not equal.
596 * - The error code returned by the entropy source is not an error.
597 */
598int mbedtls_entropy_source_self_test( int verbose )
599{
600 int ret = 0;
601 unsigned char buf0[2 * sizeof( unsigned long long int )];
602 unsigned char buf1[2 * sizeof( unsigned long long int )];
603
604 if( verbose != 0 )
605 mbedtls_printf( " ENTROPY_BIAS test: " );
606
607 memset( buf0, 0x00, sizeof( buf0 ) );
608 memset( buf1, 0x00, sizeof( buf1 ) );
609
610 if( ( ret = mbedtls_entropy_source_self_test_gather( buf0, sizeof( buf0 ) ) ) != 0 )
611 goto cleanup;
612 if( ( ret = mbedtls_entropy_source_self_test_gather( buf1, sizeof( buf1 ) ) ) != 0 )
613 goto cleanup;
614
615 /* Make sure that the returned values are not all 0 or 1 */
616 if( ( ret = mbedtls_entropy_source_self_test_check_bits( buf0, sizeof( buf0 ) ) ) != 0 )
617 goto cleanup;
618 if( ( ret = mbedtls_entropy_source_self_test_check_bits( buf1, sizeof( buf1 ) ) ) != 0 )
619 goto cleanup;
620
621 /* Make sure that the entropy source is not returning values in a
622 * pattern */
623 ret = memcmp( buf0, buf1, sizeof( buf0 ) ) == 0;
624
625cleanup:
626 if( verbose != 0 )
627 {
628 if( ret != 0 )
629 mbedtls_printf( "failed\n" );
630 else
631 mbedtls_printf( "passed\n" );
632
633 mbedtls_printf( "\n" );
634 }
635
636 return( ret != 0 );
637}
638
639#endif /* MBEDTLS_ENTROPY_HARDWARE_ALT */
640
641/*
642 * The actual entropy quality is hard to test, but we can at least
643 * test that the functions don't cause errors and write the correct
644 * amount of data to buffers.
645 */
646int mbedtls_entropy_self_test( int verbose )
647{
648 int ret = 1;
649#if !defined(MBEDTLS_TEST_NULL_ENTROPY)
650 mbedtls_entropy_context ctx;
651 unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
652 unsigned char acc[MBEDTLS_ENTROPY_BLOCK_SIZE] = { 0 };
653 size_t i, j;
654#endif /* !MBEDTLS_TEST_NULL_ENTROPY */
655
656 if( verbose != 0 )
657 mbedtls_printf( " ENTROPY test: " );
658
659#if !defined(MBEDTLS_TEST_NULL_ENTROPY)
660 mbedtls_entropy_init( &ctx );
661
662 /* First do a gather to make sure we have default sources */
663 if( ( ret = mbedtls_entropy_gather( &ctx ) ) != 0 )
664 goto cleanup;
665
666 ret = mbedtls_entropy_add_source( &ctx, entropy_dummy_source, NULL, 16,
667 MBEDTLS_ENTROPY_SOURCE_WEAK );
668 if( ret != 0 )
669 goto cleanup;
670
671 if( ( ret = mbedtls_entropy_update_manual( &ctx, buf, sizeof buf ) ) != 0 )
672 goto cleanup;
673
674 /*
675 * To test that mbedtls_entropy_func writes correct number of bytes:
676 * - use the whole buffer and rely on ASan to detect overruns
677 * - collect entropy 8 times and OR the result in an accumulator:
678 * any byte should then be 0 with probably 2^(-64), so requiring
679 * each of the 32 or 64 bytes to be non-zero has a false failure rate
680 * of at most 2^(-58) which is acceptable.
681 */
682 for( i = 0; i < 8; i++ )
683 {
684 if( ( ret = mbedtls_entropy_func( &ctx, buf, sizeof( buf ) ) ) != 0 )
685 goto cleanup;
686
687 for( j = 0; j < sizeof( buf ); j++ )
688 acc[j] |= buf[j];
689 }
690
691 for( j = 0; j < sizeof( buf ); j++ )
692 {
693 if( acc[j] == 0 )
694 {
695 ret = 1;
696 goto cleanup;
697 }
698 }
699
700#if defined(MBEDTLS_ENTROPY_HARDWARE_ALT)
701 if( ( ret = mbedtls_entropy_source_self_test( 0 ) ) != 0 )
702 goto cleanup;
703#endif
704
705cleanup:
706 mbedtls_entropy_free( &ctx );
707#endif /* !MBEDTLS_TEST_NULL_ENTROPY */
708
709 if( verbose != 0 )
710 {
711 if( ret != 0 )
712 mbedtls_printf( "failed\n" );
713 else
714 mbedtls_printf( "passed\n" );
715
716 mbedtls_printf( "\n" );
717 }
718
719 return( ret != 0 );
720}
721#endif /* MBEDTLS_SELF_TEST */
722
723#endif /* MBEDTLS_ENTROPY_C */
Impressum, Datenschutz