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 #ifdef __OpenBSD__
 137 int RAND_poll(void)
 138 {
 139         u_int32_t rnd = 0, i;
 140         unsigned char buf[ENTROPY_NEEDED];
 141
 142         for (i = 0; i < sizeof(buf); i++) {
 143                 if (i % 4 == 0)
 144                         rnd = arc4random();
 145                 buf[i] = rnd;
 146                 rnd >>= 8;
 147         }
 148         RAND_add(buf, sizeof(buf), ENTROPY_NEEDED);
 149         memset(buf, 0, sizeof(buf));
 150
 151         return 1;
 152 }
 153 #else /* !defined(__OpenBSD__) */
 154 int RAND_poll(void)
 155 {
 156         unsigned long l;
 157         pid_t curr_pid = getpid();
 158 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 159         unsigned char tmpbuf[ENTROPY_NEEDED];
 160         int n = 0;
 161 #endif
 162 #ifdef DEVRANDOM
 163         static const char *randomfiles[] = { DEVRANDOM };
 164         struct stat randomstats[sizeof(randomfiles)/sizeof(randomfiles[0])];
 165         int fd;
 166         unsigned int i;
 167 #endif
 168 #ifdef DEVRANDOM_EGD
 169         static const char *egdsockets[] = { DEVRANDOM_EGD, NULL };
 170         const char **egdsocket = NULL;
 171 #endif
 172
 173 #ifdef DEVRANDOM
 174         memset(randomstats,0,sizeof(randomstats));
 175         /* Use a random entropy pool device. Linux, FreeBSD and OpenBSD
 176          * have this. Use /dev/urandom if you can as /dev/random may block
 177          * if it runs out of random entries.  */
 178
 179         for (i = 0; (i < sizeof(randomfiles)/sizeof(randomfiles[0])) &&
 180                         (n < ENTROPY_NEEDED); i++)
 181                 {
 182                 if ((fd = open(randomfiles[i], O_RDONLY
 183 #ifdef O_NONBLOCK
 184                         |O_NONBLOCK
 185 #endif
 186 #ifdef O_BINARY
 187                         |O_BINARY
 188 #endif
 189 #ifdef O_NOCTTY /* If it happens to be a TTY (god forbid), do not make it
 190                    our controlling tty */
 191                         |O_NOCTTY
 192 #endif
 193                         )) >= 0)
 194                         {
 195                         int usec = 10*1000; /* spend 10ms on each file */
 196                         int r;
 197                         unsigned int j;
 198                         struct stat *st=&randomstats[i];
 199
 200                         /* Avoid using same input... Used to be O_NOFOLLOW
 201                          * above, but it's not universally appropriate... */
 202                         if (fstat(fd,st) != 0)  { close(fd); continue; }
 203                         for (j=0;j<i;j++)
 204                                 {
 205                                 if (randomstats[j].st_ino==st->st_ino &&
 206                                     randomstats[j].st_dev==st->st_dev)
 207                                         break;
 208                                 }
 209                         if (j<i)                { close(fd); continue; }
 210
 211                         do
 212                                 {
 213                                 int try_read = 0;
 214
 215 #if defined(OPENSSL_SYS_BEOS_R5)
 216                                 /* select() is broken in BeOS R5, so we simply
 217                                  *  try to read something and snooze if we couldn't */
 218                                 try_read = 1;
 219
 220 #elif defined(OPENSSL_SYS_LINUX)
 221                                 /* use poll() */
 222                                 struct pollfd pset;
 223
 224                                 pset.fd = fd;
 225                                 pset.events = POLLIN;
 226                                 pset.revents = 0;
 227
 228                                 if (poll(&pset, 1, usec / 1000) < 0)
 229                                         usec = 0;
 230                                 else
 231                                         try_read = (pset.revents & POLLIN) != 0;
 232
 233 #else
 234                                 /* use select() */
 235                                 fd_set fset;
 236                                 struct timeval t;
 237
 238                                 t.tv_sec = 0;
 239                                 t.tv_usec = usec;
 240
 241                                 if (FD_SETSIZE > 0 && fd >= FD_SETSIZE)
 242                                         {
 243                                         /* can't use select, so just try to read once anyway */
 244                                         try_read = 1;
 245                                         }
 246                                 else
 247                                         {
 248                                         FD_ZERO(&fset);
 249                                         FD_SET(fd, &fset);
 250
 251                                         if (select(fd+1,&fset,NULL,NULL,&t) >= 0)
 252                                                 {
 253                                                 usec = t.tv_usec;
 254                                                 if (FD_ISSET(fd, &fset))
 255                                                         try_read = 1;
 256                                                 }
 257                                         else
 258                                                 usec = 0;
 259                                         }
 260 #endif
 261
 262                                 if (try_read)
 263                                         {
 264                                         r = read(fd,(unsigned char *)tmpbuf+n, ENTROPY_NEEDED-n);
 265                                         if (r > 0)
 266                                                 n += r;
 267 #if defined(OPENSSL_SYS_BEOS_R5)
 268                                         if (r == 0)
 269                                                 snooze(t.tv_usec);
 270 #endif
 271                                         }
 272                                 else
 273                                         r = -1;
 274
 275                                 /* Some Unixen will update t in select(), some
 276                                    won't.  For those who won't, or if we
 277                                    didn't use select() in the first place,
 278                                    give up here, otherwise, we will do
 279                                    this once again for the remaining
 280                                    time. */
 281                                 if (usec == 10*1000)
 282                                         usec = 0;
 283                                 }
 284                         while ((r > 0 ||
 285                                (errno == EINTR || errno == EAGAIN)) && usec != 0 && n < ENTROPY_NEEDED);
 286
 287                         close(fd);
 288                         }
 289                 }
 290 #endif /* defined(DEVRANDOM) */
 291
 292 #ifdef DEVRANDOM_EGD
 293         /* Use an EGD socket to read entropy from an EGD or PRNGD entropy
 294          * collecting daemon. */
 295
 296         for (egdsocket = egdsockets; *egdsocket && n < ENTROPY_NEEDED; egdsocket++)
 297                 {
 298                 int r;
 299
 300                 r = RAND_query_egd_bytes(*egdsocket, (unsigned char *)tmpbuf+n,
 301                                          ENTROPY_NEEDED-n);
 302                 if (r > 0)
 303                         n += r;
 304                 }
 305 #endif /* defined(DEVRANDOM_EGD) */
 306
 307 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 308         if (n > 0)
 309                 {
 310                 RAND_add(tmpbuf,sizeof tmpbuf,(double)n);
 311                 OPENSSL_cleanse(tmpbuf,n);
 312                 }
 313 #endif
 314
 315         /* put in some default random data, we need more than just this */
 316         l=curr_pid;
 317         RAND_add(&l,sizeof(l),0.0);
 318         l=getuid();
 319         RAND_add(&l,sizeof(l),0.0);
 320
 321         l=time(NULL);
 322         RAND_add(&l,sizeof(l),0.0);
 323
 324 #if defined(OPENSSL_SYS_BEOS)
 325         {
 326         system_info sysInfo;
 327         get_system_info(&sysInfo);
 328         RAND_add(&sysInfo,sizeof(sysInfo),0);
 329         }
 330 #endif
 331
 332 #if defined(DEVRANDOM) || defined(DEVRANDOM_EGD)
 333         return 1;
 334 #else
 335         return 0;
 336 #endif
 337 }
 338
 339 #endif /* defined(__OpenBSD__) */
 340 #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)) */
 341
 342
 343 #if defined(OPENSSL_SYS_VXWORKS)
 344 int RAND_poll(void)
 345         {
 346         return 0;
 347         }
 348 #endif