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