Return to random.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

sqlite3

    1: /*
    2: ** 2001 September 15
    3: **
    4: ** The author disclaims copyright to this source code.  In place of
    5: ** a legal notice, here is a blessing:
    6: **
    7: **    May you do good and not evil.
    8: **    May you find forgiveness for yourself and forgive others.
    9: **    May you share freely, never taking more than you give.
   10: **
   11: *************************************************************************
   12: ** This file contains code to implement a pseudo-random number
   13: ** generator (PRNG) for SQLite.
   14: **
   15: ** Random numbers are used by some of the database backends in order
   16: ** to generate random integer keys for tables or random filenames.
   17: */
   18: #include "sqliteInt.h"
   19: 
   20: 
   21: /* All threads share a single random number generator.
   22: ** This structure is the current state of the generator.
   23: */
   24: static SQLITE_WSD struct sqlite3PrngType {
   25:   unsigned char isInit;          /* True if initialized */
   26:   unsigned char i, j;            /* State variables */
   27:   unsigned char s[256];          /* State variables */
   28: } sqlite3Prng;
   29: 
   30: /*
   31: ** Get a single 8-bit random value from the RC4 PRNG.  The Mutex
   32: ** must be held while executing this routine.
   33: **
   34: ** Why not just use a library random generator like lrand48() for this?
   35: ** Because the OP_NewRowid opcode in the VDBE depends on having a very
   36: ** good source of random numbers.  The lrand48() library function may
   37: ** well be good enough.  But maybe not.  Or maybe lrand48() has some
   38: ** subtle problems on some systems that could cause problems.  It is hard
   39: ** to know.  To minimize the risk of problems due to bad lrand48()
   40: ** implementations, SQLite uses this random number generator based
   41: ** on RC4, which we know works very well.
   42: **
   43: ** (Later):  Actually, OP_NewRowid does not depend on a good source of
   44: ** randomness any more.  But we will leave this code in all the same.
   45: */
   46: static u8 randomByte(void){
   47:   unsigned char t;
   48: 
   49: 
   50:   /* The "wsdPrng" macro will resolve to the pseudo-random number generator
   51:   ** state vector.  If writable static data is unsupported on the target,
   52:   ** we have to locate the state vector at run-time.  In the more common
   53:   ** case where writable static data is supported, wsdPrng can refer directly
   54:   ** to the "sqlite3Prng" state vector declared above.
   55:   */
   56: #ifdef SQLITE_OMIT_WSD
   57:   struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
   58: # define wsdPrng p[0]
   59: #else
   60: # define wsdPrng sqlite3Prng
   61: #endif
   62: 
   63: 
   64:   /* Initialize the state of the random number generator once,
   65:   ** the first time this routine is called.  The seed value does
   66:   ** not need to contain a lot of randomness since we are not
   67:   ** trying to do secure encryption or anything like that...
   68:   **
   69:   ** Nothing in this file or anywhere else in SQLite does any kind of
   70:   ** encryption.  The RC4 algorithm is being used as a PRNG (pseudo-random
   71:   ** number generator) not as an encryption device.
   72:   */
   73:   if( !wsdPrng.isInit ){
   74:     int i;
   75:     char k[256];
   76:     wsdPrng.j = 0;
   77:     wsdPrng.i = 0;
   78:     sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
   79:     for(i=0; i<256; i++){
   80:       wsdPrng.s[i] = (u8)i;
   81:     }
   82:     for(i=0; i<256; i++){
   83:       wsdPrng.j += wsdPrng.s[i] + k[i];
   84:       t = wsdPrng.s[wsdPrng.j];
   85:       wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
   86:       wsdPrng.s[i] = t;
   87:     }
   88:     wsdPrng.isInit = 1;
   89:   }
   90: 
   91:   /* Generate and return single random byte
   92:   */
   93:   wsdPrng.i++;
   94:   t = wsdPrng.s[wsdPrng.i];
   95:   wsdPrng.j += t;
   96:   wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
   97:   wsdPrng.s[wsdPrng.j] = t;
   98:   t += wsdPrng.s[wsdPrng.i];
   99:   return wsdPrng.s[t];
  100: }
  101: 
  102: /*
  103: ** Return N random bytes.
  104: */
  105: void sqlite3_randomness(int N, void *pBuf){
  106:   unsigned char *zBuf = pBuf;
  107: #if SQLITE_THREADSAFE
  108:   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
  109: #endif
  110:   sqlite3_mutex_enter(mutex);
  111:   while( N-- ){
  112:     *(zBuf++) = randomByte();
  113:   }
  114:   sqlite3_mutex_leave(mutex);
  115: }
  116: 
  117: #ifndef SQLITE_OMIT_BUILTIN_TEST
  118: /*
  119: ** For testing purposes, we sometimes want to preserve the state of
  120: ** PRNG and restore the PRNG to its saved state at a later time, or
  121: ** to reset the PRNG to its initial state.  These routines accomplish
  122: ** those tasks.
  123: **
  124: ** The sqlite3_test_control() interface calls these routines to
  125: ** control the PRNG.
  126: */
  127: static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng;
  128: void sqlite3PrngSaveState(void){
  129:   memcpy(
  130:     &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
  131:     &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
  132:     sizeof(sqlite3Prng)
  133:   );
  134: }
  135: void sqlite3PrngRestoreState(void){
  136:   memcpy(
  137:     &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
  138:     &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
  139:     sizeof(sqlite3Prng)
  140:   );
  141: }
  142: void sqlite3PrngResetState(void){
  143:   GLOBAL(struct sqlite3PrngType, sqlite3Prng).isInit = 0;
  144: }
  145: #endif /* SQLITE_OMIT_BUILTIN_TEST */