src/app.c

   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-2003 Aleksey Sanin <aleksey@aleksey.com>
   9  */
  10 #include "globals.h"
  11
  12 #ifndef XMLSEC_NO_CRYPTO_DYNAMIC_LOADING
  13
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <stdarg.h>
  17 #include <string.h>
  18 #include <time.h>
  19
  20 #include <libxml/tree.h>
  21
  22 #include <xmlsec/xmlsec.h>
  23 #include <xmlsec/app.h>
  24 #include <xmlsec/list.h>
  25 #include <xmlsec/keysdata.h>
  26 #include <xmlsec/keys.h>
  27 #include <xmlsec/keysmngr.h>
  28 #include <xmlsec/transforms.h>
  29 #include <xmlsec/private.h>
  30 #include <xmlsec/errors.h>
  31
  32
  33 /******************************************************************************
  34  *
  35  * Crypto Init/shutdown
  36  *
  37  *****************************************************************************/
  38 /**
  39  * xmlSecCryptoInit:
  40  *
  41  * XMLSec library specific crypto engine initialization.
  42  *
  43  * Returns: 0 on success or a negative value otherwise.
  44  */
  45 int
  46 xmlSecCryptoInit(void) {
  47     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoInit == NULL)) {
  48         xmlSecError(XMLSEC_ERRORS_HERE,
  49                     NULL,
  50                     "cryptoInit",
  51                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
  52                     XMLSEC_ERRORS_NO_MESSAGE);
  53         return(-1);
  54     }
  55
  56     return(xmlSecCryptoDLGetFunctions()->cryptoInit());
  57 }
  58
  59 /**
  60  * xmlSecCryptoShutdown:
  61  *
  62  * XMLSec library specific crypto engine shutdown.
  63  *
  64  * Returns: 0 on success or a negative value otherwise.
  65  */
  66 int
  67 xmlSecCryptoShutdown(void) {
  68     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoShutdown == NULL)) {
  69         xmlSecError(XMLSEC_ERRORS_HERE,
  70                     NULL,
  71                     "cryptoShutdown",
  72                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
  73                     XMLSEC_ERRORS_NO_MESSAGE);
  74         return(-1);
  75     }
  76
  77     return(xmlSecCryptoDLGetFunctions()->cryptoShutdown());
  78 }
  79
  80 /**
  81  * xmlSecCryptoKeysMngrInit:
  82  * @mngr:               the pointer to keys manager.
  83  *
  84  * Adds crypto specific key data stores in keys manager.
  85  *
  86  * Returns: 0 on success or a negative value otherwise.
  87  */
  88 int
  89 xmlSecCryptoKeysMngrInit(xmlSecKeysMngrPtr mngr) {
  90     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoKeysMngrInit == NULL)) {
  91         xmlSecError(XMLSEC_ERRORS_HERE,
  92                     NULL,
  93                     "cryptoKeysMngrInit",
  94                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
  95                     XMLSEC_ERRORS_NO_MESSAGE);
  96         return(-1);
  97     }
  98
  99     return(xmlSecCryptoDLGetFunctions()->cryptoKeysMngrInit(mngr));
 100 }
 101
 102 /******************************************************************************
 103  *
 104  * Key data ids
 105  *
 106  *****************************************************************************/
 107 /**
 108  * xmlSecKeyDataAesGetKlass:
 109  *
 110  * The AES key data klass.
 111  *
 112  * Returns: AES key data klass or NULL if an error occurs
 113  * (xmlsec-crypto library is not loaded or the AES key data
 114  * klass is not implemented).
 115  */
 116 xmlSecKeyDataId
 117 xmlSecKeyDataAesGetKlass(void) {
 118     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataAesGetKlass == NULL)) {
 119         xmlSecError(XMLSEC_ERRORS_HERE,
 120                     NULL,
 121                     "keyDataAesId",
 122                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 123                     XMLSEC_ERRORS_NO_MESSAGE);
 124         return(xmlSecKeyDataIdUnknown);
 125     }
 126
 127     return(xmlSecCryptoDLGetFunctions()->keyDataAesGetKlass());
 128 }
 129
 130 /**
 131  * xmlSecKeyDataDesGetKlass:
 132  *
 133  * The DES key data klass.
 134  *
 135  * Returns: DES key data klass or NULL if an error occurs
 136  * (xmlsec-crypto library is not loaded or the DES key data
 137  * klass is not implemented).
 138  */
 139 xmlSecKeyDataId
 140 xmlSecKeyDataDesGetKlass(void) {
 141     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataDesGetKlass == NULL)) {
 142         xmlSecError(XMLSEC_ERRORS_HERE,
 143                     NULL,
 144                     "keyDataDesId",
 145                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 146                     XMLSEC_ERRORS_NO_MESSAGE);
 147         return(xmlSecKeyDataIdUnknown);
 148     }
 149
 150     return(xmlSecCryptoDLGetFunctions()->keyDataDesGetKlass());
 151 }
 152
 153 /**
 154  * xmlSecKeyDataDsaGetKlass:
 155  *
 156  * The DSA key data klass.
 157  *
 158  * Returns: DSA key data klass or NULL if an error occurs
 159  * (xmlsec-crypto library is not loaded or the DSA key data
 160  * klass is not implemented).
 161  */
 162 xmlSecKeyDataId
 163 xmlSecKeyDataDsaGetKlass(void) {
 164     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataDsaGetKlass == NULL)) {
 165         xmlSecError(XMLSEC_ERRORS_HERE,
 166                     NULL,
 167                     "keyDataDsaId",
 168                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 169                     XMLSEC_ERRORS_NO_MESSAGE);
 170         return(xmlSecKeyDataIdUnknown);
 171     }
 172
 173     return(xmlSecCryptoDLGetFunctions()->keyDataDsaGetKlass());
 174 }
 175
 176 /**
 177  * xmlSecKeyDataGost2001GetKlass:
 178  *
 179  * The GOST2001 key data klass.
 180  *
 181  * Returns: GOST2001 key data klass or NULL if an error occurs
 182  * (xmlsec-crypto library is not loaded or the GOST2001 key data
 183  * klass is not implemented).
 184  */
 185 xmlSecKeyDataId
 186 xmlSecKeyDataGost2001GetKlass(void) {
 187     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataGost2001GetKlass == NULL)) {
 188         xmlSecError(XMLSEC_ERRORS_HERE,
 189                     NULL,
 190                     "keyDataGost2001Id",
 191                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 192                     XMLSEC_ERRORS_NO_MESSAGE);
 193         return(xmlSecKeyDataIdUnknown);
 194     }
 195
 196     return(xmlSecCryptoDLGetFunctions()->keyDataGost2001GetKlass());
 197 }
 198
 199 /**
 200  * xmlSecKeyDataHmacGetKlass:
 201  *
 202  * The HMAC key data klass.
 203  *
 204  * Returns: HMAC key data klass or NULL if an error occurs
 205  * (xmlsec-crypto library is not loaded or the HMAC key data
 206  * klass is not implemented).
 207  */
 208 xmlSecKeyDataId
 209 xmlSecKeyDataHmacGetKlass(void) {
 210     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataHmacGetKlass == NULL)) {
 211         xmlSecError(XMLSEC_ERRORS_HERE,
 212                     NULL,
 213                     "keyDataHmacId",
 214                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 215                     XMLSEC_ERRORS_NO_MESSAGE);
 216         return(xmlSecKeyDataIdUnknown);
 217     }
 218
 219     return(xmlSecCryptoDLGetFunctions()->keyDataHmacGetKlass());
 220 }
 221
 222 /**
 223  * xmlSecKeyDataRsaGetKlass:
 224  *
 225  * The RSA key data klass.
 226  *
 227  * Returns: RSA key data klass or NULL if an error occurs
 228  * (xmlsec-crypto library is not loaded or the RSA key data
 229  * klass is not implemented).
 230  */
 231 xmlSecKeyDataId
 232 xmlSecKeyDataRsaGetKlass(void) {
 233     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataRsaGetKlass == NULL)) {
 234         xmlSecError(XMLSEC_ERRORS_HERE,
 235                     NULL,
 236                     "keyDataRsaId",
 237                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 238                     XMLSEC_ERRORS_NO_MESSAGE);
 239         return(xmlSecKeyDataIdUnknown);
 240     }
 241
 242     return(xmlSecCryptoDLGetFunctions()->keyDataRsaGetKlass());
 243 }
 244
 245 /**
 246  * xmlSecKeyDataX509GetKlass:
 247  *
 248  * The X509 key data klass.
 249  *
 250  * Returns: X509 key data klass or NULL if an error occurs
 251  * (xmlsec-crypto library is not loaded or the X509 key data
 252  * klass is not implemented).
 253  */
 254 xmlSecKeyDataId
 255 xmlSecKeyDataX509GetKlass(void) {
 256     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataX509GetKlass == NULL)) {
 257         xmlSecError(XMLSEC_ERRORS_HERE,
 258                     NULL,
 259                     "keyDataX509Id",
 260                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 261                     XMLSEC_ERRORS_NO_MESSAGE);
 262         return(xmlSecKeyDataIdUnknown);
 263     }
 264
 265     return(xmlSecCryptoDLGetFunctions()->keyDataX509GetKlass());
 266 }
 267
 268 /**
 269  * xmlSecKeyDataRawX509CertGetKlass:
 270  *
 271  * The raw X509 cert key data klass.
 272  *
 273  * Returns: raw x509 cert key data klass or NULL if an error occurs
 274  * (xmlsec-crypto library is not loaded or the raw X509 cert key data
 275  * klass is not implemented).
 276  */
 277 xmlSecKeyDataId
 278 xmlSecKeyDataRawX509CertGetKlass(void) {
 279     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->keyDataRawX509CertGetKlass == NULL)) {
 280         xmlSecError(XMLSEC_ERRORS_HERE,
 281                     NULL,
 282                     "keyDataRawX509CertId",
 283                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 284                     XMLSEC_ERRORS_NO_MESSAGE);
 285         return(xmlSecKeyDataIdUnknown);
 286     }
 287
 288     return(xmlSecCryptoDLGetFunctions()->keyDataRawX509CertGetKlass());
 289 }
 290
 291 /******************************************************************************
 292  *
 293  * Key data store ids
 294  *
 295  *****************************************************************************/
 296 /**
 297  * xmlSecX509StoreGetKlass:
 298  *
 299  * The X509 certificates key data store klass.
 300  *
 301  * Returns: pointer to X509 certificates key data store klass or NULL if
 302  * an error occurs (xmlsec-crypto library is not loaded or the raw X509
 303  * cert key data klass is not implemented).
 304  */
 305 xmlSecKeyDataStoreId
 306 xmlSecX509StoreGetKlass(void) {
 307     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->x509StoreGetKlass == NULL)) {
 308         xmlSecError(XMLSEC_ERRORS_HERE,
 309                     NULL,
 310                     "x509StoreId",
 311                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 312                     XMLSEC_ERRORS_NO_MESSAGE);
 313         return(xmlSecKeyStoreIdUnknown);
 314     }
 315
 316     return(xmlSecCryptoDLGetFunctions()->x509StoreGetKlass());
 317 }
 318
 319 /******************************************************************************
 320  *
 321  * Crypto transforms ids
 322  *
 323  *****************************************************************************/
 324 /**
 325  * xmlSecTransformAes128CbcGetKlass:
 326  *
 327  * AES 128 CBC encryption transform klass.
 328  *
 329  * Returns: pointer to AES 128 CBC encryption transform or NULL if an error
 330  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 331  * implemented).
 332  */
 333 xmlSecTransformId
 334 xmlSecTransformAes128CbcGetKlass(void) {
 335     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformAes128CbcGetKlass == NULL)) {
 336         xmlSecError(XMLSEC_ERRORS_HERE,
 337                     NULL,
 338                     "transformAes128CbcId",
 339                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 340                     XMLSEC_ERRORS_NO_MESSAGE);
 341         return(xmlSecTransformIdUnknown);
 342     }
 343
 344     return(xmlSecCryptoDLGetFunctions()->transformAes128CbcGetKlass());
 345 }
 346
 347 /**
 348  * xmlSecTransformAes192CbcGetKlass:
 349  *
 350  * AES 192 CBC encryption transform klass.
 351  *
 352  * Returns: pointer to AES 192 CBC encryption transform or NULL if an error
 353  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 354  * implemented).
 355  */
 356 xmlSecTransformId
 357 xmlSecTransformAes192CbcGetKlass(void) {
 358     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformAes192CbcGetKlass == NULL)) {
 359         xmlSecError(XMLSEC_ERRORS_HERE,
 360                     NULL,
 361                     "transformAes192CbcId",
 362                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 363                     XMLSEC_ERRORS_NO_MESSAGE);
 364         return(xmlSecTransformIdUnknown);
 365     }
 366
 367     return(xmlSecCryptoDLGetFunctions()->transformAes192CbcGetKlass());
 368 }
 369
 370 /**
 371  * xmlSecTransformAes256CbcGetKlass:
 372  *
 373  * AES 256 CBC encryption transform klass.
 374  *
 375  * Returns: pointer to AES 256 CBC encryption transform or NULL if an error
 376  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 377  * implemented).
 378  */
 379 xmlSecTransformId
 380 xmlSecTransformAes256CbcGetKlass(void) {
 381     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformAes256CbcGetKlass == NULL)) {
 382         xmlSecError(XMLSEC_ERRORS_HERE,
 383                     NULL,
 384                     "transformAes256CbcId",
 385                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 386                     XMLSEC_ERRORS_NO_MESSAGE);
 387         return(xmlSecTransformIdUnknown);
 388     }
 389
 390     return(xmlSecCryptoDLGetFunctions()->transformAes256CbcGetKlass());
 391 }
 392
 393 /**
 394  * xmlSecTransformKWAes128GetKlass:
 395  *
 396  * The AES-128 kew wrapper transform klass.
 397  *
 398  * Returns: AES-128 kew wrapper transform klass or NULL if an error
 399  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 400  * implemented).
 401  */
 402 xmlSecTransformId
 403 xmlSecTransformKWAes128GetKlass(void) {
 404     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformKWAes128GetKlass == NULL)) {
 405         xmlSecError(XMLSEC_ERRORS_HERE,
 406                     NULL,
 407                     "transformKWAes128Id",
 408                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 409                     XMLSEC_ERRORS_NO_MESSAGE);
 410         return(xmlSecTransformIdUnknown);
 411     }
 412
 413     return(xmlSecCryptoDLGetFunctions()->transformKWAes128GetKlass());
 414 }
 415
 416 /**
 417  * xmlSecTransformKWAes192GetKlass:
 418  *
 419  * The AES-192 kew wrapper transform klass.
 420  *
 421  * Returns: AES-192 kew wrapper transform klass or NULL if an error
 422  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 423  * implemented).
 424  */
 425 xmlSecTransformId
 426 xmlSecTransformKWAes192GetKlass(void) {
 427     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformKWAes192GetKlass == NULL)) {
 428         xmlSecError(XMLSEC_ERRORS_HERE,
 429                     NULL,
 430                     "transformKWAes192Id",
 431                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 432                     XMLSEC_ERRORS_NO_MESSAGE);
 433         return(xmlSecTransformIdUnknown);
 434     }
 435
 436     return(xmlSecCryptoDLGetFunctions()->transformKWAes192GetKlass());
 437 }
 438
 439 /**
 440  * xmlSecTransformKWAes256GetKlass:
 441  *
 442  * The AES-256 kew wrapper transform klass.
 443  *
 444  * Returns: AES-256 kew wrapper transform klass or NULL if an error
 445  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 446  * implemented).
 447  */
 448 xmlSecTransformId
 449 xmlSecTransformKWAes256GetKlass(void) {
 450     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformKWAes256GetKlass == NULL)) {
 451         xmlSecError(XMLSEC_ERRORS_HERE,
 452                     NULL,
 453                     "transformKWAes256Id",
 454                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 455                     XMLSEC_ERRORS_NO_MESSAGE);
 456         return(xmlSecTransformIdUnknown);
 457     }
 458
 459     return(xmlSecCryptoDLGetFunctions()->transformKWAes256GetKlass());
 460 }
 461
 462 /**
 463  * xmlSecTransformDes3CbcGetKlass:
 464  *
 465  * Triple DES CBC encryption transform klass.
 466  *
 467  * Returns: pointer to Triple DES encryption transform or NULL if an error
 468  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 469  * implemented).
 470  */
 471 xmlSecTransformId
 472 xmlSecTransformDes3CbcGetKlass(void) {
 473     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformDes3CbcGetKlass == NULL)) {
 474         xmlSecError(XMLSEC_ERRORS_HERE,
 475                     NULL,
 476                     "transformDes3CbcId",
 477                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 478                     XMLSEC_ERRORS_NO_MESSAGE);
 479         return(xmlSecTransformIdUnknown);
 480     }
 481
 482     return(xmlSecCryptoDLGetFunctions()->transformDes3CbcGetKlass());
 483 }
 484
 485 /**
 486  * xmlSecTransformKWDes3GetKlass:
 487  *
 488  * The Triple DES key wrapper transform klass.
 489  *
 490  * Returns: Triple DES key wrapper transform klass or NULL if an error
 491  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 492  * implemented).
 493  */
 494 xmlSecTransformId
 495 xmlSecTransformKWDes3GetKlass(void) {
 496     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformKWDes3GetKlass == NULL)) {
 497         xmlSecError(XMLSEC_ERRORS_HERE,
 498                     NULL,
 499                     "transformKWDes3Id",
 500                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 501                     XMLSEC_ERRORS_NO_MESSAGE);
 502         return(xmlSecTransformIdUnknown);
 503     }
 504
 505     return(xmlSecCryptoDLGetFunctions()->transformKWDes3GetKlass());
 506 }
 507
 508 /**
 509  * xmlSecTransformDsaSha1GetKlass:
 510  *
 511  * The DSA-SHA1 signature transform klass.
 512  *
 513  * Returns: DSA-SHA1 signature transform klass or NULL if an error
 514  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 515  * implemented).
 516  */
 517 xmlSecTransformId
 518 xmlSecTransformDsaSha1GetKlass(void) {
 519     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformDsaSha1GetKlass == NULL)) {
 520         xmlSecError(XMLSEC_ERRORS_HERE,
 521                     NULL,
 522                     "transformDsaSha1Id",
 523                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 524                     XMLSEC_ERRORS_NO_MESSAGE);
 525         return(xmlSecTransformIdUnknown);
 526     }
 527
 528     return(xmlSecCryptoDLGetFunctions()->transformDsaSha1GetKlass());
 529 }
 530
 531 /**
 532  * xmlSecTransformGost2001GostR3411_94GetKlass:
 533  *
 534  * The GOST2001-GOSTR3411_94 signature transform klass.
 535  *
 536  * Returns: GOST2001-GOSTR3411_94 signature transform klass or NULL if an error
 537  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 538  * implemented).
 539  */
 540 xmlSecTransformId
 541 xmlSecTransformGost2001GostR3411_94GetKlass(void) {
 542     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformGost2001GostR3411_94GetKlass == NULL)) {
 543         xmlSecError(XMLSEC_ERRORS_HERE,
 544                     NULL,
 545                     "transformGost2001GostR3411_94Id",
 546                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 547                     XMLSEC_ERRORS_NO_MESSAGE);
 548         return(xmlSecTransformIdUnknown);
 549     }
 550
 551     return(xmlSecCryptoDLGetFunctions()->transformGost2001GostR3411_94GetKlass());
 552 }
 553
 554 /**
 555  * xmlSecTransformHmacMd5GetKlass:
 556  *
 557  * The HMAC-MD5 transform klass.
 558  *
 559  * Returns: the HMAC-MD5 transform klass or NULL if an error
 560  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 561  * implemented).
 562  */
 563 xmlSecTransformId
 564 xmlSecTransformHmacMd5GetKlass(void) {
 565     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacMd5GetKlass == NULL)) {
 566         xmlSecError(XMLSEC_ERRORS_HERE,
 567                     NULL,
 568                     "transformHmacMd5Id",
 569                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 570                     XMLSEC_ERRORS_NO_MESSAGE);
 571         return(xmlSecTransformIdUnknown);
 572     }
 573
 574     return(xmlSecCryptoDLGetFunctions()->transformHmacMd5GetKlass());
 575 }
 576
 577 /**
 578  * xmlSecTransformHmacRipemd160GetKlass:
 579  *
 580  * The HMAC-RIPEMD160 transform klass.
 581  *
 582  * Returns: the HMAC-RIPEMD160 transform klass or NULL if an error
 583  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 584  * implemented).
 585  */
 586 xmlSecTransformId
 587 xmlSecTransformHmacRipemd160GetKlass(void) {
 588     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacRipemd160GetKlass == NULL)) {
 589         xmlSecError(XMLSEC_ERRORS_HERE,
 590                     NULL,
 591                     "transformHmacRipemd160Id",
 592                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 593                     XMLSEC_ERRORS_NO_MESSAGE);
 594         return(xmlSecTransformIdUnknown);
 595     }
 596
 597     return(xmlSecCryptoDLGetFunctions()->transformHmacRipemd160GetKlass());
 598 }
 599
 600 /**
 601  * xmlSecTransformHmacSha1GetKlass:
 602  *
 603  * The HMAC-SHA1 transform klass.
 604  *
 605  * Returns: the HMAC-SHA1 transform klass or NULL if an error
 606  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 607  * implemented).
 608  */
 609 xmlSecTransformId
 610 xmlSecTransformHmacSha1GetKlass(void) {
 611     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacSha1GetKlass == NULL)) {
 612         xmlSecError(XMLSEC_ERRORS_HERE,
 613                     NULL,
 614                     "transformHmacSha1Id",
 615                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 616                     XMLSEC_ERRORS_NO_MESSAGE);
 617         return(xmlSecTransformIdUnknown);
 618     }
 619
 620     return(xmlSecCryptoDLGetFunctions()->transformHmacSha1GetKlass());
 621 }
 622
 623 /**
 624  * xmlSecTransformHmacSha224GetKlass:
 625  *
 626  * The HMAC-SHA224 transform klass.
 627  *
 628  * Returns: the HMAC-SHA224 transform klass or NULL if an error
 629  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 630  * implemented).
 631  */
 632 xmlSecTransformId
 633 xmlSecTransformHmacSha224GetKlass(void) {
 634     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacSha224GetKlass == NULL)) {
 635         xmlSecError(XMLSEC_ERRORS_HERE,
 636                     NULL,
 637                     "transformHmacSha224Id",
 638                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 639                     XMLSEC_ERRORS_NO_MESSAGE);
 640         return(xmlSecTransformIdUnknown);
 641     }
 642
 643     return(xmlSecCryptoDLGetFunctions()->transformHmacSha224GetKlass());
 644 }
 645
 646 /**
 647  * xmlSecTransformHmacSha256GetKlass:
 648  *
 649  * The HMAC-SHA256 transform klass.
 650  *
 651  * Returns: the HMAC-SHA256 transform klass or NULL if an error
 652  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 653  * implemented).
 654  */
 655 xmlSecTransformId
 656 xmlSecTransformHmacSha256GetKlass(void) {
 657     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacSha256GetKlass == NULL)) {
 658         xmlSecError(XMLSEC_ERRORS_HERE,
 659                     NULL,
 660                     "transformHmacSha256Id",
 661                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 662                     XMLSEC_ERRORS_NO_MESSAGE);
 663         return(xmlSecTransformIdUnknown);
 664     }
 665
 666     return(xmlSecCryptoDLGetFunctions()->transformHmacSha256GetKlass());
 667 }
 668
 669 /**
 670  * xmlSecTransformHmacSha384GetKlass:
 671  *
 672  * The HMAC-SHA384 transform klass.
 673  *
 674  * Returns: the HMAC-SHA384 transform klass or NULL if an error
 675  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 676  * implemented).
 677  */
 678 xmlSecTransformId
 679 xmlSecTransformHmacSha384GetKlass(void) {
 680     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacSha384GetKlass == NULL)) {
 681         xmlSecError(XMLSEC_ERRORS_HERE,
 682                     NULL,
 683                     "transformHmacSha384Id",
 684                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 685                     XMLSEC_ERRORS_NO_MESSAGE);
 686         return(xmlSecTransformIdUnknown);
 687     }
 688
 689     return(xmlSecCryptoDLGetFunctions()->transformHmacSha384GetKlass());
 690 }
 691
 692 /**
 693  * xmlSecTransformHmacSha512GetKlass:
 694  *
 695  * The HMAC-SHA512 transform klass.
 696  *
 697  * Returns: the HMAC-SHA512 transform klass or NULL if an error
 698  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 699  * implemented).
 700  */
 701 xmlSecTransformId
 702 xmlSecTransformHmacSha512GetKlass(void) {
 703     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformHmacSha512GetKlass == NULL)) {
 704         xmlSecError(XMLSEC_ERRORS_HERE,
 705                     NULL,
 706                     "transformHmacSha512Id",
 707                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 708                     XMLSEC_ERRORS_NO_MESSAGE);
 709         return(xmlSecTransformIdUnknown);
 710     }
 711
 712     return(xmlSecCryptoDLGetFunctions()->transformHmacSha512GetKlass());
 713 }
 714
 715 /**
 716  * xmlSecTransformMd5GetKlass:
 717  *
 718  * MD5 digest transform klass.
 719  *
 720  * Returns: pointer to MD5 digest transform klass or NULL if an error
 721  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 722  * implemented).
 723  */
 724 xmlSecTransformId
 725 xmlSecTransformMd5GetKlass(void) {
 726     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformMd5GetKlass == NULL)) {
 727         xmlSecError(XMLSEC_ERRORS_HERE,
 728                     NULL,
 729                     "transformMd5Id",
 730                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 731                     XMLSEC_ERRORS_NO_MESSAGE);
 732         return(xmlSecTransformIdUnknown);
 733     }
 734
 735     return(xmlSecCryptoDLGetFunctions()->transformMd5GetKlass());
 736 }
 737
 738 /**
 739  * xmlSecTransformRipemd160GetKlass:
 740  *
 741  * RIPEMD-160 digest transform klass.
 742  *
 743  * Returns: pointer to RIPEMD-160 digest transform klass or NULL if an error
 744  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 745  * implemented).
 746  */
 747 xmlSecTransformId
 748 xmlSecTransformRipemd160GetKlass(void) {
 749     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRipemd160GetKlass == NULL)) {
 750         xmlSecError(XMLSEC_ERRORS_HERE,
 751                     NULL,
 752                     "transformRipemd160Id",
 753                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 754                     XMLSEC_ERRORS_NO_MESSAGE);
 755         return(xmlSecTransformIdUnknown);
 756     }
 757
 758     return(xmlSecCryptoDLGetFunctions()->transformRipemd160GetKlass());
 759 }
 760
 761 /**
 762  * xmlSecTransformRsaMd5GetKlass:
 763  *
 764  * The RSA-MD5 signature transform klass.
 765  *
 766  * Returns: RSA-MD5 signature transform klass or NULL if an error
 767  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 768  * implemented).
 769  */
 770 xmlSecTransformId
 771 xmlSecTransformRsaMd5GetKlass(void) {
 772     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaMd5GetKlass == NULL)) {
 773         xmlSecError(XMLSEC_ERRORS_HERE,
 774                     NULL,
 775                     "transformRsaMd5Id",
 776                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 777                     XMLSEC_ERRORS_NO_MESSAGE);
 778         return(xmlSecTransformIdUnknown);
 779     }
 780
 781     return(xmlSecCryptoDLGetFunctions()->transformRsaMd5GetKlass());
 782 }
 783
 784 /**
 785  * xmlSecTransformRsaRipemd160GetKlass:
 786  *
 787  * The RSA-RIPEMD160 signature transform klass.
 788  *
 789  * Returns: RSA-RIPEMD160 signature transform klass or NULL if an error
 790  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 791  * implemented).
 792  */
 793 xmlSecTransformId
 794 xmlSecTransformRsaRipemd160GetKlass(void) {
 795     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaRipemd160GetKlass == NULL)) {
 796         xmlSecError(XMLSEC_ERRORS_HERE,
 797                     NULL,
 798                     "transformRsaRipemd160Id",
 799                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 800                     XMLSEC_ERRORS_NO_MESSAGE);
 801         return(xmlSecTransformIdUnknown);
 802     }
 803
 804     return(xmlSecCryptoDLGetFunctions()->transformRsaRipemd160GetKlass());
 805 }
 806
 807 /**
 808  * xmlSecTransformRsaSha1GetKlass:
 809  *
 810  * The RSA-SHA1 signature transform klass.
 811  *
 812  * Returns: RSA-SHA1 signature transform klass or NULL if an error
 813  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 814  * implemented).
 815  */
 816 xmlSecTransformId
 817 xmlSecTransformRsaSha1GetKlass(void) {
 818     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaSha1GetKlass == NULL)) {
 819         xmlSecError(XMLSEC_ERRORS_HERE,
 820                     NULL,
 821                     "transformRsaSha1Id",
 822                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 823                     XMLSEC_ERRORS_NO_MESSAGE);
 824         return(xmlSecTransformIdUnknown);
 825     }
 826
 827     return(xmlSecCryptoDLGetFunctions()->transformRsaSha1GetKlass());
 828 }
 829
 830 /**
 831  * xmlSecTransformRsaSha224GetKlass:
 832  *
 833  * The RSA-SHA224 signature transform klass.
 834  *
 835  * Returns: RSA-SHA224 signature transform klass or NULL if an error
 836  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 837  * implemented).
 838  */
 839 xmlSecTransformId
 840 xmlSecTransformRsaSha224GetKlass(void) {
 841     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaSha224GetKlass == NULL)) {
 842         xmlSecError(XMLSEC_ERRORS_HERE,
 843                     NULL,
 844                     "transformRsaSha224Id",
 845                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 846                     XMLSEC_ERRORS_NO_MESSAGE);
 847         return(xmlSecTransformIdUnknown);
 848     }
 849
 850     return(xmlSecCryptoDLGetFunctions()->transformRsaSha224GetKlass());
 851 }
 852
 853 /**
 854  * xmlSecTransformRsaSha256GetKlass:
 855  *
 856  * The RSA-SHA256 signature transform klass.
 857  *
 858  * Returns: RSA-SHA256 signature transform klass or NULL if an error
 859  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 860  * implemented).
 861  */
 862 xmlSecTransformId
 863 xmlSecTransformRsaSha256GetKlass(void) {
 864     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaSha256GetKlass == NULL)) {
 865         xmlSecError(XMLSEC_ERRORS_HERE,
 866                     NULL,
 867                     "transformRsaSha256Id",
 868                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 869                     XMLSEC_ERRORS_NO_MESSAGE);
 870         return(xmlSecTransformIdUnknown);
 871     }
 872
 873     return(xmlSecCryptoDLGetFunctions()->transformRsaSha256GetKlass());
 874 }
 875
 876 /**
 877  * xmlSecTransformRsaSha384GetKlass:
 878  *
 879  * The RSA-SHA384 signature transform klass.
 880  *
 881  * Returns: RSA-SHA384 signature transform klass or NULL if an error
 882  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 883  * implemented).
 884  */
 885 xmlSecTransformId
 886 xmlSecTransformRsaSha384GetKlass(void) {
 887     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaSha384GetKlass == NULL)) {
 888         xmlSecError(XMLSEC_ERRORS_HERE,
 889                     NULL,
 890                     "transformRsaSha384Id",
 891                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 892                     XMLSEC_ERRORS_NO_MESSAGE);
 893         return(xmlSecTransformIdUnknown);
 894     }
 895
 896     return(xmlSecCryptoDLGetFunctions()->transformRsaSha384GetKlass());
 897 }
 898
 899 /**
 900  * xmlSecTransformRsaSha512GetKlass:
 901  *
 902  * The RSA-SHA512 signature transform klass.
 903  *
 904  * Returns: RSA-SHA512 signature transform klass or NULL if an error
 905  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 906  * implemented).
 907  */
 908 xmlSecTransformId
 909 xmlSecTransformRsaSha512GetKlass(void) {
 910     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaSha512GetKlass == NULL)) {
 911         xmlSecError(XMLSEC_ERRORS_HERE,
 912                     NULL,
 913                     "transformRsaSha512Id",
 914                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 915                     XMLSEC_ERRORS_NO_MESSAGE);
 916         return(xmlSecTransformIdUnknown);
 917     }
 918
 919     return(xmlSecCryptoDLGetFunctions()->transformRsaSha512GetKlass());
 920 }
 921
 922 /**
 923  * xmlSecTransformRsaPkcs1GetKlass:
 924  *
 925  * The RSA-PKCS1 key transport transform klass.
 926  *
 927  * Returns: RSA-PKCS1 key transport transform klass or NULL if an error
 928  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 929  * implemented).
 930  */
 931 xmlSecTransformId
 932 xmlSecTransformRsaPkcs1GetKlass(void) {
 933     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaPkcs1GetKlass == NULL)) {
 934         xmlSecError(XMLSEC_ERRORS_HERE,
 935                     NULL,
 936                     "transformRsaPkcs1Id",
 937                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 938                     XMLSEC_ERRORS_NO_MESSAGE);
 939         return(xmlSecTransformIdUnknown);
 940     }
 941
 942     return(xmlSecCryptoDLGetFunctions()->transformRsaPkcs1GetKlass());
 943 }
 944
 945 /**
 946  * xmlSecTransformRsaOaepGetKlass:
 947  *
 948  * The RSA-OAEP key transport transform klass.
 949  *
 950  * Returns: RSA-OAEP key transport transform klass or NULL if an error
 951  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 952  * implemented).
 953  */
 954 xmlSecTransformId
 955 xmlSecTransformRsaOaepGetKlass(void) {
 956     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformRsaOaepGetKlass == NULL)) {
 957         xmlSecError(XMLSEC_ERRORS_HERE,
 958                     NULL,
 959                     "transformRsaOaepId",
 960                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 961                     XMLSEC_ERRORS_NO_MESSAGE);
 962         return(xmlSecTransformIdUnknown);
 963     }
 964
 965     return(xmlSecCryptoDLGetFunctions()->transformRsaOaepGetKlass());
 966 }
 967
 968 /**
 969  * xmlSecTransformGostR3411_94GetKlass:
 970  *
 971  * GOSTR3411_94 digest transform klass.
 972  *
 973  * Returns: pointer to GOSTR3411_94 digest transform klass or NULL if an error
 974  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 975  * implemented).
 976  */
 977 xmlSecTransformId
 978 xmlSecTransformGostR3411_94GetKlass(void) {
 979     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformGostR3411_94GetKlass == NULL)) {
 980         xmlSecError(XMLSEC_ERRORS_HERE,
 981                     NULL,
 982                     "transformGostR3411_94Id",
 983                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
 984                     XMLSEC_ERRORS_NO_MESSAGE);
 985         return(xmlSecTransformIdUnknown);
 986     }
 987
 988     return(xmlSecCryptoDLGetFunctions()->transformGostR3411_94GetKlass());
 989 }
 990
 991
 992 /**
 993  * xmlSecTransformSha1GetKlass:
 994  *
 995  * SHA-1 digest transform klass.
 996  *
 997  * Returns: pointer to SHA-1 digest transform klass or NULL if an error
 998  * occurs (the xmlsec-crypto library is not loaded or this transform is not
 999  * implemented).
1000  */
1001 xmlSecTransformId
1002 xmlSecTransformSha1GetKlass(void) {
1003     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformSha1GetKlass == NULL)) {
1004         xmlSecError(XMLSEC_ERRORS_HERE,
1005                     NULL,
1006                     "transformSha1Id",
1007                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1008                     XMLSEC_ERRORS_NO_MESSAGE);
1009         return(xmlSecTransformIdUnknown);
1010     }
1011
1012     return(xmlSecCryptoDLGetFunctions()->transformSha1GetKlass());
1013 }
1014
1015 /**
1016  * xmlSecTransformSha224GetKlass:
1017  *
1018  * SHA224 digest transform klass.
1019  *
1020  * Returns: pointer to SHA224 digest transform klass or NULL if an error
1021  * occurs (the xmlsec-crypto library is not loaded or this transform is not
1022  * implemented).
1023  */
1024 xmlSecTransformId
1025 xmlSecTransformSha224GetKlass(void) {
1026     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformSha224GetKlass == NULL)) {
1027         xmlSecError(XMLSEC_ERRORS_HERE,
1028                     NULL,
1029                     "transformSha224Id",
1030                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1031                     XMLSEC_ERRORS_NO_MESSAGE);
1032         return(xmlSecTransformIdUnknown);
1033     }
1034
1035     return(xmlSecCryptoDLGetFunctions()->transformSha224GetKlass());
1036 }
1037
1038 /**
1039  * xmlSecTransformSha256GetKlass:
1040  *
1041  * SHA256 digest transform klass.
1042  *
1043  * Returns: pointer to SHA256 digest transform klass or NULL if an error
1044  * occurs (the xmlsec-crypto library is not loaded or this transform is not
1045  * implemented).
1046  */
1047 xmlSecTransformId
1048 xmlSecTransformSha256GetKlass(void) {
1049     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformSha256GetKlass == NULL)) {
1050         xmlSecError(XMLSEC_ERRORS_HERE,
1051                     NULL,
1052                     "transformSha256Id",
1053                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1054                     XMLSEC_ERRORS_NO_MESSAGE);
1055         return(xmlSecTransformIdUnknown);
1056     }
1057
1058     return(xmlSecCryptoDLGetFunctions()->transformSha256GetKlass());
1059 }
1060
1061 /**
1062  * xmlSecTransformSha384GetKlass:
1063  *
1064  * SHA384 digest transform klass.
1065  *
1066  * Returns: pointer to SHA384 digest transform klass or NULL if an error
1067  * occurs (the xmlsec-crypto library is not loaded or this transform is not
1068  * implemented).
1069  */
1070 xmlSecTransformId
1071 xmlSecTransformSha384GetKlass(void) {
1072     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformSha384GetKlass == NULL)) {
1073         xmlSecError(XMLSEC_ERRORS_HERE,
1074                     NULL,
1075                     "transformSha384Id",
1076                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1077                     XMLSEC_ERRORS_NO_MESSAGE);
1078         return(xmlSecTransformIdUnknown);
1079     }
1080
1081     return(xmlSecCryptoDLGetFunctions()->transformSha384GetKlass());
1082 }
1083
1084 /**
1085  * xmlSecTransformSha512GetKlass:
1086  *
1087  * SHA512 digest transform klass.
1088  *
1089  * Returns: pointer to SHA512 digest transform klass or NULL if an error
1090  * occurs (the xmlsec-crypto library is not loaded or this transform is not
1091  * implemented).
1092  */
1093 xmlSecTransformId
1094 xmlSecTransformSha512GetKlass(void) {
1095     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->transformSha512GetKlass == NULL)) {
1096         xmlSecError(XMLSEC_ERRORS_HERE,
1097                     NULL,
1098                     "transformSha512Id",
1099                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1100                     XMLSEC_ERRORS_NO_MESSAGE);
1101         return(xmlSecTransformIdUnknown);
1102     }
1103
1104     return(xmlSecCryptoDLGetFunctions()->transformSha512GetKlass());
1105 }
1106
1107 /******************************************************************************
1108  *
1109  * High level routines form xmlsec command line utility
1110  *
1111  *****************************************************************************/
1112 /**
1113  * xmlSecCryptoAppInit:
1114  * @config:             the path to crypto library configuration.
1115  *
1116  * General crypto engine initialization. This function is used
1117  * by XMLSec command line utility and called before
1118  * @xmlSecInit function.
1119  *
1120  * Returns: 0 on success or a negative value otherwise.
1121  */
1122 int
1123 xmlSecCryptoAppInit(const char* config) {
1124     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppInit == NULL)) {
1125         xmlSecError(XMLSEC_ERRORS_HERE,
1126                     NULL,
1127                     "cryptoAppInit",
1128                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1129                     XMLSEC_ERRORS_NO_MESSAGE);
1130         return(-1);
1131     }
1132
1133     return(xmlSecCryptoDLGetFunctions()->cryptoAppInit(config));
1134 }
1135
1136
1137 /**
1138  * xmlSecCryptoAppShutdown:
1139  *
1140  * General crypto engine shutdown. This function is used
1141  * by XMLSec command line utility and called after
1142  * @xmlSecShutdown function.
1143  *
1144  * Returns: 0 on success or a negative value otherwise.
1145  */
1146 int
1147 xmlSecCryptoAppShutdown(void) {
1148     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppShutdown == NULL)) {
1149         xmlSecError(XMLSEC_ERRORS_HERE,
1150                     NULL,
1151                     "cryptoAppShutdown",
1152                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1153                     XMLSEC_ERRORS_NO_MESSAGE);
1154         return(-1);
1155     }
1156
1157     return(xmlSecCryptoDLGetFunctions()->cryptoAppShutdown());
1158 }
1159
1160 /**
1161  * xmlSecCryptoAppDefaultKeysMngrInit:
1162  * @mngr:               the pointer to keys manager.
1163  *
1164  * Initializes @mngr with simple keys store #xmlSecSimpleKeysStoreId
1165  * and a default crypto key data stores.
1166  *
1167  * Returns: 0 on success or a negative value otherwise.
1168  */
1169 int
1170 xmlSecCryptoAppDefaultKeysMngrInit(xmlSecKeysMngrPtr mngr) {
1171     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrInit == NULL)) {
1172         xmlSecError(XMLSEC_ERRORS_HERE,
1173                     NULL,
1174                     "cryptoAppDefaultKeysMngrInit",
1175                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1176                     XMLSEC_ERRORS_NO_MESSAGE);
1177         return(-1);
1178     }
1179
1180     return(xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrInit(mngr));
1181 }
1182
1183 /**
1184  * xmlSecCryptoAppDefaultKeysMngrAdoptKey:
1185  * @mngr:               the pointer to keys manager.
1186  * @key:                the pointer to key.
1187  *
1188  * Adds @key to the keys manager @mngr created with #xmlSecCryptoAppDefaultKeysMngrInit
1189  * function.
1190  *
1191  * Returns: 0 on success or a negative value otherwise.
1192  */
1193 int
1194 xmlSecCryptoAppDefaultKeysMngrAdoptKey(xmlSecKeysMngrPtr mngr, xmlSecKeyPtr key) {
1195     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrAdoptKey == NULL)) {
1196         xmlSecError(XMLSEC_ERRORS_HERE,
1197                     NULL,
1198                     "cryptoAppDefaultKeysMngrAdoptKey",
1199                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1200                     XMLSEC_ERRORS_NO_MESSAGE);
1201         return(-1);
1202     }
1203
1204     return(xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrAdoptKey(mngr, key));
1205 }
1206
1207 /**
1208  * xmlSecCryptoAppDefaultKeysMngrLoad:
1209  * @mngr:               the pointer to keys manager.
1210  * @uri:                the uri.
1211  *
1212  * Loads XML keys file from @uri to the keys manager @mngr created
1213  * with #xmlSecCryptoAppDefaultKeysMngrInit function.
1214  *
1215  * Returns: 0 on success or a negative value otherwise.
1216  */
1217 int
1218 xmlSecCryptoAppDefaultKeysMngrLoad(xmlSecKeysMngrPtr mngr, const char* uri) {
1219     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrLoad == NULL)) {
1220         xmlSecError(XMLSEC_ERRORS_HERE,
1221                     NULL,
1222                     "cryptoAppDefaultKeysMngrLoad",
1223                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1224                     XMLSEC_ERRORS_NO_MESSAGE);
1225         return(-1);
1226     }
1227
1228     return(xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrLoad(mngr, uri));
1229 }
1230
1231 /**
1232  * xmlSecCryptoAppDefaultKeysMngrSave:
1233  * @mngr:               the pointer to keys manager.
1234  * @filename:           the destination filename.
1235  * @type:               the type of keys to save (public/private/symmetric).
1236  *
1237  * Saves keys from @mngr to  XML keys file.
1238  *
1239  * Returns: 0 on success or a negative value otherwise.
1240  */
1241 int
1242 xmlSecCryptoAppDefaultKeysMngrSave(xmlSecKeysMngrPtr mngr, const char* filename,
1243                                    xmlSecKeyDataType type) {
1244     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrSave == NULL)) {
1245         xmlSecError(XMLSEC_ERRORS_HERE,
1246                     NULL,
1247                     "cryptoAppDefaultKeysMngrSave",
1248                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1249                     XMLSEC_ERRORS_NO_MESSAGE);
1250         return(-1);
1251     }
1252
1253     return(xmlSecCryptoDLGetFunctions()->cryptoAppDefaultKeysMngrSave(mngr, filename, type));
1254 }
1255
1256 /**
1257  * xmlSecCryptoAppKeysMngrCertLoad:
1258  * @mngr:               the keys manager.
1259  * @filename:           the certificate file.
1260  * @format:             the certificate file format.
1261  * @type:               the flag that indicates is the certificate in @filename
1262  *                      trusted or not.
1263  *
1264  * Reads cert from @filename and adds to the list of trusted or known
1265  * untrusted certs in @store.
1266  *
1267  * Returns: 0 on success or a negative value otherwise.
1268  */
1269 int
1270 xmlSecCryptoAppKeysMngrCertLoad(xmlSecKeysMngrPtr mngr, const char *filename,
1271                                 xmlSecKeyDataFormat format, xmlSecKeyDataType type) {
1272     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeysMngrCertLoad == NULL)) {
1273         xmlSecError(XMLSEC_ERRORS_HERE,
1274                     NULL,
1275                     "cryptoAppKeysMngrCertLoad",
1276                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1277                     XMLSEC_ERRORS_NO_MESSAGE);
1278         return(-1);
1279     }
1280
1281     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeysMngrCertLoad(mngr, filename, format, type));
1282 }
1283
1284 /**
1285  * xmlSecCryptoAppKeysMngrCertLoadMemory:
1286  * @mngr:               the keys manager.
1287  * @data:               the certificate binary data.
1288  * @dataSize:           the certificate binary data size.
1289  * @format:             the certificate file format.
1290  * @type:               the flag that indicates is the certificate trusted or not.
1291  *
1292  * Reads cert from binary buffer @data and adds to the list of trusted or known
1293  * untrusted certs in @store.
1294  *
1295  * Returns: 0 on success or a negative value otherwise.
1296  */
1297 int
1298 xmlSecCryptoAppKeysMngrCertLoadMemory(xmlSecKeysMngrPtr mngr, const xmlSecByte* data,
1299                                     xmlSecSize dataSize, xmlSecKeyDataFormat format,
1300                                     xmlSecKeyDataType type) {
1301     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeysMngrCertLoadMemory == NULL)) {
1302         xmlSecError(XMLSEC_ERRORS_HERE,
1303                     NULL,
1304                     "cryptoAppKeysMngrCertLoadMemory",
1305                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1306                     XMLSEC_ERRORS_NO_MESSAGE);
1307         return(-1);
1308     }
1309
1310     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeysMngrCertLoadMemory(mngr, data, dataSize, format, type));
1311 }
1312
1313 /**
1314  * xmlSecCryptoAppKeyLoad:
1315  * @filename:           the key filename.
1316  * @format:             the key file format.
1317  * @pwd:                the key file password.
1318  * @pwdCallback:        the key password callback.
1319  * @pwdCallbackCtx:     the user context for password callback.
1320  *
1321  * Reads key from the a file.
1322  *
1323  * Returns: pointer to the key or NULL if an error occurs.
1324  */
1325 xmlSecKeyPtr
1326 xmlSecCryptoAppKeyLoad(const char *filename, xmlSecKeyDataFormat format,
1327                        const char *pwd, void* pwdCallback, void* pwdCallbackCtx) {
1328     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeyLoad == NULL)) {
1329         xmlSecError(XMLSEC_ERRORS_HERE,
1330                     NULL,
1331                     "cryptoAppKeyLoad",
1332                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1333                     XMLSEC_ERRORS_NO_MESSAGE);
1334         return(NULL);
1335     }
1336
1337     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeyLoad(filename, format, pwd, pwdCallback, pwdCallbackCtx));
1338 }
1339
1340 /**
1341  * xmlSecCryptoAppKeyLoadMemory:
1342  * @data:               the binary key data.
1343  * @dataSize:           the size of binary key.
1344  * @format:             the key file format.
1345  * @pwd:                the key file password.
1346  * @pwdCallback:        the key password callback.
1347  * @pwdCallbackCtx:     the user context for password callback.
1348  *
1349  * Reads key from the memory buffer.
1350  *
1351  * Returns: pointer to the key or NULL if an error occurs.
1352  */
1353 xmlSecKeyPtr
1354 xmlSecCryptoAppKeyLoadMemory(const xmlSecByte* data, xmlSecSize dataSize, xmlSecKeyDataFormat format,
1355                        const char *pwd, void* pwdCallback, void* pwdCallbackCtx) {
1356     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeyLoadMemory == NULL)) {
1357         xmlSecError(XMLSEC_ERRORS_HERE,
1358                     NULL,
1359                     "cryptoAppKeyLoadMemory",
1360                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1361                     XMLSEC_ERRORS_NO_MESSAGE);
1362         return(NULL);
1363     }
1364
1365     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeyLoadMemory(data, dataSize, format, pwd, pwdCallback, pwdCallbackCtx));
1366 }
1367
1368 /**
1369  * xmlSecCryptoAppPkcs12Load:
1370  * @filename:           the PKCS12 key filename.
1371  * @pwd:                the PKCS12 file password.
1372  * @pwdCallback:        the password callback.
1373  * @pwdCallbackCtx:     the user context for password callback.
1374  *
1375  * Reads key and all associated certificates from the PKCS12 file.
1376  * For uniformity, call xmlSecCryptoAppKeyLoad instead of this function. Pass
1377  * in format=xmlSecKeyDataFormatPkcs12.
1378  *
1379  * Returns: pointer to the key or NULL if an error occurs.
1380  */
1381 xmlSecKeyPtr
1382 xmlSecCryptoAppPkcs12Load(const char* filename, const char* pwd, void* pwdCallback,
1383                           void* pwdCallbackCtx) {
1384     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppPkcs12Load == NULL)) {
1385         xmlSecError(XMLSEC_ERRORS_HERE,
1386                     NULL,
1387                     "cryptoAppPkcs12Load",
1388                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1389                     XMLSEC_ERRORS_NO_MESSAGE);
1390         return(NULL);
1391     }
1392
1393     return(xmlSecCryptoDLGetFunctions()->cryptoAppPkcs12Load(filename, pwd, pwdCallback, pwdCallbackCtx));
1394 }
1395
1396 /**
1397  * xmlSecCryptoAppPkcs12LoadMemory:
1398  * @data:               the PKCS12 binary data.
1399  * @dataSize:           the PKCS12 binary data size.
1400  * @pwd:                the PKCS12 file password.
1401  * @pwdCallback:        the password callback.
1402  * @pwdCallbackCtx:     the user context for password callback.
1403  *
1404  * Reads key and all associated certificates from the PKCS12 data in memory buffer.
1405  * For uniformity, call xmlSecCryptoAppKeyLoadMemory instead of this function. Pass
1406  * in format=xmlSecKeyDataFormatPkcs12.
1407  *
1408  * Returns: pointer to the key or NULL if an error occurs.
1409  */
1410 xmlSecKeyPtr
1411 xmlSecCryptoAppPkcs12LoadMemory(const xmlSecByte* data, xmlSecSize dataSize,
1412                            const char *pwd, void* pwdCallback,
1413                            void* pwdCallbackCtx) {
1414     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppPkcs12LoadMemory == NULL)) {
1415         xmlSecError(XMLSEC_ERRORS_HERE,
1416                     NULL,
1417                     "cryptoAppPkcs12LoadMemory",
1418                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1419                     XMLSEC_ERRORS_NO_MESSAGE);
1420         return(NULL);
1421     }
1422
1423     return(xmlSecCryptoDLGetFunctions()->cryptoAppPkcs12LoadMemory(data, dataSize, pwd, pwdCallback, pwdCallbackCtx));
1424 }
1425
1426 /**
1427  * xmlSecCryptoAppKeyCertLoad:
1428  * @key:                the pointer to key.
1429  * @filename:           the certificate filename.
1430  * @format:             the certificate file format.
1431  *
1432  * Reads the certificate from $@filename and adds it to key.
1433  *
1434  * Returns: 0 on success or a negative value otherwise.
1435  */
1436 int
1437 xmlSecCryptoAppKeyCertLoad(xmlSecKeyPtr key, const char* filename, xmlSecKeyDataFormat format) {
1438     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeyCertLoad == NULL)) {
1439         xmlSecError(XMLSEC_ERRORS_HERE,
1440                     NULL,
1441                     "cryptoAppKeyCertLoad",
1442                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1443                     XMLSEC_ERRORS_NO_MESSAGE);
1444         return(-1);
1445     }
1446
1447     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeyCertLoad(key, filename, format));
1448 }
1449
1450 /**
1451  * xmlSecCryptoAppKeyCertLoadMemory:
1452  * @key:                the pointer to key.
1453  * @data:               the certificate binary data.
1454  * @dataSize:           the certificate binary data size.
1455  * @format:             the certificate file format.
1456  *
1457  * Reads the certificate from memory buffer and adds it to key.
1458  *
1459  * Returns: 0 on success or a negative value otherwise.
1460  */
1461 int
1462 xmlSecCryptoAppKeyCertLoadMemory(xmlSecKeyPtr key, const xmlSecByte* data, xmlSecSize dataSize,
1463                                 xmlSecKeyDataFormat format) {
1464     if((xmlSecCryptoDLGetFunctions() == NULL) || (xmlSecCryptoDLGetFunctions()->cryptoAppKeyCertLoadMemory == NULL)) {
1465         xmlSecError(XMLSEC_ERRORS_HERE,
1466                     NULL,
1467                     "cryptoAppKeyCertLoadMemory",
1468                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1469                     XMLSEC_ERRORS_NO_MESSAGE);
1470         return(-1);
1471     }
1472
1473     return(xmlSecCryptoDLGetFunctions()->cryptoAppKeyCertLoadMemory(key, data, dataSize, format));
1474 }
1475
1476 /**
1477  * xmlSecCryptoAppGetDefaultPwdCallback:
1478  *
1479  * Gets default password callback.
1480  *
1481  * Returns: default password callback.
1482  */
1483 void*
1484 xmlSecCryptoAppGetDefaultPwdCallback(void) {
1485     if(xmlSecCryptoDLGetFunctions() == NULL) {
1486         xmlSecError(XMLSEC_ERRORS_HERE,
1487                     NULL,
1488                     NULL,
1489                     XMLSEC_ERRORS_R_NOT_IMPLEMENTED,
1490                     XMLSEC_ERRORS_NO_MESSAGE);
1491         return(NULL);
1492     }
1493
1494     return(xmlSecCryptoDLGetFunctions()->cryptoAppDefaultPwdCallback);
1495 }
1496
1497 #endif /* XMLSEC_NO_CRYPTO_DYNAMIC_LOADING */
1498