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