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