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