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