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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #define NONAMELESSUNION
28 #include "wine/debug.h"
29 #include "wine/list.h"
30 #include "crypt32_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
35 static const WCHAR DllW
[] = { 'D','l','l',0 };
37 static void init_function_sets(void);
38 static void init_oid_info(HINSTANCE hinst
);
39 static void free_function_sets(void);
40 static void free_oid_info(void);
42 void crypt_oid_init(HINSTANCE hinst
)
48 void crypt_oid_free(void)
54 CRITICAL_SECTION funcSetCS
;
60 CRITICAL_SECTION cs
; /* protects functions */
61 struct list functions
;
68 CRYPT_OID_FUNC_ENTRY entry
;
72 static void init_function_sets(void)
74 InitializeCriticalSection(&funcSetCS
);
78 static void free_function_sets(void)
80 struct OIDFunctionSet
*setCursor
, *setNext
;
82 LIST_FOR_EACH_ENTRY_SAFE(setCursor
, setNext
, &funcSets
,
83 struct OIDFunctionSet
, next
)
85 struct OIDFunction
*functionCursor
, *funcNext
;
87 list_remove(&setCursor
->next
);
88 CryptMemFree(setCursor
->name
);
89 LIST_FOR_EACH_ENTRY_SAFE(functionCursor
, funcNext
,
90 &setCursor
->functions
, struct OIDFunction
, next
)
92 list_remove(&functionCursor
->next
);
93 CryptMemFree(functionCursor
);
95 DeleteCriticalSection(&setCursor
->cs
);
96 CryptMemFree(setCursor
);
98 DeleteCriticalSection(&funcSetCS
);
101 /* There is no free function associated with this; therefore, the sets are
102 * freed when crypt32.dll is unloaded.
104 HCRYPTOIDFUNCSET WINAPI
CryptInitOIDFunctionSet(LPCSTR pszFuncName
,
107 struct OIDFunctionSet
*cursor
, *ret
= NULL
;
109 TRACE("(%s, %lx)\n", debugstr_a(pszFuncName
), dwFlags
);
111 EnterCriticalSection(&funcSetCS
);
112 LIST_FOR_EACH_ENTRY(cursor
, &funcSets
, struct OIDFunctionSet
, next
)
114 if (!strcasecmp(pszFuncName
, cursor
->name
))
116 ret
= (HCRYPTOIDFUNCSET
)cursor
;
122 ret
= CryptMemAlloc(sizeof(struct OIDFunctionSet
));
125 memset(ret
, 0, sizeof(*ret
));
126 ret
->name
= CryptMemAlloc(strlen(pszFuncName
) + 1);
129 InitializeCriticalSection(&ret
->cs
);
130 list_init(&ret
->functions
);
131 strcpy(ret
->name
, pszFuncName
);
132 list_add_tail(&funcSets
, &ret
->next
);
141 LeaveCriticalSection(&funcSetCS
);
143 return (HCRYPTOIDFUNCSET
)ret
;
146 static char *CRYPT_GetKeyName(DWORD dwEncodingType
, LPCSTR pszFuncName
,
149 static const char szEncodingTypeFmt
[] =
150 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %ld\\%s\\%s";
152 char numericOID
[7]; /* enough for "#65535" */
156 /* MSDN says the encoding type is a mask, but it isn't treated that way.
157 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
158 * "EncodingType 2" would be expected if it were a mask. Instead native
159 * stores values in "EncodingType 3".
163 snprintf(numericOID
, sizeof(numericOID
), "#%d", LOWORD(pszOID
));
169 /* This is enough: the lengths of the two string parameters are explicitly
170 * counted, and we need up to five additional characters for the encoding
171 * type. These are covered by the "%d", "%s", and "%s" characters in the
172 * format specifier that are removed by sprintf.
174 len
= sizeof(szEncodingTypeFmt
) + lstrlenA(pszFuncName
) + lstrlenA(oid
);
175 szKey
= CryptMemAlloc(len
);
177 sprintf(szKey
, szEncodingTypeFmt
, dwEncodingType
, pszFuncName
, oid
);
181 BOOL WINAPI
CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet
,
182 DWORD dwEncodingType
, LPWSTR pwszDllList
, DWORD
*pcchDllList
)
185 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
190 TRACE("(%p, %ld, %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 */
218 CryptMemFree(keyName
);
223 BOOL WINAPI
CryptInstallOIDFunctionAddress(HMODULE hModule
,
224 DWORD dwEncodingType
, LPCSTR pszFuncName
, DWORD cFuncEntry
,
225 const CRYPT_OID_FUNC_ENTRY rgFuncEntry
[], DWORD dwFlags
)
228 struct OIDFunctionSet
*set
;
230 TRACE("(%p, %ld, %s, %ld, %p, %08lx)\n", hModule
, dwEncodingType
,
231 debugstr_a(pszFuncName
), cFuncEntry
, rgFuncEntry
, dwFlags
);
233 set
= (struct OIDFunctionSet
*)CryptInitOIDFunctionSet(pszFuncName
, 0);
238 EnterCriticalSection(&set
->cs
);
239 for (i
= 0; ret
&& i
< cFuncEntry
; i
++)
241 struct OIDFunction
*func
;
243 if (HIWORD(rgFuncEntry
[i
].pszOID
))
244 func
= CryptMemAlloc(sizeof(struct OIDFunction
)
245 + strlen(rgFuncEntry
[i
].pszOID
) + 1);
247 func
= CryptMemAlloc(sizeof(struct OIDFunction
));
250 func
->encoding
= dwEncodingType
;
251 if (HIWORD(rgFuncEntry
[i
].pszOID
))
253 func
->entry
.pszOID
= (LPSTR
)((LPBYTE
)func
+ sizeof(*func
));
254 strcpy((LPSTR
)func
->entry
.pszOID
, rgFuncEntry
[i
].pszOID
);
257 func
->entry
.pszOID
= rgFuncEntry
[i
].pszOID
;
258 func
->entry
.pvFuncAddr
= rgFuncEntry
[i
].pvFuncAddr
;
259 list_add_tail(&set
->functions
, &func
->next
);
264 LeaveCriticalSection(&set
->cs
);
271 static BOOL
CRYPT_GetFuncFromReg(DWORD dwEncodingType
, LPCSTR pszOID
,
272 LPCSTR szFuncName
, LPVOID
*ppvFuncAddr
, HCRYPTOIDFUNCADDR
*phFuncAddr
)
276 const char *funcName
;
280 keyName
= CRYPT_GetKeyName(dwEncodingType
, szFuncName
, pszOID
);
281 rc
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
, keyName
, 0, KEY_READ
, &key
);
284 DWORD type
, size
= 0;
286 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
, NULL
, &size
);
287 if (rc
== ERROR_MORE_DATA
&& type
== REG_SZ
)
289 funcName
= CryptMemAlloc(size
);
290 rc
= RegQueryValueExA(key
, "FuncName", NULL
, &type
,
291 (LPBYTE
)funcName
, &size
);
294 funcName
= szFuncName
;
295 rc
= RegQueryValueExW(key
, DllW
, NULL
, &type
, NULL
, &size
);
296 if (rc
== ERROR_MORE_DATA
&& type
== REG_SZ
)
298 LPWSTR dllName
= CryptMemAlloc(size
);
302 rc
= RegQueryValueExW(key
, DllW
, NULL
, NULL
,
303 (LPBYTE
)dllName
, &size
);
308 /* This is a bit of a hack; MSDN describes a more
309 * complicated unload routine than this will allow.
310 * Still, this seems to suffice for now.
312 lib
= LoadLibraryW(dllName
);
315 *ppvFuncAddr
= GetProcAddress(lib
, szFuncName
);
318 *phFuncAddr
= (HCRYPTOIDFUNCADDR
)lib
;
323 /* Unload the library, the caller doesn't want
324 * to unload it when the return value is NULL.
332 CryptMemFree(dllName
);
337 if (funcName
!= szFuncName
)
338 CryptMemFree((char *)funcName
);
343 CryptMemFree(keyName
);
347 BOOL WINAPI
CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
348 DWORD dwEncodingType
, LPCSTR pszOID
, DWORD dwFlags
, void **ppvFuncAddr
,
349 HCRYPTOIDFUNCADDR
*phFuncAddr
)
352 struct OIDFunctionSet
*set
= (struct OIDFunctionSet
*)hFuncSet
;
354 TRACE("(%p, %ld, %s, %08lx, %p, %p)\n", hFuncSet
, dwEncodingType
,
355 debugstr_a(pszOID
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
358 if (!(dwFlags
& CRYPT_GET_INSTALLED_OID_FUNC_FLAG
))
360 struct OIDFunction
*function
;
362 EnterCriticalSection(&set
->cs
);
363 LIST_FOR_EACH_ENTRY(function
, &set
->functions
, struct OIDFunction
, next
)
365 if (function
->encoding
== dwEncodingType
)
369 if (HIWORD(function
->entry
.pszOID
&&
370 !strcasecmp(function
->entry
.pszOID
, pszOID
)))
372 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
373 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
378 else if (function
->entry
.pszOID
== pszOID
)
380 *ppvFuncAddr
= function
->entry
.pvFuncAddr
;
381 *phFuncAddr
= NULL
; /* FIXME: what should it be? */
387 LeaveCriticalSection(&set
->cs
);
390 ret
= CRYPT_GetFuncFromReg(dwEncodingType
, pszOID
, set
->name
,
391 ppvFuncAddr
, phFuncAddr
);
395 BOOL WINAPI
CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr
,
398 TRACE("(%p, %08lx)\n", hFuncAddr
, dwFlags
);
400 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
401 * and only unload it if it can be unloaded. Also need to implement ref
402 * counting on the functions.
404 FreeLibrary((HMODULE
)hFuncAddr
);
408 BOOL WINAPI
CryptRegisterDefaultOIDFunction(DWORD dwEncodingType
,
409 LPCSTR pszFuncName
, DWORD dwIndex
, LPCWSTR pwszDll
)
411 FIXME("(%lx,%s,%lx,%s) stub!\n", dwEncodingType
, pszFuncName
, dwIndex
,
412 debugstr_w(pwszDll
));
416 BOOL WINAPI
CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType
,
417 LPCSTR pszFuncName
, LPCWSTR pwszDll
)
419 FIXME("(%lx %s %s): stub\n", dwEncodingType
, debugstr_a(pszFuncName
),
420 debugstr_w(pwszDll
));
424 BOOL WINAPI
CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet
,
425 DWORD dwEncodingType
, LPCWSTR pwszDll
, DWORD dwFlags
, void *ppvFuncAddr
,
426 HCRYPTOIDFUNCADDR
*phFuncAddr
)
428 FIXME("(%p, %ld, %s, %08lx, %p, %p): stub\n", hFuncSet
, dwEncodingType
,
429 debugstr_w(pwszDll
), dwFlags
, ppvFuncAddr
, phFuncAddr
);
433 BOOL WINAPI
CryptRegisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
434 LPCSTR pszOID
, LPCWSTR pwszDll
, LPCSTR pszOverrideFuncName
)
440 TRACE("(%lx, %s, %s, %s, %s)\n", dwEncodingType
, pszFuncName
, pszOID
,
441 debugstr_w(pwszDll
), pszOverrideFuncName
);
443 /* This only registers functions for encoding certs, not messages */
444 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
447 /* Native does nothing pwszDll is NULL */
451 /* I'm not matching MS bug for bug here, because I doubt any app depends on
452 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry
453 * it creates would never be used.
455 if (!pszFuncName
|| !pszOID
)
457 SetLastError(HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER
));
461 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
462 TRACE("Key name is %s\n", debugstr_a(szKey
));
467 r
= RegCreateKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
469 if(r
!= ERROR_SUCCESS
)
472 /* write the values */
473 if (pszOverrideFuncName
)
474 RegSetValueExA(hKey
, "FuncName", 0, REG_SZ
,
475 (const BYTE
*)pszOverrideFuncName
, lstrlenA(pszOverrideFuncName
) + 1);
476 RegSetValueExW(hKey
, DllW
, 0, REG_SZ
, (const BYTE
*) pwszDll
,
477 (lstrlenW(pwszDll
) + 1) * sizeof (WCHAR
));
483 BOOL WINAPI
CryptUnregisterOIDFunction(DWORD dwEncodingType
, LPCSTR pszFuncName
,
489 TRACE("%lx %s %s\n", dwEncodingType
, pszFuncName
, pszOID
);
491 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
494 if (!pszFuncName
|| !pszOID
)
496 SetLastError(ERROR_INVALID_PARAMETER
);
500 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
501 rc
= RegDeleteKeyA(HKEY_LOCAL_MACHINE
, szKey
);
505 return rc
? FALSE
: TRUE
;
508 BOOL WINAPI
CryptGetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
509 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD
*pdwValueType
, BYTE
*pbValueData
,
516 TRACE("%lx %s %s %s %p %p %p\n", dwEncodingType
, debugstr_a(pszFuncName
),
517 debugstr_a(pszOID
), debugstr_w(pwszValueName
), pdwValueType
, pbValueData
,
520 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
523 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
525 SetLastError(ERROR_INVALID_PARAMETER
);
529 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
530 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
536 rc
= RegQueryValueExW(hKey
, pwszValueName
, NULL
, pdwValueType
,
537 pbValueData
, pcbValueData
);
542 return rc
? FALSE
: TRUE
;
545 BOOL WINAPI
CryptSetOIDFunctionValue(DWORD dwEncodingType
, LPCSTR pszFuncName
,
546 LPCSTR pszOID
, LPCWSTR pwszValueName
, DWORD dwValueType
,
547 const BYTE
*pbValueData
, DWORD cbValueData
)
553 TRACE("%lx %s %s %s %ld %p %ld\n", dwEncodingType
, debugstr_a(pszFuncName
),
554 debugstr_a(pszOID
), debugstr_w(pwszValueName
), dwValueType
, pbValueData
,
557 if (!GET_CERT_ENCODING_TYPE(dwEncodingType
))
560 if (!pszFuncName
|| !pszOID
|| !pwszValueName
)
562 SetLastError(ERROR_INVALID_PARAMETER
);
566 szKey
= CRYPT_GetKeyName(dwEncodingType
, pszFuncName
, pszOID
);
567 rc
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, szKey
, &hKey
);
573 rc
= RegSetValueExW(hKey
, pwszValueName
, 0, dwValueType
, pbValueData
,
579 return rc
? FALSE
: TRUE
;
582 CRITICAL_SECTION oidInfoCS
;
585 static const WCHAR tripledes
[] = { '3','d','e','s',0 };
586 static const WCHAR cms3deswrap
[] = { 'C','M','S','3','D','E','S','w','r','a',
588 static const WCHAR cmsrc2wrap
[] = { 'C','M','S','R','C','2','w','r','a','p',0 };
589 static const WCHAR des
[] = { 'd','e','s',0 };
590 static const WCHAR md2
[] = { 'm','d','2',0 };
591 static const WCHAR md4
[] = { 'm','d','4',0 };
592 static const WCHAR md5
[] = { 'm','d','5',0 };
593 static const WCHAR rc2
[] = { 'r','c','2',0 };
594 static const WCHAR rc4
[] = { 'r','c','4',0 };
595 static const WCHAR sha
[] = { 's','h','a',0 };
596 static const WCHAR sha1
[] = { 's','h','a','1',0 };
597 static const WCHAR RSA
[] = { 'R','S','A',0 };
598 static const WCHAR RSA_KEYX
[] = { 'R','S','A','_','K','E','Y','X',0 };
599 static const WCHAR RSA_SIGN
[] = { 'R','S','A','_','S','I','G','N',0 };
600 static const WCHAR DSA
[] = { 'D','S','A',0 };
601 static const WCHAR DSA_SIGN
[] = { 'D','S','A','_','S','I','G','N',0 };
602 static const WCHAR DH
[] = { 'D','H',0 };
603 static const WCHAR DSS
[] = { 'D','S','S',0 };
604 static const WCHAR mosaicKMandUpdSig
[] =
605 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 };
606 static const WCHAR ESDH
[] = { 'E','S','D','H',0 };
607 static const WCHAR NO_SIGN
[] = { 'N','O','S','I','G','N',0 };
608 static const WCHAR dsaSHA1
[] = { 'd','s','a','S','H','A','1',0 };
609 static const WCHAR md2RSA
[] = { 'm','d','2','R','S','A',0 };
610 static const WCHAR md4RSA
[] = { 'm','d','4','R','S','A',0 };
611 static const WCHAR md5RSA
[] = { 'm','d','5','R','S','A',0 };
612 static const WCHAR shaDSA
[] = { 's','h','a','D','S','A',0 };
613 static const WCHAR sha1DSA
[] = { 's','h','a','1','D','S','A',0 };
614 static const WCHAR shaRSA
[] = { 's','h','a','R','S','A',0 };
615 static const WCHAR sha1RSA
[] = { 's','h','a','1','R','S','A',0 };
616 static const WCHAR mosaicUpdatedSig
[] =
617 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 };
618 static const WCHAR CN
[] = { 'C','N',0 };
619 static const WCHAR L
[] = { 'L',0 };
620 static const WCHAR O
[] = { 'O',0 };
621 static const WCHAR OU
[] = { 'O','U',0 };
622 static const WCHAR E
[] = { 'E',0 };
623 static const WCHAR C
[] = { 'C',0 };
624 static const WCHAR S
[] = { 'S',0 };
625 static const WCHAR ST
[] = { 'S','T',0 };
626 static const WCHAR STREET
[] = { 'S','T','R','E','E','T',0 };
627 static const WCHAR T
[] = { 'T',0 };
628 static const WCHAR Title
[] = { 'T','i','t','l','e',0 };
629 static const WCHAR G
[] = { 'G',0 };
630 static const WCHAR GivenName
[] = { 'G','i','v','e','n','N','a','m','e',0 };
631 static const WCHAR I
[] = { 'I',0 };
632 static const WCHAR Initials
[] = { 'I','n','i','t','i','a','l','s',0 };
633 static const WCHAR SN
[] = { 'S','N',0 };
634 static const WCHAR DC
[] = { 'D','C',0 };
635 static const WCHAR Description
[] =
636 { 'D','e','s','c','r','i','p','t','i','o','n',0 };
637 static const WCHAR PostalCode
[] = { 'P','o','s','t','a','l','C','o','d','e',0 };
638 static const WCHAR POBox
[] = { 'P','O','B','o','x',0 };
639 static const WCHAR Phone
[] = { 'P','h','o','n','e',0 };
640 static const WCHAR X21Address
[] = { 'X','2','1','A','d','d','r','e','s','s',0 };
641 static const WCHAR dnQualifier
[] =
642 { 'd','n','Q','u','a','l','i','f','i','e','r',0 };
643 static const WCHAR Email
[] = { 'E','m','a','i','l',0 };
644 static const WCHAR GN
[] = { 'G','N',0 };
646 static const DWORD noNullFlag
= CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
647 static const DWORD mosaicFlags
= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
648 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
;
649 static const CRYPT_DATA_BLOB noNullBlob
= { sizeof(noNullFlag
),
650 (LPBYTE
)&noNullFlag
};
651 static const CRYPT_DATA_BLOB mosaicFlagsBlob
= { sizeof(mosaicFlags
),
652 (LPBYTE
)&mosaicFlags
};
654 static const DWORD rsaSign
= CALG_RSA_SIGN
;
655 static const DWORD dssSign
[2] = { CALG_DSS_SIGN
,
656 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
657 static const DWORD mosaicSign
[2] = { CALG_DSS_SIGN
,
658 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG
|
659 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
};
660 static const CRYPT_DATA_BLOB rsaSignBlob
= { sizeof(rsaSign
),
662 static const CRYPT_DATA_BLOB dssSignBlob
= { sizeof(dssSign
),
664 static const CRYPT_DATA_BLOB mosaicSignBlob
= { sizeof(mosaicSign
),
665 (LPBYTE
)mosaicSign
};
667 static const DWORD ia5String
[] = { CERT_RDN_IA5_STRING
, 0 };
668 static const DWORD numericString
[] = { CERT_RDN_NUMERIC_STRING
, 0 };
669 static const DWORD printableString
[] = { CERT_RDN_PRINTABLE_STRING
, 0 };
670 static const DWORD domainCompTypes
[] = { CERT_RDN_IA5_STRING
,
671 CERT_RDN_UTF8_STRING
, 0 };
672 static const CRYPT_DATA_BLOB ia5StringBlob
= { sizeof(ia5String
),
674 static const CRYPT_DATA_BLOB numericStringBlob
= { sizeof(numericString
),
675 (LPBYTE
)numericString
};
676 static const CRYPT_DATA_BLOB printableStringBlob
= { sizeof(printableString
),
677 (LPBYTE
)printableString
};
678 static const CRYPT_DATA_BLOB domainCompTypesBlob
= { sizeof(domainCompTypes
),
679 (LPBYTE
)domainCompTypes
};
681 struct OIDInfoConstructor
{
686 const CRYPT_DATA_BLOB
*blob
;
687 } oidInfoConstructors
[] = {
688 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha1
, NULL
},
689 { 1, szOID_OIWSEC_sha1
, CALG_SHA1
, sha
, NULL
},
690 { 1, szOID_OIWSEC_sha
, CALG_SHA
, sha
, NULL
},
691 { 1, szOID_RSA_MD5
, CALG_MD5
, md5
, NULL
},
692 { 1, szOID_RSA_MD4
, CALG_MD4
, md4
, NULL
},
693 { 1, szOID_RSA_MD2
, CALG_MD2
, md2
, NULL
},
695 { 2, szOID_OIWSEC_desCBC
, CALG_DES
, des
, NULL
},
696 { 2, szOID_RSA_DES_EDE3_CBC
, CALG_3DES
, tripledes
, NULL
},
697 { 2, szOID_RSA_RC2CBC
, CALG_RC2
, rc2
, NULL
},
698 { 2, szOID_RSA_RC4
, CALG_RC4
, rc4
, NULL
},
699 { 2, szOID_RSA_SMIMEalgCMS3DESwrap
, CALG_3DES
, cms3deswrap
, NULL
},
700 { 2, szOID_RSA_SMIMEalgCMSRC2wrap
, CALG_RC2
, cmsrc2wrap
, NULL
},
702 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA
, NULL
},
703 { 3, szOID_X957_DSA
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
704 { 3, szOID_ANSI_X942_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
705 { 3, szOID_RSA_RSA
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
706 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA
, NULL
},
707 { 3, szOID_RSA_RSA
, CALG_RSA_SIGN
, RSA_SIGN
, NULL
},
708 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA
, &noNullBlob
},
709 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSS
, &noNullBlob
},
710 { 3, szOID_OIWSEC_dsa
, CALG_DSS_SIGN
, DSA_SIGN
, &noNullBlob
},
711 { 3, szOID_RSA_DH
, CALG_DH_SF
, DH
, &noNullBlob
},
712 { 3, szOID_OIWSEC_rsaXchg
, CALG_RSA_KEYX
, RSA_KEYX
, NULL
},
713 { 3, szOID_INFOSEC_mosaicKMandUpdSig
, CALG_DSS_SIGN
, mosaicKMandUpdSig
,
715 { 3, szOID_RSA_SMIMEalgESDH
, CALG_DH_EPHEM
, ESDH
, &noNullBlob
},
716 { 3, szOID_PKIX_NO_SIGNATURE
, CALG_NO_SIGN
, NO_SIGN
, NULL
},
718 { 4, szOID_RSA_SHA1RSA
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
719 { 4, szOID_RSA_MD5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
720 { 4, szOID_X957_SHA1DSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
721 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, sha1RSA
, &rsaSignBlob
},
722 { 4, szOID_OIWSEC_sha1RSASign
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
723 { 4, szOID_OIWSEC_shaRSA
, CALG_SHA1
, shaRSA
, &rsaSignBlob
},
724 { 4, szOID_OIWSEC_md5RSA
, CALG_MD5
, md5RSA
, &rsaSignBlob
},
725 { 4, szOID_RSA_MD2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
726 { 4, szOID_RSA_MD4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
727 { 4, szOID_OIWSEC_md4RSA
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
728 { 4, szOID_OIWSEC_md4RSA2
, CALG_MD4
, md4RSA
, &rsaSignBlob
},
729 { 4, szOID_OIWDIR_md2RSA
, CALG_MD2
, md2RSA
, &rsaSignBlob
},
730 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, sha1DSA
, &dssSignBlob
},
731 { 4, szOID_OIWSEC_shaDSA
, CALG_SHA1
, shaDSA
, &dssSignBlob
},
732 { 4, szOID_OIWSEC_dsaSHA1
, CALG_SHA1
, dsaSHA1
, &dssSignBlob
},
733 { 4, szOID_INFOSEC_mosaicUpdatedSig
, CALG_SHA1
, mosaicUpdatedSig
,
736 { 5, szOID_COMMON_NAME
, 0, CN
, NULL
},
737 { 5, szOID_LOCALITY_NAME
, 0, L
, NULL
},
738 { 5, szOID_ORGANIZATION_NAME
, 0, O
, NULL
},
739 { 5, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, OU
, NULL
},
740 { 5, szOID_RSA_emailAddr
, 0, E
, &ia5StringBlob
},
741 { 5, szOID_RSA_emailAddr
, 0, Email
, &ia5StringBlob
},
742 { 5, szOID_COUNTRY_NAME
, 0, C
, &printableStringBlob
},
743 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, S
, NULL
},
744 { 5, szOID_STATE_OR_PROVINCE_NAME
, 0, ST
, NULL
},
745 { 5, szOID_STREET_ADDRESS
, 0, STREET
, NULL
},
746 { 5, szOID_TITLE
, 0, T
, NULL
},
747 { 5, szOID_TITLE
, 0, Title
, NULL
},
748 { 5, szOID_GIVEN_NAME
, 0, G
, NULL
},
749 { 5, szOID_GIVEN_NAME
, 0, GN
, NULL
},
750 { 5, szOID_GIVEN_NAME
, 0, GivenName
, NULL
},
751 { 5, szOID_INITIALS
, 0, I
, NULL
},
752 { 5, szOID_INITIALS
, 0, Initials
, NULL
},
753 { 5, szOID_SUR_NAME
, 0, SN
, NULL
},
754 { 5, szOID_DOMAIN_COMPONENT
, 0, DC
, &domainCompTypesBlob
},
755 { 5, szOID_DESCRIPTION
, 0, Description
, NULL
},
756 { 5, szOID_POSTAL_CODE
, 0, PostalCode
, NULL
},
757 { 5, szOID_POST_OFFICE_BOX
, 0, POBox
, NULL
},
758 { 5, szOID_TELEPHONE_NUMBER
, 0, Phone
, &printableStringBlob
},
759 { 5, szOID_X21_ADDRESS
, 0, X21Address
, &numericStringBlob
},
760 { 5, szOID_DN_QUALIFIER
, 0, dnQualifier
, NULL
},
762 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
763 { 6, szOID_AUTHORITY_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_AUTHORITY_KEY_ID
, NULL
},
764 { 6, szOID_KEY_ATTRIBUTES
, 0, (LPCWSTR
)IDS_KEY_ATTRIBUTES
, NULL
},
765 { 6, szOID_KEY_USAGE_RESTRICTION
, 0, (LPCWSTR
)IDS_KEY_USAGE_RESTRICTION
, NULL
},
766 { 6, szOID_SUBJECT_ALT_NAME2
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
767 { 6, szOID_SUBJECT_ALT_NAME
, 0, (LPCWSTR
)IDS_SUBJECT_ALT_NAME
, NULL
},
768 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
769 { 6, szOID_ISSUER_ALT_NAME2
, 0, (LPCWSTR
)IDS_ISSUER_ALT_NAME
, NULL
},
770 { 6, szOID_BASIC_CONSTRAINTS2
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
771 { 6, szOID_BASIC_CONSTRAINTS
, 0, (LPCWSTR
)IDS_BASIC_CONSTRAINTS
, NULL
},
772 { 6, szOID_KEY_USAGE
, 0, (LPCWSTR
)IDS_KEY_USAGE
, NULL
},
773 { 6, szOID_CERT_POLICIES
, 0, (LPCWSTR
)IDS_CERT_POLICIES
, NULL
},
774 { 6, szOID_SUBJECT_KEY_IDENTIFIER
, 0, (LPCWSTR
)IDS_SUBJECT_KEY_IDENTIFIER
, NULL
},
775 { 6, szOID_CRL_REASON_CODE
, 0, (LPCWSTR
)IDS_CRL_REASON_CODE
, NULL
},
776 { 6, szOID_CRL_DIST_POINTS
, 0, (LPCWSTR
)IDS_CRL_DIST_POINTS
, NULL
},
777 { 6, szOID_ENHANCED_KEY_USAGE
, 0, (LPCWSTR
)IDS_ENHANCED_KEY_USAGE
, NULL
},
778 { 6, szOID_AUTHORITY_INFO_ACCESS
, 0, (LPCWSTR
)IDS_AUTHORITY_INFO_ACCESS
, NULL
},
779 { 6, szOID_CERT_EXTENSIONS
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
780 { 6, szOID_RSA_certExtensions
, 0, (LPCWSTR
)IDS_CERT_EXTENSIONS
, NULL
},
781 { 6, szOID_NEXT_UPDATE_LOCATION
, 0, (LPCWSTR
)IDS_NEXT_UPDATE_LOCATION
, NULL
},
782 { 6, szOID_YESNO_TRUST_ATTR
, 0, (LPCWSTR
)IDS_YES_OR_NO_TRUST
, NULL
},
783 { 6, szOID_RSA_emailAddr
, 0, (LPCWSTR
)IDS_EMAIL_ADDRESS
, NULL
},
784 { 6, szOID_RSA_unstructName
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_NAME
, NULL
},
785 { 6, szOID_RSA_contentType
, 0, (LPCWSTR
)IDS_CONTENT_TYPE
, NULL
},
786 { 6, szOID_RSA_messageDigest
, 0, (LPCWSTR
)IDS_MESSAGE_DIGEST
, NULL
},
787 { 6, szOID_RSA_signingTime
, 0, (LPCWSTR
)IDS_SIGNING_TIME
, NULL
},
788 { 6, szOID_RSA_counterSign
, 0, (LPCWSTR
)IDS_COUNTER_SIGN
, NULL
},
789 { 6, szOID_RSA_challengePwd
, 0, (LPCWSTR
)IDS_CHALLENGE_PASSWORD
, NULL
},
790 { 6, szOID_RSA_unstructAddr
, 0, (LPCWSTR
)IDS_UNSTRUCTURED_ADDRESS
, NULL
},
791 { 6, szOID_RSA_SMIMECapabilities
, 0, (LPCWSTR
)IDS_SMIME_CAPABILITIES
, NULL
},
792 { 6, szOID_RSA_preferSignedData
, 0, (LPCWSTR
)IDS_PREFER_SIGNED_DATA
, NULL
},
793 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS
, 0, (LPCWSTR
)IDS_CPS
, NULL
},
794 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
, 0, (LPCWSTR
)IDS_USER_NOTICE
, NULL
},
795 { 6, szOID_PKIX_OCSP
, 0, (LPCWSTR
)IDS_OCSP
, NULL
},
796 { 6, szOID_PKIX_CA_ISSUERS
, 0, (LPCWSTR
)IDS_CA_ISSUER
, NULL
},
797 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TEMPLATE_NAME
, NULL
},
798 { 6, szOID_ENROLL_CERTTYPE_EXTENSION
, 0, (LPCWSTR
)IDS_CERT_TYPE
, NULL
},
799 { 6, szOID_CERT_MANIFOLD
, 0, (LPCWSTR
)IDS_CERT_MANIFOLD
, NULL
},
800 { 6, szOID_NETSCAPE_CERT_TYPE
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_TYPE
, NULL
},
801 { 6, szOID_NETSCAPE_BASE_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_BASE_URL
, NULL
},
802 { 6, szOID_NETSCAPE_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_REVOCATION_URL
, NULL
},
803 { 6, szOID_NETSCAPE_CA_REVOCATION_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_REVOCATION_URL
, NULL
},
804 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CERT_RENEWAL_URL
, NULL
},
805 { 6, szOID_NETSCAPE_CA_POLICY_URL
, 0, (LPCWSTR
)IDS_NETSCAPE_CA_POLICY_URL
, NULL
},
806 { 6, szOID_NETSCAPE_SSL_SERVER_NAME
, 0, (LPCWSTR
)IDS_NETSCAPE_SSL_SERVER_NAME
, NULL
},
807 { 6, szOID_NETSCAPE_COMMENT
, 0, (LPCWSTR
)IDS_NETSCAPE_COMMENT
, NULL
},
808 { 6, "1.3.6.1.4.1.311.2.1.10", 0, (LPCWSTR
)IDS_SPC_SP_AGENCY_INFO
, NULL
},
809 { 6, "1.3.6.1.4.1.311.2.1.27", 0, (LPCWSTR
)IDS_SPC_FINANCIAL_CRITERIA
, NULL
},
810 { 6, "1.3.6.1.4.1.311.2.1.26", 0, (LPCWSTR
)IDS_SPC_MINIMAL_CRITERIA
, NULL
},
811 { 6, szOID_COUNTRY_NAME
, 0, (LPCWSTR
)IDS_COUNTRY
, NULL
},
812 { 6, szOID_ORGANIZATION_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATION
, NULL
},
813 { 6, szOID_ORGANIZATIONAL_UNIT_NAME
, 0, (LPCWSTR
)IDS_ORGANIZATIONAL_UNIT
, NULL
},
814 { 6, szOID_COMMON_NAME
, 0, (LPCWSTR
)IDS_COMMON_NAME
, NULL
},
815 { 6, szOID_LOCALITY_NAME
, 0, (LPCWSTR
)IDS_LOCALITY
, NULL
},
816 { 6, szOID_STATE_OR_PROVINCE_NAME
, 0, (LPCWSTR
)IDS_STATE_OR_PROVINCE
, NULL
},
817 { 6, szOID_TITLE
, 0, (LPCWSTR
)IDS_TITLE
, NULL
},
818 { 6, szOID_GIVEN_NAME
, 0, (LPCWSTR
)IDS_GIVEN_NAME
, NULL
},
819 { 6, szOID_INITIALS
, 0, (LPCWSTR
)IDS_INITIALS
, NULL
},
820 { 6, szOID_SUR_NAME
, 0, (LPCWSTR
)IDS_SUR_NAME
, NULL
},
821 { 6, szOID_DOMAIN_COMPONENT
, 0, (LPCWSTR
)IDS_DOMAIN_COMPONENT
, NULL
},
822 { 6, szOID_STREET_ADDRESS
, 0, (LPCWSTR
)IDS_STREET_ADDRESS
, NULL
},
823 { 6, szOID_DEVICE_SERIAL_NUMBER
, 0, (LPCWSTR
)IDS_SERIAL_NUMBER
, NULL
},
824 { 6, szOID_CERTSRV_CA_VERSION
, 0, (LPCWSTR
)IDS_CA_VERSION
, NULL
},
825 { 6, szOID_CERTSRV_CROSSCA_VERSION
, 0, (LPCWSTR
)IDS_CROSS_CA_VERSION
, NULL
},
826 { 6, szOID_SERIALIZED
, 0, (LPCWSTR
)IDS_SERIALIZED_SIG_SERIAL_NUMBER
, NULL
},
827 { 6, szOID_NT_PRINCIPAL_NAME
, 0, (LPCWSTR
)IDS_PRINCIPAL_NAME
, NULL
},
828 { 6, szOID_PRODUCT_UPDATE
, 0, (LPCWSTR
)IDS_WINDOWS_PRODUCT_UPDATE
, NULL
},
829 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR
, 0, (LPCWSTR
)IDS_ENROLLMENT_NAME_VALUE_PAIR
, NULL
},
830 { 6, szOID_OS_VERSION
, 0, (LPCWSTR
)IDS_OS_VERSION
, NULL
},
831 { 6, szOID_ENROLLMENT_CSP_PROVIDER
, 0, (LPCWSTR
)IDS_ENROLLMENT_CSP
, NULL
},
832 { 6, szOID_CRL_NUMBER
, 0, (LPCWSTR
)IDS_CRL_NUMBER
, NULL
},
833 { 6, szOID_DELTA_CRL_INDICATOR
, 0, (LPCWSTR
)IDS_DELTA_CRL_INDICATOR
, NULL
},
834 { 6, szOID_ISSUING_DIST_POINT
, 0, (LPCWSTR
)IDS_ISSUING_DIST_POINT
, NULL
},
835 { 6, szOID_FRESHEST_CRL
, 0, (LPCWSTR
)IDS_FRESHEST_CRL
, NULL
},
836 { 6, szOID_NAME_CONSTRAINTS
, 0, (LPCWSTR
)IDS_NAME_CONSTRAINTS
, NULL
},
837 { 6, szOID_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
838 { 6, szOID_LEGACY_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_POLICY_MAPPINGS
, NULL
},
839 { 6, szOID_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_POLICY_CONSTRAINTS
, NULL
},
840 { 6, szOID_CROSS_CERT_DIST_POINTS
, 0, (LPCWSTR
)IDS_CROSS_CERT_DIST_POINTS
, NULL
},
841 { 6, szOID_APPLICATION_CERT_POLICIES
, 0, (LPCWSTR
)IDS_APPLICATION_POLICIES
, NULL
},
842 { 6, szOID_APPLICATION_POLICY_MAPPINGS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_MAPPINGS
, NULL
},
843 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS
, 0, (LPCWSTR
)IDS_APPLICATION_POLICY_CONSTRAINTS
, NULL
},
844 { 6, szOID_CT_PKI_DATA
, 0, (LPCWSTR
)IDS_CMC_DATA
, NULL
},
845 { 6, szOID_CT_PKI_RESPONSE
, 0, (LPCWSTR
)IDS_CMC_RESPONSE
, NULL
},
846 { 6, szOID_CMC
, 0, (LPCWSTR
)IDS_UNSIGNED_CMC_REQUEST
, NULL
},
847 { 6, szOID_CMC_STATUS_INFO
, 0, (LPCWSTR
)IDS_CMC_STATUS_INFO
, NULL
},
848 { 6, szOID_CMC_ADD_EXTENSIONS
, 0, (LPCWSTR
)IDS_CMC_EXTENSIONS
, NULL
},
849 { 6, szOID_CTL
, 0, (LPCWSTR
)IDS_CMC_ATTRIBUTES
, NULL
},
850 { 6, szOID_RSA_data
, 0, (LPCWSTR
)IDS_PKCS_7_DATA
, NULL
},
851 { 6, szOID_RSA_signedData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED
, NULL
},
852 { 6, szOID_RSA_envelopedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENVELOPED
, NULL
},
853 { 6, szOID_RSA_signEnvData
, 0, (LPCWSTR
)IDS_PKCS_7_SIGNED_ENVELOPED
, NULL
},
854 { 6, szOID_RSA_digestedData
, 0, (LPCWSTR
)IDS_PKCS_7_DIGESTED
, NULL
},
855 { 6, szOID_RSA_encryptedData
, 0, (LPCWSTR
)IDS_PKCS_7_ENCRYPTED
, NULL
},
856 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH
, 0, (LPCWSTR
)IDS_PREVIOUS_CA_CERT_HASH
, NULL
},
857 { 6, szOID_CRL_VIRTUAL_BASE
, 0, (LPCWSTR
)IDS_CRL_VIRTUAL_BASE
, NULL
},
858 { 6, szOID_CRL_NEXT_PUBLISH
, 0, (LPCWSTR
)IDS_CRL_NEXT_PUBLISH
, NULL
},
859 { 6, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
860 { 6, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
861 { 6, szOID_CERTIFICATE_TEMPLATE
, 0, (LPCWSTR
)IDS_CERTIFICATE_TEMPLATE
, NULL
},
862 { 6, szOID_ENTERPRISE_OID_ROOT
, 0, (LPCWSTR
)IDS_ENTERPRISE_ROOT_OID
, NULL
},
863 { 6, szOID_RDN_DUMMY_SIGNER
, 0, (LPCWSTR
)IDS_RDN_DUMMY_SIGNER
, NULL
},
864 { 6, szOID_ARCHIVED_KEY_ATTR
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_ATTR
, NULL
},
865 { 6, szOID_CRL_SELF_CDP
, 0, (LPCWSTR
)IDS_CRL_SELF_CDP
, NULL
},
866 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY
, 0, (LPCWSTR
)IDS_REQUIRE_CERT_CHAIN_POLICY
, NULL
},
867 { 6, szOID_CMC_TRANSACTION_ID
, 0, (LPCWSTR
)IDS_TRANSACTION_ID
, NULL
},
868 { 6, szOID_CMC_SENDER_NONCE
, 0, (LPCWSTR
)IDS_SENDER_NONCE
, NULL
},
869 { 6, szOID_CMC_RECIPIENT_NONCE
, 0, (LPCWSTR
)IDS_RECIPIENT_NONCE
, NULL
},
870 { 6, szOID_CMC_REG_INFO
, 0, (LPCWSTR
)IDS_REG_INFO
, NULL
},
871 { 6, szOID_CMC_GET_CERT
, 0, (LPCWSTR
)IDS_GET_CERTIFICATE
, NULL
},
872 { 6, szOID_CMC_GET_CRL
, 0, (LPCWSTR
)IDS_GET_CRL
, NULL
},
873 { 6, szOID_CMC_REVOKE_REQUEST
, 0, (LPCWSTR
)IDS_REVOKE_REQUEST
, NULL
},
874 { 6, szOID_CMC_QUERY_PENDING
, 0, (LPCWSTR
)IDS_QUERY_PENDING
, NULL
},
875 { 6, szOID_SORTED_CTL
, 0, (LPCWSTR
)IDS_SORTED_CTL
, NULL
},
876 { 6, szOID_ARCHIVED_KEY_CERT_HASH
, 0, (LPCWSTR
)IDS_ARCHIVED_KEY_CERT_HASH
, NULL
},
877 { 6, szOID_PRIVATEKEY_USAGE_PERIOD
, 0, (LPCWSTR
)IDS_PRIVATE_KEY_USAGE_PERIOD
, NULL
},
878 { 6, szOID_REQUEST_CLIENT_INFO
, 0, (LPCWSTR
)IDS_CLIENT_INFORMATION
, NULL
},
880 { 7, szOID_PKIX_KP_SERVER_AUTH
, 0, (LPCWSTR
)IDS_SERVER_AUTHENTICATION
, NULL
},
881 { 7, szOID_PKIX_KP_CLIENT_AUTH
, 0, (LPCWSTR
)IDS_CLIENT_AUTHENTICATION
, NULL
},
882 { 7, szOID_PKIX_KP_CODE_SIGNING
, 0, (LPCWSTR
)IDS_CODE_SIGNING
, NULL
},
883 { 7, szOID_PKIX_KP_EMAIL_PROTECTION
, 0, (LPCWSTR
)IDS_SECURE_EMAIL
, NULL
},
884 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING
, 0, (LPCWSTR
)IDS_TIME_STAMPING
, NULL
},
885 { 7, szOID_KP_CTL_USAGE_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TRUST_LIST_SIGNING
, NULL
},
886 { 7, szOID_KP_TIME_STAMP_SIGNING
, 0, (LPCWSTR
)IDS_MICROSOFT_TIME_STAMPING
, NULL
},
887 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM
, 0, (LPCWSTR
)IDS_IPSEC_END_SYSTEM
, NULL
},
888 { 7, szOID_PKIX_KP_IPSEC_TUNNEL
, 0, (LPCWSTR
)IDS_IPSEC_TUNNEL
, NULL
},
889 { 7, szOID_PKIX_KP_IPSEC_USER
, 0, (LPCWSTR
)IDS_IPSEC_USER
, NULL
},
890 { 7, szOID_KP_EFS
, 0, (LPCWSTR
)IDS_EFS
, NULL
},
891 { 7, szOID_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_WHQL_CRYPTO
, NULL
},
892 { 7, szOID_NT5_CRYPTO
, 0, (LPCWSTR
)IDS_NT5_CRYPTO
, NULL
},
893 { 7, szOID_OEM_WHQL_CRYPTO
, 0, (LPCWSTR
)IDS_OEM_WHQL_CRYPTO
, NULL
},
894 { 7, szOID_EMBEDDED_NT_CRYPTO
, 0, (LPCWSTR
)IDS_EMBEDDED_NT_CRYPTO
, NULL
},
895 { 7, szOID_LICENSES
, 0, (LPCWSTR
)IDS_KEY_PACK_LICENSES
, NULL
},
896 { 7, szOID_LICENSE_SERVER
, 0, (LPCWSTR
)IDS_LICENSE_SERVER
, NULL
},
897 { 7, szOID_KP_SMARTCARD_LOGON
, 0, (LPCWSTR
)IDS_SMART_CARD_LOGON
, NULL
},
898 { 7, szOID_DRM
, 0, (LPCWSTR
)IDS_DIGITAL_RIGHTS
, NULL
},
899 { 7, szOID_KP_QUALIFIED_SUBORDINATION
, 0, (LPCWSTR
)IDS_QUALIFIED_SUBORDINATION
, NULL
},
900 { 7, szOID_KP_KEY_RECOVERY
, 0, (LPCWSTR
)IDS_KEY_RECOVERY
, NULL
},
901 { 7, szOID_KP_DOCUMENT_SIGNING
, 0, (LPCWSTR
)IDS_DOCUMENT_SIGNING
, NULL
},
902 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE
, 0, (LPCWSTR
)IDS_IPSEC_IKE_INTERMEDIATE
, NULL
},
903 { 7, szOID_EFS_RECOVERY
, 0, (LPCWSTR
)IDS_FILE_RECOVERY
, NULL
},
904 { 7, szOID_ROOT_LIST_SIGNER
, 0, (LPCWSTR
)IDS_ROOT_LIST_SIGNER
, NULL
},
905 { 7, szOID_ANY_APPLICATION_POLICY
, 0, (LPCWSTR
)IDS_ANY_APPLICATION_POLICIES
, NULL
},
906 { 7, szOID_DS_EMAIL_REPLICATION
, 0, (LPCWSTR
)IDS_DS_EMAIL_REPLICATION
, NULL
},
907 { 7, szOID_ENROLLMENT_AGENT
, 0, (LPCWSTR
)IDS_ENROLLMENT_AGENT
, NULL
},
908 { 7, szOID_KP_KEY_RECOVERY_AGENT
, 0, (LPCWSTR
)IDS_KEY_RECOVERY_AGENT
, NULL
},
909 { 7, szOID_KP_CA_EXCHANGE
, 0, (LPCWSTR
)IDS_CA_EXCHANGE
, NULL
},
910 { 7, szOID_KP_LIFETIME_SIGNING
, 0, (LPCWSTR
)IDS_LIFETIME_SIGNING
, NULL
},
912 { 8, szOID_ANY_CERT_POLICY
, 0, (LPCWSTR
)IDS_ANY_CERT_POLICY
, NULL
},
920 static void init_oid_info(HINSTANCE hinst
)
924 InitializeCriticalSection(&oidInfoCS
);
926 for (i
= 0; i
< sizeof(oidInfoConstructors
) /
927 sizeof(oidInfoConstructors
[0]); i
++)
929 if (HIWORD(oidInfoConstructors
[i
].pwszName
))
931 struct OIDInfo
*info
;
933 /* The name is a static string, so just use the same pointer */
934 info
= CryptMemAlloc(sizeof(struct OIDInfo
));
937 memset(info
, 0, sizeof(*info
));
938 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
939 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
940 info
->info
.pwszName
= oidInfoConstructors
[i
].pwszName
;
941 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
942 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
943 if (oidInfoConstructors
[i
].blob
)
945 info
->info
.ExtraInfo
.cbData
=
946 oidInfoConstructors
[i
].blob
->cbData
;
947 info
->info
.ExtraInfo
.pbData
=
948 oidInfoConstructors
[i
].blob
->pbData
;
950 list_add_tail(&oidInfo
, &info
->entry
);
955 int len
= LoadStringW(hinst
, (UINT
)oidInfoConstructors
[i
].pwszName
,
960 struct OIDInfo
*info
= CryptMemAlloc(sizeof(struct OIDInfo
) +
961 (len
+ 1) * sizeof(WCHAR
));
965 memset(info
, 0, sizeof(*info
));
966 info
->info
.cbSize
= sizeof(CRYPT_OID_INFO
);
967 info
->info
.pszOID
= oidInfoConstructors
[i
].pszOID
;
968 info
->info
.pwszName
=
969 (LPWSTR
)((LPBYTE
)info
+ sizeof(struct OIDInfo
));
970 info
->info
.dwGroupId
= oidInfoConstructors
[i
].dwGroupId
;
971 info
->info
.u
.Algid
= oidInfoConstructors
[i
].Algid
;
972 LoadStringW(hinst
, (UINT
)oidInfoConstructors
[i
].pwszName
,
973 (LPWSTR
)info
->info
.pwszName
, len
+ 1);
974 if (oidInfoConstructors
[i
].blob
)
976 info
->info
.ExtraInfo
.cbData
=
977 oidInfoConstructors
[i
].blob
->cbData
;
978 info
->info
.ExtraInfo
.pbData
=
979 oidInfoConstructors
[i
].blob
->pbData
;
981 list_add_tail(&oidInfo
, &info
->entry
);
988 static void free_oid_info(void)
990 struct OIDInfo
*info
, *next
;
992 LIST_FOR_EACH_ENTRY_SAFE(info
, next
, &oidInfo
, struct OIDInfo
, entry
)
994 list_remove(&info
->entry
);
997 DeleteCriticalSection(&oidInfoCS
);
1000 BOOL WINAPI
CryptEnumOIDInfo(DWORD dwGroupId
, DWORD dwFlags
, void *pvArg
,
1001 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo
)
1004 struct OIDInfo
*info
;
1006 TRACE("(%ld, %08lx, %p, %p)\n", dwGroupId
, dwFlags
, pvArg
,
1009 EnterCriticalSection(&oidInfoCS
);
1010 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1012 if (!dwGroupId
|| dwGroupId
== info
->info
.dwGroupId
)
1014 ret
= pfnEnumOIDInfo(&info
->info
, pvArg
);
1019 LeaveCriticalSection(&oidInfoCS
);
1023 PCCRYPT_OID_INFO WINAPI
CryptFindOIDInfo(DWORD dwKeyType
, void *pvKey
,
1026 PCCRYPT_OID_INFO ret
= NULL
;
1028 TRACE("(%ld, %p, %ld)\n", dwKeyType
, pvKey
, dwGroupId
);
1032 case CRYPT_OID_INFO_ALGID_KEY
:
1034 struct OIDInfo
*info
;
1036 EnterCriticalSection(&oidInfoCS
);
1037 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1039 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1040 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1046 LeaveCriticalSection(&oidInfoCS
);
1049 case CRYPT_OID_INFO_NAME_KEY
:
1051 struct OIDInfo
*info
;
1053 EnterCriticalSection(&oidInfoCS
);
1054 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1056 if (!lstrcmpW(info
->info
.pwszName
, (LPWSTR
)pvKey
) &&
1057 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1063 LeaveCriticalSection(&oidInfoCS
);
1066 case CRYPT_OID_INFO_OID_KEY
:
1068 struct OIDInfo
*info
;
1069 LPSTR oid
= (LPSTR
)pvKey
;
1071 EnterCriticalSection(&oidInfoCS
);
1072 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1074 if (!lstrcmpA(info
->info
.pszOID
, oid
) &&
1075 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1081 LeaveCriticalSection(&oidInfoCS
);
1084 case CRYPT_OID_INFO_SIGN_KEY
:
1086 struct OIDInfo
*info
;
1088 EnterCriticalSection(&oidInfoCS
);
1089 LIST_FOR_EACH_ENTRY(info
, &oidInfo
, struct OIDInfo
, entry
)
1091 if (info
->info
.u
.Algid
== *(DWORD
*)pvKey
&&
1092 info
->info
.ExtraInfo
.cbData
>= sizeof(DWORD
) &&
1093 *(DWORD
*)info
->info
.ExtraInfo
.pbData
==
1094 *(DWORD
*)((LPBYTE
)pvKey
+ sizeof(DWORD
)) &&
1095 (!dwGroupId
|| info
->info
.dwGroupId
== dwGroupId
))
1101 LeaveCriticalSection(&oidInfoCS
);
1108 LPCSTR WINAPI
CertAlgIdToOID(DWORD dwAlgId
)
1111 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY
,
1121 DWORD WINAPI
CertOIDToAlgId(LPCSTR pszObjId
)
1124 PCCRYPT_OID_INFO info
= CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY
,
1125 (void *)pszObjId
, 0);
1128 ret
= info
->u
.Algid
;