int random_byte(void)
{
#ifdef MPEXT
int pos = pool.poolpos;
if (pos < sizeof(pool.incoming) || pos >= POOLSIZE)
{
EnterCriticalSection(&noise_section);
if (pool.poolpos >= POOLSIZE)
{
random_stir();
}
pos = pool.poolpos;
pool.poolpos++;
LeaveCriticalSection(&noise_section);
}
else
{
pool.poolpos++;
}
return pool.pool[pos];
#else
if (pool.poolpos >= POOLSIZE)
random_stir();
return pool.pool[pool.poolpos++];
#endif
}
int random_byte(void)
{
#ifdef MPEXT
int pos;
assert(random_active);
pos = pool.poolpos;
if (pos < sizeof(pool.incoming) || pos >= POOLSIZE)
{
MPEXT_PUTTY_SECTION_ENTER;
if (pool.poolpos >= POOLSIZE)
{
random_stir();
}
pos = pool.poolpos;
pool.poolpos++;
MPEXT_PUTTY_SECTION_LEAVE;
}
else
{
pool.poolpos++;
}
return pool.pool[pos];
#else
assert(random_active);
if (pool.poolpos >= POOLSIZE)
random_stir();
return pool.pool[pool.poolpos++];
#endif
}
void random_get_savedata(void **data, int *len)
{
void *buf = snewn(POOLSIZE / 2, char);
random_stir();
memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);
*len = POOLSIZE / 2;
*data = buf;
random_stir();
}
void random_get_savedata(void **data, int *len)
{
void *buf = snewn(POOLSIZE / 2, char);
MPEXT_PUTTY_SECTION_ENTER;
random_stir();
memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);
*len = POOLSIZE / 2;
*data = buf;
random_stir();
MPEXT_PUTTY_SECTION_LEAVE;
}
void random_get_savedata(void **data, int *len)
{
void *buf = snewn(POOLSIZE / 2, char);
#ifdef MPEXT
EnterCriticalSection(&noise_section);
#endif
random_stir();
memcpy(buf, pool.pool + pool.poolpos, POOLSIZE / 2);
*len = POOLSIZE / 2;
*data = buf;
random_stir();
#ifdef MPEXT
LeaveCriticalSection(&noise_section);
#endif
}
int random_byte(void)
{
if (pool.poolpos >= POOLSIZE)
random_stir();
return pool.pool[pool.poolpos++];
}
void random_add_heavynoise(void *noise, int length)
{
unsigned char *p = noise;
int i;
while (length >= POOLSIZE) {
for (i = 0; i < POOLSIZE; i++)
pool.pool[i] ^= *p++;
random_stir();
length -= POOLSIZE;
}
for (i = 0; i < length; i++)
pool.pool[i] ^= *p++;
random_stir();
}
void random_add_noise(void *noise, int length)
{
unsigned char *p = noise;
int i;
if (!random_active)
return;
/*
* This function processes HASHINPUT bytes into only HASHSIZE
* bytes, so _if_ we were getting incredibly high entropy
* sources then we would be throwing away valuable stuff.
*/
while (length >= (HASHINPUT - pool.incomingpos)) {
memcpy(pool.incomingb + pool.incomingpos, p,
HASHINPUT - pool.incomingpos);
p += HASHINPUT - pool.incomingpos;
length -= HASHINPUT - pool.incomingpos;
SHATransform((word32 *) pool.incoming, (word32 *) pool.incomingb);
for (i = 0; i < HASHSIZE; i++) {
pool.pool[pool.poolpos++] ^= pool.incomingb[i];
if (pool.poolpos >= POOLSIZE)
pool.poolpos = 0;
}
if (pool.poolpos < HASHSIZE)
random_stir();
pool.incomingpos = 0;
}
memcpy(pool.incomingb + pool.incomingpos, p, length);
pool.incomingpos += length;
}
void random_init(void)
{
memset(&pool, 0, sizeof(pool)); /* just to start with */
random_active = 1;
noise_get_heavy(random_add_heavynoise_bitbybit);
random_stir();
}
int random_byte(void)
{
#ifndef RECONNECTPORT
assert(random_active);
#endif
if (pool.poolpos >= POOLSIZE)
random_stir();
return pool.pool[pool.poolpos++];
}
void random_ref(void)
{
if (!random_active) {
memset(&pool, 0, sizeof(pool)); /* just to start with */
noise_get_heavy(random_add_heavynoise_bitbybit);
random_stir();
//next_noise_collection = schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
}
random_active++;
}
void random_init(void) {
memset(&pool, 0, sizeof(pool)); /* just to start with */
/*
* For noise_get_heavy, we temporarily use `poolpos' as the
* pointer for addition of noise, rather than extraction of
* random numbers.
*/
pool.poolpos = 0;
noise_get_heavy(random_add_heavynoise);
random_stir();
}
static void random_add_heavynoise(void *noise, int length) {
unsigned char *p = noise;
while (length >= (POOLSIZE - pool.poolpos)) {
memcpy(pool.pool + pool.poolpos, p, POOLSIZE - pool.poolpos);
p += POOLSIZE - pool.poolpos;
length -= POOLSIZE - pool.poolpos;
random_stir();
pool.poolpos = 0;
}
memcpy(pool.pool + pool.poolpos, p, length);
pool.poolpos += length;
}
static void random_add_heavynoise_bitbybit(void *noise, int length)
{
unsigned char *p = noise;
int i;
while (length >= POOLSIZE - pool.poolpos) {
for (i = 0; i < POOLSIZE - pool.poolpos; i++)
pool.pool[pool.poolpos + i] ^= *p++;
random_stir();
length -= POOLSIZE - pool.poolpos;
pool.poolpos = 0;
}
for (i = 0; i < length; i++)
pool.pool[i] ^= *p++;
pool.poolpos = i;
}
void random_add_noise(RandomState * state, const void *buf, unsigned int bytes)
{
unsigned int pos = state->add_position;
const char *input = buf;
while (bytes > 0) {
if (pos >= RANDOM_STATE_BYTES) {
pos = 0;
random_stir(state);
}
state->state[pos] ^= *input;
input++;
bytes--;
pos++;
}
state->add_position = pos;
}
void random_ref(void)
{
if (!random_active) {
#ifdef MPEXT
InitializeCriticalSection(&noise_section);
#endif
memset(&pool, 0, sizeof(pool)); /* just to start with */
noise_get_heavy(random_add_heavynoise_bitbybit);
random_stir();
next_noise_collection =
schedule_timer(NOISE_REGULAR_INTERVAL, random_timer, &pool);
}
#ifdef MPEXT
EnterCriticalSection(&noise_section);
#endif
random_active++;
#ifdef MPEXT
LeaveCriticalSection(&noise_section);
#endif
}
void random_get_savedata(void **data, int *len)
{
random_stir();
*data = pool.pool + pool.poolpos;
*len = POOLSIZE / 2;
}
static void
random_timer ()
{
random_stir ();
timecb (time (NULL) + 1800 + rnd.getword () % 1800, wrap (random_timer));
}
void random_acquire_light_environmental_noise(RandomState * state)
{
int f;
char buf[32];
int len;
/* Stir first to make all bits depend on all other bits (some of
them not revealed to callers). */
random_stir(state);
/* About every five minutes, mix in some noise from /dev/random. */
if (time(NULL) - state->last_dev_random_usage > 5 * 60) {
state->last_dev_random_usage = time(NULL);
/* If /dev/random is available, read some data from there in non-blocking
mode and mix it into the pool. */
f = open("/dev/random", O_RDONLY);
if (f >= 0) {
/* Set the descriptor into non-blocking mode. */
#if defined(O_NONBLOCK) && !defined(O_NONBLOCK_BROKEN)
fcntl(f, F_SETFL, O_NONBLOCK);
#else /* O_NONBLOCK && !O_NONBLOCK_BROKEN */
fcntl(f, F_SETFL, O_NDELAY);
#endif /* O_NONBLOCK && !O_NONBLOCK_BROKEN */
len = read(f, buf, sizeof(buf));
close(f);
if (len > 0)
random_add_noise(state, buf, len);
}
}
/* Get miscellaneous noise from various system parameters and statistics. */
random_xor_noise(state, (unsigned int) (state->state[0] + 256 * state->state[1]) % (RANDOM_STATE_BYTES / 4), (word32) time(NULL));
#ifdef HAVE_GETTIMEOFDAY
{
struct timeval tv;
#ifdef HAVE_NO_TZ_IN_GETTIMEOFDAY
gettimeofday(&tv);
#else
gettimeofday(&tv, NULL);
#endif
random_xor_noise(state, 0, (word32) tv.tv_usec);
random_xor_noise(state, 1, (word32) tv.tv_sec);
#ifdef HAVE_CLOCK
random_xor_noise(state, 3, (word32) clock());
#endif /* HAVE_CLOCK */
}
#endif /* HAVE_GETTIMEOFDAY */
#ifdef HAVE_TIMES
{
struct tms tm;
random_xor_noise(state, 2, (word32) times(&tm));
random_xor_noise(state, 4, (word32) (tm.tms_utime ^ (tm.tms_stime << 8) ^ (tm.tms_cutime << 16) ^ (tm.tms_cstime << 24)));
}
#endif /* HAVE_TIMES */
#ifdef HAVE_GETRUSAGE
{
struct rusage ru, cru;
getrusage(RUSAGE_SELF, &ru);
getrusage(RUSAGE_CHILDREN, &cru);
random_xor_noise(state, 0, (word32) (ru.ru_utime.tv_usec + cru.ru_utime.tv_usec));
random_xor_noise(state, 2, (word32) (ru.ru_stime.tv_usec + cru.ru_stime.tv_usec));
random_xor_noise(state, 5, (word32) (ru.ru_maxrss + cru.ru_maxrss));
random_xor_noise(state, 6, (word32) (ru.ru_ixrss + cru.ru_ixrss));
random_xor_noise(state, 7, (word32) (ru.ru_idrss + cru.ru_idrss));
random_xor_noise(state, 8, (word32) (ru.ru_minflt + cru.ru_minflt));
random_xor_noise(state, 9, (word32) (ru.ru_majflt + cru.ru_majflt));
random_xor_noise(state, 10, (word32) (ru.ru_nswap + cru.ru_nswap));
random_xor_noise(state, 11, (word32) (ru.ru_inblock + cru.ru_inblock));
random_xor_noise(state, 12, (word32) (ru.ru_oublock + cru.ru_oublock));
random_xor_noise(state, 13, (word32) ((ru.ru_msgsnd ^ ru.ru_msgrcv ^ ru.ru_nsignals) + (cru.ru_msgsnd ^ cru.ru_msgrcv ^ cru.ru_nsignals)));
random_xor_noise(state, 14, (word32) (ru.ru_nvcsw + cru.ru_nvcsw));
random_xor_noise(state, 15, (word32) (ru.ru_nivcsw + cru.ru_nivcsw));
}
#endif /* HAVE_GETRUSAGE */
random_xor_noise(state, 11, (word32) getpid());
random_xor_noise(state, 12, (word32) getppid());
random_xor_noise(state, 10, (word32) getuid());
random_xor_noise(state, 10, (word32) (getgid() << 16));
#ifdef _POSIX_CHILD_MAX
random_xor_noise(state, 13, (word32) (_POSIX_CHILD_MAX << 16));
#endif /* _POSIX_CHILD_MAX */
#ifdef CLK_TCK
random_xor_noise(state, 14, (word32) (CLK_TCK << 16));
#endif /* CLK_TCK */
random_stir(state);
}
