![[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 root 1: /* Copyright (C) 2004 TrueCrypt Team, truecrypt.org
2: This product uses components written by Paul Le Roux <[email protected]> */
3:
4: #include "TCdefs.h"
5:
6: #include <tlhelp32.h>
7:
8: #include "crypto.h"
9: #include "crc.h"
10: #include "random.h"
11: #include "apidrvr.h"
12: #include "dlgcode.h"
13:
14:
15: /* random management defines & pool pointers */
16: #define POOLSIZE 256
17: #define RANDOMPOOL_ALLOCSIZE ( ( POOLSIZE + SHA_DIGESTSIZE - 1 ) \
18: / SHA_DIGESTSIZE ) * SHA_DIGESTSIZE
19:
20: unsigned char *pRandPool = NULL;
21: int nRandIndex = 0;
22:
23: /* Macro to add a single byte to the pool */
24: #define RandaddByte(x) {\
25: if (nRandIndex==POOLSIZE) nRandIndex = 0;\
26: pRandPool[nRandIndex] = (unsigned char) ((unsigned char)x + pRandPool[nRandIndex]); \
27: nRandIndex++; \
28: Randmix(); \
29: }
30:
31: /* Macro to add four bytes to the pool */
32: #define RandaddLong(x) _RandaddLong((unsigned long)x);
33:
34: #pragma warning( disable : 4710 ) /* inline func. not expanded warning */
35:
36: _inline void _RandaddLong(unsigned long x)
37: {
38: RandaddByte(x);
39: RandaddByte((x >> 8));
40: RandaddByte((x >> 16));
41: RandaddByte((x >> 24));
42: }
43:
44: HHOOK hMouse = NULL; /* Mouse hook for the random number generator */
45: HHOOK hKeyboard = NULL; /* Keyboard hook for the random number
46: generator */
47:
48: /* Variables for thread control, the thread is used to gather up info about
49: the system in in the background */
50: CRITICAL_SECTION critRandProt; /* The critical section */
51: BOOL volatile bThreadTerminate = FALSE; /* This variable is shared among
52: thread's so its made volatile */
53: BOOL bDidSlowPoll = FALSE; /* We do the slow poll only once */
54:
55: /* Network library handle for the slowPollWinNT function */
56: HANDLE hNetAPI32 = NULL;
57:
58: BOOL bRandDidInit = FALSE;
59:
60: /* Init the random number generator, setup the hooks, and start the thread */
61: int
62: Randinit ()
63: {
64: HANDLE threadID;
65:
66: if(bRandDidInit == TRUE) return 0;
67:
68: InitializeCriticalSection (&critRandProt);
69:
70: bRandDidInit = TRUE;
71:
72: pRandPool = (unsigned char *) TCalloc (RANDOMPOOL_ALLOCSIZE);
73: if (pRandPool == NULL)
74: goto error;
75: else
76: memset (pRandPool, 0, RANDOMPOOL_ALLOCSIZE);
77:
78: hMouse = SetWindowsHookEx (WH_MOUSE, (HOOKPROC)&MouseProc, NULL, GetCurrentThreadId ());
79: hKeyboard = SetWindowsHookEx (WH_KEYBOARD, (HOOKPROC)&KeyboardProc, NULL, GetCurrentThreadId ());
80: if (hMouse == 0 || hKeyboard == 0)
81: goto error;
82:
83: threadID = (HANDLE) _beginthread (ThreadSafeThreadFunction, 8192, NULL);
84: if (threadID == (HANDLE) - 1)
85: goto error;
86:
87: return 0;
88:
89: error:
90: Randfree ();
91: return 1;
92: }
93:
94: /* Close everything down, including the thread which is closed down by
95: setting a flag which eventually causes the thread function to exit */
96: void
97: Randfree ()
98: {
99: if (bRandDidInit == FALSE)
100: return;
101:
102: EnterCriticalSection (&critRandProt);
103:
104: if (hMouse != 0)
105: UnhookWindowsHookEx (hMouse);
106: if (hKeyboard != 0)
107: UnhookWindowsHookEx (hKeyboard);
108:
109: bThreadTerminate = TRUE;
110:
111: LeaveCriticalSection (&critRandProt);
112:
113: for (;;)
114: {
115: Sleep (250);
116: EnterCriticalSection (&critRandProt);
117: if (bThreadTerminate == FALSE)
118: {
119: LeaveCriticalSection (&critRandProt);
120: break;
121: }
122: LeaveCriticalSection (&critRandProt);
123: }
124:
125: if (pRandPool != NULL)
126: {
127: burn (pRandPool, RANDOMPOOL_ALLOCSIZE);
128: TCfree (pRandPool);
129: pRandPool = NULL;
130: }
131:
132: if (hNetAPI32 != 0)
133: {
134: FreeLibrary (hNetAPI32);
135: hNetAPI32 = NULL;
136: }
137:
138: hMouse = NULL;
139: hKeyboard = NULL;
140: nRandIndex = 0;
141: bThreadTerminate = FALSE;
142: DeleteCriticalSection (&critRandProt);
143: bRandDidInit = FALSE;
144: }
145:
146: /* Mix random pool with the hash function */
147: void
148: Randmix ()
149: {
150: int i;
151:
152: for (i = 0; i < POOLSIZE; i += SHA_DIGESTSIZE)
153: {
154: unsigned char inputBuffer[SHA_BLOCKSIZE];
155: int j;
156:
157: /* Copy SHA_BLOCKSIZE bytes from the circular buffer into the
158: hash data buffer, hash the data, and copy the result back
159: into the random pool */
160: for (j = 0; j < SHA_BLOCKSIZE; j++)
161: inputBuffer[j] = pRandPool[(i + j) % POOLSIZE];
162: SHA1TRANSFORM ((unsigned long *) (pRandPool + i), inputBuffer);
163: memset (inputBuffer, 0, SHA_BLOCKSIZE);
164: }
165: }
166:
167: /* Add a buffer to the pool */
168: void
169: RandaddBuf (void *buf, int len)
170: {
171: int i;
172: for (i = 0; i < len; i++)
173: {
174: RandaddByte (((unsigned char *) buf)[i]);
175: }
176: }
177:
178: void
179: RandpeekBytes (char *buf, int len)
180: {
181: EnterCriticalSection (&critRandProt);
182: memcpy (buf, pRandPool, len);
183: LeaveCriticalSection (&critRandProt);
184: }
185:
186: /* Get a certain amount of true random bytes from the pool */
187: void
188: RandgetBytes (char *buf, int len)
189: {
190: int i;
191:
192: EnterCriticalSection (&critRandProt);
193:
194: FastPoll ();
195:
196: if (bDidSlowPoll == FALSE)
197: {
198: bDidSlowPoll = TRUE;
199:
200: #ifndef _DEBUG
201: if (nCurrentOS == WIN_NT)
202: SlowPollWinNT ();
203: else
204: SlowPollWin9x ();
205: #endif
206: }
207: /* Then mix the pool */
208: Randmix ();
209:
210: /* There's never more than POOLSIZE worth of randomess */
211: if (len > POOLSIZE)
212: len = POOLSIZE;
213:
214: /* Extract out the random bytes needed */
215: memcpy (buf, pRandPool, len);
216:
217: /* Now invert the pool */
218: for (i = 0; i < POOLSIZE / 4; i++)
219: {
220: ((unsigned long *) pRandPool)[i] = ~((unsigned long *) pRandPool)[i];
221: }
222:
223: /* Now remix the pool, creating the new pool */
224: Randmix ();
225:
226: LeaveCriticalSection (&critRandProt);
227: }
228:
229: /* Capture the mouse, and as long as the event is not the same as the last
230: two events :- add a crc of the event, and a crc of the time difference
231: between this event and the last + the current time to the pool */
232: LRESULT CALLBACK
233: MouseProc (int nCode, WPARAM wParam, LPARAM lParam)
234: {
235: static DWORD dwLastTimer;
236: static unsigned long lastCrc, lastCrc2;
237: MOUSEHOOKSTRUCT *lpMouse = (MOUSEHOOKSTRUCT *) lParam;
238:
239: if (nCode < 0)
240: return CallNextHookEx (hMouse, nCode, wParam, lParam);
241: else
242: {
243: DWORD dwTimer = GetTickCount ();
244: DWORD j = dwLastTimer - dwTimer;
245: unsigned long crc = 0L;
246: int i;
247:
248: dwLastTimer = dwTimer;
249:
250: for (i = 0; i < sizeof (MOUSEHOOKSTRUCT); i++)
251: {
252: crc = UPDC32 (((unsigned char *) lpMouse)[i], crc);
253: }
254:
255: if (crc != lastCrc && crc != lastCrc2)
256: {
257: unsigned long timeCrc = 0L;
258:
259: for (i = 0; i < 4; i++)
260: {
261: timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
262: }
263:
264: for (i = 0; i < 4; i++)
265: {
266: timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
267: }
268:
269: EnterCriticalSection (&critRandProt);
270: RandaddLong (timeCrc);
271: RandaddLong (crc);
272: LeaveCriticalSection (&critRandProt);
273: }
274: lastCrc2 = lastCrc;
275: lastCrc = crc;
276:
277: }
278: return 0;
279: }
280:
281: /* Capture the keyboard, as long as the event is not the same as the last two
282: events :- add a crc of the event to the pool along with a crc of the time
283: difference between this event and the last */
284: LRESULT CALLBACK
285: KeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
286: {
287: static int lLastKey, lLastKey2;
288: static DWORD dwLastTimer;
289: int nKey = (lParam & 0x00ff0000) >> 16;
290: int nCapture = 0;
291:
292: if (nCode < 0)
293: return CallNextHookEx (hMouse, nCode, wParam, lParam);
294:
295: if ((lParam & 0x0000ffff) == 1 && !(lParam & 0x20000000) &&
296: (lParam & 0x80000000))
297: {
298: if (nKey != lLastKey)
299: nCapture = 1; /* Capture this key */
300: else if (nKey != lLastKey2)
301: nCapture = 1; /* Allow for one repeat */
302: }
303: if (nCapture)
304: {
305: DWORD dwTimer = GetTickCount ();
306: DWORD j = dwLastTimer - dwTimer;
307: unsigned long timeCrc = 0L;
308: int i;
309:
310: dwLastTimer = dwTimer;
311: lLastKey2 = lLastKey;
312: lLastKey = nKey;
313:
314: for (i = 0; i < 4; i++)
315: {
316: timeCrc = UPDC32 (((unsigned char *) &j)[i], timeCrc);
317: }
318:
319: for (i = 0; i < 4; i++)
320: {
321: timeCrc = UPDC32 (((unsigned char *) &dwTimer)[i], timeCrc);
322: }
323:
324: EnterCriticalSection (&critRandProt);
325: RandaddLong (lParam);
326: RandaddLong (timeCrc);
327: LeaveCriticalSection (&critRandProt);
328: }
329: return 0;
330: }
331:
332: /* This is the thread function which will poll the system for randomness */
333: void
334: ThreadSafeThreadFunction (void *dummy)
335: {
336: if (dummy); /* Remove unused parameter warning */
337:
338: for (;;)
339: {
340: EnterCriticalSection (&critRandProt);
341:
342: if (bThreadTerminate == TRUE)
343: {
344: bThreadTerminate = FALSE;
345: LeaveCriticalSection (&critRandProt);
346: _endthread ();
347: }
348: else
349: {
350: FastPoll ();
351: }
352:
353: LeaveCriticalSection (&critRandProt);
354:
355: Sleep (250);
356: }
357: }
358:
359: /* Type definitions for function pointers to call NetAPI32 functions */
360:
361: typedef
362: DWORD (WINAPI * NETSTATISTICSGET) (LPWSTR szServer, LPWSTR szService,
363: DWORD dwLevel, DWORD dwOptions,
364: LPBYTE * lpBuffer);
365: typedef
366: DWORD (WINAPI * NETAPIBUFFERSIZE) (LPVOID lpBuffer, LPDWORD cbBuffer);
367: typedef
368: DWORD (WINAPI * NETAPIBUFFERFREE) (LPVOID lpBuffer);
369:
370: NETSTATISTICSGET pNetStatisticsGet = NULL;
371: NETAPIBUFFERSIZE pNetApiBufferSize = NULL;
372: NETAPIBUFFERFREE pNetApiBufferFree = NULL;
373:
374: /* This is the slowpoll function which gathers up network/hard drive
375: performance data for the random pool */
376: void
377: SlowPollWinNT (void)
378: {
379: static int isWorkstation = -1;
380: PPERF_DATA_BLOCK pPerfData;
381: static int cbPerfData = 0x10000;
382: HANDLE hDevice;
383: LPBYTE lpBuffer;
384: DWORD dwSize, status;
385: LPWSTR lpszLanW, lpszLanS;
386: int nDrive;
387:
388: /* Find out whether this is an NT server or workstation if necessary */
389: if (isWorkstation == -1)
390: {
391: HKEY hKey;
392:
393: if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
394: "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
395: 0, KEY_READ, &hKey) == ERROR_SUCCESS)
396: {
397: unsigned char szValue[32];
398: dwSize = sizeof (szValue);
399:
400: isWorkstation = TRUE;
401: status = RegQueryValueEx (hKey, "ProductType", 0, NULL,
402: szValue, &dwSize);
403:
404: if (status == ERROR_SUCCESS && _stricmp ((char *) szValue, "WinNT"))
405: /* Note: There are (at least) three cases for
406: ProductType: WinNT = NT Workstation,
407: ServerNT = NT Server, LanmanNT = NT Server
408: acting as a Domain Controller */
409: isWorkstation = FALSE;
410:
411: RegCloseKey (hKey);
412: }
413: }
414: /* Initialize the NetAPI32 function pointers if necessary */
415: if (hNetAPI32 == NULL)
416: {
417: /* Obtain a handle to the module containing the Lan Manager
418: functions */
419: hNetAPI32 = LoadLibrary ("NETAPI32.DLL");
420: if (hNetAPI32 != NULL)
421: {
422: /* Now get pointers to the functions */
423: pNetStatisticsGet = (NETSTATISTICSGET) GetProcAddress (hNetAPI32,
424: "NetStatisticsGet");
425: pNetApiBufferSize = (NETAPIBUFFERSIZE) GetProcAddress (hNetAPI32,
426: "NetApiBufferSize");
427: pNetApiBufferFree = (NETAPIBUFFERFREE) GetProcAddress (hNetAPI32,
428: "NetApiBufferFree");
429:
430: /* Make sure we got valid pointers for every NetAPI32
431: function */
432: if (pNetStatisticsGet == NULL ||
433: pNetApiBufferSize == NULL ||
434: pNetApiBufferFree == NULL)
435: {
436: /* Free the library reference and reset the
437: static handle */
438: FreeLibrary (hNetAPI32);
439: hNetAPI32 = NULL;
440: }
441: }
442: }
443:
444: /* Get network statistics. Note: Both NT Workstation and NT Server
445: by default will be running both the workstation and server
446: services. The heuristic below is probably useful though on the
447: assumption that the majority of the network traffic will be via
448: the appropriate service */
449: lpszLanW = (LPWSTR) WIDE ("LanmanWorkstation");
450: lpszLanS = (LPWSTR) WIDE ("LanmanServer");
451: if (hNetAPI32 &&
452: pNetStatisticsGet (NULL,
453: isWorkstation ? lpszLanW : lpszLanS,
454: 0, 0, &lpBuffer) == 0)
455: {
456: pNetApiBufferSize (lpBuffer, &dwSize);
457: RandaddBuf ((unsigned char *) lpBuffer, dwSize);
458: pNetApiBufferFree (lpBuffer);
459: }
460:
461: /* Get disk I/O statistics for all the hard drives */
462: for (nDrive = 0;; nDrive++)
463: {
464: DISK_PERFORMANCE diskPerformance;
465: char szDevice[24];
466:
467: /* Check whether we can access this device */
468: sprintf (szDevice, "\\\\.\\PhysicalDrive%d", nDrive);
469: hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
470: NULL, OPEN_EXISTING, 0, NULL);
471: if (hDevice == INVALID_HANDLE_VALUE)
472: break;
473:
474:
475: /* Note: This only works if you have turned on the disk
476: performance counters with 'diskperf -y'. These counters
477: are off by default */
478: if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
479: &diskPerformance, sizeof (DISK_PERFORMANCE),
480: &dwSize, NULL))
481: {
482: RandaddBuf ((unsigned char *) &diskPerformance, dwSize);
483: }
484: CloseHandle (hDevice);
485: }
486:
487: /* Get the performance counters */
488: pPerfData = (PPERF_DATA_BLOCK) TCalloc (cbPerfData);
489: while (pPerfData)
490: {
491: dwSize = cbPerfData;
492: status = RegQueryValueEx (HKEY_PERFORMANCE_DATA, "Global", NULL,
493: NULL, (LPBYTE) pPerfData, &dwSize);
494:
495: if (status == ERROR_SUCCESS)
496: {
497: RegCloseKey (HKEY_PERFORMANCE_DATA);
498: if (memcmp (pPerfData->Signature, WIDE ("PERF"), 8) == 0)
499: RandaddBuf (pPerfData, dwSize);
500: TCfree (pPerfData);
501: pPerfData = NULL;
502: }
503: else if (status == ERROR_MORE_DATA)
504: {
505: cbPerfData += 4096;
506: pPerfData = (PPERF_DATA_BLOCK) realloc (pPerfData, cbPerfData);
507: }
508: }
509: }
510:
511:
512: /* Win9x typedefs and variables for toolhelp32 use */
513: typedef BOOL (WINAPI * MODULEWALK) (HANDLE hSnapshot, LPMODULEENTRY32 lpme);
514: typedef BOOL (WINAPI * THREADWALK) (HANDLE hSnapshot, LPTHREADENTRY32 lpte);
515: typedef BOOL (WINAPI * PROCESSWALK) (HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
516: typedef BOOL (WINAPI * HEAPLISTWALK) (HANDLE hSnapshot, LPHEAPLIST32 lphl);
517: typedef BOOL (WINAPI * HEAPFIRST) (LPHEAPENTRY32 lphe, DWORD th32ProcessID, DWORD th32HeapID);
518: typedef BOOL (WINAPI * HEAPNEXT) (LPHEAPENTRY32 lphe);
519: typedef HANDLE (WINAPI * CREATESNAPSHOT) (DWORD dwFlags, DWORD th32ProcessID);
520: CREATESNAPSHOT pCreateToolhelp32Snapshot = NULL;
521: MODULEWALK pModule32First = NULL;
522: MODULEWALK pModule32Next = NULL;
523: PROCESSWALK pProcess32First = NULL;
524: PROCESSWALK pProcess32Next = NULL;
525: THREADWALK pThread32First = NULL;
526: THREADWALK pThread32Next = NULL;
527: HEAPLISTWALK pHeap32ListFirst = NULL;
528: HEAPLISTWALK pHeap32ListNext = NULL;
529: HEAPFIRST pHeap32First = NULL;
530: HEAPNEXT pHeap32Next = NULL;
531:
532: void
533: SlowPollWin9x (void)
534: {
535: PROCESSENTRY32 pe32;
536: THREADENTRY32 te32;
537: MODULEENTRY32 me32;
538: HEAPLIST32 hl32;
539: HANDLE hSnapshot;
540:
541: /* Initialize the Toolhelp32 function pointers if necessary */
542: if (pCreateToolhelp32Snapshot == NULL)
543: {
544: HANDLE hKernel = NULL;
545:
546: /* Obtain the module handle of the kernel to retrieve the
547: addresses of the Toolhelp32 functions */
548: if ((hKernel = GetModuleHandle ("KERNEL32.DLL")) == NULL)
549: return;
550:
551: /* Now get pointers to the functions */
552: pCreateToolhelp32Snapshot = (CREATESNAPSHOT) GetProcAddress (hKernel,
553: "CreateToolhelp32Snapshot");
554: pModule32First = (MODULEWALK) GetProcAddress (hKernel,
555: "Module32First");
556: pModule32Next = (MODULEWALK) GetProcAddress (hKernel,
557: "Module32Next");
558: pProcess32First = (PROCESSWALK) GetProcAddress (hKernel,
559: "Process32First");
560: pProcess32Next = (PROCESSWALK) GetProcAddress (hKernel,
561: "Process32Next");
562: pThread32First = (THREADWALK) GetProcAddress (hKernel,
563: "Thread32First");
564: pThread32Next = (THREADWALK) GetProcAddress (hKernel,
565: "Thread32Next");
566: pHeap32ListFirst = (HEAPLISTWALK) GetProcAddress (hKernel,
567: "Heap32ListFirst");
568: pHeap32ListNext = (HEAPLISTWALK) GetProcAddress (hKernel,
569: "Heap32ListNext");
570: pHeap32First = (HEAPFIRST) GetProcAddress (hKernel,
571: "Heap32First");
572: pHeap32Next = (HEAPNEXT) GetProcAddress (hKernel,
573: "Heap32Next");
574:
575: /* Make sure we got valid pointers for every Toolhelp32
576: function */
577: if (pModule32First == NULL || pModule32Next == NULL || \
578: pProcess32First == NULL || pProcess32Next == NULL || \
579: pThread32First == NULL || pThread32Next == NULL || \
580: pHeap32ListFirst == NULL || pHeap32ListNext == NULL || \
581: pHeap32First == NULL || pHeap32Next == NULL || \
582: pCreateToolhelp32Snapshot == NULL)
583: {
584: /* Mark the main function as unavailable in case for
585: future reference */
586: pCreateToolhelp32Snapshot = NULL;
587: return;
588: }
589: }
590:
591: /* Take a snapshot of everything we can get to which is currently in
592: the system */
593: hSnapshot = pCreateToolhelp32Snapshot (TH32CS_SNAPALL, 0);
594: if (!hSnapshot)
595: return;
596:
597: /* Walk through the local heap */
598: hl32.dwSize = sizeof (HEAPLIST32);
599: if (pHeap32ListFirst (hSnapshot, &hl32))
600: do
601: {
602: HEAPENTRY32 he32;
603:
604: /* First add the information from the basic
605: Heaplist32 structure */
606: RandaddBuf ((BYTE *) & hl32, sizeof (HEAPLIST32));
607:
608: /* Now walk through the heap blocks getting
609: information on each of them */
610: he32.dwSize = sizeof (HEAPENTRY32);
611: if (pHeap32First (&he32, hl32.th32ProcessID, hl32.th32HeapID))
612: do
613: {
614: RandaddBuf ((BYTE *) & he32, sizeof (HEAPENTRY32));
615: }
616: while (pHeap32Next (&he32));
617: }
618: while (pHeap32ListNext (hSnapshot, &hl32));
619:
620: /* Walk through all processes */
621: pe32.dwSize = sizeof (PROCESSENTRY32);
622: if (pProcess32First (hSnapshot, &pe32))
623: do
624: {
625: RandaddBuf ((BYTE *) & pe32, sizeof (PROCESSENTRY32));
626: }
627: while (pProcess32Next (hSnapshot, &pe32));
628:
629: /* Walk through all threads */
630: te32.dwSize = sizeof (THREADENTRY32);
631: if (pThread32First (hSnapshot, &te32))
632: do
633: {
634: RandaddBuf ((BYTE *) & te32, sizeof (THREADENTRY32));
635: }
636: while (pThread32Next (hSnapshot, &te32));
637:
638: /* Walk through all modules associated with the process */
639: me32.dwSize = sizeof (MODULEENTRY32);
640: if (pModule32First (hSnapshot, &me32))
641: do
642: {
643: RandaddBuf ((BYTE *) & me32, sizeof (MODULEENTRY32));
644: }
645: while (pModule32Next (hSnapshot, &me32));
646:
647: /* Clean up the snapshot */
648: CloseHandle (hSnapshot);
649: }
650:
651:
652:
653: /* This is the fastpoll function which gathers up info by calling various
654: api's */
655: void
656: FastPoll (void)
657: {
658: static BOOL addedFixedItems = FALSE;
659: FILETIME creationTime, exitTime, kernelTime, userTime;
660: DWORD minimumWorkingSetSize, maximumWorkingSetSize;
661: LARGE_INTEGER performanceCount;
662: MEMORYSTATUS memoryStatus;
663: HANDLE handle;
664: POINT point;
665:
666: /* Get various basic pieces of system information */
667: RandaddLong (GetActiveWindow ()); /* Handle of active window */
668: RandaddLong (GetCapture ()); /* Handle of window with mouse
669: capture */
670: RandaddLong (GetClipboardOwner ()); /* Handle of clipboard owner */
671: RandaddLong (GetClipboardViewer ()); /* Handle of start of
672: clpbd.viewer list */
673: RandaddLong (GetCurrentProcess ()); /* Pseudohandle of current
674: process */
675: RandaddLong (GetCurrentProcessId ()); /* Current process ID */
676: RandaddLong (GetCurrentThread ()); /* Pseudohandle of current
677: thread */
678: RandaddLong (GetCurrentThreadId ()); /* Current thread ID */
679: RandaddLong (GetCurrentTime ()); /* Milliseconds since Windows
680: started */
681: RandaddLong (GetDesktopWindow ()); /* Handle of desktop window */
682: RandaddLong (GetFocus ()); /* Handle of window with kb.focus */
683: RandaddLong (GetInputState ()); /* Whether sys.queue has any events */
684: RandaddLong (GetMessagePos ()); /* Cursor pos.for last message */
685: RandaddLong (GetMessageTime ()); /* 1 ms time for last message */
686: RandaddLong (GetOpenClipboardWindow ()); /* Handle of window with
687: clpbd.open */
688: RandaddLong (GetProcessHeap ()); /* Handle of process heap */
689: RandaddLong (GetProcessWindowStation ()); /* Handle of procs
690: window station */
691: RandaddLong (GetQueueStatus (QS_ALLEVENTS)); /* Types of events in
692: input queue */
693:
694: /* Get multiword system information */
695: GetCaretPos (&point); /* Current caret position */
696: RandaddBuf ((unsigned char *) &point, sizeof (POINT));
697: GetCursorPos (&point); /* Current mouse cursor position */
698: RandaddBuf ((unsigned char *) &point, sizeof (POINT));
699:
700: /* Get percent of memory in use, bytes of physical memory, bytes of
701: free physical memory, bytes in paging file, free bytes in paging
702: file, user bytes of address space, and free user bytes */
703: memoryStatus.dwLength = sizeof (MEMORYSTATUS);
704: GlobalMemoryStatus (&memoryStatus);
705: RandaddBuf ((unsigned char *) &memoryStatus, sizeof (MEMORYSTATUS));
706:
707: /* Get thread and process creation time, exit time, time in kernel
708: mode, and time in user mode in 100ns intervals */
709: handle = GetCurrentThread ();
710: GetThreadTimes (handle, &creationTime, &exitTime, &kernelTime, &userTime);
711: RandaddBuf ((unsigned char *) &creationTime, sizeof (FILETIME));
712: RandaddBuf ((unsigned char *) &exitTime, sizeof (FILETIME));
713: RandaddBuf ((unsigned char *) &kernelTime, sizeof (FILETIME));
714: RandaddBuf ((unsigned char *) &userTime, sizeof (FILETIME));
715: handle = GetCurrentProcess ();
716: GetProcessTimes (handle, &creationTime, &exitTime, &kernelTime, &userTime);
717: RandaddBuf ((unsigned char *) &creationTime, sizeof (FILETIME));
718: RandaddBuf ((unsigned char *) &exitTime, sizeof (FILETIME));
719: RandaddBuf ((unsigned char *) &kernelTime, sizeof (FILETIME));
720: RandaddBuf ((unsigned char *) &userTime, sizeof (FILETIME));
721:
722: /* Get the minimum and maximum working set size for the current
723: process */
724: GetProcessWorkingSetSize (handle, &minimumWorkingSetSize,
725: &maximumWorkingSetSize);
726: RandaddLong (minimumWorkingSetSize);
727: RandaddLong (maximumWorkingSetSize);
728:
729: /* The following are fixed for the lifetime of the process so we only
730: add them once */
731: if (addedFixedItems == 0)
732: {
733: STARTUPINFO startupInfo;
734:
735: /* Get name of desktop, console window title, new window
736: position and size, window flags, and handles for stdin,
737: stdout, and stderr */
738: startupInfo.cb = sizeof (STARTUPINFO);
739: GetStartupInfo (&startupInfo);
740: RandaddBuf ((unsigned char *) &startupInfo, sizeof (STARTUPINFO));
741: addedFixedItems = TRUE;
742: }
743: /* The docs say QPC can fail if appropriate hardware is not
744: available. It works on 486 & Pentium boxes, but hasn't been tested
745: for 386 or RISC boxes */
746: if (QueryPerformanceCounter (&performanceCount))
747: RandaddBuf ((unsigned char *) &performanceCount, sizeof (LARGE_INTEGER));
748: else
749: {
750: /* Millisecond accuracy at best... */
751: DWORD dwTicks = GetTickCount ();
752: RandaddBuf ((unsigned char *) &dwTicks, sizeof (dwTicks));
753: }
754: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.