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