agent: Add const qualifier for read-only table.
[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     rc = out_of_core ();
385
386   /* Allocate a buffer for the nonce and the salt.  */
387   if (!rc)
388     {
389       /* Allocate random bytes to be used as IV, padding and s2k salt
390        * or in OCB mode for a nonce and the s2k salt.  The IV/nonce is
391        * set later because for OCB we need to set the key first.  */
392       ivsize = (use_ocb? 12 : (blklen*2)) + 8;
393       iv = xtrymalloc (ivsize);
394       if (!iv)
395         rc = gpg_error_from_syserror ();
396       else
397         {
398           gcry_create_nonce (iv, ivsize);
399           s2ksalt = iv + ivsize - 8;
400         }
401     }
402
403   /* Hash the passphrase and set the key.  */
404   if (!rc)
405     {
406       unsigned char *key;
407       size_t keylen = PROT_CIPHER_KEYLEN;
408
409       key = gcry_malloc_secure (keylen);
410       if (!key)
411         rc = out_of_core ();
412       else
413         {
414           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
415                                 3, s2ksalt,
416                                 s2k_count? s2k_count:get_standard_s2k_count(),
417                                 key, keylen);
418           if (!rc)
419             rc = gcry_cipher_setkey (hd, key, keylen);
420           xfree (key);
421         }
422     }
423
424   /* Set the IV/nonce.  */
425   if (!rc)
426     {
427       rc = gcry_cipher_setiv (hd, iv, use_ocb? 12 : blklen);
428     }
429
430   if (use_ocb)
431     {
432       /* In OCB Mode we use only the public key parameters as AAD.  */
433       rc = gcry_cipher_authenticate (hd, hashbegin, protbegin - hashbegin);
434       if (!rc)
435         rc = gcry_cipher_authenticate (hd, timestamp_exp, timestamp_exp_len);
436       if (!rc)
437         rc = gcry_cipher_authenticate
438           (hd, protbegin+protlen, hashlen - (protbegin+protlen - hashbegin));
439
440     }
441   else
442     {
443       /* Hash the entire expression for CBC mode.  Because
444        * TIMESTAMP_EXP won't get protected, we can't simply hash a
445        * continuous buffer but need to call md_write several times.  */
446       gcry_md_hd_t md;
447
448       rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
449       if (!rc)
450         {
451           gcry_md_write (md, hashbegin, protbegin - hashbegin);
452           gcry_md_write (md, protbegin, protlen);
453           gcry_md_write (md, timestamp_exp, timestamp_exp_len);
454           gcry_md_write (md, protbegin+protlen,
455                          hashlen - (protbegin+protlen - hashbegin));
456           memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
457           gcry_md_close (md);
458         }
459     }
460
461
462   /* Encrypt.  */
463   if (!rc)
464     {
465       p = outbuf;
466       *p++ = '(';
467       *p++ = '(';
468       memcpy (p, protbegin, protlen);
469       p += protlen;
470       if (use_ocb)
471         {
472           *p++ = ')';
473           *p++ = ')';
474         }
475       else
476         {
477           memcpy (p, ")(4:hash4:sha120:", 17);
478           p += 17;
479           memcpy (p, hashvalue, 20);
480           p += 20;
481           *p++ = ')';
482           *p++ = ')';
483           memcpy (p, iv+blklen, blklen); /* Add padding.  */
484           p += blklen;
485         }
486       assert ( p - outbuf == outlen);
487       if (use_ocb)
488         {
489           gcry_cipher_final (hd);
490           rc = gcry_cipher_encrypt (hd, outbuf, outlen, NULL, 0);
491           if (!rc)
492             {
493               log_assert (outlen + 16 == enclen);
494               rc = gcry_cipher_gettag (hd, outbuf + outlen, 16);
495             }
496         }
497       else
498         {
499           rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
500         }
501     }
502
503   /* Release cipher handle and check for errors.  */
504   gcry_cipher_close (hd);
505   if (rc)
506     {
507       xfree (iv);
508       xfree (outbuf);
509       return rc;
510     }
511
512   /* Now allocate the buffer we want to return.  This is
513
514      (protected openpgp-s2k3-sha1-aes-cbc
515        ((sha1 salt no_of_iterations) 16byte_iv)
516        encrypted_octet_string)
517
518      in canoncical format of course.  We use asprintf and %n modifier
519      and dummy values as placeholders.  */
520   {
521     char countbuf[35];
522
523     snprintf (countbuf, sizeof countbuf, "%lu",
524             s2k_count ? s2k_count : get_standard_s2k_count ());
525     p = xtryasprintf
526       ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
527        (int)strlen (modestr), modestr,
528        &saltpos,
529        (unsigned int)strlen (countbuf), countbuf,
530        use_ocb? 12 : blklen, &ivpos, use_ocb? 12 : blklen, "",
531        enclen, &encpos, enclen, "");
532     if (!p)
533       {
534         gpg_error_t tmperr = out_of_core ();
535         xfree (iv);
536         xfree (outbuf);
537         return tmperr;
538       }
539
540   }
541   *resultlen = strlen (p);
542   *result = (unsigned char*)p;
543   memcpy (p+saltpos, s2ksalt, 8);
544   memcpy (p+ivpos, iv, use_ocb? 12 : blklen);
545   memcpy (p+encpos, outbuf, enclen);
546   xfree (iv);
547   xfree (outbuf);
548   return 0;
549 }
550
551
552
553 /* Protect the key encoded in canonical format in PLAINKEY.  We assume
554    a valid S-Exp here.  With USE_UCB set to -1 the default scheme is
555    used (ie. either CBC or OCB), set to 0 the old CBC mode is used,
556    and set to 1 OCB is used. */
557 int
558 agent_protect (const unsigned char *plainkey, const char *passphrase,
559                unsigned char **result, size_t *resultlen,
560                unsigned long s2k_count, int use_ocb)
561 {
562   int rc;
563   const char *parmlist;
564   int prot_from_idx, prot_to_idx;
565   const unsigned char *s;
566   const unsigned char *hash_begin, *hash_end;
567   const unsigned char *prot_begin, *prot_end, *real_end;
568   size_t n;
569   int c, infidx, i;
570   char timestamp_exp[35];
571   unsigned char *protected;
572   size_t protectedlen;
573   int depth = 0;
574   unsigned char *p;
575   int have_curve = 0;
576
577   if (use_ocb == -1)
578     use_ocb = opt.enable_extended_key_format;
579
580   /* Create an S-expression with the protected-at timestamp.  */
581   memcpy (timestamp_exp, "(12:protected-at15:", 19);
582   gnupg_get_isotime (timestamp_exp+19);
583   timestamp_exp[19+15] = ')';
584
585   /* Parse original key.  */
586   s = plainkey;
587   if (*s != '(')
588     return gpg_error (GPG_ERR_INV_SEXP);
589   depth++;
590   s++;
591   n = snext (&s);
592   if (!n)
593     return gpg_error (GPG_ERR_INV_SEXP);
594   if (!smatch (&s, n, "private-key"))
595     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
596   if (*s != '(')
597     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
598   depth++;
599   hash_begin = s;
600   s++;
601   n = snext (&s);
602   if (!n)
603     return gpg_error (GPG_ERR_INV_SEXP);
604
605   for (infidx=0; protect_info[infidx].algo
606               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
607     ;
608   if (!protect_info[infidx].algo)
609     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
610
611   /* The parser below is a complete mess: To make it robust for ECC
612      use we should reorder the s-expression to include only what we
613      really need and thus guarantee the right order for saving stuff.
614      This should be done before calling this function and maybe with
615      the help of the new gcry_sexp_extract_param.  */
616   parmlist      = protect_info[infidx].parmlist;
617   prot_from_idx = protect_info[infidx].prot_from;
618   prot_to_idx   = protect_info[infidx].prot_to;
619   prot_begin = prot_end = NULL;
620   for (i=0; (c=parmlist[i]); i++)
621     {
622       if (i == prot_from_idx)
623         prot_begin = s;
624       if (*s != '(')
625         return gpg_error (GPG_ERR_INV_SEXP);
626       depth++;
627       s++;
628       n = snext (&s);
629       if (!n)
630         return gpg_error (GPG_ERR_INV_SEXP);
631       if (n != 1 || c != *s)
632         {
633           if (n == 5 && !memcmp (s, "curve", 5)
634               && !i && protect_info[infidx].ecc_hack)
635             {
636               /* This is a private ECC key but the first parameter is
637                  the name of the curve.  We change the parameter list
638                  here to the one we expect in this case.  */
639               have_curve = 1;
640               parmlist = "?qd";
641               prot_from_idx = 2;
642               prot_to_idx = 2;
643             }
644           else if (n == 5 && !memcmp (s, "flags", 5)
645                    && i == 1 && have_curve)
646             {
647               /* "curve" followed by "flags": Change again.  */
648               parmlist = "??qd";
649               prot_from_idx = 3;
650               prot_to_idx = 3;
651             }
652           else
653             return gpg_error (GPG_ERR_INV_SEXP);
654         }
655       s += n;
656       n = snext (&s);
657       if (!n)
658         return gpg_error (GPG_ERR_INV_SEXP);
659       s +=n; /* skip value */
660       if (*s != ')')
661         return gpg_error (GPG_ERR_INV_SEXP);
662       depth--;
663       if (i == prot_to_idx)
664         prot_end = s;
665       s++;
666     }
667   if (*s != ')' || !prot_begin || !prot_end )
668     return gpg_error (GPG_ERR_INV_SEXP);
669   depth--;
670   hash_end = s;
671   s++;
672   /* Skip to the end of the S-expression.  */
673   assert (depth == 1);
674   rc = sskip (&s, &depth);
675   if (rc)
676     return rc;
677   assert (!depth);
678   real_end = s-1;
679
680   rc = do_encryption (hash_begin, hash_end - hash_begin + 1,
681                       prot_begin, prot_end - prot_begin + 1,
682                       passphrase, timestamp_exp, sizeof (timestamp_exp),
683                       &protected, &protectedlen, s2k_count, use_ocb);
684   if (rc)
685     return rc;
686
687   /* Now create the protected version of the key.  Note that the 10
688      extra bytes are for the inserted "protected-" string (the
689      beginning of the plaintext reads: "((11:private-key(" ).  The 35
690      term is the space for (12:protected-at15:<timestamp>).  */
691   *resultlen = (10
692                 + (prot_begin-plainkey)
693                 + protectedlen
694                 + 35
695                 + (real_end-prot_end));
696   *result = p = xtrymalloc (*resultlen);
697   if (!p)
698     {
699       gpg_error_t tmperr = out_of_core ();
700       xfree (protected);
701       return tmperr;
702     }
703   memcpy (p, "(21:protected-", 14);
704   p += 14;
705   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
706   p += prot_begin - plainkey - 4;
707   memcpy (p, protected, protectedlen);
708   p += protectedlen;
709
710   memcpy (p, timestamp_exp, 35);
711   p += 35;
712
713   memcpy (p, prot_end+1, real_end - prot_end);
714   p += real_end - prot_end;
715   assert ( p - *result == *resultlen);
716   xfree (protected);
717
718   return 0;
719 }
720
721
722 \f
723 /* Do the actual decryption and check the return list for consistency.  */
724 static int
725 do_decryption (const unsigned char *aad_begin, size_t aad_len,
726                const unsigned char *aadhole_begin, size_t aadhole_len,
727                const unsigned char *protected, size_t protectedlen,
728                const char *passphrase,
729                const unsigned char *s2ksalt, unsigned long s2kcount,
730                const unsigned char *iv, size_t ivlen,
731                int prot_cipher, int prot_cipher_keylen, int is_ocb,
732                unsigned char **result)
733 {
734   int rc = 0;
735   int blklen;
736   gcry_cipher_hd_t hd;
737   unsigned char *outbuf;
738   size_t reallen;
739
740   blklen = gcry_cipher_get_algo_blklen (prot_cipher);
741   if (is_ocb)
742     {
743       /* OCB does not require a multiple of the block length but we
744        * check that it is long enough for the 128 bit tag and that we
745        * have the 96 bit nonce.  */
746       if (protectedlen < (4 + 16) || ivlen != 12)
747         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
748     }
749   else
750     {
751       if (protectedlen < 4 || (protectedlen%blklen))
752         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
753     }
754
755   rc = gcry_cipher_open (&hd, prot_cipher,
756                          is_ocb? GCRY_CIPHER_MODE_OCB :
757                          GCRY_CIPHER_MODE_CBC,
758                          GCRY_CIPHER_SECURE);
759   if (rc)
760     return rc;
761
762   outbuf = gcry_malloc_secure (protectedlen);
763   if (!outbuf)
764     rc = out_of_core ();
765
766   /* Hash the passphrase and set the key.  */
767   if (!rc)
768     {
769       unsigned char *key;
770
771       key = gcry_malloc_secure (prot_cipher_keylen);
772       if (!key)
773         rc = out_of_core ();
774       else
775         {
776           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
777                                 3, s2ksalt, s2kcount, key, prot_cipher_keylen);
778           if (!rc)
779             rc = gcry_cipher_setkey (hd, key, prot_cipher_keylen);
780           xfree (key);
781         }
782     }
783
784   /* Set the IV/nonce.  */
785   if (!rc)
786     {
787       rc = gcry_cipher_setiv (hd, iv, ivlen);
788     }
789
790   /* Decrypt.  */
791   if (!rc)
792     {
793       if (is_ocb)
794         {
795           rc = gcry_cipher_authenticate (hd, aad_begin,
796                                          aadhole_begin - aad_begin);
797           if (!rc)
798             rc = gcry_cipher_authenticate
799               (hd, aadhole_begin + aadhole_len,
800                aad_len - (aadhole_begin+aadhole_len - aad_begin));
801
802           if (!rc)
803             {
804               gcry_cipher_final (hd);
805               rc = gcry_cipher_decrypt (hd, outbuf, protectedlen - 16,
806                                         protected, protectedlen - 16);
807             }
808           if (!rc)
809             rc = gcry_cipher_checktag (hd, protected + protectedlen - 16, 16);
810         }
811       else
812         {
813           rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
814                                     protected, protectedlen);
815         }
816     }
817
818   /* Release cipher handle and check for errors.  */
819   gcry_cipher_close (hd);
820   if (rc)
821     {
822       xfree (outbuf);
823       return rc;
824     }
825
826   /* Do a quick check on the data structure. */
827   if (*outbuf != '(' && outbuf[1] != '(')
828     {
829       /* Note that in OCB mode this is actually invalid _encrypted_
830        * data and not a bad passphrase.  */
831       xfree (outbuf);
832       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
833     }
834
835   /* Check that we have a consistent S-Exp. */
836   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
837   if (!reallen || (reallen + blklen < protectedlen) )
838     {
839       xfree (outbuf);
840       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
841     }
842   *result = outbuf;
843   return 0;
844 }
845
846
847 /* Merge the parameter list contained in CLEARTEXT with the original
848  * protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
849  * Return the new list in RESULT and the MIC value in the 20 byte
850  * buffer SHA1HASH; if SHA1HASH is NULL no MIC will be computed.
851  * CUTOFF and CUTLEN will receive the offset and the length of the
852  * resulting list which should go into the MIC calculation but then be
853  * removed.  */
854 static int
855 merge_lists (const unsigned char *protectedkey,
856              size_t replacepos,
857              const unsigned char *cleartext,
858              unsigned char *sha1hash,
859              unsigned char **result, size_t *resultlen,
860              size_t *cutoff, size_t *cutlen)
861 {
862   size_t n, newlistlen;
863   unsigned char *newlist, *p;
864   const unsigned char *s;
865   const unsigned char *startpos, *endpos;
866   int i, rc;
867
868   *result = NULL;
869   *resultlen = 0;
870   *cutoff = 0;
871   *cutlen = 0;
872
873   if (replacepos < 26)
874     return gpg_error (GPG_ERR_BUG);
875
876   /* Estimate the required size of the resulting list.  We have a large
877      safety margin of >20 bytes (FIXME: MIC hash from CLEARTEXT and the
878      removed "protected-" */
879   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
880   if (!newlistlen)
881     return gpg_error (GPG_ERR_BUG);
882   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
883   if (!n)
884     return gpg_error (GPG_ERR_BUG);
885   newlistlen += n;
886   newlist = gcry_malloc_secure (newlistlen);
887   if (!newlist)
888     return out_of_core ();
889
890   /* Copy the initial segment */
891   strcpy ((char*)newlist, "(11:private-key");
892   p = newlist + 15;
893   memcpy (p, protectedkey+15+10, replacepos-15-10);
894   p += replacepos-15-10;
895
896   /* Copy the cleartext.  */
897   s = cleartext;
898   if (*s != '(' && s[1] != '(')
899     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
900   s += 2;
901   startpos = s;
902   while ( *s == '(' )
903     {
904       s++;
905       n = snext (&s);
906       if (!n)
907         goto invalid_sexp;
908       s += n;
909       n = snext (&s);
910       if (!n)
911         goto invalid_sexp;
912       s += n;
913       if ( *s != ')' )
914         goto invalid_sexp;
915       s++;
916     }
917   if ( *s != ')' )
918     goto invalid_sexp;
919   endpos = s;
920   s++;
921
922   /* Intermezzo: Get the MIC if requested.  */
923   if (sha1hash)
924     {
925       if (*s != '(')
926         goto invalid_sexp;
927       s++;
928       n = snext (&s);
929       if (!smatch (&s, n, "hash"))
930         goto invalid_sexp;
931       n = snext (&s);
932       if (!smatch (&s, n, "sha1"))
933         goto invalid_sexp;
934       n = snext (&s);
935       if (n != 20)
936         goto invalid_sexp;
937       memcpy (sha1hash, s, 20);
938       s += n;
939       if (*s != ')')
940         goto invalid_sexp;
941     }
942
943   /* Append the parameter list.  */
944   memcpy (p, startpos, endpos - startpos);
945   p += endpos - startpos;
946
947   /* Skip over the protected list element in the original list.  */
948   s = protectedkey + replacepos;
949   assert (*s == '(');
950   s++;
951   i = 1;
952   rc = sskip (&s, &i);
953   if (rc)
954     goto failure;
955   /* Record the position of the optional protected-at expression.  */
956   if (*s == '(')
957     {
958       const unsigned char *save_s = s;
959       s++;
960       n = snext (&s);
961       if (smatch (&s, n, "protected-at"))
962         {
963           i = 1;
964           rc = sskip (&s, &i);
965           if (rc)
966             goto failure;
967           *cutlen = s - save_s;
968         }
969       s = save_s;
970     }
971   startpos = s;
972   i = 2; /* we are inside this level */
973   rc = sskip (&s, &i);
974   if (rc)
975     goto failure;
976   assert (s[-1] == ')');
977   endpos = s; /* one behind the end of the list */
978
979   /* Append the rest. */
980   if (*cutlen)
981     *cutoff = p - newlist;
982   memcpy (p, startpos, endpos - startpos);
983   p += endpos - startpos;
984
985
986   /* ready */
987   *result = newlist;
988   *resultlen = newlistlen;
989   return 0;
990
991  failure:
992   wipememory (newlist, newlistlen);
993   xfree (newlist);
994   return rc;
995
996  invalid_sexp:
997   wipememory (newlist, newlistlen);
998   xfree (newlist);
999   return gpg_error (GPG_ERR_INV_SEXP);
1000 }
1001
1002
1003
1004 /* Unprotect the key encoded in canonical format.  We assume a valid
1005    S-Exp here.  If a protected-at item is available, its value will
1006    be stored at protected_at unless this is NULL.  */
1007 int
1008 agent_unprotect (ctrl_t ctrl,
1009                  const unsigned char *protectedkey, const char *passphrase,
1010                  gnupg_isotime_t protected_at,
1011                  unsigned char **result, size_t *resultlen)
1012 {
1013   static const struct {
1014     const char *name; /* Name of the protection method. */
1015     int algo;         /* (A zero indicates the "openpgp-native" hack.)  */
1016     int keylen;       /* Used key length in bytes.  */
1017     unsigned int is_ocb:1;
1018   } algotable[] = {
1019     { "openpgp-s2k3-sha1-aes-cbc",    GCRY_CIPHER_AES128, (128/8)},
1020     { "openpgp-s2k3-sha1-aes256-cbc", GCRY_CIPHER_AES256, (256/8)},
1021     { "openpgp-s2k3-ocb-aes",         GCRY_CIPHER_AES128, (128/8), 1},
1022     { "openpgp-native", 0, 0 }
1023   };
1024   int rc;
1025   const unsigned char *s;
1026   const unsigned char *protect_list;
1027   size_t n;
1028   int infidx, i;
1029   unsigned char sha1hash[20], sha1hash2[20];
1030   const unsigned char *s2ksalt;
1031   unsigned long s2kcount;
1032   const unsigned char *iv;
1033   int prot_cipher, prot_cipher_keylen;
1034   int is_ocb;
1035   const unsigned char *aad_begin, *aad_end, *aadhole_begin, *aadhole_end;
1036   const unsigned char *prot_begin;
1037   unsigned char *cleartext;
1038   unsigned char *final;
1039   size_t finallen;
1040   size_t cutoff, cutlen;
1041
1042   if (protected_at)
1043     *protected_at = 0;
1044
1045   s = protectedkey;
1046   if (*s != '(')
1047     return gpg_error (GPG_ERR_INV_SEXP);
1048   s++;
1049   n = snext (&s);
1050   if (!n)
1051     return gpg_error (GPG_ERR_INV_SEXP);
1052   if (!smatch (&s, n, "protected-private-key"))
1053     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1054   if (*s != '(')
1055     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1056   {
1057     aad_begin = aad_end = s;
1058     aad_end++;
1059     i = 1;
1060     rc = sskip (&aad_end, &i);
1061     if (rc)
1062       return rc;
1063   }
1064
1065   s++;
1066   n = snext (&s);
1067   if (!n)
1068     return gpg_error (GPG_ERR_INV_SEXP);
1069
1070   for (infidx=0; protect_info[infidx].algo
1071               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
1072     ;
1073   if (!protect_info[infidx].algo)
1074     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1075
1076   /* See wether we have a protected-at timestamp.  */
1077   protect_list = s;  /* Save for later.  */
1078   if (protected_at)
1079     {
1080       while (*s == '(')
1081         {
1082           prot_begin = s;
1083           s++;
1084           n = snext (&s);
1085           if (!n)
1086             return gpg_error (GPG_ERR_INV_SEXP);
1087           if (smatch (&s, n, "protected-at"))
1088             {
1089               n = snext (&s);
1090               if (!n)
1091                 return gpg_error (GPG_ERR_INV_SEXP);
1092               if (n != 15)
1093                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1094               memcpy (protected_at, s, 15);
1095               protected_at[15] = 0;
1096               break;
1097             }
1098           s += n;
1099           i = 1;
1100           rc = sskip (&s, &i);
1101           if (rc)
1102             return rc;
1103         }
1104     }
1105
1106   /* Now find the list with the protected information.  Here is an
1107      example for such a list:
1108      (protected openpgp-s2k3-sha1-aes-cbc
1109         ((sha1 <salt> <count>) <Initialization_Vector>)
1110         <encrypted_data>)
1111    */
1112   s = protect_list;
1113   for (;;)
1114     {
1115       if (*s != '(')
1116         return gpg_error (GPG_ERR_INV_SEXP);
1117       prot_begin = s;
1118       s++;
1119       n = snext (&s);
1120       if (!n)
1121         return gpg_error (GPG_ERR_INV_SEXP);
1122       if (smatch (&s, n, "protected"))
1123         break;
1124       s += n;
1125       i = 1;
1126       rc = sskip (&s, &i);
1127       if (rc)
1128         return rc;
1129     }
1130   /* found */
1131   {
1132     aadhole_begin = aadhole_end = prot_begin;
1133     aadhole_end++;
1134     i = 1;
1135     rc = sskip (&aadhole_end, &i);
1136     if (rc)
1137       return rc;
1138   }
1139   n = snext (&s);
1140   if (!n)
1141     return gpg_error (GPG_ERR_INV_SEXP);
1142
1143   /* Lookup the protection algo.  */
1144   prot_cipher = 0;        /* (avoid gcc warning) */
1145   prot_cipher_keylen = 0; /* (avoid gcc warning) */
1146   is_ocb = 0;
1147   for (i=0; i < DIM (algotable); i++)
1148     if (smatch (&s, n, algotable[i].name))
1149       {
1150         prot_cipher = algotable[i].algo;
1151         prot_cipher_keylen = algotable[i].keylen;
1152         is_ocb = algotable[i].is_ocb;
1153         break;
1154       }
1155   if (i == DIM (algotable))
1156     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1157
1158   if (!prot_cipher)  /* This is "openpgp-native".  */
1159     {
1160       gcry_sexp_t s_prot_begin;
1161
1162       rc = gcry_sexp_sscan (&s_prot_begin, NULL,
1163                             prot_begin,
1164                             gcry_sexp_canon_len (prot_begin, 0,NULL,NULL));
1165       if (rc)
1166         return rc;
1167
1168       rc = convert_from_openpgp_native (ctrl, s_prot_begin, passphrase, &final);
1169       gcry_sexp_release (s_prot_begin);
1170       if (!rc)
1171         {
1172           *result = final;
1173           *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1174         }
1175       return rc;
1176     }
1177
1178   if (*s != '(' || s[1] != '(')
1179     return gpg_error (GPG_ERR_INV_SEXP);
1180   s += 2;
1181   n = snext (&s);
1182   if (!n)
1183     return gpg_error (GPG_ERR_INV_SEXP);
1184   if (!smatch (&s, n, "sha1"))
1185     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1186   n = snext (&s);
1187   if (n != 8)
1188     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1189   s2ksalt = s;
1190   s += n;
1191   n = snext (&s);
1192   if (!n)
1193     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1194   /* We expect a list close as next, so we can simply use strtoul()
1195      here.  We might want to check that we only have digits - but this
1196      is nothing we should worry about */
1197   if (s[n] != ')' )
1198     return gpg_error (GPG_ERR_INV_SEXP);
1199
1200   /* Old versions of gpg-agent used the funny floating point number in
1201      a byte encoding as specified by OpenPGP.  However this is not
1202      needed and thus we now store it as a plain unsigned integer.  We
1203      can easily distinguish the old format by looking at its value:
1204      Less than 256 is an old-style encoded number; other values are
1205      plain integers.  In any case we check that they are at least
1206      65536 because we never used a lower value in the past and we
1207      should have a lower limit.  */
1208   s2kcount = strtoul ((const char*)s, NULL, 10);
1209   if (!s2kcount)
1210     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1211   if (s2kcount < 256)
1212     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
1213   if (s2kcount < 65536)
1214     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1215
1216   s += n;
1217   s++; /* skip list end */
1218
1219   n = snext (&s);
1220   if (is_ocb)
1221     {
1222       if (n != 12) /* Wrong size of the nonce. */
1223         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1224     }
1225   else
1226     {
1227       if (n != 16) /* Wrong blocksize for IV (we support only 128 bit). */
1228         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1229     }
1230   iv = s;
1231   s += n;
1232   if (*s != ')' )
1233     return gpg_error (GPG_ERR_INV_SEXP);
1234   s++;
1235   n = snext (&s);
1236   if (!n)
1237     return gpg_error (GPG_ERR_INV_SEXP);
1238
1239   cleartext = NULL; /* Avoid cc warning. */
1240   rc = do_decryption (aad_begin, aad_end - aad_begin,
1241                       aadhole_begin, aadhole_end - aadhole_begin,
1242                       s, n,
1243                       passphrase, s2ksalt, s2kcount,
1244                       iv, is_ocb? 12:16,
1245                       prot_cipher, prot_cipher_keylen, is_ocb,
1246                       &cleartext);
1247   if (rc)
1248     return rc;
1249
1250   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
1251                     is_ocb? NULL : sha1hash,
1252                     &final, &finallen, &cutoff, &cutlen);
1253   /* Albeit cleartext has been allocated in secure memory and thus
1254      xfree will wipe it out, we do an extra wipe just in case
1255      somethings goes badly wrong. */
1256   wipememory (cleartext, n);
1257   xfree (cleartext);
1258   if (rc)
1259     return rc;
1260
1261   if (!is_ocb)
1262     {
1263       rc = calculate_mic (final, sha1hash2);
1264       if (!rc && memcmp (sha1hash, sha1hash2, 20))
1265         rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1266       if (rc)
1267         {
1268           wipememory (final, finallen);
1269           xfree (final);
1270           return rc;
1271         }
1272     }
1273
1274   /* Now remove the part which is included in the MIC but should not
1275      go into the final thing.  */
1276   if (cutlen)
1277     {
1278       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1279       finallen -= cutlen;
1280     }
1281
1282   *result = final;
1283   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1284   return 0;
1285 }
1286
1287 /* Check the type of the private key, this is one of the constants:
1288    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1289    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1290    PRIVATE_KEY_PROTECTED for an protected private key or
1291    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are
1292    stored elsewhere.  Finally PRIVATE_KEY_OPENPGP_NONE may be returned
1293    is the key is still in the openpgp-native format but without
1294    protection.  */
1295 int
1296 agent_private_key_type (const unsigned char *privatekey)
1297 {
1298   const unsigned char *s;
1299   size_t n;
1300   int i;
1301
1302   s = privatekey;
1303   if (*s != '(')
1304     return PRIVATE_KEY_UNKNOWN;
1305   s++;
1306   n = snext (&s);
1307   if (!n)
1308     return PRIVATE_KEY_UNKNOWN;
1309   if (smatch (&s, n, "protected-private-key"))
1310     {
1311       /* We need to check whether this is openpgp-native protected
1312          with the protection method "none".  In that case we return a
1313          different key type so that the caller knows that there is no
1314          need to ask for a passphrase. */
1315       if (*s != '(')
1316         return PRIVATE_KEY_PROTECTED; /* Unknown sexp - assume protected. */
1317       s++;
1318       n = snext (&s);
1319       if (!n)
1320         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1321       s += n; /* Skip over the algo */
1322
1323       /* Find the (protected ...) list.  */
1324       for (;;)
1325         {
1326           if (*s != '(')
1327             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1328           s++;
1329           n = snext (&s);
1330           if (!n)
1331             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1332           if (smatch (&s, n, "protected"))
1333             break;
1334           s += n;
1335           i = 1;
1336           if (sskip (&s, &i))
1337             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1338         }
1339       /* Found - Is this openpgp-native? */
1340       n = snext (&s);
1341       if (!n)
1342         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1343       if (smatch (&s, n, "openpgp-native")) /* Yes.  */
1344         {
1345           if (*s != '(')
1346             return PRIVATE_KEY_UNKNOWN; /* Unknown sexp. */
1347           s++;
1348           n = snext (&s);
1349           if (!n)
1350             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1351           s += n; /* Skip over "openpgp-private-key".  */
1352           /* Find the (protection ...) list.  */
1353           for (;;)
1354             {
1355               if (*s != '(')
1356                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1357               s++;
1358               n = snext (&s);
1359               if (!n)
1360                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1361               if (smatch (&s, n, "protection"))
1362                 break;
1363               s += n;
1364               i = 1;
1365               if (sskip (&s, &i))
1366                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1367             }
1368           /* Found - Is the mode "none"? */
1369           n = snext (&s);
1370           if (!n)
1371             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1372           if (smatch (&s, n, "none"))
1373             return PRIVATE_KEY_OPENPGP_NONE;  /* Yes.  */
1374         }
1375
1376       return PRIVATE_KEY_PROTECTED;
1377     }
1378   if (smatch (&s, n, "shadowed-private-key"))
1379     return PRIVATE_KEY_SHADOWED;
1380   if (smatch (&s, n, "private-key"))
1381     return PRIVATE_KEY_CLEAR;
1382   return PRIVATE_KEY_UNKNOWN;
1383 }
1384
1385
1386 \f
1387 /* Transform a passphrase into a suitable key of length KEYLEN and
1388    store this key in the caller provided buffer KEY.  The caller must
1389    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1390    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1391
1392    Returns an error code on failure.  */
1393 static int
1394 hash_passphrase (const char *passphrase, int hashalgo,
1395                  int s2kmode,
1396                  const unsigned char *s2ksalt,
1397                  unsigned long s2kcount,
1398                  unsigned char *key, size_t keylen)
1399 {
1400   /* The key derive function does not support a zero length string for
1401      the passphrase in the S2K modes.  Return a better suited error
1402      code than GPG_ERR_INV_DATA.  */
1403   if (!passphrase || !*passphrase)
1404     return gpg_error (GPG_ERR_NO_PASSPHRASE);
1405   return gcry_kdf_derive (passphrase, strlen (passphrase),
1406                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1407                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1408                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1409                           hashalgo, s2ksalt, 8, s2kcount,
1410                           keylen, key);
1411 }
1412
1413
1414 gpg_error_t
1415 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1416                      int s2kmode,
1417                      const unsigned char *s2ksalt,
1418                      unsigned int s2kcount,
1419                      unsigned char *key, size_t keylen)
1420 {
1421   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1422                           S2K_DECODE_COUNT (s2kcount),
1423                           key, keylen);
1424 }
1425
1426
1427 \f
1428
1429 /* Create an canonical encoded S-expression with the shadow info from
1430    a card's SERIALNO and the IDSTRING.  */
1431 unsigned char *
1432 make_shadow_info (const char *serialno, const char *idstring)
1433 {
1434   const char *s;
1435   char *info, *p;
1436   char numbuf[20];
1437   size_t n;
1438
1439   for (s=serialno, n=0; *s && s[1]; s += 2)
1440     n++;
1441
1442   info = p = xtrymalloc (1 + sizeof numbuf + n
1443                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1444   if (!info)
1445     return NULL;
1446   *p++ = '(';
1447   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1448   for (s=serialno; *s && s[1]; s += 2)
1449     *(unsigned char *)p++ = xtoi_2 (s);
1450   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1451   p = stpcpy (p, idstring);
1452   *p++ = ')';
1453   *p = 0;
1454   return (unsigned char *)info;
1455 }
1456
1457
1458
1459 /* Create a shadow key from a public key.  We use the shadow protocol
1460   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1461   S-expression is returned in an allocated buffer RESULT will point
1462   to. The input parameters are expected to be valid canonicalized
1463   S-expressions */
1464 int
1465 agent_shadow_key (const unsigned char *pubkey,
1466                   const unsigned char *shadow_info,
1467                   unsigned char **result)
1468 {
1469   const unsigned char *s;
1470   const unsigned char *point;
1471   size_t n;
1472   int depth = 0;
1473   char *p;
1474   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1475   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1476
1477   if (!pubkey_len || !shadow_info_len)
1478     return gpg_error (GPG_ERR_INV_VALUE);
1479   s = pubkey;
1480   if (*s != '(')
1481     return gpg_error (GPG_ERR_INV_SEXP);
1482   depth++;
1483   s++;
1484   n = snext (&s);
1485   if (!n)
1486     return gpg_error (GPG_ERR_INV_SEXP);
1487   if (!smatch (&s, n, "public-key"))
1488     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1489   if (*s != '(')
1490     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1491   depth++;
1492   s++;
1493   n = snext (&s);
1494   if (!n)
1495     return gpg_error (GPG_ERR_INV_SEXP);
1496   s += n; /* skip over the algorithm name */
1497
1498   while (*s != ')')
1499     {
1500       if (*s != '(')
1501         return gpg_error (GPG_ERR_INV_SEXP);
1502       depth++;
1503       s++;
1504       n = snext (&s);
1505       if (!n)
1506         return gpg_error (GPG_ERR_INV_SEXP);
1507       s += n;
1508       n = snext (&s);
1509       if (!n)
1510         return gpg_error (GPG_ERR_INV_SEXP);
1511       s +=n; /* skip value */
1512       if (*s != ')')
1513         return gpg_error (GPG_ERR_INV_SEXP);
1514       depth--;
1515       s++;
1516     }
1517   point = s; /* insert right before the point */
1518   depth--;
1519   s++;
1520   assert (depth == 1);
1521
1522   /* Calculate required length by taking in account: the "shadowed-"
1523      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1524   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1525   *result = xtrymalloc (n);
1526   p = (char*)*result;
1527   if (!p)
1528       return out_of_core ();
1529   p = stpcpy (p, "(20:shadowed-private-key");
1530   /* (10:public-key ...)*/
1531   memcpy (p, pubkey+14, point - (pubkey+14));
1532   p += point - (pubkey+14);
1533   p = stpcpy (p, "(8:shadowed5:t1-v1");
1534   memcpy (p, shadow_info, shadow_info_len);
1535   p += shadow_info_len;
1536   *p++ = ')';
1537   memcpy (p, point, pubkey_len - (point - pubkey));
1538   p += pubkey_len - (point - pubkey);
1539
1540   return 0;
1541 }
1542
1543 /* Parse a canonical encoded shadowed key and return a pointer to the
1544    inner list with the shadow_info */
1545 int
1546 agent_get_shadow_info (const unsigned char *shadowkey,
1547                        unsigned char const **shadow_info)
1548 {
1549   const unsigned char *s;
1550   size_t n;
1551   int depth = 0;
1552
1553   s = shadowkey;
1554   if (*s != '(')
1555     return gpg_error (GPG_ERR_INV_SEXP);
1556   depth++;
1557   s++;
1558   n = snext (&s);
1559   if (!n)
1560     return gpg_error (GPG_ERR_INV_SEXP);
1561   if (!smatch (&s, n, "shadowed-private-key"))
1562     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1563   if (*s != '(')
1564     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1565   depth++;
1566   s++;
1567   n = snext (&s);
1568   if (!n)
1569     return gpg_error (GPG_ERR_INV_SEXP);
1570   s += n; /* skip over the algorithm name */
1571
1572   for (;;)
1573     {
1574       if (*s == ')')
1575         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1576       if (*s != '(')
1577         return gpg_error (GPG_ERR_INV_SEXP);
1578       depth++;
1579       s++;
1580       n = snext (&s);
1581       if (!n)
1582         return gpg_error (GPG_ERR_INV_SEXP);
1583       if (smatch (&s, n, "shadowed"))
1584         break;
1585       s += n;
1586       n = snext (&s);
1587       if (!n)
1588         return gpg_error (GPG_ERR_INV_SEXP);
1589       s +=n; /* skip value */
1590       if (*s != ')')
1591         return gpg_error (GPG_ERR_INV_SEXP);
1592       depth--;
1593       s++;
1594     }
1595   /* Found the shadowed list, S points to the protocol */
1596   n = snext (&s);
1597   if (!n)
1598     return gpg_error (GPG_ERR_INV_SEXP);
1599   if (smatch (&s, n, "t1-v1"))
1600     {
1601       if (*s != '(')
1602         return gpg_error (GPG_ERR_INV_SEXP);
1603       *shadow_info = s;
1604     }
1605   else
1606     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1607   return 0;
1608 }
1609
1610
1611 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1612    the hex encoded serial number is returned as a malloced strings at
1613    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1614    error an error code is returned and NULL is stored at the result
1615    parameters addresses.  If the serial number or the ID string is not
1616    required, NULL may be passed for them.  */
1617 gpg_error_t
1618 parse_shadow_info (const unsigned char *shadow_info,
1619                    char **r_hexsn, char **r_idstr, int *r_pinlen)
1620 {
1621   const unsigned char *s;
1622   size_t n;
1623
1624   if (r_hexsn)
1625     *r_hexsn = NULL;
1626   if (r_idstr)
1627     *r_idstr = NULL;
1628   if (r_pinlen)
1629     *r_pinlen = 0;
1630
1631   s = shadow_info;
1632   if (*s != '(')
1633     return gpg_error (GPG_ERR_INV_SEXP);
1634   s++;
1635   n = snext (&s);
1636   if (!n)
1637     return gpg_error (GPG_ERR_INV_SEXP);
1638
1639   if (r_hexsn)
1640     {
1641       *r_hexsn = bin2hex (s, n, NULL);
1642       if (!*r_hexsn)
1643         return gpg_error_from_syserror ();
1644     }
1645   s += n;
1646
1647   n = snext (&s);
1648   if (!n)
1649     {
1650       if (r_hexsn)
1651         {
1652           xfree (*r_hexsn);
1653           *r_hexsn = NULL;
1654         }
1655       return gpg_error (GPG_ERR_INV_SEXP);
1656     }
1657
1658   if (r_idstr)
1659     {
1660       *r_idstr = xtrymalloc (n+1);
1661       if (!*r_idstr)
1662         {
1663           if (r_hexsn)
1664             {
1665               xfree (*r_hexsn);
1666               *r_hexsn = NULL;
1667             }
1668           return gpg_error_from_syserror ();
1669         }
1670       memcpy (*r_idstr, s, n);
1671       (*r_idstr)[n] = 0;
1672     }
1673
1674   /* Parse the optional PINLEN.  */
1675   n = snext (&s);
1676   if (!n)
1677     return 0;
1678
1679   if (r_pinlen)
1680     {
1681       char *tmpstr = xtrymalloc (n+1);
1682       if (!tmpstr)
1683         {
1684           if (r_hexsn)
1685             {
1686               xfree (*r_hexsn);
1687               *r_hexsn = NULL;
1688             }
1689           if (r_idstr)
1690             {
1691               xfree (*r_idstr);
1692               *r_idstr = NULL;
1693             }
1694           return gpg_error_from_syserror ();
1695         }
1696       memcpy (tmpstr, s, n);
1697       tmpstr[n] = 0;
1698
1699       *r_pinlen = (int)strtol (tmpstr, NULL, 10);
1700       xfree (tmpstr);
1701     }
1702
1703   return 0;
1704 }