Add an OpenPGP card vendor.
[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     }
1268   return 0;
1269 }
1270
1271
1272 static void
1273 show_keysize_warning (void)
1274 {
1275   static int shown;
1276
1277   if (shown)
1278     return;
1279   shown = 1;
1280   tty_printf
1281     (_("NOTE: There is no guarantee that the card "
1282        "supports the requested size.\n"
1283        "      If the key generation does not succeed, "
1284        "please check the\n"
1285        "      documentation of your card to see what "
1286        "sizes are allowed.\n"));
1287 }
1288
1289
1290 /* Ask for the size of a card key.  NBITS is the current size
1291    configured for the card.  KEYNO is the number of the key used to
1292    select the prompt.  Returns 0 to use the default size (i.e. NBITS)
1293    or the selected size.  */
1294 static unsigned int
1295 ask_card_keysize (int keyno, unsigned int nbits)
1296 {
1297   unsigned int min_nbits = 1024;
1298   unsigned int max_nbits = 4096;
1299   char *prompt, *answer;
1300   unsigned int req_nbits;
1301
1302   for (;;)
1303     {
1304       prompt = xasprintf
1305         (keyno == 0?
1306          _("What keysize do you want for the Signature key? (%u) "):
1307          keyno == 1?
1308          _("What keysize do you want for the Encryption key? (%u) "):
1309          _("What keysize do you want for the Authentication key? (%u) "),
1310          nbits);
1311       answer = cpr_get ("cardedit.genkeys.size", prompt);
1312       cpr_kill_prompt ();
1313       req_nbits = *answer? atoi (answer): nbits;
1314       xfree (prompt);
1315       xfree (answer);
1316
1317       if (req_nbits != nbits && (req_nbits % 32) )
1318         {
1319           req_nbits = ((req_nbits + 31) / 32) * 32;
1320           tty_printf (_("rounded up to %u bits\n"), req_nbits);
1321         }
1322
1323       if (req_nbits == nbits)
1324         return 0;  /* Use default.  */
1325
1326       if (req_nbits < min_nbits || req_nbits > max_nbits)
1327         {
1328           tty_printf (_("%s keysizes must be in the range %u-%u\n"),
1329                       "RSA", min_nbits, max_nbits);
1330         }
1331       else
1332         {
1333           tty_printf (_("The card will now be re-configured "
1334                         "to generate a key of %u bits\n"), req_nbits);
1335           show_keysize_warning ();
1336           return req_nbits;
1337         }
1338     }
1339 }
1340
1341
1342 /* Change the size of key KEYNO (0..2) to NBITS and show an error
1343    message if that fails.  */
1344 static gpg_error_t
1345 do_change_keysize (int keyno, unsigned int nbits)
1346 {
1347   gpg_error_t err;
1348   char args[100];
1349
1350   snprintf (args, sizeof args, "--force %d 1 %u", keyno+1, nbits);
1351   err = agent_scd_setattr ("KEY-ATTR", args, strlen (args), NULL);
1352   if (err)
1353     log_error (_("error changing size of key %d to %u bits: %s\n"),
1354                keyno+1, nbits, gpg_strerror (err));
1355   return err;
1356 }
1357
1358
1359 static void
1360 generate_card_keys (ctrl_t ctrl)
1361 {
1362   struct agent_card_info_s info;
1363   int forced_chv1;
1364   int want_backup;
1365   int keyno;
1366
1367   if (get_info_for_key_operation (&info))
1368     return;
1369
1370   if (info.extcap.ki)
1371     {
1372       char *answer;
1373
1374       /* FIXME: Should be something like cpr_get_bool so that a status
1375          GET_BOOL will be emitted.  */
1376       answer = cpr_get ("cardedit.genkeys.backup_enc",
1377                         _("Make off-card backup of encryption key? (Y/n) "));
1378
1379       want_backup = answer_is_yes_no_default (answer, 1/*(default to Yes)*/);
1380       cpr_kill_prompt ();
1381       xfree (answer);
1382     }
1383   else
1384     want_backup = 0;
1385
1386   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1387        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1388        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1389     {
1390       tty_printf ("\n");
1391       log_info (_("NOTE: keys are already stored on the card!\n"));
1392       tty_printf ("\n");
1393       if ( !cpr_get_answer_is_yes ("cardedit.genkeys.replace_keys",
1394                                    _("Replace existing keys? (y/N) ")))
1395         {
1396           agent_release_card_info (&info);
1397           return;
1398         }
1399     }
1400
1401   /* If no displayed name has been set, we assume that this is a fresh
1402      card and print a hint about the default PINs.  */
1403   if (!info.disp_name || !*info.disp_name)
1404     {
1405       tty_printf ("\n");
1406       tty_printf (_("Please note that the factory settings of the PINs are\n"
1407                     "   PIN = '%s'     Admin PIN = '%s'\n"
1408                     "You should change them using the command --change-pin\n"),
1409                   "123456", "12345678");
1410       tty_printf ("\n");
1411     }
1412
1413   if (check_pin_for_key_operation (&info, &forced_chv1))
1414     goto leave;
1415
1416   /* If the cards features changeable key attributes, we ask for the
1417      key size.  */
1418   if (info.is_v2 && info.extcap.aac)
1419     {
1420       unsigned int nbits;
1421
1422       for (keyno = 0; keyno < DIM (info.key_attr); keyno++)
1423         {
1424           nbits = ask_card_keysize (keyno, info.key_attr[keyno].nbits);
1425           if (nbits && do_change_keysize (keyno, nbits))
1426             {
1427               /* Error: Better read the default key size again.  */
1428               agent_release_card_info (&info);
1429               if (get_info_for_key_operation (&info))
1430                 goto leave;
1431               /* Ask again for this key size. */
1432               keyno--;
1433             }
1434         }
1435       /* Note that INFO has not be synced.  However we will only use
1436          the serialnumber and thus it won't harm.  */
1437     }
1438
1439   generate_keypair (ctrl, NULL, info.serialno, want_backup);
1440
1441  leave:
1442   agent_release_card_info (&info);
1443   restore_forced_chv1 (&forced_chv1);
1444 }
1445
1446
1447 /* This function is used by the key edit menu to generate an arbitrary
1448    subkey. */
1449 gpg_error_t
1450 card_generate_subkey (KBNODE pub_keyblock)
1451 {
1452   gpg_error_t err;
1453   struct agent_card_info_s info;
1454   int forced_chv1 = 0;
1455   int keyno;
1456
1457   err = get_info_for_key_operation (&info);
1458   if (err)
1459     return err;
1460
1461   show_card_key_info (&info);
1462
1463   tty_printf (_("Please select the type of key to generate:\n"));
1464
1465   tty_printf (_("   (1) Signature key\n"));
1466   tty_printf (_("   (2) Encryption key\n"));
1467   tty_printf (_("   (3) Authentication key\n"));
1468
1469   for (;;)
1470     {
1471       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1472                               _("Your selection? "));
1473       cpr_kill_prompt();
1474       if (*answer == CONTROL_D)
1475         {
1476           xfree (answer);
1477           err = gpg_error (GPG_ERR_CANCELED);
1478           goto leave;
1479         }
1480       keyno = *answer? atoi(answer): 0;
1481       xfree(answer);
1482       if (keyno >= 1 && keyno <= 3)
1483         break; /* Okay. */
1484       tty_printf(_("Invalid selection.\n"));
1485     }
1486
1487   if (replace_existing_key_p (&info, keyno))
1488     {
1489       err = gpg_error (GPG_ERR_CANCELED);
1490       goto leave;
1491     }
1492
1493   err = check_pin_for_key_operation (&info, &forced_chv1);
1494   if (err)
1495     goto leave;
1496
1497   /* If the cards features changeable key attributes, we ask for the
1498      key size.  */
1499   if (info.is_v2 && info.extcap.aac)
1500     {
1501       unsigned int nbits;
1502
1503     ask_again:
1504       nbits = ask_card_keysize (keyno-1, info.key_attr[keyno-1].nbits);
1505       if (nbits && do_change_keysize (keyno-1, nbits))
1506         {
1507           /* Error: Better read the default key size again.  */
1508           agent_release_card_info (&info);
1509           err = get_info_for_key_operation (&info);
1510           if (err)
1511             goto leave;
1512           goto ask_again;
1513         }
1514       /* Note that INFO has not be synced.  However we will only use
1515          the serialnumber and thus it won't harm.  */
1516     }
1517
1518   err = generate_card_subkeypair (pub_keyblock, keyno, info.serialno);
1519
1520  leave:
1521   agent_release_card_info (&info);
1522   restore_forced_chv1 (&forced_chv1);
1523   return err;
1524 }
1525
1526
1527 /* Store the key at NODE into the smartcard and modify NODE to
1528    carry the serialno stuff instead of the actual secret key
1529    parameters.  USE is the usage for that key; 0 means any
1530    usage. */
1531 int
1532 card_store_subkey (KBNODE node, int use)
1533 {
1534   log_info ("FIXME: card_store_subkey has not yet been implemented\n");
1535 /*   struct agent_card_info_s info; */
1536 /*   int okay = 0; */
1537 /*   int rc; */
1538 /*   int keyno, i; */
1539 /*   PKT_secret_key *copied_sk = NULL; */
1540 /*   PKT_secret_key *sk; */
1541 /*   size_t n; */
1542 /*   const char *s; */
1543 /*   int allow_keyno[3]; */
1544 /*   unsigned int nbits; */
1545
1546
1547 /*   assert (node->pkt->pkttype == PKT_SECRET_KEY */
1548 /*           || node->pkt->pkttype == PKT_SECRET_SUBKEY); */
1549 /*   sk = node->pkt->pkt.secret_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 /*   show_card_key_info (&info); */
1562
1563 /*   nbits = nbits_from_sk (sk); */
1564
1565 /*   if (!is_RSA (sk->pubkey_algo) || (!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 (replace_existing_key_p (&info, keyno)) */
1612 /*     goto leave; */
1613
1614 /*   /\* Unprotect key.  *\/ */
1615 /*   switch (is_secret_key_protected (sk) ) */
1616 /*     { */
1617 /*     case 0: /\* Not protected. *\/ */
1618 /*       break; */
1619 /*     case -1: */
1620 /*       log_error (_("unknown key protection algorithm\n")); */
1621 /*       goto leave; */
1622 /*     default: */
1623 /*       if (sk->protect.s2k.mode == 1001) */
1624 /*         { */
1625 /*           log_error (_("secret parts of key are not available\n")); */
1626 /*           goto leave; */
1627 /*      } */
1628 /*       if (sk->protect.s2k.mode == 1002) */
1629 /*         { */
1630 /*           log_error (_("secret key already stored on a card\n")); */
1631 /*           goto leave; */
1632 /*      } */
1633 /*       /\* We better copy the key before we unprotect it.  *\/ */
1634 /*       copied_sk = sk = copy_secret_key (NULL, sk); */
1635 /*       rc = 0/\*check_secret_key (sk, 0)*\/; */
1636 /*       if (rc) */
1637 /*         goto leave; */
1638 /*     } */
1639
1640 /* #warning code save_unprotected_key_to_card */
1641 /*   /\* rc = save_unprotected_key_to_card (sk, keyno); *\/ */
1642 /*   /\* if (rc) *\/ */
1643 /*   /\*   { *\/ */
1644 /*   /\*     log_error (_("error writing key to card: %s\n"), gpg_strerror (rc)); *\/ */
1645 /*   /\*     goto leave; *\/ */
1646 /*   /\*   } *\/ */
1647
1648 /*   /\* Get back to the maybe protected original secret key.  *\/ */
1649 /*   if (copied_sk) */
1650 /*     { */
1651 /*       free_secret_key (copied_sk); */
1652 /*       copied_sk = NULL;  */
1653 /*     } */
1654 /*   sk = node->pkt->pkt.secret_key; */
1655
1656 /*   /\* Get rid of the secret key parameters and store the serial numer. *\/ */
1657 /*   n = pubkey_get_nskey (sk->pubkey_algo); */
1658 /*   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++) */
1659 /*     { */
1660 /*       gcry_mpi_release (sk->skey[i]); */
1661 /*       sk->skey[i] = NULL; */
1662 /*     } */
1663 /*   i = pubkey_get_npkey (sk->pubkey_algo); */
1664 /*   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8); */
1665 /*   sk->is_protected = 1; */
1666 /*   sk->protect.s2k.mode = 1002; */
1667 /*   s = info.serialno; */
1668 /*   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1]; */
1669 /*        sk->protect.ivlen++, s += 2) */
1670 /*     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s); */
1671
1672 /*   okay = 1; */
1673
1674 /*  leave: */
1675 /*   if (copied_sk) */
1676 /*     free_secret_key (copied_sk); */
1677 /*   agent_release_card_info (&info); */
1678 /*   return okay; */
1679   return -1;
1680 }
1681
1682
1683 \f
1684 /* Data used by the command parser.  This needs to be outside of the
1685    function scope to allow readline based command completion.  */
1686 enum cmdids
1687   {
1688     cmdNOP = 0,
1689     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1690     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1691     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1692     cmdREADCERT, cmdUNBLOCK,
1693     cmdINVCMD
1694   };
1695
1696 static struct
1697 {
1698   const char *name;
1699   enum cmdids id;
1700   int admin_only;
1701   const char *desc;
1702 } cmds[] =
1703   {
1704     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1705     { "q"       , cmdQUIT  , 0, NULL },
1706     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1707     { "help"    , cmdHELP  , 0, N_("show this help")},
1708     { "?"       , cmdHELP  , 0, NULL },
1709     { "list"    , cmdLIST  , 0, N_("list all available data")},
1710     { "l"       , cmdLIST  , 0, NULL },
1711     { "debug"   , cmdDEBUG , 0, NULL },
1712     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1713     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1714     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1715     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1716     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1717     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1718     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1719     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1720     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1721     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1722     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1723     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1724     /* Note, that we do not announce these command yet. */
1725     { "privatedo", cmdPRIVATEDO, 0, NULL },
1726     { "readcert", cmdREADCERT, 0, NULL },
1727     { "writecert", cmdWRITECERT, 1, NULL },
1728     { NULL, cmdINVCMD, 0, NULL }
1729   };
1730
1731
1732 #ifdef HAVE_LIBREADLINE
1733
1734 /* These two functions are used by readline for command completion. */
1735
1736 static char *
1737 command_generator(const char *text,int state)
1738 {
1739   static int list_index,len;
1740   const char *name;
1741
1742   /* If this is a new word to complete, initialize now.  This includes
1743      saving the length of TEXT for efficiency, and initializing the
1744      index variable to 0. */
1745   if(!state)
1746     {
1747       list_index=0;
1748       len=strlen(text);
1749     }
1750
1751   /* Return the next partial match */
1752   while((name=cmds[list_index].name))
1753     {
1754       /* Only complete commands that have help text */
1755       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1756         return strdup(name);
1757     }
1758
1759   return NULL;
1760 }
1761
1762 static char **
1763 card_edit_completion(const char *text, int start, int end)
1764 {
1765   (void)end;
1766   /* If we are at the start of a line, we try and command-complete.
1767      If not, just do nothing for now. */
1768
1769   if(start==0)
1770     return rl_completion_matches(text,command_generator);
1771
1772   rl_attempted_completion_over=1;
1773
1774   return NULL;
1775 }
1776 #endif /*HAVE_LIBREADLINE*/
1777
1778 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1779    Key creation is not handled here. */
1780 void
1781 card_edit (ctrl_t ctrl, strlist_t commands)
1782 {
1783   enum cmdids cmd = cmdNOP;
1784   int have_commands = !!commands;
1785   int redisplay = 1;
1786   char *answer = NULL;
1787   int allow_admin=0;
1788   char serialnobuf[50];
1789
1790
1791   if (opt.command_fd != -1)
1792     ;
1793   else if (opt.batch && !have_commands)
1794     {
1795       log_error(_("can't do this in batch mode\n"));
1796       goto leave;
1797     }
1798
1799   for (;;)
1800     {
1801       int arg_number;
1802       const char *arg_string = "";
1803       const char *arg_rest = "";
1804       char *p;
1805       int i;
1806       int cmd_admin_only;
1807
1808       tty_printf("\n");
1809       if (redisplay )
1810         {
1811           if (opt.with_colons)
1812             {
1813               card_status (es_stdout, serialnobuf, DIM (serialnobuf));
1814               fflush (stdout);
1815             }
1816           else
1817             {
1818               card_status (NULL, serialnobuf, DIM (serialnobuf));
1819               tty_printf("\n");
1820             }
1821           redisplay = 0;
1822         }
1823
1824       do
1825         {
1826           xfree (answer);
1827           if (have_commands)
1828             {
1829               if (commands)
1830                 {
1831                   answer = xstrdup (commands->d);
1832                   commands = commands->next;
1833                 }
1834               else if (opt.batch)
1835                 {
1836                   answer = xstrdup ("quit");
1837                 }
1838               else
1839                 have_commands = 0;
1840             }
1841
1842             if (!have_commands)
1843               {
1844                 tty_enable_completion (card_edit_completion);
1845                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
1846                 cpr_kill_prompt();
1847                 tty_disable_completion ();
1848               }
1849             trim_spaces(answer);
1850         }
1851       while ( *answer == '#' );
1852
1853       arg_number = 0; /* Yes, here is the init which egcc complains about */
1854       cmd_admin_only = 0;
1855       if (!*answer)
1856         cmd = cmdLIST; /* Default to the list command */
1857       else if (*answer == CONTROL_D)
1858         cmd = cmdQUIT;
1859       else
1860         {
1861           if ((p=strchr (answer,' ')))
1862             {
1863               *p++ = 0;
1864               trim_spaces (answer);
1865               trim_spaces (p);
1866               arg_number = atoi(p);
1867               arg_string = p;
1868               arg_rest = p;
1869               while (digitp (arg_rest))
1870                 arg_rest++;
1871               while (spacep (arg_rest))
1872                 arg_rest++;
1873             }
1874
1875           for (i=0; cmds[i].name; i++ )
1876             if (!ascii_strcasecmp (answer, cmds[i].name ))
1877               break;
1878
1879           cmd = cmds[i].id;
1880           cmd_admin_only = cmds[i].admin_only;
1881         }
1882
1883       if (!allow_admin && cmd_admin_only)
1884         {
1885           tty_printf ("\n");
1886           tty_printf (_("Admin-only command\n"));
1887           continue;
1888         }
1889
1890       switch (cmd)
1891         {
1892         case cmdHELP:
1893           for (i=0; cmds[i].name; i++ )
1894             if(cmds[i].desc
1895                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1896               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1897           break;
1898
1899         case cmdADMIN:
1900           if ( !strcmp (arg_string, "on") )
1901             allow_admin = 1;
1902           else if ( !strcmp (arg_string, "off") )
1903             allow_admin = 0;
1904           else if ( !strcmp (arg_string, "verify") )
1905             {
1906               /* Force verification of the Admin Command.  However,
1907                  this is only done if the retry counter is at initial
1908                  state.  */
1909               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
1910               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
1911               allow_admin = !agent_scd_checkpin (tmp);
1912               xfree (tmp);
1913             }
1914           else /* Toggle. */
1915             allow_admin=!allow_admin;
1916           if(allow_admin)
1917             tty_printf(_("Admin commands are allowed\n"));
1918           else
1919             tty_printf(_("Admin commands are not allowed\n"));
1920           break;
1921
1922         case cmdVERIFY:
1923           agent_scd_checkpin (serialnobuf);
1924           redisplay = 1;
1925           break;
1926
1927         case cmdLIST:
1928           redisplay = 1;
1929           break;
1930
1931         case cmdNAME:
1932           change_name ();
1933           break;
1934
1935         case cmdURL:
1936           change_url ();
1937           break;
1938
1939         case cmdFETCH:
1940           fetch_url (ctrl);
1941           break;
1942
1943         case cmdLOGIN:
1944           change_login (arg_string);
1945           break;
1946
1947         case cmdLANG:
1948           change_lang ();
1949           break;
1950
1951         case cmdSEX:
1952           change_sex ();
1953           break;
1954
1955         case cmdCAFPR:
1956           if ( arg_number < 1 || arg_number > 3 )
1957             tty_printf ("usage: cafpr N\n"
1958                         "       1 <= N <= 3\n");
1959           else
1960             change_cafpr (arg_number);
1961           break;
1962
1963         case cmdPRIVATEDO:
1964           if ( arg_number < 1 || arg_number > 4 )
1965             tty_printf ("usage: privatedo N\n"
1966                         "       1 <= N <= 4\n");
1967           else
1968             change_private_do (arg_string, arg_number);
1969           break;
1970
1971         case cmdWRITECERT:
1972           if ( arg_number != 3 )
1973             tty_printf ("usage: writecert 3 < FILE\n");
1974           else
1975             change_cert (arg_rest);
1976           break;
1977
1978         case cmdREADCERT:
1979           if ( arg_number != 3 )
1980             tty_printf ("usage: readcert 3 > FILE\n");
1981           else
1982             read_cert (arg_rest);
1983           break;
1984
1985         case cmdFORCESIG:
1986           toggle_forcesig ();
1987           break;
1988
1989         case cmdGENERATE:
1990           generate_card_keys (ctrl);
1991           break;
1992
1993         case cmdPASSWD:
1994           change_pin (0, allow_admin);
1995           break;
1996
1997         case cmdUNBLOCK:
1998           change_pin (1, allow_admin);
1999           break;
2000
2001         case cmdQUIT:
2002           goto leave;
2003
2004         case cmdNOP:
2005           break;
2006
2007         case cmdINVCMD:
2008         default:
2009           tty_printf ("\n");
2010           tty_printf (_("Invalid command  (try \"help\")\n"));
2011           break;
2012         } /* End command switch. */
2013     } /* End of main menu loop. */
2014
2015  leave:
2016   xfree (answer);
2017 }