#include "wine/list.h"

Include dependency graph for crypt32_private.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	AsnEncodeSequenceItem

struct	AsnConstructedItem

struct	_CRYPT_DIGESTED_DATA

struct	_CRYPT_ENCRYPTED_CONTENT_INFO

struct	_CRYPT_ENVELOPED_DATA

struct	_CRYPT_SIGNED_INFO

struct	context_vtbl_t

struct	_context_t

struct	cert_t

struct	crl_t

struct	ctl_t

struct	_WINE_CONTEXT_INTERFACE

struct	_CONTEXT_FUNCS

struct	store_vtbl_t

struct	WINE_CRYPTCERTSTORE

Macros
#define	ASN_BOOL (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x01)

#define	ASN_BITSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x03)

#define	ASN_ENUMERATED (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x0a)

#define	ASN_UTF8STRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x0c)

#define	ASN_SETOF (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x11)

#define	ASN_NUMERICSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x12)

#define	ASN_PRINTABLESTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x13)

#define	ASN_T61STRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x14)

#define	ASN_VIDEOTEXSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x15)

#define	ASN_IA5STRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x16)

#define	ASN_UTCTIME (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x17)

#define	ASN_GENERALTIME (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x18)

#define	ASN_GRAPHICSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x19)

#define	ASN_VISIBLESTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x1a)

#define	ASN_GENERALSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x1b)

#define	ASN_UNIVERSALSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x1c)

#define	ASN_BMPSTRING (ASN_UNIVERSAL \| ASN_PRIMITIVE \| 0x1e)

#define	CERT_CERT_PROP_ID 32

#define	CERT_CRL_PROP_ID 33

#define	CERT_CTL_PROP_ID 34

#define	WINE_CRYPTCERTSTORE_MAGIC 0x74726563

#define	ALIGN_DWORD_PTR(x) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))

#define	POINTER_ALIGN_DWORD_PTR(p) ((LPVOID)ALIGN_DWORD_PTR((DWORD_PTR)(p)))

#define	IS_INTOID(x) (((ULONG_PTR)(x) >> 16) == 0)

Typedefs
typedef BOOL(WINAPI *	CryptEncodeObjectExFunc) (DWORD, LPCSTR, const void , DWORD, PCRYPT_ENCODE_PARA, BYTE , DWORD *)

typedef struct _CRYPT_DIGESTED_DATA	CRYPT_DIGESTED_DATA

typedef struct _CRYPT_ENCRYPTED_CONTENT_INFO	CRYPT_ENCRYPTED_CONTENT_INFO

typedef struct _CRYPT_ENVELOPED_DATA	CRYPT_ENVELOPED_DATA

typedef struct _CRYPT_SIGNED_INFO	CRYPT_SIGNED_INFO

typedef struct _CONTEXT_PROPERTY_LIST	CONTEXT_PROPERTY_LIST

typedef struct _context_t	context_t

typedef const void (WINAPI	CreateContextFunc) (DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)

typedef BOOL(WINAPI *	AddContextToStoreFunc) (HCERTSTORE hCertStore, const void context, DWORD dwAddDisposition, const void *ppStoreContext)

typedef BOOL(WINAPI *	AddEncodedContextToStoreFunc) (HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE pbEncoded, DWORD cbEncoded, DWORD dwAddDisposition, const void *ppContext)

typedef const void (WINAPI	EnumContextsInStoreFunc) (HCERTSTORE hCertStore, const void *pPrevContext)

typedef DWORD(WINAPI *	EnumPropertiesFunc) (const void *context, DWORD dwPropId)

typedef BOOL(WINAPI *	GetContextPropertyFunc) (const void context, DWORD dwPropID, void pvData, DWORD *pcbData)

typedef BOOL(WINAPI *	SetContextPropertyFunc) (const void context, DWORD dwPropID, DWORD dwFlags, const void pvData)

typedef BOOL(WINAPI *	SerializeElementFunc) (const void context, DWORD dwFlags, BYTE pbElement, DWORD *pcbElement)

typedef BOOL(WINAPI *	DeleteContextFunc) (const void *contex)

typedef struct _WINE_CONTEXT_INTERFACE	WINE_CONTEXT_INTERFACE

typedef struct WINE_CRYPTCERTSTORE (	StoreOpenFunc) (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)

typedef struct _CONTEXT_FUNCS	CONTEXT_FUNCS

typedef enum _CertStoreType	CertStoreType

typedef struct WINE_CRYPTCERTSTORE	WINECRYPT_CERTSTORE

Enumerations
enum	_CertStoreType { StoreTypeMem , StoreTypeCollection , StoreTypeProvider , StoreTypeEmpty }

Functions
BOOL	CRYPT_EncodeLen (DWORD len, BYTE pbEncoded, DWORD pcbEncoded) DECLSPEC_HIDDEN

BOOL WINAPI	CRYPT_AsnEncodeSequence (DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD pcbEncoded) DECLSPEC_HIDDEN

