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