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