daily pastebin goal
95%
SHARE
TWEET

OpenSSL 1.0.0 crypto/rand/rand_win.c

a guest May 24th, 2010 478 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /* crypto/rand/rand_win.c */
  2. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  3.  * All rights reserved.
  4.  *
  5.  * This package is an SSL implementation written
  6.  * by Eric Young (eay@cryptsoft.com).
  7.  * The implementation was written so as to conform with Netscapes SSL.
  8.  *
  9.  * This library is free for commercial and non-commercial use as long as
  10.  * the following conditions are aheared to.  The following conditions
  11.  * apply to all code found in this distribution, be it the RC4, RSA,
  12.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13.  * included with this distribution is covered by the same copyright terms
  14.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15.  *
  16.  * Copyright remains Eric Young's, and as such any Copyright notices in
  17.  * the code are not to be removed.
  18.  * If this package is used in a product, Eric Young should be given attribution
  19.  * as the author of the parts of the library used.
  20.  * This can be in the form of a textual message at program startup or
  21.  * in documentation (online or textual) provided with the package.
  22.  *
  23.  * Redistribution and use in source and binary forms, with or without
  24.  * modification, are permitted provided that the following conditions
  25.  * are met:
  26.  * 1. Redistributions of source code must retain the copyright
  27.  *    notice, this list of conditions and the following disclaimer.
  28.  * 2. Redistributions in binary form must reproduce the above copyright
  29.  *    notice, this list of conditions and the following disclaimer in the
  30.  *    documentation and/or other materials provided with the distribution.
  31.  * 3. All advertising materials mentioning features or use of this software
  32.  *    must display the following acknowledgement:
  33.  *    "This product includes cryptographic software written by
  34.  *     Eric Young (eay@cryptsoft.com)"
  35.  *    The word 'cryptographic' can be left out if the rouines from the library
  36.  *    being used are not cryptographic related :-).
  37.  * 4. If you include any Windows specific code (or a derivative thereof) from
  38.  *    the apps directory (application code) you must include an acknowledgement:
  39.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40.  *
  41.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51.  * SUCH DAMAGE.
  52.  *
  53.  * The licence and distribution terms for any publically available version or
  54.  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55.  * copied and put under another distribution licence
  56.  * [including the GNU Public Licence.]
  57.  */
  58. /* ====================================================================
  59.  * Copyright (c) 1998-2000 The OpenSSL Project.  All rights reserved.
  60.  *
  61.  * Redistribution and use in source and binary forms, with or without
  62.  * modification, are permitted provided that the following conditions
  63.  * are met:
  64.  *
  65.  * 1. Redistributions of source code must retain the above copyright
  66.  *    notice, this list of conditions and the following disclaimer.
  67.  *
  68.  * 2. Redistributions in binary form must reproduce the above copyright
  69.  *    notice, this list of conditions and the following disclaimer in
  70.  *    the documentation and/or other materials provided with the
  71.  *    distribution.
  72.  *
  73.  * 3. All advertising materials mentioning features or use of this
  74.  *    software must display the following acknowledgment:
  75.  *    "This product includes software developed by the OpenSSL Project
  76.  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77.  *
  78.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79.  *    endorse or promote products derived from this software without
  80.  *    prior written permission. For written permission, please contact
  81.  *    openssl-core@openssl.org.
  82.  *
  83.  * 5. Products derived from this software may not be called "OpenSSL"
  84.  *    nor may "OpenSSL" appear in their names without prior written
  85.  *    permission of the OpenSSL Project.
  86.  *
  87.  * 6. Redistributions of any form whatsoever must retain the following
  88.  *    acknowledgment:
  89.  *    "This product includes software developed by the OpenSSL Project
  90.  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91.  *
  92.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  100.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  101.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  102.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  103.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  104.  * ====================================================================
  105.  *
  106.  * This product includes cryptographic software written by Eric Young
  107.  * (eay@cryptsoft.com).  This product includes software written by Tim
  108.  * Hudson (tjh@cryptsoft.com).
  109.  *
  110.  */
  111.  
  112. #include "cryptlib.h"
  113. #include <openssl/rand.h>
  114. #include "rand_lcl.h"
  115.  
  116. #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
  117. #include <windows.h>
  118. #ifndef _WIN32_WINNT
  119. # define _WIN32_WINNT 0x0400
  120. #endif
  121. #include <wincrypt.h>
  122. #include <tlhelp32.h>
  123.  
  124. /* Limit the time spent walking through the heap, processes, threads and modules to
  125.    a maximum of 1000 miliseconds each, unless CryptoGenRandom failed */
  126. #define MAXDELAY 1000
  127.  
  128. /* Intel hardware RNG CSP -- available from
  129.  * http://developer.intel.com/design/security/rng/redist_license.htm
  130.  */
  131. #define PROV_INTEL_SEC 22
  132. #define INTEL_DEF_PROV L"Intel Hardware Cryptographic Service Provider"
  133.  
  134. static void readtimer(void);
  135. static void readscreen(void);
  136.  
  137. /* It appears like CURSORINFO, PCURSORINFO and LPCURSORINFO are only defined
  138.    when WINVER is 0x0500 and up, which currently only happens on Win2000.
  139.    Unfortunately, those are typedefs, so they're a little bit difficult to
  140.    detect properly.  On the other hand, the macro CURSOR_SHOWING is defined
  141.    within the same conditional, so it can be use to detect the absence of said
  142.    typedefs. */
  143.  
  144. #ifndef CURSOR_SHOWING
  145. /*
  146.  * Information about the global cursor.
  147.  */
  148. typedef struct tagCURSORINFO
  149. {
  150.     DWORD   cbSize;
  151.     DWORD   flags;
  152.     HCURSOR hCursor;
  153.     POINT   ptScreenPos;
  154. } CURSORINFO, *PCURSORINFO, *LPCURSORINFO;
  155.  
  156. #define CURSOR_SHOWING     0x00000001
  157. #endif /* CURSOR_SHOWING */
  158.  
  159. #if !defined(OPENSSL_SYS_WINCE)
  160. typedef BOOL (WINAPI *CRYPTACQUIRECONTEXTW)(HCRYPTPROV *, LPCWSTR, LPCWSTR,
  161.                                     DWORD, DWORD);
  162. typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV, DWORD, BYTE *);
  163. typedef BOOL (WINAPI *CRYPTRELEASECONTEXT)(HCRYPTPROV, DWORD);
  164.  
  165. typedef HWND (WINAPI *GETFOREGROUNDWINDOW)(VOID);
  166. typedef BOOL (WINAPI *GETCURSORINFO)(PCURSORINFO);
  167. typedef DWORD (WINAPI *GETQUEUESTATUS)(UINT);
  168.  
  169. typedef HANDLE (WINAPI *CREATETOOLHELP32SNAPSHOT)(DWORD, DWORD);
  170. typedef BOOL (WINAPI *CLOSETOOLHELP32SNAPSHOT)(HANDLE);
  171. typedef BOOL (WINAPI *HEAP32FIRST)(LPHEAPENTRY32, DWORD, size_t);
  172. typedef BOOL (WINAPI *HEAP32NEXT)(LPHEAPENTRY32);
  173. typedef BOOL (WINAPI *HEAP32LIST)(HANDLE, LPHEAPLIST32);
  174. typedef BOOL (WINAPI *PROCESS32)(HANDLE, LPPROCESSENTRY32);
  175. typedef BOOL (WINAPI *THREAD32)(HANDLE, LPTHREADENTRY32);
  176. typedef BOOL (WINAPI *MODULE32)(HANDLE, LPMODULEENTRY32);
  177.  
  178. #include <lmcons.h>
  179. #include <lmstats.h>
  180. #if 1 /* The NET API is Unicode only.  It requires the use of the UNICODE
  181.        * macro.  When UNICODE is defined LPTSTR becomes LPWSTR.  LMSTR was
  182.        * was added to the Platform SDK to allow the NET API to be used in
  183.        * non-Unicode applications provided that Unicode strings were still
  184.        * used for input.  LMSTR is defined as LPWSTR.
  185.        */
  186. typedef NET_API_STATUS (NET_API_FUNCTION * NETSTATGET)
  187.         (LPWSTR, LPWSTR, DWORD, DWORD, LPBYTE*);
  188. typedef NET_API_STATUS (NET_API_FUNCTION * NETFREE)(LPBYTE);
  189. #endif /* 1 */
  190. #endif /* !OPENSSL_SYS_WINCE */
  191.  
  192. int RAND_poll(void)
  193. {
  194.         MEMORYSTATUS m;
  195.         HCRYPTPROV hProvider = 0;
  196.         DWORD w;
  197.         int good = 0;
  198.  
  199.         /* Determine the OS version we are on so we can turn off things
  200.          * that do not work properly.
  201.          */
  202.         OSVERSIONINFO osverinfo ;
  203.         osverinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO) ;
  204.         GetVersionEx( &osverinfo ) ;
  205.  
  206. #if defined(OPENSSL_SYS_WINCE)
  207. # if defined(_WIN32_WCE) && _WIN32_WCE>=300
  208. /* Even though MSDN says _WIN32_WCE>=210, it doesn't seem to be available
  209.  * in commonly available implementations prior 300... */
  210.         {
  211.         BYTE buf[64];
  212.         /* poll the CryptoAPI PRNG */
  213.         /* The CryptoAPI returns sizeof(buf) bytes of randomness */
  214.         if (CryptAcquireContextW(&hProvider, NULL, NULL, PROV_RSA_FULL,
  215.                                 CRYPT_VERIFYCONTEXT))
  216.                 {
  217.                 if (CryptGenRandom(hProvider, sizeof(buf), buf))
  218.                         RAND_add(buf, sizeof(buf), sizeof(buf));
  219.                 CryptReleaseContext(hProvider, 0);
  220.                 }
  221.         }
  222. # endif
  223. #else   /* OPENSSL_SYS_WINCE */
  224.         /*
  225.          * None of below libraries are present on Windows CE, which is
  226.          * why we #ifndef the whole section. This also excuses us from
  227.          * handling the GetProcAddress issue. The trouble is that in
  228.          * real Win32 API GetProcAddress is available in ANSI flavor
  229.          * only. In WinCE on the other hand GetProcAddress is a macro
  230.          * most commonly defined as GetProcAddressW, which accepts
  231.          * Unicode argument. If we were to call GetProcAddress under
  232.          * WinCE, I'd recommend to either redefine GetProcAddress as
  233.          * GetProcAddressA (there seem to be one in common CE spec) or
  234.          * implement own shim routine, which would accept ANSI argument
  235.          * and expand it to Unicode.
  236.          */
  237.         {
  238.         /* load functions dynamically - not available on all systems */
  239.         HMODULE advapi = LoadLibrary(TEXT("ADVAPI32.DLL"));
  240.         HMODULE kernel = LoadLibrary(TEXT("KERNEL32.DLL"));
  241.         HMODULE user = NULL;
  242.         HMODULE netapi = LoadLibrary(TEXT("NETAPI32.DLL"));
  243.         CRYPTACQUIRECONTEXTW acquire = NULL;
  244.         CRYPTGENRANDOM gen = NULL;
  245.         CRYPTRELEASECONTEXT release = NULL;
  246.         NETSTATGET netstatget = NULL;
  247.         NETFREE netfree = NULL;
  248.         BYTE buf[64];
  249.  
  250.         if (netapi)
  251.                 {
  252.                 netstatget = (NETSTATGET) GetProcAddress(netapi,"NetStatisticsGet");
  253.                 netfree = (NETFREE) GetProcAddress(netapi,"NetApiBufferFree");
  254.                 }
  255.  
  256.         if (netstatget && netfree)
  257.                 {
  258.                 LPBYTE outbuf;
  259.                 /* NetStatisticsGet() is a Unicode only function
  260.                  * STAT_WORKSTATION_0 contains 45 fields and STAT_SERVER_0
  261.                  * contains 17 fields.  We treat each field as a source of
  262.                  * one byte of entropy.
  263.                  */
  264.  
  265.                 if (netstatget(NULL, L"LanmanWorkstation", 0, 0, &outbuf) == 0)
  266.                         {
  267.                         RAND_add(outbuf, sizeof(STAT_WORKSTATION_0), 45);
  268.                         netfree(outbuf);
  269.                         }
  270.                 if (netstatget(NULL, L"LanmanServer", 0, 0, &outbuf) == 0)
  271.                         {
  272.                         RAND_add(outbuf, sizeof(STAT_SERVER_0), 17);
  273.                         netfree(outbuf);
  274.                         }
  275.                 }
  276.  
  277.         if (netapi)
  278.                 FreeLibrary(netapi);
  279.  
  280.         /* It appears like this can cause an exception deep within ADVAPI32.DLL
  281.          * at random times on Windows 2000.  Reported by Jeffrey Altman.  
  282.          * Only use it on NT.
  283.          */
  284.         /* Wolfgang Marczy <WMarczy@topcall.co.at> reports that
  285.          * the RegQueryValueEx call below can hang on NT4.0 (SP6).
  286.          * So we don't use this at all for now. */
  287. #if 0
  288.         if ( osverinfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
  289.                 osverinfo.dwMajorVersion < 5)
  290.                 {
  291.                 /* Read Performance Statistics from NT/2000 registry
  292.                  * The size of the performance data can vary from call
  293.                  * to call so we must guess the size of the buffer to use
  294.                  * and increase its size if we get an ERROR_MORE_DATA
  295.                  * return instead of ERROR_SUCCESS.
  296.                  */
  297.                 LONG   rc=ERROR_MORE_DATA;
  298.                 char * buf=NULL;
  299.                 DWORD bufsz=0;
  300.                 DWORD length;
  301.  
  302.                 while (rc == ERROR_MORE_DATA)
  303.                         {
  304.                         buf = realloc(buf,bufsz+8192);
  305.                         if (!buf)
  306.                                 break;
  307.                         bufsz += 8192;
  308.  
  309.                         length = bufsz;
  310.                         rc = RegQueryValueEx(HKEY_PERFORMANCE_DATA, TEXT("Global"),
  311.                                 NULL, NULL, buf, &length);
  312.                         }
  313.                 if (rc == ERROR_SUCCESS)
  314.                         {
  315.                         /* For entropy count assume only least significant
  316.                          * byte of each DWORD is random.
  317.                          */
  318.                         RAND_add(&length, sizeof(length), 0);
  319.                         RAND_add(buf, length, length / 4.0);
  320.  
  321.                         /* Close the Registry Key to allow Windows to cleanup/close
  322.                          * the open handle
  323.                          * Note: The 'HKEY_PERFORMANCE_DATA' key is implicitly opened
  324.                          *       when the RegQueryValueEx above is done.  However, if
  325.                          *       it is not explicitly closed, it can cause disk
  326.                          *       partition manipulation problems.
  327.                          */
  328.                         RegCloseKey(HKEY_PERFORMANCE_DATA);
  329.                         }
  330.                 if (buf)
  331.                         free(buf);
  332.                 }
  333. #endif
  334.  
  335.         if (advapi)
  336.                 {
  337.                 /*
  338.                  * If it's available, then it's available in both ANSI
  339.                  * and UNICODE flavors even in Win9x, documentation says.
  340.                  * We favor Unicode...
  341.                  */
  342.                 acquire = (CRYPTACQUIRECONTEXTW) GetProcAddress(advapi,
  343.                         "CryptAcquireContextW");
  344.                 gen = (CRYPTGENRANDOM) GetProcAddress(advapi,
  345.                         "CryptGenRandom");
  346.                 release = (CRYPTRELEASECONTEXT) GetProcAddress(advapi,
  347.                         "CryptReleaseContext");
  348.                 }
  349.  
  350.         if (acquire && gen && release)
  351.                 {
  352.                 /* poll the CryptoAPI PRNG */
  353.                 /* The CryptoAPI returns sizeof(buf) bytes of randomness */
  354.                 if (acquire(&hProvider, NULL, NULL, PROV_RSA_FULL,
  355.                         CRYPT_VERIFYCONTEXT))
  356.                         {
  357.                         if (gen(hProvider, sizeof(buf), buf) != 0)
  358.                                 {
  359.                                 RAND_add(buf, sizeof(buf), 0);
  360.                                 good = 1;
  361. #if 0
  362.                                 printf("randomness from PROV_RSA_FULL\n");
  363. #endif
  364.                                 }
  365.                         release(hProvider, 0);
  366.                         }
  367.                
  368.                 /* poll the Pentium PRG with CryptoAPI */
  369.                 if (acquire(&hProvider, 0, INTEL_DEF_PROV, PROV_INTEL_SEC, 0))
  370.                         {
  371.                         if (gen(hProvider, sizeof(buf), buf) != 0)
  372.                                 {
  373.                                 RAND_add(buf, sizeof(buf), sizeof(buf));
  374.                                 good = 1;
  375. #if 0
  376.                                 printf("randomness from PROV_INTEL_SEC\n");
  377. #endif
  378.                                 }
  379.                         release(hProvider, 0);
  380.                         }
  381.                 }
  382.  
  383.         if (advapi)
  384.                 FreeLibrary(advapi);
  385.  
  386.         if ((osverinfo.dwPlatformId != VER_PLATFORM_WIN32_NT ||
  387.              !OPENSSL_isservice()) &&
  388.             (user = LoadLibrary(TEXT("USER32.DLL"))))
  389.                 {
  390.                 GETCURSORINFO cursor;
  391.                 GETFOREGROUNDWINDOW win;
  392.                 GETQUEUESTATUS queue;
  393.  
  394.                 win = (GETFOREGROUNDWINDOW) GetProcAddress(user, "GetForegroundWindow");
  395.                 cursor = (GETCURSORINFO) GetProcAddress(user, "GetCursorInfo");
  396.                 queue = (GETQUEUESTATUS) GetProcAddress(user, "GetQueueStatus");
  397.  
  398.                 if (win)
  399.                         {
  400.                         /* window handle */
  401.                         HWND h = win();
  402.                         RAND_add(&h, sizeof(h), 0);
  403.                         }
  404.                 if (cursor)
  405.                         {
  406.                         /* unfortunately, its not safe to call GetCursorInfo()
  407.                          * on NT4 even though it exists in SP3 (or SP6) and
  408.                          * higher.
  409.                          */
  410.                         if ( osverinfo.dwPlatformId == VER_PLATFORM_WIN32_NT &&
  411.                                 osverinfo.dwMajorVersion < 5)
  412.                                 cursor = 0;
  413.                         }
  414.                 if (cursor)
  415.                         {
  416.                         /* cursor position */
  417.                         /* assume 2 bytes of entropy */
  418.                         CURSORINFO ci;
  419.                         ci.cbSize = sizeof(CURSORINFO);
  420.                         if (cursor(&ci))
  421.                                 RAND_add(&ci, ci.cbSize, 2);
  422.                         }
  423.  
  424.                 if (queue)
  425.                         {
  426.                         /* message queue status */
  427.                         /* assume 1 byte of entropy */
  428.                         w = queue(QS_ALLEVENTS);
  429.                         RAND_add(&w, sizeof(w), 1);
  430.                         }
  431.  
  432.                 FreeLibrary(user);
  433.                 }
  434.  
  435.         /* Toolhelp32 snapshot: enumerate processes, threads, modules and heap
  436.          * http://msdn.microsoft.com/library/psdk/winbase/toolhelp_5pfd.htm
  437.          * (Win 9x and 2000 only, not available on NT)
  438.          *
  439.          * This seeding method was proposed in Peter Gutmann, Software
  440.          * Generation of Practically Strong Random Numbers,
  441.          * http://www.usenix.org/publications/library/proceedings/sec98/gutmann.html
  442.          * revised version at http://www.cryptoengines.com/~peter/06_random.pdf
  443.          * (The assignment of entropy estimates below is arbitrary, but based
  444.          * on Peter's analysis the full poll appears to be safe. Additional
  445.          * interactive seeding is encouraged.)
  446.          */
  447.  
  448.         if (kernel)
  449.                 {
  450.                 CREATETOOLHELP32SNAPSHOT snap;
  451.                 CLOSETOOLHELP32SNAPSHOT close_snap;
  452.                 HANDLE handle;
  453.  
  454.                 HEAP32FIRST heap_first;
  455.                 HEAP32NEXT heap_next;
  456.                 HEAP32LIST heaplist_first, heaplist_next;
  457.                 PROCESS32 process_first, process_next;
  458.                 THREAD32 thread_first, thread_next;
  459.                 MODULE32 module_first, module_next;
  460.  
  461.                 HEAPLIST32 hlist;
  462.                 HEAPENTRY32 hentry;
  463.                 PROCESSENTRY32 p;
  464.                 THREADENTRY32 t;
  465.                 MODULEENTRY32 m;
  466.                 DWORD stoptime = 0;
  467.  
  468.                 snap = (CREATETOOLHELP32SNAPSHOT)
  469.                         GetProcAddress(kernel, "CreateToolhelp32Snapshot");
  470.                 close_snap = (CLOSETOOLHELP32SNAPSHOT)
  471.                         GetProcAddress(kernel, "CloseToolhelp32Snapshot");
  472.                 heap_first = (HEAP32FIRST) GetProcAddress(kernel, "Heap32First");
  473.                 heap_next = (HEAP32NEXT) GetProcAddress(kernel, "Heap32Next");
  474.                 heaplist_first = (HEAP32LIST) GetProcAddress(kernel, "Heap32ListFirst");
  475.                 heaplist_next = (HEAP32LIST) GetProcAddress(kernel, "Heap32ListNext");
  476.                 process_first = (PROCESS32) GetProcAddress(kernel, "Process32First");
  477.                 process_next = (PROCESS32) GetProcAddress(kernel, "Process32Next");
  478.                 thread_first = (THREAD32) GetProcAddress(kernel, "Thread32First");
  479.                 thread_next = (THREAD32) GetProcAddress(kernel, "Thread32Next");
  480.                 module_first = (MODULE32) GetProcAddress(kernel, "Module32First");
  481.                 module_next = (MODULE32) GetProcAddress(kernel, "Module32Next");
  482.  
  483.                 if (snap && heap_first && heap_next && heaplist_first &&
  484.                         heaplist_next && process_first && process_next &&
  485.                         thread_first && thread_next && module_first &&
  486.                         module_next && (handle = snap(TH32CS_SNAPALL,0))
  487.                         != INVALID_HANDLE_VALUE)
  488.                         {
  489.                         /* heap list and heap walking */
  490.                         /* HEAPLIST32 contains 3 fields that will change with
  491.                          * each entry.  Consider each field a source of 1 byte
  492.                          * of entropy.
  493.                          * HEAPENTRY32 contains 5 fields that will change with
  494.                          * each entry.  Consider each field a source of 1 byte
  495.                          * of entropy.
  496.                          */
  497.                         hlist.dwSize = sizeof(HEAPLIST32);             
  498.                         if (good) stoptime = GetTickCount() + MAXDELAY;
  499.                         if (heaplist_first(handle, &hlist))
  500.                                 do
  501.                                         {
  502.                                         RAND_add(&hlist, hlist.dwSize, 3);
  503.                                         hentry.dwSize = sizeof(HEAPENTRY32);
  504.                                         if (heap_first(&hentry,
  505.                                                 hlist.th32ProcessID,
  506.                                                 hlist.th32HeapID))
  507.                                                 {
  508.                                                 int entrycnt = 80;
  509.                                                 do
  510.                                                         RAND_add(&hentry,
  511.                                                                 hentry.dwSize, 5);
  512.                                                 while (heap_next(&hentry)
  513.                                                         && --entrycnt > 0);
  514.                                                 }
  515.                                         } while (heaplist_next(handle,
  516.                                                 &hlist) && GetTickCount() < stoptime);
  517.  
  518.                         /* process walking */
  519.                         /* PROCESSENTRY32 contains 9 fields that will change
  520.                          * with each entry.  Consider each field a source of
  521.                          * 1 byte of entropy.
  522.                          */
  523.                         p.dwSize = sizeof(PROCESSENTRY32);
  524.                
  525.                         if (good) stoptime = GetTickCount() + MAXDELAY;
  526.                         if (process_first(handle, &p))
  527.                                 do
  528.                                         RAND_add(&p, p.dwSize, 9);
  529.                                 while (process_next(handle, &p) && GetTickCount() < stoptime);
  530.  
  531.                         /* thread walking */
  532.                         /* THREADENTRY32 contains 6 fields that will change
  533.                          * with each entry.  Consider each field a source of
  534.                          * 1 byte of entropy.
  535.                          */
  536.                         t.dwSize = sizeof(THREADENTRY32);
  537.                         if (good) stoptime = GetTickCount() + MAXDELAY;
  538.                         if (thread_first(handle, &t))
  539.                                 do
  540.                                         RAND_add(&t, t.dwSize, 6);
  541.                                 while (thread_next(handle, &t) && GetTickCount() < stoptime);
  542.  
  543.                         /* module walking */
  544.                         /* MODULEENTRY32 contains 9 fields that will change
  545.                          * with each entry.  Consider each field a source of
  546.                          * 1 byte of entropy.
  547.                          */
  548.                         m.dwSize = sizeof(MODULEENTRY32);
  549.                         if (good) stoptime = GetTickCount() + MAXDELAY;
  550.                         if (module_first(handle, &m))
  551.                                 do
  552.                                         RAND_add(&m, m.dwSize, 9);
  553.                                 while (module_next(handle, &m)
  554.                                                 && (GetTickCount() < stoptime));
  555.                         if (close_snap)
  556.                                 close_snap(handle);
  557.                         else
  558.                                 CloseHandle(handle);
  559.  
  560.                         }
  561.  
  562.                 FreeLibrary(kernel);
  563.                 }
  564.         }
  565. #endif /* !OPENSSL_SYS_WINCE */
  566.  
  567.         /* timer data */
  568.         readtimer();
  569.        
  570.         /* memory usage statistics */
  571.         GlobalMemoryStatus(&m);
  572.         RAND_add(&m, sizeof(m), 1);
  573.  
  574.         /* process ID */
  575.         w = GetCurrentProcessId();
  576.         RAND_add(&w, sizeof(w), 1);
  577.  
  578. #if 0
  579.         printf("Exiting RAND_poll\n");
  580. #endif
  581.  
  582.         return(1);
  583. }
  584.  
  585. int RAND_event(UINT iMsg, WPARAM wParam, LPARAM lParam)
  586.         {
  587.         double add_entropy=0;
  588.  
  589.         switch (iMsg)
  590.                 {
  591.         case WM_KEYDOWN:
  592.                         {
  593.                         static WPARAM key;
  594.                         if (key != wParam)
  595.                                 add_entropy = 0.05;
  596.                         key = wParam;
  597.                         }
  598.                         break;
  599.         case WM_MOUSEMOVE:
  600.                         {
  601.                         static int lastx,lasty,lastdx,lastdy;
  602.                         int x,y,dx,dy;
  603.  
  604.                         x=LOWORD(lParam);
  605.                         y=HIWORD(lParam);
  606.                         dx=lastx-x;
  607.                         dy=lasty-y;
  608.                         if (dx != 0 && dy != 0 && dx-lastdx != 0 && dy-lastdy != 0)
  609.                                 add_entropy=.2;
  610.                         lastx=x, lasty=y;
  611.                         lastdx=dx, lastdy=dy;
  612.                         }
  613.                 break;
  614.                 }
  615.  
  616.         readtimer();
  617.         RAND_add(&iMsg, sizeof(iMsg), add_entropy);
  618.         RAND_add(&wParam, sizeof(wParam), 0);
  619.         RAND_add(&lParam, sizeof(lParam), 0);
  620.  
  621.         return (RAND_status());
  622.         }
  623.  
  624.  
  625. void RAND_screen(void) /* function available for backward compatibility */
  626. {
  627.         RAND_poll();
  628.         readscreen();
  629. }
  630.  
  631.  
  632. /* feed timing information to the PRNG */
  633. static void readtimer(void)
  634. {
  635.         DWORD w;
  636.         LARGE_INTEGER l;
  637.         static int have_perfc = 1;
  638. #if defined(_MSC_VER) && defined(_M_X86)
  639.         static int have_tsc = 1;
  640.         DWORD cyclecount;
  641.  
  642.         if (have_tsc) {
  643.           __try {
  644.             __asm {
  645.               _emit 0x0f
  646.               _emit 0x31
  647.               mov cyclecount, eax
  648.               }
  649.             RAND_add(&cyclecount, sizeof(cyclecount), 1);
  650.           } __except(EXCEPTION_EXECUTE_HANDLER) {
  651.             have_tsc = 0;
  652.           }
  653.         }
  654. #else
  655. # define have_tsc 0
  656. #endif
  657.  
  658.         if (have_perfc) {
  659.           if (QueryPerformanceCounter(&l) == 0)
  660.             have_perfc = 0;
  661.           else
  662.             RAND_add(&l, sizeof(l), 0);
  663.         }
  664.  
  665.         if (!have_tsc && !have_perfc) {
  666.           w = GetTickCount();
  667.           RAND_add(&w, sizeof(w), 0);
  668.         }
  669. }
  670.  
  671. /* feed screen contents to PRNG */
  672. /*****************************************************************************
  673.  *
  674.  * Created 960901 by Gertjan van Oosten, gertjan@West.NL, West Consulting B.V.
  675.  *
  676.  * Code adapted from
  677.  * <URL:http://support.microsoft.com/default.aspx?scid=kb;[LN];97193>;
  678.  * the original copyright message is:
  679.  *
  680.  *   (C) Copyright Microsoft Corp. 1993.  All rights reserved.
  681.  *
  682.  *   You have a royalty-free right to use, modify, reproduce and
  683.  *   distribute the Sample Files (and/or any modified version) in
  684.  *   any way you find useful, provided that you agree that
  685.  *   Microsoft has no warranty obligations or liability for any
  686.  *   Sample Application Files which are modified.
  687.  */
  688.  
  689. static void readscreen(void)
  690. {
  691. #if !defined(OPENSSL_SYS_WINCE) && !defined(OPENSSL_SYS_WIN32_CYGWIN)
  692.   HDC           hScrDC;         /* screen DC */
  693.   HDC           hMemDC;         /* memory DC */
  694.   HBITMAP       hBitmap;        /* handle for our bitmap */
  695.   HBITMAP       hOldBitmap;     /* handle for previous bitmap */
  696.   BITMAP        bm;             /* bitmap properties */
  697.   unsigned int  size;           /* size of bitmap */
  698.   char          *bmbits;        /* contents of bitmap */
  699.   int           w;              /* screen width */
  700.   int           h;              /* screen height */
  701.   int           y;              /* y-coordinate of screen lines to grab */
  702.   int           n = 16;         /* number of screen lines to grab at a time */
  703.  
  704.   if (GetVersion() >= 0x80000000 || !OPENSSL_isservice())
  705.     return;
  706.  
  707.   /* Create a screen DC and a memory DC compatible to screen DC */
  708.   hScrDC = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);
  709.   hMemDC = CreateCompatibleDC(hScrDC);
  710.  
  711.   /* Get screen resolution */
  712.   w = GetDeviceCaps(hScrDC, HORZRES);
  713.   h = GetDeviceCaps(hScrDC, VERTRES);
  714.  
  715.   /* Create a bitmap compatible with the screen DC */
  716.   hBitmap = CreateCompatibleBitmap(hScrDC, w, n);
  717.  
  718.   /* Select new bitmap into memory DC */
  719.   hOldBitmap = SelectObject(hMemDC, hBitmap);
  720.  
  721.   /* Get bitmap properties */
  722.   GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
  723.   size = (unsigned int)bm.bmWidthBytes * bm.bmHeight * bm.bmPlanes;
  724.  
  725.   bmbits = OPENSSL_malloc(size);
  726.   if (bmbits) {
  727.     /* Now go through the whole screen, repeatedly grabbing n lines */
  728.     for (y = 0; y < h-n; y += n)
  729.         {
  730.         unsigned char md[MD_DIGEST_LENGTH];
  731.  
  732.         /* Bitblt screen DC to memory DC */
  733.         BitBlt(hMemDC, 0, 0, w, n, hScrDC, 0, y, SRCCOPY);
  734.  
  735.         /* Copy bitmap bits from memory DC to bmbits */
  736.         GetBitmapBits(hBitmap, size, bmbits);
  737.  
  738.         /* Get the hash of the bitmap */
  739.         MD(bmbits,size,md);
  740.  
  741.         /* Seed the random generator with the hash value */
  742.         RAND_add(md, MD_DIGEST_LENGTH, 0);
  743.         }
  744.  
  745.     OPENSSL_free(bmbits);
  746.   }
  747.  
  748.   /* Select old bitmap back into memory DC */
  749.   hBitmap = SelectObject(hMemDC, hOldBitmap);
  750.  
  751.   /* Clean up */
  752.   DeleteObject(hBitmap);
  753.   DeleteDC(hMemDC);
  754.   DeleteDC(hScrDC);
  755. #endif /* !OPENSSL_SYS_WINCE */
  756. }
  757.  
  758. #endif
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top