* gpgv.c (tty_fprintf): New stub.
[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 subkey at NODE into the smartcard and modify NODE to
1126    carry the serrialno stuff instead of the actual secret key
1127    parameters. */
1128 int 
1129 card_store_subkey (KBNODE node, int use)
1130 {
1131 #if GNUPG_MAJOR_VERSION == 1
1132   struct agent_card_info_s info;
1133   int okay = 0;
1134   int rc;
1135   int keyno, i;
1136   PKT_secret_key *copied_sk = NULL;
1137   PKT_secret_key *sk;
1138   size_t n;
1139   const char *s;
1140   int allow_keyno[3];
1141
1142   assert (node->pkt->pkttype == PKT_SECRET_KEY
1143           || node->pkt->pkttype == PKT_SECRET_SUBKEY);
1144   sk = node->pkt->pkt.secret_key;
1145
1146   if (get_info_for_key_operation (&info))
1147     return 0;
1148
1149   show_card_key_info (&info);
1150
1151   if (!is_RSA (sk->pubkey_algo) || nbits_from_sk (sk) != 1024 )
1152     {
1153       tty_printf ("You may only store a 1024 bit RSA key on the card\n");
1154       tty_printf ("\n");
1155       goto leave;
1156     }
1157
1158   allow_keyno[0] = (!use || (use & (PUBKEY_USAGE_SIG)));
1159   allow_keyno[1] = (!use || (use & (PUBKEY_USAGE_ENC)));
1160   allow_keyno[2] = (!use || (use & (PUBKEY_USAGE_SIG|PUBKEY_USAGE_AUTH)));
1161
1162   tty_printf (_("Please select where to store the key:\n"));
1163
1164   if (allow_keyno[0])
1165     tty_printf (_("   (1) Signature key\n"));
1166   if (allow_keyno[1])
1167     tty_printf (_("   (2) Encryption key\n"));
1168   if (allow_keyno[2])
1169     tty_printf (_("   (3) Authentication key\n"));
1170
1171   for (;;) 
1172     {
1173       char *answer = cpr_get ("cardedit.genkeys.storekeytype",
1174                               _("Your selection? "));
1175       cpr_kill_prompt();
1176       if (*answer == CONTROL_D || !*answer)
1177         {
1178           xfree (answer);
1179           goto leave;
1180         }
1181       keyno = *answer? atoi(answer): 0;
1182       xfree(answer);
1183       if (keyno >= 1 && keyno <= 3 && allow_keyno[keyno-1])
1184         break; /* Okay. */
1185       tty_printf(_("Invalid selection.\n"));
1186     }
1187
1188   if (replace_existing_key_p (&info, keyno))
1189     goto leave;
1190
1191   /* Unprotect key.  */
1192   switch (is_secret_key_protected (sk) )
1193     {
1194     case 0: /* Not protected. */
1195       break;
1196     case -1:
1197       log_error (_("unknown key protection algorithm\n"));
1198       goto leave;
1199     default:
1200       if (sk->protect.s2k.mode == 1001)
1201         {
1202           log_error (_("secret parts of key are not available\n"));
1203           goto leave;
1204         }
1205       if (sk->protect.s2k.mode == 1002)
1206         {
1207           log_error (_("secret key already stored on a card\n"));
1208           goto leave;
1209         }
1210       /* We better copy the key before we unprotect it.  */
1211       copied_sk = sk = copy_secret_key (NULL, sk);
1212       rc = check_secret_key (sk, 0);
1213       if (rc)
1214         goto leave;
1215     }
1216
1217   rc = save_unprotected_key_to_card (sk, keyno);
1218   if (rc)
1219     goto leave;
1220
1221   /* Get back to the maybe protected original secret key.  */
1222   if (copied_sk)
1223     {
1224       free_secret_key (copied_sk);
1225       copied_sk = NULL; 
1226     }
1227   sk = node->pkt->pkt.secret_key;
1228
1229   /* Get rid of the secret key parameters and store the serial numer. */
1230   n = pubkey_get_nskey (sk->pubkey_algo);
1231   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1232     {
1233       mpi_free (sk->skey[i]);
1234       sk->skey[i] = NULL;
1235     }
1236   i = pubkey_get_npkey (sk->pubkey_algo);
1237   sk->skey[i] = mpi_set_opaque (NULL, xstrdup ("dummydata"), 10);
1238   sk->is_protected = 1;
1239   sk->protect.s2k.mode = 1002;
1240   s = info.serialno;
1241   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1242        sk->protect.ivlen++, s += 2)
1243     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1244
1245   okay = 1;
1246
1247  leave:
1248   if (copied_sk)
1249     free_secret_key (copied_sk);
1250   agent_release_card_info (&info);
1251   return okay;
1252 #else
1253   return 0;
1254 #endif
1255 }
1256
1257
1258 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1259    Key creation is not handled here. */
1260 void
1261 card_edit (STRLIST commands)
1262 {
1263   enum cmdids {
1264     cmdNOP = 0,
1265     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG,
1266     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1267     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO,
1268     cmdINVCMD
1269   };
1270
1271   static struct {
1272     const char *name;
1273     enum cmdids id;
1274     int admin_only;
1275     const char *desc;
1276   } cmds[] = {
1277     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1278     { "q"       , cmdQUIT  , 0, NULL },
1279     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1280     { "help"    , cmdHELP  , 0, N_("show this help")},
1281     { "?"       , cmdHELP  , 0, NULL },
1282     { "list"    , cmdLIST  , 0, N_("list all available data")},
1283     { "l"       , cmdLIST  , 0, NULL },
1284     { "debug"   , cmdDEBUG , 0, NULL },
1285     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1286     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1287     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1288     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1289     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1290     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1291     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1292     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1293     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1294     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1295     /* Note, that we do not announce this command yet. */
1296     { "privatedo", cmdPRIVATEDO, 0, NULL },
1297     { NULL, cmdINVCMD, 0, NULL } 
1298   };
1299  
1300   enum cmdids cmd = cmdNOP;
1301   int have_commands = !!commands;
1302   int redisplay = 1;
1303   char *answer = NULL;
1304   int did_checkpin = 0, allow_admin=0;
1305   char serialnobuf[50];
1306
1307
1308   if (opt.command_fd != -1)
1309     ;
1310   else if (opt.batch && !have_commands)
1311     {
1312       log_error(_("can't do this in batch mode\n"));
1313       goto leave;
1314     }
1315
1316   for (;;)
1317     {
1318       int arg_number;
1319       const char *arg_string = "";
1320       char *p;
1321       int i;
1322       int cmd_admin_only;
1323       
1324       tty_printf("\n");
1325       if (redisplay )
1326         {
1327           if (opt.with_colons)
1328             {
1329               card_status (stdout, serialnobuf, DIM (serialnobuf));
1330               fflush (stdout);
1331             }
1332           else
1333             {
1334               card_status (NULL, serialnobuf, DIM (serialnobuf));
1335               tty_printf("\n");
1336             }
1337           redisplay = 0;
1338         }
1339
1340       do
1341         {
1342           xfree (answer);
1343           if (have_commands)
1344             {
1345               if (commands)
1346                 {
1347                   answer = xstrdup (commands->d);
1348                   commands = commands->next;
1349                 }
1350               else if (opt.batch)
1351                 {
1352                   answer = xstrdup ("quit");
1353                 }
1354               else
1355                 have_commands = 0;
1356             }
1357
1358             if (!have_commands)
1359               {
1360                 answer = cpr_get_no_help("cardedit.prompt", _("Command> "));
1361                 cpr_kill_prompt();
1362             }
1363             trim_spaces(answer);
1364         }
1365       while ( *answer == '#' );
1366
1367       arg_number = 0; /* Yes, here is the init which egcc complains about */
1368       cmd_admin_only = 0;
1369       if (!*answer)
1370         cmd = cmdLIST; /* Default to the list command */
1371       else if (*answer == CONTROL_D)
1372         cmd = cmdQUIT;
1373       else 
1374         {
1375           if ((p=strchr (answer,' ')))
1376             {
1377               *p++ = 0;
1378               trim_spaces (answer);
1379               trim_spaces (p);
1380               arg_number = atoi(p);
1381               arg_string = p;
1382             }
1383           
1384           for (i=0; cmds[i].name; i++ )
1385             if (!ascii_strcasecmp (answer, cmds[i].name ))
1386               break;
1387
1388           cmd = cmds[i].id;
1389           cmd_admin_only = cmds[i].admin_only;
1390         }
1391
1392       if (!allow_admin && cmd_admin_only)
1393         {
1394           tty_printf ("\n");
1395           tty_printf (_("Admin-only command\n"));
1396           continue;
1397         }
1398
1399       switch (cmd)
1400         {
1401         case cmdHELP:
1402           for (i=0; cmds[i].name; i++ )
1403             if(cmds[i].desc
1404                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1405               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1406           break;
1407
1408         case cmdADMIN:
1409           allow_admin=!allow_admin;
1410           if(allow_admin)
1411             tty_printf(_("Admin commands are allowed\n"));
1412           else
1413             tty_printf(_("Admin commands are not allowed\n"));
1414           break;
1415
1416         case cmdLIST:
1417           redisplay = 1;
1418           break;
1419
1420         case cmdNAME:
1421           change_name ();
1422           break;
1423
1424         case cmdURL:
1425           change_url ();
1426           break;
1427
1428         case cmdFETCH:
1429           fetch_url();
1430           break;
1431
1432         case cmdLOGIN:
1433           change_login (arg_string);
1434           break;
1435
1436         case cmdLANG:
1437           change_lang ();
1438           break;
1439
1440         case cmdSEX:
1441           change_sex ();
1442           break;
1443
1444         case cmdCAFPR:
1445           if ( arg_number < 1 || arg_number > 3 )
1446             tty_printf ("usage: cafpr N\n"
1447                         "       1 <= N <= 3\n");
1448           else
1449             change_cafpr (arg_number);
1450           break;
1451
1452         case cmdPRIVATEDO:
1453           if ( arg_number < 1 || arg_number > 4 )
1454             tty_printf ("usage: privatedo N\n"
1455                         "       1 <= N <= 4\n");
1456           else
1457             change_private_do (arg_string, arg_number);
1458           break;
1459
1460         case cmdFORCESIG:
1461           toggle_forcesig ();
1462           break;
1463
1464         case cmdGENERATE:
1465           generate_card_keys (serialnobuf);
1466           break;
1467
1468         case cmdPASSWD:
1469           change_pin (0, allow_admin);
1470           did_checkpin = 0; /* Need to reset it of course. */
1471           break;
1472
1473         case cmdQUIT:
1474           goto leave;
1475
1476         case cmdNOP:
1477           break;
1478
1479         case cmdINVCMD:
1480         default:
1481           tty_printf ("\n");
1482           tty_printf (_("Invalid command  (try \"help\")\n"));
1483           break;
1484         } /* End command switch. */
1485     } /* End of main menu loop. */
1486
1487  leave:
1488   xfree (answer);
1489 }
1490