2 * Copyright 2002 Mike McCormack for CodeWeavers
3 * Copyright 2005-2006 Juan Lang
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.
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.
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
21 #include "wine/port.h"
25 #define NONAMELESSUNION
28 #define CRYPT_OID_INFO_HAS_EXTRA_FIELDS
32 #include "wine/debug.h"
33 #include "wine/list.h"
34 #include "crypt32_private.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
39 static const WCHAR DllW
[] = { 'D','l','l',0 };
41 static CRITICAL_SECTION funcSetCS
;
42 static CRITICAL_SECTION_DEBUG funcSetCSDebug
=
45 { &funcSetCSDebug
.ProcessLocksList
, &funcSetCSDebug
.ProcessLocksList
},
46 0, 0, { (DWORD_PTR
)(__FILE__
": funcSetCS") }
48 static CRITICAL_SECTION funcSetCS
= { &funcSetCSDebug
, -1, 0, 0, 0, 0 };
49 static struct list funcSets
= { &funcSets
, &funcSets
};
54 CRITICAL_SECTION cs
; /* protects functions */
55 struct list functions
;
62 CRYPT_OID_FUNC_ENTRY entry
;
66 static const WCHAR ROOT
[] = {'R','O','O','T',0};
67 static const WCHAR MY
[] = {'M','Y',0};
68 static const WCHAR CA
[] = {'C','A',0};
69 static const WCHAR ADDRESSBOOK
[] = {'A','D','D','R','E','S','S','B','O','O','K',0};
70 static const WCHAR TRUSTEDPUBLISHER
[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0};
71 static const WCHAR DISALLOWED
[] = {'D','i','s','a','l','l','o','w','e','d',0};
72 static const LPCWSTR LocalizedKeys
[] = {ROOT
,MY
,CA
,ADDRESSBOOK
,TRUSTEDPUBLISHER
,DISALLOWED
};
73 static WCHAR LocalizedNames
[sizeof(LocalizedKeys
)/sizeof(LocalizedKeys
[0])][256];
75 static void free_function_sets(void)
77 struct OIDFunctionSet
*setCursor
, *setNext
;
79 LIST_FOR_EACH_ENTRY_SAFE(setCursor
, setNext
, &funcSets
,
80 struct OIDFunctionSet
, next
)
82 struct OIDFunction
*functionCursor
, *funcNext
;
84 list_remove(&setCursor
->next
);
85 CryptMemFree(setCursor
->name
);
86 LIST_FOR_EACH_ENTRY_SAFE(functionCursor
, funcNext
,
87 &setCursor
->functions
, struct OIDFunction
, next
)
89 list_remove(&functionCursor
->next
);
90 CryptMemFree(functionCursor
);
92 setCursor
->cs
.DebugInfo
->Spare
[0] = 0;
93 DeleteCriticalSection(&setCursor
->cs
);
94 CryptMemFree(setCursor
);
96 DeleteCriticalSection(&funcSetCS
);
99 /* There is no free function associated with this; therefore, the sets are
100 * freed when crypt32.dll is unloaded.
102 HCRYPTOIDFUNCSET WINAPI
CryptInitOIDFunctionSet(LPCSTR pszFuncName
,
105 struct OIDFunctionSet
*cursor
, *ret
= NULL
;
107 TRACE("(%s, %x)\n", debugstr_a(pszFuncName
), dwFlags
);
109 EnterCriticalSection(&funcSetCS
);
110 LIST_FOR_EACH_ENTRY(cursor
, &funcSets
, struct OIDFunctionSet
, next
)
112 if (!strcasecmp(pszFuncName
, cursor
->name
))
120 ret
= CryptMemAlloc(sizeof(struct OIDFunctionSet
));
123 memset(ret
, 0, sizeof(*ret
));
124 ret
->name
= CryptMemAlloc(strlen(pszFuncName
) + 1);
127 InitializeCriticalSection(&ret
->cs
);
128 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": OIDFunctionSet.cs");
129 list_init(&ret
->functions
);
130 strcpy(ret
->name
, pszFuncName
);
131 list_add_tail(&funcSets
, &ret
->next
);
140 LeaveCriticalSection(&funcSetCS
);
145 static char *CRYPT_GetKeyName(DWORD dwEncodingType
, LPCSTR pszFuncName
,
148 static const char szEncodingTypeFmt
[] =
149 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
151 char numericOID
[7]; /* enough for "#65535" */
155 /* MSDN says the encoding type is a mask, but it isn't treated that way.
156 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
157 * "EncodingType 2" would be expected if it were a mask. Instead native
158 * stores values in "EncodingType 3".
160 if (IS_INTOID(pszOID
))
162 snprintf(numericOID
, sizeof(numericOID
), "#%d", LOWORD(pszOID
));
168 /* This is enough: the lengths of the two string parameters are explicitly
169 * counted, and we need up to five additional characters for the encoding
170 * type. These are covered by the "%d", "%s", and "%s" characters in the
171 * format specifier that are removed by sprintf.
173 len
= sizeof(szEncodingTypeFmt
) + lstrlenA(pszFuncName
) + lstrlenA(oid
);
174 szKey
= CryptMemAlloc(len
);
176 sprintf(szKey
, szEncodingTypeFmt
,
177 GET_CERT_ENCODING_TYPE(dwEncodingType
), pszFuncName
, oid
);
181 BOOL WINAPI
CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet
,
182 DWORD dwEncodingType
, LPWSTR pwszDllList
, DWORD
*pcchDllList
)
185 struct OIDFunctionSet
*set
= hFuncSet
;
190 TRACE("(%p, %d, %p, %p)\n", hFuncSet
, dwEncodingType
, pwszDllList
,
193 keyName
= CRYPT_GetKeyName(dwEncodingType
, set
->name
, "DEFAULT");
194 rc
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0,
195 KEY_READ
, NULL
, &key
, NULL
);
198 DWORD size
= *pcchDllList
* sizeof(WCHAR
);
200 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
, (LPBYTE
)pwszDllList
,
203 *pcchDllList
= size
/ sizeof(WCHAR
);
206 /* No value, return an empty list */
207 if (pwszDllList
&& *pcchDllList
)
215 /* No value, return an empty list */
216 if (pwszDllList
&& *pcchDllList
)
220 CryptMemFree(keyName
);
225 BOOL WINAPI
CryptInstallOIDFunctionAddress(HMODULE hModule
,
226 DWORD dwEncodingType
, LPCSTR pszFuncName
, DWORD cFuncEntry
,
227 const CRYPT_OID_FUNC_ENTRY rgFuncEntry
[], DWORD dwFlags
)
230 struct OIDFunctionSet
*set
;
232 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule
, dwEncodingType
,
233 debugstr_a(pszFuncName
), cFuncEntry
, rgFuncEntry
, dwFlags
);
235 set
= CryptInitOIDFunctionSet(pszFuncName
, 0);
240 EnterCriticalSection(&set
->cs
);
241 for (i
= 0; ret
&& i
< cFuncEntry
; i
++)
243 struct OIDFunction
*func
;
245 if (!IS_INTOID(rgFuncEntry
[i
].pszOID
))
246 func
= CryptMemAlloc(sizeof(struct OIDFunction
)
247 + strlen(rgFuncEntry
[i
].pszOID
) + 1);
249 func
= CryptMemAlloc(sizeof(struct OIDFunction
));
252 func
->encoding
= GET_CERT_ENCODING_TYPE(dwEncodingType
);
253 if (!IS_INTOID(rgFuncEntry
[i
].pszOID
))
257 oid
= (LPSTR
)((LPBYTE
)func
+ sizeof(*func
));
258 strcpy(oid
, rgFuncEntry
[i
].pszOID
);
259 func
->entry
.pszOID
= oid
;
262 func
->entry
.pszOID
= rgFuncEntry
[i
].pszOID
;
263 func
->entry
.pvFuncAddr
= rgFuncEntry
[i
].pvFuncAddr
;
264 list_add_tail(&set
->functions
, &func
->next
);
269 LeaveCriticalSection(&set
->cs
);
283 static BOOL
CRYPT_GetFuncFromReg(DWORD dwEncodingType
, LPCSTR pszOID
,
284 LPCSTR szFuncName
, LPVOID
*ppvFuncAddr
, HCRYPTOIDFUNCADDR
*phFuncAddr
)
288 const char *funcName
;
292 keyName
= CRYPT_GetKeyName(dwEncodingType
, szFuncName
, pszOID
);
293 rc
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, KEY_READ
, &key
);
296 DWORD type
, size
= 0;
298 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
, NULL
, &size
);
299 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
301 funcName
= CryptMemAlloc(size
);
302 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
,
303 (LPBYTE
)funcName
, &size
);
306 funcName
= szFuncName
;
307 rc
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
308 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
310 LPWSTR dllName
= CryptMemAlloc(size
);
314 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
,
315 (LPBYTE
)dllName
, &size
);
320 /* This is a bit of a hack; MSDN describes a more
321 * complicated unload routine than this will allow.
322 * Still, this seems to suffice for now.
324 lib
= LoadLibraryW(dllName
);
327 *ppvFuncAddr
= GetProcAddress(lib
, funcName
);
330 struct FuncAddr
*addr
=
331 CryptMemAlloc(sizeof(struct FuncAddr
));
336 addr
->dllList
= addr
->currentDll
= NULL
;
348 /* Unload the library, the caller doesn't want
349 * to unload it when the return value is NULL.
357 CryptMemFree(dllName
);
362 if (funcName
!= szFuncName
)
363 CryptMemFree((char *)funcName
);
368 CryptMemFree(keyName
);
372 BOOL WINAPI
CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
373 DWORD dwEncodingType
, LPCSTR pszOID
, DWORD dwFlags
, void **ppvFuncAddr
,
374 HCRYPTOIDFUNCADDR
*phFuncAddr
)
377 struct OIDFunctionSet
*set
= hFuncSet
;
379 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
380 debugstr_a(pszOID
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
383 if (!(dwFlags
& CRYPT_GET_INSTALLED_OID_FUNC_FLAG
))
385 struct OIDFunction
*function
;
387 EnterCriticalSection(&set
->cs
);
388 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
390 if (function
->encoding
== GET_CERT_ENCODING_TYPE(dwEncodingType
))
392 if (!IS_INTOID(pszOID
))
394 if (!IS_INTOID(function
->entry
.pszOID
) &&
395 !strcasecmp(function
->entry
.pszOID
, pszOID
))
397 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
398 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
403 else if (function
->entry
.pszOID
== pszOID
)
405 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
406 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
412 LeaveCriticalSection(&set
->cs
);
415 ret
= CRYPT_GetFuncFromReg(dwEncodingType
, pszOID
, set
->name
,
416 ppvFuncAddr
, phFuncAddr
);
417 TRACE("returning %d\n", ret
);
421 BOOL WINAPI
CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr
,
424 TRACE("(%p, %08x)\n", hFuncAddr
, dwFlags
);
426 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
427 * and only unload it if it can be unloaded. Also need to implement ref
428 * counting on the functions.
432 struct FuncAddr
*addr
= hFuncAddr
;
434 CryptMemFree(addr
->dllList
);
435 FreeLibrary(addr
->lib
);
441 static BOOL
CRYPT_GetFuncFromDll(LPCWSTR dll
, LPCSTR func
, HMODULE
*lib
,
446 *lib
= LoadLibraryW(dll
);
449 *ppvFuncAddr
= GetProcAddress(*lib
, func
);
461 BOOL WINAPI
CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
462 DWORD dwEncodingType
, LPCWSTR pwszDll
, DWORD dwFlags
, void **ppvFuncAddr
,
463 HCRYPTOIDFUNCADDR
*phFuncAddr
)
465 struct OIDFunctionSet
*set
= hFuncSet
;
468 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
469 debugstr_w(pwszDll
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
476 ret
= CRYPT_GetFuncFromDll(pwszDll
, set
->name
, &lib
, ppvFuncAddr
);
479 struct FuncAddr
*addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
484 addr
->dllList
= addr
->currentDll
= NULL
;
491 SetLastError(ERROR_OUTOFMEMORY
);
496 SetLastError(ERROR_FILE_NOT_FOUND
);
500 struct FuncAddr
*addr
= *phFuncAddr
;
506 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
, NULL
,
510 LPWSTR dllList
= CryptMemAlloc(size
* sizeof(WCHAR
));
514 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
,
518 addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
521 addr
->dllList
= dllList
;
522 addr
->currentDll
= dllList
;
528 CryptMemFree(dllList
);
529 SetLastError(ERROR_OUTOFMEMORY
);
536 SetLastError(ERROR_OUTOFMEMORY
);
543 if (!*addr
->currentDll
)
545 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
546 SetLastError(ERROR_FILE_NOT_FOUND
);
552 /* FIXME: as elsewhere, can't free until DllCanUnloadNow says
553 * it's possible, and should defer unloading for some time to
554 * avoid repeated LoadLibrary/FreeLibrary on the same dll.
556 FreeLibrary(addr
->lib
);
557 ret
= CRYPT_GetFuncFromDll(addr
->currentDll
, set
->name
,
558 &addr
->lib
, ppvFuncAddr
);
561 /* Move past the current DLL */
562 addr
->currentDll
+= lstrlenW(addr
->currentDll
) + 1;
567 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
568 SetLastError(ERROR_FILE_NOT_FOUND
);
577 /***********************************************************************
578 * CryptRegisterOIDFunction (CRYPT32.@)
580 * Register the DLL and the functions it uses to cover the combination
581 * of encoding type, function name and OID.
584 * dwEncodingType [I] Encoding type to be used.
585 * pszFuncName [I] Name of the function to be registered.
586 * pszOID [I] OID of the function (numeric or string).
587 * pwszDll [I] The DLL that is to be registered.
588 * pszOverrideFuncName [I] Name of the function in the DLL.
592 * Failure: FALSE. (Look at GetLastError()).
595 * Registry errors are always reported via SetLastError().
597 BOOL WINAPI
CryptRegisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
598 LPCSTR pszOID
, LPCWSTR pwszDll
, LPCSTR pszOverrideFuncName
)
604 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
605 debugstr_a(pszOID
), debugstr_w(pwszDll
), debugstr_a(pszOverrideFuncName
));
607 /* Native does nothing pwszDll is NULL */
611 /* I'm not matching MS bug for bug here, because I doubt any app depends on
612 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
613 * it creates would never be used.
615 if (!pszFuncName
|| !pszOID
)
617 SetLastError(E_INVALIDARG
);
621 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
622 TRACE("Key name is %s\n", debugstr_a(szKey
));
627 r
= RegCreateKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
630 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
632 /* write the values */
633 if (pszOverrideFuncName
)
635 r
= RegSetValueExA(hKey
, "FuncName", 0, REG_SZ
,
636 (const BYTE
*)pszOverrideFuncName
, lstrlenA(pszOverrideFuncName
) + 1);
637 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
639 r
= RegSetValueExW(hKey
, DllW
, 0, REG_SZ
, (const BYTE
*) pwszDll
,
640 (lstrlenW(pwszDll
) + 1) * sizeof (WCHAR
));
646 if (r
!= ERROR_SUCCESS
)
655 /***********************************************************************
656 * CryptRegisterOIDInfo (CRYPT32.@)
658 BOOL WINAPI
CryptRegisterOIDInfo(PCCRYPT_OID_INFO pInfo
, DWORD dwFlags
)
660 FIXME("(%p, %x): stub\n", pInfo
, dwFlags
);
661 SetLastError(ERROR_CALL_NOT_IMPLEMENTED
);
665 /***********************************************************************
666 * CryptUnregisterOIDFunction (CRYPT32.@)
668 BOOL WINAPI
CryptUnregisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
674 TRACE("%x %s %s\n", dwEncodingType
, debugstr_a(pszFuncName
),
677 if (!pszFuncName
|| !pszOID
)
679 SetLastError(ERROR_INVALID_PARAMETER
);
683 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
684 rc
= RegDeleteKeyA(HKEY_LOCAL_MACHINE
, szKey
);
691 BOOL WINAPI
CryptGetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
692 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD
*pdwValueType
, BYTE
*pbValueData
,
699 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType
, debugstr_a(pszFuncName
),
700 debugstr_a(pszOID
), debugstr_w(pwszValueName
), pdwValueType
, pbValueData
,
703 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
706 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
708 SetLastError(ERROR_INVALID_PARAMETER
);
712 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
713 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
719 rc
= RegQueryValueExW(hKey
, pwszValueName
, NULL
, pdwValueType
,
720 pbValueData
, pcbValueData
);
728 BOOL WINAPI
CryptSetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
729 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD dwValueType
,
730 const BYTE
*pbValueData
, DWORD cbValueData
)
736 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType
, debugstr_a(pszFuncName
),
737 debugstr_a(pszOID
), debugstr_w(pwszValueName
), dwValueType
, pbValueData
,
740 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
743 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
745 SetLastError(ERROR_INVALID_PARAMETER
);
749 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
750 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
756 rc
= RegSetValueExW(hKey
, pwszValueName
, 0, dwValueType
, pbValueData
,
765 static LPCWSTR
CRYPT_FindStringInMultiString(LPCWSTR multi
, LPCWSTR toFind
)
767 LPCWSTR ret
= NULL
, ptr
;
769 for (ptr
= multi
; ptr
&& *ptr
&& !ret
; ptr
+= lstrlenW(ptr
) + 1)
771 if (!lstrcmpiW(ptr
, toFind
))
777 static DWORD
CRYPT_GetMultiStringCharacterLen(LPCWSTR multi
)
785 /* Count terminating empty string */
787 for (ptr
= multi
; *ptr
; ptr
+= lstrlenW(ptr
) + 1)
788 ret
+= lstrlenW(ptr
) + 1;
795 static LPWSTR
CRYPT_AddStringToMultiString(LPWSTR multi
, LPCWSTR toAdd
,
802 /* FIXME: ignoring index, is that okay? */
803 ret
= CryptMemAlloc((lstrlenW(toAdd
) + 2) * sizeof(WCHAR
));
806 /* copy string, including NULL terminator */
807 memcpy(ret
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
808 /* add terminating empty string */
809 *(ret
+ lstrlenW(toAdd
) + 1) = 0;
814 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
816 ret
= CryptMemRealloc(multi
, (len
+ lstrlenW(toAdd
) + 1) *
822 if (index
== CRYPT_REGISTER_LAST_INDEX
)
823 spotToAdd
= ret
+ len
- 1;
828 /* FIXME: if index is too large for the string, toAdd is
829 * added to the end. Is that okay?
831 for (i
= 0, spotToAdd
= ret
; i
< index
&& *spotToAdd
;
832 spotToAdd
+= lstrlenW(spotToAdd
) + 1)
837 /* Copy existing string "right" */
838 memmove(spotToAdd
+ lstrlenW(toAdd
) + 1, spotToAdd
,
839 (len
- (spotToAdd
- ret
)) * sizeof(WCHAR
));
840 /* Copy new string */
841 memcpy(spotToAdd
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
853 static BOOL
CRYPT_RemoveStringFromMultiString(LPWSTR multi
, LPCWSTR toRemove
)
855 LPWSTR spotToRemove
= (LPWSTR
)CRYPT_FindStringInMultiString(multi
,
861 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
863 if (spotToRemove
+ lstrlenW(toRemove
) + 2 >= multi
+ len
)
865 /* Removing last string in list, terminate multi string directly */
867 *(spotToRemove
+ 1) = 0;
871 LPCWSTR nextStr
= spotToRemove
+ lstrlenW(toRemove
) + 1;
873 /* Copy remainder of string "left" */
874 memmove(spotToRemove
, nextStr
,
875 (len
- (nextStr
- multi
)) * sizeof(WCHAR
));
881 SetLastError(ERROR_FILE_NOT_FOUND
);
887 static BOOL
CRYPT_GetDefaultOIDKey(DWORD dwEncodingType
, LPCSTR pszFuncName
,
893 keyName
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, "DEFAULT");
894 TRACE("Key name is %s\n", debugstr_a(keyName
));
899 r
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0, KEY_ALL_ACCESS
,
901 CryptMemFree(keyName
);
902 if (r
!= ERROR_SUCCESS
)
910 static LPWSTR
CRYPT_GetDefaultOIDDlls(HKEY key
)
916 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
917 if (r
== ERROR_SUCCESS
&& type
== REG_MULTI_SZ
)
919 dlls
= CryptMemAlloc(size
);
920 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, (LPBYTE
)dlls
, &size
);
921 if (r
!= ERROR_SUCCESS
)
932 static inline BOOL
CRYPT_SetDefaultOIDDlls(HKEY key
, LPCWSTR dlls
)
934 DWORD len
= CRYPT_GetMultiStringCharacterLen(dlls
);
937 if ((r
= RegSetValueExW(key
, DllW
, 0, REG_MULTI_SZ
, (const BYTE
*)dlls
,
938 len
* sizeof (WCHAR
))))
940 return r
== ERROR_SUCCESS
;
943 /***********************************************************************
944 * CryptRegisterDefaultOIDFunction (CRYPT32.@)
946 BOOL WINAPI
CryptRegisterDefaultOIDFunction(DWORD dwEncodingType
,
947 LPCSTR pszFuncName
, DWORD dwIndex
, LPCWSTR pwszDll
)
953 TRACE("(%x, %s, %d, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
954 dwIndex
, debugstr_w(pwszDll
));
958 SetLastError(E_INVALIDARG
);
962 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
965 dlls
= CRYPT_GetDefaultOIDDlls(key
);
966 if (CRYPT_FindStringInMultiString(dlls
, pwszDll
))
967 SetLastError(ERROR_FILE_EXISTS
);
970 dlls
= CRYPT_AddStringToMultiString(dlls
, pwszDll
, dwIndex
);
972 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
979 BOOL WINAPI
CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType
,
980 LPCSTR pszFuncName
, LPCWSTR pwszDll
)
986 TRACE("(%x, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
987 debugstr_w(pwszDll
));
991 SetLastError(E_INVALIDARG
);
995 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
998 dlls
= CRYPT_GetDefaultOIDDlls(key
);
999 if ((ret
= CRYPT_RemoveStringFromMultiString(dlls
, pwszDll
)))
1000 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
1006 static void oid_init_localizednames(void)
1010 for(i
= 0; i
< sizeof(LocalizedKeys
)/sizeof(LPCWSTR
); i
++)
1012 LoadStringW(hInstance
, IDS_LOCALIZEDNAME_ROOT
+i
, LocalizedNames
[i
], 256);
1016 /********************************************************************
1017 * CryptFindLocalizedName (CRYPT32.@)
1019 LPCWSTR WINAPI
CryptFindLocalizedName(LPCWSTR pwszCryptName
)
1023 for(i
= 0; i
< sizeof(LocalizedKeys
)/sizeof(LPCWSTR
); i
++)
1025 if(!lstrcmpiW(LocalizedKeys
[i
], pwszCryptName
))
1027 return LocalizedNames
[i
];
1031 FIXME("No name for: %s - stub\n",debugstr_w(pwszCryptName
));
1035 static CRITICAL_SECTION oidInfoCS
;
1036 static CRITICAL_SECTION_DEBUG oidInfoCSDebug
=
1039 { &oidInfoCSDebug
.ProcessLocksList
, &oidInfoCSDebug
.ProcessLocksList
},
1040 0, 0, { (DWORD_PTR
)(__FILE__
": oidInfoCS") }
1042 static CRITICAL_SECTION oidInfoCS
= { &oidInfoCSDebug
, -1, 0, 0, 0, 0 };
1043 static struct list oidInfo
= { &oidInfo
, &oidInfo
};
1045 static const WCHAR tripledes
[] = { '3','d','e','s',0 };
1046 static const WCHAR cms3deswrap
[] = { 'C','M','S','3','D','E','S','w','r','a',
1048 static const WCHAR cmsrc2wrap
[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
1049 static const WCHAR des
[] = { 'd','e','s',0 };
1050 static const WCHAR md2
[] = { 'm','d','2',0 };
1051 static const WCHAR md4
[] = { 'm','d','4',0 };
1052 static const WCHAR md5
[] = { 'm','d','5',0 };
1053 static const WCHAR rc2
[] = { 'r','c','2',0 };
1054 static const WCHAR rc4
[] = { 'r','c','4',0 };
1055 static const WCHAR sha
[] = { 's','h','a',0 };
1056 static const WCHAR sha1
[] = { 's','h','a','1',0 };
1057 static const WCHAR sha256
[] = { 's','h','a','2','5','6',0 };
1058 static const WCHAR sha384
[] = { 's','h','a','3','8','4',0 };
1059 static const WCHAR sha512
[] = { 's','h','a','5','1','2',0 };
1060 static const WCHAR RSA
[] = { 'R','S','A',0 };
1061 static const WCHAR RSA_KEYX
[] = { 'R','S','A','_','K','E','Y','X',0 };
1062 static const WCHAR RSA_SIGN
[] = { 'R','S','A','_','S','I','G','N',0 };
1063 static const WCHAR DSA
[] = { 'D','S','A',0 };
1064 static const WCHAR DSA_SIGN
[] = { 'D','S','A','_','S','I','G','N',0 };
1065 static const WCHAR DH
[] = { 'D','H',0 };
1066 static const WCHAR DSS
[] = { 'D','S','S',0 };
1067 static const WCHAR mosaicKMandUpdSig
[] =
1068 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
1069 static const WCHAR ESDH
[] = { 'E','S','D','H',0 };
1070 static const WCHAR NO_SIGN
[] = { 'N','O','S','I','G','N',0 };
1071 static const WCHAR dsaSHA1
[] = { 'd','s','a','S','H','A','1',0 };
1072 static const WCHAR md2RSA
[] = { 'm','d','2','R','S','A',0 };
1073 static const WCHAR md4RSA
[] = { 'm','d','4','R','S','A',0 };
1074 static const WCHAR md5RSA
[] = { 'm','d','5','R','S','A',0 };
1075 static const WCHAR shaDSA
[] = { 's','h','a','D','S','A',0 };
1076 static const WCHAR sha1DSA
[] = { 's','h','a','1','D','S','A',0 };
1077 static const WCHAR shaRSA
[] = { 's','h','a','R','S','A',0 };
1078 static const WCHAR sha1RSA
[] = { 's','h','a','1','R','S','A',0 };
1079 static const WCHAR sha256RSA
[] = { 's','h','a','2','5','6','R','S','A',0 };
1080 static const WCHAR sha384RSA
[] = { 's','h','a','3','8','4','R','S','A',0 };
1081 static const WCHAR sha512RSA
[] = { 's','h','a','5','1','2','R','S','A',0 };
1082 static const WCHAR mosaicUpdatedSig
[] =
1083 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
1084 static const WCHAR sha256ECDSA
[] = { 's','h','a','2','5','6','E','C','D','S','A',0 };
1085 static const WCHAR sha384ECDSA
[] = { 's','h','a','3','8','4','E','C','D','S','A',0 };
1086 static const WCHAR CN
[] = { 'C','N',0 };
1087 static const WCHAR L
[] = { 'L',0 };
1088 static const WCHAR O
[] = { 'O',0 };
1089 static const WCHAR OU
[] = { 'O','U',0 };
1090 static const WCHAR E
[] = { 'E',0 };
1091 static const WCHAR C
[] = { 'C',0 };
1092 static const WCHAR S
[] = { 'S',0 };
1093 static const WCHAR ST
[] = { 'S','T',0 };
1094 static const WCHAR STREET
[] = { 'S','T','R','E','E','T',0 };
1095 static const WCHAR T
[] = { 'T',0 };
1096 static const WCHAR Title
[] = { 'T','i','t','l','e',0 };
1097 static const WCHAR G
[] = { 'G',0 };
1098 static const WCHAR GivenName
[] = { 'G','i','v','e','n','N','a','m','e',0 };
1099 static const WCHAR I
[] = { 'I',0 };
1100 static const WCHAR Initials
[] = { 'I','n','i','t','i','a','l','s',0 };
1101 static const WCHAR SN
[] = { 'S','N',0 };
1102 static const WCHAR DC
[] = { 'D','C',0 };
1103 static const WCHAR Description
[] =
1104 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
1105 static const WCHAR PostalCode
[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
1106 static const WCHAR POBox
[] = { 'P','O','B','o','x',0 };
1107 static const WCHAR Phone
[] = { 'P','h','o','n','e',0 };
1108 static const WCHAR X21Address
[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
1109 static const WCHAR dnQualifier
[] =
1110 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
1111 static const WCHAR SpcSpAgencyInfo
[] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 };
1112 static const WCHAR SpcFinancialCriteria
[] = { 'S','p','c','F','i','n','a','n','c','i','a','l','C','r','i','t','e','r','i','a',0 };
1113 static const WCHAR SpcMinimalCriteria
[] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 };
1114 static const WCHAR Email
[] = { 'E','m','a','i','l',0 };
1115 static const WCHAR GN
[] = { 'G','N',0 };
1116 static const WCHAR SERIALNUMBER
[] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 };
1118 static const DWORD noNullFlag
= CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1119 static const DWORD mosaicFlags
= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1120 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1121 static const CRYPT_DATA_BLOB noNullBlob
= { sizeof(noNullFlag
),
1122 (LPBYTE
)&noNullFlag
};
1123 static const CRYPT_DATA_BLOB mosaicFlagsBlob
= { sizeof(mosaicFlags
),
1124 (LPBYTE
)&mosaicFlags
};
1126 static const DWORD rsaSign
= CALG_RSA_SIGN
;
1127 static const DWORD dssSign
[2] = { CALG_DSS_SIGN
,
1128 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1129 static const DWORD mosaicSign
[2] = { CALG_DSS_SIGN
,
1130 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1131 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1132 static const DWORD ecdsaSign
[2] = { CALG_OID_INFO_PARAMETERS
,
1133 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1134 static const CRYPT_DATA_BLOB rsaSignBlob
= { sizeof(rsaSign
),
1136 static const CRYPT_DATA_BLOB dssSignBlob
= { sizeof(dssSign
),
1138 static const CRYPT_DATA_BLOB mosaicSignBlob
= { sizeof(mosaicSign
),
1139 (LPBYTE
)mosaicSign
};
1140 static const CRYPT_DATA_BLOB ecdsaSignBlob
= { sizeof(ecdsaSign
),
1141 (LPBYTE
)ecdsaSign
};
1143 static const DWORD ia5String
[] = { CERT_RDN_IA5_STRING
, 0 };
1144 static const DWORD numericString
[] = { CERT_RDN_NUMERIC_STRING
, 0 };
1145 static const DWORD printableString
[] = { CERT_RDN_PRINTABLE_STRING
, 0 };
1146 static const DWORD domainCompTypes
[] = { CERT_RDN_IA5_STRING
,
1147 CERT_RDN_UTF8_STRING
, 0 };
1148 static const CRYPT_DATA_BLOB ia5StringBlob
= { sizeof(ia5String
),
1149 (LPBYTE
)ia5String
};
1150 static const CRYPT_DATA_BLOB numericStringBlob
= { sizeof(numericString
),
1151 (LPBYTE
)numericString
};
1152 static const CRYPT_DATA_BLOB printableStringBlob
= { sizeof(printableString
),
1153 (LPBYTE
)printableString
};
1154 static const CRYPT_DATA_BLOB domainCompTypesBlob
= { sizeof(domainCompTypes
),
1155 (LPBYTE
)domainCompTypes
};
1157 static const struct OIDInfoConstructor
{
1162 const CRYPT_DATA_BLOB
*blob
;
1163 LPCWSTR pwszCNGAlgid
;
1164 LPCWSTR pwszCNGExtraAlgid
;
1165 } oidInfoConstructors
[] = {
1166 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha1
, NULL
},
1167 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha
, NULL
},
1168 { 1, szOID_OIWSEC_sha
, CALG_SHA
, sha
, NULL
},
1169 { 1, szOID_RSA_MD5
, CALG_MD5
, md5
, NULL
},
1170 { 1, szOID_RSA_MD4
, CALG_MD4
, md4
, NULL
},
1171 { 1, szOID_RSA_MD2
, CALG_MD2
, md2
, NULL
},
1172 /* NOTE: Windows Vista+ uses -1 instead of CALG_SHA_* following SHA entries. */
1173 { 1, szOID_NIST_sha256
, CALG_SHA_256
, sha256
, NULL
},
1174 { 1, szOID_NIST_sha384
, CALG_SHA_384
, sha384
, NULL
},
1175 { 1, szOID_NIST_sha512
, CALG_SHA_512
, sha512
, NULL
},
1177 { 2, szOID_OIWSEC_desCBC
, CALG_DES
, des
, NULL
},
1178 { 2, szOID_RSA_DES_EDE3_CBC
, CALG_3DES
, tripledes
, NULL
},
1179 { 2, szOID_RSA_RC2CBC
, CALG_RC2
, rc2
, NULL
},
1180 { 2, szOID_RSA_RC4
, CALG_RC4
, rc4
, NULL
},
1181 { 2, szOID_RSA_SMIMEalgCMS3DESwrap
, CALG_3DES
, cms3deswrap
, NULL
},
1182 { 2, szOID_RSA_SMIMEalgCMSRC2wrap
, CALG_RC2
, cmsrc2wrap
, NULL
},
1184 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA
, NULL
},
1185 { 3, szOID_X957_DSA
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1186 { 3, szOID_ANSI_X942_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1187 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1188 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA
, NULL
},
1189 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA_SIGN
, NULL
},
1190 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1191 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSS
, &noNullBlob
},
1192 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA_SIGN
, &noNullBlob
},
1193 { 3, szOID_RSA_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1194 { 3, szOID_OIWSEC_rsaXchg
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1195 { 3, szOID_INFOSEC_mosaicKMandUpdSig
, CALG_DSS_SIGN
, mosaicKMandUpdSig
,
1197 { 3, szOID_RSA_SMIMEalgESDH
, CALG_DH_EPHEM
, ESDH
, &noNullBlob
},
1198 { 3, szOID_PKIX_NO_SIGNATURE
, CALG_NO_SIGN
, NO_SIGN
, NULL
},
1200 { 4, szOID_RSA_SHA1RSA
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1201 { 4, szOID_RSA_SHA256RSA
, CALG_SHA_256
, sha256RSA
, &rsaSignBlob
},
1202 { 4, szOID_RSA_SHA384RSA
, CALG_SHA_384
, sha384RSA
, &rsaSignBlob
},
1203 { 4, szOID_RSA_SHA512RSA
, CALG_SHA_512
, sha512RSA
, &rsaSignBlob
},
1204 { 4, szOID_RSA_MD5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1205 { 4, szOID_X957_SHA1DSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1206 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1207 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1208 { 4, szOID_OIWSEC_shaRSA
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1209 { 4, szOID_OIWSEC_md5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1210 { 4, szOID_RSA_MD2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1211 { 4, szOID_RSA_MD4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1212 { 4, szOID_OIWSEC_md4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1213 { 4, szOID_OIWSEC_md4RSA2
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1214 { 4, szOID_OIWDIR_md2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1215 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1216 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, shaDSA
, &dssSignBlob
},
1217 { 4, szOID_OIWSEC_dsaSHA1
, CALG_SHA1
, dsaSHA1
, &dssSignBlob
},
1218 { 4, szOID_INFOSEC_mosaicUpdatedSig
, CALG_SHA1
, mosaicUpdatedSig
,
1220 { 4, szOID_ECDSA_SHA256
, CALG_OID_INFO_CNG_ONLY
, sha256ECDSA
, &ecdsaSignBlob
,
1221 BCRYPT_SHA256_ALGORITHM
, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM
},
1222 { 4, szOID_ECDSA_SHA384
, CALG_OID_INFO_CNG_ONLY
, sha384ECDSA
, &ecdsaSignBlob
,
1223 BCRYPT_SHA384_ALGORITHM
, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM
},
1225 { 5, szOID_COMMON_NAME
, 0, CN
, NULL
},
1226 { 5, szOID_LOCALITY_NAME
, 0, L
, NULL
},
1227 { 5, szOID_ORGANIZATION_NAME
, 0, O
, NULL
},
1228 { 5, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, OU
, NULL
},
1229 { 5, szOID_RSA_emailAddr
, 0, E
, &ia5StringBlob
},
1230 { 5, szOID_RSA_emailAddr
, 0, Email
, &ia5StringBlob
},
1231 { 5, szOID_COUNTRY_NAME
, 0, C
, &printableStringBlob
},
1232 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, S
, NULL
},
1233 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, ST
, NULL
},
1234 { 5, szOID_STREET_ADDRESS
, 0, STREET
, NULL
},
1235 { 5, szOID_TITLE
, 0, T
, NULL
},
1236 { 5, szOID_TITLE
, 0, Title
, NULL
},
1237 { 5, szOID_GIVEN_NAME
, 0, G
, NULL
},
1238 { 5, szOID_GIVEN_NAME
, 0, GN
, NULL
},
1239 { 5, szOID_GIVEN_NAME
, 0, GivenName
, NULL
},
1240 { 5, szOID_INITIALS
, 0, I
, NULL
},
1241 { 5, szOID_INITIALS
, 0, Initials
, NULL
},
1242 { 5, szOID_SUR_NAME
, 0, SN
, NULL
},
1243 { 5, szOID_DOMAIN_COMPONENT
, 0, DC
, &domainCompTypesBlob
},
1244 { 5, szOID_DESCRIPTION
, 0, Description
, NULL
},
1245 { 5, szOID_POSTAL_CODE
, 0, PostalCode
, NULL
},
1246 { 5, szOID_POST_OFFICE_BOX
, 0, POBox
, NULL
},
1247 { 5, szOID_TELEPHONE_NUMBER
, 0, Phone
, &printableStringBlob
},
1248 { 5, szOID_X21_ADDRESS
, 0, X21Address
, &numericStringBlob
},
1249 { 5, szOID_DN_QUALIFIER
, 0, dnQualifier
, NULL
},
1250 { 5, szOID_DEVICE_SERIAL_NUMBER
, 0, SERIALNUMBER
, NULL
},
1252 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1253 { 6, szOID_AUTHORITY_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1254 { 6, szOID_KEY_ATTRIBUTES
, 0, (LPCWSTR
)IDS_KEY_ATTRIBUTES
, NULL
},
1255 { 6, szOID_KEY_USAGE_RESTRICTION
, 0, (LPCWSTR
)IDS_KEY_USAGE_RESTRICTION
, NULL
},
1256 { 6, szOID_SUBJECT_ALT_NAME2
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1257 { 6, szOID_SUBJECT_ALT_NAME
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1258 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1259 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1260 { 6, szOID_BASIC_CONSTRAINTS2
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1261 { 6, szOID_BASIC_CONSTRAINTS
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1262 { 6, szOID_KEY_USAGE
, 0, (LPCWSTR
)IDS_KEY_USAGE
, NULL
},
1263 { 6, szOID_CERT_POLICIES
, 0, (LPCWSTR
)IDS_CERT_POLICIES
, NULL
},
1264 { 6, szOID_SUBJECT_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_SUBJECT_KEY_IDENTIFIER
, NULL
},
1265 { 6, szOID_CRL_REASON_CODE
, 0, (LPCWSTR
)IDS_CRL_REASON_CODE
, NULL
},
1266 { 6, szOID_CRL_DIST_POINTS
, 0, (LPCWSTR
)IDS_CRL_DIST_POINTS
, NULL
},
1267 { 6, szOID_ENHANCED_KEY_USAGE
, 0, (LPCWSTR
)IDS_ENHANCED_KEY_USAGE
, NULL
},
1268 { 6, szOID_AUTHORITY_INFO_ACCESS
, 0, (LPCWSTR
)IDS_AUTHORITY_INFO_ACCESS
, NULL
},
1269 { 6, szOID_CERT_EXTENSIONS
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1270 { 6, szOID_RSA_certExtensions
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1271 { 6, szOID_NEXT_UPDATE_LOCATION
, 0, (LPCWSTR
)IDS_NEXT_UPDATE_LOCATION
, NULL
},
1272 { 6, szOID_YESNO_TRUST_ATTR
, 0, (LPCWSTR
)IDS_YES_OR_NO_TRUST
, NULL
},
1273 { 6, szOID_RSA_emailAddr
, 0, (LPCWSTR
)IDS_EMAIL_ADDRESS
, NULL
},
1274 { 6, szOID_RSA_unstructName
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_NAME
, NULL
},
1275 { 6, szOID_RSA_contentType
, 0, (LPCWSTR
)IDS_CONTENT_TYPE
, NULL
},
1276 { 6, szOID_RSA_messageDigest
, 0, (LPCWSTR
)IDS_MESSAGE_DIGEST
, NULL
},
1277 { 6, szOID_RSA_signingTime
, 0, (LPCWSTR
)IDS_SIGNING_TIME
, NULL
},
1278 { 6, szOID_RSA_counterSign
, 0, (LPCWSTR
)IDS_COUNTER_SIGN
, NULL
},
1279 { 6, szOID_RSA_challengePwd
, 0, (LPCWSTR
)IDS_CHALLENGE_PASSWORD
, NULL
},
1280 { 6, szOID_RSA_unstructAddr
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_ADDRESS
, NULL
},
1281 { 6, szOID_RSA_SMIMECapabilities
, 0, (LPCWSTR
)IDS_SMIME_CAPABILITIES
, NULL
},
1282 { 6, szOID_RSA_preferSignedData
, 0, (LPCWSTR
)IDS_PREFER_SIGNED_DATA
, NULL
},
1283 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS
, 0, (LPCWSTR
)IDS_CPS
, NULL
},
1284 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
, 0, (LPCWSTR
)IDS_USER_NOTICE
, NULL
},
1285 { 6, szOID_PKIX_OCSP
, 0, (LPCWSTR
)IDS_OCSP
, NULL
},
1286 { 6, szOID_PKIX_CA_ISSUERS
, 0, (LPCWSTR
)IDS_CA_ISSUER
, NULL
},
1287 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TEMPLATE_NAME
, NULL
},
1288 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TYPE
, NULL
},
1289 { 6, szOID_CERT_MANIFOLD
, 0, (LPCWSTR
)IDS_CERT_MANIFOLD
, NULL
},
1290 { 6, szOID_NETSCAPE_CERT_TYPE
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_TYPE
, NULL
},
1291 { 6, szOID_NETSCAPE_BASE_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_BASE_URL
, NULL
},
1292 { 6, szOID_NETSCAPE_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_REVOCATION_URL
, NULL
},
1293 { 6, szOID_NETSCAPE_CA_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_REVOCATION_URL
, NULL
},
1294 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_RENEWAL_URL
, NULL
},
1295 { 6, szOID_NETSCAPE_CA_POLICY_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_POLICY_URL
, NULL
},
1296 { 6, szOID_NETSCAPE_SSL_SERVER_NAME
, 0, (LPCWSTR
)IDS_NETSCAPE_SSL_SERVER_NAME
, NULL
},
1297 { 6, szOID_NETSCAPE_COMMENT
, 0, (LPCWSTR
)IDS_NETSCAPE_COMMENT
, NULL
},
1298 { 6, "1.3.6.1.4.1.311.2.1.10", 0, SpcSpAgencyInfo
, NULL
},
1299 { 6, "1.3.6.1.4.1.311.2.1.27", 0, SpcFinancialCriteria
, NULL
},
1300 { 6, "1.3.6.1.4.1.311.2.1.26", 0, SpcMinimalCriteria
, NULL
},
1301 { 6, szOID_COUNTRY_NAME
, 0, (LPCWSTR
)IDS_COUNTRY
, NULL
},
1302 { 6, szOID_ORGANIZATION_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATION
, NULL
},
1303 { 6, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATIONAL_UNIT
, NULL
},
1304 { 6, szOID_COMMON_NAME
, 0, (LPCWSTR
)IDS_COMMON_NAME
, NULL
},
1305 { 6, szOID_LOCALITY_NAME
, 0, (LPCWSTR
)IDS_LOCALITY
, NULL
},
1306 { 6, szOID_STATE_OR_PROVINCE_NAME
, 0, (LPCWSTR
)IDS_STATE_OR_PROVINCE
, NULL
},
1307 { 6, szOID_TITLE
, 0, (LPCWSTR
)IDS_TITLE
, NULL
},
1308 { 6, szOID_GIVEN_NAME
, 0, (LPCWSTR
)IDS_GIVEN_NAME
, NULL
},
1309 { 6, szOID_INITIALS
, 0, (LPCWSTR
)IDS_INITIALS
, NULL
},
1310 { 6, szOID_SUR_NAME
, 0, (LPCWSTR
)IDS_SUR_NAME
, NULL
},
1311 { 6, szOID_DOMAIN_COMPONENT
, 0, (LPCWSTR
)IDS_DOMAIN_COMPONENT
, NULL
},
1312 { 6, szOID_STREET_ADDRESS
, 0, (LPCWSTR
)IDS_STREET_ADDRESS
, NULL
},
1313 { 6, szOID_DEVICE_SERIAL_NUMBER
, 0, (LPCWSTR
)IDS_SERIAL_NUMBER
, NULL
},
1314 { 6, szOID_CERTSRV_CA_VERSION
, 0, (LPCWSTR
)IDS_CA_VERSION
, NULL
},
1315 { 6, szOID_CERTSRV_CROSSCA_VERSION
, 0, (LPCWSTR
)IDS_CROSS_CA_VERSION
, NULL
},
1316 { 6, szOID_SERIALIZED
, 0, (LPCWSTR
)IDS_SERIALIZED_SIG_SERIAL_NUMBER
, NULL
},
1317 { 6, szOID_NT_PRINCIPAL_NAME
, 0, (LPCWSTR
)IDS_PRINCIPAL_NAME
, NULL
},
1318 { 6, szOID_PRODUCT_UPDATE
, 0, (LPCWSTR
)IDS_WINDOWS_PRODUCT_UPDATE
, NULL
},
1319 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR
, 0, (LPCWSTR
)IDS_ENROLLMENT_NAME_VALUE_PAIR
, NULL
},
1320 { 6, szOID_OS_VERSION
, 0, (LPCWSTR
)IDS_OS_VERSION
, NULL
},
1321 { 6, szOID_ENROLLMENT_CSP_PROVIDER
, 0, (LPCWSTR
)IDS_ENROLLMENT_CSP
, NULL
},
1322 { 6, szOID_CRL_NUMBER
, 0, (LPCWSTR
)IDS_CRL_NUMBER
, NULL
},
1323 { 6, szOID_DELTA_CRL_INDICATOR
, 0, (LPCWSTR
)IDS_DELTA_CRL_INDICATOR
, NULL
},
1324 { 6, szOID_ISSUING_DIST_POINT
, 0, (LPCWSTR
)IDS_ISSUING_DIST_POINT
, NULL
},
1325 { 6, szOID_FRESHEST_CRL
, 0, (LPCWSTR
)IDS_FRESHEST_CRL
, NULL
},
1326 { 6, szOID_NAME_CONSTRAINTS
, 0, (LPCWSTR
)IDS_NAME_CONSTRAINTS
, NULL
},
1327 { 6, szOID_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1328 { 6, szOID_LEGACY_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1329 { 6, szOID_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_POLICY_CONSTRAINTS
, NULL
},
1330 { 6, szOID_CROSS_CERT_DIST_POINTS
, 0, (LPCWSTR
)IDS_CROSS_CERT_DIST_POINTS
, NULL
},
1331 { 6, szOID_APPLICATION_CERT_POLICIES
, 0, (LPCWSTR
)IDS_APPLICATION_POLICIES
, NULL
},
1332 { 6, szOID_APPLICATION_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_MAPPINGS
, NULL
},
1333 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_CONSTRAINTS
, NULL
},
1334 { 6, szOID_CT_PKI_DATA
, 0, (LPCWSTR
)IDS_CMC_DATA
, NULL
},
1335 { 6, szOID_CT_PKI_RESPONSE
, 0, (LPCWSTR
)IDS_CMC_RESPONSE
, NULL
},
1336 { 6, szOID_CMC
, 0, (LPCWSTR
)IDS_UNSIGNED_CMC_REQUEST
, NULL
},
1337 { 6, szOID_CMC_STATUS_INFO
, 0, (LPCWSTR
)IDS_CMC_STATUS_INFO
, NULL
},
1338 { 6, szOID_CMC_ADD_EXTENSIONS
, 0, (LPCWSTR
)IDS_CMC_EXTENSIONS
, NULL
},
1339 { 6, szOID_CTL
, 0, (LPCWSTR
)IDS_CMC_ATTRIBUTES
, NULL
},
1340 { 6, szOID_RSA_data
, 0, (LPCWSTR
)IDS_PKCS_7_DATA
, NULL
},
1341 { 6, szOID_RSA_signedData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED
, NULL
},
1342 { 6, szOID_RSA_envelopedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENVELOPED
, NULL
},
1343 { 6, szOID_RSA_signEnvData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED_ENVELOPED
, NULL
},
1344 { 6, szOID_RSA_digestedData
, 0, (LPCWSTR
)IDS_PKCS_7_DIGESTED
, NULL
},
1345 { 6, szOID_RSA_encryptedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENCRYPTED
, NULL
},
1346 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH
, 0, (LPCWSTR
)IDS_PREVIOUS_CA_CERT_HASH
, NULL
},
1347 { 6, szOID_CRL_VIRTUAL_BASE
, 0, (LPCWSTR
)IDS_CRL_VIRTUAL_BASE
, NULL
},
1348 { 6, szOID_CRL_NEXT_PUBLISH
, 0, (LPCWSTR
)IDS_CRL_NEXT_PUBLISH
, NULL
},
1349 { 6, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1350 { 6, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1351 { 6, szOID_CERTIFICATE_TEMPLATE
, 0, (LPCWSTR
)IDS_CERTIFICATE_TEMPLATE
, NULL
},
1352 { 6, szOID_ENTERPRISE_OID_ROOT
, 0, (LPCWSTR
)IDS_ENTERPRISE_ROOT_OID
, NULL
},
1353 { 6, szOID_RDN_DUMMY_SIGNER
, 0, (LPCWSTR
)IDS_RDN_DUMMY_SIGNER
, NULL
},
1354 { 6, szOID_ARCHIVED_KEY_ATTR
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_ATTR
, NULL
},
1355 { 6, szOID_CRL_SELF_CDP
, 0, (LPCWSTR
)IDS_CRL_SELF_CDP
, NULL
},
1356 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY
, 0, (LPCWSTR
)IDS_REQUIRE_CERT_CHAIN_POLICY
, NULL
},
1357 { 6, szOID_CMC_TRANSACTION_ID
, 0, (LPCWSTR
)IDS_TRANSACTION_ID
, NULL
},
1358 { 6, szOID_CMC_SENDER_NONCE
, 0, (LPCWSTR
)IDS_SENDER_NONCE
, NULL
},
1359 { 6, szOID_CMC_RECIPIENT_NONCE
, 0, (LPCWSTR
)IDS_RECIPIENT_NONCE
, NULL
},
1360 { 6, szOID_CMC_REG_INFO
, 0, (LPCWSTR
)IDS_REG_INFO
, NULL
},
1361 { 6, szOID_CMC_GET_CERT
, 0, (LPCWSTR
)IDS_GET_CERTIFICATE
, NULL
},
1362 { 6, szOID_CMC_GET_CRL
, 0, (LPCWSTR
)IDS_GET_CRL
, NULL
},
1363 { 6, szOID_CMC_REVOKE_REQUEST
, 0, (LPCWSTR
)IDS_REVOKE_REQUEST
, NULL
},
1364 { 6, szOID_CMC_QUERY_PENDING
, 0, (LPCWSTR
)IDS_QUERY_PENDING
, NULL
},
1365 { 6, szOID_SORTED_CTL
, 0, (LPCWSTR
)IDS_SORTED_CTL
, NULL
},
1366 { 6, szOID_ARCHIVED_KEY_CERT_HASH
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_CERT_HASH
, NULL
},
1367 { 6, szOID_PRIVATEKEY_USAGE_PERIOD
, 0, (LPCWSTR
)IDS_PRIVATE_KEY_USAGE_PERIOD
, NULL
},
1368 { 6, szOID_REQUEST_CLIENT_INFO
, 0, (LPCWSTR
)IDS_CLIENT_INFORMATION
, NULL
},
1370 { 7, szOID_PKIX_KP_SERVER_AUTH
, 0, (LPCWSTR
)IDS_SERVER_AUTHENTICATION
, NULL
},
1371 { 7, szOID_PKIX_KP_CLIENT_AUTH
, 0, (LPCWSTR
)IDS_CLIENT_AUTHENTICATION
, NULL
},
1372 { 7, szOID_PKIX_KP_CODE_SIGNING
, 0, (LPCWSTR
)IDS_CODE_SIGNING
, NULL
},
1373 { 7, szOID_PKIX_KP_EMAIL_PROTECTION
, 0, (LPCWSTR
)IDS_SECURE_EMAIL
, NULL
},
1374 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING
, 0, (LPCWSTR
)IDS_TIME_STAMPING
, NULL
},
1375 { 7, szOID_KP_CTL_USAGE_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TRUST_LIST_SIGNING
, NULL
},
1376 { 7, szOID_KP_TIME_STAMP_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TIME_STAMPING
, NULL
},
1377 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM
, 0, (LPCWSTR
)IDS_IPSEC_END_SYSTEM
, NULL
},
1378 { 7, szOID_PKIX_KP_IPSEC_TUNNEL
, 0, (LPCWSTR
)IDS_IPSEC_TUNNEL
, NULL
},
1379 { 7, szOID_PKIX_KP_IPSEC_USER
, 0, (LPCWSTR
)IDS_IPSEC_USER
, NULL
},
1380 { 7, szOID_KP_EFS
, 0, (LPCWSTR
)IDS_EFS
, NULL
},
1381 { 7, szOID_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_WHQL_CRYPTO
, NULL
},
1382 { 7, szOID_NT5_CRYPTO
, 0, (LPCWSTR
)IDS_NT5_CRYPTO
, NULL
},
1383 { 7, szOID_OEM_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_OEM_WHQL_CRYPTO
, NULL
},
1384 { 7, szOID_EMBEDDED_NT_CRYPTO
, 0, (LPCWSTR
)IDS_EMBEDDED_NT_CRYPTO
, NULL
},
1385 { 7, szOID_LICENSES
, 0, (LPCWSTR
)IDS_KEY_PACK_LICENSES
, NULL
},
1386 { 7, szOID_LICENSE_SERVER
, 0, (LPCWSTR
)IDS_LICENSE_SERVER
, NULL
},
1387 { 7, szOID_KP_SMARTCARD_LOGON
, 0, (LPCWSTR
)IDS_SMART_CARD_LOGON
, NULL
},
1388 { 7, szOID_DRM
, 0, (LPCWSTR
)IDS_DIGITAL_RIGHTS
, NULL
},
1389 { 7, szOID_KP_QUALIFIED_SUBORDINATION
, 0, (LPCWSTR
)IDS_QUALIFIED_SUBORDINATION
, NULL
},
1390 { 7, szOID_KP_KEY_RECOVERY
, 0, (LPCWSTR
)IDS_KEY_RECOVERY
, NULL
},
1391 { 7, szOID_KP_DOCUMENT_SIGNING
, 0, (LPCWSTR
)IDS_DOCUMENT_SIGNING
, NULL
},
1392 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE
, 0, (LPCWSTR
)IDS_IPSEC_IKE_INTERMEDIATE
, NULL
},
1393 { 7, szOID_EFS_RECOVERY
, 0, (LPCWSTR
)IDS_FILE_RECOVERY
, NULL
},
1394 { 7, szOID_ROOT_LIST_SIGNER
, 0, (LPCWSTR
)IDS_ROOT_LIST_SIGNER
, NULL
},
1395 { 7, szOID_ANY_APPLICATION_POLICY
, 0, (LPCWSTR
)IDS_ANY_APPLICATION_POLICIES
, NULL
},
1396 { 7, szOID_DS_EMAIL_REPLICATION
, 0, (LPCWSTR
)IDS_DS_EMAIL_REPLICATION
, NULL
},
1397 { 7, szOID_ENROLLMENT_AGENT
, 0, (LPCWSTR
)IDS_ENROLLMENT_AGENT
, NULL
},
1398 { 7, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1399 { 7, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1400 { 7, szOID_KP_LIFETIME_SIGNING
, 0, (LPCWSTR
)IDS_LIFETIME_SIGNING
, NULL
},
1402 { 8, szOID_ANY_CERT_POLICY
, 0, (LPCWSTR
)IDS_ANY_CERT_POLICY
, NULL
},
1406 CRYPT_OID_INFO info
;
1410 static void init_oid_info(void)
1414 oid_init_localizednames();
1415 for (i
= 0; i
< sizeof(oidInfoConstructors
) /
1416 sizeof(oidInfoConstructors
[0]); i
++)
1418 if (!IS_INTRESOURCE(oidInfoConstructors
[i
].pwszName
))
1420 struct OIDInfo
*info
;
1422 /* The name is a static string, so just use the same pointer */
1423 info
= CryptMemAlloc(sizeof(struct OIDInfo
));
1426 memset(info
, 0, sizeof(*info
));
1427 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1428 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1429 info
->info
.pwszName
= oidInfoConstructors
[i
].pwszName
;
1430 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1431 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1432 if (oidInfoConstructors
[i
].blob
)
1434 info
->info
.ExtraInfo
.cbData
=
1435 oidInfoConstructors
[i
].blob
->cbData
;
1436 info
->info
.ExtraInfo
.pbData
=
1437 oidInfoConstructors
[i
].blob
->pbData
;
1439 info
->info
.pwszCNGAlgid
= oidInfoConstructors
[i
].pwszCNGAlgid
;
1440 info
->info
.pwszCNGExtraAlgid
= oidInfoConstructors
[i
].pwszCNGExtraAlgid
;
1441 list_add_tail(&oidInfo
, &info
->entry
);
1446 LPCWSTR stringresource
;
1447 int len
= LoadStringW(hInstance
,
1448 (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1449 (LPWSTR
)&stringresource
, 0);
1453 struct OIDInfo
*info
= CryptMemAlloc(sizeof(struct OIDInfo
) +
1454 (len
+ 1) * sizeof(WCHAR
));
1458 memset(info
, 0, sizeof(*info
));
1459 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1460 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1461 info
->info
.pwszName
= (LPWSTR
)(info
+ 1);
1462 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1463 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1464 memcpy(info
+ 1, stringresource
, len
*sizeof(WCHAR
));
1465 ((LPWSTR
)(info
+ 1))[len
] = 0;
1466 if (oidInfoConstructors
[i
].blob
)
1468 info
->info
.ExtraInfo
.cbData
=
1469 oidInfoConstructors
[i
].blob
->cbData
;
1470 info
->info
.ExtraInfo
.pbData
=
1471 oidInfoConstructors
[i
].blob
->pbData
;
1473 info
->info
.pwszCNGAlgid
= oidInfoConstructors
[i
].pwszCNGAlgid
;
1474 info
->info
.pwszCNGExtraAlgid
= oidInfoConstructors
[i
].pwszCNGExtraAlgid
;
1475 list_add_tail(&oidInfo
, &info
->entry
);
1482 static void free_oid_info(void)
1484 struct OIDInfo
*info
, *next
;
1486 LIST_FOR_EACH_ENTRY_SAFE(info
, next
, &oidInfo
, struct OIDInfo
, entry
)
1488 list_remove(&info
->entry
);
1491 DeleteCriticalSection(&oidInfoCS
);
1494 /***********************************************************************
1495 * CryptEnumOIDInfo (CRYPT32.@)
1497 BOOL WINAPI
CryptEnumOIDInfo(DWORD dwGroupId
, DWORD dwFlags
, void *pvArg
,
1498 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo
)
1501 struct OIDInfo
*info
;
1503 TRACE("(%d, %08x, %p, %p)\n", dwGroupId
, dwFlags
, pvArg
,
1506 EnterCriticalSection(&oidInfoCS
);
1507 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1509 if (!dwGroupId
|| dwGroupId
== info
->info
.dwGroupId
)
1511 ret
= pfnEnumOIDInfo(&info
->info
, pvArg
);
1516 LeaveCriticalSection(&oidInfoCS
);
1520 PCCRYPT_OID_INFO WINAPI
CryptFindOIDInfo(DWORD dwKeyType
, void *pvKey
,
1523 PCCRYPT_OID_INFO ret
= NULL
;
1525 TRACE("(%d, %p, %d)\n", dwKeyType
, pvKey
, dwGroupId
);
1529 case CRYPT_OID_INFO_ALGID_KEY
:
1531 struct OIDInfo
*info
;
1533 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD
*)pvKey
);
1534 EnterCriticalSection(&oidInfoCS
);
1535 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1537 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1538 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1544 LeaveCriticalSection(&oidInfoCS
);
1547 case CRYPT_OID_INFO_NAME_KEY
:
1549 struct OIDInfo
*info
;
1551 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey
));
1552 EnterCriticalSection(&oidInfoCS
);
1553 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1555 if (!lstrcmpW(info
->info
.pwszName
, pvKey
) &&
1556 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1562 LeaveCriticalSection(&oidInfoCS
);
1565 case CRYPT_OID_INFO_OID_KEY
:
1567 struct OIDInfo
*info
;
1570 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid
));
1571 EnterCriticalSection(&oidInfoCS
);
1572 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1574 if (!lstrcmpA(info
->info
.pszOID
, oid
) &&
1575 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1581 LeaveCriticalSection(&oidInfoCS
);
1584 case CRYPT_OID_INFO_SIGN_KEY
:
1586 struct OIDInfo
*info
;
1588 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD
*)pvKey
);
1589 EnterCriticalSection(&oidInfoCS
);
1590 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1592 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1593 info
->info
.ExtraInfo
.cbData
>= sizeof(DWORD
) &&
1594 *(DWORD
*)info
->info
.ExtraInfo
.pbData
==
1595 *(DWORD
*)((LPBYTE
)pvKey
+ sizeof(DWORD
)) &&
1596 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1602 LeaveCriticalSection(&oidInfoCS
);
1609 LPCSTR WINAPI
CertAlgIdToOID(DWORD dwAlgId
)
1612 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY
,
1622 DWORD WINAPI
CertOIDToAlgId(LPCSTR pszObjId
)
1625 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY
,
1626 (void *)pszObjId
, 0);
1629 ret
= info
->u
.Algid
;
1635 void crypt_oid_init(void)
1640 void crypt_oid_free(void)
1642 free_function_sets();