Coverage Report

Created: 2024-05-04 12:45

/proc/self/cwd/external/curl/lib/rand.c
Line
Count
Source (jump to first uncovered line)
1
/***************************************************************************
2
 *                                  _   _ ____  _
3
 *  Project                     ___| | | |  _ \| |
4
 *                             / __| | | | |_) | |
5
 *                            | (__| |_| |  _ <| |___
6
 *                             \___|\___/|_| \_\_____|
7
 *
8
 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9
 *
10
 * This software is licensed as described in the file COPYING, which
11
 * you should have received as part of this distribution. The terms
12
 * are also available at https://curl.se/docs/copyright.html.
13
 *
14
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15
 * copies of the Software, and permit persons to whom the Software is
16
 * furnished to do so, under the terms of the COPYING file.
17
 *
18
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19
 * KIND, either express or implied.
20
 *
21
 * SPDX-License-Identifier: curl
22
 *
23
 ***************************************************************************/
24
25
#include "curl_setup.h"
26
27
#include <limits.h>
28
29
#ifdef HAVE_FCNTL_H
30
#include <fcntl.h>
31
#endif
32
#ifdef HAVE_ARPA_INET_H
33
#include <arpa/inet.h>
34
#endif
35
#ifdef HAVE_ARC4RANDOM
36
/* Some platforms might have the prototype missing (ubuntu + libressl) */
37
uint32_t arc4random(void);
38
#endif
39
40
#include <curl/curl.h>
41
#include "urldata.h"
42
#include "vtls/vtls.h"
43
#include "sendf.h"
44
#include "timeval.h"
45
#include "rand.h"
46
#include "escape.h"
47
48
/* The last 3 #include files should be in this order */
49
#include "curl_printf.h"
50
#include "curl_memory.h"
51
#include "memdebug.h"
52
53
#ifdef WIN32
54
55
#if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x600
56
#  define HAVE_WIN_BCRYPTGENRANDOM
57
#  include <bcrypt.h>
58
#  ifdef _MSC_VER
59
#    pragma comment(lib, "bcrypt.lib")
60
#  endif
61
#  ifndef BCRYPT_USE_SYSTEM_PREFERRED_RNG
62
#  define BCRYPT_USE_SYSTEM_PREFERRED_RNG 0x00000002
63
#  endif
64
#  ifndef STATUS_SUCCESS
65
#  define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
66
#  endif
67
#elif defined(USE_WIN32_CRYPTO)
68
#  include <wincrypt.h>
69
#  ifdef _MSC_VER
70
#    pragma comment(lib, "advapi32.lib")
71
#  endif
72
#endif
73
74
CURLcode Curl_win32_random(unsigned char *entropy, size_t length)
75
{
76
  memset(entropy, 0, length);
77
78
#if defined(HAVE_WIN_BCRYPTGENRANDOM)
79
  if(BCryptGenRandom(NULL, entropy, (ULONG)length,
80
                     BCRYPT_USE_SYSTEM_PREFERRED_RNG) != STATUS_SUCCESS)
81
    return CURLE_FAILED_INIT;
82
83
  return CURLE_OK;
84
#elif defined(USE_WIN32_CRYPTO)
85
  {
86
    HCRYPTPROV hCryptProv = 0;
87
88
    if(!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
89
                            CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
90
      return CURLE_FAILED_INIT;
91
92
    if(!CryptGenRandom(hCryptProv, (DWORD)length, entropy)) {
93
      CryptReleaseContext(hCryptProv, 0UL);
94
      return CURLE_FAILED_INIT;
95
    }
96
97
    CryptReleaseContext(hCryptProv, 0UL);
98
  }
99
  return CURLE_OK;
100
#else
101
  return CURLE_NOT_BUILT_IN;
102
#endif
103
}
104
#endif
105
106
static CURLcode randit(struct Curl_easy *data, unsigned int *rnd)
107
0
{
108
0
  unsigned int r;
109
0
  CURLcode result = CURLE_OK;
110
0
  static unsigned int randseed;
111
0
  static bool seeded = FALSE;
112
113
#ifdef CURLDEBUG
114
  char *force_entropy = getenv("CURL_ENTROPY");
115
  if(force_entropy) {
116
    if(!seeded) {
117
      unsigned int seed = 0;
118
      size_t elen = strlen(force_entropy);
119
      size_t clen = sizeof(seed);
120
      size_t min = elen < clen ? elen : clen;
121
      memcpy((char *)&seed, force_entropy, min);
122
      randseed = ntohl(seed);
123
      seeded = TRUE;
124
    }
125
    else
126
      randseed++;
127
    *rnd = randseed;
128
    return CURLE_OK;
129
  }
130
#endif
131
132
  /* data may be NULL! */
133
0
  result = Curl_ssl_random(data, (unsigned char *)rnd, sizeof(*rnd));
134
0
  if(result != CURLE_NOT_BUILT_IN)
135
    /* only if there is no random function in the TLS backend do the non crypto
136
       version, otherwise return result */
137
0
    return result;
138
139
  /* ---- non-cryptographic version following ---- */
140
141
#ifdef WIN32
142
  if(!seeded) {
143
    result = Curl_win32_random((unsigned char *)rnd, sizeof(*rnd));
144
    if(result != CURLE_NOT_BUILT_IN)
145
      return result;
146
  }
147
#endif
148
149
#ifdef HAVE_ARC4RANDOM
150
  *rnd = (unsigned int)arc4random();
151
  return CURLE_OK;
152
#endif
153
154
0
#if defined(RANDOM_FILE) && !defined(WIN32)
155
0
  if(!seeded) {
156
    /* if there's a random file to read a seed from, use it */
157
0
    int fd = open(RANDOM_FILE, O_RDONLY);
158
0
    if(fd > -1) {
159
      /* read random data into the randseed variable */
160
0
      ssize_t nread = read(fd, &randseed, sizeof(randseed));
161
0
      if(nread == sizeof(randseed))
162
0
        seeded = TRUE;
163
0
      close(fd);
164
0
    }
165
0
  }
166
0
#endif
167
168
0
  if(!seeded) {
169
0
    struct curltime now = Curl_now();
170
0
    infof(data, "WARNING: using weak random seed");
171
0
    randseed += (unsigned int)now.tv_usec + (unsigned int)now.tv_sec;
172
0
    randseed = randseed * 1103515245 + 12345;
173
0
    randseed = randseed * 1103515245 + 12345;
174
0
    randseed = randseed * 1103515245 + 12345;
175
0
    seeded = TRUE;
176
0
  }
177
178
  /* Return an unsigned 32-bit pseudo-random number. */
179
0
  r = randseed = randseed * 1103515245 + 12345;
180
0
  *rnd = (r << 16) | ((r >> 16) & 0xFFFF);
181
0
  return CURLE_OK;
182
0
}
183
184
/*
185
 * Curl_rand() stores 'num' number of random unsigned characters in the buffer
186
 * 'rnd' points to.
187
 *
188
 * If libcurl is built without TLS support or with a TLS backend that lacks a
189
 * proper random API (rustls or mbedTLS), this function will use "weak"
190
 * random.
191
 *
192
 * When built *with* TLS support and a backend that offers strong random, it
193
 * will return error if it cannot provide strong random values.
194
 *
195
 * NOTE: 'data' may be passed in as NULL when coming from external API without
196
 * easy handle!
197
 *
198
 */
199
200
CURLcode Curl_rand(struct Curl_easy *data, unsigned char *rnd, size_t num)
201
0
{
202
0
  CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
203
204
0
  DEBUGASSERT(num > 0);
205
206
0
  while(num) {
207
0
    unsigned int r;
208
0
    size_t left = num < sizeof(unsigned int) ? num : sizeof(unsigned int);
209
210
0
    result = randit(data, &r);
211
0
    if(result)
212
0
      return result;
213
214
0
    while(left) {
215
0
      *rnd++ = (unsigned char)(r & 0xFF);
216
0
      r >>= 8;
217
0
      --num;
218
0
      --left;
219
0
    }
220
0
  }
221
222
0
  return result;
223
0
}
224
225
/*
226
 * Curl_rand_hex() fills the 'rnd' buffer with a given 'num' size with random
227
 * hexadecimal digits PLUS a null-terminating byte. It must be an odd number
228
 * size.
229
 */
230
231
CURLcode Curl_rand_hex(struct Curl_easy *data, unsigned char *rnd,
232
                       size_t num)
233
0
{
234
0
  CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
235
0
  unsigned char buffer[128];
236
0
  DEBUGASSERT(num > 1);
237
238
#ifdef __clang_analyzer__
239
  /* This silences a scan-build warning about accessing this buffer with
240
     uninitialized memory. */
241
  memset(buffer, 0, sizeof(buffer));
242
#endif
243
244
0
  if((num/2 >= sizeof(buffer)) || !(num&1))
245
    /* make sure it fits in the local buffer and that it is an odd number! */
246
0
    return CURLE_BAD_FUNCTION_ARGUMENT;
247
248
0
  num--; /* save one for null-termination */
249
250
0
  result = Curl_rand(data, buffer, num/2);
251
0
  if(result)
252
0
    return result;
253
254
0
  Curl_hexencode(buffer, num/2, rnd, num + 1);
255
0
  return result;
256
0
}
257
258
/*
259
 * Curl_rand_alnum() fills the 'rnd' buffer with a given 'num' size with random
260
 * alphanumerical chars PLUS a null-terminating byte.
261
 */
262
263
static const char alnum[] =
264
  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
265
266
CURLcode Curl_rand_alnum(struct Curl_easy *data, unsigned char *rnd,
267
                         size_t num)
268
0
{
269
0
  CURLcode result = CURLE_OK;
270
0
  const int alnumspace = sizeof(alnum) - 1;
271
0
  unsigned int r;
272
0
  DEBUGASSERT(num > 1);
273
274
0
  num--; /* save one for null-termination */
275
276
0
  while(num) {
277
0
    do {
278
0
      result = randit(data, &r);
279
0
      if(result)
280
0
        return result;
281
0
    } while(r >= (UINT_MAX - UINT_MAX % alnumspace));
282
283
0
    *rnd++ = alnum[r % alnumspace];
284
0
    num--;
285
0
  }
286
0
  *rnd = 0;
287
288
0
  return result;
289
0
}