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