Avoid using the protect-tool to import pkcs#12.
[gnupg.git] / agent / protect.c
1 /* protect.c - Un/Protect a secret key
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003, 2007, 2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28 #include <unistd.h>
29 #include <sys/stat.h>
30 #ifdef HAVE_W32_SYSTEM
31 # include <windows.h>
32 #else
33 # include <sys/times.h>
34 #endif
35
36 #include "agent.h"
37
38 #include "sexp-parse.h"
39
40 #define PROT_CIPHER        GCRY_CIPHER_AES
41 #define PROT_CIPHER_STRING "aes"
42 #define PROT_CIPHER_KEYLEN (128/8)
43
44
45 /* A table containing the information needed to create a protected
46    private key */
47 static struct {
48   const char *algo;
49   const char *parmlist;
50   int prot_from, prot_to;
51 } protect_info[] = {
52   { "rsa",  "nedpqu", 2, 5 },
53   { "dsa",  "pqgyx", 4, 4 },
54   { "elg",  "pgyx", 3, 3 },
55   { NULL }
56 };
57
58
59 /* A helper object for time measurement.  */
60 struct calibrate_time_s
61 {
62 #ifdef HAVE_W32_SYSTEM
63   FILETIME creation_time, exit_time, kernel_time, user_time;
64 #else
65   clock_t ticks;
66 #endif
67 };
68
69
70 static int
71 hash_passphrase (const char *passphrase, int hashalgo,
72                  int s2kmode,
73                  const unsigned char *s2ksalt, unsigned long s2kcount,
74                  unsigned char *key, size_t keylen);
75
76 /* Get the process time and store it in DATA.  */
77 static void
78 calibrate_get_time (struct calibrate_time_s *data)
79 {
80 #ifdef HAVE_W32_SYSTEM
81 # ifdef HAVE_W32CE_SYSTEM
82   GetThreadTimes (GetCurrentThread (),
83 # else 
84   GetProcessTimes (GetCurrentProcess (),
85 # endif
86                    &data->creation_time, &data->exit_time,
87                    &data->kernel_time, &data->user_time);
88 #else
89   struct tms tmp;
90   
91   times (&tmp);
92   data->ticks = tmp.tms_utime;
93 #endif
94 }
95
96
97 static unsigned long
98 calibrate_elapsed_time (struct calibrate_time_s *starttime)
99 {
100   struct calibrate_time_s stoptime;
101   
102   calibrate_get_time (&stoptime);
103 #ifdef HAVE_W32_SYSTEM
104   {
105     unsigned long long t1, t2;
106     
107     t1 = (((unsigned long long)starttime->kernel_time.dwHighDateTime << 32)
108           + starttime->kernel_time.dwLowDateTime);
109     t1 += (((unsigned long long)starttime->user_time.dwHighDateTime << 32)
110            + starttime->user_time.dwLowDateTime);
111     t2 = (((unsigned long long)stoptime.kernel_time.dwHighDateTime << 32)
112           + stoptime.kernel_time.dwLowDateTime);
113     t2 += (((unsigned long long)stoptime.user_time.dwHighDateTime << 32)
114            + stoptime.user_time.dwLowDateTime);
115     return (unsigned long)((t2 - t1)/10000);
116   }
117 #else
118   return (unsigned long)((((double) (stoptime.ticks - starttime->ticks))
119                           /CLOCKS_PER_SEC)*10000000);
120 #endif
121 }
122
123
124 /* Run a test hashing for COUNT and return the time required in
125    milliseconds.  */
126 static unsigned long
127 calibrate_s2k_count_one (unsigned long count)
128 {
129   int rc;
130   char keybuf[PROT_CIPHER_KEYLEN];
131   struct calibrate_time_s starttime;
132
133   calibrate_get_time (&starttime);
134   rc = hash_passphrase ("123456789abcdef0", GCRY_MD_SHA1,
135                         3, "saltsalt", count, keybuf, sizeof keybuf);
136   if (rc)
137     BUG ();
138   return calibrate_elapsed_time (&starttime);
139 }
140
141
142 /* Measure the time we need to do the hash operations and deduce an
143    S2K count which requires about 100ms of time.  */ 
144 static unsigned long
145 calibrate_s2k_count (void)
146 {
147   unsigned long count;
148   unsigned long ms;
149
150   for (count = 65536; count; count *= 2)
151     {
152       ms = calibrate_s2k_count_one (count);
153       if (opt.verbose > 1)
154         log_info ("S2K calibration: %lu -> %lums\n", count, ms);
155       if (ms > 100)
156         break;
157     }
158
159   count = (unsigned long)(((double)count / ms) * 100);
160   count /= 1024;
161   count *= 1024;
162   if (count < 65536)
163     count = 65536;
164
165   if (opt.verbose)
166     {
167       ms = calibrate_s2k_count_one (count);
168       log_info ("S2K calibration: %lu -> %lums\n", count, ms);
169     }
170
171   return count;
172 }
173
174
175
176 /* Return the standard S2K count.  */
177 unsigned long
178 get_standard_s2k_count (void)
179 {
180   static unsigned long count;
181
182   if (!count)
183     count = calibrate_s2k_count ();
184
185   /* Enforce a lower limit.  */
186   return count < 65536 ? 65536 : count;
187 }
188
189
190
191 \f
192 /* Calculate the MIC for a private key S-Exp. SHA1HASH should point to
193    a 20 byte buffer.  This function is suitable for any algorithms. */
194 static int 
195 calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
196 {
197   const unsigned char *hash_begin, *hash_end;
198   const unsigned char *s;
199   size_t n;
200
201   s = plainkey;
202   if (*s != '(')
203     return gpg_error (GPG_ERR_INV_SEXP);
204   s++;
205   n = snext (&s);
206   if (!n)
207     return gpg_error (GPG_ERR_INV_SEXP); 
208   if (!smatch (&s, n, "private-key"))
209     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
210   if (*s != '(')
211     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
212   hash_begin = s;
213   s++;
214   n = snext (&s);
215   if (!n)
216     return gpg_error (GPG_ERR_INV_SEXP); 
217   s += n; /* skip over the algorithm name */
218
219   while (*s == '(')
220     {
221       s++;
222       n = snext (&s);
223       if (!n)
224         return gpg_error (GPG_ERR_INV_SEXP); 
225       s += n;
226       n = snext (&s);
227       if (!n)
228         return gpg_error (GPG_ERR_INV_SEXP); 
229       s += n;
230       if ( *s != ')' )
231         return gpg_error (GPG_ERR_INV_SEXP); 
232       s++;
233     }
234   if (*s != ')')
235     return gpg_error (GPG_ERR_INV_SEXP); 
236   s++;
237   hash_end = s;
238
239   gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash,
240                        hash_begin, hash_end - hash_begin);
241
242   return 0;
243 }
244
245
246 \f
247 /* Encrypt the parameter block starting at PROTBEGIN with length
248    PROTLEN using the utf8 encoded key PASSPHRASE and return the entire
249    encrypted block in RESULT or return with an error code.  SHA1HASH
250    is the 20 byte SHA-1 hash required for the integrity code.
251
252    The parameter block is expected to be an incomplete S-Expression of
253    the form (example in advanced format):
254
255      (d #046129F..[some bytes not shown]..81#)
256      (p #00e861b..[some bytes not shown]..f1#)
257      (q #00f7a7c..[some bytes not shown]..61#)
258      (u #304559a..[some bytes not shown]..9b#) 
259
260    the returned block is the S-Expression:
261
262     (protected mode (parms) encrypted_octet_string)
263
264 */
265 static int
266 do_encryption (const unsigned char *protbegin, size_t protlen, 
267                const char *passphrase,  const unsigned char *sha1hash,
268                unsigned char **result, size_t *resultlen)
269 {
270   gcry_cipher_hd_t hd;
271   const char *modestr = "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc";
272   int blklen, enclen, outlen;
273   unsigned char *iv = NULL;
274   int rc;
275   char *outbuf = NULL;
276   char *p;
277   int saltpos, ivpos, encpos;
278
279   *resultlen = 0;
280   *result = NULL;
281
282   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
283                          GCRY_CIPHER_SECURE);
284   if (rc)
285     return rc;
286
287
288   /* We need to work on a copy of the data because this makes it
289      easier to add the trailer and the padding and more important we
290      have to prefix the text with 2 parenthesis, so we have to
291      allocate enough space for:
292
293      ((<parameter_list>)(4:hash4:sha120:<hashvalue>)) + padding
294
295      We always append a full block of random bytes as padding but
296      encrypt only what is needed for a full blocksize.  */
297   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
298   outlen = 2 + protlen + 2 + 6 + 6 + 23 + 2 + blklen;
299   enclen = outlen/blklen * blklen;
300   outbuf = gcry_malloc_secure (outlen);
301   if (!outbuf)
302     rc = out_of_core ();
303   if (!rc)
304     {
305       /* Allocate random bytes to be used as IV, padding and s2k salt. */
306       iv = xtrymalloc (blklen*2+8);
307       if (!iv)
308         rc = gpg_error (GPG_ERR_ENOMEM);
309       else
310         {
311           gcry_create_nonce (iv, blklen*2+8);
312           rc = gcry_cipher_setiv (hd, iv, blklen);
313         }
314     }
315   if (!rc)
316     {
317       unsigned char *key;
318       size_t keylen = PROT_CIPHER_KEYLEN;
319       
320       key = gcry_malloc_secure (keylen);
321       if (!key)
322         rc = out_of_core ();
323       else
324         {
325           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
326                                 3, iv+2*blklen, 
327                                 get_standard_s2k_count (), key, keylen);
328           if (!rc)
329             rc = gcry_cipher_setkey (hd, key, keylen);
330           xfree (key);
331         }
332     }
333   if (!rc)
334     {
335       p = outbuf;
336       *p++ = '(';
337       *p++ = '(';
338       memcpy (p, protbegin, protlen);
339       p += protlen;
340       memcpy (p, ")(4:hash4:sha120:", 17);
341       p += 17;
342       memcpy (p, sha1hash, 20);
343       p += 20;
344       *p++ = ')';
345       *p++ = ')';
346       memcpy (p, iv+blklen, blklen); 
347       p += blklen;
348       assert ( p - outbuf == outlen);
349       rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
350     }
351   gcry_cipher_close (hd);
352   if (rc)
353     {
354       xfree (iv);
355       xfree (outbuf);
356       return rc;
357     }
358
359   /* Now allocate the buffer we want to return.  This is
360
361      (protected openpgp-s2k3-sha1-aes-cbc
362        ((sha1 salt no_of_iterations) 16byte_iv)
363        encrypted_octet_string)
364        
365      in canoncical format of course.  We use asprintf and %n modifier
366      and dummy values as placeholders.  */
367   {
368     char countbuf[35];
369
370     snprintf (countbuf, sizeof countbuf, "%lu", get_standard_s2k_count ());
371     p = xtryasprintf
372       ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
373        (int)strlen (modestr), modestr,
374        &saltpos, 
375        (unsigned int)strlen (countbuf), countbuf,
376        blklen, &ivpos, blklen, "",
377        enclen, &encpos, enclen, "");
378     if (!p)
379       {
380         gpg_error_t tmperr = out_of_core ();
381         xfree (iv);
382         xfree (outbuf);
383         return tmperr;
384       }
385   }
386   *resultlen = strlen (p);
387   *result = (unsigned char*)p;
388   memcpy (p+saltpos, iv+2*blklen, 8);
389   memcpy (p+ivpos, iv, blklen);
390   memcpy (p+encpos, outbuf, enclen);
391   xfree (iv);
392   xfree (outbuf);
393   return 0;
394 }
395
396
397
398 /* Protect the key encoded in canonical format in PLAINKEY.  We assume
399    a valid S-Exp here. */
400 int 
401 agent_protect (const unsigned char *plainkey, const char *passphrase,
402                unsigned char **result, size_t *resultlen)
403 {
404   int rc;
405   const unsigned char *s;
406   const unsigned char *hash_begin, *hash_end;
407   const unsigned char *prot_begin, *prot_end, *real_end;
408   size_t n;
409   int c, infidx, i;
410   unsigned char hashvalue[20];
411   char timestamp_exp[35];
412   unsigned char *protected;
413   size_t protectedlen;
414   int depth = 0;
415   unsigned char *p;
416   gcry_md_hd_t md;
417
418   /* Create an S-expression with the protected-at timestamp.  */
419   memcpy (timestamp_exp, "(12:protected-at15:", 19);
420   gnupg_get_isotime (timestamp_exp+19);
421   timestamp_exp[19+15] = ')';
422
423   /* Parse original key.  */
424   s = plainkey;
425   if (*s != '(')
426     return gpg_error (GPG_ERR_INV_SEXP);
427   depth++;
428   s++;
429   n = snext (&s);
430   if (!n)
431     return gpg_error (GPG_ERR_INV_SEXP); 
432   if (!smatch (&s, n, "private-key"))
433     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
434   if (*s != '(')
435     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
436   depth++;
437   hash_begin = s;
438   s++;
439   n = snext (&s);
440   if (!n)
441     return gpg_error (GPG_ERR_INV_SEXP); 
442
443   for (infidx=0; protect_info[infidx].algo
444               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
445     ;
446   if (!protect_info[infidx].algo)
447     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM); 
448
449   prot_begin = prot_end = NULL;
450   for (i=0; (c=protect_info[infidx].parmlist[i]); i++)
451     {
452       if (i == protect_info[infidx].prot_from)
453         prot_begin = s;
454       if (*s != '(')
455         return gpg_error (GPG_ERR_INV_SEXP);
456       depth++;
457       s++;
458       n = snext (&s);
459       if (!n)
460         return gpg_error (GPG_ERR_INV_SEXP); 
461       if (n != 1 || c != *s)
462         return gpg_error (GPG_ERR_INV_SEXP); 
463       s += n;
464       n = snext (&s);
465       if (!n)
466         return gpg_error (GPG_ERR_INV_SEXP); 
467       s +=n; /* skip value */
468       if (*s != ')')
469         return gpg_error (GPG_ERR_INV_SEXP); 
470       depth--;
471       if (i == protect_info[infidx].prot_to)
472         prot_end = s;
473       s++;
474     }
475   if (*s != ')' || !prot_begin || !prot_end )
476     return gpg_error (GPG_ERR_INV_SEXP); 
477   depth--;
478   hash_end = s;
479   s++;
480   /* skip to the end of the S-exp */
481   assert (depth == 1);
482   rc = sskip (&s, &depth);
483   if (rc)
484     return rc;
485   assert (!depth);
486   real_end = s-1;
487
488   
489   /* Hash the stuff.  Because the timestamp_exp won't get protected,
490      we can't simply hash a continuous buffer but need to use several
491      md_writes.  */ 
492   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
493   if (rc)
494     return rc;
495   gcry_md_write (md, hash_begin, hash_end - hash_begin);
496   gcry_md_write (md, timestamp_exp, 35);
497   gcry_md_write (md, ")", 1);
498   memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
499   gcry_md_close (md);
500
501   rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
502                       passphrase,  hashvalue,
503                       &protected, &protectedlen);
504   if (rc)
505     return rc;
506
507   /* Now create the protected version of the key.  Note that the 10
508      extra bytes are for for the inserted "protected-" string (the
509      beginning of the plaintext reads: "((11:private-key(" ).  The 35
510      term is the space for (12:protected-at15:<timestamp>).  */
511   *resultlen = (10
512                 + (prot_begin-plainkey)
513                 + protectedlen
514                 + 35
515                 + (real_end-prot_end));
516   *result = p = xtrymalloc (*resultlen);
517   if (!p)
518     {
519       gpg_error_t tmperr = out_of_core ();
520       xfree (protected);
521       return tmperr;
522     }
523   memcpy (p, "(21:protected-", 14);
524   p += 14;
525   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
526   p += prot_begin - plainkey - 4;
527   memcpy (p, protected, protectedlen);
528   p += protectedlen;
529
530   memcpy (p, timestamp_exp, 35);
531   p += 35;
532
533   memcpy (p, prot_end+1, real_end - prot_end);
534   p += real_end - prot_end;
535   assert ( p - *result == *resultlen);
536   xfree (protected);
537
538   return 0;
539 }
540
541 \f
542 /* Do the actual decryption and check the return list for consistency.  */
543 static int
544 do_decryption (const unsigned char *protected, size_t protectedlen, 
545                const char *passphrase, 
546                const unsigned char *s2ksalt, unsigned long s2kcount,
547                const unsigned char *iv, size_t ivlen,
548                unsigned char **result)
549 {
550   int rc = 0;
551   int blklen;
552   gcry_cipher_hd_t hd;
553   unsigned char *outbuf;
554   size_t reallen;
555
556   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
557   if (protectedlen < 4 || (protectedlen%blklen))
558     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
559
560   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
561                          GCRY_CIPHER_SECURE);
562   if (rc)
563     return rc;
564
565   outbuf = gcry_malloc_secure (protectedlen);
566   if (!outbuf)
567     rc = out_of_core ();
568   if (!rc)
569     rc = gcry_cipher_setiv (hd, iv, ivlen);
570   if (!rc)
571     {
572       unsigned char *key;
573       size_t keylen = PROT_CIPHER_KEYLEN;
574       
575       key = gcry_malloc_secure (keylen);
576       if (!key)
577         rc = out_of_core ();
578       else
579         {
580           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
581                                 3, s2ksalt, s2kcount, key, keylen);
582           if (!rc)
583             rc = gcry_cipher_setkey (hd, key, keylen);
584           xfree (key);
585         }
586     }
587   if (!rc)
588     rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
589                               protected, protectedlen);
590   gcry_cipher_close (hd);
591   if (rc)
592     {
593       xfree (outbuf);
594       return rc;
595     }
596   /* Do a quick check first. */
597   if (*outbuf != '(' && outbuf[1] != '(')
598     {
599       xfree (outbuf);
600       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
601     }
602   /* Check that we have a consistent S-Exp. */
603   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
604   if (!reallen || (reallen + blklen < protectedlen) )
605     {
606       xfree (outbuf);
607       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
608     }
609   *result = outbuf;
610   return 0;
611 }
612
613
614 /* Merge the parameter list contained in CLEARTEXT with the original
615    protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
616    Return the new list in RESULT and the MIC value in the 20 byte
617    buffer SHA1HASH.  CUTOFF and CUTLEN will receive the offset and the
618    length of the resulting list which should go into the MIC
619    calculation but then be removed.  */
620 static int
621 merge_lists (const unsigned char *protectedkey,
622              size_t replacepos, 
623              const unsigned char *cleartext,
624              unsigned char *sha1hash,
625              unsigned char **result, size_t *resultlen,
626              size_t *cutoff, size_t *cutlen)
627 {
628   size_t n, newlistlen;
629   unsigned char *newlist, *p;
630   const unsigned char *s;
631   const unsigned char *startpos, *endpos;
632   int i, rc;
633   
634   *result = NULL;
635   *resultlen = 0;
636   *cutoff = 0;
637   *cutlen = 0;
638
639   if (replacepos < 26)
640     return gpg_error (GPG_ERR_BUG);
641
642   /* Estimate the required size of the resulting list.  We have a large
643      safety margin of >20 bytes (MIC hash from CLEARTEXT and the
644      removed "protected-" */
645   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
646   if (!newlistlen)
647     return gpg_error (GPG_ERR_BUG);
648   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
649   if (!n)
650     return gpg_error (GPG_ERR_BUG);
651   newlistlen += n;
652   newlist = gcry_malloc_secure (newlistlen);
653   if (!newlist)
654     return out_of_core ();
655
656   /* Copy the initial segment */
657   strcpy ((char*)newlist, "(11:private-key");
658   p = newlist + 15;
659   memcpy (p, protectedkey+15+10, replacepos-15-10);
660   p += replacepos-15-10;
661
662   /* copy the cleartext */
663   s = cleartext;
664   if (*s != '(' && s[1] != '(')
665     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
666   s += 2;
667   startpos = s;
668   while ( *s == '(' )
669     {
670       s++;
671       n = snext (&s);
672       if (!n)
673         goto invalid_sexp;
674       s += n;
675       n = snext (&s);
676       if (!n)
677         goto invalid_sexp;
678       s += n;
679       if ( *s != ')' )
680         goto invalid_sexp;
681       s++;
682     }
683   if ( *s != ')' )
684     goto invalid_sexp;
685   endpos = s;
686   s++;
687   /* Intermezzo: Get the MIC */
688   if (*s != '(')
689     goto invalid_sexp;
690   s++;
691   n = snext (&s);
692   if (!smatch (&s, n, "hash"))
693     goto invalid_sexp;
694   n = snext (&s);
695   if (!smatch (&s, n, "sha1"))
696     goto invalid_sexp; 
697   n = snext (&s);
698   if (n != 20)
699     goto invalid_sexp;
700   memcpy (sha1hash, s, 20);
701   s += n;
702   if (*s != ')')
703     goto invalid_sexp;
704   /* End intermezzo */
705
706   /* append the parameter list */
707   memcpy (p, startpos, endpos - startpos);
708   p += endpos - startpos;
709   
710   /* Skip over the protected list element in the original list.  */
711   s = protectedkey + replacepos;
712   assert (*s == '(');
713   s++;
714   i = 1;
715   rc = sskip (&s, &i);
716   if (rc)
717     goto failure;
718   /* Record the position of the optional protected-at expression.  */
719   if (*s == '(')
720     {
721       const unsigned char *save_s = s;
722       s++;
723       n = snext (&s);
724       if (smatch (&s, n, "protected-at"))
725         {
726           i = 1;
727           rc = sskip (&s, &i);
728           if (rc)
729             goto failure;
730           *cutlen = s - save_s;
731         }
732       s = save_s;
733     }
734   startpos = s;
735   i = 2; /* we are inside this level */
736   rc = sskip (&s, &i);
737   if (rc)
738     goto failure;
739   assert (s[-1] == ')');
740   endpos = s; /* one behind the end of the list */
741
742   /* Append the rest. */
743   if (*cutlen)
744     *cutoff = p - newlist;
745   memcpy (p, startpos, endpos - startpos);
746   p += endpos - startpos;
747   
748
749   /* ready */
750   *result = newlist;
751   *resultlen = newlistlen;
752   return 0;
753
754  failure:
755   wipememory (newlist, newlistlen);
756   xfree (newlist);
757   return rc;
758
759  invalid_sexp:
760   wipememory (newlist, newlistlen);
761   xfree (newlist);
762   return gpg_error (GPG_ERR_INV_SEXP);
763 }
764
765
766
767 /* Unprotect the key encoded in canonical format.  We assume a valid
768    S-Exp here.  If a protected-at item is available, its value will
769    be stored at protocted_at unless this is NULL.  */
770 int 
771 agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
772                  gnupg_isotime_t protected_at, 
773                  unsigned char **result, size_t *resultlen)
774 {
775   int rc;
776   const unsigned char *s;
777   const unsigned char *protect_list; 
778   size_t n;
779   int infidx, i;
780   unsigned char sha1hash[20], sha1hash2[20];
781   const unsigned char *s2ksalt;
782   unsigned long s2kcount;
783   const unsigned char *iv;
784   const unsigned char *prot_begin;
785   unsigned char *cleartext;
786   unsigned char *final;
787   size_t finallen;
788   size_t cutoff, cutlen;
789
790   if (protected_at)
791     *protected_at = 0;
792
793   s = protectedkey;
794   if (*s != '(')
795     return gpg_error (GPG_ERR_INV_SEXP);
796   s++;
797   n = snext (&s);
798   if (!n)
799     return gpg_error (GPG_ERR_INV_SEXP); 
800   if (!smatch (&s, n, "protected-private-key"))
801     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
802   if (*s != '(')
803     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
804   s++;
805   n = snext (&s);
806   if (!n)
807     return gpg_error (GPG_ERR_INV_SEXP); 
808
809   for (infidx=0; protect_info[infidx].algo
810               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
811     ;
812   if (!protect_info[infidx].algo)
813     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM); 
814
815
816   /* See wether we have a protected-at timestamp.  */
817   protect_list = s;  /* Save for later.  */
818   if (protected_at)
819     {
820       while (*s == '(')
821         {
822           prot_begin = s;
823           s++;
824           n = snext (&s);
825           if (!n)
826             return gpg_error (GPG_ERR_INV_SEXP);
827           if (smatch (&s, n, "protected-at"))
828             {
829               n = snext (&s);
830               if (!n)
831                 return gpg_error (GPG_ERR_INV_SEXP);
832               if (n != 15)
833                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
834               memcpy (protected_at, s, 15);
835               protected_at[15] = 0;
836               break;
837             }
838           s += n;
839           i = 1;
840           rc = sskip (&s, &i);
841           if (rc)
842             return rc;
843         }
844     }
845
846   /* Now find the list with the protected information.  Here is an
847      example for such a list:
848      (protected openpgp-s2k3-sha1-aes-cbc 
849         ((sha1 <salt> <count>) <Initialization_Vector>)
850         <encrypted_data>)
851    */
852   s = protect_list;
853   for (;;)
854     {
855       if (*s != '(')
856         return gpg_error (GPG_ERR_INV_SEXP);
857       prot_begin = s;
858       s++;
859       n = snext (&s);
860       if (!n)
861         return gpg_error (GPG_ERR_INV_SEXP); 
862       if (smatch (&s, n, "protected"))
863         break;
864       s += n;
865       i = 1;
866       rc = sskip (&s, &i);
867       if (rc)
868         return rc;
869     }
870   /* found */
871   n = snext (&s);
872   if (!n)
873     return gpg_error (GPG_ERR_INV_SEXP); 
874   if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
875     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
876   if (*s != '(' || s[1] != '(')
877     return gpg_error (GPG_ERR_INV_SEXP);
878   s += 2;
879   n = snext (&s);
880   if (!n)
881     return gpg_error (GPG_ERR_INV_SEXP); 
882   if (!smatch (&s, n, "sha1"))
883     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
884   n = snext (&s);
885   if (n != 8)
886     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
887   s2ksalt = s;
888   s += n;
889   n = snext (&s);
890   if (!n)
891     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
892   /* We expect a list close as next, so we can simply use strtoul()
893      here.  We might want to check that we only have digits - but this
894      is nothing we should worry about */
895   if (s[n] != ')' )
896     return gpg_error (GPG_ERR_INV_SEXP);
897   
898   /* Old versions of gpg-agent used the funny floating point number in
899      a byte encoding as specified by OpenPGP.  However this is not
900      needed and thus we now store it as a plain unsigned integer.  We
901      can easily distinguish the old format by looking at its value:
902      Less than 256 is an old-style encoded number; other values are
903      plain integers.  In any case we check that they are at least
904      65536 because we never used a lower value in the past and we
905      should have a lower limit.  */
906   s2kcount = strtoul ((const char*)s, NULL, 10);
907   if (!s2kcount)
908     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
909   if (s2kcount < 256)
910     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
911   if (s2kcount < 65536)
912     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
913
914   s += n;
915   s++; /* skip list end */
916
917   n = snext (&s);
918   if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
919     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
920   iv = s;
921   s += n;
922   if (*s != ')' )
923     return gpg_error (GPG_ERR_INV_SEXP);
924   s++;
925   n = snext (&s);
926   if (!n)
927     return gpg_error (GPG_ERR_INV_SEXP); 
928   
929   cleartext = NULL; /* Avoid cc warning. */
930   rc = do_decryption (s, n,
931                       passphrase, s2ksalt, s2kcount,
932                       iv, 16,
933                       &cleartext);
934   if (rc)
935     return rc;
936
937   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
938                     sha1hash, &final, &finallen, &cutoff, &cutlen);
939   /* Albeit cleartext has been allocated in secure memory and thus
940      xfree will wipe it out, we do an extra wipe just in case
941      somethings goes badly wrong. */
942   wipememory (cleartext, n);
943   xfree (cleartext);
944   if (rc)
945     return rc;
946
947   rc = calculate_mic (final, sha1hash2);
948   if (!rc && memcmp (sha1hash, sha1hash2, 20))
949     rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
950   if (rc)
951     {
952       wipememory (final, finallen);
953       xfree (final);
954       return rc;
955     }
956   /* Now remove tha part which is included in the MIC but should not
957      go into the final thing.  */
958   if (cutlen)
959     {
960       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
961       finallen -= cutlen;
962     }
963
964   *result = final;
965   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
966   return 0;
967 }
968
969 /* Check the type of the private key, this is one of the constants:
970    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
971    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
972    PRIVATE_KEY_PROTECTED for an protected private key or
973    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are stored
974    elsewhere. */
975 int
976 agent_private_key_type (const unsigned char *privatekey)
977 {
978   const unsigned char *s;
979   size_t n;
980
981   s = privatekey;
982   if (*s != '(')
983     return PRIVATE_KEY_UNKNOWN;
984   s++;
985   n = snext (&s);
986   if (!n)
987     return PRIVATE_KEY_UNKNOWN;
988   if (smatch (&s, n, "protected-private-key"))
989     return PRIVATE_KEY_PROTECTED;
990   if (smatch (&s, n, "shadowed-private-key"))
991     return PRIVATE_KEY_SHADOWED;
992   if (smatch (&s, n, "private-key"))
993     return PRIVATE_KEY_CLEAR;
994   return PRIVATE_KEY_UNKNOWN;
995 }
996
997
998 \f
999 /* Transform a passphrase into a suitable key of length KEYLEN and
1000    store this key in the caller provided buffer KEY.  The caller must
1001    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1002    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1003   
1004    Returns an error code on failure.  */
1005 static int
1006 hash_passphrase (const char *passphrase, int hashalgo,
1007                  int s2kmode,
1008                  const unsigned char *s2ksalt,
1009                  unsigned long s2kcount,
1010                  unsigned char *key, size_t keylen)
1011 {
1012   int rc;
1013   gcry_md_hd_t md;
1014   int pass, i;
1015   int used = 0;
1016   int pwlen = strlen (passphrase);
1017
1018   if ( (s2kmode != 0 && s2kmode != 1 && s2kmode != 3)
1019       || !hashalgo || !keylen || !key || !passphrase)
1020     return gpg_error (GPG_ERR_INV_VALUE);
1021   if ((s2kmode == 1 ||s2kmode == 3) && !s2ksalt)
1022     return gpg_error (GPG_ERR_INV_VALUE);
1023   
1024   rc = gcry_md_open (&md, hashalgo, GCRY_MD_FLAG_SECURE);
1025   if (rc)
1026     return rc;
1027
1028   for (pass=0; used < keylen; pass++)
1029     {
1030       if (pass)
1031         {
1032           gcry_md_reset (md);
1033           for (i=0; i < pass; i++) /* preset the hash context */
1034             gcry_md_putc (md, 0);
1035         }
1036
1037       if (s2kmode == 1 || s2kmode == 3)
1038         {
1039           int len2 = pwlen + 8;
1040           unsigned long count = len2;
1041
1042           if (s2kmode == 3)
1043             {
1044               count = s2kcount;
1045               if (count < len2)
1046                 count = len2;
1047             }
1048
1049           while (count > len2)
1050             {
1051               gcry_md_write (md, s2ksalt, 8);
1052               gcry_md_write (md, passphrase, pwlen);
1053               count -= len2;
1054             }
1055           if (count < 8)
1056             gcry_md_write (md, s2ksalt, count);
1057           else 
1058             {
1059               gcry_md_write (md, s2ksalt, 8);
1060               count -= 8;
1061               gcry_md_write (md, passphrase, count);
1062             }
1063         }
1064       else
1065         gcry_md_write (md, passphrase, pwlen);
1066       
1067       gcry_md_final (md);
1068       i = gcry_md_get_algo_dlen (hashalgo);
1069       if (i > keylen - used)
1070         i = keylen - used;
1071       memcpy  (key+used, gcry_md_read (md, hashalgo), i);
1072       used += i;
1073     }
1074   gcry_md_close(md);
1075   return 0;
1076 }
1077
1078
1079 \f
1080
1081 /* Create an canonical encoded S-expression with the shadow info from
1082    a card's SERIALNO and the IDSTRING.  */
1083 unsigned char *
1084 make_shadow_info (const char *serialno, const char *idstring)
1085 {
1086   const char *s;
1087   char *info, *p;
1088   char numbuf[20];
1089   size_t n;
1090
1091   for (s=serialno, n=0; *s && s[1]; s += 2)
1092     n++;
1093
1094   info = p = xtrymalloc (1 + sizeof numbuf + n
1095                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1096   if (!info)
1097     return NULL;
1098   *p++ = '(';
1099   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1100   for (s=serialno; *s && s[1]; s += 2)
1101     *(unsigned char *)p++ = xtoi_2 (s);
1102   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1103   p = stpcpy (p, idstring);
1104   *p++ = ')';
1105   *p = 0;
1106   return (unsigned char *)info;
1107 }
1108
1109
1110
1111 /* Create a shadow key from a public key.  We use the shadow protocol
1112   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1113   S-expression is returned in an allocated buffer RESULT will point
1114   to. The input parameters are expected to be valid canonicalized
1115   S-expressions */
1116 int 
1117 agent_shadow_key (const unsigned char *pubkey,
1118                   const unsigned char *shadow_info,
1119                   unsigned char **result)
1120 {
1121   const unsigned char *s;
1122   const unsigned char *point;
1123   size_t n;
1124   int depth = 0;
1125   char *p;
1126   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1127   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1128
1129   if (!pubkey_len || !shadow_info_len)
1130     return gpg_error (GPG_ERR_INV_VALUE);
1131   s = pubkey;
1132   if (*s != '(')
1133     return gpg_error (GPG_ERR_INV_SEXP);
1134   depth++;
1135   s++;
1136   n = snext (&s);
1137   if (!n)
1138     return gpg_error (GPG_ERR_INV_SEXP); 
1139   if (!smatch (&s, n, "public-key"))
1140     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
1141   if (*s != '(')
1142     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1143   depth++;
1144   s++;
1145   n = snext (&s); 
1146   if (!n)
1147     return gpg_error (GPG_ERR_INV_SEXP); 
1148   s += n; /* skip over the algorithm name */
1149
1150   while (*s != ')')
1151     {
1152       if (*s != '(')
1153         return gpg_error (GPG_ERR_INV_SEXP);
1154       depth++;
1155       s++;
1156       n = snext (&s);
1157       if (!n) 
1158         return gpg_error (GPG_ERR_INV_SEXP); 
1159       s += n;
1160       n = snext (&s);
1161       if (!n)
1162         return gpg_error (GPG_ERR_INV_SEXP); 
1163       s +=n; /* skip value */
1164       if (*s != ')')
1165         return gpg_error (GPG_ERR_INV_SEXP); 
1166       depth--;
1167       s++;
1168     }
1169   point = s; /* insert right before the point */
1170   depth--;
1171   s++;
1172   assert (depth == 1);
1173
1174   /* Calculate required length by taking in account: the "shadowed-"
1175      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1176   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1177   *result = xtrymalloc (n);
1178   p = (char*)*result;
1179   if (!p)
1180       return out_of_core ();
1181   p = stpcpy (p, "(20:shadowed-private-key");
1182   /* (10:public-key ...)*/
1183   memcpy (p, pubkey+14, point - (pubkey+14));
1184   p += point - (pubkey+14);
1185   p = stpcpy (p, "(8:shadowed5:t1-v1");
1186   memcpy (p, shadow_info, shadow_info_len);
1187   p += shadow_info_len;
1188   *p++ = ')';
1189   memcpy (p, point, pubkey_len - (point - pubkey));
1190   p += pubkey_len - (point - pubkey);
1191
1192   return 0;
1193 }
1194
1195 /* Parse a canonical encoded shadowed key and return a pointer to the
1196    inner list with the shadow_info */
1197 int 
1198 agent_get_shadow_info (const unsigned char *shadowkey,
1199                        unsigned char const **shadow_info)
1200 {
1201   const unsigned char *s;
1202   size_t n;
1203   int depth = 0;
1204
1205   s = shadowkey;
1206   if (*s != '(')
1207     return gpg_error (GPG_ERR_INV_SEXP);
1208   depth++;
1209   s++;
1210   n = snext (&s);
1211   if (!n)
1212     return gpg_error (GPG_ERR_INV_SEXP); 
1213   if (!smatch (&s, n, "shadowed-private-key"))
1214     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
1215   if (*s != '(')
1216     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1217   depth++;
1218   s++;
1219   n = snext (&s); 
1220   if (!n)
1221     return gpg_error (GPG_ERR_INV_SEXP); 
1222   s += n; /* skip over the algorithm name */
1223
1224   for (;;)
1225     {
1226       if (*s == ')')
1227         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1228       if (*s != '(')
1229         return gpg_error (GPG_ERR_INV_SEXP);
1230       depth++;
1231       s++;
1232       n = snext (&s);
1233       if (!n) 
1234         return gpg_error (GPG_ERR_INV_SEXP); 
1235       if (smatch (&s, n, "shadowed"))
1236         break;
1237       s += n;
1238       n = snext (&s);
1239       if (!n)
1240         return gpg_error (GPG_ERR_INV_SEXP); 
1241       s +=n; /* skip value */
1242       if (*s != ')')
1243         return gpg_error (GPG_ERR_INV_SEXP); 
1244       depth--;
1245       s++;
1246     }
1247   /* Found the shadowed list, S points to the protocol */
1248   n = snext (&s);
1249   if (!n) 
1250     return gpg_error (GPG_ERR_INV_SEXP); 
1251   if (smatch (&s, n, "t1-v1"))
1252     {
1253       if (*s != '(')
1254         return gpg_error (GPG_ERR_INV_SEXP);
1255       *shadow_info = s;
1256     }
1257   else
1258     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1259   return 0;
1260 }
1261
1262
1263 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1264    the hex encoded serial number is returned as a malloced strings at
1265    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1266    error an error code is returned and NULL is stored at the result
1267    parameters addresses.  If the serial number or the ID string is not
1268    required, NULL may be passed for them.  */
1269 gpg_error_t
1270 parse_shadow_info (const unsigned char *shadow_info, 
1271                    char **r_hexsn, char **r_idstr)
1272 {
1273   const unsigned char *s;
1274   size_t n;
1275
1276   if (r_hexsn)
1277     *r_hexsn = NULL;
1278   if (r_idstr)
1279     *r_idstr = NULL;
1280
1281   s = shadow_info;
1282   if (*s != '(')
1283     return gpg_error (GPG_ERR_INV_SEXP);
1284   s++;
1285   n = snext (&s);
1286   if (!n)
1287     return gpg_error (GPG_ERR_INV_SEXP);
1288
1289   if (r_hexsn)
1290     {
1291       *r_hexsn = bin2hex (s, n, NULL);
1292       if (!*r_hexsn)
1293         return gpg_error_from_syserror ();
1294     }
1295   s += n;
1296
1297   n = snext (&s);
1298   if (!n)
1299     {
1300       if (r_hexsn)
1301         {
1302           xfree (*r_hexsn);
1303           *r_hexsn = NULL;
1304         }
1305       return gpg_error (GPG_ERR_INV_SEXP);
1306     }
1307   
1308   if (r_idstr)
1309     {
1310       *r_idstr = xtrymalloc (n+1);
1311       if (!*r_idstr)
1312         {
1313           if (r_hexsn)
1314             {
1315               xfree (*r_hexsn);
1316               *r_hexsn = NULL;
1317             }
1318           return gpg_error_from_syserror ();
1319         }
1320       memcpy (*r_idstr, s, n);
1321       (*r_idstr)[n] = 0;
1322     }
1323
1324   return 0;
1325 }
1326