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