BOOL WINAPI	CRYPT_AsnEncodeConstructed (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN

BOOL WINAPI	CRYPT_AsnEncodeOid (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN

BOOL WINAPI	CRYPT_AsnEncodeOctets (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnEncodePKCSDigestedData (const CRYPT_DIGESTED_DATA digestedData, void pvData, DWORD *pcbData) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnEncodePKCSEnvelopedData (const CRYPT_ENVELOPED_DATA envelopedData, void pvData, DWORD *pcbData) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnDecodePKCSEnvelopedData (const BYTE pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_ENVELOPED_DATA envelopedData, DWORD *pcbEnvelopedData) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnEncodeCMSSignedInfo (CRYPT_SIGNED_INFO , void pvData, DWORD *pcbData) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnDecodeCMSSignedInfo (const BYTE pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_SIGNED_INFO signedInfo, DWORD *pcbSignedInfo) DECLSPEC_HIDDEN

BOOL	CRYPT_EncodeEnsureSpace (DWORD dwFlags, const CRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) DECLSPEC_HIDDEN

BOOL	CRYPT_AsnDecodePKCSDigestedData (const BYTE pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_DIGESTED_DATA digestedData, DWORD *pcbDigestedData) DECLSPEC_HIDDEN

BOOL WINAPI	CRYPT_AsnEncodePubKeyInfoNoNull (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN

HCRYPTPROV WINAPI	I_CryptGetDefaultCryptProv (ALG_ID)

void	crypt_oid_init (void) DECLSPEC_HIDDEN

void	crypt_oid_free (void) DECLSPEC_HIDDEN

void	crypt_sip_free (void) DECLSPEC_HIDDEN

void	root_store_free (void) DECLSPEC_HIDDEN

void	default_chain_engine_free (void) DECLSPEC_HIDDEN

static context_t *	context_from_ptr (const void *ptr)

static void *	context_ptr (context_t *context)

static cert_t *	cert_from_ptr (const CERT_CONTEXT *ptr)

static crl_t *	crl_from_ptr (const CRL_CONTEXT *ptr)

static ctl_t *	ctl_from_ptr (const CTL_CONTEXT *ptr)

void	CRYPT_InitStore (WINECRYPT_CERTSTORE store, DWORD dwFlags, CertStoreType type, const store_vtbl_t ) DECLSPEC_HIDDEN

void	CRYPT_FreeStore (WINECRYPT_CERTSTORE *store) DECLSPEC_HIDDEN

BOOL WINAPI	I_CertUpdateStore (HCERTSTORE store1, HCERTSTORE store2, DWORD unk0, DWORD unk1) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_CollectionOpenStore (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_ProvCreateStore (DWORD dwFlags, WINECRYPT_CERTSTORE memStore, const CERT_STORE_PROV_INFO pProvInfo) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_ProvOpenStore (LPCSTR lpszStoreProvider, DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_RegOpenStore (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_FileOpenStore (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_FileNameOpenStoreA (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE *	CRYPT_FileNameOpenStoreW (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN

void	CRYPT_ImportSystemRootCertsToReg (void) DECLSPEC_HIDDEN

BOOL	CRYPT_SerializeContextsToReg (HKEY key, DWORD flags, const WINE_CONTEXT_INTERFACE *contextInterface, HCERTSTORE memStore) DECLSPEC_HIDDEN

DWORD	CRYPT_IsCertificateSelfSigned (const CERT_CONTEXT *cert) DECLSPEC_HIDDEN

HCERTCHAINENGINE	CRYPT_CreateChainEngine (HCERTSTORE, DWORD, const CERT_CHAIN_ENGINE_CONFIG *) DECLSPEC_HIDDEN

const void *	CRYPT_ReadSerializedElement (const BYTE pbElement, DWORD cbElement, DWORD dwContextTypeFlags, DWORD pdwContentType) DECLSPEC_HIDDEN

BOOL	CRYPT_ReadSerializedStoreFromFile (HANDLE file, HCERTSTORE store) DECLSPEC_HIDDEN

BOOL	CRYPT_ReadSerializedStoreFromBlob (const CRYPT_DATA_BLOB *blob, HCERTSTORE store) DECLSPEC_HIDDEN

void	CRYPT_FixKeyProvInfoPointers (PCRYPT_KEY_PROV_INFO info) DECLSPEC_HIDDEN

DWORD	cert_name_to_str_with_indent (DWORD dwCertEncodingType, DWORD indent, const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz) DECLSPEC_HIDDEN

context_t *	Context_CreateDataContext (size_t contextSize, const context_vtbl_t vtbl, struct WINE_CRYPTCERTSTORE ) DECLSPEC_HIDDEN

context_t *	Context_CreateLinkContext (unsigned contextSize, context_t linked, struct WINE_CRYPTCERTSTORE ) DECLSPEC_HIDDEN

void	Context_CopyProperties (const void to, const void from) DECLSPEC_HIDDEN

void	Context_AddRef (context_t *) DECLSPEC_HIDDEN

void	Context_Release (context_t *context) DECLSPEC_HIDDEN

void	Context_Free (context_t *) DECLSPEC_HIDDEN

CONTEXT_PROPERTY_LIST *	ContextPropertyList_Create (void) DECLSPEC_HIDDEN

BOOL	ContextPropertyList_FindProperty (CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN

BOOL	ContextPropertyList_SetProperty (CONTEXT_PROPERTY_LIST list, DWORD id, const BYTE pbData, size_t cbData) DECLSPEC_HIDDEN

void	ContextPropertyList_RemoveProperty (CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN

DWORD	ContextPropertyList_EnumPropIDs (CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN

void	ContextPropertyList_Copy (CONTEXT_PROPERTY_LIST to, CONTEXT_PROPERTY_LIST from) DECLSPEC_HIDDEN

void	ContextPropertyList_Free (CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN

void	init_empty_store (void) DECLSPEC_HIDDEN

Variables
HINSTANCE hInstance	DECLSPEC_HIDDEN

Macro Definition Documentation

◆ ALIGN_DWORD_PTR

#define ALIGN_DWORD_PTR ( x ) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))

Utilities.

Definition at line 447 of file crypt32_private.h.

◆ ASN_BITSTRING

#define ASN_BITSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)

Definition at line 26 of file crypt32_private.h.

◆ ASN_BMPSTRING

#define ASN_BMPSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)

Definition at line 41 of file crypt32_private.h.

◆ ASN_BOOL

#define ASN_BOOL (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)

Definition at line 25 of file crypt32_private.h.

◆ ASN_ENUMERATED

#define ASN_ENUMERATED (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0a)

Definition at line 27 of file crypt32_private.h.

◆ ASN_GENERALSTRING

#define ASN_GENERALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1b)

Definition at line 39 of file crypt32_private.h.

◆ ASN_GENERALTIME

#define ASN_GENERALTIME (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x18)

Definition at line 36 of file crypt32_private.h.

◆ ASN_GRAPHICSTRING

#define ASN_GRAPHICSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x19)

Definition at line 37 of file crypt32_private.h.

◆ ASN_IA5STRING

#define ASN_IA5STRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x16)

Definition at line 34 of file crypt32_private.h.

◆ ASN_NUMERICSTRING

#define ASN_NUMERICSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x12)

Definition at line 30 of file crypt32_private.h.

◆ ASN_PRINTABLESTRING

#define ASN_PRINTABLESTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x13)

Definition at line 31 of file crypt32_private.h.

◆ ASN_SETOF

#define ASN_SETOF (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x11)

Definition at line 29 of file crypt32_private.h.

◆ ASN_T61STRING

#define ASN_T61STRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x14)

Definition at line 32 of file crypt32_private.h.

◆ ASN_UNIVERSALSTRING

#define ASN_UNIVERSALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1c)

Definition at line 40 of file crypt32_private.h.

◆ ASN_UTCTIME

#define ASN_UTCTIME (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x17)

Definition at line 35 of file crypt32_private.h.

◆ ASN_UTF8STRING

#define ASN_UTF8STRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0c)

Definition at line 28 of file crypt32_private.h.

◆ ASN_VIDEOTEXSTRING

#define ASN_VIDEOTEXSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x15)

Definition at line 33 of file crypt32_private.h.

◆ ASN_VISIBLESTRING

#define ASN_VISIBLESTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1a)

Definition at line 38 of file crypt32_private.h.

◆ CERT_CERT_PROP_ID

#define CERT_CERT_PROP_ID 32

Definition at line 146 of file crypt32_private.h.

◆ CERT_CRL_PROP_ID

#define CERT_CRL_PROP_ID 33

Definition at line 147 of file crypt32_private.h.

◆ CERT_CTL_PROP_ID

#define CERT_CTL_PROP_ID 34

Definition at line 148 of file crypt32_private.h.

◆ IS_INTOID

#define IS_INTOID ( x ) (((ULONG_PTR)(x) >> 16) == 0)

Definition at line 452 of file crypt32_private.h.

◆ POINTER_ALIGN_DWORD_PTR

#define POINTER_ALIGN_DWORD_PTR ( p ) ((LPVOID)ALIGN_DWORD_PTR((DWORD_PTR)(p)))

Definition at line 448 of file crypt32_private.h.

◆ WINE_CRYPTCERTSTORE_MAGIC

#define WINE_CRYPTCERTSTORE_MAGIC 0x74726563

Definition at line 289 of file crypt32_private.h.

Typedef Documentation

◆ AddContextToStoreFunc

typedef BOOL(WINAPI * AddContextToStoreFunc) (HCERTSTORE hCertStore, const void *context, DWORD dwAddDisposition, const void **ppStoreContext)

Definition at line 232 of file crypt32_private.h.

◆ AddEncodedContextToStoreFunc

typedef BOOL(WINAPI * AddEncodedContextToStoreFunc) (HCERTSTORE hCertStore, DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwAddDisposition, const void **ppContext)

Definition at line 234 of file crypt32_private.h.

◆ CertStoreType

typedef enum _CertStoreType CertStoreType

◆ CONTEXT_FUNCS

typedef struct _CONTEXT_FUNCS CONTEXT_FUNCS

◆ CONTEXT_PROPERTY_LIST

typedef struct _CONTEXT_PROPERTY_LIST CONTEXT_PROPERTY_LIST

Definition at line 166 of file crypt32_private.h.

◆ context_t

typedef struct _context_t context_t

Definition at line 168 of file crypt32_private.h.

◆ CreateContextFunc

typedef const void *(WINAPI * CreateContextFunc) (DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)

Definition at line 230 of file crypt32_private.h.

◆ CRYPT_DIGESTED_DATA

typedef struct _CRYPT_DIGESTED_DATA CRYPT_DIGESTED_DATA

◆ CRYPT_ENCRYPTED_CONTENT_INFO

typedef struct _CRYPT_ENCRYPTED_CONTENT_INFO CRYPT_ENCRYPTED_CONTENT_INFO

◆ CRYPT_ENVELOPED_DATA

typedef struct _CRYPT_ENVELOPED_DATA CRYPT_ENVELOPED_DATA

◆ CRYPT_SIGNED_INFO

typedef struct _CRYPT_SIGNED_INFO CRYPT_SIGNED_INFO

◆ CryptEncodeObjectExFunc

typedef BOOL(WINAPI * CryptEncodeObjectExFunc) (DWORD, LPCSTR, const void *, DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *)

Definition at line 45 of file crypt32_private.h.

◆ DeleteContextFunc

typedef BOOL(WINAPI * DeleteContextFunc) (const void *contex)

Definition at line 246 of file crypt32_private.h.

◆ EnumContextsInStoreFunc

typedef const void *(WINAPI * EnumContextsInStoreFunc) (HCERTSTORE hCertStore, const void *pPrevContext)

Definition at line 237 of file crypt32_private.h.

◆ EnumPropertiesFunc

typedef DWORD(WINAPI * EnumPropertiesFunc) (const void *context, DWORD dwPropId)

Definition at line 239 of file crypt32_private.h.

◆ GetContextPropertyFunc

typedef BOOL(WINAPI * GetContextPropertyFunc) (const void *context, DWORD dwPropID, void *pvData, DWORD *pcbData)

Definition at line 240 of file crypt32_private.h.

◆ SerializeElementFunc

typedef BOOL(WINAPI * SerializeElementFunc) (const void *context, DWORD dwFlags, BYTE *pbElement, DWORD *pcbElement)

Definition at line 244 of file crypt32_private.h.

◆ SetContextPropertyFunc

typedef BOOL(WINAPI * SetContextPropertyFunc) (const void *context, DWORD dwPropID, DWORD dwFlags, const void *pvData)

Definition at line 242 of file crypt32_private.h.

◆ StoreOpenFunc

typedef struct WINE_CRYPTCERTSTORE *(* StoreOpenFunc) (HCRYPTPROV hCryptProv, DWORD dwFlags, const void *pvPara)

Definition at line 264 of file crypt32_private.h.

◆ WINE_CONTEXT_INTERFACE

typedef struct _WINE_CONTEXT_INTERFACE WINE_CONTEXT_INTERFACE

◆ WINECRYPT_CERTSTORE

typedef struct WINE_CRYPTCERTSTORE WINECRYPT_CERTSTORE

Enumeration Type Documentation

◆ _CertStoreType

enum _CertStoreType

Enumerator
StoreTypeMem
StoreTypeCollection
StoreTypeProvider
StoreTypeEmpty

Definition at line 282 of file crypt32_private.h.

                            {
    StoreTypeMem,
    StoreTypeCollection,
    StoreTypeProvider,
    StoreTypeEmpty
} CertStoreType;

Function Documentation

◆ cert_from_ptr()

static cert_t * cert_from_ptr ( const CERT_CONTEXT * ptr )

inlinestatic

Definition at line 202 of file crypt32_private.h.

{
    return CONTAINING_RECORD(ptr, cert_t, ctx);
}

Referenced by CertDeleteCertificateFromStore(), CertDuplicateCertificateContext(), CertEnumCertificateContextProperties(), CertEnumCertificatesInStore(), CertFreeCertificateContext(), CertGetCertificateContextProperty(), and CertSetCertificateContextProperty().

◆ cert_name_to_str_with_indent()

DWORD cert_name_to_str_with_indent	(	DWORD	dwCertEncodingType,
		DWORD	indent,
		const CERT_NAME_BLOB *	pName,
		DWORD	dwStrType,
		LPWSTR	psz,
		DWORD	csz
	)

String functions

Definition at line 576 of file str.c.

{
    static const DWORD unsupportedFlags = CERT_NAME_STR_NO_QUOTING_FLAG |
     CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG;
    static const WCHAR commaSep[] = { ',',' ',0 };
    static const WCHAR semiSep[] = { ';',' ',0 };
    static const WCHAR crlfSep[] = { '\r','\n',0 };
    static const WCHAR plusSep[] = { ' ','+',' ',0 };
    static const WCHAR spaceSep[] = { ' ',0 };
    DWORD ret = 0, bytes = 0;
    BOOL bRet;
    CERT_NAME_INFO *info;
 
    if (dwStrType & unsupportedFlags)
        FIXME("unsupported flags: %08x\n", dwStrType & unsupportedFlags);
 
    bRet = CryptDecodeObjectEx(dwCertEncodingType, X509_NAME, pName->pbData,
     pName->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &bytes);
    if (bRet)
    {
        DWORD i, j, sepLen, rdnSepLen;
        LPCWSTR sep, rdnSep;
        BOOL reverse = dwStrType & CERT_NAME_STR_REVERSE_FLAG;
        const CERT_RDN *rdn = info->rgRDN;
 
        if(reverse && info->cRDN > 1) rdn += (info->cRDN - 1);
 
        if (dwStrType & CERT_NAME_STR_SEMICOLON_FLAG)
            sep = semiSep;
        else if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
            sep = crlfSep;
        else
            sep = commaSep;
        sepLen = lstrlenW(sep);
        if (dwStrType & CERT_NAME_STR_NO_PLUS_FLAG)
            rdnSep = spaceSep;
        else
            rdnSep = plusSep;
        rdnSepLen = lstrlenW(rdnSep);
        for (i = 0; (!psz || ret < csz) && i < info->cRDN; i++)
        {
            for (j = 0; (!psz || ret < csz) && j < rdn->cRDNAttr; j++)
            {
                DWORD chars;
                LPCSTR prefixA = NULL;
                LPCWSTR prefixW = NULL;
 
                if ((dwStrType & 0x000000ff) == CERT_OID_NAME_STR)
                    prefixA = rdn->rgRDNAttr[j].pszObjId;
                else if ((dwStrType & 0x000000ff) == CERT_X500_NAME_STR)
                {
                    PCCRYPT_OID_INFO oidInfo = CryptFindOIDInfo(
                     CRYPT_OID_INFO_OID_KEY,
                     rdn->rgRDNAttr[j].pszObjId,
                     CRYPT_RDN_ATTR_OID_GROUP_ID);
 
                    if (oidInfo)
                        prefixW = oidInfo->pwszName;
                    else
                        prefixA = rdn->rgRDNAttr[j].pszObjId;
                }
                if (dwStrType & CERT_NAME_STR_CRLF_FLAG)
                {
                    DWORD k;
 
                    for (k = 0; k < indentLevel; k++)
                    {
                        if (psz)
                        {
                            chars = min(strlenW(indent), csz - ret - 1);
                            memcpy(psz + ret, indent, chars * sizeof(WCHAR));
                        }
                        else
                            chars = strlenW(indent);
                        ret += chars;
                    }
                }
                if (prefixW)
                {
                    /* - 1 is needed to account for the NULL terminator. */
                    chars = CRYPT_AddPrefixW(prefixW,
                     psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
                    ret += chars;
                }
                else if (prefixA)
                {
                    /* - 1 is needed to account for the NULL terminator. */
                    chars = CRYPT_AddPrefixAToW(prefixA,
                     psz ? psz + ret : NULL, psz ? csz - ret - 1 : 0);
                    ret += chars;
                }
                chars = quote_rdn_value_to_str_w(
                 rdn->rgRDNAttr[j].dwValueType,
                 &rdn->rgRDNAttr[j].Value, psz ? psz + ret : NULL,
                 psz ? csz - ret : 0);
                if (chars)
                    ret += chars - 1;
                if (j < rdn->cRDNAttr - 1)
                {
                    if (psz && ret < csz - rdnSepLen - 1)
                        memcpy(psz + ret, rdnSep, rdnSepLen * sizeof(WCHAR));
                    ret += rdnSepLen;
                }
            }
            if (i < info->cRDN - 1)
            {
                if (psz && ret < csz - sepLen - 1)
                    memcpy(psz + ret, sep, sepLen * sizeof(WCHAR));
                ret += sepLen;
            }
            if(reverse) rdn--;
            else rdn++;
        }
        LocalFree(info);
    }
    if (psz && csz)
    {
        *(psz + ret) = '\0';
        ret++;
    }
    else
        ret++;
    return ret;
}

Referenced by CertGetNameStringW(), CertNameToStrW(), CRYPT_FormatAltNameEntry(), and name_value_to_str().

◆ Context_AddRef()

void Context_AddRef ( context_t * context )

Definition at line 78 of file context.c.

{
    LONG ref = InterlockedIncrement(&context->ref);
 
    TRACE("(%p) ref=%d\n", context, context->ref);
 
    if(ref == 1) {
        /* This is the first external (non-store) reference. Increase store ref cnt. */
        context->store->vtbl->addref(context->store);
    }
}

Referenced by CertDuplicateCertificateContext(), CertDuplicateCRLContext(), CertDuplicateCTLContext(), Context_CreateLinkContext(), CRYPT_CollectionAdvanceEnum(), CRYPT_QuerySerializedContextObject(), EmptyStore_add(), and MemStore_enumContext().

◆ Context_CopyProperties()

void Context_CopyProperties	(	const void *	to,
		const void *	from
	)

Definition at line 123 of file context.c.

{
    CONTEXT_PROPERTY_LIST *toProperties, *fromProperties;
 
    toProperties = context_from_ptr(to)->properties;
    fromProperties = context_from_ptr(from)->properties;
    assert(toProperties && fromProperties);
    ContextPropertyList_Copy(toProperties, fromProperties);
}

Referenced by add_cert_to_store(), Cert_clone(), CertAddCRLContextToStore(), CertAddCTLContextToStore(), and CRL_clone().

◆ Context_CreateDataContext()

context_t * Context_CreateDataContext	(	size_t	contextSize,
		const context_vtbl_t *	vtbl,
		struct WINE_CRYPTCERTSTORE *	store
	)

Context functions

Definition at line 28 of file context.c.

{
    context_t *context;
 
    context = CryptMemAlloc(sizeof(context_t) + contextSize);
    if (!context)
        return NULL;
 
    context->properties = ContextPropertyList_Create();
    if (!context->properties)
    {
        CryptMemFree(context);
        return NULL;
    }
 
    context->vtbl = vtbl;
    context->ref = 1;
    context->linked = NULL;
 
    store->vtbl->addref(store);
    context->store = store;
 
    TRACE("returning %p\n", context);
    return context;
}

Referenced by Cert_clone(), CertCreateCertificateContext(), CertCreateCRLContext(), CertCreateCTLContext(), and CRL_clone().

◆ Context_CreateLinkContext()

context_t * Context_CreateLinkContext	(	unsigned	contextSize,
		context_t *	linked,
		struct WINE_CRYPTCERTSTORE *
	)

◆ Context_Free()

void Context_Free ( context_t * context )

Definition at line 90 of file context.c.

{
    TRACE("(%p)\n", context);
 
    assert(!context->ref);
 
    if (!context->linked) {
        ContextPropertyList_Free(context->properties);
        context->vtbl->free(context);
    }else {
        Context_Release(context->linked);
    }
 
    CryptMemFree(context);
}

Referenced by Collection_releaseContext(), EmptyStore_releaseContext(), free_contexts(), MemStore_deleteContext(), and MemStore_releaseContext().

◆ context_from_ptr()

static context_t * context_from_ptr ( const void * ptr )

inlinestatic

Definition at line 187 of file crypt32_private.h.

{
    return (context_t*)ptr-1;
}

Referenced by add_cert_to_store(), CertAddCRLContextToStore(), CertAddCTLContextToStore(), CertAddSerializedElementToStore(), Context_CopyProperties(), CRYPT_QuerySerializedContextObject(), CRYPT_ReadSerializedElement(), CRYPT_ReadSerializedStore(), CRYPT_RegReadSerializedFromReg(), CRYPT_SerializeContextsToReg(), and CRYPT_SerializeContextsToStream().

◆ context_ptr()

static void * context_ptr ( context_t * context )

inlinestatic

Definition at line 192 of file crypt32_private.h.

{
    return context+1;
}

Referenced by add_cert_to_store(), CertAddCRLContextToStore(), CertAddCTLContextToStore(), Context_CreateLinkContext(), ProvStore_addCert(), ProvStore_addCRL(), ProvStore_addCTL(), ProvStore_deleteCert(), ProvStore_deleteCRL(), and ProvStore_deleteCTL().

◆ Context_Release()

void Context_Release ( context_t * context )

Definition at line 106 of file context.c.

{
    LONG ref = InterlockedDecrement(&context->ref);
 
    TRACE("(%p) ref=%d\n", context, ref);
    assert(ref >= 0);
 
    if (!ref) {
        WINECRYPT_CERTSTORE *store = context->store;
 
        /* This is the last reference, but the context still may be in a store.
         * We release our store reference, but leave it up to store to free or keep the context. */
        store->vtbl->releaseContext(store, context);
        store->vtbl->release(store, 0);
    }
}

Referenced by add_cert_to_store(), CertAddSerializedElementToStore(), CertCreateCertificateContext(), CertCreateCRLContext(), CertCreateCTLContext(), CertFreeCertificateContext(), CertFreeCRLContext(), CertFreeCTLContext(), Collection_addCert(), Collection_addCRL(), Collection_addCTL(), Context_Free(), CRYPT_CollectionAdvanceEnum(), CRYPT_QuerySerializedContextObject(), CRYPT_ReadSerializedElement(), CRYPT_ReadSerializedStore(), CRYPT_RegReadSerializedFromReg(), CRYPT_SerializeContextsToReg(), CRYPT_SerializeContextsToStream(), MemStore_addContext(), and MemStore_enumContext().

◆ ContextPropertyList_Copy()

void ContextPropertyList_Copy	(	CONTEXT_PROPERTY_LIST *	to,
		CONTEXT_PROPERTY_LIST *	from
	)

Definition at line 207 of file proplist.c.

{
    CONTEXT_PROPERTY *prop;
 
    EnterCriticalSection(&from->cs);
    LIST_FOR_EACH_ENTRY(prop, &from->properties, CONTEXT_PROPERTY, entry)
    {
        ContextPropertyList_SetProperty(to, prop->propID, prop->pbData,
         prop->cbData);
    }
    LeaveCriticalSection(&from->cs);
}

Referenced by Context_CopyProperties().

◆ ContextPropertyList_Create()

CONTEXT_PROPERTY_LIST * ContextPropertyList_Create ( void )

Context property list functions

Definition at line 43 of file proplist.c.

{
    CONTEXT_PROPERTY_LIST *list = CryptMemAlloc(sizeof(CONTEXT_PROPERTY_LIST));
 
    if (list)
    {
        InitializeCriticalSection(&list->cs);
        list->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PCONTEXT_PROPERTY_LIST->cs");
        list_init(&list->properties);
    }
    return list;
}

Referenced by CertSetStoreProperty(), Context_CreateDataContext(), and CryptMsgOpenToDecode().

◆ ContextPropertyList_EnumPropIDs()

DWORD ContextPropertyList_EnumPropIDs	(	CONTEXT_PROPERTY_LIST *	list,
		DWORD	id
	)

Definition at line 170 of file proplist.c.

{
    DWORD ret;
 
    EnterCriticalSection(&list->cs);
    if (id)
    {
        CONTEXT_PROPERTY *cursor = NULL, *prop;
 
        LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
        {
            if (prop->propID == id)
            {
                cursor = prop;
                break;
            }
        }
        if (cursor)
        {
            if (cursor->entry.next != &list->properties)
                ret = LIST_ENTRY(cursor->entry.next, CONTEXT_PROPERTY,
                 entry)->propID;
            else
                ret = 0;
        }
        else
            ret = 0;
    }
    else if (!list_empty(&list->properties))
        ret = LIST_ENTRY(list->properties.next, CONTEXT_PROPERTY,
         entry)->propID;
    else
        ret = 0;
    LeaveCriticalSection(&list->cs);
    return ret;
}

Referenced by CertEnumCertificateContextProperties(), CertEnumCRLContextProperties(), and CertEnumCTLContextProperties().

◆ ContextPropertyList_FindProperty()

BOOL ContextPropertyList_FindProperty	(	CONTEXT_PROPERTY_LIST *	list,
		DWORD	id,
		PCRYPT_DATA_BLOB	blob
	)

Definition at line 72 of file proplist.c.

{
    CONTEXT_PROPERTY *prop;
    BOOL ret = FALSE;
 
    TRACE("(%p, %d, %p)\n", list, id, blob);
 
    EnterCriticalSection(&list->cs);
    LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
    {
        if (prop->propID == id)
        {
            blob->cbData = prop->cbData;
            blob->pbData = prop->pbData;
            ret = TRUE;
            break;
        }
    }
    LeaveCriticalSection(&list->cs);
    return ret;
}

Referenced by CDecodeHashMsg_GetParam(), CDecodeHashMsg_VerifyHash(), CDecodeMsg_FinalizeHashedContent(), CDecodeMsg_GetParam(), CertContext_GetProperty(), CertGetStoreProperty(), CRLContext_GetProperty(), and CTLContext_GetProperty().

◆ ContextPropertyList_Free()

void ContextPropertyList_Free ( CONTEXT_PROPERTY_LIST * list )

Definition at line 56 of file proplist.c.

{
    CONTEXT_PROPERTY *prop, *next;
 
    LIST_FOR_EACH_ENTRY_SAFE(prop, next, &list->properties, CONTEXT_PROPERTY,
     entry)
    {
        list_remove(&prop->entry);
        CryptMemFree(prop->pbData);
        CryptMemFree(prop);
    }
    list->cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&list->cs);
    CryptMemFree(list);
}

Referenced by CDecodeMsg_Close(), Context_Free(), and CRYPT_FreeStore().

◆ ContextPropertyList_RemoveProperty()

void ContextPropertyList_RemoveProperty	(	CONTEXT_PROPERTY_LIST *	list,
		DWORD	id
	)

Definition at line 149 of file proplist.c.

{
    CONTEXT_PROPERTY *prop;
 
    EnterCriticalSection(&list->cs);
    LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
    {
        if (prop->propID == id)
        {
            list_remove(&prop->entry);
            CryptMemFree(prop->pbData);
            CryptMemFree(prop);
            break;
        }
    }
    LeaveCriticalSection(&list->cs);
}

Referenced by CertContext_SetProperty(), CertSetStoreProperty(), CRLContext_SetProperty(), and CTLContext_SetProperty().

◆ ContextPropertyList_SetProperty()

BOOL ContextPropertyList_SetProperty	(	CONTEXT_PROPERTY_LIST *	list,
		DWORD	id,
		const BYTE *	pbData,
		size_t	cbData
	)

Definition at line 95 of file proplist.c.

{
    LPBYTE data;
    BOOL ret = FALSE;
 
    if (cbData)
    {
        data = CryptMemAlloc(cbData);
        if (data)
            memcpy(data, pbData, cbData);
    }
    else
        data = NULL;
    if (!cbData || data)
    {
        CONTEXT_PROPERTY *prop;
        BOOL found = FALSE;
 
        EnterCriticalSection(&list->cs);
        LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
        {
            if (prop->propID == id)
            {
                found = TRUE;
                break;
            }
        }
        if (found)
        {
            CryptMemFree(prop->pbData);
            prop->cbData = cbData;
            prop->pbData = data;
            ret = TRUE;
        }
        else
        {
            prop = CryptMemAlloc(sizeof(CONTEXT_PROPERTY));
            if (prop)
            {
                prop->propID = id;
                prop->cbData = cbData;
                prop->pbData = data;
                list_add_tail(&list->properties, &prop->entry);
                ret = TRUE;
            }
            else
                CryptMemFree(data);
        }
        LeaveCriticalSection(&list->cs);
    }
    return ret;
}

Referenced by CDecodeMsg_DecodeDataContent(), CDecodeMsg_DecodeHashedContent(), CDecodeMsg_SaveAlgorithmID(), CertContext_SetKeyProvInfoProperty(), CertContext_SetProperty(), CertSetStoreProperty(), ContextPropertyList_Copy(), CRLContext_SetProperty(), and CTLContext_SetProperty().

◆ crl_from_ptr()

static crl_t * crl_from_ptr ( const CRL_CONTEXT * ptr )

inlinestatic

Definition at line 212 of file crypt32_private.h.

{
    return CONTAINING_RECORD(ptr, crl_t, ctx);
}

Referenced by CertDeleteCRLFromStore(), CertDuplicateCRLContext(), CertEnumCRLContextProperties(), CertEnumCRLsInStore(), CertFreeCRLContext(), CertGetCRLContextProperty(), and CertSetCRLContextProperty().

◆ CRYPT_AsnDecodeCMSSignedInfo()

BOOL CRYPT_AsnDecodeCMSSignedInfo	(	const BYTE *	pbEncoded,
		DWORD	cbEncoded,
		DWORD	dwFlags,
		PCRYPT_DECODE_PARA	pDecodePara,
		CRYPT_SIGNED_INFO *	signedInfo,
		DWORD *	pcbSignedInfo
	)

Definition at line 5822 of file decode.c.

{
    BOOL ret = FALSE;
    struct AsnDecodeSequenceItem items[] = {
     { ASN_INTEGER, offsetof(CRYPT_SIGNED_INFO, version),
       CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
     /* Placeholder for the hash algorithms - redundant with those in the
      * signers, so just ignore them.
      */
     { ASN_CONSTRUCTOR | ASN_SETOF, 0, NULL, 0, TRUE, FALSE, 0, 0 },
     { ASN_SEQUENCE, offsetof(CRYPT_SIGNED_INFO, content),
       CRYPT_AsnDecodePKCSContentInfoInternal, sizeof(CRYPT_CONTENT_INFO),
       FALSE, TRUE, offsetof(CRYPT_SIGNED_INFO, content.pszObjId), 0 },
     { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
       offsetof(CRYPT_SIGNED_INFO, cCertEncoded), CRYPT_AsnDecodeCMSCertEncoded,
       MEMBERSIZE(CRYPT_SIGNED_INFO, cCertEncoded, cCrlEncoded), TRUE, TRUE,
       offsetof(CRYPT_SIGNED_INFO, rgCertEncoded), 0 },
     { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
       offsetof(CRYPT_SIGNED_INFO, cCrlEncoded), CRYPT_AsnDecodeCMSCrlEncoded,
       MEMBERSIZE(CRYPT_SIGNED_INFO, cCrlEncoded, content), TRUE, TRUE,
       offsetof(CRYPT_SIGNED_INFO, rgCrlEncoded), 0 },
     { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_SIGNED_INFO, cSignerInfo),
       CRYPT_DecodeSignerArray,
       FINALMEMBERSIZE(CRYPT_SIGNED_INFO, cSignerInfo), TRUE, TRUE,
       offsetof(CRYPT_SIGNED_INFO, rgSignerInfo), 0 },
    };
 
    TRACE("%p, %d, %08x, %p, %p, %p\n", pbEncoded, cbEncoded, dwFlags,
     pDecodePara, signedInfo, pcbSignedInfo);
 
    ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
     pbEncoded, cbEncoded, dwFlags, pDecodePara, signedInfo, pcbSignedInfo,
     NULL, NULL);
    TRACE("returning %d\n", ret);
    return ret;
}

Referenced by CDecodeMsg_DecodeSignedContent().

◆ CRYPT_AsnDecodePKCSDigestedData()

BOOL CRYPT_AsnDecodePKCSDigestedData	(	const BYTE *	pbEncoded,
		DWORD	cbEncoded,
		DWORD	dwFlags,
		PCRYPT_DECODE_PARA	pDecodePara,
		CRYPT_DIGESTED_DATA *	digestedData,
		DWORD *	pcbDigestedData
	)

Definition at line 3371 of file decode.c.

{
    BOOL ret;
    struct AsnDecodeSequenceItem items[] = {
     { ASN_INTEGER, offsetof(CRYPT_DIGESTED_DATA, version),
       CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
     { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm),
       CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
       FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm.pszObjId),
       0 },
     { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, ContentInfo),
       CRYPT_AsnDecodePKCSContentInfoInternal,
       sizeof(CRYPT_CONTENT_INFO), FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA,
       ContentInfo.pszObjId), 0 },
     { ASN_OCTETSTRING, offsetof(CRYPT_DIGESTED_DATA, hash),
       CRYPT_AsnDecodeOctets, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
       offsetof(CRYPT_DIGESTED_DATA, hash.pbData), 0 },
    };
 
    ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
     pbEncoded, cbEncoded, dwFlags, pDecodePara, digestedData, pcbDigestedData,
     NULL, NULL);
    return ret;
}

Referenced by CDecodeMsg_DecodeHashedContent().

◆ CRYPT_AsnDecodePKCSEnvelopedData()

BOOL CRYPT_AsnDecodePKCSEnvelopedData	(	const BYTE *	pbEncoded,
		DWORD	cbEncoded,
		DWORD	dwFlags,
		PCRYPT_DECODE_PARA	pDecodePara,
		CRYPT_ENVELOPED_DATA *	envelopedData,
		DWORD *	pcbEnvelopedData
	)

Definition at line 5951 of file decode.c.

{
    BOOL ret;
    struct AsnDecodeSequenceItem items[] = {
     { ASN_INTEGER, offsetof(CRYPT_ENVELOPED_DATA, version),
       CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
     { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_ENVELOPED_DATA,
       cRecipientInfo), CRYPT_DecodeRecipientInfoArray,
       MEMBERSIZE(CRYPT_ENVELOPED_DATA, cRecipientInfo, encryptedContentInfo),
       FALSE, TRUE, offsetof(CRYPT_ENVELOPED_DATA, rgRecipientInfo), 0 },
     { ASN_SEQUENCEOF, offsetof(CRYPT_ENVELOPED_DATA, encryptedContentInfo),
       CRYPT_AsnDecodeEncryptedContentInfo,
       sizeof(CRYPT_ENCRYPTED_CONTENT_INFO), FALSE, TRUE,
       offsetof(CRYPT_ENVELOPED_DATA, encryptedContentInfo.contentType), 0 },
    };
 
    TRACE("%p, %d, %08x, %p, %p, %p\n", pbEncoded, cbEncoded, dwFlags,
     pDecodePara, envelopedData, pcbEnvelopedData);
 
    ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
     pbEncoded, cbEncoded, dwFlags, pDecodePara, envelopedData,
     pcbEnvelopedData, NULL, NULL);
    TRACE("returning %d\n", ret);
    return ret;
}

Referenced by CDecodeMsg_DecodeEnvelopedContent().

◆ CRYPT_AsnEncodeCMSSignedInfo()

BOOL CRYPT_AsnEncodeCMSSignedInfo	(	CRYPT_SIGNED_INFO *	signedInfo,
		void *	pvData,
		DWORD *	pcbData
	)

Definition at line 4307 of file encode.c.

{
    struct AsnEncodeSequenceItem items[7] = {
     { &signedInfo->version, CRYPT_AsnEncodeInt, 0 },
    };
    struct DERSetDescriptor digestAlgorithmsSet = { 0 }, certSet = { 0 };
    struct DERSetDescriptor crlSet = { 0 }, signerSet = { 0 };
    struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
    DWORD cItem = 1, cSwapped = 0;
    BOOL ret = TRUE;
 
    if (signedInfo->cSignerInfo)
    {
        digestAlgorithmsSet.cItems = signedInfo->cSignerInfo;
        digestAlgorithmsSet.items = signedInfo->rgSignerInfo;
        digestAlgorithmsSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO);
        digestAlgorithmsSet.itemOffset =
         offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm);
        digestAlgorithmsSet.encode = CRYPT_AsnEncodeAlgorithmIdWithNullParams;
        items[cItem].pvStructInfo = &digestAlgorithmsSet;
        items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
        cItem++;
    }
    items[cItem].pvStructInfo = &signedInfo->content;
    items[cItem].encodeFunc = CRYPT_AsnEncodePKCSContentInfoInternal;
    cItem++;
    if (signedInfo->cCertEncoded)
    {
        certSet.cItems = signedInfo->cCertEncoded;
        certSet.items = signedInfo->rgCertEncoded;
        certSet.itemSize = sizeof(CERT_BLOB);
        certSet.itemOffset = 0;
        certSet.encode = CRYPT_CopyEncodedBlob;
        swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 0;
        swapped[cSwapped].pvStructInfo = &certSet;
        swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
        items[cItem].pvStructInfo = &swapped[cSwapped];
        items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
        cSwapped++;
        cItem++;
    }
    if (signedInfo->cCrlEncoded)
    {
        crlSet.cItems = signedInfo->cCrlEncoded;
        crlSet.items = signedInfo->rgCrlEncoded;
        crlSet.itemSize = sizeof(CRL_BLOB);
        crlSet.itemOffset = 0;
        crlSet.encode = CRYPT_CopyEncodedBlob;
        swapped[cSwapped].tag = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
        swapped[cSwapped].pvStructInfo = &crlSet;
        swapped[cSwapped].encodeFunc = CRYPT_DEREncodeItemsAsSet;
        items[cItem].pvStructInfo = &swapped[cSwapped];
        items[cItem].encodeFunc = CRYPT_AsnEncodeSwapTag;
        cSwapped++;
        cItem++;
    }
    if (ret && signedInfo->cSignerInfo)
    {
        signerSet.cItems = signedInfo->cSignerInfo;
        signerSet.items = signedInfo->rgSignerInfo;
        signerSet.itemSize = sizeof(CMSG_CMS_SIGNER_INFO);
        signerSet.itemOffset = 0;
        signerSet.encode = CRYPT_AsnEncodeCMSSignerInfo;
        items[cItem].pvStructInfo = &signerSet;
        items[cItem].encodeFunc = CRYPT_DEREncodeItemsAsSet;
        cItem++;
    }
    if (ret)
        ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
         items, cItem, 0, NULL, pvData, pcbData);
 
    return ret;
}

Referenced by CRYPT_SavePKCSToMem(), and CSignedEncodeMsg_GetParam().

◆ CRYPT_AsnEncodeConstructed()

BOOL WINAPI CRYPT_AsnEncodeConstructed	(	DWORD	dwCertEncodingType,
		LPCSTR	lpszStructType,
		const void *	pvStructInfo,
		DWORD	dwFlags,
		PCRYPT_ENCODE_PARA	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 239 of file encode.c.

{
    BOOL ret;
    const struct AsnConstructedItem *item = pvStructInfo;
    DWORD len;
 
    if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
     item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
    {
        DWORD dataLen, bytesNeeded;
 
        CRYPT_EncodeLen(len, NULL, &dataLen);
        bytesNeeded = 1 + dataLen + len;
        if (!pbEncoded)
            *pcbEncoded = bytesNeeded;
        else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
         pbEncoded, pcbEncoded, bytesNeeded)))
        {
            BYTE *out;
 
            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
                pbEncoded = *(BYTE **)pbEncoded;
            out = pbEncoded;
            *out++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
            CRYPT_EncodeLen(len, out, &dataLen);
            out += dataLen;
            ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
             item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
             out, &len);
            if (!ret)
            {
                /* Some functions propagate their errors through the size */
                *pcbEncoded = len;
                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
                    CRYPT_FreeSpace(pEncodePara, pbEncoded);
            }
        }
    }
    else
    {
        /* Some functions propagate their errors through the size */
        *pcbEncoded = len;
    }
    return ret;
}

Referenced by CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertVersion(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodePKCSContentInfoInternal(), and CRYPT_EncodeDataContentInfoHeader().

◆ CRYPT_AsnEncodeOctets()

BOOL WINAPI CRYPT_AsnEncodeOctets	(	DWORD	dwCertEncodingType,
		LPCSTR	lpszStructType,
		const void *	pvStructInfo,
		DWORD	dwFlags,
		PCRYPT_ENCODE_PARA	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 3178 of file encode.c.

{
    BOOL ret;
 
    __TRY
    {
        const CRYPT_DATA_BLOB *blob = pvStructInfo;
        DWORD bytesNeeded, lenBytes;
 
        TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
         dwFlags, pEncodePara, pbEncoded, pbEncoded ? *pcbEncoded : 0);
 
        CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
        bytesNeeded = 1 + lenBytes + blob->cbData;
        if (!pbEncoded)
        {
            *pcbEncoded = bytesNeeded;
            ret = TRUE;
        }
        else
        {
            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
             pcbEncoded, bytesNeeded)))
            {
                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
                    pbEncoded = *(BYTE **)pbEncoded;
                *pbEncoded++ = ASN_OCTETSTRING;
                CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
                pbEncoded += lenBytes;
                if (blob->cbData)
                    memcpy(pbEncoded, blob->pbData, blob->cbData);
            }
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        SetLastError(STATUS_ACCESS_VIOLATION);
        ret = FALSE;
    }
    __ENDTRY
    TRACE("returning %d (%08x)\n", ret, GetLastError());
    return ret;
}

Referenced by CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeCTLEntry(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodeRecipientInfo(), CRYPT_EncodePKCSDigestedData(), CRYPT_GetBuiltinEncoder(), and CSignedMsgData_AppendMessageDigestAttribute().

◆ CRYPT_AsnEncodeOid()

BOOL WINAPI CRYPT_AsnEncodeOid	(	DWORD	dwCertEncodingType,
		LPCSTR	lpszStructType,
		const void *	pvStructInfo,
		DWORD	dwFlags,
		PCRYPT_ENCODE_PARA	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 820 of file encode.c.

{
    LPCSTR pszObjId = pvStructInfo;
    DWORD bytesNeeded = 0, lenBytes;
    BOOL ret = TRUE;
    int firstPos = 0;
    BYTE firstByte = 0;
 
    TRACE("%s\n", debugstr_a(pszObjId));
 
    if (pszObjId)
    {
        const char *ptr;
        int val1, val2;
 
        if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2)
        {
            SetLastError(CRYPT_E_ASN1_ERROR);
            return FALSE;
        }
        bytesNeeded++;
        firstByte = val1 * 40 + val2;
        ptr = pszObjId + firstPos;
        if (*ptr == '.')
        {
            ptr++;
            firstPos++;
        }
        while (ret && *ptr)
        {
            int pos;
 
            /* note I assume each component is at most 32-bits long in base 2 */
            if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
            {
                if (val1 >= 0x10000000)
                    bytesNeeded += 5;
                else if (val1 >= 0x200000)
                    bytesNeeded += 4;
                else if (val1 >= 0x4000)
                    bytesNeeded += 3;
                else if (val1 >= 0x80)
                    bytesNeeded += 2;
                else
                    bytesNeeded += 1;
                ptr += pos;
                if (*ptr == '.')
                    ptr++;
            }
            else
            {
                SetLastError(CRYPT_E_ASN1_ERROR);
                return FALSE;
            }
        }
        CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
    }
    else
        lenBytes = 1;
    bytesNeeded += 1 + lenBytes;
    if (pbEncoded)
    {
        if (*pcbEncoded < bytesNeeded)
        {
            SetLastError(ERROR_MORE_DATA);
            ret = FALSE;
        }
        else
        {
            *pbEncoded++ = ASN_OBJECTIDENTIFIER;
            CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
            pbEncoded += lenBytes;
            if (pszObjId)
            {
                const char *ptr;
                int val, pos;
 
                *pbEncoded++ = firstByte;
                ptr = pszObjId + firstPos;
                while (ret && *ptr)
                {
                    sscanf(ptr, "%d%n", &val, &pos);
                    {
                        unsigned char outBytes[5];
                        int numBytes, i;
 
                        if (val >= 0x10000000)
                            numBytes = 5;
                        else if (val >= 0x200000)
                            numBytes = 4;
                        else if (val >= 0x4000)
                            numBytes = 3;
                        else if (val >= 0x80)
                            numBytes = 2;
                        else
                            numBytes = 1;
                        for (i = numBytes; i > 0; i--)
                        {
                            outBytes[i - 1] = val & 0x7f;
                            val >>= 7;
                        }
                        for (i = 0; i < numBytes - 1; i++)
                            *pbEncoded++ = outBytes[i] | 0x80;
                        *pbEncoded++ = outBytes[i];
                        ptr += pos;
                        if (*ptr == '.')
                            ptr++;
                    }
                }
            }
        }
    }
    *pcbEncoded = bytesNeeded;
    return ret;
}

Referenced by CRYPT_AsnEncodeAccessDescription(), CRYPT_AsnEncodeAlgorithmId(), CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAltNameEntry(), CRYPT_AsnEncodeCertPolicy(), CRYPT_AsnEncodeCertPolicyMapping(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeCTLSubjectAlgorithm(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodePKCSAttribute(), CRYPT_AsnEncodePKCSContentInfoInternal(), CRYPT_AsnEncodeRdnAttr(), CRYPT_AsnEncodeSMIMECapability(), and CRYPT_EncodeDataContentInfoHeader().

◆ CRYPT_AsnEncodePKCSDigestedData()

BOOL CRYPT_AsnEncodePKCSDigestedData	(	const CRYPT_DIGESTED_DATA *	digestedData,
		void *	pvData,
		DWORD *	pcbData
	)

Definition at line 1952 of file encode.c.

{
    struct AsnEncodeSequenceItem items[] = {
     { &digestedData->version, CRYPT_AsnEncodeInt, 0 },
     { &digestedData->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams,
       0 },
     { &digestedData->ContentInfo, CRYPT_AsnEncodePKCSContentInfoInternal, 0 },
     { &digestedData->hash, CRYPT_AsnEncodeOctets, 0 },
    };
 
    return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pvData, pcbData);
}

Referenced by CRYPT_EncodePKCSDigestedData().

◆ CRYPT_AsnEncodePKCSEnvelopedData()

BOOL CRYPT_AsnEncodePKCSEnvelopedData	(	const CRYPT_ENVELOPED_DATA *	envelopedData,
		void *	pvData,
		DWORD *	pcbData
	)

Definition at line 4418 of file encode.c.

{
    struct DERSetDescriptor recipientInfosSet = { envelopedData->cRecipientInfo,
     envelopedData->rgRecipientInfo, sizeof(CMSG_KEY_TRANS_RECIPIENT_INFO), 0,
     CRYPT_AsnEncodeRecipientInfo };
    struct AsnEncodeSequenceItem items[] = {
     { &envelopedData->version, CRYPT_AsnEncodeInt, 0 },
     { &recipientInfosSet, CRYPT_DEREncodeItemsAsSet, 0 },
     { &envelopedData->encryptedContentInfo,
       CRYPT_AsnEncodeEncryptedContentInfo, 0 },
    };
 
    return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
     ARRAY_SIZE(items), 0, NULL, pvData, pcbData);
}

Referenced by CEnvelopedEncodeMsg_GetParam().

◆ CRYPT_AsnEncodePubKeyInfoNoNull()

BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull	(	DWORD	dwCertEncodingType,
		LPCSTR	lpszStructType,
		const void *	pvStructInfo,
		DWORD	dwFlags,
		PCRYPT_ENCODE_PARA	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 484 of file encode.c.

{
    BOOL ret;
    const CERT_PUBLIC_KEY_INFO *info = pvStructInfo;
    struct AsnEncodeSequenceItem items[] = {
     { &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
     { &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
    };
 
    TRACE("Encoding public key with OID %s\n",
     debugstr_a(info->Algorithm.pszObjId));
    ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items,
     ARRAY_SIZE(items), dwFlags, pEncodePara, pbEncoded,
     pcbEncoded);
    return ret;
}

Referenced by CRYPT_AsnEncodeCertInfo(), and CryptHashPublicKeyInfo().

◆ CRYPT_AsnEncodeSequence()

BOOL WINAPI CRYPT_AsnEncodeSequence	(	DWORD	dwCertEncodingType,
		struct AsnEncodeSequenceItem	items[],
		DWORD	cItem,
		DWORD	dwFlags,
		PCRYPT_ENCODE_PARA	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 180 of file encode.c.

{
    BOOL ret;
    DWORD i, dataLen = 0;
 
    TRACE("%p, %d, %08x, %p, %p, %d\n", items, cItem, dwFlags, pEncodePara,
     pbEncoded, pbEncoded ? *pcbEncoded : 0);
    for (i = 0, ret = TRUE; ret && i < cItem; i++)
    {
        ret = items[i].encodeFunc(dwCertEncodingType, NULL,
         items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL,
         NULL, &items[i].size);
        /* Some functions propagate their errors through the size */
        if (!ret)
            *pcbEncoded = items[i].size;
        dataLen += items[i].size;
    }
    if (ret)
    {
        DWORD lenBytes, bytesNeeded;
 
        CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
        bytesNeeded = 1 + lenBytes + dataLen;
        if (!pbEncoded)
            *pcbEncoded = bytesNeeded;
        else
        {
            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
             pcbEncoded, bytesNeeded)))
            {
                BYTE *out;
 
                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
                    pbEncoded = *(BYTE **)pbEncoded;
                out = pbEncoded;
                *out++ = ASN_SEQUENCE;
                CRYPT_EncodeLen(dataLen, out, &lenBytes);
                out += lenBytes;
                for (i = 0; ret && i < cItem; i++)
                {
                    ret = items[i].encodeFunc(dwCertEncodingType, NULL,
                     items[i].pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG,
                     NULL, out, &items[i].size);
                    /* Some functions propagate their errors through the size */
                    if (!ret)
                        *pcbEncoded = items[i].size;
                    out += items[i].size;
                }
                if (!ret && (dwFlags & CRYPT_ENCODE_ALLOC_FLAG))
                    CRYPT_FreeSpace(pEncodePara, pbEncoded);
            }
        }
    }
    TRACE("returning %d (%08x)\n", ret, GetLastError());
    return ret;
}

Referenced by CRYPT_AsnEncodeAccessDescription(), CRYPT_AsnEncodeAlgorithmId(), CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeBasicConstraints(), CRYPT_AsnEncodeBasicConstraints2(), CRYPT_AsnEncodeCert(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertPolicy(), CRYPT_AsnEncodeCertPolicyConstraints(), CRYPT_AsnEncodeCertPolicyMapping(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCRLEntry(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeCTLEntry(), CRYPT_AsnEncodeCTLSubjectAlgorithm(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodeGeneralSubtree(), CRYPT_AsnEncodeIssuerSerialNumber(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodeNameConstraints(), CRYPT_AsnEncodeNoticeReference(), CRYPT_AsnEncodePKCSAttribute(), CRYPT_AsnEncodePKCSContentInfoInternal(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSEnvelopedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodePolicyQualifierUserNotice(), CRYPT_AsnEncodePubKeyInfo(), CRYPT_AsnEncodePubKeyInfoNoNull(), CRYPT_AsnEncodeRecipientInfo(), CRYPT_AsnEncodeRsaPubKey(), CRYPT_AsnEncodeSMIMECapability(), CRYPT_AsnEncodeValidity(), and CRYPT_EncodeDataContentInfoHeader().

◆ CRYPT_CollectionOpenStore()

WINECRYPT_CERTSTORE * CRYPT_CollectionOpenStore	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 464 of file collectionstore.c.

{
    WINE_COLLECTIONSTORE *store;
 
    if (dwFlags & CERT_STORE_DELETE_FLAG)
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        store = NULL;
    }
    else
    {
        store = CryptMemAlloc(sizeof(WINE_COLLECTIONSTORE));
        if (store)
        {
            memset(store, 0, sizeof(WINE_COLLECTIONSTORE));
            CRYPT_InitStore(&store->hdr, dwFlags, StoreTypeCollection, &CollectionStoreVtbl);
            InitializeCriticalSection(&store->cs);
            store->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_COLLECTIONSTORE->cs");
            list_init(&store->stores);
        }
    }
    return (WINECRYPT_CERTSTORE*)store;
}

Referenced by CertOpenStore().

◆ CRYPT_CreateChainEngine()

HCERTCHAINENGINE CRYPT_CreateChainEngine	(	HCERTSTORE	root,
		DWORD	system_store,
		const CERT_CHAIN_ENGINE_CONFIG *	config
	)

Definition at line 115 of file chain.c.

{
    CertificateChainEngine *engine;
    HCERTSTORE worldStores[4];
 
    static const WCHAR caW[] = { 'C','A',0 };
    static const WCHAR myW[] = { 'M','y',0 };
    static const WCHAR trustW[] = { 'T','r','u','s','t',0 };
 
    if(!root) {
        if(config->cbSize >= sizeof(CERT_CHAIN_ENGINE_CONFIG) && config->hExclusiveRoot)
            root = CertDuplicateStore(config->hExclusiveRoot);
        else if (config->hRestrictedRoot)
            root = CertDuplicateStore(config->hRestrictedRoot);
        else
            root = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0, system_store, rootW);
        if(!root)
            return NULL;
    }
 
    engine = CryptMemAlloc(sizeof(CertificateChainEngine));
    if(!engine) {
        CertCloseStore(root, 0);
        return NULL;
    }
 
    engine->ref = 1;
    engine->hRoot = root;
    engine->hWorld = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0, CERT_STORE_CREATE_NEW_FLAG, NULL);
    worldStores[0] = CertDuplicateStore(engine->hRoot);
    worldStores[1] = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0, system_store, caW);
    worldStores[2] = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0, system_store, myW);
    worldStores[3] = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0, system_store, trustW);
 
    CRYPT_AddStoresToCollection(engine->hWorld, ARRAY_SIZE(worldStores), worldStores);
    CRYPT_AddStoresToCollection(engine->hWorld, config->cAdditionalStore, config->rghAdditionalStore);
    CRYPT_CloseStores(ARRAY_SIZE(worldStores), worldStores);
 
    engine->dwFlags = config->dwFlags;
    engine->dwUrlRetrievalTimeout = config->dwUrlRetrievalTimeout;
    engine->MaximumCachedCertificates = config->MaximumCachedCertificates;
    if(config->CycleDetectionModulus)
        engine->CycleDetectionModulus = config->CycleDetectionModulus;
    else
        engine->CycleDetectionModulus = DEFAULT_CYCLE_MODULUS;
 
    return engine;
}

Referenced by CertCreateCertificateChainEngine(), check_and_store_certs(), and get_chain_engine().

◆ CRYPT_EncodeEnsureSpace()

BOOL CRYPT_EncodeEnsureSpace	(	DWORD	dwFlags,
		const CRYPT_ENCODE_PARA *	pEncodePara,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded,
		DWORD	bytesNeeded
	)

Definition at line 103 of file encode.c.

{
    BOOL ret = TRUE;
 
    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    {
        if (pEncodePara && pEncodePara->pfnAlloc)
            *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
        else
            *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
        if (!*(BYTE **)pbEncoded)
            ret = FALSE;
        else
            *pcbEncoded = bytesNeeded;
    }
    else if (bytesNeeded > *pcbEncoded)
    {
        *pcbEncoded = bytesNeeded;
        SetLastError(ERROR_MORE_DATA);
        ret = FALSE;
    }
    else
        *pcbEncoded = bytesNeeded;
    return ret;
}

◆ CRYPT_EncodeLen()

BOOL CRYPT_EncodeLen	(	DWORD	len,
		BYTE *	pbEncoded,
		DWORD *	pcbEncoded
	)

Definition at line 138 of file encode.c.

{
    DWORD bytesNeeded, significantBytes = 0;
 
    if (len <= 0x7f)
        bytesNeeded = 1;
    else
    {
        DWORD temp;
 
        for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
         temp <<= 8, significantBytes--)
            ;
        bytesNeeded = significantBytes + 1;
    }
    if (!pbEncoded)
    {
        *pcbEncoded = bytesNeeded;
        return TRUE;
    }
    if (*pcbEncoded < bytesNeeded)
    {
        SetLastError(ERROR_MORE_DATA);
        return FALSE;
    }
    if (len <= 0x7f)
        *pbEncoded = (BYTE)len;
    else
    {
        DWORD i;
 
        *pbEncoded++ = significantBytes | 0x80;
        for (i = 0; i < significantBytes; i++)
        {
            *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
            len >>= 8;
        }
    }
    *pcbEncoded = bytesNeeded;
    return TRUE;
}

Referenced by CRYPT_AsnEncodeAltName(), CRYPT_AsnEncodeAltNameEntry(), CRYPT_AsnEncodeAuthorityInfoAccess(), CRYPT_AsnEncodeBits(), CRYPT_AsnEncodeBMPString(), CRYPT_AsnEncodeCertPolicies(), CRYPT_AsnEncodeCertPolicyMappings(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeConstructed(), CRYPT_AsnEncodeCRLDistPoints(), CRYPT_AsnEncodeCRLEntries(), CRYPT_AsnEncodeCTLEntries(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtensions(), CRYPT_AsnEncodeIA5String(), CRYPT_AsnEncodeInteger(), CRYPT_AsnEncodeName(), CRYPT_AsnEncodeNoticeNumbers(), CRYPT_AsnEncodeNumericString(), CRYPT_AsnEncodeOctets(), CRYPT_AsnEncodeOid(), CRYPT_AsnEncodePrintableString(), CRYPT_AsnEncodeRdnAttr(), CRYPT_AsnEncodeSequence(), CRYPT_AsnEncodeSequenceOfAny(), CRYPT_AsnEncodeSMIMECapabilities(), CRYPT_AsnEncodeStringCoerce(), CRYPT_AsnEncodeUnicodeName(), CRYPT_AsnEncodeUnicodeStringCoerce(), CRYPT_AsnEncodeUniversalString(), CRYPT_AsnEncodeUnsignedInteger(), CRYPT_AsnEncodeUTF8String(), CRYPT_DEREncodeItemsAsSet(), CRYPT_DEREncodeSet(), and CRYPT_EncodeContentLength().

◆ CRYPT_FileNameOpenStoreA()

WINECRYPT_CERTSTORE * CRYPT_FileNameOpenStoreA	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 383 of file filestore.c.

{
    int len;
    WINECRYPT_CERTSTORE *ret = NULL;
 
    TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
     debugstr_a(pvPara));
 
    if (!pvPara)
    {
        SetLastError(ERROR_FILE_NOT_FOUND);
        return NULL;
    }
    len = MultiByteToWideChar(CP_ACP, 0, pvPara, -1, NULL, 0);
    if (len)
    {
        LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
 
        if (storeName)
        {
            MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
            ret = CRYPT_FileNameOpenStoreW(hCryptProv, dwFlags, storeName);
            CryptMemFree(storeName);
        }
    }
    return ret;
}

Referenced by CertOpenStore().

◆ CRYPT_FileNameOpenStoreW()

WINECRYPT_CERTSTORE * CRYPT_FileNameOpenStoreW	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 292 of file filestore.c.

{
    HCERTSTORE store = 0;
    LPCWSTR fileName = pvPara;
    DWORD access, create;
    HANDLE file;
 
    TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
 
    if (!fileName)
    {
        SetLastError(ERROR_PATH_NOT_FOUND);
        return NULL;
    }
    if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
     (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
    {
        SetLastError(E_INVALIDARG);
        return NULL;
    }
 
    access = GENERIC_READ;
    if (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG)
        access |= GENERIC_WRITE;
    if (dwFlags & CERT_STORE_CREATE_NEW_FLAG)
        create = CREATE_NEW;
    else if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
        create = OPEN_EXISTING;
    else
        create = OPEN_ALWAYS;
    file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL, create,
     FILE_ATTRIBUTE_NORMAL, NULL);
    if (file != INVALID_HANDLE_VALUE)
    {
        HCERTSTORE memStore = NULL;
        DWORD size = GetFileSize(file, NULL), type = 0;
 
        /* If the file isn't empty, try to get the type from the file itself */
        if (size)
        {
            DWORD contentType;
            BOOL ret;
 
            /* Close the file so CryptQueryObject can succeed.. */
            CloseHandle(file);
            ret = CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
             CERT_QUERY_CONTENT_FLAG_CERT |
             CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
             CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
             CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL, &contentType, NULL,
             &memStore, NULL, NULL);
            if (ret)
            {
                if (contentType == CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
                    type = CERT_STORE_SAVE_AS_PKCS7;
                else
                    type = CERT_STORE_SAVE_AS_STORE;
                /* and reopen the file. */
                file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL,
                 create, FILE_ATTRIBUTE_NORMAL, NULL);
            }
        }
        else
        {
            static const WCHAR spc[] = { 's','p','c',0 };
            static const WCHAR p7c[] = { 'p','7','c',0 };
            LPCWSTR ext = strrchrW(fileName, '.');
 
            if (ext)
            {
                ext++;
                if (!lstrcmpiW(ext, spc) || !lstrcmpiW(ext, p7c))
                    type = CERT_STORE_SAVE_AS_PKCS7;
            }
            if (!type)
                type = CERT_STORE_SAVE_AS_STORE;
            memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
             CERT_STORE_CREATE_NEW_FLAG, NULL);
        }
        if (memStore)
        {
            store = CRYPT_CreateFileStore(dwFlags, memStore, file, type);
            /* File store doesn't need crypto provider, so close it */
            if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
                CryptReleaseContext(hCryptProv, 0);
        }
    }
    return store;
}

