1 /*
2  * Unit test suite for crypt32.dll's OID support functions.
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 "precomp.h"
22 
23 static BOOL (WINAPI *pCryptEnumOIDInfo)(DWORD,DWORD,void*,PFN_CRYPT_ENUM_OID_INFO);
24 
25 
26 struct OIDToAlgID
27 {
28     LPCSTR oid;
29     LPCSTR altOid;
30     DWORD algID;
31 };
32 
33 static const struct OIDToAlgID oidToAlgID[] = {
34  { szOID_RSA_RSA, NULL, CALG_RSA_KEYX },
35  { szOID_RSA_MD2RSA, NULL, CALG_MD2 },
36  { szOID_RSA_MD4RSA, NULL, CALG_MD4 },
37  { szOID_RSA_MD5RSA, NULL, CALG_MD5 },
38  { szOID_RSA_SHA1RSA, NULL, CALG_SHA },
39  { szOID_RSA_DH, NULL, CALG_DH_SF },
40  { szOID_RSA_SMIMEalgESDH, NULL, CALG_DH_EPHEM },
41  { szOID_RSA_SMIMEalgCMS3DESwrap, NULL, CALG_3DES },
42  { szOID_RSA_SMIMEalgCMSRC2wrap, NULL, CALG_RC2 },
43  { szOID_RSA_MD2, NULL, CALG_MD2 },
44  { szOID_RSA_MD4, NULL, CALG_MD4 },
45  { szOID_RSA_MD5, NULL, CALG_MD5 },
46  { szOID_RSA_RC2CBC, NULL, CALG_RC2 },
47  { szOID_RSA_RC4, NULL, CALG_RC4 },
48  { szOID_RSA_DES_EDE3_CBC, NULL, CALG_3DES },
49  { szOID_ANSI_X942_DH, NULL, CALG_DH_SF },
50  { szOID_X957_DSA, NULL, CALG_DSS_SIGN },
51  { szOID_X957_SHA1DSA, NULL, CALG_SHA },
52  { szOID_OIWSEC_md4RSA, NULL, CALG_MD4 },
53  { szOID_OIWSEC_md5RSA, NULL, CALG_MD5 },
54  { szOID_OIWSEC_md4RSA2, NULL, CALG_MD4 },
55  { szOID_OIWSEC_desCBC, NULL, CALG_DES },
56  { szOID_OIWSEC_dsa, NULL, CALG_DSS_SIGN },
57  { szOID_OIWSEC_shaDSA, NULL, CALG_SHA },
58  { szOID_OIWSEC_shaRSA, NULL, CALG_SHA },
59  { szOID_OIWSEC_sha, NULL, CALG_SHA },
60  { szOID_OIWSEC_rsaXchg, NULL, CALG_RSA_KEYX },
61  { szOID_OIWSEC_sha1, NULL, CALG_SHA },
62  { szOID_OIWSEC_dsaSHA1, NULL, CALG_SHA },
63  { szOID_OIWSEC_sha1RSASign, NULL, CALG_SHA },
64  { szOID_OIWDIR_md2RSA, NULL, CALG_MD2 },
65  { szOID_INFOSEC_mosaicUpdatedSig, NULL, CALG_SHA },
66  { szOID_INFOSEC_mosaicKMandUpdSig, NULL, CALG_DSS_SIGN },
67 };
68 
69 static const struct OIDToAlgID algIDToOID[] = {
70  { szOID_RSA_RSA, NULL, CALG_RSA_KEYX },
71  { szOID_RSA_SMIMEalgESDH, NULL, CALG_DH_EPHEM },
72  { szOID_RSA_MD2, NULL, CALG_MD2 },
73  { szOID_RSA_MD4, NULL, CALG_MD4 },
74  { szOID_RSA_MD5, NULL, CALG_MD5 },
75  { szOID_RSA_RC2CBC, NULL, CALG_RC2 },
76  { szOID_RSA_RC4, NULL, CALG_RC4 },
77  { szOID_RSA_DES_EDE3_CBC, NULL, CALG_3DES },
78  { szOID_ANSI_X942_DH, NULL, CALG_DH_SF },
79  { szOID_X957_DSA, szOID_OIWSEC_dsa /* some Win98 */, CALG_DSS_SIGN },
80  { szOID_OIWSEC_desCBC, NULL, CALG_DES },
81  { szOID_OIWSEC_sha1, NULL, CALG_SHA },
82 };
83 
84 static const WCHAR bogusDll[] = { 'b','o','g','u','s','.','d','l','l',0 };
85 static const WCHAR bogus2Dll[] = { 'b','o','g','u','s','2','.','d','l','l',0 };
86 
87 static void testOIDToAlgID(void)
88 {
89     int i;
90     DWORD alg;
91 
92     /* Test with a bogus one */
93     alg = CertOIDToAlgId("1.2.3");
94     ok(!alg, "Expected failure, got %d\n", alg);
95 
96     for (i = 0; i < sizeof(oidToAlgID) / sizeof(oidToAlgID[0]); i++)
97     {
98         alg = CertOIDToAlgId(oidToAlgID[i].oid);
99         /* Not all Windows installations support all these, so make sure it's
100          * at least not the wrong one.
101          */
102         ok(alg == 0 || alg == oidToAlgID[i].algID,
103          "Expected %d, got %d\n", oidToAlgID[i].algID, alg);
104     }
105 }
106 
107 static void testAlgIDToOID(void)
108 {
109     int i;
110     LPCSTR oid;
111 
112     /* Test with a bogus one */
113     SetLastError(0xdeadbeef);
114     oid = CertAlgIdToOID(ALG_CLASS_SIGNATURE | ALG_TYPE_ANY | 80);
115     ok(!oid && GetLastError() == 0xdeadbeef,
116      "Didn't expect last error (%08x) to be set\n", GetLastError());
117     for (i = 0; i < sizeof(algIDToOID) / sizeof(algIDToOID[0]); i++)
118     {
119         oid = CertAlgIdToOID(algIDToOID[i].algID);
120         /* Allow failure, not every version of Windows supports every algo */
121         if (oid)
122         {
123             if (strcmp(oid, algIDToOID[i].oid))
124             {
125                 if (algIDToOID[i].altOid)
126                     ok(!strcmp(oid, algIDToOID[i].altOid),
127                      "Expected %s or %s, got %s\n", algIDToOID[i].oid,
128                      algIDToOID[i].altOid, oid);
129                 else
130                 {
131                     /* No need to rerun the test, we already know it failed. */
132                     ok(0, "Expected %s, got %s\n", algIDToOID[i].oid, oid);
133                 }
134             }
135             else
136             {
137                 /* No need to rerun the test, we already know it succeeded. */
138                 ok(1, "Expected %s, got %s\n", algIDToOID[i].oid, oid);
139             }
140         }
141     }
142 }
143 
144 static void test_oidFunctionSet(void)
145 {
146     HCRYPTOIDFUNCSET set1, set2;
147     BOOL ret;
148     LPWSTR buf = NULL;
149     DWORD size;
150 
151     /* This crashes
152     set = CryptInitOIDFunctionSet(NULL, 0);
153      */
154 
155     /* The name doesn't mean much */
156     set1 = CryptInitOIDFunctionSet("funky", 0);
157     ok(set1 != 0, "CryptInitOIDFunctionSet failed: %08x\n", GetLastError());
158     if (set1)
159     {
160         /* These crash
161         ret = CryptGetDefaultOIDDllList(NULL, 0, NULL, NULL);
162         ret = CryptGetDefaultOIDDllList(NULL, 0, NULL, &size);
163          */
164         size = 0;
165         ret = CryptGetDefaultOIDDllList(set1, 0, NULL, &size);
166         ok(ret, "CryptGetDefaultOIDDllList failed: %08x\n", GetLastError());
167         if (ret)
168         {
169             buf = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
170             if (buf)
171             {
172                 ret = CryptGetDefaultOIDDllList(set1, 0, buf, &size);
173                 ok(ret, "CryptGetDefaultOIDDllList failed: %08x\n",
174                  GetLastError());
175                 ok(!*buf, "Expected empty DLL list\n");
176                 HeapFree(GetProcessHeap(), 0, buf);
177             }
178         }
179     }
180 
181     /* MSDN says flags must be 0, but it's not checked */
182     set1 = CryptInitOIDFunctionSet("", 1);
183     ok(set1 != 0, "CryptInitOIDFunctionSet failed: %08x\n", GetLastError());
184     set2 = CryptInitOIDFunctionSet("", 0);
185     ok(set2 != 0, "CryptInitOIDFunctionSet failed: %08x\n", GetLastError());
186     /* There isn't a free function, so there must be only one set per name to
187      * limit leaks.  (I guess the sets are freed when crypt32 is unloaded.)
188      */
189     ok(set1 == set2, "Expected identical sets\n");
190     if (set1)
191     {
192         /* The empty name function set used here seems to correspond to
193          * DEFAULT.
194          */
195     }
196 
197     /* There's no installed function for a built-in encoding. */
198     set1 = CryptInitOIDFunctionSet("CryptDllEncodeObject", 0);
199     ok(set1 != 0, "CryptInitOIDFunctionSet failed: %08x\n", GetLastError());
200     if (set1)
201     {
202         void *funcAddr;
203         HCRYPTOIDFUNCADDR hFuncAddr;
204 
205         ret = CryptGetOIDFunctionAddress(set1, X509_ASN_ENCODING, X509_CERT, 0,
206          &funcAddr, &hFuncAddr);
207         ok((!ret && GetLastError() == ERROR_FILE_NOT_FOUND) ||
208          broken(ret) /* some Win98 */,
209          "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
210     }
211 }
212 
213 typedef int (*funcY)(int);
214 
215 static int funky(int x)
216 {
217     return x;
218 }
219 
220 static void test_installOIDFunctionAddress(void)
221 {
222     BOOL ret;
223     CRYPT_OID_FUNC_ENTRY entry = { CRYPT_DEFAULT_OID, funky };
224     HCRYPTOIDFUNCSET set;
225 
226     /* This crashes
227     ret = CryptInstallOIDFunctionAddress(NULL, 0, NULL, 0, NULL, 0);
228      */
229 
230     /* Installing zero functions should work */
231     SetLastError(0xdeadbeef);
232     ret = CryptInstallOIDFunctionAddress(NULL, 0, "CryptDllEncodeObject", 0,
233      NULL, 0);
234     ok(ret && GetLastError() == 0xdeadbeef, "Expected success, got %08x\n",
235      GetLastError());
236 
237     /* The function name doesn't much matter */
238     SetLastError(0xdeadbeef);
239     ret = CryptInstallOIDFunctionAddress(NULL, 0, "OhSoFunky", 0, NULL, 0);
240     ok(ret && GetLastError() == 0xdeadbeef, "Expected success, got %08x\n",
241      GetLastError());
242     SetLastError(0xdeadbeef);
243     entry.pszOID = X509_CERT;
244     ret = CryptInstallOIDFunctionAddress(NULL, 0, "OhSoFunky", 1, &entry, 0);
245     ok(ret && GetLastError() == 0xdeadbeef, "Expected success, got %08x\n",
246      GetLastError());
247     set = CryptInitOIDFunctionSet("OhSoFunky", 0);
248     ok(set != 0, "CryptInitOIDFunctionSet failed: %08x\n", GetLastError());
249     if (set)
250     {
251         funcY funcAddr = NULL;
252         HCRYPTOIDFUNCADDR hFuncAddr = NULL;
253 
254         /* This crashes
255         ret = CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, 0, 0, NULL,
256          NULL);
257          */
258         ret = CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, 0, 0,
259          (void **)&funcAddr, &hFuncAddr);
260         ok(!ret && (GetLastError() == ERROR_FILE_NOT_FOUND ||
261          GetLastError() == E_INVALIDARG /* some Win98 */),
262          "Expected ERROR_FILE_NOT_FOUND or E_INVALIDARG, got %d\n",
263          GetLastError());
264         ret = CryptGetOIDFunctionAddress(set, X509_ASN_ENCODING, X509_CERT, 0,
265          (void **)&funcAddr, &hFuncAddr);
266         ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
267          "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
268         ret = CryptGetOIDFunctionAddress(set, 0, X509_CERT, 0,
269          (void **)&funcAddr, &hFuncAddr);
270         ok(ret, "CryptGetOIDFunctionAddress failed: %d\n", GetLastError());
271         if (funcAddr)
272         {
273             int y = funcAddr(0xabadc0da);
274 
275             ok(y == 0xabadc0da, "Unexpected return (%d) from function\n", y);
276             CryptFreeOIDFunctionAddress(hFuncAddr, 0);
277         }
278     }
279 }
280 
281 static void test_registerOIDFunction(void)
282 {
283     BOOL ret;
284 
285     /* oddly, this succeeds under WinXP; the function name key is merely
286      * omitted.  This may be a side effect of the registry code, I don't know.
287      * I don't check it because I doubt anyone would depend on it.
288     ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, NULL,
289      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
290      */
291     /* On windows XP, GetLastError is incorrectly being set with an HRESULT,
292      * E_INVALIDARG
293      */
294     ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "foo", NULL, bogusDll,
295      NULL);
296     ok(!ret && GetLastError() == E_INVALIDARG,
297      "Expected E_INVALIDARG: %d\n", GetLastError());
298     /* This has no effect, but "succeeds" on XP */
299     ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "foo",
300      "1.2.3.4.5.6.7.8.9.10", NULL, NULL);
301     ok(ret, "Expected pseudo-success, got %d\n", GetLastError());
302     SetLastError(0xdeadbeef);
303     ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "CryptDllEncodeObject",
304      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
305     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
306     {
307         skip("Need admin rights\n");
308         return;
309     }
310     ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
311     ret = CryptUnregisterOIDFunction(X509_ASN_ENCODING, "CryptDllEncodeObject",
312      "1.2.3.4.5.6.7.8.9.10");
313     ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
314     ret = CryptRegisterOIDFunction(X509_ASN_ENCODING, "bogus",
315      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
316     ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
317     ret = CryptUnregisterOIDFunction(X509_ASN_ENCODING, "bogus",
318      "1.2.3.4.5.6.7.8.9.10");
319     ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
320     /* Unwanted Cryptography\OID\EncodingType 1\bogus\ will still be there */
321     ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
322      "SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 1\\bogus"),
323      "Could not delete bogus key\n");
324     /* Shouldn't have effect but registry keys are created */
325     ret = CryptRegisterOIDFunction(PKCS_7_ASN_ENCODING, "CryptDllEncodeObject",
326      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
327     ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
328     ret = CryptUnregisterOIDFunction(PKCS_7_ASN_ENCODING, "CryptDllEncodeObject",
329      "1.2.3.4.5.6.7.8.9.10");
330     ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
331     /* Check with bogus encoding type. Registry keys are still created */
332     ret = CryptRegisterOIDFunction(0, "CryptDllEncodeObject",
333      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
334     ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
335     ret = CryptUnregisterOIDFunction(0, "CryptDllEncodeObject",
336      "1.2.3.4.5.6.7.8.9.10");
337     ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
338     /* Unwanted Cryptography\OID\EncodingType 0\CryptDllEncodeObject\
339      * will still be there
340      */
341     ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
342      "SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllEncodeObject"),
343      "Could not delete CryptDllEncodeObject key\n");
344     /* This is written with value 3 verbatim.  Thus, the encoding type isn't
345      * (for now) treated as a mask. Registry keys are created.
346      */
347     ret = CryptRegisterOIDFunction(3, "CryptDllEncodeObject",
348      "1.2.3.4.5.6.7.8.9.10", bogusDll, NULL);
349     ok(ret, "CryptRegisterOIDFunction failed: %d\n", GetLastError());
350     ret = CryptUnregisterOIDFunction(3, "CryptDllEncodeObject",
351      "1.2.3.4.5.6.7.8.9.10");
352     ok(ret, "CryptUnregisterOIDFunction failed: %d\n", GetLastError());
353     /* Unwanted Cryptography\OID\EncodingType 3\CryptDllEncodeObject
354      * will still be there.
355      */
356     ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
357      "SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 3\\CryptDllEncodeObject"),
358      "Could not delete CryptDllEncodeObject key\n");
359     ok(!RegDeleteKeyA(HKEY_LOCAL_MACHINE,
360      "SOFTWARE\\Microsoft\\Cryptography\\OID\\EncodingType 3"),
361      "Could not delete 'EncodingType 3' key\n");
362 }
363 
364 static void test_registerDefaultOIDFunction(void)
365 {
366     static const char fmt[] =
367      "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\DEFAULT";
368     static const char func[] = "CertDllOpenStoreProv";
369     char buf[MAX_PATH];
370     BOOL ret;
371     LSTATUS rc;
372     HKEY key;
373 
374     ret = CryptRegisterDefaultOIDFunction(0, NULL, 0, NULL);
375     ok(!ret && GetLastError() == E_INVALIDARG,
376      "Expected E_INVALIDARG, got %08x\n", GetLastError());
377     /* This succeeds on WinXP, although the bogus entry is unusable.
378     ret = CryptRegisterDefaultOIDFunction(0, NULL, 0, bogusDll);
379      */
380     /* Register one at index 0 */
381     SetLastError(0xdeadbeef);
382     ret = CryptRegisterDefaultOIDFunction(0, "CertDllOpenStoreProv", 0,
383      bogusDll);
384     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
385     {
386         skip("Need admin rights\n");
387         return;
388     }
389     ok(ret, "CryptRegisterDefaultOIDFunction failed: %08x\n", GetLastError());
390     /* Reregistering should fail */
391     ret = CryptRegisterDefaultOIDFunction(0, "CertDllOpenStoreProv", 0,
392      bogusDll);
393     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
394      "Expected ERROR_FILE_EXISTS, got %08x\n", GetLastError());
395     /* Registering the same one at index 1 should also fail */
396     ret = CryptRegisterDefaultOIDFunction(0, "CertDllOpenStoreProv", 1,
397      bogusDll);
398     ok(!ret && GetLastError() == ERROR_FILE_EXISTS,
399      "Expected ERROR_FILE_EXISTS, got %08x\n", GetLastError());
400     /* Registering a different one at index 1 succeeds */
401     ret = CryptRegisterDefaultOIDFunction(0, "CertDllOpenStoreProv", 1,
402      bogus2Dll);
403     ok(ret, "CryptRegisterDefaultOIDFunction failed: %08x\n", GetLastError());
404     sprintf(buf, fmt, 0, func);
405     rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, buf, &key);
406     ok(rc == 0, "Expected key to exist, RegOpenKeyA failed: %d\n", rc);
407     if (rc == 0)
408     {
409         static const CHAR dllA[] = "Dll";
410         static const CHAR bogusDll_A[] = "bogus.dll";
411         static const CHAR bogus2Dll_A[] = "bogus2.dll";
412         CHAR dllBuf[MAX_PATH];
413         DWORD type, size;
414         LPSTR ptr;
415 
416         size = sizeof(dllBuf) / sizeof(dllBuf[0]);
417         rc = RegQueryValueExA(key, dllA, NULL, &type, (LPBYTE)dllBuf, &size);
418         ok(rc == 0,
419          "Expected Dll value to exist, RegQueryValueExA failed: %d\n", rc);
420         ok(type == REG_MULTI_SZ, "Expected type REG_MULTI_SZ, got %d\n", type);
421         /* bogusDll was registered first, so that should be first */
422         ptr = dllBuf;
423         ok(!lstrcmpiA(ptr, bogusDll_A), "Unexpected dll\n");
424         ptr += lstrlenA(ptr) + 1;
425         ok(!lstrcmpiA(ptr, bogus2Dll_A), "Unexpected dll\n");
426         RegCloseKey(key);
427     }
428     /* Unregister both of them */
429     ret = CryptUnregisterDefaultOIDFunction(0, "CertDllOpenStoreProv",
430      bogusDll);
431     ok(ret, "CryptUnregisterDefaultOIDFunction failed: %08x\n",
432      GetLastError());
433     ret = CryptUnregisterDefaultOIDFunction(0, "CertDllOpenStoreProv",
434      bogus2Dll);
435     ok(ret, "CryptUnregisterDefaultOIDFunction failed: %08x\n",
436      GetLastError());
437     /* Now that they're both unregistered, unregistering should fail */
438     ret = CryptUnregisterDefaultOIDFunction(0, "CertDllOpenStoreProv",
439      bogusDll);
440     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
441      "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
442 
443     /* Repeat a few tests on the normal encoding type */
444     ret = CryptRegisterDefaultOIDFunction(X509_ASN_ENCODING,
445      "CertDllOpenStoreProv", 0, bogusDll);
446     ok(ret, "CryptRegisterDefaultOIDFunction failed\n");
447     ret = CryptUnregisterDefaultOIDFunction(X509_ASN_ENCODING,
448      "CertDllOpenStoreProv", bogusDll);
449     ok(ret, "CryptUnregisterDefaultOIDFunction failed\n");
450     ret = CryptUnregisterDefaultOIDFunction(X509_ASN_ENCODING,
451      "CertDllOpenStoreProv", bogusDll);
452     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
453      "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
454 }
455 
456 static void test_getDefaultOIDFunctionAddress(void)
457 {
458     BOOL ret;
459     HCRYPTOIDFUNCSET set;
460     void *funcAddr;
461     HCRYPTOIDFUNCADDR hFuncAddr;
462 
463     /* Crash
464     ret = CryptGetDefaultOIDFunctionAddress(0, 0, NULL, 0, NULL, NULL);
465     ret = CryptGetDefaultOIDFunctionAddress(0, 0, NULL, 0, &funcAddr, NULL);
466     ret = CryptGetDefaultOIDFunctionAddress(0, 0, NULL, 0, NULL, &hFuncAddr);
467     ret = CryptGetDefaultOIDFunctionAddress(0, 0, NULL, 0, &funcAddr,
468      &hFuncAddr);
469      */
470     set = CryptInitOIDFunctionSet("CertDllOpenStoreProv", 0);
471     ok(set != 0, "CryptInitOIDFunctionSet failed: %d\n", GetLastError());
472     /* This crashes if hFuncAddr is not 0 to begin with */
473     hFuncAddr = 0;
474     ret = CryptGetDefaultOIDFunctionAddress(set, 0, NULL, 0, &funcAddr,
475      &hFuncAddr);
476     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
477      "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
478     /* This fails with the normal encoding too, so built-in functions aren't
479      * returned.
480      */
481     ret = CryptGetDefaultOIDFunctionAddress(set, X509_ASN_ENCODING, NULL, 0,
482      &funcAddr, &hFuncAddr);
483     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
484      "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
485 
486     /* Even with a registered dll, this fails (since the dll doesn't exist) */
487     SetLastError(0xdeadbeef);
488     ret = CryptRegisterDefaultOIDFunction(0, "CertDllOpenStoreProv", 0,
489      bogusDll);
490     if (!ret && GetLastError() == ERROR_ACCESS_DENIED)
491         skip("Need admin rights\n");
492     else
493         ok(ret, "CryptRegisterDefaultOIDFunction failed: %08x\n", GetLastError());
494     ret = CryptGetDefaultOIDFunctionAddress(set, 0, NULL, 0, &funcAddr,
495      &hFuncAddr);
496     ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
497      "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
498     CryptUnregisterDefaultOIDFunction(0, "CertDllOpenStoreProv", bogusDll);
499 }
500 
501 static BOOL WINAPI countOidInfo(PCCRYPT_OID_INFO pInfo, void *pvArg)
502 {
503     (*(DWORD *)pvArg)++;
504     return TRUE;
505 }
506 
507 static BOOL WINAPI noOidInfo(PCCRYPT_OID_INFO pInfo, void *pvArg)
508 {
509     return FALSE;
510 }
511 
512 static void test_enumOIDInfo(void)
513 {
514     BOOL ret;
515     DWORD count = 0;
516 
517     if (!pCryptEnumOIDInfo)
518     {
519         win_skip("CryptEnumOIDInfo() is not available\n");
520         return;
521     }
522 
523     /* This crashes
524     ret = pCryptEnumOIDInfo(7, 0, NULL, NULL);
525      */
526 
527     /* Silly tests, check that more than one thing is enumerated */
528     ret = pCryptEnumOIDInfo(0, 0, &count, countOidInfo);
529     ok(ret && count > 0, "Expected more than item enumerated\n");
530     ret = pCryptEnumOIDInfo(0, 0, NULL, noOidInfo);
531     ok(!ret, "Expected FALSE\n");
532 }
533 
534 static void test_findOIDInfo(void)
535 {
536     static WCHAR sha1[] = { 's','h','a','1',0 };
537     static CHAR oid_rsa_md5[] = szOID_RSA_MD5;
538     ALG_ID alg = CALG_SHA1;
539     ALG_ID algs[2] = { CALG_MD5, CALG_RSA_SIGN };
540     PCCRYPT_OID_INFO info;
541 
542     info = CryptFindOIDInfo(0, NULL, 0);
543     ok(info == NULL, "Expected NULL\n");
544     info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, oid_rsa_md5, 0);
545     ok(info != NULL, "Expected to find szOID_RSA_MD5\n");
546     if (info)
547     {
548         ok(!strcmp(info->pszOID, szOID_RSA_MD5), "Expected %s, got %s\n",
549          szOID_RSA_MD5, info->pszOID);
550         ok(U(*info).Algid == CALG_MD5, "Expected CALG_MD5, got %d\n",
551            U(*info).Algid);
552     }
553     info = CryptFindOIDInfo(CRYPT_OID_INFO_NAME_KEY, sha1, 0);
554     ok(info != NULL, "Expected to find sha1\n");
555     if (info)
556     {
557         ok(!strcmp(info->pszOID, szOID_OIWSEC_sha1), "Expected %s, got %s\n",
558          szOID_OIWSEC_sha1, info->pszOID);
559         ok(U(*info).Algid == CALG_SHA1, "Expected CALG_SHA1, got %d\n",
560            U(*info).Algid);
561     }
562     info = CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY, &alg, 0);
563     ok(info != NULL, "Expected to find sha1\n");
564     if (info)
565     {
566         ok(!strcmp(info->pszOID, szOID_OIWSEC_sha1), "Expected %s, got %s\n",
567          szOID_OIWSEC_sha1, info->pszOID);
568         ok(U(*info).Algid == CALG_SHA1, "Expected CALG_SHA1, got %d\n",
569            U(*info).Algid);
570     }
571     info = CryptFindOIDInfo(CRYPT_OID_INFO_SIGN_KEY, algs, 0);
572     ok(info != NULL, "Expected to find md5RSA\n");
573     if (info)
574     {
575         ok(!strcmp(info->pszOID, szOID_RSA_MD5RSA), "Expected %s, got %s\n",
576          szOID_RSA_MD5RSA, info->pszOID);
577         ok(U(*info).Algid == CALG_MD5, "Expected CALG_MD5, got %d\n",
578            U(*info).Algid);
579     }
580 }
581 
582 START_TEST(oid)
583 {
584     HMODULE hCrypt32 = GetModuleHandleA("crypt32.dll");
585     pCryptEnumOIDInfo = (void*)GetProcAddress(hCrypt32, "CryptEnumOIDInfo");
586 
587     testOIDToAlgID();
588     testAlgIDToOID();
589     test_enumOIDInfo();
590     test_findOIDInfo();
591     test_oidFunctionSet();
592     test_installOIDFunctionAddress();
593     test_registerOIDFunction();
594     test_registerDefaultOIDFunction();
595     test_getDefaultOIDFunctionAddress();
596 }
597