Home | History | Annotate | Line # | Download | only in sysrandom 
      1 
      2 #include <assert.h>
      3 #include <errno.h>
      4 #include <fcntl.h>
      5 #include <limits.h>
      6 #include <stdint.h>
      7 #include <string.h>
      8 #ifndef _WIN32
      9 # include <unistd.h>
     10 #endif
     11 
     12 #include <stdlib.h>
     13 #include <sys/types.h>
     14 #ifndef _WIN32
     15 # include <sys/stat.h>
     16 # include <sys/time.h>
     17 #endif
     18 #ifdef __linux__
     19 # ifdef __dietlibc__
     20 #  define _LINUX_SOURCE
     21 # else
     22 #  include <sys/syscall.h>
     23 # endif
     24 # include <poll.h>
     25 #endif
     26 
     27 #include "core.h"
     28 #include "private/common.h"
     29 #include "randombytes.h"
     30 #include "randombytes_sysrandom.h"
     31 #include "utils.h"
     32 
     33 #ifdef _WIN32
     34 /* `RtlGenRandom` is used over `CryptGenRandom` on Microsoft Windows based systems:
     35  *  - `CryptGenRandom` requires pulling in `CryptoAPI` which causes unnecessary
     36  *     memory overhead if this API is not being used for other purposes
     37  *  - `RtlGenRandom` is thus called directly instead. A detailed explanation
     38  *     can be found here: https://blogs.msdn.microsoft.com/michael_howard/2005/01/14/cryptographically-secure-random-number-on-windows-without-using-cryptoapi/
     39  *
     40  * In spite of the disclaimer on the `RtlGenRandom` documentation page that was
     41  * written back in the Windows XP days, this function is here to stay. The CRT
     42  * function `rand_s()` directly depends on it, so touching it would break many
     43  * applications released since Windows XP.
     44  *
     45  * Also note that Rust, Firefox and BoringSSL (thus, Google Chrome and everything
     46  * based on Chromium) also depend on it, and that libsodium allows the RNG to be
     47  * replaced without patching nor recompiling the library.
     48  */
     49 # include <windows.h>
     50 # define RtlGenRandom SystemFunction036
     51 # if defined(__cplusplus)
     52 extern "C"
     53 # endif
     54 BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
     55 # pragma comment(lib, "advapi32.lib")
     56 #endif
     57 
     58 #if defined(__OpenBSD__) || defined(__CloudABI__)
     59 # define HAVE_SAFE_ARC4RANDOM 1
     60 #endif
     61 
     62 #ifndef SSIZE_MAX
     63 # define SSIZE_MAX (SIZE_MAX / 2 - 1)
     64 #endif
     65 
     66 #ifdef HAVE_SAFE_ARC4RANDOM
     67 
     68 static uint32_t
     69 randombytes_sysrandom(void)
     70 {
     71     return arc4random();
     72 }
     73 
     74 static void
     75 randombytes_sysrandom_stir(void)
     76 {
     77 }
     78 
     79 static void
     80 randombytes_sysrandom_buf(void * const buf, const size_t size)
     81 {
     82     arc4random_buf(buf, size);
     83 }
     84 
     85 static int
     86 randombytes_sysrandom_close(void)
     87 {
     88     return 0;
     89 }
     90 
     91 #else /* __OpenBSD__ */
     92 
     93 typedef struct SysRandom_ {
     94     int random_data_source_fd;
     95     int initialized;
     96     int getrandom_available;
     97 } SysRandom;
     98 
     99 static SysRandom stream = {
    100     SODIUM_C99(.random_data_source_fd =) -1,
    101     SODIUM_C99(.initialized =) 0,
    102     SODIUM_C99(.getrandom_available =) 0
    103 };
    104 
    105 #ifndef _WIN32
    106 static ssize_t
    107 safe_read(const int fd, void * const buf_, size_t size)
    108 {
    109     unsigned char *buf = (unsigned char *) buf_;
    110     ssize_t        readnb;
    111 
    112     assert(size > (size_t) 0U);
    113     assert(size <= SSIZE_MAX);
    114     do {
    115         while ((readnb = read(fd, buf, size)) < (ssize_t) 0 &&
    116                (errno == EINTR || errno == EAGAIN)); /* LCOV_EXCL_LINE */
    117         if (readnb < (ssize_t) 0) {
    118             return readnb; /* LCOV_EXCL_LINE */
    119         }
    120         if (readnb == (ssize_t) 0) {
    121             break; /* LCOV_EXCL_LINE */
    122         }
    123         size -= (size_t) readnb;
    124         buf += readnb;
    125     } while (size > (ssize_t) 0);
    126 
    127     return (ssize_t) (buf - (unsigned char *) buf_);
    128 }
    129 #endif
    130 
    131 #ifndef _WIN32
    132 # if defined(__linux__) && !defined(USE_BLOCKING_RANDOM) && !defined(NO_BLOCKING_RANDOM_POLL)
    133 static int
    134 randombytes_block_on_dev_random(void)
    135 {
    136     struct pollfd pfd;
    137     int           fd;
    138     int           pret;
    139 
    140     fd = open("/dev/random", O_RDONLY);
    141     if (fd == -1) {
    142         return 0;
    143     }
    144     pfd.fd = fd;
    145     pfd.events = POLLIN;
    146     pfd.revents = 0;
    147     do {
    148         pret = poll(&pfd, 1, -1);
    149     } while (pret < 0 && (errno == EINTR || errno == EAGAIN));
    150     if (pret != 1) {
    151         (void) close(fd);
    152         errno = EIO;
    153         return -1;
    154     }
    155     return close(fd);
    156 }
    157 # endif
    158 
    159 static int
    160 randombytes_sysrandom_random_dev_open(void)
    161 {
    162 /* LCOV_EXCL_START */
    163     struct stat        st;
    164     static const char *devices[] = {
    165 # ifndef USE_BLOCKING_RANDOM
    166         "/dev/urandom",
    167 # endif
    168         "/dev/random", NULL
    169     };
    170     const char       **device = devices;
    171     int                fd;
    172 
    173 # if defined(__linux__) && !defined(USE_BLOCKING_RANDOM) && !defined(NO_BLOCKING_RANDOM_POLL)
    174     if (randombytes_block_on_dev_random() != 0) {
    175         return -1;
    176     }
    177 # endif
    178     do {
    179         fd = open(*device, O_RDONLY);
    180         if (fd != -1) {
    181             if (fstat(fd, &st) == 0 &&
    182 # ifdef __COMPCERT__
    183                 1
    184 # elif defined(S_ISNAM)
    185                 (S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
    186 # else
    187                 S_ISCHR(st.st_mode)
    188 # endif
    189                ) {
    190 # if defined(F_SETFD) && defined(FD_CLOEXEC)
    191                 (void) fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
    192 # endif
    193                 return fd;
    194             }
    195             (void) close(fd);
    196         } else if (errno == EINTR) {
    197             continue;
    198         }
    199         device++;
    200     } while (*device != NULL);
    201 
    202     errno = EIO;
    203     return -1;
    204 /* LCOV_EXCL_STOP */
    205 }
    206 
    207 # if defined(__dietlibc__) || (defined(SYS_getrandom) && defined(__NR_getrandom))
    208 static int
    209 _randombytes_linux_getrandom(void * const buf, const size_t size)
    210 {
    211     int readnb;
    212 
    213     assert(size <= 256U);
    214     do {
    215 #  ifdef __dietlibc__
    216         readnb = getrandom(buf, size, 0);
    217 #  else
    218         readnb = syscall(SYS_getrandom, buf, (int) size, 0);
    219 #  endif
    220     } while (readnb < 0 && (errno == EINTR || errno == EAGAIN));
    221 
    222     return (readnb == (int) size) - 1;
    223 }
    224 
    225 static int
    226 randombytes_linux_getrandom(void * const buf_, size_t size)
    227 {
    228     unsigned char *buf = (unsigned char *) buf_;
    229     size_t         chunk_size = 256U;
    230 
    231     do {
    232         if (size < chunk_size) {
    233             chunk_size = size;
    234             assert(chunk_size > (size_t) 0U);
    235         }
    236         if (_randombytes_linux_getrandom(buf, chunk_size) != 0) {
    237             return -1;
    238         }
    239         size -= chunk_size;
    240         buf += chunk_size;
    241     } while (size > (size_t) 0U);
    242 
    243     return 0;
    244 }
    245 # endif
    246 
    247 static void
    248 randombytes_sysrandom_init(void)
    249 {
    250     const int     errno_save = errno;
    251 
    252 # if defined(SYS_getrandom) && defined(__NR_getrandom)
    253     {
    254         unsigned char fodder[16];
    255 
    256         if (randombytes_linux_getrandom(fodder, sizeof fodder) == 0) {
    257             stream.getrandom_available = 1;
    258             errno = errno_save;
    259             return;
    260         }
    261         stream.getrandom_available = 0;
    262     }
    263 # endif
    264 
    265     if ((stream.random_data_source_fd =
    266          randombytes_sysrandom_random_dev_open()) == -1) {
    267         sodium_misuse(); /* LCOV_EXCL_LINE */
    268     }
    269     errno = errno_save;
    270 }
    271 
    272 #else /* _WIN32 */
    273 
    274 static void
    275 randombytes_sysrandom_init(void)
    276 {
    277 }
    278 #endif
    279 
    280 static void
    281 randombytes_sysrandom_stir(void)
    282 {
    283     if (stream.initialized == 0) {
    284         randombytes_sysrandom_init();
    285         stream.initialized = 1;
    286     }
    287 }
    288 
    289 static void
    290 randombytes_sysrandom_stir_if_needed(void)
    291 {
    292     if (stream.initialized == 0) {
    293         randombytes_sysrandom_stir();
    294     }
    295 }
    296 
    297 static int
    298 randombytes_sysrandom_close(void)
    299 {
    300     int ret = -1;
    301 
    302 #ifndef _WIN32
    303     if (stream.random_data_source_fd != -1 &&
    304         close(stream.random_data_source_fd) == 0) {
    305         stream.random_data_source_fd = -1;
    306         stream.initialized = 0;
    307         ret = 0;
    308     }
    309 # if defined(SYS_getrandom) && defined(__NR_getrandom)
    310     if (stream.getrandom_available != 0) {
    311         ret = 0;
    312     }
    313 # endif
    314 #else /* _WIN32 */
    315     if (stream.initialized != 0) {
    316         stream.initialized = 0;
    317         ret = 0;
    318     }
    319 #endif
    320     return ret;
    321 }
    322 
    323 static void
    324 randombytes_sysrandom_buf(void * const buf, const size_t size)
    325 {
    326     randombytes_sysrandom_stir_if_needed();
    327 #if defined(ULONG_LONG_MAX) && defined(SIZE_MAX)
    328 # if SIZE_MAX > ULONG_LONG_MAX
    329     /* coverity[result_independent_of_operands] */
    330     assert(size <= ULONG_LONG_MAX);
    331 # endif
    332 #endif
    333 #ifndef _WIN32
    334 # if defined(SYS_getrandom) && defined(__NR_getrandom)
    335     if (stream.getrandom_available != 0) {
    336         if (randombytes_linux_getrandom(buf, size) != 0) {
    337             sodium_misuse(); /* LCOV_EXCL_LINE */
    338         }
    339         return;
    340     }
    341 # endif
    342     if (stream.random_data_source_fd == -1 ||
    343         safe_read(stream.random_data_source_fd, buf, size) != (ssize_t) size) {
    344         sodium_misuse(); /* LCOV_EXCL_LINE */
    345     }
    346 #else
    347     COMPILER_ASSERT(randombytes_BYTES_MAX <= 0xffffffffUL);
    348     if (size > (size_t) 0xffffffffUL) {
    349         sodium_misuse(); /* LCOV_EXCL_LINE */
    350     }
    351     if (! RtlGenRandom((PVOID) buf, (ULONG) size)) {
    352         sodium_misuse(); /* LCOV_EXCL_LINE */
    353     }
    354 #endif
    355 }
    356 
    357 static uint32_t
    358 randombytes_sysrandom(void)
    359 {
    360     uint32_t r;
    361 
    362     randombytes_sysrandom_buf(&r, sizeof r);
    363 
    364     return r;
    365 }
    366 
    367 #endif /* __OpenBSD__ */
    368 
    369 static const char *
    370 randombytes_sysrandom_implementation_name(void)
    371 {
    372     return "sysrandom";
    373 }
    374 
    375 struct randombytes_implementation randombytes_sysrandom_implementation = {
    376     SODIUM_C99(.implementation_name =) randombytes_sysrandom_implementation_name,
    377     SODIUM_C99(.random =) randombytes_sysrandom,
    378     SODIUM_C99(.stir =) randombytes_sysrandom_stir,
    379     SODIUM_C99(.uniform =) NULL,
    380     SODIUM_C99(.buf =) randombytes_sysrandom_buf,
    381     SODIUM_C99(.close =) randombytes_sysrandom_close
    382 };
    383