[ros-diffs] [cwittich] 35945: fix some advapi crypt winetests

Author: cwittich
Date: Thu Sep  4 13:43:56 2008
New Revision: 35945

URL: http://svn.reactos.org/svn/reactos?rev=35945&view=rev
Log:
fix some advapi crypt winetests

Modified:
    trunk/reactos/dll/win32/advapi32/crypt/crypt.c

Modified: trunk/reactos/dll/win32/advapi32/crypt/crypt.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/advapi32/crypt/cr...
==============================================================================
--- trunk/reactos/dll/win32/advapi32/crypt/crypt.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/advapi32/crypt/crypt.c [iso-8859-1] Thu Sep  4 13:43:56 2008
@@ -22,8 +22,7 @@
  *  TODO:
  *  - Reference counting
  *  - Thread-safing
- *  - Signature checking
- */
+  */

#include <advapi32.h>
 #include "crypt.h"
@@ -49,9 +48,7 @@
     } while (--longs);
 }

-HWND crypt_hWindow = 0;
-
-#define CRYPT_ReturnLastError(err) {SetLastError(err); return FALSE;}
+static HWND crypt_hWindow = 0;

#define CRYPT_Alloc(size) ((LPVOID)LocalAlloc(LMEM_ZEROINIT, size))
 #define CRYPT_Free(buffer) (LocalFree((HLOCAL)buffer))
@@ -127,9 +124,10 @@
    	return TRUE;
    }
    count = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
-	count = count < strsize ? count : strsize;
    if (strsize == -1)
    	*str = CRYPT_Alloc(count * sizeof(CHAR));
+	else
+		count = min( count, strsize );
    if (*str)
    {
    	WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, count, NULL, NULL);
@@ -146,7 +144,7 @@
  */
 static inline BOOL CRYPT_ANSIToUnicode(LPCSTR str, LPWSTR* wstr, int wstrsize)
 {
-	int wcount;
+	unsigned int wcount;

if (!str)
    {
@@ -154,9 +152,10 @@
    	return TRUE;
    }
    wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
-	wcount = wcount < wstrsize/(int)sizeof(WCHAR) ? wcount : wstrsize/(int)sizeof(WCHAR);
    if (wstrsize == -1)
    	*wstr = CRYPT_Alloc(wcount * sizeof(WCHAR));
+	else
+		wcount = min( wcount, wstrsize/sizeof(WCHAR) );
    if (*wstr)
    {
    	MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount);
@@ -264,6 +263,64 @@
 #undef CRYPT_GetProvFunc
 #undef CRYPT_GetProvFuncOpt

+static void CRYPT_CreateMachineGuid(void)
+{
+	static const WCHAR cryptographyW[] = {
+                'S','o','f','t','w','a','r','e','\',
+                'M','i','c','r','o','s','o','f','t','\',
+                'C','r','y','p','t','o','g','r','a','p','h','y',0 };
+	static const WCHAR machineGuidW[] = {
+		'M','a','c','h','i','n','e','G','u','i','d',0 };
+	LONG r;
+	HKEY key;
+
+	r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, cryptographyW, 0, KEY_ALL_ACCESS,
+			  &key);
+	if (!r)
+	{
+		DWORD size;
+
+		r = RegQueryValueExW(key, machineGuidW, NULL, NULL, NULL, &size);
+		if (r == ERROR_FILE_NOT_FOUND)
+		{
+			static const WCHAR rpcrt4[] = {
+				'r','p','c','r','t','4',0 };
+			HMODULE lib = LoadLibraryW(rpcrt4);
+
+			if (lib)
+			{
+				RPC_STATUS (RPC_ENTRY *pUuidCreate)(UUID *);
+				UUID uuid;
+                                WCHAR buf[37];
+                                RPC_STATUS rs;
+                                static const WCHAR uuidFmt[] = {
+                                    '%','0','8','x','-','%','0','4','x','-',
+                                    '%','0','4','x','-','%','0','2','x',
+                                    '%','0','2','x','-','%','0','2','x',
+                                    '%','0','2','x','%','0','2','x',
+                                    '%','0','2','x','%','0','2','x',
+                                    '%','0','2','x',0 };
+
+				pUuidCreate = (LPVOID) GetProcAddress(lib, "UuidCreate");
+                                rs = pUuidCreate(&uuid);
+                                if (rs == S_OK)
+                                {
+                                    swprintf(buf, uuidFmt,
+                                             uuid.Data1, uuid.Data2, uuid.Data3,
+                                             uuid.Data4[0], uuid.Data4[1],
+                                             uuid.Data4[2], uuid.Data4[3],
+                                             uuid.Data4[4], uuid.Data4[5],
+                                             uuid.Data4[6], uuid.Data4[7] );
+                                    RegSetValueExW(key, machineGuidW, 0, REG_SZ,
+                                                   (const BYTE *)buf,
+                                                   (lstrlenW(buf)+1)*sizeof(WCHAR));
+                                }
+				FreeLibrary(lib);
+			}
+		}
+		RegCloseKey(key);
+	}
+}

