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