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  * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

     9  */

    10 //#include "globals.h"

    11 #include "xmlsecc_globals.h"

    12 

    13 #include <string.h>

    14 #include <e32err.h>

    15 #include "xmlsecc_config.h"

    16 #include "xmlsec_xmlsec.h"

    17 #include "xmlsec_keys.h"

    18 #include "xmlsec_transforms.h"

    19 #include "xmlsec_errors.h"

    20 #include "xmlsec_error_flag.h"

    21 

    22 #include "xmlsecc_crypto.h"

    23 #include "xmlsecc_evp.h"

    24 #include "xmlsecc_cryptowrapper.h"

    25 

    26 #ifndef XMLSEC_NO_DSA

    27 static const TInt KXmlSecSymbianCryptoDsaSignatureSize(40);

    28 static const EVP_MD *xmlSecSymbianCryptoDsaSha1Evp			(void);

    29 #endif /* XMLSEC_NO_DSA */

    30 

    31 

    32 /**************************************************************************

    33  *

    34  * Internal SymbianCrypto evp signatures ctx

    35  *

    36  *****************************************************************************/

    37 typedef struct _xmlSecSymbianCryptoEvpSignatureCtx	xmlSecSymbianCryptoEvpSignatureCtx, 

    38 						*xmlSecSymbianCryptoEvpSignatureCtxPtr;

    39 struct _xmlSecSymbianCryptoEvpSignatureCtx {

    40     int					digest;

    41     EVP_MD_CTX		digestCtx;

    42     xmlSecKeyDataId	keyId;

    43     EVP_PKEY* 		pKey;

    44 };	    

    45 

    46 xmlSecTransformGetDataTypeMethod const xmlSecCrpytoGetDataTypeMethod  = xmlSecTransformDefaultGetDataType;

    47 xmlSecTransformPushBinMethod const xmlSecCryptoPushBinMethod = xmlSecTransformDefaultPushBin;

    48 xmlSecTransformPopBinMethod const xmlSecCryptoPopBinMethod = xmlSecTransformDefaultPopBin;

    49 

    50 /******************************************************************************

    51  *

    52  * EVP Signature transforms

    53  *

    54  * xmlSecSymbianCryptoEvpSignatureCtx is located after xmlSecTransform

    55  *

    56  *****************************************************************************/

    57 #define xmlSecSymbianCryptoEvpSignatureSize	\

    58     (sizeof(xmlSecTransform) + sizeof(xmlSecSymbianCryptoEvpSignatureCtx))

    59 #define xmlSecSymbianCryptoEvpSignatureGetCtx(transform) \

    60     ((xmlSecSymbianCryptoEvpSignatureCtxPtr)(((xmlSecByte*)(transform)) + sizeof(xmlSecTransform)))

    61 

    62 static int	xmlSecSymbianCryptoEvpSignatureCheckId		(xmlSecTransformPtr transform);

    63 static int	xmlSecSymbianCryptoEvpSignatureInitialize		(xmlSecTransformPtr transform);

    64 static void	xmlSecSymbianCryptoEvpSignatureFinalize		(xmlSecTransformPtr transform);

    65 static int  	xmlSecSymbianCryptoEvpSignatureSetKeyReq		(xmlSecTransformPtr transform, 

    66 								 xmlSecKeyReqPtr keyReq);

    67 static int	xmlSecSymbianCryptoEvpSignatureSetKey			(xmlSecTransformPtr transform,

    68 								 xmlSecKeyPtr key);

    69 static int  	xmlSecSymbianCryptoEvpSignatureVerify			(xmlSecTransformPtr transform, 

    70 								 const xmlSecByte* data,

    71 								 xmlSecSize dataSize,

    72 								 xmlSecTransformCtxPtr transformCtx);

    73 static int	xmlSecSymbianCryptoEvpSignatureExecute		(xmlSecTransformPtr transform, 

    74 								 int last,

    75 								 xmlSecTransformCtxPtr transformCtx);

    76 

    77 static int

    78 xmlSecSymbianCryptoEvpSignatureCheckId(xmlSecTransformPtr transform) {

    79 #ifndef XMLSEC_NO_DSA

    80 

    81 #ifndef XMLSEC_NO_SHA1

    82     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformDsaSha1Id)) {

    83 	return(1);

    84     } else

    85 #endif /* XMLSEC_NO_SHA1 */

    86 

    87 #endif /* XMLSEC_NO_DSA */

    88 

    89 #ifndef XMLSEC_NO_RSA

    90 

    91 #ifndef XMLSEC_NO_MD5

    92     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaMd5Id)) {

    93 	return(1);

    94     } else 

    95 #endif /* XMLSEC_NO_MD5 */

    96 

    97 #ifndef XMLSEC_NO_RIPEMD160

    98     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaRipemd160Id)) {

    99 	return(1);

   100     } else 

   101 #endif /* XMLSEC_NO_RIPEMD160 */

   102 

   103 #ifndef XMLSEC_NO_SHA1

   104     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha1Id)) {

   105 	return(1);

   106     } else 

   107 #endif /* XMLSEC_NO_SHA1 */

   108 

   109 #ifndef XMLSEC_NO_SHA224

   110     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha224Id)) {

   111 	return(1);

   112     } else 

   113 #endif /* XMLSEC_NO_SHA224 */

   114 

   115 #ifndef XMLSEC_NO_SHA256

   116     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha256Id)) {

   117 	return(1);

   118     } else 

   119 #endif /* XMLSEC_NO_SHA256 */

   120 

   121 #ifndef XMLSEC_NO_SHA384

   122     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha384Id)) {

   123 	return(1);

   124     } else 

   125 #endif /* XMLSEC_NO_SHA384 */

   126 

   127 #ifndef XMLSEC_NO_SHA512

   128     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha512Id)) {

   129 	return(1);

   130     } else 

   131 #endif /* XMLSEC_NO_SHA512 */

   132 

   133 #endif /* XMLSEC_NO_RSA */

   134     

   135     {

   136 	return(0);

   137     }

   138     

   139     return(0);

   140 }

   141 

   142 static int 

   143 xmlSecSymbianCryptoEvpSignatureInitialize(xmlSecTransformPtr transform) {

   144     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   145     xmlSecAssert2(xmlSecSymbianCryptoEvpSignatureCheckId(transform), -1);

   146     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize), -1);

   147 

   148     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   149     xmlSecAssert2(ctx, -1);

   150 

   151     memset(ctx, 0, sizeof(xmlSecSymbianCryptoEvpSignatureCtx));    

   152 

   153 #ifndef XMLSEC_NO_DSA

   154 

   155 #ifndef XMLSEC_NO_SHA1

   156     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformDsaSha1Id)) {

   157 	ctx->digest	= xmlSecSymbianCryptoDsaSha1Evp();

   158 	ctx->keyId	= xmlSecSymbianCryptoKeyDataDsaId;

   159     } else 

   160 #endif /* XMLSEC_NO_SHA1 */

   161 

   162 #endif /* XMLSEC_NO_DSA */

   163 

   164 #ifndef XMLSEC_NO_RSA

   165 

   166 #ifndef XMLSEC_NO_MD5

   167     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaMd5Id)) {

   168 	ctx->digest	= EVP_md5();

   169 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   170     } else 

   171 #endif /* XMLSEC_NO_MD5 */

   172 

   173 #ifndef XMLSEC_NO_RIPEMD160

   174     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaRipemd160Id)) {

   175 	ctx->digest	= EVP_ripemd160();

   176 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   177     } else 

   178 #endif /* XMLSEC_NO_RIPEMD160 */

   179 

   180 #ifndef XMLSEC_NO_SHA1

   181     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha1Id)) {

   182 //	ctx->digest	= EVP_sha1();

   183     ctx->digest = SC_MD_SHA1;

   184 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   185     } else 

   186 #endif /* XMLSEC_NO_SHA1 */

   187 

   188 #ifndef XMLSEC_NO_SHA224

   189     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha224Id)) {

   190 	ctx->digest	= EVP_sha224();

   191 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   192     } else 

   193 #endif /* XMLSEC_NO_SHA224 */

   194 

   195 #ifndef XMLSEC_NO_SHA256

   196     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha256Id)) {

   197 	ctx->digest	= EVP_sha256();

   198 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   199     } else 

   200 #endif /* XMLSEC_NO_SHA256 */

   201 

   202 #ifndef XMLSEC_NO_SHA384

   203     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha384Id)) {

   204 	ctx->digest	= EVP_sha384();

   205 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   206     } else 

   207 #endif /* XMLSEC_NO_SHA384 */

   208 

   209 #ifndef XMLSEC_NO_SHA512

   210     if(xmlSecTransformCheckId(transform, xmlSecSymbianCryptoTransformRsaSha512Id)) {

   211 	ctx->digest	= EVP_sha512();

   212 	ctx->keyId	= xmlSecSymbianCryptoKeyDataRsaId;

   213     } else 

   214 #endif /* XMLSEC_NO_SHA512 */

   215 

   216 #endif /* XMLSEC_NO_RSA */

   217 

   218     if(1) {

   219 	xmlSecError(XMLSEC_ERRORS_HERE, 

   220 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   221 		    NULL,

   222 		    XMLSEC_ERRORS_R_INVALID_TRANSFORM,

   223 		    XMLSEC_ERRORS_NO_MESSAGE);

   224 	return(-1);

   225     }

   226 

   227     return(0);

   228 }

   229 

   230 static void 

   231 xmlSecSymbianCryptoEvpSignatureFinalize(xmlSecTransformPtr transform) {

   232     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   233 

   234     xmlSecAssert(xmlSecSymbianCryptoEvpSignatureCheckId(transform));

   235     xmlSecAssert(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize));

   236 

   237     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   238     xmlSecAssert(ctx);

   239 

   240     

   241     if (ctx->pKey) {

   242 	sc_pkey_free(ctx->pKey);

   243     }

   244     

   245     if (ctx->digestCtx)

   246     {

   247     	sc_md_close(ctx->digestCtx);

   248     }

   249 

   250     memset(ctx, 0, sizeof(xmlSecSymbianCryptoEvpSignatureCtx));    

   251 }

   252 

   253 static int 

   254 xmlSecSymbianCryptoEvpSignatureSetKey(xmlSecTransformPtr transform, xmlSecKeyPtr key) {

   255     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   256     xmlSecKeyDataPtr value;

   257     EVP_PKEY* pKey;

   258 

   259     xmlSecAssert2(xmlSecSymbianCryptoEvpSignatureCheckId(transform), -1);

   260     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) 

   261                                 || (transform->operation == xmlSecTransformOperationVerify), -1);

   262     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize), -1);

   263     xmlSecAssert2(key, -1);

   264 

   265     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   266     xmlSecAssert2(ctx, -1);

   267     xmlSecAssert2(ctx->digest, -1);

   268     xmlSecAssert2(ctx->keyId, -1);

   269     xmlSecAssert2(xmlSecKeyCheckId(key, ctx->keyId), -1);

   270 

   271     value = xmlSecKeyGetValue(key);

   272     xmlSecAssert2(value, -1);

   273     

   274     pKey = xmlSecSymbianCryptoEvpKeyDataGetEvp(value);

   275     if (!pKey) {

   276 	xmlSecError(XMLSEC_ERRORS_HERE,

   277 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   278 		    "xmlSecSymbianCryptoEvpKeyDataGetEvp",

   279 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   280 		    XMLSEC_ERRORS_NO_MESSAGE);

   281 	return(-1);

   282     }

   283     

   284     if (ctx->pKey) {

   285 	sc_pkey_free(ctx->pKey);

   286     }

   287 

   288     ctx->pKey = xmlSecSymbianCryptoEvpKeyDup(pKey);	

   289     if (!ctx->pKey) {

   290 	xmlSecError(XMLSEC_ERRORS_HERE,

   291 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   292 		    "xmlSecSymbianCryptoEvpKeyDup",

   293 		    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   294 		    XMLSEC_ERRORS_NO_MESSAGE);

   295 	return(-1);

   296     }

   297 

   298     return(0);

   299 }

   300 

   301 static int  

   302 xmlSecSymbianCryptoEvpSignatureSetKeyReq(xmlSecTransformPtr transform,  xmlSecKeyReqPtr keyReq) {

   303     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   304 

   305     xmlSecAssert2(xmlSecSymbianCryptoEvpSignatureCheckId(transform), -1);

   306     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) 

   307                                 || (transform->operation == xmlSecTransformOperationVerify), -1);

   308     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize), -1);

   309     xmlSecAssert2(keyReq, -1);

   310 

   311     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   312     xmlSecAssert2(ctx, -1);

   313     xmlSecAssert2(ctx->keyId, -1);

   314 

   315     keyReq->keyId        = ctx->keyId;

   316     if (transform->operation == xmlSecTransformOperationSign) {

   317         keyReq->keyType  = xmlSecKeyDataTypePrivate;

   318 	keyReq->keyUsage = xmlSecKeyUsageSign;

   319     } else {

   320         keyReq->keyType  = xmlSecKeyDataTypePublic;

   321 	keyReq->keyUsage = xmlSecKeyUsageVerify;

   322     }

   323     return(0);

   324 }

   325 

   326 

   327 static int

   328 xmlSecSymbianCryptoEvpSignatureVerify(xmlSecTransformPtr transform, 

   329 			const xmlSecByte* data, xmlSecSize dataSize,

   330 			xmlSecTransformCtxPtr transformCtx) {

   331     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   332     int ret = -1;

   333     

   334     xmlSecAssert2(xmlSecSymbianCryptoEvpSignatureCheckId(transform), -1);

   335     xmlSecAssert2(transform->operation == xmlSecTransformOperationVerify, -1);

   336     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize), -1);

   337     xmlSecAssert2(transform->status == xmlSecTransformStatusFinished, -1);

   338     xmlSecAssert2(data, -1);

   339     xmlSecAssert2(transformCtx, -1);

   340 

   341     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   342     xmlSecAssert2(ctx, -1);

   343 

   344     ret = sc_verify_final(ctx->digestCtx, (xmlSecByte*)data, dataSize, ctx->pKey);

   345     if (ret < 0) {

   346 	xmlSecError(XMLSEC_ERRORS_HERE, 

   347 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   348 		    "EVP_VerifyFinal",

   349 		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   350 		    XMLSEC_ERRORS_NO_MESSAGE);

   351 	return(-1);

   352     } else if (ret != 1) {

   353 	xmlSecError(XMLSEC_ERRORS_HERE, 

   354 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   355 		    "EVP_VerifyFinal",

   356 		    XMLSEC_ERRORS_R_DATA_NOT_MATCH,

   357 		    "signature do not match");

   358 	transform->status = xmlSecTransformStatusFail;

   359 	return(0);

   360     }

   361         

   362     transform->status = xmlSecTransformStatusOk;

   363     return(0);

   364 }

   365 

   366 static int 

   367 xmlSecSymbianCryptoEvpSignatureExecute(xmlSecTransformPtr transform, 

   368                                 int last, 

   369                                 xmlSecTransformCtxPtr transformCtx) {

   370     xmlSecSymbianCryptoEvpSignatureCtxPtr ctx;

   371     xmlSecBufferPtr in, out;

   372     xmlSecSize inSize, outSize;

   373     int ret = -1;

   374     

   375     xmlSecAssert2(xmlSecSymbianCryptoEvpSignatureCheckId(transform), -1);

   376     xmlSecAssert2((transform->operation == xmlSecTransformOperationSign) 

   377                                 || (transform->operation == xmlSecTransformOperationVerify), -1);

   378     xmlSecAssert2(xmlSecTransformCheckSize(transform, xmlSecSymbianCryptoEvpSignatureSize), -1);

   379     xmlSecAssert2(transformCtx, -1);

   380 

   381     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   382     xmlSecAssert2(ctx, -1);

   383 

   384     in = &(transform->inBuf);

   385     out = &(transform->outBuf);

   386     inSize = xmlSecBufferGetSize(in);

   387     outSize = xmlSecBufferGetSize(out);    

   388     

   389     ctx = xmlSecSymbianCryptoEvpSignatureGetCtx(transform);

   390     xmlSecAssert2(ctx, -1);

   391     xmlSecAssert2(ctx->digest, -1);

   392     xmlSecAssert2(ctx->pKey, -1);

   393 

   394     if (transform->status == xmlSecTransformStatusNone) {

   395 	xmlSecAssert2(outSize == 0, -1);

   396 	

   397 	if (transform->operation == xmlSecTransformOperationSign) {	

   398 		// Initialization 

   399 	    ret = sc_sign_init(&(ctx->digestCtx), ctx->digest);

   400 	    if(ret != 0) {

   401 	        xmlSecSetErrorFlag( ret );

   402 		xmlSecError(XMLSEC_ERRORS_HERE, 

   403 			    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   404 			    "EVP_SignInit",

   405 			    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   406 			    XMLSEC_ERRORS_NO_MESSAGE);

   407 		return(-1);

   408 	    }

   409 

   410 	} else {

   411 	 	 ret = sc_verify_init(&(ctx->digestCtx), ctx->digest);

   412 		 if (ret != 0) {

   413 	        xmlSecSetErrorFlag( ret );

   414 		 xmlSecError(XMLSEC_ERRORS_HERE, 

   415 				    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   416 				    "EVP_SignInit",

   417 				    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   418 				    XMLSEC_ERRORS_NO_MESSAGE);

   419 		 return(-1);

   420 		 }

   421 	}

   422 	transform->status = xmlSecTransformStatusWorking;

   423     }

   424     

   425     if ((transform->status == xmlSecTransformStatusWorking) && (inSize > 0)) {

   426 	xmlSecAssert2(outSize == 0, -1);

   427 

   428 	if (transform->operation == xmlSecTransformOperationSign) {

   429 

   430 	    sc_sign_update(ctx->digestCtx, xmlSecBufferGetData(in), inSize);

   431 

   432 	} else {

   433 

   434 	    sc_verify_update(ctx->digestCtx, xmlSecBufferGetData(in), inSize);

   435 

   436 	}

   437 	    

   438 	ret = xmlSecBufferRemoveHead(in, inSize);

   439 	if (ret < 0) {

   440 	    xmlSecError(XMLSEC_ERRORS_HERE, 

   441 			xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   442 			"xmlSecBufferRemoveHead",

   443 			XMLSEC_ERRORS_R_XMLSEC_FAILED,

   444 			XMLSEC_ERRORS_NO_MESSAGE);

   445 	    return(-1);

   446 	}

   447     }

   448 

   449     if ((transform->status == xmlSecTransformStatusWorking) && (last != 0)) {

   450 	xmlSecAssert2(outSize == 0, -1);

   451 	if (transform->operation == xmlSecTransformOperationSign) {

   452 	    outSize = sc_pkey_size(ctx->pKey);

   453 #ifndef XMLSEC_NO_DSA 

   454 	    if (outSize < XMLSEC_OPENSSL_DSA_SIGNATURE_SIZE) {

   455 		outSize = XMLSEC_OPENSSL_DSA_SIGNATURE_SIZE;

   456 	    }

   457 #endif /* XMLSEC_NO_DSA */ 

   458 

   459 	    ret = xmlSecBufferSetMaxSize(out, outSize);

   460 	    if (ret < 0) {

   461 		xmlSecError(XMLSEC_ERRORS_HERE, 

   462 			    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   463 			    "xmlSecBufferSetMaxSize",

   464 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   465 			    "size=%d", outSize);

   466 		return(-1);

   467 	    }

   468 	

   469 	    ret = sc_sign_final(ctx->digestCtx, xmlSecBufferGetData(out), &outSize, ctx->pKey);

   470 	    if (ret < 0) {

   471 		xmlSecError(XMLSEC_ERRORS_HERE, 

   472 			    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   473 			    "EVP_SignFinal",

   474 			    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   475 			    XMLSEC_ERRORS_NO_MESSAGE);

   476 		return(-1);

   477 	    }

   478 		

   479 	    ret = xmlSecBufferSetSize(out, outSize);

   480 	    if (ret < 0) {

   481 		xmlSecError(XMLSEC_ERRORS_HERE, 

   482 			    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   483 			    "xmlSecBufferSetSize",

   484 			    XMLSEC_ERRORS_R_XMLSEC_FAILED,

   485 			    "size=%d", outSize);

   486 		return(-1);

   487 	    }

   488 	}

   489 	transform->status = xmlSecTransformStatusFinished;

   490     }

   491     

   492     if ((transform->status == xmlSecTransformStatusWorking) 

   493         || (transform->status == xmlSecTransformStatusFinished)) {

   494 	/* the only way we can get here is if there is no input */

   495 	xmlSecAssert2(xmlSecBufferGetSize(&(transform->inBuf)) == 0, -1);

   496     } else {

   497 	xmlSecError(XMLSEC_ERRORS_HERE, 

   498 		    xmlSecErrorsSafeString(xmlSecTransformGetName(transform)),

   499 		    NULL,

   500 		    XMLSEC_ERRORS_R_INVALID_STATUS,

   501 		    "status=%d", transform->status);

   502 	return(-1);

   503     }

   504     

   505     return(0);

   506 }

   507 

   508 #ifndef XMLSEC_NO_DSA

   509 

   510 #ifndef XMLSEC_NO_SHA1

   511 /****************************************************************************

   512  *

   513  * DSA-SHA1 signature transform

   514  *

   515  ***************************************************************************/

   516 static xmlSecTransformKlass xmlSecSymbianCryptoDsaSha1Klass = {

   517     /* klass/object sizes */

   518     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   519     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   520 

   521     xmlSecNameDsaSha1,				/* const xmlChar* name; */

   522     xmlSecHrefDsaSha1, 				/* const xmlChar* href; */

   523     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   524     

   525     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   526     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   527     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   528     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   529     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   530     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   531     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   532     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   533     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   534     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   535     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   536     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   537     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   538     

   539     NULL,					/* void* reserved0; */

   540     NULL,					/* void* reserved1; */

   541 };

   542 

   543 /**

   544  * xmlSecSymbianCryptoTransformDsaSha1GetKlass:

   545  * 

   546  * The DSA-SHA1 signature transform klass.

   547  *

   548  * Returns DSA-SHA1 signature transform klass.

   549  */

   550 xmlSecTransformId 

   551 xmlSecSymbianCryptoTransformDsaSha1GetKlass(void) {

   552     return(&xmlSecSymbianCryptoDsaSha1Klass);

   553 }

   554 

   555 /****************************************************************************

   556  *

   557  * DSA-SHA1 EVP

   558  *

   559  * XMLDSig specifies dsa signature packing not supported by SymbianCrypto so 

   560  * we created our own EVP_MD.

   561  *

   562  * http://www.w3.org/TR/xmldsig-core/#sec-SignatureAlg:

   563  * 

   564  * The output of the DSA algorithm consists of a pair of integers 

   565  * usually referred by the pair (r, s). The signature value consists of 

   566  * the base64 encoding of the concatenation of two octet-streams that 

   567  * respectively result from the octet-encoding of the values r and s in 

   568  * that order. Integer to octet-stream conversion must be done according 

   569  * to the I2OSP operation defined in the RFC 2437 [PKCS1] specification 

   570  * with a l parameter equal to 20. For example, the SignatureValue element 

   571  * for a DSA signature (r, s) with values specified in hexadecimal:

   572  *

   573  *  r = 8BAC1AB6 6410435C B7181F95 B16AB97C 92B341C0 

   574  *  s = 41E2345F 1F56DF24 58F426D1 55B4BA2D B6DCD8C8

   575  *       

   576  * from the example in Appendix 5 of the DSS standard would be

   577  *        

   578  * <SignatureValue>i6watmQQQ1y3GB+VsWq5fJKzQcBB4jRfH1bfJFj0JtFVtLotttzYyA==</SignatureValue>

   579  *

   580  ***************************************************************************/

   581 #ifndef XMLSEC_OPENSSL_096

   582 static int 

   583 xmlSecSymbianCryptoDsaSha1EvpInit(EVP_MD_CTX *ctx)

   584 { 

   585     return SHA1_Init(ctx->md_data); 

   586 }

   587 

   588 static int 

   589 xmlSecSymbianCryptoDsaSha1EvpUpdate(EVP_MD_CTX *ctx,const void *data,unsigned long count)

   590 { 

   591     return SHA1_Update(ctx->md_data,data,count); 

   592 }

   593 

   594 static int 

   595 xmlSecSymbianCryptoDsaSha1EvpFinal(EVP_MD_CTX *ctx,xmlSecByte *md)

   596 { 

   597     return SHA1_Final(md,ctx->md_data); 

   598 }

   599 #endif /* XMLSEC_OPENSSL_096 */

   600 

   601 static int 	

   602 xmlSecSymbianCryptoDsaSha1EvpSign(int type ATTRIBUTE_UNUSED, 

   603 			const xmlSecByte *dgst, int dlen,

   604 			xmlSecByte *sig, unsigned int *siglen, DSA *dsa) {

   605     DSA_SIG *s;

   606     int rSize, sSize;

   607 

   608     s = DSA_do_sign(dgst, dlen, dsa);

   609     if(!s) {

   610 	*siglen=0;

   611 	return(0);

   612     }

   613 

   614     rSize = BN_num_bytes(s->r);

   615     sSize = BN_num_bytes(s->s);

   616     if((rSize > (KXmlSecSymbianCryptoDsaSignatureSize / 2)) ||

   617        (sSize > (KXmlSecSymbianCryptoDsaSignatureSize / 2))) {

   618 	xmlSecError(XMLSEC_ERRORS_HERE,

   619 		    NULL,

   620 		    NULL,

   621 		    XMLSEC_ERRORS_R_INVALID_SIZE,

   622 		    "size(r)=%d or size(s)=%d > %d", 

   623 		    rSize, sSize, KXmlSecSymbianCryptoDsaSignatureSize / 2);

   624 	DSA_SIG_free(s);

   625 	return(0);

   626     }	

   627 

   628     memset(sig, 0, KXmlSecSymbianCryptoDsaSignatureSize);

   629     BN_bn2bin(s->r, sig + (KXmlSecSymbianCryptoDsaSignatureSize / 2) - rSize);

   630     BN_bn2bin(s->s, sig + KXmlSecSymbianCryptoDsaSignatureSize - sSize);

   631     *siglen = KXmlSecSymbianCryptoDsaSignatureSize;

   632 

   633     DSA_SIG_free(s);

   634     return(1);    

   635 }

   636 

   637 static int 

   638 xmlSecSymbianCryptoDsaSha1EvpVerify(int type ATTRIBUTE_UNUSED, 

   639 			const xmlSecByte *dgst, int dgst_len,

   640 			const xmlSecByte *sigbuf, int siglen, DSA *dsa) {

   641     DSA_SIG *s;    

   642     int ret = -1;

   643 

   644     s = DSA_SIG_new();

   645     if (!s) {

   646 	return(ret);

   647     }

   648 

   649     if(siglen != KXmlSecSymbianCryptoDsaSignatureSize) {

   650 	xmlSecError(XMLSEC_ERRORS_HERE,

   651 		    NULL,

   652 		    NULL,

   653 		    XMLSEC_ERRORS_R_INVALID_SIZE,

   654 		    "invalid length %d (%d expected)",

   655 		    siglen, KXmlSecSymbianCryptoDsaSignatureSize);

   656 	goto err;

   657     }

   658 

   659     s->r = BN_bin2bn(sigbuf, KXmlSecSymbianCryptoDsaSignatureSize / 2, NULL);

   660     s->s = BN_bin2bn(sigbuf + (KXmlSecSymbianCryptoDsaSignatureSize / 2), 

   661 		       KXmlSecSymbianCryptoDsaSignatureSize / 2, NULL);

   662     if((!s->r) || (!s->s)) {

   663 	xmlSecError(XMLSEC_ERRORS_HERE,

   664 		    NULL,

   665 		    "BN_bin2bn",

   666 		    XMLSEC_ERRORS_R_CRYPTO_FAILED,

   667 		    XMLSEC_ERRORS_NO_MESSAGE);

   668 	goto err;

   669     }

   670 

   671     ret = DSA_do_verify(dgst, dgst_len, s, dsa);

   672 

   673 err:

   674     DSA_SIG_free(s);

   675     return(ret);

   676 }

   677 

   678 static const EVP_MD xmlSecSymbianCryptoDsaMdEvp = {

   679     NID_dsaWithSHA,

   680     NID_dsaWithSHA,

   681     SHA_DIGEST_LENGTH,

   682 #ifndef XMLSEC_OPENSSL_096

   683     0,

   684     xmlSecSymbianCryptoDsaSha1EvpInit,

   685     xmlSecSymbianCryptoDsaSha1EvpUpdate,

   686     xmlSecSymbianCryptoDsaSha1EvpFinal,

   687     NULL,

   688     NULL,

   689 #else /* XMLSEC_OPENSSL_096 */

   690     SHA1_Init,

   691     SHA1_Update,

   692     SHA1_Final,

   693 #endif /* XMLSEC_OPENSSL_096 */

   694     xmlSecSymbianCryptoDsaSha1EvpSign,

   695     xmlSecSymbianCryptoDsaSha1EvpVerify, 

   696     {EVP_PKEY_DSA,EVP_PKEY_DSA2,EVP_PKEY_DSA3,EVP_PKEY_DSA4,0},

   697     SHA_CBLOCK,

   698     sizeof(EVP_MD *)+sizeof(SHA_CTX),

   699 };

   700 

   701 static const EVP_MD *xmlSecSymbianCryptoDsaSha1Evp(void)

   702 {

   703     return(&xmlSecSymbianCryptoDsaMdEvp);

   704 }

   705 #endif /* XMLSEC_NO_SHA1 */

   706 

   707 #endif /* XMLSEC_NO_DSA */

   708 

   709 #ifndef XMLSEC_NO_RSA

   710 

   711 #ifndef XMLSEC_NO_MD5

   712 /****************************************************************************

   713  *

   714  * RSA-MD5 signature transform

   715  *

   716  ***************************************************************************/

   717 static xmlSecTransformKlass xmlSecSymbianCryptoRsaMd5Klass = {

   718     /* klass/object sizes */

   719     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   720     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   721 

   722     xmlSecNameRsaMd5,				/* const xmlChar* name; */

   723     xmlSecHrefRsaMd5, 				/* const xmlChar* href; */

   724     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   725     

   726     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   727     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   728     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   729     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   730     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   731     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   732     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   733     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   734     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   735     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   736     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   737     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   738     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   739     

   740     NULL,					/* void* reserved0; */

   741     NULL,					/* void* reserved1; */

   742 };

   743 

   744 /**

   745  * xmlSecSymbianCryptoTransformRsaMd5GetKlass:

   746  * 

   747  * The RSA-MD5 signature transform klass.

   748  *

   749  * Returns RSA-MD5 signature transform klass.

   750  */

   751 xmlSecTransformId 

   752 xmlSecSymbianCryptoTransformRsaMd5GetKlass(void) {

   753     return(&xmlSecSymbianCryptoRsaMd5Klass);

   754 }

   755 

   756 #endif /* XMLSEC_NO_MD5 */

   757 

   758 #ifndef XMLSEC_NO_RIPEMD160

   759 /****************************************************************************

   760  *

   761  * RSA-RIPEMD160 signature transform

   762  *

   763  ***************************************************************************/

   764 static xmlSecTransformKlass xmlSecSymbianCryptoRsaRipemd160Klass = {

   765     /* klass/object sizes */

   766     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   767     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   768 

   769     xmlSecNameRsaRipemd160,				/* const xmlChar* name; */

   770     xmlSecHrefRsaRipemd160, 				/* const xmlChar* href; */

   771     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   772     

   773     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   774     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   775     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   776     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   777     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   778     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   779     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   780     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   781     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   782     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   783     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   784     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   785     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   786     

   787     NULL,					/* void* reserved0; */

   788     NULL,					/* void* reserved1; */

   789 };

   790 

   791 /**

   792  * xmlSecSymbianCryptoTransformRsaRipemd160GetKlass:

   793  * 

   794  * The RSA-RIPEMD160 signature transform klass.

   795  *

   796  * Returns RSA-RIPEMD160 signature transform klass.

   797  */

   798 xmlSecTransformId 

   799 xmlSecSymbianCryptoTransformRsaRipemd160GetKlass(void) {

   800     return(&xmlSecSymbianCryptoRsaRipemd160Klass);

   801 }

   802 

   803 #endif /* XMLSEC_NO_RIPEMD160 */

   804 

   805 #ifndef XMLSEC_NO_SHA1

   806 /****************************************************************************

   807  *

   808  * RSA-SHA1 signature transform

   809  *

   810  ***************************************************************************/

   811 static xmlSecTransformKlass xmlSecSymbianCryptoRsaSha1Klass = {

   812     /* klass/object sizes */

   813     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   814     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   815 

   816     xmlSecNameRsaSha1,				/* const xmlChar* name; */

   817     xmlSecHrefRsaSha1, 				/* const xmlChar* href; */

   818     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   819     

   820     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   821     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   822     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   823     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   824     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   825     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   826     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   827     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   828     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   829     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   830     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   831     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   832     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   833     

   834     NULL,					/* void* reserved0; */

   835     NULL,					/* void* reserved1; */

   836 };

   837 

   838 /**

   839  * xmlSecSymbianCryptoTransformRsaSha1GetKlass:

   840  * 

   841  * The RSA-SHA1 signature transform klass.

   842  *

   843  * Returns RSA-SHA1 signature transform klass.

   844  */

   845 EXPORT_C

   846 xmlSecTransformId 

   847 xmlSecSymbianCryptoTransformRsaSha1GetKlass(void) {

   848     return(&xmlSecSymbianCryptoRsaSha1Klass);

   849 }

   850 

   851 #endif /* XMLSEC_NO_SHA1 */

   852 

   853 #ifndef XMLSEC_NO_SHA224

   854 /****************************************************************************

   855  *

   856  * RSA-SHA224 signature transform

   857  *

   858  ***************************************************************************/

   859 static xmlSecTransformKlass xmlSecSymbianCryptoRsaSha224Klass = {

   860     /* klass/object sizes */

   861     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   862     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   863 

   864     xmlSecNameRsaSha224,				/* const xmlChar* name; */

   865     xmlSecHrefRsaSha224, 				/* const xmlChar* href; */

   866     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   867     

   868     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   869     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   870     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   871     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   872     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   873     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   874     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   875     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   876     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   877     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   878     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   879     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   880     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   881     

   882     NULL,					/* void* reserved0; */

   883     NULL,					/* void* reserved1; */

   884 };

   885 

   886 /**

   887  * xmlSecSymbianCryptoTransformRsaSha224GetKlass:

   888  * 

   889  * The RSA-SHA224 signature transform klass.

   890  *

   891  * Returns RSA-SHA224 signature transform klass.

   892  */

   893 xmlSecTransformId 

   894 xmlSecSymbianCryptoTransformRsaSha224GetKlass(void) {

   895     return(&xmlSecSymbianCryptoRsaSha224Klass);

   896 }

   897 

   898 #endif /* XMLSEC_NO_SHA224 */

   899 

   900 #ifndef XMLSEC_NO_SHA256

   901 /****************************************************************************

   902  *

   903  * RSA-SHA256 signature transform

   904  *

   905  ***************************************************************************/

   906 static xmlSecTransformKlass xmlSecSymbianCryptoRsaSha256Klass = {

   907     /* klass/object sizes */

   908     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   909     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   910 

   911     xmlSecNameRsaSha256,				/* const xmlChar* name; */

   912     xmlSecHrefRsaSha256, 				/* const xmlChar* href; */

   913     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   914     

   915     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   916     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   917     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   918     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   919     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   920     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   921     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   922     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   923     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   924     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   925     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   926     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   927     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   928     

   929     NULL,					/* void* reserved0; */

   930     NULL,					/* void* reserved1; */

   931 };

   932 

   933 /**

   934  * xmlSecSymbianCryptoTransformRsaSha256GetKlass:

   935  * 

   936  * The RSA-SHA256 signature transform klass.

   937  *

   938  * Returns RSA-SHA256 signature transform klass.

   939  */

   940 xmlSecTransformId 

   941 xmlSecSymbianCryptoTransformRsaSha256GetKlass(void) {

   942     return(&xmlSecSymbianCryptoRsaSha256Klass);

   943 }

   944 

   945 #endif /* XMLSEC_NO_SHA256 */

   946 

   947 #ifndef XMLSEC_NO_SHA384

   948 /****************************************************************************

   949  *

   950  * RSA-SHA384 signature transform

   951  *

   952  ***************************************************************************/

   953 static xmlSecTransformKlass xmlSecSymbianCryptoRsaSha384Klass = {

   954     /* klass/object sizes */

   955     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

   956     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

   957 

   958     xmlSecNameRsaSha384,				/* const xmlChar* name; */

   959     xmlSecHrefRsaSha384, 				/* const xmlChar* href; */

   960     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

   961     

   962     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

   963     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

   964     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

   965     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

   966     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

   967     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

   968     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

   969     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

   970     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

   971     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

   972     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

   973     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

   974     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

   975     

   976     NULL,					/* void* reserved0; */

   977     NULL,					/* void* reserved1; */

   978 };

   979 

   980 /**

   981  * xmlSecSymbianCryptoTransformRsaSha384GetKlass:

   982  * 

   983  * The RSA-SHA384 signature transform klass.

   984  *

   985  * Returns RSA-SHA384 signature transform klass.

   986  */

   987 xmlSecTransformId 

   988 xmlSecSymbianCryptoTransformRsaSha384GetKlass(void) {

   989     return(&xmlSecSymbianCryptoRsaSha384Klass);

   990 }

   991 

   992 #endif /* XMLSEC_NO_SHA384 */

   993 

   994 #ifndef XMLSEC_NO_SHA512

   995 /****************************************************************************

   996  *

   997  * RSA-SHA512 signature transform

   998  *

   999  ***************************************************************************/

  1000 static xmlSecTransformKlass xmlSecSymbianCryptoRsaSha512Klass = {

  1001     /* klass/object sizes */

  1002     sizeof(xmlSecTransformKlass),		/* xmlSecSize klassSize */

  1003     xmlSecSymbianCryptoEvpSignatureSize,		/* xmlSecSize objSize */

  1004 

  1005     xmlSecNameRsaSha512,				/* const xmlChar* name; */

  1006     xmlSecHrefRsaSha512, 				/* const xmlChar* href; */

  1007     xmlSecTransformUsageSignatureMethod,	/* xmlSecTransformUsage usage; */

  1008     

  1009     xmlSecSymbianCryptoEvpSignatureInitialize,	/* xmlSecTransformInitializeMethod initialize; */

  1010     xmlSecSymbianCryptoEvpSignatureFinalize,		/* xmlSecTransformFinalizeMethod finalize; */

  1011     NULL,					/* xmlSecTransformNodeReadMethod readNode; */

  1012     NULL,					/* xmlSecTransformNodeWriteMethod writeNode; */

  1013     xmlSecSymbianCryptoEvpSignatureSetKeyReq,		/* xmlSecTransformSetKeyReqMethod setKeyReq; */

  1014     xmlSecSymbianCryptoEvpSignatureSetKey,		/* xmlSecTransformSetKeyMethod setKey; */

  1015     xmlSecSymbianCryptoEvpSignatureVerify,		/* xmlSecTransformVerifyMethod verify; */

  1016     xmlSecCrpytoGetDataTypeMethod,		/* xmlSecTransformGetDataTypeMethod getDataType; */

  1017     xmlSecCryptoPushBinMethod,		/* xmlSecTransformPushBinMethod pushBin; */

  1018     xmlSecCryptoPopBinMethod,		/* xmlSecTransformPopBinMethod popBin; */

  1019     NULL,					/* xmlSecTransformPushXmlMethod pushXml; */

  1020     NULL,					/* xmlSecTransformPopXmlMethod popXml; */

  1021     xmlSecSymbianCryptoEvpSignatureExecute,		/* xmlSecTransformExecuteMethod execute; */

  1022     

  1023     NULL,					/* void* reserved0; */

  1024     NULL,					/* void* reserved1; */

  1025 };

  1026 

  1027 /**

  1028  * xmlSecSymbianCryptoTransformRsaSha512GetKlass:

  1029  * 

  1030  * The RSA-SHA512 signature transform klass.

  1031  *

  1032  * Returns RSA-SHA512 signature transform klass.

  1033  */

  1034 xmlSecTransformId 

  1035 xmlSecSymbianCryptoTransformRsaSha512GetKlass(void) {

  1036     return(&xmlSecSymbianCryptoRsaSha512Klass);

  1037 }

  1038 

  1039 #endif /* XMLSEC_NO_SHA512 */

  1040 

  1041 #endif /* XMLSEC_NO_RSA */

  1042 

  1043 

  1044