xmlsec-shim 1.2.18.1

data/vendor/xmlsec1-1.2.18/include/xmlsec/keys.h

@@ -0,0 +1,278 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * Keys.
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_KEYS_H__
+#define __XMLSEC_KEYS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <time.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/list.h>
+#include <xmlsec/keysdata.h>
+
+
+/**
+ * xmlSecKeyUsage:
+ *
+ * The key usage.
+ */
+typedef unsigned int                    xmlSecKeyUsage;
+
+/**
+ * xmlSecKeyUsageSign:
+ *
+ * Key can be used in any way.
+
+ */
+#define xmlSecKeyUsageSign              0x00000001
+
+/**
+ * xmlSecKeyUsageVerify:
+ *
+ * Key for signing.
+ */
+#define xmlSecKeyUsageVerify            0x00000002
+
+/**
+ * xmlSecKeyUsageEncrypt:
+ *
+ * Key for signature verification.
+ */
+#define xmlSecKeyUsageEncrypt           0x00000004
+
+/**
+ * xmlSecKeyUsageDecrypt:
+ *
+ * An encryption key.
+ */
+#define xmlSecKeyUsageDecrypt           0x00000008
+
+/**
+ * xmlSecKeyUsageKeyExchange:
+ *
+ * The key is used for key exchange.
+ */
+#define xmlSecKeyUsageKeyExchange       0x00000010
+
+/**
+ * xmlSecKeyUsageAny:
+ *
+ * A decryption key.
+ */
+#define xmlSecKeyUsageAny               0xFFFFFFFF
+
+
+/**************************************************************************
+ *
+ * xmlSecKeyUseWith
+ *
+ *************************************************************************/
+typedef struct _xmlSecKeyUseWith                xmlSecKeyUseWith, *xmlSecKeyUseWithPtr;
+XMLSEC_EXPORT int       xmlSecKeyUseWithInitialize              (xmlSecKeyUseWithPtr keyUseWith);
+XMLSEC_EXPORT void      xmlSecKeyUseWithFinalize                (xmlSecKeyUseWithPtr keyUseWith);
+XMLSEC_EXPORT void      xmlSecKeyUseWithReset                   (xmlSecKeyUseWithPtr keyUseWith);
+XMLSEC_EXPORT int       xmlSecKeyUseWithCopy                    (xmlSecKeyUseWithPtr dst,
+                                                                 xmlSecKeyUseWithPtr src);
+XMLSEC_EXPORT xmlSecKeyUseWithPtr xmlSecKeyUseWithCreate        (const xmlChar* application,
+                                                                 const xmlChar* identifier);
+XMLSEC_EXPORT xmlSecKeyUseWithPtr xmlSecKeyUseWithDuplicate     (xmlSecKeyUseWithPtr keyUseWith);
+XMLSEC_EXPORT void      xmlSecKeyUseWithDestroy                 (xmlSecKeyUseWithPtr keyUseWith);
+XMLSEC_EXPORT int       xmlSecKeyUseWithSet                     (xmlSecKeyUseWithPtr keyUseWith,
+                                                                 const xmlChar* application,
+                                                                 const xmlChar* identifier);
+XMLSEC_EXPORT void      xmlSecKeyUseWithDebugDump               (xmlSecKeyUseWithPtr keyUseWith,
+                                                                 FILE* output);
+XMLSEC_EXPORT void      xmlSecKeyUseWithDebugXmlDump            (xmlSecKeyUseWithPtr keyUseWith,
+                                                                 FILE* output);
+
+/**
+ * xmlSecKeyUseWith:
+ * @application:        the application.
+ * @identifier:         the identifier.
+ * @reserved1:          reserved for future use.
+ * @reserved2:          reserved for future use.
+ *
+ * Information about application and user of the key.
+ */
+struct _xmlSecKeyUseWith {
+    xmlChar*                    application;
+    xmlChar*                    identifier;
+
+    void*                       reserved1;
+    void*                       reserved2;
+};
+
+/**
+ * xmlSecKeyUseWithPtrListId:
+ *
+ * The keys list klass.
+ */
+#define xmlSecKeyUseWithPtrListId       xmlSecKeyUseWithPtrListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecKeyUseWithPtrListGetKlass (void);
+
+/**************************************************************************
+ *
+ * xmlSecKeyReq - what key are we looking for?
+ *
+ *************************************************************************/
+typedef struct _xmlSecKeyReq                    xmlSecKeyReq, *xmlSecKeyReqPtr;
+
+/**
+ * xmlSecKeyReq:
+ * @keyId:              the desired key value klass.
+ * @keyType:            the desired key type.
+ * @keyUsage:           the desired key usage.
+ * @keyBitsSize:        the desired key size (in bits!).
+ * @keyUseWithList:     the desired key use with application/identifier information.
+ * @reserved1:          reserved for future use.
+ * @reserved2:          reserved for future use.
+ *
+ * The key requirements information.
+ */
+struct _xmlSecKeyReq {
+    xmlSecKeyDataId             keyId;
+    xmlSecKeyDataType           keyType;
+    xmlSecKeyUsage              keyUsage;
+    xmlSecSize                  keyBitsSize;
+    xmlSecPtrList               keyUseWithList;
+
+    void*                       reserved1;
+    void*                       reserved2;
+};
+
+XMLSEC_EXPORT int       xmlSecKeyReqInitialize                  (xmlSecKeyReqPtr keyReq);
+XMLSEC_EXPORT void      xmlSecKeyReqFinalize                    (xmlSecKeyReqPtr keyReq);
+XMLSEC_EXPORT void      xmlSecKeyReqReset                       (xmlSecKeyReqPtr keyReq);
+XMLSEC_EXPORT int       xmlSecKeyReqCopy                        (xmlSecKeyReqPtr dst,
+                                                                 xmlSecKeyReqPtr src);
+XMLSEC_EXPORT int       xmlSecKeyReqMatchKey                    (xmlSecKeyReqPtr keyReq,
+                                                                 xmlSecKeyPtr key);
+XMLSEC_EXPORT int       xmlSecKeyReqMatchKeyValue               (xmlSecKeyReqPtr keyReq,
+                                                                 xmlSecKeyDataPtr value);
+XMLSEC_EXPORT void      xmlSecKeyReqDebugDump                   (xmlSecKeyReqPtr keyReq,
+                                                                 FILE* output);
+XMLSEC_EXPORT void      xmlSecKeyReqDebugXmlDump                (xmlSecKeyReqPtr keyReq,
+                                                                 FILE* output);
+
+/**
+ * xmlSecKey:
+ * @name:               the key name.
+ * @value:              the key value.
+ * @dataList:           the key data list.
+ * @usage:              the key usage.
+ * @notValidBefore:     the start key validity interval.
+ * @notValidAfter:      the end key validity interval.
+ *
+ * The key.
+ */
+struct _xmlSecKey {
+    xmlChar*                            name;
+    xmlSecKeyDataPtr                    value;
+    xmlSecPtrListPtr                    dataList;
+    xmlSecKeyUsage                      usage;
+    time_t                              notValidBefore;
+    time_t                              notValidAfter;
+};
+
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyCreate         (void);
+XMLSEC_EXPORT void              xmlSecKeyDestroy        (xmlSecKeyPtr key);
+XMLSEC_EXPORT void              xmlSecKeyEmpty          (xmlSecKeyPtr key);
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyDuplicate      (xmlSecKeyPtr key);
+XMLSEC_EXPORT int               xmlSecKeyCopy           (xmlSecKeyPtr keyDst,
+                                                         xmlSecKeyPtr keySrc);
+
+XMLSEC_EXPORT const xmlChar*    xmlSecKeyGetName        (xmlSecKeyPtr key);
+XMLSEC_EXPORT int               xmlSecKeySetName        (xmlSecKeyPtr key,
+                                                         const xmlChar* name);
+
+XMLSEC_EXPORT xmlSecKeyDataType xmlSecKeyGetType        (xmlSecKeyPtr key);
+
+XMLSEC_EXPORT xmlSecKeyDataPtr  xmlSecKeyGetValue       (xmlSecKeyPtr key);
+XMLSEC_EXPORT int               xmlSecKeySetValue       (xmlSecKeyPtr key,
+                                                         xmlSecKeyDataPtr value);
+
+XMLSEC_EXPORT xmlSecKeyDataPtr  xmlSecKeyGetData        (xmlSecKeyPtr key,
+                                                         xmlSecKeyDataId dataId);
+XMLSEC_EXPORT xmlSecKeyDataPtr  xmlSecKeyEnsureData     (xmlSecKeyPtr key,
+                                                         xmlSecKeyDataId dataId);
+XMLSEC_EXPORT int               xmlSecKeyAdoptData      (xmlSecKeyPtr key,
+                                                         xmlSecKeyDataPtr data);
+
+XMLSEC_EXPORT void              xmlSecKeyDebugDump      (xmlSecKeyPtr key,
+                                                         FILE *output);
+XMLSEC_EXPORT void              xmlSecKeyDebugXmlDump   (xmlSecKeyPtr key,
+                                                         FILE *output);
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyGenerate       (xmlSecKeyDataId dataId,
+                                                         xmlSecSize sizeBits,
+                                                         xmlSecKeyDataType type);
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyGenerateByName (const xmlChar* name,
+                                                         xmlSecSize sizeBits,
+                                                         xmlSecKeyDataType type);
+
+
+XMLSEC_EXPORT int               xmlSecKeyMatch          (xmlSecKeyPtr key,
+                                                         const xmlChar *name,
+                                                         xmlSecKeyReqPtr keyReq);
+
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyReadBuffer     (xmlSecKeyDataId dataId,
+                                                         xmlSecBuffer* buffer);
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyReadBinaryFile (xmlSecKeyDataId dataId,
+                                                         const char* filename);
+XMLSEC_EXPORT xmlSecKeyPtr      xmlSecKeyReadMemory     (xmlSecKeyDataId dataId,
+                                                         const xmlSecByte* data,
+                                                         xmlSecSize dataSize);
+
+
+/**
+ * xmlSecKeyIsValid:
+ * @key: the pointer to key.
+ *
+ * Macro. Returns 1 if @key is not NULL and @key->id is not NULL
+ * or 0 otherwise.
+ */
+#define xmlSecKeyIsValid(key) \
+        ((( key ) != NULL) && \
+         (( key )->value != NULL) && \
+         ((( key )->value->id) != NULL))
+/**
+ * xmlSecKeyCheckId:
+ * @key: the pointer to key.
+ * @keyId: the key Id.
+ *
+ * Macro. Returns 1 if @key is valid and @key's id is equal to @keyId.
+ */
+#define xmlSecKeyCheckId(key, keyId) \
+        (xmlSecKeyIsValid(( key )) && \
+        ((( key )->value->id) == ( keyId )))
+
+
+/***********************************************************************
+ *
+ * Keys list
+ *
+ **********************************************************************/
+/**
+ * xmlSecKeyPtrListId:
+ *
+ * The keys list klass.
+ */
+#define xmlSecKeyPtrListId      xmlSecKeyPtrListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecKeyPtrListGetKlass                (void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XMLSEC_KEYS_H__ */
+

