* PKCS#12 import now tries several encodings in case the passphrase
[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
32 #ifdef TEST
33 #include <sys/stat.h>
34 #include <unistd.h>
35 #include <errno.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     NULL
522   };
523   int charsetidx = 0;
524   char *convertedpw = NULL;   /* Malloced and converted password or NULL.  */
525   size_t convertedpwsize = 0; /* Allocated length.  */
526
527   for (charsetidx=0; charsets[charsetidx]; charsetidx++)
528     {
529       if (*charsets[charsetidx])
530         {
531           iconv_t cd;
532           const char *inptr;
533           char *outptr;
534           size_t inbytes, outbytes;
535
536           if (!convertedpw)
537             {
538               /* We assume one byte encodings.  Thus we can allocate
539                  the buffer of the same size as the original
540                  passphrase; the result will actually be shorter
541                  then.  */
542               convertedpwsize = strlen (pw) + 1;
543               convertedpw = gcry_malloc_secure (convertedpwsize);
544               if (!convertedpw)
545                 {
546                   log_info ("out of secure memory while"
547                             " converting passphrase\n");
548                   break; /* Give up.  */
549                 }
550             }
551
552           cd = iconv_open (charsets[charsetidx], "utf-8");
553           if (cd == (iconv_t)(-1))
554             continue;
555
556           inptr = pw;
557           inbytes = strlen (pw);
558           outptr = convertedpw;
559           outbytes = convertedpwsize - 1;
560           if ( iconv (cd, (ICONV_CONST char **)&inptr, &inbytes,
561                       &outptr, &outbytes) == (size_t)-1) 
562             {
563               iconv_close (cd);
564               continue;
565             }
566           *outptr = 0;
567           iconv_close (cd);
568           log_info ("decryption failed; trying charset `%s'\n",
569                     charsets[charsetidx]);
570         }
571       memcpy (plaintext, ciphertext, length);
572       crypt_block (plaintext, length, salt, saltlen, iter,
573                    convertedpw? convertedpw:pw, cipher_algo, 0);
574       if (check_fnc (plaintext, length))
575         break; /* Decryption succeeded. */
576     }
577   gcry_free (convertedpw);
578 }
579
580
581 /* Return true if the decryption of an bag_encrypted_data object has
582    likely succeeded.  */
583 static int
584 bag_decrypted_data_p (const void *plaintext, size_t length)
585 {
586   struct tag_info ti;
587   const unsigned char *p = plaintext;
588   size_t n = length;
589
590   /*   { */
591   /* #  warning debug code is enabled */
592   /*     FILE *fp = fopen ("tmp-rc2-plain.der", "wb"); */
593   /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
594   /*       exit (2); */
595   /*     fclose (fp); */
596   /*   } */
597   
598   if (parse_tag (&p, &n, &ti))
599     return 0;
600   if (ti.class || ti.tag != TAG_SEQUENCE)
601     return 0;
602   if (parse_tag (&p, &n, &ti))
603     return 0;
604
605   return 1; 
606 }
607
608 /* Note: If R_RESULT is passed as NULL, a key object as already be
609    processed and thus we need to skip it here. */
610 static int
611 parse_bag_encrypted_data (const unsigned char *buffer, size_t length,
612                           int startoffset, size_t *r_consumed, const char *pw,
613                           void (*certcb)(void*, const unsigned char*, size_t),
614                           void *certcbarg, gcry_mpi_t **r_result)
615 {
616   struct tag_info ti;
617   const unsigned char *p = buffer;
618   const unsigned char *p_start = buffer;
619   size_t n = length;
620   const char *where;
621   char salt[20];
622   size_t saltlen;
623   unsigned int iter;
624   unsigned char *plain = NULL;
625   int bad_pass = 0;
626   unsigned char *cram_buffer = NULL;
627   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
628   int is_3des = 0;
629   gcry_mpi_t *result = NULL;
630   int result_count;
631
632   if (r_result)
633     *r_result = NULL;
634   where = "start";
635   if (parse_tag (&p, &n, &ti))
636     goto bailout;
637   if (ti.class != CONTEXT || ti.tag)
638     goto bailout;
639   if (parse_tag (&p, &n, &ti))
640     goto bailout;
641   if (ti.tag != TAG_SEQUENCE)
642     goto bailout;
643
644   where = "bag.encryptedData.version";
645   if (parse_tag (&p, &n, &ti))
646     goto bailout;
647   if (ti.tag != TAG_INTEGER || ti.length != 1 || *p != 0)
648     goto bailout;
649   p++; n--;
650   if (parse_tag (&p, &n, &ti))
651     goto bailout;
652   if (ti.tag != TAG_SEQUENCE)
653     goto bailout;
654
655   where = "bag.encryptedData.data";
656   if (parse_tag (&p, &n, &ti))
657     goto bailout;
658   if (ti.tag != TAG_OBJECT_ID || ti.length != DIM(oid_data)
659       || memcmp (p, oid_data, DIM(oid_data)))
660     goto bailout;
661   p += DIM(oid_data);
662   n -= DIM(oid_data);
663
664   where = "bag.encryptedData.keyinfo";
665   if (parse_tag (&p, &n, &ti))
666     goto bailout;
667   if (ti.class || ti.tag != TAG_SEQUENCE)
668     goto bailout;
669   if (parse_tag (&p, &n, &ti))
670     goto bailout;
671   if (!ti.class && ti.tag == TAG_OBJECT_ID 
672       && ti.length == DIM(oid_pbeWithSHAAnd40BitRC2_CBC)
673       && !memcmp (p, oid_pbeWithSHAAnd40BitRC2_CBC,
674                   DIM(oid_pbeWithSHAAnd40BitRC2_CBC)))
675     {
676       p += DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
677       n -= DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
678     }
679   else if (!ti.class && ti.tag == TAG_OBJECT_ID 
680       && ti.length == DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
681       && !memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
682                   DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
683     {
684       p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
685       n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
686       is_3des = 1;
687     }
688   else
689     goto bailout;
690
691   where = "rc2or3des-params";
692   if (parse_tag (&p, &n, &ti))
693     goto bailout;
694   if (ti.class || ti.tag != TAG_SEQUENCE)
695     goto bailout;
696   if (parse_tag (&p, &n, &ti))
697     goto bailout;
698   if (ti.class || ti.tag != TAG_OCTET_STRING
699       || ti.length < 8 || ti.length > 20 )
700     goto bailout;
701   saltlen = ti.length;
702   memcpy (salt, p, saltlen);
703   p += saltlen;
704   n -= saltlen;
705   if (parse_tag (&p, &n, &ti))
706     goto bailout;
707   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
708     goto bailout;
709   for (iter=0; ti.length; ti.length--)
710     {
711       iter <<= 8;
712       iter |= (*p++) & 0xff; 
713       n--;
714     }
715   
716   where = "rc2or3des-ciphertext";
717   if (parse_tag (&p, &n, &ti))
718     goto bailout;
719
720   consumed = p - p_start;
721   if (ti.class == CONTEXT && ti.tag == 0 && ti.is_constructed && ti.ndef)
722     {
723       /* Mozilla exported certs now come with single byte chunks of
724          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
725       where = "cram-rc2or3des-ciphertext";
726       cram_buffer = cram_octet_string ( p, &n, &consumed);
727       if (!cram_buffer)
728         goto bailout;
729       p = p_start = cram_buffer;
730       if (r_consumed)
731         *r_consumed = consumed;
732       r_consumed = NULL; /* Ugly hack to not update that value any further. */
733       ti.length = n;
734     }
735   else if (ti.class == CONTEXT && ti.tag == 0 && ti.length )
736     ;
737   else
738     goto bailout;
739   
740   log_info ("%lu bytes of %s encrypted text\n",ti.length,is_3des?"3DES":"RC2");
741
742   plain = gcry_malloc_secure (ti.length);
743   if (!plain)
744     {
745       log_error ("error allocating decryption buffer\n");
746       goto bailout;
747     }
748   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
749                  is_3des? GCRY_CIPHER_3DES : GCRY_CIPHER_RFC2268_40, 
750                  bag_decrypted_data_p);
751   n = ti.length;
752   startoffset = 0;
753   p_start = p = plain;
754
755   where = "outer.outer.seq";
756   if (parse_tag (&p, &n, &ti))
757     {
758       bad_pass = 1;
759       goto bailout;
760     }
761   if (ti.class || ti.tag != TAG_SEQUENCE)
762     {
763       bad_pass = 1;
764       goto bailout;
765     }
766
767   if (parse_tag (&p, &n, &ti))
768     {
769       bad_pass = 1;
770       goto bailout;
771     }
772
773   /* Loop over all certificates inside the bag. */
774   while (n)
775     {
776       int iscrlbag = 0;
777       int iskeybag = 0;
778
779       where = "certbag.nextcert";
780       if (ti.class || ti.tag != TAG_SEQUENCE)
781         goto bailout;
782
783       where = "certbag.objectidentifier";
784       if (parse_tag (&p, &n, &ti))
785         goto bailout;
786       if (ti.class || ti.tag != TAG_OBJECT_ID)
787         goto bailout;
788       if ( ti.length == DIM(oid_pkcs_12_CertBag)
789            && !memcmp (p, oid_pkcs_12_CertBag, DIM(oid_pkcs_12_CertBag)))
790         {
791           p += DIM(oid_pkcs_12_CertBag);
792           n -= DIM(oid_pkcs_12_CertBag);
793         }
794       else if ( ti.length == DIM(oid_pkcs_12_CrlBag)
795            && !memcmp (p, oid_pkcs_12_CrlBag, DIM(oid_pkcs_12_CrlBag)))
796         {
797           p += DIM(oid_pkcs_12_CrlBag);
798           n -= DIM(oid_pkcs_12_CrlBag);
799           iscrlbag = 1;
800         }
801       else if ( ti.length == DIM(oid_pkcs_12_keyBag)
802            && !memcmp (p, oid_pkcs_12_keyBag, DIM(oid_pkcs_12_keyBag)))
803         {
804           /* The TrustedMIME plugin for MS Outlook started to create
805              files with just one outer 3DES encrypted container and
806              inside the certificates as well as the key. */
807           p += DIM(oid_pkcs_12_keyBag);
808           n -= DIM(oid_pkcs_12_keyBag);
809           iskeybag = 1;
810         }
811       else
812         goto bailout;
813
814       where = "certbag.before.certheader";
815       if (parse_tag (&p, &n, &ti))
816         goto bailout;
817       if (ti.class != CONTEXT || ti.tag)
818         goto bailout;
819       if (iscrlbag)
820         {
821           log_info ("skipping unsupported crlBag\n");
822           p += ti.length;
823           n -= ti.length;
824         }
825       else if (iskeybag && (result || !r_result))
826         {
827           log_info ("one keyBag already processed; skipping this one\n");
828           p += ti.length;
829           n -= ti.length;
830         }
831       else if (iskeybag)
832         {
833           int len;
834
835           log_info ("processing simple keyBag\n");
836
837           /* Fixme: This code is duplicated from parse_bag_data.  */
838           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
839             goto bailout;
840           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
841               || ti.length != 1 || *p)
842             goto bailout;
843           p++; n--;
844           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
845             goto bailout;
846           len = ti.length;
847           if (parse_tag (&p, &n, &ti))
848             goto bailout;
849           if (len < ti.nhdr)
850             goto bailout;
851           len -= ti.nhdr;
852           if (ti.class || ti.tag != TAG_OBJECT_ID
853               || ti.length != DIM(oid_rsaEncryption)
854               || memcmp (p, oid_rsaEncryption,
855                          DIM(oid_rsaEncryption)))
856             goto bailout;
857           p += DIM (oid_rsaEncryption);
858           n -= DIM (oid_rsaEncryption);
859           if (len < ti.length)
860             goto bailout;
861           len -= ti.length;
862           if (n < len)
863             goto bailout;
864           p += len;
865           n -= len;
866           if ( parse_tag (&p, &n, &ti)
867                || ti.class || ti.tag != TAG_OCTET_STRING)
868             goto bailout;
869           if ( parse_tag (&p, &n, &ti)
870                || ti.class || ti.tag != TAG_SEQUENCE)
871             goto bailout;
872           len = ti.length;
873
874           result = gcry_calloc (10, sizeof *result);
875           if (!result)
876             {
877               log_error ( "error allocating result array\n");
878               goto bailout;
879             }
880           result_count = 0;
881
882           where = "reading.keybag.key-parameters";
883           for (result_count = 0; len && result_count < 9;)
884             {
885               if ( parse_tag (&p, &n, &ti)
886                    || ti.class || ti.tag != TAG_INTEGER)
887                 goto bailout;
888               if (len < ti.nhdr)
889                 goto bailout;
890               len -= ti.nhdr;
891               if (len < ti.length)
892                 goto bailout;
893               len -= ti.length;
894               if (!result_count && ti.length == 1 && !*p)
895                 ; /* ignore the very first one if it is a 0 */
896               else 
897                 {
898                   int rc;
899
900                   rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
901                                       ti.length, NULL);
902                   if (rc)
903                     {
904                       log_error ("error parsing key parameter: %s\n",
905                                  gpg_strerror (rc));
906                       goto bailout;
907                     }
908                   result_count++;
909                 }
910               p += ti.length;
911               n -= ti.length;
912             }
913           if (len)
914             goto bailout;
915         }
916       else
917         {
918           log_info ("processing certBag\n");
919           if (parse_tag (&p, &n, &ti))
920             goto bailout;
921           if (ti.class || ti.tag != TAG_SEQUENCE)
922             goto bailout;
923           if (parse_tag (&p, &n, &ti))
924             goto bailout;
925           if (ti.class || ti.tag != TAG_OBJECT_ID
926               || ti.length != DIM(oid_x509Certificate_for_pkcs_12)
927               || memcmp (p, oid_x509Certificate_for_pkcs_12,
928                          DIM(oid_x509Certificate_for_pkcs_12)))
929             goto bailout;
930           p += DIM(oid_x509Certificate_for_pkcs_12);
931           n -= DIM(oid_x509Certificate_for_pkcs_12);
932           
933           where = "certbag.before.octetstring";
934           if (parse_tag (&p, &n, &ti))
935             goto bailout;
936           if (ti.class != CONTEXT || ti.tag)
937             goto bailout;
938           if (parse_tag (&p, &n, &ti))
939             goto bailout;
940           if (ti.class || ti.tag != TAG_OCTET_STRING || ti.ndef)
941             goto bailout;
942           
943           /* Return the certificate. */
944           if (certcb)
945             certcb (certcbarg, p, ti.length);
946    
947           p += ti.length;
948           n -= ti.length;
949         }
950
951       /* Ugly hack to cope with the padding: Forget about the rest if
952          that is less or equal to the cipher's block length.  We can
953          reasonable assume that all valid data will be longer than
954          just one block. */
955       if (n <= 8)
956         n = 0;  
957
958       /* Skip the optional SET with the pkcs12 cert attributes. */
959       if (n)
960         {
961           where = "bag.attributes";
962           if (parse_tag (&p, &n, &ti))
963             goto bailout;
964           if (!ti.class && ti.tag == TAG_SEQUENCE)
965             ; /* No attributes. */
966           else if (!ti.class && ti.tag == TAG_SET && !ti.ndef)
967             { /* The optional SET. */
968               p += ti.length;
969               n -= ti.length;
970               if (n <= 8)
971                 n = 0;
972               if (n && parse_tag (&p, &n, &ti))
973                 goto bailout;
974             }
975           else
976             goto bailout;
977         }
978     }
979   
980   if (r_consumed)
981     *r_consumed = consumed;
982   gcry_free (plain);
983   gcry_free (cram_buffer);
984   if (r_result)
985     *r_result = result;
986   return 0;
987
988  bailout:
989   if (result)
990     {
991       int i;
992
993       for (i=0; result[i]; i++)
994         gcry_mpi_release (result[i]);
995       gcry_free (result);
996     }
997   if (r_consumed)
998     *r_consumed = consumed;
999   gcry_free (plain);
1000   gcry_free (cram_buffer);
1001   log_error ("encryptedData error at \"%s\", offset %u\n",
1002              where, (unsigned int)((p - p_start)+startoffset));
1003   if (bad_pass)
1004     {
1005       /* Note, that the following string might be used by other programs
1006          to check for a bad passphrase; it should therefore not be
1007          translated or changed. */
1008       log_error ("possibly bad passphrase given\n");
1009     }
1010   return -1;
1011 }
1012
1013
1014 /* Return true if the decryption of a bag_data object has likely
1015    succeeded.  */
1016 static int
1017 bag_data_p (const void *plaintext, size_t length)
1018 {
1019   struct tag_info ti;
1020   const unsigned char *p = plaintext;
1021   size_t n = length;
1022
1023 /*   { */
1024 /* #  warning debug code is enabled */
1025 /*     FILE *fp = fopen ("tmp-3des-plain-key.der", "wb"); */
1026 /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
1027 /*       exit (2); */
1028 /*     fclose (fp); */
1029 /*   } */
1030
1031   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1032     return 0;
1033   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1034       || ti.length != 1 || *p)
1035     return 0;
1036
1037   return 1; 
1038 }
1039
1040
1041 static gcry_mpi_t *
1042 parse_bag_data (const unsigned char *buffer, size_t length, int startoffset,
1043                 size_t *r_consumed, const char *pw)
1044 {
1045   int rc;
1046   struct tag_info ti;
1047   const unsigned char *p = buffer;
1048   const unsigned char *p_start = buffer;
1049   size_t n = length;
1050   const char *where;
1051   char salt[20];
1052   size_t saltlen;
1053   unsigned int iter;
1054   int len;
1055   unsigned char *plain = NULL;
1056   gcry_mpi_t *result = NULL;
1057   int result_count, i;
1058   unsigned char *cram_buffer = NULL;
1059   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
1060
1061   where = "start";
1062   if (parse_tag (&p, &n, &ti))
1063     goto bailout;
1064   if (ti.class != CONTEXT || ti.tag)
1065     goto bailout;
1066   if (parse_tag (&p, &n, &ti))
1067     goto bailout;
1068   if (ti.class || ti.tag != TAG_OCTET_STRING)
1069     goto bailout;
1070
1071   consumed = p - p_start;
1072   if (ti.is_constructed && ti.ndef)
1073     {
1074       /* Mozilla exported certs now come with single byte chunks of
1075          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
1076       where = "cram-data.outersegs";
1077       cram_buffer = cram_octet_string ( p, &n, &consumed);
1078       if (!cram_buffer)
1079         goto bailout;
1080       p = p_start = cram_buffer;
1081       if (r_consumed)
1082         *r_consumed = consumed;
1083       r_consumed = NULL; /* Ugly hack to not update that value any further. */
1084     }
1085   
1086
1087   where = "data.outerseqs";
1088   if (parse_tag (&p, &n, &ti))
1089     goto bailout;
1090   if (ti.class || ti.tag != TAG_SEQUENCE)
1091     goto bailout;
1092   if (parse_tag (&p, &n, &ti))
1093     goto bailout;
1094   if (ti.class || ti.tag != TAG_SEQUENCE)
1095     goto bailout;
1096
1097   where = "data.objectidentifier";
1098   if (parse_tag (&p, &n, &ti))
1099     goto bailout;
1100   if (ti.class || ti.tag != TAG_OBJECT_ID
1101       || ti.length != DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)
1102       || memcmp (p, oid_pkcs_12_pkcs_8ShroudedKeyBag,
1103                  DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)))
1104     goto bailout;
1105   p += DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1106   n -= DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1107
1108   where = "shrouded,outerseqs";
1109   if (parse_tag (&p, &n, &ti))
1110     goto bailout;
1111   if (ti.class != CONTEXT || ti.tag)
1112     goto bailout;
1113   if (parse_tag (&p, &n, &ti))
1114     goto bailout;
1115   if (ti.class || ti.tag != TAG_SEQUENCE)
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_OBJECT_ID
1124       || ti.length != DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
1125       || memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
1126                  DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
1127     goto bailout;
1128   p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1129   n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1130
1131   where = "3des-params";
1132   if (parse_tag (&p, &n, &ti))
1133     goto bailout;
1134   if (ti.class || ti.tag != TAG_SEQUENCE)
1135     goto bailout;
1136   if (parse_tag (&p, &n, &ti))
1137     goto bailout;
1138   if (ti.class || ti.tag != TAG_OCTET_STRING
1139       || ti.length < 8 || ti.length > 20)
1140     goto bailout;
1141   saltlen = ti.length;
1142   memcpy (salt, p, saltlen);
1143   p += saltlen;
1144   n -= saltlen;
1145   if (parse_tag (&p, &n, &ti))
1146     goto bailout;
1147   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
1148     goto bailout;
1149   for (iter=0; ti.length; ti.length--)
1150     {
1151       iter <<= 8;
1152       iter |= (*p++) & 0xff; 
1153       n--;
1154     }
1155   
1156   where = "3des-ciphertext";
1157   if (parse_tag (&p, &n, &ti))
1158     goto bailout;
1159   if (ti.class || ti.tag != TAG_OCTET_STRING || !ti.length )
1160     goto bailout;
1161   
1162   log_info ("%lu bytes of 3DES encrypted text\n", ti.length);
1163   
1164   plain = gcry_malloc_secure (ti.length);
1165   if (!plain)
1166     {
1167       log_error ("error allocating decryption buffer\n");
1168       goto bailout;
1169     }
1170   consumed += p - p_start + ti.length;
1171   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
1172                  GCRY_CIPHER_3DES, 
1173                  bag_data_p);
1174   n = ti.length;
1175   startoffset = 0;
1176   p_start = p = plain;
1177
1178   where = "decrypted-text";
1179   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1180     goto bailout;
1181   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1182       || ti.length != 1 || *p)
1183     goto bailout;
1184   p++; n--;
1185   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1186     goto bailout;
1187   len = ti.length;
1188   if (parse_tag (&p, &n, &ti))
1189     goto bailout;
1190   if (len < ti.nhdr)
1191     goto bailout;
1192   len -= ti.nhdr;
1193   if (ti.class || ti.tag != TAG_OBJECT_ID
1194       || ti.length != DIM(oid_rsaEncryption)
1195       || memcmp (p, oid_rsaEncryption,
1196                  DIM(oid_rsaEncryption)))
1197     goto bailout;
1198   p += DIM (oid_rsaEncryption);
1199   n -= DIM (oid_rsaEncryption);
1200   if (len < ti.length)
1201     goto bailout;
1202   len -= ti.length;
1203   if (n < len)
1204     goto bailout;
1205   p += len;
1206   n -= len;
1207   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_OCTET_STRING)
1208     goto bailout;
1209   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1210     goto bailout;
1211   len = ti.length;
1212
1213   result = gcry_calloc (10, sizeof *result);
1214   if (!result)
1215     {
1216       log_error ( "error allocating result array\n");
1217       goto bailout;
1218     }
1219   result_count = 0;
1220
1221   where = "reading.key-parameters";
1222   for (result_count=0; len && result_count < 9;)
1223     {
1224       if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER)
1225         goto bailout;
1226       if (len < ti.nhdr)
1227         goto bailout;
1228       len -= ti.nhdr;
1229       if (len < ti.length)
1230         goto bailout;
1231       len -= ti.length;
1232       if (!result_count && ti.length == 1 && !*p)
1233         ; /* ignore the very first one if it is a 0 */
1234       else 
1235         {
1236           rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
1237                               ti.length, NULL);
1238           if (rc)
1239             {
1240               log_error ("error parsing key parameter: %s\n",
1241                          gpg_strerror (rc));
1242               goto bailout;
1243             }
1244           result_count++;
1245         }
1246       p += ti.length;
1247       n -= ti.length;
1248     }
1249   if (len)
1250     goto bailout;
1251
1252   gcry_free (cram_buffer);
1253   if (r_consumed)
1254     *r_consumed = consumed;
1255   return result;
1256
1257  bailout:
1258   gcry_free (plain);
1259   if (result)
1260     {
1261       for (i=0; result[i]; i++)
1262         gcry_mpi_release (result[i]);
1263       gcry_free (result);
1264     }
1265   gcry_free (cram_buffer);
1266   log_error ( "data error at \"%s\", offset %u\n",
1267               where, (unsigned int)((p - buffer) + startoffset));
1268   if (r_consumed)
1269     *r_consumed = consumed;
1270   return NULL;
1271 }
1272
1273
1274 /* Parse a PKCS12 object and return an array of MPI representing the
1275    secret key parameters.  This is a very limited implementation in
1276    that it is only able to look for 3DES encoded encryptedData and
1277    tries to extract the first private key object it finds.  In case of
1278    an error NULL is returned. CERTCB and CERRTCBARG are used to pass
1279    X.509 certificates back to the caller. */
1280 gcry_mpi_t *
1281 p12_parse (const unsigned char *buffer, size_t length, const char *pw,
1282            void (*certcb)(void*, const unsigned char*, size_t),
1283            void *certcbarg)
1284 {
1285   struct tag_info ti;
1286   const unsigned char *p = buffer;
1287   const unsigned char *p_start = buffer;
1288   size_t n = length;
1289   const char *where;
1290   int bagseqlength, len;
1291   int bagseqndef, lenndef;
1292   gcry_mpi_t *result = NULL;
1293   unsigned char *cram_buffer = NULL;
1294
1295   where = "pfx";
1296   if (parse_tag (&p, &n, &ti))
1297     goto bailout;
1298   if (ti.tag != TAG_SEQUENCE)
1299     goto bailout;
1300
1301   where = "pfxVersion";
1302   if (parse_tag (&p, &n, &ti))
1303     goto bailout;
1304   if (ti.tag != TAG_INTEGER || ti.length != 1 || *p != 3)
1305     goto bailout;
1306   p++; n--;
1307   
1308   where = "authSave";
1309   if (parse_tag (&p, &n, &ti))
1310     goto bailout;
1311   if (ti.tag != TAG_SEQUENCE)
1312     goto bailout;
1313   if (parse_tag (&p, &n, &ti))
1314     goto bailout;
1315   if (ti.tag != TAG_OBJECT_ID || ti.length != DIM(oid_data)
1316       || memcmp (p, oid_data, DIM(oid_data)))
1317     goto bailout;
1318   p += DIM(oid_data);
1319   n -= DIM(oid_data);
1320
1321   if (parse_tag (&p, &n, &ti))
1322     goto bailout;
1323   if (ti.class != CONTEXT || ti.tag)
1324     goto bailout;
1325   if (parse_tag (&p, &n, &ti))
1326     goto bailout;
1327   if (ti.class != UNIVERSAL || ti.tag != TAG_OCTET_STRING)
1328     goto bailout;
1329
1330   if (ti.is_constructed && ti.ndef)
1331     {
1332       /* Mozilla exported certs now come with single byte chunks of
1333          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
1334       where = "cram-bags";
1335       cram_buffer = cram_octet_string ( p, &n, NULL);
1336       if (!cram_buffer)
1337         goto bailout;
1338       p = p_start = cram_buffer;
1339     }
1340
1341   where = "bags";
1342   if (parse_tag (&p, &n, &ti))
1343     goto bailout;
1344   if (ti.class != UNIVERSAL || ti.tag != TAG_SEQUENCE)
1345     goto bailout;
1346   bagseqndef = ti.ndef;
1347   bagseqlength = ti.length;
1348   while (bagseqlength || bagseqndef)
1349     {
1350 /*       log_debug ( "at offset %u\n", (p - p_start)); */
1351       where = "bag-sequence";
1352       if (parse_tag (&p, &n, &ti))
1353         goto bailout;
1354       if (bagseqndef && ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed)
1355         break; /* Ready */ 
1356       if (ti.class != UNIVERSAL || ti.tag != TAG_SEQUENCE)
1357         goto bailout;
1358
1359       if (!bagseqndef)
1360         {
1361           if (bagseqlength < ti.nhdr)
1362             goto bailout;
1363           bagseqlength -= ti.nhdr;
1364           if (bagseqlength < ti.length)
1365             goto bailout;
1366           bagseqlength -= ti.length;
1367         }
1368       lenndef = ti.ndef;
1369       len = ti.length;
1370
1371       if (parse_tag (&p, &n, &ti))
1372         goto bailout;
1373       if (lenndef)
1374         len = ti.nhdr; 
1375       else
1376         len -= ti.nhdr; 
1377
1378       if (ti.tag == TAG_OBJECT_ID && ti.length == DIM(oid_encryptedData)
1379           && !memcmp (p, oid_encryptedData, DIM(oid_encryptedData)))
1380         {
1381           size_t consumed = 0;
1382
1383           p += DIM(oid_encryptedData);
1384           n -= DIM(oid_encryptedData);
1385           if (!lenndef)
1386             len -= DIM(oid_encryptedData);
1387           where = "bag.encryptedData";
1388           if (parse_bag_encrypted_data (p, n, (p - p_start), &consumed, pw,
1389                                         certcb, certcbarg,
1390                                         result? NULL : &result))
1391             goto bailout;
1392           if (lenndef)
1393             len += consumed;
1394         }
1395       else if (ti.tag == TAG_OBJECT_ID && ti.length == DIM(oid_data)
1396                && !memcmp (p, oid_data, DIM(oid_data)))
1397         {
1398           if (result)
1399             {
1400               log_info ("already got an key object, skipping this one\n");
1401               p += ti.length;
1402               n -= ti.length;
1403             }
1404           else
1405             {
1406               size_t consumed = 0;
1407
1408               p += DIM(oid_data);
1409               n -= DIM(oid_data);
1410               if (!lenndef)
1411                 len -= DIM(oid_data);
1412               result = parse_bag_data (p, n, (p - p_start), &consumed, pw);
1413               if (!result)
1414                 goto bailout;
1415               if (lenndef)
1416                 len += consumed;
1417             }
1418         }
1419       else
1420         {
1421           log_info ("unknown bag type - skipped\n");
1422           p += ti.length;
1423           n -= ti.length;
1424         }
1425
1426       if (len < 0 || len > n)
1427         goto bailout;
1428       p += len;
1429       n -= len;
1430       if (lenndef)
1431         {
1432           /* Need to skip the Null Tag. */
1433           if (parse_tag (&p, &n, &ti))
1434             goto bailout;
1435           if (!(ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed))
1436             goto bailout;
1437         }
1438     }
1439   
1440   gcry_free (cram_buffer);
1441   return result;
1442  bailout:
1443   log_error ("error at \"%s\", offset %u\n",
1444              where, (unsigned int)(p - p_start));
1445   if (result)
1446     {
1447       int i;
1448
1449       for (i=0; result[i]; i++)
1450         gcry_mpi_release (result[i]);
1451       gcry_free (result);
1452     }
1453   gcry_free (cram_buffer);
1454   return NULL;
1455 }
1456
1457
1458 \f
1459 static size_t
1460 compute_tag_length (size_t n)
1461 {     
1462   int needed = 0;
1463
1464   if (n < 128)
1465     needed += 2; /* tag and one length byte */
1466   else if (n < 256)
1467     needed += 3; /* tag, number of length bytes, 1 length byte */
1468   else if (n < 65536)
1469     needed += 4; /* tag, number of length bytes, 2 length bytes */
1470   else
1471     {
1472       log_error ("object too larger to encode\n");
1473       return 0;
1474     }
1475   return needed;
1476 }
1477
1478 static unsigned char *
1479 store_tag_length (unsigned char *p, int tag, size_t n)
1480 {     
1481   if (tag == TAG_SEQUENCE)
1482     tag |= 0x20; /* constructed */
1483
1484   *p++ = tag;
1485   if (n < 128)
1486     *p++ = n;
1487   else if (n < 256)
1488     {
1489       *p++ = 0x81;
1490       *p++ = n;
1491     }
1492   else if (n < 65536)
1493     {
1494       *p++ = 0x82;
1495       *p++ = n >> 8;
1496       *p++ = n;
1497     }
1498
1499   return p;
1500 }
1501
1502
1503 /* Create the final PKCS-12 object from the sequences contained in
1504    SEQLIST.  PW is the password. That array is terminated with an NULL
1505    object. */
1506 static unsigned char *
1507 create_final (struct buffer_s *sequences, const char *pw, size_t *r_length)
1508 {
1509   int i;
1510   size_t needed = 0;
1511   size_t len[8], n;
1512   unsigned char *macstart;
1513   size_t maclen;
1514   unsigned char *result, *p;
1515   size_t resultlen;
1516   char salt[8];
1517   unsigned char keybuf[20];
1518   gcry_md_hd_t md;
1519   int rc;
1520   int with_mac = 1;
1521
1522
1523   /* 9 steps to create the pkcs#12 Krampf. */
1524
1525   /* 8. The MAC. */
1526   /* We add this at step 0. */
1527
1528   /* 7. All the buffers. */
1529   for (i=0; sequences[i].buffer; i++)
1530     needed += sequences[i].length;
1531
1532   /* 6. This goes into a sequences. */
1533   len[6] = needed;
1534   n = compute_tag_length (needed);
1535   needed += n;
1536
1537   /* 5. Encapsulate all in an octet string. */
1538   len[5] = needed;
1539   n = compute_tag_length (needed);
1540   needed += n;
1541
1542   /* 4. And tag it with [0]. */
1543   len[4] = needed;
1544   n = compute_tag_length (needed);
1545   needed += n;
1546
1547   /* 3. Prepend an data OID. */
1548   needed += 2 + DIM (oid_data);
1549
1550   /* 2. Put all into a sequences. */
1551   len[2] = needed;
1552   n = compute_tag_length (needed);
1553   needed += n;
1554
1555   /* 1. Prepend the version integer 3. */
1556   needed += 3;
1557
1558   /* 0. And the final outer sequence. */
1559   if (with_mac)
1560     needed += DIM (data_mactemplate);
1561   len[0] = needed;
1562   n = compute_tag_length (needed);
1563   needed += n;
1564
1565   /* Allocate a buffer. */
1566   result = gcry_malloc (needed);
1567   if (!result)
1568     {
1569       log_error ("error allocating buffer\n");
1570       return NULL;
1571     }
1572   p = result;
1573
1574   /* 0. Store the very outer sequence. */
1575   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1576
1577   /* 1. Store the version integer 3. */
1578   *p++ = TAG_INTEGER;
1579   *p++ = 1; 
1580   *p++ = 3;
1581
1582   /* 2. Store another sequence. */
1583   p = store_tag_length (p, TAG_SEQUENCE, len[2]);
1584
1585   /* 3. Store the data OID. */
1586   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
1587   memcpy (p, oid_data, DIM (oid_data)); 
1588   p += DIM (oid_data); 
1589
1590   /* 4. Next comes a context tag. */
1591   p = store_tag_length (p, 0xa0, len[4]);
1592
1593   /* 5. And an octet string. */
1594   p = store_tag_length (p, TAG_OCTET_STRING, len[5]);
1595
1596   /* 6. And the inner sequence. */
1597   macstart = p;
1598   p = store_tag_length (p, TAG_SEQUENCE, len[6]);
1599
1600   /* 7. Append all the buffers. */
1601   for (i=0; sequences[i].buffer; i++)
1602     {
1603       memcpy (p, sequences[i].buffer, sequences[i].length);
1604       p += sequences[i].length;
1605     }
1606
1607   if (with_mac)
1608     {
1609       /* Intermezzo to compute the MAC. */
1610       maclen = p - macstart;
1611       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
1612       if (string_to_key (3, salt, 8, 2048, pw, 20, keybuf))
1613         {
1614           gcry_free (result);
1615           return NULL;
1616         }
1617       rc = gcry_md_open (&md, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
1618       if (rc)
1619         {
1620           log_error ("gcry_md_open failed: %s\n", gpg_strerror (rc));
1621           gcry_free (result);
1622           return NULL;
1623         }
1624       rc = gcry_md_setkey (md, keybuf, 20);
1625       if (rc)
1626         {
1627           log_error ("gcry_md_setkey failed: %s\n", gpg_strerror (rc));
1628           gcry_md_close (md);
1629           gcry_free (result);
1630           return NULL;
1631         }
1632       gcry_md_write (md, macstart, maclen);
1633
1634       /* 8. Append the MAC template and fix it up. */
1635       memcpy (p, data_mactemplate, DIM (data_mactemplate));
1636       memcpy (p + DATA_MACTEMPLATE_SALT_OFF, salt, 8);
1637       memcpy (p + DATA_MACTEMPLATE_MAC_OFF, gcry_md_read (md, 0), 20);
1638       p += DIM (data_mactemplate);
1639       gcry_md_close (md);
1640     }
1641
1642   /* Ready. */
1643   resultlen = p - result;
1644   if (needed != resultlen)
1645     log_debug ("length mismatch: %lu, %lu\n",
1646                (unsigned long)needed, (unsigned long)resultlen);
1647
1648   *r_length = resultlen;
1649   return result;
1650 }
1651
1652
1653 /* Build a DER encoded SEQUENCE with the key:
1654
1655    SEQUENCE {
1656      INTEGER 0
1657      SEQUENCE {
1658        OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
1659        NULL
1660        }
1661      OCTET STRING, encapsulates {
1662        SEQUENCE {
1663          INTEGER 0
1664          INTEGER
1665          INTEGER 
1666          INTEGER
1667          INTEGER
1668          INTEGER
1669          INTEGER
1670          INTEGER
1671          INTEGER
1672          }
1673        }
1674      }
1675 */  
1676   
1677 static unsigned char * 
1678 build_key_sequence (gcry_mpi_t *kparms, size_t *r_length)
1679 {
1680   int rc, i;
1681   size_t needed, n;
1682   unsigned char *plain, *p;
1683   size_t plainlen;
1684   size_t outseqlen, oidseqlen, octstrlen, inseqlen;
1685
1686   needed = 3; /* The version(?) integer of value 0. */
1687   for (i=0; kparms[i]; i++)
1688     {
1689       n = 0;
1690       rc = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, kparms[i]);
1691       if (rc)
1692         {
1693           log_error ("error formatting parameter: %s\n", gpg_strerror (rc));
1694           return NULL;
1695         }
1696       needed += n;
1697       n = compute_tag_length (n);
1698       if (!n)
1699         return NULL;
1700       needed += n;
1701     }
1702   if (i != 8)
1703     {
1704       log_error ("invalid paramters for p12_build\n");
1705       return NULL;
1706     }
1707   /* Now this all goes into a sequence. */
1708   inseqlen = needed;
1709   n = compute_tag_length (needed);
1710   if (!n)
1711     return NULL;
1712   needed += n;
1713   /* Encapsulate all into an octet string. */
1714   octstrlen = needed;
1715   n = compute_tag_length (needed);
1716   if (!n)
1717     return NULL;
1718   needed += n;
1719   /* Prepend the object identifier sequence. */
1720   oidseqlen = 2 + DIM (oid_rsaEncryption) + 2;
1721   needed += 2 + oidseqlen;
1722   /* The version number. */
1723   needed += 3;
1724   /* And finally put the whole thing into a sequence. */
1725   outseqlen = needed;
1726   n = compute_tag_length (needed);
1727   if (!n)
1728     return NULL;
1729   needed += n;
1730   
1731   /* allocate 8 extra bytes for padding */
1732   plain = gcry_malloc_secure (needed+8);
1733   if (!plain)
1734     {
1735       log_error ("error allocating encryption buffer\n");
1736       return NULL;
1737     }
1738   
1739   /* And now fill the plaintext buffer. */
1740   p = plain;
1741   p = store_tag_length (p, TAG_SEQUENCE, outseqlen);
1742   /* Store version. */
1743   *p++ = TAG_INTEGER;
1744   *p++ = 1;
1745   *p++ = 0;
1746   /* Store object identifier sequence. */
1747   p = store_tag_length (p, TAG_SEQUENCE, oidseqlen);
1748   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_rsaEncryption));
1749   memcpy (p, oid_rsaEncryption, DIM (oid_rsaEncryption)); 
1750   p += DIM (oid_rsaEncryption); 
1751   *p++ = TAG_NULL;
1752   *p++ = 0;
1753   /* Start with the octet string. */
1754   p = store_tag_length (p, TAG_OCTET_STRING, octstrlen);
1755   p = store_tag_length (p, TAG_SEQUENCE, inseqlen);
1756   /* Store the key parameters. */
1757   *p++ = TAG_INTEGER;
1758   *p++ = 1;
1759   *p++ = 0;
1760   for (i=0; kparms[i]; i++)
1761     {
1762       n = 0;
1763       rc = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, kparms[i]);
1764       if (rc)
1765         {
1766           log_error ("oops: error formatting parameter: %s\n",
1767                      gpg_strerror (rc));
1768           gcry_free (plain);
1769           return NULL;
1770         }
1771       p = store_tag_length (p, TAG_INTEGER, n);
1772       
1773       n = plain + needed - p;
1774       rc = gcry_mpi_print (GCRYMPI_FMT_STD, p, n, &n, kparms[i]);
1775       if (rc)
1776         {
1777           log_error ("oops: error storing parameter: %s\n",
1778                      gpg_strerror (rc));
1779           gcry_free (plain);
1780           return NULL;
1781         }
1782       p += n;
1783     }
1784
1785   plainlen = p - plain;
1786   assert (needed == plainlen);
1787   /* Append some pad characters; we already allocated extra space. */
1788   n = 8 - plainlen % 8;
1789   for (i=0; i < n; i++, plainlen++)
1790     *p++ = n;
1791
1792   *r_length = plainlen;
1793   return plain;
1794 }
1795
1796
1797
1798 static unsigned char *
1799 build_key_bag (unsigned char *buffer, size_t buflen, char *salt,
1800                const unsigned char *sha1hash, const char *keyidstr,
1801                size_t *r_length)
1802 {
1803   size_t len[11], needed;
1804   unsigned char *p, *keybag;
1805   size_t keybaglen;
1806
1807   /* Walk 11 steps down to collect the info: */
1808
1809   /* 10. The data goes into an octet string. */
1810   needed = compute_tag_length (buflen);
1811   needed += buflen;
1812
1813   /* 9. Prepend the algorithm identifier. */
1814   needed += DIM (data_3desiter2048);
1815
1816   /* 8. Put a sequence around. */
1817   len[8] = needed;
1818   needed += compute_tag_length (needed);
1819
1820   /* 7. Prepend a [0] tag. */
1821   len[7] = needed;
1822   needed += compute_tag_length (needed);
1823
1824   /* 6b. The attributes which are appended at the end. */
1825   if (sha1hash)
1826     needed += DIM (data_attrtemplate) + 20;
1827
1828   /* 6. Prepend the shroudedKeyBag OID. */
1829   needed += 2 + DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag);
1830
1831   /* 5+4. Put all into two sequences. */
1832   len[5] = needed;
1833   needed += compute_tag_length ( needed);
1834   len[4] = needed;
1835   needed += compute_tag_length (needed);
1836
1837   /* 3. This all goes into an octet string. */
1838   len[3] = needed;
1839   needed += compute_tag_length (needed);
1840
1841   /* 2. Prepend another [0] tag. */
1842   len[2] = needed;
1843   needed += compute_tag_length (needed);
1844
1845   /* 1. Prepend the data OID. */
1846   needed += 2 + DIM (oid_data);
1847
1848   /* 0. Prepend another sequence. */
1849   len[0] = needed;
1850   needed += compute_tag_length (needed);
1851
1852   /* Now that we have all length information, allocate a buffer. */
1853   p = keybag = gcry_malloc (needed);
1854   if (!keybag)
1855     {
1856       log_error ("error allocating buffer\n");
1857       return NULL;
1858     }
1859
1860   /* Walk 11 steps up to store the data. */
1861
1862   /* 0. Store the first sequence. */
1863   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1864
1865   /* 1. Store the data OID. */
1866   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
1867   memcpy (p, oid_data, DIM (oid_data)); 
1868   p += DIM (oid_data); 
1869
1870   /* 2. Store a [0] tag. */
1871   p = store_tag_length (p, 0xa0, len[2]);
1872
1873   /* 3. And an octet string. */
1874   p = store_tag_length (p, TAG_OCTET_STRING, len[3]);
1875
1876   /* 4+5. Two sequences. */
1877   p = store_tag_length (p, TAG_SEQUENCE, len[4]);
1878   p = store_tag_length (p, TAG_SEQUENCE, len[5]);
1879
1880   /* 6. Store the shroudedKeyBag OID. */
1881   p = store_tag_length (p, TAG_OBJECT_ID,
1882                         DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag));
1883   memcpy (p, oid_pkcs_12_pkcs_8ShroudedKeyBag,
1884           DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag)); 
1885   p += DIM (oid_pkcs_12_pkcs_8ShroudedKeyBag); 
1886
1887   /* 7. Store a [0] tag. */
1888   p = store_tag_length (p, 0xa0, len[7]);
1889
1890   /* 8. Store a sequence. */
1891   p = store_tag_length (p, TAG_SEQUENCE, len[8]);
1892
1893   /* 9. Now for the pre-encoded algorithm identifier and the salt. */
1894   memcpy (p, data_3desiter2048, DIM (data_3desiter2048));
1895   memcpy (p + DATA_3DESITER2048_SALT_OFF, salt, 8);
1896   p += DIM (data_3desiter2048);
1897
1898   /* 10. And the octet string with the encrypted data. */
1899   p = store_tag_length (p, TAG_OCTET_STRING, buflen);
1900   memcpy (p, buffer, buflen);
1901   p += buflen;
1902
1903   /* Append the attributes whose length we calculated at step 2b. */
1904   if (sha1hash)
1905     {
1906       int i;
1907
1908       memcpy (p, data_attrtemplate, DIM (data_attrtemplate));
1909       for (i=0; i < 8; i++)
1910         p[DATA_ATTRTEMPLATE_KEYID_OFF+2*i+1] = keyidstr[i];
1911       p += DIM (data_attrtemplate);
1912       memcpy (p, sha1hash, 20);
1913       p += 20;
1914     }
1915
1916
1917   keybaglen = p - keybag;
1918   if (needed != keybaglen)
1919     log_debug ("length mismatch: %lu, %lu\n",
1920                (unsigned long)needed, (unsigned long)keybaglen);
1921   
1922   *r_length = keybaglen;
1923   return keybag;
1924 }
1925
1926
1927 static unsigned char *
1928 build_cert_bag (unsigned char *buffer, size_t buflen, char *salt,
1929                 size_t *r_length)
1930 {
1931   size_t len[9], needed;
1932   unsigned char *p, *certbag;
1933   size_t certbaglen;
1934
1935   /* Walk 9 steps down to collect the info: */
1936
1937   /* 8. The data goes into an octet string. */
1938   needed = compute_tag_length (buflen);
1939   needed += buflen;
1940
1941   /* 7. The algorithm identifier. */
1942   needed += DIM (data_rc2iter2048);
1943
1944   /* 6. The data OID. */
1945   needed += 2 + DIM (oid_data);
1946
1947   /* 5. A sequence. */
1948   len[5] = needed;
1949   needed += compute_tag_length ( needed);
1950
1951   /* 4. An integer. */
1952   needed += 3;
1953
1954   /* 3. A sequence. */
1955   len[3] = needed;
1956   needed += compute_tag_length (needed);
1957
1958   /* 2.  A [0] tag. */
1959   len[2] = needed;
1960   needed += compute_tag_length (needed);
1961
1962   /* 1. The encryptedData OID. */
1963   needed += 2 + DIM (oid_encryptedData);
1964
1965   /* 0. The first sequence. */
1966   len[0] = needed;
1967   needed += compute_tag_length (needed);
1968
1969   /* Now that we have all length information, allocate a buffer. */
1970   p = certbag = gcry_malloc (needed);
1971   if (!certbag)
1972     {
1973       log_error ("error allocating buffer\n");
1974       return NULL;
1975     }
1976
1977   /* Walk 9 steps up to store the data. */
1978
1979   /* 0. Store the first sequence. */
1980   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
1981
1982   /* 1. Store the encryptedData OID. */
1983   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_encryptedData));
1984   memcpy (p, oid_encryptedData, DIM (oid_encryptedData)); 
1985   p += DIM (oid_encryptedData); 
1986
1987   /* 2. Store a [0] tag. */
1988   p = store_tag_length (p, 0xa0, len[2]);
1989
1990   /* 3. Store a sequence. */
1991   p = store_tag_length (p, TAG_SEQUENCE, len[3]);
1992
1993   /* 4. Store the integer 0. */
1994   *p++ = TAG_INTEGER;
1995   *p++ = 1; 
1996   *p++ = 0;
1997
1998   /* 5. Store a sequence. */
1999   p = store_tag_length (p, TAG_SEQUENCE, len[5]);
2000
2001   /* 6. Store the data OID. */
2002   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_data));
2003   memcpy (p, oid_data, DIM (oid_data)); 
2004   p += DIM (oid_data); 
2005
2006   /* 7. Now for the pre-encoded algorithm identifier and the salt. */
2007   memcpy (p, data_rc2iter2048, DIM (data_rc2iter2048));
2008   memcpy (p + DATA_RC2ITER2048_SALT_OFF, salt, 8);
2009   p += DIM (data_rc2iter2048);
2010
2011   /* 8. And finally the [0] tag with the encrypted data. */
2012   p = store_tag_length (p, 0x80, buflen);
2013   memcpy (p, buffer, buflen);
2014   p += buflen;
2015   certbaglen = p - certbag;
2016   
2017   if (needed != certbaglen)
2018     log_debug ("length mismatch: %lu, %lu\n",
2019                (unsigned long)needed, (unsigned long)certbaglen);
2020
2021   *r_length = certbaglen;
2022   return certbag;
2023 }
2024
2025
2026 static unsigned char *
2027 build_cert_sequence (unsigned char *buffer, size_t buflen, 
2028                      const unsigned char *sha1hash, const char *keyidstr,
2029                      size_t *r_length)
2030 {
2031   size_t len[8], needed, n;
2032   unsigned char *p, *certseq;
2033   size_t certseqlen;
2034   int i;
2035
2036   assert (strlen (keyidstr) == 8);
2037
2038   /* Walk 8 steps down to collect the info: */
2039
2040   /* 7. The data goes into an octet string. */
2041   needed = compute_tag_length (buflen);
2042   needed += buflen;
2043
2044   /* 6. A [0] tag. */
2045   len[6] = needed;
2046   needed += compute_tag_length (needed);
2047
2048   /* 5. An OID. */
2049   needed += 2 + DIM (oid_x509Certificate_for_pkcs_12);
2050
2051   /* 4. A sequence. */
2052   len[4] = needed;
2053   needed += compute_tag_length (needed);
2054
2055   /* 3. A [0] tag. */
2056   len[3] = needed;
2057   needed += compute_tag_length (needed);
2058
2059   /* 2b. The attributes which are appended at the end. */
2060   if (sha1hash)
2061     needed += DIM (data_attrtemplate) + 20;
2062
2063   /* 2. An OID. */
2064   needed += 2 + DIM (oid_pkcs_12_CertBag);
2065
2066   /* 1. A sequence. */
2067   len[1] = needed;
2068   needed += compute_tag_length (needed);
2069
2070   /* 0. The first sequence. */
2071   len[0] = needed;
2072   needed += compute_tag_length (needed);
2073
2074   /* Now that we have all length information, allocate a buffer. */
2075   p = certseq = gcry_malloc (needed + 8 /*(for padding)*/);
2076   if (!certseq)
2077     {
2078       log_error ("error allocating buffer\n");
2079       return NULL;
2080     }
2081
2082   /* Walk 8 steps up to store the data. */
2083
2084   /* 0. Store the first sequence. */
2085   p = store_tag_length (p, TAG_SEQUENCE, len[0]);
2086
2087   /* 1. Store the second sequence. */
2088   p = store_tag_length (p, TAG_SEQUENCE, len[1]);
2089
2090   /* 2. Store the pkcs12-cert-bag OID. */
2091   p = store_tag_length (p, TAG_OBJECT_ID, DIM (oid_pkcs_12_CertBag));
2092   memcpy (p, oid_pkcs_12_CertBag, DIM (oid_pkcs_12_CertBag)); 
2093   p += DIM (oid_pkcs_12_CertBag); 
2094
2095   /* 3. Store a [0] tag. */
2096   p = store_tag_length (p, 0xa0, len[3]);
2097
2098   /* 4. Store a sequence. */
2099   p = store_tag_length (p, TAG_SEQUENCE, len[4]);
2100
2101   /* 5. Store the x509Certificate OID. */
2102   p = store_tag_length (p, TAG_OBJECT_ID,
2103                         DIM (oid_x509Certificate_for_pkcs_12));
2104   memcpy (p, oid_x509Certificate_for_pkcs_12,
2105           DIM (oid_x509Certificate_for_pkcs_12)); 
2106   p += DIM (oid_x509Certificate_for_pkcs_12); 
2107
2108   /* 6. Store a [0] tag. */
2109   p = store_tag_length (p, 0xa0, len[6]);
2110
2111   /* 7. And the octet string with the actual certificate. */
2112   p = store_tag_length (p, TAG_OCTET_STRING, buflen);
2113   memcpy (p, buffer, buflen);
2114   p += buflen;
2115   
2116   /* Append the attributes whose length we calculated at step 2b. */
2117   if (sha1hash)
2118     {
2119       memcpy (p, data_attrtemplate, DIM (data_attrtemplate));
2120       for (i=0; i < 8; i++)
2121         p[DATA_ATTRTEMPLATE_KEYID_OFF+2*i+1] = keyidstr[i];
2122       p += DIM (data_attrtemplate);
2123       memcpy (p, sha1hash, 20);
2124       p += 20;
2125     }
2126
2127   certseqlen = p - certseq;
2128   if (needed != certseqlen)
2129     log_debug ("length mismatch: %lu, %lu\n",
2130                (unsigned long)needed, (unsigned long)certseqlen);
2131
2132   /* Append some pad characters; we already allocated extra space. */
2133   n = 8 - certseqlen % 8;
2134   for (i=0; i < n; i++, certseqlen++)
2135     *p++ = n;
2136   
2137   *r_length = certseqlen;
2138   return certseq;
2139 }
2140
2141
2142 /* Expect the RSA key parameters in KPARMS and a password in
2143    PW. Create a PKCS structure from it and return it as well as the
2144    length in R_LENGTH; return NULL in case of an error. */
2145 unsigned char * 
2146 p12_build (gcry_mpi_t *kparms, unsigned char *cert, size_t certlen,
2147            const char *pw, size_t *r_length)
2148 {
2149   unsigned char *buffer;
2150   size_t n, buflen;
2151   char salt[8];
2152   struct buffer_s seqlist[3];
2153   int seqlistidx = 0;
2154   unsigned char sha1hash[20];
2155   char keyidstr[8+1];
2156
2157   n = buflen = 0; /* (avoid compiler warning). */
2158   memset (sha1hash, 0, 20);
2159   *keyidstr = 0;
2160
2161   if (cert && certlen)
2162     {
2163       /* Calculate the hash value we need for the bag attributes. */
2164       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash, cert, certlen);
2165       sprintf (keyidstr, "%02x%02x%02x%02x",
2166                sha1hash[16], sha1hash[17], sha1hash[18], sha1hash[19]);
2167
2168       /* Encode the certificate. */
2169       buffer = build_cert_sequence (cert, certlen, sha1hash, keyidstr,
2170                                     &buflen);
2171       if (!buffer)
2172         goto failure;
2173
2174       /* Encrypt it. */
2175       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2176       crypt_block (buffer, buflen, salt, 8, 2048, pw,
2177                    GCRY_CIPHER_RFC2268_40, 1);
2178       
2179       /* Encode the encrypted stuff into a bag. */
2180       seqlist[seqlistidx].buffer = build_cert_bag (buffer, buflen, salt, &n);
2181       seqlist[seqlistidx].length = n;
2182       gcry_free (buffer);
2183       buffer = NULL;
2184       if (!seqlist[seqlistidx].buffer)
2185         goto failure;
2186       seqlistidx++;
2187     }
2188
2189
2190   if (kparms)
2191     {
2192       /* Encode the key. */
2193       buffer = build_key_sequence (kparms, &buflen);
2194       if (!buffer)
2195         goto failure;
2196       
2197       /* Encrypt it. */
2198       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2199       crypt_block (buffer, buflen, salt, 8, 2048, pw, GCRY_CIPHER_3DES, 1);
2200
2201       /* Encode the encrypted stuff into a bag. */
2202       if (cert && certlen)
2203         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt, 
2204                                                     sha1hash, keyidstr, &n);
2205       else
2206         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt,
2207                                                     NULL, NULL, &n);
2208       seqlist[seqlistidx].length = n;
2209       gcry_free (buffer);
2210       buffer = NULL;
2211       if (!seqlist[seqlistidx].buffer)
2212         goto failure;
2213       seqlistidx++;
2214     }
2215
2216   seqlist[seqlistidx].buffer = NULL;
2217   seqlist[seqlistidx].length = 0;
2218
2219   buffer = create_final (seqlist, pw, &buflen);
2220
2221  failure:
2222   for ( ; seqlistidx; seqlistidx--)
2223     gcry_free (seqlist[seqlistidx].buffer);
2224
2225   *r_length = buffer? buflen : 0;
2226   return buffer;
2227 }
2228
2229
2230 #ifdef TEST
2231
2232 static void 
2233 cert_cb (void *opaque, const unsigned char *cert, size_t certlen)
2234 {
2235   printf ("got a certificate of %u bytes length\n", certlen);
2236 }
2237
2238 int
2239 main (int argc, char **argv)
2240 {
2241   FILE *fp;
2242   struct stat st;
2243   unsigned char *buf;
2244   size_t buflen;
2245   gcry_mpi_t *result;
2246
2247   if (argc != 3)
2248     {
2249       fprintf (stderr, "usage: testp12 file passphrase\n");
2250       return 1;
2251     }
2252
2253   gcry_control (GCRYCTL_DISABLE_SECMEM, NULL);
2254   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL);
2255
2256   fp = fopen (argv[1], "rb");
2257   if (!fp)
2258     {
2259       fprintf (stderr, "can't open `%s': %s\n", argv[1], strerror (errno));
2260       return 1;
2261     }
2262   
2263   if (fstat (fileno(fp), &st))
2264     {
2265       fprintf (stderr, "can't stat `%s': %s\n", argv[1], strerror (errno));
2266       return 1;
2267     }
2268
2269   buflen = st.st_size;
2270   buf = gcry_malloc (buflen+1);
2271   if (!buf || fread (buf, buflen, 1, fp) != 1)
2272     {
2273       fprintf (stderr, "error reading `%s': %s\n", argv[1], strerror (errno));
2274       return 1;
2275     }
2276   fclose (fp);
2277
2278   result = p12_parse (buf, buflen, argv[2], cert_cb, NULL);
2279   if (result)
2280     {
2281       int i, rc;
2282       unsigned char *tmpbuf;
2283
2284       for (i=0; result[i]; i++)
2285         {
2286           rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &tmpbuf,
2287                                 NULL, result[i]);
2288           if (rc)
2289             printf ("%d: [error printing number: %s]\n",
2290                     i, gpg_strerror (rc));
2291           else
2292             {
2293               printf ("%d: %s\n", i, tmpbuf);
2294               gcry_free (tmpbuf);
2295             }
2296         }
2297     }
2298
2299   return 0;
2300
2301 }
2302
2303 /*
2304 Local Variables:
2305 compile-command: "gcc -Wall -O0 -g -DTEST=1 -o minip12 minip12.c ../jnlib/libjnlib.a -L /usr/local/lib -lgcrypt -lgpg-error"
2306 End:
2307 */
2308 #endif /* TEST */