/* Modified for Linux - Robert Connolly 2006/06/03 */ /* $OpenBSD: arc4random.c,v 1.15 2005/11/30 07:51:02 otto Exp $ */ /* * Copyright (c) 1996, David Mazieres * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Arc4 random number generator for OpenBSD. * * 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. */ #include #include #include #include #include #include #include #ifdef __UCLIBC__ libc_hidden_proto(open) libc_hidden_proto(read) libc_hidden_proto(close) libc_hidden_proto(gettimeofday) #endif #if defined(IS_IN_libc) && !defined(__UCLIBC__) && defined(__GLIBC__) #define open __open #define read __read #define close __close #endif #ifdef __GNUC__ #define inline __inline #else /* !__GNUC__ */ #define inline #endif /* !__GNUC__ */ struct arc4_stream { u_int8_t i; u_int8_t j; u_int8_t s[256]; }; static int rs_initialized; static struct arc4_stream rs; static pid_t arc4_stir_pid; static int arc4_count; static inline u_int8_t arc4_getbyte(struct arc4_stream *); static inline void arc4_init(struct arc4_stream *as) { int n; for (n = 0; n < 256; n++) as->s[n] = n; as->i = 0; as->j = 0; } static inline void arc4_addrandom(struct arc4_stream *as, u_char *dat, int datlen) { 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; } as->j = as->i; } static void arc4_stir(struct arc4_stream *as) { /* * Erandom (Frandom's daughter) is a pseudo random number generator which * uses no kernel entropy during use, but is seeded by Frandom which is * seeded by kernel entropy. Erandom's initial seed is available only to * root/the-kernel, making Erandom's output safe for security applications. * Thanks to Eli Billauer for the Erandom * kernel driver. Also see */ /* * Erandom is available as a sysctl value. Sysctl has the advantage of * working from inside a chroot. Although sysctl is a single-threaded * interface, the operation of obtaining a value from sysctl is so quick * that there is little-to-no wait time for processes, and peformance is * excelent. * * SYSCTL_ERANDOM* is defined from . This requires a * modified kernel. Also see: * */ /* The vanilla Erandom sysctl provides 16 bytes. */ /* The modified fat version of Erandom sysctl provides 256 bytes. */ int i, fd; u_char rnd[128]; /* If SYSCTL_ERANDOM* is defined, use it first. */ #if !defined(__UCLIBC__) || defined(ARC4RANDOM_USES_SYSCTL_ERANDOM) #if defined(SYSCTL_ERANDOM) || defined(SYSCTL_ERANDOM256) int mib[]={CTL_KERN, KERN_RANDOM, RANDOM_ERANDOM}; size_t len; len = sizeof(rnd); #endif #ifdef SYSCTL_ERANDOM256 /* Fill the buffer in one shot. */ if (sysctl(mib, 3, rnd, &len, NULL, 0) == -1) { #endif #ifdef SYSCTL_ERANDOM /* Fill the buffer in eight shots. */ for (i = 0; i < sizeof(rnd) / sizeof(u_int); i ++) { len = sizeof(u_int); if (sysctl(mib, 3, rnd[i], &len, NULL, 0) == -1) { #endif #endif /* !__UCLIBC__ || ARC4RANDOM_USES_SYSCTL_ERANDOM */ #if !defined(__UCLIBC__) || defined(UCLIBC_USES_ERANDOM) /* If sysctl erandom did not work, try /dev/erandom. */ fd = open("/dev/erandom", O_RDONLY); if (fd != -1) { read(fd, rnd, sizeof(rnd)); close(fd); } else { #endif /* If /dev/erandom did not work try /dev/urandom. */ fd = open("/dev/urandom", O_RDONLY); if (fd != -1) { read(fd, rnd, sizeof(rnd)); close(fd); } else { /* Erandom and Urandom failed? Use the time. */ struct { struct timeval tv; u_int rnd[(128 - sizeof(struct timeval)) / sizeof(u_int)]; } rdat; gettimeofday(&rdat.tv, NULL); } #if !defined(__UCLIBC__) || defined(UCLIBC_USES_ERANDOM) } #endif #if defined(SYSCTL_ERANDOM) || defined(SYSCTL_ERANDOM256) } #endif arc4_stir_pid = getpid(); arc4_addrandom(as, rnd, sizeof(rnd)); /* * Throw away the first N words of output, as suggested in the * paper "Weaknesses in the Key Scheduling Algorithm of RC4" * by Fluher, Mantin, and Shamir. * http://www.wisdom.weizmann.ac.il/~itsik/RC4/Papers/Rc4_ksa.ps * N = 256 in our case. */ for (i = 0; i < 256; i++) (void)arc4_getbyte(as); arc4_count = 400000; } static inline u_int8_t arc4_getbyte(struct arc4_stream *as) { 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; return (as->s[(si + sj) & 0xff]); } static inline u_int32_t arc4_getword(struct arc4_stream *as) { u_int32_t val; val = arc4_getbyte(as) << 24; val |= arc4_getbyte(as) << 16; val |= arc4_getbyte(as) << 8; val |= arc4_getbyte(as); return val; } #ifdef __UCLIBC__ libc_hidden_proto(arc4random_stir) #endif void arc4random_stir(void) { if (!rs_initialized) { arc4_init(&rs); rs_initialized = 1; } arc4_stir(&rs); } #ifdef __UCLIBC__ libc_hidden_def(arc4random_stir) #endif void arc4random_addrandom(u_char *dat, int datlen) { if (!rs_initialized) arc4random_stir(); arc4_addrandom(&rs, dat, datlen); } u_int32_t arc4random(void) { if (--arc4_count == 0 || !rs_initialized || arc4_stir_pid != getpid()) arc4random_stir(); return arc4_getword(&rs); } #if 0 /*-------- Test code --------*/ /* Output a random number */ #include #include int main(void) { int random_number; random_number = arc4random() % 65536; printf("%d\n", random_number); return 0; } #endif