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