xmlsec-shim 1.2.18.1

data/vendor/xmlsec1-1.2.18/src/c14n.c

@@ -0,0 +1,801 @@
+/**
+ * XML Security Library (http://www.aleksey.com/xmlsec).
+ *
+ * Canonicalization transforms.
+ *
+ * This is free software; see Copyright file in the source
+ * distribution for preciese wording.
+ *
+ * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
+ */
+#include "globals.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <libxml/tree.h>
+#include <libxml/c14n.h>
+
+#include <xmlsec/xmlsec.h>
+#include <xmlsec/keys.h>
+#include <xmlsec/list.h>
+#include <xmlsec/transforms.h>
+#include <xmlsec/xmltree.h>
+#include <xmlsec/errors.h>
+
+/******************************************************************************
+ *
+ * C14N transforms
+ *
+ * Inclusive namespaces list for ExclC14N (xmlSecStringList) is located
+ * after xmlSecTransform structure
+ *
+ *****************************************************************************/
+#define xmlSecTransformC14NSize \
+    (sizeof(xmlSecTransform) + sizeof(xmlSecPtrList))
+#define xmlSecTransformC14NGetNsList(transform) \
+    ((xmlSecTransformCheckSize((transform), xmlSecTransformC14NSize)) ? \
+        (xmlSecPtrListPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)) : \
+        (xmlSecPtrListPtr)NULL)
+
+#define xmlSecTransformC14NCheckId(transform) \
+    (xmlSecTransformInclC14NCheckId((transform)) || \
+     xmlSecTransformInclC14N11CheckId((transform)) || \
+     xmlSecTransformExclC14NCheckId((transform)) || \
+     xmlSecTransformCheckId((transform), xmlSecTransformRemoveXmlTagsC14NId))
+#define xmlSecTransformInclC14NCheckId(transform) \
+    (xmlSecTransformCheckId((transform), xmlSecTransformInclC14NId) || \
+     xmlSecTransformCheckId((transform), xmlSecTransformInclC14NWithCommentsId))
+#define xmlSecTransformInclC14N11CheckId(transform) \
+    (xmlSecTransformCheckId((transform), xmlSecTransformInclC14N11Id) || \
+     xmlSecTransformCheckId((transform), xmlSecTransformInclC14N11WithCommentsId))
+#define xmlSecTransformExclC14NCheckId(transform) \
+    (xmlSecTransformCheckId((transform), xmlSecTransformExclC14NId) || \
+     xmlSecTransformCheckId((transform), xmlSecTransformExclC14NWithCommentsId) )
+
+
+static int              xmlSecTransformC14NInitialize   (xmlSecTransformPtr transform);
+static void             xmlSecTransformC14NFinalize     (xmlSecTransformPtr transform);
+static int              xmlSecTransformC14NNodeRead     (xmlSecTransformPtr transform,
+                                                         xmlNodePtr node,
+                                                         xmlSecTransformCtxPtr transformCtx);
+static int              xmlSecTransformC14NPushXml      (xmlSecTransformPtr transform,
+                                                         xmlSecNodeSetPtr nodes,
+                                                         xmlSecTransformCtxPtr transformCtx);
+static int              xmlSecTransformC14NPopBin       (xmlSecTransformPtr transform,
+                                                         xmlSecByte* data,
+                                                         xmlSecSize maxDataSize,
+                                                         xmlSecSize* dataSize,
+                                                         xmlSecTransformCtxPtr transformCtx);
+static int              xmlSecTransformC14NExecute      (xmlSecTransformId id,
+                                                         xmlSecNodeSetPtr nodes,
+                                                         xmlChar** nsList,
+                                                         xmlOutputBufferPtr buf);
+static int
+xmlSecTransformC14NInitialize(xmlSecTransformPtr transform) {
+    xmlSecPtrListPtr nsList;
+    int ret;
+
+    xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
+
+    nsList = xmlSecTransformC14NGetNsList(transform);
+    xmlSecAssert2(nsList != NULL, -1);
+
+    ret = xmlSecPtrListInitialize(nsList, xmlSecStringListId);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                    "xmlSecPtrListInitialize",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+    return(0);
+}
+
+static void
+xmlSecTransformC14NFinalize(xmlSecTransformPtr transform) {
+    xmlSecPtrListPtr nsList;
+
+    xmlSecAssert(xmlSecTransformC14NCheckId(transform));
+
+    nsList = xmlSecTransformC14NGetNsList(transform);
+    xmlSecAssert(xmlSecPtrListCheckId(nsList, xmlSecStringListId));
+
+    xmlSecPtrListFinalize(nsList);
+}
+
+static int
+xmlSecTransformC14NNodeRead(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) {
+    xmlSecPtrListPtr nsList;
+    xmlNodePtr cur;
+    xmlChar *list;
+    xmlChar *p, *n, *tmp;
+    int ret;
+
+    /* we have something to read only for exclusive c14n transforms */
+    xmlSecAssert2(xmlSecTransformExclC14NCheckId(transform), -1);
+    xmlSecAssert2(node != NULL, -1);
+    xmlSecAssert2(transformCtx != NULL, -1);
+
+    nsList = xmlSecTransformC14NGetNsList(transform);
+    xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
+    xmlSecAssert2(xmlSecPtrListGetSize(nsList) == 0, -1);
+
+    /* there is only one optional node */
+    cur = xmlSecGetNextElementNode(node->children);
+    if(cur != NULL) {
+        if(!xmlSecCheckNodeName(cur, xmlSecNodeInclusiveNamespaces, xmlSecNsExcC14N)) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
+                        XMLSEC_ERRORS_R_INVALID_NODE,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+
+        list = xmlGetProp(cur, xmlSecAttrPrefixList);
+        if(list == NULL) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        xmlSecErrorsSafeString(xmlSecAttrPrefixList),
+                        XMLSEC_ERRORS_R_INVALID_NODE_ATTRIBUTE,
+                        "node=%s",
+                        xmlSecErrorsSafeString(xmlSecNodeGetName(cur)));
+            return(-1);
+        }
+
+        /* the list of namespaces is space separated */
+        for(p = n = list; ((p != NULL) && ((*p) != '\0')); p = n) {
+            n = (xmlChar*)xmlStrchr(p, ' ');
+            if(n != NULL) {
+                *(n++) = '\0';
+            }
+
+            tmp = xmlStrdup(p);
+            if(tmp == NULL) {
+                xmlSecError(XMLSEC_ERRORS_HERE,
+                            xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                            NULL,
+                            XMLSEC_ERRORS_R_STRDUP_FAILED,
+                            "len=%d", xmlStrlen(p));
+                xmlFree(list);
+                return(-1);
+            }
+
+            ret = xmlSecPtrListAdd(nsList, tmp);
+            if(ret < 0) {
+                xmlSecError(XMLSEC_ERRORS_HERE,
+                            xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                            "xmlSecPtrListAdd",
+                            XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                            XMLSEC_ERRORS_NO_MESSAGE);
+                xmlFree(tmp);
+                xmlFree(list);
+                return(-1);
+            }
+        }
+        xmlFree(list);
+
+        /* add NULL at the end */
+        ret = xmlSecPtrListAdd(nsList, NULL);
+        if(ret < 0) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecPtrListAdd",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+
+        cur = xmlSecGetNextElementNode(cur->next);
+    }
+
+    /* check that we have nothing else */
+    if(cur != NULL) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    NULL,
+                    xmlSecErrorsSafeString(xmlSecNodeGetName(cur)),
+                    XMLSEC_ERRORS_R_UNEXPECTED_NODE,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+
+    return(0);
+}
+
+static int
+xmlSecTransformC14NPushXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr nodes,
+                            xmlSecTransformCtxPtr transformCtx) {
+    xmlOutputBufferPtr buf;
+    xmlSecPtrListPtr nsList;
+    int ret;
+
+    xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
+    xmlSecAssert2(nodes != NULL, -1);
+    xmlSecAssert2(nodes->doc != NULL, -1);
+    xmlSecAssert2(transformCtx != NULL, -1);
+
+    /* check/update current transform status */
+    switch(transform->status) {
+    case xmlSecTransformStatusNone:
+        transform->status = xmlSecTransformStatusWorking;
+        break;
+    case xmlSecTransformStatusWorking:
+    case xmlSecTransformStatusFinished:
+        return(0);
+    default:
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                    NULL,
+                    XMLSEC_ERRORS_R_INVALID_STATUS,
+                    "status=%d", transform->status);
+        return(-1);
+    }
+    xmlSecAssert2(transform->status == xmlSecTransformStatusWorking, -1);
+
+    /* prepare output buffer: next transform or ourselves */
+    if(transform->next != NULL) {
+        buf = xmlSecTransformCreateOutputBuffer(transform->next, transformCtx);
+        if(buf == NULL) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecTransformCreateOutputBuffer",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+    } else {
+        buf = xmlSecBufferCreateOutputBuffer(&(transform->outBuf));
+        if(buf == NULL) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecBufferCreateOutputBuffer",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+    }
+
+    /* we are using a semi-hack here: we know that xmlSecPtrList keeps
+     * all pointers in the big array */
+    nsList = xmlSecTransformC14NGetNsList(transform);
+    xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
+
+    ret = xmlSecTransformC14NExecute(transform->id, nodes, (xmlChar**)(nsList->data), buf);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                    "xmlSecTransformC14NExecute",
+                    XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        xmlOutputBufferClose(buf);
+        return(-1);
+    }
+
+    ret = xmlOutputBufferClose(buf);
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                    "xmlOutputBufferClose",
+                    XMLSEC_ERRORS_R_XML_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+    transform->status = xmlSecTransformStatusFinished;
+    return(0);
+}
+
+static int
+xmlSecTransformC14NPopBin(xmlSecTransformPtr transform, xmlSecByte* data,
+                            xmlSecSize maxDataSize, xmlSecSize* dataSize,
+                            xmlSecTransformCtxPtr transformCtx) {
+    xmlSecPtrListPtr nsList;
+    xmlSecBufferPtr out;
+    int ret;
+
+    xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
+    xmlSecAssert2(data != NULL, -1);
+    xmlSecAssert2(dataSize != NULL, -1);
+    xmlSecAssert2(transformCtx != NULL, -1);
+
+    out = &(transform->outBuf);
+    if(transform->status == xmlSecTransformStatusNone) {
+        xmlOutputBufferPtr buf;
+
+        xmlSecAssert2(transform->inNodes == NULL, -1);
+
+        /* todo: isn't it an error? */
+        if(transform->prev == NULL) {
+            (*dataSize) = 0;
+            transform->status = xmlSecTransformStatusFinished;
+            return(0);
+        }
+
+        /* get xml data from previous transform */
+        ret = xmlSecTransformPopXml(transform->prev, &(transform->inNodes), transformCtx);
+        if(ret < 0) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecTransformPopXml",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+
+        /* dump everything to internal buffer */
+        buf = xmlSecBufferCreateOutputBuffer(out);
+        if(buf == NULL) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecBufferCreateOutputBuffer",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+
+        /* we are using a semi-hack here: we know that xmlSecPtrList keeps
+         * all pointers in the big array */
+        nsList = xmlSecTransformC14NGetNsList(transform);
+        xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
+
+        ret = xmlSecTransformC14NExecute(transform->id, transform->inNodes, (xmlChar**)(nsList->data), buf);
+        if(ret < 0) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlSecTransformC14NExecute",
+                        XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            xmlOutputBufferClose(buf);
+            return(-1);
+        }
+        ret = xmlOutputBufferClose(buf);
+        if(ret < 0) {
+            xmlSecError(XMLSEC_ERRORS_HERE,
+                        xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                        "xmlOutputBufferClose",
+                        XMLSEC_ERRORS_R_XML_FAILED,
+                        XMLSEC_ERRORS_NO_MESSAGE);
+            return(-1);
+        }
+        transform->status = xmlSecTransformStatusWorking;
+    }
+
+    if(transform->status == xmlSecTransformStatusWorking) {
+        xmlSecSize outSize;
+
+        /* return chunk after chunk */
+        outSize = xmlSecBufferGetSize(out);
+        if(outSize > maxDataSize) {
+            outSize = maxDataSize;
+        }
+        if(outSize > XMLSEC_TRANSFORM_BINARY_CHUNK) {
+            outSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
+        }
+        if(outSize > 0) {
+            xmlSecAssert2(xmlSecBufferGetData(&(transform->outBuf)), -1);
+
+            memcpy(data, xmlSecBufferGetData(&(transform->outBuf)), outSize);
+            ret = xmlSecBufferRemoveHead(&(transform->outBuf), outSize);
+            if(ret < 0) {
+                xmlSecError(XMLSEC_ERRORS_HERE,
+                            xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                            "xmlSecBufferRemoveHead",
+                            XMLSEC_ERRORS_R_XMLSEC_FAILED,
+                            "size=%d", outSize);
+                return(-1);
+            }
+        } else if(xmlSecBufferGetSize(out) == 0) {
+            transform->status = xmlSecTransformStatusFinished;
+        }
+        (*dataSize) = outSize;
+    } else if(transform->status == xmlSecTransformStatusFinished) {
+        /* the only way we can get here is if there is no output */
+        xmlSecAssert2(xmlSecBufferGetSize(out) == 0, -1);
+        (*dataSize) = 0;
+    } else {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
+                    NULL,
+                    XMLSEC_ERRORS_R_INVALID_STATUS,
+                    "status=%d", transform->status);
+        return(-1);
+    }
+
+    return(0);
+}
+
+static int
+xmlSecTransformC14NExecute(xmlSecTransformId id, xmlSecNodeSetPtr nodes, xmlChar** nsList,
+                           xmlOutputBufferPtr buf) {
+    int ret;
+
+    xmlSecAssert2(id != xmlSecTransformIdUnknown, -1);
+    xmlSecAssert2(nodes != NULL, -1);
+    xmlSecAssert2(nodes->doc != NULL, -1);
+    xmlSecAssert2(buf != NULL, -1);
+
+    /* execute c14n transform */
+    if(id == xmlSecTransformInclC14NId) {
+        ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_1_0, NULL, 0, buf);
+    } else if(id == xmlSecTransformInclC14NWithCommentsId) {
+         ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_1_0, NULL, 1, buf);
+    } else if(id == xmlSecTransformInclC14N11Id) {
+        ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_1_1, NULL, 0, buf);
+    } else if(id == xmlSecTransformInclC14N11WithCommentsId) {
+         ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_1_1, NULL, 1, buf);
+    } else if(id == xmlSecTransformExclC14NId) {
+        ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_EXCLUSIVE_1_0, nsList, 0, buf);
+    } else if(id == xmlSecTransformExclC14NWithCommentsId) {
+        ret = xmlC14NExecute(nodes->doc,
+                        (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
+                        nodes, XML_C14N_EXCLUSIVE_1_0, nsList, 1, buf);
+    } else if(id == xmlSecTransformRemoveXmlTagsC14NId) {
+        ret = xmlSecNodeSetDumpTextNodes(nodes, buf);
+    } else {
+        /* shoudn't be possible to come here, actually */
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)),
+                    NULL,
+                    XMLSEC_ERRORS_R_INVALID_TRANSFORM,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+
+    if(ret < 0) {
+        xmlSecError(XMLSEC_ERRORS_HERE,
+                    xmlSecErrorsSafeString(xmlSecTransformKlassGetName(id)),
+                    "xmlC14NExecute",
+                    XMLSEC_ERRORS_R_XML_FAILED,
+                    XMLSEC_ERRORS_NO_MESSAGE);
+        return(-1);
+    }
+
+    return(0);
+}
+
+/***************************************************************************
+ *
+ * C14N
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformInclC14NKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    xmlSecNameC14N,                             /* const xmlChar* name; */
+    xmlSecHrefC14N,                             /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformInclC14NGetKlass:
+ *
+ * Inclusive (regular) canonicalization that omits comments transform klass
+ * (http://www.w3.org/TR/xmldsig-core/#sec-c14nAlg and
+ * http://www.w3.org/TR/2001/REC-xml-c14n-20010315).
+ *
+ * Returns: c14n transform id.
+ */
+xmlSecTransformId
+xmlSecTransformInclC14NGetKlass(void) {
+    return(&xmlSecTransformInclC14NKlass);
+}
+
+/***************************************************************************
+ *
+ * C14N With Comments
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformInclC14NWithCommentsKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    /* same as xmlSecTransformId */
+    xmlSecNameC14NWithComments,                 /* const xmlChar* name; */
+    xmlSecHrefC14NWithComments,                 /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    NULL,                                       /* xmlSecTransformNodeReadMethod read; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformInclC14NWithCommentsGetKlass:
+ *
+ * Inclusive (regular) canonicalization that includes comments transform klass
+ * (http://www.w3.org/TR/xmldsig-core/#sec-c14nAlg and
+ * http://www.w3.org/TR/2001/REC-xml-c14n-20010315).
+ *
+ * Returns: c14n with comments transform id.
+ */
+xmlSecTransformId
+xmlSecTransformInclC14NWithCommentsGetKlass(void) {
+    return(&xmlSecTransformInclC14NWithCommentsKlass);
+}
+
+/***************************************************************************
+ *
+ * C14N v1.1
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformInclC14N11Klass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    xmlSecNameC14N11,                           /* const xmlChar* name; */
+    xmlSecHrefC14N11,                           /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformInclC14N11GetKlass:
+ *
+ * C14N version 1.1 (http://www.w3.org/TR/xml-c14n11)
+ *
+ * Returns: c14n v1.1 transform id.
+ */
+xmlSecTransformId
+xmlSecTransformInclC14N11GetKlass(void) {
+    return(&xmlSecTransformInclC14N11Klass);
+}
+
+/***************************************************************************
+ *
+ * C14N v1.1 With Comments
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformInclC14N11WithCommentsKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    /* same as xmlSecTransformId */
+    xmlSecNameC14N11WithComments,               /* const xmlChar* name; */
+    xmlSecHrefC14N11WithComments,               /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    NULL,                                       /* xmlSecTransformNodeReadMethod read; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformInclC14N11WithCommentsGetKlass:
+ *
+ * C14N version 1.1 (http://www.w3.org/TR/xml-c14n11) with comments
+ *
+ * Returns: c14n v1.1 with comments transform id.
+ */
+xmlSecTransformId
+xmlSecTransformInclC14N11WithCommentsGetKlass(void) {
+    return(&xmlSecTransformInclC14N11WithCommentsKlass);
+}
+
+
+/***************************************************************************
+ *
+ * Excl C14N
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformExclC14NKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    xmlSecNameExcC14N,                          /* const xmlChar* name; */
+    xmlSecHrefExcC14N,                          /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    xmlSecTransformC14NNodeRead,                /* xmlSecTransformNodeReadMethod readNode; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformExclC14NGetKlass:
+ *
+ * Exclusive canoncicalization that ommits comments transform klass
+ * (http://www.w3.org/TR/xml-exc-c14n/).
+ *
+ * Returns: exclusive c14n transform id.
+ */
+xmlSecTransformId
+xmlSecTransformExclC14NGetKlass(void) {
+    return(&xmlSecTransformExclC14NKlass);
+}
+
+/***************************************************************************
+ *
+ * Excl C14N With Comments
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformExclC14NWithCommentsKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    xmlSecNameExcC14NWithComments,              /* const xmlChar* name; */
+    xmlSecHrefExcC14NWithComments,              /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    xmlSecTransformC14NNodeRead,                /* xmlSecTransformNodeReadMethod readNode; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformExclC14NWithCommentsGetKlass:
+ *
+ * Exclusive canoncicalization that includes comments transform klass
+ * (http://www.w3.org/TR/xml-exc-c14n/).
+ *
+ * Returns: exclusive c14n with comments transform id.
+ */
+xmlSecTransformId
+xmlSecTransformExclC14NWithCommentsGetKlass(void) {
+    return(&xmlSecTransformExclC14NWithCommentsKlass);
+}
+
+/***************************************************************************
+ *
+ * Remove XML tags C14N
+ *
+ ***************************************************************************/
+static xmlSecTransformKlass xmlSecTransformRemoveXmlTagsC14NKlass = {
+    /* klass/object sizes */
+    sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
+    xmlSecTransformC14NSize,                    /* xmlSecSize objSize */
+
+    BAD_CAST "remove-xml-tags-transform",       /* const xmlChar* name; */
+    NULL,                                       /* const xmlChar* href; */
+    xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
+                                                /* xmlSecAlgorithmUsage usage; */
+
+    xmlSecTransformC14NInitialize,              /* xmlSecTransformInitializeMethod initialize; */
+    xmlSecTransformC14NFinalize,                /* xmlSecTransformFinalizeMethod finalize; */
+    NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
+    NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
+    NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
+    NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
+    NULL,                                       /* xmlSecTransformValidateMethod validate; */
+    xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
+    NULL,                                       /* xmlSecTransformPushBinMethod pushBin; */
+    xmlSecTransformC14NPopBin,                  /* xmlSecTransformPopBinMethod popBin; */
+    xmlSecTransformC14NPushXml,                 /* xmlSecTransformPushXmlMethod pushXml; */
+    NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
+    NULL,                                       /* xmlSecTransformExecuteMethod execute; */
+
+    NULL,                                       /* void* reserved0; */
+    NULL,                                       /* void* reserved1; */
+};
+
+/**
+ * xmlSecTransformRemoveXmlTagsC14NGetKlass:
+ *
+ * The "remove xml tags" transform klass (http://www.w3.org/TR/xmldsig-core/#sec-Base-64):
+ * Base64 transform requires an octet stream for input. If an XPath node-set
+ * (or sufficiently functional alternative) is given as input, then it is
+ * converted to an octet stream by performing operations logically equivalent
+ * to 1) applying an XPath transform with expression self::text(), then 2)
+ * taking the string-value of the node-set. Thus, if an XML element is
+ * identified by a barename XPointer in the Reference URI, and its content
+ * consists solely of base64 encoded character data, then this transform
+ * automatically strips away the start and end tags of the identified element
+ * and any of its descendant elements as well as any descendant comments and
+ * processing instructions. The output of this transform is an octet stream.
+ *
+ * Returns: "remove xml tags" transform id.
+ */
+xmlSecTransformId
+xmlSecTransformRemoveXmlTagsC14NGetKlass(void) {
+    return(&xmlSecTransformRemoveXmlTagsC14NKlass);
+}
+