oid.c File Reference

#include "config.h"
#include "wine/port.h"
#include <stdio.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wincrypt.h"
#include "winreg.h"
#include "winuser.h"
#include "wine/debug.h"
#include "wine/list.h"
#include "crypt32_private.h"
#include "cryptres.h"

Include dependency graph for oid.c:

Go to the source code of this file.

Classes
struct	OIDFunctionSet
struct	OIDFunction
struct	FuncAddr
struct	OIDInfoConstructor
struct	OIDInfo

Macros
#define	NONAMELESSUNION
#define	CRYPT_OID_INFO_HAS_EXTRA_FIELDS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)
static void	free_function_sets (void)
HCRYPTOIDFUNCSET WINAPI	CryptInitOIDFunctionSet (LPCSTR pszFuncName, DWORD dwFlags)
static char *	CRYPT_GetKeyName (DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID)
BOOL WINAPI	CryptGetDefaultOIDDllList (HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPWSTR pwszDllList, DWORD *pcchDllList)
BOOL WINAPI	CryptInstallOIDFunctionAddress (HMODULE hModule, DWORD dwEncodingType, LPCSTR pszFuncName, DWORD cFuncEntry, const CRYPT_OID_FUNC_ENTRY rgFuncEntry[], DWORD dwFlags)
static BOOL	CRYPT_GetFuncFromReg (DWORD dwEncodingType, LPCSTR pszOID, LPCSTR szFuncName, LPVOID *ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
BOOL WINAPI	CryptGetOIDFunctionAddress (HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
static BOOL	is_module_registered (HMODULE hModule)
BOOL WINAPI	CryptFreeOIDFunctionAddress (HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags)
static BOOL	CRYPT_GetFuncFromDll (LPCWSTR dll, LPCSTR func, HMODULE *lib, void **ppvFuncAddr)
BOOL WINAPI	CryptGetDefaultOIDFunctionAddress (HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
BOOL WINAPI	CryptRegisterOIDFunction (DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszDll, LPCSTR pszOverrideFuncName)
BOOL WINAPI	CryptUnregisterOIDInfo (PCCRYPT_OID_INFO info)
BOOL WINAPI	CryptRegisterOIDInfo (PCCRYPT_OID_INFO info, DWORD flags)
BOOL WINAPI	CryptUnregisterOIDFunction (DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID)
BOOL WINAPI	CryptGetOIDFunctionValue (DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszValueName, DWORD *pdwValueType, BYTE *pbValueData, DWORD *pcbValueData)
BOOL WINAPI	CryptSetOIDFunctionValue (DWORD dwEncodingType, LPCSTR pszFuncName, LPCSTR pszOID, LPCWSTR pwszValueName, DWORD dwValueType, const BYTE *pbValueData, DWORD cbValueData)
static LPCWSTR	CRYPT_FindStringInMultiString (LPCWSTR multi, LPCWSTR toFind)
static DWORD	CRYPT_GetMultiStringCharacterLen (LPCWSTR multi)
static LPWSTR	CRYPT_AddStringToMultiString (LPWSTR multi, LPCWSTR toAdd, DWORD index)
static BOOL	CRYPT_RemoveStringFromMultiString (LPWSTR multi, LPCWSTR toRemove)
static BOOL	CRYPT_GetDefaultOIDKey (DWORD dwEncodingType, LPCSTR pszFuncName, PHKEY key)
static LPWSTR	CRYPT_GetDefaultOIDDlls (HKEY key)
static BOOL	CRYPT_SetDefaultOIDDlls (HKEY key, LPCWSTR dlls)
BOOL WINAPI	CryptRegisterDefaultOIDFunction (DWORD dwEncodingType, LPCSTR pszFuncName, DWORD dwIndex, LPCWSTR pwszDll)
BOOL WINAPI	CryptUnregisterDefaultOIDFunction (DWORD dwEncodingType, LPCSTR pszFuncName, LPCWSTR pwszDll)
static void	oid_init_localizednames (void)
LPCWSTR WINAPI	CryptFindLocalizedName (LPCWSTR pwszCryptName)
static struct OIDInfo *	read_oid_info (HKEY root, char *key_name, DWORD *flags)
static void	init_registered_oid_info (void)
static void	init_oid_info (void)
static void	free_oid_info (void)
BOOL WINAPI	CryptEnumOIDInfo (DWORD dwGroupId, DWORD dwFlags, void *pvArg, PFN_CRYPT_ENUM_OID_INFO pfnEnumOIDInfo)
PCCRYPT_OID_INFO WINAPI	CryptFindOIDInfo (DWORD dwKeyType, void *pvKey, DWORD dwGroupId)
LPCSTR WINAPI	CertAlgIdToOID (DWORD dwAlgId)
DWORD WINAPI	CertOIDToAlgId (LPCSTR pszObjId)
void	crypt_oid_init (void)
void	crypt_oid_free (void)

Variables
static const WCHAR	DllW [] = { 'D','l','l',0 }
static CRITICAL_SECTION	funcSetCS = { &funcSetCSDebug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	funcSetCSDebug
static struct list	funcSets = { &funcSets, &funcSets }
static const WCHAR	ROOT [] = {'R','O','O','T',0}
static const WCHAR	MY [] = {'M','Y',0}
static const WCHAR	CA [] = {'C','A',0}
static const WCHAR	ADDRESSBOOK [] = {'A','D','D','R','E','S','S','B','O','O','K',0}
static const WCHAR	TRUSTEDPUBLISHER [] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0}
static const WCHAR	DISALLOWED [] = {'D','i','s','a','l','l','o','w','e','d',0}
static const LPCWSTR	LocalizedKeys [] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER,DISALLOWED}
static WCHAR	LocalizedNames [ARRAY_SIZE(LocalizedKeys)][256]
static const WCHAR	nameW [] = { 'N','a','m','e',0 }
static const WCHAR	algidW [] = { 'A','l','g','i','d',0 }
static const WCHAR	extraW [] = { 'E','x','t','r','a','I','n','f','o',0 }
static const WCHAR	cngalgidW [] = { 'C','N','G','A','l','g','i','d',0 }
static const WCHAR	cngextraalgidW [] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 }
static const WCHAR	flagsW [] = { 'F','l','a','g','s',0 }
static CRITICAL_SECTION	oidInfoCS = { &oidInfoCSDebug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	oidInfoCSDebug
static struct list	oidInfo = { &oidInfo, &oidInfo }
static const WCHAR	tripledes [] = { '3','d','e','s',0 }
static const WCHAR	cms3deswrap []
static const WCHAR	cmsrc2wrap [] = { 'C','M','S','R','C','2','w','r','a','p',0 }
static const WCHAR	des [] = { 'd','e','s',0 }
static const WCHAR	md2 [] = { 'm','d','2',0 }
static const WCHAR	md4 [] = { 'm','d','4',0 }
static const WCHAR	md5 [] = { 'm','d','5',0 }
static const WCHAR	rc2 [] = { 'r','c','2',0 }
static const WCHAR	rc4 [] = { 'r','c','4',0 }
static const WCHAR	sha [] = { 's','h','a',0 }
static const WCHAR	sha1 [] = { 's','h','a','1',0 }
static const WCHAR	sha256 [] = { 's','h','a','2','5','6',0 }
static const WCHAR	sha384 [] = { 's','h','a','3','8','4',0 }
static const WCHAR	sha512 [] = { 's','h','a','5','1','2',0 }
static const WCHAR	RSA [] = { 'R','S','A',0 }
static const WCHAR	RSA_KEYX [] = { 'R','S','A','_','K','E','Y','X',0 }
static const WCHAR	RSA_SIGN [] = { 'R','S','A','_','S','I','G','N',0 }
static const WCHAR	DSA [] = { 'D','S','A',0 }
static const WCHAR	DSA_SIGN [] = { 'D','S','A','_','S','I','G','N',0 }
static const WCHAR	DH [] = { 'D','H',0 }
static const WCHAR	DSS [] = { 'D','S','S',0 }
static const WCHAR	mosaicKMandUpdSig []
static const WCHAR	ESDH [] = { 'E','S','D','H',0 }
static const WCHAR	NO_SIGN [] = { 'N','O','S','I','G','N',0 }
static const WCHAR	dsaSHA1 [] = { 'd','s','a','S','H','A','1',0 }
static const WCHAR	md2RSA [] = { 'm','d','2','R','S','A',0 }
static const WCHAR	md4RSA [] = { 'm','d','4','R','S','A',0 }
static const WCHAR	md5RSA [] = { 'm','d','5','R','S','A',0 }
static const WCHAR	shaDSA [] = { 's','h','a','D','S','A',0 }
static const WCHAR	sha1DSA [] = { 's','h','a','1','D','S','A',0 }
static const WCHAR	shaRSA [] = { 's','h','a','R','S','A',0 }
static const WCHAR	sha1RSA [] = { 's','h','a','1','R','S','A',0 }
static const WCHAR	sha256RSA [] = { 's','h','a','2','5','6','R','S','A',0 }
static const WCHAR	sha384RSA [] = { 's','h','a','3','8','4','R','S','A',0 }
static const WCHAR	sha512RSA [] = { 's','h','a','5','1','2','R','S','A',0 }
static const WCHAR	mosaicUpdatedSig []
static const WCHAR	sha256ECDSA [] = { 's','h','a','2','5','6','E','C','D','S','A',0 }
static const WCHAR	sha384ECDSA [] = { 's','h','a','3','8','4','E','C','D','S','A',0 }
static const WCHAR	CN [] = { 'C','N',0 }
static const WCHAR	L [] = { 'L',0 }
static const WCHAR	O [] = { 'O',0 }
static const WCHAR	OU [] = { 'O','U',0 }
static const WCHAR	E [] = { 'E',0 }
static const WCHAR	C [] = { 'C',0 }
static const WCHAR	S [] = { 'S',0 }
static const WCHAR	ST [] = { 'S','T',0 }
static const WCHAR	STREET [] = { 'S','T','R','E','E','T',0 }
static const WCHAR	T [] = { 'T',0 }
static const WCHAR	Title [] = { 'T','i','t','l','e',0 }
static const WCHAR	G [] = { 'G',0 }
static const WCHAR	GivenName [] = { 'G','i','v','e','n','N','a','m','e',0 }
static const WCHAR	I [] = { 'I',0 }
static const WCHAR	Initials [] = { 'I','n','i','t','i','a','l','s',0 }
static const WCHAR	SN [] = { 'S','N',0 }
static const WCHAR	DC [] = { 'D','C',0 }
static const WCHAR	Description []
static const WCHAR	PostalCode [] = { 'P','o','s','t','a','l','C','o','d','e',0 }
static const WCHAR	POBox [] = { 'P','O','B','o','x',0 }
static const WCHAR	Phone [] = { 'P','h','o','n','e',0 }
static const WCHAR	X21Address [] = { 'X','2','1','A','d','d','r','e','s','s',0 }
static const WCHAR	dnQualifier []
static const WCHAR	SpcSpAgencyInfo [] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 }
static const WCHAR	SpcFinancialCriteria [] = { 'S','p','c','F','i','n','a','n','c','i','a','l','C','r','i','t','e','r','i','a',0 }
static const WCHAR	SpcMinimalCriteria [] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 }
static const WCHAR	Email [] = { 'E','m','a','i','l',0 }
static const WCHAR	GN [] = { 'G','N',0 }
static const WCHAR	SERIALNUMBER [] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 }
static const DWORD	noNullFlag = CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG
static const DWORD	mosaicFlags
static const CRYPT_DATA_BLOB	noNullBlob
static const CRYPT_DATA_BLOB	mosaicFlagsBlob
static const DWORD	rsaSign = CALG_RSA_SIGN
static const DWORD	dssSign [2]
static const DWORD	mosaicSign [2]
static const DWORD	ecdsaSign [2] = { CALG_OID_INFO_PARAMETERS, CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }
static const CRYPT_DATA_BLOB	rsaSignBlob
static const CRYPT_DATA_BLOB	dssSignBlob
static const CRYPT_DATA_BLOB	mosaicSignBlob
static const CRYPT_DATA_BLOB	ecdsaSignBlob = { sizeof(ecdsaSign), (BYTE *)ecdsaSign }
static const DWORD	ia5String [] = { CERT_RDN_IA5_STRING, 0 }
static const DWORD	numericString [] = { CERT_RDN_NUMERIC_STRING, 0 }
static const DWORD	printableString [] = { CERT_RDN_PRINTABLE_STRING, 0 }
static const DWORD	domainCompTypes []
static const CRYPT_DATA_BLOB	ia5StringBlob
static const CRYPT_DATA_BLOB	numericStringBlob
static const CRYPT_DATA_BLOB	printableStringBlob
static const CRYPT_DATA_BLOB	domainCompTypesBlob
static const struct OIDInfoConstructor	oidInfoConstructors []

