* plaintext.c (handle_plaintext): Accept 'u' as a plaintext mode that
[gnupg.git] / g10 / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <time.h>
28
29 #if GNUPG_MAJOR_VERSION == 1
30 /* This is used with GnuPG version < 1.9.  The code has been source
31    copied from the current GnuPG >= 1.9  and is maintained over
32    there. */
33 #include "options.h"
34 #include "errors.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "i18n.h"
38 #include "cardglue.h"
39 #else /* GNUPG_MAJOR_VERSION != 1 */
40 #include "scdaemon.h"
41 #endif /* GNUPG_MAJOR_VERSION != 1 */
42
43 #include "iso7816.h"
44 #include "app-common.h"
45
46
47
48 static struct {
49   int tag;
50   int constructed;
51   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
52   int binary;
53   char *desc;
54 } data_objects[] = {
55   { 0x005E, 0,    0, 1, "Login Data" },
56   { 0x5F50, 0,    0, 0, "URL" },
57   { 0x0065, 1,    0, 1, "Cardholder Related Data"},
58   { 0x005B, 0, 0x65, 0, "Name" },
59   { 0x5F2D, 0, 0x65, 0, "Language preferences" },
60   { 0x5F35, 0, 0x65, 0, "Sex" },
61   { 0x006E, 1,    0, 1, "Application Related Data" },
62   { 0x004F, 0, 0x6E, 1, "AID" },
63   { 0x0073, 1,    0, 1, "Discretionary Data Objects" },
64   { 0x0047, 0, 0x6E, 1, "Card Capabilities" },
65   { 0x00C0, 0, 0x6E, 1, "Extended Card Capabilities" },
66   { 0x00C1, 0, 0x6E, 1, "Algorithm Attributes Signature" },
67   { 0x00C2, 0, 0x6E, 1, "Algorithm Attributes Decryption" },
68   { 0x00C3, 0, 0x6E, 1, "Algorithm Attributes Authentication" },
69   { 0x00C4, 0, 0x6E, 1, "CHV Status Bytes" },
70   { 0x00C5, 0, 0x6E, 1, "Fingerprints" },
71   { 0x00C6, 0, 0x6E, 1, "CA Fingerprints" },
72   { 0x007A, 1,    0, 1, "Security Support Template" },
73   { 0x0093, 0, 0x7A, 1, "Digital Signature Counter" },
74   { 0 }
75 };
76
77
78 static unsigned long convert_sig_counter_value (const unsigned char *value,
79                                                 size_t valuelen);
80 static unsigned long get_sig_counter (APP app);
81
82
83 /* Locate a TLV encoded data object in BUFFER of LENGTH and
84    return a pointer to value as well as its length in NBYTES.  Return
85    NULL if it was not found.  Note, that the function does not check
86    whether the value fits into the provided buffer. 
87
88    FIXME: Move this to an extra file, it is mostly duplicated from card.c.
89 */
90 static const unsigned char *
91 find_tlv (const unsigned char *buffer, size_t length,
92           int tag, size_t *nbytes, int nestlevel)
93 {
94   const unsigned char *s = buffer;
95   size_t n = length;
96   size_t len;
97   int this_tag;
98   int composite;
99     
100   for (;;)
101     {
102       buffer = s;
103       if (n < 2)
104         return NULL; /* buffer definitely too short for tag and length. */
105       if (!*s || *s == 0xff)
106         { /* Skip optional filler between TLV objects. */
107           s++;
108           n--;
109           continue;
110         }
111       composite = !!(*s & 0x20);
112       if ((*s & 0x1f) == 0x1f)
113         { /* more tag bytes to follow */
114           s++;
115           n--;
116           if (n < 2)
117             return NULL; /* buffer definitely too short for tag and length. */
118           if ((*s & 0x1f) == 0x1f)
119             return NULL; /* We support only up to 2 bytes. */
120           this_tag = (s[-1] << 8) | (s[0] & 0x7f);
121         }
122       else
123         this_tag = s[0];
124       len = s[1];
125       s += 2; n -= 2;
126       if (len < 0x80)
127         ;
128       else if (len == 0x81)
129         { /* One byte length follows. */
130           if (!n)
131             return NULL; /* we expected 1 more bytes with the length. */
132           len = s[0];
133           s++; n--;
134         }
135       else if (len == 0x82)
136         { /* Two byte length follows. */
137           if (n < 2)
138             return NULL; /* we expected 2 more bytes with the length. */
139           len = (s[0] << 8) | s[1];
140           s += 2; n -= 2;
141         }
142       else
143         return NULL; /* APDU limit is 65535, thus it does not make
144                         sense to assume longer length fields. */
145
146       if (composite && nestlevel < 100)
147         { /* Dive into this composite DO after checking for too deep
148              nesting. */
149           const unsigned char *tmp_s;
150           size_t tmp_len;
151           
152           tmp_s = find_tlv (s, len, tag, &tmp_len, nestlevel+1);
153           if (tmp_s)
154             {
155               *nbytes = tmp_len;
156               return tmp_s;
157             }
158         }
159
160       if (this_tag == tag)
161         {
162           *nbytes = len;
163           return s;
164         }
165       if (len > n)
166         return NULL; /* buffer too short to skip to the next tag. */
167       s += len; n -= len;
168     }
169 }
170
171
172 /* Get the DO identified by TAG from the card in SLOT and return a
173    buffer with its content in RESULT and NBYTES.  The return value is
174    NULL if not found or a pointer which must be used to release the
175    buffer holding value. */
176 static void *
177 get_one_do (int slot, int tag, unsigned char **result, size_t *nbytes)
178 {
179   int rc, i;
180   unsigned char *buffer;
181   size_t buflen;
182   unsigned char *value;
183   size_t valuelen;
184
185   *result = NULL;
186   *nbytes = 0;
187   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
188     ;
189
190   value = NULL;
191   rc = -1;
192   if (data_objects[i].tag && data_objects[i].get_from)
193     {
194       rc = iso7816_get_data (slot, data_objects[i].get_from,
195                              &buffer, &buflen);
196       if (!rc)
197         {
198           const unsigned char *s;
199
200           s = find_tlv (buffer, buflen, tag, &valuelen, 0);
201           if (!s)
202             value = NULL; /* not found */
203           else if (valuelen > buflen - (s - buffer))
204             {
205               log_error ("warning: constructed DO too short\n");
206               value = NULL;
207               xfree (buffer); buffer = NULL;
208             }
209           else
210             value = buffer + (s - buffer);
211         }
212     }
213
214   if (!value) /* Not in a constructed DO, try simple. */
215     {
216       rc = iso7816_get_data (slot, tag, &buffer, &buflen);
217       if (!rc)
218         {
219           value = buffer;
220           valuelen = buflen;
221         }
222     }
223
224   if (!rc)
225     {
226       *nbytes = valuelen;
227       *result = value;
228       return buffer;
229     }
230   return NULL;
231 }
232
233
234 static void
235 dump_all_do (int slot)
236 {
237   int rc, i, j;
238   unsigned char *buffer;
239   size_t buflen;
240   
241   for (i=0; data_objects[i].tag; i++)
242     {
243       if (data_objects[i].get_from)
244         continue;
245
246       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
247       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
248         ;
249       else if (rc) 
250         log_info ("DO `%s' not available: %s\n",
251                   data_objects[i].desc, gpg_strerror (rc));
252       else
253         {
254           if (data_objects[i].binary)
255             {
256               log_info ("DO `%s': ", data_objects[i].desc);
257               log_printhex ("", buffer, buflen);
258             }
259           else
260             log_info ("DO `%s': `%.*s'\n",
261                       data_objects[i].desc,
262                       (int)buflen, buffer); /* FIXME: sanitize */
263
264           if (data_objects[i].constructed)
265             {
266               for (j=0; data_objects[j].tag; j++)
267                 {
268                   const unsigned char *value;
269                   size_t valuelen;
270                   
271                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
272                     continue;
273                   value = find_tlv (buffer, buflen,
274                                     data_objects[j].tag, &valuelen, 0);
275                   if (!value)
276                     ; /* not found */
277                   else if (valuelen > buflen - (value - buffer))
278                     log_error ("warning: constructed DO too short\n");
279                   else
280                     {
281                       if (data_objects[j].binary)
282                         {
283                           log_info ("DO `%s': ", data_objects[j].desc);
284                           log_printhex ("", value, valuelen);
285                         }
286                       else
287                         log_info ("DO `%s': `%.*s'\n",
288                                   data_objects[j].desc,
289                                   (int)valuelen, value); /* FIXME: sanitize */
290                     }
291                 }
292             }
293         }
294       xfree (buffer); buffer = NULL;
295     }
296 }
297
298
299 /* Count the number of bits, assuming the A represents an unsigned big
300    integer of length LEN bytes. */
301 static unsigned int
302 count_bits (const unsigned char *a, size_t len)
303 {
304   unsigned int n = len * 8;
305   int i;
306
307   for (; len && !*a; len--, a++, n -=8)
308     ;
309   if (len)
310     {
311       for (i=7; i && !(*a & (1<<i)); i--)
312         n--;
313     }
314   return n;
315 }
316
317 /* Note, that FPR must be at least 20 bytes. */
318 static int 
319 store_fpr (int slot, int keynumber, u32 timestamp,
320            const unsigned char *m, size_t mlen,
321            const unsigned char *e, size_t elen, 
322            unsigned char *fpr, unsigned int card_version)
323 {
324   unsigned int n, nbits;
325   unsigned char *buffer, *p;
326   int rc;
327   
328   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
329     ;
330   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
331     ;
332
333   n = 6 + 2 + mlen + 2 + elen;
334   p = buffer = xtrymalloc (3 + n);
335   if (!buffer)
336     return out_of_core ();
337   
338   *p++ = 0x99;     /* ctb */
339   *p++ = n >> 8;   /* 2 byte length header */
340   *p++ = n;
341   *p++ = 4;        /* key packet version */
342   *p++ = timestamp >> 24;
343   *p++ = timestamp >> 16;
344   *p++ = timestamp >>  8;
345   *p++ = timestamp;
346   *p++ = 1; /* RSA */
347   nbits = count_bits (m, mlen);
348   *p++ = nbits >> 8;
349   *p++ = nbits;
350   memcpy (p, m, mlen); p += mlen;
351   nbits = count_bits (e, elen);
352   *p++ = nbits >> 8;
353   *p++ = nbits;
354   memcpy (p, e, elen); p += elen;
355     
356   log_printhex ("fprbuf:", buffer, n+3);
357   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
358
359   xfree (buffer);
360
361   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
362                                + keynumber, fpr, 20);
363   if (rc)
364     log_error ("failed to store the fingerprint: %s\n",gpg_strerror (rc));
365
366   return rc;
367 }
368
369        
370 static void
371 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
372                       int number, const unsigned char *fpr)
373 {                      
374   int i;
375   char buf[41];
376   char numbuf[25];
377
378   for (i=0; i < 20 && !fpr[i]; i++)
379     ;
380   if (i==20)
381     return; /* All zero. */
382   for (i=0; i< 20; i++)
383     sprintf (buf+2*i, "%02X", fpr[i]);
384   if (number == -1)
385     *numbuf = 0; /* Don't print the key number */
386   else
387     sprintf (numbuf, "%d", number);
388   send_status_info (ctrl, keyword,
389                     numbuf, (size_t)strlen(numbuf),
390                     buf, (size_t)strlen (buf), NULL, 0);
391 }
392
393 static void
394 send_key_data (CTRL ctrl, const char *name, 
395                const unsigned char *a, size_t alen)
396 {
397   char *p, *buf = xmalloc (alen*2+1);
398   
399   for (p=buf; alen; a++, alen--, p += 2)
400     sprintf (p, "%02X", *a);
401
402   send_status_info (ctrl, "KEY-DATA",
403                     name, (size_t)strlen(name), 
404                     buf, (size_t)strlen (buf),
405                     NULL, 0);
406   xfree (buf);
407 }
408
409 /* Implement the GETATTR command.  This is similar to the LEARN
410    command but returns just one value via the status interface. */
411 static int 
412 do_getattr (APP app, CTRL ctrl, const char *name)
413 {
414   static struct {
415     const char *name;
416     int tag;
417     int special;
418   } table[] = {
419     { "DISP-NAME",    0x005B },
420     { "LOGIN-DATA",   0x005E },
421     { "DISP-LANG",    0x5F2D },
422     { "DISP-SEX",     0x5F35 },
423     { "PUBKEY-URL",   0x5F50 },
424     { "KEY-FPR",      0x00C5, 3 },
425     { "CA-FPR",       0x00C6, 3 },
426     { "CHV-STATUS",   0x00C4, 1 },
427     { "SIG-COUNTER",  0x0093, 2 },
428     { "SERIALNO",     0x004F, -1 },
429     { "AID",          0x004F },
430     { NULL, 0 }
431   };
432   int idx, i;
433   void *relptr;
434   unsigned char *value;
435   size_t valuelen;
436
437   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
438     ;
439   if (!table[idx].name)
440     return gpg_error (GPG_ERR_INV_NAME); 
441   
442   if (table[idx].special == -1)
443     {
444       /* The serial number is very special.  We could have used the
445          AID DO to retrieve it, but we have it already in the app
446          context and the stanmp argument is required anyway which we
447          can't by other means. The AID DO is available anyway but not
448          hex formatted. */
449       char *serial;
450       time_t stamp;
451       char tmp[50];
452
453       if (!app_get_serial_and_stamp (app, &serial, &stamp))
454         {
455           sprintf (tmp, "%lu", (unsigned long)stamp);
456           send_status_info (ctrl, "SERIALNO",
457                             serial, strlen (serial),
458                             tmp, strlen (tmp),
459                             NULL, 0);
460           xfree (serial);
461         }
462       return 0;
463     }
464
465   relptr = get_one_do (app->slot, table[idx].tag, &value, &valuelen);
466   if (relptr)
467     {
468       if (table[idx].special == 1)
469         {
470           char numbuf[7*23];
471           
472           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
473             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
474           send_status_info (ctrl, table[idx].name,
475                             numbuf, strlen (numbuf), NULL, 0);
476         }
477       else if (table[idx].special == 2)
478         {
479           char numbuf[50];
480
481           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
482           send_status_info (ctrl, table[idx].name,
483                             numbuf, strlen (numbuf), NULL, 0);
484         }
485       else if (table[idx].special == 3)
486         {
487           if (valuelen >= 60)
488             for (i=0; i < 3; i++)
489               send_fpr_if_not_null (ctrl, "KEY-FPR", i+1, value+i*20);
490         }
491       else
492         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
493
494       xfree (relptr);
495     }
496   return 0;
497 }
498
499
500 static int
501 do_learn_status (APP app, CTRL ctrl)
502 {
503   do_getattr (app, ctrl, "DISP-NAME");
504   do_getattr (app, ctrl, "DISP-LANG");
505   do_getattr (app, ctrl, "DISP-SEX");
506   do_getattr (app, ctrl, "PUBKEY-URL");
507   do_getattr (app, ctrl, "LOGIN-DATA");
508   do_getattr (app, ctrl, "KEY-FPR");
509   do_getattr (app, ctrl, "CA-FPR");
510   do_getattr (app, ctrl, "CHV-STATUS");
511   do_getattr (app, ctrl, "SIG-COUNTER");
512
513   return 0;
514 }
515
516
517 /* Verify CHV2 if required.  Depending on the configuration of the
518    card CHV1 will also be verified. */
519 static int
520 verify_chv2 (APP app,
521              int (*pincb)(void*, const char *, char **),
522              void *pincb_arg)
523 {
524   int rc = 0;
525
526   if (!app->did_chv2) 
527     {
528       char *pinvalue;
529
530       rc = pincb (pincb_arg, "PIN", &pinvalue); 
531       if (rc)
532         {
533           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
534           return rc;
535         }
536
537       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
538       if (rc)
539         {
540           log_error ("verify CHV2 failed: %s\n", gpg_strerror (rc));
541           xfree (pinvalue);
542           return rc;
543         }
544       app->did_chv2 = 1;
545
546       if (!app->did_chv1 && !app->force_chv1)
547         {
548           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
549           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
550             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
551           if (rc)
552             {
553               log_error ("verify CHV1 failed: %s\n", gpg_strerror (rc));
554               xfree (pinvalue);
555               return rc;
556             }
557           app->did_chv1 = 1;
558         }
559       xfree (pinvalue);
560     }
561   return rc;
562 }
563
564 /* Verify CHV3 if required. */
565 static int
566 verify_chv3 (APP app,
567              int (*pincb)(void*, const char *, char **),
568              void *pincb_arg)
569 {
570   int rc = 0;
571
572   if (!app->did_chv3) 
573     {
574       char *pinvalue;
575
576       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
577       if (rc)
578         {
579           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
580           return rc;
581         }
582
583       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
584       xfree (pinvalue);
585       if (rc)
586         {
587           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
588           return rc;
589         }
590       app->did_chv3 = 1;
591     }
592   return rc;
593 }
594
595
596 /* Handle the SETATTR operation. All arguments are already basically
597    checked. */
598 static int 
599 do_setattr (APP app, const char *name,
600             int (*pincb)(void*, const char *, char **),
601             void *pincb_arg,
602             const unsigned char *value, size_t valuelen)
603 {
604   gpg_error_t rc;
605   int idx;
606   static struct {
607     const char *name;
608     int tag;
609   } table[] = {
610     { "DISP-NAME",    0x005B },
611     { "LOGIN-DATA",   0x005E },
612     { "DISP-LANG",    0x5F2D },
613     { "DISP-SEX",     0x5F35 },
614     { "PUBKEY-URL",   0x5F50 },
615     { "CHV-STATUS-1", 0x00C4 },
616     { "CA-FPR-1",     0x00CA },
617     { "CA-FPR-2",     0x00CB },
618     { "CA-FPR-3",     0x00CC },
619     { NULL, 0 }
620   };
621
622
623   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
624     ;
625   if (!table[idx].name)
626     return gpg_error (GPG_ERR_INV_NAME); 
627
628   rc = verify_chv3 (app, pincb, pincb_arg);
629   if (rc)
630     return rc;
631
632   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
633   if (rc)
634     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
635
636   return rc;
637 }
638
639
640 /* Handle the PASSWD command. */
641 static int 
642 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
643                int (*pincb)(void*, const char *, char **),
644                void *pincb_arg)
645 {
646   int rc = 0;
647   int chvno = atoi (chvnostr);
648   char *pinvalue;
649
650   if (reset_mode && chvno == 3)
651     {
652       rc = gpg_error (GPG_ERR_INV_ID);
653       goto leave;
654     }
655   else if (reset_mode || chvno == 3)
656     {
657       /* we always require that the PIN is entered. */
658       app->did_chv3 = 0;
659       rc = verify_chv3 (app, pincb, pincb_arg);
660       if (rc)
661         goto leave;
662     }
663   else if (chvno == 1 || chvno == 2)
664     {
665       /* CHV1 and CVH2 should always have the same value, thus we
666          enforce it here.  */
667       int save_force = app->force_chv1;
668
669       app->force_chv1 = 0;
670       app->did_chv1 = 0;
671       app->did_chv2 = 0;
672       rc = verify_chv2 (app, pincb, pincb_arg);
673       app->force_chv1 = save_force;
674       if (rc)
675         goto leave;
676     }
677   else
678     {
679       rc = gpg_error (GPG_ERR_INV_ID);
680       goto leave;
681     }
682
683   if (chvno == 3)
684     app->did_chv3 = 0;
685   else
686     app->did_chv1 = app->did_chv2 = 0;
687
688   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
689   if (rc)
690     {
691       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
692       goto leave;
693     }
694
695   if (reset_mode)
696     {
697       rc = iso7816_reset_retry_counter (app->slot, 0x81,
698                                         pinvalue, strlen (pinvalue));
699       if (!rc)
700         rc = iso7816_reset_retry_counter (app->slot, 0x82,
701                                           pinvalue, strlen (pinvalue));
702     }
703   else
704     {
705       if (chvno == 1 || chvno == 2)
706         {
707           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
708                                               pinvalue, strlen (pinvalue));
709           if (!rc)
710             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
711                                                 pinvalue, strlen (pinvalue));
712         }
713       else
714         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
715                                             pinvalue, strlen (pinvalue));
716     }
717   xfree (pinvalue);
718
719
720  leave:
721   return rc;
722 }
723
724
725
726 /* Handle the GENKEY command. */
727 static int 
728 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
729           int (*pincb)(void*, const char *, char **),
730           void *pincb_arg)
731 {
732   int rc;
733   int i;
734   char numbuf[30];
735   unsigned char fprbuf[20];
736   const unsigned char *fpr;
737   const unsigned char *keydata, *m, *e;
738   unsigned char *buffer;
739   size_t buflen, keydatalen, n, mlen, elen;
740   time_t created_at;
741   int keyno = atoi (keynostr);
742   int force = (flags & 1);
743   time_t start_at;
744
745   if (keyno < 1 || keyno > 3)
746     return gpg_error (GPG_ERR_INV_ID);
747   keyno--;
748
749   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
750   if (rc)
751     {
752       log_error ("error reading application data\n");
753       return gpg_error (GPG_ERR_GENERAL);
754     }
755   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
756   if (!fpr || n != 60)
757     {
758       rc = gpg_error (GPG_ERR_GENERAL);
759       log_error ("error reading fingerprint DO\n");
760       goto leave;
761     }
762   fpr += 20*keyno;
763   for (i=0; i < 20 && !fpr[i]; i++)
764     ;
765   if (i!=20 && !force)
766     {
767       rc = gpg_error (GPG_ERR_EEXIST);
768       log_error ("key already exists\n");
769       goto leave;
770     }
771   else if (i!=20)
772     log_info ("existing key will be replaced\n");
773   else
774     log_info ("generating new key\n");
775
776
777   rc = verify_chv3 (app, pincb, pincb_arg);
778   if (rc)
779     goto leave;
780
781   xfree (buffer); buffer = NULL;
782 #if 1
783   log_info ("please wait while key is being generated ...\n");
784   start_at = time (NULL);
785   rc = iso7816_generate_keypair 
786 #else
787 #warning key generation temporary replaced by reading an existing key.
788   rc = iso7816_read_public_key
789 #endif
790                               (app->slot, 
791                                  keyno == 0? "\xB6" :
792                                  keyno == 1? "\xB8" : "\xA4",
793                                  2,
794                                  &buffer, &buflen);
795   if (rc)
796     {
797       rc = gpg_error (GPG_ERR_CARD);
798       log_error ("generating key failed\n");
799       goto leave;
800     }
801   log_info ("key generation completed (%d seconds)\n",
802             (int)(time (NULL) - start_at));
803   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
804   if (!keydata)
805     {
806       rc = gpg_error (GPG_ERR_CARD);
807       log_error ("response does not contain the public key data\n");
808       goto leave;
809     }
810  
811   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
812   if (!m)
813     {
814       rc = gpg_error (GPG_ERR_CARD);
815       log_error ("response does not contain the RSA modulus\n");
816       goto leave;
817     }
818 /*    log_printhex ("RSA n:", m, mlen); */
819   send_key_data (ctrl, "n", m, mlen);
820
821   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
822   if (!e)
823     {
824       rc = gpg_error (GPG_ERR_CARD);
825       log_error ("response does not contain the RSA public exponent\n");
826       goto leave;
827     }
828 /*    log_printhex ("RSA e:", e, elen); */
829   send_key_data (ctrl, "e", e, elen);
830
831   created_at = gnupg_get_time ();
832   sprintf (numbuf, "%lu", (unsigned long)created_at);
833   send_status_info (ctrl, "KEY-CREATED-AT",
834                     numbuf, (size_t)strlen(numbuf), NULL, 0);
835
836   rc = store_fpr (app->slot, keyno, (u32)created_at,
837                   m, mlen, e, elen, fprbuf, app->card_version);
838   if (rc)
839     goto leave;
840   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
841
842
843  leave:
844   xfree (buffer);
845   return rc;
846 }
847
848
849 static unsigned long
850 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
851 {
852   unsigned long ul;
853
854   if (valuelen == 3 )
855     ul = (value[0] << 16) | (value[1] << 8) | value[2];
856   else
857     {
858       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
859       ul = 0;
860     }
861   return ul;
862 }
863
864 static unsigned long
865 get_sig_counter (APP app)
866 {
867   void *relptr;
868   unsigned char *value;
869   size_t valuelen;
870   unsigned long ul;
871
872   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
873   if (!relptr)
874     return 0;
875   ul = convert_sig_counter_value (value, valuelen);
876   xfree (relptr);
877   return ul;
878 }
879
880 static int
881 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
882 {
883   const unsigned char *fpr;
884   unsigned char *buffer;
885   size_t buflen, n;
886   int rc, i;
887   
888   assert (keyno >= 1 && keyno <= 3);
889
890   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
891   if (rc)
892     {
893       log_error ("error reading application data\n");
894       return gpg_error (GPG_ERR_GENERAL);
895     }
896   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
897   if (!fpr || n != 60)
898     {
899       xfree (buffer);
900       log_error ("error reading fingerprint DO\n");
901       return gpg_error (GPG_ERR_GENERAL);
902     }
903   fpr += (keyno-1)*20;
904   for (i=0; i < 20; i++)
905     if (sha1fpr[i] != fpr[i])
906       {
907         xfree (buffer);
908         return gpg_error (GPG_ERR_WRONG_SECKEY);
909       }
910   xfree (buffer);
911   return 0;
912 }
913
914
915   /* If a fingerprint has been specified check it against the one on
916      the card.  This is allows for a meaningful error message in case
917      the key on the card has been replaced but the shadow information
918      known to gpg was not updated.  If there is no fingerprint we
919      assume that this is okay. */
920 static int
921 check_against_given_fingerprint (APP app, const char *fpr, int keyno)
922 {
923   unsigned char tmp[20];
924   const char *s;
925   int n;
926
927   for (s=fpr, n=0; hexdigitp (s); s++, n++)
928     ;
929   if (n != 40)
930     return gpg_error (GPG_ERR_INV_ID);
931   else if (!*s)
932     ; /* okay */
933   else
934     return gpg_error (GPG_ERR_INV_ID);
935
936   for (s=fpr, n=0; n < 20; s += 2, n++)
937         tmp[n] = xtoi_2 (s);
938   return compare_fingerprint (app, keyno, tmp);
939 }
940
941
942
943 /* Compute a digital signature on INDATA which is expected to be the
944    raw message digest. For this application the KEYIDSTR consists of
945    the serialnumber and the fingerprint delimited by a slash.
946
947    Note that this fucntion may return the error code
948    GPG_ERR_WRONG_CARD to indicate that the card currently present does
949    not match the one required for the requested action (e.g. the
950    serial number does not match). */
951 static int 
952 do_sign (APP app, const char *keyidstr, int hashalgo,
953          int (*pincb)(void*, const char *, char **),
954          void *pincb_arg,
955          const void *indata, size_t indatalen,
956          unsigned char **outdata, size_t *outdatalen )
957 {
958   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
959   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
960     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
961   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
962   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
963     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
964   int rc;
965   unsigned char data[35];
966   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
967   const char *s;
968   int n;
969   const char *fpr = NULL;
970   unsigned long sigcount;
971
972   if (!keyidstr || !*keyidstr)
973     return gpg_error (GPG_ERR_INV_VALUE);
974   if (indatalen != 20)
975     return gpg_error (GPG_ERR_INV_VALUE);
976
977   /* Check whether an OpenPGP card of any version has been requested. */
978   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
979     return gpg_error (GPG_ERR_INV_ID);
980   
981   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
982     ;
983   if (n != 32)
984     return gpg_error (GPG_ERR_INV_ID);
985   else if (!*s)
986     ; /* no fingerprint given: we allow this for now. */
987   else if (*s == '/')
988     fpr = s + 1; 
989   else
990     return gpg_error (GPG_ERR_INV_ID);
991
992   for (s=keyidstr, n=0; n < 16; s += 2, n++)
993     tmp_sn[n] = xtoi_2 (s);
994
995   if (app->serialnolen != 16)
996     return gpg_error (GPG_ERR_INV_CARD);
997   if (memcmp (app->serialno, tmp_sn, 16))
998     return gpg_error (GPG_ERR_WRONG_CARD);
999
1000   /* If a fingerprint has been specified check it against the one on
1001      the card.  This is allows for a meaningful error message in case
1002      the key on the card has been replaced but the shadow information
1003      known to gpg was not updated.  If there is no fingerprint, gpg
1004      will detect a bogus signature anyway due to the
1005      verify-after-signing feature. */
1006   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1007   if (rc)
1008     return rc;
1009
1010   if (hashalgo == GCRY_MD_SHA1)
1011     memcpy (data, sha1_prefix, 15);
1012   else if (hashalgo == GCRY_MD_RMD160)
1013     memcpy (data, rmd160_prefix, 15);
1014   else 
1015     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1016   memcpy (data+15, indata, indatalen);
1017
1018   sigcount = get_sig_counter (app);
1019   log_info ("signatures created so far: %lu\n", sigcount);
1020
1021   if (!app->did_chv1 || app->force_chv1 ) 
1022     {
1023       char *pinvalue;
1024
1025       {
1026         char *prompt;
1027         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
1028           return gpg_error_from_errno (errno);
1029         rc = pincb (pincb_arg, prompt, &pinvalue); 
1030         free (prompt);
1031       }
1032       if (rc)
1033         {
1034           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1035           return rc;
1036         }
1037
1038       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1039       if (rc)
1040         {
1041           log_error ("verify CHV1 failed\n");
1042           xfree (pinvalue);
1043           return rc;
1044         }
1045       app->did_chv1 = 1;
1046       if (!app->did_chv2)
1047         {
1048           /* We should also verify CHV2. */
1049           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1050           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1051             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1052           if (rc)
1053             {
1054               log_error ("verify CHV2 failed\n");
1055               xfree (pinvalue);
1056               return rc;
1057             }
1058           app->did_chv2 = 1;
1059         }
1060       xfree (pinvalue);
1061     }
1062
1063   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1064   return rc;
1065 }
1066
1067 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1068    on INDATA which is expected to be the raw message digest. For this
1069    application the KEYIDSTR consists of the serialnumber and the
1070    fingerprint delimited by a slash.
1071
1072    Note that this fucntion may return the error code
1073    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1074    not match the one required for the requested action (e.g. the
1075    serial number does not match). */
1076 static int 
1077 do_auth (APP app, const char *keyidstr,
1078          int (*pincb)(void*, const char *, char **),
1079          void *pincb_arg,
1080          const void *indata, size_t indatalen,
1081          unsigned char **outdata, size_t *outdatalen )
1082 {
1083   int rc;
1084   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1085   const char *s;
1086   int n;
1087   const char *fpr = NULL;
1088
1089   if (!keyidstr || !*keyidstr)
1090     return gpg_error (GPG_ERR_INV_VALUE);
1091   if (indatalen > 50) /* For a 1024 bit key. */
1092     return gpg_error (GPG_ERR_INV_VALUE);
1093
1094   /* Check whether an OpenPGP card of any version has been requested. */
1095   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1096     return gpg_error (GPG_ERR_INV_ID);
1097   
1098   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1099     ;
1100   if (n != 32)
1101     return gpg_error (GPG_ERR_INV_ID);
1102   else if (!*s)
1103     ; /* no fingerprint given: we allow this for now. */
1104   else if (*s == '/')
1105     fpr = s + 1; 
1106   else
1107     return gpg_error (GPG_ERR_INV_ID);
1108
1109   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1110     tmp_sn[n] = xtoi_2 (s);
1111
1112   if (app->serialnolen != 16)
1113     return gpg_error (GPG_ERR_INV_CARD);
1114   if (memcmp (app->serialno, tmp_sn, 16))
1115     return gpg_error (GPG_ERR_WRONG_CARD);
1116
1117   /* If a fingerprint has been specified check it against the one on
1118      the card.  This is allows for a meaningful error message in case
1119      the key on the card has been replaced but the shadow information
1120      known to gpg was not updated.  If there is no fingerprint, gpg
1121      will detect a bogus signature anyway due to the
1122      verify-after-signing feature. */
1123   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1124   if (rc)
1125     return rc;
1126
1127   rc = verify_chv2 (app, pincb, pincb_arg);
1128   if (!rc)
1129     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1130                                         outdata, outdatalen);
1131   return rc;
1132 }
1133
1134
1135 static int 
1136 do_decipher (APP app, const char *keyidstr,
1137              int (pincb)(void*, const char *, char **),
1138              void *pincb_arg,
1139              const void *indata, size_t indatalen,
1140              unsigned char **outdata, size_t *outdatalen )
1141 {
1142   int rc;
1143   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1144   const char *s;
1145   int n;
1146   const char *fpr = NULL;
1147
1148   if (!keyidstr || !*keyidstr || !indatalen)
1149     return gpg_error (GPG_ERR_INV_VALUE);
1150
1151   /* Check whether an OpenPGP card of any version has been requested. */
1152   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1153     return gpg_error (GPG_ERR_INV_ID);
1154   
1155   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1156     ;
1157   if (n != 32)
1158     return gpg_error (GPG_ERR_INV_ID);
1159   else if (!*s)
1160     ; /* no fingerprint given: we allow this for now. */
1161   else if (*s == '/')
1162     fpr = s + 1; 
1163   else
1164     return gpg_error (GPG_ERR_INV_ID);
1165
1166   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1167     tmp_sn[n] = xtoi_2 (s);
1168
1169   if (app->serialnolen != 16)
1170     return gpg_error (GPG_ERR_INV_CARD);
1171   if (memcmp (app->serialno, tmp_sn, 16))
1172     return gpg_error (GPG_ERR_WRONG_CARD);
1173
1174   /* If a fingerprint has been specified check it against the one on
1175      the card.  This is allows for a meaningful error message in case
1176      the key on the card has been replaced but the shadow information
1177      known to gpg was not updated.  If there is no fingerprint, the
1178      decryption will won't produce the right plaintext anyway. */
1179   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1180   if (rc)
1181     return rc;
1182
1183   rc = verify_chv2 (app, pincb, pincb_arg);
1184   if (!rc)
1185     rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1186   return rc;
1187 }
1188
1189
1190 /* Perform a simple verify operation for CHV1 and CHV2, so that
1191    further operations won't ask for CHV2 and it is possible to do a
1192    cheap check on the PIN: If there is something wrong with the PIN
1193    entry system, only the regular CHV will get blocked and not the
1194    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1195    optional fingerprint part will be ignored. */
1196 static int 
1197 do_check_pin (APP app, const char *keyidstr,
1198               int (pincb)(void*, const char *, char **),
1199               void *pincb_arg)
1200 {
1201   unsigned char tmp_sn[20]; 
1202   const char *s;
1203   int n;
1204
1205   if (!keyidstr || !*keyidstr)
1206     return gpg_error (GPG_ERR_INV_VALUE);
1207
1208   /* Check whether an OpenPGP card of any version has been requested. */
1209   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1210     return gpg_error (GPG_ERR_INV_ID);
1211   
1212   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1213     ;
1214   if (n != 32)
1215     return gpg_error (GPG_ERR_INV_ID);
1216   else if (!*s)
1217     ; /* No fingerprint given: we allow this for now. */
1218   else if (*s == '/')
1219     ; /* We ignore a fingerprint. */
1220   else
1221     return gpg_error (GPG_ERR_INV_ID);
1222
1223   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1224     tmp_sn[n] = xtoi_2 (s);
1225
1226   if (app->serialnolen != 16)
1227     return gpg_error (GPG_ERR_INV_CARD);
1228   if (memcmp (app->serialno, tmp_sn, 16))
1229     return gpg_error (GPG_ERR_WRONG_CARD);
1230   /* Yes, there is a race conditions: The user might pull the card
1231      right here and we won't notice that.  However this is not a
1232      problem and the check above is merely for a graceful failure
1233      between operations. */
1234
1235   return verify_chv2 (app, pincb, pincb_arg);
1236 }
1237
1238
1239
1240
1241 /* Select the OpenPGP application on the card in SLOT.  This function
1242    must be used before any other OpenPGP application functions. */
1243 int
1244 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1245 {
1246   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1247   int slot = app->slot;
1248   int rc;
1249   unsigned char *buffer;
1250   size_t buflen;
1251   void *relptr;
1252   
1253   rc = iso7816_select_application (slot, aid, sizeof aid);
1254   if (!rc)
1255     {
1256       app->did_chv1 = 0;
1257       app->did_chv2 = 0;
1258       app->did_chv3 = 0;
1259
1260       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1261       if (rc)
1262         goto leave;
1263       if (opt.verbose)
1264         {
1265           log_info ("got AID: ");
1266           log_printhex ("", buffer, buflen);
1267         }
1268
1269       if (sn)
1270         {
1271           *sn = buffer;
1272           *snlen = buflen;
1273           app->card_version = buffer[6] << 8;
1274           app->card_version |= buffer[7];
1275         }
1276       else
1277         xfree (buffer);
1278
1279       relptr = get_one_do (app->slot, 0x00C4, &buffer, &buflen);
1280       if (!relptr)
1281         {
1282           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1283           goto leave;
1284         }
1285       app->force_chv1 = (buflen && *buffer == 0);
1286       xfree (relptr);
1287         
1288       if (opt.verbose > 1)
1289         dump_all_do (slot);
1290
1291       app->fnc.learn_status = do_learn_status;
1292       app->fnc.getattr = do_getattr;
1293       app->fnc.setattr = do_setattr;
1294       app->fnc.genkey = do_genkey;
1295       app->fnc.sign = do_sign;
1296       app->fnc.auth = do_auth;
1297       app->fnc.decipher = do_decipher;
1298       app->fnc.change_pin = do_change_pin;
1299       app->fnc.check_pin = do_check_pin;
1300    }
1301
1302 leave:
1303   return rc;
1304 }
1305
1306
1307
1308 /* This function is a hack to retrieve essential information about the
1309    card to be displayed by simple tools.  It mostly resembles what the
1310    LEARN command returns. All parameters return allocated strings or
1311    buffers or NULL if the data object is not available.  All returned
1312    values are sanitized. */
1313 int
1314 app_openpgp_cardinfo (APP app,
1315                       char **serialno,
1316                       char **disp_name,
1317                       char **pubkey_url,
1318                       unsigned char **fpr1,
1319                       unsigned char **fpr2,
1320                       unsigned char **fpr3)
1321 {
1322   int rc;
1323   void *relptr;
1324   unsigned char *value;
1325   size_t valuelen;
1326
1327   if (serialno)
1328     {
1329       time_t dummy;
1330
1331       *serialno = NULL;
1332       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1333       if (rc)
1334         {
1335           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1336           return rc;
1337         }
1338     }
1339       
1340   if (disp_name)
1341     {
1342       *disp_name = NULL;
1343       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1344       if (relptr)
1345         {
1346           *disp_name = make_printable_string (value, valuelen, 0);
1347           xfree (relptr);
1348         }
1349     }
1350
1351   if (pubkey_url)
1352     {
1353       *pubkey_url = NULL;
1354       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1355       if (relptr)
1356         {
1357           *pubkey_url = make_printable_string (value, valuelen, 0);
1358           xfree (relptr);
1359         }
1360     }
1361
1362   if (fpr1)
1363     *fpr1 = NULL;
1364   if (fpr2)
1365     *fpr2 = NULL;
1366   if (fpr3)
1367     *fpr3 = NULL;
1368   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1369   if (relptr && valuelen >= 60)
1370     {
1371       if (fpr1)
1372         {
1373           *fpr1 = xmalloc (20);
1374           memcpy (*fpr1, value +  0, 20);
1375         }
1376       if (fpr2)
1377         {
1378           *fpr2 = xmalloc (20);
1379           memcpy (*fpr2, value + 20, 20);
1380         }
1381       if (fpr3)
1382         {
1383           *fpr3 = xmalloc (20);
1384           memcpy (*fpr3, value + 40, 20);
1385         }
1386     }
1387   xfree (relptr);
1388
1389   return 0;
1390 }
1391
1392
1393
1394 /* This function is currently only used by the sc-copykeys program to
1395    store a key on the smartcard.  APP ist the application handle,
1396    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1397    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1398    the key template to store. CREATED_AT is the timestamp used to
1399    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1400    RSA public exponent. This function silently overwrites an existing
1401    key.*/
1402 int 
1403 app_openpgp_storekey (APP app, int keyno,
1404                       unsigned char *template, size_t template_len,
1405                       time_t created_at,
1406                       const unsigned char *m, size_t mlen,
1407                       const unsigned char *e, size_t elen,
1408                       int (*pincb)(void*, const char *, char **),
1409                       void *pincb_arg)
1410 {
1411   int rc;
1412   unsigned char fprbuf[20];
1413
1414   if (keyno < 1 || keyno > 3)
1415     return gpg_error (GPG_ERR_INV_ID);
1416   keyno--;
1417
1418   rc = verify_chv3 (app, pincb, pincb_arg);
1419   if (rc)
1420     goto leave;
1421
1422
1423   rc = iso7816_put_data (app->slot,
1424                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1425                          template, template_len);
1426   if (rc)
1427     {
1428       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1429       rc = gpg_error (GPG_ERR_CARD);
1430       goto leave;
1431     }
1432  
1433 /*    log_printhex ("RSA n:", m, mlen);  */
1434 /*    log_printhex ("RSA e:", e, elen);  */
1435
1436   rc = store_fpr (app->slot, keyno, (u32)created_at,
1437                   m, mlen, e, elen, fprbuf, app->card_version);
1438
1439  leave:
1440   return rc;
1441 }
1442
1443
1444 /* Utility function for external tools: Read the public RSA key at
1445    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1446 int 
1447 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1448                      unsigned char **e, size_t *elen)
1449 {
1450   int rc;
1451   const unsigned char *keydata, *a;
1452   unsigned char *buffer;
1453   size_t buflen, keydatalen, alen;
1454
1455   *m = NULL;
1456   *e = NULL;
1457
1458   if (keyno < 1 || keyno > 3)
1459     return gpg_error (GPG_ERR_INV_ID);
1460   keyno--;
1461
1462   rc = iso7816_read_public_key(app->slot, 
1463                                keyno == 0? "\xB6" :
1464                                keyno == 1? "\xB8" : "\xA4",
1465                                2,
1466                                &buffer, &buflen);
1467   if (rc)
1468     {
1469       rc = gpg_error (GPG_ERR_CARD);
1470       log_error ("reading key failed\n");
1471       goto leave;
1472     }
1473
1474   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1475   if (!keydata)
1476     {
1477       log_error ("response does not contain the public key data\n");
1478       rc = gpg_error (GPG_ERR_CARD);
1479       goto leave;
1480     }
1481  
1482   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1483   if (!a)
1484     {
1485       log_error ("response does not contain the RSA modulus\n");
1486       rc = gpg_error (GPG_ERR_CARD);
1487       goto leave;
1488     }
1489   *mlen = alen;
1490   *m = xmalloc (alen);
1491   memcpy (*m, a, alen);
1492   
1493   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1494   if (!e)
1495     {
1496       log_error ("response does not contain the RSA public exponent\n");
1497       rc = gpg_error (GPG_ERR_CARD);
1498       goto leave;
1499     }
1500   *elen = alen;
1501   *e = xmalloc (alen);
1502   memcpy (*e, a, alen);
1503
1504  leave:
1505   xfree (buffer);
1506   if (rc)
1507     { 
1508       xfree (*m); *m = NULL;
1509       xfree (*e); *e = NULL;
1510     }
1511   return rc;
1512 }