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