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