74007e3141132e3f03a23bee249c6d728479fed0
[libgcrypt.git] / cipher / rndw32.c
1 /* rndw32.c  -  W32 entropy gatherer
2  * Copyright (C) 1999, 2000, 2002, 2003, 2007 Free Software Foundation, Inc.
3  * Copyright Peter Gutmann, Matt Thomlinson and Blake Coverett 1996-2006
4  *
5  * This file is part of Libgcrypt.
6  *
7  *************************************************************************
8  * The code here is based on code from Cryptlib 3.0 beta by Peter Gutmann.
9  * Source file misc/rndwin32.c "Win32 Randomness-Gathering Code" with this
10  * copyright notice:
11  *
12  * This module is part of the cryptlib continuously seeded pseudorandom
13  * number generator.  For usage conditions, see lib_rand.c
14  *
15  * [Here is the notice from lib_rand.c, which is now called dev_sys.c]
16  *
17  * This module and the misc/rnd*.c modules represent the cryptlib
18  * continuously seeded pseudorandom number generator (CSPRNG) as described in
19  * my 1998 Usenix Security Symposium paper "The generation of random numbers
20  * for cryptographic purposes".
21  *
22  * The CSPRNG code is copyright Peter Gutmann (and various others) 1996,
23  * 1997, 1998, 1999, all rights reserved.  Redistribution of the CSPRNG
24  * modules and use in source and binary forms, with or without modification,
25  * are permitted provided that the following conditions are met:
26  *
27  * 1. Redistributions of source code must retain the above copyright notice
28  *    and this permission notice in its entirety.
29  *
30  * 2. Redistributions in binary form must reproduce the copyright notice in
31  *    the documentation and/or other materials provided with the distribution.
32  *
33  * 3. A copy of any bugfixes or enhancements made must be provided to the
34  *    author, <pgut001@cs.auckland.ac.nz> to allow them to be added to the
35  *    baseline version of the code.
36  *
37  * ALTERNATIVELY, the code may be distributed under the terms of the
38  * GNU Lesser General Public License, version 2.1 or any later version
39  * published by the Free Software Foundation, in which case the
40  * provisions of the GNU LGPL are required INSTEAD OF the above
41  * restrictions.
42  *
43  * Although not required under the terms of the LGPL, it would still
44  * be nice if you could make any changes available to the author to
45  * allow a consistent code base to be maintained.
46  *************************************************************************
47  * The above alternative was changed from GPL to LGPL on 2007-08-22 with
48  * permission from Peter Gutmann:
49  *==========
50  From: pgut001 <pgut001@cs.auckland.ac.nz>
51  Subject: Re: LGPL for the windows entropy gatherer
52  To: wk@gnupg.org
53  Date: Wed, 22 Aug 2007 03:05:42 +1200
54
55  Hi,
56
57  >As of now libgcrypt is GPL under Windows due to that module and some people
58  >would really like to see it under LGPL too.  Can you do such a license change
59  >to LGPL version 2?  Note that LGPL give the user the option to relicense it
60  >under GPL, so the change would be pretty easy and backwar compatible.
61
62  Sure.  I assumed that since GPG was GPLd, you'd prefer the GPL for the entropy
63  code as well, but Ian asked for LGPL as an option so as of the next release
64  I'll have LGPL in there.  You can consider it to be retroactive, so your
65  current version will be LGPLd as well.
66
67  Peter.
68  *==========
69  */
70
71 #include <config.h>
72 #include <stdio.h>
73 #include <stdlib.h>
74 #include <assert.h>
75 #include <errno.h>
76 #include <string.h>
77 #ifdef __GNUC__  
78 #include <stdint.h>
79 #endif
80
81 #include <windows.h>
82
83
84 #include "types.h"
85 #include "g10lib.h"
86 #include "rand-internal.h"
87
88
89 /* Definitions which are missing from the current GNU Windows32Api.  */
90 #ifndef IOCTL_DISK_PERFORMANCE
91 #define IOCTL_DISK_PERFORMANCE  0x00070020
92 #endif
93
94 /* This used to be (6*8+5*4+8*2), but Peter Gutmann figured a larger
95    value in a newer release. So we use a far larger value. */
96 #define SIZEOF_DISK_PERFORMANCE_STRUCT 256
97
98 /* We don't include wincrypt.h so define it here.  */
99 #define HCRYPTPROV  HANDLE
100
101
102 /* When we query the performance counters, we allocate an initial buffer and
103  * then reallocate it as required until RegQueryValueEx() stops returning
104  * ERROR_MORE_DATA.  The following values define the initial buffer size and
105  * step size by which the buffer is increased
106  */
107 #define PERFORMANCE_BUFFER_SIZE         65536   /* Start at 64K */
108 #define PERFORMANCE_BUFFER_STEP         16384   /* Step by 16K */
109
110
111 /* The number of bytes to read from the system RNG on each slow poll.  */
112 #define SYSTEMRNG_BYTES 64
113
114 /* Intel Chipset CSP type and name */
115 #define PROV_INTEL_SEC  22
116 #define INTEL_DEF_PROV  "Intel Hardware Cryptographic Service Provider"
117
118
119
120
121 /* Type definitions for function pointers to call NetAPI32 functions.  */
122 typedef DWORD (WINAPI *NETSTATISTICSGET)(LPWSTR szServer, LPWSTR szService,
123                                          DWORD dwLevel, DWORD dwOptions,
124                                          LPBYTE *lpBuffer);
125 typedef DWORD (WINAPI *NETAPIBUFFERSIZE)(LPVOID lpBuffer, LPDWORD cbBuffer);
126 typedef DWORD (WINAPI *NETAPIBUFFERFREE)(LPVOID lpBuffer);
127
128 /* Type definitions for function pointers to call native NT functions.  */
129 typedef DWORD (WINAPI *NTQUERYSYSTEMINFORMATION)(DWORD systemInformationClass,
130                                                  PVOID systemInformation,
131                                                  ULONG systemInformationLength,
132                                                  PULONG returnLength);
133 typedef DWORD (WINAPI *NTQUERYINFORMATIONPROCESS)
134      (HANDLE processHandle, DWORD processInformationClass,
135       PVOID processInformation, ULONG processInformationLength,
136       PULONG returnLength);
137 typedef DWORD (WINAPI *NTPOWERINFORMATION)
138      (DWORD powerInformationClass, PVOID inputBuffer,
139       ULONG inputBufferLength, PVOID outputBuffer, ULONG outputBufferLength );
140
141 /* Type definitions for function pointers to call CryptoAPI functions. */
142 typedef BOOL (WINAPI *CRYPTACQUIRECONTEXT)(HCRYPTPROV *phProv,
143                                            LPCTSTR pszContainer,
144                                            LPCTSTR pszProvider, 
145                                            DWORD dwProvType,
146                                            DWORD dwFlags);
147 typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen,
148                                       BYTE *pbBuffer);
149 typedef BOOL (WINAPI *CRYPTRELEASECONTEXT)(HCRYPTPROV hProv, DWORD dwFlags);
150
151 /* Somewhat alternative functionality available as a direct call, for 
152    Windows XP and newer.  This is the CryptoAPI RNG, which isn't anywhere
153    near as good as the HW RNG, but we use it if it's present on the basis
154    that at least it can't make things any worse.  This direct access version 
155    is only available under Windows XP, we don't go out of our way to access
156    the more general CryptoAPI one since the main purpose of using it is to 
157    take advantage of any possible future hardware RNGs that may be added, 
158    for example via TCPA devices.  */
159 typedef BOOL (WINAPI *RTLGENRANDOM)(PVOID RandomBuffer, 
160                                     ULONG RandomBufferLength);
161
162
163
164 /* MBM data structures, originally by Alexander van Kaam, converted to C by
165    Anders@Majland.org, finally updated by Chris Zahrt <techn0@iastate.edu> */
166 #define BusType         char
167 #define SMBType         char
168 #define SensorType      char
169
170 typedef struct 
171 {
172   SensorType iType;               /* Type of sensor.  */
173   int Count;                      /* Number of sensor for that type.  */
174 } SharedIndex;
175
176 typedef struct 
177 {
178   SensorType ssType;              /* Type of sensor */
179   unsigned char ssName[12];       /* Name of sensor */
180   char sspadding1[3];             /* Padding of 3 bytes */
181   double ssCurrent;               /* Current value */
182   double ssLow;                   /* Lowest readout */
183   double ssHigh;                  /* Highest readout */
184   long ssCount;                   /* Total number of readout */
185   char sspadding2[4];             /* Padding of 4 bytes */
186   long double ssTotal;            /* Total amout of all readouts */
187   char sspadding3[6];             /* Padding of 6 bytes */
188   double ssAlarm1;                /* Temp & fan: high alarm; voltage: % off */
189   double ssAlarm2;                /* Temp: low alarm */
190 } SharedSensor;
191
192 typedef struct
193 {
194   short siSMB_Base;               /* SMBus base address */
195   BusType siSMB_Type;             /* SMBus/Isa bus used to access chip */
196   SMBType siSMB_Code;             /* SMBus sub type, Intel, AMD or ALi */
197   char siSMB_Addr;                /* Address of sensor chip on SMBus */
198   unsigned char siSMB_Name[41];   /* Nice name for SMBus */
199   short siISA_Base;               /* ISA base address of sensor chip on ISA */
200   int siChipType;                 /* Chip nr, connects with Chipinfo.ini */
201   char siVoltageSubType;          /* Subvoltage option selected */
202 } SharedInfo;
203
204 typedef struct
205 {
206   double sdVersion;               /* Version number (example: 51090) */
207   SharedIndex sdIndex[10];        /* Sensor index */
208   SharedSensor sdSensor[100];     /* Sensor info */
209   SharedInfo sdInfo;              /* Misc.info */
210   unsigned char sdStart[41];      /* Start time */
211
212   /* We don't use the next two fields both because they're not random
213      and because it provides a nice safety margin in case of data size
214      mis- estimates (we always under-estimate the buffer size).  */
215 #if 0
216   unsigned char sdCurrent[41];    /* Current time */
217   unsigned char sdPath[256];      /* MBM path */
218 #endif /*0*/
219 } SharedData;
220
221
222
223 /* One time intialized handles and function pointers.  We use dynamic
224    loading of the DLLs to do without them in case libgcrypt does not
225    need any random.  */
226 static HANDLE hNetAPI32;
227 static NETSTATISTICSGET pNetStatisticsGet;
228 static NETAPIBUFFERSIZE pNetApiBufferSize;
229 static NETAPIBUFFERFREE pNetApiBufferFree;
230
231 static HANDLE hNTAPI;
232 static NTQUERYSYSTEMINFORMATION  pNtQuerySystemInformation;
233 static NTQUERYINFORMATIONPROCESS pNtQueryInformationProcess;
234 static NTPOWERINFORMATION        pNtPowerInformation;
235
236 static HANDLE hAdvAPI32;
237 static CRYPTACQUIRECONTEXT pCryptAcquireContext;
238 static CRYPTGENRANDOM      pCryptGenRandom;
239 static CRYPTRELEASECONTEXT pCryptReleaseContext;
240 static RTLGENRANDOM        pRtlGenRandom;
241
242
243 /* Other module global variables.  */
244 static int system_rng_available; /* Whether a system RNG is available.  */
245 static HCRYPTPROV hRNGProv;      /* Handle to Intel RNG CSP. */
246
247 static int debug_me;  /* Debug flag.  */
248
249
250
251 \f
252 /* Try and connect to the system RNG if there's one present. */
253 static void 
254 init_system_rng (void)
255 {
256   system_rng_available = 0;
257   hRNGProv = NULL;
258
259   hAdvAPI32 = GetModuleHandle ("AdvAPI32.dll");
260   if (!hAdvAPI32)
261     return;
262
263   pCryptAcquireContext = (CRYPTACQUIRECONTEXT)
264     GetProcAddress (hAdvAPI32, "CryptAcquireContextA");
265   pCryptGenRandom = (CRYPTGENRANDOM)
266     GetProcAddress (hAdvAPI32, "CryptGenRandom");
267   pCryptReleaseContext = (CRYPTRELEASECONTEXT)
268     GetProcAddress (hAdvAPI32, "CryptReleaseContext");
269   
270   /* Get a pointer to the native randomness function if it's available.  
271      This isn't exported by name, so we have to get it by ordinal.  */
272   pRtlGenRandom = (RTLGENRANDOM)
273     GetProcAddress (hAdvAPI32, "SystemFunction036");
274
275   /* Try and connect to the PIII RNG CSP.  The AMD 768 southbridge (from 
276      the 760 MP chipset) also has a hardware RNG, but there doesn't appear 
277      to be any driver support for this as there is for the Intel RNG so we 
278      can't do much with it.  OTOH the Intel RNG is also effectively dead 
279      as well, mostly due to virtually nonexistant support/marketing by 
280      Intel, it's included here mostly for form's sake.  */
281   if ( (!pCryptAcquireContext || !pCryptGenRandom || !pCryptReleaseContext
282         || !pCryptAcquireContext (&hRNGProv, NULL, INTEL_DEF_PROV,
283                                   PROV_INTEL_SEC, 0) )
284        && !pRtlGenRandom)
285     {
286       hAdvAPI32 = NULL;
287     }
288   else
289     system_rng_available = 1;
290 }
291
292
293 /* Read data from the system RNG if availavle.  */
294 static void 
295 read_system_rng (void (*add)(const void*, size_t, enum random_origins),
296                  enum random_origins requester)
297 {
298   BYTE buffer[ SYSTEMRNG_BYTES + 8 ];
299   int quality = 0;
300
301   if (!system_rng_available)
302     return;
303
304   /* Read SYSTEMRNG_BYTES bytes from the system RNG.  We don't rely on
305      this for all our randomness requirements (particularly the
306      software RNG) in case it's broken in some way.  */
307   if (hRNGProv)
308     {
309       if (pCryptGenRandom (hRNGProv, SYSTEMRNG_BYTES, buffer))
310         quality = 80;
311     }
312   else if (pRtlGenRandom)
313     {
314       if ( pRtlGenRandom (buffer, SYSTEMRNG_BYTES))
315         quality = 50;
316     }
317   if (quality > 0)
318     {
319       if (debug_me)
320         log_debug ("rndw32#read_system_rng: got %d bytes of quality %d\n",
321                    SYSTEMRNG_BYTES, quality);
322       (*add) (buffer, SYSTEMRNG_BYTES, requester);
323       wipememory (buffer, SYSTEMRNG_BYTES);
324     }
325 }
326
327
328 /* Read data from MBM.  This communicates via shared memory, so all we
329    need to do is map a file and read the data out.  */
330 static void
331 read_mbm_data (void (*add)(const void*, size_t, enum random_origins), 
332                enum random_origins requester)
333 {
334   HANDLE hMBMData;
335   SharedData *mbmDataPtr;
336
337   hMBMData = OpenFileMapping (FILE_MAP_READ, FALSE, "$M$B$M$5$S$D$" );
338   if (hMBMData)
339     {
340       mbmDataPtr = (SharedData*)MapViewOfFile (hMBMData, FILE_MAP_READ,0,0,0);
341       if (mbmDataPtr)
342         {
343           if (debug_me)
344             log_debug ("rndw32#read_mbm_data: got %d bytes\n",
345                        (int)sizeof (SharedData));
346           (*add) (mbmDataPtr, sizeof (SharedData), requester);
347           UnmapViewOfFile (mbmDataPtr);
348         }
349       CloseHandle (hMBMData);
350     }
351 }
352
353
354 /* Fallback method using the registry to poll the statistics.  */
355 static void
356 registry_poll (void (*add)(const void*, size_t, enum random_origins), 
357                enum random_origins requester)
358 {
359   static int cbPerfData = PERFORMANCE_BUFFER_SIZE;
360   int iterations;
361   DWORD dwSize, status;
362   PERF_DATA_BLOCK *pPerfData;
363
364   /* Get information from the system performance counters.  This can take a
365      few seconds to do.  In some environments the call to RegQueryValueEx()
366      can produce an access violation at some random time in the future, in
367      some cases adding a short delay after the following code block makes
368      the problem go away.  This problem is extremely difficult to
369      reproduce, I haven't been able to get it to occur despite running it
370      on a number of machines.  MS knowledge base article Q178887 covers
371      this type of problem, it's typically caused by an external driver or
372      other program that adds its own values under the
373      HKEY_PERFORMANCE_DATA key.  The NT kernel, via Advapi32.dll, calls the
374      required external module to map in the data inside an SEH try/except
375      block, so problems in the module's collect function don't pop up until
376      after it has finished, so the fault appears to occur in Advapi32.dll.
377      There may be problems in the NT kernel as well though, a low-level
378      memory checker indicated that ExpandEnvironmentStrings() in
379      Kernel32.dll, called an interminable number of calls down inside
380      RegQueryValueEx(), was overwriting memory (it wrote twice the
381      allocated size of a buffer to a buffer allocated by the NT kernel).
382      OTOH this could be coming from the external module calling back into
383      the kernel, which eventually causes the problem described above.
384
385      Possibly as an extension of the problem that the krnlWaitSemaphore()
386      call above works around, running two instances of cryptlib (e.g. two
387      applications that use it) under NT4 can result in one of them hanging
388      in the RegQueryValueEx() call.  This happens only under NT4 and is
389      hard to reproduce in any consistent manner.
390
391      One workaround that helps a bit is to read the registry as a remote
392      (rather than local) registry, it's possible that the use of a network
393      RPC call isolates the calling app from the problem in that whatever
394      service handles the RPC is taking the hit and not affecting the
395      calling app.  Since this would require another round of extensive
396      testing to verify and the NT native API call is working fine, we'll
397      stick with the native API call for now.
398
399      Some versions of NT4 had a problem where the amount of data returned
400      was mis-reported and would never settle down, because of this the code
401      below includes a safety-catch that bails out after 10 attempts have
402      been made, this results in no data being returned but at does ensure
403      that the thread will terminate.
404
405      In addition to these problems the code in RegQueryValueEx() that
406      estimates the amount of memory required to return the performance
407      counter information isn't very accurate (it's much worse than the
408      "slightly-inaccurate" level that the MS docs warn about, it's usually
409      wildly off) since it always returns a worst-case estimate which is
410      usually nowhere near the actual amount required.  For example it may
411      report that 128K of memory is required, but only return 64K of data.
412
413      Even worse than the registry-based performance counters is the
414      performance data helper (PDH) shim that tries to make the counters
415      look like the old Win16 API (which is also used by Win95).  Under NT
416      this can consume tens of MB of memory and huge amounts of CPU time
417      while it gathers its data, and even running once can still consume
418      about 1/2MB of memory */
419   pPerfData = gcry_xmalloc (cbPerfData);
420   for (iterations=0; iterations < 10; iterations++)
421     {
422       dwSize = cbPerfData;
423       if ( debug_me )
424         log_debug ("rndw32#slow_gatherer_nt: get perf data\n" );
425
426       status = RegQueryValueEx (HKEY_PERFORMANCE_DATA, "Global", NULL,
427                                 NULL, (LPBYTE) pPerfData, &dwSize);
428       if (status == ERROR_SUCCESS)
429         {
430           if (!memcmp (pPerfData->Signature, L"PERF", 8))
431             (*add) ( pPerfData, dwSize, requester );
432           else
433             log_debug ("rndw32: no PERF signature\n");
434           break;
435         }
436       else if (status == ERROR_MORE_DATA)
437         {
438           cbPerfData += PERFORMANCE_BUFFER_STEP;
439           pPerfData = gcry_xrealloc (pPerfData, cbPerfData);
440         }
441       else
442         {
443           static int been_here;
444
445           /* Silence the error message.  In particular under Wine (as
446              of 2008) we would get swamped with such diagnotiscs.  One
447              such diagnotiscs should be enough.  */
448           if (been_here != status)
449             {
450               been_here = status;
451               log_debug ("rndw32: get performance data problem: ec=%ld\n",
452                          status);
453             }
454           break;
455         }
456     }
457   gcry_free (pPerfData);
458
459   /* Although this isn't documented in the Win32 API docs, it's necessary
460      to explicitly close the HKEY_PERFORMANCE_DATA key after use (it's
461      implicitly opened on the first call to RegQueryValueEx()).  If this
462      isn't done then any system components which provide performance data
463      can't be removed or changed while the handle remains active.  */
464   RegCloseKey (HKEY_PERFORMANCE_DATA);
465 }
466
467
468 static void
469 slow_gatherer ( void (*add)(const void*, size_t, enum random_origins), 
470                 enum random_origins requester )
471 {
472   static int is_initialized = 0;
473   static int is_workstation = 1;
474   HANDLE hDevice;
475   DWORD dwType, dwSize, dwResult;
476   ULONG ulSize;
477   int drive_no, status;
478   int no_results = 0;
479   void *buffer;
480
481   if ( !is_initialized )
482     {
483       HKEY hKey;
484
485       if ( debug_me )
486         log_debug ("rndw32#slow_gatherer: init toolkit\n" );
487       /* Find out whether this is an NT server or workstation if necessary */
488       if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
489                         "SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
490                         0, KEY_READ, &hKey) == ERROR_SUCCESS)
491         {
492           BYTE szValue[32 + 8];
493           dwSize = 32;
494
495           if ( debug_me )
496             log_debug ("rndw32#slow_gatherer: check product options\n" );
497
498           status = RegQueryValueEx (hKey, "ProductType", 0, NULL,
499                                     szValue, &dwSize);
500           if (status == ERROR_SUCCESS && stricmp (szValue, "WinNT"))
501             {
502               /* Note: There are (at least) three cases for ProductType:
503                  WinNT = NT Workstation, ServerNT = NT Server, LanmanNT =
504                  NT Server acting as a Domain Controller.  */
505               is_workstation = 0;
506               if ( debug_me )
507                 log_debug ("rndw32: this is a NT server\n");
508             }
509           RegCloseKey (hKey);
510         }
511
512       /* The following are fixed for the lifetime of the process so we
513          only add them once */
514       /* readPnPData ();  - we have not implemented that.  */
515
516       /* Initialize the NetAPI32 function pointers if necessary */
517       hNetAPI32 = LoadLibrary ("NETAPI32.DLL");
518       if (hNetAPI32)
519         {
520           if (debug_me)
521             log_debug ("rndw32#slow_gatherer: netapi32 loaded\n" );
522           pNetStatisticsGet = (NETSTATISTICSGET)
523             GetProcAddress (hNetAPI32, "NetStatisticsGet");
524           pNetApiBufferSize = (NETAPIBUFFERSIZE)
525             GetProcAddress (hNetAPI32, "NetApiBufferSize");
526           pNetApiBufferFree = (NETAPIBUFFERFREE)
527             GetProcAddress (hNetAPI32, "NetApiBufferFree");
528
529           if (!pNetStatisticsGet || !pNetApiBufferSize || !pNetApiBufferFree)
530             {
531               FreeLibrary (hNetAPI32);
532               hNetAPI32 = NULL;
533               log_debug ("rndw32: No NETAPI found\n" );
534             }
535         }
536
537       /* Initialize the NT kernel native API function pointers if necessary */
538       hNTAPI = GetModuleHandle ("NTDll.dll");
539       if (hNTAPI)
540         {
541           /* Get a pointer to the NT native information query functions */
542           pNtQuerySystemInformation = (NTQUERYSYSTEMINFORMATION)
543             GetProcAddress (hNTAPI, "NtQuerySystemInformation");
544           pNtQueryInformationProcess = (NTQUERYINFORMATIONPROCESS)
545             GetProcAddress (hNTAPI, "NtQueryInformationProcess");
546           pNtPowerInformation = (NTPOWERINFORMATION)
547             GetProcAddress(hNTAPI, "NtPowerInformation");
548
549           if (!pNtQuerySystemInformation || !pNtQueryInformationProcess)
550             hNTAPI = NULL;
551         }
552
553
554       is_initialized = 1;
555     }
556   
557   read_system_rng ( add, requester );
558   read_mbm_data ( add, requester );
559   
560   /* Get network statistics.    Note: Both NT Workstation and NT Server by
561      default will be running both the workstation and server services.  The
562      heuristic below is probably useful though on the assumption that the
563      majority of the network traffic will be via the appropriate service.
564      In any case the network statistics return almost no randomness.  */
565   {
566     LPBYTE lpBuffer;
567     
568     if (hNetAPI32
569         && !pNetStatisticsGet (NULL,
570                                is_workstation ? L"LanmanWorkstation" :
571                                L"LanmanServer", 0, 0, &lpBuffer))
572       {
573         if ( debug_me )
574           log_debug ("rndw32#slow_gatherer: get netstats\n" );
575         pNetApiBufferSize (lpBuffer, &dwSize);
576         (*add) ( lpBuffer, dwSize, requester );
577         pNetApiBufferFree (lpBuffer);
578       }
579   }
580
581   /* Get disk I/O statistics for all the hard drives.  100 is an
582      arbitrary failsafe limit.  */
583   for (drive_no = 0; drive_no < 100 ; drive_no++)
584     {
585       char diskPerformance[SIZEOF_DISK_PERFORMANCE_STRUCT + 8];
586       char szDevice[50];
587       
588       /* Check whether we can access this device.  */
589       snprintf (szDevice, sizeof szDevice, "\\\\.\\PhysicalDrive%d",
590                 drive_no);
591       hDevice = CreateFile (szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
592                             NULL, OPEN_EXISTING, 0, NULL);
593       if (hDevice == INVALID_HANDLE_VALUE)
594         break; /* No more drives.  */
595         
596       /* Note: This only works if you have turned on the disk performance
597          counters with 'diskperf -y'.  These counters are off by default. */
598       dwSize = sizeof diskPerformance;
599       if (DeviceIoControl (hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
600                            diskPerformance, SIZEOF_DISK_PERFORMANCE_STRUCT,
601                            &dwSize, NULL))
602         {
603           if ( debug_me )
604             log_debug ("rndw32#slow_gatherer: iostat drive %d\n",
605                        drive_no);
606           (*add) (diskPerformance, dwSize, requester);
607         }
608       else
609         {
610           log_info ("NOTE: you should run 'diskperf -y' "
611                     "to enable the disk statistics\n");
612         }
613       CloseHandle (hDevice);
614     }
615
616   /* In theory we should be using the Win32 performance query API to obtain
617      unpredictable data from the system, however this is so unreliable (see
618      the multiple sets of comments in registryPoll()) that it's too risky
619      to rely on it except as a fallback in emergencies.  Instead, we rely
620      mostly on the NT native API function NtQuerySystemInformation(), which
621      has the dual advantages that it doesn't have as many (known) problems
622      as the Win32 equivalent and that it doesn't access the data indirectly
623      via pseudo-registry keys, which means that it's much faster.  Note
624      that the Win32 equivalent actually works almost all of the time, the
625      problem is that on one or two systems it can fail in strange ways that
626      are never the same and can't be reproduced on any other system, which
627      is why we use the native API here.  Microsoft officially documented
628      this function in early 2003, so it'll be fairly safe to use.  */
629   if ( !hNTAPI )
630     {
631       registry_poll (add, requester);
632       return;
633     }
634
635
636   /* Scan the first 64 possible information types (we don't bother with
637      increasing the buffer size as we do with the Win32 version of the
638      performance data read, we may miss a few classes but it's no big deal).
639      This scan typically yields around 20 pieces of data, there's nothing
640      in the range 65...128 so chances are there won't be anything above
641      there either.  */
642   buffer = gcry_xmalloc (PERFORMANCE_BUFFER_SIZE);
643   for (dwType = 0; dwType < 64; dwType++)
644     {
645       switch (dwType)
646         {
647           /* Some information types are write-only (the IDs are shared with
648              a set-information call), we skip these.  */
649         case 26: case 27: case 38: case 46: case 47: case 48: case 52:
650           continue;
651
652           /* ID 53 = SystemSessionProcessInformation reads input from the
653              output buffer, which has to contain a session ID and pointer
654              to the actual buffer in which to store the session information.
655              Because this isn't a standard query, we skip this.  */
656         case  53:
657           continue;
658         }
659
660       /* Query the info for this ID.  Some results (for example for
661          ID = 6, SystemCallCounts) are only available in checked builds
662          of the kernel.  A smaller subcless of results require that
663          certain system config flags be set, for example
664          SystemObjectInformation requires that the
665          FLG_MAINTAIN_OBJECT_TYPELIST be set in NtGlobalFlags.  To avoid
666          having to special-case all of these, we try reading each one and
667          only use those for which we get a success status.  */
668       dwResult = pNtQuerySystemInformation (dwType, buffer,
669                                             PERFORMANCE_BUFFER_SIZE - 2048,
670                                             &ulSize);
671       if (dwResult != ERROR_SUCCESS)
672         continue;
673
674       /* Some calls (e.g. ID = 23, SystemProcessorStatistics, and ID = 24,
675          SystemDpcInformation) incorrectly return a length of zero, so we
676          manually adjust the length to the correct value.  */
677       if ( !ulSize )
678         {
679           if (dwType == 23)
680             ulSize = 6 * sizeof (ULONG);
681           else if (dwType == 24)
682             ulSize = 5 * sizeof (ULONG);
683         }
684
685       /* If we got some data back, add it to the entropy pool.  */
686       if (ulSize > 0 && ulSize <= PERFORMANCE_BUFFER_SIZE - 2048)
687         {
688           if (debug_me)
689             log_debug ("rndw32#slow_gatherer: %lu bytes from sysinfo %ld\n",
690                        ulSize, dwType);
691           (*add) (buffer, ulSize, requester);
692           no_results++;
693         }
694     }
695
696   /* Now we would do the same for the process information.  This
697      call would rather ugly in that it requires an exact length
698      match for the data returned, failing with a
699      STATUS_INFO_LENGTH_MISMATCH error code (0xC0000004) if the
700      length isn't an exact match.  It requires a compiler to handle
701      complex nested structs, alignment issues, and so on, and
702      without the headers in which the entries are declared it's
703      almost impossible to do.  Thus we don't.  */
704
705
706   /* Finally, do the same for the system power status information.  There
707      are only a limited number of useful information types available so we
708      restrict ourselves to the useful types.  In addition since this
709      function doesn't return length information, we have to hardcode in
710      length data.  */
711   if (pNtPowerInformation)
712     {
713       static const struct { int type; int size; } powerInfo[] = {
714         { 0, 128 },     /* SystemPowerPolicyAc */
715         { 1, 128 },     /* SystemPowerPolicyDc */
716         { 4, 64 },      /* SystemPowerCapabilities */
717         { 5, 48 },      /* SystemBatteryState */
718         { 11, 48 },     /* ProcessorInformation */
719         { 12, 24 },     /* SystemPowerInformation */
720         { -1, -1 }
721       };
722       int i;
723
724       /* The 100 is a failsafe limit.  */
725       for (i = 0; powerInfo[i].type != -1 && i < 100; i++ )
726         {
727           /* Query the info for this ID */
728           dwResult = pNtPowerInformation (powerInfo[i].type, NULL, 0, buffer,
729                                           PERFORMANCE_BUFFER_SIZE - 2048);
730           if (dwResult != ERROR_SUCCESS)
731             continue;
732           if (debug_me)
733             log_debug ("rndw32#slow_gatherer: %u bytes from powerinfo %d\n",
734                        powerInfo[i].size, i);
735           (*add) (buffer, powerInfo[i].size, requester);
736           no_results++;
737         }
738       assert (i < 100);
739     }
740   gcry_free (buffer);
741
742   /* We couldn't get enough results from the kernel, fall back to the
743      somewhat troublesome registry poll.  */
744   if (no_results < 15)
745     registry_poll (add, requester);
746 }
747
748
749 int
750 _gcry_rndw32_gather_random (void (*add)(const void*, size_t,
751                                         enum random_origins),
752                             enum random_origins origin,
753                             size_t length, int level )
754 {
755   static int is_initialized;
756
757   if (!level)
758     return 0;
759
760   /* We don't differentiate between level 1 and 2 here because there
761      is no internal entropy pool as a scary resource.  It may all work
762      slower, but because our entropy source will never block but
763      deliver some not easy to measure entropy, we assume level 2.  */
764
765   if (!is_initialized)
766     {
767       OSVERSIONINFO osvi = { sizeof( osvi ) };
768
769       GetVersionEx( &osvi );
770       if ( osvi.dwPlatformId != VER_PLATFORM_WIN32_NT)
771         log_fatal ("can only run on a Windows NT platform\n" );
772       init_system_rng ();
773       is_initialized = 1;
774     }
775
776   if (debug_me)
777     log_debug ("rndw32#gather_random: ori=%d len=%u lvl=%d\n",
778                origin, (unsigned int)length, level );
779
780   slow_gatherer (add, origin);
781
782   return 0;
783 }
784
785
786
787 void
788 _gcry_rndw32_gather_random_fast (void (*add)(const void*, size_t,
789                                              enum random_origins),
790                                  enum random_origins origin)
791 {
792   static int addedFixedItems = 0;
793
794   if ( debug_me )
795     log_debug ("rndw32#gather_random_fast: ori=%d\n", origin );
796
797   /* Get various basic pieces of system information: Handle of active
798      window, handle of window with mouse capture, handle of clipboard
799      owner handle of start of clpboard viewer list, pseudohandle of
800      current process, current process ID, pseudohandle of current
801      thread, current thread ID, handle of desktop window, handle of
802      window with keyboard focus, whether system queue has any events,
803      cursor position for last message, 1 ms time for last message,
804      handle of window with clipboard open, handle of process heap,
805      handle of procs window station, types of events in input queue,
806      and milliseconds since Windows was started.  */
807
808   {
809     byte buffer[20*sizeof(ulong)], *bufptr;
810
811     bufptr = buffer;
812 #define ADD(f)  do { ulong along = (ulong)(f);                  \
813                      memcpy (bufptr, &along, sizeof (along) );  \
814                      bufptr += sizeof (along);                  \
815                    } while (0)
816
817     ADD ( GetActiveWindow ());
818     ADD ( GetCapture ());
819     ADD ( GetClipboardOwner ());
820     ADD ( GetClipboardViewer ());
821     ADD ( GetCurrentProcess ());
822     ADD ( GetCurrentProcessId ());
823     ADD ( GetCurrentThread ());
824     ADD ( GetCurrentThreadId ());
825     ADD ( GetDesktopWindow ());
826     ADD ( GetFocus ());
827     ADD ( GetInputState ());
828     ADD ( GetMessagePos ());
829     ADD ( GetMessageTime ());
830     ADD ( GetOpenClipboardWindow ());
831     ADD ( GetProcessHeap ());
832     ADD ( GetProcessWindowStation ());
833     ADD ( GetQueueStatus (QS_ALLEVENTS));
834     ADD ( GetTickCount ());
835
836     assert ( bufptr-buffer < sizeof (buffer) );
837     (*add) ( buffer, bufptr-buffer, origin );
838 #undef ADD
839   }
840
841   /* Get multiword system information: Current caret position, current
842      mouse cursor position.  */
843   {
844     POINT point;
845
846     GetCaretPos (&point);
847     (*add) ( &point, sizeof (point), origin );
848     GetCursorPos (&point);
849     (*add) ( &point, sizeof (point), origin );
850   }
851
852   /* Get percent of memory in use, bytes of physical memory, bytes of
853      free physical memory, bytes in paging file, free bytes in paging
854      file, user bytes of address space, and free user bytes.  */
855   {
856     MEMORYSTATUS memoryStatus;
857
858     memoryStatus.dwLength = sizeof (MEMORYSTATUS);
859     GlobalMemoryStatus (&memoryStatus);
860     (*add) ( &memoryStatus, sizeof (memoryStatus), origin );
861   }
862
863   /* Get thread and process creation time, exit time, time in kernel
864      mode, and time in user mode in 100ns intervals.  */
865   {
866     HANDLE handle;
867     FILETIME creationTime, exitTime, kernelTime, userTime;
868     DWORD minimumWorkingSetSize, maximumWorkingSetSize;
869
870     handle = GetCurrentThread ();
871     GetThreadTimes (handle, &creationTime, &exitTime,
872                     &kernelTime, &userTime);
873     (*add) ( &creationTime, sizeof (creationTime), origin );
874     (*add) ( &exitTime, sizeof (exitTime), origin );
875     (*add) ( &kernelTime, sizeof (kernelTime), origin );
876     (*add) ( &userTime, sizeof (userTime), origin );
877
878     handle = GetCurrentProcess ();
879     GetProcessTimes (handle, &creationTime, &exitTime,
880                      &kernelTime, &userTime);
881     (*add) ( &creationTime, sizeof (creationTime), origin );
882     (*add) ( &exitTime, sizeof (exitTime), origin );
883     (*add) ( &kernelTime, sizeof (kernelTime), origin );
884     (*add) ( &userTime, sizeof (userTime), origin );
885
886     /* Get the minimum and maximum working set size for the current
887        process.  */
888     GetProcessWorkingSetSize (handle, &minimumWorkingSetSize,
889                               &maximumWorkingSetSize);
890     (*add) ( &minimumWorkingSetSize,
891              sizeof (minimumWorkingSetSize), origin );
892     (*add) ( &maximumWorkingSetSize,
893              sizeof (maximumWorkingSetSize), origin );
894   }
895
896
897   /* The following are fixed for the lifetime of the process so we only
898    * add them once */
899   if (!addedFixedItems)
900     {
901       STARTUPINFO startupInfo;
902
903       /* Get name of desktop, console window title, new window
904          position and size, window flags, and handles for stdin,
905          stdout, and stderr.  */
906       startupInfo.cb = sizeof (STARTUPINFO);
907       GetStartupInfo (&startupInfo);
908       (*add) ( &startupInfo, sizeof (STARTUPINFO), origin );
909       addedFixedItems = 1;
910     }
911
912   /* The performance of QPC varies depending on the architecture it's
913      running on and on the OS, the MS documentation is vague about the
914      details because it varies so much.  Under Win9x/ME it reads the
915      1.193180 MHz PIC timer.  Under NT/Win2K/XP it may or may not read the
916      64-bit TSC depending on the HAL and assorted other circumstances,
917      generally on machines with a uniprocessor HAL
918      KeQueryPerformanceCounter() uses a 3.579545MHz timer and on machines
919      with a multiprocessor or APIC HAL it uses the TSC (the exact time
920      source is controlled by the HalpUse8254 flag in the kernel).  That
921      choice of time sources is somewhat peculiar because on a
922      multiprocessor machine it's theoretically possible to get completely
923      different TSC readings depending on which CPU you're currently
924      running on, while for uniprocessor machines it's not a problem.
925      However, the kernel appears to synchronise the TSCs across CPUs at
926      boot time (it resets the TSC as part of its system init), so this
927      shouldn't really be a problem.  Under WinCE it's completely platform-
928      dependant, if there's no hardware performance counter available, it
929      uses the 1ms system timer.
930      
931      Another feature of the TSC (although it doesn't really affect us here)
932      is that mobile CPUs will turn off the TSC when they idle, Pentiums
933      will change the rate of the counter when they clock-throttle (to
934      match the current CPU speed), and hyperthreading Pentiums will turn
935      it off when both threads are idle (this more or less makes sense,
936      since the CPU will be in the halted state and not executing any
937      instructions to count).
938      
939      To make things unambiguous, we detect a CPU new enough to call RDTSC
940      directly by checking for CPUID capabilities, and fall back to QPC if
941      this isn't present.  */
942 #ifdef __GNUC__  
943 /*   FIXME: We need to implement the CPU feature tests first.  */
944 /*   if (cpu_has_feature_rdtsc) */
945 /*     { */
946 /*       uint32_t lo, hi; */
947       /* We cannot use "=A", since this would use %rax on x86_64. */
948 /*       __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); */
949       /* Ignore high 32 bits, hwich are >1s res.  */
950 /*       (*add) (&lo, 4, origin ); */
951 /*     } */
952 /*   else */
953 #endif /*!__GNUC__*/
954     {
955       LARGE_INTEGER performanceCount;
956       
957       if (QueryPerformanceCounter (&performanceCount))
958         {
959           if ( debug_me )
960           log_debug ("rndw32#gather_random_fast: perf data\n");
961           (*add) (&performanceCount, sizeof (performanceCount), origin);
962         }
963       else
964         {
965           /* Millisecond accuracy at best... */
966           DWORD aword = GetTickCount ();
967           (*add) (&aword, sizeof (aword), origin );
968         }
969     }
970
971
972 }