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