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 /* a few asn.1 tags we need */
  25 #define ASN_BOOL            (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
  26 #define ASN_BITSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
  27 #define ASN_ENUMERATED      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0a)
  28 #define ASN_UTF8STRING      (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x0c)
  29 #define ASN_SETOF           (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x11)
  30 #define ASN_NUMERICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x12)
  31 #define ASN_PRINTABLESTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x13)
  32 #define ASN_T61STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x14)
  33 #define ASN_VIDEOTEXSTRING  (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x15)
  34 #define ASN_IA5STRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x16)
  35 #define ASN_UTCTIME         (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x17)
  36 #define ASN_GENERALTIME     (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x18)
  37 #define ASN_GRAPHICSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x19)
  38 #define ASN_VISIBLESTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1a)
  39 #define ASN_GENERALSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1b)
  40 #define ASN_UNIVERSALSTRING (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1c)
  41 #define ASN_BMPSTRING       (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
  42
  43 BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  44
  45 typedef BOOL (WINAPI *CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *,
  46  DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *);
  47
  48 struct AsnEncodeSequenceItem
  49 {
  50     const void             *pvStructInfo;
  51     CryptEncodeObjectExFunc encodeFunc;
  52     DWORD                   size; /* used during encoding, not for your use */
  53 };
  54
  55 BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType,
  56  struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags,
  57  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  58
  59 struct AsnConstructedItem
  60 {
  61     BYTE                    tag;
  62     const void             *pvStructInfo;
  63     CryptEncodeObjectExFunc encodeFunc;
  64 };
  65
  66 BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType,
  67  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  68  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  69 BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType,
  70  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  71  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  72 BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType,
  73  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
  74  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
  75
  76 typedef struct _CRYPT_DIGESTED_DATA
  77 {
  78     DWORD                      version;
  79     CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
  80     CRYPT_CONTENT_INFO         ContentInfo;
  81     CRYPT_HASH_BLOB            hash;
  82 } CRYPT_DIGESTED_DATA;
  83
  84 BOOL CRYPT_AsnEncodePKCSDigestedData(const CRYPT_DIGESTED_DATA *digestedData,
  85  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
  86
  87 typedef struct _CRYPT_ENCRYPTED_CONTENT_INFO
  88 {
  89     LPSTR                      contentType;
  90     CRYPT_ALGORITHM_IDENTIFIER contentEncryptionAlgorithm;
  91     CRYPT_DATA_BLOB            encryptedContent;
  92 } CRYPT_ENCRYPTED_CONTENT_INFO;
  93
  94 typedef struct _CRYPT_ENVELOPED_DATA
  95 {
  96     DWORD                          version;
  97     DWORD                          cRecipientInfo;
  98     PCMSG_KEY_TRANS_RECIPIENT_INFO rgRecipientInfo;
  99     CRYPT_ENCRYPTED_CONTENT_INFO   encryptedContentInfo;
 100 } CRYPT_ENVELOPED_DATA;
 101
 102 BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData,
 103  void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN;
 104
 105 BOOL CRYPT_AsnDecodePKCSEnvelopedData(const BYTE *pbEncoded, DWORD cbEncoded,
 106  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 107  CRYPT_ENVELOPED_DATA *envelopedData, DWORD *pcbEnvelopedData) DECLSPEC_HIDDEN;
 108
 109 typedef struct _CRYPT_SIGNED_INFO
 110 {
 111     DWORD                 version;
 112     DWORD                 cCertEncoded;
 113     PCERT_BLOB            rgCertEncoded;
 114     DWORD                 cCrlEncoded;
 115     PCRL_BLOB             rgCrlEncoded;
 116     CRYPT_CONTENT_INFO    content;
 117     DWORD                 cSignerInfo;
 118     PCMSG_CMS_SIGNER_INFO rgSignerInfo;
 119 } CRYPT_SIGNED_INFO;
 120
 121 BOOL CRYPT_AsnEncodeCMSSignedInfo(CRYPT_SIGNED_INFO *, void *pvData,
 122  DWORD *pcbData) DECLSPEC_HIDDEN;
 123
 124 BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded,
 125  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 126  CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo) DECLSPEC_HIDDEN;
 127
 128 /* Helper function to check *pcbEncoded, set it to the required size, and
 129  * optionally to allocate memory.  Assumes pbEncoded is not NULL.
 130  * If CRYPT_ENCODE_ALLOC_FLAG is set in dwFlags, *pbEncoded will be set to a
 131  * pointer to the newly allocated memory.
 132  */
 133 BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara,
 134  BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) DECLSPEC_HIDDEN;
 135
 136 BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded,
 137  DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara,
 138  CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData) DECLSPEC_HIDDEN;
 139
 140 BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull(DWORD dwCertEncodingType,
 141  LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
 142  PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN;
 143
 144 /* The following aren't defined in wincrypt.h, as they're "reserved" */
 145 #define CERT_CERT_PROP_ID 32
 146 #define CERT_CRL_PROP_ID  33
 147 #define CERT_CTL_PROP_ID  34
 148
 149 /* Returns a handle to the default crypto provider; loads it if necessary.
 150  * Returns NULL on failure.
 151  */
 152 HCRYPTPROV CRYPT_GetDefaultProvider(void) DECLSPEC_HIDDEN;
 153
 154 HINSTANCE hInstance DECLSPEC_HIDDEN;
 155
 156 void crypt_oid_init(void) DECLSPEC_HIDDEN;
 157 void crypt_oid_free(void) DECLSPEC_HIDDEN;
 158 void crypt_sip_free(void) DECLSPEC_HIDDEN;
 159 void root_store_free(void) DECLSPEC_HIDDEN;
 160 void default_chain_engine_free(void) DECLSPEC_HIDDEN;
 161
 162 typedef struct _CONTEXT_PROPERTY_LIST CONTEXT_PROPERTY_LIST;
 163
 164 typedef struct _context_t context_t;
 165
 166 typedef struct {
 167     void (*free)(context_t*);
 168 } context_vtbl_t;
 169
 170 typedef struct _context_t {
 171     const context_vtbl_t *vtbl;
 172     LONG ref;
 173     struct _context_t *linked;
 174     CONTEXT_PROPERTY_LIST *properties;
 175     union {
 176         struct list entry;
 177         void *ptr;
 178     } u;
 179 } BASE_CONTEXT;
 180
 181 static inline context_t *context_from_ptr(const void *ptr)
 182 {
 183     return (context_t*)ptr-1;
 184 }
 185
 186 static inline void *context_ptr(context_t *context)
 187 {
 188     return context+1;
 189 }
 190
 191 typedef struct {
 192     context_t base;
 193     CERT_CONTEXT ctx;
 194 } cert_t;
 195
 196 static inline cert_t *cert_from_ptr(const CERT_CONTEXT *ptr)
 197 {
 198     return CONTAINING_RECORD(ptr, cert_t, ctx);
 199 }
 200
 201 typedef struct {
 202     context_t base;
 203     CRL_CONTEXT ctx;
 204 } crl_t;
 205
 206 static inline crl_t *crl_from_ptr(const CRL_CONTEXT *ptr)
 207 {
 208     return CONTAINING_RECORD(ptr, crl_t, ctx);
 209 }
 210
 211 typedef struct {
 212     context_t base;
 213     CTL_CONTEXT ctx;
 214 } ctl_t;
 215
 216 static inline ctl_t *ctl_from_ptr(const CTL_CONTEXT *ptr)
 217 {
 218     return CONTAINING_RECORD(ptr, ctl_t, ctx);
 219 }
 220
 221 /* Some typedefs that make it easier to abstract which type of context we're
 222  * working with.
 223  */
 224 typedef const void *(WINAPI *CreateContextFunc)(DWORD dwCertEncodingType,
 225  const BYTE *pbCertEncoded, DWORD cbCertEncoded);
 226 typedef BOOL (WINAPI *AddContextToStoreFunc)(HCERTSTORE hCertStore,
 227  const void *context, DWORD dwAddDisposition, const void **ppStoreContext);
 228 typedef BOOL (WINAPI *AddEncodedContextToStoreFunc)(HCERTSTORE hCertStore,
 229  DWORD dwCertEncodingType, const BYTE *pbEncoded, DWORD cbEncoded,
 230  DWORD dwAddDisposition, const void **ppContext);
 231 typedef const void *(WINAPI *EnumContextsInStoreFunc)(HCERTSTORE hCertStore,
 232  const void *pPrevContext);
 233 typedef DWORD (WINAPI *EnumPropertiesFunc)(const void *context, DWORD dwPropId);
 234 typedef BOOL (WINAPI *GetContextPropertyFunc)(const void *context,
 235  DWORD dwPropID, void *pvData, DWORD *pcbData);
 236 typedef BOOL (WINAPI *SetContextPropertyFunc)(const void *context,
 237  DWORD dwPropID, DWORD dwFlags, const void *pvData);
 238 typedef BOOL (WINAPI *SerializeElementFunc)(const void *context, DWORD dwFlags,
 239  BYTE *pbElement, DWORD *pcbElement);
 240 typedef BOOL (WINAPI *DeleteContextFunc)(const void *contex);
 241
 242 /* An abstract context (certificate, CRL, or CTL) interface */
 243 typedef struct _WINE_CONTEXT_INTERFACE
 244 {
 245     CreateContextFunc            create;
 246     AddContextToStoreFunc        addContextToStore;
 247     AddEncodedContextToStoreFunc addEncodedToStore;
 248     EnumContextsInStoreFunc      enumContextsInStore;
 249     EnumPropertiesFunc           enumProps;
 250     GetContextPropertyFunc       getProp;
 251     SetContextPropertyFunc       setProp;
 252     SerializeElementFunc         serialize;
 253     DeleteContextFunc            deleteFromStore;
 254 } WINE_CONTEXT_INTERFACE;
 255
 256 extern const WINE_CONTEXT_INTERFACE *pCertInterface DECLSPEC_HIDDEN;
 257 extern const WINE_CONTEXT_INTERFACE *pCRLInterface DECLSPEC_HIDDEN;
 258 extern const WINE_CONTEXT_INTERFACE *pCTLInterface DECLSPEC_HIDDEN;
 259
 260 /* (Internal) certificate store types and functions */
 261 struct WINE_CRYPTCERTSTORE;
 262
 263 typedef struct WINE_CRYPTCERTSTORE * (*StoreOpenFunc)(HCRYPTPROV hCryptProv,
 264  DWORD dwFlags, const void *pvPara);
 265
 266 /* Called to enumerate the next context in a store. */
 267 typedef void * (*EnumFunc)(struct WINE_CRYPTCERTSTORE *store, void *pPrev);
 268
 269 /* Called to add a context to a store.  If toReplace is not NULL,
 270  * context replaces toReplace in the store, and access checks should not be
 271  * performed.  Otherwise context is a new context, and it should only be
 272  * added if the store allows it.  If ppStoreContext is not NULL, the added
 273  * context should be returned in *ppStoreContext.
 274  */
 275 typedef BOOL (*AddFunc)(struct WINE_CRYPTCERTSTORE *store, void *context,
 276  void *toReplace, const void **ppStoreContext);
 277
 278 typedef struct _CONTEXT_FUNCS
 279 {
 280     AddFunc    addContext;
 281     EnumFunc   enumContext;
 282     BOOL (*delete)(struct WINE_CRYPTCERTSTORE*,context_t*);
 283 } CONTEXT_FUNCS;
 284
 285 typedef enum _CertStoreType {
 286     StoreTypeMem,
 287     StoreTypeCollection,
 288     StoreTypeProvider,
 289     StoreTypeEmpty
 290 } CertStoreType;
 291
 292 #define WINE_CRYPTCERTSTORE_MAGIC 0x74726563
 293
 294 /* A cert store is polymorphic through the use of function pointers.  A type
 295  * is still needed to distinguish collection stores from other types.
 296  * On the function pointers:
 297  * - closeStore is called when the store's ref count becomes 0
 298  * - control is optional, but should be implemented by any store that supports
 299  *   persistence
 300  */
 301
 302 typedef struct {
 303     void (*addref)(struct WINE_CRYPTCERTSTORE*);
 304     DWORD (*release)(struct WINE_CRYPTCERTSTORE*,DWORD);
 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 WINECRYPT_CERTSTORE *CRYPT_RootOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags) DECLSPEC_HIDDEN;
 343
 344 /* Allocates and initializes a certificate chain engine, but without creating
 345  * the root store.  Instead, it uses root, and assumes the caller has done any
 346  * checking necessary.
 347  */
 348 HCERTCHAINENGINE CRYPT_CreateChainEngine(HCERTSTORE root,
 349  PCERT_CHAIN_ENGINE_CONFIG pConfig) DECLSPEC_HIDDEN;
 350
 351 /* Helper function for store reading functions and
 352  * CertAddSerializedElementToStore.  Returns a context of the appropriate type
 353  * if it can, or NULL otherwise.  Doesn't validate any of the properties in
 354  * the serialized context (for example, bad hashes are retained.)
 355  * *pdwContentType is set to the type of the returned context.
 356  */
 357 const void *CRYPT_ReadSerializedElement(const BYTE *pbElement,
 358  DWORD cbElement, DWORD dwContextTypeFlags, DWORD *pdwContentType) DECLSPEC_HIDDEN;
 359
 360 /* Reads contexts serialized in the file into the memory store.  Returns FALSE
 361  * if the file is not of the expected format.
 362  */
 363 BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store) DECLSPEC_HIDDEN;
 364
 365 /* Reads contexts serialized in the blob into the memory store.  Returns FALSE
 366  * if the file is not of the expected format.
 367  */
 368 BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob,
 369  HCERTSTORE store) DECLSPEC_HIDDEN;
 370
 371 /* Fixes up the pointers in info, where info is assumed to be a
 372  * CRYPT_KEY_PROV_INFO, followed by its container name, provider name, and any
 373  * provider parameters, in a contiguous buffer, but where info's pointers are
 374  * assumed to be invalid.  Upon return, info's pointers point to the
 375  * appropriate memory locations.
 376  */
 377 void CRYPT_FixKeyProvInfoPointers(PCRYPT_KEY_PROV_INFO info) DECLSPEC_HIDDEN;
 378
 379 /**
 380  *  String functions
 381  */
 382
 383 DWORD cert_name_to_str_with_indent(DWORD dwCertEncodingType, DWORD indent,
 384  const CERT_NAME_BLOB *pName, DWORD dwStrType, LPWSTR psz, DWORD csz) DECLSPEC_HIDDEN;
 385
 386 /**
 387  *  Context functions
 388  */
 389
 390 /* Allocates a new data context, a context which owns properties directly.
 391  * contextSize is the size of the public data type associated with context,
 392  * which should be one of CERT_CONTEXT, CRL_CONTEXT, or CTL_CONTEXT.
 393  * Free with Context_Release.
 394  */
 395 void *Context_CreateDataContext(size_t contextSize, const context_vtbl_t *vtbl) DECLSPEC_HIDDEN;
 396
 397 /* Creates a new link context.  The context refers to linked
 398  * rather than owning its own properties.  If addRef is TRUE (which ordinarily
 399  * it should be) linked is addref'd.
 400  * Free with Context_Release.
 401  */
 402 context_t *Context_CreateLinkContext(unsigned contextSize, context_t *linked) DECLSPEC_HIDDEN;
 403
 404 /* Gets the context linked to by context, which must be a link context. */
 405 void *Context_GetLinkedContext(void*) DECLSPEC_HIDDEN;
 406
 407 /* Copies properties from fromContext to toContext. */
 408 void Context_CopyProperties(const void *to, const void *from) DECLSPEC_HIDDEN;
 409
 410 /* Returns context's properties, or the linked context's properties if context
 411  * is a link context.
 412  */
 413 CONTEXT_PROPERTY_LIST *Context_GetProperties(const void *context) DECLSPEC_HIDDEN;
 414
 415 void Context_AddRef(context_t*) DECLSPEC_HIDDEN;
 416
 417 /* Decrements context's ref count.  If context is a link context, releases its
 418  * linked context as well.
 419  * If a data context has its ref count reach 0, calls dataContextFree on it.
 420  * Returns FALSE if the reference count is <= 0 when called.
 421  */
 422 BOOL Context_Release(context_t *context) DECLSPEC_HIDDEN;
 423
 424 /**
 425  *  Context property list functions
 426  */
 427
 428 CONTEXT_PROPERTY_LIST *ContextPropertyList_Create(void) DECLSPEC_HIDDEN;
 429
 430 /* Searches for the property with ID id in the context.  Returns TRUE if found,
 431  * and copies the property's length and a pointer to its data to blob.
 432  * Otherwise returns FALSE.
 433  */
 434 BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 435  PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN;
 436
 437 BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id,
 438  const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN;
 439
 440 void ContextPropertyList_RemoveProperty(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 441
 442 DWORD ContextPropertyList_EnumPropIDs(CONTEXT_PROPERTY_LIST *list, DWORD id) DECLSPEC_HIDDEN;
 443
 444 void ContextPropertyList_Copy(CONTEXT_PROPERTY_LIST *to,
 445  CONTEXT_PROPERTY_LIST *from) DECLSPEC_HIDDEN;
 446
 447 void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN;
 448
 449 /**
 450  *  Context list functions.  A context list is a simple list of link contexts.
 451  */
 452 struct ContextList;
 453
 454 struct ContextList *ContextList_Create(
 455  const WINE_CONTEXT_INTERFACE *contextInterface, size_t contextSize) DECLSPEC_HIDDEN;
 456
 457 void *ContextList_Add(struct ContextList *list, void *toLink, void *toReplace) DECLSPEC_HIDDEN;
 458
 459 void *ContextList_Enum(struct ContextList *list, void *pPrev) DECLSPEC_HIDDEN;
 460
 461 /* Removes a context from the list.  Returns TRUE if the context was removed,
 462  * or FALSE if not.  (The context may have been duplicated, so subsequent
 463  * removes have no effect.)
 464  */
 465 BOOL ContextList_Remove(struct ContextList *list, context_t *context) DECLSPEC_HIDDEN;
 466
 467 void ContextList_Free(struct ContextList *list) DECLSPEC_HIDDEN;
 468
 469 extern WINECRYPT_CERTSTORE empty_store;
 470 void init_empty_store(void) DECLSPEC_HIDDEN;
 471
 472 /**
 473  *  Utilities.
 474  */
 475
 476 /* Align up to a DWORD_PTR boundary
 477  */
 478 #define ALIGN_DWORD_PTR(x) (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))
 479 #define POINTER_ALIGN_DWORD_PTR(p) ((LPVOID)ALIGN_DWORD_PTR((DWORD_PTR)(p)))
 480
 481 /* Check if the OID is a small int
 482  */
 483 #define IS_INTOID(x)    (((ULONG_PTR)(x) >> 16) == 0)
 484
 485 #endif