Macro Definition Documentation

CRYPT_OID_INFO_HAS_EXTRA_FIELDS

#define CRYPT_OID_INFO_HAS_EXTRA_FIELDS

Definition at line 32 of file oid.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 29 of file oid.c.

Function Documentation

CertAlgIdToOID()

LPCSTR WINAPI CertAlgIdToOID

(

DWORD

dwAlgId

)

Definition at line 1888 of file oid.c.

{
    LPCSTR ret;
    PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_ALGID_KEY,
     &dwAlgId, 0);
 
    if (info)
        ret = info->pszOID;
    else
        ret = NULL;
    return ret;
}

Referenced by CRYPT_EncodePKCSDigestedData(), CRYPT_ExportPublicKeyInfoEx(), and testAlgIDToOID().

CertOIDToAlgId()

DWORD WINAPI CertOIDToAlgId

(

LPCSTR

pszObjId

)

Definition at line 1901 of file oid.c.

{
    DWORD ret;
    PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY,
     (void *)pszObjId, 0);
 
    if (info)
        ret = info->u.Algid;
    else
        ret = 0;
    return ret;
}

Referenced by CDecodeMsg_FinalizeHashedContent(), CEnvelopedEncodeMsg_Open(), CHashEncodeMsg_Open(), CRYPT_ImportKeyTrans(), CRYPT_IsValidSigner(), CSignedMsgData_ConstructSignerHandles(), SOFTPUB_VerifyImageHash(), and testOIDToAlgID().

CRYPT_AddStringToMultiString()

static LPWSTR CRYPT_AddStringToMultiString ( LPWSTR  multi, LPCWSTR  toAdd, DWORD  index  )

static

Definition at line 958 of file oid.c.

{
    LPWSTR ret;
 
    if (!multi)
    {
        /* FIXME: ignoring index, is that okay? */
        ret = CryptMemAlloc((lstrlenW(toAdd) + 2) * sizeof(WCHAR));
        if (ret)
        {
            /* copy string, including NULL terminator */
            memcpy(ret, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR));
            /* add terminating empty string */
            *(ret + lstrlenW(toAdd) + 1) = 0;
        }
    }
    else
    {
        DWORD len = CRYPT_GetMultiStringCharacterLen(multi);
 
        ret = CryptMemRealloc(multi, (len + lstrlenW(toAdd) + 1) *
         sizeof(WCHAR));
        if (ret)
        {
            LPWSTR spotToAdd;
 
            if (index == CRYPT_REGISTER_LAST_INDEX)
                spotToAdd = ret + len - 1;
            else
            {
                DWORD i;
 
                /* FIXME: if index is too large for the string, toAdd is
                 * added to the end.  Is that okay?
                 */
                for (i = 0, spotToAdd = ret; i < index && *spotToAdd;
                 spotToAdd += lstrlenW(spotToAdd) + 1)
                    ;
            }
            if (spotToAdd)
            {
                /* Copy existing string "right" */
                memmove(spotToAdd + lstrlenW(toAdd) + 1, spotToAdd,
                 (len - (spotToAdd - ret)) * sizeof(WCHAR));
                /* Copy new string */
                memcpy(spotToAdd, toAdd, (lstrlenW(toAdd) + 1) * sizeof(WCHAR));
            }
            else
            {
                CryptMemFree(ret);
                ret = NULL;
            }
        }
    }
    return ret;
}

Referenced by CryptRegisterDefaultOIDFunction().

CRYPT_FindStringInMultiString()

static LPCWSTR CRYPT_FindStringInMultiString ( LPCWSTR  multi, LPCWSTR  toFind  )

static

Definition at line 928 of file oid.c.

{
    LPCWSTR ret = NULL, ptr;
 
    for (ptr = multi; ptr && *ptr && !ret; ptr += lstrlenW(ptr) + 1)
    {
        if (!lstrcmpiW(ptr, toFind))
            ret = ptr;
    }
    return ret;
}

Referenced by CRYPT_RemoveStringFromMultiString(), and CryptRegisterDefaultOIDFunction().

CRYPT_GetDefaultOIDDlls()

static LPWSTR CRYPT_GetDefaultOIDDlls ( HKEY  key )

static

Definition at line 1073 of file oid.c.

{
    LONG r;
    DWORD type, size;
    LPWSTR dlls;
 
    r = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size);
    if (r == ERROR_SUCCESS && type == REG_MULTI_SZ)
    {
        dlls = CryptMemAlloc(size);
        r = RegQueryValueExW(key, DllW, NULL, &type, (LPBYTE)dlls, &size);
        if (r != ERROR_SUCCESS)
        {
            CryptMemFree(dlls);
            dlls = NULL;
        }
    }
    else
        dlls = NULL;
    return dlls;
}

Referenced by CryptRegisterDefaultOIDFunction(), and CryptUnregisterDefaultOIDFunction().

CRYPT_GetDefaultOIDKey()

static BOOL CRYPT_GetDefaultOIDKey ( DWORD  dwEncodingType, LPCSTR  pszFuncName, PHKEY  key  )

static

Definition at line 1050 of file oid.c.

{
    LPSTR keyName;
    LONG r;
 
    keyName = CRYPT_GetKeyName(dwEncodingType, pszFuncName, "DEFAULT");
    TRACE("Key name is %s\n", debugstr_a(keyName));
 
    if (!keyName)
        return FALSE;
 
    r = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0, KEY_ALL_ACCESS,
     NULL, key, NULL);
    CryptMemFree(keyName);
    if (r != ERROR_SUCCESS)
    {
        SetLastError(r);
        return FALSE;
    }
    return TRUE;
}

Referenced by CryptRegisterDefaultOIDFunction(), and CryptUnregisterDefaultOIDFunction().

CRYPT_GetFuncFromDll()

static BOOL CRYPT_GetFuncFromDll ( LPCWSTR  dll, LPCSTR  func, HMODULE *  lib, void **  ppvFuncAddr  )

static

Definition at line 491 of file oid.c.

{
    BOOL ret = FALSE;
 
    *lib = LoadLibraryW(dll);
    if (*lib)
    {
        *ppvFuncAddr = GetProcAddress(*lib, func);
        if (*ppvFuncAddr)
            ret = TRUE;
        else
        {
            FreeLibrary(*lib);
            *lib = NULL;
        }
    }
    return ret;
}

Referenced by CryptGetDefaultOIDFunctionAddress().

CRYPT_GetFuncFromReg()

static BOOL CRYPT_GetFuncFromReg ( DWORD  dwEncodingType, LPCSTR  pszOID, LPCSTR  szFuncName, LPVOID *  ppvFuncAddr, HCRYPTOIDFUNCADDR *  phFuncAddr  )

static

Definition at line 298 of file oid.c.

{
    BOOL ret = FALSE;
    char *keyName;
    const char *funcName;
    HKEY key;
    LSTATUS rc;
 
    keyName = CRYPT_GetKeyName(dwEncodingType, szFuncName, pszOID);
    rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, KEY_READ, &key);
    if (!rc)
    {
        DWORD type, size = 0;
 
        rc = RegQueryValueExA(key, "FuncName", NULL, &type, NULL, &size);
        if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
        {
            funcName = CryptMemAlloc(size);
            rc = RegQueryValueExA(key, "FuncName", NULL, &type,
             (LPBYTE)funcName, &size);
        }
        else
            funcName = szFuncName;
        rc = RegQueryValueExW(key, DllW, NULL, &type, NULL, &size);
        if ((!rc || rc == ERROR_MORE_DATA) && type == REG_SZ)
        {
            LPWSTR dllName = CryptMemAlloc(size);
 
            if (dllName)
            {
                rc = RegQueryValueExW(key, DllW, NULL, NULL,
                 (LPBYTE)dllName, &size);
                if (!rc)
                {
                    HMODULE lib;
 
                    /* This is a bit of a hack; MSDN describes a more
                     * complicated unload routine than this will allow.
                     * Still, this seems to suffice for now.
                     */
                    lib = LoadLibraryW(dllName);
                    if (lib)
                    {
                        *ppvFuncAddr = GetProcAddress(lib, funcName);
                        if (*ppvFuncAddr)
                        {
                            struct FuncAddr *addr =
                             CryptMemAlloc(sizeof(struct FuncAddr));
 
                            if (addr)
                            {
                                addr->lib = lib;
                                addr->dllList = addr->currentDll = NULL;
                                *phFuncAddr = addr;
                                ret = TRUE;
                            }
                            else
                            {
                                *phFuncAddr = NULL;
                                FreeLibrary(lib);
                            }
                        }
                        else
                        {
                            /* Unload the library, the caller doesn't want
                             * to unload it when the return value is NULL.
                             */
                            FreeLibrary(lib);
                        }
                    }
                }
                else
                    SetLastError(rc);
                CryptMemFree(dllName);
            }
        }
        else
            SetLastError(rc);
        if (funcName != szFuncName)
            CryptMemFree((char *)funcName);
        RegCloseKey(key);
    }
    else
        SetLastError(rc);
    CryptMemFree(keyName);
    return ret;
}

Referenced by CryptGetOIDFunctionAddress().

CRYPT_GetKeyName()

static char * CRYPT_GetKeyName ( DWORD  dwEncodingType, LPCSTR  pszFuncName, LPCSTR  pszOID  )

static

Definition at line 157 of file oid.c.