Referenced by CertOpenStore(), and CRYPT_FileNameOpenStoreA().

◆ CRYPT_FileOpenStore()

WINECRYPT_CERTSTORE * CRYPT_FileOpenStore	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 242 of file filestore.c.

{
    WINECRYPT_CERTSTORE *store = NULL;
    HANDLE file = (HANDLE)pvPara;
 
    TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
 
    if (!pvPara)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
    if (dwFlags & CERT_STORE_DELETE_FLAG)
    {
        SetLastError(E_INVALIDARG);
        return NULL;
    }
    if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
     (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
    {
        SetLastError(E_INVALIDARG);
        return NULL;
    }
 
    if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
     GetCurrentProcess(), &file, dwFlags & CERT_STORE_READONLY_FLAG ?
     GENERIC_READ : GENERIC_READ | GENERIC_WRITE, TRUE, 0))
    {
        HCERTSTORE memStore;
 
        memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
         CERT_STORE_CREATE_NEW_FLAG, NULL);
        if (memStore)
        {
            if (CRYPT_ReadSerializedStoreFromFile(file, memStore))
            {
                store = CRYPT_CreateFileStore(dwFlags, memStore, file,
                 CERT_STORE_SAVE_AS_STORE);
                /* File store doesn't need crypto provider, so close it */
                if (hCryptProv &&
                 !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
                    CryptReleaseContext(hCryptProv, 0);
            }
        }
    }
    TRACE("returning %p\n", store);
    return store;
}

