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