agent: Implement new protection mode openpgp-s2k3-ocb-aes.
[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, hashlen);
468           gcry_md_write (md, timestamp_exp, timestamp_exp_len);
469           gcry_md_write (md, ")", 1);
470           memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
471           gcry_md_close (md);
472         }
473     }
474
475
476   /* Encrypt.  */
477   if (!rc)
478     {
479       p = outbuf;
480       *p++ = '(';
481       *p++ = '(';
482       memcpy (p, protbegin, protlen);
483       p += protlen;
484       if (use_ocb)
485         {
486           *p++ = ')';
487           *p++ = ')';
488         }
489       else
490         {
491           memcpy (p, ")(4:hash4:sha120:", 17);
492           p += 17;
493           memcpy (p, hashvalue, 20);
494           p += 20;
495           *p++ = ')';
496           *p++ = ')';
497           memcpy (p, iv+blklen, blklen); /* Add padding.  */
498           p += blklen;
499         }
500       assert ( p - outbuf == outlen);
501 #if OCB_MODE_SUPPORTED
502       if (use_ocb)
503         {
504           gcry_cipher_final (hd);
505           rc = gcry_cipher_encrypt (hd, outbuf, outlen, NULL, 0);
506           if (!rc)
507             {
508               log_assert (outlen + 16 == enclen);
509               rc = gcry_cipher_gettag (hd, outbuf + outlen, 16);
510             }
511         }
512       else
513 #endif /*OCB_MODE_SUPPORTED*/
514         {
515           rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
516         }
517     }
518
519   /* Release cipher handle and check for errors.  */
520   gcry_cipher_close (hd);
521   if (rc)
522     {
523       xfree (iv);
524       xfree (outbuf);
525       return rc;
526     }
527
528   /* Now allocate the buffer we want to return.  This is
529
530      (protected openpgp-s2k3-sha1-aes-cbc
531        ((sha1 salt no_of_iterations) 16byte_iv)
532        encrypted_octet_string)
533
534      in canoncical format of course.  We use asprintf and %n modifier
535      and dummy values as placeholders.  */
536   {
537     char countbuf[35];
538
539     snprintf (countbuf, sizeof countbuf, "%lu",
540             s2k_count ? s2k_count : get_standard_s2k_count ());
541     p = xtryasprintf
542       ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
543        (int)strlen (modestr), modestr,
544        &saltpos,
545        (unsigned int)strlen (countbuf), countbuf,
546        use_ocb? 12 : blklen, &ivpos, use_ocb? 12 : blklen, "",
547        enclen, &encpos, enclen, "");
548     if (!p)
549       {
550         gpg_error_t tmperr = out_of_core ();
551         xfree (iv);
552         xfree (outbuf);
553         return tmperr;
554       }
555
556   }
557   *resultlen = strlen (p);
558   *result = (unsigned char*)p;
559   memcpy (p+saltpos, s2ksalt, 8);
560   memcpy (p+ivpos, iv, use_ocb? 12 : blklen);
561   memcpy (p+encpos, outbuf, enclen);
562   xfree (iv);
563   xfree (outbuf);
564   return 0;
565 }
566
567
568
569 /* Protect the key encoded in canonical format in PLAINKEY.  We assume
570    a valid S-Exp here.  With USE_UCB set to -1 the default scheme is
571    used (ie. either CBC or OCB), set to 0 the old CBC mode is used,
572    and set to 1 OCB is used. */
573 int
574 agent_protect (const unsigned char *plainkey, const char *passphrase,
575                unsigned char **result, size_t *resultlen,
576                unsigned long s2k_count, int use_ocb)
577 {
578   int rc;
579   const char *parmlist;
580   int prot_from_idx, prot_to_idx;
581   const unsigned char *s;
582   const unsigned char *hash_begin, *hash_end;
583   const unsigned char *prot_begin, *prot_end, *real_end;
584   size_t n;
585   int c, infidx, i;
586   char timestamp_exp[35];
587   unsigned char *protected;
588   size_t protectedlen;
589   int depth = 0;
590   unsigned char *p;
591   int have_curve = 0;
592
593   if (use_ocb == -1)
594     use_ocb = PROT_DEFAULT_TO_OCB;
595
596   /* Create an S-expression with the protected-at timestamp.  */
597   memcpy (timestamp_exp, "(12:protected-at15:", 19);
598   gnupg_get_isotime (timestamp_exp+19);
599   timestamp_exp[19+15] = ')';
600
601   /* Parse original key.  */
602   s = plainkey;
603   if (*s != '(')
604     return gpg_error (GPG_ERR_INV_SEXP);
605   depth++;
606   s++;
607   n = snext (&s);
608   if (!n)
609     return gpg_error (GPG_ERR_INV_SEXP);
610   if (!smatch (&s, n, "private-key"))
611     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
612   if (*s != '(')
613     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
614   depth++;
615   hash_begin = s;
616   s++;
617   n = snext (&s);
618   if (!n)
619     return gpg_error (GPG_ERR_INV_SEXP);
620
621   for (infidx=0; protect_info[infidx].algo
622               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
623     ;
624   if (!protect_info[infidx].algo)
625     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
626
627   /* The parser below is a complete mess: To make it robust for ECC
628      use we should reorder the s-expression to include only what we
629      really need and thus guarantee the right order for saving stuff.
630      This should be done before calling this function and maybe with
631      the help of the new gcry_sexp_extract_param.  */
632   parmlist      = protect_info[infidx].parmlist;
633   prot_from_idx = protect_info[infidx].prot_from;
634   prot_to_idx   = protect_info[infidx].prot_to;
635   prot_begin = prot_end = NULL;
636   for (i=0; (c=parmlist[i]); i++)
637     {
638       if (i == prot_from_idx)
639         prot_begin = s;
640       if (*s != '(')
641         return gpg_error (GPG_ERR_INV_SEXP);
642       depth++;
643       s++;
644       n = snext (&s);
645       if (!n)
646         return gpg_error (GPG_ERR_INV_SEXP);
647       if (n != 1 || c != *s)
648         {
649           if (n == 5 && !memcmp (s, "curve", 5)
650               && !i && protect_info[infidx].ecc_hack)
651             {
652               /* This is a private ECC key but the first parameter is
653                  the name of the curve.  We change the parameter list
654                  here to the one we expect in this case.  */
655               have_curve = 1;
656               parmlist = "?qd";
657               prot_from_idx = 2;
658               prot_to_idx = 2;
659             }
660           else if (n == 5 && !memcmp (s, "flags", 5)
661                    && i == 1 && have_curve)
662             {
663               /* "curve" followed by "flags": Change again.  */
664               parmlist = "??qd";
665               prot_from_idx = 3;
666               prot_to_idx = 3;
667             }
668           else
669             return gpg_error (GPG_ERR_INV_SEXP);
670         }
671       s += n;
672       n = snext (&s);
673       if (!n)
674         return gpg_error (GPG_ERR_INV_SEXP);
675       s +=n; /* skip value */
676       if (*s != ')')
677         return gpg_error (GPG_ERR_INV_SEXP);
678       depth--;
679       if (i == prot_to_idx)
680         prot_end = s;
681       s++;
682     }
683   if (*s != ')' || !prot_begin || !prot_end )
684     return gpg_error (GPG_ERR_INV_SEXP);
685   depth--;
686   hash_end = s;
687   s++;
688   /* Skip to the end of the S-expression.  */
689   assert (depth == 1);
690   rc = sskip (&s, &depth);
691   if (rc)
692     return rc;
693   assert (!depth);
694   real_end = s-1;
695
696   rc = do_encryption (hash_begin, hash_end - hash_begin + 1,
697                       prot_begin, prot_end - prot_begin + 1,
698                       passphrase, timestamp_exp, sizeof (timestamp_exp),
699                       &protected, &protectedlen, s2k_count, use_ocb);
700   if (rc)
701     return rc;
702
703   /* Now create the protected version of the key.  Note that the 10
704      extra bytes are for for the inserted "protected-" string (the
705      beginning of the plaintext reads: "((11:private-key(" ).  The 35
706      term is the space for (12:protected-at15:<timestamp>).  */
707   *resultlen = (10
708                 + (prot_begin-plainkey)
709                 + protectedlen
710                 + 35
711                 + (real_end-prot_end));
712   *result = p = xtrymalloc (*resultlen);
713   if (!p)
714     {
715       gpg_error_t tmperr = out_of_core ();
716       xfree (protected);
717       return tmperr;
718     }
719   memcpy (p, "(21:protected-", 14);
720   p += 14;
721   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
722   p += prot_begin - plainkey - 4;
723   memcpy (p, protected, protectedlen);
724   p += protectedlen;
725
726   memcpy (p, timestamp_exp, 35);
727   p += 35;
728
729   memcpy (p, prot_end+1, real_end - prot_end);
730   p += real_end - prot_end;
731   assert ( p - *result == *resultlen);
732   xfree (protected);
733
734   return 0;
735 }
736
737
738 \f
739 /* Do the actual decryption and check the return list for consistency.  */
740 static int
741 do_decryption (const unsigned char *aad_begin, size_t aad_len,
742                const unsigned char *aadhole_begin, size_t aadhole_len,
743                const unsigned char *protected, size_t protectedlen,
744                const char *passphrase,
745                const unsigned char *s2ksalt, unsigned long s2kcount,
746                const unsigned char *iv, size_t ivlen,
747                int prot_cipher, int prot_cipher_keylen, int is_ocb,
748                unsigned char **result)
749 {
750   int rc = 0;
751   int blklen;
752   gcry_cipher_hd_t hd;
753   unsigned char *outbuf;
754   size_t reallen;
755
756   if (is_ocb && !OCB_MODE_SUPPORTED)
757     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
758
759   blklen = gcry_cipher_get_algo_blklen (prot_cipher);
760   if (is_ocb)
761     {
762       /* OCB does not require a multiple of the block length but we
763        * check that it is long enough for the 128 bit tag and that we
764        * have the 96 bit nonce.  */
765       if (protectedlen < (4 + 16) || ivlen != 12)
766         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
767     }
768   else
769     {
770       if (protectedlen < 4 || (protectedlen%blklen))
771         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
772     }
773
774   rc = gcry_cipher_open (&hd, prot_cipher,
775 #if OCB_MODE_SUPPORTED
776                          is_ocb? GCRY_CIPHER_MODE_OCB :
777 #endif
778                          GCRY_CIPHER_MODE_CBC,
779                          GCRY_CIPHER_SECURE);
780   if (rc)
781     return rc;
782
783   outbuf = gcry_malloc_secure (protectedlen);
784   if (!outbuf)
785     rc = out_of_core ();
786
787   /* Hash the passphrase and set the key.  */
788   if (!rc)
789     {
790       unsigned char *key;
791
792       key = gcry_malloc_secure (prot_cipher_keylen);
793       if (!key)
794         rc = out_of_core ();
795       else
796         {
797           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
798                                 3, s2ksalt, s2kcount, key, prot_cipher_keylen);
799           if (!rc)
800             rc = gcry_cipher_setkey (hd, key, prot_cipher_keylen);
801           xfree (key);
802         }
803     }
804
805   /* Set the IV/nonce.  */
806   if (!rc)
807     {
808       rc = gcry_cipher_setiv (hd, iv, ivlen);
809     }
810
811   /* Decrypt.  */
812   if (!rc)
813     {
814 #if OCB_MODE_SUPPORTED
815       if (is_ocb)
816         {
817           rc = gcry_cipher_authenticate (hd, aad_begin,
818                                          aadhole_begin - aad_begin);
819           if (!rc)
820             rc = gcry_cipher_authenticate
821               (hd, aadhole_begin + aadhole_len,
822                aad_len - (aadhole_begin+aadhole_len - aad_begin));
823
824           if (!rc)
825             {
826               gcry_cipher_final (hd);
827               rc = gcry_cipher_decrypt (hd, outbuf, protectedlen - 16,
828                                         protected, protectedlen - 16);
829             }
830           if (!rc)
831             rc = gcry_cipher_checktag (hd, protected + protectedlen - 16, 16);
832         }
833       else
834 #endif /*OCB_MODE_SUPPORTED*/
835         {
836           rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
837                                     protected, protectedlen);
838         }
839     }
840
841   /* Release cipher handle and check for errors.  */
842   gcry_cipher_close (hd);
843   if (rc)
844     {
845       xfree (outbuf);
846       return rc;
847     }
848
849   /* Do a quick check on the data structure. */
850   if (*outbuf != '(' && outbuf[1] != '(')
851     {
852       /* Note that in OCB mode this is actually invalid _encrypted_
853        * data and not a bad passphrase.  */
854       xfree (outbuf);
855       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
856     }
857
858   /* Check that we have a consistent S-Exp. */
859   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
860   if (!reallen || (reallen + blklen < protectedlen) )
861     {
862       xfree (outbuf);
863       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
864     }
865   *result = outbuf;
866   return 0;
867 }
868
869
870 /* Merge the parameter list contained in CLEARTEXT with the original
871  * protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
872  * Return the new list in RESULT and the MIC value in the 20 byte
873  * buffer SHA1HASH; if SHA1HASH is NULL no MIC will be computed.
874  * CUTOFF and CUTLEN will receive the offset and the length of the
875  * resulting list which should go into the MIC calculation but then be
876  * removed.  */
877 static int
878 merge_lists (const unsigned char *protectedkey,
879              size_t replacepos,
880              const unsigned char *cleartext,
881              unsigned char *sha1hash,
882              unsigned char **result, size_t *resultlen,
883              size_t *cutoff, size_t *cutlen)
884 {
885   size_t n, newlistlen;
886   unsigned char *newlist, *p;
887   const unsigned char *s;
888   const unsigned char *startpos, *endpos;
889   int i, rc;
890
891   *result = NULL;
892   *resultlen = 0;
893   *cutoff = 0;
894   *cutlen = 0;
895
896   if (replacepos < 26)
897     return gpg_error (GPG_ERR_BUG);
898
899   /* Estimate the required size of the resulting list.  We have a large
900      safety margin of >20 bytes (FIXME: MIC hash from CLEARTEXT and the
901      removed "protected-" */
902   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
903   if (!newlistlen)
904     return gpg_error (GPG_ERR_BUG);
905   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
906   if (!n)
907     return gpg_error (GPG_ERR_BUG);
908   newlistlen += n;
909   newlist = gcry_malloc_secure (newlistlen);
910   if (!newlist)
911     return out_of_core ();
912
913   /* Copy the initial segment */
914   strcpy ((char*)newlist, "(11:private-key");
915   p = newlist + 15;
916   memcpy (p, protectedkey+15+10, replacepos-15-10);
917   p += replacepos-15-10;
918
919   /* Copy the cleartext.  */
920   s = cleartext;
921   if (*s != '(' && s[1] != '(')
922     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
923   s += 2;
924   startpos = s;
925   while ( *s == '(' )
926     {
927       s++;
928       n = snext (&s);
929       if (!n)
930         goto invalid_sexp;
931       s += n;
932       n = snext (&s);
933       if (!n)
934         goto invalid_sexp;
935       s += n;
936       if ( *s != ')' )
937         goto invalid_sexp;
938       s++;
939     }
940   if ( *s != ')' )
941     goto invalid_sexp;
942   endpos = s;
943   s++;
944
945   /* Intermezzo: Get the MIC if requested.  */
946   if (sha1hash)
947     {
948       if (*s != '(')
949         goto invalid_sexp;
950       s++;
951       n = snext (&s);
952       if (!smatch (&s, n, "hash"))
953         goto invalid_sexp;
954       n = snext (&s);
955       if (!smatch (&s, n, "sha1"))
956         goto invalid_sexp;
957       n = snext (&s);
958       if (n != 20)
959         goto invalid_sexp;
960       memcpy (sha1hash, s, 20);
961       s += n;
962       if (*s != ')')
963         goto invalid_sexp;
964     }
965
966   /* Append the parameter list.  */
967   memcpy (p, startpos, endpos - startpos);
968   p += endpos - startpos;
969
970   /* Skip over the protected list element in the original list.  */
971   s = protectedkey + replacepos;
972   assert (*s == '(');
973   s++;
974   i = 1;
975   rc = sskip (&s, &i);
976   if (rc)
977     goto failure;
978   /* Record the position of the optional protected-at expression.  */
979   if (*s == '(')
980     {
981       const unsigned char *save_s = s;
982       s++;
983       n = snext (&s);
984       if (smatch (&s, n, "protected-at"))
985         {
986           i = 1;
987           rc = sskip (&s, &i);
988           if (rc)
989             goto failure;
990           *cutlen = s - save_s;
991         }
992       s = save_s;
993     }
994   startpos = s;
995   i = 2; /* we are inside this level */
996   rc = sskip (&s, &i);
997   if (rc)
998     goto failure;
999   assert (s[-1] == ')');
1000   endpos = s; /* one behind the end of the list */
1001
1002   /* Append the rest. */
1003   if (*cutlen)
1004     *cutoff = p - newlist;
1005   memcpy (p, startpos, endpos - startpos);
1006   p += endpos - startpos;
1007
1008
1009   /* ready */
1010   *result = newlist;
1011   *resultlen = newlistlen;
1012   return 0;
1013
1014  failure:
1015   wipememory (newlist, newlistlen);
1016   xfree (newlist);
1017   return rc;
1018
1019  invalid_sexp:
1020   wipememory (newlist, newlistlen);
1021   xfree (newlist);
1022   return gpg_error (GPG_ERR_INV_SEXP);
1023 }
1024
1025
1026
1027 /* Unprotect the key encoded in canonical format.  We assume a valid
1028    S-Exp here.  If a protected-at item is available, its value will
1029    be stored at protected_at unless this is NULL.  */
1030 int
1031 agent_unprotect (ctrl_t ctrl,
1032                  const unsigned char *protectedkey, const char *passphrase,
1033                  gnupg_isotime_t protected_at,
1034                  unsigned char **result, size_t *resultlen)
1035 {
1036   static struct {
1037     const char *name; /* Name of the protection method. */
1038     int algo;         /* (A zero indicates the "openpgp-native" hack.)  */
1039     int keylen;       /* Used key length in bytes.  */
1040     unsigned int is_ocb:1;
1041   } algotable[] = {
1042     { "openpgp-s2k3-sha1-aes-cbc",    GCRY_CIPHER_AES128, (128/8)},
1043     { "openpgp-s2k3-sha1-aes256-cbc", GCRY_CIPHER_AES256, (256/8)},
1044     { "openpgp-s2k3-ocb-aes",         GCRY_CIPHER_AES128, (128/8), 1},
1045     { "openpgp-native", 0, 0 }
1046   };
1047   int rc;
1048   const unsigned char *s;
1049   const unsigned char *protect_list;
1050   size_t n;
1051   int infidx, i;
1052   unsigned char sha1hash[20], sha1hash2[20];
1053   const unsigned char *s2ksalt;
1054   unsigned long s2kcount;
1055   const unsigned char *iv;
1056   int prot_cipher, prot_cipher_keylen;
1057   int is_ocb;
1058   const unsigned char *aad_begin, *aad_end, *aadhole_begin, *aadhole_end;
1059   const unsigned char *prot_begin;
1060   unsigned char *cleartext;
1061   unsigned char *final;
1062   size_t finallen;
1063   size_t cutoff, cutlen;
1064
1065   if (protected_at)
1066     *protected_at = 0;
1067
1068   s = protectedkey;
1069   if (*s != '(')
1070     return gpg_error (GPG_ERR_INV_SEXP);
1071   s++;
1072   n = snext (&s);
1073   if (!n)
1074     return gpg_error (GPG_ERR_INV_SEXP);
1075   if (!smatch (&s, n, "protected-private-key"))
1076     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1077   if (*s != '(')
1078     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1079   {
1080     aad_begin = aad_end = s;
1081     aad_end++;
1082     i = 1;
1083     rc = sskip (&aad_end, &i);
1084     if (rc)
1085       return rc;
1086   }
1087
1088   s++;
1089   n = snext (&s);
1090   if (!n)
1091     return gpg_error (GPG_ERR_INV_SEXP);
1092
1093   for (infidx=0; protect_info[infidx].algo
1094               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
1095     ;
1096   if (!protect_info[infidx].algo)
1097     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1098
1099   /* See wether we have a protected-at timestamp.  */
1100   protect_list = s;  /* Save for later.  */
1101   if (protected_at)
1102     {
1103       while (*s == '(')
1104         {
1105           prot_begin = s;
1106           s++;
1107           n = snext (&s);
1108           if (!n)
1109             return gpg_error (GPG_ERR_INV_SEXP);
1110           if (smatch (&s, n, "protected-at"))
1111             {
1112               n = snext (&s);
1113               if (!n)
1114                 return gpg_error (GPG_ERR_INV_SEXP);
1115               if (n != 15)
1116                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1117               memcpy (protected_at, s, 15);
1118               protected_at[15] = 0;
1119               break;
1120             }
1121           s += n;
1122           i = 1;
1123           rc = sskip (&s, &i);
1124           if (rc)
1125             return rc;
1126         }
1127     }
1128
1129   /* Now find the list with the protected information.  Here is an
1130      example for such a list:
1131      (protected openpgp-s2k3-sha1-aes-cbc
1132         ((sha1 <salt> <count>) <Initialization_Vector>)
1133         <encrypted_data>)
1134    */
1135   s = protect_list;
1136   for (;;)
1137     {
1138       if (*s != '(')
1139         return gpg_error (GPG_ERR_INV_SEXP);
1140       prot_begin = s;
1141       s++;
1142       n = snext (&s);
1143       if (!n)
1144         return gpg_error (GPG_ERR_INV_SEXP);
1145       if (smatch (&s, n, "protected"))
1146         break;
1147       s += n;
1148       i = 1;
1149       rc = sskip (&s, &i);
1150       if (rc)
1151         return rc;
1152     }
1153   /* found */
1154   {
1155     aadhole_begin = aadhole_end = prot_begin;
1156     aadhole_end++;
1157     i = 1;
1158     rc = sskip (&aadhole_end, &i);
1159     if (rc)
1160       return rc;
1161   }
1162   n = snext (&s);
1163   if (!n)
1164     return gpg_error (GPG_ERR_INV_SEXP);
1165
1166   /* Lookup the protection algo.  */
1167   prot_cipher = 0;        /* (avoid gcc warning) */
1168   prot_cipher_keylen = 0; /* (avoid gcc warning) */
1169   is_ocb = 0;
1170   for (i=0; i < DIM (algotable); i++)
1171     if (smatch (&s, n, algotable[i].name))
1172       {
1173         prot_cipher = algotable[i].algo;
1174         prot_cipher_keylen = algotable[i].keylen;
1175         is_ocb = algotable[i].is_ocb;
1176         break;
1177       }
1178   if (i == DIM (algotable)
1179       || (is_ocb && !OCB_MODE_SUPPORTED))
1180     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1181
1182   if (!prot_cipher)  /* This is "openpgp-native".  */
1183     {
1184       gcry_sexp_t s_prot_begin;
1185
1186       rc = gcry_sexp_sscan (&s_prot_begin, NULL,
1187                             prot_begin,
1188                             gcry_sexp_canon_len (prot_begin, 0,NULL,NULL));
1189       if (rc)
1190         return rc;
1191
1192       rc = convert_from_openpgp_native (ctrl, s_prot_begin, passphrase, &final);
1193       gcry_sexp_release (s_prot_begin);
1194       if (!rc)
1195         {
1196           *result = final;
1197           *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1198         }
1199       return rc;
1200     }
1201
1202   if (*s != '(' || s[1] != '(')
1203     return gpg_error (GPG_ERR_INV_SEXP);
1204   s += 2;
1205   n = snext (&s);
1206   if (!n)
1207     return gpg_error (GPG_ERR_INV_SEXP);
1208   if (!smatch (&s, n, "sha1"))
1209     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
1210   n = snext (&s);
1211   if (n != 8)
1212     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1213   s2ksalt = s;
1214   s += n;
1215   n = snext (&s);
1216   if (!n)
1217     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1218   /* We expect a list close as next, so we can simply use strtoul()
1219      here.  We might want to check that we only have digits - but this
1220      is nothing we should worry about */
1221   if (s[n] != ')' )
1222     return gpg_error (GPG_ERR_INV_SEXP);
1223
1224   /* Old versions of gpg-agent used the funny floating point number in
1225      a byte encoding as specified by OpenPGP.  However this is not
1226      needed and thus we now store it as a plain unsigned integer.  We
1227      can easily distinguish the old format by looking at its value:
1228      Less than 256 is an old-style encoded number; other values are
1229      plain integers.  In any case we check that they are at least
1230      65536 because we never used a lower value in the past and we
1231      should have a lower limit.  */
1232   s2kcount = strtoul ((const char*)s, NULL, 10);
1233   if (!s2kcount)
1234     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1235   if (s2kcount < 256)
1236     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
1237   if (s2kcount < 65536)
1238     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1239
1240   s += n;
1241   s++; /* skip list end */
1242
1243   n = snext (&s);
1244   if (is_ocb)
1245     {
1246       if (n != 12) /* Wrong size of the nonce. */
1247         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1248     }
1249   else
1250     {
1251       if (n != 16) /* Wrong blocksize for IV (we support only 128 bit). */
1252         return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1253     }
1254   iv = s;
1255   s += n;
1256   if (*s != ')' )
1257     return gpg_error (GPG_ERR_INV_SEXP);
1258   s++;
1259   n = snext (&s);
1260   if (!n)
1261     return gpg_error (GPG_ERR_INV_SEXP);
1262
1263   cleartext = NULL; /* Avoid cc warning. */
1264   rc = do_decryption (aad_begin, aad_end - aad_begin,
1265                       aadhole_begin, aadhole_end - aadhole_begin,
1266                       s, n,
1267                       passphrase, s2ksalt, s2kcount,
1268                       iv, is_ocb? 12:16,
1269                       prot_cipher, prot_cipher_keylen, is_ocb,
1270                       &cleartext);
1271   if (rc)
1272     return rc;
1273
1274   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
1275                     is_ocb? NULL : sha1hash,
1276                     &final, &finallen, &cutoff, &cutlen);
1277   /* Albeit cleartext has been allocated in secure memory and thus
1278      xfree will wipe it out, we do an extra wipe just in case
1279      somethings goes badly wrong. */
1280   wipememory (cleartext, n);
1281   xfree (cleartext);
1282   if (rc)
1283     return rc;
1284
1285   if (!is_ocb)
1286     {
1287       rc = calculate_mic (final, sha1hash2);
1288       if (!rc && memcmp (sha1hash, sha1hash2, 20))
1289         rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
1290       if (rc)
1291         {
1292           wipememory (final, finallen);
1293           xfree (final);
1294           return rc;
1295         }
1296     }
1297
1298   /* Now remove the part which is included in the MIC but should not
1299      go into the final thing.  */
1300   if (cutlen)
1301     {
1302       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1303       finallen -= cutlen;
1304     }
1305
1306   *result = final;
1307   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1308   return 0;
1309 }
1310
1311 /* Check the type of the private key, this is one of the constants:
1312    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1313    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1314    PRIVATE_KEY_PROTECTED for an protected private key or
1315    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are
1316    stored elsewhere.  Finally PRIVATE_KEY_OPENPGP_NONE may be returned
1317    is the key is still in the openpgp-native format but without
1318    protection.  */
1319 int
1320 agent_private_key_type (const unsigned char *privatekey)
1321 {
1322   const unsigned char *s;
1323   size_t n;
1324   int i;
1325
1326   s = privatekey;
1327   if (*s != '(')
1328     return PRIVATE_KEY_UNKNOWN;
1329   s++;
1330   n = snext (&s);
1331   if (!n)
1332     return PRIVATE_KEY_UNKNOWN;
1333   if (smatch (&s, n, "protected-private-key"))
1334     {
1335       /* We need to check whether this is openpgp-native protected
1336          with the protection method "none".  In that case we return a
1337          different key type so that the caller knows that there is no
1338          need to ask for a passphrase. */
1339       if (*s != '(')
1340         return PRIVATE_KEY_PROTECTED; /* Unknown sexp - assume protected. */
1341       s++;
1342       n = snext (&s);
1343       if (!n)
1344         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1345       s += n; /* Skip over the algo */
1346
1347       /* Find the (protected ...) list.  */
1348       for (;;)
1349         {
1350           if (*s != '(')
1351             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1352           s++;
1353           n = snext (&s);
1354           if (!n)
1355             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1356           if (smatch (&s, n, "protected"))
1357             break;
1358           s += n;
1359           i = 1;
1360           if (sskip (&s, &i))
1361             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1362         }
1363       /* Found - Is this openpgp-native? */
1364       n = snext (&s);
1365       if (!n)
1366         return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1367       if (smatch (&s, n, "openpgp-native")) /* Yes.  */
1368         {
1369           if (*s != '(')
1370             return PRIVATE_KEY_UNKNOWN; /* Unknown sexp. */
1371           s++;
1372           n = snext (&s);
1373           if (!n)
1374             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1375           s += n; /* Skip over "openpgp-private-key".  */
1376           /* Find the (protection ...) list.  */
1377           for (;;)
1378             {
1379               if (*s != '(')
1380                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1381               s++;
1382               n = snext (&s);
1383               if (!n)
1384                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1385               if (smatch (&s, n, "protection"))
1386                 break;
1387               s += n;
1388               i = 1;
1389               if (sskip (&s, &i))
1390                 return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1391             }
1392           /* Found - Is the mode "none"? */
1393           n = snext (&s);
1394           if (!n)
1395             return PRIVATE_KEY_UNKNOWN; /* Invalid sexp.  */
1396           if (smatch (&s, n, "none"))
1397             return PRIVATE_KEY_OPENPGP_NONE;  /* Yes.  */
1398         }
1399
1400       return PRIVATE_KEY_PROTECTED;
1401     }
1402   if (smatch (&s, n, "shadowed-private-key"))
1403     return PRIVATE_KEY_SHADOWED;
1404   if (smatch (&s, n, "private-key"))
1405     return PRIVATE_KEY_CLEAR;
1406   return PRIVATE_KEY_UNKNOWN;
1407 }
1408
1409
1410 \f
1411 /* Transform a passphrase into a suitable key of length KEYLEN and
1412    store this key in the caller provided buffer KEY.  The caller must
1413    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1414    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1415
1416    Returns an error code on failure.  */
1417 static int
1418 hash_passphrase (const char *passphrase, int hashalgo,
1419                  int s2kmode,
1420                  const unsigned char *s2ksalt,
1421                  unsigned long s2kcount,
1422                  unsigned char *key, size_t keylen)
1423 {
1424   /* The key derive function does not support a zero length string for
1425      the passphrase in the S2K modes.  Return a better suited error
1426      code than GPG_ERR_INV_DATA.  */
1427   if (!passphrase || !*passphrase)
1428     return gpg_error (GPG_ERR_NO_PASSPHRASE);
1429   return gcry_kdf_derive (passphrase, strlen (passphrase),
1430                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1431                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1432                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1433                           hashalgo, s2ksalt, 8, s2kcount,
1434                           keylen, key);
1435 }
1436
1437
1438 gpg_error_t
1439 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1440                      int s2kmode,
1441                      const unsigned char *s2ksalt,
1442                      unsigned int s2kcount,
1443                      unsigned char *key, size_t keylen)
1444 {
1445   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1446                           S2K_DECODE_COUNT (s2kcount),
1447                           key, keylen);
1448 }
1449
1450
1451 \f
1452
1453 /* Create an canonical encoded S-expression with the shadow info from
1454    a card's SERIALNO and the IDSTRING.  */
1455 unsigned char *
1456 make_shadow_info (const char *serialno, const char *idstring)
1457 {
1458   const char *s;
1459   char *info, *p;
1460   char numbuf[20];
1461   size_t n;
1462
1463   for (s=serialno, n=0; *s && s[1]; s += 2)
1464     n++;
1465
1466   info = p = xtrymalloc (1 + sizeof numbuf + n
1467                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1468   if (!info)
1469     return NULL;
1470   *p++ = '(';
1471   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1472   for (s=serialno; *s && s[1]; s += 2)
1473     *(unsigned char *)p++ = xtoi_2 (s);
1474   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1475   p = stpcpy (p, idstring);
1476   *p++ = ')';
1477   *p = 0;
1478   return (unsigned char *)info;
1479 }
1480
1481
1482
1483 /* Create a shadow key from a public key.  We use the shadow protocol
1484   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1485   S-expression is returned in an allocated buffer RESULT will point
1486   to. The input parameters are expected to be valid canonicalized
1487   S-expressions */
1488 int
1489 agent_shadow_key (const unsigned char *pubkey,
1490                   const unsigned char *shadow_info,
1491                   unsigned char **result)
1492 {
1493   const unsigned char *s;
1494   const unsigned char *point;
1495   size_t n;
1496   int depth = 0;
1497   char *p;
1498   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1499   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1500
1501   if (!pubkey_len || !shadow_info_len)
1502     return gpg_error (GPG_ERR_INV_VALUE);
1503   s = pubkey;
1504   if (*s != '(')
1505     return gpg_error (GPG_ERR_INV_SEXP);
1506   depth++;
1507   s++;
1508   n = snext (&s);
1509   if (!n)
1510     return gpg_error (GPG_ERR_INV_SEXP);
1511   if (!smatch (&s, n, "public-key"))
1512     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1513   if (*s != '(')
1514     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1515   depth++;
1516   s++;
1517   n = snext (&s);
1518   if (!n)
1519     return gpg_error (GPG_ERR_INV_SEXP);
1520   s += n; /* skip over the algorithm name */
1521
1522   while (*s != ')')
1523     {
1524       if (*s != '(')
1525         return gpg_error (GPG_ERR_INV_SEXP);
1526       depth++;
1527       s++;
1528       n = snext (&s);
1529       if (!n)
1530         return gpg_error (GPG_ERR_INV_SEXP);
1531       s += n;
1532       n = snext (&s);
1533       if (!n)
1534         return gpg_error (GPG_ERR_INV_SEXP);
1535       s +=n; /* skip value */
1536       if (*s != ')')
1537         return gpg_error (GPG_ERR_INV_SEXP);
1538       depth--;
1539       s++;
1540     }
1541   point = s; /* insert right before the point */
1542   depth--;
1543   s++;
1544   assert (depth == 1);
1545
1546   /* Calculate required length by taking in account: the "shadowed-"
1547      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1548   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1549   *result = xtrymalloc (n);
1550   p = (char*)*result;
1551   if (!p)
1552       return out_of_core ();
1553   p = stpcpy (p, "(20:shadowed-private-key");
1554   /* (10:public-key ...)*/
1555   memcpy (p, pubkey+14, point - (pubkey+14));
1556   p += point - (pubkey+14);
1557   p = stpcpy (p, "(8:shadowed5:t1-v1");
1558   memcpy (p, shadow_info, shadow_info_len);
1559   p += shadow_info_len;
1560   *p++ = ')';
1561   memcpy (p, point, pubkey_len - (point - pubkey));
1562   p += pubkey_len - (point - pubkey);
1563
1564   return 0;
1565 }
1566
1567 /* Parse a canonical encoded shadowed key and return a pointer to the
1568    inner list with the shadow_info */
1569 int
1570 agent_get_shadow_info (const unsigned char *shadowkey,
1571                        unsigned char const **shadow_info)
1572 {
1573   const unsigned char *s;
1574   size_t n;
1575   int depth = 0;
1576
1577   s = shadowkey;
1578   if (*s != '(')
1579     return gpg_error (GPG_ERR_INV_SEXP);
1580   depth++;
1581   s++;
1582   n = snext (&s);
1583   if (!n)
1584     return gpg_error (GPG_ERR_INV_SEXP);
1585   if (!smatch (&s, n, "shadowed-private-key"))
1586     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1587   if (*s != '(')
1588     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1589   depth++;
1590   s++;
1591   n = snext (&s);
1592   if (!n)
1593     return gpg_error (GPG_ERR_INV_SEXP);
1594   s += n; /* skip over the algorithm name */
1595
1596   for (;;)
1597     {
1598       if (*s == ')')
1599         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1600       if (*s != '(')
1601         return gpg_error (GPG_ERR_INV_SEXP);
1602       depth++;
1603       s++;
1604       n = snext (&s);
1605       if (!n)
1606         return gpg_error (GPG_ERR_INV_SEXP);
1607       if (smatch (&s, n, "shadowed"))
1608         break;
1609       s += n;
1610       n = snext (&s);
1611       if (!n)
1612         return gpg_error (GPG_ERR_INV_SEXP);
1613       s +=n; /* skip value */
1614       if (*s != ')')
1615         return gpg_error (GPG_ERR_INV_SEXP);
1616       depth--;
1617       s++;
1618     }
1619   /* Found the shadowed list, S points to the protocol */
1620   n = snext (&s);
1621   if (!n)
1622     return gpg_error (GPG_ERR_INV_SEXP);
1623   if (smatch (&s, n, "t1-v1"))
1624     {
1625       if (*s != '(')
1626         return gpg_error (GPG_ERR_INV_SEXP);
1627       *shadow_info = s;
1628     }
1629   else
1630     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1631   return 0;
1632 }
1633
1634
1635 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1636    the hex encoded serial number is returned as a malloced strings at
1637    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1638    error an error code is returned and NULL is stored at the result
1639    parameters addresses.  If the serial number or the ID string is not
1640    required, NULL may be passed for them.  */
1641 gpg_error_t
1642 parse_shadow_info (const unsigned char *shadow_info,
1643                    char **r_hexsn, char **r_idstr, int *r_pinlen)
1644 {
1645   const unsigned char *s;
1646   size_t n;
1647
1648   if (r_hexsn)
1649     *r_hexsn = NULL;
1650   if (r_idstr)
1651     *r_idstr = NULL;
1652   if (r_pinlen)
1653     *r_pinlen = 0;
1654
1655   s = shadow_info;
1656   if (*s != '(')
1657     return gpg_error (GPG_ERR_INV_SEXP);
1658   s++;
1659   n = snext (&s);
1660   if (!n)
1661     return gpg_error (GPG_ERR_INV_SEXP);
1662
1663   if (r_hexsn)
1664     {
1665       *r_hexsn = bin2hex (s, n, NULL);
1666       if (!*r_hexsn)
1667         return gpg_error_from_syserror ();
1668     }
1669   s += n;
1670
1671   n = snext (&s);
1672   if (!n)
1673     {
1674       if (r_hexsn)
1675         {
1676           xfree (*r_hexsn);
1677           *r_hexsn = NULL;
1678         }
1679       return gpg_error (GPG_ERR_INV_SEXP);
1680     }
1681
1682   if (r_idstr)
1683     {
1684       *r_idstr = xtrymalloc (n+1);
1685       if (!*r_idstr)
1686         {
1687           if (r_hexsn)
1688             {
1689               xfree (*r_hexsn);
1690               *r_hexsn = NULL;
1691             }
1692           return gpg_error_from_syserror ();
1693         }
1694       memcpy (*r_idstr, s, n);
1695       (*r_idstr)[n] = 0;
1696     }
1697
1698   /* Parse the optional PINLEN.  */
1699   n = snext (&s);
1700   if (!n)
1701     return 0;
1702
1703   if (r_pinlen)
1704     {
1705       char *tmpstr = xtrymalloc (n+1);
1706       if (!tmpstr)
1707         {
1708           if (r_hexsn)
1709             {
1710               xfree (*r_hexsn);
1711               *r_hexsn = NULL;
1712             }
1713           if (r_idstr)
1714             {
1715               xfree (*r_idstr);
1716               *r_idstr = NULL;
1717             }
1718           return gpg_error_from_syserror ();
1719         }
1720       memcpy (tmpstr, s, n);
1721       tmpstr[n] = 0;
1722
1723       *r_pinlen = (int)strtol (tmpstr, NULL, 10);
1724       xfree (tmpstr);
1725     }
1726
1727   return 0;
1728 }