projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CRYPT32] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / dll / win32 / crypt32 / oid.c
1 /*
2 * Copyright 2002 Mike McCormack for CodeWeavers
3 * Copyright 2005-2006 Juan Lang
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "config.h"
21 #include "wine/port.h"
22
23 #include <stdio.h>
24 #include <stdarg.h>
25 #define NONAMELESSUNION
26 #include "windef.h"
27 #include "winbase.h"
28 #define CRYPT_OID_INFO_HAS_EXTRA_FIELDS
29 #include "wincrypt.h"
30 #include "winreg.h"
31 #include "winuser.h"
32 #include "wine/debug.h"
33 #include "wine/list.h"
34 #include "crypt32_private.h"
35 #include "cryptres.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
38
39 static const WCHAR DllW[] = { 'D','l','l',0 };
40
41 static CRITICAL_SECTION funcSetCS;
42 static CRITICAL_SECTION_DEBUG funcSetCSDebug =
43 {
44 0, 0, &funcSetCS,
45 { &funcSetCSDebug.ProcessLocksList, &funcSetCSDebug.ProcessLocksList },
46 0, 0, { (DWORD_PTR)(__FILE__ ": funcSetCS") }
47 };
48 static CRITICAL_SECTION funcSetCS = { &funcSetCSDebug, -1, 0, 0, 0, 0 };
49 static struct list funcSets = { &funcSets, &funcSets };
50
51 struct OIDFunctionSet
52 {
53 LPSTR name;
54 CRITICAL_SECTION cs; /* protects functions */
55 struct list functions;
56 struct list next;
57 };
58
59 struct OIDFunction
60 {
61 DWORD encoding;
62 CRYPT_OID_FUNC_ENTRY entry;
63 struct list next;
64 };
65
66 static const WCHAR ROOT[] = {'R','O','O','T',0};
67 static const WCHAR MY[] = {'M','Y',0};
68 static const WCHAR CA[] = {'C','A',0};
69 static const WCHAR ADDRESSBOOK[] = {'A','D','D','R','E','S','S','B','O','O','K',0};
70 static const WCHAR TRUSTEDPUBLISHER[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0};
71 static const WCHAR DISALLOWED[] = {'D','i','s','a','l','l','o','w','e','d',0};
72 static const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER,DISALLOWED};
73 static WCHAR LocalizedNames[sizeof(LocalizedKeys)/sizeof(LocalizedKeys[0])][256];
74
75 static void free_function_sets(void)
76 {
77 struct OIDFunctionSet *setCursor, *setNext;
78
79 LIST_FOR_EACH_ENTRY_SAFE(setCursor, setNext, &funcSets,
80 struct OIDFunctionSet, next)
81 {
82 struct OIDFunction *functionCursor, *funcNext;
83
84 list_remove(&setCursor->next);
85 CryptMemFree(setCursor->name);
86 LIST_FOR_EACH_ENTRY_SAFE(functionCursor, funcNext,
87 &setCursor->functions, struct OIDFunction, next)
88 {
89 list_remove(&functionCursor->next);
90 CryptMemFree(functionCursor);
91 }
92 setCursor->cs.DebugInfo->Spare[0] = 0;
93 DeleteCriticalSection(&setCursor->cs);
94 CryptMemFree(setCursor);
95 }
96 DeleteCriticalSection(&funcSetCS);
97 }
98
99 /* There is no free function associated with this; therefore, the sets are
100 * freed when crypt32.dll is unloaded.
101 */
102 HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName,
103 DWORD dwFlags)
104 {
105 struct OIDFunctionSet *cursor, *ret = NULL;
106
107 TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags);
108
109 EnterCriticalSection(&funcSetCS);
110 LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next)
111 {
112 if (!strcasecmp(pszFuncName, cursor->name))
113 {
114 ret = cursor;
115 break;
116 }
117 }
118 if (!ret)
119 {
120 ret = CryptMemAlloc(sizeof(struct OIDFunctionSet));
121 if (ret)
122 {
123 memset(ret, 0, sizeof(*ret));
124 ret->name = CryptMemAlloc(strlen(pszFuncName) + 1);
125 if (ret->name)
126 {
127 InitializeCriticalSection(&ret->cs);
128 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": OIDFunctionSet.cs");
129 list_init(&ret->functions);
130 strcpy(ret->name, pszFuncName);
131 list_add_tail(&funcSets, &ret->next);
132 }
133 else
134 {
135 CryptMemFree(ret);
136 ret = NULL;
137 }
138 }
139 }
140 LeaveCriticalSection(&funcSetCS);
141
142 return ret;
143 }
144
145 static char *CRYPT_GetKeyName(DWORD dwEncodingType, LPCSTR pszFuncName,
146 LPCSTR pszOID)
147 {
148 static const char szEncodingTypeFmt[] =
149 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
150 UINT len;
151 char numericOID[7]; /* enough for "#65535" */
152 const char *oid;
153 LPSTR szKey;
154
155 /* MSDN says the encoding type is a mask, but it isn't treated that way.
156 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
157 * "EncodingType 2" would be expected if it were a mask. Instead native
158 * stores values in "EncodingType 3".
159 */
160 if (IS_INTOID(pszOID))
161 {
162 snprintf(numericOID, sizeof(numericOID), "#%d", LOWORD(pszOID));
163 oid = numericOID;
164 }
165 else
166 oid = pszOID;
167
168 /* This is enough: the lengths of the two string parameters are explicitly
169 * counted, and we need up to five additional characters for the encoding
170 * type. These are covered by the "%d", "%s", and "%s" characters in the
171 * format specifier that are removed by sprintf.
172 */
173 len = sizeof(szEncodingTypeFmt) + lstrlenA(pszFuncName) + lstrlenA(oid);
174 szKey = CryptMemAlloc(len);
175 if (szKey)
176 sprintf(szKey, szEncodingTypeFmt,
177 GET_CERT_ENCODING_TYPE(dwEncodingType), pszFuncName, oid);
178 return szKey;
179 }
180
181 BOOL WINAPI CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet,
182 DWORD dwEncodingType, LPWSTR pwszDllList, DWORD *pcchDllList)
183 {
184 BOOL ret = TRUE;
185 struct OIDFunctionSet *set = hFuncSet;
186 char *keyName;
187 HKEY key;
188 LSTATUS rc;
189
190 TRACE("(%p, %d, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList,
191 pcchDllList);
192
193 keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT");
194 rc = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0,
195 KEY_READ, NULL, &key, NULL);
196 if (!rc)
197 {
198 DWORD size = *pcchDllList * sizeof(WCHAR);
199
200 rc = RegQueryValueExW(key, DllW, NULL, NULL, (LPBYTE)pwszDllList,
201 &size);
202 if (!rc)
203 *pcchDllList = size / sizeof(WCHAR);
204 else
205 {
206 /* No value, return an empty list */
207 if (pwszDllList && *pcchDllList)
208 *pwszDllList = '\0';
209 *pcchDllList = 1;
210 }
211 RegCloseKey(key);
212 }
213 else
214 {
215 /* No value, return an empty list */
216 if (pwszDllList && *pcchDllList)
217 *pwszDllList = '\0';
218 *pcchDllList = 1;
219 }
220 CryptMemFree(keyName);
221
222 return ret;
223 }
224
225 BOOL WINAPI CryptInstallOIDFunctionAddress(HMODULE hModule,
226 DWORD dwEncodingType, LPCSTR pszFuncName, DWORD cFuncEntry,
227 const CRYPT_OID_FUNC_ENTRY rgFuncEntry[], DWORD dwFlags)
228 {
229 BOOL ret = TRUE;
230 struct OIDFunctionSet *set;
231
232 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType,
233 debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags);
234
235 set = CryptInitOIDFunctionSet(pszFuncName, 0);
236 if (set)
237 {
238 DWORD i;
239
240 EnterCriticalSection(&set->cs);
241 for (i = 0; ret && i < cFuncEntry; i++)
242 {
243 struct OIDFunction *func;
244
245 if (!IS_INTOID(rgFuncEntry[i].pszOID))
246 func = CryptMemAlloc(sizeof(struct OIDFunction)
247 + strlen(rgFuncEntry[i].pszOID) + 1);
248 else
249 func = CryptMemAlloc(sizeof(struct OIDFunction));
250 if (func)
251 {
252 func->encoding = GET_CERT_ENCODING_TYPE(dwEncodingType);
253 if (!IS_INTOID(rgFuncEntry[i].pszOID))
254 {
255 LPSTR oid;
256
257 oid = (LPSTR)((LPBYTE)func + sizeof(*func));
258 strcpy(oid, rgFuncEntry[i].pszOID);
259 func->entry.pszOID = oid;
260 }
261 else
262 func->entry.pszOID = rgFuncEntry[i].pszOID;
263 func->entry.pvFuncAddr = rgFuncEntry[i].pvFuncAddr;
264 list_add_tail(&set->functions, &func->next);
265 }
266 else
267 ret = FALSE;
268 }
269 LeaveCriticalSection(&set->cs);
270 }
271 else
272 ret = FALSE;
273 return ret;
274 }
275
276 struct FuncAddr
277 {
278 HMODULE lib;
279 LPWSTR dllList;
280 LPWSTR currentDll;
281 };
282
283 static BOOL CRYPT_GetFuncFromReg(DWORD dwEncodingType, LPCSTR pszOID,
284 LPCSTR szFuncName, LPVOID *ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
285 {
286 BOOL ret = FALSE;
287 char *keyName;
288 const char *funcName;
289 HKEY key;
290 LSTATUS rc;
291
292 keyName = CRYPT_GetKeyName(dwEncodingType, szFuncName, pszOID);
293 rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, KEY_READ, &key);
294 if (!rc)
295 {
296 DWORD type, size = 0;
297
298 rc = RegQueryValueExA(key, "FuncName", NULL, &type, NULL, &size);
299 if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
300 {
301 funcName = CryptMemAlloc(size);
302 rc = RegQueryValueExA(key, "FuncName", NULL, &type,
303 (LPBYTE)funcName, &size);
304 }
305 else
306 funcName = szFuncName;
307 rc = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size);
308 if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
309 {
310 LPWSTR dllName = CryptMemAlloc(size);
311
312 if (dllName)
313 {
314 rc = RegQueryValueExW(key, DllW, NULL, NULL,
315 (LPBYTE)dllName, &size);
316 if (!rc)
317 {
318 HMODULE lib;
319
320 /* This is a bit of a hack; MSDN describes a more
321 * complicated unload routine than this will allow.
322 * Still, this seems to suffice for now.
323 */
324 lib = LoadLibraryW(dllName);
325 if (lib)
326 {
327 *ppvFuncAddr = GetProcAddress(lib, funcName);
328 if (*ppvFuncAddr)
329 {
330 struct FuncAddr *addr =
331 CryptMemAlloc(sizeof(struct FuncAddr));
332
333 if (addr)
334 {
335 addr->lib = lib;
336 addr->dllList = addr->currentDll = NULL;
337 *phFuncAddr = addr;
338 ret = TRUE;
339 }
340 else
341 {
342 *phFuncAddr = NULL;
343 FreeLibrary(lib);
344 }
345 }
346 else
347 {
348 /* Unload the library, the caller doesn't want
349 * to unload it when the return value is NULL.
350 */
351 FreeLibrary(lib);
352 }
353 }
354 }
355 else
356 SetLastError(rc);
357 CryptMemFree(dllName);
358 }
359 }
360 else
361 SetLastError(rc);
362 if (funcName != szFuncName)
363 CryptMemFree((char *)funcName);
364 RegCloseKey(key);
365 }
366 else
367 SetLastError(rc);
368 CryptMemFree(keyName);
369 return ret;
370 }
371
372 BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
373 DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr,
374 HCRYPTOIDFUNCADDR *phFuncAddr)
375 {
376 BOOL ret = FALSE;
377 struct OIDFunctionSet *set = hFuncSet;
378
379 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
380 debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr);
381
382 *ppvFuncAddr = NULL;
383 if (!(dwFlags & CRYPT_GET_INSTALLED_OID_FUNC_FLAG))
384 {
385 struct OIDFunction *function;
386
387 EnterCriticalSection(&set->cs);
388 LIST_FOR_EACH_ENTRY(function, &set->functions, struct OIDFunction, next)
389 {
390 if (function->encoding == GET_CERT_ENCODING_TYPE(dwEncodingType))
391 {
392 if (!IS_INTOID(pszOID))
393 {
394 if (!IS_INTOID(function->entry.pszOID) &&
395 !strcasecmp(function->entry.pszOID, pszOID))
396 {
397 *ppvFuncAddr = function->entry.pvFuncAddr;
398 *phFuncAddr = NULL; /* FIXME: what should it be? */
399 ret = TRUE;
400 break;
401 }
402 }
403 else if (function->entry.pszOID == pszOID)
404 {
405 *ppvFuncAddr = function->entry.pvFuncAddr;
406 *phFuncAddr = NULL; /* FIXME: what should it be? */
407 ret = TRUE;
408 break;
409 }
410 }
411 }
412 LeaveCriticalSection(&set->cs);
413 }
414 if (!*ppvFuncAddr)
415 ret = CRYPT_GetFuncFromReg(dwEncodingType, pszOID, set->name,
416 ppvFuncAddr, phFuncAddr);
417 TRACE("returning %d\n", ret);
418 return ret;
419 }
420
421 BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr,
422 DWORD dwFlags)
423 {
424 TRACE("(%p, %08x)\n", hFuncAddr, dwFlags);
425
426 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
427 * and only unload it if it can be unloaded. Also need to implement ref
428 * counting on the functions.
429 */
430 if (hFuncAddr)
431 {
432 struct FuncAddr *addr = hFuncAddr;
433
434 CryptMemFree(addr->dllList);
435 FreeLibrary(addr->lib);
436 CryptMemFree(addr);
437 }
438 return TRUE;
439 }
440
441 static BOOL CRYPT_GetFuncFromDll(LPCWSTR dll, LPCSTR func, HMODULE *lib,
442 void **ppvFuncAddr)
443 {
444 BOOL ret = FALSE;
445
446 *lib = LoadLibraryW(dll);
447 if (*lib)
448 {
449 *ppvFuncAddr = GetProcAddress(*lib, func);
450 if (*ppvFuncAddr)
451 ret = TRUE;
452 else
453 {
454 FreeLibrary(*lib);
455 *lib = NULL;
456 }
457 }
458 return ret;
459 }
460
461 BOOL WINAPI CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet,
462 DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void **ppvFuncAddr,
463 HCRYPTOIDFUNCADDR *phFuncAddr)
464 {
465 struct OIDFunctionSet *set = hFuncSet;
466 BOOL ret = FALSE;
467
468 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
469 debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr);
470
471 if (pwszDll)
472 {
473 HMODULE lib;
474
475 *phFuncAddr = NULL;
476 ret = CRYPT_GetFuncFromDll(pwszDll, set->name, &lib, ppvFuncAddr);
477 if (ret)
478 {
479 struct FuncAddr *addr = CryptMemAlloc(sizeof(struct FuncAddr));
480
481 if (addr)
482 {
483 addr->lib = lib;
484 addr->dllList = addr->currentDll = NULL;
485 *phFuncAddr = addr;
486 }
487 else
488 {
489 FreeLibrary(lib);
490 *ppvFuncAddr = NULL;
491 SetLastError(ERROR_OUTOFMEMORY);
492 ret = FALSE;
493 }
494 }
495 else
496 SetLastError(ERROR_FILE_NOT_FOUND);
497 }
498 else
499 {
500 struct FuncAddr *addr = *phFuncAddr;
501
502 if (!addr)
503 {
504 DWORD size;
505
506 ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType, NULL,
507 &size);
508 if (ret)
509 {
510 LPWSTR dllList = CryptMemAlloc(size * sizeof(WCHAR));
511
512 if (dllList)
513 {
514 ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType,
515 dllList, &size);
516 if (ret)
517 {
518 addr = CryptMemAlloc(sizeof(struct FuncAddr));
519 if (addr)
520 {
521 addr->dllList = dllList;
522 addr->currentDll = dllList;
523 addr->lib = NULL;
524 *phFuncAddr = addr;
525 }
526 else
527 {
528 CryptMemFree(dllList);
529 SetLastError(ERROR_OUTOFMEMORY);
530 ret = FALSE;
531 }
532 }
533 }
534 else
535 {
536 SetLastError(ERROR_OUTOFMEMORY);
537 ret = FALSE;
538 }
539 }
540 }
541 if (addr)
542 {
543 if (!*addr->currentDll)
544 {
545 CryptFreeOIDFunctionAddress(*phFuncAddr, 0);
546 SetLastError(ERROR_FILE_NOT_FOUND);
547 *phFuncAddr = NULL;
548 ret = FALSE;
549 }
550 else
551 {
552 /* FIXME: as elsewhere, can't free until DllCanUnloadNow says
553 * it's possible, and should defer unloading for some time to
554 * avoid repeated LoadLibrary/FreeLibrary on the same dll.
555 */
556 FreeLibrary(addr->lib);
557 ret = CRYPT_GetFuncFromDll(addr->currentDll, set->name,
558 &addr->lib, ppvFuncAddr);
559 if (ret)
560 {
561 /* Move past the current DLL */
562 addr->currentDll += lstrlenW(addr->currentDll) + 1;
563 *phFuncAddr = addr;
564 }
565 else
566 {
567 CryptFreeOIDFunctionAddress(*phFuncAddr, 0);
568 SetLastError(ERROR_FILE_NOT_FOUND);
569 *phFuncAddr = NULL;
570 }
571 }
572 }
573 }
574 return ret;
575 }
576
577 /***********************************************************************
578 * CryptRegisterOIDFunction (CRYPT32.@)
579 *
580 * Register the DLL and the functions it uses to cover the combination
581 * of encoding type, function name and OID.
582 *
583 * PARAMS
584 * dwEncodingType [I] Encoding type to be used.
585 * pszFuncName [I] Name of the function to be registered.
586 * pszOID [I] OID of the function (numeric or string).
587 * pwszDll [I] The DLL that is to be registered.
588 * pszOverrideFuncName [I] Name of the function in the DLL.
589 *
590 * RETURNS
591 * Success: TRUE.
592 * Failure: FALSE. (Look at GetLastError()).
593 *
594 * NOTES
595 * Registry errors are always reported via SetLastError().
596 */
597 BOOL WINAPI CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
598 LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName)
599 {
600 LONG r;
601 HKEY hKey;
602 LPSTR szKey;
603
604 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
605 debugstr_a(pszOID), debugstr_w(pwszDll), debugstr_a(pszOverrideFuncName));
606
607 /* Native does nothing pwszDll is NULL */
608 if (!pwszDll)
609 return TRUE;
610
611 /* I'm not matching MS bug for bug here, because I doubt any app depends on
612 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
613 * it creates would never be used.
614 */
615 if (!pszFuncName || !pszOID)
616 {
617 SetLastError(E_INVALIDARG);
618 return FALSE;
619 }
620
621 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
622 TRACE("Key name is %s\n", debugstr_a(szKey));
623
624 if (!szKey)
625 return FALSE;
626
627 r = RegCreateKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
628 CryptMemFree(szKey);
629
630 if (r != ERROR_SUCCESS) goto error_close_key;
631
632 /* write the values */
633 if (pszOverrideFuncName)
634 {
635 r = RegSetValueExA(hKey, "FuncName", 0, REG_SZ,
636 (const BYTE*)pszOverrideFuncName, lstrlenA(pszOverrideFuncName) + 1);
637 if (r != ERROR_SUCCESS) goto error_close_key;
638 }
639 r = RegSetValueExW(hKey, DllW, 0, REG_SZ, (const BYTE*) pwszDll,
640 (lstrlenW(pwszDll) + 1) * sizeof (WCHAR));
641
642 error_close_key:
643
644 RegCloseKey(hKey);
645
646 if (r != ERROR_SUCCESS)
647 {
648 SetLastError(r);
649 return FALSE;
650 }
651
652 return TRUE;
653 }
654
655 /***********************************************************************
656 * CryptRegisterOIDInfo (CRYPT32.@)
657 */
658 BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO pInfo, DWORD dwFlags)
659 {
660 FIXME("(%p, %x): stub\n", pInfo, dwFlags );
661 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
662 return FALSE;
663 }
664
665 /***********************************************************************
666 * CryptUnregisterOIDFunction (CRYPT32.@)
667 */
668 BOOL WINAPI CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName,
669 LPCSTR pszOID)
670 {
671 LPSTR szKey;
672 LONG rc;
673
674 TRACE("%x %s %s\n", dwEncodingType, debugstr_a(pszFuncName),
675 debugstr_a(pszOID));
676
677 if (!pszFuncName || !pszOID)
678 {
679 SetLastError(ERROR_INVALID_PARAMETER);
680 return FALSE;
681 }
682
683 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
684 rc = RegDeleteKeyA(HKEY_LOCAL_MACHINE, szKey);
685 CryptMemFree(szKey);
686 if (rc)
687 SetLastError(rc);
688 return !rc;
689 }
690
691 BOOL WINAPI CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
692 LPCSTR pszOID, LPCWSTR pwszValueName, DWORD *pdwValueType, BYTE *pbValueData,
693 DWORD *pcbValueData)
694 {
695 LPSTR szKey;
696 LONG rc;
697 HKEY hKey;
698
699 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName),
700 debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData,
701 pcbValueData);
702
703 if (!GET_CERT_ENCODING_TYPE(dwEncodingType))
704 return TRUE;
705
706 if (!pszFuncName || !pszOID || !pwszValueName)
707 {
708 SetLastError(ERROR_INVALID_PARAMETER);
709 return FALSE;
710 }
711
712 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
713 rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
714 CryptMemFree(szKey);
715 if (rc)
716 SetLastError(rc);
717 else
718 {
719 rc = RegQueryValueExW(hKey, pwszValueName, NULL, pdwValueType,
720 pbValueData, pcbValueData);
721 if (rc)
722 SetLastError(rc);
723 RegCloseKey(hKey);
724 }
725 return !rc;
726 }
727
728 BOOL WINAPI CryptSetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName,
729 LPCSTR pszOID, LPCWSTR pwszValueName, DWORD dwValueType,
730 const BYTE *pbValueData, DWORD cbValueData)
731 {
732 LPSTR szKey;
733 LONG rc;
734 HKEY hKey;
735
736 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType, debugstr_a(pszFuncName),
737 debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData,
738 cbValueData);
739
740 if (!GET_CERT_ENCODING_TYPE(dwEncodingType))
741 return TRUE;
742
743 if (!pszFuncName || !pszOID || !pwszValueName)
744 {
745 SetLastError(ERROR_INVALID_PARAMETER);
746 return FALSE;
747 }
748
749 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
750 rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
751 CryptMemFree(szKey);
752 if (rc)
753 SetLastError(rc);
754 else
755 {
756 rc = RegSetValueExW(hKey, pwszValueName, 0, dwValueType, pbValueData,
757 cbValueData);
758 if (rc)
759 SetLastError(rc);
760 RegCloseKey(hKey);
761 }
762 return !rc;
763 }
764
765 static LPCWSTR CRYPT_FindStringInMultiString(LPCWSTR multi, LPCWSTR toFind)
766 {
767 LPCWSTR ret = NULL, ptr;
768
769 for (ptr = multi; ptr && *ptr && !ret; ptr += lstrlenW(ptr) + 1)
770 {
771 if (!lstrcmpiW(ptr, toFind))
772 ret = ptr;
773 }
774 return ret;
775 }
776
777 static DWORD CRYPT_GetMultiStringCharacterLen(LPCWSTR multi)
778 {
779 DWORD ret;
780
781 if (multi)
782 {
783 LPCWSTR ptr;
784
785 /* Count terminating empty string */
786 ret = 1;
787 for (ptr = multi; *ptr; ptr += lstrlenW(ptr) + 1)
788 ret += lstrlenW(ptr) + 1;
789 }
790 else
791 ret = 0;
792 return ret;
793 }
794
795 static LPWSTR CRYPT_AddStringToMultiString(LPWSTR multi, LPCWSTR toAdd,
796 DWORD index)
797 {
798 LPWSTR ret;
799
800 if (!multi)
801 {
802 /* FIXME: ignoring index, is that okay? */
803 ret = CryptMemAlloc((lstrlenW(toAdd) + 2) * sizeof(WCHAR));
804 if (ret)
805 {
806 /* copy string, including NULL terminator */
807 memcpy(ret, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR));
808 /* add terminating empty string */
809 *(ret + lstrlenW(toAdd) + 1) = 0;
810 }
811 }
812 else
813 {
814 DWORD len = CRYPT_GetMultiStringCharacterLen(multi);
815
816 ret = CryptMemRealloc(multi, (len + lstrlenW(toAdd) + 1) *
817 sizeof(WCHAR));
818 if (ret)
819 {
820 LPWSTR spotToAdd;
821
822 if (index == CRYPT_REGISTER_LAST_INDEX)
823 spotToAdd = ret + len - 1;
824 else
825 {
826 DWORD i;
827
828 /* FIXME: if index is too large for the string, toAdd is
829 * added to the end. Is that okay?
830 */
831 for (i = 0, spotToAdd = ret; i < index && *spotToAdd;
832 spotToAdd += lstrlenW(spotToAdd) + 1)
833 ;
834 }
835 if (spotToAdd)
836 {
837 /* Copy existing string "right" */
838 memmove(spotToAdd + lstrlenW(toAdd) + 1, spotToAdd,
839 (len - (spotToAdd - ret)) * sizeof(WCHAR));
840 /* Copy new string */
841 memcpy(spotToAdd, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR));
842 }
843 else
844 {
845 CryptMemFree(ret);
846 ret = NULL;
847 }
848 }
849 }
850 return ret;
851 }
852
853 static BOOL CRYPT_RemoveStringFromMultiString(LPWSTR multi, LPCWSTR toRemove)
854 {
855 LPWSTR spotToRemove = (LPWSTR)CRYPT_FindStringInMultiString(multi,
856 toRemove);
857 BOOL ret;
858
859 if (spotToRemove)
860 {
861 DWORD len = CRYPT_GetMultiStringCharacterLen(multi);
862
863 if (spotToRemove + lstrlenW(toRemove) + 2 >= multi + len)
864 {
865 /* Removing last string in list, terminate multi string directly */
866 *spotToRemove = 0;
867 *(spotToRemove + 1) = 0;
868 }
869 else
870 {
871 LPCWSTR nextStr = spotToRemove + lstrlenW(toRemove) + 1;
872
873 /* Copy remainder of string "left" */
874 memmove(spotToRemove, nextStr,
875 (len - (nextStr - multi)) * sizeof(WCHAR));
876 }
877 ret = TRUE;
878 }
879 else
880 {
881 SetLastError(ERROR_FILE_NOT_FOUND);
882 ret = FALSE;
883 }
884 return ret;
885 }
886
887 static BOOL CRYPT_GetDefaultOIDKey(DWORD dwEncodingType, LPCSTR pszFuncName,
888 PHKEY key)
889 {
890 LPSTR keyName;
891 LONG r;
892
893 keyName = CRYPT_GetKeyName(dwEncodingType, pszFuncName, "DEFAULT");
894 TRACE("Key name is %s\n", debugstr_a(keyName));
895
896 if (!keyName)
897 return FALSE;
898
899 r = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0, KEY_ALL_ACCESS,
900 NULL, key, NULL);
901 CryptMemFree(keyName);
902 if (r != ERROR_SUCCESS)
903 {
904 SetLastError(r);
905 return FALSE;
906 }
907 return TRUE;
908 }
909
910 static LPWSTR CRYPT_GetDefaultOIDDlls(HKEY key)
911 {
912 LONG r;
913 DWORD type, size;
914 LPWSTR dlls;
915
916 r = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size);
917 if (r == ERROR_SUCCESS && type == REG_MULTI_SZ)
918 {
919 dlls = CryptMemAlloc(size);
920 r = RegQueryValueExW(key, DllW, NULL, &type, (LPBYTE)dlls, &size);
921 if (r != ERROR_SUCCESS)
922 {
923 CryptMemFree(dlls);
924 dlls = NULL;
925 }
926 }
927 else
928 dlls = NULL;
929 return dlls;
930 }
931
932 static inline BOOL CRYPT_SetDefaultOIDDlls(HKEY key, LPCWSTR dlls)
933 {
934 DWORD len = CRYPT_GetMultiStringCharacterLen(dlls);
935 LONG r;
936
937 if ((r = RegSetValueExW(key, DllW, 0, REG_MULTI_SZ, (const BYTE *)dlls,
938 len * sizeof (WCHAR))))
939 SetLastError(r);
940 return r == ERROR_SUCCESS;
941 }
942
943 /***********************************************************************
944 * CryptRegisterDefaultOIDFunction (CRYPT32.@)
945 */
946 BOOL WINAPI CryptRegisterDefaultOIDFunction(DWORD dwEncodingType,
947 LPCSTR pszFuncName, DWORD dwIndex, LPCWSTR pwszDll)
948 {
949 HKEY key;
950 LPWSTR dlls;
951 BOOL ret = FALSE;
952
953 TRACE("(%x, %s, %d, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
954 dwIndex, debugstr_w(pwszDll));
955
956 if (!pwszDll)
957 {
958 SetLastError(E_INVALIDARG);
959 return FALSE;
960 }
961
962 if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key))
963 return FALSE;
964
965 dlls = CRYPT_GetDefaultOIDDlls(key);
966 if (CRYPT_FindStringInMultiString(dlls, pwszDll))
967 SetLastError(ERROR_FILE_EXISTS);
968 else
969 {
970 dlls = CRYPT_AddStringToMultiString(dlls, pwszDll, dwIndex);
971 if (dlls)
972 ret = CRYPT_SetDefaultOIDDlls(key, dlls);
973 }
974 CryptMemFree(dlls);
975 RegCloseKey(key);
976 return ret;
977 }
978
979 BOOL WINAPI CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType,
980 LPCSTR pszFuncName, LPCWSTR pwszDll)
981 {
982 HKEY key;
983 LPWSTR dlls;
984 BOOL ret;
985
986 TRACE("(%x, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
987 debugstr_w(pwszDll));
988
989 if (!pwszDll)
990 {
991 SetLastError(E_INVALIDARG);
992 return FALSE;
993 }
994
995 if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key))
996 return FALSE;
997
998 dlls = CRYPT_GetDefaultOIDDlls(key);
999 if ((ret = CRYPT_RemoveStringFromMultiString(dlls, pwszDll)))
1000 ret = CRYPT_SetDefaultOIDDlls(key, dlls);
1001 CryptMemFree(dlls);
1002 RegCloseKey(key);
1003 return ret;
1004 }
1005
1006 static void oid_init_localizednames(void)
1007 {
1008 unsigned int i;
1009
1010 for(i = 0; i < sizeof(LocalizedKeys)/sizeof(LPCWSTR); i++)
1011 {
1012 LoadStringW(hInstance, IDS_LOCALIZEDNAME_ROOT+i, LocalizedNames[i], 256);
1013 }
1014 }
1015
1016 /********************************************************************
1017 * CryptFindLocalizedName (CRYPT32.@)
1018 */
1019 LPCWSTR WINAPI CryptFindLocalizedName(LPCWSTR pwszCryptName)
1020 {
1021 unsigned int i;
1022
1023 for(i = 0; i < sizeof(LocalizedKeys)/sizeof(LPCWSTR); i++)
1024 {
1025 if(!lstrcmpiW(LocalizedKeys[i], pwszCryptName))
1026 {
1027 return LocalizedNames[i];
1028 }
1029 }
1030
1031 FIXME("No name for: %s - stub\n",debugstr_w(pwszCryptName));
1032 return NULL;
1033 }
1034
1035 static CRITICAL_SECTION oidInfoCS;
1036 static CRITICAL_SECTION_DEBUG oidInfoCSDebug =
1037 {
1038 0, 0, &oidInfoCS,
1039 { &oidInfoCSDebug.ProcessLocksList, &oidInfoCSDebug.ProcessLocksList },
1040 0, 0, { (DWORD_PTR)(__FILE__ ": oidInfoCS") }
1041 };
1042 static CRITICAL_SECTION oidInfoCS = { &oidInfoCSDebug, -1, 0, 0, 0, 0 };
1043 static struct list oidInfo = { &oidInfo, &oidInfo };
1044
1045 static const WCHAR tripledes[] = { '3','d','e','s',0 };
1046 static const WCHAR cms3deswrap[] = { 'C','M','S','3','D','E','S','w','r','a',
1047 'p',0 };
1048 static const WCHAR cmsrc2wrap[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
1049 static const WCHAR des[] = { 'd','e','s',0 };
1050 static const WCHAR md2[] = { 'm','d','2',0 };
1051 static const WCHAR md4[] = { 'm','d','4',0 };
1052 static const WCHAR md5[] = { 'm','d','5',0 };
1053 static const WCHAR rc2[] = { 'r','c','2',0 };
1054 static const WCHAR rc4[] = { 'r','c','4',0 };
1055 static const WCHAR sha[] = { 's','h','a',0 };
1056 static const WCHAR sha1[] = { 's','h','a','1',0 };
1057 static const WCHAR sha256[] = { 's','h','a','2','5','6',0 };
1058 static const WCHAR sha384[] = { 's','h','a','3','8','4',0 };
1059 static const WCHAR sha512[] = { 's','h','a','5','1','2',0 };
1060 static const WCHAR RSA[] = { 'R','S','A',0 };
1061 static const WCHAR RSA_KEYX[] = { 'R','S','A','_','K','E','Y','X',0 };
1062 static const WCHAR RSA_SIGN[] = { 'R','S','A','_','S','I','G','N',0 };
1063 static const WCHAR DSA[] = { 'D','S','A',0 };
1064 static const WCHAR DSA_SIGN[] = { 'D','S','A','_','S','I','G','N',0 };
1065 static const WCHAR DH[] = { 'D','H',0 };
1066 static const WCHAR DSS[] = { 'D','S','S',0 };
1067 static const WCHAR mosaicKMandUpdSig[] =
1068 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
1069 static const WCHAR ESDH[] = { 'E','S','D','H',0 };
1070 static const WCHAR NO_SIGN[] = { 'N','O','S','I','G','N',0 };
1071 static const WCHAR dsaSHA1[] = { 'd','s','a','S','H','A','1',0 };
1072 static const WCHAR md2RSA[] = { 'm','d','2','R','S','A',0 };
1073 static const WCHAR md4RSA[] = { 'm','d','4','R','S','A',0 };
1074 static const WCHAR md5RSA[] = { 'm','d','5','R','S','A',0 };
1075 static const WCHAR shaDSA[] = { 's','h','a','D','S','A',0 };
1076 static const WCHAR sha1DSA[] = { 's','h','a','1','D','S','A',0 };
1077 static const WCHAR shaRSA[] = { 's','h','a','R','S','A',0 };
1078 static const WCHAR sha1RSA[] = { 's','h','a','1','R','S','A',0 };
1079 static const WCHAR sha256RSA[] = { 's','h','a','2','5','6','R','S','A',0 };
1080 static const WCHAR sha384RSA[] = { 's','h','a','3','8','4','R','S','A',0 };
1081 static const WCHAR sha512RSA[] = { 's','h','a','5','1','2','R','S','A',0 };
1082 static const WCHAR mosaicUpdatedSig[] =
1083 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
1084 static const WCHAR sha256ECDSA[] = { 's','h','a','2','5','6','E','C','D','S','A',0 };
1085 static const WCHAR sha384ECDSA[] = { 's','h','a','3','8','4','E','C','D','S','A',0 };
1086 static const WCHAR CN[] = { 'C','N',0 };
1087 static const WCHAR L[] = { 'L',0 };
1088 static const WCHAR O[] = { 'O',0 };
1089 static const WCHAR OU[] = { 'O','U',0 };
1090 static const WCHAR E[] = { 'E',0 };
1091 static const WCHAR C[] = { 'C',0 };
1092 static const WCHAR S[] = { 'S',0 };
1093 static const WCHAR ST[] = { 'S','T',0 };
1094 static const WCHAR STREET[] = { 'S','T','R','E','E','T',0 };
1095 static const WCHAR T[] = { 'T',0 };
1096 static const WCHAR Title[] = { 'T','i','t','l','e',0 };
1097 static const WCHAR G[] = { 'G',0 };
1098 static const WCHAR GivenName[] = { 'G','i','v','e','n','N','a','m','e',0 };
1099 static const WCHAR I[] = { 'I',0 };
1100 static const WCHAR Initials[] = { 'I','n','i','t','i','a','l','s',0 };
1101 static const WCHAR SN[] = { 'S','N',0 };
1102 static const WCHAR DC[] = { 'D','C',0 };
1103 static const WCHAR Description[] =
1104 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
1105 static const WCHAR PostalCode[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
1106 static const WCHAR POBox[] = { 'P','O','B','o','x',0 };
1107 static const WCHAR Phone[] = { 'P','h','o','n','e',0 };
1108 static const WCHAR X21Address[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
1109 static const WCHAR dnQualifier[] =
1110 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
1111 static const WCHAR SpcSpAgencyInfo[] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 };
1112 static const WCHAR SpcFinancialCriteria[] = { 'S','p','c','F','i','n','a','n','c','i','a','l','C','r','i','t','e','r','i','a',0 };
1113 static const WCHAR SpcMinimalCriteria[] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 };
1114 static const WCHAR Email[] = { 'E','m','a','i','l',0 };
1115 static const WCHAR GN[] = { 'G','N',0 };
1116 static const WCHAR SERIALNUMBER[] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 };
1117
1118 static const DWORD noNullFlag = CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG;
1119 static const DWORD mosaicFlags = CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG |
1120 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG;
1121 static const CRYPT_DATA_BLOB noNullBlob = { sizeof(noNullFlag),
1122 (LPBYTE)&noNullFlag };
1123 static const CRYPT_DATA_BLOB mosaicFlagsBlob = { sizeof(mosaicFlags),
1124 (LPBYTE)&mosaicFlags };
1125
1126 static const DWORD rsaSign = CALG_RSA_SIGN;
1127 static const DWORD dssSign[2] = { CALG_DSS_SIGN,
1128 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG };
1129 static const DWORD mosaicSign[2] = { CALG_DSS_SIGN,
1130 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG |
1131 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG };
1132 static const DWORD ecdsaSign[2] = { CALG_OID_INFO_PARAMETERS,
1133 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG };
1134 static const CRYPT_DATA_BLOB rsaSignBlob = { sizeof(rsaSign),
1135 (LPBYTE)&rsaSign };
1136 static const CRYPT_DATA_BLOB dssSignBlob = { sizeof(dssSign),
1137 (LPBYTE)dssSign };
1138 static const CRYPT_DATA_BLOB mosaicSignBlob = { sizeof(mosaicSign),
1139 (LPBYTE)mosaicSign };
1140 static const CRYPT_DATA_BLOB ecdsaSignBlob = { sizeof(ecdsaSign),
1141 (LPBYTE)ecdsaSign };
1142
1143 static const DWORD ia5String[] = { CERT_RDN_IA5_STRING, 0 };
1144 static const DWORD numericString[] = { CERT_RDN_NUMERIC_STRING, 0 };
1145 static const DWORD printableString[] = { CERT_RDN_PRINTABLE_STRING, 0 };
1146 static const DWORD domainCompTypes[] = { CERT_RDN_IA5_STRING,
1147 CERT_RDN_UTF8_STRING, 0 };
1148 static const CRYPT_DATA_BLOB ia5StringBlob = { sizeof(ia5String),
1149 (LPBYTE)ia5String };
1150 static const CRYPT_DATA_BLOB numericStringBlob = { sizeof(numericString),
1151 (LPBYTE)numericString };
1152 static const CRYPT_DATA_BLOB printableStringBlob = { sizeof(printableString),
1153 (LPBYTE)printableString };
1154 static const CRYPT_DATA_BLOB domainCompTypesBlob = { sizeof(domainCompTypes),
1155 (LPBYTE)domainCompTypes };
1156
1157 static const struct OIDInfoConstructor {
1158 DWORD dwGroupId;
1159 LPCSTR pszOID;
1160 UINT Algid;
1161 LPCWSTR pwszName;
1162 const CRYPT_DATA_BLOB *blob;
1163 LPCWSTR pwszCNGAlgid;
1164 LPCWSTR pwszCNGExtraAlgid;
1165 } oidInfoConstructors[] = {
1166 { 1, szOID_OIWSEC_sha1, CALG_SHA1, sha1, NULL },
1167 { 1, szOID_OIWSEC_sha1, CALG_SHA1, sha, NULL },
1168 { 1, szOID_OIWSEC_sha, CALG_SHA, sha, NULL },
1169 { 1, szOID_RSA_MD5, CALG_MD5, md5, NULL },
1170 { 1, szOID_RSA_MD4, CALG_MD4, md4, NULL },
1171 { 1, szOID_RSA_MD2, CALG_MD2, md2, NULL },
1172 /* NOTE: Windows Vista+ uses -1 instead of CALG_SHA_* following SHA entries. */
1173 { 1, szOID_NIST_sha256, CALG_SHA_256, sha256, NULL },
1174 { 1, szOID_NIST_sha384, CALG_SHA_384, sha384, NULL },
1175 { 1, szOID_NIST_sha512, CALG_SHA_512, sha512, NULL },
1176
1177 { 2, szOID_OIWSEC_desCBC, CALG_DES, des, NULL },
1178 { 2, szOID_RSA_DES_EDE3_CBC, CALG_3DES, tripledes, NULL },
1179 { 2, szOID_RSA_RC2CBC, CALG_RC2, rc2, NULL },
1180 { 2, szOID_RSA_RC4, CALG_RC4, rc4, NULL },
1181 { 2, szOID_RSA_SMIMEalgCMS3DESwrap, CALG_3DES, cms3deswrap, NULL },
1182 { 2, szOID_RSA_SMIMEalgCMSRC2wrap, CALG_RC2, cmsrc2wrap, NULL },
1183
1184 { 3, szOID_RSA_RSA, CALG_RSA_KEYX, RSA, NULL },
1185 { 3, szOID_X957_DSA, CALG_DSS_SIGN, DSA, &noNullBlob },
1186 { 3, szOID_ANSI_X942_DH, CALG_DH_SF, DH, &noNullBlob },
1187 { 3, szOID_RSA_RSA, CALG_RSA_KEYX, RSA_KEYX, NULL },
1188 { 3, szOID_RSA_RSA, CALG_RSA_SIGN, RSA, NULL },
1189 { 3, szOID_RSA_RSA, CALG_RSA_SIGN, RSA_SIGN, NULL },
1190 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSA, &noNullBlob },
1191 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSS, &noNullBlob },
1192 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSA_SIGN, &noNullBlob },
1193 { 3, szOID_RSA_DH, CALG_DH_SF, DH, &noNullBlob },
1194 { 3, szOID_OIWSEC_rsaXchg, CALG_RSA_KEYX, RSA_KEYX, NULL },
1195 { 3, szOID_INFOSEC_mosaicKMandUpdSig, CALG_DSS_SIGN, mosaicKMandUpdSig,
1196 &mosaicFlagsBlob },
1197 { 3, szOID_RSA_SMIMEalgESDH, CALG_DH_EPHEM, ESDH, &noNullBlob },
1198 { 3, szOID_PKIX_NO_SIGNATURE, CALG_NO_SIGN, NO_SIGN, NULL },
1199
1200 { 4, szOID_RSA_SHA1RSA, CALG_SHA1, sha1RSA, &rsaSignBlob },
1201 { 4, szOID_RSA_SHA256RSA, CALG_SHA_256, sha256RSA, &rsaSignBlob },
1202 { 4, szOID_RSA_SHA384RSA, CALG_SHA_384, sha384RSA, &rsaSignBlob },
1203 { 4, szOID_RSA_SHA512RSA, CALG_SHA_512, sha512RSA, &rsaSignBlob },
1204 { 4, szOID_RSA_MD5RSA, CALG_MD5, md5RSA, &rsaSignBlob },
1205 { 4, szOID_X957_SHA1DSA, CALG_SHA1, sha1DSA, &dssSignBlob },
1206 { 4, szOID_OIWSEC_sha1RSASign, CALG_SHA1, sha1RSA, &rsaSignBlob },
1207 { 4, szOID_OIWSEC_sha1RSASign, CALG_SHA1, shaRSA, &rsaSignBlob },
1208 { 4, szOID_OIWSEC_shaRSA, CALG_SHA1, shaRSA, &rsaSignBlob },
1209 { 4, szOID_OIWSEC_md5RSA, CALG_MD5, md5RSA, &rsaSignBlob },
1210 { 4, szOID_RSA_MD2RSA, CALG_MD2, md2RSA, &rsaSignBlob },
1211 { 4, szOID_RSA_MD4RSA, CALG_MD4, md4RSA, &rsaSignBlob },
1212 { 4, szOID_OIWSEC_md4RSA, CALG_MD4, md4RSA, &rsaSignBlob },
1213 { 4, szOID_OIWSEC_md4RSA2, CALG_MD4, md4RSA, &rsaSignBlob },
1214 { 4, szOID_OIWDIR_md2RSA, CALG_MD2, md2RSA, &rsaSignBlob },
1215 { 4, szOID_OIWSEC_shaDSA, CALG_SHA1, sha1DSA, &dssSignBlob },
1216 { 4, szOID_OIWSEC_shaDSA, CALG_SHA1, shaDSA, &dssSignBlob },
1217 { 4, szOID_OIWSEC_dsaSHA1, CALG_SHA1, dsaSHA1, &dssSignBlob },
1218 { 4, szOID_INFOSEC_mosaicUpdatedSig, CALG_SHA1, mosaicUpdatedSig,
1219 &mosaicSignBlob },
1220 { 4, szOID_ECDSA_SHA256, CALG_OID_INFO_CNG_ONLY, sha256ECDSA, &ecdsaSignBlob,
1221 BCRYPT_SHA256_ALGORITHM, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM },
1222 { 4, szOID_ECDSA_SHA384, CALG_OID_INFO_CNG_ONLY, sha384ECDSA, &ecdsaSignBlob,
1223 BCRYPT_SHA384_ALGORITHM, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM },
1224
1225 { 5, szOID_COMMON_NAME, 0, CN, NULL },
1226 { 5, szOID_LOCALITY_NAME, 0, L, NULL },
1227 { 5, szOID_ORGANIZATION_NAME, 0, O, NULL },
1228 { 5, szOID_ORGANIZATIONAL_UNIT_NAME, 0, OU, NULL },
1229 { 5, szOID_RSA_emailAddr, 0, E, &ia5StringBlob },
1230 { 5, szOID_RSA_emailAddr, 0, Email, &ia5StringBlob },
1231 { 5, szOID_COUNTRY_NAME, 0, C, &printableStringBlob },
1232 { 5, szOID_STATE_OR_PROVINCE_NAME, 0, S, NULL },
1233 { 5, szOID_STATE_OR_PROVINCE_NAME, 0, ST, NULL },
1234 { 5, szOID_STREET_ADDRESS, 0, STREET, NULL },
1235 { 5, szOID_TITLE, 0, T, NULL },
1236 { 5, szOID_TITLE, 0, Title, NULL },
1237 { 5, szOID_GIVEN_NAME, 0, G, NULL },
1238 { 5, szOID_GIVEN_NAME, 0, GN, NULL },
1239 { 5, szOID_GIVEN_NAME, 0, GivenName, NULL },
1240 { 5, szOID_INITIALS, 0, I, NULL },
1241 { 5, szOID_INITIALS, 0, Initials, NULL },
1242 { 5, szOID_SUR_NAME, 0, SN, NULL },
1243 { 5, szOID_DOMAIN_COMPONENT, 0, DC, &domainCompTypesBlob },
1244 { 5, szOID_DESCRIPTION, 0, Description, NULL },
1245 { 5, szOID_POSTAL_CODE, 0, PostalCode, NULL },
1246 { 5, szOID_POST_OFFICE_BOX, 0, POBox, NULL },
1247 { 5, szOID_TELEPHONE_NUMBER, 0, Phone, &printableStringBlob },
1248 { 5, szOID_X21_ADDRESS, 0, X21Address, &numericStringBlob },
1249 { 5, szOID_DN_QUALIFIER, 0, dnQualifier, NULL },
1250 { 5, szOID_DEVICE_SERIAL_NUMBER, 0, SERIALNUMBER, NULL },
1251
1252 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2, 0, (LPCWSTR)IDS_AUTHORITY_KEY_ID, NULL },
1253 { 6, szOID_AUTHORITY_KEY_IDENTIFIER, 0, (LPCWSTR)IDS_AUTHORITY_KEY_ID, NULL },
1254 { 6, szOID_KEY_ATTRIBUTES, 0, (LPCWSTR)IDS_KEY_ATTRIBUTES, NULL },
1255 { 6, szOID_KEY_USAGE_RESTRICTION, 0, (LPCWSTR)IDS_KEY_USAGE_RESTRICTION, NULL },
1256 { 6, szOID_SUBJECT_ALT_NAME2, 0, (LPCWSTR)IDS_SUBJECT_ALT_NAME, NULL },
1257 { 6, szOID_SUBJECT_ALT_NAME, 0, (LPCWSTR)IDS_SUBJECT_ALT_NAME, NULL },
1258 { 6, szOID_ISSUER_ALT_NAME2, 0, (LPCWSTR)IDS_ISSUER_ALT_NAME, NULL },
1259 { 6, szOID_ISSUER_ALT_NAME2, 0, (LPCWSTR)IDS_ISSUER_ALT_NAME, NULL },
1260 { 6, szOID_BASIC_CONSTRAINTS2, 0, (LPCWSTR)IDS_BASIC_CONSTRAINTS, NULL },
1261 { 6, szOID_BASIC_CONSTRAINTS, 0, (LPCWSTR)IDS_BASIC_CONSTRAINTS, NULL },
1262 { 6, szOID_KEY_USAGE, 0, (LPCWSTR)IDS_KEY_USAGE, NULL },
1263 { 6, szOID_CERT_POLICIES, 0, (LPCWSTR)IDS_CERT_POLICIES, NULL },
1264 { 6, szOID_SUBJECT_KEY_IDENTIFIER, 0, (LPCWSTR)IDS_SUBJECT_KEY_IDENTIFIER, NULL },
1265 { 6, szOID_CRL_REASON_CODE, 0, (LPCWSTR)IDS_CRL_REASON_CODE, NULL },
1266 { 6, szOID_CRL_DIST_POINTS, 0, (LPCWSTR)IDS_CRL_DIST_POINTS, NULL },
1267 { 6, szOID_ENHANCED_KEY_USAGE, 0, (LPCWSTR)IDS_ENHANCED_KEY_USAGE, NULL },
1268 { 6, szOID_AUTHORITY_INFO_ACCESS, 0, (LPCWSTR)IDS_AUTHORITY_INFO_ACCESS, NULL },
1269 { 6, szOID_CERT_EXTENSIONS, 0, (LPCWSTR)IDS_CERT_EXTENSIONS, NULL },
1270 { 6, szOID_RSA_certExtensions, 0, (LPCWSTR)IDS_CERT_EXTENSIONS, NULL },
1271 { 6, szOID_NEXT_UPDATE_LOCATION, 0, (LPCWSTR)IDS_NEXT_UPDATE_LOCATION, NULL },
1272 { 6, szOID_YESNO_TRUST_ATTR, 0, (LPCWSTR)IDS_YES_OR_NO_TRUST, NULL },
1273 { 6, szOID_RSA_emailAddr, 0, (LPCWSTR)IDS_EMAIL_ADDRESS, NULL },
1274 { 6, szOID_RSA_unstructName, 0, (LPCWSTR)IDS_UNSTRUCTURED_NAME, NULL },
1275 { 6, szOID_RSA_contentType, 0, (LPCWSTR)IDS_CONTENT_TYPE, NULL },
1276 { 6, szOID_RSA_messageDigest, 0, (LPCWSTR)IDS_MESSAGE_DIGEST, NULL },
1277 { 6, szOID_RSA_signingTime, 0, (LPCWSTR)IDS_SIGNING_TIME, NULL },
1278 { 6, szOID_RSA_counterSign, 0, (LPCWSTR)IDS_COUNTER_SIGN, NULL },
1279 { 6, szOID_RSA_challengePwd, 0, (LPCWSTR)IDS_CHALLENGE_PASSWORD, NULL },
1280 { 6, szOID_RSA_unstructAddr, 0, (LPCWSTR)IDS_UNSTRUCTURED_ADDRESS, NULL },
1281 { 6, szOID_RSA_SMIMECapabilities, 0, (LPCWSTR)IDS_SMIME_CAPABILITIES, NULL },
1282 { 6, szOID_RSA_preferSignedData, 0, (LPCWSTR)IDS_PREFER_SIGNED_DATA, NULL },
1283 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS, 0, (LPCWSTR)IDS_CPS, NULL },
1284 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE, 0, (LPCWSTR)IDS_USER_NOTICE, NULL },
1285 { 6, szOID_PKIX_OCSP, 0, (LPCWSTR)IDS_OCSP, NULL },
1286 { 6, szOID_PKIX_CA_ISSUERS, 0, (LPCWSTR)IDS_CA_ISSUER, NULL },
1287 { 6, szOID_ENROLL_CERTTYPE_EXTENSION, 0, (LPCWSTR)IDS_CERT_TEMPLATE_NAME, NULL },
1288 { 6, szOID_ENROLL_CERTTYPE_EXTENSION, 0, (LPCWSTR)IDS_CERT_TYPE, NULL },
1289 { 6, szOID_CERT_MANIFOLD, 0, (LPCWSTR)IDS_CERT_MANIFOLD, NULL },
1290 { 6, szOID_NETSCAPE_CERT_TYPE, 0, (LPCWSTR)IDS_NETSCAPE_CERT_TYPE, NULL },
1291 { 6, szOID_NETSCAPE_BASE_URL, 0, (LPCWSTR)IDS_NETSCAPE_BASE_URL, NULL },
1292 { 6, szOID_NETSCAPE_REVOCATION_URL, 0, (LPCWSTR)IDS_NETSCAPE_REVOCATION_URL, NULL },
1293 { 6, szOID_NETSCAPE_CA_REVOCATION_URL, 0, (LPCWSTR)IDS_NETSCAPE_CA_REVOCATION_URL, NULL },
1294 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL, 0, (LPCWSTR)IDS_NETSCAPE_CERT_RENEWAL_URL, NULL },
1295 { 6, szOID_NETSCAPE_CA_POLICY_URL, 0, (LPCWSTR)IDS_NETSCAPE_CA_POLICY_URL, NULL },
1296 { 6, szOID_NETSCAPE_SSL_SERVER_NAME, 0, (LPCWSTR)IDS_NETSCAPE_SSL_SERVER_NAME, NULL },
1297 { 6, szOID_NETSCAPE_COMMENT, 0, (LPCWSTR)IDS_NETSCAPE_COMMENT, NULL },
1298 { 6, "1.3.6.1.4.1.311.2.1.10", 0, SpcSpAgencyInfo, NULL },
1299 { 6, "1.3.6.1.4.1.311.2.1.27", 0, SpcFinancialCriteria, NULL },
1300 { 6, "1.3.6.1.4.1.311.2.1.26", 0, SpcMinimalCriteria, NULL },
1301 { 6, szOID_COUNTRY_NAME, 0, (LPCWSTR)IDS_COUNTRY, NULL },
1302 { 6, szOID_ORGANIZATION_NAME, 0, (LPCWSTR)IDS_ORGANIZATION, NULL },
1303 { 6, szOID_ORGANIZATIONAL_UNIT_NAME, 0, (LPCWSTR)IDS_ORGANIZATIONAL_UNIT, NULL },
1304 { 6, szOID_COMMON_NAME, 0, (LPCWSTR)IDS_COMMON_NAME, NULL },
1305 { 6, szOID_LOCALITY_NAME, 0, (LPCWSTR)IDS_LOCALITY, NULL },
1306 { 6, szOID_STATE_OR_PROVINCE_NAME, 0, (LPCWSTR)IDS_STATE_OR_PROVINCE, NULL },
1307 { 6, szOID_TITLE, 0, (LPCWSTR)IDS_TITLE, NULL },
1308 { 6, szOID_GIVEN_NAME, 0, (LPCWSTR)IDS_GIVEN_NAME, NULL },
1309 { 6, szOID_INITIALS, 0, (LPCWSTR)IDS_INITIALS, NULL },
1310 { 6, szOID_SUR_NAME, 0, (LPCWSTR)IDS_SUR_NAME, NULL },
1311 { 6, szOID_DOMAIN_COMPONENT, 0, (LPCWSTR)IDS_DOMAIN_COMPONENT, NULL },
1312 { 6, szOID_STREET_ADDRESS, 0, (LPCWSTR)IDS_STREET_ADDRESS, NULL },
1313 { 6, szOID_DEVICE_SERIAL_NUMBER, 0, (LPCWSTR)IDS_SERIAL_NUMBER, NULL },
1314 { 6, szOID_CERTSRV_CA_VERSION, 0, (LPCWSTR)IDS_CA_VERSION, NULL },
1315 { 6, szOID_CERTSRV_CROSSCA_VERSION, 0, (LPCWSTR)IDS_CROSS_CA_VERSION, NULL },
1316 { 6, szOID_SERIALIZED, 0, (LPCWSTR)IDS_SERIALIZED_SIG_SERIAL_NUMBER, NULL },
1317 { 6, szOID_NT_PRINCIPAL_NAME, 0, (LPCWSTR)IDS_PRINCIPAL_NAME, NULL },
1318 { 6, szOID_PRODUCT_UPDATE, 0, (LPCWSTR)IDS_WINDOWS_PRODUCT_UPDATE, NULL },
1319 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR, 0, (LPCWSTR)IDS_ENROLLMENT_NAME_VALUE_PAIR, NULL },
1320 { 6, szOID_OS_VERSION, 0, (LPCWSTR)IDS_OS_VERSION, NULL },
1321 { 6, szOID_ENROLLMENT_CSP_PROVIDER, 0, (LPCWSTR)IDS_ENROLLMENT_CSP, NULL },
1322 { 6, szOID_CRL_NUMBER, 0, (LPCWSTR)IDS_CRL_NUMBER, NULL },
1323 { 6, szOID_DELTA_CRL_INDICATOR, 0, (LPCWSTR)IDS_DELTA_CRL_INDICATOR, NULL },
1324 { 6, szOID_ISSUING_DIST_POINT, 0, (LPCWSTR)IDS_ISSUING_DIST_POINT, NULL },
1325 { 6, szOID_FRESHEST_CRL, 0, (LPCWSTR)IDS_FRESHEST_CRL, NULL },
1326 { 6, szOID_NAME_CONSTRAINTS, 0, (LPCWSTR)IDS_NAME_CONSTRAINTS, NULL },
1327 { 6, szOID_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_POLICY_MAPPINGS, NULL },
1328 { 6, szOID_LEGACY_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_POLICY_MAPPINGS, NULL },
1329 { 6, szOID_POLICY_CONSTRAINTS, 0, (LPCWSTR)IDS_POLICY_CONSTRAINTS, NULL },
1330 { 6, szOID_CROSS_CERT_DIST_POINTS, 0, (LPCWSTR)IDS_CROSS_CERT_DIST_POINTS, NULL },
1331 { 6, szOID_APPLICATION_CERT_POLICIES, 0, (LPCWSTR)IDS_APPLICATION_POLICIES, NULL },
1332 { 6, szOID_APPLICATION_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_APPLICATION_POLICY_MAPPINGS, NULL },
1333 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS, 0, (LPCWSTR)IDS_APPLICATION_POLICY_CONSTRAINTS, NULL },
1334 { 6, szOID_CT_PKI_DATA, 0, (LPCWSTR)IDS_CMC_DATA, NULL },
1335 { 6, szOID_CT_PKI_RESPONSE, 0, (LPCWSTR)IDS_CMC_RESPONSE, NULL },
1336 { 6, szOID_CMC, 0, (LPCWSTR)IDS_UNSIGNED_CMC_REQUEST, NULL },
1337 { 6, szOID_CMC_STATUS_INFO, 0, (LPCWSTR)IDS_CMC_STATUS_INFO, NULL },
1338 { 6, szOID_CMC_ADD_EXTENSIONS, 0, (LPCWSTR)IDS_CMC_EXTENSIONS, NULL },
1339 { 6, szOID_CTL, 0, (LPCWSTR)IDS_CMC_ATTRIBUTES, NULL },
1340 { 6, szOID_RSA_data, 0, (LPCWSTR)IDS_PKCS_7_DATA, NULL },
1341 { 6, szOID_RSA_signedData, 0, (LPCWSTR)IDS_PKCS_7_SIGNED, NULL },
1342 { 6, szOID_RSA_envelopedData, 0, (LPCWSTR)IDS_PKCS_7_ENVELOPED, NULL },
1343 { 6, szOID_RSA_signEnvData, 0, (LPCWSTR)IDS_PKCS_7_SIGNED_ENVELOPED, NULL },
1344 { 6, szOID_RSA_digestedData, 0, (LPCWSTR)IDS_PKCS_7_DIGESTED, NULL },
1345 { 6, szOID_RSA_encryptedData, 0, (LPCWSTR)IDS_PKCS_7_ENCRYPTED, NULL },
1346 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH, 0, (LPCWSTR)IDS_PREVIOUS_CA_CERT_HASH, NULL },
1347 { 6, szOID_CRL_VIRTUAL_BASE, 0, (LPCWSTR)IDS_CRL_VIRTUAL_BASE, NULL },
1348 { 6, szOID_CRL_NEXT_PUBLISH, 0, (LPCWSTR)IDS_CRL_NEXT_PUBLISH, NULL },
1349 { 6, szOID_KP_CA_EXCHANGE, 0, (LPCWSTR)IDS_CA_EXCHANGE, NULL },
1350 { 6, szOID_KP_KEY_RECOVERY_AGENT, 0, (LPCWSTR)IDS_KEY_RECOVERY_AGENT, NULL },
1351 { 6, szOID_CERTIFICATE_TEMPLATE, 0, (LPCWSTR)IDS_CERTIFICATE_TEMPLATE, NULL },
1352 { 6, szOID_ENTERPRISE_OID_ROOT, 0, (LPCWSTR)IDS_ENTERPRISE_ROOT_OID, NULL },
1353 { 6, szOID_RDN_DUMMY_SIGNER, 0, (LPCWSTR)IDS_RDN_DUMMY_SIGNER, NULL },
1354 { 6, szOID_ARCHIVED_KEY_ATTR, 0, (LPCWSTR)IDS_ARCHIVED_KEY_ATTR, NULL },
1355 { 6, szOID_CRL_SELF_CDP, 0, (LPCWSTR)IDS_CRL_SELF_CDP, NULL },
1356 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY, 0, (LPCWSTR)IDS_REQUIRE_CERT_CHAIN_POLICY, NULL },
1357 { 6, szOID_CMC_TRANSACTION_ID, 0, (LPCWSTR)IDS_TRANSACTION_ID, NULL },
1358 { 6, szOID_CMC_SENDER_NONCE, 0, (LPCWSTR)IDS_SENDER_NONCE, NULL },
1359 { 6, szOID_CMC_RECIPIENT_NONCE, 0, (LPCWSTR)IDS_RECIPIENT_NONCE, NULL },
1360 { 6, szOID_CMC_REG_INFO, 0, (LPCWSTR)IDS_REG_INFO, NULL },
1361 { 6, szOID_CMC_GET_CERT, 0, (LPCWSTR)IDS_GET_CERTIFICATE, NULL },
1362 { 6, szOID_CMC_GET_CRL, 0, (LPCWSTR)IDS_GET_CRL, NULL },
1363 { 6, szOID_CMC_REVOKE_REQUEST, 0, (LPCWSTR)IDS_REVOKE_REQUEST, NULL },
1364 { 6, szOID_CMC_QUERY_PENDING, 0, (LPCWSTR)IDS_QUERY_PENDING, NULL },
1365 { 6, szOID_SORTED_CTL, 0, (LPCWSTR)IDS_SORTED_CTL, NULL },
1366 { 6, szOID_ARCHIVED_KEY_CERT_HASH, 0, (LPCWSTR)IDS_ARCHIVED_KEY_CERT_HASH, NULL },
1367 { 6, szOID_PRIVATEKEY_USAGE_PERIOD, 0, (LPCWSTR)IDS_PRIVATE_KEY_USAGE_PERIOD, NULL },
1368 { 6, szOID_REQUEST_CLIENT_INFO, 0, (LPCWSTR)IDS_CLIENT_INFORMATION, NULL },
1369
1370 { 7, szOID_PKIX_KP_SERVER_AUTH, 0, (LPCWSTR)IDS_SERVER_AUTHENTICATION, NULL },
1371 { 7, szOID_PKIX_KP_CLIENT_AUTH, 0, (LPCWSTR)IDS_CLIENT_AUTHENTICATION, NULL },
1372 { 7, szOID_PKIX_KP_CODE_SIGNING, 0, (LPCWSTR)IDS_CODE_SIGNING, NULL },
1373 { 7, szOID_PKIX_KP_EMAIL_PROTECTION, 0, (LPCWSTR)IDS_SECURE_EMAIL, NULL },
1374 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING, 0, (LPCWSTR)IDS_TIME_STAMPING, NULL },
1375 { 7, szOID_KP_CTL_USAGE_SIGNING, 0, (LPCWSTR)IDS_MICROSOFT_TRUST_LIST_SIGNING, NULL },
1376 { 7, szOID_KP_TIME_STAMP_SIGNING, 0, (LPCWSTR)IDS_MICROSOFT_TIME_STAMPING, NULL },
1377 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM, 0, (LPCWSTR)IDS_IPSEC_END_SYSTEM, NULL },
1378 { 7, szOID_PKIX_KP_IPSEC_TUNNEL, 0, (LPCWSTR)IDS_IPSEC_TUNNEL, NULL },
1379 { 7, szOID_PKIX_KP_IPSEC_USER, 0, (LPCWSTR)IDS_IPSEC_USER, NULL },
1380 { 7, szOID_KP_EFS, 0, (LPCWSTR)IDS_EFS, NULL },
1381 { 7, szOID_WHQL_CRYPTO, 0, (LPCWSTR)IDS_WHQL_CRYPTO, NULL },
1382 { 7, szOID_NT5_CRYPTO, 0, (LPCWSTR)IDS_NT5_CRYPTO, NULL },
1383 { 7, szOID_OEM_WHQL_CRYPTO, 0, (LPCWSTR)IDS_OEM_WHQL_CRYPTO, NULL },
1384 { 7, szOID_EMBEDDED_NT_CRYPTO, 0, (LPCWSTR)IDS_EMBEDDED_NT_CRYPTO, NULL },
1385 { 7, szOID_LICENSES, 0, (LPCWSTR)IDS_KEY_PACK_LICENSES, NULL },
1386 { 7, szOID_LICENSE_SERVER, 0, (LPCWSTR)IDS_LICENSE_SERVER, NULL },
1387 { 7, szOID_KP_SMARTCARD_LOGON, 0, (LPCWSTR)IDS_SMART_CARD_LOGON, NULL },
1388 { 7, szOID_DRM, 0, (LPCWSTR)IDS_DIGITAL_RIGHTS, NULL },
1389 { 7, szOID_KP_QUALIFIED_SUBORDINATION, 0, (LPCWSTR)IDS_QUALIFIED_SUBORDINATION, NULL },
1390 { 7, szOID_KP_KEY_RECOVERY, 0, (LPCWSTR)IDS_KEY_RECOVERY, NULL },
1391 { 7, szOID_KP_DOCUMENT_SIGNING, 0, (LPCWSTR)IDS_DOCUMENT_SIGNING, NULL },
1392 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE, 0, (LPCWSTR)IDS_IPSEC_IKE_INTERMEDIATE, NULL },
1393 { 7, szOID_EFS_RECOVERY, 0, (LPCWSTR)IDS_FILE_RECOVERY, NULL },
1394 { 7, szOID_ROOT_LIST_SIGNER, 0, (LPCWSTR)IDS_ROOT_LIST_SIGNER, NULL },
1395 { 7, szOID_ANY_APPLICATION_POLICY, 0, (LPCWSTR)IDS_ANY_APPLICATION_POLICIES, NULL },
1396 { 7, szOID_DS_EMAIL_REPLICATION, 0, (LPCWSTR)IDS_DS_EMAIL_REPLICATION, NULL },
1397 { 7, szOID_ENROLLMENT_AGENT, 0, (LPCWSTR)IDS_ENROLLMENT_AGENT, NULL },
1398 { 7, szOID_KP_KEY_RECOVERY_AGENT, 0, (LPCWSTR)IDS_KEY_RECOVERY_AGENT, NULL },
1399 { 7, szOID_KP_CA_EXCHANGE, 0, (LPCWSTR)IDS_CA_EXCHANGE, NULL },
1400 { 7, szOID_KP_LIFETIME_SIGNING, 0, (LPCWSTR)IDS_LIFETIME_SIGNING, NULL },
1401
1402 { 8, szOID_ANY_CERT_POLICY, 0, (LPCWSTR)IDS_ANY_CERT_POLICY, NULL },
1403 };
1404
1405 struct OIDInfo {
1406 CRYPT_OID_INFO info;
1407 struct list entry;
1408 };
1409
1410 static void init_oid_info(void)
1411 {
1412 DWORD i;
1413
1414 oid_init_localizednames();
1415 for (i = 0; i < sizeof(oidInfoConstructors) /
1416 sizeof(oidInfoConstructors[0]); i++)
1417 {
1418 if (!IS_INTRESOURCE(oidInfoConstructors[i].pwszName))
1419 {
1420 struct OIDInfo *info;
1421
1422 /* The name is a static string, so just use the same pointer */
1423 info = CryptMemAlloc(sizeof(struct OIDInfo));
1424 if (info)
1425 {
1426 memset(info, 0, sizeof(*info));
1427 info->info.cbSize = sizeof(CRYPT_OID_INFO);
1428 info->info.pszOID = oidInfoConstructors[i].pszOID;
1429 info->info.pwszName = oidInfoConstructors[i].pwszName;
1430 info->info.dwGroupId = oidInfoConstructors[i].dwGroupId;
1431 info->info.u.Algid = oidInfoConstructors[i].Algid;
1432 if (oidInfoConstructors[i].blob)
1433 {
1434 info->info.ExtraInfo.cbData =
1435 oidInfoConstructors[i].blob->cbData;
1436 info->info.ExtraInfo.pbData =
1437 oidInfoConstructors[i].blob->pbData;
1438 }
1439 info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid;
1440 info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid;
1441 list_add_tail(&oidInfo, &info->entry);
1442 }
1443 }
1444 else
1445 {
1446 LPCWSTR stringresource;
1447 int len = LoadStringW(hInstance,
1448 (UINT_PTR)oidInfoConstructors[i].pwszName,
1449 (LPWSTR)&stringresource, 0);
1450
1451 if (len)
1452 {
1453 struct OIDInfo *info = CryptMemAlloc(sizeof(struct OIDInfo) +
1454 (len + 1) * sizeof(WCHAR));
1455
1456 if (info)
1457 {
1458 memset(info, 0, sizeof(*info));
1459 info->info.cbSize = sizeof(CRYPT_OID_INFO);
1460 info->info.pszOID = oidInfoConstructors[i].pszOID;
1461 info->info.pwszName = (LPWSTR)(info + 1);
1462 info->info.dwGroupId = oidInfoConstructors[i].dwGroupId;
1463 info->info.u.Algid = oidInfoConstructors[i].Algid;
1464 memcpy(info + 1, stringresource, len*sizeof(WCHAR));
1465 ((LPWSTR)(info + 1))[len] = 0;
1466 if (oidInfoConstructors[i].blob)
1467 {
1468 info->info.ExtraInfo.cbData =
1469 oidInfoConstructors[i].blob->cbData;
1470 info->info.ExtraInfo.pbData =
1471 oidInfoConstructors[i].blob->pbData;
1472 }
1473 info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid;
1474 info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid;
1475 list_add_tail(&oidInfo, &info->entry);
1476 }
1477 }
1478 }
1479 }
1480 }
1481
1482 static void free_oid_info(void)
1483 {
1484 struct OIDInfo *info, *next;
1485
1486 LIST_FOR_EACH_ENTRY_SAFE(info, next, &oidInfo, struct OIDInfo, entry)
1487 {
1488 list_remove(&info->entry);
1489 CryptMemFree(info);
1490 }
1491 DeleteCriticalSection(&oidInfoCS);
1492 }
1493
1494 /***********************************************************************
1495 * CryptEnumOIDInfo (CRYPT32.@)
1496 */
1497 BOOL WINAPI CryptEnumOIDInfo(DWORD dwGroupId, DWORD dwFlags, void *pvArg,
1498 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo)
1499 {
1500 BOOL ret = TRUE;
1501 struct OIDInfo *info;
1502
1503 TRACE("(%d, %08x, %p, %p)\n", dwGroupId, dwFlags, pvArg,
1504 pfnEnumOIDInfo);
1505
1506 EnterCriticalSection(&oidInfoCS);
1507 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
1508 {
1509 if (!dwGroupId || dwGroupId == info->info.dwGroupId)
1510 {
1511 ret = pfnEnumOIDInfo(&info->info, pvArg);
1512 if (!ret)
1513 break;
1514 }
1515 }
1516 LeaveCriticalSection(&oidInfoCS);
1517 return ret;
1518 }
1519
1520 PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey,
1521 DWORD dwGroupId)
1522 {
1523 PCCRYPT_OID_INFO ret = NULL;
1524
1525 TRACE("(%d, %p, %d)\n", dwKeyType, pvKey, dwGroupId);
1526
1527 switch(dwKeyType)
1528 {
1529 case CRYPT_OID_INFO_ALGID_KEY:
1530 {
1531 struct OIDInfo *info;
1532
1533 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey);
1534 EnterCriticalSection(&oidInfoCS);
1535 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
1536 {
1537 if (info->info.u.Algid == *(DWORD *)pvKey &&
1538 (!dwGroupId || info->info.dwGroupId == dwGroupId))
1539 {
1540 ret = &info->info;
1541 break;
1542 }
1543 }
1544 LeaveCriticalSection(&oidInfoCS);
1545 break;
1546 }
1547 case CRYPT_OID_INFO_NAME_KEY:
1548 {
1549 struct OIDInfo *info;
1550
1551 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey));
1552 EnterCriticalSection(&oidInfoCS);
1553 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
1554 {
1555 if (!lstrcmpW(info->info.pwszName, pvKey) &&
1556 (!dwGroupId || info->info.dwGroupId == dwGroupId))
1557 {
1558 ret = &info->info;
1559 break;
1560 }
1561 }
1562 LeaveCriticalSection(&oidInfoCS);
1563 break;
1564 }
1565 case CRYPT_OID_INFO_OID_KEY:
1566 {
1567 struct OIDInfo *info;
1568 LPSTR oid = pvKey;
1569
1570 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid));
1571 EnterCriticalSection(&oidInfoCS);
1572 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
1573 {
1574 if (!lstrcmpA(info->info.pszOID, oid) &&
1575 (!dwGroupId || info->info.dwGroupId == dwGroupId))
1576 {
1577 ret = &info->info;
1578 break;
1579 }
1580 }
1581 LeaveCriticalSection(&oidInfoCS);
1582 break;
1583 }
1584 case CRYPT_OID_INFO_SIGN_KEY:
1585 {
1586 struct OIDInfo *info;
1587
1588 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey);
1589 EnterCriticalSection(&oidInfoCS);
1590 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
1591 {
1592 if (info->info.u.Algid == *(DWORD *)pvKey &&
1593 info->info.ExtraInfo.cbData >= sizeof(DWORD) &&
1594 *(DWORD *)info->info.ExtraInfo.pbData ==
1595 *(DWORD *)((LPBYTE)pvKey + sizeof(DWORD)) &&
1596 (!dwGroupId || info->info.dwGroupId == dwGroupId))
1597 {
1598 ret = &info->info;
1599 break;
1600 }
1601 }
1602 LeaveCriticalSection(&oidInfoCS);
1603 break;
1604 }
1605 }
1606 return ret;
1607 }
1608
1609 LPCSTR WINAPI CertAlgIdToOID(DWORD dwAlgId)
1610 {
1611 LPCSTR ret;
1612 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY,
1613 &dwAlgId, 0);
1614
1615 if (info)
1616 ret = info->pszOID;
1617 else
1618 ret = NULL;
1619 return ret;
1620 }
1621
1622 DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
1623 {
1624 DWORD ret;
1625 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
1626 (void *)pszObjId, 0);
1627
1628 if (info)
1629 ret = info->u.Algid;
1630 else
1631 ret = 0;
1632 return ret;
1633 }
1634
1635 void crypt_oid_init(void)
1636 {
1637 init_oid_info();
1638 }
1639
1640 void crypt_oid_free(void)
1641 {
1642 free_function_sets();
1643 free_oid_info();
1644 }
A free Windows-compatible Operating System