📄 rndunix.c
字号:
/****************************************************************************
* *
* Unix Randomness-Gathering Code *
* Copyright Peter Gutmann, Paul Kendall, and Chris Wedgwood 1996-2001 *
* *
****************************************************************************/
/* This module is part of the cryptlib continuously seeded pseudorandom
number generator. For usage conditions, see lib_rand.c */
/* General includes */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "crypt.h"
/* OS-specific includes */
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <pwd.h>
#ifndef __QNX__
#include <sys/errno.h>
#include <sys/ipc.h>
#endif /* __QNX__ */
#include <sys/time.h> /* SCO and SunOS need this before resource.h */
#ifndef __QNX__
#include <sys/resource.h>
#endif /* __QNX__ */
#ifdef _AIX
#include <sys/select.h>
#include <sys/systemcfg.h>
#endif /* _AIX */
#ifndef __QNX__
#include <sys/shm.h>
#include <sys/signal.h>
#endif /* __QNX__ */
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h> /* Verschiedene komische Typen */
#include <sys/un.h>
#if defined( __hpux ) && ( OS_VERSION == 9 )
#include <vfork.h>
#endif /* __hpux 9.x, after that it's in unistd.h */
#include <sys/wait.h>
/* #include <kitchensink.h> */
/* The size of the intermediate buffer used to accumulate polled data */
#define RANDOM_BUFSIZE 4096
/* The structure containing information on random-data sources. Each record
contains the source and a relative estimate of its usefulness (weighting)
which is used to scale the number of kB of output from the source (total =
data_bytes / usefulness). Usually the weighting is in the range 1-3 (or 0
for especially useless sources), resulting in a usefulness rating of 1...3
for each kB of source output (or 0 for the useless sources).
If the source is constantly changing (certain types of network statistics
have this characteristic) but the amount of output is small, the weighting
is given as a negative value to indicate that the output should be treated
as if a minimum of 1K of output had been obtained. If the source produces
a lot of output then the scale factor is fractional, resulting in a
usefulness rating of < 1 for each kB of source output.
In order to provide enough randomness to satisfy the requirements for a
slow poll, we need to accumulate at least 20 points of usefulness (a
typical system should get about 30 points).
Some potential options are missed out because of special considerations.
pstat -i and pstat -f can produce amazing amounts of output (the record is
600K on an Oracle server) which floods the buffer and doesn't yield
anything useful (apart from perhaps increasing the entropy of the vmstat
output a bit), so we don't bother with this. pstat in general produces
quite a bit of output, but it doesn't change much over time, so it gets
very low weightings. netstat -s produces constantly-changing output but
also produces quite a bit of it, so it only gets a weighting of 2 rather
than 3. The same holds for netstat -in, which gets 1 rather than 2.
Some binaries are stored in different locations on different systems so
alternative paths are given for them. The code sorts out which one to run
by itself, once it finds an exectable somewhere it moves on to the next
source. The sources are arranged roughly in their order of usefulness,
occasionally sources which provide a tiny amount of relatively useless
data are placed ahead of ones which provide a large amount of possibly
useful data because another 100 bytes can't hurt, and it means the buffer
won't be swamped by one or two high-output sources. All the high-output
sources are clustered towards the end of the list for this reason. Some
binaries are checked for in a certain order, for example under Slowaris
/usr/ucb/ps understands aux as an arg, but the others don't. Some systems
have conditional defines enabling alternatives to commands which don't
understand the usual options but will provide enough output (in the form
of error messages) to look like they're the real thing, causing
alternative options to be skipped (we can't check the return either
because some commands return peculiar, non-zero status even when they're
working correctly).
In order to maximise use of the buffer, the code performs a form of run-
length compression on its input where a repeated sequence of bytes is
replaced by the occurrence count mod 256. Some commands output an awful
lot of whitespace, this measure greatly increases the amount of data we
can fit in the buffer.
When we scale the weighting using the SC() macro, some preprocessors may
give a division by zero warning for the most obvious expression 'weight ?
1024 / weight : 0' (and gcc 2.7.2.2 dies with a division by zero trap), so
we define a value SC_0 which evaluates to zero when fed to '1024 / SC_0' */
#define SC( weight ) ( 1024 / weight ) /* Scale factor */
#define SC_0 16384 /* SC( SC_0 ) evalutes to 0 */
static struct RI {
const char *path; /* Path to check for existence of source */
const char *arg; /* Args for source */
const int usefulness; /* Usefulness of source */
FILE *pipe; /* Pipe to source as FILE * */
int pipeFD; /* Pipe to source as FD */
pid_t pid; /* pid of child for waitpid() */
int length; /* Quantity of output produced */
const BOOLEAN hasAlternative; /* Whether source has alt.location */
} dataSources[] = {
{ "/bin/vmstat", "-s", SC( -3 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/vmstat", "-s", SC( -3 ), NULL, 0, 0, 0, FALSE },
{ "/bin/vmstat", "-c", SC( -3 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/vmstat", "-c", SC( -3 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/pfstat", NULL, SC( -2 ), NULL, 0, 0, 0, FALSE },
{ "/bin/vmstat", "-i", SC( -2 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/vmstat", "-i", SC( -2 ), NULL, 0, 0, 0, FALSE },
{ "/usr/ucb/netstat", "-s", SC( 2 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/netstat", "-s", SC( 2 ), NULL, 0, 0, 0, TRUE },
{ "/usr/sbin/netstat", "-s", SC( 2 ), NULL, 0, 0, 0, TRUE },
{ "/bin/netstat", "-s", SC( 2 ), NULL, 0, 0, 0, TRUE },
{ "/usr/etc/netstat", "-s", SC( 2 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/nfsstat", NULL, SC( 2 ), NULL, 0, 0, 0, FALSE },
{ "/usr/ucb/netstat", "-m", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/netstat", "-m", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/sbin/netstat", "-m", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/bin/netstat", "-m", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/etc/netstat", "-m", SC( -1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/ucb/netstat", "-in", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/netstat", "-in", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/sbin/netstat", "-in", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/bin/netstat", "-in", SC( -1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/etc/netstat", "-in", SC( -1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/ntptrace", "-r2 -t1 -nv", SC( -1 ), NULL, 0, 0, 0, FALSE },
#ifndef __SCO_VERSION__
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.7.1.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* UDP in */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.7.4.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* UDP out */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.4.3.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* IP ? */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.10.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* TCP ? */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.11.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* TCP ? */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.6.13.0", SC( -1 ), NULL, 0, 0, 0, FALSE }, /* TCP ? */
#else
{ "/usr/sbin/snmpstat", "-an localhost public", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/snmpstat", "-in localhost public", SC( SC_0 ), NULL, 0, 0, 0, FALSE }, /* Subset of netstat info */
{ "/usr/sbin/snmpstat", "-Sn localhost public", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
#endif /* SCO/UnixWare vs everything else */
{ "/usr/bin/mpstat", NULL, SC( 1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/w", NULL, SC( 1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bsd/w", NULL, SC( 1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/df", NULL, SC( 1 ), NULL, 0, 0, 0, TRUE },
{ "/bin/df", NULL, SC( 1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/portstat", NULL, SC( 1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/iostat", NULL, SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/uptime", NULL, SC( SC_0 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bsd/uptime", NULL, SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/bin/vmstat", "-f", SC( SC_0 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/vmstat", "-f", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/bin/vmstat", NULL, SC( SC_0 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/vmstat", NULL, SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/ucb/netstat", "-n", SC( 0.5 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/netstat", "-n", SC( 0.5 ), NULL, 0, 0, 0, TRUE },
{ "/usr/sbin/netstat", "-n", SC( 0.5) , NULL, 0, 0, 0, TRUE },
{ "/bin/netstat", "-n", SC( 0.5) , NULL, 0, 0, 0, TRUE },
{ "/usr/etc/netstat", "-n", SC( 0.5) , NULL, 0, 0, 0, FALSE },
#if defined( __sgi ) || defined( __hpux )
{ "/bin/ps", "-el", SC( 0.3 ), NULL, 0, 0, 0, TRUE },
#endif /* SGI || PHUX */
{ "/usr/ucb/ps", "aux", SC( 0.3 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/ps", "aux", SC( 0.3 ), NULL, 0, 0, 0, TRUE },
{ "/bin/ps", "aux", SC( 0.3 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/ipcs", "-a", SC( 0.5 ), NULL, 0, 0, 0, TRUE },
{ "/bin/ipcs", "-a", SC( 0.5 ), NULL, 0, 0, 0, FALSE },
/* Unreliable source, depends on system usage */
{ "/etc/pstat", "-p", SC( 0.5 ), NULL, 0, 0, 0, TRUE },
{ "/bin/pstat", "-p", SC( 0.5 ), NULL, 0, 0, 0, FALSE },
{ "/etc/pstat", "-S", SC( 0.2 ), NULL, 0, 0, 0, TRUE },
{ "/bin/pstat", "-S", SC( 0.2 ), NULL, 0, 0, 0, FALSE },
{ "/etc/pstat", "-v", SC( 0.2 ), NULL, 0, 0, 0, TRUE },
{ "/bin/pstat", "-v", SC( 0.2 ), NULL, 0, 0, 0, FALSE },
{ "/etc/pstat", "-x", SC( 0.2 ), NULL, 0, 0, 0, TRUE },
{ "/bin/pstat", "-x", SC( 0.2 ), NULL, 0, 0, 0, FALSE },
{ "/etc/pstat", "-t", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/bin/pstat", "-t", SC( 0.1 ), NULL, 0, 0, 0, FALSE },
/* pstat is your friend */
#ifndef __SCO_VERSION__
{ "/usr/sbin/sar", "-AR", SC( 0.05 ), NULL, 0, 0, 0, FALSE }, /* Only updated hourly */
#endif /* SCO/UnixWare */
{ "/usr/bin/last", "-n 50", SC( 0.3 ), NULL, 0, 0, 0, TRUE },
#ifdef __sgi
{ "/usr/bsd/last", "-50", SC( 0.3 ), NULL, 0, 0, 0, FALSE },
#endif /* SGI */
#ifdef __hpux
{ "/etc/last", "-50", SC( 0.3 ), NULL, 0, 0, 0, FALSE },
#endif /* PHUX */
{ "/usr/bsd/last", "-n 50", SC( 0.3 ), NULL, 0, 0, 0, FALSE },
#ifdef sun
{ "/usr/bin/showrev", "-a", SC( 0.1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/swap", "-l", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/prtconf", "-v", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
#endif /* SunOS/Slowaris */
{ "/usr/sbin/psrinfo", NULL, SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/local/bin/lsof", "-lnwP", SC( 0.3 ), NULL, 0, 0, 0, FALSE },
/* Output is very system and version-dependent */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.5.1.0", SC( 0.1 ), NULL, 0, 0, 0, FALSE }, /* ICMP ? */
{ "/usr/sbin/snmp_request", "localhost public get 1.3.6.1.2.1.5.3.0", SC( 0.1 ), NULL, 0, 0, 0, FALSE }, /* ICMP ? */
{ "/etc/arp", "-a", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/etc/arp", "-a", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/arp", "-a", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/sbin/arp", "-a", SC( 0.1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/ripquery", "-nw 1 127.0.0.1", SC( 0.1 ), NULL, 0, 0, 0, FALSE },
{ "/bin/lpstat", "-t", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/bin/lpstat", "-t", SC( 0.1 ), NULL, 0, 0, 0, TRUE },
{ "/usr/ucb/lpstat", "-t", SC( 0.1 ), NULL, 0, 0, 0, FALSE },
{ "/usr/bin/tcpdump", "-c 5 -efvvx", SC( 1 ), NULL, 0, 0, 0, FALSE },
/* This is very environment-dependant. If
network traffic is low, it'll probably time
out before delivering 5 packets, which is OK
because it'll probably be fixed stuff like ARP
anyway */
{ "/usr/sbin/advfsstat", "-b usr_domain", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/advfsstat", "-l 2 usr_domain", SC( 0.5 ), NULL, 0, 0, 0, FALSE },
{ "/usr/sbin/advfsstat", "-p usr_domain", SC( SC_0 ), NULL, 0, 0, 0, FALSE },
/* This is a complex and screwball program. Some
systems have things like rX_dmn, x = integer,
for RAID systems, but the statistics are
pretty dodgy */
#if 0
/* The following aren't enabled since they're somewhat slow and not very
unpredictable, however they give an indication of the sort of sources
you can use (for example the finger might be more useful on a
firewalled internal network) */
{ "/usr/bin/finger", "@ml.media.mit.edu", SC( 0.9 ), NULL, 0, 0, 0, FALSE },
{ "/usr/local/bin/wget", "-O - http://lavarand.sgi.com/block.html", SC( 0.9 ), NULL, 0, 0, 0, FALSE },
{ "/bin/cat", "/usr/spool/mqueue/syslog", SC( 0.9 ), NULL, 0, 0, 0, FALSE },
#endif /* 0 */
{ NULL, NULL, 0, NULL, 0, 0, 0, FALSE } };
/* Variables to manage the child process which fills the buffer */
static pid_t gathererProcess = 0;/* The child process which fills the buffer */
static BYTE *gathererBuffer; /* Shared buffer for gathering random noise */
static int gathererMemID; /* ID for shared memory */
static int gathererBufSize; /* Size of the shared memory buffer */
static uid_t gathererID = ( uid_t ) -1; /* Gatherers user ID */
/* The struct at the start of the shared memory buffer used to communicate
information from the child to the parent */
typedef struct {
int usefulness; /* Usefulness of data in buffer */
int noBytes; /* No.of bytes in buffer */
} GATHERER_INFO;
/* Under SunOS popen() doesn't record the pid of the child process. When
pclose() is called, instead of calling waitpid() for the correct child, it
calls wait() repeatedly until the right child is reaped. The problem is
that this reaps any other children that happen to have died at that
moment, and when their pclose() comes along, the process hangs forever.
The fix is to use a wrapper for popen()/pclose() which saves the pid in
the dataSources structure (code adapted from GNU-libc's popen() call).
Aut viam inveniam aut faciam */
static FILE *my_popen( struct RI *entry )
{
int pipedes[ 2 ];
FILE *stream;
/* Create the pipe */
if( pipe( pipedes ) < 0 )
return( NULL );
/* Fork off the child ("vfork() is like an OS orgasm. All OS's want to
do it, but most just end up faking it" - Chris Wedgwood). If your OS
supports it, you should try to use vfork() here because it's somewhat
more efficient */
#if defined( sun ) || defined( __ultrix__ ) || defined( __osf__ ) || \
defined( __hpux )
entry->pid = vfork();
#else
entry->pid = fork();
#endif /* Unixen which have vfork() */
if( entry->pid == ( pid_t ) -1 )
{
/* The fork failed */
close( pipedes[ 0 ] );
close( pipedes[ 1 ] );
return( NULL );
}
if( entry->pid == ( pid_t ) 0 )
{
struct passwd *passwd;
/* We are the child. Make the read side of the pipe be stdout */
if( dup2( pipedes[ STDOUT_FILENO ], STDOUT_FILENO ) < 0 )
exit( 127 );
/* Now that everything is set up, give up our permissions to make
sure we don't read anything sensitive. If the getpwnam() fails,
we default to -1, which is usually nobody */
if( gathererID == ( uid_t ) -1 && \
( passwd = getpwnam( "nobody" ) ) != NULL )
gathererID = passwd->pw_uid;
setuid( gathererID );
/* Close the pipe descriptors */
close( pipedes[ STDIN_FILENO ] );
close( pipedes[ STDOUT_FILENO ] );
/* Try and exec the program */
execl( entry->path, entry->path, entry->arg, NULL );
/* Die if the exec failed */
exit( 127 );
}
/* We are the parent. Close the irrelevant side of the pipe and open the
relevant side as a new stream. Mark our side of the pipe to close on
exec, so new children won't see it */
close( pipedes[ STDOUT_FILENO ] );
fcntl( pipedes[ STDIN_FILENO ], F_SETFD, FD_CLOEXEC );
stream = fdopen( pipedes[ STDIN_FILENO ], "r" );
if( stream == NULL )
{
int savedErrno = errno;
/* The stream couldn't be opened or the child structure couldn't be
allocated. Kill the child and close the other side of the pipe */
kill( entry->pid, SIGKILL );
if( stream == NULL )
close( pipedes[ STDOUT_FILENO ] );
else
fclose( stream );
waitpid( entry->pid, NULL, 0 );
entry->pid = 0;
errno = savedErrno;
return( NULL );
}
return( stream );
}
static int my_pclose( struct RI *entry )
{
int status = 0;
if( fclose( entry->pipe ) )
return( -1 );
/* We ignore the return value from the process because some programs
return funny values which would result in the input being discarded
even if they executed successfully. This isn't a problem because the
result data size threshold will filter out any programs which exit
with a usage message without producing useful output */
if( waitpid( entry->pid, NULL, 0 ) != entry->pid )
status = -1;
entry->pipe = NULL;
entry->pid = 0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -