po: Update Japanese Translation.
[gnupg.git] / scd / app-piv.c
1 /* app-piv.c - The OpenPGP card application.
2  * Copyright (C) 2019 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 /* Some notes:
21  * - Specs for PIV are at http://dx.doi.org/10.6028/NIST.SP.800-73-4
22  *
23  * - Access control matrix:
24  *   | Action       | 9B  | PIN | PUK |                              |
25  *   |--------------+-----+-----+-----+------------------------------|
26  *   | Generate key | yes |     |     |                              |
27  *   | Change 9B    | yes |     |     |                              |
28  *   | Change retry | yes | yes |     | Yubikey only                 |
29  *   | Import key   | yes |     |     |                              |
30  *   | Import cert  | yes |     |     |                              |
31  *   | Change CHUID | yes |     |     |                              |
32  *   | Reset card   |     |     |     | PIN and PUK in blocked state |
33  *   | Verify PIN   |     | yes |     |                              |
34  *   | Sign data    |     | yes |     |                              |
35  *   | Decrypt data |     | yes |     |                              |
36  *   | Change PIN   |     | yes |     |                              |
37  *   | Change PUK   |     |     | yes |                              |
38  *   | Unblock PIN  |     |     | yes | New PIN required             |
39  *   |---------------------------------------------------------------|
40  *   (9B indicates the 24 byte PIV Card Application Administration Key)
41  *
42  * - When generating a key we store the created public key in the
43  *   corresponding data object, so that gpg and gpgsm are able to get
44  *   the public key, create a certificate and store that then in that
45  *   data object.  That is not standard compliant but due to the use
46  *   of other tags, it should not harm.  See do_genkey for the actual
47  *   used tag structure.
48  */
49
50 #include <config.h>
51 #include <errno.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <stdarg.h>
55 #include <string.h>
56 #include <time.h>
57
58 #include "scdaemon.h"
59
60 #include "../common/util.h"
61 #include "../common/i18n.h"
62 #include "iso7816.h"
63 #include "app-common.h"
64 #include "../common/tlv.h"
65 #include "../common/host2net.h"
66 #include "apdu.h" /* We use apdu_send_direct.  */
67
68 #define PIV_ALGORITHM_3DES_ECB_0 0x00
69 #define PIV_ALGORITHM_2DES_ECB   0x01
70 #define PIV_ALGORITHM_2DES_CBC   0x02
71 #define PIV_ALGORITHM_3DES_ECB   0x03
72 #define PIV_ALGORITHM_3DES_CBC   0x04
73 #define PIV_ALGORITHM_RSA        0x07
74 #define PIV_ALGORITHM_AES128_ECB 0x08
75 #define PIV_ALGORITHM_AES128_CBC 0x09
76 #define PIV_ALGORITHM_AES192_ECB 0x0A
77 #define PIV_ALGORITHM_AES192_CBC 0x0B
78 #define PIV_ALGORITHM_AES256_ECB 0x0C
79 #define PIV_ALGORITHM_AES256_CBC 0x0D
80 #define PIV_ALGORITHM_ECC_P256   0x11
81 #define PIV_ALGORITHM_ECC_P384   0x14
82
83
84
85 /* A table describing the DOs of a PIV card.  */
86 struct data_object_s
87 {
88   unsigned int tag;
89   unsigned int mandatory:1;
90   unsigned int acr_contact:2;     /* 0=always, 1=VCI, 2=PIN, 3=PINorOCC */
91   unsigned int acr_contactless:2; /* 0=always, 1=VCI, 2=VCIandPIN,
92                                                       3=VCIand(PINorOCC) */
93   unsigned int dont_cache:1;      /* Data item will not be cached.  */
94   unsigned int flush_on_error:1;  /* Flush cached item on error.  */
95   unsigned int keypair:1;         /* Has a public key for a keypair.  */
96   const char keyref[3];           /* The key reference.  */
97   const char *oidsuffix;          /* Suffix of the OID. */
98   const char *usage;              /* Usage string for a keypair or NULL.  */
99   const char *desc;               /* Description of the DO.  */
100 };
101 typedef struct data_object_s *data_object_t;
102 static struct data_object_s data_objects[] = {
103   { 0x5FC107, 1, 0,1, 0,0, 0, "",   "1.219.0", NULL,
104     "Card Capability Container"},
105   { 0x5FC102, 1, 0,0, 0,0, 0, "",   "2.48.0",  NULL,
106     "Cardholder Unique Id" },
107   { 0x5FC105, 1, 0,1, 0,0, 1, "9A", "2.1.1",   "a",
108     "Cert PIV Authentication" },
109   { 0x5FC103, 1, 2,2, 0,0, 0, "",   "2.96.16", NULL,
110     "Cardholder Fingerprints" },
111   { 0x5FC106, 1, 0,1, 0,0, 0, "",   "2.144.0", NULL,
112     "Security Object" },
113   { 0x5FC108, 1, 2,2, 0,0, 0, "",   "2.96.48", NULL,
114     "Cardholder Facial Image" },
115   { 0x5FC101, 1, 0,0, 0,0, 1, "9E", "2.5.0",   "a",
116     "Cert Card Authentication"},
117   { 0x5FC10A, 0, 0,1, 0,0, 1, "9C", "2.1.0",   "sc",
118     "Cert Digital Signature" },
119   { 0x5FC10B, 0, 0,1, 0,0, 1, "9D", "2.1.2",   "e",
120     "Cert Key Management" },
121   { 0x5FC109, 0, 3,3, 0,0, 0, "",   "2.48.1",  NULL,
122     "Printed Information" },
123   { 0x7E,     0, 0,0, 0,0, 0, "",   "2.96.80", NULL,
124     "Discovery Object" },
125   { 0x5FC10C, 0, 0,1, 0,0, 0, "",   "2.96.96", NULL,
126     "Key History Object" },
127   { 0x5FC10D, 0, 0,1, 0,0, 0, "82", "2.16.1",  "e",
128     "Retired Cert Key Mgm 1" },
129   { 0x5FC10E, 0, 0,1, 0,0, 0, "83", "2.16.2",  "e",
130     "Retired Cert Key Mgm 2" },
131   { 0x5FC10F, 0, 0,1, 0,0, 0, "84", "2.16.3",  "e",
132     "Retired Cert Key Mgm 3" },
133   { 0x5FC110, 0, 0,1, 0,0, 0, "85", "2.16.4",  "e",
134     "Retired Cert Key Mgm 4" },
135   { 0x5FC111, 0, 0,1, 0,0, 0, "86", "2.16.5",  "e",
136     "Retired Cert Key Mgm 5" },
137   { 0x5FC112, 0, 0,1, 0,0, 0, "87", "2.16.6",  "e",
138     "Retired Cert Key Mgm 6" },
139   { 0x5FC113, 0, 0,1, 0,0, 0, "88", "2.16.7",  "e",
140     "Retired Cert Key Mgm 7" },
141   { 0x5FC114, 0, 0,1, 0,0, 0, "89", "2.16.8",  "e",
142     "Retired Cert Key Mgm 8" },
143   { 0x5FC115, 0, 0,1, 0,0, 0, "8A", "2.16.9",  "e",
144     "Retired Cert Key Mgm 9" },
145   { 0x5FC116, 0, 0,1, 0,0, 0, "8B", "2.16.10", "e",
146     "Retired Cert Key Mgm 10" },
147   { 0x5FC117, 0, 0,1, 0,0, 0, "8C", "2.16.11", "e",
148     "Retired Cert Key Mgm 11" },
149   { 0x5FC118, 0, 0,1, 0,0, 0, "8D", "2.16.12", "e",
150     "Retired Cert Key Mgm 12" },
151   { 0x5FC119, 0, 0,1, 0,0, 0, "8E", "2.16.13", "e",
152     "Retired Cert Key Mgm 13" },
153   { 0x5FC11A, 0, 0,1, 0,0, 0, "8F", "2.16.14", "e",
154     "Retired Cert Key Mgm 14" },
155   { 0x5FC11B, 0, 0,1, 0,0, 0, "90", "2.16.15", "e",
156     "Retired Cert Key Mgm 15" },
157   { 0x5FC11C, 0, 0,1, 0,0, 0, "91", "2.16.16", "e",
158     "Retired Cert Key Mgm 16" },
159   { 0x5FC11D, 0, 0,1, 0,0, 0, "92", "2.16.17", "e",
160     "Retired Cert Key Mgm 17" },
161   { 0x5FC11E, 0, 0,1, 0,0, 0, "93", "2.16.18", "e",
162     "Retired Cert Key Mgm 18" },
163   { 0x5FC11F, 0, 0,1, 0,0, 0, "94", "2.16.19", "e",
164     "Retired Cert Key Mgm 19" },
165   { 0x5FC120, 0, 0,1, 0,0, 0, "95", "2.16.20", "e",
166     "Retired Cert Key Mgm 20" },
167   { 0x5FC121, 0, 2,2, 0,0, 0, "",   "2.16.21", NULL,
168     "Cardholder Iris Images" },
169   { 0x7F61,   0, 0,0, 0,0, 0, "",   "2.16.22", NULL,
170     "BIT Group Template" },
171   { 0x5FC122, 0, 0,0, 0,0, 0, "",   "2.16.23", NULL,
172     "SM Cert Signer" },
173   { 0x5FC123, 0, 3,3, 0,0, 0, "",   "2.16.24", NULL,
174     "Pairing Code Ref Data" },
175   { 0 }
176   /* Other key reference values without a data object:
177    * "00" Global PIN (not cleared by application switching)
178    * "04" PIV Secure Messaging Key
179    * "80" PIV Application PIN
180    * "81" PIN Unblocking Key
181    * "96" Primary Finger OCC
182    * "97" Secondary Finger OCC
183    * "98" Pairing Code
184    * "9B" PIV Card Application Administration Key
185    *
186    * Yubikey specific data objects:
187    * "F9" Attestation key (preloaded can be replaced)
188    */
189 };
190
191
192 /* One cache item for DOs.  */
193 struct cache_s {
194   struct cache_s *next;
195   int tag;
196   size_t length;
197   unsigned char data[1];
198 };
199
200
201 /* Object with application specific data.  */
202 struct app_local_s {
203   /* A linked list with cached DOs.  */
204   struct cache_s *cache;
205
206   /* Various flags.  */
207   struct
208   {
209     unsigned int yubikey:1;  /* This is on a Yubikey.  */
210   } flags;
211
212 };
213
214
215 /***** Local prototypes  *****/
216 static gpg_error_t get_keygrip_by_tag (app_t app, unsigned int tag,
217                                        char **r_keygripstr, int *got_cert);
218 static gpg_error_t genkey_parse_rsa (const unsigned char *data, size_t datalen,
219                                      gcry_sexp_t *r_sexp);
220 static gpg_error_t genkey_parse_ecc (const unsigned char *data, size_t datalen,
221                                      int mechanism, gcry_sexp_t *r_sexp);
222
223
224
225
226 \f
227 /* Deconstructor. */
228 static void
229 do_deinit (app_t app)
230 {
231   if (app && app->app_local)
232     {
233       struct cache_s *c, *c2;
234
235       for (c = app->app_local->cache; c; c = c2)
236         {
237           c2 = c->next;
238           xfree (c);
239         }
240
241       xfree (app->app_local);
242       app->app_local = NULL;
243     }
244 }
245
246
247 /* Wrapper around iso7816_get_data which first tries to get the data
248  * from the cache.  With GET_IMMEDIATE passed as true, the cache is
249  * bypassed.  The tag-53 container is also removed.  */
250 static gpg_error_t
251 get_cached_data (app_t app, int tag,
252                  unsigned char **result, size_t *resultlen,
253                  int get_immediate)
254 {
255   gpg_error_t err;
256   int i;
257   unsigned char *p;
258   const unsigned char *s;
259   size_t len, n;
260   struct cache_s *c;
261
262   *result = NULL;
263   *resultlen = 0;
264
265   if (!get_immediate)
266     {
267       for (c=app->app_local->cache; c; c = c->next)
268         if (c->tag == tag)
269           {
270             if(c->length)
271               {
272                 p = xtrymalloc (c->length);
273                 if (!p)
274                   return gpg_error_from_syserror ();
275                 memcpy (p, c->data, c->length);
276                 *result = p;
277               }
278
279             *resultlen = c->length;
280
281             return 0;
282           }
283     }
284
285   err = iso7816_get_data_odd (app->slot, 0, tag, &p, &len);
286   if (err)
287     return err;
288
289   /* Unless the Discovery Object or the BIT Group Template is
290    * requested, remove the outer container.
291    * (SP800-73.4 Part 2, section 3.1.2)   */
292   if (tag == 0x7E || tag == 0x7F61)
293     ;
294   else if (len && *p == 0x53 && (s = find_tlv (p, len, 0x53, &n)))
295     {
296       memmove (p, s, n);
297       len = n;
298     }
299
300   if (len)
301     *result = p;
302   *resultlen = len;
303
304   /* Check whether we should cache this object. */
305   if (get_immediate)
306     return 0;
307
308   for (i=0; data_objects[i].tag; i++)
309     if (data_objects[i].tag == tag)
310       {
311         if (data_objects[i].dont_cache)
312           return 0;
313         break;
314       }
315
316   /* Okay, cache it. */
317   for (c=app->app_local->cache; c; c = c->next)
318     log_assert (c->tag != tag);
319
320   c = xtrymalloc (sizeof *c + len);
321   if (c)
322     {
323       if (len)
324         memcpy (c->data, p, len);
325       else
326         xfree (p);
327       c->length = len;
328       c->tag = tag;
329       c->next = app->app_local->cache;
330       app->app_local->cache = c;
331     }
332
333   return 0;
334 }
335
336
337 /* Remove data object described by TAG from the cache.  If TAG is 0
338  * all cache iterms are flushed.  */
339 static void
340 flush_cached_data (app_t app, int tag)
341 {
342   struct cache_s *c, *cprev;
343
344   for (c=app->app_local->cache, cprev=NULL; c; cprev=c, c = c->next)
345     if (c->tag == tag || !tag)
346       {
347         if (cprev)
348           cprev->next = c->next;
349         else
350           app->app_local->cache = c->next;
351         xfree (c);
352
353         for (c=app->app_local->cache; c ; c = c->next)
354           {
355             log_assert (c->tag != tag); /* Oops: duplicated entry. */
356           }
357         return;
358       }
359 }
360
361
362 /* Get the DO identified by TAG from the card in SLOT and return a
363  * buffer with its content in RESULT and NBYTES.  The return value is
364  * NULL if not found or a pointer which must be used to release the
365  * buffer holding value.  */
366 static void *
367 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
368             int *r_err)
369 {
370   gpg_error_t err;
371   int i;
372   unsigned char *buffer;
373   size_t buflen;
374   unsigned char *value;
375   size_t valuelen;
376   gpg_error_t dummyerr;
377
378   if (!r_err)
379     r_err = &dummyerr;
380
381   *result = NULL;
382   *nbytes = 0;
383   *r_err = 0;
384   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
385     ;
386
387   value = NULL;
388   err = gpg_error (GPG_ERR_ENOENT);
389
390   if (!value) /* Not in a constructed DO, try simple. */
391     {
392       err = get_cached_data (app, tag, &buffer, &buflen,
393                              data_objects[i].dont_cache);
394       if (!err)
395         {
396           value = buffer;
397           valuelen = buflen;
398         }
399     }
400
401   if (!err)
402     {
403       *nbytes = valuelen;
404       *result = value;
405       return buffer;
406     }
407
408   *r_err = err;
409   return NULL;
410 }
411
412
413 static void
414 dump_all_do (int slot)
415 {
416   gpg_error_t err;
417   int i;
418   unsigned char *buffer;
419   size_t buflen;
420
421   for (i=0; data_objects[i].tag; i++)
422     {
423       /* We don't try extended length APDU because such large DO would
424          be pretty useless in a log file.  */
425       err = iso7816_get_data_odd (slot, 0, data_objects[i].tag,
426                                  &buffer, &buflen);
427       if (err)
428         {
429           if (gpg_err_code (err) == GPG_ERR_ENOENT
430               && !data_objects[i].mandatory)
431             ;
432           else
433             log_info ("DO '%s' not available: %s\n",
434                       data_objects[i].desc, gpg_strerror (err));
435         }
436       else
437         {
438           if (data_objects[i].tag == 0x5FC109)
439             log_info ("DO '%s': '%.*s'\n", data_objects[i].desc,
440                       (int)buflen, buffer);
441           else
442             {
443               log_info ("DO '%s': ", data_objects[i].desc);
444               if (buflen > 16 && opt.verbose < 2)
445                 {
446                   log_printhex (buffer, 16, NULL);
447                   log_printf ("[...]\n");
448                 }
449               else
450                 log_printhex (buffer, buflen, "");
451             }
452
453         }
454       xfree (buffer); buffer = NULL;
455     }
456 }
457
458
459 /* Create a TLV tag and value and store it at BUFFER.  Return the
460  * length of tag and length.  A LENGTH greater than 65535 is
461  * truncated.  TAG must be less or equal to 2^16.  If BUFFER is NULL,
462  * only the required length is computed.  */
463 static size_t
464 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
465 {
466   if (length > 0xffff)
467     length = 0xffff;
468
469   if (buffer)
470     {
471       unsigned char *p = buffer;
472
473       if (tag > 0xff)
474         *p++ = tag >> 8;
475       *p++ = tag;
476       if (length < 128)
477         *p++ = length;
478       else if (length < 256)
479         {
480           *p++ = 0x81;
481           *p++ = length;
482         }
483       else
484         {
485           *p++ = 0x82;
486           *p++ = length >> 8;
487           *p++ = length;
488         }
489
490       return p - buffer;
491     }
492   else
493     {
494       size_t n = 0;
495
496       if (tag > 0xff)
497         n++;
498       n++;
499       if (length < 128)
500         n++;
501       else if (length < 256)
502         n += 2;
503       else
504         n += 3;
505       return n;
506     }
507 }
508
509
510 /* Function to build a list of TLV and return the result in a mallcoed
511  * buffer.  The varargs are tuples of (int,size_t,void) each with the
512  * tag, the length and the actual data.  A (0,0,NULL) tuple terminates
513  * the list.  Up to 10 tuples are supported.  If SECMEM is true the
514  * returned buffer is allocated in secure memory.  */
515 static gpg_error_t
516 concat_tlv_list (int secure, unsigned char **r_result, size_t *r_resultlen, ...)
517 {
518   gpg_error_t err;
519   va_list arg_ptr;
520   struct {
521     int tag;
522     unsigned int len;
523     unsigned int contlen;
524     const void *data;
525   } argv[10];
526   int i, j, argc;
527   unsigned char *data = NULL;
528   size_t datalen;
529   unsigned char *p;
530   size_t n;
531
532   *r_result = NULL;
533   *r_resultlen = 0;
534
535   /* Collect all args.  Check that length is <= 2^16 to match the
536    * behaviour of add_tlv.  */
537   va_start (arg_ptr, r_resultlen);
538   argc = 0;
539   while (((argv[argc].tag = va_arg (arg_ptr, int))))
540     {
541       argv[argc].len = va_arg (arg_ptr, size_t);
542       argv[argc].contlen = 0;
543       argv[argc].data = va_arg (arg_ptr, const void *);
544       if (argc >= DIM (argv)-1 || argv[argc].len > 0xffff)
545         {
546           va_end (arg_ptr);
547           err = gpg_error (GPG_ERR_EINVAL);
548           goto leave;
549         }
550       argc++;
551     }
552   va_end (arg_ptr);
553
554   /* Compute the required buffer length and allocate the buffer.  */
555   datalen = 0;
556   for (i=0; i < argc; i++)
557     {
558       if (!argv[i].len && !argv[i].data)
559         {
560           /* Constructed tag.  Compute its length.  Note that we
561            * currently allow only one constructed tag in the list.  */
562           for (n=0, j = i + 1; j < argc; j++)
563             {
564               log_assert (!(!argv[j].len && !argv[j].data));
565               n += add_tlv (NULL, argv[j].tag, argv[j].len);
566               n += argv[j].len;
567             }
568           argv[i].contlen = n;
569           datalen += add_tlv (NULL, argv[i].tag, n);
570         }
571       else
572         {
573           datalen += add_tlv (NULL, argv[i].tag, argv[i].len);
574           datalen += argv[i].len;
575         }
576     }
577   data = secure? xtrymalloc_secure (datalen) : xtrymalloc (datalen);
578   if (!data)
579     {
580       err = gpg_error_from_syserror ();
581       goto leave;
582     }
583
584   /* Copy that data to the buffer.  */
585   p = data;
586   for (i=0; i < argc; i++)
587     {
588       if (!argv[i].len && !argv[i].data)
589         {
590           /* Constructed tag.  */
591           p += add_tlv (p, argv[i].tag, argv[i].contlen);
592         }
593       else
594         {
595           p += add_tlv (p, argv[i].tag, argv[i].len);
596           memcpy (p, argv[i].data, argv[i].len);
597           p += argv[i].len;
598         }
599     }
600   log_assert ( data + datalen == p );
601   *r_result = data;
602   data = NULL;
603   *r_resultlen = datalen;
604   err = 0;
605
606  leave:
607   xfree (data);
608   return err;
609 }
610
611
612 /* Wrapper around iso7816_put_data_odd which also sets the tag into
613  * the '5C' data object.  The varargs are tuples of (int,size_t,void)
614  * with the tag, the length and the actual data.  A (0,0,NULL) tuple
615  * terminates the list.  Up to 10 tuples are supported.  */
616 static gpg_error_t
617 put_data (int slot, unsigned int tag, ...)
618 {
619   gpg_error_t err;
620   va_list arg_ptr;
621   struct {
622     int tag;
623     size_t len;
624     const void *data;
625   } argv[10];
626   int i, argc;
627   unsigned char data5c[5];
628   size_t data5clen;
629   unsigned char *data = NULL;
630   size_t datalen;
631   unsigned char *p;
632   size_t n;
633
634   /* Collect all args.  Check that length is <= 2^16 to match the
635    * behaviour of add_tlv.  */
636   va_start (arg_ptr, tag);
637   argc = 0;
638   while (((argv[argc].tag = va_arg (arg_ptr, int))))
639     {
640       argv[argc].len = va_arg (arg_ptr, size_t);
641       argv[argc].data = va_arg (arg_ptr, const void *);
642       if (argc >= DIM (argv)-1 || argv[argc].len > 0xffff)
643         {
644           va_end (arg_ptr);
645           return GPG_ERR_EINVAL;
646         }
647       argc++;
648     }
649   va_end (arg_ptr);
650
651   /* Build the TLV with the tag to be updated.  */
652   data5c[0] = 0x5c; /* Tag list */
653   if (tag <= 0xff)
654     {
655       data5c[1] = 1;
656       data5c[2] = tag;
657       data5clen = 3;
658     }
659   else if (tag <= 0xffff)
660     {
661       data5c[1] = 2;
662       data5c[2] = (tag >> 8);
663       data5c[3] = tag;
664       data5clen = 4;
665     }
666   else
667     {
668       data5c[1] = 3;
669       data5c[2] = (tag >> 16);
670       data5c[3] = (tag >> 8);
671       data5c[4] = tag;
672       data5clen = 5;
673     }
674
675   /* Compute the required buffer length and allocate the buffer.  */
676   n = 0;
677   for (i=0; i < argc; i++)
678     {
679       n += add_tlv (NULL, argv[i].tag, argv[i].len);
680       n += argv[i].len;
681     }
682   datalen = data5clen + add_tlv (NULL, 0x53, n) + n;
683   data = xtrymalloc (datalen);
684   if (!data)
685     {
686       err = gpg_error_from_syserror ();
687       goto leave;
688     }
689
690   /* Copy that data to the buffer.  */
691   p = data;
692   memcpy (p, data5c, data5clen);
693   p += data5clen;
694   p += add_tlv (p, 0x53, n);
695   for (i=0; i < argc; i++)
696     {
697       p += add_tlv (p, argv[i].tag, argv[i].len);
698       memcpy (p, argv[i].data, argv[i].len);
699       p += argv[i].len;
700     }
701   log_assert ( data + datalen == p );
702   err = iso7816_put_data_odd (slot, -1 /* use command chaining */,
703                               0x3fff, data, datalen);
704
705  leave:
706   xfree (data);
707   return err;
708 }
709
710
711 /* Parse the key reference KEYREFSTR which is expected to hold a key
712  * reference for a CHV object.  Return the one octet keyref or -1 for
713  * an invalid reference.  */
714 static int
715 parse_chv_keyref (const char *keyrefstr)
716 {
717   if (!keyrefstr)
718     return -1;
719   else if (!ascii_strcasecmp (keyrefstr, "PIV.00"))
720     return 0x00;
721   else if (!ascii_strcasecmp (keyrefstr, "PIV.80"))
722     return 0x80;
723   else if (!ascii_strcasecmp (keyrefstr, "PIV.81"))
724     return 0x81;
725   else
726     return -1;
727 }
728
729
730 /* Return an allocated string with the serial number in a format to be
731  * show to the user.  With FAILMODE is true return NULL if such an
732  * abbreviated S/N is not available, else return the full serial
733  * number as a hex string.  May return NULL on malloc problem.  */
734 static char *
735 get_dispserialno (app_t app, int failmode)
736 {
737   char *result;
738
739   if (app->serialno && app->serialnolen == 3+1+4
740       && !memcmp (app->serialno, "\xff\x02\x00", 3))
741     {
742       /* This is a 4 byte S/N of a Yubikey which seems to be printed
743        * on the token in decimal.  Maybe they will print larger S/N
744        * also in decimal but we can't be sure, thus do it only for
745        * these 32 bit numbers.  */
746       unsigned long sn;
747       sn  = app->serialno[4] * 16777216;
748       sn += app->serialno[5] * 65536;
749       sn += app->serialno[6] * 256;
750       sn += app->serialno[7];
751       result = xtryasprintf ("yk-%lu", sn);
752     }
753   else if (failmode)
754     result = NULL;  /* No Abbreviated S/N.  */
755   else
756     result = app_get_serialno (app);
757
758   return result;
759 }
760
761
762 /* The verify command can be used to retrieve the security status of
763  * the card.  Given the PIN name (e.g. "PIV.80" for thge application
764  * pin, a status is returned:
765  *
766  *        -1 = Error retrieving the data,
767  *        -2 = No such PIN,
768  *        -3 = PIN blocked,
769  *        -5 = Verify still valid,
770  *    n >= 0 = Number of verification attempts left.
771  */
772 static int
773 get_chv_status (app_t app, const char *keyrefstr)
774 {
775   unsigned char apdu[4];
776   unsigned int sw;
777   int result;
778   int keyref;
779
780   keyref = parse_chv_keyref (keyrefstr);
781   if (!keyrefstr)
782     return -1;
783
784   apdu[0] = 0x00;
785   apdu[1] = ISO7816_VERIFY;
786   apdu[2] = 0x00;
787   apdu[3] = keyref;
788   if (!iso7816_apdu_direct (app->slot, apdu, 4, 0, &sw, NULL, NULL))
789     result = -5; /* No need to verification.  */
790   else if (sw == 0x6a88 || sw == 0x6a80)
791     result = -2; /* No such PIN.  */
792   else if (sw == 0x6983)
793     result = -3; /* PIN is blocked.  */
794   else if ((sw & 0xfff0) == 0x63C0)
795     result = (sw & 0x000f);
796   else
797     result = -1; /* Error.  */
798
799   return result;
800 }
801
802
803 /* Implementation of the GETATTR command.  This is similar to the
804  * LEARN command but returns only one value via status lines.  */
805 static gpg_error_t
806 do_getattr (app_t app, ctrl_t ctrl, const char *name)
807 {
808   static struct {
809     const char *name;
810     int tag;
811     int special;
812   } table[] = {
813     { "SERIALNO",     0x0000, -1 },
814     { "$AUTHKEYID",   0x0000, -2 }, /* Default key for ssh.  */
815     { "$DISPSERIALNO",0x0000, -3 },
816     { "CHV-STATUS",   0x0000, -4 },
817     { "CHV-USAGE",    0x007E, -5 }
818   };
819   gpg_error_t err = 0;
820   int idx;
821   void *relptr;
822   unsigned char *value;
823   size_t valuelen;
824   const unsigned char *s;
825   size_t n;
826
827   for (idx=0; (idx < DIM (table)
828                && ascii_strcasecmp (table[idx].name, name)); idx++)
829     ;
830   if (!(idx < DIM (table)))
831     err = gpg_error (GPG_ERR_INV_NAME);
832   else if (table[idx].special == -1)
833     {
834       char *serial = app_get_serialno (app);
835
836       if (serial)
837         {
838           send_status_direct (ctrl, "SERIALNO", serial);
839           xfree (serial);
840         }
841     }
842   else if (table[idx].special == -2)
843     {
844       char const tmp[] = "PIV.9A"; /* Cert PIV Authenticate.  */
845       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
846     }
847   else if (table[idx].special == -3)
848     {
849       char *tmp = get_dispserialno (app, 1);
850
851       if (tmp)
852         {
853           send_status_info (ctrl, table[idx].name,
854                             tmp, strlen (tmp),
855                             NULL, (size_t)0);
856           xfree (tmp);
857         }
858       else
859         err = gpg_error (GPG_ERR_INV_NAME);  /* No Abbreviated S/N.  */
860     }
861   else if (table[idx].special == -4) /* CHV-STATUS */
862     {
863       int tmp[4];
864
865       tmp[0] = get_chv_status (app, "PIV.00");
866       tmp[1] = get_chv_status (app, "PIV.80");
867       tmp[2] = get_chv_status (app, "PIV.81");
868       err = send_status_printf (ctrl, table[idx].name, "%d %d %d",
869                                 tmp[0], tmp[1], tmp[2]);
870     }
871   else if (table[idx].special == -5) /* CHV-USAGE (aka PIN Usage Policy) */
872     {
873       /* We return 2 hex bytes or nothing in case the discovery object
874        * is not supported.  */
875       relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &err);
876       if (relptr)
877         {
878           s = find_tlv (value, valuelen, 0x7E, &n);
879           if (s && n && (s = find_tlv (s, n, 0x5F2F, &n)) && n >=2 )
880             err = send_status_printf (ctrl, table[idx].name, "%02X %02X",
881                                       s[0], s[1]);
882           xfree (relptr);
883         }
884     }
885   else
886     {
887       relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &err);
888       if (relptr)
889         {
890           send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
891           xfree (relptr);
892         }
893     }
894
895   return err;
896 }
897
898
899 /* Authenticate the card using the Card Application Administration
900  * Key.  (VALUE,VALUELEN) has that 24 byte key.  */
901 static gpg_error_t
902 auth_adm_key (app_t app, const unsigned char *value, size_t valuelen)
903 {
904   gpg_error_t err;
905   unsigned char tmpl[4+24];
906   size_t tmpllen;
907   unsigned char *outdata = NULL;
908   size_t outdatalen;
909   const unsigned char *s;
910   char witness[8];
911   size_t n;
912   gcry_cipher_hd_t cipher = NULL;
913
914   /* Prepare decryption.  */
915   err = gcry_cipher_open (&cipher, GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_ECB, 0);
916   if (err)
917     goto leave;
918   err = gcry_cipher_setkey (cipher, value, valuelen);
919   if (err)
920     goto leave;
921
922   /* Request a witness.  */
923   tmpl[0] = 0x7c;
924   tmpl[1] = 0x02;
925   tmpl[2] = 0x80;
926   tmpl[3] = 0;    /* (Empty witness requests a witness.)  */
927   tmpllen = 4;
928   err = iso7816_general_authenticate (app->slot, 0,
929                                       PIV_ALGORITHM_3DES_ECB_0, 0x9B,
930                                       tmpl, tmpllen, 0,
931                                       &outdata, &outdatalen);
932   if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
933     err = gpg_error (GPG_ERR_BAD_AUTH);
934   if (err)
935     goto leave;
936   if (!(outdatalen && *outdata == 0x7c
937         && (s = find_tlv (outdata, outdatalen, 0x80, &n))
938         && n == 8))
939     {
940       err = gpg_error (GPG_ERR_CARD);
941       log_error ("piv: improper witness received\n");
942       goto leave;
943     }
944   err = gcry_cipher_decrypt (cipher, witness, 8, s, 8);
945   if (err)
946     goto leave;
947
948   /* Return decrypted witness and send our challenge.  */
949   tmpl[0] = 0x7c;
950   tmpl[1] = 22;
951   tmpl[2] = 0x80;
952   tmpl[3] = 8;
953   memcpy (tmpl+4, witness, 8);
954   tmpl[12] = 0x81;
955   tmpl[13] = 8;
956   gcry_create_nonce (tmpl+14, 8);
957   tmpl[22] = 0x80;
958   tmpl[23] = 0;
959   tmpllen = 24;
960   xfree (outdata);
961   err = iso7816_general_authenticate (app->slot, 0,
962                                       PIV_ALGORITHM_3DES_ECB_0, 0x9B,
963                                       tmpl, tmpllen, 0,
964                                       &outdata, &outdatalen);
965   if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
966     err = gpg_error (GPG_ERR_BAD_AUTH);
967   if (err)
968     goto leave;
969   if (!(outdatalen && *outdata == 0x7c
970         && (s = find_tlv (outdata, outdatalen, 0x82, &n))
971         && n == 8))
972     {
973       err = gpg_error (GPG_ERR_CARD);
974       log_error ("piv: improper challenge received\n");
975       goto leave;
976     }
977   /* (We reuse the witness buffer.) */
978   err = gcry_cipher_decrypt (cipher, witness, 8, s, 8);
979   if (err)
980     goto leave;
981   if (memcmp (witness, tmpl+14, 8))
982     {
983       err = gpg_error (GPG_ERR_BAD_AUTH);
984       goto leave;
985     }
986
987  leave:
988    xfree (outdata);
989    gcry_cipher_close (cipher);
990    return err;
991 }
992
993
994 /* Set a new admin key.  */
995 static gpg_error_t
996 set_adm_key (app_t app, const unsigned char *value, size_t valuelen)
997 {
998   gpg_error_t err;
999   unsigned char apdu[8+24];
1000   unsigned int sw;
1001
1002   /* Check whether it is a weak key and that it is of proper length.  */
1003   {
1004     gcry_cipher_hd_t cipher;
1005
1006     err = gcry_cipher_open (&cipher, GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_ECB, 0);
1007     if (!err)
1008       {
1009         err = gcry_cipher_setkey (cipher, value, valuelen);
1010         gcry_cipher_close (cipher);
1011       }
1012     if (err)
1013       goto leave;
1014   }
1015
1016   if (app->app_local->flags.yubikey)
1017     {
1018       /* This is a Yubikey.  */
1019       if (valuelen != 24)
1020         {
1021           err = gpg_error (GPG_ERR_INV_LENGTH);
1022           goto leave;
1023         }
1024
1025       /* We use a proprietary Yubikey command.  */
1026       apdu[0] = 0;
1027       apdu[1] = 0xff;
1028       apdu[2] = 0xff;
1029       apdu[3] = 0xff;  /* touch policy: 0xff=never, 0xfe = always.  */
1030       apdu[4] = 3 + 24;
1031       apdu[5] = PIV_ALGORITHM_3DES_ECB;
1032       apdu[6] = 0x9b;
1033       apdu[7] = 24;
1034       memcpy (apdu+8, value, 24);
1035       err = iso7816_apdu_direct (app->slot, apdu, 8+24, 0, &sw, NULL, NULL);
1036       wipememory (apdu+8, 24);
1037       if (err)
1038         log_error ("piv: setting admin key failed; sw=%04x\n", sw);
1039       /* A PIN is not required, thus use a better error code.  */
1040       if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
1041         err = gpg_error (GPG_ERR_NO_AUTH);
1042     }
1043   else
1044     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1045
1046
1047  leave:
1048    return err;
1049 }
1050
1051 /* Handle the SETATTR operation. All arguments are already basically
1052  * checked. */
1053 static gpg_error_t
1054 do_setattr (app_t app, const char *name,
1055             gpg_error_t (*pincb)(void*, const char *, char **),
1056             void *pincb_arg,
1057             const unsigned char *value, size_t valuelen)
1058 {
1059   gpg_error_t err;
1060   static struct {
1061     const char *name;
1062     unsigned short tag;
1063     unsigned short flush_tag;  /* The tag which needs to be flushed or 0. */
1064     int special;               /* Special mode to use for thus NAME.  */
1065   } table[] = {
1066     /* Authenticate using the PIV Card Application Administration Key
1067      * (0x0B).  Note that Yubico calls this key the "management key"
1068      * which we don't do because that term is too similar to "Cert
1069      * Management Key" (0x9D).  */
1070     { "AUTH-ADM-KEY", 0x0000, 0x0000, 1 },
1071     { "SET-ADM-KEY",  0x0000, 0x0000, 2 }
1072   };
1073   int idx;
1074
1075   (void)pincb;
1076   (void)pincb_arg;
1077
1078   for (idx=0; (idx < DIM (table)
1079                && ascii_strcasecmp (table[idx].name, name)); idx++)
1080     ;
1081   if (!(idx < DIM (table)))
1082     return gpg_error (GPG_ERR_INV_NAME);
1083
1084   /* Flush the cache before writing it, so that the next get operation
1085    * will reread the data from the card and thus get synced in case of
1086    * errors (e.g. data truncated by the card). */
1087   if (table[idx].tag)
1088     flush_cached_data (app, table[idx].flush_tag? table[idx].flush_tag
1089                        /* */                    : table[idx].tag);
1090
1091   switch (table[idx].special)
1092     {
1093     case 1:
1094       err = auth_adm_key (app, value, valuelen);
1095       break;
1096
1097     case 2:
1098       err = set_adm_key (app, value, valuelen);
1099       break;
1100
1101     default:
1102       err = gpg_error (GPG_ERR_BUG);
1103       break;
1104     }
1105
1106   return err;
1107 }
1108
1109
1110 /* Send the KEYPAIRINFO back.  DOBJ describes the data object carrying
1111  * the key.  This is used by the LEARN command. */
1112 static gpg_error_t
1113 send_keypair_and_cert_info (app_t app, ctrl_t ctrl, data_object_t dobj,
1114                             int only_keypair)
1115 {
1116   gpg_error_t err = 0;
1117   char *keygripstr = NULL;
1118   int got_cert;
1119   char idbuf[50];
1120   const char *usage;
1121
1122   err = get_keygrip_by_tag (app, dobj->tag, &keygripstr, &got_cert);
1123   if (err)
1124     goto leave;
1125
1126   usage = dobj->usage? dobj->usage : "";
1127
1128   snprintf (idbuf, sizeof idbuf, "PIV.%s", dobj->keyref);
1129   send_status_info (ctrl, "KEYPAIRINFO",
1130                     keygripstr, strlen (keygripstr),
1131                     idbuf, strlen (idbuf),
1132                     usage, strlen (usage),
1133                     NULL, (size_t)0);
1134   if (!only_keypair && got_cert)
1135     {
1136       /* All certificates are of type 100 (Regular X.509 Cert).  */
1137       send_status_info (ctrl, "CERTINFO",
1138                         "100", 3,
1139                         idbuf, strlen (idbuf),
1140                         NULL, (size_t)0);
1141     }
1142
1143  leave:
1144   xfree (keygripstr);
1145   return err;
1146 }
1147
1148
1149 /* Handle the LEARN command.  */
1150 static gpg_error_t
1151 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1152 {
1153   int i;
1154
1155   (void)flags;
1156
1157   do_getattr (app, ctrl, "CHV-USAGE");
1158   do_getattr (app, ctrl, "CHV-STATUS");
1159
1160   for (i=0; data_objects[i].tag; i++)
1161     if (data_objects[i].keypair)
1162       send_keypair_and_cert_info (app, ctrl, data_objects + i, !!(flags & 1));
1163
1164
1165   return 0;
1166 }
1167
1168
1169 /* Core of do_readcert which fetches the certificate based on the
1170  * given tag and returns it in a freshly allocated buffer stored at
1171  * R_CERT and the length of the certificate stored at R_CERTLEN.  If
1172  * on success a non-zero value is stored at R_MECHANISM, the returned
1173  * data is not a certificate but a public key (in the format used by the
1174  * container '7f49'.  */
1175 static gpg_error_t
1176 readcert_by_tag (app_t app, unsigned int tag,
1177                  unsigned char **r_cert, size_t *r_certlen, int *r_mechanism)
1178 {
1179   gpg_error_t err;
1180   unsigned char *buffer;
1181   size_t buflen;
1182   void *relptr;
1183   const unsigned char *s, *s2;
1184   size_t n, n2;
1185
1186   *r_cert = NULL;
1187   *r_certlen = 0;
1188   *r_mechanism = 0;
1189
1190   relptr = get_one_do (app, tag, &buffer, &buflen, NULL);
1191   if (!relptr || !buflen)
1192    {
1193       err = gpg_error (GPG_ERR_NOT_FOUND);
1194       goto leave;
1195     }
1196
1197   s = find_tlv (buffer, buflen, 0x71, &n);
1198   if (!s)
1199     {
1200       /* No certificate; check whether a public key has been stored
1201        * using our own scheme.  */
1202       s = find_tlv (buffer, buflen, 0x7f49, &n);
1203       if (!s || !n)
1204         {
1205           log_error ("piv: No public key in 0x%X\n", tag);
1206           err = gpg_error (GPG_ERR_NO_PUBKEY);
1207           goto leave;
1208         }
1209       s2 = find_tlv (buffer, buflen, 0x80, &n2);
1210       if (!s2 || n2 != 1 || !*s2)
1211         {
1212           log_error ("piv: No mechanism for public key in 0x%X\n", tag);
1213           err = gpg_error (GPG_ERR_NO_PUBKEY);
1214           goto leave;
1215         }
1216       *r_mechanism = *s2;
1217     }
1218   else
1219     {
1220       if (n != 1)
1221         {
1222           log_error ("piv: invalid CertInfo in 0x%X\n", tag);
1223           err = gpg_error (GPG_ERR_INV_CERT_OBJ);
1224           goto leave;
1225         }
1226       if (*s == 0x01)
1227         {
1228           log_error ("piv: gzip compression not yet supported (tag 0x%X)\n",
1229                      tag);
1230           err = gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1231           goto leave;
1232         }
1233       if (*s)
1234         {
1235           log_error ("piv: invalid CertInfo 0x%02x in 0x%X\n", *s, tag);
1236           err = gpg_error (GPG_ERR_INV_CERT_OBJ);
1237           goto leave;
1238         }
1239
1240       /* Note: We don't check that the LRC octet has a length of zero
1241        * as required by the specs.  */
1242
1243       /* Get the cert from the container.  */
1244       s = find_tlv (buffer, buflen, 0x70, &n);
1245       if (!s || !n)
1246         {
1247           err = gpg_error (GPG_ERR_NOT_FOUND);
1248           goto leave;
1249         }
1250     }
1251
1252   /* The next is common for certificate and public key.  */
1253   if (!(*r_cert = xtrymalloc (n)))
1254     {
1255       err = gpg_error_from_syserror ();
1256       goto leave;
1257     }
1258
1259   memcpy (*r_cert, s, n);
1260   *r_certlen = n;
1261   err = 0;
1262
1263  leave:
1264   xfree (relptr);
1265   return err;
1266 }
1267
1268
1269 /* Get the keygrip in hex format of a key from the certificate stored
1270  * at TAG.  Caller must free the string at R_KEYGRIPSTR. */
1271 static gpg_error_t
1272 get_keygrip_by_tag (app_t app, unsigned int tag,
1273                     char **r_keygripstr, int *r_got_cert)
1274 {
1275   gpg_error_t err;
1276   unsigned char *certbuf = NULL;
1277   size_t certbuflen;
1278   int mechanism;
1279   gcry_sexp_t s_pkey = NULL;
1280   ksba_cert_t cert = NULL;
1281   unsigned char grip[KEYGRIP_LEN];
1282
1283   *r_got_cert = 0;
1284   *r_keygripstr = xtrymalloc (2*KEYGRIP_LEN+1);
1285   if (!r_keygripstr)
1286     {
1287       err = gpg_error_from_syserror ();
1288       goto leave;
1289     }
1290
1291   /* We need to get the public key from the certificate.  */
1292   err = readcert_by_tag (app, tag, &certbuf, &certbuflen, &mechanism);
1293   if (err)
1294     goto leave;
1295   if (mechanism) /* Compute keygrip from public key.  */
1296     {
1297       if (mechanism == PIV_ALGORITHM_RSA)
1298         err = genkey_parse_rsa (certbuf, certbuflen, &s_pkey);
1299       else if (mechanism == PIV_ALGORITHM_ECC_P256
1300                || mechanism == PIV_ALGORITHM_ECC_P384)
1301         err = genkey_parse_ecc (certbuf, certbuflen, mechanism, &s_pkey);
1302       else
1303         err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1304       if (err)
1305         goto leave;
1306
1307       if (!gcry_pk_get_keygrip (s_pkey, grip))
1308         {
1309           log_error ("piv: error computing keygrip\n");
1310           err = gpg_error (GPG_ERR_GENERAL);
1311           goto leave;
1312         }
1313
1314       bin2hex (grip, sizeof grip, *r_keygripstr);
1315     }
1316   else /* Compute keygrip from certificate.  */
1317     {
1318       *r_got_cert = 0;
1319       err = ksba_cert_new (&cert);
1320       if (err)
1321         goto leave;
1322       err = ksba_cert_init_from_mem (cert, certbuf, certbuflen);
1323       if (err)
1324         goto leave;
1325       err = app_help_get_keygrip_string (cert, *r_keygripstr);
1326     }
1327
1328  leave:
1329   gcry_sexp_release (s_pkey);
1330   ksba_cert_release (cert);
1331   xfree (certbuf);
1332   if (err)
1333     {
1334       xfree (*r_keygripstr);
1335       *r_keygripstr = NULL;
1336     }
1337   return err;
1338 }
1339
1340
1341 /* Locate the data object from the given KEYREF.  The KEYREF may also
1342  * be the corresponding OID of the key object.  Returns the data
1343  * object or NULL if not found.  */
1344 static data_object_t
1345 find_dobj_by_keyref (app_t app, const char *keyref)
1346 {
1347   int i;
1348
1349   (void)app;
1350
1351   if (!ascii_strncasecmp (keyref, "PIV.", 4))
1352     {
1353       keyref += 4;
1354       for (i=0; data_objects[i].tag; i++)
1355         if (*data_objects[i].keyref
1356             && !ascii_strcasecmp (keyref, data_objects[i].keyref))
1357           {
1358             return data_objects + i;
1359           }
1360     }
1361   else if (!strncmp (keyref, "2.16.840.1.101.3.7.", 19))
1362     {
1363       keyref += 19;
1364       for (i=0; data_objects[i].tag; i++)
1365         if (*data_objects[i].keyref
1366             && !strcmp (keyref, data_objects[i].oidsuffix))
1367           {
1368             return data_objects + i;
1369           }
1370     }
1371
1372   return NULL;
1373 }
1374
1375
1376 /* Return the keyref from DOBJ as an integer.  If it does not exist,
1377  * return -1.  */
1378 static int
1379 keyref_from_dobj (data_object_t dobj)
1380 {
1381   if (!dobj || !hexdigitp (dobj->keyref) || !hexdigitp (dobj->keyref+1))
1382     return -1;
1383   return xtoi_2 (dobj->keyref);
1384 }
1385
1386
1387 /* Read a certificate from the card and returned in a freshly
1388  * allocated buffer stored at R_CERT and the length of the certificate
1389  * stored at R_CERTLEN.  CERTID is either the OID of the cert's
1390  * container or of the form "PIV.<two_hexdigit_keyref>"  */
1391 static gpg_error_t
1392 do_readcert (app_t app, const char *certid,
1393              unsigned char **r_cert, size_t *r_certlen)
1394 {
1395   gpg_error_t err;
1396   data_object_t dobj;
1397   int mechanism;
1398
1399   *r_cert = NULL;
1400   *r_certlen = 0;
1401
1402   /* Hack to read a Yubikey attestation certificate.  */
1403   if (app->app_local->flags.yubikey
1404       && strlen (certid) == 11
1405       && !ascii_strncasecmp (certid, "PIV.ATST.", 9)
1406       && hexdigitp (certid+9) && hexdigitp (certid+10))
1407     {
1408       unsigned char apdu[4];
1409       unsigned char *result;
1410       size_t resultlen;
1411
1412       apdu[0] = 0;
1413       apdu[1] = 0xf9;  /* Yubikey: Get attestation cert.  */
1414       apdu[2] = xtoi_2 (certid+9);
1415       apdu[3] = 0;
1416       err = iso7816_apdu_direct (app->slot, apdu, 4, 1,
1417                                  NULL, &result, &resultlen);
1418       if (!err)
1419         {
1420           *r_cert = result;
1421           *r_certlen = resultlen;
1422         }
1423       return err;
1424     }
1425
1426   dobj = find_dobj_by_keyref (app, certid);
1427   if (!dobj)
1428     return gpg_error (GPG_ERR_INV_ID);
1429
1430   err = readcert_by_tag (app, dobj->tag, r_cert, r_certlen, &mechanism);
1431   if (!err && mechanism)
1432     {
1433       /* Well, no certificate but a public key - we don't want it.  */
1434       xfree (*r_cert);
1435       *r_cert = NULL;
1436       *r_certlen = 0;
1437       err = gpg_error (GPG_ERR_NOT_FOUND);
1438     }
1439   return err;
1440 }
1441
1442
1443 /* Return a public key in a freshly allocated buffer.  This will only
1444  * work for a freshly generated key as long as no reset of the
1445  * application has been performed.  This is because we return a cached
1446  * result from key generation.  If no cached result is available, the
1447  * error GPG_ERR_UNSUPPORTED_OPERATION is returned so that the higher
1448  * layer can then get the key by reading the matching certificate.
1449  * On success a canonical encoded s-expression with the public key is
1450  * stored at (R_PK,R_PKLEN); the caller must release that buffer.  On
1451  * error R_PK and R_PKLEN are not changed and an error code is
1452  * returned.
1453  */
1454 static gpg_error_t
1455 do_readkey (app_t app, const char *keyrefstr,
1456             unsigned char **r_pk, size_t *r_pklen)
1457 {
1458   gpg_error_t err;
1459   data_object_t dobj;
1460   int keyref;
1461   unsigned char *cert = NULL;
1462   size_t certlen;
1463   int mechanism;
1464   gcry_sexp_t s_pkey = NULL;
1465   unsigned char *pk = NULL;
1466   size_t pklen;
1467
1468   dobj = find_dobj_by_keyref (app, keyrefstr);
1469   if ((keyref = keyref_from_dobj (dobj)) == -1)
1470     {
1471       err = gpg_error (GPG_ERR_INV_ID);
1472       goto leave;
1473     }
1474
1475   err = readcert_by_tag (app, dobj->tag, &cert, &certlen, &mechanism);
1476   if (err)
1477     goto leave;
1478   if (!mechanism)
1479     {
1480       /* We got a certificate.  Extract the pubkey from it.  */
1481       err = app_help_pubkey_from_cert (cert, certlen, &pk, &pklen);
1482       if (err)
1483         {
1484           log_error ("failed to parse the certificate: %s\n",
1485                      gpg_strerror (err));
1486           goto leave;
1487         }
1488     }
1489   else
1490     {
1491       /* Convert the public key into the expected s-expression.  */
1492       if (mechanism == PIV_ALGORITHM_RSA)
1493         err = genkey_parse_rsa (cert, certlen, &s_pkey);
1494       else if (mechanism == PIV_ALGORITHM_ECC_P256
1495                || mechanism == PIV_ALGORITHM_ECC_P384)
1496         err = genkey_parse_ecc (cert, certlen, mechanism, &s_pkey);
1497       else
1498         err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1499       if (err)
1500         goto leave;
1501
1502       err = make_canon_sexp (s_pkey, &pk, &pklen);
1503       if (err)
1504         goto leave;
1505     }
1506
1507   *r_pk = pk;
1508   pk = NULL;
1509   *r_pklen = pklen;
1510
1511  leave:
1512   gcry_sexp_release (s_pkey);
1513   xfree (pk);
1514   xfree (cert);
1515   return err;
1516 }
1517
1518
1519 /* Given a data object DOBJ return the corresponding PIV algorithm and
1520  * store it at R_ALGO.  The algorithm is taken from the corresponding
1521  * certificate or from a cache.  */
1522 static gpg_error_t
1523 get_key_algorithm_by_dobj (app_t app, data_object_t dobj, int *r_mechanism)
1524 {
1525   gpg_error_t err;
1526   unsigned char *certbuf = NULL;
1527   size_t certbuflen;
1528   int mechanism;
1529   ksba_cert_t cert = NULL;
1530   ksba_sexp_t k_pkey = NULL;
1531   gcry_sexp_t s_pkey = NULL;
1532   gcry_sexp_t l1 = NULL;
1533   char *algoname = NULL;
1534   int algo;
1535   size_t n;
1536   const char *curve_name;
1537
1538   *r_mechanism = 0;
1539
1540   err = readcert_by_tag (app, dobj->tag, &certbuf, &certbuflen, &mechanism);
1541   if (err)
1542     goto leave;
1543   if (mechanism)
1544     {
1545       /* A public key was found.  That makes it easy.  */
1546       switch (mechanism)
1547         {
1548         case PIV_ALGORITHM_RSA:
1549         case PIV_ALGORITHM_ECC_P256:
1550         case PIV_ALGORITHM_ECC_P384:
1551           *r_mechanism = mechanism;
1552           break;
1553
1554         default:
1555           err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1556           log_error ("piv: unknown mechanism %d in public key at %s\n",
1557                      mechanism, dobj->keyref);
1558           break;
1559         }
1560       goto leave;
1561     }
1562
1563   err = ksba_cert_new (&cert);
1564   if (err)
1565     goto leave;
1566
1567   err = ksba_cert_init_from_mem (cert, certbuf, certbuflen);
1568   if (err)
1569     {
1570       log_error ("piv: failed to parse the certificate %s: %s\n",
1571                  dobj->keyref, gpg_strerror (err));
1572       goto leave;
1573     }
1574   xfree (certbuf);
1575   certbuf = NULL;
1576
1577   k_pkey = ksba_cert_get_public_key (cert);
1578   if (!k_pkey)
1579     {
1580       err = gpg_error (GPG_ERR_NO_PUBKEY);
1581       goto leave;
1582     }
1583   n = gcry_sexp_canon_len (k_pkey, 0, NULL, NULL);
1584   err = gcry_sexp_new (&s_pkey, k_pkey, n, 0);
1585   if (err)
1586     goto leave;
1587
1588   l1 = gcry_sexp_find_token (s_pkey, "public-key", 0);
1589   if (!l1)
1590     {
1591       err = gpg_error (GPG_ERR_NO_PUBKEY);
1592       goto leave;
1593     }
1594
1595   {
1596     gcry_sexp_t l_tmp = gcry_sexp_cadr (l1);
1597     gcry_sexp_release (l1);
1598     l1 = l_tmp;
1599   }
1600   algoname = gcry_sexp_nth_string (l1, 0);
1601   if (!algoname)
1602     {
1603       err = gpg_error_from_syserror ();
1604       goto leave;
1605     }
1606
1607   algo = gcry_pk_map_name (algoname);
1608   switch (algo)
1609     {
1610     case GCRY_PK_RSA:
1611       algo = PIV_ALGORITHM_RSA;
1612       break;
1613
1614     case GCRY_PK_ECC:
1615     case GCRY_PK_ECDSA:
1616     case GCRY_PK_ECDH:
1617       curve_name = gcry_pk_get_curve (s_pkey, 0, NULL);
1618       if (curve_name && !strcmp (curve_name, "NIST P-256"))
1619         algo = PIV_ALGORITHM_ECC_P256;
1620       else if (curve_name && !strcmp (curve_name, "NIST P-384"))
1621         algo = PIV_ALGORITHM_ECC_P384;
1622       else
1623         {
1624           err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
1625           log_error ("piv: certificate %s, curve '%s': %s\n",
1626                      dobj->keyref, curve_name, gpg_strerror (err));
1627           goto leave;
1628         }
1629       break;
1630
1631     default:
1632       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
1633       log_error ("piv: certificate %s, pubkey algo '%s': %s\n",
1634                  dobj->keyref, algoname, gpg_strerror (err));
1635       goto leave;
1636     }
1637   *r_mechanism = algo;
1638
1639  leave:
1640   gcry_free (algoname);
1641   gcry_sexp_release (l1);
1642   gcry_sexp_release (s_pkey);
1643   ksba_free (k_pkey);
1644   xfree (certbuf);
1645   return err;
1646 }
1647
1648
1649 /* Return an allocated string to be used as prompt.  Returns NULL on
1650  * malloc error.  */
1651 static char *
1652 make_prompt (app_t app, int remaining, const char *firstline)
1653 {
1654   char *serial, *tmpbuf, *result;
1655
1656   serial = get_dispserialno (app, 0);
1657   if (!serial)
1658     return NULL;
1659
1660   /* TRANSLATORS: Put a \x1f right before a colon.  This can be
1661    * used by pinentry to nicely align the names and values.  Keep
1662    * the %s at the start and end of the string.  */
1663   result = xtryasprintf (_("%s"
1664                            "Number\x1f: %s%%0A"
1665                            "Holder\x1f: %s"
1666                            "%s"),
1667                          "\x1e",
1668                          serial,
1669                          "Unknown", /* Fixme */
1670                          "");
1671   xfree (serial);
1672
1673   /* Append a "remaining attempts" info if needed.  */
1674   if (remaining != -1 && remaining < 3)
1675     {
1676       char *rembuf;
1677
1678       /* TRANSLATORS: This is the number of remaining attempts to
1679        * enter a PIN.  Use %%0A (double-percent,0A) for a linefeed. */
1680       rembuf = xtryasprintf (_("Remaining attempts: %d"), remaining);
1681       if (rembuf)
1682         {
1683           tmpbuf = strconcat (firstline, "%0A%0A", result,
1684                               "%0A%0A", rembuf, NULL);
1685           xfree (rembuf);
1686         }
1687       else
1688         tmpbuf = NULL;
1689       xfree (result);
1690       result = tmpbuf;
1691     }
1692   else
1693     {
1694       tmpbuf = strconcat (firstline, "%0A%0A", result, NULL);
1695       xfree (result);
1696       result = tmpbuf;
1697     }
1698
1699   return result;
1700 }
1701
1702
1703 /* Helper for verify_chv to ask for the PIN and to prepare/pad it.  On
1704  * success the result is stored at (R_PIN,R_PINLEN).  */
1705 static gpg_error_t
1706 ask_and_prepare_chv (app_t app, int keyref, int ask_new, int remaining,
1707                      gpg_error_t (*pincb)(void*,const char *,char **),
1708                      void *pincb_arg, char **r_pin, unsigned int *r_pinlen)
1709 {
1710   gpg_error_t err;
1711   const char *label;
1712   char *prompt;
1713   char *pinvalue = NULL;
1714   unsigned int pinlen;
1715   char *pinbuffer = NULL;
1716   int minlen, maxlen, padding, onlydigits;
1717
1718   *r_pin = NULL;
1719   *r_pinlen = 0;
1720
1721   if (ask_new)
1722     remaining = -1;
1723
1724   if (remaining != -1)
1725     log_debug ("piv: CHV %02X has %d attempts left\n", keyref, remaining);
1726
1727   switch (keyref)
1728     {
1729     case 0x00:
1730       minlen = 6;
1731       maxlen = 8;
1732       padding = 1;
1733       onlydigits = 1;
1734       label = (ask_new? _("|N|Please enter the new Global-PIN")
1735                /**/   : _("||Please enter the Global-PIN of your PIV card"));
1736       break;
1737     case 0x80:
1738       minlen = 6;
1739       maxlen = 8;
1740       padding = 1;
1741       onlydigits = 1;
1742       label = (ask_new? _("|N|Please enter the new PIN")
1743                /**/   : _("||Please enter the PIN of your PIV card"));
1744       break;
1745     case 0x81:
1746       minlen = 8;
1747       maxlen = 8;
1748       padding = 0;
1749       onlydigits = 0;
1750       label = (ask_new? _("|N|Please enter the new Unblocking Key")
1751                /**/   :_("||Please enter the Unblocking Key of your PIV card"));
1752       break;
1753
1754     case 0x96:
1755     case 0x97:
1756     case 0x98:
1757     case 0x9B:
1758       return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1759
1760     default:
1761       return gpg_error (GPG_ERR_INV_ID);
1762     }
1763
1764   /* Ask for the PIN.  */
1765   prompt = make_prompt (app, remaining, label);
1766   err = pincb (pincb_arg, prompt, &pinvalue);
1767   xfree (prompt);
1768   prompt = NULL;
1769   if (err)
1770     {
1771       log_info (_("PIN callback returned error: %s\n"), gpg_strerror (err));
1772       return err;
1773     }
1774
1775   pinlen = pinvalue? strlen (pinvalue) : 0;
1776   if (pinlen < minlen)
1777     {
1778       log_error (_("PIN for is too short; minimum length is %d\n"), minlen);
1779       if (pinvalue)
1780         wipememory (pinvalue, pinlen);
1781       xfree (pinvalue);
1782       return gpg_error (GPG_ERR_BAD_PIN);
1783     }
1784   if (pinlen > maxlen)
1785     {
1786       log_error (_("PIN for is too long; maximum length is %d\n"), maxlen);
1787       wipememory (pinvalue, pinlen);
1788       xfree (pinvalue);
1789       return gpg_error (GPG_ERR_BAD_PIN);
1790     }
1791   if (onlydigits && strspn (pinvalue, "0123456789") != pinlen)
1792     {
1793       log_error (_("PIN has invalid characters; only digits are allowed\n"));
1794       wipememory (pinvalue, pinlen);
1795       xfree (pinvalue);
1796       return gpg_error (GPG_ERR_BAD_PIN);
1797     }
1798
1799   pinbuffer = xtrymalloc_secure (maxlen);
1800   if (!pinbuffer)
1801     {
1802       err = gpg_error_from_syserror ();
1803       wipememory (pinvalue, pinlen);
1804       xfree (pinvalue);
1805       return err;
1806     }
1807
1808   memcpy (pinbuffer, pinvalue, pinlen);
1809   wipememory (pinvalue, pinlen);
1810   xfree (pinvalue);
1811   if (padding)
1812     {
1813       memset (pinbuffer + pinlen, 0xff, maxlen - pinlen);
1814       pinlen = maxlen;
1815     }
1816
1817   *r_pin = pinbuffer;
1818   *r_pinlen = pinlen;
1819
1820   return 0;
1821 }
1822
1823
1824 /* Verify the card holder verification identified by KEYREF.  This is
1825  * either the Appication PIN or the Global PIN.  If FORCE is true a
1826  * verification is always done.  */
1827 static gpg_error_t
1828 verify_chv (app_t app, int keyref, int force,
1829             gpg_error_t (*pincb)(void*,const char *,char **), void *pincb_arg)
1830 {
1831   gpg_error_t err;
1832   unsigned char apdu[4];
1833   unsigned int sw;
1834   int remaining;
1835   char *pin = NULL;
1836   unsigned int pinlen;
1837
1838   /* First check whether a verify is at all needed.  This is done with
1839    * P1 being 0 and no Lc and command data send.  */
1840   apdu[0] = 0x00;
1841   apdu[1] = ISO7816_VERIFY;
1842   apdu[2] = 0x00;
1843   apdu[3] = keyref;
1844   if (!iso7816_apdu_direct (app->slot, apdu, 4, 0, &sw, NULL, NULL))
1845     {
1846       if (!force) /* No need to verification.  */
1847         return 0;  /* All fine.  */
1848       remaining = -1;
1849     }
1850   else if ((sw & 0xfff0) == 0x63C0)
1851     remaining = (sw & 0x000f); /* PIN has REMAINING tries left.  */
1852   else
1853     remaining = -1;
1854
1855   err = ask_and_prepare_chv (app, keyref, 0, remaining, pincb, pincb_arg,
1856                              &pin, &pinlen);
1857   if (err)
1858     return err;
1859
1860   err = iso7816_verify (app->slot, keyref, pin, pinlen);
1861   wipememory (pin, pinlen);
1862   xfree (pin);
1863   if (err)
1864     log_error ("CHV %02X verification failed: %s\n",
1865                keyref, gpg_strerror (err));
1866
1867   return err;
1868 }
1869
1870
1871 /* Handle the PASSWD command.  Valid values for PWIDSTR are
1872  * key references related to PINs; in particular:
1873  *   PIV.00 - The Global PIN
1874  *   PIV.80 - The Application PIN
1875  *   PIV.81 - The PIN Unblocking key
1876  * The supported flags are:
1877  *   APP_CHANGE_FLAG_CLEAR   Clear the PIN verification state.
1878  *   APP_CHANGE_FLAG_RESET   Reset a PIN using the PUK.  Only
1879  *                           allowed with PIV.80.
1880  */
1881 static gpg_error_t
1882 do_change_chv (app_t app, ctrl_t ctrl, const char *pwidstr,
1883                unsigned int flags,
1884                gpg_error_t (*pincb)(void*, const char *, char **),
1885                void *pincb_arg)
1886 {
1887   gpg_error_t err;
1888   int keyref, targetkeyref;
1889   unsigned char apdu[4];
1890   unsigned int sw;
1891   int remaining;
1892   char *oldpin = NULL;
1893   unsigned int oldpinlen;
1894   char *newpin = NULL;
1895   unsigned int newpinlen;
1896
1897   (void)ctrl;
1898
1899   /* Check for unknown flags.  */
1900   if ((flags & ~(APP_CHANGE_FLAG_CLEAR|APP_CHANGE_FLAG_RESET)))
1901     {
1902       err = gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
1903       goto leave;
1904     }
1905
1906   /* Parse the keyref.  */
1907   targetkeyref = keyref = parse_chv_keyref (pwidstr);
1908   if (keyref == -1)
1909     {
1910       err = gpg_error (GPG_ERR_INV_ID);
1911       goto leave;
1912     }
1913
1914   /* First see whether the special --clear mode has been requested.  */
1915   if ((flags & APP_CHANGE_FLAG_CLEAR))
1916     {
1917       apdu[0] = 0x00;
1918       apdu[1] = ISO7816_VERIFY;
1919       apdu[2] = 0xff;
1920       apdu[3] = keyref;
1921       err = iso7816_apdu_direct (app->slot, apdu, 4, 0, NULL, NULL, NULL);
1922       goto leave;
1923     }
1924
1925   /* Prepare reset mode.  */
1926   if ((flags & APP_CHANGE_FLAG_RESET))
1927     {
1928       if (keyref == 0x81)
1929         {
1930           err = gpg_error (GPG_ERR_INV_ID); /* Can't reset the PUK.  */
1931           goto leave;
1932         }
1933       /* Set the keyref to the PUK and keep the TARGETKEYREF.  */
1934       keyref = 0x81;
1935     }
1936
1937   /* Get the remaining tries count.  This is done by using the check
1938    * for verified state feature.  */
1939   apdu[0] = 0x00;
1940   apdu[1] = ISO7816_VERIFY;
1941   apdu[2] = 0x00;
1942   apdu[3] = keyref;
1943   if (!iso7816_apdu_direct (app->slot, apdu, 4, 0, &sw, NULL, NULL))
1944     remaining = -1; /* Already verified, thus full number of tries.  */
1945   else if ((sw & 0xfff0) == 0x63C0)
1946     remaining = (sw & 0x000f); /* PIN has REMAINING tries left.  */
1947   else
1948     remaining = -1;
1949
1950   /* Ask for the old pin or puk.  */
1951   err = ask_and_prepare_chv (app, keyref, 0, remaining, pincb, pincb_arg,
1952                              &oldpin, &oldpinlen);
1953   if (err)
1954     return err;
1955
1956   /* Verify the old pin so that we don't prompt for the new pin if the
1957    * old is wrong.  This is not possible for the PUK, though. */
1958   if (keyref != 0x81)
1959     {
1960       err = iso7816_verify (app->slot, keyref, oldpin, oldpinlen);
1961       if (err)
1962         {
1963           log_error ("CHV %02X verification failed: %s\n",
1964                      keyref, gpg_strerror (err));
1965           goto leave;
1966         }
1967     }
1968
1969   /* Ask for the new pin.  */
1970   err = ask_and_prepare_chv (app, targetkeyref, 1, -1, pincb, pincb_arg,
1971                              &newpin, &newpinlen);
1972   if (err)
1973     return err;
1974
1975   if ((flags & APP_CHANGE_FLAG_RESET))
1976     {
1977       char *buf = xtrymalloc_secure (oldpinlen + newpinlen);
1978       if (!buf)
1979         {
1980           err = gpg_error_from_syserror ();
1981           goto leave;
1982         }
1983       memcpy (buf, oldpin, oldpinlen);
1984       memcpy (buf+oldpinlen, newpin, newpinlen);
1985       err = iso7816_reset_retry_counter_with_rc (app->slot, targetkeyref,
1986                                                  buf, oldpinlen+newpinlen);
1987       xfree (buf);
1988       if (err)
1989         log_error ("resetting CHV %02X using CHV %02X failed: %s\n",
1990                    targetkeyref, keyref, gpg_strerror (err));
1991     }
1992   else
1993     {
1994       err = iso7816_change_reference_data (app->slot, keyref,
1995                                            oldpin, oldpinlen,
1996                                            newpin, newpinlen);
1997       if (err)
1998         log_error ("CHV %02X changing PIN failed: %s\n",
1999                    keyref, gpg_strerror (err));
2000     }
2001
2002  leave:
2003   xfree (oldpin);
2004   xfree (newpin);
2005   return err;
2006 }
2007
2008
2009 /* Perform a simple verify operation for the PIN specified by PWIDSTR.
2010  * For valid values see do_change_chv.  */
2011 static gpg_error_t
2012 do_check_chv (app_t app, const char *pwidstr,
2013               gpg_error_t (*pincb)(void*, const char *, char **),
2014               void *pincb_arg)
2015 {
2016   int keyref;
2017
2018   keyref = parse_chv_keyref (pwidstr);
2019   if (keyref == -1)
2020     return gpg_error (GPG_ERR_INV_ID);
2021
2022   return verify_chv (app, keyref, 0, pincb, pincb_arg);
2023 }
2024
2025
2026 /* Compute a digital signature using the GENERAL AUTHENTICATE command
2027  * on INDATA which is expected to be the raw message digest.  The
2028  * KEYIDSTR has the key reference or its OID (e.g. "PIV.9A").  The
2029  * result is stored at (R_OUTDATA,R_OUTDATALEN); on error (NULL,0) is
2030  * stored there and an error code returned.  For ECDSA the result is
2031  * the simple concatenation of R and S without any DER encoding.  R
2032  * and S are left extended with zeroes to make sure they have an equal
2033  * length.  If HASHALGO is not zero, the function prepends the hash's
2034  * OID to the indata or checks that it is consistent.
2035  */
2036 static gpg_error_t
2037 do_sign (app_t app, const char *keyidstr, int hashalgo,
2038          gpg_error_t (*pincb)(void*, const char *, char **),
2039          void *pincb_arg,
2040          const void *indata_arg, size_t indatalen,
2041          unsigned char **r_outdata, size_t *r_outdatalen)
2042 {
2043   const unsigned char *indata = indata_arg;
2044   gpg_error_t err;
2045   data_object_t dobj;
2046   unsigned char oidbuf[64];
2047   size_t oidbuflen;
2048   unsigned char *outdata = NULL;
2049   size_t outdatalen;
2050   const unsigned char *s;
2051   size_t n;
2052   int keyref, mechanism;
2053   unsigned char *indata_buffer = NULL; /* Malloced helper.  */
2054   unsigned char *apdudata = NULL;
2055   size_t apdudatalen;
2056   int force_verify;
2057
2058   if (!keyidstr || !*keyidstr)
2059     {
2060       err = gpg_error (GPG_ERR_INV_VALUE);
2061       goto leave;
2062     }
2063
2064   dobj = find_dobj_by_keyref (app, keyidstr);
2065   if ((keyref = keyref_from_dobj (dobj)) == -1)
2066     {
2067       err = gpg_error (GPG_ERR_INV_ID);
2068       goto leave;
2069     }
2070
2071   /* According to table 4b of SP800-73-4 the signing key always
2072    * requires a verify.  */
2073   switch (keyref)
2074     {
2075     case 0x9c: force_verify = 1; break;
2076     default: force_verify = 0; break;
2077     }
2078
2079
2080   err = get_key_algorithm_by_dobj (app, dobj, &mechanism);
2081   if (err)
2082     goto leave;
2083
2084    /* For ECC we need to remove the ASN.1 prefix from INDATA.  For RSA
2085     * we need to add the padding and possible also the ASN.1 prefix.  */
2086   if (mechanism == PIV_ALGORITHM_ECC_P256
2087       || mechanism == PIV_ALGORITHM_ECC_P384)
2088     {
2089       int need_algo, need_digestlen;
2090
2091       if (mechanism == PIV_ALGORITHM_ECC_P256)
2092         {
2093           need_algo = GCRY_MD_SHA256;
2094           need_digestlen = 32;
2095         }
2096       else
2097         {
2098           need_algo = GCRY_MD_SHA384;
2099           need_digestlen = 48;
2100         }
2101
2102       if (hashalgo && hashalgo != need_algo)
2103         {
2104           err = gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2105           log_error ("piv: hash algo %d does not match mechanism %d\n",
2106                      need_algo, mechanism);
2107           goto leave;
2108         }
2109
2110       if (indatalen > need_digestlen)
2111         {
2112           oidbuflen = sizeof oidbuf;
2113           err = gcry_md_get_asnoid (need_algo, &oidbuf, &oidbuflen);
2114           if (err)
2115             {
2116               err = gpg_error (GPG_ERR_INTERNAL);
2117               log_debug ("piv: no OID for hash algo %d\n", need_algo);
2118               goto leave;
2119             }
2120           if (indatalen != oidbuflen + need_digestlen
2121               || memcmp (indata, oidbuf, oidbuflen))
2122             {
2123               err = gpg_error (GPG_ERR_INV_VALUE);
2124               log_error ("piv: bad input for signing with mechanism %d\n",
2125                          mechanism);
2126               goto leave;
2127             }
2128           indata += oidbuflen;
2129           indatalen -= oidbuflen;
2130         }
2131     }
2132   else if (mechanism == PIV_ALGORITHM_RSA)
2133     {
2134       /* PIV requires 2048 bit RSA.  */
2135       unsigned int framelen = 2048 / 8;
2136       unsigned char *frame;
2137       int i;
2138
2139       oidbuflen = sizeof oidbuf;
2140       if (!hashalgo)
2141         {
2142           /* We assume that indata already has the required
2143            * digestinfo; thus merely prepend the padding below.  */
2144         }
2145       else if ((err = gcry_md_get_asnoid (hashalgo, &oidbuf, &oidbuflen)))
2146         {
2147           log_debug ("piv: no OID for hash algo %d\n", hashalgo);
2148           goto leave;
2149         }
2150       else
2151         {
2152           unsigned int digestlen = gcry_md_get_algo_dlen (hashalgo);
2153
2154           if (indatalen == digestlen)
2155             {
2156               /* Plain hash in INDATA; prepend the digestinfo.  */
2157               indata_buffer = xtrymalloc (oidbuflen + indatalen);
2158               if (!indata_buffer)
2159                 {
2160                   err = gpg_error_from_syserror ();
2161                   goto leave;
2162                 }
2163               memcpy (indata_buffer, oidbuf, oidbuflen);
2164               memcpy (indata_buffer+oidbuflen, indata, indatalen);
2165               indata = indata_buffer;
2166               indatalen = oidbuflen + indatalen;
2167             }
2168           else if (indatalen == oidbuflen + digestlen
2169                    && !memcmp (indata, oidbuf, oidbuflen))
2170             ; /* Correct prefix.  */
2171           else
2172             {
2173               err = gpg_error (GPG_ERR_INV_VALUE);
2174               log_error ("piv: bad input for signing with RSA and hash %d\n",
2175                          hashalgo);
2176               goto leave;
2177             }
2178         }
2179       /* Now prepend the pkcs#v1.5 padding.  We require at least 8
2180        * byte of padding and 3 extra bytes for the prefix and the
2181        * delimiting nul.  */
2182       if (!indatalen || indatalen + 8 + 4 > framelen)
2183         {
2184           err = gpg_error (GPG_ERR_INV_VALUE);
2185           log_error ("piv: input does not fit into a %u bit PKCS#v1.5 frame\n",
2186                      8*framelen);
2187           goto leave;
2188         }
2189       frame = xtrymalloc (framelen);
2190       if (!frame)
2191         {
2192           err = gpg_error_from_syserror ();
2193           goto leave;
2194         }
2195       n = 0;
2196       frame[n++] = 0;
2197       frame[n++] = 1; /* Block type. */
2198       i = framelen - indatalen - 3 ;
2199       memset (frame+n, 0xff, i);
2200       n += i;
2201       frame[n++] = 0; /* Delimiter.  */
2202       memcpy (frame+n, indata, indatalen);
2203       n += indatalen;
2204       log_assert (n == framelen);
2205       /* And now put it into the indata_buffer.  */
2206       xfree (indata_buffer);
2207       indata_buffer = frame;
2208       indata = indata_buffer;
2209       indatalen = framelen;
2210     }
2211   else
2212     {
2213       err = gpg_error (GPG_ERR_INTERNAL);
2214       log_debug ("piv: unknown PIV mechanism %d while signing\n", mechanism);
2215       goto leave;
2216     }
2217
2218   /* Now verify the Application PIN.  */
2219   err = verify_chv (app, 0x80, force_verify, pincb, pincb_arg);
2220   if (err)
2221     return err;
2222
2223   /* Build the Dynamic Authentication Template.  */
2224   err = concat_tlv_list (0, &apdudata, &apdudatalen,
2225                          (int)0x7c, (size_t)0, NULL, /* Constructed. */
2226                          (int)0x82, (size_t)0, "",
2227                          (int)0x81, (size_t)indatalen, indata,
2228                          (int)0, (size_t)0, NULL);
2229   if (err)
2230     goto leave;
2231
2232   /* Note: the -1 requests command chaining.  */
2233   err = iso7816_general_authenticate (app->slot, -1,
2234                                       mechanism, keyref,
2235                                       apdudata, (int)apdudatalen, 0,
2236                                       &outdata, &outdatalen);
2237   if (err)
2238     goto leave;
2239
2240   /* Parse the response.  */
2241   if (outdatalen && *outdata == 0x7c
2242       && (s = find_tlv (outdata, outdatalen, 0x82, &n)))
2243     {
2244       if (mechanism == PIV_ALGORITHM_RSA)
2245         {
2246           memmove (outdata, outdata + (s - outdata), n);
2247           outdatalen = n;
2248         }
2249       else /* ECC */
2250         {
2251           const unsigned char *rval, *sval;
2252           size_t rlen, rlenx, slen, slenx, resultlen;
2253           char *result;
2254           /* The result of an ECDSA signature is
2255            *   SEQUENCE { r INTEGER, s INTEGER }
2256            * We re-pack that by concatenating R and S and making sure
2257            * that both have the same length.  We simplify parsing by
2258            * using find_tlv and not a proper DER parser.  */
2259           s = find_tlv (s, n, 0x30, &n);
2260           if (!s)
2261             goto bad_der;
2262           rval = find_tlv (s, n, 0x02, &rlen);
2263           if (!rval)
2264             goto bad_der;
2265           log_assert (n >= (rval-s)+rlen);
2266           sval = find_tlv (rval+rlen, n-((rval-s)+rlen), 0x02, &slen);
2267           if (!rval)
2268             goto bad_der;
2269           rlenx = slenx = 0;
2270           if (rlen > slen)
2271             slenx = rlen - slen;
2272           else if (slen > rlen)
2273             rlenx = slen - rlen;
2274
2275           resultlen = rlen + rlenx + slen + slenx;
2276           result = xtrycalloc (1, resultlen);
2277           if (!result)
2278             {
2279               err = gpg_error_from_syserror ();
2280               goto leave;
2281             }
2282           memcpy (result + rlenx, rval, rlen);
2283           memcpy (result + rlenx + rlen + slenx, sval, slen);
2284           xfree (outdata);
2285           outdata = result;
2286           outdatalen = resultlen;
2287         }
2288     }
2289   else
2290     {
2291     bad_der:
2292       err = gpg_error (GPG_ERR_CARD);
2293       log_error ("piv: response does not contain a proper result\n");
2294       goto leave;
2295     }
2296
2297  leave:
2298   if (err)
2299     {
2300       xfree (outdata);
2301       *r_outdata = NULL;
2302       *r_outdatalen = 0;
2303     }
2304   else
2305     {
2306       *r_outdata = outdata;
2307       *r_outdatalen = outdatalen;
2308     }
2309   xfree (apdudata);
2310   xfree (indata_buffer);
2311   return err;
2312 }
2313
2314
2315 /* AUTH for PIV cards is actually the same as SIGN.  The difference
2316  * between AUTH and SIGN is that AUTH expects that pkcs#1.5 padding
2317  * for RSA has already been done (digestInfo part w/o the padding)
2318  * whereas SIGN may accept a plain digest and does the padding if
2319  * needed.  This is also the reason why SIGN takes a hashalgo. */
2320 static gpg_error_t
2321 do_auth (app_t app, const char *keyidstr,
2322          gpg_error_t (*pincb)(void*, const char *, char **),
2323          void *pincb_arg,
2324          const void *indata, size_t indatalen,
2325          unsigned char **r_outdata, size_t *r_outdatalen)
2326 {
2327   return do_sign (app, keyidstr, 0, pincb, pincb_arg, indata, indatalen,
2328                   r_outdata, r_outdatalen);
2329 }
2330
2331
2332 /* Decrypt the data in (INDATA,INDATALEN) and on success store the
2333  * mallocated result at (R_OUTDATA,R_OUTDATALEN).  */
2334 static gpg_error_t
2335 do_decipher (app_t app, const char *keyidstr,
2336              gpg_error_t (*pincb)(void*, const char *, char **),
2337              void *pincb_arg,
2338              const void *indata_arg, size_t indatalen,
2339              unsigned char **r_outdata, size_t *r_outdatalen,
2340              unsigned int *r_info)
2341 {
2342   const unsigned char *indata = indata_arg;
2343   gpg_error_t err;
2344   data_object_t dobj;
2345   unsigned char *outdata = NULL;
2346   size_t outdatalen;
2347   const unsigned char *s;
2348   size_t n;
2349   int keyref, mechanism;
2350   unsigned int framelen;
2351   unsigned char *indata_buffer = NULL; /* Malloced helper.  */
2352   unsigned char *apdudata = NULL;
2353   size_t apdudatalen;
2354
2355   if (!keyidstr || !*keyidstr)
2356     {
2357       err = gpg_error (GPG_ERR_INV_VALUE);
2358       goto leave;
2359     }
2360
2361   dobj = find_dobj_by_keyref (app, keyidstr);
2362   if ((keyref = keyref_from_dobj (dobj)) == -1)
2363     {
2364       err = gpg_error (GPG_ERR_INV_ID);
2365       goto leave;
2366     }
2367   if (keyref == 0x9A || keyref == 0x9C || keyref == 0x9E)
2368     {
2369       /* Signing only reference.  We only allow '9D' and the retired
2370        * cert key management DOs.  */
2371       err = gpg_error (GPG_ERR_INV_ID);
2372       goto leave;
2373     }
2374
2375   err = get_key_algorithm_by_dobj (app, dobj, &mechanism);
2376   if (err)
2377     goto leave;
2378
2379   switch (mechanism)
2380     {
2381     case PIV_ALGORITHM_ECC_P256:
2382       framelen = 1+32+32;
2383       break;
2384     case PIV_ALGORITHM_ECC_P384:
2385       framelen = 1+48+48;
2386       break;
2387     case PIV_ALGORITHM_RSA:
2388       framelen = 2048 / 8;
2389       break;
2390     default:
2391       err = gpg_error (GPG_ERR_INTERNAL);
2392       log_debug ("piv: unknown PIV mechanism %d while decrypting\n", mechanism);
2393       goto leave;
2394     }
2395
2396   /* Check that the ciphertext has the right length; due to internal
2397    * convey mechanism using MPIs leading zero bytes might have been
2398    * lost.  Adjust for this.  Note that for ECC this actually
2399    * superfluous because the first octet is always '04' to indicate an
2400    * uncompressed point.  */
2401   if (indatalen > framelen)
2402     {
2403       err = gpg_error (GPG_ERR_INV_VALUE);
2404       log_error ("piv: input of %zu octets too large for mechanism %d\n",
2405                  indatalen, mechanism);
2406       goto leave;
2407     }
2408   if (indatalen < framelen)
2409     {
2410       indata_buffer = xtrycalloc (1, framelen);
2411       if (!indata_buffer)
2412         {
2413           err = gpg_error_from_syserror ();
2414           goto leave;
2415         }
2416       memcpy (indata_buffer+(framelen-indatalen), indata, indatalen);
2417       indata = indata_buffer;
2418       indatalen = framelen;
2419     }
2420
2421   /* Now verify the Application PIN.  */
2422   err = verify_chv (app, 0x80, 0, pincb, pincb_arg);
2423   if (err)
2424     return err;
2425
2426   /* Build the Dynamic Authentication Template.  */
2427   err = concat_tlv_list (0, &apdudata, &apdudatalen,
2428                          (int)0x7c, (size_t)0, NULL, /* Constructed. */
2429                          (int)0x82, (size_t)0, "",
2430                          mechanism == PIV_ALGORITHM_RSA?
2431                          (int)0x81 : (int)0x85, (size_t)indatalen, indata,
2432                          (int)0, (size_t)0, NULL);
2433   if (err)
2434     goto leave;
2435
2436   /* Note: the -1 requests command chaining.  */
2437   err = iso7816_general_authenticate (app->slot, -1,
2438                                       mechanism, keyref,
2439                                       apdudata, (int)apdudatalen, 0,
2440                                       &outdata, &outdatalen);
2441   if (err)
2442     goto leave;
2443
2444   /* Parse the response.  */
2445   if (outdatalen && *outdata == 0x7c
2446       && (s = find_tlv (outdata, outdatalen, 0x82, &n)))
2447     {
2448       memmove (outdata, outdata + (s - outdata), n);
2449       outdatalen = n;
2450     }
2451   else
2452     {
2453       err = gpg_error (GPG_ERR_CARD);
2454       log_error ("piv: response does not contain a proper result\n");
2455       goto leave;
2456     }
2457
2458  leave:
2459   if (err)
2460     {
2461       xfree (outdata);
2462       *r_outdata = NULL;
2463       *r_outdatalen = 0;
2464     }
2465   else
2466     {
2467       *r_outdata = outdata;
2468       *r_outdatalen = outdatalen;
2469     }
2470   *r_info = 0;
2471   xfree (apdudata);
2472   xfree (indata_buffer);
2473   return err;
2474 }
2475
2476
2477 /* Check whether a key for DOBJ already exists.  We detect this by
2478  * reading the certificate described by DOBJ.  If FORCE is TRUE a
2479  * diagnositic will be printed but no error returned if the key
2480  * already exists.  The flag GENERATING is used to select a
2481  * diagnositic. */
2482 static gpg_error_t
2483 does_key_exist (app_t app, data_object_t dobj, int generating, int force)
2484 {
2485   void *relptr;
2486   unsigned char *buffer;
2487   size_t buflen;
2488   int found;
2489
2490   relptr = get_one_do (app, dobj->tag, &buffer, &buflen, NULL);
2491   found = (relptr && buflen);
2492   xfree (relptr);
2493
2494   if (found && !force)
2495     {
2496       log_error (_("key already exists\n"));
2497       return gpg_error (GPG_ERR_EEXIST);
2498     }
2499
2500   if (found)
2501     log_info (_("existing key will be replaced\n"));
2502   else if (generating)
2503     log_info (_("generating new key\n"));
2504   else
2505     log_info (_("writing new key\n"));
2506   return 0;
2507 }
2508
2509
2510 /* Helper for do_writekey; here the RSA part.  BUF, BUFLEN, and DEPTH
2511  * are the current parser state of the S-expression with the key. */
2512 static gpg_error_t
2513 writekey_rsa (app_t app, data_object_t dobj, int keyref,
2514               const unsigned char *buf, size_t buflen, int depth)
2515 {
2516   gpg_error_t err;
2517   const unsigned char *tok;
2518   size_t toklen;
2519   int last_depth1, last_depth2;
2520   const unsigned char *rsa_n = NULL;
2521   const unsigned char *rsa_e = NULL;
2522   const unsigned char *rsa_p = NULL;
2523   const unsigned char *rsa_q = NULL;
2524   unsigned char *rsa_dpm1 = NULL;
2525   unsigned char *rsa_dqm1 = NULL;
2526   unsigned char *rsa_qinv = NULL;
2527   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2528   size_t rsa_dpm1_len, rsa_dqm1_len, rsa_qinv_len;
2529   unsigned char *apdudata = NULL;
2530   size_t apdudatalen;
2531   unsigned char tmpl[1];
2532
2533   last_depth1 = depth;
2534   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2535          && depth && depth >= last_depth1)
2536     {
2537       if (tok)
2538         {
2539           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2540           goto leave;
2541         }
2542       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2543         goto leave;
2544
2545       if (tok && toklen == 1)
2546         {
2547           const unsigned char **mpi;
2548           size_t *mpi_len;
2549
2550           switch (*tok)
2551             {
2552             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2553             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2554             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2555             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len; break;
2556             default: mpi = NULL;  mpi_len = NULL; break;
2557             }
2558           if (mpi && *mpi)
2559             {
2560               err = gpg_error (GPG_ERR_DUP_VALUE);
2561               goto leave;
2562             }
2563
2564           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2565             goto leave;
2566           if (tok && mpi)
2567             {
2568               /* Strip off leading zero bytes and save. */
2569               for (;toklen && !*tok; toklen--, tok++)
2570                 ;
2571               *mpi = tok;
2572               *mpi_len = toklen;
2573             }
2574         }
2575       /* Skip until end of list. */
2576       last_depth2 = depth;
2577       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2578              && depth && depth >= last_depth2)
2579         ;
2580       if (err)
2581         goto leave;
2582     }
2583
2584   /* Check that we have all parameters.  */
2585   if (!rsa_n || !rsa_e || !rsa_p || !rsa_q)
2586     {
2587       err = gpg_error (GPG_ERR_BAD_SECKEY);
2588       goto leave;
2589     }
2590   /* Fixme: Shall we check whether  n == pq ? */
2591
2592   if (opt.verbose)
2593     log_info ("RSA private key size is %u bytes\n", (unsigned int)rsa_n_len);
2594
2595   /* Compute the dp, dq and u components.  */
2596   {
2597     gcry_mpi_t mpi_e, mpi_p, mpi_q;
2598     gcry_mpi_t mpi_dpm1 = gcry_mpi_snew (0);
2599     gcry_mpi_t mpi_dqm1 = gcry_mpi_snew (0);
2600     gcry_mpi_t mpi_qinv = gcry_mpi_snew (0);
2601     gcry_mpi_t mpi_tmp  = gcry_mpi_snew (0);
2602
2603     gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
2604     gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
2605     gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
2606
2607     gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
2608     gcry_mpi_invm (mpi_dpm1, mpi_e, mpi_tmp);
2609
2610     gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
2611     gcry_mpi_invm (mpi_dqm1, mpi_e, mpi_tmp);
2612
2613     gcry_mpi_invm (mpi_qinv, mpi_q, mpi_p);
2614
2615     gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dpm1, &rsa_dpm1_len, mpi_dpm1);
2616     gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dqm1, &rsa_dqm1_len, mpi_dqm1);
2617     gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_qinv, &rsa_qinv_len, mpi_qinv);
2618
2619     gcry_mpi_release (mpi_e);
2620     gcry_mpi_release (mpi_p);
2621     gcry_mpi_release (mpi_q);
2622     gcry_mpi_release (mpi_dpm1);
2623     gcry_mpi_release (mpi_dqm1);
2624     gcry_mpi_release (mpi_qinv);
2625     gcry_mpi_release (mpi_tmp);
2626   }
2627
2628   err = concat_tlv_list (1, &apdudata, &apdudatalen,
2629                          (int)0x01, (size_t)rsa_p_len, rsa_p,
2630                          (int)0x02, (size_t)rsa_q_len, rsa_q,
2631                          (int)0x03, (size_t)rsa_dpm1_len, rsa_dpm1,
2632                          (int)0x04, (size_t)rsa_dqm1_len, rsa_dqm1,
2633                          (int)0x05, (size_t)rsa_qinv_len, rsa_qinv,
2634                          (int)0, (size_t)0, NULL);
2635   if (err)
2636     goto leave;
2637
2638   err = iso7816_send_apdu (app->slot,
2639                            -1,         /* Use command chaining.  */
2640                            0,          /* Class */
2641                            0xfe,       /* Ins: Yubikey Import Asym. Key.  */
2642                            PIV_ALGORITHM_RSA, /* P1 */
2643                            keyref,     /* P2 */
2644                            apdudatalen,/* Lc */
2645                            apdudata,   /* data */
2646                            NULL, NULL, NULL);
2647   if (err)
2648     goto leave;
2649
2650   /* Write the public key to the cert object.  */
2651   xfree (apdudata);
2652   err = concat_tlv_list (0, &apdudata, &apdudatalen,
2653                          (int)0x81, (size_t)rsa_n_len, rsa_n,
2654                          (int)0x82, (size_t)rsa_e_len, rsa_e,
2655                          (int)0, (size_t)0, NULL);
2656
2657   if (err)
2658     goto leave;
2659   tmpl[0] = PIV_ALGORITHM_RSA;
2660   err = put_data (app->slot, dobj->tag,
2661                   (int)0x80,   (size_t)1, tmpl,
2662                   (int)0x7f49, (size_t)apdudatalen, apdudata,
2663                   (int)0,      (size_t)0, NULL);
2664
2665  leave:
2666   xfree (rsa_dpm1);
2667   xfree (rsa_dqm1);
2668   xfree (rsa_qinv);
2669   xfree (apdudata);
2670   return err;
2671 }
2672
2673
2674 /* Helper for do_writekey; here the ECC part.  BUF, BUFLEN, and DEPTH
2675  * are the current parser state of the S-expression with the key. */
2676 static gpg_error_t
2677 writekey_ecc (app_t app, data_object_t dobj, int keyref,
2678               const unsigned char *buf, size_t buflen, int depth)
2679 {
2680   gpg_error_t err;
2681   const unsigned char *tok;
2682   size_t toklen;
2683   int last_depth1, last_depth2;
2684   int mechanism = 0;
2685   const unsigned char *ecc_q = NULL;
2686   const unsigned char *ecc_d = NULL;
2687   size_t ecc_q_len, ecc_d_len;
2688   unsigned char *apdudata = NULL;
2689   size_t apdudatalen;
2690   unsigned char tmpl[1];
2691
2692   last_depth1 = depth;
2693   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2694          && depth && depth >= last_depth1)
2695     {
2696       if (tok)
2697         {
2698           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2699           goto leave;
2700         }
2701       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2702         goto leave;
2703
2704       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
2705         {
2706           char *name;
2707           const char *xname;
2708
2709           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2710             goto leave;
2711
2712           name = xtrymalloc (toklen+1);
2713           if (!name)
2714             {
2715               err = gpg_error_from_syserror ();
2716               goto leave;
2717             }
2718           memcpy (name, tok, toklen);
2719           name[toklen] = 0;
2720           /* Canonicalize the curve name.  We use the openpgp
2721            * functions here because Libgcrypt has no generic curve
2722            * alias lookup feature and the PIV suppotred curves alre
2723            * also supported by OpenPGP.  */
2724           xname = openpgp_oid_to_curve (openpgp_curve_to_oid (name, NULL), 0);
2725           xfree (name);
2726
2727           if (xname && !strcmp (xname, "nistp256"))
2728             mechanism = PIV_ALGORITHM_ECC_P256;
2729           else if (xname && !strcmp (xname, "nistp384"))
2730             mechanism = PIV_ALGORITHM_ECC_P384;
2731           else
2732             {
2733               err = gpg_error (GPG_ERR_UNKNOWN_CURVE);
2734               goto leave;
2735             }
2736         }
2737       else if (tok && toklen == 1)
2738         {
2739           const unsigned char **mpi;
2740           size_t *mpi_len;
2741
2742           switch (*tok)
2743             {
2744             case 'q': mpi = &ecc_q; mpi_len = &ecc_q_len; break;
2745             case 'd': mpi = &ecc_d; mpi_len = &ecc_d_len; break;
2746             default:  mpi = NULL;  mpi_len = NULL; break;
2747             }
2748           if (mpi && *mpi)
2749             {
2750               err = gpg_error (GPG_ERR_DUP_VALUE);
2751               goto leave;
2752             }
2753
2754           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2755             goto leave;
2756           if (tok && mpi)
2757             {
2758               /* Strip off leading zero bytes and save. */
2759               for (;toklen && !*tok; toklen--, tok++)
2760                 ;
2761               *mpi = tok;
2762               *mpi_len = toklen;
2763             }
2764         }
2765       /* Skip until end of list. */
2766       last_depth2 = depth;
2767       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2768              && depth && depth >= last_depth2)
2769         ;
2770       if (err)
2771         goto leave;
2772     }
2773
2774   /* Check that we have all parameters.  */
2775   if (!mechanism || !ecc_q || !ecc_d)
2776     {
2777       err = gpg_error (GPG_ERR_BAD_SECKEY);
2778       goto leave;
2779     }
2780
2781   if (opt.verbose)
2782     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
2783
2784   err = concat_tlv_list (1, &apdudata, &apdudatalen,
2785                          (int)0x06, (size_t)ecc_d_len, ecc_d,
2786                          (int)0, (size_t)0, NULL);
2787   if (err)
2788     goto leave;
2789
2790   err = iso7816_send_apdu (app->slot,
2791                            -1,         /* Use command chaining.  */
2792                            0,          /* Class */
2793                            0xfe,       /* Ins: Yubikey Import Asym. Key.  */
2794                            mechanism,  /* P1 */
2795                            keyref,     /* P2 */
2796                            apdudatalen,/* Lc */
2797                            apdudata,   /* data */
2798                            NULL, NULL, NULL);
2799   if (err)
2800     goto leave;
2801
2802   /* Write the public key to the cert object.  */
2803   xfree (apdudata);
2804   err = concat_tlv_list (0, &apdudata, &apdudatalen,
2805                          (int)0x86, (size_t)ecc_q_len, ecc_q,
2806                          (int)0, (size_t)0, NULL);
2807
2808   if (err)
2809     goto leave;
2810   tmpl[0] = mechanism;
2811   err = put_data (app->slot, dobj->tag,
2812                   (int)0x80,   (size_t)1, tmpl,
2813                   (int)0x7f49, (size_t)apdudatalen, apdudata,
2814                   (int)0,      (size_t)0, NULL);
2815
2816
2817  leave:
2818   xfree (apdudata);
2819   return err;
2820 }
2821
2822
2823 /* Write a key to a slot.  This command requires proprietary
2824  * extensions of the PIV specification and is thus only implemnted for
2825  * supported card types.  The input is a canonical encoded
2826  * S-expression with the secret key in KEYDATA and its length (for
2827  * assertion) in KEYDATALEN.  KEYREFSTR needs to be the usual 2
2828  * hexdigit slot number prefixed with "PIV."  PINCB and PINCB_ARG are
2829  * not used for PIV cards.
2830  *
2831  * Supported FLAGS are:
2832  *   APP_WRITEKEY_FLAG_FORCE   Overwrite existing key.
2833  */
2834 static gpg_error_t
2835 do_writekey (app_t app, ctrl_t ctrl,
2836              const char *keyrefstr, unsigned int flags,
2837              gpg_error_t (*pincb)(void*, const char *, char **),
2838              void *pincb_arg,
2839              const unsigned char *keydata, size_t keydatalen)
2840 {
2841   gpg_error_t err;
2842   int force = !!(flags & APP_WRITEKEY_FLAG_FORCE);
2843   data_object_t dobj;
2844   int keyref;
2845   const unsigned char *buf, *tok;
2846   size_t buflen, toklen;
2847   int depth;
2848
2849   (void)ctrl;
2850   (void)pincb;
2851   (void)pincb_arg;
2852
2853   if (!app->app_local->flags.yubikey)
2854     {
2855       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2856       goto leave;
2857     }
2858
2859   /* Check keyref and test whether a key already exists.  */
2860   dobj = find_dobj_by_keyref (app, keyrefstr);
2861   if ((keyref = keyref_from_dobj (dobj)) == -1)
2862     {
2863       err = gpg_error (GPG_ERR_INV_ID);
2864       goto leave;
2865     }
2866   err = does_key_exist (app, dobj, 0, force);
2867   if (err)
2868     goto leave;
2869
2870   /* Parse the S-expression with the key. */
2871   buf = keydata;
2872   buflen = keydatalen;
2873   depth = 0;
2874   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2875     goto leave;
2876   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2877     goto leave;
2878   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2879     {
2880       if (!tok)
2881         ;
2882       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2883         log_info ("protected-private-key passed to writekey\n");
2884       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2885         log_info ("shadowed-private-key passed to writekey\n");
2886       err = gpg_error (GPG_ERR_BAD_SECKEY);
2887       goto leave;
2888     }
2889   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2890     goto leave;
2891   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2892     goto leave;
2893
2894   /* First clear an existing key.  We do this by writing an empty 7f49
2895    * tag.  This will return GPG_ERR_NO_PUBKEY on a later read.  */
2896   flush_cached_data (app, dobj->tag);
2897   err = put_data (app->slot, dobj->tag,
2898                   (int)0x7f49, (size_t)0, "",
2899                   (int)0,      (size_t)0, NULL);
2900   if (err)
2901     {
2902       log_error ("piv: failed to clear the cert DO %s: %s\n",
2903                  dobj->keyref, gpg_strerror (err));
2904       goto leave;
2905     }
2906
2907   /* Divert to the algo specific implementation.  */
2908   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
2909     err = writekey_rsa (app, dobj, keyref, buf, buflen, depth);
2910   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
2911     err = writekey_ecc (app, dobj, keyref, buf, buflen, depth);
2912   else
2913     err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2914
2915   if (err)
2916     {
2917       /* A PIN is not required, thus use a better error code.  */
2918       if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
2919         err = gpg_error (GPG_ERR_NO_AUTH);
2920       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2921     }
2922
2923  leave:
2924   return err;
2925 }
2926
2927
2928 /* Parse an RSA response object, consisting of the content of tag
2929  * 0x7f49, into a gcrypt s-expression object and store that R_SEXP.
2930  * On error NULL is stored at R_SEXP. */
2931 static gpg_error_t
2932 genkey_parse_rsa (const unsigned char *data, size_t datalen,
2933                   gcry_sexp_t *r_sexp)
2934 {
2935   gpg_error_t err;
2936   const unsigned char *m, *e;
2937   unsigned char *mbuf = NULL;
2938   unsigned char *ebuf = NULL;
2939   size_t mlen, elen;
2940
2941   *r_sexp = NULL;
2942
2943   m = find_tlv (data, datalen, 0x0081, &mlen);
2944   if (!m)
2945     {
2946       log_error (_("response does not contain the RSA modulus\n"));
2947       err = gpg_error (GPG_ERR_CARD);
2948       goto leave;
2949     }
2950
2951   e = find_tlv (data, datalen, 0x0082, &elen);
2952   if (!e)
2953     {
2954       log_error (_("response does not contain the RSA public exponent\n"));
2955       err = gpg_error (GPG_ERR_CARD);
2956       goto leave;
2957     }
2958
2959   for (; mlen && !*m; mlen--, m++) /* Strip leading zeroes */
2960     ;
2961   for (; elen && !*e; elen--, e++) /* Strip leading zeroes */
2962     ;
2963
2964   mbuf = xtrymalloc (mlen + 1);
2965   if (!mbuf)
2966     {
2967       err = gpg_error_from_syserror ();
2968       goto leave;
2969     }
2970   /* Prepend numbers with a 0 if needed.  */
2971   if (mlen && (*m & 0x80))
2972     {
2973       *mbuf = 0;
2974       memcpy (mbuf+1, m, mlen);
2975       mlen++;
2976     }
2977   else
2978     memcpy (mbuf, m, mlen);
2979
2980   ebuf = xtrymalloc (elen + 1);
2981   if (!ebuf)
2982     {
2983       err = gpg_error_from_syserror ();
2984       goto leave;
2985     }
2986   /* Prepend numbers with a 0 if needed.  */
2987   if (elen && (*e & 0x80))
2988     {
2989       *ebuf = 0;
2990       memcpy (ebuf+1, e, elen);
2991       elen++;
2992     }
2993   else
2994     memcpy (ebuf, e, elen);
2995
2996   err = gcry_sexp_build (r_sexp, NULL, "(public-key(rsa(n%b)(e%b)))",
2997                          (int)mlen, mbuf, (int)elen, ebuf);
2998
2999  leave:
3000   xfree (mbuf);
3001   xfree (ebuf);
3002   return err;
3003 }
3004
3005
3006 /* Parse an ECC response object, consisting of the content of tag
3007  * 0x7f49, into a gcrypt s-expression object and store that R_SEXP.
3008  * On error NULL is stored at R_SEXP.  MECHANISM specifies the
3009  * curve.  */
3010 static gpg_error_t
3011 genkey_parse_ecc (const unsigned char *data, size_t datalen, int mechanism,
3012                   gcry_sexp_t *r_sexp)
3013 {
3014   gpg_error_t err;
3015   const unsigned char *ecc_q;
3016   size_t ecc_qlen;
3017   const char *curve;
3018
3019   *r_sexp = NULL;
3020
3021   ecc_q = find_tlv (data, datalen, 0x0086, &ecc_qlen);
3022   if (!ecc_q)
3023     {
3024       log_error (_("response does not contain the EC public key\n"));
3025       err = gpg_error (GPG_ERR_CARD);
3026       goto leave;
3027     }
3028
3029   if (mechanism == PIV_ALGORITHM_ECC_P256)
3030     curve = "nistp256";
3031   else if (mechanism == PIV_ALGORITHM_ECC_P384)
3032     curve = "nistp384";
3033   else
3034     {
3035       err = gpg_error (GPG_ERR_BUG); /* Call with wrong parameters.  */
3036       goto leave;
3037     }
3038
3039
3040   err = gcry_sexp_build (r_sexp, NULL, "(public-key(ecc(curve%s)(q%b)))",
3041                          curve, (int)ecc_qlen, ecc_q);
3042
3043  leave:
3044   return err;
3045 }
3046
3047
3048 /* Create a new keypair for KEYREF.  If KEYTYPE is NULL a default
3049  * keytype is selected, else it may be one of the strings:
3050  *  "rsa2048", "nistp256, or "nistp384".
3051  *
3052  * Supported FLAGS are:
3053  *   APP_GENKEY_FLAG_FORCE   Overwrite existing key.
3054  *
3055  * Note that CREATETIME is not used for PIV cards.
3056  *
3057  * Because there seems to be no way to read the public key we need to
3058  * retrieve it from a certificate.  The GnuPG system however requires
3059  * the use of app_readkey to fetch the public key from the card to
3060  * create the certificate; to support this we temporary store the
3061  * generated public key in the local context for use by app_readkey.
3062  */
3063 static gpg_error_t
3064 do_genkey (app_t app, ctrl_t ctrl, const char *keyrefstr, const char *keytype,
3065            unsigned int flags, time_t createtime,
3066            gpg_error_t (*pincb)(void*, const char *, char **),
3067            void *pincb_arg)
3068 {
3069   gpg_error_t err;
3070   data_object_t dobj;
3071   unsigned char *buffer = NULL;
3072   size_t buflen;
3073   int force = !!(flags & APP_GENKEY_FLAG_FORCE);
3074   int mechanism;
3075   time_t start_at;
3076   int keyref;
3077   unsigned char tmpl[5];
3078   size_t tmpllen;
3079   const unsigned char *keydata;
3080   size_t keydatalen;
3081
3082   (void)ctrl;
3083   (void)createtime;
3084   (void)pincb;
3085   (void)pincb_arg;
3086
3087   if (!keytype)
3088     keytype = "rsa2048";
3089
3090   if (!strcmp (keytype, "rsa2048"))
3091     mechanism = PIV_ALGORITHM_RSA;
3092   else if (!strcmp (keytype, "nistp256"))
3093     mechanism = PIV_ALGORITHM_ECC_P256;
3094   else if (!strcmp (keytype, "nistp384"))
3095     mechanism = PIV_ALGORITHM_ECC_P384;
3096   else
3097     return gpg_error (GPG_ERR_UNKNOWN_CURVE);
3098
3099   /* We flush the cache to increase the I/O traffic before a key
3100    * generation.  This _might_ help the card to gather more entropy
3101    * and is anyway a prerequisite for does_key_exist. */
3102   flush_cached_data (app, 0);
3103
3104   /* Check whether a key already exists.  */
3105   dobj = find_dobj_by_keyref (app, keyrefstr);
3106   if ((keyref = keyref_from_dobj (dobj)) == -1)
3107     {
3108       err = gpg_error (GPG_ERR_INV_ID);
3109       goto leave;
3110     }
3111   err = does_key_exist (app, dobj, 1, force);
3112   if (err)
3113     goto leave;
3114
3115
3116   /* Create the key. */
3117   log_info (_("please wait while key is being generated ...\n"));
3118   start_at = time (NULL);
3119   tmpl[0] = 0xac;
3120   tmpl[1] = 3;
3121   tmpl[2] = 0x80;
3122   tmpl[3] = 1;
3123   tmpl[4] = mechanism;
3124   tmpllen = 5;
3125   err = iso7816_generate_keypair (app->slot, 0, 0, keyref,
3126                                   tmpl, tmpllen, 0, &buffer, &buflen);
3127   if (err)
3128     {
3129       /* A PIN is not required, thus use a better error code.  */
3130       if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
3131         err = gpg_error (GPG_ERR_NO_AUTH);
3132       log_error (_("generating key failed\n"));
3133       return err;
3134     }
3135
3136   {
3137     int nsecs = (int)(time (NULL) - start_at);
3138     log_info (ngettext("key generation completed (%d second)\n",
3139                        "key generation completed (%d seconds)\n",
3140                        nsecs), nsecs);
3141   }
3142
3143   /* Parse the result and store it as an s-expression in a dedicated
3144    * cache for later retrieval by app_readkey.  */
3145   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3146   if (!keydata || !keydatalen)
3147     {
3148       err = gpg_error (GPG_ERR_CARD);
3149       log_error (_("response does not contain the public key data\n"));
3150       goto leave;
3151     }
3152
3153   tmpl[0] = mechanism;
3154   flush_cached_data (app, dobj->tag);
3155   err = put_data (app->slot, dobj->tag,
3156                   (int)0x80,   (size_t)1,          tmpl,
3157                   (int)0x7f49, (size_t)keydatalen, keydata,
3158                   (int)0,      (size_t)0,          NULL);
3159   if (err)
3160     {
3161       log_error ("piv: failed to write key to the cert DO %s: %s\n",
3162                  dobj->keyref, gpg_strerror (err));
3163       goto leave;
3164     }
3165
3166  leave:
3167   xfree (buffer);
3168   return err;
3169 }
3170
3171
3172 /* Write the certificate (CERT,CERTLEN) to the card at CERTREFSTR.
3173  * CERTREFSTR is either the OID of the certificate's container data
3174  * object or of the form "PIV.<two_hexdigit_keyref>". */
3175 static gpg_error_t
3176 do_writecert (app_t app, ctrl_t ctrl,
3177               const char *certrefstr,
3178               gpg_error_t (*pincb)(void*, const char *, char **),
3179               void *pincb_arg,
3180               const unsigned char *cert, size_t certlen)
3181 {
3182   gpg_error_t err;
3183   data_object_t dobj;
3184   unsigned char *pk = NULL;
3185   unsigned char *orig_pk = NULL;
3186   size_t pklen, orig_pklen;
3187
3188   (void)ctrl;
3189   (void)pincb;     /* Not used; instead authentication is needed.  */
3190   (void)pincb_arg;
3191
3192   if (!certlen)
3193     return gpg_error (GPG_ERR_INV_CERT_OBJ);
3194
3195   dobj = find_dobj_by_keyref (app, certrefstr);
3196   if (!dobj || !*dobj->keyref)
3197     return gpg_error (GPG_ERR_INV_ID);
3198
3199   flush_cached_data (app, dobj->tag);
3200
3201   /* Check that the public key parameters from the certificate match
3202    * an already stored key.  Note that we do not allow writing a
3203    * certificate if no key has yet been created (GPG_ERR_NOT_FOUND) or
3204    * if there is a problem reading the public key from the certificate
3205    * GPG_ERR_NO_PUBKEY).  We enforce this because otherwise the only
3206    * way to detect whether a key exists is by trying to use that
3207    * key. */
3208   err = do_readkey (app, certrefstr, &orig_pk, &orig_pklen);
3209   if (err)
3210     {
3211       if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
3212         err = gpg_error (GPG_ERR_NO_SECKEY); /* Use a better error code.  */
3213       goto leave;
3214     }
3215
3216   /* Compare pubkeys.  */
3217   err = app_help_pubkey_from_cert (cert, certlen, &pk, &pklen);
3218   if (err)
3219     goto leave;  /* No public key in new certificate. */
3220   if (orig_pklen != pklen || memcmp (orig_pk, pk, pklen))
3221     {
3222       err = gpg_error (GPG_ERR_CONFLICT);
3223       goto leave;
3224     }
3225
3226   err = put_data (app->slot, dobj->tag,
3227                   (int)0x70, (size_t)certlen, cert,/* Certificate */
3228                   (int)0x71, (size_t)1,       "",  /* No compress */
3229                   (int)0xfe, (size_t)0,       "",  /* Empty LRC. */
3230                   (int)0,    (size_t)0,       NULL);
3231   /* A PIN is not required, thus use a better error code.  */
3232   if (gpg_err_code (err) == GPG_ERR_BAD_PIN)
3233     err = gpg_error (GPG_ERR_NO_AUTH);
3234   if (err)
3235     log_error ("piv: failed to write cert to %s: %s\n",
3236                dobj->keyref, gpg_strerror (err));
3237
3238  leave:
3239   xfree (pk);
3240   xfree (orig_pk);
3241   return err;
3242 }
3243
3244
3245 /* Select the PIV application on the card in SLOT.  This function must
3246  * be used before any other PIV application functions. */
3247 gpg_error_t
3248 app_select_piv (app_t app)
3249 {
3250   static char const aid[] = { 0xA0, 0x00, 0x00, 0x03, 0x08, /* RID=NIST */
3251                               0x00, 0x00, 0x10, 0x00        /* PIX=PIV  */ };
3252   int slot = app->slot;
3253   gpg_error_t err;
3254   unsigned char *apt = NULL;
3255   size_t aptlen;
3256   const unsigned char *s;
3257   size_t n;
3258
3259   /* Note that we select using the AID without the 2 octet version
3260    * number.  This allows for better reporting of future specs.  We
3261    * need to use the use-zero-for-P2-flag.  */
3262   err = iso7816_select_application_ext (slot, aid, sizeof aid, 0x0001,
3263                                         &apt, &aptlen);
3264   if (err)
3265     goto leave;
3266
3267   app->apptype = "PIV";
3268   app->did_chv1 = 0;
3269   app->did_chv2 = 0;
3270   app->did_chv3 = 0;
3271   app->app_local = NULL;
3272
3273   /* Check the Application Property Template.  */
3274   if (opt.verbose)
3275     {
3276       /* We  use a separate log_info to avoid the "DBG:" prefix.  */
3277       log_info ("piv: APT=");
3278       log_printhex (apt, aptlen, "");
3279     }
3280
3281   s = find_tlv (apt, aptlen, 0x4F, &n);
3282   if (!s || n != 6 || memcmp (s, aid+5, 4))
3283     {
3284       /* The PIX does not match.  */
3285       log_error ("piv: missing or invalid DO 0x4F in APT\n");
3286       err = gpg_error (GPG_ERR_CARD);
3287       goto leave;
3288     }
3289   if (s[4] != 1 || s[5] != 0)
3290     {
3291       log_error ("piv: unknown PIV version %u.%u\n", s[4], s[5]);
3292       err = gpg_error (GPG_ERR_CARD);
3293       goto leave;
3294     }
3295   app->appversion = ((s[4] << 8) | s[5]);
3296
3297   s = find_tlv (apt, aptlen, 0x79, &n);
3298   if (!s || n < 7)
3299     {
3300       log_error ("piv: missing or invalid DO 0x79 in APT\n");
3301       err = gpg_error (GPG_ERR_CARD);
3302       goto leave;
3303     }
3304   s = find_tlv (s, n, 0x4F, &n);
3305   if (!s || n != 5 || memcmp (s, aid, 5))
3306     {
3307       /* The RID does not match.  */
3308       log_error ("piv: missing or invalid DO 0x79.4F in APT\n");
3309       err = gpg_error (GPG_ERR_CARD);
3310       goto leave;
3311     }
3312
3313   app->app_local = xtrycalloc (1, sizeof *app->app_local);
3314   if (!app->app_local)
3315     {
3316       err = gpg_error_from_syserror ();
3317       goto leave;
3318     }
3319
3320   if (app->cardtype && !strcmp (app->cardtype, "yubikey"))
3321     app->app_local->flags.yubikey = 1;
3322
3323
3324   /* FIXME: Parse the optional and conditional DOs in the APT.  */
3325
3326   if (opt.verbose)
3327     dump_all_do (slot);
3328
3329   app->fnc.deinit = do_deinit;
3330   app->fnc.learn_status = do_learn_status;
3331   app->fnc.readcert = do_readcert;
3332   app->fnc.readkey = do_readkey;
3333   app->fnc.getattr = do_getattr;
3334   app->fnc.setattr = do_setattr;
3335   app->fnc.writecert = do_writecert;
3336   app->fnc.writekey = do_writekey;
3337   app->fnc.genkey = do_genkey;
3338   app->fnc.sign = do_sign;
3339   app->fnc.auth = do_auth;
3340   app->fnc.decipher = do_decipher;
3341   app->fnc.change_pin = do_change_chv;
3342   app->fnc.check_pin = do_check_chv;
3343
3344
3345 leave:
3346   xfree (apt);
3347   if (err)
3348     do_deinit (app);
3349   return err;
3350 }