1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define APR_WANT_MEMFUNC
18 #include "apr_want.h"
19 #include "apr_general.h"
20
21 #include "apr_arch_misc.h"
22 #include <sys/stat.h>
23 #if APR_HAVE_SYS_TYPES_H
24 #include <sys/types.h>
25 #endif
26 #if APR_HAVE_SYS_SOCKET_H
27 #include <sys/socket.h>
28 #endif
29 #if APR_HAVE_FCNTL_H
30 #include <fcntl.h>
31 #endif
32 #if APR_HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
35 #if APR_HAVE_SYS_UN_H
36 #include <sys/un.h>
37 #endif
38 #if defined(HAVE_UUID_H)
39 #include <uuid.h>
40 #elif defined(HAVE_UUID_UUID_H)
41 #include <uuid/uuid.h>
42 #elif defined(HAVE_SYS_UUID_H)
43 #include <sys/uuid.h>
44 #endif
45
46 #if defined(SYS_RANDOM)
47 #if defined(HAVE_SYS_RANDOM_H) && \
48 defined(HAVE_GETRANDOM)
49
50 #include <sys/random.h>
51 #define USE_GETRANDOM
52
53 #elif defined(HAVE_SYS_SYSCALL_H) && \
54 defined(HAVE_LINUX_RANDOM_H) && \
55 defined(HAVE_DECL_SYS_GETRANDOM) && \
56 HAVE_DECL_SYS_GETRANDOM
57
58 #ifndef _GNU_SOURCE
59 #define _GNU_SOURCE
60 #endif
61 #include <unistd.h>
62 #include <sys/syscall.h>
63 #include <linux/random.h>
64 #define getrandom(buf, buflen, flags) \
65 syscall(SYS_getrandom, (buf), (buflen), (flags))
66 #define USE_GETRANDOM
67
68 #endif /* HAVE_SYS_RANDOM_H */
69 #endif /* SYS_RANDOM */
70
71 #ifndef SHUT_RDWR
72 #define SHUT_RDWR 2
73 #endif
74
75 #if APR_HAS_OS_UUID
76
77 #if defined(HAVE_UUID_CREATE)
78
apr_os_uuid_get(unsigned char * uuid_data)79 APR_DECLARE(apr_status_t) apr_os_uuid_get(unsigned char *uuid_data)
80 {
81 uint32_t rv;
82 uuid_t g;
83
84 uuid_create(&g, &rv);
85
86 if (rv != uuid_s_ok)
87 return APR_EGENERAL;
88
89 memcpy(uuid_data, &g, sizeof(uuid_t));
90
91 return APR_SUCCESS;
92 }
93
94 #elif defined(HAVE_UUID_GENERATE)
95
apr_os_uuid_get(unsigned char * uuid_data)96 APR_DECLARE(apr_status_t) apr_os_uuid_get(unsigned char *uuid_data)
97 {
98 uuid_t g;
99
100 uuid_generate(g);
101
102 memcpy(uuid_data, g, sizeof(uuid_t));
103
104 return APR_SUCCESS;
105 }
106 #endif
107
108 #endif /* APR_HAS_OS_UUID */
109
110 #if APR_HAS_RANDOM
111
apr_generate_random_bytes(unsigned char * buf,apr_size_t length)112 APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char *buf,
113 apr_size_t length)
114 {
115 #if defined(HAVE_EGD)
116 /* use EGD-compatible socket daemon (such as EGD or PRNGd).
117 * message format:
118 * 0x00 (get entropy level)
119 * 0xMM (msb) 0xmm 0xll 0xLL (lsb)
120 * 0x01 (read entropy nonblocking) 0xNN (bytes requested)
121 * 0xMM (bytes granted) MM bytes
122 * 0x02 (read entropy blocking) 0xNN (bytes desired)
123 * [block] NN bytes
124 * 0x03 (write entropy) 0xMM 0xLL (bits of entropy) 0xNN (bytes of data)
125 * NN bytes
126 * (no response - write only)
127 * 0x04 (report PID)
128 * 0xMM (length of PID string, not null-terminated) MM chars
129 */
130 static const char *egd_sockets[] = { EGD_DEFAULT_SOCKET, NULL };
131 const char **egdsockname = NULL;
132
133 int egd_socket, egd_path_len, rv, bad_errno;
134 struct sockaddr_un addr;
135 apr_socklen_t egd_addr_len;
136 apr_size_t resp_expected;
137 unsigned char req[2], resp[255];
138 unsigned char *curbuf = buf;
139
140 for (egdsockname = egd_sockets; *egdsockname && length > 0; egdsockname++) {
141 egd_path_len = strlen(*egdsockname);
142
143 if (egd_path_len > sizeof(addr.sun_path)) {
144 return APR_EINVAL;
145 }
146
147 memset(&addr, 0, sizeof(struct sockaddr_un));
148 addr.sun_family = AF_UNIX;
149 memcpy(addr.sun_path, *egdsockname, egd_path_len);
150 egd_addr_len = APR_OFFSETOF(struct sockaddr_un, sun_path) +
151 egd_path_len;
152
153 egd_socket = socket(PF_UNIX, SOCK_STREAM, 0);
154
155 if (egd_socket == -1) {
156 return errno;
157 }
158
159 rv = connect(egd_socket, (struct sockaddr*)&addr, egd_addr_len);
160
161 if (rv == -1) {
162 bad_errno = errno;
163 continue;
164 }
165
166 /* EGD can only return 255 bytes of data at a time. Silly. */
167 while (length > 0) {
168 apr_ssize_t srv;
169 req[0] = 2; /* We'll block for now. */
170 req[1] = length > 255 ? 255: length;
171
172 srv = write(egd_socket, req, 2);
173 if (srv == -1) {
174 bad_errno = errno;
175 shutdown(egd_socket, SHUT_RDWR);
176 close(egd_socket);
177 break;
178 }
179
180 if (srv != 2) {
181 shutdown(egd_socket, SHUT_RDWR);
182 close(egd_socket);
183 return APR_EGENERAL;
184 }
185
186 resp_expected = req[1];
187 srv = read(egd_socket, resp, resp_expected);
188 if (srv == -1) {
189 bad_errno = errno;
190 shutdown(egd_socket, SHUT_RDWR);
191 close(egd_socket);
192 return bad_errno;
193 }
194
195 memcpy(curbuf, resp, srv);
196 curbuf += srv;
197 length -= srv;
198 }
199
200 shutdown(egd_socket, SHUT_RDWR);
201 close(egd_socket);
202 }
203
204 if (length > 0) {
205 /* We must have iterated through the list of sockets,
206 * and no go. Return the errno.
207 */
208 return bad_errno;
209 }
210
211 #elif defined(SYS_RANDOM) && defined(USE_GETRANDOM)
212
213 do {
214 int rc;
215
216 rc = getrandom(buf, length, 0);
217 if (rc == -1) {
218 if (errno == EINTR) {
219 continue;
220 }
221 return errno;
222 }
223
224 buf += rc;
225 length -= rc;
226 } while (length > 0);
227
228 #elif defined(SYS_RANDOM) && defined(HAVE_ARC4RANDOM_BUF)
229
230 arc4random_buf(buf, length);
231
232 #elif defined(DEV_RANDOM)
233
234 int fd = -1;
235
236 /* On BSD/OS 4.1, /dev/random gives out 8 bytes at a time, then
237 * gives EOF, so reading 'length' bytes may require opening the
238 * device several times. */
239 do {
240 apr_ssize_t rc;
241
242 if (fd == -1)
243 if ((fd = open(DEV_RANDOM, O_RDONLY)) == -1)
244 return errno;
245
246 do {
247 rc = read(fd, buf, length);
248 } while (rc == -1 && errno == EINTR);
249
250 if (rc < 0) {
251 int errnum = errno;
252 close(fd);
253 return errnum;
254 }
255 else if (rc == 0) {
256 close(fd);
257 fd = -1; /* force open() again */
258 }
259 else {
260 buf += rc;
261 length -= rc;
262 }
263 } while (length > 0);
264
265 close(fd);
266
267 #elif defined(OS2)
268
269 static UCHAR randbyte();
270 unsigned int idx;
271
272 for (idx=0; idx<length; idx++)
273 buf[idx] = randbyte();
274
275 #elif defined(HAVE_TRUERAND) /* use truerand */
276
277 extern int randbyte(void); /* from the truerand library */
278 unsigned int idx;
279
280 /* this will increase the startup time of the server, unfortunately...
281 * (generating 20 bytes takes about 8 seconds)
282 */
283 for (idx=0; idx<length; idx++)
284 buf[idx] = (unsigned char) randbyte();
285
286 #else
287
288 #error APR_HAS_RANDOM defined with no implementation
289
290 #endif /* DEV_RANDOM */
291
292 return APR_SUCCESS;
293 }
294
295 #undef STR
296 #undef XSTR
297
298 #ifdef OS2
299 #include "randbyte_os2.inc"
300 #endif
301
302 #endif /* APR_HAS_RANDOM */
303