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