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