Referenced by CertOpenStore().

◆ CRYPT_FixKeyProvInfoPointers()

void CRYPT_FixKeyProvInfoPointers ( PCRYPT_KEY_PROV_INFO info )

Definition at line 523 of file cert.c.

{
    DWORD i, containerLen, provNameLen;
    LPBYTE data = (LPBYTE)info + sizeof(CRYPT_KEY_PROV_INFO);
 
    info->pwszContainerName = (LPWSTR)data;
    containerLen = (lstrlenW(info->pwszContainerName) + 1) * sizeof(WCHAR);
    data += containerLen;
 
    info->pwszProvName = (LPWSTR)data;
    provNameLen = (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR);
    data += provNameLen;
 
    if (info->cProvParam)
    {
        info->rgProvParam = (PCRYPT_KEY_PROV_PARAM)data;
        data += info->cProvParam * sizeof(CRYPT_KEY_PROV_PARAM);
 
        for (i = 0; i < info->cProvParam; i++)
        {
            info->rgProvParam[i].pbData = data;
            data += info->rgProvParam[i].cbData;
        }
    }
    else
        info->rgProvParam = NULL;
}

Referenced by CertGetCertificateContextProperty(), and CRYPT_ReadContextProp().

◆ CRYPT_FreeStore()

void CRYPT_FreeStore ( WINECRYPT_CERTSTORE * store )

