7df82de037e912b982554de63f07d4593fb42814
[gnupg.git] / agent / protect.c
1 /* protect.c - Un/Protect a secret key
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2003, 2007, 2009, 2011 Free Software Foundation, Inc.
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 # include <windows.h>
32 #else
33 # include <sys/times.h>
34 #endif
35
36 #include "agent.h"
37
38 #include "sexp-parse.h"
39
40 #define PROT_CIPHER        GCRY_CIPHER_AES
41 #define PROT_CIPHER_STRING "aes"
42 #define PROT_CIPHER_KEYLEN (128/8)
43
44 /* Decode an rfc4880 encoded S2K count.  */
45 #define S2K_DECODE_COUNT(_val) ((16ul + ((_val) & 15)) << (((_val) >> 4) + 6))
46
47
48 /* A table containing the information needed to create a protected
49    private key.  */
50 static struct {
51   const char *algo;
52   const char *parmlist;
53   int prot_from, prot_to;
54 } protect_info[] = {
55   { "rsa",  "nedpqu", 2, 5 },
56   { "dsa",  "pqgyx", 4, 4 },
57   { "elg",  "pgyx", 3, 3 },
58   { "ecdsa","pabgnqd", 6, 6 },
59   { "ecdh", "pabgnqd", 6, 6 },
60   { "ecc",  "pabgnqd", 6, 6 },
61   { NULL }
62 };
63
64
65 /* A helper object for time measurement.  */
66 struct calibrate_time_s
67 {
68 #ifdef HAVE_W32_SYSTEM
69   FILETIME creation_time, exit_time, kernel_time, user_time;
70 #else
71   clock_t ticks;
72 #endif
73 };
74
75
76 static int
77 hash_passphrase (const char *passphrase, int hashalgo,
78                  int s2kmode,
79                  const unsigned char *s2ksalt, unsigned long s2kcount,
80                  unsigned char *key, size_t keylen);
81
82
83 \f
84 /* Get the process time and store it in DATA.  */
85 static void
86 calibrate_get_time (struct calibrate_time_s *data)
87 {
88 #ifdef HAVE_W32_SYSTEM
89 # ifdef HAVE_W32CE_SYSTEM
90   GetThreadTimes (GetCurrentThread (),
91 # else
92   GetProcessTimes (GetCurrentProcess (),
93 # endif
94                    &data->creation_time, &data->exit_time,
95                    &data->kernel_time, &data->user_time);
96 #else
97   struct tms tmp;
98
99   times (&tmp);
100   data->ticks = tmp.tms_utime;
101 #endif
102 }
103
104
105 static unsigned long
106 calibrate_elapsed_time (struct calibrate_time_s *starttime)
107 {
108   struct calibrate_time_s stoptime;
109
110   calibrate_get_time (&stoptime);
111 #ifdef HAVE_W32_SYSTEM
112   {
113     unsigned long long t1, t2;
114
115     t1 = (((unsigned long long)starttime->kernel_time.dwHighDateTime << 32)
116           + starttime->kernel_time.dwLowDateTime);
117     t1 += (((unsigned long long)starttime->user_time.dwHighDateTime << 32)
118            + starttime->user_time.dwLowDateTime);
119     t2 = (((unsigned long long)stoptime.kernel_time.dwHighDateTime << 32)
120           + stoptime.kernel_time.dwLowDateTime);
121     t2 += (((unsigned long long)stoptime.user_time.dwHighDateTime << 32)
122            + stoptime.user_time.dwLowDateTime);
123     return (unsigned long)((t2 - t1)/10000);
124   }
125 #else
126   return (unsigned long)((((double) (stoptime.ticks - starttime->ticks))
127                           /CLOCKS_PER_SEC)*10000000);
128 #endif
129 }
130
131
132 /* Run a test hashing for COUNT and return the time required in
133    milliseconds.  */
134 static unsigned long
135 calibrate_s2k_count_one (unsigned long count)
136 {
137   int rc;
138   char keybuf[PROT_CIPHER_KEYLEN];
139   struct calibrate_time_s starttime;
140
141   calibrate_get_time (&starttime);
142   rc = hash_passphrase ("123456789abcdef0", GCRY_MD_SHA1,
143                         3, "saltsalt", count, keybuf, sizeof keybuf);
144   if (rc)
145     BUG ();
146   return calibrate_elapsed_time (&starttime);
147 }
148
149
150 /* Measure the time we need to do the hash operations and deduce an
151    S2K count which requires about 100ms of time.  */
152 static unsigned long
153 calibrate_s2k_count (void)
154 {
155   unsigned long count;
156   unsigned long ms;
157
158   for (count = 65536; count; count *= 2)
159     {
160       ms = calibrate_s2k_count_one (count);
161       if (opt.verbose > 1)
162         log_info ("S2K calibration: %lu -> %lums\n", count, ms);
163       if (ms > 100)
164         break;
165     }
166
167   count = (unsigned long)(((double)count / ms) * 100);
168   count /= 1024;
169   count *= 1024;
170   if (count < 65536)
171     count = 65536;
172
173   if (opt.verbose)
174     {
175       ms = calibrate_s2k_count_one (count);
176       log_info ("S2K calibration: %lu -> %lums\n", count, ms);
177     }
178
179   return count;
180 }
181
182
183
184 /* Return the standard S2K count.  */
185 unsigned long
186 get_standard_s2k_count (void)
187 {
188   static unsigned long count;
189
190   if (!count)
191     count = calibrate_s2k_count ();
192
193   /* Enforce a lower limit.  */
194   return count < 65536 ? 65536 : count;
195 }
196
197
198 /* Same as get_standard_s2k_count but return the count in the encoding
199    as described by rfc4880.  */
200 unsigned char
201 get_standard_s2k_count_rfc4880 (void)
202 {
203   unsigned long iterations;
204   unsigned int count;
205   unsigned char result;
206   unsigned char c=0;
207
208   iterations = get_standard_s2k_count ();
209   if (iterations >= 65011712)
210     return 255;
211
212   /* Need count to be in the range 16-31 */
213   for (count=iterations>>6; count>=32; count>>=1)
214     c++;
215
216   result = (c<<4)|(count-16);
217
218   if (S2K_DECODE_COUNT(result) < iterations)
219     result++;
220
221   return result;
222
223 }
224
225
226 \f
227 /* Calculate the MIC for a private key or shared secret S-expression.
228    SHA1HASH should point to a 20 byte buffer.  This function is
229    suitable for all algorithms. */
230 static int
231 calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
232 {
233   const unsigned char *hash_begin, *hash_end;
234   const unsigned char *s;
235   size_t n;
236   int is_shared_secret;
237
238   s = plainkey;
239   if (*s != '(')
240     return gpg_error (GPG_ERR_INV_SEXP);
241   s++;
242   n = snext (&s);
243   if (!n)
244     return gpg_error (GPG_ERR_INV_SEXP);
245   if (smatch (&s, n, "private-key"))
246     is_shared_secret = 0;
247   else if (smatch (&s, n, "shared-secret"))
248     is_shared_secret = 1;
249   else
250     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
251   if (*s != '(')
252     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
253   hash_begin = s;
254   if (!is_shared_secret)
255     {
256       s++;
257       n = snext (&s);
258       if (!n)
259         return gpg_error (GPG_ERR_INV_SEXP);
260       s += n; /* Skip the algorithm name.  */
261     }
262
263   while (*s == '(')
264     {
265       s++;
266       n = snext (&s);
267       if (!n)
268         return gpg_error (GPG_ERR_INV_SEXP);
269       s += n;
270       n = snext (&s);
271       if (!n)
272         return gpg_error (GPG_ERR_INV_SEXP);
273       s += n;
274       if ( *s != ')' )
275         return gpg_error (GPG_ERR_INV_SEXP);
276       s++;
277     }
278   if (*s != ')')
279     return gpg_error (GPG_ERR_INV_SEXP);
280   s++;
281   hash_end = s;
282
283   gcry_md_hash_buffer (GCRY_MD_SHA1, sha1hash,
284                        hash_begin, hash_end - hash_begin);
285
286   return 0;
287 }
288
289
290 \f
291 /* Encrypt the parameter block starting at PROTBEGIN with length
292    PROTLEN using the utf8 encoded key PASSPHRASE and return the entire
293    encrypted block in RESULT or return with an error code.  SHA1HASH
294    is the 20 byte SHA-1 hash required for the integrity code.
295
296    The parameter block is expected to be an incomplete S-Expression of
297    the form (example in advanced format):
298
299      (d #046129F..[some bytes not shown]..81#)
300      (p #00e861b..[some bytes not shown]..f1#)
301      (q #00f7a7c..[some bytes not shown]..61#)
302      (u #304559a..[some bytes not shown]..9b#)
303
304    the returned block is the S-Expression:
305
306     (protected mode (parms) encrypted_octet_string)
307
308 */
309 static int
310 do_encryption (const unsigned char *protbegin, size_t protlen,
311                const char *passphrase,  const unsigned char *sha1hash,
312                unsigned char **result, size_t *resultlen)
313 {
314   gcry_cipher_hd_t hd;
315   const char *modestr = "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc";
316   int blklen, enclen, outlen;
317   unsigned char *iv = NULL;
318   int rc;
319   char *outbuf = NULL;
320   char *p;
321   int saltpos, ivpos, encpos;
322
323   *resultlen = 0;
324   *result = NULL;
325
326   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
327                          GCRY_CIPHER_SECURE);
328   if (rc)
329     return rc;
330
331
332   /* We need to work on a copy of the data because this makes it
333      easier to add the trailer and the padding and more important we
334      have to prefix the text with 2 parenthesis, so we have to
335      allocate enough space for:
336
337      ((<parameter_list>)(4:hash4:sha120:<hashvalue>)) + padding
338
339      We always append a full block of random bytes as padding but
340      encrypt only what is needed for a full blocksize.  */
341   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
342   outlen = 2 + protlen + 2 + 6 + 6 + 23 + 2 + blklen;
343   enclen = outlen/blklen * blklen;
344   outbuf = gcry_malloc_secure (outlen);
345   if (!outbuf)
346     rc = out_of_core ();
347   if (!rc)
348     {
349       /* Allocate random bytes to be used as IV, padding and s2k salt. */
350       iv = xtrymalloc (blklen*2+8);
351       if (!iv)
352         rc = gpg_error (GPG_ERR_ENOMEM);
353       else
354         {
355           gcry_create_nonce (iv, blklen*2+8);
356           rc = gcry_cipher_setiv (hd, iv, blklen);
357         }
358     }
359   if (!rc)
360     {
361       unsigned char *key;
362       size_t keylen = PROT_CIPHER_KEYLEN;
363
364       key = gcry_malloc_secure (keylen);
365       if (!key)
366         rc = out_of_core ();
367       else
368         {
369           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
370                                 3, iv+2*blklen,
371                                 get_standard_s2k_count (), key, keylen);
372           if (!rc)
373             rc = gcry_cipher_setkey (hd, key, keylen);
374           xfree (key);
375         }
376     }
377   if (!rc)
378     {
379       p = outbuf;
380       *p++ = '(';
381       *p++ = '(';
382       memcpy (p, protbegin, protlen);
383       p += protlen;
384       memcpy (p, ")(4:hash4:sha120:", 17);
385       p += 17;
386       memcpy (p, sha1hash, 20);
387       p += 20;
388       *p++ = ')';
389       *p++ = ')';
390       memcpy (p, iv+blklen, blklen);
391       p += blklen;
392       assert ( p - outbuf == outlen);
393       rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
394     }
395   gcry_cipher_close (hd);
396   if (rc)
397     {
398       xfree (iv);
399       xfree (outbuf);
400       return rc;
401     }
402
403   /* Now allocate the buffer we want to return.  This is
404
405      (protected openpgp-s2k3-sha1-aes-cbc
406        ((sha1 salt no_of_iterations) 16byte_iv)
407        encrypted_octet_string)
408
409      in canoncical format of course.  We use asprintf and %n modifier
410      and dummy values as placeholders.  */
411   {
412     char countbuf[35];
413
414     snprintf (countbuf, sizeof countbuf, "%lu", get_standard_s2k_count ());
415     p = xtryasprintf
416       ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
417        (int)strlen (modestr), modestr,
418        &saltpos,
419        (unsigned int)strlen (countbuf), countbuf,
420        blklen, &ivpos, blklen, "",
421        enclen, &encpos, enclen, "");
422     if (!p)
423       {
424         gpg_error_t tmperr = out_of_core ();
425         xfree (iv);
426         xfree (outbuf);
427         return tmperr;
428       }
429   }
430   *resultlen = strlen (p);
431   *result = (unsigned char*)p;
432   memcpy (p+saltpos, iv+2*blklen, 8);
433   memcpy (p+ivpos, iv, blklen);
434   memcpy (p+encpos, outbuf, enclen);
435   xfree (iv);
436   xfree (outbuf);
437   return 0;
438 }
439
440
441
442 /* Protect the key encoded in canonical format in PLAINKEY.  We assume
443    a valid S-Exp here. */
444 int
445 agent_protect (const unsigned char *plainkey, const char *passphrase,
446                unsigned char **result, size_t *resultlen)
447 {
448   int rc;
449   const unsigned char *s;
450   const unsigned char *hash_begin, *hash_end;
451   const unsigned char *prot_begin, *prot_end, *real_end;
452   size_t n;
453   int c, infidx, i;
454   unsigned char hashvalue[20];
455   char timestamp_exp[35];
456   unsigned char *protected;
457   size_t protectedlen;
458   int depth = 0;
459   unsigned char *p;
460   gcry_md_hd_t md;
461
462   /* Create an S-expression with the protected-at timestamp.  */
463   memcpy (timestamp_exp, "(12:protected-at15:", 19);
464   gnupg_get_isotime (timestamp_exp+19);
465   timestamp_exp[19+15] = ')';
466
467   /* Parse original key.  */
468   s = plainkey;
469   if (*s != '(')
470     return gpg_error (GPG_ERR_INV_SEXP);
471   depth++;
472   s++;
473   n = snext (&s);
474   if (!n)
475     return gpg_error (GPG_ERR_INV_SEXP);
476   if (!smatch (&s, n, "private-key"))
477     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
478   if (*s != '(')
479     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
480   depth++;
481   hash_begin = s;
482   s++;
483   n = snext (&s);
484   if (!n)
485     return gpg_error (GPG_ERR_INV_SEXP);
486
487   for (infidx=0; protect_info[infidx].algo
488               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
489     ;
490   if (!protect_info[infidx].algo)
491     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
492
493   prot_begin = prot_end = NULL;
494   for (i=0; (c=protect_info[infidx].parmlist[i]); i++)
495     {
496       if (i == protect_info[infidx].prot_from)
497         prot_begin = s;
498       if (*s != '(')
499         return gpg_error (GPG_ERR_INV_SEXP);
500       depth++;
501       s++;
502       n = snext (&s);
503       if (!n)
504         return gpg_error (GPG_ERR_INV_SEXP);
505       if (n != 1 || c != *s)
506         return gpg_error (GPG_ERR_INV_SEXP);
507       s += n;
508       n = snext (&s);
509       if (!n)
510         return gpg_error (GPG_ERR_INV_SEXP);
511       s +=n; /* skip value */
512       if (*s != ')')
513         return gpg_error (GPG_ERR_INV_SEXP);
514       depth--;
515       if (i == protect_info[infidx].prot_to)
516         prot_end = s;
517       s++;
518     }
519   if (*s != ')' || !prot_begin || !prot_end )
520     return gpg_error (GPG_ERR_INV_SEXP);
521   depth--;
522   hash_end = s;
523   s++;
524   /* Skip to the end of the S-expression.  */
525   assert (depth == 1);
526   rc = sskip (&s, &depth);
527   if (rc)
528     return rc;
529   assert (!depth);
530   real_end = s-1;
531
532
533   /* Hash the stuff.  Because the timestamp_exp won't get protected,
534      we can't simply hash a continuous buffer but need to use several
535      md_writes.  */
536   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
537   if (rc)
538     return rc;
539   gcry_md_write (md, hash_begin, hash_end - hash_begin);
540   gcry_md_write (md, timestamp_exp, 35);
541   gcry_md_write (md, ")", 1);
542   memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
543   gcry_md_close (md);
544
545   rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
546                       passphrase,  hashvalue,
547                       &protected, &protectedlen);
548   if (rc)
549     return rc;
550
551   /* Now create the protected version of the key.  Note that the 10
552      extra bytes are for for the inserted "protected-" string (the
553      beginning of the plaintext reads: "((11:private-key(" ).  The 35
554      term is the space for (12:protected-at15:<timestamp>).  */
555   *resultlen = (10
556                 + (prot_begin-plainkey)
557                 + protectedlen
558                 + 35
559                 + (real_end-prot_end));
560   *result = p = xtrymalloc (*resultlen);
561   if (!p)
562     {
563       gpg_error_t tmperr = out_of_core ();
564       xfree (protected);
565       return tmperr;
566     }
567   memcpy (p, "(21:protected-", 14);
568   p += 14;
569   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
570   p += prot_begin - plainkey - 4;
571   memcpy (p, protected, protectedlen);
572   p += protectedlen;
573
574   memcpy (p, timestamp_exp, 35);
575   p += 35;
576
577   memcpy (p, prot_end+1, real_end - prot_end);
578   p += real_end - prot_end;
579   assert ( p - *result == *resultlen);
580   xfree (protected);
581
582   return 0;
583 }
584
585 \f
586 /* Do the actual decryption and check the return list for consistency.  */
587 static int
588 do_decryption (const unsigned char *protected, size_t protectedlen,
589                const char *passphrase,
590                const unsigned char *s2ksalt, unsigned long s2kcount,
591                const unsigned char *iv, size_t ivlen,
592                unsigned char **result)
593 {
594   int rc = 0;
595   int blklen;
596   gcry_cipher_hd_t hd;
597   unsigned char *outbuf;
598   size_t reallen;
599
600   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
601   if (protectedlen < 4 || (protectedlen%blklen))
602     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
603
604   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
605                          GCRY_CIPHER_SECURE);
606   if (rc)
607     return rc;
608
609   outbuf = gcry_malloc_secure (protectedlen);
610   if (!outbuf)
611     rc = out_of_core ();
612   if (!rc)
613     rc = gcry_cipher_setiv (hd, iv, ivlen);
614   if (!rc)
615     {
616       unsigned char *key;
617       size_t keylen = PROT_CIPHER_KEYLEN;
618
619       key = gcry_malloc_secure (keylen);
620       if (!key)
621         rc = out_of_core ();
622       else
623         {
624           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
625                                 3, s2ksalt, s2kcount, key, keylen);
626           if (!rc)
627             rc = gcry_cipher_setkey (hd, key, keylen);
628           xfree (key);
629         }
630     }
631   if (!rc)
632     rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
633                               protected, protectedlen);
634   gcry_cipher_close (hd);
635   if (rc)
636     {
637       xfree (outbuf);
638       return rc;
639     }
640   /* Do a quick check first. */
641   if (*outbuf != '(' && outbuf[1] != '(')
642     {
643       xfree (outbuf);
644       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
645     }
646   /* Check that we have a consistent S-Exp. */
647   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
648   if (!reallen || (reallen + blklen < protectedlen) )
649     {
650       xfree (outbuf);
651       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
652     }
653   *result = outbuf;
654   return 0;
655 }
656
657
658 /* Merge the parameter list contained in CLEARTEXT with the original
659    protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
660    Return the new list in RESULT and the MIC value in the 20 byte
661    buffer SHA1HASH.  CUTOFF and CUTLEN will receive the offset and the
662    length of the resulting list which should go into the MIC
663    calculation but then be removed.  */
664 static int
665 merge_lists (const unsigned char *protectedkey,
666              size_t replacepos,
667              const unsigned char *cleartext,
668              unsigned char *sha1hash,
669              unsigned char **result, size_t *resultlen,
670              size_t *cutoff, size_t *cutlen)
671 {
672   size_t n, newlistlen;
673   unsigned char *newlist, *p;
674   const unsigned char *s;
675   const unsigned char *startpos, *endpos;
676   int i, rc;
677
678   *result = NULL;
679   *resultlen = 0;
680   *cutoff = 0;
681   *cutlen = 0;
682
683   if (replacepos < 26)
684     return gpg_error (GPG_ERR_BUG);
685
686   /* Estimate the required size of the resulting list.  We have a large
687      safety margin of >20 bytes (MIC hash from CLEARTEXT and the
688      removed "protected-" */
689   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
690   if (!newlistlen)
691     return gpg_error (GPG_ERR_BUG);
692   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
693   if (!n)
694     return gpg_error (GPG_ERR_BUG);
695   newlistlen += n;
696   newlist = gcry_malloc_secure (newlistlen);
697   if (!newlist)
698     return out_of_core ();
699
700   /* Copy the initial segment */
701   strcpy ((char*)newlist, "(11:private-key");
702   p = newlist + 15;
703   memcpy (p, protectedkey+15+10, replacepos-15-10);
704   p += replacepos-15-10;
705
706   /* copy the cleartext */
707   s = cleartext;
708   if (*s != '(' && s[1] != '(')
709     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
710   s += 2;
711   startpos = s;
712   while ( *s == '(' )
713     {
714       s++;
715       n = snext (&s);
716       if (!n)
717         goto invalid_sexp;
718       s += n;
719       n = snext (&s);
720       if (!n)
721         goto invalid_sexp;
722       s += n;
723       if ( *s != ')' )
724         goto invalid_sexp;
725       s++;
726     }
727   if ( *s != ')' )
728     goto invalid_sexp;
729   endpos = s;
730   s++;
731   /* Intermezzo: Get the MIC */
732   if (*s != '(')
733     goto invalid_sexp;
734   s++;
735   n = snext (&s);
736   if (!smatch (&s, n, "hash"))
737     goto invalid_sexp;
738   n = snext (&s);
739   if (!smatch (&s, n, "sha1"))
740     goto invalid_sexp;
741   n = snext (&s);
742   if (n != 20)
743     goto invalid_sexp;
744   memcpy (sha1hash, s, 20);
745   s += n;
746   if (*s != ')')
747     goto invalid_sexp;
748   /* End intermezzo */
749
750   /* append the parameter list */
751   memcpy (p, startpos, endpos - startpos);
752   p += endpos - startpos;
753
754   /* Skip over the protected list element in the original list.  */
755   s = protectedkey + replacepos;
756   assert (*s == '(');
757   s++;
758   i = 1;
759   rc = sskip (&s, &i);
760   if (rc)
761     goto failure;
762   /* Record the position of the optional protected-at expression.  */
763   if (*s == '(')
764     {
765       const unsigned char *save_s = s;
766       s++;
767       n = snext (&s);
768       if (smatch (&s, n, "protected-at"))
769         {
770           i = 1;
771           rc = sskip (&s, &i);
772           if (rc)
773             goto failure;
774           *cutlen = s - save_s;
775         }
776       s = save_s;
777     }
778   startpos = s;
779   i = 2; /* we are inside this level */
780   rc = sskip (&s, &i);
781   if (rc)
782     goto failure;
783   assert (s[-1] == ')');
784   endpos = s; /* one behind the end of the list */
785
786   /* Append the rest. */
787   if (*cutlen)
788     *cutoff = p - newlist;
789   memcpy (p, startpos, endpos - startpos);
790   p += endpos - startpos;
791
792
793   /* ready */
794   *result = newlist;
795   *resultlen = newlistlen;
796   return 0;
797
798  failure:
799   wipememory (newlist, newlistlen);
800   xfree (newlist);
801   return rc;
802
803  invalid_sexp:
804   wipememory (newlist, newlistlen);
805   xfree (newlist);
806   return gpg_error (GPG_ERR_INV_SEXP);
807 }
808
809
810
811 /* Unprotect the key encoded in canonical format.  We assume a valid
812    S-Exp here.  If a protected-at item is available, its value will
813    be stored at protocted_at unless this is NULL.  */
814 int
815 agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
816                  gnupg_isotime_t protected_at,
817                  unsigned char **result, size_t *resultlen)
818 {
819   int rc;
820   const unsigned char *s;
821   const unsigned char *protect_list;
822   size_t n;
823   int infidx, i;
824   unsigned char sha1hash[20], sha1hash2[20];
825   const unsigned char *s2ksalt;
826   unsigned long s2kcount;
827   const unsigned char *iv;
828   const unsigned char *prot_begin;
829   unsigned char *cleartext;
830   unsigned char *final;
831   size_t finallen;
832   size_t cutoff, cutlen;
833
834   if (protected_at)
835     *protected_at = 0;
836
837   s = protectedkey;
838   if (*s != '(')
839     return gpg_error (GPG_ERR_INV_SEXP);
840   s++;
841   n = snext (&s);
842   if (!n)
843     return gpg_error (GPG_ERR_INV_SEXP);
844   if (!smatch (&s, n, "protected-private-key"))
845     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
846   if (*s != '(')
847     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
848   s++;
849   n = snext (&s);
850   if (!n)
851     return gpg_error (GPG_ERR_INV_SEXP);
852
853   for (infidx=0; protect_info[infidx].algo
854               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
855     ;
856   if (!protect_info[infidx].algo)
857     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
858
859
860   /* See wether we have a protected-at timestamp.  */
861   protect_list = s;  /* Save for later.  */
862   if (protected_at)
863     {
864       while (*s == '(')
865         {
866           prot_begin = s;
867           s++;
868           n = snext (&s);
869           if (!n)
870             return gpg_error (GPG_ERR_INV_SEXP);
871           if (smatch (&s, n, "protected-at"))
872             {
873               n = snext (&s);
874               if (!n)
875                 return gpg_error (GPG_ERR_INV_SEXP);
876               if (n != 15)
877                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
878               memcpy (protected_at, s, 15);
879               protected_at[15] = 0;
880               break;
881             }
882           s += n;
883           i = 1;
884           rc = sskip (&s, &i);
885           if (rc)
886             return rc;
887         }
888     }
889
890   /* Now find the list with the protected information.  Here is an
891      example for such a list:
892      (protected openpgp-s2k3-sha1-aes-cbc
893         ((sha1 <salt> <count>) <Initialization_Vector>)
894         <encrypted_data>)
895    */
896   s = protect_list;
897   for (;;)
898     {
899       if (*s != '(')
900         return gpg_error (GPG_ERR_INV_SEXP);
901       prot_begin = s;
902       s++;
903       n = snext (&s);
904       if (!n)
905         return gpg_error (GPG_ERR_INV_SEXP);
906       if (smatch (&s, n, "protected"))
907         break;
908       s += n;
909       i = 1;
910       rc = sskip (&s, &i);
911       if (rc)
912         return rc;
913     }
914   /* found */
915   n = snext (&s);
916   if (!n)
917     return gpg_error (GPG_ERR_INV_SEXP);
918   if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
919     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
920   if (*s != '(' || s[1] != '(')
921     return gpg_error (GPG_ERR_INV_SEXP);
922   s += 2;
923   n = snext (&s);
924   if (!n)
925     return gpg_error (GPG_ERR_INV_SEXP);
926   if (!smatch (&s, n, "sha1"))
927     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
928   n = snext (&s);
929   if (n != 8)
930     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
931   s2ksalt = s;
932   s += n;
933   n = snext (&s);
934   if (!n)
935     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
936   /* We expect a list close as next, so we can simply use strtoul()
937      here.  We might want to check that we only have digits - but this
938      is nothing we should worry about */
939   if (s[n] != ')' )
940     return gpg_error (GPG_ERR_INV_SEXP);
941
942   /* Old versions of gpg-agent used the funny floating point number in
943      a byte encoding as specified by OpenPGP.  However this is not
944      needed and thus we now store it as a plain unsigned integer.  We
945      can easily distinguish the old format by looking at its value:
946      Less than 256 is an old-style encoded number; other values are
947      plain integers.  In any case we check that they are at least
948      65536 because we never used a lower value in the past and we
949      should have a lower limit.  */
950   s2kcount = strtoul ((const char*)s, NULL, 10);
951   if (!s2kcount)
952     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
953   if (s2kcount < 256)
954     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
955   if (s2kcount < 65536)
956     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
957
958   s += n;
959   s++; /* skip list end */
960
961   n = snext (&s);
962   if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
963     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
964   iv = s;
965   s += n;
966   if (*s != ')' )
967     return gpg_error (GPG_ERR_INV_SEXP);
968   s++;
969   n = snext (&s);
970   if (!n)
971     return gpg_error (GPG_ERR_INV_SEXP);
972
973   cleartext = NULL; /* Avoid cc warning. */
974   rc = do_decryption (s, n,
975                       passphrase, s2ksalt, s2kcount,
976                       iv, 16,
977                       &cleartext);
978   if (rc)
979     return rc;
980
981   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
982                     sha1hash, &final, &finallen, &cutoff, &cutlen);
983   /* Albeit cleartext has been allocated in secure memory and thus
984      xfree will wipe it out, we do an extra wipe just in case
985      somethings goes badly wrong. */
986   wipememory (cleartext, n);
987   xfree (cleartext);
988   if (rc)
989     return rc;
990
991   rc = calculate_mic (final, sha1hash2);
992   if (!rc && memcmp (sha1hash, sha1hash2, 20))
993     rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
994   if (rc)
995     {
996       wipememory (final, finallen);
997       xfree (final);
998       return rc;
999     }
1000   /* Now remove the part which is included in the MIC but should not
1001      go into the final thing.  */
1002   if (cutlen)
1003     {
1004       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1005       finallen -= cutlen;
1006     }
1007
1008   *result = final;
1009   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1010   return 0;
1011 }
1012
1013 /* Check the type of the private key, this is one of the constants:
1014    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1015    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1016    PRIVATE_KEY_PROTECTED for an protected private key or
1017    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are stored
1018    elsewhere. */
1019 int
1020 agent_private_key_type (const unsigned char *privatekey)
1021 {
1022   const unsigned char *s;
1023   size_t n;
1024
1025   s = privatekey;
1026   if (*s != '(')
1027     return PRIVATE_KEY_UNKNOWN;
1028   s++;
1029   n = snext (&s);
1030   if (!n)
1031     return PRIVATE_KEY_UNKNOWN;
1032   if (smatch (&s, n, "protected-private-key"))
1033     return PRIVATE_KEY_PROTECTED;
1034   if (smatch (&s, n, "shadowed-private-key"))
1035     return PRIVATE_KEY_SHADOWED;
1036   if (smatch (&s, n, "private-key"))
1037     return PRIVATE_KEY_CLEAR;
1038   return PRIVATE_KEY_UNKNOWN;
1039 }
1040
1041
1042 \f
1043 /* Transform a passphrase into a suitable key of length KEYLEN and
1044    store this key in the caller provided buffer KEY.  The caller must
1045    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1046    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1047
1048    Returns an error code on failure.  */
1049 static int
1050 hash_passphrase (const char *passphrase, int hashalgo,
1051                  int s2kmode,
1052                  const unsigned char *s2ksalt,
1053                  unsigned long s2kcount,
1054                  unsigned char *key, size_t keylen)
1055 {
1056
1057   return gcry_kdf_derive (passphrase, strlen (passphrase),
1058                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1059                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1060                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1061                           hashalgo, s2ksalt, 8, s2kcount,
1062                           keylen, key);
1063 }
1064
1065
1066 gpg_error_t
1067 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1068                      int s2kmode,
1069                      const unsigned char *s2ksalt,
1070                      unsigned int s2kcount,
1071                      unsigned char *key, size_t keylen)
1072 {
1073   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1074                           S2K_DECODE_COUNT (s2kcount),
1075                           key, keylen);
1076 }
1077
1078
1079 \f
1080
1081 /* Create an canonical encoded S-expression with the shadow info from
1082    a card's SERIALNO and the IDSTRING.  */
1083 unsigned char *
1084 make_shadow_info (const char *serialno, const char *idstring)
1085 {
1086   const char *s;
1087   char *info, *p;
1088   char numbuf[20];
1089   size_t n;
1090
1091   for (s=serialno, n=0; *s && s[1]; s += 2)
1092     n++;
1093
1094   info = p = xtrymalloc (1 + sizeof numbuf + n
1095                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1096   if (!info)
1097     return NULL;
1098   *p++ = '(';
1099   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1100   for (s=serialno; *s && s[1]; s += 2)
1101     *(unsigned char *)p++ = xtoi_2 (s);
1102   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1103   p = stpcpy (p, idstring);
1104   *p++ = ')';
1105   *p = 0;
1106   return (unsigned char *)info;
1107 }
1108
1109
1110
1111 /* Create a shadow key from a public key.  We use the shadow protocol
1112   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1113   S-expression is returned in an allocated buffer RESULT will point
1114   to. The input parameters are expected to be valid canonicalized
1115   S-expressions */
1116 int
1117 agent_shadow_key (const unsigned char *pubkey,
1118                   const unsigned char *shadow_info,
1119                   unsigned char **result)
1120 {
1121   const unsigned char *s;
1122   const unsigned char *point;
1123   size_t n;
1124   int depth = 0;
1125   char *p;
1126   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1127   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1128
1129   if (!pubkey_len || !shadow_info_len)
1130     return gpg_error (GPG_ERR_INV_VALUE);
1131   s = pubkey;
1132   if (*s != '(')
1133     return gpg_error (GPG_ERR_INV_SEXP);
1134   depth++;
1135   s++;
1136   n = snext (&s);
1137   if (!n)
1138     return gpg_error (GPG_ERR_INV_SEXP);
1139   if (!smatch (&s, n, "public-key"))
1140     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1141   if (*s != '(')
1142     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1143   depth++;
1144   s++;
1145   n = snext (&s);
1146   if (!n)
1147     return gpg_error (GPG_ERR_INV_SEXP);
1148   s += n; /* skip over the algorithm name */
1149
1150   while (*s != ')')
1151     {
1152       if (*s != '(')
1153         return gpg_error (GPG_ERR_INV_SEXP);
1154       depth++;
1155       s++;
1156       n = snext (&s);
1157       if (!n)
1158         return gpg_error (GPG_ERR_INV_SEXP);
1159       s += n;
1160       n = snext (&s);
1161       if (!n)
1162         return gpg_error (GPG_ERR_INV_SEXP);
1163       s +=n; /* skip value */
1164       if (*s != ')')
1165         return gpg_error (GPG_ERR_INV_SEXP);
1166       depth--;
1167       s++;
1168     }
1169   point = s; /* insert right before the point */
1170   depth--;
1171   s++;
1172   assert (depth == 1);
1173
1174   /* Calculate required length by taking in account: the "shadowed-"
1175      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1176   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1177   *result = xtrymalloc (n);
1178   p = (char*)*result;
1179   if (!p)
1180       return out_of_core ();
1181   p = stpcpy (p, "(20:shadowed-private-key");
1182   /* (10:public-key ...)*/
1183   memcpy (p, pubkey+14, point - (pubkey+14));
1184   p += point - (pubkey+14);
1185   p = stpcpy (p, "(8:shadowed5:t1-v1");
1186   memcpy (p, shadow_info, shadow_info_len);
1187   p += shadow_info_len;
1188   *p++ = ')';
1189   memcpy (p, point, pubkey_len - (point - pubkey));
1190   p += pubkey_len - (point - pubkey);
1191
1192   return 0;
1193 }
1194
1195 /* Parse a canonical encoded shadowed key and return a pointer to the
1196    inner list with the shadow_info */
1197 int
1198 agent_get_shadow_info (const unsigned char *shadowkey,
1199                        unsigned char const **shadow_info)
1200 {
1201   const unsigned char *s;
1202   size_t n;
1203   int depth = 0;
1204
1205   s = shadowkey;
1206   if (*s != '(')
1207     return gpg_error (GPG_ERR_INV_SEXP);
1208   depth++;
1209   s++;
1210   n = snext (&s);
1211   if (!n)
1212     return gpg_error (GPG_ERR_INV_SEXP);
1213   if (!smatch (&s, n, "shadowed-private-key"))
1214     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1215   if (*s != '(')
1216     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1217   depth++;
1218   s++;
1219   n = snext (&s);
1220   if (!n)
1221     return gpg_error (GPG_ERR_INV_SEXP);
1222   s += n; /* skip over the algorithm name */
1223
1224   for (;;)
1225     {
1226       if (*s == ')')
1227         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1228       if (*s != '(')
1229         return gpg_error (GPG_ERR_INV_SEXP);
1230       depth++;
1231       s++;
1232       n = snext (&s);
1233       if (!n)
1234         return gpg_error (GPG_ERR_INV_SEXP);
1235       if (smatch (&s, n, "shadowed"))
1236         break;
1237       s += n;
1238       n = snext (&s);
1239       if (!n)
1240         return gpg_error (GPG_ERR_INV_SEXP);
1241       s +=n; /* skip value */
1242       if (*s != ')')
1243         return gpg_error (GPG_ERR_INV_SEXP);
1244       depth--;
1245       s++;
1246     }
1247   /* Found the shadowed list, S points to the protocol */
1248   n = snext (&s);
1249   if (!n)
1250     return gpg_error (GPG_ERR_INV_SEXP);
1251   if (smatch (&s, n, "t1-v1"))
1252     {
1253       if (*s != '(')
1254         return gpg_error (GPG_ERR_INV_SEXP);
1255       *shadow_info = s;
1256     }
1257   else
1258     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1259   return 0;
1260 }
1261
1262
1263 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1264    the hex encoded serial number is returned as a malloced strings at
1265    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1266    error an error code is returned and NULL is stored at the result
1267    parameters addresses.  If the serial number or the ID string is not
1268    required, NULL may be passed for them.  */
1269 gpg_error_t
1270 parse_shadow_info (const unsigned char *shadow_info,
1271                    char **r_hexsn, char **r_idstr)
1272 {
1273   const unsigned char *s;
1274   size_t n;
1275
1276   if (r_hexsn)
1277     *r_hexsn = NULL;
1278   if (r_idstr)
1279     *r_idstr = NULL;
1280
1281   s = shadow_info;
1282   if (*s != '(')
1283     return gpg_error (GPG_ERR_INV_SEXP);
1284   s++;
1285   n = snext (&s);
1286   if (!n)
1287     return gpg_error (GPG_ERR_INV_SEXP);
1288
1289   if (r_hexsn)
1290     {
1291       *r_hexsn = bin2hex (s, n, NULL);
1292       if (!*r_hexsn)
1293         return gpg_error_from_syserror ();
1294     }
1295   s += n;
1296
1297   n = snext (&s);
1298   if (!n)
1299     {
1300       if (r_hexsn)
1301         {
1302           xfree (*r_hexsn);
1303           *r_hexsn = NULL;
1304         }
1305       return gpg_error (GPG_ERR_INV_SEXP);
1306     }
1307
1308   if (r_idstr)
1309     {
1310       *r_idstr = xtrymalloc (n+1);
1311       if (!*r_idstr)
1312         {
1313           if (r_hexsn)
1314             {
1315               xfree (*r_hexsn);
1316               *r_hexsn = NULL;
1317             }
1318           return gpg_error_from_syserror ();
1319         }
1320       memcpy (*r_idstr, s, n);
1321       (*r_idstr)[n] = 0;
1322     }
1323
1324   return 0;
1325 }