g10: Export cleartext keys as cleartext
[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 struct keyinfo_data {
1675   char *serialno;
1676   int cleartext;
1677 };
1678
1679 static gpg_error_t
1680 keyinfo_status_cb (void *opaque, const char *line)
1681 {
1682   struct keyinfo_data *data = opaque;
1683   int is_smartcard;
1684   const char *s, *s2;
1685
1686   if ((s = has_leading_keyword (line, "KEYINFO")) && data)
1687     {
1688       s = strchr (s, ' ');
1689       if (s)
1690         {
1691           is_smartcard = (s[1] == 'T');
1692           if ( s[2] == ' ' && s[3] )
1693             {
1694               s += 3;
1695               s2 = strchr (s, ' ');
1696               if ( s2 > s )
1697                 {
1698                   if (is_smartcard && !data->serialno)
1699                     {
1700                       data->serialno = xtrymalloc ((s2 - s)+1);
1701                       if (data->serialno)
1702                         {
1703                           memcpy (data->serialno, s, s2 - s);
1704                           (data->serialno)[s2 - s] = 0;
1705                         }
1706                     }
1707                   if (s2 = strchr (s2 + 1, ' '), s2) /* skip IDSTR (can IDSTR contain a space?) */
1708                     if (s2 = strchr (s2 + 1, ' '), s2) /* skip CACHED */
1709                       data->cleartext = (s2[1] == 'C'); /* 'P' for protected, 'C' for clear */
1710                 }
1711             }
1712         }
1713     }
1714   return 0;
1715 }
1716
1717
1718 /* Return the serial number for a secret key.  If the returned serial
1719    number is NULL, the key is not stored on a smartcard.  Caller needs
1720    to free R_SERIALNO.
1721
1722    if r_cleartext is not NULL, the referenced int will be set to 1 if
1723    the agent's copy of the key is stored in the clear, or 0 otherwise
1724 */
1725 gpg_error_t
1726 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
1727                    char **r_serialno, int *r_cleartext)
1728 {
1729   gpg_error_t err;
1730   char line[ASSUAN_LINELENGTH];
1731   struct keyinfo_data keyinfo = { .serialno = NULL, .cleartext = 0 };
1732
1733   *r_serialno = NULL;
1734
1735   err = start_agent (ctrl, 0);
1736   if (err)
1737     return err;
1738
1739   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1740     return gpg_error (GPG_ERR_INV_VALUE);
1741
1742   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1743   line[DIM(line)-1] = 0;
1744
1745   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1746                          keyinfo_status_cb, &keyinfo);
1747   if (!err && keyinfo.serialno)
1748     {
1749       /* Sanity check for bad characters.  */
1750       if (strpbrk (keyinfo.serialno, ":\n\r"))
1751         err = GPG_ERR_INV_VALUE;
1752     }
1753   if (err)
1754     xfree (keyinfo.serialno);
1755   else
1756     {
1757       *r_serialno = keyinfo.serialno;
1758       if (r_cleartext)
1759         *r_cleartext = keyinfo.cleartext;
1760     }
1761   return err;
1762 }
1763
1764 \f
1765 /* Status callback for agent_import_key, agent_export_key and
1766    agent_genkey.  */
1767 static gpg_error_t
1768 cache_nonce_status_cb (void *opaque, const char *line)
1769 {
1770   struct cache_nonce_parm_s *parm = opaque;
1771   const char *s;
1772
1773   if ((s = has_leading_keyword (line, "CACHE_NONCE")))
1774     {
1775       if (parm->cache_nonce_addr)
1776         {
1777           xfree (*parm->cache_nonce_addr);
1778           *parm->cache_nonce_addr = xtrystrdup (s);
1779         }
1780     }
1781   else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
1782     {
1783       if (parm->passwd_nonce_addr)
1784         {
1785           xfree (*parm->passwd_nonce_addr);
1786           *parm->passwd_nonce_addr = xtrystrdup (s);
1787         }
1788     }
1789   else if ((s = has_leading_keyword (line, "PROGRESS")))
1790     {
1791       if (opt.enable_progress_filter)
1792         write_status_text (STATUS_PROGRESS, s);
1793     }
1794
1795   return 0;
1796 }
1797
1798
1799 \f
1800 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1801    assuan_transact takes care of flushing and writing the end */
1802 static gpg_error_t
1803 inq_genkey_parms (void *opaque, const char *line)
1804 {
1805   struct genkey_parm_s *parm = opaque;
1806   gpg_error_t err;
1807
1808   if (has_leading_keyword (line, "KEYPARAM"))
1809     {
1810       err = assuan_send_data (parm->dflt->ctx,
1811                               parm->keyparms, strlen (parm->keyparms));
1812     }
1813   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1814     {
1815       err = assuan_send_data (parm->dflt->ctx,
1816                               parm->passphrase,  strlen (parm->passphrase));
1817     }
1818   else
1819     err = default_inq_cb (parm->dflt, line);
1820
1821   return err;
1822 }
1823
1824
1825 /* Call the agent to generate a new key.  KEYPARMS is the usual
1826    S-expression giving the parameters of the key.  gpg-agent passes it
1827    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1828    to protect the generated key.  If NO_PROTECTION is not set and
1829    PASSPHRASE is not NULL the agent is requested to protect the key
1830    with that passphrase instead of asking for one.  */
1831 gpg_error_t
1832 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
1833               const char *keyparms, int no_protection,
1834               const char *passphrase, gcry_sexp_t *r_pubkey)
1835 {
1836   gpg_error_t err;
1837   struct genkey_parm_s gk_parm;
1838   struct cache_nonce_parm_s cn_parm;
1839   struct default_inq_parm_s dfltparm;
1840   membuf_t data;
1841   size_t len;
1842   unsigned char *buf;
1843   char line[ASSUAN_LINELENGTH];
1844
1845   memset (&dfltparm, 0, sizeof dfltparm);
1846   dfltparm.ctrl = ctrl;
1847
1848   *r_pubkey = NULL;
1849   err = start_agent (ctrl, 0);
1850   if (err)
1851     return err;
1852   dfltparm.ctx = agent_ctx;
1853
1854   if (passwd_nonce_addr && *passwd_nonce_addr)
1855     ; /* A RESET would flush the passwd nonce cache.  */
1856   else
1857     {
1858       err = assuan_transact (agent_ctx, "RESET",
1859                              NULL, NULL, NULL, NULL, NULL, NULL);
1860       if (err)
1861         return err;
1862     }
1863
1864   init_membuf (&data, 1024);
1865   gk_parm.dflt     = &dfltparm;
1866   gk_parm.keyparms = keyparms;
1867   gk_parm.passphrase = passphrase;
1868   snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
1869             no_protection? " --no-protection" :
1870             passphrase   ? " --inq-passwd" :
1871             /*          */ "",
1872             passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
1873             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1874             cache_nonce_addr && *cache_nonce_addr? " ":"",
1875             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1876   cn_parm.cache_nonce_addr = cache_nonce_addr;
1877   cn_parm.passwd_nonce_addr = NULL;
1878   err = assuan_transact (agent_ctx, line,
1879                          put_membuf_cb, &data,
1880                          inq_genkey_parms, &gk_parm,
1881                          cache_nonce_status_cb, &cn_parm);
1882   if (err)
1883     {
1884       xfree (get_membuf (&data, &len));
1885       return err;
1886     }
1887
1888   buf = get_membuf (&data, &len);
1889   if (!buf)
1890     err = gpg_error_from_syserror ();
1891   else
1892     {
1893       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1894       xfree (buf);
1895     }
1896   return err;
1897 }
1898
1899
1900 \f
1901 /* Call the agent to read the public key part for a given keygrip.  If
1902    FROMCARD is true, the key is directly read from the current
1903    smartcard. In this case HEXKEYGRIP should be the keyID
1904    (e.g. OPENPGP.3). */
1905 gpg_error_t
1906 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1907                unsigned char **r_pubkey)
1908 {
1909   gpg_error_t err;
1910   membuf_t data;
1911   size_t len;
1912   unsigned char *buf;
1913   char line[ASSUAN_LINELENGTH];
1914   struct default_inq_parm_s dfltparm;
1915
1916   memset (&dfltparm, 0, sizeof dfltparm);
1917   dfltparm.ctrl = ctrl;
1918
1919   *r_pubkey = NULL;
1920   err = start_agent (ctrl, 0);
1921   if (err)
1922     return err;
1923   dfltparm.ctx = agent_ctx;
1924
1925   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1926   if (err)
1927     return err;
1928
1929   snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
1930
1931   init_membuf (&data, 1024);
1932   err = assuan_transact (agent_ctx, line,
1933                          put_membuf_cb, &data,
1934                          default_inq_cb, &dfltparm,
1935                          NULL, NULL);
1936   if (err)
1937     {
1938       xfree (get_membuf (&data, &len));
1939       return err;
1940     }
1941   buf = get_membuf (&data, &len);
1942   if (!buf)
1943     return gpg_error_from_syserror ();
1944   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1945     {
1946       xfree (buf);
1947       return gpg_error (GPG_ERR_INV_SEXP);
1948     }
1949   *r_pubkey = buf;
1950   return 0;
1951 }
1952
1953
1954 \f
1955 /* Call the agent to do a sign operation using the key identified by
1956    the hex string KEYGRIP.  DESC is a description of the key to be
1957    displayed if the agent needs to ask for the PIN.  DIGEST and
1958    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1959    used to compute the digest.  If CACHE_NONCE is used the agent is
1960    advised to first try a passphrase associated with that nonce. */
1961 gpg_error_t
1962 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1963               const char *keygrip, const char *desc,
1964               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1965               unsigned char *digest, size_t digestlen, int digestalgo,
1966               gcry_sexp_t *r_sigval)
1967 {
1968   gpg_error_t err;
1969   char line[ASSUAN_LINELENGTH];
1970   membuf_t data;
1971   struct default_inq_parm_s dfltparm;
1972
1973   memset (&dfltparm, 0, sizeof dfltparm);
1974   dfltparm.ctrl = ctrl;
1975   dfltparm.keyinfo.keyid       = keyid;
1976   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1977   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1978
1979   *r_sigval = NULL;
1980   err = start_agent (ctrl, 0);
1981   if (err)
1982     return err;
1983   dfltparm.ctx = agent_ctx;
1984
1985   if (digestlen*2 + 50 > DIM(line))
1986     return gpg_error (GPG_ERR_GENERAL);
1987
1988   err = assuan_transact (agent_ctx, "RESET",
1989                          NULL, NULL, NULL, NULL, NULL, NULL);
1990   if (err)
1991     return err;
1992
1993   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1994   line[DIM(line)-1] = 0;
1995   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1996   if (err)
1997     return err;
1998
1999   if (desc)
2000     {
2001       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2002       line[DIM(line)-1] = 0;
2003       err = assuan_transact (agent_ctx, line,
2004                             NULL, NULL, NULL, NULL, NULL, NULL);
2005       if (err)
2006         return err;
2007     }
2008
2009   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
2010   bin2hex (digest, digestlen, line + strlen (line));
2011   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2012   if (err)
2013     return err;
2014
2015   init_membuf (&data, 1024);
2016
2017   snprintf (line, sizeof line, "PKSIGN%s%s",
2018             cache_nonce? " -- ":"",
2019             cache_nonce? cache_nonce:"");
2020   err = assuan_transact (agent_ctx, line,
2021                          put_membuf_cb, &data,
2022                          default_inq_cb, &dfltparm,
2023                          NULL, NULL);
2024   if (err)
2025     xfree (get_membuf (&data, NULL));
2026   else
2027     {
2028       unsigned char *buf;
2029       size_t len;
2030
2031       buf = get_membuf (&data, &len);
2032       if (!buf)
2033         err = gpg_error_from_syserror ();
2034       else
2035         {
2036           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
2037           xfree (buf);
2038         }
2039     }
2040   return err;
2041 }
2042
2043
2044 \f
2045 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
2046    assuan_transact takes care of flushing and writing the END. */
2047 static gpg_error_t
2048 inq_ciphertext_cb (void *opaque, const char *line)
2049 {
2050   struct cipher_parm_s *parm = opaque;
2051   int rc;
2052
2053   if (has_leading_keyword (line, "CIPHERTEXT"))
2054     {
2055       assuan_begin_confidential (parm->ctx);
2056       rc = assuan_send_data (parm->dflt->ctx,
2057                              parm->ciphertext, parm->ciphertextlen);
2058       assuan_end_confidential (parm->ctx);
2059     }
2060   else
2061     rc = default_inq_cb (parm->dflt, line);
2062
2063   return rc;
2064 }
2065
2066
2067 /* Check whether there is any padding info from the agent.  */
2068 static gpg_error_t
2069 padding_info_cb (void *opaque, const char *line)
2070 {
2071   int *r_padding = opaque;
2072   const char *s;
2073
2074   if ((s=has_leading_keyword (line, "PADDING")))
2075     {
2076       *r_padding = atoi (s);
2077     }
2078
2079   return 0;
2080 }
2081
2082
2083 /* Call the agent to do a decrypt operation using the key identified
2084    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
2085    success the decoded value is stored verbatim at R_BUF and its
2086    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
2087    and PUBKEY_ALGO are used to construct additional promots or status
2088    messages.   The padding information is stored at R_PADDING with -1
2089    for not known.  */
2090 gpg_error_t
2091 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
2092                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2093                  gcry_sexp_t s_ciphertext,
2094                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
2095 {
2096   gpg_error_t err;
2097   char line[ASSUAN_LINELENGTH];
2098   membuf_t data;
2099   size_t n, len;
2100   char *p, *buf, *endp;
2101   struct default_inq_parm_s dfltparm;
2102
2103   memset (&dfltparm, 0, sizeof dfltparm);
2104   dfltparm.ctrl = ctrl;
2105   dfltparm.keyinfo.keyid       = keyid;
2106   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2107   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2108
2109   if (!keygrip || strlen(keygrip) != 40
2110       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
2111     return gpg_error (GPG_ERR_INV_VALUE);
2112
2113   *r_buf = NULL;
2114   *r_padding = -1;
2115
2116   err = start_agent (ctrl, 0);
2117   if (err)
2118     return err;
2119   dfltparm.ctx = agent_ctx;
2120
2121   err = assuan_transact (agent_ctx, "RESET",
2122                          NULL, NULL, NULL, NULL, NULL, NULL);
2123   if (err)
2124     return err;
2125
2126   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2127   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2128   if (err)
2129     return err;
2130
2131   if (desc)
2132     {
2133       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2134       line[DIM(line)-1] = 0;
2135       err = assuan_transact (agent_ctx, line,
2136                             NULL, NULL, NULL, NULL, NULL, NULL);
2137       if (err)
2138         return err;
2139     }
2140
2141   init_membuf_secure (&data, 1024);
2142   {
2143     struct cipher_parm_s parm;
2144
2145     parm.dflt = &dfltparm;
2146     parm.ctx = agent_ctx;
2147     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2148     if (err)
2149       return err;
2150     err = assuan_transact (agent_ctx, "PKDECRYPT",
2151                            put_membuf_cb, &data,
2152                            inq_ciphertext_cb, &parm,
2153                            padding_info_cb, r_padding);
2154     xfree (parm.ciphertext);
2155   }
2156   if (err)
2157     {
2158       xfree (get_membuf (&data, &len));
2159       return err;
2160     }
2161
2162   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2163   buf = get_membuf (&data, &len);
2164   if (!buf)
2165     return gpg_error_from_syserror ();
2166   log_assert (len); /* (we forced Nul termination.)  */
2167
2168   if (*buf != '(')
2169     {
2170       xfree (buf);
2171       return gpg_error (GPG_ERR_INV_SEXP);
2172     }
2173
2174   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2175     {
2176       xfree (buf);
2177       return gpg_error (GPG_ERR_INV_SEXP);
2178     }
2179   len -= 10;   /* Count only the data of the second part. */
2180   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2181
2182   n = strtoul (p, &endp, 10);
2183   if (!n || *endp != ':')
2184     {
2185       xfree (buf);
2186       return gpg_error (GPG_ERR_INV_SEXP);
2187     }
2188   endp++;
2189   if (endp-p+n > len)
2190     {
2191       xfree (buf);
2192       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2193     }
2194
2195   memmove (buf, endp, n);
2196
2197   *r_buflen = n;
2198   *r_buf = buf;
2199   return 0;
2200 }
2201
2202
2203 \f
2204 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2205    the key shall be used for export, with false for import.  On success
2206    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2207 gpg_error_t
2208 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2209 {
2210   gpg_error_t err;
2211   membuf_t data;
2212   size_t len;
2213   unsigned char *buf;
2214   char line[ASSUAN_LINELENGTH];
2215   struct default_inq_parm_s dfltparm;
2216
2217   memset (&dfltparm, 0, sizeof dfltparm);
2218   dfltparm.ctrl = ctrl;
2219
2220   *r_kek = NULL;
2221   err = start_agent (ctrl, 0);
2222   if (err)
2223     return err;
2224   dfltparm.ctx = agent_ctx;
2225
2226   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
2227             forexport? "--export":"--import");
2228
2229   init_membuf_secure (&data, 64);
2230   err = assuan_transact (agent_ctx, line,
2231                          put_membuf_cb, &data,
2232                          default_inq_cb, &dfltparm,
2233                          NULL, NULL);
2234   if (err)
2235     {
2236       xfree (get_membuf (&data, &len));
2237       return err;
2238     }
2239   buf = get_membuf (&data, &len);
2240   if (!buf)
2241     return gpg_error_from_syserror ();
2242   *r_kek = buf;
2243   *r_keklen = len;
2244   return 0;
2245 }
2246
2247
2248 \f
2249 /* Handle the inquiry for an IMPORT_KEY command.  */
2250 static gpg_error_t
2251 inq_import_key_parms (void *opaque, const char *line)
2252 {
2253   struct import_key_parm_s *parm = opaque;
2254   gpg_error_t err;
2255
2256   if (has_leading_keyword (line, "KEYDATA"))
2257     {
2258       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2259     }
2260   else
2261     err = default_inq_cb (parm->dflt, line);
2262
2263   return err;
2264 }
2265
2266
2267 /* Call the agent to import a key into the agent.  */
2268 gpg_error_t
2269 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2270                   const void *key, size_t keylen, int unattended, int force)
2271 {
2272   gpg_error_t err;
2273   struct import_key_parm_s parm;
2274   struct cache_nonce_parm_s cn_parm;
2275   char line[ASSUAN_LINELENGTH];
2276   struct default_inq_parm_s dfltparm;
2277
2278   memset (&dfltparm, 0, sizeof dfltparm);
2279   dfltparm.ctrl = ctrl;
2280
2281   err = start_agent (ctrl, 0);
2282   if (err)
2283     return err;
2284   dfltparm.ctx = agent_ctx;
2285
2286   if (desc)
2287     {
2288       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2289       line[DIM(line)-1] = 0;
2290       err = assuan_transact (agent_ctx, line,
2291                             NULL, NULL, NULL, NULL, NULL, NULL);
2292       if (err)
2293         return err;
2294     }
2295
2296   parm.dflt   = &dfltparm;
2297   parm.key    = key;
2298   parm.keylen = keylen;
2299
2300   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
2301             unattended? " --unattended":"",
2302             force? " --force":"",
2303             cache_nonce_addr && *cache_nonce_addr? " ":"",
2304             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2305   cn_parm.cache_nonce_addr = cache_nonce_addr;
2306   cn_parm.passwd_nonce_addr = NULL;
2307   err = assuan_transact (agent_ctx, line,
2308                          NULL, NULL,
2309                          inq_import_key_parms, &parm,
2310                          cache_nonce_status_cb, &cn_parm);
2311   return err;
2312 }
2313
2314
2315 \f
2316 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2317    keygrip, DESC a prompt to be displayed with the agent's passphrase
2318    question (needs to be plus+percent escaped).  if OPENPGP_PROTECTED
2319    is not zero, ensure that the key material is returned in RFC
2320    4880-compatible passphrased-protected form.  If CACHE_NONCE_ADDR is
2321    not NULL the agent is advised to first try a passphrase associated
2322    with that nonce.  On success the key is stored as a canonical
2323    S-expression at R_RESULT and R_RESULTLEN.  */
2324 gpg_error_t
2325 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2326                   int openpgp_protected, char **cache_nonce_addr,
2327                   unsigned char **r_result, size_t *r_resultlen)
2328 {
2329   gpg_error_t err;
2330   struct cache_nonce_parm_s cn_parm;
2331   membuf_t data;
2332   size_t len;
2333   unsigned char *buf;
2334   char line[ASSUAN_LINELENGTH];
2335   struct default_inq_parm_s dfltparm;
2336
2337   memset (&dfltparm, 0, sizeof dfltparm);
2338   dfltparm.ctrl = ctrl;
2339
2340   *r_result = NULL;
2341
2342   err = start_agent (ctrl, 0);
2343   if (err)
2344     return err;
2345   dfltparm.ctx = agent_ctx;
2346
2347   if (desc)
2348     {
2349       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2350       err = assuan_transact (agent_ctx, line,
2351                              NULL, NULL, NULL, NULL, NULL, NULL);
2352       if (err)
2353         return err;
2354     }
2355
2356   snprintf (line, DIM(line)-1, "EXPORT_KEY %s%s%s %s",
2357             openpgp_protected ? "--openpgp ":"",
2358             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2359             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2360             hexkeygrip);
2361
2362   init_membuf_secure (&data, 1024);
2363   cn_parm.cache_nonce_addr = cache_nonce_addr;
2364   cn_parm.passwd_nonce_addr = NULL;
2365   err = assuan_transact (agent_ctx, line,
2366                          put_membuf_cb, &data,
2367                          default_inq_cb, &dfltparm,
2368                          cache_nonce_status_cb, &cn_parm);
2369   if (err)
2370     {
2371       xfree (get_membuf (&data, &len));
2372       return err;
2373     }
2374   buf = get_membuf (&data, &len);
2375   if (!buf)
2376     return gpg_error_from_syserror ();
2377   *r_result = buf;
2378   *r_resultlen = len;
2379   return 0;
2380 }
2381
2382
2383 \f
2384 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2385    is not NULL, display DESC instead of the default description
2386    message.  If FORCE is true the agent is advised not to ask for
2387    confirmation. */
2388 gpg_error_t
2389 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2390                   int force)
2391 {
2392   gpg_error_t err;
2393   char line[ASSUAN_LINELENGTH];
2394   struct default_inq_parm_s dfltparm;
2395
2396   memset (&dfltparm, 0, sizeof dfltparm);
2397   dfltparm.ctrl = ctrl;
2398
2399   err = start_agent (ctrl, 0);
2400   if (err)
2401     return err;
2402
2403   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2404     return gpg_error (GPG_ERR_INV_VALUE);
2405
2406   if (desc)
2407     {
2408       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2409       err = assuan_transact (agent_ctx, line,
2410                              NULL, NULL, NULL, NULL, NULL, NULL);
2411       if (err)
2412         return err;
2413     }
2414
2415   snprintf (line, DIM(line)-1, "DELETE_KEY%s %s",
2416             force? " --force":"", hexkeygrip);
2417   err = assuan_transact (agent_ctx, line, NULL, NULL,
2418                          default_inq_cb, &dfltparm,
2419                          NULL, NULL);
2420   return err;
2421 }
2422
2423
2424 \f
2425 /* Ask the agent to change the passphrase of the key identified by
2426  * HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2427  * default description message.  If CACHE_NONCE_ADDR is not NULL the
2428  * agent is advised to first try a passphrase associated with that
2429  * nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2430  * the passphrase associated with that nonce for the new passphrase.
2431  * If VERIFY is true the passphrase is only verified.  */
2432 gpg_error_t
2433 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
2434               char **cache_nonce_addr, char **passwd_nonce_addr)
2435 {
2436   gpg_error_t err;
2437   struct cache_nonce_parm_s cn_parm;
2438   char line[ASSUAN_LINELENGTH];
2439   struct default_inq_parm_s dfltparm;
2440
2441   memset (&dfltparm, 0, sizeof dfltparm);
2442   dfltparm.ctrl = ctrl;
2443
2444   err = start_agent (ctrl, 0);
2445   if (err)
2446     return err;
2447   dfltparm.ctx = agent_ctx;
2448
2449   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2450     return gpg_error (GPG_ERR_INV_VALUE);
2451
2452   if (desc)
2453     {
2454       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2455       err = assuan_transact (agent_ctx, line,
2456                              NULL, NULL, NULL, NULL, NULL, NULL);
2457       if (err)
2458         return err;
2459     }
2460
2461   if (verify)
2462     snprintf (line, DIM(line)-1, "PASSWD %s%s --verify %s",
2463               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2464               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2465               hexkeygrip);
2466   else
2467     snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
2468               cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2469               cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2470               passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2471               passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2472               hexkeygrip);
2473   cn_parm.cache_nonce_addr = cache_nonce_addr;
2474   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2475   err = assuan_transact (agent_ctx, line, NULL, NULL,
2476                          default_inq_cb, &dfltparm,
2477                          cache_nonce_status_cb, &cn_parm);
2478   return err;
2479 }
2480
2481
2482 /* Return the version reported by gpg-agent.  */
2483 gpg_error_t
2484 agent_get_version (ctrl_t ctrl, char **r_version)
2485 {
2486   gpg_error_t err;
2487
2488   err = start_agent (ctrl, 0);
2489   if (err)
2490     return err;
2491
2492   err = get_assuan_server_version (agent_ctx, 0, r_version);
2493   return err;
2494 }