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