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