e45e018e4a633ae3891affc86520f4c9e733c1d8
[openssl.git] / crypto / rand / rand_unix.c
1 /*
2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #ifndef _GNU_SOURCE
11 # define _GNU_SOURCE
12 #endif
13 #include "e_os.h"
14 #include <stdio.h>
15 #include "internal/cryptlib.h"
16 #include <openssl/rand.h>
17 #include "rand_lcl.h"
18 #include "internal/rand_int.h"
19 #include <stdio.h>
20 #include "internal/dso.h"
21 #if defined(__linux)
22 # include <asm/unistd.h>
23 #endif
24 #if defined(__FreeBSD__) && !defined(OPENSSL_SYS_UEFI)
25 # include <sys/types.h>
26 # include <sys/sysctl.h>
27 # include <sys/param.h>
28 #endif
29 #if defined(__OpenBSD__) || defined(__NetBSD__)
30 # include <sys/param.h>
31 #endif
32
33 #if (defined(OPENSSL_SYS_UNIX) && !defined(OPENSSL_SYS_VXWORKS)) \
34      || defined(__DJGPP__)
35 # include <sys/types.h>
36 # include <sys/stat.h>
37 # include <fcntl.h>
38 # include <unistd.h>
39 # include <sys/time.h>
40
41 static uint64_t get_time_stamp(void);
42 static uint64_t get_timer_bits(void);
43
44 /* Macro to convert two thirty two bit values into a sixty four bit one */
45 # define TWO32TO64(a, b) ((((uint64_t)(a)) << 32) + (b))
46
47 /*
48  * Check for the existence and support of POSIX timers.  The standard
49  * says that the _POSIX_TIMERS macro will have a positive value if they
50  * are available.
51  *
52  * However, we want an additional constraint: that the timer support does
53  * not require an extra library dependency.  Early versions of glibc
54  * require -lrt to be specified on the link line to access the timers,
55  * so this needs to be checked for.
56  *
57  * It is worse because some libraries define __GLIBC__ but don't
58  * support the version testing macro (e.g. uClibc).  This means
59  * an extra check is needed.
60  *
61  * The final condition is:
62  *      "have posix timers and either not glibc or glibc without -lrt"
63  *
64  * The nested #if sequences are required to avoid using a parameterised
65  * macro that might be undefined.
66  */
67 # undef OSSL_POSIX_TIMER_OKAY
68 # if defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0
69 #  if defined(__GLIBC__)
70 #   if defined(__GLIBC_PREREQ)
71 #    if __GLIBC_PREREQ(2, 17)
72 #     define OSSL_POSIX_TIMER_OKAY
73 #    endif
74 #   endif
75 #  else
76 #   define OSSL_POSIX_TIMER_OKAY
77 #  endif
78 # endif
79 #endif /* defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) */
80
81 #if defined(OPENSSL_RAND_SEED_NONE)
82 /* none means none. this simplifies the following logic */
83 # undef OPENSSL_RAND_SEED_OS
84 # undef OPENSSL_RAND_SEED_GETRANDOM
85 # undef OPENSSL_RAND_SEED_LIBRANDOM
86 # undef OPENSSL_RAND_SEED_DEVRANDOM
87 # undef OPENSSL_RAND_SEED_RDTSC
88 # undef OPENSSL_RAND_SEED_RDCPU
89 # undef OPENSSL_RAND_SEED_EGD
90 #endif
91
92 #if defined(OPENSSL_SYS_UEFI) && !defined(OPENSSL_RAND_SEED_NONE)
93 # error "UEFI only supports seeding NONE"
94 #endif
95
96 #if !(defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) \
97     || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VXWORKS) \
98     || defined(OPENSSL_SYS_UEFI))
99
100 # if defined(OPENSSL_SYS_VOS)
101
102 #  ifndef OPENSSL_RAND_SEED_OS
103 #   error "Unsupported seeding method configured; must be os"
104 #  endif
105
106 #  if defined(OPENSSL_SYS_VOS_HPPA) && defined(OPENSSL_SYS_VOS_IA32)
107 #   error "Unsupported HP-PA and IA32 at the same time."
108 #  endif
109 #  if !defined(OPENSSL_SYS_VOS_HPPA) && !defined(OPENSSL_SYS_VOS_IA32)
110 #   error "Must have one of HP-PA or IA32"
111 #  endif
112
113 /*
114  * The following algorithm repeatedly samples the real-time clock (RTC) to
115  * generate a sequence of unpredictable data.  The algorithm relies upon the
116  * uneven execution speed of the code (due to factors such as cache misses,
117  * interrupts, bus activity, and scheduling) and upon the rather large
118  * relative difference between the speed of the clock and the rate at which
119  * it can be read.  If it is ported to an environment where execution speed
120  * is more constant or where the RTC ticks at a much slower rate, or the
121  * clock can be read with fewer instructions, it is likely that the results
122  * would be far more predictable.  This should only be used for legacy
123  * platforms.
124  *
125  * As a precaution, we assume only 2 bits of entropy per byte.
126  */
127 size_t rand_pool_acquire_entropy(RAND_POOL *pool)
128 {
129     short int code;
130     int i, k;
131     size_t bytes_needed;
132     struct timespec ts;
133     unsigned char v;
134 #  ifdef OPENSSL_SYS_VOS_HPPA
135     long duration;
136     extern void s$sleep(long *_duration, short int *_code);
137 #  else
138     long long duration;
139     extern void s$sleep2(long long *_duration, short int *_code);
140 #  endif
141
142     bytes_needed = rand_pool_bytes_needed(pool, 4 /*entropy_factor*/);
143
144     for (i = 0; i < bytes_needed; i++) {
145         /*
146          * burn some cpu; hope for interrupts, cache collisions, bus
147          * interference, etc.
148          */
149         for (k = 0; k < 99; k++)
150             ts.tv_nsec = random();
151
152 #  ifdef OPENSSL_SYS_VOS_HPPA
153         /* sleep for 1/1024 of a second (976 us).  */
154         duration = 1;
155         s$sleep(&duration, &code);
156 #  else
157         /* sleep for 1/65536 of a second (15 us).  */
158         duration = 1;
159         s$sleep2(&duration, &code);
160 #  endif
161
162         /* Get wall clock time, take 8 bits. */
163         clock_gettime(CLOCK_REALTIME, &ts);
164         v = (unsigned char)(ts.tv_nsec & 0xFF);
165         rand_pool_add(pool, arg, &v, sizeof(v) , 2);
166     }
167     return rand_pool_entropy_available(pool);
168 }
169
170 void rand_pool_cleanup(void)
171 {
172 }
173
174 void rand_pool_keep_random_devices_open(int keep)
175 {
176 }
177
178 # else
179
180 #  if defined(OPENSSL_RAND_SEED_EGD) && \
181         (defined(OPENSSL_NO_EGD) || !defined(DEVRANDOM_EGD))
182 #   error "Seeding uses EGD but EGD is turned off or no device given"
183 #  endif
184
185 #  if defined(OPENSSL_RAND_SEED_DEVRANDOM) && !defined(DEVRANDOM)
186 #   error "Seeding uses urandom but DEVRANDOM is not configured"
187 #  endif
188
189 #  if defined(OPENSSL_RAND_SEED_OS)
190 #   if !defined(DEVRANDOM)
191 #    error "OS seeding requires DEVRANDOM to be configured"
192 #   endif
193 #   define OPENSSL_RAND_SEED_GETRANDOM
194 #   define OPENSSL_RAND_SEED_DEVRANDOM
195 #  endif
196
197 #  if defined(OPENSSL_RAND_SEED_LIBRANDOM)
198 #   error "librandom not (yet) supported"
199 #  endif
200
201 #  if (defined(__FreeBSD__) || defined(__NetBSD__)) && defined(KERN_ARND)
202 /*
203  * sysctl_random(): Use sysctl() to read a random number from the kernel
204  * Returns the number of bytes returned in buf on success, -1 on failure.
205  */
206 static ssize_t sysctl_random(char *buf, size_t buflen)
207 {
208     int mib[2];
209     size_t done = 0;
210     size_t len;
211
212     /*
213      * Note: sign conversion between size_t and ssize_t is safe even
214      * without a range check, see comment in syscall_random()
215      */
216
217     /*
218      * On FreeBSD old implementations returned longs, newer versions support
219      * variable sizes up to 256 byte. The code below would not work properly
220      * when the sysctl returns long and we want to request something not a
221      * multiple of longs, which should never be the case.
222      */
223     if (!ossl_assert(buflen % sizeof(long) == 0)) {
224         errno = EINVAL;
225         return -1;
226     }
227
228     /*
229      * On NetBSD before 4.0 KERN_ARND was an alias for KERN_URND, and only
230      * filled in an int, leaving the rest uninitialized. Since NetBSD 4.0
231      * it returns a variable number of bytes with the current version supporting
232      * up to 256 bytes.
233      * Just return an error on older NetBSD versions.
234      */
235 #if   defined(__NetBSD__) && __NetBSD_Version__ < 400000000
236     errno = ENOSYS;
237     return -1;
238 #endif
239
240     mib[0] = CTL_KERN;
241     mib[1] = KERN_ARND;
242
243     do {
244         len = buflen;
245         if (sysctl(mib, 2, buf, &len, NULL, 0) == -1)
246             return done > 0 ? done : -1;
247         done += len;
248         buf += len;
249         buflen -= len;
250     } while (buflen > 0);
251
252     return done;
253 }
254 #  endif
255
256 #  if defined(OPENSSL_RAND_SEED_GETRANDOM)
257 /*
258  * syscall_random(): Try to get random data using a system call
259  * returns the number of bytes returned in buf, or < 0 on error.
260  */
261 static ssize_t syscall_random(void *buf, size_t buflen)
262 {
263     /*
264      * Note: 'buflen' equals the size of the buffer which is used by the
265      * get_entropy() callback of the RAND_DRBG. It is roughly bounded by
266      *
267      *   2 * RAND_POOL_FACTOR * (RAND_DRBG_STRENGTH / 8) = 2^14
268      *
269      * which is way below the OSSL_SSIZE_MAX limit. Therefore sign conversion
270      * between size_t and ssize_t is safe even without a range check.
271      */
272
273     /*
274      * Do runtime detection to find getentropy().
275      *
276      * Known OSs that should support this:
277      * - Darwin since 16 (OSX 10.12, IOS 10.0).
278      * - Solaris since 11.3
279      * - OpenBSD since 5.6
280      * - Linux since 3.17 with glibc 2.25
281      * - FreeBSD since 12.0 (1200061)
282      */
283 #  if defined(__GNUC__) && __GNUC__>=2 && defined(__ELF__) && !defined(__hpux)
284     extern int getentropy(void *buffer, size_t length) __attribute__((weak));
285
286     if (getentropy != NULL)
287         return getentropy(buf, buflen) == 0 ? (ssize_t)buflen : -1;
288 #  elif !defined(FIPS_MODE)
289     union {
290         void *p;
291         int (*f)(void *buffer, size_t length);
292     } p_getentropy;
293
294     /*
295      * We could cache the result of the lookup, but we normally don't
296      * call this function often.
297      */
298     ERR_set_mark();
299     p_getentropy.p = DSO_global_lookup("getentropy");
300     ERR_pop_to_mark();
301     if (p_getentropy.p != NULL)
302         return p_getentropy.f(buf, buflen) == 0 ? (ssize_t)buflen : -1;
303 #  endif
304
305     /* Linux supports this since version 3.17 */
306 #  if defined(__linux) && defined(__NR_getrandom)
307     return syscall(__NR_getrandom, buf, buflen, 0);
308 #  elif (defined(__FreeBSD__) || defined(__NetBSD__)) && defined(KERN_ARND)
309     return sysctl_random(buf, buflen);
310 #  else
311     errno = ENOSYS;
312     return -1;
313 #  endif
314 }
315 #  endif    /* defined(OPENSSL_RAND_SEED_GETRANDOM) */
316
317 #  if defined(OPENSSL_RAND_SEED_DEVRANDOM)
318 static const char *random_device_paths[] = { DEVRANDOM };
319 static struct random_device {
320     int fd;
321     dev_t dev;
322     ino_t ino;
323     mode_t mode;
324     dev_t rdev;
325 } random_devices[OSSL_NELEM(random_device_paths)];
326 static int keep_random_devices_open = 1;
327
328 /*
329  * Verify that the file descriptor associated with the random source is
330  * still valid. The rationale for doing this is the fact that it is not
331  * uncommon for daemons to close all open file handles when daemonizing.
332  * So the handle might have been closed or even reused for opening
333  * another file.
334  */
335 static int check_random_device(struct random_device * rd)
336 {
337     struct stat st;
338
339     return rd->fd != -1
340            && fstat(rd->fd, &st) != -1
341            && rd->dev == st.st_dev
342            && rd->ino == st.st_ino
343            && ((rd->mode ^ st.st_mode) & ~(S_IRWXU | S_IRWXG | S_IRWXO)) == 0
344            && rd->rdev == st.st_rdev;
345 }
346
347 /*
348  * Open a random device if required and return its file descriptor or -1 on error
349  */
350 static int get_random_device(size_t n)
351 {
352     struct stat st;
353     struct random_device * rd = &random_devices[n];
354
355     /* reuse existing file descriptor if it is (still) valid */
356     if (check_random_device(rd))
357         return rd->fd;
358
359     /* open the random device ... */
360     if ((rd->fd = open(random_device_paths[n], O_RDONLY)) == -1)
361         return rd->fd;
362
363     /* ... and cache its relevant stat(2) data */
364     if (fstat(rd->fd, &st) != -1) {
365         rd->dev = st.st_dev;
366         rd->ino = st.st_ino;
367         rd->mode = st.st_mode;
368         rd->rdev = st.st_rdev;
369     } else {
370         close(rd->fd);
371         rd->fd = -1;
372     }
373
374     return rd->fd;
375 }
376
377 /*
378  * Close a random device making sure it is a random device
379  */
380 static void close_random_device(size_t n)
381 {
382     struct random_device * rd = &random_devices[n];
383
384     if (check_random_device(rd))
385         close(rd->fd);
386     rd->fd = -1;
387 }
388
389 int rand_pool_init(void)
390 {
391     size_t i;
392
393     for (i = 0; i < OSSL_NELEM(random_devices); i++)
394         random_devices[i].fd = -1;
395
396     return 1;
397 }
398
399 void rand_pool_cleanup(void)
400 {
401     size_t i;
402
403     for (i = 0; i < OSSL_NELEM(random_devices); i++)
404         close_random_device(i);
405 }
406
407 void rand_pool_keep_random_devices_open(int keep)
408 {
409     if (!keep)
410         rand_pool_cleanup();
411
412     keep_random_devices_open = keep;
413 }
414
415 #  else     /* !defined(OPENSSL_RAND_SEED_DEVRANDOM) */
416
417 int rand_pool_init(void)
418 {
419     return 1;
420 }
421
422 void rand_pool_cleanup(void)
423 {
424 }
425
426 void rand_pool_keep_random_devices_open(int keep)
427 {
428 }
429
430 #  endif    /* defined(OPENSSL_RAND_SEED_DEVRANDOM) */
431
432 /*
433  * Try the various seeding methods in turn, exit when successful.
434  *
435  * TODO(DRBG): If more than one entropy source is available, is it
436  * preferable to stop as soon as enough entropy has been collected
437  * (as favored by @rsalz) or should one rather be defensive and add
438  * more entropy than requested and/or from different sources?
439  *
440  * Currently, the user can select multiple entropy sources in the
441  * configure step, yet in practice only the first available source
442  * will be used. A more flexible solution has been requested, but
443  * currently it is not clear how this can be achieved without
444  * overengineering the problem. There are many parameters which
445  * could be taken into account when selecting the order and amount
446  * of input from the different entropy sources (trust, quality,
447  * possibility of blocking).
448  */
449 size_t rand_pool_acquire_entropy(RAND_POOL *pool)
450 {
451 #  if defined(OPENSSL_RAND_SEED_NONE)
452     return rand_pool_entropy_available(pool);
453 #  else
454     size_t bytes_needed;
455     size_t entropy_available = 0;
456     unsigned char *buffer;
457
458 #   if defined(OPENSSL_RAND_SEED_GETRANDOM)
459     {
460         ssize_t bytes;
461         /* Maximum allowed number of consecutive unsuccessful attempts */
462         int attempts = 3;
463
464         bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
465         while (bytes_needed != 0 && attempts-- > 0) {
466             buffer = rand_pool_add_begin(pool, bytes_needed);
467             bytes = syscall_random(buffer, bytes_needed);
468             if (bytes > 0) {
469                 rand_pool_add_end(pool, bytes, 8 * bytes);
470                 bytes_needed -= bytes;
471                 attempts = 3; /* reset counter after successful attempt */
472             } else if (bytes < 0 && errno != EINTR) {
473                 break;
474             }
475         }
476     }
477     entropy_available = rand_pool_entropy_available(pool);
478     if (entropy_available > 0)
479         return entropy_available;
480 #   endif
481
482 #   if defined(OPENSSL_RAND_SEED_LIBRANDOM)
483     {
484         /* Not yet implemented. */
485     }
486 #   endif
487
488 #   if defined(OPENSSL_RAND_SEED_DEVRANDOM)
489     bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
490     {
491         size_t i;
492
493         for (i = 0; bytes_needed > 0 && i < OSSL_NELEM(random_device_paths); i++) {
494             ssize_t bytes = 0;
495             /* Maximum allowed number of consecutive unsuccessful attempts */
496             int attempts = 3;
497             const int fd = get_random_device(i);
498
499             if (fd == -1)
500                 continue;
501
502             while (bytes_needed != 0 && attempts-- > 0) {
503                 buffer = rand_pool_add_begin(pool, bytes_needed);
504                 bytes = read(fd, buffer, bytes_needed);
505
506                 if (bytes > 0) {
507                     rand_pool_add_end(pool, bytes, 8 * bytes);
508                     bytes_needed -= bytes;
509                     attempts = 3; /* reset counter after successful attempt */
510                 } else if (bytes < 0 && errno != EINTR) {
511                     break;
512                 }
513             }
514             if (bytes < 0 || !keep_random_devices_open)
515                 close_random_device(i);
516
517             bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
518         }
519         entropy_available = rand_pool_entropy_available(pool);
520         if (entropy_available > 0)
521             return entropy_available;
522     }
523 #   endif
524
525 #   if defined(OPENSSL_RAND_SEED_RDTSC)
526     entropy_available = rand_acquire_entropy_from_tsc(pool);
527     if (entropy_available > 0)
528         return entropy_available;
529 #   endif
530
531 #   if defined(OPENSSL_RAND_SEED_RDCPU)
532     entropy_available = rand_acquire_entropy_from_cpu(pool);
533     if (entropy_available > 0)
534         return entropy_available;
535 #   endif
536
537 #   if defined(OPENSSL_RAND_SEED_EGD)
538     bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
539     if (bytes_needed > 0) {
540         static const char *paths[] = { DEVRANDOM_EGD, NULL };
541         int i;
542
543         for (i = 0; paths[i] != NULL; i++) {
544             buffer = rand_pool_add_begin(pool, bytes_needed);
545             if (buffer != NULL) {
546                 size_t bytes = 0;
547                 int num = RAND_query_egd_bytes(paths[i],
548                                                buffer, (int)bytes_needed);
549                 if (num == (int)bytes_needed)
550                     bytes = bytes_needed;
551
552                 rand_pool_add_end(pool, bytes, 8 * bytes);
553                 entropy_available = rand_pool_entropy_available(pool);
554             }
555             if (entropy_available > 0)
556                 return entropy_available;
557         }
558     }
559 #   endif
560
561     return rand_pool_entropy_available(pool);
562 #  endif
563 }
564 # endif
565 #endif
566
567 #if (defined(OPENSSL_SYS_UNIX) && !defined(OPENSSL_SYS_VXWORKS)) \
568      || defined(__DJGPP__)
569 int rand_pool_add_nonce_data(RAND_POOL *pool)
570 {
571     struct {
572         pid_t pid;
573         CRYPTO_THREAD_ID tid;
574         uint64_t time;
575     } data;
576
577     /* Erase the entire structure including any padding */
578     memset(&data, 0, sizeof(data));
579
580     /*
581      * Add process id, thread id, and a high resolution timestamp to
582      * ensure that the nonce is unique with high probability for
583      * different process instances.
584      */
585     data.pid = getpid();
586     data.tid = CRYPTO_THREAD_get_current_id();
587     data.time = get_time_stamp();
588
589     return rand_pool_add(pool, (unsigned char *)&data, sizeof(data), 0);
590 }
591
592 int rand_pool_add_additional_data(RAND_POOL *pool)
593 {
594     struct {
595         CRYPTO_THREAD_ID tid;
596         uint64_t time;
597     } data;
598
599     /* Erase the entire structure including any padding */
600     memset(&data, 0, sizeof(data));
601
602     /*
603      * Add some noise from the thread id and a high resolution timer.
604      * The thread id adds a little randomness if the drbg is accessed
605      * concurrently (which is the case for the <master> drbg).
606      */
607     data.tid = CRYPTO_THREAD_get_current_id();
608     data.time = get_timer_bits();
609
610     return rand_pool_add(pool, (unsigned char *)&data, sizeof(data), 0);
611 }
612
613
614 /*
615  * Get the current time with the highest possible resolution
616  *
617  * The time stamp is added to the nonce, so it is optimized for not repeating.
618  * The current time is ideal for this purpose, provided the computer's clock
619  * is synchronized.
620  */
621 static uint64_t get_time_stamp(void)
622 {
623 # if defined(OSSL_POSIX_TIMER_OKAY)
624     {
625         struct timespec ts;
626
627         if (clock_gettime(CLOCK_REALTIME, &ts) == 0)
628             return TWO32TO64(ts.tv_sec, ts.tv_nsec);
629     }
630 # endif
631 # if defined(__unix__) \
632      || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L)
633     {
634         struct timeval tv;
635
636         if (gettimeofday(&tv, NULL) == 0)
637             return TWO32TO64(tv.tv_sec, tv.tv_usec);
638     }
639 # endif
640     return time(NULL);
641 }
642
643 /*
644  * Get an arbitrary timer value of the highest possible resolution
645  *
646  * The timer value is added as random noise to the additional data,
647  * which is not considered a trusted entropy sourec, so any result
648  * is acceptable.
649  */
650 static uint64_t get_timer_bits(void)
651 {
652     uint64_t res = OPENSSL_rdtsc();
653
654     if (res != 0)
655         return res;
656
657 # if defined(__sun) || defined(__hpux)
658     return gethrtime();
659 # elif defined(_AIX)
660     {
661         timebasestruct_t t;
662
663         read_wall_time(&t, TIMEBASE_SZ);
664         return TWO32TO64(t.tb_high, t.tb_low);
665     }
666 # elif defined(OSSL_POSIX_TIMER_OKAY)
667     {
668         struct timespec ts;
669
670 #  ifdef CLOCK_BOOTTIME
671 #   define CLOCK_TYPE CLOCK_BOOTTIME
672 #  elif defined(_POSIX_MONOTONIC_CLOCK)
673 #   define CLOCK_TYPE CLOCK_MONOTONIC
674 #  else
675 #   define CLOCK_TYPE CLOCK_REALTIME
676 #  endif
677
678         if (clock_gettime(CLOCK_TYPE, &ts) == 0)
679             return TWO32TO64(ts.tv_sec, ts.tv_nsec);
680     }
681 # endif
682 # if defined(__unix__) \
683      || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L)
684     {
685         struct timeval tv;
686
687         if (gettimeofday(&tv, NULL) == 0)
688             return TWO32TO64(tv.tv_sec, tv.tv_usec);
689     }
690 # endif
691     return time(NULL);
692 }
693 #endif /* defined(OPENSSL_SYS_UNIX) || defined(__DJGPP__) */