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