|
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 |