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