Fix strerror vs. gpg_strerror usage.
[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                unsigned long s2k_count)
314 {
315   gcry_cipher_hd_t hd;
316   const char *modestr = "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc";
317   int blklen, enclen, outlen;
318   unsigned char *iv = NULL;
319   int rc;
320   char *outbuf = NULL;
321   char *p;
322   int saltpos, ivpos, encpos;
323
324   *resultlen = 0;
325   *result = NULL;
326
327   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
328                          GCRY_CIPHER_SECURE);
329   if (rc)
330     return rc;
331
332
333   /* We need to work on a copy of the data because this makes it
334      easier to add the trailer and the padding and more important we
335      have to prefix the text with 2 parenthesis, so we have to
336      allocate enough space for:
337
338      ((<parameter_list>)(4:hash4:sha120:<hashvalue>)) + padding
339
340      We always append a full block of random bytes as padding but
341      encrypt only what is needed for a full blocksize.  */
342   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
343   outlen = 2 + protlen + 2 + 6 + 6 + 23 + 2 + blklen;
344   enclen = outlen/blklen * blklen;
345   outbuf = gcry_malloc_secure (outlen);
346   if (!outbuf)
347     rc = out_of_core ();
348   if (!rc)
349     {
350       /* Allocate random bytes to be used as IV, padding and s2k salt. */
351       iv = xtrymalloc (blklen*2+8);
352       if (!iv)
353         rc = gpg_error (GPG_ERR_ENOMEM);
354       else
355         {
356           gcry_create_nonce (iv, blklen*2+8);
357           rc = gcry_cipher_setiv (hd, iv, blklen);
358         }
359     }
360   if (!rc)
361     {
362       unsigned char *key;
363       size_t keylen = PROT_CIPHER_KEYLEN;
364
365       key = gcry_malloc_secure (keylen);
366       if (!key)
367         rc = out_of_core ();
368       else
369         {
370           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
371                                 3, iv+2*blklen,
372                                 s2k_count ? s2k_count : get_standard_s2k_count(),
373                                 key, keylen);
374           if (!rc)
375             rc = gcry_cipher_setkey (hd, key, keylen);
376           xfree (key);
377         }
378     }
379   if (!rc)
380     {
381       p = outbuf;
382       *p++ = '(';
383       *p++ = '(';
384       memcpy (p, protbegin, protlen);
385       p += protlen;
386       memcpy (p, ")(4:hash4:sha120:", 17);
387       p += 17;
388       memcpy (p, sha1hash, 20);
389       p += 20;
390       *p++ = ')';
391       *p++ = ')';
392       memcpy (p, iv+blklen, blklen);
393       p += blklen;
394       assert ( p - outbuf == outlen);
395       rc = gcry_cipher_encrypt (hd, outbuf, enclen, NULL, 0);
396     }
397   gcry_cipher_close (hd);
398   if (rc)
399     {
400       xfree (iv);
401       xfree (outbuf);
402       return rc;
403     }
404
405   /* Now allocate the buffer we want to return.  This is
406
407      (protected openpgp-s2k3-sha1-aes-cbc
408        ((sha1 salt no_of_iterations) 16byte_iv)
409        encrypted_octet_string)
410
411      in canoncical format of course.  We use asprintf and %n modifier
412      and dummy values as placeholders.  */
413   {
414     char countbuf[35];
415
416     snprintf (countbuf, sizeof countbuf, "%lu",
417             s2k_count ? s2k_count : get_standard_s2k_count ());
418     p = xtryasprintf
419       ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
420        (int)strlen (modestr), modestr,
421        &saltpos,
422        (unsigned int)strlen (countbuf), countbuf,
423        blklen, &ivpos, blklen, "",
424        enclen, &encpos, enclen, "");
425     if (!p)
426       {
427         gpg_error_t tmperr = out_of_core ();
428         xfree (iv);
429         xfree (outbuf);
430         return tmperr;
431       }
432   }
433   *resultlen = strlen (p);
434   *result = (unsigned char*)p;
435   memcpy (p+saltpos, iv+2*blklen, 8);
436   memcpy (p+ivpos, iv, blklen);
437   memcpy (p+encpos, outbuf, enclen);
438   xfree (iv);
439   xfree (outbuf);
440   return 0;
441 }
442
443
444
445 /* Protect the key encoded in canonical format in PLAINKEY.  We assume
446    a valid S-Exp here. */
447 int
448 agent_protect (const unsigned char *plainkey, const char *passphrase,
449                unsigned char **result, size_t *resultlen,
450                unsigned long s2k_count)
451 {
452   int rc;
453   const unsigned char *s;
454   const unsigned char *hash_begin, *hash_end;
455   const unsigned char *prot_begin, *prot_end, *real_end;
456   size_t n;
457   int c, infidx, i;
458   unsigned char hashvalue[20];
459   char timestamp_exp[35];
460   unsigned char *protected;
461   size_t protectedlen;
462   int depth = 0;
463   unsigned char *p;
464   gcry_md_hd_t md;
465
466   /* Create an S-expression with the protected-at timestamp.  */
467   memcpy (timestamp_exp, "(12:protected-at15:", 19);
468   gnupg_get_isotime (timestamp_exp+19);
469   timestamp_exp[19+15] = ')';
470
471   /* Parse original key.  */
472   s = plainkey;
473   if (*s != '(')
474     return gpg_error (GPG_ERR_INV_SEXP);
475   depth++;
476   s++;
477   n = snext (&s);
478   if (!n)
479     return gpg_error (GPG_ERR_INV_SEXP);
480   if (!smatch (&s, n, "private-key"))
481     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
482   if (*s != '(')
483     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
484   depth++;
485   hash_begin = s;
486   s++;
487   n = snext (&s);
488   if (!n)
489     return gpg_error (GPG_ERR_INV_SEXP);
490
491   for (infidx=0; protect_info[infidx].algo
492               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
493     ;
494   if (!protect_info[infidx].algo)
495     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
496
497   prot_begin = prot_end = NULL;
498   for (i=0; (c=protect_info[infidx].parmlist[i]); i++)
499     {
500       if (i == protect_info[infidx].prot_from)
501         prot_begin = s;
502       if (*s != '(')
503         return gpg_error (GPG_ERR_INV_SEXP);
504       depth++;
505       s++;
506       n = snext (&s);
507       if (!n)
508         return gpg_error (GPG_ERR_INV_SEXP);
509       if (n != 1 || c != *s)
510         return gpg_error (GPG_ERR_INV_SEXP);
511       s += n;
512       n = snext (&s);
513       if (!n)
514         return gpg_error (GPG_ERR_INV_SEXP);
515       s +=n; /* skip value */
516       if (*s != ')')
517         return gpg_error (GPG_ERR_INV_SEXP);
518       depth--;
519       if (i == protect_info[infidx].prot_to)
520         prot_end = s;
521       s++;
522     }
523   if (*s != ')' || !prot_begin || !prot_end )
524     return gpg_error (GPG_ERR_INV_SEXP);
525   depth--;
526   hash_end = s;
527   s++;
528   /* Skip to the end of the S-expression.  */
529   assert (depth == 1);
530   rc = sskip (&s, &depth);
531   if (rc)
532     return rc;
533   assert (!depth);
534   real_end = s-1;
535
536
537   /* Hash the stuff.  Because the timestamp_exp won't get protected,
538      we can't simply hash a continuous buffer but need to use several
539      md_writes.  */
540   rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
541   if (rc)
542     return rc;
543   gcry_md_write (md, hash_begin, hash_end - hash_begin);
544   gcry_md_write (md, timestamp_exp, 35);
545   gcry_md_write (md, ")", 1);
546   memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
547   gcry_md_close (md);
548
549   rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
550                       passphrase,  hashvalue,
551                       &protected, &protectedlen, s2k_count);
552   if (rc)
553     return rc;
554
555   /* Now create the protected version of the key.  Note that the 10
556      extra bytes are for for the inserted "protected-" string (the
557      beginning of the plaintext reads: "((11:private-key(" ).  The 35
558      term is the space for (12:protected-at15:<timestamp>).  */
559   *resultlen = (10
560                 + (prot_begin-plainkey)
561                 + protectedlen
562                 + 35
563                 + (real_end-prot_end));
564   *result = p = xtrymalloc (*resultlen);
565   if (!p)
566     {
567       gpg_error_t tmperr = out_of_core ();
568       xfree (protected);
569       return tmperr;
570     }
571   memcpy (p, "(21:protected-", 14);
572   p += 14;
573   memcpy (p, plainkey+4, prot_begin - plainkey - 4);
574   p += prot_begin - plainkey - 4;
575   memcpy (p, protected, protectedlen);
576   p += protectedlen;
577
578   memcpy (p, timestamp_exp, 35);
579   p += 35;
580
581   memcpy (p, prot_end+1, real_end - prot_end);
582   p += real_end - prot_end;
583   assert ( p - *result == *resultlen);
584   xfree (protected);
585
586   return 0;
587 }
588
589 \f
590 /* Do the actual decryption and check the return list for consistency.  */
591 static int
592 do_decryption (const unsigned char *protected, size_t protectedlen,
593                const char *passphrase,
594                const unsigned char *s2ksalt, unsigned long s2kcount,
595                const unsigned char *iv, size_t ivlen,
596                unsigned char **result)
597 {
598   int rc = 0;
599   int blklen;
600   gcry_cipher_hd_t hd;
601   unsigned char *outbuf;
602   size_t reallen;
603
604   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
605   if (protectedlen < 4 || (protectedlen%blklen))
606     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
607
608   rc = gcry_cipher_open (&hd, PROT_CIPHER, GCRY_CIPHER_MODE_CBC,
609                          GCRY_CIPHER_SECURE);
610   if (rc)
611     return rc;
612
613   outbuf = gcry_malloc_secure (protectedlen);
614   if (!outbuf)
615     rc = out_of_core ();
616   if (!rc)
617     rc = gcry_cipher_setiv (hd, iv, ivlen);
618   if (!rc)
619     {
620       unsigned char *key;
621       size_t keylen = PROT_CIPHER_KEYLEN;
622
623       key = gcry_malloc_secure (keylen);
624       if (!key)
625         rc = out_of_core ();
626       else
627         {
628           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
629                                 3, s2ksalt, s2kcount, key, keylen);
630           if (!rc)
631             rc = gcry_cipher_setkey (hd, key, keylen);
632           xfree (key);
633         }
634     }
635   if (!rc)
636     rc = gcry_cipher_decrypt (hd, outbuf, protectedlen,
637                               protected, protectedlen);
638   gcry_cipher_close (hd);
639   if (rc)
640     {
641       xfree (outbuf);
642       return rc;
643     }
644   /* Do a quick check first. */
645   if (*outbuf != '(' && outbuf[1] != '(')
646     {
647       xfree (outbuf);
648       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
649     }
650   /* Check that we have a consistent S-Exp. */
651   reallen = gcry_sexp_canon_len (outbuf, protectedlen, NULL, NULL);
652   if (!reallen || (reallen + blklen < protectedlen) )
653     {
654       xfree (outbuf);
655       return gpg_error (GPG_ERR_BAD_PASSPHRASE);
656     }
657   *result = outbuf;
658   return 0;
659 }
660
661
662 /* Merge the parameter list contained in CLEARTEXT with the original
663    protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
664    Return the new list in RESULT and the MIC value in the 20 byte
665    buffer SHA1HASH.  CUTOFF and CUTLEN will receive the offset and the
666    length of the resulting list which should go into the MIC
667    calculation but then be removed.  */
668 static int
669 merge_lists (const unsigned char *protectedkey,
670              size_t replacepos,
671              const unsigned char *cleartext,
672              unsigned char *sha1hash,
673              unsigned char **result, size_t *resultlen,
674              size_t *cutoff, size_t *cutlen)
675 {
676   size_t n, newlistlen;
677   unsigned char *newlist, *p;
678   const unsigned char *s;
679   const unsigned char *startpos, *endpos;
680   int i, rc;
681
682   *result = NULL;
683   *resultlen = 0;
684   *cutoff = 0;
685   *cutlen = 0;
686
687   if (replacepos < 26)
688     return gpg_error (GPG_ERR_BUG);
689
690   /* Estimate the required size of the resulting list.  We have a large
691      safety margin of >20 bytes (MIC hash from CLEARTEXT and the
692      removed "protected-" */
693   newlistlen = gcry_sexp_canon_len (protectedkey, 0, NULL, NULL);
694   if (!newlistlen)
695     return gpg_error (GPG_ERR_BUG);
696   n = gcry_sexp_canon_len (cleartext, 0, NULL, NULL);
697   if (!n)
698     return gpg_error (GPG_ERR_BUG);
699   newlistlen += n;
700   newlist = gcry_malloc_secure (newlistlen);
701   if (!newlist)
702     return out_of_core ();
703
704   /* Copy the initial segment */
705   strcpy ((char*)newlist, "(11:private-key");
706   p = newlist + 15;
707   memcpy (p, protectedkey+15+10, replacepos-15-10);
708   p += replacepos-15-10;
709
710   /* copy the cleartext */
711   s = cleartext;
712   if (*s != '(' && s[1] != '(')
713     return gpg_error (GPG_ERR_BUG);  /*we already checked this */
714   s += 2;
715   startpos = s;
716   while ( *s == '(' )
717     {
718       s++;
719       n = snext (&s);
720       if (!n)
721         goto invalid_sexp;
722       s += n;
723       n = snext (&s);
724       if (!n)
725         goto invalid_sexp;
726       s += n;
727       if ( *s != ')' )
728         goto invalid_sexp;
729       s++;
730     }
731   if ( *s != ')' )
732     goto invalid_sexp;
733   endpos = s;
734   s++;
735   /* Intermezzo: Get the MIC */
736   if (*s != '(')
737     goto invalid_sexp;
738   s++;
739   n = snext (&s);
740   if (!smatch (&s, n, "hash"))
741     goto invalid_sexp;
742   n = snext (&s);
743   if (!smatch (&s, n, "sha1"))
744     goto invalid_sexp;
745   n = snext (&s);
746   if (n != 20)
747     goto invalid_sexp;
748   memcpy (sha1hash, s, 20);
749   s += n;
750   if (*s != ')')
751     goto invalid_sexp;
752   /* End intermezzo */
753
754   /* append the parameter list */
755   memcpy (p, startpos, endpos - startpos);
756   p += endpos - startpos;
757
758   /* Skip over the protected list element in the original list.  */
759   s = protectedkey + replacepos;
760   assert (*s == '(');
761   s++;
762   i = 1;
763   rc = sskip (&s, &i);
764   if (rc)
765     goto failure;
766   /* Record the position of the optional protected-at expression.  */
767   if (*s == '(')
768     {
769       const unsigned char *save_s = s;
770       s++;
771       n = snext (&s);
772       if (smatch (&s, n, "protected-at"))
773         {
774           i = 1;
775           rc = sskip (&s, &i);
776           if (rc)
777             goto failure;
778           *cutlen = s - save_s;
779         }
780       s = save_s;
781     }
782   startpos = s;
783   i = 2; /* we are inside this level */
784   rc = sskip (&s, &i);
785   if (rc)
786     goto failure;
787   assert (s[-1] == ')');
788   endpos = s; /* one behind the end of the list */
789
790   /* Append the rest. */
791   if (*cutlen)
792     *cutoff = p - newlist;
793   memcpy (p, startpos, endpos - startpos);
794   p += endpos - startpos;
795
796
797   /* ready */
798   *result = newlist;
799   *resultlen = newlistlen;
800   return 0;
801
802  failure:
803   wipememory (newlist, newlistlen);
804   xfree (newlist);
805   return rc;
806
807  invalid_sexp:
808   wipememory (newlist, newlistlen);
809   xfree (newlist);
810   return gpg_error (GPG_ERR_INV_SEXP);
811 }
812
813
814
815 /* Unprotect the key encoded in canonical format.  We assume a valid
816    S-Exp here.  If a protected-at item is available, its value will
817    be stored at protocted_at unless this is NULL.  */
818 int
819 agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
820                  gnupg_isotime_t protected_at,
821                  unsigned char **result, size_t *resultlen)
822 {
823   int rc;
824   const unsigned char *s;
825   const unsigned char *protect_list;
826   size_t n;
827   int infidx, i;
828   unsigned char sha1hash[20], sha1hash2[20];
829   const unsigned char *s2ksalt;
830   unsigned long s2kcount;
831   const unsigned char *iv;
832   const unsigned char *prot_begin;
833   unsigned char *cleartext;
834   unsigned char *final;
835   size_t finallen;
836   size_t cutoff, cutlen;
837
838   if (protected_at)
839     *protected_at = 0;
840
841   s = protectedkey;
842   if (*s != '(')
843     return gpg_error (GPG_ERR_INV_SEXP);
844   s++;
845   n = snext (&s);
846   if (!n)
847     return gpg_error (GPG_ERR_INV_SEXP);
848   if (!smatch (&s, n, "protected-private-key"))
849     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
850   if (*s != '(')
851     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
852   s++;
853   n = snext (&s);
854   if (!n)
855     return gpg_error (GPG_ERR_INV_SEXP);
856
857   for (infidx=0; protect_info[infidx].algo
858               && !smatch (&s, n, protect_info[infidx].algo); infidx++)
859     ;
860   if (!protect_info[infidx].algo)
861     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
862
863
864   /* See wether we have a protected-at timestamp.  */
865   protect_list = s;  /* Save for later.  */
866   if (protected_at)
867     {
868       while (*s == '(')
869         {
870           prot_begin = s;
871           s++;
872           n = snext (&s);
873           if (!n)
874             return gpg_error (GPG_ERR_INV_SEXP);
875           if (smatch (&s, n, "protected-at"))
876             {
877               n = snext (&s);
878               if (!n)
879                 return gpg_error (GPG_ERR_INV_SEXP);
880               if (n != 15)
881                 return gpg_error (GPG_ERR_UNKNOWN_SEXP);
882               memcpy (protected_at, s, 15);
883               protected_at[15] = 0;
884               break;
885             }
886           s += n;
887           i = 1;
888           rc = sskip (&s, &i);
889           if (rc)
890             return rc;
891         }
892     }
893
894   /* Now find the list with the protected information.  Here is an
895      example for such a list:
896      (protected openpgp-s2k3-sha1-aes-cbc
897         ((sha1 <salt> <count>) <Initialization_Vector>)
898         <encrypted_data>)
899    */
900   s = protect_list;
901   for (;;)
902     {
903       if (*s != '(')
904         return gpg_error (GPG_ERR_INV_SEXP);
905       prot_begin = s;
906       s++;
907       n = snext (&s);
908       if (!n)
909         return gpg_error (GPG_ERR_INV_SEXP);
910       if (smatch (&s, n, "protected"))
911         break;
912       s += n;
913       i = 1;
914       rc = sskip (&s, &i);
915       if (rc)
916         return rc;
917     }
918   /* found */
919   n = snext (&s);
920   if (!n)
921     return gpg_error (GPG_ERR_INV_SEXP);
922   if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
923     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
924   if (*s != '(' || s[1] != '(')
925     return gpg_error (GPG_ERR_INV_SEXP);
926   s += 2;
927   n = snext (&s);
928   if (!n)
929     return gpg_error (GPG_ERR_INV_SEXP);
930   if (!smatch (&s, n, "sha1"))
931     return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
932   n = snext (&s);
933   if (n != 8)
934     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
935   s2ksalt = s;
936   s += n;
937   n = snext (&s);
938   if (!n)
939     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
940   /* We expect a list close as next, so we can simply use strtoul()
941      here.  We might want to check that we only have digits - but this
942      is nothing we should worry about */
943   if (s[n] != ')' )
944     return gpg_error (GPG_ERR_INV_SEXP);
945
946   /* Old versions of gpg-agent used the funny floating point number in
947      a byte encoding as specified by OpenPGP.  However this is not
948      needed and thus we now store it as a plain unsigned integer.  We
949      can easily distinguish the old format by looking at its value:
950      Less than 256 is an old-style encoded number; other values are
951      plain integers.  In any case we check that they are at least
952      65536 because we never used a lower value in the past and we
953      should have a lower limit.  */
954   s2kcount = strtoul ((const char*)s, NULL, 10);
955   if (!s2kcount)
956     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
957   if (s2kcount < 256)
958     s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
959   if (s2kcount < 65536)
960     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
961
962   s += n;
963   s++; /* skip list end */
964
965   n = snext (&s);
966   if (n != 16) /* Wrong blocksize for IV (we support only aes-128). */
967     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
968   iv = s;
969   s += n;
970   if (*s != ')' )
971     return gpg_error (GPG_ERR_INV_SEXP);
972   s++;
973   n = snext (&s);
974   if (!n)
975     return gpg_error (GPG_ERR_INV_SEXP);
976
977   cleartext = NULL; /* Avoid cc warning. */
978   rc = do_decryption (s, n,
979                       passphrase, s2ksalt, s2kcount,
980                       iv, 16,
981                       &cleartext);
982   if (rc)
983     return rc;
984
985   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
986                     sha1hash, &final, &finallen, &cutoff, &cutlen);
987   /* Albeit cleartext has been allocated in secure memory and thus
988      xfree will wipe it out, we do an extra wipe just in case
989      somethings goes badly wrong. */
990   wipememory (cleartext, n);
991   xfree (cleartext);
992   if (rc)
993     return rc;
994
995   rc = calculate_mic (final, sha1hash2);
996   if (!rc && memcmp (sha1hash, sha1hash2, 20))
997     rc = gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
998   if (rc)
999     {
1000       wipememory (final, finallen);
1001       xfree (final);
1002       return rc;
1003     }
1004   /* Now remove the part which is included in the MIC but should not
1005      go into the final thing.  */
1006   if (cutlen)
1007     {
1008       memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
1009       finallen -= cutlen;
1010     }
1011
1012   *result = final;
1013   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
1014   return 0;
1015 }
1016
1017 /* Check the type of the private key, this is one of the constants:
1018    PRIVATE_KEY_UNKNOWN if we can't figure out the type (this is the
1019    value 0), PRIVATE_KEY_CLEAR for an unprotected private key.
1020    PRIVATE_KEY_PROTECTED for an protected private key or
1021    PRIVATE_KEY_SHADOWED for a sub key where the secret parts are stored
1022    elsewhere. */
1023 int
1024 agent_private_key_type (const unsigned char *privatekey)
1025 {
1026   const unsigned char *s;
1027   size_t n;
1028
1029   s = privatekey;
1030   if (*s != '(')
1031     return PRIVATE_KEY_UNKNOWN;
1032   s++;
1033   n = snext (&s);
1034   if (!n)
1035     return PRIVATE_KEY_UNKNOWN;
1036   if (smatch (&s, n, "protected-private-key"))
1037     return PRIVATE_KEY_PROTECTED;
1038   if (smatch (&s, n, "shadowed-private-key"))
1039     return PRIVATE_KEY_SHADOWED;
1040   if (smatch (&s, n, "private-key"))
1041     return PRIVATE_KEY_CLEAR;
1042   return PRIVATE_KEY_UNKNOWN;
1043 }
1044
1045
1046 \f
1047 /* Transform a passphrase into a suitable key of length KEYLEN and
1048    store this key in the caller provided buffer KEY.  The caller must
1049    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
1050    that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
1051
1052    Returns an error code on failure.  */
1053 static int
1054 hash_passphrase (const char *passphrase, int hashalgo,
1055                  int s2kmode,
1056                  const unsigned char *s2ksalt,
1057                  unsigned long s2kcount,
1058                  unsigned char *key, size_t keylen)
1059 {
1060
1061   return gcry_kdf_derive (passphrase, strlen (passphrase),
1062                           s2kmode == 3? GCRY_KDF_ITERSALTED_S2K :
1063                           s2kmode == 1? GCRY_KDF_SALTED_S2K :
1064                           s2kmode == 0? GCRY_KDF_SIMPLE_S2K : GCRY_KDF_NONE,
1065                           hashalgo, s2ksalt, 8, s2kcount,
1066                           keylen, key);
1067 }
1068
1069
1070 gpg_error_t
1071 s2k_hash_passphrase (const char *passphrase, int hashalgo,
1072                      int s2kmode,
1073                      const unsigned char *s2ksalt,
1074                      unsigned int s2kcount,
1075                      unsigned char *key, size_t keylen)
1076 {
1077   return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt,
1078                           S2K_DECODE_COUNT (s2kcount),
1079                           key, keylen);
1080 }
1081
1082
1083 \f
1084
1085 /* Create an canonical encoded S-expression with the shadow info from
1086    a card's SERIALNO and the IDSTRING.  */
1087 unsigned char *
1088 make_shadow_info (const char *serialno, const char *idstring)
1089 {
1090   const char *s;
1091   char *info, *p;
1092   char numbuf[20];
1093   size_t n;
1094
1095   for (s=serialno, n=0; *s && s[1]; s += 2)
1096     n++;
1097
1098   info = p = xtrymalloc (1 + sizeof numbuf + n
1099                            + sizeof numbuf + strlen (idstring) + 1 + 1);
1100   if (!info)
1101     return NULL;
1102   *p++ = '(';
1103   p = stpcpy (p, smklen (numbuf, sizeof numbuf, n, NULL));
1104   for (s=serialno; *s && s[1]; s += 2)
1105     *(unsigned char *)p++ = xtoi_2 (s);
1106   p = stpcpy (p, smklen (numbuf, sizeof numbuf, strlen (idstring), NULL));
1107   p = stpcpy (p, idstring);
1108   *p++ = ')';
1109   *p = 0;
1110   return (unsigned char *)info;
1111 }
1112
1113
1114
1115 /* Create a shadow key from a public key.  We use the shadow protocol
1116   "ti-v1" and insert the S-expressionn SHADOW_INFO.  The resulting
1117   S-expression is returned in an allocated buffer RESULT will point
1118   to. The input parameters are expected to be valid canonicalized
1119   S-expressions */
1120 int
1121 agent_shadow_key (const unsigned char *pubkey,
1122                   const unsigned char *shadow_info,
1123                   unsigned char **result)
1124 {
1125   const unsigned char *s;
1126   const unsigned char *point;
1127   size_t n;
1128   int depth = 0;
1129   char *p;
1130   size_t pubkey_len = gcry_sexp_canon_len (pubkey, 0, NULL,NULL);
1131   size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
1132
1133   if (!pubkey_len || !shadow_info_len)
1134     return gpg_error (GPG_ERR_INV_VALUE);
1135   s = pubkey;
1136   if (*s != '(')
1137     return gpg_error (GPG_ERR_INV_SEXP);
1138   depth++;
1139   s++;
1140   n = snext (&s);
1141   if (!n)
1142     return gpg_error (GPG_ERR_INV_SEXP);
1143   if (!smatch (&s, n, "public-key"))
1144     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1145   if (*s != '(')
1146     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1147   depth++;
1148   s++;
1149   n = snext (&s);
1150   if (!n)
1151     return gpg_error (GPG_ERR_INV_SEXP);
1152   s += n; /* skip over the algorithm name */
1153
1154   while (*s != ')')
1155     {
1156       if (*s != '(')
1157         return gpg_error (GPG_ERR_INV_SEXP);
1158       depth++;
1159       s++;
1160       n = snext (&s);
1161       if (!n)
1162         return gpg_error (GPG_ERR_INV_SEXP);
1163       s += n;
1164       n = snext (&s);
1165       if (!n)
1166         return gpg_error (GPG_ERR_INV_SEXP);
1167       s +=n; /* skip value */
1168       if (*s != ')')
1169         return gpg_error (GPG_ERR_INV_SEXP);
1170       depth--;
1171       s++;
1172     }
1173   point = s; /* insert right before the point */
1174   depth--;
1175   s++;
1176   assert (depth == 1);
1177
1178   /* Calculate required length by taking in account: the "shadowed-"
1179      prefix, the "shadowed", "t1-v1" as well as some parenthesis */
1180   n = 12 + pubkey_len + 1 + 3+8 + 2+5 + shadow_info_len + 1;
1181   *result = xtrymalloc (n);
1182   p = (char*)*result;
1183   if (!p)
1184       return out_of_core ();
1185   p = stpcpy (p, "(20:shadowed-private-key");
1186   /* (10:public-key ...)*/
1187   memcpy (p, pubkey+14, point - (pubkey+14));
1188   p += point - (pubkey+14);
1189   p = stpcpy (p, "(8:shadowed5:t1-v1");
1190   memcpy (p, shadow_info, shadow_info_len);
1191   p += shadow_info_len;
1192   *p++ = ')';
1193   memcpy (p, point, pubkey_len - (point - pubkey));
1194   p += pubkey_len - (point - pubkey);
1195
1196   return 0;
1197 }
1198
1199 /* Parse a canonical encoded shadowed key and return a pointer to the
1200    inner list with the shadow_info */
1201 int
1202 agent_get_shadow_info (const unsigned char *shadowkey,
1203                        unsigned char const **shadow_info)
1204 {
1205   const unsigned char *s;
1206   size_t n;
1207   int depth = 0;
1208
1209   s = shadowkey;
1210   if (*s != '(')
1211     return gpg_error (GPG_ERR_INV_SEXP);
1212   depth++;
1213   s++;
1214   n = snext (&s);
1215   if (!n)
1216     return gpg_error (GPG_ERR_INV_SEXP);
1217   if (!smatch (&s, n, "shadowed-private-key"))
1218     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1219   if (*s != '(')
1220     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1221   depth++;
1222   s++;
1223   n = snext (&s);
1224   if (!n)
1225     return gpg_error (GPG_ERR_INV_SEXP);
1226   s += n; /* skip over the algorithm name */
1227
1228   for (;;)
1229     {
1230       if (*s == ')')
1231         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
1232       if (*s != '(')
1233         return gpg_error (GPG_ERR_INV_SEXP);
1234       depth++;
1235       s++;
1236       n = snext (&s);
1237       if (!n)
1238         return gpg_error (GPG_ERR_INV_SEXP);
1239       if (smatch (&s, n, "shadowed"))
1240         break;
1241       s += n;
1242       n = snext (&s);
1243       if (!n)
1244         return gpg_error (GPG_ERR_INV_SEXP);
1245       s +=n; /* skip value */
1246       if (*s != ')')
1247         return gpg_error (GPG_ERR_INV_SEXP);
1248       depth--;
1249       s++;
1250     }
1251   /* Found the shadowed list, S points to the protocol */
1252   n = snext (&s);
1253   if (!n)
1254     return gpg_error (GPG_ERR_INV_SEXP);
1255   if (smatch (&s, n, "t1-v1"))
1256     {
1257       if (*s != '(')
1258         return gpg_error (GPG_ERR_INV_SEXP);
1259       *shadow_info = s;
1260     }
1261   else
1262     return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
1263   return 0;
1264 }
1265
1266
1267 /* Parse the canonical encoded SHADOW_INFO S-expression.  On success
1268    the hex encoded serial number is returned as a malloced strings at
1269    R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
1270    error an error code is returned and NULL is stored at the result
1271    parameters addresses.  If the serial number or the ID string is not
1272    required, NULL may be passed for them.  */
1273 gpg_error_t
1274 parse_shadow_info (const unsigned char *shadow_info,
1275                    char **r_hexsn, char **r_idstr)
1276 {
1277   const unsigned char *s;
1278   size_t n;
1279
1280   if (r_hexsn)
1281     *r_hexsn = NULL;
1282   if (r_idstr)
1283     *r_idstr = NULL;
1284
1285   s = shadow_info;
1286   if (*s != '(')
1287     return gpg_error (GPG_ERR_INV_SEXP);
1288   s++;
1289   n = snext (&s);
1290   if (!n)
1291     return gpg_error (GPG_ERR_INV_SEXP);
1292
1293   if (r_hexsn)
1294     {
1295       *r_hexsn = bin2hex (s, n, NULL);
1296       if (!*r_hexsn)
1297         return gpg_error_from_syserror ();
1298     }
1299   s += n;
1300
1301   n = snext (&s);
1302   if (!n)
1303     {
1304       if (r_hexsn)
1305         {
1306           xfree (*r_hexsn);
1307           *r_hexsn = NULL;
1308         }
1309       return gpg_error (GPG_ERR_INV_SEXP);
1310     }
1311
1312   if (r_idstr)
1313     {
1314       *r_idstr = xtrymalloc (n+1);
1315       if (!*r_idstr)
1316         {
1317           if (r_hexsn)
1318             {
1319               xfree (*r_hexsn);
1320               *r_hexsn = NULL;
1321             }
1322           return gpg_error_from_syserror ();
1323         }
1324       memcpy (*r_idstr, s, n);
1325       (*r_idstr)[n] = 0;
1326     }
1327
1328   return 0;
1329 }