git.oblomov.eu Git - wine/blob - dlls/crypt32/oid.c

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