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
31 #include "wine/debug.h"
32 #include "wine/list.h"
33 #include "crypt32_private.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
38 static const WCHAR DllW
[] = { 'D','l','l',0 };
40 static void init_oid_info(HINSTANCE hinst
);
41 static void free_function_sets(void);
42 static void free_oid_info(void);
44 void crypt_oid_init(HINSTANCE hinst
)
49 void crypt_oid_free(void)
55 static CRITICAL_SECTION funcSetCS
;
56 static CRITICAL_SECTION_DEBUG funcSetCSDebug
=
59 { &funcSetCSDebug
.ProcessLocksList
, &funcSetCSDebug
.ProcessLocksList
},
60 0, 0, { (DWORD_PTR
)(__FILE__
": funcSetCS") }
62 static CRITICAL_SECTION funcSetCS
= { &funcSetCSDebug
, -1, 0, 0, 0, 0 };
63 static struct list funcSets
= { &funcSets
, &funcSets
};
68 CRITICAL_SECTION cs
; /* protects functions */
69 struct list functions
;
76 CRYPT_OID_FUNC_ENTRY entry
;
80 static void free_function_sets(void)
82 struct OIDFunctionSet
*setCursor
, *setNext
;
84 LIST_FOR_EACH_ENTRY_SAFE(setCursor
, setNext
, &funcSets
,
85 struct OIDFunctionSet
, next
)
87 struct OIDFunction
*functionCursor
, *funcNext
;
89 list_remove(&setCursor
->next
);
90 CryptMemFree(setCursor
->name
);
91 LIST_FOR_EACH_ENTRY_SAFE(functionCursor
, funcNext
,
92 &setCursor
->functions
, struct OIDFunction
, next
)
94 list_remove(&functionCursor
->next
);
95 CryptMemFree(functionCursor
);
97 setCursor
->cs
.DebugInfo
->Spare
[0] = 0;
98 DeleteCriticalSection(&setCursor
->cs
);
99 CryptMemFree(setCursor
);
103 /* There is no free function associated with this; therefore, the sets are
104 * freed when crypt32.dll is unloaded.
106 HCRYPTOIDFUNCSET WINAPI
CryptInitOIDFunctionSet(LPCSTR pszFuncName
,
109 struct OIDFunctionSet
*cursor
, *ret
= NULL
;
111 TRACE("(%s, %x)\n", debugstr_a(pszFuncName
), dwFlags
);
113 EnterCriticalSection(&funcSetCS
);
114 LIST_FOR_EACH_ENTRY(cursor
, &funcSets
, struct OIDFunctionSet
, next
)
116 if (!strcasecmp(pszFuncName
, cursor
->name
))
118 ret
= (HCRYPTOIDFUNCSET
)cursor
;
124 ret
= CryptMemAlloc(sizeof(struct OIDFunctionSet
));
127 memset(ret
, 0, sizeof(*ret
));
128 ret
->name
= CryptMemAlloc(strlen(pszFuncName
) + 1);
131 InitializeCriticalSection(&ret
->cs
);
132 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": OIDFunctionSet.cs");
133 list_init(&ret
->functions
);
134 strcpy(ret
->name
, pszFuncName
);
135 list_add_tail(&funcSets
, &ret
->next
);
144 LeaveCriticalSection(&funcSetCS
);
146 return (HCRYPTOIDFUNCSET
)ret
;
149 static char *CRYPT_GetKeyName(DWORD dwEncodingType
, LPCSTR pszFuncName
,
152 static const char szEncodingTypeFmt
[] =
153 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
155 char numericOID
[7]; /* enough for "#65535" */
159 /* MSDN says the encoding type is a mask, but it isn't treated that way.
160 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
161 * "EncodingType 2" would be expected if it were a mask. Instead native
162 * stores values in "EncodingType 3".
166 snprintf(numericOID
, sizeof(numericOID
), "#%d", LOWORD(pszOID
));
172 /* This is enough: the lengths of the two string parameters are explicitly
173 * counted, and we need up to five additional characters for the encoding
174 * type. These are covered by the "%d", "%s", and "%s" characters in the
175 * format specifier that are removed by sprintf.
177 len
= sizeof(szEncodingTypeFmt
) + lstrlenA(pszFuncName
) + lstrlenA(oid
);
178 szKey
= CryptMemAlloc(len
);
180 sprintf(szKey
, szEncodingTypeFmt
,
181 GET_CERT_ENCODING_TYPE(dwEncodingType
), pszFuncName
, oid
);
185 BOOL WINAPI
CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet
,
186 DWORD dwEncodingType
, LPWSTR pwszDllList
, DWORD
*pcchDllList
)
189 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
194 TRACE("(%p, %d, %p, %p)\n", hFuncSet
, dwEncodingType
, pwszDllList
,
197 keyName
= CRYPT_GetKeyName(dwEncodingType
, set
->name
, "DEFAULT");
198 rc
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0,
199 KEY_READ
, NULL
, &key
, NULL
);
202 DWORD size
= *pcchDllList
* sizeof(WCHAR
);
204 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
, (LPBYTE
)pwszDllList
,
207 *pcchDllList
= size
/ sizeof(WCHAR
);
210 /* No value, return an empty list */
211 if (pwszDllList
&& *pcchDllList
)
219 /* No value, return an empty list */
220 if (pwszDllList
&& *pcchDllList
)
224 CryptMemFree(keyName
);
229 BOOL WINAPI
CryptInstallOIDFunctionAddress(HMODULE hModule
,
230 DWORD dwEncodingType
, LPCSTR pszFuncName
, DWORD cFuncEntry
,
231 const CRYPT_OID_FUNC_ENTRY rgFuncEntry
[], DWORD dwFlags
)
234 struct OIDFunctionSet
*set
;
236 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule
, dwEncodingType
,
237 debugstr_a(pszFuncName
), cFuncEntry
, rgFuncEntry
, dwFlags
);
239 set
= (struct OIDFunctionSet
*)CryptInitOIDFunctionSet(pszFuncName
, 0);
244 EnterCriticalSection(&set
->cs
);
245 for (i
= 0; ret
&& i
< cFuncEntry
; i
++)
247 struct OIDFunction
*func
;
249 if (HIWORD(rgFuncEntry
[i
].pszOID
))
250 func
= CryptMemAlloc(sizeof(struct OIDFunction
)
251 + strlen(rgFuncEntry
[i
].pszOID
) + 1);
253 func
= CryptMemAlloc(sizeof(struct OIDFunction
));
256 func
->encoding
= GET_CERT_ENCODING_TYPE(dwEncodingType
);
257 if (HIWORD(rgFuncEntry
[i
].pszOID
))
261 oid
= (LPSTR
)((LPBYTE
)func
+ sizeof(*func
));
262 strcpy(oid
, rgFuncEntry
[i
].pszOID
);
263 func
->entry
.pszOID
= oid
;
266 func
->entry
.pszOID
= rgFuncEntry
[i
].pszOID
;
267 func
->entry
.pvFuncAddr
= rgFuncEntry
[i
].pvFuncAddr
;
268 list_add_tail(&set
->functions
, &func
->next
);
273 LeaveCriticalSection(&set
->cs
);
287 static BOOL
CRYPT_GetFuncFromReg(DWORD dwEncodingType
, LPCSTR pszOID
,
288 LPCSTR szFuncName
, LPVOID
*ppvFuncAddr
, HCRYPTOIDFUNCADDR
*phFuncAddr
)
292 const char *funcName
;
296 keyName
= CRYPT_GetKeyName(dwEncodingType
, szFuncName
, pszOID
);
297 rc
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, KEY_READ
, &key
);
300 DWORD type
, size
= 0;
302 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
, NULL
, &size
);
303 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
305 funcName
= CryptMemAlloc(size
);
306 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
,
307 (LPBYTE
)funcName
, &size
);
310 funcName
= szFuncName
;
311 rc
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
312 if ((!rc
|| rc
== ERROR_MORE_DATA
) && type
== REG_SZ
)
314 LPWSTR dllName
= CryptMemAlloc(size
);
318 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
,
319 (LPBYTE
)dllName
, &size
);
324 /* This is a bit of a hack; MSDN describes a more
325 * complicated unload routine than this will allow.
326 * Still, this seems to suffice for now.
328 lib
= LoadLibraryW(dllName
);
331 *ppvFuncAddr
= GetProcAddress(lib
, funcName
);
334 struct FuncAddr
*addr
=
335 CryptMemAlloc(sizeof(struct FuncAddr
));
340 addr
->dllList
= addr
->currentDll
= NULL
;
352 /* Unload the library, the caller doesn't want
353 * to unload it when the return value is NULL.
361 CryptMemFree(dllName
);
366 if (funcName
!= szFuncName
)
367 CryptMemFree((char *)funcName
);
372 CryptMemFree(keyName
);
376 BOOL WINAPI
CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
377 DWORD dwEncodingType
, LPCSTR pszOID
, DWORD dwFlags
, void **ppvFuncAddr
,
378 HCRYPTOIDFUNCADDR
*phFuncAddr
)
381 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
383 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
384 debugstr_a(pszOID
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
387 if (!(dwFlags
& CRYPT_GET_INSTALLED_OID_FUNC_FLAG
))
389 struct OIDFunction
*function
;
391 EnterCriticalSection(&set
->cs
);
392 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
394 if (function
->encoding
== GET_CERT_ENCODING_TYPE(dwEncodingType
))
398 if (HIWORD(function
->entry
.pszOID
) &&
399 !strcasecmp(function
->entry
.pszOID
, pszOID
))
401 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
402 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
407 else if (function
->entry
.pszOID
== pszOID
)
409 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
410 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
416 LeaveCriticalSection(&set
->cs
);
419 ret
= CRYPT_GetFuncFromReg(dwEncodingType
, pszOID
, set
->name
,
420 ppvFuncAddr
, phFuncAddr
);
421 TRACE("returning %d\n", ret
);
425 BOOL WINAPI
CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr
,
428 TRACE("(%p, %08x)\n", hFuncAddr
, dwFlags
);
430 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
431 * and only unload it if it can be unloaded. Also need to implement ref
432 * counting on the functions.
436 struct FuncAddr
*addr
= (struct FuncAddr
*)hFuncAddr
;
438 CryptMemFree(addr
->dllList
);
439 FreeLibrary(addr
->lib
);
445 static BOOL
CRYPT_GetFuncFromDll(LPCWSTR dll
, LPCSTR func
, HMODULE
*lib
,
450 *lib
= LoadLibraryW(dll
);
453 *ppvFuncAddr
= GetProcAddress(*lib
, func
);
465 BOOL WINAPI
CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
466 DWORD dwEncodingType
, LPCWSTR pwszDll
, DWORD dwFlags
, void **ppvFuncAddr
,
467 HCRYPTOIDFUNCADDR
*phFuncAddr
)
469 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
472 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
473 debugstr_w(pwszDll
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
480 ret
= CRYPT_GetFuncFromDll(pwszDll
, set
->name
, &lib
, ppvFuncAddr
);
483 struct FuncAddr
*addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
488 addr
->dllList
= addr
->currentDll
= NULL
;
495 SetLastError(ERROR_OUTOFMEMORY
);
500 SetLastError(ERROR_FILE_NOT_FOUND
);
504 struct FuncAddr
*addr
= (struct FuncAddr
*)*phFuncAddr
;
510 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
, NULL
,
514 LPWSTR dllList
= CryptMemAlloc(size
* sizeof(WCHAR
));
518 ret
= CryptGetDefaultOIDDllList(hFuncSet
, dwEncodingType
,
522 addr
= CryptMemAlloc(sizeof(struct FuncAddr
));
525 addr
->dllList
= dllList
;
526 addr
->currentDll
= dllList
;
532 CryptMemFree(dllList
);
533 SetLastError(ERROR_OUTOFMEMORY
);
540 SetLastError(ERROR_OUTOFMEMORY
);
547 if (!*addr
->currentDll
)
549 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
550 SetLastError(ERROR_FILE_NOT_FOUND
);
556 /* FIXME: as elsewhere, can't free until DllCanUnloadNow says
557 * it's possible, and should defer unloading for some time to
558 * avoid repeated LoadLibrary/FreeLibrary on the same dll.
560 FreeLibrary(addr
->lib
);
561 ret
= CRYPT_GetFuncFromDll(addr
->currentDll
, set
->name
,
562 &addr
->lib
, ppvFuncAddr
);
565 /* Move past the current DLL */
566 addr
->currentDll
+= lstrlenW(addr
->currentDll
) + 1;
571 CryptFreeOIDFunctionAddress(*phFuncAddr
, 0);
572 SetLastError(ERROR_FILE_NOT_FOUND
);
581 /***********************************************************************
582 * CryptRegisterOIDFunction (CRYPT32.@)
584 * Register the DLL and the functions it uses to cover the combination
585 * of encoding type, functionname and OID.
588 * dwEncodingType [I] Encoding type to be used.
589 * pszFuncName [I] Name of the function to be registered.
590 * pszOID [I] OID of the function (numeric or string).
591 * pwszDll [I] The DLL that is to be registered.
592 * pszOverrideFuncName [I] Name of the function in the DLL.
596 * Failure: FALSE. (Look at GetLastError()).
599 * Registry errors are always reported via SetLastError().
601 BOOL WINAPI
CryptRegisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
602 LPCSTR pszOID
, LPCWSTR pwszDll
, LPCSTR pszOverrideFuncName
)
608 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType
, pszFuncName
,
609 debugstr_a(pszOID
), debugstr_w(pwszDll
), pszOverrideFuncName
);
611 /* Native does nothing pwszDll is NULL */
615 /* I'm not matching MS bug for bug here, because I doubt any app depends on
616 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
617 * it creates would never be used.
619 if (!pszFuncName
|| !pszOID
)
621 SetLastError(E_INVALIDARG
);
625 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
626 TRACE("Key name is %s\n", debugstr_a(szKey
));
631 r
= RegCreateKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
634 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
636 /* write the values */
637 if (pszOverrideFuncName
)
639 r
= RegSetValueExA(hKey
, "FuncName", 0, REG_SZ
,
640 (const BYTE
*)pszOverrideFuncName
, lstrlenA(pszOverrideFuncName
) + 1);
641 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
643 r
= RegSetValueExW(hKey
, DllW
, 0, REG_SZ
, (const BYTE
*) pwszDll
,
644 (lstrlenW(pwszDll
) + 1) * sizeof (WCHAR
));
650 if (r
!= ERROR_SUCCESS
)
659 /***********************************************************************
660 * CryptUnregisterOIDFunction (CRYPT32.@)
662 BOOL WINAPI
CryptUnregisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
668 TRACE("%x %s %s\n", dwEncodingType
, debugstr_a(pszFuncName
),
671 if (!pszFuncName
|| !pszOID
)
673 SetLastError(ERROR_INVALID_PARAMETER
);
677 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
678 rc
= RegDeleteKeyA(HKEY_LOCAL_MACHINE
, szKey
);
682 return rc
? FALSE
: TRUE
;
685 BOOL WINAPI
CryptGetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
686 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD
*pdwValueType
, BYTE
*pbValueData
,
693 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType
, debugstr_a(pszFuncName
),
694 debugstr_a(pszOID
), debugstr_w(pwszValueName
), pdwValueType
, pbValueData
,
697 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
700 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
702 SetLastError(ERROR_INVALID_PARAMETER
);
706 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
707 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
713 rc
= RegQueryValueExW(hKey
, pwszValueName
, NULL
, pdwValueType
,
714 pbValueData
, pcbValueData
);
719 return rc
? FALSE
: TRUE
;
722 BOOL WINAPI
CryptSetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
723 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD dwValueType
,
724 const BYTE
*pbValueData
, DWORD cbValueData
)
730 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType
, debugstr_a(pszFuncName
),
731 debugstr_a(pszOID
), debugstr_w(pwszValueName
), dwValueType
, pbValueData
,
734 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
737 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
739 SetLastError(ERROR_INVALID_PARAMETER
);
743 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
744 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
750 rc
= RegSetValueExW(hKey
, pwszValueName
, 0, dwValueType
, pbValueData
,
756 return rc
? FALSE
: TRUE
;
759 static LPCWSTR
CRYPT_FindStringInMultiString(LPCWSTR multi
, LPCWSTR toFind
)
761 LPCWSTR ret
= NULL
, ptr
;
763 for (ptr
= multi
; ptr
&& *ptr
&& !ret
; ptr
+= lstrlenW(ptr
) + 1)
765 if (!lstrcmpiW(ptr
, toFind
))
771 static DWORD
CRYPT_GetMultiStringCharacterLen(LPCWSTR multi
)
779 /* Count terminating empty string */
781 for (ptr
= multi
; *ptr
; ptr
+= lstrlenW(ptr
) + 1)
782 ret
+= lstrlenW(ptr
) + 1;
789 static LPWSTR
CRYPT_AddStringToMultiString(LPWSTR multi
, LPCWSTR toAdd
,
796 /* FIXME: ignoring index, is that okay? */
797 ret
= CryptMemAlloc((lstrlenW(toAdd
) + 2) * sizeof(WCHAR
));
800 /* copy string, including NULL terminator */
801 memcpy(ret
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
802 /* add terminating empty string */
803 *(ret
+ lstrlenW(toAdd
) + 1) = 0;
808 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
810 ret
= CryptMemRealloc(multi
, (len
+ lstrlenW(toAdd
) + 1) *
816 if (index
== CRYPT_REGISTER_LAST_INDEX
)
817 spotToAdd
= ret
+ len
- 1;
822 /* FIXME: if index is too large for the string, toAdd is
823 * added to the end. Is that okay?
825 for (i
= 0, spotToAdd
= ret
; i
< index
&& *spotToAdd
;
826 spotToAdd
+= lstrlenW(spotToAdd
) + 1)
831 /* Copy existing string "right" */
832 memmove(spotToAdd
+ lstrlenW(toAdd
) + 1, spotToAdd
,
833 (len
- (spotToAdd
- ret
)) * sizeof(WCHAR
));
834 /* Copy new string */
835 memcpy(spotToAdd
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
847 static BOOL
CRYPT_RemoveStringFromMultiString(LPWSTR multi
, LPCWSTR toRemove
)
849 LPWSTR spotToRemove
= (LPWSTR
)CRYPT_FindStringInMultiString(multi
,
855 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
857 /* Copy remainder of string "left" */
858 memmove(spotToRemove
, spotToRemove
+ lstrlenW(toRemove
) + 1,
859 (len
- (spotToRemove
- multi
)) * sizeof(WCHAR
));
864 SetLastError(ERROR_FILE_NOT_FOUND
);
870 static BOOL
CRYPT_GetDefaultOIDKey(DWORD dwEncodingType
, LPCSTR pszFuncName
,
876 keyName
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, "DEFAULT");
877 TRACE("Key name is %s\n", debugstr_a(keyName
));
882 r
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0, KEY_ALL_ACCESS
,
884 CryptMemFree(keyName
);
885 if (r
!= ERROR_SUCCESS
)
893 static LPWSTR
CRYPT_GetDefaultOIDDlls(HKEY key
)
899 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
900 if (r
== ERROR_SUCCESS
&& type
== REG_MULTI_SZ
)
902 dlls
= CryptMemAlloc(size
);
903 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, (LPBYTE
)dlls
, &size
);
904 if (r
!= ERROR_SUCCESS
)
915 static inline BOOL
CRYPT_SetDefaultOIDDlls(HKEY key
, LPCWSTR dlls
)
917 DWORD len
= CRYPT_GetMultiStringCharacterLen(dlls
);
920 if ((r
= RegSetValueExW(key
, DllW
, 0, REG_MULTI_SZ
, (const BYTE
*)dlls
,
921 len
* sizeof (WCHAR
))))
923 return r
== ERROR_SUCCESS
;
926 /***********************************************************************
927 * CryptRegisterDefaultOIDFunction (CRYPT32.@)
929 BOOL WINAPI
CryptRegisterDefaultOIDFunction(DWORD dwEncodingType
,
930 LPCSTR pszFuncName
, DWORD dwIndex
, LPCWSTR pwszDll
)
937 TRACE("(%x, %s, %d, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
938 dwIndex
, debugstr_w(pwszDll
));
942 SetLastError(E_INVALIDARG
);
946 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
949 dlls
= CRYPT_GetDefaultOIDDlls(key
);
950 if ((existing
= CRYPT_FindStringInMultiString(dlls
, pwszDll
)))
951 SetLastError(ERROR_FILE_EXISTS
);
954 dlls
= CRYPT_AddStringToMultiString(dlls
, pwszDll
, dwIndex
);
956 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
963 BOOL WINAPI
CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType
,
964 LPCSTR pszFuncName
, LPCWSTR pwszDll
)
970 TRACE("(%x, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
971 debugstr_w(pwszDll
));
975 SetLastError(E_INVALIDARG
);
979 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
982 dlls
= CRYPT_GetDefaultOIDDlls(key
);
983 if ((ret
= CRYPT_RemoveStringFromMultiString(dlls
, pwszDll
)))
984 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
990 /********************************************************************
991 * CryptFindLocalizedName (CRYPT32.@)
993 LPCWSTR WINAPI
CryptFindLocalizedName(LPCWSTR pwszCryptName
)
995 FIXME(" %s - stub\n",debugstr_w(pwszCryptName
));
999 static CRITICAL_SECTION oidInfoCS
;
1000 static CRITICAL_SECTION_DEBUG oidInfoCSDebug
=
1003 { &oidInfoCSDebug
.ProcessLocksList
, &oidInfoCSDebug
.ProcessLocksList
},
1004 0, 0, { (DWORD_PTR
)(__FILE__
": oidInfoCS") }
1006 static CRITICAL_SECTION oidInfoCS
= { &oidInfoCSDebug
, -1, 0, 0, 0, 0 };
1007 static struct list oidInfo
= { &oidInfo
, &oidInfo
};
1009 static const WCHAR tripledes
[] = { '3','d','e','s',0 };
1010 static const WCHAR cms3deswrap
[] = { 'C','M','S','3','D','E','S','w','r','a',
1012 static const WCHAR cmsrc2wrap
[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
1013 static const WCHAR des
[] = { 'd','e','s',0 };
1014 static const WCHAR md2
[] = { 'm','d','2',0 };
1015 static const WCHAR md4
[] = { 'm','d','4',0 };
1016 static const WCHAR md5
[] = { 'm','d','5',0 };
1017 static const WCHAR rc2
[] = { 'r','c','2',0 };
1018 static const WCHAR rc4
[] = { 'r','c','4',0 };
1019 static const WCHAR sha
[] = { 's','h','a',0 };
1020 static const WCHAR sha1
[] = { 's','h','a','1',0 };
1021 static const WCHAR RSA
[] = { 'R','S','A',0 };
1022 static const WCHAR RSA_KEYX
[] = { 'R','S','A','_','K','E','Y','X',0 };
1023 static const WCHAR RSA_SIGN
[] = { 'R','S','A','_','S','I','G','N',0 };
1024 static const WCHAR DSA
[] = { 'D','S','A',0 };
1025 static const WCHAR DSA_SIGN
[] = { 'D','S','A','_','S','I','G','N',0 };
1026 static const WCHAR DH
[] = { 'D','H',0 };
1027 static const WCHAR DSS
[] = { 'D','S','S',0 };
1028 static const WCHAR mosaicKMandUpdSig
[] =
1029 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
1030 static const WCHAR ESDH
[] = { 'E','S','D','H',0 };
1031 static const WCHAR NO_SIGN
[] = { 'N','O','S','I','G','N',0 };
1032 static const WCHAR dsaSHA1
[] = { 'd','s','a','S','H','A','1',0 };
1033 static const WCHAR md2RSA
[] = { 'm','d','2','R','S','A',0 };
1034 static const WCHAR md4RSA
[] = { 'm','d','4','R','S','A',0 };
1035 static const WCHAR md5RSA
[] = { 'm','d','5','R','S','A',0 };
1036 static const WCHAR shaDSA
[] = { 's','h','a','D','S','A',0 };
1037 static const WCHAR sha1DSA
[] = { 's','h','a','1','D','S','A',0 };
1038 static const WCHAR shaRSA
[] = { 's','h','a','R','S','A',0 };
1039 static const WCHAR sha1RSA
[] = { 's','h','a','1','R','S','A',0 };
1040 static const WCHAR mosaicUpdatedSig
[] =
1041 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
1042 static const WCHAR CN
[] = { 'C','N',0 };
1043 static const WCHAR L
[] = { 'L',0 };
1044 static const WCHAR O
[] = { 'O',0 };
1045 static const WCHAR OU
[] = { 'O','U',0 };
1046 static const WCHAR E
[] = { 'E',0 };
1047 static const WCHAR C
[] = { 'C',0 };
1048 static const WCHAR S
[] = { 'S',0 };
1049 static const WCHAR ST
[] = { 'S','T',0 };
1050 static const WCHAR STREET
[] = { 'S','T','R','E','E','T',0 };
1051 static const WCHAR T
[] = { 'T',0 };
1052 static const WCHAR Title
[] = { 'T','i','t','l','e',0 };
1053 static const WCHAR G
[] = { 'G',0 };
1054 static const WCHAR GivenName
[] = { 'G','i','v','e','n','N','a','m','e',0 };
1055 static const WCHAR I
[] = { 'I',0 };
1056 static const WCHAR Initials
[] = { 'I','n','i','t','i','a','l','s',0 };
1057 static const WCHAR SN
[] = { 'S','N',0 };
1058 static const WCHAR DC
[] = { 'D','C',0 };
1059 static const WCHAR Description
[] =
1060 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
1061 static const WCHAR PostalCode
[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
1062 static const WCHAR POBox
[] = { 'P','O','B','o','x',0 };
1063 static const WCHAR Phone
[] = { 'P','h','o','n','e',0 };
1064 static const WCHAR X21Address
[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
1065 static const WCHAR dnQualifier
[] =
1066 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
1067 static const WCHAR Email
[] = { 'E','m','a','i','l',0 };
1068 static const WCHAR GN
[] = { 'G','N',0 };
1070 static const DWORD noNullFlag
= CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1071 static const DWORD mosaicFlags
= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1072 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
1073 static const CRYPT_DATA_BLOB noNullBlob
= { sizeof(noNullFlag
),
1074 (LPBYTE
)&noNullFlag
};
1075 static const CRYPT_DATA_BLOB mosaicFlagsBlob
= { sizeof(mosaicFlags
),
1076 (LPBYTE
)&mosaicFlags
};
1078 static const DWORD rsaSign
= CALG_RSA_SIGN
;
1079 static const DWORD dssSign
[2] = { CALG_DSS_SIGN
,
1080 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1081 static const DWORD mosaicSign
[2] = { CALG_DSS_SIGN
,
1082 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
1083 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
1084 static const CRYPT_DATA_BLOB rsaSignBlob
= { sizeof(rsaSign
),
1086 static const CRYPT_DATA_BLOB dssSignBlob
= { sizeof(dssSign
),
1088 static const CRYPT_DATA_BLOB mosaicSignBlob
= { sizeof(mosaicSign
),
1089 (LPBYTE
)mosaicSign
};
1091 static const DWORD ia5String
[] = { CERT_RDN_IA5_STRING
, 0 };
1092 static const DWORD numericString
[] = { CERT_RDN_NUMERIC_STRING
, 0 };
1093 static const DWORD printableString
[] = { CERT_RDN_PRINTABLE_STRING
, 0 };
1094 static const DWORD domainCompTypes
[] = { CERT_RDN_IA5_STRING
,
1095 CERT_RDN_UTF8_STRING
, 0 };
1096 static const CRYPT_DATA_BLOB ia5StringBlob
= { sizeof(ia5String
),
1097 (LPBYTE
)ia5String
};
1098 static const CRYPT_DATA_BLOB numericStringBlob
= { sizeof(numericString
),
1099 (LPBYTE
)numericString
};
1100 static const CRYPT_DATA_BLOB printableStringBlob
= { sizeof(printableString
),
1101 (LPBYTE
)printableString
};
1102 static const CRYPT_DATA_BLOB domainCompTypesBlob
= { sizeof(domainCompTypes
),
1103 (LPBYTE
)domainCompTypes
};
1105 static const struct OIDInfoConstructor
{
1110 const CRYPT_DATA_BLOB
*blob
;
1111 } oidInfoConstructors
[] = {
1112 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha1
, NULL
},
1113 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha
, NULL
},
1114 { 1, szOID_OIWSEC_sha
, CALG_SHA
, sha
, NULL
},
1115 { 1, szOID_RSA_MD5
, CALG_MD5
, md5
, NULL
},
1116 { 1, szOID_RSA_MD4
, CALG_MD4
, md4
, NULL
},
1117 { 1, szOID_RSA_MD2
, CALG_MD2
, md2
, NULL
},
1119 { 2, szOID_OIWSEC_desCBC
, CALG_DES
, des
, NULL
},
1120 { 2, szOID_RSA_DES_EDE3_CBC
, CALG_3DES
, tripledes
, NULL
},
1121 { 2, szOID_RSA_RC2CBC
, CALG_RC2
, rc2
, NULL
},
1122 { 2, szOID_RSA_RC4
, CALG_RC4
, rc4
, NULL
},
1123 { 2, szOID_RSA_SMIMEalgCMS3DESwrap
, CALG_3DES
, cms3deswrap
, NULL
},
1124 { 2, szOID_RSA_SMIMEalgCMSRC2wrap
, CALG_RC2
, cmsrc2wrap
, NULL
},
1126 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA
, NULL
},
1127 { 3, szOID_X957_DSA
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1128 { 3, szOID_ANSI_X942_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1129 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1130 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA
, NULL
},
1131 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA_SIGN
, NULL
},
1132 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
1133 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSS
, &noNullBlob
},
1134 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA_SIGN
, &noNullBlob
},
1135 { 3, szOID_RSA_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
1136 { 3, szOID_OIWSEC_rsaXchg
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
1137 { 3, szOID_INFOSEC_mosaicKMandUpdSig
, CALG_DSS_SIGN
, mosaicKMandUpdSig
,
1139 { 3, szOID_RSA_SMIMEalgESDH
, CALG_DH_EPHEM
, ESDH
, &noNullBlob
},
1140 { 3, szOID_PKIX_NO_SIGNATURE
, CALG_NO_SIGN
, NO_SIGN
, NULL
},
1142 { 4, szOID_RSA_SHA1RSA
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1143 { 4, szOID_RSA_MD5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1144 { 4, szOID_X957_SHA1DSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1145 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
1146 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1147 { 4, szOID_OIWSEC_shaRSA
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
1148 { 4, szOID_OIWSEC_md5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
1149 { 4, szOID_RSA_MD2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1150 { 4, szOID_RSA_MD4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1151 { 4, szOID_OIWSEC_md4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1152 { 4, szOID_OIWSEC_md4RSA2
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
1153 { 4, szOID_OIWDIR_md2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
1154 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
1155 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, shaDSA
, &dssSignBlob
},
1156 { 4, szOID_OIWSEC_dsaSHA1
, CALG_SHA1
, dsaSHA1
, &dssSignBlob
},
1157 { 4, szOID_INFOSEC_mosaicUpdatedSig
, CALG_SHA1
, mosaicUpdatedSig
,
1160 { 5, szOID_COMMON_NAME
, 0, CN
, NULL
},
1161 { 5, szOID_LOCALITY_NAME
, 0, L
, NULL
},
1162 { 5, szOID_ORGANIZATION_NAME
, 0, O
, NULL
},
1163 { 5, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, OU
, NULL
},
1164 { 5, szOID_RSA_emailAddr
, 0, E
, &ia5StringBlob
},
1165 { 5, szOID_RSA_emailAddr
, 0, Email
, &ia5StringBlob
},
1166 { 5, szOID_COUNTRY_NAME
, 0, C
, &printableStringBlob
},
1167 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, S
, NULL
},
1168 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, ST
, NULL
},
1169 { 5, szOID_STREET_ADDRESS
, 0, STREET
, NULL
},
1170 { 5, szOID_TITLE
, 0, T
, NULL
},
1171 { 5, szOID_TITLE
, 0, Title
, NULL
},
1172 { 5, szOID_GIVEN_NAME
, 0, G
, NULL
},
1173 { 5, szOID_GIVEN_NAME
, 0, GN
, NULL
},
1174 { 5, szOID_GIVEN_NAME
, 0, GivenName
, NULL
},
1175 { 5, szOID_INITIALS
, 0, I
, NULL
},
1176 { 5, szOID_INITIALS
, 0, Initials
, NULL
},
1177 { 5, szOID_SUR_NAME
, 0, SN
, NULL
},
1178 { 5, szOID_DOMAIN_COMPONENT
, 0, DC
, &domainCompTypesBlob
},
1179 { 5, szOID_DESCRIPTION
, 0, Description
, NULL
},
1180 { 5, szOID_POSTAL_CODE
, 0, PostalCode
, NULL
},
1181 { 5, szOID_POST_OFFICE_BOX
, 0, POBox
, NULL
},
1182 { 5, szOID_TELEPHONE_NUMBER
, 0, Phone
, &printableStringBlob
},
1183 { 5, szOID_X21_ADDRESS
, 0, X21Address
, &numericStringBlob
},
1184 { 5, szOID_DN_QUALIFIER
, 0, dnQualifier
, NULL
},
1186 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1187 { 6, szOID_AUTHORITY_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1188 { 6, szOID_KEY_ATTRIBUTES
, 0, (LPCWSTR
)IDS_KEY_ATTRIBUTES
, NULL
},
1189 { 6, szOID_KEY_USAGE_RESTRICTION
, 0, (LPCWSTR
)IDS_KEY_USAGE_RESTRICTION
, NULL
},
1190 { 6, szOID_SUBJECT_ALT_NAME2
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1191 { 6, szOID_SUBJECT_ALT_NAME
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1192 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1193 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1194 { 6, szOID_BASIC_CONSTRAINTS2
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1195 { 6, szOID_BASIC_CONSTRAINTS
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1196 { 6, szOID_KEY_USAGE
, 0, (LPCWSTR
)IDS_KEY_USAGE
, NULL
},
1197 { 6, szOID_CERT_POLICIES
, 0, (LPCWSTR
)IDS_CERT_POLICIES
, NULL
},
1198 { 6, szOID_SUBJECT_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_SUBJECT_KEY_IDENTIFIER
, NULL
},
1199 { 6, szOID_CRL_REASON_CODE
, 0, (LPCWSTR
)IDS_CRL_REASON_CODE
, NULL
},
1200 { 6, szOID_CRL_DIST_POINTS
, 0, (LPCWSTR
)IDS_CRL_DIST_POINTS
, NULL
},
1201 { 6, szOID_ENHANCED_KEY_USAGE
, 0, (LPCWSTR
)IDS_ENHANCED_KEY_USAGE
, NULL
},
1202 { 6, szOID_AUTHORITY_INFO_ACCESS
, 0, (LPCWSTR
)IDS_AUTHORITY_INFO_ACCESS
, NULL
},
1203 { 6, szOID_CERT_EXTENSIONS
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1204 { 6, szOID_RSA_certExtensions
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1205 { 6, szOID_NEXT_UPDATE_LOCATION
, 0, (LPCWSTR
)IDS_NEXT_UPDATE_LOCATION
, NULL
},
1206 { 6, szOID_YESNO_TRUST_ATTR
, 0, (LPCWSTR
)IDS_YES_OR_NO_TRUST
, NULL
},
1207 { 6, szOID_RSA_emailAddr
, 0, (LPCWSTR
)IDS_EMAIL_ADDRESS
, NULL
},
1208 { 6, szOID_RSA_unstructName
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_NAME
, NULL
},
1209 { 6, szOID_RSA_contentType
, 0, (LPCWSTR
)IDS_CONTENT_TYPE
, NULL
},
1210 { 6, szOID_RSA_messageDigest
, 0, (LPCWSTR
)IDS_MESSAGE_DIGEST
, NULL
},
1211 { 6, szOID_RSA_signingTime
, 0, (LPCWSTR
)IDS_SIGNING_TIME
, NULL
},
1212 { 6, szOID_RSA_counterSign
, 0, (LPCWSTR
)IDS_COUNTER_SIGN
, NULL
},
1213 { 6, szOID_RSA_challengePwd
, 0, (LPCWSTR
)IDS_CHALLENGE_PASSWORD
, NULL
},
1214 { 6, szOID_RSA_unstructAddr
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_ADDRESS
, NULL
},
1215 { 6, szOID_RSA_SMIMECapabilities
, 0, (LPCWSTR
)IDS_SMIME_CAPABILITIES
, NULL
},
1216 { 6, szOID_RSA_preferSignedData
, 0, (LPCWSTR
)IDS_PREFER_SIGNED_DATA
, NULL
},
1217 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS
, 0, (LPCWSTR
)IDS_CPS
, NULL
},
1218 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
, 0, (LPCWSTR
)IDS_USER_NOTICE
, NULL
},
1219 { 6, szOID_PKIX_OCSP
, 0, (LPCWSTR
)IDS_OCSP
, NULL
},
1220 { 6, szOID_PKIX_CA_ISSUERS
, 0, (LPCWSTR
)IDS_CA_ISSUER
, NULL
},
1221 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TEMPLATE_NAME
, NULL
},
1222 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TYPE
, NULL
},
1223 { 6, szOID_CERT_MANIFOLD
, 0, (LPCWSTR
)IDS_CERT_MANIFOLD
, NULL
},
1224 { 6, szOID_NETSCAPE_CERT_TYPE
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_TYPE
, NULL
},
1225 { 6, szOID_NETSCAPE_BASE_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_BASE_URL
, NULL
},
1226 { 6, szOID_NETSCAPE_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_REVOCATION_URL
, NULL
},
1227 { 6, szOID_NETSCAPE_CA_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_REVOCATION_URL
, NULL
},
1228 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_RENEWAL_URL
, NULL
},
1229 { 6, szOID_NETSCAPE_CA_POLICY_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_POLICY_URL
, NULL
},
1230 { 6, szOID_NETSCAPE_SSL_SERVER_NAME
, 0, (LPCWSTR
)IDS_NETSCAPE_SSL_SERVER_NAME
, NULL
},
1231 { 6, szOID_NETSCAPE_COMMENT
, 0, (LPCWSTR
)IDS_NETSCAPE_COMMENT
, NULL
},
1232 { 6, "1.3.6.1.4.1.311.2.1.10", 0, (LPCWSTR
)IDS_SPC_SP_AGENCY_INFO
, NULL
},
1233 { 6, "1.3.6.1.4.1.311.2.1.27", 0, (LPCWSTR
)IDS_SPC_FINANCIAL_CRITERIA
, NULL
},
1234 { 6, "1.3.6.1.4.1.311.2.1.26", 0, (LPCWSTR
)IDS_SPC_MINIMAL_CRITERIA
, NULL
},
1235 { 6, szOID_COUNTRY_NAME
, 0, (LPCWSTR
)IDS_COUNTRY
, NULL
},
1236 { 6, szOID_ORGANIZATION_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATION
, NULL
},
1237 { 6, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATIONAL_UNIT
, NULL
},
1238 { 6, szOID_COMMON_NAME
, 0, (LPCWSTR
)IDS_COMMON_NAME
, NULL
},
1239 { 6, szOID_LOCALITY_NAME
, 0, (LPCWSTR
)IDS_LOCALITY
, NULL
},
1240 { 6, szOID_STATE_OR_PROVINCE_NAME
, 0, (LPCWSTR
)IDS_STATE_OR_PROVINCE
, NULL
},
1241 { 6, szOID_TITLE
, 0, (LPCWSTR
)IDS_TITLE
, NULL
},
1242 { 6, szOID_GIVEN_NAME
, 0, (LPCWSTR
)IDS_GIVEN_NAME
, NULL
},
1243 { 6, szOID_INITIALS
, 0, (LPCWSTR
)IDS_INITIALS
, NULL
},
1244 { 6, szOID_SUR_NAME
, 0, (LPCWSTR
)IDS_SUR_NAME
, NULL
},
1245 { 6, szOID_DOMAIN_COMPONENT
, 0, (LPCWSTR
)IDS_DOMAIN_COMPONENT
, NULL
},
1246 { 6, szOID_STREET_ADDRESS
, 0, (LPCWSTR
)IDS_STREET_ADDRESS
, NULL
},
1247 { 6, szOID_DEVICE_SERIAL_NUMBER
, 0, (LPCWSTR
)IDS_SERIAL_NUMBER
, NULL
},
1248 { 6, szOID_CERTSRV_CA_VERSION
, 0, (LPCWSTR
)IDS_CA_VERSION
, NULL
},
1249 { 6, szOID_CERTSRV_CROSSCA_VERSION
, 0, (LPCWSTR
)IDS_CROSS_CA_VERSION
, NULL
},
1250 { 6, szOID_SERIALIZED
, 0, (LPCWSTR
)IDS_SERIALIZED_SIG_SERIAL_NUMBER
, NULL
},
1251 { 6, szOID_NT_PRINCIPAL_NAME
, 0, (LPCWSTR
)IDS_PRINCIPAL_NAME
, NULL
},
1252 { 6, szOID_PRODUCT_UPDATE
, 0, (LPCWSTR
)IDS_WINDOWS_PRODUCT_UPDATE
, NULL
},
1253 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR
, 0, (LPCWSTR
)IDS_ENROLLMENT_NAME_VALUE_PAIR
, NULL
},
1254 { 6, szOID_OS_VERSION
, 0, (LPCWSTR
)IDS_OS_VERSION
, NULL
},
1255 { 6, szOID_ENROLLMENT_CSP_PROVIDER
, 0, (LPCWSTR
)IDS_ENROLLMENT_CSP
, NULL
},
1256 { 6, szOID_CRL_NUMBER
, 0, (LPCWSTR
)IDS_CRL_NUMBER
, NULL
},
1257 { 6, szOID_DELTA_CRL_INDICATOR
, 0, (LPCWSTR
)IDS_DELTA_CRL_INDICATOR
, NULL
},
1258 { 6, szOID_ISSUING_DIST_POINT
, 0, (LPCWSTR
)IDS_ISSUING_DIST_POINT
, NULL
},
1259 { 6, szOID_FRESHEST_CRL
, 0, (LPCWSTR
)IDS_FRESHEST_CRL
, NULL
},
1260 { 6, szOID_NAME_CONSTRAINTS
, 0, (LPCWSTR
)IDS_NAME_CONSTRAINTS
, NULL
},
1261 { 6, szOID_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1262 { 6, szOID_LEGACY_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1263 { 6, szOID_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_POLICY_CONSTRAINTS
, NULL
},
1264 { 6, szOID_CROSS_CERT_DIST_POINTS
, 0, (LPCWSTR
)IDS_CROSS_CERT_DIST_POINTS
, NULL
},
1265 { 6, szOID_APPLICATION_CERT_POLICIES
, 0, (LPCWSTR
)IDS_APPLICATION_POLICIES
, NULL
},
1266 { 6, szOID_APPLICATION_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_MAPPINGS
, NULL
},
1267 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_CONSTRAINTS
, NULL
},
1268 { 6, szOID_CT_PKI_DATA
, 0, (LPCWSTR
)IDS_CMC_DATA
, NULL
},
1269 { 6, szOID_CT_PKI_RESPONSE
, 0, (LPCWSTR
)IDS_CMC_RESPONSE
, NULL
},
1270 { 6, szOID_CMC
, 0, (LPCWSTR
)IDS_UNSIGNED_CMC_REQUEST
, NULL
},
1271 { 6, szOID_CMC_STATUS_INFO
, 0, (LPCWSTR
)IDS_CMC_STATUS_INFO
, NULL
},
1272 { 6, szOID_CMC_ADD_EXTENSIONS
, 0, (LPCWSTR
)IDS_CMC_EXTENSIONS
, NULL
},
1273 { 6, szOID_CTL
, 0, (LPCWSTR
)IDS_CMC_ATTRIBUTES
, NULL
},
1274 { 6, szOID_RSA_data
, 0, (LPCWSTR
)IDS_PKCS_7_DATA
, NULL
},
1275 { 6, szOID_RSA_signedData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED
, NULL
},
1276 { 6, szOID_RSA_envelopedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENVELOPED
, NULL
},
1277 { 6, szOID_RSA_signEnvData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED_ENVELOPED
, NULL
},
1278 { 6, szOID_RSA_digestedData
, 0, (LPCWSTR
)IDS_PKCS_7_DIGESTED
, NULL
},
1279 { 6, szOID_RSA_encryptedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENCRYPTED
, NULL
},
1280 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH
, 0, (LPCWSTR
)IDS_PREVIOUS_CA_CERT_HASH
, NULL
},
1281 { 6, szOID_CRL_VIRTUAL_BASE
, 0, (LPCWSTR
)IDS_CRL_VIRTUAL_BASE
, NULL
},
1282 { 6, szOID_CRL_NEXT_PUBLISH
, 0, (LPCWSTR
)IDS_CRL_NEXT_PUBLISH
, NULL
},
1283 { 6, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1284 { 6, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1285 { 6, szOID_CERTIFICATE_TEMPLATE
, 0, (LPCWSTR
)IDS_CERTIFICATE_TEMPLATE
, NULL
},
1286 { 6, szOID_ENTERPRISE_OID_ROOT
, 0, (LPCWSTR
)IDS_ENTERPRISE_ROOT_OID
, NULL
},
1287 { 6, szOID_RDN_DUMMY_SIGNER
, 0, (LPCWSTR
)IDS_RDN_DUMMY_SIGNER
, NULL
},
1288 { 6, szOID_ARCHIVED_KEY_ATTR
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_ATTR
, NULL
},
1289 { 6, szOID_CRL_SELF_CDP
, 0, (LPCWSTR
)IDS_CRL_SELF_CDP
, NULL
},
1290 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY
, 0, (LPCWSTR
)IDS_REQUIRE_CERT_CHAIN_POLICY
, NULL
},
1291 { 6, szOID_CMC_TRANSACTION_ID
, 0, (LPCWSTR
)IDS_TRANSACTION_ID
, NULL
},
1292 { 6, szOID_CMC_SENDER_NONCE
, 0, (LPCWSTR
)IDS_SENDER_NONCE
, NULL
},
1293 { 6, szOID_CMC_RECIPIENT_NONCE
, 0, (LPCWSTR
)IDS_RECIPIENT_NONCE
, NULL
},
1294 { 6, szOID_CMC_REG_INFO
, 0, (LPCWSTR
)IDS_REG_INFO
, NULL
},
1295 { 6, szOID_CMC_GET_CERT
, 0, (LPCWSTR
)IDS_GET_CERTIFICATE
, NULL
},
1296 { 6, szOID_CMC_GET_CRL
, 0, (LPCWSTR
)IDS_GET_CRL
, NULL
},
1297 { 6, szOID_CMC_REVOKE_REQUEST
, 0, (LPCWSTR
)IDS_REVOKE_REQUEST
, NULL
},
1298 { 6, szOID_CMC_QUERY_PENDING
, 0, (LPCWSTR
)IDS_QUERY_PENDING
, NULL
},
1299 { 6, szOID_SORTED_CTL
, 0, (LPCWSTR
)IDS_SORTED_CTL
, NULL
},
1300 { 6, szOID_ARCHIVED_KEY_CERT_HASH
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_CERT_HASH
, NULL
},
1301 { 6, szOID_PRIVATEKEY_USAGE_PERIOD
, 0, (LPCWSTR
)IDS_PRIVATE_KEY_USAGE_PERIOD
, NULL
},
1302 { 6, szOID_REQUEST_CLIENT_INFO
, 0, (LPCWSTR
)IDS_CLIENT_INFORMATION
, NULL
},
1304 { 7, szOID_PKIX_KP_SERVER_AUTH
, 0, (LPCWSTR
)IDS_SERVER_AUTHENTICATION
, NULL
},
1305 { 7, szOID_PKIX_KP_CLIENT_AUTH
, 0, (LPCWSTR
)IDS_CLIENT_AUTHENTICATION
, NULL
},
1306 { 7, szOID_PKIX_KP_CODE_SIGNING
, 0, (LPCWSTR
)IDS_CODE_SIGNING
, NULL
},
1307 { 7, szOID_PKIX_KP_EMAIL_PROTECTION
, 0, (LPCWSTR
)IDS_SECURE_EMAIL
, NULL
},
1308 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING
, 0, (LPCWSTR
)IDS_TIME_STAMPING
, NULL
},
1309 { 7, szOID_KP_CTL_USAGE_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TRUST_LIST_SIGNING
, NULL
},
1310 { 7, szOID_KP_TIME_STAMP_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TIME_STAMPING
, NULL
},
1311 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM
, 0, (LPCWSTR
)IDS_IPSEC_END_SYSTEM
, NULL
},
1312 { 7, szOID_PKIX_KP_IPSEC_TUNNEL
, 0, (LPCWSTR
)IDS_IPSEC_TUNNEL
, NULL
},
1313 { 7, szOID_PKIX_KP_IPSEC_USER
, 0, (LPCWSTR
)IDS_IPSEC_USER
, NULL
},
1314 { 7, szOID_KP_EFS
, 0, (LPCWSTR
)IDS_EFS
, NULL
},
1315 { 7, szOID_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_WHQL_CRYPTO
, NULL
},
1316 { 7, szOID_NT5_CRYPTO
, 0, (LPCWSTR
)IDS_NT5_CRYPTO
, NULL
},
1317 { 7, szOID_OEM_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_OEM_WHQL_CRYPTO
, NULL
},
1318 { 7, szOID_EMBEDDED_NT_CRYPTO
, 0, (LPCWSTR
)IDS_EMBEDDED_NT_CRYPTO
, NULL
},
1319 { 7, szOID_LICENSES
, 0, (LPCWSTR
)IDS_KEY_PACK_LICENSES
, NULL
},
1320 { 7, szOID_LICENSE_SERVER
, 0, (LPCWSTR
)IDS_LICENSE_SERVER
, NULL
},
1321 { 7, szOID_KP_SMARTCARD_LOGON
, 0, (LPCWSTR
)IDS_SMART_CARD_LOGON
, NULL
},
1322 { 7, szOID_DRM
, 0, (LPCWSTR
)IDS_DIGITAL_RIGHTS
, NULL
},
1323 { 7, szOID_KP_QUALIFIED_SUBORDINATION
, 0, (LPCWSTR
)IDS_QUALIFIED_SUBORDINATION
, NULL
},
1324 { 7, szOID_KP_KEY_RECOVERY
, 0, (LPCWSTR
)IDS_KEY_RECOVERY
, NULL
},
1325 { 7, szOID_KP_DOCUMENT_SIGNING
, 0, (LPCWSTR
)IDS_DOCUMENT_SIGNING
, NULL
},
1326 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE
, 0, (LPCWSTR
)IDS_IPSEC_IKE_INTERMEDIATE
, NULL
},
1327 { 7, szOID_EFS_RECOVERY
, 0, (LPCWSTR
)IDS_FILE_RECOVERY
, NULL
},
1328 { 7, szOID_ROOT_LIST_SIGNER
, 0, (LPCWSTR
)IDS_ROOT_LIST_SIGNER
, NULL
},
1329 { 7, szOID_ANY_APPLICATION_POLICY
, 0, (LPCWSTR
)IDS_ANY_APPLICATION_POLICIES
, NULL
},
1330 { 7, szOID_DS_EMAIL_REPLICATION
, 0, (LPCWSTR
)IDS_DS_EMAIL_REPLICATION
, NULL
},
1331 { 7, szOID_ENROLLMENT_AGENT
, 0, (LPCWSTR
)IDS_ENROLLMENT_AGENT
, NULL
},
1332 { 7, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1333 { 7, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1334 { 7, szOID_KP_LIFETIME_SIGNING
, 0, (LPCWSTR
)IDS_LIFETIME_SIGNING
, NULL
},
1336 { 8, szOID_ANY_CERT_POLICY
, 0, (LPCWSTR
)IDS_ANY_CERT_POLICY
, NULL
},
1340 CRYPT_OID_INFO info
;
1344 static void init_oid_info(HINSTANCE hinst
)
1348 for (i
= 0; i
< sizeof(oidInfoConstructors
) /
1349 sizeof(oidInfoConstructors
[0]); i
++)
1351 if (HIWORD(oidInfoConstructors
[i
].pwszName
))
1353 struct OIDInfo
*info
;
1355 /* The name is a static string, so just use the same pointer */
1356 info
= CryptMemAlloc(sizeof(struct OIDInfo
));
1359 memset(info
, 0, sizeof(*info
));
1360 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1361 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1362 info
->info
.pwszName
= oidInfoConstructors
[i
].pwszName
;
1363 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1364 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1365 if (oidInfoConstructors
[i
].blob
)
1367 info
->info
.ExtraInfo
.cbData
=
1368 oidInfoConstructors
[i
].blob
->cbData
;
1369 info
->info
.ExtraInfo
.pbData
=
1370 oidInfoConstructors
[i
].blob
->pbData
;
1372 list_add_tail(&oidInfo
, &info
->entry
);
1377 int len
= LoadStringW(hinst
, (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1382 struct OIDInfo
*info
= CryptMemAlloc(sizeof(struct OIDInfo
) +
1383 (len
+ 1) * sizeof(WCHAR
));
1387 memset(info
, 0, sizeof(*info
));
1388 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1389 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1390 info
->info
.pwszName
=
1391 (LPWSTR
)((LPBYTE
)info
+ sizeof(struct OIDInfo
));
1392 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1393 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1394 LoadStringW(hinst
, (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1395 (LPWSTR
)info
->info
.pwszName
, len
+ 1);
1396 if (oidInfoConstructors
[i
].blob
)
1398 info
->info
.ExtraInfo
.cbData
=
1399 oidInfoConstructors
[i
].blob
->cbData
;
1400 info
->info
.ExtraInfo
.pbData
=
1401 oidInfoConstructors
[i
].blob
->pbData
;
1403 list_add_tail(&oidInfo
, &info
->entry
);
1410 static void free_oid_info(void)
1412 struct OIDInfo
*info
, *next
;
1414 LIST_FOR_EACH_ENTRY_SAFE(info
, next
, &oidInfo
, struct OIDInfo
, entry
)
1416 list_remove(&info
->entry
);
1421 /***********************************************************************
1422 * CryptEnumOIDInfo (CRYPT32.@)
1424 BOOL WINAPI
CryptEnumOIDInfo(DWORD dwGroupId
, DWORD dwFlags
, void *pvArg
,
1425 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo
)
1428 struct OIDInfo
*info
;
1430 TRACE("(%d, %08x, %p, %p)\n", dwGroupId
, dwFlags
, pvArg
,
1433 EnterCriticalSection(&oidInfoCS
);
1434 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1436 if (!dwGroupId
|| dwGroupId
== info
->info
.dwGroupId
)
1438 ret
= pfnEnumOIDInfo(&info
->info
, pvArg
);
1443 LeaveCriticalSection(&oidInfoCS
);
1447 PCCRYPT_OID_INFO WINAPI
CryptFindOIDInfo(DWORD dwKeyType
, void *pvKey
,
1450 PCCRYPT_OID_INFO ret
= NULL
;
1452 TRACE("(%d, %p, %d)\n", dwKeyType
, pvKey
, dwGroupId
);
1456 case CRYPT_OID_INFO_ALGID_KEY
:
1458 struct OIDInfo
*info
;
1460 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD
*)pvKey
);
1461 EnterCriticalSection(&oidInfoCS
);
1462 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1464 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1465 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1471 LeaveCriticalSection(&oidInfoCS
);
1474 case CRYPT_OID_INFO_NAME_KEY
:
1476 struct OIDInfo
*info
;
1478 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w((LPWSTR
)pvKey
));
1479 EnterCriticalSection(&oidInfoCS
);
1480 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1482 if (!lstrcmpW(info
->info
.pwszName
, (LPWSTR
)pvKey
) &&
1483 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1489 LeaveCriticalSection(&oidInfoCS
);
1492 case CRYPT_OID_INFO_OID_KEY
:
1494 struct OIDInfo
*info
;
1495 LPSTR oid
= (LPSTR
)pvKey
;
1497 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid
));
1498 EnterCriticalSection(&oidInfoCS
);
1499 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1501 if (!lstrcmpA(info
->info
.pszOID
, oid
) &&
1502 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1508 LeaveCriticalSection(&oidInfoCS
);
1511 case CRYPT_OID_INFO_SIGN_KEY
:
1513 struct OIDInfo
*info
;
1515 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD
*)pvKey
);
1516 EnterCriticalSection(&oidInfoCS
);
1517 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1519 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1520 info
->info
.ExtraInfo
.cbData
>= sizeof(DWORD
) &&
1521 *(DWORD
*)info
->info
.ExtraInfo
.pbData
==
1522 *(DWORD
*)((LPBYTE
)pvKey
+ sizeof(DWORD
)) &&
1523 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1529 LeaveCriticalSection(&oidInfoCS
);
1536 LPCSTR WINAPI
CertAlgIdToOID(DWORD dwAlgId
)
1539 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY
,
1549 DWORD WINAPI
CertOIDToAlgId(LPCSTR pszObjId
)
1552 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY
,
1553 (void *)pszObjId
, 0);
1556 ret
= info
->u
.Algid
;