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