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