gpg: Properly account for ring trust packets.
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  * Copyright (C) 2003-2005, 2009 Free Software Foundation, Inc.
3  * Copyright (C) 2003-2005, 2009 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #ifdef HAVE_LIBREADLINE
27 # define GNUPG_LIBREADLINE_H_INCLUDED
28 # include <readline/readline.h>
29 #endif /*HAVE_LIBREADLINE*/
30
31 #if GNUPG_MAJOR_VERSION != 1
32 # include "gpg.h"
33 #endif /*GNUPG_MAJOR_VERSION != 1*/
34 #include "../common/util.h"
35 #include "../common/i18n.h"
36 #include "../common/ttyio.h"
37 #include "../common/status.h"
38 #include "options.h"
39 #include "main.h"
40 #include "keyserver-internal.h"
41
42 #if GNUPG_MAJOR_VERSION == 1
43 # include "cardglue.h"
44 #else /*GNUPG_MAJOR_VERSION!=1*/
45 # include "call-agent.h"
46 #endif /*GNUPG_MAJOR_VERSION!=1*/
47
48 #define CONTROL_D ('D' - 'A' + 1)
49
50
51 static void
52 write_sc_op_status (gpg_error_t err)
53 {
54   switch (gpg_err_code (err))
55     {
56     case 0:
57       write_status (STATUS_SC_OP_SUCCESS);
58       break;
59 #if GNUPG_MAJOR_VERSION != 1
60     case GPG_ERR_CANCELED:
61     case GPG_ERR_FULLY_CANCELED:
62       write_status_text (STATUS_SC_OP_FAILURE, "1");
63       break;
64     case GPG_ERR_BAD_PIN:
65       write_status_text (STATUS_SC_OP_FAILURE, "2");
66       break;
67     default:
68       write_status (STATUS_SC_OP_FAILURE);
69       break;
70 #endif /* GNUPG_MAJOR_VERSION != 1 */
71     }
72 }
73
74
75 /* Change the PIN of an OpenPGP card.  This is an interactive
76    function. */
77 void
78 change_pin (int unblock_v2, int allow_admin)
79 {
80   struct agent_card_info_s info;
81   int rc;
82
83   rc = agent_scd_learn (&info, 0);
84   if (rc)
85     {
86       log_error (_("OpenPGP card not available: %s\n"),
87                   gpg_strerror (rc));
88       return;
89     }
90
91   log_info (_("OpenPGP card no. %s detected\n"),
92               info.serialno? info.serialno : "[none]");
93
94   agent_clear_pin_cache (info.serialno);
95
96   if (opt.batch)
97     {
98       agent_release_card_info (&info);
99       log_error (_("can't do this in batch mode\n"));
100       return;
101     }
102
103
104   if (unblock_v2)
105     {
106       if (!info.is_v2)
107         log_error (_("This command is only available for version 2 cards\n"));
108       else if (!info.chvretry[1])
109         log_error (_("Reset Code not or not anymore available\n"));
110       else
111         {
112           rc = agent_scd_change_pin (2, info.serialno);
113           write_sc_op_status (rc);
114           if (rc)
115             tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
116           else
117             tty_printf ("PIN changed.\n");
118         }
119     }
120   else if (!allow_admin)
121     {
122       rc = agent_scd_change_pin (1, info.serialno);
123       write_sc_op_status (rc);
124       if (rc)
125         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
126       else
127         tty_printf ("PIN changed.\n");
128     }
129   else
130     for (;;)
131       {
132         char *answer;
133
134         tty_printf ("\n");
135         tty_printf ("1 - change PIN\n"
136                     "2 - unblock PIN\n"
137                     "3 - change Admin PIN\n"
138                     "4 - set the Reset Code\n"
139                     "Q - quit\n");
140         tty_printf ("\n");
141
142         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
143         cpr_kill_prompt();
144         if (strlen (answer) != 1)
145           continue;
146
147         if (*answer == '1')
148           {
149             /* Change PIN.  */
150             rc = agent_scd_change_pin (1, info.serialno);
151             write_sc_op_status (rc);
152             if (rc)
153               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
154             else
155               tty_printf ("PIN changed.\n");
156           }
157         else if (*answer == '2')
158           {
159             /* Unblock PIN.  */
160             rc = agent_scd_change_pin (101, info.serialno);
161             write_sc_op_status (rc);
162             if (rc)
163               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
164             else
165               tty_printf ("PIN unblocked and new PIN set.\n");
166           }
167         else if (*answer == '3')
168           {
169             /* Change Admin PIN.  */
170             rc = agent_scd_change_pin (3, info.serialno);
171             write_sc_op_status (rc);
172             if (rc)
173               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
174             else
175               tty_printf ("PIN changed.\n");
176           }
177         else if (*answer == '4')
178           {
179             /* Set a new Reset Code.  */
180             rc = agent_scd_change_pin (102, info.serialno);
181             write_sc_op_status (rc);
182             if (rc)
183               tty_printf ("Error setting the Reset Code: %s\n",
184                           gpg_strerror (rc));
185             else
186               tty_printf ("Reset Code set.\n");
187           }
188         else if (*answer == 'q' || *answer == 'Q')
189           {
190             break;
191           }
192       }
193
194   agent_release_card_info (&info);
195 }
196
197 static const char *
198 get_manufacturer (unsigned int no)
199 {
200   /* Note:  Make sure that there is no colon or linefeed in the string. */
201   switch (no)
202     {
203     case 0x0001: return "PPC Card Systems";
204     case 0x0002: return "Prism";
205     case 0x0003: return "OpenFortress";
206     case 0x0004: return "Wewid";
207     case 0x0005: return "ZeitControl";
208     case 0x0006: return "Yubico";
209     case 0x0007: return "OpenKMS";
210     case 0x0008: return "LogoEmail";
211     case 0x0009: return "Fidesmo";
212     case 0x000A: return "Dangerous Things";
213
214     case 0x002A: return "Magrathea";
215
216     case 0x1337: return "Warsaw Hackerspace";
217     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
218     case 0xF517: return "FSIJ";
219
220       /* 0x0000 and 0xFFFF are defined as test cards per spec,
221          0xFF00 to 0xFFFE are assigned for use with randomly created
222          serial numbers.  */
223     case 0x0000:
224     case 0xffff: return "test card";
225     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
226     }
227 }
228
229
230 static void
231 print_sha1_fpr (estream_t fp, const unsigned char *fpr)
232 {
233   int i;
234
235   if (fpr)
236     {
237       for (i=0; i < 20 ; i+=2, fpr += 2 )
238         {
239           if (i == 10 )
240             tty_fprintf (fp, " ");
241           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
242         }
243     }
244   else
245     tty_fprintf (fp, " [none]");
246   tty_fprintf (fp, "\n");
247 }
248
249
250 static void
251 print_sha1_fpr_colon (estream_t fp, const unsigned char *fpr)
252 {
253   int i;
254
255   if (fpr)
256     {
257       for (i=0; i < 20 ; i++, fpr++)
258         es_fprintf (fp, "%02X", *fpr);
259     }
260   es_putc (':', fp);
261 }
262
263
264 static void
265 print_name (estream_t fp, const char *text, const char *name)
266 {
267   tty_fprintf (fp, "%s", text);
268
269   /* FIXME: tty_printf_utf8_string2 eats everything after and
270      including an @ - e.g. when printing an url. */
271   if (name && *name)
272     {
273       if (fp)
274         print_utf8_buffer2 (fp, name, strlen (name), '\n');
275       else
276         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
277     }
278   else
279     tty_fprintf (fp, _("[not set]"));
280   tty_fprintf (fp, "\n");
281 }
282
283 static void
284 print_isoname (estream_t fp, const char *text,
285                const char *tag, const char *name)
286 {
287   if (opt.with_colons)
288     es_fprintf (fp, "%s:", tag);
289   else
290     tty_fprintf (fp, "%s", text);
291
292   if (name && *name)
293     {
294       char *p, *given, *buf = xstrdup (name);
295
296       given = strstr (buf, "<<");
297       for (p=buf; *p; p++)
298         if (*p == '<')
299           *p = ' ';
300       if (given && given[2])
301         {
302           *given = 0;
303           given += 2;
304           if (opt.with_colons)
305             es_write_sanitized (fp, given, strlen (given), ":", NULL);
306           else if (fp)
307             print_utf8_buffer2 (fp, given, strlen (given), '\n');
308           else
309             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
310
311           if (opt.with_colons)
312             es_putc (':', fp);
313           else if (*buf)
314             tty_fprintf (fp, " ");
315         }
316
317       if (opt.with_colons)
318         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
319       else if (fp)
320         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
321       else
322         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
323       xfree (buf);
324     }
325   else
326     {
327       if (opt.with_colons)
328         es_putc (':', fp);
329       else
330         tty_fprintf (fp, _("[not set]"));
331     }
332
333   if (opt.with_colons)
334     es_fputs (":\n", fp);
335   else
336     tty_fprintf (fp, "\n");
337 }
338
339 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
340 static int
341 fpr_is_zero (const char *fpr)
342 {
343   int i;
344
345   for (i=0; i < 20 && !fpr[i]; i++)
346     ;
347   return (i == 20);
348 }
349
350
351 /* Return true if the SHA1 fingerprint FPR consists only of 0xFF. */
352 static int
353 fpr_is_ff (const char *fpr)
354 {
355   int i;
356
357   for (i=0; i < 20 && fpr[i] == '\xff'; i++)
358     ;
359   return (i == 20);
360 }
361
362
363 /* Print all available information about the current card. */
364 static void
365 current_card_status (ctrl_t ctrl, estream_t fp,
366                      char *serialno, size_t serialnobuflen)
367 {
368   struct agent_card_info_s info;
369   PKT_public_key *pk = xcalloc (1, sizeof *pk);
370   kbnode_t keyblock = NULL;
371   int rc;
372   unsigned int uval;
373   const unsigned char *thefpr;
374   int i;
375
376   if (serialno && serialnobuflen)
377     *serialno = 0;
378
379   rc = agent_scd_learn (&info, 0);
380   if (rc)
381     {
382       if (opt.with_colons)
383         es_fputs ("AID:::\n", fp);
384       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
385       xfree (pk);
386       return;
387     }
388
389   if (opt.with_colons)
390     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
391   else
392     tty_fprintf (fp, "Reader ...........: %s\n",
393                  info.reader? info.reader : "[none]");
394   if (opt.with_colons)
395     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
396   else
397     tty_fprintf (fp, "Application ID ...: %s\n",
398                  info.serialno? info.serialno : "[none]");
399   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
400       || strlen (info.serialno) != 32 )
401     {
402       if (info.apptype && !strcmp (info.apptype, "NKS"))
403         {
404           if (opt.with_colons)
405             es_fputs ("netkey-card:\n", fp);
406           log_info ("this is a NetKey card\n");
407         }
408       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
409         {
410           if (opt.with_colons)
411             es_fputs ("dinsig-card:\n", fp);
412           log_info ("this is a DINSIG compliant card\n");
413         }
414       else if (info.apptype && !strcmp (info.apptype, "P15"))
415         {
416           if (opt.with_colons)
417             es_fputs ("pkcs15-card:\n", fp);
418           log_info ("this is a PKCS#15 compliant card\n");
419         }
420       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
421         {
422           if (opt.with_colons)
423             es_fputs ("geldkarte-card:\n", fp);
424           log_info ("this is a Geldkarte compliant card\n");
425         }
426       else
427         {
428           if (opt.with_colons)
429             es_fputs ("unknown:\n", fp);
430         }
431       log_info ("not an OpenPGP card\n");
432       agent_release_card_info (&info);
433       xfree (pk);
434       return;
435     }
436
437   if (!serialno)
438     ;
439   else if (strlen (info.serialno)+1 > serialnobuflen)
440     log_error ("serial number longer than expected\n");
441   else
442     strcpy (serialno, info.serialno);
443
444   if (opt.with_colons)
445     es_fputs ("openpgp-card:\n", fp);
446
447
448   if (opt.with_colons)
449     {
450       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
451       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
452       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
453       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
454
455       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
456
457       es_fputs ("lang:", fp);
458       if (info.disp_lang)
459         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
460                             ":", NULL);
461       es_fputs (":\n", fp);
462
463       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
464                                  info.disp_sex == 2? 'f' : 'u'));
465
466       es_fputs ("url:", fp);
467       if (info.pubkey_url)
468         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
469                             ":", NULL);
470       es_fputs (":\n", fp);
471
472       es_fputs ("login:", fp);
473       if (info.login_data)
474         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
475                             ":", NULL);
476       es_fputs (":\n", fp);
477
478       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
479       for (i=0; i < DIM (info.key_attr); i++)
480         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
481           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
482                       info.key_attr[i].algo, info.key_attr[i].nbits);
483         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
484                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
485                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
486           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
487                       info.key_attr[i].algo, info.key_attr[i].curve);
488       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
489                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
490       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
491                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
492       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
493
494       for (i=0; i < 4; i++)
495         {
496           if (info.private_do[i])
497             {
498               es_fprintf (fp, "private_do:%d:", i+1);
499               es_write_sanitized (fp, info.private_do[i],
500                                   strlen (info.private_do[i]), ":", NULL);
501               es_fputs (":\n", fp);
502             }
503         }
504
505       es_fputs ("cafpr:", fp);
506       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
507       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
508       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
509       es_putc ('\n', fp);
510       es_fputs ("fpr:", fp);
511       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
512       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
513       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
514       es_putc ('\n', fp);
515       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
516                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
517                (unsigned long)info.fpr3time);
518     }
519   else
520     {
521       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
522                    info.serialno[12] == '0'?"":info.serialno+12,
523                    info.serialno[13],
524                    info.serialno[14] == '0'?"":info.serialno+14,
525                    info.serialno[15]);
526       tty_fprintf (fp, "Manufacturer .....: %s\n",
527                    get_manufacturer (xtoi_2(info.serialno+16)*256
528                                      + xtoi_2 (info.serialno+18)));
529       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
530
531       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
532       print_name (fp, "Language prefs ...: ", info.disp_lang);
533       tty_fprintf (fp,    "Sex ..............: %s\n",
534                    info.disp_sex == 1? _("male"):
535                    info.disp_sex == 2? _("female") : _("unspecified"));
536       print_name (fp, "URL of public key : ", info.pubkey_url);
537       print_name (fp, "Login data .......: ", info.login_data);
538       if (info.private_do[0])
539         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
540       if (info.private_do[1])
541         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
542       if (info.private_do[2])
543         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
544       if (info.private_do[3])
545         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
546       if (info.cafpr1valid)
547         {
548           tty_fprintf (fp, "CA fingerprint %d .:", 1);
549           print_sha1_fpr (fp, info.cafpr1);
550         }
551       if (info.cafpr2valid)
552         {
553           tty_fprintf (fp, "CA fingerprint %d .:", 2);
554           print_sha1_fpr (fp, info.cafpr2);
555         }
556       if (info.cafpr3valid)
557         {
558           tty_fprintf (fp, "CA fingerprint %d .:", 3);
559           print_sha1_fpr (fp, info.cafpr3);
560         }
561       tty_fprintf (fp,    "Signature PIN ....: %s\n",
562                    info.chv1_cached? _("not forced"): _("forced"));
563       if (info.key_attr[0].algo)
564         {
565           tty_fprintf (fp,    "Key attributes ...:");
566           for (i=0; i < DIM (info.key_attr); i++)
567             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
568               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
569             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
570                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
571                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
572               {
573                 const char *curve_for_print = "?";
574
575                 if (info.key_attr[i].curve)
576                   {
577                     const char *oid;
578                     oid = openpgp_curve_to_oid (info.key_attr[i].curve, NULL);
579                     if (oid)
580                       curve_for_print = openpgp_oid_to_curve (oid, 0);
581                   }
582                 tty_fprintf (fp, " %s", curve_for_print);
583               }
584           tty_fprintf (fp, "\n");
585         }
586       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
587                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
588       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
589                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
590       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
591       tty_fprintf (fp, "Signature key ....:");
592       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
593       if (info.fpr1valid && info.fpr1time)
594         tty_fprintf (fp, "      created ....: %s\n",
595                      isotimestamp (info.fpr1time));
596       tty_fprintf (fp, "Encryption key....:");
597       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
598       if (info.fpr2valid && info.fpr2time)
599         tty_fprintf (fp, "      created ....: %s\n",
600                      isotimestamp (info.fpr2time));
601       tty_fprintf (fp, "Authentication key:");
602       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
603       if (info.fpr3valid && info.fpr3time)
604         tty_fprintf (fp, "      created ....: %s\n",
605                      isotimestamp (info.fpr3time));
606       tty_fprintf (fp, "General key info..: ");
607
608       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 :
609                 info.fpr3valid? info.fpr3 : NULL);
610       /* If the fingerprint is all 0xff, the key has no asssociated
611          OpenPGP certificate.  */
612       if ( thefpr && !fpr_is_ff (thefpr)
613            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, 20))
614         {
615           print_pubkey_info (ctrl, fp, pk);
616           if (keyblock)
617             print_card_key_info (fp, keyblock);
618         }
619       else
620         tty_fprintf (fp, "[none]\n");
621     }
622
623   release_kbnode (keyblock);
624   free_public_key (pk);
625   agent_release_card_info (&info);
626 }
627
628
629 /* Print all available information for specific card with SERIALNO.
630    Print all available information for current card when SERIALNO is NULL.
631    Or print llfor all cards when SERIALNO is "all".  */
632 void
633 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
634 {
635   int err;
636   strlist_t card_list, sl;
637   char *serialno0;
638   int all_cards = 0;
639
640   if (serialno == NULL)
641     {
642       current_card_status (ctrl, fp, NULL, 0);
643       return;
644     }
645
646   if (!strcmp (serialno, "all"))
647     all_cards = 1;
648
649   err = agent_scd_serialno (&serialno0, NULL);
650   if (err)
651     {
652       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
653         log_info (_("error getting serial number of card: %s\n"),
654                   gpg_strerror (err));
655       /* Nothing available.  */
656       return;
657     }
658
659   err = agent_scd_cardlist (&card_list);
660
661   for (sl = card_list; sl; sl = sl->next)
662     {
663       char *serialno1;
664
665       if (!all_cards && strcmp (serialno, sl->d))
666         continue;
667
668       err = agent_scd_serialno (&serialno1, sl->d);
669       if (err)
670         {
671           if (opt.verbose)
672             log_info (_("error getting serial number of card: %s\n"),
673                       gpg_strerror (err));
674           continue;
675         }
676
677       current_card_status (ctrl, fp, NULL, 0);
678       xfree (serialno1);
679
680       if (!all_cards)
681         goto leave;
682     }
683
684   /* Select the original card again.  */
685   err = agent_scd_serialno (&serialno0, serialno0);
686
687  leave:
688   xfree (serialno0);
689   free_strlist (card_list);
690 }
691
692
693 static char *
694 get_one_name (const char *prompt1, const char *prompt2)
695 {
696   char *name;
697   int i;
698
699   for (;;)
700     {
701       name = cpr_get (prompt1, prompt2);
702       if (!name)
703         return NULL;
704       trim_spaces (name);
705       cpr_kill_prompt ();
706       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
707         ;
708
709       /* The name must be in Latin-1 and not UTF-8 - lacking the code
710          to ensure this we restrict it to ASCII. */
711       if (name[i])
712         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
713       else if (strchr (name, '<'))
714         tty_printf (_("Error: The \"<\" character may not be used.\n"));
715       else if (strstr (name, "  "))
716         tty_printf (_("Error: Double spaces are not allowed.\n"));
717       else
718         return name;
719       xfree (name);
720     }
721 }
722
723
724
725 static int
726 change_name (void)
727 {
728   char *surname = NULL, *givenname = NULL;
729   char *isoname, *p;
730   int rc;
731
732   surname = get_one_name ("keygen.smartcard.surname",
733                                     _("Cardholder's surname: "));
734   givenname = get_one_name ("keygen.smartcard.givenname",
735                                        _("Cardholder's given name: "));
736   if (!surname || !givenname || (!*surname && !*givenname))
737     {
738       xfree (surname);
739       xfree (givenname);
740       return -1; /*canceled*/
741     }
742
743   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
744   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
745   xfree (surname);
746   xfree (givenname);
747   for (p=isoname; *p; p++)
748     if (*p == ' ')
749       *p = '<';
750
751   if (strlen (isoname) > 39 )
752     {
753       tty_printf (_("Error: Combined name too long "
754                     "(limit is %d characters).\n"), 39);
755       xfree (isoname);
756       return -1;
757     }
758
759   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname), NULL );
760   if (rc)
761     log_error ("error setting Name: %s\n", gpg_strerror (rc));
762
763   xfree (isoname);
764   return rc;
765 }
766
767
768 static int
769 change_url (void)
770 {
771   char *url;
772   int rc;
773
774   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
775   if (!url)
776     return -1;
777   trim_spaces (url);
778   cpr_kill_prompt ();
779
780   if (strlen (url) > 254 )
781     {
782       tty_printf (_("Error: URL too long "
783                     "(limit is %d characters).\n"), 254);
784       xfree (url);
785       return -1;
786     }
787
788   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url), NULL );
789   if (rc)
790     log_error ("error setting URL: %s\n", gpg_strerror (rc));
791   xfree (url);
792   write_sc_op_status (rc);
793   return rc;
794 }
795
796
797 /* Fetch the key from the URL given on the card or try to get it from
798    the default keyserver.  */
799 static int
800 fetch_url (ctrl_t ctrl)
801 {
802   int rc;
803   struct agent_card_info_s info;
804
805   memset(&info,0,sizeof(info));
806
807   rc=agent_scd_getattr("PUBKEY-URL",&info);
808   if(rc)
809     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
810   else
811     {
812       rc=agent_scd_getattr("KEY-FPR",&info);
813       if(rc)
814         log_error("error retrieving key fingerprint from card: %s\n",
815                   gpg_strerror(rc));
816       else if (info.pubkey_url && *info.pubkey_url)
817         {
818           strlist_t sl = NULL;
819
820           add_to_strlist (&sl, info.pubkey_url);
821           rc = keyserver_fetch (ctrl, sl);
822           free_strlist (sl);
823         }
824       else if (info.fpr1valid)
825         {
826           rc = keyserver_import_fprint (ctrl, info.fpr1, 20, opt.keyserver, 0);
827         }
828     }
829
830   return rc;
831 }
832
833
834 /* Read data from file FNAME up to MAXLEN characters.  On error return
835    -1 and store NULL at R_BUFFER; on success return the number of
836    bytes read and store the address of a newly allocated buffer at
837    R_BUFFER. */
838 static int
839 get_data_from_file (const char *fname, size_t maxlen, char **r_buffer)
840 {
841   estream_t fp;
842   char *data;
843   int n;
844
845   *r_buffer = NULL;
846
847   fp = es_fopen (fname, "rb");
848 #if GNUPG_MAJOR_VERSION == 1
849   if (fp && is_secured_file (fileno (fp)))
850     {
851       fclose (fp);
852       fp = NULL;
853       errno = EPERM;
854     }
855 #endif
856   if (!fp)
857     {
858       tty_printf (_("can't open '%s': %s\n"), fname, strerror (errno));
859       return -1;
860     }
861
862   data = xtrymalloc (maxlen? maxlen:1);
863   if (!data)
864     {
865       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
866       es_fclose (fp);
867       return -1;
868     }
869
870   if (maxlen)
871     n = es_fread (data, 1, maxlen, fp);
872   else
873     n = 0;
874   es_fclose (fp);
875   if (n < 0)
876     {
877       tty_printf (_("error reading '%s': %s\n"), fname, strerror (errno));
878       xfree (data);
879       return -1;
880     }
881   *r_buffer = data;
882   return n;
883 }
884
885
886 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
887    success.  */
888 static int
889 put_data_to_file (const char *fname, const void *buffer, size_t length)
890 {
891   estream_t fp;
892
893   fp = es_fopen (fname, "wb");
894 #if GNUPG_MAJOR_VERSION == 1
895   if (fp && is_secured_file (fileno (fp)))
896     {
897       fclose (fp);
898       fp = NULL;
899       errno = EPERM;
900     }
901 #endif
902   if (!fp)
903     {
904       tty_printf (_("can't create '%s': %s\n"), fname, strerror (errno));
905       return -1;
906     }
907
908   if (length && es_fwrite (buffer, length, 1, fp) != 1)
909     {
910       tty_printf (_("error writing '%s': %s\n"), fname, strerror (errno));
911       es_fclose (fp);
912       return -1;
913     }
914   es_fclose (fp);
915   return 0;
916 }
917
918
919 static int
920 change_login (const char *args)
921 {
922   char *data;
923   int n;
924   int rc;
925
926   if (args && *args == '<')  /* Read it from a file */
927     {
928       for (args++; spacep (args); args++)
929         ;
930       n = get_data_from_file (args, 254, &data);
931       if (n < 0)
932         return -1;
933     }
934   else
935     {
936       data = cpr_get ("cardedit.change_login",
937                       _("Login data (account name): "));
938       if (!data)
939         return -1;
940       trim_spaces (data);
941       cpr_kill_prompt ();
942       n = strlen (data);
943     }
944
945   if (n > 254 )
946     {
947       tty_printf (_("Error: Login data too long "
948                     "(limit is %d characters).\n"), 254);
949       xfree (data);
950       return -1;
951     }
952
953   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
954   if (rc)
955     log_error ("error setting login data: %s\n", gpg_strerror (rc));
956   xfree (data);
957   write_sc_op_status (rc);
958   return rc;
959 }
960
961 static int
962 change_private_do (const char *args, int nr)
963 {
964   char do_name[] = "PRIVATE-DO-X";
965   char *data;
966   int n;
967   int rc;
968
969   log_assert (nr >= 1 && nr <= 4);
970   do_name[11] = '0' + nr;
971
972   if (args && (args = strchr (args, '<')))  /* Read it from a file */
973     {
974       for (args++; spacep (args); args++)
975         ;
976       n = get_data_from_file (args, 254, &data);
977       if (n < 0)
978         return -1;
979     }
980   else
981     {
982       data = cpr_get ("cardedit.change_private_do",
983                       _("Private DO data: "));
984       if (!data)
985         return -1;
986       trim_spaces (data);
987       cpr_kill_prompt ();
988       n = strlen (data);
989     }
990
991   if (n > 254 )
992     {
993       tty_printf (_("Error: Private DO too long "
994                     "(limit is %d characters).\n"), 254);
995       xfree (data);
996       return -1;
997     }
998
999   rc = agent_scd_setattr (do_name, data, n, NULL );
1000   if (rc)
1001     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
1002   xfree (data);
1003   write_sc_op_status (rc);
1004   return rc;
1005 }
1006
1007
1008 static int
1009 change_cert (const char *args)
1010 {
1011   char *data;
1012   int n;
1013   int rc;
1014
1015   if (args && *args == '<')  /* Read it from a file */
1016     {
1017       for (args++; spacep (args); args++)
1018         ;
1019       n = get_data_from_file (args, 16384, &data);
1020       if (n < 0)
1021         return -1;
1022     }
1023   else
1024     {
1025       tty_printf ("usage error: redirection to file required\n");
1026       return -1;
1027     }
1028
1029   rc = agent_scd_writecert ("OPENPGP.3", data, n);
1030   if (rc)
1031     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
1032   xfree (data);
1033   write_sc_op_status (rc);
1034   return rc;
1035 }
1036
1037
1038 static int
1039 read_cert (const char *args)
1040 {
1041   const char *fname;
1042   void *buffer;
1043   size_t length;
1044   int rc;
1045
1046   if (args && *args == '>')  /* Write it to a file */
1047     {
1048       for (args++; spacep (args); args++)
1049         ;
1050       fname = args;
1051     }
1052   else
1053     {
1054       tty_printf ("usage error: redirection to file required\n");
1055       return -1;
1056     }
1057
1058   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
1059   if (rc)
1060     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
1061   else
1062     rc = put_data_to_file (fname, buffer, length);
1063   xfree (buffer);
1064   write_sc_op_status (rc);
1065   return rc;
1066 }
1067
1068
1069 static int
1070 change_lang (void)
1071 {
1072   char *data, *p;
1073   int rc;
1074
1075   data = cpr_get ("cardedit.change_lang",
1076                   _("Language preferences: "));
1077   if (!data)
1078     return -1;
1079   trim_spaces (data);
1080   cpr_kill_prompt ();
1081
1082   if (strlen (data) > 8 || (strlen (data) & 1))
1083     {
1084       tty_printf (_("Error: invalid length of preference string.\n"));
1085       xfree (data);
1086       return -1;
1087     }
1088
1089   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1090     ;
1091   if (*p)
1092     {
1093       tty_printf (_("Error: invalid characters in preference string.\n"));
1094       xfree (data);
1095       return -1;
1096     }
1097
1098   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1099   if (rc)
1100     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1101   xfree (data);
1102   write_sc_op_status (rc);
1103   return rc;
1104 }
1105
1106
1107 static int
1108 change_sex (void)
1109 {
1110   char *data;
1111   const char *str;
1112   int rc;
1113
1114   data = cpr_get ("cardedit.change_sex",
1115                   _("Sex ((M)ale, (F)emale or space): "));
1116   if (!data)
1117     return -1;
1118   trim_spaces (data);
1119   cpr_kill_prompt ();
1120
1121   if (!*data)
1122     str = "9";
1123   else if ((*data == 'M' || *data == 'm') && !data[1])
1124     str = "1";
1125   else if ((*data == 'F' || *data == 'f') && !data[1])
1126     str = "2";
1127   else
1128     {
1129       tty_printf (_("Error: invalid response.\n"));
1130       xfree (data);
1131       return -1;
1132     }
1133
1134   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1135   if (rc)
1136     log_error ("error setting sex: %s\n", gpg_strerror (rc));
1137   xfree (data);
1138   write_sc_op_status (rc);
1139   return rc;
1140 }
1141
1142
1143 static int
1144 change_cafpr (int fprno)
1145 {
1146   char *data;
1147   const char *s;
1148   int i, c, rc;
1149   unsigned char fpr[20];
1150
1151   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1152   if (!data)
1153     return -1;
1154   trim_spaces (data);
1155   cpr_kill_prompt ();
1156
1157   for (i=0, s=data; i < 20 && *s; )
1158     {
1159       while (spacep(s))
1160         s++;
1161       if (*s == ':')
1162         s++;
1163       while (spacep(s))
1164         s++;
1165       c = hextobyte (s);
1166       if (c == -1)
1167         break;
1168       fpr[i++] = c;
1169       s += 2;
1170     }
1171   xfree (data);
1172   if (i != 20 || *s)
1173     {
1174       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1175       return -1;
1176     }
1177
1178   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1179                           fprno==2?"CA-FPR-2":
1180                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1181   if (rc)
1182     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1183   write_sc_op_status (rc);
1184   return rc;
1185 }
1186
1187
1188
1189 static void
1190 toggle_forcesig (void)
1191 {
1192   struct agent_card_info_s info;
1193   int rc;
1194   int newstate;
1195
1196   memset (&info, 0, sizeof info);
1197   rc = agent_scd_getattr ("CHV-STATUS", &info);
1198   if (rc)
1199     {
1200       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1201       return;
1202     }
1203   newstate = !info.chv1_cached;
1204   agent_release_card_info (&info);
1205
1206   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1207   if (rc)
1208     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1209   write_sc_op_status (rc);
1210 }
1211
1212
1213 /* Helper for the key generation/edit functions.  */
1214 static int
1215 get_info_for_key_operation (struct agent_card_info_s *info)
1216 {
1217   int rc;
1218
1219   memset (info, 0, sizeof *info);
1220   rc = agent_scd_getattr ("SERIALNO", info);
1221   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1222       || strlen (info->serialno) != 32 )
1223     {
1224       log_error (_("key operation not possible: %s\n"),
1225                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1226       return rc? rc: -1;
1227     }
1228   rc = agent_scd_getattr ("KEY-FPR", info);
1229   if (!rc)
1230     rc = agent_scd_getattr ("CHV-STATUS", info);
1231   if (!rc)
1232     rc = agent_scd_getattr ("DISP-NAME", info);
1233   if (!rc)
1234     rc = agent_scd_getattr ("EXTCAP", info);
1235   if (!rc)
1236     rc = agent_scd_getattr ("KEY-ATTR", info);
1237   if (rc)
1238     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1239   return rc;
1240 }
1241
1242
1243 /* Helper for the key generation/edit functions.  */
1244 static int
1245 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1246 {
1247   int rc = 0;
1248
1249   agent_clear_pin_cache (info->serialno);
1250
1251   *forced_chv1 = !info->chv1_cached;
1252   if (*forced_chv1)
1253     { /* Switch off the forced mode so that during key generation we
1254          don't get bothered with PIN queries for each
1255          self-signature. */
1256       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1257       if (rc)
1258         {
1259           log_error ("error clearing forced signature PIN flag: %s\n",
1260                      gpg_strerror (rc));
1261           *forced_chv1 = 0;
1262         }
1263     }
1264
1265   if (!rc)
1266     {
1267       /* Check the PIN now, so that we won't get asked later for each
1268          binding signature. */
1269       rc = agent_scd_checkpin (info->serialno);
1270       if (rc)
1271         {
1272           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1273           write_sc_op_status (rc);
1274         }
1275   }
1276   return rc;
1277 }
1278
1279 /* Helper for the key generation/edit functions.  */
1280 static void
1281 restore_forced_chv1 (int *forced_chv1)
1282 {
1283   int rc;
1284
1285   if (*forced_chv1)
1286     { /* Switch back to forced state. */
1287       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1288       if (rc)
1289         {
1290           log_error ("error setting forced signature PIN flag: %s\n",
1291                      gpg_strerror (rc));
1292         }
1293     }
1294 }
1295
1296
1297 /* Helper for the key generation/edit functions.  */
1298 static void
1299 show_card_key_info (struct agent_card_info_s *info)
1300 {
1301   tty_fprintf (NULL, "Signature key ....:");
1302   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1303   tty_fprintf (NULL, "Encryption key....:");
1304   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1305   tty_fprintf (NULL, "Authentication key:");
1306   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1307   tty_printf ("\n");
1308 }
1309
1310
1311 /* Helper for the key generation/edit functions.  */
1312 static int
1313 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1314 {
1315   log_assert (keyno >= 0 && keyno <= 3);
1316
1317   if ((keyno == 1 && info->fpr1valid)
1318       || (keyno == 2 && info->fpr2valid)
1319       || (keyno == 3 && info->fpr3valid))
1320     {
1321       tty_printf ("\n");
1322       log_info ("WARNING: such a key has already been stored on the card!\n");
1323       tty_printf ("\n");
1324       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1325                                   _("Replace existing key? (y/N) ")))
1326         return -1;
1327       return 1;
1328     }
1329   return 0;
1330 }
1331
1332
1333 static void
1334 show_keysize_warning (void)
1335 {
1336   static int shown;
1337
1338   if (shown)
1339     return;
1340   shown = 1;
1341   tty_printf
1342     (_("Note: There is no guarantee that the card "
1343        "supports the requested size.\n"
1344        "      If the key generation does not succeed, "
1345        "please check the\n"
1346        "      documentation of your card to see what "
1347        "sizes are allowed.\n"));
1348 }
1349
1350
1351 /* Ask for the size of a card key.  NBITS is the current size
1352    configured for the card.  KEYNO is the number of the key used to
1353    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1354    or the selected size.  */
1355 static unsigned int
1356 ask_card_rsa_keysize (int keyno, unsigned int nbits)
1357 {
1358   unsigned int min_nbits = 1024;
1359   unsigned int max_nbits = 4096;
1360   char *prompt, *answer;
1361   unsigned int req_nbits;
1362
1363   for (;;)
1364     {
1365       prompt = xasprintf
1366         (keyno == 0?
1367          _("What keysize do you want for the Signature key? (%u) "):
1368          keyno == 1?
1369          _("What keysize do you want for the Encryption key? (%u) "):
1370          _("What keysize do you want for the Authentication key? (%u) "),
1371          nbits);
1372       answer = cpr_get ("cardedit.genkeys.size", prompt);
1373       cpr_kill_prompt ();
1374       req_nbits = *answer? atoi (answer): nbits;
1375       xfree (prompt);
1376       xfree (answer);
1377
1378       if (req_nbits != nbits && (req_nbits % 32) )
1379         {
1380           req_nbits = ((req_nbits + 31) / 32) * 32;
1381           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1382         }
1383
1384       if (req_nbits == nbits)
1385         return 0;  /* Use default.  */
1386
1387       if (req_nbits < min_nbits || req_nbits > max_nbits)
1388         {
1389           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1390                       "RSA", min_nbits, max_nbits);
1391         }
1392       else
1393         {
1394           tty_printf (_("The card will now be re-configured "
1395                         "to generate a key of %u bits\n"), req_nbits);
1396           show_keysize_warning ();
1397           return req_nbits;
1398         }
1399     }
1400 }
1401
1402
1403 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1404    message if that fails.  */
1405 static gpg_error_t
1406 do_change_rsa_keysize (int keyno, unsigned int nbits)
1407 {
1408   gpg_error_t err;
1409   char args[100];
1410
1411   snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1412   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1413   if (err)
1414     log_error (_("error changing size of key %d to %u bits: %s\n"),
1415                keyno+1, nbits, gpg_strerror (err));
1416   return err;
1417 }
1418
1419
1420 static void
1421 generate_card_keys (ctrl_t ctrl)
1422 {
1423   struct agent_card_info_s info;
1424   int forced_chv1;
1425   int want_backup;
1426   int keyno;
1427
1428   if (get_info_for_key_operation (&info))
1429     return;
1430
1431   if (info.extcap.ki)
1432     {
1433       char *answer;
1434
1435       /* FIXME: Should be something like cpr_get_bool so that a status
1436          GET_BOOL will be emitted.  */
1437       answer = cpr_get ("cardedit.genkeys.backup_enc",
1438                         _("Make off-card backup of encryption key? (Y/n) "));
1439
1440       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1441       cpr_kill_prompt ();
1442       xfree (answer);
1443     }
1444   else
1445     want_backup = 0;
1446
1447   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1448        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1449        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1450     {
1451       tty_printf ("\n");
1452       log_info (_("Note: keys are already stored on the card!\n"));
1453       tty_printf ("\n");
1454       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1455                                    _("Replace existing keys? (y/N) ")))
1456         {
1457           agent_release_card_info (&info);
1458           return;
1459         }
1460     }
1461
1462   /* If no displayed name has been set, we assume that this is a fresh
1463      card and print a hint about the default PINs.  */
1464   if (!info.disp_name || !*info.disp_name)
1465     {
1466       tty_printf ("\n");
1467       tty_printf (_("Please note that the factory settings of the PINs are\n"
1468                     "   PIN = '%s'     Admin PIN = '%s'\n"
1469                     "You should change them using the command --change-pin\n"),
1470                   "123456", "12345678");
1471       tty_printf ("\n");
1472     }
1473
1474   if (check_pin_for_key_operation (&info, &forced_chv1))
1475     goto leave;
1476
1477   /* If the cards features changeable key attributes, we ask for the
1478      key size.  */
1479   if (info.is_v2 && info.extcap.aac)
1480     {
1481       unsigned int nbits;
1482
1483       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1484         {
1485           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1486             {
1487               nbits = ask_card_rsa_keysize (keyno, info.key_attr[keyno].nbits);
1488               if (nbits && do_change_rsa_keysize (keyno, nbits))
1489                 {
1490                   /* Error: Better read the default key size again.  */
1491                   agent_release_card_info (&info);
1492                   if (get_info_for_key_operation (&info))
1493                     goto leave;
1494                   /* Ask again for this key size. */
1495                   keyno--;
1496                 }
1497             }
1498         }
1499       /* Note that INFO has not be synced.  However we will only use
1500          the serialnumber and thus it won't harm.  */
1501     }
1502
1503   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1504
1505  leave:
1506   agent_release_card_info (&info);
1507   restore_forced_chv1 (&forced_chv1);
1508 }
1509
1510
1511 /* This function is used by the key edit menu to generate an arbitrary
1512    subkey. */
1513 gpg_error_t
1514 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1515 {
1516   gpg_error_t err;
1517   struct agent_card_info_s info;
1518   int forced_chv1 = 0;
1519   int keyno;
1520
1521   err = get_info_for_key_operation (&info);
1522   if (err)
1523     return err;
1524
1525   show_card_key_info (&info);
1526
1527   tty_printf (_("Please select the type of key to generate:\n"));
1528
1529   tty_printf (_("   (1) Signature key\n"));
1530   tty_printf (_("   (2) Encryption key\n"));
1531   tty_printf (_("   (3) Authentication key\n"));
1532
1533   for (;;)
1534     {
1535       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1536                               _("Your selection? "));
1537       cpr_kill_prompt();
1538       if (*answer == CONTROL_D)
1539         {
1540           xfree (answer);
1541           err = gpg_error (GPG_ERR_CANCELED);
1542           goto leave;
1543         }
1544       keyno = *answer? atoi(answer): 0;
1545       xfree(answer);
1546       if (keyno >= 1 && keyno <= 3)
1547         break; /* Okay. */
1548       tty_printf(_("Invalid selection.\n"));
1549     }
1550
1551   if (replace_existing_key_p (&info, keyno) < 0)
1552     {
1553       err = gpg_error (GPG_ERR_CANCELED);
1554       goto leave;
1555     }
1556
1557   err = check_pin_for_key_operation (&info, &forced_chv1);
1558   if (err)
1559     goto leave;
1560
1561   /* If the cards features changeable key attributes, we ask for the
1562      key size.  */
1563   if (info.is_v2 && info.extcap.aac)
1564     {
1565       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA)
1566         {
1567           unsigned int nbits;
1568
1569         ask_again:
1570           nbits = ask_card_rsa_keysize (keyno-1, info.key_attr[keyno-1].nbits);
1571           if (nbits && do_change_rsa_keysize (keyno-1, nbits))
1572             {
1573               /* Error: Better read the default key size again.  */
1574               agent_release_card_info (&info);
1575               err = get_info_for_key_operation (&info);
1576               if (err)
1577                 goto leave;
1578               goto ask_again;
1579             }
1580         }
1581       /* Note that INFO has not be synced.  However we will only use
1582          the serialnumber and thus it won't harm.  */
1583     }
1584
1585   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1586
1587  leave:
1588   agent_release_card_info (&info);
1589   restore_forced_chv1 (&forced_chv1);
1590   return err;
1591 }
1592
1593
1594 /* Store the key at NODE into the smartcard and modify NODE to
1595    carry the serialno stuff instead of the actual secret key
1596    parameters.  USE is the usage for that key; 0 means any
1597    usage. */
1598 int
1599 card_store_subkey (KBNODE node, int use)
1600 {
1601   struct agent_card_info_s info;
1602   int okay = 0;
1603   unsigned int nbits;
1604   int allow_keyno[3];
1605   int  keyno;
1606   PKT_public_key *pk;
1607   gpg_error_t err;
1608   char *hexgrip;
1609   int rc;
1610   gnupg_isotime_t timebuf;
1611
1612   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1613               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1614
1615   pk = node->pkt->pkt.public_key;
1616
1617   if (get_info_for_key_operation (&info))
1618     return 0;
1619
1620   if (!info.extcap.ki)
1621     {
1622       tty_printf ("The card does not support the import of keys\n");
1623       tty_printf ("\n");
1624       goto leave;
1625     }
1626
1627   nbits = nbits_from_pk (pk);
1628
1629   if (!info.is_v2 && nbits != 1024)
1630     {
1631       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1632       tty_printf ("\n");
1633       goto leave;
1634     }
1635
1636   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1637   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1638   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1639
1640   tty_printf (_("Please select where to store the key:\n"));
1641
1642   if (allow_keyno[0])
1643     tty_printf (_("   (1) Signature key\n"));
1644   if (allow_keyno[1])
1645     tty_printf (_("   (2) Encryption key\n"));
1646   if (allow_keyno[2])
1647     tty_printf (_("   (3) Authentication key\n"));
1648
1649   for (;;)
1650     {
1651       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1652                               _("Your selection? "));
1653       cpr_kill_prompt();
1654       if (*answer == CONTROL_D || !*answer)
1655         {
1656           xfree (answer);
1657           goto leave;
1658         }
1659       keyno = *answer? atoi(answer): 0;
1660       xfree(answer);
1661       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1662         {
1663           if (info.is_v2 && !info.extcap.aac
1664               && info.key_attr[keyno-1].nbits != nbits)
1665             {
1666               tty_printf ("Key does not match the card's capability.\n");
1667             }
1668           else
1669             break; /* Okay. */
1670         }
1671       else
1672         tty_printf(_("Invalid selection.\n"));
1673     }
1674
1675   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1676     goto leave;
1677
1678   err = hexkeygrip_from_pk (pk, &hexgrip);
1679   if (err)
1680     goto leave;
1681
1682   epoch2isotime (timebuf, (time_t)pk->timestamp);
1683   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1684
1685   if (rc)
1686     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1687   else
1688     okay = 1;
1689   xfree (hexgrip);
1690
1691  leave:
1692   agent_release_card_info (&info);
1693   return okay;
1694 }
1695
1696
1697
1698 /* Direct sending of an hex encoded APDU with error printing.  */
1699 static gpg_error_t
1700 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1701 {
1702   gpg_error_t err;
1703   unsigned int sw;
1704
1705   err = agent_scd_apdu (hexapdu, &sw);
1706   if (err)
1707     tty_printf ("sending card command %s failed: %s\n", desc,
1708                 gpg_strerror (err));
1709   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1710     ;
1711   else if (ignore == 0xffff)
1712     ; /* Ignore all status words.  */
1713   else if (sw != 0x9000)
1714     {
1715       switch (sw)
1716         {
1717         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1718         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1719         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1720         default: err = gpg_error (GPG_ERR_CARD);
1721         }
1722       if (!(ignore && ignore == sw))
1723         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1724                     gpg_strerror (err),  sw);
1725     }
1726   return err;
1727 }
1728
1729
1730 /* Do a factory reset after confirmation.  */
1731 static void
1732 factory_reset (void)
1733 {
1734   struct agent_card_info_s info;
1735   gpg_error_t err;
1736   char *answer = NULL;
1737   int termstate = 0;
1738   int i;
1739
1740   /*  The code below basically does the same what this
1741       gpg-connect-agent script does:
1742
1743         scd reset
1744         scd serialno undefined
1745         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1746         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1747         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1748         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1749         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1750         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1751         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1752         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1753         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1754         scd apdu 00 e6 00 00
1755         scd reset
1756         scd serialno undefined
1757         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1758         scd apdu 00 44 00 00
1759         /echo Card has been reset to factory defaults
1760
1761       but tries to find out something about the card first.
1762    */
1763
1764   err = agent_scd_learn (&info, 0);
1765   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1766       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1767     termstate = 1;
1768   else if (err)
1769     {
1770       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1771       return;
1772     }
1773
1774   if (!termstate)
1775     {
1776       log_info (_("OpenPGP card no. %s detected\n"),
1777                 info.serialno? info.serialno : "[none]");
1778       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1779         {
1780           /* Note: We won't see status-indicator 3 here because it is not
1781              possible to select a card application in termination state.  */
1782           log_error (_("This command is not supported by this card\n"));
1783           goto leave;
1784         }
1785
1786       tty_printf ("\n");
1787       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1788       tty_printf ("\n");
1789       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1790                                   _("Continue? (y/N) ")))
1791         goto leave;
1792
1793
1794       answer = cpr_get ("cardedit.factory-reset.really",
1795                         _("Really do a factory reset? (enter \"yes\") "));
1796       cpr_kill_prompt ();
1797       trim_spaces (answer);
1798       if (strcmp (answer, "yes"))
1799         goto leave;
1800
1801       /* We need to select a card application before we can send APDUs
1802          to the card without scdaemon doing anything on its own.  */
1803       err = send_apdu (NULL, "RESET", 0);
1804       if (err)
1805         goto leave;
1806       err = send_apdu ("undefined", "dummy select ", 0);
1807       if (err)
1808         goto leave;
1809
1810       /* Select the OpenPGP application.  */
1811       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1812       if (err)
1813         goto leave;
1814
1815       /* Do some dummy verifies with wrong PINs to set the retry
1816          counter to zero.  We can't easily use the card version 2.1
1817          feature of presenting the admin PIN to allow the terminate
1818          command because there is no machinery in scdaemon to catch
1819          the verify command and ask for the PIN when the "APDU"
1820          command is used. */
1821       for (i=0; i < 4; i++)
1822         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1823       for (i=0; i < 4; i++)
1824         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1825
1826       /* Send terminate datafile command.  */
1827       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1828       if (err)
1829         goto leave;
1830     }
1831
1832   /* The card is in termination state - reset and select again.  */
1833   err = send_apdu (NULL, "RESET", 0);
1834   if (err)
1835     goto leave;
1836   err = send_apdu ("undefined", "dummy select", 0);
1837   if (err)
1838     goto leave;
1839
1840   /* Select the OpenPGP application. (no error checking here). */
1841   send_apdu ("00A4040006D27600012401", "SELECT AID", 0xffff);
1842
1843   /* Send activate datafile command.  This is used without
1844      confirmation if the card is already in termination state.  */
1845   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1846   if (err)
1847     goto leave;
1848
1849   /* Finally we reset the card reader once more.  */
1850   err = send_apdu (NULL, "RESET", 0);
1851   if (err)
1852     goto leave;
1853
1854  leave:
1855   xfree (answer);
1856   agent_release_card_info (&info);
1857 }
1858
1859
1860 \f
1861 /* Data used by the command parser.  This needs to be outside of the
1862    function scope to allow readline based command completion.  */
1863 enum cmdids
1864   {
1865     cmdNOP = 0,
1866     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1867     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1868     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1869     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1870     cmdINVCMD
1871   };
1872
1873 static struct
1874 {
1875   const char *name;
1876   enum cmdids id;
1877   int admin_only;
1878   const char *desc;
1879 } cmds[] =
1880   {
1881     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1882     { "q"       , cmdQUIT  , 0, NULL },
1883     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1884     { "help"    , cmdHELP  , 0, N_("show this help")},
1885     { "?"       , cmdHELP  , 0, NULL },
1886     { "list"    , cmdLIST  , 0, N_("list all available data")},
1887     { "l"       , cmdLIST  , 0, NULL },
1888     { "debug"   , cmdDEBUG , 0, NULL },
1889     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1890     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1891     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1892     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1893     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1894     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1895     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1896     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1897     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1898     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1899     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1900     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1901     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1902     /* Note, that we do not announce these command yet. */
1903     { "privatedo", cmdPRIVATEDO, 0, NULL },
1904     { "readcert", cmdREADCERT, 0, NULL },
1905     { "writecert", cmdWRITECERT, 1, NULL },
1906     { NULL, cmdINVCMD, 0, NULL }
1907   };
1908
1909
1910 #ifdef HAVE_LIBREADLINE
1911
1912 /* These two functions are used by readline for command completion. */
1913
1914 static char *
1915 command_generator(const char *text,int state)
1916 {
1917   static int list_index,len;
1918   const char *name;
1919
1920   /* If this is a new word to complete, initialize now.  This includes
1921      saving the length of TEXT for efficiency, and initializing the
1922      index variable to 0. */
1923   if(!state)
1924     {
1925       list_index=0;
1926       len=strlen(text);
1927     }
1928
1929   /* Return the next partial match */
1930   while((name=cmds[list_index].name))
1931     {
1932       /* Only complete commands that have help text */
1933       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1934         return strdup(name);
1935     }
1936
1937   return NULL;
1938 }
1939
1940 static char **
1941 card_edit_completion(const char *text, int start, int end)
1942 {
1943   (void)end;
1944   /* If we are at the start of a line, we try and command-complete.
1945      If not, just do nothing for now. */
1946
1947   if(start==0)
1948     return rl_completion_matches(text,command_generator);
1949
1950   rl_attempted_completion_over=1;
1951
1952   return NULL;
1953 }
1954 #endif /*HAVE_LIBREADLINE*/
1955
1956 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1957    Key creation is not handled here. */
1958 void
1959 card_edit (ctrl_t ctrl, strlist_t commands)
1960 {
1961   enum cmdids cmd = cmdNOP;
1962   int have_commands = !!commands;
1963   int redisplay = 1;
1964   char *answer = NULL;
1965   int allow_admin=0;
1966   char serialnobuf[50];
1967
1968
1969   if (opt.command_fd != -1)
1970     ;
1971   else if (opt.batch && !have_commands)
1972     {
1973       log_error(_("can't do this in batch mode\n"));
1974       goto leave;
1975     }
1976
1977   for (;;)
1978     {
1979       int arg_number;
1980       const char *arg_string = "";
1981       const char *arg_rest = "";
1982       char *p;
1983       int i;
1984       int cmd_admin_only;
1985
1986       tty_printf("\n");
1987       if (redisplay)
1988         {
1989           if (opt.with_colons)
1990             {
1991               current_card_status (ctrl, es_stdout,
1992                                    serialnobuf, DIM (serialnobuf));
1993               fflush (stdout);
1994             }
1995           else
1996             {
1997               current_card_status (ctrl, NULL,
1998                                    serialnobuf, DIM (serialnobuf));
1999               tty_printf("\n");
2000             }
2001           redisplay = 0;
2002         }
2003
2004       do
2005         {
2006           xfree (answer);
2007           if (have_commands)
2008             {
2009               if (commands)
2010                 {
2011                   answer = xstrdup (commands->d);
2012                   commands = commands->next;
2013                 }
2014               else if (opt.batch)
2015                 {
2016                   answer = xstrdup ("quit");
2017                 }
2018               else
2019                 have_commands = 0;
2020             }
2021
2022             if (!have_commands)
2023               {
2024                 tty_enable_completion (card_edit_completion);
2025                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2026                 cpr_kill_prompt();
2027                 tty_disable_completion ();
2028               }
2029             trim_spaces(answer);
2030         }
2031       while ( *answer == '#' );
2032
2033       arg_number = 0; /* Yes, here is the init which egcc complains about */
2034       cmd_admin_only = 0;
2035       if (!*answer)
2036         cmd = cmdLIST; /* Default to the list command */
2037       else if (*answer == CONTROL_D)
2038         cmd = cmdQUIT;
2039       else
2040         {
2041           if ((p=strchr (answer,' ')))
2042             {
2043               *p++ = 0;
2044               trim_spaces (answer);
2045               trim_spaces (p);
2046               arg_number = atoi(p);
2047               arg_string = p;
2048               arg_rest = p;
2049               while (digitp (arg_rest))
2050                 arg_rest++;
2051               while (spacep (arg_rest))
2052                 arg_rest++;
2053             }
2054
2055           for (i=0; cmds[i].name; i++ )
2056             if (!ascii_strcasecmp (answer, cmds[i].name ))
2057               break;
2058
2059           cmd = cmds[i].id;
2060           cmd_admin_only = cmds[i].admin_only;
2061         }
2062
2063       if (!allow_admin && cmd_admin_only)
2064         {
2065           tty_printf ("\n");
2066           tty_printf (_("Admin-only command\n"));
2067           continue;
2068         }
2069
2070       switch (cmd)
2071         {
2072         case cmdHELP:
2073           for (i=0; cmds[i].name; i++ )
2074             if(cmds[i].desc
2075                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2076               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2077           break;
2078
2079         case cmdADMIN:
2080           if ( !strcmp (arg_string, "on") )
2081             allow_admin = 1;
2082           else if ( !strcmp (arg_string, "off") )
2083             allow_admin = 0;
2084           else if ( !strcmp (arg_string, "verify") )
2085             {
2086               /* Force verification of the Admin Command.  However,
2087                  this is only done if the retry counter is at initial
2088                  state.  */
2089               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2090               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2091               allow_admin = !agent_scd_checkpin (tmp);
2092               xfree (tmp);
2093             }
2094           else /* Toggle. */
2095             allow_admin=!allow_admin;
2096           if(allow_admin)
2097             tty_printf(_("Admin commands are allowed\n"));
2098           else
2099             tty_printf(_("Admin commands are not allowed\n"));
2100           break;
2101
2102         case cmdVERIFY:
2103           agent_scd_checkpin (serialnobuf);
2104           redisplay = 1;
2105           break;
2106
2107         case cmdLIST:
2108           redisplay = 1;
2109           break;
2110
2111         case cmdNAME:
2112           change_name ();
2113           break;
2114
2115         case cmdURL:
2116           change_url ();
2117           break;
2118
2119         case cmdFETCH:
2120           fetch_url (ctrl);
2121           break;
2122
2123         case cmdLOGIN:
2124           change_login (arg_string);
2125           break;
2126
2127         case cmdLANG:
2128           change_lang ();
2129           break;
2130
2131         case cmdSEX:
2132           change_sex ();
2133           break;
2134
2135         case cmdCAFPR:
2136           if ( arg_number < 1 || arg_number > 3 )
2137             tty_printf ("usage: cafpr N\n"
2138                         "       1 <= N <= 3\n");
2139           else
2140             change_cafpr (arg_number);
2141           break;
2142
2143         case cmdPRIVATEDO:
2144           if ( arg_number < 1 || arg_number > 4 )
2145             tty_printf ("usage: privatedo N\n"
2146                         "       1 <= N <= 4\n");
2147           else
2148             change_private_do (arg_string, arg_number);
2149           break;
2150
2151         case cmdWRITECERT:
2152           if ( arg_number != 3 )
2153             tty_printf ("usage: writecert 3 < FILE\n");
2154           else
2155             change_cert (arg_rest);
2156           break;
2157
2158         case cmdREADCERT:
2159           if ( arg_number != 3 )
2160             tty_printf ("usage: readcert 3 > FILE\n");
2161           else
2162             read_cert (arg_rest);
2163           break;
2164
2165         case cmdFORCESIG:
2166           toggle_forcesig ();
2167           break;
2168
2169         case cmdGENERATE:
2170           generate_card_keys (ctrl);
2171           break;
2172
2173         case cmdPASSWD:
2174           change_pin (0, allow_admin);
2175           break;
2176
2177         case cmdUNBLOCK:
2178           change_pin (1, allow_admin);
2179           break;
2180
2181         case cmdFACTORYRESET:
2182           factory_reset ();
2183           break;
2184
2185         case cmdQUIT:
2186           goto leave;
2187
2188         case cmdNOP:
2189           break;
2190
2191         case cmdINVCMD:
2192         default:
2193           tty_printf ("\n");
2194           tty_printf (_("Invalid command  (try \"help\")\n"));
2195           break;
2196         } /* End command switch. */
2197     } /* End of main menu loop. */
2198
2199  leave:
2200   xfree (answer);
2201 }