card: Display UIF setting.
[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     case 0x0042: return "GnuPG e.V.";
216
217     case 0x1337: return "Warsaw Hackerspace";
218     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
219     case 0x4354: return "Confidential Technologies";   /* cotech.de */
220     case 0x63AF: return "Trustica";
221     case 0xBD0E: return "Paranoidlabs";
222     case 0xF517: return "FSIJ";
223
224       /* 0x0000 and 0xFFFF are defined as test cards per spec,
225          0xFF00 to 0xFFFE are assigned for use with randomly created
226          serial numbers.  */
227     case 0x0000:
228     case 0xffff: return "test card";
229     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
230     }
231 }
232
233
234 static void
235 print_shax_fpr (estream_t fp, const unsigned char *fpr, unsigned int fprlen)
236 {
237   int i;
238
239   if (fpr)
240     {
241       /* FIXME: Fix formatting for FPRLEN != 20 */
242       for (i=0; i < fprlen ; i+=2, fpr += 2 )
243         {
244           if (i == 10 )
245             tty_fprintf (fp, " ");
246           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
247         }
248     }
249   else
250     tty_fprintf (fp, " [none]");
251   tty_fprintf (fp, "\n");
252 }
253
254
255 static void
256 print_shax_fpr_colon (estream_t fp,
257                       const unsigned char *fpr, unsigned int fprlen)
258 {
259   int i;
260
261   if (fpr)
262     {
263       for (i=0; i < fprlen ; i++, fpr++)
264         es_fprintf (fp, "%02X", *fpr);
265     }
266   es_putc (':', fp);
267 }
268
269
270 static void
271 print_keygrip (estream_t fp, const unsigned char *grp)
272 {
273   int i;
274
275   if (opt.with_keygrip)
276     {
277       tty_fprintf (fp, "      keygrip ....: ");
278       for (i=0; i < 20 ; i++, grp++)
279         tty_fprintf (fp, "%02X", *grp);
280       tty_fprintf (fp, "\n");
281     }
282 }
283
284
285 static void
286 print_name (estream_t fp, const char *text, const char *name)
287 {
288   tty_fprintf (fp, "%s", text);
289
290   /* FIXME: tty_printf_utf8_string2 eats everything after and
291      including an @ - e.g. when printing an url. */
292   if (name && *name)
293     {
294       if (fp)
295         print_utf8_buffer2 (fp, name, strlen (name), '\n');
296       else
297         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
298     }
299   else
300     tty_fprintf (fp, _("[not set]"));
301   tty_fprintf (fp, "\n");
302 }
303
304 static void
305 print_isoname (estream_t fp, const char *text,
306                const char *tag, const char *name)
307 {
308   if (opt.with_colons)
309     es_fprintf (fp, "%s:", tag);
310   else
311     tty_fprintf (fp, "%s", text);
312
313   if (name && *name)
314     {
315       char *p, *given, *buf = xstrdup (name);
316
317       given = strstr (buf, "<<");
318       for (p=buf; *p; p++)
319         if (*p == '<')
320           *p = ' ';
321       if (given && given[2])
322         {
323           *given = 0;
324           given += 2;
325           if (opt.with_colons)
326             es_write_sanitized (fp, given, strlen (given), ":", NULL);
327           else if (fp)
328             print_utf8_buffer2 (fp, given, strlen (given), '\n');
329           else
330             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
331
332           if (opt.with_colons)
333             es_putc (':', fp);
334           else if (*buf)
335             tty_fprintf (fp, " ");
336         }
337
338       if (opt.with_colons)
339         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
340       else if (fp)
341         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
342       else
343         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
344       xfree (buf);
345     }
346   else
347     {
348       if (opt.with_colons)
349         es_putc (':', fp);
350       else
351         tty_fprintf (fp, _("[not set]"));
352     }
353
354   if (opt.with_colons)
355     es_fputs (":\n", fp);
356   else
357     tty_fprintf (fp, "\n");
358 }
359
360 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
361 static int
362 fpr_is_zero (const char *fpr, unsigned int fprlen)
363 {
364   int i;
365
366   for (i=0; i < fprlen && !fpr[i]; i++)
367     ;
368   return (i == fprlen);
369 }
370
371
372 /* Return true if the fingerprint FPR consists only of 0xFF. */
373 static int
374 fpr_is_ff (const char *fpr, unsigned int fprlen)
375 {
376   int i;
377
378   for (i=0; i < fprlen && fpr[i] == '\xff'; i++)
379     ;
380   return (i == fprlen);
381 }
382
383
384 /* Print all available information about the current card. */
385 static void
386 current_card_status (ctrl_t ctrl, estream_t fp,
387                      char *serialno, size_t serialnobuflen)
388 {
389   struct agent_card_info_s info;
390   PKT_public_key *pk = xcalloc (1, sizeof *pk);
391   kbnode_t keyblock = NULL;
392   int rc;
393   unsigned int uval;
394   const unsigned char *thefpr;
395   unsigned int thefprlen;
396   int i;
397
398   if (serialno && serialnobuflen)
399     *serialno = 0;
400
401   rc = agent_scd_learn (&info, 0);
402   if (rc)
403     {
404       if (opt.with_colons)
405         es_fputs ("AID:::\n", fp);
406       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
407       xfree (pk);
408       return;
409     }
410
411   if (opt.with_colons)
412     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
413   else
414     tty_fprintf (fp, "Reader ...........: %s\n",
415                  info.reader? info.reader : "[none]");
416   if (opt.with_colons)
417     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
418   else
419     tty_fprintf (fp, "Application ID ...: %s\n",
420                  info.serialno? info.serialno : "[none]");
421   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
422       || strlen (info.serialno) != 32 )
423     {
424       if (info.apptype && !strcmp (info.apptype, "NKS"))
425         {
426           if (opt.with_colons)
427             es_fputs ("netkey-card:\n", fp);
428           log_info ("this is a NetKey card\n");
429         }
430       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
431         {
432           if (opt.with_colons)
433             es_fputs ("dinsig-card:\n", fp);
434           log_info ("this is a DINSIG compliant card\n");
435         }
436       else if (info.apptype && !strcmp (info.apptype, "P15"))
437         {
438           if (opt.with_colons)
439             es_fputs ("pkcs15-card:\n", fp);
440           log_info ("this is a PKCS#15 compliant card\n");
441         }
442       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
443         {
444           if (opt.with_colons)
445             es_fputs ("geldkarte-card:\n", fp);
446           log_info ("this is a Geldkarte compliant card\n");
447         }
448       else
449         {
450           if (opt.with_colons)
451             es_fputs ("unknown:\n", fp);
452         }
453       log_info ("not an OpenPGP card\n");
454       agent_release_card_info (&info);
455       xfree (pk);
456       return;
457     }
458
459   if (!serialno)
460     ;
461   else if (strlen (info.serialno)+1 > serialnobuflen)
462     log_error ("serial number longer than expected\n");
463   else
464     strcpy (serialno, info.serialno);
465
466   if (opt.with_colons)
467     es_fputs ("openpgp-card:\n", fp);
468
469
470   if (opt.with_colons)
471     {
472       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
473       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
474       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
475       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
476
477       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
478
479       es_fputs ("lang:", fp);
480       if (info.disp_lang)
481         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
482                             ":", NULL);
483       es_fputs (":\n", fp);
484
485       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
486                                  info.disp_sex == 2? 'f' : 'u'));
487
488       es_fputs ("url:", fp);
489       if (info.pubkey_url)
490         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
491                             ":", NULL);
492       es_fputs (":\n", fp);
493
494       es_fputs ("login:", fp);
495       if (info.login_data)
496         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
497                             ":", NULL);
498       es_fputs (":\n", fp);
499
500       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
501       for (i=0; i < DIM (info.key_attr); i++)
502         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
503           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
504                       info.key_attr[i].algo, info.key_attr[i].nbits);
505         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
506                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
507                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
508           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
509                       info.key_attr[i].algo, info.key_attr[i].curve);
510       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
511                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
512       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
513                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
514       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
515       if (info.extcap.kdf)
516         {
517           es_fprintf (fp, "kdf:%s:\n", info.kdf_do_enabled ? "on" : "off");
518         }
519       if (info.extcap.bt)
520         {
521           es_fprintf (fp, "uif:%d:%d:%d:\n",
522                       info.uif[0], info.uif[1], info.uif[2]);
523         }
524
525       for (i=0; i < 4; i++)
526         {
527           if (info.private_do[i])
528             {
529               es_fprintf (fp, "private_do:%d:", i+1);
530               es_write_sanitized (fp, info.private_do[i],
531                                   strlen (info.private_do[i]), ":", NULL);
532               es_fputs (":\n", fp);
533             }
534         }
535
536       es_fputs ("cafpr:", fp);
537       print_shax_fpr_colon (fp, info.cafpr1len? info.cafpr1:NULL,
538                             info.cafpr2len);
539       print_shax_fpr_colon (fp, info.cafpr2len? info.cafpr2:NULL,
540                             info.cafpr2len);
541       print_shax_fpr_colon (fp, info.cafpr3len? info.cafpr3:NULL,
542                             info.cafpr3len);
543       es_putc ('\n', fp);
544       es_fputs ("fpr:", fp);
545       print_shax_fpr_colon (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
546       print_shax_fpr_colon (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
547       print_shax_fpr_colon (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
548       es_putc ('\n', fp);
549       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
550                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
551                (unsigned long)info.fpr3time);
552       es_fputs ("grp:", fp);
553       print_shax_fpr_colon (fp, info.grp1, sizeof info.grp1);
554       print_shax_fpr_colon (fp, info.grp2, sizeof info.grp2);
555       print_shax_fpr_colon (fp, info.grp3, sizeof info.grp3);
556       es_putc ('\n', fp);
557     }
558   else
559     {
560       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
561                    info.serialno[12] == '0'?"":info.serialno+12,
562                    info.serialno[13],
563                    info.serialno[14] == '0'?"":info.serialno+14,
564                    info.serialno[15]);
565       tty_fprintf (fp, "Manufacturer .....: %s\n",
566                    get_manufacturer (xtoi_2(info.serialno+16)*256
567                                      + xtoi_2 (info.serialno+18)));
568       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
569
570       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
571       print_name (fp, "Language prefs ...: ", info.disp_lang);
572       tty_fprintf (fp, "Salutation .......: %s\n",
573                    info.disp_sex == 1? _("Mr."):
574                    info.disp_sex == 2? _("Mrs.") : "");
575       print_name (fp, "URL of public key : ", info.pubkey_url);
576       print_name (fp, "Login data .......: ", info.login_data);
577       if (info.private_do[0])
578         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
579       if (info.private_do[1])
580         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
581       if (info.private_do[2])
582         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
583       if (info.private_do[3])
584         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
585       if (info.cafpr1len)
586         {
587           tty_fprintf (fp, "CA fingerprint %d .:", 1);
588           print_shax_fpr (fp, info.cafpr1, info.cafpr1len);
589         }
590       if (info.cafpr2len)
591         {
592           tty_fprintf (fp, "CA fingerprint %d .:", 2);
593           print_shax_fpr (fp, info.cafpr2, info.cafpr2len);
594         }
595       if (info.cafpr3len)
596         {
597           tty_fprintf (fp, "CA fingerprint %d .:", 3);
598           print_shax_fpr (fp, info.cafpr3, info.cafpr3len);
599         }
600       tty_fprintf (fp,    "Signature PIN ....: %s\n",
601                    info.chv1_cached? _("not forced"): _("forced"));
602       if (info.key_attr[0].algo)
603         {
604           tty_fprintf (fp,    "Key attributes ...:");
605           for (i=0; i < DIM (info.key_attr); i++)
606             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
607               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
608             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
609                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
610                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
611               {
612                 const char *curve_for_print = "?";
613
614                 if (info.key_attr[i].curve)
615                   {
616                     const char *oid;
617                     oid = openpgp_curve_to_oid (info.key_attr[i].curve, NULL);
618                     if (oid)
619                       curve_for_print = openpgp_oid_to_curve (oid, 0);
620                   }
621                 tty_fprintf (fp, " %s", curve_for_print);
622               }
623           tty_fprintf (fp, "\n");
624         }
625       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
626                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
627       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
628                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
629       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
630       if (info.extcap.kdf)
631         {
632           tty_fprintf (fp, "KDF setting ......: %s\n",
633                        info.kdf_do_enabled ? "on" : "off");
634         }
635       if (info.extcap.bt)
636         {
637           tty_fprintf (fp, "UIF setting ......: Sign=%s Decrypt=%s Auth=%s\n",
638                        info.uif[0] ? "on" : "off", info.uif[1] ? "on" : "off",
639                        info.uif[2] ? "on" : "off");
640         }
641       tty_fprintf (fp, "Signature key ....:");
642       print_shax_fpr (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
643       if (info.fpr1len && info.fpr1time)
644         {
645           tty_fprintf (fp, "      created ....: %s\n",
646                        isotimestamp (info.fpr1time));
647           print_keygrip (fp, info.grp1);
648         }
649       tty_fprintf (fp, "Encryption key....:");
650       print_shax_fpr (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
651       if (info.fpr2len && info.fpr2time)
652         {
653           tty_fprintf (fp, "      created ....: %s\n",
654                        isotimestamp (info.fpr2time));
655           print_keygrip (fp, info.grp2);
656         }
657       tty_fprintf (fp, "Authentication key:");
658       print_shax_fpr (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
659       if (info.fpr3len && info.fpr3time)
660         {
661           tty_fprintf (fp, "      created ....: %s\n",
662                        isotimestamp (info.fpr3time));
663           print_keygrip (fp, info.grp3);
664         }
665       tty_fprintf (fp, "General key info..: ");
666
667       thefpr = (info.fpr1len? info.fpr1 : info.fpr2len? info.fpr2 :
668                 info.fpr3len? info.fpr3 : NULL);
669       thefprlen = (info.fpr1len? info.fpr1len : info.fpr2len? info.fpr2len :
670                    info.fpr3len? info.fpr3len : 0);
671       /* If the fingerprint is all 0xff, the key has no associated
672          OpenPGP certificate.  */
673       if ( thefpr && !fpr_is_ff (thefpr, thefprlen)
674            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, thefprlen))
675         {
676           print_pubkey_info (ctrl, fp, pk);
677           if (keyblock)
678             print_card_key_info (fp, keyblock);
679         }
680       else
681         tty_fprintf (fp, "[none]\n");
682     }
683
684   release_kbnode (keyblock);
685   free_public_key (pk);
686   agent_release_card_info (&info);
687 }
688
689
690 /* Print all available information for specific card with SERIALNO.
691    Print all available information for current card when SERIALNO is NULL.
692    Or print for all cards when SERIALNO is "all".  */
693 void
694 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
695 {
696   int err;
697   strlist_t card_list, sl;
698   char *serialno0, *serialno1;
699   int all_cards = 0;
700
701   if (serialno == NULL)
702     {
703       current_card_status (ctrl, fp, NULL, 0);
704       return;
705     }
706
707   if (!strcmp (serialno, "all"))
708     all_cards = 1;
709
710   err = agent_scd_serialno (&serialno0, NULL);
711   if (err)
712     {
713       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
714         log_info (_("error getting serial number of card: %s\n"),
715                   gpg_strerror (err));
716       /* Nothing available.  */
717       return;
718     }
719
720   err = agent_scd_cardlist (&card_list);
721
722   for (sl = card_list; sl; sl = sl->next)
723     {
724       if (!all_cards && strcmp (serialno, sl->d))
725         continue;
726
727       err = agent_scd_serialno (&serialno1, sl->d);
728       if (err)
729         {
730           if (opt.verbose)
731             log_info (_("error getting serial number of card: %s\n"),
732                       gpg_strerror (err));
733           continue;
734         }
735
736       current_card_status (ctrl, fp, NULL, 0);
737       xfree (serialno1);
738
739       if (!all_cards)
740         goto leave;
741     }
742
743   /* Select the original card again.  */
744   err = agent_scd_serialno (&serialno1, serialno0);
745   xfree (serialno1);
746
747  leave:
748   xfree (serialno0);
749   free_strlist (card_list);
750 }
751
752
753 static char *
754 get_one_name (const char *prompt1, const char *prompt2)
755 {
756   char *name;
757   int i;
758
759   for (;;)
760     {
761       name = cpr_get (prompt1, prompt2);
762       if (!name)
763         return NULL;
764       trim_spaces (name);
765       cpr_kill_prompt ();
766       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
767         ;
768
769       /* The name must be in Latin-1 and not UTF-8 - lacking the code
770          to ensure this we restrict it to ASCII. */
771       if (name[i])
772         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
773       else if (strchr (name, '<'))
774         tty_printf (_("Error: The \"<\" character may not be used.\n"));
775       else if (strstr (name, "  "))
776         tty_printf (_("Error: Double spaces are not allowed.\n"));
777       else
778         return name;
779       xfree (name);
780     }
781 }
782
783
784
785 static int
786 change_name (void)
787 {
788   char *surname = NULL, *givenname = NULL;
789   char *isoname, *p;
790   int rc;
791
792   surname = get_one_name ("keygen.smartcard.surname",
793                                     _("Cardholder's surname: "));
794   givenname = get_one_name ("keygen.smartcard.givenname",
795                                        _("Cardholder's given name: "));
796   if (!surname || !givenname || (!*surname && !*givenname))
797     {
798       xfree (surname);
799       xfree (givenname);
800       return -1; /*canceled*/
801     }
802
803   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
804   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
805   xfree (surname);
806   xfree (givenname);
807   for (p=isoname; *p; p++)
808     if (*p == ' ')
809       *p = '<';
810
811   if (strlen (isoname) > 39 )
812     {
813       tty_printf (_("Error: Combined name too long "
814                     "(limit is %d characters).\n"), 39);
815       xfree (isoname);
816       return -1;
817     }
818
819   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname), NULL );
820   if (rc)
821     log_error ("error setting Name: %s\n", gpg_strerror (rc));
822
823   xfree (isoname);
824   return rc;
825 }
826
827
828 static int
829 change_url (void)
830 {
831   char *url;
832   int rc;
833
834   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
835   if (!url)
836     return -1;
837   trim_spaces (url);
838   cpr_kill_prompt ();
839
840   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url), NULL );
841   if (rc)
842     log_error ("error setting URL: %s\n", gpg_strerror (rc));
843   xfree (url);
844   write_sc_op_status (rc);
845   return rc;
846 }
847
848
849 /* Fetch the key from the URL given on the card or try to get it from
850    the default keyserver.  */
851 static int
852 fetch_url (ctrl_t ctrl)
853 {
854   int rc;
855   struct agent_card_info_s info;
856
857   memset(&info,0,sizeof(info));
858
859   rc=agent_scd_getattr("PUBKEY-URL",&info);
860   if(rc)
861     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
862   else
863     {
864       rc=agent_scd_getattr("KEY-FPR",&info);
865       if(rc)
866         log_error("error retrieving key fingerprint from card: %s\n",
867                   gpg_strerror(rc));
868       else if (info.pubkey_url && *info.pubkey_url)
869         {
870           strlist_t sl = NULL;
871
872           add_to_strlist (&sl, info.pubkey_url);
873           rc = keyserver_fetch (ctrl, sl, KEYORG_URL);
874           free_strlist (sl);
875         }
876       else if (info.fpr1len)
877         {
878           rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len,
879                                         opt.keyserver, 0);
880         }
881     }
882
883   agent_release_card_info (&info);
884   return rc;
885 }
886
887
888 #define MAX_GET_DATA_FROM_FILE 16384
889
890 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
891    On error return -1 and store NULL at R_BUFFER; on success return
892    the number of bytes read and store the address of a newly allocated
893    buffer at R_BUFFER. */
894 static int
895 get_data_from_file (const char *fname, char **r_buffer)
896 {
897   estream_t fp;
898   char *data;
899   int n;
900
901   *r_buffer = NULL;
902
903   fp = es_fopen (fname, "rb");
904 #if GNUPG_MAJOR_VERSION == 1
905   if (fp && is_secured_file (fileno (fp)))
906     {
907       fclose (fp);
908       fp = NULL;
909       errno = EPERM;
910     }
911 #endif
912   if (!fp)
913     {
914       tty_printf (_("can't open '%s': %s\n"), fname, strerror (errno));
915       return -1;
916     }
917
918   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
919   if (!data)
920     {
921       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
922       es_fclose (fp);
923       return -1;
924     }
925
926   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
927   es_fclose (fp);
928   if (n < 0)
929     {
930       tty_printf (_("error reading '%s': %s\n"), fname, strerror (errno));
931       xfree (data);
932       return -1;
933     }
934   *r_buffer = data;
935   return n;
936 }
937
938
939 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
940    success.  */
941 static int
942 put_data_to_file (const char *fname, const void *buffer, size_t length)
943 {
944   estream_t fp;
945
946   fp = es_fopen (fname, "wb");
947 #if GNUPG_MAJOR_VERSION == 1
948   if (fp && is_secured_file (fileno (fp)))
949     {
950       fclose (fp);
951       fp = NULL;
952       errno = EPERM;
953     }
954 #endif
955   if (!fp)
956     {
957       tty_printf (_("can't create '%s': %s\n"), fname, strerror (errno));
958       return -1;
959     }
960
961   if (length && es_fwrite (buffer, length, 1, fp) != 1)
962     {
963       tty_printf (_("error writing '%s': %s\n"), fname, strerror (errno));
964       es_fclose (fp);
965       return -1;
966     }
967   es_fclose (fp);
968   return 0;
969 }
970
971
972 static int
973 change_login (const char *args)
974 {
975   char *data;
976   int n;
977   int rc;
978
979   if (args && *args == '<')  /* Read it from a file */
980     {
981       for (args++; spacep (args); args++)
982         ;
983       n = get_data_from_file (args, &data);
984       if (n < 0)
985         return -1;
986     }
987   else
988     {
989       data = cpr_get ("cardedit.change_login",
990                       _("Login data (account name): "));
991       if (!data)
992         return -1;
993       trim_spaces (data);
994       cpr_kill_prompt ();
995       n = strlen (data);
996     }
997
998   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
999   if (rc)
1000     log_error ("error setting login data: %s\n", gpg_strerror (rc));
1001   xfree (data);
1002   write_sc_op_status (rc);
1003   return rc;
1004 }
1005
1006 static int
1007 change_private_do (const char *args, int nr)
1008 {
1009   char do_name[] = "PRIVATE-DO-X";
1010   char *data;
1011   int n;
1012   int rc;
1013
1014   log_assert (nr >= 1 && nr <= 4);
1015   do_name[11] = '0' + nr;
1016
1017   if (args && (args = strchr (args, '<')))  /* Read it from a file */
1018     {
1019       for (args++; spacep (args); args++)
1020         ;
1021       n = get_data_from_file (args, &data);
1022       if (n < 0)
1023         return -1;
1024     }
1025   else
1026     {
1027       data = cpr_get ("cardedit.change_private_do",
1028                       _("Private DO data: "));
1029       if (!data)
1030         return -1;
1031       trim_spaces (data);
1032       cpr_kill_prompt ();
1033       n = strlen (data);
1034     }
1035
1036   rc = agent_scd_setattr (do_name, data, n, NULL );
1037   if (rc)
1038     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
1039   xfree (data);
1040   write_sc_op_status (rc);
1041   return rc;
1042 }
1043
1044
1045 static int
1046 change_cert (const char *args)
1047 {
1048   char *data;
1049   int n;
1050   int rc;
1051
1052   if (args && *args == '<')  /* Read it from a file */
1053     {
1054       for (args++; spacep (args); args++)
1055         ;
1056       n = get_data_from_file (args, &data);
1057       if (n < 0)
1058         return -1;
1059     }
1060   else
1061     {
1062       tty_printf ("usage error: redirection to file required\n");
1063       return -1;
1064     }
1065
1066   rc = agent_scd_writecert ("OPENPGP.3", data, n);
1067   if (rc)
1068     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
1069   xfree (data);
1070   write_sc_op_status (rc);
1071   return rc;
1072 }
1073
1074
1075 static int
1076 read_cert (const char *args)
1077 {
1078   const char *fname;
1079   void *buffer;
1080   size_t length;
1081   int rc;
1082
1083   if (args && *args == '>')  /* Write it to a file */
1084     {
1085       for (args++; spacep (args); args++)
1086         ;
1087       fname = args;
1088     }
1089   else
1090     {
1091       tty_printf ("usage error: redirection to file required\n");
1092       return -1;
1093     }
1094
1095   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
1096   if (rc)
1097     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
1098   else
1099     rc = put_data_to_file (fname, buffer, length);
1100   xfree (buffer);
1101   write_sc_op_status (rc);
1102   return rc;
1103 }
1104
1105
1106 static int
1107 change_lang (void)
1108 {
1109   char *data, *p;
1110   int rc;
1111
1112   data = cpr_get ("cardedit.change_lang",
1113                   _("Language preferences: "));
1114   if (!data)
1115     return -1;
1116   trim_spaces (data);
1117   cpr_kill_prompt ();
1118
1119   if (strlen (data) > 8 || (strlen (data) & 1))
1120     {
1121       tty_printf (_("Error: invalid length of preference string.\n"));
1122       xfree (data);
1123       return -1;
1124     }
1125
1126   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1127     ;
1128   if (*p)
1129     {
1130       tty_printf (_("Error: invalid characters in preference string.\n"));
1131       xfree (data);
1132       return -1;
1133     }
1134
1135   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1136   if (rc)
1137     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1138   xfree (data);
1139   write_sc_op_status (rc);
1140   return rc;
1141 }
1142
1143
1144 static int
1145 change_sex (void)
1146 {
1147   char *data;
1148   const char *str;
1149   int rc;
1150
1151   data = cpr_get ("cardedit.change_sex",
1152                   _("Salutation (M = Mr., F = Mrs., or space): "));
1153   if (!data)
1154     return -1;
1155   trim_spaces (data);
1156   cpr_kill_prompt ();
1157
1158   if (!*data)
1159     str = "9";
1160   else if ((*data == 'M' || *data == 'm') && !data[1])
1161     str = "1";
1162   else if ((*data == 'F' || *data == 'f') && !data[1])
1163     str = "2";
1164   else
1165     {
1166       tty_printf (_("Error: invalid response.\n"));
1167       xfree (data);
1168       return -1;
1169     }
1170
1171   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1172   if (rc)
1173     log_error ("error setting salutation: %s\n", gpg_strerror (rc));
1174   xfree (data);
1175   write_sc_op_status (rc);
1176   return rc;
1177 }
1178
1179
1180 static int
1181 change_cafpr (int fprno)
1182 {
1183   char *data;
1184   const char *s;
1185   int i, c, rc;
1186   unsigned char fpr[MAX_FINGERPRINT_LEN];
1187   int fprlen;
1188
1189   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1190   if (!data)
1191     return -1;
1192   trim_spaces (data);
1193   cpr_kill_prompt ();
1194
1195   for (i=0, s=data; i < MAX_FINGERPRINT_LEN && *s; )
1196     {
1197       while (spacep(s))
1198         s++;
1199       if (*s == ':')
1200         s++;
1201       while (spacep(s))
1202         s++;
1203       c = hextobyte (s);
1204       if (c == -1)
1205         break;
1206       fpr[i++] = c;
1207       s += 2;
1208     }
1209   fprlen = i;
1210   xfree (data);
1211   if ((fprlen != 20 && fprlen != 32) || *s)
1212     {
1213       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1214       return -1;
1215     }
1216
1217   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1218                           fprno==2?"CA-FPR-2":
1219                           fprno==3?"CA-FPR-3":"x", fpr, fprlen, NULL );
1220   if (rc)
1221     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1222   write_sc_op_status (rc);
1223   return rc;
1224 }
1225
1226
1227
1228 static void
1229 toggle_forcesig (void)
1230 {
1231   struct agent_card_info_s info;
1232   int rc;
1233   int newstate;
1234
1235   memset (&info, 0, sizeof info);
1236   rc = agent_scd_getattr ("CHV-STATUS", &info);
1237   if (rc)
1238     {
1239       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1240       return;
1241     }
1242   newstate = !info.chv1_cached;
1243   agent_release_card_info (&info);
1244
1245   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1246   if (rc)
1247     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1248   write_sc_op_status (rc);
1249 }
1250
1251
1252 /* Helper for the key generation/edit functions.  */
1253 static int
1254 get_info_for_key_operation (struct agent_card_info_s *info)
1255 {
1256   int rc;
1257
1258   memset (info, 0, sizeof *info);
1259   rc = agent_scd_getattr ("SERIALNO", info);
1260   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1261       || strlen (info->serialno) != 32 )
1262     {
1263       log_error (_("key operation not possible: %s\n"),
1264                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1265       return rc? rc: -1;
1266     }
1267   rc = agent_scd_getattr ("KEY-FPR", info);
1268   if (!rc)
1269     rc = agent_scd_getattr ("CHV-STATUS", info);
1270   if (!rc)
1271     rc = agent_scd_getattr ("DISP-NAME", info);
1272   if (!rc)
1273     rc = agent_scd_getattr ("EXTCAP", info);
1274   if (!rc)
1275     rc = agent_scd_getattr ("KEY-ATTR", info);
1276   if (rc)
1277     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1278   return rc;
1279 }
1280
1281
1282 /* Helper for the key generation/edit functions.  */
1283 static int
1284 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1285 {
1286   int rc = 0;
1287
1288   agent_clear_pin_cache (info->serialno);
1289
1290   *forced_chv1 = !info->chv1_cached;
1291   if (*forced_chv1)
1292     { /* Switch off the forced mode so that during key generation we
1293          don't get bothered with PIN queries for each
1294          self-signature. */
1295       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1296       if (rc)
1297         {
1298           log_error ("error clearing forced signature PIN flag: %s\n",
1299                      gpg_strerror (rc));
1300           *forced_chv1 = 0;
1301         }
1302     }
1303
1304   if (!rc)
1305     {
1306       /* Check the PIN now, so that we won't get asked later for each
1307          binding signature. */
1308       rc = agent_scd_checkpin (info->serialno);
1309       if (rc)
1310         {
1311           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1312           write_sc_op_status (rc);
1313         }
1314   }
1315   return rc;
1316 }
1317
1318 /* Helper for the key generation/edit functions.  */
1319 static void
1320 restore_forced_chv1 (int *forced_chv1)
1321 {
1322   int rc;
1323
1324   if (*forced_chv1)
1325     { /* Switch back to forced state. */
1326       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1327       if (rc)
1328         {
1329           log_error ("error setting forced signature PIN flag: %s\n",
1330                      gpg_strerror (rc));
1331         }
1332     }
1333 }
1334
1335
1336 /* Helper for the key generation/edit functions.  */
1337 static void
1338 show_card_key_info (struct agent_card_info_s *info)
1339 {
1340   tty_fprintf (NULL, "Signature key ....:");
1341   print_shax_fpr (NULL, info->fpr1len? info->fpr1:NULL, info->fpr1len);
1342   tty_fprintf (NULL, "Encryption key....:");
1343   print_shax_fpr (NULL, info->fpr2len? info->fpr2:NULL, info->fpr2len);
1344   tty_fprintf (NULL, "Authentication key:");
1345   print_shax_fpr (NULL, info->fpr3len? info->fpr3:NULL, info->fpr3len);
1346   tty_printf ("\n");
1347 }
1348
1349
1350 /* Helper for the key generation/edit functions.  */
1351 static int
1352 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1353 {
1354   log_assert (keyno >= 0 && keyno <= 3);
1355
1356   if ((keyno == 1 && info->fpr1len)
1357       || (keyno == 2 && info->fpr2len)
1358       || (keyno == 3 && info->fpr3len))
1359     {
1360       tty_printf ("\n");
1361       log_info ("WARNING: such a key has already been stored on the card!\n");
1362       tty_printf ("\n");
1363       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1364                                   _("Replace existing key? (y/N) ")))
1365         return -1;
1366       return 1;
1367     }
1368   return 0;
1369 }
1370
1371
1372 static void
1373 show_keysize_warning (void)
1374 {
1375   static int shown;
1376
1377   if (shown)
1378     return;
1379   shown = 1;
1380   tty_printf
1381     (_("Note: There is no guarantee that the card supports the requested\n"
1382        "      key type or size.  If the key generation does not succeed,\n"
1383        "      please check the documentation of your card to see which\n"
1384        "      key types and sizes are supported.\n")
1385      );
1386 }
1387
1388
1389 /* Ask for the size of a card key.  NBITS is the current size
1390    configured for the card.  Returns 0 to use the default size
1391    (i.e. NBITS) or the selected size.  */
1392 static unsigned int
1393 ask_card_rsa_keysize (unsigned int nbits)
1394 {
1395   unsigned int min_nbits = 1024;
1396   unsigned int max_nbits = 4096;
1397   char *prompt, *answer;
1398   unsigned int req_nbits;
1399
1400   for (;;)
1401     {
1402       prompt = xasprintf (_("What keysize do you want? (%u) "), nbits);
1403       answer = cpr_get ("cardedit.genkeys.size", prompt);
1404       cpr_kill_prompt ();
1405       req_nbits = *answer? atoi (answer): nbits;
1406       xfree (prompt);
1407       xfree (answer);
1408
1409       if (req_nbits != nbits && (req_nbits % 32) )
1410         {
1411           req_nbits = ((req_nbits + 31) / 32) * 32;
1412           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1413         }
1414
1415       if (req_nbits == nbits)
1416         return 0;  /* Use default.  */
1417
1418       if (req_nbits < min_nbits || req_nbits > max_nbits)
1419         {
1420           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1421                       "RSA", min_nbits, max_nbits);
1422         }
1423       else
1424         return req_nbits;
1425     }
1426 }
1427
1428 /* Ask for the key attribute of a card key.  CURRENT is the current
1429    attribute configured for the card.  KEYNO is the number of the key
1430    used to select the prompt.  Returns NULL to use the default
1431    attribute or the selected attribute structure.  */
1432 static struct key_attr *
1433 ask_card_keyattr (int keyno, const struct key_attr *current)
1434 {
1435   struct key_attr *key_attr = NULL;
1436   char *answer = NULL;
1437   int algo;
1438
1439   tty_printf (_("Changing card key attribute for: "));
1440   if (keyno == 0)
1441     tty_printf (_("Signature key\n"));
1442   else if (keyno == 1)
1443     tty_printf (_("Encryption key\n"));
1444   else
1445     tty_printf (_("Authentication key\n"));
1446
1447   tty_printf (_("Please select what kind of key you want:\n"));
1448   tty_printf (_("   (%d) RSA\n"), 1 );
1449   tty_printf (_("   (%d) ECC\n"), 2 );
1450
1451   for (;;)
1452     {
1453       xfree (answer);
1454       answer = cpr_get ("cardedit.genkeys.algo", _("Your selection? "));
1455       cpr_kill_prompt ();
1456       algo = *answer? atoi (answer) : 0;
1457
1458       if (!*answer || algo == 1 || algo == 2)
1459         break;
1460       else
1461         tty_printf (_("Invalid selection.\n"));
1462     }
1463
1464   if (algo == 0)
1465     goto leave;
1466
1467   key_attr = xmalloc (sizeof (struct key_attr));
1468
1469   if (algo == 1)
1470     {
1471       unsigned int nbits, result_nbits;
1472
1473       if (current->algo == PUBKEY_ALGO_RSA)
1474         nbits = current->nbits;
1475       else
1476         nbits = 2048;
1477
1478       result_nbits = ask_card_rsa_keysize (nbits);
1479       if (result_nbits == 0)
1480         {
1481           if (current->algo == PUBKEY_ALGO_RSA)
1482             {
1483               xfree (key_attr);
1484               key_attr = NULL;
1485             }
1486           else
1487             result_nbits = nbits;
1488         }
1489
1490       if (key_attr)
1491         {
1492           key_attr->algo = PUBKEY_ALGO_RSA;
1493           key_attr->nbits = result_nbits;
1494         }
1495     }
1496   else
1497     {
1498       const char *curve;
1499       const char *oid_str;
1500
1501       if (current->algo == PUBKEY_ALGO_RSA)
1502         {
1503           if (keyno == 1)
1504             /* Encryption key */
1505             algo = PUBKEY_ALGO_ECDH;
1506           else /* Signature key or Authentication key */
1507             algo = PUBKEY_ALGO_ECDSA;
1508           curve = NULL;
1509         }
1510       else
1511         {
1512           algo = current->algo;
1513           curve = current->curve;
1514         }
1515
1516       curve = ask_curve (&algo, NULL, curve);
1517       if (curve)
1518         {
1519           key_attr->algo = algo;
1520           oid_str = openpgp_curve_to_oid (curve, NULL);
1521           key_attr->curve = openpgp_oid_to_curve (oid_str, 0);
1522         }
1523       else
1524         {
1525           xfree (key_attr);
1526           key_attr = NULL;
1527         }
1528     }
1529
1530  leave:
1531   if (key_attr)
1532     {
1533       if (key_attr->algo == PUBKEY_ALGO_RSA)
1534         tty_printf (_("The card will now be re-configured"
1535                       " to generate a key of %u bits\n"), key_attr->nbits);
1536       else if (key_attr->algo == PUBKEY_ALGO_ECDH
1537                || key_attr->algo == PUBKEY_ALGO_ECDSA
1538                || key_attr->algo == PUBKEY_ALGO_EDDSA)
1539         tty_printf (_("The card will now be re-configured"
1540                       " to generate a key of type: %s\n"), key_attr->curve),
1541
1542       show_keysize_warning ();
1543     }
1544
1545   return key_attr;
1546 }
1547
1548
1549
1550 /* Change the key attribute of key KEYNO (0..2) and show an error
1551  * message if that fails.  */
1552 static gpg_error_t
1553 do_change_keyattr (int keyno, const struct key_attr *key_attr)
1554 {
1555   gpg_error_t err = 0;
1556   char args[100];
1557
1558   if (key_attr->algo == PUBKEY_ALGO_RSA)
1559     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
1560               key_attr->nbits);
1561   else if (key_attr->algo == PUBKEY_ALGO_ECDH
1562            || key_attr->algo == PUBKEY_ALGO_ECDSA
1563            || key_attr->algo == PUBKEY_ALGO_EDDSA)
1564     snprintf (args, sizeof args, "--force %d %d %s",
1565               keyno+1, key_attr->algo, key_attr->curve);
1566   else
1567     {
1568       log_error (_("public key algorithm %d (%s) is not supported\n"),
1569                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
1570       return gpg_error (GPG_ERR_PUBKEY_ALGO);
1571     }
1572
1573   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1574   if (err)
1575     log_error (_("error changing key attribute for key %d: %s\n"),
1576                keyno+1, gpg_strerror (err));
1577   return err;
1578 }
1579
1580
1581 static void
1582 key_attr (void)
1583 {
1584   struct agent_card_info_s info;
1585   gpg_error_t err;
1586   int keyno;
1587
1588   err = get_info_for_key_operation (&info);
1589   if (err)
1590     {
1591       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
1592       return;
1593     }
1594
1595   if (!(info.is_v2 && info.extcap.aac))
1596     {
1597       log_error (_("This command is not supported by this card\n"));
1598       goto leave;
1599     }
1600
1601   for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1602     {
1603       struct key_attr *key_attr;
1604
1605       if ((key_attr = ask_card_keyattr (keyno, &info.key_attr[keyno])))
1606         {
1607           err = do_change_keyattr (keyno, key_attr);
1608           xfree (key_attr);
1609           if (err)
1610             {
1611               /* Error: Better read the default key attribute again.  */
1612               agent_release_card_info (&info);
1613               if (get_info_for_key_operation (&info))
1614                 goto leave;
1615               /* Ask again for this key. */
1616               keyno--;
1617             }
1618         }
1619     }
1620
1621  leave:
1622   agent_release_card_info (&info);
1623 }
1624
1625
1626 static void
1627 generate_card_keys (ctrl_t ctrl)
1628 {
1629   struct agent_card_info_s info;
1630   int forced_chv1;
1631   int want_backup;
1632
1633   if (get_info_for_key_operation (&info))
1634     return;
1635
1636   if (info.extcap.ki)
1637     {
1638       char *answer;
1639
1640       /* FIXME: Should be something like cpr_get_bool so that a status
1641          GET_BOOL will be emitted.  */
1642       answer = cpr_get ("cardedit.genkeys.backup_enc",
1643                         _("Make off-card backup of encryption key? (Y/n) "));
1644
1645       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1646       cpr_kill_prompt ();
1647       xfree (answer);
1648     }
1649   else
1650     want_backup = 0;
1651
1652   if ( (info.fpr1len && !fpr_is_zero (info.fpr1, info.fpr1len))
1653        || (info.fpr2len && !fpr_is_zero (info.fpr2, info.fpr2len))
1654        || (info.fpr3len && !fpr_is_zero (info.fpr3, info.fpr3len)))
1655     {
1656       tty_printf ("\n");
1657       log_info (_("Note: keys are already stored on the card!\n"));
1658       tty_printf ("\n");
1659       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1660                                    _("Replace existing keys? (y/N) ")))
1661         {
1662           agent_release_card_info (&info);
1663           return;
1664         }
1665     }
1666
1667   /* If no displayed name has been set, we assume that this is a fresh
1668      card and print a hint about the default PINs.  */
1669   if (!info.disp_name || !*info.disp_name)
1670     {
1671       tty_printf ("\n");
1672       tty_printf (_("Please note that the factory settings of the PINs are\n"
1673                     "   PIN = '%s'     Admin PIN = '%s'\n"
1674                     "You should change them using the command --change-pin\n"),
1675                   "123456", "12345678");
1676       tty_printf ("\n");
1677     }
1678
1679
1680   if (check_pin_for_key_operation (&info, &forced_chv1))
1681     goto leave;
1682
1683   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1684
1685  leave:
1686   agent_release_card_info (&info);
1687   restore_forced_chv1 (&forced_chv1);
1688 }
1689
1690
1691 /* This function is used by the key edit menu to generate an arbitrary
1692    subkey. */
1693 gpg_error_t
1694 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1695 {
1696   gpg_error_t err;
1697   struct agent_card_info_s info;
1698   int forced_chv1 = 0;
1699   int keyno;
1700
1701   err = get_info_for_key_operation (&info);
1702   if (err)
1703     return err;
1704
1705   show_card_key_info (&info);
1706
1707   tty_printf (_("Please select the type of key to generate:\n"));
1708
1709   tty_printf (_("   (1) Signature key\n"));
1710   tty_printf (_("   (2) Encryption key\n"));
1711   tty_printf (_("   (3) Authentication key\n"));
1712
1713   for (;;)
1714     {
1715       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1716                               _("Your selection? "));
1717       cpr_kill_prompt();
1718       if (*answer == CONTROL_D)
1719         {
1720           xfree (answer);
1721           err = gpg_error (GPG_ERR_CANCELED);
1722           goto leave;
1723         }
1724       keyno = *answer? atoi(answer): 0;
1725       xfree(answer);
1726       if (keyno >= 1 && keyno <= 3)
1727         break; /* Okay. */
1728       tty_printf(_("Invalid selection.\n"));
1729     }
1730
1731   if (replace_existing_key_p (&info, keyno) < 0)
1732     {
1733       err = gpg_error (GPG_ERR_CANCELED);
1734       goto leave;
1735     }
1736
1737   err = check_pin_for_key_operation (&info, &forced_chv1);
1738   if (err)
1739     goto leave;
1740
1741   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1742
1743  leave:
1744   agent_release_card_info (&info);
1745   restore_forced_chv1 (&forced_chv1);
1746   return err;
1747 }
1748
1749
1750 /* Store the key at NODE into the smartcard and modify NODE to
1751    carry the serialno stuff instead of the actual secret key
1752    parameters.  USE is the usage for that key; 0 means any
1753    usage. */
1754 int
1755 card_store_subkey (KBNODE node, int use)
1756 {
1757   struct agent_card_info_s info;
1758   int okay = 0;
1759   unsigned int nbits;
1760   int allow_keyno[3];
1761   int  keyno;
1762   PKT_public_key *pk;
1763   gpg_error_t err;
1764   char *hexgrip;
1765   int rc;
1766   gnupg_isotime_t timebuf;
1767
1768   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1769               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1770
1771   pk = node->pkt->pkt.public_key;
1772
1773   if (get_info_for_key_operation (&info))
1774     return 0;
1775
1776   if (!info.extcap.ki)
1777     {
1778       tty_printf ("The card does not support the import of keys\n");
1779       tty_printf ("\n");
1780       goto leave;
1781     }
1782
1783   nbits = nbits_from_pk (pk);
1784
1785   if (!info.is_v2 && nbits != 1024)
1786     {
1787       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1788       tty_printf ("\n");
1789       goto leave;
1790     }
1791
1792   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1793   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1794   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1795
1796   tty_printf (_("Please select where to store the key:\n"));
1797
1798   if (allow_keyno[0])
1799     tty_printf (_("   (1) Signature key\n"));
1800   if (allow_keyno[1])
1801     tty_printf (_("   (2) Encryption key\n"));
1802   if (allow_keyno[2])
1803     tty_printf (_("   (3) Authentication key\n"));
1804
1805   for (;;)
1806     {
1807       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1808                               _("Your selection? "));
1809       cpr_kill_prompt();
1810       if (*answer == CONTROL_D || !*answer)
1811         {
1812           xfree (answer);
1813           goto leave;
1814         }
1815       keyno = *answer? atoi(answer): 0;
1816       xfree(answer);
1817       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1818         {
1819           if (info.is_v2 && !info.extcap.aac
1820               && info.key_attr[keyno-1].nbits != nbits)
1821             {
1822               tty_printf ("Key does not match the card's capability.\n");
1823             }
1824           else
1825             break; /* Okay. */
1826         }
1827       else
1828         tty_printf(_("Invalid selection.\n"));
1829     }
1830
1831   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1832     goto leave;
1833
1834   err = hexkeygrip_from_pk (pk, &hexgrip);
1835   if (err)
1836     goto leave;
1837
1838   epoch2isotime (timebuf, (time_t)pk->timestamp);
1839   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1840
1841   if (rc)
1842     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1843   else
1844     okay = 1;
1845   xfree (hexgrip);
1846
1847  leave:
1848   agent_release_card_info (&info);
1849   return okay;
1850 }
1851
1852
1853
1854 /* Direct sending of an hex encoded APDU with error printing.  */
1855 static gpg_error_t
1856 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1857 {
1858   gpg_error_t err;
1859   unsigned int sw;
1860
1861   err = agent_scd_apdu (hexapdu, &sw);
1862   if (err)
1863     tty_printf ("sending card command %s failed: %s\n", desc,
1864                 gpg_strerror (err));
1865   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1866     ;
1867   else if (ignore == 0xffff)
1868     ; /* Ignore all status words.  */
1869   else if (sw != 0x9000)
1870     {
1871       switch (sw)
1872         {
1873         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1874         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1875         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1876         default: err = gpg_error (GPG_ERR_CARD);
1877         }
1878       if (!(ignore && ignore == sw))
1879         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1880                     gpg_strerror (err),  sw);
1881     }
1882   return err;
1883 }
1884
1885
1886 /* Do a factory reset after confirmation.  */
1887 static void
1888 factory_reset (void)
1889 {
1890   struct agent_card_info_s info;
1891   gpg_error_t err;
1892   char *answer = NULL;
1893   int termstate = 0;
1894   int i;
1895
1896   /*  The code below basically does the same what this
1897       gpg-connect-agent script does:
1898
1899         scd reset
1900         scd serialno undefined
1901         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1902         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1903         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1904         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1905         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1906         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1907         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1908         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1909         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1910         scd apdu 00 e6 00 00
1911         scd apdu 00 44 00 00
1912         scd reset
1913         /echo Card has been reset to factory defaults
1914
1915       but tries to find out something about the card first.
1916    */
1917
1918   err = agent_scd_learn (&info, 0);
1919   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1920       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1921     termstate = 1;
1922   else if (err)
1923     {
1924       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1925       goto leave;
1926     }
1927
1928   if (!termstate)
1929     {
1930       log_info (_("OpenPGP card no. %s detected\n"),
1931                 info.serialno? info.serialno : "[none]");
1932       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1933         {
1934           /* Note: We won't see status-indicator 3 here because it is not
1935              possible to select a card application in termination state.  */
1936           log_error (_("This command is not supported by this card\n"));
1937           goto leave;
1938         }
1939
1940       tty_printf ("\n");
1941       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1942       tty_printf ("\n");
1943       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1944                                   _("Continue? (y/N) ")))
1945         goto leave;
1946
1947
1948       answer = cpr_get ("cardedit.factory-reset.really",
1949                         _("Really do a factory reset? (enter \"yes\") "));
1950       cpr_kill_prompt ();
1951       trim_spaces (answer);
1952       if (strcmp (answer, "yes"))
1953         goto leave;
1954
1955       /* We need to select a card application before we can send APDUs
1956          to the card without scdaemon doing anything on its own.  */
1957       err = send_apdu (NULL, "RESET", 0);
1958       if (err)
1959         goto leave;
1960       err = send_apdu ("undefined", "dummy select ", 0);
1961       if (err)
1962         goto leave;
1963
1964       /* Select the OpenPGP application.  */
1965       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1966       if (err)
1967         goto leave;
1968
1969       /* Do some dummy verifies with wrong PINs to set the retry
1970          counter to zero.  We can't easily use the card version 2.1
1971          feature of presenting the admin PIN to allow the terminate
1972          command because there is no machinery in scdaemon to catch
1973          the verify command and ask for the PIN when the "APDU"
1974          command is used. */
1975       /* Here, the length of dummy wrong PIN is 32-byte, also
1976          supporting authentication with KDF DO.  */
1977       for (i=0; i < 4; i++)
1978         send_apdu ("0020008120"
1979                    "40404040404040404040404040404040"
1980                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1981       for (i=0; i < 4; i++)
1982         send_apdu ("0020008320"
1983                    "40404040404040404040404040404040"
1984                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1985
1986       /* Send terminate datafile command.  */
1987       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1988       if (err)
1989         goto leave;
1990     }
1991
1992   /* Send activate datafile command.  This is used without
1993      confirmation if the card is already in termination state.  */
1994   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1995   if (err)
1996     goto leave;
1997
1998   /* Finally we reset the card reader once more.  */
1999   err = send_apdu (NULL, "RESET", 0);
2000
2001   /* Then, connect the card again.  */
2002   if (!err)
2003     {
2004       char *serialno0;
2005
2006       err = agent_scd_serialno (&serialno0, NULL);
2007       if (!err)
2008         xfree (serialno0);
2009     }
2010
2011  leave:
2012   xfree (answer);
2013   agent_release_card_info (&info);
2014 }
2015
2016
2017 #define USER_PIN_DEFAULT "123456"
2018 #define ADMIN_PIN_DEFAULT "12345678"
2019 #define KDF_DATA_LENGTH_MIN  90
2020 #define KDF_DATA_LENGTH_MAX 110
2021
2022 /* Generate KDF data.  */
2023 static gpg_error_t
2024 gen_kdf_data (unsigned char *data, int single_salt)
2025 {
2026   const unsigned char h0[] = { 0x81, 0x01, 0x03,
2027                                0x82, 0x01, 0x08,
2028                                0x83, 0x04 };
2029   const unsigned char h1[] = { 0x84, 0x08 };
2030   const unsigned char h2[] = { 0x85, 0x08 };
2031   const unsigned char h3[] = { 0x86, 0x08 };
2032   const unsigned char h4[] = { 0x87, 0x20 };
2033   const unsigned char h5[] = { 0x88, 0x20 };
2034   unsigned char *p, *salt_user, *salt_admin;
2035   unsigned char s2k_char;
2036   unsigned int iterations;
2037   unsigned char count_4byte[4];
2038   gpg_error_t err = 0;
2039
2040   p = data;
2041
2042   s2k_char = encode_s2k_iterations (0);
2043   iterations = S2K_DECODE_COUNT (s2k_char);
2044   count_4byte[0] = (iterations >> 24) & 0xff;
2045   count_4byte[1] = (iterations >> 16) & 0xff;
2046   count_4byte[2] = (iterations >>  8) & 0xff;
2047   count_4byte[3] = (iterations & 0xff);
2048
2049   memcpy (p, h0, sizeof h0);
2050   p += sizeof h0;
2051   memcpy (p, count_4byte, sizeof count_4byte);
2052   p += sizeof count_4byte;
2053   memcpy (p, h1, sizeof h1);
2054   salt_user = (p += sizeof h1);
2055   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2056   p += 8;
2057
2058   if (single_salt)
2059     salt_admin = salt_user;
2060   else
2061     {
2062       memcpy (p, h2, sizeof h2);
2063       p += sizeof h2;
2064       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2065       p += 8;
2066       memcpy (p, h3, sizeof h3);
2067       salt_admin = (p += sizeof h3);
2068       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2069       p += 8;
2070     }
2071
2072   memcpy (p, h4, sizeof h4);
2073   p += sizeof h4;
2074   err = gcry_kdf_derive (USER_PIN_DEFAULT, strlen (USER_PIN_DEFAULT),
2075                          GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
2076                          salt_user, 8, iterations, 32, p);
2077   p += 32;
2078   if (!err)
2079     {
2080       memcpy (p, h5, sizeof h5);
2081       p += sizeof h5;
2082       err = gcry_kdf_derive (ADMIN_PIN_DEFAULT, strlen (ADMIN_PIN_DEFAULT),
2083                              GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
2084                              salt_admin, 8, iterations, 32, p);
2085     }
2086
2087   return err;
2088 }
2089
2090 /* Setup KDF data object which is used for PIN authentication.  */
2091 static void
2092 kdf_setup (const char *args)
2093 {
2094   struct agent_card_info_s info;
2095   gpg_error_t err;
2096   unsigned char kdf_data[KDF_DATA_LENGTH_MAX];
2097   int single = (*args != 0);
2098
2099   memset (&info, 0, sizeof info);
2100
2101   err = agent_scd_getattr ("EXTCAP", &info);
2102   if (err)
2103     {
2104       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
2105       return;
2106     }
2107
2108   if (!info.extcap.kdf)
2109     {
2110       log_error (_("This command is not supported by this card\n"));
2111       goto leave;
2112     }
2113
2114   err = gen_kdf_data (kdf_data, single);
2115   if (err)
2116     goto leave_error;
2117
2118   err = agent_scd_setattr ("KDF", kdf_data,
2119                            single ? KDF_DATA_LENGTH_MIN : KDF_DATA_LENGTH_MAX,
2120                            NULL);
2121   if (err)
2122     goto leave_error;
2123
2124   err = agent_scd_getattr ("KDF", &info);
2125
2126  leave_error:
2127   if (err)
2128     log_error (_("error for setup KDF: %s\n"), gpg_strerror (err));
2129
2130  leave:
2131   agent_release_card_info (&info);
2132 }
2133
2134 static void
2135 uif (int arg_number, const char *arg_rest)
2136 {
2137   struct agent_card_info_s info;
2138   int feature_available;
2139   gpg_error_t err;
2140   char name[100];
2141   unsigned char data[2];
2142
2143   memset (&info, 0, sizeof info);
2144
2145   err = agent_scd_getattr ("EXTCAP", &info);
2146   if (err)
2147     {
2148       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
2149       return;
2150     }
2151
2152   feature_available = info.extcap.bt;
2153   agent_release_card_info (&info);
2154
2155   if (!feature_available)
2156     {
2157       log_error (_("This command is not supported by this card\n"));
2158       tty_printf ("\n");
2159       return;
2160     }
2161
2162   snprintf (name, sizeof name, "UIF-%d", arg_number);
2163   if ( !strcmp (arg_rest, "off") )
2164     data[0] = 0x00;
2165   else if ( !strcmp (arg_rest, "on") )
2166     data[0] = 0x01;
2167   else if ( !strcmp (arg_rest, "permanent") )
2168     data[0] = 0x02;
2169
2170   data[1] = 0x20;
2171
2172   err = agent_scd_setattr (name, data, 2, NULL);
2173   if (err)
2174     log_error (_("error for setup UIF: %s\n"), gpg_strerror (err));
2175 }
2176 \f
2177 /* Data used by the command parser.  This needs to be outside of the
2178    function scope to allow readline based command completion.  */
2179 enum cmdids
2180   {
2181     cmdNOP = 0,
2182     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
2183     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
2184     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2185     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2186     cmdKEYATTR, cmdUIF,
2187     cmdINVCMD
2188   };
2189
2190 static struct
2191 {
2192   const char *name;
2193   enum cmdids id;
2194   int admin_only;
2195   const char *desc;
2196 } cmds[] =
2197   {
2198     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2199     { "q"       , cmdQUIT  , 0, NULL },
2200     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2201     { "help"    , cmdHELP  , 0, N_("show this help")},
2202     { "?"       , cmdHELP  , 0, NULL },
2203     { "list"    , cmdLIST  , 0, N_("list all available data")},
2204     { "l"       , cmdLIST  , 0, NULL },
2205     { "debug"   , cmdDEBUG , 0, NULL },
2206     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2207     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2208     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2209     { "login"   , cmdLOGIN , 1, N_("change the login name")},
2210     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2211     { "salutation",cmdSEX  , 1, N_("change card holder's salutation")},
2212     { "sex"       ,cmdSEX  , 1, NULL },  /* Backward compatibility.  */
2213     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2214     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2215     { "generate", cmdGENERATE, 1, N_("generate new keys")},
2216     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2217     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2218     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
2219     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2220     { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2221     { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2222     { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
2223     /* Note, that we do not announce these command yet. */
2224     { "privatedo", cmdPRIVATEDO, 0, NULL },
2225     { "readcert", cmdREADCERT, 0, NULL },
2226     { "writecert", cmdWRITECERT, 1, NULL },
2227     { NULL, cmdINVCMD, 0, NULL }
2228   };
2229
2230
2231 #ifdef HAVE_LIBREADLINE
2232
2233 /* These two functions are used by readline for command completion. */
2234
2235 static char *
2236 command_generator(const char *text,int state)
2237 {
2238   static int list_index,len;
2239   const char *name;
2240
2241   /* If this is a new word to complete, initialize now.  This includes
2242      saving the length of TEXT for efficiency, and initializing the
2243      index variable to 0. */
2244   if(!state)
2245     {
2246       list_index=0;
2247       len=strlen(text);
2248     }
2249
2250   /* Return the next partial match */
2251   while((name=cmds[list_index].name))
2252     {
2253       /* Only complete commands that have help text */
2254       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
2255         return strdup(name);
2256     }
2257
2258   return NULL;
2259 }
2260
2261 static char **
2262 card_edit_completion(const char *text, int start, int end)
2263 {
2264   (void)end;
2265   /* If we are at the start of a line, we try and command-complete.
2266      If not, just do nothing for now. */
2267
2268   if(start==0)
2269     return rl_completion_matches(text,command_generator);
2270
2271   rl_attempted_completion_over=1;
2272
2273   return NULL;
2274 }
2275 #endif /*HAVE_LIBREADLINE*/
2276
2277 /* Menu to edit all user changeable values on an OpenPGP card.  Only
2278    Key creation is not handled here. */
2279 void
2280 card_edit (ctrl_t ctrl, strlist_t commands)
2281 {
2282   enum cmdids cmd = cmdNOP;
2283   int have_commands = !!commands;
2284   int redisplay = 1;
2285   char *answer = NULL;
2286   int allow_admin=0;
2287   char serialnobuf[50];
2288
2289
2290   if (opt.command_fd != -1)
2291     ;
2292   else if (opt.batch && !have_commands)
2293     {
2294       log_error(_("can't do this in batch mode\n"));
2295       goto leave;
2296     }
2297
2298   for (;;)
2299     {
2300       int arg_number;
2301       const char *arg_string = "";
2302       const char *arg_rest = "";
2303       char *p;
2304       int i;
2305       int cmd_admin_only;
2306
2307       tty_printf("\n");
2308       if (redisplay)
2309         {
2310           if (opt.with_colons)
2311             {
2312               current_card_status (ctrl, es_stdout,
2313                                    serialnobuf, DIM (serialnobuf));
2314               fflush (stdout);
2315             }
2316           else
2317             {
2318               current_card_status (ctrl, NULL,
2319                                    serialnobuf, DIM (serialnobuf));
2320               tty_printf("\n");
2321             }
2322           redisplay = 0;
2323         }
2324
2325       do
2326         {
2327           xfree (answer);
2328           if (have_commands)
2329             {
2330               if (commands)
2331                 {
2332                   answer = xstrdup (commands->d);
2333                   commands = commands->next;
2334                 }
2335               else if (opt.batch)
2336                 {
2337                   answer = xstrdup ("quit");
2338                 }
2339               else
2340                 have_commands = 0;
2341             }
2342
2343             if (!have_commands)
2344               {
2345                 tty_enable_completion (card_edit_completion);
2346                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2347                 cpr_kill_prompt();
2348                 tty_disable_completion ();
2349               }
2350             trim_spaces(answer);
2351         }
2352       while ( *answer == '#' );
2353
2354       arg_number = 0; /* Yes, here is the init which egcc complains about */
2355       cmd_admin_only = 0;
2356       if (!*answer)
2357         cmd = cmdLIST; /* Default to the list command */
2358       else if (*answer == CONTROL_D)
2359         cmd = cmdQUIT;
2360       else
2361         {
2362           if ((p=strchr (answer,' ')))
2363             {
2364               *p++ = 0;
2365               trim_spaces (answer);
2366               trim_spaces (p);
2367               arg_number = atoi(p);
2368               arg_string = p;
2369               arg_rest = p;
2370               while (digitp (arg_rest))
2371                 arg_rest++;
2372               while (spacep (arg_rest))
2373                 arg_rest++;
2374             }
2375
2376           for (i=0; cmds[i].name; i++ )
2377             if (!ascii_strcasecmp (answer, cmds[i].name ))
2378               break;
2379
2380           cmd = cmds[i].id;
2381           cmd_admin_only = cmds[i].admin_only;
2382         }
2383
2384       if (!allow_admin && cmd_admin_only)
2385         {
2386           tty_printf ("\n");
2387           tty_printf (_("Admin-only command\n"));
2388           continue;
2389         }
2390
2391       switch (cmd)
2392         {
2393         case cmdHELP:
2394           for (i=0; cmds[i].name; i++ )
2395             if(cmds[i].desc
2396                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2397               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2398           break;
2399
2400         case cmdADMIN:
2401           if ( !strcmp (arg_string, "on") )
2402             allow_admin = 1;
2403           else if ( !strcmp (arg_string, "off") )
2404             allow_admin = 0;
2405           else if ( !strcmp (arg_string, "verify") )
2406             {
2407               /* Force verification of the Admin Command.  However,
2408                  this is only done if the retry counter is at initial
2409                  state.  */
2410               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2411               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2412               allow_admin = !agent_scd_checkpin (tmp);
2413               xfree (tmp);
2414             }
2415           else /* Toggle. */
2416             allow_admin=!allow_admin;
2417           if(allow_admin)
2418             tty_printf(_("Admin commands are allowed\n"));
2419           else
2420             tty_printf(_("Admin commands are not allowed\n"));
2421           break;
2422
2423         case cmdVERIFY:
2424           agent_scd_checkpin (serialnobuf);
2425           redisplay = 1;
2426           break;
2427
2428         case cmdLIST:
2429           redisplay = 1;
2430           break;
2431
2432         case cmdNAME:
2433           change_name ();
2434           break;
2435
2436         case cmdURL:
2437           change_url ();
2438           break;
2439
2440         case cmdFETCH:
2441           fetch_url (ctrl);
2442           break;
2443
2444         case cmdLOGIN:
2445           change_login (arg_string);
2446           break;
2447
2448         case cmdLANG:
2449           change_lang ();
2450           break;
2451
2452         case cmdSEX:
2453           change_sex ();
2454           break;
2455
2456         case cmdCAFPR:
2457           if ( arg_number < 1 || arg_number > 3 )
2458             tty_printf ("usage: cafpr N\n"
2459                         "       1 <= N <= 3\n");
2460           else
2461             change_cafpr (arg_number);
2462           break;
2463
2464         case cmdPRIVATEDO:
2465           if ( arg_number < 1 || arg_number > 4 )
2466             tty_printf ("usage: privatedo N\n"
2467                         "       1 <= N <= 4\n");
2468           else
2469             change_private_do (arg_string, arg_number);
2470           break;
2471
2472         case cmdWRITECERT:
2473           if ( arg_number != 3 )
2474             tty_printf ("usage: writecert 3 < FILE\n");
2475           else
2476             change_cert (arg_rest);
2477           break;
2478
2479         case cmdREADCERT:
2480           if ( arg_number != 3 )
2481             tty_printf ("usage: readcert 3 > FILE\n");
2482           else
2483             read_cert (arg_rest);
2484           break;
2485
2486         case cmdFORCESIG:
2487           toggle_forcesig ();
2488           break;
2489
2490         case cmdGENERATE:
2491           generate_card_keys (ctrl);
2492           break;
2493
2494         case cmdPASSWD:
2495           change_pin (0, allow_admin);
2496           break;
2497
2498         case cmdUNBLOCK:
2499           change_pin (1, allow_admin);
2500           break;
2501
2502         case cmdFACTORYRESET:
2503           factory_reset ();
2504           break;
2505
2506         case cmdKDFSETUP:
2507           kdf_setup (arg_string);
2508           break;
2509
2510         case cmdKEYATTR:
2511           key_attr ();
2512           break;
2513
2514         case cmdUIF:
2515           if ( arg_number < 1 || arg_number > 3 )
2516             tty_printf ("usage: uif N [on|off|permanent]\n"
2517                         "       1 <= N <= 3\n");
2518           else
2519             uif (arg_number, arg_rest);
2520           break;
2521
2522         case cmdQUIT:
2523           goto leave;
2524
2525         case cmdNOP:
2526           break;
2527
2528         case cmdINVCMD:
2529         default:
2530           tty_printf ("\n");
2531           tty_printf (_("Invalid command  (try \"help\")\n"));
2532           break;
2533         } /* End command switch. */
2534     } /* End of main menu loop. */
2535
2536  leave:
2537   xfree (answer);
2538 }