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