https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d03ac84f4f0584b5db9aed...
commit d03ac84f4f0584b5db9aedd6bb0af55136da84a2 Author: Amine Khaldi amine.khaldi@reactos.org AuthorDate: Fri Mar 9 13:00:36 2018 +0100 Commit: Amine Khaldi amine.khaldi@reactos.org CommitDate: Fri Mar 9 13:00:36 2018 +0100
[CRYPT32_WINETEST] Sync with Wine Staging 3.3. CORE-14434 --- modules/rostests/winetests/crypt32/base64.c | 84 ++-- modules/rostests/winetests/crypt32/cert.c | 11 +- modules/rostests/winetests/crypt32/chain.c | 93 +++- modules/rostests/winetests/crypt32/crl.c | 12 +- modules/rostests/winetests/crypt32/ctl.c | 10 +- modules/rostests/winetests/crypt32/encode.c | 520 +++++++++++++++++++---- modules/rostests/winetests/crypt32/main.c | 10 +- modules/rostests/winetests/crypt32/message.c | 9 +- modules/rostests/winetests/crypt32/msg.c | 16 +- modules/rostests/winetests/crypt32/object.c | 8 +- modules/rostests/winetests/crypt32/oid.c | 70 ++- modules/rostests/winetests/crypt32/precomp.h | 5 + modules/rostests/winetests/crypt32/protectdata.c | 9 +- modules/rostests/winetests/crypt32/sip.c | 10 +- modules/rostests/winetests/crypt32/store.c | 351 ++++++--------- modules/rostests/winetests/crypt32/str.c | 8 +- 16 files changed, 833 insertions(+), 393 deletions(-)
diff --git a/modules/rostests/winetests/crypt32/base64.c b/modules/rostests/winetests/crypt32/base64.c index 4898d3897e..e127fc3891 100644 --- a/modules/rostests/winetests/crypt32/base64.c +++ b/modules/rostests/winetests/crypt32/base64.c @@ -18,8 +18,14 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h>
-#include "precomp.h" +#include "wine/test.h"
#define CERT_HEADER "-----BEGIN CERTIFICATE-----\r\n" #define ALT_CERT_HEADER "-----BEGIN This is some arbitrary text that goes on and on-----\r\n" @@ -36,15 +42,6 @@ #define X509_HEADER_NOCR "-----BEGIN X509 CRL-----\n" #define X509_TRAILER_NOCR "-----END X509 CRL-----\n"
-static BOOL (WINAPI *pCryptBinaryToStringA)(const BYTE *pbBinary, - DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString); -static BOOL (WINAPI *pCryptStringToBinaryA)(LPCSTR pszString, - DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, - DWORD *pdwSkip, DWORD *pdwFlags); -static BOOL (WINAPI *pCryptStringToBinaryW)(LPCWSTR pszString, - DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary, - DWORD *pdwSkip, DWORD *pdwFlags); - struct BinTests { const BYTE *toEncode; @@ -91,7 +88,7 @@ static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen, LPSTR str = NULL; BOOL ret;
- ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen); + ret = CryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); str = HeapAlloc(GetProcessHeap(), 0, strLen); if (str) @@ -99,7 +96,7 @@ static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen, DWORD strLen2 = strLen; LPCSTR ptr = str;
- ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, str, + ret = CryptBinaryToStringA(toEncode, toEncodeLen, format, str, &strLen2); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); ok(strLen2 == strLen - 1, "Expected length %d, got %d\n", @@ -125,10 +122,10 @@ static void testBinaryToStringA(void) BOOL ret; DWORD strLen = 0, i;
- ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, NULL); + ret = CryptBinaryToStringA(NULL, 0, 0, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); - ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, &strLen); + ret = CryptBinaryToStringA(NULL, 0, 0, NULL, &strLen); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError()); for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) @@ -137,7 +134,7 @@ static void testBinaryToStringA(void) LPSTR str = NULL; BOOL ret;
- ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, + ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, NULL, &strLen); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); str = HeapAlloc(GetProcessHeap(), 0, strLen); @@ -145,7 +142,7 @@ static void testBinaryToStringA(void) { DWORD strLen2 = strLen;
- ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, + ret = CryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen, CRYPT_STRING_BINARY, str, &strLen2); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); ok(strLen == strLen2, "Expected length %d, got %d\n", strLen, @@ -172,7 +169,7 @@ static void testBinaryToStringA(void) LPSTR str = NULL; BOOL ret;
- ret = pCryptBinaryToStringA(testsNoCR[i].toEncode, + ret = CryptBinaryToStringA(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, NULL, &strLen); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); @@ -181,7 +178,7 @@ static void testBinaryToStringA(void) { DWORD strLen2 = strLen;
- ret = pCryptBinaryToStringA(testsNoCR[i].toEncode, + ret = CryptBinaryToStringA(testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR, str, &strLen2); ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError()); @@ -236,7 +233,7 @@ static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header, strcat(str, toDecode); if (trailer) strcat(str, trailer); - ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL, + ret = CryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL, NULL); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); buf = HeapAlloc(GetProcessHeap(), 0, bufLen); @@ -245,14 +242,14 @@ static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header, DWORD skipped, usedFormat;
/* check as normal, make sure last two parameters are optional */ - ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL, + ret = CryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL, NULL); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); ok(bufLen == expectedLen, "Expected length %d, got %d\n", expectedLen, bufLen); ok(!memcmp(buf, expected, bufLen), "Unexpected value\n"); /* check last two params */ - ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, + ret = CryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, &skipped, &usedFormat); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); ok(skipped == 0, "Expected skipped 0, got %d\n", skipped); @@ -268,7 +265,7 @@ static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header, strcat(str, toDecode); if (trailer) strcat(str, trailer); - ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL, + ret = CryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL, NULL); /* expect failure with no header, and success with one */ if (header) @@ -283,7 +280,7 @@ static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header, { DWORD skipped, usedFormat;
- ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, + ret = CryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, &skipped, &usedFormat); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); ok(skipped == strlen(garbage), @@ -305,7 +302,7 @@ static void decodeBase64WithLenFmtW(LPCSTR strA, int len, DWORD fmt, BOOL retA, WCHAR strW[64]; int i; for (i = 0; (strW[i] = strA[i]) != 0; ++i); - ret = pCryptStringToBinaryW(strW, len, fmt, buf, &bufLen, NULL, &fmtUsed); + ret = CryptStringToBinaryW(strW, len, fmt, buf, &bufLen, NULL, &fmtUsed); ok(ret == retA && bufLen == bufLenA && memcmp(bufA, buf, bufLen) == 0 && fmtUsed == fmtUsedA, "base64 "%s" len %d: W and A differ\n", strA, len); } @@ -316,7 +313,7 @@ static void decodeBase64WithLenFmt(LPCSTR str, int len, DWORD fmt, LPCSTR expect DWORD bufLen = sizeof(buf)-1, fmtUsed = 0xdeadbeef; BOOL ret; SetLastError(0xdeadbeef); - ret = pCryptStringToBinaryA(str, len, fmt, buf, &bufLen, NULL, &fmtUsed); + ret = CryptStringToBinaryA(str, len, fmt, buf, &bufLen, NULL, &fmtUsed); buf[bufLen] = 0; if (expected) { BOOL correct = ret && strcmp(expected, (char*)buf) == 0; @@ -331,8 +328,8 @@ static void decodeBase64WithLenFmt(LPCSTR str, int len, DWORD fmt, LPCSTR expect "base64 "%s" len %d: expected failure, got "%s" (ret %d, le %d)\n", str, len, (char*)buf, ret, GetLastError()); } - if (pCryptStringToBinaryW) - decodeBase64WithLenFmtW(str, len, fmt, ret, buf, bufLen, fmtUsed); + + decodeBase64WithLenFmtW(str, len, fmt, ret, buf, bufLen, fmtUsed); }
static void decodeBase64WithLenBroken(LPCSTR str, int len, LPCSTR expected, int le) @@ -366,19 +363,19 @@ static void testStringToBinaryA(void) DWORD bufLen = 0, i; BYTE buf[8];
- ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, NULL, NULL, NULL); + ret = CryptStringToBinaryA(NULL, 0, 0, NULL, NULL, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got ret=%d le=%u\n", ret, GetLastError()); - ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, &bufLen, NULL, NULL); + ret = CryptStringToBinaryA(NULL, 0, 0, NULL, &bufLen, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got ret=%d le=%u\n", ret, GetLastError()); /* Bogus format */ - ret = pCryptStringToBinaryA(tests[0].base64, 0, 0, NULL, &bufLen, NULL, + ret = CryptStringToBinaryA(tests[0].base64, 0, 0, NULL, &bufLen, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got ret=%d le=%u\n", ret, GetLastError()); /* Decoding doesn't expect the NOCR flag to be specified */ - ret = pCryptStringToBinaryA(tests[0].base64, 1, + ret = CryptStringToBinaryA(tests[0].base64, 1, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, NULL, &bufLen, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got ret=%d le=%u\n", ret, GetLastError()); @@ -386,7 +383,7 @@ static void testStringToBinaryA(void) for (i = 0; i < sizeof(badStrings) / sizeof(badStrings[0]); i++) { bufLen = 0; - ret = pCryptStringToBinaryA(badStrings[i].str, 0, badStrings[i].format, + ret = CryptStringToBinaryA(badStrings[i].str, 0, badStrings[i].format, NULL, &bufLen, NULL, NULL); ok(!ret && GetLastError() == ERROR_INVALID_DATA, "%d: Expected ERROR_INVALID_DATA, got ret=%d le=%u\n", i, ret, GetLastError()); @@ -444,7 +441,7 @@ static void testStringToBinaryA(void) /* Too small buffer */ buf[0] = 0; bufLen = 4; - ret = pCryptStringToBinaryA("VVVVVVVV", 8, CRYPT_STRING_BASE64, (BYTE*)buf, &bufLen, NULL, NULL); + ret = CryptStringToBinaryA("VVVVVVVV", 8, CRYPT_STRING_BASE64, (BYTE*)buf, &bufLen, NULL, NULL); ok(!ret && bufLen == 4 && buf[0] == 0, "Expected ret 0, bufLen 4, buf[0] '\0', got ret %d, bufLen %d, buf[0] '%c'\n", ret, bufLen, buf[0]); @@ -456,7 +453,7 @@ static void testStringToBinaryA(void) /* Bogus length--oddly enough, that succeeds, even though it's not * properly padded. */ - ret = pCryptStringToBinaryA(tests[i].base64, 1, CRYPT_STRING_BASE64, + ret = CryptStringToBinaryA(tests[i].base64, 1, CRYPT_STRING_BASE64, NULL, &bufLen, NULL, NULL); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); /* Check with the precise format */ @@ -513,7 +510,7 @@ static void testStringToBinaryA(void) /* Bogus length--oddly enough, that succeeds, even though it's not * properly padded. */ - ret = pCryptStringToBinaryA(testsNoCR[i].base64, 1, CRYPT_STRING_BASE64, + ret = CryptStringToBinaryA(testsNoCR[i].base64, 1, CRYPT_STRING_BASE64, NULL, &bufLen, NULL, NULL); ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError()); /* Check with the precise format */ @@ -548,19 +545,6 @@ static void testStringToBinaryA(void)
START_TEST(base64) { - HMODULE lib = GetModuleHandleA("crypt32"); - - pCryptBinaryToStringA = (void *)GetProcAddress(lib, "CryptBinaryToStringA"); - pCryptStringToBinaryA = (void *)GetProcAddress(lib, "CryptStringToBinaryA"); - pCryptStringToBinaryW = (void *)GetProcAddress(lib, "CryptStringToBinaryW"); - - if (pCryptBinaryToStringA) - testBinaryToStringA(); - else - win_skip("CryptBinaryToStringA is not available\n"); - - if (pCryptStringToBinaryA) - testStringToBinaryA(); - else - win_skip("CryptStringToBinaryA is not available\n"); + testBinaryToStringA(); + testStringToBinaryA(); } diff --git a/modules/rostests/winetests/crypt32/cert.c b/modules/rostests/winetests/crypt32/cert.c index 8a8d36b926..e49b2a9798 100644 --- a/modules/rostests/winetests/crypt32/cert.c +++ b/modules/rostests/winetests/crypt32/cert.c @@ -18,7 +18,16 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> + +#include <windef.h> +#include <winbase.h> +#include <winreg.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h"
static PCCERT_CONTEXT (WINAPI *pCertCreateSelfSignCertificate)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE,PCERT_NAME_BLOB,DWORD,PCRYPT_KEY_PROV_INFO,PCRYPT_ALGORITHM_IDENTIFIER,PSYSTEMTIME,PSYSTEMTIME,PCERT_EXTENSIONS); static BOOL (WINAPI *pCertGetValidUsages)(DWORD,PCCERT_CONTEXT*,int*,LPSTR*,DWORD*); diff --git a/modules/rostests/winetests/crypt32/chain.c b/modules/rostests/winetests/crypt32/chain.c index e9e8634b2b..e3b280b088 100644 --- a/modules/rostests/winetests/crypt32/chain.c +++ b/modules/rostests/winetests/crypt32/chain.c @@ -18,10 +18,17 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h>
+#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> #include <wininet.h>
+#include "wine/test.h" + static const BYTE selfSignedCert[] = { 0x30, 0x82, 0x01, 0x1f, 0x30, 0x81, 0xce, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x10, 0xeb, 0x0d, 0x57, 0x2a, 0x9c, 0x09, 0xba, 0xa4, 0x4a, 0xb7, 0x25, 0x49, @@ -2882,6 +2889,59 @@ static const BYTE chain31_1[] = { 0x43,0x08,0xe5,0x78,0x2b,0x95,0xf3,0x75,0xb6,0x88,0xf0,0x6b,0x5c,0x5b,0x50, 0x04,0x91,0x3b,0x89,0x5a,0x60,0x1f,0xfc,0x36,0x53,0x32,0x36,0x0a,0x4d,0x03, 0x2c,0xd7 }; +static const BYTE ecc_crt[] = { +0x30,0x82,0x01,0x46,0x30,0x81,0xec,0x02,0x09,0x00,0xe7,0x6b,0x26,0x86,0x0a, +0x82,0xff,0xe9,0x30,0x0a,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x04,0x03,0x02, +0x30,0x2b,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02,0x44,0x45, +0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x0a,0x0c,0x04,0x57,0x69,0x6e,0x65, +0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x03,0x0c,0x04,0x57,0x69,0x6e,0x65, +0x30,0x1e,0x17,0x0d,0x31,0x37,0x30,0x39,0x32,0x37,0x31,0x33,0x34,0x31,0x30, +0x34,0x5a,0x17,0x0d,0x32,0x37,0x30,0x39,0x32,0x35,0x31,0x33,0x34,0x31,0x30, +0x34,0x5a,0x30,0x2b,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02, +0x44,0x45,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x0a,0x0c,0x04,0x54,0x65, +0x73,0x74,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x03,0x0c,0x04,0x54,0x65, +0x73,0x74,0x30,0x59,0x30,0x13,0x06,0x07,0x2a,0x86,0x48,0xce,0x3d,0x02,0x01, +0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x03,0x01,0x07,0x03,0x42,0x00,0x04,0xed, +0xfc,0x77,0xd8,0xb9,0xe7,0xf3,0xf8,0xce,0x13,0xb8,0x7f,0x0f,0x78,0xea,0x73, +0x87,0x29,0x10,0xe1,0x6d,0x10,0xce,0x57,0x60,0x3b,0x3e,0xb4,0x5f,0x0d,0x20, +0xc1,0xeb,0x6d,0x74,0xe9,0x7b,0x11,0x51,0x9a,0x00,0xe8,0xe9,0x12,0x84,0xb9, +0x07,0x7e,0x7b,0x62,0x67,0x12,0x67,0x08,0xe5,0x2e,0x27,0xce,0xa2,0x57,0x15, +0xad,0xc5,0x1f,0x30,0x0a,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x04,0x03,0x02, +0x03,0x49,0x00,0x30,0x46,0x02,0x21,0x00,0xd7,0x29,0xce,0x5a,0xef,0x74,0x85, +0xd1,0x18,0x5f,0x6e,0xf1,0xba,0x53,0xd4,0xcd,0xdd,0xe0,0x5d,0xf1,0x5e,0x48, +0x51,0xea,0x63,0xc0,0xe8,0xe2,0xf6,0xfa,0x4c,0xaf,0x02,0x21,0x00,0xe3,0x94, +0x15,0x3b,0x6c,0x71,0x6e,0x44,0x22,0xcb,0xa0,0x88,0xcd,0x0a,0x5a,0x50,0x29, +0x7c,0x5c,0xd6,0x6c,0xd2,0xe0,0x7f,0xcd,0x02,0x92,0x21,0x4c,0x2c,0x92,0xee }; +static const BYTE ecc_ca[] = { +0x30,0x82,0x01,0x9f,0x30,0x82,0x01,0x46,0xa0,0x03,0x02,0x01,0x02,0x02,0x09, +0x00,0xf1,0x54,0xae,0x21,0x2e,0x4d,0x31,0x9f,0x30,0x0a,0x06,0x08,0x2a,0x86, +0x48,0xce,0x3d,0x04,0x03,0x02,0x30,0x2b,0x31,0x0b,0x30,0x09,0x06,0x03,0x55, +0x04,0x06,0x13,0x02,0x44,0x45,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x0a, +0x0c,0x04,0x57,0x69,0x6e,0x65,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x03, +0x0c,0x04,0x57,0x69,0x6e,0x65,0x30,0x1e,0x17,0x0d,0x31,0x37,0x30,0x39,0x32, +0x37,0x31,0x33,0x33,0x39,0x31,0x35,0x5a,0x17,0x0d,0x32,0x37,0x30,0x39,0x32, +0x35,0x31,0x33,0x33,0x39,0x31,0x35,0x5a,0x30,0x2b,0x31,0x0b,0x30,0x09,0x06, +0x03,0x55,0x04,0x06,0x13,0x02,0x44,0x45,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55, +0x04,0x0a,0x0c,0x04,0x57,0x69,0x6e,0x65,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55, +0x04,0x03,0x0c,0x04,0x57,0x69,0x6e,0x65,0x30,0x59,0x30,0x13,0x06,0x07,0x2a, +0x86,0x48,0xce,0x3d,0x02,0x01,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x03,0x01, +0x07,0x03,0x42,0x00,0x04,0x3b,0x3c,0x34,0xc8,0x3f,0x15,0xea,0x02,0x68,0x46, +0x69,0xdf,0x0c,0xa6,0xee,0x7a,0xd9,0x82,0x08,0x9b,0x37,0x53,0x42,0xf3,0x13, +0x63,0xda,0x65,0x79,0xe8,0x04,0x9e,0x8c,0x77,0xc4,0x33,0x77,0xd9,0x5a,0x7f, +0x60,0x7b,0x98,0xce,0xf3,0x96,0x56,0xd6,0xb5,0x8d,0x87,0x7a,0x00,0x2b,0xf3, +0x70,0xb3,0x90,0x73,0xa0,0x56,0x06,0x3b,0x22,0xa3,0x53,0x30,0x51,0x30,0x1d, +0x06,0x03,0x55,0x1d,0x0e,0x04,0x16,0x04,0x14,0x26,0xef,0x6f,0xe4,0xb5,0x24, +0x2f,0x68,0x49,0x84,0xd9,0x89,0xa6,0xab,0x0c,0xf8,0x6d,0xf5,0xe5,0x0c,0x30, +0x1f,0x06,0x03,0x55,0x1d,0x23,0x04,0x18,0x30,0x16,0x80,0x14,0x26,0xef,0x6f, +0xe4,0xb5,0x24,0x2f,0x68,0x49,0x84,0xd9,0x89,0xa6,0xab,0x0c,0xf8,0x6d,0xf5, +0xe5,0x0c,0x30,0x0f,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x05,0x30, +0x03,0x01,0x01,0xff,0x30,0x0a,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x04,0x03, +0x02,0x03,0x47,0x00,0x30,0x44,0x02,0x20,0x2b,0x6b,0x23,0x42,0x32,0xf2,0xcb, +0x71,0xd7,0x5c,0xfa,0x5e,0x6c,0x19,0x31,0xd6,0x74,0xf7,0xc0,0xf8,0xc6,0x39, +0x38,0xe9,0x79,0x4d,0x84,0x44,0x40,0x13,0x8e,0x43,0x02,0x20,0x34,0xc7,0x61, +0xbb,0x18,0x1c,0x85,0x34,0xe3,0x4c,0x30,0x28,0x42,0x0e,0x06,0x65,0x68,0x1d, +0x76,0x53,0x24,0xa0,0x27,0xa5,0x84,0x3b,0x2d,0xf3,0xec,0x27,0x60,0xb2 }; +
typedef struct _CONST_DATA_BLOB { @@ -3079,6 +3139,8 @@ static SYSTEMTIME jun2013 = { 2013, 6, 5, 6, 0, 0, 0, 0 }; static SYSTEMTIME oct2016 = { 2016, 10, 6, 1, 0, 0, 0, 0 }; /* Wednesday, Nov 17, 2016 */ static SYSTEMTIME nov2016 = { 2016, 11, 3, 17, 0, 0, 0, 0 }; +/* Wednesday, Nov 17, 2017 */ +static SYSTEMTIME nov2017 = { 2017, 11, 3, 17, 0, 0, 0, 0 };
typedef struct _ChainCheck { @@ -3866,6 +3928,25 @@ static ChainCheck chainCheckEmbeddedNullBroken = { CERT_TRUST_HAS_VALID_NAME_CONSTRAINTS }, 1, simpleStatus27Broken }, 0 }; +static CONST_DATA_BLOB chainECDSA[] = { + { sizeof(ecc_ca), ecc_ca }, + { sizeof(ecc_crt), ecc_crt }, +}; +static const CERT_TRUST_STATUS elementStatusECDSA[] = { + { CERT_TRUST_NO_ERROR, CERT_TRUST_HAS_NAME_MATCH_ISSUER }, + { CERT_TRUST_IS_UNTRUSTED_ROOT, CERT_TRUST_HAS_KEY_MATCH_ISSUER | CERT_TRUST_IS_SELF_SIGNED }, +}; +static const SimpleChainStatusCheck simpleStatusECDSA[] = { + { sizeof(elementStatusECDSA) / sizeof(elementStatusECDSA[0]), elementStatusECDSA }, +}; +static ChainCheck chainCheckECDSA = { + { sizeof(chainECDSA) / sizeof(chainECDSA[0]), chainECDSA }, + { + { CERT_TRUST_IS_UNTRUSTED_ROOT, CERT_TRUST_HAS_PREFERRED_ISSUER }, + { CERT_TRUST_IS_UNTRUSTED_ROOT, 0 }, + 1, simpleStatusECDSA + }, 0 +};
#define test_name_blob(a,b) _test_name_blob(__LINE__,a,b) static void _test_name_blob(unsigned line, CERT_NAME_BLOB *blob, const char *exdata) @@ -4141,6 +4222,16 @@ static void testGetCertChain(void)
pCertFreeCertificateChain(chain);
+ /* Test with ECDSA certificate */ + chain = getChain(NULL, &chainCheckECDSA.certs, 0, TRUE, &nov2017, FALSE, 0); + if (chain) + { + ok(chain->TrustStatus.dwErrorStatus == CERT_TRUST_IS_UNTRUSTED_ROOT, + "unexpected chain error status %08x\n", chain->TrustStatus.dwErrorStatus); + checkChainStatus(chain, &chainCheckECDSA.status, chainCheckECDSA.todo, "chainCheckECDSA", 0); + pCertFreeCertificateChain(chain); + } + /* Test HCCE_LOCAL_MACHINE */ ret = CertGetCertificateChain(HCCE_LOCAL_MACHINE, cert, &fileTime, store, ¶, 0, NULL, &chain); ok(ret, "CertGetCertificateChain failed: %u\n", GetLastError()); diff --git a/modules/rostests/winetests/crypt32/crl.c b/modules/rostests/winetests/crypt32/crl.c index 32460e32d9..c350b20f00 100644 --- a/modules/rostests/winetests/crypt32/crl.c +++ b/modules/rostests/winetests/crypt32/crl.c @@ -18,7 +18,17 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> + +#include <windef.h> +#include <winbase.h> +#include <winreg.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h" +
static const BYTE bigCert[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, diff --git a/modules/rostests/winetests/crypt32/ctl.c b/modules/rostests/winetests/crypt32/ctl.c index 18993c0965..79a60f8c6e 100644 --- a/modules/rostests/winetests/crypt32/ctl.c +++ b/modules/rostests/winetests/crypt32/ctl.c @@ -18,7 +18,15 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> + +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h"
static const BYTE emptyCTL[] = { 0x30,0x17,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30, diff --git a/modules/rostests/winetests/crypt32/encode.c b/modules/rostests/winetests/crypt32/encode.c index 97cedb1981..ad39a35606 100644 --- a/modules/rostests/winetests/crypt32/encode.c +++ b/modules/rostests/winetests/crypt32/encode.c @@ -17,8 +17,16 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> +#include <snmp.h> + +#include "wine/test.h"
-#include "precomp.h"
static BOOL (WINAPI *pCryptDecodeObjectEx)(DWORD,LPCSTR,const BYTE*,DWORD,DWORD,PCRYPT_DECODE_PARA,void*,DWORD*); static BOOL (WINAPI *pCryptEncodeObjectEx)(DWORD,LPCSTR,const void*,DWORD,PCRYPT_ENCODE_PARA,void*,DWORD*); @@ -1952,80 +1960,138 @@ static void test_decodeUnicodeNameValue(DWORD dwEncoding) } }
-struct encodedOctets -{ - const BYTE *val; - const BYTE *encoded; -}; - -static const unsigned char bin46[] = { 'h','i',0 }; -static const unsigned char bin47[] = { 0x04,0x02,'h','i',0 }; -static const unsigned char bin48[] = { - 's','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g',0 }; -static const unsigned char bin49[] = { - 0x04,0x0f,'s','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g',0 }; -static const unsigned char bin50[] = { 0 }; -static const unsigned char bin51[] = { 0x04,0x00,0 }; - -static const struct encodedOctets octets[] = { - { bin46, bin47 }, - { bin48, bin49 }, - { bin50, bin51 }, -}; +static const unsigned char decoded_hi_octet[] = { 'h','i' }; +static const unsigned char encoded_hi_octet[] = { ASN_OCTETSTRING,2,'h','i' }; +static const unsigned char decoded_something_long_octet[] = { + 's','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g' }; +static const unsigned char encoded_something_long_octet[] = { + ASN_OCTETSTRING,15,'s','o','m','e','l','o','n','g',0xff,'s','t','r','i','n','g' }; +static const unsigned char encoded_empty_octet[] = { ASN_OCTETSTRING,0 };
static void test_encodeOctets(DWORD dwEncoding) { CRYPT_DATA_BLOB blob; DWORD i;
- for (i = 0; i < sizeof(octets) / sizeof(octets[0]); i++) + static const struct { + const BYTE *decoded; + UINT decoded_size; + const BYTE *encoded; + UINT encoded_size; + } tests[] = { + { + decoded_hi_octet, sizeof(decoded_hi_octet), + encoded_hi_octet, sizeof(encoded_hi_octet) + },{ + decoded_something_long_octet, sizeof(decoded_something_long_octet), + encoded_something_long_octet, sizeof(encoded_something_long_octet) + },{ + encoded_empty_octet, 0, + encoded_empty_octet, sizeof(encoded_empty_octet) + } + }; + + for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { BYTE *buf = NULL; BOOL ret; DWORD bufSize = 0;
- blob.cbData = strlen((const char*)octets[i].val); - blob.pbData = (BYTE*)octets[i].val; + blob.cbData = tests[i].decoded_size; + blob.pbData = (BYTE*)tests[i].decoded; ret = pCryptEncodeObjectEx(dwEncoding, X509_OCTET_STRING, &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL, &buf, &bufSize); ok(ret, "CryptEncodeObjectEx failed: %d\n", GetLastError()); if (ret) { - ok(buf[0] == 4, - "Got unexpected type %d for octet string (expected 4)\n", buf[0]); - ok(buf[1] == octets[i].encoded[1], "Got length %d, expected %d\n", - buf[1], octets[i].encoded[1]); - ok(!memcmp(buf + 1, octets[i].encoded + 1, - octets[i].encoded[1] + 1), "Got unexpected value\n"); + ok(bufSize == tests[i].encoded_size, "[%u] buf size %u expected %u\n", + i, bufSize, tests[i].encoded_size); + ok(buf[0] == 4, "Got unexpected type %d for octet string (expected 4)\n", buf[0]); + ok(buf[1] == tests[i].decoded_size, "[%u] Got length %d, expected %d\n", + i, buf[1], tests[i].decoded_size); + ok(!memcmp(buf, tests[i].encoded, tests[i].encoded_size), "[%u] Got unexpected value\n", i); LocalFree(buf); } } }
+static const unsigned char encoded_constructed_hi_octet[] = + { ASN_CONSTRUCTOR|ASN_OCTETSTRING,0x80, ASN_OCTETSTRING,2,'h','i', 0,0 }; +static const unsigned char encoded_constructed_hi_octet2[] = + { ASN_CONSTRUCTOR|ASN_OCTETSTRING,4, ASN_OCTETSTRING,2,'h','i', 1,2,3 }; +static const unsigned char encoded_constructed_hi_octet3[] = + { ASN_CONSTRUCTOR|ASN_OCTETSTRING,8, ASN_CONSTRUCTOR|ASN_OCTETSTRING,0x80, ASN_OCTETSTRING,2,'h','i', 0,0, 0,0 }; +static const unsigned char encoded_constructed_hi_octet_invalid_end[] = + { ASN_CONSTRUCTOR|ASN_OCTETSTRING,0x80, ASN_OCTETSTRING,2,'h','i', 0,1 }; + static void test_decodeOctets(DWORD dwEncoding) { DWORD i;
- for (i = 0; i < sizeof(octets) / sizeof(octets[0]); i++) + static const struct { + const BYTE *encoded; + UINT encoded_size; + const BYTE *decoded; + UINT decoded_size; + DWORD error; + } tests[] = { + { + encoded_hi_octet, sizeof(encoded_hi_octet), + decoded_hi_octet, sizeof(decoded_hi_octet) + },{ + encoded_something_long_octet, sizeof(encoded_something_long_octet), + decoded_something_long_octet, sizeof(decoded_something_long_octet) + },{ + encoded_constructed_hi_octet, sizeof(encoded_constructed_hi_octet), + decoded_hi_octet, sizeof(decoded_hi_octet) + },{ + encoded_constructed_hi_octet2, sizeof(encoded_constructed_hi_octet2), + decoded_hi_octet, sizeof(decoded_hi_octet) + },{ + encoded_constructed_hi_octet3, sizeof(encoded_constructed_hi_octet3), + decoded_hi_octet, sizeof(decoded_hi_octet) + },{ + encoded_empty_octet, sizeof(encoded_empty_octet), + encoded_empty_octet, 0 + },{ + encoded_hi_octet, sizeof(encoded_hi_octet) - 1, + NULL, 0, CRYPT_E_ASN1_EOD + },{ + encoded_constructed_hi_octet, sizeof(encoded_constructed_hi_octet) - 1, + NULL, 0, CRYPT_E_ASN1_EOD + },{ + encoded_constructed_hi_octet_invalid_end, sizeof(encoded_constructed_hi_octet_invalid_end), + NULL, 0, CRYPT_E_ASN1_CORRUPT + } + }; + + for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) { BYTE *buf = NULL; BOOL ret; DWORD bufSize = 0;
ret = pCryptDecodeObjectEx(dwEncoding, X509_OCTET_STRING, - octets[i].encoded, octets[i].encoded[1] + 2, + tests[i].encoded, tests[i].encoded_size, CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &bufSize); - ok(ret, "CryptDecodeObjectEx failed: %08x\n", GetLastError()); - ok(bufSize >= sizeof(CRYPT_DATA_BLOB) + octets[i].encoded[1], - "Expected size >= %d, got %d\n", - (int)sizeof(CRYPT_DATA_BLOB) + octets[i].encoded[1], bufSize); + if (tests[i].error) + { + ok(!ret && GetLastError() == tests[i].error, + "[%u] CryptDecodeObjectEx returned %x(%x)\n", i, ret, GetLastError()); + continue; + } + ok(ret, "[%u] CryptDecodeObjectEx failed: %08x\n", i, GetLastError()); + ok(bufSize >= sizeof(CRYPT_DATA_BLOB) + tests[i].decoded_size, + "[%u] Expected size >= %d, got %d\n", i, + (int)sizeof(CRYPT_DATA_BLOB) + tests[i].decoded_size, bufSize); ok(buf != NULL, "Expected allocated buffer\n"); if (ret) { CRYPT_DATA_BLOB *blob = (CRYPT_DATA_BLOB *)buf;
+ ok (blob->cbData == tests[i].decoded_size, "[%u] cbData = %u\n", i, blob->cbData); if (blob->cbData) - ok(!memcmp(blob->pbData, octets[i].val, blob->cbData), + ok(!memcmp(blob->pbData, tests[i].decoded, blob->cbData), "Unexpected value\n"); LocalFree(buf); } @@ -3302,18 +3368,76 @@ static const BYTE hash[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
static const BYTE signedBigCert[] = { - 0x30, 0x81, 0x93, 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0x30, - 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, - 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22, 0x18, 0x0f, - 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, - 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, - 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, - 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, - 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3, - 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, - 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, - 0x00, 0x03, 0x11, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, - 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 }; + ASN_SEQUENCE,0x81,147, + ASN_SEQUENCE,122, + ASN_INTEGER,1, 0x01, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_SEQUENCE,21, + 0x31,19, + ASN_SEQUENCE,17, + ASN_OBJECTIDENTIFIER,3, 0x55,0x04,0x03, + 0x13,10, 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00, + ASN_SEQUENCE,34, + 0x18,15, 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a, + 0x18,15, 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a, + ASN_SEQUENCE,21, + 0x31,19, + ASN_SEQUENCE,17, + ASN_OBJECTIDENTIFIER,3, 0x55,0x04,0x03, + 0x13,10, 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00, + ASN_SEQUENCE,7, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_BITS,1, 0x00, + 0xa3,22, + ASN_SEQUENCE,20, + ASN_SEQUENCE,18, + ASN_OBJECTIDENTIFIER,3, 0x55,0x1d,0x13, + 0x01,1, 0xff, + ASN_OCTETSTRING,8, 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_BITS,17, 0x00,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08, + 0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00 +}; + +static const BYTE signedBigCertWithIndefiniteSeq[] = { + ASN_SEQUENCE,0x81,151, + ASN_SEQUENCE,126, + ASN_INTEGER,1, 0x01, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_SEQUENCE,21, + 0x31,19, + ASN_SEQUENCE,17, + ASN_OBJECTIDENTIFIER,3, 0x55,0x04,0x03, + 0x13,10, 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00, + ASN_SEQUENCE,0x80, + 0x18,15, 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a, + 0x18,15, 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a, + 0,0, + ASN_SEQUENCE,21, + 0x31,19, + ASN_SEQUENCE,17, + ASN_OBJECTIDENTIFIER,3, 0x55,0x04,0x03, + 0x13,10, 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00, + ASN_SEQUENCE,0x80, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_BITS,1, 0x00, + 0,0, + 0xa3,22, + ASN_SEQUENCE,20, + ASN_SEQUENCE,18, + ASN_OBJECTIDENTIFIER,3, 0x55,0x1d,0x13, + 0x01,1, 0xff, + ASN_OCTETSTRING,8, 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01, + ASN_SEQUENCE,2, + ASN_OBJECTIDENTIFIER,0, + ASN_BITS,17, 0x00,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08, + 0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00 +};
static void test_encodeCert(DWORD dwEncoding) { @@ -3369,6 +3493,29 @@ static void test_decodeCert(DWORD dwEncoding) { CERT_INFO *info = (CERT_INFO *)buf;
+ ok(size >= sizeof(CERT_INFO), "Wrong size %d\n", size); + ok(info->SerialNumber.cbData == 1, + "Expected serial number size 1, got %d\n", info->SerialNumber.cbData); + ok(*info->SerialNumber.pbData == *serialNum, + "Expected serial number %d, got %d\n", *serialNum, + *info->SerialNumber.pbData); + ok(info->Issuer.cbData == sizeof(encodedCommonName), + "Wrong size %d\n", info->Issuer.cbData); + ok(!memcmp(info->Issuer.pbData, encodedCommonName, info->Issuer.cbData), + "Unexpected issuer\n"); + ok(info->Subject.cbData == sizeof(encodedCommonName), + "Wrong size %d\n", info->Subject.cbData); + ok(!memcmp(info->Subject.pbData, encodedCommonName, + info->Subject.cbData), "Unexpected subject\n"); + LocalFree(buf); + } + ret = pCryptDecodeObjectEx(dwEncoding, X509_CERT_TO_BE_SIGNED, signedBigCertWithIndefiniteSeq, + sizeof(signedBigCertWithIndefiniteSeq), CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); + ok(ret, "CryptDecodeObjectEx failed: %08x\n", GetLastError()); + if (ret) + { + CERT_INFO *info = (CERT_INFO *)buf; + ok(size >= sizeof(CERT_INFO), "Wrong size %d\n", size); ok(info->SerialNumber.cbData == 1, "Expected serial number size 1, got %d\n", info->SerialNumber.cbData); @@ -5909,32 +6056,79 @@ static const BYTE indefiniteSignedPKCSContent[] = { 0xe3,0x55,0x71,0x91,0xf9,0x2a,0xd1,0xb8,0xaa,0x52,0xb8,0x22,0x3a,0xeb,0x61, 0x00,0x00,0x00,0x00,0x00,0x00 };
+static const BYTE content_abcd[] = { + ASN_SEQUENCE, 0x80, + ASN_OBJECTIDENTIFIER, 2, 42,3, + ASN_CONTEXT|ASN_CONSTRUCTOR, 0x80, + ASN_OCTETSTRING, 4, 'a','b','c','d', + 0,0, + 0,0, +}; + +static const BYTE encoded_abcd[] = { + ASN_OCTETSTRING, 4, 'a','b','c','d', +}; + +static const BYTE content_constructed_abcd[] = { + ASN_SEQUENCE, 0x80, + ASN_OBJECTIDENTIFIER, 2, 42,3, + ASN_CONTEXT|ASN_CONSTRUCTOR, 0x80, + ASN_CONSTRUCTOR|ASN_OCTETSTRING,0x80, + ASN_OCTETSTRING, 4, 'a','b','0','0', + 0,0, + 0,0, + 0,0, + 1,2,3,4,5,6,7 /* extra garbage */ +}; + static void test_decodePKCSContentInfo(DWORD dwEncoding) { BOOL ret; LPBYTE buf = NULL; - DWORD size = 0; + DWORD size = 0, i; CRYPT_CONTENT_INFO *info;
- ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, - emptyPKCSContentInfo, sizeof(emptyPKCSContentInfo), - CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); - ok(ret, "CryptDecodeObjectEx failed: %x\n", GetLastError()); - if (ret) + const struct { + const BYTE *encoded; + UINT encoded_size; + const char *obj_id; + const BYTE *content; + UINT content_size; + } tests[] = { + { emptyPKCSContentInfo, sizeof(emptyPKCSContentInfo), + "1.2.3", NULL, 0 }, + { emptyPKCSContentInfoExtraBytes, sizeof(emptyPKCSContentInfoExtraBytes), + "1.2.3", NULL, 0 }, + { intPKCSContentInfo, sizeof(intPKCSContentInfo), + "1.2.3", ints[0].encoded, ints[0].encoded[1] + 2 }, + { indefiniteSignedPKCSContent, sizeof(indefiniteSignedPKCSContent), + "1.2.840.113549.1.7.2", NULL, 392 }, + { content_abcd, sizeof(content_abcd), + "1.2.3", encoded_abcd, 6 }, + { content_constructed_abcd, sizeof(content_constructed_abcd), + "1.2.3", content_constructed_abcd + 8, 10 } + }; + + for (i = 0; i < sizeof(tests)/sizeof(*tests); i++) { + ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, tests[i].encoded, + tests[i].encoded_size, CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); + ok(ret, "[%u] CryptDecodeObjectEx failed: %x\n", i, GetLastError()); + if (!ret) continue; + info = (CRYPT_CONTENT_INFO *)buf;
- ok(!strcmp(info->pszObjId, "1.2.3"), "Expected 1.2.3, got %s\n", - info->pszObjId); - ok(info->Content.cbData == 0, "Expected no data, got %d\n", - info->Content.cbData); + ok(!strcmp(info->pszObjId, tests[i].obj_id), "[%u] Expected %s, got %s\n", + i, tests[i].obj_id, info->pszObjId); + ok(info->Content.cbData == tests[i].content_size, + "[%u] Unexpected size %d expected %d\n", i, info->Content.cbData, + tests[i].content_size); + if (tests[i].content) + ok(!memcmp(info->Content.pbData, tests[i].content, tests[i].content_size), + "[%u] Unexpected value\n", i); LocalFree(buf); } - ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, - emptyPKCSContentInfoExtraBytes, sizeof(emptyPKCSContentInfoExtraBytes), - 0, NULL, NULL, &size); - ok(ret, "CryptDecodeObjectEx failed: %x\n", GetLastError()); - SetLastError(0xdeadbeef); + ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, bogusPKCSContentInfo, sizeof(bogusPKCSContentInfo), CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); @@ -5945,36 +6139,6 @@ static void test_decodePKCSContentInfo(DWORD dwEncoding) GetLastError() == CRYPT_E_ASN1_CORRUPT)) || broken(ret), "Expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT, got %x\n", GetLastError()); - ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, - intPKCSContentInfo, sizeof(intPKCSContentInfo), - CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); - ok(ret, "CryptDecodeObjectEx failed: %x\n", GetLastError()); - if (ret) - { - info = (CRYPT_CONTENT_INFO *)buf; - - ok(!strcmp(info->pszObjId, "1.2.3"), "Expected 1.2.3, got %s\n", - info->pszObjId); - ok(info->Content.cbData == ints[0].encoded[1] + 2, - "Unexpected size %d\n", info->Content.cbData); - ok(!memcmp(info->Content.pbData, ints[0].encoded, - info->Content.cbData), "Unexpected value\n"); - LocalFree(buf); - } - ret = pCryptDecodeObjectEx(dwEncoding, PKCS_CONTENT_INFO, - indefiniteSignedPKCSContent, sizeof(indefiniteSignedPKCSContent), - CRYPT_DECODE_ALLOC_FLAG, NULL, &buf, &size); - ok(ret, "CryptDecodeObjectEx failed: %x\n", GetLastError()); - if (ret) - { - info = (CRYPT_CONTENT_INFO *)buf; - - ok(!strcmp(info->pszObjId, szOID_RSA_signedData), - "Expected %s, got %s\n", szOID_RSA_signedData, info->pszObjId); - ok(info->Content.cbData == 392, "Expected 392, got %d\n", - info->Content.cbData); - LocalFree(buf); - } }
static const BYTE emptyPKCSAttr[] = { 0x30,0x06,0x06,0x02,0x2a,0x03,0x31, @@ -8345,6 +8509,173 @@ static void testPortPublicKeyInfo(void) ok(ret,"CryptAcquireContextA failed\n"); }
+static const BYTE eccCert[] = { +0x30,0x82,0x01,0x46,0x30,0x81,0xec,0x02,0x09,0x00,0xe7,0x6b, +0x26,0x86,0x0a,0x82,0xff,0xe9,0x30,0x0a,0x06,0x08,0x2a,0x86, +0x48,0xce,0x3d,0x04,0x03,0x02,0x30,0x2b,0x31,0x0b,0x30,0x09, +0x06,0x03,0x55,0x04,0x06,0x13,0x02,0x44,0x45,0x31,0x0d,0x30, +0x0b,0x06,0x03,0x55,0x04,0x0a,0x0c,0x04,0x57,0x69,0x6e,0x65, +0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x03,0x0c,0x04,0x57, +0x69,0x6e,0x65,0x30,0x1e,0x17,0x0d,0x31,0x37,0x30,0x39,0x32, +0x37,0x31,0x33,0x34,0x31,0x30,0x34,0x5a,0x17,0x0d,0x32,0x37, +0x30,0x39,0x32,0x35,0x31,0x33,0x34,0x31,0x30,0x34,0x5a,0x30, +0x2b,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x06,0x13,0x02, +0x44,0x45,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55,0x04,0x0a,0x0c, +0x04,0x54,0x65,0x73,0x74,0x31,0x0d,0x30,0x0b,0x06,0x03,0x55, +0x04,0x03,0x0c,0x04,0x54,0x65,0x73,0x74,0x30,0x59,0x30,0x13, +0x06,0x07,0x2a,0x86,0x48,0xce,0x3d,0x02,0x01,0x06,0x08,0x2a, +0x86,0x48,0xce,0x3d,0x03,0x01,0x07,0x03,0x42,0x00,0x04,0xed, +0xfc,0x77,0xd8,0xb9,0xe7,0xf3,0xf8,0xce,0x13,0xb8,0x7f,0x0f, +0x78,0xea,0x73,0x87,0x29,0x10,0xe1,0x6d,0x10,0xce,0x57,0x60, +0x3b,0x3e,0xb4,0x5f,0x0d,0x20,0xc1,0xeb,0x6d,0x74,0xe9,0x7b, +0x11,0x51,0x9a,0x00,0xe8,0xe9,0x12,0x84,0xb9,0x07,0x7e,0x7b, +0x62,0x67,0x12,0x67,0x08,0xe5,0x2e,0x27,0xce,0xa2,0x57,0x15, +0xad,0xc5,0x1f,0x30,0x0a,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d, +0x04,0x03,0x02,0x03,0x49,0x00,0x30,0x46,0x02,0x21,0x00,0xd7, +0x29,0xce,0x5a,0xef,0x74,0x85,0xd1,0x18,0x5f,0x6e,0xf1,0xba, +0x53,0xd4,0xcd,0xdd,0xe0,0x5d,0xf1,0x5e,0x48,0x51,0xea,0x63, +0xc0,0xe8,0xe2,0xf6,0xfa,0x4c,0xaf,0x02,0x21,0x00,0xe3,0x94, +0x15,0x3b,0x6c,0x71,0x6e,0x44,0x22,0xcb,0xa0,0x88,0xcd,0x0a, +0x5a,0x50,0x29,0x7c,0x5c,0xd6,0x6c,0xd2,0xe0,0x7f,0xcd,0x02, +0x92,0x21,0x4c,0x2c,0x92,0xee }; +static const BYTE ecdsaSig[] = { +0x30,0x46,0x02,0x21,0x00,0xd7,0x29,0xce,0x5a,0xef,0x74,0x85, +0xd1,0x18,0x5f,0x6e,0xf1,0xba,0x53,0xd4,0xcd,0xdd,0xe0,0x5d, +0xf1,0x5e,0x48,0x51,0xea,0x63,0xc0,0xe8,0xe2,0xf6,0xfa,0x4c, +0xaf,0x02,0x21,0x00,0xe3,0x94,0x15,0x3b,0x6c,0x71,0x6e,0x44, +0x22,0xcb,0xa0,0x88,0xcd,0x0a,0x5a,0x50,0x29,0x7c,0x5c,0xd6, +0x6c,0xd2,0xe0,0x7f,0xcd,0x02,0x92,0x21,0x4c,0x2c,0x92,0xee }; +static const BYTE eccPubKey[] = { +0x30,0x59,0x30,0x13,0x06,0x07,0x2a,0x86,0x48,0xce,0x3d,0x02, +0x01,0x06,0x08,0x2a,0x86,0x48,0xce,0x3d,0x03,0x01,0x07,0x03, +0x42,0x00,0x04,0xed,0xfc,0x77,0xd8,0xb9,0xe7,0xf3,0xf8,0xce, +0x13,0xb8,0x7f,0x0f,0x78,0xea,0x73,0x87,0x29,0x10,0xe1,0x6d, +0x10,0xce,0x57,0x60,0x3b,0x3e,0xb4,0x5f,0x0d,0x20,0xc1,0xeb, +0x6d,0x74,0xe9,0x7b,0x11,0x51,0x9a,0x00,0xe8,0xe9,0x12,0x84, +0xb9,0x07,0x7e,0x7b,0x62,0x67,0x12,0x67,0x08,0xe5,0x2e,0x27, +0xce,0xa2,0x57,0x15,0xad,0xc5,0x1f }; + +static void testECDSACert(void) +{ + DWORD decode_flags = CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG; + CERT_SIGNED_CONTENT_INFO *info; + CERT_PUBLIC_KEY_INFO *pubkey; + CERT_ECC_SIGNATURE *ecc_sig; + LPSTR *ecc_curve; + DWORD size; + BOOL ret; + int i; + + info = NULL; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT, eccCert, sizeof(eccCert), decode_flags, + NULL, &info, &size); + ok(ret, "CryptDecodeObjectEx failed with %d\n", GetLastError()); + + ok(!strcmp(info->SignatureAlgorithm.pszObjId, szOID_ECDSA_SHA256), + "Expected 1.2.840.10045.4.3.2, got %s\n", info->SignatureAlgorithm.pszObjId); + ok(!info->SignatureAlgorithm.Parameters.cbData, + "Expected no parameter data, got %d bytes\n", info->SignatureAlgorithm.Parameters.cbData); + ok(!info->SignatureAlgorithm.Parameters.pbData, + "Expected no parameter data, got %p pointer\n", info->SignatureAlgorithm.Parameters.pbData); + + ok(info->Signature.cbData == sizeof(ecdsaSig), + "Expected %d bytes, got %d\n", (int)sizeof(ecdsaSig), info->Signature.cbData); + ok(info->Signature.pbData != NULL, "Got NULL pointer\n"); + ok(!info->Signature.cUnusedBits, "Expected no unused bytes, got %d\n", info->Signature.cUnusedBits); + for (i = 0; i < info->Signature.cbData; i++) + { + ok(ecdsaSig[i] == info->Signature.pbData[i], "Expected %02x, got %02x at offset %d\n", + ecdsaSig[i], info->Signature.pbData[i], i); + } + + ecc_sig = NULL; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, X509_ECC_SIGNATURE, info->Signature.pbData, + info->Signature.cbData, decode_flags, NULL, &ecc_sig, &size); + ok(ret, "CryptDecodeObjectEx failed with %d\n", GetLastError()); + if (ret) + { + ok(ecc_sig->r.cbData == 32, "Expected 32 bytes, got %d\n", ecc_sig->r.cbData); + ok(ecc_sig->r.pbData != NULL, "Got NULL pointer\n"); + ok(ecc_sig->s.cbData == 32, "Expected 32 bytes, got %d\n", ecc_sig->s.cbData); + ok(ecc_sig->s.pbData != NULL, "Got NULL pointer\n"); + for (i = 0; i < ecc_sig->r.cbData; i++) + { + ok(ecdsaSig[4+32-i] == ecc_sig->r.pbData[i], "Expected %02x, got %02x at offset %d\n", + ecdsaSig[4+32-i], ecc_sig->r.pbData[i], i); + } + for (i = 0; i < ecc_sig->s.cbData; i++) + { + ok(ecdsaSig[4+35+32-i] == ecc_sig->s.pbData[i], "Expected %02x, got %02x at offset %d\n", + ecdsaSig[4+35+32-i], ecc_sig->s.pbData[i], i); + } + LocalFree(ecc_sig); + } + + LocalFree(info); + + info = NULL; + decode_flags &= ~CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, X509_CERT, eccCert, sizeof(eccCert), decode_flags, + NULL, &info, &size); + ok(ret, "CryptDecodeObjectEx failed with %d\n", GetLastError()); + + ok(info->Signature.cbData == sizeof(ecdsaSig), + "Expected %d bytes, got %d\n", (int)sizeof(ecdsaSig), info->Signature.cbData); + ok(info->Signature.pbData != NULL, "Got NULL pointer\n"); + ok(!info->Signature.cUnusedBits, "Expected no unused bytes, got %d\n", info->Signature.cUnusedBits); + for (i = 0; i < info->Signature.cbData; i++) + { + ok(ecdsaSig[sizeof(ecdsaSig)-i-1] == info->Signature.pbData[i], "Expected %02x, got %02x at offset %d\n", + ecdsaSig[sizeof(ecdsaSig)-i-1], info->Signature.pbData[i], i); + } + + LocalFree(info); + + pubkey = NULL; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, X509_PUBLIC_KEY_INFO, eccPubKey, sizeof(eccPubKey), + decode_flags, NULL, &pubkey, &size); + ok(ret, "CryptDecodeObjectEx failed with %d\n", GetLastError()); + + ok(!strcmp(pubkey->Algorithm.pszObjId, szOID_ECC_PUBLIC_KEY), + "Expected 1.2.840.10045.2.1, got %s\n", pubkey->Algorithm.pszObjId); + ok(pubkey->Algorithm.Parameters.cbData == 10, + "Expected 10 bytes parameters, got %d bytes\n", pubkey->Algorithm.Parameters.cbData); + ok(pubkey->Algorithm.Parameters.pbData != NULL, + "Expected pointer to parameters, got NULL\n"); + + ecc_curve = NULL; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, X509_OBJECT_IDENTIFIER, pubkey->Algorithm.Parameters.pbData, + pubkey->Algorithm.Parameters.cbData, decode_flags, NULL, &ecc_curve, &size); + ok(ret || broken(GetLastError() == ERROR_FILE_NOT_FOUND /* < Vista */), + "CryptDecodeObjectEx failed with %d\n", GetLastError()); + if (ret) + { + ok(!strcmp(*ecc_curve, szOID_ECC_CURVE_P256), "Expected 1.2.840.10045.3.1.7, got %s\n", *ecc_curve); + LocalFree(ecc_curve); + } + + ecc_curve = NULL; + ret = pCryptDecodeObjectEx(X509_ASN_ENCODING, szOID_ECC_PUBLIC_KEY, pubkey->Algorithm.Parameters.pbData, + pubkey->Algorithm.Parameters.cbData, decode_flags, NULL, &ecc_curve, &size); + ok(ret || broken(GetLastError() == ERROR_FILE_NOT_FOUND /* < Vista */), + "CryptDecodeObjectEx failed with %d\n", GetLastError()); + if (ret) + { + ok(!strcmp(*ecc_curve, szOID_ECC_CURVE_P256), "Expected 1.2.840.10045.3.1.7, got %s\n", *ecc_curve); + LocalFree(ecc_curve); + } + + ok(pubkey->PublicKey.cbData == 65, "Expected 32 bytes parameters, got %d bytes\n", pubkey->PublicKey.cbData); + ok(pubkey->PublicKey.pbData != NULL, "Expected pointer to parameters, got NULL\n"); + for (i = 0; i < pubkey->PublicKey.cbData; i++) + { + ok(eccPubKey[26+i] == pubkey->PublicKey.pbData[i], "Expected %02x, got %02x at offset %d\n", + eccPubKey[26+i], pubkey->PublicKey.pbData[i], i); + } + + LocalFree(pubkey); +} + START_TEST(encode) { static const DWORD encodings[] = { X509_ASN_ENCODING, PKCS_7_ASN_ENCODING, @@ -8438,4 +8769,5 @@ START_TEST(encode) test_decodeRsaPrivateKey(encodings[i]); } testPortPublicKeyInfo(); + testECDSACert(); } diff --git a/modules/rostests/winetests/crypt32/main.c b/modules/rostests/winetests/crypt32/main.c index d6ef8ddeed..a0019b5869 100644 --- a/modules/rostests/winetests/crypt32/main.c +++ b/modules/rostests/winetests/crypt32/main.c @@ -18,7 +18,15 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> +#include <winreg.h> + +#include "wine/test.h"
static HMODULE hCrypt;
diff --git a/modules/rostests/winetests/crypt32/message.c b/modules/rostests/winetests/crypt32/message.c index 11f3ff0cf3..7e2e8aa840 100644 --- a/modules/rostests/winetests/crypt32/message.c +++ b/modules/rostests/winetests/crypt32/message.c @@ -18,7 +18,14 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h"
static BOOL (WINAPI * pCryptAcquireContextA) (HCRYPTPROV *, LPCSTR, LPCSTR, DWORD, DWORD); diff --git a/modules/rostests/winetests/crypt32/msg.c b/modules/rostests/winetests/crypt32/msg.c index 45a012a22c..c2405335b9 100644 --- a/modules/rostests/winetests/crypt32/msg.c +++ b/modules/rostests/winetests/crypt32/msg.c @@ -18,7 +18,16 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#define CMSG_SIGNER_ENCODE_INFO_HAS_CMS_FIELDS +#define CMSG_SIGNED_ENCODE_INFO_HAS_CMS_FIELDS +#include <wincrypt.h> + +#include "wine/test.h"
static BOOL have_nt = TRUE; static BOOL old_crypt32 = FALSE; @@ -2848,7 +2857,7 @@ static void test_decode_msg_get_param(void) HCRYPTPROV hCryptProv; HCRYPTKEY key = 0; BOOL ret; - DWORD size = 0, value; + DWORD size = 0, value, req_size; LPBYTE buf; CMSG_CTRL_DECRYPT_PARA decryptPara = { sizeof(decryptPara), 0 };
@@ -2938,7 +2947,10 @@ static void test_decode_msg_get_param(void) signer.SerialNumber.cbData = sizeof(serialNum); signer.SerialNumber.pbData = serialNum; signer.HashAlgorithm.pszObjId = oid_rsa_md5; + req_size = size; + size += 10; CryptMsgGetParam(msg, CMSG_SIGNER_INFO_PARAM, 0, buf, &size); + ok(size == req_size, "size = %u, expected %u\n", size, req_size); compare_signer_info((CMSG_SIGNER_INFO *)buf, &signer); CryptMemFree(buf); } diff --git a/modules/rostests/winetests/crypt32/object.c b/modules/rostests/winetests/crypt32/object.c index 61e64442f5..211b5423e0 100644 --- a/modules/rostests/winetests/crypt32/object.c +++ b/modules/rostests/winetests/crypt32/object.c @@ -17,8 +17,14 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h>
-#include "precomp.h" +#include "wine/test.h"
static BOOL (WINAPI * pCryptQueryObject)(DWORD, const void *, DWORD, DWORD, DWORD, DWORD *, DWORD *, DWORD *, HCERTSTORE *, HCRYPTMSG *, const void **); diff --git a/modules/rostests/winetests/crypt32/oid.c b/modules/rostests/winetests/crypt32/oid.c index 9a3dbe130c..89d58b77f8 100644 --- a/modules/rostests/winetests/crypt32/oid.c +++ b/modules/rostests/winetests/crypt32/oid.c @@ -17,8 +17,17 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#define CRYPT_OID_INFO_HAS_EXTRA_FIELDS +#include <wincrypt.h> +#include <winreg.h> + +#include "wine/test.h"
-#include "precomp.h"
static BOOL (WINAPI *pCryptEnumOIDInfo)(DWORD,DWORD,void*,PFN_CRYPT_ENUM_OID_INFO);
@@ -28,6 +37,7 @@ struct OIDToAlgID LPCSTR oid; LPCSTR altOid; DWORD algID; + DWORD altAlgID; };
static const struct OIDToAlgID oidToAlgID[] = { @@ -64,6 +74,9 @@ static const struct OIDToAlgID oidToAlgID[] = { { szOID_OIWDIR_md2RSA, NULL, CALG_MD2 }, { szOID_INFOSEC_mosaicUpdatedSig, NULL, CALG_SHA }, { szOID_INFOSEC_mosaicKMandUpdSig, NULL, CALG_DSS_SIGN }, + { szOID_NIST_sha256, NULL, CALG_SHA_256, -1 }, + { szOID_NIST_sha384, NULL, CALG_SHA_384, -1 }, + { szOID_NIST_sha512, NULL, CALG_SHA_512, -1 } };
static const struct OIDToAlgID algIDToOID[] = { @@ -96,10 +109,7 @@ static void testOIDToAlgID(void) for (i = 0; i < sizeof(oidToAlgID) / sizeof(oidToAlgID[0]); i++) { alg = CertOIDToAlgId(oidToAlgID[i].oid); - /* Not all Windows installations support all these, so make sure it's - * at least not the wrong one. - */ - ok(alg == 0 || alg == oidToAlgID[i].algID, + ok(alg == oidToAlgID[i].algID || (oidToAlgID[i].altAlgID && alg == oidToAlgID[i].altAlgID), "Expected %d, got %d\n", oidToAlgID[i].algID, alg); } } @@ -118,6 +128,7 @@ static void testAlgIDToOID(void) { oid = CertAlgIdToOID(algIDToOID[i].algID); /* Allow failure, not every version of Windows supports every algo */ + ok(oid != NULL || broken(!oid), "CertAlgIdToOID failed, expected %s\n", algIDToOID[i].oid); if (oid) { if (strcmp(oid, algIDToOID[i].oid)) @@ -533,12 +544,16 @@ static void test_enumOIDInfo(void)
static void test_findOIDInfo(void) { + static WCHAR sha256ECDSA[] = { 's','h','a','2','5','6','E','C','D','S','A',0 }; static WCHAR sha1[] = { 's','h','a','1',0 }; - static CHAR oid_rsa_md5[] = szOID_RSA_MD5; + static CHAR oid_rsa_md5[] = szOID_RSA_MD5, oid_sha256[] = szOID_NIST_sha256; + static CHAR oid_ecda_sha25[] = szOID_ECDSA_SHA256; ALG_ID alg = CALG_SHA1; ALG_ID algs[2] = { CALG_MD5, CALG_RSA_SIGN }; PCCRYPT_OID_INFO info;
+ static const WCHAR sha256W[] = {'s','h','a','2','5','6',0}; + info = CryptFindOIDInfo(0, NULL, 0); ok(info == NULL, "Expected NULL\n"); info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid_rsa_md5, 0); @@ -577,6 +592,49 @@ static void test_findOIDInfo(void) ok(U(*info).Algid == CALG_MD5, "Expected CALG_MD5, got %d\n", U(*info).Algid); } + + info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid_sha256, 0); + ok(info != NULL, "Expected to find szOID_RSA_MD5\n"); + if (info) + { + ok(!strcmp(info->pszOID, szOID_NIST_sha256), "Expected %s, got %s\n", + szOID_NIST_sha256, info->pszOID); + ok(!lstrcmpW(info->pwszName, sha256W), "pwszName = %s\n", wine_dbgstr_w(info->pwszName)); + ok(U(*info).Algid == CALG_SHA_256 || U(*info).Algid == -1, + "Expected CALG_MD5 or -1, got %d\n", U(*info).Algid); + } + + info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid_ecda_sha25, 0); + if (info) + { + DWORD *data; + + ok(info->cbSize == sizeof(*info), + "Expected %d, got %d\n", (int)sizeof(*info), info->cbSize); + ok(!strcmp(info->pszOID, oid_ecda_sha25), + "Expected %s, got %s\n", oid_ecda_sha25, info->pszOID); + ok(!lstrcmpW(info->pwszName, sha256ECDSA), + "Expected %s, got %s\n", wine_dbgstr_w(sha256ECDSA), wine_dbgstr_w(info->pwszName)); + ok(info->dwGroupId == CRYPT_SIGN_ALG_OID_GROUP_ID, + "Expected CRYPT_SIGN_ALG_OID_GROUP_ID, got %u\n", info->dwGroupId); + ok(U(*info).Algid == CALG_OID_INFO_CNG_ONLY, + "Expected CALG_OID_INFO_CNG_ONLY, got %d\n", U(*info).Algid); + + data = (DWORD *)info->ExtraInfo.pbData; + ok(info->ExtraInfo.cbData == 8, + "Expected 8, got %d\n", info->ExtraInfo.cbData); + ok(data[0] == CALG_OID_INFO_PARAMETERS, + "Expected CALG_OID_INFO_PARAMETERS, got %x\n", data[0]); + ok(data[1] == CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG, + "Expected CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG, got %x\n", data[1]); + + ok(!lstrcmpW(info->pwszCNGAlgid, BCRYPT_SHA256_ALGORITHM), "Expected %s, got %s\n", + wine_dbgstr_w(BCRYPT_SHA256_ALGORITHM), wine_dbgstr_w(info->pwszCNGAlgid)); + ok(!lstrcmpW(info->pwszCNGExtraAlgid, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM), "Expected %s, got %s\n", + wine_dbgstr_w(CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM), wine_dbgstr_w(info->pwszCNGExtraAlgid)); + } + else + win_skip("Host does not support ECDSA_SHA256, skipping test\n"); }
START_TEST(oid) diff --git a/modules/rostests/winetests/crypt32/precomp.h b/modules/rostests/winetests/crypt32/precomp.h index 81c3376acc..247edf56f1 100644 --- a/modules/rostests/winetests/crypt32/precomp.h +++ b/modules/rostests/winetests/crypt32/precomp.h @@ -1,3 +1,4 @@ + #ifndef _CRYPT32_WINETEST_PRECOMP_H_ #define _CRYPT32_WINETEST_PRECOMP_H_
@@ -5,12 +6,16 @@
#define _INC_WINDOWS #define COM_NO_WINDOWS_H + #include <ntstatus.h> #define WIN32_NO_STATUS + #include <wine/test.h> #include <winreg.h> + #define CMSG_SIGNER_ENCODE_INFO_HAS_CMS_FIELDS #define CMSG_SIGNED_ENCODE_INFO_HAS_CMS_FIELDS +#define CRYPT_OID_INFO_HAS_EXTRA_FIELDS #include <wincrypt.h>
#endif /* !_CRYPT32_WINETEST_PRECOMP_H_ */ diff --git a/modules/rostests/winetests/crypt32/protectdata.c b/modules/rostests/winetests/crypt32/protectdata.c index 3cde714cad..70a8ba86b0 100644 --- a/modules/rostests/winetests/crypt32/protectdata.c +++ b/modules/rostests/winetests/crypt32/protectdata.c @@ -18,7 +18,14 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h"
static BOOL (WINAPI *pCryptProtectData)(DATA_BLOB*,LPCWSTR,DATA_BLOB*,PVOID,CRYPTPROTECT_PROMPTSTRUCT*,DWORD,DATA_BLOB*); static BOOL (WINAPI *pCryptUnprotectData)(DATA_BLOB*,LPWSTR*,DATA_BLOB*,PVOID,CRYPTPROTECT_PROMPTSTRUCT*,DWORD,DATA_BLOB*); diff --git a/modules/rostests/winetests/crypt32/sip.c b/modules/rostests/winetests/crypt32/sip.c index 512146e826..e2ec2f411d 100644 --- a/modules/rostests/winetests/crypt32/sip.c +++ b/modules/rostests/winetests/crypt32/sip.c @@ -19,11 +19,17 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" - +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> #include <winnls.h> +#include <wincrypt.h> #include <mssip.h>
+#include "wine/test.h" + static BOOL (WINAPI * funcCryptSIPGetSignedDataMsg)(SIP_SUBJECTINFO *,DWORD *,DWORD,DWORD *,BYTE *); static BOOL (WINAPI * funcCryptSIPPutSignedDataMsg)(SIP_SUBJECTINFO *,DWORD,DWORD *,DWORD,BYTE *); static BOOL (WINAPI * funcCryptSIPCreateIndirectData)(SIP_SUBJECTINFO *,DWORD *,SIP_INDIRECT_DATA *); diff --git a/modules/rostests/winetests/crypt32/store.c b/modules/rostests/winetests/crypt32/store.c index 226ffc04c3..47cd0b38cd 100644 --- a/modules/rostests/winetests/crypt32/store.c +++ b/modules/rostests/winetests/crypt32/store.c @@ -18,10 +18,19 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
-#include "precomp.h" +#include <stdio.h> +#include <stdarg.h>
+#include <windef.h> +#include <winbase.h> +#include <winuser.h> #include <shlobj.h> #include <shlwapi.h> +#include <winreg.h> +#include <winerror.h> +#include <wincrypt.h> + +#include "wine/test.h"
/* The following aren't defined in wincrypt.h, as they're "reserved" */ #define CERT_CERT_PROP_ID 32 @@ -108,16 +117,6 @@ static const BYTE signedCTLWithCTLInnerContent[] = { 0x8e,0xe7,0x5f,0x76,0x2b,0xd1,0x6a,0x82,0xb3,0x30,0x25,0x61,0xf6,0x25,0x23, 0x57,0x6c,0x0b,0x47,0xb8 };
-static BOOL (WINAPI *pCertControlStore)(HCERTSTORE,DWORD,DWORD,void const*); -static PCCRL_CONTEXT (WINAPI *pCertEnumCRLsInStore)(HCERTSTORE,PCCRL_CONTEXT); -static BOOL (WINAPI *pCertEnumSystemStore)(DWORD,void*,void*,PFN_CERT_ENUM_SYSTEM_STORE); -static BOOL (WINAPI *pCertGetStoreProperty)(HCERTSTORE,DWORD,void*,DWORD*); -static void (WINAPI *pCertRemoveStoreFromCollection)(HCERTSTORE,HCERTSTORE); -static BOOL (WINAPI *pCertSetStoreProperty)(HCERTSTORE,DWORD,DWORD,const void*); -static BOOL (WINAPI *pCertAddCertificateLinkToStore)(HCERTSTORE,PCCERT_CONTEXT,DWORD,PCCERT_CONTEXT*); -static BOOL (WINAPI *pCertRegisterSystemStore)(const void*,DWORD,void*,void*); -static BOOL (WINAPI *pCertUnregisterSystemStore)(const void*,DWORD); - #define test_store_is_empty(store) _test_store_is_empty(__LINE__,store) static void _test_store_is_empty(unsigned line, HCERTSTORE store) { @@ -882,32 +881,25 @@ static void testCollectionStore(void) ok(context == NULL, "Unexpected cert\n"); }
- if (!pCertRemoveStoreFromCollection) - { - win_skip("CertRemoveStoreFromCollection() is not available\n"); - } - else - { - /* Finally, test removing stores from the collection. No return - * value, so it's a bit funny to test. - */ - /* This crashes - * pCertRemoveStoreFromCollection(NULL, NULL); - */ - /* This "succeeds," no crash, no last error set */ - SetLastError(0xdeadbeef); - pCertRemoveStoreFromCollection(store2, collection); - ok(GetLastError() == 0xdeadbeef, - "Didn't expect an error to be set: %08x\n", GetLastError()); - - /* After removing store2, the collection should be empty */ - SetLastError(0xdeadbeef); - pCertRemoveStoreFromCollection(collection, store2); - ok(GetLastError() == 0xdeadbeef, - "Didn't expect an error to be set: %08x\n", GetLastError()); - context = CertEnumCertificatesInStore(collection, NULL); - ok(!context, "Unexpected cert\n"); - } + /* Finally, test removing stores from the collection. No return + * value, so it's a bit funny to test. + */ + /* This crashes + * CertRemoveStoreFromCollection(NULL, NULL); + */ + /* This "succeeds," no crash, no last error set */ + SetLastError(0xdeadbeef); + CertRemoveStoreFromCollection(store2, collection); + ok(GetLastError() == 0xdeadbeef, + "Didn't expect an error to be set: %08x\n", GetLastError()); + + /* After removing store2, the collection should be empty */ + SetLastError(0xdeadbeef); + CertRemoveStoreFromCollection(collection, store2); + ok(GetLastError() == 0xdeadbeef, + "Didn't expect an error to be set: %08x\n", GetLastError()); + context = CertEnumCertificatesInStore(collection, NULL); + ok(!context, "Unexpected cert\n");
CertCloseStore(collection, 0); CertCloseStore(store2, 0); @@ -935,16 +927,11 @@ static void testCollectionStore(void) CertCloseStore(store1, 0);
/* Test whether a collection store can be committed */ - if (!pCertControlStore) - { - win_skip("CertControlStore() is not available\n"); - return; - } collection = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
SetLastError(0xdeadbeef); - ret = pCertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError());
/* Adding a mem store that can't be committed prevents a successful commit. @@ -953,10 +940,10 @@ static void testCollectionStore(void) CERT_STORE_CREATE_NEW_FLAG, NULL); CertAddStoreToCollection(collection, store1, 0, 0); SetLastError(0xdeadbeef); - ret = pCertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED, "expected ERROR_CALL_NOT_IMPLEMENTED, got %d\n", GetLastError()); - pCertRemoveStoreFromCollection(collection, store1); + CertRemoveStoreFromCollection(collection, store1); CertCloseStore(store1, 0);
/* Test adding a cert to a collection with a file store, committing the @@ -982,7 +969,7 @@ static void testCollectionStore(void) bigCert, sizeof(bigCert), CERT_STORE_ADD_ALWAYS, NULL); ok(ret, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError()); - ret = pCertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(collection, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %d\n", ret); compareStore(collection, "serialized store with cert", serializedStoreWithCert, sizeof(serializedStoreWithCert), FALSE); @@ -1050,13 +1037,6 @@ static void testRegStore(void) todo_wine ok(store != 0, "CertOpenStore failed: %08x\n", GetLastError()); CertCloseStore(store, 0);
- /* It looks like the remainder pretty much needs CertControlStore() */ - if (!pCertControlStore) - { - win_skip("CertControlStore() is not available\n"); - return; - } - rc = RegCreateKeyExA(HKEY_CURRENT_USER, tempKey, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &key, NULL); ok(!rc, "RegCreateKeyExA failed: %d\n", rc); @@ -1080,7 +1060,7 @@ static void testRegStore(void) ok(ret, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError()); /* so flush the cache to force a commit.. */ - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError()); /* and check that the expected subkey was written. */ size = sizeof(hash); @@ -1139,7 +1119,7 @@ static void testRegStore(void) ok(context != NULL, "Expected a cert context\n"); if (context) CertDeleteCertificateFromStore(context); - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError());
/* Add a serialized cert with a bogus hash directly to the registry */ @@ -1176,7 +1156,7 @@ static void testRegStore(void) sizeof(buf)); ok(!rc, "RegSetValueExA failed: %d\n", rc);
- ret = pCertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError());
/* Make sure the bogus hash cert gets loaded. */ @@ -1233,7 +1213,7 @@ static void testRegStore(void) sizeof(buf)); ok(!rc, "RegSetValueExA failed: %d\n", rc);
- ret = pCertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError());
/* and make sure just one cert still gets loaded. */ @@ -1244,9 +1224,7 @@ static void testRegStore(void) if (context) certCount++; } while (context != NULL); - ok(certCount == 1 || - broken(certCount == 2) /* NT4 */ , - "Expected 1 certificates, got %d\n", certCount); + ok(certCount == 1, "Expected 1 certificate, got %d\n", certCount);
/* Try again with the correct hash... */ ptr = buf + sizeof(*hdr); @@ -1256,7 +1234,7 @@ static void testRegStore(void) sizeof(buf)); ok(!rc, "RegSetValueExA failed: %d\n", rc);
- ret = pCertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_RESYNC, NULL); ok(ret, "CertControlStore failed: %08x\n", GetLastError());
/* and make sure two certs get loaded. */ @@ -1295,20 +1273,10 @@ static void testRegStore(void) rc = RegDeleteKeyA(HKEY_CURRENT_USER, tempKey); if (rc) { - HMODULE shlwapi = LoadLibraryA("shlwapi"); - /* Use shlwapi's SHDeleteKeyA to _really_ blow away the key, * otherwise subsequent tests will fail. */ - if (shlwapi) - { - DWORD (WINAPI *pSHDeleteKeyA)(HKEY, LPCSTR); - - pSHDeleteKeyA = (void*)GetProcAddress(shlwapi, "SHDeleteKeyA"); - if (pSHDeleteKeyA) - pSHDeleteKeyA(HKEY_CURRENT_USER, tempKey); - FreeLibrary(shlwapi); - } + SHDeleteKeyA(HKEY_CURRENT_USER, tempKey); } } } @@ -1429,7 +1397,6 @@ static void testSystemStore(void) if (memStore) { BOOL ret = CertAddStoreToCollection(store, memStore, 0, 0); - /* FIXME: this'll fail on NT4, but what error will it give? */ ok(ret, "CertAddStoreToCollection failed: %08x\n", GetLastError()); CertCloseStore(memStore, 0); } @@ -1480,12 +1447,6 @@ static void testFileStore(void) PCCERT_CONTEXT cert; HANDLE file;
- if (!pCertControlStore) - { - win_skip("CertControlStore() is not available\n"); - return; - } - store = CertOpenStore(CERT_STORE_PROV_FILE, 0, 0, 0, NULL); ok(!store && GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError()); @@ -1521,7 +1482,7 @@ static void testFileStore(void) /* apparently allows adding certificates.. */ ok(ret, "CertAddEncodedCertificateToStore failed: %d\n", ret); /* but not commits.. */ - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED, "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError()); /* It still has certs in memory.. */ @@ -1545,7 +1506,7 @@ static void testFileStore(void) ret = CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, bigCert, sizeof(bigCert), CERT_STORE_ADD_ALWAYS, NULL); ok(ret, "CertAddEncodedCertificateToStore failed: %d\n", ret); - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED, "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError()); CertCloseStore(store, 0); @@ -1560,7 +1521,7 @@ static void testFileStore(void) ret = CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, bigCert, sizeof(bigCert), CERT_STORE_ADD_ALWAYS, NULL); ok(ret, "CertAddEncodedCertificateToStore failed: %d\n", ret); - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED, "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError()); CertCloseStore(store, 0); @@ -1576,7 +1537,7 @@ static void testFileStore(void) ok(ret, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError()); /* with commits enabled, commit is allowed */ - ret = pCertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %d\n", ret); compareStore(store, "serialized store with cert", serializedStoreWithCert, sizeof(serializedStoreWithCert), FALSE); @@ -1692,15 +1653,11 @@ static void testFileNameStore(void) BOOL ret; DWORD GLE;
- if (0) - { - /* Crashes on NT4 */ - store = CertOpenStore(CERT_STORE_PROV_FILENAME_W, 0, 0, 0, NULL); - GLE = GetLastError(); - ok(!store && (GLE == ERROR_PATH_NOT_FOUND || GLE == ERROR_INVALID_PARAMETER), - "Expected ERROR_PATH_NOT_FOUND or ERROR_INVALID_PARAMETER, got %08x\n", - GLE); - } + store = CertOpenStore(CERT_STORE_PROV_FILENAME_W, 0, 0, 0, NULL); + GLE = GetLastError(); + ok(!store && (GLE == ERROR_PATH_NOT_FOUND || GLE == ERROR_INVALID_PARAMETER), + "Expected ERROR_PATH_NOT_FOUND or ERROR_INVALID_PARAMETER, got %08x\n", + GLE);
if (!GetTempFileNameW(szDot, szPrefix, 0, filename)) return; @@ -1727,11 +1684,8 @@ static void testFileNameStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(!crl, "Expected no CRLs\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(!crl, "Expected no CRLs\n");
CertCloseStore(store, 0); DeleteFileW(filename); @@ -1751,11 +1705,8 @@ static void testFileNameStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(!crl, "Expected no CRLs\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(!crl, "Expected no CRLs\n");
CertCloseStore(store, 0); DeleteFileW(filename); @@ -1775,13 +1726,10 @@ static void testFileNameStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(crl != NULL, "CertEnumCRLsInStore failed: %08x\n", GetLastError()); - crl = pCertEnumCRLsInStore(store, crl); - ok(!crl, "Expected only one CRL\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(crl != NULL, "CertEnumCRLsInStore failed: %08x\n", GetLastError()); + crl = CertEnumCRLsInStore(store, crl); + ok(!crl, "Expected only one CRL\n");
CertCloseStore(store, 0); /* Don't delete it this time, the next test uses it */ @@ -1839,11 +1787,8 @@ static void testFileNameStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(!crl, "Expected no CRLs\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(!crl, "Expected no CRLs\n");
CertCloseStore(store, 0); DeleteFileW(filename); @@ -1863,11 +1808,8 @@ static void testFileNameStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(!crl, "Expected no CRLs\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(!crl, "Expected no CRLs\n");
CertCloseStore(store, 0); DeleteFileW(filename); @@ -1957,16 +1899,13 @@ static void testMessageStore(void) } while (cert); ok(count == 0, "Expected 0 certificates, got %d\n", count);
- if (pCertEnumCRLsInStore) - { - count = 0; - do { - crl = pCertEnumCRLsInStore(store, crl); - if (crl) - count++; - } while (crl); - ok(count == 0, "Expected 0 CRLs, got %d\n", count); - } + count = 0; + do { + crl = CertEnumCRLsInStore(store, crl); + if (crl) + count++; + } while (crl); + ok(count == 0, "Expected 0 CRLs, got %d\n", count);
/* Can add certs to a message store */ ret = CertAddEncodedCertificateToStore(store, X509_ASN_ENCODING, @@ -2008,16 +1947,14 @@ static void testMessageStore(void) } while (cert); ok(count == 1, "Expected 1 certificate, got %d\n", count);
- if (pCertEnumCRLsInStore) - { - count = 0; - do { - crl = pCertEnumCRLsInStore(store, crl); - if (crl) - count++; - } while (crl); - ok(count == 1, "Expected 1 CRL, got %d\n", count); - } + count = 0; + do { + crl = CertEnumCRLsInStore(store, crl); + if (crl) + count++; + } while (crl); + ok(count == 1, "Expected 1 CRL, got %d\n", count); + CertCloseStore(store, 0); } /* Encoding appears to be ignored */ @@ -2037,9 +1974,7 @@ static void testMessageStore(void) blob.pbData = (LPBYTE)hashBareContent; SetLastError(0xdeadbeef); store = CertOpenStore(CERT_STORE_PROV_PKCS7, 0, 0, 0, &blob); - ok(!store && - (GetLastError() == CRYPT_E_ASN1_BADTAG || - broken(GetLastError() == OSS_DATA_ERROR)), /* NT4 */ + ok(!store && GetLastError() == CRYPT_E_ASN1_BADTAG, "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError()); }
@@ -2073,11 +2008,9 @@ static void testSerializedStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(!crl, "Expected no CRLs\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(!crl, "Expected no CRLs\n"); + CertCloseStore(store, 0); } blob.cbData = sizeof(serializedStoreWithCertAndCRL); @@ -2094,14 +2027,12 @@ static void testSerializedStore(void) GetLastError()); cert = CertEnumCertificatesInStore(store, cert); ok(!cert, "Expected only one cert\n"); - if (pCertEnumCRLsInStore) - { - crl = pCertEnumCRLsInStore(store, NULL); - ok(crl != NULL, "CertEnumCRLsInStore failed: %08x\n", - GetLastError()); - crl = pCertEnumCRLsInStore(store, crl); - ok(!crl, "Expected only one CRL\n"); - } + crl = CertEnumCRLsInStore(store, NULL); + ok(crl != NULL, "CertEnumCRLsInStore failed: %08x\n", + GetLastError()); + crl = CertEnumCRLsInStore(store, crl); + ok(!crl, "Expected only one CRL\n"); + CertCloseStore(store, 0); } } @@ -2150,15 +2081,9 @@ static void testCertRegisterSystemStore(void) const CERT_CONTEXT *cert, *cert2; unsigned int i;
- if (!pCertRegisterSystemStore || !pCertUnregisterSystemStore) - { - win_skip("CertRegisterSystemStore() or CertUnregisterSystemStore() is not available\n"); - return; - } - for (i = 0; i < sizeof(reg_system_store_test_data) / sizeof(reg_system_store_test_data[0]); i++) { cur_flag = reg_system_store_test_data[i].cert_store; - ret = pCertRegisterSystemStore(WineTestW, cur_flag, NULL, NULL); + ret = CertRegisterSystemStore(WineTestW, cur_flag, NULL, NULL); if (!ret) { err = GetLastError(); @@ -2200,7 +2125,7 @@ static void testCertRegisterSystemStore(void) ret = CertCloseStore(hstore, 0); ok (ret, "CertCloseStore failed at %08x, last error %x\n", cur_flag, GetLastError());
- ret = pCertUnregisterSystemStore(WineTestW, cur_flag ); + ret = CertUnregisterSystemStore(WineTestW, cur_flag ); todo_wine_if (reg_system_store_test_data[i].todo) ok( ret == reg_system_store_test_data[i].expected, "Unregistering failed at %08x, last error %d\n", cur_flag, GetLastError()); @@ -2228,23 +2153,17 @@ static void testCertEnumSystemStore(void) BOOL ret; struct EnumSystemStoreInfo info = { FALSE, 0 };
- if (!pCertEnumSystemStore) - { - win_skip("CertEnumSystemStore() is not available\n"); - return; - } - SetLastError(0xdeadbeef); - ret = pCertEnumSystemStore(0, NULL, NULL, NULL); + ret = CertEnumSystemStore(0, NULL, NULL, NULL); ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError()); /* Crashes - ret = pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, NULL, + ret = CertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, NULL, NULL); */
SetLastError(0xdeadbeef); - ret = pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, &info, + ret = CertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, &info, enumSystemStoreCB); /* Callback returning FALSE stops enumeration */ ok(!ret, "Expected CertEnumSystemStore to stop\n"); @@ -2253,7 +2172,7 @@ static void testCertEnumSystemStore(void)
info.goOn = TRUE; info.storeCount = 0; - ret = pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, &info, + ret = CertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, &info, enumSystemStoreCB); ok(ret, "CertEnumSystemStore failed: %08x\n", GetLastError()); /* There should always be at least My, Root, and CA stores */ @@ -2268,58 +2187,52 @@ static void testStoreProperty(void) DWORD propID, size = 0, state; CRYPT_DATA_BLOB blob;
- if (!pCertGetStoreProperty || !pCertSetStoreProperty) - { - win_skip("CertGet/SetStoreProperty() is not available\n"); - return; - } - /* Crash - ret = pCertGetStoreProperty(NULL, 0, NULL, NULL); - ret = pCertGetStoreProperty(NULL, 0, NULL, &size); - ret = pCertGetStoreProperty(store, 0, NULL, NULL); + ret = CertGetStoreProperty(NULL, 0, NULL, NULL); + ret = CertGetStoreProperty(NULL, 0, NULL, &size); + ret = CertGetStoreProperty(store, 0, NULL, NULL); */
store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL); /* Check a missing prop ID */ SetLastError(0xdeadbeef); - ret = pCertGetStoreProperty(store, 0, NULL, &size); + ret = CertGetStoreProperty(store, 0, NULL, &size); ok(!ret && GetLastError() == CRYPT_E_NOT_FOUND, "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError()); /* Contrary to MSDN, CERT_ACCESS_STATE_PROP_ID is supported for stores.. */ size = sizeof(state); - ret = pCertGetStoreProperty(store, CERT_ACCESS_STATE_PROP_ID, &state, &size); + ret = CertGetStoreProperty(store, CERT_ACCESS_STATE_PROP_ID, &state, &size); ok(ret, "CertGetStoreProperty failed for CERT_ACCESS_STATE_PROP_ID: %08x\n", GetLastError()); ok(!state, "Expected a non-persisted store\n"); /* and CERT_STORE_LOCALIZED_NAME_PROP_ID isn't supported by default. */ size = 0; - ret = pCertGetStoreProperty(store, CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, + ret = CertGetStoreProperty(store, CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size); ok(!ret && GetLastError() == CRYPT_E_NOT_FOUND, "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError()); /* Delete an arbitrary property on a store */ - ret = pCertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, NULL); + ret = CertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, NULL); ok(ret, "CertSetStoreProperty failed: %08x\n", GetLastError()); /* Set an arbitrary property on a store */ blob.pbData = (LPBYTE)&state; blob.cbData = sizeof(state); - ret = pCertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, &blob); + ret = CertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, &blob); ok(ret, "CertSetStoreProperty failed: %08x\n", GetLastError()); /* Get an arbitrary property that's been set */ - ret = pCertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, NULL, &size); + ret = CertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, NULL, &size); ok(ret, "CertGetStoreProperty failed: %08x\n", GetLastError()); ok(size == sizeof(state), "Unexpected data size %d\n", size); - ret = pCertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, &propID, &size); + ret = CertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, &propID, &size); ok(ret, "CertGetStoreProperty failed: %08x\n", GetLastError()); ok(propID == state, "CertGetStoreProperty got the wrong value\n"); /* Delete it again */ - ret = pCertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, NULL); + ret = CertSetStoreProperty(store, CERT_FIRST_USER_PROP_ID, 0, NULL); ok(ret, "CertSetStoreProperty failed: %08x\n", GetLastError()); /* And check that it's missing */ SetLastError(0xdeadbeef); - ret = pCertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, NULL, &size); + ret = CertGetStoreProperty(store, CERT_FIRST_USER_PROP_ID, NULL, &size); ok(!ret && GetLastError() == CRYPT_E_NOT_FOUND, "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError()); CertCloseStore(store, 0); @@ -2327,13 +2240,13 @@ static void testStoreProperty(void) /* Recheck on the My store.. */ store = CertOpenSystemStoreW(0, MyW); size = sizeof(state); - ret = pCertGetStoreProperty(store, CERT_ACCESS_STATE_PROP_ID, &state, &size); + ret = CertGetStoreProperty(store, CERT_ACCESS_STATE_PROP_ID, &state, &size); ok(ret, "CertGetStoreProperty failed for CERT_ACCESS_STATE_PROP_ID: %08x\n", GetLastError()); ok(state, "Expected a persisted store\n"); SetLastError(0xdeadbeef); size = 0; - ret = pCertGetStoreProperty(store, CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, + ret = CertGetStoreProperty(store, CERT_STORE_LOCALIZED_NAME_PROP_ID, NULL, &size); ok(!ret && GetLastError() == CRYPT_E_NOT_FOUND, "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError()); @@ -2579,32 +2492,26 @@ static void testAddCertificateLink(void) WCHAR filename1[MAX_PATH], filename2[MAX_PATH]; HANDLE file;
- if (!pCertAddCertificateLinkToStore) - { - win_skip("CertAddCertificateLinkToStore not found\n"); - return; - } - if (0) { /* Crashes, i.e. the store is dereferenced without checking. */ - ret = pCertAddCertificateLinkToStore(NULL, NULL, 0, NULL); + ret = CertAddCertificateLinkToStore(NULL, NULL, 0, NULL); }
/* Adding a certificate link to a store requires a valid add disposition */ store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL); SetLastError(0xdeadbeef); - ret = pCertAddCertificateLinkToStore(store1, NULL, 0, NULL); + ret = CertAddCertificateLinkToStore(store1, NULL, 0, NULL); ok(!ret && GetLastError() == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", GetLastError()); source = CertCreateCertificateContext(X509_ASN_ENCODING, bigCert, sizeof(bigCert)); SetLastError(0xdeadbeef); - ret = pCertAddCertificateLinkToStore(store1, source, 0, NULL); + ret = CertAddCertificateLinkToStore(store1, source, 0, NULL); ok(!ret && GetLastError() == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", GetLastError()); - ret = pCertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, NULL); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (0) @@ -2612,14 +2519,14 @@ static void testAddCertificateLink(void) /* Crashes, i.e. the source certificate is dereferenced without * checking when a valid add disposition is given. */ - ret = pCertAddCertificateLinkToStore(store1, NULL, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store1, NULL, CERT_STORE_ADD_ALWAYS, NULL); } CertCloseStore(store1, 0);
store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL); - ret = pCertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, &linked); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (ret) @@ -2695,7 +2602,7 @@ static void testAddCertificateLink(void) /* Test adding a link to a memory store. */ store2 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL); - ret = pCertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, &linked); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (ret) @@ -2757,7 +2664,7 @@ static void testAddCertificateLink(void) ok(store2 != NULL, "CertOpenStore failed: %08x\n", GetLastError()); CloseHandle(file); /* Test adding a link to a file store. */ - ret = pCertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, &linked); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (ret) @@ -2799,7 +2706,7 @@ static void testAddCertificateLink(void) source = CertCreateCertificateContext(X509_ASN_ENCODING, bigCert, sizeof(bigCert)); SetLastError(0xdeadbeef); - ret = pCertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store1, source, CERT_STORE_ADD_ALWAYS, &linked); ok(!ret && GetLastError() == E_INVALIDARG, "expected E_INVALIDARG, got %08x\n", GetLastError()); @@ -2826,13 +2733,13 @@ static void testAddCertificateLink(void) ok(store2 != NULL, "CertOpenStore failed: %08x\n", GetLastError()); CloseHandle(file);
- ret = pCertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, &linked); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (ret) { ok(linked->hCertStore == store2, "unexpected store\n"); - ret = pCertControlStore(store2, 0, CERT_STORE_CTRL_COMMIT, NULL); + ret = CertControlStore(store2, 0, CERT_STORE_CTRL_COMMIT, NULL); ok(ret, "CertControlStore failed: %d\n", ret); compareStore(store2, "file store -> system store", serializedStoreWithCertAndHash, @@ -2849,7 +2756,7 @@ static void testAddCertificateLink(void) store2 = CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY, 0, 0, CERT_SYSTEM_STORE_CURRENT_USER, WineTestW); ok(store2 != NULL, "CertOpenStore failed: %08x\n", GetLastError()); - ret = pCertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, + ret = CertAddCertificateLinkToStore(store2, source, CERT_STORE_ADD_ALWAYS, &linked); ok(ret, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError()); if (ret) @@ -2884,7 +2791,7 @@ static DWORD countCRLsInStore(HCERTSTORE store) DWORD crls = 0;
do { - crl = pCertEnumCRLsInStore(store, crl); + crl = CertEnumCRLsInStore(store, crl); if (crl) crls++; } while (crl); @@ -3112,11 +3019,8 @@ static void test_I_UpdateStore(void) ok(ret, "I_CertUpdateStore failed: %08x\n", GetLastError()); certs = countCertsInStore(store1); ok(certs == 1, "Expected 1 cert, got %d\n", certs); - if (pCertEnumCRLsInStore) - { - certs = countCRLsInStore(store1); - ok(certs == 1, "Expected 1 CRL, got %d\n", certs); - } + certs = countCRLsInStore(store1); + ok(certs == 1, "Expected 1 CRL, got %d\n", certs);
CertDeleteCertificateFromStore(cert); /* If a context is deleted from store2, I_CertUpdateStore deletes it @@ -3133,19 +3037,6 @@ static void test_I_UpdateStore(void)
START_TEST(store) { - HMODULE hdll; - - hdll = GetModuleHandleA("Crypt32.dll"); - pCertControlStore = (void*)GetProcAddress(hdll, "CertControlStore"); - pCertEnumCRLsInStore = (void*)GetProcAddress(hdll, "CertEnumCRLsInStore"); - pCertEnumSystemStore = (void*)GetProcAddress(hdll, "CertEnumSystemStore"); - pCertGetStoreProperty = (void*)GetProcAddress(hdll, "CertGetStoreProperty"); - pCertRemoveStoreFromCollection = (void*)GetProcAddress(hdll, "CertRemoveStoreFromCollection"); - pCertSetStoreProperty = (void*)GetProcAddress(hdll, "CertSetStoreProperty"); - pCertAddCertificateLinkToStore = (void*)GetProcAddress(hdll, "CertAddCertificateLinkToStore"); - pCertRegisterSystemStore = (void*)GetProcAddress(hdll, "CertRegisterSystemStore"); - pCertUnregisterSystemStore = (void*)GetProcAddress(hdll, "CertUnregisterSystemStore"); - /* various combinations of CertOpenStore */ testMemStore(); testCollectionStore(); diff --git a/modules/rostests/winetests/crypt32/str.c b/modules/rostests/winetests/crypt32/str.c index 56480859f8..5245885503 100644 --- a/modules/rostests/winetests/crypt32/str.c +++ b/modules/rostests/winetests/crypt32/str.c @@ -17,8 +17,14 @@ * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ +#include <stdio.h> +#include <stdarg.h> +#include <windef.h> +#include <winbase.h> +#include <winerror.h> +#include <wincrypt.h>
-#include "precomp.h" +#include "wine/test.h"
typedef struct _CertRDNAttrEncoding { LPCSTR pszObjId;
-
Amine Khaldi