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