agent: Stop scdaemon after reload when disable_scdaemon.
[gnupg.git] / g10 / call-agent.c
1 /* call-agent.c - Divert GPG operations to the agent.
2  * Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
3  * Copyright (C) 2013-2015  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 <https://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 <unistd.h>
27 #include <time.h>
28 #ifdef HAVE_LOCALE_H
29 #include <locale.h>
30 #endif
31
32 #include "gpg.h"
33 #include <assuan.h>
34 #include "../common/util.h"
35 #include "../common/membuf.h"
36 #include "options.h"
37 #include "../common/i18n.h"
38 #include "../common/asshelp.h"
39 #include "../common/sysutils.h"
40 #include "call-agent.h"
41 #include "../common/status.h"
42 #include "../common/shareddefs.h"
43 #include "../common/host2net.h"
44
45 #define CONTROL_D ('D' - 'A' + 1)
46
47
48 static assuan_context_t agent_ctx = NULL;
49 static int did_early_card_test;
50
51 struct default_inq_parm_s
52 {
53   ctrl_t ctrl;
54   assuan_context_t ctx;
55   struct {
56     u32 *keyid;
57     u32 *mainkeyid;
58     int pubkey_algo;
59   } keyinfo;
60 };
61
62 struct cipher_parm_s
63 {
64   struct default_inq_parm_s *dflt;
65   assuan_context_t ctx;
66   unsigned char *ciphertext;
67   size_t ciphertextlen;
68 };
69
70 struct writecert_parm_s
71 {
72   struct default_inq_parm_s *dflt;
73   const unsigned char *certdata;
74   size_t certdatalen;
75 };
76
77 struct writekey_parm_s
78 {
79   struct default_inq_parm_s *dflt;
80   const unsigned char *keydata;
81   size_t keydatalen;
82 };
83
84 struct genkey_parm_s
85 {
86   struct default_inq_parm_s *dflt;
87   const char *keyparms;
88   const char *passphrase;
89 };
90
91 struct import_key_parm_s
92 {
93   struct default_inq_parm_s *dflt;
94   const void *key;
95   size_t keylen;
96 };
97
98
99 struct cache_nonce_parm_s
100 {
101   char **cache_nonce_addr;
102   char **passwd_nonce_addr;
103 };
104
105
106 static gpg_error_t learn_status_cb (void *opaque, const char *line);
107
108
109 \f
110 /* If RC is not 0, write an appropriate status message. */
111 static void
112 status_sc_op_failure (int rc)
113 {
114   switch (gpg_err_code (rc))
115     {
116     case 0:
117       break;
118     case GPG_ERR_CANCELED:
119     case GPG_ERR_FULLY_CANCELED:
120       write_status_text (STATUS_SC_OP_FAILURE, "1");
121       break;
122     case GPG_ERR_BAD_PIN:
123       write_status_text (STATUS_SC_OP_FAILURE, "2");
124       break;
125     default:
126       write_status (STATUS_SC_OP_FAILURE);
127       break;
128     }
129 }
130
131
132 /* This is the default inquiry callback.  It mainly handles the
133    Pinentry notifications.  */
134 static gpg_error_t
135 default_inq_cb (void *opaque, const char *line)
136 {
137   gpg_error_t err = 0;
138   struct default_inq_parm_s *parm = opaque;
139
140   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
141     {
142       err = gpg_proxy_pinentry_notify (parm->ctrl, line);
143       if (err)
144         log_error (_("failed to proxy %s inquiry to client\n"),
145                    "PINENTRY_LAUNCHED");
146       /* We do not pass errors to avoid breaking other code.  */
147     }
148   else if ((has_leading_keyword (line, "PASSPHRASE")
149             || has_leading_keyword (line, "NEW_PASSPHRASE"))
150            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
151     {
152       if (have_static_passphrase ())
153         {
154           const char *s = get_static_passphrase ();
155           err = assuan_send_data (parm->ctx, s, strlen (s));
156         }
157       else
158         {
159           char *pw;
160           char buf[32];
161
162           if (parm->keyinfo.keyid)
163             emit_status_need_passphrase (parm->ctrl,
164                                          parm->keyinfo.keyid,
165                                          parm->keyinfo.mainkeyid,
166                                          parm->keyinfo.pubkey_algo);
167
168           snprintf (buf, sizeof (buf), "%u", 100);
169           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
170           pw = cpr_get_hidden ("passphrase.enter", _("Enter passphrase: "));
171           cpr_kill_prompt ();
172           if (*pw == CONTROL_D && !pw[1])
173             err = gpg_error (GPG_ERR_CANCELED);
174           else
175             err = assuan_send_data (parm->ctx, pw, strlen (pw));
176           xfree (pw);
177         }
178     }
179   else
180     log_debug ("ignoring gpg-agent inquiry '%s'\n", line);
181
182   return err;
183 }
184
185
186 /* Print a warning if the server's version number is less than our
187    version number.  Returns an error code on a connection problem.  */
188 static gpg_error_t
189 warn_version_mismatch (assuan_context_t ctx, const char *servername, int mode)
190 {
191   gpg_error_t err;
192   char *serverversion;
193   const char *myversion = strusage (13);
194
195   err = get_assuan_server_version (ctx, mode, &serverversion);
196   if (err)
197     log_log (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED?
198              GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
199              _("error getting version from '%s': %s\n"),
200              servername, gpg_strerror (err));
201   else if (compare_version_strings (serverversion, myversion) < 0)
202     {
203       char *warn;
204
205       warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
206                            servername, serverversion, myversion);
207       if (!warn)
208         err = gpg_error_from_syserror ();
209       else
210         {
211           log_info (_("WARNING: %s\n"), warn);
212           if (!opt.quiet)
213             {
214               log_info (_("Note: Outdated servers may lack important"
215                           " security fixes.\n"));
216               log_info (_("Note: Use the command \"%s\" to restart them.\n"),
217                         "gpgconf --kill all");
218             }
219           write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
220                                 " ", warn, NULL);
221           xfree (warn);
222         }
223     }
224   xfree (serverversion);
225   return err;
226 }
227
228
229 #define FLAG_FOR_CARD_SUPPRESS_ERRORS 2
230
231 /* Try to connect to the agent via socket or fork it off and work by
232    pipes.  Handle the server's initial greeting */
233 static int
234 start_agent (ctrl_t ctrl, int flag_for_card)
235 {
236   int rc;
237
238   (void)ctrl;  /* Not yet used.  */
239
240   /* Fixme: We need a context for each thread or serialize the access
241      to the agent. */
242   if (agent_ctx)
243     rc = 0;
244   else
245     {
246       rc = start_new_gpg_agent (&agent_ctx,
247                                 GPG_ERR_SOURCE_DEFAULT,
248                                 opt.agent_program,
249                                 opt.lc_ctype, opt.lc_messages,
250                                 opt.session_env,
251                                 opt.autostart, opt.verbose, DBG_IPC,
252                                 NULL, NULL);
253       if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
254         {
255           static int shown;
256
257           if (!shown)
258             {
259               shown = 1;
260               log_info (_("no gpg-agent running in this session\n"));
261             }
262         }
263       else if (!rc
264                && !(rc = warn_version_mismatch (agent_ctx, GPG_AGENT_NAME, 0)))
265         {
266           /* Tell the agent that we support Pinentry notifications.
267              No error checking so that it will work also with older
268              agents.  */
269           assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
270                            NULL, NULL, NULL, NULL, NULL, NULL);
271           /* Tell the agent about what version we are aware.  This is
272              here used to indirectly enable GPG_ERR_FULLY_CANCELED.  */
273           assuan_transact (agent_ctx, "OPTION agent-awareness=2.1.0",
274                            NULL, NULL, NULL, NULL, NULL, NULL);
275           /* Pass on the pinentry mode.  */
276           if (opt.pinentry_mode)
277             {
278               char *tmp = xasprintf ("OPTION pinentry-mode=%s",
279                                      str_pinentry_mode (opt.pinentry_mode));
280               rc = assuan_transact (agent_ctx, tmp,
281                                NULL, NULL, NULL, NULL, NULL, NULL);
282               xfree (tmp);
283               if (rc)
284                 {
285                   log_error ("setting pinentry mode '%s' failed: %s\n",
286                              str_pinentry_mode (opt.pinentry_mode),
287                              gpg_strerror (rc));
288                   write_status_error ("set_pinentry_mode", rc);
289                 }
290             }
291
292           /* Pass on the request origin.  */
293           if (opt.request_origin)
294             {
295               char *tmp = xasprintf ("OPTION pretend-request-origin=%s",
296                                      str_request_origin (opt.request_origin));
297               rc = assuan_transact (agent_ctx, tmp,
298                                NULL, NULL, NULL, NULL, NULL, NULL);
299               xfree (tmp);
300               if (rc)
301                 {
302                   log_error ("setting request origin '%s' failed: %s\n",
303                              str_request_origin (opt.request_origin),
304                              gpg_strerror (rc));
305                   write_status_error ("set_request_origin", rc);
306                 }
307             }
308
309           /* In DE_VS mode under Windows we require that the JENT RNG
310            * is active.  */
311 #ifdef HAVE_W32_SYSTEM
312           if (!rc && opt.compliance == CO_DE_VS)
313             {
314               if (assuan_transact (agent_ctx, "GETINFO jent_active",
315                                    NULL, NULL, NULL, NULL, NULL, NULL))
316                 {
317                   rc = gpg_error (GPG_ERR_FORBIDDEN);
318                   log_error (_("%s is not compliant with %s mode\n"),
319                              GPG_AGENT_NAME,
320                              gnupg_compliance_option_string (opt.compliance));
321                   write_status_error ("random-compliance", rc);
322                 }
323             }
324 #endif /*HAVE_W32_SYSTEM*/
325
326         }
327     }
328
329   if (!rc && flag_for_card && !did_early_card_test)
330     {
331       /* Request the serial number of the card for an early test.  */
332       struct agent_card_info_s info;
333
334       memset (&info, 0, sizeof info);
335
336       if (!(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
337         rc = warn_version_mismatch (agent_ctx, SCDAEMON_NAME, 2);
338       if (!rc)
339         rc = assuan_transact (agent_ctx, "SCD SERIALNO",
340                               NULL, NULL, NULL, NULL,
341                               learn_status_cb, &info);
342       if (rc && !(flag_for_card & FLAG_FOR_CARD_SUPPRESS_ERRORS))
343         {
344           switch (gpg_err_code (rc))
345             {
346             case GPG_ERR_NOT_SUPPORTED:
347             case GPG_ERR_NO_SCDAEMON:
348               write_status_text (STATUS_CARDCTRL, "6");
349               break;
350             case GPG_ERR_OBJ_TERM_STATE:
351               write_status_text (STATUS_CARDCTRL, "7");
352               break;
353             default:
354               write_status_text (STATUS_CARDCTRL, "4");
355               log_info ("selecting card failed: %s\n", gpg_strerror (rc));
356               break;
357             }
358         }
359
360       if (!rc && is_status_enabled () && info.serialno)
361         {
362           char *buf;
363
364           buf = xasprintf ("3 %s", info.serialno);
365           write_status_text (STATUS_CARDCTRL, buf);
366           xfree (buf);
367         }
368
369       agent_release_card_info (&info);
370
371       if (!rc)
372         did_early_card_test = 1;
373     }
374
375
376   return rc;
377 }
378
379
380 /* Return a new malloced string by unescaping the string S.  Escaping
381    is percent escaping and '+'/space mapping.  A binary nul will
382    silently be replaced by a 0xFF.  Function returns NULL to indicate
383    an out of memory status. */
384 static char *
385 unescape_status_string (const unsigned char *s)
386 {
387   return percent_plus_unescape (s, 0xff);
388 }
389
390
391 /* Take a 20 or 32 byte hexencoded string and put it into the provided
392  * FPRLEN byte long buffer FPR in binary format.  Returns the actual
393  * used length of the FPR buffer or 0 on error.  */
394 static unsigned int
395 unhexify_fpr (const char *hexstr, unsigned char *fpr, unsigned int fprlen)
396 {
397   const char *s;
398   int n;
399
400   for (s=hexstr, n=0; hexdigitp (s); s++, n++)
401     ;
402   if ((*s && *s != ' ') || !(n == 40 || n == 64))
403     return 0; /* no fingerprint (invalid or wrong length). */
404   for (s=hexstr, n=0; *s && n < fprlen; s += 2, n++)
405     fpr[n] = xtoi_2 (s);
406
407   return (n == 20 || n == 32)? n : 0;
408 }
409
410 /* Take the serial number from LINE and return it verbatim in a newly
411    allocated string.  We make sure that only hex characters are
412    returned. */
413 static char *
414 store_serialno (const char *line)
415 {
416   const char *s;
417   char *p;
418
419   for (s=line; hexdigitp (s); s++)
420     ;
421   p = xtrymalloc (s + 1 - line);
422   if (p)
423     {
424       memcpy (p, line, s-line);
425       p[s-line] = 0;
426     }
427   return p;
428 }
429
430
431 \f
432 /* This is a dummy data line callback.  */
433 static gpg_error_t
434 dummy_data_cb (void *opaque, const void *buffer, size_t length)
435 {
436   (void)opaque;
437   (void)buffer;
438   (void)length;
439   return 0;
440 }
441
442 /* A simple callback used to return the serialnumber of a card.  */
443 static gpg_error_t
444 get_serialno_cb (void *opaque, const char *line)
445 {
446   char **serialno = opaque;
447   const char *keyword = line;
448   const char *s;
449   int keywordlen, n;
450
451   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
452     ;
453   while (spacep (line))
454     line++;
455
456   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
457     {
458       if (*serialno)
459         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
460       for (n=0,s=line; hexdigitp (s); s++, n++)
461         ;
462       if (!n || (n&1)|| !(spacep (s) || !*s) )
463         return gpg_error (GPG_ERR_ASS_PARAMETER);
464       *serialno = xtrymalloc (n+1);
465       if (!*serialno)
466         return out_of_core ();
467       memcpy (*serialno, line, n);
468       (*serialno)[n] = 0;
469     }
470
471   return 0;
472 }
473
474
475
476 /* Release the card info structure INFO. */
477 void
478 agent_release_card_info (struct agent_card_info_s *info)
479 {
480   int i;
481
482   if (!info)
483     return;
484
485   xfree (info->reader); info->reader = NULL;
486   xfree (info->serialno); info->serialno = NULL;
487   xfree (info->apptype); info->apptype = NULL;
488   xfree (info->disp_name); info->disp_name = NULL;
489   xfree (info->disp_lang); info->disp_lang = NULL;
490   xfree (info->pubkey_url); info->pubkey_url = NULL;
491   xfree (info->login_data); info->login_data = NULL;
492   info->cafpr1len = info->cafpr2len = info->cafpr3len = 0;
493   info->fpr1len = info->fpr2len = info->fpr3len = 0;
494   for (i=0; i < DIM(info->private_do); i++)
495     {
496       xfree (info->private_do[i]);
497       info->private_do[i] = NULL;
498     }
499 }
500
501
502 static gpg_error_t
503 learn_status_cb (void *opaque, const char *line)
504 {
505   struct agent_card_info_s *parm = opaque;
506   const char *keyword = line;
507   int keywordlen;
508   int i;
509
510   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
511     ;
512   while (spacep (line))
513     line++;
514
515   if (keywordlen == 6 && !memcmp (keyword, "READER", keywordlen))
516     {
517       xfree (parm->reader);
518       parm->reader = unescape_status_string (line);
519     }
520   else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
521     {
522       xfree (parm->serialno);
523       parm->serialno = store_serialno (line);
524       parm->is_v2 = (strlen (parm->serialno) >= 16
525                      && xtoi_2 (parm->serialno+12) >= 2 );
526     }
527   else if (keywordlen == 7 && !memcmp (keyword, "APPTYPE", keywordlen))
528     {
529       xfree (parm->apptype);
530       parm->apptype = unescape_status_string (line);
531     }
532   else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
533     {
534       xfree (parm->disp_name);
535       parm->disp_name = unescape_status_string (line);
536     }
537   else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
538     {
539       xfree (parm->disp_lang);
540       parm->disp_lang = unescape_status_string (line);
541     }
542   else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
543     {
544       parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
545     }
546   else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
547     {
548       xfree (parm->pubkey_url);
549       parm->pubkey_url = unescape_status_string (line);
550     }
551   else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
552     {
553       xfree (parm->login_data);
554       parm->login_data = unescape_status_string (line);
555     }
556   else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
557     {
558       parm->sig_counter = strtoul (line, NULL, 0);
559     }
560   else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
561     {
562       char *p, *buf;
563
564       buf = p = unescape_status_string (line);
565       if (buf)
566         {
567           while (spacep (p))
568             p++;
569           parm->chv1_cached = atoi (p);
570           while (*p && !spacep (p))
571             p++;
572           while (spacep (p))
573             p++;
574           for (i=0; *p && i < 3; i++)
575             {
576               parm->chvmaxlen[i] = atoi (p);
577               while (*p && !spacep (p))
578                 p++;
579               while (spacep (p))
580                 p++;
581             }
582           for (i=0; *p && i < 3; i++)
583             {
584               parm->chvretry[i] = atoi (p);
585               while (*p && !spacep (p))
586                 p++;
587               while (spacep (p))
588                 p++;
589             }
590           xfree (buf);
591         }
592     }
593   else if (keywordlen == 6 && !memcmp (keyword, "EXTCAP", keywordlen))
594     {
595       char *p, *p2, *buf;
596       int abool;
597
598       buf = p = unescape_status_string (line);
599       if (buf)
600         {
601           for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
602             {
603               p2 = strchr (p, '=');
604               if (p2)
605                 {
606                   *p2++ = 0;
607                   abool = (*p2 == '1');
608                   if (!strcmp (p, "ki"))
609                     parm->extcap.ki = abool;
610                   else if (!strcmp (p, "aac"))
611                     parm->extcap.aac = abool;
612                   else if (!strcmp (p, "bt"))
613                     parm->extcap.bt = abool;
614                   else if (!strcmp (p, "kdf"))
615                     parm->extcap.kdf = abool;
616                   else if (!strcmp (p, "si"))
617                     parm->status_indicator = strtoul (p2, NULL, 10);
618                 }
619             }
620           xfree (buf);
621         }
622     }
623   else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
624     {
625       int no = atoi (line);
626       while (*line && !spacep (line))
627         line++;
628       while (spacep (line))
629         line++;
630       if (no == 1)
631         parm->fpr1len = unhexify_fpr (line, parm->fpr1, sizeof parm->fpr1);
632       else if (no == 2)
633         parm->fpr2len = unhexify_fpr (line, parm->fpr2, sizeof parm->fpr2);
634       else if (no == 3)
635         parm->fpr3len = unhexify_fpr (line, parm->fpr3, sizeof parm->fpr3);
636     }
637   else if (keywordlen == 8 && !memcmp (keyword, "KEY-TIME", keywordlen))
638     {
639       int no = atoi (line);
640       while (* line && !spacep (line))
641         line++;
642       while (spacep (line))
643         line++;
644       if (no == 1)
645         parm->fpr1time = strtoul (line, NULL, 10);
646       else if (no == 2)
647         parm->fpr2time = strtoul (line, NULL, 10);
648       else if (no == 3)
649         parm->fpr3time = strtoul (line, NULL, 10);
650     }
651   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
652     {
653       const char *hexgrp = line;
654       int no;
655
656       while (*line && !spacep (line))
657         line++;
658       while (spacep (line))
659         line++;
660       if (strncmp (line, "OPENPGP.", 8))
661         ;
662       else if ((no = atoi (line+8)) == 1)
663         unhexify_fpr (hexgrp, parm->grp1, sizeof parm->grp1);
664       else if (no == 2)
665         unhexify_fpr (hexgrp, parm->grp2, sizeof parm->grp2);
666       else if (no == 3)
667         unhexify_fpr (hexgrp, parm->grp3, sizeof parm->grp3);
668     }
669   else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
670     {
671       int no = atoi (line);
672       while (*line && !spacep (line))
673         line++;
674       while (spacep (line))
675         line++;
676       if (no == 1)
677         parm->cafpr1len = unhexify_fpr (line, parm->cafpr1,sizeof parm->cafpr1);
678       else if (no == 2)
679         parm->cafpr2len = unhexify_fpr (line, parm->cafpr2,sizeof parm->cafpr2);
680       else if (no == 3)
681         parm->cafpr3len = unhexify_fpr (line, parm->cafpr3,sizeof parm->cafpr3);
682     }
683   else if (keywordlen == 8 && !memcmp (keyword, "KEY-ATTR", keywordlen))
684     {
685       int keyno = 0;
686       int algo = PUBKEY_ALGO_RSA;
687       int n = 0;
688
689       sscanf (line, "%d %d %n", &keyno, &algo, &n);
690       keyno--;
691       if (keyno < 0 || keyno >= DIM (parm->key_attr))
692         return 0;
693
694       parm->key_attr[keyno].algo = algo;
695       if (algo == PUBKEY_ALGO_RSA)
696         parm->key_attr[keyno].nbits = strtoul (line+n+3, NULL, 10);
697       else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
698                || algo == PUBKEY_ALGO_EDDSA)
699         parm->key_attr[keyno].curve = openpgp_is_curve_supported (line + n,
700                                                                   NULL, NULL);
701     }
702   else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
703            && strchr("1234", keyword[11]))
704     {
705       int no = keyword[11] - '1';
706       log_assert (no >= 0 && no <= 3);
707       xfree (parm->private_do[no]);
708       parm->private_do[no] = unescape_status_string (line);
709     }
710   else if (keywordlen == 3 && !memcmp (keyword, "KDF", 3))
711     {
712       parm->kdf_do_enabled = 1;
713     }
714   else if (keywordlen == 5 && !memcmp (keyword, "UIF-", 4)
715            && strchr("123", keyword[4]))
716     {
717       unsigned char *data;
718       int no = keyword[4] - '1';
719
720       log_assert (no >= 0 && no <= 2);
721       data = unescape_status_string (line);
722       parm->uif[no] = (data[0] != 0xff);
723       xfree (data);
724     }
725
726   return 0;
727 }
728
729
730 /* Call the scdaemon to learn about a smartcard.  Note that in
731  * contradiction to the function's name, gpg-agent's LEARN command is
732  * used and not the low-level "SCD LEARN".
733  * Used by:
734  *  card-util.c
735  *  keyedit_menu
736  *  card_store_key_with_backup  (Woth force to remove secret key data)
737  */
738 int
739 agent_scd_learn (struct agent_card_info_s *info, int force)
740 {
741   int rc;
742   struct default_inq_parm_s parm;
743   struct agent_card_info_s dummyinfo;
744
745   if (!info)
746     info = &dummyinfo;
747   memset (info, 0, sizeof *info);
748   memset (&parm, 0, sizeof parm);
749
750   rc = start_agent (NULL, 1);
751   if (rc)
752     return rc;
753
754   parm.ctx = agent_ctx;
755   rc = assuan_transact (agent_ctx,
756                         force ? "LEARN --sendinfo --force" : "LEARN --sendinfo",
757                         dummy_data_cb, NULL, default_inq_cb, &parm,
758                         learn_status_cb, info);
759   /* Also try to get the key attributes.  */
760   if (!rc)
761     agent_scd_getattr ("KEY-ATTR", info);
762
763   if (info == &dummyinfo)
764     agent_release_card_info (info);
765
766   return rc;
767 }
768
769
770 \f
771 /* Callback for the agent_scd_keypairinfo function.  */
772 static gpg_error_t
773 scd_keypairinfo_status_cb (void *opaque, const char *line)
774 {
775   strlist_t *listaddr = opaque;
776   const char *keyword = line;
777   int keywordlen;
778   strlist_t sl;
779   char *p;
780
781   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
782     ;
783   while (spacep (line))
784     line++;
785
786   if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
787     {
788       sl = append_to_strlist (listaddr, line);
789       p = sl->d;
790       /* Make sure that we only have two tokens so that future
791        * extensions of the format won't change the format expected by
792        * the caller.  */
793       while (*p && !spacep (p))
794         p++;
795       if (*p)
796         {
797           while (spacep (p))
798             p++;
799           while (*p && !spacep (p))
800             p++;
801           if (*p)
802             {
803               *p++ = 0;
804               while (spacep (p))
805                 p++;
806               while (*p && !spacep (p))
807                 {
808                   switch (*p++)
809                     {
810                     case 'c': sl->flags |= GCRY_PK_USAGE_CERT; break;
811                     case 's': sl->flags |= GCRY_PK_USAGE_SIGN; break;
812                     case 'e': sl->flags |= GCRY_PK_USAGE_ENCR; break;
813                     case 'a': sl->flags |= GCRY_PK_USAGE_AUTH; break;
814                     }
815                 }
816             }
817         }
818     }
819
820   return 0;
821 }
822
823
824 /* Read the keypairinfo lines of the current card directly from
825  * scdaemon.  The list is returned as a string made up of the keygrip,
826  * a space and the keyref.  The flags of the string carry the usage
827  * bits.  If KEYREF is not NULL, only a single string is returned
828  * which matches the given keyref. */
829 gpg_error_t
830 agent_scd_keypairinfo (ctrl_t ctrl, const char *keyref, strlist_t *r_list)
831 {
832   gpg_error_t err;
833   strlist_t list = NULL;
834   struct default_inq_parm_s inq_parm;
835   char line[ASSUAN_LINELENGTH];
836
837   *r_list = NULL;
838   err= start_agent (ctrl, 1);
839   if (err)
840     return err;
841   memset (&inq_parm, 0, sizeof inq_parm);
842   inq_parm.ctx = agent_ctx;
843
844   if (keyref)
845     snprintf (line, DIM(line), "SCD READKEY --info-only %s", keyref);
846   else
847     snprintf (line, DIM(line), "SCD LEARN --keypairinfo");
848
849   err = assuan_transact (agent_ctx, line,
850                          NULL, NULL,
851                          default_inq_cb, &inq_parm,
852                          scd_keypairinfo_status_cb, &list);
853   if (!err && !list)
854     err = gpg_error (GPG_ERR_NO_DATA);
855   if (err)
856     {
857       free_strlist (list);
858       return err;
859     }
860   *r_list = list;
861   return 0;
862 }
863
864
865
866 /* Send an APDU to the current card.  On success the status word is
867  * stored at R_SW.  With HEXAPDU being NULL only a RESET command is
868  * send to scd.  With HEXAPDU being the string "undefined" the command
869  * "SERIALNO undefined" is send to scd.
870  * Used by:
871  *  card-util.c
872  */
873 gpg_error_t
874 agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
875 {
876   gpg_error_t err;
877
878   /* Start the agent but not with the card flag so that we do not
879      autoselect the openpgp application.  */
880   err = start_agent (NULL, 0);
881   if (err)
882     return err;
883
884   if (!hexapdu)
885     {
886       err = assuan_transact (agent_ctx, "SCD RESET",
887                              NULL, NULL, NULL, NULL, NULL, NULL);
888
889     }
890   else if (!strcmp (hexapdu, "undefined"))
891     {
892       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
893                              NULL, NULL, NULL, NULL, NULL, NULL);
894     }
895   else
896     {
897       char line[ASSUAN_LINELENGTH];
898       membuf_t mb;
899       unsigned char *data;
900       size_t datalen;
901
902       init_membuf (&mb, 256);
903
904       snprintf (line, DIM(line), "SCD APDU %s", hexapdu);
905       err = assuan_transact (agent_ctx, line,
906                              put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
907       if (!err)
908         {
909           data = get_membuf (&mb, &datalen);
910           if (!data)
911             err = gpg_error_from_syserror ();
912           else if (datalen < 2) /* Ooops */
913             err = gpg_error (GPG_ERR_CARD);
914           else
915             {
916               *r_sw = buf16_to_uint (data+datalen-2);
917             }
918           xfree (data);
919         }
920     }
921
922   return err;
923 }
924
925
926 /* Used by:
927  *  card_store_subkey
928  *  card_store_key_with_backup
929  */
930 int
931 agent_keytocard (const char *hexgrip, int keyno, int force,
932                  const char *serialno, const char *timestamp)
933 {
934   int rc;
935   char line[ASSUAN_LINELENGTH];
936   struct default_inq_parm_s parm;
937
938   memset (&parm, 0, sizeof parm);
939
940   snprintf (line, DIM(line), "KEYTOCARD %s%s %s OPENPGP.%d %s",
941             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
942
943   rc = start_agent (NULL, 1);
944   if (rc)
945     return rc;
946   parm.ctx = agent_ctx;
947
948   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
949                         NULL, NULL);
950   if (rc)
951     return rc;
952
953   return rc;
954 }
955
956
957 \f
958 /* Object used with the agent_scd_getattr_one.  */
959 struct getattr_one_parm_s {
960   const char *keyword;  /* Keyword to look for.  */
961   char *data;           /* Malloced and unescaped data.  */
962   gpg_error_t err;      /* Error code or 0 on success. */
963 };
964
965
966 /* Callback for agent_scd_getattr_one.  */
967 static gpg_error_t
968 getattr_one_status_cb (void *opaque, const char *line)
969 {
970   struct getattr_one_parm_s *parm = opaque;
971   const char *s;
972
973   if (parm->data)
974     return 0; /* We want only the first occurrence.  */
975
976   if ((s=has_leading_keyword (line, parm->keyword)))
977     {
978       parm->data = percent_plus_unescape (s, 0xff);
979       if (!parm->data)
980         parm->err = gpg_error_from_syserror ();
981     }
982
983   return 0;
984 }
985
986
987 /* Simplified version of agent_scd_getattr.  This function returns
988  * only the first occurance of the attribute NAME and stores it at
989  * R_VALUE.  A nul in the result is silennly replaced by 0xff.  On
990  * error NULL is stored at R_VALUE.  */
991 gpg_error_t
992 agent_scd_getattr_one (const char *name, char **r_value)
993 {
994   gpg_error_t err;
995   char line[ASSUAN_LINELENGTH];
996   struct default_inq_parm_s inqparm;
997   struct getattr_one_parm_s parm;
998
999   *r_value = NULL;
1000
1001   if (!*name)
1002     return gpg_error (GPG_ERR_INV_VALUE);
1003
1004   memset (&inqparm, 0, sizeof inqparm);
1005   inqparm.ctx = agent_ctx;
1006
1007   memset (&parm, 0, sizeof parm);
1008   parm.keyword = name;
1009
1010   /* We assume that NAME does not need escaping. */
1011   if (12 + strlen (name) > DIM(line)-1)
1012     return gpg_error (GPG_ERR_TOO_LARGE);
1013   stpcpy (stpcpy (line, "SCD GETATTR "), name);
1014
1015   err = start_agent (NULL, 1);
1016   if (err)
1017     return err;
1018
1019   err = assuan_transact (agent_ctx, line,
1020                          NULL, NULL,
1021                          default_inq_cb, &inqparm,
1022                          getattr_one_status_cb, &parm);
1023   if (!err && parm.err)
1024     err = parm.err;
1025   else if (!err && !parm.data)
1026     err = gpg_error (GPG_ERR_NO_DATA);
1027
1028   if (!err)
1029     *r_value = parm.data;
1030   else
1031     xfree (parm.data);
1032
1033   return err;
1034 }
1035
1036
1037 \f
1038 /* Call the agent to retrieve a data object.  This function returns
1039  * the data in the same structure as used by the learn command.  It is
1040  * allowed to update such a structure using this command.
1041  *
1042  *  Used by:
1043  *     build_sk_list
1044  *     enum_secret_keys
1045  *     get_signature_count
1046  *     card-util.c
1047  *     generate_keypair (KEY-ATTR)
1048  *     card_store_key_with_backup (SERIALNO)
1049  *     generate_card_subkeypair  (KEY-ATTR)
1050  */
1051 int
1052 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
1053 {
1054   int rc;
1055   char line[ASSUAN_LINELENGTH];
1056   struct default_inq_parm_s parm;
1057
1058   memset (&parm, 0, sizeof parm);
1059
1060   if (!*name)
1061     return gpg_error (GPG_ERR_INV_VALUE);
1062
1063   /* We assume that NAME does not need escaping. */
1064   if (12 + strlen (name) > DIM(line)-1)
1065     return gpg_error (GPG_ERR_TOO_LARGE);
1066   stpcpy (stpcpy (line, "SCD GETATTR "), name);
1067
1068   rc = start_agent (NULL, 1);
1069   if (rc)
1070     return rc;
1071
1072   parm.ctx = agent_ctx;
1073   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
1074                         learn_status_cb, info);
1075
1076   return rc;
1077 }
1078
1079
1080 \f
1081 /* Send an setattr command to the SCdaemon.
1082  * Used by:
1083  *   card-util.c
1084  */
1085 gpg_error_t
1086 agent_scd_setattr (const char *name, const void *value_arg, size_t valuelen)
1087 {
1088   gpg_error_t err;
1089   const unsigned char *value = value_arg;
1090   char line[ASSUAN_LINELENGTH];
1091   char *p;
1092   struct default_inq_parm_s parm;
1093
1094   memset (&parm, 0, sizeof parm);
1095
1096   if (!*name || !valuelen)
1097     return gpg_error (GPG_ERR_INV_VALUE);
1098
1099   /* We assume that NAME does not need escaping. */
1100   if (12 + strlen (name) > DIM(line)-1)
1101     return gpg_error (GPG_ERR_TOO_LARGE);
1102
1103   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
1104   *p++ = ' ';
1105   for (; valuelen; value++, valuelen--)
1106     {
1107       if (p >= line + DIM(line)-5 )
1108         return gpg_error (GPG_ERR_TOO_LARGE);
1109       if (*value < ' ' || *value == '+' || *value == '%')
1110         {
1111           sprintf (p, "%%%02X", *value);
1112           p += 3;
1113         }
1114       else if (*value == ' ')
1115         *p++ = '+';
1116       else
1117         *p++ = *value;
1118     }
1119   *p = 0;
1120
1121   err = start_agent (NULL, 1);
1122   if (!err)
1123     {
1124       parm.ctx = agent_ctx;
1125       err = assuan_transact (agent_ctx, line, NULL, NULL,
1126                             default_inq_cb, &parm, NULL, NULL);
1127     }
1128
1129   status_sc_op_failure (err);
1130   return err;
1131 }
1132
1133
1134 \f
1135 /* Handle a CERTDATA inquiry.  Note, we only send the data,
1136    assuan_transact takes care of flushing and writing the END
1137    command. */
1138 static gpg_error_t
1139 inq_writecert_parms (void *opaque, const char *line)
1140 {
1141   int rc;
1142   struct writecert_parm_s *parm = opaque;
1143
1144   if (has_leading_keyword (line, "CERTDATA"))
1145     {
1146       rc = assuan_send_data (parm->dflt->ctx,
1147                              parm->certdata, parm->certdatalen);
1148     }
1149   else
1150     rc = default_inq_cb (parm->dflt, line);
1151
1152   return rc;
1153 }
1154
1155
1156 /* Send a WRITECERT command to the SCdaemon.
1157  * Used by:
1158  *  card-util.c
1159  */
1160 int
1161 agent_scd_writecert (const char *certidstr,
1162                      const unsigned char *certdata, size_t certdatalen)
1163 {
1164   int rc;
1165   char line[ASSUAN_LINELENGTH];
1166   struct writecert_parm_s parms;
1167   struct default_inq_parm_s dfltparm;
1168
1169   memset (&dfltparm, 0, sizeof dfltparm);
1170
1171   rc = start_agent (NULL, 1);
1172   if (rc)
1173     return rc;
1174
1175   memset (&parms, 0, sizeof parms);
1176
1177   snprintf (line, DIM(line), "SCD WRITECERT %s", certidstr);
1178   dfltparm.ctx = agent_ctx;
1179   parms.dflt = &dfltparm;
1180   parms.certdata = certdata;
1181   parms.certdatalen = certdatalen;
1182
1183   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1184                         inq_writecert_parms, &parms, NULL, NULL);
1185
1186   return rc;
1187 }
1188
1189
1190 \f
1191 /* Status callback for the SCD GENKEY command. */
1192 static gpg_error_t
1193 scd_genkey_cb (void *opaque, const char *line)
1194 {
1195   u32 *createtime = opaque;
1196   const char *keyword = line;
1197   int keywordlen;
1198
1199   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1200     ;
1201   while (spacep (line))
1202     line++;
1203
1204  if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
1205     {
1206       *createtime = (u32)strtoul (line, NULL, 10);
1207     }
1208   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
1209     {
1210       write_status_text (STATUS_PROGRESS, line);
1211     }
1212
1213   return 0;
1214 }
1215
1216 /* Send a GENKEY command to the SCdaemon.  If *CREATETIME is not 0,
1217  * the value will be passed to SCDAEMON with --timestamp option so that
1218  * the key is created with this.  Otherwise, timestamp was generated by
1219  * SCDEAMON.  On success, creation time is stored back to
1220  * CREATETIME.
1221  * Used by:
1222  *   gen_card_key
1223  */
1224 int
1225 agent_scd_genkey (int keyno, int force, u32 *createtime)
1226 {
1227   int rc;
1228   char line[ASSUAN_LINELENGTH];
1229   gnupg_isotime_t tbuf;
1230   struct default_inq_parm_s dfltparm;
1231
1232   memset (&dfltparm, 0, sizeof dfltparm);
1233
1234   rc = start_agent (NULL, 1);
1235   if (rc)
1236     return rc;
1237
1238   if (*createtime)
1239     epoch2isotime (tbuf, *createtime);
1240   else
1241     *tbuf = 0;
1242
1243   snprintf (line, DIM(line), "SCD GENKEY %s%s %s %d",
1244             *tbuf? "--timestamp=":"", tbuf,
1245             force? "--force":"",
1246             keyno);
1247
1248   dfltparm.ctx = agent_ctx;
1249   rc = assuan_transact (agent_ctx, line,
1250                         NULL, NULL, default_inq_cb, &dfltparm,
1251                         scd_genkey_cb, createtime);
1252
1253   status_sc_op_failure (rc);
1254   return rc;
1255 }
1256
1257
1258 \f
1259 /* Return the serial number of the card or an appropriate error.  The
1260  * serial number is returned as a hexstring.  With DEMAND the active
1261  * card is switched to the card with that serialno.
1262  * Used by:
1263  *   card-util.c
1264  *   build_sk_list
1265  *   enum_secret_keys
1266  */
1267 int
1268 agent_scd_serialno (char **r_serialno, const char *demand)
1269 {
1270   int err;
1271   char *serialno = NULL;
1272   char line[ASSUAN_LINELENGTH];
1273
1274   err = start_agent (NULL, (1 | FLAG_FOR_CARD_SUPPRESS_ERRORS));
1275   if (err)
1276     return err;
1277
1278   if (!demand)
1279     strcpy (line, "SCD SERIALNO");
1280   else
1281     snprintf (line, DIM(line), "SCD SERIALNO --demand=%s", demand);
1282
1283   err = assuan_transact (agent_ctx, line,
1284                          NULL, NULL, NULL, NULL,
1285                          get_serialno_cb, &serialno);
1286   if (err)
1287     {
1288       xfree (serialno);
1289       return err;
1290     }
1291
1292   *r_serialno = serialno;
1293   return 0;
1294 }
1295
1296
1297 \f
1298 /* Send a READCERT command to the SCdaemon.
1299  * Used by:
1300  *  card-util.c
1301  */
1302 int
1303 agent_scd_readcert (const char *certidstr,
1304                     void **r_buf, size_t *r_buflen)
1305 {
1306   int rc;
1307   char line[ASSUAN_LINELENGTH];
1308   membuf_t data;
1309   size_t len;
1310   struct default_inq_parm_s dfltparm;
1311
1312   memset (&dfltparm, 0, sizeof dfltparm);
1313
1314   *r_buf = NULL;
1315   rc = start_agent (NULL, 1);
1316   if (rc)
1317     return rc;
1318
1319   dfltparm.ctx = agent_ctx;
1320
1321   init_membuf (&data, 2048);
1322
1323   snprintf (line, DIM(line), "SCD READCERT %s", certidstr);
1324   rc = assuan_transact (agent_ctx, line,
1325                         put_membuf_cb, &data,
1326                         default_inq_cb, &dfltparm,
1327                         NULL, NULL);
1328   if (rc)
1329     {
1330       xfree (get_membuf (&data, &len));
1331       return rc;
1332     }
1333   *r_buf = get_membuf (&data, r_buflen);
1334   if (!*r_buf)
1335     return gpg_error (GPG_ERR_ENOMEM);
1336
1337   return 0;
1338 }
1339
1340
1341 /* This is a variant of agent_readkey which sends a READKEY command
1342  * directly Scdaemon.  On success a new s-expression is stored at
1343  * R_RESULT.  */
1344 gpg_error_t
1345 agent_scd_readkey (const char *keyrefstr, gcry_sexp_t *r_result)
1346 {
1347   gpg_error_t err;
1348   char line[ASSUAN_LINELENGTH];
1349   membuf_t data;
1350   unsigned char *buf;
1351   size_t len, buflen;
1352   struct default_inq_parm_s dfltparm;
1353
1354   memset (&dfltparm, 0, sizeof dfltparm);
1355   dfltparm.ctx = agent_ctx;
1356
1357   *r_result = NULL;
1358   err = start_agent (NULL, 1);
1359   if (err)
1360     return err;
1361
1362   init_membuf (&data, 1024);
1363   snprintf (line, DIM(line), "SCD READKEY %s", keyrefstr);
1364   err = assuan_transact (agent_ctx, line,
1365                          put_membuf_cb, &data,
1366                          default_inq_cb, &dfltparm,
1367                          NULL, NULL);
1368   if (err)
1369     {
1370       xfree (get_membuf (&data, &len));
1371       return err;
1372     }
1373   buf = get_membuf (&data, &buflen);
1374   if (!buf)
1375     return gpg_error_from_syserror ();
1376
1377   err = gcry_sexp_new (r_result, buf, buflen, 0);
1378   xfree (buf);
1379
1380   return err;
1381 }
1382
1383
1384 \f
1385 struct card_cardlist_parm_s {
1386   int error;
1387   strlist_t list;
1388 };
1389
1390
1391 /* Callback function for agent_card_cardlist.  */
1392 static gpg_error_t
1393 card_cardlist_cb (void *opaque, const char *line)
1394 {
1395   struct card_cardlist_parm_s *parm = opaque;
1396   const char *keyword = line;
1397   int keywordlen;
1398
1399   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1400     ;
1401   while (spacep (line))
1402     line++;
1403
1404   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
1405     {
1406       const char *s;
1407       int n;
1408
1409       for (n=0,s=line; hexdigitp (s); s++, n++)
1410         ;
1411
1412       if (!n || (n&1) || *s)
1413         parm->error = gpg_error (GPG_ERR_ASS_PARAMETER);
1414       else
1415         add_to_strlist (&parm->list, line);
1416     }
1417
1418   return 0;
1419 }
1420
1421
1422 /* Return a list of currently available cards.
1423  * Used by:
1424  *   card-util.c
1425  *   skclist.c
1426  */
1427 int
1428 agent_scd_cardlist (strlist_t *result)
1429 {
1430   int err;
1431   char line[ASSUAN_LINELENGTH];
1432   struct card_cardlist_parm_s parm;
1433
1434   memset (&parm, 0, sizeof parm);
1435   *result = NULL;
1436   err = start_agent (NULL, 1 | FLAG_FOR_CARD_SUPPRESS_ERRORS);
1437   if (err)
1438     return err;
1439
1440   strcpy (line, "SCD GETINFO card_list");
1441
1442   err = assuan_transact (agent_ctx, line,
1443                          NULL, NULL, NULL, NULL,
1444                          card_cardlist_cb, &parm);
1445   if (!err && parm.error)
1446     err = parm.error;
1447
1448   if (!err)
1449     *result = parm.list;
1450   else
1451     free_strlist (parm.list);
1452
1453   return 0;
1454 }
1455
1456
1457 \f
1458 /* Change the PIN of an OpenPGP card or reset the retry counter.
1459  * CHVNO 1: Change the PIN
1460  *       2: For v1 cards: Same as 1.
1461  *          For v2 cards: Reset the PIN using the Reset Code.
1462  *       3: Change the admin PIN
1463  *     101: Set a new PIN and reset the retry counter
1464  *     102: For v1 cars: Same as 101.
1465  *          For v2 cards: Set a new Reset Code.
1466  * SERIALNO is not used.
1467  * Used by:
1468  *  card-util.c
1469  */
1470 int
1471 agent_scd_change_pin (int chvno, const char *serialno)
1472 {
1473   int rc;
1474   char line[ASSUAN_LINELENGTH];
1475   const char *reset = "";
1476   struct default_inq_parm_s dfltparm;
1477
1478   memset (&dfltparm, 0, sizeof dfltparm);
1479
1480   (void)serialno;
1481
1482   if (chvno >= 100)
1483     reset = "--reset";
1484   chvno %= 100;
1485
1486   rc = start_agent (NULL, 1);
1487   if (rc)
1488     return rc;
1489   dfltparm.ctx = agent_ctx;
1490
1491   snprintf (line, DIM(line), "SCD PASSWD %s %d", reset, chvno);
1492   rc = assuan_transact (agent_ctx, line,
1493                         NULL, NULL,
1494                         default_inq_cb, &dfltparm,
1495                         NULL, NULL);
1496   status_sc_op_failure (rc);
1497   return rc;
1498 }
1499
1500
1501 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1502  * number of the card - optionally followed by the fingerprint;
1503  * however the fingerprint is ignored here.
1504  * Used by:
1505  *  card-util.c
1506  */
1507 int
1508 agent_scd_checkpin  (const char *serialno)
1509 {
1510   int rc;
1511   char line[ASSUAN_LINELENGTH];
1512   struct default_inq_parm_s dfltparm;
1513
1514   memset (&dfltparm, 0, sizeof dfltparm);
1515
1516   rc = start_agent (NULL, 1);
1517   if (rc)
1518     return rc;
1519   dfltparm.ctx = agent_ctx;
1520
1521   snprintf (line, DIM(line), "SCD CHECKPIN %s", serialno);
1522   rc = assuan_transact (agent_ctx, line,
1523                         NULL, NULL,
1524                         default_inq_cb, &dfltparm,
1525                         NULL, NULL);
1526   status_sc_op_failure (rc);
1527   return rc;
1528 }
1529
1530
1531 \f
1532 /* Note: All strings shall be UTF-8. On success the caller needs to
1533    free the string stored at R_PASSPHRASE. On error NULL will be
1534    stored at R_PASSPHRASE and an appropriate fpf error code
1535    returned. */
1536 gpg_error_t
1537 agent_get_passphrase (const char *cache_id,
1538                       const char *err_msg,
1539                       const char *prompt,
1540                       const char *desc_msg,
1541                       int repeat,
1542                       int check,
1543                       char **r_passphrase)
1544 {
1545   int rc;
1546   char line[ASSUAN_LINELENGTH];
1547   char *arg1 = NULL;
1548   char *arg2 = NULL;
1549   char *arg3 = NULL;
1550   char *arg4 = NULL;
1551   membuf_t data;
1552   struct default_inq_parm_s dfltparm;
1553
1554   memset (&dfltparm, 0, sizeof dfltparm);
1555
1556   *r_passphrase = NULL;
1557
1558   rc = start_agent (NULL, 0);
1559   if (rc)
1560     return rc;
1561   dfltparm.ctx = agent_ctx;
1562
1563   /* Check that the gpg-agent understands the repeat option.  */
1564   if (assuan_transact (agent_ctx,
1565                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1566                        NULL, NULL, NULL, NULL, NULL, NULL))
1567     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1568
1569   if (cache_id && *cache_id)
1570     if (!(arg1 = percent_plus_escape (cache_id)))
1571       goto no_mem;
1572   if (err_msg && *err_msg)
1573     if (!(arg2 = percent_plus_escape (err_msg)))
1574       goto no_mem;
1575   if (prompt && *prompt)
1576     if (!(arg3 = percent_plus_escape (prompt)))
1577       goto no_mem;
1578   if (desc_msg && *desc_msg)
1579     if (!(arg4 = percent_plus_escape (desc_msg)))
1580       goto no_mem;
1581
1582   snprintf (line, DIM(line),
1583             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1584             repeat,
1585             check? " --check --qualitybar":"",
1586             arg1? arg1:"X",
1587             arg2? arg2:"X",
1588             arg3? arg3:"X",
1589             arg4? arg4:"X");
1590   xfree (arg1);
1591   xfree (arg2);
1592   xfree (arg3);
1593   xfree (arg4);
1594
1595   init_membuf_secure (&data, 64);
1596   rc = assuan_transact (agent_ctx, line,
1597                         put_membuf_cb, &data,
1598                         default_inq_cb, &dfltparm,
1599                         NULL, NULL);
1600
1601   if (rc)
1602     xfree (get_membuf (&data, NULL));
1603   else
1604     {
1605       put_membuf (&data, "", 1);
1606       *r_passphrase = get_membuf (&data, NULL);
1607       if (!*r_passphrase)
1608         rc = gpg_error_from_syserror ();
1609     }
1610   return rc;
1611  no_mem:
1612   rc = gpg_error_from_syserror ();
1613   xfree (arg1);
1614   xfree (arg2);
1615   xfree (arg3);
1616   xfree (arg4);
1617   return rc;
1618 }
1619
1620
1621 gpg_error_t
1622 agent_clear_passphrase (const char *cache_id)
1623 {
1624   int rc;
1625   char line[ASSUAN_LINELENGTH];
1626   struct default_inq_parm_s dfltparm;
1627
1628   memset (&dfltparm, 0, sizeof dfltparm);
1629
1630   if (!cache_id || !*cache_id)
1631     return 0;
1632
1633   rc = start_agent (NULL, 0);
1634   if (rc)
1635     return rc;
1636   dfltparm.ctx = agent_ctx;
1637
1638   snprintf (line, DIM(line), "CLEAR_PASSPHRASE %s", cache_id);
1639   return assuan_transact (agent_ctx, line,
1640                           NULL, NULL,
1641                           default_inq_cb, &dfltparm,
1642                           NULL, NULL);
1643 }
1644
1645
1646 /* Ask the agent to pop up a confirmation dialog with the text DESC
1647    and an okay and cancel button. */
1648 gpg_error_t
1649 gpg_agent_get_confirmation (const char *desc)
1650 {
1651   int rc;
1652   char *tmp;
1653   char line[ASSUAN_LINELENGTH];
1654   struct default_inq_parm_s dfltparm;
1655
1656   memset (&dfltparm, 0, sizeof dfltparm);
1657
1658   rc = start_agent (NULL, 0);
1659   if (rc)
1660     return rc;
1661   dfltparm.ctx = agent_ctx;
1662
1663   tmp = percent_plus_escape (desc);
1664   if (!tmp)
1665     return gpg_error_from_syserror ();
1666   snprintf (line, DIM(line), "GET_CONFIRMATION %s", tmp);
1667   xfree (tmp);
1668
1669   rc = assuan_transact (agent_ctx, line,
1670                         NULL, NULL,
1671                         default_inq_cb, &dfltparm,
1672                         NULL, NULL);
1673   return rc;
1674 }
1675
1676
1677 /* Return the S2K iteration count as computed by gpg-agent.  On error
1678  * print a warning and return a default value. */
1679 unsigned long
1680 agent_get_s2k_count (void)
1681 {
1682   gpg_error_t err;
1683   membuf_t data;
1684   char *buf;
1685   unsigned long count = 0;
1686
1687   err = start_agent (NULL, 0);
1688   if (err)
1689     goto leave;
1690
1691   init_membuf (&data, 32);
1692   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1693                         put_membuf_cb, &data,
1694                         NULL, NULL, NULL, NULL);
1695   if (err)
1696     xfree (get_membuf (&data, NULL));
1697   else
1698     {
1699       put_membuf (&data, "", 1);
1700       buf = get_membuf (&data, NULL);
1701       if (!buf)
1702         err = gpg_error_from_syserror ();
1703       else
1704         {
1705           count = strtoul (buf, NULL, 10);
1706           xfree (buf);
1707         }
1708     }
1709
1710  leave:
1711   if (err || count < 65536)
1712     {
1713       /* Don't print an error if an older agent is used.  */
1714       if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
1715         log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
1716
1717       /* Default to 65536 which was used up to 2.0.13.  */
1718       count = 65536;
1719     }
1720
1721   return count;
1722 }
1723
1724
1725 \f
1726 /* Ask the agent whether a secret key for the given public key is
1727    available.  Returns 0 if available.  */
1728 gpg_error_t
1729 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1730 {
1731   gpg_error_t err;
1732   char line[ASSUAN_LINELENGTH];
1733   char *hexgrip;
1734
1735   err = start_agent (ctrl, 0);
1736   if (err)
1737     return err;
1738
1739   err = hexkeygrip_from_pk (pk, &hexgrip);
1740   if (err)
1741     return err;
1742
1743   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1744   xfree (hexgrip);
1745
1746   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1747   return err;
1748 }
1749
1750 /* Ask the agent whether a secret key is available for any of the
1751    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1752 gpg_error_t
1753 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1754 {
1755   gpg_error_t err;
1756   char line[ASSUAN_LINELENGTH];
1757   char *p;
1758   kbnode_t kbctx, node;
1759   int nkeys;
1760   unsigned char grip[KEYGRIP_LEN];
1761
1762   err = start_agent (ctrl, 0);
1763   if (err)
1764     return err;
1765
1766   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1767                                           found in KEYBLOCK.  */
1768   p = stpcpy (line, "HAVEKEY");
1769   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1770     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1771         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1772         || node->pkt->pkttype == PKT_SECRET_KEY
1773         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1774       {
1775         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1776           {
1777             err = assuan_transact (agent_ctx, line,
1778                                    NULL, NULL, NULL, NULL, NULL, NULL);
1779             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1780               break; /* Seckey available or unexpected error - ready.  */
1781             p = stpcpy (line, "HAVEKEY");
1782             nkeys = 0;
1783           }
1784
1785         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1786         if (err)
1787           return err;
1788         *p++ = ' ';
1789         bin2hex (grip, 20, p);
1790         p += 40;
1791         nkeys++;
1792       }
1793
1794   if (!err && nkeys)
1795     err = assuan_transact (agent_ctx, line,
1796                            NULL, NULL, NULL, NULL, NULL, NULL);
1797
1798   return err;
1799 }
1800
1801
1802 \f
1803 struct keyinfo_data_parm_s
1804 {
1805   char *serialno;
1806   int cleartext;
1807 };
1808
1809
1810 static gpg_error_t
1811 keyinfo_status_cb (void *opaque, const char *line)
1812 {
1813   struct keyinfo_data_parm_s *data = opaque;
1814   int is_smartcard;
1815   char *s;
1816
1817   if ((s = has_leading_keyword (line, "KEYINFO")) && data)
1818     {
1819       /* Parse the arguments:
1820        *      0        1        2        3       4          5
1821        *   <keygrip> <type> <serialno> <idstr> <cached> <protection>
1822        */
1823       char *fields[6];
1824
1825       if (split_fields (s, fields, DIM (fields)) == 6)
1826         {
1827           is_smartcard = (fields[1][0] == 'T');
1828           if (is_smartcard && !data->serialno && strcmp (fields[2], "-"))
1829             data->serialno = xtrystrdup (fields[2]);
1830           /* 'P' for protected, 'C' for clear */
1831           data->cleartext = (fields[5][0] == 'C');
1832         }
1833     }
1834   return 0;
1835 }
1836
1837
1838 /* Return the serial number for a secret key.  If the returned serial
1839    number is NULL, the key is not stored on a smartcard.  Caller needs
1840    to free R_SERIALNO.
1841
1842    if r_cleartext is not NULL, the referenced int will be set to 1 if
1843    the agent's copy of the key is stored in the clear, or 0 otherwise
1844 */
1845 gpg_error_t
1846 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
1847                    char **r_serialno, int *r_cleartext)
1848 {
1849   gpg_error_t err;
1850   char line[ASSUAN_LINELENGTH];
1851   struct keyinfo_data_parm_s keyinfo;
1852
1853   memset (&keyinfo, 0,sizeof keyinfo);
1854
1855   *r_serialno = NULL;
1856
1857   err = start_agent (ctrl, 0);
1858   if (err)
1859     return err;
1860
1861   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1862     return gpg_error (GPG_ERR_INV_VALUE);
1863
1864   snprintf (line, DIM(line), "KEYINFO %s", hexkeygrip);
1865
1866   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1867                          keyinfo_status_cb, &keyinfo);
1868   if (!err && keyinfo.serialno)
1869     {
1870       /* Sanity check for bad characters.  */
1871       if (strpbrk (keyinfo.serialno, ":\n\r"))
1872         err = GPG_ERR_INV_VALUE;
1873     }
1874   if (err)
1875     xfree (keyinfo.serialno);
1876   else
1877     {
1878       *r_serialno = keyinfo.serialno;
1879       if (r_cleartext)
1880         *r_cleartext = keyinfo.cleartext;
1881     }
1882   return err;
1883 }
1884
1885 \f
1886 /* Status callback for agent_import_key, agent_export_key and
1887    agent_genkey.  */
1888 static gpg_error_t
1889 cache_nonce_status_cb (void *opaque, const char *line)
1890 {
1891   struct cache_nonce_parm_s *parm = opaque;
1892   const char *s;
1893
1894   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1895     {
1896       if (parm->cache_nonce_addr)
1897         {
1898           xfree (*parm->cache_nonce_addr);
1899           *parm->cache_nonce_addr = xtrystrdup (s);
1900         }
1901     }
1902   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1903     {
1904       if (parm->passwd_nonce_addr)
1905         {
1906           xfree (*parm->passwd_nonce_addr);
1907           *parm->passwd_nonce_addr = xtrystrdup (s);
1908         }
1909     }
1910   else if ((s = has_leading_keyword (line, "PROGRESS")))
1911     {
1912       if (opt.enable_progress_filter)
1913         write_status_text (STATUS_PROGRESS, s);
1914     }
1915
1916   return 0;
1917 }
1918
1919
1920 \f
1921 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1922    assuan_transact takes care of flushing and writing the end */
1923 static gpg_error_t
1924 inq_genkey_parms (void *opaque, const char *line)
1925 {
1926   struct genkey_parm_s *parm = opaque;
1927   gpg_error_t err;
1928
1929   if (has_leading_keyword (line, "KEYPARAM"))
1930     {
1931       err = assuan_send_data (parm->dflt->ctx,
1932                               parm->keyparms, strlen (parm->keyparms));
1933     }
1934   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1935     {
1936       err = assuan_send_data (parm->dflt->ctx,
1937                               parm->passphrase,  strlen (parm->passphrase));
1938     }
1939   else
1940     err = default_inq_cb (parm->dflt, line);
1941
1942   return err;
1943 }
1944
1945
1946 /* Call the agent to generate a new key.  KEYPARMS is the usual
1947    S-expression giving the parameters of the key.  gpg-agent passes it
1948    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1949    to protect the generated key.  If NO_PROTECTION is not set and
1950    PASSPHRASE is not NULL the agent is requested to protect the key
1951    with that passphrase instead of asking for one.  */
1952 gpg_error_t
1953 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
1954               const char *keyparms, int no_protection,
1955               const char *passphrase, gcry_sexp_t *r_pubkey)
1956 {
1957   gpg_error_t err;
1958   struct genkey_parm_s gk_parm;
1959   struct cache_nonce_parm_s cn_parm;
1960   struct default_inq_parm_s dfltparm;
1961   membuf_t data;
1962   size_t len;
1963   unsigned char *buf;
1964   char line[ASSUAN_LINELENGTH];
1965
1966   memset (&dfltparm, 0, sizeof dfltparm);
1967   dfltparm.ctrl = ctrl;
1968
1969   *r_pubkey = NULL;
1970   err = start_agent (ctrl, 0);
1971   if (err)
1972     return err;
1973   dfltparm.ctx = agent_ctx;
1974
1975   if (passwd_nonce_addr && *passwd_nonce_addr)
1976     ; /* A RESET would flush the passwd nonce cache.  */
1977   else
1978     {
1979       err = assuan_transact (agent_ctx, "RESET",
1980                              NULL, NULL, NULL, NULL, NULL, NULL);
1981       if (err)
1982         return err;
1983     }
1984
1985   init_membuf (&data, 1024);
1986   gk_parm.dflt     = &dfltparm;
1987   gk_parm.keyparms = keyparms;
1988   gk_parm.passphrase = passphrase;
1989   snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
1990             no_protection? " --no-protection" :
1991             passphrase   ? " --inq-passwd" :
1992             /*          */ "",
1993             passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
1994             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1995             cache_nonce_addr && *cache_nonce_addr? " ":"",
1996             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1997   cn_parm.cache_nonce_addr = cache_nonce_addr;
1998   cn_parm.passwd_nonce_addr = NULL;
1999   err = assuan_transact (agent_ctx, line,
2000                          put_membuf_cb, &data,
2001                          inq_genkey_parms, &gk_parm,
2002                          cache_nonce_status_cb, &cn_parm);
2003   if (err)
2004     {
2005       xfree (get_membuf (&data, &len));
2006       return err;
2007     }
2008
2009   buf = get_membuf (&data, &len);
2010   if (!buf)
2011     err = gpg_error_from_syserror ();
2012   else
2013     {
2014       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
2015       xfree (buf);
2016     }
2017   return err;
2018 }
2019
2020
2021 \f
2022 /* Call the agent to read the public key part for a given keygrip.  If
2023    FROMCARD is true, the key is directly read from the current
2024    smartcard. In this case HEXKEYGRIP should be the keyID
2025    (e.g. OPENPGP.3). */
2026 gpg_error_t
2027 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
2028                unsigned char **r_pubkey)
2029 {
2030   gpg_error_t err;
2031   membuf_t data;
2032   size_t len;
2033   unsigned char *buf;
2034   char line[ASSUAN_LINELENGTH];
2035   struct default_inq_parm_s dfltparm;
2036
2037   memset (&dfltparm, 0, sizeof dfltparm);
2038   dfltparm.ctrl = ctrl;
2039
2040   *r_pubkey = NULL;
2041   err = start_agent (ctrl, 0);
2042   if (err)
2043     return err;
2044   dfltparm.ctx = agent_ctx;
2045
2046   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
2047   if (err)
2048     return err;
2049
2050   snprintf (line, DIM(line), "READKEY %s%s", fromcard? "--card ":"",
2051             hexkeygrip);
2052
2053   init_membuf (&data, 1024);
2054   err = assuan_transact (agent_ctx, line,
2055                          put_membuf_cb, &data,
2056                          default_inq_cb, &dfltparm,
2057                          NULL, NULL);
2058   if (err)
2059     {
2060       xfree (get_membuf (&data, &len));
2061       return err;
2062     }
2063   buf = get_membuf (&data, &len);
2064   if (!buf)
2065     return gpg_error_from_syserror ();
2066   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
2067     {
2068       xfree (buf);
2069       return gpg_error (GPG_ERR_INV_SEXP);
2070     }
2071   *r_pubkey = buf;
2072   return 0;
2073 }
2074
2075
2076 \f
2077 /* Call the agent to do a sign operation using the key identified by
2078    the hex string KEYGRIP.  DESC is a description of the key to be
2079    displayed if the agent needs to ask for the PIN.  DIGEST and
2080    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
2081    used to compute the digest.  If CACHE_NONCE is used the agent is
2082    advised to first try a passphrase associated with that nonce. */
2083 gpg_error_t
2084 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
2085               const char *keygrip, const char *desc,
2086               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2087               unsigned char *digest, size_t digestlen, int digestalgo,
2088               gcry_sexp_t *r_sigval)
2089 {
2090   gpg_error_t err;
2091   char line[ASSUAN_LINELENGTH];
2092   membuf_t data;
2093   struct default_inq_parm_s dfltparm;
2094
2095   memset (&dfltparm, 0, sizeof dfltparm);
2096   dfltparm.ctrl = ctrl;
2097   dfltparm.keyinfo.keyid       = keyid;
2098   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2099   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2100
2101   *r_sigval = NULL;
2102   err = start_agent (ctrl, 0);
2103   if (err)
2104     return err;
2105   dfltparm.ctx = agent_ctx;
2106
2107   if (digestlen*2 + 50 > DIM(line))
2108     return gpg_error (GPG_ERR_GENERAL);
2109
2110   err = assuan_transact (agent_ctx, "RESET",
2111                          NULL, NULL, NULL, NULL, NULL, NULL);
2112   if (err)
2113     return err;
2114
2115   snprintf (line, DIM(line), "SIGKEY %s", keygrip);
2116   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2117   if (err)
2118     return err;
2119
2120   if (desc)
2121     {
2122       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2123       err = assuan_transact (agent_ctx, line,
2124                             NULL, NULL, NULL, NULL, NULL, NULL);
2125       if (err)
2126         return err;
2127     }
2128
2129   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
2130   bin2hex (digest, digestlen, line + strlen (line));
2131   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2132   if (err)
2133     return err;
2134
2135   init_membuf (&data, 1024);
2136
2137   snprintf (line, sizeof line, "PKSIGN%s%s",
2138             cache_nonce? " -- ":"",
2139             cache_nonce? cache_nonce:"");
2140
2141   if (DBG_CLOCK)
2142     log_clock ("enter signing");
2143   err = assuan_transact (agent_ctx, line,
2144                          put_membuf_cb, &data,
2145                          default_inq_cb, &dfltparm,
2146                          NULL, NULL);
2147   if (DBG_CLOCK)
2148     log_clock ("leave signing");
2149
2150   if (err)
2151     xfree (get_membuf (&data, NULL));
2152   else
2153     {
2154       unsigned char *buf;
2155       size_t len;
2156
2157       buf = get_membuf (&data, &len);
2158       if (!buf)
2159         err = gpg_error_from_syserror ();
2160       else
2161         {
2162           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
2163           xfree (buf);
2164         }
2165     }
2166   return err;
2167 }
2168
2169
2170 \f
2171 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
2172    assuan_transact takes care of flushing and writing the END. */
2173 static gpg_error_t
2174 inq_ciphertext_cb (void *opaque, const char *line)
2175 {
2176   struct cipher_parm_s *parm = opaque;
2177   int rc;
2178
2179   if (has_leading_keyword (line, "CIPHERTEXT"))
2180     {
2181       assuan_begin_confidential (parm->ctx);
2182       rc = assuan_send_data (parm->dflt->ctx,
2183                              parm->ciphertext, parm->ciphertextlen);
2184       assuan_end_confidential (parm->ctx);
2185     }
2186   else
2187     rc = default_inq_cb (parm->dflt, line);
2188
2189   return rc;
2190 }
2191
2192
2193 /* Check whether there is any padding info from the agent.  */
2194 static gpg_error_t
2195 padding_info_cb (void *opaque, const char *line)
2196 {
2197   int *r_padding = opaque;
2198   const char *s;
2199
2200   if ((s=has_leading_keyword (line, "PADDING")))
2201     {
2202       *r_padding = atoi (s);
2203     }
2204
2205   return 0;
2206 }
2207
2208
2209 /* Call the agent to do a decrypt operation using the key identified
2210    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
2211    success the decoded value is stored verbatim at R_BUF and its
2212    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
2213    and PUBKEY_ALGO are used to construct additional promots or status
2214    messages.   The padding information is stored at R_PADDING with -1
2215    for not known.  */
2216 gpg_error_t
2217 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
2218                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2219                  gcry_sexp_t s_ciphertext,
2220                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
2221 {
2222   gpg_error_t err;
2223   char line[ASSUAN_LINELENGTH];
2224   membuf_t data;
2225   size_t n, len;
2226   char *p, *buf, *endp;
2227   struct default_inq_parm_s dfltparm;
2228
2229   memset (&dfltparm, 0, sizeof dfltparm);
2230   dfltparm.ctrl = ctrl;
2231   dfltparm.keyinfo.keyid       = keyid;
2232   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2233   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2234
2235   if (!keygrip || strlen(keygrip) != 40
2236       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
2237     return gpg_error (GPG_ERR_INV_VALUE);
2238
2239   *r_buf = NULL;
2240   *r_padding = -1;
2241
2242   err = start_agent (ctrl, 0);
2243   if (err)
2244     return err;
2245   dfltparm.ctx = agent_ctx;
2246
2247   err = assuan_transact (agent_ctx, "RESET",
2248                          NULL, NULL, NULL, NULL, NULL, NULL);
2249   if (err)
2250     return err;
2251
2252   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2253   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2254   if (err)
2255     return err;
2256
2257   if (desc)
2258     {
2259       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2260       err = assuan_transact (agent_ctx, line,
2261                             NULL, NULL, NULL, NULL, NULL, NULL);
2262       if (err)
2263         return err;
2264     }
2265
2266   init_membuf_secure (&data, 1024);
2267   {
2268     struct cipher_parm_s parm;
2269
2270     parm.dflt = &dfltparm;
2271     parm.ctx = agent_ctx;
2272     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2273     if (err)
2274       return err;
2275     err = assuan_transact (agent_ctx, "PKDECRYPT",
2276                            put_membuf_cb, &data,
2277                            inq_ciphertext_cb, &parm,
2278                            padding_info_cb, r_padding);
2279     xfree (parm.ciphertext);
2280   }
2281   if (err)
2282     {
2283       xfree (get_membuf (&data, &len));
2284       return err;
2285     }
2286
2287   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2288   buf = get_membuf (&data, &len);
2289   if (!buf)
2290     return gpg_error_from_syserror ();
2291   log_assert (len); /* (we forced Nul termination.)  */
2292
2293   if (*buf != '(')
2294     {
2295       xfree (buf);
2296       return gpg_error (GPG_ERR_INV_SEXP);
2297     }
2298
2299   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2300     {
2301       xfree (buf);
2302       return gpg_error (GPG_ERR_INV_SEXP);
2303     }
2304   len -= 10;   /* Count only the data of the second part. */
2305   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2306
2307   n = strtoul (p, &endp, 10);
2308   if (!n || *endp != ':')
2309     {
2310       xfree (buf);
2311       return gpg_error (GPG_ERR_INV_SEXP);
2312     }
2313   endp++;
2314   if (endp-p+n > len)
2315     {
2316       xfree (buf);
2317       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2318     }
2319
2320   memmove (buf, endp, n);
2321
2322   *r_buflen = n;
2323   *r_buf = buf;
2324   return 0;
2325 }
2326
2327
2328 \f
2329 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2330    the key shall be used for export, with false for import.  On success
2331    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2332 gpg_error_t
2333 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2334 {
2335   gpg_error_t err;
2336   membuf_t data;
2337   size_t len;
2338   unsigned char *buf;
2339   char line[ASSUAN_LINELENGTH];
2340   struct default_inq_parm_s dfltparm;
2341
2342   memset (&dfltparm, 0, sizeof dfltparm);
2343   dfltparm.ctrl = ctrl;
2344
2345   *r_kek = NULL;
2346   err = start_agent (ctrl, 0);
2347   if (err)
2348     return err;
2349   dfltparm.ctx = agent_ctx;
2350
2351   snprintf (line, DIM(line), "KEYWRAP_KEY %s",
2352             forexport? "--export":"--import");
2353
2354   init_membuf_secure (&data, 64);
2355   err = assuan_transact (agent_ctx, line,
2356                          put_membuf_cb, &data,
2357                          default_inq_cb, &dfltparm,
2358                          NULL, NULL);
2359   if (err)
2360     {
2361       xfree (get_membuf (&data, &len));
2362       return err;
2363     }
2364   buf = get_membuf (&data, &len);
2365   if (!buf)
2366     return gpg_error_from_syserror ();
2367   *r_kek = buf;
2368   *r_keklen = len;
2369   return 0;
2370 }
2371
2372
2373 \f
2374 /* Handle the inquiry for an IMPORT_KEY command.  */
2375 static gpg_error_t
2376 inq_import_key_parms (void *opaque, const char *line)
2377 {
2378   struct import_key_parm_s *parm = opaque;
2379   gpg_error_t err;
2380
2381   if (has_leading_keyword (line, "KEYDATA"))
2382     {
2383       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2384     }
2385   else
2386     err = default_inq_cb (parm->dflt, line);
2387
2388   return err;
2389 }
2390
2391
2392 /* Call the agent to import a key into the agent.  */
2393 gpg_error_t
2394 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2395                   const void *key, size_t keylen, int unattended, int force,
2396                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2397 {
2398   gpg_error_t err;
2399   struct import_key_parm_s parm;
2400   struct cache_nonce_parm_s cn_parm;
2401   char line[ASSUAN_LINELENGTH];
2402   struct default_inq_parm_s dfltparm;
2403
2404   memset (&dfltparm, 0, sizeof dfltparm);
2405   dfltparm.ctrl = ctrl;
2406   dfltparm.keyinfo.keyid       = keyid;
2407   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2408   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2409
2410   err = start_agent (ctrl, 0);
2411   if (err)
2412     return err;
2413   dfltparm.ctx = agent_ctx;
2414
2415   if (desc)
2416     {
2417       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2418       err = assuan_transact (agent_ctx, line,
2419                             NULL, NULL, NULL, NULL, NULL, NULL);
2420       if (err)
2421         return err;
2422     }
2423
2424   parm.dflt   = &dfltparm;
2425   parm.key    = key;
2426   parm.keylen = keylen;
2427
2428   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2429             unattended? " --unattended":"",
2430             force? " --force":"",
2431             cache_nonce_addr && *cache_nonce_addr? " ":"",
2432             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2433   cn_parm.cache_nonce_addr = cache_nonce_addr;
2434   cn_parm.passwd_nonce_addr = NULL;
2435   err = assuan_transact (agent_ctx, line,
2436                          NULL, NULL,
2437                          inq_import_key_parms, &parm,
2438                          cache_nonce_status_cb, &cn_parm);
2439   return err;
2440 }
2441
2442
2443 \f
2444 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2445    keygrip, DESC a prompt to be displayed with the agent's passphrase
2446    question (needs to be plus+percent escaped).  if OPENPGP_PROTECTED
2447    is not zero, ensure that the key material is returned in RFC
2448    4880-compatible passphrased-protected form.  If CACHE_NONCE_ADDR is
2449    not NULL the agent is advised to first try a passphrase associated
2450    with that nonce.  On success the key is stored as a canonical
2451    S-expression at R_RESULT and R_RESULTLEN.  */
2452 gpg_error_t
2453 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2454                   int openpgp_protected, char **cache_nonce_addr,
2455                   unsigned char **r_result, size_t *r_resultlen,
2456                   u32 *keyid, u32 *mainkeyid, int pubkey_algo)
2457 {
2458   gpg_error_t err;
2459   struct cache_nonce_parm_s cn_parm;
2460   membuf_t data;
2461   size_t len;
2462   unsigned char *buf;
2463   char line[ASSUAN_LINELENGTH];
2464   struct default_inq_parm_s dfltparm;
2465
2466   memset (&dfltparm, 0, sizeof dfltparm);
2467   dfltparm.ctrl = ctrl;
2468   dfltparm.keyinfo.keyid       = keyid;
2469   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2470   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2471
2472   *r_result = NULL;
2473
2474   err = start_agent (ctrl, 0);
2475   if (err)
2476     return err;
2477   dfltparm.ctx = agent_ctx;
2478
2479   if (desc)
2480     {
2481       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2482       err = assuan_transact (agent_ctx, line,
2483                              NULL, NULL, NULL, NULL, NULL, NULL);
2484       if (err)
2485         return err;
2486     }
2487
2488   snprintf (line, DIM(line), "EXPORT_KEY %s%s%s %s",
2489             openpgp_protected ? "--openpgp ":"",
2490             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2491             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2492             hexkeygrip);
2493
2494   init_membuf_secure (&data, 1024);
2495   cn_parm.cache_nonce_addr = cache_nonce_addr;
2496   cn_parm.passwd_nonce_addr = NULL;
2497   err = assuan_transact (agent_ctx, line,
2498                          put_membuf_cb, &data,
2499                          default_inq_cb, &dfltparm,
2500                          cache_nonce_status_cb, &cn_parm);
2501   if (err)
2502     {
2503       xfree (get_membuf (&data, &len));
2504       return err;
2505     }
2506   buf = get_membuf (&data, &len);
2507   if (!buf)
2508     return gpg_error_from_syserror ();
2509   *r_result = buf;
2510   *r_resultlen = len;
2511   return 0;
2512 }
2513
2514
2515 \f
2516 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2517    is not NULL, display DESC instead of the default description
2518    message.  If FORCE is true the agent is advised not to ask for
2519    confirmation. */
2520 gpg_error_t
2521 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2522                   int force)
2523 {
2524   gpg_error_t err;
2525   char line[ASSUAN_LINELENGTH];
2526   struct default_inq_parm_s dfltparm;
2527
2528   memset (&dfltparm, 0, sizeof dfltparm);
2529   dfltparm.ctrl = ctrl;
2530
2531   err = start_agent (ctrl, 0);
2532   if (err)
2533     return err;
2534
2535   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2536     return gpg_error (GPG_ERR_INV_VALUE);
2537
2538   if (desc)
2539     {
2540       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2541       err = assuan_transact (agent_ctx, line,
2542                              NULL, NULL, NULL, NULL, NULL, NULL);
2543       if (err)
2544         return err;
2545     }
2546
2547   snprintf (line, DIM(line), "DELETE_KEY%s %s",
2548             force? " --force":"", hexkeygrip);
2549   err = assuan_transact (agent_ctx, line, NULL, NULL,
2550                          default_inq_cb, &dfltparm,
2551                          NULL, NULL);
2552   return err;
2553 }
2554
2555
2556 \f
2557 /* Ask the agent to change the passphrase of the key identified by
2558  * HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2559  * default description message.  If CACHE_NONCE_ADDR is not NULL the
2560  * agent is advised to first try a passphrase associated with that
2561  * nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2562  * the passphrase associated with that nonce for the new passphrase.
2563  * If VERIFY is true the passphrase is only verified.  */
2564 gpg_error_t
2565 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
2566               char **cache_nonce_addr, char **passwd_nonce_addr)
2567 {
2568   gpg_error_t err;
2569   struct cache_nonce_parm_s cn_parm;
2570   char line[ASSUAN_LINELENGTH];
2571   struct default_inq_parm_s dfltparm;
2572
2573   memset (&dfltparm, 0, sizeof dfltparm);
2574   dfltparm.ctrl = ctrl;
2575
2576   err = start_agent (ctrl, 0);
2577   if (err)
2578     return err;
2579   dfltparm.ctx = agent_ctx;
2580
2581   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2582     return gpg_error (GPG_ERR_INV_VALUE);
2583
2584   if (desc)
2585     {
2586       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2587       err = assuan_transact (agent_ctx, line,
2588                              NULL, NULL, NULL, NULL, NULL, NULL);
2589       if (err)
2590         return err;
2591     }
2592
2593   if (verify)
2594     snprintf (line, DIM(line), "PASSWD %s%s --verify %s",
2595               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2596               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2597               hexkeygrip);
2598   else
2599     snprintf (line, DIM(line), "PASSWD %s%s %s%s %s",
2600               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2601               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2602               passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2603               passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2604               hexkeygrip);
2605   cn_parm.cache_nonce_addr = cache_nonce_addr;
2606   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2607   err = assuan_transact (agent_ctx, line, NULL, NULL,
2608                          default_inq_cb, &dfltparm,
2609                          cache_nonce_status_cb, &cn_parm);
2610   return err;
2611 }
2612
2613
2614 /* Return the version reported by gpg-agent.  */
2615 gpg_error_t
2616 agent_get_version (ctrl_t ctrl, char **r_version)
2617 {
2618   gpg_error_t err;
2619
2620   err = start_agent (ctrl, 0);
2621   if (err)
2622     return err;
2623
2624   err = get_assuan_server_version (agent_ctx, 0, r_version);
2625   return err;
2626 }