Fix usage of SHA-2 algorithm with OpenPGP cards.
[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
918 \f
919 /* Send a READCERT command to the SCdaemon. */
920 int
921 agent_scd_readcert (const char *certidstr,
922                     void **r_buf, size_t *r_buflen)
923 {
924   int rc;
925   char line[ASSUAN_LINELENGTH];
926   membuf_t data;
927   size_t len;
928
929   *r_buf = NULL;
930   rc = start_agent (NULL, 1);
931   if (rc)
932     return rc;
933
934   init_membuf (&data, 2048);
935
936   snprintf (line, DIM(line)-1, "SCD READCERT %s", certidstr);
937   line[DIM(line)-1] = 0;
938   rc = assuan_transact (agent_ctx, line,
939                         membuf_data_cb, &data,
940                         default_inq_cb, NULL, NULL, NULL);
941   if (rc)
942     {
943       xfree (get_membuf (&data, &len));
944       return rc;
945     }
946   *r_buf = get_membuf (&data, r_buflen);
947   if (!*r_buf)
948     return gpg_error (GPG_ERR_ENOMEM);
949
950   return 0;
951 }
952
953
954 \f
955 /* Change the PIN of an OpenPGP card or reset the retry counter.
956    CHVNO 1: Change the PIN
957          2: For v1 cards: Same as 1.
958             For v2 cards: Reset the PIN using the Reset Code.
959          3: Change the admin PIN
960        101: Set a new PIN and reset the retry counter
961        102: For v1 cars: Same as 101.
962             For v2 cards: Set a new Reset Code.
963    SERIALNO is not used.
964  */
965 int
966 agent_scd_change_pin (int chvno, const char *serialno)
967 {
968   int rc;
969   char line[ASSUAN_LINELENGTH];
970   const char *reset = "";
971
972   (void)serialno;
973
974   if (chvno >= 100)
975     reset = "--reset";
976   chvno %= 100;
977
978   rc = start_agent (NULL, 1);
979   if (rc)
980     return rc;
981
982   snprintf (line, DIM(line)-1, "SCD PASSWD %s %d", reset, chvno);
983   line[DIM(line)-1] = 0;
984   rc = assuan_transact (agent_ctx, line, NULL, NULL,
985                         default_inq_cb, NULL, NULL, NULL);
986   status_sc_op_failure (rc);
987   return rc;
988 }
989
990
991 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
992    number of the card - optionally followed by the fingerprint;
993    however the fingerprint is ignored here. */
994 int
995 agent_scd_checkpin  (const char *serialno)
996 {
997   int rc;
998   char line[ASSUAN_LINELENGTH];
999
1000   rc = start_agent (NULL, 1);
1001   if (rc)
1002     return rc;
1003
1004   snprintf (line, DIM(line)-1, "SCD CHECKPIN %s", serialno);
1005   line[DIM(line)-1] = 0;
1006   rc = assuan_transact (agent_ctx, line,
1007                         NULL, NULL,
1008                         default_inq_cb, NULL, NULL, NULL);
1009   status_sc_op_failure (rc);
1010   return rc;
1011 }
1012
1013
1014 /* Dummy function, only used by the gpg 1.4 implementation. */
1015 void
1016 agent_clear_pin_cache (const char *sn)
1017 {
1018   (void)sn;
1019 }
1020
1021
1022
1023 \f
1024 /* Note: All strings shall be UTF-8. On success the caller needs to
1025    free the string stored at R_PASSPHRASE. On error NULL will be
1026    stored at R_PASSPHRASE and an appropriate fpf error code
1027    returned. */
1028 gpg_error_t
1029 agent_get_passphrase (const char *cache_id,
1030                       const char *err_msg,
1031                       const char *prompt,
1032                       const char *desc_msg,
1033                       int repeat,
1034                       int check,
1035                       char **r_passphrase)
1036 {
1037   int rc;
1038   char line[ASSUAN_LINELENGTH];
1039   char *arg1 = NULL;
1040   char *arg2 = NULL;
1041   char *arg3 = NULL;
1042   char *arg4 = NULL;
1043   membuf_t data;
1044
1045   *r_passphrase = NULL;
1046
1047   rc = start_agent (NULL, 0);
1048   if (rc)
1049     return rc;
1050
1051   /* Check that the gpg-agent understands the repeat option.  */
1052   if (assuan_transact (agent_ctx,
1053                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1054                        NULL, NULL, NULL, NULL, NULL, NULL))
1055     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1056
1057   if (cache_id && *cache_id)
1058     if (!(arg1 = percent_plus_escape (cache_id)))
1059       goto no_mem;
1060   if (err_msg && *err_msg)
1061     if (!(arg2 = percent_plus_escape (err_msg)))
1062       goto no_mem;
1063   if (prompt && *prompt)
1064     if (!(arg3 = percent_plus_escape (prompt)))
1065       goto no_mem;
1066   if (desc_msg && *desc_msg)
1067     if (!(arg4 = percent_plus_escape (desc_msg)))
1068       goto no_mem;
1069
1070   snprintf (line, DIM(line)-1,
1071             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1072             repeat,
1073             check? " --check --qualitybar":"",
1074             arg1? arg1:"X",
1075             arg2? arg2:"X",
1076             arg3? arg3:"X",
1077             arg4? arg4:"X");
1078   line[DIM(line)-1] = 0;
1079   xfree (arg1);
1080   xfree (arg2);
1081   xfree (arg3);
1082   xfree (arg4);
1083
1084   init_membuf_secure (&data, 64);
1085   rc = assuan_transact (agent_ctx, line,
1086                         membuf_data_cb, &data,
1087                         default_inq_cb, NULL, NULL, NULL);
1088
1089   if (rc)
1090     xfree (get_membuf (&data, NULL));
1091   else
1092     {
1093       put_membuf (&data, "", 1);
1094       *r_passphrase = get_membuf (&data, NULL);
1095       if (!*r_passphrase)
1096         rc = gpg_error_from_syserror ();
1097     }
1098   return rc;
1099  no_mem:
1100   rc = gpg_error_from_syserror ();
1101   xfree (arg1);
1102   xfree (arg2);
1103   xfree (arg3);
1104   xfree (arg4);
1105   return rc;
1106 }
1107
1108
1109 gpg_error_t
1110 agent_clear_passphrase (const char *cache_id)
1111 {
1112   int rc;
1113   char line[ASSUAN_LINELENGTH];
1114
1115   if (!cache_id || !*cache_id)
1116     return 0;
1117
1118   rc = start_agent (NULL, 0);
1119   if (rc)
1120     return rc;
1121
1122   snprintf (line, DIM(line)-1, "CLEAR_PASSPHRASE %s", cache_id);
1123   line[DIM(line)-1] = 0;
1124   return assuan_transact (agent_ctx, line, NULL, NULL,
1125                           default_inq_cb, NULL, NULL, NULL);
1126 }
1127
1128
1129 /* Ask the agent to pop up a confirmation dialog with the text DESC
1130    and an okay and cancel button. */
1131 gpg_error_t
1132 gpg_agent_get_confirmation (const char *desc)
1133 {
1134   int rc;
1135   char *tmp;
1136   char line[ASSUAN_LINELENGTH];
1137
1138   rc = start_agent (NULL, 0);
1139   if (rc)
1140     return rc;
1141
1142   tmp = percent_plus_escape (desc);
1143   if (!tmp)
1144     return gpg_error_from_syserror ();
1145   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", tmp);
1146   line[DIM(line)-1] = 0;
1147   xfree (tmp);
1148
1149   rc = assuan_transact (agent_ctx, line, NULL, NULL,
1150                         default_inq_cb, NULL, NULL, NULL);
1151   return rc;
1152 }
1153
1154
1155 /* Return the S2K iteration count as computed by gpg-agent.  */
1156 gpg_error_t
1157 agent_get_s2k_count (unsigned long *r_count)
1158 {
1159   gpg_error_t err;
1160   membuf_t data;
1161   char *buf;
1162
1163   *r_count = 0;
1164
1165   err = start_agent (NULL, 0);
1166   if (err)
1167     return err;
1168
1169   init_membuf (&data, 32);
1170   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1171                         membuf_data_cb, &data,
1172                         NULL, NULL, NULL, NULL);
1173   if (err)
1174     xfree (get_membuf (&data, NULL));
1175   else
1176     {
1177       put_membuf (&data, "", 1);
1178       buf = get_membuf (&data, NULL);
1179       if (!buf)
1180         err = gpg_error_from_syserror ();
1181       else
1182         {
1183           *r_count = strtoul (buf, NULL, 10);
1184           xfree (buf);
1185         }
1186     }
1187   return err;
1188 }
1189
1190
1191 \f
1192 /* Ask the agent whether a secret key for the given public key is
1193    available.  Returns 0 if available.  */
1194 gpg_error_t
1195 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1196 {
1197   gpg_error_t err;
1198   char line[ASSUAN_LINELENGTH];
1199   char *hexgrip;
1200
1201   err = start_agent (ctrl, 0);
1202   if (err)
1203     return err;
1204
1205   err = hexkeygrip_from_pk (pk, &hexgrip);
1206   if (err)
1207     return err;
1208
1209   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1210   xfree (hexgrip);
1211
1212   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1213   return err;
1214 }
1215
1216 /* Ask the agent whether a secret key is availabale for any of the
1217    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1218 gpg_error_t
1219 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1220 {
1221   gpg_error_t err;
1222   char line[ASSUAN_LINELENGTH];
1223   char *p;
1224   kbnode_t kbctx, node;
1225   int nkeys;
1226   unsigned char grip[20];
1227
1228   err = start_agent (ctrl, 0);
1229   if (err)
1230     return err;
1231
1232   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1233                                           found in KEYBLOCK.  */
1234   p = stpcpy (line, "HAVEKEY");
1235   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1236     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1237         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1238         || node->pkt->pkttype == PKT_SECRET_KEY
1239         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1240       {
1241         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1242           {
1243             err = assuan_transact (agent_ctx, line,
1244                                    NULL, NULL, NULL, NULL, NULL, NULL);
1245             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1246               break; /* Seckey available or unexpected error - ready.  */
1247             p = stpcpy (line, "HAVEKEY");
1248             nkeys = 0;
1249           }
1250
1251         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1252         if (err)
1253           return err;
1254         *p++ = ' ';
1255         bin2hex (grip, 20, p);
1256         p += 40;
1257         nkeys++;
1258       }
1259
1260   if (!err && nkeys)
1261     err = assuan_transact (agent_ctx, line,
1262                            NULL, NULL, NULL, NULL, NULL, NULL);
1263
1264   return err;
1265 }
1266
1267
1268 \f
1269 static gpg_error_t
1270 keyinfo_status_cb (void *opaque, const char *line)
1271 {
1272   char **serialno = opaque;
1273   const char *s, *s2;
1274
1275   if (!strncmp (line, "KEYINFO ", 8) && !*serialno)
1276     {
1277       s = strchr (line+8, ' ');
1278       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1279         {
1280           s += 3;
1281           s2 = strchr (s, ' ');
1282           if ( s2 > s )
1283             {
1284               *serialno = xtrymalloc ((s2 - s)+1);
1285               if (*serialno)
1286                 {
1287                   memcpy (*serialno, s, s2 - s);
1288                   (*serialno)[s2 - s] = 0;
1289                 }
1290             }
1291         }
1292     }
1293   return 0;
1294 }
1295
1296
1297 /* Return the serial number for a secret key.  If the returned serial
1298    number is NULL, the key is not stored on a smartcard.  Caller needs
1299    to free R_SERIALNO.  */
1300 gpg_error_t
1301 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1302 {
1303   gpg_error_t err;
1304   char line[ASSUAN_LINELENGTH];
1305   char *serialno = NULL;
1306
1307   *r_serialno = NULL;
1308
1309   err = start_agent (ctrl, 0);
1310   if (err)
1311     return err;
1312
1313   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1314     return gpg_error (GPG_ERR_INV_VALUE);
1315
1316   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1317   line[DIM(line)-1] = 0;
1318
1319   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1320                          keyinfo_status_cb, &serialno);
1321   if (!err && serialno)
1322     {
1323       /* Sanity check for bad characters.  */
1324       if (strpbrk (serialno, ":\n\r"))
1325         err = GPG_ERR_INV_VALUE;
1326     }
1327   if (err)
1328     xfree (serialno);
1329   else
1330     *r_serialno = serialno;
1331   return err;
1332 }
1333
1334 \f
1335 /* Status callback for agent_import_key, agent_export_key and
1336    agent_genkey.  */
1337 static gpg_error_t
1338 cache_nonce_status_cb (void *opaque, const char *line)
1339 {
1340   struct cache_nonce_parm_s *parm = opaque;
1341   const char *keyword = line;
1342   int keywordlen;
1343
1344   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1345     ;
1346   while (spacep (line))
1347     line++;
1348
1349   if (keywordlen == 11 && !memcmp (keyword, "CACHE_NONCE", keywordlen))
1350     {
1351       if (parm->cache_nonce_addr)
1352         {
1353           xfree (*parm->cache_nonce_addr);
1354           *parm->cache_nonce_addr = xtrystrdup (line);
1355         }
1356     }
1357   else if (keywordlen == 12 && !memcmp (keyword, "PASSWD_NONCE", keywordlen))
1358     {
1359       if (parm->passwd_nonce_addr)
1360         {
1361           xfree (*parm->passwd_nonce_addr);
1362           *parm->passwd_nonce_addr = xtrystrdup (line);
1363         }
1364     }
1365
1366   return 0;
1367 }
1368
1369
1370 \f
1371 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1372    assuan_transact takes care of flushing and writing the end */
1373 static gpg_error_t
1374 inq_genkey_parms (void *opaque, const char *line)
1375 {
1376   struct genkey_parm_s *parm = opaque;
1377   gpg_error_t err;
1378
1379   if (!strncmp (line, "KEYPARAM", 8) && (line[8]==' '||!line[8]))
1380     {
1381       err = assuan_send_data (parm->ctx,
1382                               parm->keyparms, strlen (parm->keyparms));
1383     }
1384   else
1385     err = default_inq_cb (parm->ctrl, line);
1386
1387   return err;
1388 }
1389
1390
1391 /* Call the agent to generate a new key.  KEYPARMS is the usual
1392    S-expression giving the parameters of the key.  gpg-agent passes it
1393    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1394    to protect the generated key. */
1395 gpg_error_t
1396 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr,
1397               const char *keyparms, int no_protection, gcry_sexp_t *r_pubkey)
1398 {
1399   gpg_error_t err;
1400   struct genkey_parm_s gk_parm;
1401   struct cache_nonce_parm_s cn_parm;
1402   membuf_t data;
1403   size_t len;
1404   unsigned char *buf;
1405   char line[ASSUAN_LINELENGTH];
1406
1407   *r_pubkey = NULL;
1408   err = start_agent (ctrl, 0);
1409   if (err)
1410     return err;
1411
1412   err = assuan_transact (agent_ctx, "RESET",
1413                          NULL, NULL, NULL, NULL, NULL, NULL);
1414   if (err)
1415     return err;
1416
1417   init_membuf (&data, 1024);
1418   gk_parm.ctrl     = ctrl;
1419   gk_parm.ctx      = agent_ctx;
1420   gk_parm.keyparms = keyparms;
1421   snprintf (line, sizeof line, "GENKEY%s%s%s",
1422             no_protection? " --no-protection":"",
1423             cache_nonce_addr && *cache_nonce_addr? " ":"",
1424             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1425   cn_parm.cache_nonce_addr = cache_nonce_addr;
1426   cn_parm.passwd_nonce_addr = NULL;
1427   err = assuan_transact (agent_ctx, line,
1428                          membuf_data_cb, &data,
1429                          inq_genkey_parms, &gk_parm,
1430                          cache_nonce_status_cb, &cn_parm);
1431   if (err)
1432     {
1433       xfree (get_membuf (&data, &len));
1434       return err;
1435     }
1436
1437   buf = get_membuf (&data, &len);
1438   if (!buf)
1439     err = gpg_error_from_syserror ();
1440   else
1441     {
1442       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1443       xfree (buf);
1444     }
1445   return err;
1446 }
1447
1448
1449
1450 \f
1451 /* FIXME: Call the agent to read the public key part for a given keygrip.  If
1452    FROMCARD is true, the key is directly read from the current
1453    smartcard. In this case HEXKEYGRIP should be the keyID
1454    (e.g. OPENPGP.3). */
1455 /* int */
1456 /* agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip, */
1457 /*                ksba_sexp_t *r_pubkey) */
1458 /* { */
1459 /*   int rc; */
1460 /*   membuf_t data; */
1461 /*   size_t len; */
1462 /*   unsigned char *buf; */
1463 /*   char line[ASSUAN_LINELENGTH]; */
1464
1465 /*   *r_pubkey = NULL; */
1466 /*   rc = start_agent (ctrl); */
1467 /*   if (rc) */
1468 /*     return rc; */
1469
1470 /*   rc = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL); */
1471 /*   if (rc) */
1472 /*     return rc; */
1473
1474 /*   snprintf (line, DIM(line)-1, "%sREADKEY %s", */
1475 /*             fromcard? "SCD ":"", hexkeygrip); */
1476 /*   line[DIM(line)-1] = 0; */
1477
1478 /*   init_membuf (&data, 1024); */
1479 /*   rc = assuan_transact (agent_ctx, line, */
1480 /*                         membuf_data_cb, &data,  */
1481 /*                         default_inq_cb, ctrl, NULL, NULL); */
1482 /*   if (rc) */
1483 /*     { */
1484 /*       xfree (get_membuf (&data, &len)); */
1485 /*       return rc; */
1486 /*     } */
1487 /*   buf = get_membuf (&data, &len); */
1488 /*   if (!buf) */
1489 /*     return gpg_error (GPG_ERR_ENOMEM); */
1490 /*   if (!gcry_sexp_canon_len (buf, len, NULL, NULL)) */
1491 /*     { */
1492 /*       xfree (buf); */
1493 /*       return gpg_error (GPG_ERR_INV_SEXP); */
1494 /*     } */
1495 /*   *r_pubkey = buf; */
1496 /*   return 0; */
1497 /* } */
1498
1499
1500 \f
1501 /* Call the agent to do a sign operation using the key identified by
1502    the hex string KEYGRIP.  DESC is a description of the key to be
1503    displayed if the agent needs to ask for the PIN.  DIGEST and
1504    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1505    used to compute the digest.  If CACHE_NONCE is used the agent is
1506    advised to first try a passphrase associated with that nonce. */
1507 gpg_error_t
1508 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1509               const char *keygrip, const char *desc,
1510               unsigned char *digest, size_t digestlen, int digestalgo,
1511               gcry_sexp_t *r_sigval)
1512 {
1513   gpg_error_t err;
1514   char line[ASSUAN_LINELENGTH];
1515   membuf_t data;
1516
1517   *r_sigval = NULL;
1518   err = start_agent (ctrl, 0);
1519   if (err)
1520     return err;
1521
1522   if (digestlen*2 + 50 > DIM(line))
1523     return gpg_error (GPG_ERR_GENERAL);
1524
1525   err = assuan_transact (agent_ctx, "RESET",
1526                          NULL, NULL, NULL, NULL, NULL, NULL);
1527   if (err)
1528     return err;
1529
1530   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1531   line[DIM(line)-1] = 0;
1532   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1533   if (err)
1534     return err;
1535
1536   if (desc)
1537     {
1538       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1539       line[DIM(line)-1] = 0;
1540       err = assuan_transact (agent_ctx, line,
1541                             NULL, NULL, NULL, NULL, NULL, NULL);
1542       if (err)
1543         return err;
1544     }
1545
1546   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1547   bin2hex (digest, digestlen, line + strlen (line));
1548   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1549   if (err)
1550     return err;
1551
1552   init_membuf (&data, 1024);
1553
1554   snprintf (line, sizeof line, "PKSIGN%s%s",
1555             cache_nonce? " -- ":"",
1556             cache_nonce? cache_nonce:"");
1557   err = assuan_transact (agent_ctx, line,
1558                         membuf_data_cb, &data, default_inq_cb, ctrl,
1559                         NULL, NULL);
1560   if (err)
1561     xfree (get_membuf (&data, NULL));
1562   else
1563     {
1564       unsigned char *buf;
1565       size_t len;
1566
1567       buf = get_membuf (&data, &len);
1568       if (!buf)
1569         err = gpg_error_from_syserror ();
1570       else
1571         {
1572           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1573           xfree (buf);
1574         }
1575     }
1576   return err;
1577 }
1578
1579
1580 \f
1581 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1582    assuan_transact takes care of flushing and writing the END. */
1583 static gpg_error_t
1584 inq_ciphertext_cb (void *opaque, const char *line)
1585 {
1586   struct cipher_parm_s *parm = opaque;
1587   int rc;
1588
1589   if (!strncmp (line, "CIPHERTEXT", 10) && (line[10]==' '||!line[10]))
1590     {
1591       assuan_begin_confidential (parm->ctx);
1592       rc = assuan_send_data (parm->ctx, parm->ciphertext, parm->ciphertextlen);
1593       assuan_end_confidential (parm->ctx);
1594     }
1595   else
1596     rc = default_inq_cb (parm->ctrl, line);
1597
1598   return rc;
1599 }
1600
1601
1602 /* Call the agent to do a decrypt operation using the key identified
1603    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
1604    success the decoded value is stored verbatim at R_BUF and its
1605    length at R_BUF; the callers needs to release it.  */
1606 gpg_error_t
1607 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
1608                  gcry_sexp_t s_ciphertext,
1609                  unsigned char **r_buf, size_t *r_buflen)
1610 {
1611   gpg_error_t err;
1612   char line[ASSUAN_LINELENGTH];
1613   membuf_t data;
1614   size_t n, len;
1615   char *p, *buf, *endp;
1616
1617   if (!keygrip || strlen(keygrip) != 40 || !s_ciphertext || !r_buf || !r_buflen)
1618     return gpg_error (GPG_ERR_INV_VALUE);
1619   *r_buf = NULL;
1620
1621   err = start_agent (ctrl, 0);
1622   if (err)
1623     return err;
1624
1625   err = assuan_transact (agent_ctx, "RESET",
1626                          NULL, NULL, NULL, NULL, NULL, NULL);
1627   if (err)
1628     return err;
1629
1630   snprintf (line, sizeof line, "SETKEY %s", keygrip);
1631   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1632   if (err)
1633     return err;
1634
1635   if (desc)
1636     {
1637       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1638       line[DIM(line)-1] = 0;
1639       err = assuan_transact (agent_ctx, line,
1640                             NULL, NULL, NULL, NULL, NULL, NULL);
1641       if (err)
1642         return err;
1643     }
1644
1645   init_membuf_secure (&data, 1024);
1646   {
1647     struct cipher_parm_s parm;
1648
1649     parm.ctrl = ctrl;
1650     parm.ctx = agent_ctx;
1651     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
1652     if (err)
1653       return err;
1654     err = assuan_transact (agent_ctx, "PKDECRYPT",
1655                            membuf_data_cb, &data,
1656                            inq_ciphertext_cb, &parm, NULL, NULL);
1657     xfree (parm.ciphertext);
1658   }
1659   if (err)
1660     {
1661       xfree (get_membuf (&data, &len));
1662       return err;
1663     }
1664
1665   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
1666   buf = get_membuf (&data, &len);
1667   if (!buf)
1668     return gpg_error_from_syserror ();
1669   assert (len); /* (we forced Nul termination.)  */
1670
1671   if (*buf != '(')
1672     {
1673       xfree (buf);
1674       return gpg_error (GPG_ERR_INV_SEXP);
1675     }
1676
1677   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
1678     {
1679       xfree (buf);
1680       return gpg_error (GPG_ERR_INV_SEXP);
1681     }
1682   len -= 11;   /* Count only the data of the second part. */
1683   p = buf + 8; /* Skip leading parenthesis and the value tag. */
1684
1685   n = strtoul (p, &endp, 10);
1686   if (!n || *endp != ':')
1687     {
1688       xfree (buf);
1689       return gpg_error (GPG_ERR_INV_SEXP);
1690     }
1691   endp++;
1692   if (endp-p+n > len)
1693     {
1694       xfree (buf);
1695       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
1696     }
1697
1698   memmove (buf, endp, n);
1699
1700   *r_buflen = n;
1701   *r_buf = buf;
1702   return 0;
1703 }
1704
1705
1706 \f
1707 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
1708    the key shall be used for export, with false for import.  On success
1709    the new key is stored at R_KEY and its length at R_KEKLEN.  */
1710 gpg_error_t
1711 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
1712 {
1713   gpg_error_t err;
1714   membuf_t data;
1715   size_t len;
1716   unsigned char *buf;
1717   char line[ASSUAN_LINELENGTH];
1718
1719   *r_kek = NULL;
1720   err = start_agent (ctrl, 0);
1721   if (err)
1722     return err;
1723
1724   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
1725             forexport? "--export":"--import");
1726
1727   init_membuf_secure (&data, 64);
1728   err = assuan_transact (agent_ctx, line,
1729                          membuf_data_cb, &data,
1730                          default_inq_cb, ctrl, NULL, NULL);
1731   if (err)
1732     {
1733       xfree (get_membuf (&data, &len));
1734       return err;
1735     }
1736   buf = get_membuf (&data, &len);
1737   if (!buf)
1738     return gpg_error_from_syserror ();
1739   *r_kek = buf;
1740   *r_keklen = len;
1741   return 0;
1742 }
1743
1744
1745 \f
1746 /* Handle the inquiry for an IMPORT_KEY command.  */
1747 static gpg_error_t
1748 inq_import_key_parms (void *opaque, const char *line)
1749 {
1750   struct import_key_parm_s *parm = opaque;
1751   gpg_error_t err;
1752
1753   if (!strncmp (line, "KEYDATA", 7) && (line[7]==' '||!line[7]))
1754     {
1755       err = assuan_send_data (parm->ctx, parm->key, parm->keylen);
1756     }
1757   else
1758     err = default_inq_cb (parm->ctrl, line);
1759
1760   return err;
1761 }
1762
1763
1764 /* Call the agent to import a key into the agent.  */
1765 gpg_error_t
1766 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
1767                   const void *key, size_t keylen)
1768 {
1769   gpg_error_t err;
1770   struct import_key_parm_s parm;
1771   struct cache_nonce_parm_s cn_parm;
1772   char line[ASSUAN_LINELENGTH];
1773
1774   err = start_agent (ctrl, 0);
1775   if (err)
1776     return err;
1777
1778   if (desc)
1779     {
1780       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1781       line[DIM(line)-1] = 0;
1782       err = assuan_transact (agent_ctx, line,
1783                             NULL, NULL, NULL, NULL, NULL, NULL);
1784       if (err)
1785         return err;
1786     }
1787
1788   parm.ctrl   = ctrl;
1789   parm.ctx    = agent_ctx;
1790   parm.key    = key;
1791   parm.keylen = keylen;
1792
1793   snprintf (line, sizeof line, "IMPORT_KEY%s%s",
1794             cache_nonce_addr && *cache_nonce_addr? " ":"",
1795             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1796   cn_parm.cache_nonce_addr = cache_nonce_addr;
1797   cn_parm.passwd_nonce_addr = NULL;
1798   err = assuan_transact (agent_ctx, line,
1799                          NULL, NULL, inq_import_key_parms, &parm,
1800                          cache_nonce_status_cb, &cn_parm);
1801   return err;
1802 }
1803
1804
1805 \f
1806 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
1807    keygrip, DESC a prompt to be displayed with the agent's passphrase
1808    question (needs to be plus+percent escaped).  On success the key is
1809    stored as a canonical S-expression at R_RESULT and R_RESULTLEN.  */
1810 gpg_error_t
1811 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
1812                   char **cache_nonce_addr,
1813                   unsigned char **r_result, size_t *r_resultlen)
1814 {
1815   gpg_error_t err;
1816   struct cache_nonce_parm_s cn_parm;
1817   membuf_t data;
1818   size_t len;
1819   unsigned char *buf;
1820   char line[ASSUAN_LINELENGTH];
1821
1822   *r_result = NULL;
1823
1824   err = start_agent (ctrl, 0);
1825   if (err)
1826     return err;
1827
1828   if (desc)
1829     {
1830       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1831       err = assuan_transact (agent_ctx, line,
1832                              NULL, NULL, NULL, NULL, NULL, NULL);
1833       if (err)
1834         return err;
1835     }
1836
1837   snprintf (line, DIM(line)-1, "EXPORT_KEY --openpgp %s%s %s",
1838             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
1839             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
1840             hexkeygrip);
1841
1842   init_membuf_secure (&data, 1024);
1843   cn_parm.cache_nonce_addr = cache_nonce_addr;
1844   cn_parm.passwd_nonce_addr = NULL;
1845   err = assuan_transact (agent_ctx, line,
1846                          membuf_data_cb, &data,
1847                          default_inq_cb, ctrl,
1848                          cache_nonce_status_cb, &cn_parm);
1849   if (err)
1850     {
1851       xfree (get_membuf (&data, &len));
1852       return err;
1853     }
1854   buf = get_membuf (&data, &len);
1855   if (!buf)
1856     return gpg_error_from_syserror ();
1857   *r_result = buf;
1858   *r_resultlen = len;
1859   return 0;
1860 }
1861
1862
1863 \f
1864 /* Ask the agent to change the passphrase of the key identified by
1865    HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
1866    default description message.  If CACHE_NONCE_ADDR is not NULL the
1867    agent is advised to first try a passphrase associated with that
1868    nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
1869    the passphrase associated with that nonce.  */
1870 gpg_error_t
1871 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
1872               char **cache_nonce_addr, char **passwd_nonce_addr)
1873 {
1874   gpg_error_t err;
1875   struct cache_nonce_parm_s cn_parm;
1876   char line[ASSUAN_LINELENGTH];
1877
1878   err = start_agent (ctrl, 0);
1879   if (err)
1880     return err;
1881
1882   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1883     return gpg_error (GPG_ERR_INV_VALUE);
1884
1885   if (desc)
1886     {
1887       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1888       err = assuan_transact (agent_ctx, line,
1889                              NULL, NULL, NULL, NULL, NULL, NULL);
1890       if (err)
1891         return err;
1892     }
1893
1894   snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
1895             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
1896             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
1897             passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
1898             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
1899             hexkeygrip);
1900   cn_parm.cache_nonce_addr = cache_nonce_addr;
1901   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
1902   err = assuan_transact (agent_ctx, line, NULL, NULL,
1903                          default_inq_cb, ctrl,
1904                          cache_nonce_status_cb, &cn_parm);
1905   return err;
1906 }