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