e8fe19ea156e69a7873855ff9162240b99c52ff0
[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 #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     { NULL, 0 }
429   };
430   int idx, i;
431   void *relptr;
432   unsigned char *value;
433   size_t valuelen;
434
435   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
436     ;
437   if (!table[idx].name)
438     return gpg_error (GPG_ERR_INV_NAME); 
439   
440   relptr = get_one_do (app->slot, table[idx].tag, &value, &valuelen);
441   if (relptr)
442     {
443       if (table[idx].special == 1)
444         {
445           char numbuf[7*23];
446           
447           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
448             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
449           send_status_info (ctrl, table[idx].name,
450                             numbuf, strlen (numbuf), NULL, 0);
451         }
452       else if (table[idx].special == 2)
453         {
454           char numbuf[50];
455
456           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
457           send_status_info (ctrl, table[idx].name,
458                             numbuf, strlen (numbuf), NULL, 0);
459         }
460       else if (table[idx].special == 3)
461         {
462           if (valuelen >= 60)
463             for (i=0; i < 3; i++)
464               send_fpr_if_not_null (ctrl, "KEY-FPR", i+1, value+i*20);
465         }
466       else
467         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
468
469       xfree (relptr);
470     }
471   return 0;
472 }
473
474
475 static int
476 do_learn_status (APP app, CTRL ctrl)
477 {
478   do_getattr (app, ctrl, "DISP-NAME");
479   do_getattr (app, ctrl, "DISP-LANG");
480   do_getattr (app, ctrl, "DISP-SEX");
481   do_getattr (app, ctrl, "PUBKEY-URL");
482   do_getattr (app, ctrl, "LOGIN-DATA");
483   do_getattr (app, ctrl, "KEY-FPR");
484   do_getattr (app, ctrl, "CA-FPR");
485   do_getattr (app, ctrl, "CHV-STATUS");
486   do_getattr (app, ctrl, "SIG-COUNTER");
487
488   return 0;
489 }
490
491
492 /* Verify CHV2 if required.  Depending on the configuration of the
493    card CHV1 will also be verified. */
494 static int
495 verify_chv2 (APP app,
496              int (*pincb)(void*, const char *, char **),
497              void *pincb_arg)
498 {
499   int rc = 0;
500
501   if (!app->did_chv2) 
502     {
503       char *pinvalue;
504
505       rc = pincb (pincb_arg, "PIN", &pinvalue); 
506       if (rc)
507         {
508           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
509           return rc;
510         }
511
512       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
513       if (rc)
514         {
515           log_error ("verify CHV2 failed: %s\n", gpg_strerror (rc));
516           xfree (pinvalue);
517           return rc;
518         }
519       app->did_chv2 = 1;
520
521       if (!app->did_chv1 && !app->force_chv1)
522         {
523           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
524           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
525             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
526           if (rc)
527             {
528               log_error ("verify CHV1 failed: %s\n", gpg_strerror (rc));
529               xfree (pinvalue);
530               return rc;
531             }
532           app->did_chv1 = 1;
533         }
534       xfree (pinvalue);
535     }
536   return rc;
537 }
538
539 /* Verify CHV3 if required. */
540 static int
541 verify_chv3 (APP app,
542              int (*pincb)(void*, const char *, char **),
543              void *pincb_arg)
544 {
545   int rc = 0;
546
547   if (!app->did_chv3) 
548     {
549       char *pinvalue;
550
551       rc = pincb (pincb_arg, "Admin PIN", &pinvalue); 
552       if (rc)
553         {
554           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
555           return rc;
556         }
557
558       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
559       xfree (pinvalue);
560       if (rc)
561         {
562           log_error ("verify CHV3 failed: %s\n", gpg_strerror (rc));
563           return rc;
564         }
565       app->did_chv3 = 1;
566     }
567   return rc;
568 }
569
570
571 /* Handle the SETATTR operation. All arguments are already basically
572    checked. */
573 static int 
574 do_setattr (APP app, const char *name,
575             int (*pincb)(void*, const char *, char **),
576             void *pincb_arg,
577             const unsigned char *value, size_t valuelen)
578 {
579   gpg_error_t rc;
580   int idx;
581   static struct {
582     const char *name;
583     int tag;
584   } table[] = {
585     { "DISP-NAME",    0x005B },
586     { "LOGIN-DATA",   0x005E },
587     { "DISP-LANG",    0x5F2D },
588     { "DISP-SEX",     0x5F35 },
589     { "PUBKEY-URL",   0x5F50 },
590     { "CHV-STATUS-1", 0x00C4 },
591     { "CA-FPR-1",     0x00CA },
592     { "CA-FPR-2",     0x00CB },
593     { "CA-FPR-3",     0x00CC },
594     { NULL, 0 }
595   };
596
597
598   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
599     ;
600   if (!table[idx].name)
601     return gpg_error (GPG_ERR_INV_NAME); 
602
603   rc = verify_chv3 (app, pincb, pincb_arg);
604   if (rc)
605     return rc;
606
607   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
608   if (rc)
609     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
610
611   return rc;
612 }
613
614
615 /* Handle the PASSWD command. */
616 static int 
617 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
618                int (*pincb)(void*, const char *, char **),
619                void *pincb_arg)
620 {
621   int rc = 0;
622   int chvno = atoi (chvnostr);
623   char *pinvalue;
624
625   if (reset_mode && chvno == 3)
626     {
627       rc = gpg_error (GPG_ERR_INV_ID);
628       goto leave;
629     }
630   else if (reset_mode || chvno == 3)
631     {
632       /* we always require that the PIN is entered. */
633       app->did_chv3 = 0;
634       rc = verify_chv3 (app, pincb, pincb_arg);
635       if (rc)
636         goto leave;
637     }
638   else if (chvno == 1 || chvno == 2)
639     {
640       /* CHV1 and CVH2 should always have the same value, thus we
641          enforce it here.  */
642       int save_force = app->force_chv1;
643
644       app->force_chv1 = 0;
645       app->did_chv1 = 0;
646       app->did_chv2 = 0;
647       rc = verify_chv2 (app, pincb, pincb_arg);
648       app->force_chv1 = save_force;
649       if (rc)
650         goto leave;
651     }
652   else
653     {
654       rc = gpg_error (GPG_ERR_INV_ID);
655       goto leave;
656     }
657
658   if (chvno == 3)
659     app->did_chv3 = 0;
660   else
661     app->did_chv1 = app->did_chv2 = 0;
662
663   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
664   if (rc)
665     {
666       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
667       goto leave;
668     }
669
670   if (reset_mode)
671     {
672       rc = iso7816_reset_retry_counter (app->slot, 0x81,
673                                         pinvalue, strlen (pinvalue));
674       if (!rc)
675         rc = iso7816_reset_retry_counter (app->slot, 0x82,
676                                           pinvalue, strlen (pinvalue));
677     }
678   else
679     {
680       if (chvno == 1 || chvno == 2)
681         {
682           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
683                                               pinvalue, strlen (pinvalue));
684           if (!rc)
685             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
686                                                 pinvalue, strlen (pinvalue));
687         }
688       else
689         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
690                                             pinvalue, strlen (pinvalue));
691     }
692   xfree (pinvalue);
693
694
695  leave:
696   return rc;
697 }
698
699
700
701 /* Handle the GENKEY command. */
702 static int 
703 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
704           int (*pincb)(void*, const char *, char **),
705           void *pincb_arg)
706 {
707   int rc;
708   int i;
709   char numbuf[30];
710   unsigned char fprbuf[20];
711   const unsigned char *fpr;
712   const unsigned char *keydata, *m, *e;
713   unsigned char *buffer;
714   size_t buflen, keydatalen, n, mlen, elen;
715   time_t created_at;
716   int keyno = atoi (keynostr);
717   int force = (flags & 1);
718   time_t start_at;
719
720   if (keyno < 1 || keyno > 3)
721     return gpg_error (GPG_ERR_INV_ID);
722   keyno--;
723
724   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
725   if (rc)
726     {
727       log_error ("error reading application data\n");
728       return gpg_error (GPG_ERR_GENERAL);
729     }
730   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
731   if (!fpr || n != 60)
732     {
733       rc = gpg_error (GPG_ERR_GENERAL);
734       log_error ("error reading fingerprint DO\n");
735       goto leave;
736     }
737   fpr += 20*keyno;
738   for (i=0; i < 20 && !fpr[i]; i++)
739     ;
740   if (i!=20 && !force)
741     {
742       rc = gpg_error (GPG_ERR_EEXIST);
743       log_error ("key already exists\n");
744       goto leave;
745     }
746   else if (i!=20)
747     log_info ("existing key will be replaced\n");
748   else
749     log_info ("generating new key\n");
750
751
752   rc = verify_chv3 (app, pincb, pincb_arg);
753   if (rc)
754     goto leave;
755
756   xfree (buffer); buffer = NULL;
757 #if 1
758   log_info ("please wait while key is being generated ...\n");
759   start_at = time (NULL);
760   rc = iso7816_generate_keypair 
761 #else
762 #warning key generation temporary replaced by reading an existing key.
763   rc = iso7816_read_public_key
764 #endif
765                               (app->slot, 
766                                  keyno == 0? "\xB6" :
767                                  keyno == 1? "\xB8" : "\xA4",
768                                  2,
769                                  &buffer, &buflen);
770   if (rc)
771     {
772       rc = gpg_error (GPG_ERR_CARD);
773       log_error ("generating key failed\n");
774       goto leave;
775     }
776   log_info ("key generation completed (%d seconds)\n",
777             (int)(time (NULL) - start_at));
778   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
779   if (!keydata)
780     {
781       rc = gpg_error (GPG_ERR_CARD);
782       log_error ("response does not contain the public key data\n");
783       goto leave;
784     }
785  
786   m = find_tlv (keydata, keydatalen, 0x0081, &mlen, 0);
787   if (!m)
788     {
789       rc = gpg_error (GPG_ERR_CARD);
790       log_error ("response does not contain the RSA modulus\n");
791       goto leave;
792     }
793 /*    log_printhex ("RSA n:", m, mlen); */
794   send_key_data (ctrl, "n", m, mlen);
795
796   e = find_tlv (keydata, keydatalen, 0x0082, &elen, 0);
797   if (!e)
798     {
799       rc = gpg_error (GPG_ERR_CARD);
800       log_error ("response does not contain the RSA public exponent\n");
801       goto leave;
802     }
803 /*    log_printhex ("RSA e:", e, elen); */
804   send_key_data (ctrl, "e", e, elen);
805
806   created_at = gnupg_get_time ();
807   sprintf (numbuf, "%lu", (unsigned long)created_at);
808   send_status_info (ctrl, "KEY-CREATED-AT",
809                     numbuf, (size_t)strlen(numbuf), NULL, 0);
810
811   rc = store_fpr (app->slot, keyno, (u32)created_at,
812                   m, mlen, e, elen, fprbuf, app->card_version);
813   if (rc)
814     goto leave;
815   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
816
817
818  leave:
819   xfree (buffer);
820   return rc;
821 }
822
823
824 static unsigned long
825 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
826 {
827   unsigned long ul;
828
829   if (valuelen == 3 )
830     ul = (value[0] << 16) | (value[1] << 8) | value[2];
831   else
832     {
833       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
834       ul = 0;
835     }
836   return ul;
837 }
838
839 static unsigned long
840 get_sig_counter (APP app)
841 {
842   void *relptr;
843   unsigned char *value;
844   size_t valuelen;
845   unsigned long ul;
846
847   relptr = get_one_do (app->slot, 0x0093, &value, &valuelen);
848   if (!relptr)
849     return 0;
850   ul = convert_sig_counter_value (value, valuelen);
851   xfree (relptr);
852   return ul;
853 }
854
855 static int
856 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
857 {
858   const unsigned char *fpr;
859   unsigned char *buffer;
860   size_t buflen, n;
861   int rc, i;
862   
863   assert (keyno >= 1 && keyno <= 3);
864
865   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
866   if (rc)
867     {
868       log_error ("error reading application data\n");
869       return gpg_error (GPG_ERR_GENERAL);
870     }
871   fpr = find_tlv (buffer, buflen, 0x00C5, &n, 0);
872   if (!fpr || n != 60)
873     {
874       xfree (buffer);
875       log_error ("error reading fingerprint DO\n");
876       return gpg_error (GPG_ERR_GENERAL);
877     }
878   fpr += (keyno-1)*20;
879   for (i=0; i < 20; i++)
880     if (sha1fpr[i] != fpr[i])
881       {
882         xfree (buffer);
883         return gpg_error (GPG_ERR_WRONG_SECKEY);
884       }
885   xfree (buffer);
886   return 0;
887 }
888
889
890
891 /* Compute a digital signature on INDATA which is expected to be the
892    raw message digest. For this application the KEYIDSTR consists of
893    the serialnumber and the fingerprint delimited by a slash.
894
895    Note that this fucntion may return the error code
896    GPG_ERR_WRONG_CARD to indicate that the card currently present does
897    not match the one required for the requested action (e.g. the
898    serial number does not match). */
899 static int 
900 do_sign (APP app, const char *keyidstr, int hashalgo,
901          int (*pincb)(void*, const char *, char **),
902          void *pincb_arg,
903          const void *indata, size_t indatalen,
904          unsigned char **outdata, size_t *outdatalen )
905 {
906   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
907   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
908     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
909   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
910   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
911     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
912   int rc;
913   unsigned char data[35];
914   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
915   const char *s;
916   int n;
917   const char *fpr = NULL;
918   unsigned long sigcount;
919
920   if (!keyidstr || !*keyidstr)
921     return gpg_error (GPG_ERR_INV_VALUE);
922   if (indatalen != 20)
923     return gpg_error (GPG_ERR_INV_VALUE);
924
925   /* Check whether an OpenPGP card of any version has been requested. */
926   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
927     return gpg_error (GPG_ERR_INV_ID);
928   
929   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
930     ;
931   if (n != 32)
932     return gpg_error (GPG_ERR_INV_ID);
933   else if (!*s)
934     ; /* no fingerprint given: we allow this for now. */
935   else if (*s == '/')
936     fpr = s + 1; 
937   else
938     return gpg_error (GPG_ERR_INV_ID);
939
940   for (s=keyidstr, n=0; n < 16; s += 2, n++)
941     tmp_sn[n] = xtoi_2 (s);
942
943   if (app->serialnolen != 16)
944     return gpg_error (GPG_ERR_INV_CARD);
945   if (memcmp (app->serialno, tmp_sn, 16))
946     return gpg_error (GPG_ERR_WRONG_CARD);
947
948   /* If a fingerprint has been specified check it against the one on
949      the card.  This is allows for a meaningful error message in case
950      the key on the card has been replaced but the shadow information
951      known to gpg was not updated.  If there is no fingerprint, gpg
952      will detect a bogus signature anyway due to the
953      verify-after-signing feature. */
954   if (fpr)
955     {
956       for (s=fpr, n=0; hexdigitp (s); s++, n++)
957         ;
958       if (n != 40)
959         return gpg_error (GPG_ERR_INV_ID);
960       else if (!*s)
961         ; /* okay */
962       else
963         return gpg_error (GPG_ERR_INV_ID);
964
965       for (s=fpr, n=0; n < 20; s += 2, n++)
966         tmp_sn[n] = xtoi_2 (s);
967       rc = compare_fingerprint (app, 1, tmp_sn);
968       if (rc)
969         return rc;
970     }
971
972   if (hashalgo == GCRY_MD_SHA1)
973     memcpy (data, sha1_prefix, 15);
974   else if (hashalgo == GCRY_MD_RMD160)
975     memcpy (data, rmd160_prefix, 15);
976   else 
977     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
978   memcpy (data+15, indata, indatalen);
979
980   sigcount = get_sig_counter (app);
981   log_info ("signatures created so far: %lu\n", sigcount);
982
983   if (!app->did_chv1 || app->force_chv1 ) 
984     {
985       char *pinvalue;
986
987       {
988         char *prompt;
989         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
990           return gpg_error_from_errno (errno);
991         rc = pincb (pincb_arg, prompt, &pinvalue); 
992         free (prompt);
993       }
994       if (rc)
995         {
996           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
997           return rc;
998         }
999
1000       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1001       if (rc)
1002         {
1003           log_error ("verify CHV1 failed\n");
1004           xfree (pinvalue);
1005           return rc;
1006         }
1007       app->did_chv1 = 1;
1008       if (!app->did_chv2)
1009         {
1010           /* We should also verify CHV2. */
1011           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1012           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1013             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1014           if (rc)
1015             {
1016               log_error ("verify CHV2 failed\n");
1017               xfree (pinvalue);
1018               return rc;
1019             }
1020           app->did_chv2 = 1;
1021         }
1022       xfree (pinvalue);
1023     }
1024
1025   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1026   return rc;
1027 }
1028
1029 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1030    on INDATA which is expected to be the raw message digest. For this
1031    application the KEYIDSTR consists of the serialnumber and the
1032    fingerprint delimited by a slash.
1033
1034    Note that this fucntion may return the error code
1035    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1036    not match the one required for the requested action (e.g. the
1037    serial number does not match). */
1038 static int 
1039 do_auth (APP app, const char *keyidstr,
1040          int (*pincb)(void*, const char *, char **),
1041          void *pincb_arg,
1042          const void *indata, size_t indatalen,
1043          unsigned char **outdata, size_t *outdatalen )
1044 {
1045   int rc;
1046   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1047   const char *s;
1048   int n;
1049   const char *fpr = NULL;
1050
1051   if (!keyidstr || !*keyidstr)
1052     return gpg_error (GPG_ERR_INV_VALUE);
1053   if (indatalen > 50) /* For a 1024 bit key. */
1054     return gpg_error (GPG_ERR_INV_VALUE);
1055
1056   /* Check whether an OpenPGP card of any version has been requested. */
1057   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1058     return gpg_error (GPG_ERR_INV_ID);
1059   
1060   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1061     ;
1062   if (n != 32)
1063     return gpg_error (GPG_ERR_INV_ID);
1064   else if (!*s)
1065     ; /* no fingerprint given: we allow this for now. */
1066   else if (*s == '/')
1067     fpr = s + 1; 
1068   else
1069     return gpg_error (GPG_ERR_INV_ID);
1070
1071   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1072     tmp_sn[n] = xtoi_2 (s);
1073
1074   if (app->serialnolen != 16)
1075     return gpg_error (GPG_ERR_INV_CARD);
1076   if (memcmp (app->serialno, tmp_sn, 16))
1077     return gpg_error (GPG_ERR_WRONG_CARD);
1078
1079   /* If a fingerprint has been specified check it against the one on
1080      the card.  This is allows for a meaningful error message in case
1081      the key on the card has been replaced but the shadow information
1082      known to gpg was not updated.  If there is no fingerprint, gpg
1083      will detect a bogus signature anyway due to the
1084      verify-after-signing feature. */
1085   if (fpr)
1086     {
1087       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1088         ;
1089       if (n != 40)
1090         return gpg_error (GPG_ERR_INV_ID);
1091       else if (!*s)
1092         ; /* okay */
1093       else
1094         return gpg_error (GPG_ERR_INV_ID);
1095
1096       for (s=fpr, n=0; n < 20; s += 2, n++)
1097         tmp_sn[n] = xtoi_2 (s);
1098       rc = compare_fingerprint (app, 3, tmp_sn);
1099       if (rc)
1100         return rc;
1101     }
1102
1103   rc = verify_chv2 (app, pincb, pincb_arg);
1104   if (!rc)
1105     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1106                                         outdata, outdatalen);
1107   return rc;
1108 }
1109
1110
1111 static int 
1112 do_decipher (APP app, const char *keyidstr,
1113              int (pincb)(void*, const char *, char **),
1114              void *pincb_arg,
1115              const void *indata, size_t indatalen,
1116              unsigned char **outdata, size_t *outdatalen )
1117 {
1118   int rc;
1119   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1120   const char *s;
1121   int n;
1122   const char *fpr = NULL;
1123
1124   if (!keyidstr || !*keyidstr || !indatalen)
1125     return gpg_error (GPG_ERR_INV_VALUE);
1126
1127   /* Check whether an OpenPGP card of any version has been requested. */
1128   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1129     return gpg_error (GPG_ERR_INV_ID);
1130   
1131   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1132     ;
1133   if (n != 32)
1134     return gpg_error (GPG_ERR_INV_ID);
1135   else if (!*s)
1136     ; /* no fingerprint given: we allow this for now. */
1137   else if (*s == '/')
1138     fpr = s + 1; 
1139   else
1140     return gpg_error (GPG_ERR_INV_ID);
1141
1142   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1143     tmp_sn[n] = xtoi_2 (s);
1144
1145   if (app->serialnolen != 16)
1146     return gpg_error (GPG_ERR_INV_CARD);
1147   if (memcmp (app->serialno, tmp_sn, 16))
1148     return gpg_error (GPG_ERR_WRONG_CARD);
1149
1150   /* If a fingerprint has been specified check it against the one on
1151      the card.  This is allows for a meaningful error message in case
1152      the key on the card has been replaced but the shadow information
1153      known to gpg was not updated.  If there is no fingerprint, the
1154      decryption will won't produce the right plaintext anyway. */
1155   if (fpr)
1156     {
1157       for (s=fpr, n=0; hexdigitp (s); s++, n++)
1158         ;
1159       if (n != 40)
1160         return gpg_error (GPG_ERR_INV_ID);
1161       else if (!*s)
1162         ; /* okay */
1163       else
1164         return gpg_error (GPG_ERR_INV_ID);
1165
1166       for (s=fpr, n=0; n < 20; s += 2, n++)
1167         tmp_sn[n] = xtoi_2 (s);
1168       rc = compare_fingerprint (app, 2, tmp_sn);
1169       if (rc)
1170         return rc;
1171     }
1172
1173   rc = verify_chv2 (app, pincb, pincb_arg);
1174   if (!rc)
1175     rc = iso7816_decipher (app->slot, indata, indatalen, outdata, outdatalen);
1176   return rc;
1177 }
1178
1179
1180
1181
1182 /* Select the OpenPGP application on the card in SLOT.  This function
1183    must be used before any other OpenPGP application functions. */
1184 int
1185 app_select_openpgp (APP app, unsigned char **sn, size_t *snlen)
1186 {
1187   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1188   int slot = app->slot;
1189   int rc;
1190   unsigned char *buffer;
1191   size_t buflen;
1192   void *relptr;
1193   
1194   rc = iso7816_select_application (slot, aid, sizeof aid);
1195   if (!rc)
1196     {
1197       app->did_chv1 = 0;
1198       app->did_chv2 = 0;
1199       app->did_chv3 = 0;
1200
1201       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1202       if (rc)
1203         goto leave;
1204       if (opt.verbose)
1205         {
1206           log_info ("got AID: ");
1207           log_printhex ("", buffer, buflen);
1208         }
1209
1210       if (sn)
1211         {
1212           *sn = buffer;
1213           *snlen = buflen;
1214           app->card_version = buffer[6] << 8;
1215           app->card_version |= buffer[7];
1216         }
1217       else
1218         xfree (buffer);
1219
1220       relptr = get_one_do (app->slot, 0x00C4, &buffer, &buflen);
1221       if (!relptr)
1222         {
1223           log_error ("can't access CHV Status Bytes - invalid OpenPGP card?\n");
1224           goto leave;
1225         }
1226       app->force_chv1 = (buflen && *buffer == 0);
1227       xfree (relptr);
1228         
1229       if (opt.verbose > 1)
1230         dump_all_do (slot);
1231
1232       app->fnc.learn_status = do_learn_status;
1233       app->fnc.getattr = do_getattr;
1234       app->fnc.setattr = do_setattr;
1235       app->fnc.genkey = do_genkey;
1236       app->fnc.sign = do_sign;
1237       app->fnc.auth = do_auth;
1238       app->fnc.decipher = do_decipher;
1239       app->fnc.change_pin = do_change_pin;
1240    }
1241
1242 leave:
1243   return rc;
1244 }
1245
1246
1247
1248 /* This function is a hack to retrieve essential information about the
1249    card to be displayed by simple tools.  It mostly resembles what the
1250    LEARN command returns. All parameters return allocated strings or
1251    buffers or NULL if the data object is not available.  All returned
1252    values are sanitized. */
1253 int
1254 app_openpgp_cardinfo (APP app,
1255                       char **serialno,
1256                       char **disp_name,
1257                       char **pubkey_url,
1258                       unsigned char **fpr1,
1259                       unsigned char **fpr2,
1260                       unsigned char **fpr3)
1261 {
1262   int rc;
1263   void *relptr;
1264   unsigned char *value;
1265   size_t valuelen;
1266
1267   if (serialno)
1268     {
1269       time_t dummy;
1270
1271       *serialno = NULL;
1272       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1273       if (rc)
1274         {
1275           log_error ("error getting serial number: %s\n", gpg_strerror (rc));
1276           return rc;
1277         }
1278     }
1279       
1280   if (disp_name)
1281     {
1282       *disp_name = NULL;
1283       relptr = get_one_do (app->slot, 0x005B, &value, &valuelen);
1284       if (relptr)
1285         {
1286           *disp_name = make_printable_string (value, valuelen, 0);
1287           xfree (relptr);
1288         }
1289     }
1290
1291   if (pubkey_url)
1292     {
1293       *pubkey_url = NULL;
1294       relptr = get_one_do (app->slot, 0x5F50, &value, &valuelen);
1295       if (relptr)
1296         {
1297           *pubkey_url = make_printable_string (value, valuelen, 0);
1298           xfree (relptr);
1299         }
1300     }
1301
1302   if (fpr1)
1303     *fpr1 = NULL;
1304   if (fpr2)
1305     *fpr2 = NULL;
1306   if (fpr3)
1307     *fpr3 = NULL;
1308   relptr = get_one_do (app->slot, 0x00C5, &value, &valuelen);
1309   if (relptr && valuelen >= 60)
1310     {
1311       if (fpr1)
1312         {
1313           *fpr1 = xmalloc (20);
1314           memcpy (*fpr1, value +  0, 20);
1315         }
1316       if (fpr2)
1317         {
1318           *fpr2 = xmalloc (20);
1319           memcpy (*fpr2, value + 20, 20);
1320         }
1321       if (fpr3)
1322         {
1323           *fpr3 = xmalloc (20);
1324           memcpy (*fpr3, value + 40, 20);
1325         }
1326     }
1327   xfree (relptr);
1328
1329   return 0;
1330 }
1331
1332
1333
1334 /* This function is currently only used by the sc-copykeys program to
1335    store a key on the smartcard.  APP ist the application handle,
1336    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1337    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1338    the key template to store. CREATED_AT is the timestamp used to
1339    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1340    RSA public exponent. This function silently overwrites an existing
1341    key.*/
1342 int 
1343 app_openpgp_storekey (APP app, int keyno,
1344                       unsigned char *template, size_t template_len,
1345                       time_t created_at,
1346                       const unsigned char *m, size_t mlen,
1347                       const unsigned char *e, size_t elen,
1348                       int (*pincb)(void*, const char *, char **),
1349                       void *pincb_arg)
1350 {
1351   int rc;
1352   unsigned char fprbuf[20];
1353
1354   if (keyno < 1 || keyno > 3)
1355     return gpg_error (GPG_ERR_INV_ID);
1356   keyno--;
1357
1358   rc = verify_chv3 (app, pincb, pincb_arg);
1359   if (rc)
1360     goto leave;
1361
1362
1363   rc = iso7816_put_data (app->slot,
1364                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1365                          template, template_len);
1366   if (rc)
1367     {
1368       log_error ("failed to store the key: rc=%s\n", gpg_strerror (rc));
1369       rc = gpg_error (GPG_ERR_CARD);
1370       goto leave;
1371     }
1372  
1373 /*    log_printhex ("RSA n:", m, mlen);  */
1374 /*    log_printhex ("RSA e:", e, elen);  */
1375
1376   rc = store_fpr (app->slot, keyno, (u32)created_at,
1377                   m, mlen, e, elen, fprbuf, app->card_version);
1378
1379  leave:
1380   return rc;
1381 }
1382
1383
1384 /* Utility function for external tools: Read the public RSA key at
1385    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1386 int 
1387 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1388                      unsigned char **e, size_t *elen)
1389 {
1390   int rc;
1391   const unsigned char *keydata, *a;
1392   unsigned char *buffer;
1393   size_t buflen, keydatalen, alen;
1394
1395   *m = NULL;
1396   *e = NULL;
1397
1398   if (keyno < 1 || keyno > 3)
1399     return gpg_error (GPG_ERR_INV_ID);
1400   keyno--;
1401
1402   rc = iso7816_read_public_key(app->slot, 
1403                                keyno == 0? "\xB6" :
1404                                keyno == 1? "\xB8" : "\xA4",
1405                                2,
1406                                &buffer, &buflen);
1407   if (rc)
1408     {
1409       rc = gpg_error (GPG_ERR_CARD);
1410       log_error ("reading key failed\n");
1411       goto leave;
1412     }
1413
1414   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen, 0);
1415   if (!keydata)
1416     {
1417       log_error ("response does not contain the public key data\n");
1418       rc = gpg_error (GPG_ERR_CARD);
1419       goto leave;
1420     }
1421  
1422   a = find_tlv (keydata, keydatalen, 0x0081, &alen, 0);
1423   if (!a)
1424     {
1425       log_error ("response does not contain the RSA modulus\n");
1426       rc = gpg_error (GPG_ERR_CARD);
1427       goto leave;
1428     }
1429   *mlen = alen;
1430   *m = xmalloc (alen);
1431   memcpy (*m, a, alen);
1432   
1433   a = find_tlv (keydata, keydatalen, 0x0082, &alen, 0);
1434   if (!e)
1435     {
1436       log_error ("response does not contain the RSA public exponent\n");
1437       rc = gpg_error (GPG_ERR_CARD);
1438       goto leave;
1439     }
1440   *elen = alen;
1441   *e = xmalloc (alen);
1442   memcpy (*e, a, alen);
1443
1444  leave:
1445   xfree (buffer);
1446   if (rc)
1447     { 
1448       xfree (*m); *m = NULL;
1449       xfree (*e); *e = NULL;
1450     }
1451   return rc;
1452 }