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