9 Mar
2018
9 Mar
'18
noon
https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d03ac84f4f0584b5db9ae…
commit d03ac84f4f0584b5db9aedd6bb0af55136da84a2
Author: Amine Khaldi <amine.khaldi(a)reactos.org>
AuthorDate: Fri Mar 9 13:00:36 2018 +0100
Commit: Amine Khaldi <amine.khaldi(a)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;
2484
days inactive
2484
days old
0 comments
1 participants
participants (1)
-
Amine Khaldi