Make gpgconf aware of --p12-charset.
[gnupg.git] / agent / minip12.c
1 /* minip12.c - A minimal pkcs-12 implementation.
2  * Copyright (C) 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <assert.h>
29 #include <gcrypt.h>
30 #include <iconv.h>
31 #include <errno.h>
32
33 #ifdef TEST
34 #include <sys/stat.h>
35 #include <unistd.h>
36 #endif
37
38 #include "../jnlib/logging.h"
39 #include "minip12.h"
40
41 #ifndef DIM
42 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
43 #endif
44
45 #ifndef ICONV_CONST
46 #define ICONV_CONST
47 #endif
48
49
50
51 enum
52 {
53   UNIVERSAL = 0,
54   APPLICATION = 1,
55   CONTEXT = 2,
56   PRIVATE = 3
57 };
58
59
60 enum
61 {
62   TAG_NONE = 0,
63   TAG_BOOLEAN = 1,
64   TAG_INTEGER = 2,
65   TAG_BIT_STRING = 3,
66   TAG_OCTET_STRING = 4,
67   TAG_NULL = 5,
68   TAG_OBJECT_ID = 6,
69   TAG_OBJECT_DESCRIPTOR = 7,
70   TAG_EXTERNAL = 8,
71   TAG_REAL = 9,
72   TAG_ENUMERATED = 10,
73   TAG_EMBEDDED_PDV = 11,
74   TAG_UTF8_STRING = 12,
75   TAG_REALTIVE_OID = 13,
76   TAG_SEQUENCE = 16,
77   TAG_SET = 17,
78   TAG_NUMERIC_STRING = 18,
79   TAG_PRINTABLE_STRING = 19,
80   TAG_TELETEX_STRING = 20,
81   TAG_VIDEOTEX_STRING = 21,
82   TAG_IA5_STRING = 22,
83   TAG_UTC_TIME = 23,
84   TAG_GENERALIZED_TIME = 24,
85   TAG_GRAPHIC_STRING = 25,
86   TAG_VISIBLE_STRING = 26,
87   TAG_GENERAL_STRING = 27,
88   TAG_UNIVERSAL_STRING = 28,
89   TAG_CHARACTER_STRING = 29,
90   TAG_BMP_STRING = 30
91 };
92
93
94 static unsigned char const oid_data[9] = {
95   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
96 static unsigned char const oid_encryptedData[9] = {
97   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x06 };
98 static unsigned char const oid_pkcs_12_keyBag[11] = {
99   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x01 };
100 static unsigned char const oid_pkcs_12_pkcs_8ShroudedKeyBag[11] = {
101   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x02 };
102 static unsigned char const oid_pkcs_12_CertBag[11] = {
103   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x03 };
104 static unsigned char const oid_pkcs_12_CrlBag[11] = {
105   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x04 };
106
107 static unsigned char const oid_pbeWithSHAAnd3_KeyTripleDES_CBC[10] = {
108   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03 };
109 static unsigned char const oid_pbeWithSHAAnd40BitRC2_CBC[10] = {
110   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x06 };
111 static unsigned char const oid_x509Certificate_for_pkcs_12[10] = {
112   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x16, 0x01 };
113
114
115 static unsigned char const oid_rsaEncryption[9] = {
116   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 };
117
118
119 static unsigned char const data_3desiter2048[30] = {
120   0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, 0x86,
121   0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, 0x0E, 
122   0x04, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
123   0xFF, 0xFF, 0x02, 0x02, 0x08, 0x00 };
124 #define DATA_3DESITER2048_SALT_OFF  18
125
126 static unsigned char const data_rc2iter2048[30] = {
127   0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, 0x86,
128   0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x06, 0x30, 0x0E, 
129   0x04, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
130   0xFF, 0xFF, 0x02, 0x02, 0x08, 0x00 };
131 #define DATA_RC2ITER2048_SALT_OFF  18
132
133 static unsigned char const data_mactemplate[51] = {
134   0x30, 0x31, 0x30, 0x21, 0x30, 0x09, 0x06, 0x05,
135   0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04,
136   0x14, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
137   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
138   0xff, 0xff, 0xff, 0xff, 0xff, 0x04, 0x08, 0xff,
139   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x02,
140   0x02, 0x08, 0x00 }; 
141 #define DATA_MACTEMPLATE_MAC_OFF 17
142 #define DATA_MACTEMPLATE_SALT_OFF 39
143
144 static unsigned char const data_attrtemplate[106] = {
145   0x31, 0x7c, 0x30, 0x55, 0x06, 0x09, 0x2a, 0x86,
146   0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x14, 0x31,
147   0x48, 0x1e, 0x46, 0x00, 0x47, 0x00, 0x6e, 0x00,
148   0x75, 0x00, 0x50, 0x00, 0x47, 0x00, 0x20, 0x00,
149   0x65, 0x00, 0x78, 0x00, 0x70, 0x00, 0x6f, 0x00,
150   0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
151   0x20, 0x00, 0x63, 0x00, 0x65, 0x00, 0x72, 0x00,
152   0x74, 0x00, 0x69, 0x00, 0x66, 0x00, 0x69, 0x00,
153   0x63, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00,
154   0x20, 0x00, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00,
155   0x66, 0x00, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00,
156   0x66, 0x30, 0x23, 0x06, 0x09, 0x2a, 0x86, 0x48,
157   0x86, 0xf7, 0x0d, 0x01, 0x09, 0x15, 0x31, 0x16,
158   0x04, 0x14 }; /* Need to append SHA-1 digest. */
159 #define DATA_ATTRTEMPLATE_KEYID_OFF 73
160
161 struct buffer_s 
162 {
163   unsigned char *buffer;
164   size_t length;
165 };  
166
167
168 struct tag_info 
169 {
170   int class;
171   int is_constructed;
172   unsigned long tag;
173   unsigned long length;  /* length part of the TLV */
174   int nhdr;
175   int ndef;              /* It is an indefinite length */
176 };
177
178
179 /* Parse the buffer at the address BUFFER which is of SIZE and return
180    the tag and the length part from the TLV triplet.  Update BUFFER
181    and SIZE on success.  Checks that the encoded length does not
182    exhaust the length of the provided buffer. */
183 static int 
184 parse_tag (unsigned char const **buffer, size_t *size, struct tag_info *ti)
185 {
186   int c;
187   unsigned long tag;
188   const unsigned char *buf = *buffer;
189   size_t length = *size;
190
191   ti->length = 0;
192   ti->ndef = 0;
193   ti->nhdr = 0;
194
195   /* Get the tag */
196   if (!length)
197     return -1; /* premature eof */
198   c = *buf++; length--;
199   ti->nhdr++;
200
201   ti->class = (c & 0xc0) >> 6;
202   ti->is_constructed = !!(c & 0x20);
203   tag = c & 0x1f;
204
205   if (tag == 0x1f)
206     {
207       tag = 0;
208       do
209         {
210           tag <<= 7;
211           if (!length)
212             return -1; /* premature eof */
213           c = *buf++; length--;
214           ti->nhdr++;
215           tag |= c & 0x7f;
216         }
217       while (c & 0x80);
218     }
219   ti->tag = tag;
220
221   /* Get the length */
222   if (!length)
223     return -1; /* prematureeof */
224   c = *buf++; length--;
225   ti->nhdr++;
226
227   if ( !(c & 0x80) )
228     ti->length = c;
229   else if (c == 0x80)
230     ti->ndef = 1;
231   else if (c == 0xff)
232     return -1; /* forbidden length value */
233   else
234     {
235       unsigned long len = 0;
236       int count = c & 0x7f;
237
238       for (; count; count--)
239         {
240           len <<= 8;
241           if (!length)
242             return -1; /* premature_eof */
243           c = *buf++; length--;
244           ti->nhdr++;
245           len |= c & 0xff;
246         }
247       ti->length = len;
248     }
249   
250   if (ti->class == UNIVERSAL && !ti->tag)
251     ti->length = 0;
252
253   if (ti->length > length)
254     return -1; /* data larger than buffer. */
255   
256   *buffer = buf;
257   *size = length;
258   return 0;
259 }
260
261
262 /* Given an ASN.1 chunk of a structure like:
263
264      24 NDEF:       OCTET STRING  -- This is not passed to us
265      04    1:         OCTET STRING  -- INPUT point s to here
266             :           30
267      04    1:         OCTET STRING
268             :           80
269           [...]
270      04    2:         OCTET STRING
271             :           00 00
272             :         } -- This denotes a Null tag and are the last 
273                         -- two bytes in INPUT.
274    
275    Create a new buffer with the content of that octet string.  INPUT
276    is the orginal buffer with a length as stored at LENGTH.  Returns
277    NULL on error or a new malloced buffer with the length of this new
278    buffer stored at LENGTH and the number of bytes parsed from input
279    are added to the value stored at INPUT_CONSUMED.  INPUT_CONSUMED is
280    allowed to be passed as NULL if the caller is not interested in
281    this value. */
282 static unsigned char *
283 cram_octet_string (const unsigned char *input, size_t *length,
284                    size_t *input_consumed)
285 {
286   const unsigned char *s = input;
287   size_t n = *length;
288   unsigned char *output, *d;
289   struct tag_info ti;
290
291   /* Allocate output buf.  We know that it won't be longer than the
292      input buffer. */
293   d = output = gcry_malloc (n);
294   if (!output)
295     goto bailout;
296
297   for (;;)
298     {
299       if (parse_tag (&s, &n, &ti))
300         goto bailout;
301       if (ti.class == UNIVERSAL && ti.tag == TAG_OCTET_STRING 
302           && !ti.ndef && !ti.is_constructed)
303         {
304           memcpy (d, s, ti.length);
305           s += ti.length;
306           d += ti.length;
307           n -= ti.length;
308         }
309       else if (ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed)
310         break; /* Ready */ 
311       else
312         goto bailout;
313     }
314
315
316   *length = d - output;
317   if (input_consumed)
318     *input_consumed += s - input;
319   return output;
320
321  bailout:
322   if (input_consumed)
323     *input_consumed += s - input;
324   gcry_free (output);
325   return NULL;
326 }
327
328
329
330 static int 
331 string_to_key (int id, char *salt, size_t saltlen, int iter, const char *pw,
332                int req_keylen, unsigned char *keybuf)
333 {
334   int rc, i, j;
335   gcry_md_hd_t md;
336   gcry_mpi_t num_b1 = NULL;
337   int pwlen;
338   unsigned char hash[20], buf_b[64], buf_i[128], *p;
339   size_t cur_keylen;
340   size_t n;
341
342   cur_keylen = 0;
343   pwlen = strlen (pw);
344   if (pwlen > 63/2)
345     {
346       log_error ("password too long\n");
347       return -1;
348     }
349
350   if (saltlen < 8)
351     {
352       log_error ("salt too short\n");
353       return -1;
354     }
355   
356   /* Store salt and password in BUF_I */
357   p = buf_i;
358   for(i=0; i < 64; i++)
359     *p++ = salt [i%saltlen];
360   for(i=j=0; i < 64; i += 2)
361     {
362       *p++ = 0;
363       *p++ = pw[j];
364       if (++j > pwlen) /* Note, that we include the trailing zero */
365         j = 0;
366     }
367
368   for (;;)
369     {
370       rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
371       if (rc)
372         {
373           log_error ( "gcry_md_open failed: %s\n", gpg_strerror (rc));
374           return rc;
375         }
376       for(i=0; i < 64; i++)
377         gcry_md_putc (md, id);
378       gcry_md_write (md, buf_i, 128);
379       memcpy (hash, gcry_md_read (md, 0), 20);
380       gcry_md_close (md);
381       for (i=1; i < iter; i++)
382         gcry_md_hash_buffer (GCRY_MD_SHA1, hash, hash, 20);
383
384       for (i=0; i < 20 && cur_keylen < req_keylen; i++)
385         keybuf[cur_keylen++] = hash[i];
386       if (cur_keylen == req_keylen)
387         {
388           gcry_mpi_release (num_b1);
389           return 0; /* ready */
390         }
391       
392       /* need more bytes. */
393       for(i=0; i < 64; i++)
394         buf_b[i] = hash[i % 20];
395       rc = gcry_mpi_scan (&num_b1, GCRYMPI_FMT_USG, buf_b, 64, &n);
396       if (rc)
397         {
398           log_error ( "gcry_mpi_scan failed: %s\n", gpg_strerror (rc));
399           return -1;
400         }
401       gcry_mpi_add_ui (num_b1, num_b1, 1);
402       for (i=0; i < 128; i += 64)
403         {
404           gcry_mpi_t num_ij;
405
406           rc = gcry_mpi_scan (&num_ij, GCRYMPI_FMT_USG, buf_i + i, 64, &n);
407           if (rc)
408             {
409               log_error ( "gcry_mpi_scan failed: %s\n",
410                        gpg_strerror (rc));
411               return -1;
412             }
413           gcry_mpi_add (num_ij, num_ij, num_b1);
414           gcry_mpi_clear_highbit (num_ij, 64*8);
415           rc = gcry_mpi_print (GCRYMPI_FMT_USG, buf_i + i, 64, &n, num_ij);
416           if (rc)
417             {
418               log_error ( "gcry_mpi_print failed: %s\n",
419                           gpg_strerror (rc));
420               return -1;
421             }
422           gcry_mpi_release (num_ij);
423         }
424     }
425 }
426
427
428 static int 
429 set_key_iv (gcry_cipher_hd_t chd, char *salt, size_t saltlen, int iter,
430             const char *pw, int keybytes)
431 {
432   unsigned char keybuf[24];
433   int rc;
434
435   assert (keybytes == 5 || keybytes == 24);
436   if (string_to_key (1, salt, saltlen, iter, pw, keybytes, keybuf))
437     return -1;
438   rc = gcry_cipher_setkey (chd, keybuf, keybytes);
439   if (rc)
440     {
441       log_error ( "gcry_cipher_setkey failed: %s\n", gpg_strerror (rc));
442       return -1;
443     }
444
445   if (string_to_key (2, salt, saltlen, iter, pw, 8, keybuf))
446     return -1;
447   rc = gcry_cipher_setiv (chd, keybuf, 8);
448   if (rc)
449     {
450       log_error ("gcry_cipher_setiv failed: %s\n", gpg_strerror (rc));
451       return -1;
452     }
453   return 0;
454 }
455
456
457 static void
458 crypt_block (unsigned char *buffer, size_t length, char *salt, size_t saltlen,
459              int iter, const char *pw, int cipher_algo, int encrypt)
460 {
461   gcry_cipher_hd_t chd;
462   int rc;
463
464   rc = gcry_cipher_open (&chd, cipher_algo, GCRY_CIPHER_MODE_CBC, 0); 
465   if (rc)
466     {
467       log_error ( "gcry_cipher_open failed: %s\n", gpg_strerror(rc));
468       wipememory (buffer, length);
469       return;
470     }
471   if (set_key_iv (chd, salt, saltlen, iter, pw,
472                   cipher_algo == GCRY_CIPHER_RFC2268_40? 5:24))
473     {
474       wipememory (buffer, length);
475       goto leave;
476     }
477
478   rc = encrypt? gcry_cipher_encrypt (chd, buffer, length, NULL, 0)
479               : gcry_cipher_decrypt (chd, buffer, length, NULL, 0);
480
481   if (rc)
482     {
483       wipememory (buffer, length);
484       log_error ( "en/de-crytion failed: %s\n", gpg_strerror (rc));
485       goto leave;
486     }
487
488  leave:
489   gcry_cipher_close (chd);
490 }
491   
492
493 /* Decrypt a block of data and try several encodings of the key.
494    CIPHERTEXT is the encrypted data of size LENGTH bytes; PLAINTEXT is
495    a buffer of the same size to receive the decryption result. SALT,
496    SALTLEN, ITER and PW are the information required for decryption
497    and CIPHER_ALGO is the algorithm id to use.  CHECK_FNC is a
498    function called with the plaintext and used to check whether the
499    decryption succeeded; i.e. that a correct passphrase has been
500    given.  That function shall return true if the decryption has likely
501    succeeded. */
502 static void
503 decrypt_block (const void *ciphertext, unsigned char *plaintext, size_t length,
504                char *salt, size_t saltlen,
505                int iter, const char *pw, int cipher_algo,
506                int (*check_fnc) (const void *, size_t))
507 {
508   static const char const *charsets[] = {
509     "",   /* No conversion - use the UTF-8 passphrase direct.  */
510     "ISO-8859-1",
511     "ISO-8859-15",
512     "ISO-8859-2",
513     "ISO-8859-3",
514     "ISO-8859-4",
515     "ISO-8859-5",
516     "ISO-8859-6",
517     "ISO-8859-7",
518     "ISO-8859-8",
519     "ISO-8859-9",
520     "KOI8-R",
521     "IBM437",
522     "IBM850",
523     "EUC-JP",
524     "BIG5",
525     NULL
526   };
527   int charsetidx = 0;
528   char *convertedpw = NULL;   /* Malloced and converted password or NULL.  */
529   size_t convertedpwsize = 0; /* Allocated length.  */
530
531   for (charsetidx=0; charsets[charsetidx]; charsetidx++)
532     {
533       if (*charsets[charsetidx])
534         {
535           iconv_t cd;
536           const char *inptr;
537           char *outptr;
538           size_t inbytes, outbytes;
539
540           if (!convertedpw)
541             {
542               /* We assume one byte encodings.  Thus we can allocate
543                  the buffer of the same size as the original
544                  passphrase; the result will actually be shorter
545                  then.  */
546               convertedpwsize = strlen (pw) + 1;
547               convertedpw = gcry_malloc_secure (convertedpwsize);
548               if (!convertedpw)
549                 {
550                   log_info ("out of secure memory while"
551                             " converting passphrase\n");
552                   break; /* Give up.  */
553                 }
554             }
555
556           cd = iconv_open (charsets[charsetidx], "utf-8");
557           if (cd == (iconv_t)(-1))
558             continue;
559
560           inptr = pw;
561           inbytes = strlen (pw);
562           outptr = convertedpw;
563           outbytes = convertedpwsize - 1;
564           if ( iconv (cd, (ICONV_CONST char **)&inptr, &inbytes,
565                       &outptr, &outbytes) == (size_t)-1) 
566             {
567               iconv_close (cd);
568               continue;
569             }
570           *outptr = 0;
571           iconv_close (cd);
572           log_info ("decryption failed; trying charset `%s'\n",
573                     charsets[charsetidx]);
574         }
575       memcpy (plaintext, ciphertext, length);
576       crypt_block (plaintext, length, salt, saltlen, iter,
577                    convertedpw? convertedpw:pw, cipher_algo, 0);
578       if (check_fnc (plaintext, length))
579         break; /* Decryption succeeded. */
580     }
581   gcry_free (convertedpw);
582 }
583
584
585 /* Return true if the decryption of an bag_encrypted_data object has
586    likely succeeded.  */
587 static int
588 bag_decrypted_data_p (const void *plaintext, size_t length)
589 {
590   struct tag_info ti;
591   const unsigned char *p = plaintext;
592   size_t n = length;
593
594   /*   { */
595   /* #  warning debug code is enabled */
596   /*     FILE *fp = fopen ("tmp-rc2-plain.der", "wb"); */
597   /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
598   /*       exit (2); */
599   /*     fclose (fp); */
600   /*   } */
601   
602   if (parse_tag (&p, &n, &ti))
603     return 0;
604   if (ti.class || ti.tag != TAG_SEQUENCE)
605     return 0;
606   if (parse_tag (&p, &n, &ti))
607     return 0;
608
609   return 1; 
610 }
611
612 /* Note: If R_RESULT is passed as NULL, a key object as already be
613    processed and thus we need to skip it here. */
614 static int
615 parse_bag_encrypted_data (const unsigned char *buffer, size_t length,
616                           int startoffset, size_t *r_consumed, const char *pw,
617                           void (*certcb)(void*, const unsigned char*, size_t),
618                           void *certcbarg, gcry_mpi_t **r_result)
619 {
620   struct tag_info ti;
621   const unsigned char *p = buffer;
622   const unsigned char *p_start = buffer;
623   size_t n = length;
624   const char *where;
625   char salt[20];
626   size_t saltlen;
627   unsigned int iter;
628   unsigned char *plain = NULL;
629   int bad_pass = 0;
630   unsigned char *cram_buffer = NULL;
631   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
632   int is_3des = 0;
633   gcry_mpi_t *result = NULL;
634   int result_count;
635
636   if (r_result)
637     *r_result = NULL;
638   where = "start";
639   if (parse_tag (&p, &n, &ti))
640     goto bailout;
641   if (ti.class != CONTEXT || ti.tag)
642     goto bailout;
643   if (parse_tag (&p, &n, &ti))
644     goto bailout;
645   if (ti.tag != TAG_SEQUENCE)
646     goto bailout;
647
648   where = "bag.encryptedData.version";
649   if (parse_tag (&p, &n, &ti))
650     goto bailout;
651   if (ti.tag != TAG_INTEGER || ti.length != 1 || *p != 0)
652     goto bailout;
653   p++; n--;
654   if (parse_tag (&p, &n, &ti))
655     goto bailout;
656   if (ti.tag != TAG_SEQUENCE)
657     goto bailout;
658
659   where = "bag.encryptedData.data";
660   if (parse_tag (&p, &n, &ti))
661     goto bailout;
662   if (ti.tag != TAG_OBJECT_ID || ti.length != DIM(oid_data)
663       || memcmp (p, oid_data, DIM(oid_data)))
664     goto bailout;
665   p += DIM(oid_data);
666   n -= DIM(oid_data);
667
668   where = "bag.encryptedData.keyinfo";
669   if (parse_tag (&p, &n, &ti))
670     goto bailout;
671   if (ti.class || ti.tag != TAG_SEQUENCE)
672     goto bailout;
673   if (parse_tag (&p, &n, &ti))
674     goto bailout;
675   if (!ti.class && ti.tag == TAG_OBJECT_ID 
676       && ti.length == DIM(oid_pbeWithSHAAnd40BitRC2_CBC)
677       && !memcmp (p, oid_pbeWithSHAAnd40BitRC2_CBC,
678                   DIM(oid_pbeWithSHAAnd40BitRC2_CBC)))
679     {
680       p += DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
681       n -= DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
682     }
683   else if (!ti.class && ti.tag == TAG_OBJECT_ID 
684       && ti.length == DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
685       && !memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
686                   DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
687     {
688       p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
689       n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
690       is_3des = 1;
691     }
692   else
693     goto bailout;
694
695   where = "rc2or3des-params";
696   if (parse_tag (&p, &n, &ti))
697     goto bailout;
698   if (ti.class || ti.tag != TAG_SEQUENCE)
699     goto bailout;
700   if (parse_tag (&p, &n, &ti))
701     goto bailout;
702   if (ti.class || ti.tag != TAG_OCTET_STRING
703       || ti.length < 8 || ti.length > 20 )
704     goto bailout;
705   saltlen = ti.length;
706   memcpy (salt, p, saltlen);
707   p += saltlen;
708   n -= saltlen;
709   if (parse_tag (&p, &n, &ti))
710     goto bailout;
711   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
712     goto bailout;
713   for (iter=0; ti.length; ti.length--)
714     {
715       iter <<= 8;
716       iter |= (*p++) & 0xff; 
717       n--;
718     }
719   
720   where = "rc2or3des-ciphertext";
721   if (parse_tag (&p, &n, &ti))
722     goto bailout;
723
724   consumed = p - p_start;
725   if (ti.class == CONTEXT && ti.tag == 0 && ti.is_constructed && ti.ndef)
726     {
727       /* Mozilla exported certs now come with single byte chunks of
728          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
729       where = "cram-rc2or3des-ciphertext";
730       cram_buffer = cram_octet_string ( p, &n, &consumed);
731       if (!cram_buffer)
732         goto bailout;
733       p = p_start = cram_buffer;
734       if (r_consumed)
735         *r_consumed = consumed;
736       r_consumed = NULL; /* Ugly hack to not update that value any further. */
737       ti.length = n;
738     }
739   else if (ti.class == CONTEXT && ti.tag == 0 && ti.length )
740     ;
741   else
742     goto bailout;
743   
744   log_info ("%lu bytes of %s encrypted text\n",ti.length,is_3des?"3DES":"RC2");
745
746   plain = gcry_malloc_secure (ti.length);
747   if (!plain)
748     {
749       log_error ("error allocating decryption buffer\n");
750       goto bailout;
751     }
752   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
753                  is_3des? GCRY_CIPHER_3DES : GCRY_CIPHER_RFC2268_40, 
754                  bag_decrypted_data_p);
755   n = ti.length;
756   startoffset = 0;
757   p_start = p = plain;
758
759   where = "outer.outer.seq";
760   if (parse_tag (&p, &n, &ti))
761     {
762       bad_pass = 1;
763       goto bailout;
764     }
765   if (ti.class || ti.tag != TAG_SEQUENCE)
766     {
767       bad_pass = 1;
768       goto bailout;
769     }
770
771   if (parse_tag (&p, &n, &ti))
772     {
773       bad_pass = 1;
774       goto bailout;
775     }
776
777   /* Loop over all certificates inside the bag. */
778   while (n)
779     {
780       int iscrlbag = 0;
781       int iskeybag = 0;
782
783       where = "certbag.nextcert";
784       if (ti.class || ti.tag != TAG_SEQUENCE)
785         goto bailout;
786
787       where = "certbag.objectidentifier";
788       if (parse_tag (&p, &n, &ti))
789         goto bailout;
790       if (ti.class || ti.tag != TAG_OBJECT_ID)
791         goto bailout;
792       if ( ti.length == DIM(oid_pkcs_12_CertBag)
793            && !memcmp (p, oid_pkcs_12_CertBag, DIM(oid_pkcs_12_CertBag)))
794         {
795           p += DIM(oid_pkcs_12_CertBag);
796           n -= DIM(oid_pkcs_12_CertBag);
797         }
798       else if ( ti.length == DIM(oid_pkcs_12_CrlBag)
799            && !memcmp (p, oid_pkcs_12_CrlBag, DIM(oid_pkcs_12_CrlBag)))
800         {
801           p += DIM(oid_pkcs_12_CrlBag);
802           n -= DIM(oid_pkcs_12_CrlBag);
803           iscrlbag = 1;
804         }
805       else if ( ti.length == DIM(oid_pkcs_12_keyBag)
806            && !memcmp (p, oid_pkcs_12_keyBag, DIM(oid_pkcs_12_keyBag)))
807         {
808           /* The TrustedMIME plugin for MS Outlook started to create
809              files with just one outer 3DES encrypted container and
810              inside the certificates as well as the key. */
811           p += DIM(oid_pkcs_12_keyBag);
812           n -= DIM(oid_pkcs_12_keyBag);
813           iskeybag = 1;
814         }
815       else
816         goto bailout;
817
818       where = "certbag.before.certheader";
819       if (parse_tag (&p, &n, &ti))
820         goto bailout;
821       if (ti.class != CONTEXT || ti.tag)
822         goto bailout;
823       if (iscrlbag)
824         {
825           log_info ("skipping unsupported crlBag\n");
826           p += ti.length;
827           n -= ti.length;
828         }
829       else if (iskeybag && (result || !r_result))
830         {
831           log_info ("one keyBag already processed; skipping this one\n");
832           p += ti.length;
833           n -= ti.length;
834         }
835       else if (iskeybag)
836         {
837           int len;
838
839           log_info ("processing simple keyBag\n");
840
841           /* Fixme: This code is duplicated from parse_bag_data.  */
842           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
843             goto bailout;
844           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
845               || ti.length != 1 || *p)
846             goto bailout;
847           p++; n--;
848           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
849             goto bailout;
850           len = ti.length;
851           if (parse_tag (&p, &n, &ti))
852             goto bailout;
853           if (len < ti.nhdr)
854             goto bailout;
855           len -= ti.nhdr;
856           if (ti.class || ti.tag != TAG_OBJECT_ID
857               || ti.length != DIM(oid_rsaEncryption)
858               || memcmp (p, oid_rsaEncryption,
859                          DIM(oid_rsaEncryption)))
860             goto bailout;
861           p += DIM (oid_rsaEncryption);
862           n -= DIM (oid_rsaEncryption);
863           if (len < ti.length)
864             goto bailout;
865           len -= ti.length;
866           if (n < len)
867             goto bailout;
868           p += len;
869           n -= len;
870           if ( parse_tag (&p, &n, &ti)
871                || ti.class || ti.tag != TAG_OCTET_STRING)
872             goto bailout;
873           if ( parse_tag (&p, &n, &ti)
874                || ti.class || ti.tag != TAG_SEQUENCE)
875             goto bailout;
876           len = ti.length;
877
878           result = gcry_calloc (10, sizeof *result);
879           if (!result)
880             {
881               log_error ( "error allocating result array\n");
882               goto bailout;
883             }
884           result_count = 0;
885
886           where = "reading.keybag.key-parameters";
887           for (result_count = 0; len && result_count < 9;)
888             {
889               if ( parse_tag (&p, &n, &ti)
890                    || ti.class || ti.tag != TAG_INTEGER)
891                 goto bailout;
892               if (len < ti.nhdr)
893                 goto bailout;
894               len -= ti.nhdr;
895               if (len < ti.length)
896                 goto bailout;
897               len -= ti.length;
898               if (!result_count && ti.length == 1 && !*p)
899                 ; /* ignore the very first one if it is a 0 */
900               else 
901                 {
902                   int rc;
903
904                   rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
905                                       ti.length, NULL);
906                   if (rc)
907                     {
908                       log_error ("error parsing key parameter: %s\n",
909                                  gpg_strerror (rc));
910                       goto bailout;
911                     }
912                   result_count++;
913                 }
914               p += ti.length;
915               n -= ti.length;
916             }
917           if (len)
918             goto bailout;
919         }
920       else
921         {
922           log_info ("processing certBag\n");
923           if (parse_tag (&p, &n, &ti))
924             goto bailout;
925           if (ti.class || ti.tag != TAG_SEQUENCE)
926             goto bailout;
927           if (parse_tag (&p, &n, &ti))
928             goto bailout;
929           if (ti.class || ti.tag != TAG_OBJECT_ID
930               || ti.length != DIM(oid_x509Certificate_for_pkcs_12)
931               || memcmp (p, oid_x509Certificate_for_pkcs_12,
932                          DIM(oid_x509Certificate_for_pkcs_12)))
933             goto bailout;
934           p += DIM(oid_x509Certificate_for_pkcs_12);
935           n -= DIM(oid_x509Certificate_for_pkcs_12);
936           
937           where = "certbag.before.octetstring";
938           if (parse_tag (&p, &n, &ti))
939             goto bailout;
940           if (ti.class != CONTEXT || ti.tag)
941             goto bailout;
942           if (parse_tag (&p, &n, &ti))
943             goto bailout;
944           if (ti.class || ti.tag != TAG_OCTET_STRING || ti.ndef)
945             goto bailout;
946           
947           /* Return the certificate. */
948           if (certcb)
949             certcb (certcbarg, p, ti.length);
950    
951           p += ti.length;
952           n -= ti.length;
953         }
954
955       /* Ugly hack to cope with the padding: Forget about the rest if
956          that is less or equal to the cipher's block length.  We can
957          reasonable assume that all valid data will be longer than
958          just one block. */
959       if (n <= 8)
960         n = 0;  
961
962       /* Skip the optional SET with the pkcs12 cert attributes. */
963       if (n)
964         {
965           where = "bag.attributes";
966           if (parse_tag (&p, &n, &ti))
967             goto bailout;
968           if (!ti.class && ti.tag == TAG_SEQUENCE)
969             ; /* No attributes. */
970           else if (!ti.class && ti.tag == TAG_SET && !ti.ndef)
971             { /* The optional SET. */
972               p += ti.length;
973               n -= ti.length;
974               if (n <= 8)
975                 n = 0;
976               if (n && parse_tag (&p, &n, &ti))
977                 goto bailout;
978             }
979           else
980             goto bailout;
981         }
982     }
983   
984   if (r_consumed)
985     *r_consumed = consumed;
986   gcry_free (plain);
987   gcry_free (cram_buffer);
988   if (r_result)
989     *r_result = result;
990   return 0;
991
992  bailout:
993   if (result)
994     {
995       int i;
996
997       for (i=0; result[i]; i++)
998         gcry_mpi_release (result[i]);
999       gcry_free (result);
1000     }
1001   if (r_consumed)
1002     *r_consumed = consumed;
1003   gcry_free (plain);
1004   gcry_free (cram_buffer);
1005   log_error ("encryptedData error at \"%s\", offset %u\n",
1006              where, (unsigned int)((p - p_start)+startoffset));
1007   if (bad_pass)
1008     {
1009       /* Note, that the following string might be used by other programs
1010          to check for a bad passphrase; it should therefore not be
1011          translated or changed. */
1012       log_error ("possibly bad passphrase given\n");
1013     }
1014   return -1;
1015 }
1016
1017
1018 /* Return true if the decryption of a bag_data object has likely
1019    succeeded.  */
1020 static int
1021 bag_data_p (const void *plaintext, size_t length)
1022 {
1023   struct tag_info ti;
1024   const unsigned char *p = plaintext;
1025   size_t n = length;
1026
1027 /*   { */
1028 /* #  warning debug code is enabled */
1029 /*     FILE *fp = fopen ("tmp-3des-plain-key.der", "wb"); */
1030 /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
1031 /*       exit (2); */
1032 /*     fclose (fp); */
1033 /*   } */
1034
1035   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1036     return 0;
1037   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1038       || ti.length != 1 || *p)
1039     return 0;
1040
1041   return 1; 
1042 }
1043
1044
1045 static gcry_mpi_t *
1046 parse_bag_data (const unsigned char *buffer, size_t length, int startoffset,
1047                 size_t *r_consumed, const char *pw)
1048 {
1049   int rc;
1050   struct tag_info ti;
1051   const unsigned char *p = buffer;
1052   const unsigned char *p_start = buffer;
1053   size_t n = length;
1054   const char *where;
1055   char salt[20];
1056   size_t saltlen;
1057   unsigned int iter;
1058   int len;
1059   unsigned char *plain = NULL;
1060   gcry_mpi_t *result = NULL;
1061   int result_count, i;
1062   unsigned char *cram_buffer = NULL;
1063   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
1064
1065   where = "start";
1066   if (parse_tag (&p, &n, &ti))
1067     goto bailout;
1068   if (ti.class != CONTEXT || ti.tag)
1069     goto bailout;
1070   if (parse_tag (&p, &n, &ti))
1071     goto bailout;
1072   if (ti.class || ti.tag != TAG_OCTET_STRING)
1073     goto bailout;
1074
1075   consumed = p - p_start;
1076   if (ti.is_constructed && ti.ndef)
1077     {
1078       /* Mozilla exported certs now come with single byte chunks of
1079          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
1080       where = "cram-data.outersegs";
1081       cram_buffer = cram_octet_string ( p, &n, &consumed);
1082       if (!cram_buffer)
1083         goto bailout;
1084       p = p_start = cram_buffer;
1085       if (r_consumed)
1086         *r_consumed = consumed;
1087       r_consumed = NULL; /* Ugly hack to not update that value any further. */
1088     }
1089   
1090
1091   where = "data.outerseqs";
1092   if (parse_tag (&p, &n, &ti))
1093     goto bailout;
1094   if (ti.class || ti.tag != TAG_SEQUENCE)
1095     goto bailout;
1096   if (parse_tag (&p, &n, &ti))
1097     goto bailout;
1098   if (ti.class || ti.tag != TAG_SEQUENCE)
1099     goto bailout;
1100
1101   where = "data.objectidentifier";
1102   if (parse_tag (&p, &n, &ti))
1103     goto bailout;
1104   if (ti.class || ti.tag != TAG_OBJECT_ID
1105       || ti.length != DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)
1106       || memcmp (p, oid_pkcs_12_pkcs_8ShroudedKeyBag,
1107                  DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)))
1108     goto bailout;
1109   p += DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1110   n -= DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1111
1112   where = "shrouded,outerseqs";
1113   if (parse_tag (&p, &n, &ti))
1114     goto bailout;
1115   if (ti.class != CONTEXT || ti.tag)
1116     goto bailout;
1117   if (parse_tag (&p, &n, &ti))
1118     goto bailout;
1119   if (ti.class || ti.tag != TAG_SEQUENCE)
1120     goto bailout;
1121   if (parse_tag (&p, &n, &ti))
1122     goto bailout;
1123   if (ti.class || ti.tag != TAG_SEQUENCE)
1124     goto bailout;
1125   if (parse_tag (&p, &n, &ti))
1126     goto bailout;
1127   if (ti.class || ti.tag != TAG_OBJECT_ID
1128       || ti.length != DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
1129       || memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
1130                  DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
1131     goto bailout;
1132   p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1133   n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1134
1135   where = "3des-params";
1136   if (parse_tag (&p, &n, &ti))
1137     goto bailout;
1138   if (ti.class || ti.tag != TAG_SEQUENCE)
1139     goto bailout;
1140   if (parse_tag (&p, &n, &ti))
1141     goto bailout;
1142   if (ti.class || ti.tag != TAG_OCTET_STRING
1143       || ti.length < 8 || ti.length > 20)
1144     goto bailout;
1145   saltlen = ti.length;
1146   memcpy (salt, p, saltlen);
1147   p += saltlen;
1148   n -= saltlen;
1149   if (parse_tag (&p, &n, &ti))
1150     goto bailout;
1151   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
1152     goto bailout;
1153   for (iter=0; ti.length; ti.length--)
1154     {
1155       iter <<= 8;
1156       iter |= (*p++) & 0xff; 
1157       n--;
1158     }
1159   
1160   where = "3des-ciphertext";
1161   if (parse_tag (&p, &n, &ti))
1162     goto bailout;
1163   if (ti.class || ti.tag != TAG_OCTET_STRING || !ti.length )
1164     goto bailout;
1165   
1166   log_info ("%lu bytes of 3DES encrypted text\n", ti.length);
1167   
1168   plain = gcry_malloc_secure (ti.length);
1169   if (!plain)
1170     {
1171       log_error ("error allocating decryption buffer\n");
1172       goto bailout;
1173     }
1174   consumed += p - p_start + ti.length;
1175   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
1176                  GCRY_CIPHER_3DES, 
1177                  bag_data_p);
1178   n = ti.length;
1179   startoffset = 0;
1180   p_start = p = plain;
1181
1182   where = "decrypted-text";
1183   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1184     goto bailout;
1185   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1186       || ti.length != 1 || *p)
1187     goto bailout;
1188   p++; n--;
1189   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1190     goto bailout;
1191   len = ti.length;
1192   if (parse_tag (&p, &n, &ti))
1193     goto bailout;
1194   if (len < ti.nhdr)
1195     goto bailout;
1196   len -= ti.nhdr;
1197   if (ti.class || ti.tag != TAG_OBJECT_ID
1198       || ti.length != DIM(oid_rsaEncryption)
1199       || memcmp (p, oid_rsaEncryption,
1200                  DIM(oid_rsaEncryption)))
1201     goto bailout;
1202   p += DIM (oid_rsaEncryption);
1203   n -= DIM (oid_rsaEncryption);
1204   if (len < ti.length)
1205     goto bailout;
1206   len -= ti.length;
1207   if (n < len)
1208     goto bailout;
1209   p += len;
1210   n -= len;
1211   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_OCTET_STRING)
1212     goto bailout;
1213   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1214     goto bailout;
1215   len = ti.length;
1216
1217   result = gcry_calloc (10, sizeof *result);
1218   if (!result)
1219     {
1220       log_error ( "error allocating result array\n");
1221       goto bailout;
1222     }
1223   result_count = 0;
1224
1225   where = "reading.key-parameters";
1226   for (result_count=0; len && result_count < 9;)
1227     {
1228       if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER)
1229         goto bailout;
1230       if (len < ti.nhdr)
1231         goto bailout;
1232       len -= ti.nhdr;
1233       if (len < ti.length)
1234         goto bailout;
1235       len -= ti.length;
1236       if (!result_count && ti.length == 1 && !*p)
1237         ; /* ignore the very first one if it is a 0 */
1238       else 
1239         {
1240           rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
1241                               ti.length, NULL);
1242           if (rc)
1243             {
1244               log_error ("error parsing key parameter: %s\n",
1245                          gpg_strerror (rc));
1246               goto bailout;
1247             }
1248           result_count++;
1249         }
1250       p += ti.length;
1251       n -= ti.length;
1252     }
1253   if (len)
1254     goto bailout;
1255
1256   gcry_free (cram_buffer);
1257   if (r_consumed)
1258     *r_consumed = consumed;
1259   return result;
1260
1261  bailout:
1262   gcry_free (plain);
1263   if (result)
1264     {
1265       for (i=0; result[i]; i++)
1266         gcry_mpi_release (result[i]);
1267       gcry_free (result);
1268     }
1269   gcry_free (cram_buffer);
1270   log_error ( "data error at \"%s\", offset %u\n",
1271               where, (unsigned int)((p - buffer) + startoffset));
1272   if (r_consumed)
1273     *r_consumed = consumed;
1274   return NULL;
1275 }
1276
1277
1278 /* Parse a PKCS12 object and return an array of MPI representing the
1279    secret key parameters.  This is a very limited implementation in
1280    that it is only able to look for 3DES encoded encryptedData and
1281    tries to extract the first private key object it finds.  In case of
1282    an error NULL is returned. CERTCB and CERRTCBARG are used to pass
1283    X.509 certificates back to the caller. */
1284 gcry_mpi_t *
1285 p12_parse (const unsigned char *buffer, size_t length, const char *pw,
1286            void (*certcb)(void*, const unsigned char*, size_t),
1287            void *certcbarg)
1288 {
1289   struct tag_info ti;
1290   const unsigned char *p = buffer;
1291   const unsigned char *p_start = buffer;
1292   size_t n = length;
1293   const char *where;
1294   int bagseqlength, len;
1295   int bagseqndef, lenndef;
1296   gcry_mpi_t *result = NULL;
1297   unsigned char *cram_buffer = NULL;
1298
1299   where = "pfx";
1300   if (parse_tag (&p, &n, &ti))
1301     goto bailout;
1302   if (ti.tag != TAG_SEQUENCE)
1303     goto bailout;
1304
1305   where = "pfxVersion";
1306   if (parse_tag (&p, &n, &ti))
1307     goto bailout;
1308   if (ti.tag != TAG_INTEGER || ti.length != 1 || *p != 3)
1309     goto bailout;
1310   p++; n--;
1311   
1312   where = "authSave";
1313   if (parse_tag (&p, &n, &ti))
1314     goto bailout;
1315   if (ti.tag != TAG_SEQUENCE)
1316     goto bailout;
1317   if (parse_tag (&p, &n, &ti))
1318     goto bailout;
1319   if (ti.tag != TAG_OBJECT_ID || ti.length != DIM(oid_data)
1320       || memcmp (p, oid_data, DIM(oid_data)))
1321     goto bailout;
1322   p += DIM(oid_data);
1323   n -= DIM(oid_data);
1324
1325   if (parse_tag (&p, &n, &ti))
1326     goto bailout;
1327   if (ti.class != CONTEXT || ti.tag)
1328     goto bailout;
1329   if (parse_tag (&p, &n, &ti))
1330     goto bailout;
1331   if (ti.class != UNIVERSAL || ti.tag != TAG_OCTET_STRING)
1332     goto bailout;
1333
1334   if (ti.is_constructed && ti.ndef)
1335     {
1336       /* Mozilla exported certs now come with single byte chunks of
1337          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
1338       where = "cram-bags";
1339       cram_buffer = cram_octet_string ( p, &n, NULL);
1340       if (!cram_buffer)
1341         goto bailout;
1342       p = p_start = cram_buffer;
1343     }
1344
1345   where = "bags";
1346   if (parse_tag (&p, &n, &ti))
1347     goto bailout;
1348   if (ti.class != UNIVERSAL || ti.tag != TAG_SEQUENCE)
1349     goto bailout;
1350   bagseqndef = ti.ndef;
1351   bagseqlength = ti.length;
1352   while (bagseqlength || bagseqndef)
1353     {
1354 /*       log_debug ( "at offset %u\n", (p - p_start)); */
1355       where = "bag-sequence";
1356       if (parse_tag (&p, &n, &ti))
1357         goto bailout;
1358       if (bagseqndef && ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed)
1359         break; /* Ready */ 
1360       if (ti.class != UNIVERSAL || ti.tag != TAG_SEQUENCE)
1361         goto bailout;
1362
1363       if (!bagseqndef)
1364         {
1365           if (bagseqlength < ti.nhdr)
1366             goto bailout;
1367           bagseqlength -= ti.nhdr;
1368           if (bagseqlength < ti.length)
1369             goto bailout;
1370           bagseqlength -= ti.length;
1371         }
1372       lenndef = ti.ndef;
1373       len = ti.length;
1374
1375       if (parse_tag (&p, &n, &ti))
1376         goto bailout;
1377       if (lenndef)
1378         len = ti.nhdr; 
1379       else
1380         len -= ti.nhdr; 
1381
1382       if (ti.tag == TAG_OBJECT_ID && ti.length == DIM(oid_encryptedData)
1383           && !memcmp (p, oid_encryptedData, DIM(oid_encryptedData)))
1384         {
1385           size_t consumed = 0;
1386
1387           p += DIM(oid_encryptedData);
1388           n -= DIM(oid_encryptedData);
1389           if (!lenndef)
1390             len -= DIM(oid_encryptedData);
1391           where = "bag.encryptedData";
1392           if (parse_bag_encrypted_data (p, n, (p - p_start), &consumed, pw,
1393                                         certcb, certcbarg,
1394                                         result? NULL : &result))
1395             goto bailout;
1396           if (lenndef)
1397             len += consumed;
1398         }
1399       else if (ti.tag == TAG_OBJECT_ID && ti.length == DIM(oid_data)
1400                && !memcmp (p, oid_data, DIM(oid_data)))
1401         {
1402           if (result)
1403             {
1404               log_info ("already got an key object, skipping this one\n");
1405               p += ti.length;
1406               n -= ti.length;
1407             }
1408           else
1409             {
1410               size_t consumed = 0;
1411
1412               p += DIM(oid_data);
1413               n -= DIM(oid_data);
1414               if (!lenndef)
1415                 len -= DIM(oid_data);
1416               result = parse_bag_data (p, n, (p - p_start), &consumed, pw);
1417               if (!result)
1418                 goto bailout;
1419               if (lenndef)
1420                 len += consumed;
1421             }
1422         }
1423       else
1424         {
1425           log_info ("unknown bag type - skipped\n");
1426           p += ti.length;
1427           n -= ti.length;
1428         }
1429
1430       if (len < 0 || len > n)
1431         goto bailout;
1432       p += len;
1433       n -= len;
1434       if (lenndef)
1435         {
1436           /* Need to skip the Null Tag. */
1437           if (parse_tag (&p, &n, &ti))
1438             goto bailout;
1439           if (!(ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed))
1440             goto bailout;
1441         }
1442     }
1443   
1444   gcry_free (cram_buffer);
1445   return result;
1446  bailout:
1447   log_error ("error at \"%s\", offset %u\n",
1448              where, (unsigned int)(p - p_start));
1449   if (result)
1450     {
1451       int i;
1452
1453       for (i=0; result[i]; i++)
1454         gcry_mpi_release (result[i]);
1455       gcry_free (result);
1456     }
1457   gcry_free (cram_buffer);
1458   return NULL;
1459 }
1460
1461
1462 \f
1463 static size_t
1464 compute_tag_length (size_t n)
1465 {     
1466   int needed = 0;
1467
1468   if (n < 128)
1469     needed += 2; /* tag and one length byte */
1470   else if (n < 256)
1471     needed += 3; /* tag, number of length bytes, 1 length byte */
1472   else if (n < 65536)
1473     needed += 4; /* tag, number of length bytes, 2 length bytes */
1474   else
1475     {
1476       log_error ("object too larger to encode\n");
1477       return 0;
1478     }
1479   return needed;
1480 }
1481
1482 static unsigned char *
1483 store_tag_length (unsigned char *p, int tag, size_t n)
1484 {     
1485   if (tag == TAG_SEQUENCE)
1486     tag |= 0x20; /* constructed */
1487
1488   *p++ = tag;
1489   if (n < 128)
1490     *p++ = n;
1491   else if (n < 256)
1492     {
1493       *p++ = 0x81;
1494       *p++ = n;
1495     }
1496   else if (n < 65536)
1497     {
1498       *p++ = 0x82;
1499       *p++ = n >> 8;
1500       *p++ = n;
1501     }
1502
1503   return p;
1504 }
1505
1506
1507 /* Create the final PKCS-12 object from the sequences contained in
1508    SEQLIST.  PW is the password. That array is terminated with an NULL
1509    object. */
1510 static unsigned char *
1511 create_final (struct buffer_s *sequences, const char *pw, size_t *r_length)
1512 {
1513   int i;
1514   size_t needed = 0;
1515   size_t len[8], n;
1516   unsigned char *macstart;
1517   size_t maclen;
1518   unsigned char *result, *p;
1519   size_t resultlen;
1520   char salt[8];
1521   unsigned char keybuf[20];
1522   gcry_md_hd_t md;
1523   int rc;
1524   int with_mac = 1;
1525
1526
1527   /* 9 steps to create the pkcs#12 Krampf. */
1528
1529   /* 8. The MAC. */
1530   /* We add this at step 0. */
1531
1532   /* 7. All the buffers. */
1533   for (i=0; sequences[i].buffer; i++)
1534     needed += sequences[i].length;
1535
1536   /* 6. This goes into a sequences. */
1537   len[6] = needed;
1538   n = compute_tag_length (needed);
1539   needed += n;
1540
1541   /* 5. Encapsulate all in an octet string. */
1542   len[5] = needed;
1543   n = compute_tag_length (needed);
1544   needed += n;
1545
1546   /* 4. And tag it with [0]. */
1547   len[4] = needed;
1548   n = compute_tag_length (needed);
1549   needed += n;
1550
1551   /* 3. Prepend an data OID. */
1552   needed += 2 + DIM (oid_data);
1553
1554   /* 2. Put all into a sequences. */
1555   len[2] = needed;
1556   n = compute_tag_length (needed);
1557   needed += n;
1558
1559   /* 1. Prepend the version integer 3. */
1560   needed += 3;
1561
1562   /* 0. And the final outer sequence. */
1563   if (with_mac)
1564     needed += DIM (data_mactemplate);
1565   len[0] = needed;
1566   n = compute_tag_length (needed);
1567   needed += n;
1568
1569   /* Allocate a buffer. */
1570   result = gcry_malloc (needed);
1571   if (!result)
1572     {
1573       log_error ("error allocating buffer\n");
1574       return NULL;
1575     }
1576   p = result;
1577
1578   /* 0. Store the very outer sequence. */
1579   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1580
1581   /* 1. Store the version integer 3. */
1582   *p++ = TAG_INTEGER;
1583   *p++ = 1; 
1584   *p++ = 3;
1585
1586   /* 2. Store another sequence. */
1587   p = store_tag_length (p, TAG_SEQUENCE, len[2]);
1588
1589   /* 3. Store the data OID. */
1590   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
1591   memcpy (p, oid_data, DIM (oid_data)); 
1592   p += DIM (oid_data); 
1593
1594   /* 4. Next comes a context tag. */
1595   p = store_tag_length (p, 0xa0, len[4]);
1596
1597   /* 5. And an octet string. */
1598   p = store_tag_length (p, TAG_OCTET_STRING, len[5]);
1599
1600   /* 6. And the inner sequence. */
1601   macstart = p;
1602   p = store_tag_length (p, TAG_SEQUENCE, len[6]);
1603
1604   /* 7. Append all the buffers. */
1605   for (i=0; sequences[i].buffer; i++)
1606     {
1607       memcpy (p, sequences[i].buffer, sequences[i].length);
1608       p += sequences[i].length;
1609     }
1610
1611   if (with_mac)
1612     {
1613       /* Intermezzo to compute the MAC. */
1614       maclen = p - macstart;
1615       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
1616       if (string_to_key (3, salt, 8, 2048, pw, 20, keybuf))
1617         {
1618           gcry_free (result);
1619           return NULL;
1620         }
1621       rc = gcry_md_open (&md, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
1622       if (rc)
1623         {
1624           log_error ("gcry_md_open failed: %s\n", gpg_strerror (rc));
1625           gcry_free (result);
1626           return NULL;
1627         }
1628       rc = gcry_md_setkey (md, keybuf, 20);
1629       if (rc)
1630         {
1631           log_error ("gcry_md_setkey failed: %s\n", gpg_strerror (rc));
1632           gcry_md_close (md);
1633           gcry_free (result);
1634           return NULL;
1635         }
1636       gcry_md_write (md, macstart, maclen);
1637
1638       /* 8. Append the MAC template and fix it up. */
1639       memcpy (p, data_mactemplate, DIM (data_mactemplate));
1640       memcpy (p + DATA_MACTEMPLATE_SALT_OFF, salt, 8);
1641       memcpy (p + DATA_MACTEMPLATE_MAC_OFF, gcry_md_read (md, 0), 20);
1642       p += DIM (data_mactemplate);
1643       gcry_md_close (md);
1644     }
1645
1646   /* Ready. */
1647   resultlen = p - result;
1648   if (needed != resultlen)
1649     log_debug ("length mismatch: %lu, %lu\n",
1650                (unsigned long)needed, (unsigned long)resultlen);
1651
1652   *r_length = resultlen;
1653   return result;
1654 }
1655
1656
1657 /* Build a DER encoded SEQUENCE with the key:
1658
1659    SEQUENCE {
1660      INTEGER 0
1661      SEQUENCE {
1662        OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
1663        NULL
1664        }
1665      OCTET STRING, encapsulates {
1666        SEQUENCE {
1667          INTEGER 0
1668          INTEGER
1669          INTEGER 
1670          INTEGER
1671          INTEGER
1672          INTEGER
1673          INTEGER
1674          INTEGER
1675          INTEGER
1676          }
1677        }
1678      }
1679 */  
1680   
1681 static unsigned char * 
1682 build_key_sequence (gcry_mpi_t *kparms, size_t *r_length)
1683 {
1684   int rc, i;
1685   size_t needed, n;
1686   unsigned char *plain, *p;
1687   size_t plainlen;
1688   size_t outseqlen, oidseqlen, octstrlen, inseqlen;
1689
1690   needed = 3; /* The version(?) integer of value 0. */
1691   for (i=0; kparms[i]; i++)
1692     {
1693       n = 0;
1694       rc = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, kparms[i]);
1695       if (rc)
1696         {
1697           log_error ("error formatting parameter: %s\n", gpg_strerror (rc));
1698           return NULL;
1699         }
1700       needed += n;
1701       n = compute_tag_length (n);
1702       if (!n)
1703         return NULL;
1704       needed += n;
1705     }
1706   if (i != 8)
1707     {
1708       log_error ("invalid paramters for p12_build\n");
1709       return NULL;
1710     }
1711   /* Now this all goes into a sequence. */
1712   inseqlen = needed;
1713   n = compute_tag_length (needed);
1714   if (!n)
1715     return NULL;
1716   needed += n;
1717   /* Encapsulate all into an octet string. */
1718   octstrlen = needed;
1719   n = compute_tag_length (needed);
1720   if (!n)
1721     return NULL;
1722   needed += n;
1723   /* Prepend the object identifier sequence. */
1724   oidseqlen = 2 + DIM (oid_rsaEncryption) + 2;
1725   needed += 2 + oidseqlen;
1726   /* The version number. */
1727   needed += 3;
1728   /* And finally put the whole thing into a sequence. */
1729   outseqlen = needed;
1730   n = compute_tag_length (needed);
1731   if (!n)
1732     return NULL;
1733   needed += n;
1734   
1735   /* allocate 8 extra bytes for padding */
1736   plain = gcry_malloc_secure (needed+8);
1737   if (!plain)
1738     {
1739       log_error ("error allocating encryption buffer\n");
1740       return NULL;
1741     }
1742   
1743   /* And now fill the plaintext buffer. */
1744   p = plain;
1745   p = store_tag_length (p, TAG_SEQUENCE, outseqlen);
1746   /* Store version. */
1747   *p++ = TAG_INTEGER;
1748   *p++ = 1;
1749   *p++ = 0;
1750   /* Store object identifier sequence. */
1751   p = store_tag_length (p, TAG_SEQUENCE, oidseqlen);
1752   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_rsaEncryption));
1753   memcpy (p, oid_rsaEncryption, DIM (oid_rsaEncryption)); 
1754   p += DIM (oid_rsaEncryption); 
1755   *p++ = TAG_NULL;
1756   *p++ = 0;
1757   /* Start with the octet string. */
1758   p = store_tag_length (p, TAG_OCTET_STRING, octstrlen);
1759   p = store_tag_length (p, TAG_SEQUENCE, inseqlen);
1760   /* Store the key parameters. */
1761   *p++ = TAG_INTEGER;
1762   *p++ = 1;
1763   *p++ = 0;
1764   for (i=0; kparms[i]; i++)
1765     {
1766       n = 0;
1767       rc = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, kparms[i]);
1768       if (rc)
1769         {
1770           log_error ("oops: error formatting parameter: %s\n",
1771                      gpg_strerror (rc));
1772           gcry_free (plain);
1773           return NULL;
1774         }
1775       p = store_tag_length (p, TAG_INTEGER, n);
1776       
1777       n = plain + needed - p;
1778       rc = gcry_mpi_print (GCRYMPI_FMT_STD, p, n, &n, kparms[i]);
1779       if (rc)
1780         {
1781           log_error ("oops: error storing parameter: %s\n",
1782                      gpg_strerror (rc));
1783           gcry_free (plain);
1784           return NULL;
1785         }
1786       p += n;
1787     }
1788
1789   plainlen = p - plain;
1790   assert (needed == plainlen);
1791   /* Append some pad characters; we already allocated extra space. */
1792   n = 8 - plainlen % 8;
1793   for (i=0; i < n; i++, plainlen++)
1794     *p++ = n;
1795
1796   *r_length = plainlen;
1797   return plain;
1798 }
1799
1800
1801
1802 static unsigned char *
1803 build_key_bag (unsigned char *buffer, size_t buflen, char *salt,
1804                const unsigned char *sha1hash, const char *keyidstr,
1805                size_t *r_length)
1806 {
1807   size_t len[11], needed;
1808   unsigned char *p, *keybag;
1809   size_t keybaglen;
1810
1811   /* Walk 11 steps down to collect the info: */
1812
1813   /* 10. The data goes into an octet string. */
1814   needed = compute_tag_length (buflen);
1815   needed += buflen;
1816
1817   /* 9. Prepend the algorithm identifier. */
1818   needed += DIM (data_3desiter2048);
1819
1820   /* 8. Put a sequence around. */
1821   len[8] = needed;
1822   needed += compute_tag_length (needed);
1823
1824   /* 7. Prepend a [0] tag. */
1825   len[7] = needed;
1826   needed += compute_tag_length (needed);
1827
1828   /* 6b. The attributes which are appended at the end. */
1829   if (sha1hash)
1830     needed += DIM (data_attrtemplate) + 20;
1831
1832   /* 6. Prepend the shroudedKeyBag OID. */
1833   needed += 2 + DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag);
1834
1835   /* 5+4. Put all into two sequences. */
1836   len[5] = needed;
1837   needed += compute_tag_length ( needed);
1838   len[4] = needed;
1839   needed += compute_tag_length (needed);
1840
1841   /* 3. This all goes into an octet string. */
1842   len[3] = needed;
1843   needed += compute_tag_length (needed);
1844
1845   /* 2. Prepend another [0] tag. */
1846   len[2] = needed;
1847   needed += compute_tag_length (needed);
1848
1849   /* 1. Prepend the data OID. */
1850   needed += 2 + DIM (oid_data);
1851
1852   /* 0. Prepend another sequence. */
1853   len[0] = needed;
1854   needed += compute_tag_length (needed);
1855
1856   /* Now that we have all length information, allocate a buffer. */
1857   p = keybag = gcry_malloc (needed);
1858   if (!keybag)
1859     {
1860       log_error ("error allocating buffer\n");
1861       return NULL;
1862     }
1863
1864   /* Walk 11 steps up to store the data. */
1865
1866   /* 0. Store the first sequence. */
1867   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1868
1869   /* 1. Store the data OID. */
1870   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
1871   memcpy (p, oid_data, DIM (oid_data)); 
1872   p += DIM (oid_data); 
1873
1874   /* 2. Store a [0] tag. */
1875   p = store_tag_length (p, 0xa0, len[2]);
1876
1877   /* 3. And an octet string. */
1878   p = store_tag_length (p, TAG_OCTET_STRING, len[3]);
1879
1880   /* 4+5. Two sequences. */
1881   p = store_tag_length (p, TAG_SEQUENCE, len[4]);
1882   p = store_tag_length (p, TAG_SEQUENCE, len[5]);
1883
1884   /* 6. Store the shroudedKeyBag OID. */
1885   p = store_tag_length (p, TAG_OBJECT_ID,
1886                         DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag));
1887   memcpy (p, oid_pkcs_12_pkcs_8ShroudedKeyBag,
1888           DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag)); 
1889   p += DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag); 
1890
1891   /* 7. Store a [0] tag. */
1892   p = store_tag_length (p, 0xa0, len[7]);
1893
1894   /* 8. Store a sequence. */
1895   p = store_tag_length (p, TAG_SEQUENCE, len[8]);
1896
1897   /* 9. Now for the pre-encoded algorithm identifier and the salt. */
1898   memcpy (p, data_3desiter2048, DIM (data_3desiter2048));
1899   memcpy (p + DATA_3DESITER2048_SALT_OFF, salt, 8);
1900   p += DIM (data_3desiter2048);
1901
1902   /* 10. And the octet string with the encrypted data. */
1903   p = store_tag_length (p, TAG_OCTET_STRING, buflen);
1904   memcpy (p, buffer, buflen);
1905   p += buflen;
1906
1907   /* Append the attributes whose length we calculated at step 2b. */
1908   if (sha1hash)
1909     {
1910       int i;
1911
1912       memcpy (p, data_attrtemplate, DIM (data_attrtemplate));
1913       for (i=0; i < 8; i++)
1914         p[DATA_ATTRTEMPLATE_KEYID_OFF+2*i+1] = keyidstr[i];
1915       p += DIM (data_attrtemplate);
1916       memcpy (p, sha1hash, 20);
1917       p += 20;
1918     }
1919
1920
1921   keybaglen = p - keybag;
1922   if (needed != keybaglen)
1923     log_debug ("length mismatch: %lu, %lu\n",
1924                (unsigned long)needed, (unsigned long)keybaglen);
1925   
1926   *r_length = keybaglen;
1927   return keybag;
1928 }
1929
1930
1931 static unsigned char *
1932 build_cert_bag (unsigned char *buffer, size_t buflen, char *salt,
1933                 size_t *r_length)
1934 {
1935   size_t len[9], needed;
1936   unsigned char *p, *certbag;
1937   size_t certbaglen;
1938
1939   /* Walk 9 steps down to collect the info: */
1940
1941   /* 8. The data goes into an octet string. */
1942   needed = compute_tag_length (buflen);
1943   needed += buflen;
1944
1945   /* 7. The algorithm identifier. */
1946   needed += DIM (data_rc2iter2048);
1947
1948   /* 6. The data OID. */
1949   needed += 2 + DIM (oid_data);
1950
1951   /* 5. A sequence. */
1952   len[5] = needed;
1953   needed += compute_tag_length ( needed);
1954
1955   /* 4. An integer. */
1956   needed += 3;
1957
1958   /* 3. A sequence. */
1959   len[3] = needed;
1960   needed += compute_tag_length (needed);
1961
1962   /* 2.  A [0] tag. */
1963   len[2] = needed;
1964   needed += compute_tag_length (needed);
1965
1966   /* 1. The encryptedData OID. */
1967   needed += 2 + DIM (oid_encryptedData);
1968
1969   /* 0. The first sequence. */
1970   len[0] = needed;
1971   needed += compute_tag_length (needed);
1972
1973   /* Now that we have all length information, allocate a buffer. */
1974   p = certbag = gcry_malloc (needed);
1975   if (!certbag)
1976     {
1977       log_error ("error allocating buffer\n");
1978       return NULL;
1979     }
1980
1981   /* Walk 9 steps up to store the data. */
1982
1983   /* 0. Store the first sequence. */
1984   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1985
1986   /* 1. Store the encryptedData OID. */
1987   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_encryptedData));
1988   memcpy (p, oid_encryptedData, DIM (oid_encryptedData)); 
1989   p += DIM (oid_encryptedData); 
1990
1991   /* 2. Store a [0] tag. */
1992   p = store_tag_length (p, 0xa0, len[2]);
1993
1994   /* 3. Store a sequence. */
1995   p = store_tag_length (p, TAG_SEQUENCE, len[3]);
1996
1997   /* 4. Store the integer 0. */
1998   *p++ = TAG_INTEGER;
1999   *p++ = 1; 
2000   *p++ = 0;
2001
2002   /* 5. Store a sequence. */
2003   p = store_tag_length (p, TAG_SEQUENCE, len[5]);
2004
2005   /* 6. Store the data OID. */
2006   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
2007   memcpy (p, oid_data, DIM (oid_data)); 
2008   p += DIM (oid_data); 
2009
2010   /* 7. Now for the pre-encoded algorithm identifier and the salt. */
2011   memcpy (p, data_rc2iter2048, DIM (data_rc2iter2048));
2012   memcpy (p + DATA_RC2ITER2048_SALT_OFF, salt, 8);
2013   p += DIM (data_rc2iter2048);
2014
2015   /* 8. And finally the [0] tag with the encrypted data. */
2016   p = store_tag_length (p, 0x80, buflen);
2017   memcpy (p, buffer, buflen);
2018   p += buflen;
2019   certbaglen = p - certbag;
2020   
2021   if (needed != certbaglen)
2022     log_debug ("length mismatch: %lu, %lu\n",
2023                (unsigned long)needed, (unsigned long)certbaglen);
2024
2025   *r_length = certbaglen;
2026   return certbag;
2027 }
2028
2029
2030 static unsigned char *
2031 build_cert_sequence (unsigned char *buffer, size_t buflen, 
2032                      const unsigned char *sha1hash, const char *keyidstr,
2033                      size_t *r_length)
2034 {
2035   size_t len[8], needed, n;
2036   unsigned char *p, *certseq;
2037   size_t certseqlen;
2038   int i;
2039
2040   assert (strlen (keyidstr) == 8);
2041
2042   /* Walk 8 steps down to collect the info: */
2043
2044   /* 7. The data goes into an octet string. */
2045   needed = compute_tag_length (buflen);
2046   needed += buflen;
2047
2048   /* 6. A [0] tag. */
2049   len[6] = needed;
2050   needed += compute_tag_length (needed);
2051
2052   /* 5. An OID. */
2053   needed += 2 + DIM (oid_x509Certificate_for_pkcs_12);
2054
2055   /* 4. A sequence. */
2056   len[4] = needed;
2057   needed += compute_tag_length (needed);
2058
2059   /* 3. A [0] tag. */
2060   len[3] = needed;
2061   needed += compute_tag_length (needed);
2062
2063   /* 2b. The attributes which are appended at the end. */
2064   if (sha1hash)
2065     needed += DIM (data_attrtemplate) + 20;
2066
2067   /* 2. An OID. */
2068   needed += 2 + DIM (oid_pkcs_12_CertBag);
2069
2070   /* 1. A sequence. */
2071   len[1] = needed;
2072   needed += compute_tag_length (needed);
2073
2074   /* 0. The first sequence. */
2075   len[0] = needed;
2076   needed += compute_tag_length (needed);
2077
2078   /* Now that we have all length information, allocate a buffer. */
2079   p = certseq = gcry_malloc (needed + 8 /*(for padding)*/);
2080   if (!certseq)
2081     {
2082       log_error ("error allocating buffer\n");
2083       return NULL;
2084     }
2085
2086   /* Walk 8 steps up to store the data. */
2087
2088   /* 0. Store the first sequence. */
2089   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
2090
2091   /* 1. Store the second sequence. */
2092   p = store_tag_length (p, TAG_SEQUENCE, len[1]);
2093
2094   /* 2. Store the pkcs12-cert-bag OID. */
2095   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_pkcs_12_CertBag));
2096   memcpy (p, oid_pkcs_12_CertBag, DIM (oid_pkcs_12_CertBag)); 
2097   p += DIM (oid_pkcs_12_CertBag); 
2098
2099   /* 3. Store a [0] tag. */
2100   p = store_tag_length (p, 0xa0, len[3]);
2101
2102   /* 4. Store a sequence. */
2103   p = store_tag_length (p, TAG_SEQUENCE, len[4]);
2104
2105   /* 5. Store the x509Certificate OID. */
2106   p = store_tag_length (p, TAG_OBJECT_ID,
2107                         DIM (oid_x509Certificate_for_pkcs_12));
2108   memcpy (p, oid_x509Certificate_for_pkcs_12,
2109           DIM (oid_x509Certificate_for_pkcs_12)); 
2110   p += DIM (oid_x509Certificate_for_pkcs_12); 
2111
2112   /* 6. Store a [0] tag. */
2113   p = store_tag_length (p, 0xa0, len[6]);
2114
2115   /* 7. And the octet string with the actual certificate. */
2116   p = store_tag_length (p, TAG_OCTET_STRING, buflen);
2117   memcpy (p, buffer, buflen);
2118   p += buflen;
2119   
2120   /* Append the attributes whose length we calculated at step 2b. */
2121   if (sha1hash)
2122     {
2123       memcpy (p, data_attrtemplate, DIM (data_attrtemplate));
2124       for (i=0; i < 8; i++)
2125         p[DATA_ATTRTEMPLATE_KEYID_OFF+2*i+1] = keyidstr[i];
2126       p += DIM (data_attrtemplate);
2127       memcpy (p, sha1hash, 20);
2128       p += 20;
2129     }
2130
2131   certseqlen = p - certseq;
2132   if (needed != certseqlen)
2133     log_debug ("length mismatch: %lu, %lu\n",
2134                (unsigned long)needed, (unsigned long)certseqlen);
2135
2136   /* Append some pad characters; we already allocated extra space. */
2137   n = 8 - certseqlen % 8;
2138   for (i=0; i < n; i++, certseqlen++)
2139     *p++ = n;
2140   
2141   *r_length = certseqlen;
2142   return certseq;
2143 }
2144
2145
2146 /* Expect the RSA key parameters in KPARMS and a password in PW.
2147    Create a PKCS structure from it and return it as well as the length
2148    in R_LENGTH; return NULL in case of an error.  If CHARSET is not
2149    NULL, re-encode PW to that character set. */
2150 unsigned char * 
2151 p12_build (gcry_mpi_t *kparms, unsigned char *cert, size_t certlen,
2152            const char *pw, const char *charset, size_t *r_length)
2153 {
2154   unsigned char *buffer = NULL;
2155   size_t n, buflen;
2156   char salt[8];
2157   struct buffer_s seqlist[3];
2158   int seqlistidx = 0;
2159   unsigned char sha1hash[20];
2160   char keyidstr[8+1];
2161   char *pwbuf = NULL;
2162   size_t pwbufsize = 0;
2163
2164   n = buflen = 0; /* (avoid compiler warning). */
2165   memset (sha1hash, 0, 20);
2166   *keyidstr = 0;
2167
2168   if (charset && pw && *pw)
2169     {
2170       iconv_t cd;
2171       const char *inptr;
2172       char *outptr;
2173       size_t inbytes, outbytes;
2174
2175       /* We assume that the converted passphrase is at max 2 times
2176          longer than its utf-8 encoding. */
2177       pwbufsize = strlen (pw)*2 + 1;
2178       pwbuf = gcry_malloc_secure (pwbufsize);
2179       if (!pwbuf)
2180         {
2181           log_error ("out of secure memory while converting passphrase\n");
2182           goto failure;
2183         }
2184
2185       cd = iconv_open (charset, "utf-8");
2186       if (cd == (iconv_t)(-1))
2187         {
2188           log_error ("can't convert passphrase to"
2189                      " requested charset `%s': %s\n",
2190                      charset, strerror (errno));
2191           gcry_free (pwbuf);
2192           goto failure;
2193         }
2194
2195       inptr = pw;
2196       inbytes = strlen (pw);
2197       outptr = pwbuf;
2198       outbytes = pwbufsize - 1;
2199       if ( iconv (cd, (ICONV_CONST char **)&inptr, &inbytes,
2200                       &outptr, &outbytes) == (size_t)-1) 
2201         {
2202           log_error ("error converting passphrase to"
2203                      " requested charset `%s': %s\n",
2204                      charset, strerror (errno));
2205           gcry_free (pwbuf);
2206           iconv_close (cd);
2207           goto failure;
2208         }
2209       *outptr = 0;
2210       iconv_close (cd);
2211       pw = pwbuf;
2212     }
2213
2214
2215   if (cert && certlen)
2216     {
2217       /* Calculate the hash value we need for the bag attributes. */
2218       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash, cert, certlen);
2219       sprintf (keyidstr, "%02x%02x%02x%02x",
2220                sha1hash[16], sha1hash[17], sha1hash[18], sha1hash[19]);
2221
2222       /* Encode the certificate. */
2223       buffer = build_cert_sequence (cert, certlen, sha1hash, keyidstr,
2224                                     &buflen);
2225       if (!buffer)
2226         goto failure;
2227
2228       /* Encrypt it. */
2229       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2230       crypt_block (buffer, buflen, salt, 8, 2048, pw,
2231                    GCRY_CIPHER_RFC2268_40, 1);
2232       
2233       /* Encode the encrypted stuff into a bag. */
2234       seqlist[seqlistidx].buffer = build_cert_bag (buffer, buflen, salt, &n);
2235       seqlist[seqlistidx].length = n;
2236       gcry_free (buffer);
2237       buffer = NULL;
2238       if (!seqlist[seqlistidx].buffer)
2239         goto failure;
2240       seqlistidx++;
2241     }
2242
2243
2244   if (kparms)
2245     {
2246       /* Encode the key. */
2247       buffer = build_key_sequence (kparms, &buflen);
2248       if (!buffer)
2249         goto failure;
2250       
2251       /* Encrypt it. */
2252       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2253       crypt_block (buffer, buflen, salt, 8, 2048, pw, GCRY_CIPHER_3DES, 1);
2254
2255       /* Encode the encrypted stuff into a bag. */
2256       if (cert && certlen)
2257         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt, 
2258                                                     sha1hash, keyidstr, &n);
2259       else
2260         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt,
2261                                                     NULL, NULL, &n);
2262       seqlist[seqlistidx].length = n;
2263       gcry_free (buffer);
2264       buffer = NULL;
2265       if (!seqlist[seqlistidx].buffer)
2266         goto failure;
2267       seqlistidx++;
2268     }
2269
2270   seqlist[seqlistidx].buffer = NULL;
2271   seqlist[seqlistidx].length = 0;
2272
2273   buffer = create_final (seqlist, pw, &buflen);
2274
2275  failure:
2276   if (pwbuf)
2277     {
2278       wipememory (pwbuf, pwbufsize);
2279       gcry_free (pwbuf);
2280     }
2281   for ( ; seqlistidx; seqlistidx--)
2282     gcry_free (seqlist[seqlistidx].buffer);
2283
2284   *r_length = buffer? buflen : 0;
2285   return buffer;
2286 }
2287
2288
2289 #ifdef TEST
2290
2291 static void 
2292 cert_cb (void *opaque, const unsigned char *cert, size_t certlen)
2293 {
2294   printf ("got a certificate of %u bytes length\n", certlen);
2295 }
2296
2297 int
2298 main (int argc, char **argv)
2299 {
2300   FILE *fp;
2301   struct stat st;
2302   unsigned char *buf;
2303   size_t buflen;
2304   gcry_mpi_t *result;
2305
2306   if (argc != 3)
2307     {
2308       fprintf (stderr, "usage: testp12 file passphrase\n");
2309       return 1;
2310     }
2311
2312   gcry_control (GCRYCTL_DISABLE_SECMEM, NULL);
2313   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL);
2314
2315   fp = fopen (argv[1], "rb");
2316   if (!fp)
2317     {
2318       fprintf (stderr, "can't open `%s': %s\n", argv[1], strerror (errno));
2319       return 1;
2320     }
2321   
2322   if (fstat (fileno(fp), &st))
2323     {
2324       fprintf (stderr, "can't stat `%s': %s\n", argv[1], strerror (errno));
2325       return 1;
2326     }
2327
2328   buflen = st.st_size;
2329   buf = gcry_malloc (buflen+1);
2330   if (!buf || fread (buf, buflen, 1, fp) != 1)
2331     {
2332       fprintf (stderr, "error reading `%s': %s\n", argv[1], strerror (errno));
2333       return 1;
2334     }
2335   fclose (fp);
2336
2337   result = p12_parse (buf, buflen, argv[2], cert_cb, NULL);
2338   if (result)
2339     {
2340       int i, rc;
2341       unsigned char *tmpbuf;
2342
2343       for (i=0; result[i]; i++)
2344         {
2345           rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &tmpbuf,
2346                                 NULL, result[i]);
2347           if (rc)
2348             printf ("%d: [error printing number: %s]\n",
2349                     i, gpg_strerror (rc));
2350           else
2351             {
2352               printf ("%d: %s\n", i, tmpbuf);
2353               gcry_free (tmpbuf);
2354             }
2355         }
2356     }
2357
2358   return 0;
2359
2360 }
2361
2362 /*
2363 Local Variables:
2364 compile-command: "gcc -Wall -O0 -g -DTEST=1 -o minip12 minip12.c ../jnlib/libjnlib.a -L /usr/local/lib -lgcrypt -lgpg-error"
2365 End:
2366 */
2367 #endif /* TEST */