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