crypto/rand/rand_unix.c

   1 /* crypto/rand/rand_unix.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111 #include <stdio.h>
 112
 113 #define USE_SOCKETS
 114 #include "e_os.h"
 115 #include "cryptlib.h"
 116 #include <openssl/rand.h>
 117 #include "rand_lcl.h"
 118
 119 #if !(defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_NETWARE))
 120
 121 #include <sys/types.h>
 122 #include <sys/time.h>
 123 #include <sys/times.h>
 124 #include <sys/stat.h>
 125 #include <fcntl.h>
 126 #include <unistd.h>
 127 #include <time.h>
 128 #if defined(OPENSSL_SYS_LINUX) /* should actually be available virtually everywhere */
 129 # include <poll.h>
 130 #endif
 131 #include <limits.h>
 132 #ifndef FD_SETSIZE
 133 # define FD_SETSIZE (8*sizeof(fd_set))
 134 #endif
 135
 136 #if defined(OPENSSL_SYS_VOS)
 137
 138 /* The following algorithm repeatedly samples the real-time clock
 139    (RTC) to generate a sequence of unpredictable data.  The algorithm
 140    relies upon the uneven execution speed of the code (due to factors
 141    such as cache misses, interrupts, bus activity, and scheduling) and
 142    upon the rather large relative difference between the speed of the
 143    clock and the rate at which it can be read.
 144
 145    If this code is ported to an environment where execution speed is
 146    more constant or where the RTC ticks at a much slower rate, or the
 147    clock can be read with fewer instructions, it is likely that the
 148    results would be far more predictable.
 149
 150    As a precaution, we generate 4 times the minimum required amount of
 151    seed data.  */
 152
 153 int RAND_poll(void)
 154 {
 155         short int code;
 156         gid_t curr_gid;
 157         pid_t curr_pid;
 158         uid_t curr_uid;
 159         int i, k;
 160         struct timespec ts;
 161         unsigned char v;
 162
 163 #ifdef OPENSSL_SYS_VOS_HPPA
 164         long duration;
 165         extern void s$sleep (long *_duration, short int *_code);
 166 #else
 167 #ifdef OPENSSL_SYS_VOS_IA32
 168         long long duration;
 169         extern void s$sleep2 (long long *_duration, short int *_code);
 170 #else
 171 #error "Unsupported Platform."
 172 #endif /* OPENSSL_SYS_VOS_IA32 */
 173 #endif /* OPENSSL_SYS_VOS_HPPA */
 174
 175         /* Seed with the gid, pid, and uid, to ensure *some*
 176            variation between different processes.  */
 177
 178         curr_gid = getgid();
 179         RAND_add (&curr_gid, sizeof curr_gid, 1);
 180         curr_gid = 0;
 181
 182         curr_pid = getpid();
 183         RAND_add (&curr_pid, sizeof curr_pid, 1);
 184         curr_pid = 0;
 185
 186         curr_uid = getuid();
 187         RAND_add (&curr_uid, sizeof curr_uid, 1);
 188         curr_uid = 0;
 189
 190         for (i=0; i<(ENTROPY_NEEDED*4); i++)
 191         {
 192                 /* burn some cpu; hope for interrupts, cache
 193                    collisions, bus interference, etc.  */
 194                 for (k=0; k<99; k++)
 195                         ts.tv_nsec = random ();
 196
 197 #ifdef OPENSSL_SYS_VOS_HPPA
 198                 /* sleep for 1/1024 of a second (976 us).  */
 199                 duration = 1;
 200                 s$sleep (&duration, &code);
 201 #else
 202 #ifdef OPENSSL_SYS_VOS_IA32
 203                 /* sleep for 1/65536 of a second (15 us).  */
 204                 duration = 1;
 205                 s$sleep2 (&duration, &code);
 206 #endif /* OPENSSL_SYS_VOS_IA32 */
 207 #endif /* OPENSSL_SYS_VOS_HPPA */
 208
 209                 /* get wall clock time.  */
 210                 clock_gettime (CLOCK_REALTIME, &ts);
 211
 212                 /* take 8 bits */
 213                 v = (unsigned char) (ts.tv_nsec % 256);
 214                 RAND_add (&v, sizeof v, 1);
 215                 v = 0;
 216         }
 217         return 1;
 218 }
 219 #elif defined __OpenBSD__
 220 int RAND_poll(void)
 221 {
 222         u_int32_t rnd = 0, i;
 223         unsigned char buf[ENTROPY_NEEDED];
 224
 225         for (i = 0; i < sizeof(buf); i++) {
 226                 if (i % 4 == 0)
 227                         rnd = arc4random();
 228                 buf[i] = rnd;
 229                 rnd >>= 8;
 230         }
 231         RAND_add(buf, sizeof(buf), ENTROPY_NEEDED);
 232         memset(buf, 0, sizeof(buf));
 233
 234         return 1;
 235 }
 236 #else /* !defined(__OpenBSD__) */
 237 int RAND_poll(void)
 238 {
 239         unsigned long l;
 240         pid_t curr_pid = getpid();
 241 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 242         unsigned char tmpbuf[ENTROPY_NEEDED];
 243         int n = 0;
 244 #endif
 245 #ifdef DEVRANDOM
 246         static const char *randomfiles[] = { DEVRANDOM };
 247         struct stat randomstats[sizeof(randomfiles)/sizeof(randomfiles[0])];
 248         int fd;
 249         unsigned int i;
 250 #endif
 251 #ifdef DEVRANDOM_EGD
 252         static const char *egdsockets[] = { DEVRANDOM_EGD, NULL };
 253         const char **egdsocket = NULL;
 254 #endif
 255
 256 #ifdef DEVRANDOM
 257         memset(randomstats,0,sizeof(randomstats));
 258         /* Use a random entropy pool device. Linux, FreeBSD and OpenBSD
 259          * have this. Use /dev/urandom if you can as /dev/random may block
 260          * if it runs out of random entries.  */
 261
 262         for (i = 0; (i < sizeof(randomfiles)/sizeof(randomfiles[0])) &&
 263                         (n < ENTROPY_NEEDED); i++)
 264                 {
 265                 if ((fd = open(randomfiles[i], O_RDONLY
 266 #ifdef O_NONBLOCK
 267                         |O_NONBLOCK
 268 #endif
 269 #ifdef O_BINARY
 270                         |O_BINARY
 271 #endif
 272 #ifdef O_NOCTTY /* If it happens to be a TTY (god forbid), do not make it
 273                    our controlling tty */
 274                         |O_NOCTTY
 275 #endif
 276                         )) >= 0)
 277                         {
 278                         int usec = 10*1000; /* spend 10ms on each file */
 279                         int r;
 280                         unsigned int j;
 281                         struct stat *st=&randomstats[i];
 282
 283                         /* Avoid using same input... Used to be O_NOFOLLOW
 284                          * above, but it's not universally appropriate... */
 285                         if (fstat(fd,st) != 0)  { close(fd); continue; }
 286                         for (j=0;j<i;j++)
 287                                 {
 288                                 if (randomstats[j].st_ino==st->st_ino &&
 289                                     randomstats[j].st_dev==st->st_dev)
 290                                         break;
 291                                 }
 292                         if (j<i)                { close(fd); continue; }
 293
 294                         do
 295                                 {
 296                                 int try_read = 0;
 297
 298 #if defined(OPENSSL_SYS_LINUX)
 299                                 /* use poll() */
 300                                 struct pollfd pset;
 301
 302                                 pset.fd = fd;
 303                                 pset.events = POLLIN;
 304                                 pset.revents = 0;
 305
 306                                 if (poll(&pset, 1, usec / 1000) < 0)
 307                                         usec = 0;
 308                                 else
 309                                         try_read = (pset.revents & POLLIN) != 0;
 310
 311 #else
 312                                 /* use select() */
 313                                 fd_set fset;
 314                                 struct timeval t;
 315
 316                                 t.tv_sec = 0;
 317                                 t.tv_usec = usec;
 318
 319                                 if (FD_SETSIZE > 0 && (unsigned)fd >= FD_SETSIZE)
 320                                         {
 321                                         /* can't use select, so just try to read once anyway */
 322                                         try_read = 1;
 323                                         }
 324                                 else
 325                                         {
 326                                         FD_ZERO(&fset);
 327                                         FD_SET(fd, &fset);
 328
 329                                         if (select(fd+1,&fset,NULL,NULL,&t) >= 0)
 330                                                 {
 331                                                 usec = t.tv_usec;
 332                                                 if (FD_ISSET(fd, &fset))
 333                                                         try_read = 1;
 334                                                 }
 335                                         else
 336                                                 usec = 0;
 337                                         }
 338 #endif
 339
 340                                 if (try_read)
 341                                         {
 342                                         r = read(fd,(unsigned char *)tmpbuf+n, ENTROPY_NEEDED-n);
 343                                         if (r > 0)
 344                                                 n += r;
 345                                         }
 346                                 else
 347                                         r = -1;
 348
 349                                 /* Some Unixen will update t in select(), some
 350                                    won't.  For those who won't, or if we
 351                                    didn't use select() in the first place,
 352                                    give up here, otherwise, we will do
 353                                    this once again for the remaining
 354                                    time. */
 355                                 if (usec == 10*1000)
 356                                         usec = 0;
 357                                 }
 358                         while ((r > 0 ||
 359                                (errno == EINTR || errno == EAGAIN)) && usec != 0 && n < ENTROPY_NEEDED);
 360
 361                         close(fd);
 362                         }
 363                 }
 364 #endif /* defined(DEVRANDOM) */
 365
 366 #ifdef DEVRANDOM_EGD
 367         /* Use an EGD socket to read entropy from an EGD or PRNGD entropy
 368          * collecting daemon. */
 369
 370         for (egdsocket = egdsockets; *egdsocket && n < ENTROPY_NEEDED; egdsocket++)
 371                 {
 372                 int r;
 373
 374                 r = RAND_query_egd_bytes(*egdsocket, (unsigned char *)tmpbuf+n,
 375                                          ENTROPY_NEEDED-n);
 376                 if (r > 0)
 377                         n += r;
 378                 }
 379 #endif /* defined(DEVRANDOM_EGD) */
 380
 381 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 382         if (n > 0)
 383                 {
 384                 RAND_add(tmpbuf,sizeof tmpbuf,(double)n);
 385                 OPENSSL_cleanse(tmpbuf,n);
 386                 }
 387 #endif
 388
 389         /* put in some default random data, we need more than just this */
 390         l=curr_pid;
 391         RAND_add(&l,sizeof(l),0.0);
 392         l=getuid();
 393         RAND_add(&l,sizeof(l),0.0);
 394
 395         l=time(NULL);
 396         RAND_add(&l,sizeof(l),0.0);
 397
 398 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 399         return 1;
 400 #else
 401         return 0;
 402 #endif
 403 }
 404
 405 #endif /* defined(__OpenBSD__) */
 406 #endif /* !(defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_NETWARE)) */
 407
 408
 409 #if defined(OPENSSL_SYS_VXWORKS)
 410 int RAND_poll(void)
 411         {
 412         return 0;
 413         }
 414 #endif