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