wkd: New command --print-wkd-hash for gpg-wks-client.
[gnupg.git] / tools / gpg-card.c
1 /* gpg-card.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 "gpg-card.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"; 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"
155            " [options] [{[--] command [args]}]  (-h for help)");
156       break;
157     case 41:
158       p = ("Syntax: gpg-card"
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 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");
238   set_strusage (my_strusage);
239   gnupg_rl_initialize ();
240   log_set_prefix ("gpg-card", 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 = { 0 };
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.  LABEL_KEYREF is a fallback key
613  * reference if no info is available; it may be NULL.  */
614 static void
615 list_one_kinfo (key_info_t firstkinfo, key_info_t kinfo,
616                 const char *label_keyref, estream_t fp)
617 {
618   gpg_error_t err;
619   keyblock_t keyblock = NULL;
620   keyblock_t kb;
621   pubkey_t pubkey;
622   userid_t uid;
623   key_info_t ki;
624   const char *s;
625   gcry_sexp_t s_pkey;
626   int any;
627
628   if (firstkinfo && kinfo)
629     {
630       tty_fprintf (fp, " ");
631       if (mem_is_zero (kinfo->grip, sizeof kinfo->grip))
632         {
633           tty_fprintf (fp, "[none]\n");
634           tty_fprintf (fp, "      keyref .....: %s\n", kinfo->keyref);
635           goto leave;
636         }
637
638       print_keygrip (fp, kinfo->grip);
639       tty_fprintf (fp, "      keyref .....: %s", kinfo->keyref);
640       if (kinfo->usage)
641         {
642           any = 0;
643           tty_fprintf (fp, "  (");
644           if ((kinfo->usage & GCRY_PK_USAGE_SIGN))
645             { tty_fprintf (fp, "sign"); any=1; }
646           if ((kinfo->usage & GCRY_PK_USAGE_CERT))
647             { tty_fprintf (fp, "%scert", any?",":""); any=1; }
648           if ((kinfo->usage & GCRY_PK_USAGE_AUTH))
649             { tty_fprintf (fp, "%sauth", any?",":""); any=1; }
650           if ((kinfo->usage & GCRY_PK_USAGE_ENCR))
651             { tty_fprintf (fp, "%sencr", any?",":""); any=1; }
652           tty_fprintf (fp, ")");
653         }
654       tty_fprintf (fp, "\n");
655
656       if (!scd_readkey (kinfo->keyref, &s_pkey))
657         {
658           char *tmp = pubkey_algo_string (s_pkey);
659           tty_fprintf (fp, "      algorithm ..: %s\n", tmp);
660           xfree (tmp);
661           gcry_sexp_release (s_pkey);
662           s_pkey = NULL;
663         }
664
665       if (kinfo->fprlen && kinfo->created)
666         {
667           tty_fprintf (fp, "      fingerprint :");
668           print_shax_fpr (fp, kinfo->fpr, kinfo->fprlen);
669           tty_fprintf (fp, "      created ....: %s\n",
670                        isotimestamp (kinfo->created));
671         }
672       err = get_matching_keys (kinfo->grip,
673                                (GNUPG_PROTOCOL_OPENPGP | GNUPG_PROTOCOL_CMS),
674                                &keyblock);
675       if (err)
676         {
677           if (gpg_err_code (err) != GPG_ERR_NO_PUBKEY)
678             tty_fprintf (fp, "      error ......: %s\n", gpg_strerror (err));
679           goto leave;
680         }
681       for (kb = keyblock; kb; kb = kb->next)
682         {
683           tty_fprintf (fp, "      used for ...: %s\n",
684                        kb->protocol == GNUPG_PROTOCOL_OPENPGP? "OpenPGP" :
685                        kb->protocol == GNUPG_PROTOCOL_CMS? "X.509" : "?");
686           pubkey = kb->keys;
687           /* If this is not the primary key print the primary key's
688            * fingerprint or a reference to it.  */
689           if (kb->protocol == GNUPG_PROTOCOL_OPENPGP)
690             {
691               tty_fprintf (fp, "        main key .:");
692               for (ki=firstkinfo; ki; ki = ki->next)
693                 if (pubkey->grip_valid
694                     && !memcmp (ki->grip, pubkey->grip, KEYGRIP_LEN))
695                   break;
696               if (ki)
697                 {
698                   /* Fixme: Replace mapping by a table lookup.  */
699                   if (!memcmp (kinfo->grip, pubkey->grip, KEYGRIP_LEN))
700                     s = "this";
701                   else if (!strcmp (ki->keyref, "OPENPGP.1"))
702                     s = "Signature key";
703                   else if (!strcmp (ki->keyref, "OPENPGP.2"))
704                     s = "Encryption key";
705                   else if (!strcmp (ki->keyref, "OPENPGP.3"))
706                     s = "Authentication key";
707                   else
708                     s = NULL;
709                   if (s)
710                     tty_fprintf (fp, " <%s>\n", s);
711                   else
712                     tty_fprintf (fp, " <Key %s>\n", ki->keyref);
713                 }
714               else
715                 print_shax_fpr (fp, pubkey->fpr, pubkey->fprlen);
716             }
717           for (uid = kb->uids; uid; uid = uid->next)
718             {
719               print_string (fp, "        user id ..: ", uid->value);
720             }
721
722         }
723     }
724   else
725     {
726       tty_fprintf (fp, " [none]\n");
727       if (label_keyref)
728         tty_fprintf (fp, "      keyref .....: %s\n", label_keyref);
729     }
730
731  leave:
732   release_keyblock (keyblock);
733 }
734
735
736 /* List all keyinfo in INFO using the list of LABELS.  */
737 static void
738 list_all_kinfo (card_info_t info, keyinfolabel_t labels, estream_t fp)
739 {
740   key_info_t kinfo;
741   int idx, i;
742
743   /* Print the keyinfo.  We first print those we known and then all
744    * remaining item.  */
745   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
746     kinfo->xflag = 0;
747   if (labels)
748     {
749       for (idx=0; labels[idx].label; idx++)
750         {
751           tty_fprintf (fp, "%s", labels[idx].label);
752           kinfo = find_kinfo (info, labels[idx].keyref);
753           list_one_kinfo (info->kinfo, kinfo, labels[idx].keyref, fp);
754           if (kinfo)
755             kinfo->xflag = 1;
756         }
757     }
758   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
759     {
760       if (kinfo->xflag)
761         continue;
762       tty_fprintf (fp, "Key %s ", kinfo->keyref);
763       for (i=5+strlen (kinfo->keyref); i < 18; i++)
764         tty_fprintf (fp, ".");
765       tty_fprintf (fp, ":");
766       list_one_kinfo (info->kinfo, kinfo, NULL, fp);
767     }
768 }
769
770
771 /* List OpenPGP card specific data.  */
772 static void
773 list_openpgp (card_info_t info, estream_t fp)
774 {
775   static struct keyinfolabel_s keyinfolabels[] = {
776     { "Signature key ....:", "OPENPGP.1" },
777     { "Encryption key....:", "OPENPGP.2" },
778     { "Authentication key:", "OPENPGP.3" },
779     { NULL, NULL }
780   };
781   int i;
782
783   if (!info->serialno
784       || strncmp (info->serialno, "D27600012401", 12)
785       || strlen (info->serialno) != 32 )
786     {
787       tty_fprintf (fp, "invalid OpenPGP card\n");
788       return;
789     }
790
791   tty_fprintf (fp, "Manufacturer .....: %s\n",
792                get_manufacturer (xtoi_2(info->serialno+16)*256
793                                  + xtoi_2 (info->serialno+18)));
794   tty_fprintf (fp, "Name of cardholder: ");
795   print_isoname (fp, info->disp_name);
796
797   print_string (fp, "Language prefs ...: ", info->disp_lang);
798   tty_fprintf (fp, "Salutation .......: %s\n",
799                info->disp_sex == 1? _("Mr."):
800                info->disp_sex == 2? _("Mrs.") : "");
801   print_string (fp, "URL of public key : ", info->pubkey_url);
802   print_string (fp, "Login data .......: ", info->login_data);
803   if (info->private_do[0])
804     print_string (fp, "Private DO 1 .....: ", info->private_do[0]);
805   if (info->private_do[1])
806     print_string (fp, "Private DO 2 .....: ", info->private_do[1]);
807   if (info->private_do[2])
808     print_string (fp, "Private DO 3 .....: ", info->private_do[2]);
809   if (info->private_do[3])
810     print_string (fp, "Private DO 4 .....: ", info->private_do[3]);
811   if (info->cafpr1len)
812     {
813       tty_fprintf (fp, "CA fingerprint %d .:", 1);
814       print_shax_fpr (fp, info->cafpr1, info->cafpr1len);
815     }
816   if (info->cafpr2len)
817     {
818       tty_fprintf (fp, "CA fingerprint %d .:", 2);
819       print_shax_fpr (fp, info->cafpr2, info->cafpr2len);
820     }
821   if (info->cafpr3len)
822     {
823       tty_fprintf (fp, "CA fingerprint %d .:", 3);
824       print_shax_fpr (fp, info->cafpr3, info->cafpr3len);
825     }
826   tty_fprintf (fp, "Signature PIN ....: %s\n",
827                info->chv1_cached? _("not forced"): _("forced"));
828   if (info->key_attr[0].algo)
829     {
830       tty_fprintf (fp,    "Key attributes ...:");
831       for (i=0; i < DIM (info->key_attr); i++)
832         if (info->key_attr[i].algo == PUBKEY_ALGO_RSA)
833           tty_fprintf (fp, " rsa%u", info->key_attr[i].nbits);
834         else if (info->key_attr[i].algo == PUBKEY_ALGO_ECDH
835                  || info->key_attr[i].algo == PUBKEY_ALGO_ECDSA
836                  || info->key_attr[i].algo == PUBKEY_ALGO_EDDSA)
837           {
838             const char *curve_for_print = "?";
839             const char *oid;
840
841             if (info->key_attr[i].curve
842                 && (oid = openpgp_curve_to_oid (info->key_attr[i].curve, NULL)))
843               curve_for_print = openpgp_oid_to_curve (oid, 0);
844             tty_fprintf (fp, " %s", curve_for_print);
845           }
846       tty_fprintf (fp, "\n");
847     }
848   tty_fprintf (fp, "Max. PIN lengths .: %d %d %d\n",
849                info->chvmaxlen[0], info->chvmaxlen[1], info->chvmaxlen[2]);
850   tty_fprintf (fp, "PIN retry counter : %d %d %d\n",
851                info->chvinfo[0], info->chvinfo[1], info->chvinfo[2]);
852   tty_fprintf (fp, "Signature counter : %lu\n", info->sig_counter);
853   if (info->extcap.kdf)
854     {
855       tty_fprintf (fp, "KDF setting ......: %s\n",
856                    info->kdf_do_enabled ? "on" : "off");
857     }
858   if (info->extcap.bt)
859     {
860       tty_fprintf (fp, "UIF setting ......: Sign=%s Decrypt=%s Auth=%s\n",
861                    info->uif[0] ? "on" : "off", info->uif[1] ? "on" : "off",
862                    info->uif[2] ? "on" : "off");
863     }
864
865   list_all_kinfo (info, keyinfolabels, fp);
866
867 }
868
869
870 /* List PIV card specific data.  */
871 static void
872 list_piv (card_info_t info, estream_t fp)
873 {
874   static struct keyinfolabel_s keyinfolabels[] = {
875     { "PIV authentication:", "PIV.9A" },
876     { "Card authenticat. :", "PIV.9E" },
877     { "Digital signature :", "PIV.9C" },
878     { "Key management ...:", "PIV.9D" },
879     { NULL, NULL }
880   };
881   const char *s;
882   int i;
883
884   if (info->chvusage[0] || info->chvusage[1])
885     {
886       tty_fprintf (fp, "PIN usage policy .:");
887       if ((info->chvusage[0] & 0x40))
888           tty_fprintf (fp, " app-pin");
889       if ((info->chvusage[0] & 0x20))
890         tty_fprintf (fp, " global-pin");
891       if ((info->chvusage[0] & 0x10))
892         tty_fprintf (fp, " occ");
893       if ((info->chvusage[0] & 0x08))
894         tty_fprintf (fp, " vci");
895       if ((info->chvusage[0] & 0x08) && !(info->chvusage[0] & 0x04))
896         tty_fprintf (fp, " pairing");
897
898       if (info->chvusage[1] == 0x10)
899         tty_fprintf (fp, " primary:card");
900       else if (info->chvusage[1] == 0x20)
901         tty_fprintf (fp, " primary:global");
902
903       tty_fprintf (fp, "\n");
904     }
905
906   tty_fprintf (fp, "PIN retry counter :");
907   for (i=0; i < DIM (info->chvinfo); i++)
908     {
909       if (info->chvinfo[i] > 0)
910         tty_fprintf (fp, " %d", info->chvinfo[i]);
911       else
912         {
913           switch (info->chvinfo[i])
914             {
915             case -1: s = "[error]"; break;
916             case -2: s = "-"; break;  /* No such PIN or info not available. */
917             case -3: s = "[blocked]"; break;
918             case -5: s = "[verified]"; break;
919             default: s = "[?]"; break;
920             }
921           tty_fprintf (fp, " %s", s);
922         }
923     }
924   tty_fprintf (fp, "\n");
925   list_all_kinfo (info, keyinfolabels, fp);
926
927 }
928
929
930
931 static void
932 print_a_version (estream_t fp, const char *prefix, unsigned int value)
933 {
934   unsigned int a, b, c, d;
935   a = ((value >> 24) & 0xff);
936   b = ((value >> 16) & 0xff);
937   c = ((value >>  8) & 0xff);
938   d = ((value      ) & 0xff);
939
940   if (a)
941     tty_fprintf (fp, "%s %u.%u.%u.%u\n", prefix, a, b, c, d);
942   else if (b)
943     tty_fprintf (fp, "%s %u.%u.%u\n", prefix, b, c, d);
944   else
945     tty_fprintf (fp, "%s %u.%u\n", prefix, c, d);
946 }
947
948
949 /* Print all available information about the current card. */
950 static void
951 list_card (card_info_t info)
952 {
953   estream_t fp = opt.interactive? NULL : es_stdout;
954
955   tty_fprintf (fp, "Reader ...........: %s\n",
956                info->reader? info->reader : "[none]");
957   if (info->cardtype)
958     tty_fprintf (fp, "Card type ........: %s\n", info->cardtype);
959   if (info->cardversion)
960     print_a_version (fp, "Card firmware ....:", info->cardversion);
961   tty_fprintf (fp, "Serial number ....: %s\n",
962                info->serialno? info->serialno : "[none]");
963   tty_fprintf (fp, "Application type .: %s%s%s%s\n",
964                app_type_string (info->apptype),
965                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? "(":"",
966                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr
967                ? info->apptypestr:"",
968                info->apptype == APP_TYPE_UNKNOWN && info->apptypestr? ")":"");
969   if (info->appversion)
970     print_a_version (fp, "Version ..........:", info->appversion);
971   if (info->serialno && info->dispserialno
972       && strcmp (info->serialno, info->dispserialno))
973     tty_fprintf (fp, "Displayed s/n ....: %s\n", info->dispserialno);
974
975   switch (info->apptype)
976     {
977     case APP_TYPE_OPENPGP: list_openpgp (info, fp); break;
978     case APP_TYPE_PIV:     list_piv (info, fp); break;
979     default: break;
980     }
981 }
982
983
984 \f
985 /* The VERIFY command.  */
986 static gpg_error_t
987 cmd_verify (card_info_t info, char *argstr)
988 {
989   gpg_error_t err;
990   const char *pinref;
991
992   if (!info)
993     return print_help ("verify [chvid]", 0);
994
995   if (*argstr)
996     pinref = argstr;
997   else if (info->apptype == APP_TYPE_OPENPGP)
998     pinref = info->serialno;
999   else if (info->apptype == APP_TYPE_PIV)
1000     pinref = "PIV.80";
1001   else
1002     return gpg_error (GPG_ERR_MISSING_VALUE);
1003
1004   err = scd_checkpin (pinref);
1005   if (err)
1006     log_error ("verify failed: %s <%s>\n",
1007                gpg_strerror (err), gpg_strsource (err));
1008   return err;
1009 }
1010
1011
1012 static gpg_error_t
1013 cmd_authenticate (card_info_t info, char *argstr)
1014 {
1015   gpg_error_t err;
1016   int opt_setkey;
1017   int opt_raw;
1018   char *string = NULL;
1019   char *key = NULL;
1020   size_t keylen;
1021
1022   if (!info)
1023     return print_help
1024       ("AUTHENTICATE [--setkey] [--raw] [< FILE]|KEY\n\n"
1025        "Perform a mutual autentication either by reading the key\n"
1026        "from FILE or by taking it from the command line.  Without\n"
1027        "the option --raw the key is expected to be hex encoded.\n"
1028        "To install a new administration key --setkey is used; this\n"
1029        "requires a prior authentication with the old key.",
1030        APP_TYPE_PIV, 0);
1031
1032   if (info->apptype != APP_TYPE_PIV)
1033     {
1034       log_info ("Note: This is a PIV only command.\n");
1035       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1036     }
1037
1038   opt_setkey = has_leading_option (argstr, "--setkey");
1039   opt_raw = has_leading_option (argstr, "--raw");
1040   argstr = skip_options (argstr);
1041
1042   if (*argstr == '<')  /* Read key from a file. */
1043     {
1044       for (argstr++; spacep (argstr); argstr++)
1045         ;
1046       err = get_data_from_file (argstr, &string, NULL);
1047       if (err)
1048         goto leave;
1049     }
1050
1051   if (opt_raw)
1052     {
1053       key = string? string : xstrdup (argstr);
1054       string = NULL;
1055       keylen = strlen (key);
1056     }
1057   else
1058     {
1059       key = hex_to_buffer (string? string: argstr, &keylen);
1060       if (!key)
1061         {
1062           err = gpg_error_from_syserror ();
1063           goto leave;
1064         }
1065     }
1066   err = scd_setattr (opt_setkey? "SET-ADM-KEY":"AUTH-ADM-KEY", key, keylen);
1067
1068  leave:
1069   if (key)
1070     {
1071       wipememory (key, keylen);
1072       xfree (key);
1073     }
1074   xfree (string);
1075   return err;
1076 }
1077
1078
1079 /* Helper for cmd_name to qyery a part of name.  */
1080 static char *
1081 ask_one_name (const char *prompt)
1082 {
1083   char *name;
1084   int i;
1085
1086   for (;;)
1087     {
1088       name = tty_get (prompt);
1089       trim_spaces (name);
1090       tty_kill_prompt ();
1091       if (!*name || *name == CONTROL_D)
1092         {
1093           if (*name == CONTROL_D)
1094             tty_fprintf (NULL, "\n");
1095           xfree (name);
1096           return NULL;
1097         }
1098       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
1099         ;
1100
1101       /* The name must be in Latin-1 and not UTF-8 - lacking the code
1102        * to ensure this we restrict it to ASCII. */
1103       if (name[i])
1104         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
1105       else if (strchr (name, '<'))
1106         tty_printf (_("Error: The \"<\" character may not be used.\n"));
1107       else if (strstr (name, "  "))
1108         tty_printf (_("Error: Double spaces are not allowed.\n"));
1109       else
1110         return name;
1111       xfree (name);
1112     }
1113 }
1114
1115
1116 /* The NAME command.  */
1117 static gpg_error_t
1118 cmd_name (card_info_t info, const char *argstr)
1119 {
1120   gpg_error_t err;
1121   char *surname, *givenname;
1122   char *isoname, *p;
1123
1124   if (!info)
1125     return print_help
1126       ("name [--clear]\n\n"
1127        "Set the name field of an OpenPGP card.  With --clear the stored\n"
1128        "name is cleared off the card.", APP_TYPE_OPENPGP, APP_TYPE_NKS, 0);
1129
1130   if (info->apptype != APP_TYPE_OPENPGP)
1131     {
1132       log_info ("Note: This is an OpenPGP only command.\n");
1133       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1134     }
1135
1136  again:
1137   if (!strcmp (argstr, "--clear"))
1138     isoname = xstrdup (" "); /* No real way to clear; set to space instead. */
1139   else
1140     {
1141       surname = ask_one_name (_("Cardholder's surname: "));
1142       givenname = ask_one_name (_("Cardholder's given name: "));
1143       if (!surname || !givenname || (!*surname && !*givenname))
1144         {
1145           xfree (surname);
1146           xfree (givenname);
1147           return gpg_error (GPG_ERR_CANCELED);
1148         }
1149
1150       isoname = xstrconcat (surname, "<<", givenname, NULL);
1151       xfree (surname);
1152       xfree (givenname);
1153       for (p=isoname; *p; p++)
1154         if (*p == ' ')
1155           *p = '<';
1156
1157       if (strlen (isoname) > 39 )
1158         {
1159           log_info (_("Error: Combined name too long "
1160                       "(limit is %d characters).\n"), 39);
1161           xfree (isoname);
1162           goto again;
1163         }
1164     }
1165
1166   err = scd_setattr ("DISP-NAME", isoname, strlen (isoname));
1167
1168   xfree (isoname);
1169   return err;
1170 }
1171
1172
1173 static gpg_error_t
1174 cmd_url (card_info_t info, const char *argstr)
1175 {
1176   gpg_error_t err;
1177   char *url;
1178
1179   if (!info)
1180     return print_help
1181       ("URL [--clear]\n\n"
1182        "Set the URL data object.  That data object can be used by\n"
1183        "the FETCH command to retrieve the full public key.  The\n"
1184        "option --clear deletes the content of that data object.",
1185        APP_TYPE_OPENPGP, 0);
1186
1187   if (info->apptype != APP_TYPE_OPENPGP)
1188     {
1189       log_info ("Note: This is an OpenPGP only command.\n");
1190       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1191     }
1192
1193   if (!strcmp (argstr, "--clear"))
1194     url = xstrdup (" "); /* No real way to clear; set to space instead. */
1195   else
1196     {
1197       url = tty_get (_("URL to retrieve public key: "));
1198       trim_spaces (url);
1199       tty_kill_prompt ();
1200       if (!*url || *url == CONTROL_D)
1201         {
1202           err = gpg_error (GPG_ERR_CANCELED);
1203           goto leave;
1204         }
1205     }
1206
1207   err = scd_setattr ("PUBKEY-URL", url, strlen (url));
1208
1209  leave:
1210   xfree (url);
1211   return err;
1212 }
1213
1214
1215 /* Fetch the key from the URL given on the card or try to get it from
1216  * the default keyserver.  */
1217 static gpg_error_t
1218 cmd_fetch (card_info_t info)
1219 {
1220   gpg_error_t err;
1221   key_info_t kinfo;
1222
1223   if (!info)
1224     return print_help
1225       ("FETCH\n\n"
1226        "Retrieve a key using the URL data object or if that is missing\n"
1227        "using the fingerprint.", APP_TYPE_OPENPGP, 0);
1228
1229   if (info->pubkey_url && *info->pubkey_url)
1230     {
1231       /* strlist_t sl = NULL; */
1232
1233       /* add_to_strlist (&sl, info.pubkey_url); */
1234       /* err = keyserver_fetch (ctrl, sl, KEYORG_URL); */
1235       /* free_strlist (sl); */
1236       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1237     }
1238   else if ((kinfo = find_kinfo (info, "OPENPGP.1")) && kinfo->fprlen)
1239     {
1240       /* rc = keyserver_import_fprint (ctrl, info.fpr1, info.fpr1len, */
1241       /*                               opt.keyserver, 0); */
1242       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);  /* FIXME */
1243     }
1244   else
1245     err = gpg_error (GPG_ERR_NO_DATA);
1246
1247   return err;
1248 }
1249
1250
1251 static gpg_error_t
1252 cmd_login (card_info_t info, char *argstr)
1253 {
1254   gpg_error_t err;
1255   char *data;
1256   size_t datalen;
1257
1258   if (!info)
1259     return print_help
1260       ("LOGIN [--clear] [< FILE]\n\n"
1261        "Set the login data object.  If FILE is given the data is\n"
1262        "is read from that file.  This allows for binary data.\n"
1263        "The option --clear deletes the login data.",
1264        APP_TYPE_OPENPGP, 0);
1265
1266   if (!strcmp (argstr, "--clear"))
1267     {
1268       data = xstrdup (" "); /* kludge.  */
1269       datalen = 1;
1270     }
1271   else if (*argstr == '<')  /* Read it from a file */
1272     {
1273       for (argstr++; spacep (argstr); argstr++)
1274         ;
1275       err = get_data_from_file (argstr, &data, &datalen);
1276       if (err)
1277         goto leave;
1278     }
1279   else
1280     {
1281       data = tty_get (_("Login data (account name): "));
1282       trim_spaces (data);
1283       tty_kill_prompt ();
1284       if (!*data || *data == CONTROL_D)
1285         {
1286           err = gpg_error (GPG_ERR_CANCELED);
1287           goto leave;
1288         }
1289       datalen = strlen (data);
1290     }
1291
1292   err = scd_setattr ("LOGIN-DATA", data, datalen);
1293
1294  leave:
1295   xfree (data);
1296   return err;
1297 }
1298
1299
1300 static gpg_error_t
1301 cmd_lang (card_info_t info, const char *argstr)
1302 {
1303   gpg_error_t err;
1304   char *data, *p;
1305
1306   if (!info)
1307     return print_help
1308       ("LANG [--clear]\n\n"
1309        "Change the language info for the card.  This info can be used\n"
1310        "by applications for a personalized greeting.  Up to 4 two-digit\n"
1311        "language identifiers can be entered as a preference.  The option\n"
1312        "--clear removes all identifiers.  GnuPG does not use this info.",
1313        APP_TYPE_OPENPGP, 0);
1314
1315   if (!strcmp (argstr, "--clear"))
1316     data = xstrdup ("  "); /* Note that we need two spaces here.  */
1317   else
1318     {
1319     again:
1320       data = tty_get (_("Language preferences: "));
1321       trim_spaces (data);
1322       tty_kill_prompt ();
1323       if (!*data || *data == CONTROL_D)
1324         {
1325           err = gpg_error (GPG_ERR_CANCELED);
1326           goto leave;
1327         }
1328
1329       if (strlen (data) > 8 || (strlen (data) & 1))
1330         {
1331           log_info (_("Error: invalid length of preference string.\n"));
1332           xfree (data);
1333           goto again;
1334         }
1335
1336       for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1337         ;
1338       if (*p)
1339         {
1340           log_info (_("Error: invalid characters in preference string.\n"));
1341           xfree (data);
1342           goto again;
1343         }
1344     }
1345
1346   err = scd_setattr ("DISP-LANG", data, strlen (data));
1347
1348  leave:
1349   xfree (data);
1350   return err;
1351 }
1352
1353
1354 static gpg_error_t
1355 cmd_salut (card_info_t info, const char *argstr)
1356 {
1357   gpg_error_t err;
1358   char *data = NULL;
1359   const char *str;
1360
1361   if (!info)
1362     return print_help
1363       ("SALUT [--clear]\n\n"
1364        "Change the salutation info for the card.  This info can be used\n"
1365        "by applications for a personalized greeting.  The option --clear\n"
1366        "removes this data object.  GnuPG does not use this info.",
1367        APP_TYPE_OPENPGP, 0);
1368
1369  again:
1370   if (!strcmp (argstr, "--clear"))
1371     str = "9";
1372   else
1373     {
1374       data = tty_get (_("Salutation (M = Mr., F = Mrs., or space): "));
1375       trim_spaces (data);
1376       tty_kill_prompt ();
1377       if (*data == CONTROL_D)
1378         {
1379           err = gpg_error (GPG_ERR_CANCELED);
1380           goto leave;
1381         }
1382
1383       if (!*data)
1384         str = "9";
1385       else if ((*data == 'M' || *data == 'm') && !data[1])
1386         str = "1";
1387       else if ((*data == 'F' || *data == 'f') && !data[1])
1388         str = "2";
1389       else
1390         {
1391           tty_printf (_("Error: invalid response.\n"));
1392           xfree (data);
1393           goto again;
1394         }
1395     }
1396
1397   err = scd_setattr ("DISP-SEX", str, 1);
1398  leave:
1399   xfree (data);
1400   return err;
1401 }
1402
1403
1404 static gpg_error_t
1405 cmd_cafpr (card_info_t info, char *argstr)
1406 {
1407   gpg_error_t err;
1408   char *data = NULL;
1409   const char *s;
1410   int i, c;
1411   unsigned char fpr[32];
1412   int fprlen;
1413   int fprno;
1414   int opt_clear = 0;
1415
1416   if (!info)
1417     return print_help
1418       ("CAFPR [--clear] N\n\n"
1419        "Change the CA fingerprint number N.  N must be in the\n"
1420        "range 1 to 3.  The option --clear clears the specified\n"
1421        "CA fingerprint N or all of them if N is 0 or not given.",
1422        APP_TYPE_OPENPGP, 0);
1423
1424
1425   opt_clear = has_leading_option (argstr, "--clear");
1426   argstr = skip_options (argstr);
1427
1428   if (digitp (argstr))
1429     {
1430       fprno = atoi (argstr);
1431       while (digitp (argstr))
1432         argstr++;
1433       while (spacep (argstr))
1434         argstr++;
1435     }
1436   else
1437     fprno = 0;
1438
1439   if (opt_clear && !fprno)
1440     ; /* Okay: clear all fprs.  */
1441   else if (fprno < 1 || fprno > 3)
1442     {
1443       err = gpg_error (GPG_ERR_INV_ARG);
1444       goto leave;
1445     }
1446
1447  again:
1448   if (opt_clear)
1449     {
1450       memset (fpr, 0, 20);
1451       fprlen = 20;
1452     }
1453   else
1454     {
1455       xfree (data);
1456       data = tty_get (_("CA fingerprint: "));
1457       trim_spaces (data);
1458       tty_kill_prompt ();
1459       if (!*data || *data == CONTROL_D)
1460         {
1461           err = gpg_error (GPG_ERR_CANCELED);
1462           goto leave;
1463         }
1464
1465       for (i=0, s=data; i < sizeof fpr && *s; )
1466         {
1467           while (spacep(s))
1468             s++;
1469           if (*s == ':')
1470             s++;
1471           while (spacep(s))
1472             s++;
1473           c = hextobyte (s);
1474           if (c == -1)
1475             break;
1476           fpr[i++] = c;
1477           s += 2;
1478         }
1479       fprlen = i;
1480       if ((fprlen != 20 && fprlen != 32) || *s)
1481         {
1482           log_error (_("Error: invalid formatted fingerprint.\n"));
1483           goto again;
1484         }
1485     }
1486
1487   if (!fprno)
1488     {
1489       log_assert (opt_clear);
1490       err = scd_setattr ("CA-FPR-1", fpr, fprlen);
1491       if (!err)
1492         err = scd_setattr ("CA-FPR-2", fpr, fprlen);
1493       if (!err)
1494         err = scd_setattr ("CA-FPR-3", fpr, fprlen);
1495     }
1496   else
1497     err = scd_setattr (fprno==1?"CA-FPR-1":
1498                        fprno==2?"CA-FPR-2":
1499                        fprno==3?"CA-FPR-3":"x", fpr, fprlen);
1500
1501  leave:
1502   xfree (data);
1503   return err;
1504 }
1505
1506
1507 static gpg_error_t
1508 cmd_privatedo (card_info_t info, char *argstr)
1509 {
1510   gpg_error_t err;
1511   int opt_clear;
1512   char *do_name = NULL;
1513   char *data = NULL;
1514   size_t datalen;
1515   int do_no;
1516
1517   if (!info)
1518     return print_help
1519       ("PRIVATEDO [--clear] N [< FILE]\n\n"
1520        "Change the private data object N.  N must be in the\n"
1521        "range 1 to 4.  If FILE is given the data is is read\n"
1522        "from that file.  The option --clear clears the data.",
1523        APP_TYPE_OPENPGP, 0);
1524
1525   opt_clear = has_leading_option (argstr, "--clear");
1526   argstr = skip_options (argstr);
1527
1528   if (digitp (argstr))
1529     {
1530       do_no = atoi (argstr);
1531       while (digitp (argstr))
1532         argstr++;
1533       while (spacep (argstr))
1534         argstr++;
1535     }
1536   else
1537     do_no = 0;
1538
1539   if (do_no < 1 || do_no > 4)
1540     {
1541       err = gpg_error (GPG_ERR_INV_ARG);
1542       goto leave;
1543     }
1544   do_name = xasprintf ("PRIVATE-DO-%d", do_no);
1545
1546   if (opt_clear)
1547     {
1548       data = xstrdup (" ");
1549       datalen = 1;
1550     }
1551   else if (*argstr == '<')  /* Read it from a file */
1552     {
1553       for (argstr++; spacep (argstr); argstr++)
1554         ;
1555       err = get_data_from_file (argstr, &data, &datalen);
1556       if (err)
1557         goto leave;
1558     }
1559   else if (*argstr)
1560     {
1561       err = gpg_error (GPG_ERR_INV_ARG);
1562       goto leave;
1563     }
1564   else
1565     {
1566       data = tty_get (_("Private DO data: "));
1567       trim_spaces (data);
1568       tty_kill_prompt ();
1569       datalen = strlen (data);
1570       if (!*data || *data == CONTROL_D)
1571         {
1572           err = gpg_error (GPG_ERR_CANCELED);
1573           goto leave;
1574         }
1575     }
1576
1577   err = scd_setattr (do_name, data, datalen);
1578
1579  leave:
1580   xfree (do_name);
1581   xfree (data);
1582   return err;
1583 }
1584
1585
1586 static gpg_error_t
1587 cmd_writecert (card_info_t info, char *argstr)
1588 {
1589   gpg_error_t err;
1590   int opt_clear;
1591   char *certref_buffer = NULL;
1592   char *certref;
1593   char *data = NULL;
1594   size_t datalen;
1595
1596   if (!info)
1597     return print_help
1598       ("WRITECERT [--clear] CERTREF < FILE\n\n"
1599        "Write a certificate for key 3.  Unless --clear is given\n"
1600        "the file argument is mandatory.  The option --clear removes\n"
1601        "the certificate from the card.",
1602        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1603
1604   opt_clear = has_leading_option (argstr, "--clear");
1605   argstr = skip_options (argstr);
1606
1607   certref = argstr;
1608   if ((argstr = strchr (certref, ' ')))
1609     {
1610       *argstr++ = 0;
1611       trim_spaces (certref);
1612       trim_spaces (argstr);
1613     }
1614   else /* Let argstr point to an empty string.  */
1615     argstr = certref + strlen (certref);
1616
1617   if (info->apptype == APP_TYPE_OPENPGP)
1618     {
1619       if (ascii_strcasecmp (certref, "OPENPGP.3") && strcmp (certref, "3"))
1620         {
1621           err = gpg_error (GPG_ERR_INV_ID);
1622           log_error ("Error: CERTREF must be \"3\" or \"OPENPGP.3\"\n");
1623           goto leave;
1624         }
1625       certref = certref_buffer = xstrdup ("OPENPGP.3");
1626     }
1627   else /* Upcase the certref; prepend cardtype if needed.  */
1628     {
1629       if (!strchr (certref, '.'))
1630         certref_buffer = xstrconcat (app_type_string (info->apptype), ".",
1631                                      certref, NULL);
1632       else
1633         certref_buffer = xstrdup (certref);
1634       ascii_strupr (certref_buffer);
1635       certref = certref_buffer;
1636     }
1637
1638   if (opt_clear)
1639     {
1640       data = xstrdup (" ");
1641       datalen = 1;
1642     }
1643   else if (*argstr == '<')  /* Read it from a file */
1644     {
1645       for (argstr++; spacep (argstr); argstr++)
1646         ;
1647       err = get_data_from_file (argstr, &data, &datalen);
1648       if (err)
1649         goto leave;
1650       if (ascii_memistr (data, datalen, "-----BEGIN CERTIFICATE-----")
1651           && ascii_memistr (data, datalen, "-----END CERTIFICATE-----")
1652           && !memchr (data, 0, datalen) && !memchr (data, 1, datalen))
1653         {
1654           struct b64state b64;
1655
1656           err = b64dec_start (&b64, "");
1657           if (!err)
1658             err = b64dec_proc (&b64, data, datalen, &datalen);
1659           if (!err)
1660             err = b64dec_finish (&b64);
1661           if (err)
1662             goto leave;
1663         }
1664     }
1665   else
1666     {
1667       err = gpg_error (GPG_ERR_INV_ARG);
1668       goto leave;
1669     }
1670
1671   err = scd_writecert (certref, data, datalen);
1672
1673  leave:
1674   xfree (data);
1675   xfree (certref_buffer);
1676   return err;
1677 }
1678
1679
1680 static gpg_error_t
1681 cmd_readcert (card_info_t info, char *argstr)
1682 {
1683   gpg_error_t err;
1684   char *certref_buffer = NULL;
1685   char *certref;
1686   void *data = NULL;
1687   size_t datalen;
1688   const char *fname;
1689
1690   if (!info)
1691     return print_help
1692       ("READCERT CERTREF > FILE\n\n"
1693        "Read the certificate for key CERTREF and store it in FILE.",
1694        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1695
1696   argstr = skip_options (argstr);
1697
1698   certref = argstr;
1699   if ((argstr = strchr (certref, ' ')))
1700     {
1701       *argstr++ = 0;
1702       trim_spaces (certref);
1703       trim_spaces (argstr);
1704     }
1705   else /* Let argstr point to an empty string.  */
1706     argstr = certref + strlen (certref);
1707
1708   if (info->apptype == APP_TYPE_OPENPGP)
1709     {
1710       if (ascii_strcasecmp (certref, "OPENPGP.3") && strcmp (certref, "3"))
1711         {
1712           err = gpg_error (GPG_ERR_INV_ID);
1713           log_error ("Error: CERTREF must be \"3\" or \"OPENPGP.3\"\n");
1714           goto leave;
1715         }
1716       certref = certref_buffer = xstrdup ("OPENPGP.3");
1717     }
1718
1719   if (*argstr == '>')  /* Write it to a file */
1720     {
1721       for (argstr++; spacep (argstr); argstr++)
1722         ;
1723       fname = argstr;
1724     }
1725   else
1726     {
1727       err = gpg_error (GPG_ERR_INV_ARG);
1728       goto leave;
1729     }
1730
1731   err = scd_readcert (certref, &data, &datalen);
1732   if (err)
1733     goto leave;
1734
1735   err = put_data_to_file (fname, data, datalen);
1736
1737  leave:
1738   xfree (data);
1739   xfree (certref_buffer);
1740   return err;
1741 }
1742
1743
1744 static gpg_error_t
1745 cmd_writekey (card_info_t info, char *argstr)
1746 {
1747   gpg_error_t err;
1748   int opt_force;
1749   char *argv[2];
1750   int argc;
1751   char *keyref_buffer = NULL;
1752   char *keyref;
1753   char *keygrip;
1754
1755   if (!info)
1756     return print_help
1757       ("WRITEKEY [--force] KEYREF KEYGRIP\n\n"
1758        "Write a private key object identified by KEYGRIP to slot KEYREF.\n"
1759        "Use --force to overwrite an existing key.",
1760        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1761
1762   opt_force = has_leading_option (argstr, "--force");
1763   argstr = skip_options (argstr);
1764
1765   argc = split_fields (argstr, argv, DIM (argv));
1766   if (argc < 2)
1767     {
1768       err = gpg_error (GPG_ERR_INV_ARG);
1769       goto leave;
1770     }
1771
1772   /* Upcase the keyref; prepend cardtype if needed.  */
1773   keyref = argv[0];
1774   if (!strchr (keyref, '.'))
1775     keyref_buffer = xstrconcat (app_type_string (info->apptype), ".",
1776                                 keyref, NULL);
1777   else
1778     keyref_buffer = xstrdup (keyref);
1779   ascii_strupr (keyref_buffer);
1780   keyref = keyref_buffer;
1781
1782   /* Get the keygrip.  */
1783   keygrip = argv[1];
1784   if (strlen (keygrip) != 40
1785       && !(keygrip[0] == '&' && strlen (keygrip+1) == 40))
1786     {
1787       log_error (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1788       err = gpg_error (GPG_ERR_INV_ARG);
1789       goto leave;
1790     }
1791
1792   err = scd_writekey (keyref, opt_force, keygrip);
1793
1794  leave:
1795   xfree (keyref_buffer);
1796   return err;
1797 }
1798
1799
1800 static gpg_error_t
1801 cmd_forcesig (card_info_t info)
1802 {
1803   gpg_error_t err;
1804   int newstate;
1805
1806   if (!info)
1807     return print_help
1808       ("FORCESIG\n\n"
1809        "Toggle the forcesig flag of an OpenPGP card.",
1810        APP_TYPE_OPENPGP, 0);
1811
1812   if (info->apptype != APP_TYPE_OPENPGP)
1813     {
1814       log_info ("Note: This is an OpenPGP only command.\n");
1815       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1816     }
1817
1818   newstate = !info->chv1_cached;
1819
1820   err = scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
1821   if (err)
1822     goto leave;
1823
1824   /* Read it back to be sure we have the right toggle state the next
1825    * time.  */
1826   err = scd_getattr ("CHV-STATUS", info);
1827
1828  leave:
1829   return err;
1830 }
1831
1832
1833 \f
1834 /* Helper for cmd_generate_openpgp.  Noe that either 0 or 1 is stored at
1835  * FORCED_CHV1. */
1836 static gpg_error_t
1837 check_pin_for_key_operation (card_info_t info, int *forced_chv1)
1838 {
1839   gpg_error_t err = 0;
1840
1841   *forced_chv1 = !info->chv1_cached;
1842   if (*forced_chv1)
1843     { /* Switch off the forced mode so that during key generation we
1844        * don't get bothered with PIN queries for each self-signature. */
1845       err = scd_setattr ("CHV-STATUS-1", "\x01", 1);
1846       if (err)
1847         {
1848           log_error ("error clearing forced signature PIN flag: %s\n",
1849                      gpg_strerror (err));
1850           *forced_chv1 = -1;  /* Not changed.  */
1851           goto leave;
1852         }
1853     }
1854
1855   /* Check the PIN now, so that we won't get asked later for each
1856    * binding signature.  */
1857   err = scd_checkpin (info->serialno);
1858   if (err)
1859     log_error ("error checking the PIN: %s\n", gpg_strerror (err));
1860
1861  leave:
1862   return err;
1863 }
1864
1865
1866 /* Helper for cmd_generate_openpgp.  */
1867 static void
1868 restore_forced_chv1 (int *forced_chv1)
1869 {
1870   gpg_error_t err;
1871
1872   /* Note the possible values stored at FORCED_CHV1:
1873    *   0 - forcesig was not enabled.
1874    *   1 - forcesig was enabled - enable it again.
1875    *  -1 - We have not changed anything.  */
1876   if (*forced_chv1 == 1)
1877     { /* Switch back to forced state. */
1878       err = scd_setattr ("CHV-STATUS-1", "", 1);
1879       if (err)
1880         log_error ("error setting forced signature PIN flag: %s\n",
1881                    gpg_strerror (err));
1882       *forced_chv1 = 0;
1883     }
1884 }
1885
1886
1887 /* Implementation of cmd_generate for OpenPGP cards.  */
1888 static gpg_error_t
1889 generate_openpgp (card_info_t info)
1890 {
1891   gpg_error_t err;
1892   int forced_chv1 = -1;
1893   int want_backup;
1894   char *answer = NULL;
1895   key_info_t kinfo1, kinfo2, kinfo3;
1896
1897   if (info->extcap.ki)
1898     {
1899       xfree (answer);
1900       answer = tty_get (_("Make off-card backup of encryption key? (Y/n) "));
1901       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1902       tty_kill_prompt ();
1903       if (*answer == CONTROL_D)
1904         {
1905           err = gpg_error (GPG_ERR_CANCELED);
1906           goto leave;
1907         }
1908     }
1909   else
1910     want_backup = 0;
1911
1912   kinfo1 = find_kinfo (info, "OPENPGP.1");
1913   kinfo2 = find_kinfo (info, "OPENPGP.2");
1914   kinfo3 = find_kinfo (info, "OPENPGP.3");
1915
1916   if ((kinfo1 && kinfo1->fprlen && !mem_is_zero (kinfo1->fpr,kinfo1->fprlen))
1917       || (kinfo2 && kinfo2->fprlen && !mem_is_zero (kinfo2->fpr,kinfo2->fprlen))
1918       || (kinfo3 && kinfo3->fprlen && !mem_is_zero (kinfo3->fpr,kinfo3->fprlen))
1919       )
1920     {
1921       tty_printf ("\n");
1922       log_info (_("Note: keys are already stored on the card!\n"));
1923       tty_printf ("\n");
1924       answer = tty_get (_("Replace existing keys? (y/N) "));
1925       tty_kill_prompt ();
1926       if (*answer == CONTROL_D)
1927         {
1928           err = gpg_error (GPG_ERR_CANCELED);
1929           goto leave;
1930         }
1931
1932       if (!answer_is_yes_no_default (answer, 0/*(default to No)*/))
1933         {
1934           err = gpg_error (GPG_ERR_CANCELED);
1935           goto leave;
1936         }
1937     }
1938
1939   /* If no displayed name has been set, we assume that this is a fresh
1940    * card and print a hint about the default PINs.  */
1941   if (!info->disp_name || !*info->disp_name)
1942     {
1943       tty_printf ("\n");
1944       tty_printf (_("Please note that the factory settings of the PINs are\n"
1945                     "   PIN = '%s'     Admin PIN = '%s'\n"
1946                     "You should change them using the command --change-pin\n"),
1947                   OPENPGP_USER_PIN_DEFAULT, OPENPGP_ADMIN_PIN_DEFAULT);
1948       tty_printf ("\n");
1949     }
1950
1951   err = check_pin_for_key_operation (info, &forced_chv1);
1952   if (err)
1953     goto leave;
1954
1955   /* FIXME: We need to divert to a function which spwans gpg which
1956    * will then create the key.  This also requires new features in
1957    * gpg.  We might also first create the keys on the card and then
1958    * tell gpg to use them to create the OpenPGP keyblock. */
1959   /* generate_keypair (ctrl, 1, NULL, info.serialno, want_backup); */
1960   (void)want_backup;
1961   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1962
1963  leave:
1964   restore_forced_chv1 (&forced_chv1);
1965   xfree (answer);
1966   return err;
1967 }
1968
1969
1970 /* Generic implementation of cmd_generate.  */
1971 static gpg_error_t
1972 generate_generic (card_info_t info, const char *keyref, int force,
1973                   const char *algo)
1974 {
1975   gpg_error_t err;
1976
1977   (void)info;
1978
1979   err = scd_genkey (keyref, force, algo, NULL);
1980
1981   return err;
1982 }
1983
1984
1985 static gpg_error_t
1986 cmd_generate (card_info_t info, char *argstr)
1987 {
1988   static char * const valid_algos[] =
1989     { "rsa2048", "rsa3072", "rsa4096",
1990       "nistp256", "nistp384", "nistp521",
1991       "ed25519", "cv25519",
1992       NULL
1993     };
1994   gpg_error_t err;
1995   int opt_force;
1996   char *opt_algo = NULL; /* Malloced.  */
1997   char *keyref_buffer = NULL;  /* Malloced.  */
1998   char *keyref;          /* Points into argstr or keyref_buffer.  */
1999   int i;
2000
2001   if (!info)
2002     return print_help
2003       ("GENERATE [--force] [--algo=ALGO] KEYREF\n\n"
2004        "Create a new key on a card.  For OpenPGP cards are menu is used\n"
2005        "and KEYREF is ignored.  Use --force to overwrite an existing key.",
2006        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2007
2008   if (opt.interactive || opt.verbose)
2009     log_info (_("%s card no. %s detected\n"),
2010               app_type_string (info->apptype),
2011               info->dispserialno? info->dispserialno : info->serialno);
2012
2013   opt_force = has_leading_option (argstr, "--force");
2014   err = get_option_value (argstr, "--algo", &opt_algo);
2015   if (err)
2016     goto leave;
2017   argstr = skip_options (argstr);
2018
2019   keyref = argstr;
2020   if ((argstr = strchr (keyref, ' ')))
2021     {
2022       *argstr++ = 0;
2023       trim_spaces (keyref);
2024       trim_spaces (argstr);
2025     }
2026   else /* Let argstr point to an empty string.  */
2027     argstr = keyref + strlen (keyref);
2028
2029   if (!*keyref)
2030     keyref = NULL;
2031
2032   if (*argstr)
2033     {
2034       /* Extra arguments found.  */
2035       err = gpg_error (GPG_ERR_INV_ARG);
2036       goto leave;
2037     }
2038
2039   if (opt_algo)
2040     {
2041       for (i=0; valid_algos[i]; i++)
2042         if (!strcmp (valid_algos[i], opt_algo))
2043           break;
2044       if (!valid_algos[i])
2045         {
2046           err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2047           log_info ("Invalid algorithm '%s' given.  Use one:\n", opt_algo);
2048           for (i=0; valid_algos[i]; i++)
2049             if (!(i%5))
2050               log_info ("  %s%s", valid_algos[i], valid_algos[i+1]?",":".");
2051             else
2052               log_printf (" %s%s", valid_algos[i], valid_algos[i+1]?",":".");
2053           log_info ("Note that the card may not support all of them.\n");
2054           goto leave;
2055         }
2056     }
2057
2058   /* Upcase the keyref; if it misses the cardtype, prepend it.  */
2059   if (keyref)
2060     {
2061       if (!strchr (keyref, '.'))
2062         keyref_buffer = xstrconcat (app_type_string (info->apptype), ".",
2063                                     keyref, NULL);
2064       else
2065         keyref_buffer = xstrdup (keyref);
2066       ascii_strupr (keyref_buffer);
2067       keyref = keyref_buffer;
2068     }
2069
2070   /* Special checks.  */
2071   if ((info->cardtype && !strcmp (info->cardtype, "yubikey"))
2072       && info->cardversion >= 0x040200 && info->cardversion < 0x040305)
2073     {
2074       log_error ("On-chip key generation on this YubiKey has been blocked.\n");
2075       log_info ("Please see <https://yubi.co/ysa201701> for details\n");
2076       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2077       goto leave;
2078     }
2079
2080   /* Divert to dedicated functions.  */
2081   if (info->apptype == APP_TYPE_OPENPGP)
2082     {
2083       if (opt_force || opt_algo || keyref)
2084         log_info ("Note: Options are ignored for OpenPGP cards.\n");
2085       err = generate_openpgp (info);
2086     }
2087   else if (!keyref)
2088     err = gpg_error (GPG_ERR_INV_ID);
2089   else
2090     err = generate_generic (info, keyref, opt_force, opt_algo);
2091
2092  leave:
2093   xfree (opt_algo);
2094   xfree (keyref_buffer);
2095   return err;
2096 }
2097
2098
2099 \f
2100 /* Sub-menu to change a PIN.  */
2101 static gpg_error_t
2102 cmd_passwd (card_info_t info, char *argstr)
2103 {
2104   gpg_error_t err;
2105   char *answer = NULL;
2106   const char *pinref;
2107
2108   if (!info)
2109     return print_help
2110       ("PASSWD [PINREF]\n\n"
2111        "Menu to change or unblock the PINs.  Note that the\n"
2112        "presented menu options depend on the type of card\n"
2113        "and whether the admin mode is enabled.  For OpenPGP\n"
2114        "and PIV cards defaults for PINREF are available.",
2115        0);
2116
2117   if (opt.interactive || opt.verbose)
2118     log_info (_("%s card no. %s detected\n"),
2119               app_type_string (info->apptype),
2120               info->dispserialno? info->dispserialno : info->serialno);
2121
2122   if (!*argstr && info->apptype == APP_TYPE_OPENPGP)
2123     {
2124       /* For an OpenPGP card we present the well known menu if no
2125        * argument is given.  */
2126       for (;;)
2127         {
2128           tty_printf ("\n");
2129           tty_printf ("1 - change PIN\n"
2130                       "2 - unblock and set new PIN\n"
2131                       "3 - change Admin PIN\n"
2132                       "4 - set the Reset Code\n"
2133                       "Q - quit\n");
2134           tty_printf ("\n");
2135
2136           err = 0;
2137           xfree (answer);
2138           answer = tty_get (_("Your selection? "));
2139           tty_kill_prompt ();
2140           if (*answer == CONTROL_D)
2141             break;  /* Quit.  */
2142           if (strlen (answer) != 1)
2143             continue;
2144           if (*answer == 'q' || *answer == 'Q')
2145             break;  /* Quit.  */
2146
2147           if (*answer == '1')
2148             {
2149               /* Change PIN (same as the direct thing in non-admin mode).  */
2150               err = scd_change_pin ("OPENPGP.1", 0);
2151               if (err)
2152                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
2153               else
2154                 log_info ("PIN changed.\n");
2155             }
2156           else if (*answer == '2')
2157             {
2158               /* Unblock PIN by setting a new PIN.  */
2159               err = scd_change_pin ("OPENPGP.1", 1);
2160               if (err)
2161                 log_error ("Error unblocking the PIN: %s\n", gpg_strerror(err));
2162               else
2163                 log_info ("PIN unblocked and new PIN set.\n");
2164             }
2165           else if (*answer == '3')
2166             {
2167               /* Change Admin PIN.  */
2168               err = scd_change_pin ("OPENPGP.3", 0);
2169               if (err)
2170                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
2171               else
2172                 log_info ("PIN changed.\n");
2173           }
2174           else if (*answer == '4')
2175             {
2176               /* Set a new Reset Code.  */
2177               err = scd_change_pin ("OPENPGP.2", 1);
2178               if (err)
2179                 log_error ("Error setting the Reset Code: %s\n",
2180                            gpg_strerror (err));
2181               else
2182                 log_info ("Reset Code set.\n");
2183             }
2184
2185         } /*end for loop*/
2186     }
2187   else
2188     {
2189       if (*argstr)
2190         pinref = argstr;
2191       else if (info->apptype == APP_TYPE_PIV)
2192         pinref = "PIV.80";
2193       else
2194         {
2195           /* Note that we do not have a default value for OpenPGP
2196            * because we want to be mostly compatible to "gpg
2197            * --card-edit" and show a menu in that case (above).  */
2198           err = gpg_error (GPG_ERR_MISSING_VALUE);
2199           goto leave;
2200         }
2201       err = scd_change_pin (pinref, 0);
2202       if (err)
2203         goto leave;
2204
2205       if (info->apptype == APP_TYPE_PIV
2206           && !ascii_strcasecmp (pinref, "PIV.81"))
2207         log_info ("PUK changed.\n");
2208       else
2209         log_info ("PIN changed.\n");
2210     }
2211
2212  leave:
2213   xfree (answer);
2214   return err;
2215 }
2216
2217
2218 static gpg_error_t
2219 cmd_unblock (card_info_t info)
2220 {
2221   gpg_error_t err = 0;
2222
2223   if (!info)
2224     return print_help
2225       ("UNBLOCK\n\n"
2226        "Unblock a PIN using a PUK or Reset Code.  Note that OpenPGP\n"
2227        "cards prior to version 2 can't use this; instead the PASSWD\n"
2228        "command can be used to set a new PIN.",
2229        0);
2230
2231   if (opt.interactive || opt.verbose)
2232     log_info (_("%s card no. %s detected\n"),
2233               app_type_string (info->apptype),
2234               info->dispserialno? info->dispserialno : info->serialno);
2235
2236   if (info->apptype == APP_TYPE_OPENPGP)
2237     {
2238       if (!info->is_v2)
2239         {
2240           log_error (_("This command is only available for version 2 cards\n"));
2241           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2242         }
2243       else if (!info->chvinfo[1])
2244         {
2245           log_error (_("Reset Code not or not anymore available\n"));
2246           err = gpg_error (GPG_ERR_PIN_BLOCKED);
2247         }
2248       else
2249         {
2250           err = scd_change_pin ("OPENPGP.2", 0);
2251           if (!err)
2252             log_info ("PIN changed.\n");
2253         }
2254     }
2255   else if (info->apptype == APP_TYPE_PIV)
2256     {
2257       /* Unblock the Application PIN.  */
2258       err = scd_change_pin ("PIV.80", 1);
2259       if (!err)
2260         log_info ("PIN unblocked and changed.\n");
2261     }
2262   else
2263     {
2264       log_info ("Unblocking not yet supported for '%s'\n",
2265                 app_type_string (info->apptype));
2266       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2267     }
2268
2269   return err;
2270 }
2271
2272
2273 /* Note: On successful execution a redisplay should be scheduled.  If
2274  * this function fails the card may be in an unknown state. */
2275 static gpg_error_t
2276 cmd_factoryreset (card_info_t info)
2277 {
2278   gpg_error_t err;
2279   char *answer = NULL;
2280   int termstate = 0;
2281   int any_apdu = 0;
2282   int is_yubikey = 0;
2283   int i;
2284
2285
2286   if (!info)
2287     return print_help
2288       ("FACTORY-RESET\n\n"
2289        "Do a complete reset of some OpenPGP and PIV cards.  This\n"
2290        "deletes all data and keys and resets the PINs to their default.\n"
2291        "This is mainly used by developers with scratch cards.  Don't\n"
2292        "worry, you need to confirm before the command proceeds.",
2293        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2294
2295   /* We support the factory reset for most OpenPGP cards and Yubikeys
2296    * with the PIV application.  */
2297   if (info->apptype == APP_TYPE_OPENPGP)
2298     ;
2299   else if (info->apptype == APP_TYPE_PIV
2300            && info->cardtype && !strcmp (info->cardtype, "yubikey"))
2301     is_yubikey = 1;
2302   else
2303
2304     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2305
2306   /* For an OpenPGP card the code below basically does the same what
2307    * this gpg-connect-agent script does:
2308    *
2309    *   scd reset
2310    *   scd serialno undefined
2311    *   scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
2312    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2313    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2314    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2315    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2316    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2317    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2318    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2319    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2320    *   scd apdu 00 e6 00 00
2321    *   scd apdu 00 44 00 00
2322    *   scd reset
2323    *   /echo Card has been reset to factory defaults
2324    *
2325    * For a PIV application on a Yubikey it merely issues the Yubikey
2326    * specific resset command.
2327    */
2328
2329   err = scd_learn (info);
2330   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
2331       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
2332     termstate = 1;
2333   else if (err)
2334     {
2335       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
2336       goto leave;
2337     }
2338
2339   if (opt.interactive || opt.verbose)
2340     log_info (_("%s card no. %s detected\n"),
2341               app_type_string (info->apptype),
2342               info->dispserialno? info->dispserialno : info->serialno);
2343
2344   if (!termstate || is_yubikey)
2345     {
2346       if (!is_yubikey)
2347         {
2348           if (!(info->status_indicator == 3 || info->status_indicator == 5))
2349             {
2350               /* Note: We won't see status-indicator 3 here because it
2351                * is not possible to select a card application in
2352                * termination state.  */
2353               log_error (_("This command is not supported by this card\n"));
2354               err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2355               goto leave;
2356             }
2357         }
2358
2359       tty_printf ("\n");
2360       log_info
2361         (_("Note: This command destroys all keys stored on the card!\n"));
2362       tty_printf ("\n");
2363       xfree (answer);
2364       answer = tty_get (_("Continue? (y/N) "));
2365       tty_kill_prompt ();
2366       trim_spaces (answer);
2367       if (*answer == CONTROL_D
2368           || !answer_is_yes_no_default (answer, 0/*(default to no)*/))
2369         {
2370           err = gpg_error (GPG_ERR_CANCELED);
2371           goto leave;
2372         }
2373
2374       xfree (answer);
2375       answer = tty_get (_("Really do a factory reset? (enter \"yes\") "));
2376       tty_kill_prompt ();
2377       trim_spaces (answer);
2378       if (strcmp (answer, "yes") && strcmp (answer,_("yes")))
2379         {
2380           err = gpg_error (GPG_ERR_CANCELED);
2381           goto leave;
2382         }
2383
2384
2385       if (is_yubikey)
2386         {
2387           /* The PIV application si already selected, we only need to
2388            * send the special reset APDU after having blocked PIN and
2389            * PUK.  Note that blocking the PUK is done using the
2390            * unblock PIN command.  */
2391           any_apdu = 1;
2392           for (i=0; i < 5; i++)
2393             send_apdu ("0020008008FFFFFFFFFFFFFFFF", "VERIFY", 0xffff,
2394                        NULL, NULL);
2395           for (i=0; i < 5; i++)
2396             send_apdu ("002C008010FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
2397                        "RESET RETRY COUNTER", 0xffff, NULL, NULL);
2398           err = send_apdu ("00FB000001FF", "YUBIKEY RESET", 0, NULL, NULL);
2399           if (err)
2400             goto leave;
2401         }
2402       else /* OpenPGP card.  */
2403         {
2404           any_apdu = 1;
2405           /* We need to select a card application before we can send APDUs
2406            * to the card without scdaemon doing anything on its own.  */
2407           err = send_apdu (NULL, "RESET", 0, NULL, NULL);
2408           if (err)
2409             goto leave;
2410           err = send_apdu ("undefined", "dummy select ", 0, NULL, NULL);
2411           if (err)
2412             goto leave;
2413           /* Select the OpenPGP application.  */
2414           err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0,
2415                            NULL, NULL);
2416           if (err)
2417             goto leave;
2418
2419           /* Do some dummy verifies with wrong PINs to set the retry
2420            * counter to zero.  We can't easily use the card version 2.1
2421            * feature of presenting the admin PIN to allow the terminate
2422            * command because there is no machinery in scdaemon to catch
2423            * the verify command and ask for the PIN when the "APDU"
2424            * command is used.
2425            * Here, the length of dummy wrong PIN is 32-byte, also
2426            * supporting authentication with KDF DO.  */
2427           for (i=0; i < 4; i++)
2428             send_apdu ("0020008120"
2429                        "40404040404040404040404040404040"
2430                        "40404040404040404040404040404040", "VERIFY", 0xffff,
2431                        NULL, NULL);
2432           for (i=0; i < 4; i++)
2433             send_apdu ("0020008320"
2434                        "40404040404040404040404040404040"
2435                        "40404040404040404040404040404040", "VERIFY", 0xffff,
2436                        NULL, NULL);
2437
2438           /* Send terminate datafile command.  */
2439           err = send_apdu ("00e60000", "TERMINATE DF", 0x6985, NULL, NULL);
2440           if (err)
2441             goto leave;
2442         }
2443     }
2444
2445   if (!is_yubikey)
2446     {
2447       any_apdu = 1;
2448       /* Send activate datafile command.  This is used without
2449        * confirmation if the card is already in termination state.  */
2450       err = send_apdu ("00440000", "ACTIVATE DF", 0, NULL, NULL);
2451       if (err)
2452         goto leave;
2453     }
2454
2455   /* Finally we reset the card reader once more.  */
2456   err = send_apdu (NULL, "RESET", 0, NULL, NULL);
2457   if (err)
2458     goto leave;
2459
2460   /* Then, connect the card again (answer used as a dummy).  */
2461   xfree (answer); answer = NULL;
2462   err = scd_serialno (&answer, NULL);
2463
2464  leave:
2465   if (err && any_apdu && !is_yubikey)
2466     {
2467       log_info ("Due to an error the card might be in an inconsistent state\n"
2468                 "You should run the LIST command to check this.\n");
2469       /* FIXME: We need a better solution in the case that the card is
2470        * in a termination state, i.e. the card was removed before the
2471        * activate was sent.  The best solution I found with v2.1
2472        * Zeitcontrol card was to kill scdaemon and the issue this
2473        * sequence with gpg-connect-agent:
2474        *   scd reset
2475        *   scd serialno undefined
2476        *   scd apdu 00A4040006D27600012401 (returns error)
2477        *   scd apdu 00440000
2478        * Then kill scdaemon again and issue:
2479        *   scd reset
2480        *   scd serialno openpgp
2481        */
2482     }
2483   xfree (answer);
2484   return err;
2485 }
2486
2487
2488 /* Generate KDF data.  This is a helper for cmd_kdfsetup.  */
2489 static gpg_error_t
2490 gen_kdf_data (unsigned char *data, int single_salt)
2491 {
2492   gpg_error_t err;
2493   const unsigned char h0[] = { 0x81, 0x01, 0x03,
2494                                0x82, 0x01, 0x08,
2495                                0x83, 0x04 };
2496   const unsigned char h1[] = { 0x84, 0x08 };
2497   const unsigned char h2[] = { 0x85, 0x08 };
2498   const unsigned char h3[] = { 0x86, 0x08 };
2499   const unsigned char h4[] = { 0x87, 0x20 };
2500   const unsigned char h5[] = { 0x88, 0x20 };
2501   unsigned char *p, *salt_user, *salt_admin;
2502   unsigned char s2k_char;
2503   unsigned int iterations;
2504   unsigned char count_4byte[4];
2505
2506   p = data;
2507
2508   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
2509   iterations = S2K_DECODE_COUNT (s2k_char);
2510   count_4byte[0] = (iterations >> 24) & 0xff;
2511   count_4byte[1] = (iterations >> 16) & 0xff;
2512   count_4byte[2] = (iterations >>  8) & 0xff;
2513   count_4byte[3] = (iterations & 0xff);
2514
2515   memcpy (p, h0, sizeof h0);
2516   p += sizeof h0;
2517   memcpy (p, count_4byte, sizeof count_4byte);
2518   p += sizeof count_4byte;
2519   memcpy (p, h1, sizeof h1);
2520   salt_user = (p += sizeof h1);
2521   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2522   p += 8;
2523
2524   if (single_salt)
2525     salt_admin = salt_user;
2526   else
2527     {
2528       memcpy (p, h2, sizeof h2);
2529       p += sizeof h2;
2530       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2531       p += 8;
2532       memcpy (p, h3, sizeof h3);
2533       salt_admin = (p += sizeof h3);
2534       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2535       p += 8;
2536     }
2537
2538   memcpy (p, h4, sizeof h4);
2539   p += sizeof h4;
2540   err = gcry_kdf_derive (OPENPGP_USER_PIN_DEFAULT,
2541                          strlen (OPENPGP_USER_PIN_DEFAULT),
2542                          GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2543                          salt_user, 8, iterations, 32, p);
2544   p += 32;
2545   if (!err)
2546     {
2547       memcpy (p, h5, sizeof h5);
2548       p += sizeof h5;
2549       err = gcry_kdf_derive (OPENPGP_ADMIN_PIN_DEFAULT,
2550                              strlen (OPENPGP_ADMIN_PIN_DEFAULT),
2551                              GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2552                              salt_admin, 8, iterations, 32, p);
2553     }
2554
2555   return err;
2556 }
2557
2558
2559 static gpg_error_t
2560 cmd_kdfsetup (card_info_t info, char *argstr)
2561 {
2562   gpg_error_t err;
2563   unsigned char kdf_data[OPENPGP_KDF_DATA_LENGTH_MAX];
2564   int single = (*argstr != 0);
2565
2566   if (!info)
2567     return print_help
2568       ("KDF-SETUP\n\n"
2569        "Prepare the OpenPGP card KDF feature for this card.",
2570        APP_TYPE_OPENPGP, 0);
2571
2572   if (info->apptype != APP_TYPE_OPENPGP)
2573     {
2574       log_info ("Note: This is an OpenPGP only command.\n");
2575       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2576     }
2577
2578   if (!info->extcap.kdf)
2579     {
2580       log_error (_("This command is not supported by this card\n"));
2581       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2582       goto leave;
2583     }
2584
2585   err = gen_kdf_data (kdf_data, single);
2586   if (err)
2587     goto leave;
2588
2589   err = scd_setattr ("KDF", kdf_data,
2590                      single ? OPENPGP_KDF_DATA_LENGTH_MIN
2591                      /* */  : OPENPGP_KDF_DATA_LENGTH_MAX);
2592   if (err)
2593     goto leave;
2594
2595   err = scd_getattr ("KDF", info);
2596
2597  leave:
2598   return err;
2599 }
2600
2601
2602 \f
2603 static void
2604 show_keysize_warning (void)
2605 {
2606   static int shown;
2607
2608   if (shown)
2609     return;
2610   shown = 1;
2611   tty_printf
2612     (_("Note: There is no guarantee that the card supports the requested\n"
2613        "      key type or size.  If the key generation does not succeed,\n"
2614        "      please check the documentation of your card to see which\n"
2615        "      key types and sizes are supported.\n")
2616      );
2617 }
2618
2619
2620 /* Ask for the size of a card key.  NBITS is the current size
2621  * configured for the card.  Returns 0 on success and stored the
2622  * chosen key size at R_KEYSIZE; 0 is stored to indicate that the
2623  * default size shall be used.  */
2624 static gpg_error_t
2625 ask_card_rsa_keysize (unsigned int nbits, unsigned int *r_keysize)
2626 {
2627   unsigned int min_nbits = 1024;
2628   unsigned int max_nbits = 4096;
2629   char*answer;
2630   unsigned int req_nbits;
2631
2632   for (;;)
2633     {
2634       answer = tty_getf (_("What keysize do you want? (%u) "), nbits);
2635       trim_spaces (answer);
2636       tty_kill_prompt ();
2637       if (*answer == CONTROL_D)
2638         {
2639           xfree (answer);
2640           return gpg_error (GPG_ERR_CANCELED);
2641         }
2642       req_nbits = *answer? atoi (answer): nbits;
2643       xfree (answer);
2644
2645       if (req_nbits != nbits && (req_nbits % 32) )
2646         {
2647           req_nbits = ((req_nbits + 31) / 32) * 32;
2648           tty_printf (_("rounded up to %u bits\n"), req_nbits);
2649         }
2650
2651       if (req_nbits == nbits)
2652         {
2653           /* Use default.  */
2654           *r_keysize = 0;
2655           return 0;
2656         }
2657
2658       if (req_nbits < min_nbits || req_nbits > max_nbits)
2659         {
2660           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
2661                       "RSA", min_nbits, max_nbits);
2662         }
2663       else
2664         {
2665           *r_keysize = req_nbits;
2666           return 0;
2667         }
2668     }
2669 }
2670
2671
2672 /* Ask for the key attribute of a card key.  CURRENT is the current
2673  * attribute configured for the card.  KEYNO is the number of the key
2674  * used to select the prompt.  Stores NULL at result to use the
2675  * default attribute or stores the selected attribute structure at
2676  * RESULT.  On error an error code is returned.  */
2677 static gpg_error_t
2678 ask_card_keyattr (int keyno, const struct key_attr *current,
2679                   struct key_attr **result)
2680 {
2681   gpg_error_t err;
2682   struct key_attr *key_attr = NULL;
2683   char *answer = NULL;
2684   int selection;
2685
2686   *result = NULL;
2687
2688   key_attr = xcalloc (1, sizeof *key_attr);
2689
2690   tty_printf (_("Changing card key attribute for: "));
2691   if (keyno == 0)
2692     tty_printf (_("Signature key\n"));
2693   else if (keyno == 1)
2694     tty_printf (_("Encryption key\n"));
2695   else
2696     tty_printf (_("Authentication key\n"));
2697
2698   tty_printf (_("Please select what kind of key you want:\n"));
2699   tty_printf (_("   (%d) RSA\n"), 1 );
2700   tty_printf (_("   (%d) ECC\n"), 2 );
2701
2702   for (;;)
2703     {
2704       xfree (answer);
2705       answer = tty_get (_("Your selection? "));
2706       trim_spaces (answer);
2707       tty_kill_prompt ();
2708       if (!*answer || *answer == CONTROL_D)
2709         {
2710           err = gpg_error (GPG_ERR_CANCELED);
2711           goto leave;
2712         }
2713       selection = *answer? atoi (answer) : 0;
2714
2715       if (selection == 1 || selection == 2)
2716         break;
2717       else
2718         tty_printf (_("Invalid selection.\n"));
2719     }
2720
2721
2722   if (selection == 1)
2723     {
2724       unsigned int nbits, result_nbits;
2725
2726       if (current->algo == PUBKEY_ALGO_RSA)
2727         nbits = current->nbits;
2728       else
2729         nbits = 2048;
2730
2731       err = ask_card_rsa_keysize (nbits, &result_nbits);
2732       if (err)
2733         goto leave;
2734       if (result_nbits == 0)
2735         {
2736           if (current->algo == PUBKEY_ALGO_RSA)
2737             {
2738               xfree (key_attr);
2739               key_attr = NULL;
2740             }
2741           else
2742             result_nbits = nbits;
2743         }
2744
2745       if (key_attr)
2746         {
2747           key_attr->algo = PUBKEY_ALGO_RSA;
2748           key_attr->nbits = result_nbits;
2749         }
2750     }
2751   else if (selection == 2)
2752     {
2753       const char *curve;
2754       /* const char *oid_str; */
2755       int algo;
2756
2757       if (current->algo == PUBKEY_ALGO_RSA)
2758         {
2759           if (keyno == 1) /* Encryption key */
2760             algo = PUBKEY_ALGO_ECDH;
2761           else /* Signature key or Authentication key */
2762             algo = PUBKEY_ALGO_ECDSA;
2763           curve = NULL;
2764         }
2765       else
2766         {
2767           algo = current->algo;
2768           curve = current->curve;
2769         }
2770
2771       (void)curve;
2772       (void)algo;
2773       err = GPG_ERR_NOT_IMPLEMENTED;
2774       goto leave;
2775       /* FIXME: We need to move the ask_cure code out to common or
2776        * provide another sultion.  */
2777       /* curve = ask_curve (&algo, NULL, curve); */
2778       /* if (curve) */
2779       /*   { */
2780       /*     key_attr->algo = algo; */
2781       /*     oid_str = openpgp_curve_to_oid (curve, NULL); */
2782       /*     key_attr->curve = openpgp_oid_to_curve (oid_str, 0); */
2783       /*   } */
2784       /* else */
2785       /*   { */
2786       /*     xfree (key_attr); */
2787       /*     key_attr = NULL; */
2788       /*   } */
2789     }
2790   else
2791     {
2792       err = gpg_error (GPG_ERR_BUG);
2793       goto leave;
2794     }
2795
2796   /* Tell the user what we are going to do.  */
2797   if (key_attr->algo == PUBKEY_ALGO_RSA)
2798     {
2799       tty_printf (_("The card will now be re-configured"
2800                     " to generate a key of %u bits\n"), key_attr->nbits);
2801     }
2802   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2803            || key_attr->algo == PUBKEY_ALGO_ECDSA
2804            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2805     {
2806       tty_printf (_("The card will now be re-configured"
2807                     " to generate a key of type: %s\n"), key_attr->curve);
2808     }
2809   show_keysize_warning ();
2810
2811   *result = key_attr;
2812   key_attr = NULL;
2813
2814  leave:
2815   xfree (key_attr);
2816   xfree (answer);
2817   return err;
2818 }
2819
2820
2821 /* Change the key attribute of key KEYNO (0..2) and show an error
2822  * message if that fails.  */
2823 static gpg_error_t
2824 do_change_keyattr (int keyno, const struct key_attr *key_attr)
2825 {
2826   gpg_error_t err = 0;
2827   char args[100];
2828
2829   if (key_attr->algo == PUBKEY_ALGO_RSA)
2830     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
2831               key_attr->nbits);
2832   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2833            || key_attr->algo == PUBKEY_ALGO_ECDSA
2834            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2835     snprintf (args, sizeof args, "--force %d %d %s",
2836               keyno+1, key_attr->algo, key_attr->curve);
2837   else
2838     {
2839       /* FIXME: Above we use openpgp algo names but in the error
2840        * message we use the gcrypt names.  We should settle for a
2841        * consistent solution. */
2842       log_error (_("public key algorithm %d (%s) is not supported\n"),
2843                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
2844       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2845       goto leave;
2846     }
2847
2848   err = scd_setattr ("KEY-ATTR", args, strlen (args));
2849   if (err)
2850     log_error (_("error changing key attribute for key %d: %s\n"),
2851                keyno+1, gpg_strerror (err));
2852  leave:
2853   return err;
2854 }
2855
2856
2857 static gpg_error_t
2858 cmd_keyattr (card_info_t info, char *argstr)
2859 {
2860   gpg_error_t err = 0;
2861   int keyno;
2862   struct key_attr *key_attr = NULL;
2863
2864   (void)argstr;
2865
2866   if (!info)
2867     return print_help
2868       ("KEY-ATTR\n\n"
2869        "Menu to change the key attributes of an OpenPGP card.",
2870        APP_TYPE_OPENPGP, 0);
2871
2872   if (info->apptype != APP_TYPE_OPENPGP)
2873     {
2874       log_info ("Note: This is an OpenPGP only command.\n");
2875       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2876     }
2877
2878   if (!(info->is_v2 && info->extcap.aac))
2879     {
2880       log_error (_("This command is not supported by this card\n"));
2881       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2882       goto leave;
2883     }
2884
2885   for (keyno = 0; keyno < DIM (info->key_attr); keyno++)
2886     {
2887       xfree (key_attr);
2888       key_attr = NULL;
2889       err = ask_card_keyattr (keyno, &info->key_attr[keyno], &key_attr);
2890       if (err)
2891         goto leave;
2892
2893       err = do_change_keyattr (keyno, key_attr);
2894       if (err)
2895         {
2896           /* Error: Better read the default key attribute again.  */
2897           log_debug ("FIXME\n");
2898           /* Ask again for this key. */
2899           keyno--;
2900         }
2901     }
2902
2903  leave:
2904   xfree (key_attr);
2905   return err;
2906 }
2907
2908
2909 static gpg_error_t
2910 cmd_uif (card_info_t info, char *argstr)
2911 {
2912   gpg_error_t err;
2913   int keyno;
2914
2915   if (!info)
2916     return print_help
2917       ("UIF N [on|off|permanent]\n\n"
2918        "Change the User Interaction Flag.  N must in the range 1 to 3.",
2919        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2920
2921   argstr = skip_options (argstr);
2922
2923   if (digitp (argstr))
2924     {
2925       keyno = atoi (argstr);
2926       while (digitp (argstr))
2927         argstr++;
2928       while (spacep (argstr))
2929         argstr++;
2930     }
2931   else
2932     keyno = 0;
2933
2934   if (keyno < 1 || keyno > 3)
2935     {
2936       err = gpg_error (GPG_ERR_INV_ARG);
2937       goto leave;
2938     }
2939
2940
2941   err = GPG_ERR_NOT_IMPLEMENTED;
2942
2943  leave:
2944   return err;
2945 }
2946
2947
2948 static gpg_error_t
2949 cmd_yubikey (card_info_t info, char *argstr)
2950 {
2951   gpg_error_t err, err2;
2952   estream_t fp = opt.interactive? NULL : es_stdout;
2953   char *words[20];
2954   int nwords;
2955
2956   if (!info)
2957     return print_help
2958       ("YUBIKEY <cmd> args\n\n"
2959        "Various commands pertaining to Yubikey tokens with <cmd> being:\n"
2960        "\n"
2961        "  LIST \n"
2962        "\n"
2963        "List supported and enabled applications.\n"
2964        "\n"
2965        "  ENABLE  usb|nfc|all [otp|u2f|opgp|piv|oath|fido2|all]\n"
2966        "  DISABLE usb|nfc|all [otp|u2f|opgp|piv|oath|fido2|all]\n"
2967        "\n"
2968        "Enable or disable the specified or all applications on the\n"
2969        "given interface.",
2970        0);
2971
2972   argstr = skip_options (argstr);
2973
2974   if (!info->cardtype || strcmp (info->cardtype, "yubikey"))
2975     {
2976       log_info ("This command can only be used with Yubikeys.\n");
2977       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2978       goto leave;
2979     }
2980
2981   nwords = split_fields (argstr, words, DIM (words));
2982   if (nwords < 1)
2983     {
2984       err = gpg_error (GPG_ERR_SYNTAX);
2985       goto leave;
2986     }
2987
2988
2989   /* Note that we always do a learn to get a chance to the card back
2990    * into a usable state.  */
2991   err = yubikey_commands (fp, nwords, words);
2992   err2 = scd_learn (info);
2993   if (err2)
2994     log_error ("Error re-reading card: %s\n", gpg_strerror (err));
2995
2996  leave:
2997   return err;
2998 }
2999
3000 \f
3001
3002 /* Data used by the command parser.  This needs to be outside of the
3003  * function scope to allow readline based command completion.  */
3004 enum cmdids
3005   {
3006     cmdNOP = 0,
3007     cmdQUIT, cmdHELP, cmdLIST, cmdRESET, cmdVERIFY,
3008     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSALUT, cmdCAFPR,
3009     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
3010     cmdREADCERT, cmdWRITEKEY,  cmdUNBLOCK, cmdFACTRST, cmdKDFSETUP,
3011     cmdKEYATTR, cmdUIF, cmdAUTH, cmdYUBIKEY,
3012     cmdINVCMD
3013   };
3014
3015 static struct
3016 {
3017   const char *name;
3018   enum cmdids id;
3019   const char *desc;
3020 } cmds[] = {
3021   { "quit"    ,  cmdQUIT,       N_("quit this menu")},
3022   { "q"       ,  cmdQUIT,       NULL },
3023   { "help"    ,  cmdHELP,       N_("show this help")},
3024   { "?"       ,  cmdHELP,       NULL },
3025   { "list"    ,  cmdLIST,       N_("list all available data")},
3026   { "l"       ,  cmdLIST,       NULL },
3027   { "name"    ,  cmdNAME,       N_("change card holder's name")},
3028   { "url"     ,  cmdURL,        N_("change URL to retrieve key")},
3029   { "fetch"   ,  cmdFETCH,      N_("fetch the key specified in the card URL")},
3030   { "login"   ,  cmdLOGIN,      N_("change the login name")},
3031   { "lang"    ,  cmdLANG,       N_("change the language preferences")},
3032   { "salutation",cmdSALUT,      N_("change card holder's salutation")},
3033   { "salut"   ,  cmdSALUT,      NULL },
3034   { "cafpr"   ,  cmdCAFPR ,     N_("change a CA fingerprint")},
3035   { "forcesig",  cmdFORCESIG,   N_("toggle the signature force PIN flag")},
3036   { "generate",  cmdGENERATE,   N_("generate new keys")},
3037   { "passwd"  ,  cmdPASSWD,     N_("menu to change or unblock the PIN")},
3038   { "verify"  ,  cmdVERIFY,     N_("verify the PIN and list all data")},
3039   { "unblock" ,  cmdUNBLOCK,    N_("unblock the PIN using a Reset Code")},
3040   { "authenticate",cmdAUTH,     N_("authenticate to the card")},
3041   { "auth"    ,  cmdAUTH,       NULL },
3042   { "reset"   ,  cmdRESET,      N_("send a reset to the card daemon")},
3043   { "factory-reset",cmdFACTRST, N_("destroy all keys and data")},
3044   { "kdf-setup", cmdKDFSETUP,   N_("setup KDF for PIN authentication")},
3045   { "key-attr",  cmdKEYATTR,    N_("change the key attribute")},
3046   { "uif",       cmdUIF,        N_("change the User Interaction Flag")},
3047   { "privatedo", cmdPRIVATEDO,  N_("change a private data object")},
3048   { "readcert",  cmdREADCERT,   N_("read a certificate from a data object")},
3049   { "writecert", cmdWRITECERT,  N_("store a certificate to a data object")},
3050   { "writekey",  cmdWRITEKEY,   N_("store a private key to a data object")},
3051   { "yubikey",   cmdYUBIKEY,    N_("Yubikey management commands")},
3052   { NULL, cmdINVCMD, NULL }
3053 };
3054
3055
3056 /* The command line command dispatcher.  */
3057 static gpg_error_t
3058 dispatch_command (card_info_t info, const char *orig_command)
3059 {
3060   gpg_error_t err = 0;
3061   enum cmdids cmd;             /* The command.  */
3062   char *command;               /* A malloced copy of ORIG_COMMAND.  */
3063   char *argstr;                /* The argument as a string.  */
3064   int i;
3065   int ignore_error;
3066
3067   if ((ignore_error = *orig_command == '-'))
3068     orig_command++;
3069   command = xstrdup (orig_command);
3070   argstr = NULL;
3071   if ((argstr = strchr (command, ' ')))
3072     {
3073       *argstr++ = 0;
3074       trim_spaces (command);
3075       trim_spaces (argstr);
3076     }
3077
3078   for (i=0; cmds[i].name; i++ )
3079     if (!ascii_strcasecmp (command, cmds[i].name ))
3080       break;
3081   cmd = cmds[i].id; /* (If not found this will be cmdINVCMD). */
3082
3083   /* Make sure we have valid strings for the args.  They are allowed
3084    * to be modified and must thus point to a buffer.  */
3085   if (!argstr)
3086     argstr = command + strlen (command);
3087
3088   /* For most commands we need to make sure that we have a card.  */
3089   if (!info)
3090     ;  /* Help mode */
3091   else if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP
3092              || cmd == cmdINVCMD)
3093            && !info->initialized)
3094     {
3095       err = scd_learn (info);
3096       if (err)
3097         {
3098           log_error ("Error reading card: %s\n", gpg_strerror (err));
3099           goto leave;
3100         }
3101     }
3102
3103   switch (cmd)
3104     {
3105     case cmdNOP:
3106       if (!info)
3107         print_help ("NOP\n\n"
3108                     "Dummy command.", 0);
3109       break;
3110
3111     case cmdQUIT:
3112       if (!info)
3113         print_help ("QUIT\n\n"
3114                     "Stop processing.", 0);
3115       else
3116         {
3117           err = gpg_error (GPG_ERR_EOF);
3118           goto leave;
3119         }
3120       break;
3121
3122     case cmdHELP:
3123       if (!info)
3124         print_help ("HELP [command]\n\n"
3125                     "Show all commands.  With an argument show help\n"
3126                     "for that command.", 0);
3127       else if (*argstr)
3128         dispatch_command (NULL, argstr);
3129       else
3130         {
3131           es_printf
3132             ("List of commands (\"help <command>\" for details):\n");
3133           for (i=0; cmds[i].name; i++ )
3134             if(cmds[i].desc)
3135               es_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
3136           es_printf ("Prefix a command with a dash to ignore its error.\n");
3137         }
3138       break;
3139
3140     case cmdLIST:
3141       if (!info)
3142         print_help ("LIST\n\n"
3143                     "Show content of the card.", 0);
3144       else
3145         {
3146           err = scd_learn (info);
3147           if (err)
3148             log_error ("Error reading card: %s\n", gpg_strerror (err));
3149           else
3150             list_card (info);
3151         }
3152       break;
3153
3154     case cmdRESET:
3155       if (!info)
3156         print_help ("RESET\n\n"
3157                     "Send a RESET to the card daemon.", 0);
3158       else
3159         {
3160           flush_keyblock_cache ();
3161           err = scd_apdu (NULL, NULL, NULL, NULL);
3162         }
3163       break;
3164
3165     case cmdVERIFY:       err = cmd_verify (info, argstr); break;
3166     case cmdAUTH:         err = cmd_authenticate (info, argstr); break;
3167     case cmdNAME:         err = cmd_name (info, argstr); break;
3168     case cmdURL:          err = cmd_url (info, argstr);  break;
3169     case cmdFETCH:        err = cmd_fetch (info);  break;
3170     case cmdLOGIN:        err = cmd_login (info, argstr); break;
3171     case cmdLANG:         err = cmd_lang (info, argstr); break;
3172     case cmdSALUT:        err = cmd_salut (info, argstr); break;
3173     case cmdCAFPR:        err = cmd_cafpr (info, argstr); break;
3174     case cmdPRIVATEDO:    err = cmd_privatedo (info, argstr); break;
3175     case cmdWRITECERT:    err = cmd_writecert (info, argstr); break;
3176     case cmdREADCERT:     err = cmd_readcert (info, argstr); break;
3177     case cmdWRITEKEY:     err = cmd_writekey (info, argstr); break;
3178     case cmdFORCESIG:     err = cmd_forcesig (info); break;
3179     case cmdGENERATE:     err = cmd_generate (info, argstr); break;
3180     case cmdPASSWD:       err = cmd_passwd (info, argstr); break;
3181     case cmdUNBLOCK:      err = cmd_unblock (info); break;
3182     case cmdFACTRST:      err = cmd_factoryreset (info); break;
3183     case cmdKDFSETUP:     err = cmd_kdfsetup (info, argstr); break;
3184     case cmdKEYATTR:      err = cmd_keyattr (info, argstr); break;
3185     case cmdUIF:          err = cmd_uif (info, argstr); break;
3186     case cmdYUBIKEY:      err = cmd_yubikey (info, argstr); break;
3187
3188     case cmdINVCMD:
3189     default:
3190       log_error (_("Invalid command  (try \"help\")\n"));
3191       break;
3192     } /* End command switch. */
3193
3194
3195  leave:
3196   /* Return GPG_ERR_EOF only if its origin was "quit".  */
3197   es_fflush (es_stdout);
3198   if (gpg_err_code (err) == GPG_ERR_EOF && cmd != cmdQUIT)
3199     err = gpg_error (GPG_ERR_GENERAL);
3200   if (err && gpg_err_code (err) != GPG_ERR_EOF)
3201     {
3202       if (ignore_error)
3203         {
3204           log_info ("Command '%s' failed: %s\n", command, gpg_strerror (err));
3205           err = 0;
3206         }
3207       else
3208         log_error ("Command '%s' failed: %s\n", command, gpg_strerror (err));
3209     }
3210   xfree (command);
3211
3212   return err;
3213 }
3214
3215
3216 /* The interactive main loop.  */
3217 static void
3218 interactive_loop (void)
3219 {
3220   gpg_error_t err;
3221   char *answer = NULL;         /* The input line.  */
3222   enum cmdids cmd = cmdNOP;    /* The command.  */
3223   char *argstr;                /* The argument as a string.  */
3224   int redisplay = 1;           /* Whether to redisplay the main info.  */
3225   char *help_arg = NULL;       /* Argument of the HELP command.         */
3226   struct card_info_s info_buffer = { 0 };
3227   card_info_t info = &info_buffer;
3228   char *p;
3229   int i;
3230
3231   /* In the interactive mode we do not want to print the program prefix.  */
3232   log_set_prefix (NULL, 0);
3233
3234   for (;;)
3235     {
3236       if (help_arg)
3237         {
3238           /* Clear info to indicate helpmode */
3239           info = NULL;
3240         }
3241       else if (!info)
3242         {
3243           /* Get out of help.  */
3244           info = &info_buffer;
3245           help_arg = NULL;
3246           redisplay = 0;
3247         }
3248       else if (redisplay)
3249         {
3250           err = scd_learn (info);
3251           if (err)
3252             {
3253               log_error ("Error reading card: %s\n", gpg_strerror (err));
3254             }
3255           else
3256             {
3257               list_card (info);
3258               tty_printf("\n");
3259               redisplay = 0;
3260             }
3261         }
3262
3263       if (!info)
3264         {
3265           /* Copy the pending help arg into our answer.  Noe that
3266            * help_arg points into answer.  */
3267           p = xstrdup (help_arg);
3268           help_arg = NULL;
3269           xfree (answer);
3270           answer = p;
3271         }
3272       else
3273         {
3274           do
3275             {
3276               xfree (answer);
3277               tty_enable_completion (command_completion);
3278               answer = tty_get (_("gpg/card> "));
3279               tty_kill_prompt();
3280               tty_disable_completion ();
3281               trim_spaces(answer);
3282             }
3283           while ( *answer == '#' );
3284         }
3285
3286       argstr = NULL;
3287       if (!*answer)
3288         cmd = cmdLIST; /* We default to the list command */
3289       else if (*answer == CONTROL_D)
3290         cmd = cmdQUIT;
3291       else
3292         {
3293           if ((argstr = strchr (answer,' ')))
3294             {
3295               *argstr++ = 0;
3296               trim_spaces (answer);
3297               trim_spaces (argstr);
3298             }
3299
3300           for (i=0; cmds[i].name; i++ )
3301             if (!ascii_strcasecmp (answer, cmds[i].name ))
3302               break;
3303
3304           cmd = cmds[i].id;
3305         }
3306
3307       /* Make sure we have valid strings for the args.  They are
3308        * allowed to be modified and must thus point to a buffer.  */
3309       if (!argstr)
3310         argstr = answer + strlen (answer);
3311
3312       if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP
3313             || cmd == cmdINVCMD))
3314         {
3315           /* If redisplay is set we know that there was an error reading
3316            * the card.  In this case we force a LIST command to retry.  */
3317           if (!info)
3318             ; /* In help mode.  */
3319           else if (redisplay)
3320             {
3321               cmd = cmdLIST;
3322             }
3323           else if (!info->serialno)
3324             {
3325               /* Without a serial number most commands won't work.
3326                * Catch it here.  */
3327               tty_printf ("\n");
3328               tty_printf ("Serial number missing\n");
3329               continue;
3330             }
3331         }
3332
3333       err = 0;
3334       switch (cmd)
3335         {
3336         case cmdNOP:
3337           if (!info)
3338             print_help ("NOP\n\n"
3339                         "Dummy command.", 0);
3340           break;
3341
3342         case cmdQUIT:
3343           if (!info)
3344             print_help ("QUIT\n\n"
3345                         "Leave this tool.", 0);
3346           else
3347             {
3348               tty_printf ("\n");
3349               goto leave;
3350             }
3351           break;
3352
3353         case cmdHELP:
3354           if (!info)
3355             print_help ("HELP [command]\n\n"
3356                         "Show all commands.  With an argument show help\n"
3357                         "for that command.", 0);
3358           else if (*argstr)
3359             help_arg = argstr; /* Trigger help for a command.  */
3360           else
3361             {
3362               tty_printf
3363                 ("List of commands (\"help <command>\" for details):\n");
3364               for (i=0; cmds[i].name; i++ )
3365                 if(cmds[i].desc)
3366                   tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
3367             }
3368           break;
3369
3370         case cmdLIST:
3371           if (!info)
3372             print_help ("LIST\n\n"
3373                         "Show content of the card.", 0);
3374           else
3375             {
3376               /* Actual work is done by the redisplay code block.  */
3377               redisplay = 1;
3378             }
3379           break;
3380
3381         case cmdRESET:
3382           if (!info)
3383             print_help ("RESET\n\n"
3384                         "Send a RESET to the card daemon.", 0);
3385           else
3386             {
3387               flush_keyblock_cache ();
3388               err = scd_apdu (NULL, NULL, NULL, NULL);
3389             }
3390           break;
3391
3392         case cmdVERIFY:
3393           err = cmd_verify (info, argstr);
3394           if (!err)
3395             redisplay = 1;
3396           break;
3397         case cmdAUTH:      err = cmd_authenticate (info, argstr); break;
3398         case cmdNAME:      err = cmd_name (info, argstr); break;
3399         case cmdURL:       err = cmd_url (info, argstr);  break;
3400         case cmdFETCH:     err = cmd_fetch (info);  break;
3401         case cmdLOGIN:     err = cmd_login (info, argstr); break;
3402         case cmdLANG:      err = cmd_lang (info, argstr); break;
3403         case cmdSALUT:     err = cmd_salut (info, argstr); break;
3404         case cmdCAFPR:     err = cmd_cafpr (info, argstr); break;
3405         case cmdPRIVATEDO: err = cmd_privatedo (info, argstr); break;
3406         case cmdWRITECERT: err = cmd_writecert (info, argstr); break;
3407         case cmdREADCERT:  err = cmd_readcert (info, argstr); break;
3408         case cmdWRITEKEY:  err = cmd_writekey (info, argstr); break;
3409         case cmdFORCESIG:  err = cmd_forcesig (info); break;
3410         case cmdGENERATE:  err = cmd_generate (info, argstr); break;
3411         case cmdPASSWD:    err = cmd_passwd (info, argstr); break;
3412         case cmdUNBLOCK:   err = cmd_unblock (info); break;
3413         case cmdFACTRST:
3414           err = cmd_factoryreset (info);
3415           if (!err)
3416             redisplay = 1;
3417           break;
3418         case cmdKDFSETUP:  err = cmd_kdfsetup (info, argstr); break;
3419         case cmdKEYATTR:   err = cmd_keyattr (info, argstr); break;
3420         case cmdUIF:       err = cmd_uif (info, argstr); break;
3421         case cmdYUBIKEY:   err = cmd_yubikey (info, argstr); break;
3422
3423         case cmdINVCMD:
3424         default:
3425           tty_printf ("\n");
3426           tty_printf (_("Invalid command  (try \"help\")\n"));
3427           break;
3428         } /* End command switch. */
3429
3430       if (gpg_err_code (err) == GPG_ERR_CANCELED)
3431         tty_fprintf (NULL, "\n");
3432       else if (err)
3433         {
3434           const char *s = "?";
3435           for (i=0; cmds[i].name; i++ )
3436             if (cmd == cmds[i].id)
3437               {
3438                 s = cmds[i].name;
3439                 break;
3440               }
3441           log_error ("Command '%s' failed: %s\n", s, gpg_strerror (err));
3442         }
3443
3444     } /* End of main menu loop. */
3445
3446  leave:
3447   release_card_info (info);
3448   xfree (answer);
3449 }
3450
3451 #ifdef HAVE_LIBREADLINE
3452 /* Helper function for readline's command completion. */
3453 static char *
3454 command_generator (const char *text, int state)
3455 {
3456   static int list_index, len;
3457   const char *name;
3458
3459   /* If this is a new word to complete, initialize now.  This includes
3460    * saving the length of TEXT for efficiency, and initializing the
3461    index variable to 0. */
3462   if (!state)
3463     {
3464       list_index = 0;
3465       len = strlen(text);
3466     }
3467
3468   /* Return the next partial match */
3469   while ((name = cmds[list_index].name))
3470     {
3471       /* Only complete commands that have help text. */
3472       if (cmds[list_index++].desc && !strncmp (name, text, len))
3473         return strdup(name);
3474     }
3475
3476   return NULL;
3477 }
3478
3479 /* Second helper function for readline's command completion.  */
3480 static char **
3481 command_completion (const char *text, int start, int end)
3482 {
3483   (void)end;
3484
3485   /* If we are at the start of a line, we try and command-complete.
3486    * If not, just do nothing for now.  The support for help completion
3487    * needs to be more smarter. */
3488   if (!start)
3489     return rl_completion_matches (text, command_generator);
3490   else if (start == 5 && !ascii_strncasecmp (rl_line_buffer, "help ", 5))
3491     return rl_completion_matches (text, command_generator);
3492
3493   rl_attempted_completion_over = 1;
3494
3495   return NULL;
3496 }
3497 #endif /*HAVE_LIBREADLINE*/