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, ¬Null, 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, ¬Null, 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, ¬Null, 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, ¬Null, 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]