data/vendor/xmlsec1-1.2.18/include/xmlsec/keysdata.h

@@ -0,0 +1,837 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * Key data.
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#ifndef __XMLSEC_KEYSDATA_H__
+#define __XMLSEC_KEYSDATA_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <libxml/tree.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/buffer.h>
+#include <xmlsec/list.h>
+
+/****************************************************************************
+ *
+ * Forward declarations
+ *
+ ****************************************************************************/
+typedef const struct _xmlSecKeyDataKlass                xmlSecKeyDataKlass,
+                                                        *xmlSecKeyDataId;
+typedef const struct _xmlSecKeyDataStoreKlass           xmlSecKeyDataStoreKlass,
+                                                        *xmlSecKeyDataStoreId;
+typedef struct _xmlSecKeyDataList                       xmlSecKeyDataList,
+                                                        *xmlSecKeyDataListPtr;
+
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataUsage
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataUsage:
+ *
+ * The bits mask that determines possible keys data usage.
+ */
+typedef unsigned int                                    xmlSecKeyDataUsage;
+
+/**
+ * xmlSecKeyDataUsageUnknown:
+ *
+ * The key data usage is unknown.
+ */
+#define xmlSecKeyDataUsageUnknown                       0x00000
+
+/**
+ * xmlSecKeyDataUsageKeyInfoNodeRead:
+ *
+ * The key data could be read from a <dsig:KeyInfo/> child.
+ */
+#define xmlSecKeyDataUsageKeyInfoNodeRead               0x00001
+
+/**
+ * xmlSecKeyDataUsageKeyInfoNodeWrite:
+ *
+ * The key data could be written to a <dsig:KeyInfo /> child.
+ */
+#define xmlSecKeyDataUsageKeyInfoNodeWrite              0x00002
+
+/**
+ * xmlSecKeyDataUsageKeyValueNodeRead:
+ *
+ * The key data could be read from a <dsig:KeyValue /> child.
+ */
+#define xmlSecKeyDataUsageKeyValueNodeRead              0x00004
+
+/**
+ * xmlSecKeyDataUsageKeyValueNodeWrite:
+ *
+ * The key data could be written to a <dsig:KeyValue /> child.
+ */
+#define xmlSecKeyDataUsageKeyValueNodeWrite             0x00008
+
+/**
+ * xmlSecKeyDataUsageRetrievalMethodNodeXml:
+ *
+ * The key data could be retrieved using <dsig:RetrievalMethod /> node
+ * in XML format.
+ */
+#define xmlSecKeyDataUsageRetrievalMethodNodeXml        0x00010
+
+/**
+ * xmlSecKeyDataUsageRetrievalMethodNodeBin:
+ *
+ * The key data could be retrieved using <dsig:RetrievalMethod /> node
+ * in binary format.
+ */
+#define xmlSecKeyDataUsageRetrievalMethodNodeBin        0x00020
+
+/**
+ * xmlSecKeyDataUsageAny:
+ *
+ * Any key data usage.
+ */
+#define xmlSecKeyDataUsageAny                           0xFFFFF
+
+/**
+ * xmlSecKeyDataUsageKeyInfoNode:
+ *
+ * The key data could be read and written from/to a <dsig:KeyInfo /> child.
+ */
+#define xmlSecKeyDataUsageKeyInfoNode                   \
+        (xmlSecKeyDataUsageKeyInfoNodeRead | xmlSecKeyDataUsageKeyInfoNodeWrite)
+
+/**
+ * xmlSecKeyDataUsageKeyValueNode:
+ *
+ * The key data could be read and written from/to a <dsig:KeyValue /> child.
+ */
+#define xmlSecKeyDataUsageKeyValueNode                  \
+        (xmlSecKeyDataUsageKeyValueNodeRead | xmlSecKeyDataUsageKeyValueNodeWrite)
+
+/**
+ * xmlSecKeyDataUsageRetrievalMethodNode:
+ *
+ * The key data could be retrieved using <dsig:RetrievalMethod /> node
+ * in any format.
+ */
+#define xmlSecKeyDataUsageRetrievalMethodNode           \
+        (xmlSecKeyDataUsageRetrievalMethodNodeXml | xmlSecKeyDataUsageRetrievalMethodNodeBin)
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataType
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataType:
+ *
+ * The key data type (public/private, session/permanet, etc.).
+ */
+typedef unsigned int                            xmlSecKeyDataType;
+
+/**
+ * xmlSecKeyDataTypeUnknown:
+ *
+ * The key data type is unknown (same as #xmlSecKeyDataTypeNone).
+ */
+#define xmlSecKeyDataTypeUnknown                        0x0000
+
+/**
+ * xmlSecKeyDataTypeNone:
+ *
+ * The key data type is unknown (same as #xmlSecKeyDataTypeUnknown).
+ */
+#define xmlSecKeyDataTypeNone                           xmlSecKeyDataTypeUnknown
+
+/**
+ * xmlSecKeyDataTypePublic:
+ *
+ * The key data contain a public key.
+ */
+#define xmlSecKeyDataTypePublic                         0x0001
+
+/**
+ * xmlSecKeyDataTypePrivate:
+ *
+ * The key data contain a private key.
+ */
+#define xmlSecKeyDataTypePrivate                        0x0002
+
+/**
+ * xmlSecKeyDataTypeSymmetric:
+ *
+ * The key data contain a symmetric key.
+ */
+#define xmlSecKeyDataTypeSymmetric                      0x0004
+
+/**
+ * xmlSecKeyDataTypeSession:
+ *
+ * The key data contain session key (one time key, not stored in keys manager).
+ */
+#define xmlSecKeyDataTypeSession                        0x0008
+
+/**
+ * xmlSecKeyDataTypePermanent:
+ *
+ * The key data contain permanent key (stored in keys manager).
+ */
+#define xmlSecKeyDataTypePermanent                      0x0010
+
+/**
+ * xmlSecKeyDataTypeTrusted:
+ *
+ * The key data is trusted.
+ */
+#define xmlSecKeyDataTypeTrusted                        0x0100
+
+/**
+ * xmlSecKeyDataTypeAny:
+ *
+ * Any key data.
+ */
+#define xmlSecKeyDataTypeAny                            0xFFFF
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataFormat
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataFormat:
+ * @xmlSecKeyDataFormatUnknown:         the key data format is unknown.
+ * @xmlSecKeyDataFormatBinary:          the binary key data.
+ * @xmlSecKeyDataFormatPem:             the PEM key data (cert or public/private key).
+ * @xmlSecKeyDataFormatDer:             the DER key data (cert or public/private key).
+ * @xmlSecKeyDataFormatPkcs8Pem:        the PKCS8 PEM private key.
+ * @xmlSecKeyDataFormatPkcs8Der:        the PKCS8 DER private key.
+ * @xmlSecKeyDataFormatPkcs12:          the PKCS12 format (bag of keys and certs)
+ * @xmlSecKeyDataFormatCertPem:         the PEM cert.
+ * @xmlSecKeyDataFormatCertDer:         the DER cert.
+ *
+ * The key data format (binary, der, pem, etc.).
+ */
+typedef enum {
+    xmlSecKeyDataFormatUnknown = 0,
+    xmlSecKeyDataFormatBinary,
+    xmlSecKeyDataFormatPem,
+    xmlSecKeyDataFormatDer,
+    xmlSecKeyDataFormatPkcs8Pem,
+    xmlSecKeyDataFormatPkcs8Der,
+    xmlSecKeyDataFormatPkcs12,
+    xmlSecKeyDataFormatCertPem,
+    xmlSecKeyDataFormatCertDer
+} xmlSecKeyDataFormat;
+
+/**************************************************************************
+ *
+ * Global xmlSecKeyDataIds methods
+ *
+ *************************************************************************/
+XMLSEC_EXPORT xmlSecPtrListPtr  xmlSecKeyDataIdsGet             (void);
+XMLSEC_EXPORT int               xmlSecKeyDataIdsInit            (void);
+XMLSEC_EXPORT void              xmlSecKeyDataIdsShutdown        (void);
+XMLSEC_EXPORT int               xmlSecKeyDataIdsRegisterDefault (void);
+XMLSEC_EXPORT int               xmlSecKeyDataIdsRegister        (xmlSecKeyDataId id);
+
+/**************************************************************************
+ *
+ * xmlSecKeyData
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyData:
+ * @id:                 the data id (#xmlSecKeyDataId).
+ * @reserved0:          reserved for the future.
+ * @reserved1:          reserved for the future.
+ *
+ * The key data: key value (crypto material), x509 data, pgp data, etc.
+ */
+struct _xmlSecKeyData {
+    xmlSecKeyDataId                     id;
+    void*                               reserved0;
+    void*                               reserved1;
+};
+
+XMLSEC_EXPORT xmlSecKeyDataPtr  xmlSecKeyDataCreate             (xmlSecKeyDataId id);
+XMLSEC_EXPORT xmlSecKeyDataPtr  xmlSecKeyDataDuplicate          (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT void              xmlSecKeyDataDestroy            (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT int               xmlSecKeyDataGenerate           (xmlSecKeyDataPtr data,
+                                                                 xmlSecSize sizeBits,
+                                                                 xmlSecKeyDataType type);
+XMLSEC_EXPORT xmlSecKeyDataType xmlSecKeyDataGetType            (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT xmlSecSize        xmlSecKeyDataGetSize            (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT const xmlChar*    xmlSecKeyDataGetIdentifier      (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT void              xmlSecKeyDataDebugDump          (xmlSecKeyDataPtr data,
+                                                                 FILE *output);
+XMLSEC_EXPORT void              xmlSecKeyDataDebugXmlDump       (xmlSecKeyDataPtr data,
+                                                                 FILE *output);
+XMLSEC_EXPORT int               xmlSecKeyDataXmlRead            (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlNodePtr node,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataXmlWrite           (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlNodePtr node,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataBinRead            (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 const xmlSecByte* buf,
+                                                                 xmlSecSize bufSize,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataBinWrite           (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlSecByte** buf,
+                                                                 xmlSecSize* bufSize,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+
+/**
+ * xmlSecKeyDataGetName:
+ * @data:               the pointer to key data.
+ *
+ * Macro. Returns the key data name.
+ */
+#define xmlSecKeyDataGetName(data) \
+        ((xmlSecKeyDataIsValid((data))) ? \
+          xmlSecKeyDataKlassGetName((data)->id) : NULL)
+
+/**
+ * xmlSecKeyDataIsValid:
+ * @data:               the pointer to data.
+ *
+ * Macro. Returns 1 if @data is not NULL and @data->id is not NULL
+ * or 0 otherwise.
+ */
+#define xmlSecKeyDataIsValid(data) \
+        ((( data ) != NULL) && \
+         (( data )->id != NULL) && \
+         (( data )->id->klassSize >= sizeof(xmlSecKeyDataKlass)) && \
+         (( data )->id->objSize >= sizeof(xmlSecKeyData)) && \
+         (( data )->id->name != NULL))
+/**
+ * xmlSecKeyDataCheckId:
+ * @data:               the pointer to data.
+ * @dataId:             the data Id.
+ *
+ * Macro. Returns 1 if @data is valid and @data's id is equal to @dataId.
+ */
+#define xmlSecKeyDataCheckId(data, dataId) \
+        (xmlSecKeyDataIsValid(( data )) && \
+        ((( data )->id) == ( dataId )))
+
+/**
+ * xmlSecKeyDataCheckUsage:
+ * @data:               the pointer to data.
+ * @usg:                the data usage.
+ *
+ * Macro. Returns 1 if @data is valid and could be used for @usg.
+ */
+#define xmlSecKeyDataCheckUsage(data, usg) \
+        (xmlSecKeyDataIsValid(( data )) && \
+        (((( data )->id->usage) & ( usg )) != 0))
+
+/**
+ * xmlSecKeyDataCheckSize:
+ * @data:               the pointer to data.
+ * @size:               the expected size.
+ *
+ * Macro. Returns 1 if @data is valid and @data's object has at least @size bytes.
+ */
+#define xmlSecKeyDataCheckSize(data, size) \
+        (xmlSecKeyDataIsValid(( data )) && \
+         (( data )->id->objSize >= size))
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataKlass
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataIdUnknown:
+ *
+ * The "unknown" id.
+ */
+#define xmlSecKeyDataIdUnknown                  ((xmlSecKeyDataId)NULL)
+
+/**
+ * xmlSecKeyDataInitMethod:
+ * @data:               the pointer to key data.
+ *
+ * Key data specific initialization method.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataInitMethod)      (xmlSecKeyDataPtr data);
+
+/**
+ * xmlSecKeyDataDuplicateMethod:
+ * @dst:                the pointer to destination key data.
+ * @src:                the poiniter to source key data.
+ *
+ * Key data specific duplication (copy) method.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataDuplicateMethod) (xmlSecKeyDataPtr dst,
+                                                                 xmlSecKeyDataPtr src);
+
+/**
+ * xmlSecKeyDataFinalizeMethod:
+ * @data:               the data.
+ *
+ * Key data specific finalization method. All the objects and resources allocated
+ * by the key data object must be freed inside this method.
+ */
+typedef void                    (*xmlSecKeyDataFinalizeMethod)  (xmlSecKeyDataPtr data);
+
+/**
+ * xmlSecKeyDataXmlReadMethod:
+ * @id:                 the data id.
+ * @key:                the key.
+ * @node:               the pointer to data's value XML node.
+ * @keyInfoCtx:         the <dsig:KeyInfo/> node processing context.
+ *
+ * Key data specific method for reading XML node.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataXmlReadMethod)   (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlNodePtr node,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+/**
+ * xmlSecKeyDataXmlWriteMethod:
+ * @id:                 the data id.
+ * @key:                the key.
+ * @node:               the pointer to data's value XML node.
+ * @keyInfoCtx:         the <dsig:KeyInfo> node processing context.
+ *
+ * Key data specific method for writing XML node.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataXmlWriteMethod)  (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlNodePtr node,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+/**
+ * xmlSecKeyDataBinReadMethod:
+ * @id:                 the data id.
+ * @key:                the key.
+ * @buf:                the input buffer.
+ * @bufSize:            the buffer size.
+ * @keyInfoCtx:         the <dsig:KeyInfo/> node processing context.
+ *
+ * Key data specific method for reading binary buffer.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataBinReadMethod)   (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 const xmlSecByte* buf,
+                                                                 xmlSecSize bufSize,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+/**
+ * xmlSecKeyDataBinWriteMethod:
+ * @id:                 the data id.
+ * @key:                the key.
+ * @buf:                the output buffer.
+ * @bufSize:            the buffer size.
+ * @keyInfoCtx:         the <dsig:KeyInfo/> node processing context.
+ *
+ * Key data specific method for reading binary buffer.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataBinWriteMethod)  (xmlSecKeyDataId id,
+                                                                 xmlSecKeyPtr key,
+                                                                 xmlSecByte** buf,
+                                                                 xmlSecSize* bufSize,
+                                                                 xmlSecKeyInfoCtxPtr keyInfoCtx);
+
+/**
+ * xmlSecKeyDataGenerateMethod:
+ * @data:               the pointer to key data.
+ * @sizeBits:           the key data specific size.
+ * @type:               the required key type (session/permanent, etc.)
+ *
+ * Key data specific method for generating new key data.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataGenerateMethod)  (xmlSecKeyDataPtr data,
+                                                                 xmlSecSize sizeBits,
+                                                                 xmlSecKeyDataType type);
+
+/**
+ * xmlSecKeyDataGetTypeMethod:
+ * @data:                the data.
+ *
+ * Key data specific method to get the key type.
+ *
+ * Returns: the key type.
+ */
+typedef xmlSecKeyDataType       (*xmlSecKeyDataGetTypeMethod)   (xmlSecKeyDataPtr data);
+
+/**
+ * xmlSecKeyDataGetSizeMethod:
+ * @data:               the pointer to key data.
+ *
+ * Key data specific method to get the key size.
+ *
+ * Returns: the key size in bits.
+ */
+typedef xmlSecSize              (*xmlSecKeyDataGetSizeMethod)   (xmlSecKeyDataPtr data);
+
+/**
+ * xmlSecKeyDataGetIdentifierMethod:
+ * @data:               the pointer to key data.
+ *
+ * Key data specific method to get the key data identifier string (for example,
+ * X509 data identifier is the subject of the verified cert).
+ *
+ * Returns: the identifier string or NULL if an error occurs.
+ */
+typedef const xmlChar*          (*xmlSecKeyDataGetIdentifierMethod) (xmlSecKeyDataPtr data);
+
+/**
+ * xmlSecKeyDataDebugDumpMethod:
+ * @data:               the data.
+ * @output:             the FILE to print debug info (should be open for writing).
+ *
+ * Key data specific method for printing debug info.
+ */
+typedef void                    (*xmlSecKeyDataDebugDumpMethod) (xmlSecKeyDataPtr data,
+                                                                 FILE* output);
+
+/**
+ * xmlSecKeyDataKlass:
+ * @klassSize:          the klass size.
+ * @objSize:            the object size.
+ * @name:               the object name.
+ * @usage:              the allowed data usage.
+ * @href:               the identification string (href).
+ * @dataNodeName:       the data's XML node name.
+ * @dataNodeNs:         the data's XML node namespace.
+ * @initialize:         the initialization method.
+ * @duplicate:          the duplicate (copy) method.
+ * @finalize:           the finalization (destroy) method.
+ * @generate:           the new data generation method.
+ * @getType:            the method to access data's type information.
+ * @getSize:            the method to access data's size.
+ * @getIdentifier:      the method to access data's string identifier.
+ * @xmlRead:            the method for reading data from XML node.
+ * @xmlWrite:           the method for writing data to XML node.
+ * @binRead:            the method for reading data from a binary buffer.
+ * @binWrite:           the method for writing data to binary buffer.
+ * @debugDump:          the method for printing debug data information.
+ * @debugXmlDump:       the method for printing debug data information in XML format.
+ * @reserved0:          reserved for the future.
+ * @reserved1:          reserved for the future.
+ *
+ * The data id (klass).
+ */
+struct _xmlSecKeyDataKlass {
+    xmlSecSize                          klassSize;
+    xmlSecSize                          objSize;
+
+    /* data */
+    const xmlChar*                      name;
+    xmlSecKeyDataUsage                  usage;
+    const xmlChar*                      href;
+    const xmlChar*                      dataNodeName;
+    const xmlChar*                      dataNodeNs;
+
+    /* constructors/destructor */
+    xmlSecKeyDataInitMethod             initialize;
+    xmlSecKeyDataDuplicateMethod        duplicate;
+    xmlSecKeyDataFinalizeMethod         finalize;
+    xmlSecKeyDataGenerateMethod         generate;
+
+    /* get info */
+    xmlSecKeyDataGetTypeMethod          getType;
+    xmlSecKeyDataGetSizeMethod          getSize;
+    xmlSecKeyDataGetIdentifierMethod    getIdentifier;
+
+    /* read/write */
+    xmlSecKeyDataXmlReadMethod          xmlRead;
+    xmlSecKeyDataXmlWriteMethod         xmlWrite;
+    xmlSecKeyDataBinReadMethod          binRead;
+    xmlSecKeyDataBinWriteMethod         binWrite;
+
+    /* debug */
+    xmlSecKeyDataDebugDumpMethod        debugDump;
+    xmlSecKeyDataDebugDumpMethod        debugXmlDump;
+
+    /* for the future */
+    void*                               reserved0;
+    void*                               reserved1;
+};
+
+/**
+ * xmlSecKeyDataKlassGetName:
+ * @klass:              the data klass.
+ *
+ * Macro. Returns data klass name.
+ */
+#define xmlSecKeyDataKlassGetName(klass) \
+        (((klass)) ? ((klass)->name) : NULL)
+
+/***********************************************************************
+ *
+ * Key Data list
+ *
+ **********************************************************************/
+/**
+ * xmlSecKeyDataListId:
+ *
+ *
+ * The key data klasses list klass id.
+ */
+#define xmlSecKeyDataListId     xmlSecKeyDataListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecKeyDataListGetKlass       (void);
+
+/***********************************************************************
+ *
+ * Key Data Ids list
+ *
+ **********************************************************************/
+/**
+ * xmlSecKeyDataIdListId:
+ *
+ *
+ * The key data list klass id.
+ */
+#define xmlSecKeyDataIdListId   xmlSecKeyDataIdListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecKeyDataIdListGetKlass     (void);
+XMLSEC_EXPORT int               xmlSecKeyDataIdListFind         (xmlSecPtrListPtr list,
+                                                                 xmlSecKeyDataId dataId);
+XMLSEC_EXPORT xmlSecKeyDataId   xmlSecKeyDataIdListFindByNode   (xmlSecPtrListPtr list,
+                                                                 const xmlChar* nodeName,
+                                                                 const xmlChar* nodeNs,
+                                                                 xmlSecKeyDataUsage usage);
+XMLSEC_EXPORT xmlSecKeyDataId   xmlSecKeyDataIdListFindByHref   (xmlSecPtrListPtr list,
+                                                                 const xmlChar* href,
+                                                                 xmlSecKeyDataUsage usage);
+XMLSEC_EXPORT xmlSecKeyDataId   xmlSecKeyDataIdListFindByName   (xmlSecPtrListPtr list,
+                                                                 const xmlChar* name,
+                                                                 xmlSecKeyDataUsage usage);
+XMLSEC_EXPORT void              xmlSecKeyDataIdListDebugDump    (xmlSecPtrListPtr list,
+                                                                 FILE* output);
+XMLSEC_EXPORT void              xmlSecKeyDataIdListDebugXmlDump (xmlSecPtrListPtr list,
+                                                                 FILE* output);
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataBinary
+ *
+ * key (xmlSecBuffer) is located after xmlSecKeyData structure
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataBinarySize:
+ *
+ * The binary key data object size.
+ */
+#define xmlSecKeyDataBinarySize \
+    (sizeof(xmlSecKeyData) + sizeof(xmlSecBuffer))
+
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueInitialize      (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueDuplicate       (xmlSecKeyDataPtr dst,
+                                                                        xmlSecKeyDataPtr src);
+XMLSEC_EXPORT void              xmlSecKeyDataBinaryValueFinalize        (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueXmlRead         (xmlSecKeyDataId id,
+                                                                         xmlSecKeyPtr key,
+                                                                         xmlNodePtr node,
+                                                                         xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueXmlWrite        (xmlSecKeyDataId id,
+                                                                         xmlSecKeyPtr key,
+                                                                         xmlNodePtr node,
+                                                                         xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueBinRead         (xmlSecKeyDataId id,
+                                                                         xmlSecKeyPtr key,
+                                                                         const xmlSecByte* buf,
+                                                                         xmlSecSize bufSize,
+                                                                         xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueBinWrite        (xmlSecKeyDataId id,
+                                                                         xmlSecKeyPtr key,
+                                                                         xmlSecByte** buf,
+                                                                         xmlSecSize* bufSize,
+                                                                         xmlSecKeyInfoCtxPtr keyInfoCtx);
+XMLSEC_EXPORT void              xmlSecKeyDataBinaryValueDebugDump       (xmlSecKeyDataPtr data,
+                                                                        FILE* output);
+XMLSEC_EXPORT void              xmlSecKeyDataBinaryValueDebugXmlDump    (xmlSecKeyDataPtr data,
+                                                                         FILE* output);
+
+XMLSEC_EXPORT xmlSecSize        xmlSecKeyDataBinaryValueGetSize         (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT xmlSecBufferPtr   xmlSecKeyDataBinaryValueGetBuffer       (xmlSecKeyDataPtr data);
+XMLSEC_EXPORT int               xmlSecKeyDataBinaryValueSetBuffer       (xmlSecKeyDataPtr data,
+                                                                         const xmlSecByte* buf,
+                                                                         xmlSecSize bufSize);
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataStore
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataStore:
+ * @id:                 the store id (#xmlSecKeyDataStoreId).
+ * @reserved0:          reserved for the future.
+ * @reserved1:          reserved for the future.
+ *
+ * The key data store. Key data store holds common key data specific information
+ * required for key data processing. For example, X509 data store may hold
+ * information about trusted (root) certificates.
+ */
+struct _xmlSecKeyDataStore {
+    xmlSecKeyDataStoreId                id;
+
+    /* for the future */
+    void*                               reserved0;
+    void*                               reserved1;
+};
+
+XMLSEC_EXPORT xmlSecKeyDataStorePtr xmlSecKeyDataStoreCreate    (xmlSecKeyDataStoreId id);
+XMLSEC_EXPORT void              xmlSecKeyDataStoreDestroy       (xmlSecKeyDataStorePtr store);
+
+/**
+ * xmlSecKeyDataStoreGetName:
+ * @store:              the pointer to store.
+ *
+ * Macro. Returns key data store name.
+ */
+#define xmlSecKeyDataStoreGetName(store) \
+    ((xmlSecKeyDataStoreIsValid((store))) ? \
+      xmlSecKeyDataStoreKlassGetName((store)->id) : NULL)
+
+/**
+ * xmlSecKeyDataStoreIsValid:
+ * @store:              the pointer to store.
+ *
+ * Macro. Returns 1 if @store is not NULL and @store->id is not NULL
+ * or 0 otherwise.
+ */
+#define xmlSecKeyDataStoreIsValid(store) \
+        ((( store ) != NULL) && ((( store )->id) != NULL))
+/**
+ * xmlSecKeyDataStoreCheckId:
+ * @store:              the pointer to store.
+ * @storeId:            the store Id.
+ *
+ * Macro. Returns 1 if @store is valid and @store's id is equal to @storeId.
+ */
+#define xmlSecKeyDataStoreCheckId(store, storeId) \
+        (xmlSecKeyDataStoreIsValid(( store )) && \
+        ((( store )->id) == ( storeId )))
+
+/**
+ * xmlSecKeyDataStoreCheckSize:
+ * @store:              the pointer to store.
+ * @size:               the expected size.
+ *
+ * Macro. Returns 1 if @data is valid and @stores's object has at least @size bytes.
+ */
+#define xmlSecKeyDataStoreCheckSize(store, size) \
+        (xmlSecKeyDataStoreIsValid(( store )) && \
+         (( store )->id->objSize >= size))
+
+
+/**************************************************************************
+ *
+ * xmlSecKeyDataStoreKlass
+ *
+ *************************************************************************/
+/**
+ * xmlSecKeyDataStoreIdUnknown:
+ *
+ * The "unknown" id.
+ */
+#define xmlSecKeyDataStoreIdUnknown                     NULL
+
+/**
+ * xmlSecKeyDataStoreInitializeMethod:
+ * @store:              the data store.
+ *
+ * Key data store specific initialization method.
+ *
+ * Returns: 0 on success or a negative value if an error occurs.
+ */
+typedef int                     (*xmlSecKeyDataStoreInitializeMethod)   (xmlSecKeyDataStorePtr store);
+
+/**
+ * xmlSecKeyDataStoreFinalizeMethod:
+ * @store:              the data store.
+ *
+ * Key data store specific finalization (destroy) method.
+ */
+typedef void                    (*xmlSecKeyDataStoreFinalizeMethod)     (xmlSecKeyDataStorePtr store);
+
+/**
+ * xmlSecKeyDataStoreKlass:
+ * @klassSize:          the data store klass size.
+ * @objSize:            the data store obj size.
+ * @name:               the store's name.
+ * @initialize:         the store's initialization method.
+ * @finalize:           the store's finalization (destroy) method.
+ * @reserved0:          reserved for the future.
+ * @reserved1:          reserved for the future.
+ *
+ * The data store id (klass).
+ */
+struct _xmlSecKeyDataStoreKlass {
+    xmlSecSize                          klassSize;
+    xmlSecSize                          objSize;
+
+    /* data */
+    const xmlChar*                      name;
+
+    /* constructors/destructor */
+    xmlSecKeyDataStoreInitializeMethod  initialize;
+    xmlSecKeyDataStoreFinalizeMethod    finalize;
+
+    /* for the future */
+    void*                               reserved0;
+    void*                               reserved1;
+};
+
+/**
+ * xmlSecKeyDataStoreKlassGetName:
+ * @klass:              the pointer to store klass.
+ *
+ * Macro. Returns store klass name.
+ */
+#define xmlSecKeyDataStoreKlassGetName(klass) \
+        (((klass)) ? ((klass)->name) : NULL)
+
+/***********************************************************************
+ *
+ * Key Data Store list
+ *
+ **********************************************************************/
+/**
+ * xmlSecKeyDataStorePtrListId:
+ *
+ * The data store list id (klass).
+ */
+#define xmlSecKeyDataStorePtrListId     xmlSecKeyDataStorePtrListGetKlass()
+XMLSEC_EXPORT xmlSecPtrListId   xmlSecKeyDataStorePtrListGetKlass       (void);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __XMLSEC_KEYSDATA_H__ */