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