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