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