g10: Let card-edit/key-attr show message when change.
[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,    "Sex ..............: %s\n",
556                    info.disp_sex == 1? _("male"):
557                    info.disp_sex == 2? _("female") : _("unspecified"));
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                   _("Sex ((M)ale, (F)emale 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 sex: %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[20];
1156
1157   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1158   if (!data)
1159     return -1;
1160   trim_spaces (data);
1161   cpr_kill_prompt ();
1162
1163   for (i=0, s=data; i < 20 && *s; )
1164     {
1165       while (spacep(s))
1166         s++;
1167       if (*s == ':')
1168         s++;
1169       while (spacep(s))
1170         s++;
1171       c = hextobyte (s);
1172       if (c == -1)
1173         break;
1174       fpr[i++] = c;
1175       s += 2;
1176     }
1177   xfree (data);
1178   if (i != 20 || *s)
1179     {
1180       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1181       return -1;
1182     }
1183
1184   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1185                           fprno==2?"CA-FPR-2":
1186                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1187   if (rc)
1188     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1189   write_sc_op_status (rc);
1190   return rc;
1191 }
1192
1193
1194
1195 static void
1196 toggle_forcesig (void)
1197 {
1198   struct agent_card_info_s info;
1199   int rc;
1200   int newstate;
1201
1202   memset (&info, 0, sizeof info);
1203   rc = agent_scd_getattr ("CHV-STATUS", &info);
1204   if (rc)
1205     {
1206       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1207       return;
1208     }
1209   newstate = !info.chv1_cached;
1210   agent_release_card_info (&info);
1211
1212   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1213   if (rc)
1214     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1215   write_sc_op_status (rc);
1216 }
1217
1218
1219 /* Helper for the key generation/edit functions.  */
1220 static int
1221 get_info_for_key_operation (struct agent_card_info_s *info)
1222 {
1223   int rc;
1224
1225   memset (info, 0, sizeof *info);
1226   rc = agent_scd_getattr ("SERIALNO", info);
1227   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1228       || strlen (info->serialno) != 32 )
1229     {
1230       log_error (_("key operation not possible: %s\n"),
1231                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1232       return rc? rc: -1;
1233     }
1234   rc = agent_scd_getattr ("KEY-FPR", info);
1235   if (!rc)
1236     rc = agent_scd_getattr ("CHV-STATUS", info);
1237   if (!rc)
1238     rc = agent_scd_getattr ("DISP-NAME", info);
1239   if (!rc)
1240     rc = agent_scd_getattr ("EXTCAP", info);
1241   if (!rc)
1242     rc = agent_scd_getattr ("KEY-ATTR", info);
1243   if (rc)
1244     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1245   return rc;
1246 }
1247
1248
1249 /* Helper for the key generation/edit functions.  */
1250 static int
1251 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1252 {
1253   int rc = 0;
1254
1255   agent_clear_pin_cache (info->serialno);
1256
1257   *forced_chv1 = !info->chv1_cached;
1258   if (*forced_chv1)
1259     { /* Switch off the forced mode so that during key generation we
1260          don't get bothered with PIN queries for each
1261          self-signature. */
1262       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1263       if (rc)
1264         {
1265           log_error ("error clearing forced signature PIN flag: %s\n",
1266                      gpg_strerror (rc));
1267           *forced_chv1 = 0;
1268         }
1269     }
1270
1271   if (!rc)
1272     {
1273       /* Check the PIN now, so that we won't get asked later for each
1274          binding signature. */
1275       rc = agent_scd_checkpin (info->serialno);
1276       if (rc)
1277         {
1278           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1279           write_sc_op_status (rc);
1280         }
1281   }
1282   return rc;
1283 }
1284
1285 /* Helper for the key generation/edit functions.  */
1286 static void
1287 restore_forced_chv1 (int *forced_chv1)
1288 {
1289   int rc;
1290
1291   if (*forced_chv1)
1292     { /* Switch back to forced state. */
1293       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1294       if (rc)
1295         {
1296           log_error ("error setting forced signature PIN flag: %s\n",
1297                      gpg_strerror (rc));
1298         }
1299     }
1300 }
1301
1302
1303 /* Helper for the key generation/edit functions.  */
1304 static void
1305 show_card_key_info (struct agent_card_info_s *info)
1306 {
1307   tty_fprintf (NULL, "Signature key ....:");
1308   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1309   tty_fprintf (NULL, "Encryption key....:");
1310   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1311   tty_fprintf (NULL, "Authentication key:");
1312   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1313   tty_printf ("\n");
1314 }
1315
1316
1317 /* Helper for the key generation/edit functions.  */
1318 static int
1319 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1320 {
1321   log_assert (keyno >= 0 && keyno <= 3);
1322
1323   if ((keyno == 1 && info->fpr1valid)
1324       || (keyno == 2 && info->fpr2valid)
1325       || (keyno == 3 && info->fpr3valid))
1326     {
1327       tty_printf ("\n");
1328       log_info ("WARNING: such a key has already been stored on the card!\n");
1329       tty_printf ("\n");
1330       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1331                                   _("Replace existing key? (y/N) ")))
1332         return -1;
1333       return 1;
1334     }
1335   return 0;
1336 }
1337
1338
1339 static void
1340 show_keysize_warning (void)
1341 {
1342   static int shown;
1343
1344   if (shown)
1345     return;
1346   shown = 1;
1347   tty_printf
1348     (_("Note: There is no guarantee that the card "
1349        "supports the requested size.\n"
1350        "      If the key generation does not succeed, "
1351        "please check the\n"
1352        "      documentation of your card to see what "
1353        "sizes are allowed.\n"));
1354 }
1355
1356
1357 /* Ask for the size of a card key.  NBITS is the current size
1358    configured for the card.  Returns 0 to use the default size
1359    (i.e. NBITS) or the selected size.  */
1360 static unsigned int
1361 ask_card_rsa_keysize (unsigned int nbits)
1362 {
1363   unsigned int min_nbits = 1024;
1364   unsigned int max_nbits = 4096;
1365   char *prompt, *answer;
1366   unsigned int req_nbits;
1367
1368   for (;;)
1369     {
1370       prompt = xasprintf (_("What keysize do you want? (%u) "), nbits);
1371       answer = cpr_get ("cardedit.genkeys.size", prompt);
1372       cpr_kill_prompt ();
1373       req_nbits = *answer? atoi (answer): nbits;
1374       xfree (prompt);
1375       xfree (answer);
1376
1377       if (req_nbits != nbits && (req_nbits % 32) )
1378         {
1379           req_nbits = ((req_nbits + 31) / 32) * 32;
1380           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1381         }
1382
1383       if (req_nbits == nbits)
1384         return 0;  /* Use default.  */
1385
1386       if (req_nbits < min_nbits || req_nbits > max_nbits)
1387         {
1388           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1389                       "RSA", min_nbits, max_nbits);
1390         }
1391       else
1392         return req_nbits;
1393     }
1394 }
1395
1396 /* Ask for the key attribute of a card key.  CURRENT is the current
1397    attribute configured for the card.  KEYNO is the number of the key
1398    used to select the prompt.  Returns NULL to use the default
1399    attribute or the selected attribute structure.  */
1400 static struct key_attr *
1401 ask_card_keyattr (int keyno, const struct key_attr *current)
1402 {
1403   struct key_attr *key_attr = NULL;
1404   char *answer = NULL;
1405   int algo;
1406
1407   tty_printf (_("Changing card key attribute for: "));
1408   if (keyno == 0)
1409     tty_printf (_("Signature key\n"));
1410   else if (keyno == 1)
1411     tty_printf (_("Encryption key\n"));
1412   else
1413     tty_printf (_("Authentication key\n"));
1414
1415   tty_printf (_("Please select what kind of key you want:\n"));
1416   tty_printf (_("   (%d) RSA\n"), 1 );
1417   tty_printf (_("   (%d) ECC\n"), 2 );
1418
1419   for (;;)
1420     {
1421       xfree (answer);
1422       answer = cpr_get ("cardedit.genkeys.algo", _("Your selection? "));
1423       cpr_kill_prompt ();
1424       algo = *answer? atoi (answer) : 0;
1425
1426       if (!*answer || algo == 1 || algo == 2)
1427         break;
1428       else
1429         tty_printf (_("Invalid selection.\n"));
1430     }
1431
1432   if (algo == 0)
1433     goto leave;
1434
1435   key_attr = xmalloc (sizeof (struct key_attr));
1436
1437   if (algo == 1)
1438     {
1439       unsigned int nbits, result_nbits;
1440
1441       if (current->algo == PUBKEY_ALGO_RSA)
1442         nbits = current->nbits;
1443       else
1444         nbits = 2048;
1445
1446       result_nbits = ask_card_rsa_keysize (nbits);
1447       if (result_nbits == 0)
1448         {
1449           if (current->algo == PUBKEY_ALGO_RSA)
1450             {
1451               xfree (key_attr);
1452               key_attr = NULL;
1453             }
1454           else
1455             result_nbits = nbits;
1456         }
1457
1458       if (key_attr)
1459         {
1460           key_attr->algo = PUBKEY_ALGO_RSA;
1461           key_attr->nbits = result_nbits;
1462         }
1463     }
1464   else
1465     {
1466       const char *curve;
1467       const char *oid_str;
1468
1469       if (current->algo == PUBKEY_ALGO_RSA)
1470         {
1471           if (keyno == 1)
1472             /* Encryption key */
1473             algo = PUBKEY_ALGO_ECDH;
1474           else /* Signature key or Authentication key */
1475             algo = PUBKEY_ALGO_ECDSA;
1476           curve = NULL;
1477         }
1478       else
1479         {
1480           algo = current->algo;
1481           curve = current->curve;
1482         }
1483
1484       curve = ask_curve (&algo, NULL, curve);
1485       if (curve)
1486         {
1487           key_attr->algo = algo;
1488           oid_str = openpgp_curve_to_oid (curve, NULL);
1489           key_attr->curve = openpgp_oid_to_curve (oid_str, 0);
1490         }
1491       else
1492         {
1493           xfree (key_attr);
1494           key_attr = NULL;
1495         }
1496     }
1497
1498  leave:
1499   if (key_attr)
1500     {
1501       if (key_attr->algo == PUBKEY_ALGO_RSA)
1502         tty_printf (_("The card will now be re-configured"
1503                       " to generate a key of %u bits\n"), key_attr->nbits);
1504       else if (key_attr->algo == PUBKEY_ALGO_ECDH
1505                || key_attr->algo == PUBKEY_ALGO_ECDSA
1506                || key_attr->algo == PUBKEY_ALGO_EDDSA)
1507         tty_printf (_("The card will now be re-configured"
1508                       " to generate a key of type: %s\n"), key_attr->curve),
1509
1510       show_keysize_warning ();
1511     }
1512
1513   return key_attr;
1514 }
1515
1516
1517
1518 /* Change the key attribute of key KEYNO (0..2) and show an error
1519  * message if that fails.  */
1520 static gpg_error_t
1521 do_change_keyattr (int keyno, const struct key_attr *key_attr)
1522 {
1523   gpg_error_t err = 0;
1524   char args[100];
1525
1526   if (key_attr->algo == PUBKEY_ALGO_RSA)
1527     snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1,
1528               key_attr->nbits);
1529   else if (key_attr->algo == PUBKEY_ALGO_ECDH
1530            || key_attr->algo == PUBKEY_ALGO_ECDSA
1531            || key_attr->algo == PUBKEY_ALGO_EDDSA)
1532     snprintf (args, sizeof args, "--force %d %d %s",
1533               keyno+1, key_attr->algo, key_attr->curve);
1534   else
1535     {
1536       log_error (_("public key algorithm %d (%s) is not supported\n"),
1537                  key_attr->algo, gcry_pk_algo_name (key_attr->algo));
1538       return gpg_error (GPG_ERR_PUBKEY_ALGO);
1539     }
1540
1541   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1542   if (err)
1543     log_error (_("error changing key attribute for key %d: %s\n"),
1544                keyno+1, gpg_strerror (err));
1545   return err;
1546 }
1547
1548
1549 static void
1550 key_attr (void)
1551 {
1552   struct agent_card_info_s info;
1553   gpg_error_t err;
1554   int keyno;
1555
1556   err = get_info_for_key_operation (&info);
1557   if (err)
1558     {
1559       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
1560       return;
1561     }
1562
1563   if (!(info.is_v2 && info.extcap.aac))
1564     {
1565       log_error (_("This command is not supported by this card\n"));
1566       goto leave;
1567     }
1568
1569   for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1570     {
1571       struct key_attr *key_attr;
1572
1573       if ((key_attr = ask_card_keyattr (keyno, &info.key_attr[keyno])))
1574         {
1575           err = do_change_keyattr (keyno, key_attr);
1576           xfree (key_attr);
1577           if (err)
1578             {
1579               /* Error: Better read the default key attribute again.  */
1580               agent_release_card_info (&info);
1581               if (get_info_for_key_operation (&info))
1582                 goto leave;
1583               /* Ask again for this key. */
1584               keyno--;
1585             }
1586         }
1587     }
1588
1589  leave:
1590   agent_release_card_info (&info);
1591 }
1592
1593
1594 static void
1595 generate_card_keys (ctrl_t ctrl)
1596 {
1597   struct agent_card_info_s info;
1598   int forced_chv1;
1599   int want_backup;
1600
1601   if (get_info_for_key_operation (&info))
1602     return;
1603
1604   if (info.extcap.ki)
1605     {
1606       char *answer;
1607
1608       /* FIXME: Should be something like cpr_get_bool so that a status
1609          GET_BOOL will be emitted.  */
1610       answer = cpr_get ("cardedit.genkeys.backup_enc",
1611                         _("Make off-card backup of encryption key? (Y/n) "));
1612
1613       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1614       cpr_kill_prompt ();
1615       xfree (answer);
1616     }
1617   else
1618     want_backup = 0;
1619
1620   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1621        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1622        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1623     {
1624       tty_printf ("\n");
1625       log_info (_("Note: keys are already stored on the card!\n"));
1626       tty_printf ("\n");
1627       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1628                                    _("Replace existing keys? (y/N) ")))
1629         {
1630           agent_release_card_info (&info);
1631           return;
1632         }
1633     }
1634
1635   /* If no displayed name has been set, we assume that this is a fresh
1636      card and print a hint about the default PINs.  */
1637   if (!info.disp_name || !*info.disp_name)
1638     {
1639       tty_printf ("\n");
1640       tty_printf (_("Please note that the factory settings of the PINs are\n"
1641                     "   PIN = '%s'     Admin PIN = '%s'\n"
1642                     "You should change them using the command --change-pin\n"),
1643                   "123456", "12345678");
1644       tty_printf ("\n");
1645     }
1646
1647
1648   if (check_pin_for_key_operation (&info, &forced_chv1))
1649     goto leave;
1650
1651   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1652
1653  leave:
1654   agent_release_card_info (&info);
1655   restore_forced_chv1 (&forced_chv1);
1656 }
1657
1658
1659 /* This function is used by the key edit menu to generate an arbitrary
1660    subkey. */
1661 gpg_error_t
1662 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1663 {
1664   gpg_error_t err;
1665   struct agent_card_info_s info;
1666   int forced_chv1 = 0;
1667   int keyno;
1668
1669   err = get_info_for_key_operation (&info);
1670   if (err)
1671     return err;
1672
1673   show_card_key_info (&info);
1674
1675   tty_printf (_("Please select the type of key to generate:\n"));
1676
1677   tty_printf (_("   (1) Signature key\n"));
1678   tty_printf (_("   (2) Encryption key\n"));
1679   tty_printf (_("   (3) Authentication key\n"));
1680
1681   for (;;)
1682     {
1683       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1684                               _("Your selection? "));
1685       cpr_kill_prompt();
1686       if (*answer == CONTROL_D)
1687         {
1688           xfree (answer);
1689           err = gpg_error (GPG_ERR_CANCELED);
1690           goto leave;
1691         }
1692       keyno = *answer? atoi(answer): 0;
1693       xfree(answer);
1694       if (keyno >= 1 && keyno <= 3)
1695         break; /* Okay. */
1696       tty_printf(_("Invalid selection.\n"));
1697     }
1698
1699   if (replace_existing_key_p (&info, keyno) < 0)
1700     {
1701       err = gpg_error (GPG_ERR_CANCELED);
1702       goto leave;
1703     }
1704
1705   err = check_pin_for_key_operation (&info, &forced_chv1);
1706   if (err)
1707     goto leave;
1708
1709   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1710
1711  leave:
1712   agent_release_card_info (&info);
1713   restore_forced_chv1 (&forced_chv1);
1714   return err;
1715 }
1716
1717
1718 /* Store the key at NODE into the smartcard and modify NODE to
1719    carry the serialno stuff instead of the actual secret key
1720    parameters.  USE is the usage for that key; 0 means any
1721    usage. */
1722 int
1723 card_store_subkey (KBNODE node, int use)
1724 {
1725   struct agent_card_info_s info;
1726   int okay = 0;
1727   unsigned int nbits;
1728   int allow_keyno[3];
1729   int  keyno;
1730   PKT_public_key *pk;
1731   gpg_error_t err;
1732   char *hexgrip;
1733   int rc;
1734   gnupg_isotime_t timebuf;
1735
1736   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1737               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1738
1739   pk = node->pkt->pkt.public_key;
1740
1741   if (get_info_for_key_operation (&info))
1742     return 0;
1743
1744   if (!info.extcap.ki)
1745     {
1746       tty_printf ("The card does not support the import of keys\n");
1747       tty_printf ("\n");
1748       goto leave;
1749     }
1750
1751   nbits = nbits_from_pk (pk);
1752
1753   if (!info.is_v2 && nbits != 1024)
1754     {
1755       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1756       tty_printf ("\n");
1757       goto leave;
1758     }
1759
1760   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1761   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1762   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1763
1764   tty_printf (_("Please select where to store the key:\n"));
1765
1766   if (allow_keyno[0])
1767     tty_printf (_("   (1) Signature key\n"));
1768   if (allow_keyno[1])
1769     tty_printf (_("   (2) Encryption key\n"));
1770   if (allow_keyno[2])
1771     tty_printf (_("   (3) Authentication key\n"));
1772
1773   for (;;)
1774     {
1775       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1776                               _("Your selection? "));
1777       cpr_kill_prompt();
1778       if (*answer == CONTROL_D || !*answer)
1779         {
1780           xfree (answer);
1781           goto leave;
1782         }
1783       keyno = *answer? atoi(answer): 0;
1784       xfree(answer);
1785       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1786         {
1787           if (info.is_v2 && !info.extcap.aac
1788               && info.key_attr[keyno-1].nbits != nbits)
1789             {
1790               tty_printf ("Key does not match the card's capability.\n");
1791             }
1792           else
1793             break; /* Okay. */
1794         }
1795       else
1796         tty_printf(_("Invalid selection.\n"));
1797     }
1798
1799   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1800     goto leave;
1801
1802   err = hexkeygrip_from_pk (pk, &hexgrip);
1803   if (err)
1804     goto leave;
1805
1806   epoch2isotime (timebuf, (time_t)pk->timestamp);
1807   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1808
1809   if (rc)
1810     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1811   else
1812     okay = 1;
1813   xfree (hexgrip);
1814
1815  leave:
1816   agent_release_card_info (&info);
1817   return okay;
1818 }
1819
1820
1821
1822 /* Direct sending of an hex encoded APDU with error printing.  */
1823 static gpg_error_t
1824 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1825 {
1826   gpg_error_t err;
1827   unsigned int sw;
1828
1829   err = agent_scd_apdu (hexapdu, &sw);
1830   if (err)
1831     tty_printf ("sending card command %s failed: %s\n", desc,
1832                 gpg_strerror (err));
1833   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1834     ;
1835   else if (ignore == 0xffff)
1836     ; /* Ignore all status words.  */
1837   else if (sw != 0x9000)
1838     {
1839       switch (sw)
1840         {
1841         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1842         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1843         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1844         default: err = gpg_error (GPG_ERR_CARD);
1845         }
1846       if (!(ignore && ignore == sw))
1847         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1848                     gpg_strerror (err),  sw);
1849     }
1850   return err;
1851 }
1852
1853
1854 /* Do a factory reset after confirmation.  */
1855 static void
1856 factory_reset (void)
1857 {
1858   struct agent_card_info_s info;
1859   gpg_error_t err;
1860   char *answer = NULL;
1861   int termstate = 0;
1862   int i;
1863
1864   /*  The code below basically does the same what this
1865       gpg-connect-agent script does:
1866
1867         scd reset
1868         scd serialno undefined
1869         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1870         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
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 83 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 e6 00 00
1879         scd apdu 00 44 00 00
1880         scd reset
1881         /echo Card has been reset to factory defaults
1882
1883       but tries to find out something about the card first.
1884    */
1885
1886   err = agent_scd_learn (&info, 0);
1887   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1888       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1889     termstate = 1;
1890   else if (err)
1891     {
1892       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1893       goto leave;
1894     }
1895
1896   if (!termstate)
1897     {
1898       log_info (_("OpenPGP card no. %s detected\n"),
1899                 info.serialno? info.serialno : "[none]");
1900       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1901         {
1902           /* Note: We won't see status-indicator 3 here because it is not
1903              possible to select a card application in termination state.  */
1904           log_error (_("This command is not supported by this card\n"));
1905           goto leave;
1906         }
1907
1908       tty_printf ("\n");
1909       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1910       tty_printf ("\n");
1911       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1912                                   _("Continue? (y/N) ")))
1913         goto leave;
1914
1915
1916       answer = cpr_get ("cardedit.factory-reset.really",
1917                         _("Really do a factory reset? (enter \"yes\") "));
1918       cpr_kill_prompt ();
1919       trim_spaces (answer);
1920       if (strcmp (answer, "yes"))
1921         goto leave;
1922
1923       /* We need to select a card application before we can send APDUs
1924          to the card without scdaemon doing anything on its own.  */
1925       err = send_apdu (NULL, "RESET", 0);
1926       if (err)
1927         goto leave;
1928       err = send_apdu ("undefined", "dummy select ", 0);
1929       if (err)
1930         goto leave;
1931
1932       /* Select the OpenPGP application.  */
1933       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1934       if (err)
1935         goto leave;
1936
1937       /* Do some dummy verifies with wrong PINs to set the retry
1938          counter to zero.  We can't easily use the card version 2.1
1939          feature of presenting the admin PIN to allow the terminate
1940          command because there is no machinery in scdaemon to catch
1941          the verify command and ask for the PIN when the "APDU"
1942          command is used. */
1943       /* Here, the length of dummy wrong PIN is 32-byte, also
1944          supporting authentication with KDF DO.  */
1945       for (i=0; i < 4; i++)
1946         send_apdu ("0020008120"
1947                    "40404040404040404040404040404040"
1948                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1949       for (i=0; i < 4; i++)
1950         send_apdu ("0020008320"
1951                    "40404040404040404040404040404040"
1952                    "40404040404040404040404040404040", "VERIFY", 0xffff);
1953
1954       /* Send terminate datafile command.  */
1955       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1956       if (err)
1957         goto leave;
1958     }
1959
1960   /* Send activate datafile command.  This is used without
1961      confirmation if the card is already in termination state.  */
1962   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1963   if (err)
1964     goto leave;
1965
1966   /* Finally we reset the card reader once more.  */
1967   err = send_apdu (NULL, "RESET", 0);
1968
1969   /* Then, connect the card again.  */
1970   if (!err)
1971     {
1972       char *serialno0;
1973
1974       err = agent_scd_serialno (&serialno0, NULL);
1975       if (!err)
1976         xfree (serialno0);
1977     }
1978
1979  leave:
1980   xfree (answer);
1981   agent_release_card_info (&info);
1982 }
1983
1984
1985 #define USER_PIN_DEFAULT "123456"
1986 #define ADMIN_PIN_DEFAULT "12345678"
1987 #define KDF_DATA_LENGTH_MIN  90
1988 #define KDF_DATA_LENGTH_MAX 110
1989
1990 /* Generate KDF data.  */
1991 static gpg_error_t
1992 gen_kdf_data (unsigned char *data, int single_salt)
1993 {
1994   const unsigned char h0[] = { 0x81, 0x01, 0x03,
1995                                0x82, 0x01, 0x08,
1996                                0x83, 0x04 };
1997   const unsigned char h1[] = { 0x84, 0x08 };
1998   const unsigned char h2[] = { 0x85, 0x08 };
1999   const unsigned char h3[] = { 0x86, 0x08 };
2000   const unsigned char h4[] = { 0x87, 0x20 };
2001   const unsigned char h5[] = { 0x88, 0x20 };
2002   unsigned char *p, *salt_user, *salt_admin;
2003   unsigned char s2k_char;
2004   unsigned int iterations;
2005   unsigned char count_4byte[4];
2006   gpg_error_t err = 0;
2007
2008   p = data;
2009
2010   s2k_char = encode_s2k_iterations (0);
2011   iterations = S2K_DECODE_COUNT (s2k_char);
2012   count_4byte[0] = (iterations >> 24) & 0xff;
2013   count_4byte[1] = (iterations >> 16) & 0xff;
2014   count_4byte[2] = (iterations >>  8) & 0xff;
2015   count_4byte[3] = (iterations & 0xff);
2016
2017   memcpy (p, h0, sizeof h0);
2018   p += sizeof h0;
2019   memcpy (p, count_4byte, sizeof count_4byte);
2020   p += sizeof count_4byte;
2021   memcpy (p, h1, sizeof h1);
2022   salt_user = (p += sizeof h1);
2023   gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2024   p += 8;
2025
2026   if (single_salt)
2027     salt_admin = salt_user;
2028   else
2029     {
2030       memcpy (p, h2, sizeof h2);
2031       p += sizeof h2;
2032       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2033       p += 8;
2034       memcpy (p, h3, sizeof h3);
2035       salt_admin = (p += sizeof h3);
2036       gcry_randomize (p, 8, GCRY_STRONG_RANDOM);
2037       p += 8;
2038     }
2039
2040   memcpy (p, h4, sizeof h4);
2041   p += sizeof h4;
2042   err = gcry_kdf_derive (USER_PIN_DEFAULT, strlen (USER_PIN_DEFAULT),
2043                          GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
2044                          salt_user, 8, iterations, 32, p);
2045   p += 32;
2046   if (!err)
2047     {
2048       memcpy (p, h5, sizeof h5);
2049       p += sizeof h5;
2050       err = gcry_kdf_derive (ADMIN_PIN_DEFAULT, strlen (ADMIN_PIN_DEFAULT),
2051                              GCRY_KDF_ITERSALTED_S2K, DIGEST_ALGO_SHA256,
2052                              salt_admin, 8, iterations, 32, p);
2053     }
2054
2055   return err;
2056 }
2057
2058 /* Setup KDF data object which is used for PIN authentication.  */
2059 static void
2060 kdf_setup (const char *args)
2061 {
2062   struct agent_card_info_s info;
2063   gpg_error_t err;
2064   unsigned char kdf_data[KDF_DATA_LENGTH_MAX];
2065   int single = (*args != 0);
2066
2067   memset (&info, 0, sizeof info);
2068
2069   err = agent_scd_getattr ("EXTCAP", &info);
2070   if (err)
2071     {
2072       log_error (_("error getting card info: %s\n"), gpg_strerror (err));
2073       return;
2074     }
2075
2076   if (!info.extcap.kdf)
2077     {
2078       log_error (_("This command is not supported by this card\n"));
2079       goto leave;
2080     }
2081
2082   err = gen_kdf_data (kdf_data, single);
2083   if (err)
2084     goto leave_error;
2085
2086   err = agent_scd_setattr ("KDF", kdf_data,
2087                            single ? KDF_DATA_LENGTH_MIN : KDF_DATA_LENGTH_MAX,
2088                            NULL);
2089   if (err)
2090     goto leave_error;
2091
2092   err = agent_scd_getattr ("KDF", &info);
2093
2094  leave_error:
2095   if (err)
2096     log_error (_("error for setup KDF: %s\n"), gpg_strerror (err));
2097
2098  leave:
2099   agent_release_card_info (&info);
2100 }
2101 \f
2102 /* Data used by the command parser.  This needs to be outside of the
2103    function scope to allow readline based command completion.  */
2104 enum cmdids
2105   {
2106     cmdNOP = 0,
2107     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
2108     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
2109     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2110     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2111     cmdKEYATTR,
2112     cmdINVCMD
2113   };
2114
2115 static struct
2116 {
2117   const char *name;
2118   enum cmdids id;
2119   int admin_only;
2120   const char *desc;
2121 } cmds[] =
2122   {
2123     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2124     { "q"       , cmdQUIT  , 0, NULL },
2125     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2126     { "help"    , cmdHELP  , 0, N_("show this help")},
2127     { "?"       , cmdHELP  , 0, NULL },
2128     { "list"    , cmdLIST  , 0, N_("list all available data")},
2129     { "l"       , cmdLIST  , 0, NULL },
2130     { "debug"   , cmdDEBUG , 0, NULL },
2131     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2132     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2133     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2134     { "login"   , cmdLOGIN , 1, N_("change the login name")},
2135     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2136     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
2137     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2138     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2139     { "generate", cmdGENERATE, 1, N_("generate new keys")},
2140     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2141     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2142     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
2143     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2144     { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2145     { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2146     /* Note, that we do not announce these command yet. */
2147     { "privatedo", cmdPRIVATEDO, 0, NULL },
2148     { "readcert", cmdREADCERT, 0, NULL },
2149     { "writecert", cmdWRITECERT, 1, NULL },
2150     { NULL, cmdINVCMD, 0, NULL }
2151   };
2152
2153
2154 #ifdef HAVE_LIBREADLINE
2155
2156 /* These two functions are used by readline for command completion. */
2157
2158 static char *
2159 command_generator(const char *text,int state)
2160 {
2161   static int list_index,len;
2162   const char *name;
2163
2164   /* If this is a new word to complete, initialize now.  This includes
2165      saving the length of TEXT for efficiency, and initializing the
2166      index variable to 0. */
2167   if(!state)
2168     {
2169       list_index=0;
2170       len=strlen(text);
2171     }
2172
2173   /* Return the next partial match */
2174   while((name=cmds[list_index].name))
2175     {
2176       /* Only complete commands that have help text */
2177       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
2178         return strdup(name);
2179     }
2180
2181   return NULL;
2182 }
2183
2184 static char **
2185 card_edit_completion(const char *text, int start, int end)
2186 {
2187   (void)end;
2188   /* If we are at the start of a line, we try and command-complete.
2189      If not, just do nothing for now. */
2190
2191   if(start==0)
2192     return rl_completion_matches(text,command_generator);
2193
2194   rl_attempted_completion_over=1;
2195
2196   return NULL;
2197 }
2198 #endif /*HAVE_LIBREADLINE*/
2199
2200 /* Menu to edit all user changeable values on an OpenPGP card.  Only
2201    Key creation is not handled here. */
2202 void
2203 card_edit (ctrl_t ctrl, strlist_t commands)
2204 {
2205   enum cmdids cmd = cmdNOP;
2206   int have_commands = !!commands;
2207   int redisplay = 1;
2208   char *answer = NULL;
2209   int allow_admin=0;
2210   char serialnobuf[50];
2211
2212
2213   if (opt.command_fd != -1)
2214     ;
2215   else if (opt.batch && !have_commands)
2216     {
2217       log_error(_("can't do this in batch mode\n"));
2218       goto leave;
2219     }
2220
2221   for (;;)
2222     {
2223       int arg_number;
2224       const char *arg_string = "";
2225       const char *arg_rest = "";
2226       char *p;
2227       int i;
2228       int cmd_admin_only;
2229
2230       tty_printf("\n");
2231       if (redisplay)
2232         {
2233           if (opt.with_colons)
2234             {
2235               current_card_status (ctrl, es_stdout,
2236                                    serialnobuf, DIM (serialnobuf));
2237               fflush (stdout);
2238             }
2239           else
2240             {
2241               current_card_status (ctrl, NULL,
2242                                    serialnobuf, DIM (serialnobuf));
2243               tty_printf("\n");
2244             }
2245           redisplay = 0;
2246         }
2247
2248       do
2249         {
2250           xfree (answer);
2251           if (have_commands)
2252             {
2253               if (commands)
2254                 {
2255                   answer = xstrdup (commands->d);
2256                   commands = commands->next;
2257                 }
2258               else if (opt.batch)
2259                 {
2260                   answer = xstrdup ("quit");
2261                 }
2262               else
2263                 have_commands = 0;
2264             }
2265
2266             if (!have_commands)
2267               {
2268                 tty_enable_completion (card_edit_completion);
2269                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2270                 cpr_kill_prompt();
2271                 tty_disable_completion ();
2272               }
2273             trim_spaces(answer);
2274         }
2275       while ( *answer == '#' );
2276
2277       arg_number = 0; /* Yes, here is the init which egcc complains about */
2278       cmd_admin_only = 0;
2279       if (!*answer)
2280         cmd = cmdLIST; /* Default to the list command */
2281       else if (*answer == CONTROL_D)
2282         cmd = cmdQUIT;
2283       else
2284         {
2285           if ((p=strchr (answer,' ')))
2286             {
2287               *p++ = 0;
2288               trim_spaces (answer);
2289               trim_spaces (p);
2290               arg_number = atoi(p);
2291               arg_string = p;
2292               arg_rest = p;
2293               while (digitp (arg_rest))
2294                 arg_rest++;
2295               while (spacep (arg_rest))
2296                 arg_rest++;
2297             }
2298
2299           for (i=0; cmds[i].name; i++ )
2300             if (!ascii_strcasecmp (answer, cmds[i].name ))
2301               break;
2302
2303           cmd = cmds[i].id;
2304           cmd_admin_only = cmds[i].admin_only;
2305         }
2306
2307       if (!allow_admin && cmd_admin_only)
2308         {
2309           tty_printf ("\n");
2310           tty_printf (_("Admin-only command\n"));
2311           continue;
2312         }
2313
2314       switch (cmd)
2315         {
2316         case cmdHELP:
2317           for (i=0; cmds[i].name; i++ )
2318             if(cmds[i].desc
2319                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2320               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2321           break;
2322
2323         case cmdADMIN:
2324           if ( !strcmp (arg_string, "on") )
2325             allow_admin = 1;
2326           else if ( !strcmp (arg_string, "off") )
2327             allow_admin = 0;
2328           else if ( !strcmp (arg_string, "verify") )
2329             {
2330               /* Force verification of the Admin Command.  However,
2331                  this is only done if the retry counter is at initial
2332                  state.  */
2333               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2334               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2335               allow_admin = !agent_scd_checkpin (tmp);
2336               xfree (tmp);
2337             }
2338           else /* Toggle. */
2339             allow_admin=!allow_admin;
2340           if(allow_admin)
2341             tty_printf(_("Admin commands are allowed\n"));
2342           else
2343             tty_printf(_("Admin commands are not allowed\n"));
2344           break;
2345
2346         case cmdVERIFY:
2347           agent_scd_checkpin (serialnobuf);
2348           redisplay = 1;
2349           break;
2350
2351         case cmdLIST:
2352           redisplay = 1;
2353           break;
2354
2355         case cmdNAME:
2356           change_name ();
2357           break;
2358
2359         case cmdURL:
2360           change_url ();
2361           break;
2362
2363         case cmdFETCH:
2364           fetch_url (ctrl);
2365           break;
2366
2367         case cmdLOGIN:
2368           change_login (arg_string);
2369           break;
2370
2371         case cmdLANG:
2372           change_lang ();
2373           break;
2374
2375         case cmdSEX:
2376           change_sex ();
2377           break;
2378
2379         case cmdCAFPR:
2380           if ( arg_number < 1 || arg_number > 3 )
2381             tty_printf ("usage: cafpr N\n"
2382                         "       1 <= N <= 3\n");
2383           else
2384             change_cafpr (arg_number);
2385           break;
2386
2387         case cmdPRIVATEDO:
2388           if ( arg_number < 1 || arg_number > 4 )
2389             tty_printf ("usage: privatedo N\n"
2390                         "       1 <= N <= 4\n");
2391           else
2392             change_private_do (arg_string, arg_number);
2393           break;
2394
2395         case cmdWRITECERT:
2396           if ( arg_number != 3 )
2397             tty_printf ("usage: writecert 3 < FILE\n");
2398           else
2399             change_cert (arg_rest);
2400           break;
2401
2402         case cmdREADCERT:
2403           if ( arg_number != 3 )
2404             tty_printf ("usage: readcert 3 > FILE\n");
2405           else
2406             read_cert (arg_rest);
2407           break;
2408
2409         case cmdFORCESIG:
2410           toggle_forcesig ();
2411           break;
2412
2413         case cmdGENERATE:
2414           generate_card_keys (ctrl);
2415           break;
2416
2417         case cmdPASSWD:
2418           change_pin (0, allow_admin);
2419           break;
2420
2421         case cmdUNBLOCK:
2422           change_pin (1, allow_admin);
2423           break;
2424
2425         case cmdFACTORYRESET:
2426           factory_reset ();
2427           break;
2428
2429         case cmdKDFSETUP:
2430           kdf_setup (arg_string);
2431           break;
2432
2433         case cmdKEYATTR:
2434           key_attr ();
2435           break;
2436
2437         case cmdQUIT:
2438           goto leave;
2439
2440         case cmdNOP:
2441           break;
2442
2443         case cmdINVCMD:
2444         default:
2445           tty_printf ("\n");
2446           tty_printf (_("Invalid command  (try \"help\")\n"));
2447           break;
2448         } /* End command switch. */
2449     } /* End of main menu loop. */
2450
2451  leave:
2452   xfree (answer);
2453 }