{
    static const char szEncodingTypeFmt[] =
     "Software\\Microsoft\\Cryptography\\OID\\EncodingType %d\\%s\\%s";
    UINT len;
    char numericOID[7]; /* enough for "#65535" */
    const char *oid;
    LPSTR szKey;
 
    /* MSDN says the encoding type is a mask, but it isn't treated that way.
     * (E.g., if dwEncodingType were 3, the key names "EncodingType 1" and
     * "EncodingType 2" would be expected if it were a mask.  Instead native
     * stores values in "EncodingType 3".
     */
    if (IS_INTOID(pszOID))
    {
        snprintf(numericOID, sizeof(numericOID), "#%d", LOWORD(pszOID));
        oid = numericOID;
    }
    else
        oid = pszOID;
 
    /* This is enough: the lengths of the two string parameters are explicitly
     * counted, and we need up to five additional characters for the encoding
     * type.  These are covered by the "%d", "%s", and "%s" characters in the
     * format specifier that are removed by sprintf.
     */
    len = sizeof(szEncodingTypeFmt) + lstrlenA(pszFuncName) + lstrlenA(oid);
    szKey = CryptMemAlloc(len);
    if (szKey)
        sprintf(szKey, szEncodingTypeFmt,
         GET_CERT_ENCODING_TYPE(dwEncodingType), pszFuncName, oid);
    return szKey;
}

Referenced by CRYPT_GetDefaultOIDKey(), CRYPT_GetFuncFromReg(), CryptGetDefaultOIDDllList(), CryptGetOIDFunctionValue(), CryptRegisterOIDFunction(), CryptSetOIDFunctionValue(), and CryptUnregisterOIDFunction().

CRYPT_GetMultiStringCharacterLen()

static DWORD CRYPT_GetMultiStringCharacterLen ( LPCWSTR  multi )

static

Definition at line 940 of file oid.c.

{
    DWORD ret;
 
    if (multi)
    {
        LPCWSTR ptr;
 
        /* Count terminating empty string */
        ret = 1;
        for (ptr = multi; *ptr; ptr += lstrlenW(ptr) + 1)
            ret += lstrlenW(ptr) + 1;
    }
    else
        ret = 0;
    return ret;
}

Referenced by CRYPT_AddStringToMultiString(), CRYPT_RemoveStringFromMultiString(), and CRYPT_SetDefaultOIDDlls().

crypt_oid_free()

void crypt_oid_free

(

void

)

Definition at line 1920 of file oid.c.

{
    free_function_sets();
    free_oid_info();
}

Referenced by DllMain().

crypt_oid_init()

void crypt_oid_init

(

void

)

Definition at line 1914 of file oid.c.

{
    init_oid_info();
    init_registered_oid_info();
}

Referenced by DllMain().

CRYPT_RemoveStringFromMultiString()

static BOOL CRYPT_RemoveStringFromMultiString ( LPWSTR  multi, LPCWSTR  toRemove  )

static

Definition at line 1016 of file oid.c.

{
    LPWSTR spotToRemove = (LPWSTR)CRYPT_FindStringInMultiString(multi,
     toRemove);
    BOOL ret;
 
    if (spotToRemove)
    {
        DWORD len = CRYPT_GetMultiStringCharacterLen(multi);
 
        if (spotToRemove + lstrlenW(toRemove) + 2 >= multi + len)
        {
            /* Removing last string in list, terminate multi string directly */
            *spotToRemove = 0;
            *(spotToRemove + 1) = 0;
        }
        else
        {
            LPCWSTR nextStr = spotToRemove + lstrlenW(toRemove) + 1;
 
            /* Copy remainder of string "left" */
            memmove(spotToRemove, nextStr,
             (len - (nextStr - multi)) * sizeof(WCHAR));
        }
        ret = TRUE;
    }
    else
    {
        SetLastError(ERROR_FILE_NOT_FOUND);
        ret = FALSE;
    }
    return ret;
}

Referenced by CryptUnregisterDefaultOIDFunction().

CRYPT_SetDefaultOIDDlls()

static BOOL CRYPT_SetDefaultOIDDlls ( HKEY  key, LPCWSTR  dlls  )

inlinestatic

Definition at line 1095 of file oid.c.

{
    DWORD len = CRYPT_GetMultiStringCharacterLen(dlls);
    LONG r;
 
    if ((r = RegSetValueExW(key, DllW, 0, REG_MULTI_SZ, (const BYTE *)dlls,
     len * sizeof (WCHAR))))
        SetLastError(r);
    return r == ERROR_SUCCESS;
}

Referenced by CryptRegisterDefaultOIDFunction(), and CryptUnregisterDefaultOIDFunction().

CryptEnumOIDInfo()

BOOL WINAPI CryptEnumOIDInfo	(	DWORD	dwGroupId,
		DWORD	dwFlags,
		void *	pvArg,
		PFN_CRYPT_ENUM_OID_INFO	pfnEnumOIDInfo
	)

Definition at line 1776 of file oid.c.

{
    BOOL ret = TRUE;
    struct OIDInfo *info;
 
    TRACE("(%d, %08x, %p, %p)\n", dwGroupId, dwFlags, pvArg,
     pfnEnumOIDInfo);
 
    EnterCriticalSection(&oidInfoCS);
    LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    {
        if (!dwGroupId || dwGroupId == info->info.dwGroupId)
        {
            ret = pfnEnumOIDInfo(&info->info, pvArg);
            if (!ret)
                break;
        }
    }
    LeaveCriticalSection(&oidInfoCS);
    return ret;
}

Referenced by WTHelperGetKnownUsages().

CryptFindLocalizedName()

LPCWSTR WINAPI CryptFindLocalizedName

(

LPCWSTR

pwszCryptName

)

Definition at line 1182 of file oid.c.

{
    unsigned int i;
 
    for(i = 0; i < ARRAY_SIZE(LocalizedKeys); i++)
    {
        if(!lstrcmpiW(LocalizedKeys[i], pwszCryptName))
        {
            return LocalizedNames[i];
        }
    }
 
    FIXME("No name for: %s - stub\n",debugstr_w(pwszCryptName));
    return NULL;
}

Referenced by enum_store_callback(), and show_cert_stores().

CryptFindOIDInfo()

PCCRYPT_OID_INFO WINAPI CryptFindOIDInfo	(	DWORD	dwKeyType,
		void *	pvKey,
		DWORD	dwGroupId
	)

Definition at line 1799 of file oid.c.

{
    PCCRYPT_OID_INFO ret = NULL;
 
    TRACE("(%d, %p, %d)\n", dwKeyType, pvKey, dwGroupId);
 
    switch(dwKeyType)
    {
    case CRYPT_OID_INFO_ALGID_KEY:
    {
        struct OIDInfo *info;
 
        TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey);
        EnterCriticalSection(&oidInfoCS);
        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
        {
            if (info->info.u.Algid == *(DWORD *)pvKey &&
             (!dwGroupId || info->info.dwGroupId == dwGroupId))
            {
                ret = &info->info;
                break;
            }
        }
        LeaveCriticalSection(&oidInfoCS);
        break;
    }
    case CRYPT_OID_INFO_NAME_KEY:
    {
        struct OIDInfo *info;
 
        TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey));
        EnterCriticalSection(&oidInfoCS);
        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
        {
            if (!lstrcmpW(info->info.pwszName, pvKey) &&
             (!dwGroupId || info->info.dwGroupId == dwGroupId))
            {
                ret = &info->info;
                break;
            }
        }
        LeaveCriticalSection(&oidInfoCS);
        break;
    }
    case CRYPT_OID_INFO_OID_KEY:
    {
        struct OIDInfo *info;
        LPSTR oid = pvKey;
 
        TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid));
        EnterCriticalSection(&oidInfoCS);
        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
        {
            if (!lstrcmpA(info->info.pszOID, oid) &&
             (!dwGroupId || info->info.dwGroupId == dwGroupId))
            {
                ret = &info->info;
                break;
            }
        }
        LeaveCriticalSection(&oidInfoCS);
        break;
    }
    case CRYPT_OID_INFO_SIGN_KEY:
    {
        struct OIDInfo *info;
 
        TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey);
        EnterCriticalSection(&oidInfoCS);
        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
        {
            if (info->info.u.Algid == *(DWORD *)pvKey &&
             info->info.ExtraInfo.cbData >= sizeof(DWORD) &&
             *(DWORD *)info->info.ExtraInfo.pbData ==
             *(DWORD *)((LPBYTE)pvKey + sizeof(DWORD)) &&
             (!dwGroupId || info->info.dwGroupId == dwGroupId))
            {
                ret = &info->info;
                break;
            }
        }
        LeaveCriticalSection(&oidInfoCS);
        break;
    }
    }
    return ret;
}

Referenced by add_cert_extension_detail(), add_oid_text_to_control(), cert_name_to_str_with_indent(), CertAlgIdToOID(), CertGetPublicKeyLength(), CertNameToStrA(), CertOIDToAlgId(), CertStrToNameW(), CRYPT_FormatEnhancedKeyUsage(), CRYPT_VerifyCertSignatureFromPublicKeyInfo(), CryptHashToBeSigned(), CryptSignCertificate(), field_format_public_key(), find_oid_in_list(), get_cert_usages(), initialize_purpose_selection(), request_query_option(), show_cert_usages(), test_findOIDInfo(), and test_registerOIDInfo().

CryptFreeOIDFunctionAddress()

BOOL WINAPI CryptFreeOIDFunctionAddress	(	HCRYPTOIDFUNCADDR	hFuncAddr,
		DWORD	dwFlags
	)

Definition at line 468 of file oid.c.

{
    TRACE("(%p, %08x)\n", hFuncAddr, dwFlags);
 
    /* FIXME: as MSDN states, need to check for DllCanUnloadNow in the DLL,
     * and only unload it if it can be unloaded.  Also need to implement ref
     * counting on the functions.
     */
    if (hFuncAddr)
    {
        struct FuncAddr *addr = hFuncAddr;
 
        if (!is_module_registered(addr->lib))
        {
            CryptMemFree(addr->dllList);
            FreeLibrary(addr->lib);
            CryptMemFree(addr);
        }
    }
    return TRUE;
}

