← Back to branch summary

~bibledit/bibledit/client

« back to all changes in this revision

Viewing changes to mbedtls2/entropy_poll.c

  • Committer: Teus Benschop
  • Date: 2024-08-17 17:08:44 UTC
  • Revision ID: teusjannette@gmail.com-20240817170844-0qf789ywtms3hyz7
new upstream version

Show diffs side-by-side

added added

removed removed

Lines of Context:
mbedtls2/entropy_poll.c
 
1
#pragma clang diagnostic ignored "-Wunknown-warning-option"
 
2
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
3
#pragma clang diagnostic ignored "-Wsign-conversion"
 
4
 
 
5
#pragma GCC diagnostic ignored "-Wconversion"
 
6
 
 
7
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
8
#pragma clang diagnostic ignored "-Wsign-conversion"
 
9
 
 
10
#pragma GCC diagnostic ignored "-Wconversion"
 
11
 
 
12
#pragma clang diagnostic ignored "-Wimplicit-int-conversion"
 
13
#pragma clang diagnostic ignored "-Wsign-conversion"
 
14
/*
 
15
 *  Platform-specific and custom entropy polling functions
 
16
 *
 
17
 *  Copyright The Mbed TLS Contributors
 
18
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
 
19
 *
 
20
 *  This file is provided under the Apache License 2.0, or the
 
21
 *  GNU General Public License v2.0 or later.
 
22
 *
 
23
 *  **********
 
24
 *  Apache License 2.0:
 
25
 *
 
26
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may
 
27
 *  not use this file except in compliance with the License.
 
28
 *  You may obtain a copy of the License at
 
29
 *
 
30
 *  http://www.apache.org/licenses/LICENSE-2.0
 
31
 *
 
32
 *  Unless required by applicable law or agreed to in writing, software
 
33
 *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
34
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
35
 *  See the License for the specific language governing permissions and
 
36
 *  limitations under the License.
 
37
 *
 
38
 *  **********
 
39
 *
 
40
 *  **********
 
41
 *  GNU General Public License v2.0 or later:
 
42
 *
 
43
 *  This program is free software; you can redistribute it and/or modify
 
44
 *  it under the terms of the GNU General Public License as published by
 
45
 *  the Free Software Foundation; either version 2 of the License, or
 
46
 *  (at your option) any later version.
 
47
 *
 
48
 *  This program is distributed in the hope that it will be useful,
 
49
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
50
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
51
 *  GNU General Public License for more details.
 
52
 *
 
53
 *  You should have received a copy of the GNU General Public License along
 
54
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 
55
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
56
 *
 
57
 *  **********
 
58
 */
 
59
 
 
60
#if defined(__linux__) && !defined(_GNU_SOURCE)
 
61
/* Ensure that syscall() is available even when compiling with -std=c99 */
 
62
#define _GNU_SOURCE
 
63
#endif
 
64
 
 
65
#if !defined(MBEDTLS_CONFIG_FILE)
 
66
#include "mbedtls/config.h"
 
67
#else
 
68
#include MBEDTLS_CONFIG_FILE
 
69
#endif
 
70
 
 
71
#include <string.h>
 
72
 
 
73
#if defined(MBEDTLS_ENTROPY_C)
 
74
 
 
75
#include "mbedtls/entropy.h"
 
76
#include "mbedtls/entropy_poll.h"
 
77
 
 
78
#if defined(MBEDTLS_TIMING_C)
 
79
#include "mbedtls/timing.h"
 
80
#endif
 
81
#if defined(MBEDTLS_HAVEGE_C)
 
82
#include "mbedtls/havege.h"
 
83
#endif
 
84
#if defined(MBEDTLS_ENTROPY_NV_SEED)
 
85
#include "mbedtls/platform.h"
 
86
#endif
 
87
 
 
88
#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY)
 
89
 
 
90
#if !defined(unix) && !defined(__unix__) && !defined(__unix) && \
 
91
    !defined(__APPLE__) && !defined(_WIN32) && !defined(__QNXNTO__) && \
 
92
    !defined(__HAIKU__)
 
93
#error "Platform entropy sources only work on Unix and Windows, see MBEDTLS_NO_PLATFORM_ENTROPY in config.h"
 
94
#endif
 
95
 
 
96
#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
 
97
 
 
98
#if !defined(_WIN32_WINNT)
 
99
#define _WIN32_WINNT 0x0400
 
100
#endif
 
101
#include <windows.h>
 
102
#include <wincrypt.h>
 
103
 
 
104
int mbedtls_platform_entropy_poll( void *data, unsigned char *output, size_t len,
 
105
                           size_t *olen )
 
106
{
 
107
    HCRYPTPROV provider;
 
108
    ((void) data);
 
109
    *olen = 0;
 
110
 
 
111
    if( CryptAcquireContext( &provider, NULL, NULL,
 
112
                              PROV_RSA_FULL, CRYPT_VERIFYCONTEXT ) == FALSE )
 
113
    {
 
114
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
115
    }
 
116
 
 
117
    if( CryptGenRandom( provider, (DWORD) len, output ) == FALSE )
 
118
    {
 
119
        CryptReleaseContext( provider, 0 );
 
120
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
121
    }
 
122
 
 
123
    CryptReleaseContext( provider, 0 );
 
124
    *olen = len;
 
125
 
 
126
    return( 0 );
 
127
}
 
128
#else /* _WIN32 && !EFIX64 && !EFI32 */
 
