gpg: Introduce magic value 25519 to switch a card to ECC.
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  * Copyright (C) 2003-2005, 2009 Free Software Foundation, Inc.
3  * Copyright (C) 2003-2005, 2009 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <https://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #ifdef HAVE_LIBREADLINE
27 # define GNUPG_LIBREADLINE_H_INCLUDED
28 # include <readline/readline.h>
29 #endif /*HAVE_LIBREADLINE*/
30
31 #if GNUPG_MAJOR_VERSION != 1
32 # include "gpg.h"
33 #endif /*GNUPG_MAJOR_VERSION != 1*/
34 #include "../common/util.h"
35 #include "../common/i18n.h"
36 #include "../common/ttyio.h"
37 #include "../common/status.h"
38 #include "options.h"
39 #include "main.h"
40 #include "keyserver-internal.h"
41
42 #if GNUPG_MAJOR_VERSION == 1
43 # include "cardglue.h"
44 #else /*GNUPG_MAJOR_VERSION!=1*/
45 # include "call-agent.h"
46 #endif /*GNUPG_MAJOR_VERSION!=1*/
47
48 #define CONTROL_D ('D' - 'A' + 1)
49
50
51 static void
52 write_sc_op_status (gpg_error_t err)
53 {
54   switch (gpg_err_code (err))
55     {
56     case 0:
57       write_status (STATUS_SC_OP_SUCCESS);
58       break;
59 #if GNUPG_MAJOR_VERSION != 1
60     case GPG_ERR_CANCELED:
61     case GPG_ERR_FULLY_CANCELED:
62       write_status_text (STATUS_SC_OP_FAILURE, "1");
63       break;
64     case GPG_ERR_BAD_PIN:
65       write_status_text (STATUS_SC_OP_FAILURE, "2");
66       break;
67     default:
68       write_status (STATUS_SC_OP_FAILURE);
69       break;
70 #endif /* GNUPG_MAJOR_VERSION != 1 */
71     }
72 }
73
74
75 /* Change the PIN of an OpenPGP card.  This is an interactive
76    function. */
77 void
78 change_pin (int unblock_v2, int allow_admin)
79 {
80   struct agent_card_info_s info;
81   int rc;
82
83   rc = agent_scd_learn (&info, 0);
84   if (rc)
85     {
86       log_error (_("OpenPGP card not available: %s\n"),
87                   gpg_strerror (rc));
88       return;
89     }
90
91   log_info (_("OpenPGP card no. %s detected\n"),
92               info.serialno? info.serialno : "[none]");
93
94   agent_clear_pin_cache (info.serialno);
95
96   if (opt.batch)
97     {
98       agent_release_card_info (&info);
99       log_error (_("can't do this in batch mode\n"));
100       return;
101     }
102
103
104   if (unblock_v2)
105     {
106       if (!info.is_v2)
107         log_error (_("This command is only available for version 2 cards\n"));
108       else if (!info.chvretry[1])
109         log_error (_("Reset Code not or not anymore available\n"));
110       else
111         {
112           rc = agent_scd_change_pin (2, info.serialno);
113           write_sc_op_status (rc);
114           if (rc)
115             tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
116           else
117             tty_printf ("PIN changed.\n");
118         }
119     }
120   else if (!allow_admin)
121     {
122       rc = agent_scd_change_pin (1, info.serialno);
123       write_sc_op_status (rc);
124       if (rc)
125         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
126       else
127         tty_printf ("PIN changed.\n");
128     }
129   else
130     for (;;)
131       {
132         char *answer;
133
134         tty_printf ("\n");
135         tty_printf ("1 - change PIN\n"
136                     "2 - unblock PIN\n"
137                     "3 - change Admin PIN\n"
138                     "4 - set the Reset Code\n"
139                     "Q - quit\n");
140         tty_printf ("\n");
141
142         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
143         cpr_kill_prompt();
144         if (strlen (answer) != 1)
145           continue;
146
147         if (*answer == '1')
148           {
149             /* Change PIN.  */
150             rc = agent_scd_change_pin (1, info.serialno);
151             write_sc_op_status (rc);
152             if (rc)
153               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
154             else
155               tty_printf ("PIN changed.\n");
156           }
157         else if (*answer == '2')
158           {
159             /* Unblock PIN.  */
160             rc = agent_scd_change_pin (101, info.serialno);
161             write_sc_op_status (rc);
162             if (rc)
163               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
164             else
165               tty_printf ("PIN unblocked and new PIN set.\n");
166           }
167         else if (*answer == '3')
168           {
169             /* Change Admin PIN.  */
170             rc = agent_scd_change_pin (3, info.serialno);
171             write_sc_op_status (rc);
172             if (rc)
173               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
174             else
175               tty_printf ("PIN changed.\n");
176           }
177         else if (*answer == '4')
178           {
179             /* Set a new Reset Code.  */
180             rc = agent_scd_change_pin (102, info.serialno);
181             write_sc_op_status (rc);
182             if (rc)
183               tty_printf ("Error setting the Reset Code: %s\n",
184                           gpg_strerror (rc));
185             else
186               tty_printf ("Reset Code set.\n");
187           }
188         else if (*answer == 'q' || *answer == 'Q')
189           {
190             break;
191           }
192       }
193
194   agent_release_card_info (&info);
195 }
196
197 static const char *
198 get_manufacturer (unsigned int no)
199 {
200   /* Note:  Make sure that there is no colon or linefeed in the string. */
201   switch (no)
202     {
203     case 0x0001: return "PPC Card Systems";
204     case 0x0002: return "Prism";
205     case 0x0003: return "OpenFortress";
206     case 0x0004: return "Wewid";
207     case 0x0005: return "ZeitControl";
208     case 0x0006: return "Yubico";
209     case 0x0007: return "OpenKMS";
210     case 0x0008: return "LogoEmail";
211     case 0x0009: return "Fidesmo";
212     case 0x000A: return "Dangerous Things";
213
214     case 0x002A: return "Magrathea";
215     case 0x0042: return "GnuPG e.V.";
216
217     case 0x1337: return "Warsaw Hackerspace";
218     case 0x2342: return "warpzone"; /* hackerspace Muenster.  */
219     case 0xF517: return "FSIJ";
220
221       /* 0x0000 and 0xFFFF are defined as test cards per spec,
222          0xFF00 to 0xFFFE are assigned for use with randomly created
223          serial numbers.  */
224     case 0x0000:
225     case 0xffff: return "test card";
226     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
227     }
228 }
229
230
231 static void
232 print_sha1_fpr (estream_t fp, const unsigned char *fpr)
233 {
234   int i;
235
236   if (fpr)
237     {
238       for (i=0; i < 20 ; i+=2, fpr += 2 )
239         {
240           if (i == 10 )
241             tty_fprintf (fp, " ");
242           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
243         }
244     }
245   else
246     tty_fprintf (fp, " [none]");
247   tty_fprintf (fp, "\n");
248 }
249
250
251 static void
252 print_sha1_fpr_colon (estream_t fp, const unsigned char *fpr)
253 {
254   int i;
255
256   if (fpr)
257     {
258       for (i=0; i < 20 ; i++, fpr++)
259         es_fprintf (fp, "%02X", *fpr);
260     }
261   es_putc (':', fp);
262 }
263
264
265 static void
266 print_name (estream_t fp, const char *text, const char *name)
267 {
268   tty_fprintf (fp, "%s", text);
269
270   /* FIXME: tty_printf_utf8_string2 eats everything after and
271      including an @ - e.g. when printing an url. */
272   if (name && *name)
273     {
274       if (fp)
275         print_utf8_buffer2 (fp, name, strlen (name), '\n');
276       else
277         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
278     }
279   else
280     tty_fprintf (fp, _("[not set]"));
281   tty_fprintf (fp, "\n");
282 }
283
284 static void
285 print_isoname (estream_t fp, const char *text,
286                const char *tag, const char *name)
287 {
288   if (opt.with_colons)
289     es_fprintf (fp, "%s:", tag);
290   else
291     tty_fprintf (fp, "%s", text);
292
293   if (name && *name)
294     {
295       char *p, *given, *buf = xstrdup (name);
296
297       given = strstr (buf, "<<");
298       for (p=buf; *p; p++)
299         if (*p == '<')
300           *p = ' ';
301       if (given && given[2])
302         {
303           *given = 0;
304           given += 2;
305           if (opt.with_colons)
306             es_write_sanitized (fp, given, strlen (given), ":", NULL);
307           else if (fp)
308             print_utf8_buffer2 (fp, given, strlen (given), '\n');
309           else
310             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
311
312           if (opt.with_colons)
313             es_putc (':', fp);
314           else if (*buf)
315             tty_fprintf (fp, " ");
316         }
317
318       if (opt.with_colons)
319         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
320       else if (fp)
321         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
322       else
323         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
324       xfree (buf);
325     }
326   else
327     {
328       if (opt.with_colons)
329         es_putc (':', fp);
330       else
331         tty_fprintf (fp, _("[not set]"));
332     }
333
334   if (opt.with_colons)
335     es_fputs (":\n", fp);
336   else
337     tty_fprintf (fp, "\n");
338 }
339
340 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
341 static int
342 fpr_is_zero (const char *fpr)
343 {
344   int i;
345
346   for (i=0; i < 20 && !fpr[i]; i++)
347     ;
348   return (i == 20);
349 }
350
351
352 /* Return true if the SHA1 fingerprint FPR consists only of 0xFF. */
353 static int
354 fpr_is_ff (const char *fpr)
355 {
356   int i;
357
358   for (i=0; i < 20 && fpr[i] == '\xff'; i++)
359     ;
360   return (i == 20);
361 }
362
363
364 /* Print all available information about the current card. */
365 static void
366 current_card_status (ctrl_t ctrl, estream_t fp,
367                      char *serialno, size_t serialnobuflen)
368 {
369   struct agent_card_info_s info;
370   PKT_public_key *pk = xcalloc (1, sizeof *pk);
371   kbnode_t keyblock = NULL;
372   int rc;
373   unsigned int uval;
374   const unsigned char *thefpr;
375   int i;
376
377   if (serialno && serialnobuflen)
378     *serialno = 0;
379
380   rc = agent_scd_learn (&info, 0);
381   if (rc)
382     {
383       if (opt.with_colons)
384         es_fputs ("AID:::\n", fp);
385       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
386       xfree (pk);
387       return;
388     }
389
390   if (opt.with_colons)
391     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
392   else
393     tty_fprintf (fp, "Reader ...........: %s\n",
394                  info.reader? info.reader : "[none]");
395   if (opt.with_colons)
396     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
397   else
398     tty_fprintf (fp, "Application ID ...: %s\n",
399                  info.serialno? info.serialno : "[none]");
400   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
401       || strlen (info.serialno) != 32 )
402     {
403       if (info.apptype && !strcmp (info.apptype, "NKS"))
404         {
405           if (opt.with_colons)
406             es_fputs ("netkey-card:\n", fp);
407           log_info ("this is a NetKey card\n");
408         }
409       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
410         {
411           if (opt.with_colons)
412             es_fputs ("dinsig-card:\n", fp);
413           log_info ("this is a DINSIG compliant card\n");
414         }
415       else if (info.apptype && !strcmp (info.apptype, "P15"))
416         {
417           if (opt.with_colons)
418             es_fputs ("pkcs15-card:\n", fp);
419           log_info ("this is a PKCS#15 compliant card\n");
420         }
421       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
422         {
423           if (opt.with_colons)
424             es_fputs ("geldkarte-card:\n", fp);
425           log_info ("this is a Geldkarte compliant card\n");
426         }
427       else
428         {
429           if (opt.with_colons)
430             es_fputs ("unknown:\n", fp);
431         }
432       log_info ("not an OpenPGP card\n");
433       agent_release_card_info (&info);
434       xfree (pk);
435       return;
436     }
437
438   if (!serialno)
439     ;
440   else if (strlen (info.serialno)+1 > serialnobuflen)
441     log_error ("serial number longer than expected\n");
442   else
443     strcpy (serialno, info.serialno);
444
445   if (opt.with_colons)
446     es_fputs ("openpgp-card:\n", fp);
447
448
449   if (opt.with_colons)
450     {
451       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
452       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
453       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
454       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
455
456       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
457
458       es_fputs ("lang:", fp);
459       if (info.disp_lang)
460         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
461                             ":", NULL);
462       es_fputs (":\n", fp);
463
464       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
465                                  info.disp_sex == 2? 'f' : 'u'));
466
467       es_fputs ("url:", fp);
468       if (info.pubkey_url)
469         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
470                             ":", NULL);
471       es_fputs (":\n", fp);
472
473       es_fputs ("login:", fp);
474       if (info.login_data)
475         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
476                             ":", NULL);
477       es_fputs (":\n", fp);
478
479       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
480       for (i=0; i < DIM (info.key_attr); i++)
481         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
482           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
483                       info.key_attr[i].algo, info.key_attr[i].nbits);
484         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
485                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
486                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
487           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
488                       info.key_attr[i].algo, info.key_attr[i].curve);
489       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
490                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
491       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
492                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
493       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
494
495       for (i=0; i < 4; i++)
496         {
497           if (info.private_do[i])
498             {
499               es_fprintf (fp, "private_do:%d:", i+1);
500               es_write_sanitized (fp, info.private_do[i],
501                                   strlen (info.private_do[i]), ":", NULL);
502               es_fputs (":\n", fp);
503             }
504         }
505
506       es_fputs ("cafpr:", fp);
507       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
508       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
509       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
510       es_putc ('\n', fp);
511       es_fputs ("fpr:", fp);
512       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
513       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
514       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
515       es_putc ('\n', fp);
516       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
517                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
518                (unsigned long)info.fpr3time);
519     }
520   else
521     {
522       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
523                    info.serialno[12] == '0'?"":info.serialno+12,
524                    info.serialno[13],
525                    info.serialno[14] == '0'?"":info.serialno+14,
526                    info.serialno[15]);
527       tty_fprintf (fp, "Manufacturer .....: %s\n",
528                    get_manufacturer (xtoi_2(info.serialno+16)*256
529                                      + xtoi_2 (info.serialno+18)));
530       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
531
532       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
533       print_name (fp, "Language prefs ...: ", info.disp_lang);
534       tty_fprintf (fp,    "Sex ..............: %s\n",
535                    info.disp_sex == 1? _("male"):
536                    info.disp_sex == 2? _("female") : _("unspecified"));
537       print_name (fp, "URL of public key : ", info.pubkey_url);
538       print_name (fp, "Login data .......: ", info.login_data);
539       if (info.private_do[0])
540         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
541       if (info.private_do[1])
542         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
543       if (info.private_do[2])
544         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
545       if (info.private_do[3])
546         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
547       if (info.cafpr1valid)
548         {
549           tty_fprintf (fp, "CA fingerprint %d .:", 1);
550           print_sha1_fpr (fp, info.cafpr1);
551         }
552       if (info.cafpr2valid)
553         {
554           tty_fprintf (fp, "CA fingerprint %d .:", 2);
555           print_sha1_fpr (fp, info.cafpr2);
556         }
557       if (info.cafpr3valid)
558         {
559           tty_fprintf (fp, "CA fingerprint %d .:", 3);
560           print_sha1_fpr (fp, info.cafpr3);
561         }
562       tty_fprintf (fp,    "Signature PIN ....: %s\n",
563                    info.chv1_cached? _("not forced"): _("forced"));
564       if (info.key_attr[0].algo)
565         {
566           tty_fprintf (fp,    "Key attributes ...:");
567           for (i=0; i < DIM (info.key_attr); i++)
568             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
569               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
570             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
571                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
572                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
573               {
574                 const char *curve_for_print = "?";
575
576                 if (info.key_attr[i].curve)
577                   {
578                     const char *oid;
579                     oid = openpgp_curve_to_oid (info.key_attr[i].curve, NULL);
580                     if (oid)
581                       curve_for_print = openpgp_oid_to_curve (oid, 0);
582                   }
583                 tty_fprintf (fp, " %s", curve_for_print);
584               }
585           tty_fprintf (fp, "\n");
586         }
587       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
588                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
589       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
590                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
591       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
592       tty_fprintf (fp, "Signature key ....:");
593       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
594       if (info.fpr1valid && info.fpr1time)
595         tty_fprintf (fp, "      created ....: %s\n",
596                      isotimestamp (info.fpr1time));
597       tty_fprintf (fp, "Encryption key....:");
598       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
599       if (info.fpr2valid && info.fpr2time)
600         tty_fprintf (fp, "      created ....: %s\n",
601                      isotimestamp (info.fpr2time));
602       tty_fprintf (fp, "Authentication key:");
603       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
604       if (info.fpr3valid && info.fpr3time)
605         tty_fprintf (fp, "      created ....: %s\n",
606                      isotimestamp (info.fpr3time));
607       tty_fprintf (fp, "General key info..: ");
608
609       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 :
610                 info.fpr3valid? info.fpr3 : NULL);
611       /* If the fingerprint is all 0xff, the key has no asssociated
612          OpenPGP certificate.  */
613       if ( thefpr && !fpr_is_ff (thefpr)
614            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, 20))
615         {
616           print_pubkey_info (ctrl, fp, pk);
617           if (keyblock)
618             print_card_key_info (fp, keyblock);
619         }
620       else
621         tty_fprintf (fp, "[none]\n");
622     }
623
624   release_kbnode (keyblock);
625   free_public_key (pk);
626   agent_release_card_info (&info);
627 }
628
629
630 /* Print all available information for specific card with SERIALNO.
631    Print all available information for current card when SERIALNO is NULL.
632    Or print llfor all cards when SERIALNO is "all".  */
633 void
634 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
635 {
636   int err;
637   strlist_t card_list, sl;
638   char *serialno0;
639   int all_cards = 0;
640
641   if (serialno == NULL)
642     {
643       current_card_status (ctrl, fp, NULL, 0);
644       return;
645     }
646
647   if (!strcmp (serialno, "all"))
648     all_cards = 1;
649
650   err = agent_scd_serialno (&serialno0, NULL);
651   if (err)
652     {
653       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
654         log_info (_("error getting serial number of card: %s\n"),
655                   gpg_strerror (err));
656       /* Nothing available.  */
657       return;
658     }
659
660   err = agent_scd_cardlist (&card_list);
661
662   for (sl = card_list; sl; sl = sl->next)
663     {
664       char *serialno1;
665
666       if (!all_cards && strcmp (serialno, sl->d))
667         continue;
668
669       err = agent_scd_serialno (&serialno1, sl->d);
670       if (err)
671         {
672           if (opt.verbose)
673             log_info (_("error getting serial number of card: %s\n"),
674                       gpg_strerror (err));
675           continue;
676         }
677
678       current_card_status (ctrl, fp, NULL, 0);
679       xfree (serialno1);
680
681       if (!all_cards)
682         goto leave;
683     }
684
685   /* Select the original card again.  */
686   err = agent_scd_serialno (&serialno0, serialno0);
687
688  leave:
689   xfree (serialno0);
690   free_strlist (card_list);
691 }
692
693
694 static char *
695 get_one_name (const char *prompt1, const char *prompt2)
696 {
697   char *name;
698   int i;
699
700   for (;;)
701     {
702       name = cpr_get (prompt1, prompt2);
703       if (!name)
704         return NULL;
705       trim_spaces (name);
706       cpr_kill_prompt ();
707       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
708         ;
709
710       /* The name must be in Latin-1 and not UTF-8 - lacking the code
711          to ensure this we restrict it to ASCII. */
712       if (name[i])
713         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
714       else if (strchr (name, '<'))
715         tty_printf (_("Error: The \"<\" character may not be used.\n"));
716       else if (strstr (name, "  "))
717         tty_printf (_("Error: Double spaces are not allowed.\n"));
718       else
719         return name;
720       xfree (name);
721     }
722 }
723
724
725
726 static int
727 change_name (void)
728 {
729   char *surname = NULL, *givenname = NULL;
730   char *isoname, *p;
731   int rc;
732
733   surname = get_one_name ("keygen.smartcard.surname",
734                                     _("Cardholder's surname: "));
735   givenname = get_one_name ("keygen.smartcard.givenname",
736                                        _("Cardholder's given name: "));
737   if (!surname || !givenname || (!*surname && !*givenname))
738     {
739       xfree (surname);
740       xfree (givenname);
741       return -1; /*canceled*/
742     }
743
744   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
745   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
746   xfree (surname);
747   xfree (givenname);
748   for (p=isoname; *p; p++)
749     if (*p == ' ')
750       *p = '<';
751
752   if (strlen (isoname) > 39 )
753     {
754       tty_printf (_("Error: Combined name too long "
755                     "(limit is %d characters).\n"), 39);
756       xfree (isoname);
757       return -1;
758     }
759
760   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname), NULL );
761   if (rc)
762     log_error ("error setting Name: %s\n", gpg_strerror (rc));
763
764   xfree (isoname);
765   return rc;
766 }
767
768
769 static int
770 change_url (void)
771 {
772   char *url;
773   int rc;
774
775   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
776   if (!url)
777     return -1;
778   trim_spaces (url);
779   cpr_kill_prompt ();
780
781   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url), NULL );
782   if (rc)
783     log_error ("error setting URL: %s\n", gpg_strerror (rc));
784   xfree (url);
785   write_sc_op_status (rc);
786   return rc;
787 }
788
789
790 /* Fetch the key from the URL given on the card or try to get it from
791    the default keyserver.  */
792 static int
793 fetch_url (ctrl_t ctrl)
794 {
795   int rc;
796   struct agent_card_info_s info;
797
798   memset(&info,0,sizeof(info));
799
800   rc=agent_scd_getattr("PUBKEY-URL",&info);
801   if(rc)
802     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
803   else
804     {
805       rc=agent_scd_getattr("KEY-FPR",&info);
806       if(rc)
807         log_error("error retrieving key fingerprint from card: %s\n",
808                   gpg_strerror(rc));
809       else if (info.pubkey_url && *info.pubkey_url)
810         {
811           strlist_t sl = NULL;
812
813           add_to_strlist (&sl, info.pubkey_url);
814           rc = keyserver_fetch (ctrl, sl, KEYORG_URL);
815           free_strlist (sl);
816         }
817       else if (info.fpr1valid)
818         {
819           rc = keyserver_import_fprint (ctrl, info.fpr1, 20, opt.keyserver, 0);
820         }
821     }
822
823   return rc;
824 }
825
826
827 #define MAX_GET_DATA_FROM_FILE 16384
828
829 /* Read data from file FNAME up to MAX_GET_DATA_FROM_FILE characters.
830    On error return -1 and store NULL at R_BUFFER; on success return
831    the number of bytes read and store the address of a newly allocated
832    buffer at R_BUFFER. */
833 static int
834 get_data_from_file (const char *fname, char **r_buffer)
835 {
836   estream_t fp;
837   char *data;
838   int n;
839
840   *r_buffer = NULL;
841
842   fp = es_fopen (fname, "rb");
843 #if GNUPG_MAJOR_VERSION == 1
844   if (fp && is_secured_file (fileno (fp)))
845     {
846       fclose (fp);
847       fp = NULL;
848       errno = EPERM;
849     }
850 #endif
851   if (!fp)
852     {
853       tty_printf (_("can't open '%s': %s\n"), fname, strerror (errno));
854       return -1;
855     }
856
857   data = xtrymalloc (MAX_GET_DATA_FROM_FILE);
858   if (!data)
859     {
860       tty_printf (_("error allocating enough memory: %s\n"), strerror (errno));
861       es_fclose (fp);
862       return -1;
863     }
864
865   n = es_fread (data, 1, MAX_GET_DATA_FROM_FILE, fp);
866   es_fclose (fp);
867   if (n < 0)
868     {
869       tty_printf (_("error reading '%s': %s\n"), fname, strerror (errno));
870       xfree (data);
871       return -1;
872     }
873   *r_buffer = data;
874   return n;
875 }
876
877
878 /* Write LENGTH bytes from BUFFER to file FNAME.  Return 0 on
879    success.  */
880 static int
881 put_data_to_file (const char *fname, const void *buffer, size_t length)
882 {
883   estream_t fp;
884
885   fp = es_fopen (fname, "wb");
886 #if GNUPG_MAJOR_VERSION == 1
887   if (fp && is_secured_file (fileno (fp)))
888     {
889       fclose (fp);
890       fp = NULL;
891       errno = EPERM;
892     }
893 #endif
894   if (!fp)
895     {
896       tty_printf (_("can't create '%s': %s\n"), fname, strerror (errno));
897       return -1;
898     }
899
900   if (length && es_fwrite (buffer, length, 1, fp) != 1)
901     {
902       tty_printf (_("error writing '%s': %s\n"), fname, strerror (errno));
903       es_fclose (fp);
904       return -1;
905     }
906   es_fclose (fp);
907   return 0;
908 }
909
910
911 static int
912 change_login (const char *args)
913 {
914   char *data;
915   int n;
916   int rc;
917
918   if (args && *args == '<')  /* Read it from a file */
919     {
920       for (args++; spacep (args); args++)
921         ;
922       n = get_data_from_file (args, &data);
923       if (n < 0)
924         return -1;
925     }
926   else
927     {
928       data = cpr_get ("cardedit.change_login",
929                       _("Login data (account name): "));
930       if (!data)
931         return -1;
932       trim_spaces (data);
933       cpr_kill_prompt ();
934       n = strlen (data);
935     }
936
937   rc = agent_scd_setattr ("LOGIN-DATA", data, n, NULL );
938   if (rc)
939     log_error ("error setting login data: %s\n", gpg_strerror (rc));
940   xfree (data);
941   write_sc_op_status (rc);
942   return rc;
943 }
944
945 static int
946 change_private_do (const char *args, int nr)
947 {
948   char do_name[] = "PRIVATE-DO-X";
949   char *data;
950   int n;
951   int rc;
952
953   log_assert (nr >= 1 && nr <= 4);
954   do_name[11] = '0' + nr;
955
956   if (args && (args = strchr (args, '<')))  /* Read it from a file */
957     {
958       for (args++; spacep (args); args++)
959         ;
960       n = get_data_from_file (args, &data);
961       if (n < 0)
962         return -1;
963     }
964   else
965     {
966       data = cpr_get ("cardedit.change_private_do",
967                       _("Private DO data: "));
968       if (!data)
969         return -1;
970       trim_spaces (data);
971       cpr_kill_prompt ();
972       n = strlen (data);
973     }
974
975   rc = agent_scd_setattr (do_name, data, n, NULL );
976   if (rc)
977     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
978   xfree (data);
979   write_sc_op_status (rc);
980   return rc;
981 }
982
983
984 static int
985 change_cert (const char *args)
986 {
987   char *data;
988   int n;
989   int rc;
990
991   if (args && *args == '<')  /* Read it from a file */
992     {
993       for (args++; spacep (args); args++)
994         ;
995       n = get_data_from_file (args, &data);
996       if (n < 0)
997         return -1;
998     }
999   else
1000     {
1001       tty_printf ("usage error: redirection to file required\n");
1002       return -1;
1003     }
1004
1005   rc = agent_scd_writecert ("OPENPGP.3", data, n);
1006   if (rc)
1007     log_error ("error writing certificate to card: %s\n", gpg_strerror (rc));
1008   xfree (data);
1009   write_sc_op_status (rc);
1010   return rc;
1011 }
1012
1013
1014 static int
1015 read_cert (const char *args)
1016 {
1017   const char *fname;
1018   void *buffer;
1019   size_t length;
1020   int rc;
1021
1022   if (args && *args == '>')  /* Write it to a file */
1023     {
1024       for (args++; spacep (args); args++)
1025         ;
1026       fname = args;
1027     }
1028   else
1029     {
1030       tty_printf ("usage error: redirection to file required\n");
1031       return -1;
1032     }
1033
1034   rc = agent_scd_readcert ("OPENPGP.3", &buffer, &length);
1035   if (rc)
1036     log_error ("error reading certificate from card: %s\n", gpg_strerror (rc));
1037   else
1038     rc = put_data_to_file (fname, buffer, length);
1039   xfree (buffer);
1040   write_sc_op_status (rc);
1041   return rc;
1042 }
1043
1044
1045 static int
1046 change_lang (void)
1047 {
1048   char *data, *p;
1049   int rc;
1050
1051   data = cpr_get ("cardedit.change_lang",
1052                   _("Language preferences: "));
1053   if (!data)
1054     return -1;
1055   trim_spaces (data);
1056   cpr_kill_prompt ();
1057
1058   if (strlen (data) > 8 || (strlen (data) & 1))
1059     {
1060       tty_printf (_("Error: invalid length of preference string.\n"));
1061       xfree (data);
1062       return -1;
1063     }
1064
1065   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
1066     ;
1067   if (*p)
1068     {
1069       tty_printf (_("Error: invalid characters in preference string.\n"));
1070       xfree (data);
1071       return -1;
1072     }
1073
1074   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data), NULL );
1075   if (rc)
1076     log_error ("error setting lang: %s\n", gpg_strerror (rc));
1077   xfree (data);
1078   write_sc_op_status (rc);
1079   return rc;
1080 }
1081
1082
1083 static int
1084 change_sex (void)
1085 {
1086   char *data;
1087   const char *str;
1088   int rc;
1089
1090   data = cpr_get ("cardedit.change_sex",
1091                   _("Sex ((M)ale, (F)emale or space): "));
1092   if (!data)
1093     return -1;
1094   trim_spaces (data);
1095   cpr_kill_prompt ();
1096
1097   if (!*data)
1098     str = "9";
1099   else if ((*data == 'M' || *data == 'm') && !data[1])
1100     str = "1";
1101   else if ((*data == 'F' || *data == 'f') && !data[1])
1102     str = "2";
1103   else
1104     {
1105       tty_printf (_("Error: invalid response.\n"));
1106       xfree (data);
1107       return -1;
1108     }
1109
1110   rc = agent_scd_setattr ("DISP-SEX", str, 1, NULL );
1111   if (rc)
1112     log_error ("error setting sex: %s\n", gpg_strerror (rc));
1113   xfree (data);
1114   write_sc_op_status (rc);
1115   return rc;
1116 }
1117
1118
1119 static int
1120 change_cafpr (int fprno)
1121 {
1122   char *data;
1123   const char *s;
1124   int i, c, rc;
1125   unsigned char fpr[MAX_FINGERPRINT_LEN];
1126   int fprlen;
1127
1128   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1129   if (!data)
1130     return -1;
1131   trim_spaces (data);
1132   cpr_kill_prompt ();
1133
1134   for (i=0, s=data; i < MAX_FINGERPRINT_LEN && *s; )
1135     {
1136       while (spacep(s))
1137         s++;
1138       if (*s == ':')
1139         s++;
1140       while (spacep(s))
1141         s++;
1142       c = hextobyte (s);
1143       if (c == -1)
1144         break;
1145       fpr[i++] = c;
1146       s += 2;
1147     }
1148   fprlen = i;
1149   xfree (data);
1150   if ((fprlen != 20 && fprlen != 32) || *s)
1151     {
1152       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1153       return -1;
1154     }
1155
1156   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1157                           fprno==2?"CA-FPR-2":
1158                           fprno==3?"CA-FPR-3":"x", fpr, fprlen, NULL );
1159   if (rc)
1160     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1161   write_sc_op_status (rc);
1162   return rc;
1163 }
1164
1165
1166
1167 static void
1168 toggle_forcesig (void)
1169 {
1170   struct agent_card_info_s info;
1171   int rc;
1172   int newstate;
1173
1174   memset (&info, 0, sizeof info);
1175   rc = agent_scd_getattr ("CHV-STATUS", &info);
1176   if (rc)
1177     {
1178       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1179       return;
1180     }
1181   newstate = !info.chv1_cached;
1182   agent_release_card_info (&info);
1183
1184   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1185   if (rc)
1186     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1187   write_sc_op_status (rc);
1188 }
1189
1190
1191 /* Helper for the key generation/edit functions.  */
1192 static int
1193 get_info_for_key_operation (struct agent_card_info_s *info)
1194 {
1195   int rc;
1196
1197   memset (info, 0, sizeof *info);
1198   rc = agent_scd_getattr ("SERIALNO", info);
1199   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1200       || strlen (info->serialno) != 32 )
1201     {
1202       log_error (_("key operation not possible: %s\n"),
1203                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1204       return rc? rc: -1;
1205     }
1206   rc = agent_scd_getattr ("KEY-FPR", info);
1207   if (!rc)
1208     rc = agent_scd_getattr ("CHV-STATUS", info);
1209   if (!rc)
1210     rc = agent_scd_getattr ("DISP-NAME", info);
1211   if (!rc)
1212     rc = agent_scd_getattr ("EXTCAP", info);
1213   if (!rc)
1214     rc = agent_scd_getattr ("KEY-ATTR", info);
1215   if (rc)
1216     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1217   return rc;
1218 }
1219
1220
1221 /* Helper for the key generation/edit functions.  */
1222 static int
1223 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1224 {
1225   int rc = 0;
1226
1227   agent_clear_pin_cache (info->serialno);
1228
1229   *forced_chv1 = !info->chv1_cached;
1230   if (*forced_chv1)
1231     { /* Switch off the forced mode so that during key generation we
1232          don't get bothered with PIN queries for each
1233          self-signature. */
1234       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1235       if (rc)
1236         {
1237           log_error ("error clearing forced signature PIN flag: %s\n",
1238                      gpg_strerror (rc));
1239           *forced_chv1 = 0;
1240         }
1241     }
1242
1243   if (!rc)
1244     {
1245       /* Check the PIN now, so that we won't get asked later for each
1246          binding signature. */
1247       rc = agent_scd_checkpin (info->serialno);
1248       if (rc)
1249         {
1250           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1251           write_sc_op_status (rc);
1252         }
1253   }
1254   return rc;
1255 }
1256
1257 /* Helper for the key generation/edit functions.  */
1258 static void
1259 restore_forced_chv1 (int *forced_chv1)
1260 {
1261   int rc;
1262
1263   if (*forced_chv1)
1264     { /* Switch back to forced state. */
1265       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1266       if (rc)
1267         {
1268           log_error ("error setting forced signature PIN flag: %s\n",
1269                      gpg_strerror (rc));
1270         }
1271     }
1272 }
1273
1274
1275 /* Helper for the key generation/edit functions.  */
1276 static void
1277 show_card_key_info (struct agent_card_info_s *info)
1278 {
1279   tty_fprintf (NULL, "Signature key ....:");
1280   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1281   tty_fprintf (NULL, "Encryption key....:");
1282   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1283   tty_fprintf (NULL, "Authentication key:");
1284   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1285   tty_printf ("\n");
1286 }
1287
1288
1289 /* Helper for the key generation/edit functions.  */
1290 static int
1291 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1292 {
1293   log_assert (keyno >= 0 && keyno <= 3);
1294
1295   if ((keyno == 1 && info->fpr1valid)
1296       || (keyno == 2 && info->fpr2valid)
1297       || (keyno == 3 && info->fpr3valid))
1298     {
1299       tty_printf ("\n");
1300       log_info ("WARNING: such a key has already been stored on the card!\n");
1301       tty_printf ("\n");
1302       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1303                                   _("Replace existing key? (y/N) ")))
1304         return -1;
1305       return 1;
1306     }
1307   return 0;
1308 }
1309
1310
1311 static void
1312 show_keysize_warning (void)
1313 {
1314   static int shown;
1315
1316   if (shown)
1317     return;
1318   shown = 1;
1319   tty_printf
1320     (_("Note: There is no guarantee that the card supports the requested\n"
1321        "      key type or size.  If the key generation does not succeed,\n"
1322        "      please check the documentation of your card to see which\n"
1323        "      key types and sizes are supported.\n")
1324      );
1325 }
1326
1327
1328 /* Ask for the size of a card key.  NBITS is the current size
1329    configured for the card.  KEYNO is the number of the key used to
1330    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1331    or the selected size.  */
1332 static unsigned int
1333 ask_card_keyattr (int keyno, unsigned int nbits)
1334 {
1335   unsigned int min_nbits = 1024;
1336   unsigned int max_nbits = 4096;
1337   char *prompt, *answer;
1338   unsigned int req_nbits;
1339
1340   for (;;)
1341     {
1342       prompt = xasprintf
1343         (keyno == 0?
1344          _("What keysize do you want for the Signature key? (%u) "):
1345          keyno == 1?
1346          _("What keysize do you want for the Encryption key? (%u) "):
1347          _("What keysize do you want for the Authentication key? (%u) "),
1348          nbits);
1349       answer = cpr_get ("cardedit.genkeys.size", prompt);
1350       cpr_kill_prompt ();
1351       req_nbits = *answer? atoi (answer): nbits;
1352       xfree (prompt);
1353       xfree (answer);
1354
1355       if (req_nbits == 25519)
1356         {
1357           if (req_nbits == nbits)
1358             return 0;  /* Use default.  */
1359
1360           tty_printf (_("The card will now be re-configured"
1361                         " to generate a key of type: %s\n"),
1362                       keyno==1? "cv25519":"ed25519");
1363           show_keysize_warning ();
1364           return req_nbits;
1365         }
1366       else
1367         {
1368           if (req_nbits != nbits && (req_nbits % 32) )
1369             {
1370               req_nbits = ((req_nbits + 31) / 32) * 32;
1371               tty_printf (_("rounded up to %u bits\n"), req_nbits);
1372             }
1373
1374           if (req_nbits == nbits)
1375             return 0;  /* Use default.  */
1376
1377           if (req_nbits < min_nbits || req_nbits > max_nbits)
1378             {
1379               tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1380                       "RSA", min_nbits, max_nbits);
1381             }
1382           else
1383             {
1384               tty_printf (_("The card will now be re-configured"
1385                             " to generate a key of %u bits\n"), req_nbits);
1386               show_keysize_warning ();
1387               return req_nbits;
1388             }
1389         }
1390     }
1391 }
1392
1393
1394 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1395  * message if that fails.  Using the magic value 25519 for NBITS
1396  * switches to ed25519 or cv25519 depending on the KEYNO.  */
1397 static gpg_error_t
1398 do_change_keyattr (int keyno, unsigned int nbits)
1399 {
1400   gpg_error_t err;
1401   char args[100];
1402
1403   if (nbits == 25519)
1404     snprintf (args, sizeof args, "--force %d %d %s",
1405               keyno+1,
1406               keyno == 1? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_EDDSA,
1407               keyno == 1? "cv25519" : "ed25519");
1408   else
1409     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1410   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1411   if (err)
1412     log_error (_("error changing size of key %d to %u bits: %s\n"),
1413                keyno+1, nbits, gpg_strerror (err));
1414   return err;
1415 }
1416
1417
1418 static void
1419 generate_card_keys (ctrl_t ctrl)
1420 {
1421   struct agent_card_info_s info;
1422   int forced_chv1;
1423   int want_backup;
1424   int keyno;
1425
1426   if (get_info_for_key_operation (&info))
1427     return;
1428
1429   if (info.extcap.ki)
1430     {
1431       char *answer;
1432
1433       /* FIXME: Should be something like cpr_get_bool so that a status
1434          GET_BOOL will be emitted.  */
1435       answer = cpr_get ("cardedit.genkeys.backup_enc",
1436                         _("Make off-card backup of encryption key? (Y/n) "));
1437
1438       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1439       cpr_kill_prompt ();
1440       xfree (answer);
1441     }
1442   else
1443     want_backup = 0;
1444
1445   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1446        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1447        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1448     {
1449       tty_printf ("\n");
1450       log_info (_("Note: keys are already stored on the card!\n"));
1451       tty_printf ("\n");
1452       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1453                                    _("Replace existing keys? (y/N) ")))
1454         {
1455           agent_release_card_info (&info);
1456           return;
1457         }
1458     }
1459
1460   /* If no displayed name has been set, we assume that this is a fresh
1461      card and print a hint about the default PINs.  */
1462   if (!info.disp_name || !*info.disp_name)
1463     {
1464       tty_printf ("\n");
1465       tty_printf (_("Please note that the factory settings of the PINs are\n"
1466                     "   PIN = '%s'     Admin PIN = '%s'\n"
1467                     "You should change them using the command --change-pin\n"),
1468                   "123456", "12345678");
1469       tty_printf ("\n");
1470     }
1471
1472   if (check_pin_for_key_operation (&info, &forced_chv1))
1473     goto leave;
1474
1475   /* If the cards features changeable key attributes, we ask for the
1476      key size.  */
1477   if (info.is_v2 && info.extcap.aac)
1478     {
1479       unsigned int nbits;
1480
1481       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1482         {
1483           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA
1484               || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1485               || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1486             {
1487               if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1488                 nbits = ask_card_keyattr (keyno, info.key_attr[keyno].nbits);
1489               else
1490                 nbits = ask_card_keyattr (keyno, 25519 /* magic */);
1491
1492               if (nbits && do_change_keyattr (keyno, nbits))
1493                 {
1494                   /* Error: Better read the default key size again.  */
1495                   agent_release_card_info (&info);
1496                   if (get_info_for_key_operation (&info))
1497                     goto leave;
1498                   /* Ask again for this key size. */
1499                   keyno--;
1500                 }
1501             }
1502         }
1503       /* Note that INFO has not be synced.  However we will only use
1504          the serialnumber and thus it won't harm.  */
1505     }
1506
1507   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1508
1509  leave:
1510   agent_release_card_info (&info);
1511   restore_forced_chv1 (&forced_chv1);
1512 }
1513
1514
1515 /* This function is used by the key edit menu to generate an arbitrary
1516    subkey. */
1517 gpg_error_t
1518 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1519 {
1520   gpg_error_t err;
1521   struct agent_card_info_s info;
1522   int forced_chv1 = 0;
1523   int keyno;
1524
1525   err = get_info_for_key_operation (&info);
1526   if (err)
1527     return err;
1528
1529   show_card_key_info (&info);
1530
1531   tty_printf (_("Please select the type of key to generate:\n"));
1532
1533   tty_printf (_("   (1) Signature key\n"));
1534   tty_printf (_("   (2) Encryption key\n"));
1535   tty_printf (_("   (3) Authentication key\n"));
1536
1537   for (;;)
1538     {
1539       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1540                               _("Your selection? "));
1541       cpr_kill_prompt();
1542       if (*answer == CONTROL_D)
1543         {
1544           xfree (answer);
1545           err = gpg_error (GPG_ERR_CANCELED);
1546           goto leave;
1547         }
1548       keyno = *answer? atoi(answer): 0;
1549       xfree(answer);
1550       if (keyno >= 1 && keyno <= 3)
1551         break; /* Okay. */
1552       tty_printf(_("Invalid selection.\n"));
1553     }
1554
1555   if (replace_existing_key_p (&info, keyno) < 0)
1556     {
1557       err = gpg_error (GPG_ERR_CANCELED);
1558       goto leave;
1559     }
1560
1561   err = check_pin_for_key_operation (&info, &forced_chv1);
1562   if (err)
1563     goto leave;
1564
1565   /* If the cards features changeable key attributes, we ask for the
1566      key size.  */
1567   if (info.is_v2 && info.extcap.aac)
1568     {
1569       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA
1570           || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1571           || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1572         {
1573           unsigned int nbits;
1574
1575         ask_again:
1576           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1577             nbits = ask_card_keyattr (keyno-1, info.key_attr[keyno-1].nbits);
1578           else
1579             nbits = ask_card_keyattr (keyno-1, 25519);
1580
1581           if (nbits && do_change_keyattr (keyno-1, nbits))
1582             {
1583               /* Error: Better read the default key size again.  */
1584               agent_release_card_info (&info);
1585               err = get_info_for_key_operation (&info);
1586               if (err)
1587                 goto leave;
1588               goto ask_again;
1589             }
1590         }
1591       /* Note that INFO has not be synced.  However we will only use
1592          the serialnumber and thus it won't harm.  */
1593     }
1594
1595   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1596
1597  leave:
1598   agent_release_card_info (&info);
1599   restore_forced_chv1 (&forced_chv1);
1600   return err;
1601 }
1602
1603
1604 /* Store the key at NODE into the smartcard and modify NODE to
1605    carry the serialno stuff instead of the actual secret key
1606    parameters.  USE is the usage for that key; 0 means any
1607    usage. */
1608 int
1609 card_store_subkey (KBNODE node, int use)
1610 {
1611   struct agent_card_info_s info;
1612   int okay = 0;
1613   unsigned int nbits;
1614   int allow_keyno[3];
1615   int  keyno;
1616   PKT_public_key *pk;
1617   gpg_error_t err;
1618   char *hexgrip;
1619   int rc;
1620   gnupg_isotime_t timebuf;
1621
1622   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1623               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1624
1625   pk = node->pkt->pkt.public_key;
1626
1627   if (get_info_for_key_operation (&info))
1628     return 0;
1629
1630   if (!info.extcap.ki)
1631     {
1632       tty_printf ("The card does not support the import of keys\n");
1633       tty_printf ("\n");
1634       goto leave;
1635     }
1636
1637   nbits = nbits_from_pk (pk);
1638
1639   if (!info.is_v2 && nbits != 1024)
1640     {
1641       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1642       tty_printf ("\n");
1643       goto leave;
1644     }
1645
1646   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1647   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1648   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1649
1650   tty_printf (_("Please select where to store the key:\n"));
1651
1652   if (allow_keyno[0])
1653     tty_printf (_("   (1) Signature key\n"));
1654   if (allow_keyno[1])
1655     tty_printf (_("   (2) Encryption key\n"));
1656   if (allow_keyno[2])
1657     tty_printf (_("   (3) Authentication key\n"));
1658
1659   for (;;)
1660     {
1661       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1662                               _("Your selection? "));
1663       cpr_kill_prompt();
1664       if (*answer == CONTROL_D || !*answer)
1665         {
1666           xfree (answer);
1667           goto leave;
1668         }
1669       keyno = *answer? atoi(answer): 0;
1670       xfree(answer);
1671       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1672         {
1673           if (info.is_v2 && !info.extcap.aac
1674               && info.key_attr[keyno-1].nbits != nbits)
1675             {
1676               tty_printf ("Key does not match the card's capability.\n");
1677             }
1678           else
1679             break; /* Okay. */
1680         }
1681       else
1682         tty_printf(_("Invalid selection.\n"));
1683     }
1684
1685   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1686     goto leave;
1687
1688   err = hexkeygrip_from_pk (pk, &hexgrip);
1689   if (err)
1690     goto leave;
1691
1692   epoch2isotime (timebuf, (time_t)pk->timestamp);
1693   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1694
1695   if (rc)
1696     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1697   else
1698     okay = 1;
1699   xfree (hexgrip);
1700
1701  leave:
1702   agent_release_card_info (&info);
1703   return okay;
1704 }
1705
1706
1707
1708 /* Direct sending of an hex encoded APDU with error printing.  */
1709 static gpg_error_t
1710 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1711 {
1712   gpg_error_t err;
1713   unsigned int sw;
1714
1715   err = agent_scd_apdu (hexapdu, &sw);
1716   if (err)
1717     tty_printf ("sending card command %s failed: %s\n", desc,
1718                 gpg_strerror (err));
1719   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1720     ;
1721   else if (ignore == 0xffff)
1722     ; /* Ignore all status words.  */
1723   else if (sw != 0x9000)
1724     {
1725       switch (sw)
1726         {
1727         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1728         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1729         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1730         default: err = gpg_error (GPG_ERR_CARD);
1731         }
1732       if (!(ignore && ignore == sw))
1733         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1734                     gpg_strerror (err),  sw);
1735     }
1736   return err;
1737 }
1738
1739
1740 /* Do a factory reset after confirmation.  */
1741 static void
1742 factory_reset (void)
1743 {
1744   struct agent_card_info_s info;
1745   gpg_error_t err;
1746   char *answer = NULL;
1747   int termstate = 0;
1748   int i;
1749
1750   /*  The code below basically does the same what this
1751       gpg-connect-agent script does:
1752
1753         scd reset
1754         scd serialno undefined
1755         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1756         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1757         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1758         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1759         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1760         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1761         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1762         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1763         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1764         scd apdu 00 e6 00 00
1765         scd apdu 00 44 00 00
1766         /echo Card has been reset to factory defaults
1767
1768       but tries to find out something about the card first.
1769    */
1770
1771   err = agent_scd_learn (&info, 0);
1772   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1773       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1774     termstate = 1;
1775   else if (err)
1776     {
1777       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1778       return;
1779     }
1780
1781   if (!termstate)
1782     {
1783       log_info (_("OpenPGP card no. %s detected\n"),
1784                 info.serialno? info.serialno : "[none]");
1785       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1786         {
1787           /* Note: We won't see status-indicator 3 here because it is not
1788              possible to select a card application in termination state.  */
1789           log_error (_("This command is not supported by this card\n"));
1790           goto leave;
1791         }
1792
1793       tty_printf ("\n");
1794       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1795       tty_printf ("\n");
1796       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1797                                   _("Continue? (y/N) ")))
1798         goto leave;
1799
1800
1801       answer = cpr_get ("cardedit.factory-reset.really",
1802                         _("Really do a factory reset? (enter \"yes\") "));
1803       cpr_kill_prompt ();
1804       trim_spaces (answer);
1805       if (strcmp (answer, "yes"))
1806         goto leave;
1807
1808       /* We need to select a card application before we can send APDUs
1809          to the card without scdaemon doing anything on its own.  */
1810       err = send_apdu (NULL, "RESET", 0);
1811       if (err)
1812         goto leave;
1813       err = send_apdu ("undefined", "dummy select ", 0);
1814       if (err)
1815         goto leave;
1816
1817       /* Select the OpenPGP application.  */
1818       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1819       if (err)
1820         goto leave;
1821
1822       /* Do some dummy verifies with wrong PINs to set the retry
1823          counter to zero.  We can't easily use the card version 2.1
1824          feature of presenting the admin PIN to allow the terminate
1825          command because there is no machinery in scdaemon to catch
1826          the verify command and ask for the PIN when the "APDU"
1827          command is used. */
1828       for (i=0; i < 4; i++)
1829         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1830       for (i=0; i < 4; i++)
1831         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1832
1833       /* Send terminate datafile command.  */
1834       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1835       if (err)
1836         goto leave;
1837     }
1838
1839   /* Send activate datafile command.  This is used without
1840      confirmation if the card is already in termination state.  */
1841   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1842   if (err)
1843     goto leave;
1844
1845   /* Finally we reset the card reader once more.  */
1846   err = send_apdu (NULL, "RESET", 0);
1847   if (err)
1848     goto leave;
1849
1850  leave:
1851   xfree (answer);
1852   agent_release_card_info (&info);
1853 }
1854
1855
1856 \f
1857 /* Data used by the command parser.  This needs to be outside of the
1858    function scope to allow readline based command completion.  */
1859 enum cmdids
1860   {
1861     cmdNOP = 0,
1862     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1863     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1864     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1865     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1866     cmdINVCMD
1867   };
1868
1869 static struct
1870 {
1871   const char *name;
1872   enum cmdids id;
1873   int admin_only;
1874   const char *desc;
1875 } cmds[] =
1876   {
1877     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1878     { "q"       , cmdQUIT  , 0, NULL },
1879     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1880     { "help"    , cmdHELP  , 0, N_("show this help")},
1881     { "?"       , cmdHELP  , 0, NULL },
1882     { "list"    , cmdLIST  , 0, N_("list all available data")},
1883     { "l"       , cmdLIST  , 0, NULL },
1884     { "debug"   , cmdDEBUG , 0, NULL },
1885     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1886     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1887     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1888     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1889     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1890     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1891     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1892     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1893     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1894     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1895     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1896     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1897     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1898     /* Note, that we do not announce these command yet. */
1899     { "privatedo", cmdPRIVATEDO, 0, NULL },
1900     { "readcert", cmdREADCERT, 0, NULL },
1901     { "writecert", cmdWRITECERT, 1, NULL },
1902     { NULL, cmdINVCMD, 0, NULL }
1903   };
1904
1905
1906 #ifdef HAVE_LIBREADLINE
1907
1908 /* These two functions are used by readline for command completion. */
1909
1910 static char *
1911 command_generator(const char *text,int state)
1912 {
1913   static int list_index,len;
1914   const char *name;
1915
1916   /* If this is a new word to complete, initialize now.  This includes
1917      saving the length of TEXT for efficiency, and initializing the
1918      index variable to 0. */
1919   if(!state)
1920     {
1921       list_index=0;
1922       len=strlen(text);
1923     }
1924
1925   /* Return the next partial match */
1926   while((name=cmds[list_index].name))
1927     {
1928       /* Only complete commands that have help text */
1929       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1930         return strdup(name);
1931     }
1932
1933   return NULL;
1934 }
1935
1936 static char **
1937 card_edit_completion(const char *text, int start, int end)
1938 {
1939   (void)end;
1940   /* If we are at the start of a line, we try and command-complete.
1941      If not, just do nothing for now. */
1942
1943   if(start==0)
1944     return rl_completion_matches(text,command_generator);
1945
1946   rl_attempted_completion_over=1;
1947
1948   return NULL;
1949 }
1950 #endif /*HAVE_LIBREADLINE*/
1951
1952 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1953    Key creation is not handled here. */
1954 void
1955 card_edit (ctrl_t ctrl, strlist_t commands)
1956 {
1957   enum cmdids cmd = cmdNOP;
1958   int have_commands = !!commands;
1959   int redisplay = 1;
1960   char *answer = NULL;
1961   int allow_admin=0;
1962   char serialnobuf[50];
1963
1964
1965   if (opt.command_fd != -1)
1966     ;
1967   else if (opt.batch && !have_commands)
1968     {
1969       log_error(_("can't do this in batch mode\n"));
1970       goto leave;
1971     }
1972
1973   for (;;)
1974     {
1975       int arg_number;
1976       const char *arg_string = "";
1977       const char *arg_rest = "";
1978       char *p;
1979       int i;
1980       int cmd_admin_only;
1981
1982       tty_printf("\n");
1983       if (redisplay)
1984         {
1985           if (opt.with_colons)
1986             {
1987               current_card_status (ctrl, es_stdout,
1988                                    serialnobuf, DIM (serialnobuf));
1989               fflush (stdout);
1990             }
1991           else
1992             {
1993               current_card_status (ctrl, NULL,
1994                                    serialnobuf, DIM (serialnobuf));
1995               tty_printf("\n");
1996             }
1997           redisplay = 0;
1998         }
1999
2000       do
2001         {
2002           xfree (answer);
2003           if (have_commands)
2004             {
2005               if (commands)
2006                 {
2007                   answer = xstrdup (commands->d);
2008                   commands = commands->next;
2009                 }
2010               else if (opt.batch)
2011                 {
2012                   answer = xstrdup ("quit");
2013                 }
2014               else
2015                 have_commands = 0;
2016             }
2017
2018             if (!have_commands)
2019               {
2020                 tty_enable_completion (card_edit_completion);
2021                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2022                 cpr_kill_prompt();
2023                 tty_disable_completion ();
2024               }
2025             trim_spaces(answer);
2026         }
2027       while ( *answer == '#' );
2028
2029       arg_number = 0; /* Yes, here is the init which egcc complains about */
2030       cmd_admin_only = 0;
2031       if (!*answer)
2032         cmd = cmdLIST; /* Default to the list command */
2033       else if (*answer == CONTROL_D)
2034         cmd = cmdQUIT;
2035       else
2036         {
2037           if ((p=strchr (answer,' ')))
2038             {
2039               *p++ = 0;
2040               trim_spaces (answer);
2041               trim_spaces (p);
2042               arg_number = atoi(p);
2043               arg_string = p;
2044               arg_rest = p;
2045               while (digitp (arg_rest))
2046                 arg_rest++;
2047               while (spacep (arg_rest))
2048                 arg_rest++;
2049             }
2050
2051           for (i=0; cmds[i].name; i++ )
2052             if (!ascii_strcasecmp (answer, cmds[i].name ))
2053               break;
2054
2055           cmd = cmds[i].id;
2056           cmd_admin_only = cmds[i].admin_only;
2057         }
2058
2059       if (!allow_admin && cmd_admin_only)
2060         {
2061           tty_printf ("\n");
2062           tty_printf (_("Admin-only command\n"));
2063           continue;
2064         }
2065
2066       switch (cmd)
2067         {
2068         case cmdHELP:
2069           for (i=0; cmds[i].name; i++ )
2070             if(cmds[i].desc
2071                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2072               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2073           break;
2074
2075         case cmdADMIN:
2076           if ( !strcmp (arg_string, "on") )
2077             allow_admin = 1;
2078           else if ( !strcmp (arg_string, "off") )
2079             allow_admin = 0;
2080           else if ( !strcmp (arg_string, "verify") )
2081             {
2082               /* Force verification of the Admin Command.  However,
2083                  this is only done if the retry counter is at initial
2084                  state.  */
2085               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2086               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2087               allow_admin = !agent_scd_checkpin (tmp);
2088               xfree (tmp);
2089             }
2090           else /* Toggle. */
2091             allow_admin=!allow_admin;
2092           if(allow_admin)
2093             tty_printf(_("Admin commands are allowed\n"));
2094           else
2095             tty_printf(_("Admin commands are not allowed\n"));
2096           break;
2097
2098         case cmdVERIFY:
2099           agent_scd_checkpin (serialnobuf);
2100           redisplay = 1;
2101           break;
2102
2103         case cmdLIST:
2104           redisplay = 1;
2105           break;
2106
2107         case cmdNAME:
2108           change_name ();
2109           break;
2110
2111         case cmdURL:
2112           change_url ();
2113           break;
2114
2115         case cmdFETCH:
2116           fetch_url (ctrl);
2117           break;
2118
2119         case cmdLOGIN:
2120           change_login (arg_string);
2121           break;
2122
2123         case cmdLANG:
2124           change_lang ();
2125           break;
2126
2127         case cmdSEX:
2128           change_sex ();
2129           break;
2130
2131         case cmdCAFPR:
2132           if ( arg_number < 1 || arg_number > 3 )
2133             tty_printf ("usage: cafpr N\n"
2134                         "       1 <= N <= 3\n");
2135           else
2136             change_cafpr (arg_number);
2137           break;
2138
2139         case cmdPRIVATEDO:
2140           if ( arg_number < 1 || arg_number > 4 )
2141             tty_printf ("usage: privatedo N\n"
2142                         "       1 <= N <= 4\n");
2143           else
2144             change_private_do (arg_string, arg_number);
2145           break;
2146
2147         case cmdWRITECERT:
2148           if ( arg_number != 3 )
2149             tty_printf ("usage: writecert 3 < FILE\n");
2150           else
2151             change_cert (arg_rest);
2152           break;
2153
2154         case cmdREADCERT:
2155           if ( arg_number != 3 )
2156             tty_printf ("usage: readcert 3 > FILE\n");
2157           else
2158             read_cert (arg_rest);
2159           break;
2160
2161         case cmdFORCESIG:
2162           toggle_forcesig ();
2163           break;
2164
2165         case cmdGENERATE:
2166           generate_card_keys (ctrl);
2167           break;
2168
2169         case cmdPASSWD:
2170           change_pin (0, allow_admin);
2171           break;
2172
2173         case cmdUNBLOCK:
2174           change_pin (1, allow_admin);
2175           break;
2176
2177         case cmdFACTORYRESET:
2178           factory_reset ();
2179           break;
2180
2181         case cmdQUIT:
2182           goto leave;
2183
2184         case cmdNOP:
2185           break;
2186
2187         case cmdINVCMD:
2188         default:
2189           tty_printf ("\n");
2190           tty_printf (_("Invalid command  (try \"help\")\n"));
2191           break;
2192         } /* End command switch. */
2193     } /* End of main menu loop. */
2194
2195  leave:
2196   xfree (answer);
2197 }