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