card: Make printing of key information more flexible.
[gnupg.git] / tools / gpg-card-tool.c
1 /* gpg-card-tool.c - An interactive tool to work with cards.
2  * Copyright (C) 2019 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * This file is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This file is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://gnu.org/licenses/>.
18  * SPDX-License-Identifier: GPL-3.0-or-later
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #ifdef HAVE_LIBREADLINE
26 # define GNUPG_LIBREADLINE_H_INCLUDED
27 # include <readline/readline.h>
28 #endif /*HAVE_LIBREADLINE*/
29
30 #include "../common/util.h"
31 #include "../common/status.h"
32 #include "../common/i18n.h"
33 #include "../common/init.h"
34 #include "../common/sysutils.h"
35 #include "../common/asshelp.h"
36 #include "../common/userids.h"
37 #include "../common/ccparray.h"
38 #include "../common/exectool.h"
39 #include "../common/ttyio.h"
40 #include "../common/server-help.h"
41 #include "../common/openpgpdefs.h"
42
43 #include "card-tool.h"
44
45
46 #define CONTROL_D ('D' - 'A' + 1)
47
48 /* Constants to identify the commands and options. */
49 enum cmd_and_opt_values
50   {
51     aNull = 0,
52
53     oQuiet      = 'q',
54     oVerbose    = 'v',
55
56     oDebug      = 500,
57
58     oGpgProgram,
59     oGpgsmProgram,
60     oStatusFD,
61     oWithColons,
62     oNoAutostart,
63     oAgentProgram,
64
65     oDisplay,
66     oTTYname,
67     oTTYtype,
68     oXauthority,
69     oLCctype,
70     oLCmessages,
71
72     oDummy
73   };
74
75
76 /* The list of commands and options. */
77 static ARGPARSE_OPTS opts[] = {
78   ARGPARSE_group (300, ("@Commands:\n ")),
79
80   ARGPARSE_group (301, ("@\nOptions:\n ")),
81
82   ARGPARSE_s_n (oVerbose, "verbose", ("verbose")),
83   ARGPARSE_s_n (oQuiet, "quiet",  ("be somewhat more quiet")),
84   ARGPARSE_s_s (oDebug, "debug", "@"),
85   ARGPARSE_s_s (oGpgProgram, "gpg", "@"),
86   ARGPARSE_s_s (oGpgsmProgram, "gpgsm", "@"),
87   ARGPARSE_s_i (oStatusFD, "status-fd", N_("|FD|write status info to this FD")),
88   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
89   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
90   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
91   ARGPARSE_s_s (oDisplay,    "display",    "@"),
92   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
93   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
94   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
95   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
96   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
97
98   ARGPARSE_end ()
99 };
100
101 /* The list of supported debug flags.  */
102 static struct debug_flags_s debug_flags [] =
103   {
104     { DBG_IPC_VALUE    , "ipc"     },
105     { DBG_EXTPROG_VALUE, "extprog" },
106     { 0, NULL }
107   };
108
109
110 /* An object to create lists of labels and keyrefs.  */
111 struct keyinfolabel_s
112 {
113   const char *label;
114   const char *keyref;
115 };
116 typedef struct keyinfolabel_s *keyinfolabel_t;
117
118
119 /* Limit of size of data we read from a file for certain commands.  */
120 #define MAX_GET_DATA_FROM_FILE 16384
121
122 /* Constants for OpenPGP cards.  */
123 #define OPENPGP_USER_PIN_DEFAULT  "123456"
124 #define OPENPGP_ADMIN_PIN_DEFAULT "12345678"
125 #define OPENPGP_KDF_DATA_LENGTH_MIN  90
126 #define OPENPGP_KDF_DATA_LENGTH_MAX 110
127
128
129
130
131 /* Local prototypes.  */
132 static void wrong_args (const char *text) GPGRT_ATTR_NORETURN;
133 static void interactive_loop (void);
134 #ifdef HAVE_LIBREADLINE
135 static char **command_completion (const char *text, int start, int end);
136 #endif /*HAVE_LIBREADLINE*/
137
138
139 \f
140 /* Print usage information and provide strings for help. */
141 static const char *
142 my_strusage( int level )
143 {
144   const char *p;
145
146   switch (level)
147     {
148     case 11: p = "gpg-card-tool"; break;
149     case 12: p = "@GNUPG@"; break;
150     case 13: p = VERSION; break;
151     case 17: p = PRINTABLE_OS_NAME; break;
152     case 19: p = ("Please report bugs to <@EMAIL@>.\n"); break;
153
154     case 1:
155     case 40:
156       p = ("Usage: gpg-card-tool [command] [options] [args] (-h for help)");
157       break;
158     case 41:
159       p = ("Syntax: gpg-card-tool [command] [options] [args]\n"
160            "Tool to configure cards and tokens\n");
161       break;
162
163     default: p = NULL; break;
164     }
165   return p;
166 }
167
168
169 static void
170 wrong_args (const char *text)
171 {
172   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), strusage (11), text);
173   exit (2);
174 }
175
176
177 static void
178 set_opt_session_env (const char *name, const char *value)
179 {
180   gpg_error_t err;
181
182   err = session_env_setenv (opt.session_env, name, value);
183   if (err)
184     log_fatal ("error setting session environment: %s\n",
185                gpg_strerror (err));
186 }
187
188
189 \f
190 /* Command line parsing.  */
191 static enum cmd_and_opt_values
192 parse_arguments (ARGPARSE_ARGS *pargs, ARGPARSE_OPTS *popts)
193 {
194   enum cmd_and_opt_values cmd = 0;
195   int no_more_options = 0;
196
197   while (!no_more_options && optfile_parse (NULL, NULL, NULL, pargs, popts))
198     {
199       switch (pargs->r_opt)
200         {
201         case oQuiet:     opt.quiet = 1; break;
202         case oVerbose:   opt.verbose++; break;
203         case oDebug:
204           if (parse_debug_flag (pargs->r.ret_str, &opt.debug, debug_flags))
205             {
206               pargs->r_opt = ARGPARSE_INVALID_ARG;
207               pargs->err = ARGPARSE_PRINT_ERROR;
208             }
209           break;
210
211         case oGpgProgram:   opt.gpg_program = pargs->r.ret_str; break;
212         case oGpgsmProgram: opt.gpgsm_program = pargs->r.ret_str; break;
213         case oAgentProgram: opt.agent_program = pargs->r.ret_str; break;
214
215         case oStatusFD:
216           gnupg_set_status_fd (translate_sys2libc_fd_int (pargs->r.ret_int, 1));
217           break;
218
219         case oWithColons:  opt.with_colons = 1; break;
220         case oNoAutostart: opt.autostart = 0; break;
221
222         case oDisplay: set_opt_session_env ("DISPLAY", pargs->r.ret_str); break;
223         case oTTYname: set_opt_session_env ("GPG_TTY", pargs->r.ret_str); break;
224         case oTTYtype: set_opt_session_env ("TERM", pargs->r.ret_str); break;
225         case oXauthority: set_opt_session_env ("XAUTHORITY",
226                                                pargs->r.ret_str); break;
227         case oLCctype:     opt.lc_ctype = pargs->r.ret_str; break;
228         case oLCmessages:  opt.lc_messages = pargs->r.ret_str; break;
229
230         default: pargs->err = 2; break;
231         }
232     }
233
234   return cmd;
235 }
236
237
238 \f
239 /* gpg-card-tool main. */
240 int
241 main (int argc, char **argv)
242 {
243   gpg_error_t err;
244   ARGPARSE_ARGS pargs;
245   enum cmd_and_opt_values cmd;
246
247   gnupg_reopen_std ("gpg-card-tool");
248   set_strusage (my_strusage);
249   gnupg_rl_initialize ();
250   log_set_prefix ("gpg-card-tool", GPGRT_LOG_WITH_PREFIX);
251
252   /* Make sure that our subsystems are ready.  */
253   i18n_init();
254   init_common_subsystems (&argc, &argv);
255
256   assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
257   setup_libassuan_logging (&opt.debug, NULL);
258
259   /* Setup default options.  */
260   opt.autostart = 1;
261   opt.session_env = session_env_new ();
262   if (!opt.session_env)
263     log_fatal ("error allocating session environment block: %s\n",
264                gpg_strerror (gpg_error_from_syserror ()));
265
266
267   /* Parse the command line. */
268   pargs.argc  = &argc;
269   pargs.argv  = &argv;
270   pargs.flags = ARGPARSE_FLAG_KEEP;
271   cmd = parse_arguments (&pargs, opts);
272
273   if (log_get_errorcount (0))
274     exit (2);
275
276   /* Print a warning if an argument looks like an option.  */
277   if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
278     {
279       int i;
280
281       for (i=0; i < argc; i++)
282         if (argv[i][0] == '-' && argv[i][1] == '-')
283           log_info (("NOTE: '%s' is not considered an option\n"), argv[i]);
284     }
285
286   /* Set defaults for non given options.  */
287   if (!opt.gpg_program)
288     opt.gpg_program = gnupg_module_name (GNUPG_MODULE_NAME_GPG);
289   if (!opt.gpgsm_program)
290     opt.gpgsm_program = gnupg_module_name (GNUPG_MODULE_NAME_GPGSM);
291
292   /* Run the selected command.  */
293   switch (cmd)
294     {
295     default:
296       interactive_loop ();
297       err = 0;
298       break;
299     }
300
301   if (err)
302     gnupg_status_printf (STATUS_FAILURE, "- %u", err);
303   else if (log_get_errorcount (0))
304     gnupg_status_printf (STATUS_FAILURE, "- %u", GPG_ERR_GENERAL);
305   else
306     gnupg_status_printf (STATUS_SUCCESS, NULL);
307   return log_get_errorcount (0)? 1:0;
308 }
309
310
311 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
312  * On error return an error code and stores NULL at R_BUFFER; on
313  * success returns 0, stpres the number of bytes read at R_BUFLEN and
314  * the address of a newly allocated buffer at R_BUFFER. */
315 static gpg_error_t
316 get_data_from_file (const char *fname, char **r_buffer, size_t *r_buflen)
317 {
318   gpg_error_t err;
319   estream_t fp;
320   char *data;
321   int n;
322
323   *r_buffer = NULL;
324   *r_buflen = 0;
325
326   fp = es_fopen (fname, "rb");
327   if (!fp)
328     {
329       err = gpg_error_from_syserror ();
330       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
331       return err;
332     }
333
334   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
335   if (!data)
336     {
337       err = gpg_error_from_syserror ();
338       log_error (_("error allocating enough memory: %s\n"), gpg_strerror (err));
339       es_fclose (fp);
340       return err;
341     }
342
343   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
344   es_fclose (fp);
345   if (n < 0)
346     {
347       err = gpg_error_from_syserror ();
348       tty_printf (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
349       xfree (data);
350       return err;
351     }
352   *r_buffer = data;
353   *r_buflen = n;
354   return 0;
355 }
356
357
358 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
359  * success.  */
360 static gpg_error_t
361 put_data_to_file (const char *fname, const void *buffer, size_t length)
362 {
363   gpg_error_t err;
364   estream_t fp;
365
366   fp = es_fopen (fname, "wb");
367   if (!fp)
368     {
369       err = gpg_error_from_syserror ();
370       log_error (_("can't create '%s': %s\n"), fname, gpg_strerror (err));
371       return err;
372     }
373
374   if (length && es_fwrite (buffer, length, 1, fp) != 1)
375     {
376       err = gpg_error_from_syserror ();
377       log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
378       es_fclose (fp);
379       return err;
380     }
381   if (es_fclose (fp))
382     {
383       err = gpg_error_from_syserror ();
384       log_error (_("error writing '%s': %s\n"), fname, gpg_strerror (err));
385       return err;
386     }
387   return 0;
388 }
389
390
391 \f
392 /* Simply prints TEXT to the output.  Returns 0 as a convenience.
393  * This is a separate fucntion so that it can be extended to run
394  * less(1) or so.  The extra arguments are int values terminated by a
395  * 0 to indicate card application types supported with this command.
396  * If none are given (just teh final 0), this is a general
397  * command.  */
398 static gpg_error_t
399 print_help (const char *text, ...)
400 {
401   va_list arg_ptr;
402   int value;
403   int any = 0;
404
405   tty_fprintf (NULL, "%s\n", text);
406
407   va_start (arg_ptr, text);
408   while ((value = va_arg (arg_ptr, int)))
409     {
410       if (!any)
411         tty_fprintf (NULL, "[Supported by: ");
412       tty_fprintf (NULL, "%s%s", any?", ":"", app_type_string (value));
413       any = 1;
414     }
415   if (any)
416     tty_fprintf (NULL, "]\n");
417
418   va_end (arg_ptr);
419   return 0;
420 }
421
422
423 /* Return the OpenPGP card manufacturer name.  */
424 static const char *
425 get_manufacturer (unsigned int no)
426 {
427   /* Note:  Make sure that there is no colon or linefeed in the string. */
428   switch (no)
429     {
430     case 0x0001: return "PPC Card Systems";
431     case 0x0002: return "Prism";
432     case 0x0003: return "OpenFortress";
433     case 0x0004: return "Wewid";
434     case 0x0005: return "ZeitControl";
435     case 0x0006: return "Yubico";
436     case 0x0007: return "OpenKMS";
437     case 0x0008: return "LogoEmail";
438     case 0x0009: return "Fidesmo";
439     case 0x000A: return "Dangerous Things";
440
441     case 0x002A: return "Magrathea";
442     case 0x0042: return "GnuPG e.V.";
443
444     case 0x1337: return "Warsaw Hackerspace";
445     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
446     case 0x4354: return "Confidential Technologies";   /* cotech.de */
447     case 0x63AF: return "Trustica";
448     case 0xBD0E: return "Paranoidlabs";
449     case 0xF517: return "FSIJ";
450
451       /* 0x0000 and 0xFFFF are defined as test cards per spec,
452        * 0xFF00 to 0xFFFE are assigned for use with randomly created
453        * serial numbers.  */
454     case 0x0000:
455     case 0xffff: return "test card";
456     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
457     }
458 }
459
460 /* Print an (OpenPGP) fingerprint.  */
461 static void
462 print_shax_fpr (estream_t fp, const unsigned char *fpr, unsigned int fprlen)
463 {
464   int i;
465
466   if (fpr)
467     {
468       /* FIXME: Fix formatting for FPRLEN != 20 */
469       for (i=0; i < fprlen ; i+=2, fpr += 2 )
470         {
471           if (i == 10 )
472             tty_fprintf (fp, " ");
473           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
474         }
475     }
476   else
477     tty_fprintf (fp, " [none]");
478   tty_fprintf (fp, "\n");
479 }
480
481 /* Print the keygrip GRP.  */
482 static void
483 print_keygrip (estream_t fp, const unsigned char *grp)
484 {
485   int i;
486
487   for (i=0; i < 20 ; i++, grp++)
488     tty_fprintf (fp, "%02X", *grp);
489   tty_fprintf (fp, "\n");
490 }
491
492
493 /* Print a string but avoid printing control characters.  */
494 static void
495 print_string (estream_t fp, const char *text, const char *name)
496 {
497   tty_fprintf (fp, "%s", text);
498
499   /* FIXME: tty_printf_utf8_string2 eats everything after and
500      including an @ - e.g. when printing an url. */
501   if (name && *name)
502     {
503       if (fp)
504         print_utf8_buffer2 (fp, name, strlen (name), '\n');
505       else
506         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
507     }
508   else
509     tty_fprintf (fp, _("[not set]"));
510   tty_fprintf (fp, "\n");
511 }
512
513
514 /* Print an ISO formatted name or "[not set]".  */
515 static void
516 print_isoname (estream_t fp, const char *name)
517 {
518   if (name && *name)
519     {
520       char *p, *given, *buf;
521
522       buf = xstrdup (name);
523       given = strstr (buf, "<<");
524       for (p=buf; *p; p++)
525         if (*p == '<')
526           *p = ' ';
527       if (given && given[2])
528         {
529           *given = 0;
530           given += 2;
531           if (fp)
532             print_utf8_buffer2 (fp, given, strlen (given), '\n');
533           else
534             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
535
536           if (*buf)
537             tty_fprintf (fp, " ");
538         }
539
540       if (fp)
541         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
542       else
543         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
544
545       xfree (buf);
546     }
547   else
548     {
549       tty_fprintf (fp, _("[not set]"));
550     }
551
552   tty_fprintf (fp, "\n");
553 }
554
555
556 /* Return true if the buffer MEM of length memlen consists only of zeroes. */
557 static int
558 mem_is_zero (const char *mem, unsigned int memlen)
559 {
560   int i;
561
562   for (i=0; i < memlen && !mem[i]; i++)
563     ;
564   return (i == memlen);
565 }
566
567
568 /* Return true if the buffer MEM or length MEMLEN consists only of 0xFF. */
569 static int
570 mem_is_ff (const char *mem, unsigned int memlen)
571 {
572   int i;
573
574   for (i=0; i < memlen && mem[i] == '\xff'; i++)
575     ;
576   return (i == memlen);
577 }
578
579
580 \f
581 /* Helper to list a single keyref.  */
582 static void
583 list_one_kinfo (key_info_t kinfo, estream_t fp)
584 {
585   if (kinfo)
586     {
587       tty_fprintf (fp, " ");
588       if (mem_is_zero (kinfo->grip, sizeof kinfo->grip))
589         tty_fprintf (fp, "[none]\n");
590       else
591         print_keygrip (fp, kinfo->grip);
592
593       if (kinfo->fprlen && kinfo->created)
594         {
595           tty_fprintf (fp, "      fingerprint :");
596           print_shax_fpr (fp, kinfo->fpr, kinfo->fprlen);
597           tty_fprintf (fp, "      created ....: %s\n",
598                        isotimestamp (kinfo->created));
599         }
600     }
601   else
602     tty_fprintf (fp, " [none]\n");
603 }
604
605
606 /* List all keyinfo in INFO using the list of LABELS.  */
607 static void
608 list_all_kinfo (card_info_t info, keyinfolabel_t labels, estream_t fp)
609 {
610   key_info_t kinfo;
611   int idx, i;
612
613   /* Print the keyinfo.  We first print those we known and then all
614    * remaining item.  */
615   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
616     kinfo->xflag = 0;
617   if (labels)
618     {
619       for (idx=0; labels[idx].label; idx++)
620         {
621           tty_fprintf (fp, "%s", labels[idx].label);
622           kinfo = find_kinfo (info, labels[idx].keyref);
623           list_one_kinfo (kinfo, fp);
624           if (kinfo)
625             kinfo->xflag = 1;
626         }
627     }
628   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
629     {
630       if (kinfo->xflag)
631         continue;
632       tty_fprintf (fp, "Key %s ", kinfo->keyref);
633       for (i=5+strlen (kinfo->keyref); i < 18; i++)
634         tty_fprintf (fp, ".");
635       tty_fprintf (fp, ":");
636       list_one_kinfo (kinfo, fp);
637     }
638 }
639
640
641 /* List OpenPGP card specific data.  */
642 static void
643 list_openpgp (card_info_t info, estream_t fp)
644 {
645   static struct keyinfolabel_s keyinfolabels[] = {
646     { "Signature key ....:", "OPENPGP.1" },
647     { "Encryption key....:", "OPENPGP.2" },
648     { "Authentication key:", "OPENPGP.3" },
649     { NULL, NULL }
650   };
651   int i;
652
653   if (!info->serialno
654       || strncmp (info->serialno, "D27600012401", 12)
655       || strlen (info->serialno) != 32 )
656     {
657       tty_fprintf (fp, "invalid OpenPGP card\n");
658       return;
659     }
660
661   tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
662                info->serialno[12] == '0'?"":info->serialno+12,
663                info->serialno[13],
664                info->serialno[14] == '0'?"":info->serialno+14,
665                info->serialno[15]);
666   tty_fprintf (fp, "Manufacturer .....: %s\n",
667                get_manufacturer (xtoi_2(info->serialno+16)*256
668                                  + xtoi_2 (info->serialno+18)));
669   tty_fprintf (fp, "Name of cardholder: ");
670   print_isoname (fp, info->disp_name);
671
672   print_string (fp, "Language prefs ...: ", info->disp_lang);
673   tty_fprintf (fp, "Salutation .......: %s\n",
674                info->disp_sex == 1? _("Mr."):
675                info->disp_sex == 2? _("Mrs.") : "");
676   print_string (fp, "URL of public key : ", info->pubkey_url);
677   print_string (fp, "Login data .......: ", info->login_data);
678   if (info->private_do[0])
679     print_string (fp, "Private DO 1 .....: ", info->private_do[0]);
680   if (info->private_do[1])
681     print_string (fp, "Private DO 2 .....: ", info->private_do[1]);
682   if (info->private_do[2])
683     print_string (fp, "Private DO 3 .....: ", info->private_do[2]);
684   if (info->private_do[3])
685     print_string (fp, "Private DO 4 .....: ", info->private_do[3]);
686   if (info->cafpr1len)
687     {
688       tty_fprintf (fp, "CA fingerprint %d .:", 1);
689       print_shax_fpr (fp, info->cafpr1, info->cafpr1len);
690     }
691   if (info->cafpr2len)
692     {
693       tty_fprintf (fp, "CA fingerprint %d .:", 2);
694       print_shax_fpr (fp, info->cafpr2, info->cafpr2len);
695     }
696   if (info->cafpr3len)
697     {
698       tty_fprintf (fp, "CA fingerprint %d .:", 3);
699       print_shax_fpr (fp, info->cafpr3, info->cafpr3len);
700     }
701   tty_fprintf (fp, "Signature PIN ....: %s\n",
702                info->chv1_cached? _("not forced"): _("forced"));
703   if (info->key_attr[0].algo)
704     {
705       tty_fprintf (fp,    "Key attributes ...:");
706       for (i=0; i < DIM (info->key_attr); i++)
707         if (info->key_attr[i].algo == PUBKEY_ALGO_RSA)
708           tty_fprintf (fp, " rsa%u", info->key_attr[i].nbits);
709         else if (info->key_attr[i].algo == PUBKEY_ALGO_ECDH
710                  || info->key_attr[i].algo == PUBKEY_ALGO_ECDSA
711                  || info->key_attr[i].algo == PUBKEY_ALGO_EDDSA)
712           {
713             const char *curve_for_print = "?";
714             const char *oid;
715
716             if (info->key_attr[i].curve
717                 && (oid = openpgp_curve_to_oid (info->key_attr[i].curve, NULL)))
718               curve_for_print = openpgp_oid_to_curve (oid, 0);
719             tty_fprintf (fp, " %s", curve_for_print);
720           }
721       tty_fprintf (fp, "\n");
722     }
723   tty_fprintf (fp, "Max. PIN lengths .: %d %d %d\n",
724                info->chvmaxlen[0], info->chvmaxlen[1], info->chvmaxlen[2]);
725   tty_fprintf (fp, "PIN retry counter : %d %d %d\n",
726                info->chvretry[0], info->chvretry[1], info->chvretry[2]);
727   tty_fprintf (fp, "Signature counter : %lu\n", info->sig_counter);
728   if (info->extcap.kdf)
729     {
730       tty_fprintf (fp, "KDF setting ......: %s\n",
731                    info->kdf_do_enabled ? "on" : "off");
732     }
733   if (info->extcap.bt)
734     {
735       tty_fprintf (fp, "UIF setting ......: Sign=%s Decrypt=%s Auth=%s\n",
736                    info->uif[0] ? "on" : "off", info->uif[1] ? "on" : "off",
737                    info->uif[2] ? "on" : "off");
738     }
739
740   list_all_kinfo (info, keyinfolabels, fp);
741
742   /* tty_fprintf (fp, "General key info->.: "); */
743   /* thefpr = (info->fpr1len? info->fpr1 : info->fpr2len? info->fpr2 : */
744   /*           info->fpr3len? info->fpr3 : NULL); */
745   /* thefprlen = (info->fpr1len? info->fpr1len : info->fpr2len? info->fpr2len : */
746   /*              info->fpr3len? info->fpr3len : 0); */
747   /* If the fingerprint is all 0xff, the key has no associated
748      OpenPGP certificate.  */
749   /* if ( thefpr && !mem_is_ff (thefpr, thefprlen) */
750   /*      && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, thefprlen)) */
751   /*   { */
752       /* print_pubkey_info (ctrl, fp, pk); */
753       /* if (keyblock) */
754       /*   print_card_key_info (fp, keyblock); */
755   /*   } */
756   /* else */
757   /*   tty_fprintf (fp, "[none]\n"); */
758 }
759
760
761 /* Print all available information about the current card. */
762 static void
763 list_card (card_info_t info)
764 {
765   estream_t fp = NULL;
766
767   tty_fprintf (fp, "Reader ...........: %s\n",
768                info->reader? info->reader : "[none]");
769   tty_fprintf (fp, "Serial number ....: %s\n",
770                info->serialno? info->serialno : "[none]");
771   tty_fprintf (fp, "Application Type .: %s%s%s%s\n",
772                app_type_string (info->apptype),
773                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? "(":"",
774                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr
775                ? info->apptypestr:"",
776                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? ")":"");
777   if (info->serialno && info->dispserialno
778       && strcmp (info->serialno, info->dispserialno))
779     tty_fprintf (fp, "Displayed S/N ....: %s\n", info->dispserialno);
780
781   switch (info->apptype)
782     {
783     case APP_TYPE_OPENPGP: list_openpgp (info, fp); break;
784     default: break;
785     }
786 }
787
788
789 \f
790 /* The VERIFY command.  */
791 static gpg_error_t
792 cmd_verify (card_info_t info, char *argstr)
793 {
794   gpg_error_t err;
795
796   if (!info)
797     return print_help ("verify [chvid]", 0);
798
799   if (info->apptype == APP_TYPE_OPENPGP)
800     err = scd_checkpin (info->serialno);
801   else
802     err = scd_checkpin (argstr);
803
804   if (err)
805     log_error ("verify failed: %s <%s>\n",
806                gpg_strerror (err), gpg_strsource (err));
807   return err;
808 }
809
810
811 /* Helper for cmd_name to qyery a part of name.  */
812 static char *
813 ask_one_name (const char *prompt)
814 {
815   char *name;
816   int i;
817
818   for (;;)
819     {
820       name = tty_get (prompt);
821       trim_spaces (name);
822       tty_kill_prompt ();
823       if (!*name || *name == CONTROL_D)
824         {
825           if (*name == CONTROL_D)
826             tty_fprintf (NULL, "\n");
827           xfree (name);
828           return NULL;
829         }
830       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
831         ;
832
833       /* The name must be in Latin-1 and not UTF-8 - lacking the code
834        * to ensure this we restrict it to ASCII. */
835       if (name[i])
836         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
837       else if (strchr (name, '<'))
838         tty_printf (_("Error: The \"<\" character may not be used.\n"));
839       else if (strstr (name, "  "))
840         tty_printf (_("Error: Double spaces are not allowed.\n"));
841       else
842         return name;
843       xfree (name);
844     }
845 }
846
847
848 /* The NAME command.  */
849 static gpg_error_t
850 cmd_name (card_info_t info, const char *argstr)
851 {
852   gpg_error_t err;
853   char *surname, *givenname;
854   char *isoname, *p;
855
856   if (!info)
857     return print_help
858       ("name [--clear]\n\n"
859        "Set the name field of an OpenPGP card.  With --clear the stored\n"
860        "name is cleared off the card.", APP_TYPE_OPENPGP, APP_TYPE_NKS, 0);
861
862   if (info->apptype != APP_TYPE_OPENPGP)
863     {
864       log_info ("Note: This is an OpenPGP only command.\n");
865       return gpg_error (GPG_ERR_NOT_SUPPORTED);
866     }
867
868  again:
869   if (!strcmp (argstr, "--clear"))
870     isoname = xstrdup (" "); /* No real way to clear; set to space instead. */
871   else
872     {
873       surname = ask_one_name (_("Cardholder's surname: "));
874       givenname = ask_one_name (_("Cardholder's given name: "));
875       if (!surname || !givenname || (!*surname && !*givenname))
876         {
877           xfree (surname);
878           xfree (givenname);
879           return gpg_error (GPG_ERR_CANCELED);
880         }
881
882       isoname = xstrconcat (surname, "<<", givenname, NULL);
883       xfree (surname);
884       xfree (givenname);
885       for (p=isoname; *p; p++)
886         if (*p == ' ')
887           *p = '<';
888
889       if (strlen (isoname) > 39 )
890         {
891           log_info (_("Error: Combined name too long "
892                       "(limit is %d characters).\n"), 39);
893           xfree (isoname);
894           goto again;
895         }
896     }
897
898   err = scd_setattr ("DISP-NAME", isoname, strlen (isoname));
899
900   xfree (isoname);
901   return err;
902 }
903
904
905 static gpg_error_t
906 cmd_url (card_info_t info, const char *argstr)
907 {
908   gpg_error_t err;
909   char *url;
910
911   if (!info)
912     return print_help
913       ("URL [--clear]\n\n"
914        "Set the URL data object.  That data object can be used by\n"
915        "the FETCH command to retrieve the full public key.  The\n"
916        "option --clear deletes the content of that data object.",
917        APP_TYPE_OPENPGP, 0);
918
919   if (info->apptype != APP_TYPE_OPENPGP)
920     {
921       log_info ("Note: This is an OpenPGP only command.\n");
922       return gpg_error (GPG_ERR_NOT_SUPPORTED);
923     }
924
925   if (!strcmp (argstr, "--clear"))
926     url = xstrdup (" "); /* No real way to clear; set to space instead. */
927   else
928     {
929       url = tty_get (_("URL to retrieve public key: "));
930       trim_spaces (url);
931       tty_kill_prompt ();
932       if (!*url || *url == CONTROL_D)
933         {
934           err = gpg_error (GPG_ERR_CANCELED);
935           goto leave;
936         }
937     }
938
939   err = scd_setattr ("PUBKEY-URL", url, strlen (url));
940
941  leave:
942   xfree (url);
943   return err;
944 }
945
946
947 /* Fetch the key from the URL given on the card or try to get it from
948  * the default keyserver.  */
949 static gpg_error_t
950 cmd_fetch (card_info_t info)
951 {
952   gpg_error_t err;
953   key_info_t kinfo;
954
955   if (!info)
956     return print_help
957       ("FETCH\n\n"
958        "Retrieve a key using the URL data object or if that is missing\n"
959        "using the fingerprint.", APP_TYPE_OPENPGP, 0);
960
961   if (info->pubkey_url && *info->pubkey_url)
962     {
963       /* strlist_t sl = NULL; */
964
965       /* add_to_strlist (&sl, info.pubkey_url); */
966       /* err = keyserver_fetch (ctrl, sl, KEYORG_URL); */
967       /* free_strlist (sl); */
968       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
969     }
970   else if ((kinfo = find_kinfo (info, "OPENPGP.1")) && kinfo->fprlen)
971     {
972       /* rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len, */
973       /*                               opt.keyserver, 0); */
974       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
975     }
976   else
977     err = gpg_error (GPG_ERR_NO_DATA);
978
979   return err;
980 }
981
982
983 static gpg_error_t
984 cmd_login (card_info_t info, char *argstr)
985 {
986   gpg_error_t err;
987   char *data;
988   size_t datalen;
989
990   if (!info)
991     return print_help
992       ("LOGIN [--clear] [< FILE]\n\n"
993        "Set the login data object.  If FILE is given the data is\n"
994        "is read from that file.  This allows for binary data.\n"
995        "The option --clear deletes the login data.",
996        APP_TYPE_OPENPGP, 0);
997
998   if (!strcmp (argstr, "--clear"))
999     {
1000       data = xstrdup (" "); /* kludge.  */
1001       datalen = 1;
1002     }
1003   else if (*argstr == '<')  /* Read it from a file */
1004     {
1005       for (argstr++; spacep (argstr); argstr++)
1006         ;
1007       err = get_data_from_file (argstr, &data, &datalen);
1008       if (err)
1009         goto leave;
1010     }
1011   else
1012     {
1013       data = tty_get (_("Login data (account name): "));
1014       trim_spaces (data);
1015       tty_kill_prompt ();
1016       if (!*data || *data == CONTROL_D)
1017         {
1018           err = gpg_error (GPG_ERR_CANCELED);
1019           goto leave;
1020         }
1021       datalen = strlen (data);
1022     }
1023
1024   err = scd_setattr ("LOGIN-DATA", data, datalen);
1025
1026  leave:
1027   xfree (data);
1028   return err;
1029 }
1030
1031
1032 static gpg_error_t
1033 cmd_lang (card_info_t info, const char *argstr)
1034 {
1035   gpg_error_t err;
1036   char *data, *p;
1037
1038   if (!info)
1039     return print_help
1040       ("LANG [--clear]\n\n"
1041        "Change the language info for the card.  This info can be used\n"
1042        "by applications for a personalized greeting.  Up to 4 two-digit\n"
1043        "language identifiers can be entered as a preference.  The option\n"
1044        "--clear removes all identifiers.  GnuPG does not use this info.",
1045        APP_TYPE_OPENPGP, 0);
1046
1047   if (!strcmp (argstr, "--clear"))
1048     data = xstrdup ("  "); /* Note that we need two spaces here.  */
1049   else
1050     {
1051     again:
1052       data = tty_get (_("Language preferences: "));
1053       trim_spaces (data);
1054       tty_kill_prompt ();
1055       if (!*data || *data == CONTROL_D)
1056         {
1057           err = gpg_error (GPG_ERR_CANCELED);
1058           goto leave;
1059         }
1060
1061       if (strlen (data) > 8 || (strlen (data) & 1))
1062         {
1063           log_info (_("Error: invalid length of preference string.\n"));
1064           xfree (data);
1065           goto again;
1066         }
1067
1068       for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1069         ;
1070       if (*p)
1071         {
1072           log_info (_("Error: invalid characters in preference string.\n"));
1073           xfree (data);
1074           goto again;
1075         }
1076     }
1077
1078   err = scd_setattr ("DISP-LANG", data, strlen (data));
1079
1080  leave:
1081   xfree (data);
1082   return err;
1083 }
1084
1085
1086 static gpg_error_t
1087 cmd_salut (card_info_t info, const char *argstr)
1088 {
1089   gpg_error_t err;
1090   char *data = NULL;
1091   const char *str;
1092
1093   if (!info)
1094     return print_help
1095       ("SALUT [--clear]\n\n"
1096        "Change the salutation info for the card.  This info can be used\n"
1097        "by applications for a personalized greeting.  The option --clear\n"
1098        "removes this data object.  GnuPG does not use this info.",
1099        APP_TYPE_OPENPGP, 0);
1100
1101  again:
1102   if (!strcmp (argstr, "--clear"))
1103     str = "9";
1104   else
1105     {
1106       data = tty_get (_("Salutation (M = Mr., F = Mrs., or space): "));
1107       trim_spaces (data);
1108       tty_kill_prompt ();
1109       if (*data == CONTROL_D)
1110         {
1111           err = gpg_error (GPG_ERR_CANCELED);
1112           goto leave;
1113         }
1114
1115       if (!*data)
1116         str = "9";
1117       else if ((*data == 'M' || *data == 'm') && !data[1])
1118         str = "1";
1119       else if ((*data == 'F' || *data == 'f') && !data[1])
1120         str = "2";
1121       else
1122         {
1123           tty_printf (_("Error: invalid response.\n"));
1124           xfree (data);
1125           goto again;
1126         }
1127     }
1128
1129   err = scd_setattr ("DISP-SEX", str, 1);
1130  leave:
1131   xfree (data);
1132   return err;
1133 }
1134
1135
1136 static gpg_error_t
1137 cmd_cafpr (card_info_t info, char *argstr)
1138 {
1139   gpg_error_t err;
1140   char *data = NULL;
1141   const char *s;
1142   int i, c;
1143   unsigned char fpr[32];
1144   int fprlen;
1145   int fprno;
1146   int opt_clear = 0;
1147
1148   if (!info)
1149     return print_help
1150       ("CAFPR [--clear] N\n\n"
1151        "Change the CA fingerprint number N.  N must be in the\n"
1152        "range 1 to 3.  The option --clear clears the specified\n"
1153        "CA fingerprint N or all of them if N is 0 or not given.",
1154        APP_TYPE_OPENPGP, 0);
1155
1156
1157   opt_clear = has_leading_option (argstr, "--clear");
1158   argstr = skip_options (argstr);
1159
1160   if (digitp (argstr))
1161     {
1162       fprno = atoi (argstr);
1163       while (digitp (argstr))
1164         argstr++;
1165       while (spacep (argstr))
1166         argstr++;
1167     }
1168   else
1169     fprno = 0;
1170
1171   if (opt_clear && !fprno)
1172     ; /* Okay: clear all fprs.  */
1173   else if (fprno < 1 || fprno > 3)
1174     {
1175       err = gpg_error (GPG_ERR_INV_ARG);
1176       goto leave;
1177     }
1178
1179  again:
1180   if (opt_clear)
1181     {
1182       memset (fpr, 0, 20);
1183       fprlen = 20;
1184     }
1185   else
1186     {
1187       xfree (data);
1188       data = tty_get (_("CA fingerprint: "));
1189       trim_spaces (data);
1190       tty_kill_prompt ();
1191       if (!*data || *data == CONTROL_D)
1192         {
1193           err = gpg_error (GPG_ERR_CANCELED);
1194           goto leave;
1195         }
1196
1197       for (i=0, s=data; i < sizeof fpr && *s; )
1198         {
1199           while (spacep(s))
1200             s++;
1201           if (*s == ':')
1202             s++;
1203           while (spacep(s))
1204             s++;
1205           c = hextobyte (s);
1206           if (c == -1)
1207             break;
1208           fpr[i++] = c;
1209           s += 2;
1210         }
1211       fprlen = i;
1212       if ((fprlen != 20 && fprlen != 32) || *s)
1213         {
1214           log_error (_("Error: invalid formatted fingerprint.\n"));
1215           goto again;
1216         }
1217     }
1218
1219   if (!fprno)
1220     {
1221       log_assert (opt_clear);
1222       err = scd_setattr ("CA-FPR-1", fpr, fprlen);
1223       if (!err)
1224         err = scd_setattr ("CA-FPR-2", fpr, fprlen);
1225       if (!err)
1226         err = scd_setattr ("CA-FPR-3", fpr, fprlen);
1227     }
1228   else
1229     err = scd_setattr (fprno==1?"CA-FPR-1":
1230                        fprno==2?"CA-FPR-2":
1231                        fprno==3?"CA-FPR-3":"x", fpr, fprlen);
1232
1233  leave:
1234   xfree (data);
1235   return err;
1236 }
1237
1238
1239 static gpg_error_t
1240 cmd_privatedo (card_info_t info, char *argstr)
1241 {
1242   gpg_error_t err;
1243   int opt_clear;
1244   char *do_name = NULL;
1245   char *data = NULL;
1246   size_t datalen;
1247   int do_no;
1248
1249   if (!info)
1250     return print_help
1251       ("PRIVATEDO [--clear] N [< FILE]\n\n"
1252        "Change the private data object N.  N must be in the\n"
1253        "range 1 to 4.  If FILE is given the data is is read\n"
1254        "from that file.  The option --clear clears the data.",
1255        APP_TYPE_OPENPGP, 0);
1256
1257   opt_clear = has_leading_option (argstr, "--clear");
1258   argstr = skip_options (argstr);
1259
1260   if (digitp (argstr))
1261     {
1262       do_no = atoi (argstr);
1263       while (digitp (argstr))
1264         argstr++;
1265       while (spacep (argstr))
1266         argstr++;
1267     }
1268   else
1269     do_no = 0;
1270
1271   if (do_no < 1 || do_no > 4)
1272     {
1273       err = gpg_error (GPG_ERR_INV_ARG);
1274       goto leave;
1275     }
1276   do_name = xasprintf ("PRIVATE-DO-%d", do_no);
1277
1278   if (opt_clear)
1279     {
1280       data = xstrdup (" ");
1281       datalen = 1;
1282     }
1283   else if (*argstr == '<')  /* Read it from a file */
1284     {
1285       for (argstr++; spacep (argstr); argstr++)
1286         ;
1287       err = get_data_from_file (argstr, &data, &datalen);
1288       if (err)
1289         goto leave;
1290     }
1291   else if (*argstr)
1292     {
1293       err = gpg_error (GPG_ERR_INV_ARG);
1294       goto leave;
1295     }
1296   else
1297     {
1298       data = tty_get (_("Private DO data: "));
1299       trim_spaces (data);
1300       tty_kill_prompt ();
1301       datalen = strlen (data);
1302       if (!*data || *data == CONTROL_D)
1303         {
1304           err = gpg_error (GPG_ERR_CANCELED);
1305           goto leave;
1306         }
1307     }
1308
1309   err = scd_setattr (do_name, data, datalen);
1310
1311  leave:
1312   xfree (do_name);
1313   xfree (data);
1314   return err;
1315 }
1316
1317
1318 static gpg_error_t
1319 cmd_writecert (card_info_t info, char *argstr)
1320 {
1321   gpg_error_t err;
1322   int opt_clear;
1323   int do_no;
1324   char *data = NULL;
1325   size_t datalen;
1326
1327   if (!info)
1328     return print_help
1329       ("WRITECERT [--clear] 3 < FILE\n\n"
1330        "Write a certificate for key 3.  Unless --clear is given\n"
1331        "the file argement is mandatory.  The option --clear removes\n"
1332        "the certificate from the card.",
1333        APP_TYPE_OPENPGP, 0);
1334
1335   opt_clear = has_leading_option (argstr, "--clear");
1336   argstr = skip_options (argstr);
1337
1338   if (digitp (argstr))
1339     {
1340       do_no = atoi (argstr);
1341       while (digitp (argstr))
1342         argstr++;
1343       while (spacep (argstr))
1344         argstr++;
1345     }
1346   else
1347     do_no = 0;
1348
1349   if (do_no != 3)
1350     {
1351       err = gpg_error (GPG_ERR_INV_ARG);
1352       goto leave;
1353     }
1354
1355   if (opt_clear)
1356     {
1357       data = xstrdup (" ");
1358       datalen = 1;
1359     }
1360   else if (*argstr == '<')  /* Read it from a file */
1361     {
1362       for (argstr++; spacep (argstr); argstr++)
1363         ;
1364       err = get_data_from_file (argstr, &data, &datalen);
1365       if (err)
1366         goto leave;
1367     }
1368   else
1369     {
1370       err = gpg_error (GPG_ERR_INV_ARG);
1371       goto leave;
1372     }
1373
1374   err = scd_writecert ("OPENPGP.3", data, datalen);
1375
1376  leave:
1377   xfree (data);
1378   return err;
1379 }
1380
1381
1382 static gpg_error_t
1383 cmd_readcert (card_info_t info, char *argstr)
1384 {
1385   gpg_error_t err;
1386   int do_no;
1387   void *data = NULL;
1388   size_t datalen;
1389   const char *fname;
1390
1391   if (!info)
1392     return print_help
1393       ("READCERT 3 > FILE\n\n"
1394        "Read the certificate for key 3 and store it in FILE.",
1395        APP_TYPE_OPENPGP, 0);
1396
1397   argstr = skip_options (argstr);
1398
1399   if (digitp (argstr))
1400     {
1401       do_no = atoi (argstr);
1402       while (digitp (argstr))
1403         argstr++;
1404       while (spacep (argstr))
1405         argstr++;
1406     }
1407   else
1408     do_no = 0;
1409
1410   if (do_no != 3)
1411     {
1412       err = gpg_error (GPG_ERR_INV_ARG);
1413       goto leave;
1414     }
1415
1416   if (*argstr == '>')  /* Read it from a file */
1417     {
1418       for (argstr++; spacep (argstr); argstr++)
1419         ;
1420       fname = argstr;
1421     }
1422   else
1423     {
1424       err = gpg_error (GPG_ERR_INV_ARG);
1425       goto leave;
1426     }
1427
1428   err = scd_readcert ("OPENPGP.3", &data, &datalen);
1429   if (err)
1430     goto leave;
1431
1432   err = put_data_to_file (fname, data, datalen);
1433
1434  leave:
1435   xfree (data);
1436   return err;
1437 }
1438
1439
1440 static gpg_error_t
1441 cmd_forcesig (card_info_t info)
1442 {
1443   gpg_error_t err;
1444   int newstate;
1445
1446   if (!info)
1447     return print_help
1448       ("FORCESIG\n\n"
1449        "Toggle the forcesig flag of an OpenPGP card.",
1450        APP_TYPE_OPENPGP, 0);
1451
1452   if (info->apptype != APP_TYPE_OPENPGP)
1453     {
1454       log_info ("Note: This is an OpenPGP only command.\n");
1455       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1456     }
1457
1458   newstate = !info->chv1_cached;
1459
1460   err = scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
1461   if (err)
1462     goto leave;
1463
1464   /* Read it back to be sure we have the right toggle state the next
1465    * time.  */
1466   err = scd_getattr ("CHV-STATUS", info);
1467
1468  leave:
1469   return err;
1470 }
1471
1472
1473 /* Helper for cmd_generate.  Noe that either 0 or 1 is stored at
1474  * FORCED_CHV1. */
1475 static gpg_error_t
1476 check_pin_for_key_operation (card_info_t info, int *forced_chv1)
1477 {
1478   gpg_error_t err = 0;
1479
1480   *forced_chv1 = !info->chv1_cached;
1481   if (*forced_chv1)
1482     { /* Switch off the forced mode so that during key generation we
1483        * don't get bothered with PIN queries for each self-signature. */
1484       err = scd_setattr ("CHV-STATUS-1", "\x01", 1);
1485       if (err)
1486         {
1487           log_error ("error clearing forced signature PIN flag: %s\n",
1488                      gpg_strerror (err));
1489           *forced_chv1 = -1;  /* Not changed.  */
1490           goto leave;
1491         }
1492     }
1493
1494   /* Check the PIN now, so that we won't get asked later for each
1495    * binding signature.  */
1496   err = scd_checkpin (info->serialno);
1497   if (err)
1498     log_error ("error checking the PIN: %s\n", gpg_strerror (err));
1499
1500  leave:
1501   return err;
1502 }
1503
1504
1505 /* Helper for cmd_generate.  */
1506 static void
1507 restore_forced_chv1 (int *forced_chv1)
1508 {
1509   gpg_error_t err;
1510
1511   /* Note the possible values stored at FORCED_CHV1:
1512    *   0 - forcesig was not enabled.
1513    *   1 - forcesig was enabled - enable it again.
1514    *  -1 - We have not changed anything.  */
1515   if (*forced_chv1 == 1)
1516     { /* Switch back to forced state. */
1517       err = scd_setattr ("CHV-STATUS-1", "", 1);
1518       if (err)
1519         log_error ("error setting forced signature PIN flag: %s\n",
1520                    gpg_strerror (err));
1521       *forced_chv1 = 0;
1522     }
1523 }
1524
1525
1526 static gpg_error_t
1527 cmd_generate (card_info_t info)
1528 {
1529   gpg_error_t err;
1530   int forced_chv1 = -1;
1531   int want_backup;
1532   char *answer = NULL;
1533   key_info_t kinfo1, kinfo2, kinfo3;
1534
1535   if (!info)
1536     return print_help
1537       ("GENERATE\n\n"
1538        "Menu to generate a new keys.",
1539        APP_TYPE_OPENPGP, 0);
1540
1541   if (info->apptype != APP_TYPE_OPENPGP)
1542     {
1543       log_info ("Note: This is an OpenPGP only command.\n");
1544       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1545     }
1546
1547   if (info->extcap.ki)
1548     {
1549       xfree (answer);
1550       answer = tty_get (_("Make off-card backup of encryption key? (Y/n) "));
1551       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1552       tty_kill_prompt ();
1553       if (*answer == CONTROL_D)
1554         {
1555           err = gpg_error (GPG_ERR_CANCELED);
1556           goto leave;
1557         }
1558     }
1559   else
1560     want_backup = 0;
1561
1562
1563   kinfo1 = find_kinfo (info, "OPENPGP.1");
1564   kinfo2 = find_kinfo (info, "OPENPGP.2");
1565   kinfo3 = find_kinfo (info, "OPENPGP.3");
1566
1567   if ((kinfo1 && kinfo1->fprlen && !mem_is_zero (kinfo1->fpr,kinfo1->fprlen))
1568       || (kinfo2 && kinfo2->fprlen && !mem_is_zero (kinfo2->fpr,kinfo2->fprlen))
1569       || (kinfo3 && kinfo3->fprlen && !mem_is_zero (kinfo3->fpr,kinfo3->fprlen))
1570       )
1571     {
1572       tty_printf ("\n");
1573       log_info (_("Note: keys are already stored on the card!\n"));
1574       tty_printf ("\n");
1575       answer = tty_get (_("Replace existing keys? (y/N) "));
1576       tty_kill_prompt ();
1577       if (*answer == CONTROL_D)
1578         {
1579           err = gpg_error (GPG_ERR_CANCELED);
1580           goto leave;
1581         }
1582
1583       if (!answer_is_yes_no_default (answer, 0/*(default to No)*/))
1584         {
1585           err = gpg_error (GPG_ERR_CANCELED);
1586           goto leave;
1587         }
1588     }
1589
1590   /* If no displayed name has been set, we assume that this is a fresh
1591    * card and print a hint about the default PINs.  */
1592   if (!info->disp_name || !*info->disp_name)
1593     {
1594       tty_printf ("\n");
1595       tty_printf (_("Please note that the factory settings of the PINs are\n"
1596                     "   PIN = '%s'     Admin PIN = '%s'\n"
1597                     "You should change them using the command --change-pin\n"),
1598                   OPENPGP_USER_PIN_DEFAULT, OPENPGP_ADMIN_PIN_DEFAULT);
1599       tty_printf ("\n");
1600     }
1601
1602   err = check_pin_for_key_operation (info, &forced_chv1);
1603   if (err)
1604     goto leave;
1605
1606   /* FIXME: We need to divert to a function which spwans gpg which
1607    * will then create the key.  This also requires new features in
1608    * gpg.  We might also first create the keys on the card and then
1609    * tell gpg to use them to create the OpenPGP keyblock. */
1610   /* generate_keypair (ctrl, 1, NULL, info.serialno, want_backup); */
1611   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1612
1613  leave:
1614   restore_forced_chv1 (&forced_chv1);
1615   xfree (answer);
1616   return err;
1617 }
1618
1619
1620 /* Sub-menu to change a PIN.  The presented options may depend on the
1621  * the ALLOW_ADMIN flag.  */
1622 static gpg_error_t
1623 cmd_passwd (card_info_t info, int allow_admin)
1624 {
1625   gpg_error_t err;
1626   char *answer = NULL;
1627
1628   if (!info)
1629     return print_help
1630       ("PASSWD\n\n"
1631        "Menu to change or unblock the PINs.  Note that the\n"
1632        "presented menu options depend on the type of card\n"
1633        "and whether the admin mode is enabled.",
1634        0);
1635
1636   /* Convenience message because we did this in gpg --card-edit too.  */
1637   if (info->apptype == APP_TYPE_OPENPGP)
1638     log_info (_("OpenPGP card no. %s detected\n"),
1639               info->dispserialno? info->dispserialno : info->serialno);
1640
1641   if (!allow_admin)
1642     {
1643       err = scd_change_pin (1);
1644       if (err)
1645         goto leave;
1646       log_info ("PIN changed.\n");
1647     }
1648   else if (info->apptype == APP_TYPE_OPENPGP)
1649     {
1650       for (;;)
1651         {
1652           tty_printf ("\n");
1653           tty_printf ("1 - change PIN\n"
1654                       "2 - unblock and set new PIN\n"
1655                       "3 - change Admin PIN\n"
1656                       "4 - set the Reset Code\n"
1657                       "Q - quit\n");
1658           tty_printf ("\n");
1659
1660           err = 0;
1661           xfree (answer);
1662           answer = tty_get (_("Your selection? "));
1663           tty_kill_prompt ();
1664           if (*answer == CONTROL_D)
1665             break;  /* Quit.  */
1666           if (strlen (answer) != 1)
1667             continue;
1668           if (*answer == 'q' || *answer == 'Q')
1669             break;  /* Quit.  */
1670
1671           if (*answer == '1')
1672             {
1673               /* Change PIN (same as the direct thing in non-admin mode).  */
1674               err = scd_change_pin (1);
1675               if (err)
1676                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1677               else
1678                 log_info ("PIN changed.\n");
1679             }
1680           else if (*answer == '2')
1681             {
1682               /* Unblock PIN by setting a new PIN.  */
1683               err = scd_change_pin (101);
1684               if (err)
1685                 log_error ("Error unblocking the PIN: %s\n", gpg_strerror(err));
1686               else
1687                 log_info ("PIN unblocked and new PIN set.\n");
1688             }
1689           else if (*answer == '3')
1690             {
1691               /* Change Admin PIN.  */
1692               err = scd_change_pin (3);
1693               if (err)
1694                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1695               else
1696                 log_info ("PIN changed.\n");
1697           }
1698           else if (*answer == '4')
1699             {
1700               /* Set a new Reset Code.  */
1701               err = scd_change_pin (102);
1702               if (err)
1703                 log_error ("Error setting the Reset Code: %s\n",
1704                            gpg_strerror (err));
1705               else
1706                 log_info ("Reset Code set.\n");
1707             }
1708
1709         } /*end for loop*/
1710     }
1711   else
1712     {
1713       log_info ("Admin related passwd options not yet supported for '%s'\n",
1714                 app_type_string (info->apptype));
1715       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1716     }
1717
1718  leave:
1719   xfree (answer);
1720   return err;
1721 }
1722
1723
1724 static gpg_error_t
1725 cmd_unblock (card_info_t info)
1726 {
1727   gpg_error_t err = 0;
1728
1729   if (!info)
1730     return print_help
1731       ("UNBLOCK\n\n"
1732        "Unblock a PIN using a PUK or Reset Code.  Note that OpenPGP\n"
1733        "cards prior to version 2 can't use this; instead the PASSWD\n"
1734        "command can be used to set a new PIN.",
1735        0);
1736
1737   if (info->apptype == APP_TYPE_OPENPGP)
1738     log_info (_("OpenPGP card no. %s detected\n"),
1739               info->dispserialno? info->dispserialno : info->serialno);
1740
1741   if (info->apptype == APP_TYPE_OPENPGP && !info->is_v2)
1742     log_error (_("This command is only available for version 2 cards\n"));
1743   else if (info->apptype == APP_TYPE_OPENPGP && !info->chvretry[1])
1744     log_error (_("Reset Code not or not anymore available\n"));
1745   else if (info->apptype == APP_TYPE_OPENPGP)
1746     {
1747       err = scd_change_pin (2);
1748       if (!err)
1749         log_info ("PIN changed.\n");
1750     }
1751   else
1752     log_info ("Unblocking not yet supported for '%s'\n",
1753               app_type_string (info->apptype));
1754
1755   return err;
1756 }
1757
1758
1759 /* Direct sending of an hex encoded APDU with error printing.  */
1760 static gpg_error_t
1761 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1762 {
1763   gpg_error_t err;
1764   unsigned int sw;
1765
1766   err = scd_apdu (hexapdu, &sw);
1767   if (err)
1768     log_error ("sending card command %s failed: %s\n", desc,
1769                gpg_strerror (err));
1770   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1771     ;
1772   else if (ignore == 0xffff)
1773     ; /* Ignore all status words.  */
1774   else if (sw != 0x9000)
1775     {
1776       switch (sw)
1777         {
1778         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1779         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1780         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1781         default: err = gpg_error (GPG_ERR_CARD);
1782         }
1783       if (!(ignore && ignore == sw))
1784         log_error ("card command %s failed: %s (0x%04x)\n", desc,
1785                    gpg_strerror (err),  sw);
1786     }
1787   return err;
1788 }
1789
1790
1791 /* Note: On successful execution a redisplay should be scheduled.  If
1792  * this function fails the card may be in an unknown state. */
1793 static gpg_error_t
1794 cmd_factoryreset (card_info_t info)
1795 {
1796   gpg_error_t err;
1797   char *answer = NULL;
1798   int termstate = 0;
1799   int any_apdu = 0;
1800   int i;
1801
1802
1803   if (!info)
1804     return print_help
1805       ("FACTORY-RESET\n\n"
1806        "Do a complete reset of an OpenPGP card.  This deletes all\n"
1807        "data and keys and resets the PINs to their default.  This\n"
1808        "mainly used by developers with scratch cards.  Don't worry,\n"
1809        "you need to confirm before the command proceeds.",
1810        APP_TYPE_OPENPGP, 0);
1811
1812   if (info->apptype != APP_TYPE_OPENPGP)
1813     {
1814       log_info ("Note: This is an OpenPGP only command.\n");
1815       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1816     }
1817
1818   /* The code below basically does the same what this
1819    * gpg-connect-agent script does:
1820    *
1821    *   scd reset
1822    *   scd serialno undefined
1823    *   scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1824    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1825    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1826    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1827    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1828    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1829    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1830    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1831    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1832    *   scd apdu 00 e6 00 00
1833    *   scd apdu 00 44 00 00
1834    *   scd reset
1835    *   /echo Card has been reset to factory defaults
1836    *
1837    * but tries to find out something about the card first.
1838    */
1839
1840   err = scd_learn (info);
1841   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1842       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1843     termstate = 1;
1844   else if (err)
1845     {
1846       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1847       goto leave;
1848     }
1849
1850   if (!termstate)
1851     {
1852       log_info (_("OpenPGP card no. %s detected\n"),
1853                 info->dispserialno? info->dispserialno : info->serialno);
1854       if (!(info->status_indicator == 3 || info->status_indicator == 5))
1855         {
1856           /* Note: We won't see status-indicator 3 here because it is not
1857            * possible to select a card application in termination state.  */
1858           log_error (_("This command is not supported by this card\n"));
1859           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1860           goto leave;
1861         }
1862
1863       tty_printf ("\n");
1864       log_info
1865         (_("Note: This command destroys all keys stored on the card!\n"));
1866       tty_printf ("\n");
1867       xfree (answer);
1868       answer = tty_get (_("Continue? (y/N) "));
1869       tty_kill_prompt ();
1870       trim_spaces (answer);
1871       if (*answer == CONTROL_D
1872           || !answer_is_yes_no_default (answer, 0/*(default to no)*/))
1873         {
1874           err = gpg_error (GPG_ERR_CANCELED);
1875           goto leave;
1876         }
1877
1878       xfree (answer);
1879       answer = tty_get (_("Really do a factory reset? (enter \"yes\") "));
1880       tty_kill_prompt ();
1881       trim_spaces (answer);
1882       if (strcmp (answer, "yes") && strcmp (answer,_("yes")))
1883         {
1884           err = gpg_error (GPG_ERR_CANCELED);
1885           goto leave;
1886         }
1887
1888       any_apdu = 1;
1889       /* We need to select a card application before we can send APDUs
1890        * to the card without scdaemon doing anything on its own.  */
1891       err = send_apdu (NULL, "RESET", 0);
1892       if (err)
1893         goto leave;
1894       err = send_apdu ("undefined", "dummy select ", 0);
1895       if (err)
1896         goto leave;
1897
1898       /* Select the OpenPGP application.  */
1899       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1900       if (err)
1901         goto leave;
1902
1903       /* Do some dummy verifies with wrong PINs to set the retry
1904        * counter to zero.  We can't easily use the card version 2.1
1905        * feature of presenting the admin PIN to allow the terminate
1906        * command because there is no machinery in scdaemon to catch
1907        * the verify command and ask for the PIN when the "APDU"
1908        * command is used.
1909        * Here, the length of dummy wrong PIN is 32-byte, also
1910        * supporting authentication with KDF DO.  */
1911       for (i=0; i < 4; i++)
1912         send_apdu ("0020008120"
1913                    "40404040404040404040404040404040"
1914                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1915       for (i=0; i < 4; i++)
1916         send_apdu ("0020008320"
1917                    "40404040404040404040404040404040"
1918                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1919
1920       /* Send terminate datafile command.  */
1921       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1922       if (err)
1923         goto leave;
1924     }
1925
1926   any_apdu = 1;
1927   /* Send activate datafile command.  This is used without
1928    * confirmation if the card is already in termination state.  */
1929   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1930   if (err)
1931     goto leave;
1932
1933   /* Finally we reset the card reader once more.  */
1934   err = send_apdu (NULL, "RESET", 0);
1935   if (err)
1936     goto leave;
1937
1938   /* Then, connect the card again (answer used as a dummy).  */
1939   xfree (answer); answer = NULL;
1940   err = scd_serialno (&answer, NULL);
1941
1942  leave:
1943   if (err && any_apdu)
1944     {
1945       log_info ("Due to an error the card might be in an inconsistent state\n"
1946                 "You should run the LIST command to check this.\n");
1947       /* FIXME: We need a better solution in the case that the card is
1948        * in a termination state, i.e. the card was removed before the
1949        * activate was sent.  The best solution I found with v2.1
1950        * Zeitcontrol card was to kill scdaemon and the issue this
1951        * sequence with gpg-connect-agent:
1952        *   scd reset
1953        *   scd serialno undefined
1954        *   scd apdu 00A4040006D27600012401 (returns error)
1955        *   scd apdu 00440000
1956        * Then kill scdaemon again and issue:
1957        *   scd reset
1958        *   scd serialno openpgp
1959        */
1960     }
1961   xfree (answer);
1962   return err;
1963 }
1964
1965
1966 /* Generate KDF data.  This is a helper for cmd_kdfsetup.  */
1967 static gpg_error_t
1968 gen_kdf_data (unsigned char *data, int single_salt)
1969 {
1970   gpg_error_t err;
1971   const unsigned char h0[] = { 0x81, 0x01, 0x03,
1972                                0x82, 0x01, 0x08,
1973                                0x83, 0x04 };
1974   const unsigned char h1[] = { 0x84, 0x08 };
1975   const unsigned char h2[] = { 0x85, 0x08 };
1976   const unsigned char h3[] = { 0x86, 0x08 };
1977   const unsigned char h4[] = { 0x87, 0x20 };
1978   const unsigned char h5[] = { 0x88, 0x20 };
1979   unsigned char *p, *salt_user, *salt_admin;
1980   unsigned char s2k_char;
1981   unsigned int iterations;
1982   unsigned char count_4byte[4];
1983
1984   p = data;
1985
1986   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
1987   iterations = S2K_DECODE_COUNT (s2k_char);
1988   count_4byte[0] = (iterations >> 24) & 0xff;
1989   count_4byte[1] = (iterations >> 16) & 0xff;
1990   count_4byte[2] = (iterations >>  8) & 0xff;
1991   count_4byte[3] = (iterations & 0xff);
1992
1993   memcpy (p, h0, sizeof h0);
1994   p += sizeof h0;
1995   memcpy (p, count_4byte, sizeof count_4byte);
1996   p += sizeof count_4byte;
1997   memcpy (p, h1, sizeof h1);
1998   salt_user = (p += sizeof h1);
1999   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2000   p += 8;
2001
2002   if (single_salt)
2003     salt_admin = salt_user;
2004   else
2005     {
2006       memcpy (p, h2, sizeof h2);
2007       p += sizeof h2;
2008       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2009       p += 8;
2010       memcpy (p, h3, sizeof h3);
2011       salt_admin = (p += sizeof h3);
2012       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2013       p += 8;
2014     }
2015
2016   memcpy (p, h4, sizeof h4);
2017   p += sizeof h4;
2018   err = gcry_kdf_derive (OPENPGP_USER_PIN_DEFAULT,
2019                          strlen (OPENPGP_USER_PIN_DEFAULT),
2020                          GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2021                          salt_user, 8, iterations, 32, p);
2022   p += 32;
2023   if (!err)
2024     {
2025       memcpy (p, h5, sizeof h5);
2026       p += sizeof h5;
2027       err = gcry_kdf_derive (OPENPGP_ADMIN_PIN_DEFAULT,
2028                              strlen (OPENPGP_ADMIN_PIN_DEFAULT),
2029                              GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2030                              salt_admin, 8, iterations, 32, p);
2031     }
2032
2033   return err;
2034 }
2035
2036
2037 static gpg_error_t
2038 cmd_kdfsetup (card_info_t info, char *argstr)
2039 {
2040   gpg_error_t err;
2041   unsigned char kdf_data[OPENPGP_KDF_DATA_LENGTH_MAX];
2042   int single = (*argstr != 0);
2043
2044   if (!info)
2045     return print_help
2046       ("KDF-SETUP\n\n"
2047        "Prepare the OpenPGP card KDF feature for this card.",
2048        APP_TYPE_OPENPGP, 0);
2049
2050   if (info->apptype != APP_TYPE_OPENPGP)
2051     {
2052       log_info ("Note: This is an OpenPGP only command.\n");
2053       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2054     }
2055
2056   if (!info->extcap.kdf)
2057     {
2058       log_error (_("This command is not supported by this card\n"));
2059       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2060       goto leave;
2061     }
2062
2063   err = gen_kdf_data (kdf_data, single);
2064   if (err)
2065     goto leave;
2066
2067   err = scd_setattr ("KDF", kdf_data,
2068                      single ? OPENPGP_KDF_DATA_LENGTH_MIN
2069                      /* */  : OPENPGP_KDF_DATA_LENGTH_MAX);
2070   if (err)
2071     goto leave;
2072
2073   err = scd_getattr ("KDF", info);
2074
2075  leave:
2076   return err;
2077 }
2078
2079
2080 \f
2081 static void
2082 show_keysize_warning (void)
2083 {
2084   static int shown;
2085
2086   if (shown)
2087     return;
2088   shown = 1;
2089   tty_printf
2090     (_("Note: There is no guarantee that the card supports the requested\n"
2091        "      key type or size.  If the key generation does not succeed,\n"
2092        "      please check the documentation of your card to see which\n"
2093        "      key types and sizes are supported.\n")
2094      );
2095 }
2096
2097
2098 /* Ask for the size of a card key.  NBITS is the current size
2099  * configured for the card.  Returns 0 on success and stored the
2100  * chosen key size at R_KEYSIZE; 0 is stored to indicate that the
2101  * default size shall be used.  */
2102 static gpg_error_t
2103 ask_card_rsa_keysize (unsigned int nbits, unsigned int *r_keysize)
2104 {
2105   unsigned int min_nbits = 1024;
2106   unsigned int max_nbits = 4096;
2107   char*answer;
2108   unsigned int req_nbits;
2109
2110   for (;;)
2111     {
2112       answer = tty_getf (_("What keysize do you want? (%u) "), nbits);
2113       trim_spaces (answer);
2114       tty_kill_prompt ();
2115       if (*answer == CONTROL_D)
2116         {
2117           xfree (answer);
2118           return gpg_error (GPG_ERR_CANCELED);
2119         }
2120       req_nbits = *answer? atoi (answer): nbits;
2121       xfree (answer);
2122
2123       if (req_nbits != nbits && (req_nbits % 32) )
2124         {
2125           req_nbits = ((req_nbits + 31) / 32) * 32;
2126           tty_printf (_("rounded up to %u bits\n"), req_nbits);
2127         }
2128
2129       if (req_nbits == nbits)
2130         {
2131           /* Use default.  */
2132           *r_keysize = 0;
2133           return 0;
2134         }
2135
2136       if (req_nbits < min_nbits || req_nbits > max_nbits)
2137         {
2138           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
2139                       "RSA", min_nbits, max_nbits);
2140         }
2141       else
2142         {
2143           *r_keysize = req_nbits;
2144           return 0;
2145         }
2146     }
2147 }
2148
2149
2150 /* Ask for the key attribute of a card key.  CURRENT is the current
2151  * attribute configured for the card.  KEYNO is the number of the key
2152  * used to select the prompt.  Stores NULL at result to use the
2153  * default attribute or stores the selected attribute structure at
2154  * RESULT.  On error an error code is returned.  */
2155 static gpg_error_t
2156 ask_card_keyattr (int keyno, const struct key_attr *current,
2157                   struct key_attr **result)
2158 {
2159   gpg_error_t err;
2160   struct key_attr *key_attr = NULL;
2161   char *answer = NULL;
2162   int selection;
2163
2164   *result = NULL;
2165
2166   key_attr = xcalloc (1, sizeof *key_attr);
2167
2168   tty_printf (_("Changing card key attribute for: "));
2169   if (keyno == 0)
2170     tty_printf (_("Signature key\n"));
2171   else if (keyno == 1)
2172     tty_printf (_("Encryption key\n"));
2173   else
2174     tty_printf (_("Authentication key\n"));
2175
2176   tty_printf (_("Please select what kind of key you want:\n"));
2177   tty_printf (_("   (%d) RSA\n"), 1 );
2178   tty_printf (_("   (%d) ECC\n"), 2 );
2179
2180   for (;;)
2181     {
2182       xfree (answer);
2183       answer = tty_get (_("Your selection? "));
2184       trim_spaces (answer);
2185       tty_kill_prompt ();
2186       if (!*answer || *answer == CONTROL_D)
2187         {
2188           err = gpg_error (GPG_ERR_CANCELED);
2189           goto leave;
2190         }
2191       selection = *answer? atoi (answer) : 0;
2192
2193       if (selection == 1 || selection == 2)
2194         break;
2195       else
2196         tty_printf (_("Invalid selection.\n"));
2197     }
2198
2199
2200   if (selection == 1)
2201     {
2202       unsigned int nbits, result_nbits;
2203
2204       if (current->algo == PUBKEY_ALGO_RSA)
2205         nbits = current->nbits;
2206       else
2207         nbits = 2048;
2208
2209       err = ask_card_rsa_keysize (nbits, &result_nbits);
2210       if (err)
2211         goto leave;
2212       if (result_nbits == 0)
2213         {
2214           if (current->algo == PUBKEY_ALGO_RSA)
2215             {
2216               xfree (key_attr);
2217               key_attr = NULL;
2218             }
2219           else
2220             result_nbits = nbits;
2221         }
2222
2223       if (key_attr)
2224         {
2225           key_attr->algo = PUBKEY_ALGO_RSA;
2226           key_attr->nbits = result_nbits;
2227         }
2228     }
2229   else if (selection == 2)
2230     {
2231       const char *curve;
2232       /* const char *oid_str; */
2233       int algo;
2234
2235       if (current->algo == PUBKEY_ALGO_RSA)
2236         {
2237           if (keyno == 1) /* Encryption key */
2238             algo = PUBKEY_ALGO_ECDH;
2239           else /* Signature key or Authentication key */
2240             algo = PUBKEY_ALGO_ECDSA;
2241           curve = NULL;
2242         }
2243       else
2244         {
2245           algo = current->algo;
2246           curve = current->curve;
2247         }
2248
2249       err = GPG_ERR_NOT_IMPLEMENTED;
2250       goto leave;
2251       /* FIXME: We need to mve the ask_cure code out to common or
2252        * provide another sultion.  */
2253       /* curve = ask_curve (&algo, NULL, curve); */
2254       /* if (curve) */
2255       /*   { */
2256       /*     key_attr->algo = algo; */
2257       /*     oid_str = openpgp_curve_to_oid (curve, NULL); */
2258       /*     key_attr->curve = openpgp_oid_to_curve (oid_str, 0); */
2259       /*   } */
2260       /* else */
2261       /*   { */
2262       /*     xfree (key_attr); */
2263       /*     key_attr = NULL; */
2264       /*   } */
2265     }
2266   else
2267     {
2268       err = gpg_error (GPG_ERR_BUG);
2269       goto leave;
2270     }
2271
2272   /* Tell the user what we are going to do.  */
2273   if (key_attr->algo == PUBKEY_ALGO_RSA)
2274     {
2275       tty_printf (_("The card will now be re-configured"
2276                     " to generate a key of %u bits\n"), key_attr->nbits);
2277     }
2278   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2279            || key_attr->algo == PUBKEY_ALGO_ECDSA
2280            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2281     {
2282       tty_printf (_("The card will now be re-configured"
2283                     " to generate a key of type: %s\n"), key_attr->curve);
2284     }
2285   show_keysize_warning ();
2286
2287   *result = key_attr;
2288   key_attr = NULL;
2289
2290  leave:
2291   xfree (key_attr);
2292   xfree (answer);
2293   return err;
2294 }
2295
2296
2297 /* Change the key attribute of key KEYNO (0..2) and show an error
2298  * message if that fails.  */
2299 static gpg_error_t
2300 do_change_keyattr (int keyno, const struct key_attr *key_attr)
2301 {
2302   gpg_error_t err = 0;
2303   char args[100];
2304
2305   if (key_attr->algo == PUBKEY_ALGO_RSA)
2306     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
2307               key_attr->nbits);
2308   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2309            || key_attr->algo == PUBKEY_ALGO_ECDSA
2310            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2311     snprintf (args, sizeof args, "--force %d %d %s",
2312               keyno+1, key_attr->algo, key_attr->curve);
2313   else
2314     {
2315       /* FIXME: Above we use opnepgp algo names but in the error
2316        * message we use the gcrypt names.  We should settle for a
2317        * consistent solution. */
2318       log_error (_("public key algorithm %d (%s) is not supported\n"),
2319                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
2320       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2321       goto leave;
2322     }
2323
2324   err = scd_setattr ("KEY-ATTR", args, strlen (args));
2325   if (err)
2326     log_error (_("error changing key attribute for key %d: %s\n"),
2327                keyno+1, gpg_strerror (err));
2328  leave:
2329   return err;
2330 }
2331
2332
2333 static gpg_error_t
2334 cmd_keyattr (card_info_t info, char *argstr)
2335 {
2336   gpg_error_t err = 0;
2337   int keyno;
2338   struct key_attr *key_attr = NULL;
2339
2340   (void)argstr;
2341
2342   if (!info)
2343     return print_help
2344       ("KEY-ATTR\n\n"
2345        "Menu to change the key attributes of an OpenPGP card.",
2346        APP_TYPE_OPENPGP, 0);
2347
2348   if (info->apptype != APP_TYPE_OPENPGP)
2349     {
2350       log_info ("Note: This is an OpenPGP only command.\n");
2351       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2352     }
2353
2354   if (!(info->is_v2 && info->extcap.aac))
2355     {
2356       log_error (_("This command is not supported by this card\n"));
2357       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2358       goto leave;
2359     }
2360
2361   for (keyno = 0; keyno < DIM (info->key_attr); keyno++)
2362     {
2363       xfree (key_attr);
2364       key_attr = NULL;
2365       err = ask_card_keyattr (keyno, &info->key_attr[keyno], &key_attr);
2366       if (err)
2367         goto leave;
2368
2369       err = do_change_keyattr (keyno, key_attr);
2370       if (err)
2371         {
2372           /* Error: Better read the default key attribute again.  */
2373           log_debug ("FIXME\n");
2374           /* Ask again for this key. */
2375           keyno--;
2376         }
2377     }
2378
2379  leave:
2380   xfree (key_attr);
2381   return err;
2382 }
2383
2384
2385 static gpg_error_t
2386 cmd_uif (card_info_t info, char *argstr)
2387 {
2388   gpg_error_t err;
2389   int keyno;
2390
2391   if (!info)
2392     return print_help
2393       ("UIF N [on|off|permanent]\n\n"
2394        "Change the User Interaction Flag.  N must in the range 1 to 3.",
2395        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2396
2397   argstr = skip_options (argstr);
2398
2399   if (digitp (argstr))
2400     {
2401       keyno = atoi (argstr);
2402       while (digitp (argstr))
2403         argstr++;
2404       while (spacep (argstr))
2405         argstr++;
2406     }
2407   else
2408     keyno = 0;
2409
2410   if (keyno < 1 || keyno > 3)
2411     {
2412       err = gpg_error (GPG_ERR_INV_ARG);
2413       goto leave;
2414     }
2415
2416
2417   err = GPG_ERR_NOT_IMPLEMENTED;
2418
2419  leave:
2420   return err;
2421 }
2422
2423
2424 \f
2425 /* Data used by the command parser.  This needs to be outside of the
2426  * function scope to allow readline based command completion.  */
2427 enum cmdids
2428   {
2429     cmdNOP = 0,
2430     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdRESET, cmdVERIFY,
2431     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSALUT, cmdCAFPR,
2432     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2433     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2434     cmdKEYATTR, cmdUIF,
2435     cmdINVCMD
2436   };
2437
2438 static struct
2439 {
2440   const char *name;
2441   enum cmdids id;
2442   int admin_only;
2443   const char *desc;
2444 } cmds[] = {
2445   { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2446   { "q"       , cmdQUIT  , 0, NULL },
2447   { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2448   { "help"    , cmdHELP  , 0, N_("show this help")},
2449   { "?"       , cmdHELP  , 0, NULL },
2450   { "list"    , cmdLIST  , 0, N_("list all available data")},
2451   { "l"       , cmdLIST  , 0, NULL },
2452   { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2453   { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2454   { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2455   { "login"   , cmdLOGIN , 1, N_("change the login name")},
2456   { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2457   { "salutation",cmdSALUT, 1, N_("change card holder's salutation")},
2458   { "salut"   , cmdSALUT,  1, NULL },
2459   { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2460   { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2461   { "generate", cmdGENERATE, 1, N_("generate new keys")},
2462   { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2463   { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2464   { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
2465   { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2466   { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2467   { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2468   { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
2469   /* Note, that we do not announce these command yet. */
2470   { "privatedo", cmdPRIVATEDO, 0, N_("change a private data object")},
2471   { "readcert",  cmdREADCERT,  0, N_("read a certificate from a data object")},
2472   { "writecert", cmdWRITECERT, 1, N_("store a certificate to a data object")},
2473   { NULL, cmdINVCMD, 0, NULL }
2474 };
2475
2476
2477 /* The main loop.  */
2478 static void
2479 interactive_loop (void)
2480 {
2481   gpg_error_t err;
2482   char *answer = NULL;         /* The input line.  */
2483   enum cmdids cmd = cmdNOP;    /* The command.  */
2484   int cmd_admin_only;          /* The command is an admin only command.  */
2485   char *argstr;                /* The argument as a string.  */
2486   int redisplay = 1;           /* Whether to redisplay the main info.  */
2487   int allow_admin = 0;         /* Whether admin commands are allowed.  */
2488   char *help_arg = NULL;       /* Argument of the HELP command.         */
2489   struct card_info_s info_buffer;
2490   card_info_t info = &info_buffer;
2491   char *p;
2492   int i;
2493
2494   /* In the interactive mode we do not want to print the program prefix.  */
2495   log_set_prefix (NULL, 0);
2496
2497   for (;;)
2498     {
2499       if (help_arg)
2500         {
2501           /* Clear info to indicate helpmode */
2502           info = NULL;
2503         }
2504       else if (!info)
2505         {
2506           /* Get out of help.  */
2507           info = &info_buffer;
2508           help_arg = NULL;
2509           redisplay = 0;
2510         }
2511       else if (redisplay)
2512         {
2513           err = scd_learn (info);
2514           if (err)
2515             {
2516               log_error ("Error reading card: %s\n", gpg_strerror (err));
2517             }
2518           else
2519             {
2520               list_card (info);
2521               tty_printf("\n");
2522               redisplay = 0;
2523             }
2524         }
2525
2526       if (!info)
2527         {
2528           /* Copy the pending help arg into our answer.  Noe that
2529            * help_arg points into answer.  */
2530           p = xstrdup (help_arg);
2531           help_arg = NULL;
2532           xfree (answer);
2533           answer = p;
2534         }
2535       else
2536         {
2537           do
2538             {
2539               xfree (answer);
2540               tty_enable_completion (command_completion);
2541               answer = tty_get (_("gpg/card> "));
2542               tty_kill_prompt();
2543               tty_disable_completion ();
2544               trim_spaces(answer);
2545             }
2546           while ( *answer == '#' );
2547         }
2548
2549       argstr = NULL;
2550       cmd_admin_only = 0;
2551       if (!*answer)
2552         cmd = cmdLIST; /* We default to the list command */
2553       else if (*answer == CONTROL_D)
2554         cmd = cmdQUIT;
2555       else
2556         {
2557           if ((argstr = strchr (answer,' ')))
2558             {
2559               *argstr++ = 0;
2560               trim_spaces (answer);
2561               trim_spaces (argstr);
2562             }
2563
2564           for (i=0; cmds[i].name; i++ )
2565             if (!ascii_strcasecmp (answer, cmds[i].name ))
2566               break;
2567
2568           cmd = cmds[i].id;
2569           cmd_admin_only = cmds[i].admin_only;
2570         }
2571
2572       /* Make sure we have valid strings for the args.  They are
2573        * allowed to be modifed and must thus point to a buffer.  */
2574       if (!argstr)
2575         argstr = answer + strlen (answer);
2576
2577       if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP))
2578         {
2579           /* If redisplay is set we know that there was an error reading
2580            * the card.  In this case we force a LIST command to retry.  */
2581           if (!info)
2582             ; /* In help mode.  */
2583           else if (redisplay)
2584             {
2585               cmd = cmdLIST;
2586               cmd_admin_only = 0;
2587             }
2588           else if (!info->serialno)
2589             {
2590               /* Without a serial number most commands won't work.
2591                * Catch it here.  */
2592               tty_printf ("\n");
2593               tty_printf ("Serial number missing\n");
2594               continue;
2595             }
2596           else if (!allow_admin && cmd_admin_only)
2597             {
2598               tty_printf ("\n");
2599               tty_printf (_("Admin-only command\n"));
2600               continue;
2601             }
2602         }
2603
2604       err = 0;
2605       switch (cmd)
2606         {
2607         case cmdNOP:
2608           if (!info)
2609             print_help ("NOP\n\n"
2610                         "Dummy command.", 0);
2611           break;
2612
2613         case cmdQUIT:
2614           if (!info)
2615             print_help ("QUIT\n\n"
2616                         "Leave this tool.", 0);
2617           else
2618             {
2619               tty_printf ("\n");
2620               goto leave;
2621             }
2622           break;
2623
2624         case cmdHELP:
2625           if (!info)
2626             print_help ("HELP [command]\n\n"
2627                         "Show all commands.  With an argument show help\n"
2628                         "for that command.", 0);
2629           else if (*argstr)
2630             help_arg = argstr; /* Trigger help for a command.  */
2631           else
2632             {
2633               tty_printf
2634                 ("List of commands (\"help <command>\" for details):\n");
2635               for (i=0; cmds[i].name; i++ )
2636                 if(cmds[i].desc
2637                    && (!cmds[i].admin_only
2638                        || (cmds[i].admin_only && allow_admin)))
2639                   tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2640             }
2641           break;
2642
2643         case cmdLIST:
2644           if (!info)
2645             print_help ("LIST\n\n"
2646                         "Show content of the card.", 0);
2647           else
2648             {
2649               /* Actual work is done by the redisplay code block.  */
2650               redisplay = 1;
2651             }
2652           break;
2653
2654         case cmdRESET:
2655           if (!info)
2656             print_help ("RESET\n\n"
2657                         "Send a RESET to the card daemon.", 0);
2658           else
2659             {
2660               err = scd_apdu (NULL, NULL);
2661             }
2662           break;
2663
2664         case cmdADMIN:
2665           if ( !strcmp (argstr, "on") )
2666             allow_admin = 1;
2667           else if ( !strcmp (argstr, "off") )
2668             allow_admin = 0;
2669           else if ( !strcmp (argstr, "verify") )
2670             {
2671               /* Force verification of the Admin Command.  However,
2672                  this is only done if the retry counter is at initial
2673                  state.  */
2674               /* FIXME: Must depend on the type of the card.  */
2675               /* char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1); */
2676               /* strcpy (stpcpy (tmp, serialnobuf), "[CHV3]"); */
2677               /* allow_admin = !agent_scd_checkpin (tmp); */
2678               /* xfree (tmp); */
2679             }
2680           else /* Toggle. */
2681             allow_admin=!allow_admin;
2682           if(allow_admin)
2683             tty_printf(_("Admin commands are allowed\n"));
2684           else
2685             tty_printf(_("Admin commands are not allowed\n"));
2686           break;
2687
2688         case cmdVERIFY:
2689           err = cmd_verify (info, argstr);
2690           if (!err)
2691             redisplay = 1;
2692           break;
2693         case cmdNAME:      err = cmd_name (info, argstr); break;
2694         case cmdURL:       err = cmd_url (info, argstr);  break;
2695         case cmdFETCH:     err = cmd_fetch (info);  break;
2696         case cmdLOGIN:     err = cmd_login (info, argstr); break;
2697         case cmdLANG:      err = cmd_lang (info, argstr); break;
2698         case cmdSALUT:     err = cmd_salut (info, argstr); break;
2699         case cmdCAFPR:     err = cmd_cafpr (info, argstr); break;
2700         case cmdPRIVATEDO: err = cmd_privatedo (info, argstr); break;
2701         case cmdWRITECERT: err = cmd_writecert (info, argstr); break;
2702         case cmdREADCERT:  err = cmd_readcert (info, argstr); break;
2703         case cmdFORCESIG:  err = cmd_forcesig (info); break;
2704         case cmdGENERATE:  err = cmd_generate (info); break;
2705         case cmdPASSWD:    err = cmd_passwd (info, allow_admin); break;
2706         case cmdUNBLOCK:   err = cmd_unblock (info); break;
2707         case cmdFACTORYRESET:
2708           err = cmd_factoryreset (info);
2709           if (!err)
2710             redisplay = 1;
2711           break;
2712         case cmdKDFSETUP:  err = cmd_kdfsetup (info, argstr); break;
2713         case cmdKEYATTR:   err = cmd_keyattr (info, argstr); break;
2714         case cmdUIF:       err = cmd_uif (info, argstr); break;
2715
2716         case cmdINVCMD:
2717         default:
2718           tty_printf ("\n");
2719           tty_printf (_("Invalid command  (try \"help\")\n"));
2720           break;
2721         } /* End command switch. */
2722
2723       if (gpg_err_code (err) == GPG_ERR_CANCELED)
2724         tty_fprintf (NULL, "\n");
2725       else if (err)
2726         {
2727           const char *s = "?";
2728           for (i=0; cmds[i].name; i++ )
2729             if (cmd == cmds[i].id)
2730               {
2731                 s = cmds[i].name;
2732                 break;
2733               }
2734           log_error ("Command '%s' failed: %s\n", s, gpg_strerror (err));
2735         }
2736
2737     } /* End of main menu loop. */
2738
2739  leave:
2740   release_card_info (info);
2741   xfree (answer);
2742 }
2743
2744 #ifdef HAVE_LIBREADLINE
2745 /* Helper function for readline's command completion. */
2746 static char *
2747 command_generator (const char *text, int state)
2748 {
2749   static int list_index, len;
2750   const char *name;
2751
2752   /* If this is a new word to complete, initialize now.  This includes
2753    * saving the length of TEXT for efficiency, and initializing the
2754    index variable to 0. */
2755   if (!state)
2756     {
2757       list_index = 0;
2758       len = strlen(text);
2759     }
2760
2761   /* Return the next partial match */
2762   while ((name = cmds[list_index].name))
2763     {
2764       /* Only complete commands that have help text. */
2765       if (cmds[list_index++].desc && !strncmp (name, text, len))
2766         return strdup(name);
2767     }
2768
2769   return NULL;
2770 }
2771
2772 /* Second helper function for readline's command completion.  */
2773 static char **
2774 command_completion (const char *text, int start, int end)
2775 {
2776   (void)end;
2777
2778   /* If we are at the start of a line, we try and command-complete.
2779    * If not, just do nothing for now. */
2780   if (!start)
2781     return rl_completion_matches (text, command_generator);
2782
2783   rl_attempted_completion_over = 1;
2784
2785   return NULL;
2786 }
2787 #endif /*HAVE_LIBREADLINE*/