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