Referenced by CertVerifyCertificateChainPolicy(), CertVerifyRevocation(), CRYPT_ExportEncryptedKey(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_GenKey(), CRYPT_ImportEncryptedKey(), CRYPT_ImportPublicKeyInfoEx(), CRYPT_ProvOpenStore(), CryptDecodeObjectEx(), CryptEncodeObject(), CryptEncodeObjectEx(), CryptExportPublicKeyInfoEx(), CryptFormatObject(), CryptGetDefaultOIDFunctionAddress(), CryptGetObjectUrl(), CryptImportPublicKeyInfoEx(), CryptRetrieveObjectByUrlW(), and test_installOIDFunctionAddress().

CryptGetDefaultOIDDllList()

BOOL WINAPI CryptGetDefaultOIDDllList	(	HCRYPTOIDFUNCSET	hFuncSet,
		DWORD	dwEncodingType,
		LPWSTR	pwszDllList,
		DWORD *	pcchDllList
	)

Definition at line 193 of file oid.c.

{
    BOOL ret = TRUE;
    struct OIDFunctionSet *set = hFuncSet;
    char *keyName;
    HKEY key;
    LSTATUS rc;
 
    TRACE("(%p, %d, %p, %p)\n", hFuncSet, dwEncodingType, pwszDllList,
     pcchDllList);
 
    keyName = CRYPT_GetKeyName(dwEncodingType, set->name, "DEFAULT");
    rc = RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, NULL, 0,
     KEY_READ, NULL, &key, NULL);
    if (!rc)
    {
        DWORD size = *pcchDllList * sizeof(WCHAR);
 
        rc = RegQueryValueExW(key, DllW, NULL, NULL, (LPBYTE)pwszDllList,
         &size);
        if (!rc)
            *pcchDllList = size / sizeof(WCHAR);
        else
        {
            /* No value, return an empty list */
            if (pwszDllList && *pcchDllList)
                *pwszDllList = '\0';
            *pcchDllList = 1;
        }
        RegCloseKey(key);
    }
    else
    {
        /* No value, return an empty list */
        if (pwszDllList && *pcchDllList)
            *pwszDllList = '\0';
        *pcchDllList = 1;
    }
    CryptMemFree(keyName);
 
    return ret;
}

Referenced by CertVerifyRevocation(), CryptGetDefaultOIDFunctionAddress(), and test_oidFunctionSet().

CryptGetDefaultOIDFunctionAddress()

BOOL WINAPI CryptGetDefaultOIDFunctionAddress	(	HCRYPTOIDFUNCSET	hFuncSet,
		DWORD	dwEncodingType,
		LPCWSTR	pwszDll,
		DWORD	dwFlags,
		void **	ppvFuncAddr,
		HCRYPTOIDFUNCADDR *	phFuncAddr
	)

Definition at line 511 of file oid.c.

{
    struct OIDFunctionSet *set = hFuncSet;
    BOOL ret = FALSE;
 
    TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
     debugstr_w(pwszDll), dwFlags, ppvFuncAddr, phFuncAddr);
 
    if (pwszDll)
    {
        HMODULE lib;
 
        *phFuncAddr = NULL;
        ret = CRYPT_GetFuncFromDll(pwszDll, set->name, &lib, ppvFuncAddr);
        if (ret)
        {
            struct FuncAddr *addr = CryptMemAlloc(sizeof(struct FuncAddr));
 
            if (addr)
            {
                addr->lib = lib;
                addr->dllList = addr->currentDll = NULL;
                *phFuncAddr = addr;
            }
            else
            {
                FreeLibrary(lib);
                *ppvFuncAddr = NULL;
                SetLastError(ERROR_OUTOFMEMORY);
                ret = FALSE;
            }
        }
        else
            SetLastError(ERROR_FILE_NOT_FOUND);
    }
    else
    {
        struct FuncAddr *addr = *phFuncAddr;
 
        if (!addr)
        {
            DWORD size;
 
            ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType, NULL,
             &size);
            if (ret)
            {
                LPWSTR dllList = CryptMemAlloc(size * sizeof(WCHAR));
 
                if (dllList)
                {
                    ret = CryptGetDefaultOIDDllList(hFuncSet, dwEncodingType,
                     dllList, &size);
                    if (ret)
                    {
                        addr = CryptMemAlloc(sizeof(struct FuncAddr));
                        if (addr)
                        {
                            addr->dllList = dllList;
                            addr->currentDll = dllList;
                            addr->lib = NULL;
                            *phFuncAddr = addr;
                        }
                        else
                        {
                            CryptMemFree(dllList);
                            SetLastError(ERROR_OUTOFMEMORY);
                            ret = FALSE;
                        }
                    }
                }
                else
                {
                    SetLastError(ERROR_OUTOFMEMORY);
                    ret = FALSE;
                }
            }
        }
        if (addr)
        {
            if (!*addr->currentDll)
            {
                CryptFreeOIDFunctionAddress(*phFuncAddr, 0);
                SetLastError(ERROR_FILE_NOT_FOUND);
                *phFuncAddr = NULL;
                ret = FALSE;
            }
            else
            {
                /* FIXME: as elsewhere, can't free until DllCanUnloadNow says
                 * it's possible, and should defer unloading for some time to
                 * avoid repeated LoadLibrary/FreeLibrary on the same dll.
                 */
                FreeLibrary(addr->lib);
                ret = CRYPT_GetFuncFromDll(addr->currentDll, set->name,
                 &addr->lib, ppvFuncAddr);
                if (ret)
                {
                    /* Move past the current DLL */
                    addr->currentDll += lstrlenW(addr->currentDll) + 1;
                    *phFuncAddr = addr;
                }
                else
                {
                    CryptFreeOIDFunctionAddress(*phFuncAddr, 0);
                    SetLastError(ERROR_FILE_NOT_FOUND);
                    *phFuncAddr = NULL;
                }
            }
        }
    }
    return ret;
}

Referenced by CertVerifyRevocation(), and test_getDefaultOIDFunctionAddress().

CryptGetOIDFunctionAddress()

BOOL WINAPI CryptGetOIDFunctionAddress	(	HCRYPTOIDFUNCSET	hFuncSet,
		DWORD	dwEncodingType,
		LPCSTR	pszOID,
		DWORD	dwFlags,
		void **	ppvFuncAddr,
		HCRYPTOIDFUNCADDR *	phFuncAddr
	)

Definition at line 387 of file oid.c.

{
    BOOL ret = FALSE;
    struct OIDFunctionSet *set = hFuncSet;
 
    TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
     debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr);
 
    *ppvFuncAddr = NULL;
    if (!(dwFlags & CRYPT_GET_INSTALLED_OID_FUNC_FLAG))
    {
        struct OIDFunction *function;
 
        EnterCriticalSection(&set->cs);
        LIST_FOR_EACH_ENTRY(function, &set->functions, struct OIDFunction, next)
        {
            if (function->encoding == GET_CERT_ENCODING_TYPE(dwEncodingType))
            {
                if (!IS_INTOID(pszOID))
                {
                    if (!IS_INTOID(function->entry.pszOID) &&
                     !strcasecmp(function->entry.pszOID, pszOID))
                    {
                        *ppvFuncAddr = function->entry.pvFuncAddr;
                        *phFuncAddr = NULL; /* FIXME: what should it be? */
                        ret = TRUE;
                        break;
                    }
                }
                else if (function->entry.pszOID == pszOID)
                {
                    *ppvFuncAddr = function->entry.pvFuncAddr;
                    *phFuncAddr = NULL; /* FIXME: what should it be? */
                    ret = TRUE;
                    break;
                }
            }
        }
        LeaveCriticalSection(&set->cs);
    }
    if (!*ppvFuncAddr)
        ret = CRYPT_GetFuncFromReg(dwEncodingType, pszOID, set->name,
         ppvFuncAddr, phFuncAddr);
    TRACE("returning %d\n", ret);
    return ret;
}

Referenced by CertVerifyCertificateChainPolicy(), CRYPT_ExportEncryptedKey(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_GenKey(), CRYPT_GetCreateFunction(), CRYPT_GetRetrieveFunction(), CRYPT_ImportEncryptedKey(), CRYPT_ImportPublicKeyInfoEx(), CRYPT_LoadDecoderExFunc(), CRYPT_LoadDecoderFunc(), CRYPT_LoadEncoderExFunc(), CRYPT_LoadEncoderFunc(), CRYPT_ProvOpenStore(), CryptExportPublicKeyInfoEx(), CryptFormatObject(), CryptGetObjectUrl(), CryptImportPublicKeyInfoEx(), test_installOIDFunctionAddress(), and test_oidFunctionSet().

CryptGetOIDFunctionValue()

BOOL WINAPI CryptGetOIDFunctionValue	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		LPCSTR	pszOID,
		LPCWSTR	pwszValueName,
		DWORD *	pdwValueType,
		BYTE *	pbValueData,
		DWORD *	pcbValueData
	)

Definition at line 854 of file oid.c.

{
    LPSTR szKey;
    LONG rc;
    HKEY hKey;
 
    TRACE("%x %s %s %s %p %p %p\n", dwEncodingType, debugstr_a(pszFuncName),
     debugstr_a(pszOID), debugstr_w(pwszValueName), pdwValueType, pbValueData,
     pcbValueData);
 
    if (!GET_CERT_ENCODING_TYPE(dwEncodingType))
        return TRUE;
 
    if (!pszFuncName || !pszOID || !pwszValueName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
    rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
    CryptMemFree(szKey);
    if (rc)
        SetLastError(rc);
    else
    {
        rc = RegQueryValueExW(hKey, pwszValueName, NULL, pdwValueType,
         pbValueData, pcbValueData);
        if (rc)
            SetLastError(rc);
        RegCloseKey(hKey);
    }
    return !rc;
}

CryptInitOIDFunctionSet()

HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet	(	LPCSTR	pszFuncName,
		DWORD	dwFlags
	)

Definition at line 114 of file oid.c.

{
    struct OIDFunctionSet *cursor, *ret = NULL;
 
    TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags);
 
    EnterCriticalSection(&funcSetCS);
    LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next)
    {
        if (!strcasecmp(pszFuncName, cursor->name))
        {
            ret = cursor;
            break;
        }
    }
    if (!ret)
    {
        ret = CryptMemAlloc(sizeof(struct OIDFunctionSet));
        if (ret)
        {
            memset(ret, 0, sizeof(*ret));
            ret->name = CryptMemAlloc(strlen(pszFuncName) + 1);
            if (ret->name)
            {
                InitializeCriticalSection(&ret->cs);
                ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": OIDFunctionSet.cs");
                list_init(&ret->functions);
                strcpy(ret->name, pszFuncName);
                list_add_tail(&funcSets, &ret->next);
            }
            else
            {
                CryptMemFree(ret);
                ret = NULL;
            }
        }
    }
    LeaveCriticalSection(&funcSetCS);
 
    return ret;
}

