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