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