* gpg.sgml: Add bkuptocard command for --edit-key.
[gnupg.git] / g10 / card-util.c
1 /* card-util.c - Utility functions for the OpenPGP card.
2  *      Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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
28 #if GNUPG_MAJOR_VERSION != 1
29 #include "gpg.h"
30 #endif
31 #include "util.h"
32 #include "i18n.h"
33 #include "ttyio.h"
34 #include "status.h"
35 #include "options.h"
36 #include "main.h"
37 #include "keyserver-internal.h"
38 #if GNUPG_MAJOR_VERSION == 1
39 #include "cardglue.h"
40 #else
41 #include "call-agent.h"
42 #endif
43
44 #define CONTROL_D ('D' - 'A' + 1)
45
46
47 /* Change the PIN of a an OpenPGP card.  This is an interactive
48    function. */
49 void
50 change_pin (int chvno, int allow_admin)
51 {
52   struct agent_card_info_s info;
53   int rc;
54
55   rc = agent_learn (&info);
56   if (rc)
57     {
58       log_error (_("OpenPGP card not available: %s\n"),
59                   gpg_strerror (rc));
60       return;
61     }
62   
63   log_info (_("OpenPGP card no. %s detected\n"),
64               info.serialno? info.serialno : "[none]");
65
66   agent_release_card_info (&info);
67
68   if (opt.batch)
69     {
70       log_error (_("can't do this in batch mode\n"));
71       return;
72     }
73
74   if(!allow_admin)
75     {
76       rc = agent_scd_change_pin (1);
77       if (rc)
78         tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
79       else
80         tty_printf ("PIN changed.\n");
81     }
82   else
83     for (;;)
84       {
85         char *answer;
86
87         tty_printf ("\n");
88         tty_printf ("1 - change PIN\n"
89                     "2 - unblock PIN\n"
90                     "3 - change Admin PIN\n"
91                     "Q - quit\n");
92         tty_printf ("\n");
93
94         answer = cpr_get("cardutil.change_pin.menu",_("Your selection? "));
95         cpr_kill_prompt();
96         if (strlen (answer) != 1)
97           continue;
98
99         rc = 0;
100         if (*answer == '1')
101           {
102             rc = agent_scd_change_pin (1);
103             if (rc)
104               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
105             else
106               tty_printf ("PIN changed.\n");
107           }
108         else if (*answer == '2')
109           {
110             rc = agent_scd_change_pin (101);
111             if (rc)
112               tty_printf ("Error unblocking the PIN: %s\n", gpg_strerror (rc));
113             else
114               tty_printf ("PIN unblocked and new PIN set.\n");
115           }
116         else if (*answer == '3')
117           {
118             rc = agent_scd_change_pin (3);
119             if (rc)
120               tty_printf ("Error changing the PIN: %s\n", gpg_strerror (rc));
121             else
122               tty_printf ("PIN changed.\n");
123           }
124         else if (*answer == 'q' || *answer == 'Q')
125           {
126             break;
127           }
128       }
129 }
130
131 static const char *
132 get_manufacturer (unsigned int no)
133 {
134   /* Note:  Make sure that there is no colon or linefeed in the string. */
135   switch (no)
136     {
137     case 0:
138     case 0xffff: return "test card";
139     case 0x0001: return "PPC Card Systems";
140     default: return "unknown";
141     }
142 }
143
144
145 static void
146 print_sha1_fpr (FILE *fp, const unsigned char *fpr)
147 {
148   int i;
149
150   if (fpr)
151     {
152       for (i=0; i < 20 ; i+=2, fpr += 2 )
153         {
154           if (i == 10 )
155             tty_fprintf (fp, " ");
156           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
157         }
158     }
159   else
160     tty_fprintf (fp, " [none]");
161   tty_fprintf (fp, "\n");
162 }
163
164
165 static void
166 print_sha1_fpr_colon (FILE *fp, const unsigned char *fpr)
167 {
168   int i;
169
170   if (fpr)
171     {
172       for (i=0; i < 20 ; i++, fpr++)
173         fprintf (fp, "%02X", *fpr);
174     }
175   putc (':', fp);
176 }
177
178
179 static void
180 print_name (FILE *fp, const char *text, const char *name)
181 {
182   tty_fprintf (fp, "%s", text);
183
184   /* FIXME: tty_printf_utf8_string2 eats everything after and
185      including an @ - e.g. when printing an url. */
186   if (name && *name)
187     {
188       if (fp)
189         print_utf8_string2 (fp, name, strlen (name), '\n');
190       else
191         tty_print_utf8_string2 (name, strlen (name), 0);
192     }
193   else
194     tty_fprintf (fp, _("[not set]"));
195   tty_fprintf (fp, "\n");
196 }
197
198 static void
199 print_isoname (FILE *fp, const char *text, const char *tag, const char *name)
200 {
201   if (opt.with_colons)
202     fprintf (fp, "%s:", tag);
203   else
204     tty_fprintf (fp, "%s", text);
205
206   if (name && *name)
207     {
208       char *p, *given, *buf = xstrdup (name);
209
210       given = strstr (buf, "<<");
211       for (p=buf; *p; p++)
212         if (*p == '<')
213           *p = ' ';
214       if (given && given[2])
215         {
216           *given = 0;
217           given += 2;
218           if (opt.with_colons)
219             print_string (fp, given, strlen (given), ':');
220           else if (fp)
221             print_utf8_string2 (fp, given, strlen (given), '\n');
222           else
223             tty_print_utf8_string2 (given, strlen (given), 0);
224
225           if (opt.with_colons)
226             putc (':', fp);
227           else if (*buf)
228             tty_fprintf (fp, " ");
229         }
230
231       if (opt.with_colons)
232         print_string (fp, buf, strlen (buf), ':');
233       else if (fp)
234         print_utf8_string2 (fp, buf, strlen (buf), '\n');
235       else
236         tty_print_utf8_string2 (buf, strlen (buf), 0);
237       xfree (buf);
238     }
239   else
240     {
241       if (opt.with_colons)
242         putc (':', fp);
243       else
244         tty_fprintf (fp, _("[not set]"));
245     }
246
247   if (opt.with_colons)
248     fputs (":\n", fp);
249   else
250     tty_fprintf (fp, "\n");
251 }
252
253 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
254 static int
255 fpr_is_zero (const char *fpr)
256 {
257   int i;
258
259   for (i=0; i < 20 && !fpr[i]; i++)
260     ;
261   return (i == 20);
262 }
263
264
265 /* Print all available information about the current card. */
266 void
267 card_status (FILE *fp, char *serialno, size_t serialnobuflen)
268 {
269   struct agent_card_info_s info;
270   PKT_public_key *pk = xcalloc (1, sizeof *pk);
271   int rc;
272   unsigned int uval;
273   const unsigned char *thefpr;
274
275   if (serialno && serialnobuflen)
276     *serialno = 0;
277
278   rc = agent_learn (&info);
279   if (rc)
280     {
281       if (opt.with_colons)
282         fputs ("AID:::\n", fp);
283       log_error (_("OpenPGP card not available: %s\n"),
284                   gpg_strerror (rc));
285       xfree (pk);
286       return;
287     }
288
289   if (opt.with_colons)
290     fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
291   else
292     tty_fprintf (fp, "Application ID ...: %s\n",
293                  info.serialno? info.serialno : "[none]");
294   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12) 
295       || strlen (info.serialno) != 32 )
296     {
297       if (opt.with_colons)
298         fputs ("unknown:\n", fp);
299       log_info ("not an OpenPGP card\n");
300       agent_release_card_info (&info);
301       xfree (pk);
302       return;
303     }
304
305   if (!serialno)
306     ;
307   else if (strlen (serialno)+1 > serialnobuflen)
308     log_error ("serial number longer than expected\n");
309   else 
310     strcpy (serialno, info.serialno);
311
312   if (opt.with_colons)
313     fputs ("openpgp-card:\n", fp);
314
315
316   if (opt.with_colons)
317     {
318       fprintf (fp, "version:%.4s:\n", info.serialno+12);
319       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
320       fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
321       fprintf (fp, "serial:%.8s:\n", info.serialno+20);
322       
323       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
324
325       fputs ("lang:", fp);
326       if (info.disp_lang)
327         print_string (fp, info.disp_lang, strlen (info.disp_lang), ':');
328       fputs (":\n", fp);
329
330       fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
331                                  info.disp_sex == 2? 'f' : 'u'));
332
333       fputs ("url:", fp);
334       if (info.pubkey_url)
335         print_string (fp, info.pubkey_url, strlen (info.pubkey_url), ':');
336       fputs (":\n", fp);
337
338       fputs ("login:", fp);
339       if (info.login_data)
340         print_string (fp, info.login_data, strlen (info.login_data), ':');
341       fputs (":\n", fp);
342
343       fprintf (fp, "forcepin:%d:::\n", !info.chv1_cached);
344       fprintf (fp, "maxpinlen:%d:%d:%d:\n",
345                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
346       fprintf (fp, "pinretry:%d:%d:%d:\n",
347                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
348       fprintf (fp, "sigcount:%lu:::\n", info.sig_counter);
349
350       fputs ("cafpr:", fp);
351       print_sha1_fpr_colon (fp, info.cafpr1valid? info.cafpr1:NULL);
352       print_sha1_fpr_colon (fp, info.cafpr2valid? info.cafpr2:NULL);
353       print_sha1_fpr_colon (fp, info.cafpr3valid? info.cafpr3:NULL);
354       putc ('\n', fp);
355       fputs ("fpr:", fp);
356       print_sha1_fpr_colon (fp, info.fpr1valid? info.fpr1:NULL);
357       print_sha1_fpr_colon (fp, info.fpr2valid? info.fpr2:NULL);
358       print_sha1_fpr_colon (fp, info.fpr3valid? info.fpr3:NULL);
359       putc ('\n', fp);
360       fprintf (fp, "fprtime:%lu:%lu:%lu:\n",
361                (unsigned long)info.fpr1time, (unsigned long)info.fpr2time,
362                (unsigned long)info.fpr3time);
363     }
364   else 
365     {
366       tty_fprintf (fp, "Version ..........: %.1s%c.%.1s%c\n",
367                    info.serialno[12] == '0'?"":info.serialno+12,
368                    info.serialno[13],
369                    info.serialno[14] == '0'?"":info.serialno+14,
370                    info.serialno[15]);
371       tty_fprintf (fp, "Manufacturer .....: %s\n", 
372                    get_manufacturer (xtoi_2(info.serialno+16)*256
373                                      + xtoi_2 (info.serialno+18)));
374       tty_fprintf (fp, "Serial number ....: %.8s\n", info.serialno+20);
375       
376       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
377       print_name (fp, "Language prefs ...: ", info.disp_lang);
378       tty_fprintf (fp,    "Sex ..............: %s\n",
379                    info.disp_sex == 1? _("male"):
380                    info.disp_sex == 2? _("female") : _("unspecified"));
381       print_name (fp, "URL of public key : ", info.pubkey_url);
382       print_name (fp, "Login data .......: ", info.login_data);
383       if (info.private_do[0])
384         print_name (fp, "Private DO 1 .....: ", info.private_do[0]);
385       if (info.private_do[1])
386         print_name (fp, "Private DO 2 .....: ", info.private_do[1]);
387       if (info.private_do[2])
388         print_name (fp, "Private DO 3 .....: ", info.private_do[2]);
389       if (info.private_do[3])
390         print_name (fp, "Private DO 4 .....: ", info.private_do[3]);
391       if (info.cafpr1valid)
392         {
393           tty_fprintf (fp, "CA fingerprint %d .:", 1);
394           print_sha1_fpr (fp, info.cafpr1);
395         }
396       if (info.cafpr2valid)
397         {
398           tty_fprintf (fp, "CA fingerprint %d .:", 2);
399           print_sha1_fpr (fp, info.cafpr2);
400         }
401       if (info.cafpr3valid)
402         {
403           tty_fprintf (fp, "CA fingerprint %d .:", 3);
404           print_sha1_fpr (fp, info.cafpr3);
405         }
406       tty_fprintf (fp,    "Signature PIN ....: %s\n",
407                    info.chv1_cached? _("not forced"): _("forced"));
408       tty_fprintf (fp,    "Max. PIN lengths .: %d %d %d\n",
409                    info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
410       tty_fprintf (fp,    "PIN retry counter : %d %d %d\n",
411                    info.chvretry[0], info.chvretry[1], info.chvretry[2]);
412       tty_fprintf (fp,    "Signature counter : %lu\n", info.sig_counter);
413       tty_fprintf (fp, "Signature key ....:");
414       print_sha1_fpr (fp, info.fpr1valid? info.fpr1:NULL);
415       if (info.fpr1valid && info.fpr1time)
416         tty_fprintf (fp, "      created ....: %s\n",
417                      asctimestamp (info.fpr1time));
418       tty_fprintf (fp, "Encryption key....:");
419       print_sha1_fpr (fp, info.fpr2valid? info.fpr2:NULL);
420       if (info.fpr2valid && info.fpr2time)
421         tty_fprintf (fp, "      created ....: %s\n",
422                      asctimestamp (info.fpr2time));
423       tty_fprintf (fp, "Authentication key:");
424       print_sha1_fpr (fp, info.fpr3valid? info.fpr3:NULL);
425       if (info.fpr3valid && info.fpr3time)
426         tty_fprintf (fp, "      created ....: %s\n",
427                      asctimestamp (info.fpr3time));
428       tty_fprintf (fp, "General key info..: "); 
429
430       thefpr = (info.fpr1valid? info.fpr1 : info.fpr2valid? info.fpr2 : 
431                 info.fpr3valid? info.fpr3 : NULL);
432       if ( thefpr && !get_pubkey_byfprint (pk, thefpr, 20))
433         {
434           KBNODE keyblock = NULL;
435
436           print_pubkey_info (fp, pk);
437
438           if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
439             print_card_key_info (fp, keyblock);
440           else if ( !get_keyblock_byfprint (&keyblock, thefpr, 20) )
441             {
442               release_kbnode (keyblock);
443               keyblock = NULL;
444               
445               if (!auto_create_card_key_stub (info.serialno,
446                                               info.fpr1valid? info.fpr1:NULL,
447                                               info.fpr2valid? info.fpr2:NULL,
448                                               info.fpr3valid? info.fpr3:NULL))
449                 {
450                   if ( !get_seckeyblock_byfprint (&keyblock, thefpr, 20) )
451                     print_card_key_info (fp, keyblock);
452                 }
453             }
454
455           release_kbnode (keyblock);
456         }
457       else
458         tty_fprintf (fp, "[none]\n");
459     }
460       
461   free_public_key (pk);
462   agent_release_card_info (&info);
463 }
464
465
466 static char *
467 get_one_name (const char *prompt1, const char *prompt2)
468 {
469   char *name;
470   int i;
471
472   for (;;)
473     {
474       name = cpr_get (prompt1, prompt2);
475       if (!name)
476         return NULL;
477       trim_spaces (name);
478       cpr_kill_prompt ();
479       for (i=0; name[i] && name[i] >= ' ' && name[i] <= 126; i++)
480         ;
481
482       /* The name must be in Latin-1 and not UTF-8 - lacking the code
483          to ensure this we restrict it to ASCII. */
484       if (name[i])
485         tty_printf (_("Error: Only plain ASCII is currently allowed.\n"));
486       else if (strchr (name, '<'))
487         tty_printf (_("Error: The \"<\" character may not be used.\n"));
488       else if (strstr (name, "  "))
489         tty_printf (_("Error: Double spaces are not allowed.\n"));    
490       else
491         return name;
492       xfree (name);
493     }
494 }
495
496
497
498 static int
499 change_name (void)
500 {
501   char *surname = NULL, *givenname = NULL;
502   char *isoname, *p;
503   int rc;
504
505   surname = get_one_name ("keygen.smartcard.surname",
506                                     _("Cardholder's surname: "));
507   givenname = get_one_name ("keygen.smartcard.givenname",
508                                        _("Cardholder's given name: "));
509   if (!surname || !givenname || (!*surname && !*givenname))
510     {
511       xfree (surname);
512       xfree (givenname);
513       return -1; /*canceled*/
514     }
515
516   isoname = xmalloc ( strlen (surname) + 2 + strlen (givenname) + 1);
517   strcpy (stpcpy (stpcpy (isoname, surname), "<<"), givenname);
518   xfree (surname);
519   xfree (givenname);
520   for (p=isoname; *p; p++)
521     if (*p == ' ')
522       *p = '<';
523
524   if (strlen (isoname) > 39 )
525     {
526       tty_printf (_("Error: Combined name too long "
527                     "(limit is %d characters).\n"), 39);    
528       xfree (isoname);
529       return -1;
530     }
531
532   log_debug ("setting Name to `%s'\n", isoname);
533   rc = agent_scd_setattr ("DISP-NAME", isoname, strlen (isoname) );
534   if (rc)
535     log_error ("error setting Name: %s\n", gpg_strerror (rc));
536
537   xfree (isoname);
538   return rc;
539 }
540
541
542 static int
543 change_url (void)
544 {
545   char *url;
546   int rc;
547
548   url = cpr_get ("cardedit.change_url", _("URL to retrieve public key: "));
549   if (!url)
550     return -1;
551   trim_spaces (url);
552   cpr_kill_prompt ();
553
554   if (strlen (url) > 254 )
555     {
556       tty_printf (_("Error: URL too long "
557                     "(limit is %d characters).\n"), 254);    
558       xfree (url);
559       return -1;
560     }
561
562   rc = agent_scd_setattr ("PUBKEY-URL", url, strlen (url) );
563   if (rc)
564     log_error ("error setting URL: %s\n", gpg_strerror (rc));
565   xfree (url);
566   return rc;
567 }
568
569 static int
570 fetch_url(void)
571 {
572 #if GNUPG_MAJOR_VERSION == 1
573   int rc;
574   struct agent_card_info_s info;
575
576   memset(&info,0,sizeof(info));
577
578   rc=agent_scd_getattr("PUBKEY-URL",&info);
579   if(rc)
580     log_error("error retrieving URL from card: %s\n",gpg_strerror(rc));
581   else if(info.pubkey_url)
582     {
583       struct keyserver_spec *spec=NULL;
584
585       rc=agent_scd_getattr("KEY-FPR",&info);
586       if(rc)
587         log_error("error retrieving key fingerprint from card: %s\n",
588                   gpg_strerror(rc));
589       else
590         {
591           spec=parse_keyserver_uri(info.pubkey_url,0,NULL,0);
592           if(spec && info.fpr1valid)
593             {
594               /* This is not perfectly right.  Currently, all card
595                  fingerprints are 20 digits, but what about
596                  fingerprints for a future v5 key?  We should get the
597                  length from somewhere lower in the code.  In any
598                  event, the fpr/keyid is not meaningful for straight
599                  HTTP fetches, but using it allows the card to point
600                  to HKP and LDAP servers as well. */
601               rc=keyserver_import_fprint(info.fpr1,20,spec);
602               free_keyserver_spec(spec);
603             }
604         }
605     }
606   else
607     log_error("no URL set on card\n");
608
609   return rc;
610 #else
611   return 0;
612 #endif
613 }
614
615
616 static int
617 change_login (const char *args)
618 {
619   char *data;
620   int n;
621   int rc;
622
623   if (args && *args == '<')  /* Read it from a file */
624     {
625       FILE *fp;
626
627       for (args++; spacep (args); args++)
628         ;
629       fp = fopen (args, "rb");
630 #if GNUPG_MAJOR_VERSION == 1
631       if (fp && is_secured_file (fileno (fp)))
632         {
633           fclose (fp);
634           fp = NULL;
635           errno = EPERM;
636         }
637 #endif
638       if (!fp)
639         {
640           tty_printf (_("can't open `%s': %s\n"), args, strerror (errno));
641           return -1;
642         }
643           
644       data = xmalloc (254);
645       n = fread (data, 1, 254, fp);
646       fclose (fp);
647       if (n < 0)
648         {
649           tty_printf (_("error reading `%s': %s\n"), args, strerror (errno));
650           xfree (data);
651           return -1;
652         }
653     }
654   else
655     {
656       data = cpr_get ("cardedit.change_login",
657                       _("Login data (account name): "));
658       if (!data)
659         return -1;
660       trim_spaces (data);
661       cpr_kill_prompt ();
662       n = strlen (data);
663     }
664
665   if (n > 254 )
666     {
667       tty_printf (_("Error: Login data too long "
668                     "(limit is %d characters).\n"), 254);    
669       xfree (data);
670       return -1;
671     }
672
673   rc = agent_scd_setattr ("LOGIN-DATA", data, n );
674   if (rc)
675     log_error ("error setting login data: %s\n", gpg_strerror (rc));
676   xfree (data);
677   return rc;
678 }
679
680 static int
681 change_private_do (const char *args, int nr)
682 {
683   char do_name[] = "PRIVATE-DO-X";
684   char *data;
685   int n;
686   int rc; 
687
688   assert (nr >= 1 && nr <= 4);
689   do_name[11] = '0' + nr;
690
691   if (args && (args = strchr (args, '<')))  /* Read it from a file */
692     {
693       FILE *fp;
694
695       /* Fixme: Factor this duplicated code out. */
696       for (args++; spacep (args); args++)
697         ;
698       fp = fopen (args, "rb");
699 #if GNUPG_MAJOR_VERSION == 1
700       if (fp && is_secured_file (fileno (fp)))
701         {
702           fclose (fp);
703           fp = NULL;
704           errno = EPERM;
705         }
706 #endif
707       if (!fp)
708         {
709           tty_printf (_("can't open `%s': %s\n"), args, strerror (errno));
710           return -1;
711         }
712           
713       data = xmalloc (254);
714       n = fread (data, 1, 254, fp);
715       fclose (fp);
716       if (n < 0)
717         {
718           tty_printf (_("error reading `%s': %s\n"), args, strerror (errno));
719           xfree (data);
720           return -1;
721         }
722     }
723   else
724     {
725       data = cpr_get ("cardedit.change_private_do",
726                       _("Private DO data: "));
727       if (!data)
728         return -1;
729       trim_spaces (data);
730       cpr_kill_prompt ();
731       n = strlen (data);
732     }
733
734   if (n > 254 )
735     {
736       tty_printf (_("Error: Private DO too long "
737                     "(limit is %d characters).\n"), 254);    
738       xfree (data);
739       return -1;
740     }
741
742   rc = agent_scd_setattr (do_name, data, n );
743   if (rc)
744     log_error ("error setting private DO: %s\n", gpg_strerror (rc));
745   xfree (data);
746   return rc;
747 }
748
749 static int
750 change_lang (void)
751 {
752   char *data, *p;
753   int rc;
754
755   data = cpr_get ("cardedit.change_lang",
756                   _("Language preferences: "));
757   if (!data)
758     return -1;
759   trim_spaces (data);
760   cpr_kill_prompt ();
761
762   if (strlen (data) > 8 || (strlen (data) & 1))
763     {
764       tty_printf (_("Error: invalid length of preference string.\n"));
765       xfree (data);
766       return -1;
767     }
768
769   for (p=data; *p && *p >= 'a' && *p <= 'z'; p++)
770     ;
771   if (*p)
772     {
773       tty_printf (_("Error: invalid characters in preference string.\n"));
774       xfree (data);
775       return -1;
776     }
777
778   rc = agent_scd_setattr ("DISP-LANG", data, strlen (data) );
779   if (rc)
780     log_error ("error setting lang: %s\n", gpg_strerror (rc));
781   xfree (data);
782   return rc;
783 }
784
785
786 static int
787 change_sex (void)
788 {
789   char *data;
790   const char *str;
791   int rc;
792
793   data = cpr_get ("cardedit.change_sex",
794                   _("Sex ((M)ale, (F)emale or space): "));
795   if (!data)
796     return -1;
797   trim_spaces (data);
798   cpr_kill_prompt ();
799
800   if (!*data)
801     str = "9";
802   else if ((*data == 'M' || *data == 'm') && !data[1])
803     str = "1";
804   else if ((*data == 'F' || *data == 'f') && !data[1])
805     str = "2";
806   else 
807     {
808       tty_printf (_("Error: invalid response.\n"));
809       xfree (data);
810       return -1;
811     }
812      
813   rc = agent_scd_setattr ("DISP-SEX", str, 1 );
814   if (rc)
815     log_error ("error setting sex: %s\n", gpg_strerror (rc));
816   xfree (data);
817   return rc;
818 }
819
820
821 static int
822 change_cafpr (int fprno)
823 {
824   char *data;
825   const char *s;
826   int i, c, rc;
827   unsigned char fpr[20];
828
829   data = cpr_get ("cardedit.change_cafpr", _("CA fingerprint: "));
830   if (!data)
831     return -1;
832   trim_spaces (data);
833   cpr_kill_prompt ();
834
835   for (i=0, s=data; i < 20 && *s; )
836     {
837       while (spacep(s))
838         s++;
839       if (*s == ':')
840         s++;
841       while (spacep(s))
842         s++;
843       c = hextobyte (s);
844       if (c == -1)
845         break;
846       fpr[i++] = c;
847       s += 2;
848     }
849   xfree (data);
850   if (i != 20 || *s)
851     {
852       tty_printf (_("Error: invalid formatted fingerprint.\n"));
853       return -1;
854     }
855
856   rc = agent_scd_setattr (fprno==1?"CA-FPR-1":
857                           fprno==2?"CA-FPR-2":
858                           fprno==3?"CA-FPR-3":"x", fpr, 20 );
859   if (rc)
860     log_error ("error setting cafpr: %s\n", gpg_strerror (rc));
861   return rc;
862 }
863
864
865
866 static void
867 toggle_forcesig (void)
868 {
869   struct agent_card_info_s info;
870   int rc;
871   int newstate;
872
873   memset (&info, 0, sizeof info);
874   rc = agent_scd_getattr ("CHV-STATUS", &info);
875   if (rc)
876     {
877       log_error ("error getting current status: %s\n", gpg_strerror (rc));
878       return;
879     }
880   newstate = !info.chv1_cached;
881   agent_release_card_info (&info);
882
883   rc = agent_scd_setattr ("CHV-STATUS-1", newstate? "\x01":"", 1);
884   if (rc)
885     log_error ("error toggling signature PIN flag: %s\n", gpg_strerror (rc));
886 }
887
888
889 /* Helper for the key generation/edit functions.  */
890 static int
891 get_info_for_key_operation (struct agent_card_info_s *info)
892 {
893   int rc;
894
895   memset (info, 0, sizeof *info);
896   rc = agent_scd_getattr ("SERIALNO", info);
897   if (rc || !info->serialno || strncmp (info->serialno, "D27600012401", 12) 
898       || strlen (info->serialno) != 32 )
899     {
900       log_error (_("key operation not possible: %s\n"),
901                  rc ? gpg_strerror (rc) : _("not an OpenPGP card"));
902       return rc? rc: -1;
903     }
904   rc = agent_scd_getattr ("KEY-FPR", info);
905   if (!rc)
906     rc = agent_scd_getattr ("CHV-STATUS", info);
907   if (!rc)
908     rc = agent_scd_getattr ("DISP-NAME", info);
909   if (rc)
910     log_error (_("error getting current key info: %s\n"), gpg_strerror (rc));
911   return rc;
912 }
913
914
915 /* Helper for the key generation/edit functions.  */
916 static int
917 check_pin_for_key_operation (struct agent_card_info_s *info, int *forced_chv1)
918 {     
919   int rc = 0;
920
921   *forced_chv1 = !info->chv1_cached;
922   if (*forced_chv1)
923     { /* Switch of the forced mode so that during key generation we
924          don't get bothered with PIN queries for each
925          self-signature. */
926       rc = agent_scd_setattr ("CHV-STATUS-1", "\x01", 1);
927       if (rc)
928         {
929           log_error ("error clearing forced signature PIN flag: %s\n",
930                      gpg_strerror (rc));
931           *forced_chv1 = 0;
932         }
933     }
934
935   if (!rc)
936     {
937       /* Check the PIN now, so that we won't get asked later for each
938          binding signature. */
939       rc = agent_scd_checkpin (info->serialno);
940       if (rc)
941         log_error ("error checking the PIN: %s\n", gpg_strerror (rc));
942     }
943   return rc;
944 }
945
946 /* Helper for the key generation/edit functions.  */
947 static void 
948 restore_forced_chv1 (int *forced_chv1)
949 {
950   int rc;
951
952   if (*forced_chv1)
953     { /* Switch back to forced state. */
954       rc = agent_scd_setattr ("CHV-STATUS-1", "", 1);
955       if (rc)
956         {
957           log_error ("error setting forced signature PIN flag: %s\n",
958                      gpg_strerror (rc));
959         }
960     }
961 }
962
963 #if GNUPG_MAJOR_VERSION == 1
964 /* Helper for the key generation/edit functions.  */
965 static void
966 show_card_key_info (struct agent_card_info_s *info)
967 {
968   tty_fprintf (NULL, "Signature key ....:");
969   print_sha1_fpr (NULL, info->fpr1valid? info->fpr1:NULL);
970   tty_fprintf (NULL, "Encryption key....:");
971   print_sha1_fpr (NULL, info->fpr2valid? info->fpr2:NULL);
972   tty_fprintf (NULL, "Authentication key:");
973   print_sha1_fpr (NULL, info->fpr3valid? info->fpr3:NULL);
974   tty_printf ("\n");
975 }
976 #endif
977
978 #if GNUPG_MAJOR_VERSION == 1
979 /* Helper for the key generation/edit functions.  */
980 static int
981 replace_existing_key_p (struct agent_card_info_s *info, int keyno)
982 {
983   assert (keyno >= 0 && keyno <= 3);
984
985   if ((keyno == 1 && info->fpr1valid)
986       || (keyno == 2 && info->fpr2valid)
987       || (keyno == 3 && info->fpr3valid))
988     {
989       tty_printf ("\n");
990       log_info ("WARNING: such a key has already been stored on the card!\n");
991       tty_printf ("\n");
992       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_key",
993                                   _("Replace existing key? (y/N) ")))
994         return -1;
995     }
996   return 0;
997 }
998 #endif
999
1000
1001 static void
1002 generate_card_keys (const char *serialno)
1003 {
1004   struct agent_card_info_s info;
1005   int forced_chv1;
1006   int want_backup;
1007
1008   if (get_info_for_key_operation (&info))
1009     return;
1010
1011 #if GNUPG_MAJOR_VERSION == 1
1012   {
1013     char *answer=cpr_get("cardedit.genkeys.backup_enc",
1014                          _("Make off-card backup of encryption key? (Y/n) "));
1015
1016     want_backup=answer_is_yes_no_default(answer,1);
1017     cpr_kill_prompt();
1018     m_free(answer);
1019   }
1020 #else
1021   want_backup = cpr_get_answer_is_yes 
1022                   ( "cardedit.genkeys.backup_enc",
1023                     _("Make off-card backup of encryption key? (Y/n) "));
1024   /*FIXME: we need answer_is_yes_no_default()*/
1025 #endif
1026
1027   if ( (info.fpr1valid && !fpr_is_zero (info.fpr1))
1028        || (info.fpr2valid && !fpr_is_zero (info.fpr2))
1029        || (info.fpr3valid && !fpr_is_zero (info.fpr3)))
1030     {
1031       tty_printf ("\n");
1032       log_info ("NOTE: keys are already stored on the card!\n");
1033       tty_printf ("\n");
1034       if ( !cpr_get_answer_is_yes( "cardedit.genkeys.replace_keys",
1035                                   _("Replace existing keys? (y/N) ")))
1036         {
1037           agent_release_card_info (&info);
1038           return;
1039         }
1040     }
1041   else if (!info.disp_name || !*info.disp_name)
1042     {
1043       tty_printf ("\n");
1044       tty_printf (_("Please note that the factory settings of the PINs are\n"
1045                     "   PIN = `%s'     Admin PIN = `%s'\n"
1046                     "You should change them using the command --change-pin\n"),
1047                   "123456", "12345678");
1048       tty_printf ("\n");
1049     }
1050
1051   if (check_pin_for_key_operation (&info, &forced_chv1))
1052     goto leave;
1053   
1054 #if GNUPG_MAJOR_VERSION == 1
1055   generate_keypair (NULL, info.serialno,
1056                     want_backup? opt.homedir:NULL);
1057 #else
1058   generate_keypair (NULL, info.serialno);
1059 #endif
1060
1061  leave:
1062   agent_release_card_info (&info);
1063   restore_forced_chv1 (&forced_chv1);
1064 }
1065
1066
1067 /* This function is used by the key edit menu to generate an arbitrary
1068    subkey. */
1069 int
1070 card_generate_subkey (KBNODE pub_keyblock, KBNODE sec_keyblock)
1071 {
1072 #if GNUPG_MAJOR_VERSION == 1
1073   struct agent_card_info_s info;
1074   int okay = 0;
1075   int forced_chv1 = 0;
1076   int keyno;
1077
1078   if (get_info_for_key_operation (&info))
1079     return 0;
1080
1081   show_card_key_info (&info);
1082
1083   tty_printf (_("Please select the type of key to generate:\n"));
1084
1085   tty_printf (_("   (1) Signature key\n"));
1086   tty_printf (_("   (2) Encryption key\n"));
1087   tty_printf (_("   (3) Authentication key\n"));
1088
1089   for (;;) 
1090     {
1091       char *answer = cpr_get ("cardedit.genkeys.subkeytype",
1092                               _("Your selection? "));
1093       cpr_kill_prompt();
1094       if (*answer == CONTROL_D)
1095         {
1096           xfree (answer);
1097           goto leave;
1098         }
1099       keyno = *answer? atoi(answer): 0;
1100       xfree(answer);
1101       if (keyno >= 1 && keyno <= 3)
1102         break; /* Okay. */
1103       tty_printf(_("Invalid selection.\n"));
1104     }
1105
1106   if (replace_existing_key_p (&info, keyno))
1107     goto leave;
1108
1109   if (check_pin_for_key_operation (&info, &forced_chv1))
1110     goto leave;
1111
1112   okay = generate_card_subkeypair (pub_keyblock, sec_keyblock,
1113                                    keyno, info.serialno);
1114
1115  leave:
1116   agent_release_card_info (&info);
1117   restore_forced_chv1 (&forced_chv1);
1118   return okay;
1119 #else
1120   return 0;
1121 #endif
1122 }
1123
1124
1125 /* Store the key at NODE into the smartcard and modify NODE to
1126    carry the serialno stuff instead of the actual secret key
1127    parameters.  USE is the usage for that key; 0 means any
1128    usage. */
1129 int 
1130 card_store_subkey (KBNODE node, int use)
1131 {
1132 #if GNUPG_MAJOR_VERSION == 1
1133   struct agent_card_info_s info;
1134   int okay = 0;
1135   int rc;
1136   int keyno, i;
1137   PKT_secret_key *copied_sk = NULL;
1138   PKT_secret_key *sk;
1139   size_t n;
1140   const char *s;
1141   int allow_keyno[3];
1142
1143   assert (node->pkt->pkttype == PKT_SECRET_KEY
1144           || node->pkt->pkttype == PKT_SECRET_SUBKEY);
1145   sk = node->pkt->pkt.secret_key;
1146
1147   if (get_info_for_key_operation (&info))
1148     return 0;
1149
1150   show_card_key_info (&info);
1151
1152   if (!is_RSA (sk->pubkey_algo) || nbits_from_sk (sk) != 1024 )
1153     {
1154       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1155       tty_printf ("\n");
1156       goto leave;
1157     }
1158
1159   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG)));
1160   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1161   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1162
1163   tty_printf (_("Please select where to store the key:\n"));
1164
1165   if (allow_keyno[0])
1166     tty_printf (_("   (1) Signature key\n"));
1167   if (allow_keyno[1])
1168     tty_printf (_("   (2) Encryption key\n"));
1169   if (allow_keyno[2])
1170     tty_printf (_("   (3) Authentication key\n"));
1171
1172   for (;;) 
1173     {
1174       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1175                               _("Your selection? "));
1176       cpr_kill_prompt();
1177       if (*answer == CONTROL_D || !*answer)
1178         {
1179           xfree (answer);
1180           goto leave;
1181         }
1182       keyno = *answer? atoi(answer): 0;
1183       xfree(answer);
1184       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1185         break; /* Okay. */
1186       tty_printf(_("Invalid selection.\n"));
1187     }
1188
1189   if (replace_existing_key_p (&info, keyno))
1190     goto leave;
1191
1192   /* Unprotect key.  */
1193   switch (is_secret_key_protected (sk) )
1194     {
1195     case 0: /* Not protected. */
1196       break;
1197     case -1:
1198       log_error (_("unknown key protection algorithm\n"));
1199       goto leave;
1200     default:
1201       if (sk->protect.s2k.mode == 1001)
1202         {
1203           log_error (_("secret parts of key are not available\n"));
1204           goto leave;
1205         }
1206       if (sk->protect.s2k.mode == 1002)
1207         {
1208           log_error (_("secret key already stored on a card\n"));
1209           goto leave;
1210         }
1211       /* We better copy the key before we unprotect it.  */
1212       copied_sk = sk = copy_secret_key (NULL, sk);
1213       rc = check_secret_key (sk, 0);
1214       if (rc)
1215         goto leave;
1216     }
1217
1218   rc = save_unprotected_key_to_card (sk, keyno);
1219   if (rc)
1220     goto leave;
1221
1222   /* Get back to the maybe protected original secret key.  */
1223   if (copied_sk)
1224     {
1225       free_secret_key (copied_sk);
1226       copied_sk = NULL; 
1227     }
1228   sk = node->pkt->pkt.secret_key;
1229
1230   /* Get rid of the secret key parameters and store the serial numer. */
1231   n = pubkey_get_nskey (sk->pubkey_algo);
1232   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1233     {
1234       mpi_free (sk->skey[i]);
1235       sk->skey[i] = NULL;
1236     }
1237   i = pubkey_get_npkey (sk->pubkey_algo);
1238   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
1239   sk->is_protected = 1;
1240   sk->protect.s2k.mode = 1002;
1241   s = info.serialno;
1242   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1243        sk->protect.ivlen++, s += 2)
1244     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1245
1246   okay = 1;
1247
1248  leave:
1249   if (copied_sk)
1250     free_secret_key (copied_sk);
1251   agent_release_card_info (&info);
1252   return okay;
1253 #else
1254   return 0;
1255 #endif
1256 }
1257
1258
1259 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1260    Key creation is not handled here. */
1261 void
1262 card_edit (STRLIST commands)
1263 {
1264   enum cmdids {
1265     cmdNOP = 0,
1266     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG,
1267     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1268     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO,
1269     cmdINVCMD
1270   };
1271
1272   static struct {
1273     const char *name;
1274     enum cmdids id;
1275     int admin_only;
1276     const char *desc;
1277   } cmds[] = {
1278     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1279     { "q"       , cmdQUIT  , 0, NULL },
1280     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1281     { "help"    , cmdHELP  , 0, N_("show this help")},
1282     { "?"       , cmdHELP  , 0, NULL },
1283     { "list"    , cmdLIST  , 0, N_("list all available data")},
1284     { "l"       , cmdLIST  , 0, NULL },
1285     { "debug"   , cmdDEBUG , 0, NULL },
1286     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1287     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1288     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1289     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1290     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1291     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1292     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1293     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1294     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1295     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1296     /* Note, that we do not announce this command yet. */
1297     { "privatedo", cmdPRIVATEDO, 0, NULL },
1298     { NULL, cmdINVCMD, 0, NULL } 
1299   };
1300  
1301   enum cmdids cmd = cmdNOP;
1302   int have_commands = !!commands;
1303   int redisplay = 1;
1304   char *answer = NULL;
1305   int did_checkpin = 0, allow_admin=0;
1306   char serialnobuf[50];
1307
1308
1309   if (opt.command_fd != -1)
1310     ;
1311   else if (opt.batch && !have_commands)
1312     {
1313       log_error(_("can't do this in batch mode\n"));
1314       goto leave;
1315     }
1316
1317   for (;;)
1318     {
1319       int arg_number;
1320       const char *arg_string = "";
1321       char *p;
1322       int i;
1323       int cmd_admin_only;
1324       
1325       tty_printf("\n");
1326       if (redisplay )
1327         {
1328           if (opt.with_colons)
1329             {
1330               card_status (stdout, serialnobuf, DIM (serialnobuf));
1331               fflush (stdout);
1332             }
1333           else
1334             {
1335               card_status (NULL, serialnobuf, DIM (serialnobuf));
1336               tty_printf("\n");
1337             }
1338           redisplay = 0;
1339         }
1340
1341       do
1342         {
1343           xfree (answer);
1344           if (have_commands)
1345             {
1346               if (commands)
1347                 {
1348                   answer = xstrdup (commands->d);
1349                   commands = commands->next;
1350                 }
1351               else if (opt.batch)
1352                 {
1353                   answer = xstrdup ("quit");
1354                 }
1355               else
1356                 have_commands = 0;
1357             }
1358
1359             if (!have_commands)
1360               {
1361                 answer = cpr_get_no_help("cardedit.prompt", _("Command> "));
1362                 cpr_kill_prompt();
1363             }
1364             trim_spaces(answer);
1365         }
1366       while ( *answer == '#' );
1367
1368       arg_number = 0; /* Yes, here is the init which egcc complains about */
1369       cmd_admin_only = 0;
1370       if (!*answer)
1371         cmd = cmdLIST; /* Default to the list command */
1372       else if (*answer == CONTROL_D)
1373         cmd = cmdQUIT;
1374       else 
1375         {
1376           if ((p=strchr (answer,' ')))
1377             {
1378               *p++ = 0;
1379               trim_spaces (answer);
1380               trim_spaces (p);
1381               arg_number = atoi(p);
1382               arg_string = p;
1383             }
1384           
1385           for (i=0; cmds[i].name; i++ )
1386             if (!ascii_strcasecmp (answer, cmds[i].name ))
1387               break;
1388
1389           cmd = cmds[i].id;
1390           cmd_admin_only = cmds[i].admin_only;
1391         }
1392
1393       if (!allow_admin && cmd_admin_only)
1394         {
1395           tty_printf ("\n");
1396           tty_printf (_("Admin-only command\n"));
1397           continue;
1398         }
1399
1400       switch (cmd)
1401         {
1402         case cmdHELP:
1403           for (i=0; cmds[i].name; i++ )
1404             if(cmds[i].desc
1405                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1406               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1407           break;
1408
1409         case cmdADMIN:
1410           allow_admin=!allow_admin;
1411           if(allow_admin)
1412             tty_printf(_("Admin commands are allowed\n"));
1413           else
1414             tty_printf(_("Admin commands are not allowed\n"));
1415           break;
1416
1417         case cmdLIST:
1418           redisplay = 1;
1419           break;
1420
1421         case cmdNAME:
1422           change_name ();
1423           break;
1424
1425         case cmdURL:
1426           change_url ();
1427           break;
1428
1429         case cmdFETCH:
1430           fetch_url();
1431           break;
1432
1433         case cmdLOGIN:
1434           change_login (arg_string);
1435           break;
1436
1437         case cmdLANG:
1438           change_lang ();
1439           break;
1440
1441         case cmdSEX:
1442           change_sex ();
1443           break;
1444
1445         case cmdCAFPR:
1446           if ( arg_number < 1 || arg_number > 3 )
1447             tty_printf ("usage: cafpr N\n"
1448                         "       1 <= N <= 3\n");
1449           else
1450             change_cafpr (arg_number);
1451           break;
1452
1453         case cmdPRIVATEDO:
1454           if ( arg_number < 1 || arg_number > 4 )
1455             tty_printf ("usage: privatedo N\n"
1456                         "       1 <= N <= 4\n");
1457           else
1458             change_private_do (arg_string, arg_number);
1459           break;
1460
1461         case cmdFORCESIG:
1462           toggle_forcesig ();
1463           break;
1464
1465         case cmdGENERATE:
1466           generate_card_keys (serialnobuf);
1467           break;
1468
1469         case cmdPASSWD:
1470           change_pin (0, allow_admin);
1471           did_checkpin = 0; /* Need to reset it of course. */
1472           break;
1473
1474         case cmdQUIT:
1475           goto leave;
1476
1477         case cmdNOP:
1478           break;
1479
1480         case cmdINVCMD:
1481         default:
1482           tty_printf ("\n");
1483           tty_printf (_("Invalid command  (try \"help\")\n"));
1484           break;
1485         } /* End command switch. */
1486     } /* End of main menu loop. */
1487
1488  leave:
1489   xfree (answer);
1490 }
1491