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