1 /*
2 * Platform-specific and custom entropy polling functions
3 *
4 * Copyright The Mbed TLS Contributors
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.
18 */
19
20 #if defined(__linux__) && !defined(_GNU_SOURCE)
21 /* Ensure that syscall() is available even when compiling with -std=c99 */
22 #define _GNU_SOURCE
23 #endif
24
25 #include "common.h"
26
27 #include <string.h>
28
29 #if defined(MBEDTLS_ENTROPY_C)
30
31 #include "mbedtls/entropy.h"
32 #include "mbedtls/entropy_poll.h"
33 #include "mbedtls/error.h"
34
35 #if defined(MBEDTLS_TIMING_C)
36 #include "mbedtls/timing.h"
37 #endif
38 #if defined(MBEDTLS_HAVEGE_C)
39 #include "mbedtls/havege.h"
40 #endif
41 #if defined(MBEDTLS_ENTROPY_NV_SEED)
42 #include "mbedtls/platform.h"
43 #endif
44
45 #if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
46
47 #if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
48 !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \
49 !defined(__HAIKU__) && !defined(__midipix__)
50 #error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in config.h"
51 #endif
52
53 #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
54
55 #if !defined(_WIN32_WINNT)
56 #define _WIN32_WINNT 0x0400
57 #endif
58 #include <windows.h>
59 #include <wincrypt.h>
60
mbedtls_platform_entropy_poll(void * data,unsigned char * output,size_t len,size_t * olen)61 int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
62 size_t *olen )
63 {
64 HCRYPTPROV provider;
65 ((void) data);
66 *olen = 0;
67
68 if( CryptAcquireContext( &provider, NULL, NULL,
69 PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
70 {
71 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
72 }
73
74 if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
75 {
76 CryptReleaseContext( provider, 0 );
77 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
78 }
79
80 CryptReleaseContext( provider, 0 );
81 *olen = len;
82
83 return( 0 );
84 }
85 #else /* _WIN32 && !EFIX64 && !EFI32 */
86
87 /*
88 * Test for Linux getrandom() support.
89 * Since there is no wrapper in the libc yet, use the generic syscall wrapper
90 * available in GNU libc and compatible libc's (eg uClibc).
91 */
92 #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__midipix__))
93 #include <unistd.h>
94 #include <sys/syscall.h>
95 #if defined(SYS_getrandom)
96 #define HAVE_GETRANDOM
97 #include <errno.h>
98
getrandom_wrapper(void * buf,size_t buflen,unsigned int flags)99 static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
100 {
101 /* MemSan cannot understand that the syscall writes to the buffer */
102 #if defined(__has_feature)
103 #if __has_feature(memory_sanitizer)
104 memset( buf, 0, buflen );
105 #endif
106 #endif
107 return( syscall( SYS_getrandom, buf, buflen, flags ) );
108 }
109 #endif /* SYS_getrandom */
110 #endif /* __linux__ || __midipix__ */
111
112 /*
113 * Some BSD systems provide KERN_ARND.
114 * This is equivalent to reading from /dev/urandom, only it doesn't require an
115 * open file descriptor, and provides up to 256 bytes per call (basically the
116 * same as getentropy(), but with a longer history).
117 *
118 * Documentation: https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7
119 */
120 #if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM)
121 #include <sys/param.h>
122 #include <sys/sysctl.h>
123 #if defined(KERN_ARND)
124 #define HAVE_SYSCTL_ARND
125
sysctl_arnd_wrapper(unsigned char * buf,size_t buflen)126 static int sysctl_arnd_wrapper( unsigned char *buf, size_t buflen )
127 {
128 int name[2];
129 size_t len;
130
131 name[0] = CTL_KERN;
132 name[1] = KERN_ARND;
133
134 while( buflen > 0 )
135 {
136 len = buflen > 256 ? 256 : buflen;
137 if( sysctl(name, 2, buf, &len, NULL, 0) == -1 )
138 return( -1 );
139 buflen -= len;
140 buf += len;
141 }
142 return( 0 );
143 }
144 #endif /* KERN_ARND */
145 #endif /* __FreeBSD__ || __NetBSD__ */
146
147 #include <stdio.h>
148
mbedtls_platform_entropy_poll(void * data,unsigned char * output,size_t len,size_t * olen)149 int mbedtls_platform_entropy_poll( void *data,
150 unsigned char *output, size_t len, size_t *olen )
151 {
152 FILE *file;
153 size_t read_len;
154 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
155 ((void) data);
156
157 #if defined(HAVE_GETRANDOM)
158 ret = getrandom_wrapper( output, len, 0 );
159 if( ret >= 0 )
160 {
161 *olen = ret;
162 return( 0 );
163 }
164 else if( errno != ENOSYS )
165 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
166 /* Fall through if the system call isn't known. */
167 #else
168 ((void) ret);
169 #endif /* HAVE_GETRANDOM */
170
171 #if defined(HAVE_SYSCTL_ARND)
172 ((void) file);
173 ((void) read_len);
174 if( sysctl_arnd_wrapper( output, len ) == -1 )
175 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
176 *olen = len;
177 return( 0 );
178 #else
179
180 *olen = 0;
181
182 file = fopen( "/dev/urandom", "rb" );
183 if( file == NULL )
184 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
185
186 read_len = fread( output, 1, len, file );
187 if( read_len != len )
188 {
189 fclose( file );
190 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
191 }
192
193 fclose( file );
194 *olen = len;
195
196 return( 0 );
197 #endif /* HAVE_SYSCTL_ARND */
198 }
199 #endif /* _WIN32 && !EFIX64 && !EFI32 */
200 #endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
201
202 #if defined(MBEDTLS_TEST_NULL_ENTROPY)
mbedtls_null_entropy_poll(void * data,unsigned char * output,size_t len,size_t * olen)203 int mbedtls_null_entropy_poll( void *data,
204 unsigned char *output, size_t len, size_t *olen )
205 {
206 ((void) data);
207 ((void) output);
208 *olen = 0;
209
210 if( len < sizeof(unsigned char) )
211 return( 0 );
212
213 *olen = sizeof(unsigned char);
214
215 return( 0 );
216 }
217 #endif
218
219 #if defined(MBEDTLS_TIMING_C)
mbedtls_hardclock_poll(void * data,unsigned char * output,size_t len,size_t * olen)220 int mbedtls_hardclock_poll( void *data,
221 unsigned char *output, size_t len, size_t *olen )
222 {
223 unsigned long timer = mbedtls_timing_hardclock();
224 ((void) data);
225 *olen = 0;
226
227 if( len < sizeof(unsigned long) )
228 return( 0 );
229
230 memcpy( output, &timer, sizeof(unsigned long) );
231 *olen = sizeof(unsigned long);
232
233 return( 0 );
234 }
235 #endif /* MBEDTLS_TIMING_C */
236
237 #if defined(MBEDTLS_HAVEGE_C)
mbedtls_havege_poll(void * data,unsigned char * output,size_t len,size_t * olen)238 int mbedtls_havege_poll( void *data,
239 unsigned char *output, size_t len, size_t *olen )
240 {
241 mbedtls_havege_state *hs = (mbedtls_havege_state *) data;
242 *olen = 0;
243
244 if( mbedtls_havege_random( hs, output, len ) != 0 )
245 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
246
247 *olen = len;
248
249 return( 0 );
250 }
251 #endif /* MBEDTLS_HAVEGE_C */
252
253 #if defined(MBEDTLS_ENTROPY_NV_SEED)
mbedtls_nv_seed_poll(void * data,unsigned char * output,size_t len,size_t * olen)254 int mbedtls_nv_seed_poll( void *data,
255 unsigned char *output, size_t len, size_t *olen )
256 {
257 unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
258 size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
259 ((void) data);
260
261 memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
262
263 if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
264 return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
265
266 if( len < use_len )
267 use_len = len;
268
269 memcpy( output, buf, use_len );
270 *olen = use_len;
271
272 return( 0 );
273 }
274 #endif /* MBEDTLS_ENTROPY_NV_SEED */
275
276 #endif /* MBEDTLS_ENTROPY_C */
277
