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