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