9a742a728480daef726afb90063254e663fe8ee6
[gnupg.git] / tools / card-call-scd.c
1 /* card-call-scd.c - IPC calls to scdaemon.
2  * Copyright (C) 2019 g10 Code GmbH
3  * Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
4  * Copyright (C) 2013-2015  Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
20  * SPDX-License-Identifier: GPL-3.0-or-later
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <unistd.h>
29 #include <time.h>
30 #ifdef HAVE_LOCALE_H
31 #include <locale.h>
32 #endif
33
34 #include "../common/util.h"
35 #include "../common/membuf.h"
36 #include "../common/i18n.h"
37 #include "../common/asshelp.h"
38 #include "../common/sysutils.h"
39 #include "../common/status.h"
40 #include "../common/host2net.h"
41 #include "../common/openpgpdefs.h"
42 #include "card-tool.h"
43
44 #define CONTROL_D ('D' - 'A' + 1)
45
46 #define START_AGENT_NO_STARTUP_CMDS 1
47 #define START_AGENT_SUPPRESS_ERRORS 2
48
49 struct default_inq_parm_s
50 {
51   assuan_context_t ctx;
52   struct {
53     u32 *keyid;
54     u32 *mainkeyid;
55     int pubkey_algo;
56   } keyinfo;
57 };
58
59 struct cipher_parm_s
60 {
61   struct default_inq_parm_s *dflt;
62   assuan_context_t ctx;
63   unsigned char *ciphertext;
64   size_t ciphertextlen;
65 };
66
67 struct writecert_parm_s
68 {
69   struct default_inq_parm_s *dflt;
70   const unsigned char *certdata;
71   size_t certdatalen;
72 };
73
74 struct writekey_parm_s
75 {
76   struct default_inq_parm_s *dflt;
77   const unsigned char *keydata;
78   size_t keydatalen;
79 };
80
81 struct genkey_parm_s
82 {
83   struct default_inq_parm_s *dflt;
84   const char *keyparms;
85   const char *passphrase;
86 };
87
88 struct card_cardlist_parm_s
89 {
90   gpg_error_t error;
91   strlist_t list;
92 };
93
94 struct import_key_parm_s
95 {
96   struct default_inq_parm_s *dflt;
97   const void *key;
98   size_t keylen;
99 };
100
101
102 struct cache_nonce_parm_s
103 {
104   char **cache_nonce_addr;
105   char **passwd_nonce_addr;
106 };
107
108
109 \f
110 /*
111  * File local variables
112  */
113
114 /* The established context to the agent.  Note that all calls to
115  * scdaemon are routed via the agent and thus we only need to care
116  * about the IPC with the agent.  */
117 static assuan_context_t agent_ctx;
118
119
120 \f
121 /*
122  * Local prototypes
123  */
124 static gpg_error_t learn_status_cb (void *opaque, const char *line);
125
126
127
128 \f
129 /* Release the card info structure INFO. */
130 void
131 release_card_info (card_info_t info)
132 {
133   int i;
134
135
136   if (!info)
137     return;
138
139   xfree (info->reader); info->reader = NULL;
140   xfree (info->cardtype); info->cardtype = NULL;
141   xfree (info->serialno); info->serialno = NULL;
142   xfree (info->dispserialno); info->dispserialno = NULL;
143   xfree (info->apptypestr); info->apptypestr = NULL;
144   info->apptype = APP_TYPE_NONE;
145   xfree (info->disp_name); info->disp_name = NULL;
146   xfree (info->disp_lang); info->disp_lang = NULL;
147   xfree (info->pubkey_url); info->pubkey_url = NULL;
148   xfree (info->login_data); info->login_data = NULL;
149   info->cafpr1len = info->cafpr2len = info->cafpr3len = 0;
150   for (i=0; i < DIM(info->private_do); i++)
151     {
152       xfree (info->private_do[i]);
153       info->private_do[i] = NULL;
154     }
155   while (info->kinfo)
156     {
157       key_info_t kinfo = info->kinfo->next;
158       xfree (info->kinfo);
159       info->kinfo = kinfo;
160     }
161   info->chvusage[0] = info->chvusage[1] = 0;
162 }
163
164
165 /* Map an application type string to an integer.  */
166 static app_type_t
167 map_apptypestr (const char *string)
168 {
169   app_type_t result;
170
171   if (!string)
172     result = APP_TYPE_NONE;
173   else if (!ascii_strcasecmp (string, "OPENPGP"))
174     result = APP_TYPE_OPENPGP;
175   else if (!ascii_strcasecmp (string, "NKS"))
176     result = APP_TYPE_NKS;
177   else if (!ascii_strcasecmp (string, "DINSIG"))
178     result = APP_TYPE_DINSIG;
179   else if (!ascii_strcasecmp (string, "P15"))
180     result = APP_TYPE_P15;
181   else if (!ascii_strcasecmp (string, "GELDKARTE"))
182     result = APP_TYPE_GELDKARTE;
183   else if (!ascii_strcasecmp (string, "SC-HSM"))
184     result = APP_TYPE_SC_HSM;
185   else if (!ascii_strcasecmp (string, "PIV"))
186     result = APP_TYPE_PIV;
187   else
188     result = APP_TYPE_UNKNOWN;
189
190   return result;
191 }
192
193
194 /* Return a string representation of the application type.  */
195 const char *
196 app_type_string (app_type_t app_type)
197 {
198   const char *result = "?";
199   switch (app_type)
200     {
201     case APP_TYPE_NONE:      result = "None"; break;
202     case APP_TYPE_OPENPGP:   result = "OpenPGP"; break;
203     case APP_TYPE_NKS:       result = "NetKey"; break;
204     case APP_TYPE_DINSIG:    result = "DINSIG"; break;
205     case APP_TYPE_P15:       result = "PKCS#15"; break;
206     case APP_TYPE_GELDKARTE: result = "Geldkarte"; break;
207     case APP_TYPE_SC_HSM:    result = "SC-HSM"; break;
208     case APP_TYPE_PIV:       result = "PIV"; break;
209     case APP_TYPE_UNKNOWN:   result = "Unknown"; break;
210     }
211   return result;
212 }
213
214
215
216 /* If RC is not 0, write an appropriate status message. */
217 static gpg_error_t
218 status_sc_op_failure (gpg_error_t err)
219 {
220   switch (gpg_err_code (err))
221     {
222     case 0:
223       break;
224     case GPG_ERR_CANCELED:
225     case GPG_ERR_FULLY_CANCELED:
226       gnupg_status_printf (STATUS_SC_OP_FAILURE, "1");
227       break;
228     case GPG_ERR_BAD_PIN:
229       gnupg_status_printf (STATUS_SC_OP_FAILURE, "2");
230       break;
231     default:
232       gnupg_status_printf (STATUS_SC_OP_FAILURE, NULL);
233       break;
234     }
235   return err;
236 }
237
238
239 /* This is the default inquiry callback.  It mainly handles the
240    Pinentry notifications.  */
241 static gpg_error_t
242 default_inq_cb (void *opaque, const char *line)
243 {
244   gpg_error_t err = 0;
245   struct default_inq_parm_s *parm = opaque;
246
247   (void)parm;
248
249   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
250     {
251       /* err = gpg_proxy_pinentry_notify (parm->ctrl, line); */
252       /* if (err) */
253       /*   log_error (_("failed to proxy %s inquiry to client\n"), */
254       /*              "PINENTRY_LAUNCHED"); */
255       /* We do not pass errors to avoid breaking other code.  */
256     }
257   else
258     log_debug ("ignoring gpg-agent inquiry '%s'\n", line);
259
260   return err;
261 }
262
263
264 /* Print a warning if the server's version number is less than our
265    version number.  Returns an error code on a connection problem.  */
266 static gpg_error_t
267 warn_version_mismatch (assuan_context_t ctx, const char *servername, int mode)
268 {
269   gpg_error_t err;
270   char *serverversion;
271   const char *myversion = strusage (13);
272
273   err = get_assuan_server_version (ctx, mode, &serverversion);
274   if (err)
275     log_log (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED?
276              GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
277              _("error getting version from '%s': %s\n"),
278              servername, gpg_strerror (err));
279   else if (compare_version_strings (serverversion, myversion) < 0)
280     {
281       char *warn;
282
283       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
284                            servername, serverversion, myversion);
285       if (!warn)
286         err = gpg_error_from_syserror ();
287       else
288         {
289           log_info (_("WARNING: %s\n"), warn);
290           if (!opt.quiet)
291             {
292               log_info (_("Note: Outdated servers may lack important"
293                           " security fixes.\n"));
294               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
295                         "gpgconf --kill all");
296             }
297           gnupg_status_printf (STATUS_WARNING, "server_version_mismatch 0 %s",
298                                warn);
299           xfree (warn);
300         }
301     }
302   xfree (serverversion);
303   return err;
304 }
305
306
307 /* Try to connect to the agent via socket or fork it off and work by
308  * pipes.  Handle the server's initial greeting.  */
309 static gpg_error_t
310 start_agent (unsigned int flags)
311 {
312   gpg_error_t err;
313
314   if (agent_ctx)
315     err = 0;
316   else
317     {
318       err = start_new_gpg_agent (&agent_ctx,
319                                  GPG_ERR_SOURCE_DEFAULT,
320                                  opt.agent_program,
321                                  opt.lc_ctype, opt.lc_messages,
322                                  opt.session_env,
323                                  opt.autostart, opt.verbose, DBG_IPC,
324                                  NULL, NULL);
325       if (!opt.autostart && gpg_err_code (err) == GPG_ERR_NO_AGENT)
326         {
327           static int shown;
328
329           if (!shown)
330             {
331               shown = 1;
332               log_info (_("no gpg-agent running in this session\n"));
333             }
334         }
335       else if (!err
336                && !(err = warn_version_mismatch (agent_ctx, GPG_AGENT_NAME, 0)))
337         {
338           /* Tell the agent that we support Pinentry notifications.
339              No error checking so that it will work also with older
340              agents.  */
341           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
342                            NULL, NULL, NULL, NULL, NULL, NULL);
343           /* Tell the agent about what version we are aware.  This is
344              here used to indirectly enable GPG_ERR_FULLY_CANCELED.  */
345           assuan_transact (agent_ctx, "OPTION agent-awareness=2.1.0",
346                            NULL, NULL, NULL, NULL, NULL, NULL);
347         }
348     }
349
350   if (!err && !(flags & START_AGENT_NO_STARTUP_CMDS))
351     {
352       /* Request the serial number of the card for an early test.  */
353       struct card_info_s info;
354
355       memset (&info, 0, sizeof info);
356
357       if (!(flags & START_AGENT_SUPPRESS_ERRORS))
358         err = warn_version_mismatch (agent_ctx, SCDAEMON_NAME, 2);
359
360       if (!err)
361         err = assuan_transact (agent_ctx, "SCD SERIALNO",
362                                NULL, NULL, NULL, NULL,
363                                learn_status_cb, &info);
364       if (err && !(flags & START_AGENT_SUPPRESS_ERRORS))
365         {
366           switch (gpg_err_code (err))
367             {
368             case GPG_ERR_NOT_SUPPORTED:
369             case GPG_ERR_NO_SCDAEMON:
370               gnupg_status_printf (STATUS_CARDCTRL, "6"); /* No card support. */
371               break;
372             case GPG_ERR_OBJ_TERM_STATE:
373               /* Card is in termination state. */
374               gnupg_status_printf (STATUS_CARDCTRL, "7");
375               break;
376             default:
377               gnupg_status_printf (STATUS_CARDCTRL, "4");  /* No card.  */
378               break;
379             }
380         }
381
382       if (!err && info.serialno)
383         gnupg_status_printf (STATUS_CARDCTRL, "3 %s", info.serialno);
384
385       release_card_info (&info);
386     }
387
388   return err;
389 }
390
391
392 /* Return a new malloced string by unescaping the string S.  Escaping
393  * is percent escaping and '+'/space mapping.  A binary nul will
394  * silently be replaced by a 0xFF.  Function returns NULL to indicate
395  * an out of memory status. */
396 static char *
397 unescape_status_string (const unsigned char *s)
398 {
399   return percent_plus_unescape (s, 0xff);
400 }
401
402
403 /* Take a 20 or 32 byte hexencoded string and put it into the provided
404  * FPRLEN byte long buffer FPR in binary format.  Returns the actual
405  * used length of the FPR buffer or 0 on error.  */
406 static unsigned int
407 unhexify_fpr (const char *hexstr, unsigned char *fpr, unsigned int fprlen)
408 {
409   const char *s;
410   int n;
411
412   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
413     ;
414   if ((*s && *s != ' ') || !(n == 40 || n == 64))
415     return 0; /* no fingerprint (invalid or wrong length). */
416   for (s=hexstr, n=0; *s && n < fprlen; s += 2, n++)
417     fpr[n] = xtoi_2 (s);
418
419   return (n == 20 || n == 32)? n : 0;
420 }
421
422
423 /* Take the serial number from LINE and return it verbatim in a newly
424  * allocated string.  We make sure that only hex characters are
425  * returned.  Returns NULL on error. */
426 static char *
427 store_serialno (const char *line)
428 {
429   const char *s;
430   char *p;
431
432   for (s=line; hexdigitp (s); s++)
433     ;
434   p = xtrymalloc (s + 1 - line);
435   if (p)
436     {
437       memcpy (p, line, s-line);
438       p[s-line] = 0;
439     }
440   return p;
441 }
442
443
444 \f
445 /* Send an APDU to the current card.  On success the status word is
446  * stored at R_SW inless R_SW is NULL.  With HEXAPDU being NULL only a
447  * RESET command is send to scd.  With HEXAPDU being the string
448  * "undefined" the command "SERIALNO undefined" is send to scd. */
449 gpg_error_t
450 scd_apdu (const char *hexapdu, unsigned int *r_sw)
451 {
452   gpg_error_t err;
453
454   err = start_agent (START_AGENT_NO_STARTUP_CMDS);
455   if (err)
456     return err;
457
458   if (!hexapdu)
459     {
460       err = assuan_transact (agent_ctx, "SCD RESET",
461                              NULL, NULL, NULL, NULL, NULL, NULL);
462
463     }
464   else if (!strcmp (hexapdu, "undefined"))
465     {
466       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
467                              NULL, NULL, NULL, NULL, NULL, NULL);
468     }
469   else
470     {
471       char line[ASSUAN_LINELENGTH];
472       membuf_t mb;
473       unsigned char *data;
474       size_t datalen;
475
476       init_membuf (&mb, 256);
477
478       snprintf (line, DIM(line), "SCD APDU %s", hexapdu);
479       err = assuan_transact (agent_ctx, line,
480                              put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
481       if (!err)
482         {
483           data = get_membuf (&mb, &datalen);
484           if (!data)
485             err = gpg_error_from_syserror ();
486           else if (datalen < 2) /* Ooops */
487             err = gpg_error (GPG_ERR_CARD);
488           else
489             {
490               if (r_sw)
491                 *r_sw = buf16_to_uint (data+datalen-2);
492             }
493           xfree (data);
494         }
495     }
496
497   return err;
498 }
499
500
501 /* This is a dummy data line callback.  */
502 static gpg_error_t
503 dummy_data_cb (void *opaque, const void *buffer, size_t length)
504 {
505   (void)opaque;
506   (void)buffer;
507   (void)length;
508   return 0;
509 }
510
511 /* A simple callback used to return the serialnumber of a card.  */
512 static gpg_error_t
513 get_serialno_cb (void *opaque, const char *line)
514 {
515   char **serialno = opaque;
516   const char *keyword = line;
517   const char *s;
518   int keywordlen, n;
519
520   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
521     ;
522   while (spacep (line))
523     line++;
524
525   /* FIXME: Should we use has_leading_keyword? */
526   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
527     {
528       if (*serialno)
529         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
530       for (n=0,s=line; hexdigitp (s); s++, n++)
531         ;
532       if (!n || (n&1)|| !(spacep (s) || !*s) )
533         return gpg_error (GPG_ERR_ASS_PARAMETER);
534       *serialno = xtrymalloc (n+1);
535       if (!*serialno)
536         return out_of_core ();
537       memcpy (*serialno, line, n);
538       (*serialno)[n] = 0;
539     }
540
541   return 0;
542 }
543
544
545
546 /* For historical reasons OpenPGP cards simply use the numbers 1 to 3
547  * for the <keyref>.  Other cards and future versions of
548  * scd/app-openpgp.c may print the full keyref; i.e. "OpenPGP.1"
549  * instead of "1".  This is a helper to cope with that. */
550 static const char *
551 parse_keyref_helper (const char *string)
552 {
553   if (*string == '1' && spacep (string+1))
554     return "OPENPGP.1";
555   else if (*string == '2' && spacep (string+1))
556     return "OPENPGP.2";
557   else if (*string == '3' && spacep (string+1))
558     return "OPENPGP.3";
559   else
560     return string;
561 }
562
563
564 /* Create a new key info object with KEYREF.  All fields but the
565  * keyref are zeroed out.  Never returns NULL.  The created object is
566  * appended to the list at INFO. */
567 static key_info_t
568 create_kinfo (card_info_t info, const char *keyref)
569 {
570   key_info_t kinfo, ki;
571
572   kinfo = xcalloc (1, sizeof *kinfo + strlen (keyref));
573   strcpy (kinfo->keyref, keyref);
574
575   if (!info->kinfo)
576     info->kinfo = kinfo;
577   else
578     {
579       for (ki=info->kinfo; ki->next; ki = ki->next)
580         ;
581       ki->next = kinfo;
582     }
583   return kinfo;
584 }
585
586
587 /* The status callback to handle the LEARN and GETATTR commands.  */
588 static gpg_error_t
589 learn_status_cb (void *opaque, const char *line)
590 {
591   struct card_info_s *parm = opaque;
592   const char *keyword = line;
593   int keywordlen;
594   char *line_buffer = NULL; /* In case we need a copy.  */
595   char *pline;
596   key_info_t kinfo;
597   const char *keyref;
598   int i;
599
600   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
601     ;
602   while (spacep (line))
603     line++;
604
605   switch (keywordlen)
606     {
607     case 3:
608       if (!memcmp (keyword, "KDF", 3))
609         {
610           parm->kdf_do_enabled = 1;
611         }
612       break;
613
614     case 5:
615       if (!memcmp (keyword, "UIF-", 4)
616           && strchr("123", keyword[4]))
617         {
618           unsigned char *data;
619           int no = keyword[4] - '1';
620
621           log_assert (no >= 0 && no <= 2);
622           data = unescape_status_string (line);
623           parm->uif[no] = (data[0] != 0xff);
624           xfree (data);
625         }
626       break;
627
628     case 6:
629       if (!memcmp (keyword, "READER", keywordlen))
630         {
631           xfree (parm->reader);
632           parm->reader = unescape_status_string (line);
633         }
634       else if (!memcmp (keyword, "EXTCAP", keywordlen))
635         {
636           char *p, *p2, *buf;
637           int abool;
638
639           buf = p = unescape_status_string (line);
640           if (buf)
641             {
642               for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
643                 {
644                   p2 = strchr (p, '=');
645                   if (p2)
646                     {
647                       *p2++ = 0;
648                       abool = (*p2 == '1');
649                       if (!strcmp (p, "ki"))
650                         parm->extcap.ki = abool;
651                       else if (!strcmp (p, "aac"))
652                         parm->extcap.aac = abool;
653                       else if (!strcmp (p, "bt"))
654                         parm->extcap.bt = abool;
655                       else if (!strcmp (p, "kdf"))
656                         parm->extcap.kdf = abool;
657                       else if (!strcmp (p, "si"))
658                         parm->status_indicator = strtoul (p2, NULL, 10);
659                     }
660                 }
661               xfree (buf);
662             }
663         }
664       else if (!memcmp (keyword, "CA-FPR", keywordlen))
665         {
666           int no = atoi (line);
667           while (*line && !spacep (line))
668             line++;
669           while (spacep (line))
670             line++;
671           if (no == 1)
672             parm->cafpr1len = unhexify_fpr (line, parm->cafpr1,
673                                             sizeof parm->cafpr1);
674           else if (no == 2)
675             parm->cafpr2len = unhexify_fpr (line, parm->cafpr2,
676                                             sizeof parm->cafpr2);
677           else if (no == 3)
678             parm->cafpr3len = unhexify_fpr (line, parm->cafpr3,
679                                             sizeof parm->cafpr3);
680         }
681       break;
682
683     case 7:
684       if (!memcmp (keyword, "APPTYPE", keywordlen))
685         {
686           xfree (parm->apptypestr);
687           parm->apptypestr = unescape_status_string (line);
688           parm->apptype = map_apptypestr (parm->apptypestr);
689         }
690       else if (!memcmp (keyword, "KEY-FPR", keywordlen))
691         {
692           /* The format of such a line is:
693            *   KEY-FPR <keyref> <fingerprintinhex>
694            */
695           const char *fpr;
696
697           line_buffer = pline = xstrdup (line);
698
699           keyref = parse_keyref_helper (pline);
700           while (*pline && !spacep (pline))
701             pline++;
702           if (*pline)
703             *pline++ = 0; /* Terminate keyref.  */
704           while (spacep (pline)) /* Skip to the fingerprint.  */
705             pline++;
706           fpr = pline;
707
708           /* Check whether we already have an item for the keyref.  */
709           kinfo = find_kinfo (parm, keyref);
710           if (!kinfo)  /* No: new entry.  */
711             kinfo = create_kinfo (parm, keyref);
712           else /* Existing entry - clear the fpr.  */
713             memset (kinfo->fpr, 0, sizeof kinfo->fpr);
714
715           /* Set or update or the fingerprint.  */
716           kinfo->fprlen = unhexify_fpr (fpr, kinfo->fpr, sizeof kinfo->fpr);
717         }
718       break;
719
720     case 8:
721       if (!memcmp (keyword, "SERIALNO", keywordlen))
722         {
723           xfree (parm->serialno);
724           parm->serialno = store_serialno (line);
725           parm->is_v2 = (strlen (parm->serialno) >= 16
726                          && xtoi_2 (parm->serialno+12) >= 2 );
727         }
728       else if (!memcmp (keyword, "CARDTYPE", keywordlen))
729         {
730           xfree (parm->cardtype);
731           parm->cardtype = unescape_status_string (line);
732         }
733       else if (!memcmp (keyword, "DISP-SEX", keywordlen))
734         {
735           parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
736         }
737       else if (!memcmp (keyword, "KEY-TIME", keywordlen))
738         {
739           /* The format of such a line is:
740            *   KEY-TIME <keyref> <timestamp>
741            */
742           const char *timestamp;
743
744           line_buffer = pline = xstrdup (line);
745
746           keyref = parse_keyref_helper (pline);
747           while (*pline && !spacep (pline))
748             pline++;
749           if (*pline)
750             *pline++ = 0; /* Terminate keyref.  */
751           while (spacep (pline)) /* Skip to the timestamp.  */
752             pline++;
753           timestamp = pline;
754
755           /* Check whether we already have an item for the keyref.  */
756           kinfo = find_kinfo (parm, keyref);
757           if (!kinfo)  /* No: new entry.  */
758             kinfo = create_kinfo (parm, keyref);
759
760           kinfo->created = strtoul (timestamp, NULL, 10);
761         }
762       else if (!memcmp (keyword, "KEY-ATTR", keywordlen))
763         {
764           int keyno = 0;
765           int algo = GCRY_PK_RSA;
766           int n = 0;
767
768           sscanf (line, "%d %d %n", &keyno, &algo, &n);
769           keyno--;
770           if (keyno < 0 || keyno >= DIM (parm->key_attr))
771             ; /* Out of range - ignore.  */
772           else
773             {
774               parm->key_attr[keyno].algo = algo;
775               if (algo == PUBKEY_ALGO_RSA)
776                 parm->key_attr[keyno].nbits = strtoul (line+n+3, NULL, 10);
777               else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
778                        || algo == PUBKEY_ALGO_EDDSA)
779                 {
780                   parm->key_attr[keyno].curve =
781                     openpgp_is_curve_supported (line + n, NULL, NULL);
782                 }
783             }
784         }
785       break;
786
787     case 9:
788       if (!memcmp (keyword, "DISP-NAME", keywordlen))
789         {
790           xfree (parm->disp_name);
791           parm->disp_name = unescape_status_string (line);
792         }
793       else if (!memcmp (keyword, "DISP-LANG", keywordlen))
794         {
795           xfree (parm->disp_lang);
796           parm->disp_lang = unescape_status_string (line);
797         }
798       else if (!memcmp (keyword, "CHV-USAGE", keywordlen))
799         {
800           unsigned int byte1, byte2;
801
802           byte1 = byte2 = 0;
803           sscanf (line, "%x %x", &byte1, &byte2);
804           parm->chvusage[0] = byte1;
805           parm->chvusage[1] = byte2;
806         }
807         break;
808
809     case 10:
810       if (!memcmp (keyword, "PUBKEY-URL", keywordlen))
811         {
812           xfree (parm->pubkey_url);
813           parm->pubkey_url = unescape_status_string (line);
814         }
815       else if (!memcmp (keyword, "LOGIN-DATA", keywordlen))
816         {
817           xfree (parm->login_data);
818           parm->login_data = unescape_status_string (line);
819         }
820       else if (!memcmp (keyword, "CHV-STATUS", keywordlen))
821         {
822           char *p, *buf;
823
824           buf = p = unescape_status_string (line);
825           if (buf)
826             while (spacep (p))
827               p++;
828
829           if (!buf)
830             ;
831           else if (parm->apptype == APP_TYPE_OPENPGP)
832             {
833               parm->chv1_cached = atoi (p);
834               while (*p && !spacep (p))
835                 p++;
836               while (spacep (p))
837                 p++;
838               for (i=0; *p && i < 3; i++)
839                 {
840                   parm->chvmaxlen[i] = atoi (p);
841                   while (*p && !spacep (p))
842                     p++;
843                   while (spacep (p))
844                     p++;
845                 }
846               for (i=0; *p && i < 3; i++)
847                 {
848                   parm->chvinfo[i] = atoi (p);
849                   while (*p && !spacep (p))
850                     p++;
851                   while (spacep (p))
852                     p++;
853                 }
854             }
855           else if (parm->apptype == APP_TYPE_PIV)
856             {
857               for (i=0; *p && i < DIM (parm->chvinfo); i++)
858                 {
859                   parm->chvinfo[i] = atoi (p);
860                   while (*p && !spacep (p))
861                     p++;
862                   while (spacep (p))
863                     p++;
864                 }
865             }
866
867           xfree (buf);
868         }
869       break;
870
871     case 11:
872       if (!memcmp (keyword, "SIG-COUNTER", keywordlen))
873         {
874           parm->sig_counter = strtoul (line, NULL, 0);
875         }
876       else if (!memcmp (keyword, "KEYPAIRINFO", keywordlen))
877         {
878           /* The format of such a line is:
879            *   KEYPARINFO <hexgrip> <keyref>
880            */
881           const char *hexgrp = line;
882
883           while (*line && !spacep (line))
884             line++;
885           while (spacep (line))
886             line++;
887
888           keyref = line;
889
890           /* Check whether we already have an item for the keyref.  */
891           kinfo = find_kinfo (parm, keyref);
892           if (!kinfo)  /* New entry.  */
893             kinfo = create_kinfo (parm, keyref);
894           else /* Existing entry - clear the grip.  */
895             memset (kinfo->grip, 0, sizeof kinfo->grip);
896
897           /* Set or update the grip.  Note that due to the
898            * calloc/memset an erroneous too short grip will be nul
899            * padded on the right. */
900           unhexify_fpr (hexgrp, kinfo->grip, sizeof kinfo->grip);
901         }
902       break;
903
904     case 12:
905       if (!memcmp (keyword, "PRIVATE-DO-", 11)
906           && strchr("1234", keyword[11]))
907         {
908           int no = keyword[11] - '1';
909           log_assert (no >= 0 && no <= 3);
910           xfree (parm->private_do[no]);
911           parm->private_do[no] = unescape_status_string (line);
912         }
913       break;
914
915     case 13:
916       if (!memcmp (keyword, "$DISPSERIALNO", keywordlen))
917         {
918           xfree (parm->dispserialno);
919           parm->dispserialno = unescape_status_string (line);
920         }
921       break;
922
923     default:
924       /* Unknown.  */
925       break;
926     }
927
928   xfree (line_buffer);
929   return 0;
930 }
931
932
933 /* Call the scdaemon to learn about a smartcard.  This fills INFO
934  * wioth data from the card. */
935 gpg_error_t
936 scd_learn (card_info_t info)
937 {
938   gpg_error_t err;
939   struct default_inq_parm_s parm;
940   struct card_info_s dummyinfo;
941
942   if (!info)
943     info = &dummyinfo;
944
945   memset (info, 0, sizeof *info);
946   memset (&parm, 0, sizeof parm);
947
948   err = start_agent (0);
949   if (err)
950     return err;
951
952   parm.ctx = agent_ctx;
953   err = assuan_transact (agent_ctx, "SCD LEARN --force",
954                          dummy_data_cb, NULL, default_inq_cb, &parm,
955                          learn_status_cb, info);
956   /* Also try to get some other key attributes.  */
957   if (!err)
958     {
959       err = scd_getattr ("KEY-ATTR", info);
960       if (gpg_err_code (err) == GPG_ERR_INV_NAME
961           || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_OPERATION)
962         err = 0; /* Not implemented or GETATTR not supported.  */
963       err = scd_getattr ("$DISPSERIALNO", info);
964       if (gpg_err_code (err) == GPG_ERR_INV_NAME
965           || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_OPERATION)
966         err = 0; /* Not implemented or GETATTR not supported.  */
967
968     }
969
970   if (info == &dummyinfo)
971     release_card_info (info);
972
973   return err;
974 }
975
976
977 /* Call the agent to retrieve a data object.  This function returns
978  * the data in the same structure as used by the learn command.  It is
979  * allowed to update such a structure using this command. */
980 gpg_error_t
981 scd_getattr (const char *name, struct card_info_s *info)
982 {
983   gpg_error_t err;
984   char line[ASSUAN_LINELENGTH];
985   struct default_inq_parm_s parm;
986
987   memset (&parm, 0, sizeof parm);
988
989   if (!*name)
990     return gpg_error (GPG_ERR_INV_VALUE);
991
992   /* We assume that NAME does not need escaping. */
993   if (12 + strlen (name) > DIM(line)-1)
994     return gpg_error (GPG_ERR_TOO_LARGE);
995   stpcpy (stpcpy (line, "SCD GETATTR "), name);
996
997   err = start_agent (0);
998   if (err)
999     return err;
1000
1001   parm.ctx = agent_ctx;
1002   err = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
1003                         learn_status_cb, info);
1004
1005   return err;
1006 }
1007
1008
1009 /* Send an setattr command to the SCdaemon.  */
1010 gpg_error_t
1011 scd_setattr (const char *name,
1012              const unsigned char *value, size_t valuelen)
1013 {
1014   gpg_error_t err;
1015   char *tmp;
1016   char *line = NULL;
1017   struct default_inq_parm_s parm;
1018
1019
1020   if (!*name || !valuelen)
1021     return gpg_error (GPG_ERR_INV_VALUE);
1022
1023   tmp = strconcat ("SCD SETATTR ", name, " ", NULL);
1024   if (!tmp)
1025     {
1026       err = gpg_error_from_syserror ();
1027       goto leave;
1028     }
1029   line = percent_data_escape (1, tmp, value, valuelen);
1030   xfree (tmp);
1031   if (!line)
1032     {
1033       err = gpg_error_from_syserror ();
1034       goto leave;
1035     }
1036
1037   if (strlen (line) + 10 > ASSUAN_LINELENGTH)
1038     {
1039       err = gpg_error (GPG_ERR_TOO_LARGE);
1040       goto leave;
1041     }
1042
1043   err = start_agent (0);
1044   if (err )
1045     goto leave;
1046
1047   memset (&parm, 0, sizeof parm);
1048   parm.ctx = agent_ctx;
1049   err = assuan_transact (agent_ctx, line, NULL, NULL,
1050                          default_inq_cb, &parm, NULL, NULL);
1051
1052  leave:
1053   xfree (line);
1054   return status_sc_op_failure (err);
1055 }
1056
1057
1058 \f
1059 /* Handle a CERTDATA inquiry.  Note, we only send the data,
1060  * assuan_transact takes care of flushing and writing the END
1061  * command. */
1062 static gpg_error_t
1063 inq_writecert_parms (void *opaque, const char *line)
1064 {
1065   gpg_error_t err;
1066   struct writecert_parm_s *parm = opaque;
1067
1068   if (has_leading_keyword (line, "CERTDATA"))
1069     {
1070       err = assuan_send_data (parm->dflt->ctx,
1071                               parm->certdata, parm->certdatalen);
1072     }
1073   else
1074     err = default_inq_cb (parm->dflt, line);
1075
1076   return err;
1077 }
1078
1079
1080 /* Send a WRITECERT command to the SCdaemon. */
1081 gpg_error_t
1082 scd_writecert (const char *certidstr,
1083                const unsigned char *certdata, size_t certdatalen)
1084 {
1085   gpg_error_t err;
1086   char line[ASSUAN_LINELENGTH];
1087   struct writecert_parm_s parms;
1088   struct default_inq_parm_s dfltparm;
1089
1090   memset (&dfltparm, 0, sizeof dfltparm);
1091
1092   err = start_agent (0);
1093   if (err)
1094     return err;
1095
1096   memset (&parms, 0, sizeof parms);
1097
1098   snprintf (line, sizeof line, "SCD WRITECERT %s", certidstr);
1099   dfltparm.ctx = agent_ctx;
1100   parms.dflt = &dfltparm;
1101   parms.certdata = certdata;
1102   parms.certdatalen = certdatalen;
1103
1104   err = assuan_transact (agent_ctx, line, NULL, NULL,
1105                          inq_writecert_parms, &parms, NULL, NULL);
1106
1107   return status_sc_op_failure (err);
1108 }
1109
1110
1111 \f
1112 /* Handle a KEYDATA inquiry.  Note, we only send the data,
1113    assuan_transact takes care of flushing and writing the end */
1114 static gpg_error_t
1115 inq_writekey_parms (void *opaque, const char *line)
1116 {
1117   gpg_error_t err;
1118   struct writekey_parm_s *parm = opaque;
1119
1120   if (has_leading_keyword (line, "KEYDATA"))
1121     {
1122       err = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
1123     }
1124   else
1125     err = default_inq_cb (parm->dflt, line);
1126
1127   return err;
1128 }
1129
1130
1131 /* Send a WRITEKEY command to the SCdaemon. */
1132 gpg_error_t
1133 scd_writekey (int keyno, const unsigned char *keydata, size_t keydatalen)
1134 {
1135   gpg_error_t err;
1136   char line[ASSUAN_LINELENGTH];
1137   struct writekey_parm_s parms;
1138   struct default_inq_parm_s dfltparm;
1139
1140   memset (&parms, 0, sizeof parms);
1141   memset (&dfltparm, 0, sizeof dfltparm);
1142
1143   err = start_agent (0);
1144   if (err)
1145     return err;
1146
1147   snprintf (line, sizeof line, "SCD WRITEKEY --force OPENPGP.%d", keyno);
1148   dfltparm.ctx = agent_ctx;
1149   parms.dflt = &dfltparm;
1150   parms.keydata = keydata;
1151   parms.keydatalen = keydatalen;
1152
1153   err = assuan_transact (agent_ctx, line, NULL, NULL,
1154                          inq_writekey_parms, &parms, NULL, NULL);
1155
1156   return status_sc_op_failure (err);
1157 }
1158
1159
1160 \f
1161 /* Status callback for the SCD GENKEY command. */
1162 static gpg_error_t
1163 scd_genkey_cb (void *opaque, const char *line)
1164 {
1165   u32 *createtime = opaque;
1166   const char *keyword = line;
1167   int keywordlen;
1168
1169   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1170     ;
1171   while (spacep (line))
1172     line++;
1173
1174  if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
1175     {
1176       *createtime = (u32)strtoul (line, NULL, 10);
1177     }
1178   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
1179     {
1180       gnupg_status_printf (STATUS_PROGRESS, "%s", line);
1181     }
1182
1183   return 0;
1184 }
1185
1186 /* Send a GENKEY command to the SCdaemon.  If *CREATETIME is not 0,
1187  * the value will be passed to SCDAEMON with --timestamp option so that
1188  * the key is created with this.  Otherwise, timestamp was generated by
1189  * SCDEAMON.  On success, creation time is stored back to
1190  * CREATETIME.  */
1191 gpg_error_t
1192 scd_genkey (int keyno, int force, u32 *createtime)
1193 {
1194   gpg_error_t err;
1195   char line[ASSUAN_LINELENGTH];
1196   gnupg_isotime_t tbuf;
1197   struct default_inq_parm_s dfltparm;
1198
1199   memset (&dfltparm, 0, sizeof dfltparm);
1200
1201   err = start_agent (0);
1202   if (err)
1203     return err;
1204
1205   if (*createtime)
1206     epoch2isotime (tbuf, *createtime);
1207   else
1208     *tbuf = 0;
1209
1210   snprintf (line, sizeof line, "SCD GENKEY %s%s %s %d",
1211             *tbuf? "--timestamp=":"", tbuf,
1212             force? "--force":"",
1213             keyno);
1214
1215   dfltparm.ctx = agent_ctx;
1216   err = assuan_transact (agent_ctx, line,
1217                          NULL, NULL, default_inq_cb, &dfltparm,
1218                          scd_genkey_cb, createtime);
1219
1220   return status_sc_op_failure (err);
1221 }
1222
1223
1224 \f
1225 /* Return the serial number of the card or an appropriate error.  The
1226  * serial number is returned as a hexstring.  If DEMAND is not NULL
1227  * the reader with the a card of the serilanumber DEMAND is
1228  * requested.  */
1229 gpg_error_t
1230 scd_serialno (char **r_serialno, const char *demand)
1231 {
1232   int err;
1233   char *serialno = NULL;
1234   char line[ASSUAN_LINELENGTH];
1235
1236   err = start_agent (START_AGENT_SUPPRESS_ERRORS);
1237   if (err)
1238     return err;
1239
1240   if (!demand)
1241     strcpy (line, "SCD SERIALNO");
1242   else
1243     snprintf (line, DIM(line), "SCD SERIALNO --demand=%s", demand);
1244
1245   err = assuan_transact (agent_ctx, line,
1246                          NULL, NULL, NULL, NULL,
1247                          get_serialno_cb, &serialno);
1248   if (err)
1249     {
1250       xfree (serialno);
1251       return err;
1252     }
1253
1254   *r_serialno = serialno;
1255   return 0;
1256 }
1257
1258
1259 \f
1260 /* Send a READCERT command to the SCdaemon. */
1261 gpg_error_t
1262 scd_readcert (const char *certidstr, void **r_buf, size_t *r_buflen)
1263 {
1264   gpg_error_t err;
1265   char line[ASSUAN_LINELENGTH];
1266   membuf_t data;
1267   size_t len;
1268   struct default_inq_parm_s dfltparm;
1269
1270   memset (&dfltparm, 0, sizeof dfltparm);
1271
1272   *r_buf = NULL;
1273   err = start_agent (0);
1274   if (err)
1275     return err;
1276
1277   dfltparm.ctx = agent_ctx;
1278
1279   init_membuf (&data, 2048);
1280
1281   snprintf (line, sizeof line, "SCD READCERT %s", certidstr);
1282   err = assuan_transact (agent_ctx, line,
1283                          put_membuf_cb, &data,
1284                          default_inq_cb, &dfltparm,
1285                          NULL, NULL);
1286   if (err)
1287     {
1288       xfree (get_membuf (&data, &len));
1289       return err;
1290     }
1291
1292   *r_buf = get_membuf (&data, r_buflen);
1293   if (!*r_buf)
1294     return gpg_error_from_syserror ();
1295
1296   return 0;
1297 }
1298
1299
1300 \f
1301 /* Callback function for card_cardlist.  */
1302 static gpg_error_t
1303 card_cardlist_cb (void *opaque, const char *line)
1304 {
1305   struct card_cardlist_parm_s *parm = opaque;
1306   const char *keyword = line;
1307   int keywordlen;
1308
1309   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1310     ;
1311   while (spacep (line))
1312     line++;
1313
1314   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
1315     {
1316       const char *s;
1317       int n;
1318
1319       for (n=0,s=line; hexdigitp (s); s++, n++)
1320         ;
1321
1322       if (!n || (n&1) || *s)
1323         parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1324       else
1325         add_to_strlist (&parm->list, line);
1326     }
1327
1328   return 0;
1329 }
1330
1331
1332 /* Return the serial numbers of all cards currently inserted.  */
1333 gpg_error_t
1334 scd_cardlist (strlist_t *result)
1335 {
1336   gpg_error_t err;
1337   struct card_cardlist_parm_s parm;
1338
1339   memset (&parm, 0, sizeof parm);
1340   *result = NULL;
1341
1342   err = start_agent (START_AGENT_SUPPRESS_ERRORS);
1343   if (err)
1344     return err;
1345
1346   err = assuan_transact (agent_ctx, "SCD GETINFO card_list",
1347                          NULL, NULL, NULL, NULL,
1348                          card_cardlist_cb, &parm);
1349   if (!err && parm.error)
1350     err = parm.error;
1351
1352   if (!err)
1353     *result = parm.list;
1354   else
1355     free_strlist (parm.list);
1356
1357   return err;
1358 }
1359
1360
1361 \f
1362 /* Change the PIN of an OpenPGP card or reset the retry counter.
1363  * CHVNO 1: Change the PIN
1364  *       2: For v1 cards: Same as 1.
1365  *          For v2 cards: Reset the PIN using the Reset Code.
1366  *       3: Change the admin PIN
1367  *     101: Set a new PIN and reset the retry counter
1368  *     102: For v1 cars: Same as 101.
1369  *          For v2 cards: Set a new Reset Code.
1370  * SERIALNO is not used.
1371  */
1372 gpg_error_t
1373 scd_change_pin (int chvno)
1374 {
1375   gpg_error_t err;
1376   char line[ASSUAN_LINELENGTH];
1377   const char *reset = "";
1378   struct default_inq_parm_s dfltparm;
1379
1380   memset (&dfltparm, 0, sizeof dfltparm);
1381
1382   if (chvno >= 100)
1383     reset = "--reset";
1384   chvno %= 100;
1385
1386   err = start_agent (0);
1387   if (err)
1388     return err;
1389   dfltparm.ctx = agent_ctx;
1390
1391   snprintf (line, sizeof line, "SCD PASSWD %s %d", reset, chvno);
1392   err = assuan_transact (agent_ctx, line,
1393                          NULL, NULL,
1394                          default_inq_cb, &dfltparm,
1395                          NULL, NULL);
1396
1397   return status_sc_op_failure (err);
1398 }
1399
1400
1401 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1402  * number of the card - optionally followed by the fingerprint;
1403  * however the fingerprint is ignored here. */
1404 gpg_error_t
1405 scd_checkpin (const char *serialno)
1406 {
1407   gpg_error_t err;
1408   char line[ASSUAN_LINELENGTH];
1409   struct default_inq_parm_s dfltparm;
1410
1411   memset (&dfltparm, 0, sizeof dfltparm);
1412
1413   err = start_agent (0);
1414   if (err)
1415     return err;
1416   dfltparm.ctx = agent_ctx;
1417
1418   snprintf (line, sizeof line, "SCD CHECKPIN %s", serialno);
1419   err = assuan_transact (agent_ctx, line,
1420                          NULL, NULL,
1421                          default_inq_cb, &dfltparm,
1422                          NULL, NULL);
1423   return status_sc_op_failure (err);
1424 }
1425
1426
1427 /* Return the S2K iteration count as computed by gpg-agent.  On error
1428  * print a warning and return a default value. */
1429 unsigned long
1430 agent_get_s2k_count (void)
1431 {
1432   gpg_error_t err;
1433   membuf_t data;
1434   char *buf;
1435   unsigned long count = 0;
1436
1437   err = start_agent (0);
1438   if (err)
1439     goto leave;
1440
1441   init_membuf (&data, 32);
1442   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1443                         put_membuf_cb, &data,
1444                         NULL, NULL, NULL, NULL);
1445   if (err)
1446     xfree (get_membuf (&data, NULL));
1447   else
1448     {
1449       put_membuf (&data, "", 1);
1450       buf = get_membuf (&data, NULL);
1451       if (!buf)
1452         err = gpg_error_from_syserror ();
1453       else
1454         {
1455           count = strtoul (buf, NULL, 10);
1456           xfree (buf);
1457         }
1458     }
1459
1460  leave:
1461   if (err || count < 65536)
1462     {
1463       /* Don't print an error if an older agent is used.  */
1464       if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
1465         log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
1466
1467       /* Default to 65536 which was used up to 2.0.13.  */
1468       count = 65536;
1469     }
1470
1471   return count;
1472 }