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