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