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