Fix use cases of snprintf.
[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 <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <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))
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         {
628           const char *curve;
629
630           for (i = 0; (curve = openpgp_enum_curves (&i));)
631             if (!strcmp (curve, line+n))
632               break;
633
634           parm->key_attr[keyno].curve = curve;
635         }
636     }
637   else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
638            && strchr("1234", keyword[11]))
639     {
640       int no = keyword[11] - '1';
641       log_assert (no >= 0 && no <= 3);
642       xfree (parm->private_do[no]);
643       parm->private_do[no] = unescape_status_string (line);
644     }
645
646   return 0;
647 }
648
649 /* Call the scdaemon to learn about a smartcard */
650 int
651 agent_scd_learn (struct agent_card_info_s *info, int force)
652 {
653   int rc;
654   struct default_inq_parm_s parm;
655   struct agent_card_info_s dummyinfo;
656
657   if (!info)
658     info = &dummyinfo;
659   memset (info, 0, sizeof *info);
660   memset (&parm, 0, sizeof parm);
661
662   rc = start_agent (NULL, 1);
663   if (rc)
664     return rc;
665
666   /* Send the serialno command to initialize the connection.  We don't
667      care about the data returned.  If the card has already been
668      initialized, this is a very fast command.  The main reason we
669      need to do this here is to handle a card removed case so that an
670      "l" command in --card-edit can be used to show ta newly inserted
671      card.  We request the openpgp card because that is what we
672      expect. */
673   rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
674                         NULL, NULL, NULL, NULL, NULL, NULL);
675   if (rc)
676     return rc;
677
678   parm.ctx = agent_ctx;
679   rc = assuan_transact (agent_ctx,
680                         force ? "LEARN --sendinfo --force" : "LEARN --sendinfo",
681                         dummy_data_cb, NULL, default_inq_cb, &parm,
682                         learn_status_cb, info);
683   /* Also try to get the key attributes.  */
684   if (!rc)
685     agent_scd_getattr ("KEY-ATTR", info);
686
687   if (info == &dummyinfo)
688     agent_release_card_info (info);
689
690   return rc;
691 }
692
693
694 /* Send an APDU to the current card.  On success the status word is
695    stored at R_SW.  With HEXAPDU being NULL only a RESET command is
696    send to scd.  With HEXAPDU being the string "undefined" the command
697    "SERIALNO undefined" is send to scd. */
698 gpg_error_t
699 agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
700 {
701   gpg_error_t err;
702
703   /* Start the agent but not with the card flag so that we do not
704      autoselect the openpgp application.  */
705   err = start_agent (NULL, 0);
706   if (err)
707     return err;
708
709   if (!hexapdu)
710     {
711       err = assuan_transact (agent_ctx, "SCD RESET",
712                              NULL, NULL, NULL, NULL, NULL, NULL);
713
714     }
715   else if (!strcmp (hexapdu, "undefined"))
716     {
717       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
718                              NULL, NULL, NULL, NULL, NULL, NULL);
719     }
720   else
721     {
722       char line[ASSUAN_LINELENGTH];
723       membuf_t mb;
724       unsigned char *data;
725       size_t datalen;
726
727       init_membuf (&mb, 256);
728
729       snprintf (line, DIM(line), "SCD APDU %s", hexapdu);
730       err = assuan_transact (agent_ctx, line,
731                              put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
732       if (!err)
733         {
734           data = get_membuf (&mb, &datalen);
735           if (!data)
736             err = gpg_error_from_syserror ();
737           else if (datalen < 2) /* Ooops */
738             err = gpg_error (GPG_ERR_CARD);
739           else
740             {
741               *r_sw = buf16_to_uint (data+datalen-2);
742             }
743           xfree (data);
744         }
745     }
746
747   return err;
748 }
749
750
751 int
752 agent_keytocard (const char *hexgrip, int keyno, int force,
753                  const char *serialno, const char *timestamp)
754 {
755   int rc;
756   char line[ASSUAN_LINELENGTH];
757   struct default_inq_parm_s parm;
758
759   memset (&parm, 0, sizeof parm);
760
761   snprintf (line, DIM(line), "KEYTOCARD %s%s %s OPENPGP.%d %s",
762             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
763
764   rc = start_agent (NULL, 1);
765   if (rc)
766     return rc;
767   parm.ctx = agent_ctx;
768
769   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
770                         NULL, NULL);
771   if (rc)
772     return rc;
773
774   return rc;
775 }
776 \f
777 /* Call the agent to retrieve a data object.  This function returns
778    the data in the same structure as used by the learn command.  It is
779    allowed to update such a structure using this commmand. */
780 int
781 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
782 {
783   int rc;
784   char line[ASSUAN_LINELENGTH];
785   struct default_inq_parm_s parm;
786
787   memset (&parm, 0, sizeof parm);
788
789   if (!*name)
790     return gpg_error (GPG_ERR_INV_VALUE);
791
792   /* We assume that NAME does not need escaping. */
793   if (12 + strlen (name) > DIM(line)-1)
794     return gpg_error (GPG_ERR_TOO_LARGE);
795   stpcpy (stpcpy (line, "SCD GETATTR "), name);
796
797   rc = start_agent (NULL, 1);
798   if (rc)
799     return rc;
800
801   parm.ctx = agent_ctx;
802   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
803                         learn_status_cb, info);
804
805   return rc;
806 }
807
808 \f
809 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
810    used here but required by gpg 1.4's implementation of this code in
811    cardglue.c. */
812 int
813 agent_scd_setattr (const char *name,
814                    const unsigned char *value, size_t valuelen,
815                    const char *serialno)
816 {
817   int rc;
818   char line[ASSUAN_LINELENGTH];
819   char *p;
820   struct default_inq_parm_s parm;
821
822   memset (&parm, 0, sizeof parm);
823
824   (void)serialno;
825
826   if (!*name || !valuelen)
827     return gpg_error (GPG_ERR_INV_VALUE);
828
829   /* We assume that NAME does not need escaping. */
830   if (12 + strlen (name) > DIM(line)-1)
831     return gpg_error (GPG_ERR_TOO_LARGE);
832
833   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
834   *p++ = ' ';
835   for (; valuelen; value++, valuelen--)
836     {
837       if (p >= line + DIM(line)-5 )
838         return gpg_error (GPG_ERR_TOO_LARGE);
839       if (*value < ' ' || *value == '+' || *value == '%')
840         {
841           sprintf (p, "%%%02X", *value);
842           p += 3;
843         }
844       else if (*value == ' ')
845         *p++ = '+';
846       else
847         *p++ = *value;
848     }
849   *p = 0;
850
851   rc = start_agent (NULL, 1);
852   if (!rc)
853     {
854       parm.ctx = agent_ctx;
855       rc = assuan_transact (agent_ctx, line, NULL, NULL,
856                             default_inq_cb, &parm, NULL, NULL);
857     }
858
859   status_sc_op_failure (rc);
860   return rc;
861 }
862
863
864 \f
865 /* Handle a CERTDATA inquiry.  Note, we only send the data,
866    assuan_transact takes care of flushing and writing the END
867    command. */
868 static gpg_error_t
869 inq_writecert_parms (void *opaque, const char *line)
870 {
871   int rc;
872   struct writecert_parm_s *parm = opaque;
873
874   if (has_leading_keyword (line, "CERTDATA"))
875     {
876       rc = assuan_send_data (parm->dflt->ctx,
877                              parm->certdata, parm->certdatalen);
878     }
879   else
880     rc = default_inq_cb (parm->dflt, line);
881
882   return rc;
883 }
884
885
886 /* Send a WRITECERT command to the SCdaemon. */
887 int
888 agent_scd_writecert (const char *certidstr,
889                      const unsigned char *certdata, size_t certdatalen)
890 {
891   int rc;
892   char line[ASSUAN_LINELENGTH];
893   struct writecert_parm_s parms;
894   struct default_inq_parm_s dfltparm;
895
896   memset (&dfltparm, 0, sizeof dfltparm);
897
898   rc = start_agent (NULL, 1);
899   if (rc)
900     return rc;
901
902   memset (&parms, 0, sizeof parms);
903
904   snprintf (line, DIM(line), "SCD WRITECERT %s", certidstr);
905   dfltparm.ctx = agent_ctx;
906   parms.dflt = &dfltparm;
907   parms.certdata = certdata;
908   parms.certdatalen = certdatalen;
909
910   rc = assuan_transact (agent_ctx, line, NULL, NULL,
911                         inq_writecert_parms, &parms, NULL, NULL);
912
913   return rc;
914 }
915
916
917 \f
918 /* Handle a KEYDATA inquiry.  Note, we only send the data,
919    assuan_transact takes care of flushing and writing the end */
920 static gpg_error_t
921 inq_writekey_parms (void *opaque, const char *line)
922 {
923   int rc;
924   struct writekey_parm_s *parm = opaque;
925
926   if (has_leading_keyword (line, "KEYDATA"))
927     {
928       rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
929     }
930   else
931     rc = default_inq_cb (parm->dflt, line);
932
933   return rc;
934 }
935
936
937 /* Send a WRITEKEY command to the SCdaemon. */
938 int
939 agent_scd_writekey (int keyno, const char *serialno,
940                     const unsigned char *keydata, size_t keydatalen)
941 {
942   int rc;
943   char line[ASSUAN_LINELENGTH];
944   struct writekey_parm_s parms;
945   struct default_inq_parm_s dfltparm;
946
947   memset (&dfltparm, 0, sizeof dfltparm);
948
949   (void)serialno;
950
951   rc = start_agent (NULL, 1);
952   if (rc)
953     return rc;
954
955   memset (&parms, 0, sizeof parms);
956
957   snprintf (line, DIM(line), "SCD WRITEKEY --force OPENPGP.%d", keyno);
958   dfltparm.ctx = agent_ctx;
959   parms.dflt = &dfltparm;
960   parms.keydata = keydata;
961   parms.keydatalen = keydatalen;
962
963   rc = assuan_transact (agent_ctx, line, NULL, NULL,
964                         inq_writekey_parms, &parms, NULL, NULL);
965
966   status_sc_op_failure (rc);
967   return rc;
968 }
969
970
971 \f
972 /* Status callback for the SCD GENKEY command. */
973 static gpg_error_t
974 scd_genkey_cb (void *opaque, const char *line)
975 {
976   u32 *createtime = opaque;
977   const char *keyword = line;
978   int keywordlen;
979
980   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
981     ;
982   while (spacep (line))
983     line++;
984
985  if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
986     {
987       *createtime = (u32)strtoul (line, NULL, 10);
988     }
989   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
990     {
991       write_status_text (STATUS_PROGRESS, line);
992     }
993
994   return 0;
995 }
996
997 /* Send a GENKEY command to the SCdaemon.  If CREATETIME is not 0, it
998   will be passed to SCDAEMON so that the key is created with this
999   timestamp.  On success, creation time  is stored back to CREATETIME.  */
1000 int
1001 agent_scd_genkey (int keyno, int force, u32 *createtime)
1002 {
1003   int rc;
1004   char line[ASSUAN_LINELENGTH];
1005   gnupg_isotime_t tbuf;
1006   struct default_inq_parm_s dfltparm;
1007
1008   memset (&dfltparm, 0, sizeof dfltparm);
1009
1010   rc = start_agent (NULL, 1);
1011   if (rc)
1012     return rc;
1013
1014   if (*createtime)
1015     epoch2isotime (tbuf, *createtime);
1016   else
1017     *tbuf = 0;
1018
1019   snprintf (line, DIM(line), "SCD GENKEY %s%s %s %d",
1020             *tbuf? "--timestamp=":"", tbuf,
1021             force? "--force":"",
1022             keyno);
1023
1024   dfltparm.ctx = agent_ctx;
1025   rc = assuan_transact (agent_ctx, line,
1026                         NULL, NULL, default_inq_cb, &dfltparm,
1027                         scd_genkey_cb, createtime);
1028
1029   status_sc_op_failure (rc);
1030   return rc;
1031 }
1032
1033
1034
1035 \f
1036 /* Issue an SCD SERIALNO openpgp command and if SERIALNO is not NULL
1037    ask the user to insert the requested card.  */
1038 gpg_error_t
1039 select_openpgp (const char *serialno)
1040 {
1041   gpg_error_t err;
1042
1043   /* Send the serialno command to initialize the connection.  Without
1044      a given S/N we don't care about the data returned.  If the card
1045      has already been initialized, this is a very fast command.  We
1046      request the openpgp card because that is what we expect.
1047
1048      Note that an opt.limit_card_insert_tries of 1 means: No tries at
1049      all whereas 0 means do not limit the number of tries.  Due to the
1050      sue of a pinentry prompt with a cancel option we use it here in a
1051      boolean sense.  */
1052   if (!serialno || opt.limit_card_insert_tries == 1)
1053     err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
1054                            NULL, NULL, NULL, NULL, NULL, NULL);
1055   else
1056     {
1057       char *this_sn = NULL;
1058       char *desc;
1059       int ask;
1060       char *want_sn;
1061       char *p;
1062
1063       want_sn = xtrystrdup (serialno);
1064       if (!want_sn)
1065         return gpg_error_from_syserror ();
1066       p = strchr (want_sn, '/');
1067       if (p)
1068         *p = 0;
1069
1070       do
1071         {
1072           ask = 0;
1073           err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
1074                                  NULL, NULL, NULL, NULL,
1075                                  get_serialno_cb, &this_sn);
1076           if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
1077             ask = 1;
1078           else if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
1079             ask = 2;
1080           else if (err)
1081             ;
1082           else if (this_sn)
1083             {
1084               if (strcmp (want_sn, this_sn))
1085                 ask = 2;
1086             }
1087
1088           xfree (this_sn);
1089           this_sn = NULL;
1090
1091           if (ask)
1092             {
1093               char *formatted = NULL;
1094               char *ocodeset = i18n_switchto_utf8 ();
1095
1096               if (!strncmp (want_sn, "D27600012401", 12)
1097                   && strlen (want_sn) == 32 )
1098                 formatted = xtryasprintf ("(%.4s) %.8s",
1099                                           want_sn + 16, want_sn + 20);
1100
1101               err = 0;
1102               desc = xtryasprintf
1103                 ("%s:\n\n"
1104                  "  \"%s\"",
1105                  ask == 1
1106                  ? _("Please insert the card with serial number")
1107                  : _("Please remove the current card and "
1108                      "insert the one with serial number"),
1109                  formatted? formatted : want_sn);
1110               if (!desc)
1111                 err = gpg_error_from_syserror ();
1112               xfree (formatted);
1113               i18n_switchback (ocodeset);
1114               if (!err)
1115                 err = gpg_agent_get_confirmation (desc);
1116               xfree (desc);
1117             }
1118         }
1119       while (ask && !err);
1120       xfree (want_sn);
1121     }
1122
1123   return err;
1124 }
1125
1126
1127 \f
1128 /* Send a READCERT command to the SCdaemon. */
1129 int
1130 agent_scd_readcert (const char *certidstr,
1131                     void **r_buf, size_t *r_buflen)
1132 {
1133   int rc;
1134   char line[ASSUAN_LINELENGTH];
1135   membuf_t data;
1136   size_t len;
1137   struct default_inq_parm_s dfltparm;
1138
1139   memset (&dfltparm, 0, sizeof dfltparm);
1140
1141   *r_buf = NULL;
1142   rc = start_agent (NULL, 1);
1143   if (rc)
1144     return rc;
1145
1146   dfltparm.ctx = agent_ctx;
1147
1148   init_membuf (&data, 2048);
1149
1150   snprintf (line, DIM(line), "SCD READCERT %s", certidstr);
1151   rc = assuan_transact (agent_ctx, line,
1152                         put_membuf_cb, &data,
1153                         default_inq_cb, &dfltparm,
1154                         NULL, NULL);
1155   if (rc)
1156     {
1157       xfree (get_membuf (&data, &len));
1158       return rc;
1159     }
1160   *r_buf = get_membuf (&data, r_buflen);
1161   if (!*r_buf)
1162     return gpg_error (GPG_ERR_ENOMEM);
1163
1164   return 0;
1165 }
1166
1167
1168 \f
1169 /* Change the PIN of an OpenPGP card or reset the retry counter.
1170    CHVNO 1: Change the PIN
1171          2: For v1 cards: Same as 1.
1172             For v2 cards: Reset the PIN using the Reset Code.
1173          3: Change the admin PIN
1174        101: Set a new PIN and reset the retry counter
1175        102: For v1 cars: Same as 101.
1176             For v2 cards: Set a new Reset Code.
1177    SERIALNO is not used.
1178  */
1179 int
1180 agent_scd_change_pin (int chvno, const char *serialno)
1181 {
1182   int rc;
1183   char line[ASSUAN_LINELENGTH];
1184   const char *reset = "";
1185   struct default_inq_parm_s dfltparm;
1186
1187   memset (&dfltparm, 0, sizeof dfltparm);
1188
1189   (void)serialno;
1190
1191   if (chvno >= 100)
1192     reset = "--reset";
1193   chvno %= 100;
1194
1195   rc = start_agent (NULL, 1);
1196   if (rc)
1197     return rc;
1198   dfltparm.ctx = agent_ctx;
1199
1200   snprintf (line, DIM(line), "SCD PASSWD %s %d", reset, chvno);
1201   rc = assuan_transact (agent_ctx, line,
1202                         NULL, NULL,
1203                         default_inq_cb, &dfltparm,
1204                         NULL, NULL);
1205   status_sc_op_failure (rc);
1206   return rc;
1207 }
1208
1209
1210 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1211    number of the card - optionally followed by the fingerprint;
1212    however the fingerprint is ignored here. */
1213 int
1214 agent_scd_checkpin  (const char *serialno)
1215 {
1216   int rc;
1217   char line[ASSUAN_LINELENGTH];
1218   struct default_inq_parm_s dfltparm;
1219
1220   memset (&dfltparm, 0, sizeof dfltparm);
1221
1222   rc = start_agent (NULL, 1);
1223   if (rc)
1224     return rc;
1225   dfltparm.ctx = agent_ctx;
1226
1227   snprintf (line, DIM(line), "SCD CHECKPIN %s", serialno);
1228   rc = assuan_transact (agent_ctx, line,
1229                         NULL, NULL,
1230                         default_inq_cb, &dfltparm,
1231                         NULL, NULL);
1232   status_sc_op_failure (rc);
1233   return rc;
1234 }
1235
1236
1237 /* Dummy function, only used by the gpg 1.4 implementation. */
1238 void
1239 agent_clear_pin_cache (const char *sn)
1240 {
1241   (void)sn;
1242 }
1243
1244
1245
1246 \f
1247 /* Note: All strings shall be UTF-8. On success the caller needs to
1248    free the string stored at R_PASSPHRASE. On error NULL will be
1249    stored at R_PASSPHRASE and an appropriate fpf error code
1250    returned. */
1251 gpg_error_t
1252 agent_get_passphrase (const char *cache_id,
1253                       const char *err_msg,
1254                       const char *prompt,
1255                       const char *desc_msg,
1256                       int repeat,
1257                       int check,
1258                       char **r_passphrase)
1259 {
1260   int rc;
1261   char line[ASSUAN_LINELENGTH];
1262   char *arg1 = NULL;
1263   char *arg2 = NULL;
1264   char *arg3 = NULL;
1265   char *arg4 = NULL;
1266   membuf_t data;
1267   struct default_inq_parm_s dfltparm;
1268
1269   memset (&dfltparm, 0, sizeof dfltparm);
1270
1271   *r_passphrase = NULL;
1272
1273   rc = start_agent (NULL, 0);
1274   if (rc)
1275     return rc;
1276   dfltparm.ctx = agent_ctx;
1277
1278   /* Check that the gpg-agent understands the repeat option.  */
1279   if (assuan_transact (agent_ctx,
1280                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1281                        NULL, NULL, NULL, NULL, NULL, NULL))
1282     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1283
1284   if (cache_id && *cache_id)
1285     if (!(arg1 = percent_plus_escape (cache_id)))
1286       goto no_mem;
1287   if (err_msg && *err_msg)
1288     if (!(arg2 = percent_plus_escape (err_msg)))
1289       goto no_mem;
1290   if (prompt && *prompt)
1291     if (!(arg3 = percent_plus_escape (prompt)))
1292       goto no_mem;
1293   if (desc_msg && *desc_msg)
1294     if (!(arg4 = percent_plus_escape (desc_msg)))
1295       goto no_mem;
1296
1297   snprintf (line, DIM(line),
1298             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1299             repeat,
1300             check? " --check --qualitybar":"",
1301             arg1? arg1:"X",
1302             arg2? arg2:"X",
1303             arg3? arg3:"X",
1304             arg4? arg4:"X");
1305   xfree (arg1);
1306   xfree (arg2);
1307   xfree (arg3);
1308   xfree (arg4);
1309
1310   init_membuf_secure (&data, 64);
1311   rc = assuan_transact (agent_ctx, line,
1312                         put_membuf_cb, &data,
1313                         default_inq_cb, &dfltparm,
1314                         NULL, NULL);
1315
1316   if (rc)
1317     xfree (get_membuf (&data, NULL));
1318   else
1319     {
1320       put_membuf (&data, "", 1);
1321       *r_passphrase = get_membuf (&data, NULL);
1322       if (!*r_passphrase)
1323         rc = gpg_error_from_syserror ();
1324     }
1325   return rc;
1326  no_mem:
1327   rc = gpg_error_from_syserror ();
1328   xfree (arg1);
1329   xfree (arg2);
1330   xfree (arg3);
1331   xfree (arg4);
1332   return rc;
1333 }
1334
1335
1336 gpg_error_t
1337 agent_clear_passphrase (const char *cache_id)
1338 {
1339   int rc;
1340   char line[ASSUAN_LINELENGTH];
1341   struct default_inq_parm_s dfltparm;
1342
1343   memset (&dfltparm, 0, sizeof dfltparm);
1344
1345   if (!cache_id || !*cache_id)
1346     return 0;
1347
1348   rc = start_agent (NULL, 0);
1349   if (rc)
1350     return rc;
1351   dfltparm.ctx = agent_ctx;
1352
1353   snprintf (line, DIM(line), "CLEAR_PASSPHRASE %s", cache_id);
1354   return assuan_transact (agent_ctx, line,
1355                           NULL, NULL,
1356                           default_inq_cb, &dfltparm,
1357                           NULL, NULL);
1358 }
1359
1360
1361 /* Ask the agent to pop up a confirmation dialog with the text DESC
1362    and an okay and cancel button. */
1363 gpg_error_t
1364 gpg_agent_get_confirmation (const char *desc)
1365 {
1366   int rc;
1367   char *tmp;
1368   char line[ASSUAN_LINELENGTH];
1369   struct default_inq_parm_s dfltparm;
1370
1371   memset (&dfltparm, 0, sizeof dfltparm);
1372
1373   rc = start_agent (NULL, 0);
1374   if (rc)
1375     return rc;
1376   dfltparm.ctx = agent_ctx;
1377
1378   tmp = percent_plus_escape (desc);
1379   if (!tmp)
1380     return gpg_error_from_syserror ();
1381   snprintf (line, DIM(line), "GET_CONFIRMATION %s", tmp);
1382   xfree (tmp);
1383
1384   rc = assuan_transact (agent_ctx, line,
1385                         NULL, NULL,
1386                         default_inq_cb, &dfltparm,
1387                         NULL, NULL);
1388   return rc;
1389 }
1390
1391
1392 /* Return the S2K iteration count as computed by gpg-agent.  */
1393 gpg_error_t
1394 agent_get_s2k_count (unsigned long *r_count)
1395 {
1396   gpg_error_t err;
1397   membuf_t data;
1398   char *buf;
1399
1400   *r_count = 0;
1401
1402   err = start_agent (NULL, 0);
1403   if (err)
1404     return err;
1405
1406   init_membuf (&data, 32);
1407   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1408                         put_membuf_cb, &data,
1409                         NULL, NULL, NULL, NULL);
1410   if (err)
1411     xfree (get_membuf (&data, NULL));
1412   else
1413     {
1414       put_membuf (&data, "", 1);
1415       buf = get_membuf (&data, NULL);
1416       if (!buf)
1417         err = gpg_error_from_syserror ();
1418       else
1419         {
1420           *r_count = strtoul (buf, NULL, 10);
1421           xfree (buf);
1422         }
1423     }
1424   return err;
1425 }
1426
1427
1428 \f
1429 /* Ask the agent whether a secret key for the given public key is
1430    available.  Returns 0 if available.  */
1431 gpg_error_t
1432 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1433 {
1434   gpg_error_t err;
1435   char line[ASSUAN_LINELENGTH];
1436   char *hexgrip;
1437
1438   err = start_agent (ctrl, 0);
1439   if (err)
1440     return err;
1441
1442   err = hexkeygrip_from_pk (pk, &hexgrip);
1443   if (err)
1444     return err;
1445
1446   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1447   xfree (hexgrip);
1448
1449   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1450   return err;
1451 }
1452
1453 /* Ask the agent whether a secret key is available for any of the
1454    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1455 gpg_error_t
1456 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1457 {
1458   gpg_error_t err;
1459   char line[ASSUAN_LINELENGTH];
1460   char *p;
1461   kbnode_t kbctx, node;
1462   int nkeys;
1463   unsigned char grip[20];
1464
1465   err = start_agent (ctrl, 0);
1466   if (err)
1467     return err;
1468
1469   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1470                                           found in KEYBLOCK.  */
1471   p = stpcpy (line, "HAVEKEY");
1472   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1473     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1474         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1475         || node->pkt->pkttype == PKT_SECRET_KEY
1476         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1477       {
1478         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1479           {
1480             err = assuan_transact (agent_ctx, line,
1481                                    NULL, NULL, NULL, NULL, NULL, NULL);
1482             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1483               break; /* Seckey available or unexpected error - ready.  */
1484             p = stpcpy (line, "HAVEKEY");
1485             nkeys = 0;
1486           }
1487
1488         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1489         if (err)
1490           return err;
1491         *p++ = ' ';
1492         bin2hex (grip, 20, p);
1493         p += 40;
1494         nkeys++;
1495       }
1496
1497   if (!err && nkeys)
1498     err = assuan_transact (agent_ctx, line,
1499                            NULL, NULL, NULL, NULL, NULL, NULL);
1500
1501   return err;
1502 }
1503
1504
1505 \f
1506 struct keyinfo_data_parm_s
1507 {
1508   char *serialno;
1509   int cleartext;
1510 };
1511
1512
1513 static gpg_error_t
1514 keyinfo_status_cb (void *opaque, const char *line)
1515 {
1516   struct keyinfo_data_parm_s *data = opaque;
1517   int is_smartcard;
1518   char *s;
1519
1520   if ((s = has_leading_keyword (line, "KEYINFO")) && data)
1521     {
1522       /* Parse the arguments:
1523        *      0        1        2        3       4          5
1524        *   <keygrip> <type> <serialno> <idstr> <cached> <protection>
1525        */
1526       char *fields[6];
1527
1528       if (split_fields (s, fields, DIM (fields)) == 6)
1529         {
1530           is_smartcard = (fields[1][0] == 'T');
1531           if (is_smartcard && !data->serialno && strcmp (fields[2], "-"))
1532             data->serialno = xtrystrdup (fields[2]);
1533           /* 'P' for protected, 'C' for clear */
1534           data->cleartext = (fields[5][0] == 'C');
1535         }
1536     }
1537   return 0;
1538 }
1539
1540
1541 /* Return the serial number for a secret key.  If the returned serial
1542    number is NULL, the key is not stored on a smartcard.  Caller needs
1543    to free R_SERIALNO.
1544
1545    if r_cleartext is not NULL, the referenced int will be set to 1 if
1546    the agent's copy of the key is stored in the clear, or 0 otherwise
1547 */
1548 gpg_error_t
1549 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
1550                    char **r_serialno, int *r_cleartext)
1551 {
1552   gpg_error_t err;
1553   char line[ASSUAN_LINELENGTH];
1554   struct keyinfo_data_parm_s keyinfo;
1555
1556   memset (&keyinfo, 0,sizeof keyinfo);
1557
1558   *r_serialno = NULL;
1559
1560   err = start_agent (ctrl, 0);
1561   if (err)
1562     return err;
1563
1564   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1565     return gpg_error (GPG_ERR_INV_VALUE);
1566
1567   snprintf (line, DIM(line), "KEYINFO %s", hexkeygrip);
1568
1569   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1570                          keyinfo_status_cb, &keyinfo);
1571   if (!err && keyinfo.serialno)
1572     {
1573       /* Sanity check for bad characters.  */
1574       if (strpbrk (keyinfo.serialno, ":\n\r"))
1575         err = GPG_ERR_INV_VALUE;
1576     }
1577   if (err)
1578     xfree (keyinfo.serialno);
1579   else
1580     {
1581       *r_serialno = keyinfo.serialno;
1582       if (r_cleartext)
1583         *r_cleartext = keyinfo.cleartext;
1584     }
1585   return err;
1586 }
1587
1588 \f
1589 /* Status callback for agent_import_key, agent_export_key and
1590    agent_genkey.  */
1591 static gpg_error_t
1592 cache_nonce_status_cb (void *opaque, const char *line)
1593 {
1594   struct cache_nonce_parm_s *parm = opaque;
1595   const char *s;
1596
1597   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1598     {
1599       if (parm->cache_nonce_addr)
1600         {
1601           xfree (*parm->cache_nonce_addr);
1602           *parm->cache_nonce_addr = xtrystrdup (s);
1603         }
1604     }
1605   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1606     {
1607       if (parm->passwd_nonce_addr)
1608         {
1609           xfree (*parm->passwd_nonce_addr);
1610           *parm->passwd_nonce_addr = xtrystrdup (s);
1611         }
1612     }
1613   else if ((s = has_leading_keyword (line, "PROGRESS")))
1614     {
1615       if (opt.enable_progress_filter)
1616         write_status_text (STATUS_PROGRESS, s);
1617     }
1618
1619   return 0;
1620 }
1621
1622
1623 \f
1624 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1625    assuan_transact takes care of flushing and writing the end */
1626 static gpg_error_t
1627 inq_genkey_parms (void *opaque, const char *line)
1628 {
1629   struct genkey_parm_s *parm = opaque;
1630   gpg_error_t err;
1631
1632   if (has_leading_keyword (line, "KEYPARAM"))
1633     {
1634       err = assuan_send_data (parm->dflt->ctx,
1635                               parm->keyparms, strlen (parm->keyparms));
1636     }
1637   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1638     {
1639       err = assuan_send_data (parm->dflt->ctx,
1640                               parm->passphrase,  strlen (parm->passphrase));
1641     }
1642   else
1643     err = default_inq_cb (parm->dflt, line);
1644
1645   return err;
1646 }
1647
1648
1649 /* Call the agent to generate a new key.  KEYPARMS is the usual
1650    S-expression giving the parameters of the key.  gpg-agent passes it
1651    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1652    to protect the generated key.  If NO_PROTECTION is not set and
1653    PASSPHRASE is not NULL the agent is requested to protect the key
1654    with that passphrase instead of asking for one.  */
1655 gpg_error_t
1656 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
1657               const char *keyparms, int no_protection,
1658               const char *passphrase, gcry_sexp_t *r_pubkey)
1659 {
1660   gpg_error_t err;
1661   struct genkey_parm_s gk_parm;
1662   struct cache_nonce_parm_s cn_parm;
1663   struct default_inq_parm_s dfltparm;
1664   membuf_t data;
1665   size_t len;
1666   unsigned char *buf;
1667   char line[ASSUAN_LINELENGTH];
1668
1669   memset (&dfltparm, 0, sizeof dfltparm);
1670   dfltparm.ctrl = ctrl;
1671
1672   *r_pubkey = NULL;
1673   err = start_agent (ctrl, 0);
1674   if (err)
1675     return err;
1676   dfltparm.ctx = agent_ctx;
1677
1678   if (passwd_nonce_addr && *passwd_nonce_addr)
1679     ; /* A RESET would flush the passwd nonce cache.  */
1680   else
1681     {
1682       err = assuan_transact (agent_ctx, "RESET",
1683                              NULL, NULL, NULL, NULL, NULL, NULL);
1684       if (err)
1685         return err;
1686     }
1687
1688   init_membuf (&data, 1024);
1689   gk_parm.dflt     = &dfltparm;
1690   gk_parm.keyparms = keyparms;
1691   gk_parm.passphrase = passphrase;
1692   snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
1693             no_protection? " --no-protection" :
1694             passphrase   ? " --inq-passwd" :
1695             /*          */ "",
1696             passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
1697             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1698             cache_nonce_addr && *cache_nonce_addr? " ":"",
1699             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1700   cn_parm.cache_nonce_addr = cache_nonce_addr;
1701   cn_parm.passwd_nonce_addr = NULL;
1702   err = assuan_transact (agent_ctx, line,
1703                          put_membuf_cb, &data,
1704                          inq_genkey_parms, &gk_parm,
1705                          cache_nonce_status_cb, &cn_parm);
1706   if (err)
1707     {
1708       xfree (get_membuf (&data, &len));
1709       return err;
1710     }
1711
1712   buf = get_membuf (&data, &len);
1713   if (!buf)
1714     err = gpg_error_from_syserror ();
1715   else
1716     {
1717       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1718       xfree (buf);
1719     }
1720   return err;
1721 }
1722
1723
1724 \f
1725 /* Call the agent to read the public key part for a given keygrip.  If
1726    FROMCARD is true, the key is directly read from the current
1727    smartcard. In this case HEXKEYGRIP should be the keyID
1728    (e.g. OPENPGP.3). */
1729 gpg_error_t
1730 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1731                unsigned char **r_pubkey)
1732 {
1733   gpg_error_t err;
1734   membuf_t data;
1735   size_t len;
1736   unsigned char *buf;
1737   char line[ASSUAN_LINELENGTH];
1738   struct default_inq_parm_s dfltparm;
1739
1740   memset (&dfltparm, 0, sizeof dfltparm);
1741   dfltparm.ctrl = ctrl;
1742
1743   *r_pubkey = NULL;
1744   err = start_agent (ctrl, 0);
1745   if (err)
1746     return err;
1747   dfltparm.ctx = agent_ctx;
1748
1749   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1750   if (err)
1751     return err;
1752
1753   snprintf (line, DIM(line), "READKEY %s%s", fromcard? "--card ":"",
1754             hexkeygrip);
1755
1756   init_membuf (&data, 1024);
1757   err = assuan_transact (agent_ctx, line,
1758                          put_membuf_cb, &data,
1759                          default_inq_cb, &dfltparm,
1760                          NULL, NULL);
1761   if (err)
1762     {
1763       xfree (get_membuf (&data, &len));
1764       return err;
1765     }
1766   buf = get_membuf (&data, &len);
1767   if (!buf)
1768     return gpg_error_from_syserror ();
1769   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1770     {
1771       xfree (buf);
1772       return gpg_error (GPG_ERR_INV_SEXP);
1773     }
1774   *r_pubkey = buf;
1775   return 0;
1776 }
1777
1778
1779 \f
1780 /* Call the agent to do a sign operation using the key identified by
1781    the hex string KEYGRIP.  DESC is a description of the key to be
1782    displayed if the agent needs to ask for the PIN.  DIGEST and
1783    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1784    used to compute the digest.  If CACHE_NONCE is used the agent is
1785    advised to first try a passphrase associated with that nonce. */
1786 gpg_error_t
1787 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1788               const char *keygrip, const char *desc,
1789               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1790               unsigned char *digest, size_t digestlen, int digestalgo,
1791               gcry_sexp_t *r_sigval)
1792 {
1793   gpg_error_t err;
1794   char line[ASSUAN_LINELENGTH];
1795   membuf_t data;
1796   struct default_inq_parm_s dfltparm;
1797
1798   memset (&dfltparm, 0, sizeof dfltparm);
1799   dfltparm.ctrl = ctrl;
1800   dfltparm.keyinfo.keyid       = keyid;
1801   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1802   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1803
1804   *r_sigval = NULL;
1805   err = start_agent (ctrl, 0);
1806   if (err)
1807     return err;
1808   dfltparm.ctx = agent_ctx;
1809
1810   if (digestlen*2 + 50 > DIM(line))
1811     return gpg_error (GPG_ERR_GENERAL);
1812
1813   err = assuan_transact (agent_ctx, "RESET",
1814                          NULL, NULL, NULL, NULL, NULL, NULL);
1815   if (err)
1816     return err;
1817
1818   snprintf (line, DIM(line), "SIGKEY %s", keygrip);
1819   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1820   if (err)
1821     return err;
1822
1823   if (desc)
1824     {
1825       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
1826       err = assuan_transact (agent_ctx, line,
1827                             NULL, NULL, NULL, NULL, NULL, NULL);
1828       if (err)
1829         return err;
1830     }
1831
1832   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1833   bin2hex (digest, digestlen, line + strlen (line));
1834   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1835   if (err)
1836     return err;
1837
1838   init_membuf (&data, 1024);
1839
1840   snprintf (line, sizeof line, "PKSIGN%s%s",
1841             cache_nonce? " -- ":"",
1842             cache_nonce? cache_nonce:"");
1843   err = assuan_transact (agent_ctx, line,
1844                          put_membuf_cb, &data,
1845                          default_inq_cb, &dfltparm,
1846                          NULL, NULL);
1847   if (err)
1848     xfree (get_membuf (&data, NULL));
1849   else
1850     {
1851       unsigned char *buf;
1852       size_t len;
1853
1854       buf = get_membuf (&data, &len);
1855       if (!buf)
1856         err = gpg_error_from_syserror ();
1857       else
1858         {
1859           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1860           xfree (buf);
1861         }
1862     }
1863   return err;
1864 }
1865
1866
1867 \f
1868 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1869    assuan_transact takes care of flushing and writing the END. */
1870 static gpg_error_t
1871 inq_ciphertext_cb (void *opaque, const char *line)
1872 {
1873   struct cipher_parm_s *parm = opaque;
1874   int rc;
1875
1876   if (has_leading_keyword (line, "CIPHERTEXT"))
1877     {
1878       assuan_begin_confidential (parm->ctx);
1879       rc = assuan_send_data (parm->dflt->ctx,
1880                              parm->ciphertext, parm->ciphertextlen);
1881       assuan_end_confidential (parm->ctx);
1882     }
1883   else
1884     rc = default_inq_cb (parm->dflt, line);
1885
1886   return rc;
1887 }
1888
1889
1890 /* Check whether there is any padding info from the agent.  */
1891 static gpg_error_t
1892 padding_info_cb (void *opaque, const char *line)
1893 {
1894   int *r_padding = opaque;
1895   const char *s;
1896
1897   if ((s=has_leading_keyword (line, "PADDING")))
1898     {
1899       *r_padding = atoi (s);
1900     }
1901
1902   return 0;
1903 }
1904
1905
1906 /* Call the agent to do a decrypt operation using the key identified
1907    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
1908    success the decoded value is stored verbatim at R_BUF and its
1909    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
1910    and PUBKEY_ALGO are used to construct additional promots or status
1911    messages.   The padding information is stored at R_PADDING with -1
1912    for not known.  */
1913 gpg_error_t
1914 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
1915                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1916                  gcry_sexp_t s_ciphertext,
1917                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
1918 {
1919   gpg_error_t err;
1920   char line[ASSUAN_LINELENGTH];
1921   membuf_t data;
1922   size_t n, len;
1923   char *p, *buf, *endp;
1924   struct default_inq_parm_s dfltparm;
1925
1926   memset (&dfltparm, 0, sizeof dfltparm);
1927   dfltparm.ctrl = ctrl;
1928   dfltparm.keyinfo.keyid       = keyid;
1929   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1930   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1931
1932   if (!keygrip || strlen(keygrip) != 40
1933       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
1934     return gpg_error (GPG_ERR_INV_VALUE);
1935
1936   *r_buf = NULL;
1937   *r_padding = -1;
1938
1939   err = start_agent (ctrl, 0);
1940   if (err)
1941     return err;
1942   dfltparm.ctx = agent_ctx;
1943
1944   err = assuan_transact (agent_ctx, "RESET",
1945                          NULL, NULL, NULL, NULL, NULL, NULL);
1946   if (err)
1947     return err;
1948
1949   snprintf (line, sizeof line, "SETKEY %s", keygrip);
1950   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1951   if (err)
1952     return err;
1953
1954   if (desc)
1955     {
1956       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
1957       err = assuan_transact (agent_ctx, line,
1958                             NULL, NULL, NULL, NULL, NULL, NULL);
1959       if (err)
1960         return err;
1961     }
1962
1963   init_membuf_secure (&data, 1024);
1964   {
1965     struct cipher_parm_s parm;
1966
1967     parm.dflt = &dfltparm;
1968     parm.ctx = agent_ctx;
1969     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
1970     if (err)
1971       return err;
1972     err = assuan_transact (agent_ctx, "PKDECRYPT",
1973                            put_membuf_cb, &data,
1974                            inq_ciphertext_cb, &parm,
1975                            padding_info_cb, r_padding);
1976     xfree (parm.ciphertext);
1977   }
1978   if (err)
1979     {
1980       xfree (get_membuf (&data, &len));
1981       return err;
1982     }
1983
1984   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
1985   buf = get_membuf (&data, &len);
1986   if (!buf)
1987     return gpg_error_from_syserror ();
1988   log_assert (len); /* (we forced Nul termination.)  */
1989
1990   if (*buf != '(')
1991     {
1992       xfree (buf);
1993       return gpg_error (GPG_ERR_INV_SEXP);
1994     }
1995
1996   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
1997     {
1998       xfree (buf);
1999       return gpg_error (GPG_ERR_INV_SEXP);
2000     }
2001   len -= 10;   /* Count only the data of the second part. */
2002   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2003
2004   n = strtoul (p, &endp, 10);
2005   if (!n || *endp != ':')
2006     {
2007       xfree (buf);
2008       return gpg_error (GPG_ERR_INV_SEXP);
2009     }
2010   endp++;
2011   if (endp-p+n > len)
2012     {
2013       xfree (buf);
2014       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2015     }
2016
2017   memmove (buf, endp, n);
2018
2019   *r_buflen = n;
2020   *r_buf = buf;
2021   return 0;
2022 }
2023
2024
2025 \f
2026 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2027    the key shall be used for export, with false for import.  On success
2028    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2029 gpg_error_t
2030 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2031 {
2032   gpg_error_t err;
2033   membuf_t data;
2034   size_t len;
2035   unsigned char *buf;
2036   char line[ASSUAN_LINELENGTH];
2037   struct default_inq_parm_s dfltparm;
2038
2039   memset (&dfltparm, 0, sizeof dfltparm);
2040   dfltparm.ctrl = ctrl;
2041
2042   *r_kek = NULL;
2043   err = start_agent (ctrl, 0);
2044   if (err)
2045     return err;
2046   dfltparm.ctx = agent_ctx;
2047
2048   snprintf (line, DIM(line), "KEYWRAP_KEY %s",
2049             forexport? "--export":"--import");
2050
2051   init_membuf_secure (&data, 64);
2052   err = assuan_transact (agent_ctx, line,
2053                          put_membuf_cb, &data,
2054                          default_inq_cb, &dfltparm,
2055                          NULL, NULL);
2056   if (err)
2057     {
2058       xfree (get_membuf (&data, &len));
2059       return err;
2060     }
2061   buf = get_membuf (&data, &len);
2062   if (!buf)
2063     return gpg_error_from_syserror ();
2064   *r_kek = buf;
2065   *r_keklen = len;
2066   return 0;
2067 }
2068
2069
2070 \f
2071 /* Handle the inquiry for an IMPORT_KEY command.  */
2072 static gpg_error_t
2073 inq_import_key_parms (void *opaque, const char *line)
2074 {
2075   struct import_key_parm_s *parm = opaque;
2076   gpg_error_t err;
2077
2078   if (has_leading_keyword (line, "KEYDATA"))
2079     {
2080       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2081     }
2082   else
2083     err = default_inq_cb (parm->dflt, line);
2084
2085   return err;
2086 }
2087
2088
2089 /* Call the agent to import a key into the agent.  */
2090 gpg_error_t
2091 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2092                   const void *key, size_t keylen, int unattended, int force)
2093 {
2094   gpg_error_t err;
2095   struct import_key_parm_s parm;
2096   struct cache_nonce_parm_s cn_parm;
2097   char line[ASSUAN_LINELENGTH];
2098   struct default_inq_parm_s dfltparm;
2099
2100   memset (&dfltparm, 0, sizeof dfltparm);
2101   dfltparm.ctrl = ctrl;
2102
2103   err = start_agent (ctrl, 0);
2104   if (err)
2105     return err;
2106   dfltparm.ctx = agent_ctx;
2107
2108   if (desc)
2109     {
2110       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2111       err = assuan_transact (agent_ctx, line,
2112                             NULL, NULL, NULL, NULL, NULL, NULL);
2113       if (err)
2114         return err;
2115     }
2116
2117   parm.dflt   = &dfltparm;
2118   parm.key    = key;
2119   parm.keylen = keylen;
2120
2121   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2122             unattended? " --unattended":"",
2123             force? " --force":"",
2124             cache_nonce_addr && *cache_nonce_addr? " ":"",
2125             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2126   cn_parm.cache_nonce_addr = cache_nonce_addr;
2127   cn_parm.passwd_nonce_addr = NULL;
2128   err = assuan_transact (agent_ctx, line,
2129                          NULL, NULL,
2130                          inq_import_key_parms, &parm,
2131                          cache_nonce_status_cb, &cn_parm);
2132   return err;
2133 }
2134
2135
2136 \f
2137 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2138    keygrip, DESC a prompt to be displayed with the agent's passphrase
2139    question (needs to be plus+percent escaped).  if OPENPGP_PROTECTED
2140    is not zero, ensure that the key material is returned in RFC
2141    4880-compatible passphrased-protected form.  If CACHE_NONCE_ADDR is
2142    not NULL the agent is advised to first try a passphrase associated
2143    with that nonce.  On success the key is stored as a canonical
2144    S-expression at R_RESULT and R_RESULTLEN.  */
2145 gpg_error_t
2146 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2147                   int openpgp_protected, char **cache_nonce_addr,
2148                   unsigned char **r_result, size_t *r_resultlen)
2149 {
2150   gpg_error_t err;
2151   struct cache_nonce_parm_s cn_parm;
2152   membuf_t data;
2153   size_t len;
2154   unsigned char *buf;
2155   char line[ASSUAN_LINELENGTH];
2156   struct default_inq_parm_s dfltparm;
2157
2158   memset (&dfltparm, 0, sizeof dfltparm);
2159   dfltparm.ctrl = ctrl;
2160
2161   *r_result = NULL;
2162
2163   err = start_agent (ctrl, 0);
2164   if (err)
2165     return err;
2166   dfltparm.ctx = agent_ctx;
2167
2168   if (desc)
2169     {
2170       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2171       err = assuan_transact (agent_ctx, line,
2172                              NULL, NULL, NULL, NULL, NULL, NULL);
2173       if (err)
2174         return err;
2175     }
2176
2177   snprintf (line, DIM(line), "EXPORT_KEY %s%s%s %s",
2178             openpgp_protected ? "--openpgp ":"",
2179             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2180             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2181             hexkeygrip);
2182
2183   init_membuf_secure (&data, 1024);
2184   cn_parm.cache_nonce_addr = cache_nonce_addr;
2185   cn_parm.passwd_nonce_addr = NULL;
2186   err = assuan_transact (agent_ctx, line,
2187                          put_membuf_cb, &data,
2188                          default_inq_cb, &dfltparm,
2189                          cache_nonce_status_cb, &cn_parm);
2190   if (err)
2191     {
2192       xfree (get_membuf (&data, &len));
2193       return err;
2194     }
2195   buf = get_membuf (&data, &len);
2196   if (!buf)
2197     return gpg_error_from_syserror ();
2198   *r_result = buf;
2199   *r_resultlen = len;
2200   return 0;
2201 }
2202
2203
2204 \f
2205 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2206    is not NULL, display DESC instead of the default description
2207    message.  If FORCE is true the agent is advised not to ask for
2208    confirmation. */
2209 gpg_error_t
2210 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2211                   int force)
2212 {
2213   gpg_error_t err;
2214   char line[ASSUAN_LINELENGTH];
2215   struct default_inq_parm_s dfltparm;
2216
2217   memset (&dfltparm, 0, sizeof dfltparm);
2218   dfltparm.ctrl = ctrl;
2219
2220   err = start_agent (ctrl, 0);
2221   if (err)
2222     return err;
2223
2224   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2225     return gpg_error (GPG_ERR_INV_VALUE);
2226
2227   if (desc)
2228     {
2229       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2230       err = assuan_transact (agent_ctx, line,
2231                              NULL, NULL, NULL, NULL, NULL, NULL);
2232       if (err)
2233         return err;
2234     }
2235
2236   snprintf (line, DIM(line), "DELETE_KEY%s %s",
2237             force? " --force":"", hexkeygrip);
2238   err = assuan_transact (agent_ctx, line, NULL, NULL,
2239                          default_inq_cb, &dfltparm,
2240                          NULL, NULL);
2241   return err;
2242 }
2243
2244
2245 \f
2246 /* Ask the agent to change the passphrase of the key identified by
2247  * HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2248  * default description message.  If CACHE_NONCE_ADDR is not NULL the
2249  * agent is advised to first try a passphrase associated with that
2250  * nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2251  * the passphrase associated with that nonce for the new passphrase.
2252  * If VERIFY is true the passphrase is only verified.  */
2253 gpg_error_t
2254 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
2255               char **cache_nonce_addr, char **passwd_nonce_addr)
2256 {
2257   gpg_error_t err;
2258   struct cache_nonce_parm_s cn_parm;
2259   char line[ASSUAN_LINELENGTH];
2260   struct default_inq_parm_s dfltparm;
2261
2262   memset (&dfltparm, 0, sizeof dfltparm);
2263   dfltparm.ctrl = ctrl;
2264
2265   err = start_agent (ctrl, 0);
2266   if (err)
2267     return err;
2268   dfltparm.ctx = agent_ctx;
2269
2270   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2271     return gpg_error (GPG_ERR_INV_VALUE);
2272
2273   if (desc)
2274     {
2275       snprintf (line, DIM(line), "SETKEYDESC %s", desc);
2276       err = assuan_transact (agent_ctx, line,
2277                              NULL, NULL, NULL, NULL, NULL, NULL);
2278       if (err)
2279         return err;
2280     }
2281
2282   if (verify)
2283     snprintf (line, DIM(line), "PASSWD %s%s --verify %s",
2284               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2285               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2286               hexkeygrip);
2287   else
2288     snprintf (line, DIM(line), "PASSWD %s%s %s%s %s",
2289               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2290               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2291               passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2292               passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2293               hexkeygrip);
2294   cn_parm.cache_nonce_addr = cache_nonce_addr;
2295   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2296   err = assuan_transact (agent_ctx, line, NULL, NULL,
2297                          default_inq_cb, &dfltparm,
2298                          cache_nonce_status_cb, &cn_parm);
2299   return err;
2300 }
2301
2302
2303 /* Return the version reported by gpg-agent.  */
2304 gpg_error_t
2305 agent_get_version (ctrl_t ctrl, char **r_version)
2306 {
2307   gpg_error_t err;
2308
2309   err = start_agent (ctrl, 0);
2310   if (err)
2311     return err;
2312
2313   err = get_assuan_server_version (agent_ctx, 0, r_version);
2314   return err;
2315 }