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