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