/** * 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-2016 Aleksey Sanin . All Rights Reserved. */ #include "globals.h" #include #include #include #include #include #include #include #include #include #include #include /****************************************************************************** * * 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); }