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