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