1 /*
2  * Miscellaneous crypt32 tests
3  *
4  * Copyright 2005 Juan Lang
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <windef.h>
24 #include <winbase.h>
25 #include <winerror.h>
26 #include <wincrypt.h>
27 #include <winreg.h>
28 
29 #include "wine/test.h"
30 
31 static HMODULE hCrypt;
32 
test_findAttribute(void)33 static void test_findAttribute(void)
34 {
35     PCRYPT_ATTRIBUTE ret;
36     BYTE blobbin[] = {0x02,0x01,0x01};
37     static CHAR oid[] = "1.2.3";
38     CRYPT_ATTR_BLOB blobs[] = { { sizeof blobbin, blobbin }, };
39     CRYPT_ATTRIBUTE attr = { oid, ARRAY_SIZE(blobs), blobs };
40 
41     /* returns NULL, last error not set */
42     SetLastError(0xdeadbeef);
43     ret = CertFindAttribute(NULL, 0, NULL);
44     ok(ret == NULL, "Expected failure\n");
45     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
46      GetLastError());
47     if (0)
48     {
49         /* crashes */
50         CertFindAttribute(NULL, 1, NULL);
51         /* returns NULL, last error is ERROR_INVALID_PARAMETER
52          * crashes on Vista
53          */
54         SetLastError(0xdeadbeef);
55         ret = CertFindAttribute(NULL, 1, &attr);
56         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
57          "Expected ERROR_INVALID_PARAMETER, got %d (%08x)\n", GetLastError(),
58          GetLastError());
59     }
60     /* returns NULL, last error not set */
61     SetLastError(0xdeadbeef);
62     ret = CertFindAttribute("bogus", 1, &attr);
63     ok(ret == NULL, "Expected failure\n");
64     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
65      GetLastError());
66     /* returns NULL, last error not set */
67     SetLastError(0xdeadbeef);
68     ret = CertFindAttribute("1.2.4", 1, &attr);
69     ok(ret == NULL, "Expected failure\n");
70     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
71      GetLastError());
72     /* succeeds, last error not set */
73     SetLastError(0xdeadbeef);
74     ret = CertFindAttribute("1.2.3", 1, &attr);
75     ok(ret != NULL, "CertFindAttribute failed: %08x\n", GetLastError());
76 }
77 
test_findExtension(void)78 static void test_findExtension(void)
79 {
80     PCERT_EXTENSION ret;
81     static CHAR oid[] = "1.2.3";
82     BYTE blobbin[] = {0x02,0x01,0x01};
83     CERT_EXTENSION ext = { oid, TRUE, { sizeof blobbin, blobbin } };
84 
85     /* returns NULL, last error not set */
86     SetLastError(0xdeadbeef);
87     ret = CertFindExtension(NULL, 0, NULL);
88     ok(ret == NULL, "Expected failure\n");
89     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
90      GetLastError());
91     if (0)
92     {
93         /* crashes */
94         SetLastError(0xdeadbeef);
95         CertFindExtension(NULL, 1, NULL);
96         /* returns NULL, last error is ERROR_INVALID_PARAMETER
97          * crashes on Vista
98          */
99         SetLastError(0xdeadbeef);
100         ret = CertFindExtension(NULL, 1, &ext);
101         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
102          "Expected ERROR_INVALID_PARAMETER, got %d (%08x)\n", GetLastError(),
103          GetLastError());
104     }
105     /* returns NULL, last error not set */
106     SetLastError(0xdeadbeef);
107     ret = CertFindExtension("bogus", 1, &ext);
108     ok(ret == NULL, "Expected failure\n");
109     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
110      GetLastError());
111     /* returns NULL, last error not set */
112     SetLastError(0xdeadbeef);
113     ret = CertFindExtension("1.2.4", 1, &ext);
114     ok(ret == NULL, "Expected failure\n");
115     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
116      GetLastError());
117     /* succeeds, last error not set */
118     SetLastError(0xdeadbeef);
119     ret = CertFindExtension("1.2.3", 1, &ext);
120     ok(ret != NULL, "CertFindExtension failed: %08x\n", GetLastError());
121 }
122 
test_findRDNAttr(void)123 static void test_findRDNAttr(void)
124 {
125     PCERT_RDN_ATTR ret;
126     static CHAR oid[] = "1.2.3";
127     BYTE bin[] = { 0x16,0x09,'J','u','a','n',' ','L','a','n','g' };
128     CERT_RDN_ATTR attrs[] = {
129      { oid, CERT_RDN_IA5_STRING, { sizeof bin, bin } },
130     };
131     CERT_RDN rdns[] = { { ARRAY_SIZE(attrs), attrs } };
132     CERT_NAME_INFO nameInfo = { ARRAY_SIZE(rdns), rdns };
133 
134     if (0)
135     {
136         /* crashes */
137         SetLastError(0xdeadbeef);
138         CertFindRDNAttr(NULL, NULL);
139         /* returns NULL, last error is ERROR_INVALID_PARAMETER
140          * crashes on Vista
141          */
142         SetLastError(0xdeadbeef);
143         ret = CertFindRDNAttr(NULL, &nameInfo);
144         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
145          "Expected ERROR_INVALID_PARAMETER, got %d (%08x)\n", GetLastError(),
146          GetLastError());
147     }
148     /* returns NULL, last error not set */
149     SetLastError(0xdeadbeef);
150     ret = CertFindRDNAttr("bogus", &nameInfo);
151     ok(ret == NULL, "Expected failure\n");
152     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
153      GetLastError());
154     /* returns NULL, last error not set */
155     SetLastError(0xdeadbeef);
156     ret = CertFindRDNAttr("1.2.4", &nameInfo);
157     ok(ret == NULL, "Expected failure\n");
158     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08x\n",
159      GetLastError());
160     /* succeeds, last error not set */
161     SetLastError(0xdeadbeef);
162     ret = CertFindRDNAttr("1.2.3", &nameInfo);
163     ok(ret != NULL, "CertFindRDNAttr failed: %08x\n", GetLastError());
164 }
165 
test_verifyTimeValidity(void)166 static void test_verifyTimeValidity(void)
167 {
168     SYSTEMTIME sysTime;
169     FILETIME fileTime;
170     CERT_INFO info = { 0 };
171     LONG ret;
172 
173     GetSystemTime(&sysTime);
174     SystemTimeToFileTime(&sysTime, &fileTime);
175     /* crashes
176     ret = CertVerifyTimeValidity(NULL, NULL);
177     ret = CertVerifyTimeValidity(&fileTime, NULL);
178      */
179     /* Check with 0 NotBefore and NotAfter */
180     ret = CertVerifyTimeValidity(&fileTime, &info);
181     ok(ret == 1, "Expected 1, got %d\n", ret);
182     info.NotAfter = fileTime;
183     /* Check with NotAfter equal to comparison time */
184     ret = CertVerifyTimeValidity(&fileTime, &info);
185     ok(ret == 0, "Expected 0, got %d\n", ret);
186     /* Check with NotBefore after comparison time */
187     info.NotBefore = fileTime;
188     info.NotBefore.dwLowDateTime += 5000;
189     ret = CertVerifyTimeValidity(&fileTime, &info);
190     ok(ret == -1, "Expected -1, got %d\n", ret);
191 }
192 
test_cryptAllocate(void)193 static void test_cryptAllocate(void)
194 {
195     LPVOID buf;
196 
197     buf = CryptMemAlloc(0);
198     ok(buf != NULL, "CryptMemAlloc failed: %08x\n", GetLastError());
199     CryptMemFree(buf);
200     /* CryptMemRealloc(NULL, 0) fails pre-Vista */
201     buf = CryptMemAlloc(0);
202     buf = CryptMemRealloc(buf, 1);
203     ok(buf != NULL, "CryptMemRealloc failed: %08x\n", GetLastError());
204     CryptMemFree(buf);
205 }
206 
207 
test_cryptTls(void)208 static void test_cryptTls(void)
209 {
210     DWORD  (WINAPI *pI_CryptAllocTls)(void);
211     LPVOID (WINAPI *pI_CryptDetachTls)(DWORD dwTlsIndex);
212     LPVOID (WINAPI *pI_CryptGetTls)(DWORD dwTlsIndex);
213     BOOL   (WINAPI *pI_CryptSetTls)(DWORD dwTlsIndex, LPVOID lpTlsValue);
214     BOOL   (WINAPI *pI_CryptFreeTls)(DWORD dwTlsIndex, DWORD unknown);
215     DWORD index;
216     BOOL ret;
217 
218     pI_CryptAllocTls = (void *)GetProcAddress(hCrypt, "I_CryptAllocTls");
219     pI_CryptDetachTls = (void *)GetProcAddress(hCrypt, "I_CryptDetachTls");
220     pI_CryptGetTls = (void *)GetProcAddress(hCrypt, "I_CryptGetTls");
221     pI_CryptSetTls = (void *)GetProcAddress(hCrypt, "I_CryptSetTls");
222     pI_CryptFreeTls = (void *)GetProcAddress(hCrypt, "I_CryptFreeTls");
223 
224     /* One normal pass */
225     index = pI_CryptAllocTls();
226     ok(index, "I_CryptAllocTls failed: %08x\n", GetLastError());
227     if (index)
228     {
229         LPVOID ptr;
230 
231         ptr = pI_CryptGetTls(index);
232         ok(!ptr, "Expected NULL\n");
233         ret = pI_CryptSetTls(index, (LPVOID)0xdeadbeef);
234         ok(ret, "I_CryptSetTls failed: %08x\n", GetLastError());
235         ptr = pI_CryptGetTls(index);
236         ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
237         /* This crashes
238         ret = pI_CryptFreeTls(index, 1);
239          */
240         ret = pI_CryptFreeTls(index, 0);
241         ok(ret, "I_CryptFreeTls failed: %08x\n", GetLastError());
242         ret = pI_CryptFreeTls(index, 0);
243         ok(!ret, "I_CryptFreeTls succeeded\n");
244         ok(GetLastError() == E_INVALIDARG,
245          "Expected E_INVALIDARG, got %08x\n", GetLastError());
246     }
247     /* Similar pass, check I_CryptDetachTls */
248     index = pI_CryptAllocTls();
249     ok(index, "I_CryptAllocTls failed: %08x\n", GetLastError());
250     if (index)
251     {
252         LPVOID ptr;
253 
254         ptr = pI_CryptGetTls(index);
255         ok(!ptr, "Expected NULL\n");
256         ret = pI_CryptSetTls(index, (LPVOID)0xdeadbeef);
257         ok(ret, "I_CryptSetTls failed: %08x\n", GetLastError());
258         ptr = pI_CryptGetTls(index);
259         ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
260         ptr = pI_CryptDetachTls(index);
261         ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
262         ptr = pI_CryptGetTls(index);
263         ok(!ptr, "Expected NULL\n");
264     }
265 }
266 
test_readTrustedPublisherDWORD(void)267 static void test_readTrustedPublisherDWORD(void)
268 {
269 
270     BOOL (WINAPI *pReadDWORD)(LPCWSTR, DWORD *);
271 
272     pReadDWORD = (void *)GetProcAddress(hCrypt, "I_CryptReadTrustedPublisherDWORDValueFromRegistry");
273     if (pReadDWORD)
274     {
275         static const WCHAR safer[] = {
276          'S','o','f','t','w','a','r','e','\\',
277          'P','o','l','i','c','i','e','s','\\',
278          'M','i','c','r','o','s','o','f','t','\\','S','y','s','t','e','m',
279          'C','e','r','t','i','f','i','c','a','t','e','s','\\',
280          'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',
281          '\\','S','a','f','e','r',0 };
282         static const WCHAR authenticodeFlags[] = { 'A','u','t','h','e','n',
283          't','i','c','o','d','e','F','l','a','g','s',0 };
284         BOOL ret, exists = FALSE;
285         DWORD size, readFlags = 0, returnedFlags;
286         HKEY key;
287         LONG rc;
288 
289         rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, safer, &key);
290         if (rc == ERROR_SUCCESS)
291         {
292             size = sizeof(readFlags);
293             rc = RegQueryValueExW(key, authenticodeFlags, NULL, NULL,
294              (LPBYTE)&readFlags, &size);
295             if (rc == ERROR_SUCCESS)
296                 exists = TRUE;
297         }
298         returnedFlags = 0xdeadbeef;
299         ret = pReadDWORD(authenticodeFlags, &returnedFlags);
300         ok(ret == exists, "Unexpected return value\n");
301         ok(readFlags == returnedFlags,
302          "Expected flags %08x, got %08x\n", readFlags, returnedFlags);
303     }
304 }
305 
test_getDefaultCryptProv(void)306 static void test_getDefaultCryptProv(void)
307 {
308 #define ALG(id) id, #id
309     static const struct
310     {
311         ALG_ID algid;
312         const char *name;
313         BOOL optional;
314     } test_prov[] =
315     {
316         { ALG(CALG_MD2), TRUE },
317         { ALG(CALG_MD4), TRUE },
318         { ALG(CALG_MD5), TRUE },
319         { ALG(CALG_SHA), TRUE },
320         { ALG(CALG_RSA_SIGN) },
321         { ALG(CALG_DSS_SIGN) },
322         { ALG(CALG_NO_SIGN) },
323         { ALG(CALG_ECDSA), TRUE },
324         { ALG(CALG_ECDH), TRUE },
325         { ALG(CALG_RSA_KEYX) },
326         { ALG(CALG_RSA_KEYX) },
327     };
328 #undef ALG
329     HCRYPTPROV (WINAPI *pI_CryptGetDefaultCryptProv)(DWORD w);
330     HCRYPTPROV prov;
331     BOOL ret;
332     DWORD size, i;
333     LPSTR name;
334 
335     pI_CryptGetDefaultCryptProv = (void *)GetProcAddress(hCrypt, "I_CryptGetDefaultCryptProv");
336     if (!pI_CryptGetDefaultCryptProv) return;
337 
338     prov = pI_CryptGetDefaultCryptProv(0xdeadbeef);
339     ok(prov == 0 && GetLastError() == E_INVALIDARG,
340      "Expected E_INVALIDARG, got %08x\n", GetLastError());
341     prov = pI_CryptGetDefaultCryptProv(PROV_RSA_FULL);
342     ok(prov == 0 && GetLastError() == E_INVALIDARG,
343      "Expected E_INVALIDARG, got %08x\n", GetLastError());
344     prov = pI_CryptGetDefaultCryptProv(1);
345     ok(prov == 0 && GetLastError() == E_INVALIDARG,
346      "Expected E_INVALIDARG, got %08x\n", GetLastError());
347     prov = pI_CryptGetDefaultCryptProv(0);
348     ok(prov != 0, "I_CryptGetDefaultCryptProv failed: %08x\n", GetLastError());
349     CryptReleaseContext(prov, 0);
350 
351     for (i = 0; i < ARRAY_SIZE(test_prov); i++)
352     {
353         if (winetest_debug > 1)
354             trace("%u: algid %#x (%s): class %u, type %u, sid %u\n", i, test_prov[i].algid, test_prov[i].name,
355                   GET_ALG_CLASS(test_prov[i].algid) >> 13, GET_ALG_TYPE(test_prov[i].algid) >> 9, GET_ALG_SID(test_prov[i].algid));
356 
357         prov = pI_CryptGetDefaultCryptProv(test_prov[i].algid);
358         if (!prov)
359         {
360 todo_wine_if(test_prov[i].algid == CALG_DSS_SIGN || test_prov[i].algid == CALG_NO_SIGN)
361             ok(test_prov[i].optional, "%u: I_CryptGetDefaultCryptProv(%#x) failed\n", i, test_prov[i].algid);
362             continue;
363         }
364 
365         ret = CryptGetProvParam(prov, PP_NAME, NULL, &size, 0);
366         if (ret) /* some provders don't support PP_NAME */
367         {
368             name = CryptMemAlloc(size);
369             ret = CryptGetProvParam(prov, PP_NAME, (BYTE *)name, &size, 0);
370             ok(ret, "%u: CryptGetProvParam failed %#x\n", i, GetLastError());
371             if (winetest_debug > 1)
372                 trace("%u: algid %#x, name %s\n", i, test_prov[i].algid, name);
373             CryptMemFree(name);
374         }
375 
376         CryptReleaseContext(prov, 0);
377     }
378 }
379 
test_CryptInstallOssGlobal(void)380 static void test_CryptInstallOssGlobal(void)
381 {
382     int (WINAPI *pI_CryptInstallOssGlobal)(DWORD,DWORD,DWORD);
383     int ret,i;
384 
385     pI_CryptInstallOssGlobal = (void *)GetProcAddress(hCrypt,"I_CryptInstallOssGlobal");
386     /* passing in some random values to I_CryptInstallOssGlobal, it always returns 9 the first time, then 10, 11 etc.*/
387     for(i=0;i<30;i++)
388     {
389       ret =  pI_CryptInstallOssGlobal(rand(),rand(),rand());
390       ok((9+i) == ret ||
391          ret == 0, /* Vista */
392          "Expected %d or 0, got %d\n",(9+i),ret);
393     }
394 }
395 
396 static const BYTE encodedInt[] = { 0x02,0x01,0x01 };
397 static const WCHAR encodedIntStr[] = { '0','2',' ','0','1',' ','0','1',0 };
398 static const BYTE encodedBigInt[] = { 0x02,0x1f,0x01,0x02,0x03,0x04,0x05,0x06,
399  0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,
400  0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f };
401 static const WCHAR encodedBigIntStr[] = { '0','2',' ','1','f',' ','0','1',' ',
402  '0','2',' ','0','3',' ','0','4',' ','0','5',' ','0','6',' ','0','7',' ','0',
403  '8',' ','0','9',' ','0','a',' ','0','b',' ','0','c',' ','0','d',' ','0','e',
404  ' ','0','f',' ','1','0',' ','1','1',' ','1','2',' ','1','3',' ','1','4',' ',
405  '1','5',' ','1','6',' ','1','7',' ','1','8',' ','1','9',' ','1','a',' ','1',
406  'b',' ','1','c',' ','1','d',' ','1','e',' ','1','f',0 };
407 
test_format_object(void)408 static void test_format_object(void)
409 {
410     BOOL (WINAPI *pCryptFormatObject)(DWORD dwEncoding, DWORD dwFormatType,
411         DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType,
412         const BYTE *pbEncoded, DWORD dwEncoded, void *pbFormat,
413         DWORD *pcbFormat);
414     BOOL ret;
415     DWORD size;
416     LPWSTR str;
417 
418     pCryptFormatObject = (void *)GetProcAddress(hCrypt, "CryptFormatObject");
419     if (!pCryptFormatObject)
420     {
421         skip("No CryptFormatObject\n");
422         return;
423     }
424     /* Crash */
425     if (0)
426     {
427         pCryptFormatObject(0, 0, 0, NULL, NULL, NULL, 0, NULL, NULL);
428     }
429     /* When called with any but the default encoding, it fails to find a
430      * formatting function.
431      */
432     SetLastError(0xdeadbeef);
433     ret = pCryptFormatObject(0, 0, 0, NULL, NULL, NULL, 0, NULL, &size);
434     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
435      "expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
436     /* When called with the default encoding type for any undefined struct type
437      * (including none), it succeeds:  the default encoding is a hex string
438      * encoding.
439      */
440     SetLastError(0xdeadbeef);
441     ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL, NULL, 0,
442      NULL, &size);
443     ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
444     if (ret)
445     {
446         if (size == 0 && GetLastError() == ERROR_FILE_NOT_FOUND)
447         {
448             win_skip("CryptFormatObject has no default implementation\n");
449             return;
450         }
451         ok(size == sizeof(WCHAR), "unexpected size %d\n", size);
452         str = HeapAlloc(GetProcessHeap(), 0, size);
453         SetLastError(0xdeadbeef);
454         size = 0;
455         ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL, NULL, 0,
456          str, &size);
457         ok(!ret && GetLastError() == ERROR_MORE_DATA,
458          "expected ERROR_MORE_DATA, got %d\n", GetLastError());
459         size = sizeof(WCHAR);
460         ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL, NULL, 0,
461          str, &size);
462         ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
463         ok(!str[0], "expected empty string\n");
464         HeapFree(GetProcessHeap(), 0, str);
465     }
466     ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL, encodedInt,
467      sizeof(encodedInt), NULL, &size);
468     ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
469     if (ret)
470     {
471         str = HeapAlloc(GetProcessHeap(), 0, size);
472         ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL,
473          encodedInt, sizeof(encodedInt), str, &size);
474         ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
475         ok(!lstrcmpW(str, encodedIntStr), "unexpected format string\n");
476         HeapFree(GetProcessHeap(), 0, str);
477     }
478     ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL,
479      encodedBigInt, sizeof(encodedBigInt), NULL, &size);
480     ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
481     if (ret)
482     {
483         str = HeapAlloc(GetProcessHeap(), 0, size);
484         ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL, NULL,
485          encodedBigInt, sizeof(encodedBigInt), str, &size);
486         ok(ret, "CryptFormatObject failed: %d\n", GetLastError());
487         ok(!lstrcmpiW(str, encodedBigIntStr), "unexpected format string\n");
488         HeapFree(GetProcessHeap(), 0, str);
489     }
490     /* When called with the default encoding type for any undefined struct
491      * type but CRYPT_FORMAT_STR_NO_HEX specified, it fails to find a
492      * formatting function.
493      */
494     SetLastError(0xdeadbeef);
495     ret = pCryptFormatObject(X509_ASN_ENCODING, 0, CRYPT_FORMAT_STR_NO_HEX,
496      NULL, NULL, NULL, 0, NULL, &size);
497     ok(!ret, "CryptFormatObject succeeded\n");
498     ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
499      GetLastError() == 0xdeadbeef, /* Vista, W2K8 */
500      "expected ERROR_FILE_NOT_FOUND or no change, got %d\n", GetLastError());
501     /* When called to format an AUTHORITY_KEY_ID2_INFO, it fails when no
502      * data are given.
503      */
504     SetLastError(0xdeadbeef);
505     ret = pCryptFormatObject(X509_ASN_ENCODING, 0, 0, NULL,
506      szOID_AUTHORITY_KEY_IDENTIFIER2, NULL, 0, NULL, &size);
507     ok(!ret && GetLastError() == E_INVALIDARG,
508      "expected E_INVALIDARG, got %d\n", GetLastError());
509 }
510 
START_TEST(main)511 START_TEST(main)
512 {
513     hCrypt = GetModuleHandleA("crypt32.dll");
514 
515     test_findAttribute();
516     test_findExtension();
517     test_findRDNAttr();
518     test_verifyTimeValidity();
519     test_cryptAllocate();
520     test_cryptTls();
521     test_readTrustedPublisherDWORD();
522     test_getDefaultCryptProv();
523     test_CryptInstallOssGlobal();
524     test_format_object();
525 }
526