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