Referenced by CertVerifyCertificateChainPolicy(), CertVerifyRevocation(), CRYPT_ExportEncryptedKey(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_GenKey(), CRYPT_GetCreateFunction(), CRYPT_GetRetrieveFunction(), CRYPT_ImportEncryptedKey(), CRYPT_ImportPublicKeyInfoEx(), CRYPT_LoadDecoderExFunc(), CRYPT_LoadDecoderFunc(), CRYPT_LoadEncoderExFunc(), CRYPT_LoadEncoderFunc(), CRYPT_ProvOpenStore(), CryptExportPublicKeyInfoEx(), CryptFormatObject(), CryptGetObjectUrl(), CryptImportPublicKeyInfoEx(), CryptInstallOIDFunctionAddress(), test_getDefaultOIDFunctionAddress(), test_installOIDFunctionAddress(), and test_oidFunctionSet().

CryptInstallOIDFunctionAddress()

BOOL WINAPI CryptInstallOIDFunctionAddress	(	HMODULE	hModule,
		DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		DWORD	cFuncEntry,
		const CRYPT_OID_FUNC_ENTRY	rgFuncEntry[],
		DWORD	dwFlags
	)

Definition at line 237 of file oid.c.

{
    BOOL ret = TRUE;
    struct OIDFunctionSet *set;
 
    TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType,
     debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags);
 
    set = CryptInitOIDFunctionSet(pszFuncName, 0);
    if (set)
    {
        DWORD i;
 
        EnterCriticalSection(&set->cs);
        for (i = 0; ret && i < cFuncEntry; i++)
        {
            struct OIDFunction *func;
 
            TRACE("OID %s, func %p\n", debugstr_a(rgFuncEntry[i].pszOID), rgFuncEntry[i].pvFuncAddr);
 
            if (!IS_INTOID(rgFuncEntry[i].pszOID))
                func = CryptMemAlloc(sizeof(struct OIDFunction)
                 + strlen(rgFuncEntry[i].pszOID) + 1);
            else
                func = CryptMemAlloc(sizeof(struct OIDFunction));
            if (func)
            {
                func->encoding = GET_CERT_ENCODING_TYPE(dwEncodingType);
                if (!IS_INTOID(rgFuncEntry[i].pszOID))
                {
                    LPSTR oid;
 
                    oid = (LPSTR)((LPBYTE)func + sizeof(*func));
                    strcpy(oid, rgFuncEntry[i].pszOID);
                    func->entry.pszOID = oid;
                }
                else
                    func->entry.pszOID = rgFuncEntry[i].pszOID;
                func->entry.pvFuncAddr = rgFuncEntry[i].pvFuncAddr;
                func->hModule = hModule;
                list_add_tail(&set->functions, &func->next);
            }
            else
                ret = FALSE;
        }
        LeaveCriticalSection(&set->cs);
    }
    else
        ret = FALSE;
    return ret;
}

Referenced by test_installOIDFunctionAddress().

CryptRegisterDefaultOIDFunction()

BOOL WINAPI CryptRegisterDefaultOIDFunction	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		DWORD	dwIndex,
		LPCWSTR	pwszDll
	)

Definition at line 1109 of file oid.c.

{
    HKEY key;
    LPWSTR dlls;
    BOOL ret = FALSE;
 
    TRACE("(%x, %s, %d, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
     dwIndex, debugstr_w(pwszDll));
 
    if (!pwszDll)
    {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
 
    if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key))
        return FALSE;
 
    dlls = CRYPT_GetDefaultOIDDlls(key);
    if (CRYPT_FindStringInMultiString(dlls, pwszDll))
        SetLastError(ERROR_FILE_EXISTS);
    else
    {
        dlls = CRYPT_AddStringToMultiString(dlls, pwszDll, dwIndex);
        if (dlls)
            ret = CRYPT_SetDefaultOIDDlls(key, dlls);
    }
    CryptMemFree(dlls);
    RegCloseKey(key);
    return ret;
}

Referenced by DllRegisterServer(), test_getDefaultOIDFunctionAddress(), and test_registerDefaultOIDFunction().

CryptRegisterOIDFunction()

BOOL WINAPI CryptRegisterOIDFunction	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		LPCSTR	pszOID,
		LPCWSTR	pwszDll,
		LPCSTR	pszOverrideFuncName
	)

Definition at line 647 of file oid.c.

{
    LONG r;
    HKEY hKey;
    LPSTR szKey;
 
    TRACE("(%x, %s, %s, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
          debugstr_a(pszOID), debugstr_w(pwszDll), debugstr_a(pszOverrideFuncName));
 
    /* Native does nothing pwszDll is NULL */
    if (!pwszDll)
        return TRUE;
 
    /* I'm not matching MS bug for bug here, because I doubt any app depends on
     * it:  native "succeeds" if pszFuncName is NULL, but the nonsensical entry
     * it creates would never be used.
     */
    if (!pszFuncName || !pszOID)
    {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
 
    szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
    TRACE("Key name is %s\n", debugstr_a(szKey));
 
    if (!szKey)
        return FALSE;
 
    r = RegCreateKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
    CryptMemFree(szKey);
 
    if (r != ERROR_SUCCESS) goto error_close_key;
 
    /* write the values */
    if (pszOverrideFuncName)
    {
        r = RegSetValueExA(hKey, "FuncName", 0, REG_SZ,
             (const BYTE*)pszOverrideFuncName, lstrlenA(pszOverrideFuncName) + 1);
        if (r != ERROR_SUCCESS) goto error_close_key;
    }
    r = RegSetValueExW(hKey, DllW, 0, REG_SZ, (const BYTE*) pwszDll,
         (lstrlenW(pwszDll) + 1) * sizeof (WCHAR));
 
error_close_key:
 
    RegCloseKey(hKey);
 
    if (r != ERROR_SUCCESS) 
    {
        SetLastError(r);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DllRegisterServer(), and test_registerOIDFunction().

CryptRegisterOIDInfo()

BOOL WINAPI CryptRegisterOIDInfo	(	PCCRYPT_OID_INFO	info,
		DWORD	flags
	)

Definition at line 750 of file oid.c.

{
    char *key_name;
    HKEY root = 0, key = 0;
    DWORD err;
 
    TRACE("(%p, %x)\n", info, flags );
 
    if (!info || info->cbSize != sizeof(*info) || !info->pszOID)
    {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
 
    if (!info->dwGroupId) return TRUE;
 
    key_name = CryptMemAlloc(strlen(info->pszOID) + 16);
    if (!key_name)
    {
        err = ERROR_OUTOFMEMORY;
        goto done;
    }
 
    err = RegCreateKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo",
                          0, NULL, 0, KEY_ALL_ACCESS, NULL, &root, NULL);
    if (err != ERROR_SUCCESS) goto done;
 
    sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId);
    err = RegCreateKeyA(root, key_name, &key);
    if (err != ERROR_SUCCESS) goto done;
 
    if (flags)
    {
        err = RegSetValueExW(key, flagsW, 0, REG_DWORD, (const BYTE *)&flags, sizeof(flags));
        if (err != ERROR_SUCCESS) goto done;
    }
 
    if (info->pwszName)
    {
        err = RegSetValueExW(key, nameW, 0, REG_SZ, (const BYTE *)info->pwszName, (lstrlenW(info->pwszName) + 1) * sizeof(WCHAR));
        if (err != ERROR_SUCCESS) goto done;
    }
 
    if (info->u.Algid)
    {
        err = RegSetValueExW(key, algidW, 0, REG_DWORD, (const BYTE *)&info->u.Algid, sizeof(info->u.Algid));
        if (err != ERROR_SUCCESS) goto done;
    }
 
    if (info->ExtraInfo.cbData && info->ExtraInfo.pbData)
    {
        err = RegSetValueExW(key, extraW, 0, REG_BINARY, info->ExtraInfo.pbData, info->ExtraInfo.cbData);
        if (err != ERROR_SUCCESS) goto done;
    }
 
    if (info->pwszCNGAlgid)
    {
        err = RegSetValueExW(key, cngalgidW, 0, REG_SZ, (const BYTE *)info->pwszCNGAlgid, (lstrlenW(info->pwszCNGAlgid) + 1) * sizeof(WCHAR));
        if (err != ERROR_SUCCESS) goto done;
    }
 
    if (info->pwszCNGExtraAlgid)
    {
        err = RegSetValueExW(key, cngextraalgidW, 0, REG_SZ, (const BYTE *)info->pwszCNGExtraAlgid, (lstrlenW(info->pwszCNGExtraAlgid) + 1) * sizeof(WCHAR));
        if (err != ERROR_SUCCESS) goto done;
    }
 
done:
    CryptMemFree(key_name);
    if (key) RegCloseKey(key);
    if (root) RegCloseKey(root);
 
    if (err)
        SetLastError(err);
 
    return !err;
}

Referenced by test_registerOIDInfo().

CryptSetOIDFunctionValue()

BOOL WINAPI CryptSetOIDFunctionValue	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		LPCSTR	pszOID,
		LPCWSTR	pwszValueName,
		DWORD	dwValueType,
		const BYTE *	pbValueData,
		DWORD	cbValueData
	)

Definition at line 891 of file oid.c.

{
    LPSTR szKey;
    LONG rc;
    HKEY hKey;
 
    TRACE("%x %s %s %s %d %p %d\n", dwEncodingType, debugstr_a(pszFuncName),
     debugstr_a(pszOID), debugstr_w(pwszValueName), dwValueType, pbValueData,
     cbValueData);
 
    if (!GET_CERT_ENCODING_TYPE(dwEncodingType))
        return TRUE;
 
    if (!pszFuncName || !pszOID || !pwszValueName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
    rc = RegOpenKeyA(HKEY_LOCAL_MACHINE, szKey, &hKey);
    CryptMemFree(szKey);
    if (rc)
        SetLastError(rc);
    else
    {
        rc = RegSetValueExW(hKey, pwszValueName, 0, dwValueType, pbValueData,
         cbValueData);
        if (rc)
            SetLastError(rc);
        RegCloseKey(hKey);
    }
    return !rc;
}

CryptUnregisterDefaultOIDFunction()

BOOL WINAPI CryptUnregisterDefaultOIDFunction	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		LPCWSTR	pwszDll
	)

Definition at line 1142 of file oid.c.

{
    HKEY key;
    LPWSTR dlls;
    BOOL ret;
 
    TRACE("(%x, %s, %s)\n", dwEncodingType, debugstr_a(pszFuncName),
     debugstr_w(pwszDll));
 
    if (!pwszDll)
    {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
 
    if (!CRYPT_GetDefaultOIDKey(dwEncodingType, pszFuncName, &key))
        return FALSE;
 
    dlls = CRYPT_GetDefaultOIDDlls(key);
    if ((ret = CRYPT_RemoveStringFromMultiString(dlls, pwszDll)))
        ret = CRYPT_SetDefaultOIDDlls(key, dlls);
    CryptMemFree(dlls);
    RegCloseKey(key);
    return ret;
}

Referenced by DllUnregisterServer(), test_getDefaultOIDFunctionAddress(), and test_registerDefaultOIDFunction().

CryptUnregisterOIDFunction()

BOOL WINAPI CryptUnregisterOIDFunction	(	DWORD	dwEncodingType,
		LPCSTR	pszFuncName,
		LPCSTR	pszOID
	)

Definition at line 831 of file oid.c.

{
    LPSTR szKey;
    LONG rc;
 
    TRACE("%x %s %s\n", dwEncodingType, debugstr_a(pszFuncName),
     debugstr_a(pszOID));
 
    if (!pszFuncName || !pszOID)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    szKey = CRYPT_GetKeyName(dwEncodingType, pszFuncName, pszOID);
    rc = RegDeleteKeyA(HKEY_LOCAL_MACHINE, szKey);
    CryptMemFree(szKey);
    if (rc)
        SetLastError(rc);
    return !rc;
}

Referenced by DllUnregisterServer(), and test_registerOIDFunction().

CryptUnregisterOIDInfo()

BOOL WINAPI CryptUnregisterOIDInfo

(

PCCRYPT_OID_INFO

info

)

Definition at line 708 of file oid.c.

{
    char *key_name;
    HKEY root;
    DWORD err;
 
    TRACE("(%p)\n", info);
 
    if (!info || info->cbSize != sizeof(*info) || !info->pszOID)
    {
        SetLastError(E_INVALIDARG);
        return FALSE;
    }
 
    err = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo", 0, KEY_ALL_ACCESS, &root);
    if (err != ERROR_SUCCESS)
    {
        SetLastError(err);
        return FALSE;
    }
 
    key_name = CryptMemAlloc(strlen(info->pszOID) + 16);
    if (key_name)
    {
        sprintf(key_name, "%s!%u", info->pszOID, info->dwGroupId);
        err = RegDeleteKeyA(root, key_name);
    }
    else
        err = ERROR_OUTOFMEMORY;
 
    CryptMemFree(key_name);
    RegCloseKey(root);
 
    if (err)
        SetLastError(err);
 
    return !err;
}

Referenced by test_registerOIDInfo().

free_function_sets()

static void free_function_sets ( void  )

static

Definition at line 87 of file oid.c.

{
    struct OIDFunctionSet *setCursor, *setNext;
 
    LIST_FOR_EACH_ENTRY_SAFE(setCursor, setNext, &funcSets,
     struct OIDFunctionSet, next)
    {
        struct OIDFunction *functionCursor, *funcNext;
 
        list_remove(&setCursor->next);
        CryptMemFree(setCursor->name);
        LIST_FOR_EACH_ENTRY_SAFE(functionCursor, funcNext,
         &setCursor->functions, struct OIDFunction, next)
        {
            list_remove(&functionCursor->next);
            CryptMemFree(functionCursor);
        }
        setCursor->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&setCursor->cs);
        CryptMemFree(setCursor);
    }
    DeleteCriticalSection(&funcSetCS);
}

Referenced by crypt_oid_free().

free_oid_info()

static void free_oid_info ( void  )

static

Definition at line 1761 of file oid.c.

{
    struct OIDInfo *info, *next;
 
    LIST_FOR_EACH_ENTRY_SAFE(info, next, &oidInfo, struct OIDInfo, entry)
    {
        list_remove(&info->entry);
        CryptMemFree(info);
    }
    DeleteCriticalSection(&oidInfoCS);
}

Referenced by crypt_oid_free().

init_oid_info()

static void init_oid_info ( void  )

static

Definition at line 1690 of file oid.c.

{
    DWORD i;
 
    oid_init_localizednames();
    for (i = 0; i < ARRAY_SIZE(oidInfoConstructors); i++)
    {
        if (!IS_INTRESOURCE(oidInfoConstructors[i].pwszName))
        {
            struct OIDInfo *info;
 
            /* The name is a static string, so just use the same pointer */
            info = CryptMemAlloc(sizeof(struct OIDInfo));
            if (info)
            {
                memset(info, 0, sizeof(*info));
                info->info.cbSize = sizeof(CRYPT_OID_INFO);
                info->info.pszOID = oidInfoConstructors[i].pszOID;
                info->info.pwszName = oidInfoConstructors[i].pwszName;
                info->info.dwGroupId = oidInfoConstructors[i].dwGroupId;
                info->info.u.Algid = oidInfoConstructors[i].Algid;
                if (oidInfoConstructors[i].blob)
                {
                    info->info.ExtraInfo.cbData =
                     oidInfoConstructors[i].blob->cbData;
                    info->info.ExtraInfo.pbData =
                     oidInfoConstructors[i].blob->pbData;
                }
                info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid;
                info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid;
                list_add_tail(&oidInfo, &info->entry);
            }
        }
        else
        {
            LPCWSTR stringresource;
            int len = LoadStringW(hInstance,
             (UINT_PTR)oidInfoConstructors[i].pwszName,
             (LPWSTR)&stringresource, 0);
 
            if (len)
            {
                struct OIDInfo *info = CryptMemAlloc(sizeof(struct OIDInfo) +
                 (len + 1) * sizeof(WCHAR));
 
                if (info)
                {
                    memset(info, 0, sizeof(*info));
                    info->info.cbSize = sizeof(CRYPT_OID_INFO);
                    info->info.pszOID = oidInfoConstructors[i].pszOID;
                    info->info.pwszName = (LPWSTR)(info + 1);
                    info->info.dwGroupId = oidInfoConstructors[i].dwGroupId;
                    info->info.u.Algid = oidInfoConstructors[i].Algid;
                    memcpy(info + 1, stringresource, len*sizeof(WCHAR));
                    ((LPWSTR)(info + 1))[len] = 0;
                    if (oidInfoConstructors[i].blob)
                    {
                        info->info.ExtraInfo.cbData =
                         oidInfoConstructors[i].blob->cbData;
                        info->info.ExtraInfo.pbData =
                         oidInfoConstructors[i].blob->pbData;
                    }
                    info->info.pwszCNGAlgid = oidInfoConstructors[i].pwszCNGAlgid;
                    info->info.pwszCNGExtraAlgid = oidInfoConstructors[i].pwszCNGExtraAlgid;
                    list_add_tail(&oidInfo, &info->entry);
                }
            }
        }
    }
}

Referenced by crypt_oid_init().

init_registered_oid_info()

static void init_registered_oid_info ( void  )

static

Definition at line 1650 of file oid.c.

{
    DWORD err, idx;
    HKEY root;
 
    err = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Cryptography\\OID\\EncodingType 0\\CryptDllFindOIDInfo",
                        0, KEY_ALL_ACCESS, &root);
    if (err != ERROR_SUCCESS) return;
 
    idx = 0;
    for (;;)
    {
        char key_name[MAX_PATH];
        struct OIDInfo *info;
        DWORD flags;
 
        err = RegEnumKeyA(root, idx++, key_name, MAX_PATH);
        if (err == ERROR_NO_MORE_ITEMS)
            break;
 
        if (err == ERROR_SUCCESS)
        {
            if ((info = read_oid_info(root, key_name, &flags)))
            {
                TRACE("adding oid %s, name %s, groupid %u, algid %u, extra %u, CNG algid %s, CNG extra %s\n",
                      debugstr_a(info->info.pszOID), debugstr_w(info->info.pwszName),
                      info->info.dwGroupId, info->info.u.Algid, info->info.ExtraInfo.cbData,
                      debugstr_w(info->info.pwszCNGAlgid), debugstr_w(info->info.pwszCNGExtraAlgid));
 
                if (flags & CRYPT_INSTALL_OID_INFO_BEFORE_FLAG)
                    list_add_head(&oidInfo, &info->entry);
                else
                    list_add_tail(&oidInfo, &info->entry);
            }
        }
    }
 
    RegCloseKey(root);
}

