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