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