Definition at line 101 of file store.c.

{
    if (store->properties)
        ContextPropertyList_Free(store->properties);
    store->dwMagic = 0;
    CryptMemFree(store);
}

Referenced by Collection_release(), MemStore_release(), and ProvStore_release().

◆ CRYPT_ImportSystemRootCertsToReg()

void CRYPT_ImportSystemRootCertsToReg ( void )

Definition at line 1044 of file rootstore.c.

{
    HCERTSTORE store = NULL;
    HKEY key;
    LONG rc;
    HANDLE hsem;
 
    static BOOL root_certs_imported = FALSE;
 
    if (root_certs_imported)
        return;
 
    hsem = CreateSemaphoreW( NULL, 0, 1, semaphoreW);
    if (!hsem)
    {
        ERR("Failed to create semaphore\n");
        return;
    }
 
    if(GetLastError() == ERROR_ALREADY_EXISTS)
        WaitForSingleObject(hsem, INFINITE);
    else
    {
        if ((store = create_root_store()))
        {
            rc = RegCreateKeyExW(HKEY_LOCAL_MACHINE, certs_root_pathW, 0, NULL, 0,
                KEY_ALL_ACCESS, NULL, &key, 0);
            if (!rc)
            {
                if (!CRYPT_SerializeContextsToReg(key, REG_OPTION_VOLATILE, pCertInterface, store))
                    ERR("Failed to import system certs into registry, %08x\n", GetLastError());
                RegCloseKey(key);
            }
            CertCloseStore(store, 0);
        } else
            ERR("Failed to create root store\n");
    }
 
    root_certs_imported = TRUE;
    ReleaseSemaphore(hsem, 1, NULL);
    CloseHandle(hsem);
}

