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