[sedwards] 13954: added Wine tests for advapi32. (untested)

added Wine tests for advapi32. (untested)
Added: trunk/reactos/lib/advapi32/winetests/
Added: trunk/reactos/lib/advapi32/winetests/crypt.c
Added: trunk/reactos/lib/advapi32/winetests/crypt_lmhash.c
Added: trunk/reactos/lib/advapi32/winetests/crypt_md4.c
Added: trunk/reactos/lib/advapi32/winetests/crypt_md5.c
Added: trunk/reactos/lib/advapi32/winetests/crypt_sha.c
Added: trunk/reactos/lib/advapi32/winetests/makefile
Added: trunk/reactos/lib/advapi32/winetests/registry.c
Added: trunk/reactos/lib/advapi32/winetests/security.c
Added: trunk/reactos/lib/advapi32/winetests/testlist.c
  _____  

Added: trunk/reactos/lib/advapi32/winetests/crypt.c
--- trunk/reactos/lib/advapi32/winetests/crypt.c	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/crypt.c	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,575 @@

+/*
+ * Unit tests for crypt functions
+ *
+ * Copyright (c) 2004 Michael Jung
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wincrypt.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "wine/test.h"
+
+static const char szRsaBaseProv[] = MS_DEF_PROV_A;
+static const char szNonExistentProv[] = "Wine Nonexistent Cryptographic
Provider v11.2";
+static const char szKeySet[] = "wine_test_keyset";
+static const char szBadKeySet[] = "wine_test_bad_keyset";
+#define NON_DEF_PROV_TYPE 999
+
+static HMODULE hadvapi32;
+static BOOL (WINAPI
*pCryptAcquireContextA)(HCRYPTPROV*,LPCSTR,LPCSTR,DWORD,DWORD);
+static BOOL (WINAPI *pCryptEnumProviderTypesA)(DWORD, DWORD*, DWORD,
DWORD*, LPSTR, DWORD*);
+static BOOL (WINAPI *pCryptEnumProvidersA)(DWORD, DWORD*, DWORD,
DWORD*, LPSTR, DWORD*);
+static BOOL (WINAPI *pCryptGetDefaultProviderA)(DWORD, DWORD*, DWORD,
LPSTR, DWORD*);
+static BOOL (WINAPI *pCryptReleaseContext)(HCRYPTPROV, DWORD);
+static BOOL (WINAPI *pCryptSetProviderExA)(LPCSTR, DWORD, DWORD*,
DWORD);
+
+static void init_function_pointers(void)
+{
+    hadvapi32 = GetModuleHandleA("advapi32.dll");
+
+    if(hadvapi32)
+    {
+	pCryptAcquireContextA = (void*)GetProcAddress(hadvapi32,
"CryptAcquireContextA");
+	pCryptEnumProviderTypesA = (void*)GetProcAddress(hadvapi32,
"CryptEnumProviderTypesA");
+	pCryptEnumProvidersA = (void*)GetProcAddress(hadvapi32,
"CryptEnumProvidersA");
+	pCryptGetDefaultProviderA = (void*)GetProcAddress(hadvapi32,
"CryptGetDefaultProviderA");
+	pCryptReleaseContext = (void*)GetProcAddress(hadvapi32,
"CryptReleaseContext");
+	pCryptSetProviderExA = (void*)GetProcAddress(hadvapi32,
"CryptSetProviderExA");
+    }
+}
+
+
+static void init_environment(void)
+{
+	HCRYPTPROV hProv;
+	
+	/* Ensure that container "wine_test_keyset" does exist */
+	if (!pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, 0))
+	{
+		pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, CRYPT_NEWKEYSET);
+	}
+	pCryptReleaseContext(hProv, 0);
+
+	/* Ensure that container "wine_test_keyset" does exist in
default PROV_RSA_FULL type provider */
+	if (!pCryptAcquireContextA(&hProv, szKeySet, NULL,
PROV_RSA_FULL, 0))
+	{
+		pCryptAcquireContextA(&hProv, szKeySet, NULL,
PROV_RSA_FULL, CRYPT_NEWKEYSET);
+	}
+	pCryptReleaseContext(hProv, 0);
+
+	/* Ensure that container "wine_test_bad_keyset" does not exist.
*/
+	if (pCryptAcquireContextA(&hProv, szBadKeySet, szRsaBaseProv,
PROV_RSA_FULL, 0))
+	{
+		pCryptReleaseContext(hProv, 0);
+		pCryptAcquireContextA(&hProv, szBadKeySet,
szRsaBaseProv, PROV_RSA_FULL, CRYPT_DELETEKEYSET);
+	}
+}
+
+static void clean_up_environment(void)
+{
+	HCRYPTPROV hProv;
+
+	/* Remove container "wine_test_keyset" */
+	if (pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, 0))
+	{
+		pCryptReleaseContext(hProv, 0);
+		pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, CRYPT_DELETEKEYSET);
+	}
+
+	/* Remove container "wine_test_keyset" from default
PROV_RSA_FULL type provider */
+	if (pCryptAcquireContextA(&hProv, szKeySet, NULL, PROV_RSA_FULL,
0))
+	{
+		pCryptReleaseContext(hProv, 0);
+		pCryptAcquireContextA(&hProv, szKeySet, NULL,
PROV_RSA_FULL, CRYPT_DELETEKEYSET);
+	}
+}
+
+static void test_acquire_context(void)
+{
+	BOOL result;
+	HCRYPTPROV hProv;
+
+	/* Provoke all kinds of error conditions (which are easy to
provoke). 
+	 * The order of the error tests seems to match Windows XP's
rsaenh.dll CSP,
+	 * but since this is likely to change between CSP versions, we
don't check
+	 * this. Please don't change the order of tests. */
+	result = pCryptAcquireContextA(&hProv, NULL, NULL, 0, 0);
+	ok(!result && GetLastError()==NTE_BAD_PROV_TYPE, "%ld\n",
GetLastError());
+	
+	result = pCryptAcquireContextA(&hProv, NULL, NULL, 1000, 0);
+	ok(!result && GetLastError()==NTE_BAD_PROV_TYPE, "%ld\n",
GetLastError());
+
+	result = pCryptAcquireContextA(&hProv, NULL, NULL,
NON_DEF_PROV_TYPE, 0);
+	ok(!result && GetLastError()==NTE_PROV_TYPE_NOT_DEF, "%ld\n",
GetLastError());
+	
+	result = pCryptAcquireContextA(&hProv, szKeySet,
szNonExistentProv, PROV_RSA_FULL, 0);
+	ok(!result && GetLastError()==NTE_KEYSET_NOT_DEF, "%ld\n",
GetLastError());
+
+	result = pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
NON_DEF_PROV_TYPE, 0);
+	ok(!result && GetLastError()==NTE_PROV_TYPE_NO_MATCH, "%ld\n",
GetLastError());
+	
+	/* This test fails under Win2k SP4:
+	   result = TRUE, GetLastError() == ERROR_INVALID_PARAMETER
+	SetLastError(0xdeadbeef);
+	result = pCryptAcquireContextA(NULL, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, 0);
+	ok(!result && GetLastError()==ERROR_INVALID_PARAMETER,
"%d/%ld\n", result, GetLastError());
+	*/
+	
+	/* Last not least, try to really acquire a context. */
+	hProv = 0;
+	SetLastError(0xdeadbeef);
+	result = pCryptAcquireContextA(&hProv, szKeySet, szRsaBaseProv,
PROV_RSA_FULL, 0);
+	ok(result && (GetLastError() == ERROR_ENVVAR_NOT_FOUND ||
GetLastError() == ERROR_SUCCESS  || GetLastError() ==
ERROR_RING2_STACK_IN_USE), "%d/%ld\n", result, GetLastError());
+
+	if (hProv) 
+		pCryptReleaseContext(hProv, 0);
+
+	/* Try again, witch an empty ("\0") szProvider parameter */
+	hProv = 0;
+	SetLastError(0xdeadbeef);
+	result = pCryptAcquireContextA(&hProv, szKeySet, "",
PROV_RSA_FULL, 0);
+	ok(result && (GetLastError() == ERROR_ENVVAR_NOT_FOUND ||
GetLastError() == ERROR_SUCCESS  || GetLastError() ==
ERROR_RING2_STACK_IN_USE), "%d/%ld\n", result, GetLastError());
+
+	if (hProv) 
+		pCryptReleaseContext(hProv, 0);
+}
+
+static BOOL FindProvRegVals(DWORD dwIndex, DWORD *pdwProvType, LPSTR
*pszProvName, 
+			    DWORD *pcbProvName, DWORD *pdwProvCount)
+{
+	HKEY hKey;
+	HKEY subkey;
+	DWORD size = sizeof(DWORD);
+	
+	if (RegOpenKey(HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Cryptography\\Defaults\\Provider", &hKey))
+		return FALSE;
+	
+	RegQueryInfoKey(hKey, NULL, NULL, NULL, pdwProvCount,
pcbProvName, 
+				 NULL, NULL, NULL, NULL, NULL, NULL);
+	(*pcbProvName)++;
+	
+	if (!(*pszProvName = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
*pcbProvName))))
+		return FALSE;
+	
+	RegEnumKeyEx(hKey, dwIndex, *pszProvName, pcbProvName, NULL,
NULL, NULL, NULL);
+	(*pcbProvName)++;
+
+	RegOpenKey(hKey, *pszProvName, &subkey);
+	RegQueryValueEx(subkey, "Type", NULL, NULL, (BYTE*)pdwProvType,
&size);
+	
+	RegCloseKey(subkey);
+	RegCloseKey(hKey);
+	
+	return TRUE;
+}
+
+static void test_enum_providers(void)
+{
+	/* expected results */
+	CHAR *pszProvName = NULL;
+	DWORD cbName;
+	DWORD dwType;
+	DWORD provCount;
+	DWORD dwIndex = 0;
+	
+	/* actual results */
+	CHAR *provider = NULL;
+	DWORD providerLen;
+	DWORD type;
+	DWORD count;
+	BOOL result;
+	DWORD notNull = 5;
+	DWORD notZeroFlags = 5;
+	
+	if(!pCryptEnumProvidersA)
+	{
+	    trace("skipping CryptEnumProviders tests\n");
+	    return;
+	}
+	
+	if (!FindProvRegVals(dwIndex, &dwType, &pszProvName, &cbName,
&provCount))
+		return;
+	
+	/* check pdwReserved flag for NULL */
+	result = pCryptEnumProvidersA(dwIndex, &notNull, 0, &type, NULL,
&providerLen);
+	ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "%ld\n",
GetLastError());
+	
+	/* check dwFlags == 0 */
+	result = pCryptEnumProvidersA(dwIndex, NULL, notZeroFlags,
&type, NULL, &providerLen);
+	ok(!result && GetLastError()==NTE_BAD_FLAGS, "%ld\n",
GetLastError());
+	
+	/* alloc provider to half the size required
+	 * cbName holds the size required */
+	providerLen = cbName / 2;
+	if (!(provider = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
providerLen))))
+		return;
+
+	result = pCryptEnumProvidersA(dwIndex, NULL, 0, &type, provider,
&providerLen);
+	ok(!result && GetLastError()==ERROR_MORE_DATA, "expected %i, got
%ld\n",
+		ERROR_MORE_DATA, GetLastError());
+
+	LocalFree(provider);
+
+	/* loop through the providers to get the number of providers 
+	 * after loop ends, count should be provCount + 1 so subtract 1
+	 * to get actual number of providers */
+	count = 0;
+	while(pCryptEnumProvidersA(count++, NULL, 0, &type, NULL,
&providerLen))
+		;
+	count--;
+	ok(count==provCount, "expected %i, got %i\n", (int)provCount,
(int)count);
+	
+	/* loop past the actual number of providers to get the error
+	 * ERROR_NO_MORE_ITEMS */
+	for (count = 0; count < provCount + 1; count++)
+		result = pCryptEnumProvidersA(count, NULL, 0, &type,
NULL, &providerLen);
+	ok(!result && GetLastError()==ERROR_NO_MORE_ITEMS, "expected %i,
got %ld\n", 
+			ERROR_NO_MORE_ITEMS, GetLastError());
+	
+	/* check expected versus actual values returned */
+	result = pCryptEnumProvidersA(dwIndex, NULL, 0, &type, NULL,
&providerLen);
+	ok(result && providerLen==cbName, "expected %i, got %i\n",
(int)cbName, (int)providerLen);
+	if (!(provider = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
providerLen))))
+		return;
+		
+	result = pCryptEnumProvidersA(dwIndex, NULL, 0, &type, provider,
&providerLen);
+	ok(result && type==dwType, "expected %ld, got %ld\n", 
+		dwType, type);
+	ok(result && !strcmp(pszProvName, provider), "expected %s, got
%s\n", pszProvName, provider);
+	ok(result && cbName==providerLen, "expected %ld, got %ld\n", 
+		cbName, providerLen);
+
+	LocalFree(provider);
+}
+
+static BOOL FindProvTypesRegVals(DWORD dwIndex, DWORD *pdwProvType,
LPSTR *pszTypeName, 
+				 DWORD *pcbTypeName, DWORD
*pdwTypeCount)
+{
+	HKEY hKey;
+	HKEY hSubKey;
+	PSTR ch;
+	
+	if (RegOpenKey(HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &hKey))
+		return FALSE;
+	
+	if (RegQueryInfoKey(hKey, NULL, NULL, NULL, pdwTypeCount,
pcbTypeName, NULL,
+			NULL, NULL, NULL, NULL, NULL))
+	    return FALSE;
+	(*pcbTypeName)++;
+	
+	if (!(*pszTypeName = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
*pcbTypeName))))
+		return FALSE;
+	
+	if (RegEnumKeyEx(hKey, dwIndex, *pszTypeName, pcbTypeName, NULL,
NULL, NULL, NULL))
+	    return FALSE;
+	(*pcbTypeName)++;
+	ch = *pszTypeName + strlen(*pszTypeName);
+	/* Convert "Type 000" to 0, etc/ */
+	*pdwProvType = *(--ch) - '0';
+	*pdwProvType += (*(--ch) - '0') * 10;
+	*pdwProvType += (*(--ch) - '0') * 100;
+	
+	if (RegOpenKey(hKey, *pszTypeName, &hSubKey))
+	    return FALSE;
+	
+	if (RegQueryValueEx(hSubKey, "TypeName", NULL, NULL, NULL,
pcbTypeName))
+            return FALSE;
+
+	if (!(*pszTypeName = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
*pcbTypeName))))
+		return FALSE;
+	
+	if (RegQueryValueEx(hSubKey, "TypeName", NULL, NULL,
*pszTypeName, pcbTypeName))
+	    return FALSE;
+	
+	RegCloseKey(hSubKey);
+	RegCloseKey(hKey);
+	
+	return TRUE;
+}
+
+static void test_enum_provider_types()
+{
+	/* expected values */
+	DWORD dwProvType;
+	LPSTR pszTypeName = NULL;
+	DWORD cbTypeName;
+	DWORD dwTypeCount;
+	
+	/* actual values */
+	DWORD index = 0;
+	DWORD provType;
+	LPSTR typeName = NULL;
+	DWORD typeNameSize;
+	DWORD typeCount;
+	DWORD result;
+	DWORD notNull = 5;
+	DWORD notZeroFlags = 5;
+	
+	if(!pCryptEnumProviderTypesA)
+	{
+	    trace("skipping CryptEnumProviderTypes tests\n");
+	    return;
+	}
+	
+	if (!FindProvTypesRegVals(index, &dwProvType, &pszTypeName,
&cbTypeName, &dwTypeCount))
+	{
+	    trace("could not find provider types in registry, skipping
the test\n");
+	    return;
+	}
+	
+	/* check pdwReserved for NULL */
+	result = pCryptEnumProviderTypesA(index, &notNull, 0, &provType,
typeName, &typeNameSize);
+	ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "expected
%i, got %ld\n", 
+		ERROR_INVALID_PARAMETER, GetLastError());
+	
+	/* check dwFlags == zero */
+	result = pCryptEnumProviderTypesA(index, NULL, notZeroFlags,
&provType, typeName, &typeNameSize);
+	ok(!result && GetLastError()==NTE_BAD_FLAGS, "expected %i, got
%ld\n",
+		ERROR_INVALID_PARAMETER, GetLastError());
+	
+	/* alloc provider type to half the size required
+	 * cbTypeName holds the size required */
+	typeNameSize = cbTypeName / 2;
+	if (!(typeName = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
typeNameSize))))
+		return;
+
+	/* This test fails under Win2k SP4:
+	   result = TRUE, GetLastError() == 0xdeadbeef
+	SetLastError(0xdeadbeef);
+	result = pCryptEnumProviderTypesA(index, NULL, 0, &provType,
typeName, &typeNameSize);
+	ok(!result && GetLastError()==ERROR_MORE_DATA, "expected
0/ERROR_MORE_DATA, got %d/%08lx\n",
+		result, GetLastError());
+	*/
+	
+	LocalFree(typeName);
+	
+	/* loop through the provider types to get the number of provider
types 
+	 * after loop ends, count should be dwTypeCount + 1 so subtract
1
+	 * to get actual number of provider types */
+	typeCount = 0;
+	while(pCryptEnumProviderTypesA(typeCount++, NULL, 0, &provType,
NULL, &typeNameSize))
+		;
+	typeCount--;
+	ok(typeCount==dwTypeCount, "expected %ld, got %ld\n",
dwTypeCount, typeCount);
+	
+	/* loop past the actual number of provider types to get the
error
+	 * ERROR_NO_MORE_ITEMS */
+	for (typeCount = 0; typeCount < dwTypeCount + 1; typeCount++)
+		result = pCryptEnumProviderTypesA(typeCount, NULL, 0,
&provType, NULL, &typeNameSize);
+	ok(!result && GetLastError()==ERROR_NO_MORE_ITEMS, "expected %i,
got %ld\n", 
+			ERROR_NO_MORE_ITEMS, GetLastError());
+	
+
+	/* check expected versus actual values returned */
+	result = pCryptEnumProviderTypesA(index, NULL, 0, &provType,
NULL, &typeNameSize);
+	ok(result && typeNameSize==cbTypeName, "expected %ld, got
%ld\n", cbTypeName, typeNameSize);
+	if (!(typeName = ((LPSTR)LocalAlloc(LMEM_ZEROINIT,
typeNameSize))))
+		return;
+		
+	typeNameSize = 0xdeadbeef;
+	result = pCryptEnumProviderTypesA(index, NULL, 0, &provType,
typeName, &typeNameSize);
+	ok(result, "expected TRUE, got %ld\n", result);
+	ok(provType==dwProvType, "expected %ld, got %ld\n", dwProvType,
provType);
+	if (pszTypeName)
+	    ok(!strcmp(pszTypeName, typeName), "expected %s, got %s\n",
pszTypeName, typeName);
+	ok(typeNameSize==cbTypeName, "expected %ld, got %ld\n",
cbTypeName, typeNameSize);
+	
+	LocalFree(typeName);
+}
+
+static BOOL FindDfltProvRegVals(DWORD dwProvType, DWORD dwFlags, LPSTR
*pszProvName, DWORD *pcbProvName)
+{
+	HKEY hKey;
+	PSTR keyname;
+	PSTR ptr;
+	DWORD user = dwFlags & CRYPT_USER_DEFAULT;
+	
+	LPSTR MACHINESTR =
"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
+	LPSTR USERSTR = "Software\\Microsoft\\Cryptography\\Provider
Type XXX";
+	
+	keyname = LocalAlloc(LMEM_ZEROINIT, (user ? strlen(USERSTR) :
strlen(MACHINESTR)) + 1);
+	if (keyname)
+	{
+		user ? strcpy(keyname, USERSTR) : strcpy(keyname,
MACHINESTR);
+		ptr = keyname + strlen(keyname);
+		*(--ptr) = (dwProvType % 10) + '0';
+		*(--ptr) = ((dwProvType / 10) % 10) + '0';
+		*(--ptr) = (dwProvType / 100) + '0';
+	} else
+		return FALSE;
+	
+	if (RegOpenKey((dwFlags & CRYPT_USER_DEFAULT) ?
HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
+	{
+		LocalFree(keyname);
+		return FALSE;
+	}
+	LocalFree(keyname);
+	
+	if (RegQueryValueEx(hKey, "Name", NULL, NULL, *pszProvName,
pcbProvName))
+	{
+		if (GetLastError() != ERROR_MORE_DATA)
+			SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
+		return FALSE;
+	}
+	
+	if (!(*pszProvName = LocalAlloc(LMEM_ZEROINIT, *pcbProvName)))
+		return FALSE;
+	
+	if (RegQueryValueEx(hKey, "Name", NULL, NULL, *pszProvName,
pcbProvName))
+	{
+		if (GetLastError() != ERROR_MORE_DATA)
+			SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
+		return FALSE;
+	}
+	
+	RegCloseKey(hKey);
+	
+	return TRUE;
+}
+
+static void test_get_default_provider()
+{
+	/* expected results */
+	DWORD dwProvType = PROV_RSA_FULL;
+	DWORD dwFlags = CRYPT_MACHINE_DEFAULT;
+	LPSTR pszProvName = NULL;
+	DWORD cbProvName;
+	
+	/* actual results */
+	DWORD provType = PROV_RSA_FULL;
+	DWORD flags = CRYPT_MACHINE_DEFAULT;
+	LPSTR provName = NULL;
+	DWORD provNameSize;
+	DWORD result;
+	DWORD notNull = 5;
+	
+	if(!pCryptGetDefaultProviderA)
+	{
+	    trace("skipping CryptGetDefaultProvider tests\n");
+	    return;
+	}
+	
+	FindDfltProvRegVals(dwProvType, dwFlags, &pszProvName,
&cbProvName);
+	
+	/* check pdwReserved for NULL */
+	result = pCryptGetDefaultProviderA(provType, &notNull, flags,
provName, &provNameSize);
+	ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "expected
%i, got %ld\n",
+		ERROR_INVALID_PARAMETER, GetLastError());
+	
+	/* check for invalid flag */
+	flags = 0xdeadbeef;
+	result = pCryptGetDefaultProviderA(provType, NULL, flags,
provName, &provNameSize);
+	ok(!result && GetLastError()==NTE_BAD_FLAGS, "expected %ld, got
%ld\n",
+		NTE_BAD_FLAGS, GetLastError());
+	flags = CRYPT_MACHINE_DEFAULT;
+	
+	/* check for invalid prov type */
+	provType = 0xdeadbeef;
+	result = pCryptGetDefaultProviderA(provType, NULL, flags,
provName, &provNameSize);
+	ok(!result && (GetLastError() == NTE_BAD_PROV_TYPE ||
+	               GetLastError() == ERROR_INVALID_PARAMETER),
+		"expected NTE_BAD_PROV_TYPE or ERROR_INVALID_PARAMETER,
got %ld/%ld\n",
+		result, GetLastError());
+	provType = PROV_RSA_FULL;
+	
+	SetLastError(0);
+	
+	/* alloc provName to half the size required
+	 * cbProvName holds the size required */
+	provNameSize = cbProvName / 2;
+	if (!(provName = LocalAlloc(LMEM_ZEROINIT, provNameSize)))
+		return;
+	
+	result = pCryptGetDefaultProviderA(provType, NULL, flags,
provName, &provNameSize);
+	ok(!result && GetLastError()==ERROR_MORE_DATA, "expected %i, got
%ld\n",
+		ERROR_MORE_DATA, GetLastError());
+		
+	LocalFree(provName);
+	
+	/* check expected versus actual values returned */
+	result = pCryptGetDefaultProviderA(provType, NULL, flags, NULL,
&provNameSize);
+	ok(result && provNameSize==cbProvName, "expected %ld, got
%ld\n", cbProvName, provNameSize);
+	provNameSize = cbProvName;
+	
+	if (!(provName = LocalAlloc(LMEM_ZEROINIT, provNameSize)))
+		return;
+	
+	result = pCryptGetDefaultProviderA(provType, NULL, flags,
provName, &provNameSize);
+	ok(result && !strcmp(pszProvName, provName), "expected %s, got
%s\n", pszProvName, provName);
+	ok(result && provNameSize==cbProvName, "expected %ld, got
%ld\n", cbProvName, provNameSize);
+
+	LocalFree(provName);
+}
+
+static void test_set_provider_ex()
+{
+	DWORD result;
+	DWORD notNull = 5;
+	
+	/* results */
+	LPSTR pszProvName = NULL;
+	DWORD cbProvName;
+	
+	if(!pCryptGetDefaultProviderA || !pCryptSetProviderExA)
+	{
+	    trace("skipping CryptSetProviderEx tests\n");
+	    return;
+	}
+
+	/* check pdwReserved for NULL */
+	result = pCryptSetProviderExA(MS_DEF_PROV, PROV_RSA_FULL,
&notNull, CRYPT_MACHINE_DEFAULT);
+	ok(!result && GetLastError()==ERROR_INVALID_PARAMETER, "expected
%i, got %ld\n",
+		ERROR_INVALID_PARAMETER, GetLastError());
+
+	/* remove the default provider and then set it to
MS_DEF_PROV/PROV_RSA_FULL */
+	result = pCryptSetProviderExA(MS_DEF_PROV, PROV_RSA_FULL, NULL,
CRYPT_MACHINE_DEFAULT | CRYPT_DELETE_DEFAULT);
+	ok(result, "%ld\n", GetLastError());
+
+	result = pCryptSetProviderExA(MS_DEF_PROV, PROV_RSA_FULL, NULL,
CRYPT_MACHINE_DEFAULT);
+	ok(result, "%ld\n", GetLastError());
+	
+	/* call CryptGetDefaultProvider to see if they match */
+	result = pCryptGetDefaultProviderA(PROV_RSA_FULL, NULL,
CRYPT_MACHINE_DEFAULT, NULL, &cbProvName);
+	if (!(pszProvName = LocalAlloc(LMEM_ZEROINIT, cbProvName)))
+		return;
+
+	result = pCryptGetDefaultProviderA(PROV_RSA_FULL, NULL,
CRYPT_MACHINE_DEFAULT, pszProvName, &cbProvName);
+	ok(result && !strcmp(MS_DEF_PROV, pszProvName), "expected %s,
got %s\n", MS_DEF_PROV, pszProvName);
+	ok(result && cbProvName==(strlen(MS_DEF_PROV) + 1), "expected
%i, got %ld\n", (strlen(MS_DEF_PROV) + 1), cbProvName);
+
+	LocalFree(pszProvName);
+}
+
+START_TEST(crypt)
+{
+	init_function_pointers();
+	if(pCryptAcquireContextA && pCryptReleaseContext) {
+	init_environment();
+	test_acquire_context();
+	clean_up_environment();
+	}
+	
+	test_enum_providers();
+	test_enum_provider_types();
+	test_get_default_provider();
+	test_set_provider_ex();
+}
  _____  

Added: trunk/reactos/lib/advapi32/winetests/crypt_lmhash.c
--- trunk/reactos/lib/advapi32/winetests/crypt_lmhash.c	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/crypt_lmhash.c	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,63 @@

+/*
+ * Unit tests for SystemFunction006 (LMHash?)
+ *
+ * Copyright 2004 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdio.h>
+
+#include "wine/test.h"
+#include "windef.h"
+#include "winbase.h"
+
+typedef VOID (WINAPI *fnSystemFunction006)( PCSTR passwd, PSTR lmhash
);
+fnSystemFunction006 pSystemFunction006;
+
+static void test_SystemFunction006()
+{
+    static unsigned char lmhash[16 + 1];
+
+    unsigned char passwd[] = {
's','e','c','r','e','t', 0, 0, 0, 0, 0,
0, 0, 0 };
+    unsigned char expect[] = 
+        { 0x85, 0xf5, 0x28, 0x9f, 0x09, 0xdc, 0xa7, 0xeb,
+          0xaa, 0xd3, 0xb4, 0x35, 0xb5, 0x14, 0x04, 0xee };
+
+    pSystemFunction006( passwd, lmhash );
+
+    ok( !memcmp( lmhash, expect, sizeof(expect) ),
+        "lmhash:
%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
+        lmhash[0], lmhash[1], lmhash[2], lmhash[3], lmhash[4],
lmhash[5],
+        lmhash[6], lmhash[7], lmhash[8], lmhash[9], lmhash[10],
lmhash[11],
+        lmhash[12], lmhash[13], lmhash[14], lmhash[15] );
+}
+
+START_TEST(crypt_lmhash)
+{
+    HMODULE module;
+
+    if (!(module = LoadLibrary("advapi32.dll"))) return;
+
+    pSystemFunction006 = (fnSystemFunction006)GetProcAddress( module,
"SystemFunction006" );
+
+    if (!pSystemFunction006) goto out;
+
+    if (pSystemFunction006) 
+        test_SystemFunction006();
+
+out:
+    FreeLibrary( module );
+}
  _____  

Added: trunk/reactos/lib/advapi32/winetests/crypt_md4.c
--- trunk/reactos/lib/advapi32/winetests/crypt_md4.c	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/crypt_md4.c	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,109 @@

+/*
+ * Unit tests for MD4 functions
+ *
+ * Copyright 2004 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdio.h>
+
+#include "wine/test.h"
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+typedef struct
+{
+    unsigned int buf[4];
+    unsigned int i[2];
+    unsigned char in[64];
+    unsigned char digest[16];
+} MD4_CTX;
+
+typedef VOID (WINAPI *fnMD4Init)( MD4_CTX *ctx );
+typedef VOID (WINAPI *fnMD4Update)( MD4_CTX *ctx, const unsigned char
*src, const int len );
+typedef VOID (WINAPI *fnMD4Final)( MD4_CTX *ctx );
+
+fnMD4Init pMD4Init;
+fnMD4Update pMD4Update;
+fnMD4Final pMD4Final;
+
+#define ctxcmp( a, b ) memcmp( (char*)a, (char*)b, FIELD_OFFSET(
MD4_CTX, in ) )
+
+void test_md4_ctx()
+{
+    static unsigned char message[] =
+        "In our Life there's If"
+        "In our beliefs there's Lie"
+        "In our business there is Sin"
+        "In our bodies, there is Die";
+
+    int size = strlen( message );
+    HMODULE module;
+
+    MD4_CTX ctx;
+    MD4_CTX ctx_initialized = 
+    {
+        { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 },
+        { 0, 0 }
+    };
+
+    MD4_CTX ctx_update1 =
+    {
+        { 0x5e592ef7, 0xbdcb1567, 0x2b626d17, 0x7d1198bd },
+        { 0x00000338, 0 }
+    };
+
+    MD4_CTX ctx_update2 =
+    {
+        { 0x05dcfd65, 0xb3711c0d, 0x9e3369c2, 0x903ead11 },
+        { 0x00000670, 0 }
+    };
+
+    unsigned char expect[16] =
+        { 0x5f, 0xd3, 0x9b, 0x29, 0x47, 0x53, 0x47, 0xaf,
+          0xa5, 0xba, 0x0c, 0x05, 0xff, 0xc0, 0xc7, 0xda };
+
+    if (!(module = LoadLibrary( "advapi32.dll" ))) return;
+
+    pMD4Init = (fnMD4Init)GetProcAddress( module, "MD4Init" );
+    pMD4Update = (fnMD4Update)GetProcAddress( module, "MD4Update" );
+    pMD4Final = (fnMD4Final)GetProcAddress( module, "MD4Final" );
+
+    if (!pMD4Init || !pMD4Update || !pMD4Final) goto out;
+
+    memset( &ctx, 0, sizeof(ctx) );
+    pMD4Init( &ctx );
+    ok( !ctxcmp( &ctx, &ctx_initialized ), "invalid initialization\n"
);
+
+    pMD4Update( &ctx, message, size );
+    ok( !ctxcmp( &ctx, &ctx_update1 ), "update doesn't work
correctly\n" );
+
+    pMD4Update( &ctx, message, size );
+    ok( !ctxcmp( &ctx, &ctx_update2 ), "update doesn't work
correctly\n" );
+
+    pMD4Final( &ctx );
+    ok( ctxcmp( &ctx, &ctx_initialized ), "context has changed\n" );
+    ok( !memcmp( ctx.digest, expect, sizeof(expect) ), "incorrect
result\n" );
+
+out:
+    FreeLibrary( module );
+}
+
+START_TEST(crypt_md4)
+{
+    test_md4_ctx();
+}
  _____  

Added: trunk/reactos/lib/advapi32/winetests/crypt_md5.c
--- trunk/reactos/lib/advapi32/winetests/crypt_md5.c	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/crypt_md5.c	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,109 @@

+/*
+ * Unit tests for MD5 functions
+ *
+ * Copyright 2004 Hans Leidekker
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdio.h>
+
+#include "wine/test.h"
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+typedef struct
+{
+    unsigned int i[2];
+    unsigned int buf[4];
+    unsigned char in[64];
+    unsigned char digest[16];
+} MD5_CTX;
+
+typedef VOID (WINAPI *fnMD5Init)( MD5_CTX *ctx );
+typedef VOID (WINAPI *fnMD5Update)( MD5_CTX *ctx, const unsigned char
*src, const int len );
+typedef VOID (WINAPI *fnMD5Final)( MD5_CTX *ctx );
+
+fnMD5Init pMD5Init;
+fnMD5Update pMD5Update;
+fnMD5Final pMD5Final;
+
+#define ctxcmp( a, b ) memcmp( (char*)a, (char*)b, FIELD_OFFSET(
MD5_CTX, in ) )
+
+void test_md5_ctx()
+{
+    static unsigned char message[] =
+        "In our Life there's If"
+        "In our beliefs there's Lie"
+        "In our business there is Sin"
+        "In our bodies, there is Die";
+
+    int size = strlen( message );
+    HMODULE module;
+
+    MD5_CTX ctx;
+    MD5_CTX ctx_initialized = 
+    {
+        { 0, 0 },
+        { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 }
+    };
+
+    MD5_CTX ctx_update1 =
+    {
+        { 0x00000338, 0 },
+        { 0x068cb64d, 0xb7a05790, 0x426979ee, 0xed67e221 }
+    };
+
+    MD5_CTX ctx_update2 =
+    {
+        { 0x00000670, 0 },
+        { 0x2f7afe58, 0xcc3e9315, 0x709c465c, 0xbf6414c8 }
+    };
+
+    unsigned char expect[16] =
+        { 0x43, 0x03, 0xdd, 0x8c, 0x60, 0xd9, 0x3a, 0x22,
+          0x0b, 0x28, 0xd0, 0xb2, 0x65, 0x93, 0xd0, 0x36 };
+
+    if (!(module = LoadLibrary( "advapi32.dll" ))) return;
+
+    pMD5Init = (fnMD5Init)GetProcAddress( module, "MD5Init" );
+    pMD5Update = (fnMD5Update)GetProcAddress( module, "MD5Update" );
+    pMD5Final = (fnMD5Final)GetProcAddress( module, "MD5Final" );
+
+    if (!pMD5Init || !pMD5Update || !pMD5Final) goto out;
+
+    memset( &ctx, 0, sizeof(ctx) );
+    pMD5Init( &ctx );
+    ok( !ctxcmp( &ctx, &ctx_initialized ), "invalid initialization\n"
);
+
+    pMD5Update( &ctx, message, size );
+    ok( !ctxcmp( &ctx, &ctx_update1 ), "update doesn't work
correctly\n" );
+
+    pMD5Update( &ctx, message, size );
+    ok( !ctxcmp( &ctx, &ctx_update2 ), "update doesn't work
correctly\n" );
+
+    pMD5Final( &ctx );
+    ok( ctxcmp( &ctx, &ctx_initialized ), "context has changed\n" );
+    ok( !memcmp( ctx.digest, expect, sizeof(expect) ), "incorrect
result\n" );
+
+out:
+    FreeLibrary( module );
+}
+
+START_TEST(crypt_md5)
+{
+    test_md5_ctx();
+}
  _____  

Added: trunk/reactos/lib/advapi32/winetests/crypt_sha.c
--- trunk/reactos/lib/advapi32/winetests/crypt_sha.c	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/crypt_sha.c	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,81 @@

+/*
+ * Unit tests for SHA functions
+ *
+ * Copyright (c) 2004 Filip Navara
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
USA
+ */
+
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+#include "wine/test.h"
+
+typedef struct {
+   ULONG Unknown[6];
+   ULONG State[5];
+   ULONG Count[2];
+   UCHAR Buffer[64];
+} SHA_CTX, *PSHA_CTX;
+
+#define ctxcmp(a,b) memcmp((char*)a, (char*)b, FIELD_OFFSET(SHA_CTX,
Buffer))
+
+static void test_sha_ctx(void)
+{
+   FARPROC pA_SHAInit, pA_SHAUpdate, pA_SHAFinal;
+   static const char test_buffer[] = "In our Life there's If"
+                       "In our beliefs there's Lie"
+                       "In our business there is Sin"
+                       "In our bodies, there is Die";
+   ULONG test_buffer_size = strlen(test_buffer);
+   HMODULE hmod;
+   SHA_CTX ctx;
+   SHA_CTX ctx_initialized = {{0, 0, 0, 0, 0}, {0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476, 0xc3d2e1f0}, {0, 0}};
+   SHA_CTX ctx_update1 = {{0, 0, 0, 0, 0}, {0xdbe5eba8, 0x6b4335ca,
0xf7c94abe, 0xc9f34e31, 0x311023f0}, {0, 0x67}};
+   SHA_CTX ctx_update2 = {{0, 0, 0, 0, 0}, {0x5ecc818d, 0x52498169,
0xf6758559, 0xd035a164, 0x871dd125}, {0, 0xce}};
+   ULONG result[5];
+   ULONG result_correct[5] = {0xe014f93, 0xe09791ec, 0x6dcf96c8,
0x8e9385fc, 0x1611c1bb};
+
+   hmod = LoadLibrary("advapi32.dll");
+   pA_SHAInit = GetProcAddress(hmod, "A_SHAInit");
+   pA_SHAUpdate = GetProcAddress(hmod, "A_SHAUpdate");
+   pA_SHAFinal = GetProcAddress(hmod, "A_SHAFinal");
+
+   if (!pA_SHAInit || !pA_SHAUpdate || !pA_SHAFinal) return;
+
+   RtlZeroMemory(&ctx, sizeof(ctx));
+   pA_SHAInit(&ctx);
+   ok(!ctxcmp(&ctx, &ctx_initialized), "invalid initialization\n");
+
+   pA_SHAUpdate(&ctx, test_buffer, test_buffer_size);
+   ok(!ctxcmp(&ctx, &ctx_update1), "update doesn't work
correctly\n");
+
+   pA_SHAUpdate(&ctx, test_buffer, test_buffer_size);
+   ok(!ctxcmp(&ctx, &ctx_update2), "update doesn't work
correctly\n");
+
+   pA_SHAFinal(&ctx, result);
+   ok(!ctxcmp(&ctx, &ctx_initialized), "context hasn't been
reinitialized\n");
+   ok(!memcmp(result, result_correct, sizeof(result)), "incorrect
result\n");
+
+   FreeLibrary(hmod);
+}
+
+START_TEST(crypt_sha)
+{
+    test_sha_ctx();
+}
  _____  

Added: trunk/reactos/lib/advapi32/winetests/makefile
--- trunk/reactos/lib/advapi32/winetests/makefile	2005-03-12
04:20:35 UTC (rev 13953)
+++ trunk/reactos/lib/advapi32/winetests/makefile	2005-03-12
04:32:00 UTC (rev 13954)
@@ -0,0 +1,33 @@

+# $Id: Makefile 12745 2005-01-03 02:37:10Z sedwards $
+
+PATH_TO_TOP = ../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+# require os code to explicitly request A/W version of
structs/functions
+TARGET_CFLAGS += -D_DISABLE_TIDENTS -D__USE_W32API -D_WIN32_IE=0x0600 \
+	-D_WIN32_WINNT=0x0501 -D__REACTOS__
+
+TARGET_NAME = advapi32_test
+
+TARGET_SDKLIBS = advapi32.a ntdll.a wine.a
+
+TARGET_OBJECTS = \
+	testlist.o \
+	crypt.o \
+	crypt_lmhash.o \
+	crypt_md4.o \
+	crypt_md5.o \
+	crypt_sha.o \
+	registry.o \
+	security.o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF
[truncated at 1000 lines; 819 more skipped]