card: Print the keyref also for non-initialized slots.
[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     }
1651   else
1652     {
1653       err = gpg_error (GPG_ERR_INV_ARG);
1654       goto leave;
1655     }
1656
1657   err = scd_writecert (certref, data, datalen);
1658
1659  leave:
1660   xfree (data);
1661   xfree (certref_buffer);
1662   return err;
1663 }
1664
1665
1666 static gpg_error_t
1667 cmd_readcert (card_info_t info, char *argstr)
1668 {
1669   gpg_error_t err;
1670   char *certref_buffer = NULL;
1671   char *certref;
1672   void *data = NULL;
1673   size_t datalen;
1674   const char *fname;
1675
1676   if (!info)
1677     return print_help
1678       ("READCERT CERTREF > FILE\n\n"
1679        "Read the certificate for key CERTREF and store it in FILE.",
1680        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1681
1682   argstr = skip_options (argstr);
1683
1684   certref = argstr;
1685   if ((argstr = strchr (certref, ' ')))
1686     {
1687       *argstr++ = 0;
1688       trim_spaces (certref);
1689       trim_spaces (argstr);
1690     }
1691   else /* Let argstr point to an empty string.  */
1692     argstr = certref + strlen (certref);
1693
1694   if (info->apptype == APP_TYPE_OPENPGP)
1695     {
1696       if (ascii_strcasecmp (certref, "OPENPGP.3") && strcmp (certref, "3"))
1697         {
1698           err = gpg_error (GPG_ERR_INV_ID);
1699           log_error ("Error: CERTREF must be \"3\" or \"OPENPGP.3\"\n");
1700           goto leave;
1701         }
1702       certref = certref_buffer = xstrdup ("OPENPGP.3");
1703     }
1704
1705   if (*argstr == '>')  /* Write it to a file */
1706     {
1707       for (argstr++; spacep (argstr); argstr++)
1708         ;
1709       fname = argstr;
1710     }
1711   else
1712     {
1713       err = gpg_error (GPG_ERR_INV_ARG);
1714       goto leave;
1715     }
1716
1717   err = scd_readcert (certref, &data, &datalen);
1718   if (err)
1719     goto leave;
1720
1721   err = put_data_to_file (fname, data, datalen);
1722
1723  leave:
1724   xfree (data);
1725   xfree (certref_buffer);
1726   return err;
1727 }
1728
1729
1730 static gpg_error_t
1731 cmd_writekey (card_info_t info, char *argstr)
1732 {
1733   gpg_error_t err;
1734   int opt_force;
1735   char *argv[2];
1736   int argc;
1737   char *keyref_buffer = NULL;
1738   char *keyref;
1739   char *keygrip;
1740
1741   if (!info)
1742     return print_help
1743       ("WRITEKEY [--force] KEYREF KEYGRIP\n\n"
1744        "Write a private key object identified by KEYGRIP to slot KEYREF.\n"
1745        "Use --force to overwrite an existing key.",
1746        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1747
1748   opt_force = has_leading_option (argstr, "--force");
1749   argstr = skip_options (argstr);
1750
1751   argc = split_fields (argstr, argv, DIM (argv));
1752   if (argc < 2)
1753     {
1754       err = gpg_error (GPG_ERR_INV_ARG);
1755       goto leave;
1756     }
1757
1758   /* Upcase the keyref; prepend cardtype if needed.  */
1759   keyref = argv[0];
1760   if (!strchr (keyref, '.'))
1761     keyref_buffer = xstrconcat (app_type_string (info->apptype), ".",
1762                                 keyref, NULL);
1763   else
1764     keyref_buffer = xstrdup (keyref);
1765   ascii_strupr (keyref_buffer);
1766   keyref = keyref_buffer;
1767
1768   /* Get the keygrip.  */
1769   keygrip = argv[1];
1770   if (strlen (keygrip) != 40
1771       && !(keygrip[0] == '&' && strlen (keygrip+1) == 40))
1772     {
1773       log_error (_("Not a valid keygrip (expecting 40 hex digits)\n"));
1774       err = gpg_error (GPG_ERR_INV_ARG);
1775       goto leave;
1776     }
1777
1778   err = scd_writekey (keyref, opt_force, keygrip);
1779
1780  leave:
1781   xfree (keyref_buffer);
1782   return err;
1783 }
1784
1785
1786 static gpg_error_t
1787 cmd_forcesig (card_info_t info)
1788 {
1789   gpg_error_t err;
1790   int newstate;
1791
1792   if (!info)
1793     return print_help
1794       ("FORCESIG\n\n"
1795        "Toggle the forcesig flag of an OpenPGP card.",
1796        APP_TYPE_OPENPGP, 0);
1797
1798   if (info->apptype != APP_TYPE_OPENPGP)
1799     {
1800       log_info ("Note: This is an OpenPGP only command.\n");
1801       return gpg_error (GPG_ERR_NOT_SUPPORTED);
1802     }
1803
1804   newstate = !info->chv1_cached;
1805
1806   err = scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
1807   if (err)
1808     goto leave;
1809
1810   /* Read it back to be sure we have the right toggle state the next
1811    * time.  */
1812   err = scd_getattr ("CHV-STATUS", info);
1813
1814  leave:
1815   return err;
1816 }
1817
1818
1819 \f
1820 /* Helper for cmd_generate_openpgp.  Noe that either 0 or 1 is stored at
1821  * FORCED_CHV1. */
1822 static gpg_error_t
1823 check_pin_for_key_operation (card_info_t info, int *forced_chv1)
1824 {
1825   gpg_error_t err = 0;
1826
1827   *forced_chv1 = !info->chv1_cached;
1828   if (*forced_chv1)
1829     { /* Switch off the forced mode so that during key generation we
1830        * don't get bothered with PIN queries for each self-signature. */
1831       err = scd_setattr ("CHV-STATUS-1", "\x01", 1);
1832       if (err)
1833         {
1834           log_error ("error clearing forced signature PIN flag: %s\n",
1835                      gpg_strerror (err));
1836           *forced_chv1 = -1;  /* Not changed.  */
1837           goto leave;
1838         }
1839     }
1840
1841   /* Check the PIN now, so that we won't get asked later for each
1842    * binding signature.  */
1843   err = scd_checkpin (info->serialno);
1844   if (err)
1845     log_error ("error checking the PIN: %s\n", gpg_strerror (err));
1846
1847  leave:
1848   return err;
1849 }
1850
1851
1852 /* Helper for cmd_generate_openpgp.  */
1853 static void
1854 restore_forced_chv1 (int *forced_chv1)
1855 {
1856   gpg_error_t err;
1857
1858   /* Note the possible values stored at FORCED_CHV1:
1859    *   0 - forcesig was not enabled.
1860    *   1 - forcesig was enabled - enable it again.
1861    *  -1 - We have not changed anything.  */
1862   if (*forced_chv1 == 1)
1863     { /* Switch back to forced state. */
1864       err = scd_setattr ("CHV-STATUS-1", "", 1);
1865       if (err)
1866         log_error ("error setting forced signature PIN flag: %s\n",
1867                    gpg_strerror (err));
1868       *forced_chv1 = 0;
1869     }
1870 }
1871
1872
1873 /* Implementation of cmd_generate for OpenPGP cards.  */
1874 static gpg_error_t
1875 generate_openpgp (card_info_t info)
1876 {
1877   gpg_error_t err;
1878   int forced_chv1 = -1;
1879   int want_backup;
1880   char *answer = NULL;
1881   key_info_t kinfo1, kinfo2, kinfo3;
1882
1883   if (info->extcap.ki)
1884     {
1885       xfree (answer);
1886       answer = tty_get (_("Make off-card backup of encryption key? (Y/n) "));
1887       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1888       tty_kill_prompt ();
1889       if (*answer == CONTROL_D)
1890         {
1891           err = gpg_error (GPG_ERR_CANCELED);
1892           goto leave;
1893         }
1894     }
1895   else
1896     want_backup = 0;
1897
1898   kinfo1 = find_kinfo (info, "OPENPGP.1");
1899   kinfo2 = find_kinfo (info, "OPENPGP.2");
1900   kinfo3 = find_kinfo (info, "OPENPGP.3");
1901
1902   if ((kinfo1 && kinfo1->fprlen && !mem_is_zero (kinfo1->fpr,kinfo1->fprlen))
1903       || (kinfo2 && kinfo2->fprlen && !mem_is_zero (kinfo2->fpr,kinfo2->fprlen))
1904       || (kinfo3 && kinfo3->fprlen && !mem_is_zero (kinfo3->fpr,kinfo3->fprlen))
1905       )
1906     {
1907       tty_printf ("\n");
1908       log_info (_("Note: keys are already stored on the card!\n"));
1909       tty_printf ("\n");
1910       answer = tty_get (_("Replace existing keys? (y/N) "));
1911       tty_kill_prompt ();
1912       if (*answer == CONTROL_D)
1913         {
1914           err = gpg_error (GPG_ERR_CANCELED);
1915           goto leave;
1916         }
1917
1918       if (!answer_is_yes_no_default (answer, 0/*(default to No)*/))
1919         {
1920           err = gpg_error (GPG_ERR_CANCELED);
1921           goto leave;
1922         }
1923     }
1924
1925   /* If no displayed name has been set, we assume that this is a fresh
1926    * card and print a hint about the default PINs.  */
1927   if (!info->disp_name || !*info->disp_name)
1928     {
1929       tty_printf ("\n");
1930       tty_printf (_("Please note that the factory settings of the PINs are\n"
1931                     "   PIN = '%s'     Admin PIN = '%s'\n"
1932                     "You should change them using the command --change-pin\n"),
1933                   OPENPGP_USER_PIN_DEFAULT, OPENPGP_ADMIN_PIN_DEFAULT);
1934       tty_printf ("\n");
1935     }
1936
1937   err = check_pin_for_key_operation (info, &forced_chv1);
1938   if (err)
1939     goto leave;
1940
1941   /* FIXME: We need to divert to a function which spwans gpg which
1942    * will then create the key.  This also requires new features in
1943    * gpg.  We might also first create the keys on the card and then
1944    * tell gpg to use them to create the OpenPGP keyblock. */
1945   /* generate_keypair (ctrl, 1, NULL, info.serialno, want_backup); */
1946   (void)want_backup;
1947   err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1948
1949  leave:
1950   restore_forced_chv1 (&forced_chv1);
1951   xfree (answer);
1952   return err;
1953 }
1954
1955
1956 /* Generic implementation of cmd_generate.  */
1957 static gpg_error_t
1958 generate_generic (card_info_t info, const char *keyref, int force,
1959                   const char *algo)
1960 {
1961   gpg_error_t err;
1962
1963   (void)info;
1964
1965   err = scd_genkey (keyref, force, algo, NULL);
1966
1967   return err;
1968 }
1969
1970
1971 static gpg_error_t
1972 cmd_generate (card_info_t info, char *argstr)
1973 {
1974   static char * const valid_algos[] =
1975     { "rsa2048", "rsa3072", "rsa4096",
1976       "nistp256", "nistp384", "nistp521",
1977       "ed25519", "cv25519",
1978       NULL
1979     };
1980   gpg_error_t err;
1981   int opt_force;
1982   char *opt_algo = NULL; /* Malloced.  */
1983   char *keyref_buffer = NULL;  /* Malloced.  */
1984   char *keyref;          /* Points into argstr or keyref_buffer.  */
1985   int i;
1986
1987   if (!info)
1988     return print_help
1989       ("GENERATE [--force] [--algo=ALGO] KEYREF\n\n"
1990        "Create a new key on a card.  For OpenPGP cards are menu is used\n"
1991        "and KEYREF is ignored.  Use --force to overwrite an existing key.",
1992        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
1993
1994   if (opt.interactive || opt.verbose)
1995     log_info (_("%s card no. %s detected\n"),
1996               app_type_string (info->apptype),
1997               info->dispserialno? info->dispserialno : info->serialno);
1998
1999   opt_force = has_leading_option (argstr, "--force");
2000   err = get_option_value (argstr, "--algo", &opt_algo);
2001   if (err)
2002     goto leave;
2003   argstr = skip_options (argstr);
2004
2005   keyref = argstr;
2006   if ((argstr = strchr (keyref, ' ')))
2007     {
2008       *argstr++ = 0;
2009       trim_spaces (keyref);
2010       trim_spaces (argstr);
2011     }
2012   else /* Let argstr point to an empty string.  */
2013     argstr = keyref + strlen (keyref);
2014
2015   if (!*keyref)
2016     keyref = NULL;
2017
2018   if (*argstr)
2019     {
2020       /* Extra arguments found.  */
2021       err = gpg_error (GPG_ERR_INV_ARG);
2022       goto leave;
2023     }
2024
2025   if (opt_algo)
2026     {
2027       for (i=0; valid_algos[i]; i++)
2028         if (!strcmp (valid_algos[i], opt_algo))
2029           break;
2030       if (!valid_algos[i])
2031         {
2032           err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2033           log_info ("Invalid algorithm '%s' given.  Use one:\n", opt_algo);
2034           for (i=0; valid_algos[i]; i++)
2035             if (!(i%5))
2036               log_info ("  %s%s", valid_algos[i], valid_algos[i+1]?",":".");
2037             else
2038               log_printf (" %s%s", valid_algos[i], valid_algos[i+1]?",":".");
2039           log_info ("Note that the card may not support all of them.\n");
2040           goto leave;
2041         }
2042     }
2043
2044   /* Upcase the keyref; if it misses the cardtype, prepend it.  */
2045   if (keyref)
2046     {
2047       if (!strchr (keyref, '.'))
2048         keyref_buffer = xstrconcat (app_type_string (info->apptype), ".",
2049                                     keyref, NULL);
2050       else
2051         keyref_buffer = xstrdup (keyref);
2052       ascii_strupr (keyref_buffer);
2053       keyref = keyref_buffer;
2054     }
2055
2056   /* Special checks.  */
2057   if ((info->cardtype && !strcmp (info->cardtype, "yubikey"))
2058       && info->cardversion >= 0x040200 && info->cardversion < 0x040305)
2059     {
2060       log_error ("On-chip key generation on this YubiKey has been blocked.\n");
2061       log_info ("Please see <https://yubi.co/ysa201701> for details\n");
2062       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2063       goto leave;
2064     }
2065
2066   /* Divert to dedicated functions.  */
2067   if (info->apptype == APP_TYPE_OPENPGP)
2068     {
2069       if (opt_force || opt_algo || keyref)
2070         log_info ("Note: Options are ignored for OpenPGP cards.\n");
2071       err = generate_openpgp (info);
2072     }
2073   else if (!keyref)
2074     err = gpg_error (GPG_ERR_INV_ID);
2075   else
2076     err = generate_generic (info, keyref, opt_force, opt_algo);
2077
2078  leave:
2079   xfree (opt_algo);
2080   xfree (keyref_buffer);
2081   return err;
2082 }
2083
2084
2085 \f
2086 /* Sub-menu to change a PIN.  */
2087 static gpg_error_t
2088 cmd_passwd (card_info_t info, char *argstr)
2089 {
2090   gpg_error_t err;
2091   char *answer = NULL;
2092   const char *pinref;
2093
2094   if (!info)
2095     return print_help
2096       ("PASSWD [PINREF]\n\n"
2097        "Menu to change or unblock the PINs.  Note that the\n"
2098        "presented menu options depend on the type of card\n"
2099        "and whether the admin mode is enabled.  For OpenPGP\n"
2100        "and PIV cards defaults for PINREF are available.",
2101        0);
2102
2103   if (opt.interactive || opt.verbose)
2104     log_info (_("%s card no. %s detected\n"),
2105               app_type_string (info->apptype),
2106               info->dispserialno? info->dispserialno : info->serialno);
2107
2108   if (!*argstr && info->apptype == APP_TYPE_OPENPGP)
2109     {
2110       /* For an OpenPGP card we present the well known menu if no
2111        * argument is given.  */
2112       for (;;)
2113         {
2114           tty_printf ("\n");
2115           tty_printf ("1 - change PIN\n"
2116                       "2 - unblock and set new PIN\n"
2117                       "3 - change Admin PIN\n"
2118                       "4 - set the Reset Code\n"
2119                       "Q - quit\n");
2120           tty_printf ("\n");
2121
2122           err = 0;
2123           xfree (answer);
2124           answer = tty_get (_("Your selection? "));
2125           tty_kill_prompt ();
2126           if (*answer == CONTROL_D)
2127             break;  /* Quit.  */
2128           if (strlen (answer) != 1)
2129             continue;
2130           if (*answer == 'q' || *answer == 'Q')
2131             break;  /* Quit.  */
2132
2133           if (*answer == '1')
2134             {
2135               /* Change PIN (same as the direct thing in non-admin mode).  */
2136               err = scd_change_pin ("OPENPGP.1", 0);
2137               if (err)
2138                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
2139               else
2140                 log_info ("PIN changed.\n");
2141             }
2142           else if (*answer == '2')
2143             {
2144               /* Unblock PIN by setting a new PIN.  */
2145               err = scd_change_pin ("OPENPGP.1", 1);
2146               if (err)
2147                 log_error ("Error unblocking the PIN: %s\n", gpg_strerror(err));
2148               else
2149                 log_info ("PIN unblocked and new PIN set.\n");
2150             }
2151           else if (*answer == '3')
2152             {
2153               /* Change Admin PIN.  */
2154               err = scd_change_pin ("OPENPGP.3", 0);
2155               if (err)
2156                 log_error ("Error changing the PIN: %s\n", gpg_strerror (err));
2157               else
2158                 log_info ("PIN changed.\n");
2159           }
2160           else if (*answer == '4')
2161             {
2162               /* Set a new Reset Code.  */
2163               err = scd_change_pin ("OPENPGP.2", 1);
2164               if (err)
2165                 log_error ("Error setting the Reset Code: %s\n",
2166                            gpg_strerror (err));
2167               else
2168                 log_info ("Reset Code set.\n");
2169             }
2170
2171         } /*end for loop*/
2172     }
2173   else
2174     {
2175       if (*argstr)
2176         pinref = argstr;
2177       else if (info->apptype == APP_TYPE_PIV)
2178         pinref = "PIV.80";
2179       else
2180         {
2181           /* Note that we do not have a default value for OpenPGP
2182            * because we want to be mostly compatible to "gpg
2183            * --card-edit" and show a menu in that case (above).  */
2184           err = gpg_error (GPG_ERR_MISSING_VALUE);
2185           goto leave;
2186         }
2187       err = scd_change_pin (pinref, 0);
2188       if (err)
2189         goto leave;
2190
2191       if (info->apptype == APP_TYPE_PIV
2192           && !ascii_strcasecmp (pinref, "PIV.81"))
2193         log_info ("PUK changed.\n");
2194       else
2195         log_info ("PIN changed.\n");
2196     }
2197
2198  leave:
2199   xfree (answer);
2200   return err;
2201 }
2202
2203
2204 static gpg_error_t
2205 cmd_unblock (card_info_t info)
2206 {
2207   gpg_error_t err = 0;
2208
2209   if (!info)
2210     return print_help
2211       ("UNBLOCK\n\n"
2212        "Unblock a PIN using a PUK or Reset Code.  Note that OpenPGP\n"
2213        "cards prior to version 2 can't use this; instead the PASSWD\n"
2214        "command can be used to set a new PIN.",
2215        0);
2216
2217   if (opt.interactive || opt.verbose)
2218     log_info (_("%s card no. %s detected\n"),
2219               app_type_string (info->apptype),
2220               info->dispserialno? info->dispserialno : info->serialno);
2221
2222   if (info->apptype == APP_TYPE_OPENPGP)
2223     {
2224       if (!info->is_v2)
2225         {
2226           log_error (_("This command is only available for version 2 cards\n"));
2227           err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2228         }
2229       else if (!info->chvinfo[1])
2230         {
2231           log_error (_("Reset Code not or not anymore available\n"));
2232           err = gpg_error (GPG_ERR_PIN_BLOCKED);
2233         }
2234       else
2235         {
2236           err = scd_change_pin ("OPENPGP.2", 0);
2237           if (!err)
2238             log_info ("PIN changed.\n");
2239         }
2240     }
2241   else if (info->apptype == APP_TYPE_PIV)
2242     {
2243       /* Unblock the Application PIN.  */
2244       err = scd_change_pin ("PIV.80", 1);
2245       if (!err)
2246         log_info ("PIN unblocked and changed.\n");
2247     }
2248   else
2249     {
2250       log_info ("Unblocking not yet supported for '%s'\n",
2251                 app_type_string (info->apptype));
2252       err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2253     }
2254
2255   return err;
2256 }
2257
2258
2259 /* Note: On successful execution a redisplay should be scheduled.  If
2260  * this function fails the card may be in an unknown state. */
2261 static gpg_error_t
2262 cmd_factoryreset (card_info_t info)
2263 {
2264   gpg_error_t err;
2265   char *answer = NULL;
2266   int termstate = 0;
2267   int any_apdu = 0;
2268   int is_yubikey = 0;
2269   int i;
2270
2271
2272   if (!info)
2273     return print_help
2274       ("FACTORY-RESET\n\n"
2275        "Do a complete reset of some OpenPGP and PIV cards.  This\n"
2276        "deletes all data and keys and resets the PINs to their default.\n"
2277        "This is mainly used by developers with scratch cards.  Don't\n"
2278        "worry, you need to confirm before the command proceeds.",
2279        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2280
2281   /* We support the factory reset for most OpenPGP cards and Yubikeys
2282    * with the PIV application.  */
2283   if (info->apptype == APP_TYPE_OPENPGP)
2284     ;
2285   else if (info->apptype == APP_TYPE_PIV
2286            && info->cardtype && !strcmp (info->cardtype, "yubikey"))
2287     is_yubikey = 1;
2288   else
2289
2290     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2291
2292   /* For an OpenPGP card the code below basically does the same what
2293    * this gpg-connect-agent script does:
2294    *
2295    *   scd reset
2296    *   scd serialno undefined
2297    *   scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
2298    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2299    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2300    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2301    *   scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
2302    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2303    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2304    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2305    *   scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
2306    *   scd apdu 00 e6 00 00
2307    *   scd apdu 00 44 00 00
2308    *   scd reset
2309    *   /echo Card has been reset to factory defaults
2310    *
2311    * For a PIV application on a Yubikey it merely issues the Yubikey
2312    * specific resset command.
2313    */
2314
2315   err = scd_learn (info);
2316   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
2317       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
2318     termstate = 1;
2319   else if (err)
2320     {
2321       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
2322       goto leave;
2323     }
2324
2325   if (opt.interactive || opt.verbose)
2326     log_info (_("%s card no. %s detected\n"),
2327               app_type_string (info->apptype),
2328               info->dispserialno? info->dispserialno : info->serialno);
2329
2330   if (!termstate || is_yubikey)
2331     {
2332       if (!is_yubikey)
2333         {
2334           if (!(info->status_indicator == 3 || info->status_indicator == 5))
2335             {
2336               /* Note: We won't see status-indicator 3 here because it
2337                * is not possible to select a card application in
2338                * termination state.  */
2339               log_error (_("This command is not supported by this card\n"));
2340               err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2341               goto leave;
2342             }
2343         }
2344
2345       tty_printf ("\n");
2346       log_info
2347         (_("Note: This command destroys all keys stored on the card!\n"));
2348       tty_printf ("\n");
2349       xfree (answer);
2350       answer = tty_get (_("Continue? (y/N) "));
2351       tty_kill_prompt ();
2352       trim_spaces (answer);
2353       if (*answer == CONTROL_D
2354           || !answer_is_yes_no_default (answer, 0/*(default to no)*/))
2355         {
2356           err = gpg_error (GPG_ERR_CANCELED);
2357           goto leave;
2358         }
2359
2360       xfree (answer);
2361       answer = tty_get (_("Really do a factory reset? (enter \"yes\") "));
2362       tty_kill_prompt ();
2363       trim_spaces (answer);
2364       if (strcmp (answer, "yes") && strcmp (answer,_("yes")))
2365         {
2366           err = gpg_error (GPG_ERR_CANCELED);
2367           goto leave;
2368         }
2369
2370
2371       if (is_yubikey)
2372         {
2373           /* The PIV application si already selected, we only need to
2374            * send the special reset APDU after having blocked PIN and
2375            * PUK.  Note that blocking the PUK is done using the
2376            * unblock PIN command.  */
2377           any_apdu = 1;
2378           for (i=0; i < 5; i++)
2379             send_apdu ("0020008008FFFFFFFFFFFFFFFF", "VERIFY", 0xffff,
2380                        NULL, NULL);
2381           for (i=0; i < 5; i++)
2382             send_apdu ("002C008010FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
2383                        "RESET RETRY COUNTER", 0xffff, NULL, NULL);
2384           err = send_apdu ("00FB000001FF", "YUBIKEY RESET", 0, NULL, NULL);
2385           if (err)
2386             goto leave;
2387         }
2388       else /* OpenPGP card.  */
2389         {
2390           any_apdu = 1;
2391           /* We need to select a card application before we can send APDUs
2392            * to the card without scdaemon doing anything on its own.  */
2393           err = send_apdu (NULL, "RESET", 0, NULL, NULL);
2394           if (err)
2395             goto leave;
2396           err = send_apdu ("undefined", "dummy select ", 0, NULL, NULL);
2397           if (err)
2398             goto leave;
2399           /* Select the OpenPGP application.  */
2400           err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0,
2401                            NULL, NULL);
2402           if (err)
2403             goto leave;
2404
2405           /* Do some dummy verifies with wrong PINs to set the retry
2406            * counter to zero.  We can't easily use the card version 2.1
2407            * feature of presenting the admin PIN to allow the terminate
2408            * command because there is no machinery in scdaemon to catch
2409            * the verify command and ask for the PIN when the "APDU"
2410            * command is used.
2411            * Here, the length of dummy wrong PIN is 32-byte, also
2412            * supporting authentication with KDF DO.  */
2413           for (i=0; i < 4; i++)
2414             send_apdu ("0020008120"
2415                        "40404040404040404040404040404040"
2416                        "40404040404040404040404040404040", "VERIFY", 0xffff,
2417                        NULL, NULL);
2418           for (i=0; i < 4; i++)
2419             send_apdu ("0020008320"
2420                        "40404040404040404040404040404040"
2421                        "40404040404040404040404040404040", "VERIFY", 0xffff,
2422                        NULL, NULL);
2423
2424           /* Send terminate datafile command.  */
2425           err = send_apdu ("00e60000", "TERMINATE DF", 0x6985, NULL, NULL);
2426           if (err)
2427             goto leave;
2428         }
2429     }
2430
2431   if (!is_yubikey)
2432     {
2433       any_apdu = 1;
2434       /* Send activate datafile command.  This is used without
2435        * confirmation if the card is already in termination state.  */
2436       err = send_apdu ("00440000", "ACTIVATE DF", 0, NULL, NULL);
2437       if (err)
2438         goto leave;
2439     }
2440
2441   /* Finally we reset the card reader once more.  */
2442   err = send_apdu (NULL, "RESET", 0, NULL, NULL);
2443   if (err)
2444     goto leave;
2445
2446   /* Then, connect the card again (answer used as a dummy).  */
2447   xfree (answer); answer = NULL;
2448   err = scd_serialno (&answer, NULL);
2449
2450  leave:
2451   if (err && any_apdu && !is_yubikey)
2452     {
2453       log_info ("Due to an error the card might be in an inconsistent state\n"
2454                 "You should run the LIST command to check this.\n");
2455       /* FIXME: We need a better solution in the case that the card is
2456        * in a termination state, i.e. the card was removed before the
2457        * activate was sent.  The best solution I found with v2.1
2458        * Zeitcontrol card was to kill scdaemon and the issue this
2459        * sequence with gpg-connect-agent:
2460        *   scd reset
2461        *   scd serialno undefined
2462        *   scd apdu 00A4040006D27600012401 (returns error)
2463        *   scd apdu 00440000
2464        * Then kill scdaemon again and issue:
2465        *   scd reset
2466        *   scd serialno openpgp
2467        */
2468     }
2469   xfree (answer);
2470   return err;
2471 }
2472
2473
2474 /* Generate KDF data.  This is a helper for cmd_kdfsetup.  */
2475 static gpg_error_t
2476 gen_kdf_data (unsigned char *data, int single_salt)
2477 {
2478   gpg_error_t err;
2479   const unsigned char h0[] = { 0x81, 0x01, 0x03,
2480                                0x82, 0x01, 0x08,
2481                                0x83, 0x04 };
2482   const unsigned char h1[] = { 0x84, 0x08 };
2483   const unsigned char h2[] = { 0x85, 0x08 };
2484   const unsigned char h3[] = { 0x86, 0x08 };
2485   const unsigned char h4[] = { 0x87, 0x20 };
2486   const unsigned char h5[] = { 0x88, 0x20 };
2487   unsigned char *p, *salt_user, *salt_admin;
2488   unsigned char s2k_char;
2489   unsigned int iterations;
2490   unsigned char count_4byte[4];
2491
2492   p = data;
2493
2494   s2k_char = encode_s2k_iterations (agent_get_s2k_count ());
2495   iterations = S2K_DECODE_COUNT (s2k_char);
2496   count_4byte[0] = (iterations >> 24) & 0xff;
2497   count_4byte[1] = (iterations >> 16) & 0xff;
2498   count_4byte[2] = (iterations >>  8) & 0xff;
2499   count_4byte[3] = (iterations & 0xff);
2500
2501   memcpy (p, h0, sizeof h0);
2502   p += sizeof h0;
2503   memcpy (p, count_4byte, sizeof count_4byte);
2504   p += sizeof count_4byte;
2505   memcpy (p, h1, sizeof h1);
2506   salt_user = (p += sizeof h1);
2507   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2508   p += 8;
2509
2510   if (single_salt)
2511     salt_admin = salt_user;
2512   else
2513     {
2514       memcpy (p, h2, sizeof h2);
2515       p += sizeof h2;
2516       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2517       p += 8;
2518       memcpy (p, h3, sizeof h3);
2519       salt_admin = (p += sizeof h3);
2520       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2521       p += 8;
2522     }
2523
2524   memcpy (p, h4, sizeof h4);
2525   p += sizeof h4;
2526   err = gcry_kdf_derive (OPENPGP_USER_PIN_DEFAULT,
2527                          strlen (OPENPGP_USER_PIN_DEFAULT),
2528                          GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2529                          salt_user, 8, iterations, 32, p);
2530   p += 32;
2531   if (!err)
2532     {
2533       memcpy (p, h5, sizeof h5);
2534       p += sizeof h5;
2535       err = gcry_kdf_derive (OPENPGP_ADMIN_PIN_DEFAULT,
2536                              strlen (OPENPGP_ADMIN_PIN_DEFAULT),
2537                              GCRY_KDF_ITERSALTED_S2K, GCRY_MD_SHA256,
2538                              salt_admin, 8, iterations, 32, p);
2539     }
2540
2541   return err;
2542 }
2543
2544
2545 static gpg_error_t
2546 cmd_kdfsetup (card_info_t info, char *argstr)
2547 {
2548   gpg_error_t err;
2549   unsigned char kdf_data[OPENPGP_KDF_DATA_LENGTH_MAX];
2550   int single = (*argstr != 0);
2551
2552   if (!info)
2553     return print_help
2554       ("KDF-SETUP\n\n"
2555        "Prepare the OpenPGP card KDF feature for this card.",
2556        APP_TYPE_OPENPGP, 0);
2557
2558   if (info->apptype != APP_TYPE_OPENPGP)
2559     {
2560       log_info ("Note: This is an OpenPGP only command.\n");
2561       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2562     }
2563
2564   if (!info->extcap.kdf)
2565     {
2566       log_error (_("This command is not supported by this card\n"));
2567       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2568       goto leave;
2569     }
2570
2571   err = gen_kdf_data (kdf_data, single);
2572   if (err)
2573     goto leave;
2574
2575   err = scd_setattr ("KDF", kdf_data,
2576                      single ? OPENPGP_KDF_DATA_LENGTH_MIN
2577                      /* */  : OPENPGP_KDF_DATA_LENGTH_MAX);
2578   if (err)
2579     goto leave;
2580
2581   err = scd_getattr ("KDF", info);
2582
2583  leave:
2584   return err;
2585 }
2586
2587
2588 \f
2589 static void
2590 show_keysize_warning (void)
2591 {
2592   static int shown;
2593
2594   if (shown)
2595     return;
2596   shown = 1;
2597   tty_printf
2598     (_("Note: There is no guarantee that the card supports the requested\n"
2599        "      key type or size.  If the key generation does not succeed,\n"
2600        "      please check the documentation of your card to see which\n"
2601        "      key types and sizes are supported.\n")
2602      );
2603 }
2604
2605
2606 /* Ask for the size of a card key.  NBITS is the current size
2607  * configured for the card.  Returns 0 on success and stored the
2608  * chosen key size at R_KEYSIZE; 0 is stored to indicate that the
2609  * default size shall be used.  */
2610 static gpg_error_t
2611 ask_card_rsa_keysize (unsigned int nbits, unsigned int *r_keysize)
2612 {
2613   unsigned int min_nbits = 1024;
2614   unsigned int max_nbits = 4096;
2615   char*answer;
2616   unsigned int req_nbits;
2617
2618   for (;;)
2619     {
2620       answer = tty_getf (_("What keysize do you want? (%u) "), nbits);
2621       trim_spaces (answer);
2622       tty_kill_prompt ();
2623       if (*answer == CONTROL_D)
2624         {
2625           xfree (answer);
2626           return gpg_error (GPG_ERR_CANCELED);
2627         }
2628       req_nbits = *answer? atoi (answer): nbits;
2629       xfree (answer);
2630
2631       if (req_nbits != nbits && (req_nbits % 32) )
2632         {
2633           req_nbits = ((req_nbits + 31) / 32) * 32;
2634           tty_printf (_("rounded up to %u bits\n"), req_nbits);
2635         }
2636
2637       if (req_nbits == nbits)
2638         {
2639           /* Use default.  */
2640           *r_keysize = 0;
2641           return 0;
2642         }
2643
2644       if (req_nbits < min_nbits || req_nbits > max_nbits)
2645         {
2646           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
2647                       "RSA", min_nbits, max_nbits);
2648         }
2649       else
2650         {
2651           *r_keysize = req_nbits;
2652           return 0;
2653         }
2654     }
2655 }
2656
2657
2658 /* Ask for the key attribute of a card key.  CURRENT is the current
2659  * attribute configured for the card.  KEYNO is the number of the key
2660  * used to select the prompt.  Stores NULL at result to use the
2661  * default attribute or stores the selected attribute structure at
2662  * RESULT.  On error an error code is returned.  */
2663 static gpg_error_t
2664 ask_card_keyattr (int keyno, const struct key_attr *current,
2665                   struct key_attr **result)
2666 {
2667   gpg_error_t err;
2668   struct key_attr *key_attr = NULL;
2669   char *answer = NULL;
2670   int selection;
2671
2672   *result = NULL;
2673
2674   key_attr = xcalloc (1, sizeof *key_attr);
2675
2676   tty_printf (_("Changing card key attribute for: "));
2677   if (keyno == 0)
2678     tty_printf (_("Signature key\n"));
2679   else if (keyno == 1)
2680     tty_printf (_("Encryption key\n"));
2681   else
2682     tty_printf (_("Authentication key\n"));
2683
2684   tty_printf (_("Please select what kind of key you want:\n"));
2685   tty_printf (_("   (%d) RSA\n"), 1 );
2686   tty_printf (_("   (%d) ECC\n"), 2 );
2687
2688   for (;;)
2689     {
2690       xfree (answer);
2691       answer = tty_get (_("Your selection? "));
2692       trim_spaces (answer);
2693       tty_kill_prompt ();
2694       if (!*answer || *answer == CONTROL_D)
2695         {
2696           err = gpg_error (GPG_ERR_CANCELED);
2697           goto leave;
2698         }
2699       selection = *answer? atoi (answer) : 0;
2700
2701       if (selection == 1 || selection == 2)
2702         break;
2703       else
2704         tty_printf (_("Invalid selection.\n"));
2705     }
2706
2707
2708   if (selection == 1)
2709     {
2710       unsigned int nbits, result_nbits;
2711
2712       if (current->algo == PUBKEY_ALGO_RSA)
2713         nbits = current->nbits;
2714       else
2715         nbits = 2048;
2716
2717       err = ask_card_rsa_keysize (nbits, &result_nbits);
2718       if (err)
2719         goto leave;
2720       if (result_nbits == 0)
2721         {
2722           if (current->algo == PUBKEY_ALGO_RSA)
2723             {
2724               xfree (key_attr);
2725               key_attr = NULL;
2726             }
2727           else
2728             result_nbits = nbits;
2729         }
2730
2731       if (key_attr)
2732         {
2733           key_attr->algo = PUBKEY_ALGO_RSA;
2734           key_attr->nbits = result_nbits;
2735         }
2736     }
2737   else if (selection == 2)
2738     {
2739       const char *curve;
2740       /* const char *oid_str; */
2741       int algo;
2742
2743       if (current->algo == PUBKEY_ALGO_RSA)
2744         {
2745           if (keyno == 1) /* Encryption key */
2746             algo = PUBKEY_ALGO_ECDH;
2747           else /* Signature key or Authentication key */
2748             algo = PUBKEY_ALGO_ECDSA;
2749           curve = NULL;
2750         }
2751       else
2752         {
2753           algo = current->algo;
2754           curve = current->curve;
2755         }
2756
2757       (void)curve;
2758       (void)algo;
2759       err = GPG_ERR_NOT_IMPLEMENTED;
2760       goto leave;
2761       /* FIXME: We need to move the ask_cure code out to common or
2762        * provide another sultion.  */
2763       /* curve = ask_curve (&algo, NULL, curve); */
2764       /* if (curve) */
2765       /*   { */
2766       /*     key_attr->algo = algo; */
2767       /*     oid_str = openpgp_curve_to_oid (curve, NULL); */
2768       /*     key_attr->curve = openpgp_oid_to_curve (oid_str, 0); */
2769       /*   } */
2770       /* else */
2771       /*   { */
2772       /*     xfree (key_attr); */
2773       /*     key_attr = NULL; */
2774       /*   } */
2775     }
2776   else
2777     {
2778       err = gpg_error (GPG_ERR_BUG);
2779       goto leave;
2780     }
2781
2782   /* Tell the user what we are going to do.  */
2783   if (key_attr->algo == PUBKEY_ALGO_RSA)
2784     {
2785       tty_printf (_("The card will now be re-configured"
2786                     " to generate a key of %u bits\n"), key_attr->nbits);
2787     }
2788   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2789            || key_attr->algo == PUBKEY_ALGO_ECDSA
2790            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2791     {
2792       tty_printf (_("The card will now be re-configured"
2793                     " to generate a key of type: %s\n"), key_attr->curve);
2794     }
2795   show_keysize_warning ();
2796
2797   *result = key_attr;
2798   key_attr = NULL;
2799
2800  leave:
2801   xfree (key_attr);
2802   xfree (answer);
2803   return err;
2804 }
2805
2806
2807 /* Change the key attribute of key KEYNO (0..2) and show an error
2808  * message if that fails.  */
2809 static gpg_error_t
2810 do_change_keyattr (int keyno, const struct key_attr *key_attr)
2811 {
2812   gpg_error_t err = 0;
2813   char args[100];
2814
2815   if (key_attr->algo == PUBKEY_ALGO_RSA)
2816     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
2817               key_attr->nbits);
2818   else if (key_attr->algo == PUBKEY_ALGO_ECDH
2819            || key_attr->algo == PUBKEY_ALGO_ECDSA
2820            || key_attr->algo == PUBKEY_ALGO_EDDSA)
2821     snprintf (args, sizeof args, "--force %d %d %s",
2822               keyno+1, key_attr->algo, key_attr->curve);
2823   else
2824     {
2825       /* FIXME: Above we use openpgp algo names but in the error
2826        * message we use the gcrypt names.  We should settle for a
2827        * consistent solution. */
2828       log_error (_("public key algorithm %d (%s) is not supported\n"),
2829                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
2830       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2831       goto leave;
2832     }
2833
2834   err = scd_setattr ("KEY-ATTR", args, strlen (args));
2835   if (err)
2836     log_error (_("error changing key attribute for key %d: %s\n"),
2837                keyno+1, gpg_strerror (err));
2838  leave:
2839   return err;
2840 }
2841
2842
2843 static gpg_error_t
2844 cmd_keyattr (card_info_t info, char *argstr)
2845 {
2846   gpg_error_t err = 0;
2847   int keyno;
2848   struct key_attr *key_attr = NULL;
2849
2850   (void)argstr;
2851
2852   if (!info)
2853     return print_help
2854       ("KEY-ATTR\n\n"
2855        "Menu to change the key attributes of an OpenPGP card.",
2856        APP_TYPE_OPENPGP, 0);
2857
2858   if (info->apptype != APP_TYPE_OPENPGP)
2859     {
2860       log_info ("Note: This is an OpenPGP only command.\n");
2861       return gpg_error (GPG_ERR_NOT_SUPPORTED);
2862     }
2863
2864   if (!(info->is_v2 && info->extcap.aac))
2865     {
2866       log_error (_("This command is not supported by this card\n"));
2867       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2868       goto leave;
2869     }
2870
2871   for (keyno = 0; keyno < DIM (info->key_attr); keyno++)
2872     {
2873       xfree (key_attr);
2874       key_attr = NULL;
2875       err = ask_card_keyattr (keyno, &info->key_attr[keyno], &key_attr);
2876       if (err)
2877         goto leave;
2878
2879       err = do_change_keyattr (keyno, key_attr);
2880       if (err)
2881         {
2882           /* Error: Better read the default key attribute again.  */
2883           log_debug ("FIXME\n");
2884           /* Ask again for this key. */
2885           keyno--;
2886         }
2887     }
2888
2889  leave:
2890   xfree (key_attr);
2891   return err;
2892 }
2893
2894
2895 static gpg_error_t
2896 cmd_uif (card_info_t info, char *argstr)
2897 {
2898   gpg_error_t err;
2899   int keyno;
2900
2901   if (!info)
2902     return print_help
2903       ("UIF N [on|off|permanent]\n\n"
2904        "Change the User Interaction Flag.  N must in the range 1 to 3.",
2905        APP_TYPE_OPENPGP, APP_TYPE_PIV, 0);
2906
2907   argstr = skip_options (argstr);
2908
2909   if (digitp (argstr))
2910     {
2911       keyno = atoi (argstr);
2912       while (digitp (argstr))
2913         argstr++;
2914       while (spacep (argstr))
2915         argstr++;
2916     }
2917   else
2918     keyno = 0;
2919
2920   if (keyno < 1 || keyno > 3)
2921     {
2922       err = gpg_error (GPG_ERR_INV_ARG);
2923       goto leave;
2924     }
2925
2926
2927   err = GPG_ERR_NOT_IMPLEMENTED;
2928
2929  leave:
2930   return err;
2931 }
2932
2933
2934 static gpg_error_t
2935 cmd_yubikey (card_info_t info, char *argstr)
2936 {
2937   gpg_error_t err, err2;
2938   estream_t fp = opt.interactive? NULL : es_stdout;
2939   char *words[20];
2940   int nwords;
2941
2942   if (!info)
2943     return print_help
2944       ("YUBIKEY <cmd> args\n\n"
2945        "Various commands pertaining to Yubikey tokens with <cmd> being:\n"
2946        "\n"
2947        "  LIST \n"
2948        "\n"
2949        "List supported and enabled applications.\n"
2950        "\n"
2951        "  ENABLE  usb|nfc|all [otp|u2f|opgp|piv|oath|fido2|all]\n"
2952        "  DISABLE usb|nfc|all [otp|u2f|opgp|piv|oath|fido2|all]\n"
2953        "\n"
2954        "Enable or disable the specified or all applications on the\n"
2955        "given interface.",
2956        0);
2957
2958   argstr = skip_options (argstr);
2959
2960   if (!info->cardtype || strcmp (info->cardtype, "yubikey"))
2961     {
2962       log_info ("This command can only be used with Yubikeys.\n");
2963       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
2964       goto leave;
2965     }
2966
2967   nwords = split_fields (argstr, words, DIM (words));
2968   if (nwords < 1)
2969     {
2970       err = gpg_error (GPG_ERR_SYNTAX);
2971       goto leave;
2972     }
2973
2974
2975   /* Note that we always do a learn to get a chance to the card back
2976    * into a usable state.  */
2977   err = yubikey_commands (fp, nwords, words);
2978   err2 = scd_learn (info);
2979   if (err2)
2980     log_error ("Error re-reading card: %s\n", gpg_strerror (err));
2981
2982  leave:
2983   return err;
2984 }
2985
2986 \f
2987
2988 /* Data used by the command parser.  This needs to be outside of the
2989  * function scope to allow readline based command completion.  */
2990 enum cmdids
2991   {
2992     cmdNOP = 0,
2993     cmdQUIT, cmdHELP, cmdLIST, cmdRESET, cmdVERIFY,
2994     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSALUT, cmdCAFPR,
2995     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2996     cmdREADCERT, cmdWRITEKEY,  cmdUNBLOCK, cmdFACTRST, cmdKDFSETUP,
2997     cmdKEYATTR, cmdUIF, cmdAUTH, cmdYUBIKEY,
2998     cmdINVCMD
2999   };
3000
3001 static struct
3002 {
3003   const char *name;
3004   enum cmdids id;
3005   const char *desc;
3006 } cmds[] = {
3007   { "quit"    ,  cmdQUIT,       N_("quit this menu")},
3008   { "q"       ,  cmdQUIT,       NULL },
3009   { "help"    ,  cmdHELP,       N_("show this help")},
3010   { "?"       ,  cmdHELP,       NULL },
3011   { "list"    ,  cmdLIST,       N_("list all available data")},
3012   { "l"       ,  cmdLIST,       NULL },
3013   { "name"    ,  cmdNAME,       N_("change card holder's name")},
3014   { "url"     ,  cmdURL,        N_("change URL to retrieve key")},
3015   { "fetch"   ,  cmdFETCH,      N_("fetch the key specified in the card URL")},
3016   { "login"   ,  cmdLOGIN,      N_("change the login name")},
3017   { "lang"    ,  cmdLANG,       N_("change the language preferences")},
3018   { "salutation",cmdSALUT,      N_("change card holder's salutation")},
3019   { "salut"   ,  cmdSALUT,      NULL },
3020   { "cafpr"   ,  cmdCAFPR ,     N_("change a CA fingerprint")},
3021   { "forcesig",  cmdFORCESIG,   N_("toggle the signature force PIN flag")},
3022   { "generate",  cmdGENERATE,   N_("generate new keys")},
3023   { "passwd"  ,  cmdPASSWD,     N_("menu to change or unblock the PIN")},
3024   { "verify"  ,  cmdVERIFY,     N_("verify the PIN and list all data")},
3025   { "unblock" ,  cmdUNBLOCK,    N_("unblock the PIN using a Reset Code")},
3026   { "authenticate",cmdAUTH,     N_("authenticate to the card")},
3027   { "auth"    ,  cmdAUTH,       NULL },
3028   { "reset"   ,  cmdRESET,      N_("send a reset to the card daemon")},
3029   { "factory-reset",cmdFACTRST, N_("destroy all keys and data")},
3030   { "kdf-setup", cmdKDFSETUP,   N_("setup KDF for PIN authentication")},
3031   { "key-attr",  cmdKEYATTR,    N_("change the key attribute")},
3032   { "uif",       cmdUIF,        N_("change the User Interaction Flag")},
3033   { "privatedo", cmdPRIVATEDO,  N_("change a private data object")},
3034   { "readcert",  cmdREADCERT,   N_("read a certificate from a data object")},
3035   { "writecert", cmdWRITECERT,  N_("store a certificate to a data object")},
3036   { "writekey",  cmdWRITEKEY,   N_("store a private key to a data object")},
3037   { "yubikey",   cmdYUBIKEY,    N_("Yubikey management commands")},
3038   { NULL, cmdINVCMD, NULL }
3039 };
3040
3041
3042 /* The command line command dispatcher.  */
3043 static gpg_error_t
3044 dispatch_command (card_info_t info, const char *orig_command)
3045 {
3046   gpg_error_t err = 0;
3047   enum cmdids cmd;             /* The command.  */
3048   char *command;               /* A malloced copy of ORIG_COMMAND.  */
3049   char *argstr;                /* The argument as a string.  */
3050   int i;
3051   int ignore_error;
3052
3053   if ((ignore_error = *orig_command == '-'))
3054     orig_command++;
3055   command = xstrdup (orig_command);
3056   argstr = NULL;
3057   if ((argstr = strchr (command, ' ')))
3058     {
3059       *argstr++ = 0;
3060       trim_spaces (command);
3061       trim_spaces (argstr);
3062     }
3063
3064   for (i=0; cmds[i].name; i++ )
3065     if (!ascii_strcasecmp (command, cmds[i].name ))
3066       break;
3067   cmd = cmds[i].id; /* (If not found this will be cmdINVCMD). */
3068
3069   /* Make sure we have valid strings for the args.  They are allowed
3070    * to be modified and must thus point to a buffer.  */
3071   if (!argstr)
3072     argstr = command + strlen (command);
3073
3074   /* For most commands we need to make sure that we have a card.  */
3075   if (!info)
3076     ;  /* Help mode */
3077   else if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP
3078              || cmd == cmdINVCMD)
3079            && !info->initialized)
3080     {
3081       err = scd_learn (info);
3082       if (err)
3083         {
3084           log_error ("Error reading card: %s\n", gpg_strerror (err));
3085           goto leave;
3086         }
3087     }
3088
3089   switch (cmd)
3090     {
3091     case cmdNOP:
3092       if (!info)
3093         print_help ("NOP\n\n"
3094                     "Dummy command.", 0);
3095       break;
3096
3097     case cmdQUIT:
3098       if (!info)
3099         print_help ("QUIT\n\n"
3100                     "Stop processing.", 0);
3101       else
3102         {
3103           err = gpg_error (GPG_ERR_EOF);
3104           goto leave;
3105         }
3106       break;
3107
3108     case cmdHELP:
3109       if (!info)
3110         print_help ("HELP [command]\n\n"
3111                     "Show all commands.  With an argument show help\n"
3112                     "for that command.", 0);
3113       else if (*argstr)
3114         dispatch_command (NULL, argstr);
3115       else
3116         {
3117           es_printf
3118             ("List of commands (\"help <command>\" for details):\n");
3119           for (i=0; cmds[i].name; i++ )
3120             if(cmds[i].desc)
3121               es_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
3122           es_printf ("Prefix a command with a dash to ignore its error.\n");
3123         }
3124       break;
3125
3126     case cmdLIST:
3127       if (!info)
3128         print_help ("LIST\n\n"
3129                     "Show content of the card.", 0);
3130       else
3131         {
3132           err = scd_learn (info);
3133           if (err)
3134             log_error ("Error reading card: %s\n", gpg_strerror (err));
3135           else
3136             list_card (info);
3137         }
3138       break;
3139
3140     case cmdRESET:
3141       if (!info)
3142         print_help ("RESET\n\n"
3143                     "Send a RESET to the card daemon.", 0);
3144       else
3145         {
3146           flush_keyblock_cache ();
3147           err = scd_apdu (NULL, NULL, NULL, NULL);
3148         }
3149       break;
3150
3151     case cmdVERIFY:       err = cmd_verify (info, argstr); break;
3152     case cmdAUTH:         err = cmd_authenticate (info, argstr); break;
3153     case cmdNAME:         err = cmd_name (info, argstr); break;
3154     case cmdURL:          err = cmd_url (info, argstr);  break;
3155     case cmdFETCH:        err = cmd_fetch (info);  break;
3156     case cmdLOGIN:        err = cmd_login (info, argstr); break;
3157     case cmdLANG:         err = cmd_lang (info, argstr); break;
3158     case cmdSALUT:        err = cmd_salut (info, argstr); break;
3159     case cmdCAFPR:        err = cmd_cafpr (info, argstr); break;
3160     case cmdPRIVATEDO:    err = cmd_privatedo (info, argstr); break;
3161     case cmdWRITECERT:    err = cmd_writecert (info, argstr); break;
3162     case cmdREADCERT:     err = cmd_readcert (info, argstr); break;
3163     case cmdWRITEKEY:     err = cmd_writekey (info, argstr); break;
3164     case cmdFORCESIG:     err = cmd_forcesig (info); break;
3165     case cmdGENERATE:     err = cmd_generate (info, argstr); break;
3166     case cmdPASSWD:       err = cmd_passwd (info, argstr); break;
3167     case cmdUNBLOCK:      err = cmd_unblock (info); break;
3168     case cmdFACTRST:      err = cmd_factoryreset (info); break;
3169     case cmdKDFSETUP:     err = cmd_kdfsetup (info, argstr); break;
3170     case cmdKEYATTR:      err = cmd_keyattr (info, argstr); break;
3171     case cmdUIF:          err = cmd_uif (info, argstr); break;
3172     case cmdYUBIKEY:      err = cmd_yubikey (info, argstr); break;
3173
3174     case cmdINVCMD:
3175     default:
3176       log_error (_("Invalid command  (try \"help\")\n"));
3177       break;
3178     } /* End command switch. */
3179
3180
3181  leave:
3182   /* Return GPG_ERR_EOF only if its origin was "quit".  */
3183   es_fflush (es_stdout);
3184   if (gpg_err_code (err) == GPG_ERR_EOF && cmd != cmdQUIT)
3185     err = gpg_error (GPG_ERR_GENERAL);
3186   if (err && gpg_err_code (err) != GPG_ERR_EOF)
3187     {
3188       if (ignore_error)
3189         {
3190           log_info ("Command '%s' failed: %s\n", command, gpg_strerror (err));
3191           err = 0;
3192         }
3193       else
3194         log_error ("Command '%s' failed: %s\n", command, gpg_strerror (err));
3195     }
3196   xfree (command);
3197
3198   return err;
3199 }
3200
3201
3202 /* The interactive main loop.  */
3203 static void
3204 interactive_loop (void)
3205 {
3206   gpg_error_t err;
3207   char *answer = NULL;         /* The input line.  */
3208   enum cmdids cmd = cmdNOP;    /* The command.  */
3209   char *argstr;                /* The argument as a string.  */
3210   int redisplay = 1;           /* Whether to redisplay the main info.  */
3211   char *help_arg = NULL;       /* Argument of the HELP command.         */
3212   struct card_info_s info_buffer = { 0 };
3213   card_info_t info = &info_buffer;
3214   char *p;
3215   int i;
3216
3217   /* In the interactive mode we do not want to print the program prefix.  */
3218   log_set_prefix (NULL, 0);
3219
3220   for (;;)
3221     {
3222       if (help_arg)
3223         {
3224           /* Clear info to indicate helpmode */
3225           info = NULL;
3226         }
3227       else if (!info)
3228         {
3229           /* Get out of help.  */
3230           info = &info_buffer;
3231           help_arg = NULL;
3232           redisplay = 0;
3233         }
3234       else if (redisplay)
3235         {
3236           err = scd_learn (info);
3237           if (err)
3238             {
3239               log_error ("Error reading card: %s\n", gpg_strerror (err));
3240             }
3241           else
3242             {
3243               list_card (info);
3244               tty_printf("\n");
3245               redisplay = 0;
3246             }
3247         }
3248
3249       if (!info)
3250         {
3251           /* Copy the pending help arg into our answer.  Noe that
3252            * help_arg points into answer.  */
3253           p = xstrdup (help_arg);
3254           help_arg = NULL;
3255           xfree (answer);
3256           answer = p;
3257         }
3258       else
3259         {
3260           do
3261             {
3262               xfree (answer);
3263               tty_enable_completion (command_completion);
3264               answer = tty_get (_("gpg/card> "));
3265               tty_kill_prompt();
3266               tty_disable_completion ();
3267               trim_spaces(answer);
3268             }
3269           while ( *answer == '#' );
3270         }
3271
3272       argstr = NULL;
3273       if (!*answer)
3274         cmd = cmdLIST; /* We default to the list command */
3275       else if (*answer == CONTROL_D)
3276         cmd = cmdQUIT;
3277       else
3278         {
3279           if ((argstr = strchr (answer,' ')))
3280             {
3281               *argstr++ = 0;
3282               trim_spaces (answer);
3283               trim_spaces (argstr);
3284             }
3285
3286           for (i=0; cmds[i].name; i++ )
3287             if (!ascii_strcasecmp (answer, cmds[i].name ))
3288               break;
3289
3290           cmd = cmds[i].id;
3291         }
3292
3293       /* Make sure we have valid strings for the args.  They are
3294        * allowed to be modified and must thus point to a buffer.  */
3295       if (!argstr)
3296         argstr = answer + strlen (answer);
3297
3298       if (!(cmd == cmdNOP || cmd == cmdQUIT || cmd == cmdHELP
3299             || cmd == cmdINVCMD))
3300         {
3301           /* If redisplay is set we know that there was an error reading
3302            * the card.  In this case we force a LIST command to retry.  */
3303           if (!info)
3304             ; /* In help mode.  */
3305           else if (redisplay)
3306             {
3307               cmd = cmdLIST;
3308             }
3309           else if (!info->serialno)
3310             {
3311               /* Without a serial number most commands won't work.
3312                * Catch it here.  */
3313               tty_printf ("\n");
3314               tty_printf ("Serial number missing\n");
3315               continue;
3316             }
3317         }
3318
3319       err = 0;
3320       switch (cmd)
3321         {
3322         case cmdNOP:
3323           if (!info)
3324             print_help ("NOP\n\n"
3325                         "Dummy command.", 0);
3326           break;
3327
3328         case cmdQUIT:
3329           if (!info)
3330             print_help ("QUIT\n\n"
3331                         "Leave this tool.", 0);
3332           else
3333             {
3334               tty_printf ("\n");
3335               goto leave;
3336             }
3337           break;
3338
3339         case cmdHELP:
3340           if (!info)
3341             print_help ("HELP [command]\n\n"
3342                         "Show all commands.  With an argument show help\n"
3343                         "for that command.", 0);
3344           else if (*argstr)
3345             help_arg = argstr; /* Trigger help for a command.  */
3346           else
3347             {
3348               tty_printf
3349                 ("List of commands (\"help <command>\" for details):\n");
3350               for (i=0; cmds[i].name; i++ )
3351                 if(cmds[i].desc)
3352                   tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
3353             }
3354           break;
3355
3356         case cmdLIST:
3357           if (!info)
3358             print_help ("LIST\n\n"
3359                         "Show content of the card.", 0);
3360           else
3361             {
3362               /* Actual work is done by the redisplay code block.  */
3363               redisplay = 1;
3364             }
3365           break;
3366
3367         case cmdRESET:
3368           if (!info)
3369             print_help ("RESET\n\n"
3370                         "Send a RESET to the card daemon.", 0);
3371           else
3372             {
3373               flush_keyblock_cache ();
3374               err = scd_apdu (NULL, NULL, NULL, NULL);
3375             }
3376           break;
3377
3378         case cmdVERIFY:
3379           err = cmd_verify (info, argstr);
3380           if (!err)
3381             redisplay = 1;
3382           break;
3383         case cmdAUTH:      err = cmd_authenticate (info, argstr); break;
3384         case cmdNAME:      err = cmd_name (info, argstr); break;
3385         case cmdURL:       err = cmd_url (info, argstr);  break;
3386         case cmdFETCH:     err = cmd_fetch (info);  break;
3387         case cmdLOGIN:     err = cmd_login (info, argstr); break;
3388         case cmdLANG:      err = cmd_lang (info, argstr); break;
3389         case cmdSALUT:     err = cmd_salut (info, argstr); break;
3390         case cmdCAFPR:     err = cmd_cafpr (info, argstr); break;
3391         case cmdPRIVATEDO: err = cmd_privatedo (info, argstr); break;
3392         case cmdWRITECERT: err = cmd_writecert (info, argstr); break;
3393         case cmdREADCERT:  err = cmd_readcert (info, argstr); break;
3394         case cmdWRITEKEY:  err = cmd_writekey (info, argstr); break;
3395         case cmdFORCESIG:  err = cmd_forcesig (info); break;
3396         case cmdGENERATE:  err = cmd_generate (info, argstr); break;
3397         case cmdPASSWD:    err = cmd_passwd (info, argstr); break;
3398         case cmdUNBLOCK:   err = cmd_unblock (info); break;
3399         case cmdFACTRST:
3400           err = cmd_factoryreset (info);
3401           if (!err)
3402             redisplay = 1;
3403           break;
3404         case cmdKDFSETUP:  err = cmd_kdfsetup (info, argstr); break;
3405         case cmdKEYATTR:   err = cmd_keyattr (info, argstr); break;
3406         case cmdUIF:       err = cmd_uif (info, argstr); break;
3407         case cmdYUBIKEY:   err = cmd_yubikey (info, argstr); break;
3408
3409         case cmdINVCMD:
3410         default:
3411           tty_printf ("\n");
3412           tty_printf (_("Invalid command  (try \"help\")\n"));
3413           break;
3414         } /* End command switch. */
3415
3416       if (gpg_err_code (err) == GPG_ERR_CANCELED)
3417         tty_fprintf (NULL, "\n");
3418       else if (err)
3419         {
3420           const char *s = "?";
3421           for (i=0; cmds[i].name; i++ )
3422             if (cmd == cmds[i].id)
3423               {
3424                 s = cmds[i].name;
3425                 break;
3426               }
3427           log_error ("Command '%s' failed: %s\n", s, gpg_strerror (err));
3428         }
3429
3430     } /* End of main menu loop. */
3431
3432  leave:
3433   release_card_info (info);
3434   xfree (answer);
3435 }
3436
3437 #ifdef HAVE_LIBREADLINE
3438 /* Helper function for readline's command completion. */
3439 static char *
3440 command_generator (const char *text, int state)
3441 {
3442   static int list_index, len;
3443   const char *name;
3444
3445   /* If this is a new word to complete, initialize now.  This includes
3446    * saving the length of TEXT for efficiency, and initializing the
3447    index variable to 0. */
3448   if (!state)
3449     {
3450       list_index = 0;
3451       len = strlen(text);
3452     }
3453
3454   /* Return the next partial match */
3455   while ((name = cmds[list_index].name))
3456     {
3457       /* Only complete commands that have help text. */
3458       if (cmds[list_index++].desc && !strncmp (name, text, len))
3459         return strdup(name);
3460     }
3461
3462   return NULL;
3463 }
3464
3465 /* Second helper function for readline's command completion.  */
3466 static char **
3467 command_completion (const char *text, int start, int end)
3468 {
3469   (void)end;
3470
3471   /* If we are at the start of a line, we try and command-complete.
3472    * If not, just do nothing for now.  The support for help completion
3473    * needs to be more smarter. */
3474   if (!start)
3475     return rl_completion_matches (text, command_generator);
3476   else if (start == 5 && !ascii_strncasecmp (rl_line_buffer, "help ", 5))
3477     return rl_completion_matches (text, command_generator);
3478
3479   rl_attempted_completion_over = 1;
3480
3481   return NULL;
3482 }
3483 #endif /*HAVE_LIBREADLINE*/