gpg: Add new card vendor
[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 0x4354: return "Confidential Technologies";   /* cotech.de */
220     case 0x63AF: return "Trustica";
221     case 0xBD0E: return "Paranoidlabs";
222     case 0xF517: return "FSIJ";
223
224       /* 0x0000 and 0xFFFF are defined as test cards per spec,
225          0xFF00 to 0xFFFE are assigned for use with randomly created
226          serial numbers.  */
227     case 0x0000:
228     case 0xffff: return "test card";
229     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
230     }
231 }
232
233
234 static void
235 print_shax_fpr (estream_t fp, const unsigned char *fpr, unsigned int fprlen)
236 {
237   int i;
238
239   if (fpr)
240     {
241       /* FIXME: Fix formatting for FPRLEN != 20 */
242       for (i=0; i < fprlen ; i+=2, fpr += 2 )
243         {
244           if (i == 10 )
245             tty_fprintf (fp, " ");
246           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
247         }
248     }
249   else
250     tty_fprintf (fp, " [none]");
251   tty_fprintf (fp, "\n");
252 }
253
254
255 static void
256 print_shax_fpr_colon (estream_t fp,
257                       const unsigned char *fpr, unsigned int fprlen)
258 {
259   int i;
260
261   if (fpr)
262     {
263       for (i=0; i < fprlen ; i++, fpr++)
264         es_fprintf (fp, "%02X", *fpr);
265     }
266   es_putc (':', fp);
267 }
268
269
270 static void
271 print_keygrip (estream_t fp, const unsigned char *grp)
272 {
273   int i;
274
275   if (opt.with_keygrip)
276     {
277       tty_fprintf (fp, "      keygrip ....: ");
278       for (i=0; i < 20 ; i++, grp++)
279         es_fprintf (fp, "%02X", *grp);
280       tty_fprintf (fp, "\n");
281     }
282 }
283
284
285 static void
286 print_name (estream_t fp, const char *text, const char *name)
287 {
288   tty_fprintf (fp, "%s", text);
289
290   /* FIXME: tty_printf_utf8_string2 eats everything after and
291      including an @ - e.g. when printing an url. */
292   if (name && *name)
293     {
294       if (fp)
295         print_utf8_buffer2 (fp, name, strlen (name), '\n');
296       else
297         tty_print_utf8_string2 (NULL, name, strlen (name), 0);
298     }
299   else
300     tty_fprintf (fp, _("[not set]"));
301   tty_fprintf (fp, "\n");
302 }
303
304 static void
305 print_isoname (estream_t fp, const char *text,
306                const char *tag, const char *name)
307 {
308   if (opt.with_colons)
309     es_fprintf (fp, "%s:", tag);
310   else
311     tty_fprintf (fp, "%s", text);
312
313   if (name && *name)
314     {
315       char *p, *given, *buf = xstrdup (name);
316
317       given = strstr (buf, "<<");
318       for (p=buf; *p; p++)
319         if (*p == '<')
320           *p = ' ';
321       if (given && given[2])
322         {
323           *given = 0;
324           given += 2;
325           if (opt.with_colons)
326             es_write_sanitized (fp, given, strlen (given), ":", NULL);
327           else if (fp)
328             print_utf8_buffer2 (fp, given, strlen (given), '\n');
329           else
330             tty_print_utf8_string2 (NULL, given, strlen (given), 0);
331
332           if (opt.with_colons)
333             es_putc (':', fp);
334           else if (*buf)
335             tty_fprintf (fp, " ");
336         }
337
338       if (opt.with_colons)
339         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
340       else if (fp)
341         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
342       else
343         tty_print_utf8_string2 (NULL, buf, strlen (buf), 0);
344       xfree (buf);
345     }
346   else
347     {
348       if (opt.with_colons)
349         es_putc (':', fp);
350       else
351         tty_fprintf (fp, _("[not set]"));
352     }
353
354   if (opt.with_colons)
355     es_fputs (":\n", fp);
356   else
357     tty_fprintf (fp, "\n");
358 }
359
360 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
361 static int
362 fpr_is_zero (const char *fpr, unsigned int fprlen)
363 {
364   int i;
365
366   for (i=0; i < fprlen && !fpr[i]; i++)
367     ;
368   return (i == fprlen);
369 }
370
371
372 /* Return true if the fingerprint FPR consists only of 0xFF. */
373 static int
374 fpr_is_ff (const char *fpr, unsigned int fprlen)
375 {
376   int i;
377
378   for (i=0; i < fprlen && fpr[i] == '\xff'; i++)
379     ;
380   return (i == fprlen);
381 }
382
383
384 /* Print all available information about the current card. */
385 static void
386 current_card_status (ctrl_t ctrl, estream_t fp,
387                      char *serialno, size_t serialnobuflen)
388 {
389   struct agent_card_info_s info;
390   PKT_public_key *pk = xcalloc (1, sizeof *pk);
391   kbnode_t keyblock = NULL;
392   int rc;
393   unsigned int uval;
394   const unsigned char *thefpr;
395   unsigned int thefprlen;
396   int i;
397
398   if (serialno && serialnobuflen)
399     *serialno = 0;
400
401   rc = agent_scd_learn (&info, 0);
402   if (rc)
403     {
404       if (opt.with_colons)
405         es_fputs ("AID:::\n", fp);
406       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
407       xfree (pk);
408       return;
409     }
410
411   if (opt.with_colons)
412     es_fprintf (fp, "Reader:%s:", info.reader? info.reader : "");
413   else
414     tty_fprintf (fp, "Reader ...........: %s\n",
415                  info.reader? info.reader : "[none]");
416   if (opt.with_colons)
417     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
418   else
419     tty_fprintf (fp, "Application ID ...: %s\n",
420                  info.serialno? info.serialno : "[none]");
421   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12)
422       || strlen (info.serialno) != 32 )
423     {
424       if (info.apptype && !strcmp (info.apptype, "NKS"))
425         {
426           if (opt.with_colons)
427             es_fputs ("netkey-card:\n", fp);
428           log_info ("this is a NetKey card\n");
429         }
430       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
431         {
432           if (opt.with_colons)
433             es_fputs ("dinsig-card:\n", fp);
434           log_info ("this is a DINSIG compliant card\n");
435         }
436       else if (info.apptype && !strcmp (info.apptype, "P15"))
437         {
438           if (opt.with_colons)
439             es_fputs ("pkcs15-card:\n", fp);
440           log_info ("this is a PKCS#15 compliant card\n");
441         }
442       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
443         {
444           if (opt.with_colons)
445             es_fputs ("geldkarte-card:\n", fp);
446           log_info ("this is a Geldkarte compliant card\n");
447         }
448       else
449         {
450           if (opt.with_colons)
451             es_fputs ("unknown:\n", fp);
452         }
453       log_info ("not an OpenPGP card\n");
454       agent_release_card_info (&info);
455       xfree (pk);
456       return;
457     }
458
459   if (!serialno)
460     ;
461   else if (strlen (info.serialno)+1 > serialnobuflen)
462     log_error ("serial number longer than expected\n");
463   else
464     strcpy (serialno, info.serialno);
465
466   if (opt.with_colons)
467     es_fputs ("openpgp-card:\n", fp);
468
469
470   if (opt.with_colons)
471     {
472       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
473       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
474       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
475       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
476
477       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
478
479       es_fputs ("lang:", fp);
480       if (info.disp_lang)
481         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
482                             ":", NULL);
483       es_fputs (":\n", fp);
484
485       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
486                                  info.disp_sex == 2? 'f' : 'u'));
487
488       es_fputs ("url:", fp);
489       if (info.pubkey_url)
490         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
491                             ":", NULL);
492       es_fputs (":\n", fp);
493
494       es_fputs ("login:", fp);
495       if (info.login_data)
496         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
497                             ":", NULL);
498       es_fputs (":\n", fp);
499
500       es_fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
501       for (i=0; i < DIM (info.key_attr); i++)
502         if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
503           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
504                       info.key_attr[i].algo, info.key_attr[i].nbits);
505         else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
506                  || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
507                  || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
508           es_fprintf (fp, "keyattr:%d:%d:%s:\n", i+1,
509                       info.key_attr[i].algo, info.key_attr[i].curve);
510       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
511                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
512       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
513                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
514       es_fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
515
516       for (i=0; i < 4; i++)
517         {
518           if (info.private_do[i])
519             {
520               es_fprintf (fp, "private_do:%d:", i+1);
521               es_write_sanitized (fp, info.private_do[i],
522                                   strlen (info.private_do[i]), ":", NULL);
523               es_fputs (":\n", fp);
524             }
525         }
526
527       es_fputs ("cafpr:", fp);
528       print_shax_fpr_colon (fp, info.cafpr1len? info.cafpr1:NULL,
529                             info.cafpr2len);
530       print_shax_fpr_colon (fp, info.cafpr2len? info.cafpr2:NULL,
531                             info.cafpr2len);
532       print_shax_fpr_colon (fp, info.cafpr3len? info.cafpr3:NULL,
533                             info.cafpr3len);
534       es_putc ('\n', fp);
535       es_fputs ("fpr:", fp);
536       print_shax_fpr_colon (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
537       print_shax_fpr_colon (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
538       print_shax_fpr_colon (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
539       es_putc ('\n', fp);
540       es_fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
541                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
542                (unsigned long)info.fpr3time);
543       es_fputs ("grp:", fp);
544       print_shax_fpr_colon (fp, info.grp1, sizeof info.grp1);
545       print_shax_fpr_colon (fp, info.grp2, sizeof info.grp2);
546       print_shax_fpr_colon (fp, info.grp3, sizeof info.grp3);
547       es_putc ('\n', fp);
548     }
549   else
550     {
551       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
552                    info.serialno[12] == '0'?"":info.serialno+12,
553                    info.serialno[13],
554                    info.serialno[14] == '0'?"":info.serialno+14,
555                    info.serialno[15]);
556       tty_fprintf (fp, "Manufacturer .....: %s\n",
557                    get_manufacturer (xtoi_2(info.serialno+16)*256
558                                      + xtoi_2 (info.serialno+18)));
559       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
560
561       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
562       print_name (fp, "Language prefs ...: ", info.disp_lang);
563       tty_fprintf (fp, "Salutation .......: %s\n",
564                    info.disp_sex == 1? _("Mr."):
565                    info.disp_sex == 2? _("Mrs.") : "");
566       print_name (fp, "URL of public key : ", info.pubkey_url);
567       print_name (fp, "Login data .......: ", info.login_data);
568       if (info.private_do[0])
569         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
570       if (info.private_do[1])
571         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
572       if (info.private_do[2])
573         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
574       if (info.private_do[3])
575         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
576       if (info.cafpr1len)
577         {
578           tty_fprintf (fp, "CA fingerprint %d .:", 1);
579           print_shax_fpr (fp, info.cafpr1, info.cafpr1len);
580         }
581       if (info.cafpr2len)
582         {
583           tty_fprintf (fp, "CA fingerprint %d .:", 2);
584           print_shax_fpr (fp, info.cafpr2, info.cafpr2len);
585         }
586       if (info.cafpr3len)
587         {
588           tty_fprintf (fp, "CA fingerprint %d .:", 3);
589           print_shax_fpr (fp, info.cafpr3, info.cafpr3len);
590         }
591       tty_fprintf (fp,    "Signature PIN ....: %s\n",
592                    info.chv1_cached? _("not forced"): _("forced"));
593       if (info.key_attr[0].algo)
594         {
595           tty_fprintf (fp,    "Key attributes ...:");
596           for (i=0; i < DIM (info.key_attr); i++)
597             if (info.key_attr[i].algo == PUBKEY_ALGO_RSA)
598               tty_fprintf (fp, " rsa%u", info.key_attr[i].nbits);
599             else if (info.key_attr[i].algo == PUBKEY_ALGO_ECDH
600                      || info.key_attr[i].algo == PUBKEY_ALGO_ECDSA
601                      || info.key_attr[i].algo == PUBKEY_ALGO_EDDSA)
602               {
603                 const char *curve_for_print = "?";
604
605                 if (info.key_attr[i].curve)
606                   {
607                     const char *oid;
608                     oid = openpgp_curve_to_oid (info.key_attr[i].curve, NULL);
609                     if (oid)
610                       curve_for_print = openpgp_oid_to_curve (oid, 0);
611                   }
612                 tty_fprintf (fp, " %s", curve_for_print);
613               }
614           tty_fprintf (fp, "\n");
615         }
616       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
617                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
618       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
619                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
620       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
621       tty_fprintf (fp, "Signature key ....:");
622       print_shax_fpr (fp, info.fpr1len? info.fpr1:NULL, info.fpr1len);
623       if (info.fpr1len && info.fpr1time)
624         {
625           tty_fprintf (fp, "      created ....: %s\n",
626                        isotimestamp (info.fpr1time));
627           print_keygrip (fp, info.grp1);
628         }
629       tty_fprintf (fp, "Encryption key....:");
630       print_shax_fpr (fp, info.fpr2len? info.fpr2:NULL, info.fpr2len);
631       if (info.fpr2len && info.fpr2time)
632         {
633           tty_fprintf (fp, "      created ....: %s\n",
634                        isotimestamp (info.fpr2time));
635           print_keygrip (fp, info.grp2);
636         }
637       tty_fprintf (fp, "Authentication key:");
638       print_shax_fpr (fp, info.fpr3len? info.fpr3:NULL, info.fpr3len);
639       if (info.fpr3len && info.fpr3time)
640         {
641           tty_fprintf (fp, "      created ....: %s\n",
642                        isotimestamp (info.fpr3time));
643           print_keygrip (fp, info.grp3);
644         }
645       tty_fprintf (fp, "General key info..: ");
646
647       thefpr = (info.fpr1len? info.fpr1 : info.fpr2len? info.fpr2 :
648                 info.fpr3len? info.fpr3 : NULL);
649       thefprlen = (info.fpr1len? info.fpr1len : info.fpr2len? info.fpr2len :
650                    info.fpr3len? info.fpr3len : 0);
651       /* If the fingerprint is all 0xff, the key has no asssociated
652          OpenPGP certificate.  */
653       if ( thefpr && !fpr_is_ff (thefpr, thefprlen)
654            && !get_pubkey_byfprint (ctrl, pk, &keyblock, thefpr, thefprlen))
655         {
656           print_pubkey_info (ctrl, fp, pk);
657           if (keyblock)
658             print_card_key_info (fp, keyblock);
659         }
660       else
661         tty_fprintf (fp, "[none]\n");
662     }
663
664   release_kbnode (keyblock);
665   free_public_key (pk);
666   agent_release_card_info (&info);
667 }
668
669
670 /* Print all available information for specific card with SERIALNO.
671    Print all available information for current card when SERIALNO is NULL.
672    Or print for all cards when SERIALNO is "all".  */
673 void
674 card_status (ctrl_t ctrl, estream_t fp, const char *serialno)
675 {
676   int err;
677   strlist_t card_list, sl;
678   char *serialno0, *serialno1;
679   int all_cards = 0;
680
681   if (serialno == NULL)
682     {
683       current_card_status (ctrl, fp, NULL, 0);
684       return;
685     }
686
687   if (!strcmp (serialno, "all"))
688     all_cards = 1;
689
690   err = agent_scd_serialno (&serialno0, NULL);
691   if (err)
692     {
693       if (gpg_err_code (err) != GPG_ERR_ENODEV && opt.verbose)
694         log_info (_("error getting serial number of card: %s\n"),
695                   gpg_strerror (err));
696       /* Nothing available.  */
697       return;
698     }
699
700   err = agent_scd_cardlist (&card_list);
701
702   for (sl = card_list; sl; sl = sl->next)
703     {
704       if (!all_cards && strcmp (serialno, sl->d))
705         continue;
706
707       err = agent_scd_serialno (&serialno1, sl->d);
708       if (err)
709         {
710           if (opt.verbose)
711             log_info (_("error getting serial number of card: %s\n"),
712                       gpg_strerror (err));
713           continue;
714         }
715
716       current_card_status (ctrl, fp, NULL, 0);
717       xfree (serialno1);
718
719       if (!all_cards)
720         goto leave;
721     }
722
723   /* Select the original card again.  */
724   err = agent_scd_serialno (&serialno1, serialno0);
725   xfree (serialno1);
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
2114 static void
2115 uif (int arg_number, const char *arg_rest)
2116 {
2117   gpg_error_t err;
2118   char name[100];
2119   unsigned char data[2];
2120
2121   snprintf (name, sizeof name, "UIF-%d", arg_number);
2122   if ( !strcmp (arg_rest, "off") )
2123     data[0] = 0x00;
2124   else if ( !strcmp (arg_rest, "on") )
2125     data[0] = 0x01;
2126   else if ( !strcmp (arg_rest, "permanent") )
2127     data[0] = 0x02;
2128
2129   data[1] = 0x20;
2130
2131   err = agent_scd_setattr (name, data, 2, NULL);
2132   if (err)
2133     log_error (_("error for setup UIF: %s\n"), gpg_strerror (err));
2134 }
2135 \f
2136 /* Data used by the command parser.  This needs to be outside of the
2137    function scope to allow readline based command completion.  */
2138 enum cmdids
2139   {
2140     cmdNOP = 0,
2141     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
2142     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
2143     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
2144     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET, cmdKDFSETUP,
2145     cmdKEYATTR, cmdUIF,
2146     cmdINVCMD
2147   };
2148
2149 static struct
2150 {
2151   const char *name;
2152   enum cmdids id;
2153   int admin_only;
2154   const char *desc;
2155 } cmds[] =
2156   {
2157     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
2158     { "q"       , cmdQUIT  , 0, NULL },
2159     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
2160     { "help"    , cmdHELP  , 0, N_("show this help")},
2161     { "?"       , cmdHELP  , 0, NULL },
2162     { "list"    , cmdLIST  , 0, N_("list all available data")},
2163     { "l"       , cmdLIST  , 0, NULL },
2164     { "debug"   , cmdDEBUG , 0, NULL },
2165     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
2166     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
2167     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
2168     { "login"   , cmdLOGIN , 1, N_("change the login name")},
2169     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
2170     { "salutation",cmdSEX  , 1, N_("change card holder's salutation")},
2171     { "sex"       ,cmdSEX  , 1, NULL },  /* Backward compatibility.  */
2172     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
2173     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
2174     { "generate", cmdGENERATE, 1, N_("generate new keys")},
2175     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
2176     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
2177     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code")},
2178     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
2179     { "kdf-setup", cmdKDFSETUP, 1, N_("setup KDF for PIN authentication")},
2180     { "key-attr", cmdKEYATTR, 1, N_("change the key attribute")},
2181     { "uif", cmdUIF, 1, N_("change the User Interaction Flag")},
2182     /* Note, that we do not announce these command yet. */
2183     { "privatedo", cmdPRIVATEDO, 0, NULL },
2184     { "readcert", cmdREADCERT, 0, NULL },
2185     { "writecert", cmdWRITECERT, 1, NULL },
2186     { NULL, cmdINVCMD, 0, NULL }
2187   };
2188
2189
2190 #ifdef HAVE_LIBREADLINE
2191
2192 /* These two functions are used by readline for command completion. */
2193
2194 static char *
2195 command_generator(const char *text,int state)
2196 {
2197   static int list_index,len;
2198   const char *name;
2199
2200   /* If this is a new word to complete, initialize now.  This includes
2201      saving the length of TEXT for efficiency, and initializing the
2202      index variable to 0. */
2203   if(!state)
2204     {
2205       list_index=0;
2206       len=strlen(text);
2207     }
2208
2209   /* Return the next partial match */
2210   while((name=cmds[list_index].name))
2211     {
2212       /* Only complete commands that have help text */
2213       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
2214         return strdup(name);
2215     }
2216
2217   return NULL;
2218 }
2219
2220 static char **
2221 card_edit_completion(const char *text, int start, int end)
2222 {
2223   (void)end;
2224   /* If we are at the start of a line, we try and command-complete.
2225      If not, just do nothing for now. */
2226
2227   if(start==0)
2228     return rl_completion_matches(text,command_generator);
2229
2230   rl_attempted_completion_over=1;
2231
2232   return NULL;
2233 }
2234 #endif /*HAVE_LIBREADLINE*/
2235
2236 /* Menu to edit all user changeable values on an OpenPGP card.  Only
2237    Key creation is not handled here. */
2238 void
2239 card_edit (ctrl_t ctrl, strlist_t commands)
2240 {
2241   enum cmdids cmd = cmdNOP;
2242   int have_commands = !!commands;
2243   int redisplay = 1;
2244   char *answer = NULL;
2245   int allow_admin=0;
2246   char serialnobuf[50];
2247
2248
2249   if (opt.command_fd != -1)
2250     ;
2251   else if (opt.batch && !have_commands)
2252     {
2253       log_error(_("can't do this in batch mode\n"));
2254       goto leave;
2255     }
2256
2257   for (;;)
2258     {
2259       int arg_number;
2260       const char *arg_string = "";
2261       const char *arg_rest = "";
2262       char *p;
2263       int i;
2264       int cmd_admin_only;
2265
2266       tty_printf("\n");
2267       if (redisplay)
2268         {
2269           if (opt.with_colons)
2270             {
2271               current_card_status (ctrl, es_stdout,
2272                                    serialnobuf, DIM (serialnobuf));
2273               fflush (stdout);
2274             }
2275           else
2276             {
2277               current_card_status (ctrl, NULL,
2278                                    serialnobuf, DIM (serialnobuf));
2279               tty_printf("\n");
2280             }
2281           redisplay = 0;
2282         }
2283
2284       do
2285         {
2286           xfree (answer);
2287           if (have_commands)
2288             {
2289               if (commands)
2290                 {
2291                   answer = xstrdup (commands->d);
2292                   commands = commands->next;
2293                 }
2294               else if (opt.batch)
2295                 {
2296                   answer = xstrdup ("quit");
2297                 }
2298               else
2299                 have_commands = 0;
2300             }
2301
2302             if (!have_commands)
2303               {
2304                 tty_enable_completion (card_edit_completion);
2305                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2306                 cpr_kill_prompt();
2307                 tty_disable_completion ();
2308               }
2309             trim_spaces(answer);
2310         }
2311       while ( *answer == '#' );
2312
2313       arg_number = 0; /* Yes, here is the init which egcc complains about */
2314       cmd_admin_only = 0;
2315       if (!*answer)
2316         cmd = cmdLIST; /* Default to the list command */
2317       else if (*answer == CONTROL_D)
2318         cmd = cmdQUIT;
2319       else
2320         {
2321           if ((p=strchr (answer,' ')))
2322             {
2323               *p++ = 0;
2324               trim_spaces (answer);
2325               trim_spaces (p);
2326               arg_number = atoi(p);
2327               arg_string = p;
2328               arg_rest = p;
2329               while (digitp (arg_rest))
2330                 arg_rest++;
2331               while (spacep (arg_rest))
2332                 arg_rest++;
2333             }
2334
2335           for (i=0; cmds[i].name; i++ )
2336             if (!ascii_strcasecmp (answer, cmds[i].name ))
2337               break;
2338
2339           cmd = cmds[i].id;
2340           cmd_admin_only = cmds[i].admin_only;
2341         }
2342
2343       if (!allow_admin && cmd_admin_only)
2344         {
2345           tty_printf ("\n");
2346           tty_printf (_("Admin-only command\n"));
2347           continue;
2348         }
2349
2350       switch (cmd)
2351         {
2352         case cmdHELP:
2353           for (i=0; cmds[i].name; i++ )
2354             if(cmds[i].desc
2355                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2356               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2357           break;
2358
2359         case cmdADMIN:
2360           if ( !strcmp (arg_string, "on") )
2361             allow_admin = 1;
2362           else if ( !strcmp (arg_string, "off") )
2363             allow_admin = 0;
2364           else if ( !strcmp (arg_string, "verify") )
2365             {
2366               /* Force verification of the Admin Command.  However,
2367                  this is only done if the retry counter is at initial
2368                  state.  */
2369               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2370               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2371               allow_admin = !agent_scd_checkpin (tmp);
2372               xfree (tmp);
2373             }
2374           else /* Toggle. */
2375             allow_admin=!allow_admin;
2376           if(allow_admin)
2377             tty_printf(_("Admin commands are allowed\n"));
2378           else
2379             tty_printf(_("Admin commands are not allowed\n"));
2380           break;
2381
2382         case cmdVERIFY:
2383           agent_scd_checkpin (serialnobuf);
2384           redisplay = 1;
2385           break;
2386
2387         case cmdLIST:
2388           redisplay = 1;
2389           break;
2390
2391         case cmdNAME:
2392           change_name ();
2393           break;
2394
2395         case cmdURL:
2396           change_url ();
2397           break;
2398
2399         case cmdFETCH:
2400           fetch_url (ctrl);
2401           break;
2402
2403         case cmdLOGIN:
2404           change_login (arg_string);
2405           break;
2406
2407         case cmdLANG:
2408           change_lang ();
2409           break;
2410
2411         case cmdSEX:
2412           change_sex ();
2413           break;
2414
2415         case cmdCAFPR:
2416           if ( arg_number < 1 || arg_number > 3 )
2417             tty_printf ("usage: cafpr N\n"
2418                         "       1 <= N <= 3\n");
2419           else
2420             change_cafpr (arg_number);
2421           break;
2422
2423         case cmdPRIVATEDO:
2424           if ( arg_number < 1 || arg_number > 4 )
2425             tty_printf ("usage: privatedo N\n"
2426                         "       1 <= N <= 4\n");
2427           else
2428             change_private_do (arg_string, arg_number);
2429           break;
2430
2431         case cmdWRITECERT:
2432           if ( arg_number != 3 )
2433             tty_printf ("usage: writecert 3 < FILE\n");
2434           else
2435             change_cert (arg_rest);
2436           break;
2437
2438         case cmdREADCERT:
2439           if ( arg_number != 3 )
2440             tty_printf ("usage: readcert 3 > FILE\n");
2441           else
2442             read_cert (arg_rest);
2443           break;
2444
2445         case cmdFORCESIG:
2446           toggle_forcesig ();
2447           break;
2448
2449         case cmdGENERATE:
2450           generate_card_keys (ctrl);
2451           break;
2452
2453         case cmdPASSWD:
2454           change_pin (0, allow_admin);
2455           break;
2456
2457         case cmdUNBLOCK:
2458           change_pin (1, allow_admin);
2459           break;
2460
2461         case cmdFACTORYRESET:
2462           factory_reset ();
2463           break;
2464
2465         case cmdKDFSETUP:
2466           kdf_setup (arg_string);
2467           break;
2468
2469         case cmdKEYATTR:
2470           key_attr ();
2471           break;
2472
2473         case cmdUIF:
2474           if ( arg_number < 1 || arg_number > 3 )
2475             tty_printf ("usage: uif N [on|off|permanent]\n"
2476                         "       1 <= N <= 3\n");
2477           else
2478             uif (arg_number, arg_rest);
2479           break;
2480
2481         case cmdQUIT:
2482           goto leave;
2483
2484         case cmdNOP:
2485           break;
2486
2487         case cmdINVCMD:
2488         default:
2489           tty_printf ("\n");
2490           tty_printf (_("Invalid command  (try \"help\")\n"));
2491           break;
2492         } /* End command switch. */
2493     } /* End of main menu loop. */
2494
2495  leave:
2496   xfree (answer);
2497 }