Return to randpool.c CVS log

Up to [PGP] / pgp / src

Annotation of pgp/src/randpool.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * True random number computation and storage
                      3:  *
                      4:  * (c) Copyright 1990-1994 by Philip Zimmermann.  All rights reserved.
                      5:  * The author assumes no liability for damages resulting from the use
                      6:  * of this software, even if the damage results from defects in this
                      7:  * software.  No warranty is expressed or implied.
                      8:  *
                      9:  * Note that while most PGP source modules bear Philip Zimmermann's
                     10:  * copyright notice, many of them have been revised or entirely written
                     11:  * by contributors who frequently failed to put their names in their
                     12:  * code.  Code that has been incorporated into PGP from other authors
                     13:  * was either originally published in the public domain or is used with
                     14:  * permission from the various authors.
                     15:  *
                     16:  * PGP is available for free to the public under certain restrictions.
                     17:  * See the PGP User's Guide (included in the release package) for
                     18:  * important information about licensing, patent restrictions on
                     19:  * certain algorithms, trademarks, copyrights, and export controls.
                     20:  *
                     21:  * Written by Colin Plumb.
                     22:  */
                     23: #include <stdlib.h>
                     24: 
                     25: #include "randpool.h"
                     26: #include "usuals.h"
                     27: #include "md5.h"
                     28: 
                     29: /* The pool must be a multiple of the 16-byte (128-bit) MD5 block size */
                     30: #define RANDPOOLBYTES ((RANDPOOLBITS+127 & ~127) >> 3)
                     31: #if RANDPOOLBYTES <= 64
                     32: #error Random pool too small - please increase RANDPOOLBITS in randpool.h
                     33: #endif
                     34: 
                     35: static byte randPool[RANDPOOLBYTES];   /* Random pool */
                     36: static unsigned randPoolGetPos = 0;    /* Current position to get from */
                     37: static unsigned randPoolAddPos = 0;    /* Current position to add to */
                     38: 
                     39: static byte randPoolKey[64];
                     40: 
                     41: static void
                     42: xorbytes(byte *dest, byte const *src, unsigned len)
                     43: {
                     44:        while (len--)
                     45:                *dest++ = *src++;
                     46: }
                     47: 
                     48: /*
                     49:  * Destroys already-used random numbers.  Ensures no sensitive data
                     50:  * remains in memory that can be recovered later.  This is also
                     51:  * called to "stir in" newly acquired environmental noise bits.
                     52:  * These noise bits are placed in the trueRandKey.
                     53:  *
                     54:  * The transformation is carried out by "encrypting" the data in CBC
                     55:  * mode with MD5 as the block cipher.  This is not invertible, but that
                     56:  * is just fine for these purposes.
                     57:  *
                     58:  * Then, to make doubly certain the stirring operation is strictly one-way,
                     59:  * we destroy the key.  This is done by reinitializing it from the pool,
                     60:  * copying the first 64 bytes of the pool over the key.  These bytes are
                     61:  * not returned by randPoolGetBytes().
                     62:  */
                     63: void
                     64: randPoolStir(void)
                     65: {
                     66:        int i;
                     67: 
                     68:        xorbytes(randPool, randPool+sizeof(randPool)-16, 16);
                     69:        MD5Transform((word32 *)randPool, (word32 *)randPoolKey);
                     70:        for(i = 16; i < sizeof(randPool); i += 16) {
                     71:                xorbytes(randPool+i, randPool+i-16, 16);
                     72:                MD5Transform((word32 *)(randPool+i), (word32 *)randPoolKey);
                     73:        }
                     74: 
                     75:        memcpy(randPoolKey, randPool, sizeof(randPoolKey));
                     76: 
                     77:        randPoolAddPos = 0;
                     78:        randPoolGetPos = sizeof(randPoolKey);
                     79: }
                     80: 
                     81: void
                     82: randPoolAddBytes(byte const *buf, unsigned len)
                     83: {
                     84:        unsigned t;
                     85: 
                     86:        while (len > (t = sizeof(randPool) - randPoolAddPos)) {
                     87:                xorbytes(randPool+randPoolAddPos, buf, t);
                     88:                buf += t;
                     89:                len -= t;
                     90:                randPoolStir();
                     91:        }
                     92: 
                     93:        if (len) {
                     94:                xorbytes(randPool+randPoolAddPos, buf, len);
                     95:                randPoolAddPos += len;
                     96:                randPoolGetPos = sizeof(randPool);
                     97:        }
                     98: }
                     99: 
                    100: void
                    101: randPoolGetBytes(byte *buf, unsigned len)
                    102: {
                    103:        unsigned t;
                    104: 
                    105:        while (len > (t = sizeof(randPool) - randPoolGetPos)) {
                    106:                memcpy(buf, randPool+randPoolGetPos, t);
                    107:                buf += t;
                    108:                len -= t;
                    109:                randPoolStir();
                    110:        }
                    111: 
                    112:        if (len) {
                    113:                memcpy(buf, randPool+randPoolGetPos, len);
                    114:                randPoolGetPos += len;
                    115:        }
                    116: }
                    117: 
                    118: byte
                    119: randPoolGetByte(void)
                    120: {
                    121:        if (randPoolGetPos == sizeof(randPool))
                    122:                randPoolStir();
                    123: 
                    124:        return randPool[randPoolGetPos++];
                    125: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.