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[20];
1125
1126   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
1127   if (!data)
1128     return -1;
1129   trim_spaces (data);
1130   cpr_kill_prompt ();
1131
1132   for (i=0, s=data; i < 20 && *s; )
1133     {
1134       while (spacep(s))
1135         s++;
1136       if (*s == ':')
1137         s++;
1138       while (spacep(s))
1139         s++;
1140       c = hextobyte (s);
1141       if (c == -1)
1142         break;
1143       fpr[i++] = c;
1144       s += 2;
1145     }
1146   xfree (data);
1147   if (i != 20 || *s)
1148     {
1149       tty_printf (_("Error: invalid formatted fingerprint.\n"));
1150       return -1;
1151     }
1152
1153   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
1154                           fprno==2?"CA-FPR-2":
1155                           fprno==3?"CA-FPR-3":"x", fpr, 20, NULL );
1156   if (rc)
1157     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
1158   write_sc_op_status (rc);
1159   return rc;
1160 }
1161
1162
1163
1164 static void
1165 toggle_forcesig (void)
1166 {
1167   struct agent_card_info_s info;
1168   int rc;
1169   int newstate;
1170
1171   memset (&info, 0, sizeof info);
1172   rc = agent_scd_getattr ("CHV-STATUS", &info);
1173   if (rc)
1174     {
1175       log_error ("error getting current status: %s\n", gpg_strerror (rc));
1176       return;
1177     }
1178   newstate = !info.chv1_cached;
1179   agent_release_card_info (&info);
1180
1181   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1, NULL);
1182   if (rc)
1183     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
1184   write_sc_op_status (rc);
1185 }
1186
1187
1188 /* Helper for the key generation/edit functions.  */
1189 static int
1190 get_info_for_key_operation (struct agent_card_info_s *info)
1191 {
1192   int rc;
1193
1194   memset (info, 0, sizeof *info);
1195   rc = agent_scd_getattr ("SERIALNO", info);
1196   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12)
1197       || strlen (info->serialno) != 32 )
1198     {
1199       log_error (_("key operation not possible: %s\n"),
1200                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
1201       return rc? rc: -1;
1202     }
1203   rc = agent_scd_getattr ("KEY-FPR", info);
1204   if (!rc)
1205     rc = agent_scd_getattr ("CHV-STATUS", info);
1206   if (!rc)
1207     rc = agent_scd_getattr ("DISP-NAME", info);
1208   if (!rc)
1209     rc = agent_scd_getattr ("EXTCAP", info);
1210   if (!rc)
1211     rc = agent_scd_getattr ("KEY-ATTR", info);
1212   if (rc)
1213     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
1214   return rc;
1215 }
1216
1217
1218 /* Helper for the key generation/edit functions.  */
1219 static int
1220 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
1221 {
1222   int rc = 0;
1223
1224   agent_clear_pin_cache (info->serialno);
1225
1226   *forced_chv1 = !info->chv1_cached;
1227   if (*forced_chv1)
1228     { /* Switch off the forced mode so that during key generation we
1229          don't get bothered with PIN queries for each
1230          self-signature. */
1231       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1, info->serialno);
1232       if (rc)
1233         {
1234           log_error ("error clearing forced signature PIN flag: %s\n",
1235                      gpg_strerror (rc));
1236           *forced_chv1 = 0;
1237         }
1238     }
1239
1240   if (!rc)
1241     {
1242       /* Check the PIN now, so that we won't get asked later for each
1243          binding signature. */
1244       rc = agent_scd_checkpin (info->serialno);
1245       if (rc)
1246         {
1247           log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
1248           write_sc_op_status (rc);
1249         }
1250   }
1251   return rc;
1252 }
1253
1254 /* Helper for the key generation/edit functions.  */
1255 static void
1256 restore_forced_chv1 (int *forced_chv1)
1257 {
1258   int rc;
1259
1260   if (*forced_chv1)
1261     { /* Switch back to forced state. */
1262       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1, NULL);
1263       if (rc)
1264         {
1265           log_error ("error setting forced signature PIN flag: %s\n",
1266                      gpg_strerror (rc));
1267         }
1268     }
1269 }
1270
1271
1272 /* Helper for the key generation/edit functions.  */
1273 static void
1274 show_card_key_info (struct agent_card_info_s *info)
1275 {
1276   tty_fprintf (NULL, "Signature key ....:");
1277   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
1278   tty_fprintf (NULL, "Encryption key....:");
1279   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
1280   tty_fprintf (NULL, "Authentication key:");
1281   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
1282   tty_printf ("\n");
1283 }
1284
1285
1286 /* Helper for the key generation/edit functions.  */
1287 static int
1288 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
1289 {
1290   log_assert (keyno >= 0 && keyno <= 3);
1291
1292   if ((keyno == 1 && info->fpr1valid)
1293       || (keyno == 2 && info->fpr2valid)
1294       || (keyno == 3 && info->fpr3valid))
1295     {
1296       tty_printf ("\n");
1297       log_info ("WARNING: such a key has already been stored on the card!\n");
1298       tty_printf ("\n");
1299       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
1300                                   _("Replace existing key? (y/N) ")))
1301         return -1;
1302       return 1;
1303     }
1304   return 0;
1305 }
1306
1307
1308 static void
1309 show_keysize_warning (void)
1310 {
1311   static int shown;
1312
1313   if (shown)
1314     return;
1315   shown = 1;
1316   tty_printf
1317     (_("Note: There is no guarantee that the card "
1318        "supports the requested size.\n"
1319        "      If the key generation does not succeed, "
1320        "please check the\n"
1321        "      documentation of your card to see what "
1322        "sizes are allowed.\n"));
1323 }
1324
1325
1326 /* Ask for the size of a card key.  NBITS is the current size
1327    configured for the card.  KEYNO is the number of the key used to
1328    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1329    or the selected size.  */
1330 static unsigned int
1331 ask_card_keyattr (int keyno, unsigned int nbits)
1332 {
1333   unsigned int min_nbits = 1024;
1334   unsigned int max_nbits = 4096;
1335   char *prompt, *answer;
1336   unsigned int req_nbits;
1337
1338   for (;;)
1339     {
1340       prompt = xasprintf
1341         (keyno == 0?
1342          _("What keysize do you want for the Signature key? (%u) "):
1343          keyno == 1?
1344          _("What keysize do you want for the Encryption key? (%u) "):
1345          _("What keysize do you want for the Authentication key? (%u) "),
1346          nbits);
1347       answer = cpr_get ("cardedit.genkeys.size", prompt);
1348       cpr_kill_prompt ();
1349       req_nbits = *answer? atoi (answer): nbits;
1350       xfree (prompt);
1351       xfree (answer);
1352
1353       if (req_nbits != nbits && (req_nbits % 32) )
1354         {
1355           req_nbits = ((req_nbits + 31) / 32) * 32;
1356           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1357         }
1358
1359       if (req_nbits == nbits)
1360         return 0;  /* Use default.  */
1361
1362       if (req_nbits < min_nbits || req_nbits > max_nbits)
1363         {
1364           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1365                       "RSA", min_nbits, max_nbits);
1366         }
1367       else
1368         {
1369           tty_printf (_("The card will now be re-configured "
1370                         "to generate a key of %u bits\n"), req_nbits);
1371           show_keysize_warning ();
1372           return req_nbits;
1373         }
1374     }
1375 }
1376
1377
1378 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1379    message if that fails.  */
1380 static gpg_error_t
1381 do_change_keyattr (int keyno, unsigned int nbits)
1382 {
1383   gpg_error_t err;
1384   char args[100];
1385
1386   snprintf (args, sizeof args, "--force %d 1 rsa%u", keyno+1, nbits);
1387   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1388   if (err)
1389     log_error (_("error changing size of key %d to %u bits: %s\n"),
1390                keyno+1, nbits, gpg_strerror (err));
1391   return err;
1392 }
1393
1394
1395 static void
1396 generate_card_keys (ctrl_t ctrl)
1397 {
1398   struct agent_card_info_s info;
1399   int forced_chv1;
1400   int want_backup;
1401   int keyno;
1402
1403   if (get_info_for_key_operation (&info))
1404     return;
1405
1406   if (info.extcap.ki)
1407     {
1408       char *answer;
1409
1410       /* FIXME: Should be something like cpr_get_bool so that a status
1411          GET_BOOL will be emitted.  */
1412       answer = cpr_get ("cardedit.genkeys.backup_enc",
1413                         _("Make off-card backup of encryption key? (Y/n) "));
1414
1415       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1416       cpr_kill_prompt ();
1417       xfree (answer);
1418     }
1419   else
1420     want_backup = 0;
1421
1422   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1423        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1424        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1425     {
1426       tty_printf ("\n");
1427       log_info (_("Note: keys are already stored on the card!\n"));
1428       tty_printf ("\n");
1429       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1430                                    _("Replace existing keys? (y/N) ")))
1431         {
1432           agent_release_card_info (&info);
1433           return;
1434         }
1435     }
1436
1437   /* If no displayed name has been set, we assume that this is a fresh
1438      card and print a hint about the default PINs.  */
1439   if (!info.disp_name || !*info.disp_name)
1440     {
1441       tty_printf ("\n");
1442       tty_printf (_("Please note that the factory settings of the PINs are\n"
1443                     "   PIN = '%s'     Admin PIN = '%s'\n"
1444                     "You should change them using the command --change-pin\n"),
1445                   "123456", "12345678");
1446       tty_printf ("\n");
1447     }
1448
1449   if (check_pin_for_key_operation (&info, &forced_chv1))
1450     goto leave;
1451
1452   /* If the cards features changeable key attributes, we ask for the
1453      key size.  */
1454   if (info.is_v2 && info.extcap.aac)
1455     {
1456       unsigned int nbits;
1457
1458       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1459         {
1460           if (info.key_attr[keyno].algo == PUBKEY_ALGO_RSA)
1461             {
1462               nbits = ask_card_keyattr (keyno, info.key_attr[keyno].nbits);
1463               if (nbits && do_change_keyattr (keyno, nbits))
1464                 {
1465                   /* Error: Better read the default key size again.  */
1466                   agent_release_card_info (&info);
1467                   if (get_info_for_key_operation (&info))
1468                     goto leave;
1469                   /* Ask again for this key size. */
1470                   keyno--;
1471                 }
1472             }
1473         }
1474       /* Note that INFO has not be synced.  However we will only use
1475          the serialnumber and thus it won't harm.  */
1476     }
1477
1478   generate_keypair (ctrl, 1, NULL, info.serialno, want_backup);
1479
1480  leave:
1481   agent_release_card_info (&info);
1482   restore_forced_chv1 (&forced_chv1);
1483 }
1484
1485
1486 /* This function is used by the key edit menu to generate an arbitrary
1487    subkey. */
1488 gpg_error_t
1489 card_generate_subkey (ctrl_t ctrl, kbnode_t pub_keyblock)
1490 {
1491   gpg_error_t err;
1492   struct agent_card_info_s info;
1493   int forced_chv1 = 0;
1494   int keyno;
1495
1496   err = get_info_for_key_operation (&info);
1497   if (err)
1498     return err;
1499
1500   show_card_key_info (&info);
1501
1502   tty_printf (_("Please select the type of key to generate:\n"));
1503
1504   tty_printf (_("   (1) Signature key\n"));
1505   tty_printf (_("   (2) Encryption key\n"));
1506   tty_printf (_("   (3) Authentication key\n"));
1507
1508   for (;;)
1509     {
1510       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1511                               _("Your selection? "));
1512       cpr_kill_prompt();
1513       if (*answer == CONTROL_D)
1514         {
1515           xfree (answer);
1516           err = gpg_error (GPG_ERR_CANCELED);
1517           goto leave;
1518         }
1519       keyno = *answer? atoi(answer): 0;
1520       xfree(answer);
1521       if (keyno >= 1 && keyno <= 3)
1522         break; /* Okay. */
1523       tty_printf(_("Invalid selection.\n"));
1524     }
1525
1526   if (replace_existing_key_p (&info, keyno) < 0)
1527     {
1528       err = gpg_error (GPG_ERR_CANCELED);
1529       goto leave;
1530     }
1531
1532   err = check_pin_for_key_operation (&info, &forced_chv1);
1533   if (err)
1534     goto leave;
1535
1536   /* If the cards features changeable key attributes, we ask for the
1537      key size.  */
1538   if (info.is_v2 && info.extcap.aac)
1539     {
1540       if (info.key_attr[keyno-1].algo == PUBKEY_ALGO_RSA)
1541         {
1542           unsigned int nbits;
1543
1544         ask_again:
1545           nbits = ask_card_keyattr (keyno-1, info.key_attr[keyno-1].nbits);
1546           if (nbits && do_change_keyattr (keyno-1, nbits))
1547             {
1548               /* Error: Better read the default key size again.  */
1549               agent_release_card_info (&info);
1550               err = get_info_for_key_operation (&info);
1551               if (err)
1552                 goto leave;
1553               goto ask_again;
1554             }
1555         }
1556       /* Note that INFO has not be synced.  However we will only use
1557          the serialnumber and thus it won't harm.  */
1558     }
1559
1560   err = generate_card_subkeypair (ctrl, pub_keyblock, keyno, info.serialno);
1561
1562  leave:
1563   agent_release_card_info (&info);
1564   restore_forced_chv1 (&forced_chv1);
1565   return err;
1566 }
1567
1568
1569 /* Store the key at NODE into the smartcard and modify NODE to
1570    carry the serialno stuff instead of the actual secret key
1571    parameters.  USE is the usage for that key; 0 means any
1572    usage. */
1573 int
1574 card_store_subkey (KBNODE node, int use)
1575 {
1576   struct agent_card_info_s info;
1577   int okay = 0;
1578   unsigned int nbits;
1579   int allow_keyno[3];
1580   int  keyno;
1581   PKT_public_key *pk;
1582   gpg_error_t err;
1583   char *hexgrip;
1584   int rc;
1585   gnupg_isotime_t timebuf;
1586
1587   log_assert (node->pkt->pkttype == PKT_PUBLIC_KEY
1588               || node->pkt->pkttype == PKT_PUBLIC_SUBKEY);
1589
1590   pk = node->pkt->pkt.public_key;
1591
1592   if (get_info_for_key_operation (&info))
1593     return 0;
1594
1595   if (!info.extcap.ki)
1596     {
1597       tty_printf ("The card does not support the import of keys\n");
1598       tty_printf ("\n");
1599       goto leave;
1600     }
1601
1602   nbits = nbits_from_pk (pk);
1603
1604   if (!info.is_v2 && nbits != 1024)
1605     {
1606       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1607       tty_printf ("\n");
1608       goto leave;
1609     }
1610
1611   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_CERT)));
1612   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1613   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1614
1615   tty_printf (_("Please select where to store the key:\n"));
1616
1617   if (allow_keyno[0])
1618     tty_printf (_("   (1) Signature key\n"));
1619   if (allow_keyno[1])
1620     tty_printf (_("   (2) Encryption key\n"));
1621   if (allow_keyno[2])
1622     tty_printf (_("   (3) Authentication key\n"));
1623
1624   for (;;)
1625     {
1626       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1627                               _("Your selection? "));
1628       cpr_kill_prompt();
1629       if (*answer == CONTROL_D || !*answer)
1630         {
1631           xfree (answer);
1632           goto leave;
1633         }
1634       keyno = *answer? atoi(answer): 0;
1635       xfree(answer);
1636       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1637         {
1638           if (info.is_v2 && !info.extcap.aac
1639               && info.key_attr[keyno-1].nbits != nbits)
1640             {
1641               tty_printf ("Key does not match the card's capability.\n");
1642             }
1643           else
1644             break; /* Okay. */
1645         }
1646       else
1647         tty_printf(_("Invalid selection.\n"));
1648     }
1649
1650   if ((rc = replace_existing_key_p (&info, keyno)) < 0)
1651     goto leave;
1652
1653   err = hexkeygrip_from_pk (pk, &hexgrip);
1654   if (err)
1655     goto leave;
1656
1657   epoch2isotime (timebuf, (time_t)pk->timestamp);
1658   rc = agent_keytocard (hexgrip, keyno, rc, info.serialno, timebuf);
1659
1660   if (rc)
1661     log_error (_("KEYTOCARD failed: %s\n"), gpg_strerror (rc));
1662   else
1663     okay = 1;
1664   xfree (hexgrip);
1665
1666  leave:
1667   agent_release_card_info (&info);
1668   return okay;
1669 }
1670
1671
1672
1673 /* Direct sending of an hex encoded APDU with error printing.  */
1674 static gpg_error_t
1675 send_apdu (const char *hexapdu, const char *desc, unsigned int ignore)
1676 {
1677   gpg_error_t err;
1678   unsigned int sw;
1679
1680   err = agent_scd_apdu (hexapdu, &sw);
1681   if (err)
1682     tty_printf ("sending card command %s failed: %s\n", desc,
1683                 gpg_strerror (err));
1684   else if (!hexapdu || !strcmp (hexapdu, "undefined"))
1685     ;
1686   else if (ignore == 0xffff)
1687     ; /* Ignore all status words.  */
1688   else if (sw != 0x9000)
1689     {
1690       switch (sw)
1691         {
1692         case 0x6285: err = gpg_error (GPG_ERR_OBJ_TERM_STATE); break;
1693         case 0x6982: err = gpg_error (GPG_ERR_BAD_PIN); break;
1694         case 0x6985: err = gpg_error (GPG_ERR_USE_CONDITIONS); break;
1695         default: err = gpg_error (GPG_ERR_CARD);
1696         }
1697       if (!(ignore && ignore == sw))
1698         tty_printf ("card command %s failed: %s (0x%04x)\n", desc,
1699                     gpg_strerror (err),  sw);
1700     }
1701   return err;
1702 }
1703
1704
1705 /* Do a factory reset after confirmation.  */
1706 static void
1707 factory_reset (void)
1708 {
1709   struct agent_card_info_s info;
1710   gpg_error_t err;
1711   char *answer = NULL;
1712   int termstate = 0;
1713   int i;
1714
1715   /*  The code below basically does the same what this
1716       gpg-connect-agent script does:
1717
1718         scd reset
1719         scd serialno undefined
1720         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1721         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
1722         scd apdu 00 20 00 81 08 40 40 40 40 40 40 40 40
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 83 08 40 40 40 40 40 40 40 40
1726         scd apdu 00 20 00 83 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 e6 00 00
1730         scd reset
1731         scd serialno undefined
1732         scd apdu 00 A4 04 00 06 D2 76 00 01 24 01
1733         scd apdu 00 44 00 00
1734         /echo Card has been reset to factory defaults
1735
1736       but tries to find out something about the card first.
1737    */
1738
1739   err = agent_scd_learn (&info, 0);
1740   if (gpg_err_code (err) == GPG_ERR_OBJ_TERM_STATE
1741       && gpg_err_source (err) == GPG_ERR_SOURCE_SCD)
1742     termstate = 1;
1743   else if (err)
1744     {
1745       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (err));
1746       return;
1747     }
1748
1749   if (!termstate)
1750     {
1751       log_info (_("OpenPGP card no. %s detected\n"),
1752                 info.serialno? info.serialno : "[none]");
1753       if (!(info.status_indicator == 3 || info.status_indicator == 5))
1754         {
1755           /* Note: We won't see status-indicator 3 here because it is not
1756              possible to select a card application in termination state.  */
1757           log_error (_("This command is not supported by this card\n"));
1758           goto leave;
1759         }
1760
1761       tty_printf ("\n");
1762       log_info (_("Note: This command destroys all keys stored on the card!\n"));
1763       tty_printf ("\n");
1764       if (!cpr_get_answer_is_yes ("cardedit.factory-reset.proceed",
1765                                   _("Continue? (y/N) ")))
1766         goto leave;
1767
1768
1769       answer = cpr_get ("cardedit.factory-reset.really",
1770                         _("Really do a factory reset? (enter \"yes\") "));
1771       cpr_kill_prompt ();
1772       trim_spaces (answer);
1773       if (strcmp (answer, "yes"))
1774         goto leave;
1775
1776       /* We need to select a card application before we can send APDUs
1777          to the card without scdaemon doing anything on its own.  */
1778       err = send_apdu (NULL, "RESET", 0);
1779       if (err)
1780         goto leave;
1781       err = send_apdu ("undefined", "dummy select ", 0);
1782       if (err)
1783         goto leave;
1784
1785       /* Select the OpenPGP application.  */
1786       err = send_apdu ("00A4040006D27600012401", "SELECT AID", 0);
1787       if (err)
1788         goto leave;
1789
1790       /* Do some dummy verifies with wrong PINs to set the retry
1791          counter to zero.  We can't easily use the card version 2.1
1792          feature of presenting the admin PIN to allow the terminate
1793          command because there is no machinery in scdaemon to catch
1794          the verify command and ask for the PIN when the "APDU"
1795          command is used. */
1796       for (i=0; i < 4; i++)
1797         send_apdu ("00200081084040404040404040", "VERIFY", 0xffff);
1798       for (i=0; i < 4; i++)
1799         send_apdu ("00200083084040404040404040", "VERIFY", 0xffff);
1800
1801       /* Send terminate datafile command.  */
1802       err = send_apdu ("00e60000", "TERMINATE DF", 0x6985);
1803       if (err)
1804         goto leave;
1805     }
1806
1807   /* The card is in termination state - reset and select again.  */
1808   err = send_apdu (NULL, "RESET", 0);
1809   if (err)
1810     goto leave;
1811   err = send_apdu ("undefined", "dummy select", 0);
1812   if (err)
1813     goto leave;
1814
1815   /* Select the OpenPGP application. (no error checking here). */
1816   send_apdu ("00A4040006D27600012401", "SELECT AID", 0xffff);
1817
1818   /* Send activate datafile command.  This is used without
1819      confirmation if the card is already in termination state.  */
1820   err = send_apdu ("00440000", "ACTIVATE DF", 0);
1821   if (err)
1822     goto leave;
1823
1824   /* Finally we reset the card reader once more.  */
1825   err = send_apdu (NULL, "RESET", 0);
1826   if (err)
1827     goto leave;
1828
1829  leave:
1830   xfree (answer);
1831   agent_release_card_info (&info);
1832 }
1833
1834
1835 \f
1836 /* Data used by the command parser.  This needs to be outside of the
1837    function scope to allow readline based command completion.  */
1838 enum cmdids
1839   {
1840     cmdNOP = 0,
1841     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1842     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1843     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1844     cmdREADCERT, cmdUNBLOCK, cmdFACTORYRESET,
1845     cmdINVCMD
1846   };
1847
1848 static struct
1849 {
1850   const char *name;
1851   enum cmdids id;
1852   int admin_only;
1853   const char *desc;
1854 } cmds[] =
1855   {
1856     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1857     { "q"       , cmdQUIT  , 0, NULL },
1858     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1859     { "help"    , cmdHELP  , 0, N_("show this help")},
1860     { "?"       , cmdHELP  , 0, NULL },
1861     { "list"    , cmdLIST  , 0, N_("list all available data")},
1862     { "l"       , cmdLIST  , 0, NULL },
1863     { "debug"   , cmdDEBUG , 0, NULL },
1864     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1865     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1866     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1867     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1868     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1869     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1870     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1871     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1872     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1873     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1874     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1875     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1876     { "factory-reset", cmdFACTORYRESET, 1, N_("destroy all keys and data")},
1877     /* Note, that we do not announce these command yet. */
1878     { "privatedo", cmdPRIVATEDO, 0, NULL },
1879     { "readcert", cmdREADCERT, 0, NULL },
1880     { "writecert", cmdWRITECERT, 1, NULL },
1881     { NULL, cmdINVCMD, 0, NULL }
1882   };
1883
1884
1885 #ifdef HAVE_LIBREADLINE
1886
1887 /* These two functions are used by readline for command completion. */
1888
1889 static char *
1890 command_generator(const char *text,int state)
1891 {
1892   static int list_index,len;
1893   const char *name;
1894
1895   /* If this is a new word to complete, initialize now.  This includes
1896      saving the length of TEXT for efficiency, and initializing the
1897      index variable to 0. */
1898   if(!state)
1899     {
1900       list_index=0;
1901       len=strlen(text);
1902     }
1903
1904   /* Return the next partial match */
1905   while((name=cmds[list_index].name))
1906     {
1907       /* Only complete commands that have help text */
1908       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1909         return strdup(name);
1910     }
1911
1912   return NULL;
1913 }
1914
1915 static char **
1916 card_edit_completion(const char *text, int start, int end)
1917 {
1918   (void)end;
1919   /* If we are at the start of a line, we try and command-complete.
1920      If not, just do nothing for now. */
1921
1922   if(start==0)
1923     return rl_completion_matches(text,command_generator);
1924
1925   rl_attempted_completion_over=1;
1926
1927   return NULL;
1928 }
1929 #endif /*HAVE_LIBREADLINE*/
1930
1931 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1932    Key creation is not handled here. */
1933 void
1934 card_edit (ctrl_t ctrl, strlist_t commands)
1935 {
1936   enum cmdids cmd = cmdNOP;
1937   int have_commands = !!commands;
1938   int redisplay = 1;
1939   char *answer = NULL;
1940   int allow_admin=0;
1941   char serialnobuf[50];
1942
1943
1944   if (opt.command_fd != -1)
1945     ;
1946   else if (opt.batch && !have_commands)
1947     {
1948       log_error(_("can't do this in batch mode\n"));
1949       goto leave;
1950     }
1951
1952   for (;;)
1953     {
1954       int arg_number;
1955       const char *arg_string = "";
1956       const char *arg_rest = "";
1957       char *p;
1958       int i;
1959       int cmd_admin_only;
1960
1961       tty_printf("\n");
1962       if (redisplay)
1963         {
1964           if (opt.with_colons)
1965             {
1966               current_card_status (ctrl, es_stdout,
1967                                    serialnobuf, DIM (serialnobuf));
1968               fflush (stdout);
1969             }
1970           else
1971             {
1972               current_card_status (ctrl, NULL,
1973                                    serialnobuf, DIM (serialnobuf));
1974               tty_printf("\n");
1975             }
1976           redisplay = 0;
1977         }
1978
1979       do
1980         {
1981           xfree (answer);
1982           if (have_commands)
1983             {
1984               if (commands)
1985                 {
1986                   answer = xstrdup (commands->d);
1987                   commands = commands->next;
1988                 }
1989               else if (opt.batch)
1990                 {
1991                   answer = xstrdup ("quit");
1992                 }
1993               else
1994                 have_commands = 0;
1995             }
1996
1997             if (!have_commands)
1998               {
1999                 tty_enable_completion (card_edit_completion);
2000                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
2001                 cpr_kill_prompt();
2002                 tty_disable_completion ();
2003               }
2004             trim_spaces(answer);
2005         }
2006       while ( *answer == '#' );
2007
2008       arg_number = 0; /* Yes, here is the init which egcc complains about */
2009       cmd_admin_only = 0;
2010       if (!*answer)
2011         cmd = cmdLIST; /* Default to the list command */
2012       else if (*answer == CONTROL_D)
2013         cmd = cmdQUIT;
2014       else
2015         {
2016           if ((p=strchr (answer,' ')))
2017             {
2018               *p++ = 0;
2019               trim_spaces (answer);
2020               trim_spaces (p);
2021               arg_number = atoi(p);
2022               arg_string = p;
2023               arg_rest = p;
2024               while (digitp (arg_rest))
2025                 arg_rest++;
2026               while (spacep (arg_rest))
2027                 arg_rest++;
2028             }
2029
2030           for (i=0; cmds[i].name; i++ )
2031             if (!ascii_strcasecmp (answer, cmds[i].name ))
2032               break;
2033
2034           cmd = cmds[i].id;
2035           cmd_admin_only = cmds[i].admin_only;
2036         }
2037
2038       if (!allow_admin && cmd_admin_only)
2039         {
2040           tty_printf ("\n");
2041           tty_printf (_("Admin-only command\n"));
2042           continue;
2043         }
2044
2045       switch (cmd)
2046         {
2047         case cmdHELP:
2048           for (i=0; cmds[i].name; i++ )
2049             if(cmds[i].desc
2050                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
2051               tty_printf("%-14s %s\n", cmds[i].name, _(cmds[i].desc) );
2052           break;
2053
2054         case cmdADMIN:
2055           if ( !strcmp (arg_string, "on") )
2056             allow_admin = 1;
2057           else if ( !strcmp (arg_string, "off") )
2058             allow_admin = 0;
2059           else if ( !strcmp (arg_string, "verify") )
2060             {
2061               /* Force verification of the Admin Command.  However,
2062                  this is only done if the retry counter is at initial
2063                  state.  */
2064               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
2065               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
2066               allow_admin = !agent_scd_checkpin (tmp);
2067               xfree (tmp);
2068             }
2069           else /* Toggle. */
2070             allow_admin=!allow_admin;
2071           if(allow_admin)
2072             tty_printf(_("Admin commands are allowed\n"));
2073           else
2074             tty_printf(_("Admin commands are not allowed\n"));
2075           break;
2076
2077         case cmdVERIFY:
2078           agent_scd_checkpin (serialnobuf);
2079           redisplay = 1;
2080           break;
2081
2082         case cmdLIST:
2083           redisplay = 1;
2084           break;
2085
2086         case cmdNAME:
2087           change_name ();
2088           break;
2089
2090         case cmdURL:
2091           change_url ();
2092           break;
2093
2094         case cmdFETCH:
2095           fetch_url (ctrl);
2096           break;
2097
2098         case cmdLOGIN:
2099           change_login (arg_string);
2100           break;
2101
2102         case cmdLANG:
2103           change_lang ();
2104           break;
2105
2106         case cmdSEX:
2107           change_sex ();
2108           break;
2109
2110         case cmdCAFPR:
2111           if ( arg_number < 1 || arg_number > 3 )
2112             tty_printf ("usage: cafpr N\n"
2113                         "       1 <= N <= 3\n");
2114           else
2115             change_cafpr (arg_number);
2116           break;
2117
2118         case cmdPRIVATEDO:
2119           if ( arg_number < 1 || arg_number > 4 )
2120             tty_printf ("usage: privatedo N\n"
2121                         "       1 <= N <= 4\n");
2122           else
2123             change_private_do (arg_string, arg_number);
2124           break;
2125
2126         case cmdWRITECERT:
2127           if ( arg_number != 3 )
2128             tty_printf ("usage: writecert 3 < FILE\n");
2129           else
2130             change_cert (arg_rest);
2131           break;
2132
2133         case cmdREADCERT:
2134           if ( arg_number != 3 )
2135             tty_printf ("usage: readcert 3 > FILE\n");
2136           else
2137             read_cert (arg_rest);
2138           break;
2139
2140         case cmdFORCESIG:
2141           toggle_forcesig ();
2142           break;
2143
2144         case cmdGENERATE:
2145           generate_card_keys (ctrl);
2146           break;
2147
2148         case cmdPASSWD:
2149           change_pin (0, allow_admin);
2150           break;
2151
2152         case cmdUNBLOCK:
2153           change_pin (1, allow_admin);
2154           break;
2155
2156         case cmdFACTORYRESET:
2157           factory_reset ();
2158           break;
2159
2160         case cmdQUIT:
2161           goto leave;
2162
2163         case cmdNOP:
2164           break;
2165
2166         case cmdINVCMD:
2167         default:
2168           tty_printf ("\n");
2169           tty_printf (_("Invalid command  (try \"help\")\n"));
2170           break;
2171         } /* End command switch. */
2172     } /* End of main menu loop. */
2173
2174  leave:
2175   xfree (answer);
2176 }