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