bfdd3e6efae30a4e37f5dcfa472f958948f44213
[openssl.git] / crypto / rand / rand_unix.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 #include <stdio.h>
11
12 #define USE_SOCKETS
13 #include "e_os.h"
14 #include "internal/cryptlib.h"
15 #include <openssl/rand.h>
16 #include "rand_lcl.h"
17
18 #if !(defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_UEFI))
19
20 # include <sys/types.h>
21 # include <sys/time.h>
22 # include <sys/times.h>
23 # include <sys/stat.h>
24 # include <fcntl.h>
25 # include <unistd.h>
26 # include <time.h>
27 # if defined(OPENSSL_SYS_LINUX) /* should actually be available virtually
28                                  * everywhere */
29 #  include <poll.h>
30 # endif
31 # include <limits.h>
32 # ifndef FD_SETSIZE
33 #  define FD_SETSIZE (8*sizeof(fd_set))
34 # endif
35
36 # if defined(OPENSSL_SYS_VOS)
37
38 /*
39  * The following algorithm repeatedly samples the real-time clock (RTC) to
40  * generate a sequence of unpredictable data.  The algorithm relies upon the
41  * uneven execution speed of the code (due to factors such as cache misses,
42  * interrupts, bus activity, and scheduling) and upon the rather large
43  * relative difference between the speed of the clock and the rate at which
44  * it can be read.
45  *
46  * If this code is ported to an environment where execution speed is more
47  * constant or where the RTC ticks at a much slower rate, or the clock can be
48  * read with fewer instructions, it is likely that the results would be far
49  * more predictable.
50  *
51  * As a precaution, we generate 4 times the minimum required amount of seed
52  * data.
53  */
54
55 int RAND_poll(void)
56 {
57     short int code;
58     gid_t curr_gid;
59     pid_t curr_pid;
60     uid_t curr_uid;
61     int i, k;
62     struct timespec ts;
63     unsigned char v;
64
65 #  ifdef OPENSSL_SYS_VOS_HPPA
66     long duration;
67     extern void s$sleep(long *_duration, short int *_code);
68 #  else
69 #   ifdef OPENSSL_SYS_VOS_IA32
70     long long duration;
71     extern void s$sleep2(long long *_duration, short int *_code);
72 #   else
73 #    error "Unsupported Platform."
74 #   endif                       /* OPENSSL_SYS_VOS_IA32 */
75 #  endif                        /* OPENSSL_SYS_VOS_HPPA */
76
77     /*
78      * Seed with the gid, pid, and uid, to ensure *some* variation between
79      * different processes.
80      */
81
82     curr_gid = getgid();
83     RAND_add(&curr_gid, sizeof curr_gid, 1);
84     curr_gid = 0;
85
86     curr_pid = getpid();
87     RAND_add(&curr_pid, sizeof curr_pid, 1);
88     curr_pid = 0;
89
90     curr_uid = getuid();
91     RAND_add(&curr_uid, sizeof curr_uid, 1);
92     curr_uid = 0;
93
94     for (i = 0; i < (RANDOMNESS_NEEDED * 4); i++) {
95         /*
96          * burn some cpu; hope for interrupts, cache collisions, bus
97          * interference, etc.
98          */
99         for (k = 0; k < 99; k++)
100             ts.tv_nsec = random();
101
102 #  ifdef OPENSSL_SYS_VOS_HPPA
103         /* sleep for 1/1024 of a second (976 us).  */
104         duration = 1;
105         s$sleep(&duration, &code);
106 #  else
107 #   ifdef OPENSSL_SYS_VOS_IA32
108         /* sleep for 1/65536 of a second (15 us).  */
109         duration = 1;
110         s$sleep2(&duration, &code);
111 #   endif                       /* OPENSSL_SYS_VOS_IA32 */
112 #  endif                        /* OPENSSL_SYS_VOS_HPPA */
113
114         /* get wall clock time.  */
115         clock_gettime(CLOCK_REALTIME, &ts);
116
117         /* take 8 bits */
118         v = (unsigned char)(ts.tv_nsec % 256);
119         RAND_add(&v, sizeof v, 1);
120         v = 0;
121     }
122     return 1;
123 }
124 # else
125 int RAND_poll(void)
126 {
127     unsigned long l;
128     pid_t curr_pid = getpid();
129 #  if defined(DEVRANDOM) || (!defined(OPENSS_NO_EGD) && defined(DEVRANDOM_EGD))
130     unsigned char tmpbuf[RANDOMNESS_NEEDED];
131     int n = 0;
132 #  endif
133 #  ifdef DEVRANDOM
134     static const char *randomfiles[] = { DEVRANDOM };
135     struct stat randomstats[OSSL_NELEM(randomfiles)];
136     int fd;
137     unsigned int i;
138 #  endif
139 #  if !defined(OPENSSL_NO_EGD) && defined(DEVRANDOM_EGD)
140     static const char *egdsockets[] = { DEVRANDOM_EGD, NULL };
141     const char **egdsocket = NULL;
142 #  endif
143
144 #  ifdef DEVRANDOM
145     memset(randomstats, 0, sizeof(randomstats));
146     /*
147      * Use a randomness device. Linux, FreeBSD and OpenBSD have
148      * this. Use /dev/urandom if you can as /dev/random may block if it runs
149      * out of random entries.
150      */
151
152     for (i = 0; (i < OSSL_NELEM(randomfiles)) && (n < RANDOMNESS_NEEDED); i++) {
153         if ((fd = open(randomfiles[i], O_RDONLY
154 #   ifdef O_NONBLOCK
155                        | O_NONBLOCK
156 #   endif
157 #   ifdef O_BINARY
158                        | O_BINARY
159 #   endif
160 #   ifdef O_NOCTTY              /* If it happens to be a TTY (god forbid), do
161                                  * not make it our controlling tty */
162                        | O_NOCTTY
163 #   endif
164              )) >= 0) {
165             int usec = 10 * 1000; /* spend 10ms on each file */
166             int r;
167             unsigned int j;
168             struct stat *st = &randomstats[i];
169
170             /*
171              * Avoid using same input... Used to be O_NOFOLLOW above, but
172              * it's not universally appropriate...
173              */
174             if (fstat(fd, st) != 0) {
175                 close(fd);
176                 continue;
177             }
178             for (j = 0; j < i; j++) {
179                 if (randomstats[j].st_ino == st->st_ino &&
180                     randomstats[j].st_dev == st->st_dev)
181                     break;
182             }
183             if (j < i) {
184                 close(fd);
185                 continue;
186             }
187
188             do {
189                 int try_read = 0;
190
191 #   if defined(OPENSSL_SYS_LINUX)
192                 /* use poll() */
193                 struct pollfd pset;
194
195                 pset.fd = fd;
196                 pset.events = POLLIN;
197                 pset.revents = 0;
198
199                 if (poll(&pset, 1, usec / 1000) < 0)
200                     usec = 0;
201                 else
202                     try_read = (pset.revents & POLLIN) != 0;
203
204 #   else
205                 /* use select() */
206                 fd_set fset;
207                 struct timeval t;
208
209                 t.tv_sec = 0;
210                 t.tv_usec = usec;
211
212                 if (FD_SETSIZE > 0 && (unsigned)fd >= FD_SETSIZE) {
213                     /*
214                      * can't use select, so just try to read once anyway
215                      */
216                     try_read = 1;
217                 } else {
218                     FD_ZERO(&fset);
219                     FD_SET(fd, &fset);
220
221                     if (select(fd + 1, &fset, NULL, NULL, &t) >= 0) {
222                         usec = t.tv_usec;
223                         if (FD_ISSET(fd, &fset))
224                             try_read = 1;
225                     } else
226                         usec = 0;
227                 }
228 #   endif
229
230                 if (try_read) {
231                     r = read(fd, (unsigned char *)tmpbuf + n,
232                              RANDOMNESS_NEEDED - n);
233                     if (r > 0)
234                         n += r;
235                 } else
236                     r = -1;
237
238                 /*
239                  * Some Unixen will update t in select(), some won't.  For
240                  * those who won't, or if we didn't use select() in the first
241                  * place, give up here, otherwise, we will do this once again
242                  * for the remaining time.
243                  */
244                 if (usec == 10 * 1000)
245                     usec = 0;
246             }
247             while ((r > 0 ||
248                     (errno == EINTR || errno == EAGAIN)) && usec != 0
249                    && n < RANDOMNESS_NEEDED);
250
251             close(fd);
252         }
253     }
254 #  endif                        /* defined(DEVRANDOM) */
255
256 #  if !defined(OPENSSL_NO_EGD) && defined(DEVRANDOM_EGD)
257     /*
258      * Use an EGD socket to read randomness from the daemon.
259      */
260
261     for (egdsocket = egdsockets; *egdsocket && n < RANDOMNESS_NEEDED;
262          egdsocket++) {
263         int r;
264
265         r = RAND_query_egd_bytes(*egdsocket, (unsigned char *)tmpbuf + n,
266                                  RANDOMNESS_NEEDED - n);
267         if (r > 0)
268             n += r;
269     }
270 #  endif                        /* defined(DEVRANDOM_EGD) */
271
272 #  if defined(DEVRANDOM) || (!defined(OPENSSL_NO_EGD) && defined(DEVRANDOM_EGD))
273     if (n > 0) {
274         RAND_add(tmpbuf, sizeof tmpbuf, (double)n);
275         OPENSSL_cleanse(tmpbuf, n);
276     }
277 #  endif
278
279     /* put in some default random data, we need more than just this */
280     l = curr_pid;
281     RAND_add(&l, sizeof(l), 0.0);
282     l = getuid();
283     RAND_add(&l, sizeof(l), 0.0);
284
285     l = time(NULL);
286     RAND_add(&l, sizeof(l), 0.0);
287
288 #  if defined(DEVRANDOM) || (!defined(OPENSSL_NO_EGD) && defined(DEVRANDOM_EGD))
289     return 1;
290 #  else
291     return 0;
292 #  endif
293 }
294
295 # endif                         /* defined(__OpenBSD__) */
296 #endif                          /* !(defined(OPENSSL_SYS_WINDOWS) ||
297                                  * defined(OPENSSL_SYS_WIN32) ||
298                                  * defined(OPENSSL_SYS_VMS) ||
299                                  * defined(OPENSSL_SYS_VXWORKS) */
300
301 #if defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_UEFI)
302 int RAND_poll(void)
303 {
304     return 0;
305 }
306 #endif