![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to random.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / common|
Return to random.c CVS log | Up to [truecrypt] / truecrypt / common |
1.1.1.10 root 1: /*
2: Legal Notice: The source code contained in this file has been derived from
3: the source code of Encryption for the Masses 2.02a, which is Copyright (c)
4: Paul Le Roux and which is covered by the 'License Agreement for Encryption
5: for the Masses'. Modifications and additions to that source code contained
6: in this file are Copyright (c) TrueCrypt Foundation and are covered by the
1.1.1.11! root 7: TrueCrypt License 2.3 the full text of which is contained in the file
1.1.1.10 root 8: License.txt included in TrueCrypt binary and source code distribution
9: packages. */
1.1 root 10:
1.1.1.9 root 11: #include <stdlib.h>
12: #include <stdio.h>
1.1.1.10 root 13: #include <string.h>
1.1.1.9 root 14: #include <fcntl.h>
1.1.1.6 root 15: #include "Tcdefs.h"
16: #include "Crc.h"
17: #include "Random.h"
18: #include "Apidrvr.h"
1.1 root 19:
1.1.1.9 root 20: unsigned __int8 buffer[RNG_POOL_SIZE];
1.1 root 21: unsigned char *pRandPool = NULL;
1.1.1.9 root 22: static BOOL bRandDidInit = FALSE;
1.1.1.2 root 23: int nRandIndex = 0, randPoolReadIndex = 0;
1.1.1.9 root 24: int HashFunction = DEFAULT_HASH_ALGORITHM;
25: BOOL bDidSlowPoll = FALSE; /* We do the slow poll only once */
26: BOOL volatile bFastPollEnabled = TRUE; /* Used to reduce CPU load when performing benchmarks */
27: BOOL volatile bRandmixEnabled = TRUE; /* Used to reduce CPU load when performing benchmarks */
1.1.1.3 root 28:
1.1 root 29: /* Macro to add a single byte to the pool */
30: #define RandaddByte(x) {\
1.1.1.6 root 31: if (nRandIndex == RNG_POOL_SIZE) nRandIndex = 0;\
1.1 root 32: pRandPool[nRandIndex] = (unsigned char) ((unsigned char)x + pRandPool[nRandIndex]); \
1.1.1.6 root 33: if (nRandIndex % 8 == 0) Randmix();\
1.1 root 34: nRandIndex++; \
35: }
36:
37: /* Macro to add four bytes to the pool */
1.1.1.9 root 38: #define RandaddInt32(x) RandAddInt((unsigned __int32)x);
1.1 root 39:
1.1.1.9 root 40: void RandAddInt (unsigned __int32 x)
1.1 root 41: {
42: RandaddByte(x);
43: RandaddByte((x >> 8));
44: RandaddByte((x >> 16));
45: RandaddByte((x >> 24));
46: }
47:
1.1.1.9 root 48: #ifdef _WIN32
49:
50: #include <tlhelp32.h>
51: #include "Dlgcode.h"
52:
1.1 root 53: HHOOK hMouse = NULL; /* Mouse hook for the random number generator */
1.1.1.6 root 54: HHOOK hKeyboard = NULL; /* Keyboard hook for the random number generator */
1.1 root 55:
56: /* Variables for thread control, the thread is used to gather up info about
57: the system in in the background */
58: CRITICAL_SECTION critRandProt; /* The critical section */
1.1.1.6 root 59: BOOL volatile bThreadTerminate = FALSE; /* This variable is shared among thread's so its made volatile */
1.1 root 60:
1.1.1.9 root 61: /* Network library handle for the SlowPoll function */
1.1 root 62: HANDLE hNetAPI32 = NULL;
63:
1.1.1.4 root 64: // CryptoAPI
65: HCRYPTPROV hCryptProv;
66:
1.1.1.9 root 67: #endif // _WIN32
1.1 root 68:
69: /* Init the random number generator, setup the hooks, and start the thread */
70: int
71: Randinit ()
72: {
1.1.1.6 root 73: if(bRandDidInit) return 0;
1.1 root 74:
1.1.1.9 root 75: #ifdef _WIN32
1.1 root 76: InitializeCriticalSection (&critRandProt);
1.1.1.9 root 77: #endif
1.1 root 78:
79: bRandDidInit = TRUE;
80:
81: pRandPool = (unsigned char *) TCalloc (RANDOMPOOL_ALLOCSIZE);
82: if (pRandPool == NULL)
83: goto error;
84: else
85: memset (pRandPool, 0, RANDOMPOOL_ALLOCSIZE);
86:
1.1.1.9 root 87: #ifdef _WIN32
1.1.1.2 root 88: VirtualLock (pRandPool, RANDOMPOOL_ALLOCSIZE);
89:
1.1 root 90: hKeyboard = SetWindowsHookEx (WH_KEYBOARD, (HOOKPROC)&KeyboardProc, NULL, GetCurrentThreadId ());
1.1.1.4 root 91: if (hKeyboard == 0) handleWin32Error (0);
92:
93: hMouse = SetWindowsHookEx (WH_MOUSE, (HOOKPROC)&MouseProc, NULL, GetCurrentThreadId ());
94: if (hMouse == 0)
95: {
96: handleWin32Error (0);
1.1 root 97: goto error;
1.1.1.4 root 98: }
99:
100: if (!CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL, 0)
101: && !CryptAcquireContext (&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET))
102: {
1.1.1.6 root 103: hCryptProv = 0;
1.1.1.4 root 104: }
1.1 root 105:
1.1.1.9 root 106: if (_beginthread (ThreadSafeThreadFunction, 8192, NULL) == -1)
1.1 root 107: goto error;
1.1.1.9 root 108: #endif
1.1 root 109:
110: return 0;
111:
1.1.1.4 root 112: error:
1.1 root 113: Randfree ();
114: return 1;
115: }
116:
117: /* Close everything down, including the thread which is closed down by
118: setting a flag which eventually causes the thread function to exit */
119: void
120: Randfree ()
121: {
122: if (bRandDidInit == FALSE)
123: return;
124:
1.1.1.9 root 125: #ifdef _WIN32
1.1 root 126: EnterCriticalSection (&critRandProt);
127:
128: if (hMouse != 0)
129: UnhookWindowsHookEx (hMouse);
130: if (hKeyboard != 0)
131: UnhookWindowsHookEx (hKeyboard);
132:
133: bThreadTerminate = TRUE;
134:
135: LeaveCriticalSection (&critRandProt);
136:
137: for (;;)
138: {
139: Sleep (250);
140: EnterCriticalSection (&critRandProt);
141: if (bThreadTerminate == FALSE)
142: {
143: LeaveCriticalSection (&critRandProt);
144: break;
145: }
146: LeaveCriticalSection (&critRandProt);
147: }
148:
149: if (hNetAPI32 != 0)
150: {
151: FreeLibrary (hNetAPI32);
152: hNetAPI32 = NULL;
153: }
154:
1.1.1.4 root 155: if (hCryptProv)
156: {
157: CryptReleaseContext (hCryptProv, 0);
158: hCryptProv = 0;
159: }
160:
1.1 root 161: hMouse = NULL;
162: hKeyboard = NULL;
163: bThreadTerminate = FALSE;
164: DeleteCriticalSection (&critRandProt);
1.1.1.9 root 165:
166: #endif // _WIN32
167:
168: if (pRandPool != NULL)
169: {
170: burn (pRandPool, RANDOMPOOL_ALLOCSIZE);
171: TCfree (pRandPool);
172: pRandPool = NULL;
173: }
174:
175: nRandIndex = 0;
1.1 root 176: bRandDidInit = FALSE;
177: }
178:
1.1.1.9 root 179:
1.1.1.6 root 180: void RandSetHashFunction (int hash_algo_id)
1.1.1.3 root 181: {
1.1.1.9 root 182: HashFunction = hash_algo_id;
1.1.1.3 root 183: }
184:
1.1.1.6 root 185: int RandGetHashFunction (void)
186: {
1.1.1.9 root 187: return HashFunction;
1.1.1.6 root 188: }
189:
190: /* The random pool mixing function */
1.1.1.9 root 191: BOOL
1.1 root 192: Randmix ()
193: {
1.1.1.6 root 194: if (bRandmixEnabled)
1.1 root 195: {
1.1.1.6 root 196: unsigned char hashOutputBuffer [MAX_DIGESTSIZE];
197: WHIRLPOOL_CTX wctx;
198: RMD160_CTX rctx;
199: sha1_ctx sctx;
200: int poolIndex, digestIndex, digestSize;
201:
1.1.1.9 root 202: switch (HashFunction)
1.1.1.6 root 203: {
204: case SHA1:
205: digestSize = SHA1_DIGESTSIZE;
206: break;
1.1 root 207:
1.1.1.6 root 208: case RIPEMD160:
209: digestSize = RIPEMD160_DIGESTSIZE;
210: break;
211:
212: case WHIRLPOOL:
213: digestSize = WHIRLPOOL_DIGESTSIZE;
214: break;
1.1.1.9 root 215:
216: default:
217: return FALSE;
1.1.1.6 root 218: }
1.1.1.3 root 219:
1.1.1.6 root 220: for (poolIndex = 0; poolIndex < RNG_POOL_SIZE; poolIndex += digestSize)
221: {
222: /* Compute the message digest of the entire pool using the selected hash function. */
1.1.1.9 root 223: switch (HashFunction)
1.1.1.6 root 224: {
225: case SHA1:
226: sha1_begin (&sctx);
227: sha1_hash (pRandPool, RNG_POOL_SIZE, &sctx);
228: sha1_end (hashOutputBuffer, &sctx);
229: break;
230:
231: case RIPEMD160:
232: RMD160Init(&rctx);
233: RMD160Update(&rctx, pRandPool, RNG_POOL_SIZE);
234: RMD160Final(hashOutputBuffer, &rctx);
235: break;
236:
237: case WHIRLPOOL:
238: WHIRLPOOL_init (&wctx);
239: WHIRLPOOL_add (pRandPool, RNG_POOL_SIZE * 8, &wctx);
240: WHIRLPOOL_finalize (&wctx, hashOutputBuffer);
241: break;
242: }
243:
244: /* XOR the resultant message digest to the pool at the poolIndex position. */
245: for (digestIndex = 0; digestIndex < digestSize; digestIndex++)
246: {
247: pRandPool [poolIndex + digestIndex] ^= hashOutputBuffer [digestIndex];
248: }
249: }
250:
251: /* Prevent leaks */
252: memset (hashOutputBuffer, 0, MAX_DIGESTSIZE);
1.1.1.9 root 253: switch (HashFunction)
1.1.1.6 root 254: {
255: case SHA1:
256: memset (&sctx, 0, sizeof(sctx));
257: break;
258:
259: case RIPEMD160:
260: memset (&rctx, 0, sizeof(rctx));
261: break;
262:
263: case WHIRLPOOL:
264: memset (&wctx, 0, sizeof(wctx));
265: break;
266: }
1.1 root 267: }
1.1.1.9 root 268: return TRUE;
1.1 root 269: }
270:
271: /* Add a buffer to the pool */
272: void
273: RandaddBuf (void *buf, int len)
274: {
275: int i;
276: for (i = 0; i < len; i++)
277: {
278: RandaddByte (((unsigned char *) buf)[i]);
279: }
280: }
281:
1.1.1.9 root 282: #ifdef _WIN32
1.1.1.8 root 283: BOOL
1.1.1.4 root 284: RandpeekBytes (unsigned char *buf, int len)
1.1 root 285: {
1.1.1.6 root 286: if (len > RNG_POOL_SIZE)
1.1.1.7 root 287: {
288: Error ("ERR_NOT_ENOUGH_RANDOM_DATA");
1.1.1.6 root 289: len = RNG_POOL_SIZE;
1.1.1.7 root 290: }
1.1.1.6 root 291:
1.1 root 292: EnterCriticalSection (&critRandProt);
293: memcpy (buf, pRandPool, len);
294: LeaveCriticalSection (&critRandProt);
1.1.1.8 root 295:
296: return TRUE;
1.1 root 297: }
1.1.1.9 root 298: #endif
299:
1.1 root 300:
1.1.1.6 root 301: /* Get len random bytes from the pool (max. RNG_POOL_SIZE bytes per a single call) */
1.1.1.8 root 302: BOOL
1.1.1.4 root 303: RandgetBytes (unsigned char *buf, int len, BOOL forceSlowPoll)
1.1 root 304: {
305: int i;
1.1.1.9 root 306: BOOL ret = TRUE;
307:
308: if (HashFunction == 0)
309: return FALSE;
1.1 root 310:
1.1.1.9 root 311: #ifdef _WIN32
1.1 root 312: EnterCriticalSection (&critRandProt);
1.1.1.9 root 313: #endif
1.1 root 314:
1.1.1.2 root 315: if (bDidSlowPoll == FALSE || forceSlowPoll)
1.1 root 316: {
1.1.1.9 root 317: if (!SlowPoll ())
318: ret = FALSE;
319: else
320: bDidSlowPoll = TRUE;
1.1 root 321: }
1.1.1.2 root 322:
1.1.1.9 root 323: if (!FastPoll ())
324: ret = FALSE;
1.1 root 325:
1.1.1.6 root 326: /* There's never more than RNG_POOL_SIZE worth of randomess */
327: if (len > RNG_POOL_SIZE)
328: {
1.1.1.9 root 329: #ifdef _WIN32
1.1.1.6 root 330: Error ("ERR_NOT_ENOUGH_RANDOM_DATA");
331: len = RNG_POOL_SIZE;
1.1.1.9 root 332: #else
333: return FALSE;
334: #endif
1.1.1.6 root 335: }
1.1 root 336:
1.1.1.2 root 337: // Requested number of bytes is copied from pool to output buffer,
338: // pool is rehashed, and output buffer is XORed with new data from pool
339: for (i = 0; i < len; i++)
340: {
341: buf[i] = pRandPool[randPoolReadIndex++];
1.1.1.6 root 342: if (randPoolReadIndex == RNG_POOL_SIZE) randPoolReadIndex = 0;
1.1.1.2 root 343: }
344:
1.1.1.6 root 345: /* Invert the pool */
346: for (i = 0; i < RNG_POOL_SIZE / 4; i++)
1.1 root 347: {
1.1.1.6 root 348: ((unsigned __int32 *) pRandPool)[i] = ~((unsigned __int32 *) pRandPool)[i];
1.1 root 349: }
350:
1.1.1.6 root 351: // Mix the pool
1.1.1.9 root 352: if (!FastPoll ())
353: ret = FALSE;
1.1.1.4 root 354:
1.1.1.6 root 355: // XOR the current pool content into the output buffer to prevent pool state leaks
1.1.1.4 root 356: for (i = 0; i < len; i++)
357: {
358: buf[i] ^= pRandPool[randPoolReadIndex++];
1.1.1.6 root 359: if (randPoolReadIndex == RNG_POOL_SIZE) randPoolReadIndex = 0;
1.1.1.4 root 360: }
1.1 root 361:
1.1.1.9 root 362: #ifdef _WIN32
1.1 root 363: LeaveCriticalSection (&critRandProt);
1.1.1.9 root 364: #endif
365: return ret;
1.1 root 366: }
367:
1.1.1.9 root 368: #ifdef _WIN32
1.1 root 369: /* Capture the mouse, and as long as the event is not the same as the last
1.1.1.6 root 370: two events, add the crc of the event, and the crc of the time difference
1.1.1.9 root 371: between this event and the last + the current time to the pool.
372: The role of CRC-32 is merely to perform diffusion. Note that the output
373: of CRC-32 is subsequently processed using a cryptographically secure hash
374: algorithm. */
1.1 root 375: LRESULT CALLBACK
376: MouseProc (int nCode, WPARAM wParam, LPARAM lParam)
377: {
378: static DWORD dwLastTimer;
1.1.1.6 root 379: static unsigned __int32 lastCrc, lastCrc2;
1.1 root 380: MOUSEHOOKSTRUCT *lpMouse = (MOUSEHOOKSTRUCT *) lParam;
381:
382: if (nCode < 0)
383: return CallNextHookEx (hMouse, nCode, wParam, lParam);
384: else
385: {
386: DWORD dwTimer = GetTickCount ();
387: DWORD j = dwLastTimer - dwTimer;
1.1.1.6 root 388: unsigned __int32 crc = 0L;
1.1 root 389: int i;
390:
391: dwLastTimer = dwTimer;
392:
393: for (i = 0; i < sizeof (MOUSEHOOKSTRUCT); i++)
394: {
395: crc = UPDC32 (((unsigned char *) lpMouse)[i], crc);
396: }
397:
398: if (crc != lastCrc && crc != lastCrc2)
399: {
1.1.1.6 root 400: unsigned __int32 timeCrc = 0L;
1.1 root 401:
402: for (i = 0; i < 4; i++)
403: {
404: timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
405: }
406:
407: for (i = 0; i < 4; i++)
408: {
409: timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
410: }
411:
412: EnterCriticalSection (&critRandProt);
1.1.1.6 root 413: RandaddInt32 ((unsigned __int32) (crc + timeCrc));
1.1 root 414: LeaveCriticalSection (&critRandProt);
415: }
416: lastCrc2 = lastCrc;
417: lastCrc = crc;
418:
419: }
420: return 0;
421: }
422:
423: /* Capture the keyboard, as long as the event is not the same as the last two
1.1.1.6 root 424: events, add the crc of the event to the pool along with the crc of the time
1.1.1.9 root 425: difference between this event and the last. The role of CRC-32 is merely to
426: perform diffusion. Note that the output of CRC-32 is subsequently processed
427: using a cryptographically secure hash algorithm. */
1.1 root 428: LRESULT CALLBACK
429: KeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
430: {
431: static int lLastKey, lLastKey2;
432: static DWORD dwLastTimer;
433: int nKey = (lParam & 0x00ff0000) >> 16;
434: int nCapture = 0;
435:
436: if (nCode < 0)
437: return CallNextHookEx (hMouse, nCode, wParam, lParam);
438:
439: if ((lParam & 0x0000ffff) == 1 && !(lParam & 0x20000000) &&
440: (lParam & 0x80000000))
441: {
442: if (nKey != lLastKey)
443: nCapture = 1; /* Capture this key */
444: else if (nKey != lLastKey2)
445: nCapture = 1; /* Allow for one repeat */
446: }
447: if (nCapture)
448: {
449: DWORD dwTimer = GetTickCount ();
450: DWORD j = dwLastTimer - dwTimer;
1.1.1.6 root 451: unsigned __int32 timeCrc = 0L;
1.1 root 452: int i;
453:
454: dwLastTimer = dwTimer;
455: lLastKey2 = lLastKey;
456: lLastKey = nKey;
457:
458: for (i = 0; i < 4; i++)
459: {
460: timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
461: }
462:
463: for (i = 0; i < 4; i++)
464: {
465: timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
466: }
467:
468: EnterCriticalSection (&critRandProt);
1.1.1.6 root 469: RandaddInt32 ((unsigned __int32) (crc32int(&lParam) + timeCrc));
1.1 root 470: LeaveCriticalSection (&critRandProt);
471: }
1.1.1.9 root 472:
473: return CallNextHookEx (hMouse, nCode, wParam, lParam);
1.1 root 474: }
475:
476: /* This is the thread function which will poll the system for randomness */
477: void
478: ThreadSafeThreadFunction (void *dummy)
479: {
480: if (dummy); /* Remove unused parameter warning */
481:
482: for (;;)
483: {
484: EnterCriticalSection (&critRandProt);
485:
1.1.1.6 root 486: if (bThreadTerminate)
1.1 root 487: {
488: bThreadTerminate = FALSE;
489: LeaveCriticalSection (&critRandProt);
490: _endthread ();
491: }
1.1.1.6 root 492: else if (bFastPollEnabled)
1.1 root 493: {
494: FastPoll ();
495: }
496:
497: LeaveCriticalSection (&critRandProt);
498:
1.1.1.6 root 499: Sleep (500);
1.1 root 500: }
501: }
502:
503: /* Type definitions for function pointers to call NetAPI32 functions */
504:
505: typedef
506: DWORD (WINAPI * NETSTATISTICSGET) (LPWSTR szServer, LPWSTR szService,
507: DWORD dwLevel, DWORD dwOptions,
508: LPBYTE * lpBuffer);
509: typedef
510: DWORD (WINAPI * NETAPIBUFFERSIZE) (LPVOID lpBuffer, LPDWORD cbBuffer);
511: typedef
512: DWORD (WINAPI * NETAPIBUFFERFREE) (LPVOID lpBuffer);
513:
514: NETSTATISTICSGET pNetStatisticsGet = NULL;
515: NETAPIBUFFERSIZE pNetApiBufferSize = NULL;
516: NETAPIBUFFERFREE pNetApiBufferFree = NULL;
517:
1.1.1.9 root 518: #endif // _WIN32
519:
1.1 root 520: /* This is the slowpoll function which gathers up network/hard drive
521: performance data for the random pool */
1.1.1.9 root 522: BOOL SlowPoll (void)
1.1 root 523: {
1.1.1.9 root 524: int i;
525: #ifdef _WIN32
1.1 root 526: static int isWorkstation = -1;
527: static int cbPerfData = 0x10000;
528: HANDLE hDevice;
529: LPBYTE lpBuffer;
530: DWORD dwSize, status;
531: LPWSTR lpszLanW, lpszLanS;
1.1.1.9 root 532: int nDrive;
1.1 root 533:
534: /* Find out whether this is an NT server or workstation if necessary */
535: if (isWorkstation == -1)
536: {
537: HKEY hKey;
538:
539: if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
540: "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
541: 0, KEY_READ, &hKey) == ERROR_SUCCESS)
542: {
543: unsigned char szValue[32];
544: dwSize = sizeof (szValue);
545:
546: isWorkstation = TRUE;
547: status = RegQueryValueEx (hKey, "ProductType", 0, NULL,
548: szValue, &dwSize);
549:
550: if (status == ERROR_SUCCESS && _stricmp ((char *) szValue, "WinNT"))
551: /* Note: There are (at least) three cases for
552: ProductType: WinNT = NT Workstation,
553: ServerNT = NT Server, LanmanNT = NT Server
554: acting as a Domain Controller */
555: isWorkstation = FALSE;
556:
557: RegCloseKey (hKey);
558: }
559: }
560: /* Initialize the NetAPI32 function pointers if necessary */
561: if (hNetAPI32 == NULL)
562: {
563: /* Obtain a handle to the module containing the Lan Manager
564: functions */
565: hNetAPI32 = LoadLibrary ("NETAPI32.DLL");
566: if (hNetAPI32 != NULL)
567: {
568: /* Now get pointers to the functions */
569: pNetStatisticsGet = (NETSTATISTICSGET) GetProcAddress (hNetAPI32,
570: "NetStatisticsGet");
571: pNetApiBufferSize = (NETAPIBUFFERSIZE) GetProcAddress (hNetAPI32,
572: "NetApiBufferSize");
573: pNetApiBufferFree = (NETAPIBUFFERFREE) GetProcAddress (hNetAPI32,
574: "NetApiBufferFree");
575:
576: /* Make sure we got valid pointers for every NetAPI32
577: function */
578: if (pNetStatisticsGet == NULL ||
579: pNetApiBufferSize == NULL ||
580: pNetApiBufferFree == NULL)
581: {
582: /* Free the library reference and reset the
583: static handle */
584: FreeLibrary (hNetAPI32);
585: hNetAPI32 = NULL;
586: }
587: }
588: }
589:
590: /* Get network statistics. Note: Both NT Workstation and NT Server
591: by default will be running both the workstation and server
592: services. The heuristic below is probably useful though on the
593: assumption that the majority of the network traffic will be via
594: the appropriate service */
595: lpszLanW = (LPWSTR) WIDE ("LanmanWorkstation");
596: lpszLanS = (LPWSTR) WIDE ("LanmanServer");
597: if (hNetAPI32 &&
598: pNetStatisticsGet (NULL,
599: isWorkstation ? lpszLanW : lpszLanS,
600: 0, 0, &lpBuffer) == 0)
601: {
602: pNetApiBufferSize (lpBuffer, &dwSize);
603: RandaddBuf ((unsigned char *) lpBuffer, dwSize);
604: pNetApiBufferFree (lpBuffer);
605: }
606:
607: /* Get disk I/O statistics for all the hard drives */
608: for (nDrive = 0;; nDrive++)
609: {
610: DISK_PERFORMANCE diskPerformance;
611: char szDevice[24];
612:
613: /* Check whether we can access this device */
614: sprintf (szDevice, "\\\\.\\PhysicalDrive%d", nDrive);
615: hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
616: NULL, OPEN_EXISTING, 0, NULL);
617: if (hDevice == INVALID_HANDLE_VALUE)
618: break;
619:
620:
621: /* Note: This only works if you have turned on the disk
622: performance counters with 'diskperf -y'. These counters
623: are off by default */
624: if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
625: &diskPerformance, sizeof (DISK_PERFORMANCE),
626: &dwSize, NULL))
627: {
628: RandaddBuf ((unsigned char *) &diskPerformance, dwSize);
629: }
630: CloseHandle (hDevice);
631: }
632:
1.1.1.4 root 633: // CryptoAPI
1.1.1.7 root 634: for (i = 0; i < 100; i++)
1.1.1.4 root 635: {
1.1.1.6 root 636: if (hCryptProv && CryptGenRandom(hCryptProv, sizeof (buffer), buffer))
1.1.1.4 root 637: RandaddBuf (buffer, sizeof (buffer));
1.1 root 638: }
639:
1.1.1.9 root 640: #else // _WIN32
641:
642: // Read all bytes available in /dev/random up to buffer size
643: int f = open ("/dev/random", O_RDONLY | O_NONBLOCK);
644: if (f == -1)
645: {
646: perror ("Cannot open /dev/random");
647: return FALSE;
648: }
649:
650: i = read (f, buffer, sizeof (buffer));
651: RandaddBuf (buffer, i);
652: close (f);
653:
654: FastPoll ();
655:
656: #endif // #else _WIN32
657:
658: burn(buffer, sizeof (buffer));
1.1.1.6 root 659: Randmix();
1.1.1.9 root 660: return TRUE;
1.1 root 661: }
662:
663:
1.1.1.6 root 664: /* This is the fastpoll function which gathers up info by calling various api's */
1.1.1.9 root 665: BOOL FastPoll (void)
1.1 root 666: {
1.1.1.9 root 667: int nOriginalRandIndex = nRandIndex;
668: #ifdef _WIN32
1.1 root 669: static BOOL addedFixedItems = FALSE;
670: FILETIME creationTime, exitTime, kernelTime, userTime;
671: DWORD minimumWorkingSetSize, maximumWorkingSetSize;
672: LARGE_INTEGER performanceCount;
673: MEMORYSTATUS memoryStatus;
674: HANDLE handle;
675: POINT point;
676:
677: /* Get various basic pieces of system information */
1.1.1.6 root 678: RandaddInt32 (GetActiveWindow ()); /* Handle of active window */
679: RandaddInt32 (GetCapture ()); /* Handle of window with mouse
1.1 root 680: capture */
1.1.1.6 root 681: RandaddInt32 (GetClipboardOwner ()); /* Handle of clipboard owner */
682: RandaddInt32 (GetClipboardViewer ()); /* Handle of start of
1.1 root 683: clpbd.viewer list */
1.1.1.6 root 684: RandaddInt32 (GetCurrentProcess ()); /* Pseudohandle of current
1.1 root 685: process */
1.1.1.6 root 686: RandaddInt32 (GetCurrentProcessId ()); /* Current process ID */
687: RandaddInt32 (GetCurrentThread ()); /* Pseudohandle of current
1.1 root 688: thread */
1.1.1.6 root 689: RandaddInt32 (GetCurrentThreadId ()); /* Current thread ID */
690: RandaddInt32 (GetCurrentTime ()); /* Milliseconds since Windows
1.1 root 691: started */
1.1.1.6 root 692: RandaddInt32 (GetDesktopWindow ()); /* Handle of desktop window */
693: RandaddInt32 (GetFocus ()); /* Handle of window with kb.focus */
694: RandaddInt32 (GetInputState ()); /* Whether sys.queue has any events */
695: RandaddInt32 (GetMessagePos ()); /* Cursor pos.for last message */
696: RandaddInt32 (GetMessageTime ()); /* 1 ms time for last message */
697: RandaddInt32 (GetOpenClipboardWindow ()); /* Handle of window with
1.1 root 698: clpbd.open */
1.1.1.6 root 699: RandaddInt32 (GetProcessHeap ()); /* Handle of process heap */
700: RandaddInt32 (GetProcessWindowStation ()); /* Handle of procs
1.1 root 701: window station */
1.1.1.6 root 702: RandaddInt32 (GetQueueStatus (QS_ALLEVENTS)); /* Types of events in
1.1 root 703: input queue */
704:
705: /* Get multiword system information */
706: GetCaretPos (&point); /* Current caret position */
707: RandaddBuf ((unsigned char *) &point, sizeof (POINT));
708: GetCursorPos (&point); /* Current mouse cursor position */
709: RandaddBuf ((unsigned char *) &point, sizeof (POINT));
710:
711: /* Get percent of memory in use, bytes of physical memory, bytes of
712: free physical memory, bytes in paging file, free bytes in paging
713: file, user bytes of address space, and free user bytes */
714: memoryStatus.dwLength = sizeof (MEMORYSTATUS);
715: GlobalMemoryStatus (&memoryStatus);
716: RandaddBuf ((unsigned char *) &memoryStatus, sizeof (MEMORYSTATUS));
717:
718: /* Get thread and process creation time, exit time, time in kernel
719: mode, and time in user mode in 100ns intervals */
720: handle = GetCurrentThread ();
721: GetThreadTimes (handle, &creationTime, &exitTime, &kernelTime, &userTime);
722: RandaddBuf ((unsigned char *) &creationTime, sizeof (FILETIME));
723: RandaddBuf ((unsigned char *) &exitTime, sizeof (FILETIME));
724: RandaddBuf ((unsigned char *) &kernelTime, sizeof (FILETIME));
725: RandaddBuf ((unsigned char *) &userTime, sizeof (FILETIME));
726: handle = GetCurrentProcess ();
727: GetProcessTimes (handle, &creationTime, &exitTime, &kernelTime, &userTime);
728: RandaddBuf ((unsigned char *) &creationTime, sizeof (FILETIME));
729: RandaddBuf ((unsigned char *) &exitTime, sizeof (FILETIME));
730: RandaddBuf ((unsigned char *) &kernelTime, sizeof (FILETIME));
731: RandaddBuf ((unsigned char *) &userTime, sizeof (FILETIME));
732:
733: /* Get the minimum and maximum working set size for the current
734: process */
735: GetProcessWorkingSetSize (handle, &minimumWorkingSetSize,
736: &maximumWorkingSetSize);
1.1.1.6 root 737: RandaddInt32 (minimumWorkingSetSize);
738: RandaddInt32 (maximumWorkingSetSize);
1.1 root 739:
740: /* The following are fixed for the lifetime of the process so we only
741: add them once */
742: if (addedFixedItems == 0)
743: {
744: STARTUPINFO startupInfo;
745:
746: /* Get name of desktop, console window title, new window
747: position and size, window flags, and handles for stdin,
748: stdout, and stderr */
749: startupInfo.cb = sizeof (STARTUPINFO);
750: GetStartupInfo (&startupInfo);
751: RandaddBuf ((unsigned char *) &startupInfo, sizeof (STARTUPINFO));
752: addedFixedItems = TRUE;
753: }
754: /* The docs say QPC can fail if appropriate hardware is not
755: available. It works on 486 & Pentium boxes, but hasn't been tested
756: for 386 or RISC boxes */
757: if (QueryPerformanceCounter (&performanceCount))
758: RandaddBuf ((unsigned char *) &performanceCount, sizeof (LARGE_INTEGER));
759: else
760: {
761: /* Millisecond accuracy at best... */
762: DWORD dwTicks = GetTickCount ();
763: RandaddBuf ((unsigned char *) &dwTicks, sizeof (dwTicks));
764: }
1.1.1.4 root 765:
766: // CryptoAPI
1.1.1.6 root 767: if (hCryptProv && CryptGenRandom(hCryptProv, sizeof (buffer), buffer))
1.1.1.4 root 768: RandaddBuf (buffer, sizeof (buffer));
1.1.1.6 root 769:
1.1.1.9 root 770: #else // _WIN32
771:
772: // /dev/urandom
773:
774: int f = open ("/dev/urandom", 0);
775:
776: if (f == -1)
777: {
778: perror ("Cannot open /dev/urandom");
779: return FALSE;
780: }
781:
782: if (read (f, buffer, sizeof (buffer)) != sizeof (buffer))
783: {
784: perror ("Read from /dev/urandom failed");
785: close (f);
786: return FALSE;
787: }
788:
789: close (f);
790: RandaddBuf (buffer, sizeof (buffer));
791:
792: #endif // #else _WIN32
793:
1.1.1.6 root 794: /* Apply the pool mixing function */
795: Randmix();
796:
797: /* Restore the original pool cursor position. If this wasn't done, mouse coordinates
798: could be written to a limited area of the pool, especially when moving the mouse
799: uninterruptedly. The severity of the problem would depend on the length of data
800: written by FastPoll (if it was equal to the size of the pool, mouse coordinates
801: would be written only to a particular 4-byte area, whenever moving the mouse
802: uninterruptedly). */
803: nRandIndex = nOriginalRandIndex;
1.1.1.9 root 804:
805: return TRUE;
1.1 root 806: }
1.1.1.9 root 807:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.