fa2d293eb992717a11dd51708cd3ed44c1083461
[libksba.git] / src / cms.c
1 /* cms.c - cryptographic message syntax main functions
2  * Copyright (C) 2001, 2003, 2004, 2008, 2012 g10 Code GmbH
3  *
4  * This file is part of KSBA.
5  *
6  * KSBA is free software; you can redistribute it and/or modify
7  * it under the terms of either
8  *
9  *   - the GNU Lesser General Public License as published by the Free
10  *     Software Foundation; either version 3 of the License, or (at
11  *     your option) any later version.
12  *
13  * or
14  *
15  *   - the GNU General Public License as published by the Free
16  *     Software Foundation; either version 2 of the License, or (at
17  *     your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * KSBA is distributed in the hope that it will be useful, but WITHOUT
22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
24  * License for more details.
25  *
26  * You should have received a copies of the GNU General Public License
27  * and the GNU Lesser General Public License along with this program;
28  * if not, see <http://www.gnu.org/licenses/>.
29  */
30
31 #include <config.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <assert.h>
36 #include <errno.h>
37
38 #include "util.h"
39
40 #include "cms.h"
41 #include "convert.h"
42 #include "keyinfo.h"
43 #include "der-encoder.h"
44 #include "ber-help.h"
45 #include "sexp-parse.h"
46 #include "cert.h" /* need to access cert->root and cert->image */
47
48 static gpg_error_t ct_parse_data (ksba_cms_t cms);
49 static gpg_error_t ct_parse_signed_data (ksba_cms_t cms);
50 static gpg_error_t ct_parse_enveloped_data (ksba_cms_t cms);
51 static gpg_error_t ct_parse_digested_data (ksba_cms_t cms);
52 static gpg_error_t ct_parse_encrypted_data (ksba_cms_t cms);
53 static gpg_error_t ct_build_data (ksba_cms_t cms);
54 static gpg_error_t ct_build_signed_data (ksba_cms_t cms);
55 static gpg_error_t ct_build_enveloped_data (ksba_cms_t cms);
56 static gpg_error_t ct_build_digested_data (ksba_cms_t cms);
57 static gpg_error_t ct_build_encrypted_data (ksba_cms_t cms);
58
59 static struct {
60   const char *oid;
61   ksba_content_type_t ct;
62   gpg_error_t (*parse_handler)(ksba_cms_t);
63   gpg_error_t (*build_handler)(ksba_cms_t);
64 } content_handlers[] = {
65   {  "1.2.840.113549.1.7.1", KSBA_CT_DATA,
66      ct_parse_data   , ct_build_data                  },
67   {  "1.2.840.113549.1.7.2", KSBA_CT_SIGNED_DATA,
68      ct_parse_signed_data   , ct_build_signed_data    },
69   {  "1.2.840.113549.1.7.3", KSBA_CT_ENVELOPED_DATA,
70      ct_parse_enveloped_data, ct_build_enveloped_data },
71   {  "1.2.840.113549.1.7.5", KSBA_CT_DIGESTED_DATA,
72      ct_parse_digested_data , ct_build_digested_data  },
73   {  "1.2.840.113549.1.7.6", KSBA_CT_ENCRYPTED_DATA,
74      ct_parse_encrypted_data, ct_build_encrypted_data },
75   {  "1.2.840.113549.1.9.16.1.2", KSBA_CT_AUTH_DATA   },
76   { NULL }
77 };
78
79 static const char oidstr_contentType[] = "1.2.840.113549.1.9.3";
80 /*static char oid_contentType[9] = "\x2A\x86\x48\x86\xF7\x0D\x01\x09\x03";*/
81
82 static const char oidstr_messageDigest[] = "1.2.840.113549.1.9.4";
83 static const char oid_messageDigest[9] ="\x2A\x86\x48\x86\xF7\x0D\x01\x09\x04";
84
85 static const char oidstr_signingTime[] = "1.2.840.113549.1.9.5";
86 static const char oid_signingTime[9] = "\x2A\x86\x48\x86\xF7\x0D\x01\x09\x05";
87
88 static const char oidstr_smimeCapabilities[] = "1.2.840.113549.1.9.15";
89
90 \f
91
92 /* Helper for read_and_hash_cont().  */
93 static gpg_error_t
94 read_hash_block (ksba_cms_t cms, unsigned long nleft)
95 {
96   gpg_error_t err;
97   char buffer[4096];
98   size_t n, nread;
99
100   while (nleft)
101     {
102       n = nleft < sizeof (buffer)? nleft : sizeof (buffer);
103       err = ksba_reader_read (cms->reader, buffer, n, &nread);
104       if (err)
105         return err;
106       nleft -= nread;
107       if (cms->hash_fnc)
108         cms->hash_fnc (cms->hash_fnc_arg, buffer, nread);
109       if (cms->writer)
110         err = ksba_writer_write (cms->writer, buffer, nread);
111       if (err)
112         return err;
113     }
114   return 0;
115 }
116
117
118 /* Copy all the bytes from the reader to the writer and hash them if a
119    a hash function has been set.  The writer may be NULL to just do
120    the hashing */
121 static gpg_error_t
122 read_and_hash_cont (ksba_cms_t cms)
123 {
124   gpg_error_t err = 0;
125   unsigned long nleft;
126   struct tag_info ti;
127
128   if (cms->inner_cont_ndef)
129     {
130       for (;;)
131         {
132           err = _ksba_ber_read_tl (cms->reader, &ti);
133           if (err)
134             return err;
135
136           if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
137               && !ti.is_constructed)
138             { /* next chunk */
139               nleft = ti.length;
140               err = read_hash_block (cms, nleft);
141               if (err)
142                 return err;
143             }
144           else if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
145                    && ti.is_constructed)
146             { /* next chunk is constructed */
147               for (;;)
148                 {
149                   err = _ksba_ber_read_tl (cms->reader, &ti);
150                   if (err)
151                     return err;
152                   if (ti.class == CLASS_UNIVERSAL
153                       && ti.tag == TYPE_OCTET_STRING
154                       && !ti.is_constructed)
155                     {
156                       nleft = ti.length;
157                       err = read_hash_block (cms, nleft);
158                       if (err)
159                         return err;
160                     }
161                   else if (ti.class == CLASS_UNIVERSAL && !ti.tag
162                            && !ti.is_constructed)
163                     break; /* ready with this chunk */
164                   else
165                     return gpg_error (GPG_ERR_ENCODING_PROBLEM);
166                 }
167             }
168           else if (ti.class == CLASS_UNIVERSAL && !ti.tag
169                    && !ti.is_constructed)
170             return 0; /* ready */
171           else
172             return gpg_error (GPG_ERR_ENCODING_PROBLEM);
173         }
174     }
175   else
176     {
177       /* This is basically the same as above but we allow for
178          arbitrary types.  Not sure whether it is really needed but
179          right in the beginning of gnupg 1.9 we had at least one
180          message with didn't used octet strings.  Not ethat we don't
181          do proper NLEFT checking but well why should we validate
182          these things?  Well, it might be nice to have such a feature
183          but then we should write a more general mechanism to do
184          that.  */
185       nleft = cms->inner_cont_len;
186       /* First read the octet string but allow all types here */
187       err = _ksba_ber_read_tl (cms->reader, &ti);
188       if (err)
189         return err;
190       if (nleft < ti.nhdr)
191         return gpg_error (GPG_ERR_ENCODING_PROBLEM);
192       nleft -= ti.nhdr;
193
194       if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
195           && ti.is_constructed)
196         { /* Next chunk is constructed */
197           for (;;)
198             {
199               err = _ksba_ber_read_tl (cms->reader, &ti);
200               if (err)
201                 return err;
202               if (ti.class == CLASS_UNIVERSAL
203                   && ti.tag == TYPE_OCTET_STRING
204                   && !ti.is_constructed)
205                 {
206                   nleft = ti.length;
207                   err = read_hash_block (cms, nleft);
208                   if (err)
209                     return err;
210                 }
211               else if (ti.class == CLASS_UNIVERSAL && !ti.tag
212                        && !ti.is_constructed)
213                 break; /* Ready with this chunk */
214               else
215                 return gpg_error (GPG_ERR_ENCODING_PROBLEM);
216             }
217         }
218       else if (ti.class == CLASS_UNIVERSAL && !ti.tag
219                && !ti.is_constructed)
220         return 0; /* ready */
221       else
222         {
223           err = read_hash_block (cms, nleft);
224           if (err)
225             return err;
226         }
227     }
228   return 0;
229 }
230
231
232
233 /* Copy all the encrypted bytes from the reader to the writer.
234    Handles indefinite length encoding */
235 static gpg_error_t
236 read_encrypted_cont (ksba_cms_t cms)
237 {
238   gpg_error_t err = 0;
239   unsigned long nleft;
240   char buffer[4096];
241   size_t n, nread;
242
243   if (cms->inner_cont_ndef)
244     {
245       struct tag_info ti;
246
247       /* fixme: this ist mostly a duplicate of the code in
248          read_and_hash_cont(). */
249       for (;;)
250         {
251           err = _ksba_ber_read_tl (cms->reader, &ti);
252           if (err)
253             return err;
254
255           if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
256               && !ti.is_constructed)
257             { /* next chunk */
258               nleft = ti.length;
259               while (nleft)
260                 {
261                   n = nleft < sizeof (buffer)? nleft : sizeof (buffer);
262                   err = ksba_reader_read (cms->reader, buffer, n, &nread);
263                   if (err)
264                     return err;
265                   nleft -= nread;
266                   err = ksba_writer_write (cms->writer, buffer, nread);
267                   if (err)
268                     return err;
269                 }
270             }
271           else if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
272                    && ti.is_constructed)
273             { /* next chunk is constructed */
274               for (;;)
275                 {
276                   err = _ksba_ber_read_tl (cms->reader, &ti);
277                   if (err)
278                     return err;
279                   if (ti.class == CLASS_UNIVERSAL
280                       && ti.tag == TYPE_OCTET_STRING
281                       && !ti.is_constructed)
282                     {
283                       nleft = ti.length;
284                       while (nleft)
285                         {
286                           n = nleft < sizeof (buffer)? nleft : sizeof (buffer);
287                           err = ksba_reader_read (cms->reader, buffer, n, &nread);
288                           if (err)
289                             return err;
290                           nleft -= nread;
291                           if (cms->writer)
292                             err = ksba_writer_write (cms->writer, buffer, nread);
293                           if (err)
294                             return err;
295                         }
296                     }
297                   else if (ti.class == CLASS_UNIVERSAL && !ti.tag
298                            && !ti.is_constructed)
299                     break; /* ready with this chunk */
300                   else
301                     return gpg_error (GPG_ERR_ENCODING_PROBLEM);
302                 }
303             }
304           else if (ti.class == CLASS_UNIVERSAL && !ti.tag
305                    && !ti.is_constructed)
306             return 0; /* ready */
307           else
308             return gpg_error (GPG_ERR_ENCODING_PROBLEM);
309         }
310     }
311   else
312     {
313       nleft = cms->inner_cont_len;
314       while (nleft)
315         {
316           n = nleft < sizeof (buffer)? nleft : sizeof (buffer);
317           err = ksba_reader_read (cms->reader, buffer, n, &nread);
318           if (err)
319             return err;
320           nleft -= nread;
321           err = ksba_writer_write (cms->writer, buffer, nread);
322           if (err)
323             return err;
324         }
325     }
326   return 0;
327 }
328
329 /* copy data from reader to writer.  Assume that it is an octet string
330    and insert undefinite length headers where needed */
331 static gpg_error_t
332 write_encrypted_cont (ksba_cms_t cms)
333 {
334   gpg_error_t err = 0;
335   char buffer[4096];
336   size_t nread;
337
338   /* we do it the simple way: the parts are made up from the chunks we
339      got from the read function.
340
341      Fixme: We should write the tag here, and write a definite length
342      header if everything fits into our local buffer.  Actually pretty
343      simple to do, but I am too lazy right now. */
344   while (!(err = ksba_reader_read (cms->reader, buffer,
345                                    sizeof buffer, &nread)) )
346     {
347       err = _ksba_ber_write_tl (cms->writer, TYPE_OCTET_STRING,
348                                 CLASS_UNIVERSAL, 0, nread);
349       if (!err)
350         err = ksba_writer_write (cms->writer, buffer, nread);
351     }
352   if (gpg_err_code (err) == GPG_ERR_EOF) /* write the end tag */
353       err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
354
355   return err;
356 }
357
358 \f
359 /* Figure out whether the data read from READER is a CMS object and
360    return its content type.  This function does only peek at the
361    READER and tries to identify the type with best effort.  Because of
362    the ubiquity of the stupid and insecure pkcs#12 format, the
363    function will also identify those files and return KSBA_CT_PKCS12;
364    there is and will be no other pkcs#12 support in this library. */
365 ksba_content_type_t
366 ksba_cms_identify (ksba_reader_t reader)
367 {
368   struct tag_info ti;
369   unsigned char buffer[24];
370   const unsigned char*p;
371   size_t n, count;
372   char *oid;
373   int i;
374   int maybe_p12 = 0;
375
376   if (!reader)
377     return KSBA_CT_NONE; /* oops */
378
379   /* This is a common example of a CMS object - it is obvious that we
380      only need to read a few bytes to get to the OID:
381   30 82 0B 59 06 09 2A 86 48 86 F7 0D 01 07 02 A0 82 0B 4A 30 82 0B 46 02
382   ----------- ++++++++++++++++++++++++++++++++
383   SEQUENCE    OID (signedData)
384   (2 byte len)
385
386      For a pkcs12 message we have this:
387
388   30 82 08 59 02 01 03 30 82 08 1F 06 09 2A 86 48 86 F7 0D 01 07 01 A0 82
389   ----------- ++++++++ ----------- ++++++++++++++++++++++++++++++++
390   SEQUENCE    INTEGER  SEQUENCE    OID (data)
391
392     This we need to read at least 22 bytes, we add 2 bytes to cope with
393     length headers store with 4 bytes.
394   */
395
396   for (count = sizeof buffer; count; count -= n)
397     {
398       if (ksba_reader_read (reader, buffer+sizeof (buffer)-count, count, &n))
399         return KSBA_CT_NONE; /* too short */
400     }
401   n = sizeof buffer;
402   if (ksba_reader_unread (reader, buffer, n))
403     return KSBA_CT_NONE; /* oops */
404
405   p = buffer;
406   if (_ksba_ber_parse_tl (&p, &n, &ti))
407     return KSBA_CT_NONE;
408   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
409          && ti.is_constructed) )
410     return KSBA_CT_NONE;
411   if (_ksba_ber_parse_tl (&p, &n, &ti))
412     return KSBA_CT_NONE;
413   if ( ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_INTEGER
414        && !ti.is_constructed && ti.length == 1 && n && *p == 3)
415     {
416       maybe_p12 = 1;
417       p++;
418       n--;
419       if (_ksba_ber_parse_tl (&p, &n, &ti))
420         return KSBA_CT_NONE;
421       if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
422              && ti.is_constructed) )
423         return KSBA_CT_NONE;
424       if (_ksba_ber_parse_tl (&p, &n, &ti))
425         return KSBA_CT_NONE;
426     }
427   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OBJECT_ID
428          && !ti.is_constructed && ti.length) || ti.length > n)
429     return KSBA_CT_NONE;
430   oid = ksba_oid_to_str (p, ti.length);
431   if (!oid)
432     return KSBA_CT_NONE; /* out of core */
433   for (i=0; content_handlers[i].oid; i++)
434     {
435       if (!strcmp (content_handlers[i].oid, oid))
436         break;
437     }
438   ksba_free(oid);
439   if (!content_handlers[i].oid)
440     return KSBA_CT_NONE; /* unknown */
441   if (maybe_p12 && (content_handlers[i].ct == KSBA_CT_DATA
442                     || content_handlers[i].ct == KSBA_CT_SIGNED_DATA))
443       return KSBA_CT_PKCS12;
444   return content_handlers[i].ct;
445 }
446
447
448 \f
449 /**
450  * ksba_cms_new:
451  *
452  * Create a new and empty CMS object
453  *
454  * Return value: A CMS object or an error code.
455  **/
456 gpg_error_t
457 ksba_cms_new (ksba_cms_t *r_cms)
458 {
459   *r_cms = xtrycalloc (1, sizeof **r_cms);
460   if (!*r_cms)
461     return gpg_error_from_errno (errno);
462   return 0;
463 }
464
465 /* Release a list of value trees. */
466 static void
467 release_value_tree (struct value_tree_s *tree)
468 {
469   while (tree)
470     {
471       struct value_tree_s *tmp = tree->next;
472       _ksba_asn_release_nodes (tree->root);
473       xfree (tree->image);
474       xfree (tree);
475       tree = tmp;
476     }
477 }
478
479 /**
480  * ksba_cms_release:
481  * @cms: A CMS object
482  *
483  * Release a CMS object.
484  **/
485 void
486 ksba_cms_release (ksba_cms_t cms)
487 {
488   if (!cms)
489     return;
490   xfree (cms->content.oid);
491   while (cms->digest_algos)
492     {
493       struct oidlist_s *ol = cms->digest_algos->next;
494       xfree (cms->digest_algos->oid);
495       xfree (cms->digest_algos);
496       cms->digest_algos = ol;
497     }
498   while (cms->cert_list)
499     {
500       struct certlist_s *cl = cms->cert_list->next;
501       ksba_cert_release (cms->cert_list->cert);
502       xfree (cms->cert_list->enc_val.algo);
503       xfree (cms->cert_list->enc_val.value);
504       xfree (cms->cert_list);
505       cms->cert_list = cl;
506     }
507   while (cms->cert_info_list)
508     {
509       struct certlist_s *cl = cms->cert_info_list->next;
510       ksba_cert_release (cms->cert_info_list->cert);
511       xfree (cms->cert_info_list->enc_val.algo);
512       xfree (cms->cert_info_list->enc_val.value);
513       xfree (cms->cert_info_list);
514       cms->cert_info_list = cl;
515     }
516   xfree (cms->inner_cont_oid);
517   xfree (cms->encr_algo_oid);
518   xfree (cms->encr_iv);
519   xfree (cms->data.digest);
520   while (cms->signer_info)
521     {
522       struct signer_info_s *tmp = cms->signer_info->next;
523       _ksba_asn_release_nodes (cms->signer_info->root);
524       xfree (cms->signer_info->image);
525       xfree (cms->signer_info->cache.digest_algo);
526       xfree (cms->signer_info);
527       cms->signer_info = tmp;
528     }
529   release_value_tree (cms->recp_info);
530   while (cms->sig_val)
531     {
532       struct sig_val_s *tmp = cms->sig_val->next;
533       xfree (cms->sig_val->algo);
534       xfree (cms->sig_val->value);
535       xfree (cms->sig_val);
536       cms->sig_val = tmp;
537     }
538   while (cms->capability_list)
539     {
540       struct oidparmlist_s *tmp = cms->capability_list->next;
541       xfree (cms->capability_list->oid);
542       xfree (cms->capability_list);
543       cms->capability_list = tmp;
544     }
545
546   xfree (cms);
547 }
548
549
550 gpg_error_t
551 ksba_cms_set_reader_writer (ksba_cms_t cms, ksba_reader_t r, ksba_writer_t w)
552 {
553   if (!cms || !(r || w))
554     return gpg_error (GPG_ERR_INV_VALUE);
555   if ((r && cms->reader) || (w && cms->writer) )
556     return gpg_error (GPG_ERR_CONFLICT); /* already set */
557
558   cms->reader = r;
559   cms->writer = w;
560   return 0;
561 }
562
563
564 \f
565 gpg_error_t
566 ksba_cms_parse (ksba_cms_t cms, ksba_stop_reason_t *r_stopreason)
567 {
568   gpg_error_t err;
569   int i;
570
571   if (!cms || !r_stopreason)
572     return gpg_error (GPG_ERR_INV_VALUE);
573
574   *r_stopreason = KSBA_SR_RUNNING;
575   if (!cms->stop_reason)
576     { /* Initial state: start parsing */
577       err = _ksba_cms_parse_content_info (cms);
578       if (err)
579         return err;
580       for (i=0; content_handlers[i].oid; i++)
581         {
582           if (!strcmp (content_handlers[i].oid, cms->content.oid))
583             break;
584         }
585       if (!content_handlers[i].oid)
586         return gpg_error (GPG_ERR_UNKNOWN_CMS_OBJ);
587       if (!content_handlers[i].parse_handler)
588         return gpg_error (GPG_ERR_UNSUPPORTED_CMS_OBJ);
589       cms->content.ct      = content_handlers[i].ct;
590       cms->content.handler = content_handlers[i].parse_handler;
591       cms->stop_reason = KSBA_SR_GOT_CONTENT;
592     }
593   else if (cms->content.handler)
594     {
595       err = cms->content.handler (cms);
596       if (err)
597         return err;
598     }
599   else
600     return gpg_error (GPG_ERR_UNSUPPORTED_CMS_OBJ);
601
602   *r_stopreason = cms->stop_reason;
603   return 0;
604 }
605
606 gpg_error_t
607 ksba_cms_build (ksba_cms_t cms, ksba_stop_reason_t *r_stopreason)
608 {
609   gpg_error_t err;
610
611   if (!cms || !r_stopreason)
612     return gpg_error (GPG_ERR_INV_VALUE);
613
614   *r_stopreason = KSBA_SR_RUNNING;
615   if (!cms->stop_reason)
616     { /* Initial state: check that the content handler is known */
617       if (!cms->writer)
618         return gpg_error (GPG_ERR_MISSING_ACTION);
619       if (!cms->content.handler)
620         return gpg_error (GPG_ERR_MISSING_ACTION);
621       if (!cms->inner_cont_oid)
622         return gpg_error (GPG_ERR_MISSING_ACTION);
623       cms->stop_reason = KSBA_SR_GOT_CONTENT;
624     }
625   else if (cms->content.handler)
626     {
627       err = cms->content.handler (cms);
628       if (err)
629         return err;
630     }
631   else
632     return gpg_error (GPG_ERR_UNSUPPORTED_CMS_OBJ);
633
634   *r_stopreason = cms->stop_reason;
635   return 0;
636 }
637
638
639
640 \f
641 /* Return the content type.  A WHAT of 0 returns the real content type
642    whereas a 1 returns the inner content type.
643 */
644 ksba_content_type_t
645 ksba_cms_get_content_type (ksba_cms_t cms, int what)
646 {
647   int i;
648
649   if (!cms)
650     return 0;
651   if (!what)
652     return cms->content.ct;
653
654   if (what == 1 && cms->inner_cont_oid)
655     {
656       for (i=0; content_handlers[i].oid; i++)
657         {
658           if (!strcmp (content_handlers[i].oid, cms->inner_cont_oid))
659             return content_handlers[i].ct;
660         }
661     }
662   return 0;
663 }
664
665
666 /* Return the object ID of the current cms.  This is a constant string
667    valid as long as the context is valid and no new parse is
668    started. */
669 const char *
670 ksba_cms_get_content_oid (ksba_cms_t cms, int what)
671 {
672   if (!cms)
673     return NULL;
674   if (!what)
675     return cms->content.oid;
676   if (what == 1)
677     return cms->inner_cont_oid;
678   if (what == 2)
679     return cms->encr_algo_oid;
680   return NULL;
681 }
682
683
684 /* Copy the initialization vector into iv and its len into ivlen.
685    The caller should provide a suitable large buffer */
686 gpg_error_t
687 ksba_cms_get_content_enc_iv (ksba_cms_t cms, void *iv,
688                              size_t maxivlen, size_t *ivlen)
689 {
690   if (!cms || !iv || !ivlen)
691     return gpg_error (GPG_ERR_INV_VALUE);
692   if (!cms->encr_ivlen)
693     return gpg_error (GPG_ERR_NO_DATA);
694   if (cms->encr_ivlen > maxivlen)
695     return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
696   memcpy (iv, cms->encr_iv, cms->encr_ivlen);
697   *ivlen = cms->encr_ivlen;
698   return 0;
699 }
700
701
702 /**
703  * ksba_cert_get_digest_algo_list:
704  * @cert: Initialized certificate object
705  * @idx: enumerator
706  *
707  * Figure out the the digest algorithm used for the signature and
708  * return its OID.  Note that the algos returned are just hints on
709  * what to hash.
710  *
711  * Return value: NULL for no more algorithms or a string valid as long
712  * as the the cms object is valid.
713  **/
714 const char *
715 ksba_cms_get_digest_algo_list (ksba_cms_t cms, int idx)
716 {
717   struct oidlist_s *ol;
718
719   if (!cms)
720     return NULL;
721
722   for (ol=cms->digest_algos; ol && idx; ol = ol->next, idx-- )
723     ;
724   if (!ol)
725     return NULL;
726   return ol->oid;
727 }
728
729
730 /**
731  * ksba_cms_get_issuer_serial:
732  * @cms: CMS object
733  * @idx: index number
734  * @r_issuer: returns the issuer
735  * @r_serial: returns the serial number
736  *
737  * This functions returns the issuer and serial number either from the
738  * sid or the rid elements of a CMS object.
739  *
740  * Return value: 0 on success or an error code.  An error code of -1
741  * is returned to indicate that there is no issuer with that idx,
742  * GPG_ERR_No_Data is returned to indicate that there is no issuer at
743  * all.
744  **/
745 gpg_error_t
746 ksba_cms_get_issuer_serial (ksba_cms_t cms, int idx,
747                             char **r_issuer, ksba_sexp_t *r_serial)
748 {
749   gpg_error_t err;
750   const char *issuer_path, *serial_path;
751   AsnNode root;
752   const unsigned char *image;
753   AsnNode n;
754
755   if (!cms)
756     return gpg_error (GPG_ERR_INV_VALUE);
757   if (idx < 0)
758     return gpg_error (GPG_ERR_INV_INDEX);
759
760   if (cms->signer_info)
761     {
762       struct signer_info_s *si;
763
764       for (si=cms->signer_info; si && idx; si = si->next, idx-- )
765         ;
766       if (!si)
767         return -1;
768
769       issuer_path = "SignerInfo.sid.issuerAndSerialNumber.issuer";
770       serial_path = "SignerInfo.sid.issuerAndSerialNumber.serialNumber";
771       root = si->root;
772       image = si->image;
773     }
774   else if (cms->recp_info)
775     {
776       struct value_tree_s *tmp;
777
778       issuer_path = "KeyTransRecipientInfo.rid.issuerAndSerialNumber.issuer";
779       serial_path = "KeyTransRecipientInfo.rid.issuerAndSerialNumber.serialNumber";
780       for (tmp=cms->recp_info; tmp && idx; tmp=tmp->next, idx-- )
781         ;
782       if (!tmp)
783         return -1;
784       root = tmp->root;
785       image = tmp->image;
786     }
787   else
788     return gpg_error (GPG_ERR_NO_DATA);
789
790   if (r_issuer)
791     {
792       n = _ksba_asn_find_node (root, issuer_path);
793       if (!n || !n->down)
794         return gpg_error (GPG_ERR_NO_VALUE);
795       n = n->down; /* dereference the choice node */
796
797       if (n->off == -1)
798         {
799 /*            fputs ("get_issuer problem at node:\n", stderr); */
800 /*            _ksba_asn_node_dump_all (n, stderr); */
801           return gpg_error (GPG_ERR_GENERAL);
802         }
803       err = _ksba_dn_to_str (image, n, r_issuer);
804       if (err)
805         return err;
806     }
807
808   if (r_serial)
809     {
810       char numbuf[22];
811       int numbuflen;
812       unsigned char *p;
813
814       /* fixme: we do not release the r_issuer stuff on error */
815       n = _ksba_asn_find_node (root, serial_path);
816       if (!n)
817         return gpg_error (GPG_ERR_NO_VALUE);
818
819       if (n->off == -1)
820         {
821 /*            fputs ("get_serial problem at node:\n", stderr); */
822 /*            _ksba_asn_node_dump_all (n, stderr); */
823           return gpg_error (GPG_ERR_GENERAL);
824         }
825
826       sprintf (numbuf,"(%u:", (unsigned int)n->len);
827       numbuflen = strlen (numbuf);
828       p = xtrymalloc (numbuflen + n->len + 2);
829       if (!p)
830         return gpg_error (GPG_ERR_ENOMEM);
831       strcpy (p, numbuf);
832       memcpy (p+numbuflen, image + n->off + n->nhdr, n->len);
833       p[numbuflen + n->len] = ')';
834       p[numbuflen + n->len + 1] = 0;
835       *r_serial = p;
836     }
837
838   return 0;
839 }
840
841
842
843 /**
844  * ksba_cms_get_digest_algo:
845  * @cms: CMS object
846  * @idx: index of signer
847  *
848  * Figure out the the digest algorithm used by the signer @idx return
849  * its OID.  This is the algorithm acually used to calculate the
850  * signature.
851  *
852  * Return value: NULL for no such signer or a constn string valid as
853  * long as the CMS object lives.
854  **/
855 const char *
856 ksba_cms_get_digest_algo (ksba_cms_t cms, int idx)
857 {
858   AsnNode n;
859   char *algo;
860   struct signer_info_s *si;
861
862   if (!cms)
863     return NULL;
864   if (!cms->signer_info)
865     return NULL;
866   if (idx < 0)
867     return NULL;
868
869   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
870     ;
871   if (!si)
872     return NULL;
873
874   if (si->cache.digest_algo)
875     return si->cache.digest_algo;
876
877   n = _ksba_asn_find_node (si->root, "SignerInfo.digestAlgorithm.algorithm");
878   algo = _ksba_oid_node_to_str (si->image, n);
879   if (algo)
880     {
881       si->cache.digest_algo = algo;
882     }
883   return algo;
884 }
885
886
887 /**
888  * ksba_cms_get_cert:
889  * @cms: CMS object
890  * @idx: enumerator
891  *
892  * Get the certificate out of a CMS.  The caller should use this in a
893  * loop to get all certificates.  The returned certificate is a
894  * shallow copy of the original one; the caller must still use
895  * ksba_cert_release() to free it.
896  *
897  * Return value: A Certificate object or NULL for end of list or error
898  **/
899 ksba_cert_t
900 ksba_cms_get_cert (ksba_cms_t cms, int idx)
901 {
902   struct certlist_s *cl;
903
904   if (!cms || idx < 0)
905     return NULL;
906
907   for (cl=cms->cert_list; cl && idx; cl = cl->next, idx--)
908     ;
909   if (!cl)
910     return NULL;
911   ksba_cert_ref (cl->cert);
912   return cl->cert;
913 }
914
915
916 /*
917    Return the extension attribute messageDigest
918 */
919 gpg_error_t
920 ksba_cms_get_message_digest (ksba_cms_t cms, int idx,
921                              char **r_digest, size_t *r_digest_len)
922 {
923   AsnNode nsiginfo, n;
924   struct signer_info_s *si;
925
926   if (!cms || !r_digest || !r_digest_len)
927     return gpg_error (GPG_ERR_INV_VALUE);
928   if (!cms->signer_info)
929     return gpg_error (GPG_ERR_NO_DATA);
930   if (idx < 0)
931     return gpg_error (GPG_ERR_INV_INDEX);
932
933   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
934     ;
935   if (!si)
936     return -1;
937
938
939   *r_digest = NULL;
940   *r_digest_len = 0;
941   nsiginfo = _ksba_asn_find_node (si->root, "SignerInfo.signedAttrs");
942   if (!nsiginfo)
943     return gpg_error (GPG_ERR_BUG);
944
945   n = _ksba_asn_find_type_value (si->image, nsiginfo, 0,
946                                  oid_messageDigest, DIM(oid_messageDigest));
947   if (!n)
948     return 0; /* this is okay, because the element is optional */
949
950   /* check that there is only one */
951   if (_ksba_asn_find_type_value (si->image, nsiginfo, 1,
952                                  oid_messageDigest, DIM(oid_messageDigest)))
953     return gpg_error (GPG_ERR_DUP_VALUE);
954
955   /* the value is is a SET OF OCTECT STRING but the set must have
956      excactly one OCTECT STRING.  (rfc2630 11.2) */
957   if ( !(n->type == TYPE_SET_OF && n->down
958          && n->down->type == TYPE_OCTET_STRING && !n->down->right))
959     return gpg_error (GPG_ERR_INV_CMS_OBJ);
960   n = n->down;
961   if (n->off == -1)
962     return gpg_error (GPG_ERR_BUG);
963
964   *r_digest_len = n->len;
965   *r_digest = xtrymalloc (n->len);
966   if (!*r_digest)
967     return gpg_error (GPG_ERR_ENOMEM);
968   memcpy (*r_digest, si->image + n->off + n->nhdr, n->len);
969   return 0;
970 }
971
972
973 /* Return the extension attribute signing time, which may be empty for no
974    signing time available. */
975 gpg_error_t
976 ksba_cms_get_signing_time (ksba_cms_t cms, int idx, ksba_isotime_t r_sigtime)
977 {
978   AsnNode nsiginfo, n;
979   struct signer_info_s *si;
980
981   if (!cms)
982     return gpg_error (GPG_ERR_INV_VALUE);
983   *r_sigtime = 0;
984   if (!cms->signer_info)
985     return gpg_error (GPG_ERR_NO_DATA);
986   if (idx < 0)
987     return gpg_error (GPG_ERR_INV_INDEX);
988
989   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
990     ;
991   if (!si)
992     return -1;
993
994   *r_sigtime = 0;
995   nsiginfo = _ksba_asn_find_node (si->root, "SignerInfo.signedAttrs");
996   if (!nsiginfo)
997     return 0; /* This is okay because signedAttribs are optional. */
998
999   n = _ksba_asn_find_type_value (si->image, nsiginfo, 0,
1000                                  oid_signingTime, DIM(oid_signingTime));
1001   if (!n)
1002     return 0; /* This is okay because signing time is optional. */
1003
1004   /* check that there is only one */
1005   if (_ksba_asn_find_type_value (si->image, nsiginfo, 1,
1006                                  oid_signingTime, DIM(oid_signingTime)))
1007     return gpg_error (GPG_ERR_DUP_VALUE);
1008
1009   /* the value is is a SET OF CHOICE but the set must have
1010      excactly one CHOICE of generalized or utctime.  (rfc2630 11.3) */
1011   if ( !(n->type == TYPE_SET_OF && n->down
1012          && (n->down->type == TYPE_GENERALIZED_TIME
1013              || n->down->type == TYPE_UTC_TIME)
1014          && !n->down->right))
1015     return gpg_error (GPG_ERR_INV_CMS_OBJ);
1016   n = n->down;
1017   if (n->off == -1)
1018     return gpg_error (GPG_ERR_BUG);
1019
1020   return _ksba_asntime_to_iso (si->image + n->off + n->nhdr, n->len,
1021                                n->type == TYPE_UTC_TIME, r_sigtime);
1022 }
1023
1024
1025 /* Return a list of OIDs stored as signed attributes for the signature
1026    number IDX.  All the values (OIDs) for the the requested OID REQOID
1027    are returned delimited by a linefeed.  Caller must free that
1028    list. -1 is returned when IDX is larger than the number of
1029    signatures, GPG_ERR_No_Data is returned when there is no such
1030    attribute for the given signer. */
1031 gpg_error_t
1032 ksba_cms_get_sigattr_oids (ksba_cms_t cms, int idx,
1033                            const char *reqoid, char **r_value)
1034 {
1035   gpg_error_t err;
1036   AsnNode nsiginfo, n;
1037   struct signer_info_s *si;
1038   unsigned char *reqoidbuf;
1039   size_t reqoidlen;
1040   char *retstr = NULL;
1041   int i;
1042
1043   if (!cms || !r_value)
1044     return gpg_error (GPG_ERR_INV_VALUE);
1045   if (!cms->signer_info)
1046     return gpg_error (GPG_ERR_NO_DATA);
1047   if (idx < 0)
1048     return gpg_error (GPG_ERR_INV_INDEX);
1049   *r_value = NULL;
1050
1051   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
1052     ;
1053   if (!si)
1054     return -1; /* no more signers */
1055
1056   nsiginfo = _ksba_asn_find_node (si->root, "SignerInfo.signedAttrs");
1057   if (!nsiginfo)
1058     return -1; /* this is okay, because signedAttribs are optional */
1059
1060   err = ksba_oid_from_str (reqoid, &reqoidbuf, &reqoidlen);
1061   if(err)
1062     return err;
1063
1064   for (i=0; (n = _ksba_asn_find_type_value (si->image, nsiginfo,
1065                                             i, reqoidbuf, reqoidlen)); i++)
1066     {
1067       char *line, *p;
1068
1069       /* the value is is a SET OF OBJECT ID but the set must have
1070          excactly one OBJECT ID.  (rfc2630 11.1) */
1071       if ( !(n->type == TYPE_SET_OF && n->down
1072              && n->down->type == TYPE_OBJECT_ID && !n->down->right))
1073         {
1074           xfree (reqoidbuf);
1075           xfree (retstr);
1076           return gpg_error (GPG_ERR_INV_CMS_OBJ);
1077         }
1078       n = n->down;
1079       if (n->off == -1)
1080         {
1081           xfree (reqoidbuf);
1082           xfree (retstr);
1083           return gpg_error (GPG_ERR_BUG);
1084         }
1085
1086       p = _ksba_oid_node_to_str (si->image, n);
1087       if (!p)
1088         {
1089           xfree (reqoidbuf);
1090           xfree (retstr);
1091           return gpg_error (GPG_ERR_INV_CMS_OBJ);
1092         }
1093
1094       if (!retstr)
1095         line = retstr = xtrymalloc (strlen (p) + 2);
1096       else
1097         {
1098           char *tmp = xtryrealloc (retstr,
1099                                    strlen (retstr) + 1 + strlen (p) + 2);
1100           if (!tmp)
1101             line = NULL;
1102           else
1103             {
1104               retstr = tmp;
1105               line = stpcpy (retstr + strlen (retstr), "\n");
1106             }
1107         }
1108       if (!line)
1109         {
1110           xfree (reqoidbuf);
1111           xfree (retstr);
1112           xfree (p);
1113           return gpg_error (GPG_ERR_ENOMEM);
1114         }
1115       strcpy (line, p);
1116       xfree (p);
1117     }
1118   xfree (reqoidbuf);
1119   if (!n && !i)
1120     return -1; /* no such attribute */
1121   *r_value = retstr;
1122   return 0;
1123 }
1124
1125
1126 /**
1127  * ksba_cms_get_sig_val:
1128  * @cms: CMS object
1129  * @idx: index of signer
1130  *
1131  * Return the actual signature of signer @idx in a format suitable to
1132  * be used as input to Libgcrypt's verification function.  The caller
1133  * must free the returned string.
1134  *
1135  * Return value: NULL or a string with a S-Exp.
1136  **/
1137 ksba_sexp_t
1138 ksba_cms_get_sig_val (ksba_cms_t cms, int idx)
1139 {
1140   AsnNode n, n2;
1141   gpg_error_t err;
1142   ksba_sexp_t string;
1143   struct signer_info_s *si;
1144
1145   if (!cms)
1146     return NULL;
1147   if (!cms->signer_info)
1148     return NULL;
1149   if (idx < 0)
1150     return NULL;
1151
1152   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
1153     ;
1154   if (!si)
1155     return NULL;
1156
1157   n = _ksba_asn_find_node (si->root, "SignerInfo.signatureAlgorithm");
1158   if (!n)
1159       return NULL;
1160   if (n->off == -1)
1161     {
1162 /*        fputs ("ksba_cms_get_sig_val problem at node:\n", stderr); */
1163 /*        _ksba_asn_node_dump_all (n, stderr); */
1164       return NULL;
1165     }
1166
1167   n2 = n->right; /* point to the actual value */
1168   err = _ksba_sigval_to_sexp (si->image + n->off,
1169                               n->nhdr + n->len
1170                               + ((!n2||n2->off == -1)? 0:(n2->nhdr+n2->len)),
1171                               &string);
1172   if (err)
1173       return NULL;
1174
1175   return string;
1176 }
1177
1178
1179 /**
1180  * ksba_cms_get_enc_val:
1181  * @cms: CMS object
1182  * @idx: index of recipient info
1183  *
1184  * Return the encrypted value (the session key) of recipient @idx in a
1185  * format suitable to be used as input to Libgcrypt's decryption
1186  * function.  The caller must free the returned string.
1187  *
1188  * Return value: NULL or a string with a S-Exp.
1189  **/
1190 ksba_sexp_t
1191 ksba_cms_get_enc_val (ksba_cms_t cms, int idx)
1192 {
1193   AsnNode n, n2;
1194   gpg_error_t err;
1195   ksba_sexp_t string;
1196   struct value_tree_s *vt;
1197
1198   if (!cms)
1199     return NULL;
1200   if (!cms->recp_info)
1201     return NULL;
1202   if (idx < 0)
1203     return NULL;
1204
1205   for (vt=cms->recp_info; vt && idx; vt=vt->next, idx--)
1206     ;
1207   if (!vt)
1208     return NULL; /* No value at this IDX */
1209
1210
1211   n = _ksba_asn_find_node (vt->root,
1212                            "KeyTransRecipientInfo.keyEncryptionAlgorithm");
1213   if (!n)
1214       return NULL;
1215   if (n->off == -1)
1216     {
1217 /*        fputs ("ksba_cms_get_enc_val problem at node:\n", stderr); */
1218 /*        _ksba_asn_node_dump_all (n, stderr); */
1219       return NULL;
1220     }
1221
1222   n2 = n->right; /* point to the actual value */
1223   err = _ksba_encval_to_sexp (vt->image + n->off,
1224                               n->nhdr + n->len
1225                               + ((!n2||n2->off == -1)? 0:(n2->nhdr+n2->len)),
1226                               &string);
1227   if (err)
1228       return NULL;
1229
1230   return string;
1231 }
1232
1233
1234
1235
1236 \f
1237 /* Provide a hash function so that we are able to hash the data */
1238 void
1239 ksba_cms_set_hash_function (ksba_cms_t cms,
1240                             void (*hash_fnc)(void *, const void *, size_t),
1241                             void *hash_fnc_arg)
1242 {
1243   if (cms)
1244     {
1245       cms->hash_fnc = hash_fnc;
1246       cms->hash_fnc_arg = hash_fnc_arg;
1247     }
1248 }
1249
1250
1251 /* hash the signed attributes of the given signer */
1252 gpg_error_t
1253 ksba_cms_hash_signed_attrs (ksba_cms_t cms, int idx)
1254 {
1255   AsnNode n;
1256   struct signer_info_s *si;
1257
1258   if (!cms)
1259     return gpg_error (GPG_ERR_INV_VALUE);
1260   if (!cms->hash_fnc)
1261     return gpg_error (GPG_ERR_MISSING_ACTION);
1262   if (idx < 0)
1263     return -1;
1264
1265   for (si=cms->signer_info; si && idx; si = si->next, idx-- )
1266     ;
1267   if (!si)
1268     return -1;
1269
1270   n = _ksba_asn_find_node (si->root, "SignerInfo.signedAttrs");
1271   if (!n || n->off == -1)
1272     return gpg_error (GPG_ERR_NO_VALUE);
1273
1274   /* We don't hash the implicit tag [0] but a SET tag */
1275   cms->hash_fnc (cms->hash_fnc_arg, "\x31", 1);
1276   cms->hash_fnc (cms->hash_fnc_arg,
1277                  si->image + n->off + 1, n->nhdr + n->len - 1);
1278
1279   return 0;
1280 }
1281
1282 \f
1283 /*
1284   Code to create CMS structures
1285 */
1286
1287
1288 /**
1289  * ksba_cms_set_content_type:
1290  * @cms: A CMS object
1291  * @what: 0 for content type, 1 for inner content type
1292  * @type: Tyep constant
1293  *
1294  * Set the content type used for build operations.  This should be the
1295  * first operation before starting to create a CMS message.
1296  *
1297  * Return value: 0 on success or an error code
1298  **/
1299 gpg_error_t
1300 ksba_cms_set_content_type (ksba_cms_t cms, int what, ksba_content_type_t type)
1301 {
1302   int i;
1303   char *oid;
1304
1305   if (!cms || what < 0 || what > 1 )
1306     return gpg_error (GPG_ERR_INV_VALUE);
1307
1308   for (i=0; content_handlers[i].oid; i++)
1309     {
1310       if (content_handlers[i].ct == type)
1311         break;
1312     }
1313   if (!content_handlers[i].oid)
1314     return gpg_error (GPG_ERR_UNKNOWN_CMS_OBJ);
1315   if (!content_handlers[i].build_handler)
1316     return gpg_error (GPG_ERR_UNSUPPORTED_CMS_OBJ);
1317   oid = xtrystrdup (content_handlers[i].oid);
1318   if (!oid)
1319     return gpg_error (GPG_ERR_ENOMEM);
1320
1321   if (!what)
1322     {
1323       cms->content.oid     = oid;
1324       cms->content.ct      = content_handlers[i].ct;
1325       cms->content.handler = content_handlers[i].build_handler;
1326     }
1327   else
1328     {
1329       cms->inner_cont_oid = oid;
1330     }
1331
1332   return 0;
1333 }
1334
1335
1336 /**
1337  * ksba_cms_add_digest_algo:
1338  * @cms:  A CMS object
1339  * @oid: A stringified object OID describing the hash algorithm
1340  *
1341  * Set the algorithm to be used for creating the hash. Note, that we
1342  * currently can't do a per-signer hash.
1343  *
1344  * Return value: 0 on success or an error code
1345  **/
1346 gpg_error_t
1347 ksba_cms_add_digest_algo (ksba_cms_t cms, const char *oid)
1348 {
1349   struct oidlist_s *ol;
1350
1351   if (!cms || !oid)
1352     return gpg_error (GPG_ERR_INV_VALUE);
1353
1354   ol = xtrymalloc (sizeof *ol);
1355   if (!ol)
1356     return gpg_error (GPG_ERR_ENOMEM);
1357
1358   ol->oid = xtrystrdup (oid);
1359   if (!ol->oid)
1360     {
1361       xfree (ol);
1362       return gpg_error (GPG_ERR_ENOMEM);
1363     }
1364   ol->next = cms->digest_algos;
1365   cms->digest_algos = ol;
1366   return 0;
1367 }
1368
1369
1370 /**
1371  * ksba_cms_add_signer:
1372  * @cms: A CMS object
1373  * @cert: A certificate used to describe the signer.
1374  *
1375  * This functions starts assembly of a new signed data content or adds
1376  * another signer to the list of signers.
1377  *
1378  * Return value: 0 on success or an error code.
1379  **/
1380 gpg_error_t
1381 ksba_cms_add_signer (ksba_cms_t cms, ksba_cert_t cert)
1382 {
1383   struct certlist_s *cl, *cl2;
1384
1385   if (!cms)
1386     return gpg_error (GPG_ERR_INV_VALUE);
1387
1388   cl = xtrycalloc (1,sizeof *cl);
1389   if (!cl)
1390       return gpg_error (GPG_ERR_ENOMEM);
1391
1392   ksba_cert_ref (cert);
1393   cl->cert = cert;
1394   if (!cms->cert_list)
1395     cms->cert_list = cl;
1396   else
1397     {
1398       for (cl2=cms->cert_list; cl2->next; cl2 = cl2->next)
1399         ;
1400       cl2->next = cl;
1401     }
1402   return 0;
1403 }
1404
1405 /**
1406  * ksba_cms_add_cert:
1407  * @cms: A CMS object
1408  * @cert: A certificate to be send along with the signed data.
1409  *
1410  * This functions adds a certificate to the list of certificates send
1411  * along with the signed data.  Using this is optional but it is very
1412  * common to include at least the certificate of the signer it self.
1413  *
1414  * Return value: 0 on success or an error code.
1415  **/
1416 gpg_error_t
1417 ksba_cms_add_cert (ksba_cms_t cms, ksba_cert_t cert)
1418 {
1419   struct certlist_s *cl;
1420
1421   if (!cms || !cert)
1422     return gpg_error (GPG_ERR_INV_VALUE);
1423
1424   /* first check whether this is a duplicate. */
1425   for (cl = cms->cert_info_list; cl; cl = cl->next)
1426     {
1427       if (!_ksba_cert_cmp (cert, cl->cert))
1428         return 0; /* duplicate */
1429     }
1430
1431   /* Okay, add it. */
1432   cl = xtrycalloc (1,sizeof *cl);
1433   if (!cl)
1434       return gpg_error (GPG_ERR_ENOMEM);
1435
1436   ksba_cert_ref (cert);
1437   cl->cert = cert;
1438   cl->next = cms->cert_info_list;
1439   cms->cert_info_list = cl;
1440   return 0;
1441 }
1442
1443
1444 /* Add an S/MIME capability as an extended attribute to the message.
1445    This function is to be called for each capability in turn. The
1446    first capability added will receive the highest priority.  CMS is
1447    the context, OID the object identifier of the capability and if DER
1448    is not NULL it is used as the DER-encoded parameters of the
1449    capability; the length of that DER object is given in DERLEN.
1450    DERLEN should be 0 if DER is NULL.
1451
1452    The function returns 0 on success or an error code.
1453 */
1454 gpg_error_t
1455 ksba_cms_add_smime_capability (ksba_cms_t cms, const char *oid,
1456                                const unsigned char *der, size_t derlen)
1457 {
1458   gpg_error_t err;
1459   struct oidparmlist_s *opl, *opl2;
1460
1461   if (!cms || !oid)
1462     return gpg_error (GPG_ERR_INV_VALUE);
1463
1464   if (!der)
1465     derlen = 0;
1466
1467   opl = xtrymalloc (sizeof *opl + derlen - 1);
1468   if (!opl)
1469     return gpg_error_from_errno (errno);
1470   opl->next = NULL;
1471   opl->oid = xtrystrdup (oid);
1472   if (!opl->oid)
1473     {
1474       err = gpg_error_from_errno (errno);
1475       xfree (opl);
1476       return err;
1477     }
1478   opl->parmlen = derlen;
1479   if (der)
1480     memcpy (opl->parm, der, derlen);
1481
1482   /* Append it to maintain the desired order. */
1483   if (!cms->capability_list)
1484     cms->capability_list = opl;
1485   else
1486     {
1487       for (opl2=cms->capability_list; opl2->next; opl2 = opl2->next)
1488         ;
1489       opl2->next = opl;
1490     }
1491
1492   return 0;
1493 }
1494
1495
1496
1497 /**
1498  * ksba_cms_set_message_digest:
1499  * @cms: A CMS object
1500  * @idx: The index of the signer
1501  * @digest: a message digest
1502  * @digest_len: the length of the message digest
1503  *
1504  * Set a message digest into the signedAttributes of the signer with
1505  * the index IDX.  The index of a signer is determined by the sequence
1506  * of ksba_cms_add_signer() calls; the first signer has the index 0.
1507  * This function is to be used when the hash value of the data has
1508  * been calculated and before the create function requests the sign
1509  * operation.
1510  *
1511  * Return value: 0 on success or an error code
1512  **/
1513 gpg_error_t
1514 ksba_cms_set_message_digest (ksba_cms_t cms, int idx,
1515                              const unsigned char *digest, size_t digest_len)
1516 {
1517   struct certlist_s *cl;
1518
1519   if (!cms || !digest)
1520     return gpg_error (GPG_ERR_INV_VALUE);
1521   if (!digest_len || digest_len > DIM(cl->msg_digest))
1522     return gpg_error (GPG_ERR_INV_VALUE);
1523   if (idx < 0)
1524     return gpg_error (GPG_ERR_INV_INDEX);
1525
1526   for (cl=cms->cert_list; cl && idx; cl = cl->next, idx--)
1527     ;
1528   if (!cl)
1529     return gpg_error (GPG_ERR_INV_INDEX); /* no certificate to store it */
1530   cl->msg_digest_len = digest_len;
1531   memcpy (cl->msg_digest, digest, digest_len);
1532   return 0;
1533 }
1534
1535 /**
1536  * ksba_cms_set_signing_time:
1537  * @cms: A CMS object
1538  * @idx: The index of the signer
1539  * @sigtime: a time or an empty value to use the current time
1540  *
1541  * Set a signing time into the signedAttributes of the signer with
1542  * the index IDX.  The index of a signer is determined by the sequence
1543  * of ksba_cms_add_signer() calls; the first signer has the index 0.
1544  *
1545  * Return value: 0 on success or an error code
1546  **/
1547 gpg_error_t
1548 ksba_cms_set_signing_time (ksba_cms_t cms, int idx, const ksba_isotime_t sigtime)
1549 {
1550   struct certlist_s *cl;
1551
1552   if (!cms)
1553     return gpg_error (GPG_ERR_INV_VALUE);
1554   if (idx < 0)
1555     return gpg_error (GPG_ERR_INV_INDEX);
1556
1557   for (cl=cms->cert_list; cl && idx; cl = cl->next, idx--)
1558     ;
1559   if (!cl)
1560     return gpg_error (GPG_ERR_INV_INDEX); /* no certificate to store it */
1561
1562   /* Fixme: We might want to check the validity of the passed time
1563      string. */
1564   if (!*sigtime)
1565     _ksba_current_time (cl->signing_time);
1566   else
1567     _ksba_copy_time (cl->signing_time, sigtime);
1568   return 0;
1569 }
1570
1571
1572 /*
1573   r_sig  = (sig-val
1574               (<algo>
1575                 (<param_name1> <mpi>)
1576                 ...
1577                 (<param_namen> <mpi>)
1578               ))
1579   The sexp must be in canonical form.
1580   Note the <algo> must be given as a stringified OID or the special
1581   string "rsa".
1582
1583   Note that IDX is only used for consistency checks.
1584  */
1585 gpg_error_t
1586 ksba_cms_set_sig_val (ksba_cms_t cms, int idx, ksba_const_sexp_t sigval)
1587 {
1588   const unsigned char *s;
1589   unsigned long n;
1590   struct sig_val_s *sv, **sv_tail;
1591   int i;
1592
1593   if (!cms)
1594     return gpg_error (GPG_ERR_INV_VALUE);
1595   if (idx < 0)
1596     return gpg_error (GPG_ERR_INV_INDEX); /* only one signer for now */
1597
1598   s = sigval;
1599   if (*s != '(')
1600     return gpg_error (GPG_ERR_INV_SEXP);
1601   s++;
1602
1603   for (i=0, sv_tail=&cms->sig_val; *sv_tail; sv_tail=&(*sv_tail)->next, i++)
1604     ;
1605   if (i != idx)
1606     return gpg_error (GPG_ERR_INV_INDEX);
1607
1608   if (!(n = snext (&s)))
1609     return gpg_error (GPG_ERR_INV_SEXP);
1610   if (!smatch (&s, 7, "sig-val"))
1611     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1612   if (*s != '(')
1613     return gpg_error (digitp (s)? GPG_ERR_UNKNOWN_SEXP : GPG_ERR_INV_SEXP);
1614   s++;
1615
1616   /* Break out the algorithm ID. */
1617   if (!(n = snext (&s)))
1618     return gpg_error (GPG_ERR_INV_SEXP);
1619
1620   sv = xtrycalloc (1, sizeof *sv);
1621   if (!sv)
1622     return gpg_error (GPG_ERR_ENOMEM);
1623   if (n==3 && s[0] == 'r' && s[1] == 's' && s[2] == 'a')
1624     { /* kludge to allow "rsa" to be passed as algorithm name */
1625       sv->algo = xtrystrdup ("1.2.840.113549.1.1.1");
1626       if (!sv->algo)
1627         {
1628           xfree (sv);
1629           return gpg_error (GPG_ERR_ENOMEM);
1630         }
1631     }
1632   else
1633     {
1634       sv->algo = xtrymalloc (n+1);
1635       if (!sv->algo)
1636         {
1637           xfree (sv);
1638           return gpg_error (GPG_ERR_ENOMEM);
1639         }
1640       memcpy (sv->algo, s, n);
1641       sv->algo[n] = 0;
1642     }
1643   s += n;
1644
1645   /* And now the values - FIXME: For now we only support one */
1646   /* fixme: start loop */
1647   if (*s != '(')
1648     {
1649       xfree (sv->algo);
1650       xfree (sv);
1651       return gpg_error (digitp (s)? GPG_ERR_UNKNOWN_SEXP : GPG_ERR_INV_SEXP);
1652     }
1653   s++;
1654
1655   if (!(n = snext (&s)))
1656     {
1657       xfree (sv->algo);
1658       xfree (sv);
1659       return gpg_error (GPG_ERR_INV_SEXP);
1660     }
1661   s += n; /* ignore the name of the parameter */
1662
1663   if (!digitp(s))
1664     {
1665       xfree (sv->algo);
1666       xfree (sv);
1667       /* May also be an invalid S-EXP.  */
1668       return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1669     }
1670
1671   if (!(n = snext (&s)))
1672     {
1673       xfree (sv->algo);
1674       xfree (sv);
1675       return gpg_error (GPG_ERR_INV_SEXP);
1676     }
1677
1678   sv->value = xtrymalloc (n);
1679   if (!sv->value)
1680     {
1681       xfree (sv->algo);
1682       xfree (sv);
1683       return gpg_error (GPG_ERR_ENOMEM);
1684     }
1685   memcpy (sv->value, s, n);
1686   sv->valuelen = n;
1687   s += n;
1688   if ( *s != ')')
1689     {
1690       xfree (sv->value);
1691       xfree (sv->algo);
1692       xfree (sv);
1693       return gpg_error (GPG_ERR_UNKNOWN_SEXP); /* but may also be an invalid one */
1694     }
1695   s++;
1696   /* fixme: end loop over parameters */
1697
1698   /* we need 2 closing parenthesis */
1699   if ( *s != ')' || s[1] != ')')
1700     {
1701       xfree (sv->value);
1702       xfree (sv->algo);
1703       xfree (sv);
1704       return gpg_error (GPG_ERR_INV_SEXP);
1705     }
1706
1707   *sv_tail = sv;
1708   return 0;
1709 }
1710
1711
1712 /* Set the content encryption algorithm to OID and optionally set the
1713    initialization vector to IV */
1714 gpg_error_t
1715 ksba_cms_set_content_enc_algo (ksba_cms_t cms,
1716                                const char *oid,
1717                                const void *iv, size_t ivlen)
1718 {
1719   if (!cms || !oid)
1720     return gpg_error (GPG_ERR_INV_VALUE);
1721
1722   xfree (cms->encr_iv);
1723   cms->encr_iv = NULL;
1724   cms->encr_ivlen = 0;
1725
1726   cms->encr_algo_oid = xtrystrdup (oid);
1727   if (!cms->encr_algo_oid)
1728     return gpg_error (GPG_ERR_ENOMEM);
1729
1730   if (iv)
1731     {
1732       cms->encr_iv = xtrymalloc (ivlen);
1733       if (!cms->encr_iv)
1734         return gpg_error (GPG_ERR_ENOMEM);
1735       memcpy (cms->encr_iv, iv, ivlen);
1736       cms->encr_ivlen = ivlen;
1737     }
1738   return 0;
1739 }
1740
1741
1742 /*
1743  * encval is expected to be a canonical encoded  S-Exp of this form:
1744  *  (enc-val
1745  *      (<algo>
1746  *         (<param_name1> <mpi>)
1747  *          ...
1748  *         (<param_namen> <mpi>)
1749  *      ))
1750  *
1751  * Note the <algo> must be given as a stringified OID or the special
1752  * string "rsa" */
1753 gpg_error_t
1754 ksba_cms_set_enc_val (ksba_cms_t cms, int idx, ksba_const_sexp_t encval)
1755 {
1756   /*FIXME: This shares most code with ...set_sig_val */
1757   struct certlist_s *cl;
1758   const char *s, *endp;
1759   unsigned long n;
1760
1761   if (!cms)
1762     return gpg_error (GPG_ERR_INV_VALUE);
1763   if (idx < 0)
1764     return gpg_error (GPG_ERR_INV_INDEX);
1765   for (cl=cms->cert_list; cl && idx; cl = cl->next, idx--)
1766     ;
1767   if (!cl)
1768     return gpg_error (GPG_ERR_INV_INDEX); /* no certificate to store the value */
1769
1770   s = encval;
1771   if (*s != '(')
1772     return gpg_error (GPG_ERR_INV_SEXP);
1773   s++;
1774
1775   n = strtoul (s, (char**)&endp, 10);
1776   s = endp;
1777   if (!n || *s!=':')
1778     return gpg_error (GPG_ERR_INV_SEXP); /* we don't allow empty lengths */
1779   s++;
1780   if (n != 7 || memcmp (s, "enc-val", 7))
1781     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1782   s += 7;
1783   if (*s != '(')
1784     return gpg_error (digitp (s)? GPG_ERR_UNKNOWN_SEXP : GPG_ERR_INV_SEXP);
1785   s++;
1786
1787   /* break out the algorithm ID */
1788   n = strtoul (s, (char**)&endp, 10);
1789   s = endp;
1790   if (!n || *s != ':')
1791     return gpg_error (GPG_ERR_INV_SEXP); /* we don't allow empty lengths */
1792   s++;
1793   xfree (cl->enc_val.algo);
1794   if (n==3 && s[0] == 'r' && s[1] == 's' && s[2] == 'a')
1795     { /* kludge to allow "rsa" to be passed as algorithm name */
1796       cl->enc_val.algo = xtrystrdup ("1.2.840.113549.1.1.1");
1797       if (!cl->enc_val.algo)
1798         return gpg_error (GPG_ERR_ENOMEM);
1799     }
1800   else
1801     {
1802       cl->enc_val.algo = xtrymalloc (n+1);
1803       if (!cl->enc_val.algo)
1804         return gpg_error (GPG_ERR_ENOMEM);
1805       memcpy (cl->enc_val.algo, s, n);
1806       cl->enc_val.algo[n] = 0;
1807     }
1808   s += n;
1809
1810   /* And now the values - FIXME: For now we only support one */
1811   /* fixme: start loop */
1812   if (*s != '(')
1813     return gpg_error (digitp (s)? GPG_ERR_UNKNOWN_SEXP : GPG_ERR_INV_SEXP);
1814   s++;
1815   n = strtoul (s, (char**)&endp, 10);
1816   s = endp;
1817   if (!n || *s != ':')
1818     return gpg_error (GPG_ERR_INV_SEXP);
1819   s++;
1820   s += n; /* ignore the name of the parameter */
1821
1822   if (!digitp(s))
1823     return gpg_error (GPG_ERR_UNKNOWN_SEXP); /* but may also be an invalid one */
1824   n = strtoul (s, (char**)&endp, 10);
1825   s = endp;
1826   if (!n || *s != ':')
1827     return gpg_error (GPG_ERR_INV_SEXP);
1828   s++;
1829   xfree (cl->enc_val.value);
1830   cl->enc_val.value = xtrymalloc (n);
1831   if (!cl->enc_val.value)
1832     return gpg_error (GPG_ERR_ENOMEM);
1833   memcpy (cl->enc_val.value, s, n);
1834   cl->enc_val.valuelen = n;
1835   s += n;
1836   if ( *s != ')')
1837     return gpg_error (GPG_ERR_UNKNOWN_SEXP); /* but may also be an invalid one */
1838   s++;
1839   /* fixme: end loop over parameters */
1840
1841   /* we need 2 closing parenthesis */
1842   if ( *s != ')' || s[1] != ')')
1843     return gpg_error (GPG_ERR_INV_SEXP);
1844
1845   return 0;
1846 }
1847
1848
1849
1850
1851 /**
1852  * ksba_cms_add_recipient:
1853  * @cms: A CMS object
1854  * @cert: A certificate used to describe the recipient.
1855  *
1856  * This functions starts assembly of a new enveloped data content or adds
1857  * another recipient to the list of recipients.
1858  *
1859  * Note: after successful completion of this function ownership of
1860  * @cert is transferred to @cms.
1861  *
1862  * Return value: 0 on success or an error code.
1863  **/
1864 gpg_error_t
1865 ksba_cms_add_recipient (ksba_cms_t cms, ksba_cert_t cert)
1866 {
1867   /* for now we use the same structure */
1868   return ksba_cms_add_signer (cms, cert);
1869 }
1870
1871
1872
1873 \f
1874 /*
1875    Content handler for parsing messages
1876 */
1877
1878 static gpg_error_t
1879 ct_parse_data (ksba_cms_t cms)
1880 {
1881   (void)cms;
1882   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1883 }
1884
1885
1886 static gpg_error_t
1887 ct_parse_signed_data (ksba_cms_t cms)
1888 {
1889   enum {
1890     sSTART,
1891     sGOT_HASH,
1892     sIN_DATA,
1893     sERROR
1894   } state = sERROR;
1895   ksba_stop_reason_t stop_reason = cms->stop_reason;
1896   gpg_error_t err = 0;
1897
1898   cms->stop_reason = KSBA_SR_RUNNING;
1899
1900   /* Calculate state from last reason and do some checks */
1901   if (stop_reason == KSBA_SR_GOT_CONTENT)
1902     {
1903       state = sSTART;
1904     }
1905   else if (stop_reason == KSBA_SR_NEED_HASH)
1906     {
1907       state = sGOT_HASH;
1908     }
1909   else if (stop_reason == KSBA_SR_BEGIN_DATA)
1910     {
1911       if (!cms->hash_fnc)
1912         err = gpg_error (GPG_ERR_MISSING_ACTION);
1913       else
1914         state = sIN_DATA;
1915     }
1916   else if (stop_reason == KSBA_SR_END_DATA)
1917     {
1918       state = sGOT_HASH;
1919     }
1920   else if (stop_reason == KSBA_SR_RUNNING)
1921     err = gpg_error (GPG_ERR_INV_STATE);
1922   else if (stop_reason)
1923     err = gpg_error (GPG_ERR_BUG);
1924
1925   if (err)
1926     return err;
1927
1928   /* Do the action */
1929   if (state == sSTART)
1930     err = _ksba_cms_parse_signed_data_part_1 (cms);
1931   else if (state == sGOT_HASH)
1932     err = _ksba_cms_parse_signed_data_part_2 (cms);
1933   else if (state == sIN_DATA)
1934     err = read_and_hash_cont (cms);
1935   else
1936     err = gpg_error (GPG_ERR_INV_STATE);
1937
1938   if (err)
1939     return err;
1940
1941   /* Calculate new stop reason */
1942   if (state == sSTART)
1943     {
1944       if (cms->detached_data && !cms->data.digest)
1945         { /* We use this stop reason to inform the caller about a
1946              detached signatures.  Actually there is no need for him
1947              to hash the data now, he can do this also later. */
1948           stop_reason = KSBA_SR_NEED_HASH;
1949         }
1950       else
1951         { /* The user must now provide a hash function so that we can
1952              hash the data in the next round */
1953           stop_reason = KSBA_SR_BEGIN_DATA;
1954         }
1955     }
1956   else if (state == sIN_DATA)
1957     stop_reason = KSBA_SR_END_DATA;
1958   else if (state ==sGOT_HASH)
1959     stop_reason = KSBA_SR_READY;
1960
1961   cms->stop_reason = stop_reason;
1962   return 0;
1963 }
1964
1965
1966 static gpg_error_t
1967 ct_parse_enveloped_data (ksba_cms_t cms)
1968 {
1969   enum {
1970     sSTART,
1971     sREST,
1972     sINDATA,
1973     sERROR
1974   } state = sERROR;
1975   ksba_stop_reason_t stop_reason = cms->stop_reason;
1976   gpg_error_t err = 0;
1977
1978   cms->stop_reason = KSBA_SR_RUNNING;
1979
1980   /* Calculate state from last reason and do some checks */
1981   if (stop_reason == KSBA_SR_GOT_CONTENT)
1982     {
1983       state = sSTART;
1984     }
1985   else if (stop_reason == KSBA_SR_DETACHED_DATA)
1986     {
1987       state = sREST;
1988     }
1989   else if (stop_reason == KSBA_SR_BEGIN_DATA)
1990     {
1991       state = sINDATA;
1992     }
1993   else if (stop_reason == KSBA_SR_END_DATA)
1994     {
1995       state = sREST;
1996     }
1997   else if (stop_reason == KSBA_SR_RUNNING)
1998     err = gpg_error (GPG_ERR_INV_STATE);
1999   else if (stop_reason)
2000     err = gpg_error (GPG_ERR_BUG);
2001
2002   if (err)
2003     return err;
2004
2005   /* Do the action */
2006   if (state == sSTART)
2007     err = _ksba_cms_parse_enveloped_data_part_1 (cms);
2008   else if (state == sREST)
2009     err = _ksba_cms_parse_enveloped_data_part_2 (cms);
2010   else if (state == sINDATA)
2011     err = read_encrypted_cont (cms);
2012   else
2013     err = gpg_error (GPG_ERR_INV_STATE);
2014
2015   if (err)
2016     return err;
2017
2018   /* Calculate new stop reason */
2019   if (state == sSTART)
2020     {
2021       stop_reason = cms->detached_data? KSBA_SR_DETACHED_DATA
2022                                       : KSBA_SR_BEGIN_DATA;
2023     }
2024   else if (state == sINDATA)
2025     stop_reason = KSBA_SR_END_DATA;
2026   else if (state ==sREST)
2027     stop_reason = KSBA_SR_READY;
2028
2029   cms->stop_reason = stop_reason;
2030   return 0;
2031 }
2032
2033
2034 static gpg_error_t
2035 ct_parse_digested_data (ksba_cms_t cms)
2036 {
2037   (void)cms;
2038   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2039 }
2040
2041
2042 static gpg_error_t
2043 ct_parse_encrypted_data (ksba_cms_t cms)
2044 {
2045   (void)cms;
2046   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2047 }
2048
2049
2050 \f
2051 /*
2052    Content handlers for building messages
2053 */
2054
2055 static gpg_error_t
2056 ct_build_data (ksba_cms_t cms)
2057 {
2058   (void)cms;
2059   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2060 }
2061
2062
2063
2064 /* Write everything up to the encapsulated data content type. */
2065 static gpg_error_t
2066 build_signed_data_header (ksba_cms_t cms)
2067 {
2068   gpg_error_t err;
2069   unsigned char *buf;
2070   const char *s;
2071   size_t len;
2072   int i;
2073
2074   /* Write the outer contentInfo. */
2075   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
2076   if (err)
2077     return err;
2078   err = ksba_oid_from_str (cms->content.oid, &buf, &len);
2079   if (err)
2080     return err;
2081   err = _ksba_ber_write_tl (cms->writer,
2082                             TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, len);
2083   if (!err)
2084     err = ksba_writer_write (cms->writer, buf, len);
2085   xfree (buf);
2086   if (err)
2087     return err;
2088
2089   err = _ksba_ber_write_tl (cms->writer, 0, CLASS_CONTEXT, 1, 0);
2090   if (err)
2091     return err;
2092
2093   /* The SEQUENCE */
2094   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
2095   if (err)
2096     return err;
2097
2098   /* figure out the CMSVersion to be used */
2099   if (0 /* fixme: have_attribute_certificates
2100            || encapsulated_content != data
2101            || any_signer_info_is_version_3*/ )
2102     s = "\x03";
2103   else
2104     s = "\x01";
2105   err = _ksba_ber_write_tl (cms->writer, TYPE_INTEGER, CLASS_UNIVERSAL, 0, 1);
2106   if (err)
2107     return err;
2108   err = ksba_writer_write (cms->writer, s, 1);
2109   if (err)
2110     return err;
2111
2112   /* SET OF DigestAlgorithmIdentifier */
2113   {
2114     unsigned char *value;
2115     size_t valuelen;
2116     ksba_writer_t tmpwrt;
2117
2118     err = ksba_writer_new (&tmpwrt);
2119     if (err)
2120       return err;
2121     err = ksba_writer_set_mem (tmpwrt, 512);
2122     if (err)
2123       {
2124         ksba_writer_release (tmpwrt);
2125         return err;
2126       }
2127
2128     for (i=0; (s = ksba_cms_get_digest_algo_list (cms, i)); i++)
2129       {
2130         int j;
2131         const char *s2;
2132
2133         /* (make sure not to write duplicates) */
2134         for (j=0; j < i && (s2=ksba_cms_get_digest_algo_list (cms, j)); j++)
2135           {
2136             if (!strcmp (s, s2))
2137               break;
2138           }
2139         if (j == i)
2140           {
2141             err = _ksba_der_write_algorithm_identifier (tmpwrt, s, NULL, 0);
2142             if (err)
2143               {
2144                 ksba_writer_release (tmpwrt);
2145                 return err;
2146               }
2147           }
2148       }
2149
2150     value = ksba_writer_snatch_mem (tmpwrt, &valuelen);
2151     ksba_writer_release (tmpwrt);
2152     if (!value)
2153       {
2154         err = gpg_error (GPG_ERR_ENOMEM);
2155         return err;
2156       }
2157     err = _ksba_ber_write_tl (cms->writer, TYPE_SET, CLASS_UNIVERSAL,
2158                               1, valuelen);
2159     if (!err)
2160       err = ksba_writer_write (cms->writer, value, valuelen);
2161     xfree (value);
2162     if (err)
2163       return err;
2164   }
2165
2166
2167
2168   /* Write the (inner) encapsulatedContentInfo */
2169   /* if we have a detached signature we don't need to use undefinite
2170      length here - but it doesn't matter either */
2171   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
2172   if (err)
2173     return err;
2174   err = ksba_oid_from_str (cms->inner_cont_oid, &buf, &len);
2175   if (err)
2176     return err;
2177   err = _ksba_ber_write_tl (cms->writer,
2178                             TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, len);
2179   if (!err)
2180     err = ksba_writer_write (cms->writer, buf, len);
2181   xfree (buf);
2182   if (err)
2183     return err;
2184
2185   if ( !cms->detached_data)
2186     { /* write the tag */
2187       err = _ksba_ber_write_tl (cms->writer, 0, CLASS_CONTEXT, 1, 0);
2188       if (err)
2189         return err;
2190     }
2191
2192   return err;
2193 }
2194
2195 /* Set the issuer/serial from the cert to the node.
2196    mode 0: sid
2197    mode 1: rid
2198  */
2199 static gpg_error_t
2200 set_issuer_serial (AsnNode info, ksba_cert_t cert, int mode)
2201 {
2202   gpg_error_t err;
2203   AsnNode dst, src;
2204
2205   if (!info || !cert)
2206     return gpg_error (GPG_ERR_INV_VALUE);
2207
2208   src = _ksba_asn_find_node (cert->root,
2209                              "Certificate.tbsCertificate.serialNumber");
2210   dst = _ksba_asn_find_node (info,
2211                              mode?
2212                              "rid.issuerAndSerialNumber.serialNumber":
2213                              "sid.issuerAndSerialNumber.serialNumber");
2214   err = _ksba_der_copy_tree (dst, src, cert->image);
2215   if (err)
2216     return err;
2217
2218   src = _ksba_asn_find_node (cert->root,
2219                              "Certificate.tbsCertificate.issuer");
2220   dst = _ksba_asn_find_node (info,
2221                              mode?
2222                              "rid.issuerAndSerialNumber.issuer":
2223                              "sid.issuerAndSerialNumber.issuer");
2224   err = _ksba_der_copy_tree (dst, src, cert->image);
2225   if (err)
2226     return err;
2227
2228   return 0;
2229 }
2230
2231
2232 /* Store the sequence of capabilities at NODE */
2233 static gpg_error_t
2234 store_smime_capability_sequence (AsnNode node,
2235                                  struct oidparmlist_s *capabilities)
2236 {
2237   gpg_error_t err;
2238   struct oidparmlist_s *cap, *cap2;
2239   unsigned char *value;
2240   size_t valuelen;
2241   ksba_writer_t tmpwrt;
2242
2243   err = ksba_writer_new (&tmpwrt);
2244   if (err)
2245     return err;
2246   err = ksba_writer_set_mem (tmpwrt, 512);
2247   if (err)
2248     {
2249       ksba_writer_release (tmpwrt);
2250       return err;
2251     }
2252
2253   for (cap=capabilities; cap; cap = cap->next)
2254     {
2255       /* (avoid writing duplicates) */
2256       for (cap2=capabilities; cap2 != cap; cap2 = cap2->next)
2257         {
2258           if (!strcmp (cap->oid, cap2->oid)
2259               && cap->parmlen && cap->parmlen == cap2->parmlen
2260               && !memcmp (cap->parm, cap2->parm, cap->parmlen))
2261             break; /* Duplicate found. */
2262         }
2263       if (cap2 == cap)
2264         {
2265           /* RFC3851 requires that a missing parameter must not be
2266              encoded as NULL.  This is in contrast to all other usages
2267              of the algorithm identifier where ist is allowed and in
2268              some profiles (e.g. tmttv2) even explicitly suggested to
2269              use NULL.  */
2270           err = _ksba_der_write_algorithm_identifier
2271                  (tmpwrt, cap->oid,
2272                   cap->parmlen?cap->parm:(const void*)"", cap->parmlen);
2273           if (err)
2274             {
2275               ksba_writer_release (tmpwrt);
2276               return err;
2277             }
2278         }
2279     }
2280
2281   value = ksba_writer_snatch_mem (tmpwrt, &valuelen);
2282   if (!value)
2283     err = gpg_error (GPG_ERR_ENOMEM);
2284   if (!err)
2285     err = _ksba_der_store_sequence (node, value, valuelen);
2286   xfree (value);
2287   ksba_writer_release (tmpwrt);
2288   return err;
2289 }
2290
2291
2292 /* An object used to construct the signed attributes. */
2293 struct attrarray_s {
2294   AsnNode root;
2295   unsigned char *image;
2296   size_t imagelen;
2297 };
2298
2299
2300 /* Thank you ASN.1 committee for allowing us to employ a sort to make
2301    that DER encoding even more complicate. */
2302 static int
2303 compare_attrarray (const void *a_v, const void *b_v)
2304 {
2305   const struct attrarray_s *a = a_v;
2306   const struct attrarray_s *b = b_v;
2307   const unsigned char *ap, *bp;
2308   size_t an, bn;
2309
2310   ap = a->image;
2311   an = a->imagelen;
2312   bp = b->image;
2313   bn = b->imagelen;
2314   for (; an && bn; an--, bn--, ap++, bp++ )
2315     if (*ap != *bp)
2316       return *ap - *bp;
2317
2318   return (an == bn)? 0 : (an > bn)? 1 : -1;
2319 }
2320
2321
2322
2323
2324 /* Write the END of data NULL tag and everything we can write before
2325    the user can calculate the signature */
2326 static gpg_error_t
2327 build_signed_data_attributes (ksba_cms_t cms)
2328 {
2329   gpg_error_t err;
2330   int signer;
2331   ksba_asn_tree_t cms_tree = NULL;
2332   struct certlist_s *certlist;
2333   struct oidlist_s *digestlist;
2334   struct signer_info_s *si, **si_tail;
2335   AsnNode root = NULL;
2336   struct attrarray_s attrarray[4];
2337   int attridx = 0;
2338   int i;
2339
2340   memset (attrarray, 0, sizeof (attrarray));
2341
2342   /* Write the End tag */
2343   err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
2344   if (err)
2345     return err;
2346
2347   if (cms->signer_info)
2348     return gpg_error (GPG_ERR_CONFLICT); /* This list must be empty at
2349                                             this point. */
2350
2351   /* Write optional certificates */
2352   if (cms->cert_info_list)
2353     {
2354       unsigned long totallen = 0;
2355       const unsigned char *der;
2356       size_t n;
2357
2358       for (certlist = cms->cert_info_list; certlist; certlist = certlist->next)
2359         {
2360           if (!ksba_cert_get_image (certlist->cert, &n))
2361             return gpg_error (GPG_ERR_GENERAL); /* User passed an
2362                                                    unitialized cert */
2363           totallen += n;
2364         }
2365
2366       err = _ksba_ber_write_tl (cms->writer, 0, CLASS_CONTEXT, 1, totallen);
2367       if (err)
2368         return err;
2369
2370       for (certlist = cms->cert_info_list; certlist; certlist = certlist->next)
2371         {
2372           if (!(der=ksba_cert_get_image (certlist->cert, &n)))
2373             return gpg_error (GPG_ERR_BUG);
2374           err = ksba_writer_write (cms->writer, der, n);
2375           if (err )
2376             return err;
2377         }
2378     }
2379
2380   /* If we ever support it, here is the right place to do it:
2381      Write the optional CRLs */
2382
2383   /* Now we have to prepare the signer info.  For now we will just build the
2384      signedAttributes, so that the user can do the signature calculation */
2385   err = ksba_asn_create_tree ("cms", &cms_tree);
2386   if (err)
2387     return err;
2388
2389   certlist = cms->cert_list;
2390   if (!certlist)
2391     {
2392       err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
2393       goto leave;
2394     }
2395   digestlist = cms->digest_algos;
2396   if (!digestlist)
2397     {
2398       err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
2399       goto leave;
2400     }
2401
2402   si_tail = &cms->signer_info;
2403   for (signer=0; certlist;
2404        signer++, certlist = certlist->next, digestlist = digestlist->next)
2405     {
2406       AsnNode attr;
2407       AsnNode n;
2408       unsigned char *image;
2409       size_t imagelen;
2410
2411       for (i = 0; i < attridx; i++)
2412         {
2413           _ksba_asn_release_nodes (attrarray[i].root);
2414           xfree (attrarray[i].image);
2415         }
2416       attridx = 0;
2417       memset (attrarray, 0, sizeof (attrarray));
2418
2419       if (!digestlist)
2420         {
2421           err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
2422           goto leave;
2423         }
2424
2425       if (!certlist->cert || !digestlist->oid)
2426         {
2427           err = gpg_error (GPG_ERR_BUG);
2428           goto leave;
2429         }
2430
2431       /* Include the pretty important message digest. */
2432       attr = _ksba_asn_expand_tree (cms_tree->parse_tree,
2433                                     "CryptographicMessageSyntax.Attribute");
2434       if (!attr)
2435         {
2436           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2437           goto leave;
2438         }
2439       n = _ksba_asn_find_node (attr, "Attribute.attrType");
2440       if (!n)
2441         {
2442           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2443           goto leave;
2444         }
2445       err = _ksba_der_store_oid (n, oidstr_messageDigest);
2446       if (err)
2447         goto leave;
2448       n = _ksba_asn_find_node (attr, "Attribute.attrValues");
2449       if (!n || !n->down)
2450         return gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2451       n = n->down; /* fixme: ugly hack */
2452       assert (certlist && certlist->msg_digest_len);
2453       err = _ksba_der_store_octet_string (n, certlist->msg_digest,
2454                                           certlist->msg_digest_len);
2455       if (err)
2456         goto leave;
2457       err = _ksba_der_encode_tree (attr, &image, &imagelen);
2458       if (err)
2459         goto leave;
2460       attrarray[attridx].root = attr;
2461       attrarray[attridx].image = image;
2462       attrarray[attridx].imagelen = imagelen;
2463       attridx++;
2464
2465       /* Include the content-type attribute. */
2466       attr = _ksba_asn_expand_tree (cms_tree->parse_tree,
2467                                     "CryptographicMessageSyntax.Attribute");
2468       if (!attr)
2469         {
2470           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2471           goto leave;
2472         }
2473       n = _ksba_asn_find_node (attr, "Attribute.attrType");
2474       if (!n)
2475         {
2476           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2477           goto leave;
2478         }
2479       err = _ksba_der_store_oid (n, oidstr_contentType);
2480       if (err)
2481         goto leave;
2482       n = _ksba_asn_find_node (attr, "Attribute.attrValues");
2483       if (!n || !n->down)
2484         {
2485           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2486           goto leave;
2487         }
2488       n = n->down; /* fixme: ugly hack */
2489       err = _ksba_der_store_oid (n, cms->inner_cont_oid);
2490       if (err)
2491         goto leave;
2492       err = _ksba_der_encode_tree (attr, &image, &imagelen);
2493       if (err)
2494         goto leave;
2495       attrarray[attridx].root = attr;
2496       attrarray[attridx].image = image;
2497       attrarray[attridx].imagelen = imagelen;
2498       attridx++;
2499
2500       /* Include the signing time */
2501       if (*certlist->signing_time)
2502         {
2503           attr = _ksba_asn_expand_tree (cms_tree->parse_tree,
2504                                      "CryptographicMessageSyntax.Attribute");
2505           if (!attr)
2506             {
2507               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2508               goto leave;
2509             }
2510           n = _ksba_asn_find_node (attr, "Attribute.attrType");
2511           if (!n)
2512             {
2513               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2514               goto leave;
2515             }
2516           err = _ksba_der_store_oid (n, oidstr_signingTime);
2517           if (err)
2518             goto leave;
2519           n = _ksba_asn_find_node (attr, "Attribute.attrValues");
2520           if (!n || !n->down)
2521             {
2522               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2523               goto leave;
2524             }
2525           n = n->down; /* fixme: ugly hack */
2526           err = _ksba_der_store_time (n, certlist->signing_time);
2527           if (err)
2528             goto leave;
2529           err = _ksba_der_encode_tree (attr, &image, &imagelen);
2530           if (err)
2531             goto leave;
2532           /* We will use the attributes again - so save them */
2533           attrarray[attridx].root = attr;
2534           attrarray[attridx].image = image;
2535           attrarray[attridx].imagelen = imagelen;
2536           attridx++;
2537         }
2538
2539       /* Include the S/MIME capabilities with the first signer. */
2540       if (cms->capability_list && !signer)
2541         {
2542           attr = _ksba_asn_expand_tree (cms_tree->parse_tree,
2543                                     "CryptographicMessageSyntax.Attribute");
2544           if (!attr)
2545             {
2546               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2547               goto leave;
2548             }
2549           n = _ksba_asn_find_node (attr, "Attribute.attrType");
2550           if (!n)
2551             {
2552               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2553               goto leave;
2554             }
2555           err = _ksba_der_store_oid (n, oidstr_smimeCapabilities);
2556           if (err)
2557             goto leave;
2558           n = _ksba_asn_find_node (attr, "Attribute.attrValues");
2559           if (!n || !n->down)
2560             {
2561               err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2562               goto leave;
2563             }
2564           n = n->down; /* fixme: ugly hack */
2565           err = store_smime_capability_sequence (n, cms->capability_list);
2566           if (err)
2567             goto leave;
2568           err = _ksba_der_encode_tree (attr, &image, &imagelen);
2569           if (err)
2570             goto leave;
2571           attrarray[attridx].root = attr;
2572           attrarray[attridx].image = image;
2573           attrarray[attridx].imagelen = imagelen;
2574           attridx++;
2575         }
2576
2577       /* Arggh.  That silly ASN.1 DER encoding rules: We need to sort
2578          the SET values. */
2579       qsort (attrarray, attridx, sizeof (struct attrarray_s),
2580              compare_attrarray);
2581
2582       /* Now copy them to an SignerInfo tree.  This tree is not
2583          complete but suitable for ksba_cms_hash_signed_attributes() */
2584       root = _ksba_asn_expand_tree (cms_tree->parse_tree,
2585                                     "CryptographicMessageSyntax.SignerInfo");
2586       n = _ksba_asn_find_node (root, "SignerInfo.signedAttrs");
2587       if (!n || !n->down)
2588         {
2589           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2590           goto leave;
2591         }
2592       /* This is another ugly hack to move to the element we want */
2593       for (n = n->down->down; n && n->type != TYPE_SEQUENCE; n = n->right)
2594         ;
2595       if (!n)
2596         {
2597           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2598           goto leave;
2599         }
2600
2601       assert (attridx <= DIM (attrarray));
2602       for (i=0; i < attridx; i++)
2603         {
2604           if (i)
2605             {
2606               if ( !(n=_ksba_asn_insert_copy (n)))
2607                 {
2608                   err = gpg_error (GPG_ERR_ENOMEM);
2609                   goto leave;
2610                 }
2611             }
2612           err = _ksba_der_copy_tree (n, attrarray[i].root, attrarray[i].image);
2613           if (err)
2614             goto leave;
2615           _ksba_asn_release_nodes (attrarray[i].root);
2616           free (attrarray[i].image);
2617           attrarray[i].root = NULL;
2618           attrarray[i].image = NULL;
2619         }
2620
2621       err = _ksba_der_encode_tree (root, &image, NULL);
2622       if (err)
2623         goto leave;
2624
2625       si = xtrycalloc (1, sizeof *si);
2626       if (!si)
2627         return gpg_error (GPG_ERR_ENOMEM);
2628       si->root = root;
2629       root = NULL;
2630       si->image = image;
2631       /* Hmmm, we don't set the length of the image. */
2632       *si_tail = si;
2633       si_tail = &si->next;
2634     }
2635
2636  leave:
2637   _ksba_asn_release_nodes (root);
2638   ksba_asn_tree_release (cms_tree);
2639   for (i = 0; i < attridx; i++)
2640     {
2641       _ksba_asn_release_nodes (attrarray[i].root);
2642       xfree (attrarray[i].image);
2643     }
2644
2645   return err;
2646 }
2647
2648
2649
2650
2651 /* The user has calculated the signatures and we can therefore write
2652    everything left over to do. */
2653 static gpg_error_t
2654 build_signed_data_rest (ksba_cms_t cms)
2655 {
2656   gpg_error_t err;
2657   int signer;
2658   ksba_asn_tree_t cms_tree = NULL;
2659   struct certlist_s *certlist;
2660   struct oidlist_s *digestlist;
2661   struct signer_info_s *si;
2662   struct sig_val_s *sv;
2663   ksba_writer_t tmpwrt = NULL;
2664   AsnNode root = NULL;
2665
2666   /* Now we can really write the signer info */
2667   err = ksba_asn_create_tree ("cms", &cms_tree);
2668   if (err)
2669     return err;
2670
2671   certlist = cms->cert_list;
2672   if (!certlist)
2673     {
2674       err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
2675       return err;
2676     }
2677
2678   /* To construct the set we use a temporary writer object. */
2679   err = ksba_writer_new (&tmpwrt);
2680   if (err)
2681     goto leave;
2682   err = ksba_writer_set_mem (tmpwrt, 2048);
2683   if (err)
2684     goto leave;
2685
2686   digestlist = cms->digest_algos;
2687   si = cms->signer_info;
2688   sv = cms->sig_val;
2689
2690   for (signer=0; certlist;
2691        signer++,
2692          certlist = certlist->next,
2693          digestlist = digestlist->next,
2694          si = si->next,
2695          sv = sv->next)
2696     {
2697       AsnNode n, n2;
2698       unsigned char *image;
2699       size_t imagelen;
2700
2701       if (!digestlist || !si || !sv)
2702         {
2703           err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
2704           goto leave;
2705         }
2706       if (!certlist->cert || !digestlist->oid)
2707         {
2708           err = gpg_error (GPG_ERR_BUG);
2709           goto leave;
2710         }
2711
2712       root = _ksba_asn_expand_tree (cms_tree->parse_tree,
2713                                     "CryptographicMessageSyntax.SignerInfo");
2714
2715       /* We store a version of 1 because we use the issuerAndSerialNumber */
2716       n = _ksba_asn_find_node (root, "SignerInfo.version");
2717       if (!n)
2718         {
2719           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2720           goto leave;
2721         }
2722       err = _ksba_der_store_integer (n, "\x00\x00\x00\x01\x01");
2723       if (err)
2724         goto leave;
2725
2726       /* Store the sid */
2727       n = _ksba_asn_find_node (root, "SignerInfo.sid");
2728       if (!n)
2729         {
2730           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2731           goto leave;
2732         }
2733
2734       err = set_issuer_serial (n, certlist->cert, 0);
2735       if (err)
2736         goto leave;
2737
2738       /* store the digestAlgorithm */
2739       n = _ksba_asn_find_node (root, "SignerInfo.digestAlgorithm.algorithm");
2740       if (!n)
2741         {
2742           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2743           goto leave;
2744         }
2745       err = _ksba_der_store_oid (n, digestlist->oid);
2746       if (err)
2747         goto leave;
2748       n = _ksba_asn_find_node (root, "SignerInfo.digestAlgorithm.parameters");
2749       if (!n)
2750         {
2751           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2752           goto leave;
2753         }
2754       err = _ksba_der_store_null (n);
2755       if (err)
2756         goto leave;
2757
2758       /* and the signed attributes */
2759       n = _ksba_asn_find_node (root, "SignerInfo.signedAttrs");
2760       if (!n || !n->down)
2761         {
2762           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2763           goto leave;
2764         }
2765       assert (si->root);
2766       assert (si->image);
2767       n2 = _ksba_asn_find_node (si->root, "SignerInfo.signedAttrs");
2768       if (!n2 || !n2->down)
2769         {
2770           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2771           goto leave;
2772         }
2773       err = _ksba_der_copy_tree (n, n2, si->image);
2774       if (err)
2775         goto leave;
2776       image = NULL;
2777
2778       /* store the signatureAlgorithm */
2779       n = _ksba_asn_find_node (root,
2780                                "SignerInfo.signatureAlgorithm.algorithm");
2781       if (!n)
2782         {
2783           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2784           goto leave;
2785         }
2786       if (!sv->algo)
2787         {
2788           err = gpg_error (GPG_ERR_MISSING_VALUE);
2789           goto leave;
2790         }
2791       err = _ksba_der_store_oid (n, sv->algo);
2792       if (err)
2793         goto leave;
2794       n = _ksba_asn_find_node (root,
2795                                "SignerInfo.signatureAlgorithm.parameters");
2796       if (!n)
2797         {
2798           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2799           goto leave;
2800         }
2801       err = _ksba_der_store_null (n);
2802       if (err)
2803         goto leave;
2804
2805       /* store the signature  */
2806       if (!sv->value)
2807         {
2808           err = gpg_error (GPG_ERR_MISSING_VALUE);
2809           goto leave;
2810         }
2811       n = _ksba_asn_find_node (root, "SignerInfo.signature");
2812       if (!n)
2813         {
2814           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
2815           goto leave;
2816         }
2817       err = _ksba_der_store_octet_string (n, sv->value, sv->valuelen);
2818       if (err)
2819         goto leave;
2820
2821       /* Make the DER encoding and write it out. */
2822       err = _ksba_der_encode_tree (root, &image, &imagelen);
2823       if (err)
2824         goto leave;
2825
2826       err = ksba_writer_write (tmpwrt, image, imagelen);
2827       xfree (image);
2828       if (err)
2829         goto leave;
2830     }
2831
2832   /* Write out the SET filled with all signer infos */
2833   {
2834     unsigned char *value;
2835     size_t valuelen;
2836
2837     value = ksba_writer_snatch_mem (tmpwrt, &valuelen);
2838     if (!value)
2839       {
2840         err = gpg_error (GPG_ERR_ENOMEM);
2841         goto leave;
2842       }
2843     err = _ksba_ber_write_tl (cms->writer, TYPE_SET, CLASS_UNIVERSAL,
2844                               1, valuelen);
2845     if (!err)
2846       err = ksba_writer_write (cms->writer, value, valuelen);
2847     xfree (value);
2848     if (err)
2849       goto leave;
2850   }
2851
2852   /* Write 3 end tags */
2853   err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
2854   if (!err)
2855     err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
2856   if (!err)
2857     err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
2858
2859  leave:
2860   ksba_asn_tree_release (cms_tree);
2861   _ksba_asn_release_nodes (root);
2862   ksba_writer_release (tmpwrt);
2863
2864   return err;
2865 }
2866
2867
2868
2869
2870 static gpg_error_t
2871 ct_build_signed_data (ksba_cms_t cms)
2872 {
2873   enum {
2874     sSTART,
2875     sDATAREADY,
2876     sGOTSIG,
2877     sERROR
2878   } state = sERROR;
2879   ksba_stop_reason_t stop_reason;
2880   gpg_error_t err = 0;
2881
2882   stop_reason = cms->stop_reason;
2883   cms->stop_reason = KSBA_SR_RUNNING;
2884
2885   /* Calculate state from last reason and do some checks */
2886   if (stop_reason == KSBA_SR_GOT_CONTENT)
2887     {
2888       state = sSTART;
2889     }
2890   else if (stop_reason == KSBA_SR_BEGIN_DATA)
2891     {
2892       /* fixme: check that the message digest has been set */
2893       state = sDATAREADY;
2894     }
2895   else if (stop_reason == KSBA_SR_END_DATA)
2896     state = sDATAREADY;
2897   else if (stop_reason == KSBA_SR_NEED_SIG)
2898     {
2899       if (!cms->sig_val)
2900         err = gpg_error (GPG_ERR_MISSING_ACTION); /* No ksba_cms_set_sig_val () called */
2901       state = sGOTSIG;
2902     }
2903   else if (stop_reason == KSBA_SR_RUNNING)
2904     err = gpg_error (GPG_ERR_INV_STATE);
2905   else if (stop_reason)
2906     err = gpg_error (GPG_ERR_BUG);
2907
2908   if (err)
2909     return err;
2910
2911   /* Do the action */
2912   if (state == sSTART)
2913     {
2914       /* figure out whether a detached signature is requested */
2915       if (cms->cert_list && cms->cert_list->msg_digest_len)
2916         cms->detached_data = 1;
2917       else
2918         cms->detached_data = 0;
2919       /* and start encoding */
2920       err = build_signed_data_header (cms);
2921     }
2922   else if (state == sDATAREADY)
2923     {
2924       if (!cms->detached_data)
2925         err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
2926       if (!err)
2927         err = build_signed_data_attributes (cms);
2928     }
2929   else if (state == sGOTSIG)
2930     err = build_signed_data_rest (cms);
2931   else
2932     err = gpg_error (GPG_ERR_INV_STATE);
2933
2934   if (err)
2935     return err;
2936
2937   /* Calculate new stop reason */
2938   if (state == sSTART)
2939     {
2940       /* user should write the data and calculate the hash or do
2941          nothing in case of END_DATA */
2942       stop_reason = cms->detached_data? KSBA_SR_END_DATA
2943                                       : KSBA_SR_BEGIN_DATA;
2944     }
2945   else if (state == sDATAREADY)
2946     stop_reason = KSBA_SR_NEED_SIG;
2947   else if (state == sGOTSIG)
2948     stop_reason = KSBA_SR_READY;
2949
2950   cms->stop_reason = stop_reason;
2951   return 0;
2952 }
2953
2954 \f
2955 /* write everything up to the encryptedContentInfo including the tag */
2956 static gpg_error_t
2957 build_enveloped_data_header (ksba_cms_t cms)
2958 {
2959   gpg_error_t err;
2960   int recpno;
2961   ksba_asn_tree_t cms_tree = NULL;
2962   struct certlist_s *certlist;
2963   unsigned char *buf;
2964   const char *s;
2965   size_t len;
2966   ksba_writer_t tmpwrt = NULL;
2967
2968   /* Write the outer contentInfo */
2969   /* fixme: code is shared with signed_data_header */
2970   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
2971   if (err)
2972     return err;
2973   err = ksba_oid_from_str (cms->content.oid, &buf, &len);
2974   if (err)
2975     return err;
2976   err = _ksba_ber_write_tl (cms->writer,
2977                             TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, len);
2978   if (!err)
2979     err = ksba_writer_write (cms->writer, buf, len);
2980   xfree (buf);
2981   if (err)
2982     return err;
2983
2984   err = _ksba_ber_write_tl (cms->writer, 0, CLASS_CONTEXT, 1, 0);
2985   if (err)
2986     return err;
2987
2988   /* The SEQUENCE */
2989   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
2990   if (err)
2991     return err;
2992
2993   /* figure out the CMSVersion to be used (from rfc2630):
2994      version is the syntax version number.  If originatorInfo is
2995      present, then version shall be 2.  If any of the RecipientInfo
2996      structures included have a version other than 0, then the version
2997      shall be 2.  If unprotectedAttrs is present, then version shall
2998      be 2.  If originatorInfo is absent, all of the RecipientInfo
2999      structures are version 0, and unprotectedAttrs is absent, then
3000      version shall be 0.
3001
3002      For SPHINX the version number must be 0.
3003   */
3004   s = "\x00";
3005   err = _ksba_ber_write_tl (cms->writer, TYPE_INTEGER, CLASS_UNIVERSAL, 0, 1);
3006   if (err)
3007     return err;
3008   err = ksba_writer_write (cms->writer, s, 1);
3009   if (err)
3010     return err;
3011
3012   /* Note: originatorInfo is not yet implemented and must not be used
3013      for SPHINX */
3014
3015   /* Now we write the recipientInfo */
3016   err = ksba_asn_create_tree ("cms", &cms_tree);
3017   if (err)
3018     return err;
3019
3020   certlist = cms->cert_list;
3021   if (!certlist)
3022     {
3023       err = gpg_error (GPG_ERR_MISSING_VALUE); /* oops */
3024       goto leave;
3025     }
3026
3027   /* To construct the set we use a temporary writer object */
3028   err = ksba_writer_new (&tmpwrt);
3029   if (err)
3030     goto leave;
3031   err = ksba_writer_set_mem (tmpwrt, 2048);
3032   if (err)
3033     goto leave;
3034
3035   for (recpno=0; certlist; recpno++, certlist = certlist->next)
3036     {
3037       AsnNode root, n;
3038       unsigned char *image;
3039       size_t imagelen;
3040
3041       if (!certlist->cert)
3042         {
3043           err = gpg_error (GPG_ERR_BUG);
3044           goto leave;
3045         }
3046
3047       root = _ksba_asn_expand_tree (cms_tree->parse_tree,
3048                                 "CryptographicMessageSyntax.RecipientInfo");
3049
3050       /* We store a version of 0 because we are only allowed to use
3051          the issuerAndSerialNumber for SPHINX */
3052       n = _ksba_asn_find_node (root, "RecipientInfo.ktri.version");
3053       if (!n)
3054         {
3055           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
3056           goto leave;
3057         }
3058       err = _ksba_der_store_integer (n, "\x00\x00\x00\x01\x00");
3059       if (err)
3060         goto leave;
3061
3062       /* Store the rid */
3063       n = _ksba_asn_find_node (root, "RecipientInfo.ktri.rid");
3064       if (!n)
3065         {
3066           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
3067           goto leave;
3068         }
3069
3070       err = set_issuer_serial (n, certlist->cert, 1);
3071       if (err)
3072         goto leave;
3073
3074       /* store the keyEncryptionAlgorithm */
3075       if (!certlist->enc_val.algo || !certlist->enc_val.value)
3076         return gpg_error (GPG_ERR_MISSING_VALUE);
3077       n = _ksba_asn_find_node (root,
3078                   "RecipientInfo.ktri.keyEncryptionAlgorithm.algorithm");
3079       if (!n)
3080         {
3081           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
3082           goto leave;
3083         }
3084       err = _ksba_der_store_oid (n, certlist->enc_val.algo);
3085       if (err)
3086         goto leave;
3087       n = _ksba_asn_find_node (root,
3088                   "RecipientInfo.ktri.keyEncryptionAlgorithm.parameters");
3089       if (!n)
3090         {
3091           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
3092           goto leave;
3093         }
3094
3095       /* Now store NULL for the optional parameters.  From Peter
3096        * Gutmann's X.509 style guide:
3097        *
3098        *   Another pitfall to be aware of is that algorithms which
3099        *   have no parameters have this specified as a NULL value
3100        *   rather than omitting the parameters field entirely.  The
3101        *   reason for this is that when the 1988 syntax for
3102        *   AlgorithmIdentifier was translated into the 1997 syntax,
3103        *   the OPTIONAL associated with the AlgorithmIdentifier
3104        *   parameters got lost.  Later it was recovered via a defect
3105        *   report, but by then everyone thought that algorithm
3106        *   parameters were mandatory.  Because of this the algorithm
3107        *   parameters should be specified as NULL, regardless of what
3108        *   you read elsewhere.
3109        *
3110        *        The trouble is that things *never* get better, they just
3111        *        stay the same, only more so
3112        *            -- Terry Pratchett, "Eric"
3113        *
3114        * Although this is about signing, we always do it.  Versions of
3115        * Libksba before 1.0.6 had a bug writing out the NULL tag here,
3116        * thus in reality we used to be correct according to the
3117        * standards despite we didn't intended so.
3118        */
3119
3120       err = _ksba_der_store_null (n);
3121       if (err)
3122         goto leave;
3123
3124       /* store the encryptedKey  */
3125       if (!certlist->enc_val.value)
3126         {
3127           err = gpg_error (GPG_ERR_MISSING_VALUE);
3128           goto leave;
3129         }
3130       n = _ksba_asn_find_node (root, "RecipientInfo.ktri.encryptedKey");
3131       if (!n)
3132         {
3133           err = gpg_error (GPG_ERR_ELEMENT_NOT_FOUND);
3134           goto leave;
3135         }
3136       err = _ksba_der_store_octet_string (n,
3137                                           certlist->enc_val.value,
3138                                           certlist->enc_val.valuelen);
3139       if (err)
3140         goto leave;
3141
3142
3143       /* Make the DER encoding and write it out */
3144       err = _ksba_der_encode_tree (root, &image, &imagelen);
3145       if (err)
3146           goto leave;
3147
3148       err = ksba_writer_write (tmpwrt, image, imagelen);
3149       if (err)
3150         goto leave;
3151
3152       xfree (image);
3153       _ksba_asn_release_nodes (root);
3154     }
3155
3156   ksba_asn_tree_release (cms_tree);
3157   cms_tree = NULL;
3158
3159   /* Write out the SET filled with all recipient infos */
3160   {
3161     unsigned char *value;
3162     size_t valuelen;
3163
3164     value = ksba_writer_snatch_mem (tmpwrt, &valuelen);
3165     if (!value)
3166       {
3167         err = gpg_error (GPG_ERR_ENOMEM);
3168         goto leave;
3169       }
3170     ksba_writer_release (tmpwrt);
3171     tmpwrt = NULL;
3172     err = _ksba_ber_write_tl (cms->writer, TYPE_SET, CLASS_UNIVERSAL,
3173                               1, valuelen);
3174     if (!err)
3175       err = ksba_writer_write (cms->writer, value, valuelen);
3176     xfree (value);
3177     if (err)
3178       goto leave;
3179   }
3180
3181
3182   /* Write the (inner) encryptedContentInfo */
3183   err = _ksba_ber_write_tl (cms->writer, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, 0);
3184   if (err)
3185     return err;
3186   err = ksba_oid_from_str (cms->inner_cont_oid, &buf, &len);
3187   if (err)
3188     return err;
3189   err = _ksba_ber_write_tl (cms->writer,
3190                             TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, len);
3191   if (!err)
3192     err = ksba_writer_write (cms->writer, buf, len);
3193   xfree (buf);
3194   if (err)
3195     return err;
3196
3197   /* and the encryptionAlgorithm */
3198   err = _ksba_der_write_algorithm_identifier (cms->writer,
3199                                               cms->encr_algo_oid,
3200                                               cms->encr_iv,
3201                                               cms->encr_ivlen);
3202   if (err)
3203     return err;
3204
3205   /* write the tag for the encrypted data, it is an implicit octect
3206      string in constructed form and indefinite length */
3207   err = _ksba_ber_write_tl (cms->writer, 0, CLASS_CONTEXT, 1, 0);
3208   if (err)
3209     return err;
3210
3211   /* Now the encrypted data should be written */
3212
3213  leave:
3214   ksba_writer_release (tmpwrt);
3215   ksba_asn_tree_release (cms_tree);
3216   return err;
3217 }
3218
3219
3220 static gpg_error_t
3221 ct_build_enveloped_data (ksba_cms_t cms)
3222 {
3223   enum {
3224     sSTART,
3225     sINDATA,
3226     sREST,
3227     sERROR
3228   } state = sERROR;
3229   ksba_stop_reason_t stop_reason;
3230   gpg_error_t err = 0;
3231
3232   stop_reason = cms->stop_reason;
3233   cms->stop_reason = KSBA_SR_RUNNING;
3234
3235   /* Calculate state from last reason and do some checks */
3236   if (stop_reason == KSBA_SR_GOT_CONTENT)
3237     state = sSTART;
3238   else if (stop_reason == KSBA_SR_BEGIN_DATA)
3239     state = sINDATA;
3240   else if (stop_reason == KSBA_SR_END_DATA)
3241     state = sREST;
3242   else if (stop_reason == KSBA_SR_RUNNING)
3243     err = gpg_error (GPG_ERR_INV_STATE);
3244   else if (stop_reason)
3245     err = gpg_error (GPG_ERR_BUG);
3246
3247   if (err)
3248     return err;
3249
3250   /* Do the action */
3251   if (state == sSTART)
3252     err = build_enveloped_data_header (cms);
3253   else if (state == sINDATA)
3254     err = write_encrypted_cont (cms);
3255   else if (state == sREST)
3256     {
3257       /* SPHINX does not allow for unprotectedAttributes */
3258
3259       /* Write 5 end tags */
3260       err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
3261       if (!err)
3262         err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
3263       if (!err)
3264         err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
3265       if (!err)
3266         err = _ksba_ber_write_tl (cms->writer, 0, 0, 0, 0);
3267     }
3268   else
3269     err = gpg_error (GPG_ERR_INV_STATE);
3270
3271   if (err)
3272     return err;
3273
3274   /* Calculate new stop reason */
3275   if (state == sSTART)
3276     { /* user should now write the encrypted data */
3277       stop_reason = KSBA_SR_BEGIN_DATA;
3278     }
3279   else if (state == sINDATA)
3280     { /* tell the user that we wrote everything */
3281       stop_reason = KSBA_SR_END_DATA;
3282     }
3283   else if (state == sREST)
3284     {
3285       stop_reason = KSBA_SR_READY;
3286     }
3287
3288   cms->stop_reason = stop_reason;
3289   return 0;
3290 }
3291
3292
3293 static gpg_error_t
3294 ct_build_digested_data (ksba_cms_t cms)
3295 {
3296   (void)cms;
3297   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3298 }
3299
3300
3301 static gpg_error_t
3302 ct_build_encrypted_data (ksba_cms_t cms)
3303 {
3304   (void)cms;
3305   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
3306 }