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