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