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