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