129
 
 
130
/*
 
131
 * Test for Linux getrandom() support.
 
132
 * Since there is no wrapper in the libc yet, use the generic syscall wrapper
 
133
 * available in GNU libc and compatible libc's (eg uClibc).
 
134
 */
 
135
#if defined(__linux__) && defined(__GLIBC__)
 
136
#include <unistd.h>
 
137
#include <sys/syscall.h>
 
138
#if defined(SYS_getrandom)
 
139
#define HAVE_GETRANDOM
 
140
#include <errno.h>
 
141
 
 
142
static int getrandom_wrapper( void *buf, size_t buflen, unsigned int flags )
 
143
{
 
144
    /* MemSan cannot understand that the syscall writes to the buffer */
 
145
#if defined(__has_feature)
 
146
#if __has_feature(memory_sanitizer)
 
147
    memset( buf, 0, buflen );
 
148
#endif
 
149
#endif
 
150
    return( syscall( SYS_getrandom, buf, buflen, flags ) );
 
151
}
 
152
#endif /* SYS_getrandom */
 
153
#endif /* __linux__ */
 
154
 
 
155
#include <stdio.h>
 
156
 
 
157
int mbedtls_platform_entropy_poll( void *data,
 
158
                           unsigned char *output, size_t len, size_t *olen )
 
159
{
 
160
    FILE *file;
 
161
    size_t read_len;
 
162
    int ret;
 
163
    ((void) data);
 
164
 
 
165
#if defined(HAVE_GETRANDOM)
 
166
    ret = getrandom_wrapper( output, len, 0 );
 
167
    if( ret >= 0 )
 
168
    {
 
169
        *olen = ret;
 
170
        return( 0 );
 
171
    }
 
172
    else if( errno != ENOSYS )
 
173
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
174
    /* Fall through if the system call isn't known. */
 
175
#else
 
176
    ((void) ret);
 
177
#endif /* HAVE_GETRANDOM */
 
178
 
 
179
    *olen = 0;
 
180
 
 
181
    file = fopen( "/dev/urandom", "rb" );
 
182
    if( file == NULL )
 
183
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
184
 
 
185
    read_len = fread( output, 1, len, file );
 
186
    if( read_len != len )
 
187
    {
 
188
        fclose( file );
 
189
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
190
    }
 
191
 
 
192
    fclose( file );
 
193
    *olen = len;
 
194
 
 
195
    return( 0 );
 
196
}
 
197
#endif /* _WIN32 && !EFIX64 && !EFI32 */
 
198
#endif /* !MBEDTLS_NO_PLATFORM_ENTROPY */
 
199
 
 
200
#if defined(MBEDTLS_TEST_NULL_ENTROPY)
 
201
int mbedtls_null_entropy_poll( void *data,
 
202
                    unsigned char *output, size_t len, size_t *olen )
 
203
{
 
204
    ((void) data);
 
205
    ((void) output);
 
206
    *olen = 0;
 
207
 
 
208
    if( len < sizeof(unsigned char) )
 
209
        return( 0 );
 
210
 
 
211
    *olen = sizeof(unsigned char);
 
212
 
 
213
    return( 0 );
 
214
}
 
215
#endif
 
216
 
 
217
#if defined(MBEDTLS_TIMING_C)
 
218
int mbedtls_hardclock_poll( void *data,
 
219
                    unsigned char *output, size_t len, size_t *olen )
 
220
{
 
221
    unsigned long timer = mbedtls_timing_hardclock();
 
222
    ((void) data);
 
223
    *olen = 0;
 
224
 
 
225
    if( len < sizeof(unsigned long) )
 
226
        return( 0 );
 
227
 
 
228
    memcpy( output, &timer, sizeof(unsigned long) );
 
229
    *olen = sizeof(unsigned long);
 
230
 
 
231
    return( 0 );
 
232
}
 
233
#endif /* MBEDTLS_TIMING_C */
 
234
 
 
235
#if defined(MBEDTLS_HAVEGE_C)
 
236
int mbedtls_havege_poll( void *data,
 
237
                 unsigned char *output, size_t len, size_t *olen )
 
238
{
 
239
    mbedtls_havege_state *hs = (mbedtls_havege_state *) data;
 
240
    *olen = 0;
 
241
 
 
242
    if( mbedtls_havege_random( hs, output, len ) != 0 )
 
243
        return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
244
 
 
245
    *olen = len;
 
246
 
 
247
    return( 0 );
 
248
}
 
249
#endif /* MBEDTLS_HAVEGE_C */
 
250
 
 
251
#if defined(MBEDTLS_ENTROPY_NV_SEED)
 
252
int mbedtls_nv_seed_poll( void *data,
 
253
                          unsigned char *output, size_t len, size_t *olen )
 
254
{
 
255
    unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
 
256
    size_t use_len = MBEDTLS_ENTROPY_BLOCK_SIZE;
 
257
    ((void) data);
 
258
 
 
259
    memset( buf, 0, MBEDTLS_ENTROPY_BLOCK_SIZE );
 
260
 
 
261
    if( mbedtls_nv_seed_read( buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) < 0 )
 
262
      return( MBEDTLS_ERR_ENTROPY_SOURCE_FAILED );
 
263
 
 
264
    if( len < use_len )
 
265
      use_len = len;
 
266
 
 
267
    memcpy( output, buf, use_len );
 
268
    *olen = use_len;
 
269
 
 
270
    return( 0 );
 
271
}
 
272
#endif /* MBEDTLS_ENTROPY_NV_SEED */
 
273
 
 
274
#endif /* MBEDTLS_ENTROPY_C */