Line data Source code
1 : /**
2 : * XML Security Library (http://www.aleksey.com/xmlsec).
3 : *
4 : * Key data.
5 : *
6 : * This is free software; see Copyright file in the source
7 : * distribution for preciese wording.
8 : *
9 : * Copyright (C) 2002-2003 Aleksey Sanin <aleksey@aleksey.com>
10 : */
11 :
12 : #include "globals.h"
13 :
14 : #include <stdlib.h>
15 : #include <string.h>
16 :
17 : #include <libxml/tree.h>
18 :
19 : #include <xmlsec/xmlsec.h>
20 : #include <xmlsec/xmltree.h>
21 : #include <xmlsec/keys.h>
22 : #include <xmlsec/keyinfo.h>
23 : #include <xmlsec/transforms.h>
24 : #include <xmlsec/base64.h>
25 : #include <xmlsec/keyinfo.h>
26 : #include <xmlsec/errors.h>
27 :
28 :
29 : /**************************************************************************
30 : *
31 : * Global xmlSecKeyDataIds list functions
32 : *
33 : *************************************************************************/
34 : static xmlSecPtrList xmlSecAllKeyDataIds;
35 :
36 : /**
37 : * xmlSecKeyDataIdsGet:
38 : *
39 : * Gets global registered key data klasses list.
40 : *
41 : * Returns: the pointer to list of all registered key data klasses.
42 : */
43 : xmlSecPtrListPtr
44 0 : xmlSecKeyDataIdsGet(void) {
45 0 : return(&xmlSecAllKeyDataIds);
46 : }
47 :
48 : /**
49 : * xmlSecKeyDataIdsInit:
50 : *
51 : * Initializes the key data klasses. This function is called from the
52 : * #xmlSecInit function and the application should not call it directly.
53 : *
54 : * Returns: 0 on success or a negative value if an error occurs.
55 : */
56 : int
57 0 : xmlSecKeyDataIdsInit(void) {
58 : int ret;
59 :
60 0 : ret = xmlSecPtrListInitialize(xmlSecKeyDataIdsGet(), xmlSecKeyDataIdListId);
61 0 : if(ret < 0) {
62 0 : xmlSecError(XMLSEC_ERRORS_HERE,
63 : NULL,
64 : "xmlSecPtrListPtrInitialize",
65 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
66 : "xmlSecKeyDataIdListId");
67 0 : return(-1);
68 : }
69 :
70 0 : ret = xmlSecKeyDataIdsRegisterDefault();
71 0 : if(ret < 0) {
72 0 : xmlSecError(XMLSEC_ERRORS_HERE,
73 : NULL,
74 : "xmlSecKeyDataIdsRegisterDefault",
75 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
76 : XMLSEC_ERRORS_NO_MESSAGE);
77 0 : return(-1);
78 : }
79 :
80 0 : return(0);
81 : }
82 :
83 : /**
84 : * xmlSecKeyDataIdsShutdown:
85 : *
86 : * Shuts down the keys data klasses. This function is called from the
87 : * #xmlSecShutdown function and the application should not call it directly.
88 : */
89 : void
90 0 : xmlSecKeyDataIdsShutdown(void) {
91 0 : xmlSecPtrListFinalize(xmlSecKeyDataIdsGet());
92 0 : }
93 :
94 : /**
95 : * xmlSecKeyDataIdsRegister:
96 : * @id: the key data klass.
97 : *
98 : * Registers @id in the global list of key data klasses.
99 : *
100 : * Returns: 0 on success or a negative value if an error occurs.
101 : */
102 : int
103 0 : xmlSecKeyDataIdsRegister(xmlSecKeyDataId id) {
104 : int ret;
105 :
106 0 : xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);
107 :
108 0 : ret = xmlSecPtrListAdd(xmlSecKeyDataIdsGet(), (xmlSecPtr)id);
109 0 : if(ret < 0) {
110 0 : xmlSecError(XMLSEC_ERRORS_HERE,
111 : NULL,
112 : "xmlSecPtrListAdd",
113 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
114 : "dataId=%s",
115 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)));
116 0 : return(-1);
117 : }
118 :
119 0 : return(0);
120 : }
121 :
122 : /**
123 : * xmlSecKeyDataIdsRegisterDefault:
124 : *
125 : * Registers default (implemented by XML Security Library)
126 : * key data klasses: <dsig:KeyName/> element processing klass,
127 : * <dsig:KeyValue/> element processing klass, ...
128 : *
129 : * Returns: 0 on success or a negative value if an error occurs.
130 : */
131 : int
132 0 : xmlSecKeyDataIdsRegisterDefault(void) {
133 0 : if(xmlSecKeyDataIdsRegister(xmlSecKeyDataNameId) < 0) {
134 0 : xmlSecError(XMLSEC_ERRORS_HERE,
135 : NULL,
136 : "xmlSecKeyDataIdsRegister",
137 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
138 : "xmlSecKeyDataNameId");
139 0 : return(-1);
140 : }
141 :
142 0 : if(xmlSecKeyDataIdsRegister(xmlSecKeyDataValueId) < 0) {
143 0 : xmlSecError(XMLSEC_ERRORS_HERE,
144 : NULL,
145 : "xmlSecKeyDataIdsRegister",
146 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
147 : "xmlSecKeyDataValueId");
148 0 : return(-1);
149 : }
150 :
151 0 : if(xmlSecKeyDataIdsRegister(xmlSecKeyDataRetrievalMethodId) < 0) {
152 0 : xmlSecError(XMLSEC_ERRORS_HERE,
153 : NULL,
154 : "xmlSecKeyDataIdsRegister",
155 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
156 : "xmlSecKeyDataRetrievalMethodId");
157 0 : return(-1);
158 : }
159 :
160 : #ifndef XMLSEC_NO_XMLENC
161 0 : if(xmlSecKeyDataIdsRegister(xmlSecKeyDataEncryptedKeyId) < 0) {
162 0 : xmlSecError(XMLSEC_ERRORS_HERE,
163 : NULL,
164 : "xmlSecKeyDataIdsRegister",
165 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
166 : "xmlSecKeyDataEncryptedKeyId");
167 0 : return(-1);
168 : }
169 : #endif /* XMLSEC_NO_XMLENC */
170 :
171 0 : return(0);
172 : }
173 :
174 : /**************************************************************************
175 : *
176 : * xmlSecKeyData functions
177 : *
178 : *************************************************************************/
179 : /**
180 : * xmlSecKeyDataCreate:
181 : * @id: the data id.
182 : *
183 : * Allocates and initializes new key data of the specified type @id.
184 : * Caller is responsible for destroing returend object with
185 : * #xmlSecKeyDataDestroy function.
186 : *
187 : * Returns: the pointer to newly allocated key data structure
188 : * or NULL if an error occurs.
189 : */
190 : xmlSecKeyDataPtr
191 0 : xmlSecKeyDataCreate(xmlSecKeyDataId id) {
192 : xmlSecKeyDataPtr data;
193 : int ret;
194 :
195 0 : xmlSecAssert2(id != NULL, NULL);
196 0 : xmlSecAssert2(id->klassSize >= sizeof(xmlSecKeyDataKlass), NULL);
197 0 : xmlSecAssert2(id->objSize >= sizeof(xmlSecKeyData), NULL);
198 0 : xmlSecAssert2(id->name != NULL, NULL);
199 :
200 : /* Allocate a new xmlSecKeyData and fill the fields. */
201 0 : data = (xmlSecKeyDataPtr)xmlMalloc(id->objSize);
202 0 : if(data == NULL) {
203 0 : xmlSecError(XMLSEC_ERRORS_HERE,
204 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
205 : NULL,
206 : XMLSEC_ERRORS_R_MALLOC_FAILED,
207 : "size=%d", id->objSize);
208 0 : return(NULL);
209 : }
210 0 : memset(data, 0, id->objSize);
211 0 : data->id = id;
212 :
213 0 : if(id->initialize != NULL) {
214 0 : ret = (id->initialize)(data);
215 0 : if(ret < 0) {
216 0 : xmlSecError(XMLSEC_ERRORS_HERE,
217 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
218 : "id->initialize",
219 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
220 : XMLSEC_ERRORS_NO_MESSAGE);
221 0 : xmlSecKeyDataDestroy(data);
222 0 : return(NULL);
223 : }
224 : }
225 :
226 0 : return(data);
227 : }
228 :
229 : /**
230 : * xmlSecKeyDataDuplicate:
231 : * @data: the pointer to the key data.
232 : *
233 : * Creates a duplicate of the given @data. Caller is responsible for
234 : * destroing returend object with #xmlSecKeyDataDestroy function.
235 : *
236 : * Returns: the pointer to newly allocated key data structure
237 : * or NULL if an error occurs.
238 : */
239 : xmlSecKeyDataPtr
240 0 : xmlSecKeyDataDuplicate(xmlSecKeyDataPtr data) {
241 : xmlSecKeyDataPtr newData;
242 : int ret;
243 :
244 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);
245 0 : xmlSecAssert2(data->id->duplicate != NULL, NULL);
246 :
247 0 : newData = xmlSecKeyDataCreate(data->id);
248 0 : if(newData == NULL) {
249 0 : xmlSecError(XMLSEC_ERRORS_HERE,
250 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
251 : "xmlSecKeyDataCreate",
252 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
253 : XMLSEC_ERRORS_NO_MESSAGE);
254 0 : return(NULL);
255 : }
256 :
257 0 : ret = (data->id->duplicate)(newData, data);
258 0 : if(newData == NULL) {
259 0 : xmlSecError(XMLSEC_ERRORS_HERE,
260 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
261 : "id->duplicate",
262 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
263 : XMLSEC_ERRORS_NO_MESSAGE);
264 0 : xmlSecKeyDataDestroy(newData);
265 0 : return(NULL);
266 : }
267 :
268 0 : return(newData);
269 : }
270 :
271 : /**
272 : * xmlSecKeyDataDestroy:
273 : * @data: the pointer to the key data.
274 : *
275 : * Destroys the data and frees all allocated memory.
276 : */
277 : void
278 0 : xmlSecKeyDataDestroy(xmlSecKeyDataPtr data) {
279 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
280 0 : xmlSecAssert(data->id->objSize > 0);
281 :
282 0 : if(data->id->finalize != NULL) {
283 0 : (data->id->finalize)(data);
284 : }
285 0 : memset(data, 0, data->id->objSize);
286 0 : xmlFree(data);
287 : }
288 :
289 :
290 : /**
291 : * xmlSecKeyDataXmlRead:
292 : * @id: the data klass.
293 : * @key: the destination key.
294 : * @node: the pointer to an XML node.
295 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
296 : *
297 : * Reads the key data of klass @id from XML @node and adds them to @key.
298 : *
299 : * Returns: 0 on success or a negative value otherwise.
300 : */
301 : int
302 0 : xmlSecKeyDataXmlRead(xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {
303 0 : xmlSecAssert2(id != NULL, -1);
304 0 : xmlSecAssert2(id->xmlRead != NULL, -1);
305 0 : xmlSecAssert2(key != NULL, -1);
306 0 : xmlSecAssert2(node != NULL, -1);
307 :
308 0 : return((id->xmlRead)(id, key, node, keyInfoCtx));
309 : }
310 :
311 : /**
312 : * xmlSecKeyDataXmlWrite:
313 : * @id: the data klass.
314 : * @key: the source key.
315 : * @node: the pointer to an XML node.
316 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
317 : *
318 : * Writes the key data of klass @id from @key to an XML @node.
319 : *
320 : * Returns: 0 on success or a negative value otherwise.
321 : */
322 : int
323 0 : xmlSecKeyDataXmlWrite(xmlSecKeyDataId id, xmlSecKeyPtr key, xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {
324 0 : xmlSecAssert2(id != NULL, -1);
325 0 : xmlSecAssert2(id->xmlWrite != NULL, -1);
326 0 : xmlSecAssert2(key != NULL, -1);
327 0 : xmlSecAssert2(node != NULL, -1);
328 :
329 0 : return((id->xmlWrite)(id, key, node, keyInfoCtx));
330 : }
331 :
332 : /**
333 : * xmlSecKeyDataBinRead:
334 : * @id: the data klass.
335 : * @key: the destination key.
336 : * @buf: the input binary buffer.
337 : * @bufSize: the input buffer size.
338 : * @keyInfoCtx: the <dsig:KeyInfo/> node processing context.
339 : *
340 : * Reads the key data of klass @id from binary buffer @buf to @key.
341 : *
342 : * Returns: 0 on success or a negative value if an error occurs.
343 : */
344 : int
345 0 : xmlSecKeyDataBinRead(xmlSecKeyDataId id, xmlSecKeyPtr key,
346 : const xmlSecByte* buf, xmlSecSize bufSize,
347 : xmlSecKeyInfoCtxPtr keyInfoCtx) {
348 0 : xmlSecAssert2(id != NULL, -1);
349 0 : xmlSecAssert2(id->binRead != NULL, -1);
350 0 : xmlSecAssert2(key != NULL, -1);
351 0 : xmlSecAssert2(buf != NULL, -1);
352 :
353 0 : return((id->binRead)(id, key, buf, bufSize, keyInfoCtx));
354 : }
355 :
356 : /**
357 : * xmlSecKeyDataBinWrite:
358 : * @id: the data klass.
359 : * @key: the source key.
360 : * @buf: the output binary buffer.
361 : * @bufSize: the output buffer size.
362 : * @keyInfoCtx: the <dsig:KeyInfo/> node processing context.
363 : *
364 : * Writes the key data of klass @id from the @key to a binary buffer @buf.
365 : *
366 : * Returns: 0 on success or a negative value if an error occurs.
367 : */
368 : int
369 0 : xmlSecKeyDataBinWrite(xmlSecKeyDataId id, xmlSecKeyPtr key,
370 : xmlSecByte** buf, xmlSecSize* bufSize,
371 : xmlSecKeyInfoCtxPtr keyInfoCtx) {
372 0 : xmlSecAssert2(id != NULL, -1);
373 0 : xmlSecAssert2(id->binWrite != NULL, -1);
374 0 : xmlSecAssert2(key != NULL, -1);
375 0 : xmlSecAssert2(buf != NULL, -1);
376 :
377 0 : return((id->binWrite)(id, key, buf, bufSize, keyInfoCtx));
378 : }
379 :
380 : /**
381 : * xmlSecKeyDataGenerate:
382 : * @data: the pointer to key data.
383 : * @sizeBits: the desired key data size (in bits).
384 : * @type: the desired key data type.
385 : *
386 : * Generates new key data of given size and type.
387 : *
388 : * Returns: 0 on success or a negative value otherwise.
389 : */
390 : int
391 0 : xmlSecKeyDataGenerate(xmlSecKeyDataPtr data, xmlSecSize sizeBits,
392 : xmlSecKeyDataType type) {
393 : int ret;
394 :
395 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);
396 0 : xmlSecAssert2(data->id->generate != NULL, -1);
397 :
398 : /* write data */
399 0 : ret = data->id->generate(data, sizeBits, type);
400 0 : if(ret < 0) {
401 0 : xmlSecError(XMLSEC_ERRORS_HERE,
402 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
403 : "id->generate",
404 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
405 : "size=%d", sizeBits);
406 0 : return(-1);
407 : }
408 0 : return(0);
409 : }
410 :
411 : /**
412 : * xmlSecKeyDataGetType:
413 : * @data: the pointer to key data.
414 : *
415 : * Gets key data type.
416 : *
417 : * Returns: key data type.
418 : */
419 : xmlSecKeyDataType
420 0 : xmlSecKeyDataGetType(xmlSecKeyDataPtr data) {
421 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), xmlSecKeyDataTypeUnknown);
422 0 : xmlSecAssert2(data->id->getType != NULL, xmlSecKeyDataTypeUnknown);
423 :
424 0 : return(data->id->getType(data));
425 : }
426 :
427 : /**
428 : * xmlSecKeyDataGetSize:
429 : * @data: the pointer to key data.
430 : *
431 : * Gets key data size.
432 : *
433 : * Returns: key data size (in bits).
434 : */
435 : xmlSecSize
436 0 : xmlSecKeyDataGetSize(xmlSecKeyDataPtr data) {
437 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), 0);
438 0 : xmlSecAssert2(data->id->getSize != NULL, 0);
439 :
440 0 : return(data->id->getSize(data));
441 : }
442 :
443 : /**
444 : * xmlSecKeyDataGetIdentifier:
445 : * @data: the pointer to key data.
446 : *
447 : * Gets key data identifier string.
448 : *
449 : * Returns: key data id string.
450 : */
451 : const xmlChar*
452 0 : xmlSecKeyDataGetIdentifier(xmlSecKeyDataPtr data) {
453 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);
454 0 : xmlSecAssert2(data->id->getIdentifier != NULL, NULL);
455 :
456 0 : return(data->id->getIdentifier(data));
457 : }
458 :
459 : /**
460 : * xmlSecKeyDataDebugDump:
461 : * @data: the pointer to key data.
462 : * @output: the pointer to output FILE.
463 : *
464 : * Prints key data debug info.
465 : */
466 : void
467 0 : xmlSecKeyDataDebugDump(xmlSecKeyDataPtr data, FILE *output) {
468 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
469 0 : xmlSecAssert(data->id->debugDump != NULL);
470 0 : xmlSecAssert(output != NULL);
471 :
472 0 : data->id->debugDump(data, output);
473 : }
474 :
475 : /**
476 : * xmlSecKeyDataDebugXmlDump:
477 : * @data: the pointer to key data.
478 : * @output: the pointer to output FILE.
479 : *
480 : * Prints key data debug info in XML format.
481 : */
482 : void
483 0 : xmlSecKeyDataDebugXmlDump(xmlSecKeyDataPtr data, FILE *output) {
484 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
485 0 : xmlSecAssert(data->id->debugXmlDump != NULL);
486 0 : xmlSecAssert(output != NULL);
487 :
488 0 : data->id->debugXmlDump(data, output);
489 : }
490 :
491 : /**************************************************************************
492 : *
493 : * xmlSecKeyDataBinary methods
494 : *
495 : * key (xmlSecBuffer) is located after xmlSecKeyData structure
496 : *
497 : *************************************************************************/
498 : /**
499 : * xmlSecKeyDataBinaryValueInitialize:
500 : * @data: the pointer to binary key data.
501 : *
502 : * Initializes key data.
503 : *
504 : * Returns: 0 on success or a negative value otherwise.
505 : */
506 : int
507 0 : xmlSecKeyDataBinaryValueInitialize(xmlSecKeyDataPtr data) {
508 : xmlSecBufferPtr buffer;
509 : int ret;
510 :
511 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);
512 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize), -1);
513 :
514 : /* initialize buffer */
515 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
516 0 : xmlSecAssert2(buffer != NULL, -1);
517 :
518 0 : ret = xmlSecBufferInitialize(buffer, 0);
519 0 : if(ret < 0) {
520 0 : xmlSecError(XMLSEC_ERRORS_HERE,
521 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
522 : "xmlSecBufferInitialize",
523 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
524 : XMLSEC_ERRORS_NO_MESSAGE);
525 0 : return(-1);
526 : }
527 :
528 0 : return(0);
529 : }
530 :
531 : /**
532 : * xmlSecKeyDataBinaryValueDuplicate:
533 : * @dst: the pointer to destination binary key data.
534 : * @src: the pointer to source binary key data.
535 : *
536 : * Copies binary key data from @src to @dst.
537 : *
538 : * Returns: 0 on success or a negative value otherwise.
539 : */
540 : int
541 0 : xmlSecKeyDataBinaryValueDuplicate(xmlSecKeyDataPtr dst, xmlSecKeyDataPtr src) {
542 : xmlSecBufferPtr buffer;
543 : int ret;
544 :
545 0 : xmlSecAssert2(xmlSecKeyDataIsValid(dst), -1);
546 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(dst, xmlSecKeyDataBinarySize), -1);
547 0 : xmlSecAssert2(xmlSecKeyDataIsValid(src), -1);
548 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(src, xmlSecKeyDataBinarySize), -1);
549 :
550 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(src);
551 0 : xmlSecAssert2(buffer != NULL, -1);
552 :
553 : /* copy data */
554 0 : ret = xmlSecKeyDataBinaryValueSetBuffer(dst,
555 0 : xmlSecBufferGetData(buffer),
556 : xmlSecBufferGetSize(buffer));
557 0 : if(ret < 0) {
558 0 : xmlSecError(XMLSEC_ERRORS_HERE,
559 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(dst)),
560 : "xmlSecKeyDataBinaryValueSetBuffer",
561 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
562 : XMLSEC_ERRORS_NO_MESSAGE);
563 0 : return(-1);
564 : }
565 :
566 0 : return(0);
567 : }
568 :
569 : /**
570 : * xmlSecKeyDataBinaryValueFinalize:
571 : * @data: the pointer to binary key data.
572 : *
573 : * Cleans up binary key data.
574 : */
575 : void
576 0 : xmlSecKeyDataBinaryValueFinalize(xmlSecKeyDataPtr data) {
577 : xmlSecBufferPtr buffer;
578 :
579 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
580 0 : xmlSecAssert(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize));
581 :
582 : /* initialize buffer */
583 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
584 0 : xmlSecAssert(buffer != NULL);
585 :
586 0 : xmlSecBufferFinalize(buffer);
587 : }
588 :
589 : /**
590 : * xmlSecKeyDataBinaryValueXmlRead:
591 : * @id: the data klass.
592 : * @key: the pointer to destination key.
593 : * @node: the pointer to an XML node.
594 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
595 : *
596 : * Reads binary key data from @node to the key by base64 decoding the @node content.
597 : *
598 : * Returns: 0 on success or a negative value otherwise.
599 : */
600 : int
601 0 : xmlSecKeyDataBinaryValueXmlRead(xmlSecKeyDataId id, xmlSecKeyPtr key,
602 : xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {
603 : xmlChar* str;
604 : xmlSecSize len;
605 : xmlSecKeyDataPtr data;
606 : int ret;
607 :
608 0 : xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);
609 0 : xmlSecAssert2(key != NULL, -1);
610 0 : xmlSecAssert2(node != NULL, -1);
611 0 : xmlSecAssert2(keyInfoCtx != NULL, -1);
612 :
613 0 : str = xmlNodeGetContent(node);
614 0 : if(str == NULL) {
615 0 : xmlSecError(XMLSEC_ERRORS_HERE,
616 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
617 0 : xmlSecErrorsSafeString(xmlSecNodeGetName(node)),
618 : XMLSEC_ERRORS_R_INVALID_NODE_CONTENT,
619 : XMLSEC_ERRORS_NO_MESSAGE);
620 0 : return(-1);
621 : }
622 :
623 : /* usual trick: decode into the same buffer */
624 0 : ret = xmlSecBase64Decode(str, (xmlSecByte*)str, xmlStrlen(str));
625 0 : if(ret < 0) {
626 0 : xmlSecError(XMLSEC_ERRORS_HERE,
627 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
628 : "xmlSecBase64Decode",
629 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
630 : XMLSEC_ERRORS_NO_MESSAGE);
631 0 : xmlFree(str);
632 0 : return(-1);
633 : }
634 0 : len = ret;
635 :
636 : /* check do we have a key already */
637 0 : data = xmlSecKeyGetValue(key);
638 0 : if(data != NULL) {
639 : xmlSecBufferPtr buffer;
640 :
641 0 : if(!xmlSecKeyDataCheckId(data, id)) {
642 0 : xmlSecError(XMLSEC_ERRORS_HERE,
643 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
644 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
645 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
646 : XMLSEC_ERRORS_NO_MESSAGE);
647 0 : xmlFree(str);
648 0 : return(-1);
649 : }
650 :
651 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
652 0 : if((buffer != NULL) && ((xmlSecSize)xmlSecBufferGetSize(buffer) != len)) {
653 0 : xmlSecError(XMLSEC_ERRORS_HERE,
654 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
655 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
656 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
657 : "cur-data-size=%d;new-data-size=%d",
658 : xmlSecBufferGetSize(buffer), len);
659 0 : xmlFree(str);
660 0 : return(-1);
661 : }
662 0 : if((buffer != NULL) && (len > 0) && (memcmp(xmlSecBufferGetData(buffer), str, len) != 0)) {
663 0 : xmlSecError(XMLSEC_ERRORS_HERE,
664 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
665 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
666 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
667 : "key already has a different value");
668 0 : xmlFree(str);
669 0 : return(-1);
670 : }
671 0 : if(buffer != NULL) {
672 : /* we already have exactly the same key */
673 0 : xmlFree(str);
674 0 : return(0);
675 : }
676 :
677 : /* we have binary key value with empty buffer */
678 : }
679 :
680 :
681 0 : data = xmlSecKeyDataCreate(id);
682 0 : if(data == NULL ) {
683 0 : xmlSecError(XMLSEC_ERRORS_HERE,
684 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
685 : "xmlSecKeyDataCreate",
686 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
687 : XMLSEC_ERRORS_NO_MESSAGE);
688 0 : xmlFree(str);
689 0 : return(-1);
690 : }
691 :
692 0 : ret = xmlSecKeyDataBinaryValueSetBuffer(data, (xmlSecByte*)str, len);
693 0 : if(ret < 0) {
694 0 : xmlSecError(XMLSEC_ERRORS_HERE,
695 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
696 : "xmlSecKeyDataBinaryValueSetBuffer",
697 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
698 : "size=%d", len);
699 0 : xmlSecKeyDataDestroy(data);
700 0 : xmlFree(str);
701 0 : return(-1);
702 : }
703 0 : xmlFree(str);
704 :
705 0 : if(xmlSecKeyReqMatchKeyValue(&(keyInfoCtx->keyReq), data) != 1) {
706 0 : xmlSecError(XMLSEC_ERRORS_HERE,
707 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
708 : "xmlSecKeyReqMatchKeyValue",
709 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
710 : XMLSEC_ERRORS_NO_MESSAGE);
711 0 : xmlSecKeyDataDestroy(data);
712 0 : return(0);
713 : }
714 :
715 0 : ret = xmlSecKeySetValue(key, data);
716 0 : if(ret < 0) {
717 0 : xmlSecError(XMLSEC_ERRORS_HERE,
718 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
719 : "xmlSecKeySetValue",
720 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
721 : XMLSEC_ERRORS_NO_MESSAGE);
722 0 : xmlSecKeyDataDestroy(data);
723 0 : return(-1);
724 : }
725 :
726 0 : return(0);
727 : }
728 :
729 : /**
730 : * xmlSecKeyDataBinaryValueXmlWrite:
731 : * @id: the data klass.
732 : * @key: the pointer to source key.
733 : * @node: the pointer to an XML node.
734 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
735 : *
736 : * Base64 encodes binary key data of klass @id from the @key and
737 : * sets to the @node content.
738 : *
739 : * Returns: 0 on success or a negative value otherwise.
740 : */
741 : int
742 0 : xmlSecKeyDataBinaryValueXmlWrite(xmlSecKeyDataId id, xmlSecKeyPtr key,
743 : xmlNodePtr node, xmlSecKeyInfoCtxPtr keyInfoCtx) {
744 : xmlSecBufferPtr buffer;
745 : xmlSecKeyDataPtr value;
746 : xmlChar* str;
747 :
748 0 : xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);
749 0 : xmlSecAssert2(key != NULL, -1);
750 0 : xmlSecAssert2(node != NULL, -1);
751 0 : xmlSecAssert2(keyInfoCtx != NULL, -1);
752 :
753 0 : if((xmlSecKeyDataTypeSymmetric & keyInfoCtx->keyReq.keyType) == 0) {
754 : /* we can have only symmetric key */
755 0 : return(0);
756 : }
757 :
758 0 : value = xmlSecKeyGetValue(key);
759 0 : xmlSecAssert2(xmlSecKeyDataIsValid(value), -1);
760 :
761 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(value);
762 0 : xmlSecAssert2(buffer != NULL, -1);
763 :
764 0 : str = xmlSecBase64Encode(xmlSecBufferGetData(buffer),
765 : xmlSecBufferGetSize(buffer),
766 : keyInfoCtx->base64LineSize);
767 0 : if(str == NULL) {
768 0 : xmlSecError(XMLSEC_ERRORS_HERE,
769 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
770 : "xmlSecBase64Encode",
771 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
772 : XMLSEC_ERRORS_NO_MESSAGE);
773 0 : return(-1);
774 : }
775 0 : xmlNodeSetContent(node, str);
776 0 : xmlFree(str);
777 0 : return(0);
778 : }
779 :
780 : /**
781 : * xmlSecKeyDataBinaryValueBinRead:
782 : * @id: the data klass.
783 : * @key: the pointer to destination key.
784 : * @buf: the source binary buffer.
785 : * @bufSize: the source binary buffer size.
786 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
787 : *
788 : * Reads binary key data of the klass @id from @buf to the @key.
789 : *
790 : * Returns: 0 on success or a negative value otherwise.
791 : */
792 : int
793 0 : xmlSecKeyDataBinaryValueBinRead(xmlSecKeyDataId id, xmlSecKeyPtr key,
794 : const xmlSecByte* buf, xmlSecSize bufSize,
795 : xmlSecKeyInfoCtxPtr keyInfoCtx) {
796 : xmlSecKeyDataPtr data;
797 : int ret;
798 :
799 0 : xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);
800 0 : xmlSecAssert2(key != NULL, -1);
801 0 : xmlSecAssert2(buf != NULL, -1);
802 0 : xmlSecAssert2(bufSize > 0, -1);
803 0 : xmlSecAssert2(keyInfoCtx != NULL, -1);
804 :
805 : /* check do we have a key already */
806 0 : data = xmlSecKeyGetValue(key);
807 0 : if(data != NULL) {
808 : xmlSecBufferPtr buffer;
809 :
810 0 : if(!xmlSecKeyDataCheckId(data, id)) {
811 0 : xmlSecError(XMLSEC_ERRORS_HERE,
812 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
813 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
814 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
815 : XMLSEC_ERRORS_NO_MESSAGE);
816 0 : return(-1);
817 : }
818 :
819 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
820 0 : if((buffer != NULL) && ((xmlSecSize)xmlSecBufferGetSize(buffer) != bufSize)) {
821 0 : xmlSecError(XMLSEC_ERRORS_HERE,
822 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
823 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
824 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
825 : "cur-data-size=%d;new-data-size=%d",
826 : xmlSecBufferGetSize(buffer), bufSize);
827 0 : return(-1);
828 : }
829 0 : if((buffer != NULL) && (bufSize > 0) && (memcmp(xmlSecBufferGetData(buffer), buf, bufSize) != 0)) {
830 0 : xmlSecError(XMLSEC_ERRORS_HERE,
831 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
832 0 : xmlSecErrorsSafeString(xmlSecKeyDataGetName(data)),
833 : XMLSEC_ERRORS_R_KEY_DATA_ALREADY_EXIST,
834 : "key already has a different value");
835 0 : return(-1);
836 : }
837 0 : if(buffer != NULL) {
838 : /* we already have exactly the same key */
839 0 : return(0);
840 : }
841 :
842 : /* we have binary key value with empty buffer */
843 : }
844 :
845 0 : data = xmlSecKeyDataCreate(id);
846 0 : if(data == NULL ) {
847 0 : xmlSecError(XMLSEC_ERRORS_HERE,
848 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
849 : "xmlSecKeyDataCreate",
850 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
851 : XMLSEC_ERRORS_NO_MESSAGE);
852 0 : return(-1);
853 : }
854 :
855 0 : ret = xmlSecKeyDataBinaryValueSetBuffer(data, buf, bufSize);
856 0 : if(ret < 0) {
857 0 : xmlSecError(XMLSEC_ERRORS_HERE,
858 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
859 : "xmlSecKeyDataBinaryValueSetBuffer",
860 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
861 : "size=%d", bufSize);
862 0 : xmlSecKeyDataDestroy(data);
863 0 : return(-1);
864 : }
865 :
866 0 : if(xmlSecKeyReqMatchKeyValue(&(keyInfoCtx->keyReq), data) != 1) {
867 0 : xmlSecError(XMLSEC_ERRORS_HERE,
868 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
869 : "xmlSecKeyReqMatchKeyValue",
870 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
871 : XMLSEC_ERRORS_NO_MESSAGE);
872 0 : xmlSecKeyDataDestroy(data);
873 0 : return(0);
874 : }
875 :
876 0 : ret = xmlSecKeySetValue(key, data);
877 0 : if(ret < 0) {
878 0 : xmlSecError(XMLSEC_ERRORS_HERE,
879 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
880 : "xmlSecKeySetValue",
881 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
882 : XMLSEC_ERRORS_NO_MESSAGE);
883 0 : xmlSecKeyDataDestroy(data);
884 0 : return(-1);
885 : }
886 :
887 0 : return(0);
888 : }
889 :
890 : /**
891 : * xmlSecKeyDataBinaryValueBinWrite:
892 : * @id: the data klass.
893 : * @key: the pointer to source key.
894 : * @buf: the destination binary buffer.
895 : * @bufSize: the destination binary buffer size.
896 : * @keyInfoCtx: the pointer to <dsig:KeyInfo/> element processing context.
897 : *
898 : * Writes binary key data of klass @id from the @key to @buf.
899 : *
900 : * Returns: 0 on success or a negative value otherwise.
901 : */
902 : int
903 0 : xmlSecKeyDataBinaryValueBinWrite(xmlSecKeyDataId id, xmlSecKeyPtr key,
904 : xmlSecByte** buf, xmlSecSize* bufSize,
905 : xmlSecKeyInfoCtxPtr keyInfoCtx) {
906 : xmlSecKeyDataPtr value;
907 : xmlSecBufferPtr buffer;
908 :
909 0 : xmlSecAssert2(id != xmlSecKeyDataIdUnknown, -1);
910 0 : xmlSecAssert2(key != NULL, -1);
911 0 : xmlSecAssert2(buf != NULL, -1);
912 0 : xmlSecAssert2(bufSize != NULL, -1);
913 0 : xmlSecAssert2(keyInfoCtx != NULL, -1);
914 :
915 0 : if((xmlSecKeyDataTypeSymmetric & keyInfoCtx->keyReq.keyType) == 0) {
916 : /* we can have only symmetric key */
917 0 : return(0);
918 : }
919 :
920 0 : value = xmlSecKeyGetValue(key);
921 0 : xmlSecAssert2(xmlSecKeyDataIsValid(value), -1);
922 :
923 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(key->value);
924 0 : xmlSecAssert2(buffer != NULL, -1);
925 :
926 0 : (*bufSize) = xmlSecBufferGetSize(buffer);
927 0 : (*buf) = (xmlSecByte*) xmlMalloc((*bufSize));
928 0 : if((*buf) == NULL) {
929 0 : xmlSecError(XMLSEC_ERRORS_HERE,
930 0 : xmlSecErrorsSafeString(xmlSecKeyDataKlassGetName(id)),
931 : NULL,
932 : XMLSEC_ERRORS_R_MALLOC_FAILED,
933 : XMLSEC_ERRORS_NO_MESSAGE);
934 0 : return(-1);
935 : }
936 0 : memcpy((*buf), xmlSecBufferGetData(buffer), (*bufSize));
937 0 : return(0);
938 : }
939 :
940 : /**
941 : * xmlSecKeyDataBinaryValueDebugDump:
942 : * @data: the pointer to binary key data.
943 : * @output: the pointer to output FILE.
944 : *
945 : * Prints binary key data debug information to @output.
946 : */
947 : void
948 0 : xmlSecKeyDataBinaryValueDebugDump(xmlSecKeyDataPtr data, FILE* output) {
949 : xmlSecBufferPtr buffer;
950 :
951 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
952 0 : xmlSecAssert(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize));
953 0 : xmlSecAssert(data->id->dataNodeName != NULL);
954 0 : xmlSecAssert(output != NULL);
955 :
956 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
957 0 : xmlSecAssert(buffer != NULL);
958 :
959 : /* print only size, everything else is sensitive */
960 0 : fprintf(output, "=== %s: size=%d\n", data->id->dataNodeName,
961 : xmlSecKeyDataGetSize(data));
962 : }
963 :
964 : /**
965 : * xmlSecKeyDataBinaryValueDebugXmlDump:
966 : * @data: the pointer to binary key data.
967 : * @output: the pointer to output FILE.
968 : *
969 : * Prints binary key data debug information to @output in XML format.
970 : */
971 : void
972 0 : xmlSecKeyDataBinaryValueDebugXmlDump(xmlSecKeyDataPtr data, FILE* output) {
973 : xmlSecBufferPtr buffer;
974 :
975 0 : xmlSecAssert(xmlSecKeyDataIsValid(data));
976 0 : xmlSecAssert(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize));
977 0 : xmlSecAssert(data->id->dataNodeName != NULL);
978 0 : xmlSecAssert(output != NULL);
979 :
980 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
981 0 : xmlSecAssert(buffer != NULL);
982 :
983 : /* print only size, everything else is sensitive */
984 0 : fprintf(output, "<%s size=\"%d\" />\n", data->id->dataNodeName,
985 : xmlSecKeyDataGetSize(data));
986 : }
987 :
988 : /**
989 : * xmlSecKeyDataBinaryValueGetSize:
990 : * @data: the pointer to binary key data.
991 : *
992 : * Gets the binary key data size.
993 : *
994 : * Returns: binary key data size in bits.
995 : */
996 : xmlSecSize
997 0 : xmlSecKeyDataBinaryValueGetSize(xmlSecKeyDataPtr data) {
998 : xmlSecBufferPtr buffer;
999 :
1000 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), 0);
1001 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize), 0);
1002 :
1003 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
1004 0 : xmlSecAssert2(buffer != NULL, 0);
1005 :
1006 : /* return size in bits */
1007 0 : return(8 * xmlSecBufferGetSize(buffer));
1008 : }
1009 :
1010 : /**
1011 : * xmlSecKeyDataBinaryValueGetBuffer:
1012 : * @data: the pointer to binary key data.
1013 : *
1014 : * Gets the binary key data buffer.
1015 : *
1016 : * Returns: pointer to binary key data buffer.
1017 : */
1018 : xmlSecBufferPtr
1019 0 : xmlSecKeyDataBinaryValueGetBuffer(xmlSecKeyDataPtr data) {
1020 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), NULL);
1021 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize), NULL);
1022 :
1023 : /* key (xmlSecBuffer) is located after xmlSecKeyData structure */
1024 0 : return((xmlSecBufferPtr)(((xmlSecByte*)data) + sizeof(xmlSecKeyData)));
1025 : }
1026 :
1027 : /**
1028 : * xmlSecKeyDataBinaryValueSetBuffer:
1029 : * @data: the pointer to binary key data.
1030 : * @buf: the pointer to binary buffer.
1031 : * @bufSize: the binary buffer size.
1032 : *
1033 : * Sets the value of @data to @buf.
1034 : *
1035 : * Returns: 0 on success or a negative value otherwise.
1036 : */
1037 : int
1038 0 : xmlSecKeyDataBinaryValueSetBuffer(xmlSecKeyDataPtr data,
1039 : const xmlSecByte* buf, xmlSecSize bufSize) {
1040 : xmlSecBufferPtr buffer;
1041 :
1042 0 : xmlSecAssert2(xmlSecKeyDataIsValid(data), -1);
1043 0 : xmlSecAssert2(xmlSecKeyDataCheckSize(data, xmlSecKeyDataBinarySize), -1);
1044 0 : xmlSecAssert2(buf != NULL, -1);
1045 0 : xmlSecAssert2(bufSize > 0, -1);
1046 :
1047 0 : buffer = xmlSecKeyDataBinaryValueGetBuffer(data);
1048 0 : xmlSecAssert2(buffer != NULL, -1);
1049 :
1050 0 : return(xmlSecBufferSetData(buffer, buf, bufSize));
1051 : }
1052 :
1053 : /***********************************************************************
1054 : *
1055 : * Keys Data list
1056 : *
1057 : **********************************************************************/
1058 : static xmlSecPtrListKlass xmlSecKeyDataListKlass = {
1059 : BAD_CAST "key-data-list",
1060 : (xmlSecPtrDuplicateItemMethod)xmlSecKeyDataDuplicate, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
1061 : (xmlSecPtrDestroyItemMethod)xmlSecKeyDataDestroy, /* xmlSecPtrDestroyItemMethod destroyItem; */
1062 : (xmlSecPtrDebugDumpItemMethod)xmlSecKeyDataDebugDump, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
1063 : (xmlSecPtrDebugDumpItemMethod)xmlSecKeyDataDebugXmlDump, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
1064 : };
1065 :
1066 : /**
1067 : * xmlSecKeyDataListGetKlass:
1068 : *
1069 : * The key data list klass.
1070 : *
1071 : * Returns: pointer to the key data list klass.
1072 : */
1073 : xmlSecPtrListId
1074 0 : xmlSecKeyDataListGetKlass(void) {
1075 0 : return(&xmlSecKeyDataListKlass);
1076 : }
1077 :
1078 :
1079 : /***********************************************************************
1080 : *
1081 : * Keys Data Ids list
1082 : *
1083 : **********************************************************************/
1084 : static xmlSecPtrListKlass xmlSecKeyDataIdListKlass = {
1085 : BAD_CAST "key-data-ids-list",
1086 : NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
1087 : NULL, /* xmlSecPtrDestroyItemMethod destroyItem; */
1088 : NULL, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
1089 : NULL, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
1090 : };
1091 :
1092 : /**
1093 : * xmlSecKeyDataIdListGetKlass:
1094 : *
1095 : * The key data id list klass.
1096 : *
1097 : * Returns: pointer to the key data id list klass.
1098 : */
1099 : xmlSecPtrListId
1100 0 : xmlSecKeyDataIdListGetKlass(void) {
1101 0 : return(&xmlSecKeyDataIdListKlass);
1102 : }
1103 :
1104 : /**
1105 : * xmlSecKeyDataIdListFind:
1106 : * @list: the pointer to key data ids list.
1107 : * @dataId: the key data klass.
1108 : *
1109 : * Lookups @dataId in @list.
1110 : *
1111 : * Returns: 1 if @dataId is found in the @list, 0 if not and a negative
1112 : * value if an error occurs.
1113 : */
1114 : int
1115 0 : xmlSecKeyDataIdListFind(xmlSecPtrListPtr list, xmlSecKeyDataId dataId) {
1116 : xmlSecSize i, size;
1117 :
1118 0 : xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId), 0);
1119 0 : xmlSecAssert2(dataId != NULL, 0);
1120 :
1121 0 : size = xmlSecPtrListGetSize(list);
1122 0 : for(i = 0; i < size; ++i) {
1123 0 : if((xmlSecKeyDataId)xmlSecPtrListGetItem(list, i) == dataId) {
1124 0 : return(1);
1125 : }
1126 : }
1127 0 : return(0);
1128 : }
1129 :
1130 : /**
1131 : * xmlSecKeyDataIdListFindByNode:
1132 : * @list: the pointer to key data ids list.
1133 : * @nodeName: the desired key data klass XML node name.
1134 : * @nodeNs: the desired key data klass XML node namespace.
1135 : * @usage: the desired key data usage.
1136 : *
1137 : * Lookups data klass in the list with given @nodeName, @nodeNs and
1138 : * @usage in the @list.
1139 : *
1140 : * Returns: key data klass is found and NULL otherwise.
1141 : */
1142 : xmlSecKeyDataId
1143 0 : xmlSecKeyDataIdListFindByNode(xmlSecPtrListPtr list, const xmlChar* nodeName,
1144 : const xmlChar* nodeNs, xmlSecKeyDataUsage usage) {
1145 : xmlSecKeyDataId dataId;
1146 : xmlSecSize i, size;
1147 :
1148 0 : xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId), xmlSecKeyDataIdUnknown);
1149 0 : xmlSecAssert2(nodeName != NULL, xmlSecKeyDataIdUnknown);
1150 :
1151 0 : size = xmlSecPtrListGetSize(list);
1152 0 : for(i = 0; i < size; ++i) {
1153 0 : dataId = (xmlSecKeyDataId)xmlSecPtrListGetItem(list, i);
1154 0 : xmlSecAssert2(dataId != xmlSecKeyDataIdUnknown, xmlSecKeyDataIdUnknown);
1155 :
1156 0 : if(((usage & dataId->usage) != 0) &&
1157 0 : xmlStrEqual(nodeName, dataId->dataNodeName) &&
1158 0 : xmlStrEqual(nodeNs, dataId->dataNodeNs)) {
1159 :
1160 0 : return(dataId);
1161 : }
1162 : }
1163 0 : return(xmlSecKeyDataIdUnknown);
1164 : }
1165 :
1166 : /**
1167 : * xmlSecKeyDataIdListFindByHref:
1168 : * @list: the pointer to key data ids list.
1169 : * @href: the desired key data klass href.
1170 : * @usage: the desired key data usage.
1171 : *
1172 : * Lookups data klass in the list with given @href and @usage in @list.
1173 : *
1174 : * Returns: key data klass is found and NULL otherwise.
1175 : */
1176 : xmlSecKeyDataId
1177 0 : xmlSecKeyDataIdListFindByHref(xmlSecPtrListPtr list, const xmlChar* href,
1178 : xmlSecKeyDataUsage usage) {
1179 : xmlSecKeyDataId dataId;
1180 : xmlSecSize i, size;
1181 :
1182 0 : xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId), xmlSecKeyDataIdUnknown);
1183 0 : xmlSecAssert2(href != NULL, xmlSecKeyDataIdUnknown);
1184 :
1185 0 : size = xmlSecPtrListGetSize(list);
1186 0 : for(i = 0; i < size; ++i) {
1187 0 : dataId = (xmlSecKeyDataId)xmlSecPtrListGetItem(list, i);
1188 0 : xmlSecAssert2(dataId != xmlSecKeyDataIdUnknown, xmlSecKeyDataIdUnknown);
1189 :
1190 0 : if(((usage & dataId->usage) != 0) && (dataId->href != NULL) &&
1191 0 : xmlStrEqual(href, dataId->href)) {
1192 :
1193 0 : return(dataId);
1194 : }
1195 : }
1196 0 : return(xmlSecKeyDataIdUnknown);
1197 : }
1198 :
1199 : /**
1200 : * xmlSecKeyDataIdListFindByName:
1201 : * @list: the pointer to key data ids list.
1202 : * @name: the desired key data klass name.
1203 : * @usage: the desired key data usage.
1204 : *
1205 : * Lookups data klass in the list with given @name and @usage in @list.
1206 : *
1207 : * Returns: key data klass is found and NULL otherwise.
1208 : */
1209 : xmlSecKeyDataId
1210 0 : xmlSecKeyDataIdListFindByName(xmlSecPtrListPtr list, const xmlChar* name,
1211 : xmlSecKeyDataUsage usage) {
1212 : xmlSecKeyDataId dataId;
1213 : xmlSecSize i, size;
1214 :
1215 0 : xmlSecAssert2(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId), xmlSecKeyDataIdUnknown);
1216 0 : xmlSecAssert2(name != NULL, xmlSecKeyDataIdUnknown);
1217 :
1218 0 : size = xmlSecPtrListGetSize(list);
1219 0 : for(i = 0; i < size; ++i) {
1220 0 : dataId = (xmlSecKeyDataId)xmlSecPtrListGetItem(list, i);
1221 0 : xmlSecAssert2(dataId != xmlSecKeyDataIdUnknown, xmlSecKeyDataIdUnknown);
1222 :
1223 0 : if(((usage & dataId->usage) != 0) && (dataId->name != NULL) &&
1224 0 : xmlStrEqual(name, BAD_CAST dataId->name)) {
1225 :
1226 0 : return(dataId);
1227 : }
1228 : }
1229 0 : return(xmlSecKeyDataIdUnknown);
1230 : }
1231 :
1232 : /**
1233 : * xmlSecKeyDataIdListDebugDump:
1234 : * @list: the pointer to key data ids list.
1235 : * @output: the pointer to output FILE.
1236 : *
1237 : * Prints binary key data debug information to @output.
1238 : */
1239 : void
1240 0 : xmlSecKeyDataIdListDebugDump(xmlSecPtrListPtr list, FILE* output) {
1241 : xmlSecKeyDataId dataId;
1242 : xmlSecSize i, size;
1243 :
1244 0 : xmlSecAssert(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId));
1245 0 : xmlSecAssert(output != NULL);
1246 :
1247 0 : size = xmlSecPtrListGetSize(list);
1248 0 : for(i = 0; i < size; ++i) {
1249 0 : dataId = (xmlSecKeyDataId)xmlSecPtrListGetItem(list, i);
1250 0 : xmlSecAssert(dataId != NULL);
1251 0 : xmlSecAssert(dataId->name != NULL);
1252 :
1253 0 : if(i > 0) {
1254 0 : fprintf(output, ",\"%s\"", dataId->name);
1255 : } else {
1256 0 : fprintf(output, "\"%s\"", dataId->name);
1257 : }
1258 : }
1259 0 : fprintf(output, "\n");
1260 : }
1261 :
1262 : /**
1263 : * xmlSecKeyDataIdListDebugXmlDump:
1264 : * @list: the pointer to key data ids list.
1265 : * @output: the pointer to output FILE.
1266 : *
1267 : * Prints binary key data debug information to @output in XML format.
1268 : */
1269 : void
1270 0 : xmlSecKeyDataIdListDebugXmlDump(xmlSecPtrListPtr list, FILE* output) {
1271 : xmlSecKeyDataId dataId;
1272 : xmlSecSize i, size;
1273 :
1274 0 : xmlSecAssert(xmlSecPtrListCheckId(list, xmlSecKeyDataIdListId));
1275 0 : xmlSecAssert(output != NULL);
1276 :
1277 0 : fprintf(output, "<KeyDataIdsList>\n");
1278 0 : size = xmlSecPtrListGetSize(list);
1279 0 : for(i = 0; i < size; ++i) {
1280 0 : dataId = (xmlSecKeyDataId)xmlSecPtrListGetItem(list, i);
1281 0 : xmlSecAssert(dataId != NULL);
1282 0 : xmlSecAssert(dataId->name != NULL);
1283 :
1284 0 : fprintf(output, "<DataId name=\"");
1285 0 : xmlSecPrintXmlString(output, dataId->name);
1286 0 : fprintf(output, "\"/>");
1287 : }
1288 0 : fprintf(output, "</KeyDataIdsList>\n");
1289 : }
1290 :
1291 : /**************************************************************************
1292 : *
1293 : * xmlSecKeyDataStore functions
1294 : *
1295 : *************************************************************************/
1296 : /**
1297 : * xmlSecKeyDataStoreCreate:
1298 : * @id: the store id.
1299 : *
1300 : * Creates new key data store of the specified klass @id. Caller is responsible
1301 : * for freeng returned object with #xmlSecKeyDataStoreDestroy function.
1302 : *
1303 : * Returns: the pointer to newly allocated key data store structure
1304 : * or NULL if an error occurs.
1305 : */
1306 : xmlSecKeyDataStorePtr
1307 0 : xmlSecKeyDataStoreCreate(xmlSecKeyDataStoreId id) {
1308 : xmlSecKeyDataStorePtr store;
1309 : int ret;
1310 :
1311 0 : xmlSecAssert2(id != NULL, NULL);
1312 0 : xmlSecAssert2(id->objSize > 0, NULL);
1313 :
1314 : /* Allocate a new xmlSecKeyDataStore and fill the fields. */
1315 0 : store = (xmlSecKeyDataStorePtr)xmlMalloc(id->objSize);
1316 0 : if(store == NULL) {
1317 0 : xmlSecError(XMLSEC_ERRORS_HERE,
1318 0 : xmlSecErrorsSafeString(xmlSecKeyDataStoreKlassGetName(id)),
1319 : NULL,
1320 : XMLSEC_ERRORS_R_MALLOC_FAILED,
1321 : "size=%d", id->objSize);
1322 0 : return(NULL);
1323 : }
1324 0 : memset(store, 0, id->objSize);
1325 0 : store->id = id;
1326 :
1327 0 : if(id->initialize != NULL) {
1328 0 : ret = (id->initialize)(store);
1329 0 : if(ret < 0) {
1330 0 : xmlSecError(XMLSEC_ERRORS_HERE,
1331 0 : xmlSecErrorsSafeString(xmlSecKeyDataStoreKlassGetName(id)),
1332 : "id->initialize",
1333 : XMLSEC_ERRORS_R_XMLSEC_FAILED,
1334 : XMLSEC_ERRORS_NO_MESSAGE);
1335 0 : xmlSecKeyDataStoreDestroy(store);
1336 0 : return(NULL);
1337 : }
1338 : }
1339 :
1340 0 : return(store);
1341 : }
1342 :
1343 : /**
1344 : * xmlSecKeyDataStoreDestroy:
1345 : * @store: the pointer to the key data store..
1346 : *
1347 : * Destroys the key data store created with #xmlSecKeyDataStoreCreate
1348 : * function.
1349 : */
1350 : void
1351 0 : xmlSecKeyDataStoreDestroy(xmlSecKeyDataStorePtr store) {
1352 0 : xmlSecAssert(xmlSecKeyDataStoreIsValid(store));
1353 0 : xmlSecAssert(store->id->objSize > 0);
1354 :
1355 0 : if(store->id->finalize != NULL) {
1356 0 : (store->id->finalize)(store);
1357 : }
1358 0 : memset(store, 0, store->id->objSize);
1359 0 : xmlFree(store);
1360 : }
1361 :
1362 : /***********************************************************************
1363 : *
1364 : * Keys Data Store list
1365 : *
1366 : **********************************************************************/
1367 : static xmlSecPtrListKlass xmlSecKeyDataStorePtrListKlass = {
1368 : BAD_CAST "keys-data-store-list",
1369 : NULL, /* xmlSecPtrDuplicateItemMethod duplicateItem; */
1370 : (xmlSecPtrDestroyItemMethod)xmlSecKeyDataStoreDestroy, /* xmlSecPtrDestroyItemMethod destroyItem; */
1371 : NULL, /* xmlSecPtrDebugDumpItemMethod debugDumpItem; */
1372 : NULL, /* xmlSecPtrDebugDumpItemMethod debugXmlDumpItem; */
1373 : };
1374 :
1375 : /**
1376 : * xmlSecKeyDataStorePtrListGetKlass:
1377 : *
1378 : * Key data stores list.
1379 : *
1380 : * Returns: key data stores list klass.
1381 : */
1382 : xmlSecPtrListId
1383 0 : xmlSecKeyDataStorePtrListGetKlass(void) {
1384 0 : return(&xmlSecKeyDataStorePtrListKlass);
1385 : }
1386 :
1387 :
|
