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