Return to r_random.c CVS log

Up to [rsaref] / rsaref / source

Annotation of rsaref/source/r_random.c, revision 1.1.1.1

1.1       root        1: /* R_RANDOM.C - random objects for RSAREF
                      2:  */
                      3: 
                      4: /* Copyright (C) 1991-2 RSA Laboratories, a division of RSA Data
                      5:    Security, Inc. All rights reserved.
                      6:  */
                      7: 
                      8: #include "global.h"
                      9: #include "rsaref.h"
                     10: #include "r_random.h"
                     11: #include "md5.h"
                     12: 
                     13: #define RANDOM_BYTES_NEEDED 256
                     14: 
                     15: int R_RandomInit (randomStruct)
                     16: R_RANDOM_STRUCT *randomStruct;                      /* new random structure */
                     17: {
                     18:   randomStruct->bytesNeeded = RANDOM_BYTES_NEEDED;
                     19:   R_memset ((POINTER)randomStruct->state, 0, sizeof (randomStruct->state));
                     20:   randomStruct->outputAvailable = 0;
                     21:   
                     22:   return (0);
                     23: }
                     24: 
                     25: int R_RandomUpdate (randomStruct, block, blockLen)
                     26: R_RANDOM_STRUCT *randomStruct;                          /* random structure */
                     27: unsigned char *block;                          /* block of values to mix in */
                     28: unsigned int blockLen;                                   /* length of block */
                     29: {
                     30:   MD5_CTX context;
                     31:   unsigned char digest[16];
                     32:   unsigned int i, x;
                     33:   
                     34:   MD5Init (&context);
                     35:   MD5Update (&context, block, blockLen);
                     36:   MD5Final (digest, &context);
                     37: 
                     38:   /* add digest to state */
                     39:   x = 0;
                     40:   for (i = 0; i < 16; i++) {
                     41:     x += randomStruct->state[15-i] + digest[15-i];
                     42:     randomStruct->state[15-i] = (unsigned char)x;
                     43:     x >>= 8;
                     44:   }
                     45:   
                     46:   if (randomStruct->bytesNeeded < blockLen)
                     47:     randomStruct->bytesNeeded = 0;
                     48:   else
                     49:     randomStruct->bytesNeeded -= blockLen;
                     50:   
                     51:   /* Zeroize sensitive information.
                     52:    */
                     53:   R_memset ((POINTER)digest, 0, sizeof (digest));
                     54:   x = 0;
                     55:   
                     56:   return (0);
                     57: }
                     58: 
                     59: int R_GetRandomBytesNeeded (bytesNeeded, randomStruct)
                     60: unsigned int *bytesNeeded;                 /* number of mix-in bytes needed */
                     61: R_RANDOM_STRUCT *randomStruct;                          /* random structure */
                     62: {
                     63:   *bytesNeeded = randomStruct->bytesNeeded;
                     64:   
                     65:   return (0);
                     66: }
                     67: 
                     68: int R_GenerateBytes (block, blockLen, randomStruct)
                     69: unsigned char *block;                                              /* block */
                     70: unsigned int blockLen;                                   /* length of block */
                     71: R_RANDOM_STRUCT *randomStruct;                          /* random structure */
                     72: {
                     73:   MD5_CTX context;
                     74:   unsigned int available, i;
                     75:   
                     76:   if (randomStruct->bytesNeeded)
                     77:     return (RE_NEED_RANDOM);
                     78:   
                     79:   available = randomStruct->outputAvailable;
                     80:   
                     81:   while (blockLen > available) {
                     82:     R_memcpy
                     83:       ((POINTER)block, (POINTER)&randomStruct->output[16-available],
                     84:        available);
                     85:     block += available;
                     86:     blockLen -= available;
                     87: 
                     88:     /* generate new output */
                     89:     MD5Init (&context);
                     90:     MD5Update (&context, randomStruct->state, 16);
                     91:     MD5Final (randomStruct->output, &context);
                     92:     available = 16;
                     93: 
                     94:     /* increment state */
                     95:     for (i = 0; i < 16; i++)
                     96:       if (randomStruct->state[15-i]++)
                     97:         break;
                     98:   }
                     99: 
                    100:   R_memcpy 
                    101:     ((POINTER)block, (POINTER)&randomStruct->output[16-available], blockLen);
                    102:   randomStruct->outputAvailable = available - blockLen;
                    103: 
                    104:   return (0);
                    105: }
                    106: 
                    107: void R_RandomFinal (randomStruct)
                    108: R_RANDOM_STRUCT *randomStruct;                          /* random structure */
                    109: {
                    110:   R_memset ((POINTER)randomStruct, 0, sizeof (*randomStruct));
                    111: }

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