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