diff options
Diffstat (limited to 'src/c14n.c')
| -rw-r--r-- | src/c14n.c | 801 |
1 files changed, 801 insertions, 0 deletions
diff --git a/src/c14n.c b/src/c14n.c new file mode 100644 index 00000000..5967a35e --- /dev/null +++ b/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); +} + |