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