Avoid using the protect-tool to import pkcs#12.
[gnupg.git] / sm / 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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <gcrypt.h>
28 #include <errno.h>
29
30 #ifdef TEST
31 #include <sys/stat.h>
32 #include <unistd.h>
33 #endif
34
35 #include "../common/logging.h"
36 #include "../common/utf8conv.h"
37 #include "minip12.h"
38
39 #ifndef DIM
40 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
41 #endif
42
43
44 enum
45 {
46   UNIVERSAL = 0,
47   APPLICATION = 1,
48   ASNCONTEXT = 2,
49   PRIVATE = 3
50 };
51
52
53 enum
54 {
55   TAG_NONE = 0,
56   TAG_BOOLEAN = 1,
57   TAG_INTEGER = 2,
58   TAG_BIT_STRING = 3,
59   TAG_OCTET_STRING = 4,
60   TAG_NULL = 5,
61   TAG_OBJECT_ID = 6,
62   TAG_OBJECT_DESCRIPTOR = 7,
63   TAG_EXTERNAL = 8,
64   TAG_REAL = 9,
65   TAG_ENUMERATED = 10,
66   TAG_EMBEDDED_PDV = 11,
67   TAG_UTF8_STRING = 12,
68   TAG_REALTIVE_OID = 13,
69   TAG_SEQUENCE = 16,
70   TAG_SET = 17,
71   TAG_NUMERIC_STRING = 18,
72   TAG_PRINTABLE_STRING = 19,
73   TAG_TELETEX_STRING = 20,
74   TAG_VIDEOTEX_STRING = 21,
75   TAG_IA5_STRING = 22,
76   TAG_UTC_TIME = 23,
77   TAG_GENERALIZED_TIME = 24,
78   TAG_GRAPHIC_STRING = 25,
79   TAG_VISIBLE_STRING = 26,
80   TAG_GENERAL_STRING = 27,
81   TAG_UNIVERSAL_STRING = 28,
82   TAG_CHARACTER_STRING = 29,
83   TAG_BMP_STRING = 30
84 };
85
86
87 static unsigned char const oid_data[9] = {
88   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
89 static unsigned char const oid_encryptedData[9] = {
90   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x06 };
91 static unsigned char const oid_pkcs_12_keyBag[11] = {
92   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x01 };
93 static unsigned char const oid_pkcs_12_pkcs_8ShroudedKeyBag[11] = {
94   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x02 };
95 static unsigned char const oid_pkcs_12_CertBag[11] = {
96   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x03 };
97 static unsigned char const oid_pkcs_12_CrlBag[11] = {
98   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x0A, 0x01, 0x04 };
99
100 static unsigned char const oid_pbeWithSHAAnd3_KeyTripleDES_CBC[10] = {
101   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03 };
102 static unsigned char const oid_pbeWithSHAAnd40BitRC2_CBC[10] = {
103   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x06 };
104 static unsigned char const oid_x509Certificate_for_pkcs_12[10] = {
105   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x16, 0x01 };
106
107
108 static unsigned char const oid_rsaEncryption[9] = {
109   0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 };
110
111
112 static unsigned char const data_3desiter2048[30] = {
113   0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, 0x86,
114   0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x03, 0x30, 0x0E, 
115   0x04, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
116   0xFF, 0xFF, 0x02, 0x02, 0x08, 0x00 };
117 #define DATA_3DESITER2048_SALT_OFF  18
118
119 static unsigned char const data_rc2iter2048[30] = {
120   0x30, 0x1C, 0x06, 0x0A, 0x2A, 0x86, 0x48, 0x86,
121   0xF7, 0x0D, 0x01, 0x0C, 0x01, 0x06, 0x30, 0x0E, 
122   0x04, 0x08, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
123   0xFF, 0xFF, 0x02, 0x02, 0x08, 0x00 };
124 #define DATA_RC2ITER2048_SALT_OFF  18
125
126 static unsigned char const data_mactemplate[51] = {
127   0x30, 0x31, 0x30, 0x21, 0x30, 0x09, 0x06, 0x05,
128   0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04,
129   0x14, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
130   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
131   0xff, 0xff, 0xff, 0xff, 0xff, 0x04, 0x08, 0xff,
132   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x02,
133   0x02, 0x08, 0x00 }; 
134 #define DATA_MACTEMPLATE_MAC_OFF 17
135 #define DATA_MACTEMPLATE_SALT_OFF 39
136
137 static unsigned char const data_attrtemplate[106] = {
138   0x31, 0x7c, 0x30, 0x55, 0x06, 0x09, 0x2a, 0x86,
139   0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x14, 0x31,
140   0x48, 0x1e, 0x46, 0x00, 0x47, 0x00, 0x6e, 0x00,
141   0x75, 0x00, 0x50, 0x00, 0x47, 0x00, 0x20, 0x00,
142   0x65, 0x00, 0x78, 0x00, 0x70, 0x00, 0x6f, 0x00,
143   0x72, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00,
144   0x20, 0x00, 0x63, 0x00, 0x65, 0x00, 0x72, 0x00,
145   0x74, 0x00, 0x69, 0x00, 0x66, 0x00, 0x69, 0x00,
146   0x63, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00,
147   0x20, 0x00, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00,
148   0x66, 0x00, 0x66, 0x00, 0x66, 0x00, 0x66, 0x00,
149   0x66, 0x30, 0x23, 0x06, 0x09, 0x2a, 0x86, 0x48,
150   0x86, 0xf7, 0x0d, 0x01, 0x09, 0x15, 0x31, 0x16,
151   0x04, 0x14 }; /* Need to append SHA-1 digest. */
152 #define DATA_ATTRTEMPLATE_KEYID_OFF 73
153
154 struct buffer_s 
155 {
156   unsigned char *buffer;
157   size_t length;
158 };  
159
160
161 struct tag_info 
162 {
163   int class;
164   int is_constructed;
165   unsigned long tag;
166   unsigned long length;  /* length part of the TLV */
167   int nhdr;
168   int ndef;              /* It is an indefinite length */
169 };
170
171
172 /* Parse the buffer at the address BUFFER which is of SIZE and return
173    the tag and the length part from the TLV triplet.  Update BUFFER
174    and SIZE on success.  Checks that the encoded length does not
175    exhaust the length of the provided buffer. */
176 static int 
177 parse_tag (unsigned char const **buffer, size_t *size, struct tag_info *ti)
178 {
179   int c;
180   unsigned long tag;
181   const unsigned char *buf = *buffer;
182   size_t length = *size;
183
184   ti->length = 0;
185   ti->ndef = 0;
186   ti->nhdr = 0;
187
188   /* Get the tag */
189   if (!length)
190     return -1; /* premature eof */
191   c = *buf++; length--;
192   ti->nhdr++;
193
194   ti->class = (c & 0xc0) >> 6;
195   ti->is_constructed = !!(c & 0x20);
196   tag = c & 0x1f;
197
198   if (tag == 0x1f)
199     {
200       tag = 0;
201       do
202         {
203           tag <<= 7;
204           if (!length)
205             return -1; /* premature eof */
206           c = *buf++; length--;
207           ti->nhdr++;
208           tag |= c & 0x7f;
209         }
210       while (c & 0x80);
211     }
212   ti->tag = tag;
213
214   /* Get the length */
215   if (!length)
216     return -1; /* prematureeof */
217   c = *buf++; length--;
218   ti->nhdr++;
219
220   if ( !(c & 0x80) )
221     ti->length = c;
222   else if (c == 0x80)
223     ti->ndef = 1;
224   else if (c == 0xff)
225     return -1; /* forbidden length value */
226   else
227     {
228       unsigned long len = 0;
229       int count = c & 0x7f;
230
231       for (; count; count--)
232         {
233           len <<= 8;
234           if (!length)
235             return -1; /* premature_eof */
236           c = *buf++; length--;
237           ti->nhdr++;
238           len |= c & 0xff;
239         }
240       ti->length = len;
241     }
242   
243   if (ti->class == UNIVERSAL && !ti->tag)
244     ti->length = 0;
245
246   if (ti->length > length)
247     return -1; /* data larger than buffer. */
248   
249   *buffer = buf;
250   *size = length;
251   return 0;
252 }
253
254
255 /* Given an ASN.1 chunk of a structure like:
256
257      24 NDEF:       OCTET STRING  -- This is not passed to us
258      04    1:         OCTET STRING  -- INPUT point s to here
259             :           30
260      04    1:         OCTET STRING
261             :           80
262           [...]
263      04    2:         OCTET STRING
264             :           00 00
265             :         } -- This denotes a Null tag and are the last 
266                         -- two bytes in INPUT.
267    
268    Create a new buffer with the content of that octet string.  INPUT
269    is the orginal buffer with a length as stored at LENGTH.  Returns
270    NULL on error or a new malloced buffer with the length of this new
271    buffer stored at LENGTH and the number of bytes parsed from input
272    are added to the value stored at INPUT_CONSUMED.  INPUT_CONSUMED is
273    allowed to be passed as NULL if the caller is not interested in
274    this value. */
275 static unsigned char *
276 cram_octet_string (const unsigned char *input, size_t *length,
277                    size_t *input_consumed)
278 {
279   const unsigned char *s = input;
280   size_t n = *length;
281   unsigned char *output, *d;
282   struct tag_info ti;
283
284   /* Allocate output buf.  We know that it won't be longer than the
285      input buffer. */
286   d = output = gcry_malloc (n);
287   if (!output)
288     goto bailout;
289
290   for (;;)
291     {
292       if (parse_tag (&s, &n, &ti))
293         goto bailout;
294       if (ti.class == UNIVERSAL && ti.tag == TAG_OCTET_STRING 
295           && !ti.ndef && !ti.is_constructed)
296         {
297           memcpy (d, s, ti.length);
298           s += ti.length;
299           d += ti.length;
300           n -= ti.length;
301         }
302       else if (ti.class == UNIVERSAL && !ti.tag && !ti.is_constructed)
303         break; /* Ready */ 
304       else
305         goto bailout;
306     }
307
308
309   *length = d - output;
310   if (input_consumed)
311     *input_consumed += s - input;
312   return output;
313
314  bailout:
315   if (input_consumed)
316     *input_consumed += s - input;
317   gcry_free (output);
318   return NULL;
319 }
320
321
322
323 static int 
324 string_to_key (int id, char *salt, size_t saltlen, int iter, const char *pw,
325                int req_keylen, unsigned char *keybuf)
326 {
327   int rc, i, j;
328   gcry_md_hd_t md;
329   gcry_mpi_t num_b1 = NULL;
330   int pwlen;
331   unsigned char hash[20], buf_b[64], buf_i[128], *p;
332   size_t cur_keylen;
333   size_t n;
334
335   cur_keylen = 0;
336   pwlen = strlen (pw);
337   if (pwlen > 63/2)
338     {
339       log_error ("password too long\n");
340       return -1;
341     }
342
343   if (saltlen < 8)
344     {
345       log_error ("salt too short\n");
346       return -1;
347     }
348   
349   /* Store salt and password in BUF_I */
350   p = buf_i;
351   for(i=0; i < 64; i++)
352     *p++ = salt [i%saltlen];
353   for(i=j=0; i < 64; i += 2)
354     {
355       *p++ = 0;
356       *p++ = pw[j];
357       if (++j > pwlen) /* Note, that we include the trailing zero */
358         j = 0;
359     }
360
361   for (;;)
362     {
363       rc = gcry_md_open (&md, GCRY_MD_SHA1, 0);
364       if (rc)
365         {
366           log_error ( "gcry_md_open failed: %s\n", gpg_strerror (rc));
367           return rc;
368         }
369       for(i=0; i < 64; i++)
370         gcry_md_putc (md, id);
371       gcry_md_write (md, buf_i, 128);
372       memcpy (hash, gcry_md_read (md, 0), 20);
373       gcry_md_close (md);
374       for (i=1; i < iter; i++)
375         gcry_md_hash_buffer (GCRY_MD_SHA1, hash, hash, 20);
376
377       for (i=0; i < 20 && cur_keylen < req_keylen; i++)
378         keybuf[cur_keylen++] = hash[i];
379       if (cur_keylen == req_keylen)
380         {
381           gcry_mpi_release (num_b1);
382           return 0; /* ready */
383         }
384       
385       /* need more bytes. */
386       for(i=0; i < 64; i++)
387         buf_b[i] = hash[i % 20];
388       rc = gcry_mpi_scan (&num_b1, GCRYMPI_FMT_USG, buf_b, 64, &n);
389       if (rc)
390         {
391           log_error ( "gcry_mpi_scan failed: %s\n", gpg_strerror (rc));
392           return -1;
393         }
394       gcry_mpi_add_ui (num_b1, num_b1, 1);
395       for (i=0; i < 128; i += 64)
396         {
397           gcry_mpi_t num_ij;
398
399           rc = gcry_mpi_scan (&num_ij, GCRYMPI_FMT_USG, buf_i + i, 64, &n);
400           if (rc)
401             {
402               log_error ( "gcry_mpi_scan failed: %s\n",
403                        gpg_strerror (rc));
404               return -1;
405             }
406           gcry_mpi_add (num_ij, num_ij, num_b1);
407           gcry_mpi_clear_highbit (num_ij, 64*8);
408           rc = gcry_mpi_print (GCRYMPI_FMT_USG, buf_i + i, 64, &n, num_ij);
409           if (rc)
410             {
411               log_error ( "gcry_mpi_print failed: %s\n",
412                           gpg_strerror (rc));
413               return -1;
414             }
415           gcry_mpi_release (num_ij);
416         }
417     }
418 }
419
420
421 static int 
422 set_key_iv (gcry_cipher_hd_t chd, char *salt, size_t saltlen, int iter,
423             const char *pw, int keybytes)
424 {
425   unsigned char keybuf[24];
426   int rc;
427
428   assert (keybytes == 5 || keybytes == 24);
429   if (string_to_key (1, salt, saltlen, iter, pw, keybytes, keybuf))
430     return -1;
431   rc = gcry_cipher_setkey (chd, keybuf, keybytes);
432   if (rc)
433     {
434       log_error ( "gcry_cipher_setkey failed: %s\n", gpg_strerror (rc));
435       return -1;
436     }
437
438   if (string_to_key (2, salt, saltlen, iter, pw, 8, keybuf))
439     return -1;
440   rc = gcry_cipher_setiv (chd, keybuf, 8);
441   if (rc)
442     {
443       log_error ("gcry_cipher_setiv failed: %s\n", gpg_strerror (rc));
444       return -1;
445     }
446   return 0;
447 }
448
449
450 static void
451 crypt_block (unsigned char *buffer, size_t length, char *salt, size_t saltlen,
452              int iter, const char *pw, int cipher_algo, int encrypt)
453 {
454   gcry_cipher_hd_t chd;
455   int rc;
456
457   rc = gcry_cipher_open (&chd, cipher_algo, GCRY_CIPHER_MODE_CBC, 0); 
458   if (rc)
459     {
460       log_error ( "gcry_cipher_open failed: %s\n", gpg_strerror(rc));
461       wipememory (buffer, length);
462       return;
463     }
464   if (set_key_iv (chd, salt, saltlen, iter, pw,
465                   cipher_algo == GCRY_CIPHER_RFC2268_40? 5:24))
466     {
467       wipememory (buffer, length);
468       goto leave;
469     }
470
471   rc = encrypt? gcry_cipher_encrypt (chd, buffer, length, NULL, 0)
472               : gcry_cipher_decrypt (chd, buffer, length, NULL, 0);
473
474   if (rc)
475     {
476       wipememory (buffer, length);
477       log_error ( "en/de-crytion failed: %s\n", gpg_strerror (rc));
478       goto leave;
479     }
480
481  leave:
482   gcry_cipher_close (chd);
483 }
484   
485
486 /* Decrypt a block of data and try several encodings of the key.
487    CIPHERTEXT is the encrypted data of size LENGTH bytes; PLAINTEXT is
488    a buffer of the same size to receive the decryption result. SALT,
489    SALTLEN, ITER and PW are the information required for decryption
490    and CIPHER_ALGO is the algorithm id to use.  CHECK_FNC is a
491    function called with the plaintext and used to check whether the
492    decryption succeeded; i.e. that a correct passphrase has been
493    given.  That function shall return true if the decryption has likely
494    succeeded. */
495 static void
496 decrypt_block (const void *ciphertext, unsigned char *plaintext, size_t length,
497                char *salt, size_t saltlen,
498                int iter, const char *pw, int cipher_algo,
499                int (*check_fnc) (const void *, size_t))
500 {
501   static const char * const charsets[] = {
502     "",   /* No conversion - use the UTF-8 passphrase direct.  */
503     "ISO-8859-1",
504     "ISO-8859-15",
505     "ISO-8859-2",
506     "ISO-8859-3",
507     "ISO-8859-4",
508     "ISO-8859-5",
509     "ISO-8859-6",
510     "ISO-8859-7",
511     "ISO-8859-8",
512     "ISO-8859-9",
513     "KOI8-R",
514     "IBM437",
515     "IBM850",
516     "EUC-JP",
517     "BIG5",
518     NULL
519   };
520   int charsetidx = 0;
521   char *convertedpw = NULL;   /* Malloced and converted password or NULL.  */
522   size_t convertedpwsize = 0; /* Allocated length.  */
523
524   for (charsetidx=0; charsets[charsetidx]; charsetidx++)
525     {
526       if (*charsets[charsetidx])
527         {
528           jnlib_iconv_t cd;
529           const char *inptr;
530           char *outptr;
531           size_t inbytes, outbytes;
532
533           if (!convertedpw)
534             {
535               /* We assume one byte encodings.  Thus we can allocate
536                  the buffer of the same size as the original
537                  passphrase; the result will actually be shorter
538                  then.  */
539               convertedpwsize = strlen (pw) + 1;
540               convertedpw = gcry_malloc_secure (convertedpwsize);
541               if (!convertedpw)
542                 {
543                   log_info ("out of secure memory while"
544                             " converting passphrase\n");
545                   break; /* Give up.  */
546                 }
547             }
548
549           cd = jnlib_iconv_open (charsets[charsetidx], "utf-8");
550           if (cd == (jnlib_iconv_t)(-1))
551             continue;
552
553           inptr = pw;
554           inbytes = strlen (pw);
555           outptr = convertedpw;
556           outbytes = convertedpwsize - 1;
557           if ( jnlib_iconv (cd, (const char **)&inptr, &inbytes,
558                       &outptr, &outbytes) == (size_t)-1) 
559             {
560               jnlib_iconv_close (cd);
561               continue;
562             }
563           *outptr = 0;
564           jnlib_iconv_close (cd);
565           log_info ("decryption failed; trying charset `%s'\n",
566                     charsets[charsetidx]);
567         }
568       memcpy (plaintext, ciphertext, length);
569       crypt_block (plaintext, length, salt, saltlen, iter,
570                    convertedpw? convertedpw:pw, cipher_algo, 0);
571       if (check_fnc (plaintext, length))
572         break; /* Decryption succeeded. */
573     }
574   gcry_free (convertedpw);
575 }
576
577
578 /* Return true if the decryption of an bag_encrypted_data object has
579    likely succeeded.  */
580 static int
581 bag_decrypted_data_p (const void *plaintext, size_t length)
582 {
583   struct tag_info ti;
584   const unsigned char *p = plaintext;
585   size_t n = length;
586
587   /*   { */
588   /* #  warning debug code is enabled */
589   /*     FILE *fp = fopen ("tmp-rc2-plain.der", "wb"); */
590   /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
591   /*       exit (2); */
592   /*     fclose (fp); */
593   /*   } */
594   
595   if (parse_tag (&p, &n, &ti))
596     return 0;
597   if (ti.class || ti.tag != TAG_SEQUENCE)
598     return 0;
599   if (parse_tag (&p, &n, &ti))
600     return 0;
601
602   return 1; 
603 }
604
605 /* Note: If R_RESULT is passed as NULL, a key object as already be
606    processed and thus we need to skip it here. */
607 static int
608 parse_bag_encrypted_data (const unsigned char *buffer, size_t length,
609                           int startoffset, size_t *r_consumed, const char *pw,
610                           void (*certcb)(void*, const unsigned char*, size_t),
611                           void *certcbarg, gcry_mpi_t **r_result,
612                           int *r_badpass)
613 {
614   struct tag_info ti;
615   const unsigned char *p = buffer;
616   const unsigned char *p_start = buffer;
617   size_t n = length;
618   const char *where;
619   char salt[20];
620   size_t saltlen;
621   unsigned int iter;
622   unsigned char *plain = NULL;
623   int bad_pass = 0;
624   unsigned char *cram_buffer = NULL;
625   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
626   int is_3des = 0;
627   gcry_mpi_t *result = NULL;
628   int result_count;
629
630   if (r_result)
631     *r_result = NULL;
632   where = "start";
633   if (parse_tag (&p, &n, &ti))
634     goto bailout;
635   if (ti.class != ASNCONTEXT || ti.tag)
636     goto bailout;
637   if (parse_tag (&p, &n, &ti))
638     goto bailout;
639   if (ti.tag != TAG_SEQUENCE)
640     goto bailout;
641
642   where = "bag.encryptedData.version";
643   if (parse_tag (&p, &n, &ti))
644     goto bailout;
645   if (ti.tag != TAG_INTEGER || ti.length != 1 || *p != 0)
646     goto bailout;
647   p++; n--;
648   if (parse_tag (&p, &n, &ti))
649     goto bailout;
650   if (ti.tag != TAG_SEQUENCE)
651     goto bailout;
652
653   where = "bag.encryptedData.data";
654   if (parse_tag (&p, &n, &ti))
655     goto bailout;
656   if (ti.tag != TAG_OBJECT_ID || ti.length != DIM(oid_data)
657       || memcmp (p, oid_data, DIM(oid_data)))
658     goto bailout;
659   p += DIM(oid_data);
660   n -= DIM(oid_data);
661
662   where = "bag.encryptedData.keyinfo";
663   if (parse_tag (&p, &n, &ti))
664     goto bailout;
665   if (ti.class || ti.tag != TAG_SEQUENCE)
666     goto bailout;
667   if (parse_tag (&p, &n, &ti))
668     goto bailout;
669   if (!ti.class && ti.tag == TAG_OBJECT_ID 
670       && ti.length == DIM(oid_pbeWithSHAAnd40BitRC2_CBC)
671       && !memcmp (p, oid_pbeWithSHAAnd40BitRC2_CBC,
672                   DIM(oid_pbeWithSHAAnd40BitRC2_CBC)))
673     {
674       p += DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
675       n -= DIM(oid_pbeWithSHAAnd40BitRC2_CBC);
676     }
677   else if (!ti.class && ti.tag == TAG_OBJECT_ID 
678       && ti.length == DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
679       && !memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
680                   DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
681     {
682       p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
683       n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
684       is_3des = 1;
685     }
686   else
687     goto bailout;
688
689   where = "rc2or3des-params";
690   if (parse_tag (&p, &n, &ti))
691     goto bailout;
692   if (ti.class || ti.tag != TAG_SEQUENCE)
693     goto bailout;
694   if (parse_tag (&p, &n, &ti))
695     goto bailout;
696   if (ti.class || ti.tag != TAG_OCTET_STRING
697       || ti.length < 8 || ti.length > 20 )
698     goto bailout;
699   saltlen = ti.length;
700   memcpy (salt, p, saltlen);
701   p += saltlen;
702   n -= saltlen;
703   if (parse_tag (&p, &n, &ti))
704     goto bailout;
705   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
706     goto bailout;
707   for (iter=0; ti.length; ti.length--)
708     {
709       iter <<= 8;
710       iter |= (*p++) & 0xff; 
711       n--;
712     }
713   
714   where = "rc2or3des-ciphertext";
715   if (parse_tag (&p, &n, &ti))
716     goto bailout;
717
718   consumed = p - p_start;
719   if (ti.class == ASNCONTEXT && ti.tag == 0 && ti.is_constructed && ti.ndef)
720     {
721       /* Mozilla exported certs now come with single byte chunks of
722          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
723       where = "cram-rc2or3des-ciphertext";
724       cram_buffer = cram_octet_string ( p, &n, &consumed);
725       if (!cram_buffer)
726         goto bailout;
727       p = p_start = cram_buffer;
728       if (r_consumed)
729         *r_consumed = consumed;
730       r_consumed = NULL; /* Ugly hack to not update that value any further. */
731       ti.length = n;
732     }
733   else if (ti.class == ASNCONTEXT && ti.tag == 0 && ti.length )
734     ;
735   else
736     goto bailout;
737   
738   log_info ("%lu bytes of %s encrypted text\n",ti.length,is_3des?"3DES":"RC2");
739
740   plain = gcry_malloc_secure (ti.length);
741   if (!plain)
742     {
743       log_error ("error allocating decryption buffer\n");
744       goto bailout;
745     }
746   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
747                  is_3des? GCRY_CIPHER_3DES : GCRY_CIPHER_RFC2268_40, 
748                  bag_decrypted_data_p);
749   n = ti.length;
750   startoffset = 0;
751   p_start = p = plain;
752
753   where = "outer.outer.seq";
754   if (parse_tag (&p, &n, &ti))
755     {
756       bad_pass = 1;
757       goto bailout;
758     }
759   if (ti.class || ti.tag != TAG_SEQUENCE)
760     {
761       bad_pass = 1;
762       goto bailout;
763     }
764
765   if (parse_tag (&p, &n, &ti))
766     {
767       bad_pass = 1;
768       goto bailout;
769     }
770
771   /* Loop over all certificates inside the bag. */
772   while (n)
773     {
774       int iscrlbag = 0;
775       int iskeybag = 0;
776
777       where = "certbag.nextcert";
778       if (ti.class || ti.tag != TAG_SEQUENCE)
779         goto bailout;
780
781       where = "certbag.objectidentifier";
782       if (parse_tag (&p, &n, &ti))
783         goto bailout;
784       if (ti.class || ti.tag != TAG_OBJECT_ID)
785         goto bailout;
786       if ( ti.length == DIM(oid_pkcs_12_CertBag)
787            && !memcmp (p, oid_pkcs_12_CertBag, DIM(oid_pkcs_12_CertBag)))
788         {
789           p += DIM(oid_pkcs_12_CertBag);
790           n -= DIM(oid_pkcs_12_CertBag);
791         }
792       else if ( ti.length == DIM(oid_pkcs_12_CrlBag)
793            && !memcmp (p, oid_pkcs_12_CrlBag, DIM(oid_pkcs_12_CrlBag)))
794         {
795           p += DIM(oid_pkcs_12_CrlBag);
796           n -= DIM(oid_pkcs_12_CrlBag);
797           iscrlbag = 1;
798         }
799       else if ( ti.length == DIM(oid_pkcs_12_keyBag)
800            && !memcmp (p, oid_pkcs_12_keyBag, DIM(oid_pkcs_12_keyBag)))
801         {
802           /* The TrustedMIME plugin for MS Outlook started to create
803              files with just one outer 3DES encrypted container and
804              inside the certificates as well as the key. */
805           p += DIM(oid_pkcs_12_keyBag);
806           n -= DIM(oid_pkcs_12_keyBag);
807           iskeybag = 1;
808         }
809       else
810         goto bailout;
811
812       where = "certbag.before.certheader";
813       if (parse_tag (&p, &n, &ti))
814         goto bailout;
815       if (ti.class != ASNCONTEXT || ti.tag)
816         goto bailout;
817       if (iscrlbag)
818         {
819           log_info ("skipping unsupported crlBag\n");
820           p += ti.length;
821           n -= ti.length;
822         }
823       else if (iskeybag && (result || !r_result))
824         {
825           log_info ("one keyBag already processed; skipping this one\n");
826           p += ti.length;
827           n -= ti.length;
828         }
829       else if (iskeybag)
830         {
831           int len;
832
833           log_info ("processing simple keyBag\n");
834
835           /* Fixme: This code is duplicated from parse_bag_data.  */
836           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
837             goto bailout;
838           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
839               || ti.length != 1 || *p)
840             goto bailout;
841           p++; n--;
842           if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
843             goto bailout;
844           len = ti.length;
845           if (parse_tag (&p, &n, &ti))
846             goto bailout;
847           if (len < ti.nhdr)
848             goto bailout;
849           len -= ti.nhdr;
850           if (ti.class || ti.tag != TAG_OBJECT_ID
851               || ti.length != DIM(oid_rsaEncryption)
852               || memcmp (p, oid_rsaEncryption,
853                          DIM(oid_rsaEncryption)))
854             goto bailout;
855           p += DIM (oid_rsaEncryption);
856           n -= DIM (oid_rsaEncryption);
857           if (len < ti.length)
858             goto bailout;
859           len -= ti.length;
860           if (n < len)
861             goto bailout;
862           p += len;
863           n -= len;
864           if ( parse_tag (&p, &n, &ti)
865                || ti.class || ti.tag != TAG_OCTET_STRING)
866             goto bailout;
867           if ( parse_tag (&p, &n, &ti)
868                || ti.class || ti.tag != TAG_SEQUENCE)
869             goto bailout;
870           len = ti.length;
871
872           result = gcry_calloc (10, sizeof *result);
873           if (!result)
874             {
875               log_error ( "error allocating result array\n");
876               goto bailout;
877             }
878           result_count = 0;
879
880           where = "reading.keybag.key-parameters";
881           for (result_count = 0; len && result_count < 9;)
882             {
883               if ( parse_tag (&p, &n, &ti)
884                    || ti.class || ti.tag != TAG_INTEGER)
885                 goto bailout;
886               if (len < ti.nhdr)
887                 goto bailout;
888               len -= ti.nhdr;
889               if (len < ti.length)
890                 goto bailout;
891               len -= ti.length;
892               if (!result_count && ti.length == 1 && !*p)
893                 ; /* ignore the very first one if it is a 0 */
894               else 
895                 {
896                   int rc;
897
898                   rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
899                                       ti.length, NULL);
900                   if (rc)
901                     {
902                       log_error ("error parsing key parameter: %s\n",
903                                  gpg_strerror (rc));
904                       goto bailout;
905                     }
906                   result_count++;
907                 }
908               p += ti.length;
909               n -= ti.length;
910             }
911           if (len)
912             goto bailout;
913         }
914       else
915         {
916           log_info ("processing certBag\n");
917           if (parse_tag (&p, &n, &ti))
918             goto bailout;
919           if (ti.class || ti.tag != TAG_SEQUENCE)
920             goto bailout;
921           if (parse_tag (&p, &n, &ti))
922             goto bailout;
923           if (ti.class || ti.tag != TAG_OBJECT_ID
924               || ti.length != DIM(oid_x509Certificate_for_pkcs_12)
925               || memcmp (p, oid_x509Certificate_for_pkcs_12,
926                          DIM(oid_x509Certificate_for_pkcs_12)))
927             goto bailout;
928           p += DIM(oid_x509Certificate_for_pkcs_12);
929           n -= DIM(oid_x509Certificate_for_pkcs_12);
930           
931           where = "certbag.before.octetstring";
932           if (parse_tag (&p, &n, &ti))
933             goto bailout;
934           if (ti.class != ASNCONTEXT || ti.tag)
935             goto bailout;
936           if (parse_tag (&p, &n, &ti))
937             goto bailout;
938           if (ti.class || ti.tag != TAG_OCTET_STRING || ti.ndef)
939             goto bailout;
940           
941           /* Return the certificate. */
942           if (certcb)
943             certcb (certcbarg, p, ti.length);
944    
945           p += ti.length;
946           n -= ti.length;
947         }
948
949       /* Ugly hack to cope with the padding: Forget about the rest if
950          that is less or equal to the cipher's block length.  We can
951          reasonable assume that all valid data will be longer than
952          just one block. */
953       if (n <= 8)
954         n = 0;  
955
956       /* Skip the optional SET with the pkcs12 cert attributes. */
957       if (n)
958         {
959           where = "bag.attributes";
960           if (parse_tag (&p, &n, &ti))
961             goto bailout;
962           if (!ti.class && ti.tag == TAG_SEQUENCE)
963             ; /* No attributes. */
964           else if (!ti.class && ti.tag == TAG_SET && !ti.ndef)
965             { /* The optional SET. */
966               p += ti.length;
967               n -= ti.length;
968               if (n <= 8)
969                 n = 0;
970               if (n && parse_tag (&p, &n, &ti))
971                 goto bailout;
972             }
973           else
974             goto bailout;
975         }
976     }
977   
978   if (r_consumed)
979     *r_consumed = consumed;
980   gcry_free (plain);
981   gcry_free (cram_buffer);
982   if (r_result)
983     *r_result = result;
984   return 0;
985
986  bailout:
987   if (result)
988     {
989       int i;
990
991       for (i=0; result[i]; i++)
992         gcry_mpi_release (result[i]);
993       gcry_free (result);
994     }
995   if (r_consumed)
996     *r_consumed = consumed;
997   gcry_free (plain);
998   gcry_free (cram_buffer);
999   log_error ("encryptedData error at \"%s\", offset %u\n",
1000              where, (unsigned int)((p - p_start)+startoffset));
1001   if (bad_pass)
1002     {
1003       /* Note, that the following string might be used by other programs
1004          to check for a bad passphrase; it should therefore not be
1005          translated or changed. */
1006       log_error ("possibly bad passphrase given\n");
1007       *r_badpass = 1;
1008     }
1009   return -1;
1010 }
1011
1012
1013 /* Return true if the decryption of a bag_data object has likely
1014    succeeded.  */
1015 static int
1016 bag_data_p (const void *plaintext, size_t length)
1017 {
1018   struct tag_info ti;
1019   const unsigned char *p = plaintext;
1020   size_t n = length;
1021
1022 /*   { */
1023 /* #  warning debug code is enabled */
1024 /*     FILE *fp = fopen ("tmp-3des-plain-key.der", "wb"); */
1025 /*     if (!fp || fwrite (p, n, 1, fp) != 1) */
1026 /*       exit (2); */
1027 /*     fclose (fp); */
1028 /*   } */
1029
1030   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1031     return 0;
1032   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1033       || ti.length != 1 || *p)
1034     return 0;
1035
1036   return 1; 
1037 }
1038
1039
1040 static gcry_mpi_t *
1041 parse_bag_data (const unsigned char *buffer, size_t length, int startoffset,
1042                 size_t *r_consumed, const char *pw)
1043 {
1044   int rc;
1045   struct tag_info ti;
1046   const unsigned char *p = buffer;
1047   const unsigned char *p_start = buffer;
1048   size_t n = length;
1049   const char *where;
1050   char salt[20];
1051   size_t saltlen;
1052   unsigned int iter;
1053   int len;
1054   unsigned char *plain = NULL;
1055   gcry_mpi_t *result = NULL;
1056   int result_count, i;
1057   unsigned char *cram_buffer = NULL;
1058   size_t consumed = 0; /* Number of bytes consumed from the orginal buffer. */
1059
1060   where = "start";
1061   if (parse_tag (&p, &n, &ti))
1062     goto bailout;
1063   if (ti.class != ASNCONTEXT || ti.tag)
1064     goto bailout;
1065   if (parse_tag (&p, &n, &ti))
1066     goto bailout;
1067   if (ti.class || ti.tag != TAG_OCTET_STRING)
1068     goto bailout;
1069
1070   consumed = p - p_start;
1071   if (ti.is_constructed && ti.ndef)
1072     {
1073       /* Mozilla exported certs now come with single byte chunks of
1074          octect strings.  (Mozilla Firefox 1.0.4).  Arghh. */
1075       where = "cram-data.outersegs";
1076       cram_buffer = cram_octet_string ( p, &n, &consumed);
1077       if (!cram_buffer)
1078         goto bailout;
1079       p = p_start = cram_buffer;
1080       if (r_consumed)
1081         *r_consumed = consumed;
1082       r_consumed = NULL; /* Ugly hack to not update that value any further. */
1083     }
1084   
1085
1086   where = "data.outerseqs";
1087   if (parse_tag (&p, &n, &ti))
1088     goto bailout;
1089   if (ti.class || ti.tag != TAG_SEQUENCE)
1090     goto bailout;
1091   if (parse_tag (&p, &n, &ti))
1092     goto bailout;
1093   if (ti.class || ti.tag != TAG_SEQUENCE)
1094     goto bailout;
1095
1096   where = "data.objectidentifier";
1097   if (parse_tag (&p, &n, &ti))
1098     goto bailout;
1099   if (ti.class || ti.tag != TAG_OBJECT_ID
1100       || ti.length != DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)
1101       || memcmp (p, oid_pkcs_12_pkcs_8ShroudedKeyBag,
1102                  DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag)))
1103     goto bailout;
1104   p += DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1105   n -= DIM(oid_pkcs_12_pkcs_8ShroudedKeyBag);
1106
1107   where = "shrouded,outerseqs";
1108   if (parse_tag (&p, &n, &ti))
1109     goto bailout;
1110   if (ti.class != ASNCONTEXT || ti.tag)
1111     goto bailout;
1112   if (parse_tag (&p, &n, &ti))
1113     goto bailout;
1114   if (ti.class || ti.tag != TAG_SEQUENCE)
1115     goto bailout;
1116   if (parse_tag (&p, &n, &ti))
1117     goto bailout;
1118   if (ti.class || ti.tag != TAG_SEQUENCE)
1119     goto bailout;
1120   if (parse_tag (&p, &n, &ti))
1121     goto bailout;
1122   if (ti.class || ti.tag != TAG_OBJECT_ID
1123       || ti.length != DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)
1124       || memcmp (p, oid_pbeWithSHAAnd3_KeyTripleDES_CBC,
1125                  DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC)))
1126     goto bailout;
1127   p += DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1128   n -= DIM(oid_pbeWithSHAAnd3_KeyTripleDES_CBC);
1129
1130   where = "3des-params";
1131   if (parse_tag (&p, &n, &ti))
1132     goto bailout;
1133   if (ti.class || ti.tag != TAG_SEQUENCE)
1134     goto bailout;
1135   if (parse_tag (&p, &n, &ti))
1136     goto bailout;
1137   if (ti.class || ti.tag != TAG_OCTET_STRING
1138       || ti.length < 8 || ti.length > 20)
1139     goto bailout;
1140   saltlen = ti.length;
1141   memcpy (salt, p, saltlen);
1142   p += saltlen;
1143   n -= saltlen;
1144   if (parse_tag (&p, &n, &ti))
1145     goto bailout;
1146   if (ti.class || ti.tag != TAG_INTEGER || !ti.length )
1147     goto bailout;
1148   for (iter=0; ti.length; ti.length--)
1149     {
1150       iter <<= 8;
1151       iter |= (*p++) & 0xff; 
1152       n--;
1153     }
1154   
1155   where = "3des-ciphertext";
1156   if (parse_tag (&p, &n, &ti))
1157     goto bailout;
1158   if (ti.class || ti.tag != TAG_OCTET_STRING || !ti.length )
1159     goto bailout;
1160   
1161   log_info ("%lu bytes of 3DES encrypted text\n", ti.length);
1162   
1163   plain = gcry_malloc_secure (ti.length);
1164   if (!plain)
1165     {
1166       log_error ("error allocating decryption buffer\n");
1167       goto bailout;
1168     }
1169   consumed += p - p_start + ti.length;
1170   decrypt_block (p, plain, ti.length, salt, saltlen, iter, pw, 
1171                  GCRY_CIPHER_3DES, 
1172                  bag_data_p);
1173   n = ti.length;
1174   startoffset = 0;
1175   p_start = p = plain;
1176
1177   where = "decrypted-text";
1178   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1179     goto bailout;
1180   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER
1181       || ti.length != 1 || *p)
1182     goto bailout;
1183   p++; n--;
1184   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1185     goto bailout;
1186   len = ti.length;
1187   if (parse_tag (&p, &n, &ti))
1188     goto bailout;
1189   if (len < ti.nhdr)
1190     goto bailout;
1191   len -= ti.nhdr;
1192   if (ti.class || ti.tag != TAG_OBJECT_ID
1193       || ti.length != DIM(oid_rsaEncryption)
1194       || memcmp (p, oid_rsaEncryption,
1195                  DIM(oid_rsaEncryption)))
1196     goto bailout;
1197   p += DIM (oid_rsaEncryption);
1198   n -= DIM (oid_rsaEncryption);
1199   if (len < ti.length)
1200     goto bailout;
1201   len -= ti.length;
1202   if (n < len)
1203     goto bailout;
1204   p += len;
1205   n -= len;
1206   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_OCTET_STRING)
1207     goto bailout;
1208   if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_SEQUENCE)
1209     goto bailout;
1210   len = ti.length;
1211
1212   result = gcry_calloc (10, sizeof *result);
1213   if (!result)
1214     {
1215       log_error ( "error allocating result array\n");
1216       goto bailout;
1217     }
1218   result_count = 0;
1219
1220   where = "reading.key-parameters";
1221   for (result_count=0; len && result_count < 9;)
1222     {
1223       if (parse_tag (&p, &n, &ti) || ti.class || ti.tag != TAG_INTEGER)
1224         goto bailout;
1225       if (len < ti.nhdr)
1226         goto bailout;
1227       len -= ti.nhdr;
1228       if (len < ti.length)
1229         goto bailout;
1230       len -= ti.length;
1231       if (!result_count && ti.length == 1 && !*p)
1232         ; /* ignore the very first one if it is a 0 */
1233       else 
1234         {
1235           rc = gcry_mpi_scan (result+result_count, GCRYMPI_FMT_USG, p,
1236                               ti.length, NULL);
1237           if (rc)
1238             {
1239               log_error ("error parsing key parameter: %s\n",
1240                          gpg_strerror (rc));
1241               goto bailout;
1242             }
1243           result_count++;
1244         }
1245       p += ti.length;
1246       n -= ti.length;
1247     }
1248   if (len)
1249     goto bailout;
1250
1251   gcry_free (cram_buffer);
1252   if (r_consumed)
1253     *r_consumed = consumed;
1254   return result;
1255
1256  bailout:
1257   gcry_free (plain);
1258   if (result)
1259     {
1260       for (i=0; result[i]; i++)
1261         gcry_mpi_release (result[i]);
1262       gcry_free (result);
1263     }
1264   gcry_free (cram_buffer);
1265   log_error ( "data error at \"%s\", offset %u\n",
1266               where, (unsigned int)((p - buffer) + startoffset));
1267   if (r_consumed)
1268     *r_consumed = consumed;
1269   return NULL;
1270 }
1271
1272
1273 /* Parse a PKCS12 object and return an array of MPI representing the
1274    secret key parameters.  This is a very limited implementation in
1275    that it is only able to look for 3DES encoded encryptedData and
1276    tries to extract the first private key object it finds.  In case of
1277    an error NULL is returned. CERTCB and CERRTCBARG are used to pass
1278    X.509 certificates back to the caller. */
1279 gcry_mpi_t *
1280 p12_parse (const unsigned char *buffer, size_t length, const char *pw,
1281            void (*certcb)(void*, const unsigned char*, size_t),
1282            void *certcbarg, int *r_badpass)
1283 {
1284   struct tag_info ti;
1285   const unsigned char *p = buffer;
1286   const unsigned char *p_start = buffer;
1287   size_t n = length;
1288   const char *where;
1289   int bagseqlength, len;
1290   int bagseqndef, lenndef;
1291   gcry_mpi_t *result = NULL;
1292   unsigned char *cram_buffer = NULL;
1293
1294   *r_badpass = 0;
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 != ASNCONTEXT || 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, r_badpass))
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 parameters 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 PW.
2143    Create a PKCS structure from it and return it as well as the length
2144    in R_LENGTH; return NULL in case of an error.  If CHARSET is not
2145    NULL, re-encode PW to that character set. */
2146 unsigned char * 
2147 p12_build (gcry_mpi_t *kparms, unsigned char *cert, size_t certlen,
2148            const char *pw, const char *charset, size_t *r_length)
2149 {
2150   unsigned char *buffer = NULL;
2151   size_t n, buflen;
2152   char salt[8];
2153   struct buffer_s seqlist[3];
2154   int seqlistidx = 0;
2155   unsigned char sha1hash[20];
2156   char keyidstr[8+1];
2157   char *pwbuf = NULL;
2158   size_t pwbufsize = 0;
2159
2160   n = buflen = 0; /* (avoid compiler warning). */
2161   memset (sha1hash, 0, 20);
2162   *keyidstr = 0;
2163
2164   if (charset && pw && *pw)
2165     {
2166       jnlib_iconv_t cd;
2167       const char *inptr;
2168       char *outptr;
2169       size_t inbytes, outbytes;
2170
2171       /* We assume that the converted passphrase is at max 2 times
2172          longer than its utf-8 encoding. */
2173       pwbufsize = strlen (pw)*2 + 1;
2174       pwbuf = gcry_malloc_secure (pwbufsize);
2175       if (!pwbuf)
2176         {
2177           log_error ("out of secure memory while converting passphrase\n");
2178           goto failure;
2179         }
2180
2181       cd = jnlib_iconv_open (charset, "utf-8");
2182       if (cd == (jnlib_iconv_t)(-1))
2183         {
2184           log_error ("can't convert passphrase to"
2185                      " requested charset `%s': %s\n",
2186                      charset, strerror (errno));
2187           gcry_free (pwbuf);
2188           goto failure;
2189         }
2190
2191       inptr = pw;
2192       inbytes = strlen (pw);
2193       outptr = pwbuf;
2194       outbytes = pwbufsize - 1;
2195       if ( jnlib_iconv (cd, (const char **)&inptr, &inbytes,
2196                       &outptr, &outbytes) == (size_t)-1) 
2197         {
2198           log_error ("error converting passphrase to"
2199                      " requested charset `%s': %s\n",
2200                      charset, strerror (errno));
2201           gcry_free (pwbuf);
2202           jnlib_iconv_close (cd);
2203           goto failure;
2204         }
2205       *outptr = 0;
2206       jnlib_iconv_close (cd);
2207       pw = pwbuf;
2208     }
2209
2210
2211   if (cert && certlen)
2212     {
2213       /* Calculate the hash value we need for the bag attributes. */
2214       gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash, cert, certlen);
2215       sprintf (keyidstr, "%02x%02x%02x%02x",
2216                sha1hash[16], sha1hash[17], sha1hash[18], sha1hash[19]);
2217
2218       /* Encode the certificate. */
2219       buffer = build_cert_sequence (cert, certlen, sha1hash, keyidstr,
2220                                     &buflen);
2221       if (!buffer)
2222         goto failure;
2223
2224       /* Encrypt it. */
2225       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2226       crypt_block (buffer, buflen, salt, 8, 2048, pw,
2227                    GCRY_CIPHER_RFC2268_40, 1);
2228       
2229       /* Encode the encrypted stuff into a bag. */
2230       seqlist[seqlistidx].buffer = build_cert_bag (buffer, buflen, salt, &n);
2231       seqlist[seqlistidx].length = n;
2232       gcry_free (buffer);
2233       buffer = NULL;
2234       if (!seqlist[seqlistidx].buffer)
2235         goto failure;
2236       seqlistidx++;
2237     }
2238
2239
2240   if (kparms)
2241     {
2242       /* Encode the key. */
2243       buffer = build_key_sequence (kparms, &buflen);
2244       if (!buffer)
2245         goto failure;
2246       
2247       /* Encrypt it. */
2248       gcry_randomize (salt, 8, GCRY_STRONG_RANDOM);
2249       crypt_block (buffer, buflen, salt, 8, 2048, pw, GCRY_CIPHER_3DES, 1);
2250
2251       /* Encode the encrypted stuff into a bag. */
2252       if (cert && certlen)
2253         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt, 
2254                                                     sha1hash, keyidstr, &n);
2255       else
2256         seqlist[seqlistidx].buffer = build_key_bag (buffer, buflen, salt,
2257                                                     NULL, NULL, &n);
2258       seqlist[seqlistidx].length = n;
2259       gcry_free (buffer);
2260       buffer = NULL;
2261       if (!seqlist[seqlistidx].buffer)
2262         goto failure;
2263       seqlistidx++;
2264     }
2265
2266   seqlist[seqlistidx].buffer = NULL;
2267   seqlist[seqlistidx].length = 0;
2268
2269   buffer = create_final (seqlist, pw, &buflen);
2270
2271  failure:
2272   if (pwbuf)
2273     {
2274       wipememory (pwbuf, pwbufsize);
2275       gcry_free (pwbuf);
2276     }
2277   for ( ; seqlistidx; seqlistidx--)
2278     gcry_free (seqlist[seqlistidx].buffer);
2279
2280   *r_length = buffer? buflen : 0;
2281   return buffer;
2282 }
2283
2284
2285 #ifdef TEST
2286
2287 static void 
2288 cert_cb (void *opaque, const unsigned char *cert, size_t certlen)
2289 {
2290   printf ("got a certificate of %u bytes length\n", certlen);
2291 }
2292
2293 int
2294 main (int argc, char **argv)
2295 {
2296   FILE *fp;
2297   struct stat st;
2298   unsigned char *buf;
2299   size_t buflen;
2300   gcry_mpi_t *result;
2301
2302   if (argc != 3)
2303     {
2304       fprintf (stderr, "usage: testp12 file passphrase\n");
2305       return 1;
2306     }
2307
2308   gcry_control (GCRYCTL_DISABLE_SECMEM, NULL);
2309   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL);
2310
2311   fp = fopen (argv[1], "rb");
2312   if (!fp)
2313     {
2314       fprintf (stderr, "can't open `%s': %s\n", argv[1], strerror (errno));
2315       return 1;
2316     }
2317   
2318   if (fstat (fileno(fp), &st))
2319     {
2320       fprintf (stderr, "can't stat `%s': %s\n", argv[1], strerror (errno));
2321       return 1;
2322     }
2323
2324   buflen = st.st_size;
2325   buf = gcry_malloc (buflen+1);
2326   if (!buf || fread (buf, buflen, 1, fp) != 1)
2327     {
2328       fprintf (stderr, "error reading `%s': %s\n", argv[1], strerror (errno));
2329       return 1;
2330     }
2331   fclose (fp);
2332
2333   result = p12_parse (buf, buflen, argv[2], cert_cb, NULL);
2334   if (result)
2335     {
2336       int i, rc;
2337       unsigned char *tmpbuf;
2338
2339       for (i=0; result[i]; i++)
2340         {
2341           rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &tmpbuf,
2342                                 NULL, result[i]);
2343           if (rc)
2344             printf ("%d: [error printing number: %s]\n",
2345                     i, gpg_strerror (rc));
2346           else
2347             {
2348               printf ("%d: %s\n", i, tmpbuf);
2349               gcry_free (tmpbuf);
2350             }
2351         }
2352     }
2353
2354   return 0;
2355
2356 }
2357
2358 /*
2359 Local Variables:
2360 compile-command: "gcc -Wall -O0 -g -DTEST=1 -o minip12 minip12.c ../common/libcommon.a -L /usr/local/lib -lgcrypt -lgpg-error"
2361 End:
2362 */
2363 #endif /* TEST */