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