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