Reworked the estream memory buffer allocation.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  * Copyright (C) 2003, 2004, 2005, 2007, 2008,
3  *               2009 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  *
20  * $Id$
21  */
22
23 /* Some notes:
24
25    CHV means Card Holder Verification and is nothing else than a PIN
26    or password.  That term seems to have been used originally with GSM
27    cards.  Version v2 of the specs changes the term to the clearer
28    term PW for password.  We use the terms here interchangeable
29    because we do not want to change existing strings i18n wise.
30
31    Version 2 of the specs also drops the separate PW2 which was
32    required in v1 due to ISO requirements.  It is now possible to have
33    one physical PW but two reference to it so that they can be
34    individually be verified (e.g. to implement a forced verification
35    for one key).  Thus you will noticed the use of PW2 with the verify
36    command but not with change_reference_data because the latter
37    operates directly on the physical PW.
38
39    The Reset Code (RC) as implemented by v2 cards uses the same error
40    counter as the PW2 of v1 cards.  By default no RC is set and thus
41    that error counter is set to 0.  After setting the RC the error
42    counter will be initialized to 3.
43
44  */
45
46 #include <config.h>
47 #include <errno.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <assert.h>
52 #include <time.h>
53
54 #if GNUPG_MAJOR_VERSION == 1
55 /* This is used with GnuPG version < 1.9.  The code has been source
56    copied from the current GnuPG >= 1.9  and is maintained over
57    there. */
58 #include "options.h"
59 #include "errors.h"
60 #include "memory.h"
61 #include "util.h"
62 #include "cardglue.h"
63 #else /* GNUPG_MAJOR_VERSION != 1 */
64 #include "scdaemon.h"
65 #endif /* GNUPG_MAJOR_VERSION != 1 */
66
67 #include "i18n.h"
68 #include "iso7816.h"
69 #include "app-common.h"
70 #include "tlv.h"
71
72
73 /* A table describing the DOs of the card.  */
74 static struct {
75   int tag;
76   int constructed;
77   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
78   int binary:1;
79   int dont_cache:1;
80   int flush_on_error:1;
81   int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
82                                  this data object if it is used in 1.1
83                                  and later versions of the card.  This
84                                  does not work with composite DO and
85                                  is currently only useful for the CHV
86                                  status bytes. */
87   int try_extlen:1;           /* Large object; try to use an extended
88                                  length APDU.  */
89   char *desc;
90 } data_objects[] = {
91   { 0x005E, 0,    0, 1, 0, 0, 0, 0, "Login Data" },
92   { 0x5F50, 0,    0, 0, 0, 0, 0, 0, "URL" },
93   { 0x5F52, 0,    0, 1, 0, 0, 0, 0, "Historical Bytes" },
94   { 0x0065, 1,    0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
95   { 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
96   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
97   { 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Sex" },
98   { 0x006E, 1,    0, 1, 0, 0, 0, 0, "Application Related Data" },
99   { 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
100   { 0x0073, 1,    0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
101   { 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
102   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
103   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
104   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
105   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
106   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
107   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
108   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
109   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
110   { 0x007A, 1,    0, 1, 0, 0, 0, 0, "Security Support Template" },
111   { 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
112   { 0x0101, 0,    0, 0, 0, 0, 0, 0, "Private DO 1"},
113   { 0x0102, 0,    0, 0, 0, 0, 0, 0, "Private DO 2"},
114   { 0x0103, 0,    0, 0, 0, 0, 0, 0, "Private DO 3"},
115   { 0x0104, 0,    0, 0, 0, 0, 0, 0, "Private DO 4"},
116   { 0x7F21, 1,    0, 1, 0, 0, 0, 1, "Cardholder certificate"},
117   { 0 }
118 };
119
120
121 /* The format of RSA private keys.  */
122 typedef enum
123   { 
124     RSA_UNKNOWN_FMT,
125     RSA_STD,
126     RSA_STD_N,
127     RSA_CRT,
128     RSA_CRT_N
129   } 
130 rsa_key_format_t;
131
132
133 /* One cache item for DOs.  */
134 struct cache_s {
135   struct cache_s *next;
136   int tag;
137   size_t length;
138   unsigned char data[1];
139 };
140
141
142 /* Object with application (i.e. OpenPGP card) specific data.  */
143 struct app_local_s {
144   /* A linked list with cached DOs.  */
145   struct cache_s *cache;
146   
147   /* Keep track of the public keys.  */
148   struct
149   {
150     int read_done;   /* True if we have at least tried to read them.  */
151     unsigned char *key; /* This is a malloced buffer with a canonical
152                            encoded S-expression encoding a public
153                            key. Might be NULL if key is not
154                            available.  */
155     size_t keylen;      /* The length of the above S-expression.  This
156                            is usually only required for cross checks
157                            because the length of an S-expression is
158                            implicitly available.  */
159   } pk[3];
160
161   unsigned char status_indicator; /* The card status indicator.  */
162
163   /* Keep track of the ISO card capabilities.  */
164   struct
165   {
166     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
167     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
168   } cardcap;
169
170   /* Keep track of extended card capabilities.  */
171   struct 
172   {
173     unsigned int is_v2:1;              /* This is a v2.0 compatible card.  */
174     unsigned int get_challenge:1;
175     unsigned int key_import:1;
176     unsigned int change_force_chv:1;
177     unsigned int private_dos:1;
178     unsigned int algo_attr_change:1;   /* Algorithm attributes changeable.  */
179     unsigned int sm_supported:1;       /* Secure Messaging is supported.  */
180     unsigned int sm_aes128:1;          /* Use AES-128 for SM.  */
181     unsigned int max_certlen_3:16;
182     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.  */
183     unsigned int max_cmd_data:16;      /* Maximum data size for a command.  */
184     unsigned int max_rsp_data:16;      /* Maximum size of a response.  */
185   } extcap;
186
187   /* Flags used to control the application.  */
188   struct
189   {
190     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
191     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
192   } flags;
193
194   struct
195   {
196     unsigned int n_bits;     /* Size of the modulus in bits.  The rest
197                                 of this strucuire is only valid if
198                                 this is not 0.  */
199     unsigned int e_bits;     /* Size of the public exponent in bits.  */
200     rsa_key_format_t format;  
201   } keyattr[3];
202
203 };
204
205
206
207 /***** Local prototypes  *****/
208 static unsigned long convert_sig_counter_value (const unsigned char *value,
209                                                 size_t valuelen);
210 static unsigned long get_sig_counter (app_t app);
211 static gpg_error_t do_auth (app_t app, const char *keyidstr,
212                             gpg_error_t (*pincb)(void*, const char *, char **),
213                             void *pincb_arg,
214                             const void *indata, size_t indatalen,
215                             unsigned char **outdata, size_t *outdatalen);
216
217
218
219
220 \f
221 /* Deconstructor. */
222 static void
223 do_deinit (app_t app)
224 {
225   if (app && app->app_local)
226     {
227       struct cache_s *c, *c2;
228       int i;
229
230       for (c = app->app_local->cache; c; c = c2)
231         {
232           c2 = c->next;
233           xfree (c);
234         }
235
236       for (i=0; i < DIM (app->app_local->pk); i++)
237         {
238           xfree (app->app_local->pk[i].key);
239           app->app_local->pk[i].read_done = 0;
240         }
241       xfree (app->app_local);
242       app->app_local = NULL;
243     }
244 }
245
246
247 /* Wrapper around iso7816_get_data which first tries to get the data
248    from the cache.  With GET_IMMEDIATE passed as true, the cache is
249    bypassed.  With TRY_EXTLEN extended lengths APDUs are use if
250    supported by the card.  */
251 static gpg_error_t
252 get_cached_data (app_t app, int tag, 
253                  unsigned char **result, size_t *resultlen,
254                  int get_immediate, int try_extlen)
255 {
256   gpg_error_t err;
257   int i;
258   unsigned char *p;
259   size_t len;
260   struct cache_s *c;
261   int exmode;
262
263   *result = NULL;
264   *resultlen = 0;
265
266   if (!get_immediate)
267     {
268       for (c=app->app_local->cache; c; c = c->next)
269         if (c->tag == tag)
270           {
271             if(c->length)
272               {
273                 p = xtrymalloc (c->length);
274                 if (!p)
275                   return gpg_error (gpg_err_code_from_errno (errno));
276                 memcpy (p, c->data, c->length);
277                 *result = p;
278               }
279             
280             *resultlen = c->length;
281             
282             return 0;
283           }
284     }
285   
286   if (try_extlen && app->app_local->cardcap.ext_lc_le)
287     exmode = app->app_local->extcap.max_rsp_data;
288   else
289     exmode = 0;
290
291   err = iso7816_get_data (app->slot, exmode, tag, &p, &len);
292   if (err)
293     return err;
294   *result = p;
295   *resultlen = len;
296
297   /* Check whether we should cache this object. */
298   if (get_immediate)
299     return 0;
300
301   for (i=0; data_objects[i].tag; i++)
302     if (data_objects[i].tag == tag)
303       {
304         if (data_objects[i].dont_cache)
305           return 0;
306         break;
307       }
308
309   /* Okay, cache it. */
310   for (c=app->app_local->cache; c; c = c->next)
311     assert (c->tag != tag);
312   
313   c = xtrymalloc (sizeof *c + len);
314   if (c)
315     {
316       memcpy (c->data, p, len);
317       c->length = len;
318       c->tag = tag;
319       c->next = app->app_local->cache;
320       app->app_local->cache = c;
321     }
322
323   return 0;
324 }
325
326 /* Remove DO at TAG from the cache. */
327 static void
328 flush_cache_item (app_t app, int tag)
329 {
330   struct cache_s *c, *cprev;
331   int i;
332
333   if (!app->app_local)
334     return;
335
336   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
337     if (c->tag == tag)
338       {
339         if (cprev)
340           cprev->next = c->next;
341         else
342           app->app_local->cache = c->next;
343         xfree (c);
344
345         for (c=app->app_local->cache; c ; c = c->next)
346           {
347             assert (c->tag != tag); /* Oops: duplicated entry. */
348           }
349         return;
350       }
351
352   /* Try again if we have an outer tag. */
353   for (i=0; data_objects[i].tag; i++)
354     if (data_objects[i].tag == tag && data_objects[i].get_from
355         && data_objects[i].get_from != tag)
356       flush_cache_item (app, data_objects[i].get_from);
357 }
358
359 /* Flush all entries from the cache which might be out of sync after
360    an error. */
361 static void
362 flush_cache_after_error (app_t app)
363 {
364   int i;
365
366   for (i=0; data_objects[i].tag; i++)
367     if (data_objects[i].flush_on_error)
368       flush_cache_item (app, data_objects[i].tag);
369 }
370
371
372 /* Flush the entire cache. */
373 static void
374 flush_cache (app_t app)
375 {
376   if (app && app->app_local)
377     {
378       struct cache_s *c, *c2;
379
380       for (c = app->app_local->cache; c; c = c2)
381         {
382           c2 = c->next;
383           xfree (c);
384         }
385       app->app_local->cache = NULL;
386     }
387 }
388
389
390 /* Get the DO identified by TAG from the card in SLOT and return a
391    buffer with its content in RESULT and NBYTES.  The return value is
392    NULL if not found or a pointer which must be used to release the
393    buffer holding value. */
394 static void *
395 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
396             int *r_rc)
397 {
398   int rc, i;
399   unsigned char *buffer;
400   size_t buflen;
401   unsigned char *value;
402   size_t valuelen;
403   int dummyrc;
404   int exmode;
405
406   if (!r_rc)
407     r_rc = &dummyrc;
408
409   *result = NULL;
410   *nbytes = 0;
411   *r_rc = 0;
412   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
413     ;
414
415   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
416     {
417       if (data_objects[i].try_extlen && app->app_local->cardcap.ext_lc_le)
418         exmode = app->app_local->extcap.max_rsp_data;
419       else
420         exmode = 0;
421       rc = iso7816_get_data (app->slot, exmode, tag, &buffer, &buflen);
422       if (rc)
423         {
424           *r_rc = rc;
425           return NULL;
426         }
427       *result = buffer;
428       *nbytes = buflen;
429       return buffer;
430     }
431
432   value = NULL;
433   rc = -1;
434   if (data_objects[i].tag && data_objects[i].get_from)
435     {
436       rc = get_cached_data (app, data_objects[i].get_from,
437                             &buffer, &buflen,
438                             (data_objects[i].dont_cache 
439                              || data_objects[i].get_immediate_in_v11),
440                             data_objects[i].try_extlen);
441       if (!rc)
442         {
443           const unsigned char *s;
444
445           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
446           if (!s)
447             value = NULL; /* not found */
448           else if (valuelen > buflen - (s - buffer))
449             {
450               log_error ("warning: constructed DO too short\n");
451               value = NULL;
452               xfree (buffer); buffer = NULL;
453             }
454           else
455             value = buffer + (s - buffer);
456         }
457     }
458
459   if (!value) /* Not in a constructed DO, try simple. */
460     {
461       rc = get_cached_data (app, tag, &buffer, &buflen,
462                             (data_objects[i].dont_cache 
463                              || data_objects[i].get_immediate_in_v11),
464                             data_objects[i].try_extlen);
465       if (!rc)
466         {
467           value = buffer;
468           valuelen = buflen;
469         }
470     }
471
472   if (!rc)
473     {
474       *nbytes = valuelen;
475       *result = value;
476       return buffer;
477     }
478   *r_rc = rc;
479   return NULL;
480 }
481
482
483 static void
484 dump_all_do (int slot)
485 {
486   int rc, i, j;
487   unsigned char *buffer;
488   size_t buflen;
489   
490   for (i=0; data_objects[i].tag; i++)
491     {
492       if (data_objects[i].get_from)
493         continue;
494
495       /* We don't try extended length APDU because such large DO would
496          be pretty useless in a log file.  */
497       rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
498       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
499         ;
500       else if (rc) 
501         log_info ("DO `%s' not available: %s\n",
502                   data_objects[i].desc, gpg_strerror (rc));
503       else
504         {
505           if (data_objects[i].binary)
506             {
507               log_info ("DO `%s': ", data_objects[i].desc);
508               log_printhex ("", buffer, buflen);
509             }
510           else
511             log_info ("DO `%s': `%.*s'\n",
512                       data_objects[i].desc,
513                       (int)buflen, buffer); /* FIXME: sanitize */
514
515           if (data_objects[i].constructed)
516             {
517               for (j=0; data_objects[j].tag; j++)
518                 {
519                   const unsigned char *value;
520                   size_t valuelen;
521                   
522                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
523                     continue;
524                   value = find_tlv_unchecked (buffer, buflen,
525                                               data_objects[j].tag, &valuelen);
526                   if (!value)
527                     ; /* not found */
528                   else if (valuelen > buflen - (value - buffer))
529                     log_error ("warning: constructed DO too short\n");
530                   else
531                     {
532                       if (data_objects[j].binary)
533                         {
534                           log_info ("DO `%s': ", data_objects[j].desc);
535                           if (valuelen > 200)
536                             log_info ("[%u]\n", (unsigned int)valuelen);
537                           else
538                             log_printhex ("", value, valuelen);
539                         }
540                       else
541                         log_info ("DO `%s': `%.*s'\n",
542                                   data_objects[j].desc,
543                                   (int)valuelen, value); /* FIXME: sanitize */
544                     }
545                 }
546             }
547         }
548       xfree (buffer); buffer = NULL;
549     }
550 }
551
552
553 /* Count the number of bits, assuming the A represents an unsigned big
554    integer of length LEN bytes. */
555 static unsigned int
556 count_bits (const unsigned char *a, size_t len)
557 {
558   unsigned int n = len * 8;
559   int i;
560
561   for (; len && !*a; len--, a++, n -=8)
562     ;
563   if (len)
564     {
565       for (i=7; i && !(*a & (1<<i)); i--)
566         n--;
567     }
568   return n;
569 }
570
571 /* GnuPG makes special use of the login-data DO, this function parses
572    the login data to store the flags for later use.  It may be called
573    at any time and should be called after changing the login-data DO.
574
575    Everything up to a LF is considered a mailbox or account name.  If
576    the first LF is followed by DC4 (0x14) control sequence are
577    expected up to the next LF.  Control sequences are separated by FS
578    (0x18) and consist of key=value pairs.  There is one key defined:
579
580     F=<flags>
581
582     Were FLAGS is a plain hexadecimal number representing flag values.
583     The lsb is here the rightmost bit.  Defined flags bits are:
584
585       Bit 0 = CHV1 and CHV2 are not syncronized
586       Bit 1 = CHV2 has been been set to the default PIN of "123456"
587               (this implies that bit 0 is also set).
588
589 */
590 static void
591 parse_login_data (app_t app)
592 {
593   unsigned char *buffer, *p;
594   size_t buflen, len;
595   void *relptr;
596
597   /* Set defaults.  */
598   app->app_local->flags.no_sync = 0;
599   app->app_local->flags.def_chv2 = 0;
600
601   /* Read the DO.  */
602   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
603   if (!relptr)
604     return; /* Ooops. */
605   for (; buflen; buflen--, buffer++)
606     if (*buffer == '\n')
607       break;
608   if (buflen < 2 || buffer[1] != '\x14')
609     return; /* No control sequences.  */
610   buflen--;
611   buffer++;
612   do
613     {
614       buflen--;
615       buffer++;
616       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
617         {
618           /* Flags control sequence found.  */
619           int lastdig = 0;
620
621           /* For now we are only interested in the last digit, so skip
622              any leading digits but bail out on invalid characters. */
623           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
624             lastdig = xtoi_1 (p);
625           if (len && !(*p == '\n' || *p == '\x18'))
626             goto next;  /* Invalid characters in field.  */
627           app->app_local->flags.no_sync = !!(lastdig & 1);
628           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
629         }
630     next:
631       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
632         if (*buffer == '\n')
633           buflen = 1; 
634     }
635   while (buflen);
636
637   xfree (relptr);
638 }
639
640 /* Note, that FPR must be at least 20 bytes. */
641 static gpg_error_t 
642 store_fpr (app_t app, int keynumber, u32 timestamp,
643            const unsigned char *m, size_t mlen,
644            const unsigned char *e, size_t elen, 
645            unsigned char *fpr, unsigned int card_version)
646 {
647   unsigned int n, nbits;
648   unsigned char *buffer, *p;
649   int tag, tag2;
650   int rc;
651   
652   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
653     ;
654   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
655     ;
656
657   n = 6 + 2 + mlen + 2 + elen;
658   p = buffer = xtrymalloc (3 + n);
659   if (!buffer)
660     return gpg_error_from_syserror ();
661   
662   *p++ = 0x99;     /* ctb */
663   *p++ = n >> 8;   /* 2 byte length header */
664   *p++ = n;
665   *p++ = 4;        /* key packet version */
666   *p++ = timestamp >> 24;
667   *p++ = timestamp >> 16;
668   *p++ = timestamp >>  8;
669   *p++ = timestamp;
670   *p++ = 1; /* RSA */
671   nbits = count_bits (m, mlen);
672   *p++ = nbits >> 8;
673   *p++ = nbits;
674   memcpy (p, m, mlen); p += mlen;
675   nbits = count_bits (e, elen);
676   *p++ = nbits >> 8;
677   *p++ = nbits;
678   memcpy (p, e, elen); p += elen;
679     
680   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
681
682   xfree (buffer);
683
684   tag = (card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
685   flush_cache_item (app, tag);
686   tag2 = 0xCE + keynumber;
687   flush_cache_item (app, tag2);
688
689   rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
690   if (rc)
691     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
692
693   if (!rc && card_version > 0x0100)
694     {
695       unsigned char buf[4];
696
697       buf[0] = timestamp >> 24;
698       buf[1] = timestamp >> 16;
699       buf[2] = timestamp >>  8;
700       buf[3] = timestamp;
701
702       rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
703       if (rc)
704         log_error (_("failed to store the creation date: %s\n"),
705                    gpg_strerror (rc));
706     }
707
708   return rc;
709 }
710
711        
712 static void
713 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
714                       int number, const unsigned char *fpr)
715 {                      
716   int i;
717   char buf[41];
718   char numbuf[25];
719
720   for (i=0; i < 20 && !fpr[i]; i++)
721     ;
722   if (i==20)
723     return; /* All zero. */
724   bin2hex (fpr, 20, buf);
725   if (number == -1)
726     *numbuf = 0; /* Don't print the key number */
727   else
728     sprintf (numbuf, "%d", number);
729   send_status_info (ctrl, keyword,
730                     numbuf, (size_t)strlen(numbuf),
731                     buf, (size_t)strlen (buf), NULL, 0);
732 }
733
734 static void
735 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
736                           int number, const unsigned char *stamp)
737 {                      
738   char numbuf1[50], numbuf2[50];
739   unsigned long value;
740
741   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
742   if (!value)
743     return;
744   sprintf (numbuf1, "%d", number);
745   sprintf (numbuf2, "%lu", value);
746   send_status_info (ctrl, keyword,
747                     numbuf1, (size_t)strlen(numbuf1),
748                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
749 }
750
751 static void
752 send_key_data (ctrl_t ctrl, const char *name, 
753                const unsigned char *a, size_t alen)
754 {
755   char *buf;
756   
757   buf = bin2hex (a, alen, NULL);
758   if (!buf)
759     {
760       log_error ("memory allocation error in send_key_data\n");
761       return;
762     }
763
764   send_status_info (ctrl, "KEY-DATA",
765                     name, (size_t)strlen(name), 
766                     buf, (size_t)strlen (buf),
767                     NULL, 0);
768   xfree (buf);
769 }
770
771
772 static void
773 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int number)
774 {                      
775   char buffer[200];
776
777   assert (number >=0 && number < DIM(app->app_local->keyattr));
778
779   /* We only support RSA thus the algo identifier is fixed to 1.  */
780   snprintf (buffer, sizeof buffer, "%d 1 %u %u %d",
781             number+1,
782             app->app_local->keyattr[number].n_bits,
783             app->app_local->keyattr[number].e_bits,
784             app->app_local->keyattr[number].format);
785   send_status_direct (ctrl, keyword, buffer);
786 }
787
788
789 /* Implement the GETATTR command.  This is similar to the LEARN
790    command but returns just one value via the status interface. */
791 static gpg_error_t 
792 do_getattr (app_t app, ctrl_t ctrl, const char *name)
793 {
794   static struct {
795     const char *name;
796     int tag;
797     int special;
798   } table[] = {
799     { "DISP-NAME",    0x005B },
800     { "LOGIN-DATA",   0x005E },
801     { "DISP-LANG",    0x5F2D },
802     { "DISP-SEX",     0x5F35 },
803     { "PUBKEY-URL",   0x5F50 },
804     { "KEY-FPR",      0x00C5, 3 },
805     { "KEY-TIME",     0x00CD, 4 },
806     { "KEY-ATTR",     0x0000, -5 },
807     { "CA-FPR",       0x00C6, 3 },
808     { "CHV-STATUS",   0x00C4, 1 }, 
809     { "SIG-COUNTER",  0x0093, 2 },
810     { "SERIALNO",     0x004F, -1 },
811     { "AID",          0x004F },
812     { "EXTCAP",       0x0000, -2 },
813     { "PRIVATE-DO-1", 0x0101 },
814     { "PRIVATE-DO-2", 0x0102 },
815     { "PRIVATE-DO-3", 0x0103 },
816     { "PRIVATE-DO-4", 0x0104 },
817     { "$AUTHKEYID",   0x0000, -3 },
818     { "$DISPSERIALNO",0x0000, -4 },
819     { NULL, 0 }
820   };
821   int idx, i, rc;
822   void *relptr;
823   unsigned char *value;
824   size_t valuelen;
825
826   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
827     ;
828   if (!table[idx].name)
829     return gpg_error (GPG_ERR_INV_NAME); 
830   
831   if (table[idx].special == -1)
832     {
833       /* The serial number is very special.  We could have used the
834          AID DO to retrieve it, but we have it already in the app
835          context and the stamp argument is required anyway which we
836          can't by other means. The AID DO is available anyway but not
837          hex formatted. */
838       char *serial;
839       time_t stamp;
840       char tmp[50];
841
842       if (!app_get_serial_and_stamp (app, &serial, &stamp))
843         {
844           sprintf (tmp, "%lu", (unsigned long)stamp);
845           send_status_info (ctrl, "SERIALNO",
846                             serial, strlen (serial),
847                             tmp, strlen (tmp),
848                             NULL, 0);
849           xfree (serial);
850         }
851       return 0;
852     }
853   if (table[idx].special == -2)
854     {
855       char tmp[100];
856
857       snprintf (tmp, sizeof tmp,
858                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d sm=%d", 
859                 app->app_local->extcap.get_challenge,
860                 app->app_local->extcap.key_import,
861                 app->app_local->extcap.change_force_chv,
862                 app->app_local->extcap.private_dos,
863                 app->app_local->extcap.max_certlen_3,
864                 app->app_local->extcap.algo_attr_change,
865                 (app->app_local->extcap.sm_supported
866                  ? (app->app_local->extcap.sm_aes128? 7 : 2)
867                  : 0));
868       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
869       return 0;
870     }
871   if (table[idx].special == -3)
872     {
873       char const tmp[] = "OPENPGP.3";
874       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
875       return 0;
876     }
877   if (table[idx].special == -4)
878     {
879       char *serial;
880       time_t stamp;
881     
882       if (!app_get_serial_and_stamp (app, &serial, &stamp))
883         {
884           if (strlen (serial) > 16+12)
885             {
886               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
887               xfree (serial);
888               return 0;
889             }
890           xfree (serial);
891         }
892       return gpg_error (GPG_ERR_INV_NAME); 
893     }
894   if (table[idx].special == -5)
895     {
896       for (i=0; i < 3; i++)
897         send_key_attr (ctrl, app, table[idx].name, i);
898       return 0;
899     }
900
901   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
902   if (relptr)
903     {
904       if (table[idx].special == 1)
905         {
906           char numbuf[7*23];
907           
908           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
909             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
910           send_status_info (ctrl, table[idx].name,
911                             numbuf, strlen (numbuf), NULL, 0);
912         }
913       else if (table[idx].special == 2)
914         {
915           char numbuf[50];
916
917           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
918           send_status_info (ctrl, table[idx].name,
919                             numbuf, strlen (numbuf), NULL, 0);
920         }
921       else if (table[idx].special == 3)
922         {
923           if (valuelen >= 60)
924             for (i=0; i < 3; i++)
925               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
926         }
927       else if (table[idx].special == 4)
928         {
929           if (valuelen >= 12)
930             for (i=0; i < 3; i++)
931               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
932         }
933       else
934         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
935
936       xfree (relptr);
937     }
938   return rc;
939 }
940
941 /* Retrieve the fingerprint from the card inserted in SLOT and write
942    the according hex representation to FPR.  Caller must have provide
943    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
944    error code. */
945 #if GNUPG_MAJOR_VERSION > 1
946 static gpg_error_t
947 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
948 {
949   gpg_error_t err = 0;
950   void *relptr;
951   unsigned char *value;
952   size_t valuelen;
953
954   assert (keyno >=0 && keyno <= 2);
955
956   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
957   if (relptr && valuelen >= 60)
958     bin2hex (value+keyno*20, 20, fpr);
959   else
960     err = gpg_error (GPG_ERR_NOT_FOUND);
961   xfree (relptr);
962   return err;
963 }
964 #endif /*GNUPG_MAJOR_VERSION > 1*/
965
966
967 /* Retrieve the public key material for the RSA key, whose fingerprint
968    is FPR, from gpg output, which can be read through the stream FP.
969    The RSA modulus will be stored at the address of M and MLEN, the
970    public exponent at E and ELEN.  Returns zero on success, an error
971    code on failure.  Caller must release the allocated buffers at M
972    and E if the function returns success.  */
973 #if GNUPG_MAJOR_VERSION > 1
974 static gpg_error_t
975 retrieve_key_material (FILE *fp, const char *hexkeyid,
976                        const unsigned char **m, size_t *mlen,
977                        const unsigned char **e, size_t *elen)
978 {
979   gcry_error_t err = 0;
980   char *line = NULL;    /* read_line() buffer. */
981   size_t line_size = 0; /* Helper for for read_line. */
982   int found_key = 0;    /* Helper to find a matching key. */
983   unsigned char *m_new = NULL;
984   unsigned char *e_new = NULL;
985   size_t m_new_n = 0;
986   size_t e_new_n = 0;
987
988   /* Loop over all records until we have found the subkey
989      corresponding to the fingerprint. Inm general the first record
990      should be the pub record, but we don't rely on that.  Given that
991      we only need to look at one key, it is sufficient to compare the
992      keyid so that we don't need to look at "fpr" records. */
993   for (;;)
994     {
995       char *p;
996       char *fields[6];
997       int nfields;
998       size_t max_length;
999       gcry_mpi_t mpi;
1000       int i;
1001
1002       max_length = 4096;
1003       i = read_line (fp, &line, &line_size, &max_length);
1004       if (!i)
1005         break; /* EOF. */
1006       if (i < 0)
1007         {
1008           err = gpg_error_from_syserror ();
1009           goto leave; /* Error. */
1010         }
1011       if (!max_length)
1012         {
1013           err = gpg_error (GPG_ERR_TRUNCATED);
1014           goto leave;  /* Line truncated - we better stop processing.  */
1015         }
1016
1017       /* Parse the line into fields. */
1018       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1019         {
1020           fields[nfields] = p;
1021           p = strchr (p, ':');
1022           if (p)
1023             *(p++) = 0;
1024         }
1025       if (!nfields)
1026         continue; /* No fields at all - skip line.  */
1027
1028       if (!found_key)
1029         {
1030           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1031                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1032             found_key = 1;
1033           continue;
1034         }
1035       
1036       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1037         break; /* Next key - stop.  */
1038
1039       if ( strcmp (fields[0], "pkd") )
1040         continue; /* Not a key data record.  */
1041       i = 0; /* Avoid erroneous compiler warning. */
1042       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1043            || (!i && m_new) || (i && e_new))
1044         {
1045           err = gpg_error (GPG_ERR_GENERAL);
1046           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1047         }
1048       
1049       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1050       if (err)
1051         mpi = NULL;
1052       else if (!i)
1053         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1054       else
1055         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1056       gcry_mpi_release (mpi);
1057       if (err)
1058         goto leave;
1059     }
1060   
1061   if (m_new && e_new)
1062     {
1063       *m = m_new;
1064       *mlen = m_new_n;
1065       m_new = NULL;
1066       *e = e_new;
1067       *elen = e_new_n;
1068       e_new = NULL;
1069     }
1070   else
1071     err = gpg_error (GPG_ERR_GENERAL);
1072
1073  leave:
1074   xfree (m_new);
1075   xfree (e_new);
1076   xfree (line);
1077   return err;
1078 }
1079 #endif /*GNUPG_MAJOR_VERSION > 1*/
1080
1081
1082 /* Get the public key for KEYNO and store it as an S-expresion with
1083    the APP handle.  On error that field gets cleared.  If we already
1084    know about the public key we will just return.  Note that this does
1085    not mean a key is available; this is soley indicated by the
1086    presence of the app->app_local->pk[KEYNO-1].key field.
1087
1088    Note that GnuPG 1.x does not need this and it would be too time
1089    consuming to send it just for the fun of it. However, given that we
1090    use the same code in gpg 1.4, we can't use the gcry S-expresion
1091    here but need to open encode it. */
1092 #if GNUPG_MAJOR_VERSION > 1
1093 static gpg_error_t
1094 get_public_key (app_t app, int keyno)
1095 {
1096   gpg_error_t err = 0;
1097   unsigned char *buffer;
1098   const unsigned char *keydata, *m, *e;
1099   size_t buflen, keydatalen, mlen, elen;
1100   unsigned char *mbuf = NULL;
1101   unsigned char *ebuf = NULL;
1102   char *keybuf = NULL;
1103   char *keybuf_p;
1104
1105   if (keyno < 1 || keyno > 3)
1106     return gpg_error (GPG_ERR_INV_ID);
1107   keyno--;
1108
1109   /* Already cached? */
1110   if (app->app_local->pk[keyno].read_done)
1111     return 0;
1112
1113   xfree (app->app_local->pk[keyno].key);
1114   app->app_local->pk[keyno].key = NULL;
1115   app->app_local->pk[keyno].keylen = 0;
1116
1117   m = e = NULL; /* (avoid cc warning) */
1118
1119   if (app->card_version > 0x0100)
1120     {
1121       int exmode, le_value;
1122
1123       /* We may simply read the public key out of these cards.  */
1124       if (app->app_local->cardcap.ext_lc_le)
1125         {
1126           exmode = 1;    /* Use extended length.  */
1127           le_value = app->app_local->extcap.max_rsp_data;
1128         }
1129       else
1130         {
1131           exmode = 0;
1132           le_value = 256; /* Use legacy value. */
1133         }
1134
1135       err = iso7816_read_public_key 
1136         (app->slot, exmode,
1137          (const unsigned char*)(keyno == 0? "\xB6" :
1138                                 keyno == 1? "\xB8" : "\xA4"), 2,  
1139          le_value,
1140          &buffer, &buflen);
1141       if (err)
1142         {
1143           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1144           goto leave;
1145         }
1146
1147       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1148       if (!keydata)
1149         {
1150           err = gpg_error (GPG_ERR_CARD);
1151           log_error (_("response does not contain the public key data\n"));
1152           goto leave;
1153         }
1154  
1155       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1156       if (!m)
1157         {
1158           err = gpg_error (GPG_ERR_CARD);
1159           log_error (_("response does not contain the RSA modulus\n"));
1160           goto leave;
1161         }
1162       
1163
1164       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1165       if (!e)
1166         {
1167           err = gpg_error (GPG_ERR_CARD);
1168           log_error (_("response does not contain the RSA public exponent\n"));
1169           goto leave;
1170         }
1171
1172       /* Prepend numbers with a 0 if needed.  */
1173       if (mlen && (*m & 0x80))
1174         {
1175           mbuf = xtrymalloc ( mlen + 1);
1176           if (!mbuf)
1177             {
1178               err = gpg_error_from_syserror ();
1179               goto leave;
1180             }
1181           *mbuf = 0;
1182           memcpy (mbuf+1, m, mlen);
1183           mlen++;
1184           m = mbuf;
1185         }
1186       if (elen && (*e & 0x80))
1187         {
1188           ebuf = xtrymalloc ( elen + 1);
1189           if (!ebuf)
1190             {
1191               err = gpg_error_from_syserror ();
1192               goto leave;
1193             }
1194           *ebuf = 0;
1195           memcpy (ebuf+1, e, elen);
1196           elen++;
1197           e = ebuf;
1198         }
1199
1200     }
1201   else
1202     {
1203       /* Due to a design problem in v1.0 cards we can't get the public
1204          key out of these cards without doing a verify on CHV3.
1205          Clearly that is not an option and thus we try to locate the
1206          key using an external helper.
1207
1208          The helper we use here is gpg itself, which should know about
1209          the key in any case.  */
1210
1211       char fpr[41];
1212       char *hexkeyid;
1213       char *command = NULL;
1214       FILE *fp;
1215       int ret;
1216
1217       buffer = NULL; /* We don't need buffer.  */
1218
1219       err = retrieve_fpr_from_card (app, keyno, fpr);
1220       if (err)
1221         {
1222           log_error ("error while retrieving fpr from card: %s\n",
1223                      gpg_strerror (err));
1224           goto leave;
1225         }
1226       hexkeyid = fpr + 24;
1227
1228       ret = estream_asprintf (&command,
1229                               "gpg --list-keys --with-colons --with-key-data '%s'",
1230                               fpr);
1231       if (ret < 0)
1232         {
1233           err = gpg_error_from_syserror ();
1234           goto leave;
1235         }
1236
1237       fp = popen (command, "r");
1238       xfree (command);
1239       if (!fp)
1240         {
1241           err = gpg_error_from_syserror ();
1242           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1243           goto leave;
1244         }
1245
1246       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1247       fclose (fp);
1248       if (err)
1249         {
1250           log_error ("error while retrieving key material through pipe: %s\n",
1251                      gpg_strerror (err));
1252           goto leave;
1253         }
1254     }
1255
1256   /* Allocate a buffer to construct the S-expression.  */
1257   /* FIXME: We should provide a generalized S-expression creation
1258      mechanism. */
1259   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1260   if (!keybuf)
1261     {
1262       err = gpg_error_from_syserror ();
1263       goto leave;
1264     }
1265   
1266   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1267   keybuf_p = keybuf + strlen (keybuf);
1268   memcpy (keybuf_p, m, mlen);
1269   keybuf_p += mlen;
1270   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1271   keybuf_p += strlen (keybuf_p);
1272   memcpy (keybuf_p, e, elen);
1273   keybuf_p += elen;
1274   strcpy (keybuf_p, ")))");
1275   keybuf_p += strlen (keybuf_p);
1276   
1277   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1278   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1279
1280  leave:
1281   /* Set a flag to indicate that we tried to read the key.  */
1282   app->app_local->pk[keyno].read_done = 1;
1283
1284   xfree (buffer);
1285   xfree (mbuf);
1286   xfree (ebuf);
1287   return 0;
1288 }
1289 #endif /* GNUPG_MAJOR_VERSION > 1 */
1290
1291
1292
1293 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1294    This is used by the LEARN command. */
1295 static gpg_error_t
1296 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1297 {
1298   gpg_error_t err = 0;
1299   /* Note that GnuPG 1.x does not need this and it would be too time
1300      consuming to send it just for the fun of it. */
1301 #if GNUPG_MAJOR_VERSION > 1
1302   unsigned char grip[20];
1303   char gripstr[41];
1304   char idbuf[50];
1305
1306   err = get_public_key (app, keyno);
1307   if (err)
1308     goto leave;
1309   
1310   assert (keyno >= 1 && keyno <= 3);
1311   if (!app->app_local->pk[keyno-1].key)
1312     goto leave; /* No such key - ignore. */
1313
1314   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1315                                  app->app_local->pk[keyno-1].keylen,
1316                                  grip);
1317   if (err)
1318     goto leave;
1319   
1320   bin2hex (grip, 20, gripstr);
1321
1322   sprintf (idbuf, "OPENPGP.%d", keyno);
1323   send_status_info (ctrl, "KEYPAIRINFO", 
1324                     gripstr, 40, 
1325                     idbuf, strlen (idbuf), 
1326                     NULL, (size_t)0);
1327
1328  leave:
1329 #endif /* GNUPG_MAJOR_VERSION > 1 */
1330
1331   return err; 
1332 }
1333
1334
1335 /* Handle the LEARN command for OpenPGP.  */
1336 static gpg_error_t
1337 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1338 {
1339   (void)flags;
1340   
1341   do_getattr (app, ctrl, "EXTCAP");
1342   do_getattr (app, ctrl, "DISP-NAME");
1343   do_getattr (app, ctrl, "DISP-LANG");
1344   do_getattr (app, ctrl, "DISP-SEX");
1345   do_getattr (app, ctrl, "PUBKEY-URL");
1346   do_getattr (app, ctrl, "LOGIN-DATA");
1347   do_getattr (app, ctrl, "KEY-FPR");
1348   if (app->card_version > 0x0100)
1349     do_getattr (app, ctrl, "KEY-TIME");
1350   do_getattr (app, ctrl, "CA-FPR");
1351   do_getattr (app, ctrl, "CHV-STATUS");
1352   do_getattr (app, ctrl, "SIG-COUNTER");
1353   if (app->app_local->extcap.private_dos)
1354     {
1355       do_getattr (app, ctrl, "PRIVATE-DO-1");
1356       do_getattr (app, ctrl, "PRIVATE-DO-2");
1357       if (app->did_chv2)
1358         do_getattr (app, ctrl, "PRIVATE-DO-3");
1359       if (app->did_chv3)
1360         do_getattr (app, ctrl, "PRIVATE-DO-4");
1361     }
1362   send_keypair_info (app, ctrl, 1);
1363   send_keypair_info (app, ctrl, 2);
1364   send_keypair_info (app, ctrl, 3);
1365   /* Note: We do not send the Cardholder Certificate, because that is
1366      relativly long and for OpenPGP applications not really needed.  */
1367   return 0;
1368 }
1369
1370
1371 /* Handle the READKEY command for OpenPGP.  On success a canonical
1372    encoded S-expression with the public key will get stored at PK and
1373    its length (for assertions) at PKLEN; the caller must release that
1374    buffer. On error PK and PKLEN are not changed and an error code is
1375    returned.  */
1376 static gpg_error_t
1377 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1378 {
1379 #if GNUPG_MAJOR_VERSION > 1
1380   gpg_error_t err;
1381   int keyno;
1382   unsigned char *buf;
1383
1384   if (!strcmp (keyid, "OPENPGP.1"))
1385     keyno = 1;
1386   else if (!strcmp (keyid, "OPENPGP.2"))
1387     keyno = 2;
1388   else if (!strcmp (keyid, "OPENPGP.3"))
1389     keyno = 3;
1390   else
1391     return gpg_error (GPG_ERR_INV_ID);
1392
1393   err = get_public_key (app, keyno);
1394   if (err)
1395     return err;
1396
1397   buf = app->app_local->pk[keyno-1].key;
1398   if (!buf)
1399     return gpg_error (GPG_ERR_NO_PUBKEY);
1400   *pklen = app->app_local->pk[keyno-1].keylen;;
1401   *pk = xtrymalloc (*pklen);
1402   if (!*pk)
1403     {
1404       err = gpg_error_from_syserror ();
1405       *pklen = 0;
1406       return err;
1407     }
1408   memcpy (*pk, buf, *pklen);
1409   return 0;
1410 #else
1411   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1412 #endif
1413 }
1414
1415 /* Read the standard certificate of an OpenPGP v2 card.  It is
1416    returned in a freshly allocated buffer with that address stored at
1417    CERT and the length of the certificate stored at CERTLEN.  CERTID
1418    needs to be set to "OPENPGP.3".  */
1419 static gpg_error_t
1420 do_readcert (app_t app, const char *certid,
1421              unsigned char **cert, size_t *certlen)
1422 {
1423 #if GNUPG_MAJOR_VERSION > 1
1424   gpg_error_t err;
1425   unsigned char *buffer;
1426   size_t buflen;
1427   void *relptr;
1428
1429   *cert = NULL;
1430   *certlen = 0;
1431   if (strcmp (certid, "OPENPGP.3"))
1432     return gpg_error (GPG_ERR_INV_ID);
1433   if (!app->app_local->extcap.is_v2)
1434     return gpg_error (GPG_ERR_NOT_FOUND);
1435
1436   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1437   if (!relptr)
1438     return gpg_error (GPG_ERR_NOT_FOUND);
1439
1440   if (!buflen)
1441     err = gpg_error (GPG_ERR_NOT_FOUND);
1442   else if (!(*cert = xtrymalloc (buflen)))
1443     err = gpg_error_from_syserror ();
1444   else
1445     {
1446       memcpy (*cert, buffer, buflen);
1447       *certlen = buflen;
1448       err  = 0;
1449     }
1450   xfree (relptr);
1451   return err;
1452 #else
1453   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1454 #endif
1455 }
1456
1457
1458 /* Verify a CHV either using using the pinentry or if possibile by
1459    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1460    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1461    used with CHV1.  PINVALUE is the address of a pointer which will
1462    receive a newly allocated block with the actual PIN (this is useful
1463    in case that PIN shall be used for another verify operation).  The
1464    caller needs to free this value.  If the function returns with
1465    success and NULL is stored at PINVALUE, the caller should take this
1466    as an indication that the keypad has been used.
1467    */
1468 static gpg_error_t
1469 verify_a_chv (app_t app,
1470               gpg_error_t (*pincb)(void*, const char *, char **),
1471               void *pincb_arg,
1472               int chvno, unsigned long sigcount, char **pinvalue)
1473 {
1474   int rc = 0;
1475   char *prompt_buffer = NULL;
1476   const char *prompt;
1477   iso7816_pininfo_t pininfo;
1478   int minlen = 6;
1479
1480   assert (chvno == 1 || chvno == 2);
1481
1482   *pinvalue = NULL;
1483
1484   if (chvno == 2 && app->app_local->flags.def_chv2)
1485     {
1486       /* Special case for def_chv2 mechanism. */
1487       if (opt.verbose)
1488         log_info (_("using default PIN as %s\n"), "CHV2");
1489       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1490       if (rc)
1491         {
1492           /* Verification of CHV2 with the default PIN failed,
1493              although the card pretends to have the default PIN set as
1494              CHV2.  We better disable the def_chv2 flag now. */
1495           log_info (_("failed to use default PIN as %s: %s"
1496                       " - disabling further default use\n"),
1497                     "CHV2", gpg_strerror (rc));
1498           app->app_local->flags.def_chv2 = 0;
1499         }
1500       return rc;
1501     }
1502
1503   memset (&pininfo, 0, sizeof pininfo);
1504   pininfo.mode = 1;
1505   pininfo.minlen = minlen;
1506
1507
1508   if (chvno == 1)
1509     {
1510 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1511       size_t promptsize = strlen (PROMPTSTRING) + 50;
1512
1513       prompt_buffer = xtrymalloc (promptsize);
1514       if (!prompt_buffer)
1515         return gpg_error_from_syserror ();
1516       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1517       prompt = prompt_buffer;
1518 #undef PROMPTSTRING
1519     }
1520   else
1521     prompt = _("||Please enter the PIN");
1522
1523   
1524   if (!opt.disable_keypad
1525       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1526     {
1527       /* The reader supports the verify command through the keypad.
1528          Note that the pincb appends a text to the prompt telling the
1529          user to use the keypad. */
1530       rc = pincb (pincb_arg, prompt, NULL); 
1531       prompt = NULL;
1532       xfree (prompt_buffer); 
1533       prompt_buffer = NULL;
1534       if (rc)
1535         {
1536           log_info (_("PIN callback returned error: %s\n"),
1537                     gpg_strerror (rc));
1538           return rc;
1539         }
1540       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1541       /* Dismiss the prompt. */
1542       pincb (pincb_arg, NULL, NULL);
1543
1544       assert (!*pinvalue);
1545     }
1546   else
1547     {
1548       /* The reader has no keypad or we don't want to use it. */
1549       rc = pincb (pincb_arg, prompt, pinvalue); 
1550       prompt = NULL;
1551       xfree (prompt_buffer); 
1552       prompt_buffer = NULL;
1553       if (rc)
1554         {
1555           log_info (_("PIN callback returned error: %s\n"),
1556                     gpg_strerror (rc));
1557           return rc;
1558         }
1559       
1560       if (strlen (*pinvalue) < minlen)
1561         {
1562           log_error (_("PIN for CHV%d is too short;"
1563                        " minimum length is %d\n"), chvno, minlen);
1564           xfree (*pinvalue);
1565           *pinvalue = NULL;
1566           return gpg_error (GPG_ERR_BAD_PIN);
1567         }
1568
1569       rc = iso7816_verify (app->slot, 0x80+chvno,
1570                            *pinvalue, strlen (*pinvalue));
1571     }
1572   
1573   if (rc)
1574     {
1575       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1576       xfree (*pinvalue);
1577       *pinvalue = NULL;
1578       flush_cache_after_error (app);
1579     }
1580
1581   return rc;
1582 }
1583
1584
1585 /* Verify CHV2 if required.  Depending on the configuration of the
1586    card CHV1 will also be verified. */
1587 static gpg_error_t
1588 verify_chv2 (app_t app,
1589              gpg_error_t (*pincb)(void*, const char *, char **),
1590              void *pincb_arg)
1591 {
1592   int rc;
1593   char *pinvalue;
1594
1595   if (app->did_chv2) 
1596     return 0;  /* We already verified CHV2.  */
1597
1598   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1599   if (rc)
1600     return rc;
1601   app->did_chv2 = 1;
1602   
1603   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1604     {
1605       /* For convenience we verify CHV1 here too.  We do this only if
1606          the card is not configured to require a verification before
1607          each CHV1 controlled operation (force_chv1) and if we are not
1608          using the keypad (PINVALUE == NULL). */
1609       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1610       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1611         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1612       if (rc)
1613         {
1614           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1615           flush_cache_after_error (app);
1616         }
1617       else
1618         app->did_chv1 = 1;
1619     }
1620
1621   xfree (pinvalue);
1622
1623   return rc;
1624 }
1625
1626
1627 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
1628    current sdtate of the card.  */
1629 static gpg_error_t 
1630 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
1631 {
1632   void *relptr;
1633   unsigned char *value;
1634   size_t valuelen;
1635   int remaining;
1636   char *prompt;
1637
1638   *r_prompt = NULL;
1639
1640   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1641   if (!relptr || valuelen < 7)
1642     {
1643       log_error (_("error retrieving CHV status from card\n"));
1644       xfree (relptr);
1645       return gpg_error (GPG_ERR_CARD);
1646     }
1647   if (value[6] == 0)
1648     {
1649       log_info (_("card is permanently locked!\n"));
1650       xfree (relptr);
1651       return gpg_error (GPG_ERR_BAD_PIN);
1652     }
1653   remaining = value[6];
1654   xfree (relptr);
1655   
1656   log_info(_("%d Admin PIN attempts remaining before card"
1657              " is permanently locked\n"), remaining);
1658
1659   if (remaining < 3)
1660     {
1661       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
1662          the start of the string.  Use %%0A to force a linefeed.  */
1663       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
1664                                "[remaining attempts: %d]"), remaining);
1665     }
1666   else
1667     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
1668   
1669   if (!prompt)
1670     return gpg_error_from_syserror ();
1671   
1672   *r_prompt = prompt;
1673   return 0;
1674 }
1675
1676
1677 /* Verify CHV3 if required. */
1678 static gpg_error_t
1679 verify_chv3 (app_t app,
1680              gpg_error_t (*pincb)(void*, const char *, char **),
1681              void *pincb_arg)
1682 {
1683   int rc = 0;
1684
1685 #if GNUPG_MAJOR_VERSION != 1
1686   if (!opt.allow_admin)
1687     {
1688       log_info (_("access to admin commands is not configured\n"));
1689       return gpg_error (GPG_ERR_EACCES);
1690     }
1691 #endif
1692       
1693   if (!app->did_chv3) 
1694     {
1695       iso7816_pininfo_t pininfo;
1696       int minlen = 8;
1697       char *prompt;
1698
1699       memset (&pininfo, 0, sizeof pininfo);
1700       pininfo.mode = 1;
1701       pininfo.minlen = minlen;
1702
1703       rc = build_enter_admin_pin_prompt (app, &prompt);
1704       if (rc)
1705         return rc;
1706
1707       if (!opt.disable_keypad
1708           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1709         {
1710           /* The reader supports the verify command through the keypad. */
1711           rc = pincb (pincb_arg, prompt, NULL); 
1712           xfree (prompt);
1713           prompt = NULL;
1714           if (rc)
1715             {
1716               log_info (_("PIN callback returned error: %s\n"),
1717                         gpg_strerror (rc));
1718               return rc;
1719             }
1720           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1721           /* Dismiss the prompt. */
1722           pincb (pincb_arg, NULL, NULL);
1723         }
1724       else
1725         {
1726           char *pinvalue;
1727
1728           rc = pincb (pincb_arg, prompt, &pinvalue); 
1729           xfree (prompt);
1730           prompt = NULL;
1731           if (rc)
1732             {
1733               log_info (_("PIN callback returned error: %s\n"),
1734                         gpg_strerror (rc));
1735               return rc;
1736             }
1737           
1738           if (strlen (pinvalue) < minlen)
1739             {
1740               log_error (_("PIN for CHV%d is too short;"
1741                            " minimum length is %d\n"), 3, minlen);
1742               xfree (pinvalue);
1743               return gpg_error (GPG_ERR_BAD_PIN);
1744             }
1745           
1746           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1747           xfree (pinvalue);
1748         }
1749       
1750       if (rc)
1751         {
1752           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1753           flush_cache_after_error (app);
1754           return rc;
1755         }
1756       app->did_chv3 = 1;
1757     }
1758   return rc;
1759 }
1760
1761
1762 /* Handle the SETATTR operation. All arguments are already basically
1763    checked. */
1764 static gpg_error_t 
1765 do_setattr (app_t app, const char *name,
1766             gpg_error_t (*pincb)(void*, const char *, char **),
1767             void *pincb_arg,
1768             const unsigned char *value, size_t valuelen)
1769 {
1770   gpg_error_t rc;
1771   int idx;
1772   static struct {
1773     const char *name;
1774     int tag;
1775     int need_chv;
1776     int special;
1777     unsigned int need_v2:1;
1778   } table[] = {
1779     { "DISP-NAME",    0x005B, 3 },
1780     { "LOGIN-DATA",   0x005E, 3, 2 },
1781     { "DISP-LANG",    0x5F2D, 3 },
1782     { "DISP-SEX",     0x5F35, 3 },
1783     { "PUBKEY-URL",   0x5F50, 3 },
1784     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1785     { "CA-FPR-1",     0x00CA, 3 },
1786     { "CA-FPR-2",     0x00CB, 3 },
1787     { "CA-FPR-3",     0x00CC, 3 },
1788     { "PRIVATE-DO-1", 0x0101, 2 },
1789     { "PRIVATE-DO-2", 0x0102, 3 },
1790     { "PRIVATE-DO-3", 0x0103, 2 },
1791     { "PRIVATE-DO-4", 0x0104, 3 },
1792     { "CERT-3",       0x7F21, 3, 0, 1 },
1793     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1794     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1795     { NULL, 0 }
1796   };
1797   int exmode;
1798
1799   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1800     ;
1801   if (!table[idx].name)
1802     return gpg_error (GPG_ERR_INV_NAME); 
1803   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1804     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1805
1806   switch (table[idx].need_chv)
1807     {
1808     case 2:
1809       rc = verify_chv2 (app, pincb, pincb_arg);
1810       break;
1811     case 3:
1812       rc = verify_chv3 (app, pincb, pincb_arg);
1813       break;
1814     default:
1815       rc = 0;
1816     }
1817   if (rc)
1818     return rc;
1819
1820   /* Flush the cache before writing it, so that the next get operation
1821      will reread the data from the card and thus get synced in case of
1822      errors (e.g. data truncated by the card). */
1823   flush_cache_item (app, table[idx].tag);
1824
1825   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
1826     exmode = 1;    /* Use extended length w/o a limit.  */
1827   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1828     exmode = -254; /* Command chaining with max. 254 bytes.  */
1829   else
1830     exmode = 0;
1831   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1832   if (rc)
1833     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1834
1835   if (table[idx].special == 1)
1836     app->force_chv1 = (valuelen && *value == 0);
1837   else if (table[idx].special == 2)
1838     parse_login_data (app);
1839
1840   return rc;
1841 }
1842
1843
1844 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1845    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1846    PINCB and PINCB_ARG are the usual arguments for the pinentry
1847    callback.  */
1848 static gpg_error_t
1849 do_writecert (app_t app, ctrl_t ctrl,
1850               const char *certidstr, 
1851               gpg_error_t (*pincb)(void*, const char *, char **),
1852               void *pincb_arg,
1853               const unsigned char *certdata, size_t certdatalen)
1854 {
1855   (void)ctrl;
1856 #if GNUPG_MAJOR_VERSION > 1
1857   if (strcmp (certidstr, "OPENPGP.3"))
1858     return gpg_error (GPG_ERR_INV_ID);
1859   if (!certdata || !certdatalen)
1860     return gpg_error (GPG_ERR_INV_ARG);
1861   if (!app->app_local->extcap.is_v2)
1862     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1863   if (certdatalen > app->app_local->extcap.max_certlen_3)
1864     return gpg_error (GPG_ERR_TOO_LARGE);
1865   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1866 #else
1867   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1868 #endif
1869 }
1870
1871
1872
1873 /* Handle the PASSWD command.  The following combinations are
1874    possible:
1875
1876     Flags  CHVNO Vers.  Description
1877     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
1878     RESET    1   2      Verify PW3 and set a new PW1.
1879     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
1880     RESET    2   2      Verify PW3 and set a new Reset Code.
1881     RESET    3   any    Returns GPG_ERR_INV_ID.
1882      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
1883      -       1   2      Verify PW1 and set a new PW1.
1884      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
1885      -       2   2      Verify Reset Code and set a new PW1.
1886      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
1887  */
1888 static gpg_error_t 
1889 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1890                unsigned int flags,
1891                gpg_error_t (*pincb)(void*, const char *, char **),
1892                void *pincb_arg)
1893 {
1894   int rc = 0;
1895   int chvno = atoi (chvnostr);
1896   char *resetcode = NULL;
1897   char *oldpinvalue = NULL;
1898   char *pinvalue;
1899   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1900   int set_resetcode = 0;
1901
1902   (void)ctrl;
1903
1904   if (reset_mode && chvno == 3)
1905     {
1906       rc = gpg_error (GPG_ERR_INV_ID);
1907       goto leave;
1908     }
1909
1910   if (!app->app_local->extcap.is_v2)
1911     {
1912       /* Version 1 cards.  */
1913
1914       if (reset_mode || chvno == 3)
1915         {
1916           /* We always require that the PIN is entered. */
1917           app->did_chv3 = 0;
1918           rc = verify_chv3 (app, pincb, pincb_arg);
1919           if (rc)
1920             goto leave;
1921         }
1922       else if (chvno == 1 || chvno == 2)
1923         {
1924           /* On a v1.x card CHV1 and CVH2 should always have the same
1925              value, thus we enforce it here.  */
1926           int save_force = app->force_chv1;
1927           
1928           app->force_chv1 = 0;
1929           app->did_chv1 = 0;
1930           app->did_chv2 = 0;
1931           rc = verify_chv2 (app, pincb, pincb_arg);
1932           app->force_chv1 = save_force;
1933           if (rc)
1934             goto leave;
1935         }
1936       else
1937         {
1938           rc = gpg_error (GPG_ERR_INV_ID);
1939           goto leave;
1940         }
1941     }
1942   else
1943     {
1944       /* Version 2 cards.  */
1945
1946       if (reset_mode)
1947         {
1948           /* To reset a PIN the Admin PIN is required. */
1949           app->did_chv3 = 0;
1950           rc = verify_chv3 (app, pincb, pincb_arg);
1951           if (rc)
1952             goto leave;
1953           
1954           if (chvno == 2)
1955             set_resetcode = 1;
1956         }
1957       else if (chvno == 1 || chvno == 3)
1958         {
1959           int minlen = (chvno ==3)? 8 : 6;
1960           char *promptbuf = NULL;
1961           const char *prompt;
1962
1963           if (chvno == 3)
1964             {
1965               rc = build_enter_admin_pin_prompt (app, &promptbuf);
1966               if (rc)
1967                 goto leave;
1968               prompt = promptbuf;
1969             }
1970           else
1971             prompt = _("||Please enter the PIN");
1972           rc = pincb (pincb_arg, prompt, &oldpinvalue);
1973           xfree (promptbuf);
1974           promptbuf = NULL;
1975           if (rc)
1976             {
1977               log_info (_("PIN callback returned error: %s\n"),
1978                         gpg_strerror (rc));
1979               goto leave;
1980             }
1981
1982           if (strlen (oldpinvalue) < minlen)
1983             {
1984               log_info (_("PIN for CHV%d is too short;"
1985                           " minimum length is %d\n"), chvno, minlen);
1986               rc = gpg_error (GPG_ERR_BAD_PIN);
1987               goto leave;
1988             }
1989         }
1990       else if (chvno == 2)
1991         {
1992           /* There is no PW2 for v2 cards.  We use this condition to
1993              allow a PW reset using the Reset Code.  */
1994           void *relptr;
1995           unsigned char *value;
1996           size_t valuelen;
1997           int remaining;
1998           int minlen = 8;
1999
2000           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2001           if (!relptr || valuelen < 7)
2002             {
2003               log_error (_("error retrieving CHV status from card\n"));
2004               xfree (relptr);
2005               rc = gpg_error (GPG_ERR_CARD);
2006               goto leave;
2007             }
2008           remaining = value[5];
2009           xfree (relptr);
2010           if (!remaining)
2011             {
2012               log_error (_("Reset Code not or not anymore available\n"));
2013               rc = gpg_error (GPG_ERR_BAD_PIN);
2014               goto leave;
2015             }          
2016           
2017           rc = pincb (pincb_arg,
2018                       _("||Please enter the Reset Code for the card"),
2019                       &resetcode); 
2020           if (rc)
2021             {
2022               log_info (_("PIN callback returned error: %s\n"), 
2023                         gpg_strerror (rc));
2024               goto leave;
2025             }
2026           if (strlen (resetcode) < minlen)
2027             {
2028               log_info (_("Reset Code is too short; minimum length is %d\n"),
2029                         minlen);
2030               rc = gpg_error (GPG_ERR_BAD_PIN);
2031               goto leave;
2032             }
2033         }
2034       else
2035         {
2036           rc = gpg_error (GPG_ERR_INV_ID);
2037           goto leave;
2038         }
2039     }
2040
2041   if (chvno == 3)
2042     app->did_chv3 = 0;
2043   else
2044     app->did_chv1 = app->did_chv2 = 0;
2045
2046   /* TRANSLATORS: Do not translate the "|*|" prefixes but
2047      keep it at the start of the string.  We need this elsewhere
2048      to get some infos on the string. */
2049   rc = pincb (pincb_arg, 
2050               set_resetcode? _("|RN|New Reset Code") :
2051               chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
2052               &pinvalue); 
2053   if (rc)
2054     {
2055       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2056       goto leave;
2057     }
2058
2059
2060   if (resetcode)
2061     {
2062       char *buffer;
2063
2064       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2065       if (!buffer)
2066         rc = gpg_error_from_syserror ();
2067       else
2068         {
2069           strcpy (stpcpy (buffer, resetcode), pinvalue);
2070           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2071                                                     buffer, strlen (buffer));
2072           wipememory (buffer, strlen (buffer));
2073           xfree (buffer);
2074         }
2075     }
2076   else if (set_resetcode)
2077     {
2078       if (strlen (pinvalue) < 8)
2079         {
2080           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2081           rc = gpg_error (GPG_ERR_BAD_PIN);
2082         }
2083       else
2084         rc = iso7816_put_data (app->slot, 0, 0xD3,
2085                                pinvalue, strlen (pinvalue));
2086     }
2087   else if (reset_mode)
2088     {
2089       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2090                                         pinvalue, strlen (pinvalue));
2091       if (!rc && !app->app_local->extcap.is_v2)
2092         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2093                                           pinvalue, strlen (pinvalue));
2094     }
2095   else if (!app->app_local->extcap.is_v2)
2096     {
2097       /* Version 1 cards.  */
2098       if (chvno == 1 || chvno == 2)
2099         {
2100           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2101                                               pinvalue, strlen (pinvalue));
2102           if (!rc)
2103             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2104                                                 pinvalue, strlen (pinvalue));
2105         }
2106       else /* CHVNO == 3 */
2107         {
2108           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2109                                               pinvalue, strlen (pinvalue));
2110         }
2111     }
2112   else
2113     {
2114       /* Version 2 cards.  */
2115       assert (chvno == 1 || chvno == 3);
2116       
2117       rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2118                                           oldpinvalue, strlen (oldpinvalue),
2119                                           pinvalue, strlen (pinvalue));
2120     }
2121
2122   if (pinvalue)
2123     {
2124       wipememory (pinvalue, strlen (pinvalue));
2125       xfree (pinvalue);
2126     }
2127   if (rc)
2128     flush_cache_after_error (app);
2129
2130  leave:
2131   if (resetcode)
2132     {
2133       wipememory (resetcode, strlen (resetcode));
2134       xfree (resetcode);
2135     }
2136   if (oldpinvalue)
2137     {
2138       wipememory (oldpinvalue, strlen (oldpinvalue));
2139       xfree (oldpinvalue);
2140     }
2141   return rc;
2142 }
2143
2144
2145 /* Check whether a key already exists.  KEYIDX is the index of the key
2146    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2147    error returned if the key already exists. */
2148 static gpg_error_t
2149 does_key_exist (app_t app, int keyidx, int force)
2150 {
2151   const unsigned char *fpr;
2152   unsigned char *buffer;
2153   size_t buflen, n;
2154   int i;
2155
2156   assert (keyidx >=0 && keyidx <= 2);
2157
2158   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2159     {
2160       log_error (_("error reading application data\n"));
2161       return gpg_error (GPG_ERR_GENERAL);
2162     }
2163   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2164   if (!fpr || n < 60)
2165     {
2166       log_error (_("error reading fingerprint DO\n"));
2167       xfree (buffer);
2168       return gpg_error (GPG_ERR_GENERAL);
2169     }
2170   fpr += 20*keyidx;
2171   for (i=0; i < 20 && !fpr[i]; i++)
2172     ;
2173   xfree (buffer);
2174   if (i!=20 && !force)
2175     {
2176       log_error (_("key already exists\n"));
2177       return gpg_error (GPG_ERR_EEXIST);
2178     }
2179   else if (i!=20)
2180     log_info (_("existing key will be replaced\n"));
2181   else
2182     log_info (_("generating new key\n"));
2183   return 0;
2184 }
2185
2186
2187 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2188    of tag and length.  A LENGTH greater than 65535 is truncated. */
2189 static size_t
2190 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2191
2192   unsigned char *p = buffer;
2193
2194   assert (tag <= 0xffff);
2195   if ( tag > 0xff )
2196     *p++ = tag >> 8;
2197   *p++ = tag;
2198   if (length < 128)
2199     *p++ = length;
2200   else if (length < 256)
2201     {
2202       *p++ = 0x81;
2203       *p++ = length;
2204     }
2205   else
2206     {
2207       if (length > 0xffff)
2208         length = 0xffff;
2209       *p++ = 0x82;
2210       *p++ = length >> 8;
2211       *p++ = length;
2212     }
2213
2214   return p - buffer;
2215 }
2216
2217
2218 /* Build the private key template as specified in the OpenPGP specs
2219    v2.0 section 4.3.3.7.  */
2220 static gpg_error_t
2221 build_privkey_template (app_t app, int keyno,
2222                         const unsigned char *rsa_n, size_t rsa_n_len,
2223                         const unsigned char *rsa_e, size_t rsa_e_len,
2224                         const unsigned char *rsa_p, size_t rsa_p_len,
2225                         const unsigned char *rsa_q, size_t rsa_q_len,
2226                         unsigned char **result, size_t *resultlen)
2227 {
2228   size_t rsa_e_reqlen;
2229   unsigned char privkey[7*(1+3)];
2230   size_t privkey_len;
2231   unsigned char exthdr[2+2+3];
2232   size_t exthdr_len;
2233   unsigned char suffix[2+3];
2234   size_t suffix_len;
2235   unsigned char *tp;
2236   size_t datalen;
2237   unsigned char *template;
2238   size_t template_size;
2239
2240   *result = NULL;
2241   *resultlen = 0;
2242
2243   switch (app->app_local->keyattr[keyno].format)
2244     {
2245     case RSA_STD:
2246     case RSA_STD_N:
2247       break;
2248     case RSA_CRT:
2249     case RSA_CRT_N:
2250       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2251
2252     default:
2253       return gpg_error (GPG_ERR_INV_VALUE);
2254     }
2255
2256   /* Get the required length for E.  */
2257   rsa_e_reqlen = app->app_local->keyattr[keyno].e_bits/8;
2258   assert (rsa_e_len <= rsa_e_reqlen);
2259
2260   /* Build the 7f48 cardholder private key template.  */
2261   datalen = 0;
2262   tp = privkey;
2263
2264   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2265   datalen += rsa_e_reqlen;
2266
2267   tp += add_tlv (tp, 0x92, rsa_p_len);
2268   datalen += rsa_p_len;
2269
2270   tp += add_tlv (tp, 0x93, rsa_q_len);
2271   datalen += rsa_q_len;
2272
2273   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2274       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2275     {
2276       tp += add_tlv (tp, 0x97, rsa_n_len);
2277       datalen += rsa_n_len;
2278     }
2279   privkey_len = tp - privkey;
2280
2281   /* Build the extended header list without the private key template.  */
2282   tp = exthdr;
2283   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2284   *tp++ = 0;
2285   tp += add_tlv (tp, 0x7f48, privkey_len);
2286   exthdr_len = tp - exthdr;
2287
2288   /* Build the 5f48 suffix of the data.  */
2289   tp = suffix;
2290   tp += add_tlv (tp, 0x5f48, datalen);
2291   suffix_len = tp - suffix;
2292
2293   /* Now concatenate everything.  */
2294   template_size = (1 + 3   /* 0x4d and len. */
2295                    + exthdr_len
2296                    + privkey_len
2297                    + suffix_len
2298                    + datalen);
2299   tp = template = xtrymalloc_secure (template_size);
2300   if (!template)
2301     return gpg_error_from_syserror ();
2302
2303   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2304   memcpy (tp, exthdr, exthdr_len);
2305   tp += exthdr_len;
2306   memcpy (tp, privkey, privkey_len);
2307   tp += privkey_len;
2308   memcpy (tp, suffix, suffix_len);
2309   tp += suffix_len;
2310
2311   memcpy (tp, rsa_e, rsa_e_len);
2312   if (rsa_e_len < rsa_e_reqlen)
2313     {
2314       /* Right justify E. */
2315       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2316       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2317     }                 
2318   tp += rsa_e_reqlen;
2319       
2320   memcpy (tp, rsa_p, rsa_p_len);
2321   tp += rsa_p_len;
2322       
2323   memcpy (tp, rsa_q, rsa_q_len);
2324   tp += rsa_q_len;
2325   
2326   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2327       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2328     {
2329       memcpy (tp, rsa_n, rsa_n_len);
2330       tp += rsa_n_len;
2331     }
2332
2333   /* Sanity check.  We don't know the exact length because we
2334      allocated 3 bytes for the first length header.  */
2335   assert (tp - template <= template_size);
2336
2337   *result = template;
2338   *resultlen = tp - template;
2339   return 0;
2340 }
2341
2342
2343
2344 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2345    canonical encoded S-expression with the secret key in KEYDATA and
2346    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2347    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2348    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2349    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2350    the pinentry callback.  */
2351 static gpg_error_t
2352 do_writekey (app_t app, ctrl_t ctrl,
2353              const char *keyid, unsigned int flags,
2354              gpg_error_t (*pincb)(void*, const char *, char **),
2355              void *pincb_arg,
2356              const unsigned char *keydata, size_t keydatalen)
2357 {
2358   gpg_error_t err;
2359   int force = (flags & 1);
2360   int keyno;
2361   const unsigned char *buf, *tok;
2362   size_t buflen, toklen;
2363   int depth, last_depth1, last_depth2;
2364   const unsigned char *rsa_n = NULL;
2365   const unsigned char *rsa_e = NULL;
2366   const unsigned char *rsa_p = NULL;
2367   const unsigned char *rsa_q = NULL;
2368   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2369   unsigned int nbits;
2370   unsigned int maxbits;
2371   unsigned char *template = NULL;
2372   unsigned char *tp;
2373   size_t template_len;
2374   unsigned char fprbuf[20];
2375   u32 created_at = 0;
2376
2377   (void)ctrl;
2378
2379   if (!strcmp (keyid, "OPENPGP.1"))
2380     keyno = 0;
2381   else if (!strcmp (keyid, "OPENPGP.2"))
2382     keyno = 1;
2383   else if (!strcmp (keyid, "OPENPGP.3"))
2384     keyno = 2;
2385   else
2386     return gpg_error (GPG_ERR_INV_ID);
2387   
2388   err = does_key_exist (app, keyno, force);
2389   if (err)
2390     return err;
2391
2392
2393   /* 
2394      Parse the S-expression
2395    */
2396   buf = keydata;
2397   buflen = keydatalen;
2398   depth = 0;
2399   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2400     goto leave;
2401   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2402     goto leave;
2403   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2404     {
2405       if (!tok)
2406         ;
2407       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2408         log_info ("protected-private-key passed to writekey\n");
2409       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2410         log_info ("shadowed-private-key passed to writekey\n");
2411       err = gpg_error (GPG_ERR_BAD_SECKEY);
2412       goto leave;
2413     }
2414   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2415     goto leave;
2416   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2417     goto leave;
2418   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2419     {
2420       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2421       goto leave;
2422     }
2423   last_depth1 = depth;
2424   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2425          && depth && depth >= last_depth1)
2426     {
2427       if (tok)
2428         {
2429           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2430           goto leave;
2431         }
2432       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2433         goto leave;
2434       if (tok && toklen == 1)
2435         {
2436           const unsigned char **mpi;
2437           size_t *mpi_len;
2438
2439           switch (*tok)
2440             {
2441             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
2442             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
2443             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
2444             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
2445             default: mpi = NULL;  mpi_len = NULL; break;
2446             }
2447           if (mpi && *mpi)
2448             {
2449               err = gpg_error (GPG_ERR_DUP_VALUE);
2450               goto leave;
2451             }
2452           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2453             goto leave;
2454           if (tok && mpi)
2455             {
2456               /* Strip off leading zero bytes and save. */
2457               for (;toklen && !*tok; toklen--, tok++)
2458                 ;
2459               *mpi = tok;
2460               *mpi_len = toklen;
2461             }
2462         }
2463       /* Skip until end of list. */
2464       last_depth2 = depth;
2465       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2466              && depth && depth >= last_depth2)
2467         ;
2468       if (err)
2469         goto leave;
2470     }
2471   /* Parse other attributes. */
2472   last_depth1 = depth;
2473   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2474          && depth && depth >= last_depth1)
2475     {
2476       if (tok)
2477         {
2478           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2479           goto leave;
2480         }
2481       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2482         goto leave;
2483       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2484         {
2485           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2486             goto leave;
2487           if (tok)
2488             {
2489               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2490                    tok++, toklen--)
2491                 created_at = created_at*10 + (*tok - '0');
2492             }
2493         }
2494       /* Skip until end of list. */
2495       last_depth2 = depth;
2496       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2497              && depth && depth >= last_depth2)
2498         ;
2499       if (err)
2500         goto leave;
2501     }
2502
2503
2504   /* Check that we have all parameters and that they match the card
2505      description. */
2506   if (!created_at)
2507     {
2508       log_error (_("creation timestamp missing\n"));
2509       err = gpg_error (GPG_ERR_INV_VALUE);
2510       goto leave;
2511     }
2512
2513   maxbits = app->app_local->keyattr[keyno].n_bits;
2514   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2515   if (opt.verbose)
2516     log_info ("RSA modulus size is %u bits (%u bytes)\n", 
2517               nbits, (unsigned int)rsa_n_len);
2518   if (nbits != maxbits)
2519     {
2520       log_error (_("RSA modulus missing or not of size %d bits\n"), 
2521                  (int)maxbits);
2522       err = gpg_error (GPG_ERR_BAD_SECKEY);
2523       goto leave;
2524     }
2525
2526   maxbits = app->app_local->keyattr[keyno].e_bits;
2527   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2528     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2529   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2530   if (nbits < 2 || nbits > maxbits)
2531     {
2532       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2533                  (int)maxbits);
2534       err = gpg_error (GPG_ERR_BAD_SECKEY);
2535       goto leave;
2536     }
2537
2538   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2539   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2540   if (nbits != maxbits)
2541     {
2542       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2543                  "P", (int)maxbits);
2544       err = gpg_error (GPG_ERR_BAD_SECKEY);
2545       goto leave;
2546     }
2547   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2548   if (nbits != maxbits)
2549     {
2550       log_error (_("RSA prime %s missing or not of size %d bits\n"), 
2551                  "Q", (int)maxbits);
2552       err = gpg_error (GPG_ERR_BAD_SECKEY);
2553       goto leave;
2554     }
2555   
2556   /* We need to remove the cached public key.  */
2557   xfree (app->app_local->pk[keyno].key);
2558   app->app_local->pk[keyno].key = NULL;
2559   app->app_local->pk[keyno].keylen = 0;
2560   app->app_local->pk[keyno].read_done = 0;
2561
2562
2563   if (app->app_local->extcap.is_v2)
2564     {
2565       /* Build the private key template as described in section 4.3.3.7 of
2566          the OpenPGP card specs version 2.0.  */
2567       int exmode;
2568  
2569       err = build_privkey_template (app, keyno,
2570                                     rsa_n, rsa_n_len,
2571                                     rsa_e, rsa_e_len,
2572                                     rsa_p, rsa_p_len,
2573                                     rsa_q, rsa_q_len,
2574                                     &template, &template_len);
2575       if (err)
2576         goto leave;
2577
2578       /* Prepare for storing the key.  */
2579       err = verify_chv3 (app, pincb, pincb_arg);
2580       if (err)
2581         goto leave;
2582
2583       /* Store the key. */
2584       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2585         exmode = 1;    /* Use extended length w/o a limit.  */
2586       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2587         exmode = -254;
2588       else
2589         exmode = 0;
2590       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2591                                   template, template_len);
2592     }
2593   else
2594     {
2595       /* Build the private key template as described in section 4.3.3.6 of
2596          the OpenPGP card specs version 1.1:
2597          0xC0   <length> public exponent
2598          0xC1   <length> prime p 
2599          0xC2   <length> prime q 
2600       */
2601       assert (rsa_e_len <= 4);
2602       template_len = (1 + 1 + 4
2603                       + 1 + 1 + rsa_p_len
2604                       + 1 + 1 + rsa_q_len);
2605       template = tp = xtrymalloc_secure (template_len);
2606       if (!template)
2607         {
2608           err = gpg_error_from_syserror ();
2609           goto leave;
2610         }
2611       *tp++ = 0xC0;
2612       *tp++ = 4;
2613       memcpy (tp, rsa_e, rsa_e_len);
2614       if (rsa_e_len < 4)
2615         {
2616           /* Right justify E. */
2617           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2618           memset (tp, 0, 4-rsa_e_len);
2619         }                 
2620       tp += 4;
2621       
2622       *tp++ = 0xC1;
2623       *tp++ = rsa_p_len;
2624       memcpy (tp, rsa_p, rsa_p_len);
2625       tp += rsa_p_len;
2626       
2627       *tp++ = 0xC2;
2628       *tp++ = rsa_q_len;
2629       memcpy (tp, rsa_q, rsa_q_len);
2630       tp += rsa_q_len;
2631       
2632       assert (tp - template == template_len);
2633       
2634       /* Prepare for storing the key.  */
2635       err = verify_chv3 (app, pincb, pincb_arg);
2636       if (err)
2637         goto leave;
2638
2639       /* Store the key. */
2640       err = iso7816_put_data (app->slot, 0,
2641                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2642                               template, template_len);
2643     }
2644   if (err)
2645     {
2646       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2647       goto leave;
2648     }
2649  
2650   err = store_fpr (app, keyno, created_at,
2651                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2652                   fprbuf, app->card_version);
2653   if (err)
2654     goto leave;
2655
2656
2657  leave:
2658   xfree (template);
2659   return err;
2660 }
2661
2662
2663 /* Handle the GENKEY command. */
2664 static gpg_error_t 
2665 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2666            time_t createtime,
2667            gpg_error_t (*pincb)(void*, const char *, char **),
2668            void *pincb_arg)
2669 {
2670   int rc;
2671   char numbuf[30];
2672   unsigned char fprbuf[20];
2673   const unsigned char *keydata, *m, *e;
2674   unsigned char *buffer = NULL;
2675   size_t buflen, keydatalen, mlen, elen;
2676   time_t created_at;
2677   int keyno = atoi (keynostr);
2678   int force = (flags & 1);
2679   time_t start_at;
2680   int exmode;
2681   int le_value;
2682   unsigned int keybits; 
2683
2684   if (keyno < 1 || keyno > 3)
2685     return gpg_error (GPG_ERR_INV_ID);
2686   keyno--;
2687
2688   /* We flush the cache to increase the traffic before a key
2689      generation.  This _might_ help a card to gather more entropy. */
2690   flush_cache (app);
2691
2692   /* Obviously we need to remove the cached public key.  */
2693   xfree (app->app_local->pk[keyno].key);
2694   app->app_local->pk[keyno].key = NULL;
2695   app->app_local->pk[keyno].keylen = 0;
2696   app->app_local->pk[keyno].read_done = 0;
2697
2698   /* Check whether a key already exists.  */
2699   rc = does_key_exist (app, keyno, force);
2700   if (rc)
2701     return rc;
2702
2703   /* Because we send the key parameter back via status lines we need
2704      to put a limit on the max. allowed keysize.  2048 bit will
2705      already lead to a 527 byte long status line and thus a 4096 bit
2706      key would exceed the Assuan line length limit.  */ 
2707   keybits = app->app_local->keyattr[keyno].n_bits;
2708   if (keybits > 3072)
2709     return gpg_error (GPG_ERR_TOO_LARGE);
2710
2711   /* Prepare for key generation by verifying the Admin PIN.  */
2712   rc = verify_chv3 (app, pincb, pincb_arg);
2713   if (rc)
2714     goto leave;
2715
2716   /* Test whether we will need extended length mode.  (1900 is an
2717      arbitrary length which for sure fits into a short apdu.)  */
2718   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
2719     {
2720       exmode = 1;    /* Use extended length w/o a limit.  */
2721       le_value = app->app_local->extcap.max_rsp_data;
2722       /* No need to check le_value because it comes from a 16 bit
2723          value and thus can't create an overflow on a 32 bit
2724          system.  */ 
2725     }
2726   else
2727     {
2728       exmode = 0;
2729       le_value = 256; /* Use legacy value. */
2730     }
2731
2732   log_info (_("please wait while key is being generated ...\n"));
2733   start_at = time (NULL);
2734   rc = iso7816_generate_keypair 
2735 /* # warning key generation temporary replaced by reading an existing key. */
2736 /*   rc = iso7816_read_public_key */
2737     (app->slot, exmode, 
2738      (const unsigned char*)(keyno == 0? "\xB6" :
2739                             keyno == 1? "\xB8" : "\xA4"), 2,
2740      le_value,
2741      &buffer, &buflen);
2742   if (rc)
2743     {
2744       rc = gpg_error (GPG_ERR_CARD);
2745       log_error (_("generating key failed\n"));
2746       goto leave;
2747     }
2748   log_info (_("key generation completed (%d seconds)\n"),
2749             (int)(time (NULL) - start_at));
2750
2751   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2752   if (!keydata)
2753     {
2754       rc = gpg_error (GPG_ERR_CARD);
2755       log_error (_("response does not contain the public key data\n"));
2756       goto leave;
2757     }
2758  
2759   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2760   if (!m)
2761     {
2762       rc = gpg_error (GPG_ERR_CARD);
2763       log_error (_("response does not contain the RSA modulus\n"));
2764       goto leave;
2765     }
2766   /* log_printhex ("RSA n:", m, mlen); */
2767   send_key_data (ctrl, "n", m, mlen);
2768
2769   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2770   if (!e)
2771     {
2772       rc = gpg_error (GPG_ERR_CARD);
2773       log_error (_("response does not contain the RSA public exponent\n"));
2774       goto leave;
2775     }
2776   /* log_printhex ("RSA e:", e, elen); */
2777   send_key_data (ctrl, "e", e, elen);
2778
2779   created_at = createtime? createtime : gnupg_get_time ();
2780   sprintf (numbuf, "%lu", (unsigned long)created_at);
2781   send_status_info (ctrl, "KEY-CREATED-AT",
2782                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2783
2784   rc = store_fpr (app, keyno, (u32)created_at,
2785                   m, mlen, e, elen, fprbuf, app->card_version);
2786   if (rc)
2787     goto leave;
2788   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2789
2790
2791  leave:
2792   xfree (buffer);
2793   return rc;
2794 }
2795
2796
2797 static unsigned long
2798 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2799 {
2800   unsigned long ul;
2801
2802   if (valuelen == 3 )
2803     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2804   else
2805     {
2806       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2807       ul = 0;
2808     }
2809   return ul;
2810 }
2811
2812 static unsigned long
2813 get_sig_counter (app_t app)
2814 {
2815   void *relptr;
2816   unsigned char *value;
2817   size_t valuelen;
2818   unsigned long ul;
2819
2820   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2821   if (!relptr)
2822     return 0;
2823   ul = convert_sig_counter_value (value, valuelen);
2824   xfree (relptr);
2825   return ul;
2826 }
2827
2828 static gpg_error_t
2829 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2830 {
2831   const unsigned char *fpr;
2832   unsigned char *buffer;
2833   size_t buflen, n;
2834   int rc, i;
2835   
2836   assert (keyno >= 1 && keyno <= 3);
2837
2838   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
2839   if (rc)
2840     {
2841       log_error (_("error reading application data\n"));
2842       return gpg_error (GPG_ERR_GENERAL);
2843     }
2844   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2845   if (!fpr || n != 60)
2846     {
2847       xfree (buffer);
2848       log_error (_("error reading fingerprint DO\n"));
2849       return gpg_error (GPG_ERR_GENERAL);
2850     }
2851   fpr += (keyno-1)*20;
2852   for (i=0; i < 20; i++)
2853     if (sha1fpr[i] != fpr[i])
2854       {
2855         xfree (buffer);
2856         log_info (_("fingerprint on card does not match requested one\n"));
2857         return gpg_error (GPG_ERR_WRONG_SECKEY);
2858       }
2859   xfree (buffer);
2860   return 0;
2861 }
2862
2863
2864 /* If a fingerprint has been specified check it against the one on the
2865    card.  This allows for a meaningful error message in case the key
2866    on the card has been replaced but the shadow information known to
2867    gpg has not been updated.  If there is no fingerprint we assume
2868    that this is okay. */
2869 static gpg_error_t
2870 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2871 {
2872   unsigned char tmp[20];
2873   const char *s;
2874   int n;
2875
2876   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2877     ;
2878   if (n != 40)
2879     return gpg_error (GPG_ERR_INV_ID);
2880   else if (!*s)
2881     ; /* okay */
2882   else
2883     return gpg_error (GPG_ERR_INV_ID);
2884
2885   for (s=fpr, n=0; n < 20; s += 2, n++)
2886         tmp[n] = xtoi_2 (s);
2887   return compare_fingerprint (app, keyno, tmp);
2888 }
2889
2890
2891
2892 /* Compute a digital signature on INDATA which is expected to be the
2893    raw message digest. For this application the KEYIDSTR consists of
2894    the serialnumber and the fingerprint delimited by a slash.
2895
2896    Note that this function may return the error code
2897    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2898    not match the one required for the requested action (e.g. the
2899    serial number does not match). 
2900    
2901    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2902    operation to the auth command.
2903 */
2904 static gpg_error_t 
2905 do_sign (app_t app, const char *keyidstr, int hashalgo,
2906          gpg_error_t (*pincb)(void*, const char *, char **),
2907          void *pincb_arg,
2908          const void *indata, size_t indatalen,
2909          unsigned char **outdata, size_t *outdatalen )
2910 {
2911   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2912     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2913       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2914   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2915     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2916       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2917   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2918     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2919       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2920       0x1C  };
2921   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2922     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2923       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2924       0x00, 0x04, 0x20  };
2925   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2926     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2927       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2928       0x00, 0x04, 0x30  };
2929   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2930     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2931       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2932       0x00, 0x04, 0x40  };
2933   int rc;
2934   unsigned char data[19+64];
2935   size_t datalen;
2936   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2937   const char *s;
2938   int n;
2939   const char *fpr = NULL;
2940   unsigned long sigcount;
2941   int use_auth = 0;
2942
2943   if (!keyidstr || !*keyidstr)
2944     return gpg_error (GPG_ERR_INV_VALUE);
2945
2946   /* Strip off known prefixes.  */
2947 #define X(a,b,c,d) \
2948   if (hashalgo == GCRY_MD_ ## a                               \
2949       && (d)                                                  \
2950       && indatalen == sizeof b ## _prefix + (c)               \
2951       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2952     {                                                         \
2953       indata = (const char*)indata + sizeof b ## _prefix;     \
2954       indatalen -= sizeof b ## _prefix;                       \
2955     }                                                         
2956
2957   if (indatalen == 20)
2958     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2959   else X(SHA1,   sha1,   20, 1)
2960   else X(RMD160, rmd160, 20, 1)
2961   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2962   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2963   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2964   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2965   else if ((indatalen == 28 || indatalen == 32 
2966             || indatalen == 48 || indatalen ==64)
2967            && app->app_local->extcap.is_v2)
2968     ;  /* Assume a plain SHA-3 digest has been given.  */
2969   else
2970     {
2971       log_error (_("card does not support digest algorithm %s\n"),
2972                  gcry_md_algo_name (hashalgo));
2973       /* Or the supplied digest length does not match an algorithm.  */
2974       return gpg_error (GPG_ERR_INV_VALUE);
2975     }
2976 #undef X
2977
2978   /* Check whether an OpenPGP card of any version has been requested. */
2979   if (!strcmp (keyidstr, "OPENPGP.1"))
2980     ;
2981   else if (!strcmp (keyidstr, "OPENPGP.3"))
2982     use_auth = 1;
2983   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2984     return gpg_error (GPG_ERR_INV_ID);
2985   else
2986     {
2987       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2988         ;
2989       if (n != 32)
2990         return gpg_error (GPG_ERR_INV_ID);
2991       else if (!*s)
2992         ; /* no fingerprint given: we allow this for now. */
2993       else if (*s == '/')
2994         fpr = s + 1; 
2995       else
2996         return gpg_error (GPG_ERR_INV_ID);
2997
2998       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2999         tmp_sn[n] = xtoi_2 (s);
3000
3001       if (app->serialnolen != 16)
3002         return gpg_error (GPG_ERR_INV_CARD);
3003       if (memcmp (app->serialno, tmp_sn, 16))
3004         return gpg_error (GPG_ERR_WRONG_CARD);
3005     }
3006
3007   /* If a fingerprint has been specified check it against the one on
3008      the card.  This is allows for a meaningful error message in case
3009      the key on the card has been replaced but the shadow information
3010      known to gpg was not updated.  If there is no fingerprint, gpg
3011      will detect a bogus signature anyway due to the
3012      verify-after-signing feature. */
3013   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3014   if (rc)
3015     return rc;
3016
3017   /* Concatenate prefix and digest.  */
3018 #define X(a,b,d) \
3019   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3020     {                                                         \
3021       datalen = sizeof b ## _prefix + indatalen;              \
3022       assert (datalen <= sizeof data);                        \
3023       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3024       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3025     }                                                         
3026
3027   X(SHA1,   sha1,   1)
3028   else X(RMD160, rmd160, 1)
3029   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3030   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3031   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3032   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3033   else 
3034     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3035 #undef X
3036
3037   /* Redirect to the AUTH command if asked to. */
3038   if (use_auth)
3039     {
3040       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3041                       data, datalen,
3042                       outdata, outdatalen);
3043     }
3044
3045   /* Show the number of signature done using this key.  */
3046   sigcount = get_sig_counter (app);
3047   log_info (_("signatures created so far: %lu\n"), sigcount);
3048
3049   /* Check CHV if needed.  */
3050   if (!app->did_chv1 || app->force_chv1 ) 
3051     {
3052       char *pinvalue;
3053
3054       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3055       if (rc)
3056         return rc;
3057
3058       app->did_chv1 = 1;
3059
3060       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3061          sync, thus we verify CHV2 here using the given PIN.  Cards
3062          with version2 to not have the need for a separate CHV2 and
3063          internally use just one.  Obviously we can't do that if the
3064          keypad has been used. */
3065       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3066         {
3067           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3068           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3069             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3070           if (rc)
3071             {
3072               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3073               xfree (pinvalue);
3074               flush_cache_after_error (app);
3075               return rc;
3076             }
3077           app->did_chv2 = 1;
3078         }
3079       xfree (pinvalue);
3080     }
3081
3082   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
3083   return rc;
3084 }
3085
3086 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3087    on INDATA which is expected to be the raw message digest. For this
3088    application the KEYIDSTR consists of the serialnumber and the
3089    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3090    be given.
3091
3092    Note that this function may return the error code
3093    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3094    not match the one required for the requested action (e.g. the
3095    serial number does not match). */
3096 static gpg_error_t 
3097 do_auth (app_t app, const char *keyidstr,
3098          gpg_error_t (*pincb)(void*, const char *, char **),
3099          void *pincb_arg,
3100          const void *indata, size_t indatalen,
3101          unsigned char **outdata, size_t *outdatalen )
3102 {
3103   int rc;
3104   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3105   const char *s;
3106   int n;
3107   const char *fpr = NULL;
3108
3109   if (!keyidstr || !*keyidstr)
3110     return gpg_error (GPG_ERR_INV_VALUE);
3111   if (indatalen > 101) /* For a 2048 bit key. */
3112     return gpg_error (GPG_ERR_INV_VALUE);
3113
3114   /* Check whether an OpenPGP card of any version has been requested. */
3115   if (!strcmp (keyidstr, "OPENPGP.3"))
3116     ;
3117   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3118     return gpg_error (GPG_ERR_INV_ID);
3119   else
3120     {
3121       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3122         ;
3123       if (n != 32)
3124         return gpg_error (GPG_ERR_INV_ID);
3125       else if (!*s)
3126         ; /* no fingerprint given: we allow this for now. */
3127       else if (*s == '/')
3128         fpr = s + 1; 
3129       else
3130         return gpg_error (GPG_ERR_INV_ID);
3131
3132       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3133         tmp_sn[n] = xtoi_2 (s);
3134       
3135       if (app->serialnolen != 16)
3136         return gpg_error (GPG_ERR_INV_CARD);
3137       if (memcmp (app->serialno, tmp_sn, 16))
3138         return gpg_error (GPG_ERR_WRONG_CARD);
3139     }
3140
3141   /* If a fingerprint has been specified check it against the one on
3142      the card.  This is allows for a meaningful error message in case
3143      the key on the card has been replaced but the shadow information
3144      known to gpg was not updated.  If there is no fingerprint, gpg
3145      will detect a bogus signature anyway due to the
3146      verify-after-signing feature. */
3147   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3148   if (rc)
3149     return rc;
3150
3151   rc = verify_chv2 (app, pincb, pincb_arg);
3152   if (!rc)
3153     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
3154                                         outdata, outdatalen);
3155   return rc;
3156 }
3157
3158
3159 static gpg_error_t 
3160 do_decipher (app_t app, const char *keyidstr,
3161              gpg_error_t (*pincb)(void*, const char *, char **),
3162              void *pincb_arg,
3163              const void *indata, size_t indatalen,
3164              unsigned char **outdata, size_t *outdatalen )
3165 {
3166   int rc;
3167   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3168   const char *s;
3169   int n;
3170   const char *fpr = NULL;
3171   int exmode;
3172
3173   if (!keyidstr || !*keyidstr || !indatalen)
3174     return gpg_error (GPG_ERR_INV_VALUE);
3175
3176   /* Check whether an OpenPGP card of any version has been requested. */
3177   if (!strcmp (keyidstr, "OPENPGP.2"))
3178     ;
3179   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3180     return gpg_error (GPG_ERR_INV_ID);
3181   else
3182     {
3183       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3184         ;
3185       if (n != 32)
3186         return gpg_error (GPG_ERR_INV_ID);
3187       else if (!*s)
3188         ; /* no fingerprint given: we allow this for now. */
3189       else if (*s == '/')
3190         fpr = s + 1; 
3191       else
3192         return gpg_error (GPG_ERR_INV_ID);
3193       
3194       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3195         tmp_sn[n] = xtoi_2 (s);
3196       
3197       if (app->serialnolen != 16)
3198         return gpg_error (GPG_ERR_INV_CARD);
3199       if (memcmp (app->serialno, tmp_sn, 16))
3200         return gpg_error (GPG_ERR_WRONG_CARD);
3201     }
3202
3203   /* If a fingerprint has been specified check it against the one on
3204      the card.  This is allows for a meaningful error message in case
3205      the key on the card has been replaced but the shadow information
3206      known to gpg was not updated.  If there is no fingerprint, the
3207      decryption won't produce the right plaintext anyway. */
3208   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
3209   if (rc)
3210     return rc;
3211
3212   rc = verify_chv2 (app, pincb, pincb_arg);
3213   if (!rc)
3214     {
3215       size_t fixuplen;
3216       unsigned char *fixbuf = NULL;
3217       int padind = 0;
3218
3219       /* We might encounter a couple of leading zeroes in the
3220          cryptogram.  Due to internal use of MPIs thease leading
3221          zeroes are stripped.  However the OpenPGP card expects
3222          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
3223          need to fix it up.  We do this for up to 16 leading zero
3224          bytes; a cryptogram with more than this is with a very high
3225          probability anyway broken.  */
3226       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
3227         fixuplen = 128 - indatalen;
3228       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
3229         fixuplen = 192 - indatalen;
3230       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
3231         fixuplen = 256 - indatalen;
3232       else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key.  */
3233         fixuplen = 384 - indatalen;
3234       else
3235         fixuplen = 0;
3236
3237       if (fixuplen)
3238         {
3239           /* While we have to prepend stuff anyway, we can also
3240              include the padding byte here so that iso1816_decipher
3241              does not need to do another data mangling.  */
3242           fixuplen++;
3243
3244           fixbuf = xtrymalloc (fixuplen + indatalen);
3245           if (!fixbuf)
3246             return gpg_error_from_syserror ();
3247           
3248           memset (fixbuf, 0, fixuplen);
3249           memcpy (fixbuf+fixuplen, indata, indatalen);
3250           indata = fixbuf;
3251           indatalen = fixuplen + indatalen;
3252           padind = -1; /* Already padded.  */
3253         }
3254       
3255       if (app->app_local->cardcap.ext_lc_le && indatalen > 254 )
3256         exmode = 1;    /* Extended length w/o a limit.  */
3257       else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
3258         exmode = -254; /* Command chaining with max. 254 bytes.  */
3259       else
3260         exmode = 0;    
3261
3262       rc = iso7816_decipher (app->slot, exmode, 
3263                              indata, indatalen, padind,
3264                              outdata, outdatalen);
3265       xfree (fixbuf);
3266     }
3267
3268   return rc;
3269 }
3270
3271
3272 /* Perform a simple verify operation for CHV1 and CHV2, so that
3273    further operations won't ask for CHV2 and it is possible to do a
3274    cheap check on the PIN: If there is something wrong with the PIN
3275    entry system, only the regular CHV will get blocked and not the
3276    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
3277    optional fingerprint part will be ignored.
3278
3279    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
3280    the "[CHV3]" being a literal string:  The Admin Pin is checked if
3281    and only if the retry counter is still at 3. */
3282 static gpg_error_t 
3283 do_check_pin (app_t app, const char *keyidstr,
3284               gpg_error_t (*pincb)(void*, const char *, char **),
3285               void *pincb_arg)
3286 {
3287   unsigned char tmp_sn[20]; 
3288   const char *s;
3289   int n;
3290   int admin_pin = 0;
3291
3292   if (!keyidstr || !*keyidstr)
3293     return gpg_error (GPG_ERR_INV_VALUE);
3294
3295   /* Check whether an OpenPGP card of any version has been requested. */
3296   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3297     return gpg_error (GPG_ERR_INV_ID);
3298   
3299   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3300     ;
3301   if (n != 32)
3302     return gpg_error (GPG_ERR_INV_ID);
3303   else if (!*s)
3304     ; /* No fingerprint given: we allow this for now. */
3305   else if (*s == '/')
3306     ; /* We ignore a fingerprint. */
3307   else if (!strcmp (s, "[CHV3]") )
3308     admin_pin = 1;
3309   else
3310     return gpg_error (GPG_ERR_INV_ID);
3311
3312   for (s=keyidstr, n=0; n < 16; s += 2, n++)
3313     tmp_sn[n] = xtoi_2 (s);
3314
3315   if (app->serialnolen != 16)
3316     return gpg_error (GPG_ERR_INV_CARD);
3317   if (memcmp (app->serialno, tmp_sn, 16))
3318     return gpg_error (GPG_ERR_WRONG_CARD);
3319
3320   /* Yes, there is a race conditions: The user might pull the card
3321      right here and we won't notice that.  However this is not a
3322      problem and the check above is merely for a graceful failure
3323      between operations. */
3324
3325   if (admin_pin)
3326     {
3327       void *relptr;
3328       unsigned char *value;
3329       size_t valuelen;
3330       int count;
3331       
3332       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
3333       if (!relptr || valuelen < 7)
3334         {
3335           log_error (_("error retrieving CHV status from card\n"));
3336           xfree (relptr);
3337           return gpg_error (GPG_ERR_CARD);
3338         }
3339       count = value[6];
3340       xfree (relptr);
3341
3342       if (!count)
3343         {
3344           log_info (_("card is permanently locked!\n"));
3345           return gpg_error (GPG_ERR_BAD_PIN);
3346         }
3347       else if (value[6] < 3)
3348         {
3349           log_info (_("verification of Admin PIN is currently prohibited "
3350                       "through this command\n"));
3351           return gpg_error (GPG_ERR_GENERAL);
3352         }
3353
3354       app->did_chv3 = 0; /* Force verification.  */
3355       return verify_chv3 (app, pincb, pincb_arg);
3356     }
3357   else
3358     return verify_chv2 (app, pincb, pincb_arg);
3359 }
3360
3361
3362 /* Show information about card capabilities.  */
3363 static void
3364 show_caps (struct app_local_s *s)
3365 {
3366   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
3367   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
3368   if (s->extcap.get_challenge)
3369     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
3370   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
3371   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
3372   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
3373   log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
3374   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
3375   if (s->extcap.sm_supported)
3376     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
3377   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
3378   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
3379   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
3380   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
3381   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
3382   log_info ("Status Indicator: %02X\n", s->status_indicator);
3383
3384   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
3385   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
3386 }
3387
3388
3389 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
3390    APPLOC.  */
3391 static void
3392 parse_historical (struct app_local_s *apploc, 
3393                   const unsigned char * buffer, size_t buflen)
3394 {
3395   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
3396   if (buflen < 4)
3397     {
3398       log_error ("warning: historical bytes are too short\n");
3399       return; /* Too short.  */
3400     }
3401   if (*buffer)
3402     {
3403       log_error ("warning: bad category indicator in historical bytes\n");
3404       return; 
3405     }
3406   
3407   /* Skip category indicator.  */
3408   buffer++;
3409   buflen--;
3410
3411   /* Get the status indicator.  */
3412   apploc->status_indicator = buffer[buflen-3];
3413   buflen -= 3;
3414
3415   /* Parse the compact TLV.  */
3416   while (buflen)
3417     {
3418       unsigned int tag = (*buffer & 0xf0) >> 4;
3419       unsigned int len = (*buffer & 0x0f);
3420       if (len+1 > buflen)
3421         {
3422           log_error ("warning: bad Compact-TLV in historical bytes\n");
3423           return; /* Error.  */
3424         }
3425       buffer++;
3426       buflen--;
3427       if (tag == 7 && len == 3)
3428         {
3429           /* Card capabilities.  */
3430           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
3431           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
3432         }
3433       buffer += len;
3434       buflen -= len;
3435     }
3436 }
3437
3438
3439 /* Parse and optionally show the algorithm attributes for KEYNO.
3440    KEYNO must be in the range 0..2.  */
3441 static void 
3442 parse_algorithm_attribute (app_t app, int keyno)
3443
3444   unsigned char *buffer;
3445   size_t buflen;
3446   void *relptr;
3447   const char const desc[3][5] = {"sign", "encr", "auth"};
3448
3449   assert (keyno >=0 && keyno <= 2);
3450
3451   app->app_local->keyattr[keyno].n_bits = 0;
3452       
3453   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
3454   if (!relptr)
3455     {
3456       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3457       return;
3458     }
3459   if (buflen < 1)
3460     {
3461       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
3462       xfree (relptr);
3463       return;
3464     }
3465
3466   if (opt.verbose)
3467     log_info ("Key-Attr-%s ..: ", desc[keyno]);
3468   if (*buffer == 1 && (buflen == 5 || buflen == 6))
3469     {
3470       app->app_local->keyattr[keyno].n_bits = (buffer[1]<<8 | buffer[2]);
3471       app->app_local->keyattr[keyno].e_bits = (buffer[3]<<8 | buffer[4]);
3472       app->app_local->keyattr[keyno].format = 0;
3473       if (buflen < 6)
3474         app->app_local->keyattr[keyno].format = RSA_STD;
3475       else
3476         app->app_local->keyattr[keyno].format = (buffer[5] == 0? RSA_STD   :
3477                                                  buffer[5] == 1? RSA_STD_N :
3478                                                  buffer[5] == 2? RSA_CRT   :
3479                                                  buffer[5] == 3? RSA_CRT_N : 
3480                                                  RSA_UNKNOWN_FMT);
3481
3482       if (opt.verbose)
3483         log_printf
3484           ("RSA, n=%u, e=%u, fmt=%s\n",
3485            app->app_local->keyattr[keyno].n_bits,
3486            app->app_local->keyattr[keyno].e_bits,
3487            app->app_local->keyattr[keyno].format == RSA_STD?  "std"  :
3488            app->app_local->keyattr[keyno].format == RSA_STD_N?"std+n":
3489            app->app_local->keyattr[keyno].format == RSA_CRT?  "crt"  :
3490            app->app_local->keyattr[keyno].format == RSA_CRT_N?"crt+n":"?");
3491     }
3492   else if (opt.verbose)
3493     log_printhex ("", buffer, buflen);
3494
3495   xfree (relptr);
3496 }
3497
3498 /* Select the OpenPGP application on the card in SLOT.  This function
3499    must be used before any other OpenPGP application functions. */
3500 gpg_error_t
3501 app_select_openpgp (app_t app)
3502 {
3503   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
3504   int slot = app->slot;
3505   int rc;
3506   unsigned char *buffer;
3507   size_t buflen;
3508   void *relptr;
3509   
3510   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
3511      special flag value. */
3512   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
3513   if (!rc)
3514     {
3515       unsigned int manufacturer;
3516
3517       app->apptype = "OPENPGP";
3518
3519       app->did_chv1 = 0;
3520       app->did_chv2 = 0;
3521       app->did_chv3 = 0;
3522       app->app_local = NULL;
3523
3524       /* The OpenPGP card returns the serial number as part of the
3525          AID; because we prefer to use OpenPGP serial numbers, we
3526          replace a possibly already set one from a EF.GDO with this
3527          one.  Note, that for current OpenPGP cards, no EF.GDO exists
3528          and thus it won't matter at all. */
3529       rc = iso7816_get_data (slot, 0, 0x004F, &buffer, &buflen);
3530       if (rc)
3531         goto leave;
3532       if (opt.verbose)
3533         {
3534           log_info ("AID: ");
3535           log_printhex ("", buffer, buflen);
3536         }
3537
3538       app->card_version = buffer[6] << 8;
3539       app->card_version |= buffer[7];
3540       manufacturer = (buffer[8]<<8 | buffer[9]);
3541
3542       xfree (app->serialno);
3543       app->serialno = buffer;
3544       app->serialnolen = buflen;
3545       buffer = NULL;
3546       app->app_local = xtrycalloc (1, sizeof *app->app_local);
3547       if (!app->app_local)
3548         {
3549           rc = gpg_error (gpg_err_code_from_errno (errno));
3550           goto leave;
3551         }
3552
3553       if (app->card_version >= 0x0200)
3554         app->app_local->extcap.is_v2 = 1;
3555
3556
3557       /* Read the historical bytes.  */
3558       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3559       if (relptr)
3560         {
3561           if (opt.verbose)
3562             {
3563               log_info ("Historical Bytes: ");
3564               log_printhex ("", buffer, buflen);
3565             }
3566           parse_historical (app->app_local, buffer, buflen);
3567           xfree (relptr);
3568         }
3569
3570       /* Read the force-chv1 flag.  */
3571       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3572       if (!relptr)
3573         {
3574           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3575                      "CHV Status Bytes");
3576           goto leave;
3577         }
3578       app->force_chv1 = (buflen && *buffer == 0);
3579       xfree (relptr);
3580
3581       /* Read the extended capabilities.  */
3582       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3583       if (!relptr)
3584         {
3585           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3586                      "Extended Capability Flags" );
3587           goto leave;
3588         }
3589       if (buflen)
3590         {
3591           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3592           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3593           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3594           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3595           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3596           app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
3597         }
3598       if (buflen >= 10)
3599         {
3600           /* Available with v2 cards.  */
3601           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3602           app->app_local->extcap.max_get_challenge 
3603                                                = (buffer[2] << 8 | buffer[3]);
3604           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3605           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3606           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3607         }
3608       xfree (relptr);
3609
3610       /* Some of the first cards accidently don't set the
3611          CHANGE_FORCE_CHV bit but allow it anyway. */
3612       if (app->card_version <= 0x0100 && manufacturer == 1)
3613         app->app_local->extcap.change_force_chv = 1;
3614
3615       parse_login_data (app);
3616
3617       if (opt.verbose)
3618         show_caps (app->app_local);
3619
3620       parse_algorithm_attribute (app, 0);
3621       parse_algorithm_attribute (app, 1);
3622       parse_algorithm_attribute (app, 2);
3623       
3624       if (opt.verbose > 1)
3625         dump_all_do (slot);
3626
3627       app->fnc.deinit = do_deinit;
3628       app->fnc.learn_status = do_learn_status;
3629       app->fnc.readcert = do_readcert;
3630       app->fnc.readkey = do_readkey;
3631       app->fnc.getattr = do_getattr;
3632       app->fnc.setattr = do_setattr;
3633       app->fnc.writecert = do_writecert;
3634       app->fnc.writekey = do_writekey;
3635       app->fnc.genkey = do_genkey;
3636       app->fnc.sign = do_sign;
3637       app->fnc.auth = do_auth;
3638       app->fnc.decipher = do_decipher;
3639       app->fnc.change_pin = do_change_pin;
3640       app->fnc.check_pin = do_check_pin;
3641    }
3642
3643 leave:
3644   if (rc)
3645     do_deinit (app);
3646   return rc;
3647 }
3648
3649
3650