src/mscrypto/signatures.c

   1 /**
   2  * XMLSec library
   3  *
   4  * This is free software; see Copyright file in the source
   5  * distribution for preciese wording.
   6  *
   7  * Copyrigth (C) 2003 Cordys R&D BV, All rights reserved.
   8  * Copyright (C) 2003 Aleksey Sanin <aleksey@aleksey.com>
   9  * Copyright (c) 2005-2006 Cryptocom LTD (http://www.cryptocom.ru).
  10  */
  11 #include "globals.h"
  12
  13 #include <string.h>
  14
  15 #include <windows.h>
  16 #include <wincrypt.h>
  17 #ifndef XMLSEC_NO_GOST
  18 #include "csp_calg.h"
  19 #endif
  20
  21 #include <xmlsec/xmlsec.h>
  22 #include <xmlsec/keys.h>
  23 #include <xmlsec/transforms.h>
  24 #include <xmlsec/errors.h>
  25
  26 #include <xmlsec/mscrypto/crypto.h>
  27 #include <xmlsec/mscrypto/symbols.h>
  28 #include <xmlsec/mscrypto/certkeys.h>
  29 #include <xmlsec/mscrypto/x509.h>
  30
  31 /*FIXME: include header files*/
  32 extern HCRYPTPROV xmlSecMSCryptoKeyDataGetMSCryptoProvider(xmlSecKeyDataPtr data);
  33 extern DWORD xmlSecMSCryptoKeyDataGetMSCryptoKeySpec(xmlSecKeyDataPtr data);
  34
  35 #if defined(__MINGW32__)
  36 #  include "xmlsec-mingw.h"
  37 #endif
  38
  39 /**************************************************************************
  40  *
  41  * Internal MSCrypto signatures ctx
  42  *
  43  *****************************************************************************/
  44 typedef struct _xmlSecMSCryptoSignatureCtx      xmlSecMSCryptoSignatureCtx,
  45                                                 *xmlSecMSCryptoSignatureCtxPtr;
  46 struct _xmlSecMSCryptoSignatureCtx {
  47     xmlSecKeyDataPtr    data;
  48     ALG_ID              alg_id;
  49     HCRYPTHASH          mscHash;
  50     ALG_ID              digestAlgId;
  51     xmlSecKeyDataId     keyId;
  52 };
  53
  54 /******************************************************************************
  55  *
  56  * Signature transforms
  57  *
  58  * xmlSecMSCryptoSignatureCtx is located after xmlSecTransform
  59  *
  60  *****************************************************************************/
  61 #define xmlSecMSCryptoSignatureSize     \
  62     (sizeof(xmlSecTransform) + sizeof(xmlSecMSCryptoSignatureCtx))
  63 #define xmlSecMSCryptoSignatureGetCtx(transform) \
  64     ((xmlSecMSCryptoSignatureCtxPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)))
  65
  66 static int      xmlSecMSCryptoSignatureCheckId          (xmlSecTransformPtr transform);
  67 static int      xmlSecMSCryptoSignatureInitialize       (xmlSecTransformPtr transform);
  68 static void     xmlSecMSCryptoSignatureFinalize         (xmlSecTransformPtr transform);
  69 static int      xmlSecMSCryptoSignatureSetKeyReq        (xmlSecTransformPtr transform,
  70                                                          xmlSecKeyReqPtr keyReq);
  71 static int      xmlSecMSCryptoSignatureSetKey           (xmlSecTransformPtr transform,
  72                                                          xmlSecKeyPtr key);
  73 static int      xmlSecMSCryptoSignatureVerify           (xmlSecTransformPtr transform,
  74                                                          const xmlSecByte* data,
  75                                                          xmlSecSize dataSize,
  76                                                          xmlSecTransformCtxPtr transformCtx);
  77 static int      xmlSecMSCryptoSignatureExecute          (xmlSecTransformPtr transform,
  78                                                          int last,
  79                                                          xmlSecTransformCtxPtr transformCtx);
  80
  81
  82 static int xmlSecMSCryptoSignatureCheckId(xmlSecTransformPtr transform) {
  83
  84 #ifndef XMLSEC_NO_DSA
  85     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformDsaSha1Id)) {
  86         return(1);
  87     }
  88 #endif /* XMLSEC_NO_DSA */
  89
  90 #ifndef XMLSEC_NO_GOST
  91     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformGost2001GostR3411_94Id)) {
  92         return(1);
  93     }
  94 #endif /* XMLSEC_NO_GOST*/
  95
  96 #ifndef XMLSEC_NO_RSA
  97     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaSha1Id)) {
  98         return(1);
  99     }
 100 #endif /* XMLSEC_NO_RSA */
 101
 102     return(0);
 103 }
 104
 105 static int xmlSecMSCryptoSignatureInitialize(xmlSecTransformPtr transform) {
 106     xmlSecMSCryptoSignatureCtxPtr ctx;
 107
 108     xmlSecAssert2(xmlSecMSCryptoSignatureCheckId(transform), -1);
 109     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize), -1);
 110
 111     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 112     xmlSecAssert2(ctx != NULL, -1);
 113
 114     memset(ctx, 0, sizeof(xmlSecMSCryptoSignatureCtx));
 115
 116 #ifndef XMLSEC_NO_RSA
 117     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaSha1Id)) {
 118         ctx->digestAlgId    = CALG_SHA1;
 119         ctx->keyId          = xmlSecMSCryptoKeyDataRsaId;
 120     } else
 121 #endif /* XMLSEC_NO_RSA */
 122
 123 #ifndef XMLSEC_NO_GOST
 124     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformGost2001GostR3411_94Id)) {
 125         ctx->digestAlgId    = CALG_MAGPRO_HASH_R3411_94;
 126         ctx->keyId          = xmlSecMSCryptoKeyDataGost2001Id;
 127     } else
 128 #endif /* XMLSEC_NO_GOST*/
 129
 130 #ifndef XMLSEC_NO_DSA
 131     if(xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformDsaSha1Id)) {
 132         ctx->digestAlgId    = CALG_SHA1;
 133         ctx->keyId          = xmlSecMSCryptoKeyDataDsaId;
 134     } else
 135 #endif /* XMLSEC_NO_DSA */
 136
 137     if(1) {
 138         xmlSecError(XMLSEC_ERRORS_HERE,
 139                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 140                     NULL,
 141                     XMLSEC_ERRORS_R_INVALID_TRANSFORM,
 142                     XMLSEC_ERRORS_NO_MESSAGE);
 143         return(-1);
 144     }
 145
 146     return(0);
 147 }
 148
 149 static void xmlSecMSCryptoSignatureFinalize(xmlSecTransformPtr transform) {
 150     xmlSecMSCryptoSignatureCtxPtr ctx;
 151
 152     xmlSecAssert(xmlSecMSCryptoSignatureCheckId(transform));
 153     xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize));
 154
 155     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 156     xmlSecAssert(ctx != NULL);
 157
 158     if (ctx->mscHash) {
 159         CryptDestroyHash(ctx->mscHash);
 160     }
 161
 162     if (ctx->data != NULL)  {
 163         xmlSecKeyDataDestroy(ctx->data);
 164         ctx->data = NULL;
 165     }
 166
 167     memset(ctx, 0, sizeof(xmlSecMSCryptoSignatureCtx));
 168 }
 169
 170 static int xmlSecMSCryptoSignatureSetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {
 171     xmlSecMSCryptoSignatureCtxPtr ctx;
 172     xmlSecKeyDataPtr value;
 173
 174     xmlSecAssert2(xmlSecMSCryptoSignatureCheckId(transform), -1);
 175     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) || (transform->operation == xmlSecTransformOperationVerify), -1);
 176     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize), -1);
 177     xmlSecAssert2(key != NULL, -1);
 178
 179     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 180     xmlSecAssert2(ctx != NULL, -1);
 181     xmlSecAssert2(ctx->digestAlgId != 0, -1);
 182     xmlSecAssert2(ctx->keyId != NULL, -1);
 183     xmlSecAssert2(xmlSecKeyCheckId(key, ctx->keyId), -1);
 184
 185     value = xmlSecKeyGetValue(key);
 186     xmlSecAssert2(value != NULL, -1);
 187
 188     ctx->data = xmlSecKeyDataDuplicate(value);
 189     if(ctx->data == NULL) {
 190         xmlSecError(XMLSEC_ERRORS_HERE,
 191                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 192                     "xmlSecKeyDataDuplicate",
 193                     XMLSEC_ERRORS_R_XMLSEC_FAILED,
 194                     XMLSEC_ERRORS_NO_MESSAGE);
 195         return(-1);
 196     }
 197
 198     return(0);
 199 }
 200
 201 static int xmlSecMSCryptoSignatureSetKeyReq(xmlSecTransformPtr transform,  xmlSecKeyReqPtr keyReq) {
 202     xmlSecMSCryptoSignatureCtxPtr ctx;
 203
 204     xmlSecAssert2(xmlSecMSCryptoSignatureCheckId(transform), -1);
 205     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) || (transform->operation == xmlSecTransformOperationVerify), -1);
 206     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize), -1);
 207     xmlSecAssert2(keyReq != NULL, -1);
 208
 209     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 210     xmlSecAssert2(ctx != NULL, -1);
 211     xmlSecAssert2(ctx->keyId != NULL, -1);
 212
 213     keyReq->keyId        = ctx->keyId;
 214     if(transform->operation == xmlSecTransformOperationSign) {
 215         keyReq->keyType  = xmlSecKeyDataTypePrivate;
 216         keyReq->keyUsage = xmlSecKeyUsageSign;
 217     } else {
 218         keyReq->keyType  = xmlSecKeyDataTypePublic;
 219         keyReq->keyUsage = xmlSecKeyUsageVerify;
 220     }
 221     return(0);
 222 }
 223
 224
 225 static int xmlSecMSCryptoSignatureVerify(xmlSecTransformPtr transform,
 226                                          const xmlSecByte* data,
 227                                          xmlSecSize dataSize,
 228                                          xmlSecTransformCtxPtr transformCtx) {
 229     xmlSecMSCryptoSignatureCtxPtr ctx;
 230     xmlSecBuffer tmp;
 231     HCRYPTKEY hKey;
 232     DWORD dwError;
 233     BYTE *tmpBuf, *j, *k, *l, *m;
 234     int ret;
 235
 236     xmlSecAssert2(xmlSecMSCryptoSignatureCheckId(transform), -1);
 237     xmlSecAssert2(transform->operation == xmlSecTransformOperationVerify, -1);
 238     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize), -1);
 239     xmlSecAssert2(transform->status == xmlSecTransformStatusFinished, -1);
 240     xmlSecAssert2(data != NULL, -1);
 241     xmlSecAssert2(dataSize > 0, -1);
 242     xmlSecAssert2(transformCtx != NULL, -1);
 243
 244     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 245     xmlSecAssert2(ctx != NULL, -1);
 246
 247     ret = xmlSecBufferInitialize(&tmp, dataSize);
 248     if(ret < 0) {
 249         xmlSecError(XMLSEC_ERRORS_HERE,
 250                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 251                     "xmlSecBufferInitialize",
 252                     XMLSEC_ERRORS_R_XMLSEC_FAILED,
 253                     "dataSize=%d", dataSize);
 254         return(-1);
 255     }
 256
 257     tmpBuf = xmlSecBufferGetData(&tmp);
 258     xmlSecAssert2(tmpBuf != NULL, -1);
 259
 260     /* Reverse the sig - Windows stores integers as octet streams in little endian
 261      * order.  The I2OSP algorithm used by XMLDSig to store integers is big endian */
 262     if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformDsaSha1Id)) {
 263         j = (BYTE *)data;
 264         k = (BYTE *)data + 20;
 265         l = tmpBuf + 19;
 266         m = tmpBuf + 39;
 267         while (l >= tmpBuf) {
 268             *l-- = *j++;
 269             *m-- = *k++;
 270         }
 271 #ifndef XMLSEC_NO_GOST
 272     } else if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformGost2001GostR3411_94Id)) {
 273         j = (BYTE *)data;
 274         l = tmpBuf + dataSize - 1;
 275         while (l >= tmpBuf) {
 276             *l-- = *j++;
 277         }
 278 #endif /*ndef XMLSEC_NO_GOST*/
 279     } else if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaSha1Id)) {
 280         j = (BYTE *)data;
 281         l = tmpBuf + dataSize - 1;
 282         while (l >= tmpBuf) {
 283             *l-- = *j++;
 284         }
 285     } else {
 286         xmlSecError(XMLSEC_ERRORS_HERE,
 287                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 288                     NULL,
 289                     XMLSEC_ERRORS_R_XMLSEC_FAILED,
 290                     "Invalid algo");
 291         xmlSecBufferFinalize(&tmp);
 292         return(-1);
 293     }
 294
 295     hKey = xmlSecMSCryptoKeyDataGetKey(ctx->data, xmlSecKeyDataTypePublic);
 296     if (hKey == 0) {
 297         xmlSecError(XMLSEC_ERRORS_HERE,
 298                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 299                     "xmlSecMSCryptoKeyDataGetKey",
 300                     XMLSEC_ERRORS_R_XMLSEC_FAILED,
 301                     XMLSEC_ERRORS_NO_MESSAGE);
 302         xmlSecBufferFinalize(&tmp);
 303         return(-1);
 304     }
 305     if (!CryptVerifySignature(ctx->mscHash,
 306                               tmpBuf,
 307                               dataSize,
 308                               hKey,
 309                               NULL,
 310                               0)) {
 311         dwError = GetLastError();
 312         if (NTE_BAD_SIGNATURE == dwError) {
 313             xmlSecError(XMLSEC_ERRORS_HERE,
 314                         xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 315                         "CryptVerifySignature",
 316                         XMLSEC_ERRORS_R_DATA_NOT_MATCH,
 317                         "signature do not match");
 318             transform->status = xmlSecTransformStatusFail;
 319             xmlSecBufferFinalize(&tmp);
 320             return(0);
 321         } else {
 322             xmlSecError(XMLSEC_ERRORS_HERE,
 323                         xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 324                         "CryptVerifySignature",
 325                         XMLSEC_ERRORS_R_CRYPTO_FAILED,
 326                         XMLSEC_ERRORS_NO_MESSAGE);
 327             xmlSecBufferFinalize(&tmp);
 328             return (-1);
 329         }
 330     }
 331     xmlSecBufferFinalize(&tmp);
 332     transform->status = xmlSecTransformStatusOk;
 333     return(0);
 334 }
 335
 336 static int
 337 xmlSecMSCryptoSignatureExecute(xmlSecTransformPtr transform, int last, xmlSecTransformCtxPtr transformCtx) {
 338     xmlSecMSCryptoSignatureCtxPtr ctx;
 339     HCRYPTPROV hProv;
 340     DWORD dwKeySpec;
 341     xmlSecBufferPtr in, out;
 342     xmlSecSize inSize, outSize;
 343     int ret;
 344     DWORD dwSigLen;
 345     BYTE *tmpBuf, *outBuf, *i, *j, *m, *n;
 346
 347     xmlSecAssert2(xmlSecMSCryptoSignatureCheckId(transform), -1);
 348     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) || (transform->operation == xmlSecTransformOperationVerify), -1);
 349     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecMSCryptoSignatureSize), -1);
 350     xmlSecAssert2(transformCtx != NULL, -1);
 351
 352     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 353     xmlSecAssert2(ctx != NULL, -1);
 354
 355     in = &(transform->inBuf);
 356     out = &(transform->outBuf);
 357     inSize = xmlSecBufferGetSize(in);
 358     outSize = xmlSecBufferGetSize(out);
 359
 360     ctx = xmlSecMSCryptoSignatureGetCtx(transform);
 361     xmlSecAssert2(ctx != NULL, -1);
 362     xmlSecAssert2(ctx->digestAlgId != 0, -1);
 363
 364     if(transform->status == xmlSecTransformStatusNone) {
 365         xmlSecAssert2(outSize == 0, -1);
 366
 367         if (0 == (hProv = xmlSecMSCryptoKeyDataGetMSCryptoProvider(ctx->data))) {
 368             xmlSecError(XMLSEC_ERRORS_HERE,
 369                         xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 370                         "xmlSecMSCryptoKeyDataGetMSCryptoProvider",
 371                         XMLSEC_ERRORS_R_CRYPTO_FAILED,
 372                         XMLSEC_ERRORS_NO_MESSAGE);
 373             return (-1);
 374         }
 375         if (!CryptCreateHash(hProv, ctx->digestAlgId, 0, 0, &(ctx->mscHash))) {
 376             xmlSecError(XMLSEC_ERRORS_HERE,
 377                         NULL,
 378                         "CryptCreateHash",
 379                         XMLSEC_ERRORS_R_CRYPTO_FAILED,
 380                         XMLSEC_ERRORS_NO_MESSAGE);
 381             return(-1);
 382         }
 383
 384         transform->status = xmlSecTransformStatusWorking;
 385     }
 386
 387     if((transform->status == xmlSecTransformStatusWorking) && (inSize > 0)) {
 388         xmlSecAssert2(outSize == 0, -1);
 389
 390         if (!CryptHashData(ctx->mscHash, xmlSecBufferGetData(in), inSize, 0)) {
 391             xmlSecError(XMLSEC_ERRORS_HERE,
 392                         NULL,
 393                         "CryptHashData",
 394                         XMLSEC_ERRORS_R_CRYPTO_FAILED,
 395                         XMLSEC_ERRORS_NO_MESSAGE);
 396             return(-1);
 397         }
 398
 399         ret = xmlSecBufferRemoveHead(in, inSize);
 400         if(ret < 0) {
 401             xmlSecError(XMLSEC_ERRORS_HERE,
 402                         xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 403                         "xmlSecBufferRemoveHead",
 404                         XMLSEC_ERRORS_R_XMLSEC_FAILED,
 405                         XMLSEC_ERRORS_NO_MESSAGE);
 406             return(-1);
 407         }
 408     }
 409
 410     if((transform->status == xmlSecTransformStatusWorking) && (last != 0)) {
 411         xmlSecBuffer tmp;
 412
 413         xmlSecAssert2(outSize == 0, -1);
 414
 415         if(transform->operation == xmlSecTransformOperationSign) {
 416             dwKeySpec = xmlSecMSCryptoKeyDataGetMSCryptoKeySpec(ctx->data);
 417             if (!CryptSignHash(ctx->mscHash, dwKeySpec, NULL, 0, NULL, &dwSigLen)) {
 418                 xmlSecError(XMLSEC_ERRORS_HERE,
 419                             NULL,
 420                             "CryptSignHash",
 421                             XMLSEC_ERRORS_R_CRYPTO_FAILED,
 422                             XMLSEC_ERRORS_NO_MESSAGE);
 423                 return(-1);
 424             }
 425             outSize = (xmlSecSize)dwSigLen;
 426
 427             ret = xmlSecBufferInitialize(&tmp, outSize);
 428             if(ret < 0) {
 429                 xmlSecError(XMLSEC_ERRORS_HERE,
 430                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 431                             "xmlSecBufferSetMaxSize",
 432                             XMLSEC_ERRORS_R_XMLSEC_FAILED,
 433                             "size=%d", outSize);
 434                 return(-1);
 435             }
 436             tmpBuf = xmlSecBufferGetData(&tmp);
 437             xmlSecAssert2(tmpBuf != NULL, -1);
 438
 439             if (!CryptSignHash(ctx->mscHash, dwKeySpec, NULL, 0, tmpBuf, &dwSigLen)) {
 440                 xmlSecError(XMLSEC_ERRORS_HERE,
 441                             NULL,
 442                             "CryptSignHash",
 443                             XMLSEC_ERRORS_R_CRYPTO_FAILED,
 444                             XMLSEC_ERRORS_NO_MESSAGE);
 445                 xmlSecBufferFinalize(&tmp);
 446                 return(-1);
 447             }
 448             outSize = (xmlSecSize)dwSigLen;
 449
 450             ret = xmlSecBufferSetSize(out, outSize);
 451             if(ret < 0) {
 452                 xmlSecError(XMLSEC_ERRORS_HERE,
 453                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 454                             "xmlSecBufferSetSize",
 455                             XMLSEC_ERRORS_R_XMLSEC_FAILED,
 456                             "size=%d", outSize);
 457                 xmlSecBufferFinalize(&tmp);
 458                 return(-1);
 459             }
 460             outBuf = xmlSecBufferGetData(out);
 461             xmlSecAssert2(outBuf != NULL, -1);
 462
 463             /* Now encode into a signature block,
 464              * convert signature value to big endian */
 465             if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformDsaSha1Id)) {
 466                 i = tmpBuf;
 467                 j = tmpBuf + 20;
 468                 m = outBuf + 19;
 469                 n = outBuf + 39;
 470                 while (m >= outBuf) {
 471                     *m-- = *i++;
 472                     *n-- = *j++;
 473                 }
 474 #ifndef XMLSEC_NO_GOST
 475     } else if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformGost2001GostR3411_94Id)) {
 476                 i = tmpBuf;
 477                 j = outBuf + dwSigLen - 1;
 478
 479                 while (j >= outBuf) {
 480                     *j-- = *i++;
 481                 }
 482 #endif /*ndef XMLSEC_NO_GOST*/
 483             } else if (xmlSecTransformCheckId(transform, xmlSecMSCryptoTransformRsaSha1Id)) {
 484                 i = tmpBuf;
 485                 j = outBuf + dwSigLen - 1;
 486
 487                 while (j >= outBuf) {
 488                     *j-- = *i++;
 489                 }
 490             } else {
 491                 /* We shouldn't get at this place */
 492                 xmlSecError(XMLSEC_ERRORS_HERE,
 493                             xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 494                             NULL,
 495                             XMLSEC_ERRORS_R_XMLSEC_FAILED,
 496                             "Invalid algo");
 497                 xmlSecBufferFinalize(&tmp);
 498                 return(-1);
 499             }
 500             xmlSecBufferFinalize(&tmp);
 501         }
 502         transform->status = xmlSecTransformStatusFinished;
 503     }
 504
 505     if((transform->status == xmlSecTransformStatusWorking) || (transform->status == xmlSecTransformStatusFinished)) {
 506         /* the only way we can get here is if there is no input */
 507         xmlSecAssert2(xmlSecBufferGetSize(&(transform->inBuf)) == 0, -1);
 508     } else {
 509         xmlSecError(XMLSEC_ERRORS_HERE,
 510                     xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),
 511                     NULL,
 512                     XMLSEC_ERRORS_R_INVALID_STATUS,
 513                     "status=%d", transform->status);
 514         return(-1);
 515     }
 516
 517     return(0);
 518 }
 519
 520
 521 #ifndef XMLSEC_NO_RSA
 522 /****************************************************************************
 523  *
 524  * RSA-SHA1 signature transform
 525  *
 526  ***************************************************************************/
 527 static xmlSecTransformKlass xmlSecMSCryptoRsaSha1Klass = {
 528     /* klass/object sizes */
 529     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 530     xmlSecMSCryptoSignatureSize,                /* xmlSecSize objSize */
 531
 532     xmlSecNameRsaSha1,                          /* const xmlChar* name; */
 533     xmlSecHrefRsaSha1,                          /* const xmlChar* href; */
 534     xmlSecTransformUsageSignatureMethod,        /* xmlSecTransformUsage usage; */
 535
 536     xmlSecMSCryptoSignatureInitialize,          /* xmlSecTransformInitializeMethod initialize; */
 537     xmlSecMSCryptoSignatureFinalize,            /* xmlSecTransformFinalizeMethod finalize; */
 538     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 539     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 540     xmlSecMSCryptoSignatureSetKeyReq,           /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 541     xmlSecMSCryptoSignatureSetKey,              /* xmlSecTransformSetKeyMethod setKey; */
 542     xmlSecMSCryptoSignatureVerify,              /* xmlSecTransformVerifyMethod verify; */
 543     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 544     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 545     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 546     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 547     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 548     xmlSecMSCryptoSignatureExecute,             /* xmlSecTransformExecuteMethod execute; */
 549
 550     NULL,                                       /* void* reserved0; */
 551     NULL,                                       /* void* reserved1; */
 552 };
 553
 554 /**
 555  * xmlSecMSCryptoTransformRsaSha1GetKlass:
 556  *
 557  * The RSA-SHA1 signature transform klass.
 558  *
 559  * Returns: RSA-SHA1 signature transform klass.
 560  */
 561 xmlSecTransformId
 562 xmlSecMSCryptoTransformRsaSha1GetKlass(void) {
 563     return(&xmlSecMSCryptoRsaSha1Klass);
 564 }
 565
 566 #endif /* XMLSEC_NO_RSA */
 567
 568 #ifndef XMLSEC_NO_DSA
 569 /****************************************************************************
 570  *
 571  * DSA-SHA1 signature transform
 572  *
 573  ***************************************************************************/
 574
 575 static xmlSecTransformKlass xmlSecMSCryptoDsaSha1Klass = {
 576     /* klass/object sizes */
 577     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 578     xmlSecMSCryptoSignatureSize,                /* xmlSecSize objSize */
 579
 580     xmlSecNameDsaSha1,                          /* const xmlChar* name; */
 581     xmlSecHrefDsaSha1,                          /* const xmlChar* href; */
 582     xmlSecTransformUsageSignatureMethod,        /* xmlSecTransformUsage usage; */
 583
 584     xmlSecMSCryptoSignatureInitialize,          /* xmlSecTransformInitializeMethod initialize; */
 585     xmlSecMSCryptoSignatureFinalize,            /* xmlSecTransformFinalizeMethod finalize; */
 586     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 587     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 588     xmlSecMSCryptoSignatureSetKeyReq,           /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 589     xmlSecMSCryptoSignatureSetKey,              /* xmlSecTransformSetKeyMethod setKey; */
 590     xmlSecMSCryptoSignatureVerify,              /* xmlSecTransformVerifyMethod verify; */
 591     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 592     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 593     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 594     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 595     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 596     xmlSecMSCryptoSignatureExecute,             /* xmlSecTransformExecuteMethod execute; */
 597
 598     NULL,                                       /* void* reserved0; */
 599     NULL,                                       /* void* reserved1; */
 600 };
 601
 602 /**
 603  * xmlSecMSCryptoTransformDsaSha1GetKlass:
 604  *
 605  * The DSA-SHA1 signature transform klass.
 606  *
 607  * Returns: DSA-SHA1 signature transform klass.
 608  */
 609 xmlSecTransformId
 610 xmlSecMSCryptoTransformDsaSha1GetKlass(void) {
 611     return(&xmlSecMSCryptoDsaSha1Klass);
 612 }
 613
 614 #endif /* XMLSEC_NO_DSA */
 615
 616 #ifndef XMLSEC_NO_GOST
 617 /****************************************************************************
 618  *
 619  * GOST2001-GOSTR3411_94 signature transform
 620  *
 621  ***************************************************************************/
 622
 623 static xmlSecTransformKlass xmlSecMSCryptoGost2001GostR3411_94Klass = {
 624     /* klass/object sizes */
 625     sizeof(xmlSecTransformKlass),               /* xmlSecSize klassSize */
 626     xmlSecMSCryptoSignatureSize,                /* xmlSecSize objSize */
 627
 628     xmlSecNameGost2001GostR3411_94,                             /* const xmlChar* name; */
 629     xmlSecHrefGost2001GostR3411_94,                             /* const xmlChar* href; */
 630     xmlSecTransformUsageSignatureMethod,        /* xmlSecTransformUsage usage; */
 631
 632     xmlSecMSCryptoSignatureInitialize,          /* xmlSecTransformInitializeMethod initialize; */
 633     xmlSecMSCryptoSignatureFinalize,            /* xmlSecTransformFinalizeMethod finalize; */
 634     NULL,                                       /* xmlSecTransformNodeReadMethod readNode; */
 635     NULL,                                       /* xmlSecTransformNodeWriteMethod writeNode; */
 636     xmlSecMSCryptoSignatureSetKeyReq,           /* xmlSecTransformSetKeyReqMethod setKeyReq; */
 637     xmlSecMSCryptoSignatureSetKey,              /* xmlSecTransformSetKeyMethod setKey; */
 638     xmlSecMSCryptoSignatureVerify,              /* xmlSecTransformVerifyMethod verify; */
 639     xmlSecTransformDefaultGetDataType,          /* xmlSecTransformGetDataTypeMethod getDataType; */
 640     xmlSecTransformDefaultPushBin,              /* xmlSecTransformPushBinMethod pushBin; */
 641     xmlSecTransformDefaultPopBin,               /* xmlSecTransformPopBinMethod popBin; */
 642     NULL,                                       /* xmlSecTransformPushXmlMethod pushXml; */
 643     NULL,                                       /* xmlSecTransformPopXmlMethod popXml; */
 644     xmlSecMSCryptoSignatureExecute,             /* xmlSecTransformExecuteMethod execute; */
 645
 646     NULL,                                       /* void* reserved0; */
 647     NULL,                                       /* void* reserved1; */
 648 };
 649
 650 /**
 651  * xmlSecMSCryptoTransformGost2001GostR3411_94GetKlass:
 652  *
 653  * The GOST2001-GOSTR3411_94 signature transform klass.
 654  *
 655  * Returns: GOST2001-GOSTR3411_94 signature transform klass.
 656  */
 657 xmlSecTransformId
 658 xmlSecMSCryptoTransformGost2001GostR3411_94GetKlass(void) {
 659     return(&xmlSecMSCryptoGost2001GostR3411_94Klass);
 660 }
 661
 662 #endif /* XMLSEC_NO_GOST*/
 663