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