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