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