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