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_function_sets(void);
41 static void init_oid_info(HINSTANCE hinst
);
42 static void free_function_sets(void);
43 static void free_oid_info(void);
45 void crypt_oid_init(HINSTANCE hinst
)
51 void crypt_oid_free(void)
57 static CRITICAL_SECTION funcSetCS
;
58 static struct list funcSets
;
63 CRITICAL_SECTION cs
; /* protects functions */
64 struct list functions
;
71 CRYPT_OID_FUNC_ENTRY entry
;
75 static void init_function_sets(void)
77 InitializeCriticalSection(&funcSetCS
);
78 funcSetCS
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": funcSetCS");
82 static void free_function_sets(void)
84 struct OIDFunctionSet
*setCursor
, *setNext
;
86 LIST_FOR_EACH_ENTRY_SAFE(setCursor
, setNext
, &funcSets
,
87 struct OIDFunctionSet
, next
)
89 struct OIDFunction
*functionCursor
, *funcNext
;
91 list_remove(&setCursor
->next
);
92 CryptMemFree(setCursor
->name
);
93 LIST_FOR_EACH_ENTRY_SAFE(functionCursor
, funcNext
,
94 &setCursor
->functions
, struct OIDFunction
, next
)
96 list_remove(&functionCursor
->next
);
97 CryptMemFree(functionCursor
);
99 setCursor
->cs
.DebugInfo
->Spare
[0] = 0;
100 DeleteCriticalSection(&setCursor
->cs
);
101 CryptMemFree(setCursor
);
103 funcSetCS
.DebugInfo
->Spare
[0] = 0;
104 DeleteCriticalSection(&funcSetCS
);
107 /* There is no free function associated with this; therefore, the sets are
108 * freed when crypt32.dll is unloaded.
110 HCRYPTOIDFUNCSET WINAPI
CryptInitOIDFunctionSet(LPCSTR pszFuncName
,
113 struct OIDFunctionSet
*cursor
, *ret
= NULL
;
115 TRACE("(%s, %x)\n", debugstr_a(pszFuncName
), dwFlags
);
117 EnterCriticalSection(&funcSetCS
);
118 LIST_FOR_EACH_ENTRY(cursor
, &funcSets
, struct OIDFunctionSet
, next
)
120 if (!strcasecmp(pszFuncName
, cursor
->name
))
122 ret
= (HCRYPTOIDFUNCSET
)cursor
;
128 ret
= CryptMemAlloc(sizeof(struct OIDFunctionSet
));
131 memset(ret
, 0, sizeof(*ret
));
132 ret
->name
= CryptMemAlloc(strlen(pszFuncName
) + 1);
135 InitializeCriticalSection(&ret
->cs
);
136 ret
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": OIDFunctionSet.cs");
137 list_init(&ret
->functions
);
138 strcpy(ret
->name
, pszFuncName
);
139 list_add_tail(&funcSets
, &ret
->next
);
148 LeaveCriticalSection(&funcSetCS
);
150 return (HCRYPTOIDFUNCSET
)ret
;
153 static char *CRYPT_GetKeyName(DWORD dwEncodingType
, LPCSTR pszFuncName
,
156 static const char szEncodingTypeFmt
[] =
157 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
159 char numericOID
[7]; /* enough for "#65535" */
163 /* MSDN says the encoding type is a mask, but it isn't treated that way.
164 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
165 * "EncodingType 2" would be expected if it were a mask. Instead native
166 * stores values in "EncodingType 3".
170 snprintf(numericOID
, sizeof(numericOID
), "#%d", LOWORD(pszOID
));
176 /* This is enough: the lengths of the two string parameters are explicitly
177 * counted, and we need up to five additional characters for the encoding
178 * type. These are covered by the "%d", "%s", and "%s" characters in the
179 * format specifier that are removed by sprintf.
181 len
= sizeof(szEncodingTypeFmt
) + lstrlenA(pszFuncName
) + lstrlenA(oid
);
182 szKey
= CryptMemAlloc(len
);
184 sprintf(szKey
, szEncodingTypeFmt
, dwEncodingType
, pszFuncName
, oid
);
188 BOOL WINAPI
CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet
,
189 DWORD dwEncodingType
, LPWSTR pwszDllList
, DWORD
*pcchDllList
)
192 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
197 TRACE("(%p, %d, %p, %p)\n", hFuncSet
, dwEncodingType
, pwszDllList
,
200 keyName
= CRYPT_GetKeyName(dwEncodingType
, set
->name
, "DEFAULT");
201 rc
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0,
202 KEY_READ
, NULL
, &key
, NULL
);
205 DWORD size
= *pcchDllList
* sizeof(WCHAR
);
207 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
, (LPBYTE
)pwszDllList
,
210 *pcchDllList
= size
/ sizeof(WCHAR
);
213 /* No value, return an empty list */
225 CryptMemFree(keyName
);
230 BOOL WINAPI
CryptInstallOIDFunctionAddress(HMODULE hModule
,
231 DWORD dwEncodingType
, LPCSTR pszFuncName
, DWORD cFuncEntry
,
232 const CRYPT_OID_FUNC_ENTRY rgFuncEntry
[], DWORD dwFlags
)
235 struct OIDFunctionSet
*set
;
237 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule
, dwEncodingType
,
238 debugstr_a(pszFuncName
), cFuncEntry
, rgFuncEntry
, dwFlags
);
240 set
= (struct OIDFunctionSet
*)CryptInitOIDFunctionSet(pszFuncName
, 0);
245 EnterCriticalSection(&set
->cs
);
246 for (i
= 0; ret
&& i
< cFuncEntry
; i
++)
248 struct OIDFunction
*func
;
250 if (HIWORD(rgFuncEntry
[i
].pszOID
))
251 func
= CryptMemAlloc(sizeof(struct OIDFunction
)
252 + strlen(rgFuncEntry
[i
].pszOID
) + 1);
254 func
= CryptMemAlloc(sizeof(struct OIDFunction
));
257 func
->encoding
= dwEncodingType
;
258 if (HIWORD(rgFuncEntry
[i
].pszOID
))
262 oid
= (LPSTR
)((LPBYTE
)func
+ sizeof(*func
));
263 strcpy(oid
, rgFuncEntry
[i
].pszOID
);
264 func
->entry
.pszOID
= oid
;
267 func
->entry
.pszOID
= rgFuncEntry
[i
].pszOID
;
268 func
->entry
.pvFuncAddr
= rgFuncEntry
[i
].pvFuncAddr
;
269 list_add_tail(&set
->functions
, &func
->next
);
274 LeaveCriticalSection(&set
->cs
);
281 static BOOL
CRYPT_GetFuncFromReg(DWORD dwEncodingType
, LPCSTR pszOID
,
282 LPCSTR szFuncName
, LPVOID
*ppvFuncAddr
, HCRYPTOIDFUNCADDR
*phFuncAddr
)
286 const char *funcName
;
290 keyName
= CRYPT_GetKeyName(dwEncodingType
, szFuncName
, pszOID
);
291 rc
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, KEY_READ
, &key
);
294 DWORD type
, size
= 0;
296 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
, NULL
, &size
);
297 if (rc
== ERROR_MORE_DATA
&& type
== REG_SZ
)
299 funcName
= CryptMemAlloc(size
);
300 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
,
301 (LPBYTE
)funcName
, &size
);
304 funcName
= szFuncName
;
305 rc
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
306 if (rc
== ERROR_MORE_DATA
&& type
== REG_SZ
)
308 LPWSTR dllName
= CryptMemAlloc(size
);
312 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
,
313 (LPBYTE
)dllName
, &size
);
318 /* This is a bit of a hack; MSDN describes a more
319 * complicated unload routine than this will allow.
320 * Still, this seems to suffice for now.
322 lib
= LoadLibraryW(dllName
);
325 *ppvFuncAddr
= GetProcAddress(lib
, szFuncName
);
328 *phFuncAddr
= (HCRYPTOIDFUNCADDR
)lib
;
333 /* Unload the library, the caller doesn't want
334 * to unload it when the return value is NULL.
342 CryptMemFree(dllName
);
347 if (funcName
!= szFuncName
)
348 CryptMemFree((char *)funcName
);
353 CryptMemFree(keyName
);
357 BOOL WINAPI
CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
358 DWORD dwEncodingType
, LPCSTR pszOID
, DWORD dwFlags
, void **ppvFuncAddr
,
359 HCRYPTOIDFUNCADDR
*phFuncAddr
)
362 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
364 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet
, dwEncodingType
,
365 debugstr_a(pszOID
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
368 if (!(dwFlags
& CRYPT_GET_INSTALLED_OID_FUNC_FLAG
))
370 struct OIDFunction
*function
;
372 EnterCriticalSection(&set
->cs
);
373 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
375 if (function
->encoding
== dwEncodingType
)
379 if (HIWORD(function
->entry
.pszOID
) &&
380 !strcasecmp(function
->entry
.pszOID
, pszOID
))
382 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
383 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
388 else if (function
->entry
.pszOID
== pszOID
)
390 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
391 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
397 LeaveCriticalSection(&set
->cs
);
400 ret
= CRYPT_GetFuncFromReg(dwEncodingType
, pszOID
, set
->name
,
401 ppvFuncAddr
, phFuncAddr
);
405 BOOL WINAPI
CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr
,
408 TRACE("(%p, %08x)\n", hFuncAddr
, dwFlags
);
410 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
411 * and only unload it if it can be unloaded. Also need to implement ref
412 * counting on the functions.
414 FreeLibrary((HMODULE
)hFuncAddr
);
418 BOOL WINAPI
CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
419 DWORD dwEncodingType
, LPCWSTR pwszDll
, DWORD dwFlags
, void *ppvFuncAddr
,
420 HCRYPTOIDFUNCADDR
*phFuncAddr
)
422 FIXME("(%p, %d, %s, %08x, %p, %p): stub\n", hFuncSet
, dwEncodingType
,
423 debugstr_w(pwszDll
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
427 /***********************************************************************
428 * CryptRegisterOIDFunction (CRYPT32.@)
430 * Register the DLL and the functions it uses to cover the combination
431 * of encoding type, functionname and OID.
434 * dwEncodingType [I] Encoding type to be used.
435 * pszFuncName [I] Name of the function to be registered.
436 * pszOID [I] OID of the function (numeric or string).
437 * pwszDll [I] The DLL that is to be registered.
438 * pszOverrideFuncName [I] Name of the function in the DLL.
442 * Failure: FALSE. (Look at GetLastError()).
445 * Registry errors are always reported via SetLastError().
447 BOOL WINAPI
CryptRegisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
448 LPCSTR pszOID
, LPCWSTR pwszDll
, LPCSTR pszOverrideFuncName
)
454 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType
, pszFuncName
,
455 debugstr_a(pszOID
), debugstr_w(pwszDll
), pszOverrideFuncName
);
457 /* This only registers functions for encoding certs, not messages */
458 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
461 /* Native does nothing pwszDll is NULL */
465 /* I'm not matching MS bug for bug here, because I doubt any app depends on
466 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
467 * it creates would never be used.
469 if (!pszFuncName
|| !pszOID
)
471 SetLastError(E_INVALIDARG
);
475 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
476 TRACE("Key name is %s\n", debugstr_a(szKey
));
481 r
= RegCreateKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
484 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
486 /* write the values */
487 if (pszOverrideFuncName
)
489 r
= RegSetValueExA(hKey
, "FuncName", 0, REG_SZ
,
490 (const BYTE
*)pszOverrideFuncName
, lstrlenA(pszOverrideFuncName
) + 1);
491 if (r
!= ERROR_SUCCESS
) goto error_close_key
;
493 r
= RegSetValueExW(hKey
, DllW
, 0, REG_SZ
, (const BYTE
*) pwszDll
,
494 (lstrlenW(pwszDll
) + 1) * sizeof (WCHAR
));
500 if (r
!= ERROR_SUCCESS
)
509 /***********************************************************************
510 * CryptUnregisterOIDFunction (CRYPT32.@)
512 BOOL WINAPI
CryptUnregisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
518 TRACE("%x %s %s\n", dwEncodingType
, pszFuncName
, pszOID
);
520 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
523 if (!pszFuncName
|| !pszOID
)
525 SetLastError(ERROR_INVALID_PARAMETER
);
529 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
530 rc
= RegDeleteKeyA(HKEY_LOCAL_MACHINE
, szKey
);
534 return rc
? FALSE
: TRUE
;
537 BOOL WINAPI
CryptGetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
538 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD
*pdwValueType
, BYTE
*pbValueData
,
545 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType
, debugstr_a(pszFuncName
),
546 debugstr_a(pszOID
), debugstr_w(pwszValueName
), pdwValueType
, pbValueData
,
549 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
552 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
554 SetLastError(ERROR_INVALID_PARAMETER
);
558 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
559 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
565 rc
= RegQueryValueExW(hKey
, pwszValueName
, NULL
, pdwValueType
,
566 pbValueData
, pcbValueData
);
571 return rc
? FALSE
: TRUE
;
574 BOOL WINAPI
CryptSetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
575 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD dwValueType
,
576 const BYTE
*pbValueData
, DWORD cbValueData
)
582 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType
, debugstr_a(pszFuncName
),
583 debugstr_a(pszOID
), debugstr_w(pwszValueName
), dwValueType
, pbValueData
,
586 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
589 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
591 SetLastError(ERROR_INVALID_PARAMETER
);
595 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
596 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
602 rc
= RegSetValueExW(hKey
, pwszValueName
, 0, dwValueType
, pbValueData
,
608 return rc
? FALSE
: TRUE
;
611 static LPCWSTR
CRYPT_FindStringInMultiString(LPCWSTR multi
, LPCWSTR toFind
)
613 LPCWSTR ret
= NULL
, ptr
;
615 for (ptr
= multi
; ptr
&& *ptr
&& !ret
; ptr
+= lstrlenW(ptr
) + 1)
617 if (!lstrcmpiW(ptr
, toFind
))
623 static DWORD
CRYPT_GetMultiStringCharacterLen(LPCWSTR multi
)
631 /* Count terminating empty string */
633 for (ptr
= multi
; *ptr
; ptr
+= lstrlenW(ptr
) + 1)
634 ret
+= lstrlenW(ptr
) + 1;
641 static LPWSTR
CRYPT_AddStringToMultiString(LPWSTR multi
, LPCWSTR toAdd
,
648 /* FIXME: ignoring index, is that okay? */
649 ret
= CryptMemAlloc((lstrlenW(toAdd
) + 2) * sizeof(WCHAR
));
652 /* copy string, including NULL terminator */
653 memcpy(ret
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
654 /* add terminating empty string */
655 *(ret
+ lstrlenW(toAdd
) + 1) = 0;
660 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
662 ret
= CryptMemRealloc(multi
, (len
+ lstrlenW(toAdd
) + 1) *
668 if (index
== CRYPT_REGISTER_LAST_INDEX
)
669 spotToAdd
= ret
+ len
- 1;
674 /* FIXME: if index is too large for the string, toAdd is
675 * added to the end. Is that okay?
677 for (i
= 0, spotToAdd
= ret
; i
< index
&& *spotToAdd
;
678 spotToAdd
+= lstrlenW(spotToAdd
) + 1)
683 /* Copy existing string "right" */
684 memmove(spotToAdd
+ lstrlenW(toAdd
) + 1, spotToAdd
,
685 (len
- (spotToAdd
- ret
)) * sizeof(WCHAR
));
686 /* Copy new string */
687 memcpy(spotToAdd
, toAdd
, (lstrlenW(toAdd
) + 1) * sizeof(WCHAR
));
699 static BOOL
CRYPT_RemoveStringFromMultiString(LPWSTR multi
, LPCWSTR toRemove
)
701 LPWSTR spotToRemove
= (LPWSTR
)CRYPT_FindStringInMultiString(multi
,
707 DWORD len
= CRYPT_GetMultiStringCharacterLen(multi
);
709 /* Copy remainder of string "left" */
710 memmove(spotToRemove
, spotToRemove
+ lstrlenW(toRemove
) + 1,
711 (len
- (spotToRemove
- multi
)) * sizeof(WCHAR
));
716 SetLastError(ERROR_FILE_NOT_FOUND
);
722 static BOOL
CRYPT_GetDefaultOIDKey(DWORD dwEncodingType
, LPCSTR pszFuncName
,
728 keyName
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, "DEFAULT");
729 TRACE("Key name is %s\n", debugstr_a(keyName
));
734 r
= RegCreateKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, NULL
, 0, KEY_ALL_ACCESS
,
736 CryptMemFree(keyName
);
737 if (r
!= ERROR_SUCCESS
)
745 static LPWSTR
CRYPT_GetDefaultOIDDlls(HKEY key
)
751 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
752 if (r
== ERROR_SUCCESS
&& type
== REG_MULTI_SZ
)
754 dlls
= CryptMemAlloc(size
);
755 r
= RegQueryValueExW(key
, DllW
, NULL
, &type
, (LPBYTE
)dlls
, &size
);
756 if (r
!= ERROR_SUCCESS
)
767 static inline BOOL
CRYPT_SetDefaultOIDDlls(HKEY key
, LPCWSTR dlls
)
769 DWORD len
= CRYPT_GetMultiStringCharacterLen(dlls
);
772 if ((r
= RegSetValueExW(key
, DllW
, 0, REG_MULTI_SZ
, (const BYTE
*)dlls
,
773 len
* sizeof (WCHAR
))))
775 return r
== ERROR_SUCCESS
;
778 /***********************************************************************
779 * CryptRegisterDefaultOIDFunction (CRYPT32.@)
781 BOOL WINAPI
CryptRegisterDefaultOIDFunction(DWORD dwEncodingType
,
782 LPCSTR pszFuncName
, DWORD dwIndex
, LPCWSTR pwszDll
)
789 TRACE("(%x, %s, %x, %s)\n", dwEncodingType
, pszFuncName
, dwIndex
,
790 debugstr_w(pwszDll
));
794 SetLastError(E_INVALIDARG
);
798 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
801 dlls
= CRYPT_GetDefaultOIDDlls(key
);
802 if ((existing
= CRYPT_FindStringInMultiString(dlls
, pwszDll
)))
803 SetLastError(ERROR_FILE_EXISTS
);
806 dlls
= CRYPT_AddStringToMultiString(dlls
, pwszDll
, dwIndex
);
808 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
815 BOOL WINAPI
CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType
,
816 LPCSTR pszFuncName
, LPCWSTR pwszDll
)
822 TRACE("(%x, %s, %s)\n", dwEncodingType
, debugstr_a(pszFuncName
),
823 debugstr_w(pwszDll
));
827 SetLastError(E_INVALIDARG
);
831 if (!CRYPT_GetDefaultOIDKey(dwEncodingType
, pszFuncName
, &key
))
834 dlls
= CRYPT_GetDefaultOIDDlls(key
);
835 if ((ret
= CRYPT_RemoveStringFromMultiString(dlls
, pwszDll
)))
836 ret
= CRYPT_SetDefaultOIDDlls(key
, dlls
);
842 static CRITICAL_SECTION oidInfoCS
;
843 static struct list oidInfo
;
845 static const WCHAR tripledes
[] = { '3','d','e','s',0 };
846 static const WCHAR cms3deswrap
[] = { 'C','M','S','3','D','E','S','w','r','a',
848 static const WCHAR cmsrc2wrap
[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
849 static const WCHAR des
[] = { 'd','e','s',0 };
850 static const WCHAR md2
[] = { 'm','d','2',0 };
851 static const WCHAR md4
[] = { 'm','d','4',0 };
852 static const WCHAR md5
[] = { 'm','d','5',0 };
853 static const WCHAR rc2
[] = { 'r','c','2',0 };
854 static const WCHAR rc4
[] = { 'r','c','4',0 };
855 static const WCHAR sha
[] = { 's','h','a',0 };
856 static const WCHAR sha1
[] = { 's','h','a','1',0 };
857 static const WCHAR RSA
[] = { 'R','S','A',0 };
858 static const WCHAR RSA_KEYX
[] = { 'R','S','A','_','K','E','Y','X',0 };
859 static const WCHAR RSA_SIGN
[] = { 'R','S','A','_','S','I','G','N',0 };
860 static const WCHAR DSA
[] = { 'D','S','A',0 };
861 static const WCHAR DSA_SIGN
[] = { 'D','S','A','_','S','I','G','N',0 };
862 static const WCHAR DH
[] = { 'D','H',0 };
863 static const WCHAR DSS
[] = { 'D','S','S',0 };
864 static const WCHAR mosaicKMandUpdSig
[] =
865 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
866 static const WCHAR ESDH
[] = { 'E','S','D','H',0 };
867 static const WCHAR NO_SIGN
[] = { 'N','O','S','I','G','N',0 };
868 static const WCHAR dsaSHA1
[] = { 'd','s','a','S','H','A','1',0 };
869 static const WCHAR md2RSA
[] = { 'm','d','2','R','S','A',0 };
870 static const WCHAR md4RSA
[] = { 'm','d','4','R','S','A',0 };
871 static const WCHAR md5RSA
[] = { 'm','d','5','R','S','A',0 };
872 static const WCHAR shaDSA
[] = { 's','h','a','D','S','A',0 };
873 static const WCHAR sha1DSA
[] = { 's','h','a','1','D','S','A',0 };
874 static const WCHAR shaRSA
[] = { 's','h','a','R','S','A',0 };
875 static const WCHAR sha1RSA
[] = { 's','h','a','1','R','S','A',0 };
876 static const WCHAR mosaicUpdatedSig
[] =
877 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
878 static const WCHAR CN
[] = { 'C','N',0 };
879 static const WCHAR L
[] = { 'L',0 };
880 static const WCHAR O
[] = { 'O',0 };
881 static const WCHAR OU
[] = { 'O','U',0 };
882 static const WCHAR E
[] = { 'E',0 };
883 static const WCHAR C
[] = { 'C',0 };
884 static const WCHAR S
[] = { 'S',0 };
885 static const WCHAR ST
[] = { 'S','T',0 };
886 static const WCHAR STREET
[] = { 'S','T','R','E','E','T',0 };
887 static const WCHAR T
[] = { 'T',0 };
888 static const WCHAR Title
[] = { 'T','i','t','l','e',0 };
889 static const WCHAR G
[] = { 'G',0 };
890 static const WCHAR GivenName
[] = { 'G','i','v','e','n','N','a','m','e',0 };
891 static const WCHAR I
[] = { 'I',0 };
892 static const WCHAR Initials
[] = { 'I','n','i','t','i','a','l','s',0 };
893 static const WCHAR SN
[] = { 'S','N',0 };
894 static const WCHAR DC
[] = { 'D','C',0 };
895 static const WCHAR Description
[] =
896 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
897 static const WCHAR PostalCode
[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
898 static const WCHAR POBox
[] = { 'P','O','B','o','x',0 };
899 static const WCHAR Phone
[] = { 'P','h','o','n','e',0 };
900 static const WCHAR X21Address
[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
901 static const WCHAR dnQualifier
[] =
902 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
903 static const WCHAR Email
[] = { 'E','m','a','i','l',0 };
904 static const WCHAR GN
[] = { 'G','N',0 };
906 static const DWORD noNullFlag
= CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
907 static const DWORD mosaicFlags
= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
908 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
909 static const CRYPT_DATA_BLOB noNullBlob
= { sizeof(noNullFlag
),
910 (LPBYTE
)&noNullFlag
};
911 static const CRYPT_DATA_BLOB mosaicFlagsBlob
= { sizeof(mosaicFlags
),
912 (LPBYTE
)&mosaicFlags
};
914 static const DWORD rsaSign
= CALG_RSA_SIGN
;
915 static const DWORD dssSign
[2] = { CALG_DSS_SIGN
,
916 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
917 static const DWORD mosaicSign
[2] = { CALG_DSS_SIGN
,
918 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
919 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
920 static const CRYPT_DATA_BLOB rsaSignBlob
= { sizeof(rsaSign
),
922 static const CRYPT_DATA_BLOB dssSignBlob
= { sizeof(dssSign
),
924 static const CRYPT_DATA_BLOB mosaicSignBlob
= { sizeof(mosaicSign
),
925 (LPBYTE
)mosaicSign
};
927 static const DWORD ia5String
[] = { CERT_RDN_IA5_STRING
, 0 };
928 static const DWORD numericString
[] = { CERT_RDN_NUMERIC_STRING
, 0 };
929 static const DWORD printableString
[] = { CERT_RDN_PRINTABLE_STRING
, 0 };
930 static const DWORD domainCompTypes
[] = { CERT_RDN_IA5_STRING
,
931 CERT_RDN_UTF8_STRING
, 0 };
932 static const CRYPT_DATA_BLOB ia5StringBlob
= { sizeof(ia5String
),
934 static const CRYPT_DATA_BLOB numericStringBlob
= { sizeof(numericString
),
935 (LPBYTE
)numericString
};
936 static const CRYPT_DATA_BLOB printableStringBlob
= { sizeof(printableString
),
937 (LPBYTE
)printableString
};
938 static const CRYPT_DATA_BLOB domainCompTypesBlob
= { sizeof(domainCompTypes
),
939 (LPBYTE
)domainCompTypes
};
941 static const struct OIDInfoConstructor
{
946 const CRYPT_DATA_BLOB
*blob
;
947 } oidInfoConstructors
[] = {
948 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha1
, NULL
},
949 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha
, NULL
},
950 { 1, szOID_OIWSEC_sha
, CALG_SHA
, sha
, NULL
},
951 { 1, szOID_RSA_MD5
, CALG_MD5
, md5
, NULL
},
952 { 1, szOID_RSA_MD4
, CALG_MD4
, md4
, NULL
},
953 { 1, szOID_RSA_MD2
, CALG_MD2
, md2
, NULL
},
955 { 2, szOID_OIWSEC_desCBC
, CALG_DES
, des
, NULL
},
956 { 2, szOID_RSA_DES_EDE3_CBC
, CALG_3DES
, tripledes
, NULL
},
957 { 2, szOID_RSA_RC2CBC
, CALG_RC2
, rc2
, NULL
},
958 { 2, szOID_RSA_RC4
, CALG_RC4
, rc4
, NULL
},
959 { 2, szOID_RSA_SMIMEalgCMS3DESwrap
, CALG_3DES
, cms3deswrap
, NULL
},
960 { 2, szOID_RSA_SMIMEalgCMSRC2wrap
, CALG_RC2
, cmsrc2wrap
, NULL
},
962 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA
, NULL
},
963 { 3, szOID_X957_DSA
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
964 { 3, szOID_ANSI_X942_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
965 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
966 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA
, NULL
},
967 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA_SIGN
, NULL
},
968 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
969 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSS
, &noNullBlob
},
970 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA_SIGN
, &noNullBlob
},
971 { 3, szOID_RSA_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
972 { 3, szOID_OIWSEC_rsaXchg
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
973 { 3, szOID_INFOSEC_mosaicKMandUpdSig
, CALG_DSS_SIGN
, mosaicKMandUpdSig
,
975 { 3, szOID_RSA_SMIMEalgESDH
, CALG_DH_EPHEM
, ESDH
, &noNullBlob
},
976 { 3, szOID_PKIX_NO_SIGNATURE
, CALG_NO_SIGN
, NO_SIGN
, NULL
},
978 { 4, szOID_RSA_SHA1RSA
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
979 { 4, szOID_RSA_MD5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
980 { 4, szOID_X957_SHA1DSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
981 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
982 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
983 { 4, szOID_OIWSEC_shaRSA
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
984 { 4, szOID_OIWSEC_md5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
985 { 4, szOID_RSA_MD2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
986 { 4, szOID_RSA_MD4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
987 { 4, szOID_OIWSEC_md4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
988 { 4, szOID_OIWSEC_md4RSA2
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
989 { 4, szOID_OIWDIR_md2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
990 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
991 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, shaDSA
, &dssSignBlob
},
992 { 4, szOID_OIWSEC_dsaSHA1
, CALG_SHA1
, dsaSHA1
, &dssSignBlob
},
993 { 4, szOID_INFOSEC_mosaicUpdatedSig
, CALG_SHA1
, mosaicUpdatedSig
,
996 { 5, szOID_COMMON_NAME
, 0, CN
, NULL
},
997 { 5, szOID_LOCALITY_NAME
, 0, L
, NULL
},
998 { 5, szOID_ORGANIZATION_NAME
, 0, O
, NULL
},
999 { 5, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, OU
, NULL
},
1000 { 5, szOID_RSA_emailAddr
, 0, E
, &ia5StringBlob
},
1001 { 5, szOID_RSA_emailAddr
, 0, Email
, &ia5StringBlob
},
1002 { 5, szOID_COUNTRY_NAME
, 0, C
, &printableStringBlob
},
1003 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, S
, NULL
},
1004 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, ST
, NULL
},
1005 { 5, szOID_STREET_ADDRESS
, 0, STREET
, NULL
},
1006 { 5, szOID_TITLE
, 0, T
, NULL
},
1007 { 5, szOID_TITLE
, 0, Title
, NULL
},
1008 { 5, szOID_GIVEN_NAME
, 0, G
, NULL
},
1009 { 5, szOID_GIVEN_NAME
, 0, GN
, NULL
},
1010 { 5, szOID_GIVEN_NAME
, 0, GivenName
, NULL
},
1011 { 5, szOID_INITIALS
, 0, I
, NULL
},
1012 { 5, szOID_INITIALS
, 0, Initials
, NULL
},
1013 { 5, szOID_SUR_NAME
, 0, SN
, NULL
},
1014 { 5, szOID_DOMAIN_COMPONENT
, 0, DC
, &domainCompTypesBlob
},
1015 { 5, szOID_DESCRIPTION
, 0, Description
, NULL
},
1016 { 5, szOID_POSTAL_CODE
, 0, PostalCode
, NULL
},
1017 { 5, szOID_POST_OFFICE_BOX
, 0, POBox
, NULL
},
1018 { 5, szOID_TELEPHONE_NUMBER
, 0, Phone
, &printableStringBlob
},
1019 { 5, szOID_X21_ADDRESS
, 0, X21Address
, &numericStringBlob
},
1020 { 5, szOID_DN_QUALIFIER
, 0, dnQualifier
, NULL
},
1022 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1023 { 6, szOID_AUTHORITY_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
1024 { 6, szOID_KEY_ATTRIBUTES
, 0, (LPCWSTR
)IDS_KEY_ATTRIBUTES
, NULL
},
1025 { 6, szOID_KEY_USAGE_RESTRICTION
, 0, (LPCWSTR
)IDS_KEY_USAGE_RESTRICTION
, NULL
},
1026 { 6, szOID_SUBJECT_ALT_NAME2
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1027 { 6, szOID_SUBJECT_ALT_NAME
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
1028 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1029 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
1030 { 6, szOID_BASIC_CONSTRAINTS2
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1031 { 6, szOID_BASIC_CONSTRAINTS
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
1032 { 6, szOID_KEY_USAGE
, 0, (LPCWSTR
)IDS_KEY_USAGE
, NULL
},
1033 { 6, szOID_CERT_POLICIES
, 0, (LPCWSTR
)IDS_CERT_POLICIES
, NULL
},
1034 { 6, szOID_SUBJECT_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_SUBJECT_KEY_IDENTIFIER
, NULL
},
1035 { 6, szOID_CRL_REASON_CODE
, 0, (LPCWSTR
)IDS_CRL_REASON_CODE
, NULL
},
1036 { 6, szOID_CRL_DIST_POINTS
, 0, (LPCWSTR
)IDS_CRL_DIST_POINTS
, NULL
},
1037 { 6, szOID_ENHANCED_KEY_USAGE
, 0, (LPCWSTR
)IDS_ENHANCED_KEY_USAGE
, NULL
},
1038 { 6, szOID_AUTHORITY_INFO_ACCESS
, 0, (LPCWSTR
)IDS_AUTHORITY_INFO_ACCESS
, NULL
},
1039 { 6, szOID_CERT_EXTENSIONS
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1040 { 6, szOID_RSA_certExtensions
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
1041 { 6, szOID_NEXT_UPDATE_LOCATION
, 0, (LPCWSTR
)IDS_NEXT_UPDATE_LOCATION
, NULL
},
1042 { 6, szOID_YESNO_TRUST_ATTR
, 0, (LPCWSTR
)IDS_YES_OR_NO_TRUST
, NULL
},
1043 { 6, szOID_RSA_emailAddr
, 0, (LPCWSTR
)IDS_EMAIL_ADDRESS
, NULL
},
1044 { 6, szOID_RSA_unstructName
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_NAME
, NULL
},
1045 { 6, szOID_RSA_contentType
, 0, (LPCWSTR
)IDS_CONTENT_TYPE
, NULL
},
1046 { 6, szOID_RSA_messageDigest
, 0, (LPCWSTR
)IDS_MESSAGE_DIGEST
, NULL
},
1047 { 6, szOID_RSA_signingTime
, 0, (LPCWSTR
)IDS_SIGNING_TIME
, NULL
},
1048 { 6, szOID_RSA_counterSign
, 0, (LPCWSTR
)IDS_COUNTER_SIGN
, NULL
},
1049 { 6, szOID_RSA_challengePwd
, 0, (LPCWSTR
)IDS_CHALLENGE_PASSWORD
, NULL
},
1050 { 6, szOID_RSA_unstructAddr
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_ADDRESS
, NULL
},
1051 { 6, szOID_RSA_SMIMECapabilities
, 0, (LPCWSTR
)IDS_SMIME_CAPABILITIES
, NULL
},
1052 { 6, szOID_RSA_preferSignedData
, 0, (LPCWSTR
)IDS_PREFER_SIGNED_DATA
, NULL
},
1053 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS
, 0, (LPCWSTR
)IDS_CPS
, NULL
},
1054 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
, 0, (LPCWSTR
)IDS_USER_NOTICE
, NULL
},
1055 { 6, szOID_PKIX_OCSP
, 0, (LPCWSTR
)IDS_OCSP
, NULL
},
1056 { 6, szOID_PKIX_CA_ISSUERS
, 0, (LPCWSTR
)IDS_CA_ISSUER
, NULL
},
1057 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TEMPLATE_NAME
, NULL
},
1058 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TYPE
, NULL
},
1059 { 6, szOID_CERT_MANIFOLD
, 0, (LPCWSTR
)IDS_CERT_MANIFOLD
, NULL
},
1060 { 6, szOID_NETSCAPE_CERT_TYPE
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_TYPE
, NULL
},
1061 { 6, szOID_NETSCAPE_BASE_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_BASE_URL
, NULL
},
1062 { 6, szOID_NETSCAPE_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_REVOCATION_URL
, NULL
},
1063 { 6, szOID_NETSCAPE_CA_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_REVOCATION_URL
, NULL
},
1064 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_RENEWAL_URL
, NULL
},
1065 { 6, szOID_NETSCAPE_CA_POLICY_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_POLICY_URL
, NULL
},
1066 { 6, szOID_NETSCAPE_SSL_SERVER_NAME
, 0, (LPCWSTR
)IDS_NETSCAPE_SSL_SERVER_NAME
, NULL
},
1067 { 6, szOID_NETSCAPE_COMMENT
, 0, (LPCWSTR
)IDS_NETSCAPE_COMMENT
, NULL
},
1068 { 6, "1.3.6.1.4.1.311.2.1.10", 0, (LPCWSTR
)IDS_SPC_SP_AGENCY_INFO
, NULL
},
1069 { 6, "1.3.6.1.4.1.311.2.1.27", 0, (LPCWSTR
)IDS_SPC_FINANCIAL_CRITERIA
, NULL
},
1070 { 6, "1.3.6.1.4.1.311.2.1.26", 0, (LPCWSTR
)IDS_SPC_MINIMAL_CRITERIA
, NULL
},
1071 { 6, szOID_COUNTRY_NAME
, 0, (LPCWSTR
)IDS_COUNTRY
, NULL
},
1072 { 6, szOID_ORGANIZATION_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATION
, NULL
},
1073 { 6, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATIONAL_UNIT
, NULL
},
1074 { 6, szOID_COMMON_NAME
, 0, (LPCWSTR
)IDS_COMMON_NAME
, NULL
},
1075 { 6, szOID_LOCALITY_NAME
, 0, (LPCWSTR
)IDS_LOCALITY
, NULL
},
1076 { 6, szOID_STATE_OR_PROVINCE_NAME
, 0, (LPCWSTR
)IDS_STATE_OR_PROVINCE
, NULL
},
1077 { 6, szOID_TITLE
, 0, (LPCWSTR
)IDS_TITLE
, NULL
},
1078 { 6, szOID_GIVEN_NAME
, 0, (LPCWSTR
)IDS_GIVEN_NAME
, NULL
},
1079 { 6, szOID_INITIALS
, 0, (LPCWSTR
)IDS_INITIALS
, NULL
},
1080 { 6, szOID_SUR_NAME
, 0, (LPCWSTR
)IDS_SUR_NAME
, NULL
},
1081 { 6, szOID_DOMAIN_COMPONENT
, 0, (LPCWSTR
)IDS_DOMAIN_COMPONENT
, NULL
},
1082 { 6, szOID_STREET_ADDRESS
, 0, (LPCWSTR
)IDS_STREET_ADDRESS
, NULL
},
1083 { 6, szOID_DEVICE_SERIAL_NUMBER
, 0, (LPCWSTR
)IDS_SERIAL_NUMBER
, NULL
},
1084 { 6, szOID_CERTSRV_CA_VERSION
, 0, (LPCWSTR
)IDS_CA_VERSION
, NULL
},
1085 { 6, szOID_CERTSRV_CROSSCA_VERSION
, 0, (LPCWSTR
)IDS_CROSS_CA_VERSION
, NULL
},
1086 { 6, szOID_SERIALIZED
, 0, (LPCWSTR
)IDS_SERIALIZED_SIG_SERIAL_NUMBER
, NULL
},
1087 { 6, szOID_NT_PRINCIPAL_NAME
, 0, (LPCWSTR
)IDS_PRINCIPAL_NAME
, NULL
},
1088 { 6, szOID_PRODUCT_UPDATE
, 0, (LPCWSTR
)IDS_WINDOWS_PRODUCT_UPDATE
, NULL
},
1089 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR
, 0, (LPCWSTR
)IDS_ENROLLMENT_NAME_VALUE_PAIR
, NULL
},
1090 { 6, szOID_OS_VERSION
, 0, (LPCWSTR
)IDS_OS_VERSION
, NULL
},
1091 { 6, szOID_ENROLLMENT_CSP_PROVIDER
, 0, (LPCWSTR
)IDS_ENROLLMENT_CSP
, NULL
},
1092 { 6, szOID_CRL_NUMBER
, 0, (LPCWSTR
)IDS_CRL_NUMBER
, NULL
},
1093 { 6, szOID_DELTA_CRL_INDICATOR
, 0, (LPCWSTR
)IDS_DELTA_CRL_INDICATOR
, NULL
},
1094 { 6, szOID_ISSUING_DIST_POINT
, 0, (LPCWSTR
)IDS_ISSUING_DIST_POINT
, NULL
},
1095 { 6, szOID_FRESHEST_CRL
, 0, (LPCWSTR
)IDS_FRESHEST_CRL
, NULL
},
1096 { 6, szOID_NAME_CONSTRAINTS
, 0, (LPCWSTR
)IDS_NAME_CONSTRAINTS
, NULL
},
1097 { 6, szOID_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1098 { 6, szOID_LEGACY_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
1099 { 6, szOID_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_POLICY_CONSTRAINTS
, NULL
},
1100 { 6, szOID_CROSS_CERT_DIST_POINTS
, 0, (LPCWSTR
)IDS_CROSS_CERT_DIST_POINTS
, NULL
},
1101 { 6, szOID_APPLICATION_CERT_POLICIES
, 0, (LPCWSTR
)IDS_APPLICATION_POLICIES
, NULL
},
1102 { 6, szOID_APPLICATION_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_MAPPINGS
, NULL
},
1103 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_CONSTRAINTS
, NULL
},
1104 { 6, szOID_CT_PKI_DATA
, 0, (LPCWSTR
)IDS_CMC_DATA
, NULL
},
1105 { 6, szOID_CT_PKI_RESPONSE
, 0, (LPCWSTR
)IDS_CMC_RESPONSE
, NULL
},
1106 { 6, szOID_CMC
, 0, (LPCWSTR
)IDS_UNSIGNED_CMC_REQUEST
, NULL
},
1107 { 6, szOID_CMC_STATUS_INFO
, 0, (LPCWSTR
)IDS_CMC_STATUS_INFO
, NULL
},
1108 { 6, szOID_CMC_ADD_EXTENSIONS
, 0, (LPCWSTR
)IDS_CMC_EXTENSIONS
, NULL
},
1109 { 6, szOID_CTL
, 0, (LPCWSTR
)IDS_CMC_ATTRIBUTES
, NULL
},
1110 { 6, szOID_RSA_data
, 0, (LPCWSTR
)IDS_PKCS_7_DATA
, NULL
},
1111 { 6, szOID_RSA_signedData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED
, NULL
},
1112 { 6, szOID_RSA_envelopedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENVELOPED
, NULL
},
1113 { 6, szOID_RSA_signEnvData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED_ENVELOPED
, NULL
},
1114 { 6, szOID_RSA_digestedData
, 0, (LPCWSTR
)IDS_PKCS_7_DIGESTED
, NULL
},
1115 { 6, szOID_RSA_encryptedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENCRYPTED
, NULL
},
1116 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH
, 0, (LPCWSTR
)IDS_PREVIOUS_CA_CERT_HASH
, NULL
},
1117 { 6, szOID_CRL_VIRTUAL_BASE
, 0, (LPCWSTR
)IDS_CRL_VIRTUAL_BASE
, NULL
},
1118 { 6, szOID_CRL_NEXT_PUBLISH
, 0, (LPCWSTR
)IDS_CRL_NEXT_PUBLISH
, NULL
},
1119 { 6, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1120 { 6, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1121 { 6, szOID_CERTIFICATE_TEMPLATE
, 0, (LPCWSTR
)IDS_CERTIFICATE_TEMPLATE
, NULL
},
1122 { 6, szOID_ENTERPRISE_OID_ROOT
, 0, (LPCWSTR
)IDS_ENTERPRISE_ROOT_OID
, NULL
},
1123 { 6, szOID_RDN_DUMMY_SIGNER
, 0, (LPCWSTR
)IDS_RDN_DUMMY_SIGNER
, NULL
},
1124 { 6, szOID_ARCHIVED_KEY_ATTR
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_ATTR
, NULL
},
1125 { 6, szOID_CRL_SELF_CDP
, 0, (LPCWSTR
)IDS_CRL_SELF_CDP
, NULL
},
1126 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY
, 0, (LPCWSTR
)IDS_REQUIRE_CERT_CHAIN_POLICY
, NULL
},
1127 { 6, szOID_CMC_TRANSACTION_ID
, 0, (LPCWSTR
)IDS_TRANSACTION_ID
, NULL
},
1128 { 6, szOID_CMC_SENDER_NONCE
, 0, (LPCWSTR
)IDS_SENDER_NONCE
, NULL
},
1129 { 6, szOID_CMC_RECIPIENT_NONCE
, 0, (LPCWSTR
)IDS_RECIPIENT_NONCE
, NULL
},
1130 { 6, szOID_CMC_REG_INFO
, 0, (LPCWSTR
)IDS_REG_INFO
, NULL
},
1131 { 6, szOID_CMC_GET_CERT
, 0, (LPCWSTR
)IDS_GET_CERTIFICATE
, NULL
},
1132 { 6, szOID_CMC_GET_CRL
, 0, (LPCWSTR
)IDS_GET_CRL
, NULL
},
1133 { 6, szOID_CMC_REVOKE_REQUEST
, 0, (LPCWSTR
)IDS_REVOKE_REQUEST
, NULL
},
1134 { 6, szOID_CMC_QUERY_PENDING
, 0, (LPCWSTR
)IDS_QUERY_PENDING
, NULL
},
1135 { 6, szOID_SORTED_CTL
, 0, (LPCWSTR
)IDS_SORTED_CTL
, NULL
},
1136 { 6, szOID_ARCHIVED_KEY_CERT_HASH
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_CERT_HASH
, NULL
},
1137 { 6, szOID_PRIVATEKEY_USAGE_PERIOD
, 0, (LPCWSTR
)IDS_PRIVATE_KEY_USAGE_PERIOD
, NULL
},
1138 { 6, szOID_REQUEST_CLIENT_INFO
, 0, (LPCWSTR
)IDS_CLIENT_INFORMATION
, NULL
},
1140 { 7, szOID_PKIX_KP_SERVER_AUTH
, 0, (LPCWSTR
)IDS_SERVER_AUTHENTICATION
, NULL
},
1141 { 7, szOID_PKIX_KP_CLIENT_AUTH
, 0, (LPCWSTR
)IDS_CLIENT_AUTHENTICATION
, NULL
},
1142 { 7, szOID_PKIX_KP_CODE_SIGNING
, 0, (LPCWSTR
)IDS_CODE_SIGNING
, NULL
},
1143 { 7, szOID_PKIX_KP_EMAIL_PROTECTION
, 0, (LPCWSTR
)IDS_SECURE_EMAIL
, NULL
},
1144 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING
, 0, (LPCWSTR
)IDS_TIME_STAMPING
, NULL
},
1145 { 7, szOID_KP_CTL_USAGE_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TRUST_LIST_SIGNING
, NULL
},
1146 { 7, szOID_KP_TIME_STAMP_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TIME_STAMPING
, NULL
},
1147 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM
, 0, (LPCWSTR
)IDS_IPSEC_END_SYSTEM
, NULL
},
1148 { 7, szOID_PKIX_KP_IPSEC_TUNNEL
, 0, (LPCWSTR
)IDS_IPSEC_TUNNEL
, NULL
},
1149 { 7, szOID_PKIX_KP_IPSEC_USER
, 0, (LPCWSTR
)IDS_IPSEC_USER
, NULL
},
1150 { 7, szOID_KP_EFS
, 0, (LPCWSTR
)IDS_EFS
, NULL
},
1151 { 7, szOID_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_WHQL_CRYPTO
, NULL
},
1152 { 7, szOID_NT5_CRYPTO
, 0, (LPCWSTR
)IDS_NT5_CRYPTO
, NULL
},
1153 { 7, szOID_OEM_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_OEM_WHQL_CRYPTO
, NULL
},
1154 { 7, szOID_EMBEDDED_NT_CRYPTO
, 0, (LPCWSTR
)IDS_EMBEDDED_NT_CRYPTO
, NULL
},
1155 { 7, szOID_LICENSES
, 0, (LPCWSTR
)IDS_KEY_PACK_LICENSES
, NULL
},
1156 { 7, szOID_LICENSE_SERVER
, 0, (LPCWSTR
)IDS_LICENSE_SERVER
, NULL
},
1157 { 7, szOID_KP_SMARTCARD_LOGON
, 0, (LPCWSTR
)IDS_SMART_CARD_LOGON
, NULL
},
1158 { 7, szOID_DRM
, 0, (LPCWSTR
)IDS_DIGITAL_RIGHTS
, NULL
},
1159 { 7, szOID_KP_QUALIFIED_SUBORDINATION
, 0, (LPCWSTR
)IDS_QUALIFIED_SUBORDINATION
, NULL
},
1160 { 7, szOID_KP_KEY_RECOVERY
, 0, (LPCWSTR
)IDS_KEY_RECOVERY
, NULL
},
1161 { 7, szOID_KP_DOCUMENT_SIGNING
, 0, (LPCWSTR
)IDS_DOCUMENT_SIGNING
, NULL
},
1162 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE
, 0, (LPCWSTR
)IDS_IPSEC_IKE_INTERMEDIATE
, NULL
},
1163 { 7, szOID_EFS_RECOVERY
, 0, (LPCWSTR
)IDS_FILE_RECOVERY
, NULL
},
1164 { 7, szOID_ROOT_LIST_SIGNER
, 0, (LPCWSTR
)IDS_ROOT_LIST_SIGNER
, NULL
},
1165 { 7, szOID_ANY_APPLICATION_POLICY
, 0, (LPCWSTR
)IDS_ANY_APPLICATION_POLICIES
, NULL
},
1166 { 7, szOID_DS_EMAIL_REPLICATION
, 0, (LPCWSTR
)IDS_DS_EMAIL_REPLICATION
, NULL
},
1167 { 7, szOID_ENROLLMENT_AGENT
, 0, (LPCWSTR
)IDS_ENROLLMENT_AGENT
, NULL
},
1168 { 7, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
1169 { 7, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
1170 { 7, szOID_KP_LIFETIME_SIGNING
, 0, (LPCWSTR
)IDS_LIFETIME_SIGNING
, NULL
},
1172 { 8, szOID_ANY_CERT_POLICY
, 0, (LPCWSTR
)IDS_ANY_CERT_POLICY
, NULL
},
1176 CRYPT_OID_INFO info
;
1180 static void init_oid_info(HINSTANCE hinst
)
1184 InitializeCriticalSection(&oidInfoCS
);
1185 oidInfoCS
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": oidInfoCS");
1186 list_init(&oidInfo
);
1187 for (i
= 0; i
< sizeof(oidInfoConstructors
) /
1188 sizeof(oidInfoConstructors
[0]); i
++)
1190 if (HIWORD(oidInfoConstructors
[i
].pwszName
))
1192 struct OIDInfo
*info
;
1194 /* The name is a static string, so just use the same pointer */
1195 info
= CryptMemAlloc(sizeof(struct OIDInfo
));
1198 memset(info
, 0, sizeof(*info
));
1199 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1200 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1201 info
->info
.pwszName
= oidInfoConstructors
[i
].pwszName
;
1202 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1203 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1204 if (oidInfoConstructors
[i
].blob
)
1206 info
->info
.ExtraInfo
.cbData
=
1207 oidInfoConstructors
[i
].blob
->cbData
;
1208 info
->info
.ExtraInfo
.pbData
=
1209 oidInfoConstructors
[i
].blob
->pbData
;
1211 list_add_tail(&oidInfo
, &info
->entry
);
1216 int len
= LoadStringW(hinst
, (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1221 struct OIDInfo
*info
= CryptMemAlloc(sizeof(struct OIDInfo
) +
1222 (len
+ 1) * sizeof(WCHAR
));
1226 memset(info
, 0, sizeof(*info
));
1227 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
1228 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
1229 info
->info
.pwszName
=
1230 (LPWSTR
)((LPBYTE
)info
+ sizeof(struct OIDInfo
));
1231 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
1232 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
1233 LoadStringW(hinst
, (UINT_PTR
)oidInfoConstructors
[i
].pwszName
,
1234 (LPWSTR
)info
->info
.pwszName
, len
+ 1);
1235 if (oidInfoConstructors
[i
].blob
)
1237 info
->info
.ExtraInfo
.cbData
=
1238 oidInfoConstructors
[i
].blob
->cbData
;
1239 info
->info
.ExtraInfo
.pbData
=
1240 oidInfoConstructors
[i
].blob
->pbData
;
1242 list_add_tail(&oidInfo
, &info
->entry
);
1249 static void free_oid_info(void)
1251 struct OIDInfo
*info
, *next
;
1253 LIST_FOR_EACH_ENTRY_SAFE(info
, next
, &oidInfo
, struct OIDInfo
, entry
)
1255 list_remove(&info
->entry
);
1258 oidInfoCS
.DebugInfo
->Spare
[0] = 0;
1259 DeleteCriticalSection(&oidInfoCS
);
1262 /***********************************************************************
1263 * CryptEnumOIDInfo (CRYPT32.@)
1265 BOOL WINAPI
CryptEnumOIDInfo(DWORD dwGroupId
, DWORD dwFlags
, void *pvArg
,
1266 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo
)
1269 struct OIDInfo
*info
;
1271 TRACE("(%d, %08x, %p, %p)\n", dwGroupId
, dwFlags
, pvArg
,
1274 EnterCriticalSection(&oidInfoCS
);
1275 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1277 if (!dwGroupId
|| dwGroupId
== info
->info
.dwGroupId
)
1279 ret
= pfnEnumOIDInfo(&info
->info
, pvArg
);
1284 LeaveCriticalSection(&oidInfoCS
);
1288 PCCRYPT_OID_INFO WINAPI
CryptFindOIDInfo(DWORD dwKeyType
, void *pvKey
,
1291 PCCRYPT_OID_INFO ret
= NULL
;
1293 TRACE("(%d, %p, %d)\n", dwKeyType
, pvKey
, dwGroupId
);
1297 case CRYPT_OID_INFO_ALGID_KEY
:
1299 struct OIDInfo
*info
;
1301 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD
*)pvKey
);
1302 EnterCriticalSection(&oidInfoCS
);
1303 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1305 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1306 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1312 LeaveCriticalSection(&oidInfoCS
);
1315 case CRYPT_OID_INFO_NAME_KEY
:
1317 struct OIDInfo
*info
;
1319 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w((LPWSTR
)pvKey
));
1320 EnterCriticalSection(&oidInfoCS
);
1321 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1323 if (!lstrcmpW(info
->info
.pwszName
, (LPWSTR
)pvKey
) &&
1324 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1330 LeaveCriticalSection(&oidInfoCS
);
1333 case CRYPT_OID_INFO_OID_KEY
:
1335 struct OIDInfo
*info
;
1336 LPSTR oid
= (LPSTR
)pvKey
;
1338 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid
));
1339 EnterCriticalSection(&oidInfoCS
);
1340 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1342 if (!lstrcmpA(info
->info
.pszOID
, oid
) &&
1343 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1349 LeaveCriticalSection(&oidInfoCS
);
1352 case CRYPT_OID_INFO_SIGN_KEY
:
1354 struct OIDInfo
*info
;
1356 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD
*)pvKey
);
1357 EnterCriticalSection(&oidInfoCS
);
1358 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1360 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1361 info
->info
.ExtraInfo
.cbData
>= sizeof(DWORD
) &&
1362 *(DWORD
*)info
->info
.ExtraInfo
.pbData
==
1363 *(DWORD
*)((LPBYTE
)pvKey
+ sizeof(DWORD
)) &&
1364 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1370 LeaveCriticalSection(&oidInfoCS
);
1377 LPCSTR WINAPI
CertAlgIdToOID(DWORD dwAlgId
)
1380 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY
,
1390 DWORD WINAPI
CertOIDToAlgId(LPCSTR pszObjId
)
1393 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY
,
1394 (void *)pszObjId
, 0);
1397 ret
= info
->u
.Algid
;