1 /* 2 * Copyright 2002 Mike McCormack for CodeWeavers 3 * Copyright 2005-2006 Juan Lang 4 * 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. 9 * 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. 14 * 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 18 */ 19 20 #include "config.h" 21 #include "wine/port.h" 22 23 #include <stdio.h> 24 #include <stdarg.h> 25 #define NONAMELESSUNION 26 #include "windef.h" 27 #include "winbase.h" 28 #define CRYPT_OID_INFO_HAS_EXTRA_FIELDS 29 #include "wincrypt.h" 30 #include "winreg.h" 31 #include "winuser.h" 32 #include "wine/debug.h" 33 #include "wine/list.h" 34 #include "crypt32_private.h" 35 #include "cryptres.h" 36 37 WINE_DEFAULT_DEBUG_CHANNEL(crypt); 38 39 static const WCHAR DllW[] = { 'D','l','l',0 }; 40 41 static CRITICAL_SECTION funcSetCS; 42 static CRITICAL_SECTION_DEBUG funcSetCSDebug = 43 { 44 0, 0, &funcSetCS, 45 { &funcSetCSDebug.ProcessLocksList, &funcSetCSDebug.ProcessLocksList }, 46 0, 0, { (DWORD_PTR)(__FILE__ ": funcSetCS") } 47 }; 48 static CRITICAL_SECTION funcSetCS = { &funcSetCSDebug, -1, 0, 0, 0, 0 }; 49 static struct list funcSets = { &funcSets, &funcSets }; 50 51 struct OIDFunctionSet 52 { 53 LPSTR name; 54 CRITICAL_SECTION cs; /* protects functions */ 55 struct list functions; 56 struct list next; 57 }; 58 59 struct OIDFunction 60 { 61 DWORD encoding; 62 CRYPT_OID_FUNC_ENTRY entry; 63 struct list next; 64 }; 65 66 static const WCHAR ROOT[] = {'R','O','O','T',0}; 67 static const WCHAR MY[] = {'M','Y',0}; 68 static const WCHAR CA[] = {'C','A',0}; 69 static const WCHAR ADDRESSBOOK[] = {'A','D','D','R','E','S','S','B','O','O','K',0}; 70 static const WCHAR TRUSTEDPUBLISHER[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0}; 71 static const WCHAR DISALLOWED[] = {'D','i','s','a','l','l','o','w','e','d',0}; 72 static const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER,DISALLOWED}; 73 static WCHAR LocalizedNames[sizeof(LocalizedKeys)/sizeof(LocalizedKeys[0])][256]; 74 75 static void free_function_sets(void) 76 { 77 struct OIDFunctionSet *setCursor, *setNext; 78 79 LIST_FOR_EACH_ENTRY_SAFE(setCursor, setNext, &funcSets, 80 struct OIDFunctionSet, next) 81 { 82 struct OIDFunction *functionCursor, *funcNext; 83 84 list_remove(&setCursor->next); 85 CryptMemFree(setCursor->name); 86 LIST_FOR_EACH_ENTRY_SAFE(functionCursor, funcNext, 87 &setCursor->functions, struct OIDFunction, next) 88 { 89 list_remove(&functionCursor->next); 90 CryptMemFree(functionCursor); 91 } 92 setCursor->cs.DebugInfo->Spare[0] = 0; 93 DeleteCriticalSection(&setCursor->cs); 94 CryptMemFree(setCursor); 95 } 96 DeleteCriticalSection(&funcSetCS); 97 } 98 99 /* There is no free function associated with this; therefore, the sets are 100 * freed when crypt32.dll is unloaded. 101 */ 102 HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName, 103 DWORD dwFlags) 104 { 105 struct OIDFunctionSet *cursor, *ret = NULL; 106 107 TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags); 108 109 EnterCriticalSection(&funcSetCS); 110 LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next) 111 { 112 if (!strcasecmp(pszFuncName, cursor->name)) 113 { 114 ret = cursor; 115 break; 116 } 117 } 118 if (!ret) 119 { 120 ret = CryptMemAlloc(sizeof(struct OIDFunctionSet)); 121 if (ret) 122 { 123 memset(ret, 0, sizeof(*ret)); 124 ret->name = CryptMemAlloc(strlen(pszFuncName) + 1); 125 if (ret->name) 126 { 127 InitializeCriticalSection(&ret->cs); 128 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": OIDFunctionSet.cs"); 129 list_init(&ret->functions); 130 strcpy(ret->name, pszFuncName); 131 list_add_tail(&funcSets, &ret->next); 132 } 133 else 134 { 135 CryptMemFree(ret); 136 ret = NULL; 137 } 138 } 139 } 140 LeaveCriticalSection(&funcSetCS); 141 142 return ret; 143 } 144 145 static char *CRYPT_GetKeyName(DWORD dwEncodingType, LPCSTR pszFuncName, 146 LPCSTR pszOID) 147 { 148 static const char szEncodingTypeFmt[] = 149 "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s"; 150 UINT len; 151 char numericOID[7]; /* enough for "#65535" */ 152 const char *oid; 153 LPSTR szKey; 154 155 /* MSDN says the encoding type is a mask, but it isn't treated that way. 156 * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and 157 * "EncodingType 2" would be expected if it were a mask. Instead native 158 * stores values in "EncodingType 3". 159 */ 160 if (IS_INTOID(pszOID)) 161 { 162 snprintf(numericOID, sizeof(numericOID), "#%d", LOWORD(pszOID)); 163 oid = numericOID; 164 } 165 else 166 oid = pszOID; 167 168 /* This is enough: the lengths of the two string parameters are explicitly 169 * counted, and we need up to five additional characters for the encoding 170 * type. These are covered by the "%d", "%s", and "%s" characters in the 171 * format specifier that are removed by sprintf. 172 */ 173 len = sizeof(szEncodingTypeFmt) + lstrlenA(pszFuncName) + lstrlenA(oid); 174 szKey = CryptMemAlloc(len); 175 if (szKey) 176 sprintf(szKey, szEncodingTypeFmt, 177 GET_CERT_ENCODING_TYPE(dwEncodingType), pszFuncName, oid); 178 return szKey; 179 } 180 181 BOOL WINAPI CryptGetDefaultOIDDllList(HCRYPTOIDFUNCSET hFuncSet, 182 DWORD dwEncodingType, LPWSTR pwszDllList, DWORD *pcchDllList) 183 { 184 BOOL ret = TRUE; 185 struct OIDFunctionSet *set = hFuncSet; 186 char *keyName; 187 HKEY key; 188 LSTATUS rc; 189 190 TRACE("(%p, %d, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList, 191 pcchDllList); 192 193 keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT"); 194 rc = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0, 195 KEY_READ, NULL, &key, NULL); 196 if (!rc) 197 { 198 DWORD size = *pcchDllList * sizeof(WCHAR); 199 200 rc = RegQueryValueExW(key, DllW, NULL, NULL, (LPBYTE)pwszDllList, 201 &size); 202 if (!rc) 203 *pcchDllList = size / sizeof(WCHAR); 204 else 205 { 206 /* No value, return an empty list */ 207 if (pwszDllList && *pcchDllList) 208 *pwszDllList = '\0'; 209 *pcchDllList = 1; 210 } 211 RegCloseKey(key); 212 } 213 else 214 { 215 /* No value, return an empty list */ 216 if (pwszDllList && *pcchDllList) 217 *pwszDllList = '\0'; 218 *pcchDllList = 1; 219 } 220 CryptMemFree(keyName); 221 222 return ret; 223 } 224 225 BOOL WINAPI CryptInstallOIDFunctionAddress(HMODULE hModule, 226 DWORD dwEncodingType, LPCSTR pszFuncName, DWORD cFuncEntry, 227 const CRYPT_OID_FUNC_ENTRY rgFuncEntry[], DWORD dwFlags) 228 { 229 BOOL ret = TRUE; 230 struct OIDFunctionSet *set; 231 232 TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType, 233 debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags); 234 235 set = CryptInitOIDFunctionSet(pszFuncName, 0); 236 if (set) 237 { 238 DWORD i; 239 240 EnterCriticalSection(&set->cs); 241 for (i = 0; ret && i < cFuncEntry; i++) 242 { 243 struct OIDFunction *func; 244 245 if (!IS_INTOID(rgFuncEntry[i].pszOID)) 246 func = CryptMemAlloc(sizeof(struct OIDFunction) 247 + strlen(rgFuncEntry[i].pszOID) + 1); 248 else 249 func = CryptMemAlloc(sizeof(struct OIDFunction)); 250 if (func) 251 { 252 func->encoding = GET_CERT_ENCODING_TYPE(dwEncodingType); 253 if (!IS_INTOID(rgFuncEntry[i].pszOID)) 254 { 255 LPSTR oid; 256 257 oid = (LPSTR)((LPBYTE)func + sizeof(*func)); 258 strcpy(oid, rgFuncEntry[i].pszOID); 259 func->entry.pszOID = oid; 260 } 261 else 262 func->entry.pszOID = rgFuncEntry[i].pszOID; 263 func->entry.pvFuncAddr = rgFuncEntry[i].pvFuncAddr; 264 list_add_tail(&set->functions, &func->next); 265 } 266 else 267 ret = FALSE; 268 } 269 LeaveCriticalSection(&set->cs); 270 } 271 else 272 ret = FALSE; 273 return ret; 274 } 275 276 struct FuncAddr 277 { 278 HMODULE lib; 279 LPWSTR dllList; 280 LPWSTR currentDll; 281 }; 282 283 static BOOL CRYPT_GetFuncFromReg(DWORD dwEncodingType, LPCSTR pszOID, 284 LPCSTR szFuncName, LPVOID *ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr) 285 { 286 BOOL ret = FALSE; 287 char *keyName; 288 const char *funcName; 289 HKEY key; 290 LSTATUS rc; 291 292 keyName = CRYPT_GetKeyName(dwEncodingType, szFuncName, pszOID); 293 rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, KEY_READ, &key); 294 if (!rc) 295 { 296 DWORD type, size = 0; 297 298 rc = RegQueryValueExA(key, "FuncName", NULL, &type, NULL, &size); 299 if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ) 300 { 301 funcName = CryptMemAlloc(size); 302 rc = RegQueryValueExA(key, "FuncName", NULL, &type, 303 (LPBYTE)funcName, &size); 304 } 305 else 306 funcName = szFuncName; 307 rc = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size); 308 if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ) 309 { 310 LPWSTR dllName = CryptMemAlloc(size); 311 312 if (dllName) 313 { 314 rc = RegQueryValueExW(key, DllW, NULL, NULL, 315 (LPBYTE)dllName, &size); 316 if (!rc) 317 { 318 HMODULE lib; 319 320 /* This is a bit of a hack; MSDN describes a more 321 * complicated unload routine than this will allow. 322 * Still, this seems to suffice for now. 323 */ 324 lib = LoadLibraryW(dllName); 325 if (lib) 326 { 327 *ppvFuncAddr = GetProcAddress(lib, funcName); 328 if (*ppvFuncAddr) 329 { 330 struct FuncAddr *addr = 331 CryptMemAlloc(sizeof(struct FuncAddr)); 332 333 if (addr) 334 { 335 addr->lib = lib; 336 addr->dllList = addr->currentDll = NULL; 337 *phFuncAddr = addr; 338 ret = TRUE; 339 } 340 else 341 { 342 *phFuncAddr = NULL; 343 FreeLibrary(lib); 344 } 345 } 346 else 347 { 348 /* Unload the library, the caller doesn't want 349 * to unload it when the return value is NULL. 350 */ 351 FreeLibrary(lib); 352 } 353 } 354 } 355 else 356 SetLastError(rc); 357 CryptMemFree(dllName); 358 } 359 } 360 else 361 SetLastError(rc); 362 if (funcName != szFuncName) 363 CryptMemFree((char *)funcName); 364 RegCloseKey(key); 365 } 366 else 367 SetLastError(rc); 368 CryptMemFree(keyName); 369 return ret; 370 } 371 372 BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, 373 DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, 374 HCRYPTOIDFUNCADDR *phFuncAddr) 375 { 376 BOOL ret = FALSE; 377 struct OIDFunctionSet *set = hFuncSet; 378 379 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType, 380 debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr); 381 382 *ppvFuncAddr = NULL; 383 if (!(dwFlags & CRYPT_GET_INSTALLED_OID_FUNC_FLAG)) 384 { 385 struct OIDFunction *function; 386 387 EnterCriticalSection(&set->cs); 388 LIST_FOR_EACH_ENTRY(function, &set->functions, struct OIDFunction, next) 389 { 390 if (function->encoding == GET_CERT_ENCODING_TYPE(dwEncodingType)) 391 { 392 if (!IS_INTOID(pszOID)) 393 { 394 if (!IS_INTOID(function->entry.pszOID) && 395 !strcasecmp(function->entry.pszOID, pszOID)) 396 { 397 *ppvFuncAddr = function->entry.pvFuncAddr; 398 *phFuncAddr = NULL; /* FIXME: what should it be? */ 399 ret = TRUE; 400 break; 401 } 402 } 403 else if (function->entry.pszOID == pszOID) 404 { 405 *ppvFuncAddr = function->entry.pvFuncAddr; 406 *phFuncAddr = NULL; /* FIXME: what should it be? */ 407 ret = TRUE; 408 break; 409 } 410 } 411 } 412 LeaveCriticalSection(&set->cs); 413 } 414 if (!*ppvFuncAddr) 415 ret = CRYPT_GetFuncFromReg(dwEncodingType, pszOID, set->name, 416 ppvFuncAddr, phFuncAddr); 417 TRACE("returning %d\n", ret); 418 return ret; 419 } 420 421 BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, 422 DWORD dwFlags) 423 { 424 TRACE("(%p, %08x)\n", hFuncAddr, dwFlags); 425 426 /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL, 427 * and only unload it if it can be unloaded. Also need to implement ref 428 * counting on the functions. 429 */ 430 if (hFuncAddr) 431 { 432 struct FuncAddr *addr = hFuncAddr; 433 434 CryptMemFree(addr->dllList); 435 FreeLibrary(addr->lib); 436 CryptMemFree(addr); 437 } 438 return TRUE; 439 } 440 441 static BOOL CRYPT_GetFuncFromDll(LPCWSTR dll, LPCSTR func, HMODULE *lib, 442 void **ppvFuncAddr) 443 { 444 BOOL ret = FALSE; 445 446 *lib = LoadLibraryW(dll); 447 if (*lib) 448 { 449 *ppvFuncAddr = GetProcAddress(*lib, func); 450 if (*ppvFuncAddr) 451 ret = TRUE; 452 else 453 { 454 FreeLibrary(*lib); 455 *lib = NULL; 456 } 457 } 458 return ret; 459 } 460 461 BOOL WINAPI CryptGetDefaultOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, 462 DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void **ppvFuncAddr, 463 HCRYPTOIDFUNCADDR *phFuncAddr) 464 { 465 struct OIDFunctionSet *set = hFuncSet; 466 BOOL ret = FALSE; 467 468 TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType, 469 debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr); 470 471 if (pwszDll) 472 { 473 HMODULE lib; 474 475 *phFuncAddr = NULL; 476 ret = CRYPT_GetFuncFromDll(pwszDll, set->name, &lib, ppvFuncAddr); 477 if (ret) 478 { 479 struct FuncAddr *addr = CryptMemAlloc(sizeof(struct FuncAddr)); 480 481 if (addr) 482 { 483 addr->lib = lib; 484 addr->dllList = addr->currentDll = NULL; 485 *phFuncAddr = addr; 486 } 487 else 488 { 489 FreeLibrary(lib); 490 *ppvFuncAddr = NULL; 491 SetLastError(ERROR_OUTOFMEMORY); 492 ret = FALSE; 493 } 494 } 495 else 496 SetLastError(ERROR_FILE_NOT_FOUND); 497 } 498 else 499 { 500 struct FuncAddr *addr = *phFuncAddr; 501 502 if (!addr) 503 { 504 DWORD size; 505 506 ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType, NULL, 507 &size); 508 if (ret) 509 { 510 LPWSTR dllList = CryptMemAlloc(size * sizeof(WCHAR)); 511 512 if (dllList) 513 { 514 ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType, 515 dllList, &size); 516 if (ret) 517 { 518 addr = CryptMemAlloc(sizeof(struct FuncAddr)); 519 if (addr) 520 { 521 addr->dllList = dllList; 522 addr->currentDll = dllList; 523 addr->lib = NULL; 524 *phFuncAddr = addr; 525 } 526 else 527 { 528 CryptMemFree(dllList); 529 SetLastError(ERROR_OUTOFMEMORY); 530 ret = FALSE; 531 } 532 } 533 } 534 else 535 { 536 SetLastError(ERROR_OUTOFMEMORY); 537 ret = FALSE; 538 } 539 } 540 } 541 if (addr) 542 { 543 if (!*addr->currentDll) 544 { 545 CryptFreeOIDFunctionAddress(*phFuncAddr, 0); 546 SetLastError(ERROR_FILE_NOT_FOUND); 547 *phFuncAddr = NULL; 548 ret = FALSE; 549 } 550 else 551 { 552 /* FIXME: as elsewhere, can't free until DllCanUnloadNow says 553 * it's possible, and should defer unloading for some time to 554 * avoid repeated LoadLibrary/FreeLibrary on the same dll. 555 */ 556 FreeLibrary(addr->lib); 557 ret = CRYPT_GetFuncFromDll(addr->currentDll, set->name, 558 &addr->lib, ppvFuncAddr); 559 if (ret) 560 { 561 /* Move past the current DLL */ 562 addr->currentDll += lstrlenW(addr->currentDll) + 1; 563 *phFuncAddr = addr; 564 } 565 else 566 { 567 CryptFreeOIDFunctionAddress(*phFuncAddr, 0); 568 SetLastError(ERROR_FILE_NOT_FOUND); 569 *phFuncAddr = NULL; 570 } 571 } 572 } 573 } 574 return ret; 575 } 576 577 /*********************************************************************** 578 * CryptRegisterOIDFunction (CRYPT32.@) 579 * 580 * Register the DLL and the functions it uses to cover the combination 581 * of encoding type, function name and OID. 582 * 583 * PARAMS 584 * dwEncodingType [I] Encoding type to be used. 585 * pszFuncName [I] Name of the function to be registered. 586 * pszOID [I] OID of the function (numeric or string). 587 * pwszDll [I] The DLL that is to be registered. 588 * pszOverrideFuncName [I] Name of the function in the DLL. 589 * 590 * RETURNS 591 * Success: TRUE. 592 * Failure: FALSE. (Look at GetLastError()). 593 * 594 * NOTES 595 * Registry errors are always reported via SetLastError(). 596 */ 597 BOOL WINAPI CryptRegisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, 598 LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName) 599 { 600 LONG r; 601 HKEY hKey; 602 LPSTR szKey; 603 604 TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName), 605 debugstr_a(pszOID), debugstr_w(pwszDll), debugstr_a(pszOverrideFuncName)); 606 607 /* Native does nothing pwszDll is NULL */ 608 if (!pwszDll) 609 return TRUE; 610 611 /* I'm not matching MS bug for bug here, because I doubt any app depends on 612 * it: native "succeeds" if pszFuncName is NULL, but the nonsensical entry 613 * it creates would never be used. 614 */ 615 if (!pszFuncName || !pszOID) 616 { 617 SetLastError(E_INVALIDARG); 618 return FALSE; 619 } 620 621 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID); 622 TRACE("Key name is %s\n", debugstr_a(szKey)); 623 624 if (!szKey) 625 return FALSE; 626 627 r = RegCreateKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey); 628 CryptMemFree(szKey); 629 630 if (r != ERROR_SUCCESS) goto error_close_key; 631 632 /* write the values */ 633 if (pszOverrideFuncName) 634 { 635 r = RegSetValueExA(hKey, "FuncName", 0, REG_SZ, 636 (const BYTE*)pszOverrideFuncName, lstrlenA(pszOverrideFuncName) + 1); 637 if (r != ERROR_SUCCESS) goto error_close_key; 638 } 639 r = RegSetValueExW(hKey, DllW, 0, REG_SZ, (const BYTE*) pwszDll, 640 (lstrlenW(pwszDll) + 1) * sizeof (WCHAR)); 641 642 error_close_key: 643 644 RegCloseKey(hKey); 645 646 if (r != ERROR_SUCCESS) 647 { 648 SetLastError(r); 649 return FALSE; 650 } 651 652 return TRUE; 653 } 654 655 /*********************************************************************** 656 * CryptRegisterOIDInfo (CRYPT32.@) 657 */ 658 BOOL WINAPI CryptRegisterOIDInfo(PCCRYPT_OID_INFO pInfo, DWORD dwFlags) 659 { 660 FIXME("(%p, %x): stub\n", pInfo, dwFlags ); 661 SetLastError(ERROR_CALL_NOT_IMPLEMENTED); 662 return FALSE; 663 } 664 665 /*********************************************************************** 666 * CryptUnregisterOIDFunction (CRYPT32.@) 667 */ 668 BOOL WINAPI CryptUnregisterOIDFunction(DWORD dwEncodingType, LPCSTR pszFuncName, 669 LPCSTR pszOID) 670 { 671 LPSTR szKey; 672 LONG rc; 673 674 TRACE("%x %s %s\n", dwEncodingType, debugstr_a(pszFuncName), 675 debugstr_a(pszOID)); 676 677 if (!pszFuncName || !pszOID) 678 { 679 SetLastError(ERROR_INVALID_PARAMETER); 680 return FALSE; 681 } 682 683 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID); 684 rc = RegDeleteKeyA(HKEY_LOCAL_MACHINE, szKey); 685 CryptMemFree(szKey); 686 if (rc) 687 SetLastError(rc); 688 return !rc; 689 } 690 691 BOOL WINAPI CryptGetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName, 692 LPCSTR pszOID, LPCWSTR pwszValueName, DWORD *pdwValueType, BYTE *pbValueData, 693 DWORD *pcbValueData) 694 { 695 LPSTR szKey; 696 LONG rc; 697 HKEY hKey; 698 699 TRACE("%x %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName), 700 debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData, 701 pcbValueData); 702 703 if (!GET_CERT_ENCODING_TYPE(dwEncodingType)) 704 return TRUE; 705 706 if (!pszFuncName || !pszOID || !pwszValueName) 707 { 708 SetLastError(ERROR_INVALID_PARAMETER); 709 return FALSE; 710 } 711 712 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID); 713 rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey); 714 CryptMemFree(szKey); 715 if (rc) 716 SetLastError(rc); 717 else 718 { 719 rc = RegQueryValueExW(hKey, pwszValueName, NULL, pdwValueType, 720 pbValueData, pcbValueData); 721 if (rc) 722 SetLastError(rc); 723 RegCloseKey(hKey); 724 } 725 return !rc; 726 } 727 728 BOOL WINAPI CryptSetOIDFunctionValue(DWORD dwEncodingType, LPCSTR pszFuncName, 729 LPCSTR pszOID, LPCWSTR pwszValueName, DWORD dwValueType, 730 const BYTE *pbValueData, DWORD cbValueData) 731 { 732 LPSTR szKey; 733 LONG rc; 734 HKEY hKey; 735 736 TRACE("%x %s %s %s %d %p %d\n", dwEncodingType, debugstr_a(pszFuncName), 737 debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData, 738 cbValueData); 739 740 if (!GET_CERT_ENCODING_TYPE(dwEncodingType)) 741 return TRUE; 742 743 if (!pszFuncName || !pszOID || !pwszValueName) 744 { 745 SetLastError(ERROR_INVALID_PARAMETER); 746 return FALSE; 747 } 748 749 szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID); 750 rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey); 751 CryptMemFree(szKey); 752 if (rc) 753 SetLastError(rc); 754 else 755 { 756 rc = RegSetValueExW(hKey, pwszValueName, 0, dwValueType, pbValueData, 757 cbValueData); 758 if (rc) 759 SetLastError(rc); 760 RegCloseKey(hKey); 761 } 762 return !rc; 763 } 764 765 static LPCWSTR CRYPT_FindStringInMultiString(LPCWSTR multi, LPCWSTR toFind) 766 { 767 LPCWSTR ret = NULL, ptr; 768 769 for (ptr = multi; ptr && *ptr && !ret; ptr += lstrlenW(ptr) + 1) 770 { 771 if (!lstrcmpiW(ptr, toFind)) 772 ret = ptr; 773 } 774 return ret; 775 } 776 777 static DWORD CRYPT_GetMultiStringCharacterLen(LPCWSTR multi) 778 { 779 DWORD ret; 780 781 if (multi) 782 { 783 LPCWSTR ptr; 784 785 /* Count terminating empty string */ 786 ret = 1; 787 for (ptr = multi; *ptr; ptr += lstrlenW(ptr) + 1) 788 ret += lstrlenW(ptr) + 1; 789 } 790 else 791 ret = 0; 792 return ret; 793 } 794 795 static LPWSTR CRYPT_AddStringToMultiString(LPWSTR multi, LPCWSTR toAdd, 796 DWORD index) 797 { 798 LPWSTR ret; 799 800 if (!multi) 801 { 802 /* FIXME: ignoring index, is that okay? */ 803 ret = CryptMemAlloc((lstrlenW(toAdd) + 2) * sizeof(WCHAR)); 804 if (ret) 805 { 806 /* copy string, including NULL terminator */ 807 memcpy(ret, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR)); 808 /* add terminating empty string */ 809 *(ret + lstrlenW(toAdd) + 1) = 0; 810 } 811 } 812 else 813 { 814 DWORD len = CRYPT_GetMultiStringCharacterLen(multi); 815 816 ret = CryptMemRealloc(multi, (len + lstrlenW(toAdd) + 1) * 817 sizeof(WCHAR)); 818 if (ret) 819 { 820 LPWSTR spotToAdd; 821 822 if (index == CRYPT_REGISTER_LAST_INDEX) 823 spotToAdd = ret + len - 1; 824 else 825 { 826 DWORD i; 827 828 /* FIXME: if index is too large for the string, toAdd is 829 * added to the end. Is that okay? 830 */ 831 for (i = 0, spotToAdd = ret; i < index && *spotToAdd; 832 spotToAdd += lstrlenW(spotToAdd) + 1) 833 ; 834 } 835 if (spotToAdd) 836 { 837 /* Copy existing string "right" */ 838 memmove(spotToAdd + lstrlenW(toAdd) + 1, spotToAdd, 839 (len - (spotToAdd - ret)) * sizeof(WCHAR)); 840 /* Copy new string */ 841 memcpy(spotToAdd, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR)); 842 } 843 else 844 { 845 CryptMemFree(ret); 846 ret = NULL; 847 } 848 } 849 } 850 return ret; 851 } 852 853 static BOOL CRYPT_RemoveStringFromMultiString(LPWSTR multi, LPCWSTR toRemove) 854 { 855 LPWSTR spotToRemove = (LPWSTR)CRYPT_FindStringInMultiString(multi, 856 toRemove); 857 BOOL ret; 858 859 if (spotToRemove) 860 { 861 DWORD len = CRYPT_GetMultiStringCharacterLen(multi); 862 863 if (spotToRemove + lstrlenW(toRemove) + 2 >= multi + len) 864 { 865 /* Removing last string in list, terminate multi string directly */ 866 *spotToRemove = 0; 867 *(spotToRemove + 1) = 0; 868 } 869 else 870 { 871 LPCWSTR nextStr = spotToRemove + lstrlenW(toRemove) + 1; 872 873 /* Copy remainder of string "left" */ 874 memmove(spotToRemove, nextStr, 875 (len - (nextStr - multi)) * sizeof(WCHAR)); 876 } 877 ret = TRUE; 878 } 879 else 880 { 881 SetLastError(ERROR_FILE_NOT_FOUND); 882 ret = FALSE; 883 } 884 return ret; 885 } 886 887 static BOOL CRYPT_GetDefaultOIDKey(DWORD dwEncodingType, LPCSTR pszFuncName, 888 PHKEY key) 889 { 890 LPSTR keyName; 891 LONG r; 892 893 keyName = CRYPT_GetKeyName(dwEncodingType, pszFuncName, "DEFAULT"); 894 TRACE("Key name is %s\n", debugstr_a(keyName)); 895 896 if (!keyName) 897 return FALSE; 898 899 r = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0, KEY_ALL_ACCESS, 900 NULL, key, NULL); 901 CryptMemFree(keyName); 902 if (r != ERROR_SUCCESS) 903 { 904 SetLastError(r); 905 return FALSE; 906 } 907 return TRUE; 908 } 909 910 static LPWSTR CRYPT_GetDefaultOIDDlls(HKEY key) 911 { 912 LONG r; 913 DWORD type, size; 914 LPWSTR dlls; 915 916 r = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size); 917 if (r == ERROR_SUCCESS && type == REG_MULTI_SZ) 918 { 919 dlls = CryptMemAlloc(size); 920 r = RegQueryValueExW(key, DllW, NULL, &type, (LPBYTE)dlls, &size); 921 if (r != ERROR_SUCCESS) 922 { 923 CryptMemFree(dlls); 924 dlls = NULL; 925 } 926 } 927 else 928 dlls = NULL; 929 return dlls; 930 } 931 932 static inline BOOL CRYPT_SetDefaultOIDDlls(HKEY key, LPCWSTR dlls) 933 { 934 DWORD len = CRYPT_GetMultiStringCharacterLen(dlls); 935 LONG r; 936 937 if ((r = RegSetValueExW(key, DllW, 0, REG_MULTI_SZ, (const BYTE *)dlls, 938 len * sizeof (WCHAR)))) 939 SetLastError(r); 940 return r == ERROR_SUCCESS; 941 } 942 943 /*********************************************************************** 944 * CryptRegisterDefaultOIDFunction (CRYPT32.@) 945 */ 946 BOOL WINAPI CryptRegisterDefaultOIDFunction(DWORD dwEncodingType, 947 LPCSTR pszFuncName, DWORD dwIndex, LPCWSTR pwszDll) 948 { 949 HKEY key; 950 LPWSTR dlls; 951 BOOL ret = FALSE; 952 953 TRACE("(%x, %s, %d, %s)\n", dwEncodingType, debugstr_a(pszFuncName), 954 dwIndex, debugstr_w(pwszDll)); 955 956 if (!pwszDll) 957 { 958 SetLastError(E_INVALIDARG); 959 return FALSE; 960 } 961 962 if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key)) 963 return FALSE; 964 965 dlls = CRYPT_GetDefaultOIDDlls(key); 966 if (CRYPT_FindStringInMultiString(dlls, pwszDll)) 967 SetLastError(ERROR_FILE_EXISTS); 968 else 969 { 970 dlls = CRYPT_AddStringToMultiString(dlls, pwszDll, dwIndex); 971 if (dlls) 972 ret = CRYPT_SetDefaultOIDDlls(key, dlls); 973 } 974 CryptMemFree(dlls); 975 RegCloseKey(key); 976 return ret; 977 } 978 979 BOOL WINAPI CryptUnregisterDefaultOIDFunction(DWORD dwEncodingType, 980 LPCSTR pszFuncName, LPCWSTR pwszDll) 981 { 982 HKEY key; 983 LPWSTR dlls; 984 BOOL ret; 985 986 TRACE("(%x, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName), 987 debugstr_w(pwszDll)); 988 989 if (!pwszDll) 990 { 991 SetLastError(E_INVALIDARG); 992 return FALSE; 993 } 994 995 if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key)) 996 return FALSE; 997 998 dlls = CRYPT_GetDefaultOIDDlls(key); 999 if ((ret = CRYPT_RemoveStringFromMultiString(dlls, pwszDll))) 1000 ret = CRYPT_SetDefaultOIDDlls(key, dlls); 1001 CryptMemFree(dlls); 1002 RegCloseKey(key); 1003 return ret; 1004 } 1005 1006 static void oid_init_localizednames(void) 1007 { 1008 unsigned int i; 1009 1010 for(i = 0; i < sizeof(LocalizedKeys)/sizeof(LPCWSTR); i++) 1011 { 1012 LoadStringW(hInstance, IDS_LOCALIZEDNAME_ROOT+i, LocalizedNames[i], 256); 1013 } 1014 } 1015 1016 /******************************************************************** 1017 * CryptFindLocalizedName (CRYPT32.@) 1018 */ 1019 LPCWSTR WINAPI CryptFindLocalizedName(LPCWSTR pwszCryptName) 1020 { 1021 unsigned int i; 1022 1023 for(i = 0; i < sizeof(LocalizedKeys)/sizeof(LPCWSTR); i++) 1024 { 1025 if(!lstrcmpiW(LocalizedKeys[i], pwszCryptName)) 1026 { 1027 return LocalizedNames[i]; 1028 } 1029 } 1030 1031 FIXME("No name for: %s - stub\n",debugstr_w(pwszCryptName)); 1032 return NULL; 1033 } 1034 1035 static CRITICAL_SECTION oidInfoCS; 1036 static CRITICAL_SECTION_DEBUG oidInfoCSDebug = 1037 { 1038 0, 0, &oidInfoCS, 1039 { &oidInfoCSDebug.ProcessLocksList, &oidInfoCSDebug.ProcessLocksList }, 1040 0, 0, { (DWORD_PTR)(__FILE__ ": oidInfoCS") } 1041 }; 1042 static CRITICAL_SECTION oidInfoCS = { &oidInfoCSDebug, -1, 0, 0, 0, 0 }; 1043 static struct list oidInfo = { &oidInfo, &oidInfo }; 1044 1045 static const WCHAR tripledes[] = { '3','d','e','s',0 }; 1046 static const WCHAR cms3deswrap[] = { 'C','M','S','3','D','E','S','w','r','a', 1047 'p',0 }; 1048 static const WCHAR cmsrc2wrap[] = { 'C','M','S','R','C','2','w','r','a','p',0 }; 1049 static const WCHAR des[] = { 'd','e','s',0 }; 1050 static const WCHAR md2[] = { 'm','d','2',0 }; 1051 static const WCHAR md4[] = { 'm','d','4',0 }; 1052 static const WCHAR md5[] = { 'm','d','5',0 }; 1053 static const WCHAR rc2[] = { 'r','c','2',0 }; 1054 static const WCHAR rc4[] = { 'r','c','4',0 }; 1055 static const WCHAR sha[] = { 's','h','a',0 }; 1056 static const WCHAR sha1[] = { 's','h','a','1',0 }; 1057 static const WCHAR sha256[] = { 's','h','a','2','5','6',0 }; 1058 static const WCHAR sha384[] = { 's','h','a','3','8','4',0 }; 1059 static const WCHAR sha512[] = { 's','h','a','5','1','2',0 }; 1060 static const WCHAR RSA[] = { 'R','S','A',0 }; 1061 static const WCHAR RSA_KEYX[] = { 'R','S','A','_','K','E','Y','X',0 }; 1062 static const WCHAR RSA_SIGN[] = { 'R','S','A','_','S','I','G','N',0 }; 1063 static const WCHAR DSA[] = { 'D','S','A',0 }; 1064 static const WCHAR DSA_SIGN[] = { 'D','S','A','_','S','I','G','N',0 }; 1065 static const WCHAR DH[] = { 'D','H',0 }; 1066 static const WCHAR DSS[] = { 'D','S','S',0 }; 1067 static const WCHAR mosaicKMandUpdSig[] = 1068 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 }; 1069 static const WCHAR ESDH[] = { 'E','S','D','H',0 }; 1070 static const WCHAR NO_SIGN[] = { 'N','O','S','I','G','N',0 }; 1071 static const WCHAR dsaSHA1[] = { 'd','s','a','S','H','A','1',0 }; 1072 static const WCHAR md2RSA[] = { 'm','d','2','R','S','A',0 }; 1073 static const WCHAR md4RSA[] = { 'm','d','4','R','S','A',0 }; 1074 static const WCHAR md5RSA[] = { 'm','d','5','R','S','A',0 }; 1075 static const WCHAR shaDSA[] = { 's','h','a','D','S','A',0 }; 1076 static const WCHAR sha1DSA[] = { 's','h','a','1','D','S','A',0 }; 1077 static const WCHAR shaRSA[] = { 's','h','a','R','S','A',0 }; 1078 static const WCHAR sha1RSA[] = { 's','h','a','1','R','S','A',0 }; 1079 static const WCHAR sha256RSA[] = { 's','h','a','2','5','6','R','S','A',0 }; 1080 static const WCHAR sha384RSA[] = { 's','h','a','3','8','4','R','S','A',0 }; 1081 static const WCHAR sha512RSA[] = { 's','h','a','5','1','2','R','S','A',0 }; 1082 static const WCHAR mosaicUpdatedSig[] = 1083 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 }; 1084 static const WCHAR sha256ECDSA[] = { 's','h','a','2','5','6','E','C','D','S','A',0 }; 1085 static const WCHAR sha384ECDSA[] = { 's','h','a','3','8','4','E','C','D','S','A',0 }; 1086 static const WCHAR CN[] = { 'C','N',0 }; 1087 static const WCHAR L[] = { 'L',0 }; 1088 static const WCHAR O[] = { 'O',0 }; 1089 static const WCHAR OU[] = { 'O','U',0 }; 1090 static const WCHAR E[] = { 'E',0 }; 1091 static const WCHAR C[] = { 'C',0 }; 1092 static const WCHAR S[] = { 'S',0 }; 1093 static const WCHAR ST[] = { 'S','T',0 }; 1094 static const WCHAR STREET[] = { 'S','T','R','E','E','T',0 }; 1095 static const WCHAR T[] = { 'T',0 }; 1096 static const WCHAR Title[] = { 'T','i','t','l','e',0 }; 1097 static const WCHAR G[] = { 'G',0 }; 1098 static const WCHAR GivenName[] = { 'G','i','v','e','n','N','a','m','e',0 }; 1099 static const WCHAR I[] = { 'I',0 }; 1100 static const WCHAR Initials[] = { 'I','n','i','t','i','a','l','s',0 }; 1101 static const WCHAR SN[] = { 'S','N',0 }; 1102 static const WCHAR DC[] = { 'D','C',0 }; 1103 static const WCHAR Description[] = 1104 { 'D','e','s','c','r','i','p','t','i','o','n',0 }; 1105 static const WCHAR PostalCode[] = { 'P','o','s','t','a','l','C','o','d','e',0 }; 1106 static const WCHAR POBox[] = { 'P','O','B','o','x',0 }; 1107 static const WCHAR Phone[] = { 'P','h','o','n','e',0 }; 1108 static const WCHAR X21Address[] = { 'X','2','1','A','d','d','r','e','s','s',0 }; 1109 static const WCHAR dnQualifier[] = 1110 { 'd','n','Q','u','a','l','i','f','i','e','r',0 }; 1111 static const WCHAR SpcSpAgencyInfo[] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 }; 1112 static const WCHAR SpcFinancialCriteria[] = { 'S','p','c','F','i','n','a','n','c','i','a','l','C','r','i','t','e','r','i','a',0 }; 1113 static const WCHAR SpcMinimalCriteria[] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 }; 1114 static const WCHAR Email[] = { 'E','m','a','i','l',0 }; 1115 static const WCHAR GN[] = { 'G','N',0 }; 1116 static const WCHAR SERIALNUMBER[] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 }; 1117 1118 static const DWORD noNullFlag = CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG; 1119 static const DWORD mosaicFlags = CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG | 1120 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG; 1121 static const CRYPT_DATA_BLOB noNullBlob = { sizeof(noNullFlag), 1122 (LPBYTE)&noNullFlag }; 1123 static const CRYPT_DATA_BLOB mosaicFlagsBlob = { sizeof(mosaicFlags), 1124 (LPBYTE)&mosaicFlags }; 1125 1126 static const DWORD rsaSign = CALG_RSA_SIGN; 1127 static const DWORD dssSign[2] = { CALG_DSS_SIGN, 1128 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }; 1129 static const DWORD mosaicSign[2] = { CALG_DSS_SIGN, 1130 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG | 1131 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }; 1132 static const DWORD ecdsaSign[2] = { CALG_OID_INFO_PARAMETERS, 1133 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }; 1134 static const CRYPT_DATA_BLOB rsaSignBlob = { sizeof(rsaSign), 1135 (LPBYTE)&rsaSign }; 1136 static const CRYPT_DATA_BLOB dssSignBlob = { sizeof(dssSign), 1137 (LPBYTE)dssSign }; 1138 static const CRYPT_DATA_BLOB mosaicSignBlob = { sizeof(mosaicSign), 1139 (LPBYTE)mosaicSign }; 1140 static const CRYPT_DATA_BLOB ecdsaSignBlob = { sizeof(ecdsaSign), 1141 (LPBYTE)ecdsaSign }; 1142 1143 static const DWORD ia5String[] = { CERT_RDN_IA5_STRING, 0 }; 1144 static const DWORD numericString[] = { CERT_RDN_NUMERIC_STRING, 0 }; 1145 static const DWORD printableString[] = { CERT_RDN_PRINTABLE_STRING, 0 }; 1146 static const DWORD domainCompTypes[] = { CERT_RDN_IA5_STRING, 1147 CERT_RDN_UTF8_STRING, 0 }; 1148 static const CRYPT_DATA_BLOB ia5StringBlob = { sizeof(ia5String), 1149 (LPBYTE)ia5String }; 1150 static const CRYPT_DATA_BLOB numericStringBlob = { sizeof(numericString), 1151 (LPBYTE)numericString }; 1152 static const CRYPT_DATA_BLOB printableStringBlob = { sizeof(printableString), 1153 (LPBYTE)printableString }; 1154 static const CRYPT_DATA_BLOB domainCompTypesBlob = { sizeof(domainCompTypes), 1155 (LPBYTE)domainCompTypes }; 1156 1157 static const struct OIDInfoConstructor { 1158 DWORD dwGroupId; 1159 LPCSTR pszOID; 1160 UINT Algid; 1161 LPCWSTR pwszName; 1162 const CRYPT_DATA_BLOB *blob; 1163 LPCWSTR pwszCNGAlgid; 1164 LPCWSTR pwszCNGExtraAlgid; 1165 } oidInfoConstructors[] = { 1166 { 1, szOID_OIWSEC_sha1, CALG_SHA1, sha1, NULL }, 1167 { 1, szOID_OIWSEC_sha1, CALG_SHA1, sha, NULL }, 1168 { 1, szOID_OIWSEC_sha, CALG_SHA, sha, NULL }, 1169 { 1, szOID_RSA_MD5, CALG_MD5, md5, NULL }, 1170 { 1, szOID_RSA_MD4, CALG_MD4, md4, NULL }, 1171 { 1, szOID_RSA_MD2, CALG_MD2, md2, NULL }, 1172 /* NOTE: Windows Vista+ uses -1 instead of CALG_SHA_* following SHA entries. */ 1173 { 1, szOID_NIST_sha256, CALG_SHA_256, sha256, NULL }, 1174 { 1, szOID_NIST_sha384, CALG_SHA_384, sha384, NULL }, 1175 { 1, szOID_NIST_sha512, CALG_SHA_512, sha512, NULL }, 1176 1177 { 2, szOID_OIWSEC_desCBC, CALG_DES, des, NULL }, 1178 { 2, szOID_RSA_DES_EDE3_CBC, CALG_3DES, tripledes, NULL }, 1179 { 2, szOID_RSA_RC2CBC, CALG_RC2, rc2, NULL }, 1180 { 2, szOID_RSA_RC4, CALG_RC4, rc4, NULL }, 1181 { 2, szOID_RSA_SMIMEalgCMS3DESwrap, CALG_3DES, cms3deswrap, NULL }, 1182 { 2, szOID_RSA_SMIMEalgCMSRC2wrap, CALG_RC2, cmsrc2wrap, NULL }, 1183 1184 { 3, szOID_RSA_RSA, CALG_RSA_KEYX, RSA, NULL }, 1185 { 3, szOID_X957_DSA, CALG_DSS_SIGN, DSA, &noNullBlob }, 1186 { 3, szOID_ANSI_X942_DH, CALG_DH_SF, DH, &noNullBlob }, 1187 { 3, szOID_RSA_RSA, CALG_RSA_KEYX, RSA_KEYX, NULL }, 1188 { 3, szOID_RSA_RSA, CALG_RSA_SIGN, RSA, NULL }, 1189 { 3, szOID_RSA_RSA, CALG_RSA_SIGN, RSA_SIGN, NULL }, 1190 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSA, &noNullBlob }, 1191 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSS, &noNullBlob }, 1192 { 3, szOID_OIWSEC_dsa, CALG_DSS_SIGN, DSA_SIGN, &noNullBlob }, 1193 { 3, szOID_RSA_DH, CALG_DH_SF, DH, &noNullBlob }, 1194 { 3, szOID_OIWSEC_rsaXchg, CALG_RSA_KEYX, RSA_KEYX, NULL }, 1195 { 3, szOID_INFOSEC_mosaicKMandUpdSig, CALG_DSS_SIGN, mosaicKMandUpdSig, 1196 &mosaicFlagsBlob }, 1197 { 3, szOID_RSA_SMIMEalgESDH, CALG_DH_EPHEM, ESDH, &noNullBlob }, 1198 { 3, szOID_PKIX_NO_SIGNATURE, CALG_NO_SIGN, NO_SIGN, NULL }, 1199 1200 { 4, szOID_RSA_SHA1RSA, CALG_SHA1, sha1RSA, &rsaSignBlob }, 1201 { 4, szOID_RSA_SHA256RSA, CALG_SHA_256, sha256RSA, &rsaSignBlob }, 1202 { 4, szOID_RSA_SHA384RSA, CALG_SHA_384, sha384RSA, &rsaSignBlob }, 1203 { 4, szOID_RSA_SHA512RSA, CALG_SHA_512, sha512RSA, &rsaSignBlob }, 1204 { 4, szOID_RSA_MD5RSA, CALG_MD5, md5RSA, &rsaSignBlob }, 1205 { 4, szOID_X957_SHA1DSA, CALG_SHA1, sha1DSA, &dssSignBlob }, 1206 { 4, szOID_OIWSEC_sha1RSASign, CALG_SHA1, sha1RSA, &rsaSignBlob }, 1207 { 4, szOID_OIWSEC_sha1RSASign, CALG_SHA1, shaRSA, &rsaSignBlob }, 1208 { 4, szOID_OIWSEC_shaRSA, CALG_SHA1, shaRSA, &rsaSignBlob }, 1209 { 4, szOID_OIWSEC_md5RSA, CALG_MD5, md5RSA, &rsaSignBlob }, 1210 { 4, szOID_RSA_MD2RSA, CALG_MD2, md2RSA, &rsaSignBlob }, 1211 { 4, szOID_RSA_MD4RSA, CALG_MD4, md4RSA, &rsaSignBlob }, 1212 { 4, szOID_OIWSEC_md4RSA, CALG_MD4, md4RSA, &rsaSignBlob }, 1213 { 4, szOID_OIWSEC_md4RSA2, CALG_MD4, md4RSA, &rsaSignBlob }, 1214 { 4, szOID_OIWDIR_md2RSA, CALG_MD2, md2RSA, &rsaSignBlob }, 1215 { 4, szOID_OIWSEC_shaDSA, CALG_SHA1, sha1DSA, &dssSignBlob }, 1216 { 4, szOID_OIWSEC_shaDSA, CALG_SHA1, shaDSA, &dssSignBlob }, 1217 { 4, szOID_OIWSEC_dsaSHA1, CALG_SHA1, dsaSHA1, &dssSignBlob }, 1218 { 4, szOID_INFOSEC_mosaicUpdatedSig, CALG_SHA1, mosaicUpdatedSig, 1219 &mosaicSignBlob }, 1220 { 4, szOID_ECDSA_SHA256, CALG_OID_INFO_CNG_ONLY, sha256ECDSA, &ecdsaSignBlob, 1221 BCRYPT_SHA256_ALGORITHM, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM }, 1222 { 4, szOID_ECDSA_SHA384, CALG_OID_INFO_CNG_ONLY, sha384ECDSA, &ecdsaSignBlob, 1223 BCRYPT_SHA384_ALGORITHM, CRYPT_OID_INFO_ECC_PARAMETERS_ALGORITHM }, 1224 1225 { 5, szOID_COMMON_NAME, 0, CN, NULL }, 1226 { 5, szOID_LOCALITY_NAME, 0, L, NULL }, 1227 { 5, szOID_ORGANIZATION_NAME, 0, O, NULL }, 1228 { 5, szOID_ORGANIZATIONAL_UNIT_NAME, 0, OU, NULL }, 1229 { 5, szOID_RSA_emailAddr, 0, E, &ia5StringBlob }, 1230 { 5, szOID_RSA_emailAddr, 0, Email, &ia5StringBlob }, 1231 { 5, szOID_COUNTRY_NAME, 0, C, &printableStringBlob }, 1232 { 5, szOID_STATE_OR_PROVINCE_NAME, 0, S, NULL }, 1233 { 5, szOID_STATE_OR_PROVINCE_NAME, 0, ST, NULL }, 1234 { 5, szOID_STREET_ADDRESS, 0, STREET, NULL }, 1235 { 5, szOID_TITLE, 0, T, NULL }, 1236 { 5, szOID_TITLE, 0, Title, NULL }, 1237 { 5, szOID_GIVEN_NAME, 0, G, NULL }, 1238 { 5, szOID_GIVEN_NAME, 0, GN, NULL }, 1239 { 5, szOID_GIVEN_NAME, 0, GivenName, NULL }, 1240 { 5, szOID_INITIALS, 0, I, NULL }, 1241 { 5, szOID_INITIALS, 0, Initials, NULL }, 1242 { 5, szOID_SUR_NAME, 0, SN, NULL }, 1243 { 5, szOID_DOMAIN_COMPONENT, 0, DC, &domainCompTypesBlob }, 1244 { 5, szOID_DESCRIPTION, 0, Description, NULL }, 1245 { 5, szOID_POSTAL_CODE, 0, PostalCode, NULL }, 1246 { 5, szOID_POST_OFFICE_BOX, 0, POBox, NULL }, 1247 { 5, szOID_TELEPHONE_NUMBER, 0, Phone, &printableStringBlob }, 1248 { 5, szOID_X21_ADDRESS, 0, X21Address, &numericStringBlob }, 1249 { 5, szOID_DN_QUALIFIER, 0, dnQualifier, NULL }, 1250 { 5, szOID_DEVICE_SERIAL_NUMBER, 0, SERIALNUMBER, NULL }, 1251 1252 { 6, szOID_AUTHORITY_KEY_IDENTIFIER2, 0, (LPCWSTR)IDS_AUTHORITY_KEY_ID, NULL }, 1253 { 6, szOID_AUTHORITY_KEY_IDENTIFIER, 0, (LPCWSTR)IDS_AUTHORITY_KEY_ID, NULL }, 1254 { 6, szOID_KEY_ATTRIBUTES, 0, (LPCWSTR)IDS_KEY_ATTRIBUTES, NULL }, 1255 { 6, szOID_KEY_USAGE_RESTRICTION, 0, (LPCWSTR)IDS_KEY_USAGE_RESTRICTION, NULL }, 1256 { 6, szOID_SUBJECT_ALT_NAME2, 0, (LPCWSTR)IDS_SUBJECT_ALT_NAME, NULL }, 1257 { 6, szOID_SUBJECT_ALT_NAME, 0, (LPCWSTR)IDS_SUBJECT_ALT_NAME, NULL }, 1258 { 6, szOID_ISSUER_ALT_NAME2, 0, (LPCWSTR)IDS_ISSUER_ALT_NAME, NULL }, 1259 { 6, szOID_ISSUER_ALT_NAME2, 0, (LPCWSTR)IDS_ISSUER_ALT_NAME, NULL }, 1260 { 6, szOID_BASIC_CONSTRAINTS2, 0, (LPCWSTR)IDS_BASIC_CONSTRAINTS, NULL }, 1261 { 6, szOID_BASIC_CONSTRAINTS, 0, (LPCWSTR)IDS_BASIC_CONSTRAINTS, NULL }, 1262 { 6, szOID_KEY_USAGE, 0, (LPCWSTR)IDS_KEY_USAGE, NULL }, 1263 { 6, szOID_CERT_POLICIES, 0, (LPCWSTR)IDS_CERT_POLICIES, NULL }, 1264 { 6, szOID_SUBJECT_KEY_IDENTIFIER, 0, (LPCWSTR)IDS_SUBJECT_KEY_IDENTIFIER, NULL }, 1265 { 6, szOID_CRL_REASON_CODE, 0, (LPCWSTR)IDS_CRL_REASON_CODE, NULL }, 1266 { 6, szOID_CRL_DIST_POINTS, 0, (LPCWSTR)IDS_CRL_DIST_POINTS, NULL }, 1267 { 6, szOID_ENHANCED_KEY_USAGE, 0, (LPCWSTR)IDS_ENHANCED_KEY_USAGE, NULL }, 1268 { 6, szOID_AUTHORITY_INFO_ACCESS, 0, (LPCWSTR)IDS_AUTHORITY_INFO_ACCESS, NULL }, 1269 { 6, szOID_CERT_EXTENSIONS, 0, (LPCWSTR)IDS_CERT_EXTENSIONS, NULL }, 1270 { 6, szOID_RSA_certExtensions, 0, (LPCWSTR)IDS_CERT_EXTENSIONS, NULL }, 1271 { 6, szOID_NEXT_UPDATE_LOCATION, 0, (LPCWSTR)IDS_NEXT_UPDATE_LOCATION, NULL }, 1272 { 6, szOID_YESNO_TRUST_ATTR, 0, (LPCWSTR)IDS_YES_OR_NO_TRUST, NULL }, 1273 { 6, szOID_RSA_emailAddr, 0, (LPCWSTR)IDS_EMAIL_ADDRESS, NULL }, 1274 { 6, szOID_RSA_unstructName, 0, (LPCWSTR)IDS_UNSTRUCTURED_NAME, NULL }, 1275 { 6, szOID_RSA_contentType, 0, (LPCWSTR)IDS_CONTENT_TYPE, NULL }, 1276 { 6, szOID_RSA_messageDigest, 0, (LPCWSTR)IDS_MESSAGE_DIGEST, NULL }, 1277 { 6, szOID_RSA_signingTime, 0, (LPCWSTR)IDS_SIGNING_TIME, NULL }, 1278 { 6, szOID_RSA_counterSign, 0, (LPCWSTR)IDS_COUNTER_SIGN, NULL }, 1279 { 6, szOID_RSA_challengePwd, 0, (LPCWSTR)IDS_CHALLENGE_PASSWORD, NULL }, 1280 { 6, szOID_RSA_unstructAddr, 0, (LPCWSTR)IDS_UNSTRUCTURED_ADDRESS, NULL }, 1281 { 6, szOID_RSA_SMIMECapabilities, 0, (LPCWSTR)IDS_SMIME_CAPABILITIES, NULL }, 1282 { 6, szOID_RSA_preferSignedData, 0, (LPCWSTR)IDS_PREFER_SIGNED_DATA, NULL }, 1283 { 6, szOID_PKIX_POLICY_QUALIFIER_CPS, 0, (LPCWSTR)IDS_CPS, NULL }, 1284 { 6, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE, 0, (LPCWSTR)IDS_USER_NOTICE, NULL }, 1285 { 6, szOID_PKIX_OCSP, 0, (LPCWSTR)IDS_OCSP, NULL }, 1286 { 6, szOID_PKIX_CA_ISSUERS, 0, (LPCWSTR)IDS_CA_ISSUER, NULL }, 1287 { 6, szOID_ENROLL_CERTTYPE_EXTENSION, 0, (LPCWSTR)IDS_CERT_TEMPLATE_NAME, NULL }, 1288 { 6, szOID_ENROLL_CERTTYPE_EXTENSION, 0, (LPCWSTR)IDS_CERT_TYPE, NULL }, 1289 { 6, szOID_CERT_MANIFOLD, 0, (LPCWSTR)IDS_CERT_MANIFOLD, NULL }, 1290 { 6, szOID_NETSCAPE_CERT_TYPE, 0, (LPCWSTR)IDS_NETSCAPE_CERT_TYPE, NULL }, 1291 { 6, szOID_NETSCAPE_BASE_URL, 0, (LPCWSTR)IDS_NETSCAPE_BASE_URL, NULL }, 1292 { 6, szOID_NETSCAPE_REVOCATION_URL, 0, (LPCWSTR)IDS_NETSCAPE_REVOCATION_URL, NULL }, 1293 { 6, szOID_NETSCAPE_CA_REVOCATION_URL, 0, (LPCWSTR)IDS_NETSCAPE_CA_REVOCATION_URL, NULL }, 1294 { 6, szOID_NETSCAPE_CERT_RENEWAL_URL, 0, (LPCWSTR)IDS_NETSCAPE_CERT_RENEWAL_URL, NULL }, 1295 { 6, szOID_NETSCAPE_CA_POLICY_URL, 0, (LPCWSTR)IDS_NETSCAPE_CA_POLICY_URL, NULL }, 1296 { 6, szOID_NETSCAPE_SSL_SERVER_NAME, 0, (LPCWSTR)IDS_NETSCAPE_SSL_SERVER_NAME, NULL }, 1297 { 6, szOID_NETSCAPE_COMMENT, 0, (LPCWSTR)IDS_NETSCAPE_COMMENT, NULL }, 1298 { 6, "1.3.6.1.4.1.311.2.1.10", 0, SpcSpAgencyInfo, NULL }, 1299 { 6, "1.3.6.1.4.1.311.2.1.27", 0, SpcFinancialCriteria, NULL }, 1300 { 6, "1.3.6.1.4.1.311.2.1.26", 0, SpcMinimalCriteria, NULL }, 1301 { 6, szOID_COUNTRY_NAME, 0, (LPCWSTR)IDS_COUNTRY, NULL }, 1302 { 6, szOID_ORGANIZATION_NAME, 0, (LPCWSTR)IDS_ORGANIZATION, NULL }, 1303 { 6, szOID_ORGANIZATIONAL_UNIT_NAME, 0, (LPCWSTR)IDS_ORGANIZATIONAL_UNIT, NULL }, 1304 { 6, szOID_COMMON_NAME, 0, (LPCWSTR)IDS_COMMON_NAME, NULL }, 1305 { 6, szOID_LOCALITY_NAME, 0, (LPCWSTR)IDS_LOCALITY, NULL }, 1306 { 6, szOID_STATE_OR_PROVINCE_NAME, 0, (LPCWSTR)IDS_STATE_OR_PROVINCE, NULL }, 1307 { 6, szOID_TITLE, 0, (LPCWSTR)IDS_TITLE, NULL }, 1308 { 6, szOID_GIVEN_NAME, 0, (LPCWSTR)IDS_GIVEN_NAME, NULL }, 1309 { 6, szOID_INITIALS, 0, (LPCWSTR)IDS_INITIALS, NULL }, 1310 { 6, szOID_SUR_NAME, 0, (LPCWSTR)IDS_SUR_NAME, NULL }, 1311 { 6, szOID_DOMAIN_COMPONENT, 0, (LPCWSTR)IDS_DOMAIN_COMPONENT, NULL }, 1312 { 6, szOID_STREET_ADDRESS, 0, (LPCWSTR)IDS_STREET_ADDRESS, NULL }, 1313 { 6, szOID_DEVICE_SERIAL_NUMBER, 0, (LPCWSTR)IDS_SERIAL_NUMBER, NULL }, 1314 { 6, szOID_CERTSRV_CA_VERSION, 0, (LPCWSTR)IDS_CA_VERSION, NULL }, 1315 { 6, szOID_CERTSRV_CROSSCA_VERSION, 0, (LPCWSTR)IDS_CROSS_CA_VERSION, NULL }, 1316 { 6, szOID_SERIALIZED, 0, (LPCWSTR)IDS_SERIALIZED_SIG_SERIAL_NUMBER, NULL }, 1317 { 6, szOID_NT_PRINCIPAL_NAME, 0, (LPCWSTR)IDS_PRINCIPAL_NAME, NULL }, 1318 { 6, szOID_PRODUCT_UPDATE, 0, (LPCWSTR)IDS_WINDOWS_PRODUCT_UPDATE, NULL }, 1319 { 6, szOID_ENROLLMENT_NAME_VALUE_PAIR, 0, (LPCWSTR)IDS_ENROLLMENT_NAME_VALUE_PAIR, NULL }, 1320 { 6, szOID_OS_VERSION, 0, (LPCWSTR)IDS_OS_VERSION, NULL }, 1321 { 6, szOID_ENROLLMENT_CSP_PROVIDER, 0, (LPCWSTR)IDS_ENROLLMENT_CSP, NULL }, 1322 { 6, szOID_CRL_NUMBER, 0, (LPCWSTR)IDS_CRL_NUMBER, NULL }, 1323 { 6, szOID_DELTA_CRL_INDICATOR, 0, (LPCWSTR)IDS_DELTA_CRL_INDICATOR, NULL }, 1324 { 6, szOID_ISSUING_DIST_POINT, 0, (LPCWSTR)IDS_ISSUING_DIST_POINT, NULL }, 1325 { 6, szOID_FRESHEST_CRL, 0, (LPCWSTR)IDS_FRESHEST_CRL, NULL }, 1326 { 6, szOID_NAME_CONSTRAINTS, 0, (LPCWSTR)IDS_NAME_CONSTRAINTS, NULL }, 1327 { 6, szOID_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_POLICY_MAPPINGS, NULL }, 1328 { 6, szOID_LEGACY_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_POLICY_MAPPINGS, NULL }, 1329 { 6, szOID_POLICY_CONSTRAINTS, 0, (LPCWSTR)IDS_POLICY_CONSTRAINTS, NULL }, 1330 { 6, szOID_CROSS_CERT_DIST_POINTS, 0, (LPCWSTR)IDS_CROSS_CERT_DIST_POINTS, NULL }, 1331 { 6, szOID_APPLICATION_CERT_POLICIES, 0, (LPCWSTR)IDS_APPLICATION_POLICIES, NULL }, 1332 { 6, szOID_APPLICATION_POLICY_MAPPINGS, 0, (LPCWSTR)IDS_APPLICATION_POLICY_MAPPINGS, NULL }, 1333 { 6, szOID_APPLICATION_POLICY_CONSTRAINTS, 0, (LPCWSTR)IDS_APPLICATION_POLICY_CONSTRAINTS, NULL }, 1334 { 6, szOID_CT_PKI_DATA, 0, (LPCWSTR)IDS_CMC_DATA, NULL }, 1335 { 6, szOID_CT_PKI_RESPONSE, 0, (LPCWSTR)IDS_CMC_RESPONSE, NULL }, 1336 { 6, szOID_CMC, 0, (LPCWSTR)IDS_UNSIGNED_CMC_REQUEST, NULL }, 1337 { 6, szOID_CMC_STATUS_INFO, 0, (LPCWSTR)IDS_CMC_STATUS_INFO, NULL }, 1338 { 6, szOID_CMC_ADD_EXTENSIONS, 0, (LPCWSTR)IDS_CMC_EXTENSIONS, NULL }, 1339 { 6, szOID_CTL, 0, (LPCWSTR)IDS_CMC_ATTRIBUTES, NULL }, 1340 { 6, szOID_RSA_data, 0, (LPCWSTR)IDS_PKCS_7_DATA, NULL }, 1341 { 6, szOID_RSA_signedData, 0, (LPCWSTR)IDS_PKCS_7_SIGNED, NULL }, 1342 { 6, szOID_RSA_envelopedData, 0, (LPCWSTR)IDS_PKCS_7_ENVELOPED, NULL }, 1343 { 6, szOID_RSA_signEnvData, 0, (LPCWSTR)IDS_PKCS_7_SIGNED_ENVELOPED, NULL }, 1344 { 6, szOID_RSA_digestedData, 0, (LPCWSTR)IDS_PKCS_7_DIGESTED, NULL }, 1345 { 6, szOID_RSA_encryptedData, 0, (LPCWSTR)IDS_PKCS_7_ENCRYPTED, NULL }, 1346 { 6, szOID_CERTSRV_PREVIOUS_CERT_HASH, 0, (LPCWSTR)IDS_PREVIOUS_CA_CERT_HASH, NULL }, 1347 { 6, szOID_CRL_VIRTUAL_BASE, 0, (LPCWSTR)IDS_CRL_VIRTUAL_BASE, NULL }, 1348 { 6, szOID_CRL_NEXT_PUBLISH, 0, (LPCWSTR)IDS_CRL_NEXT_PUBLISH, NULL }, 1349 { 6, szOID_KP_CA_EXCHANGE, 0, (LPCWSTR)IDS_CA_EXCHANGE, NULL }, 1350 { 6, szOID_KP_KEY_RECOVERY_AGENT, 0, (LPCWSTR)IDS_KEY_RECOVERY_AGENT, NULL }, 1351 { 6, szOID_CERTIFICATE_TEMPLATE, 0, (LPCWSTR)IDS_CERTIFICATE_TEMPLATE, NULL }, 1352 { 6, szOID_ENTERPRISE_OID_ROOT, 0, (LPCWSTR)IDS_ENTERPRISE_ROOT_OID, NULL }, 1353 { 6, szOID_RDN_DUMMY_SIGNER, 0, (LPCWSTR)IDS_RDN_DUMMY_SIGNER, NULL }, 1354 { 6, szOID_ARCHIVED_KEY_ATTR, 0, (LPCWSTR)IDS_ARCHIVED_KEY_ATTR, NULL }, 1355 { 6, szOID_CRL_SELF_CDP, 0, (LPCWSTR)IDS_CRL_SELF_CDP, NULL }, 1356 { 6, szOID_REQUIRE_CERT_CHAIN_POLICY, 0, (LPCWSTR)IDS_REQUIRE_CERT_CHAIN_POLICY, NULL }, 1357 { 6, szOID_CMC_TRANSACTION_ID, 0, (LPCWSTR)IDS_TRANSACTION_ID, NULL }, 1358 { 6, szOID_CMC_SENDER_NONCE, 0, (LPCWSTR)IDS_SENDER_NONCE, NULL }, 1359 { 6, szOID_CMC_RECIPIENT_NONCE, 0, (LPCWSTR)IDS_RECIPIENT_NONCE, NULL }, 1360 { 6, szOID_CMC_REG_INFO, 0, (LPCWSTR)IDS_REG_INFO, NULL }, 1361 { 6, szOID_CMC_GET_CERT, 0, (LPCWSTR)IDS_GET_CERTIFICATE, NULL }, 1362 { 6, szOID_CMC_GET_CRL, 0, (LPCWSTR)IDS_GET_CRL, NULL }, 1363 { 6, szOID_CMC_REVOKE_REQUEST, 0, (LPCWSTR)IDS_REVOKE_REQUEST, NULL }, 1364 { 6, szOID_CMC_QUERY_PENDING, 0, (LPCWSTR)IDS_QUERY_PENDING, NULL }, 1365 { 6, szOID_SORTED_CTL, 0, (LPCWSTR)IDS_SORTED_CTL, NULL }, 1366 { 6, szOID_ARCHIVED_KEY_CERT_HASH, 0, (LPCWSTR)IDS_ARCHIVED_KEY_CERT_HASH, NULL }, 1367 { 6, szOID_PRIVATEKEY_USAGE_PERIOD, 0, (LPCWSTR)IDS_PRIVATE_KEY_USAGE_PERIOD, NULL }, 1368 { 6, szOID_REQUEST_CLIENT_INFO, 0, (LPCWSTR)IDS_CLIENT_INFORMATION, NULL }, 1369 1370 { 7, szOID_PKIX_KP_SERVER_AUTH, 0, (LPCWSTR)IDS_SERVER_AUTHENTICATION, NULL }, 1371 { 7, szOID_PKIX_KP_CLIENT_AUTH, 0, (LPCWSTR)IDS_CLIENT_AUTHENTICATION, NULL }, 1372 { 7, szOID_PKIX_KP_CODE_SIGNING, 0, (LPCWSTR)IDS_CODE_SIGNING, NULL }, 1373 { 7, szOID_PKIX_KP_EMAIL_PROTECTION, 0, (LPCWSTR)IDS_SECURE_EMAIL, NULL }, 1374 { 7, szOID_PKIX_KP_TIMESTAMP_SIGNING, 0, (LPCWSTR)IDS_TIME_STAMPING, NULL }, 1375 { 7, szOID_KP_CTL_USAGE_SIGNING, 0, (LPCWSTR)IDS_MICROSOFT_TRUST_LIST_SIGNING, NULL }, 1376 { 7, szOID_KP_TIME_STAMP_SIGNING, 0, (LPCWSTR)IDS_MICROSOFT_TIME_STAMPING, NULL }, 1377 { 7, szOID_PKIX_KP_IPSEC_END_SYSTEM, 0, (LPCWSTR)IDS_IPSEC_END_SYSTEM, NULL }, 1378 { 7, szOID_PKIX_KP_IPSEC_TUNNEL, 0, (LPCWSTR)IDS_IPSEC_TUNNEL, NULL }, 1379 { 7, szOID_PKIX_KP_IPSEC_USER, 0, (LPCWSTR)IDS_IPSEC_USER, NULL }, 1380 { 7, szOID_KP_EFS, 0, (LPCWSTR)IDS_EFS, NULL }, 1381 { 7, szOID_WHQL_CRYPTO, 0, (LPCWSTR)IDS_WHQL_CRYPTO, NULL }, 1382 { 7, szOID_NT5_CRYPTO, 0, (LPCWSTR)IDS_NT5_CRYPTO, NULL }, 1383 { 7, szOID_OEM_WHQL_CRYPTO, 0, (LPCWSTR)IDS_OEM_WHQL_CRYPTO, NULL }, 1384 { 7, szOID_EMBEDDED_NT_CRYPTO, 0, (LPCWSTR)IDS_EMBEDDED_NT_CRYPTO, NULL }, 1385 { 7, szOID_LICENSES, 0, (LPCWSTR)IDS_KEY_PACK_LICENSES, NULL }, 1386 { 7, szOID_LICENSE_SERVER, 0, (LPCWSTR)IDS_LICENSE_SERVER, NULL }, 1387 { 7, szOID_KP_SMARTCARD_LOGON, 0, (LPCWSTR)IDS_SMART_CARD_LOGON, NULL }, 1388 { 7, szOID_DRM, 0, (LPCWSTR)IDS_DIGITAL_RIGHTS, NULL }, 1389 { 7, szOID_KP_QUALIFIED_SUBORDINATION, 0, (LPCWSTR)IDS_QUALIFIED_SUBORDINATION, NULL }, 1390 { 7, szOID_KP_KEY_RECOVERY, 0, (LPCWSTR)IDS_KEY_RECOVERY, NULL }, 1391 { 7, szOID_KP_DOCUMENT_SIGNING, 0, (LPCWSTR)IDS_DOCUMENT_SIGNING, NULL }, 1392 { 7, szOID_IPSEC_KP_IKE_INTERMEDIATE, 0, (LPCWSTR)IDS_IPSEC_IKE_INTERMEDIATE, NULL }, 1393 { 7, szOID_EFS_RECOVERY, 0, (LPCWSTR)IDS_FILE_RECOVERY, NULL }, 1394 { 7, szOID_ROOT_LIST_SIGNER, 0, (LPCWSTR)IDS_ROOT_LIST_SIGNER, NULL }, 1395 { 7, szOID_ANY_APPLICATION_POLICY, 0, (LPCWSTR)IDS_ANY_APPLICATION_POLICIES, NULL }, 1396 { 7, szOID_DS_EMAIL_REPLICATION, 0, (LPCWSTR)IDS_DS_EMAIL_REPLICATION, NULL }, 1397 { 7, szOID_ENROLLMENT_AGENT, 0, (LPCWSTR)IDS_ENROLLMENT_AGENT, NULL }, 1398 { 7, szOID_KP_KEY_RECOVERY_AGENT, 0, (LPCWSTR)IDS_KEY_RECOVERY_AGENT, NULL }, 1399 { 7, szOID_KP_CA_EXCHANGE, 0, (LPCWSTR)IDS_CA_EXCHANGE, NULL }, 1400 { 7, szOID_KP_LIFETIME_SIGNING, 0, (LPCWSTR)IDS_LIFETIME_SIGNING, NULL }, 1401 1402 { 8, szOID_ANY_CERT_POLICY, 0, (LPCWSTR)IDS_ANY_CERT_POLICY, NULL }, 1403 }; 1404 1405 struct OIDInfo { 1406 CRYPT_OID_INFO info; 1407 struct list entry; 1408 }; 1409 1410 static void init_oid_info(void) 1411 { 1412 DWORD i; 1413 1414 oid_init_localizednames(); 1415 for (i = 0; i < sizeof(oidInfoConstructors) / 1416 sizeof(oidInfoConstructors[0]); i++) 1417 { 1418 if (!IS_INTRESOURCE(oidInfoConstructors[i].pwszName)) 1419 { 1420 struct OIDInfo *info; 1421 1422 /* The name is a static string, so just use the same pointer */ 1423 info = CryptMemAlloc(sizeof(struct OIDInfo)); 1424 if (info) 1425 { 1426 memset(info, 0, sizeof(*info)); 1427 info->info.cbSize = sizeof(CRYPT_OID_INFO); 1428 info->info.pszOID = oidInfoConstructors[i].pszOID; 1429 info->info.pwszName = oidInfoConstructors[i].pwszName; 1430 info->info.dwGroupId = oidInfoConstructors[i].dwGroupId; 1431 info->info.u.Algid = oidInfoConstructors[i].Algid; 1432 if (oidInfoConstructors[i].blob) 1433 { 1434 info->info.ExtraInfo.cbData = 1435 oidInfoConstructors[i].blob->cbData; 1436 info->info.ExtraInfo.pbData = 1437 oidInfoConstructors[i].blob->pbData; 1438 } 1439 info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid; 1440 info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid; 1441 list_add_tail(&oidInfo, &info->entry); 1442 } 1443 } 1444 else 1445 { 1446 LPCWSTR stringresource; 1447 int len = LoadStringW(hInstance, 1448 (UINT_PTR)oidInfoConstructors[i].pwszName, 1449 (LPWSTR)&stringresource, 0); 1450 1451 if (len) 1452 { 1453 struct OIDInfo *info = CryptMemAlloc(sizeof(struct OIDInfo) + 1454 (len + 1) * sizeof(WCHAR)); 1455 1456 if (info) 1457 { 1458 memset(info, 0, sizeof(*info)); 1459 info->info.cbSize = sizeof(CRYPT_OID_INFO); 1460 info->info.pszOID = oidInfoConstructors[i].pszOID; 1461 info->info.pwszName = (LPWSTR)(info + 1); 1462 info->info.dwGroupId = oidInfoConstructors[i].dwGroupId; 1463 info->info.u.Algid = oidInfoConstructors[i].Algid; 1464 memcpy(info + 1, stringresource, len*sizeof(WCHAR)); 1465 ((LPWSTR)(info + 1))[len] = 0; 1466 if (oidInfoConstructors[i].blob) 1467 { 1468 info->info.ExtraInfo.cbData = 1469 oidInfoConstructors[i].blob->cbData; 1470 info->info.ExtraInfo.pbData = 1471 oidInfoConstructors[i].blob->pbData; 1472 } 1473 info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid; 1474 info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid; 1475 list_add_tail(&oidInfo, &info->entry); 1476 } 1477 } 1478 } 1479 } 1480 } 1481 1482 static void free_oid_info(void) 1483 { 1484 struct OIDInfo *info, *next; 1485 1486 LIST_FOR_EACH_ENTRY_SAFE(info, next, &oidInfo, struct OIDInfo, entry) 1487 { 1488 list_remove(&info->entry); 1489 CryptMemFree(info); 1490 } 1491 DeleteCriticalSection(&oidInfoCS); 1492 } 1493 1494 /*********************************************************************** 1495 * CryptEnumOIDInfo (CRYPT32.@) 1496 */ 1497 BOOL WINAPI CryptEnumOIDInfo(DWORD dwGroupId, DWORD dwFlags, void *pvArg, 1498 PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo) 1499 { 1500 BOOL ret = TRUE; 1501 struct OIDInfo *info; 1502 1503 TRACE("(%d, %08x, %p, %p)\n", dwGroupId, dwFlags, pvArg, 1504 pfnEnumOIDInfo); 1505 1506 EnterCriticalSection(&oidInfoCS); 1507 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) 1508 { 1509 if (!dwGroupId || dwGroupId == info->info.dwGroupId) 1510 { 1511 ret = pfnEnumOIDInfo(&info->info, pvArg); 1512 if (!ret) 1513 break; 1514 } 1515 } 1516 LeaveCriticalSection(&oidInfoCS); 1517 return ret; 1518 } 1519 1520 PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo(DWORD dwKeyType, void *pvKey, 1521 DWORD dwGroupId) 1522 { 1523 PCCRYPT_OID_INFO ret = NULL; 1524 1525 TRACE("(%d, %p, %d)\n", dwKeyType, pvKey, dwGroupId); 1526 1527 switch(dwKeyType) 1528 { 1529 case CRYPT_OID_INFO_ALGID_KEY: 1530 { 1531 struct OIDInfo *info; 1532 1533 TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey); 1534 EnterCriticalSection(&oidInfoCS); 1535 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) 1536 { 1537 if (info->info.u.Algid == *(DWORD *)pvKey && 1538 (!dwGroupId || info->info.dwGroupId == dwGroupId)) 1539 { 1540 ret = &info->info; 1541 break; 1542 } 1543 } 1544 LeaveCriticalSection(&oidInfoCS); 1545 break; 1546 } 1547 case CRYPT_OID_INFO_NAME_KEY: 1548 { 1549 struct OIDInfo *info; 1550 1551 TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey)); 1552 EnterCriticalSection(&oidInfoCS); 1553 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) 1554 { 1555 if (!lstrcmpW(info->info.pwszName, pvKey) && 1556 (!dwGroupId || info->info.dwGroupId == dwGroupId)) 1557 { 1558 ret = &info->info; 1559 break; 1560 } 1561 } 1562 LeaveCriticalSection(&oidInfoCS); 1563 break; 1564 } 1565 case CRYPT_OID_INFO_OID_KEY: 1566 { 1567 struct OIDInfo *info; 1568 LPSTR oid = pvKey; 1569 1570 TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid)); 1571 EnterCriticalSection(&oidInfoCS); 1572 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) 1573 { 1574 if (!lstrcmpA(info->info.pszOID, oid) && 1575 (!dwGroupId || info->info.dwGroupId == dwGroupId)) 1576 { 1577 ret = &info->info; 1578 break; 1579 } 1580 } 1581 LeaveCriticalSection(&oidInfoCS); 1582 break; 1583 } 1584 case CRYPT_OID_INFO_SIGN_KEY: 1585 { 1586 struct OIDInfo *info; 1587 1588 TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey); 1589 EnterCriticalSection(&oidInfoCS); 1590 LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry) 1591 { 1592 if (info->info.u.Algid == *(DWORD *)pvKey && 1593 info->info.ExtraInfo.cbData >= sizeof(DWORD) && 1594 *(DWORD *)info->info.ExtraInfo.pbData == 1595 *(DWORD *)((LPBYTE)pvKey + sizeof(DWORD)) && 1596 (!dwGroupId || info->info.dwGroupId == dwGroupId)) 1597 { 1598 ret = &info->info; 1599 break; 1600 } 1601 } 1602 LeaveCriticalSection(&oidInfoCS); 1603 break; 1604 } 1605 } 1606 return ret; 1607 } 1608 1609 LPCSTR WINAPI CertAlgIdToOID(DWORD dwAlgId) 1610 { 1611 LPCSTR ret; 1612 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY, 1613 &dwAlgId, 0); 1614 1615 if (info) 1616 ret = info->pszOID; 1617 else 1618 ret = NULL; 1619 return ret; 1620 } 1621 1622 DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId) 1623 { 1624 DWORD ret; 1625 PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, 1626 (void *)pszObjId, 0); 1627 1628 if (info) 1629 ret = info->u.Algid; 1630 else 1631 ret = 0; 1632 return ret; 1633 } 1634 1635 void crypt_oid_init(void) 1636 { 1637 init_oid_info(); 1638 } 1639 1640 void crypt_oid_free(void) 1641 { 1642 free_function_sets(); 1643 free_oid_info(); 1644 } 1645