Referenced by CRYPT_SysRegOpenStoreW().

◆ CRYPT_InitStore()

void CRYPT_InitStore	(	WINECRYPT_CERTSTORE *	store,
		DWORD	dwFlags,
		CertStoreType	type,
		const store_vtbl_t *	vtbl
	)

Definition at line 91 of file store.c.

{
    store->ref = 1;
    store->dwMagic = WINE_CRYPTCERTSTORE_MAGIC;
    store->type = type;
    store->dwOpenFlags = dwFlags;
    store->vtbl = vtbl;
    store->properties = NULL;
}

Referenced by CRYPT_CollectionOpenStore(), CRYPT_MemOpenStore(), CRYPT_ProvCreateStore(), and init_empty_store().

◆ CRYPT_IsCertificateSelfSigned()

DWORD CRYPT_IsCertificateSelfSigned ( const CERT_CONTEXT * cert )

Definition at line 268 of file chain.c.

{
    DWORD size, status = 0;
    PCERT_EXTENSION ext;
    BOOL ret;
 
    if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
     cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
    {
        CERT_AUTHORITY_KEY_ID2_INFO *info;
 
        ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
         X509_AUTHORITY_KEY_ID2, ext->Value.pbData, ext->Value.cbData,
         CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
         &info, &size);
        if (ret)
        {
            if (info->AuthorityCertIssuer.cAltEntry &&
             info->AuthorityCertSerialNumber.cbData)
            {
                PCERT_ALT_NAME_ENTRY directoryName = NULL;
                DWORD i;
 
                for (i = 0; !directoryName &&
                 i < info->AuthorityCertIssuer.cAltEntry; i++)
                    if (info->AuthorityCertIssuer.rgAltEntry[i].dwAltNameChoice
                     == CERT_ALT_NAME_DIRECTORY_NAME)
                        directoryName =
                         &info->AuthorityCertIssuer.rgAltEntry[i];
                if (directoryName)
                {
                    if (CertCompareCertificateName(cert->dwCertEncodingType, &directoryName->u.DirectoryName, &cert->pCertInfo->Issuer)
                            && CertCompareIntegerBlob(&info->AuthorityCertSerialNumber, &cert->pCertInfo->SerialNumber))
                        status = CERT_TRUST_HAS_NAME_MATCH_ISSUER;
                }
                else
                {
                    FIXME("no supported name type in authority key id2\n");
                    ret = FALSE;
                }
            }
            else if (info->KeyId.cbData)
            {
                ret = CertGetCertificateContextProperty(cert,
                 CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
                if (ret && size == info->KeyId.cbData)
                {
                    LPBYTE buf = CryptMemAlloc(size);
 
                    if (buf)
                    {
                        CertGetCertificateContextProperty(cert, CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
                        if (!memcmp(buf, info->KeyId.pbData, size))
                            status = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
                        CryptMemFree(buf);
                    }
                }
            }
            LocalFree(info);
        }
    }
    else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
     cert->pCertInfo->cExtension, cert->pCertInfo->rgExtension)))
    {
        CERT_AUTHORITY_KEY_ID_INFO *info;
 
        ret = CryptDecodeObjectEx(cert->dwCertEncodingType,
         X509_AUTHORITY_KEY_ID, ext->Value.pbData, ext->Value.cbData,
         CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
         &info, &size);
        if (ret)
        {
            if (info->CertIssuer.cbData && info->CertSerialNumber.cbData)
            {
                if (CertCompareCertificateName(cert->dwCertEncodingType, &info->CertIssuer, &cert->pCertInfo->Issuer)
                        && CertCompareIntegerBlob(&info->CertSerialNumber, &cert->pCertInfo->SerialNumber))
                    status = CERT_TRUST_HAS_NAME_MATCH_ISSUER;
            }
            else if (info->KeyId.cbData)
            {
                ret = CertGetCertificateContextProperty(cert,
                 CERT_KEY_IDENTIFIER_PROP_ID, NULL, &size);
                if (ret && size == info->KeyId.cbData)
                {
                    LPBYTE buf = CryptMemAlloc(size);
 
                    if (buf)
                    {
                        CertGetCertificateContextProperty(cert,
                         CERT_KEY_IDENTIFIER_PROP_ID, buf, &size);
                        if (!memcmp(buf, info->KeyId.pbData, size))
                            status = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
                        CryptMemFree(buf);
                    }
                }
            }
            LocalFree(info);
        }
    }
    else
        if (CertCompareCertificateName(cert->dwCertEncodingType, &cert->pCertInfo->Subject, &cert->pCertInfo->Issuer))
            status = CERT_TRUST_HAS_NAME_MATCH_ISSUER;
 
    if (status)
        status |= CERT_TRUST_IS_SELF_SIGNED;
 
    return status;
}

