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