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