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