Referenced by CertGetIssuerCertificateFromStore(), CRYPT_BuildSimpleChain(), CRYPT_CheckChainNameConstraints(), and CRYPT_CheckSimpleChain().

◆ 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_ProvCreateStore()

WINECRYPT_CERTSTORE * CRYPT_ProvCreateStore	(	DWORD	dwFlags,
		WINECRYPT_CERTSTORE *	memStore,
		const CERT_STORE_PROV_INFO *	pProvInfo
	)

Definition at line 307 of file provstore.c.

{
    WINE_PROVIDERSTORE *ret = CryptMemAlloc(sizeof(WINE_PROVIDERSTORE));
 
    if (ret)
    {
        CRYPT_InitStore(&ret->hdr, dwFlags, StoreTypeProvider, &ProvStoreVtbl);
        ret->dwStoreProvFlags = pProvInfo->dwStoreProvFlags;
        if (ret->dwStoreProvFlags & CERT_STORE_PROV_EXTERNAL_FLAG)
        {
            CertCloseStore(memStore, 0);
            ret->memStore = NULL;
        }
        else
            ret->memStore = memStore;
        ret->hStoreProv = pProvInfo->hStoreProv;
        if (pProvInfo->cStoreProvFunc > CERT_STORE_PROV_CLOSE_FUNC)
            ret->provCloseStore =
             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_CLOSE_FUNC];
        else
            ret->provCloseStore = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_WRITE_CERT_FUNC)
            ret->provWriteCert = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_WRITE_CERT_FUNC];
        else
            ret->provWriteCert = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_DELETE_CERT_FUNC)
            ret->provDeleteCert = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_DELETE_CERT_FUNC];
        else
            ret->provDeleteCert = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_WRITE_CRL_FUNC)
            ret->provWriteCrl = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_WRITE_CRL_FUNC];
        else
            ret->provWriteCrl = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_DELETE_CRL_FUNC)
            ret->provDeleteCrl = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_DELETE_CRL_FUNC];
        else
            ret->provDeleteCrl = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_WRITE_CTL_FUNC)
            ret->provWriteCtl = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_WRITE_CTL_FUNC];
        else
            ret->provWriteCtl = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_DELETE_CTL_FUNC)
            ret->provDeleteCtl = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_DELETE_CTL_FUNC];
        else
            ret->provDeleteCtl = NULL;
        if (pProvInfo->cStoreProvFunc >
         CERT_STORE_PROV_CONTROL_FUNC)
            ret->provControl = pProvInfo->rgpvStoreProvFunc[
             CERT_STORE_PROV_CONTROL_FUNC];
        else
            ret->provControl = NULL;
    }
    return (WINECRYPT_CERTSTORE*)ret;
}

Referenced by create_root_store(), CRYPT_CreateFileStore(), CRYPT_MsgOpenStore(), CRYPT_ProvOpenStore(), and CRYPT_RegOpenStore().

◆ CRYPT_ProvOpenStore()

WINECRYPT_CERTSTORE * CRYPT_ProvOpenStore	(	LPCSTR	lpszStoreProvider,
		DWORD	dwEncodingType,
		HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 375 of file provstore.c.

{
    static HCRYPTOIDFUNCSET set = NULL;
    PFN_CERT_DLL_OPEN_STORE_PROV_FUNC provOpenFunc;
    HCRYPTOIDFUNCADDR hFunc;
    WINECRYPT_CERTSTORE *ret = NULL;
 
    if (!set)
        set = CryptInitOIDFunctionSet(CRYPT_OID_OPEN_STORE_PROV_FUNC, 0);
    CryptGetOIDFunctionAddress(set, dwEncodingType, lpszStoreProvider, 0,
     (void **)&provOpenFunc, &hFunc);
    if (provOpenFunc)
    {
        CERT_STORE_PROV_INFO provInfo = { 0 };
 
        provInfo.cbSize = sizeof(provInfo);
        if (dwFlags & CERT_STORE_DELETE_FLAG)
            provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
             dwFlags, pvPara, NULL, &provInfo);
        else
        {
            HCERTSTORE memStore;
 
            memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
             CERT_STORE_CREATE_NEW_FLAG, NULL);
            if (memStore)
            {
                if (provOpenFunc(lpszStoreProvider, dwEncodingType, hCryptProv,
                 dwFlags, pvPara, memStore, &provInfo))
                    ret = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
                else
                    CertCloseStore(memStore, 0);
            }
        }
        CryptFreeOIDFunctionAddress(hFunc, 0);
    }
    else
        SetLastError(ERROR_FILE_NOT_FOUND);
    return ret;
}

Referenced by CertOpenStore().

◆ CRYPT_ReadSerializedElement()

const void * CRYPT_ReadSerializedElement	(	const BYTE *	pbElement,
		DWORD	cbElement,
		DWORD	dwContextTypeFlags,
		DWORD *	pdwContentType
	)

Definition at line 295 of file serialize.c.

{
    const void *context;
 
    TRACE("(%p, %d, %08x, %p)\n", pbElement, cbElement, dwContextTypeFlags,
     pdwContentType);
 
    if (!cbElement)
    {
        SetLastError(ERROR_END_OF_MEDIA);
        return NULL;
    }
 
    __TRY
    {
        const WINE_CONTEXT_INTERFACE *contextInterface = NULL;
        const WINE_CERT_PROP_HEADER *hdr = NULL;
        DWORD type = 0;
        BOOL ret;
 
        ret = TRUE;
        context = NULL;
        if (dwContextTypeFlags == CERT_STORE_ALL_CONTEXT_FLAG)
        {
            hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
            if (hdr)
                type = CERT_STORE_CERTIFICATE_CONTEXT;
            else
            {
                hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
                if (hdr)
                    type = CERT_STORE_CRL_CONTEXT;
                else
                {
                    hdr = CRYPT_findPropID(pbElement, cbElement,
                     CERT_CTL_PROP_ID);
                    if (hdr)
                        type = CERT_STORE_CTL_CONTEXT;
                }
            }
        }
        else if (dwContextTypeFlags & CERT_STORE_CERTIFICATE_CONTEXT_FLAG)
        {
            hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CERT_PROP_ID);
            type = CERT_STORE_CERTIFICATE_CONTEXT;
        }
        else if (dwContextTypeFlags & CERT_STORE_CRL_CONTEXT_FLAG)
        {
            hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CRL_PROP_ID);
            type = CERT_STORE_CRL_CONTEXT;
        }
        else if (dwContextTypeFlags & CERT_STORE_CTL_CONTEXT_FLAG)
        {
            hdr = CRYPT_findPropID(pbElement, cbElement, CERT_CTL_PROP_ID);
            type = CERT_STORE_CTL_CONTEXT;
        }
 
        switch (type)
        {
        case CERT_STORE_CERTIFICATE_CONTEXT:
            contextInterface = pCertInterface;
            break;
        case CERT_STORE_CRL_CONTEXT:
            contextInterface = pCRLInterface;
            break;
        case CERT_STORE_CTL_CONTEXT:
            contextInterface = pCTLInterface;
            break;
        default:
            SetLastError(E_INVALIDARG);
            ret = FALSE;
        }
        if (!hdr)
            ret = FALSE;
 
        if (ret)
            context = contextInterface->create(X509_ASN_ENCODING,
             (BYTE *)hdr + sizeof(WINE_CERT_PROP_HEADER), hdr->cb);
        if (ret && context)
        {
            BOOL noMoreProps = FALSE;
 
            while (!noMoreProps && ret)
            {
                if (cbElement < sizeof(WINE_CERT_PROP_HEADER))
                    ret = FALSE;
                else
                {
                    const WINE_CERT_PROP_HEADER *hdr =
                     (const WINE_CERT_PROP_HEADER *)pbElement;
 
                    TRACE("prop is %d\n", hdr->propID);
                    cbElement -= sizeof(WINE_CERT_PROP_HEADER);
                    pbElement += sizeof(WINE_CERT_PROP_HEADER);
                    if (!hdr->propID)
                    {
                        /* Like in CRYPT_findPropID, stop if the propID is zero
                         */
                        noMoreProps = TRUE;
                    }
                    else
                        ret = CRYPT_ReadContextProp(contextInterface, context,
                         hdr, pbElement, cbElement);
                    pbElement += hdr->cb;
                    cbElement -= hdr->cb;
                    if (!cbElement)
                        noMoreProps = TRUE;
                }
            }
            if (ret)
            {
                if (pdwContentType)
                    *pdwContentType = type;
            }
            else
            {
                Context_Release(context_from_ptr(context));
                context = NULL;
            }
        }
    }
    __EXCEPT_PAGE_FAULT
    {
        SetLastError(STATUS_ACCESS_VIOLATION);
        context = NULL;
    }
    __ENDTRY
    return context;
}

Referenced by CertAddSerializedElementToStore(), CRYPT_QuerySerializedContextObject(), and CRYPT_RegReadSerializedFromReg().

◆ CRYPT_ReadSerializedStoreFromBlob()

BOOL CRYPT_ReadSerializedStoreFromBlob	(	const CRYPT_DATA_BLOB *	blob,
		HCERTSTORE	store
	)

