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