Referenced by crypt_oid_init().

is_module_registered()

static BOOL is_module_registered ( HMODULE  hModule )

static

Definition at line 436 of file oid.c.

{
    struct OIDFunctionSet *set;
    BOOL ret = FALSE;
 
    EnterCriticalSection(&funcSetCS);
 
    LIST_FOR_EACH_ENTRY(set, &funcSets, struct OIDFunctionSet, next)
    {
        struct OIDFunction *function;
 
        EnterCriticalSection(&set->cs);
 
        LIST_FOR_EACH_ENTRY(function, &set->functions, struct OIDFunction, next)
        {
            if (function->hModule == hModule)
            {
                ret = TRUE;
                break;
            }
        }
 
        LeaveCriticalSection(&set->cs);
 
        if (ret) break;
    }
 
    LeaveCriticalSection(&funcSetCS);
 
    return ret;
}

Referenced by CryptFreeOIDFunctionAddress().

oid_init_localizednames()

static void oid_init_localizednames ( void  )

static

Definition at line 1169 of file oid.c.

{
    unsigned int i;
 
    for(i = 0; i < ARRAY_SIZE(LocalizedKeys); i++)
    {
        LoadStringW(hInstance, IDS_LOCALIZEDNAME_ROOT+i, LocalizedNames[i], 256);
    }
}

Referenced by init_oid_info().

read_oid_info()

static struct OIDInfo * read_oid_info ( HKEY  root, char *  key_name, DWORD *  flags  )

static

Definition at line 1571 of file oid.c.

{
    HKEY key;
    DWORD len, oid_len, name_len = 0, extra_len = 0, cngalgid_len = 0, cngextra_len = 0, group_id = 0;
    struct OIDInfo *info;
    char *p;
 
    if (RegOpenKeyExA(root, key_name, 0, KEY_READ, &key))
        return NULL;
 
    p = strchr(key_name, '!');
    if (p)
    {
        group_id = strtol(p + 1, NULL, 10);
        *p = 0;
    }
 
    oid_len = strlen(key_name) + 1;
 
    RegQueryValueExW(key, nameW, NULL, NULL, NULL, &name_len);
    RegQueryValueExW(key, extraW, NULL, NULL, NULL, &extra_len);
    RegQueryValueExW(key, cngalgidW, NULL, NULL, NULL, &cngalgid_len);
    RegQueryValueExW(key, cngextraalgidW, NULL, NULL, NULL, &cngextra_len);
 
    info = CryptMemAlloc(sizeof(*info) + oid_len + name_len + extra_len + cngalgid_len + cngextra_len);
    if (info)
    {
        *flags = 0;
        len = sizeof(*flags);
        RegQueryValueExW(key, flagsW, NULL, NULL, (BYTE *)flags, &len);
 
        memset(info, 0, sizeof(*info));
        info->info.cbSize = sizeof(info->info);
 
        p = (char *)(info + 1);
 
        info->info.pszOID = p;
        strcpy((char *)info->info.pszOID, key_name);
        p += oid_len;
 
        if (name_len)
        {
            info->info.pwszName = (WCHAR *)p;
            RegQueryValueExW(key, nameW, NULL, NULL, (BYTE *)info->info.pwszName, &name_len);
            p += name_len;
        }
 
        info->info.dwGroupId = group_id;
 
        len = sizeof(info->info.u.Algid);
        RegQueryValueExW(key, algidW, NULL, NULL, (BYTE *)&info->info.u.Algid, &len);
 
        if (extra_len)
        {
            info->info.ExtraInfo.cbData = extra_len;
            info->info.ExtraInfo.pbData = (BYTE *)p;
            RegQueryValueExW(key, extraW, NULL, NULL, info->info.ExtraInfo.pbData, &extra_len);
            p += extra_len;
        }
 
        if (cngalgid_len)
        {
            info->info.pwszCNGAlgid = (WCHAR *)p;
            RegQueryValueExW(key, cngalgidW, NULL, NULL, (BYTE *)info->info.pwszCNGAlgid, &cngalgid_len);
            p += cngalgid_len;
        }
 
        if (cngextra_len)
        {
            info->info.pwszCNGExtraAlgid = (WCHAR *)p;
            RegQueryValueExW(key, cngextraalgidW, NULL, NULL, (BYTE *)info->info.pwszCNGExtraAlgid, &cngalgid_len);
        }
    }
 
    RegCloseKey(key);
 
    return info;
}

