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