1 /** 

     2  * XML Security Library (http://www.aleksey.com/xmlsec).

     3  *

     4  * Creating signature and encryption templates.

     5  *

     6  * This is free software; see Copyright file in the source

     7  * distribution for preciese wording.

     8  * 

     9  * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>

    10  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

    11  */

    12 #include "xmlsec_globals.h"

    13 

    14 #include <stdlib.h>

    15 #include <string.h>

    16  

    17 #include <libxml2_tree.h>

    18 #include <libxml2_globals.h>

    19 

    20 #include "xmlsec_xmlsec.h"

    21 #include "xmlsec_xmltree.h"

    22 #include "xmlsec_transforms.h"

    23 #include "xmlsec_strings.h"

    24 #include "xmlsec_base64.h"

    25 #include "xmlsec_templates.h"

    26 #include "xmlsec_errors.h"

    27 

    28 //added for symbian port

    29 #include <libxml2_parser.h>

    30 

    31 static int useNewLine = 1;

    32 

    33 static unsigned char* dsPref = NULL;

    34 

    35 static xmlNodePtr 	xmlSecTmplAddReference		(xmlNodePtr parentNode, 

    36 							 xmlSecTransformId digestMethodId,

    37 							 const xmlChar *id, 

    38 							 const xmlChar *uri, 

    39 							 const xmlChar *type);

    40 static int	 	xmlSecTmplPrepareEncData	(xmlNodePtr parentNode, 

    41 							 xmlSecTransformId encMethodId);

    42 static int 		xmlSecTmplNodeWriteNsList	(xmlNodePtr parentNode, 

    43 							 const xmlChar** namespaces);

    44 EXPORT_C

    45 							 

    46 							 

    47 void xmlSetNewLineFlag(int aNewLine)

    48     {

    49     useNewLine = aNewLine;

    50     }

    51 

    52 int xmlGetNewLineFlag()

    53     {

    54     return useNewLine;

    55     }

    56 EXPORT_C

    57 

    58 void xmlSetPrefix(unsigned char* aPref)

    59     {

    60     dsPref = aPref;

    61     }

    62 

    63 unsigned char* xmlGetPrefix()

    64     {

    65     return dsPref;

    66     }

    67 

    68 /**************************************************************************

    69  *

    70  * <dsig:Signature/> node

    71  *

    72  **************************************************************************/

    73 /**

    74  * xmlSecTmplSignatureCreate:

    75  * @doc: 		the pointer to signature document or NULL; in the 

    76  *			second case, application must later call @xmlSetTreeDoc

    77  *			to ensure that all the children nodes have correct 

    78  *			pointer to XML document.

    79  * @c14nMethodId: 	the signature canonicalization method.

    80  * @signMethodId: 	the signature  method.

    81  * @id: 		the node id (may be NULL).

    82  *

    83  * Creates new <dsig:Signature/> node with the mandatory <dsig:SignedInfo/>, 

    84  * <dsig:CanonicalizationMethod/>, <dsig:SignatureMethod/> and 

    85  * <dsig:SignatureValue/> children and sub-children. 

    86  * The application is responsible for inserting the returned node

    87  * in the XML document. 

    88  *

    89  * Returns the pointer to newly created <dsig:Signature/> node or NULL if an 

    90  * error occurs.

    91  */

    92 EXPORT_C

    93 xmlNodePtr

    94 xmlSecTmplSignatureCreate(xmlDocPtr doc, xmlSecTransformId c14nMethodId,

    95 		      xmlSecTransformId signMethodId, const xmlChar *id) {

    96     xmlNodePtr signNode;

    97     xmlNodePtr signedInfoNode;

    98     xmlNodePtr cur;

    99     xmlNsPtr ns;

   100     

   101     xmlSecAssert2(c14nMethodId != NULL, NULL);

   102     xmlSecAssert2(c14nMethodId->href != NULL, NULL);

   103     xmlSecAssert2(signMethodId != NULL, NULL);

   104     xmlSecAssert2(signMethodId->href != NULL, NULL);

   105     

   106     /* create Signature node itself */

   107     signNode = xmlNewDocNode(doc, NULL, xmlSecNodeSignature, NULL);

   108     if(signNode == NULL) {

   109 	xmlSecError(XMLSEC_ERRORS_HERE,

   110 		    NULL,

   111 		    "xmlNewDocNode",

   112 		    XMLSEC_ERRORS_R_XML_FAILED,

   113 		    "node=%s",

   114 		    xmlSecErrorsSafeString(xmlSecNodeSignature));

   115 	return(NULL);	            

   116     }

   117     

   118     ns = xmlNewNs(signNode, xmlSecDSigNs, dsPref);

   119     if(ns == NULL) {

   120 	xmlSecError(XMLSEC_ERRORS_HERE,

   121 		    NULL,

   122 		    "xmlNewNs",

   123 		    XMLSEC_ERRORS_R_XML_FAILED,

   124 		    "ns=%s",

   125 		    xmlSecErrorsSafeString(xmlSecDSigNs));

   126 	xmlFreeNode(signNode);

   127 	return(NULL);	        	

   128     }

   129     xmlSetNs(signNode, ns);

   130     

   131     if(id != NULL) {

   132 	    xmlAttrPtr ptr = xmlSetProp(signNode, BAD_CAST "Id", id);

   133 	    if ( !ptr && OOM_FLAG ) 

   134 	        {

   135 	        xmlFreeNode(signNode);

   136 	        return(NULL);

   137 	        }

   138     }

   139 

   140     /* add SignedInfo node */    

   141     signedInfoNode = xmlSecAddChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

   142     if(signedInfoNode == NULL) {

   143 	xmlSecError(XMLSEC_ERRORS_HERE,

   144 		    NULL,

   145 		    "xmlSecAddChild",

   146 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   147 		    "node=%s",

   148 		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo));

   149 	xmlFreeNode(signNode);

   150 	return(NULL);	        	

   151     }

   152 

   153     /* add SignatureValue node */    

   154     cur = xmlSecAddChild(signNode, xmlSecNodeSignatureValue, xmlSecDSigNs);

   155     if(cur == NULL) {

   156 	xmlSecError(XMLSEC_ERRORS_HERE,

   157 		    NULL,

   158 		    "xmlSecAddChild",

   159 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   160 		    "node=%s",

   161 		    xmlSecErrorsSafeString(xmlSecNodeSignatureValue));

   162 	xmlFreeNode(signNode);

   163 	return(NULL);	        	

   164     }

   165 

   166     /* add CanonicaizationMethod node to SignedInfo */

   167     cur = xmlSecAddChild(signedInfoNode, xmlSecNodeCanonicalizationMethod, xmlSecDSigNs);

   168     if(cur == NULL) {

   169 	xmlSecError(XMLSEC_ERRORS_HERE,

   170 		    NULL,

   171 		    "xmlSecAddChild",

   172 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   173 		    "node=%s",

   174 		    xmlSecErrorsSafeString(xmlSecNodeCanonicalizationMethod));

   175 	xmlFreeNode(signNode);

   176 	return(NULL);	        	

   177     }

   178     if(xmlSetNsProp(cur, ns, xmlSecAttrAlgorithm, c14nMethodId->href) == NULL) {

   179 	xmlSecError(XMLSEC_ERRORS_HERE,

   180 		    NULL,

   181 		    "xmlSetProp",

   182 		    XMLSEC_ERRORS_R_XML_FAILED,

   183 		    "name=%s,value=%s",

   184 		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

   185 		    xmlSecErrorsSafeString(c14nMethodId->href));

   186 	xmlFreeNode(signNode);

   187 	return(NULL);	        	

   188     }

   189 

   190     /* add SignatureMethod node to SignedInfo */

   191     cur = xmlSecAddChild(signedInfoNode, xmlSecNodeSignatureMethod, xmlSecDSigNs);

   192     if(cur == NULL) {

   193 	xmlSecError(XMLSEC_ERRORS_HERE,

   194 		    NULL,

   195 		    "xmlSecAddChild",

   196 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   197 		    "node=%s",

   198 		    xmlSecErrorsSafeString(xmlSecNodeSignatureMethod));

   199 	xmlFreeNode(signNode);

   200 	return(NULL);	        	

   201     }

   202     if(xmlSetNsProp(cur, ns, xmlSecAttrAlgorithm, signMethodId->href) == NULL) {

   203 	xmlSecError(XMLSEC_ERRORS_HERE,

   204 		    NULL,

   205 		    "xmlSetProp",

   206 		    XMLSEC_ERRORS_R_XML_FAILED,

   207 		    "name=%s,value=%s",

   208 		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

   209 		    xmlSecErrorsSafeString(signMethodId->href));

   210 	xmlFreeNode(signNode);

   211 	return(NULL);	        	

   212     }

   213         

   214     return(signNode);

   215 }

   216 

   217 /**

   218  * xmlSecTmplSignatureEnsureKeyInfo:

   219  * @signNode: 		the  pointer to <dsig:Signature/> node.

   220  * @id: 		the node id (may be NULL).

   221  *

   222  * Adds (if necessary) <dsig:KeyInfo/> node to the <dsig:Signature/> 

   223  * node @signNode. 

   224  *

   225  * Returns the pointer to newly created <dsig:KeyInfo/> node or NULL if an 

   226  * error occurs.

   227  */

   228 EXPORT_C

   229 xmlNodePtr

   230 xmlSecTmplSignatureEnsureKeyInfo(xmlNodePtr signNode, const xmlChar *id) {

   231     xmlNodePtr res;

   232     int created = 0;

   233     

   234     xmlSecAssert2(signNode != NULL, NULL);

   235 

   236     res = xmlSecFindChild(signNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

   237     if(res == NULL) {

   238 	xmlNodePtr signValueNode;

   239     

   240         signValueNode = xmlSecFindChild(signNode, xmlSecNodeSignatureValue, xmlSecDSigNs);

   241 	if(signValueNode == NULL) {

   242 	    xmlSecError(XMLSEC_ERRORS_HERE,

   243 		        NULL,

   244 			xmlSecErrorsSafeString(xmlSecNodeSignatureValue),

   245 		        XMLSEC_ERRORS_R_NODE_NOT_FOUND,

   246 			XMLSEC_ERRORS_NO_MESSAGE);

   247 	    return(NULL);	

   248 	}

   249 

   250 	res = xmlSecAddNextSibling(signValueNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

   251 	if(res == NULL) {

   252 	    xmlSecError(XMLSEC_ERRORS_HERE,

   253 		        NULL,

   254 			"xmlSecAddNextSibling",

   255 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   256 			"node=%s",

   257 			xmlSecErrorsSafeString(xmlSecNodeKeyInfo));

   258 	    return(NULL);	        	

   259 	}

   260 	created = 1;

   261     }

   262     if(id != NULL) {

   263 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   264         if (!ptr && OOM_FLAG) 

   265             {

   266             if (created) 

   267                 {

   268                 xmlUnlinkNode(res);

   269     	        xmlFreeNode(res);

   270                 }

   271             return(NULL);

   272             }

   273     }

   274     return(res);        

   275 }         

   276 

   277 /**

   278  * xmlSecTmplSignatureAddReference:

   279  * @signNode: 		the pointer to <dsig:Signature/> node.

   280  * @digestMethodId:	the reference digest method.

   281  * @id: 		the node id (may be NULL).

   282  * @uri: 		the reference node uri (may be NULL).

   283  * @type: 		the reference node type (may be NULL).

   284  *

   285  * Adds <dsig:Reference/> node with given URI (@uri), Id (@id) and 

   286  * Type (@type) attributes and the required children <dsig:DigestMethod/> and

   287  * <dsig:DigestValue/> to the <dsig:SignedInfo/> child of @signNode. 

   288  *

   289  * Returns the pointer to newly created <dsig:Reference/> node or NULL 

   290  * if an error occurs.

   291  */

   292 EXPORT_C

   293 xmlNodePtr	

   294 xmlSecTmplSignatureAddReference(xmlNodePtr signNode, xmlSecTransformId digestMethodId,

   295 		    const xmlChar *id, const xmlChar *uri, const xmlChar *type) {

   296     xmlNodePtr signedInfoNode;

   297     

   298     xmlSecAssert2(signNode != NULL, NULL);

   299     xmlSecAssert2(digestMethodId != NULL, NULL);

   300     xmlSecAssert2(digestMethodId->href != NULL, NULL);

   301 

   302     signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

   303     if(signedInfoNode == NULL) {

   304 	xmlSecError(XMLSEC_ERRORS_HERE,

   305 		    NULL,

   306 		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

   307 		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

   308 		    XMLSEC_ERRORS_NO_MESSAGE);

   309 	return(NULL);	

   310     }

   311     

   312     return(xmlSecTmplAddReference(signedInfoNode, digestMethodId, id, uri, type));

   313 }

   314 

   315 static xmlNodePtr 

   316 xmlSecTmplAddReference(xmlNodePtr parentNode, xmlSecTransformId digestMethodId,

   317 		    const xmlChar *id, const xmlChar *uri, const xmlChar *type) {    

   318     xmlNodePtr res;

   319     xmlNodePtr cur;

   320     int error = 0;

   321     

   322     xmlSecAssert2(parentNode != NULL, NULL);

   323     xmlSecAssert2(digestMethodId != NULL, NULL);

   324     xmlSecAssert2(digestMethodId->href != NULL, NULL);

   325 

   326     /* add Reference node */

   327     res = xmlSecAddChild(parentNode, xmlSecNodeReference, xmlSecDSigNs);

   328     if(res == NULL) {

   329 	xmlSecError(XMLSEC_ERRORS_HERE,

   330 		    NULL,

   331 		    "xmlSecAddChild",

   332 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   333 		    "node=%s",

   334 		    xmlSecErrorsSafeString(xmlSecNodeReference));

   335 	return(NULL);

   336     }

   337 

   338     /* set Reference node attributes */

   339     if(id != NULL) {

   340 	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrId, id);

   341     error = error || !ptr;

   342     }

   343     if(type != NULL) {

   344 	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrType, type);

   345     error = error || !ptr;

   346     }

   347     if(uri != NULL) {

   348 	xmlAttrPtr ptr = xmlSetNsProp(res, res->ns, xmlSecAttrURI, uri);

   349     error = error || !ptr;

   350     }

   351     if (error && OOM_FLAG) 

   352         {

   353  	    xmlUnlinkNode(res);

   354 	    xmlFreeNode(res); 

   355 	    return(NULL);      

   356         }

   357 

   358     /* add DigestMethod node and set algorithm */    

   359     cur = xmlSecAddChild(res, xmlSecNodeDigestMethod, xmlSecDSigNs);

   360     if(cur == NULL) {

   361 	xmlSecError(XMLSEC_ERRORS_HERE,

   362 		    NULL,

   363 		    "xmlSecAddChild",

   364 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   365 		    "node=%s",

   366 		    xmlSecErrorsSafeString(xmlSecNodeDigestMethod));

   367 	xmlUnlinkNode(res);

   368 	xmlFreeNode(res);

   369 	return(NULL);	        	

   370     }

   371     if(xmlSetNsProp(cur, cur->ns, xmlSecAttrAlgorithm, digestMethodId->href) == NULL) {

   372 	xmlSecError(XMLSEC_ERRORS_HERE,

   373 		    NULL,

   374 		    "xmlSetProp",

   375 		    XMLSEC_ERRORS_R_XML_FAILED,

   376 		    "name=%s,value=%s",

   377 		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

   378 		    xmlSecErrorsSafeString(digestMethodId->href));

   379 	xmlUnlinkNode(res);

   380 	xmlFreeNode(res);

   381 	return(NULL);	        	

   382     }

   383 

   384     /* add DigestValue node */    

   385     cur = xmlSecAddChild(res, xmlSecNodeDigestValue, xmlSecDSigNs);

   386     if(cur == NULL) {

   387 	xmlSecError(XMLSEC_ERRORS_HERE,

   388 		    NULL,

   389 		    "xmlSecAddChild",

   390 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   391 		    "node=%s",

   392 		    xmlSecErrorsSafeString(xmlSecNodeDigestValue));

   393 	xmlUnlinkNode(res);

   394 	xmlFreeNode(res);

   395 	return(NULL);	        	

   396     }

   397     

   398     return(res);    

   399 }

   400 

   401 /**

   402  * xmlSecTmplSignatureAddObject:

   403  * @signNode: 		the pointer to <dsig:Signature/> node.

   404  * @id: 		the node id (may be NULL).

   405  * @mimeType: 		the object mime type (may be NULL).

   406  * @encoding: 		the object encoding (may be NULL).

   407  *

   408  * Adds <dsig:Object/> node to the <dsig:Signature/> node @signNode. 

   409  *

   410  * Returns the pointer to newly created <dsig:Object/> node or NULL 

   411  * if an error occurs.

   412  */

   413 EXPORT_C

   414 xmlNodePtr

   415 xmlSecTmplSignatureAddObject(xmlNodePtr signNode, const xmlChar *id, 

   416 			 const xmlChar *mimeType, const xmlChar *encoding) {

   417     xmlNodePtr res;

   418     int error = 0;

   419 

   420     xmlSecAssert2(signNode != NULL, NULL);

   421     

   422     res = xmlSecAddChild(signNode, xmlSecNodeObject, xmlSecDSigNs);

   423     if(res == NULL) {

   424 	xmlSecError(XMLSEC_ERRORS_HERE,

   425 		    NULL,

   426 		    "xmlSecAddChild",

   427 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   428 		    "node=%s",

   429 		    xmlSecErrorsSafeString(xmlSecNodeObject));

   430 	return(NULL);	        	

   431     }

   432     if(id != NULL) {

   433 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   434     error = error || !ptr;

   435     }

   436     if(mimeType != NULL) {

   437 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrMimeType, mimeType);

   438     error = error || !ptr;

   439     }

   440     if(encoding != NULL) {

   441 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrEncoding, encoding);

   442     error = error || !ptr;

   443     }

   444     if (error && OOM_FLAG) 

   445         {

   446         xmlUnlinkNode(res);

   447 	    xmlFreeNode(res);

   448 	    return(NULL);

   449         }

   450     

   451     return(res);        

   452 }

   453 

   454 /** 

   455  * xmlSecTmplSignatureGetSignMethodNode:

   456  * @signNode:		the pointer to <dsig:Signature /> node.

   457  *

   458  * Gets pointer to <dsig:SignatureMethod/> child of <dsig:KeyInfo/> node.

   459  *

   460  * Returns pointer to <dsig:SignatureMethod /> node or NULL if an error occurs.

   461  */

   462 EXPORT_C

   463 xmlNodePtr 

   464 xmlSecTmplSignatureGetSignMethodNode(xmlNodePtr signNode) {

   465     xmlNodePtr signedInfoNode;

   466     

   467     xmlSecAssert2(signNode != NULL, NULL);

   468     

   469     signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

   470     if(signedInfoNode == NULL) {

   471 	xmlSecError(XMLSEC_ERRORS_HERE,

   472 		    NULL,

   473 		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

   474 		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

   475 		    XMLSEC_ERRORS_NO_MESSAGE);

   476 	return(NULL);	

   477     }

   478     return(xmlSecFindChild(signedInfoNode, xmlSecNodeSignatureMethod, xmlSecDSigNs));

   479 }

   480 

   481 /** 

   482  * xmlSecTmplSignatureGetC14NMethodNode:

   483  * @signNode:		the pointer to <dsig:Signature /> node.

   484  *

   485  * Gets pointer to <dsig:CanonicalizationMethod/> child of <dsig:KeyInfo/> node.

   486  *

   487  * Returns pointer to <dsig:CanonicalizationMethod /> node or NULL if an error occurs.

   488  */

   489 EXPORT_C

   490 xmlNodePtr 

   491 xmlSecTmplSignatureGetC14NMethodNode(xmlNodePtr signNode) {

   492     xmlNodePtr signedInfoNode;

   493     

   494     xmlSecAssert2(signNode != NULL, NULL);

   495     

   496     signedInfoNode = xmlSecFindChild(signNode, xmlSecNodeSignedInfo, xmlSecDSigNs);

   497     if(signedInfoNode == NULL) {

   498 	xmlSecError(XMLSEC_ERRORS_HERE,

   499 		    NULL,

   500 		    xmlSecErrorsSafeString(xmlSecNodeSignedInfo),

   501 		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

   502 		    XMLSEC_ERRORS_NO_MESSAGE);

   503 	return(NULL);	

   504     }

   505     return(xmlSecFindChild(signedInfoNode, xmlSecNodeCanonicalizationMethod, xmlSecDSigNs));

   506 }

   507 

   508 /**

   509  * xmlSecTmplReferenceAddTransform:

   510  * @referenceNode: 		the pointer to <dsig:Reference/> node.

   511  * @transformId: 		the transform method id.

   512  *

   513  * Adds <dsig:Transform/> node to the <dsig:Reference/> node @referenceNode.

   514  * 

   515  * Returns the pointer to newly created <dsig:Transform/> node or NULL if an 

   516  * error occurs.

   517  */

   518 EXPORT_C

   519 xmlNodePtr

   520 xmlSecTmplReferenceAddTransform(xmlNodePtr referenceNode, xmlSecTransformId transformId) {

   521     xmlNodePtr transformsNode;

   522     xmlNodePtr res;

   523     

   524     xmlSecAssert2(referenceNode != NULL, NULL);

   525     xmlSecAssert2(transformId != NULL, NULL);

   526     xmlSecAssert2(transformId->href != NULL, NULL);

   527 

   528     /* do we need to create Transforms node first */

   529     transformsNode = xmlSecFindChild(referenceNode, xmlSecNodeTransforms, xmlSecDSigNs);

   530     if(transformsNode == NULL) {

   531 	xmlNodePtr tmp;

   532 	

   533 	tmp = xmlSecGetNextElementNode(referenceNode->children);

   534 	if(tmp == NULL) {

   535 	    transformsNode = xmlSecAddChild(referenceNode, xmlSecNodeTransforms, xmlSecDSigNs);

   536 	} else {

   537 	    transformsNode = xmlSecAddPrevSibling(tmp, xmlSecNodeTransforms, xmlSecDSigNs);

   538 	}   

   539 	if(transformsNode == NULL) {

   540 	    xmlSecError(XMLSEC_ERRORS_HERE,

   541 			NULL,

   542 			"xmlSecAddChild or xmlSecAddPrevSibling",

   543 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   544 			"node=%s",

   545 			xmlSecErrorsSafeString(xmlSecNodeTransforms));

   546 	    return(NULL);	        	

   547 	}

   548     }

   549 

   550     res = xmlSecAddChild(transformsNode, xmlSecNodeTransform, xmlSecDSigNs);

   551     if(res == NULL) {

   552 	xmlSecError(XMLSEC_ERRORS_HERE,

   553 		    NULL,

   554 		    "xmlSecAddChild",

   555 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   556 		    "node=%s",

   557 		    xmlSecErrorsSafeString(xmlSecNodeTransform));

   558 	return(NULL);	        	

   559     }

   560 

   561     if(xmlSetNsProp(res, res->ns, xmlSecAttrAlgorithm, transformId->href) == NULL) {

   562 	xmlSecError(XMLSEC_ERRORS_HERE,

   563 		    NULL,

   564 		    "xmlSetProp",

   565 		    XMLSEC_ERRORS_R_XML_FAILED,

   566 		    "name=%s,value=%s",

   567 		    xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

   568 		    xmlSecErrorsSafeString(transformId->href));

   569 	xmlUnlinkNode(res);

   570 	xmlFreeNode(res);

   571 	return(NULL);	        	

   572     }

   573 

   574     return(res);    

   575 }

   576 

   577 /**

   578  * xmlSecTmplObjectAddSignProperties:

   579  * @objectNode: 	the  pointer to <dsig:Object/> node.

   580  * @id: 		the node id (may be NULL).

   581  * @target: 		the Target  (may be NULL).

   582  *

   583  * Adds <dsig:SignatureProperties/> node to the <dsig:Object/> node @objectNode.

   584  *

   585  * Returns the pointer to newly created <dsig:SignatureProperties/> node or NULL 

   586  * if an error occurs.

   587  */

   588 EXPORT_C

   589 xmlNodePtr		

   590 xmlSecTmplObjectAddSignProperties(xmlNodePtr objectNode, const xmlChar *id, const xmlChar *target) {

   591     xmlNodePtr res;

   592     int error = 0;

   593 

   594     xmlSecAssert2(objectNode != NULL, NULL);

   595 

   596     res = xmlSecAddChild(objectNode, xmlSecNodeSignatureProperties, xmlSecDSigNs);

   597     if(res == NULL) {

   598 	xmlSecError(XMLSEC_ERRORS_HERE,

   599 		    NULL,

   600 		    "xmlSecAddChild",

   601 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   602 		    "node=%s",

   603 		    xmlSecErrorsSafeString(xmlSecNodeSignatureProperties));

   604 	return(NULL);	        	

   605     }

   606     if(id != NULL) {

   607 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   608     error = error || !ptr;

   609     }

   610     if(target != NULL) {

   611 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrTarget, target);

   612     error = error || !ptr;

   613     }

   614     if (error && OOM_FLAG) 

   615         {

   616         xmlUnlinkNode(res);

   617 	    xmlFreeNode(res);

   618 	    return(NULL);

   619         }

   620     return(res);

   621 }

   622 

   623 /**

   624  * xmlSecTmplObjectAddManifest:

   625  * @objectNode: 	the  pointer to <dsig:Object/> node.

   626  * @id: 		the node id (may be NULL).

   627  *

   628  * Adds <dsig:Manifest/> node to the <dsig:Object/> node @objectNode.

   629  *

   630  * Returns the pointer to newly created <dsig:Manifest/> node or NULL 

   631  * if an error occurs.

   632  */

   633 EXPORT_C

   634 xmlNodePtr

   635 xmlSecTmplObjectAddManifest(xmlNodePtr objectNode,  const xmlChar *id) {

   636     xmlNodePtr res;

   637 

   638     xmlSecAssert2(objectNode != NULL, NULL);

   639 

   640     res = xmlSecAddChild(objectNode, xmlSecNodeManifest, xmlSecDSigNs);

   641     if(res == NULL) {

   642 	xmlSecError(XMLSEC_ERRORS_HERE,

   643 		    NULL,

   644 		    "xmlSecAddChild",

   645 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   646 		    "node=%s",

   647 		    xmlSecErrorsSafeString(xmlSecNodeManifest));

   648 	return(NULL);	        	

   649     }

   650     if(id != NULL) {

   651 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   652         if (!ptr && OOM_FLAG) 

   653             {

   654             xmlUnlinkNode(res);

   655 	        xmlFreeNode(res);

   656 	        return(NULL);

   657             }

   658     }

   659     return(res);

   660 }

   661 

   662 /**

   663  * xmlSecTmplManifestAddReference:

   664  * @manifestNode: 	the pointer to <dsig:Manifest/> node.

   665  * @digestMethodId:	the reference digest method.

   666  * @id: 		the node id (may be NULL).

   667  * @uri: 		the reference node uri (may be NULL).

   668  * @type: 		the reference node type (may be NULL).

   669  *

   670  * Adds <dsig:Reference/> node with specified URI (@uri), Id (@id) and 

   671  * Type (@type) attributes and the required children <dsig:DigestMethod/> and

   672  * <dsig:DigestValue/> to the <dsig:Manifest/> node @manifestNode.

   673  *

   674  * Returns the pointer to newly created <dsig:Reference/> node or NULL 

   675  * if an error occurs.

   676  */

   677 EXPORT_C

   678 xmlNodePtr 

   679 xmlSecTmplManifestAddReference(xmlNodePtr manifestNode, xmlSecTransformId digestMethodId,

   680 			      const xmlChar *id, const xmlChar *uri, const xmlChar *type) {

   681     return(xmlSecTmplAddReference(manifestNode, digestMethodId, id, uri, type));

   682 }

   683 

   684 /**************************************************************************

   685  *

   686  * <enc:EncryptedData/> node

   687  *

   688  **************************************************************************/

   689 /** 

   690  * xmlSecTmplEncDataCreate:

   691  * @doc: 		the pointer to signature document or NULL; in the later

   692  *			case, application must later call @xmlSetTreeDoc to ensure 

   693  *			that all the children nodes have correct pointer to XML document.

   694  * @encMethodId:	the encryption method (may be NULL).

   695  * @id: 		the Id attribute (optional).

   696  * @type: 		the Type attribute (optional)

   697  * @mimeType: 		the MimeType attribute (optional)

   698  * @encoding: 		the Encoding attribute (optional)

   699  *

   700  * Creates new <enc:EncryptedData /> node for encryption template. 

   701  *

   702  * Returns the pointer newly created  <enc:EncryptedData/> node or NULL 

   703  * if an error occurs.

   704  */

   705 EXPORT_C

   706 xmlNodePtr		

   707 xmlSecTmplEncDataCreate(xmlDocPtr doc, xmlSecTransformId encMethodId,

   708 			    const xmlChar *id, const xmlChar *type,

   709 			    const xmlChar *mimeType, const xmlChar *encoding) {

   710     xmlNodePtr encNode;

   711     xmlNsPtr ns;

   712     int error = 0;

   713     

   714     encNode = xmlNewDocNode(doc, NULL, xmlSecNodeEncryptedData, NULL);

   715     if(encNode == NULL) {

   716 	xmlSecError(XMLSEC_ERRORS_HERE,

   717 		    NULL,

   718 		    "xmlNewDocNode",

   719 		    XMLSEC_ERRORS_R_XML_FAILED,

   720 		    "node=%s",

   721 		    xmlSecErrorsSafeString(xmlSecNodeEncryptedData));

   722 	return(NULL);	        

   723     }

   724     

   725     ns = xmlNewNs(encNode, xmlSecEncNs, NULL);

   726     if(ns == NULL) {

   727         xmlFreeNode(encNode);

   728 	xmlSecError(XMLSEC_ERRORS_HERE,

   729 		    NULL,

   730 		    "xmlNewNs",

   731 		    XMLSEC_ERRORS_R_XML_FAILED,

   732 		    "ns=%s",

   733 		    xmlSecErrorsSafeString(xmlSecEncNs));

   734 	return(NULL);	        	

   735     }

   736     xmlSetNs(encNode, ns);

   737     

   738     if(id != NULL) {

   739 	xmlAttrPtr ptr = xmlSetProp(encNode, xmlSecAttrId, id);

   740     error = error || !ptr;

   741     }

   742     if(type != NULL) {

   743 	xmlAttrPtr ptr = xmlSetProp(encNode, xmlSecAttrType, type);

   744     error = error || !ptr;

   745     }

   746     if(mimeType != NULL) {

   747 	xmlAttrPtr ptr = xmlSetProp(encNode, xmlSecAttrMimeType, mimeType);

   748     error = error || !ptr;

   749     }

   750     if(encoding != NULL) {

   751 	xmlAttrPtr ptr = xmlSetProp(encNode, xmlSecAttrEncoding, encoding);

   752     error = error || !ptr;

   753     }

   754     if (error && OOM_FLAG) 

   755         {

   756 	    xmlFreeNode(encNode);

   757 	    return(NULL);

   758         }

   759     

   760     if(xmlSecTmplPrepareEncData(encNode, encMethodId) < 0) {

   761 	xmlFreeNode(encNode);

   762 	return(NULL);

   763     }

   764     return(encNode);

   765 }

   766 

   767 static int  

   768 xmlSecTmplPrepareEncData(xmlNodePtr parentNode, xmlSecTransformId encMethodId) {

   769     xmlNodePtr cur;

   770     

   771     xmlSecAssert2(parentNode != NULL, -1);

   772     xmlSecAssert2((encMethodId == NULL) || (encMethodId->href != NULL), -1);

   773     

   774     /* add EncryptionMethod node if requested */

   775     if(encMethodId != NULL) {

   776 	cur = xmlSecAddChild(parentNode, xmlSecNodeEncryptionMethod, xmlSecEncNs);

   777 	if(cur == NULL) {

   778 	    xmlSecError(XMLSEC_ERRORS_HERE,

   779 			NULL,

   780 			"xmlSecAddChild",

   781 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   782 			"node=%s",

   783 			xmlSecErrorsSafeString(xmlSecNodeEncryptionMethod));

   784 	    return(-1);        	

   785 	}

   786 	if(xmlSetProp(cur, xmlSecAttrAlgorithm, encMethodId->href) == NULL) {

   787 	    xmlSecError(XMLSEC_ERRORS_HERE,

   788 		        NULL,

   789 			"xmlSetProp",

   790 		        XMLSEC_ERRORS_R_XML_FAILED,

   791 			"name=%s,value=%s",

   792 		        xmlSecErrorsSafeString(xmlSecAttrAlgorithm),

   793 			xmlSecErrorsSafeString(encMethodId->href));

   794 	    return(-1); 	

   795 	}	

   796     }

   797         

   798     /* and CipherData node */

   799     cur = xmlSecAddChild(parentNode, xmlSecNodeCipherData, xmlSecEncNs);

   800     if(cur == NULL) {

   801 	xmlSecError(XMLSEC_ERRORS_HERE,

   802 		    NULL,

   803 		    "xmlSecAddChild",

   804 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   805 		    "node=%s",

   806 		    xmlSecErrorsSafeString(xmlSecNodeCipherData));

   807 	return(-1);	        	

   808     }

   809     

   810     return(0);

   811 }

   812 

   813 

   814 /** 

   815  * xmlSecTmplEncDataEnsureKeyInfo:

   816  * @encNode: 		the pointer to <enc:EncryptedData/> node.

   817  * @id:			the Id attrbibute (optional).

   818  *

   819  * Adds <dsig:KeyInfo/> to the  <enc:EncryptedData/> node @encNode.

   820  *

   821  * Returns the pointer to newly created <dsig:KeyInfo/> node or 

   822  * NULL if an error occurs.

   823  */

   824 EXPORT_C

   825 xmlNodePtr

   826 xmlSecTmplEncDataEnsureKeyInfo(xmlNodePtr encNode, const xmlChar* id) {

   827     xmlNodePtr res;

   828     

   829     xmlSecAssert2(encNode != NULL, NULL);

   830 

   831     res = xmlSecFindChild(encNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

   832     if(res == NULL) {

   833 	xmlNodePtr cipherDataNode;

   834     

   835         cipherDataNode = xmlSecFindChild(encNode, xmlSecNodeCipherData, xmlSecEncNs);

   836 	if(cipherDataNode == NULL) {

   837 	    xmlSecError(XMLSEC_ERRORS_HERE,

   838 		        NULL,

   839 			xmlSecErrorsSafeString(xmlSecNodeCipherData),

   840 		        XMLSEC_ERRORS_R_NODE_NOT_FOUND,

   841 			XMLSEC_ERRORS_NO_MESSAGE);

   842 	    return(NULL);	

   843 	}

   844 

   845 	res = xmlSecAddPrevSibling(cipherDataNode, xmlSecNodeKeyInfo, xmlSecDSigNs);

   846 	if(res == NULL) {

   847 	    xmlSecError(XMLSEC_ERRORS_HERE,

   848 		        NULL,

   849 			"xmlSecAddPrevSibling",

   850 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   851 			"node=%s",

   852 			xmlSecErrorsSafeString(xmlSecNodeKeyInfo));

   853 	    return(NULL);	        	

   854 	}

   855     }

   856     if(id != NULL) {

   857 	    xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   858         if (!ptr && OOM_FLAG) 

   859             {

   860             xmlUnlinkNode(res);

   861     	    xmlFreeNode(res);

   862     	    return(NULL);

   863             }

   864     }

   865     return(res);        

   866 }

   867 

   868 /** 

   869  * xmlSecTmplEncDataEnsureEncProperties:

   870  * @encNode: 		the pointer to <enc:EncryptedData/> node.

   871  * @id: 		the Id attribute (optional).

   872  *

   873  * Adds <enc:EncryptionProperties/> node to the <enc:EncryptedData/> 

   874  * node @encNode.

   875  *

   876  * Returns the pointer to newly created <enc:EncryptionProperties/> node or 

   877  * NULL if an error occurs.

   878  */

   879 EXPORT_C

   880 xmlNodePtr

   881 xmlSecTmplEncDataEnsureEncProperties(xmlNodePtr encNode, const xmlChar *id) {

   882     xmlNodePtr res;

   883     int created = 0;

   884 

   885     xmlSecAssert2(encNode != NULL, NULL);

   886 

   887     res = xmlSecFindChild(encNode, xmlSecNodeEncryptionProperties, xmlSecEncNs);

   888     if(res == NULL) {

   889 	res = xmlSecAddChild(encNode, xmlSecNodeEncryptionProperties, xmlSecEncNs);

   890 	if(res == NULL) {

   891 	    xmlSecError(XMLSEC_ERRORS_HERE,

   892 			NULL,

   893 			"xmlSecAddChild",

   894 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   895 			"node=%s",

   896 			xmlSecErrorsSafeString(xmlSecNodeEncryptionProperties));

   897 	    return(NULL);	        	

   898 	}

   899 	created = 1;

   900     }

   901 

   902     if(id != NULL) {

   903 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   904         if (!ptr && OOM_FLAG) 

   905             {

   906             if (created) 

   907                 {

   908                 xmlUnlinkNode(res);

   909         	    xmlFreeNode(res);

   910                 }

   911             return(NULL);

   912             }

   913     }

   914     

   915     return(res);

   916 }

   917 

   918 /** 

   919  * xmlSecTmplEncDataAddEncProperty:

   920  * @encNode: 		the pointer to <enc:EncryptedData/> node.

   921  * @id: 		the Id attribute (optional).

   922  * @target: 		the Target attribute (optional).

   923  *

   924  * Adds <enc:EncryptionProperty/> node (and the parent 

   925  * <enc:EncryptionProperties/> node if required) to the 

   926  * <enc:EncryptedData/> node @encNode.

   927  *

   928  * Returns the pointer to newly created <enc:EncryptionProperty/> node or 

   929  * NULL if an error occurs.

   930  */

   931 EXPORT_C

   932 xmlNodePtr	

   933 xmlSecTmplEncDataAddEncProperty(xmlNodePtr encNode, const xmlChar *id, const xmlChar *target) {

   934     xmlNodePtr encProps;

   935     xmlNodePtr res;

   936     int error = 0;

   937         

   938     xmlSecAssert2(encNode != NULL, NULL);

   939 

   940     encProps = xmlSecTmplEncDataEnsureEncProperties(encNode, NULL);

   941     if(encProps == NULL) {

   942 	xmlSecError(XMLSEC_ERRORS_HERE,

   943 		    NULL,

   944 		    "xmlSecTmplEncDataEnsureEncProperties",

   945 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   946 		    XMLSEC_ERRORS_NO_MESSAGE);

   947 	return(NULL);	

   948     }

   949 

   950     res = xmlSecAddChild(encProps, xmlSecNodeEncryptionProperty, xmlSecEncNs);

   951     if(res == NULL) {

   952 	xmlSecError(XMLSEC_ERRORS_HERE,

   953 		    NULL,

   954 		    "xmlSecAddChild",

   955 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   956 		    "node=%s",

   957 		    xmlSecErrorsSafeString(xmlSecNodeEncryptionProperty));

   958 	return(NULL);	

   959     }

   960     if(id != NULL) {

   961 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrId, id);

   962     error = error || !ptr;

   963     }

   964     if(target != NULL) {

   965 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrTarget, target);

   966     error = error || !ptr;

   967     }

   968     if (error && OOM_FLAG) 

   969         {

   970         xmlUnlinkNode(res);

   971 	    xmlFreeNode(res);

   972 	    return(NULL);

   973         }

   974     

   975     return(res);

   976 }

   977 

   978 /** 

   979  * xmlSecTmplEncDataEnsureCipherValue:

   980  * @encNode: 		the pointer to <enc:EncryptedData/> node.

   981  *

   982  * Adds <enc:CipherValue/> to the <enc:EncryptedData/> node @encNode.

   983  *

   984  * Returns the pointer to newly created <enc:CipherValue/> node or 

   985  * NULL if an error occurs.

   986  */

   987 EXPORT_C

   988 xmlNodePtr

   989 xmlSecTmplEncDataEnsureCipherValue(xmlNodePtr encNode) {

   990     xmlNodePtr cipherDataNode;

   991     xmlNodePtr res, tmp;

   992         

   993     xmlSecAssert2(encNode != NULL, NULL);

   994 

   995     cipherDataNode = xmlSecFindChild(encNode, xmlSecNodeCipherData, xmlSecEncNs);

   996     if(cipherDataNode == NULL) {

   997 	xmlSecError(XMLSEC_ERRORS_HERE,

   998 		    NULL,

   999 		    xmlSecErrorsSafeString(xmlSecNodeCipherData),

  1000 		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

  1001 		    XMLSEC_ERRORS_NO_MESSAGE);

  1002 	return(NULL);	

  1003     }

  1004 

  1005     /* check that we don;t have CipherReference node */

  1006     tmp = xmlSecFindChild(cipherDataNode, xmlSecNodeCipherReference, xmlSecEncNs);

  1007     if(tmp != NULL) {

  1008 	xmlSecError(XMLSEC_ERRORS_HERE,

  1009 		    NULL,

  1010 		    xmlSecErrorsSafeString(xmlSecNodeCipherReference),

  1011 		    XMLSEC_ERRORS_R_NODE_ALREADY_PRESENT,

  1012 		    XMLSEC_ERRORS_NO_MESSAGE);

  1013 	return(NULL);	

  1014     }

  1015 

  1016     res = xmlSecFindChild(cipherDataNode, xmlSecNodeCipherValue, xmlSecEncNs);

  1017     if(res == NULL) {

  1018 	res = xmlSecAddChild(cipherDataNode, xmlSecNodeCipherValue, xmlSecEncNs);

  1019 	if(res == NULL) {

  1020 	    xmlSecError(XMLSEC_ERRORS_HERE,

  1021 			NULL,

  1022 			"xmlSecAddChild",

  1023 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1024 			"node=%s",

  1025 			xmlSecErrorsSafeString(xmlSecNodeCipherValue));

  1026 	    return(NULL);	        	

  1027 	}

  1028     }

  1029         

  1030     return(res);

  1031 }

  1032 

  1033 /** 

  1034  * xmlSecTmplEncDataEnsureCipherReference:

  1035  * @encNode: 		the pointer to <enc:EncryptedData/> node.

  1036  * @uri: 		the URI attribute (may be NULL).

  1037  *

  1038  * Adds <enc:CipherReference/> node with specified URI attribute @uri

  1039  * to the <enc:EncryptedData/> node @encNode.

  1040  *

  1041  * Returns the pointer to newly created <enc:CipherReference/> node or 

  1042  * NULL if an error occurs.

  1043  */

  1044 EXPORT_C

  1045 xmlNodePtr

  1046 xmlSecTmplEncDataEnsureCipherReference(xmlNodePtr encNode, const xmlChar *uri) {

  1047     xmlNodePtr cipherDataNode;

  1048     xmlNodePtr res, tmp;

  1049     int created = 1;

  1050         

  1051     xmlSecAssert2(encNode != NULL, NULL);

  1052 

  1053     cipherDataNode = xmlSecFindChild(encNode, xmlSecNodeCipherData, xmlSecEncNs);

  1054     if(cipherDataNode == NULL) {

  1055 	xmlSecError(XMLSEC_ERRORS_HERE,

  1056 		    NULL,

  1057 		    xmlSecErrorsSafeString(xmlSecNodeCipherData),

  1058 		    XMLSEC_ERRORS_R_NODE_NOT_FOUND,

  1059 		    XMLSEC_ERRORS_NO_MESSAGE);

  1060 	return(NULL);	

  1061     }

  1062 

  1063     /* check that we don;t have CipherValue node */

  1064     tmp = xmlSecFindChild(cipherDataNode, xmlSecNodeCipherValue, xmlSecEncNs);

  1065     if(tmp != NULL) {

  1066 	xmlSecError(XMLSEC_ERRORS_HERE,

  1067 		    NULL,

  1068 		    xmlSecErrorsSafeString(xmlSecNodeCipherValue),

  1069 		    XMLSEC_ERRORS_R_NODE_ALREADY_PRESENT,

  1070 		    XMLSEC_ERRORS_NO_MESSAGE);

  1071 	return(NULL);	

  1072     }

  1073 

  1074     res = xmlSecFindChild(cipherDataNode, xmlSecNodeCipherReference, xmlSecEncNs);

  1075     if(res == NULL) {

  1076 	res = xmlSecAddChild(cipherDataNode, xmlSecNodeCipherReference, xmlSecEncNs);

  1077 	if(res == NULL) {

  1078 	    xmlSecError(XMLSEC_ERRORS_HERE,

  1079 			NULL,

  1080 			"xmlSecAddChild",

  1081 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

  1082 			"node=%s",

  1083 			xmlSecErrorsSafeString(xmlSecNodeCipherReference));

  1084 	    return(NULL);	        	

  1085 	}

  1086 	created = 1;

  1087     }

  1088     

  1089     if(uri != NULL) {

  1090 	xmlAttrPtr ptr = xmlSetProp(res, xmlSecAttrURI, uri);

  1091         if (!ptr && OOM_FLAG) 

  1092             {

  1093             if (created) 

  1094                 {

  1095                 xmlUnlinkNode(res);

  1096         	    xmlFreeNode(res);

  1097                 }

  1098             return(NULL);

  1099             }

  1100     }

  1101     

  1102     return(res);

  1103 }

  1104 

  1105 /** 

  1106  * xmlSecTmplEncDataGetEncMethodNode:

  1107  * @encNode:		the pointer to <enc:EcnryptedData /> node.

  1108  *

  1109  * Gets pointer to <enc:EncrytpionMethod/> node.

  1110  *

  1111  * Returns pointer to <enc:EncryptionMethod /> node or NULL if an error occurs.

  1112  */

  1113 EXPORT_C

  1114 xmlNodePtr 

  1115 xmlSecTmplEncDataGetEncMethodNode(xmlNodePtr encNode) {

  1116     xmlSecAssert2(encNode != NULL, NULL);

  1117 

  1118     return(xmlSecFindChild(encNode, xmlSecNodeEncryptionMethod, xmlSecEncNs));

  1119 }

  1120 

  1121 /** 

  1122  * xmlSecTmplCipherReferenceAddTransform:

  1123  * @cipherReferenceNode: 	the pointer to <enc:CipherReference/> node.

  1124  * @transformId: 		the transform id.

  1125  *

  1126  * Adds <dsig:Transform/> node (and the parent <dsig:Transforms/> node)

  1127  * with specified transform methods @transform to the <enc:CipherReference/>

  1128  * child node of the <enc:EncryptedData/> node @encNode.

  1129  *

  1130  * Returns the pointer to newly created <dsig:Transform/> node or 

  1131  * NULL if an error occurs.

  1132  */

  1133 EXPORT_C

  1134 xmlNodePtr