1997-06-14 01:15:41 +00:00
|
|
|
/*
|
|
|
|
* Arc4 random number generator for OpenBSD.
|
|
|
|
* Copyright 1996 David Mazieres <dm@lcs.mit.edu>.
|
|
|
|
*
|
|
|
|
* Modification and redistribution in source and binary forms is
|
|
|
|
* permitted provided that due credit is given to the author and the
|
|
|
|
* OpenBSD project (for instance by leaving this copyright notice
|
|
|
|
* intact).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This code is derived from section 17.1 of Applied Cryptography,
|
|
|
|
* second edition, which describes a stream cipher allegedly
|
|
|
|
* compatible with RSA Labs "RC4" cipher (the actual description of
|
|
|
|
* which is a trade secret). The same algorithm is used as a stream
|
|
|
|
* cipher called "arcfour" in Tatu Ylonen's ssh package.
|
|
|
|
*
|
|
|
|
* Here the stream cipher has been modified always to include the time
|
|
|
|
* when initializing the state. That makes it impossible to
|
|
|
|
* regenerate the same random sequence twice, so this can't be used
|
|
|
|
* for encryption, but will generate good random numbers.
|
|
|
|
*
|
|
|
|
* RC4 is a registered trademark of RSA Laboratories.
|
|
|
|
*/
|
|
|
|
|
2002-03-22 21:53:29 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2001-01-24 13:01:12 +00:00
|
|
|
#include "namespace.h"
|
2002-03-22 21:53:29 +00:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/time.h>
|
1997-06-14 01:15:41 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2004-03-24 14:44:57 +00:00
|
|
|
#include <pthread.h>
|
|
|
|
|
|
|
|
#include "libc_private.h"
|
2001-01-24 13:01:12 +00:00
|
|
|
#include "un-namespace.h"
|
1997-06-14 01:15:41 +00:00
|
|
|
|
|
|
|
struct arc4_stream {
|
|
|
|
u_int8_t i;
|
|
|
|
u_int8_t j;
|
|
|
|
u_int8_t s[256];
|
|
|
|
};
|
|
|
|
|
2004-03-24 14:44:57 +00:00
|
|
|
static pthread_mutex_t arc4random_mtx = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
|
|
|
|
#define RANDOMDEV "/dev/urandom"
|
|
|
|
#define THREAD_LOCK() \
|
|
|
|
do { \
|
|
|
|
if (__isthreaded) \
|
|
|
|
_pthread_mutex_lock(&arc4random_mtx); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define THREAD_UNLOCK() \
|
|
|
|
do { \
|
|
|
|
if (__isthreaded) \
|
|
|
|
_pthread_mutex_unlock(&arc4random_mtx); \
|
|
|
|
} while (0)
|
|
|
|
|
1997-06-14 01:15:41 +00:00
|
|
|
static struct arc4_stream rs;
|
2004-03-24 14:44:57 +00:00
|
|
|
static int rs_initialized;
|
|
|
|
static int rs_stired;
|
2006-10-04 01:17:23 +00:00
|
|
|
static int arc4_count;
|
1997-06-14 01:15:41 +00:00
|
|
|
|
2004-01-20 04:22:47 +00:00
|
|
|
static inline u_int8_t arc4_getbyte(struct arc4_stream *);
|
2004-03-24 14:44:57 +00:00
|
|
|
static void arc4_stir(struct arc4_stream *);
|
2004-01-20 04:22:47 +00:00
|
|
|
|
1997-06-14 01:15:41 +00:00
|
|
|
static inline void
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4_init(struct arc4_stream *as)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
for (n = 0; n < 256; n++)
|
|
|
|
as->s[n] = n;
|
|
|
|
as->i = 0;
|
|
|
|
as->j = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4_addrandom(struct arc4_stream *as, u_char *dat, int datlen)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
u_int8_t si;
|
|
|
|
|
|
|
|
as->i--;
|
|
|
|
for (n = 0; n < 256; n++) {
|
|
|
|
as->i = (as->i + 1);
|
|
|
|
si = as->s[as->i];
|
|
|
|
as->j = (as->j + si + dat[n % datlen]);
|
|
|
|
as->s[as->i] = as->s[as->j];
|
|
|
|
as->s[as->j] = si;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4_stir(struct arc4_stream *as)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
2004-01-20 04:22:47 +00:00
|
|
|
int fd, n;
|
1997-06-14 01:15:41 +00:00
|
|
|
struct {
|
|
|
|
struct timeval tv;
|
|
|
|
pid_t pid;
|
|
|
|
u_int8_t rnd[128 - sizeof(struct timeval) - sizeof(pid_t)];
|
|
|
|
} rdat;
|
|
|
|
|
|
|
|
gettimeofday(&rdat.tv, NULL);
|
|
|
|
rdat.pid = getpid();
|
2004-03-24 14:44:57 +00:00
|
|
|
fd = _open(RANDOMDEV, O_RDONLY, 0);
|
1997-06-14 01:15:41 +00:00
|
|
|
if (fd >= 0) {
|
Simplify sytem call renaming. Instead of _foo() <-- _libc_foo <-- foo(),
just use _foo() <-- foo(). In the case of a libpthread that doesn't do
call conversion (such as linuxthreads and our upcoming libpthread), this
is adequate. In the case of libc_r, we still need three names, which are
now _thread_sys_foo() <-- _foo() <-- foo().
Convert all internal libc usage of: aio_suspend(), close(), fsync(), msync(),
nanosleep(), open(), fcntl(), read(), and write() to _foo() instead of foo().
Remove all internal libc usage of: creat(), pause(), sleep(), system(),
tcdrain(), wait(), and waitpid().
Make thread cancellation fully POSIX-compliant.
Suggested by: deischen
2000-01-27 23:07:25 +00:00
|
|
|
(void) _read(fd, rdat.rnd, sizeof(rdat.rnd));
|
|
|
|
_close(fd);
|
2004-03-24 14:44:57 +00:00
|
|
|
}
|
1997-06-14 01:15:41 +00:00
|
|
|
/* fd < 0? Ah, what the heck. We'll just take whatever was on the
|
|
|
|
* stack... */
|
|
|
|
|
|
|
|
arc4_addrandom(as, (void *) &rdat, sizeof(rdat));
|
2004-01-20 04:22:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Throw away the first N bytes of output, as suggested in the
|
|
|
|
* paper "Weaknesses in the Key Scheduling Algorithm of RC4"
|
|
|
|
* by Fluher, Mantin, and Shamir. N=1024 is based on
|
|
|
|
* suggestions in the paper "(Not So) Random Shuffles of RC4"
|
|
|
|
* by Ilya Mironov.
|
|
|
|
*/
|
|
|
|
for (n = 0; n < 1024; n++)
|
2006-10-04 01:17:23 +00:00
|
|
|
(void) arc4_getbyte(as);
|
|
|
|
arc4_count = 400000;
|
1997-06-14 01:15:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline u_int8_t
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4_getbyte(struct arc4_stream *as)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
|
|
|
u_int8_t si, sj;
|
|
|
|
|
|
|
|
as->i = (as->i + 1);
|
|
|
|
si = as->s[as->i];
|
|
|
|
as->j = (as->j + si);
|
|
|
|
sj = as->s[as->j];
|
|
|
|
as->s[as->i] = sj;
|
|
|
|
as->s[as->j] = si;
|
2004-02-23 20:42:03 +00:00
|
|
|
|
1997-06-14 01:15:41 +00:00
|
|
|
return (as->s[(si + sj) & 0xff]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u_int32_t
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4_getword(struct arc4_stream *as)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
|
|
|
u_int32_t val;
|
2004-02-23 20:42:03 +00:00
|
|
|
|
1997-06-14 01:15:41 +00:00
|
|
|
val = arc4_getbyte(as) << 24;
|
|
|
|
val |= arc4_getbyte(as) << 16;
|
|
|
|
val |= arc4_getbyte(as) << 8;
|
|
|
|
val |= arc4_getbyte(as);
|
2004-02-23 20:42:03 +00:00
|
|
|
|
|
|
|
return (val);
|
1997-06-14 01:15:41 +00:00
|
|
|
}
|
|
|
|
|
2004-03-24 14:44:57 +00:00
|
|
|
static void
|
|
|
|
arc4_check_init(void)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
|
|
|
if (!rs_initialized) {
|
|
|
|
arc4_init(&rs);
|
|
|
|
rs_initialized = 1;
|
|
|
|
}
|
2004-03-24 14:44:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
arc4_check_stir(void)
|
|
|
|
{
|
2006-10-04 01:17:23 +00:00
|
|
|
if (!rs_stired || --arc4_count == 0) {
|
2004-03-24 14:44:57 +00:00
|
|
|
arc4_stir(&rs);
|
|
|
|
rs_stired = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4random_stir(void)
|
2004-03-24 14:44:57 +00:00
|
|
|
{
|
|
|
|
THREAD_LOCK();
|
|
|
|
arc4_check_init();
|
1997-06-14 01:15:41 +00:00
|
|
|
arc4_stir(&rs);
|
2004-03-24 14:44:57 +00:00
|
|
|
THREAD_UNLOCK();
|
1997-06-14 01:15:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4random_addrandom(u_char *dat, int datlen)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
2004-03-24 14:44:57 +00:00
|
|
|
THREAD_LOCK();
|
|
|
|
arc4_check_init();
|
|
|
|
arc4_check_stir();
|
1997-06-14 01:15:41 +00:00
|
|
|
arc4_addrandom(&rs, dat, datlen);
|
2004-03-24 14:44:57 +00:00
|
|
|
THREAD_UNLOCK();
|
1997-06-14 01:15:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
u_int32_t
|
2007-05-25 10:40:33 +00:00
|
|
|
arc4random(void)
|
1997-06-14 01:15:41 +00:00
|
|
|
{
|
2004-03-24 14:44:57 +00:00
|
|
|
u_int32_t rnd;
|
|
|
|
|
|
|
|
THREAD_LOCK();
|
|
|
|
arc4_check_init();
|
|
|
|
arc4_check_stir();
|
|
|
|
rnd = arc4_getword(&rs);
|
|
|
|
THREAD_UNLOCK();
|
2004-02-23 20:42:03 +00:00
|
|
|
|
2004-03-24 14:44:57 +00:00
|
|
|
return (rnd);
|
1997-06-14 01:15:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/*-------- Test code for i386 --------*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <machine/pctr.h>
|
|
|
|
int
|
|
|
|
main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
const int iter = 1000000;
|
|
|
|
int i;
|
|
|
|
pctrval v;
|
|
|
|
|
|
|
|
v = rdtsc();
|
|
|
|
for (i = 0; i < iter; i++)
|
|
|
|
arc4random();
|
|
|
|
v = rdtsc() - v;
|
|
|
|
v /= iter;
|
|
|
|
|
|
|
|
printf("%qd cycles\n", v);
|
|
|
|
}
|
|
|
|
#endif
|