Make use of the *_NAME etc macros.
[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   int have_curve = 0;
471
472   /* Create an S-expression with the protected-at timestamp.  */
473   memcpy (timestamp_exp, "(12:protected-at15:", 19);
474   gnupg_get_isotime (timestamp_exp+19);
475   timestamp_exp[19+15] = ')';
476
477   /* Parse original key.  */
478   s = plainkey;
479   if (*s != '(')
480     return gpg_error (GPG_ERR_INV_SEXP);
481   depth++;
482   s++;
483   n = snext (&s);
484   if (!n)
485     return gpg_error (GPG_ERR_INV_SEXP);
486   if (!smatch (&s, n, "private-key"))
487     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
488   if (*s != '(')
489     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
490   depth++;
491   hash_begin = s;
492   s++;
493   n = snext (&s);
494   if (!n)
495     return gpg_error (GPG_ERR_INV_SEXP);
496
497   for (infidx=0; protect_info[infidx].algo
498               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
499     ;
500   if (!protect_info[infidx].algo)
501     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
502
503   /* The parser below is a complete mess: To make it robust for ECC
504      use we should reorder the s-expression to include only what we
505      really need and thus guarantee the right order for saving stuff.
506      This should be done before calling this function and maybe with
507      the help of the new gcry_sexp_extract_param.  */
508   parmlist      = protect_info[infidx].parmlist;
509   prot_from_idx = protect_info[infidx].prot_from;
510   prot_to_idx   = protect_info[infidx].prot_to;
511   prot_begin = prot_end = NULL;
512   for (i=0; (c=parmlist[i]); i++)
513     {
514       if (i == prot_from_idx)
515         prot_begin = s;
516       if (*s != '(')
517         return gpg_error (GPG_ERR_INV_SEXP);
518       depth++;
519       s++;
520       n = snext (&s);
521       if (!n)
522         return gpg_error (GPG_ERR_INV_SEXP);
523       if (n != 1 || c != *s)
524         {
525           if (n == 5 && !memcmp (s, "curve", 5)
526               && !i && protect_info[infidx].ecc_hack)
527             {
528               /* This is a private ECC key but the first parameter is
529                  the name of the curve.  We change the parameter list
530                  here to the one we expect in this case.  */
531               have_curve = 1;
532               parmlist = "?qd";
533               prot_from_idx = 2;
534               prot_to_idx = 2;
535             }
536           else if (n == 5 && !memcmp (s, "flags", 5)
537                    && i == 1 && have_curve)
538             {
539               /* "curve" followed by "flags": Change again.  */
540               parmlist = "??qd";
541               prot_from_idx = 3;
542               prot_to_idx = 3;
543             }
544           else
545             return gpg_error (GPG_ERR_INV_SEXP);
546         }
547       s += n;
548       n = snext (&s);
549       if (!n)
550         return gpg_error (GPG_ERR_INV_SEXP);
551       s +=n; /* skip value */
552       if (*s != ')')
553         return gpg_error (GPG_ERR_INV_SEXP);
554       depth--;
555       if (i == prot_to_idx)
556         prot_end = s;
557       s++;
558     }
559   if (*s != ')' || !prot_begin || !prot_end )
560     return gpg_error (GPG_ERR_INV_SEXP);
561   depth--;
562   hash_end = s;
563   s++;
564   /* Skip to the end of the S-expression.  */
565   assert (depth == 1);
566   rc = sskip (&s, &depth);
567   if (rc)
568     return rc;
569   assert (!depth);
570   real_end = s-1;
571
572   /* Hash the stuff.  Because the timestamp_exp won't get protected,
573      we can't simply hash a continuous buffer but need to use several
574      md_writes.  */
575   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
576   if (rc)
577     return rc;
578   gcry_md_write (md, hash_begin, hash_end - hash_begin);
579   gcry_md_write (md, timestamp_exp, 35);
580   gcry_md_write (md, ")", 1);
581   memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
582   gcry_md_close (md);
583
584   rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
585                       passphrase,  hashvalue,
586                       &protected, &protectedlen, s2k_count);
587   if (rc)
588     return rc;
589
590   /* Now create the protected version of the key.  Note that the 10
591      extra bytes are for for the inserted "protected-" string (the
592      beginning of the plaintext reads: "((11:private-key(" ).  The 35
593      term is the space for (12:protected-at15:<timestamp>).  */
594   *resultlen = (10
595                 + (prot_begin-plainkey)
596                 + protectedlen
597                 + 35
598                 + (real_end-prot_end));
599   *result = p = xtrymalloc (*resultlen);
600   if (!p)
601     {
602       gpg_error_t tmperr = out_of_core ();
603       xfree (protected);
604       return tmperr;
605     }
606   memcpy (p, "(21:protected-", 14);
607   p += 14;
608   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
609   p += prot_begin - plainkey - 4;
610   memcpy (p, protected, protectedlen);
611   p += protectedlen;
612
613   memcpy (p, timestamp_exp, 35);
614   p += 35;
615
616   memcpy (p, prot_end+1, real_end - prot_end);
617   p += real_end - prot_end;
618   assert ( p - *result == *resultlen);
619   xfree (protected);
620
621   return 0;
622 }
623
624
625 \f
626 /* Do the actual decryption and check the return list for consistency.  */
627 static int
628 do_decryption (const unsigned char *protected, size_t protectedlen,
629                const char *passphrase,
630                const unsigned char *s2ksalt, unsigned long s2kcount,
631                const unsigned char *iv, size_t ivlen,
632                unsigned char **result)
633 {
634   int rc = 0;
635   int blklen;
636   gcry_cipher_hd_t hd;
637   unsigned char *outbuf;
638   size_t reallen;
639
640   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
641   if (protectedlen < 4 || (protectedlen%blklen))
642     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
643
644   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
645                          GCRY_CIPHER_SECURE);
646   if (rc)
647     return rc;
648
649   outbuf = gcry_malloc_secure (protectedlen);
650   if (!outbuf)
651     rc = out_of_core ();
652   if (!rc)
653     rc = gcry_cipher_setiv (hd, iv, ivlen);
654   if (!rc)
655     {
656       unsigned char *key;
657       size_t keylen = PROT_CIPHER_KEYLEN;
658
659       key = gcry_malloc_secure (keylen);
660       if (!key)
661         rc = out_of_core ();
662       else
663         {
664           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
665                                 3, s2ksalt, s2kcount, key, keylen);
666           if (!rc)
667             rc = gcry_cipher_setkey (hd, key, keylen);
668           xfree (key);
669         }
670     }
671   if (!rc)
672     rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
673                               protected, protectedlen);
674   gcry_cipher_close (hd);
675   if (rc)
676     {
677       xfree (outbuf);
678       return rc;
679     }
680   /* Do a quick check first. */
681   if (*outbuf != '(' && outbuf[1] != '(')
682     {
683       xfree (outbuf);
684       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
685     }
686   /* Check that we have a consistent S-Exp. */
687   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
688   if (!reallen || (reallen + blklen < protectedlen) )
689     {
690       xfree (outbuf);
691       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
692     }
693   *result = outbuf;
694   return 0;
695 }
696
697
698 /* Merge the parameter list contained in CLEARTEXT with the original
699    protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
700    Return the new list in RESULT and the MIC value in the 20 byte
701    buffer SHA1HASH.  CUTOFF and CUTLEN will receive the offset and the
702    length of the resulting list which should go into the MIC
703    calculation but then be removed.  */
704 static int
705 merge_lists (const unsigned char *protectedkey,
706              size_t replacepos,
707              const unsigned char *cleartext,
708              unsigned char *sha1hash,
709              unsigned char **result, size_t *resultlen,
710              size_t *cutoff, size_t *cutlen)
711 {
712   size_t n, newlistlen;
713   unsigned char *newlist, *p;
714   const unsigned char *s;
715   const unsigned char *startpos, *endpos;
716   int i, rc;
717
718   *result = NULL;
719   *resultlen = 0;
720   *cutoff = 0;
721   *cutlen = 0;
722
723   if (replacepos < 26)
724     return gpg_error (GPG_ERR_BUG);
725
726   /* Estimate the required size of the resulting list.  We have a large
727      safety margin of >20 bytes (MIC hash from CLEARTEXT and the
728      removed "protected-" */
729   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
730   if (!newlistlen)
731     return gpg_error (GPG_ERR_BUG);
732   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
733   if (!n)
734     return gpg_error (GPG_ERR_BUG);
735   newlistlen += n;
736   newlist = gcry_malloc_secure (newlistlen);
737   if (!newlist)
738     return out_of_core ();
739
740   /* Copy the initial segment */
741   strcpy ((char*)newlist, "(11:private-key");
742   p = newlist + 15;
743   memcpy (p, protectedkey+15+10, replacepos-15-10);
744   p += replacepos-15-10;
745
746   /* copy the cleartext */
747   s = cleartext;
748   if (*s != '(' && s[1] != '(')
749     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
750   s += 2;
751   startpos = s;
752   while ( *s == '(' )
753     {
754       s++;
755       n = snext (&s);
756       if (!n)
757         goto invalid_sexp;
758       s += n;
759       n = snext (&s);
760       if (!n)
761         goto invalid_sexp;
762       s += n;
763       if ( *s != ')' )
764         goto invalid_sexp;
765       s++;
766     }
767   if ( *s != ')' )
768     goto invalid_sexp;
769   endpos = s;
770   s++;
771   /* Intermezzo: Get the MIC */
772   if (*s != '(')
773     goto invalid_sexp;
774   s++;
775   n = snext (&s);
776   if (!smatch (&s, n, "hash"))
777     goto invalid_sexp;
778   n = snext (&s);
779   if (!smatch (&s, n, "sha1"))
780     goto invalid_sexp;
781   n = snext (&s);
782   if (n != 20)
783     goto invalid_sexp;
784   memcpy (sha1hash, s, 20);
785   s += n;
786   if (*s != ')')
787     goto invalid_sexp;
788   /* End intermezzo */
789
790   /* append the parameter list */
791   memcpy (p, startpos, endpos - startpos);
792   p += endpos - startpos;
793
794   /* Skip over the protected list element in the original list.  */
795   s = protectedkey + replacepos;
796   assert (*s == '(');
797   s++;
798   i = 1;
799   rc = sskip (&s, &i);
800   if (rc)
801     goto failure;
802   /* Record the position of the optional protected-at expression.  */
803   if (*s == '(')
804     {
805       const unsigned char *save_s = s;
806       s++;
807       n = snext (&s);
808       if (smatch (&s, n, "protected-at"))
809         {
810           i = 1;
811           rc = sskip (&s, &i);
812           if (rc)
813             goto failure;
814           *cutlen = s - save_s;
815         }
816       s = save_s;
817     }
818   startpos = s;
819   i = 2; /* we are inside this level */
820   rc = sskip (&s, &i);
821   if (rc)
822     goto failure;
823   assert (s[-1] == ')');
824   endpos = s; /* one behind the end of the list */
825
826   /* Append the rest. */
827   if (*cutlen)
828     *cutoff = p - newlist;
829   memcpy (p, startpos, endpos - startpos);
830   p += endpos - startpos;
831
832
833   /* ready */
834   *result = newlist;
835   *resultlen = newlistlen;
836   return 0;
837
838  failure:
839   wipememory (newlist, newlistlen);
840   xfree (newlist);
841   return rc;
842
843  invalid_sexp:
844   wipememory (newlist, newlistlen);
845   xfree (newlist);
846   return gpg_error (GPG_ERR_INV_SEXP);
847 }
848
849
850
851 /* Unprotect the key encoded in canonical format.  We assume a valid
852    S-Exp here.  If a protected-at item is available, its value will
853    be stored at protected_at unless this is NULL.  */
854 int
855 agent_unprotect (ctrl_t ctrl,
856                  const unsigned char *protectedkey, const char *passphrase,
857                  gnupg_isotime_t protected_at,
858                  unsigned char **result, size_t *resultlen)
859 {
860   int rc;
861   const unsigned char *s;
862   const unsigned char *protect_list;
863   size_t n;
864   int infidx, i;
865   unsigned char sha1hash[20], sha1hash2[20];
866   const unsigned char *s2ksalt;
867   unsigned long s2kcount;
868   const unsigned char *iv;
869   const unsigned char *prot_begin;
870   unsigned char *cleartext;
871   unsigned char *final;
872   size_t finallen;
873   size_t cutoff, cutlen;
874
875   if (protected_at)
876     *protected_at = 0;
877
878   s = protectedkey;
879   if (*s != '(')
880     return gpg_error (GPG_ERR_INV_SEXP);
881   s++;
882   n = snext (&s);
883   if (!n)
884     return gpg_error (GPG_ERR_INV_SEXP);
885   if (!smatch (&s, n, "protected-private-key"))
886     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
887   if (*s != '(')
888     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
889   s++;
890   n = snext (&s);
891   if (!n)
892     return gpg_error (GPG_ERR_INV_SEXP);
893
894   for (infidx=0; protect_info[infidx].algo
895               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
896     ;
897   if (!protect_info[infidx].algo)
898     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
899
900
901   /* See wether we have a protected-at timestamp.  */
902   protect_list = s;  /* Save for later.  */
903   if (protected_at)
904     {
905       while (*s == '(')
906         {
907           prot_begin = s;
908           s++;
909           n = snext (&s);
910           if (!n)
911             return gpg_error (GPG_ERR_INV_SEXP);
912           if (smatch (&s, n, "protected-at"))
913             {
914               n = snext (&s);
915               if (!n)
916                 return gpg_error (GPG_ERR_INV_SEXP);
917               if (n != 15)
918                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
919               memcpy (protected_at, s, 15);
920               protected_at[15] = 0;
921               break;
922             }
923           s += n;
924           i = 1;
925           rc = sskip (&s, &i);
926           if (rc)
927             return rc;
928         }
929     }
930
931   /* Now find the list with the protected information.  Here is an
932      example for such a list:
933      (protected openpgp-s2k3-sha1-aes-cbc
934         ((sha1 <salt> <count>) <Initialization_Vector>)
935         <encrypted_data>)
936    */
937   s = protect_list;
938   for (;;)
939     {
940       if (*s != '(')
941         return gpg_error (GPG_ERR_INV_SEXP);
942       prot_begin = s;
943       s++;
944       n = snext (&s);
945       if (!n)
946         return gpg_error (GPG_ERR_INV_SEXP);
947       if (smatch (&s, n, "protected"))
948         break;
949       s += n;
950       i = 1;
951       rc = sskip (&s, &i);
952       if (rc)
953         return rc;
954     }
955   /* found */
956   n = snext (&s);
957   if (!n)
958     return gpg_error (GPG_ERR_INV_SEXP);
959   if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
960     {
961       if (smatch (&s, n, "openpgp-native"))
962         {
963           gcry_sexp_t s_prot_begin;
964
965           rc = gcry_sexp_sscan (&s_prot_begin, NULL,
966                                 prot_begin,
967                                 gcry_sexp_canon_len (prot_begin, 0,NULL,NULL));
968           if (rc)
969             return rc;
970
971           rc = convert_from_openpgp_native (ctrl,
972                                             s_prot_begin, passphrase, &final);
973           gcry_sexp_release (s_prot_begin);
974           if (!rc)
975             {
976               *result = final;
977               *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
978             }
979           return rc;
980         }
981       else
982         return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
983     }
984   if (*s != '(' || s[1] != '(')
985     return gpg_error (GPG_ERR_INV_SEXP);
986   s += 2;
987   n = snext (&s);
988   if (!n)
989     return gpg_error (GPG_ERR_INV_SEXP);
990   if (!smatch (&s, n, "sha1"))
991     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
992   n = snext (&s);
993   if (n != 8)
994     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
995   s2ksalt = s;
996   s += n;
997   n = snext (&s);
998   if (!n)
999     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1000   /* We expect a list close as next, so we can simply use strtoul()
1001      here.  We might want to check that we only have digits - but this
1002      is nothing we should worry about */
1003   if (s[n] != ')' )
1004     return gpg_error (GPG_ERR_INV_SEXP);
1005
1006   /* Old versions of gpg-agent used the funny floating point number in
1007      a byte encoding as specified by OpenPGP.  However this is not
1008      needed and thus we now store it as a plain unsigned integer.  We
1009      can easily distinguish the old format by looking at its value:
1010      Less than 256 is an old-style encoded number; other values are
1011      plain integers.  In any case we check that they are at least
1012      65536 because we never used a lower value in the past and we
1013      should have a lower limit.  */
1014   s2kcount = strtoul ((const char*)s, NULL, 10);
1015   if (!s2kcount)
1016     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1017   if (s2kcount < 256)
1018     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
1019   if (s2kcount < 65536)
1020     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1021
1022   s += n;
1023   s++; /* skip list end */
1024
1025   n = snext (&s);
1026   if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
1027     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1028   iv = s;
1029   s += n;
1030   if (*s != ')' )
1031     return gpg_error (GPG_ERR_INV_SEXP);
1032   s++;
1033   n = snext (&s);
1034   if (!n)
1035     return gpg_error (GPG_ERR_INV_SEXP);
1036
1037   cleartext = NULL; /* Avoid cc warning. */
1038   rc = do_decryption (s, n,
1039                       passphrase, s2ksalt, s2kcount,
1040                       iv, 16,
1041                       &cleartext);
1042   if (rc)
1043     return rc;
1044
1045   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
1046                     sha1hash, &final, &finallen, &cutoff, &cutlen);
1047   /* Albeit cleartext has been allocated in secure memory and thus
1048      xfree will wipe it out, we do an extra wipe just in case
1049      somethings goes badly wrong. */
1050   wipememory (cleartext, n);
1051   xfree (cleartext);
1052   if (rc)
1053     return rc;
1054
1055   rc = calculate_mic (final, sha1hash2);
1056   if (!rc && memcmp (sha1hash, sha1hash2, 20))
1057     rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1058   if (rc)
1059     {
1060       wipememory (final, finallen);
1061       xfree (final);
1062       return rc;
1063     }
1064   /* Now remove the part which is included in the MIC but should not
1065      go into the final thing.  */
1066   if (cutlen)
1067     {
1068       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1069       finallen -= cutlen;
1070     }
1071
1072   *result = final;
1073   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1074   return 0;
1075 }
1076
1077 /* Check the type of the private key, this is one of the constants:
1078    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1079    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1080    PRIVATE_KEY_PROTECTED for an protected private key or
1081    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are stored
1082    elsewhere. */
1083 int
1084 agent_private_key_type (const unsigned char *privatekey)
1085 {
1086   const unsigned char *s;
1087   size_t n;
1088
1089   s = privatekey;
1090   if (*s != '(')
1091     return PRIVATE_KEY_UNKNOWN;
1092   s++;
1093   n = snext (&s);
1094   if (!n)
1095     return PRIVATE_KEY_UNKNOWN;
1096   if (smatch (&s, n, "protected-private-key"))
1097     return PRIVATE_KEY_PROTECTED;
1098   if (smatch (&s, n, "shadowed-private-key"))
1099     return PRIVATE_KEY_SHADOWED;
1100   if (smatch (&s, n, "private-key"))
1101     return PRIVATE_KEY_CLEAR;
1102   return PRIVATE_KEY_UNKNOWN;
1103 }
1104
1105
1106 \f
1107 /* Transform a passphrase into a suitable key of length KEYLEN and
1108    store this key in the caller provided buffer KEY.  The caller must
1109    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1110    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1111
1112    Returns an error code on failure.  */
1113 static int
1114 hash_passphrase (const char *passphrase, int hashalgo,
1115                  int s2kmode,
1116                  const unsigned char *s2ksalt,
1117                  unsigned long s2kcount,
1118                  unsigned char *key, size_t keylen)
1119 {
1120   /* The key derive function does not support a zero length string for
1121      the passphrase in the S2K modes.  Return a better suited error
1122      code than GPG_ERR_INV_DATA.  */
1123   if (!passphrase || !*passphrase)
1124     return gpg_error (GPG_ERR_NO_PASSPHRASE);
1125   return gcry_kdf_derive (passphrase, strlen (passphrase),
1126                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1127                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1128                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1129                           hashalgo, s2ksalt, 8, s2kcount,
1130                           keylen, key);
1131 }
1132
1133
1134 gpg_error_t
1135 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1136                      int s2kmode,
1137                      const unsigned char *s2ksalt,
1138                      unsigned int s2kcount,
1139                      unsigned char *key, size_t keylen)
1140 {
1141   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1142                           S2K_DECODE_COUNT (s2kcount),
1143                           key, keylen);
1144 }
1145
1146
1147 \f
1148
1149 /* Create an canonical encoded S-expression with the shadow info from
1150    a card's SERIALNO and the IDSTRING.  */
1151 unsigned char *
1152 make_shadow_info (const char *serialno, const char *idstring)
1153 {
1154   const char *s;
1155   char *info, *p;
1156   char numbuf[20];
1157   size_t n;
1158
1159   for (s=serialno, n=0; *s && s[1]; s += 2)
1160     n++;
1161
1162   info = p = xtrymalloc (1 + sizeof numbuf + n
1163                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1164   if (!info)
1165     return NULL;
1166   *p++ = '(';
1167   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1168   for (s=serialno; *s && s[1]; s += 2)
1169     *(unsigned char *)p++ = xtoi_2 (s);
1170   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1171   p = stpcpy (p, idstring);
1172   *p++ = ')';
1173   *p = 0;
1174   return (unsigned char *)info;
1175 }
1176
1177
1178
1179 /* Create a shadow key from a public key.  We use the shadow protocol
1180   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1181   S-expression is returned in an allocated buffer RESULT will point
1182   to. The input parameters are expected to be valid canonicalized
1183   S-expressions */
1184 int
1185 agent_shadow_key (const unsigned char *pubkey,
1186                   const unsigned char *shadow_info,
1187                   unsigned char **result)
1188 {
1189   const unsigned char *s;
1190   const unsigned char *point;
1191   size_t n;
1192   int depth = 0;
1193   char *p;
1194   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1195   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1196
1197   if (!pubkey_len || !shadow_info_len)
1198     return gpg_error (GPG_ERR_INV_VALUE);
1199   s = pubkey;
1200   if (*s != '(')
1201     return gpg_error (GPG_ERR_INV_SEXP);
1202   depth++;
1203   s++;
1204   n = snext (&s);
1205   if (!n)
1206     return gpg_error (GPG_ERR_INV_SEXP);
1207   if (!smatch (&s, n, "public-key"))
1208     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1209   if (*s != '(')
1210     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1211   depth++;
1212   s++;
1213   n = snext (&s);
1214   if (!n)
1215     return gpg_error (GPG_ERR_INV_SEXP);
1216   s += n; /* skip over the algorithm name */
1217
1218   while (*s != ')')
1219     {
1220       if (*s != '(')
1221         return gpg_error (GPG_ERR_INV_SEXP);
1222       depth++;
1223       s++;
1224       n = snext (&s);
1225       if (!n)
1226         return gpg_error (GPG_ERR_INV_SEXP);
1227       s += n;
1228       n = snext (&s);
1229       if (!n)
1230         return gpg_error (GPG_ERR_INV_SEXP);
1231       s +=n; /* skip value */
1232       if (*s != ')')
1233         return gpg_error (GPG_ERR_INV_SEXP);
1234       depth--;
1235       s++;
1236     }
1237   point = s; /* insert right before the point */
1238   depth--;
1239   s++;
1240   assert (depth == 1);
1241
1242   /* Calculate required length by taking in account: the "shadowed-"
1243      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1244   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1245   *result = xtrymalloc (n);
1246   p = (char*)*result;
1247   if (!p)
1248       return out_of_core ();
1249   p = stpcpy (p, "(20:shadowed-private-key");
1250   /* (10:public-key ...)*/
1251   memcpy (p, pubkey+14, point - (pubkey+14));
1252   p += point - (pubkey+14);
1253   p = stpcpy (p, "(8:shadowed5:t1-v1");
1254   memcpy (p, shadow_info, shadow_info_len);
1255   p += shadow_info_len;
1256   *p++ = ')';
1257   memcpy (p, point, pubkey_len - (point - pubkey));
1258   p += pubkey_len - (point - pubkey);
1259
1260   return 0;
1261 }
1262
1263 /* Parse a canonical encoded shadowed key and return a pointer to the
1264    inner list with the shadow_info */
1265 int
1266 agent_get_shadow_info (const unsigned char *shadowkey,
1267                        unsigned char const **shadow_info)
1268 {
1269   const unsigned char *s;
1270   size_t n;
1271   int depth = 0;
1272
1273   s = shadowkey;
1274   if (*s != '(')
1275     return gpg_error (GPG_ERR_INV_SEXP);
1276   depth++;
1277   s++;
1278   n = snext (&s);
1279   if (!n)
1280     return gpg_error (GPG_ERR_INV_SEXP);
1281   if (!smatch (&s, n, "shadowed-private-key"))
1282     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1283   if (*s != '(')
1284     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1285   depth++;
1286   s++;
1287   n = snext (&s);
1288   if (!n)
1289     return gpg_error (GPG_ERR_INV_SEXP);
1290   s += n; /* skip over the algorithm name */
1291
1292   for (;;)
1293     {
1294       if (*s == ')')
1295         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1296       if (*s != '(')
1297         return gpg_error (GPG_ERR_INV_SEXP);
1298       depth++;
1299       s++;
1300       n = snext (&s);
1301       if (!n)
1302         return gpg_error (GPG_ERR_INV_SEXP);
1303       if (smatch (&s, n, "shadowed"))
1304         break;
1305       s += n;
1306       n = snext (&s);
1307       if (!n)
1308         return gpg_error (GPG_ERR_INV_SEXP);
1309       s +=n; /* skip value */
1310       if (*s != ')')
1311         return gpg_error (GPG_ERR_INV_SEXP);
1312       depth--;
1313       s++;
1314     }
1315   /* Found the shadowed list, S points to the protocol */
1316   n = snext (&s);
1317   if (!n)
1318     return gpg_error (GPG_ERR_INV_SEXP);
1319   if (smatch (&s, n, "t1-v1"))
1320     {
1321       if (*s != '(')
1322         return gpg_error (GPG_ERR_INV_SEXP);
1323       *shadow_info = s;
1324     }
1325   else
1326     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1327   return 0;
1328 }
1329
1330
1331 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1332    the hex encoded serial number is returned as a malloced strings at
1333    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1334    error an error code is returned and NULL is stored at the result
1335    parameters addresses.  If the serial number or the ID string is not
1336    required, NULL may be passed for them.  */
1337 gpg_error_t
1338 parse_shadow_info (const unsigned char *shadow_info,
1339                    char **r_hexsn, char **r_idstr, int *r_pinlen)
1340 {
1341   const unsigned char *s;
1342   size_t n;
1343
1344   if (r_hexsn)
1345     *r_hexsn = NULL;
1346   if (r_idstr)
1347     *r_idstr = NULL;
1348   if (r_pinlen)
1349     *r_pinlen = 0;
1350
1351   s = shadow_info;
1352   if (*s != '(')
1353     return gpg_error (GPG_ERR_INV_SEXP);
1354   s++;
1355   n = snext (&s);
1356   if (!n)
1357     return gpg_error (GPG_ERR_INV_SEXP);
1358
1359   if (r_hexsn)
1360     {
1361       *r_hexsn = bin2hex (s, n, NULL);
1362       if (!*r_hexsn)
1363         return gpg_error_from_syserror ();
1364     }
1365   s += n;
1366
1367   n = snext (&s);
1368   if (!n)
1369     {
1370       if (r_hexsn)
1371         {
1372           xfree (*r_hexsn);
1373           *r_hexsn = NULL;
1374         }
1375       return gpg_error (GPG_ERR_INV_SEXP);
1376     }
1377
1378   if (r_idstr)
1379     {
1380       *r_idstr = xtrymalloc (n+1);
1381       if (!*r_idstr)
1382         {
1383           if (r_hexsn)
1384             {
1385               xfree (*r_hexsn);
1386               *r_hexsn = NULL;
1387             }
1388           return gpg_error_from_syserror ();
1389         }
1390       memcpy (*r_idstr, s, n);
1391       (*r_idstr)[n] = 0;
1392     }
1393
1394   /* Parse the optional PINLEN.  */
1395   n = snext (&s);
1396   if (!n)
1397     return 0;
1398
1399   if (r_pinlen)
1400     {
1401       char *tmpstr = xtrymalloc (n+1);
1402       if (!tmpstr)
1403         {
1404           if (r_hexsn)
1405             {
1406               xfree (*r_hexsn);
1407               *r_hexsn = NULL;
1408             }
1409           if (r_idstr)
1410             {
1411               xfree (*r_idstr);
1412               *r_idstr = NULL;
1413             }
1414           return gpg_error_from_syserror ();
1415         }
1416       memcpy (tmpstr, s, n);
1417       tmpstr[n] = 0;
1418
1419       *r_pinlen = (int)strtol (tmpstr, NULL, 10);
1420       xfree (tmpstr);
1421     }
1422
1423   return 0;
1424 }