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