/******************************************************************************
  * CryptAcquireContextW (ADVAPI32.@)
@@ -307,6 +364,9 @@
    	SetLastError(ERROR_INVALID_PARAMETER);
    	return FALSE;
    }
+
+	/* Make sure the MachineGuid value exists */
+	CRYPT_CreateMachineGuid();

if (!pszProvider || !*pszProvider)
    {
@@ -566,16 +626,22 @@
  *  Success: TRUE
  *  Failure: FALSE
  */
-BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags)
+BOOL WINAPI CryptReleaseContext (HCRYPTPROV hProv, ULONG_PTR dwFlags)
 {
    PCRYPTPROV pProv = (PCRYPTPROV)hProv;
    BOOL ret = TRUE;

-	TRACE("(0x%lx, %08ld)\n", hProv, dwFlags);
+	TRACE("(0x%lx, %08lx)\n", hProv, dwFlags);

if (!pProv)
    {
    	SetLastError(NTE_BAD_UID);
+		return FALSE;
+	}
+
+	if (pProv->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
    	return FALSE;
    }

@@ -583,6 +649,7 @@
    if (pProv->refcount <= 0)
    {
    	ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
+		pProv->dwMagic = 0;
    	FreeLibrary(pProv->hModule);
 #if 0
    	CRYPT_Free(pProv->pVTable->pContextInfo);
@@ -619,10 +686,16 @@
    TRACE("(0x%lx, %ld, %p)\n", hProv, dwLen, pbBuffer);

if (!hProv)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
-
-    if (prov->dwMagic != MAGIC_CRYPTPROV)
-        CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+
+	if (prov->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer);
 }
@@ -656,13 +729,25 @@
    TRACE("(0x%lx, 0x%x, 0x%lx, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash);

if (!prov)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
    if (!phHash || prov->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
    if (dwFlags)
-		CRYPT_ReturnLastError(NTE_BAD_FLAGS);
-	if (!(hash = CRYPT_Alloc(sizeof(CRYPTHASH))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(NTE_BAD_FLAGS);
+		return FALSE;
+	}
+	if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

hash->pProvider = prov;

@@ -706,8 +791,11 @@

TRACE("(0x%lx, 0x%lx, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);

-	if (!key || !pbData || !pdwDataLen || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	if (!key || !pbData || !pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
@@ -740,11 +828,20 @@
    TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08lx, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);

if (!prov || !hash)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
    if (!phKey || prov->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
-	if (!(key = CRYPT_Alloc(sizeof(CRYPTKEY))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
+	if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

key->pProvider = prov;
    if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
@@ -779,8 +876,17 @@

TRACE("(0x%lx)\n", hHash);

-	if (!hash || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	if (!hash)
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+
+	if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
@@ -809,10 +915,16 @@
    TRACE("(0x%lx)\n", hKey);

if (!key)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
-
-    if (!key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-        CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+
+	if (!key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
@@ -844,16 +956,25 @@
    TRACE("(0x%lx, %p, %08ld, %p)\n", hHash, pdwReserved, dwFlags, phHash);

orghash = (PCRYPTHASH)hHash;
-	if (!orghash || pdwReserved || !phHash|| 
-        orghash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	if (!orghash || pdwReserved || !phHash || !orghash->pProvider || 
+		orghash->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = orghash->pProvider;
    if (!prov->pFuncs->pCPDuplicateHash)
-		CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
-	if (!(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+		return FALSE;
+	}
+
+	if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

newhash->pProvider = prov;
    if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
@@ -888,15 +1009,25 @@
    TRACE("(0x%lx, %p, %08ld, %p)\n", hKey, pdwReserved, dwFlags, phKey);

orgkey = (PCRYPTKEY)hKey;
-	if (!orgkey || pdwReserved || !phKey || orgkey->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	if (!orgkey || pdwReserved || !phKey || !orgkey->pProvider || 
+		orgkey->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = orgkey->pProvider;
    if (!prov->pFuncs->pCPDuplicateKey)
-		CRYPT_ReturnLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
-	if (!(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+		return FALSE;
+	}
+
+	if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

newkey->pProvider = prov;
    if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
@@ -940,8 +1071,11 @@

TRACE("(0x%lx, 0x%lx, %d, %08ld, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);

-	if (!key || !pdwDataLen || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	if (!key || !pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
@@ -951,7 +1085,7 @@
 /******************************************************************************
  * CryptEnumProvidersW (ADVAPI32.@)
  *
- * Returns the next availabe CSP.
+ * Returns the next available CSP.
  *
  * PARAMS
  *  dwIndex     [I] Index of the next provider to be enumerated.
@@ -979,14 +1113,23 @@
    	pdwProvType, pszProvName, pcbProvName);

if (pdwReserved || !pcbProvName)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
    if (dwFlags)
-		CRYPT_ReturnLastError(NTE_BAD_FLAGS);
+	{
+		SetLastError(NTE_BAD_FLAGS);
+		return FALSE;
+	}

if (RegOpenKeyW(HKEY_LOCAL_MACHINE,
    		L"Software\Microsoft\Cryptography\Defaults\Provider",
    		&hKey))
-		CRYPT_ReturnLastError(NTE_FAIL);
+	{
+		SetLastError(NTE_FAIL);
+		return FALSE;
+	}

if (!pszProvName)
    {
@@ -997,16 +1140,21 @@
    			 NULL, NULL, NULL, NULL, NULL, NULL);

if (!(provNameW = CRYPT_Alloc(*pcbProvName * sizeof(WCHAR))))
-			CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+		{
+			SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+			return FALSE;
+		}

RegEnumKeyExW(hKey, dwIndex, provNameW, pcbProvName, NULL, NULL, NULL, NULL);
+		CRYPT_Free(provNameW);
    	(*pcbProvName)++;
    	*pcbProvName *= sizeof(WCHAR);

-		CRYPT_Free(provNameW);
-
    	if (dwIndex >= numkeys)
-			CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
+		{
+			SetLastError(ERROR_NO_MORE_ITEMS);
+			return FALSE;
+		}
    }
    else
    {
@@ -1016,7 +1164,10 @@

result = RegEnumKeyW(hKey, dwIndex, pszProvName, *pcbProvName / sizeof(WCHAR));
    	if (result)
-			CRYPT_ReturnLastError(result);
+		{
+			SetLastError(result);
+			return FALSE;
+		}
    	if (RegOpenKeyW(hKey, pszProvName, &subkey))
    		return FALSE;
    	if (RegQueryValueExW(subkey, L"Type", NULL, NULL, (BYTE*)pdwProvType, &size))
@@ -1044,12 +1195,15 @@

if(!CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
         return FALSE;
-	if (pszProvName && !(str = CRYPT_Alloc(bufsize)))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}
    ret = CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
     if (str)
         CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
-    *pcbProvName = bufsize / sizeof(WCHAR);
+    *pcbProvName = bufsize / sizeof(WCHAR);  /* FIXME: not correct */
    if (str)
    {
    	CRYPT_Free(str);
@@ -1063,7 +1217,7 @@
 }

/******************************************************************************
- * CryptEnumProviderTypesA (ADVAPI32i.@)
+ * CryptEnumProviderTypesW (ADVAPI32.@)
  *
  * Retrieves the next type of CSP supported.
  *
@@ -1084,47 +1238,62 @@
  *   If pszTypeName is NULL, CryptEnumProviderTypesA sets the size of the name
  *   for memory allocation purposes.
  */
-BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
-		DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
+BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
+		DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
 {
    HKEY hKey, hSubkey;
    DWORD keylen, numkeys, dwType;
-	PSTR keyname, ch;
+	PWSTR keyname, ch;
    DWORD result;

TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved,
    	dwFlags, pdwProvType, pszTypeName, pcbTypeName);

if (pdwReserved || !pdwProvType || !pcbTypeName)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
    if (dwFlags)
-		CRYPT_ReturnLastError(NTE_BAD_FLAGS);
-
-	if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\Microsoft\Cryptography\Defaults\Provider Types", &hKey))
-		return FALSE;
-
-	RegQueryInfoKeyA(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
+	{
+		SetLastError(NTE_BAD_FLAGS);
+		return FALSE;
+	}
+
+	if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"Software\Microsoft\Cryptography\Defaults\Provider Types", &hKey))
+		return FALSE;
+
+	RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwIndex >= numkeys)
-		CRYPT_ReturnLastError(ERROR_NO_MORE_ITEMS);
+	{
+		SetLastError(ERROR_NO_MORE_ITEMS);
+		return FALSE;
+	}
    keylen++;
-	if ( !(keyname = CRYPT_Alloc(keylen)) )
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
-	if ( RegEnumKeyA(hKey, dwIndex, keyname, keylen) )
+	if ( !(keyname = CRYPT_Alloc(keylen*sizeof(WCHAR))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}
+	if ( RegEnumKeyW(hKey, dwIndex, keyname, keylen) )
    {
    	CRYPT_Free(keyname);
    	return FALSE;
    }
-	RegOpenKeyA(hKey, keyname, &hSubkey);
-	ch = keyname + strlen(keyname);
+	RegOpenKeyW(hKey, keyname, &hSubkey);
+	ch = keyname + wcslen(keyname);
    /* Convert "Type 000" to 0, etc/ */
    *pdwProvType = *(--ch) - '0';
    *pdwProvType += (*(--ch) - '0') * 10;
    *pdwProvType += (*(--ch) - '0') * 100;
    CRYPT_Free(keyname);

-	result = RegQueryValueExA(hSubkey, "TypeName", NULL, &dwType, (LPBYTE)pszTypeName, pcbTypeName);
+	result = RegQueryValueExW(hSubkey, L"TypeName", NULL, &dwType, (LPBYTE)pszTypeName, pcbTypeName);
    if (result)
-		CRYPT_ReturnLastError(result);
+	{
+		SetLastError(result);
+		return FALSE;
+	}

RegCloseKey(hSubkey);
    RegCloseKey(hKey);
@@ -1132,29 +1301,40 @@
 }

/******************************************************************************
- * CryptEnumProviderTypesW (ADVAPI32.@)
- *
- * see CryptEnumProviderTypesA
- */
-BOOL WINAPI CryptEnumProviderTypesW (DWORD dwIndex, DWORD *pdwReserved,
-		DWORD dwFlags, DWORD *pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)
-{
-	PSTR str = NULL;
-	DWORD strlen;
+ * CryptEnumProviderTypesA (ADVAPI32.@)
+ *
+ * see CryptEnumProviderTypesW.
+ */
+BOOL WINAPI CryptEnumProviderTypesA (DWORD dwIndex, DWORD *pdwReserved,
+		DWORD dwFlags, DWORD *pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)
+{
+	PWSTR str = NULL;
+	DWORD bufsize;
    BOOL ret;

TRACE("(%ld, %p, %08ld, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
    		pdwProvType, pszTypeName, pcbTypeName);
-	strlen = *pcbTypeName / sizeof(WCHAR);
-	if (pszTypeName && !(str = CRYPT_Alloc(strlen)))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
-	ret = CryptEnumProviderTypesA(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &strlen);
+
+	if(!CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
+		return FALSE;
+	if ( pszTypeName && !(str = CRYPT_Alloc(bufsize)) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}
+	ret = CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
    if (str)
-	{
-		CRYPT_ANSIToUnicode(str, &pszTypeName, *pcbTypeName);
+		CRYPT_UnicodeToANSI(str, &pszTypeName, *pcbTypeName);
+	*pcbTypeName = bufsize / sizeof(WCHAR);
+	if (str)
+	{
    	CRYPT_Free(str);
-	}
-	*pcbTypeName = strlen * sizeof(WCHAR);
+		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+		{
+			SetLastError(ERROR_MORE_DATA);
+			return FALSE;
+		}
+	}
    return ret;
 }

@@ -1188,7 +1368,10 @@
    TRACE("(0x%lx, 0x%lx, %ld, %08ld, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);

if (!key || !pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
@@ -1218,11 +1401,20 @@
    TRACE("(0x%lx, %d, %08ld, %p)\n", hProv, Algid, dwFlags, phKey);

if (!prov)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
-	if (!phKey || prov->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
-	if (!(key = CRYPT_Alloc(sizeof(CRYPTKEY))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+	if (!phKey || !prov || prov->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
+	if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

key->pProvider = prov;

@@ -1317,21 +1509,21 @@
    	DWORD dwFlags, LPSTR pszProvName, DWORD *pcbProvName)
 {
    PWSTR str = NULL;
-	DWORD strlen;
+	DWORD bufsize;
    BOOL ret = FALSE;

TRACE("(%d, %p, %08x, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);

-	CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, NULL, &strlen);
-	if ( pszProvName && !(str = CRYPT_Alloc(strlen)) )
+	CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, NULL, &bufsize);
+	if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
    {
    	SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    	return FALSE;
    }
-	ret = CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, str, &strlen);
+	ret = CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, str, &bufsize);
    if (str)
    	CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
-	*pcbProvName = strlen / sizeof(WCHAR);
+	*pcbProvName = bufsize / sizeof(WCHAR);
    if (str)
    {
    	CRYPT_Free(str);
@@ -1372,7 +1564,10 @@
    TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);

if (!hash || !pdwDataLen || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
@@ -1407,7 +1602,10 @@
    TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);

if (!key || !pdwDataLen || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
@@ -1440,8 +1638,11 @@

TRACE("(0x%lx, %ld, %p, %p, %08ld)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);

-    if (!prov || prov->dwMagic != MAGIC_CRYPTPROV)
-        CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	if (!prov || prov->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
 }
@@ -1468,11 +1669,20 @@
    TRACE("(0x%lx, %ld, %p)\n", hProv, dwKeySpec, phUserKey);

if (!prov)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
    if (!phUserKey || prov->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
-	if (!(key = CRYPT_Alloc(sizeof(CRYPTKEY))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
+	if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

key->pProvider = prov;

@@ -1511,9 +1721,15 @@
    TRACE("(0x%lx, %p, %ld, %08ld)\n", hHash, pbData, dwDataLen, dwFlags);

if (!hash)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
    if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
@@ -1540,9 +1756,16 @@
    TRACE("(0x%lx, 0x%lx, %08ld)\n", hHash, hKey, dwFlags);

if (!hash || !key)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
-    if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-        CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+
+	if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
@@ -1572,10 +1795,16 @@
    TRACE("(0x%lx, %p, %ld, 0x%lx, %08ld, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);

if (!prov || !pbData || !dwDataLen || !phKey || prov->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
-
-	if (!(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))))
-		CRYPT_ReturnLastError(ERROR_NOT_ENOUGH_MEMORY);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
+
+	if (!(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
+	{
+		SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+		return FALSE;
+	}

importkey->pProvider = prov;
    if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
@@ -1635,9 +1864,15 @@
    }

if (!hash)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
    if (!pdwSigLen || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, NULL,
@@ -1668,7 +1903,10 @@
    TRACE("(0x%lx, %ld, %p, %08ld)\n", hHash, dwParam, pbData, dwFlags);

if (!hash || !pbData || !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
    return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
@@ -1698,7 +1936,10 @@
    TRACE("(0x%lx, %ld, %p, %08ld)\n", hKey, dwParam, pbData, dwFlags);

if (!key || !pbData || !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-		CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = key->pProvider;
    return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
@@ -1868,9 +2109,15 @@
    TRACE("(0x%lx, %ld, %p, %08ld)\n", hProv, dwParam, pbData, dwFlags);

if (!prov)
-		CRYPT_ReturnLastError(ERROR_INVALID_HANDLE);
-    if (prov->dwMagic != MAGIC_CRYPTPROV)
-        CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
+	{
+		SetLastError(ERROR_INVALID_HANDLE);
+		return FALSE;
+	}
+	if (prov->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}
    if (dwFlags & PP_USE_HARDWARE_RNG)
    {
    	FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
@@ -1930,13 +2177,8 @@
     return CryptVerifySignatureW(hHash, pbSignature, dwSigLen, hPubKey, NULL, dwFlags);
 }

-BOOL WINAPI
-CryptVerifySignatureW (HCRYPTHASH hHash,
-			CONST BYTE *pbSignature,
-			DWORD dwSigLen,
-			HCRYPTKEY hPubKey,
-			LPCWSTR sDescription,
-			DWORD dwFlags)
+BOOL WINAPI CryptVerifySignatureW (HCRYPTHASH hHash, CONST BYTE *pbSignature, DWORD dwSigLen,
+		HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags)
 {
     PCRYPTHASH hash = (PCRYPTHASH)hHash;
     PCRYPTKEY key = (PCRYPTKEY)hPubKey;
@@ -1945,16 +2187,13 @@
     TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash, pbSignature,
         dwSigLen, hPubKey, debugstr_w(sDescription), dwFlags);

-    if (sDescription)
-	{
-		WARN("The sDescription parameter is not supported (and no longer used).  Ignoring.\n");
-	}
-
-    if (!hash || !key ||
-        !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV ||
-        !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
-    CRYPT_ReturnLastError(ERROR_INVALID_PARAMETER);
-
+	if (!hash || !key ||
+	    !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV ||
+	    !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
+	{
+		SetLastError(ERROR_INVALID_PARAMETER);
+		return FALSE;
+	}

prov = hash->pProvider;
     return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,