src/c14n.c

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