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