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