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