agent: Minor cleanup (mostly for documentation).
[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 gpg_error_t
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 gpg_error_t
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;
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 gpg_error_t
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 gpg_error_t
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
1295 /* Check the type of the private key, this is one of the constants:
1296    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1297    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1298    PRIVATE_KEY_PROTECTED for an protected private key or
1299    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are
1300    stored elsewhere.  Finally PRIVATE_KEY_OPENPGP_NONE may be returned
1301    is the key is still in the openpgp-native format but without
1302    protection.  */
1303 int
1304 agent_private_key_type (const unsigned char *privatekey)
1305 {
1306   const unsigned char *s;
1307   size_t n;
1308   int i;
1309
1310   s = privatekey;
1311   if (*s != '(')
1312     return PRIVATE_KEY_UNKNOWN;
1313   s++;
1314   n = snext (&s);
1315   if (!n)
1316     return PRIVATE_KEY_UNKNOWN;
1317   if (smatch (&s, n, "protected-private-key"))
1318     {
1319       /* We need to check whether this is openpgp-native protected
1320          with the protection method "none".  In that case we return a
1321          different key type so that the caller knows that there is no
1322          need to ask for a passphrase. */
1323       if (*s != '(')
1324         return PRIVATE_KEY_PROTECTED; /* Unknown sexp - assume protected. */
1325       s++;
1326       n = snext (&s);
1327       if (!n)
1328         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1329       s += n; /* Skip over the algo */
1330
1331       /* Find the (protected ...) list.  */
1332       for (;;)
1333         {
1334           if (*s != '(')
1335             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1336           s++;
1337           n = snext (&s);
1338           if (!n)
1339             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1340           if (smatch (&s, n, "protected"))
1341             break;
1342           s += n;
1343           i = 1;
1344           if (sskip (&s, &i))
1345             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1346         }
1347       /* Found - Is this openpgp-native? */
1348       n = snext (&s);
1349       if (!n)
1350         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1351       if (smatch (&s, n, "openpgp-native")) /* Yes.  */
1352         {
1353           if (*s != '(')
1354             return PRIVATE_KEY_UNKNOWN; /* Unknown sexp. */
1355           s++;
1356           n = snext (&s);
1357           if (!n)
1358             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1359           s += n; /* Skip over "openpgp-private-key".  */
1360           /* Find the (protection ...) list.  */
1361           for (;;)
1362             {
1363               if (*s != '(')
1364                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1365               s++;
1366               n = snext (&s);
1367               if (!n)
1368                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1369               if (smatch (&s, n, "protection"))
1370                 break;
1371               s += n;
1372               i = 1;
1373               if (sskip (&s, &i))
1374                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1375             }
1376           /* Found - Is the mode "none"? */
1377           n = snext (&s);
1378           if (!n)
1379             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1380           if (smatch (&s, n, "none"))
1381             return PRIVATE_KEY_OPENPGP_NONE;  /* Yes.  */
1382         }
1383
1384       return PRIVATE_KEY_PROTECTED;
1385     }
1386   if (smatch (&s, n, "shadowed-private-key"))
1387     return PRIVATE_KEY_SHADOWED;
1388   if (smatch (&s, n, "private-key"))
1389     return PRIVATE_KEY_CLEAR;
1390   return PRIVATE_KEY_UNKNOWN;
1391 }
1392
1393
1394 \f
1395 /* Transform a passphrase into a suitable key of length KEYLEN and
1396    store this key in the caller provided buffer KEY.  The caller must
1397    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1398    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1399
1400    Returns an error code on failure.  */
1401 static int
1402 hash_passphrase (const char *passphrase, int hashalgo,
1403                  int s2kmode,
1404                  const unsigned char *s2ksalt,
1405                  unsigned long s2kcount,
1406                  unsigned char *key, size_t keylen)
1407 {
1408   /* The key derive function does not support a zero length string for
1409      the passphrase in the S2K modes.  Return a better suited error
1410      code than GPG_ERR_INV_DATA.  */
1411   if (!passphrase || !*passphrase)
1412     return gpg_error (GPG_ERR_NO_PASSPHRASE);
1413   return gcry_kdf_derive (passphrase, strlen (passphrase),
1414                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1415                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1416                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1417                           hashalgo, s2ksalt, 8, s2kcount,
1418                           keylen, key);
1419 }
1420
1421
1422 gpg_error_t
1423 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1424                      int s2kmode,
1425                      const unsigned char *s2ksalt,
1426                      unsigned int s2kcount,
1427                      unsigned char *key, size_t keylen)
1428 {
1429   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1430                           S2K_DECODE_COUNT (s2kcount),
1431                           key, keylen);
1432 }
1433
1434
1435 \f
1436
1437 /* Create an canonical encoded S-expression with the shadow info from
1438    a card's SERIALNO and the IDSTRING.  */
1439 unsigned char *
1440 make_shadow_info (const char *serialno, const char *idstring)
1441 {
1442   const char *s;
1443   char *info, *p;
1444   char numbuf[20];
1445   size_t n;
1446
1447   for (s=serialno, n=0; *s && s[1]; s += 2)
1448     n++;
1449
1450   info = p = xtrymalloc (1 + sizeof numbuf + n
1451                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1452   if (!info)
1453     return NULL;
1454   *p++ = '(';
1455   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1456   for (s=serialno; *s && s[1]; s += 2)
1457     *(unsigned char *)p++ = xtoi_2 (s);
1458   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1459   p = stpcpy (p, idstring);
1460   *p++ = ')';
1461   *p = 0;
1462   return (unsigned char *)info;
1463 }
1464
1465
1466
1467 /* Create a shadow key from a public key.  We use the shadow protocol
1468   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1469   S-expression is returned in an allocated buffer RESULT will point
1470   to. The input parameters are expected to be valid canonicalized
1471   S-expressions */
1472 int
1473 agent_shadow_key (const unsigned char *pubkey,
1474                   const unsigned char *shadow_info,
1475                   unsigned char **result)
1476 {
1477   const unsigned char *s;
1478   const unsigned char *point;
1479   size_t n;
1480   int depth = 0;
1481   char *p;
1482   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1483   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1484
1485   if (!pubkey_len || !shadow_info_len)
1486     return gpg_error (GPG_ERR_INV_VALUE);
1487   s = pubkey;
1488   if (*s != '(')
1489     return gpg_error (GPG_ERR_INV_SEXP);
1490   depth++;
1491   s++;
1492   n = snext (&s);
1493   if (!n)
1494     return gpg_error (GPG_ERR_INV_SEXP);
1495   if (!smatch (&s, n, "public-key"))
1496     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1497   if (*s != '(')
1498     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1499   depth++;
1500   s++;
1501   n = snext (&s);
1502   if (!n)
1503     return gpg_error (GPG_ERR_INV_SEXP);
1504   s += n; /* skip over the algorithm name */
1505
1506   while (*s != ')')
1507     {
1508       if (*s != '(')
1509         return gpg_error (GPG_ERR_INV_SEXP);
1510       depth++;
1511       s++;
1512       n = snext (&s);
1513       if (!n)
1514         return gpg_error (GPG_ERR_INV_SEXP);
1515       s += n;
1516       n = snext (&s);
1517       if (!n)
1518         return gpg_error (GPG_ERR_INV_SEXP);
1519       s +=n; /* skip value */
1520       if (*s != ')')
1521         return gpg_error (GPG_ERR_INV_SEXP);
1522       depth--;
1523       s++;
1524     }
1525   point = s; /* insert right before the point */
1526   depth--;
1527   s++;
1528   assert (depth == 1);
1529
1530   /* Calculate required length by taking in account: the "shadowed-"
1531      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1532   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1533   *result = xtrymalloc (n);
1534   p = (char*)*result;
1535   if (!p)
1536       return out_of_core ();
1537   p = stpcpy (p, "(20:shadowed-private-key");
1538   /* (10:public-key ...)*/
1539   memcpy (p, pubkey+14, point - (pubkey+14));
1540   p += point - (pubkey+14);
1541   p = stpcpy (p, "(8:shadowed5:t1-v1");
1542   memcpy (p, shadow_info, shadow_info_len);
1543   p += shadow_info_len;
1544   *p++ = ')';
1545   memcpy (p, point, pubkey_len - (point - pubkey));
1546   p += pubkey_len - (point - pubkey);
1547
1548   return 0;
1549 }
1550
1551 /* Parse a canonical encoded shadowed key and return a pointer to the
1552    inner list with the shadow_info */
1553 gpg_error_t
1554 agent_get_shadow_info (const unsigned char *shadowkey,
1555                        unsigned char const **shadow_info)
1556 {
1557   const unsigned char *s;
1558   size_t n;
1559   int depth = 0;
1560
1561   s = shadowkey;
1562   if (*s != '(')
1563     return gpg_error (GPG_ERR_INV_SEXP);
1564   depth++;
1565   s++;
1566   n = snext (&s);
1567   if (!n)
1568     return gpg_error (GPG_ERR_INV_SEXP);
1569   if (!smatch (&s, n, "shadowed-private-key"))
1570     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1571   if (*s != '(')
1572     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1573   depth++;
1574   s++;
1575   n = snext (&s);
1576   if (!n)
1577     return gpg_error (GPG_ERR_INV_SEXP);
1578   s += n; /* skip over the algorithm name */
1579
1580   for (;;)
1581     {
1582       if (*s == ')')
1583         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1584       if (*s != '(')
1585         return gpg_error (GPG_ERR_INV_SEXP);
1586       depth++;
1587       s++;
1588       n = snext (&s);
1589       if (!n)
1590         return gpg_error (GPG_ERR_INV_SEXP);
1591       if (smatch (&s, n, "shadowed"))
1592         break;
1593       s += n;
1594       n = snext (&s);
1595       if (!n)
1596         return gpg_error (GPG_ERR_INV_SEXP);
1597       s +=n; /* skip value */
1598       if (*s != ')')
1599         return gpg_error (GPG_ERR_INV_SEXP);
1600       depth--;
1601       s++;
1602     }
1603   /* Found the shadowed list, S points to the protocol */
1604   n = snext (&s);
1605   if (!n)
1606     return gpg_error (GPG_ERR_INV_SEXP);
1607   if (smatch (&s, n, "t1-v1"))
1608     {
1609       if (*s != '(')
1610         return gpg_error (GPG_ERR_INV_SEXP);
1611       *shadow_info = s;
1612     }
1613   else
1614     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1615   return 0;
1616 }
1617
1618
1619 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1620    the hex encoded serial number is returned as a malloced strings at
1621    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1622    error an error code is returned and NULL is stored at the result
1623    parameters addresses.  If the serial number or the ID string is not
1624    required, NULL may be passed for them.  */
1625 gpg_error_t
1626 parse_shadow_info (const unsigned char *shadow_info,
1627                    char **r_hexsn, char **r_idstr, int *r_pinlen)
1628 {
1629   const unsigned char *s;
1630   size_t n;
1631
1632   if (r_hexsn)
1633     *r_hexsn = NULL;
1634   if (r_idstr)
1635     *r_idstr = NULL;
1636   if (r_pinlen)
1637     *r_pinlen = 0;
1638
1639   s = shadow_info;
1640   if (*s != '(')
1641     return gpg_error (GPG_ERR_INV_SEXP);
1642   s++;
1643   n = snext (&s);
1644   if (!n)
1645     return gpg_error (GPG_ERR_INV_SEXP);
1646
1647   if (r_hexsn)
1648     {
1649       *r_hexsn = bin2hex (s, n, NULL);
1650       if (!*r_hexsn)
1651         return gpg_error_from_syserror ();
1652     }
1653   s += n;
1654
1655   n = snext (&s);
1656   if (!n)
1657     {
1658       if (r_hexsn)
1659         {
1660           xfree (*r_hexsn);
1661           *r_hexsn = NULL;
1662         }
1663       return gpg_error (GPG_ERR_INV_SEXP);
1664     }
1665
1666   if (r_idstr)
1667     {
1668       *r_idstr = xtrymalloc (n+1);
1669       if (!*r_idstr)
1670         {
1671           if (r_hexsn)
1672             {
1673               xfree (*r_hexsn);
1674               *r_hexsn = NULL;
1675             }
1676           return gpg_error_from_syserror ();
1677         }
1678       memcpy (*r_idstr, s, n);
1679       (*r_idstr)[n] = 0;
1680     }
1681
1682   /* Parse the optional PINLEN.  */
1683   n = snext (&s);
1684   if (!n)
1685     return 0;
1686
1687   if (r_pinlen)
1688     {
1689       char *tmpstr = xtrymalloc (n+1);
1690       if (!tmpstr)
1691         {
1692           if (r_hexsn)
1693             {
1694               xfree (*r_hexsn);
1695               *r_hexsn = NULL;
1696             }
1697           if (r_idstr)
1698             {
1699               xfree (*r_idstr);
1700               *r_idstr = NULL;
1701             }
1702           return gpg_error_from_syserror ();
1703         }
1704       memcpy (tmpstr, s, n);
1705       tmpstr[n] = 0;
1706
1707       *r_pinlen = (int)strtol (tmpstr, NULL, 10);
1708       xfree (tmpstr);
1709     }
1710
1711   return 0;
1712 }