Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Platform-specific and custom entropy polling functions |
| 3 | * |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 4 | * Copyright The Mbed TLS Contributors |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: Apache-2.0 |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 8 | * not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 18 | */ |
| 19 | |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 20 | #if defined(__linux__) |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 21 | #if !defined(_GNU_SOURCE) |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 22 | /* Ensure that syscall() is available even when compiling with -std=c99 */ |
| 23 | #define _GNU_SOURCE |
| 24 | #endif |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 25 | #include <features.h> |
| 26 | #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25) |
| 27 | #define HAVE_SYS_RANDOM 1 |
| 28 | #endif |
| 29 | #endif |
Nicholas Wilson | 2682edf | 2017-12-05 12:08:15 +0000 | [diff] [blame] | 30 | |
Gilles Peskine | db09ef6 | 2020-06-03 01:43:33 +0200 | [diff] [blame] | 31 | #include "common.h" |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 32 | |
Gilles Peskine | 02b9329 | 2018-06-01 14:38:45 +0200 | [diff] [blame] | 33 | #include <string.h> |
| 34 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 35 | #if defined(MBEDTLS_ENTROPY_C) |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 36 | |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 37 | #include "mbedtls/entropy.h" |
| 38 | #include "mbedtls/entropy_poll.h" |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 39 | #include "mbedtls/error.h" |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 40 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 41 | #if defined(MBEDTLS_TIMING_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 42 | #include "mbedtls/timing.h" |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 43 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 44 | #if defined(MBEDTLS_HAVEGE_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 45 | #include "mbedtls/havege.h" |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 46 | #endif |
Paul Bakker | 9988d6b | 2016-06-01 11:29:42 +0100 | [diff] [blame] | 47 | #if defined(MBEDTLS_ENTROPY_NV_SEED) |
| 48 | #include "mbedtls/platform.h" |
| 49 | #endif |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 50 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 51 | #if !defined(MBEDTLS_NO_PLATFORM_ENTROPY) |
Manuel Pégourié-Gonnard | 325ce09 | 2016-02-22 10:33:34 +0100 | [diff] [blame] | 52 | |
| 53 | #if !defined(unix) && !defined(__unix__) && !defined(__unix) && \ |
Augustin Cavalier | 60bc47d | 2018-04-11 20:27:32 -0400 | [diff] [blame] | 54 | !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \ |
Ørjan Malde | 479d8de | 2020-05-20 09:32:39 +0000 | [diff] [blame] | 55 | !defined(__HAIKU__) && !defined(__midipix__) |
Manuel Pégourié-Gonnard | 325ce09 | 2016-02-22 10:33:34 +0100 | [diff] [blame] | 56 | #error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in config.h" |
| 57 | #endif |
| 58 | |
Paul Bakker | fa6a620 | 2013-10-28 18:48:30 +0100 | [diff] [blame] | 59 | #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32) |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 60 | |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 61 | #if !defined(_WIN32_WINNT) |
| 62 | #define _WIN32_WINNT 0x0400 |
| 63 | #endif |
Paul Bakker | 4a2bd0d | 2012-11-02 11:06:08 +0000 | [diff] [blame] | 64 | #include <windows.h> |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 65 | #include <wincrypt.h> |
| 66 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 67 | int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len, |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 68 | size_t *olen ) |
| 69 | { |
| 70 | HCRYPTPROV provider; |
Paul Bakker | 6bcfc67 | 2011-12-05 13:54:00 +0000 | [diff] [blame] | 71 | ((void) data); |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 72 | *olen = 0; |
| 73 | |
| 74 | if( CryptAcquireContext( &provider, NULL, NULL, |
| 75 | PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE ) |
| 76 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 77 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 78 | } |
| 79 | |
Paul Bakker | b9cfaa0 | 2013-10-11 18:58:55 +0200 | [diff] [blame] | 80 | if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE ) |
Attila Molnar | 2791ba1 | 2016-01-26 11:39:26 +0100 | [diff] [blame] | 81 | { |
| 82 | CryptReleaseContext( provider, 0 ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 83 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
Attila Molnar | 2791ba1 | 2016-01-26 11:39:26 +0100 | [diff] [blame] | 84 | } |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 85 | |
| 86 | CryptReleaseContext( provider, 0 ); |
| 87 | *olen = len; |
| 88 | |
| 89 | return( 0 ); |
| 90 | } |
Paul Bakker | 9af723c | 2014-05-01 13:03:14 +0200 | [diff] [blame] | 91 | #else /* _WIN32 && !EFIX64 && !EFI32 */ |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 92 | |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 93 | /* |
| 94 | * Test for Linux getrandom() support. |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 95 | * When the C library is GNU libc and its version is greater than 2.25, |
| 96 | * include sys/random.h to use getrandom(), |
| 97 | * otherwise use the generic use the generic syscall wrapper |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 98 | * available in GNU libc and compatible libc's (eg uClibc). |
| 99 | */ |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 100 | #if HAVE_SYS_RANDOM |
| 101 | #include <sys/random.h> |
| 102 | #include <errno.h> |
| 103 | #define HAVE_GETRANDOM |
| 104 | #elif (defined(__linux__) && defined(__GLIBC__)) || defined(__midipix__) |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 105 | #include <unistd.h> |
| 106 | #include <sys/syscall.h> |
| 107 | #if defined(SYS_getrandom) |
| 108 | #define HAVE_GETRANDOM |
Hanno Becker | 2751697 | 2018-10-18 11:49:25 +0100 | [diff] [blame] | 109 | #include <errno.h> |
Manuel Pégourié-Gonnard | bcf13ba | 2015-06-22 18:06:17 +0200 | [diff] [blame] | 110 | |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 111 | static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags ) |
| 112 | { |
Manuel Pégourié-Gonnard | bcf13ba | 2015-06-22 18:06:17 +0200 | [diff] [blame] | 113 | /* MemSan cannot understand that the syscall writes to the buffer */ |
| 114 | #if defined(__has_feature) |
| 115 | #if __has_feature(memory_sanitizer) |
| 116 | memset( buf, 0, buflen ); |
| 117 | #endif |
| 118 | #endif |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 119 | return( syscall( SYS_getrandom, buf, buflen, flags ) ); |
| 120 | } |
Manuel Pégourié-Gonnard | d97828e | 2015-04-29 14:03:28 +0200 | [diff] [blame] | 121 | #endif /* SYS_getrandom */ |
Ørjan Malde | 479d8de | 2020-05-20 09:32:39 +0000 | [diff] [blame] | 122 | #endif /* __linux__ || __midipix__ */ |
Manuel Pégourié-Gonnard | 1829245 | 2015-01-09 14:34:13 +0100 | [diff] [blame] | 123 | |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 124 | /* |
| 125 | * Some BSD systems provide KERN_ARND. |
| 126 | * This is equivalent to reading from /dev/urandom, only it doesn't require an |
| 127 | * open file descriptor, and provides up to 256 bytes per call (basically the |
| 128 | * same as getentropy(), but with a longer history). |
| 129 | * |
| 130 | * Documentation: https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7 |
| 131 | */ |
| 132 | #if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM) |
| 133 | #include <sys/param.h> |
| 134 | #include <sys/sysctl.h> |
| 135 | #if defined(KERN_ARND) |
| 136 | #define HAVE_SYSCTL_ARND |
| 137 | |
nia | 8373c86 | 2020-06-24 17:15:02 +0100 | [diff] [blame] | 138 | static int sysctl_arnd_wrapper( unsigned char *buf, size_t buflen ) |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 139 | { |
| 140 | int name[2]; |
| 141 | size_t len; |
| 142 | |
| 143 | name[0] = CTL_KERN; |
| 144 | name[1] = KERN_ARND; |
| 145 | |
| 146 | while( buflen > 0 ) |
| 147 | { |
| 148 | len = buflen > 256 ? 256 : buflen; |
nia | 8373c86 | 2020-06-24 17:15:02 +0100 | [diff] [blame] | 149 | if( sysctl(name, 2, buf, &len, NULL, 0) == -1 ) |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 150 | return( -1 ); |
| 151 | buflen -= len; |
nia | 8373c86 | 2020-06-24 17:15:02 +0100 | [diff] [blame] | 152 | buf += len; |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 153 | } |
| 154 | return( 0 ); |
| 155 | } |
| 156 | #endif /* KERN_ARND */ |
| 157 | #endif /* __FreeBSD__ || __NetBSD__ */ |
| 158 | |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 159 | #include <stdio.h> |
| 160 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 161 | int mbedtls_platform_entropy_poll( void *data, |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 162 | unsigned char *output, size_t len, size_t *olen ) |
| 163 | { |
| 164 | FILE *file; |
Manuel Pégourié-Gonnard | ea35666 | 2015-08-27 12:02:40 +0200 | [diff] [blame] | 165 | size_t read_len; |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 166 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 167 | ((void) data); |
| 168 | |
Manuel Pégourié-Gonnard | d97828e | 2015-04-29 14:03:28 +0200 | [diff] [blame] | 169 | #if defined(HAVE_GETRANDOM) |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 170 | #if HAVE_SYS_RANDOM |
| 171 | ret = getrandom(output, len, 0); |
| 172 | #else |
Hanno Becker | 2751697 | 2018-10-18 11:49:25 +0100 | [diff] [blame] | 173 | ret = getrandom_wrapper( output, len, 0 ); |
okhowang(王沛文) | 9c46a60 | 2020-09-03 16:55:01 +0800 | [diff] [blame] | 174 | #endif |
Hanno Becker | 2751697 | 2018-10-18 11:49:25 +0100 | [diff] [blame] | 175 | if( ret >= 0 ) |
Manuel Pégourié-Gonnard | d97828e | 2015-04-29 14:03:28 +0200 | [diff] [blame] | 176 | { |
Manuel Pégourié-Gonnard | d97828e | 2015-04-29 14:03:28 +0200 | [diff] [blame] | 177 | *olen = ret; |
| 178 | return( 0 ); |
| 179 | } |
Hanno Becker | 2751697 | 2018-10-18 11:49:25 +0100 | [diff] [blame] | 180 | else if( errno != ENOSYS ) |
| 181 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
| 182 | /* Fall through if the system call isn't known. */ |
| 183 | #else |
Hanno Becker | 9772da8 | 2018-11-05 11:43:07 +0000 | [diff] [blame] | 184 | ((void) ret); |
Manuel Pégourié-Gonnard | d97828e | 2015-04-29 14:03:28 +0200 | [diff] [blame] | 185 | #endif /* HAVE_GETRANDOM */ |
| 186 | |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 187 | #if defined(HAVE_SYSCTL_ARND) |
| 188 | ((void) file); |
| 189 | ((void) read_len); |
nia | f4d9f21 | 2020-06-19 16:14:27 +0100 | [diff] [blame] | 190 | if( sysctl_arnd_wrapper( output, len ) == -1 ) |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 191 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
| 192 | *olen = len; |
| 193 | return( 0 ); |
| 194 | #else |
| 195 | |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 196 | *olen = 0; |
| 197 | |
| 198 | file = fopen( "/dev/urandom", "rb" ); |
| 199 | if( file == NULL ) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 200 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
Paul Bakker | 9af723c | 2014-05-01 13:03:14 +0200 | [diff] [blame] | 201 | |
Manuel Pégourié-Gonnard | ea35666 | 2015-08-27 12:02:40 +0200 | [diff] [blame] | 202 | read_len = fread( output, 1, len, file ); |
| 203 | if( read_len != len ) |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 204 | { |
| 205 | fclose( file ); |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 206 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | fclose( file ); |
| 210 | *olen = len; |
| 211 | |
| 212 | return( 0 ); |
nia | 9f5312c | 2020-06-11 13:32:13 +0100 | [diff] [blame] | 213 | #endif /* HAVE_SYSCTL_ARND */ |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 214 | } |
Paul Bakker | 9af723c | 2014-05-01 13:03:14 +0200 | [diff] [blame] | 215 | #endif /* _WIN32 && !EFIX64 && !EFI32 */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 216 | #endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */ |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 217 | |
Simon Butcher | ab5df40 | 2016-06-11 02:31:21 +0100 | [diff] [blame] | 218 | #if defined(MBEDTLS_TEST_NULL_ENTROPY) |
Simon Butcher | 4157b60 | 2016-06-12 00:31:33 +0100 | [diff] [blame] | 219 | int mbedtls_null_entropy_poll( void *data, |
Janos Follath | 53de784 | 2016-06-08 15:29:18 +0100 | [diff] [blame] | 220 | unsigned char *output, size_t len, size_t *olen ) |
| 221 | { |
| 222 | ((void) data); |
Simon Butcher | ab5df40 | 2016-06-11 02:31:21 +0100 | [diff] [blame] | 223 | ((void) output); |
Janos Follath | 53de784 | 2016-06-08 15:29:18 +0100 | [diff] [blame] | 224 | *olen = 0; |
| 225 | |
| 226 | if( len < sizeof(unsigned char) ) |
| 227 | return( 0 ); |
| 228 | |
| 229 | *olen = sizeof(unsigned char); |
| 230 | |
| 231 | return( 0 ); |
| 232 | } |
| 233 | #endif |
| 234 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 235 | #if defined(MBEDTLS_TIMING_C) |
| 236 | int mbedtls_hardclock_poll( void *data, |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 237 | unsigned char *output, size_t len, size_t *olen ) |
| 238 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 239 | unsigned long timer = mbedtls_timing_hardclock(); |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 240 | ((void) data); |
| 241 | *olen = 0; |
| 242 | |
| 243 | if( len < sizeof(unsigned long) ) |
| 244 | return( 0 ); |
| 245 | |
| 246 | memcpy( output, &timer, sizeof(unsigned long) ); |
| 247 | *olen = sizeof(unsigned long); |
| 248 | |
| 249 | return( 0 ); |
| 250 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 251 | #endif /* MBEDTLS_TIMING_C */ |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 252 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 253 | #if defined(MBEDTLS_HAVEGE_C) |
| 254 | int mbedtls_havege_poll( void *data, |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 255 | unsigned char *output, size_t len, size_t *olen ) |
| 256 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 257 | mbedtls_havege_state *hs = (mbedtls_havege_state *) data; |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 258 | *olen = 0; |
| 259 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 260 | if( mbedtls_havege_random( hs, output, len ) != 0 ) |
| 261 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 262 | |
| 263 | *olen = len; |
| 264 | |
| 265 | return( 0 ); |
| 266 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 267 | #endif /* MBEDTLS_HAVEGE_C */ |
Paul Bakker | 6083fd2 | 2011-12-03 21:45:14 +0000 | [diff] [blame] | 268 | |
Paul Bakker | 9988d6b | 2016-06-01 11:29:42 +0100 | [diff] [blame] | 269 | #if defined(MBEDTLS_ENTROPY_NV_SEED) |
| 270 | int mbedtls_nv_seed_poll( void *data, |
| 271 | unsigned char *output, size_t len, size_t *olen ) |
| 272 | { |
| 273 | unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE]; |
| 274 | size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE; |
| 275 | ((void) data); |
| 276 | |
| 277 | memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE ); |
| 278 | |
| 279 | if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 ) |
| 280 | return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED ); |
| 281 | |
| 282 | if( len < use_len ) |
| 283 | use_len = len; |
| 284 | |
| 285 | memcpy( output, buf, use_len ); |
| 286 | *olen = use_len; |
| 287 | |
| 288 | return( 0 ); |
| 289 | } |
| 290 | #endif /* MBEDTLS_ENTROPY_NV_SEED */ |
| 291 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 292 | #endif /* MBEDTLS_ENTROPY_C */ |