summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/arc4random/getentropy_linux.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/arc4random/getentropy_linux.c')
-rw-r--r--src/lib/libcrypto/arc4random/getentropy_linux.c264
1 files changed, 135 insertions, 129 deletions
diff --git a/src/lib/libcrypto/arc4random/getentropy_linux.c b/src/lib/libcrypto/arc4random/getentropy_linux.c
index 27b9e9ad08..769d6c977e 100644
--- a/src/lib/libcrypto/arc4random/getentropy_linux.c
+++ b/src/lib/libcrypto/arc4random/getentropy_linux.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: getentropy_linux.c,v 1.5 2014/06/21 02:08:34 deraadt Exp $ */ 1/* $OpenBSD: getentropy_linux.c,v 1.6 2014/06/21 21:44:36 deraadt Exp $ */
2 2
3/* 3/*
4 * Copyright (c) 2014 Theo de Raadt <deraadt@openbsd.org> 4 * Copyright (c) 2014 Theo de Raadt <deraadt@openbsd.org>
@@ -49,15 +49,15 @@
49#define REPEAT 5 49#define REPEAT 5
50#define min(a, b) (((a) < (b)) ? (a) : (b)) 50#define min(a, b) (((a) < (b)) ? (a) : (b))
51 51
52#define HASHX(a, b) \ 52#define HX(a, b) \
53 do { \ 53 do { \
54 if ((a)) \ 54 if ((a)) \
55 HASHD(errno); \ 55 HD(errno); \
56 else \ 56 else \
57 HASHD(b); \ 57 HD(b); \
58 } while (0) 58 } while (0)
59 59
60#define HASHD(xxx) (SHA512_Update(&ctx, (char *)&(xxx), sizeof (xxx))) 60#define HD(xxx) (SHA512_Update(&ctx, (char *)&(xxx), sizeof (xxx)))
61 61
62int getentropy(void *buf, size_t len); 62int getentropy(void *buf, size_t len);
63 63
@@ -278,8 +278,8 @@ static int
278getentropy_fallback(void *buf, size_t len) 278getentropy_fallback(void *buf, size_t len)
279{ 279{
280 uint8_t results[SHA512_DIGEST_LENGTH]; 280 uint8_t results[SHA512_DIGEST_LENGTH];
281 int save_errno = errno, e, m, pgsiz = getpagesize(), repeat; 281 int save_errno = errno, e, m, pgs = getpagesize(), repeat;
282 static int counter; 282 static int cnt;
283 struct timespec ts; 283 struct timespec ts;
284 struct timeval tv; 284 struct timeval tv;
285 struct rusage ru; 285 struct rusage ru;
@@ -288,153 +288,159 @@ getentropy_fallback(void *buf, size_t len)
288 SHA512_CTX ctx; 288 SHA512_CTX ctx;
289 pid_t pid; 289 pid_t pid;
290 size_t i, ii; 290 size_t i, ii;
291 void *p; 291 char *p;
292 292
293 for (i = 0; i < len; ) { 293 for (i = 0; i < len; ) {
294 SHA512_Init(&ctx); 294 SHA512_Init(&ctx);
295 for (repeat = 0; repeat < REPEAT; repeat++) { 295 for (repeat = 0; repeat < REPEAT; repeat++) {
296 296
297 HASHX((e = gettimeofday(&tv, NULL)) == -1, tv); 297 HX((e = gettimeofday(&tv, NULL)) == -1, tv);
298 if (e != -1) { 298 if (e != -1) {
299 counter += (int)tv.tv_sec; 299 cnt += (int)tv.tv_sec;
300 counter += (int)tv.tv_usec; 300 cnt += (int)tv.tv_usec;
301 } 301 }
302 302
303 for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]); ii++) 303 for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]); ii++)
304 HASHX(clock_gettime(cl[ii], &ts) == -1, ts); 304 HX(clock_gettime(cl[ii], &ts) == -1, ts);
305 305
306 HASHX((pid = getpid()) == -1, pid); 306 HX((pid = getpid()) == -1, pid);
307 HASHX((pid = getsid(pid)) == -1, pid); 307 HX((pid = getsid(pid)) == -1, pid);
308 HASHX((pid = getppid()) == -1, pid); 308 HX((pid = getppid()) == -1, pid);
309 HASHX((pid = getpgid(0)) == -1, pid); 309 HX((pid = getpgid(0)) == -1, pid);
310 HASHX((m = getpriority(0, 0)) == -1, m); 310 HX((m = getpriority(0, 0)) == -1, m);
311 311
312 ts.tv_sec = 0; 312 ts.tv_sec = 0;
313 ts.tv_nsec = 1; 313 ts.tv_nsec = 1;
314 (void) nanosleep(&ts, NULL); 314 (void) nanosleep(&ts, NULL);
315 315
316 HASHX(sigpending(&sigset) == -1, sigset); 316 HX(sigpending(&sigset) == -1, sigset);
317 HASHX(sigprocmask(SIG_BLOCK, NULL, &sigset) == -1, 317 HX(sigprocmask(SIG_BLOCK, NULL, &sigset) == -1,
318 sigset); 318 sigset);
319 319
320 HASHD(main); /* an address in the main program */ 320 HD(main); /* an addr in program */
321 HASHD(getentropy); /* man address in this library */ 321 HD(getentropy); /* an addr in this library */
322 HASHD(printf); /* an address in libc */ 322 HD(printf); /* an addr in libc */
323 p = (void *)&p; 323 p = (char *)&p;
324 HASHD(p); /* an address on stack */ 324 HD(p); /* an addr on stack */
325 p = (void *)&errno; 325 p = (char *)&errno;
326 HASHD(p); /* the address of errno */ 326 HD(p); /* the addr of errno */
327 327
328 if (i == 0) { 328 if (i == 0) {
329 struct sockaddr_storage ss; 329 struct sockaddr_storage ss;
330 struct statvfs stvfs; 330 struct statvfs stvfs;
331 struct termios tios; 331 struct termios tios;
332 struct statfs stfs; 332 struct statfs stfs;
333 socklen_t ssl; 333 socklen_t ssl;
334 off_t off; 334 off_t off;
335 335
336 /* 336 /*
337 * Prime-sized mappings encourage fragmentation; 337 * Prime-sized mappings encourage fragmentation;
338 * thus exposing some address entropy. 338 * thus exposing some address entropy.
339 */ 339 */
340 struct mm { 340 struct mm {
341 size_t npg; 341 size_t npg;
342 void *p; 342 void *p;
343 } mm[] = { 343 } mm[] = {
344 { 17, MAP_FAILED }, { 3, MAP_FAILED }, 344 { 17, MAP_FAILED }, { 3, MAP_FAILED },
345 { 11, MAP_FAILED }, { 2, MAP_FAILED }, 345 { 11, MAP_FAILED }, { 2, MAP_FAILED },
346 { 5, MAP_FAILED }, { 3, MAP_FAILED }, 346 { 5, MAP_FAILED }, { 3, MAP_FAILED },
347 { 7, MAP_FAILED }, { 1, MAP_FAILED }, 347 { 7, MAP_FAILED }, { 1, MAP_FAILED },
348 { 57, MAP_FAILED }, { 3, MAP_FAILED }, 348 { 57, MAP_FAILED }, { 3, MAP_FAILED },
349 { 131, MAP_FAILED }, { 1, MAP_FAILED }, 349 { 131, MAP_FAILED }, { 1, MAP_FAILED },
350 }; 350 };
351 351
352 for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) { 352 for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) {
353 HASHX(mm[m].p = mmap(NULL, mm[m].npg * pgsiz, 353 HX(mm[m].p = mmap(NULL,
354 PROT_READ|PROT_WRITE, 354 mm[m].npg * pgs,
355 MAP_PRIVATE|MAP_ANON, -1, (off_t)0), mm[m].p); 355 PROT_READ|PROT_WRITE,
356 if (mm[m].p != MAP_FAILED) { 356 MAP_PRIVATE|MAP_ANON, -1,
357 char *mp; 357 (off_t)0), mm[m].p);
358 358 if (mm[m].p != MAP_FAILED) {
359 /* Touch some memory... */ 359 size_t mo;
360 mp = mm[m].p; 360
361 mp[counter % (mm[m].npg * 361 /* Touch some memory... */
362 pgsiz - 1)] = 1; 362 p = mm[m].p;
363 counter += (int)((long)(mm[m].p) 363 mo = cnt %
364 / pgsiz); 364 (mm[m].npg * pgs - 1);
365 p[mo] = 1;
366 cnt += (int)((long)(mm[m].p)
367 / pgs);
368 }
369
370 /* Check cnts and times... */
371 for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]);
372 ii++) {
373 HX((e = clock_gettime(cl[ii],
374 &ts)) == -1, ts);
375 if (e != -1)
376 cnt += (int)ts.tv_nsec;
377 }
378
379 HX((e = getrusage(RUSAGE_SELF,
380 &ru)) == -1, ru);
381 if (e != -1) {
382 cnt += (int)ru.ru_utime.tv_sec;
383 cnt += (int)ru.ru_utime.tv_usec;
384 }
365 } 385 }
366 386
367 /* Check counters and times... */ 387 for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) {
368 for (ii = 0; ii < sizeof(cl)/sizeof(cl[0]); 388 if (mm[m].p != MAP_FAILED)
369 ii++) { 389 munmap(mm[m].p, mm[m].npg * pgs);
370 HASHX((e = clock_gettime(cl[ii], 390 mm[m].p = MAP_FAILED;
371 &ts)) == -1, ts);
372 if (e != -1)
373 counter += (int)ts.tv_nsec;
374 }
375
376 HASHX((e = getrusage(RUSAGE_SELF, &ru)) == -1,
377 ru);
378 if (e != -1) {
379 counter += (int)ru.ru_utime.tv_sec;
380 counter += (int)ru.ru_utime.tv_usec;
381 } 391 }
382 } 392
383 393 HX(stat(".", &st) == -1, st);
384 for (m = 0; m < sizeof mm/sizeof(mm[0]); m++) { 394 HX(statvfs(".", &stvfs) == -1, stvfs);
385 if (mm[m].p != MAP_FAILED) 395 HX(statfs(".", &stfs) == -1, stfs);
386 munmap(mm[m].p, mm[m].npg * pgsiz); 396
387 mm[m].p = MAP_FAILED; 397 HX(stat("/", &st) == -1, st);
388 } 398 HX(statvfs("/", &stvfs) == -1, stvfs);
389 399 HX(statfs("/", &stfs) == -1, stfs);
390 HASHX(stat(".", &st) == -1, st); 400
391 HASHX(statvfs(".", &stvfs) == -1, stvfs); 401 HX((e = fstat(0, &st)) == -1, st);
392 HASHX(statfs(".", &stfs) == -1, stfs); 402 if (e == -1) {
393 403 if (S_ISREG(st.st_mode) ||
394 HASHX(stat("/", &st) == -1, st); 404 S_ISFIFO(st.st_mode) ||
395 HASHX(statvfs("/", &stvfs) == -1, stvfs); 405 S_ISSOCK(st.st_mode)) {
396 HASHX(statfs("/", &stfs) == -1, stfs); 406 HX(fstatvfs(0, &stvfs) == -1,
397 407 stvfs);
398 HASHX((e = fstat(0, &st)) == -1, st); 408 HX(fstatfs(0, &stfs) == -1,
399 if (e == -1) { 409 stfs);
400 if (S_ISREG(st.st_mode) || 410 HX((off = lseek(0, (off_t)0,
401 S_ISFIFO(st.st_mode) || 411 SEEK_CUR)) < 0, off);
402 S_ISSOCK(st.st_mode)) { 412 }
403 HASHX(fstatvfs(0, &stvfs) == -1, 413 if (S_ISCHR(st.st_mode)) {
404 stvfs); 414 HX(tcgetattr(0, &tios) == -1,
405 HASHX(fstatfs(0, &stfs) == -1, stfs); 415 tios);
406 HASHX((off = lseek(0, (off_t)0, 416 } else if (S_ISSOCK(st.st_mode)) {
407 SEEK_CUR)) < 0, off); 417 memset(&ss, 0, sizeof ss);
418 ssl = sizeof(ss);
419 HX(getpeername(0,
420 (void *)&ss, &ssl) == -1,
421 ss);
422 }
408 } 423 }
409 if (S_ISCHR(st.st_mode)) { 424
410 HASHX(tcgetattr(0, &tios) == -1, tios); 425 HX((e = getrusage(RUSAGE_CHILDREN,
411 } else if (S_ISSOCK(st.st_mode)) { 426 &ru)) == -1, ru);
412 memset(&ss, 0, sizeof ss); 427 if (e != -1) {
413 ssl = sizeof(ss); 428 cnt += (int)ru.ru_utime.tv_sec;
414 HASHX(getpeername(0, (void *)&ss, 429 cnt += (int)ru.ru_utime.tv_usec;
415 &ssl) == -1, ss);
416 } 430 }
431 } else {
432 /* Subsequent hashes absorb previous result */
433 HD(results);
417 } 434 }
418 435
419 HASHX((e = getrusage(RUSAGE_CHILDREN, &ru)) == -1, ru); 436 HX((e = gettimeofday(&tv, NULL)) == -1, tv);
420 if (e != -1) { 437 if (e != -1) {
421 counter += (int)ru.ru_utime.tv_sec; 438 cnt += (int)tv.tv_sec;
422 counter += (int)ru.ru_utime.tv_usec; 439 cnt += (int)tv.tv_usec;
423 } 440 }
424 } else { 441
425 /* Subsequent hashes absorb previous result */ 442 HD(cnt);
426 HASHD(results);
427 } 443 }
428
429 HASHX((e = gettimeofday(&tv, NULL)) == -1, tv);
430 if (e != -1) {
431 counter += (int)tv.tv_sec;
432 counter += (int)tv.tv_usec;
433 }
434
435 HASHD(counter);
436
437 } /* repeat */
438 SHA512_Final(results, &ctx); 444 SHA512_Final(results, &ctx);
439 memcpy(buf + i, results, min(sizeof(results), len - i)); 445 memcpy(buf + i, results, min(sizeof(results), len - i));
440 i += min(sizeof(results), len - i); 446 i += min(sizeof(results), len - i);
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-11-04 05:11:08 +0000