126 lines
3.3 KiB
C
126 lines
3.3 KiB
C
/**
|
|
* @PROJECT PH7 Engine for the AerScript Interpreter
|
|
* @COPYRIGHT See COPYING in the top level directory
|
|
* @FILE engine/lib/random.c
|
|
* @DESCRIPTION Psuedo Random Number Generator (PRNG) for the PH7 Engine
|
|
* @DEVELOPERS Symisc Systems <devel@symisc.net>
|
|
* Rafal Kupiec <belliash@codingworkshop.eu.org>
|
|
*/
|
|
#include "ph7int.h"
|
|
|
|
#define SXPRNG_MAGIC 0x13C4
|
|
#ifdef __UNIXES__
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <sys/time.h>
|
|
#endif
|
|
static sxi32 SyOSUtilRandomSeed(void *pBuf, sxu32 nLen, void *pUnused) {
|
|
char *zBuf = (char *)pBuf;
|
|
#ifdef __WINNT__
|
|
DWORD nProcessID; /* Yes,keep it uninitialized when compiling using the MinGW32 builds tools */
|
|
#elif defined(__UNIXES__)
|
|
pid_t pid;
|
|
int fd;
|
|
#else
|
|
char zGarbage[128]; /* Yes,keep this buffer uninitialized */
|
|
#endif
|
|
SXUNUSED(pUnused);
|
|
#ifdef __WINNT__
|
|
#ifndef __MINGW32__
|
|
nProcessID = GetProcessId(GetCurrentProcess());
|
|
#endif
|
|
SyMemcpy((const void *)&nProcessID, zBuf, SXMIN(nLen, sizeof(DWORD)));
|
|
if((sxu32)(&zBuf[nLen] - &zBuf[sizeof(DWORD)]) >= sizeof(SYSTEMTIME)) {
|
|
GetSystemTime((LPSYSTEMTIME)&zBuf[sizeof(DWORD)]);
|
|
}
|
|
#elif defined(__UNIXES__)
|
|
fd = open("/dev/urandom", O_RDONLY);
|
|
if(fd >= 0) {
|
|
if(read(fd, zBuf, nLen) > 0) {
|
|
close(fd);
|
|
return SXRET_OK;
|
|
}
|
|
/* FALL THRU */
|
|
}
|
|
close(fd);
|
|
pid = getpid();
|
|
SyMemcpy((const void *)&pid, zBuf, SXMIN(nLen, sizeof(pid_t)));
|
|
if(&zBuf[nLen] - &zBuf[sizeof(pid_t)] >= (int)sizeof(struct timeval)) {
|
|
gettimeofday((struct timeval *)&zBuf[sizeof(pid_t)], 0);
|
|
}
|
|
#else
|
|
/* Fill with uninitialized data */
|
|
SyMemcpy(zGarbage, zBuf, SXMIN(nLen, sizeof(zGarbage)));
|
|
#endif
|
|
return SXRET_OK;
|
|
}
|
|
PH7_PRIVATE sxi32 SyRandomnessInit(SyPRNGCtx *pCtx, ProcRandomSeed xSeed, void *pUserData) {
|
|
char zSeed[256];
|
|
sxu8 t;
|
|
sxi32 rc;
|
|
sxu32 i;
|
|
if(pCtx->nMagic == SXPRNG_MAGIC) {
|
|
return SXRET_OK; /* Already initialized */
|
|
}
|
|
/* 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...
|
|
*/
|
|
if(xSeed == 0) {
|
|
xSeed = SyOSUtilRandomSeed;
|
|
}
|
|
rc = xSeed(zSeed, sizeof(zSeed), pUserData);
|
|
if(rc != SXRET_OK) {
|
|
return rc;
|
|
}
|
|
pCtx->i = pCtx->j = 0;
|
|
for(i = 0; i < SX_ARRAYSIZE(pCtx->s) ; i++) {
|
|
pCtx->s[i] = (unsigned char)i;
|
|
}
|
|
for(i = 0; i < sizeof(zSeed) ; i++) {
|
|
pCtx->j += pCtx->s[i] + zSeed[i];
|
|
t = pCtx->s[pCtx->j];
|
|
pCtx->s[pCtx->j] = pCtx->s[i];
|
|
pCtx->s[i] = t;
|
|
}
|
|
pCtx->nMagic = SXPRNG_MAGIC;
|
|
return SXRET_OK;
|
|
}
|
|
/*
|
|
* Get a single 8-bit random value using the RC4 PRNG.
|
|
*/
|
|
static sxu8 randomByte(SyPRNGCtx *pCtx) {
|
|
sxu8 t;
|
|
/* Generate and return single random byte */
|
|
pCtx->i++;
|
|
t = pCtx->s[pCtx->i];
|
|
pCtx->j += t;
|
|
pCtx->s[pCtx->i] = pCtx->s[pCtx->j];
|
|
pCtx->s[pCtx->j] = t;
|
|
t += pCtx->s[pCtx->i];
|
|
return pCtx->s[t];
|
|
}
|
|
PH7_PRIVATE sxi32 SyRandomness(SyPRNGCtx *pCtx, void *pBuf, sxu32 nLen) {
|
|
unsigned char *zBuf = (unsigned char *)pBuf;
|
|
unsigned char *zEnd = &zBuf[nLen];
|
|
if(pCtx == 0 || pBuf == 0 || nLen <= 0) {
|
|
return SXERR_EMPTY;
|
|
}
|
|
if(pCtx->nMagic != SXPRNG_MAGIC) {
|
|
return SXERR_CORRUPT;
|
|
}
|
|
for(;;) {
|
|
if(zBuf >= zEnd) {
|
|
break;
|
|
}
|
|
zBuf[0] = randomByte(pCtx);
|
|
zBuf++;
|
|
}
|
|
return SXRET_OK;
|
|
}
|