开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
unix_rand.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：17k
源码类别：

CA认证

开发平台：

WINDOWS

unix_rand.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include <stdio.h>
  35. #include <string.h>
  36. #include <signal.h>
  37. #include <unistd.h>
  38. #include <errno.h>
  39. #include <stdlib.h>
  40. #include <sys/time.h>
  41. #include <sys/wait.h>
  42. #include <sys/stat.h>
  43. #include <assert.h>
  44. #include "secrng.h"
  47. /*
  48.  * When copying data to the buffer we want the least signicant bytes
  49.  * from the input since those bits are changing the fastest. The address
  50.  * of least significant byte depends upon whether we are running on
  51.  * a big-endian or little-endian machine.
  52.  *
  53.  * Does this mean the least signicant bytes are the most significant
  54.  * to us? :-)
  55.  */
  56.     
  57. static size_t CopyLowBits(void *dst, size_t dstlen, void *src, size_t srclen)
  58. {
  59.     union endianness {
  60. int32 i;
  61. char c[4];
  62.     } u;
  64.     if (srclen <= dstlen) {
  65. memcpy(dst, src, srclen);
  66. return srclen;
  67.     }
  68.     u.i = 0x01020304;
  69.     if (u.c[0] == 0x01) {
  70. /* big-endian case */
  71. memcpy(dst, (char*)src + (srclen - dstlen), dstlen);
  72.     } else {
  73. /* little-endian case */
  74. memcpy(dst, src, dstlen);
  75.     }
  76.     return dstlen;
  77. }
  79. #if defined(SCO) || defined(UNIXWARE) || defined(BSDI) || defined(FREEBSD) 
  80.     || defined(NETBSD)
  81. #include <sys/times.h>
  83. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  85. static size_t
  86. GetHighResClock(void *buf, size_t maxbytes)
  87. {
  88.     int ticks;
  89.     struct tms buffer;
  91.     ticks=times(&buffer);
  92.     return CopyLowBits(buf, maxbytes, &ticks, sizeof(ticks));
  93. }
  95. static void
  96. GiveSystemInfo(void)
  97. {
  98.     long si;
  100.     /* 
  101.      * Is this really necessary?  Why not use rand48 or something?
  102.      */
  103.     si = sysconf(_SC_CHILD_MAX);
  104.     RNG_RandomUpdate(&si, sizeof(si));
  106.     si = sysconf(_SC_STREAM_MAX);
  107.     RNG_RandomUpdate(&si, sizeof(si));
  109.     si = sysconf(_SC_OPEN_MAX);
  110.     RNG_RandomUpdate(&si, sizeof(si));
  111. }
  112. #endif
  114. #if defined(__sun)
  115. #if defined(__svr4) || defined(SVR4)
  116. #include <sys/systeminfo.h>
  117. #include <sys/times.h>
  118. #include <wait.h>
  120. int gettimeofday(struct timeval *);
  121. int gethostname(char *, int);
  123. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  125. static void
  126. GiveSystemInfo(void)
  127. {
  128.     int rv;
  129.     char buf[2000];
  131.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  132.     if (rv > 0) {
  133. RNG_RandomUpdate(buf, rv);
  134.     }
  135.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  136.     if (rv > 0) {
  137. RNG_RandomUpdate(buf, rv);
  138.     }
  139.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  140.     if (rv > 0) {
  141. RNG_RandomUpdate(buf, rv);
  142.     }
  143. }
  145. static size_t
  146. GetHighResClock(void *buf, size_t maxbytes)
  147. {
  148.     hrtime_t t;
  149.     t = gethrtime();
  150.     if (t) {
  151. return CopyLowBits(buf, maxbytes, &t, sizeof(t));
  152.     }
  153.     return 0;
  154. }
  155. #else /* SunOS (Sun, but not SVR4) */
  157. #include <sys/wait.h>
  158. extern long sysconf(int name);
  160. static size_t
  161. GetHighResClock(void *buf, size_t maxbytes)
  162. {
  163.     return 0;
  164. }
  166. static void
  167. GiveSystemInfo(void)
  168. {
  169.     long si;
  171.     /* This is not very good */
  172.     si = sysconf(_SC_CHILD_MAX);
  173.     RNG_RandomUpdate(&si, sizeof(si));
  174. }
  175. #endif
  176. #endif /* Sun */
  178. #if defined(__hpux)
  179. #include <sys/unistd.h>
  180. #include <sys/wait.h>
  182. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  184. static size_t
  185. GetHighResClock(void *buf, size_t maxbytes)
  186. {
  187.     extern int ret_cr16();
  188.     int cr16val;
  190.     cr16val = ret_cr16();
  191.     return CopyLowBits(buf, maxbytes, &cr16val, sizeof(cr16val));
  192. }
  194. static void
  195. GiveSystemInfo(void)
  196. {
  197.     long si;
  199.     /* This is not very good */
  200.     si = sysconf(_AES_OS_VERSION);
  201.     RNG_RandomUpdate(&si, sizeof(si));
  202.     si = sysconf(_SC_CPU_VERSION);
  203.     RNG_RandomUpdate(&si, sizeof(si));
  204. }
  205. #endif /* HPUX */
  207. #if defined(OSF1)
  208. #include <sys/types.h>
  209. #include <sys/sysinfo.h>
  210. #include <sys/wait.h>
  211. #include <sys/systeminfo.h>
  212. #include <c_asm.h>
  214. static void
  215. GiveSystemInfo(void)
  216. {
  217.     char buf[BUFSIZ];
  218.     int rv;
  219.     int off = 0;
  221.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  222.     if (rv > 0) {
  223. RNG_RandomUpdate(buf, rv);
  224.     }
  225.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  226.     if (rv > 0) {
  227. RNG_RandomUpdate(buf, rv);
  228.     }
  229.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  230.     if (rv > 0) {
  231. RNG_RandomUpdate(buf, rv);
  232.     }
  233. }
  235. /*
  236.  * Use the "get the cycle counter" instruction on the alpha.
  237.  * The low 32 bits completely turn over in less than a minute.
  238.  * The high 32 bits are some non-counter gunk that changes sometimes.
  239.  */
  240. static size_t
  241. GetHighResClock(void *buf, size_t maxbytes)
  242. {
  243.     unsigned long t;
  245.     t = asm("rpcc %v0");
  246.     return CopyLowBits(buf, maxbytes, &t, sizeof(t));
  247. }
  249. #endif /* Alpha */
  251. #if defined(_IBMR2)
  252. static size_t
  253. GetHighResClock(void *buf, size_t maxbytes)
  254. {
  255.     return 0;
  256. }
  258. static void
  259. GiveSystemInfo(void)
  260. {
  261.     /* XXX haven't found any yet! */
  262. }
  263. #endif /* IBM R2 */
  265. #if defined(__linux)
  266. #include <linux/kernel.h>
  268. static size_t
  269. GetHighResClock(void *buf, size_t maxbytes)
  270. {
  271.     return 0;
  272. }
  274. static void
  275. GiveSystemInfo(void)
  276. {
  277.     /* XXX sysinfo() does not seem be implemented anywhwere */
  278. #if 0
  279.     struct sysinfo si;
  280.     char hn[2000];
  281.     if (sysinfo(&si) == 0) {
  282. RNG_RandomUpdate(&si, sizeof(si));
  283.     }
  284. #endif
  285. }
  286. #endif /* __linux */
  288. #if defined(NCR)
  290. #include <sys/utsname.h>
  291. #include <sys/systeminfo.h>
  293. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  295. static size_t
  296. GetHighResClock(void *buf, size_t maxbytes)
  297. {
  298.     return 0;
  299. }
  301. static void
  302. GiveSystemInfo(void)
  303. {
  304.     int rv;
  305.     char buf[2000];
  307.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  308.     if (rv > 0) {
  309. RNG_RandomUpdate(buf, rv);
  310.     }
  311.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  312.     if (rv > 0) {
  313. RNG_RandomUpdate(buf, rv);
  314.     }
  315.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  316.     if (rv > 0) {
  317. RNG_RandomUpdate(buf, rv);
  318.     }
  319. }
  321. #endif /* NCR */
  324. #if defined(sgi)
  325. #include <fcntl.h>
  326. #undef PRIVATE
  327. #include <sys/mman.h>
  328. #include <sys/syssgi.h>
  329. #include <sys/immu.h>
  330. #include <sys/systeminfo.h>
  331. #include <sys/utsname.h>
  332. #include <wait.h>
  334. static void
  335. GiveSystemInfo(void)
  336. {
  337.     int rv;
  338.     char buf[4096];
  340.     rv = syssgi(SGI_SYSID, &buf[0]);
  341.     if (rv > 0) {
  342. RNG_RandomUpdate(buf, MAXSYSIDSIZE);
  343.     }
  344. #ifdef SGI_RDUBLK
  345.     rv = syssgi(SGI_RDUBLK, getpid(), &buf[0], sizeof(buf));
  346.     if (rv > 0) {
  347. RNG_RandomUpdate(buf, sizeof(buf));
  348.     }
  349. #endif /* SGI_RDUBLK */
  350.     rv = syssgi(SGI_INVENT, SGI_INV_READ, buf, sizeof(buf));
  351.     if (rv > 0) {
  352. RNG_RandomUpdate(buf, sizeof(buf));
  353.     }
  354.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  355.     if (rv > 0) {
  356. RNG_RandomUpdate(buf, rv);
  357.     }
  358.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  359.     if (rv > 0) {
  360. RNG_RandomUpdate(buf, rv);
  361.     }
  362.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  363.     if (rv > 0) {
  364. RNG_RandomUpdate(buf, rv);
  365.     }
  366. }
  368. static size_t GetHighResClock(void *buf, size_t maxbuf)
  369. {
  370.     unsigned phys_addr, raddr, cycleval;
  371.     static volatile unsigned *iotimer_addr = NULL;
  372.     static int tries = 0;
  373.     static int cntr_size;
  374.     int mfd;
  375.     long s0[2];
  376.     struct timeval tv;
  378. #ifndef SGI_CYCLECNTR_SIZE
  379. #define SGI_CYCLECNTR_SIZE      165     /* Size user needs to use to read CC */
  380. #endif
  382.     if (iotimer_addr == NULL) {
  383. if (tries++ > 1) {
  384.     /* Don't keep trying if it didn't work */
  385.     return 0;
  386. }
  388. /*
  389. ** For SGI machines we can use the cycle counter, if it has one,
  390. ** to generate some truly random numbers
  391. */
  392. phys_addr = syssgi(SGI_QUERY_CYCLECNTR, &cycleval);
  393. if (phys_addr) {
  394.     int pgsz = getpagesize();
  395.     int pgoffmask = pgsz - 1;
  397.     raddr = phys_addr & ~pgoffmask;
  398.     mfd = open("/dev/mmem", O_RDONLY);
  399.     if (mfd < 0) {
  400. return 0;
  401.     }
  402.     iotimer_addr = (unsigned *)
  403. mmap(0, pgoffmask, PROT_READ, MAP_PRIVATE, mfd, (int)raddr);
  404.     if (iotimer_addr == (void*)-1) {
  405. close(mfd);
  406. iotimer_addr = NULL;
  407. return 0;
  408.     }
  409.     iotimer_addr = (unsigned*)
  410. ((__psint_t)iotimer_addr | (phys_addr & pgoffmask));
  411.     /*
  412.      * The file 'mfd' is purposefully not closed.
  413.      */
  414.     cntr_size = syssgi(SGI_CYCLECNTR_SIZE);
  415.     if (cntr_size < 0) {
  416. struct utsname utsinfo;
  418. /* 
  419.  * We must be executing on a 6.0 or earlier system, since the
  420.  * SGI_CYCLECNTR_SIZE call is not supported.
  421.  * 
  422.  * The only pre-6.1 platforms with 64-bit counters are
  423.  * IP19 and IP21 (Challenge, PowerChallenge, Onyx).
  424.  */
  425. uname(&utsinfo);
  426. if (!strncmp(utsinfo.machine, "IP19", 4) ||
  427.     !strncmp(utsinfo.machine, "IP21", 4))
  428. cntr_size = 64;
  429. else
  430. cntr_size = 32;
  431.     }
  432.     cntr_size /= 8; /* Convert from bits to bytes */
  433. }
  434.     }
  436.     s0[0] = *iotimer_addr;
  437.     if (cntr_size > 4)
  438. s0[1] = *(iotimer_addr + 1);
  439.     memcpy(buf, (char *)&s0[0], cntr_size);
  440.     return CopyLowBits(buf, maxbuf, &s0, cntr_size);
  441. }
  442. #endif
  444. #if defined(sony)
  445. #include <sys/systeminfo.h>
  447. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  449. static size_t
  450. GetHighResClock(void *buf, size_t maxbytes)
  451. {
  452.     return 0;
  453. }
  455. static void
  456. GiveSystemInfo(void)
  457. {
  458.     int rv;
  459.     char buf[2000];
  461.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  462.     if (rv > 0) {
  463. RNG_RandomUpdate(buf, rv);
  464.     }
  465.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  466.     if (rv > 0) {
  467. RNG_RandomUpdate(buf, rv);
  468.     }
  469.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  470.     if (rv > 0) {
  471. RNG_RandomUpdate(buf, rv);
  472.     }
  473. }
  474. #endif /* sony */
  476. #if defined(sinix)
  477. #include <unistd.h>
  478. #include <sys/systeminfo.h>
  479. #include <sys/times.h>
  481. int gettimeofday(struct timeval *, struct timezone *);
  482. int gethostname(char *, int);
  484. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  486. static size_t
  487. GetHighResClock(void *buf, size_t maxbytes)
  488. {
  489.     int ticks;
  490.     struct tms buffer;
  492.     ticks=times(&buffer);
  493.     return CopyLowBits(buf, maxbytes, &ticks, sizeof(ticks));
  494. }
  496. static void
  497. GiveSystemInfo(void)
  498. {
  499.     int rv;
  500.     char buf[2000];
  502.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  503.     if (rv > 0) {
  504. RNG_RandomUpdate(buf, rv);
  505.     }
  506.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  507.     if (rv > 0) {
  508. RNG_RandomUpdate(buf, rv);
  509.     }
  510.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  511.     if (rv > 0) {
  512. RNG_RandomUpdate(buf, rv);
  513.     }
  514. }
  515. #endif /* sinix */
  517. #if defined(nec_ews)
  518. #include <sys/systeminfo.h>
  520. #define getdtablesize() sysconf(_SC_OPEN_MAX)
  522. static size_t
  523. GetHighResClock(void *buf, size_t maxbytes)
  524. {
  525.     return 0;
  526. }
  528. static void
  529. GiveSystemInfo(void)
  530. {
  531.     int rv;
  532.     char buf[2000];
  534.     rv = sysinfo(SI_MACHINE, buf, sizeof(buf));
  535.     if (rv > 0) {
  536. RNG_RandomUpdate(buf, rv);
  537.     }
  538.     rv = sysinfo(SI_RELEASE, buf, sizeof(buf));
  539.     if (rv > 0) {
  540. RNG_RandomUpdate(buf, rv);
  541.     }
  542.     rv = sysinfo(SI_HW_SERIAL, buf, sizeof(buf));
  543.     if (rv > 0) {
  544. RNG_RandomUpdate(buf, rv);
  545.     }
  546. }
  547. #endif /* nec_ews */
  549. size_t RNG_GetNoise(void *buf, size_t maxbytes)
  550. {
  551.     struct timeval tv;
  552.     int n = 0;
  553.     int c;
  555.     n = GetHighResClock(buf, maxbytes);
  556.     maxbytes -= n;
  558. #if defined(__sun) && (defined(_svr4) || defined(SVR4)) || defined(sony)
  559.     (void)gettimeofday(&tv);
  560. #else
  561.     (void)gettimeofday(&tv, 0);
  562. #endif
  563.     c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_usec, sizeof(tv.tv_usec));
  564.     n += c;
  565.     maxbytes -= c;
  566.     c = CopyLowBits((char*)buf+n, maxbytes, &tv.tv_sec, sizeof(tv.tv_sec));
  567.     n += c;
  568.     return n;
  569. }
  571. #define SAFE_POPEN_MAXARGS 10 /* must be at least 2 */
  573. /*
  574.  * safe_popen is static to this module and we know what arguments it is
  575.  * called with. Note that this version only supports a single open child
  576.  * process at any time.
  577.  */
  578. static pid_t safe_popen_pid;
  579. static struct sigaction oldact;
  581. static FILE *
  582. safe_popen(char *cmd)
  583. {
  584.     int p[2], fd, argc;
  585.     pid_t pid;
  586.     char *argv[SAFE_POPEN_MAXARGS + 1];
  587.     FILE *fp;
  588.     static char blank[] = " t";
  589.     static struct sigaction newact;
  591.     if (pipe(p) < 0)
  592. return 0;
  594.     /* Setup signals so that SIGCHLD is ignored as we want to do waitpid */
  595.     newact.sa_handler = SIG_DFL;
  596.     newact.sa_flags = 0;
  597.     sigfillset(&newact.sa_mask);
  598.     sigaction (SIGCHLD, &newact, &oldact);
  600.     pid = fork();
  601.     switch (pid) {
  602.       case -1:
  603. close(p[0]);
  604. close(p[1]);
  605. sigaction (SIGCHLD, &oldact, NULL);
  606. return 0;
  608.       case 0:
  609. /* dup write-side of pipe to stderr and stdout */
  610. if (p[1] != 1) dup2(p[1], 1);
  611. if (p[1] != 2) dup2(p[1], 2);
  612. close(0);
  613. for (fd = getdtablesize(); --fd > 2; close(fd))
  614.     ;
  616. /* clean up environment in the child process */
  617. putenv("PATH=/bin:/usr/bin:/sbin:/usr/sbin:/etc:/usr/etc");
  618. putenv("SHELL=/bin/sh");
  619. putenv("IFS= t");
  621. /*
  622.  * The caller may have passed us a string that is in text
  623.  * space. It may be illegal to modify the string
  624.  */
  625. cmd = strdup(cmd);
  626. /* format argv */
  627. argv[0] = strtok(cmd, blank);
  628. argc = 1;
  629. while ((argv[argc] = strtok(0, blank)) != 0) {
  630.     if (++argc == SAFE_POPEN_MAXARGS) {
  631. argv[argc] = 0;
  632. break;
  633.     }
  634. }
  636. /* and away we go */
  637. execvp(argv[0], argv);
  638. exit(127);
  639. break;
  641.       default:
  642. close(p[1]);
  643. fp = fdopen(p[0], "r");
  644. if (fp == 0) {
  645.     close(p[0]);
  646.     sigaction (SIGCHLD, &oldact, NULL);
  647.     return 0;
  648. }
  649. break;
  650.     }
  652.     /* non-zero means there's a cmd running */
  653.     safe_popen_pid = pid;
  654.     return fp;
  655. }
  657. static int
  658. safe_pclose(FILE *fp)
  659. {
  660.     pid_t pid;
  661.     int count, status;
  663.     if ((pid = safe_popen_pid) == 0)
  664. return -1;
  665.     safe_popen_pid = 0;
  667.     /* if the child hasn't exited, kill it -- we're done with its output */
  668.     count = 0;
  669.     while (waitpid(pid, &status, WNOHANG) == 0) {
  670.      if (kill(pid, SIGKILL) < 0 && errno == ESRCH)
  671.     break;
  672. if (++count == 1000)
  673.     break;
  674.     }
  676.     /* Reset SIGCHLD signal hander before returning */
  677.     sigaction(SIGCHLD, &oldact, NULL);
  679.     fclose(fp);
  680.     return status;
  681. }
  683. void RNG_SystemInfoForRNG(void)
  684. {
  685.     FILE *fp;
  686.     char buf[BUFSIZ];
  687.     size_t bytes;
  688.     extern char **environ;
  689.     char **cp;
  690.     char *randfile;
  691.     char *files[] = {
  692. "/etc/passwd",
  693. "/etc/utmp",
  694. "/tmp",
  695. "/var/tmp",
  696. "/usr/tmp",
  697. 0
  698.     };
  700. #ifdef DO_PS
  701. For now it is considered that it is too expensive to run the ps command
  702. for the small amount of entropy it provides.
  703. #if defined(__sun) && (!defined(__svr4) && !defined(SVR4)) || defined(bsdi) || defined(__linux)
  704.     static char ps_cmd[] = "ps aux";
  705. #else
  706.     static char ps_cmd[] = "ps -el";
  707. #endif
  708. #endif /* DO_PS */
  709.     static char netstat_ni_cmd[] = "netstat -ni";
  711.     GiveSystemInfo();
  713.     bytes = RNG_GetNoise(buf, sizeof(buf));
  714.     RNG_RandomUpdate(buf, bytes);
  716. #ifdef DO_PS
  717.     fp = safe_popen(ps_cmd);
  718.     if (fp != NULL) {
  719. while ((bytes = fread(buf, 1, sizeof(buf), fp)) > 0)
  720.     RNG_RandomUpdate(buf, bytes);
  721. safe_pclose(fp);
  722.     }
  723. #endif
  724.     fp = safe_popen(netstat_ni_cmd);
  725.     if (fp != NULL) {
  726. while ((bytes = fread(buf, 1, sizeof(buf), fp)) > 0)
  727.     RNG_RandomUpdate(buf, bytes);
  728. safe_pclose(fp);
  729.     }
  731.     /*
  732.      * Pass the C environment and the addresses of the pointers to the
  733.      * hash function. This makes the random number function depend on the
  734.      * execution environment of the user and on the platform the program
  735.      * is running on.
  736.      */
  737.     cp = environ;
  738.     while (*cp) {
  739. RNG_RandomUpdate(*cp, strlen(*cp));
  740. cp++;
  741.     }
  742.     RNG_RandomUpdate(environ, (char*)cp - (char*)environ);
  744.     /* Give in system information */
  745.     if (gethostname(buf, sizeof(buf)) > 0) {
  746. RNG_RandomUpdate(buf, strlen(buf));
  747.     }
  748.     GiveSystemInfo();
  750.     /* If the user points us to a random file, pass it through the rng */
  751.     randfile = getenv("NSRANDFILE");
  752.     if ( ( randfile != NULL ) && ( randfile[0] != '') ) {
  753. RNG_FileForRNG(randfile);
  754.     }
  756.     /* pass other files through */
  757.     for (cp = files; *cp; cp++)
  758. RNG_FileForRNG(*cp);
  760. }
  762. void RNG_FileForRNG(char *fileName)
  763. {
  764.     struct stat stat_buf;
  765.     unsigned char buffer[BUFSIZ];
  766.     size_t bytes;
  767.     FILE *file;
  768.     static size_t totalFileBytes = 0;
  769.     
  770.     if (stat((char *)fileName, &stat_buf) < 0)
  771. return;
  772.     RNG_RandomUpdate(&stat_buf, sizeof(stat_buf));
  773.     
  774.     file = fopen((char *)fileName, "r");
  775.     if (file != NULL) {
  776. for (;;) {
  777.     bytes = fread(buffer, 1, sizeof(buffer), file);
  778.     if (bytes == 0) break;
  779.     RNG_RandomUpdate(buffer, bytes);
  780.     totalFileBytes += bytes;
  781.     if (totalFileBytes > 1024*1024) break;
  782. }
  783. fclose(file);
  784.     }
  785.     /*
  786.      * Pass yet another snapshot of our highest resolution clock into
  787.      * the hash function.
  788.      */
  789.     bytes = RNG_GetNoise(buffer, sizeof(buffer));
  790.     RNG_RandomUpdate(buffer, bytes);
  791. }