sqlcipher/src/random.c at sqlite-release · PHPDOTSQL/sqlcipher · GitHub

History

145 lines (135 loc) · 4.56 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

** 2001 September 15

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** This file contains code to implement a pseudo-random number

** generator (PRNG) for SQLite.

** Random numbers are used by some of the database backends in order

** to generate random integer keys for tables or random filenames.

#include "sqliteInt.h"

/* All threads share a single random number generator.

** This structure is the current state of the generator.

static SQLITE_WSD struct sqlite3PrngType {

unsigned char isInit; /* True if initialized */

unsigned char i, j; /* State variables */

unsigned char s[256]; /* State variables */

} sqlite3Prng;

** Get a single 8-bit random value from the RC4 PRNG. The Mutex

** must be held while executing this routine.

** Why not just use a library random generator like lrand48() for this?

** Because the OP_NewRowid opcode in the VDBE depends on having a very

** good source of random numbers. The lrand48() library function may

** well be good enough. But maybe not. Or maybe lrand48() has some

** subtle problems on some systems that could cause problems. It is hard

** to know. To minimize the risk of problems due to bad lrand48()

** implementations, SQLite uses this random number generator based

** on RC4, which we know works very well.

** (Later): Actually, OP_NewRowid does not depend on a good source of

** randomness any more. But we will leave this code in all the same.

static u8 randomByte(void){

unsigned char t;

/* The "wsdPrng" macro will resolve to the pseudo-random number generator

** state vector. If writable static data is unsupported on the target,

** we have to locate the state vector at run-time. In the more common

** case where writable static data is supported, wsdPrng can refer directly

** to the "sqlite3Prng" state vector declared above.

#ifdef SQLITE_OMIT_WSD

struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);

# define wsdPrng p[0]

#else

# define wsdPrng sqlite3Prng

#endif

/* Initialize the state of the random number generator once,

** the first time this routine is called. The seed value does

** not need to contain a lot of randomness since we are not

** trying to do secure encryption or anything like that...

** Nothing in this file or anywhere else in SQLite does any kind of

** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random

** number generator) not as an encryption device.

if( !wsdPrng.isInit ){

int i;

char k[256];

wsdPrng.j = 0;

wsdPrng.i = 0;

sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);

for(i=0; i<256; i++){

wsdPrng.s[i] = (u8)i;

}

for(i=0; i<256; i++){

wsdPrng.j += wsdPrng.s[i] + k[i];

t = wsdPrng.s[wsdPrng.j];

wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];

wsdPrng.s[i] = t;

}

wsdPrng.isInit = 1;

}

/* Generate and return single random byte

wsdPrng.i++;

t = wsdPrng.s[wsdPrng.i];

wsdPrng.j += t;

wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];

wsdPrng.s[wsdPrng.j] = t;

t += wsdPrng.s[wsdPrng.i];

return wsdPrng.s[t];

}

** Return N random bytes.

void sqlite3_randomness(int N, void *pBuf){

unsigned char *zBuf = pBuf;

#if SQLITE_THREADSAFE

sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);

#endif

sqlite3_mutex_enter(mutex);

while( N-- ){

*(zBuf++) = randomByte();

}

sqlite3_mutex_leave(mutex);

}

#ifndef SQLITE_OMIT_BUILTIN_TEST

** For testing purposes, we sometimes want to preserve the state of

** PRNG and restore the PRNG to its saved state at a later time, or

** to reset the PRNG to its initial state. These routines accomplish

** those tasks.

** The sqlite3_test_control() interface calls these routines to

** control the PRNG.

static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng;

void sqlite3PrngSaveState(void){

memcpy(

&GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),

&GLOBAL(struct sqlite3PrngType, sqlite3Prng),

sizeof(sqlite3Prng)

);

}

void sqlite3PrngRestoreState(void){

memcpy(

&GLOBAL(struct sqlite3PrngType, sqlite3Prng),

&GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),

sizeof(sqlite3Prng)

);

}

void sqlite3PrngResetState(void){

GLOBAL(struct sqlite3PrngType, sqlite3Prng).isInit = 0;

}

#endif /* SQLITE_OMIT_BUILTIN_TEST */

sqlcipher/src/random.c at sqlite-release · PHPDOTSQL/sqlcipher · GitHub

Expand file tree

Breadcrumbs

random.c

Latest commit

History

Breadcrumbs

random.c

File metadata and controls