Referenced by init_registered_oid_info().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

crypt

)

Variable Documentation

ADDRESSBOOK

const WCHAR ADDRESSBOOK[] = {'A','D','D','R','E','S','S','B','O','O','K',0}

static

Definition at line 74 of file oid.c.

algidW

const WCHAR algidW[] = { 'A','l','g','i','d',0 }

static

Definition at line 81 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

C

const WCHAR C[] = { 'C',0 }

static

Definition at line 1254 of file oid.c.

CA

const WCHAR CA[] = {'C','A',0}

static

Definition at line 73 of file oid.c.

Referenced by test_crypt_ui_wiz_import().

cms3deswrap

const WCHAR cms3deswrap[]

static

Initial value:

= { 'C','M','S','3','D','E','S','w','r','a',
 'p',0 }

Definition at line 1209 of file oid.c.

cmsrc2wrap

const WCHAR cmsrc2wrap[] = { 'C','M','S','R','C','2','w','r','a','p',0 }

static

Definition at line 1211 of file oid.c.

CN

const WCHAR CN[] = { 'C','N',0 }

static

Definition at line 1249 of file oid.c.

cngalgidW

const WCHAR cngalgidW[] = { 'C','N','G','A','l','g','i','d',0 }

static

Definition at line 83 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

cngextraalgidW

const WCHAR cngextraalgidW[] = { 'C','N','G','E','x','t','r','a','A','l','g','i','d',0 }

static

Definition at line 84 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

DC

const WCHAR DC[] = { 'D','C',0 }

static

Definition at line 1265 of file oid.c.

des

const WCHAR des[] = { 'd','e','s',0 }

static

Definition at line 1212 of file oid.c.

Referenced by ConvertULargeInteger(), des_ecb_decrypt(), des_ecb_encrypt(), des_setup(), and test_des().

Description

const WCHAR Description[]

static

Initial value:

=
 { 'D','e','s','c','r','i','p','t','i','o','n',0 }

Definition at line 1266 of file oid.c.

Referenced by BiGetObjectDescription(), BmGetEntryDescription(), BmpPopulateBootEntryList(), ChannelGetDescription(), ChannelSetDescription(), CreateFreeLoaderIniForReactOSAndBootSector(), DoDESCRIPTIONS(), FindDmaDescriptor(), FindIoDescriptor(), FindIrqDescriptor(), FindMemoryDescriptor(), FindMethodHandler(), FindPropertyHandler(), GetPartitionTypeString(), GreenPnp(), InstallFatBootcodeToPartition(), InstallOneService(), IsaConvertDmaRequirement(), IsaConvertIoRequirement(), IsaConvertIrqRequirement(), IsaConvertMemRange32Requirement(), IsaConvertMemRangeRequirement(), MMixerGetChannelCountEnhanced(), NdisMAllocateMapRegisters(), NtLdrOutputLoadMsg(), ODBC32_SQLDataSources(), ODBC32_SQLDataSourcesA(), ODBC32_SQLDataSourcesW(), ParseTags(), PciCreateDeviceDescriptionString(), PciGetDescriptionMessage(), QueryTimeZoneData(), ScControl(), SerenumPdoPnp(), SetDescription(), TestEnumFontFamilies(), FxChildList::UpdateAsMissing(), WshShortcut_get_Description(), and WshShortcut_put_Description().

DH

const WCHAR DH[] = { 'D','H',0 }

static

Definition at line 1228 of file oid.c.

DISALLOWED

const WCHAR DISALLOWED[] = {'D','i','s','a','l','l','o','w','e','d',0}

static

Definition at line 76 of file oid.c.

DllW

const WCHAR DllW[] = { 'D','l','l',0 }

static

Definition at line 43 of file oid.c.

Referenced by CRYPT_GetDefaultOIDDlls(), CRYPT_GetFuncFromReg(), CRYPT_SetDefaultOIDDlls(), CryptGetDefaultOIDDllList(), and CryptRegisterOIDFunction().

dnQualifier

const WCHAR dnQualifier[]

static

Initial value:

=
 { 'd','n','Q','u','a','l','i','f','i','e','r',0 }

Definition at line 1272 of file oid.c.

domainCompTypes

const DWORD domainCompTypes[]

static

Initial value:

= { CERT_RDN_IA5_STRING,
 CERT_RDN_UTF8_STRING, 0 }

Definition at line 1307 of file oid.c.

domainCompTypesBlob

const CRYPT_DATA_BLOB domainCompTypesBlob

static

Initial value:

= { sizeof(domainCompTypes),
 (LPBYTE)domainCompTypes }

Definition at line 1315 of file oid.c.

DSA

const WCHAR DSA[] = { 'D','S','A',0 }

static

Definition at line 1226 of file oid.c.

DSA_SIGN

const WCHAR DSA_SIGN[] = { 'D','S','A','_','S','I','G','N',0 }

static

Definition at line 1227 of file oid.c.

dsaSHA1

const WCHAR dsaSHA1[] = { 'd','s','a','S','H','A','1',0 }

static

Definition at line 1234 of file oid.c.

DSS

const WCHAR DSS[] = { 'D','S','S',0 }

static

Definition at line 1229 of file oid.c.

dssSign

const DWORD dssSign[2]

static

Initial value:

= { CALG_DSS_SIGN,
 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }

Definition at line 1290 of file oid.c.

dssSignBlob

const CRYPT_DATA_BLOB dssSignBlob

static

Initial value:

= { sizeof(dssSign),
 (LPBYTE)dssSign }

Definition at line 1298 of file oid.c.

E

const WCHAR E[] = { 'E',0 }

static

Definition at line 1253 of file oid.c.

Referenced by ios_base::_M_invoke_callbacks(), ATL::CAtlArray< E, ETraits >::Add(), ATL::CAtlArray< E, ETraits >::CreateItems(), FillTable(), gl_xform_normals_3fv(), ATL::CAtlArray< E, ETraits >::GrowAllocatedData(), IntEngLineTo(), monoPolyPart(), ATL::CAtlList< E, ETraits >::RemoveHead(), ATL::CAtlList< E, ETraits >::RemoveTail(), and UDFNotifyFullReportChange().

ecdsaSign

const DWORD ecdsaSign[2] = { CALG_OID_INFO_PARAMETERS, CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }

static

Definition at line 1295 of file oid.c.

ecdsaSignBlob

const CRYPT_DATA_BLOB ecdsaSignBlob = { sizeof(ecdsaSign), (BYTE *)ecdsaSign }

static

Definition at line 1302 of file oid.c.

Email

const WCHAR Email[] = { 'E','m','a','i','l',0 }

static

Definition at line 1277 of file oid.c.

ESDH

const WCHAR ESDH[] = { 'E','S','D','H',0 }

static

Definition at line 1232 of file oid.c.

extraW

const WCHAR extraW[] = { 'E','x','t','r','a','I','n','f','o',0 }

static

Definition at line 82 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

flagsW

const WCHAR flagsW[] = { 'F','l','a','g','s',0 }

static

Definition at line 85 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

funcSetCS

static CRITICAL_SECTION funcSetCS = { &funcSetCSDebug, -1, 0, 0, 0, 0 }

static

Definition at line 45 of file oid.c.

Referenced by CryptInitOIDFunctionSet(), free_function_sets(), and is_module_registered().

funcSetCSDebug

CRITICAL_SECTION_DEBUG funcSetCSDebug

static

Initial value:

=
{
    0, 0, &funcSetCS,
    { &funcSetCSDebug.ProcessLocksList, &funcSetCSDebug.ProcessLocksList },
    0, 0, { (DWORD_PTR)(__FILE__ ": funcSetCS") }
}

Definition at line 46 of file oid.c.

funcSets

struct list funcSets = { &funcSets, &funcSets }

static

Definition at line 53 of file oid.c.

Referenced by CryptInitOIDFunctionSet(), free_function_sets(), and is_module_registered().

G

const WCHAR G[] = { 'G',0 }

static

Definition at line 1260 of file oid.c.

GivenName

const WCHAR GivenName[] = { 'G','i','v','e','n','N','a','m','e',0 }

static

Definition at line 1261 of file oid.c.

GN

const WCHAR GN[] = { 'G','N',0 }

static

Definition at line 1278 of file oid.c.

I

const WCHAR I[] = { 'I',0 }

static

Definition at line 1262 of file oid.c.

ia5String

const DWORD ia5String[] = { CERT_RDN_IA5_STRING, 0 }

static

Definition at line 1304 of file oid.c.

ia5StringBlob

const CRYPT_DATA_BLOB ia5StringBlob

static

Initial value:

= { sizeof(ia5String),
 (LPBYTE)ia5String }

Definition at line 1309 of file oid.c.

Initials

const WCHAR Initials[] = { 'I','n','i','t','i','a','l','s',0 }

static

Definition at line 1263 of file oid.c.

L

const WCHAR L[] = { 'L',0 }

static

Definition at line 1250 of file oid.c.

LocalizedKeys

const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER,DISALLOWED}

static

Definition at line 77 of file oid.c.

Referenced by CryptFindLocalizedName(), and oid_init_localizednames().

LocalizedNames

WCHAR LocalizedNames[ARRAY_SIZE(LocalizedKeys)][256]

static

Definition at line 78 of file oid.c.

Referenced by CryptFindLocalizedName(), and oid_init_localizednames().

md2

const WCHAR md2[] = { 'm','d','2',0 }

static

Definition at line 1213 of file oid.c.

md2RSA

const WCHAR md2RSA[] = { 'm','d','2','R','S','A',0 }

static

Definition at line 1235 of file oid.c.

md4

const WCHAR md4[] = { 'm','d','4',0 }

static

Definition at line 1214 of file oid.c.

md4RSA

const WCHAR md4RSA[] = { 'm','d','4','R','S','A',0 }

static

Definition at line 1236 of file oid.c.

md5

const WCHAR md5[] = { 'm','d','5',0 }

static

Definition at line 1215 of file oid.c.

md5RSA

const WCHAR md5RSA[] = { 'm','d','5','R','S','A',0 }

static

Definition at line 1237 of file oid.c.

mosaicFlags

const DWORD mosaicFlags

static

Initial value:

= CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG |
 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG

Definition at line 1282 of file oid.c.

mosaicFlagsBlob

const CRYPT_DATA_BLOB mosaicFlagsBlob

static

Initial value:

= { sizeof(mosaicFlags),
 (LPBYTE)&mosaicFlags }

Definition at line 1286 of file oid.c.

mosaicKMandUpdSig

const WCHAR mosaicKMandUpdSig[]

static

Initial value:

=
 { 'm','o','s','a','i','c','K','M','a','n','d','U','p','d','S','i','g',0 }

Definition at line 1230 of file oid.c.

mosaicSign

const DWORD mosaicSign[2]

static

Initial value:

= { CALG_DSS_SIGN,
 CRYPT_OID_INHIBIT_SIGNATURE_FORMAT_FLAG |
 CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG }

Definition at line 1292 of file oid.c.

mosaicSignBlob

const CRYPT_DATA_BLOB mosaicSignBlob

static

Initial value:

