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