gpg: Fix memory leak in parse_auto_key_locate.
[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             {
817               rc = gcry_cipher_checktag (hd, protected + protectedlen - 16, 16);
818               if (gpg_err_code (rc) == GPG_ERR_CHECKSUM)
819                 {
820                   /* Return Bad Passphrase instead of checksum error */
821                   rc = gpg_error (GPG_ERR_BAD_PASSPHRASE);
822                 }
823             }
824         }
825       else
826         {
827           rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
828                                     protected, protectedlen);
829         }
830     }
831
832   /* Release cipher handle and check for errors.  */
833   gcry_cipher_close (hd);
834   if (rc)
835     {
836       xfree (outbuf);
837       return rc;
838     }
839
840   /* Do a quick check on the data structure. */
841   if (*outbuf != '(' && outbuf[1] != '(')
842     {
843       xfree (outbuf);
844       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
845     }
846
847   /* Check that we have a consistent S-Exp. */
848   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
849   if (!reallen || (reallen + blklen < protectedlen) )
850     {
851       xfree (outbuf);
852       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
853     }
854   *result = outbuf;
855   return 0;
856 }
857
858
859 /* Merge the parameter list contained in CLEARTEXT with the original
860  * protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
861  * Return the new list in RESULT and the MIC value in the 20 byte
862  * buffer SHA1HASH; if SHA1HASH is NULL no MIC will be computed.
863  * CUTOFF and CUTLEN will receive the offset and the length of the
864  * resulting list which should go into the MIC calculation but then be
865  * removed.  */
866 static gpg_error_t
867 merge_lists (const unsigned char *protectedkey,
868              size_t replacepos,
869              const unsigned char *cleartext,
870              unsigned char *sha1hash,
871              unsigned char **result, size_t *resultlen,
872              size_t *cutoff, size_t *cutlen)
873 {
874   size_t n, newlistlen;
875   unsigned char *newlist, *p;
876   const unsigned char *s;
877   const unsigned char *startpos, *endpos;
878   int i, rc;
879
880   *result = NULL;
881   *resultlen = 0;
882   *cutoff = 0;
883   *cutlen = 0;
884
885   if (replacepos < 26)
886     return gpg_error (GPG_ERR_BUG);
887
888   /* Estimate the required size of the resulting list.  We have a large
889      safety margin of >20 bytes (FIXME: MIC hash from CLEARTEXT and the
890      removed "protected-" */
891   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
892   if (!newlistlen)
893     return gpg_error (GPG_ERR_BUG);
894   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
895   if (!n)
896     return gpg_error (GPG_ERR_BUG);
897   newlistlen += n;
898   newlist = gcry_malloc_secure (newlistlen);
899   if (!newlist)
900     return out_of_core ();
901
902   /* Copy the initial segment */
903   strcpy ((char*)newlist, "(11:private-key");
904   p = newlist + 15;
905   memcpy (p, protectedkey+15+10, replacepos-15-10);
906   p += replacepos-15-10;
907
908   /* Copy the cleartext.  */
909   s = cleartext;
910   if (*s != '(' && s[1] != '(')
911     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
912   s += 2;
913   startpos = s;
914   while ( *s == '(' )
915     {
916       s++;
917       n = snext (&s);
918       if (!n)
919         goto invalid_sexp;
920       s += n;
921       n = snext (&s);
922       if (!n)
923         goto invalid_sexp;
924       s += n;
925       if ( *s != ')' )
926         goto invalid_sexp;
927       s++;
928     }
929   if ( *s != ')' )
930     goto invalid_sexp;
931   endpos = s;
932   s++;
933
934   /* Intermezzo: Get the MIC if requested.  */
935   if (sha1hash)
936     {
937       if (*s != '(')
938         goto invalid_sexp;
939       s++;
940       n = snext (&s);
941       if (!smatch (&s, n, "hash"))
942         goto invalid_sexp;
943       n = snext (&s);
944       if (!smatch (&s, n, "sha1"))
945         goto invalid_sexp;
946       n = snext (&s);
947       if (n != 20)
948         goto invalid_sexp;
949       memcpy (sha1hash, s, 20);
950       s += n;
951       if (*s != ')')
952         goto invalid_sexp;
953     }
954
955   /* Append the parameter list.  */
956   memcpy (p, startpos, endpos - startpos);
957   p += endpos - startpos;
958
959   /* Skip over the protected list element in the original list.  */
960   s = protectedkey + replacepos;
961   assert (*s == '(');
962   s++;
963   i = 1;
964   rc = sskip (&s, &i);
965   if (rc)
966     goto failure;
967   /* Record the position of the optional protected-at expression.  */
968   if (*s == '(')
969     {
970       const unsigned char *save_s = s;
971       s++;
972       n = snext (&s);
973       if (smatch (&s, n, "protected-at"))
974         {
975           i = 1;
976           rc = sskip (&s, &i);
977           if (rc)
978             goto failure;
979           *cutlen = s - save_s;
980         }
981       s = save_s;
982     }
983   startpos = s;
984   i = 2; /* we are inside this level */
985   rc = sskip (&s, &i);
986   if (rc)
987     goto failure;
988   assert (s[-1] == ')');
989   endpos = s; /* one behind the end of the list */
990
991   /* Append the rest. */
992   if (*cutlen)
993     *cutoff = p - newlist;
994   memcpy (p, startpos, endpos - startpos);
995   p += endpos - startpos;
996
997
998   /* ready */
999   *result = newlist;
1000   *resultlen = newlistlen;
1001   return 0;
1002
1003  failure:
1004   wipememory (newlist, newlistlen);
1005   xfree (newlist);
1006   return rc;
1007
1008  invalid_sexp:
1009   wipememory (newlist, newlistlen);
1010   xfree (newlist);
1011   return gpg_error (GPG_ERR_INV_SEXP);
1012 }
1013
1014
1015
1016 /* Unprotect the key encoded in canonical format.  We assume a valid
1017    S-Exp here.  If a protected-at item is available, its value will
1018    be stored at protected_at unless this is NULL.  */
1019 gpg_error_t
1020 agent_unprotect (ctrl_t ctrl,
1021                  const unsigned char *protectedkey, const char *passphrase,
1022                  gnupg_isotime_t protected_at,
1023                  unsigned char **result, size_t *resultlen)
1024 {
1025   static const struct {
1026     const char *name; /* Name of the protection method. */
1027     int algo;         /* (A zero indicates the "openpgp-native" hack.)  */
1028     int keylen;       /* Used key length in bytes.  */
1029     unsigned int is_ocb:1;
1030   } algotable[] = {
1031     { "openpgp-s2k3-sha1-aes-cbc",    GCRY_CIPHER_AES128, (128/8)},
1032     { "openpgp-s2k3-sha1-aes256-cbc", GCRY_CIPHER_AES256, (256/8)},
1033     { "openpgp-s2k3-ocb-aes",         GCRY_CIPHER_AES128, (128/8), 1},
1034     { "openpgp-native", 0, 0 }
1035   };
1036   int rc;
1037   const unsigned char *s;
1038   const unsigned char *protect_list;
1039   size_t n;
1040   int infidx, i;
1041   unsigned char sha1hash[20], sha1hash2[20];
1042   const unsigned char *s2ksalt;
1043   unsigned long s2kcount;
1044   const unsigned char *iv;
1045   int prot_cipher, prot_cipher_keylen;
1046   int is_ocb;
1047   const unsigned char *aad_begin, *aad_end, *aadhole_begin, *aadhole_end;
1048   const unsigned char *prot_begin;
1049   unsigned char *cleartext;
1050   unsigned char *final;
1051   size_t finallen;
1052   size_t cutoff, cutlen;
1053
1054   if (protected_at)
1055     *protected_at = 0;
1056
1057   s = protectedkey;
1058   if (*s != '(')
1059     return gpg_error (GPG_ERR_INV_SEXP);
1060   s++;
1061   n = snext (&s);
1062   if (!n)
1063     return gpg_error (GPG_ERR_INV_SEXP);
1064   if (!smatch (&s, n, "protected-private-key"))
1065     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1066   if (*s != '(')
1067     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1068   {
1069     aad_begin = aad_end = s;
1070     aad_end++;
1071     i = 1;
1072     rc = sskip (&aad_end, &i);
1073     if (rc)
1074       return rc;
1075   }
1076
1077   s++;
1078   n = snext (&s);
1079   if (!n)
1080     return gpg_error (GPG_ERR_INV_SEXP);
1081
1082   for (infidx=0; protect_info[infidx].algo
1083               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
1084     ;
1085   if (!protect_info[infidx].algo)
1086     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1087
1088   /* See wether we have a protected-at timestamp.  */
1089   protect_list = s;  /* Save for later.  */
1090   if (protected_at)
1091     {
1092       while (*s == '(')
1093         {
1094           prot_begin = s;
1095           s++;
1096           n = snext (&s);
1097           if (!n)
1098             return gpg_error (GPG_ERR_INV_SEXP);
1099           if (smatch (&s, n, "protected-at"))
1100             {
1101               n = snext (&s);
1102               if (!n)
1103                 return gpg_error (GPG_ERR_INV_SEXP);
1104               if (n != 15)
1105                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1106               memcpy (protected_at, s, 15);
1107               protected_at[15] = 0;
1108               break;
1109             }
1110           s += n;
1111           i = 1;
1112           rc = sskip (&s, &i);
1113           if (rc)
1114             return rc;
1115         }
1116     }
1117
1118   /* Now find the list with the protected information.  Here is an
1119      example for such a list:
1120      (protected openpgp-s2k3-sha1-aes-cbc
1121         ((sha1 <salt> <count>) <Initialization_Vector>)
1122         <encrypted_data>)
1123    */
1124   s = protect_list;
1125   for (;;)
1126     {
1127       if (*s != '(')
1128         return gpg_error (GPG_ERR_INV_SEXP);
1129       prot_begin = s;
1130       s++;
1131       n = snext (&s);
1132       if (!n)
1133         return gpg_error (GPG_ERR_INV_SEXP);
1134       if (smatch (&s, n, "protected"))
1135         break;
1136       s += n;
1137       i = 1;
1138       rc = sskip (&s, &i);
1139       if (rc)
1140         return rc;
1141     }
1142   /* found */
1143   {
1144     aadhole_begin = aadhole_end = prot_begin;
1145     aadhole_end++;
1146     i = 1;
1147     rc = sskip (&aadhole_end, &i);
1148     if (rc)
1149       return rc;
1150   }
1151   n = snext (&s);
1152   if (!n)
1153     return gpg_error (GPG_ERR_INV_SEXP);
1154
1155   /* Lookup the protection algo.  */
1156   prot_cipher = 0;        /* (avoid gcc warning) */
1157   prot_cipher_keylen = 0; /* (avoid gcc warning) */
1158   is_ocb = 0;
1159   for (i=0; i < DIM (algotable); i++)
1160     if (smatch (&s, n, algotable[i].name))
1161       {
1162         prot_cipher = algotable[i].algo;
1163         prot_cipher_keylen = algotable[i].keylen;
1164         is_ocb = algotable[i].is_ocb;
1165         break;
1166       }
1167   if (i == DIM (algotable))
1168     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1169
1170   if (!prot_cipher)  /* This is "openpgp-native".  */
1171     {
1172       gcry_sexp_t s_prot_begin;
1173
1174       rc = gcry_sexp_sscan (&s_prot_begin, NULL,
1175                             prot_begin,
1176                             gcry_sexp_canon_len (prot_begin, 0,NULL,NULL));
1177       if (rc)
1178         return rc;
1179
1180       rc = convert_from_openpgp_native (ctrl, s_prot_begin, passphrase, &final);
1181       gcry_sexp_release (s_prot_begin);
1182       if (!rc)
1183         {
1184           *result = final;
1185           *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1186         }
1187       return rc;
1188     }
1189
1190   if (*s != '(' || s[1] != '(')
1191     return gpg_error (GPG_ERR_INV_SEXP);
1192   s += 2;
1193   n = snext (&s);
1194   if (!n)
1195     return gpg_error (GPG_ERR_INV_SEXP);
1196   if (!smatch (&s, n, "sha1"))
1197     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1198   n = snext (&s);
1199   if (n != 8)
1200     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1201   s2ksalt = s;
1202   s += n;
1203   n = snext (&s);
1204   if (!n)
1205     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1206   /* We expect a list close as next, so we can simply use strtoul()
1207      here.  We might want to check that we only have digits - but this
1208      is nothing we should worry about */
1209   if (s[n] != ')' )
1210     return gpg_error (GPG_ERR_INV_SEXP);
1211
1212   /* Old versions of gpg-agent used the funny floating point number in
1213      a byte encoding as specified by OpenPGP.  However this is not
1214      needed and thus we now store it as a plain unsigned integer.  We
1215      can easily distinguish the old format by looking at its value:
1216      Less than 256 is an old-style encoded number; other values are
1217      plain integers.  In any case we check that they are at least
1218      65536 because we never used a lower value in the past and we
1219      should have a lower limit.  */
1220   s2kcount = strtoul ((const char*)s, NULL, 10);
1221   if (!s2kcount)
1222     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1223   if (s2kcount < 256)
1224     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
1225   if (s2kcount < 65536)
1226     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1227
1228   s += n;
1229   s++; /* skip list end */
1230
1231   n = snext (&s);
1232   if (is_ocb)
1233     {
1234       if (n != 12) /* Wrong size of the nonce. */
1235         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1236     }
1237   else
1238     {
1239       if (n != 16) /* Wrong blocksize for IV (we support only 128 bit). */
1240         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1241     }
1242   iv = s;
1243   s += n;
1244   if (*s != ')' )
1245     return gpg_error (GPG_ERR_INV_SEXP);
1246   s++;
1247   n = snext (&s);
1248   if (!n)
1249     return gpg_error (GPG_ERR_INV_SEXP);
1250
1251   cleartext = NULL; /* Avoid cc warning. */
1252   rc = do_decryption (aad_begin, aad_end - aad_begin,
1253                       aadhole_begin, aadhole_end - aadhole_begin,
1254                       s, n,
1255                       passphrase, s2ksalt, s2kcount,
1256                       iv, is_ocb? 12:16,
1257                       prot_cipher, prot_cipher_keylen, is_ocb,
1258                       &cleartext);
1259   if (rc)
1260     return rc;
1261
1262   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
1263                     is_ocb? NULL : sha1hash,
1264                     &final, &finallen, &cutoff, &cutlen);
1265   /* Albeit cleartext has been allocated in secure memory and thus
1266      xfree will wipe it out, we do an extra wipe just in case
1267      somethings goes badly wrong. */
1268   wipememory (cleartext, n);
1269   xfree (cleartext);
1270   if (rc)
1271     return rc;
1272
1273   if (!is_ocb)
1274     {
1275       rc = calculate_mic (final, sha1hash2);
1276       if (!rc && memcmp (sha1hash, sha1hash2, 20))
1277         rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1278       if (rc)
1279         {
1280           wipememory (final, finallen);
1281           xfree (final);
1282           return rc;
1283         }
1284     }
1285
1286   /* Now remove the part which is included in the MIC but should not
1287      go into the final thing.  */
1288   if (cutlen)
1289     {
1290       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1291       finallen -= cutlen;
1292     }
1293
1294   *result = final;
1295   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1296   return 0;
1297 }
1298
1299
1300 /* Check the type of the private key, this is one of the constants:
1301    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1302    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1303    PRIVATE_KEY_PROTECTED for an protected private key or
1304    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are
1305    stored elsewhere.  Finally PRIVATE_KEY_OPENPGP_NONE may be returned
1306    is the key is still in the openpgp-native format but without
1307    protection.  */
1308 int
1309 agent_private_key_type (const unsigned char *privatekey)
1310 {
1311   const unsigned char *s;
1312   size_t n;
1313   int i;
1314
1315   s = privatekey;
1316   if (*s != '(')
1317     return PRIVATE_KEY_UNKNOWN;
1318   s++;
1319   n = snext (&s);
1320   if (!n)
1321     return PRIVATE_KEY_UNKNOWN;
1322   if (smatch (&s, n, "protected-private-key"))
1323     {
1324       /* We need to check whether this is openpgp-native protected
1325          with the protection method "none".  In that case we return a
1326          different key type so that the caller knows that there is no
1327          need to ask for a passphrase. */
1328       if (*s != '(')
1329         return PRIVATE_KEY_PROTECTED; /* Unknown sexp - assume protected. */
1330       s++;
1331       n = snext (&s);
1332       if (!n)
1333         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1334       s += n; /* Skip over the algo */
1335
1336       /* Find the (protected ...) list.  */
1337       for (;;)
1338         {
1339           if (*s != '(')
1340             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1341           s++;
1342           n = snext (&s);
1343           if (!n)
1344             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1345           if (smatch (&s, n, "protected"))
1346             break;
1347           s += n;
1348           i = 1;
1349           if (sskip (&s, &i))
1350             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1351         }
1352       /* Found - Is this openpgp-native? */
1353       n = snext (&s);
1354       if (!n)
1355         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1356       if (smatch (&s, n, "openpgp-native")) /* Yes.  */
1357         {
1358           if (*s != '(')
1359             return PRIVATE_KEY_UNKNOWN; /* Unknown sexp. */
1360           s++;
1361           n = snext (&s);
1362           if (!n)
1363             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1364           s += n; /* Skip over "openpgp-private-key".  */
1365           /* Find the (protection ...) list.  */
1366           for (;;)
1367             {
1368               if (*s != '(')
1369                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1370               s++;
1371               n = snext (&s);
1372               if (!n)
1373                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1374               if (smatch (&s, n, "protection"))
1375                 break;
1376               s += n;
1377               i = 1;
1378               if (sskip (&s, &i))
1379                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1380             }
1381           /* Found - Is the mode "none"? */
1382           n = snext (&s);
1383           if (!n)
1384             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1385           if (smatch (&s, n, "none"))
1386             return PRIVATE_KEY_OPENPGP_NONE;  /* Yes.  */
1387         }
1388
1389       return PRIVATE_KEY_PROTECTED;
1390     }
1391   if (smatch (&s, n, "shadowed-private-key"))
1392     return PRIVATE_KEY_SHADOWED;
1393   if (smatch (&s, n, "private-key"))
1394     return PRIVATE_KEY_CLEAR;
1395   return PRIVATE_KEY_UNKNOWN;
1396 }
1397
1398
1399 \f
1400 /* Transform a passphrase into a suitable key of length KEYLEN and
1401    store this key in the caller provided buffer KEY.  The caller must
1402    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1403    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1404
1405    Returns an error code on failure.  */
1406 static int
1407 hash_passphrase (const char *passphrase, int hashalgo,
1408                  int s2kmode,
1409                  const unsigned char *s2ksalt,
1410                  unsigned long s2kcount,
1411                  unsigned char *key, size_t keylen)
1412 {
1413   /* The key derive function does not support a zero length string for
1414      the passphrase in the S2K modes.  Return a better suited error
1415      code than GPG_ERR_INV_DATA.  */
1416   if (!passphrase || !*passphrase)
1417     return gpg_error (GPG_ERR_NO_PASSPHRASE);
1418   return gcry_kdf_derive (passphrase, strlen (passphrase),
1419                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1420                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1421                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1422                           hashalgo, s2ksalt, 8, s2kcount,
1423                           keylen, key);
1424 }
1425
1426
1427 gpg_error_t
1428 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1429                      int s2kmode,
1430                      const unsigned char *s2ksalt,
1431                      unsigned int s2kcount,
1432                      unsigned char *key, size_t keylen)
1433 {
1434   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1435                           S2K_DECODE_COUNT (s2kcount),
1436                           key, keylen);
1437 }
1438
1439
1440 \f
1441
1442 /* Create an canonical encoded S-expression with the shadow info from
1443    a card's SERIALNO and the IDSTRING.  */
1444 unsigned char *
1445 make_shadow_info (const char *serialno, const char *idstring)
1446 {
1447   const char *s;
1448   char *info, *p;
1449   char numbuf[20];
1450   size_t n;
1451
1452   for (s=serialno, n=0; *s && s[1]; s += 2)
1453     n++;
1454
1455   info = p = xtrymalloc (1 + sizeof numbuf + n
1456                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1457   if (!info)
1458     return NULL;
1459   *p++ = '(';
1460   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1461   for (s=serialno; *s && s[1]; s += 2)
1462     *(unsigned char *)p++ = xtoi_2 (s);
1463   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1464   p = stpcpy (p, idstring);
1465   *p++ = ')';
1466   *p = 0;
1467   return (unsigned char *)info;
1468 }
1469
1470
1471
1472 /* Create a shadow key from a public key.  We use the shadow protocol
1473   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1474   S-expression is returned in an allocated buffer RESULT will point
1475   to. The input parameters are expected to be valid canonicalized
1476   S-expressions */
1477 int
1478 agent_shadow_key (const unsigned char *pubkey,
1479                   const unsigned char *shadow_info,
1480                   unsigned char **result)
1481 {
1482   const unsigned char *s;
1483   const unsigned char *point;
1484   size_t n;
1485   int depth = 0;
1486   char *p;
1487   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1488   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1489
1490   if (!pubkey_len || !shadow_info_len)
1491     return gpg_error (GPG_ERR_INV_VALUE);
1492   s = pubkey;
1493   if (*s != '(')
1494     return gpg_error (GPG_ERR_INV_SEXP);
1495   depth++;
1496   s++;
1497   n = snext (&s);
1498   if (!n)
1499     return gpg_error (GPG_ERR_INV_SEXP);
1500   if (!smatch (&s, n, "public-key"))
1501     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1502   if (*s != '(')
1503     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1504   depth++;
1505   s++;
1506   n = snext (&s);
1507   if (!n)
1508     return gpg_error (GPG_ERR_INV_SEXP);
1509   s += n; /* skip over the algorithm name */
1510
1511   while (*s != ')')
1512     {
1513       if (*s != '(')
1514         return gpg_error (GPG_ERR_INV_SEXP);
1515       depth++;
1516       s++;
1517       n = snext (&s);
1518       if (!n)
1519         return gpg_error (GPG_ERR_INV_SEXP);
1520       s += n;
1521       n = snext (&s);
1522       if (!n)
1523         return gpg_error (GPG_ERR_INV_SEXP);
1524       s +=n; /* skip value */
1525       if (*s != ')')
1526         return gpg_error (GPG_ERR_INV_SEXP);
1527       depth--;
1528       s++;
1529     }
1530   point = s; /* insert right before the point */
1531   depth--;
1532   s++;
1533   assert (depth == 1);
1534
1535   /* Calculate required length by taking in account: the "shadowed-"
1536      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1537   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1538   *result = xtrymalloc (n);
1539   p = (char*)*result;
1540   if (!p)
1541       return out_of_core ();
1542   p = stpcpy (p, "(20:shadowed-private-key");
1543   /* (10:public-key ...)*/
1544   memcpy (p, pubkey+14, point - (pubkey+14));
1545   p += point - (pubkey+14);
1546   p = stpcpy (p, "(8:shadowed5:t1-v1");
1547   memcpy (p, shadow_info, shadow_info_len);
1548   p += shadow_info_len;
1549   *p++ = ')';
1550   memcpy (p, point, pubkey_len - (point - pubkey));
1551   p += pubkey_len - (point - pubkey);
1552
1553   return 0;
1554 }
1555
1556 /* Parse a canonical encoded shadowed key and return a pointer to the
1557    inner list with the shadow_info */
1558 gpg_error_t
1559 agent_get_shadow_info (const unsigned char *shadowkey,
1560                        unsigned char const **shadow_info)
1561 {
1562   const unsigned char *s;
1563   size_t n;
1564   int depth = 0;
1565
1566   s = shadowkey;
1567   if (*s != '(')
1568     return gpg_error (GPG_ERR_INV_SEXP);
1569   depth++;
1570   s++;
1571   n = snext (&s);
1572   if (!n)
1573     return gpg_error (GPG_ERR_INV_SEXP);
1574   if (!smatch (&s, n, "shadowed-private-key"))
1575     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1576   if (*s != '(')
1577     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1578   depth++;
1579   s++;
1580   n = snext (&s);
1581   if (!n)
1582     return gpg_error (GPG_ERR_INV_SEXP);
1583   s += n; /* skip over the algorithm name */
1584
1585   for (;;)
1586     {
1587       if (*s == ')')
1588         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1589       if (*s != '(')
1590         return gpg_error (GPG_ERR_INV_SEXP);
1591       depth++;
1592       s++;
1593       n = snext (&s);
1594       if (!n)
1595         return gpg_error (GPG_ERR_INV_SEXP);
1596       if (smatch (&s, n, "shadowed"))
1597         break;
1598       s += n;
1599       n = snext (&s);
1600       if (!n)
1601         return gpg_error (GPG_ERR_INV_SEXP);
1602       s +=n; /* skip value */
1603       if (*s != ')')
1604         return gpg_error (GPG_ERR_INV_SEXP);
1605       depth--;
1606       s++;
1607     }
1608   /* Found the shadowed list, S points to the protocol */
1609   n = snext (&s);
1610   if (!n)
1611     return gpg_error (GPG_ERR_INV_SEXP);
1612   if (smatch (&s, n, "t1-v1"))
1613     {
1614       if (*s != '(')
1615         return gpg_error (GPG_ERR_INV_SEXP);
1616       *shadow_info = s;
1617     }
1618   else
1619     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1620   return 0;
1621 }
1622
1623
1624 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1625    the hex encoded serial number is returned as a malloced strings at
1626    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1627    error an error code is returned and NULL is stored at the result
1628    parameters addresses.  If the serial number or the ID string is not
1629    required, NULL may be passed for them.  */
1630 gpg_error_t
1631 parse_shadow_info (const unsigned char *shadow_info,
1632                    char **r_hexsn, char **r_idstr, int *r_pinlen)
1633 {
1634   const unsigned char *s;
1635   size_t n;
1636
1637   if (r_hexsn)
1638     *r_hexsn = NULL;
1639   if (r_idstr)
1640     *r_idstr = NULL;
1641   if (r_pinlen)
1642     *r_pinlen = 0;
1643
1644   s = shadow_info;
1645   if (*s != '(')
1646     return gpg_error (GPG_ERR_INV_SEXP);
1647   s++;
1648   n = snext (&s);
1649   if (!n)
1650     return gpg_error (GPG_ERR_INV_SEXP);
1651
1652   if (r_hexsn)
1653     {
1654       *r_hexsn = bin2hex (s, n, NULL);
1655       if (!*r_hexsn)
1656         return gpg_error_from_syserror ();
1657     }
1658   s += n;
1659
1660   n = snext (&s);
1661   if (!n)
1662     {
1663       if (r_hexsn)
1664         {
1665           xfree (*r_hexsn);
1666           *r_hexsn = NULL;
1667         }
1668       return gpg_error (GPG_ERR_INV_SEXP);
1669     }
1670
1671   if (r_idstr)
1672     {
1673       *r_idstr = xtrymalloc (n+1);
1674       if (!*r_idstr)
1675         {
1676           if (r_hexsn)
1677             {
1678               xfree (*r_hexsn);
1679               *r_hexsn = NULL;
1680             }
1681           return gpg_error_from_syserror ();
1682         }
1683       memcpy (*r_idstr, s, n);
1684       (*r_idstr)[n] = 0;
1685     }
1686
1687   /* Parse the optional PINLEN.  */
1688   n = snext (&s);
1689   if (!n)
1690     return 0;
1691
1692   if (r_pinlen)
1693     {
1694       char *tmpstr = xtrymalloc (n+1);
1695       if (!tmpstr)
1696         {
1697           if (r_hexsn)
1698             {
1699               xfree (*r_hexsn);
1700               *r_hexsn = NULL;
1701             }
1702           if (r_idstr)
1703             {
1704               xfree (*r_idstr);
1705               *r_idstr = NULL;
1706             }
1707           return gpg_error_from_syserror ();
1708         }
1709       memcpy (tmpstr, s, n);
1710       tmpstr[n] = 0;
1711
1712       *r_pinlen = (int)strtol (tmpstr, NULL, 10);
1713       xfree (tmpstr);
1714     }
1715
1716   return 0;
1717 }