dlls/crypt32/crypt32_private.h

   1 /*
   2  * Copyright 2005 Juan Lang
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef __CRYPT32_PRIVATE_H__
  20 #define __CRYPT32_PRIVATE_H__
  21
  22 #include "wine/list.h"
  23
  24 BOOL CNG_ImportPubKey(CERT_PUBLIC_KEY_INFO *pubKeyInfo, BCRYPT_KEY_HANDLE *key) DECLSPEC_HIDDEN;
  25
  26 /* a few asn.1 tags we need */
  27 #define ASN_BOOL            (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
  28 #define ASN_BITSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
  29 #define ASN_ENUMERATED      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0a)
  30 #define ASN_UTF8STRING      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0c)
  31 #define ASN_SETOF           (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x11)
  32 #define ASN_NUMERICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x12)
  33 #define ASN_PRINTABLESTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x13)
  34 #define ASN_T61STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x14)
  35 #define ASN_VIDEOTEXSTRING  (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x15)
  36 #define ASN_IA5STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x16)
  37 #define ASN_UTCTIME         (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x17)
  38 #define ASN_GENERALTIME     (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x18)
  39 #define ASN_GRAPHICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x19)
  40 #define ASN_VISIBLESTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1a)
  41 #define ASN_GENERALSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1b)
  42 #define ASN_UNIVERSALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1c)
  43 #define ASN_BMPSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
  44
  45 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  46
  47 typedef BOOL (WINAPI *CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *,
  48  DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *);
  49
  50 struct AsnEncodeSequenceItem
  51 {
  52     const void             *pvStructInfo;
  53     CryptEncodeObjectExFunc encodeFunc;
  54     DWORD                   size; /* used during encoding, not for your use */
  55 };
  56
  57 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
  58  struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
  59  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  60
  61 struct AsnConstructedItem
  62 {
  63     BYTE                    tag;
  64     const void             *pvStructInfo;
  65     CryptEncodeObjectExFunc encodeFunc;
  66 };
  67
  68 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
  69  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  70  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  71 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
  72  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  73  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  74 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
  75  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  76  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  77
  78 typedef struct _CRYPT_DIGESTED_DATA
  79 {
  80     DWORD                      version;
  81     CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
  82     CRYPT_CONTENT_INFO         ContentInfo;
  83     CRYPT_HASH_BLOB            hash;
  84 } CRYPT_DIGESTED_DATA;
  85
  86 BOOL CRYPT_AsnEncodePKCSDigestedData(const CRYPT_DIGESTED_DATA *digestedData,
  87  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
  88
  89 typedef struct _CRYPT_ENCRYPTED_CONTENT_INFO
  90 {
  91     LPSTR                      contentType;
  92     CRYPT_ALGORITHM_IDENTIFIER contentEncryptionAlgorithm;
  93     CRYPT_DATA_BLOB            encryptedContent;
  94 } CRYPT_ENCRYPTED_CONTENT_INFO;
  95
  96 typedef struct _CRYPT_ENVELOPED_DATA
  97 {
  98     DWORD                          version;
  99     DWORD                          cRecipientInfo;
 100     PCMSG_KEY_TRANS_RECIPIENT_INFO rgRecipientInfo;
 101     CRYPT_ENCRYPTED_CONTENT_INFO   encryptedContentInfo;
 102 } CRYPT_ENVELOPED_DATA;
 103
 104 BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData,
 105  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
 106
 107 BOOL CRYPT_AsnDecodePKCSEnvelopedData(const BYTE *pbEncoded, DWORD cbEncoded,
 108  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 109  CRYPT_ENVELOPED_DATA *envelopedData, DWORD *pcbEnvelopedData) DECLSPEC_HIDDEN;
 110
 111 typedef struct _CRYPT_SIGNED_INFO
 112 {
 113     DWORD                 version;
 114     DWORD                 cCertEncoded;
 115     PCERT_BLOB            rgCertEncoded;
 116     DWORD                 cCrlEncoded;
 117     PCRL_BLOB             rgCrlEncoded;
 118     CRYPT_CONTENT_INFO    content;
 119     DWORD                 cSignerInfo;
 120     PCMSG_CMS_SIGNER_INFO rgSignerInfo;
 121     PDWORD                signerKeySpec;
 122 } CRYPT_SIGNED_INFO;
 123
 124 BOOL CRYPT_AsnEncodeCMSSignedInfo(CRYPT_SIGNED_INFO *, void *pvData,
 125  DWORD *pcbData) DECLSPEC_HIDDEN;
 126
 127 BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded,
 128  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 129  CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo) DECLSPEC_HIDDEN;
 130
 131 /* Helper function to check *pcbEncoded, set it to the required size, and
 132  * optionally to allocate memory.  Assumes pbEncoded is not NULL.
 133  * If CRYPT_ENCODE_ALLOC_FLAG is set in dwFlags, *pbEncoded will be set to a
 134  * pointer to the newly allocated memory.
 135  */
 136 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara,
 137  BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) DECLSPEC_HIDDEN;
 138
 139 BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded,
 140  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 141  CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData) DECLSPEC_HIDDEN;
 142
 143 BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull(DWORD dwCertEncodingType,
 144  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
 145  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
 146
 147 /* The following aren't defined in wincrypt.h, as they're "reserved" */
 148 #define CERT_CERT_PROP_ID 32
 149 #define CERT_CRL_PROP_ID  33
 150 #define CERT_CTL_PROP_ID  34
 151
 152 /* Returns a handle to the default crypto provider; loads it if necessary.
 153  * Returns NULL on failure.
 154  */
 155 HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(ALG_ID);
 156
 157 extern HINSTANCE hInstance DECLSPEC_HIDDEN;
 158
 159 void crypt_oid_init(void) DECLSPEC_HIDDEN;
 160 void crypt_oid_free(void) DECLSPEC_HIDDEN;
 161 void crypt_sip_free(void) DECLSPEC_HIDDEN;
 162 void root_store_free(void) DECLSPEC_HIDDEN;
 163 void default_chain_engine_free(void) DECLSPEC_HIDDEN;
 164
 165 /* (Internal) certificate store types and functions */
 166 struct WINE_CRYPTCERTSTORE;
 167
 168 typedef struct _CONTEXT_PROPERTY_LIST CONTEXT_PROPERTY_LIST;
 169
 170 typedef struct _context_t context_t;
 171
 172 typedef struct {
 173     void (*free)(context_t*);
 174     struct _context_t *(*clone)(context_t*,struct WINE_CRYPTCERTSTORE*,BOOL);
 175 } context_vtbl_t;
 176
 177 struct _context_t {
 178     const context_vtbl_t *vtbl;
 179     LONG ref;
 180     struct WINE_CRYPTCERTSTORE *store;
 181     struct _context_t *linked;
 182     CONTEXT_PROPERTY_LIST *properties;
 183     union {
 184         struct list entry;
 185         void *ptr;
 186     } u;
 187 };
 188
 189 static inline context_t *context_from_ptr(const void *ptr)
 190 {
 191     return (context_t*)ptr-1;
 192 }
 193
 194 static inline void *context_ptr(context_t *context)
 195 {
 196     return context+1;
 197 }
 198
 199 typedef struct {
 200     context_t base;
 201     CERT_CONTEXT ctx;
 202 } cert_t;
 203
 204 static inline cert_t *cert_from_ptr(const CERT_CONTEXT *ptr)
 205 {
 206     return CONTAINING_RECORD(ptr, cert_t, ctx);
 207 }
 208
 209 typedef struct {
 210     context_t base;
 211     CRL_CONTEXT ctx;
 212 } crl_t;
 213
 214 static inline crl_t *crl_from_ptr(const CRL_CONTEXT *ptr)
 215 {
 216     return CONTAINING_RECORD(ptr, crl_t, ctx);
 217 }
 218
 219 typedef struct {
 220     context_t base;
 221     CTL_CONTEXT ctx;
 222 } ctl_t;
 223
 224 static inline ctl_t *ctl_from_ptr(const CTL_CONTEXT *ptr)
 225 {
 226     return CONTAINING_RECORD(ptr, ctl_t, ctx);
 227 }
 228
 229 /* Some typedefs that make it easier to abstract which type of context we're
 230  * working with.
 231  */
 232 typedef const void *(WINAPI *CreateContextFunc)(DWORD dwCertEncodingType,
 233  const BYTE *pbCertEncoded, DWORD cbCertEncoded);
 234 typedef BOOL (WINAPI *AddContextToStoreFunc)(HCERTSTORE hCertStore,
 235  const void *context, DWORD dwAddDisposition, const void **ppStoreContext);
 236 typedef BOOL (WINAPI *AddEncodedContextToStoreFunc)(HCERTSTORE hCertStore,
 237  DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded,
 238  DWORD dwAddDisposition, const void **ppContext);
 239 typedef const void *(WINAPI *EnumContextsInStoreFunc)(HCERTSTORE hCertStore,
 240  const void *pPrevContext);
 241 typedef DWORD (WINAPI *EnumPropertiesFunc)(const void *context, DWORD dwPropId);
 242 typedef BOOL (WINAPI *GetContextPropertyFunc)(const void *context,
 243  DWORD dwPropID, void *pvData, DWORD *pcbData);
 244 typedef BOOL (WINAPI *SetContextPropertyFunc)(const void *context,
 245  DWORD dwPropID, DWORD dwFlags, const void *pvData);
 246 typedef BOOL (WINAPI *SerializeElementFunc)(const void *context, DWORD dwFlags,
 247  BYTE *pbElement, DWORD *pcbElement);
 248 typedef BOOL (WINAPI *DeleteContextFunc)(const void *contex);
 249
 250 /* An abstract context (certificate, CRL, or CTL) interface */
 251 typedef struct _WINE_CONTEXT_INTERFACE
 252 {
 253     CreateContextFunc            create;
 254     AddContextToStoreFunc        addContextToStore;
 255     AddEncodedContextToStoreFunc addEncodedToStore;
 256     EnumContextsInStoreFunc      enumContextsInStore;
 257     EnumPropertiesFunc           enumProps;
 258     GetContextPropertyFunc       getProp;
 259     SetContextPropertyFunc       setProp;
 260     SerializeElementFunc         serialize;
 261     DeleteContextFunc            deleteFromStore;
 262 } WINE_CONTEXT_INTERFACE;
 263
 264 extern const WINE_CONTEXT_INTERFACE *pCertInterface DECLSPEC_HIDDEN;
 265 extern const WINE_CONTEXT_INTERFACE *pCRLInterface DECLSPEC_HIDDEN;
 266 extern const WINE_CONTEXT_INTERFACE *pCTLInterface DECLSPEC_HIDDEN;
 267
 268 typedef struct WINE_CRYPTCERTSTORE * (*StoreOpenFunc)(HCRYPTPROV hCryptProv,
 269  DWORD dwFlags, const void *pvPara);
 270
 271 typedef struct _CONTEXT_FUNCS
 272 {
 273   /* Called to add a context to a store.  If toReplace is not NULL,
 274    * context replaces toReplace in the store, and access checks should not be
 275    * performed.  Otherwise context is a new context, and it should only be
 276    * added if the store allows it.  If ppStoreContext is not NULL, the added
 277    * context should be returned in *ppStoreContext.
 278    */
 279     BOOL (*addContext)(struct WINE_CRYPTCERTSTORE*,context_t*,context_t*,context_t**,BOOL);
 280     context_t *(*enumContext)(struct WINE_CRYPTCERTSTORE *store, context_t *prev);
 281     BOOL (*delete)(struct WINE_CRYPTCERTSTORE*,context_t*);
 282 } CONTEXT_FUNCS;
 283
 284 typedef enum _CertStoreType {
 285     StoreTypeMem,
 286     StoreTypeCollection,
 287     StoreTypeProvider,
 288     StoreTypeEmpty
 289 } CertStoreType;
 290
 291 #define WINE_CRYPTCERTSTORE_MAGIC 0x74726563
 292
 293 /* A cert store is polymorphic through the use of function pointers.  A type
 294  * is still needed to distinguish collection stores from other types.
 295  * On the function pointers:
 296  * - closeStore is called when the store's ref count becomes 0
 297  * - control is optional, but should be implemented by any store that supports
 298  *   persistence
 299  */
 300
 301 typedef struct {
 302     void (*addref)(struct WINE_CRYPTCERTSTORE*);
 303     DWORD (*release)(struct WINE_CRYPTCERTSTORE*,DWORD);
 304     void (*releaseContext)(struct WINE_CRYPTCERTSTORE*,context_t*);
 305     BOOL (*control)(struct WINE_CRYPTCERTSTORE*,DWORD,DWORD,void const*);
 306     CONTEXT_FUNCS certs;
 307     CONTEXT_FUNCS crls;
 308     CONTEXT_FUNCS ctls;
 309 } store_vtbl_t;
 310
 311 typedef struct WINE_CRYPTCERTSTORE
 312 {
 313     DWORD                       dwMagic;
 314     LONG                        ref;
 315     DWORD                       dwOpenFlags;
 316     CertStoreType               type;
 317     const store_vtbl_t         *vtbl;
 318     CONTEXT_PROPERTY_LIST      *properties;
 319 } WINECRYPT_CERTSTORE;
 320
 321 void CRYPT_InitStore(WINECRYPT_CERTSTORE *store, DWORD dwFlags,
 322  CertStoreType type, const store_vtbl_t*) DECLSPEC_HIDDEN;
 323 void CRYPT_FreeStore(WINECRYPT_CERTSTORE *store) DECLSPEC_HIDDEN;
 324 BOOL WINAPI I_CertUpdateStore(HCERTSTORE store1, HCERTSTORE store2, DWORD unk0,
 325  DWORD unk1) DECLSPEC_HIDDEN;
 326
 327 WINECRYPT_CERTSTORE *CRYPT_CollectionOpenStore(HCRYPTPROV hCryptProv,
 328  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 329 WINECRYPT_CERTSTORE *CRYPT_ProvCreateStore(DWORD dwFlags,
 330  WINECRYPT_CERTSTORE *memStore, const CERT_STORE_PROV_INFO *pProvInfo) DECLSPEC_HIDDEN;
 331 WINECRYPT_CERTSTORE *CRYPT_ProvOpenStore(LPCSTR lpszStoreProvider,
 332  DWORD dwEncodingType, HCRYPTPROV hCryptProv, DWORD dwFlags,
 333  const void *pvPara) DECLSPEC_HIDDEN;
 334 WINECRYPT_CERTSTORE *CRYPT_RegOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
 335  const void *pvPara) DECLSPEC_HIDDEN;
 336 WINECRYPT_CERTSTORE *CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
 337  const void *pvPara) DECLSPEC_HIDDEN;
 338 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
 339  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 340 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
 341  DWORD dwFlags, const void *pvPara) DECLSPEC_HIDDEN;
 342
 343 void CRYPT_ImportSystemRootCertsToReg(void) DECLSPEC_HIDDEN;
 344 BOOL CRYPT_SerializeContextsToReg(HKEY key, DWORD flags, const WINE_CONTEXT_INTERFACE *contextInterface,
 345     HCERTSTORE memStore) DECLSPEC_HIDDEN;
 346
 347 DWORD CRYPT_IsCertificateSelfSigned(const CERT_CONTEXT *cert) DECLSPEC_HIDDEN;
 348
 349 /* Allocates and initializes a certificate chain engine, but without creating
 350  * the root store.  Instead, it uses root, and assumes the caller has done any
 351  * checking necessary.
 352  */
 353 HCERTCHAINENGINE CRYPT_CreateChainEngine(HCERTSTORE, DWORD, const CERT_CHAIN_ENGINE_CONFIG*) DECLSPEC_HIDDEN;
 354
 355 /* Helper function for store reading functions and
 356  * CertAddSerializedElementToStore.  Returns a context of the appropriate type
 357  * if it can, or NULL otherwise.  Doesn't validate any of the properties in
 358  * the serialized context (for example, bad hashes are retained.)
 359  * *pdwContentType is set to the type of the returned context.
 360  */
 361 const void *CRYPT_ReadSerializedElement(const BYTE *pbElement,
 362  DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType) DECLSPEC_HIDDEN;
 363
 364 /* Reads contexts serialized in the file into the memory store.  Returns FALSE
 365  * if the file is not of the expected format.
 366  */
 367 BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store) DECLSPEC_HIDDEN;
 368
 369 /* Reads contexts serialized in the blob into the memory store.  Returns FALSE
 370  * if the file is not of the expected format.
 371  */
 372 BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
 373  HCERTSTORE store) DECLSPEC_HIDDEN;
 374
 375 struct store_CERT_KEY_CONTEXT
 376 {
 377     DWORD   cbSize;
 378     DWORD64 hCryptProv;
 379     DWORD   dwKeySpec;
 380 };
 381 void CRYPT_ConvertKeyContext(const struct store_CERT_KEY_CONTEXT *src, CERT_KEY_CONTEXT *dst) DECLSPEC_HIDDEN;
 382
 383 /**
 384  *  String functions
 385  */
 386
 387 DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indent,
 388  const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz) DECLSPEC_HIDDEN;
 389
 390 /**
 391  *  Context functions
 392  */
 393
 394 /* Allocates a new data context, a context which owns properties directly.
 395  * contextSize is the size of the public data type associated with context,
 396  * which should be one of CERT_CONTEXT, CRL_CONTEXT, or CTL_CONTEXT.
 397  * Free with Context_Release.
 398  */
 399 context_t *Context_CreateDataContext(size_t contextSize, const context_vtbl_t *vtbl, struct WINE_CRYPTCERTSTORE*) DECLSPEC_HIDDEN;
 400
 401 /* Creates a new link context.  The context refers to linked
 402  * rather than owning its own properties.  If addRef is TRUE (which ordinarily
 403  * it should be) linked is addref'd.
 404  * Free with Context_Release.
 405  */
 406 context_t *Context_CreateLinkContext(unsigned contextSize, context_t *linked, struct WINE_CRYPTCERTSTORE*) DECLSPEC_HIDDEN;
 407
 408 /* Copies properties from fromContext to toContext. */
 409 void Context_CopyProperties(const void *to, const void *from) DECLSPEC_HIDDEN;
 410
 411 void Context_AddRef(context_t*) DECLSPEC_HIDDEN;
 412 void Context_Release(context_t *context) DECLSPEC_HIDDEN;
 413 void Context_Free(context_t*) DECLSPEC_HIDDEN;
 414
 415 /**
 416  *  Context property list functions
 417  */
 418
 419 CONTEXT_PROPERTY_LIST *ContextPropertyList_Create(void) DECLSPEC_HIDDEN;
 420
 421 /* Searches for the property with ID id in the context.  Returns TRUE if found,
 422  * and copies the property's length and a pointer to its data to blob.
 423  * Otherwise returns FALSE.
 424  */
 425 BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 426  PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN;
 427
 428 BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 429  const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN;
 430
 431 void ContextPropertyList_RemoveProperty(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 432
 433 DWORD ContextPropertyList_EnumPropIDs(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 434
 435 void ContextPropertyList_Copy(CONTEXT_PROPERTY_LIST *to,
 436  CONTEXT_PROPERTY_LIST *from) DECLSPEC_HIDDEN;
 437
 438 void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN;
 439
 440 extern WINECRYPT_CERTSTORE empty_store DECLSPEC_HIDDEN;
 441 void init_empty_store(void) DECLSPEC_HIDDEN;
 442
 443 /**
 444  *  Utilities.
 445  */
 446
 447 /* Align up to a DWORD_PTR boundary
 448  */
 449 #define ALIGN_DWORD_PTR(x) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))
 450 #define POINTER_ALIGN_DWORD_PTR(p) ((LPVOID)ALIGN_DWORD_PTR((DWORD_PTR)(p)))
 451
 452 /* Check if the OID is a small int
 453  */
 454 #define IS_INTOID(x)    (((ULONG_PTR)(x) >> 16) == 0)
 455
 456 /* Unix interface */
 457
 458 struct unix_funcs
 459 {
 460     BOOL (WINAPI *enum_root_certs)( void *buffer, SIZE_T size, SIZE_T *needed );
 461     BOOL (WINAPI *import_cert_store)( CRYPT_DATA_BLOB *pfx, const WCHAR *password, DWORD flags,
 462                                       void **key_ret, void ***chain_ret, DWORD *count_ret );
 463 };
 464
 465 extern const struct unix_funcs *unix_funcs DECLSPEC_HIDDEN;
 466
 467 #endif