4bac8a0efee25852f2c085a177f22bef163a08ac
[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 #ifndef DBG_ASSUAN
47 # define DBG_ASSUAN 1
48 #endif
49
50 #define CONTROL_D ('D' - 'A' + 1)
51
52
53 static assuan_context_t agent_ctx = NULL;
54 static int did_early_card_test;
55
56 struct default_inq_parm_s
57 {
58   ctrl_t ctrl;
59   assuan_context_t ctx;
60   struct {
61     u32 *keyid;
62     u32 *mainkeyid;
63     int pubkey_algo;
64   } keyinfo;
65 };
66
67 struct cipher_parm_s
68 {
69   struct default_inq_parm_s *dflt;
70   assuan_context_t ctx;
71   unsigned char *ciphertext;
72   size_t ciphertextlen;
73 };
74
75 struct writecert_parm_s
76 {
77   struct default_inq_parm_s *dflt;
78   const unsigned char *certdata;
79   size_t certdatalen;
80 };
81
82 struct writekey_parm_s
83 {
84   struct default_inq_parm_s *dflt;
85   const unsigned char *keydata;
86   size_t keydatalen;
87 };
88
89 struct genkey_parm_s
90 {
91   struct default_inq_parm_s *dflt;
92   const char *keyparms;
93   const char *passphrase;
94 };
95
96 struct import_key_parm_s
97 {
98   struct default_inq_parm_s *dflt;
99   const void *key;
100   size_t keylen;
101 };
102
103
104 struct cache_nonce_parm_s
105 {
106   char **cache_nonce_addr;
107   char **passwd_nonce_addr;
108 };
109
110
111 struct scd_genkey_parm_s
112 {
113   struct agent_card_genkey_s *cgk;
114   char *savedbytes;     /* Malloced space to save key parameter chunks.  */
115 };
116
117
118 static gpg_error_t learn_status_cb (void *opaque, const char *line);
119
120
121 \f
122 /* If RC is not 0, write an appropriate status message. */
123 static void
124 status_sc_op_failure (int rc)
125 {
126   switch (gpg_err_code (rc))
127     {
128     case 0:
129       break;
130     case GPG_ERR_CANCELED:
131     case GPG_ERR_FULLY_CANCELED:
132       write_status_text (STATUS_SC_OP_FAILURE, "1");
133       break;
134     case GPG_ERR_BAD_PIN:
135       write_status_text (STATUS_SC_OP_FAILURE, "2");
136       break;
137     default:
138       write_status (STATUS_SC_OP_FAILURE);
139       break;
140     }
141 }
142
143
144 static gpg_error_t
145 membuf_data_cb (void *opaque, const void *buffer, size_t length)
146 {
147   membuf_t *data = opaque;
148
149   if (buffer)
150     put_membuf (data, buffer, length);
151   return 0;
152 }
153
154
155
156 /* This is the default inquiry callback.  It mainly handles the
157    Pinentry notifications.  */
158 static gpg_error_t
159 default_inq_cb (void *opaque, const char *line)
160 {
161   gpg_error_t err = 0;
162   struct default_inq_parm_s *parm = opaque;
163
164   if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
165     {
166       err = gpg_proxy_pinentry_notify (parm->ctrl, line);
167       if (err)
168         log_error (_("failed to proxy %s inquiry to client\n"),
169                    "PINENTRY_LAUNCHED");
170       /* We do not pass errors to avoid breaking other code.  */
171     }
172   else if ((has_leading_keyword (line, "PASSPHRASE")
173             || has_leading_keyword (line, "NEW_PASSPHRASE"))
174            && opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
175     {
176       if (have_static_passphrase ())
177         {
178           const char *s = get_static_passphrase ();
179           err = assuan_send_data (parm->ctx, s, strlen (s));
180         }
181       else
182         {
183           char *pw;
184
185           if (parm->keyinfo.keyid)
186             emit_status_need_passphrase (parm->keyinfo.keyid,
187                                          parm->keyinfo.mainkeyid,
188                                          parm->keyinfo.pubkey_algo);
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_ASSUAN,
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, algo, nbits;
653
654       sscanf (line, "%d %d %d", &keyno, &algo, &nbits);
655       keyno--;
656       if (keyno >= 0 && keyno < DIM (parm->key_attr))
657         {
658           parm->key_attr[keyno].algo = algo;
659           parm->key_attr[keyno].nbits = nbits;
660         }
661     }
662   else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
663            && strchr("1234", keyword[11]))
664     {
665       int no = keyword[11] - '1';
666       assert (no >= 0 && no <= 3);
667       xfree (parm->private_do[no]);
668       parm->private_do[no] = unescape_status_string (line);
669     }
670
671   return 0;
672 }
673
674 /* Call the scdaemon to learn about a smartcard */
675 int
676 agent_scd_learn (struct agent_card_info_s *info)
677 {
678   int rc;
679   struct default_inq_parm_s parm;
680   struct agent_card_info_s dummyinfo;
681
682   if (!info)
683     info = &dummyinfo;
684   memset (info, 0, sizeof *info);
685   memset (&parm, 0, sizeof parm);
686
687   rc = start_agent (NULL, 1);
688   if (rc)
689     return rc;
690
691   /* Send the serialno command to initialize the connection.  We don't
692      care about the data returned.  If the card has already been
693      initialized, this is a very fast command.  The main reason we
694      need to do this here is to handle a card removed case so that an
695      "l" command in --card-edit can be used to show ta newly inserted
696      card.  We request the openpgp card because that is what we
697      expect. */
698   rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
699                         NULL, NULL, NULL, NULL, NULL, NULL);
700   if (rc)
701     return rc;
702
703   parm.ctx = agent_ctx;
704   rc = assuan_transact (agent_ctx, "LEARN --sendinfo",
705                         dummy_data_cb, NULL, default_inq_cb, &parm,
706                         learn_status_cb, info);
707   /* Also try to get the key attributes.  */
708   if (!rc)
709     agent_scd_getattr ("KEY-ATTR", info);
710
711   if (info == &dummyinfo)
712     agent_release_card_info (info);
713
714   return rc;
715 }
716
717
718 /* Send an APDU to the current card.  On success the status word is
719    stored at R_SW.  With HEXAPDU being NULL only a RESET command is
720    send to scd.  With HEXAPDU being the string "undefined" the command
721    "SERIALNO undefined" is send to scd. */
722 gpg_error_t
723 agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
724 {
725   gpg_error_t err;
726
727   /* Start the agent but not with the card flag so that we do not
728      autoselect the openpgp application.  */
729   err = start_agent (NULL, 0);
730   if (err)
731     return err;
732
733   if (!hexapdu)
734     {
735       err = assuan_transact (agent_ctx, "SCD RESET",
736                              NULL, NULL, NULL, NULL, NULL, NULL);
737
738     }
739   else if (!strcmp (hexapdu, "undefined"))
740     {
741       err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
742                              NULL, NULL, NULL, NULL, NULL, NULL);
743     }
744   else
745     {
746       char line[ASSUAN_LINELENGTH];
747       membuf_t mb;
748       unsigned char *data;
749       size_t datalen;
750
751       init_membuf (&mb, 256);
752
753       snprintf (line, DIM(line)-1, "SCD APDU %s", hexapdu);
754       err = assuan_transact (agent_ctx, line,
755                              membuf_data_cb, &mb, NULL, NULL, NULL, NULL);
756       if (!err)
757         {
758           data = get_membuf (&mb, &datalen);
759           if (!data)
760             err = gpg_error_from_syserror ();
761           else if (datalen < 2) /* Ooops */
762             err = gpg_error (GPG_ERR_CARD);
763           else
764             {
765               *r_sw = buf16_to_uint (data+datalen-2);
766             }
767           xfree (data);
768         }
769     }
770
771   return err;
772 }
773
774
775 int
776 agent_keytocard (const char *hexgrip, int keyno, int force,
777                  const char *serialno, const char *timestamp)
778 {
779   int rc;
780   char line[ASSUAN_LINELENGTH];
781   struct default_inq_parm_s parm;
782
783   memset (&parm, 0, sizeof parm);
784   parm.ctx = agent_ctx;
785
786   snprintf (line, DIM(line)-1, "KEYTOCARD %s%s %s OPENPGP.%d %s",
787             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
788   line[DIM(line)-1] = 0;
789
790   rc = start_agent (NULL, 1);
791   if (rc)
792     return rc;
793
794   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
795                         NULL, NULL);
796   if (rc)
797     return rc;
798
799   return rc;
800 }
801 \f
802 /* Call the agent to retrieve a data object.  This function returns
803    the data in the same structure as used by the learn command.  It is
804    allowed to update such a structure using this commmand. */
805 int
806 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
807 {
808   int rc;
809   char line[ASSUAN_LINELENGTH];
810   struct default_inq_parm_s parm;
811
812   memset (&parm, 0, sizeof parm);
813
814   if (!*name)
815     return gpg_error (GPG_ERR_INV_VALUE);
816
817   /* We assume that NAME does not need escaping. */
818   if (12 + strlen (name) > DIM(line)-1)
819     return gpg_error (GPG_ERR_TOO_LARGE);
820   stpcpy (stpcpy (line, "SCD GETATTR "), name);
821
822   rc = start_agent (NULL, 1);
823   if (rc)
824     return rc;
825
826   parm.ctx = agent_ctx;
827   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
828                         learn_status_cb, info);
829
830   return rc;
831 }
832
833 \f
834 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
835    used here but required by gpg 1.4's implementation of this code in
836    cardglue.c. */
837 int
838 agent_scd_setattr (const char *name,
839                    const unsigned char *value, size_t valuelen,
840                    const char *serialno)
841 {
842   int rc;
843   char line[ASSUAN_LINELENGTH];
844   char *p;
845   struct default_inq_parm_s parm;
846
847   memset (&parm, 0, sizeof parm);
848
849   (void)serialno;
850
851   if (!*name || !valuelen)
852     return gpg_error (GPG_ERR_INV_VALUE);
853
854   /* We assume that NAME does not need escaping. */
855   if (12 + strlen (name) > DIM(line)-1)
856     return gpg_error (GPG_ERR_TOO_LARGE);
857
858   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
859   *p++ = ' ';
860   for (; valuelen; value++, valuelen--)
861     {
862       if (p >= line + DIM(line)-5 )
863         return gpg_error (GPG_ERR_TOO_LARGE);
864       if (*value < ' ' || *value == '+' || *value == '%')
865         {
866           sprintf (p, "%%%02X", *value);
867           p += 3;
868         }
869       else if (*value == ' ')
870         *p++ = '+';
871       else
872         *p++ = *value;
873     }
874   *p = 0;
875
876   rc = start_agent (NULL, 1);
877   if (!rc)
878     {
879       parm.ctx = agent_ctx;
880       rc = assuan_transact (agent_ctx, line, NULL, NULL,
881                             default_inq_cb, &parm, NULL, NULL);
882     }
883
884   status_sc_op_failure (rc);
885   return rc;
886 }
887
888
889 \f
890 /* Handle a CERTDATA inquiry.  Note, we only send the data,
891    assuan_transact takes care of flushing and writing the END
892    command. */
893 static gpg_error_t
894 inq_writecert_parms (void *opaque, const char *line)
895 {
896   int rc;
897   struct writecert_parm_s *parm = opaque;
898
899   if (has_leading_keyword (line, "CERTDATA"))
900     {
901       rc = assuan_send_data (parm->dflt->ctx,
902                              parm->certdata, parm->certdatalen);
903     }
904   else
905     rc = default_inq_cb (parm->dflt, line);
906
907   return rc;
908 }
909
910
911 /* Send a WRITECERT command to the SCdaemon. */
912 int
913 agent_scd_writecert (const char *certidstr,
914                      const unsigned char *certdata, size_t certdatalen)
915 {
916   int rc;
917   char line[ASSUAN_LINELENGTH];
918   struct writecert_parm_s parms;
919   struct default_inq_parm_s dfltparm;
920
921   memset (&dfltparm, 0, sizeof dfltparm);
922
923   rc = start_agent (NULL, 1);
924   if (rc)
925     return rc;
926
927   memset (&parms, 0, sizeof parms);
928
929   snprintf (line, DIM(line)-1, "SCD WRITECERT %s", certidstr);
930   line[DIM(line)-1] = 0;
931   dfltparm.ctx = agent_ctx;
932   parms.dflt = &dfltparm;
933   parms.certdata = certdata;
934   parms.certdatalen = certdatalen;
935
936   rc = assuan_transact (agent_ctx, line, NULL, NULL,
937                         inq_writecert_parms, &parms, NULL, NULL);
938
939   return rc;
940 }
941
942
943 \f
944 /* Handle a KEYDATA inquiry.  Note, we only send the data,
945    assuan_transact takes care of flushing and writing the end */
946 static gpg_error_t
947 inq_writekey_parms (void *opaque, const char *line)
948 {
949   int rc;
950   struct writekey_parm_s *parm = opaque;
951
952   if (has_leading_keyword (line, "KEYDATA"))
953     {
954       rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
955     }
956   else
957     rc = default_inq_cb (parm->dflt, line);
958
959   return rc;
960 }
961
962
963 /* Send a WRITEKEY command to the SCdaemon. */
964 int
965 agent_scd_writekey (int keyno, const char *serialno,
966                     const unsigned char *keydata, size_t keydatalen)
967 {
968   int rc;
969   char line[ASSUAN_LINELENGTH];
970   struct writekey_parm_s parms;
971   struct default_inq_parm_s dfltparm;
972
973   memset (&dfltparm, 0, sizeof dfltparm);
974
975   (void)serialno;
976
977   rc = start_agent (NULL, 1);
978   if (rc)
979     return rc;
980
981   memset (&parms, 0, sizeof parms);
982
983   snprintf (line, DIM(line)-1, "SCD WRITEKEY --force OPENPGP.%d", keyno);
984   line[DIM(line)-1] = 0;
985   dfltparm.ctx = agent_ctx;
986   parms.dflt = &dfltparm;
987   parms.keydata = keydata;
988   parms.keydatalen = keydatalen;
989
990   rc = assuan_transact (agent_ctx, line, NULL, NULL,
991                         inq_writekey_parms, &parms, NULL, NULL);
992
993   status_sc_op_failure (rc);
994   return rc;
995 }
996
997
998 \f
999 static gpg_error_t
1000 scd_genkey_cb_append_savedbytes (struct scd_genkey_parm_s *parm,
1001                                  const char *line)
1002 {
1003   gpg_error_t err = 0;
1004   char *p;
1005
1006   if (!parm->savedbytes)
1007     {
1008       parm->savedbytes = xtrystrdup (line);
1009       if (!parm->savedbytes)
1010         err = gpg_error_from_syserror ();
1011     }
1012   else
1013     {
1014       p = xtrymalloc (strlen (parm->savedbytes) + strlen (line) + 1);
1015       if (!p)
1016         err = gpg_error_from_syserror ();
1017       else
1018         {
1019           strcpy (stpcpy (p, parm->savedbytes), line);
1020           xfree (parm->savedbytes);
1021           parm->savedbytes = p;
1022         }
1023     }
1024
1025   return err;
1026 }
1027
1028 /* Status callback for the SCD GENKEY command. */
1029 static gpg_error_t
1030 scd_genkey_cb (void *opaque, const char *line)
1031 {
1032   struct scd_genkey_parm_s *parm = opaque;
1033   const char *keyword = line;
1034   int keywordlen;
1035   gpg_error_t rc = 0;
1036
1037   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1038     ;
1039   while (spacep (line))
1040     line++;
1041
1042   if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
1043     {
1044       parm->cgk->fprvalid = unhexify_fpr (line, parm->cgk->fpr);
1045     }
1046   else if (keywordlen == 8 && !memcmp (keyword, "KEY-DATA", keywordlen))
1047     {
1048       gcry_mpi_t a;
1049       const char *name = line;
1050
1051       while (*line && !spacep (line))
1052         line++;
1053       while (spacep (line))
1054         line++;
1055
1056       if (*name == '-' && spacep (name+1))
1057         rc = scd_genkey_cb_append_savedbytes (parm, line);
1058       else
1059         {
1060           if (parm->savedbytes)
1061             {
1062               rc = scd_genkey_cb_append_savedbytes (parm, line);
1063               if (!rc)
1064                 rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX,
1065                                     parm->savedbytes, 0, NULL);
1066             }
1067           else
1068             rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, line, 0, NULL);
1069           if (rc)
1070             log_error ("error parsing received key data: %s\n",
1071                        gpg_strerror (rc));
1072           else if (*name == 'n' && spacep (name+1))
1073             parm->cgk->n = a;
1074           else if (*name == 'e' && spacep (name+1))
1075             parm->cgk->e = a;
1076           else
1077             {
1078               log_info ("unknown parameter name in received key data\n");
1079               gcry_mpi_release (a);
1080               rc = gpg_error (GPG_ERR_INV_PARAMETER);
1081             }
1082
1083           xfree (parm->savedbytes);
1084           parm->savedbytes = NULL;
1085         }
1086     }
1087   else if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
1088     {
1089       parm->cgk->created_at = (u32)strtoul (line, NULL, 10);
1090     }
1091   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
1092     {
1093       write_status_text (STATUS_PROGRESS, line);
1094     }
1095
1096   return rc;
1097 }
1098
1099 /* Send a GENKEY command to the SCdaemon.  SERIALNO is not used in
1100    this implementation.  If CREATEDATE is not 0, it will be passed to
1101    SCDAEMON so that the key is created with this timestamp.  INFO will
1102    receive information about the generated key.  */
1103 int
1104 agent_scd_genkey (struct agent_card_genkey_s *info, int keyno, int force,
1105                   const char *serialno, u32 createtime)
1106 {
1107   int rc;
1108   char line[ASSUAN_LINELENGTH];
1109   gnupg_isotime_t tbuf;
1110   struct scd_genkey_parm_s parms;
1111   struct default_inq_parm_s dfltparm;
1112
1113   memset (&dfltparm, 0, sizeof dfltparm);
1114
1115   (void)serialno;
1116
1117   memset (&parms, 0, sizeof parms);
1118   parms.cgk = info;
1119
1120   rc = start_agent (NULL, 1);
1121   if (rc)
1122     return rc;
1123
1124   if (createtime)
1125     epoch2isotime (tbuf, createtime);
1126   else
1127     *tbuf = 0;
1128
1129   snprintf (line, DIM(line)-1, "SCD GENKEY %s%s %s %d",
1130             *tbuf? "--timestamp=":"", tbuf,
1131             force? "--force":"",
1132             keyno);
1133   line[DIM(line)-1] = 0;
1134
1135   dfltparm.ctx = agent_ctx;
1136   memset (info, 0, sizeof *info);
1137   rc = assuan_transact (agent_ctx, line,
1138                         NULL, NULL, default_inq_cb, &dfltparm,
1139                         scd_genkey_cb, &parms);
1140
1141   xfree (parms.savedbytes);
1142
1143   status_sc_op_failure (rc);
1144   return rc;
1145 }
1146
1147
1148
1149 \f
1150 /* Issue an SCD SERIALNO openpgp command and if SERIALNO is not NULL
1151    ask the user to insert the requested card.  */
1152 gpg_error_t
1153 select_openpgp (const char *serialno)
1154 {
1155   gpg_error_t err;
1156
1157   /* Send the serialno command to initialize the connection.  Without
1158      a given S/N we don't care about the data returned.  If the card
1159      has already been initialized, this is a very fast command.  We
1160      request the openpgp card because that is what we expect.
1161
1162      Note that an opt.limit_card_insert_tries of 1 means: No tries at
1163      all whereas 0 means do not limit the number of tries.  Due to the
1164      sue of a pinentry prompt with a cancel option we use it here in a
1165      boolean sense.  */
1166   if (!serialno || opt.limit_card_insert_tries == 1)
1167     err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
1168                            NULL, NULL, NULL, NULL, NULL, NULL);
1169   else
1170     {
1171       char *this_sn = NULL;
1172       char *desc;
1173       int ask;
1174       char *want_sn;
1175       char *p;
1176
1177       want_sn = xtrystrdup (serialno);
1178       if (!want_sn)
1179         return gpg_error_from_syserror ();
1180       p = strchr (want_sn, '/');
1181       if (p)
1182         *p = 0;
1183
1184       do
1185         {
1186           ask = 0;
1187           err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
1188                                  NULL, NULL, NULL, NULL,
1189                                  get_serialno_cb, &this_sn);
1190           if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
1191             ask = 1;
1192           else if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
1193             ask = 2;
1194           else if (err)
1195             ;
1196           else if (this_sn)
1197             {
1198               if (strcmp (want_sn, this_sn))
1199                 ask = 2;
1200             }
1201
1202           xfree (this_sn);
1203           this_sn = NULL;
1204
1205           if (ask)
1206             {
1207               char *formatted = NULL;
1208               char *ocodeset = i18n_switchto_utf8 ();
1209
1210               if (!strncmp (want_sn, "D27600012401", 12)
1211                   && strlen (want_sn) == 32 )
1212                 formatted = xtryasprintf ("(%.4s) %.8s",
1213                                           want_sn + 16, want_sn + 20);
1214
1215               err = 0;
1216               desc = xtryasprintf
1217                 ("%s:\n\n"
1218                  "  \"%s\"",
1219                  ask == 1
1220                  ? _("Please insert the card with serial number")
1221                  : _("Please remove the current card and "
1222                      "insert the one with serial number"),
1223                  formatted? formatted : want_sn);
1224               if (!desc)
1225                 err = gpg_error_from_syserror ();
1226               xfree (formatted);
1227               i18n_switchback (ocodeset);
1228               if (!err)
1229                 err = gpg_agent_get_confirmation (desc);
1230               xfree (desc);
1231             }
1232         }
1233       while (ask && !err);
1234       xfree (want_sn);
1235     }
1236
1237   return err;
1238 }
1239
1240
1241 \f
1242 /* Send a READCERT command to the SCdaemon. */
1243 int
1244 agent_scd_readcert (const char *certidstr,
1245                     void **r_buf, size_t *r_buflen)
1246 {
1247   int rc;
1248   char line[ASSUAN_LINELENGTH];
1249   membuf_t data;
1250   size_t len;
1251   struct default_inq_parm_s dfltparm;
1252
1253   memset (&dfltparm, 0, sizeof dfltparm);
1254
1255   *r_buf = NULL;
1256   rc = start_agent (NULL, 1);
1257   if (rc)
1258     return rc;
1259
1260   dfltparm.ctx = agent_ctx;
1261
1262   init_membuf (&data, 2048);
1263
1264   snprintf (line, DIM(line)-1, "SCD READCERT %s", certidstr);
1265   line[DIM(line)-1] = 0;
1266   rc = assuan_transact (agent_ctx, line,
1267                         membuf_data_cb, &data,
1268                         default_inq_cb, &dfltparm,
1269                         NULL, NULL);
1270   if (rc)
1271     {
1272       xfree (get_membuf (&data, &len));
1273       return rc;
1274     }
1275   *r_buf = get_membuf (&data, r_buflen);
1276   if (!*r_buf)
1277     return gpg_error (GPG_ERR_ENOMEM);
1278
1279   return 0;
1280 }
1281
1282
1283 \f
1284 /* Change the PIN of an OpenPGP card or reset the retry counter.
1285    CHVNO 1: Change the PIN
1286          2: For v1 cards: Same as 1.
1287             For v2 cards: Reset the PIN using the Reset Code.
1288          3: Change the admin PIN
1289        101: Set a new PIN and reset the retry counter
1290        102: For v1 cars: Same as 101.
1291             For v2 cards: Set a new Reset Code.
1292    SERIALNO is not used.
1293  */
1294 int
1295 agent_scd_change_pin (int chvno, const char *serialno)
1296 {
1297   int rc;
1298   char line[ASSUAN_LINELENGTH];
1299   const char *reset = "";
1300   struct default_inq_parm_s dfltparm;
1301
1302   memset (&dfltparm, 0, sizeof dfltparm);
1303
1304   (void)serialno;
1305
1306   if (chvno >= 100)
1307     reset = "--reset";
1308   chvno %= 100;
1309
1310   rc = start_agent (NULL, 1);
1311   if (rc)
1312     return rc;
1313   dfltparm.ctx = agent_ctx;
1314
1315   snprintf (line, DIM(line)-1, "SCD PASSWD %s %d", reset, chvno);
1316   line[DIM(line)-1] = 0;
1317   rc = assuan_transact (agent_ctx, line,
1318                         NULL, NULL,
1319                         default_inq_cb, &dfltparm,
1320                         NULL, NULL);
1321   status_sc_op_failure (rc);
1322   return rc;
1323 }
1324
1325
1326 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1327    number of the card - optionally followed by the fingerprint;
1328    however the fingerprint is ignored here. */
1329 int
1330 agent_scd_checkpin  (const char *serialno)
1331 {
1332   int rc;
1333   char line[ASSUAN_LINELENGTH];
1334   struct default_inq_parm_s dfltparm;
1335
1336   memset (&dfltparm, 0, sizeof dfltparm);
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 CHECKPIN %s", serialno);
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 /* Dummy function, only used by the gpg 1.4 implementation. */
1355 void
1356 agent_clear_pin_cache (const char *sn)
1357 {
1358   (void)sn;
1359 }
1360
1361
1362
1363 \f
1364 /* Note: All strings shall be UTF-8. On success the caller needs to
1365    free the string stored at R_PASSPHRASE. On error NULL will be
1366    stored at R_PASSPHRASE and an appropriate fpf error code
1367    returned. */
1368 gpg_error_t
1369 agent_get_passphrase (const char *cache_id,
1370                       const char *err_msg,
1371                       const char *prompt,
1372                       const char *desc_msg,
1373                       int repeat,
1374                       int check,
1375                       char **r_passphrase)
1376 {
1377   int rc;
1378   char line[ASSUAN_LINELENGTH];
1379   char *arg1 = NULL;
1380   char *arg2 = NULL;
1381   char *arg3 = NULL;
1382   char *arg4 = NULL;
1383   membuf_t data;
1384   struct default_inq_parm_s dfltparm;
1385
1386   memset (&dfltparm, 0, sizeof dfltparm);
1387
1388   *r_passphrase = NULL;
1389
1390   rc = start_agent (NULL, 0);
1391   if (rc)
1392     return rc;
1393   dfltparm.ctx = agent_ctx;
1394
1395   /* Check that the gpg-agent understands the repeat option.  */
1396   if (assuan_transact (agent_ctx,
1397                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1398                        NULL, NULL, NULL, NULL, NULL, NULL))
1399     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1400
1401   if (cache_id && *cache_id)
1402     if (!(arg1 = percent_plus_escape (cache_id)))
1403       goto no_mem;
1404   if (err_msg && *err_msg)
1405     if (!(arg2 = percent_plus_escape (err_msg)))
1406       goto no_mem;
1407   if (prompt && *prompt)
1408     if (!(arg3 = percent_plus_escape (prompt)))
1409       goto no_mem;
1410   if (desc_msg && *desc_msg)
1411     if (!(arg4 = percent_plus_escape (desc_msg)))
1412       goto no_mem;
1413
1414   snprintf (line, DIM(line)-1,
1415             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1416             repeat,
1417             check? " --check --qualitybar":"",
1418             arg1? arg1:"X",
1419             arg2? arg2:"X",
1420             arg3? arg3:"X",
1421             arg4? arg4:"X");
1422   line[DIM(line)-1] = 0;
1423   xfree (arg1);
1424   xfree (arg2);
1425   xfree (arg3);
1426   xfree (arg4);
1427
1428   init_membuf_secure (&data, 64);
1429   rc = assuan_transact (agent_ctx, line,
1430                         membuf_data_cb, &data,
1431                         default_inq_cb, &dfltparm,
1432                         NULL, NULL);
1433
1434   if (rc)
1435     xfree (get_membuf (&data, NULL));
1436   else
1437     {
1438       put_membuf (&data, "", 1);
1439       *r_passphrase = get_membuf (&data, NULL);
1440       if (!*r_passphrase)
1441         rc = gpg_error_from_syserror ();
1442     }
1443   return rc;
1444  no_mem:
1445   rc = gpg_error_from_syserror ();
1446   xfree (arg1);
1447   xfree (arg2);
1448   xfree (arg3);
1449   xfree (arg4);
1450   return rc;
1451 }
1452
1453
1454 gpg_error_t
1455 agent_clear_passphrase (const char *cache_id)
1456 {
1457   int rc;
1458   char line[ASSUAN_LINELENGTH];
1459   struct default_inq_parm_s dfltparm;
1460
1461   memset (&dfltparm, 0, sizeof dfltparm);
1462
1463   if (!cache_id || !*cache_id)
1464     return 0;
1465
1466   rc = start_agent (NULL, 0);
1467   if (rc)
1468     return rc;
1469   dfltparm.ctx = agent_ctx;
1470
1471   snprintf (line, DIM(line)-1, "CLEAR_PASSPHRASE %s", cache_id);
1472   line[DIM(line)-1] = 0;
1473   return assuan_transact (agent_ctx, line,
1474                           NULL, NULL,
1475                           default_inq_cb, &dfltparm,
1476                           NULL, NULL);
1477 }
1478
1479
1480 /* Ask the agent to pop up a confirmation dialog with the text DESC
1481    and an okay and cancel button. */
1482 gpg_error_t
1483 gpg_agent_get_confirmation (const char *desc)
1484 {
1485   int rc;
1486   char *tmp;
1487   char line[ASSUAN_LINELENGTH];
1488   struct default_inq_parm_s dfltparm;
1489
1490   memset (&dfltparm, 0, sizeof dfltparm);
1491
1492   rc = start_agent (NULL, 0);
1493   if (rc)
1494     return rc;
1495   dfltparm.ctx = agent_ctx;
1496
1497   tmp = percent_plus_escape (desc);
1498   if (!tmp)
1499     return gpg_error_from_syserror ();
1500   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", tmp);
1501   line[DIM(line)-1] = 0;
1502   xfree (tmp);
1503
1504   rc = assuan_transact (agent_ctx, line,
1505                         NULL, NULL,
1506                         default_inq_cb, &dfltparm,
1507                         NULL, NULL);
1508   return rc;
1509 }
1510
1511
1512 /* Return the S2K iteration count as computed by gpg-agent.  */
1513 gpg_error_t
1514 agent_get_s2k_count (unsigned long *r_count)
1515 {
1516   gpg_error_t err;
1517   membuf_t data;
1518   char *buf;
1519
1520   *r_count = 0;
1521
1522   err = start_agent (NULL, 0);
1523   if (err)
1524     return err;
1525
1526   init_membuf (&data, 32);
1527   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1528                         membuf_data_cb, &data,
1529                         NULL, NULL, NULL, NULL);
1530   if (err)
1531     xfree (get_membuf (&data, NULL));
1532   else
1533     {
1534       put_membuf (&data, "", 1);
1535       buf = get_membuf (&data, NULL);
1536       if (!buf)
1537         err = gpg_error_from_syserror ();
1538       else
1539         {
1540           *r_count = strtoul (buf, NULL, 10);
1541           xfree (buf);
1542         }
1543     }
1544   return err;
1545 }
1546
1547
1548 \f
1549 /* Ask the agent whether a secret key for the given public key is
1550    available.  Returns 0 if available.  */
1551 gpg_error_t
1552 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1553 {
1554   gpg_error_t err;
1555   char line[ASSUAN_LINELENGTH];
1556   char *hexgrip;
1557
1558   err = start_agent (ctrl, 0);
1559   if (err)
1560     return err;
1561
1562   err = hexkeygrip_from_pk (pk, &hexgrip);
1563   if (err)
1564     return err;
1565
1566   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1567   xfree (hexgrip);
1568
1569   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1570   return err;
1571 }
1572
1573 /* Ask the agent whether a secret key is available for any of the
1574    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1575 gpg_error_t
1576 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1577 {
1578   gpg_error_t err;
1579   char line[ASSUAN_LINELENGTH];
1580   char *p;
1581   kbnode_t kbctx, node;
1582   int nkeys;
1583   unsigned char grip[20];
1584
1585   err = start_agent (ctrl, 0);
1586   if (err)
1587     return err;
1588
1589   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1590                                           found in KEYBLOCK.  */
1591   p = stpcpy (line, "HAVEKEY");
1592   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1593     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1594         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1595         || node->pkt->pkttype == PKT_SECRET_KEY
1596         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1597       {
1598         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1599           {
1600             err = assuan_transact (agent_ctx, line,
1601                                    NULL, NULL, NULL, NULL, NULL, NULL);
1602             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1603               break; /* Seckey available or unexpected error - ready.  */
1604             p = stpcpy (line, "HAVEKEY");
1605             nkeys = 0;
1606           }
1607
1608         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1609         if (err)
1610           return err;
1611         *p++ = ' ';
1612         bin2hex (grip, 20, p);
1613         p += 40;
1614         nkeys++;
1615       }
1616
1617   if (!err && nkeys)
1618     err = assuan_transact (agent_ctx, line,
1619                            NULL, NULL, NULL, NULL, NULL, NULL);
1620
1621   return err;
1622 }
1623
1624
1625 \f
1626 static gpg_error_t
1627 keyinfo_status_cb (void *opaque, const char *line)
1628 {
1629   char **serialno = opaque;
1630   const char *s, *s2;
1631
1632   if ((s = has_leading_keyword (line, "KEYINFO ")) && !*serialno)
1633     {
1634       s = strchr (s, ' ');
1635       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1636         {
1637           s += 3;
1638           s2 = strchr (s, ' ');
1639           if ( s2 > s )
1640             {
1641               *serialno = xtrymalloc ((s2 - s)+1);
1642               if (*serialno)
1643                 {
1644                   memcpy (*serialno, s, s2 - s);
1645                   (*serialno)[s2 - s] = 0;
1646                 }
1647             }
1648         }
1649     }
1650   return 0;
1651 }
1652
1653
1654 /* Return the serial number for a secret key.  If the returned serial
1655    number is NULL, the key is not stored on a smartcard.  Caller needs
1656    to free R_SERIALNO.  */
1657 gpg_error_t
1658 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1659 {
1660   gpg_error_t err;
1661   char line[ASSUAN_LINELENGTH];
1662   char *serialno = NULL;
1663
1664   *r_serialno = NULL;
1665
1666   err = start_agent (ctrl, 0);
1667   if (err)
1668     return err;
1669
1670   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1671     return gpg_error (GPG_ERR_INV_VALUE);
1672
1673   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1674   line[DIM(line)-1] = 0;
1675
1676   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1677                          keyinfo_status_cb, &serialno);
1678   if (!err && serialno)
1679     {
1680       /* Sanity check for bad characters.  */
1681       if (strpbrk (serialno, ":\n\r"))
1682         err = GPG_ERR_INV_VALUE;
1683     }
1684   if (err)
1685     xfree (serialno);
1686   else
1687     *r_serialno = serialno;
1688   return err;
1689 }
1690
1691 \f
1692 /* Status callback for agent_import_key, agent_export_key and
1693    agent_genkey.  */
1694 static gpg_error_t
1695 cache_nonce_status_cb (void *opaque, const char *line)
1696 {
1697   struct cache_nonce_parm_s *parm = opaque;
1698   const char *keyword = line;
1699   int keywordlen;
1700
1701   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1702     ;
1703   while (spacep (line))
1704     line++;
1705
1706   if (keywordlen == 11 && !memcmp (keyword, "CACHE_NONCE", keywordlen))
1707     {
1708       if (parm->cache_nonce_addr)
1709         {
1710           xfree (*parm->cache_nonce_addr);
1711           *parm->cache_nonce_addr = xtrystrdup (line);
1712         }
1713     }
1714   else if (keywordlen == 12 && !memcmp (keyword, "PASSWD_NONCE", keywordlen))
1715     {
1716       if (parm->passwd_nonce_addr)
1717         {
1718           xfree (*parm->passwd_nonce_addr);
1719           *parm->passwd_nonce_addr = xtrystrdup (line);
1720         }
1721     }
1722
1723   return 0;
1724 }
1725
1726
1727 \f
1728 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1729    assuan_transact takes care of flushing and writing the end */
1730 static gpg_error_t
1731 inq_genkey_parms (void *opaque, const char *line)
1732 {
1733   struct genkey_parm_s *parm = opaque;
1734   gpg_error_t err;
1735
1736   if (has_leading_keyword (line, "KEYPARAM"))
1737     {
1738       err = assuan_send_data (parm->dflt->ctx,
1739                               parm->keyparms, strlen (parm->keyparms));
1740     }
1741   else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
1742     {
1743       err = assuan_send_data (parm->dflt->ctx,
1744                               parm->passphrase,  strlen (parm->passphrase));
1745     }
1746   else
1747     err = default_inq_cb (parm->dflt, line);
1748
1749   return err;
1750 }
1751
1752
1753 /* Call the agent to generate a new key.  KEYPARMS is the usual
1754    S-expression giving the parameters of the key.  gpg-agent passes it
1755    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1756    to protect the generated key.  If NO_PROTECTION is not set and
1757    PASSPHRASE is not NULL the agent is requested to protect the key
1758    with that passphrase instead of asking for one.  */
1759 gpg_error_t
1760 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr,
1761               const char *keyparms, int no_protection,
1762               const char *passphrase, gcry_sexp_t *r_pubkey)
1763 {
1764   gpg_error_t err;
1765   struct genkey_parm_s gk_parm;
1766   struct cache_nonce_parm_s cn_parm;
1767   struct default_inq_parm_s dfltparm;
1768   membuf_t data;
1769   size_t len;
1770   unsigned char *buf;
1771   char line[ASSUAN_LINELENGTH];
1772
1773   memset (&dfltparm, 0, sizeof dfltparm);
1774   dfltparm.ctrl = ctrl;
1775
1776   *r_pubkey = NULL;
1777   err = start_agent (ctrl, 0);
1778   if (err)
1779     return err;
1780   dfltparm.ctx = agent_ctx;
1781
1782   err = assuan_transact (agent_ctx, "RESET",
1783                          NULL, NULL, NULL, NULL, NULL, NULL);
1784   if (err)
1785     return err;
1786
1787   init_membuf (&data, 1024);
1788   gk_parm.dflt     = &dfltparm;
1789   gk_parm.keyparms = keyparms;
1790   gk_parm.passphrase = passphrase;
1791   snprintf (line, sizeof line, "GENKEY%s%s%s",
1792             no_protection? " --no-protection" :
1793             passphrase   ? " --inq-passwd" :
1794             /*          */ "",
1795             cache_nonce_addr && *cache_nonce_addr? " ":"",
1796             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1797   cn_parm.cache_nonce_addr = cache_nonce_addr;
1798   cn_parm.passwd_nonce_addr = NULL;
1799   err = assuan_transact (agent_ctx, line,
1800                          membuf_data_cb, &data,
1801                          inq_genkey_parms, &gk_parm,
1802                          cache_nonce_status_cb, &cn_parm);
1803   if (err)
1804     {
1805       xfree (get_membuf (&data, &len));
1806       return err;
1807     }
1808
1809   buf = get_membuf (&data, &len);
1810   if (!buf)
1811     err = gpg_error_from_syserror ();
1812   else
1813     {
1814       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1815       xfree (buf);
1816     }
1817   return err;
1818 }
1819
1820
1821 \f
1822 /* Call the agent to read the public key part for a given keygrip.  If
1823    FROMCARD is true, the key is directly read from the current
1824    smartcard. In this case HEXKEYGRIP should be the keyID
1825    (e.g. OPENPGP.3). */
1826 gpg_error_t
1827 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1828                unsigned char **r_pubkey)
1829 {
1830   gpg_error_t err;
1831   membuf_t data;
1832   size_t len;
1833   unsigned char *buf;
1834   char line[ASSUAN_LINELENGTH];
1835   struct default_inq_parm_s dfltparm;
1836
1837   memset (&dfltparm, 0, sizeof dfltparm);
1838   dfltparm.ctrl = ctrl;
1839
1840   *r_pubkey = NULL;
1841   err = start_agent (ctrl, 0);
1842   if (err)
1843     return err;
1844   dfltparm.ctx = agent_ctx;
1845
1846   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1847   if (err)
1848     return err;
1849
1850   snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
1851
1852   init_membuf (&data, 1024);
1853   err = assuan_transact (agent_ctx, line,
1854                          membuf_data_cb, &data,
1855                          default_inq_cb, &dfltparm,
1856                          NULL, NULL);
1857   if (err)
1858     {
1859       xfree (get_membuf (&data, &len));
1860       return err;
1861     }
1862   buf = get_membuf (&data, &len);
1863   if (!buf)
1864     return gpg_error_from_syserror ();
1865   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1866     {
1867       xfree (buf);
1868       return gpg_error (GPG_ERR_INV_SEXP);
1869     }
1870   *r_pubkey = buf;
1871   return 0;
1872 }
1873
1874
1875 \f
1876 /* Call the agent to do a sign operation using the key identified by
1877    the hex string KEYGRIP.  DESC is a description of the key to be
1878    displayed if the agent needs to ask for the PIN.  DIGEST and
1879    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1880    used to compute the digest.  If CACHE_NONCE is used the agent is
1881    advised to first try a passphrase associated with that nonce. */
1882 gpg_error_t
1883 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1884               const char *keygrip, const char *desc,
1885               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1886               unsigned char *digest, size_t digestlen, int digestalgo,
1887               gcry_sexp_t *r_sigval)
1888 {
1889   gpg_error_t err;
1890   char line[ASSUAN_LINELENGTH];
1891   membuf_t data;
1892   struct default_inq_parm_s dfltparm;
1893
1894   memset (&dfltparm, 0, sizeof dfltparm);
1895   dfltparm.ctrl = ctrl;
1896   dfltparm.keyinfo.keyid       = keyid;
1897   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1898   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1899
1900   *r_sigval = NULL;
1901   err = start_agent (ctrl, 0);
1902   if (err)
1903     return err;
1904   dfltparm.ctx = agent_ctx;
1905
1906   if (digestlen*2 + 50 > DIM(line))
1907     return gpg_error (GPG_ERR_GENERAL);
1908
1909   err = assuan_transact (agent_ctx, "RESET",
1910                          NULL, NULL, NULL, NULL, NULL, NULL);
1911   if (err)
1912     return err;
1913
1914   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1915   line[DIM(line)-1] = 0;
1916   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1917   if (err)
1918     return err;
1919
1920   if (desc)
1921     {
1922       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1923       line[DIM(line)-1] = 0;
1924       err = assuan_transact (agent_ctx, line,
1925                             NULL, NULL, NULL, NULL, NULL, NULL);
1926       if (err)
1927         return err;
1928     }
1929
1930   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1931   bin2hex (digest, digestlen, line + strlen (line));
1932   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1933   if (err)
1934     return err;
1935
1936   init_membuf (&data, 1024);
1937
1938   snprintf (line, sizeof line, "PKSIGN%s%s",
1939             cache_nonce? " -- ":"",
1940             cache_nonce? cache_nonce:"");
1941   err = assuan_transact (agent_ctx, line,
1942                          membuf_data_cb, &data,
1943                          default_inq_cb, &dfltparm,
1944                          NULL, NULL);
1945   if (err)
1946     xfree (get_membuf (&data, NULL));
1947   else
1948     {
1949       unsigned char *buf;
1950       size_t len;
1951
1952       buf = get_membuf (&data, &len);
1953       if (!buf)
1954         err = gpg_error_from_syserror ();
1955       else
1956         {
1957           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1958           xfree (buf);
1959         }
1960     }
1961   return err;
1962 }
1963
1964
1965 \f
1966 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1967    assuan_transact takes care of flushing and writing the END. */
1968 static gpg_error_t
1969 inq_ciphertext_cb (void *opaque, const char *line)
1970 {
1971   struct cipher_parm_s *parm = opaque;
1972   int rc;
1973
1974   if (has_leading_keyword (line, "CIPHERTEXT"))
1975     {
1976       assuan_begin_confidential (parm->ctx);
1977       rc = assuan_send_data (parm->dflt->ctx,
1978                              parm->ciphertext, parm->ciphertextlen);
1979       assuan_end_confidential (parm->ctx);
1980     }
1981   else
1982     rc = default_inq_cb (parm->dflt, line);
1983
1984   return rc;
1985 }
1986
1987
1988 /* Check whether there is any padding info from the agent.  */
1989 static gpg_error_t
1990 padding_info_cb (void *opaque, const char *line)
1991 {
1992   int *r_padding = opaque;
1993   const char *s;
1994
1995   if ((s=has_leading_keyword (line, "PADDING")))
1996     {
1997       *r_padding = atoi (s);
1998     }
1999
2000   return 0;
2001 }
2002
2003
2004 /* Call the agent to do a decrypt operation using the key identified
2005    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
2006    success the decoded value is stored verbatim at R_BUF and its
2007    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
2008    and PUBKEY_ALGO are used to construct additional promots or status
2009    messages.   The padding information is stored at R_PADDING with -1
2010    for not known.  */
2011 gpg_error_t
2012 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
2013                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
2014                  gcry_sexp_t s_ciphertext,
2015                  unsigned char **r_buf, size_t *r_buflen, int *r_padding)
2016 {
2017   gpg_error_t err;
2018   char line[ASSUAN_LINELENGTH];
2019   membuf_t data;
2020   size_t n, len;
2021   char *p, *buf, *endp;
2022   struct default_inq_parm_s dfltparm;
2023
2024   memset (&dfltparm, 0, sizeof dfltparm);
2025   dfltparm.ctrl = ctrl;
2026   dfltparm.keyinfo.keyid       = keyid;
2027   dfltparm.keyinfo.mainkeyid   = mainkeyid;
2028   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
2029
2030   if (!keygrip || strlen(keygrip) != 40
2031       || !s_ciphertext || !r_buf || !r_buflen || !r_padding)
2032     return gpg_error (GPG_ERR_INV_VALUE);
2033
2034   *r_buf = NULL;
2035   *r_padding = -1;
2036
2037   err = start_agent (ctrl, 0);
2038   if (err)
2039     return err;
2040   dfltparm.ctx = agent_ctx;
2041
2042   err = assuan_transact (agent_ctx, "RESET",
2043                          NULL, NULL, NULL, NULL, NULL, NULL);
2044   if (err)
2045     return err;
2046
2047   snprintf (line, sizeof line, "SETKEY %s", keygrip);
2048   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
2049   if (err)
2050     return err;
2051
2052   if (desc)
2053     {
2054       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2055       line[DIM(line)-1] = 0;
2056       err = assuan_transact (agent_ctx, line,
2057                             NULL, NULL, NULL, NULL, NULL, NULL);
2058       if (err)
2059         return err;
2060     }
2061
2062   init_membuf_secure (&data, 1024);
2063   {
2064     struct cipher_parm_s parm;
2065
2066     parm.dflt = &dfltparm;
2067     parm.ctx = agent_ctx;
2068     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
2069     if (err)
2070       return err;
2071     err = assuan_transact (agent_ctx, "PKDECRYPT",
2072                            membuf_data_cb, &data,
2073                            inq_ciphertext_cb, &parm,
2074                            padding_info_cb, r_padding);
2075     xfree (parm.ciphertext);
2076   }
2077   if (err)
2078     {
2079       xfree (get_membuf (&data, &len));
2080       return err;
2081     }
2082
2083   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
2084   buf = get_membuf (&data, &len);
2085   if (!buf)
2086     return gpg_error_from_syserror ();
2087   assert (len); /* (we forced Nul termination.)  */
2088
2089   if (*buf != '(')
2090     {
2091       xfree (buf);
2092       return gpg_error (GPG_ERR_INV_SEXP);
2093     }
2094
2095   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
2096     {
2097       xfree (buf);
2098       return gpg_error (GPG_ERR_INV_SEXP);
2099     }
2100   len -= 10;   /* Count only the data of the second part. */
2101   p = buf + 8; /* Skip leading parenthesis and the value tag. */
2102
2103   n = strtoul (p, &endp, 10);
2104   if (!n || *endp != ':')
2105     {
2106       xfree (buf);
2107       return gpg_error (GPG_ERR_INV_SEXP);
2108     }
2109   endp++;
2110   if (endp-p+n > len)
2111     {
2112       xfree (buf);
2113       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
2114     }
2115
2116   memmove (buf, endp, n);
2117
2118   *r_buflen = n;
2119   *r_buf = buf;
2120   return 0;
2121 }
2122
2123
2124 \f
2125 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
2126    the key shall be used for export, with false for import.  On success
2127    the new key is stored at R_KEY and its length at R_KEKLEN.  */
2128 gpg_error_t
2129 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
2130 {
2131   gpg_error_t err;
2132   membuf_t data;
2133   size_t len;
2134   unsigned char *buf;
2135   char line[ASSUAN_LINELENGTH];
2136   struct default_inq_parm_s dfltparm;
2137
2138   memset (&dfltparm, 0, sizeof dfltparm);
2139   dfltparm.ctrl = ctrl;
2140
2141   *r_kek = NULL;
2142   err = start_agent (ctrl, 0);
2143   if (err)
2144     return err;
2145   dfltparm.ctx = agent_ctx;
2146
2147   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
2148             forexport? "--export":"--import");
2149
2150   init_membuf_secure (&data, 64);
2151   err = assuan_transact (agent_ctx, line,
2152                          membuf_data_cb, &data,
2153                          default_inq_cb, &dfltparm,
2154                          NULL, NULL);
2155   if (err)
2156     {
2157       xfree (get_membuf (&data, &len));
2158       return err;
2159     }
2160   buf = get_membuf (&data, &len);
2161   if (!buf)
2162     return gpg_error_from_syserror ();
2163   *r_kek = buf;
2164   *r_keklen = len;
2165   return 0;
2166 }
2167
2168
2169 \f
2170 /* Handle the inquiry for an IMPORT_KEY command.  */
2171 static gpg_error_t
2172 inq_import_key_parms (void *opaque, const char *line)
2173 {
2174   struct import_key_parm_s *parm = opaque;
2175   gpg_error_t err;
2176
2177   if (has_leading_keyword (line, "KEYDATA"))
2178     {
2179       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
2180     }
2181   else
2182     err = default_inq_cb (parm->dflt, line);
2183
2184   return err;
2185 }
2186
2187
2188 /* Call the agent to import a key into the agent.  */
2189 gpg_error_t
2190 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2191                   const void *key, size_t keylen, int unattended)
2192 {
2193   gpg_error_t err;
2194   struct import_key_parm_s parm;
2195   struct cache_nonce_parm_s cn_parm;
2196   char line[ASSUAN_LINELENGTH];
2197   struct default_inq_parm_s dfltparm;
2198
2199   memset (&dfltparm, 0, sizeof dfltparm);
2200   dfltparm.ctrl = ctrl;
2201
2202   err = start_agent (ctrl, 0);
2203   if (err)
2204     return err;
2205   dfltparm.ctx = agent_ctx;
2206
2207   if (desc)
2208     {
2209       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2210       line[DIM(line)-1] = 0;
2211       err = assuan_transact (agent_ctx, line,
2212                             NULL, NULL, NULL, NULL, NULL, NULL);
2213       if (err)
2214         return err;
2215     }
2216
2217   parm.dflt   = &dfltparm;
2218   parm.key    = key;
2219   parm.keylen = keylen;
2220
2221   snprintf (line, sizeof line, "IMPORT_KEY%s%s%s",
2222             unattended? " --unattended":"",
2223             cache_nonce_addr && *cache_nonce_addr? " ":"",
2224             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2225   cn_parm.cache_nonce_addr = cache_nonce_addr;
2226   cn_parm.passwd_nonce_addr = NULL;
2227   err = assuan_transact (agent_ctx, line,
2228                          NULL, NULL,
2229                          inq_import_key_parms, &parm,
2230                          cache_nonce_status_cb, &cn_parm);
2231   return err;
2232 }
2233
2234
2235 \f
2236 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2237    keygrip, DESC a prompt to be displayed with the agent's passphrase
2238    question (needs to be plus+percent escaped).  If CACHE_NONCE_ADDR
2239    is not NULL the agent is advised to first try a passphrase
2240    associated with that nonce.  On success the key is stored as a
2241    canonical S-expression at R_RESULT and R_RESULTLEN.  */
2242 gpg_error_t
2243 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2244                   char **cache_nonce_addr,
2245                   unsigned char **r_result, size_t *r_resultlen)
2246 {
2247   gpg_error_t err;
2248   struct cache_nonce_parm_s cn_parm;
2249   membuf_t data;
2250   size_t len;
2251   unsigned char *buf;
2252   char line[ASSUAN_LINELENGTH];
2253   struct default_inq_parm_s dfltparm;
2254
2255   memset (&dfltparm, 0, sizeof dfltparm);
2256   dfltparm.ctrl = ctrl;
2257
2258   *r_result = NULL;
2259
2260   err = start_agent (ctrl, 0);
2261   if (err)
2262     return err;
2263   dfltparm.ctx = agent_ctx;
2264
2265   if (desc)
2266     {
2267       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2268       err = assuan_transact (agent_ctx, line,
2269                              NULL, NULL, NULL, NULL, NULL, NULL);
2270       if (err)
2271         return err;
2272     }
2273
2274   snprintf (line, DIM(line)-1, "EXPORT_KEY --openpgp %s%s %s",
2275             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2276             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2277             hexkeygrip);
2278
2279   init_membuf_secure (&data, 1024);
2280   cn_parm.cache_nonce_addr = cache_nonce_addr;
2281   cn_parm.passwd_nonce_addr = NULL;
2282   err = assuan_transact (agent_ctx, line,
2283                          membuf_data_cb, &data,
2284                          default_inq_cb, &dfltparm,
2285                          cache_nonce_status_cb, &cn_parm);
2286   if (err)
2287     {
2288       xfree (get_membuf (&data, &len));
2289       return err;
2290     }
2291   buf = get_membuf (&data, &len);
2292   if (!buf)
2293     return gpg_error_from_syserror ();
2294   *r_result = buf;
2295   *r_resultlen = len;
2296   return 0;
2297 }
2298
2299
2300 \f
2301 /* Ask the agent to delete the key identified by HEXKEYGRIP.  If DESC
2302    is not NULL, display DESC instead of the default description
2303    message.  */
2304 gpg_error_t
2305 agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc)
2306 {
2307   gpg_error_t err;
2308   char line[ASSUAN_LINELENGTH];
2309   struct default_inq_parm_s dfltparm;
2310
2311   memset (&dfltparm, 0, sizeof dfltparm);
2312   dfltparm.ctrl = ctrl;
2313
2314   err = start_agent (ctrl, 0);
2315   if (err)
2316     return err;
2317
2318   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2319     return gpg_error (GPG_ERR_INV_VALUE);
2320
2321   if (desc)
2322     {
2323       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2324       err = assuan_transact (agent_ctx, line,
2325                              NULL, NULL, NULL, NULL, NULL, NULL);
2326       if (err)
2327         return err;
2328     }
2329
2330   snprintf (line, DIM(line)-1, "DELETE_KEY %s", hexkeygrip);
2331   err = assuan_transact (agent_ctx, line, NULL, NULL,
2332                          default_inq_cb, &dfltparm,
2333                          NULL, NULL);
2334   return err;
2335 }
2336
2337
2338 \f
2339 /* Ask the agent to change the passphrase of the key identified by
2340    HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2341    default description message.  If CACHE_NONCE_ADDR is not NULL the
2342    agent is advised to first try a passphrase associated with that
2343    nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2344    the passphrase associated with that nonce.  */
2345 gpg_error_t
2346 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2347               char **cache_nonce_addr, char **passwd_nonce_addr)
2348 {
2349   gpg_error_t err;
2350   struct cache_nonce_parm_s cn_parm;
2351   char line[ASSUAN_LINELENGTH];
2352   struct default_inq_parm_s dfltparm;
2353
2354   memset (&dfltparm, 0, sizeof dfltparm);
2355   dfltparm.ctrl = ctrl;
2356
2357   err = start_agent (ctrl, 0);
2358   if (err)
2359     return err;
2360   dfltparm.ctx = agent_ctx;
2361
2362   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2363     return gpg_error (GPG_ERR_INV_VALUE);
2364
2365
2366   if (desc)
2367     {
2368       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2369       err = assuan_transact (agent_ctx, line,
2370                              NULL, NULL, NULL, NULL, NULL, NULL);
2371       if (err)
2372         return err;
2373     }
2374
2375   snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
2376             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2377             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2378             passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2379             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2380             hexkeygrip);
2381   cn_parm.cache_nonce_addr = cache_nonce_addr;
2382   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2383   err = assuan_transact (agent_ctx, line, NULL, NULL,
2384                          default_inq_cb, &dfltparm,
2385                          cache_nonce_status_cb, &cn_parm);
2386   return err;
2387 }
2388
2389 /* Return the version reported by gpg-agent.  */
2390 gpg_error_t
2391 agent_get_version (ctrl_t ctrl, char **r_version)
2392 {
2393   gpg_error_t err;
2394   membuf_t data;
2395
2396   err = start_agent (ctrl, 0);
2397   if (err)
2398     return err;
2399
2400   init_membuf (&data, 64);
2401   err = assuan_transact (agent_ctx, "GETINFO version",
2402                         membuf_data_cb, &data,
2403                         NULL, NULL, NULL, NULL);
2404   if (err)
2405     {
2406       xfree (get_membuf (&data, NULL));
2407       *r_version = NULL;
2408     }
2409   else
2410     {
2411       put_membuf (&data, "", 1);
2412       *r_version = get_membuf (&data, NULL);
2413       if (!*r_version)
2414         err = gpg_error_from_syserror ();
2415     }
2416   return err;
2417 }