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