src/openssl/digests.c

   1 /**
   2  * XMLSec library
   3  *
   4  * This is free software; see Copyright file in the source
   5  * distribution for preciese wording.
   6  *
   7  * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
   8  */
   9 #include "globals.h"
  10
  11 #include <string.h>
  12
  13 #include <openssl/evp.h>
  14
  15 #include <xmlsec/xmlsec.h>
  16 #include <xmlsec/keys.h>
  17 #include <xmlsec/transforms.h>
  18 #include <xmlsec/errors.h>
  19
  20 #include <xmlsec/openssl/crypto.h>
  21 #include <xmlsec/openssl/evp.h>
  22
  23 /**************************************************************************
  24  *
  25  * Internal OpenSSL Digest CTX
  26  *
  27  *****************************************************************************/
  28 typedef struct _xmlSecOpenSSLDigestCtx          xmlSecOpenSSLDigestCtx, *xmlSecOpenSSLDigestCtxPtr;
  29 struct _xmlSecOpenSSLDigestCtx {
  30     const EVP_MD*       digest;
  31     EVP_MD_CTX          digestCtx;
  32     xmlSecByte          dgst[EVP_MAX_MD_SIZE];
  33     xmlSecSize          dgstSize;       /* dgst size in bytes */
  34 };
  35
  36 /******************************************************************************
  37  *
  38  * EVP Digest transforms
  39  *
  40  * xmlSecOpenSSLDigestCtx is located after xmlSecTransform
  41  *
  42  *****************************************************************************/
  43 #define xmlSecOpenSSLEvpDigestSize      \
  44     (sizeof(xmlSecTransform) + sizeof(xmlSecOpenSSLDigestCtx))
  45 #define xmlSecOpenSSLEvpDigestGetCtx(transform) \
  46     ((xmlSecOpenSSLDigestCtxPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)))
  47
  48
  49 static int      xmlSecOpenSSLEvpDigestInitialize        (xmlSecTransformPtr transform);
  50 static void     xmlSecOpenSSLEvpDigestFinalize          (xmlSecTransformPtr transform);
  51 static int      xmlSecOpenSSLEvpDigestVerify            (xmlSecTransformPtr transform,
  52                                                          const xmlSecByte* data,
  53                                                          xmlSecSize dataSize,
  54                                                          xmlSecTransformCtxPtr transformCtx);
  55 static int      xmlSecOpenSSLEvpDigestExecute           (xmlSecTransformPtr transform,
  56                                                          int last,
  57                                                          xmlSecTransformCtxPtr transformCtx);
  58 static int      xmlSecOpenSSLEvpDigestCheckId           (xmlSecTransformPtr transform);
  59
  60 static int
  61 xmlSecOpenSSLEvpDigestCheckId(xmlSecTransformPtr transform) {
  62
  63 #ifndef XMLSEC_NO_MD5
  64     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformMd5Id)) {
  65         return(1);
  66     } else
  67 #endif /* XMLSEC_NO_MD5 */
  68
  69 #ifndef XMLSEC_NO_RIPEMD160
  70     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRipemd160Id)) {
  71         return(1);
  72     } else
  73 #endif /* XMLSEC_NO_RIPEMD160 */
  74
  75 #ifndef XMLSEC_NO_SHA1
  76     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha1Id)) {
  77         return(1);
  78     } else
  79 #endif /* XMLSEC_NO_SHA1 */
  80
  81 #ifndef XMLSEC_NO_SHA224
  82     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha224Id)) {
  83         return(1);
  84     } else
  85 #endif /* XMLSEC_NO_SHA224 */
  86
  87 #ifndef XMLSEC_NO_SHA256
  88     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha256Id)) {
  89         return(1);
  90     } else
  91 #endif /* XMLSEC_NO_SHA256 */
  92
  93 #ifndef XMLSEC_NO_SHA384
  94     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha384Id)) {
  95         return(1);
  96     } else
  97 #endif /* XMLSEC_NO_SHA384 */
  98
  99 #ifndef XMLSEC_NO_SHA512
 100     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha512Id)) {
 101         return(1);
 102     } else
 103 #endif /* XMLSEC_NO_SHA512 */
 104
 105
 106     {
 107         return(0);
 108     }
 109
 110     return(0);
 111 }
 112
 113 static int
 114 xmlSecOpenSSLEvpDigestInitialize(xmlSecTransformPtr transform) {
 115     xmlSecOpenSSLDigestCtxPtr ctx;
 116
 117     xmlSecAssert2(xmlSecOpenSSLEvpDigestCheckId(transform), -1);
 118     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLEvpDigestSize), -1);
 119
 120     ctx = xmlSecOpenSSLEvpDigestGetCtx(transform);
 121     xmlSecAssert2(ctx != NULL, -1);
 122
 123     /* initialize context */
 124     memset(ctx, 0, sizeof(xmlSecOpenSSLDigestCtx));
 125
 126 #ifndef XMLSEC_NO_MD5
 127     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformMd5Id)) {
 128         ctx->digest = EVP_md5();
 129     } else
 130 #endif /* XMLSEC_NO_MD5 */
 131
 132 #ifndef XMLSEC_NO_RIPEMD160
 133     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformRipemd160Id)) {
 134         ctx->digest = EVP_ripemd160();
 135     } else
 136 #endif /* XMLSEC_NO_RIPEMD160 */
 137
 138 #ifndef XMLSEC_NO_SHA1
 139     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha1Id)) {
 140         ctx->digest = EVP_sha1();
 141     } else
 142 #endif /* XMLSEC_NO_SHA1 */
 143
 144 #ifndef XMLSEC_NO_SHA224
 145     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha224Id)) {
 146         ctx->digest = EVP_sha224();
 147     } else
 148 #endif /* XMLSEC_NO_SHA224 */
 149
 150 #ifndef XMLSEC_NO_SHA256
 151     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha256Id)) {
 152         ctx->digest = EVP_sha256();
 153     } else
 154 #endif /* XMLSEC_NO_SHA256 */
 155
 156 #ifndef XMLSEC_NO_SHA384
 157     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha384Id)) {
 158         ctx->digest = EVP_sha384();
 159     } else
 160 #endif /* XMLSEC_NO_SHA384 */
 161
 162 #ifndef XMLSEC_NO_SHA512
 163     if(xmlSecTransformCheckId(transform, xmlSecOpenSSLTransformSha512Id)) {
 164         ctx->digest = EVP_sha512();
 165     } else
 166 #endif /* XMLSEC_NO_SHA512 */
 167
 168     {
 169         xmlSecError(XMLSEC_ERRORS_HERE,
 170                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 171                     NULL,
 172                     XMLSEC_ERRORS_R_INVALID_TRANSFORM,
 173                     XMLSEC_ERRORS_NO_MESSAGE);
 174         return(-1);
 175     }
 176
 177 #ifndef XMLSEC_OPENSSL_096
 178     EVP_MD_CTX_init(&(ctx->digestCtx));
 179 #endif /* XMLSEC_OPENSSL_096 */
 180
 181     return(0);
 182 }
 183
 184 static void
 185 xmlSecOpenSSLEvpDigestFinalize(xmlSecTransformPtr transform) {
 186     xmlSecOpenSSLDigestCtxPtr ctx;
 187
 188     xmlSecAssert(xmlSecOpenSSLEvpDigestCheckId(transform));
 189     xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecOpenSSLEvpDigestSize));
 190
 191     ctx = xmlSecOpenSSLEvpDigestGetCtx(transform);
 192     xmlSecAssert(ctx != NULL);
 193
 194 #ifndef XMLSEC_OPENSSL_096
 195     EVP_MD_CTX_cleanup(&(ctx->digestCtx));
 196 #endif /* XMLSEC_OPENSSL_096 */
 197     memset(ctx, 0, sizeof(xmlSecOpenSSLDigestCtx));
 198 }
 199
 200 static int
 201 xmlSecOpenSSLEvpDigestVerify(xmlSecTransformPtr transform,
 202                         const xmlSecByte* data, xmlSecSize dataSize,
 203                         xmlSecTransformCtxPtr transformCtx) {
 204     xmlSecOpenSSLDigestCtxPtr ctx;
 205
 206     xmlSecAssert2(xmlSecOpenSSLEvpDigestCheckId(transform), -1);
 207     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLEvpDigestSize), -1);
 208     xmlSecAssert2(transform->operation == xmlSecTransformOperationVerify, -1);
 209     xmlSecAssert2(transform->status == xmlSecTransformStatusFinished, -1);
 210     xmlSecAssert2(data != NULL, -1);
 211     xmlSecAssert2(transformCtx != NULL, -1);
 212
 213     ctx = xmlSecOpenSSLEvpDigestGetCtx(transform);
 214     xmlSecAssert2(ctx != NULL, -1);
 215     xmlSecAssert2(ctx->dgstSize > 0, -1);
 216
 217     if(dataSize != ctx->dgstSize) {
 218         xmlSecError(XMLSEC_ERRORS_HERE,
 219                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 220                     NULL,
 221                     XMLSEC_ERRORS_R_INVALID_SIZE,
 222                     "data_size=%d;dgst_size=%d",
 223                     dataSize, ctx->dgstSize);
 224         transform->status = xmlSecTransformStatusFail;
 225         return(0);
 226     }
 227
 228     if(memcmp(ctx->dgst, data, ctx->dgstSize) != 0) {
 229         xmlSecError(XMLSEC_ERRORS_HERE,
 230                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 231                     NULL,
 232                     XMLSEC_ERRORS_R_INVALID_DATA,
 233                     "data and digest do not match");
 234         transform->status = xmlSecTransformStatusFail;
 235         return(0);
 236     }
 237
 238     transform->status = xmlSecTransformStatusOk;
 239     return(0);
 240 }
 241
 242 static int
 243 xmlSecOpenSSLEvpDigestExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {
 244     xmlSecOpenSSLDigestCtxPtr ctx;
 245     xmlSecBufferPtr in, out;
 246     int ret;
 247
 248     xmlSecAssert2(xmlSecOpenSSLEvpDigestCheckId(transform), -1);
 249     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) || (transform->operation == xmlSecTransformOperationVerify), -1);
 250     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecOpenSSLEvpDigestSize), -1);
 251     xmlSecAssert2(transformCtx != NULL, -1);
 252
 253     in = &(transform->inBuf);
 254     xmlSecAssert2(in != NULL, -1);
 255
 256     out = &(transform->outBuf);
 257     xmlSecAssert2(out != NULL, -1);
 258
 259     ctx = xmlSecOpenSSLEvpDigestGetCtx(transform);
 260     xmlSecAssert2(ctx != NULL, -1);
 261     xmlSecAssert2(ctx->digest != NULL, -1);
 262
 263     if(transform->status == xmlSecTransformStatusNone) {
 264 #ifndef XMLSEC_OPENSSL_096
 265         ret = EVP_DigestInit(&(ctx->digestCtx), ctx->digest);
 266         if(ret != 1) {
 267             xmlSecError(XMLSEC_ERRORS_HERE,
 268                         xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 269                         "EVP_DigestInit",
 270                         XMLSEC_ERRORS_R_CRYPTO_FAILED,
 271                         XMLSEC_ERRORS_NO_MESSAGE);
 272             return(-1);
 273         }
 274 #else /* XMLSEC_OPENSSL_096 */
 275         EVP_DigestInit(&(ctx->digestCtx), ctx->digest);
 276 #endif /* XMLSEC_OPENSSL_096 */
 277         transform->status = xmlSecTransformStatusWorking;
 278     }
 279
 280     if(transform->status == xmlSecTransformStatusWorking) {
 281         xmlSecSize inSize;
 282
 283         inSize = xmlSecBufferGetSize(in);
 284         if(inSize > 0) {
 285 #ifndef XMLSEC_OPENSSL_096
 286             ret = EVP_DigestUpdate(&(ctx->digestCtx), xmlSecBufferGetData(in), inSize);
 287             if(ret != 1) {
 288                 xmlSecError(XMLSEC_ERRORS_HERE,
 289                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 290                             "EVP_DigestUpdate",
 291                             XMLSEC_ERRORS_R_CRYPTO_FAILED,
 292                             "size=%d", inSize);
 293                 return(-1);
 294             }
 295 #else /* XMLSEC_OPENSSL_096 */
 296             EVP_DigestUpdate(&(ctx->digestCtx), xmlSecBufferGetData(in), inSize);
 297 #endif /* XMLSEC_OPENSSL_096 */
 298
 299             ret = xmlSecBufferRemoveHead(in, inSize);
 300             if(ret < 0) {
 301                 xmlSecError(XMLSEC_ERRORS_HERE,
 302                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 303                             "xmlSecBufferRemoveHead",
 304                             XMLSEC_ERRORS_R_XMLSEC_FAILED,
 305                             "size=%d", inSize);
 306                 return(-1);
 307             }
 308         }
 309         if(last) {
 310             xmlSecAssert2((xmlSecSize)EVP_MD_size(ctx->digest) <= sizeof(ctx->dgst), -1);
 311
 312 #ifndef XMLSEC_OPENSSL_096
 313             ret = EVP_DigestFinal(&(ctx->digestCtx), ctx->dgst, &ctx->dgstSize);
 314             if(ret != 1) {
 315                 xmlSecError(XMLSEC_ERRORS_HERE,
 316                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 317                             "EVP_DigestFinal",
 318                             XMLSEC_ERRORS_R_CRYPTO_FAILED,
 319                             XMLSEC_ERRORS_NO_MESSAGE);
 320                 return(-1);
 321             }
 322 #else /* XMLSEC_OPENSSL_096 */
 323             EVP_DigestFinal(&(ctx->digestCtx), ctx->dgst, &ctx->dgstSize);
 324 #endif /* XMLSEC_OPENSSL_096 */
 325             xmlSecAssert2(ctx->dgstSize > 0, -1);
 326
 327             /* copy result to output */
 328             if(transform->operation == xmlSecTransformOperationSign) {
 329                 ret = xmlSecBufferAppend(out, ctx->dgst, ctx->dgstSize);
 330                 if(ret < 0) {
 331                     xmlSecError(XMLSEC_ERRORS_HERE,
 332                                 xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 333                                 "xmlSecBufferAppend",
 334                                 XMLSEC_ERRORS_R_XMLSEC_FAILED,
 335                                 "size=%d", ctx->dgstSize);
 336                     return(-1);
 337                 }
 338             }
 339             transform->status = xmlSecTransformStatusFinished;
 340         }
 341     } else if(transform->status == xmlSecTransformStatusFinished) {
 342         /* the only way we can get here is if there is no input */
 343         xmlSecAssert2(xmlSecBufferGetSize(in) == 0, -1);
 344     } else {
 345         xmlSecError(XMLSEC_ERRORS_HERE,
 346                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 347                     NULL,
 348                     XMLSEC_ERRORS_R_INVALID_STATUS,
 349                     "status=%d", transform->status);
 350         return(-1);
 351     }
 352
 353     return(0);
 354 }
 355
 356
 357 #ifndef XMLSEC_NO_MD5
 358 /******************************************************************************
 359  *
 360  * MD5
 361  *
 362  *****************************************************************************/
 363 static xmlSecTransformKlass xmlSecOpenSSLMd5Klass = {
 364     /* klass/object sizes */
 365     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 366     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 367
 368     xmlSecNameMd5,                              /* const xmlChar* name; */
 369     xmlSecHrefMd5,                              /* const xmlChar* href; */
 370     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 371
 372     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 373     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 374     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 375     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 376     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 377     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 378     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 379     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 380     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 381     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 382     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 383     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 384     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 385
 386     NULL,                                       /* void* reserved0; */
 387     NULL,                                       /* void* reserved1; */
 388 };
 389
 390 /**
 391  * xmlSecOpenSSLTransformMd5GetKlass:
 392  *
 393  * MD5 digest transform klass.
 394  *
 395  * Returns: pointer to MD5 digest transform klass.
 396  */
 397 xmlSecTransformId
 398 xmlSecOpenSSLTransformMd5GetKlass(void) {
 399     return(&xmlSecOpenSSLMd5Klass);
 400 }
 401 #endif /* XMLSEC_NO_MD5 */
 402
 403 #ifndef XMLSEC_NO_RIPEMD160
 404 /******************************************************************************
 405  *
 406  * RIPEMD160
 407  *
 408  *****************************************************************************/
 409 static xmlSecTransformKlass xmlSecOpenSSLRipemd160Klass = {
 410     /* klass/object sizes */
 411     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 412     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 413
 414     xmlSecNameRipemd160,                        /* const xmlChar* name; */
 415     xmlSecHrefRipemd160,                        /* const xmlChar* href; */
 416     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 417
 418     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 419     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 420     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 421     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 422     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 423     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 424     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 425     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 426     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 427     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 428     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 429     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 430     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 431
 432     NULL,                                       /* void* reserved0; */
 433     NULL,                                       /* void* reserved1; */
 434 };
 435
 436 /**
 437  * xmlSecOpenSSLTransformRipemd160GetKlass:
 438  *
 439  * RIPEMD-160 digest transform klass.
 440  *
 441  * Returns: pointer to RIPEMD-160 digest transform klass.
 442  */
 443 xmlSecTransformId
 444 xmlSecOpenSSLTransformRipemd160GetKlass(void) {
 445     return(&xmlSecOpenSSLRipemd160Klass);
 446 }
 447 #endif /* XMLSEC_NO_RIPEMD160 */
 448
 449
 450 #ifndef XMLSEC_NO_SHA1
 451 /******************************************************************************
 452  *
 453  * SHA1
 454  *
 455  *****************************************************************************/
 456 static xmlSecTransformKlass xmlSecOpenSSLSha1Klass = {
 457     /* klass/object sizes */
 458     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 459     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 460
 461     xmlSecNameSha1,                             /* const xmlChar* name; */
 462     xmlSecHrefSha1,                             /* const xmlChar* href; */
 463     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 464
 465     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 466     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 467     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 468     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 469     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 470     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 471     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 472     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 473     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 474     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 475     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 476     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 477     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 478
 479     NULL,                                       /* void* reserved0; */
 480     NULL,                                       /* void* reserved1; */
 481 };
 482
 483 /**
 484  * xmlSecOpenSSLTransformSha1GetKlass:
 485  *
 486  * SHA-1 digest transform klass.
 487  *
 488  * Returns: pointer to SHA-1 digest transform klass.
 489  */
 490 xmlSecTransformId
 491 xmlSecOpenSSLTransformSha1GetKlass(void) {
 492     return(&xmlSecOpenSSLSha1Klass);
 493 }
 494 #endif /* XMLSEC_NO_SHA1 */
 495
 496 #ifndef XMLSEC_NO_SHA224
 497 /******************************************************************************
 498  *
 499  * SHA224
 500  *
 501  *****************************************************************************/
 502 static xmlSecTransformKlass xmlSecOpenSSLSha224Klass = {
 503     /* klass/object sizes */
 504     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 505     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 506
 507     xmlSecNameSha224,                           /* const xmlChar* name; */
 508     xmlSecHrefSha224,                           /* const xmlChar* href; */
 509     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 510
 511     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 512     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 513     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 514     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 515     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 516     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 517     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 518     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 519     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 520     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 521     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 522     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 523     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 524
 525     NULL,                                       /* void* reserved0; */
 526     NULL,                                       /* void* reserved1; */
 527 };
 528
 529 /**
 530  * xmlSecOpenSSLTransformSha224GetKlass:
 531  *
 532  * SHA-224 digest transform klass.
 533  *
 534  * Returns: pointer to SHA-224 digest transform klass.
 535  */
 536 xmlSecTransformId
 537 xmlSecOpenSSLTransformSha224GetKlass(void) {
 538     return(&xmlSecOpenSSLSha224Klass);
 539 }
 540 #endif /* XMLSEC_NO_SHA224 */
 541
 542 #ifndef XMLSEC_NO_SHA256
 543 /******************************************************************************
 544  *
 545  * SHA256
 546  *
 547  *****************************************************************************/
 548 static xmlSecTransformKlass xmlSecOpenSSLSha256Klass = {
 549     /* klass/object sizes */
 550     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 551     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 552
 553     xmlSecNameSha256,                           /* const xmlChar* name; */
 554     xmlSecHrefSha256,                           /* const xmlChar* href; */
 555     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 556
 557     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 558     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 559     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 560     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 561     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 562     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 563     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 564     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 565     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 566     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 567     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 568     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 569     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 570
 571     NULL,                                       /* void* reserved0; */
 572     NULL,                                       /* void* reserved1; */
 573 };
 574
 575 /**
 576  * xmlSecOpenSSLTransformSha256GetKlass:
 577  *
 578  * SHA-256 digest transform klass.
 579  *
 580  * Returns: pointer to SHA-256 digest transform klass.
 581  */
 582 xmlSecTransformId
 583 xmlSecOpenSSLTransformSha256GetKlass(void) {
 584     return(&xmlSecOpenSSLSha256Klass);
 585 }
 586 #endif /* XMLSEC_NO_SHA256 */
 587
 588 #ifndef XMLSEC_NO_SHA384
 589 /******************************************************************************
 590  *
 591  * SHA384
 592  *
 593  *****************************************************************************/
 594 static xmlSecTransformKlass xmlSecOpenSSLSha384Klass = {
 595     /* klass/object sizes */
 596     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 597     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 598
 599     xmlSecNameSha384,                           /* const xmlChar* name; */
 600     xmlSecHrefSha384,                           /* const xmlChar* href; */
 601     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 602
 603     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 604     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 605     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 606     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 607     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 608     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 609     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 610     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 611     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 612     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 613     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 614     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 615     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 616
 617     NULL,                                       /* void* reserved0; */
 618     NULL,                                       /* void* reserved1; */
 619 };
 620
 621 /**
 622  * xmlSecOpenSSLTransformSha384GetKlass:
 623  *
 624  * SHA-384 digest transform klass.
 625  *
 626  * Returns: pointer to SHA-384 digest transform klass.
 627  */
 628 xmlSecTransformId
 629 xmlSecOpenSSLTransformSha384GetKlass(void) {
 630     return(&xmlSecOpenSSLSha384Klass);
 631 }
 632 #endif /* XMLSEC_NO_SHA384 */
 633
 634 #ifndef XMLSEC_NO_SHA512
 635 /******************************************************************************
 636  *
 637  * SHA512
 638  *
 639  *****************************************************************************/
 640 static xmlSecTransformKlass xmlSecOpenSSLSha512Klass = {
 641     /* klass/object sizes */
 642     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 643     xmlSecOpenSSLEvpDigestSize,                 /* xmlSecSize objSize */
 644
 645     xmlSecNameSha512,                           /* const xmlChar* name; */
 646     xmlSecHrefSha512,                           /* const xmlChar* href; */
 647     xmlSecTransformUsageDigestMethod,           /* xmlSecTransformUsage usage; */
 648
 649     xmlSecOpenSSLEvpDigestInitialize,           /* xmlSecTransformInitializeMethod initialize; */
 650     xmlSecOpenSSLEvpDigestFinalize,             /* xmlSecTransformFinalizeMethod finalize; */
 651     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 652     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 653     NULL,                                       /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 654     NULL,                                       /* xmlSecTransformSetKeyMethod setKey; */
 655     xmlSecOpenSSLEvpDigestVerify,               /* xmlSecTransformVerifyMethod verify; */
 656     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 657     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 658     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 659     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 660     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 661     xmlSecOpenSSLEvpDigestExecute,              /* xmlSecTransformExecuteMethod execute; */
 662
 663     NULL,                                       /* void* reserved0; */
 664     NULL,                                       /* void* reserved1; */
 665 };
 666
 667 /**
 668  * xmlSecOpenSSLTransformSha512GetKlass:
 669  *
 670  * SHA-512 digest transform klass.
 671  *
 672  * Returns: pointer to SHA-512 digest transform klass.
 673  */
 674 xmlSecTransformId
 675 xmlSecOpenSSLTransformSha512GetKlass(void) {
 676     return(&xmlSecOpenSSLSha512Klass);
 677 }
 678 #endif /* XMLSEC_NO_SHA512 */
 679