2 * Copyright 2002 Mike McCormack for CodeWeavers
3 * Copyright 2005-2006 Juan Lang
4 * Copyright 2018 Dmitry Timoshkov
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
29 #define NONAMELESSUNION
32 #define CRYPT_OID_INFO_HAS_EXTRA_FIELDS
36 #include "wine/debug.h"
37 #include "wine/list.h"
38 #include "crypt32_private.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
43 static const WCHAR DllW
[] = { 'D','l','l',0 };
45 static CRITICAL_SECTION funcSetCS
;
46 static CRITICAL_SECTION_DEBUG funcSetCSDebug
=
49 { &funcSetCSDebug
.ProcessLocksList
, &funcSetCSDebug
.ProcessLocksList
},
50 0, 0, { (DWORD_PTR
)(__FILE__
": funcSetCS") }
52 static CRITICAL_SECTION funcSetCS
= { &funcSetCSDebug
, -1, 0, 0, 0, 0 };
53 static struct list funcSets
= { &funcSets
, &funcSets
};
58 CRITICAL_SECTION cs
; /* protects functions */
59 struct list functions
;
67 CRYPT_OID_FUNC_ENTRY entry
;
71 static const WCHAR ROOT
[] = {'R','O','O','T',0};
72 static const WCHAR MY
[] = {'M','Y',0};
73 static const WCHAR CA
[] = {'C','A',0};
74 static const WCHAR ADDRESSBOOK
[] = {'A','D','D','R','E','S','S','B','O','O','K',0};
75 static const WCHAR TRUSTEDPUBLISHER
[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0};
76 static const WCHAR DISALLOWED
[] = {'D','i','s','a','l','l','o','w','e','d',0};
77 static const LPCWSTR LocalizedKeys
[] = {ROOT
,MY
,CA
,ADDRESSBOOK
,TRUSTEDPUBLISHER
,DISALLOWED
};
78 static WCHAR LocalizedNames
[ARRAY_SIZE(LocalizedKeys
)][256];
80 static const WCHAR nameW
[] = { 'N','a','m','e',0 };
81 static const WCHAR algidW
[] = { 'A','l','g','i','d',0 };
82 static const WCHAR extraW
[] = { 'E','x','t','r','a','I','n','f','o',0 };
83 static const WCHAR cngalgidW
[] = { 'C','N','G','A','l','g','i','d',0 };
84 static const WCHAR cngextraalgidW
[] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 };
85 static const WCHAR flagsW
[] = { 'F','l','a','g','s',0 };
87 static void free_function_sets(void)
89 struct OIDFunctionSet
*setCursor
, *setNext
;
91 LIST_FOR_EACH_ENTRY_SAFE(setCursor
, setNext
, &funcSets
,
92 struct OIDFunctionSet
, next
)
94 struct OIDFunction
*functionCursor
, *funcNext
;
96 list_remove(&setCursor
->next
);
97 CryptMemFree(setCursor
->name
);
98 LIST_FOR_EACH_ENTRY_SAFE(functionCursor
, funcNext
,
99 &setCursor
->functions
, struct OIDFunction
, next
)
101 list_remove(&functionCursor
->next
);
102 CryptMemFree(functionCursor
);
104 setCursor
->cs
.DebugInfo
->Spare
[0] = 0;
105 DeleteCriticalSection(&setCursor
->cs
);
106 CryptMemFree(setCursor
);
108 DeleteCriticalSection(&funcSetCS
);
111 /* There is no free function associated with this; therefore, the sets are
112 * freed when crypt32.dll is unloaded.
114 HCRYPTOIDFUNCSET WINAPI
CryptInitOIDFunctionSet(LPCSTR pszFuncName
,
117 struct OIDFunctionSet
*cursor
, *ret
= NULL
;
119 TRACE("(%s, %x)\n", debugstr_a(pszFuncName
), dwFlags
);
121 EnterCriticalSection(&funcSetCS
);
122 LIST_FOR_EACH_ENTRY(cursor
, &funcSets
, struct OIDFunctionSet
, next
)
124 if (!strcasecmp(pszFuncName
, cursor
->name
))
132 ret
= CryptMemAlloc(sizeof(struct OIDFunctionSet
));
135 memset(ret
, 0, sizeof(*ret
));
136 ret
->name
= CryptMemAlloc(strlen(pszFuncName
) + 1);
139 InitializeCriticalSection(&ret
->cs
);
140 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": OIDFunctionSet.cs");
141 list_init(&ret
->functions
);
142 strcpy(ret
->name
, pszFuncName
);
143 list_add_tail(&funcSets
, &ret
->next
);
152 LeaveCriticalSection(&funcSetCS
);
157 static char *CRYPT_GetKeyName(DWORD dwEncodingType
, LPCSTR pszFuncName
,
160 static const char szEncodingTypeFmt
[] =
161 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
163 char numericOID
[7]; /* enough for "#65535" */
167 /* MSDN says the encoding type is a mask, but it isn't treated that way.
168 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
169 * "EncodingType 2" would be expected if it were a mask. Instead native
170 * stores values in "EncodingType 3".
172 if (IS_INTOID(pszOID
))
174 snprintf(numericOID
, sizeof(numericOID
), "#%d", LOWORD(pszOID
));
180 /* This is enough: the lengths of the two string parameters are explicitly
181 * counted, and we need up to five additional characters for the encoding
182 * type. These are covered by the "%d", "%s", and "%s" characters in the
183 * format specifier that are removed by sprintf.
185 len
= sizeof(szEncodingTypeFmt
) + lstrlenA(pszFuncName
) + lstrlenA(oid
);
186 szKey
= CryptMemAlloc(len
);
188 sprintf(szKey
, szEncodingTypeFmt
,
189 GET_CERT_ENCODING_TYPE(dwEncodingType
), pszFuncName
, oid
);
193 BOOL WINAPI
CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet
,
194 DWORD dwEncodingType
, LPWSTR pwszDllList
, DWORD
*pcchDllList
)
197 struct OIDFunctionSet
*set
= hFuncSet
;
202 TRACE("(%p, %d, %p, %p)\n", hFuncSet
, dwEncodingType
, pwszDllList
,
205 keyName
= CRYPT_GetKeyName(dwEncodingType
, set
->name
, "DEFAULT");
206 rc
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0,
207 KEY_READ
, NULL
, &key
, NULL
);
210 DWORD size
= *pcchDllList
* sizeof(WCHAR
);
212 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
, (LPBYTE
)pwszDllList
,
215 *pcchDllList
= size
/ sizeof(WCHAR
);
218 /* No value, return an empty list */
219 if (pwszDllList
&& *pcchDllList
)
227 /* No value, return an empty list */
228 if (pwszDllList
&& *pcchDllList
)
232 CryptMemFree(keyName
);
237 BOOL WINAPI
CryptInstallOIDFunctionAddress(HMODULE hModule
,
238 DWORD dwEncodingType
, LPCSTR pszFuncName
, DWORD cFuncEntry
,
239 const CRYPT_OID_FUNC_ENTRY rgFuncEntry
[], DWORD dwFlags
)
242 struct OIDFunctionSet
*set
;
244 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule
, dwEncodingType
,
245 debugstr_a(pszFuncName
), cFuncEntry
, rgFuncEntry
, dwFlags
);
247 set
= CryptInitOIDFunctionSet(pszFuncName
, 0);
252 EnterCriticalSection(&set
->cs
);
253 for (i
= 0; ret
&& i
< cFuncEntry
; i
++)
255 struct OIDFunction
*func
;
257 TRACE("OID %s, func %p\n", debugstr_a(rgFuncEntry
[i
].pszOID
), rgFuncEntry
[i
].pvFuncAddr
);
259 if (!IS_INTOID(rgFuncEntry
[i
].pszOID
))
260 func
= CryptMemAlloc(sizeof(struct OIDFunction
)
261 + strlen(rgFuncEntry
[i
].pszOID
) + 1);
263 func
= CryptMemAlloc(sizeof(struct OIDFunction
));
266 func
->encoding
= GET_CERT_ENCODING_TYPE(dwEncodingType
);
267 if (!IS_INTOID(rgFuncEntry
[i
].pszOID
))
271 oid
= (LPSTR
)((LPBYTE
)func
+ sizeof(*func
));
272 strcpy(oid
, rgFuncEntry
[i
].pszOID
);
273 func
->entry
.pszOID
= oid
;
276 func
->entry
.pszOID
= rgFuncEntry
[i
].pszOID
;
277 func
->entry
.pvFuncAddr
= rgFuncEntry
[i
].pvFuncAddr
;
278 func
->hModule
= hModule
;
279 list_add_tail(&set
->functions
, &func
->next
);
284 LeaveCriticalSection(&set
->cs
);
298 static BOOL
CRYPT_GetFuncFromReg(DWORD dwEncodingType
, LPCSTR pszOID
,
299 LPCSTR szFuncName
, LPVOID
*ppvFuncAddr
, HCRYPTOIDFUNCADDR
*phFuncAddr
)
303 const char *funcName
;
307 keyName
= CRYPT_GetKeyName(dwEncodingType
, szFuncName
, pszOID
);
308 rc
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, KEY_READ
, &key
);
311 DWORD type
, size
= 0;
313 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
, NULL
, &size
);
314 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
316 funcName
= CryptMemAlloc(size
);
317 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
,
318 (LPBYTE
)funcName
, &size
);
321 funcName
= szFuncName
;
322 rc
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
323 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
325 LPWSTR dllName
= CryptMemAlloc(size
);
329 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
,
330 (LPBYTE
)dllName
, &size
);
335 /* This is a bit of a hack; MSDN describes a more
336 * complicated unload routine than this will allow.
337 * Still, this seems to suffice for now.
339 lib
= LoadLibraryW(dllName
);
342 *ppvFuncAddr
= GetProcAddress(lib
, funcName
);
345 struct FuncAddr
*addr
=
346 CryptMemAlloc(sizeof(struct FuncAddr
));
351 addr
->dllList
= addr
->currentDll
= NULL
;
363 /* Unload the library, the caller doesn't want
364 * to unload it when the return value is NULL.
372 CryptMemFree(dllName
);
377 if (funcName
!= szFuncName
)
378 CryptMemFree((char *)funcName
);
383 CryptMemFree(keyName
);
387 BOOL WINAPI
CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
388 DWORD dwEncodingType
, LPCSTR pszOID
, DWORD dwFlags
, void **ppvFuncAddr
,
389 HCRYPTOIDFUNCADDR
*phFuncAddr
)
392 struct OIDFunctionSet
*set
= hFuncSet
;
394 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
395 debugstr_a(pszOID
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
398 if (!(dwFlags
& CRYPT_GET_INSTALLED_OID_FUNC_FLAG
))
400 struct OIDFunction
*function
;
402 EnterCriticalSection(&set
->cs
);
403 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
405 if (function
->encoding
== GET_CERT_ENCODING_TYPE(dwEncodingType
))
407 if (!IS_INTOID(pszOID
))
409 if (!IS_INTOID(function
->entry
.pszOID
) &&
410 !strcasecmp(function
->entry
.pszOID
, pszOID
))
412 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
413 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
418 else if (function
->entry
.pszOID
== pszOID
)
420 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
421 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
427 LeaveCriticalSection(&set
->cs
);
430 ret
= CRYPT_GetFuncFromReg(dwEncodingType
, pszOID
, set
->name
,
431 ppvFuncAddr
, phFuncAddr
);
432 TRACE("returning %d\n", ret
);
436 static BOOL
is_module_registered(HMODULE hModule
)
438 struct OIDFunctionSet
*set
;
441 EnterCriticalSection(&funcSetCS
);
443 LIST_FOR_EACH_ENTRY(set
, &funcSets
, struct OIDFunctionSet
, next
)
445 struct OIDFunction
*function
;
447 EnterCriticalSection(&set
->cs
);
449 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
451 if (function
->hModule
== hModule
)
458 LeaveCriticalSection(&set
->cs
);
463 LeaveCriticalSection(&funcSetCS
);
468 BOOL WINAPI
CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr
,
471 TRACE("(%p, %08x)\n", hFuncAddr
, dwFlags
);
473 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
474 * and only unload it if it can be unloaded. Also need to implement ref
475 * counting on the functions.
479 struct FuncAddr
*addr
= hFuncAddr
;
481 if (!is_module_registered(addr
->lib
))
483 CryptMemFree(addr
->dllList
);
484 FreeLibrary(addr
->lib
);
491 static BOOL
CRYPT_GetFuncFromDll(LPCWSTR dll
, LPCSTR func
, HMODULE
*lib
,
496 *lib
= LoadLibraryW(dll
);
499 *ppvFuncAddr
= GetProcAddress(*lib
, func
);
511 BOOL WINAPI
CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
512 DWORD dwEncodingType
, LPCWSTR pwszDll
, DWORD dwFlags
, void **ppvFuncAddr
,
513 HCRYPTOIDFUNCADDR
*phFuncAddr
)
515 struct OIDFunctionSet
*set
= hFuncSet
;
518 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
519 debugstr_w(pwszDll
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
526 ret
= CRYPT_GetFuncFromDll(pwszDll
, set
->name
, &lib
, ppvFuncAddr
);
529 struct FuncAddr
*addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
534 addr
->dllList
= addr
->currentDll
= NULL
;
541 SetLastError(ERROR_OUTOFMEMORY
);
546 SetLastError(ERROR_FILE_NOT_FOUND
);
550 struct FuncAddr
*addr
= *phFuncAddr
;
556 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
, NULL
,
560 LPWSTR dllList
= CryptMemAlloc(size
* sizeof(WCHAR
));
564 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
,
568 addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
571 addr
->dllList
= dllList
;
572 addr
->currentDll
= dllList
;
578 CryptMemFree(dllList
);
579 SetLastError(ERROR_OUTOFMEMORY
);
586 SetLastError(ERROR_OUTOFMEMORY
);
593 if (!*addr
->currentDll
)
595 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
596 SetLastError(ERROR_FILE_NOT_FOUND
);
602 /* FIXME: as elsewhere, can't free until DllCanUnloadNow says
603 * it's possible, and should defer unloading for some time to
604 * avoid repeated LoadLibrary/FreeLibrary on the same dll.
606 FreeLibrary(addr
->lib
);
607 ret
= CRYPT_GetFuncFromDll(addr
->currentDll
, set
->name
,
608 &addr
->lib
, ppvFuncAddr
);
611 /* Move past the current DLL */
612 addr
->currentDll
+= lstrlenW(addr
->currentDll
) + 1;
617 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
618 SetLastError(ERROR_FILE_NOT_FOUND
);
627 /***********************************************************************
628 * CryptRegisterOIDFunction (CRYPT32.@)
630 * Register the DLL and the functions it uses to cover the combination
631 * of encoding type, function name and OID.
634 * dwEncodingType [I] Encoding type to be used.
635 * pszFuncName [I] Name of the function to be registered.
636 * pszOID [I] OID of the function (numeric or string).
637 * pwszDll [I] The DLL that is to be registered.
638 * pszOverrideFuncName [I] Name of the function in the DLL.
642 * Failure: FALSE. (Look at GetLastError()).
645 * Registry errors are always reported via SetLastError().
647 BOOL WINAPI
CryptRegisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
648 LPCSTR pszOID
, LPCWSTR pwszDll
, LPCSTR pszOverrideFuncName
)
654 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
655 debugstr_a(pszOID
), debugstr_w(pwszDll
), debugstr_a(pszOverrideFuncName
));
657 /* Native does nothing pwszDll is NULL */
661 /* I'm not matching MS bug for bug here, because I doubt any app depends on
662 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
663 * it creates would never be used.
665 if (!pszFuncName
|| !pszOID
)
667 SetLastError(E_INVALIDARG
);
671 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
672 TRACE("Key name is %s\n", debugstr_a(szKey
));
677 r
= RegCreateKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
680 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
682 /* write the values */
683 if (pszOverrideFuncName
)
685 r
= RegSetValueExA(hKey
, "FuncName", 0, REG_SZ
,
686 (const BYTE
*)pszOverrideFuncName
, lstrlenA(pszOverrideFuncName
) + 1);
687 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
689 r
= RegSetValueExW(hKey
, DllW
, 0, REG_SZ
, (const BYTE
*) pwszDll
,
690 (lstrlenW(pwszDll
) + 1) * sizeof (WCHAR
));
696 if (r
!= ERROR_SUCCESS
)
705 /***********************************************************************
706 * CryptUnregisterOIDInfo (CRYPT32.@)
708 BOOL WINAPI
CryptUnregisterOIDInfo(PCCRYPT_OID_INFO info
)
714 TRACE("(%p)\n", info
);
716 if (!info
|| info
->cbSize
!= sizeof(*info
) || !info
->pszOID
)
718 SetLastError(E_INVALIDARG
);
722 err
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo", 0, KEY_ALL_ACCESS
, &root
);
723 if (err
!= ERROR_SUCCESS
)
729 key_name
= CryptMemAlloc(strlen(info
->pszOID
) + 16);
732 sprintf(key_name
, "%s!%u", info
->pszOID
, info
->dwGroupId
);
733 err
= RegDeleteKeyA(root
, key_name
);
736 err
= ERROR_OUTOFMEMORY
;
738 CryptMemFree(key_name
);
747 /***********************************************************************
748 * CryptRegisterOIDInfo (CRYPT32.@)
750 BOOL WINAPI
CryptRegisterOIDInfo(PCCRYPT_OID_INFO info
, DWORD flags
)
753 HKEY root
= 0, key
= 0;
756 TRACE("(%p, %x)\n", info
, flags
);
758 if (!info
|| info
->cbSize
!= sizeof(*info
) || !info
->pszOID
)
760 SetLastError(E_INVALIDARG
);
764 if (!info
->dwGroupId
) return TRUE
;
766 key_name
= CryptMemAlloc(strlen(info
->pszOID
) + 16);
769 err
= ERROR_OUTOFMEMORY
;
773 err
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo",
774 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
, &root
, NULL
);
775 if (err
!= ERROR_SUCCESS
) goto done
;
777 sprintf(key_name
, "%s!%u", info
->pszOID
, info
->dwGroupId
);
778 err
= RegCreateKeyA(root
, key_name
, &key
);
779 if (err
!= ERROR_SUCCESS
) goto done
;
783 err
= RegSetValueExW(key
, flagsW
, 0, REG_DWORD
, (const BYTE
*)&flags
, sizeof(flags
));
784 if (err
!= ERROR_SUCCESS
) goto done
;
789 err
= RegSetValueExW(key
, nameW
, 0, REG_SZ
, (const BYTE
*)info
->pwszName
, (lstrlenW(info
->pwszName
) + 1) * sizeof(WCHAR
));
790 if (err
!= ERROR_SUCCESS
) goto done
;
795 err
= RegSetValueExW(key
, algidW
, 0, REG_DWORD
, (const BYTE
*)&info
->u
.Algid
, sizeof(info
->u
.Algid
));
796 if (err
!= ERROR_SUCCESS
) goto done
;
799 if (info
->ExtraInfo
.cbData
&& info
->ExtraInfo
.pbData
)
801 err
= RegSetValueExW(key
, extraW
, 0, REG_BINARY
, info
->ExtraInfo
.pbData
, info
->ExtraInfo
.cbData
);
802 if (err
!= ERROR_SUCCESS
) goto done
;
805 if (info
->pwszCNGAlgid
)
807 err
= RegSetValueExW(key
, cngalgidW
, 0, REG_SZ
, (const BYTE
*)info
->pwszCNGAlgid
, (lstrlenW(info
->pwszCNGAlgid
) + 1) * sizeof(WCHAR
));
808 if (err
!= ERROR_SUCCESS
) goto done
;
811 if (info
->pwszCNGExtraAlgid
)
813 err
= RegSetValueExW(key
, cngextraalgidW
, 0, REG_SZ
, (const BYTE
*)info
->pwszCNGExtraAlgid
, (lstrlenW(info
->pwszCNGExtraAlgid
) + 1) * sizeof(WCHAR
));
814 if (err
!= ERROR_SUCCESS
) goto done
;
818 CryptMemFree(key_name
);
819 if (key
) RegCloseKey(key
);
820 if (root
) RegCloseKey(root
);
828 /***********************************************************************
829 * CryptUnregisterOIDFunction (CRYPT32.@)
831 BOOL WINAPI
CryptUnregisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
837 TRACE("%x %s %s\n", dwEncodingType
, debugstr_a(pszFuncName
),
840 if (!pszFuncName
|| !pszOID
)
842 SetLastError(ERROR_INVALID_PARAMETER
);
846 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
847 rc
= RegDeleteKeyA(HKEY_LOCAL_MACHINE
, szKey
);
854 BOOL WINAPI
CryptGetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
855 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD
*pdwValueType
, BYTE
*pbValueData
,
862 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType
, debugstr_a(pszFuncName
),
863 debugstr_a(pszOID
), debugstr_w(pwszValueName
), pdwValueType
, pbValueData
,
866 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
869 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
871 SetLastError(ERROR_INVALID_PARAMETER
);
875 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
876 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
882 rc
= RegQueryValueExW(hKey
, pwszValueName
, NULL
, pdwValueType
,
883 pbValueData
, pcbValueData
);
891 BOOL WINAPI
CryptSetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
892 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD dwValueType
,
893 const BYTE
*pbValueData
, DWORD cbValueData
)
899 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType
, debugstr_a(pszFuncName
),
900 debugstr_a(pszOID
), debugstr_w(pwszValueName
), dwValueType
, pbValueData
,
903 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
906 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
908 SetLastError(ERROR_INVALID_PARAMETER
);
912 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
913 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
919 rc
= RegSetValueExW(hKey
, pwszValueName
, 0, dwValueType
, pbValueData
,
928 static LPCWSTR
CRYPT_FindStringInMultiString(LPCWSTR multi
, LPCWSTR toFind
)
930 LPCWSTR ret
= NULL
, ptr
;
932 for (ptr
= multi
; ptr
&& *ptr
&& !ret
; ptr
+= lstrlenW(ptr
) + 1)
934 if (!lstrcmpiW(ptr
, toFind
))
940 static DWORD
CRYPT_GetMultiStringCharacterLen(LPCWSTR multi
)
948 /* Count terminating empty string */
950 for (ptr
= multi
; *ptr
; ptr
+= lstrlenW(ptr
) + 1)
951 ret
+= lstrlenW(ptr
) + 1;
958 static LPWSTR
CRYPT_AddStringToMultiString(LPWSTR multi
, LPCWSTR toAdd
,
965 /* FIXME: ignoring index, is that okay? */
966 ret
= CryptMemAlloc((lstrlenW(toAdd
) + 2) * sizeof(WCHAR
));
969 /* copy string, including NULL terminator */
970 memcpy(ret
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
971 /* add terminating empty string */
972 *(ret
+ lstrlenW(toAdd
) + 1) = 0;
977 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
979 ret
= CryptMemRealloc(multi
, (len
+ lstrlenW(toAdd
) + 1) *
985 if (index
== CRYPT_REGISTER_LAST_INDEX
)
986 spotToAdd
= ret
+ len
- 1;
991 /* FIXME: if index is too large for the string, toAdd is
992 * added to the end. Is that okay?
994 for (i
= 0, spotToAdd
= ret
; i
< index
&& *spotToAdd
;
995 spotToAdd
+= lstrlenW(spotToAdd
) + 1)
1000 /* Copy existing string "right" */
1001 memmove(spotToAdd
+ lstrlenW(toAdd
) + 1, spotToAdd
,
1002 (len
- (spotToAdd
- ret
)) * sizeof(WCHAR
));
1003 /* Copy new string */
1004 memcpy(spotToAdd
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
1016 static BOOL
CRYPT_RemoveStringFromMultiString(LPWSTR multi
, LPCWSTR toRemove
)
1018 LPWSTR spotToRemove
= (LPWSTR
)CRYPT_FindStringInMultiString(multi
,
1024 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
1026 if (spotToRemove
+ lstrlenW(toRemove
) + 2 >= multi
+ len
)
1028 /* Removing last string in list, terminate multi string directly */
1030 *(spotToRemove
+ 1) = 0;
1034 LPCWSTR nextStr
= spotToRemove
+ lstrlenW(toRemove
) + 1;
1036 /* Copy remainder of string "left" */
1037 memmove(spotToRemove
, nextStr
,
1038 (len
- (nextStr
- multi
)) * sizeof(WCHAR
));
1044 SetLastError(ERROR_FILE_NOT_FOUND
);
1050 static BOOL
CRYPT_GetDefaultOIDKey(DWORD dwEncodingType
, LPCSTR pszFuncName
,
1056 keyName
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, "DEFAULT");
1057 TRACE("Key name is %s\n", debugstr_a(keyName
));
1062 r
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0, KEY_ALL_ACCESS
,
1064 CryptMemFree(keyName
);
1065 if (r
!= ERROR_SUCCESS
)
1073 static LPWSTR
CRYPT_GetDefaultOIDDlls(HKEY key
)
1079 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
1080 if (r
== ERROR_SUCCESS
&& type
== REG_MULTI_SZ
)
1082 dlls
= CryptMemAlloc(size
);
1083 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, (LPBYTE
)dlls
, &size
);
1084 if (r
!= ERROR_SUCCESS
)
1095 static inline BOOL
CRYPT_SetDefaultOIDDlls(HKEY key
, LPCWSTR dlls
)
1097 DWORD len
= CRYPT_GetMultiStringCharacterLen(dlls
);
1100 if ((r
= RegSetValueExW(key
, DllW
, 0, REG_MULTI_SZ
, (const BYTE
*)dlls
,
1101 len
* sizeof (WCHAR
))))
1103 return r
== ERROR_SUCCESS
;
1106 /***********************************************************************
1107 * CryptRegisterDefaultOIDFunction (CRYPT32.@)
1109 BOOL WINAPI
CryptRegisterDefaultOIDFunction(DWORD dwEncodingType
,
1110 LPCSTR pszFuncName
, DWORD dwIndex
, LPCWSTR pwszDll
)
1116 TRACE("(%x, %s, %d, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
1117 dwIndex
, debugstr_w(pwszDll
));
1121 SetLastError(E_INVALIDARG
);
1125 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
1128 dlls
= CRYPT_GetDefaultOIDDlls(key
);
1129 if (CRYPT_FindStringInMultiString(dlls
, pwszDll
))
1130 SetLastError(ERROR_FILE_EXISTS
);
1133 dlls
= CRYPT_AddStringToMultiString(dlls
, pwszDll
, dwIndex
);
1135 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
1142 BOOL WINAPI
CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType
,
1143 LPCSTR pszFuncName
, LPCWSTR pwszDll
)
1149 TRACE("(%x, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
1150 debugstr_w(pwszDll
));
1154 SetLastError(E_INVALIDARG
);
1158 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
1161 dlls
= CRYPT_GetDefaultOIDDlls(key
);
1162 if ((ret
= CRYPT_RemoveStringFromMultiString(dlls
, pwszDll
)))
1163 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
1169 static void oid_init_localizednames(void)
1173 for(i
= 0; i
< ARRAY_SIZE(LocalizedKeys
); i
++)
1175 LoadStringW(hInstance
, IDS_LOCALIZEDNAME_ROOT
+i
, LocalizedNames
[i
], 256);
1179 /********************************************************************
1180 * CryptFindLocalizedName (CRYPT32.@)
1182 LPCWSTR WINAPI
CryptFindLocalizedName(LPCWSTR pwszCryptName
)
1186 for(i
= 0; i
< ARRAY_SIZE(LocalizedKeys
); i
++)
1188 if(!lstrcmpiW(LocalizedKeys
[i
], pwszCryptName
))
1190 return LocalizedNames
[i
];
1194 FIXME("No name for: %s - stub\n",debugstr_w(pwszCryptName
));
1198 static CRITICAL_SECTION oidInfoCS
;
1199 static CRITICAL_SECTION_DEBUG oidInfoCSDebug
=
1202 { &oidInfoCSDebug
.ProcessLocksList
, &oidInfoCSDebug
.ProcessLocksList
},
1203 0, 0, { (DWORD_PTR
)(__FILE__
": oidInfoCS") }
1205 static CRITICAL_SECTION oidInfoCS
= { &oidInfoCSDebug
, -1, 0, 0, 0, 0 };
1206 static struct list oidInfo
= { &oidInfo
, &oidInfo
};
1208 static const WCHAR tripledes
[] = { '3','d','e','s',0 };
1209 static const WCHAR cms3deswrap
[] = { 'C','M','S','3','D','E','S','w','r','a',
1211 static const WCHAR cmsrc2wrap
[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
1212 static const WCHAR des
[] = { 'd','e','s',0 };
1213 static const WCHAR md2
[] = { 'm','d','2',0 };
1214 static const WCHAR md4
[] = { 'm','d','4',0 };
1215 static const WCHAR md5
[] = { 'm','d','5',0 };
1216 static const WCHAR rc2
[] = { 'r','c','2',0 };
1217 static const WCHAR rc4
[] = { 'r','c','4',0 };
1218 static const WCHAR sha
[] = { 's','h','a',0 };
1219 static const WCHAR sha1
[] = { 's','h','a','1',0 };
1220 static const WCHAR sha256
[] = { 's','h','a','2','5','6',0 };
1221 static const WCHAR sha384
[] = { 's','h','a','3','8','4',0 };
1222 static const WCHAR sha512
[] = { 's','h','a','5','1','2',0 };
1223 static const WCHAR RSA
[] = { 'R','S','A',0 };
1224 static const WCHAR RSA_KEYX
[] = { 'R','S','A','_','K','E','Y','X',0 };
1225 static const WCHAR RSA_SIGN
[] = { 'R','S','A','_','S','I','G','N',0 };
1226 static const WCHAR DSA
[] = { 'D','S','A',0 };
1227 static const WCHAR DSA_SIGN
[] = { 'D','S','A','_','S','I','G','N',0 };
1228 static const WCHAR DH
[] = { 'D','H',0 };
1229 static const WCHAR DSS
[] = { 'D','S','S',0 };
1230 static const WCHAR mosaicKMandUpdSig
[] =
1231 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
1232 static const WCHAR ESDH
[] = { 'E','S','D','H',0 };
1233 static const WCHAR NO_SIGN
[] = { 'N','O','S','I','G','N',0 };
1234 static const WCHAR dsaSHA1
[] = { 'd','s','a','S','H','A','1',0 };
1235 static const WCHAR md2RSA
[] = { 'm','d','2','R','S','A',0 };
1236 static const WCHAR md4RSA
[] = { 'm','d','4','R','S','A',0 };
1237 static const WCHAR md5RSA
[] = { 'm','d','5','R','S','A',0 };
1238 static const WCHAR shaDSA
[] = { 's','h','a','D','S','A',0 };
1239 static const WCHAR sha1DSA
[] = { 's','h','a','1','D','S','A',0 };
1240 static const WCHAR shaRSA
[] = { 's','h','a','R','S','A',0 };
1241 static const WCHAR sha1RSA
[] = { 's','h','a','1','R','S','A',0 };
1242 static const WCHAR sha256RSA
[] = { 's','h','a','2','5','6','R','S','A',0 };
1243 static const WCHAR sha384RSA
[] = { 's','h','a','3','8','4','R','S','A',0 };
1244 static const WCHAR sha512RSA
[] = { 's','h','a','5','1','2','R','S','A',0 };
1245 static const WCHAR mosaicUpdatedSig
[] =
1246 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
1247 static const WCHAR sha256ECDSA
[] = { 's','h','a','2','5','6','E','C','D','S','A',0 };
1248 static const WCHAR sha384ECDSA
[] = { 's','h','a','3','8','4','E','C','D','S','A',0 };
1249 static const WCHAR CN
[] = { 'C','N',0 };
1250 static const WCHAR L
[] = { 'L',0 };
1251 static const WCHAR O
[] = { 'O',0 };
1252 static const WCHAR OU
[] = { 'O','U',0 };
1253 static const WCHAR E
[] = { 'E',0 };
1254 static const WCHAR C
[] = { 'C',0 };
1255 static const WCHAR S
[] = { 'S',0 };
1256 static const WCHAR ST
[] = { 'S','T',0 };
1257 static const WCHAR STREET
[] = { 'S','T','R','E','E','T',0 };
1258 static const WCHAR T
[] = { 'T',0 };
1259 static const WCHAR Title
[] = { 'T','i','t','l','e',0 };
1260 static const WCHAR G
[] = { 'G',0 };
1261 static const WCHAR GivenName
[] = { 'G','i','v','e','n','N','a','m','e',0 };
1262 static const WCHAR I
[] = { 'I',0 };
1263 static const WCHAR Initials
[] = { 'I','n','i','t','i','a','l','s',0 };
1264 static const WCHAR SN
[] = { 'S','N',0 };
1265 static const WCHAR DC
[] = { 'D','C',0 };
1266 static const WCHAR Description
[] =
1267 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
1268 static const WCHAR PostalCode
[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
1269 static const WCHAR POBox
[] = { 'P','O','B','o','x',0 };
1270 static const WCHAR Phone
[] = { 'P','h','o','n','e',0 };
1271 static const WCHAR X21Address
[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
1272 static const WCHAR dnQualifier
[] =
1273 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
1274 static const WCHAR SpcSpAgencyInfo
[] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 };
1275 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 };
1276 static const WCHAR SpcMinimalCriteria
[] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 };
1277 static const WCHAR Email
[] = { 'E','m','a','i','l',0 };
1278 static const WCHAR GN
[] = { 'G','N',0 };
1279 static const WCHAR SERIALNUMBER
[] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 };
1281 static const DWORD noNullFlag
= CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1282 static const DWORD mosaicFlags
= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1283 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1284 static const CRYPT_DATA_BLOB noNullBlob
= { sizeof(noNullFlag
),
1285 (LPBYTE
)&noNullFlag
};
1286 static const CRYPT_DATA_BLOB mosaicFlagsBlob
= { sizeof(mosaicFlags
),
1287 (LPBYTE
)&mosaicFlags
};
1289 static const DWORD rsaSign
= CALG_RSA_SIGN
;
1290 static const DWORD dssSign
[2] = { CALG_DSS_SIGN
,
1291 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1292 static const DWORD mosaicSign
[2] = { CALG_DSS_SIGN
,
1293 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1294 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1295 static const DWORD ecdsaSign
[2] = { CALG_OID_INFO_PARAMETERS
, CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1296 static const CRYPT_DATA_BLOB rsaSignBlob
= { sizeof(rsaSign
),
1298 static const CRYPT_DATA_BLOB dssSignBlob
= { sizeof(dssSign
),
1300 static const CRYPT_DATA_BLOB mosaicSignBlob
= { sizeof(mosaicSign
),
1301 (LPBYTE
)mosaicSign
};
1302 static const CRYPT_DATA_BLOB ecdsaSignBlob
= { sizeof(ecdsaSign
), (BYTE
*)ecdsaSign
};
1304 static const DWORD ia5String
[] = { CERT_RDN_IA5_STRING
, 0 };
1305 static const DWORD numericString
[] = { CERT_RDN_NUMERIC_STRING
, 0 };
1306 static const DWORD printableString
[] = { CERT_RDN_PRINTABLE_STRING
, 0 };
1307 static const DWORD domainCompTypes
[] = { CERT_RDN_IA5_STRING
,
1308 CERT_RDN_UTF8_STRING
, 0 };
1309 static const CRYPT_DATA_BLOB ia5StringBlob
= { sizeof(ia5String
),
1310 (LPBYTE
)ia5String
};
1311 static const CRYPT_DATA_BLOB numericStringBlob
= { sizeof(numericString
),
1312 (LPBYTE
)numericString
};
1313 static const CRYPT_DATA_BLOB printableStringBlob
= { sizeof(printableString
),
1314 (LPBYTE
)printableString
};
1315 static const CRYPT_DATA_BLOB domainCompTypesBlob
= { sizeof(domainCompTypes
),
1316 (LPBYTE
)domainCompTypes
};
1318 static const struct OIDInfoConstructor
{
1323 const CRYPT_DATA_BLOB
*blob
;
1324 const WCHAR
*pwszCNGAlgid
;
1325 const WCHAR
*pwszCNGExtraAlgid
;
1326 } oidInfoConstructors
[] = {
1327 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha1
, NULL
},
1328 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha
, NULL
},
1329 { 1, szOID_OIWSEC_sha
, CALG_SHA
, sha
, NULL
},
1330 { 1, szOID_RSA_MD5
, CALG_MD5
, md5
, NULL
},
1331 { 1, szOID_RSA_MD4
, CALG_MD4
, md4
, NULL
},
1332 { 1, szOID_RSA_MD2
, CALG_MD2
, md2
, NULL
},
1333 /* NOTE: Windows Vista+ uses -1 instead of CALG_SHA_* following SHA entries. */
1334 { 1, szOID_NIST_sha256
, CALG_SHA_256
, sha256
, NULL
},
1335 { 1, szOID_NIST_sha384
, CALG_SHA_384
, sha384
, NULL
},
1336 { 1, szOID_NIST_sha512
, CALG_SHA_512
, sha512
, NULL
},
1338 { 2, szOID_OIWSEC_desCBC
, CALG_DES
, des
, NULL
},
1339 { 2, szOID_RSA_DES_EDE3_CBC
, CALG_3DES
, tripledes
, NULL
},
1340 { 2, szOID_RSA_RC2CBC
, CALG_RC2
, rc2
, NULL
},
1341 { 2, szOID_RSA_RC4
, CALG_RC4
, rc4
, NULL
},
1342 { 2, szOID_RSA_SMIMEalgCMS3DESwrap
, CALG_3DES
, cms3deswrap
, NULL
},
1343 { 2, szOID_RSA_SMIMEalgCMSRC2wrap
, CALG_RC2
, cmsrc2wrap
, NULL
},
1345 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA
, NULL
},
1346 { 3, szOID_X957_DSA
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1347 { 3, szOID_ANSI_X942_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1348 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1349 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA
, NULL
},
1350 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA_SIGN
, NULL
},
1351 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1352 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSS
, &noNullBlob
},
1353 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA_SIGN
, &noNullBlob
},
1354 { 3, szOID_RSA_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1355 { 3, szOID_OIWSEC_rsaXchg
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1356 { 3, szOID_INFOSEC_mosaicKMandUpdSig
, CALG_DSS_SIGN
, mosaicKMandUpdSig
,
1358 { 3, szOID_RSA_SMIMEalgESDH
, CALG_DH_EPHEM
, ESDH
, &noNullBlob
},
1359 { 3, szOID_PKIX_NO_SIGNATURE
, CALG_NO_SIGN
, NO_SIGN
, NULL
},
1361 { 4, szOID_RSA_SHA1RSA
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1362 { 4, szOID_RSA_SHA256RSA
, CALG_SHA_256
, sha256RSA
, &rsaSignBlob
},
1363 { 4, szOID_RSA_SHA384RSA
, CALG_SHA_384
, sha384RSA
, &rsaSignBlob
},
1364 { 4, szOID_RSA_SHA512RSA
, CALG_SHA_512
, sha512RSA
, &rsaSignBlob
},
1365 { 4, szOID_RSA_MD5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1366 { 4, szOID_X957_SHA1DSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1367 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1368 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1369 { 4, szOID_OIWSEC_shaRSA
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1370 { 4, szOID_OIWSEC_md5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1371 { 4, szOID_RSA_MD2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1372 { 4, szOID_RSA_MD4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1373 { 4, szOID_OIWSEC_md4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1374 { 4, szOID_OIWSEC_md4RSA2
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1375 { 4, szOID_OIWDIR_md2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1376 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1377 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, shaDSA
, &dssSignBlob
},
1378 { 4, szOID_OIWSEC_dsaSHA1
, CALG_SHA1
, dsaSHA1
, &dssSignBlob
},
1379 { 4, szOID_INFOSEC_mosaicUpdatedSig
, CALG_SHA1
, mosaicUpdatedSig
,
1381 { 4, szOID_ECDSA_SHA256
, CALG_OID_INFO_CNG_ONLY
, sha256ECDSA
, &ecdsaSignBlob
,
1382 BCRYPT_SHA256_ALGORITHM
, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM
},
1383 { 4, szOID_ECDSA_SHA384
, CALG_OID_INFO_CNG_ONLY
, sha384ECDSA
, &ecdsaSignBlob
,
1384 BCRYPT_SHA384_ALGORITHM
, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM
},
1386 { 5, szOID_COMMON_NAME
, 0, CN
, NULL
},
1387 { 5, szOID_LOCALITY_NAME
, 0, L
, NULL
},
1388 { 5, szOID_ORGANIZATION_NAME
, 0, O
, NULL
},
1389 { 5, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, OU
, NULL
},
1390 { 5, szOID_RSA_emailAddr
, 0, E
, &ia5StringBlob
},
1391 { 5, szOID_RSA_emailAddr
, 0, Email
, &ia5StringBlob
},
1392 { 5, szOID_COUNTRY_NAME
, 0, C
, &printableStringBlob
},
1393 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, S
, NULL
},
1394 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, ST
, NULL
},
1395 { 5, szOID_STREET_ADDRESS
, 0, STREET
, NULL
},
1396 { 5, szOID_TITLE
, 0, T
, NULL
},
1397 { 5, szOID_TITLE
, 0, Title
, NULL
},
1398 { 5, szOID_GIVEN_NAME
, 0, G
, NULL
},
1399 { 5, szOID_GIVEN_NAME
, 0, GN
, NULL
},
1400 { 5, szOID_GIVEN_NAME
, 0, GivenName
, NULL
},
1401 { 5, szOID_INITIALS
, 0, I
, NULL
},
1402 { 5, szOID_INITIALS
, 0, Initials
, NULL
},
1403 { 5, szOID_SUR_NAME
, 0, SN
, NULL
},
1404 { 5, szOID_DOMAIN_COMPONENT
, 0, DC
, &domainCompTypesBlob
},
1405 { 5, szOID_DESCRIPTION
, 0, Description
, NULL
},
1406 { 5, szOID_POSTAL_CODE
, 0, PostalCode
, NULL
},
1407 { 5, szOID_POST_OFFICE_BOX
, 0, POBox
, NULL
},
1408 { 5, szOID_TELEPHONE_NUMBER
, 0, Phone
, &printableStringBlob
},
1409 { 5, szOID_X21_ADDRESS
, 0, X21Address
, &numericStringBlob
},
1410 { 5, szOID_DN_QUALIFIER
, 0, dnQualifier
, NULL
},
1411 { 5, szOID_DEVICE_SERIAL_NUMBER
, 0, SERIALNUMBER
, NULL
},
1413 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1414 { 6, szOID_AUTHORITY_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1415 { 6, szOID_KEY_ATTRIBUTES
, 0, (LPCWSTR
)IDS_KEY_ATTRIBUTES
, NULL
},
1416 { 6, szOID_KEY_USAGE_RESTRICTION
, 0, (LPCWSTR
)IDS_KEY_USAGE_RESTRICTION
, NULL
},
1417 { 6, szOID_SUBJECT_ALT_NAME2
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1418 { 6, szOID_SUBJECT_ALT_NAME
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1419 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1420 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1421 { 6, szOID_BASIC_CONSTRAINTS2
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1422 { 6, szOID_BASIC_CONSTRAINTS
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1423 { 6, szOID_KEY_USAGE
, 0, (LPCWSTR
)IDS_KEY_USAGE
, NULL
},
1424 { 6, szOID_CERT_POLICIES
, 0, (LPCWSTR
)IDS_CERT_POLICIES
, NULL
},
1425 { 6, szOID_SUBJECT_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_SUBJECT_KEY_IDENTIFIER
, NULL
},
1426 { 6, szOID_CRL_REASON_CODE
, 0, (LPCWSTR
)IDS_CRL_REASON_CODE
, NULL
},
1427 { 6, szOID_CRL_DIST_POINTS
, 0, (LPCWSTR
)IDS_CRL_DIST_POINTS
, NULL
},
1428 { 6, szOID_ENHANCED_KEY_USAGE
, 0, (LPCWSTR
)IDS_ENHANCED_KEY_USAGE
, NULL
},
1429 { 6, szOID_AUTHORITY_INFO_ACCESS
, 0, (LPCWSTR
)IDS_AUTHORITY_INFO_ACCESS
, NULL
},
1430 { 6, szOID_CERT_EXTENSIONS
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1431 { 6, szOID_RSA_certExtensions
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1432 { 6, szOID_NEXT_UPDATE_LOCATION
, 0, (LPCWSTR
)IDS_NEXT_UPDATE_LOCATION
, NULL
},
1433 { 6, szOID_YESNO_TRUST_ATTR
, 0, (LPCWSTR
)IDS_YES_OR_NO_TRUST
, NULL
},
1434 { 6, szOID_RSA_emailAddr
, 0, (LPCWSTR
)IDS_EMAIL_ADDRESS
, NULL
},
1435 { 6, szOID_RSA_unstructName
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_NAME
, NULL
},
1436 { 6, szOID_RSA_contentType
, 0, (LPCWSTR
)IDS_CONTENT_TYPE
, NULL
},
1437 { 6, szOID_RSA_messageDigest
, 0, (LPCWSTR
)IDS_MESSAGE_DIGEST
, NULL
},
1438 { 6, szOID_RSA_signingTime
, 0, (LPCWSTR
)IDS_SIGNING_TIME
, NULL
},
1439 { 6, szOID_RSA_counterSign
, 0, (LPCWSTR
)IDS_COUNTER_SIGN
, NULL
},
1440 { 6, szOID_RSA_challengePwd
, 0, (LPCWSTR
)IDS_CHALLENGE_PASSWORD
, NULL
},
1441 { 6, szOID_RSA_unstructAddr
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_ADDRESS
, NULL
},
1442 { 6, szOID_RSA_SMIMECapabilities
, 0, (LPCWSTR
)IDS_SMIME_CAPABILITIES
, NULL
},
1443 { 6, szOID_RSA_preferSignedData
, 0, (LPCWSTR
)IDS_PREFER_SIGNED_DATA
, NULL
},
1444 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS
, 0, (LPCWSTR
)IDS_CPS
, NULL
},
1445 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
, 0, (LPCWSTR
)IDS_USER_NOTICE
, NULL
},
1446 { 6, szOID_PKIX_OCSP
, 0, (LPCWSTR
)IDS_OCSP
, NULL
},
1447 { 6, szOID_PKIX_CA_ISSUERS
, 0, (LPCWSTR
)IDS_CA_ISSUER
, NULL
},
1448 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TEMPLATE_NAME
, NULL
},
1449 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TYPE
, NULL
},
1450 { 6, szOID_CERT_MANIFOLD
, 0, (LPCWSTR
)IDS_CERT_MANIFOLD
, NULL
},
1451 { 6, szOID_NETSCAPE_CERT_TYPE
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_TYPE
, NULL
},
1452 { 6, szOID_NETSCAPE_BASE_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_BASE_URL
, NULL
},
1453 { 6, szOID_NETSCAPE_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_REVOCATION_URL
, NULL
},
1454 { 6, szOID_NETSCAPE_CA_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_REVOCATION_URL
, NULL
},
1455 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_RENEWAL_URL
, NULL
},
1456 { 6, szOID_NETSCAPE_CA_POLICY_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_POLICY_URL
, NULL
},
1457 { 6, szOID_NETSCAPE_SSL_SERVER_NAME
, 0, (LPCWSTR
)IDS_NETSCAPE_SSL_SERVER_NAME
, NULL
},
1458 { 6, szOID_NETSCAPE_COMMENT
, 0, (LPCWSTR
)IDS_NETSCAPE_COMMENT
, NULL
},
1459 { 6, "1.3.6.1.4.1.311.2.1.10", 0, SpcSpAgencyInfo
, NULL
},
1460 { 6, "1.3.6.1.4.1.311.2.1.27", 0, SpcFinancialCriteria
, NULL
},
1461 { 6, "1.3.6.1.4.1.311.2.1.26", 0, SpcMinimalCriteria
, NULL
},
1462 { 6, szOID_COUNTRY_NAME
, 0, (LPCWSTR
)IDS_COUNTRY
, NULL
},
1463 { 6, szOID_ORGANIZATION_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATION
, NULL
},
1464 { 6, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATIONAL_UNIT
, NULL
},
1465 { 6, szOID_COMMON_NAME
, 0, (LPCWSTR
)IDS_COMMON_NAME
, NULL
},
1466 { 6, szOID_LOCALITY_NAME
, 0, (LPCWSTR
)IDS_LOCALITY
, NULL
},
1467 { 6, szOID_STATE_OR_PROVINCE_NAME
, 0, (LPCWSTR
)IDS_STATE_OR_PROVINCE
, NULL
},
1468 { 6, szOID_TITLE
, 0, (LPCWSTR
)IDS_TITLE
, NULL
},
1469 { 6, szOID_GIVEN_NAME
, 0, (LPCWSTR
)IDS_GIVEN_NAME
, NULL
},
1470 { 6, szOID_INITIALS
, 0, (LPCWSTR
)IDS_INITIALS
, NULL
},
1471 { 6, szOID_SUR_NAME
, 0, (LPCWSTR
)IDS_SUR_NAME
, NULL
},
1472 { 6, szOID_DOMAIN_COMPONENT
, 0, (LPCWSTR
)IDS_DOMAIN_COMPONENT
, NULL
},
1473 { 6, szOID_STREET_ADDRESS
, 0, (LPCWSTR
)IDS_STREET_ADDRESS
, NULL
},
1474 { 6, szOID_DEVICE_SERIAL_NUMBER
, 0, (LPCWSTR
)IDS_SERIAL_NUMBER
, NULL
},
1475 { 6, szOID_CERTSRV_CA_VERSION
, 0, (LPCWSTR
)IDS_CA_VERSION
, NULL
},
1476 { 6, szOID_CERTSRV_CROSSCA_VERSION
, 0, (LPCWSTR
)IDS_CROSS_CA_VERSION
, NULL
},
1477 { 6, szOID_SERIALIZED
, 0, (LPCWSTR
)IDS_SERIALIZED_SIG_SERIAL_NUMBER
, NULL
},
1478 { 6, szOID_NT_PRINCIPAL_NAME
, 0, (LPCWSTR
)IDS_PRINCIPAL_NAME
, NULL
},
1479 { 6, szOID_PRODUCT_UPDATE
, 0, (LPCWSTR
)IDS_WINDOWS_PRODUCT_UPDATE
, NULL
},
1480 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR
, 0, (LPCWSTR
)IDS_ENROLLMENT_NAME_VALUE_PAIR
, NULL
},
1481 { 6, szOID_OS_VERSION
, 0, (LPCWSTR
)IDS_OS_VERSION
, NULL
},
1482 { 6, szOID_ENROLLMENT_CSP_PROVIDER
, 0, (LPCWSTR
)IDS_ENROLLMENT_CSP
, NULL
},
1483 { 6, szOID_CRL_NUMBER
, 0, (LPCWSTR
)IDS_CRL_NUMBER
, NULL
},
1484 { 6, szOID_DELTA_CRL_INDICATOR
, 0, (LPCWSTR
)IDS_DELTA_CRL_INDICATOR
, NULL
},
1485 { 6, szOID_ISSUING_DIST_POINT
, 0, (LPCWSTR
)IDS_ISSUING_DIST_POINT
, NULL
},
1486 { 6, szOID_FRESHEST_CRL
, 0, (LPCWSTR
)IDS_FRESHEST_CRL
, NULL
},
1487 { 6, szOID_NAME_CONSTRAINTS
, 0, (LPCWSTR
)IDS_NAME_CONSTRAINTS
, NULL
},
1488 { 6, szOID_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1489 { 6, szOID_LEGACY_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1490 { 6, szOID_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_POLICY_CONSTRAINTS
, NULL
},
1491 { 6, szOID_CROSS_CERT_DIST_POINTS
, 0, (LPCWSTR
)IDS_CROSS_CERT_DIST_POINTS
, NULL
},
1492 { 6, szOID_APPLICATION_CERT_POLICIES
, 0, (LPCWSTR
)IDS_APPLICATION_POLICIES
, NULL
},
1493 { 6, szOID_APPLICATION_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_MAPPINGS
, NULL
},
1494 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_CONSTRAINTS
, NULL
},
1495 { 6, szOID_CT_PKI_DATA
, 0, (LPCWSTR
)IDS_CMC_DATA
, NULL
},
1496 { 6, szOID_CT_PKI_RESPONSE
, 0, (LPCWSTR
)IDS_CMC_RESPONSE
, NULL
},
1497 { 6, szOID_CMC
, 0, (LPCWSTR
)IDS_UNSIGNED_CMC_REQUEST
, NULL
},
1498 { 6, szOID_CMC_STATUS_INFO
, 0, (LPCWSTR
)IDS_CMC_STATUS_INFO
, NULL
},
1499 { 6, szOID_CMC_ADD_EXTENSIONS
, 0, (LPCWSTR
)IDS_CMC_EXTENSIONS
, NULL
},
1500 { 6, szOID_CTL
, 0, (LPCWSTR
)IDS_CMC_ATTRIBUTES
, NULL
},
1501 { 6, szOID_RSA_data
, 0, (LPCWSTR
)IDS_PKCS_7_DATA
, NULL
},
1502 { 6, szOID_RSA_signedData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED
, NULL
},
1503 { 6, szOID_RSA_envelopedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENVELOPED
, NULL
},
1504 { 6, szOID_RSA_signEnvData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED_ENVELOPED
, NULL
},
1505 { 6, szOID_RSA_digestedData
, 0, (LPCWSTR
)IDS_PKCS_7_DIGESTED
, NULL
},
1506 { 6, szOID_RSA_encryptedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENCRYPTED
, NULL
},
1507 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH
, 0, (LPCWSTR
)IDS_PREVIOUS_CA_CERT_HASH
, NULL
},
1508 { 6, szOID_CRL_VIRTUAL_BASE
, 0, (LPCWSTR
)IDS_CRL_VIRTUAL_BASE
, NULL
},
1509 { 6, szOID_CRL_NEXT_PUBLISH
, 0, (LPCWSTR
)IDS_CRL_NEXT_PUBLISH
, NULL
},
1510 { 6, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1511 { 6, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1512 { 6, szOID_CERTIFICATE_TEMPLATE
, 0, (LPCWSTR
)IDS_CERTIFICATE_TEMPLATE
, NULL
},
1513 { 6, szOID_ENTERPRISE_OID_ROOT
, 0, (LPCWSTR
)IDS_ENTERPRISE_ROOT_OID
, NULL
},
1514 { 6, szOID_RDN_DUMMY_SIGNER
, 0, (LPCWSTR
)IDS_RDN_DUMMY_SIGNER
, NULL
},
1515 { 6, szOID_ARCHIVED_KEY_ATTR
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_ATTR
, NULL
},
1516 { 6, szOID_CRL_SELF_CDP
, 0, (LPCWSTR
)IDS_CRL_SELF_CDP
, NULL
},
1517 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY
, 0, (LPCWSTR
)IDS_REQUIRE_CERT_CHAIN_POLICY
, NULL
},
1518 { 6, szOID_CMC_TRANSACTION_ID
, 0, (LPCWSTR
)IDS_TRANSACTION_ID
, NULL
},
1519 { 6, szOID_CMC_SENDER_NONCE
, 0, (LPCWSTR
)IDS_SENDER_NONCE
, NULL
},
1520 { 6, szOID_CMC_RECIPIENT_NONCE
, 0, (LPCWSTR
)IDS_RECIPIENT_NONCE
, NULL
},
1521 { 6, szOID_CMC_REG_INFO
, 0, (LPCWSTR
)IDS_REG_INFO
, NULL
},
1522 { 6, szOID_CMC_GET_CERT
, 0, (LPCWSTR
)IDS_GET_CERTIFICATE
, NULL
},
1523 { 6, szOID_CMC_GET_CRL
, 0, (LPCWSTR
)IDS_GET_CRL
, NULL
},
1524 { 6, szOID_CMC_REVOKE_REQUEST
, 0, (LPCWSTR
)IDS_REVOKE_REQUEST
, NULL
},
1525 { 6, szOID_CMC_QUERY_PENDING
, 0, (LPCWSTR
)IDS_QUERY_PENDING
, NULL
},
1526 { 6, szOID_SORTED_CTL
, 0, (LPCWSTR
)IDS_SORTED_CTL
, NULL
},
1527 { 6, szOID_ARCHIVED_KEY_CERT_HASH
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_CERT_HASH
, NULL
},
1528 { 6, szOID_PRIVATEKEY_USAGE_PERIOD
, 0, (LPCWSTR
)IDS_PRIVATE_KEY_USAGE_PERIOD
, NULL
},
1529 { 6, szOID_REQUEST_CLIENT_INFO
, 0, (LPCWSTR
)IDS_CLIENT_INFORMATION
, NULL
},
1531 { 7, szOID_PKIX_KP_SERVER_AUTH
, 0, (LPCWSTR
)IDS_SERVER_AUTHENTICATION
, NULL
},
1532 { 7, szOID_PKIX_KP_CLIENT_AUTH
, 0, (LPCWSTR
)IDS_CLIENT_AUTHENTICATION
, NULL
},
1533 { 7, szOID_PKIX_KP_CODE_SIGNING
, 0, (LPCWSTR
)IDS_CODE_SIGNING
, NULL
},
1534 { 7, szOID_PKIX_KP_EMAIL_PROTECTION
, 0, (LPCWSTR
)IDS_SECURE_EMAIL
, NULL
},
1535 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING
, 0, (LPCWSTR
)IDS_TIME_STAMPING
, NULL
},
1536 { 7, szOID_KP_CTL_USAGE_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TRUST_LIST_SIGNING
, NULL
},
1537 { 7, szOID_KP_TIME_STAMP_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TIME_STAMPING
, NULL
},
1538 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM
, 0, (LPCWSTR
)IDS_IPSEC_END_SYSTEM
, NULL
},
1539 { 7, szOID_PKIX_KP_IPSEC_TUNNEL
, 0, (LPCWSTR
)IDS_IPSEC_TUNNEL
, NULL
},
1540 { 7, szOID_PKIX_KP_IPSEC_USER
, 0, (LPCWSTR
)IDS_IPSEC_USER
, NULL
},
1541 { 7, szOID_KP_EFS
, 0, (LPCWSTR
)IDS_EFS
, NULL
},
1542 { 7, szOID_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_WHQL_CRYPTO
, NULL
},
1543 { 7, szOID_NT5_CRYPTO
, 0, (LPCWSTR
)IDS_NT5_CRYPTO
, NULL
},
1544 { 7, szOID_OEM_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_OEM_WHQL_CRYPTO
, NULL
},
1545 { 7, szOID_EMBEDDED_NT_CRYPTO
, 0, (LPCWSTR
)IDS_EMBEDDED_NT_CRYPTO
, NULL
},
1546 { 7, szOID_LICENSES
, 0, (LPCWSTR
)IDS_KEY_PACK_LICENSES
, NULL
},
1547 { 7, szOID_LICENSE_SERVER
, 0, (LPCWSTR
)IDS_LICENSE_SERVER
, NULL
},
1548 { 7, szOID_KP_SMARTCARD_LOGON
, 0, (LPCWSTR
)IDS_SMART_CARD_LOGON
, NULL
},
1549 { 7, szOID_DRM
, 0, (LPCWSTR
)IDS_DIGITAL_RIGHTS
, NULL
},
1550 { 7, szOID_KP_QUALIFIED_SUBORDINATION
, 0, (LPCWSTR
)IDS_QUALIFIED_SUBORDINATION
, NULL
},
1551 { 7, szOID_KP_KEY_RECOVERY
, 0, (LPCWSTR
)IDS_KEY_RECOVERY
, NULL
},
1552 { 7, szOID_KP_DOCUMENT_SIGNING
, 0, (LPCWSTR
)IDS_DOCUMENT_SIGNING
, NULL
},
1553 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE
, 0, (LPCWSTR
)IDS_IPSEC_IKE_INTERMEDIATE
, NULL
},
1554 { 7, szOID_EFS_RECOVERY
, 0, (LPCWSTR
)IDS_FILE_RECOVERY
, NULL
},
1555 { 7, szOID_ROOT_LIST_SIGNER
, 0, (LPCWSTR
)IDS_ROOT_LIST_SIGNER
, NULL
},
1556 { 7, szOID_ANY_APPLICATION_POLICY
, 0, (LPCWSTR
)IDS_ANY_APPLICATION_POLICIES
, NULL
},
1557 { 7, szOID_DS_EMAIL_REPLICATION
, 0, (LPCWSTR
)IDS_DS_EMAIL_REPLICATION
, NULL
},
1558 { 7, szOID_ENROLLMENT_AGENT
, 0, (LPCWSTR
)IDS_ENROLLMENT_AGENT
, NULL
},
1559 { 7, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1560 { 7, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1561 { 7, szOID_KP_LIFETIME_SIGNING
, 0, (LPCWSTR
)IDS_LIFETIME_SIGNING
, NULL
},
1563 { 8, szOID_ANY_CERT_POLICY
, 0, (LPCWSTR
)IDS_ANY_CERT_POLICY
, NULL
},
1567 CRYPT_OID_INFO info
;
1571 static struct OIDInfo
*read_oid_info(HKEY root
, char *key_name
, DWORD
*flags
)
1574 DWORD len
, oid_len
, name_len
= 0, extra_len
= 0, cngalgid_len
= 0, cngextra_len
= 0, group_id
= 0;
1575 struct OIDInfo
*info
;
1578 if (RegOpenKeyExA(root
, key_name
, 0, KEY_READ
, &key
))
1581 p
= strchr(key_name
, '!');
1584 group_id
= strtol(p
+ 1, NULL
, 10);
1588 oid_len
= strlen(key_name
) + 1;
1590 RegQueryValueExW(key
, nameW
, NULL
, NULL
, NULL
, &name_len
);
1591 RegQueryValueExW(key
, extraW
, NULL
, NULL
, NULL
, &extra_len
);
1592 RegQueryValueExW(key
, cngalgidW
, NULL
, NULL
, NULL
, &cngalgid_len
);
1593 RegQueryValueExW(key
, cngextraalgidW
, NULL
, NULL
, NULL
, &cngextra_len
);
1595 info
= CryptMemAlloc(sizeof(*info
) + oid_len
+ name_len
+ extra_len
+ cngalgid_len
+ cngextra_len
);
1599 len
= sizeof(*flags
);
1600 RegQueryValueExW(key
, flagsW
, NULL
, NULL
, (BYTE
*)flags
, &len
);
1602 memset(info
, 0, sizeof(*info
));
1603 info
->info
.cbSize
= sizeof(info
->info
);
1605 p
= (char *)(info
+ 1);
1607 info
->info
.pszOID
= p
;
1608 strcpy((char *)info
->info
.pszOID
, key_name
);
1613 info
->info
.pwszName
= (WCHAR
*)p
;
1614 RegQueryValueExW(key
, nameW
, NULL
, NULL
, (BYTE
*)info
->info
.pwszName
, &name_len
);
1618 info
->info
.dwGroupId
= group_id
;
1620 len
= sizeof(info
->info
.u
.Algid
);
1621 RegQueryValueExW(key
, algidW
, NULL
, NULL
, (BYTE
*)&info
->info
.u
.Algid
, &len
);
1625 info
->info
.ExtraInfo
.cbData
= extra_len
;
1626 info
->info
.ExtraInfo
.pbData
= (BYTE
*)p
;
1627 RegQueryValueExW(key
, extraW
, NULL
, NULL
, info
->info
.ExtraInfo
.pbData
, &extra_len
);
1633 info
->info
.pwszCNGAlgid
= (WCHAR
*)p
;
1634 RegQueryValueExW(key
, cngalgidW
, NULL
, NULL
, (BYTE
*)info
->info
.pwszCNGAlgid
, &cngalgid_len
);
1640 info
->info
.pwszCNGExtraAlgid
= (WCHAR
*)p
;
1641 RegQueryValueExW(key
, cngextraalgidW
, NULL
, NULL
, (BYTE
*)info
->info
.pwszCNGExtraAlgid
, &cngalgid_len
);
1650 static void init_registered_oid_info(void)
1655 err
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo",
1656 0, KEY_ALL_ACCESS
, &root
);
1657 if (err
!= ERROR_SUCCESS
) return;
1662 char key_name
[MAX_PATH
];
1663 struct OIDInfo
*info
;
1666 err
= RegEnumKeyA(root
, idx
++, key_name
, MAX_PATH
);
1667 if (err
== ERROR_NO_MORE_ITEMS
)
1670 if (err
== ERROR_SUCCESS
)
1672 if ((info
= read_oid_info(root
, key_name
, &flags
)))
1674 TRACE("adding oid %s, name %s, groupid %u, algid %u, extra %u, CNG algid %s, CNG extra %s\n",
1675 debugstr_a(info
->info
.pszOID
), debugstr_w(info
->info
.pwszName
),
1676 info
->info
.dwGroupId
, info
->info
.u
.Algid
, info
->info
.ExtraInfo
.cbData
,
1677 debugstr_w(info
->info
.pwszCNGAlgid
), debugstr_w(info
->info
.pwszCNGExtraAlgid
));
1679 if (flags
& CRYPT_INSTALL_OID_INFO_BEFORE_FLAG
)
1680 list_add_head(&oidInfo
, &info
->entry
);
1682 list_add_tail(&oidInfo
, &info
->entry
);
1690 static void init_oid_info(void)
1694 oid_init_localizednames();
1695 for (i
= 0; i
< ARRAY_SIZE(oidInfoConstructors
); i
++)
1697 if (!IS_INTRESOURCE(oidInfoConstructors
[i
].pwszName
))
1699 struct OIDInfo
*info
;
1701 /* The name is a static string, so just use the same pointer */
1702 info
= CryptMemAlloc(sizeof(struct OIDInfo
));
1705 memset(info
, 0, sizeof(*info
));
1706 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1707 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1708 info
->info
.pwszName
= oidInfoConstructors
[i
].pwszName
;
1709 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1710 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1711 if (oidInfoConstructors
[i
].blob
)
1713 info
->info
.ExtraInfo
.cbData
=
1714 oidInfoConstructors
[i
].blob
->cbData
;
1715 info
->info
.ExtraInfo
.pbData
=
1716 oidInfoConstructors
[i
].blob
->pbData
;
1718 info
->info
.pwszCNGAlgid
= oidInfoConstructors
[i
].pwszCNGAlgid
;
1719 info
->info
.pwszCNGExtraAlgid
= oidInfoConstructors
[i
].pwszCNGExtraAlgid
;
1720 list_add_tail(&oidInfo
, &info
->entry
);
1725 LPCWSTR stringresource
;
1726 int len
= LoadStringW(hInstance
,
1727 (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1728 (LPWSTR
)&stringresource
, 0);
1732 struct OIDInfo
*info
= CryptMemAlloc(sizeof(struct OIDInfo
) +
1733 (len
+ 1) * sizeof(WCHAR
));
1737 memset(info
, 0, sizeof(*info
));
1738 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1739 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1740 info
->info
.pwszName
= (LPWSTR
)(info
+ 1);
1741 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1742 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1743 memcpy(info
+ 1, stringresource
, len
*sizeof(WCHAR
));
1744 ((LPWSTR
)(info
+ 1))[len
] = 0;
1745 if (oidInfoConstructors
[i
].blob
)
1747 info
->info
.ExtraInfo
.cbData
=
1748 oidInfoConstructors
[i
].blob
->cbData
;
1749 info
->info
.ExtraInfo
.pbData
=
1750 oidInfoConstructors
[i
].blob
->pbData
;
1752 info
->info
.pwszCNGAlgid
= oidInfoConstructors
[i
].pwszCNGAlgid
;
1753 info
->info
.pwszCNGExtraAlgid
= oidInfoConstructors
[i
].pwszCNGExtraAlgid
;
1754 list_add_tail(&oidInfo
, &info
->entry
);
1761 static void free_oid_info(void)
1763 struct OIDInfo
*info
, *next
;
1765 LIST_FOR_EACH_ENTRY_SAFE(info
, next
, &oidInfo
, struct OIDInfo
, entry
)
1767 list_remove(&info
->entry
);
1770 DeleteCriticalSection(&oidInfoCS
);
1773 /***********************************************************************
1774 * CryptEnumOIDInfo (CRYPT32.@)
1776 BOOL WINAPI
CryptEnumOIDInfo(DWORD dwGroupId
, DWORD dwFlags
, void *pvArg
,
1777 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo
)
1780 struct OIDInfo
*info
;
1782 TRACE("(%d, %08x, %p, %p)\n", dwGroupId
, dwFlags
, pvArg
,
1785 EnterCriticalSection(&oidInfoCS
);
1786 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1788 if (!dwGroupId
|| dwGroupId
== info
->info
.dwGroupId
)
1790 ret
= pfnEnumOIDInfo(&info
->info
, pvArg
);
1795 LeaveCriticalSection(&oidInfoCS
);
1799 PCCRYPT_OID_INFO WINAPI
CryptFindOIDInfo(DWORD dwKeyType
, void *pvKey
,
1802 PCCRYPT_OID_INFO ret
= NULL
;
1804 TRACE("(%d, %p, %d)\n", dwKeyType
, pvKey
, dwGroupId
);
1808 case CRYPT_OID_INFO_ALGID_KEY
:
1810 struct OIDInfo
*info
;
1812 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD
*)pvKey
);
1813 EnterCriticalSection(&oidInfoCS
);
1814 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1816 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1817 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1823 LeaveCriticalSection(&oidInfoCS
);
1826 case CRYPT_OID_INFO_NAME_KEY
:
1828 struct OIDInfo
*info
;
1830 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey
));
1831 EnterCriticalSection(&oidInfoCS
);
1832 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1834 if (!lstrcmpW(info
->info
.pwszName
, pvKey
) &&
1835 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1841 LeaveCriticalSection(&oidInfoCS
);
1844 case CRYPT_OID_INFO_OID_KEY
:
1846 struct OIDInfo
*info
;
1849 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid
));
1850 EnterCriticalSection(&oidInfoCS
);
1851 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1853 if (!lstrcmpA(info
->info
.pszOID
, oid
) &&
1854 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1860 LeaveCriticalSection(&oidInfoCS
);
1863 case CRYPT_OID_INFO_SIGN_KEY
:
1865 struct OIDInfo
*info
;
1867 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD
*)pvKey
);
1868 EnterCriticalSection(&oidInfoCS
);
1869 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1871 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1872 info
->info
.ExtraInfo
.cbData
>= sizeof(DWORD
) &&
1873 *(DWORD
*)info
->info
.ExtraInfo
.pbData
==
1874 *(DWORD
*)((LPBYTE
)pvKey
+ sizeof(DWORD
)) &&
1875 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1881 LeaveCriticalSection(&oidInfoCS
);
1888 LPCSTR WINAPI
CertAlgIdToOID(DWORD dwAlgId
)
1891 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY
,
1901 DWORD WINAPI
CertOIDToAlgId(LPCSTR pszObjId
)
1904 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY
,
1905 (void *)pszObjId
, 0);
1908 ret
= info
->u
.Algid
;
1914 void crypt_oid_init(void)
1917 init_registered_oid_info();
1920 void crypt_oid_free(void)
1922 free_function_sets();