gpg: Fix AEAD encryption for chunk sizes other than 64 KiB.
[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, "Salutation .......: %s\n",
535                    info.disp_sex == 1? _("Mr."):
536                    info.disp_sex == 2? _("Mrs.") : "");
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                   _("Salutation (M = Mr., F = Mrs., 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 salutation: %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               char name[30];
1385
1386               snprintf (name, sizeof name, "rsa%u", req_nbits);
1387               tty_printf (_("The card will now be re-configured"
1388                             " to generate a key of type: %s\n"),
1389                           name);
1390               show_keysize_warning ();
1391               return req_nbits;
1392             }
1393         }
1394     }
1395 }
1396
1397
1398 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1399  * message if that fails.  Using the magic value 25519 for NBITS
1400  * switches to ed25519 or cv25519 depending on the KEYNO.  */
1401 static gpg_error_t
1402 do_change_keyattr (int keyno, unsigned int nbits)
1403 {
1404   gpg_error_t err;
1405   char args[100];
1406
1407   if (nbits == 25519)
1408     snprintf (args, sizeof args, "--force %d %d %s",
1409               keyno+1,
1410               keyno == 1? PUBKEY_ALGO_ECDH : PUBKEY_ALGO_EDDSA,
1411               keyno == 1? "cv25519" : "ed25519");
1412   else
1413     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1414   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1415   if (err)
1416     log_error (_("error changing size of key %d to %u bits: %s\n"),
1417                keyno+1, nbits, gpg_strerror (err));
1418   return err;
1419 }
1420
1421
1422 static void
1423 generate_card_keys (ctrl_t ctrl)
1424 {
1425   struct agent_card_info_s info;
1426   int forced_chv1;
1427   int want_backup;
1428   int keyno;
1429
1430   if (get_info_for_key_operation (&info))
1431     return;
1432
1433   if (info.extcap.ki)
1434     {
1435       char *answer;
1436
1437       /* FIXME: Should be something like cpr_get_bool so that a status
1438          GET_BOOL will be emitted.  */
1439       answer = cpr_get ("cardedit.genkeys.backup_enc",
1440                         _("Make off-card backup of encryption key? (Y/n) "));
1441
1442       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1443       cpr_kill_prompt ();
1444       xfree (answer);
1445     }
1446   else
1447     want_backup = 0;
1448
1449   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1450        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1451        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1452     {
1453       tty_printf ("\n");
1454       log_info (_("Note: keys are already stored on the card!\n"));
1455       tty_printf ("\n");
1456       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1457                                    _("Replace existing keys? (y/N) ")))
1458         {
1459           agent_release_card_info (&info);
1460           return;
1461         }
1462     }
1463
1464   /* If no displayed name has been set, we assume that this is a fresh
1465      card and print a hint about the default PINs.  */
1466   if (!info.disp_name || !*info.disp_name)
1467     {
1468       tty_printf ("\n");
1469       tty_printf (_("Please note that the factory settings of the PINs are\n"
1470                     "   PIN = '%s'     Admin PIN = '%s'\n"
1471                     "You should change them using the command --change-pin\n"),
1472                   "123456", "12345678");
1473       tty_printf ("\n");
1474     }
1475
1476   if (check_pin_for_key_operation (&info, &forced_chv1))
1477     goto leave;
1478
1479   /* If the cards features changeable key attributes, we ask for the
1480      key size.  */
1481   if (info.is_v2 && info.extcap.aac)
1482     {
1483       unsigned int nbits;
1484
1485       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1486         {
1487           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA
1488               || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1489               || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1490             {
1491               if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1492                 nbits = ask_card_keyattr (keyno, info.key_attr[keyno].nbits);
1493               else
1494                 nbits = ask_card_keyattr (keyno, 25519 /* magic */);
1495
1496               if (nbits && do_change_keyattr (keyno, nbits))
1497                 {
1498                   /* Error: Better read the default key size again.  */
1499                   agent_release_card_info (&info);
1500                   if (get_info_for_key_operation (&info))
1501                     goto leave;
1502                   /* Ask again for this key size. */
1503                   keyno--;
1504                 }
1505             }
1506         }
1507       /* Note that INFO has not be synced.  However we will only use
1508          the serialnumber and thus it won't harm.  */
1509     }
1510
1511   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1512
1513  leave:
1514   agent_release_card_info (&info);
1515   restore_forced_chv1 (&forced_chv1);
1516 }
1517
1518
1519 /* This function is used by the key edit menu to generate an arbitrary
1520    subkey. */
1521 gpg_error_t
1522 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1523 {
1524   gpg_error_t err;
1525   struct agent_card_info_s info;
1526   int forced_chv1 = 0;
1527   int keyno;
1528
1529   err = get_info_for_key_operation (&info);
1530   if (err)
1531     return err;
1532
1533   show_card_key_info (&info);
1534
1535   tty_printf (_("Please select the type of key to generate:\n"));
1536
1537   tty_printf (_("   (1) Signature key\n"));
1538   tty_printf (_("   (2) Encryption key\n"));
1539   tty_printf (_("   (3) Authentication key\n"));
1540
1541   for (;;)
1542     {
1543       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1544                               _("Your selection? "));
1545       cpr_kill_prompt();
1546       if (*answer == CONTROL_D)
1547         {
1548           xfree (answer);
1549           err = gpg_error (GPG_ERR_CANCELED);
1550           goto leave;
1551         }
1552       keyno = *answer? atoi(answer): 0;
1553       xfree(answer);
1554       if (keyno >= 1 && keyno <= 3)
1555         break; /* Okay. */
1556       tty_printf(_("Invalid selection.\n"));
1557     }
1558
1559   if (replace_existing_key_p (&info, keyno) < 0)
1560     {
1561       err = gpg_error (GPG_ERR_CANCELED);
1562       goto leave;
1563     }
1564
1565   err = check_pin_for_key_operation (&info, &forced_chv1);
1566   if (err)
1567     goto leave;
1568
1569   /* If the cards features changeable key attributes, we ask for the
1570      key size.  */
1571   if (info.is_v2 && info.extcap.aac)
1572     {
1573       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA
1574           || info.key_attr[keyno].algo == PUBKEY_ALGO_ECDH
1575           || info.key_attr[keyno].algo == PUBKEY_ALGO_EDDSA)
1576         {
1577           unsigned int nbits;
1578
1579         ask_again:
1580           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1581             nbits = ask_card_keyattr (keyno-1, info.key_attr[keyno-1].nbits);
1582           else
1583             nbits = ask_card_keyattr (keyno-1, 25519);
1584
1585           if (nbits && do_change_keyattr (keyno-1, nbits))
1586             {
1587               /* Error: Better read the default key size again.  */
1588               agent_release_card_info (&info);
1589               err = get_info_for_key_operation (&info);
1590               if (err)
1591                 goto leave;
1592               goto ask_again;
1593             }
1594         }
1595       /* Note that INFO has not be synced.  However we will only use
1596          the serialnumber and thus it won't harm.  */
1597     }
1598
1599   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1600
1601  leave:
1602   agent_release_card_info (&info);
1603   restore_forced_chv1 (&forced_chv1);
1604   return err;
1605 }
1606
1607
1608 /* Store the key at NODE into the smartcard and modify NODE to
1609    carry the serialno stuff instead of the actual secret key
1610    parameters.  USE is the usage for that key; 0 means any
1611    usage. */
1612 int
1613 card_store_subkey (KBNODE node, int use)
1614 {
1615   struct agent_card_info_s info;
1616   int okay = 0;
1617   unsigned int nbits;
1618   int allow_keyno[3];
1619   int  keyno;
1620   PKT_public_key *pk;
1621   gpg_error_t err;
1622   char *hexgrip;
1623   int rc;
1624   gnupg_isotime_t timebuf;
1625
1626   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1627               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1628
1629   pk = node->pkt->pkt.public_key;
1630
1631   if (get_info_for_key_operation (&info))
1632     return 0;
1633
1634   if (!info.extcap.ki)
1635     {
1636       tty_printf ("The card does not support the import of keys\n");
1637       tty_printf ("\n");
1638       goto leave;
1639     }
1640
1641   nbits = nbits_from_pk (pk);
1642
1643   if (!info.is_v2 && nbits != 1024)
1644     {
1645       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1646       tty_printf ("\n");
1647       goto leave;
1648     }
1649
1650   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1651   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1652   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1653
1654   tty_printf (_("Please select where to store the key:\n"));
1655
1656   if (allow_keyno[0])
1657     tty_printf (_("   (1) Signature key\n"));
1658   if (allow_keyno[1])
1659     tty_printf (_("   (2) Encryption key\n"));
1660   if (allow_keyno[2])
1661     tty_printf (_("   (3) Authentication key\n"));
1662
1663   for (;;)
1664     {
1665       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1666                               _("Your selection? "));
1667       cpr_kill_prompt();
1668       if (*answer == CONTROL_D || !*answer)
1669         {
1670           xfree (answer);
1671           goto leave;
1672         }
1673       keyno = *answer? atoi(answer): 0;
1674       xfree(answer);
1675       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1676         {
1677           if (info.is_v2 && !info.extcap.aac
1678               && info.key_attr[keyno-1].nbits != nbits)
1679             {
1680               tty_printf ("Key does not match the card's capability.\n");
1681             }
1682           else
1683             break; /* Okay. */
1684         }
1685       else
1686         tty_printf(_("Invalid selection.\n"));
1687     }
1688
1689   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1690     goto leave;
1691
1692   err = hexkeygrip_from_pk (pk, &hexgrip);
1693   if (err)
1694     goto leave;
1695
1696   epoch2isotime (timebuf, (time_t)pk->timestamp);
1697   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1698
1699   if (rc)
1700     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1701   else
1702     okay = 1;
1703   xfree (hexgrip);
1704
1705  leave:
1706   agent_release_card_info (&info);
1707   return okay;
1708 }
1709
1710
1711
1712 /* Direct sending of an hex encoded APDU with error printing.  */
1713 static gpg_error_t
1714 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1715 {
1716   gpg_error_t err;
1717   unsigned int sw;
1718
1719   err = agent_scd_apdu (hexapdu, &sw);
1720   if (err)
1721     tty_printf ("sending card command %s failed: %s\n", desc,
1722                 gpg_strerror (err));
1723   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1724     ;
1725   else if (ignore == 0xffff)
1726     ; /* Ignore all status words.  */
1727   else if (sw != 0x9000)
1728     {
1729       switch (sw)
1730         {
1731         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1732         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1733         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1734         default: err = gpg_error (GPG_ERR_CARD);
1735         }
1736       if (!(ignore && ignore == sw))
1737         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1738                     gpg_strerror (err),  sw);
1739     }
1740   return err;
1741 }
1742
1743
1744 /* Do a factory reset after confirmation.  */
1745 static void
1746 factory_reset (void)
1747 {
1748   struct agent_card_info_s info;
1749   gpg_error_t err;
1750   char *answer = NULL;
1751   int termstate = 0;
1752   int i;
1753
1754   /*  The code below basically does the same what this
1755       gpg-connect-agent script does:
1756
1757         scd reset
1758         scd serialno undefined
1759         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1760         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1761         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1762         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1763         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1764         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1765         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1766         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1767         scd apdu 00 20 00 83 08 40 40 40 40 40 40 40 40
1768         scd apdu 00 e6 00 00
1769         scd apdu 00 44 00 00
1770         /echo Card has been reset to factory defaults
1771
1772       but tries to find out something about the card first.
1773    */
1774
1775   err = agent_scd_learn (&info, 0);
1776   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1777       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1778     termstate = 1;
1779   else if (err)
1780     {
1781       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1782       return;
1783     }
1784
1785   if (!termstate)
1786     {
1787       log_info (_("OpenPGP card no. %s detected\n"),
1788                 info.serialno? info.serialno : "[none]");
1789       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1790         {
1791           /* Note: We won't see status-indicator 3 here because it is not
1792              possible to select a card application in termination state.  */
1793           log_error (_("This command is not supported by this card\n"));
1794           goto leave;
1795         }
1796
1797       tty_printf ("\n");
1798       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1799       tty_printf ("\n");
1800       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1801                                   _("Continue? (y/N) ")))
1802         goto leave;
1803
1804
1805       answer = cpr_get ("cardedit.factory-reset.really",
1806                         _("Really do a factory reset? (enter \"yes\") "));
1807       cpr_kill_prompt ();
1808       trim_spaces (answer);
1809       if (strcmp (answer, "yes"))
1810         goto leave;
1811
1812       /* We need to select a card application before we can send APDUs
1813          to the card without scdaemon doing anything on its own.  */
1814       err = send_apdu (NULL, "RESET", 0);
1815       if (err)
1816         goto leave;
1817       err = send_apdu ("undefined", "dummy select ", 0);
1818       if (err)
1819         goto leave;
1820
1821       /* Select the OpenPGP application.  */
1822       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1823       if (err)
1824         goto leave;
1825
1826       /* Do some dummy verifies with wrong PINs to set the retry
1827          counter to zero.  We can't easily use the card version 2.1
1828          feature of presenting the admin PIN to allow the terminate
1829          command because there is no machinery in scdaemon to catch
1830          the verify command and ask for the PIN when the "APDU"
1831          command is used. */
1832       for (i=0; i < 4; i++)
1833         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1834       for (i=0; i < 4; i++)
1835         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1836
1837       /* Send terminate datafile command.  */
1838       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1839       if (err)
1840         goto leave;
1841     }
1842
1843   /* Send activate datafile command.  This is used without
1844      confirmation if the card is already in termination state.  */
1845   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1846   if (err)
1847     goto leave;
1848
1849   /* Finally we reset the card reader once more.  */
1850   err = send_apdu (NULL, "RESET", 0);
1851   if (err)
1852     goto leave;
1853
1854  leave:
1855   xfree (answer);
1856   agent_release_card_info (&info);
1857 }
1858
1859
1860 \f
1861 /* Data used by the command parser.  This needs to be outside of the
1862    function scope to allow readline based command completion.  */
1863 enum cmdids
1864   {
1865     cmdNOP = 0,
1866     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1867     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1868     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1869     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1870     cmdINVCMD
1871   };
1872
1873 static struct
1874 {
1875   const char *name;
1876   enum cmdids id;
1877   int admin_only;
1878   const char *desc;
1879 } cmds[] =
1880   {
1881     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1882     { "q"       , cmdQUIT  , 0, NULL },
1883     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1884     { "help"    , cmdHELP  , 0, N_("show this help")},
1885     { "?"       , cmdHELP  , 0, NULL },
1886     { "list"    , cmdLIST  , 0, N_("list all available data")},
1887     { "l"       , cmdLIST  , 0, NULL },
1888     { "debug"   , cmdDEBUG , 0, NULL },
1889     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1890     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1891     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1892     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1893     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1894     { "salutation",cmdSEX  , 1, N_("change card holder's salutation")},
1895     { "sex"       ,cmdSEX  , 1, NULL },  /* Backward compatibility.  */
1896     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1897     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1898     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1899     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1900     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1901     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1902     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1903     /* Note, that we do not announce these command yet. */
1904     { "privatedo", cmdPRIVATEDO, 0, NULL },
1905     { "readcert", cmdREADCERT, 0, NULL },
1906     { "writecert", cmdWRITECERT, 1, NULL },
1907     { NULL, cmdINVCMD, 0, NULL }
1908   };
1909
1910
1911 #ifdef HAVE_LIBREADLINE
1912
1913 /* These two functions are used by readline for command completion. */
1914
1915 static char *
1916 command_generator(const char *text,int state)
1917 {
1918   static int list_index,len;
1919   const char *name;
1920
1921   /* If this is a new word to complete, initialize now.  This includes
1922      saving the length of TEXT for efficiency, and initializing the
1923      index variable to 0. */
1924   if(!state)
1925     {
1926       list_index=0;
1927       len=strlen(text);
1928     }
1929
1930   /* Return the next partial match */
1931   while((name=cmds[list_index].name))
1932     {
1933       /* Only complete commands that have help text */
1934       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1935         return strdup(name);
1936     }
1937
1938   return NULL;
1939 }
1940
1941 static char **
1942 card_edit_completion(const char *text, int start, int end)
1943 {
1944   (void)end;
1945   /* If we are at the start of a line, we try and command-complete.
1946      If not, just do nothing for now. */
1947
1948   if(start==0)
1949     return rl_completion_matches(text,command_generator);
1950
1951   rl_attempted_completion_over=1;
1952
1953   return NULL;
1954 }
1955 #endif /*HAVE_LIBREADLINE*/
1956
1957 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1958    Key creation is not handled here. */
1959 void
1960 card_edit (ctrl_t ctrl, strlist_t commands)
1961 {
1962   enum cmdids cmd = cmdNOP;
1963   int have_commands = !!commands;
1964   int redisplay = 1;
1965   char *answer = NULL;
1966   int allow_admin=0;
1967   char serialnobuf[50];
1968
1969
1970   if (opt.command_fd != -1)
1971     ;
1972   else if (opt.batch && !have_commands)
1973     {
1974       log_error(_("can't do this in batch mode\n"));
1975       goto leave;
1976     }
1977
1978   for (;;)
1979     {
1980       int arg_number;
1981       const char *arg_string = "";
1982       const char *arg_rest = "";
1983       char *p;
1984       int i;
1985       int cmd_admin_only;
1986
1987       tty_printf("\n");
1988       if (redisplay)
1989         {
1990           if (opt.with_colons)
1991             {
1992               current_card_status (ctrl, es_stdout,
1993                                    serialnobuf, DIM (serialnobuf));
1994               fflush (stdout);
1995             }
1996           else
1997             {
1998               current_card_status (ctrl, NULL,
1999                                    serialnobuf, DIM (serialnobuf));
2000               tty_printf("\n");
2001             }
2002           redisplay = 0;
2003         }
2004
2005       do
2006         {
2007           xfree (answer);
2008           if (have_commands)
2009             {
2010               if (commands)
2011                 {
2012                   answer = xstrdup (commands->d);
2013                   commands = commands->next;
2014                 }
2015               else if (opt.batch)
2016                 {
2017                   answer = xstrdup ("quit");
2018                 }
2019               else
2020                 have_commands = 0;
2021             }
2022
2023             if (!have_commands)
2024               {
2025                 tty_enable_completion (card_edit_completion);
2026                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2027                 cpr_kill_prompt();
2028                 tty_disable_completion ();
2029               }
2030             trim_spaces(answer);
2031         }
2032       while ( *answer == '#' );
2033
2034       arg_number = 0; /* Yes, here is the init which egcc complains about */
2035       cmd_admin_only = 0;
2036       if (!*answer)
2037         cmd = cmdLIST; /* Default to the list command */
2038       else if (*answer == CONTROL_D)
2039         cmd = cmdQUIT;
2040       else
2041         {
2042           if ((p=strchr (answer,' ')))
2043             {
2044               *p++ = 0;
2045               trim_spaces (answer);
2046               trim_spaces (p);
2047               arg_number = atoi(p);
2048               arg_string = p;
2049               arg_rest = p;
2050               while (digitp (arg_rest))
2051                 arg_rest++;
2052               while (spacep (arg_rest))
2053                 arg_rest++;
2054             }
2055
2056           for (i=0; cmds[i].name; i++ )
2057             if (!ascii_strcasecmp (answer, cmds[i].name ))
2058               break;
2059
2060           cmd = cmds[i].id;
2061           cmd_admin_only = cmds[i].admin_only;
2062         }
2063
2064       if (!allow_admin && cmd_admin_only)
2065         {
2066           tty_printf ("\n");
2067           tty_printf (_("Admin-only command\n"));
2068           continue;
2069         }
2070
2071       switch (cmd)
2072         {
2073         case cmdHELP:
2074           for (i=0; cmds[i].name; i++ )
2075             if(cmds[i].desc
2076                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2077               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2078           break;
2079
2080         case cmdADMIN:
2081           if ( !strcmp (arg_string, "on") )
2082             allow_admin = 1;
2083           else if ( !strcmp (arg_string, "off") )
2084             allow_admin = 0;
2085           else if ( !strcmp (arg_string, "verify") )
2086             {
2087               /* Force verification of the Admin Command.  However,
2088                  this is only done if the retry counter is at initial
2089                  state.  */
2090               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2091               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2092               allow_admin = !agent_scd_checkpin (tmp);
2093               xfree (tmp);
2094             }
2095           else /* Toggle. */
2096             allow_admin=!allow_admin;
2097           if(allow_admin)
2098             tty_printf(_("Admin commands are allowed\n"));
2099           else
2100             tty_printf(_("Admin commands are not allowed\n"));
2101           break;
2102
2103         case cmdVERIFY:
2104           agent_scd_checkpin (serialnobuf);
2105           redisplay = 1;
2106           break;
2107
2108         case cmdLIST:
2109           redisplay = 1;
2110           break;
2111
2112         case cmdNAME:
2113           change_name ();
2114           break;
2115
2116         case cmdURL:
2117           change_url ();
2118           break;
2119
2120         case cmdFETCH:
2121           fetch_url (ctrl);
2122           break;
2123
2124         case cmdLOGIN:
2125           change_login (arg_string);
2126           break;
2127
2128         case cmdLANG:
2129           change_lang ();
2130           break;
2131
2132         case cmdSEX:
2133           change_sex ();
2134           break;
2135
2136         case cmdCAFPR:
2137           if ( arg_number < 1 || arg_number > 3 )
2138             tty_printf ("usage: cafpr N\n"
2139                         "       1 <= N <= 3\n");
2140           else
2141             change_cafpr (arg_number);
2142           break;
2143
2144         case cmdPRIVATEDO:
2145           if ( arg_number < 1 || arg_number > 4 )
2146             tty_printf ("usage: privatedo N\n"
2147                         "       1 <= N <= 4\n");
2148           else
2149             change_private_do (arg_string, arg_number);
2150           break;
2151
2152         case cmdWRITECERT:
2153           if ( arg_number != 3 )
2154             tty_printf ("usage: writecert 3 < FILE\n");
2155           else
2156             change_cert (arg_rest);
2157           break;
2158
2159         case cmdREADCERT:
2160           if ( arg_number != 3 )
2161             tty_printf ("usage: readcert 3 > FILE\n");
2162           else
2163             read_cert (arg_rest);
2164           break;
2165
2166         case cmdFORCESIG:
2167           toggle_forcesig ();
2168           break;
2169
2170         case cmdGENERATE:
2171           generate_card_keys (ctrl);
2172           break;
2173
2174         case cmdPASSWD:
2175           change_pin (0, allow_admin);
2176           break;
2177
2178         case cmdUNBLOCK:
2179           change_pin (1, allow_admin);
2180           break;
2181
2182         case cmdFACTORYRESET:
2183           factory_reset ();
2184           break;
2185
2186         case cmdQUIT:
2187           goto leave;
2188
2189         case cmdNOP:
2190           break;
2191
2192         case cmdINVCMD:
2193         default:
2194           tty_printf ("\n");
2195           tty_printf (_("Invalid command  (try \"help\")\n"));
2196           break;
2197         } /* End command switch. */
2198     } /* End of main menu loop. */
2199
2200  leave:
2201   xfree (answer);
2202 }