Return to random.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / hping2

Annotation of embedaddon/hping2/random.c, revision 1.1

1.1     ! misho       1: /* rc4-based pseudo-random number generator for hping.
        !             2:  * Copyright (C) 2003 Salvatore Sanfilippo
        !             3:  * This software is released under the GPL license
        !             4:  * All rights reserved */
        !             5: 
        !             6: #include <sys/types.h>
        !             7: #include <sys/stat.h>
        !             8: #include <fcntl.h>
        !             9: #include <unistd.h>
        !            10: #include <sys/time.h>
        !            11: #include <time.h>
        !            12: 
        !            13: u_int32_t hp_rand(void);
        !            14: 
        !            15: /* The rc4 sbox */
        !            16: static unsigned char rc4_sbox[256];
        !            17: /* This flags is used to initialize the sbox the first time,
        !            18:  * without an explicit intialization step outside this file. */
        !            19: static int rc4_seedflag = 0;
        !            20: 
        !            21: /* Initialize the sbox with pseudo random data */
        !            22: static void hp_rand_init(void)
        !            23: {
        !            24:        int i, fd;
        !            25: 
        !            26:        /* Strong sbox initialization */
        !            27:        fd = open("/dev/urandom", O_RDONLY);
        !            28:        if (fd != -1) {
        !            29:                read(fd, rc4_sbox, 256);
        !            30:                close(fd);
        !            31:        }
        !            32:        /* Weaker sbox initialization */
        !            33:        for (i = 0; i < 256; i++) {
        !            34:                struct timeval tv;
        !            35:                gettimeofday(&tv, NULL);
        !            36:                if (i&1)
        !            37:                        rc4_sbox[i] ^= (tv.tv_usec >> (i&0xF)) & 0xFF;
        !            38:                else
        !            39:                        rc4_sbox[i] ^= (tv.tv_sec >> (i&0xF)) & 0xFF;
        !            40:        }
        !            41:        rc4_seedflag = 1;
        !            42: }
        !            43: 
        !            44: #if 0
        !            45: /* Re-seed the generator with user-provided bytes. Not used for now. */
        !            46: static void hp_rand_seed(void *seed, size_t len)
        !            47: {
        !            48:        int i;
        !            49: 
        !            50:        if (len > 256) len = 256;
        !            51:        memcpy(rc4_sbox, seed, len);
        !            52:        /* discard the first 256 bytes of output after the reseed */
        !            53:        for (i = 0; i < 32; i++)
        !            54:                (void) hp_rand();
        !            55: }
        !            56: #endif
        !            57: 
        !            58: /* Generates a 32bit random number using an RC4-like algorithm */
        !            59: u_int32_t hp_rand(void)
        !            60: {
        !            61:        u_int32_t r = 0;
        !            62:        unsigned char *rc = (unsigned char*) &r;
        !            63:        static unsigned int i = 0, j = 0;
        !            64:        unsigned int si, sj, x;
        !            65: 
        !            66:        /* initialization, only needed the first time */
        !            67:        if (!rc4_seedflag)
        !            68:                hp_rand_init();
        !            69:        /* generates 4 bytes of pseudo-random data using RC4 */
        !            70:        for (x = 0; x < 4; x++) {
        !            71:                i = (i+1) & 0xff;
        !            72:                si = rc4_sbox[i];
        !            73:                j = (j + si) & 0xff;
        !            74:                sj = rc4_sbox[j];
        !            75:                rc4_sbox[i] = sj;
        !            76:                rc4_sbox[j] = si;
        !            77:                *rc++ = rc4_sbox[(si+sj)&0xff];
        !            78:        }
        !            79:        return r;
        !            80: }
        !            81: