Generating an OpenPGP key cia gpg-agent basically works.
[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       /* 0x00000 and 0xFFFF are defined as test cards per spec,
211          0xFFF00 to 0xFFFE are assigned for use with randomly created
212          serial numbers.  */
213     case 0x0000:
214     case 0xffff: return "test card";
215     default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
216     }
217 }
218
219
220 static void
221 print_sha1_fpr (estream_t fp, const unsigned char *fpr)
222 {
223   int i;
224
225   if (fpr)
226     {
227       for (i=0; i < 20 ; i+=2, fpr += 2 )
228         {
229           if (i == 10 )
230             tty_fprintf (fp, " ");
231           tty_fprintf (fp, " %02X%02X", *fpr, fpr[1]);
232         }
233     }
234   else
235     tty_fprintf (fp, " [none]");
236   tty_fprintf (fp, "\n");
237 }
238
239
240 static void
241 print_sha1_fpr_colon (estream_t fp, const unsigned char *fpr)
242 {
243   int i;
244
245   if (fpr)
246     {
247       for (i=0; i < 20 ; i++, fpr++)
248         es_fprintf (fp, "%02X", *fpr);
249     }
250   es_putc (':', fp);
251 }
252
253
254 static void
255 print_name (estream_t fp, const char *text, const char *name)
256 {
257   tty_fprintf (fp, "%s", text);
258
259   /* FIXME: tty_printf_utf8_string2 eats everything after and
260      including an @ - e.g. when printing an url. */
261   if (name && *name)
262     {
263       if (fp)
264         print_utf8_buffer2 (fp, name, strlen (name), '\n');
265       else
266         tty_print_utf8_string2 (name, strlen (name), 0);
267     }
268   else
269     tty_fprintf (fp, _("[not set]"));
270   tty_fprintf (fp, "\n");
271 }
272
273 static void
274 print_isoname (estream_t fp, const char *text,
275                const char *tag, const char *name)
276 {
277   if (opt.with_colons)
278     es_fprintf (fp, "%s:", tag);
279   else
280     tty_fprintf (fp, "%s", text);
281
282   if (name && *name)
283     {
284       char *p, *given, *buf = xstrdup (name);
285
286       given = strstr (buf, "<<");
287       for (p=buf; *p; p++)
288         if (*p == '<')
289           *p = ' ';
290       if (given && given[2])
291         {
292           *given = 0;
293           given += 2;
294           if (opt.with_colons)
295             es_write_sanitized (fp, given, strlen (given), ":", NULL);
296           else if (fp)
297             print_utf8_buffer2 (fp, given, strlen (given), '\n');
298           else
299             tty_print_utf8_string2 (given, strlen (given), 0);
300
301           if (opt.with_colons)
302             es_putc (':', fp);
303           else if (*buf)
304             tty_fprintf (fp, " ");
305         }
306
307       if (opt.with_colons)
308         es_write_sanitized (fp, buf, strlen (buf), ":", NULL);
309       else if (fp)
310         print_utf8_buffer2 (fp, buf, strlen (buf), '\n');
311       else
312         tty_print_utf8_string2 (buf, strlen (buf), 0);
313       xfree (buf);
314     }
315   else
316     {
317       if (opt.with_colons)
318         es_putc (':', fp);
319       else
320         tty_fprintf (fp, _("[not set]"));
321     }
322
323   if (opt.with_colons)
324     es_fputs (":\n", fp);
325   else
326     tty_fprintf (fp, "\n");
327 }
328
329 /* Return true if the SHA1 fingerprint FPR consists only of zeroes. */
330 static int
331 fpr_is_zero (const char *fpr)
332 {
333   int i;
334
335   for (i=0; i < 20 && !fpr[i]; i++)
336     ;
337   return (i == 20);
338 }
339
340
341 /* Return true if the SHA1 fingerprint FPR consists only of 0xFF. */
342 static int
343 fpr_is_ff (const char *fpr)
344 {
345   int i;
346
347   for (i=0; i < 20 && fpr[i] == '\xff'; i++)
348     ;
349   return (i == 20);
350 }
351
352
353 /* Print all available information about the current card. */
354 void
355 card_status (estream_t fp, char *serialno, size_t serialnobuflen)
356 {
357   struct agent_card_info_s info;
358   PKT_public_key *pk = xcalloc (1, sizeof *pk);
359   int rc;
360   unsigned int uval;
361   const unsigned char *thefpr;
362   int i;
363
364   if (serialno && serialnobuflen)
365     *serialno = 0;
366
367   rc = agent_learn (&info);
368   if (rc)
369     {
370       if (opt.with_colons)
371         es_fputs ("AID:::\n", fp);
372       log_error (_("OpenPGP card not available: %s\n"), gpg_strerror (rc));
373       xfree (pk);
374       return;
375     }
376
377   if (opt.with_colons)
378     es_fprintf (fp, "AID:%s:", info.serialno? info.serialno : "");
379   else
380     tty_fprintf (fp, "Application ID ...: %s\n",
381                  info.serialno? info.serialno : "[none]");
382   if (!info.serialno || strncmp (info.serialno, "D27600012401", 12) 
383       || strlen (info.serialno) != 32 )
384     {
385       if (info.apptype && !strcmp (info.apptype, "NKS"))
386         {
387           if (opt.with_colons)
388             es_fputs ("netkey-card:\n", fp);
389           log_info ("this is a NetKey card\n");
390         }
391       else if (info.apptype && !strcmp (info.apptype, "DINSIG"))
392         {
393           if (opt.with_colons)
394             es_fputs ("dinsig-card:\n", fp);
395           log_info ("this is a DINSIG compliant card\n");
396         }
397       else if (info.apptype && !strcmp (info.apptype, "P15"))
398         {
399           if (opt.with_colons)
400             es_fputs ("pkcs15-card:\n", fp);
401           log_info ("this is a PKCS#15 compliant card\n");
402         }
403       else if (info.apptype && !strcmp (info.apptype, "GELDKARTE"))
404         {
405           if (opt.with_colons)
406             es_fputs ("geldkarte-card:\n", fp);
407           log_info ("this is a Geldkarte compliant card\n");
408         }
409       else
410         {
411           if (opt.with_colons)
412             es_fputs ("unknown:\n", fp);
413         }
414       log_info ("not an OpenPGP card\n");
415       agent_release_card_info (&info);
416       xfree (pk);
417       return;
418     }
419
420   if (!serialno)
421     ;
422   else if (strlen (serialno)+1 > serialnobuflen)
423     log_error ("serial number longer than expected\n");
424   else 
425     strcpy (serialno, info.serialno);
426
427   if (opt.with_colons)
428     es_fputs ("openpgp-card:\n", fp);
429
430
431   if (opt.with_colons)
432     {
433       es_fprintf (fp, "version:%.4s:\n", info.serialno+12);
434       uval = xtoi_2(info.serialno+16)*256 + xtoi_2 (info.serialno+18);
435       es_fprintf (fp, "vendor:%04x:%s:\n", uval, get_manufacturer (uval));
436       es_fprintf (fp, "serial:%.8s:\n", info.serialno+20);
437       
438       print_isoname (fp, "Name of cardholder: ", "name", info.disp_name);
439
440       es_fputs ("lang:", fp);
441       if (info.disp_lang)
442         es_write_sanitized (fp, info.disp_lang, strlen (info.disp_lang),
443                             ":", NULL);
444       es_fputs (":\n", fp);
445
446       es_fprintf (fp, "sex:%c:\n", (info.disp_sex == 1? 'm':
447                                  info.disp_sex == 2? 'f' : 'u'));
448
449       es_fputs ("url:", fp);
450       if (info.pubkey_url)
451         es_write_sanitized (fp, info.pubkey_url, strlen (info.pubkey_url),
452                             ":", NULL);
453       es_fputs (":\n", fp);
454
455       es_fputs ("login:", fp);
456       if (info.login_data)
457         es_write_sanitized (fp, info.login_data, strlen (info.login_data),
458                             ":", NULL);
459       es_fputs (":\n", fp);
460
461       es_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           es_fprintf (fp, "keyattr:%d:%d:%u:\n", i+1,
465                       info.key_attr[i].algo, info.key_attr[i].nbits);
466       es_fprintf (fp, "maxpinlen:%d:%d:%d:\n",
467                   info.chvmaxlen[0], info.chvmaxlen[1], info.chvmaxlen[2]);
468       es_fprintf (fp, "pinretry:%d:%d:%d:\n",
469                   info.chvretry[0], info.chvretry[1], info.chvretry[2]);
470       es_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               es_fprintf (fp, "private_do:%d:", i+1);
477               es_write_sanitized (fp, info.private_do[i],
478                                   strlen (info.private_do[i]), ":", NULL);
479               es_fputs (":\n", fp);
480             }
481         }
482
483       es_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       es_putc ('\n', fp);
488       es_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       es_putc ('\n', fp);
493       es_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   estream_t fp;
771   char *data;
772   int n;
773   
774   *r_buffer = NULL;
775
776   fp = es_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       es_fclose (fp);
796       return -1;
797     }
798
799   if (maxlen)
800     n = es_fread (data, 1, maxlen, fp);
801   else
802     n = 0;
803   es_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   estream_t fp;
821   
822   fp = es_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 && es_fwrite (buffer, length, 1, fp) != 1)
838     {
839       tty_printf (_("error writing `%s': %s\n"), fname, strerror (errno));
840       es_fclose (fp);
841       return -1;
842     }
843   es_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   /* xxx = 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 = 0/*check_secret_key (sk, 0)*/;
1616       if (rc)
1617         goto leave;
1618     }
1619
1620 #warning code save_unprotected_key_to_card
1621   /* rc = save_unprotected_key_to_card (sk, keyno); */
1622   /* if (rc) */
1623   /*   { */
1624   /*     log_error (_("error writing key to card: %s\n"), gpg_strerror (rc)); */
1625   /*     goto leave; */
1626   /*   } */
1627
1628   /* Get back to the maybe protected original secret key.  */
1629   if (copied_sk)
1630     {
1631       free_secret_key (copied_sk);
1632       copied_sk = NULL; 
1633     }
1634   sk = node->pkt->pkt.secret_key;
1635
1636   /* Get rid of the secret key parameters and store the serial numer. */
1637   n = pubkey_get_nskey (sk->pubkey_algo);
1638   for (i=pubkey_get_npkey (sk->pubkey_algo); i < n; i++)
1639     {
1640       gcry_mpi_release (sk->skey[i]);
1641       sk->skey[i] = NULL;
1642     }
1643   i = pubkey_get_npkey (sk->pubkey_algo);
1644   sk->skey[i] = gcry_mpi_set_opaque (NULL, xstrdup ("dummydata"), 10*8);
1645   sk->is_protected = 1;
1646   sk->protect.s2k.mode = 1002;
1647   s = info.serialno;
1648   for (sk->protect.ivlen=0; sk->protect.ivlen < 16 && *s && s[1];
1649        sk->protect.ivlen++, s += 2)
1650     sk->protect.iv[sk->protect.ivlen] = xtoi_2 (s);
1651
1652   okay = 1;
1653
1654  leave:
1655   if (copied_sk)
1656     free_secret_key (copied_sk);
1657   agent_release_card_info (&info);
1658   return okay;
1659 }
1660
1661
1662 \f
1663 /* Data used by the command parser.  This needs to be outside of the
1664    function scope to allow readline based command completion.  */
1665 enum cmdids
1666   {
1667     cmdNOP = 0,
1668     cmdQUIT, cmdADMIN, cmdHELP, cmdLIST, cmdDEBUG, cmdVERIFY,
1669     cmdNAME, cmdURL, cmdFETCH, cmdLOGIN, cmdLANG, cmdSEX, cmdCAFPR,
1670     cmdFORCESIG, cmdGENERATE, cmdPASSWD, cmdPRIVATEDO, cmdWRITECERT,
1671     cmdREADCERT, cmdUNBLOCK,
1672     cmdINVCMD
1673   };
1674
1675 static struct
1676 {
1677   const char *name;
1678   enum cmdids id;
1679   int admin_only;
1680   const char *desc;
1681 } cmds[] =
1682   {
1683     { "quit"    , cmdQUIT  , 0, N_("quit this menu")},
1684     { "q"       , cmdQUIT  , 0, NULL },
1685     { "admin"   , cmdADMIN , 0, N_("show admin commands")},
1686     { "help"    , cmdHELP  , 0, N_("show this help")},
1687     { "?"       , cmdHELP  , 0, NULL },
1688     { "list"    , cmdLIST  , 0, N_("list all available data")},
1689     { "l"       , cmdLIST  , 0, NULL },
1690     { "debug"   , cmdDEBUG , 0, NULL },
1691     { "name"    , cmdNAME  , 1, N_("change card holder's name")},
1692     { "url"     , cmdURL   , 1, N_("change URL to retrieve key")},
1693     { "fetch"   , cmdFETCH , 0, N_("fetch the key specified in the card URL")},
1694     { "login"   , cmdLOGIN , 1, N_("change the login name")},
1695     { "lang"    , cmdLANG  , 1, N_("change the language preferences")},
1696     { "sex"     , cmdSEX   , 1, N_("change card holder's sex")},
1697     { "cafpr"   , cmdCAFPR , 1, N_("change a CA fingerprint")},
1698     { "forcesig", cmdFORCESIG, 1, N_("toggle the signature force PIN flag")},
1699     { "generate", cmdGENERATE, 1, N_("generate new keys")},
1700     { "passwd"  , cmdPASSWD, 0, N_("menu to change or unblock the PIN")},
1701     { "verify"  , cmdVERIFY, 0, N_("verify the PIN and list all data")},
1702     { "unblock" , cmdUNBLOCK,0, N_("unblock the PIN using a Reset Code") },
1703     /* Note, that we do not announce these command yet. */
1704     { "privatedo", cmdPRIVATEDO, 0, NULL },
1705     { "readcert", cmdREADCERT, 0, NULL },
1706     { "writecert", cmdWRITECERT, 1, NULL },
1707     { NULL, cmdINVCMD, 0, NULL } 
1708   };
1709
1710
1711 #ifdef HAVE_LIBREADLINE
1712
1713 /* These two functions are used by readline for command completion. */
1714
1715 static char *
1716 command_generator(const char *text,int state)
1717 {
1718   static int list_index,len;
1719   const char *name;
1720
1721   /* If this is a new word to complete, initialize now.  This includes
1722      saving the length of TEXT for efficiency, and initializing the
1723      index variable to 0. */
1724   if(!state)
1725     {
1726       list_index=0;
1727       len=strlen(text);
1728     }
1729
1730   /* Return the next partial match */
1731   while((name=cmds[list_index].name))
1732     {
1733       /* Only complete commands that have help text */
1734       if(cmds[list_index++].desc && strncmp(name,text,len)==0)
1735         return strdup(name);
1736     }
1737
1738   return NULL;
1739 }
1740
1741 static char **
1742 card_edit_completion(const char *text, int start, int end)
1743 {
1744   (void)end;
1745   /* If we are at the start of a line, we try and command-complete.
1746      If not, just do nothing for now. */
1747
1748   if(start==0)
1749     return rl_completion_matches(text,command_generator);
1750
1751   rl_attempted_completion_over=1;
1752
1753   return NULL;
1754 }
1755 #endif /*HAVE_LIBREADLINE*/
1756
1757 /* Menu to edit all user changeable values on an OpenPGP card.  Only
1758    Key creation is not handled here. */
1759 void
1760 card_edit (strlist_t commands)
1761 {
1762   enum cmdids cmd = cmdNOP;
1763   int have_commands = !!commands;
1764   int redisplay = 1;
1765   char *answer = NULL;
1766   int allow_admin=0;
1767   char serialnobuf[50];
1768
1769
1770   if (opt.command_fd != -1)
1771     ;
1772   else if (opt.batch && !have_commands)
1773     {
1774       log_error(_("can't do this in batch mode\n"));
1775       goto leave;
1776     }
1777
1778   for (;;)
1779     {
1780       int arg_number;
1781       const char *arg_string = "";
1782       const char *arg_rest = "";
1783       char *p;
1784       int i;
1785       int cmd_admin_only;
1786       
1787       tty_printf("\n");
1788       if (redisplay )
1789         {
1790           if (opt.with_colons)
1791             {
1792               card_status (es_stdout, serialnobuf, DIM (serialnobuf));
1793               fflush (stdout);
1794             }
1795           else
1796             {
1797               card_status (NULL, serialnobuf, DIM (serialnobuf));
1798               tty_printf("\n");
1799             }
1800           redisplay = 0;
1801         }
1802
1803       do
1804         {
1805           xfree (answer);
1806           if (have_commands)
1807             {
1808               if (commands)
1809                 {
1810                   answer = xstrdup (commands->d);
1811                   commands = commands->next;
1812                 }
1813               else if (opt.batch)
1814                 {
1815                   answer = xstrdup ("quit");
1816                 }
1817               else
1818                 have_commands = 0;
1819             }
1820
1821             if (!have_commands)
1822               {
1823                 tty_enable_completion (card_edit_completion);
1824                 answer = cpr_get_no_help("cardedit.prompt", _("gpg/card> "));
1825                 cpr_kill_prompt();
1826                 tty_disable_completion ();
1827               }
1828             trim_spaces(answer);
1829         }
1830       while ( *answer == '#' );
1831
1832       arg_number = 0; /* Yes, here is the init which egcc complains about */
1833       cmd_admin_only = 0;
1834       if (!*answer)
1835         cmd = cmdLIST; /* Default to the list command */
1836       else if (*answer == CONTROL_D)
1837         cmd = cmdQUIT;
1838       else 
1839         {
1840           if ((p=strchr (answer,' ')))
1841             {
1842               *p++ = 0;
1843               trim_spaces (answer);
1844               trim_spaces (p);
1845               arg_number = atoi(p);
1846               arg_string = p;
1847               arg_rest = p;
1848               while (digitp (arg_rest))
1849                 arg_rest++;
1850               while (spacep (arg_rest))
1851                 arg_rest++;
1852             }
1853           
1854           for (i=0; cmds[i].name; i++ )
1855             if (!ascii_strcasecmp (answer, cmds[i].name ))
1856               break;
1857
1858           cmd = cmds[i].id;
1859           cmd_admin_only = cmds[i].admin_only;
1860         }
1861
1862       if (!allow_admin && cmd_admin_only)
1863         {
1864           tty_printf ("\n");
1865           tty_printf (_("Admin-only command\n"));
1866           continue;
1867         }
1868
1869       switch (cmd)
1870         {
1871         case cmdHELP:
1872           for (i=0; cmds[i].name; i++ )
1873             if(cmds[i].desc
1874                && (!cmds[i].admin_only || (cmds[i].admin_only && allow_admin)))
1875               tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
1876           break;
1877
1878         case cmdADMIN:
1879           if ( !strcmp (arg_string, "on") )
1880             allow_admin = 1;
1881           else if ( !strcmp (arg_string, "off") )
1882             allow_admin = 0;
1883           else if ( !strcmp (arg_string, "verify") )
1884             {
1885               /* Force verification of the Admin Command.  However,
1886                  this is only done if the retry counter is at initial
1887                  state.  */
1888               char *tmp = xmalloc (strlen (serialnobuf) + 6 + 1);
1889               strcpy (stpcpy (tmp, serialnobuf), "[CHV3]");
1890               allow_admin = !agent_scd_checkpin (tmp);
1891               xfree (tmp);
1892             }
1893           else /* Toggle. */
1894             allow_admin=!allow_admin;
1895           if(allow_admin)
1896             tty_printf(_("Admin commands are allowed\n"));
1897           else
1898             tty_printf(_("Admin commands are not allowed\n"));
1899           break;
1900
1901         case cmdVERIFY:
1902           agent_scd_checkpin (serialnobuf);
1903           redisplay = 1;
1904           break;
1905
1906         case cmdLIST:
1907           redisplay = 1;
1908           break;
1909
1910         case cmdNAME:
1911           change_name ();
1912           break;
1913
1914         case cmdURL:
1915           change_url ();
1916           break;
1917
1918         case cmdFETCH:
1919           fetch_url();
1920           break;
1921
1922         case cmdLOGIN:
1923           change_login (arg_string);
1924           break;
1925
1926         case cmdLANG:
1927           change_lang ();
1928           break;
1929
1930         case cmdSEX:
1931           change_sex ();
1932           break;
1933
1934         case cmdCAFPR:
1935           if ( arg_number < 1 || arg_number > 3 )
1936             tty_printf ("usage: cafpr N\n"
1937                         "       1 <= N <= 3\n");
1938           else
1939             change_cafpr (arg_number);
1940           break;
1941
1942         case cmdPRIVATEDO:
1943           if ( arg_number < 1 || arg_number > 4 )
1944             tty_printf ("usage: privatedo N\n"
1945                         "       1 <= N <= 4\n");
1946           else
1947             change_private_do (arg_string, arg_number);
1948           break;
1949
1950         case cmdWRITECERT:
1951           if ( arg_number != 3 )
1952             tty_printf ("usage: writecert 3 < FILE\n");
1953           else
1954             change_cert (arg_rest);
1955           break;
1956
1957         case cmdREADCERT:
1958           if ( arg_number != 3 )
1959             tty_printf ("usage: readcert 3 > FILE\n");
1960           else
1961             read_cert (arg_rest);
1962           break;
1963
1964         case cmdFORCESIG:
1965           toggle_forcesig ();
1966           break;
1967
1968         case cmdGENERATE:
1969           generate_card_keys ();
1970           break;
1971
1972         case cmdPASSWD:
1973           change_pin (0, allow_admin);
1974           break;
1975
1976         case cmdUNBLOCK:
1977           change_pin (1, allow_admin);
1978           break;
1979
1980         case cmdQUIT:
1981           goto leave;
1982
1983         case cmdNOP:
1984           break;
1985
1986         case cmdINVCMD:
1987         default:
1988           tty_printf ("\n");
1989           tty_printf (_("Invalid command  (try \"help\")\n"));
1990           break;
1991         } /* End command switch. */
1992     } /* End of main menu loop. */
1993
1994  leave:
1995   xfree (answer);
1996 }
1997