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