Definition at line 578 of file serialize.c.

{
    struct BlobReader reader = { blob, 0 };
 
    return CRYPT_ReadSerializedStore(&reader, read_blob_wrapper, store);
}

Referenced by CRYPT_QuerySerializedStoreFromBlob(), and CRYPT_SerializedOpenStore().

◆ CRYPT_ReadSerializedStoreFromFile()

BOOL CRYPT_ReadSerializedStoreFromFile	(	HANDLE	file,
		HCERTSTORE	store
	)

Definition at line 544 of file serialize.c.

{
    return CRYPT_ReadSerializedStore(file, read_file_wrapper, store);
}

Referenced by CRYPT_FileControl(), CRYPT_FileOpenStore(), and CRYPT_QuerySerializedStoreFromFile().

◆ CRYPT_RegOpenStore()

WINECRYPT_CERTSTORE * CRYPT_RegOpenStore	(	HCRYPTPROV	hCryptProv,
		DWORD	dwFlags,
		const void *	pvPara
	)

Definition at line 512 of file regstore.c.

{
    WINECRYPT_CERTSTORE *store = NULL;
 
    TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
 
    if (dwFlags & CERT_STORE_DELETE_FLAG)
    {
        DWORD rc = RegDeleteTreeW((HKEY)pvPara, CertsW);
 
        if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
            rc = RegDeleteTreeW((HKEY)pvPara, CRLsW);
        if (rc == ERROR_SUCCESS || rc == ERROR_NO_MORE_ITEMS)
            rc = RegDeleteTreeW((HKEY)pvPara, CTLsW);
        if (rc == ERROR_NO_MORE_ITEMS)
            rc = ERROR_SUCCESS;
        SetLastError(rc);
    }
    else
    {
        HKEY key;
 
        if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
         GetCurrentProcess(), (LPHANDLE)&key,
         dwFlags & CERT_STORE_READONLY_FLAG ? KEY_READ : KEY_ALL_ACCESS,
         TRUE, 0))
        {
            WINECRYPT_CERTSTORE *memStore;
 
            memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, hCryptProv,
             CERT_STORE_CREATE_NEW_FLAG, NULL);
            if (memStore)
            {
                WINE_REGSTOREINFO *regInfo = CryptMemAlloc(
                 sizeof(WINE_REGSTOREINFO));
 
                if (regInfo)
                {
                    CERT_STORE_PROV_INFO provInfo = { 0 };
 
                    regInfo->dwOpenFlags = dwFlags;
                    regInfo->memStore = memStore;
                    regInfo->key = key;
                    InitializeCriticalSection(&regInfo->cs);
                    regInfo->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_REGSTOREINFO->cs");
                    list_init(&regInfo->certsToDelete);
                    list_init(&regInfo->crlsToDelete);
                    list_init(&regInfo->ctlsToDelete);
                    CRYPT_RegReadFromReg(regInfo->key, regInfo->memStore);
                    regInfo->dirty = FALSE;
                    provInfo.cbSize = sizeof(provInfo);
                    provInfo.cStoreProvFunc = ARRAY_SIZE(regProvFuncs);
                    provInfo.rgpvStoreProvFunc = regProvFuncs;
                    provInfo.hStoreProv = regInfo;
                    store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
                    /* Reg store doesn't need crypto provider, so close it */
                    if (hCryptProv &&
                     !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
                        CryptReleaseContext(hCryptProv, 0);
                }
            }
        }
    }
    TRACE("returning %p\n", store);
    return store;
}

Referenced by CertOpenStore(), and CRYPT_SysRegOpenStoreW().

◆ CRYPT_SerializeContextsToReg()

BOOL CRYPT_SerializeContextsToReg	(	HKEY	key,
		DWORD	flags,
		const WINE_CONTEXT_INTERFACE *	contextInterface,
		HCERTSTORE	memStore
	)

Definition at line 208 of file regstore.c.

{
    const void *context = NULL;
    BOOL ret;
 
    do {
        context = contextInterface->enumContextsInStore(memStore, context);
        if (context)
        {
            BYTE hash[20];
            DWORD hashSize = sizeof(hash);
 
            ret = contextInterface->getProp(context, CERT_HASH_PROP_ID, hash,
             &hashSize);
            if (ret)
            {
                DWORD size = 0;
                LPBYTE buf = NULL;
 
                ret = contextInterface->serialize(context, 0, NULL, &size);
                if (size)
                    buf = CryptMemAlloc(size);
                if (buf)
                {
                    ret = contextInterface->serialize(context, 0, buf, &size);
                    if (ret)
                        ret = CRYPT_WriteSerializedToReg(key, flags, hash, buf, size);
                }
                CryptMemFree(buf);
            }
        }
        else
            ret = TRUE;
    } while (ret && context != NULL);
    if (context)
        Context_Release(context_from_ptr(context));
    return ret;
}

Referenced by CRYPT_ImportSystemRootCertsToReg(), and CRYPT_RegWriteToReg().

◆ crypt_sip_free()

void crypt_sip_free ( void )

Definition at line 610 of file sip.c.

{
    WINE_SIP_PROVIDER *prov, *next;
 
    LIST_FOR_EACH_ENTRY_SAFE(prov, next, &providers, WINE_SIP_PROVIDER, entry)
    {
        list_remove(&prov->entry);
        FreeLibrary(prov->info.hSIP);
        CryptMemFree(prov);
    }
    DeleteCriticalSection(&providers_cs);
}

Referenced by DllMain().

◆ ctl_from_ptr()

static ctl_t * ctl_from_ptr ( const CTL_CONTEXT * ptr )

inlinestatic

Definition at line 222 of file crypt32_private.h.

{
    return CONTAINING_RECORD(ptr, ctl_t, ctx);
}

Referenced by CertDeleteCTLFromStore(), CertDuplicateCTLContext(), CertEnumCTLContextProperties(), CertEnumCTLsInStore(), CertFreeCTLContext(), CertGetCTLContextProperty(), and CertSetCTLContextProperty().

◆ default_chain_engine_free()

void default_chain_engine_free ( void )

Definition at line 255 of file chain.c.

{
    free_chain_engine(default_cu_engine);
    free_chain_engine(default_lm_engine);
}

Referenced by DllMain().

◆ I_CertUpdateStore()

BOOL WINAPI I_CertUpdateStore	(	HCERTSTORE	store1,
		HCERTSTORE	store2,
		DWORD	unk0,
		DWORD	unk1
	)

Definition at line 109 of file store.c.

{
    static BOOL warned = FALSE;
    const WINE_CONTEXT_INTERFACE * const interfaces[] = { pCertInterface,
     pCRLInterface, pCTLInterface };
    DWORD i;
 
    TRACE("(%p, %p, %08x, %08x)\n", store1, store2, unk0, unk1);
    if (!warned)
    {
        FIXME("semi-stub\n");
        warned = TRUE;
    }
 
    /* Poor-man's resync:  empty first store, then add everything from second
     * store to it.
     */
    for (i = 0; i < ARRAY_SIZE(interfaces); i++)
    {
        const void *context;
 
        do {
            context = interfaces[i]->enumContextsInStore(store1, NULL);
            if (context)
                interfaces[i]->deleteFromStore(context);
        } while (context);
        do {
            context = interfaces[i]->enumContextsInStore(store2, context);
            if (context)
                interfaces[i]->addContextToStore(store1, context,
                 CERT_STORE_ADD_ALWAYS, NULL);
        } while (context);
    }
    return TRUE;
}

Referenced by CRYPT_FileControl(), and CRYPT_RegControl().

◆ I_CryptGetDefaultCryptProv()

HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv ( ALG_ID algid )

Definition at line 210 of file main.c.

{
    HCRYPTPROV prov, defprov;
 
    TRACE("(%08x)\n", algid);
 
    defprov = CRYPT_GetDefaultProvider();
 
    if (algid && !is_supported_algid(defprov, algid))
    {
        DWORD i = 0, type, size;
 
        while (CryptEnumProvidersW(i, NULL, 0, &type, NULL, &size))
        {
            WCHAR *name = CryptMemAlloc(size);
            if (name)
            {
                if (CryptEnumProvidersW(i, NULL, 0, &type, name, &size))
                {
                    if (CryptAcquireContextW(&prov, NULL, name, type, CRYPT_VERIFYCONTEXT))
                    {
                        if (is_supported_algid(prov, algid))
                        {
                            CryptMemFree(name);
                            return prov;
                        }
                        CryptReleaseContext(prov, 0);
                    }
                }
                CryptMemFree(name);
            }
            i++;
        }
 
        SetLastError(E_INVALIDARG);
        return 0;
    }
 
    CryptContextAddRef(defprov, NULL, 0);
    return defprov;
}

Referenced by CDecodeMsg_FinalizeHashedContent(), CEnvelopedEncodeMsg_Open(), CertGetPublicKeyLength(), CHashEncodeMsg_Open(), CRYPT_VerifySignature(), CryptHashCertificate(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptSignCertificate(), and CSignedMsgData_ConstructSignerHandles().

◆ init_empty_store()

void init_empty_store ( void )

Definition at line 1511 of file store.c.

{
    CRYPT_InitStore(&empty_store, CERT_STORE_READONLY_FLAG, StoreTypeEmpty, &EmptyStoreVtbl);
}

Referenced by DllMain().

◆ root_store_free()

void root_store_free ( void )

Variable Documentation

◆ DECLSPEC_HIDDEN

WINECRYPT_CERTSTORE empty_store DECLSPEC_HIDDEN

extern

Definition at line 262 of file crypt32_private.h.

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ALIGN_DWORD_PTR

◆ ASN_BITSTRING

◆ ASN_BMPSTRING

◆ ASN_BOOL

◆ ASN_ENUMERATED

◆ ASN_GENERALSTRING

◆ ASN_GENERALTIME

◆ ASN_GRAPHICSTRING

◆ ASN_IA5STRING

◆ ASN_NUMERICSTRING

◆ ASN_PRINTABLESTRING

◆ ASN_SETOF

◆ ASN_T61STRING

◆ ASN_UNIVERSALSTRING

◆ ASN_UTCTIME

◆ ASN_UTF8STRING

◆ ASN_VIDEOTEXSTRING

◆ ASN_VISIBLESTRING

◆ CERT_CERT_PROP_ID

◆ CERT_CRL_PROP_ID

◆ CERT_CTL_PROP_ID

◆ IS_INTOID

◆ POINTER_ALIGN_DWORD_PTR

◆ WINE_CRYPTCERTSTORE_MAGIC

Typedef Documentation

◆ AddContextToStoreFunc

◆ AddEncodedContextToStoreFunc

◆ CertStoreType

◆ CONTEXT_FUNCS

◆ CONTEXT_PROPERTY_LIST

◆ context_t

◆ CreateContextFunc

◆ CRYPT_DIGESTED_DATA

◆ CRYPT_ENCRYPTED_CONTENT_INFO

◆ CRYPT_ENVELOPED_DATA

◆ CRYPT_SIGNED_INFO

◆ CryptEncodeObjectExFunc

◆ DeleteContextFunc

◆ EnumContextsInStoreFunc

◆ EnumPropertiesFunc

◆ GetContextPropertyFunc

◆ SerializeElementFunc

◆ SetContextPropertyFunc

◆ StoreOpenFunc

◆ WINE_CONTEXT_INTERFACE

◆ WINECRYPT_CERTSTORE

Enumeration Type Documentation

◆ _CertStoreType

Function Documentation

◆ cert_from_ptr()

◆ cert_name_to_str_with_indent()

◆ Context_AddRef()

◆ Context_CopyProperties()

◆ Context_CreateDataContext()

◆ Context_CreateLinkContext()

◆ Context_Free()

◆ context_from_ptr()

◆ context_ptr()

◆ Context_Release()

◆ ContextPropertyList_Copy()

◆ ContextPropertyList_Create()

◆ ContextPropertyList_EnumPropIDs()

◆ ContextPropertyList_FindProperty()

◆ ContextPropertyList_Free()

◆ ContextPropertyList_RemoveProperty()

◆ ContextPropertyList_SetProperty()

◆ crl_from_ptr()

◆ CRYPT_AsnDecodeCMSSignedInfo()

◆ CRYPT_AsnDecodePKCSDigestedData()

◆ CRYPT_AsnDecodePKCSEnvelopedData()

◆ CRYPT_AsnEncodeCMSSignedInfo()

◆ CRYPT_AsnEncodeConstructed()

◆ CRYPT_AsnEncodeOctets()