1 files changed, 682 insertions, 0 deletions

diff --git a/pwmanager/libcrypt/cipher/rndw32.c b/pwmanager/libcrypt/cipher/rndw32.c
new file mode 100644
index 0000000..870eec6
--- a/dev/null
+++ b/pwmanager/libcrypt/cipher/rndw32.c
@@ -0,0 +1,682 @@
+        /* rndw32.c  -W32 entropy gatherer
+         *Copyright (C) 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
+         *Copyright Peter Gutmann, Matt Thomlinson and Blake Coverett 1996-1999
+ *
+ * This file is part of Libgcrypt.
+ *
+ *************************************************************************
+ * The code here is based on code from Cryptlib 3.0 beta by Peter Gutmann.
+ * Source file misc/rndwin32.c "Win32 Randomness-Gathering Code" with this
+ * copyright notice:
+ *
+ * This module is part of the cryptlib continuously seeded pseudorandom
+ * number generator.  For usage conditions, see lib_rand.c
+ *
+ * [Here is the notice from lib_rand.c, which is now called dev_sys.c]
+ *
+ * This module and the misc/rnd*.c modules represent the cryptlib
+ * continuously seeded pseudorandom number generator (CSPRNG) as described in
+ * my 1998 Usenix Security Symposium paper "The generation of random numbers
+ * for cryptographic purposes".
+ *
+ * The CSPRNG code is copyright Peter Gutmann (and various others) 1996,
+ * 1997, 1998, 1999, all rights reserved.  Redistribution of the CSPRNG
+ * modules and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice
+ *    and this permission notice in its entirety.
+ *
+ * 2. Redistributions in binary form must reproduce the copyright notice in
+ *    the documentation and/or other materials provided with the distribution.
+ *
+ * 3. A copy of any bugfixes or enhancements made must be provided to the
+ *    author, <pgut001@cs.auckland.ac.nz> to allow them to be added to the
+ *    baseline version of the code.
+ *
+ * ALTERNATIVELY, the code may be distributed under the terms of the GNU
+ * General Public License, version 2 or any later version published by the
+ * Free Software Foundation, in which case the provisions of the GNU GPL are
+ * required INSTEAD OF the above restrictions.
+ *
+ * Although not required under the terms of the GPL, it would still be nice if
+ * you could make any changes available to the author to allow a consistent
+ * code base to be maintained
+ *************************************************************************
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+#include <windows.h>
+
+
+#include "types.h"
+#include "g10lib.h"
+#include "rand-internal.h"
+
+
+static int debug_me;
+
+/*
+ * Definitions which are missing from the current GNU Windows32Api
+ */
+
+#ifndef TH32CS_SNAPHEAPLIST
+#define TH32CS_SNAPHEAPLIST 1
+#define TH32CS_SNAPPROCESS  2
+#define TH32CS_SNAPTHREAD   4
+#define TH32CS_SNAPMODULE   8
+        #define TH32CS_SNAPALL    (1|2|4|8)
+        #define TH32CS_INHERIT    0x80000000
+#endif /*TH32CS_SNAPHEAPLIST*/
+
+#ifndef IOCTL_DISK_PERFORMANCE
+        #define IOCTL_DISK_PERFORMANCE0x00070020
+#endif
+#ifndef VER_PLATFORM_WIN32_WINDOWS
+#define VER_PLATFORM_WIN32_WINDOWS 1
+#endif
+
+/* This used to be (6*8+5*4+8*2), but Peter Gutmann figured a larger
+   value in a newer release. So we use a far larger value. */
+#define SIZEOF_DISK_PERFORMANCE_STRUCT 256
+
+
+typedef struct {
+    DWORD dwSize;
+    DWORD th32ProcessID;
+    DWORD th32HeapID;
+    DWORD dwFlags;
+} HEAPLIST32;
+
+typedef struct {
+    DWORD dwSize;
+    HANDLE hHandle;
+    DWORD dwAddress;
+    DWORD dwBlockSize;
+    DWORD dwFlags;
+    DWORD dwLockCount;
+    DWORD dwResvd;
+    DWORD th32ProcessID;
+    DWORD th32HeapID;
+} HEAPENTRY32;
+
+typedef struct {
+    DWORD dwSize;
+    DWORD cntUsage;
+    DWORD th32ProcessID;
+    DWORD th32DefaultHeapID;
+    DWORD th32ModuleID;
+    DWORD cntThreads;
+    DWORD th32ParentProcessID;
+    LONG  pcPriClassBase;
+    DWORD dwFlags;
+    char  szExeFile[260];
+} PROCESSENTRY32;
+
+typedef struct {
+    DWORD dwSize;
+    DWORD cntUsage;
+    DWORD th32ThreadID;
+    DWORD th32OwnerProcessID;
+    LONG  tpBasePri;
+    LONG  tpDeltaPri;
+    DWORD dwFlags;
+} THREADENTRY32;
+
+typedef struct {
+    DWORD dwSize;
+    DWORD th32ModuleID;
+    DWORD th32ProcessID;
+    DWORD GlblcntUsage;
+    DWORD ProccntUsage;
+    BYTE  *modBaseAddr;
+    DWORD modBaseSize;
+    HMODULE hModule;
+    char  szModule[256];
+    char  szExePath[260];
+} MODULEENTRY32;
+
+
+
+/* Type definitions for function pointers to call Toolhelp32 functions
+ * used with the windows95 gatherer */
+typedef BOOL (WINAPI * MODULEWALK) (HANDLE hSnapshot, MODULEENTRY32 *lpme);
+typedef BOOL (WINAPI * THREADWALK) (HANDLE hSnapshot, THREADENTRY32 *lpte);
+typedef BOOL (WINAPI * PROCESSWALK) (HANDLE hSnapshot, PROCESSENTRY32 *lppe);
+typedef BOOL (WINAPI * HEAPLISTWALK) (HANDLE hSnapshot, HEAPLIST32 *lphl);
+typedef BOOL (WINAPI * HEAPFIRST) (HEAPENTRY32 *lphe, DWORD th32ProcessID,
+                                   DWORD th32HeapID);
+typedef BOOL (WINAPI * HEAPNEXT) (HEAPENTRY32 *lphe);
+typedef HANDLE (WINAPI * CREATESNAPSHOT) (DWORD dwFlags, DWORD th32ProcessID);
+
+/* Type definitions for function pointers to call NetAPI32 functions */
+typedef DWORD (WINAPI * NETSTATISTICSGET) (LPWSTR szServer, LPWSTR szService,
+                                           DWORD dwLevel, DWORD dwOptions,
+                                           LPBYTE * lpBuffer);
+typedef DWORD (WINAPI * NETAPIBUFFERSIZE) (LPVOID lpBuffer, LPDWORD cbBuffer);
+typedef DWORD (WINAPI * NETAPIBUFFERFREE) (LPVOID lpBuffer);
+
+
+/* When we query the performance counters, we allocate an initial buffer and
+ * then reallocate it as required until RegQueryValueEx() stops returning
+ * ERROR_MORE_DATA.  The following values define the initial buffer size and
+ * step size by which the buffer is increased
+ */
+        #define PERFORMANCE_BUFFER_SIZE         65536/* Start at 64K */
+        #define PERFORMANCE_BUFFER_STEP         16384/* Step by 16K */
+
+
+static void
+slow_gatherer_windows95( void (*add)(const void*, size_t, int), int requester )
+{
+    static CREATESNAPSHOT pCreateToolhelp32Snapshot = NULL;
+    static MODULEWALK pModule32First = NULL;
+    static MODULEWALK pModule32Next = NULL;
+    static PROCESSWALK pProcess32First = NULL;
+    static PROCESSWALK pProcess32Next = NULL;
+    static THREADWALK pThread32First = NULL;
+    static THREADWALK pThread32Next = NULL;
+    static HEAPLISTWALK pHeap32ListFirst = NULL;
+    static HEAPLISTWALK pHeap32ListNext = NULL;
+    static HEAPFIRST pHeap32First = NULL;
+    static HEAPNEXT pHeap32Next = NULL;
+    HANDLE hSnapshot;
+
+
+    /* initialize the Toolhelp32 function pointers */
+    if ( !pCreateToolhelp32Snapshot ) {
+        HANDLE hKernel;
+
+        if ( debug_me )
+            log_debug ("rndw32#slow_gatherer_95: init toolkit\n" );
+
+        /* Obtain the module handle of the kernel to retrieve the addresses
+         * of the Toolhelp32 functions */
+        if ( ( !(hKernel = GetModuleHandle ("KERNEL32.DLL"))) ) {
+            log_fatal ( "rndw32: can't get module handle\n" );
+        }
+
+        /* Now get pointers to the functions */
+        pCreateToolhelp32Snapshot = (CREATESNAPSHOT) GetProcAddress (hKernel,
+                                                  "CreateToolhelp32Snapshot");
+        pModule32First = (MODULEWALK) GetProcAddress (hKernel, "Module32First");
+        pModule32Next = (MODULEWALK) GetProcAddress (hKernel, "Module32Next");
+        pProcess32First = (PROCESSWALK) GetProcAddress (hKernel,
+                                                        "Process32First");
+        pProcess32Next = (PROCESSWALK) GetProcAddress (hKernel,
+                                                       "Process32Next");
+        pThread32First = (THREADWALK) GetProcAddress (hKernel, "Thread32First");
+        pThread32Next = (THREADWALK) GetProcAddress (hKernel, "Thread32Next");
+        pHeap32ListFirst = (HEAPLISTWALK) GetProcAddress (hKernel,
+                                                          "Heap32ListFirst");
+        pHeap32ListNext = (HEAPLISTWALK) GetProcAddress (hKernel,
+                                                         "Heap32ListNext");
+        pHeap32First = (HEAPFIRST) GetProcAddress (hKernel, "Heap32First");
+        pHeap32Next = (HEAPNEXT) GetProcAddress (hKernel, "Heap32Next");
+
+                if (!pCreateToolhelp32Snapshot
+             || !pModule32First || !pModule32Next
+             || !pProcess32First || !pProcess32Next
+             || !pThread32First  || !pThread32Next
+             || !pHeap32ListFirst || !pHeap32ListNext
+                     || !pHeap32First  || !pHeap32Next  ) {
+            log_fatal ( "rndw32: failed to get a toolhelp function\n" );
+        }
+    }
+
+    /* Take a snapshot of everything we can get to which is currently
+             *in the system */
+    if ( !(hSnapshot = pCreateToolhelp32Snapshot (TH32CS_SNAPALL, 0)) ) {
+        log_fatal ( "rndw32: failed to take a toolhelp snapshot\n" );
+    }
+
+    /* Walk through the local heap */
+            {HEAPLIST32 hl32;
+        hl32.dwSize = sizeof (HEAPLIST32);
+        if (pHeap32ListFirst (hSnapshot, &hl32)) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_95: walk heap\n" );
+            do {
+                HEAPENTRY32 he32;
+
+                /* First add the information from the basic Heaplist32 struct */
+                (*add) ( &hl32, sizeof (hl32), requester );
+
+                /* Now walk through the heap blocks getting information
+                 * on each of them */
+                he32.dwSize = sizeof (HEAPENTRY32);
+                if (pHeap32First (&he32, hl32.th32ProcessID, hl32.th32HeapID)){
+                    do {
+                        (*add) ( &he32, sizeof (he32), requester );
+                    } while (pHeap32Next (&he32));
+                }
+            } while (pHeap32ListNext (hSnapshot, &hl32));
+        }
+    }
+
+
+    /* Walk through all processes */
+            {PROCESSENTRY32 pe32;
+        pe32.dwSize = sizeof (PROCESSENTRY32);
+        if (pProcess32First (hSnapshot, &pe32)) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_95: walk processes\n" );
+            do {
+                (*add) ( &pe32, sizeof (pe32), requester );
+            } while (pProcess32Next (hSnapshot, &pe32));
+        }
+    }
+
+    /* Walk through all threads */
+            {THREADENTRY32 te32;
+        te32.dwSize = sizeof (THREADENTRY32);
+        if (pThread32First (hSnapshot, &te32)) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_95: walk threads\n" );
+            do {
+                (*add) ( &te32, sizeof (te32), requester );
+            } while (pThread32Next (hSnapshot, &te32));
+        }
+    }
+
+    /* Walk through all modules associated with the process */
+            {MODULEENTRY32 me32;
+        me32.dwSize = sizeof (MODULEENTRY32);
+        if (pModule32First (hSnapshot, &me32)) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_95: walk modules\n" );
+            do {
+                (*add) ( &me32, sizeof (me32), requester );
+            } while (pModule32Next (hSnapshot, &me32));
+        }
+    }
+
+    CloseHandle (hSnapshot);
+}
+
+
+
+static void
+slow_gatherer_windowsNT( void (*add)(const void*, size_t, int), int requester )
+{
+    static int is_initialized = 0;
+    static NETSTATISTICSGET pNetStatisticsGet = NULL;
+    static NETAPIBUFFERSIZE pNetApiBufferSize = NULL;
+    static NETAPIBUFFERFREE pNetApiBufferFree = NULL;
+    static int is_workstation = 1;
+
+    static int cbPerfData = PERFORMANCE_BUFFER_SIZE;
+    PERF_DATA_BLOCK *pPerfData;
+    HANDLE hDevice, hNetAPI32 = NULL;
+    DWORD dwSize, status;
+    int nDrive;
+
+    if ( !is_initialized ) {
+        HKEY hKey;
+
+        if ( debug_me )
+            log_debug ("rndw32#slow_gatherer_nt: init toolkit\n" );
+        /* Find out whether this is an NT server or workstation if necessary */
+        if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
+                          "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
+                          0, KEY_READ, &hKey) == ERROR_SUCCESS) {
+            BYTE szValue[32];
+            dwSize = sizeof (szValue);
+
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_nt: check product options\n" );
+            status = RegQueryValueEx (hKey, "ProductType", 0, NULL,
+                                      szValue, &dwSize);
+            if (status == ERROR_SUCCESS && stricmp (szValue, "WinNT")) {
+                /* Note: There are (at least) three cases for ProductType:
+                 * WinNT = NT Workstation, ServerNT = NT Server, LanmanNT =
+                 * NT Server acting as a Domain Controller */
+                is_workstation = 0;
+                if ( debug_me )
+                    log_debug ("rndw32: this is a NT server\n");
+            }
+            RegCloseKey (hKey);
+        }
+
+        /* Initialize the NetAPI32 function pointers if necessary */
+        if ( (hNetAPI32 = LoadLibrary ("NETAPI32.DLL")) ) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_nt: netapi32 loaded\n" );
+            pNetStatisticsGet = (NETSTATISTICSGET) GetProcAddress (hNetAPI32,
+                                                       "NetStatisticsGet");
+            pNetApiBufferSize = (NETAPIBUFFERSIZE) GetProcAddress (hNetAPI32,
+                                                       "NetApiBufferSize");
+            pNetApiBufferFree = (NETAPIBUFFERFREE) GetProcAddress (hNetAPI32,
+                                                       "NetApiBufferFree");
+
+            if ( !pNetStatisticsGet
+                 || !pNetApiBufferSize || !pNetApiBufferFree ) {
+                FreeLibrary (hNetAPI32);
+                hNetAPI32 = NULL;
+                log_debug ("rndw32: No NETAPI found\n" );
+            }
+        }
+
+        is_initialized = 1;
+    }
+
+            /* Get network statistics.Note: Both NT Workstation and NT Server by
+     * default will be running both the workstation and server services.  The
+     * heuristic below is probably useful though on the assumption that the
+     * majority of the network traffic will be via the appropriate service.
+     * In any case the network statistics return almost no randomness */
+            {LPBYTE lpBuffer;
+        if (hNetAPI32 && !pNetStatisticsGet (NULL,
+                           is_workstation ? L"LanmanWorkstation" :
+                           L"LanmanServer", 0, 0, &lpBuffer) ) {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_nt: get netstats\n" );
+            pNetApiBufferSize (lpBuffer, &dwSize);
+            (*add) ( lpBuffer, dwSize,requester );
+            pNetApiBufferFree (lpBuffer);
+        }
+    }
+
+    /* Get disk I/O statistics for all the hard drives */
+    for (nDrive = 0;; nDrive++) {
+        char diskPerformance[SIZEOF_DISK_PERFORMANCE_STRUCT];
+        char szDevice[50];
+
+        /* Check whether we can access this device */
+        sprintf (szDevice, "\\\\.\\PhysicalDrive%d", nDrive);
+        hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, OPEN_EXISTING, 0, NULL);
+        if (hDevice == INVALID_HANDLE_VALUE)
+            break;
+
+        /* Note: This only works if you have turned on the disk performance
+         * counters with 'diskperf -y'.  These counters are off by default */
+        if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
+                             &diskPerformance, SIZEOF_DISK_PERFORMANCE_STRUCT,
+                             &dwSize, NULL))
+        {
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_nt: iostats drive %d\n",
+                                                                  nDrive );
+            (*add) (diskPerformance, dwSize, requester );
+        }
+        else {
+            log_info ("NOTE: you should run 'diskperf -y' "
+                      "to enable the disk statistics\n");
+        }
+        CloseHandle (hDevice);
+    }
+
+#if 0 /* we don't need this in GnuPG  */
+    /* Wait for any async keyset driver binding to complete.  You may be
+     * wondering what this call is doing here... the reason it's necessary is
+     * because RegQueryValueEx() will hang indefinitely if the async driver
+     * bind is in progress.  The problem occurs in the dynamic loading and
+     * linking of driver DLL's, which work as follows:
+     *
+     * hDriver = LoadLibrary( DRIVERNAME );
+     * pFunction1 = ( TYPE_FUNC1 ) GetProcAddress( hDriver, NAME_FUNC1 );
+     * pFunction2 = ( TYPE_FUNC1 ) GetProcAddress( hDriver, NAME_FUNC2 );
+     *
+     * If RegQueryValueEx() is called while the GetProcAddress()'s are in
+     * progress, it will hang indefinitely.  This is probably due to some
+     * synchronisation problem in the NT kernel where the GetProcAddress()
+     * calls affect something like a module reference count or function
+     * reference count while RegQueryValueEx() is trying to take a snapshot
+     * of the statistics, which include the reference counts.  Because of
+     * this, we have to wait until any async driver bind has completed
+     * before we can call RegQueryValueEx() */
+    waitSemaphore (SEMAPHORE_DRIVERBIND);
+#endif
+
+    /* Get information from the system performance counters.  This can take
+     * a few seconds to do.  In some environments the call to
+     * RegQueryValueEx() can produce an access violation at some random time
+     * in the future, adding a short delay after the following code block
+     * makes the problem go away.  This problem is extremely difficult to
+     * reproduce, I haven't been able to get it to occur despite running it
+     * on a number of machines.  The best explanation for the problem is that
+     * on the machine where it did occur, it was caused by an external driver
+     * or other program which adds its own values under the
+     * HKEY_PERFORMANCE_DATA key.  The NT kernel calls the required external
+     * modules to map in the data, if there's a synchronisation problem the
+     * external module would write its data at an inappropriate moment,
+     * causing the access violation.  A low-level memory checker indicated
+     * that ExpandEnvironmentStrings() in KERNEL32.DLL, called an
+     * interminable number of calls down inside RegQueryValueEx(), was
+     * overwriting memory (it wrote twice the allocated size of a buffer to a
+     * buffer allocated by the NT kernel).  This may be what's causing the
+     * problem, but since it's in the kernel there isn't much which can be
+     * done.
+     *
+     * In addition to these problems the code in RegQueryValueEx() which
+     * estimates the amount of memory required to return the performance
+     * counter information isn't very accurate, since it always returns a
+     * worst-case estimate which is usually nowhere near the actual amount
+     * required.  For example it may report that 128K of memory is required,
+     * but only return 64K of data */
+            {pPerfData =  gcry_xmalloc (cbPerfData);
+        for (;;) {
+            dwSize = cbPerfData;
+            if ( debug_me )
+                log_debug ("rndw32#slow_gatherer_nt: get perf data\n" );
+            status = RegQueryValueEx (HKEY_PERFORMANCE_DATA, "Global", NULL,
+                                      NULL, (LPBYTE) pPerfData, &dwSize);
+            if (status == ERROR_SUCCESS) {
+                if (!memcmp (pPerfData->Signature, L"PERF", 8)) {
+                    (*add) ( pPerfData, dwSize, requester );
+                }
+                else
+                    log_debug ( "rndw32: no PERF signature\n");
+                break;
+            }
+            else if (status == ERROR_MORE_DATA) {
+                cbPerfData += PERFORMANCE_BUFFER_STEP;
+                pPerfData = gcry_realloc (pPerfData, cbPerfData);
+            }
+            else {
+                log_debug ( "rndw32: get performance data problem\n");
+                break;
+            }
+        }
+        gcry_free (pPerfData);
+    }
+    /* Although this isn't documented in the Win32 API docs, it's necessary
+       to explicitly close the HKEY_PERFORMANCE_DATA key after use (it's
+       implicitly opened on the first call to RegQueryValueEx()).  If this
+       isn't done then any system components which provide performance data
+       can't be removed or changed while the handle remains active */
+    RegCloseKey (HKEY_PERFORMANCE_DATA);
+}
+
+
+int
+_gcry_rndw32_gather_random( void (*add)(const void*, size_t, int),
+                            int requester,
+                            size_t length, int level )
+{
+    static int is_initialized;
+    static int is_windowsNT, has_toolhelp;
+
+
+    if( !level )
+        return 0;
+    /* We don't differentiate between level 1 and 2 here because
+     * there is no internal entropy pool as a scary resource.  It may
+     * all work slower, but because our entropy source will never
+     * block but deliver some not easy to measure entropy, we assume level 2
+     */
+
+
+    if ( !is_initialized ) {
+        OSVERSIONINFO osvi = { sizeof( osvi ) };
+        DWORD platform;
+
+        GetVersionEx( &osvi );
+        platform = osvi.dwPlatformId;
+        is_windowsNT = platform == VER_PLATFORM_WIN32_NT;
+        has_toolhelp = (platform == VER_PLATFORM_WIN32_WINDOWS
+                        || (is_windowsNT && osvi.dwMajorVersion >= 5));
+
+        if ( platform == VER_PLATFORM_WIN32s ) {
+            log_fatal("can't run on a W32s platform\n" );
+        }
+        is_initialized = 1;
+        if ( debug_me )
+            log_debug ("rndw32#gather_random: platform=%d\n", (int)platform );
+    }
+
+
+    if ( debug_me )
+        log_debug ("rndw32#gather_random: req=%d len=%u lvl=%d\n",
+                           requester, (unsigned int)length, level );
+
+    if ( has_toolhelp ) {
+        slow_gatherer_windows95 ( add, requester );
+    }
+    if ( is_windowsNT ) {
+        slow_gatherer_windowsNT ( add, requester );
+    }
+
+    return 0;
+}
+
+
+int
+_gcry_rndw32_gather_random_fast (void (*add)(const void*, size_t, int),
+                                 int requester )
+{
+    static int addedFixedItems = 0;
+
+    if ( debug_me )
+        log_debug ("rndw32#gather_random_fast: req=%d\n", requester );
+
+    /* Get various basic pieces of system information: Handle of active
+     * window, handle of window with mouse capture, handle of clipboard owner
+     * handle of start of clpboard viewer list, pseudohandle of current
+     * process, current process ID, pseudohandle of current thread, current
+     * thread ID, handle of desktop window, handle  of window with keyboard
+     * focus, whether system queue has any events, cursor position for last
+     * message, 1 ms time for last message, handle of window with clipboard
+     * open, handle of process heap, handle of procs window station, types of
+     * events in input queue, and milliseconds since Windows was started */
+            {byte buffer[20*sizeof(ulong)], *bufptr;
+        bufptr = buffer;
+        #define ADD(f)  do { ulong along = (ulong)(f);        \
+                           memcpy (bufptr, &along, sizeof (along) );  \
+                           bufptr += sizeof (along); } while (0)
+        ADD ( GetActiveWindow ());
+        ADD ( GetCapture ());
+        ADD ( GetClipboardOwner ());
+        ADD ( GetClipboardViewer ());
+        ADD ( GetCurrentProcess ());
+        ADD ( GetCurrentProcessId ());
+        ADD ( GetCurrentThread ());
+        ADD ( GetCurrentThreadId ());
+        ADD ( GetDesktopWindow ());
+        ADD ( GetFocus ());
+        ADD ( GetInputState ());
+        ADD ( GetMessagePos ());
+        ADD ( GetMessageTime ());
+        ADD ( GetOpenClipboardWindow ());
+        ADD ( GetProcessHeap ());
+        ADD ( GetProcessWindowStation ());
+        ADD ( GetQueueStatus (QS_ALLEVENTS));
+        ADD ( GetTickCount ());
+
+        assert ( bufptr-buffer < sizeof (buffer) );
+        (*add) ( buffer, bufptr-buffer, requester );
+#undef ADD
+    }
+
+    /* Get multiword system information: Current caret position, current
+     * mouse cursor position */
+            {POINT point;
+        GetCaretPos (&point);
+        (*add) ( &point, sizeof (point), requester );
+        GetCursorPos (&point);
+        (*add) ( &point, sizeof (point), requester );
+    }
+
+    /* Get percent of memory in use, bytes of physical memory, bytes of free
+     * physical memory, bytes in paging file, free bytes in paging file, user
+     * bytes of address space, and free user bytes */
+            {MEMORYSTATUS memoryStatus;
+        memoryStatus.dwLength = sizeof (MEMORYSTATUS);
+        GlobalMemoryStatus (&memoryStatus);
+        (*add) ( &memoryStatus, sizeof (memoryStatus), requester );
+    }
+
+    /* Get thread and process creation time, exit time, time in kernel mode,
+       and time in user mode in 100ns intervals */
+            {HANDLE handle;
+        FILETIME creationTime, exitTime, kernelTime, userTime;
+        DWORD minimumWorkingSetSize, maximumWorkingSetSize;
+
+        handle = GetCurrentThread ();
+        GetThreadTimes (handle, &creationTime, &exitTime,
+                                               &kernelTime, &userTime);
+        (*add) ( &creationTime, sizeof (creationTime), requester );
+        (*add) ( &exitTime, sizeof (exitTime), requester );
+        (*add) ( &kernelTime, sizeof (kernelTime), requester );
+        (*add) ( &userTime, sizeof (userTime), requester );
+
+        handle = GetCurrentProcess ();
+        GetProcessTimes (handle, &creationTime, &exitTime,
+                                                &kernelTime, &userTime);
+        (*add) ( &creationTime, sizeof (creationTime), requester );
+        (*add) ( &exitTime, sizeof (exitTime), requester );
+        (*add) ( &kernelTime, sizeof (kernelTime), requester );
+        (*add) ( &userTime, sizeof (userTime), requester );
+
+        /* Get the minimum and maximum working set size for the current process */
+        GetProcessWorkingSetSize (handle, &minimumWorkingSetSize,
+                                          &maximumWorkingSetSize);
+        (*add) ( &minimumWorkingSetSize,
+                                   sizeof (&minimumWorkingSetSize), requester );
+        (*add) ( &maximumWorkingSetSize,
+                                   sizeof (&maximumWorkingSetSize), requester );
+    }
+
+
+    /* The following are fixed for the lifetime of the process so we only
+     * add them once */
+    if (!addedFixedItems) {
+        STARTUPINFO startupInfo;
+
+        /* Get name of desktop, console window title, new window position and
+         * size, window flags, and handles for stdin, stdout, and stderr */
+        startupInfo.cb = sizeof (STARTUPINFO);
+        GetStartupInfo (&startupInfo);
+        (*add) ( &startupInfo, sizeof (STARTUPINFO), requester );
+        addedFixedItems = 1;
+    }
+
+    /* The performance of QPC varies depending on the architecture it's
+     * running on and on the OS.  Under NT it reads the CPU's 64-bit timestamp
+     * counter (at least on a Pentium and newer '486's, it hasn't been tested
+     * on anything without a TSC), under Win95 it reads the 1.193180 MHz PIC
+     * timer.  There are vague mumblings in the docs that it may fail if the
+     * appropriate hardware isn't available (possibly '386's or MIPS machines
+     * running NT), but who's going to run NT on a '386? */
+            {LARGE_INTEGER performanceCount;
+        if (QueryPerformanceCounter (&performanceCount)) {
+            if ( debug_me )
+                log_debug ("rndw32#gather_random_fast: perf data\n");
+            (*add) (&performanceCount, sizeof (&performanceCount), requester);
+        }
+        else { /* Millisecond accuracy at best... */
+            DWORD aword = GetTickCount ();
+            (*add) (&aword, sizeof (aword), requester );
+        }
+    }
+
+    return 0;
+}
+