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