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