gpg: fix keytocard and support ECC card for key attribute.
[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   struct default_inq_parm_s parm;
610
611   memset (&parm, 0, sizeof parm);
612   parm.ctx = agent_ctx;
613
614   snprintf (line, DIM(line)-1, "KEYTOCARD %s%s %s OPENPGP.%d %s",
615             force?"--force ": "", hexgrip, serialno, keyno, timestamp);
616   line[DIM(line)-1] = 0;
617
618   rc = start_agent (NULL, 1);
619   if (rc)
620     return rc;
621
622   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
623                         NULL, NULL);
624   if (rc)
625     return rc;
626
627   return rc;
628 }
629 \f
630 /* Call the agent to retrieve a data object.  This function returns
631    the data in the same structure as used by the learn command.  It is
632    allowed to update such a structure using this commmand. */
633 int
634 agent_scd_getattr (const char *name, struct agent_card_info_s *info)
635 {
636   int rc;
637   char line[ASSUAN_LINELENGTH];
638   struct default_inq_parm_s parm;
639
640   memset (&parm, 0, sizeof parm);
641
642   if (!*name)
643     return gpg_error (GPG_ERR_INV_VALUE);
644
645   /* We assume that NAME does not need escaping. */
646   if (12 + strlen (name) > DIM(line)-1)
647     return gpg_error (GPG_ERR_TOO_LARGE);
648   stpcpy (stpcpy (line, "SCD GETATTR "), name);
649
650   rc = start_agent (NULL, 1);
651   if (rc)
652     return rc;
653
654   parm.ctx = agent_ctx;
655   rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
656                         learn_status_cb, info);
657
658   return rc;
659 }
660
661 \f
662 /* Send an setattr command to the SCdaemon.  SERIALNO is not actually
663    used here but required by gpg 1.4's implementation of this code in
664    cardglue.c. */
665 int
666 agent_scd_setattr (const char *name,
667                    const unsigned char *value, size_t valuelen,
668                    const char *serialno)
669 {
670   int rc;
671   char line[ASSUAN_LINELENGTH];
672   char *p;
673   struct default_inq_parm_s parm;
674
675   memset (&parm, 0, sizeof parm);
676
677   (void)serialno;
678
679   if (!*name || !valuelen)
680     return gpg_error (GPG_ERR_INV_VALUE);
681
682   /* We assume that NAME does not need escaping. */
683   if (12 + strlen (name) > DIM(line)-1)
684     return gpg_error (GPG_ERR_TOO_LARGE);
685
686   p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
687   *p++ = ' ';
688   for (; valuelen; value++, valuelen--)
689     {
690       if (p >= line + DIM(line)-5 )
691         return gpg_error (GPG_ERR_TOO_LARGE);
692       if (*value < ' ' || *value == '+' || *value == '%')
693         {
694           sprintf (p, "%%%02X", *value);
695           p += 3;
696         }
697       else if (*value == ' ')
698         *p++ = '+';
699       else
700         *p++ = *value;
701     }
702   *p = 0;
703
704   rc = start_agent (NULL, 1);
705   if (!rc)
706     {
707       parm.ctx = agent_ctx;
708       rc = assuan_transact (agent_ctx, line, NULL, NULL,
709                             default_inq_cb, &parm, NULL, NULL);
710     }
711
712   status_sc_op_failure (rc);
713   return rc;
714 }
715
716
717 \f
718 /* Handle a CERTDATA inquiry.  Note, we only send the data,
719    assuan_transact takes care of flushing and writing the END
720    command. */
721 static gpg_error_t
722 inq_writecert_parms (void *opaque, const char *line)
723 {
724   int rc;
725   struct writecert_parm_s *parm = opaque;
726
727   if (!strncmp (line, "CERTDATA", 8) && (line[8]==' '||!line[8]))
728     {
729       rc = assuan_send_data (parm->dflt->ctx,
730                              parm->certdata, parm->certdatalen);
731     }
732   else
733     rc = default_inq_cb (parm->dflt, line);
734
735   return rc;
736 }
737
738
739 /* Send a WRITECERT command to the SCdaemon. */
740 int
741 agent_scd_writecert (const char *certidstr,
742                      const unsigned char *certdata, size_t certdatalen)
743 {
744   int rc;
745   char line[ASSUAN_LINELENGTH];
746   struct writecert_parm_s parms;
747   struct default_inq_parm_s dfltparm;
748
749   memset (&dfltparm, 0, sizeof dfltparm);
750
751   rc = start_agent (NULL, 1);
752   if (rc)
753     return rc;
754
755   memset (&parms, 0, sizeof parms);
756
757   snprintf (line, DIM(line)-1, "SCD WRITECERT %s", certidstr);
758   line[DIM(line)-1] = 0;
759   dfltparm.ctx = agent_ctx;
760   parms.dflt = &dfltparm;
761   parms.certdata = certdata;
762   parms.certdatalen = certdatalen;
763
764   rc = assuan_transact (agent_ctx, line, NULL, NULL,
765                         inq_writecert_parms, &parms, NULL, NULL);
766
767   return rc;
768 }
769
770
771 \f
772 /* Handle a KEYDATA inquiry.  Note, we only send the data,
773    assuan_transact takes care of flushing and writing the end */
774 static gpg_error_t
775 inq_writekey_parms (void *opaque, const char *line)
776 {
777   int rc;
778   struct writekey_parm_s *parm = opaque;
779
780   if (!strncmp (line, "KEYDATA", 7) && (line[7]==' '||!line[7]))
781     {
782       rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
783     }
784   else
785     rc = default_inq_cb (parm->dflt, line);
786
787   return rc;
788 }
789
790
791 /* Send a WRITEKEY command to the SCdaemon. */
792 int
793 agent_scd_writekey (int keyno, const char *serialno,
794                     const unsigned char *keydata, size_t keydatalen)
795 {
796   int rc;
797   char line[ASSUAN_LINELENGTH];
798   struct writekey_parm_s parms;
799   struct default_inq_parm_s dfltparm;
800
801   memset (&dfltparm, 0, sizeof dfltparm);
802
803   (void)serialno;
804
805   rc = start_agent (NULL, 1);
806   if (rc)
807     return rc;
808
809   memset (&parms, 0, sizeof parms);
810
811   snprintf (line, DIM(line)-1, "SCD WRITEKEY --force OPENPGP.%d", keyno);
812   line[DIM(line)-1] = 0;
813   dfltparm.ctx = agent_ctx;
814   parms.dflt = &dfltparm;
815   parms.keydata = keydata;
816   parms.keydatalen = keydatalen;
817
818   rc = assuan_transact (agent_ctx, line, NULL, NULL,
819                         inq_writekey_parms, &parms, NULL, NULL);
820
821   status_sc_op_failure (rc);
822   return rc;
823 }
824
825
826 \f
827 static gpg_error_t
828 scd_genkey_cb_append_savedbytes (struct scd_genkey_parm_s *parm,
829                                  const char *line)
830 {
831   gpg_error_t err = 0;
832   char *p;
833
834   if (!parm->savedbytes)
835     {
836       parm->savedbytes = xtrystrdup (line);
837       if (!parm->savedbytes)
838         err = gpg_error_from_syserror ();
839     }
840   else
841     {
842       p = xtrymalloc (strlen (parm->savedbytes) + strlen (line) + 1);
843       if (!p)
844         err = gpg_error_from_syserror ();
845       else
846         {
847           strcpy (stpcpy (p, parm->savedbytes), line);
848           xfree (parm->savedbytes);
849           parm->savedbytes = p;
850         }
851     }
852
853   return err;
854 }
855
856 /* Status callback for the SCD GENKEY command. */
857 static gpg_error_t
858 scd_genkey_cb (void *opaque, const char *line)
859 {
860   struct scd_genkey_parm_s *parm = opaque;
861   const char *keyword = line;
862   int keywordlen;
863   gpg_error_t rc = 0;
864
865   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
866     ;
867   while (spacep (line))
868     line++;
869
870   if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
871     {
872       parm->cgk->fprvalid = unhexify_fpr (line, parm->cgk->fpr);
873     }
874   else if (keywordlen == 8 && !memcmp (keyword, "KEY-DATA", keywordlen))
875     {
876       gcry_mpi_t a;
877       const char *name = line;
878
879       while (*line && !spacep (line))
880         line++;
881       while (spacep (line))
882         line++;
883
884       if (*name == '-' && spacep (name+1))
885         rc = scd_genkey_cb_append_savedbytes (parm, line);
886       else
887         {
888           if (parm->savedbytes)
889             {
890               rc = scd_genkey_cb_append_savedbytes (parm, line);
891               if (!rc)
892                 rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX,
893                                     parm->savedbytes, 0, NULL);
894             }
895           else
896             rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, line, 0, NULL);
897           if (rc)
898             log_error ("error parsing received key data: %s\n",
899                        gpg_strerror (rc));
900           else if (*name == 'n' && spacep (name+1))
901             parm->cgk->n = a;
902           else if (*name == 'e' && spacep (name+1))
903             parm->cgk->e = a;
904           else
905             {
906               log_info ("unknown parameter name in received key data\n");
907               gcry_mpi_release (a);
908               rc = gpg_error (GPG_ERR_INV_PARAMETER);
909             }
910
911           xfree (parm->savedbytes);
912           parm->savedbytes = NULL;
913         }
914     }
915   else if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
916     {
917       parm->cgk->created_at = (u32)strtoul (line, NULL, 10);
918     }
919   else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
920     {
921       write_status_text (STATUS_PROGRESS, line);
922     }
923
924   return rc;
925 }
926
927 /* Send a GENKEY command to the SCdaemon.  SERIALNO is not used in
928    this implementation.  If CREATEDATE is not 0, it will be passed to
929    SCDAEMON so that the key is created with this timestamp.  INFO will
930    receive information about the generated key.  */
931 int
932 agent_scd_genkey (struct agent_card_genkey_s *info, int keyno, int force,
933                   const char *serialno, u32 createtime)
934 {
935   int rc;
936   char line[ASSUAN_LINELENGTH];
937   gnupg_isotime_t tbuf;
938   struct scd_genkey_parm_s parms;
939   struct default_inq_parm_s dfltparm;
940
941   memset (&dfltparm, 0, sizeof dfltparm);
942
943   (void)serialno;
944
945   memset (&parms, 0, sizeof parms);
946   parms.cgk = info;
947
948   rc = start_agent (NULL, 1);
949   if (rc)
950     return rc;
951
952   if (createtime)
953     epoch2isotime (tbuf, createtime);
954   else
955     *tbuf = 0;
956
957   snprintf (line, DIM(line)-1, "SCD GENKEY %s%s %s %d",
958             *tbuf? "--timestamp=":"", tbuf,
959             force? "--force":"",
960             keyno);
961   line[DIM(line)-1] = 0;
962
963   dfltparm.ctx = agent_ctx;
964   memset (info, 0, sizeof *info);
965   rc = assuan_transact (agent_ctx, line,
966                         NULL, NULL, default_inq_cb, &dfltparm,
967                         scd_genkey_cb, &parms);
968
969   xfree (parms.savedbytes);
970
971   status_sc_op_failure (rc);
972   return rc;
973 }
974
975
976
977 \f
978 /* Issue an SCD SERIALNO openpgp command and if SERIALNO is not NULL
979    ask the user to insert the requested card.  */
980 gpg_error_t
981 select_openpgp (const char *serialno)
982 {
983   gpg_error_t err;
984
985   /* Send the serialno command to initialize the connection.  Without
986      a given S/N we don't care about the data returned.  If the card
987      has already been initialized, this is a very fast command.  We
988      request the openpgp card because that is what we expect.
989
990      Note that an opt.limit_card_insert_tries of 1 means: No tries at
991      all whereas 0 means do not limit the number of tries.  Due to the
992      sue of a pinentry prompt with a cancel option we use it here in a
993      boolean sense.  */
994   if (!serialno || opt.limit_card_insert_tries == 1)
995     err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
996                            NULL, NULL, NULL, NULL, NULL, NULL);
997   else
998     {
999       char *this_sn = NULL;
1000       char *desc;
1001       int ask;
1002       char *want_sn;
1003       char *p;
1004
1005       want_sn = xtrystrdup (serialno);
1006       if (!want_sn)
1007         return gpg_error_from_syserror ();
1008       p = strchr (want_sn, '/');
1009       if (p)
1010         *p = 0;
1011
1012       do
1013         {
1014           ask = 0;
1015           err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
1016                                  NULL, NULL, NULL, NULL,
1017                                  get_serialno_cb, &this_sn);
1018           if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
1019             ask = 1;
1020           else if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
1021             ask = 2;
1022           else if (err)
1023             ;
1024           else if (this_sn)
1025             {
1026               if (strcmp (want_sn, this_sn))
1027                 ask = 2;
1028             }
1029
1030           xfree (this_sn);
1031           this_sn = NULL;
1032
1033           if (ask)
1034             {
1035               char *formatted = NULL;
1036               char *ocodeset = i18n_switchto_utf8 ();
1037
1038               if (!strncmp (want_sn, "D27600012401", 12)
1039                   && strlen (want_sn) == 32 )
1040                 formatted = xtryasprintf ("(%.4s) %.8s",
1041                                           want_sn + 16, want_sn + 20);
1042
1043               err = 0;
1044               desc = xtryasprintf
1045                 ("%s:\n\n"
1046                  "  \"%s\"",
1047                  ask == 1
1048                  ? _("Please insert the card with serial number")
1049                  : _("Please remove the current card and "
1050                      "insert the one with serial number"),
1051                  formatted? formatted : want_sn);
1052               if (!desc)
1053                 err = gpg_error_from_syserror ();
1054               xfree (formatted);
1055               i18n_switchback (ocodeset);
1056               if (!err)
1057                 err = gpg_agent_get_confirmation (desc);
1058               xfree (desc);
1059             }
1060         }
1061       while (ask && !err);
1062       xfree (want_sn);
1063     }
1064
1065   return err;
1066 }
1067
1068
1069 \f
1070 static gpg_error_t
1071 membuf_data_cb (void *opaque, const void *buffer, size_t length)
1072 {
1073   membuf_t *data = opaque;
1074
1075   if (buffer)
1076     put_membuf (data, buffer, length);
1077   return 0;
1078 }
1079
1080
1081
1082 \f
1083 /* Send a READCERT command to the SCdaemon. */
1084 int
1085 agent_scd_readcert (const char *certidstr,
1086                     void **r_buf, size_t *r_buflen)
1087 {
1088   int rc;
1089   char line[ASSUAN_LINELENGTH];
1090   membuf_t data;
1091   size_t len;
1092   struct default_inq_parm_s dfltparm;
1093
1094   memset (&dfltparm, 0, sizeof dfltparm);
1095
1096   *r_buf = NULL;
1097   rc = start_agent (NULL, 1);
1098   if (rc)
1099     return rc;
1100
1101   dfltparm.ctx = agent_ctx;
1102
1103   init_membuf (&data, 2048);
1104
1105   snprintf (line, DIM(line)-1, "SCD READCERT %s", certidstr);
1106   line[DIM(line)-1] = 0;
1107   rc = assuan_transact (agent_ctx, line,
1108                         membuf_data_cb, &data,
1109                         default_inq_cb, &dfltparm,
1110                         NULL, NULL);
1111   if (rc)
1112     {
1113       xfree (get_membuf (&data, &len));
1114       return rc;
1115     }
1116   *r_buf = get_membuf (&data, r_buflen);
1117   if (!*r_buf)
1118     return gpg_error (GPG_ERR_ENOMEM);
1119
1120   return 0;
1121 }
1122
1123
1124 \f
1125 /* Change the PIN of an OpenPGP card or reset the retry counter.
1126    CHVNO 1: Change the PIN
1127          2: For v1 cards: Same as 1.
1128             For v2 cards: Reset the PIN using the Reset Code.
1129          3: Change the admin PIN
1130        101: Set a new PIN and reset the retry counter
1131        102: For v1 cars: Same as 101.
1132             For v2 cards: Set a new Reset Code.
1133    SERIALNO is not used.
1134  */
1135 int
1136 agent_scd_change_pin (int chvno, const char *serialno)
1137 {
1138   int rc;
1139   char line[ASSUAN_LINELENGTH];
1140   const char *reset = "";
1141   struct default_inq_parm_s dfltparm;
1142
1143   memset (&dfltparm, 0, sizeof dfltparm);
1144
1145   (void)serialno;
1146
1147   if (chvno >= 100)
1148     reset = "--reset";
1149   chvno %= 100;
1150
1151   rc = start_agent (NULL, 1);
1152   if (rc)
1153     return rc;
1154   dfltparm.ctx = agent_ctx;
1155
1156   snprintf (line, DIM(line)-1, "SCD PASSWD %s %d", reset, chvno);
1157   line[DIM(line)-1] = 0;
1158   rc = assuan_transact (agent_ctx, line,
1159                         NULL, NULL,
1160                         default_inq_cb, &dfltparm,
1161                         NULL, NULL);
1162   status_sc_op_failure (rc);
1163   return rc;
1164 }
1165
1166
1167 /* Perform a CHECKPIN operation.  SERIALNO should be the serial
1168    number of the card - optionally followed by the fingerprint;
1169    however the fingerprint is ignored here. */
1170 int
1171 agent_scd_checkpin  (const char *serialno)
1172 {
1173   int rc;
1174   char line[ASSUAN_LINELENGTH];
1175   struct default_inq_parm_s dfltparm;
1176
1177   memset (&dfltparm, 0, sizeof dfltparm);
1178
1179   rc = start_agent (NULL, 1);
1180   if (rc)
1181     return rc;
1182   dfltparm.ctx = agent_ctx;
1183
1184   snprintf (line, DIM(line)-1, "SCD CHECKPIN %s", serialno);
1185   line[DIM(line)-1] = 0;
1186   rc = assuan_transact (agent_ctx, line,
1187                         NULL, NULL,
1188                         default_inq_cb, &dfltparm,
1189                         NULL, NULL);
1190   status_sc_op_failure (rc);
1191   return rc;
1192 }
1193
1194
1195 /* Dummy function, only used by the gpg 1.4 implementation. */
1196 void
1197 agent_clear_pin_cache (const char *sn)
1198 {
1199   (void)sn;
1200 }
1201
1202
1203
1204 \f
1205 /* Note: All strings shall be UTF-8. On success the caller needs to
1206    free the string stored at R_PASSPHRASE. On error NULL will be
1207    stored at R_PASSPHRASE and an appropriate fpf error code
1208    returned. */
1209 gpg_error_t
1210 agent_get_passphrase (const char *cache_id,
1211                       const char *err_msg,
1212                       const char *prompt,
1213                       const char *desc_msg,
1214                       int repeat,
1215                       int check,
1216                       char **r_passphrase)
1217 {
1218   int rc;
1219   char line[ASSUAN_LINELENGTH];
1220   char *arg1 = NULL;
1221   char *arg2 = NULL;
1222   char *arg3 = NULL;
1223   char *arg4 = NULL;
1224   membuf_t data;
1225   struct default_inq_parm_s dfltparm;
1226
1227   memset (&dfltparm, 0, sizeof dfltparm);
1228
1229   *r_passphrase = NULL;
1230
1231   rc = start_agent (NULL, 0);
1232   if (rc)
1233     return rc;
1234   dfltparm.ctx = agent_ctx;
1235
1236   /* Check that the gpg-agent understands the repeat option.  */
1237   if (assuan_transact (agent_ctx,
1238                        "GETINFO cmd_has_option GET_PASSPHRASE repeat",
1239                        NULL, NULL, NULL, NULL, NULL, NULL))
1240     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1241
1242   if (cache_id && *cache_id)
1243     if (!(arg1 = percent_plus_escape (cache_id)))
1244       goto no_mem;
1245   if (err_msg && *err_msg)
1246     if (!(arg2 = percent_plus_escape (err_msg)))
1247       goto no_mem;
1248   if (prompt && *prompt)
1249     if (!(arg3 = percent_plus_escape (prompt)))
1250       goto no_mem;
1251   if (desc_msg && *desc_msg)
1252     if (!(arg4 = percent_plus_escape (desc_msg)))
1253       goto no_mem;
1254
1255   snprintf (line, DIM(line)-1,
1256             "GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
1257             repeat,
1258             check? " --check --qualitybar":"",
1259             arg1? arg1:"X",
1260             arg2? arg2:"X",
1261             arg3? arg3:"X",
1262             arg4? arg4:"X");
1263   line[DIM(line)-1] = 0;
1264   xfree (arg1);
1265   xfree (arg2);
1266   xfree (arg3);
1267   xfree (arg4);
1268
1269   init_membuf_secure (&data, 64);
1270   rc = assuan_transact (agent_ctx, line,
1271                         membuf_data_cb, &data,
1272                         default_inq_cb, &dfltparm,
1273                         NULL, NULL);
1274
1275   if (rc)
1276     xfree (get_membuf (&data, NULL));
1277   else
1278     {
1279       put_membuf (&data, "", 1);
1280       *r_passphrase = get_membuf (&data, NULL);
1281       if (!*r_passphrase)
1282         rc = gpg_error_from_syserror ();
1283     }
1284   return rc;
1285  no_mem:
1286   rc = gpg_error_from_syserror ();
1287   xfree (arg1);
1288   xfree (arg2);
1289   xfree (arg3);
1290   xfree (arg4);
1291   return rc;
1292 }
1293
1294
1295 gpg_error_t
1296 agent_clear_passphrase (const char *cache_id)
1297 {
1298   int rc;
1299   char line[ASSUAN_LINELENGTH];
1300   struct default_inq_parm_s dfltparm;
1301
1302   memset (&dfltparm, 0, sizeof dfltparm);
1303
1304   if (!cache_id || !*cache_id)
1305     return 0;
1306
1307   rc = start_agent (NULL, 0);
1308   if (rc)
1309     return rc;
1310   dfltparm.ctx = agent_ctx;
1311
1312   snprintf (line, DIM(line)-1, "CLEAR_PASSPHRASE %s", cache_id);
1313   line[DIM(line)-1] = 0;
1314   return assuan_transact (agent_ctx, line,
1315                           NULL, NULL,
1316                           default_inq_cb, &dfltparm,
1317                           NULL, NULL);
1318 }
1319
1320
1321 /* Ask the agent to pop up a confirmation dialog with the text DESC
1322    and an okay and cancel button. */
1323 gpg_error_t
1324 gpg_agent_get_confirmation (const char *desc)
1325 {
1326   int rc;
1327   char *tmp;
1328   char line[ASSUAN_LINELENGTH];
1329   struct default_inq_parm_s dfltparm;
1330
1331   memset (&dfltparm, 0, sizeof dfltparm);
1332
1333   rc = start_agent (NULL, 0);
1334   if (rc)
1335     return rc;
1336   dfltparm.ctx = agent_ctx;
1337
1338   tmp = percent_plus_escape (desc);
1339   if (!tmp)
1340     return gpg_error_from_syserror ();
1341   snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", tmp);
1342   line[DIM(line)-1] = 0;
1343   xfree (tmp);
1344
1345   rc = assuan_transact (agent_ctx, line,
1346                         NULL, NULL,
1347                         default_inq_cb, &dfltparm,
1348                         NULL, NULL);
1349   return rc;
1350 }
1351
1352
1353 /* Return the S2K iteration count as computed by gpg-agent.  */
1354 gpg_error_t
1355 agent_get_s2k_count (unsigned long *r_count)
1356 {
1357   gpg_error_t err;
1358   membuf_t data;
1359   char *buf;
1360
1361   *r_count = 0;
1362
1363   err = start_agent (NULL, 0);
1364   if (err)
1365     return err;
1366
1367   init_membuf (&data, 32);
1368   err = assuan_transact (agent_ctx, "GETINFO s2k_count",
1369                         membuf_data_cb, &data,
1370                         NULL, NULL, NULL, NULL);
1371   if (err)
1372     xfree (get_membuf (&data, NULL));
1373   else
1374     {
1375       put_membuf (&data, "", 1);
1376       buf = get_membuf (&data, NULL);
1377       if (!buf)
1378         err = gpg_error_from_syserror ();
1379       else
1380         {
1381           *r_count = strtoul (buf, NULL, 10);
1382           xfree (buf);
1383         }
1384     }
1385   return err;
1386 }
1387
1388
1389 \f
1390 /* Ask the agent whether a secret key for the given public key is
1391    available.  Returns 0 if available.  */
1392 gpg_error_t
1393 agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
1394 {
1395   gpg_error_t err;
1396   char line[ASSUAN_LINELENGTH];
1397   char *hexgrip;
1398
1399   err = start_agent (ctrl, 0);
1400   if (err)
1401     return err;
1402
1403   err = hexkeygrip_from_pk (pk, &hexgrip);
1404   if (err)
1405     return err;
1406
1407   snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
1408   xfree (hexgrip);
1409
1410   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1411   return err;
1412 }
1413
1414 /* Ask the agent whether a secret key is availabale for any of the
1415    keys (primary or sub) in KEYBLOCK.  Returns 0 if available.  */
1416 gpg_error_t
1417 agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
1418 {
1419   gpg_error_t err;
1420   char line[ASSUAN_LINELENGTH];
1421   char *p;
1422   kbnode_t kbctx, node;
1423   int nkeys;
1424   unsigned char grip[20];
1425
1426   err = start_agent (ctrl, 0);
1427   if (err)
1428     return err;
1429
1430   err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
1431                                           found in KEYBLOCK.  */
1432   p = stpcpy (line, "HAVEKEY");
1433   for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
1434     if (node->pkt->pkttype == PKT_PUBLIC_KEY
1435         || node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1436         || node->pkt->pkttype == PKT_SECRET_KEY
1437         || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1438       {
1439         if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
1440           {
1441             err = assuan_transact (agent_ctx, line,
1442                                    NULL, NULL, NULL, NULL, NULL, NULL);
1443             if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
1444               break; /* Seckey available or unexpected error - ready.  */
1445             p = stpcpy (line, "HAVEKEY");
1446             nkeys = 0;
1447           }
1448
1449         err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
1450         if (err)
1451           return err;
1452         *p++ = ' ';
1453         bin2hex (grip, 20, p);
1454         p += 40;
1455         nkeys++;
1456       }
1457
1458   if (!err && nkeys)
1459     err = assuan_transact (agent_ctx, line,
1460                            NULL, NULL, NULL, NULL, NULL, NULL);
1461
1462   return err;
1463 }
1464
1465
1466 \f
1467 static gpg_error_t
1468 keyinfo_status_cb (void *opaque, const char *line)
1469 {
1470   char **serialno = opaque;
1471   const char *s, *s2;
1472
1473   if (!strncmp (line, "KEYINFO ", 8) && !*serialno)
1474     {
1475       s = strchr (line+8, ' ');
1476       if (s && s[1] == 'T' && s[2] == ' ' && s[3])
1477         {
1478           s += 3;
1479           s2 = strchr (s, ' ');
1480           if ( s2 > s )
1481             {
1482               *serialno = xtrymalloc ((s2 - s)+1);
1483               if (*serialno)
1484                 {
1485                   memcpy (*serialno, s, s2 - s);
1486                   (*serialno)[s2 - s] = 0;
1487                 }
1488             }
1489         }
1490     }
1491   return 0;
1492 }
1493
1494
1495 /* Return the serial number for a secret key.  If the returned serial
1496    number is NULL, the key is not stored on a smartcard.  Caller needs
1497    to free R_SERIALNO.  */
1498 gpg_error_t
1499 agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip, char **r_serialno)
1500 {
1501   gpg_error_t err;
1502   char line[ASSUAN_LINELENGTH];
1503   char *serialno = NULL;
1504
1505   *r_serialno = NULL;
1506
1507   err = start_agent (ctrl, 0);
1508   if (err)
1509     return err;
1510
1511   if (!hexkeygrip || strlen (hexkeygrip) != 40)
1512     return gpg_error (GPG_ERR_INV_VALUE);
1513
1514   snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
1515   line[DIM(line)-1] = 0;
1516
1517   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
1518                          keyinfo_status_cb, &serialno);
1519   if (!err && serialno)
1520     {
1521       /* Sanity check for bad characters.  */
1522       if (strpbrk (serialno, ":\n\r"))
1523         err = GPG_ERR_INV_VALUE;
1524     }
1525   if (err)
1526     xfree (serialno);
1527   else
1528     *r_serialno = serialno;
1529   return err;
1530 }
1531
1532 \f
1533 /* Status callback for agent_import_key, agent_export_key and
1534    agent_genkey.  */
1535 static gpg_error_t
1536 cache_nonce_status_cb (void *opaque, const char *line)
1537 {
1538   struct cache_nonce_parm_s *parm = opaque;
1539   const char *keyword = line;
1540   int keywordlen;
1541
1542   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1543     ;
1544   while (spacep (line))
1545     line++;
1546
1547   if (keywordlen == 11 && !memcmp (keyword, "CACHE_NONCE", keywordlen))
1548     {
1549       if (parm->cache_nonce_addr)
1550         {
1551           xfree (*parm->cache_nonce_addr);
1552           *parm->cache_nonce_addr = xtrystrdup (line);
1553         }
1554     }
1555   else if (keywordlen == 12 && !memcmp (keyword, "PASSWD_NONCE", keywordlen))
1556     {
1557       if (parm->passwd_nonce_addr)
1558         {
1559           xfree (*parm->passwd_nonce_addr);
1560           *parm->passwd_nonce_addr = xtrystrdup (line);
1561         }
1562     }
1563
1564   return 0;
1565 }
1566
1567
1568 \f
1569 /* Handle a KEYPARMS inquiry.  Note, we only send the data,
1570    assuan_transact takes care of flushing and writing the end */
1571 static gpg_error_t
1572 inq_genkey_parms (void *opaque, const char *line)
1573 {
1574   struct genkey_parm_s *parm = opaque;
1575   gpg_error_t err;
1576
1577   if (!strncmp (line, "KEYPARAM", 8) && (line[8]==' '||!line[8]))
1578     {
1579       err = assuan_send_data (parm->dflt->ctx,
1580                               parm->keyparms, strlen (parm->keyparms));
1581     }
1582   else
1583     err = default_inq_cb (parm->dflt, line);
1584
1585   return err;
1586 }
1587
1588
1589 /* Call the agent to generate a new key.  KEYPARMS is the usual
1590    S-expression giving the parameters of the key.  gpg-agent passes it
1591    gcry_pk_genkey.  If NO_PROTECTION is true the agent is advised not
1592    to protect the generated key. */
1593 gpg_error_t
1594 agent_genkey (ctrl_t ctrl, char **cache_nonce_addr,
1595               const char *keyparms, int no_protection, gcry_sexp_t *r_pubkey)
1596 {
1597   gpg_error_t err;
1598   struct genkey_parm_s gk_parm;
1599   struct cache_nonce_parm_s cn_parm;
1600   struct default_inq_parm_s dfltparm;
1601   membuf_t data;
1602   size_t len;
1603   unsigned char *buf;
1604   char line[ASSUAN_LINELENGTH];
1605
1606   memset (&dfltparm, 0, sizeof dfltparm);
1607   dfltparm.ctrl = ctrl;
1608
1609   *r_pubkey = NULL;
1610   err = start_agent (ctrl, 0);
1611   if (err)
1612     return err;
1613   dfltparm.ctx = agent_ctx;
1614
1615   err = assuan_transact (agent_ctx, "RESET",
1616                          NULL, NULL, NULL, NULL, NULL, NULL);
1617   if (err)
1618     return err;
1619
1620   init_membuf (&data, 1024);
1621   gk_parm.dflt     = &dfltparm;
1622   gk_parm.keyparms = keyparms;
1623   snprintf (line, sizeof line, "GENKEY%s%s%s",
1624             no_protection? " --no-protection":"",
1625             cache_nonce_addr && *cache_nonce_addr? " ":"",
1626             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
1627   cn_parm.cache_nonce_addr = cache_nonce_addr;
1628   cn_parm.passwd_nonce_addr = NULL;
1629   err = assuan_transact (agent_ctx, line,
1630                          membuf_data_cb, &data,
1631                          inq_genkey_parms, &gk_parm,
1632                          cache_nonce_status_cb, &cn_parm);
1633   if (err)
1634     {
1635       xfree (get_membuf (&data, &len));
1636       return err;
1637     }
1638
1639   buf = get_membuf (&data, &len);
1640   if (!buf)
1641     err = gpg_error_from_syserror ();
1642   else
1643     {
1644       err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
1645       xfree (buf);
1646     }
1647   return err;
1648 }
1649
1650
1651 \f
1652 /* Call the agent to read the public key part for a given keygrip.  If
1653    FROMCARD is true, the key is directly read from the current
1654    smartcard. In this case HEXKEYGRIP should be the keyID
1655    (e.g. OPENPGP.3). */
1656 gpg_error_t
1657 agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
1658                unsigned char **r_pubkey)
1659 {
1660   gpg_error_t err;
1661   membuf_t data;
1662   size_t len;
1663   unsigned char *buf;
1664   char line[ASSUAN_LINELENGTH];
1665   struct default_inq_parm_s dfltparm;
1666
1667   memset (&dfltparm, 0, sizeof dfltparm);
1668   dfltparm.ctrl = ctrl;
1669
1670   *r_pubkey = NULL;
1671   err = start_agent (ctrl, 0);
1672   if (err)
1673     return err;
1674   dfltparm.ctx = agent_ctx;
1675
1676   err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
1677   if (err)
1678     return err;
1679
1680   snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
1681
1682   init_membuf (&data, 1024);
1683   err = assuan_transact (agent_ctx, line,
1684                          membuf_data_cb, &data,
1685                          default_inq_cb, &dfltparm,
1686                          NULL, NULL);
1687   if (err)
1688     {
1689       xfree (get_membuf (&data, &len));
1690       return err;
1691     }
1692   buf = get_membuf (&data, &len);
1693   if (!buf)
1694     return gpg_error_from_syserror ();
1695   if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
1696     {
1697       xfree (buf);
1698       return gpg_error (GPG_ERR_INV_SEXP);
1699     }
1700   *r_pubkey = buf;
1701   return 0;
1702 }
1703
1704
1705 \f
1706 /* Call the agent to do a sign operation using the key identified by
1707    the hex string KEYGRIP.  DESC is a description of the key to be
1708    displayed if the agent needs to ask for the PIN.  DIGEST and
1709    DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
1710    used to compute the digest.  If CACHE_NONCE is used the agent is
1711    advised to first try a passphrase associated with that nonce. */
1712 gpg_error_t
1713 agent_pksign (ctrl_t ctrl, const char *cache_nonce,
1714               const char *keygrip, const char *desc,
1715               u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1716               unsigned char *digest, size_t digestlen, int digestalgo,
1717               gcry_sexp_t *r_sigval)
1718 {
1719   gpg_error_t err;
1720   char line[ASSUAN_LINELENGTH];
1721   membuf_t data;
1722   struct default_inq_parm_s dfltparm;
1723
1724   memset (&dfltparm, 0, sizeof dfltparm);
1725   dfltparm.ctrl = ctrl;
1726   dfltparm.keyinfo.keyid       = keyid;
1727   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1728   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1729
1730   *r_sigval = NULL;
1731   err = start_agent (ctrl, 0);
1732   if (err)
1733     return err;
1734   dfltparm.ctx = agent_ctx;
1735
1736   if (digestlen*2 + 50 > DIM(line))
1737     return gpg_error (GPG_ERR_GENERAL);
1738
1739   err = assuan_transact (agent_ctx, "RESET",
1740                          NULL, NULL, NULL, NULL, NULL, NULL);
1741   if (err)
1742     return err;
1743
1744   snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
1745   line[DIM(line)-1] = 0;
1746   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1747   if (err)
1748     return err;
1749
1750   if (desc)
1751     {
1752       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1753       line[DIM(line)-1] = 0;
1754       err = assuan_transact (agent_ctx, line,
1755                             NULL, NULL, NULL, NULL, NULL, NULL);
1756       if (err)
1757         return err;
1758     }
1759
1760   snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
1761   bin2hex (digest, digestlen, line + strlen (line));
1762   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1763   if (err)
1764     return err;
1765
1766   init_membuf (&data, 1024);
1767
1768   snprintf (line, sizeof line, "PKSIGN%s%s",
1769             cache_nonce? " -- ":"",
1770             cache_nonce? cache_nonce:"");
1771   err = assuan_transact (agent_ctx, line,
1772                          membuf_data_cb, &data,
1773                          default_inq_cb, &dfltparm,
1774                          NULL, NULL);
1775   if (err)
1776     xfree (get_membuf (&data, NULL));
1777   else
1778     {
1779       unsigned char *buf;
1780       size_t len;
1781
1782       buf = get_membuf (&data, &len);
1783       if (!buf)
1784         err = gpg_error_from_syserror ();
1785       else
1786         {
1787           err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
1788           xfree (buf);
1789         }
1790     }
1791   return err;
1792 }
1793
1794
1795 \f
1796 /* Handle a CIPHERTEXT inquiry.  Note, we only send the data,
1797    assuan_transact takes care of flushing and writing the END. */
1798 static gpg_error_t
1799 inq_ciphertext_cb (void *opaque, const char *line)
1800 {
1801   struct cipher_parm_s *parm = opaque;
1802   int rc;
1803
1804   if (!strncmp (line, "CIPHERTEXT", 10) && (line[10]==' '||!line[10]))
1805     {
1806       assuan_begin_confidential (parm->ctx);
1807       rc = assuan_send_data (parm->dflt->ctx,
1808                              parm->ciphertext, parm->ciphertextlen);
1809       assuan_end_confidential (parm->ctx);
1810     }
1811   else
1812     rc = default_inq_cb (parm->dflt, line);
1813
1814   return rc;
1815 }
1816
1817
1818 /* Call the agent to do a decrypt operation using the key identified
1819    by the hex string KEYGRIP and the input data S_CIPHERTEXT.  On the
1820    success the decoded value is stored verbatim at R_BUF and its
1821    length at R_BUF; the callers needs to release it.  KEYID, MAINKEYID
1822    and PUBKEY_ALGO are used to construct additional promots or status
1823    messages. */
1824 gpg_error_t
1825 agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
1826                  u32 *keyid, u32 *mainkeyid, int pubkey_algo,
1827                  gcry_sexp_t s_ciphertext,
1828                  unsigned char **r_buf, size_t *r_buflen)
1829 {
1830   gpg_error_t err;
1831   char line[ASSUAN_LINELENGTH];
1832   membuf_t data;
1833   size_t n, len;
1834   char *p, *buf, *endp;
1835   struct default_inq_parm_s dfltparm;
1836
1837   memset (&dfltparm, 0, sizeof dfltparm);
1838   dfltparm.ctrl = ctrl;
1839   dfltparm.keyinfo.keyid       = keyid;
1840   dfltparm.keyinfo.mainkeyid   = mainkeyid;
1841   dfltparm.keyinfo.pubkey_algo = pubkey_algo;
1842
1843   if (!keygrip || strlen(keygrip) != 40 || !s_ciphertext || !r_buf || !r_buflen)
1844     return gpg_error (GPG_ERR_INV_VALUE);
1845   *r_buf = NULL;
1846
1847   err = start_agent (ctrl, 0);
1848   if (err)
1849     return err;
1850   dfltparm.ctx = agent_ctx;
1851
1852   err = assuan_transact (agent_ctx, "RESET",
1853                          NULL, NULL, NULL, NULL, NULL, NULL);
1854   if (err)
1855     return err;
1856
1857   snprintf (line, sizeof line, "SETKEY %s", keygrip);
1858   err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
1859   if (err)
1860     return err;
1861
1862   if (desc)
1863     {
1864       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
1865       line[DIM(line)-1] = 0;
1866       err = assuan_transact (agent_ctx, line,
1867                             NULL, NULL, NULL, NULL, NULL, NULL);
1868       if (err)
1869         return err;
1870     }
1871
1872   init_membuf_secure (&data, 1024);
1873   {
1874     struct cipher_parm_s parm;
1875
1876     parm.dflt = &dfltparm;
1877     parm.ctx = agent_ctx;
1878     err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
1879     if (err)
1880       return err;
1881     err = assuan_transact (agent_ctx, "PKDECRYPT",
1882                            membuf_data_cb, &data,
1883                            inq_ciphertext_cb, &parm, NULL, NULL);
1884     xfree (parm.ciphertext);
1885   }
1886   if (err)
1887     {
1888       xfree (get_membuf (&data, &len));
1889       return err;
1890     }
1891
1892   put_membuf (&data, "", 1); /* Make sure it is 0 terminated.  */
1893   buf = get_membuf (&data, &len);
1894   if (!buf)
1895     return gpg_error_from_syserror ();
1896   assert (len); /* (we forced Nul termination.)  */
1897
1898   if (*buf != '(')
1899     {
1900       xfree (buf);
1901       return gpg_error (GPG_ERR_INV_SEXP);
1902     }
1903
1904   if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
1905     {
1906       xfree (buf);
1907       return gpg_error (GPG_ERR_INV_SEXP);
1908     }
1909   len -= 11;   /* Count only the data of the second part. */
1910   p = buf + 8; /* Skip leading parenthesis and the value tag. */
1911
1912   n = strtoul (p, &endp, 10);
1913   if (!n || *endp != ':')
1914     {
1915       xfree (buf);
1916       return gpg_error (GPG_ERR_INV_SEXP);
1917     }
1918   endp++;
1919   if (endp-p+n > len)
1920     {
1921       xfree (buf);
1922       return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
1923     }
1924
1925   memmove (buf, endp, n);
1926
1927   *r_buflen = n;
1928   *r_buf = buf;
1929   return 0;
1930 }
1931
1932
1933 \f
1934 /* Retrieve a key encryption key from the agent.  With FOREXPORT true
1935    the key shall be used for export, with false for import.  On success
1936    the new key is stored at R_KEY and its length at R_KEKLEN.  */
1937 gpg_error_t
1938 agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
1939 {
1940   gpg_error_t err;
1941   membuf_t data;
1942   size_t len;
1943   unsigned char *buf;
1944   char line[ASSUAN_LINELENGTH];
1945   struct default_inq_parm_s dfltparm;
1946
1947   memset (&dfltparm, 0, sizeof dfltparm);
1948   dfltparm.ctrl = ctrl;
1949
1950   *r_kek = NULL;
1951   err = start_agent (ctrl, 0);
1952   if (err)
1953     return err;
1954   dfltparm.ctx = agent_ctx;
1955
1956   snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
1957             forexport? "--export":"--import");
1958
1959   init_membuf_secure (&data, 64);
1960   err = assuan_transact (agent_ctx, line,
1961                          membuf_data_cb, &data,
1962                          default_inq_cb, &dfltparm,
1963                          NULL, NULL);
1964   if (err)
1965     {
1966       xfree (get_membuf (&data, &len));
1967       return err;
1968     }
1969   buf = get_membuf (&data, &len);
1970   if (!buf)
1971     return gpg_error_from_syserror ();
1972   *r_kek = buf;
1973   *r_keklen = len;
1974   return 0;
1975 }
1976
1977
1978 \f
1979 /* Handle the inquiry for an IMPORT_KEY command.  */
1980 static gpg_error_t
1981 inq_import_key_parms (void *opaque, const char *line)
1982 {
1983   struct import_key_parm_s *parm = opaque;
1984   gpg_error_t err;
1985
1986   if (!strncmp (line, "KEYDATA", 7) && (line[7]==' '||!line[7]))
1987     {
1988       err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
1989     }
1990   else
1991     err = default_inq_cb (parm->dflt, line);
1992
1993   return err;
1994 }
1995
1996
1997 /* Call the agent to import a key into the agent.  */
1998 gpg_error_t
1999 agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
2000                   const void *key, size_t keylen)
2001 {
2002   gpg_error_t err;
2003   struct import_key_parm_s parm;
2004   struct cache_nonce_parm_s cn_parm;
2005   char line[ASSUAN_LINELENGTH];
2006   struct default_inq_parm_s dfltparm;
2007
2008   memset (&dfltparm, 0, sizeof dfltparm);
2009   dfltparm.ctrl = ctrl;
2010
2011   err = start_agent (ctrl, 0);
2012   if (err)
2013     return err;
2014   dfltparm.ctx = agent_ctx;
2015
2016   if (desc)
2017     {
2018       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2019       line[DIM(line)-1] = 0;
2020       err = assuan_transact (agent_ctx, line,
2021                             NULL, NULL, NULL, NULL, NULL, NULL);
2022       if (err)
2023         return err;
2024     }
2025
2026   parm.dflt   = &dfltparm;
2027   parm.key    = key;
2028   parm.keylen = keylen;
2029
2030   snprintf (line, sizeof line, "IMPORT_KEY%s%s",
2031             cache_nonce_addr && *cache_nonce_addr? " ":"",
2032             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
2033   cn_parm.cache_nonce_addr = cache_nonce_addr;
2034   cn_parm.passwd_nonce_addr = NULL;
2035   err = assuan_transact (agent_ctx, line,
2036                          NULL, NULL,
2037                          inq_import_key_parms, &parm,
2038                          cache_nonce_status_cb, &cn_parm);
2039   return err;
2040 }
2041
2042
2043 \f
2044 /* Receive a secret key from the agent.  HEXKEYGRIP is the hexified
2045    keygrip, DESC a prompt to be displayed with the agent's passphrase
2046    question (needs to be plus+percent escaped).  On success the key is
2047    stored as a canonical S-expression at R_RESULT and R_RESULTLEN.  */
2048 gpg_error_t
2049 agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2050                   char **cache_nonce_addr,
2051                   unsigned char **r_result, size_t *r_resultlen)
2052 {
2053   gpg_error_t err;
2054   struct cache_nonce_parm_s cn_parm;
2055   membuf_t data;
2056   size_t len;
2057   unsigned char *buf;
2058   char line[ASSUAN_LINELENGTH];
2059   struct default_inq_parm_s dfltparm;
2060
2061   memset (&dfltparm, 0, sizeof dfltparm);
2062   dfltparm.ctrl = ctrl;
2063
2064   *r_result = NULL;
2065
2066   err = start_agent (ctrl, 0);
2067   if (err)
2068     return err;
2069   dfltparm.ctx = agent_ctx;
2070
2071   if (desc)
2072     {
2073       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2074       err = assuan_transact (agent_ctx, line,
2075                              NULL, NULL, NULL, NULL, NULL, NULL);
2076       if (err)
2077         return err;
2078     }
2079
2080   snprintf (line, DIM(line)-1, "EXPORT_KEY --openpgp %s%s %s",
2081             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2082             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2083             hexkeygrip);
2084
2085   init_membuf_secure (&data, 1024);
2086   cn_parm.cache_nonce_addr = cache_nonce_addr;
2087   cn_parm.passwd_nonce_addr = NULL;
2088   err = assuan_transact (agent_ctx, line,
2089                          membuf_data_cb, &data,
2090                          default_inq_cb, &dfltparm,
2091                          cache_nonce_status_cb, &cn_parm);
2092   if (err)
2093     {
2094       xfree (get_membuf (&data, &len));
2095       return err;
2096     }
2097   buf = get_membuf (&data, &len);
2098   if (!buf)
2099     return gpg_error_from_syserror ();
2100   *r_result = buf;
2101   *r_resultlen = len;
2102   return 0;
2103 }
2104
2105
2106 \f
2107 /* Ask the agent to change the passphrase of the key identified by
2108    HEXKEYGRIP.  If DESC is not NULL, display DESC instead of the
2109    default description message.  If CACHE_NONCE_ADDR is not NULL the
2110    agent is advised to first try a passphrase associated with that
2111    nonce.  If PASSWD_NONCE_ADDR is not NULL the agent will try to use
2112    the passphrase associated with that nonce.  */
2113 gpg_error_t
2114 agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
2115               char **cache_nonce_addr, char **passwd_nonce_addr)
2116 {
2117   gpg_error_t err;
2118   struct cache_nonce_parm_s cn_parm;
2119   char line[ASSUAN_LINELENGTH];
2120   struct default_inq_parm_s dfltparm;
2121
2122   memset (&dfltparm, 0, sizeof dfltparm);
2123   dfltparm.ctrl = ctrl;
2124
2125   err = start_agent (ctrl, 0);
2126   if (err)
2127     return err;
2128   dfltparm.ctx = agent_ctx;
2129
2130   if (!hexkeygrip || strlen (hexkeygrip) != 40)
2131     return gpg_error (GPG_ERR_INV_VALUE);
2132
2133
2134   if (desc)
2135     {
2136       snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
2137       err = assuan_transact (agent_ctx, line,
2138                              NULL, NULL, NULL, NULL, NULL, NULL);
2139       if (err)
2140         return err;
2141     }
2142
2143   snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
2144             cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
2145             cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
2146             passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
2147             passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
2148             hexkeygrip);
2149   cn_parm.cache_nonce_addr = cache_nonce_addr;
2150   cn_parm.passwd_nonce_addr = passwd_nonce_addr;
2151   err = assuan_transact (agent_ctx, line, NULL, NULL,
2152                          default_inq_cb, &dfltparm,
2153                          cache_nonce_status_cb, &cn_parm);
2154   return err;
2155 }