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