= { sizeof(mosaicSign),
 (LPBYTE)mosaicSign }

Definition at line 1300 of file oid.c.

mosaicUpdatedSig

const WCHAR mosaicUpdatedSig[]

static

Initial value:

=
 { 'm','o','s','a','i','c','U','p','d','a','t','e','d','S','i','g',0 }

Definition at line 1245 of file oid.c.

MY

const WCHAR MY[] = {'M','Y',0}

static

Definition at line 72 of file oid.c.

nameW

const WCHAR nameW[] = { 'N','a','m','e',0 }

static

Definition at line 80 of file oid.c.

Referenced by CryptRegisterOIDInfo(), and read_oid_info().

NO_SIGN

const WCHAR NO_SIGN[] = { 'N','O','S','I','G','N',0 }

static

Definition at line 1233 of file oid.c.

noNullBlob

const CRYPT_DATA_BLOB noNullBlob

static

Initial value:

= { sizeof(noNullFlag),
 (LPBYTE)&noNullFlag }

Definition at line 1284 of file oid.c.

noNullFlag

const DWORD noNullFlag = CRYPT_OID_NO_NULL_ALGORITHM_PARA_FLAG

static

Definition at line 1281 of file oid.c.

numericString

const DWORD numericString[] = { CERT_RDN_NUMERIC_STRING, 0 }

static

Definition at line 1305 of file oid.c.

numericStringBlob

const CRYPT_DATA_BLOB numericStringBlob

static

Initial value:

= { sizeof(numericString),
 (LPBYTE)numericString }

Definition at line 1311 of file oid.c.

O

const WCHAR O[] = { 'O',0 }

static

Definition at line 1251 of file oid.c.

oidInfo

struct list oidInfo = { &oidInfo, &oidInfo }

static

Definition at line 1206 of file oid.c.

Referenced by add_cert_extension_detail(), add_oid_text_to_control(), cert_name_to_str_with_indent(), CertNameToStrA(), CryptEnumOIDInfo(), CryptFindOIDInfo(), CryptHashToBeSigned(), field_format_public_key(), find_oid_in_list(), free_oid_info(), init_oid_info(), init_registered_oid_info(), and request_query_option().

oidInfoConstructors

const struct OIDInfoConstructor oidInfoConstructors[]

static

Referenced by init_oid_info().

oidInfoCS

static CRITICAL_SECTION oidInfoCS = { &oidInfoCSDebug, -1, 0, 0, 0, 0 }

static

Definition at line 1198 of file oid.c.

Referenced by CryptEnumOIDInfo(), CryptFindOIDInfo(), and free_oid_info().

oidInfoCSDebug

CRITICAL_SECTION_DEBUG oidInfoCSDebug

static

Initial value:

=
{
    0, 0, &oidInfoCS,
    { &oidInfoCSDebug.ProcessLocksList, &oidInfoCSDebug.ProcessLocksList },
    0, 0, { (DWORD_PTR)(__FILE__ ": oidInfoCS") }
}

Definition at line 1199 of file oid.c.

OU

const WCHAR OU[] = { 'O','U',0 }

static

Definition at line 1252 of file oid.c.

Phone

const WCHAR Phone[] = { 'P','h','o','n','e',0 }

static

Definition at line 1270 of file oid.c.

POBox

const WCHAR POBox[] = { 'P','O','B','o','x',0 }

static

Definition at line 1269 of file oid.c.

PostalCode

const WCHAR PostalCode[] = { 'P','o','s','t','a','l','C','o','d','e',0 }

static

Definition at line 1268 of file oid.c.

printableString

const DWORD printableString[] = { CERT_RDN_PRINTABLE_STRING, 0 }

static

Definition at line 1306 of file oid.c.

printableStringBlob

const CRYPT_DATA_BLOB printableStringBlob

static

Initial value:

= { sizeof(printableString),
 (LPBYTE)printableString }

Definition at line 1313 of file oid.c.

rc2

const WCHAR rc2[] = { 'r','c','2',0 }

static

Definition at line 1216 of file oid.c.

Referenced by Window::DoAction(), CUIFToolbarButton::Init(), is_equal_rect(), main_window_procA(), mdi_child_wnd_proc_2(), mdi_main_wnd_procA(), NewExtDlg_OnAdvanced(), NewExtDlg_OnInitDialog(), OnInitDialog(), rc2_ecb_decrypt(), rc2_ecb_encrypt(), rc2_setup(), CUIFToolTip::ShowTip(), test_get_file_info(), test_GetRandomRgn(), test_GetUpdateRect(), test_height(), test_midiStream(), test_PathNameA(), test_scrolldc(), test_scrollwindow(), test_SetWindowPos(), test_validatergn(), and CMenuFocusManager::UpdateFocus().

rc4

const WCHAR rc4[] = { 'r','c','4',0 }

static

Definition at line 1217 of file oid.c.

Referenced by MyDrawCaptionButtons(), and test_rc4().

ROOT

const WCHAR ROOT[] = {'R','O','O','T',0}

static

Definition at line 71 of file oid.c.

RSA

const WCHAR RSA[] = { 'R','S','A',0 }

static

Definition at line 1223 of file oid.c.

Referenced by sec_parse_x509_key().

RSA_KEYX

const WCHAR RSA_KEYX[] = { 'R','S','A','_','K','E','Y','X',0 }

static

Definition at line 1224 of file oid.c.

RSA_SIGN

const WCHAR RSA_SIGN[] = { 'R','S','A','_','S','I','G','N',0 }

static

Definition at line 1225 of file oid.c.

rsaSign

const DWORD rsaSign = CALG_RSA_SIGN

static

Definition at line 1289 of file oid.c.

rsaSignBlob

const CRYPT_DATA_BLOB rsaSignBlob

static

Initial value:

= { sizeof(rsaSign),
 (LPBYTE)&rsaSign }

Definition at line 1296 of file oid.c.

S

const WCHAR S[] = { 'S',0 }

static

Definition at line 1255 of file oid.c.

SERIALNUMBER

const WCHAR SERIALNUMBER[] = { 'S','E','R','I','A','L','N','U','M','B','E','R',0 }

static

Definition at line 1279 of file oid.c.

sha

const WCHAR sha[] = { 's','h','a',0 }

static

Definition at line 1218 of file oid.c.

Referenced by sec_hash_48(), sec_hash_sha1_16(), sec_sign(), sec_update(), sha_check(), and VerifyInteg().

sha1

const WCHAR sha1[] = { 's','h','a','1',0 }

static

Definition at line 1219 of file oid.c.

Referenced by test_findOIDInfo().

sha1DSA

const WCHAR sha1DSA[] = { 's','h','a','1','D','S','A',0 }

static

Definition at line 1239 of file oid.c.

sha1RSA

const WCHAR sha1RSA[] = { 's','h','a','1','R','S','A',0 }

static

Definition at line 1241 of file oid.c.

sha256

const WCHAR sha256[] = { 's','h','a','2','5','6',0 }

static

Definition at line 1220 of file oid.c.

sha256ECDSA

const WCHAR sha256ECDSA[] = { 's','h','a','2','5','6','E','C','D','S','A',0 }

static

Definition at line 1247 of file oid.c.

Referenced by test_findOIDInfo().

sha256RSA

const WCHAR sha256RSA[] = { 's','h','a','2','5','6','R','S','A',0 }

static

Definition at line 1242 of file oid.c.

sha384

const WCHAR sha384[] = { 's','h','a','3','8','4',0 }

static

Definition at line 1221 of file oid.c.

Referenced by test_sha384().

sha384ECDSA

const WCHAR sha384ECDSA[] = { 's','h','a','3','8','4','E','C','D','S','A',0 }

static

Definition at line 1248 of file oid.c.

sha384RSA

const WCHAR sha384RSA[] = { 's','h','a','3','8','4','R','S','A',0 }

static

Definition at line 1243 of file oid.c.

sha512

const WCHAR sha512[] = { 's','h','a','5','1','2',0 }

static

Definition at line 1222 of file oid.c.

sha512RSA

const WCHAR sha512RSA[] = { 's','h','a','5','1','2','R','S','A',0 }

static

Definition at line 1244 of file oid.c.

shaDSA

const WCHAR shaDSA[] = { 's','h','a','D','S','A',0 }

static

Definition at line 1238 of file oid.c.

shaRSA

const WCHAR shaRSA[] = { 's','h','a','R','S','A',0 }

static

Definition at line 1240 of file oid.c.

SN

const WCHAR SN[] = { 'S','N',0 }

static

Definition at line 1264 of file oid.c.

SpcFinancialCriteria

const WCHAR SpcFinancialCriteria[] = { 'S','p','c','F','i','n','a','n','c','i','a','l','C','r','i','t','e','r','i','a',0 }

static

Definition at line 1275 of file oid.c.

SpcMinimalCriteria

const WCHAR SpcMinimalCriteria[] = { 'S','p','c','M','i','n','i','m','a','l','C','r','i','t','e','r','i','a',0 }

static

Definition at line 1276 of file oid.c.

SpcSpAgencyInfo

const WCHAR SpcSpAgencyInfo[] = { 'S','p','c','S','p','A','g','e','n','c','y','I','n','f','o',0 }

static

Definition at line 1274 of file oid.c.

ST

const WCHAR ST[] = { 'S','T',0 }

static

Definition at line 1256 of file oid.c.

STREET

const WCHAR STREET[] = { 'S','T','R','E','E','T',0 }

static

Definition at line 1257 of file oid.c.

T

const WCHAR T[] = { 'T',0 }

static

Definition at line 1258 of file oid.c.

Title

const WCHAR Title[] = { 'T','i','t','l','e',0 }

static

Definition at line 1259 of file oid.c.

Referenced by AcpiRsDumpResourceLabel(), AcpiRsOutInteger16(), AcpiRsOutInteger32(), AcpiRsOutInteger64(), AcpiRsOutInteger8(), AcpiRsOutString(), AcpiRsOutTitle(), BasePushProcessParameters(), CShellDispatch::BrowseForFolder(), CHSourceDlgProc(), ComputerPageDlgProc(), ConfirmDialog(), ConfirmMessageBox(), EndNowDlgProc(), GetProcessInfo(), CExplorerCommand::GetTitle(), IntAllocConsole(), LabelWndProc(), NetworkDomainPageDlgProc(), OwnerPageDlgProc(), PrepAndLaunchRedirectedChild(), PrintProcess(), PrintProcessInfoDepth(), PrintProcessList(), SetUpConsoleInfo(), ShellUIHelper2_AddFavourite(), ShowItemError(), ShowStepError(), SwitchDisplayMode(), WriteComputerSettings(), and WriteDateTimeSettings().

tripledes

const WCHAR tripledes[] = { '3','d','e','s',0 }

static

Definition at line 1208 of file oid.c.

TRUSTEDPUBLISHER

const WCHAR TRUSTEDPUBLISHER[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0}

static

Definition at line 75 of file oid.c.

X21Address

const WCHAR X21Address[] = { 'X','2','1','A','d','d','r','e','s','s',0 }

static

Definition at line 1271 of file oid.c.