1 /*
2 * XML Security Library (http://www.aleksey.com/xmlsec).
3 *
4 *
5 * This is free software; see Copyright file in the source
6 * distribution for preciese wording.
7 *
8 * Copyright (C) 2002-2016 Aleksey Sanin <aleksey@aleksey.com>. All Rights Reserved.
9 */
10 /**
11 * SECTION:c14n
12 * @Short_description: C14N transform implementation.
13 * @Stability: Private
14 *
15 */
16 #include "globals.h"
17
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21
22 #include <libxml/tree.h>
23 #include <libxml/c14n.h>
24
25 #include <xmlsec/xmlsec.h>
26 #include <xmlsec/keys.h>
27 #include <xmlsec/list.h>
28 #include <xmlsec/transforms.h>
29 #include <xmlsec/xmltree.h>
30 #include <xmlsec/errors.h>
31
32 /******************************************************************************
33 *
34 * C14N transforms
35 *
36 * Inclusive namespaces list for ExclC14N (xmlSecStringList) is located
37 * after xmlSecTransform structure
38 *
39 *****************************************************************************/
40 #define xmlSecTransformC14NSize \
41 (sizeof(xmlSecTransform) + sizeof(xmlSecPtrList))
42 #define xmlSecTransformC14NGetNsList(transform) \
43 ((xmlSecTransformCheckSize((transform), xmlSecTransformC14NSize)) ? \
44 (xmlSecPtrListPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)) : \
45 (xmlSecPtrListPtr)NULL)
46
47 #define xmlSecTransformC14NCheckId(transform) \
48 (xmlSecTransformInclC14NCheckId((transform)) || \
49 xmlSecTransformInclC14N11CheckId((transform)) || \
50 xmlSecTransformExclC14NCheckId((transform)) || \
51 xmlSecTransformCheckId((transform), xmlSecTransformRemoveXmlTagsC14NId))
52 #define xmlSecTransformInclC14NCheckId(transform) \
53 (xmlSecTransformCheckId((transform), xmlSecTransformInclC14NId) || \
54 xmlSecTransformCheckId((transform), xmlSecTransformInclC14NWithCommentsId))
55 #define xmlSecTransformInclC14N11CheckId(transform) \
56 (xmlSecTransformCheckId((transform), xmlSecTransformInclC14N11Id) || \
57 xmlSecTransformCheckId((transform), xmlSecTransformInclC14N11WithCommentsId))
58 #define xmlSecTransformExclC14NCheckId(transform) \
59 (xmlSecTransformCheckId((transform), xmlSecTransformExclC14NId) || \
60 xmlSecTransformCheckId((transform), xmlSecTransformExclC14NWithCommentsId) )
61
62
63 static int xmlSecTransformC14NInitialize (xmlSecTransformPtr transform);
64 static void xmlSecTransformC14NFinalize (xmlSecTransformPtr transform);
65 static int xmlSecTransformC14NNodeRead (xmlSecTransformPtr transform,
66 xmlNodePtr node,
67 xmlSecTransformCtxPtr transformCtx);
68 static int xmlSecTransformC14NPushXml (xmlSecTransformPtr transform,
69 xmlSecNodeSetPtr nodes,
70 xmlSecTransformCtxPtr transformCtx);
71 static int xmlSecTransformC14NPopBin (xmlSecTransformPtr transform,
72 xmlSecByte* data,
73 xmlSecSize maxDataSize,
74 xmlSecSize* dataSize,
75 xmlSecTransformCtxPtr transformCtx);
76 static int xmlSecTransformC14NExecute (xmlSecTransformId id,
77 xmlSecNodeSetPtr nodes,
78 xmlChar** nsList,
79 xmlOutputBufferPtr buf);
80 static int
xmlSecTransformC14NInitialize(xmlSecTransformPtr transform)81 xmlSecTransformC14NInitialize(xmlSecTransformPtr transform) {
82 xmlSecPtrListPtr nsList;
83 int ret;
84
85 xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
86
87 nsList = xmlSecTransformC14NGetNsList(transform);
88 xmlSecAssert2(nsList != NULL, -1);
89
90 ret = xmlSecPtrListInitialize(nsList, xmlSecStringListId);
91 if(ret < 0) {
92 xmlSecInternalError("xmlSecPtrListInitialize",
93 xmlSecTransformGetName(transform));
94 return(-1);
95 }
96 return(0);
97 }
98
99 static void
xmlSecTransformC14NFinalize(xmlSecTransformPtr transform)100 xmlSecTransformC14NFinalize(xmlSecTransformPtr transform) {
101 xmlSecPtrListPtr nsList;
102
103 xmlSecAssert(xmlSecTransformC14NCheckId(transform));
104
105 nsList = xmlSecTransformC14NGetNsList(transform);
106 xmlSecAssert(xmlSecPtrListCheckId(nsList, xmlSecStringListId));
107
108 xmlSecPtrListFinalize(nsList);
109 }
110
111 static int
xmlSecTransformC14NNodeRead(xmlSecTransformPtr transform,xmlNodePtr node,xmlSecTransformCtxPtr transformCtx)112 xmlSecTransformC14NNodeRead(xmlSecTransformPtr transform, xmlNodePtr node, xmlSecTransformCtxPtr transformCtx) {
113 xmlSecPtrListPtr nsList;
114 xmlNodePtr cur;
115 xmlChar *list;
116 xmlChar *p, *n, *tmp;
117 int ret;
118
119 /* we have something to read only for exclusive c14n transforms */
120 xmlSecAssert2(xmlSecTransformExclC14NCheckId(transform), -1);
121 xmlSecAssert2(node != NULL, -1);
122 xmlSecAssert2(transformCtx != NULL, -1);
123
124 nsList = xmlSecTransformC14NGetNsList(transform);
125 xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
126 xmlSecAssert2(xmlSecPtrListGetSize(nsList) == 0, -1);
127
128 /* there is only one optional node */
129 cur = xmlSecGetNextElementNode(node->children);
130 if(cur != NULL) {
131 if(!xmlSecCheckNodeName(cur, xmlSecNodeInclusiveNamespaces, xmlSecNsExcC14N)) {
132 xmlSecInvalidNodeError(cur, xmlSecNodeInclusiveNamespaces,
133 xmlSecTransformGetName(transform));
134 return(-1);
135 }
136
137 list = xmlGetProp(cur, xmlSecAttrPrefixList);
138 if(list == NULL) {
139 xmlSecInvalidNodeAttributeError(cur, xmlSecAttrPrefixList,
140 xmlSecTransformGetName(transform),
141 "empty");
142 return(-1);
143 }
144
145 /* the list of namespaces is space separated */
146 for(p = n = list; ((p != NULL) && ((*p) != '\0')); p = n) {
147 n = (xmlChar*)xmlStrchr(p, ' ');
148 if(n != NULL) {
149 *(n++) = '\0';
150 }
151
152 tmp = xmlStrdup(p);
153 if(tmp == NULL) {
154 xmlSecStrdupError(p, xmlSecTransformGetName(transform));
155 xmlFree(list);
156 return(-1);
157 }
158
159 ret = xmlSecPtrListAdd(nsList, tmp);
160 if(ret < 0) {
161 xmlSecInternalError("xmlSecPtrListAdd",
162 xmlSecTransformGetName(transform));
163 xmlFree(tmp);
164 xmlFree(list);
165 return(-1);
166 }
167 }
168 xmlFree(list);
169
170 /* add NULL at the end */
171 ret = xmlSecPtrListAdd(nsList, NULL);
172 if(ret < 0) {
173 xmlSecInternalError("xmlSecPtrListAdd",
174 xmlSecTransformGetName(transform));
175 return(-1);
176 }
177
178 cur = xmlSecGetNextElementNode(cur->next);
179 }
180
181 /* check that we have nothing else */
182 if(cur != NULL) {
183 xmlSecUnexpectedNodeError(cur, NULL);
184 return(-1);
185 }
186
187 return(0);
188 }
189
190 static int
xmlSecTransformC14NPushXml(xmlSecTransformPtr transform,xmlSecNodeSetPtr nodes,xmlSecTransformCtxPtr transformCtx)191 xmlSecTransformC14NPushXml(xmlSecTransformPtr transform, xmlSecNodeSetPtr nodes,
192 xmlSecTransformCtxPtr transformCtx) {
193 xmlOutputBufferPtr buf;
194 xmlSecPtrListPtr nsList;
195 int ret;
196
197 xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
198 xmlSecAssert2(nodes != NULL, -1);
199 xmlSecAssert2(nodes->doc != NULL, -1);
200 xmlSecAssert2(transformCtx != NULL, -1);
201
202 /* check/update current transform status */
203 switch(transform->status) {
204 case xmlSecTransformStatusNone:
205 transform->status = xmlSecTransformStatusWorking;
206 break;
207 case xmlSecTransformStatusWorking:
208 case xmlSecTransformStatusFinished:
209 return(0);
210 default:
211 xmlSecInvalidTransfromStatusError(transform);
212 return(-1);
213 }
214 xmlSecAssert2(transform->status == xmlSecTransformStatusWorking, -1);
215
216 /* prepare output buffer: next transform or ourselves */
217 if(transform->next != NULL) {
218 buf = xmlSecTransformCreateOutputBuffer(transform->next, transformCtx);
219 if(buf == NULL) {
220 xmlSecInternalError("xmlSecTransformCreateOutputBuffer",
221 xmlSecTransformGetName(transform));
222 return(-1);
223 }
224 } else {
225 buf = xmlSecBufferCreateOutputBuffer(&(transform->outBuf));
226 if(buf == NULL) {
227 xmlSecInternalError("xmlSecBufferCreateOutputBuffer",
228 xmlSecTransformGetName(transform));
229 return(-1);
230 }
231 }
232
233 /* we are using a semi-hack here: we know that xmlSecPtrList keeps
234 * all pointers in the big array */
235 nsList = xmlSecTransformC14NGetNsList(transform);
236 xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
237
238 ret = xmlSecTransformC14NExecute(transform->id, nodes, (xmlChar**)(nsList->data), buf);
239 if(ret < 0) {
240 xmlSecInternalError("xmlSecTransformC14NExecute",
241 xmlSecTransformGetName(transform));
242 xmlOutputBufferClose(buf);
243 return(-1);
244 }
245
246 ret = xmlOutputBufferClose(buf);
247 if(ret < 0) {
248 xmlSecXmlError("xmlOutputBufferClose", xmlSecTransformGetName(transform));
249 return(-1);
250 }
251 transform->status = xmlSecTransformStatusFinished;
252 return(0);
253 }
254
255 static int
xmlSecTransformC14NPopBin(xmlSecTransformPtr transform,xmlSecByte * data,xmlSecSize maxDataSize,xmlSecSize * dataSize,xmlSecTransformCtxPtr transformCtx)256 xmlSecTransformC14NPopBin(xmlSecTransformPtr transform, xmlSecByte* data,
257 xmlSecSize maxDataSize, xmlSecSize* dataSize,
258 xmlSecTransformCtxPtr transformCtx) {
259 xmlSecPtrListPtr nsList;
260 xmlSecBufferPtr out;
261 int ret;
262
263 xmlSecAssert2(xmlSecTransformC14NCheckId(transform), -1);
264 xmlSecAssert2(data != NULL, -1);
265 xmlSecAssert2(dataSize != NULL, -1);
266 xmlSecAssert2(transformCtx != NULL, -1);
267
268 out = &(transform->outBuf);
269 if(transform->status == xmlSecTransformStatusNone) {
270 xmlOutputBufferPtr buf;
271
272 xmlSecAssert2(transform->inNodes == NULL, -1);
273
274 /* todo: isn't it an error? */
275 if(transform->prev == NULL) {
276 (*dataSize) = 0;
277 transform->status = xmlSecTransformStatusFinished;
278 return(0);
279 }
280
281 /* get xml data from previous transform */
282 ret = xmlSecTransformPopXml(transform->prev, &(transform->inNodes), transformCtx);
283 if(ret < 0) {
284 xmlSecInternalError("xmlSecTransformPopXml",
285 xmlSecTransformGetName(transform));
286 return(-1);
287 }
288
289 /* dump everything to internal buffer */
290 buf = xmlSecBufferCreateOutputBuffer(out);
291 if(buf == NULL) {
292 xmlSecInternalError("xmlSecBufferCreateOutputBuffer",
293 xmlSecTransformGetName(transform));
294 return(-1);
295 }
296
297 /* we are using a semi-hack here: we know that xmlSecPtrList keeps
298 * all pointers in the big array */
299 nsList = xmlSecTransformC14NGetNsList(transform);
300 xmlSecAssert2(xmlSecPtrListCheckId(nsList, xmlSecStringListId), -1);
301
302 ret = xmlSecTransformC14NExecute(transform->id, transform->inNodes, (xmlChar**)(nsList->data), buf);
303 if(ret < 0) {
304 xmlSecInternalError("xmlSecTransformC14NExecute",
305 xmlSecTransformGetName(transform));
306 xmlOutputBufferClose(buf);
307 return(-1);
308 }
309 ret = xmlOutputBufferClose(buf);
310 if(ret < 0) {
311 xmlSecXmlError("xmlOutputBufferClose", xmlSecTransformGetName(transform));
312 return(-1);
313 }
314 transform->status = xmlSecTransformStatusWorking;
315 }
316
317 if(transform->status == xmlSecTransformStatusWorking) {
318 xmlSecSize outSize;
319
320 /* return chunk after chunk */
321 outSize = xmlSecBufferGetSize(out);
322 if(outSize > maxDataSize) {
323 outSize = maxDataSize;
324 }
325 if(outSize > XMLSEC_TRANSFORM_BINARY_CHUNK) {
326 outSize = XMLSEC_TRANSFORM_BINARY_CHUNK;
327 }
328 if(outSize > 0) {
329 xmlSecAssert2(xmlSecBufferGetData(&(transform->outBuf)), -1);
330
331 memcpy(data, xmlSecBufferGetData(&(transform->outBuf)), outSize);
332 ret = xmlSecBufferRemoveHead(&(transform->outBuf), outSize);
333 if(ret < 0) {
334 xmlSecInternalError2("xmlSecBufferRemoveHead",
335 xmlSecTransformGetName(transform),
336 "size=%d", outSize);
337 return(-1);
338 }
339 } else if(xmlSecBufferGetSize(out) == 0) {
340 transform->status = xmlSecTransformStatusFinished;
341 }
342 (*dataSize) = outSize;
343 } else if(transform->status == xmlSecTransformStatusFinished) {
344 /* the only way we can get here is if there is no output */
345 xmlSecAssert2(xmlSecBufferGetSize(out) == 0, -1);
346 (*dataSize) = 0;
347 } else {
348 xmlSecInvalidTransfromStatusError(transform);
349 return(-1);
350 }
351
352 return(0);
353 }
354
355 static int
xmlSecTransformC14NExecute(xmlSecTransformId id,xmlSecNodeSetPtr nodes,xmlChar ** nsList,xmlOutputBufferPtr buf)356 xmlSecTransformC14NExecute(xmlSecTransformId id, xmlSecNodeSetPtr nodes, xmlChar** nsList,
357 xmlOutputBufferPtr buf) {
358 int ret;
359
360 xmlSecAssert2(id != xmlSecTransformIdUnknown, -1);
361 xmlSecAssert2(nodes != NULL, -1);
362 xmlSecAssert2(nodes->doc != NULL, -1);
363 xmlSecAssert2(buf != NULL, -1);
364
365 /* execute c14n transform */
366 if(id == xmlSecTransformInclC14NId) {
367 ret = xmlC14NExecute(nodes->doc,
368 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
369 nodes, XML_C14N_1_0, NULL, 0, buf);
370 } else if(id == xmlSecTransformInclC14NWithCommentsId) {
371 ret = xmlC14NExecute(nodes->doc,
372 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
373 nodes, XML_C14N_1_0, NULL, 1, buf);
374 } else if(id == xmlSecTransformInclC14N11Id) {
375 ret = xmlC14NExecute(nodes->doc,
376 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
377 nodes, XML_C14N_1_1, NULL, 0, buf);
378 } else if(id == xmlSecTransformInclC14N11WithCommentsId) {
379 ret = xmlC14NExecute(nodes->doc,
380 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
381 nodes, XML_C14N_1_1, NULL, 1, buf);
382 } else if(id == xmlSecTransformExclC14NId) {
383 ret = xmlC14NExecute(nodes->doc,
384 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
385 nodes, XML_C14N_EXCLUSIVE_1_0, nsList, 0, buf);
386 } else if(id == xmlSecTransformExclC14NWithCommentsId) {
387 ret = xmlC14NExecute(nodes->doc,
388 (xmlC14NIsVisibleCallback)xmlSecNodeSetContains,
389 nodes, XML_C14N_EXCLUSIVE_1_0, nsList, 1, buf);
390 } else if(id == xmlSecTransformRemoveXmlTagsC14NId) {
391 ret = xmlSecNodeSetDumpTextNodes(nodes, buf);
392 } else {
393 /* shoudn't be possible to come here, actually */
394 xmlSecOtherError(XMLSEC_ERRORS_R_INVALID_TRANSFORM,
395 xmlSecTransformKlassGetName(id), NULL);
396 return(-1);
397 }
398
399 if(ret < 0) {
400 xmlSecXmlError("xmlC14NExecute", xmlSecTransformKlassGetName(id));
401 return(-1);
402 }
403
404 return(0);
405 }
406
407 /***************************************************************************
408 *
409 * C14N
410 *
411 ***************************************************************************/
412 static xmlSecTransformKlass xmlSecTransformInclC14NKlass = {
413 /* klass/object sizes */
414 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
415 xmlSecTransformC14NSize, /* xmlSecSize objSize */
416
417 xmlSecNameC14N, /* const xmlChar* name; */
418 xmlSecHrefC14N, /* const xmlChar* href; */
419 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
420 /* xmlSecAlgorithmUsage usage; */
421
422 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
423 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
424 NULL, /* xmlSecTransformNodeReadMethod readNode; */
425 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
426 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
427 NULL, /* xmlSecTransformSetKeyMethod setKey; */
428 NULL, /* xmlSecTransformValidateMethod validate; */
429 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
430 NULL, /* xmlSecTransformPushBinMethod pushBin; */
431 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
432 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
433 NULL, /* xmlSecTransformPopXmlMethod popXml; */
434 NULL, /* xmlSecTransformExecuteMethod execute; */
435
436 NULL, /* void* reserved0; */
437 NULL, /* void* reserved1; */
438 };
439
440 /**
441 * xmlSecTransformInclC14NGetKlass:
442 *
443 * Inclusive (regular) canonicalization that omits comments transform klass
444 * (http://www.w3.org/TR/xmldsig-core/#sec-c14nAlg and
445 * http://www.w3.org/TR/2001/REC-xml-c14n-20010315).
446 *
447 * Returns: c14n transform id.
448 */
449 xmlSecTransformId
xmlSecTransformInclC14NGetKlass(void)450 xmlSecTransformInclC14NGetKlass(void) {
451 return(&xmlSecTransformInclC14NKlass);
452 }
453
454 /***************************************************************************
455 *
456 * C14N With Comments
457 *
458 ***************************************************************************/
459 static xmlSecTransformKlass xmlSecTransformInclC14NWithCommentsKlass = {
460 /* klass/object sizes */
461 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
462 xmlSecTransformC14NSize, /* xmlSecSize objSize */
463
464 /* same as xmlSecTransformId */
465 xmlSecNameC14NWithComments, /* const xmlChar* name; */
466 xmlSecHrefC14NWithComments, /* const xmlChar* href; */
467 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
468 /* xmlSecAlgorithmUsage usage; */
469
470 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
471 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
472 NULL, /* xmlSecTransformNodeReadMethod read; */
473 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
474 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
475 NULL, /* xmlSecTransformSetKeyMethod setKey; */
476 NULL, /* xmlSecTransformValidateMethod validate; */
477 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
478 NULL, /* xmlSecTransformPushBinMethod pushBin; */
479 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
480 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
481 NULL, /* xmlSecTransformPopXmlMethod popXml; */
482 NULL, /* xmlSecTransformExecuteMethod execute; */
483
484 NULL, /* void* reserved0; */
485 NULL, /* void* reserved1; */
486 };
487
488 /**
489 * xmlSecTransformInclC14NWithCommentsGetKlass:
490 *
491 * Inclusive (regular) canonicalization that includes comments transform klass
492 * (http://www.w3.org/TR/xmldsig-core/#sec-c14nAlg and
493 * http://www.w3.org/TR/2001/REC-xml-c14n-20010315).
494 *
495 * Returns: c14n with comments transform id.
496 */
497 xmlSecTransformId
xmlSecTransformInclC14NWithCommentsGetKlass(void)498 xmlSecTransformInclC14NWithCommentsGetKlass(void) {
499 return(&xmlSecTransformInclC14NWithCommentsKlass);
500 }
501
502 /***************************************************************************
503 *
504 * C14N v1.1
505 *
506 ***************************************************************************/
507 static xmlSecTransformKlass xmlSecTransformInclC14N11Klass = {
508 /* klass/object sizes */
509 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
510 xmlSecTransformC14NSize, /* xmlSecSize objSize */
511
512 xmlSecNameC14N11, /* const xmlChar* name; */
513 xmlSecHrefC14N11, /* const xmlChar* href; */
514 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
515 /* xmlSecAlgorithmUsage usage; */
516
517 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
518 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
519 NULL, /* xmlSecTransformNodeReadMethod readNode; */
520 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
521 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
522 NULL, /* xmlSecTransformSetKeyMethod setKey; */
523 NULL, /* xmlSecTransformValidateMethod validate; */
524 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
525 NULL, /* xmlSecTransformPushBinMethod pushBin; */
526 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
527 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
528 NULL, /* xmlSecTransformPopXmlMethod popXml; */
529 NULL, /* xmlSecTransformExecuteMethod execute; */
530
531 NULL, /* void* reserved0; */
532 NULL, /* void* reserved1; */
533 };
534
535 /**
536 * xmlSecTransformInclC14N11GetKlass:
537 *
538 * C14N version 1.1 (http://www.w3.org/TR/xml-c14n11)
539 *
540 * Returns: c14n v1.1 transform id.
541 */
542 xmlSecTransformId
xmlSecTransformInclC14N11GetKlass(void)543 xmlSecTransformInclC14N11GetKlass(void) {
544 return(&xmlSecTransformInclC14N11Klass);
545 }
546
547 /***************************************************************************
548 *
549 * C14N v1.1 With Comments
550 *
551 ***************************************************************************/
552 static xmlSecTransformKlass xmlSecTransformInclC14N11WithCommentsKlass = {
553 /* klass/object sizes */
554 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
555 xmlSecTransformC14NSize, /* xmlSecSize objSize */
556
557 /* same as xmlSecTransformId */
558 xmlSecNameC14N11WithComments, /* const xmlChar* name; */
559 xmlSecHrefC14N11WithComments, /* const xmlChar* href; */
560 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
561 /* xmlSecAlgorithmUsage usage; */
562
563 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
564 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
565 NULL, /* xmlSecTransformNodeReadMethod read; */
566 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
567 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
568 NULL, /* xmlSecTransformSetKeyMethod setKey; */
569 NULL, /* xmlSecTransformValidateMethod validate; */
570 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
571 NULL, /* xmlSecTransformPushBinMethod pushBin; */
572 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
573 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
574 NULL, /* xmlSecTransformPopXmlMethod popXml; */
575 NULL, /* xmlSecTransformExecuteMethod execute; */
576
577 NULL, /* void* reserved0; */
578 NULL, /* void* reserved1; */
579 };
580
581 /**
582 * xmlSecTransformInclC14N11WithCommentsGetKlass:
583 *
584 * C14N version 1.1 (http://www.w3.org/TR/xml-c14n11) with comments
585 *
586 * Returns: c14n v1.1 with comments transform id.
587 */
588 xmlSecTransformId
xmlSecTransformInclC14N11WithCommentsGetKlass(void)589 xmlSecTransformInclC14N11WithCommentsGetKlass(void) {
590 return(&xmlSecTransformInclC14N11WithCommentsKlass);
591 }
592
593
594 /***************************************************************************
595 *
596 * Excl C14N
597 *
598 ***************************************************************************/
599 static xmlSecTransformKlass xmlSecTransformExclC14NKlass = {
600 /* klass/object sizes */
601 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
602 xmlSecTransformC14NSize, /* xmlSecSize objSize */
603
604 xmlSecNameExcC14N, /* const xmlChar* name; */
605 xmlSecHrefExcC14N, /* const xmlChar* href; */
606 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
607 /* xmlSecAlgorithmUsage usage; */
608
609 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
610 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
611 xmlSecTransformC14NNodeRead, /* xmlSecTransformNodeReadMethod readNode; */
612 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
613 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
614 NULL, /* xmlSecTransformSetKeyMethod setKey; */
615 NULL, /* xmlSecTransformValidateMethod validate; */
616 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
617 NULL, /* xmlSecTransformPushBinMethod pushBin; */
618 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
619 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
620 NULL, /* xmlSecTransformPopXmlMethod popXml; */
621 NULL, /* xmlSecTransformExecuteMethod execute; */
622
623 NULL, /* void* reserved0; */
624 NULL, /* void* reserved1; */
625 };
626
627 /**
628 * xmlSecTransformExclC14NGetKlass:
629 *
630 * Exclusive canoncicalization that omits comments transform klass
631 * (http://www.w3.org/TR/xml-exc-c14n/).
632 *
633 * Returns: exclusive c14n transform id.
634 */
635 xmlSecTransformId
xmlSecTransformExclC14NGetKlass(void)636 xmlSecTransformExclC14NGetKlass(void) {
637 return(&xmlSecTransformExclC14NKlass);
638 }
639
640 /***************************************************************************
641 *
642 * Excl C14N With Comments
643 *
644 ***************************************************************************/
645 static xmlSecTransformKlass xmlSecTransformExclC14NWithCommentsKlass = {
646 /* klass/object sizes */
647 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
648 xmlSecTransformC14NSize, /* xmlSecSize objSize */
649
650 xmlSecNameExcC14NWithComments, /* const xmlChar* name; */
651 xmlSecHrefExcC14NWithComments, /* const xmlChar* href; */
652 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
653 /* xmlSecAlgorithmUsage usage; */
654
655 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
656 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
657 xmlSecTransformC14NNodeRead, /* xmlSecTransformNodeReadMethod readNode; */
658 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
659 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
660 NULL, /* xmlSecTransformSetKeyMethod setKey; */
661 NULL, /* xmlSecTransformValidateMethod validate; */
662 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
663 NULL, /* xmlSecTransformPushBinMethod pushBin; */
664 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
665 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
666 NULL, /* xmlSecTransformPopXmlMethod popXml; */
667 NULL, /* xmlSecTransformExecuteMethod execute; */
668
669 NULL, /* void* reserved0; */
670 NULL, /* void* reserved1; */
671 };
672
673 /**
674 * xmlSecTransformExclC14NWithCommentsGetKlass:
675 *
676 * Exclusive canoncicalization that includes comments transform klass
677 * (http://www.w3.org/TR/xml-exc-c14n/).
678 *
679 * Returns: exclusive c14n with comments transform id.
680 */
681 xmlSecTransformId
xmlSecTransformExclC14NWithCommentsGetKlass(void)682 xmlSecTransformExclC14NWithCommentsGetKlass(void) {
683 return(&xmlSecTransformExclC14NWithCommentsKlass);
684 }
685
686 /***************************************************************************
687 *
688 * Remove XML tags C14N
689 *
690 ***************************************************************************/
691 static xmlSecTransformKlass xmlSecTransformRemoveXmlTagsC14NKlass = {
692 /* klass/object sizes */
693 sizeof(xmlSecTransformKlass), /* xmlSecSize klassSize */
694 xmlSecTransformC14NSize, /* xmlSecSize objSize */
695
696 BAD_CAST "remove-xml-tags-transform", /* const xmlChar* name; */
697 NULL, /* const xmlChar* href; */
698 xmlSecTransformUsageC14NMethod | xmlSecTransformUsageDSigTransform,
699 /* xmlSecAlgorithmUsage usage; */
700
701 xmlSecTransformC14NInitialize, /* xmlSecTransformInitializeMethod initialize; */
702 xmlSecTransformC14NFinalize, /* xmlSecTransformFinalizeMethod finalize; */
703 NULL, /* xmlSecTransformNodeReadMethod readNode; */
704 NULL, /* xmlSecTransformNodeWriteMethod writeNode; */
705 NULL, /* xmlSecTransformSetKeyReqMethod setKeyReq; */
706 NULL, /* xmlSecTransformSetKeyMethod setKey; */
707 NULL, /* xmlSecTransformValidateMethod validate; */
708 xmlSecTransformDefaultGetDataType, /* xmlSecTransformGetDataTypeMethod getDataType; */
709 NULL, /* xmlSecTransformPushBinMethod pushBin; */
710 xmlSecTransformC14NPopBin, /* xmlSecTransformPopBinMethod popBin; */
711 xmlSecTransformC14NPushXml, /* xmlSecTransformPushXmlMethod pushXml; */
712 NULL, /* xmlSecTransformPopXmlMethod popXml; */
713 NULL, /* xmlSecTransformExecuteMethod execute; */
714
715 NULL, /* void* reserved0; */
716 NULL, /* void* reserved1; */
717 };
718
719 /**
720 * xmlSecTransformRemoveXmlTagsC14NGetKlass:
721 *
722 * The "remove xml tags" transform klass (http://www.w3.org/TR/xmldsig-core/#sec-Base-64):
723 * Base64 transform requires an octet stream for input. If an XPath node-set
724 * (or sufficiently functional alternative) is given as input, then it is
725 * converted to an octet stream by performing operations logically equivalent
726 * to 1) applying an XPath transform with expression self::text(), then 2)
727 * taking the string-value of the node-set. Thus, if an XML element is
728 * identified by a barename XPointer in the Reference URI, and its content
729 * consists solely of base64 encoded character data, then this transform
730 * automatically strips away the start and end tags of the identified element
731 * and any of its descendant elements as well as any descendant comments and
732 * processing instructions. The output of this transform is an octet stream.
733 *
734 * Returns: "remove xml tags" transform id.
735 */
736 xmlSecTransformId
xmlSecTransformRemoveXmlTagsC14NGetKlass(void)737 xmlSecTransformRemoveXmlTagsC14NGetKlass(void) {
738 return(&xmlSecTransformRemoveXmlTagsC14NKlass);
739 }
740
741