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