5ba44fcbb2bde73015c928ea9e3753418454be22
[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->chvinfo[0], info->chvinfo[1], info->chvinfo[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 /* List PIV card specific data.  */
762 static void
763 list_piv (card_info_t info, estream_t fp)
764 {
765   static struct keyinfolabel_s keyinfolabels[] = {
766     { "PIV Authentication:", "PIV.9A" },
767     { "Card Authenticat. :", "PIV.9E" },
768     { "Digital Signature :", "PIV.9C" },
769     { "Key Management ...:", "PIV.9D" },
770     { NULL, NULL }
771   };
772   const char *s;
773   int i;
774
775   tty_fprintf (fp, "PIN retry counter :");
776   for (i=0; i < DIM (info->chvinfo); i++)
777     {
778       if (info->chvinfo[i] > 0)
779         tty_fprintf (fp, " %d", info->chvinfo[i]);
780       else
781         {
782           switch (info->chvinfo[i])
783             {
784             case -1: s = "[error]"; break;
785             case -2: s = "-"; break;  /* No such PIN */
786             case -3: s = "[blocked]"; break;
787             case -5: s = "[verified]"; break;
788             default: s = "[?]"; break;
789             }
790           tty_fprintf (fp, " %s", s);
791         }
792     }
793   tty_fprintf (fp, "\n", s);
794   list_all_kinfo (info, keyinfolabels, fp);
795
796 }
797
798
799 /* Print all available information about the current card. */
800 static void
801 list_card (card_info_t info)
802 {
803   estream_t fp = NULL;
804
805   tty_fprintf (fp, "Reader ...........: %s\n",
806                info->reader? info->reader : "[none]");
807   tty_fprintf (fp, "Serial number ....: %s\n",
808                info->serialno? info->serialno : "[none]");
809   tty_fprintf (fp, "Application Type .: %s%s%s%s\n",
810                app_type_string (info->apptype),
811                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? "(":"",
812                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr
813                ? info->apptypestr:"",
814                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? ")":"");
815   if (info->serialno && info->dispserialno
816       && strcmp (info->serialno, info->dispserialno))
817     tty_fprintf (fp, "Displayed S/N ....: %s\n", info->dispserialno);
818
819   switch (info->apptype)
820     {
821     case APP_TYPE_OPENPGP: list_openpgp (info, fp); break;
822     case APP_TYPE_PIV:     list_piv (info, fp); break;
823     default: break;
824     }
825 }
826
827
828 \f
829 /* The VERIFY command.  */
830 static gpg_error_t
831 cmd_verify (card_info_t info, char *argstr)
832 {
833   gpg_error_t err;
834
835   if (!info)
836     return print_help ("verify [chvid]", 0);
837
838   if (info->apptype == APP_TYPE_OPENPGP)
839     err = scd_checkpin (info->serialno);
840   else
841     err = scd_checkpin (argstr);
842
843   if (err)
844     log_error ("verify failed: %s <%s>\n",
845                gpg_strerror (err), gpg_strsource (err));
846   return err;
847 }
848
849
850 /* Helper for cmd_name to qyery a part of name.  */
851 static char *
852 ask_one_name (const char *prompt)
853 {
854   char *name;
855   int i;
856
857   for (;;)
858     {
859       name = tty_get (prompt);
860       trim_spaces (name);
861       tty_kill_prompt ();
862       if (!*name || *name == CONTROL_D)
863         {
864           if (*name == CONTROL_D)
865             tty_fprintf (NULL, "\n");
866           xfree (name);
867           return NULL;
868         }
869       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
870         ;
871
872       /* The name must be in Latin-1 and not UTF-8 - lacking the code
873        * to ensure this we restrict it to ASCII. */
874       if (name[i])
875         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
876       else if (strchr (name, '<'))
877         tty_printf (_("Error: The \"<\" character may not be used.\n"));
878       else if (strstr (name, "  "))
879         tty_printf (_("Error: Double spaces are not allowed.\n"));
880       else
881         return name;
882       xfree (name);
883     }
884 }
885
886
887 /* The NAME command.  */
888 static gpg_error_t
889 cmd_name (card_info_t info, const char *argstr)
890 {
891   gpg_error_t err;
892   char *surname, *givenname;
893   char *isoname, *p;
894
895   if (!info)
896     return print_help
897       ("name [--clear]\n\n"
898        "Set the name field of an OpenPGP card.  With --clear the stored\n"
899        "name is cleared off the card.", APP_TYPE_OPENPGP, APP_TYPE_NKS, 0);
900
901   if (info->apptype != APP_TYPE_OPENPGP)
902     {
903       log_info ("Note: This is an OpenPGP only command.\n");
904       return gpg_error (GPG_ERR_NOT_SUPPORTED);
905     }
906
907  again:
908   if (!strcmp (argstr, "--clear"))
909     isoname = xstrdup (" "); /* No real way to clear; set to space instead. */
910   else
911     {
912       surname = ask_one_name (_("Cardholder's surname: "));
913       givenname = ask_one_name (_("Cardholder's given name: "));
914       if (!surname || !givenname || (!*surname && !*givenname))
915         {
916           xfree (surname);
917           xfree (givenname);
918           return gpg_error (GPG_ERR_CANCELED);
919         }
920
921       isoname = xstrconcat (surname, "<<", givenname, NULL);
922       xfree (surname);
923       xfree (givenname);
924       for (p=isoname; *p; p++)
925         if (*p == ' ')
926           *p = '<';
927
928       if (strlen (isoname) > 39 )
929         {
930           log_info (_("Error: Combined name too long "
931                       "(limit is %d characters).\n"), 39);
932           xfree (isoname);
933           goto again;
934         }
935     }
936
937   err = scd_setattr ("DISP-NAME", isoname, strlen (isoname));
938
939   xfree (isoname);
940   return err;
941 }
942
943
944 static gpg_error_t
945 cmd_url (card_info_t info, const char *argstr)
946 {
947   gpg_error_t err;
948   char *url;
949
950   if (!info)
951     return print_help
952       ("URL [--clear]\n\n"
953        "Set the URL data object.  That data object can be used by\n"
954        "the FETCH command to retrieve the full public key.  The\n"
955        "option --clear deletes the content of that data object.",
956        APP_TYPE_OPENPGP, 0);
957
958   if (info->apptype != APP_TYPE_OPENPGP)
959     {
960       log_info ("Note: This is an OpenPGP only command.\n");
961       return gpg_error (GPG_ERR_NOT_SUPPORTED);
962     }
963
964   if (!strcmp (argstr, "--clear"))
965     url = xstrdup (" "); /* No real way to clear; set to space instead. */
966   else
967     {
968       url = tty_get (_("URL to retrieve public key: "));
969       trim_spaces (url);
970       tty_kill_prompt ();
971       if (!*url || *url == CONTROL_D)
972         {
973           err = gpg_error (GPG_ERR_CANCELED);
974           goto leave;
975         }
976     }
977
978   err = scd_setattr ("PUBKEY-URL", url, strlen (url));
979
980  leave:
981   xfree (url);
982   return err;
983 }
984
985
986 /* Fetch the key from the URL given on the card or try to get it from
987  * the default keyserver.  */
988 static gpg_error_t
989 cmd_fetch (card_info_t info)
990 {
991   gpg_error_t err;
992   key_info_t kinfo;
993
994   if (!info)
995     return print_help
996       ("FETCH\n\n"
997        "Retrieve a key using the URL data object or if that is missing\n"
998        "using the fingerprint.", APP_TYPE_OPENPGP, 0);
999
1000   if (info->pubkey_url && *info->pubkey_url)
1001     {
1002       /* strlist_t sl = NULL; */
1003
1004       /* add_to_strlist (&sl, info.pubkey_url); */
1005       /* err = keyserver_fetch (ctrl, sl, KEYORG_URL); */
1006       /* free_strlist (sl); */
1007       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1008     }
1009   else if ((kinfo = find_kinfo (info, "OPENPGP.1")) && kinfo->fprlen)
1010     {
1011       /* rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len, */
1012       /*                               opt.keyserver, 0); */
1013       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1014     }
1015   else
1016     err = gpg_error (GPG_ERR_NO_DATA);
1017
1018   return err;
1019 }
1020
1021
1022 static gpg_error_t
1023 cmd_login (card_info_t info, char *argstr)
1024 {
1025   gpg_error_t err;
1026   char *data;
1027   size_t datalen;
1028
1029   if (!info)
1030     return print_help
1031       ("LOGIN [--clear] [< FILE]\n\n"
1032        "Set the login data object.  If FILE is given the data is\n"
1033        "is read from that file.  This allows for binary data.\n"
1034        "The option --clear deletes the login data.",
1035        APP_TYPE_OPENPGP, 0);
1036
1037   if (!strcmp (argstr, "--clear"))
1038     {
1039       data = xstrdup (" "); /* kludge.  */
1040       datalen = 1;
1041     }
1042   else if (*argstr == '<')  /* Read it from a file */
1043     {
1044       for (argstr++; spacep (argstr); argstr++)
1045         ;
1046       err = get_data_from_file (argstr, &data, &datalen);
1047       if (err)
1048         goto leave;
1049     }
1050   else
1051     {
1052       data = tty_get (_("Login data (account name): "));
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       datalen = strlen (data);
1061     }
1062
1063   err = scd_setattr ("LOGIN-DATA", data, datalen);
1064
1065  leave:
1066   xfree (data);
1067   return err;
1068 }
1069
1070
1071 static gpg_error_t
1072 cmd_lang (card_info_t info, const char *argstr)
1073 {
1074   gpg_error_t err;
1075   char *data, *p;
1076
1077   if (!info)
1078     return print_help
1079       ("LANG [--clear]\n\n"
1080        "Change the language info for the card.  This info can be used\n"
1081        "by applications for a personalized greeting.  Up to 4 two-digit\n"
1082        "language identifiers can be entered as a preference.  The option\n"
1083        "--clear removes all identifiers.  GnuPG does not use this info.",
1084        APP_TYPE_OPENPGP, 0);
1085
1086   if (!strcmp (argstr, "--clear"))
1087     data = xstrdup ("  "); /* Note that we need two spaces here.  */
1088   else
1089     {
1090     again:
1091       data = tty_get (_("Language preferences: "));
1092       trim_spaces (data);
1093       tty_kill_prompt ();
1094       if (!*data || *data == CONTROL_D)
1095         {
1096           err = gpg_error (GPG_ERR_CANCELED);
1097           goto leave;
1098         }
1099
1100       if (strlen (data) > 8 || (strlen (data) & 1))
1101         {
1102           log_info (_("Error: invalid length of preference string.\n"));
1103           xfree (data);
1104           goto again;
1105         }
1106
1107       for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1108         ;
1109       if (*p)
1110         {
1111           log_info (_("Error: invalid characters in preference string.\n"));
1112           xfree (data);
1113           goto again;
1114         }
1115     }
1116
1117   err = scd_setattr ("DISP-LANG", data, strlen (data));
1118
1119  leave:
1120   xfree (data);
1121   return err;
1122 }
1123
1124
1125 static gpg_error_t
1126 cmd_salut (card_info_t info, const char *argstr)
1127 {
1128   gpg_error_t err;
1129   char *data = NULL;
1130   const char *str;
1131
1132   if (!info)
1133     return print_help
1134       ("SALUT [--clear]\n\n"
1135        "Change the salutation info for the card.  This info can be used\n"
1136        "by applications for a personalized greeting.  The option --clear\n"
1137        "removes this data object.  GnuPG does not use this info.",
1138        APP_TYPE_OPENPGP, 0);
1139
1140  again:
1141   if (!strcmp (argstr, "--clear"))
1142     str = "9";
1143   else
1144     {
1145       data = tty_get (_("Salutation (M = Mr., F = Mrs., or space): "));
1146       trim_spaces (data);
1147       tty_kill_prompt ();
1148       if (*data == CONTROL_D)
1149         {
1150           err = gpg_error (GPG_ERR_CANCELED);
1151           goto leave;
1152         }
1153
1154       if (!*data)
1155         str = "9";
1156       else if ((*data == 'M' || *data == 'm') && !data[1])
1157         str = "1";
1158       else if ((*data == 'F' || *data == 'f') && !data[1])
1159         str = "2";
1160       else
1161         {
1162           tty_printf (_("Error: invalid response.\n"));
1163           xfree (data);
1164           goto again;
1165         }
1166     }
1167
1168   err = scd_setattr ("DISP-SEX", str, 1);
1169  leave:
1170   xfree (data);
1171   return err;
1172 }
1173
1174
1175 static gpg_error_t
1176 cmd_cafpr (card_info_t info, char *argstr)
1177 {
1178   gpg_error_t err;
1179   char *data = NULL;
1180   const char *s;
1181   int i, c;
1182   unsigned char fpr[32];
1183   int fprlen;
1184   int fprno;
1185   int opt_clear = 0;
1186
1187   if (!info)
1188     return print_help
1189       ("CAFPR [--clear] N\n\n"
1190        "Change the CA fingerprint number N.  N must be in the\n"
1191        "range 1 to 3.  The option --clear clears the specified\n"
1192        "CA fingerprint N or all of them if N is 0 or not given.",
1193        APP_TYPE_OPENPGP, 0);
1194
1195
1196   opt_clear = has_leading_option (argstr, "--clear");
1197   argstr = skip_options (argstr);
1198
1199   if (digitp (argstr))
1200     {
1201       fprno = atoi (argstr);
1202       while (digitp (argstr))
1203         argstr++;
1204       while (spacep (argstr))
1205         argstr++;
1206     }
1207   else
1208     fprno = 0;
1209
1210   if (opt_clear && !fprno)
1211     ; /* Okay: clear all fprs.  */
1212   else if (fprno < 1 || fprno > 3)
1213     {
1214       err = gpg_error (GPG_ERR_INV_ARG);
1215       goto leave;
1216     }
1217
1218  again:
1219   if (opt_clear)
1220     {
1221       memset (fpr, 0, 20);
1222       fprlen = 20;
1223     }
1224   else
1225     {
1226       xfree (data);
1227       data = tty_get (_("CA fingerprint: "));
1228       trim_spaces (data);
1229       tty_kill_prompt ();
1230       if (!*data || *data == CONTROL_D)
1231         {
1232           err = gpg_error (GPG_ERR_CANCELED);
1233           goto leave;
1234         }
1235
1236       for (i=0, s=data; i < sizeof fpr && *s; )
1237         {
1238           while (spacep(s))
1239             s++;
1240           if (*s == ':')
1241             s++;
1242           while (spacep(s))
1243             s++;
1244           c = hextobyte (s);
1245           if (c == -1)
1246             break;
1247           fpr[i++] = c;
1248           s += 2;
1249         }
1250       fprlen = i;
1251       if ((fprlen != 20 && fprlen != 32) || *s)
1252         {
1253           log_error (_("Error: invalid formatted fingerprint.\n"));
1254           goto again;
1255         }
1256     }
1257
1258   if (!fprno)
1259     {
1260       log_assert (opt_clear);
1261       err = scd_setattr ("CA-FPR-1", fpr, fprlen);
1262       if (!err)
1263         err = scd_setattr ("CA-FPR-2", fpr, fprlen);
1264       if (!err)
1265         err = scd_setattr ("CA-FPR-3", fpr, fprlen);
1266     }
1267   else
1268     err = scd_setattr (fprno==1?"CA-FPR-1":
1269                        fprno==2?"CA-FPR-2":
1270                        fprno==3?"CA-FPR-3":"x", fpr, fprlen);
1271
1272  leave:
1273   xfree (data);
1274   return err;
1275 }
1276
1277
1278 static gpg_error_t
1279 cmd_privatedo (card_info_t info, char *argstr)
1280 {
1281   gpg_error_t err;
1282   int opt_clear;
1283   char *do_name = NULL;
1284   char *data = NULL;
1285   size_t datalen;
1286   int do_no;
1287
1288   if (!info)
1289     return print_help
1290       ("PRIVATEDO [--clear] N [< FILE]\n\n"
1291        "Change the private data object N.  N must be in the\n"
1292        "range 1 to 4.  If FILE is given the data is is read\n"
1293        "from that file.  The option --clear clears the data.",
1294        APP_TYPE_OPENPGP, 0);
1295
1296   opt_clear = has_leading_option (argstr, "--clear");
1297   argstr = skip_options (argstr);
1298
1299   if (digitp (argstr))
1300     {
1301       do_no = atoi (argstr);
1302       while (digitp (argstr))
1303         argstr++;
1304       while (spacep (argstr))
1305         argstr++;
1306     }
1307   else
1308     do_no = 0;
1309
1310   if (do_no < 1 || do_no > 4)
1311     {
1312       err = gpg_error (GPG_ERR_INV_ARG);
1313       goto leave;
1314     }
1315   do_name = xasprintf ("PRIVATE-DO-%d", do_no);
1316
1317   if (opt_clear)
1318     {
1319       data = xstrdup (" ");
1320       datalen = 1;
1321     }
1322   else if (*argstr == '<')  /* Read it from a file */
1323     {
1324       for (argstr++; spacep (argstr); argstr++)
1325         ;
1326       err = get_data_from_file (argstr, &data, &datalen);
1327       if (err)
1328         goto leave;
1329     }
1330   else if (*argstr)
1331     {
1332       err = gpg_error (GPG_ERR_INV_ARG);
1333       goto leave;
1334     }
1335   else
1336     {
1337       data = tty_get (_("Private DO data: "));
1338       trim_spaces (data);
1339       tty_kill_prompt ();
1340       datalen = strlen (data);
1341       if (!*data || *data == CONTROL_D)
1342         {
1343           err = gpg_error (GPG_ERR_CANCELED);
1344           goto leave;
1345         }
1346     }
1347
1348   err = scd_setattr (do_name, data, datalen);
1349
1350  leave:
1351   xfree (do_name);
1352   xfree (data);
1353   return err;
1354 }
1355
1356
1357 static gpg_error_t
1358 cmd_writecert (card_info_t info, char *argstr)
1359 {
1360   gpg_error_t err;
1361   int opt_clear;
1362   int do_no;
1363   char *data = NULL;
1364   size_t datalen;
1365
1366   if (!info)
1367     return print_help
1368       ("WRITECERT [--clear] 3 < FILE\n\n"
1369        "Write a certificate for key 3.  Unless --clear is given\n"
1370        "the file argement is mandatory.  The option --clear removes\n"
1371        "the certificate from the card.",
1372        APP_TYPE_OPENPGP, 0);
1373
1374   opt_clear = has_leading_option (argstr, "--clear");
1375   argstr = skip_options (argstr);
1376
1377   if (digitp (argstr))
1378     {
1379       do_no = atoi (argstr);
1380       while (digitp (argstr))
1381         argstr++;
1382       while (spacep (argstr))
1383         argstr++;
1384     }
1385   else
1386     do_no = 0;
1387
1388   if (do_no != 3)
1389     {
1390       err = gpg_error (GPG_ERR_INV_ARG);
1391       goto leave;
1392     }
1393
1394   if (opt_clear)
1395     {
1396       data = xstrdup (" ");
1397       datalen = 1;
1398     }
1399   else if (*argstr == '<')  /* Read it from a file */
1400     {
1401       for (argstr++; spacep (argstr); argstr++)
1402         ;
1403       err = get_data_from_file (argstr, &data, &datalen);
1404       if (err)
1405         goto leave;
1406     }
1407   else
1408     {
1409       err = gpg_error (GPG_ERR_INV_ARG);
1410       goto leave;
1411     }
1412
1413   err = scd_writecert ("OPENPGP.3", data, datalen);
1414
1415  leave:
1416   xfree (data);
1417   return err;
1418 }
1419
1420
1421 static gpg_error_t
1422 cmd_readcert (card_info_t info, char *argstr)
1423 {
1424   gpg_error_t err;
1425   int do_no;
1426   void *data = NULL;
1427   size_t datalen;
1428   const char *fname;
1429
1430   if (!info)
1431     return print_help
1432       ("READCERT 3 > FILE\n\n"
1433        "Read the certificate for key 3 and store it in FILE.",
1434        APP_TYPE_OPENPGP, 0);
1435
1436   argstr = skip_options (argstr);
1437
1438   if (digitp (argstr))
1439     {
1440       do_no = atoi (argstr);
1441       while (digitp (argstr))
1442         argstr++;
1443       while (spacep (argstr))
1444         argstr++;
1445     }
1446   else
1447     do_no = 0;
1448
1449   if (do_no != 3)
1450     {
1451       err = gpg_error (GPG_ERR_INV_ARG);
1452       goto leave;
1453     }
1454
1455   if (*argstr == '>')  /* Read it from a file */
1456     {
1457       for (argstr++; spacep (argstr); argstr++)
1458         ;
1459       fname = argstr;
1460     }
1461   else
1462     {
1463       err = gpg_error (GPG_ERR_INV_ARG);
1464       goto leave;
1465     }
1466
1467   err = scd_readcert ("OPENPGP.3", &data, &datalen);
1468   if (err)
1469     goto leave;
1470
1471   err = put_data_to_file (fname, data, datalen);
1472
1473  leave:
1474   xfree (data);
1475   return err;
1476 }
1477
1478
1479 static gpg_error_t
1480 cmd_forcesig (card_info_t info)
1481 {
1482   gpg_error_t err;
1483   int newstate;
1484
1485   if (!info)
1486     return print_help
1487       ("FORCESIG\n\n"
1488        "Toggle the forcesig flag of an OpenPGP card.",
1489        APP_TYPE_OPENPGP, 0);
1490
1491   if (info->apptype != APP_TYPE_OPENPGP)
1492     {
1493       log_info ("Note: This is an OpenPGP only command.\n");
1494       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1495     }
1496
1497   newstate = !info->chv1_cached;
1498
1499   err = scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
1500   if (err)
1501     goto leave;
1502
1503   /* Read it back to be sure we have the right toggle state the next
1504    * time.  */
1505   err = scd_getattr ("CHV-STATUS", info);
1506
1507  leave:
1508   return err;
1509 }
1510
1511
1512 /* Helper for cmd_generate.  Noe that either 0 or 1 is stored at
1513  * FORCED_CHV1. */
1514 static gpg_error_t
1515 check_pin_for_key_operation (card_info_t info, int *forced_chv1)
1516 {
1517   gpg_error_t err = 0;
1518
1519   *forced_chv1 = !info->chv1_cached;
1520   if (*forced_chv1)
1521     { /* Switch off the forced mode so that during key generation we
1522        * don't get bothered with PIN queries for each self-signature. */
1523       err = scd_setattr ("CHV-STATUS-1", "\x01", 1);
1524       if (err)
1525         {
1526           log_error ("error clearing forced signature PIN flag: %s\n",
1527                      gpg_strerror (err));
1528           *forced_chv1 = -1;  /* Not changed.  */
1529           goto leave;
1530         }
1531     }
1532
1533   /* Check the PIN now, so that we won't get asked later for each
1534    * binding signature.  */
1535   err = scd_checkpin (info->serialno);
1536   if (err)
1537     log_error ("error checking the PIN: %s\n", gpg_strerror (err));
1538
1539  leave:
1540   return err;
1541 }
1542
1543
1544 /* Helper for cmd_generate.  */
1545 static void
1546 restore_forced_chv1 (int *forced_chv1)
1547 {
1548   gpg_error_t err;
1549
1550   /* Note the possible values stored at FORCED_CHV1:
1551    *   0 - forcesig was not enabled.
1552    *   1 - forcesig was enabled - enable it again.
1553    *  -1 - We have not changed anything.  */
1554   if (*forced_chv1 == 1)
1555     { /* Switch back to forced state. */
1556       err = scd_setattr ("CHV-STATUS-1", "", 1);
1557       if (err)
1558         log_error ("error setting forced signature PIN flag: %s\n",
1559                    gpg_strerror (err));
1560       *forced_chv1 = 0;
1561     }
1562 }
1563
1564
1565 static gpg_error_t
1566 cmd_generate (card_info_t info)
1567 {
1568   gpg_error_t err;
1569   int forced_chv1 = -1;
1570   int want_backup;
1571   char *answer = NULL;
1572   key_info_t kinfo1, kinfo2, kinfo3;
1573
1574   if (!info)
1575     return print_help
1576       ("GENERATE\n\n"
1577        "Menu to generate a new keys.",
1578        APP_TYPE_OPENPGP, 0);
1579
1580   if (info->apptype != APP_TYPE_OPENPGP)
1581     {
1582       log_info ("Note: This is an OpenPGP only command.\n");
1583       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1584     }
1585
1586   if (info->extcap.ki)
1587     {
1588       xfree (answer);
1589       answer = tty_get (_("Make off-card backup of encryption key? (Y/n) "));
1590       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1591       tty_kill_prompt ();
1592       if (*answer == CONTROL_D)
1593         {
1594           err = gpg_error (GPG_ERR_CANCELED);
1595           goto leave;
1596         }
1597     }
1598   else
1599     want_backup = 0;
1600
1601
1602   kinfo1 = find_kinfo (info, "OPENPGP.1");
1603   kinfo2 = find_kinfo (info, "OPENPGP.2");
1604   kinfo3 = find_kinfo (info, "OPENPGP.3");
1605
1606   if ((kinfo1 && kinfo1->fprlen && !mem_is_zero (kinfo1->fpr,kinfo1->fprlen))
1607       || (kinfo2 && kinfo2->fprlen && !mem_is_zero (kinfo2->fpr,kinfo2->fprlen))
1608       || (kinfo3 && kinfo3->fprlen && !mem_is_zero (kinfo3->fpr,kinfo3->fprlen))
1609       )
1610     {
1611       tty_printf ("\n");
1612       log_info (_("Note: keys are already stored on the card!\n"));
1613       tty_printf ("\n");
1614       answer = tty_get (_("Replace existing keys? (y/N) "));
1615       tty_kill_prompt ();
1616       if (*answer == CONTROL_D)
1617         {
1618           err = gpg_error (GPG_ERR_CANCELED);
1619           goto leave;
1620         }
1621
1622       if (!answer_is_yes_no_default (answer, 0/*(default to No)*/))
1623         {
1624           err = gpg_error (GPG_ERR_CANCELED);
1625           goto leave;
1626         }
1627     }
1628
1629   /* If no displayed name has been set, we assume that this is a fresh
1630    * card and print a hint about the default PINs.  */
1631   if (!info->disp_name || !*info->disp_name)
1632     {
1633       tty_printf ("\n");
1634       tty_printf (_("Please note that the factory settings of the PINs are\n"
1635                     "   PIN = '%s'     Admin PIN = '%s'\n"
1636                     "You should change them using the command --change-pin\n"),
1637                   OPENPGP_USER_PIN_DEFAULT, OPENPGP_ADMIN_PIN_DEFAULT);
1638       tty_printf ("\n");
1639     }
1640
1641   err = check_pin_for_key_operation (info, &forced_chv1);
1642   if (err)
1643     goto leave;
1644
1645   /* FIXME: We need to divert to a function which spwans gpg which
1646    * will then create the key.  This also requires new features in
1647    * gpg.  We might also first create the keys on the card and then
1648    * tell gpg to use them to create the OpenPGP keyblock. */
1649   /* generate_keypair (ctrl, 1, NULL, info.serialno, want_backup); */
1650   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1651
1652  leave:
1653   restore_forced_chv1 (&forced_chv1);
1654   xfree (answer);
1655   return err;
1656 }
1657
1658
1659 /* Sub-menu to change a PIN.  The presented options may depend on the
1660  * the ALLOW_ADMIN flag.  */
1661 static gpg_error_t
1662 cmd_passwd (card_info_t info, int allow_admin)
1663 {
1664   gpg_error_t err;
1665   char *answer = NULL;
1666
1667   if (!info)
1668     return print_help
1669       ("PASSWD\n\n"
1670        "Menu to change or unblock the PINs.  Note that the\n"
1671        "presented menu options depend on the type of card\n"
1672        "and whether the admin mode is enabled.",
1673        0);
1674
1675   /* Convenience message because we did this in gpg --card-edit too.  */
1676   if (info->apptype == APP_TYPE_OPENPGP)
1677     log_info (_("OpenPGP card no. %s detected\n"),
1678               info->dispserialno? info->dispserialno : info->serialno);
1679
1680   if (!allow_admin)
1681     {
1682       err = scd_change_pin (1);
1683       if (err)
1684         goto leave;
1685       log_info ("PIN changed.\n");
1686     }
1687   else if (info->apptype == APP_TYPE_OPENPGP)
1688     {
1689       for (;;)
1690         {
1691           tty_printf ("\n");
1692           tty_printf ("1 - change PIN\n"
1693                       "2 - unblock and set new PIN\n"
1694                       "3 - change Admin PIN\n"
1695                       "4 - set the Reset Code\n"
1696                       "Q - quit\n");
1697           tty_printf ("\n");
1698
1699           err = 0;
1700           xfree (answer);
1701           answer = tty_get (_("Your selection? "));
1702           tty_kill_prompt ();
1703           if (*answer == CONTROL_D)
1704             break;  /* Quit.  */
1705           if (strlen (answer) != 1)
1706             continue;
1707           if (*answer == 'q' || *answer == 'Q')
1708             break;  /* Quit.  */
1709
1710           if (*answer == '1')
1711             {
1712               /* Change PIN (same as the direct thing in non-admin mode).  */
1713               err = scd_change_pin (1);
1714               if (err)
1715                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1716               else
1717                 log_info ("PIN changed.\n");
1718             }
1719           else if (*answer == '2')
1720             {
1721               /* Unblock PIN by setting a new PIN.  */
1722               err = scd_change_pin (101);
1723               if (err)
1724                 log_error ("Error unblocking the PIN: %s\n", gpg_strerror(err));
1725               else
1726                 log_info ("PIN unblocked and new PIN set.\n");
1727             }
1728           else if (*answer == '3')
1729             {
1730               /* Change Admin PIN.  */
1731               err = scd_change_pin (3);
1732               if (err)
1733                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
1734               else
1735                 log_info ("PIN changed.\n");
1736           }
1737           else if (*answer == '4')
1738             {
1739               /* Set a new Reset Code.  */
1740               err = scd_change_pin (102);
1741               if (err)
1742                 log_error ("Error setting the Reset Code: %s\n",
1743                            gpg_strerror (err));
1744               else
1745                 log_info ("Reset Code set.\n");
1746             }
1747
1748         } /*end for loop*/
1749     }
1750   else
1751     {
1752       log_info ("Admin related passwd options not yet supported for '%s'\n",
1753                 app_type_string (info->apptype));
1754       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1755     }
1756
1757  leave:
1758   xfree (answer);
1759   return err;
1760 }
1761
1762
1763 static gpg_error_t
1764 cmd_unblock (card_info_t info)
1765 {
1766   gpg_error_t err = 0;
1767
1768   if (!info)
1769     return print_help
1770       ("UNBLOCK\n\n"
1771        "Unblock a PIN using a PUK or Reset Code.  Note that OpenPGP\n"
1772        "cards prior to version 2 can't use this; instead the PASSWD\n"
1773        "command can be used to set a new PIN.",
1774        0);
1775
1776   if (info->apptype == APP_TYPE_OPENPGP)
1777     log_info (_("OpenPGP card no. %s detected\n"),
1778               info->dispserialno? info->dispserialno : info->serialno);
1779
1780   if (info->apptype == APP_TYPE_OPENPGP && !info->is_v2)
1781     log_error (_("This command is only available for version 2 cards\n"));
1782   else if (info->apptype == APP_TYPE_OPENPGP && !info->chvinfo[1])
1783     log_error (_("Reset Code not or not anymore available\n"));
1784   else if (info->apptype == APP_TYPE_OPENPGP)
1785     {
1786       err = scd_change_pin (2);
1787       if (!err)
1788         log_info ("PIN changed.\n");
1789     }
1790   else
1791     log_info ("Unblocking not yet supported for '%s'\n",
1792               app_type_string (info->apptype));
1793
1794   return err;
1795 }
1796
1797
1798 /* Direct sending of an hex encoded APDU with error printing.  */
1799 static gpg_error_t
1800 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1801 {
1802   gpg_error_t err;
1803   unsigned int sw;
1804
1805   err = scd_apdu (hexapdu, &sw);
1806   if (err)
1807     log_error ("sending card command %s failed: %s\n", desc,
1808                gpg_strerror (err));
1809   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1810     ;
1811   else if (ignore == 0xffff)
1812     ; /* Ignore all status words.  */
1813   else if (sw != 0x9000)
1814     {
1815       switch (sw)
1816         {
1817         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1818         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1819         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1820         default: err = gpg_error (GPG_ERR_CARD);
1821         }
1822       if (!(ignore && ignore == sw))
1823         log_error ("card command %s failed: %s (0x%04x)\n", desc,
1824                    gpg_strerror (err),  sw);
1825     }
1826   return err;
1827 }
1828
1829
1830 /* Note: On successful execution a redisplay should be scheduled.  If
1831  * this function fails the card may be in an unknown state. */
1832 static gpg_error_t
1833 cmd_factoryreset (card_info_t info)
1834 {
1835   gpg_error_t err;
1836   char *answer = NULL;
1837   int termstate = 0;
1838   int any_apdu = 0;
1839   int i;
1840
1841
1842   if (!info)
1843     return print_help
1844       ("FACTORY-RESET\n\n"
1845        "Do a complete reset of an OpenPGP card.  This deletes all\n"
1846        "data and keys and resets the PINs to their default.  This\n"
1847        "mainly used by developers with scratch cards.  Don't worry,\n"
1848        "you need to confirm before the command proceeds.",
1849        APP_TYPE_OPENPGP, 0);
1850
1851   if (info->apptype != APP_TYPE_OPENPGP)
1852     {
1853       log_info ("Note: This is an OpenPGP only command.\n");
1854       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1855     }
1856
1857   /* The code below basically does the same what this
1858    * gpg-connect-agent script does:
1859    *
1860    *   scd reset
1861    *   scd serialno undefined
1862    *   scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1863    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1864    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1865    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1866    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1867    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1868    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1869    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1870    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1871    *   scd apdu 00 e6 00 00
1872    *   scd apdu 00 44 00 00
1873    *   scd reset
1874    *   /echo Card has been reset to factory defaults
1875    *
1876    * but tries to find out something about the card first.
1877    */
1878
1879   err = scd_learn (info);
1880   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1881       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1882     termstate = 1;
1883   else if (err)
1884     {
1885       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1886       goto leave;
1887     }
1888
1889   if (!termstate)
1890     {
1891       log_info (_("OpenPGP card no. %s detected\n"),
1892                 info->dispserialno? info->dispserialno : info->serialno);
1893       if (!(info->status_indicator == 3 || info->status_indicator == 5))
1894         {
1895           /* Note: We won't see status-indicator 3 here because it is not
1896            * possible to select a card application in termination state.  */
1897           log_error (_("This command is not supported by this card\n"));
1898           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
1899           goto leave;
1900         }
1901
1902       tty_printf ("\n");
1903       log_info
1904         (_("Note: This command destroys all keys stored on the card!\n"));
1905       tty_printf ("\n");
1906       xfree (answer);
1907       answer = tty_get (_("Continue? (y/N) "));
1908       tty_kill_prompt ();
1909       trim_spaces (answer);
1910       if (*answer == CONTROL_D
1911           || !answer_is_yes_no_default (answer, 0/*(default to no)*/))
1912         {
1913           err = gpg_error (GPG_ERR_CANCELED);
1914           goto leave;
1915         }
1916
1917       xfree (answer);
1918       answer = tty_get (_("Really do a factory reset? (enter \"yes\") "));
1919       tty_kill_prompt ();
1920       trim_spaces (answer);
1921       if (strcmp (answer, "yes") && strcmp (answer,_("yes")))
1922         {
1923           err = gpg_error (GPG_ERR_CANCELED);
1924           goto leave;
1925         }
1926
1927       any_apdu = 1;
1928       /* We need to select a card application before we can send APDUs
1929        * to the card without scdaemon doing anything on its own.  */
1930       err = send_apdu (NULL, "RESET", 0);
1931       if (err)
1932         goto leave;
1933       err = send_apdu ("undefined", "dummy select ", 0);
1934       if (err)
1935         goto leave;
1936
1937       /* Select the OpenPGP application.  */
1938       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1939       if (err)
1940         goto leave;
1941
1942       /* Do some dummy verifies with wrong PINs to set the retry
1943        * counter to zero.  We can't easily use the card version 2.1
1944        * feature of presenting the admin PIN to allow the terminate
1945        * command because there is no machinery in scdaemon to catch
1946        * the verify command and ask for the PIN when the "APDU"
1947        * command is used.
1948        * Here, the length of dummy wrong PIN is 32-byte, also
1949        * supporting authentication with KDF DO.  */
1950       for (i=0; i < 4; i++)
1951         send_apdu ("0020008120"
1952                    "40404040404040404040404040404040"
1953                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1954       for (i=0; i < 4; i++)
1955         send_apdu ("0020008320"
1956                    "40404040404040404040404040404040"
1957                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1958
1959       /* Send terminate datafile command.  */
1960       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1961       if (err)
1962         goto leave;
1963     }
1964
1965   any_apdu = 1;
1966   /* Send activate datafile command.  This is used without
1967    * confirmation if the card is already in termination state.  */
1968   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1969   if (err)
1970     goto leave;
1971
1972   /* Finally we reset the card reader once more.  */
1973   err = send_apdu (NULL, "RESET", 0);
1974   if (err)
1975     goto leave;
1976
1977   /* Then, connect the card again (answer used as a dummy).  */
1978   xfree (answer); answer = NULL;
1979   err = scd_serialno (&answer, NULL);
1980
1981  leave:
1982   if (err && any_apdu)
1983     {
1984       log_info ("Due to an error the card might be in an inconsistent state\n"
1985                 "You should run the LIST command to check this.\n");
1986       /* FIXME: We need a better solution in the case that the card is
1987        * in a termination state, i.e. the card was removed before the
1988        * activate was sent.  The best solution I found with v2.1
1989        * Zeitcontrol card was to kill scdaemon and the issue this
1990        * sequence with gpg-connect-agent:
1991        *   scd reset
1992        *   scd serialno undefined
1993        *   scd apdu 00A4040006D27600012401 (returns error)
1994        *   scd apdu 00440000
1995        * Then kill scdaemon again and issue:
1996        *   scd reset
1997        *   scd serialno openpgp
1998        */
1999     }
2000   xfree (answer);
2001   return err;
2002 }
2003
2004
2005 /* Generate KDF data.  This is a helper for cmd_kdfsetup.  */
2006 static gpg_error_t
2007 gen_kdf_data (unsigned char *data, int single_salt)
2008 {
2009   gpg_error_t err;
2010   const unsigned char h0[] = { 0x81, 0x01, 0x03,
2011                                0x82, 0x01, 0x08,
2012                                0x83, 0x04 };
2013   const unsigned char h1[] = { 0x84, 0x08 };
2014   const unsigned char h2[] = { 0x85, 0x08 };
2015   const unsigned char h3[] = { 0x86, 0x08 };
2016   const unsigned char h4[] = { 0x87, 0x20 };
2017   const unsigned char h5[] = { 0x88, 0x20 };
2018   unsigned char *p, *salt_user, *salt_admin;
2019   unsigned char s2k_char;
2020   unsigned int iterations;
2021   unsigned char count_4byte[4];
2022
2023   p = data;
2024
2025   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
2026   iterations = S2K_DECODE_COUNT (s2k_char);
2027   count_4byte[0] = (iterations >> 24) & 0xff;
2028   count_4byte[1] = (iterations >> 16) & 0xff;
2029   count_4byte[2] = (iterations >>  8) & 0xff;
2030   count_4byte[3] = (iterations & 0xff);
2031
2032   memcpy (p, h0, sizeof h0);
2033   p += sizeof h0;
2034   memcpy (p, count_4byte, sizeof count_4byte);
2035   p += sizeof count_4byte;
2036   memcpy (p, h1, sizeof h1);
2037   salt_user = (p += sizeof h1);
2038   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2039   p += 8;
2040
2041   if (single_salt)
2042     salt_admin = salt_user;
2043   else
2044     {
2045       memcpy (p, h2, sizeof h2);
2046       p += sizeof h2;
2047       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2048       p += 8;
2049       memcpy (p, h3, sizeof h3);
2050       salt_admin = (p += sizeof h3);
2051       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2052       p += 8;
2053     }
2054
2055   memcpy (p, h4, sizeof h4);
2056   p += sizeof h4;
2057   err = gcry_kdf_derive (OPENPGP_USER_PIN_DEFAULT,
2058                          strlen (OPENPGP_USER_PIN_DEFAULT),
2059                          GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2060                          salt_user, 8, iterations, 32, p);
2061   p += 32;
2062   if (!err)
2063     {
2064       memcpy (p, h5, sizeof h5);
2065       p += sizeof h5;
2066       err = gcry_kdf_derive (OPENPGP_ADMIN_PIN_DEFAULT,
2067                              strlen (OPENPGP_ADMIN_PIN_DEFAULT),
2068                              GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2069                              salt_admin, 8, iterations, 32, p);
2070     }
2071
2072   return err;
2073 }
2074
2075
2076 static gpg_error_t
2077 cmd_kdfsetup (card_info_t info, char *argstr)
2078 {
2079   gpg_error_t err;
2080   unsigned char kdf_data[OPENPGP_KDF_DATA_LENGTH_MAX];
2081   int single = (*argstr != 0);
2082
2083   if (!info)
2084     return print_help
2085       ("KDF-SETUP\n\n"
2086        "Prepare the OpenPGP card KDF feature for this card.",
2087        APP_TYPE_OPENPGP, 0);
2088
2089   if (info->apptype != APP_TYPE_OPENPGP)
2090     {
2091       log_info ("Note: This is an OpenPGP only command.\n");
2092       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2093     }
2094
2095   if (!info->extcap.kdf)
2096     {
2097       log_error (_("This command is not supported by this card\n"));
2098       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2099       goto leave;
2100     }
2101
2102   err = gen_kdf_data (kdf_data, single);
2103   if (err)
2104     goto leave;
2105
2106   err = scd_setattr ("KDF", kdf_data,
2107                      single ? OPENPGP_KDF_DATA_LENGTH_MIN
2108                      /* */  : OPENPGP_KDF_DATA_LENGTH_MAX);
2109   if (err)
2110     goto leave;
2111
2112   err = scd_getattr ("KDF", info);
2113
2114  leave:
2115   return err;
2116 }
2117
2118
2119 \f
2120 static void
2121 show_keysize_warning (void)
2122 {
2123   static int shown;
2124
2125   if (shown)
2126     return;
2127   shown = 1;
2128   tty_printf
2129     (_("Note: There is no guarantee that the card supports the requested\n"
2130        "      key type or size.  If the key generation does not succeed,\n"
2131        "      please check the documentation of your card to see which\n"
2132        "      key types and sizes are supported.\n")
2133      );
2134 }
2135
2136
2137 /* Ask for the size of a card key.  NBITS is the current size
2138  * configured for the card.  Returns 0 on success and stored the
2139  * chosen key size at R_KEYSIZE; 0 is stored to indicate that the
2140  * default size shall be used.  */
2141 static gpg_error_t
2142 ask_card_rsa_keysize (unsigned int nbits, unsigned int *r_keysize)
2143 {
2144   unsigned int min_nbits = 1024;
2145   unsigned int max_nbits = 4096;
2146   char*answer;
2147   unsigned int req_nbits;
2148
2149   for (;;)
2150     {
2151       answer = tty_getf (_("What keysize do you want? (%u) "), nbits);
2152       trim_spaces (answer);
2153       tty_kill_prompt ();
2154       if (*answer == CONTROL_D)
2155         {
2156           xfree (answer);
2157           return gpg_error (GPG_ERR_CANCELED);
2158         }
2159       req_nbits = *answer? atoi (answer): nbits;
2160       xfree (answer);
2161
2162       if (req_nbits != nbits && (req_nbits % 32) )
2163         {
2164           req_nbits = ((req_nbits + 31) / 32) * 32;
2165           tty_printf (_("rounded up to %u bits\n"), req_nbits);
2166         }
2167
2168       if (req_nbits == nbits)
2169         {
2170           /* Use default.  */
2171           *r_keysize = 0;
2172           return 0;
2173         }
2174
2175       if (req_nbits < min_nbits || req_nbits > max_nbits)
2176         {
2177           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
2178                       "RSA", min_nbits, max_nbits);
2179         }
2180       else
2181         {
2182           *r_keysize = req_nbits;
2183           return 0;
2184         }
2185     }
2186 }
2187
2188
2189 /* Ask for the key attribute of a card key.  CURRENT is the current
2190  * attribute configured for the card.  KEYNO is the number of the key
2191  * used to select the prompt.  Stores NULL at result to use the
2192  * default attribute or stores the selected attribute structure at
2193  * RESULT.  On error an error code is returned.  */
2194 static gpg_error_t
2195 ask_card_keyattr (int keyno, const struct key_attr *current,
2196                   struct key_attr **result)
2197 {
2198   gpg_error_t err;
2199   struct key_attr *key_attr = NULL;
2200   char *answer = NULL;
2201   int selection;
2202
2203   *result = NULL;
2204
2205   key_attr = xcalloc (1, sizeof *key_attr);
2206
2207   tty_printf (_("Changing card key attribute for: "));
2208   if (keyno == 0)
2209     tty_printf (_("Signature key\n"));
2210   else if (keyno == 1)
2211     tty_printf (_("Encryption key\n"));
2212   else
2213     tty_printf (_("Authentication key\n"));
2214
2215   tty_printf (_("Please select what kind of key you want:\n"));
2216   tty_printf (_("   (%d) RSA\n"), 1 );
2217   tty_printf (_("   (%d) ECC\n"), 2 );
2218
2219   for (;;)
2220     {
2221       xfree (answer);
2222       answer = tty_get (_("Your selection? "));
2223       trim_spaces (answer);
2224       tty_kill_prompt ();
2225       if (!*answer || *answer == CONTROL_D)
2226         {
2227           err = gpg_error (GPG_ERR_CANCELED);
2228           goto leave;
2229         }
2230       selection = *answer? atoi (answer) : 0;
2231
2232       if (selection == 1 || selection == 2)
2233         break;
2234       else
2235         tty_printf (_("Invalid selection.\n"));
2236     }
2237
2238
2239   if (selection == 1)
2240     {
2241       unsigned int nbits, result_nbits;
2242
2243       if (current->algo == PUBKEY_ALGO_RSA)
2244         nbits = current->nbits;
2245       else
2246         nbits = 2048;
2247
2248       err = ask_card_rsa_keysize (nbits, &result_nbits);
2249       if (err)
2250         goto leave;
2251       if (result_nbits == 0)
2252         {
2253           if (current->algo == PUBKEY_ALGO_RSA)
2254             {
2255               xfree (key_attr);
2256               key_attr = NULL;
2257             }
2258           else
2259             result_nbits = nbits;
2260         }
2261
2262       if (key_attr)
2263         {
2264           key_attr->algo = PUBKEY_ALGO_RSA;
2265           key_attr->nbits = result_nbits;
2266         }
2267     }
2268   else if (selection == 2)
2269     {
2270       const char *curve;
2271       /* const char *oid_str; */
2272       int algo;
2273
2274       if (current->algo == PUBKEY_ALGO_RSA)
2275         {
2276           if (keyno == 1) /* Encryption key */
2277             algo = PUBKEY_ALGO_ECDH;
2278           else /* Signature key or Authentication key */
2279             algo = PUBKEY_ALGO_ECDSA;
2280           curve = NULL;
2281         }
2282       else
2283         {
2284           algo = current->algo;
2285           curve = current->curve;
2286         }
2287
2288       err = GPG_ERR_NOT_IMPLEMENTED;
2289       goto leave;
2290       /* FIXME: We need to mve the ask_cure code out to common or
2291        * provide another sultion.  */
2292       /* curve = ask_curve (&algo, NULL, curve); */
2293       /* if (curve) */
2294       /*   { */
2295       /*     key_attr->algo = algo; */
2296       /*     oid_str = openpgp_curve_to_oid (curve, NULL); */
2297       /*     key_attr->curve = openpgp_oid_to_curve (oid_str, 0); */
2298       /*   } */
2299       /* else */
2300       /*   { */
2301       /*     xfree (key_attr); */
2302       /*     key_attr = NULL; */
2303       /*   } */
2304     }
2305   else
2306     {
2307       err = gpg_error (GPG_ERR_BUG);
2308       goto leave;
2309     }
2310
2311   /* Tell the user what we are going to do.  */
2312   if (key_attr->algo == PUBKEY_ALGO_RSA)
2313     {
2314       tty_printf (_("The card will now be re-configured"
2315                     " to generate a key of %u bits\n"), key_attr->nbits);
2316     }
2317   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2318            || key_attr->algo == PUBKEY_ALGO_ECDSA
2319            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2320     {
2321       tty_printf (_("The card will now be re-configured"
2322                     " to generate a key of type: %s\n"), key_attr->curve);
2323     }
2324   show_keysize_warning ();
2325
2326   *result = key_attr;
2327   key_attr = NULL;
2328
2329  leave:
2330   xfree (key_attr);
2331   xfree (answer);
2332   return err;
2333 }
2334
2335
2336 /* Change the key attribute of key KEYNO (0..2) and show an error
2337  * message if that fails.  */
2338 static gpg_error_t
2339 do_change_keyattr (int keyno, const struct key_attr *key_attr)
2340 {
2341   gpg_error_t err = 0;
2342   char args[100];
2343
2344   if (key_attr->algo == PUBKEY_ALGO_RSA)
2345     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
2346               key_attr->nbits);
2347   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2348            || key_attr->algo == PUBKEY_ALGO_ECDSA
2349            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2350     snprintf (args, sizeof args, "--force %d %d %s",
2351               keyno+1, key_attr->algo, key_attr->curve);
2352   else
2353     {
2354       /* FIXME: Above we use opnepgp algo names but in the error
2355        * message we use the gcrypt names.  We should settle for a
2356        * consistent solution. */
2357       log_error (_("public key algorithm %d (%s) is not supported\n"),
2358                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
2359       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2360       goto leave;
2361     }
2362
2363   err = scd_setattr ("KEY-ATTR", args, strlen (args));
2364   if (err)
2365     log_error (_("error changing key attribute for key %d: %s\n"),
2366                keyno+1, gpg_strerror (err));
2367  leave:
2368   return err;
2369 }
2370
2371
2372 static gpg_error_t
2373 cmd_keyattr (card_info_t info, char *argstr)
2374 {
2375   gpg_error_t err = 0;
2376   int keyno;
2377   struct key_attr *key_attr = NULL;
2378
2379   (void)argstr;
2380
2381   if (!info)
2382     return print_help
2383       ("KEY-ATTR\n\n"
2384        "Menu to change the key attributes of an OpenPGP card.",
2385        APP_TYPE_OPENPGP, 0);
2386
2387   if (info->apptype != APP_TYPE_OPENPGP)
2388     {
2389       log_info ("Note: This is an OpenPGP only command.\n");
2390       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2391     }
2392
2393   if (!(info->is_v2 && info->extcap.aac))
2394     {
2395       log_error (_("This command is not supported by this card\n"));
2396       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2397       goto leave;
2398     }
2399
2400   for (keyno = 0; keyno < DIM (info->key_attr); keyno++)
2401     {
2402       xfree (key_attr);
2403       key_attr = NULL;
2404       err = ask_card_keyattr (keyno, &info->key_attr[keyno], &key_attr);
2405       if (err)
2406         goto leave;
2407
2408       err = do_change_keyattr (keyno, key_attr);
2409       if (err)
2410         {
2411           /* Error: Better read the default key attribute again.  */
2412           log_debug ("FIXME\n");
2413           /* Ask again for this key. */
2414           keyno--;
2415         }
2416     }
2417
2418  leave:
2419   xfree (key_attr);
2420   return err;
2421 }
2422
2423
2424 static gpg_error_t
2425 cmd_uif (card_info_t info, char *argstr)
2426 {
2427   gpg_error_t err;
2428   int keyno;
2429
2430   if (!info)
2431     return print_help
2432       ("UIF N [on|off|permanent]\n\n"
2433        "Change the User Interaction Flag.  N must in the range 1 to 3.",
2434        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2435
2436   argstr = skip_options (argstr);
2437
2438   if (digitp (argstr))
2439     {
2440       keyno = atoi (argstr);
2441       while (digitp (argstr))
2442         argstr++;
2443       while (spacep (argstr))
2444         argstr++;
2445     }
2446   else
2447     keyno = 0;
2448
2449   if (keyno < 1 || keyno > 3)
2450     {
2451       err = gpg_error (GPG_ERR_INV_ARG);
2452       goto leave;
2453     }
2454
2455
2456   err = GPG_ERR_NOT_IMPLEMENTED;
2457
2458  leave:
2459   return err;
2460 }
2461
2462
2463 \f
2464 /* Data used by the command parser.  This needs to be outside of the
2465  * function scope to allow readline based command completion.  */
2466 enum cmdids
2467   {
2468     cmdNOP = 0,
2469     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdRESET, cmdVERIFY,
2470     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSALUT, cmdCAFPR,
2471     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2472     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2473     cmdKEYATTR, cmdUIF,
2474     cmdINVCMD
2475   };
2476
2477 static struct
2478 {
2479   const char *name;
2480   enum cmdids id;
2481   int admin_only;
2482   const char *desc;
2483 } cmds[] = {
2484   { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2485   { "q"       , cmdQUIT  , 0, NULL },
2486   { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2487   { "help"    , cmdHELP  , 0, N_("show this help")},
2488   { "?"       , cmdHELP  , 0, NULL },
2489   { "list"    , cmdLIST  , 0, N_("list all available data")},
2490   { "l"       , cmdLIST  , 0, NULL },
2491   { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2492   { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2493   { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2494   { "login"   , cmdLOGIN , 1, N_("change the login name")},
2495   { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2496   { "salutation",cmdSALUT, 1, N_("change card holder's salutation")},
2497   { "salut"   , cmdSALUT,  1, NULL },
2498   { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2499   { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2500   { "generate", cmdGENERATE, 1, N_("generate new keys")},
2501   { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2502   { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2503   { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
2504   { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2505   { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2506   { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2507   { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
2508   /* Note, that we do not announce these command yet. */
2509   { "privatedo", cmdPRIVATEDO, 0, N_("change a private data object")},
2510   { "readcert",  cmdREADCERT,  0, N_("read a certificate from a data object")},
2511   { "writecert", cmdWRITECERT, 1, N_("store a certificate to a data object")},
2512   { NULL, cmdINVCMD, 0, NULL }
2513 };
2514
2515
2516 /* The main loop.  */
2517 static void
2518 interactive_loop (void)
2519 {
2520   gpg_error_t err;
2521   char *answer = NULL;         /* The input line.  */
2522   enum cmdids cmd = cmdNOP;    /* The command.  */
2523   int cmd_admin_only;          /* The command is an admin only command.  */
2524   char *argstr;                /* The argument as a string.  */
2525   int redisplay = 1;           /* Whether to redisplay the main info.  */
2526   int allow_admin = 0;         /* Whether admin commands are allowed.  */
2527   char *help_arg = NULL;       /* Argument of the HELP command.         */
2528   struct card_info_s info_buffer;
2529   card_info_t info = &info_buffer;
2530   char *p;
2531   int i;
2532
2533   /* In the interactive mode we do not want to print the program prefix.  */
2534   log_set_prefix (NULL, 0);
2535
2536   for (;;)
2537     {
2538       if (help_arg)
2539         {
2540           /* Clear info to indicate helpmode */
2541           info = NULL;
2542         }
2543       else if (!info)
2544         {
2545           /* Get out of help.  */
2546           info = &info_buffer;
2547           help_arg = NULL;
2548           redisplay = 0;
2549         }
2550       else if (redisplay)
2551         {
2552           err = scd_learn (info);
2553           if (err)
2554             {
2555               log_error ("Error reading card: %s\n", gpg_strerror (err));
2556             }
2557           else
2558             {
2559               list_card (info);
2560               tty_printf("\n");
2561               redisplay = 0;
2562             }
2563         }
2564
2565       if (!info)
2566         {
2567           /* Copy the pending help arg into our answer.  Noe that
2568            * help_arg points into answer.  */
2569           p = xstrdup (help_arg);
2570           help_arg = NULL;
2571           xfree (answer);
2572           answer = p;
2573         }
2574       else
2575         {
2576           do
2577             {
2578               xfree (answer);
2579               tty_enable_completion (command_completion);
2580               answer = tty_get (_("gpg/card> "));
2581               tty_kill_prompt();
2582               tty_disable_completion ();
2583               trim_spaces(answer);
2584             }
2585           while ( *answer == '#' );
2586         }
2587
2588       argstr = NULL;
2589       cmd_admin_only = 0;
2590       if (!*answer)
2591         cmd = cmdLIST; /* We default to the list command */
2592       else if (*answer == CONTROL_D)
2593         cmd = cmdQUIT;
2594       else
2595         {
2596           if ((argstr = strchr (answer,' ')))
2597             {
2598               *argstr++ = 0;
2599               trim_spaces (answer);
2600               trim_spaces (argstr);
2601             }
2602
2603           for (i=0; cmds[i].name; i++ )
2604             if (!ascii_strcasecmp (answer, cmds[i].name ))
2605               break;
2606
2607           cmd = cmds[i].id;
2608           cmd_admin_only = cmds[i].admin_only;
2609         }
2610
2611       /* Make sure we have valid strings for the args.  They are
2612        * allowed to be modifed and must thus point to a buffer.  */
2613       if (!argstr)
2614         argstr = answer + strlen (answer);
2615
2616       if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP))
2617         {
2618           /* If redisplay is set we know that there was an error reading
2619            * the card.  In this case we force a LIST command to retry.  */
2620           if (!info)
2621             ; /* In help mode.  */
2622           else if (redisplay)
2623             {
2624               cmd = cmdLIST;
2625               cmd_admin_only = 0;
2626             }
2627           else if (!info->serialno)
2628             {
2629               /* Without a serial number most commands won't work.
2630                * Catch it here.  */
2631               tty_printf ("\n");
2632               tty_printf ("Serial number missing\n");
2633               continue;
2634             }
2635           else if (!allow_admin && cmd_admin_only)
2636             {
2637               tty_printf ("\n");
2638               tty_printf (_("Admin-only command\n"));
2639               continue;
2640             }
2641         }
2642
2643       err = 0;
2644       switch (cmd)
2645         {
2646         case cmdNOP:
2647           if (!info)
2648             print_help ("NOP\n\n"
2649                         "Dummy command.", 0);
2650           break;
2651
2652         case cmdQUIT:
2653           if (!info)
2654             print_help ("QUIT\n\n"
2655                         "Leave this tool.", 0);
2656           else
2657             {
2658               tty_printf ("\n");
2659               goto leave;
2660             }
2661           break;
2662
2663         case cmdHELP:
2664           if (!info)
2665             print_help ("HELP [command]\n\n"
2666                         "Show all commands.  With an argument show help\n"
2667                         "for that command.", 0);
2668           else if (*argstr)
2669             help_arg = argstr; /* Trigger help for a command.  */
2670           else
2671             {
2672               tty_printf
2673                 ("List of commands (\"help <command>\" for details):\n");
2674               for (i=0; cmds[i].name; i++ )
2675                 if(cmds[i].desc
2676                    && (!cmds[i].admin_only
2677                        || (cmds[i].admin_only && allow_admin)))
2678                   tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2679             }
2680           break;
2681
2682         case cmdLIST:
2683           if (!info)
2684             print_help ("LIST\n\n"
2685                         "Show content of the card.", 0);
2686           else
2687             {
2688               /* Actual work is done by the redisplay code block.  */
2689               redisplay = 1;
2690             }
2691           break;
2692
2693         case cmdRESET:
2694           if (!info)
2695             print_help ("RESET\n\n"
2696                         "Send a RESET to the card daemon.", 0);
2697           else
2698             {
2699               err = scd_apdu (NULL, NULL);
2700             }
2701           break;
2702
2703         case cmdADMIN:
2704           if ( !strcmp (argstr, "on") )
2705             allow_admin = 1;
2706           else if ( !strcmp (argstr, "off") )
2707             allow_admin = 0;
2708           else if ( !strcmp (argstr, "verify") )
2709             {
2710               /* Force verification of the Admin Command.  However,
2711                  this is only done if the retry counter is at initial
2712                  state.  */
2713               /* FIXME: Must depend on the type of the card.  */
2714               /* char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1); */
2715               /* strcpy (stpcpy (tmp, serialnobuf), "[CHV3]"); */
2716               /* allow_admin = !agent_scd_checkpin (tmp); */
2717               /* xfree (tmp); */
2718             }
2719           else /* Toggle. */
2720             allow_admin=!allow_admin;
2721           if(allow_admin)
2722             tty_printf(_("Admin commands are allowed\n"));
2723           else
2724             tty_printf(_("Admin commands are not allowed\n"));
2725           break;
2726
2727         case cmdVERIFY:
2728           err = cmd_verify (info, argstr);
2729           if (!err)
2730             redisplay = 1;
2731           break;
2732         case cmdNAME:      err = cmd_name (info, argstr); break;
2733         case cmdURL:       err = cmd_url (info, argstr);  break;
2734         case cmdFETCH:     err = cmd_fetch (info);  break;
2735         case cmdLOGIN:     err = cmd_login (info, argstr); break;
2736         case cmdLANG:      err = cmd_lang (info, argstr); break;
2737         case cmdSALUT:     err = cmd_salut (info, argstr); break;
2738         case cmdCAFPR:     err = cmd_cafpr (info, argstr); break;
2739         case cmdPRIVATEDO: err = cmd_privatedo (info, argstr); break;
2740         case cmdWRITECERT: err = cmd_writecert (info, argstr); break;
2741         case cmdREADCERT:  err = cmd_readcert (info, argstr); break;
2742         case cmdFORCESIG:  err = cmd_forcesig (info); break;
2743         case cmdGENERATE:  err = cmd_generate (info); break;
2744         case cmdPASSWD:    err = cmd_passwd (info, allow_admin); break;
2745         case cmdUNBLOCK:   err = cmd_unblock (info); break;
2746         case cmdFACTORYRESET:
2747           err = cmd_factoryreset (info);
2748           if (!err)
2749             redisplay = 1;
2750           break;
2751         case cmdKDFSETUP:  err = cmd_kdfsetup (info, argstr); break;
2752         case cmdKEYATTR:   err = cmd_keyattr (info, argstr); break;
2753         case cmdUIF:       err = cmd_uif (info, argstr); break;
2754
2755         case cmdINVCMD:
2756         default:
2757           tty_printf ("\n");
2758           tty_printf (_("Invalid command  (try \"help\")\n"));
2759           break;
2760         } /* End command switch. */
2761
2762       if (gpg_err_code (err) == GPG_ERR_CANCELED)
2763         tty_fprintf (NULL, "\n");
2764       else if (err)
2765         {
2766           const char *s = "?";
2767           for (i=0; cmds[i].name; i++ )
2768             if (cmd == cmds[i].id)
2769               {
2770                 s = cmds[i].name;
2771                 break;
2772               }
2773           log_error ("Command '%s' failed: %s\n", s, gpg_strerror (err));
2774         }
2775
2776     } /* End of main menu loop. */
2777
2778  leave:
2779   release_card_info (info);
2780   xfree (answer);
2781 }
2782
2783 #ifdef HAVE_LIBREADLINE
2784 /* Helper function for readline's command completion. */
2785 static char *
2786 command_generator (const char *text, int state)
2787 {
2788   static int list_index, len;
2789   const char *name;
2790
2791   /* If this is a new word to complete, initialize now.  This includes
2792    * saving the length of TEXT for efficiency, and initializing the
2793    index variable to 0. */
2794   if (!state)
2795     {
2796       list_index = 0;
2797       len = strlen(text);
2798     }
2799
2800   /* Return the next partial match */
2801   while ((name = cmds[list_index].name))
2802     {
2803       /* Only complete commands that have help text. */
2804       if (cmds[list_index++].desc && !strncmp (name, text, len))
2805         return strdup(name);
2806     }
2807
2808   return NULL;
2809 }
2810
2811 /* Second helper function for readline's command completion.  */
2812 static char **
2813 command_completion (const char *text, int start, int end)
2814 {
2815   (void)end;
2816
2817   /* If we are at the start of a line, we try and command-complete.
2818    * If not, just do nothing for now. */
2819   if (!start)
2820     return rl_completion_matches (text, command_generator);
2821
2822   rl_attempted_completion_over = 1;
2823
2824   return NULL;
2825 }
2826 #endif /*HAVE_LIBREADLINE*/