Fix usage of SHA-2 algorithm with OpenPGP cards.
[gnupg.git] / agent / call-scd.c
1 /* call-scd.c - fork of the scdaemon to do SC operations
2  * Copyright (C) 2001, 2002, 2005, 2007, 2010 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <assert.h>
27 #include <unistd.h>
28 #ifdef HAVE_SIGNAL_H
29 # include <signal.h>
30 #endif
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #ifndef HAVE_W32_SYSTEM
34 #include <sys/wait.h>
35 #endif
36 #include <pth.h>
37
38 #include "agent.h"
39 #include <assuan.h>
40
41 #ifdef _POSIX_OPEN_MAX
42 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
43 #else
44 #define MAX_OPEN_FDS 20
45 #endif
46
47 /* This Assuan flag is only available since libassuan 2.0.2.  Because
48    comments lines are comments anyway we can use a replacement which
49    might not do anything.  assuan_{g,s}et_flag don't return an error
50    thus there won't be any ABI problem.  */
51 #ifndef ASSUAN_CONVEY_COMMENTS
52 #define ASSUAN_CONVEY_COMMENTS 4
53 #endif
54
55
56 /* Definition of module local data of the CTRL structure.  */
57 struct scd_local_s
58 {
59   /* We keep a list of all allocated context with a an achnor at
60      SCD_LOCAL_LIST (see below). */
61   struct scd_local_s *next_local;
62
63   /* We need to get back to the ctrl object actually referencing this
64      structure.  This is really an awkward way of enumerint the lcoal
65      contects.  A much cleaner way would be to keep a global list of
66      ctrl objects to enumerate them.  */
67   ctrl_t ctrl_backlink;
68
69   assuan_context_t ctx; /* NULL or session context for the SCdaemon
70                            used with this connection. */
71   int locked;           /* This flag is used to assert proper use of
72                            start_scd and unlock_scd. */
73
74 };
75
76
77 /* Callback parameter for learn card */
78 struct learn_parm_s
79 {
80   void (*kpinfo_cb)(void*, const char *);
81   void *kpinfo_cb_arg;
82   void (*certinfo_cb)(void*, const char *);
83   void *certinfo_cb_arg;
84   void (*sinfo_cb)(void*, const char *, size_t, const char *);
85   void *sinfo_cb_arg;
86 };
87
88 struct inq_needpin_s
89 {
90   assuan_context_t ctx;
91   int (*getpin_cb)(void *, const char *, char*, size_t);
92   void *getpin_cb_arg;
93   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
94                                  up to the caller.  */
95 };
96
97
98 /* To keep track of all active SCD contexts, we keep a linked list
99    anchored at this variable. */
100 static struct scd_local_s *scd_local_list;
101
102 /* A Mutex used inside the start_scd function. */
103 static pth_mutex_t start_scd_lock;
104
105 /* A malloced string with the name of the socket to be used for
106    additional connections.  May be NULL if not provided by
107    SCdaemon. */
108 static char *socket_name;
109
110 /* The context of the primary connection.  This is also used as a flag
111    to indicate whether the scdaemon has been started. */
112 static assuan_context_t primary_scd_ctx;
113
114 /* To allow reuse of the primary connection, the following flag is set
115    to true if the primary context has been reset and is not in use by
116    any connection. */
117 static int primary_scd_ctx_reusable;
118
119
120
121 /* Local prototypes.  */
122 static gpg_error_t membuf_data_cb (void *opaque,
123                                    const void *buffer, size_t length);
124
125
126
127 \f
128 /* This function must be called once to initialize this module.  This
129    has to be done before a second thread is spawned.  We can't do the
130    static initialization because Pth emulation code might not be able
131    to do a static init; in particular, it is not possible for W32. */
132 void
133 initialize_module_call_scd (void)
134 {
135   static int initialized;
136
137   if (!initialized)
138     {
139       if (!pth_mutex_init (&start_scd_lock))
140         log_fatal ("error initializing mutex: %s\n", strerror (errno));
141       initialized = 1;
142     }
143 }
144
145
146 static void
147 dump_mutex_state (pth_mutex_t *m)
148 {
149 #ifdef _W32_PTH_H
150   (void)m;
151   log_printf ("unknown under W32");
152 #else
153   if (!(m->mx_state & PTH_MUTEX_INITIALIZED))
154     log_printf ("not_initialized");
155   else if (!(m->mx_state & PTH_MUTEX_LOCKED))
156     log_printf ("not_locked");
157   else
158     log_printf ("locked tid=0x%lx count=%lu", (long)m->mx_owner, m->mx_count);
159 #endif
160 }
161
162
163 /* This function may be called to print infromation pertaining to the
164    current state of this module to the log. */
165 void
166 agent_scd_dump_state (void)
167 {
168   log_info ("agent_scd_dump_state: scd_lock=");
169   dump_mutex_state (&start_scd_lock);
170   log_printf ("\n");
171   log_info ("agent_scd_dump_state: primary_scd_ctx=%p pid=%ld reusable=%d\n",
172             primary_scd_ctx,
173             (long)assuan_get_pid (primary_scd_ctx),
174             primary_scd_ctx_reusable);
175   if (socket_name)
176     log_info ("agent_scd_dump_state: socket=`%s'\n", socket_name);
177 }
178
179
180 /* The unlock_scd function shall be called after having accessed the
181    SCD.  It is currently not very useful but gives an opportunity to
182    keep track of connections currently calling SCD.  Note that the
183    "lock" operation is done by the start_scd() function which must be
184    called and error checked before any SCD operation.  CTRL is the
185    usual connection context and RC the error code to be passed trhough
186    the function. */
187 static int
188 unlock_scd (ctrl_t ctrl, int rc)
189 {
190   if (ctrl->scd_local->locked != 1)
191     {
192       log_error ("unlock_scd: invalid lock count (%d)\n",
193                  ctrl->scd_local->locked);
194       if (!rc)
195         rc = gpg_error (GPG_ERR_INTERNAL);
196     }
197   ctrl->scd_local->locked = 0;
198   return rc;
199 }
200
201 /* To make sure we leave no secrets in our image after forking of the
202    scdaemon, we use this callback. */
203 static void
204 atfork_cb (void *opaque, int where)
205 {
206   (void)opaque;
207
208   if (!where)
209     gcry_control (GCRYCTL_TERM_SECMEM);
210 }
211
212
213 /* Fork off the SCdaemon if this has not already been done.  Lock the
214    daemon and make sure that a proper context has been setup in CTRL.
215    This function might also lock the daemon, which means that the
216    caller must call unlock_scd after this fucntion has returned
217    success and the actual Assuan transaction been done. */
218 static int
219 start_scd (ctrl_t ctrl)
220 {
221   gpg_error_t err = 0;
222   const char *pgmname;
223   assuan_context_t ctx = NULL;
224   const char *argv[3];
225   int no_close_list[3];
226   int i;
227   int rc;
228
229   if (opt.disable_scdaemon)
230     return gpg_error (GPG_ERR_NOT_SUPPORTED);
231
232   /* If this is the first call for this session, setup the local data
233      structure. */
234   if (!ctrl->scd_local)
235     {
236       ctrl->scd_local = xtrycalloc (1, sizeof *ctrl->scd_local);
237       if (!ctrl->scd_local)
238         return gpg_error_from_syserror ();
239       ctrl->scd_local->ctrl_backlink = ctrl;
240       ctrl->scd_local->next_local = scd_local_list;
241       scd_local_list = ctrl->scd_local;
242     }
243
244
245   /* Assert that the lock count is as expected. */
246   if (ctrl->scd_local->locked)
247     {
248       log_error ("start_scd: invalid lock count (%d)\n",
249                  ctrl->scd_local->locked);
250       return gpg_error (GPG_ERR_INTERNAL);
251     }
252   ctrl->scd_local->locked++;
253
254   if (ctrl->scd_local->ctx)
255     return 0; /* Okay, the context is fine.  We used to test for an
256                  alive context here and do an disconnect.  Now that we
257                  have a ticker function to check for it, it is easier
258                  not to check here but to let the connection run on an
259                  error instead. */
260
261
262   /* We need to protect the following code. */
263   if (!pth_mutex_acquire (&start_scd_lock, 0, NULL))
264     {
265       log_error ("failed to acquire the start_scd lock: %s\n",
266                  strerror (errno));
267       return gpg_error (GPG_ERR_INTERNAL);
268     }
269
270   /* Check whether the pipe server has already been started and in
271      this case either reuse a lingering pipe connection or establish a
272      new socket based one. */
273   if (primary_scd_ctx && primary_scd_ctx_reusable)
274     {
275       ctx = primary_scd_ctx;
276       primary_scd_ctx_reusable = 0;
277       if (opt.verbose)
278         log_info ("new connection to SCdaemon established (reusing)\n");
279       goto leave;
280     }
281
282   rc = assuan_new (&ctx);
283   if (rc)
284     {
285       log_error ("can't allocate assuan context: %s\n", gpg_strerror (rc));
286       err = rc;
287       goto leave;
288     }
289
290   if (socket_name)
291     {
292       rc = assuan_socket_connect (ctx, socket_name, 0, 0);
293       if (rc)
294         {
295           log_error ("can't connect to socket `%s': %s\n",
296                      socket_name, gpg_strerror (rc));
297           err = gpg_error (GPG_ERR_NO_SCDAEMON);
298           goto leave;
299         }
300
301       if (opt.verbose)
302         log_info ("new connection to SCdaemon established\n");
303       goto leave;
304     }
305
306   if (primary_scd_ctx)
307     {
308       log_info ("SCdaemon is running but won't accept further connections\n");
309       err = gpg_error (GPG_ERR_NO_SCDAEMON);
310       goto leave;
311     }
312
313   /* Nope, it has not been started.  Fire it up now. */
314   if (opt.verbose)
315     log_info ("no running SCdaemon - starting it\n");
316
317   if (fflush (NULL))
318     {
319 #ifndef HAVE_W32_SYSTEM
320       err = gpg_error_from_syserror ();
321 #endif
322       log_error ("error flushing pending output: %s\n", strerror (errno));
323       /* At least Windows XP fails here with EBADF.  According to docs
324          and Wine an fflush(NULL) is the same as _flushall.  However
325          the Wime implementaion does not flush stdin,stdout and stderr
326          - see above.  Lets try to ignore the error. */
327 #ifndef HAVE_W32_SYSTEM
328       goto leave;
329 #endif
330     }
331
332   if (!opt.scdaemon_program || !*opt.scdaemon_program)
333     opt.scdaemon_program = gnupg_module_name (GNUPG_MODULE_NAME_SCDAEMON);
334   if ( !(pgmname = strrchr (opt.scdaemon_program, '/')))
335     pgmname = opt.scdaemon_program;
336   else
337     pgmname++;
338
339   argv[0] = pgmname;
340   argv[1] = "--multi-server";
341   argv[2] = NULL;
342
343   i=0;
344   if (!opt.running_detached)
345     {
346       if (log_get_fd () != -1)
347         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
348       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
349     }
350   no_close_list[i] = -1;
351
352   /* Connect to the pinentry and perform initial handshaking.  Use
353      detached flag (128) so that under W32 SCDAEMON does not show up a
354      new window.  */
355   rc = assuan_pipe_connect (ctx, opt.scdaemon_program, argv,
356                             no_close_list, atfork_cb, NULL, 128);
357   if (rc)
358     {
359       log_error ("can't connect to the SCdaemon: %s\n",
360                  gpg_strerror (rc));
361       err = gpg_error (GPG_ERR_NO_SCDAEMON);
362       goto leave;
363     }
364
365   if (opt.verbose)
366     log_debug ("first connection to SCdaemon established\n");
367
368
369   /* Get the name of the additional socket opened by scdaemon. */
370   {
371     membuf_t data;
372     unsigned char *databuf;
373     size_t datalen;
374
375     xfree (socket_name);
376     socket_name = NULL;
377     init_membuf (&data, 256);
378     assuan_transact (ctx, "GETINFO socket_name",
379                      membuf_data_cb, &data, NULL, NULL, NULL, NULL);
380
381     databuf = get_membuf (&data, &datalen);
382     if (databuf && datalen)
383       {
384         socket_name = xtrymalloc (datalen + 1);
385         if (!socket_name)
386           log_error ("warning: can't store socket name: %s\n",
387                      strerror (errno));
388         else
389           {
390             memcpy (socket_name, databuf, datalen);
391             socket_name[datalen] = 0;
392             if (DBG_ASSUAN)
393               log_debug ("additional connections at `%s'\n", socket_name);
394           }
395       }
396     xfree (databuf);
397   }
398
399   /* Tell the scdaemon we want him to send us an event signal.  We
400      don't support this for W32CE.  */
401 #ifndef HAVE_W32CE_SYSTEM
402   if (opt.sigusr2_enabled)
403     {
404       char buf[100];
405
406 #ifdef HAVE_W32_SYSTEM
407       snprintf (buf, sizeof buf, "OPTION event-signal=%lx",
408                 (unsigned long)get_agent_scd_notify_event ());
409 #else
410       snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
411 #endif
412       assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
413     }
414 #endif /*HAVE_W32CE_SYSTEM*/
415
416   primary_scd_ctx = ctx;
417   primary_scd_ctx_reusable = 0;
418
419  leave:
420   if (err)
421     {
422       unlock_scd (ctrl, err);
423       if (ctx)
424         assuan_release (ctx);
425     }
426   else
427     {
428       ctrl->scd_local->ctx = ctx;
429     }
430   if (!pth_mutex_release (&start_scd_lock))
431     log_error ("failed to release the start_scd lock: %s\n", strerror (errno));
432   return err;
433 }
434
435
436 /* Check whether the SCdaemon is active.  This is a fast check without
437    any locking and might give a wrong result if another thread is about
438    to start the daemon or the daemon is about to be stopped.. */
439 int
440 agent_scd_check_running (void)
441 {
442   return !!primary_scd_ctx;
443 }
444
445
446 /* Check whether the Scdaemon is still alive and clean it up if not. */
447 void
448 agent_scd_check_aliveness (void)
449 {
450   pth_event_t evt;
451   pid_t pid;
452 #ifdef HAVE_W32_SYSTEM
453   DWORD rc;
454 #else
455   int rc;
456 #endif
457
458   if (!primary_scd_ctx)
459     return; /* No scdaemon running. */
460
461   /* This is not a critical function so we use a short timeout while
462      acquiring the lock.  */
463   evt = pth_event (PTH_EVENT_TIME, pth_timeout (1, 0));
464   if (!pth_mutex_acquire (&start_scd_lock, 0, evt))
465     {
466       if (pth_event_occurred (evt))
467         {
468           if (opt.verbose > 1)
469             log_info ("failed to acquire the start_scd lock while"
470                       " doing an aliveness check: %s\n", "timeout");
471         }
472       else
473         log_error ("failed to acquire the start_scd lock while"
474                    " doing an aliveness check: %s\n", strerror (errno));
475       pth_event_free (evt, PTH_FREE_THIS);
476       return;
477     }
478   pth_event_free (evt, PTH_FREE_THIS);
479
480   if (primary_scd_ctx)
481     {
482       pid = assuan_get_pid (primary_scd_ctx);
483 #ifdef HAVE_W32_SYSTEM
484       /* If we have a PID we disconnect if either GetExitProcessCode
485          fails or if ir returns the exit code of the scdaemon.  259 is
486          the error code for STILL_ALIVE.  */
487       if (pid != (pid_t)(void*)(-1) && pid
488           && (!GetExitCodeProcess ((HANDLE)pid, &rc) || rc != 259))
489 #else
490       if (pid != (pid_t)(-1) && pid
491           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
492 #endif
493         {
494           /* Okay, scdaemon died.  Disconnect the primary connection
495              now but take care that it won't do another wait. Also
496              cleanup all other connections and release their
497              resources.  The next use will start a new daemon then.
498              Due to the use of the START_SCD_LOCAL we are sure that
499              none of these context are actually in use. */
500           struct scd_local_s *sl;
501
502           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
503           assuan_release (primary_scd_ctx);
504
505           for (sl=scd_local_list; sl; sl = sl->next_local)
506             {
507               if (sl->ctx)
508                 {
509                   if (sl->ctx != primary_scd_ctx)
510                     assuan_release (sl->ctx);
511                   sl->ctx = NULL;
512                 }
513             }
514
515           primary_scd_ctx = NULL;
516           primary_scd_ctx_reusable = 0;
517
518           xfree (socket_name);
519           socket_name = NULL;
520         }
521     }
522
523   if (!pth_mutex_release (&start_scd_lock))
524     log_error ("failed to release the start_scd lock while"
525                " doing the aliveness check: %s\n", strerror (errno));
526 }
527
528
529
530 /* Reset the SCD if it has been used.  Actually it is not a reset but
531    a cleanup of resources used by the current connection. */
532 int
533 agent_reset_scd (ctrl_t ctrl)
534 {
535   if (ctrl->scd_local)
536     {
537       if (ctrl->scd_local->ctx)
538         {
539           /* We can't disconnect the primary context because libassuan
540              does a waitpid on it and thus the system would hang.
541              Instead we send a reset and keep that connection for
542              reuse. */
543           if (ctrl->scd_local->ctx == primary_scd_ctx)
544             {
545               /* Send a RESTART to the SCD.  This is required for the
546                  primary connection as a kind of virtual EOF; we don't
547                  have another way to tell it that the next command
548                  should be viewed as if a new connection has been
549                  made.  For the non-primary connections this is not
550                  needed as we simply close the socket.  We don't check
551                  for an error here because the RESTART may fail for
552                  example if the scdaemon has already been terminated.
553                  Anyway, we need to set the reusable flag to make sure
554                  that the aliveness check can clean it up. */
555               assuan_transact (primary_scd_ctx, "RESTART",
556                                NULL, NULL, NULL, NULL, NULL, NULL);
557               primary_scd_ctx_reusable = 1;
558             }
559           else
560             assuan_release (ctrl->scd_local->ctx);
561           ctrl->scd_local->ctx = NULL;
562         }
563
564       /* Remove the local context from our list and release it. */
565       if (!scd_local_list)
566         BUG ();
567       else if (scd_local_list == ctrl->scd_local)
568         scd_local_list = ctrl->scd_local->next_local;
569       else
570         {
571           struct scd_local_s *sl;
572
573           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
574             if (sl->next_local == ctrl->scd_local)
575               break;
576           if (!sl->next_local)
577             BUG ();
578           sl->next_local = ctrl->scd_local->next_local;
579         }
580       xfree (ctrl->scd_local);
581       ctrl->scd_local = NULL;
582     }
583
584   return 0;
585 }
586
587
588 \f
589 static gpg_error_t
590 learn_status_cb (void *opaque, const char *line)
591 {
592   struct learn_parm_s *parm = opaque;
593   const char *keyword = line;
594   int keywordlen;
595
596   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
597     ;
598   while (spacep (line))
599     line++;
600   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
601     {
602       parm->certinfo_cb (parm->certinfo_cb_arg, line);
603     }
604   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
605     {
606       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
607     }
608   else if (keywordlen && *line)
609     {
610       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
611     }
612
613   return 0;
614 }
615
616 /* Perform the LEARN command and return a list of all private keys
617    stored on the card. */
618 int
619 agent_card_learn (ctrl_t ctrl,
620                   void (*kpinfo_cb)(void*, const char *),
621                   void *kpinfo_cb_arg,
622                   void (*certinfo_cb)(void*, const char *),
623                   void *certinfo_cb_arg,
624                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
625                   void *sinfo_cb_arg)
626 {
627   int rc;
628   struct learn_parm_s parm;
629
630   rc = start_scd (ctrl);
631   if (rc)
632     return rc;
633
634   memset (&parm, 0, sizeof parm);
635   parm.kpinfo_cb = kpinfo_cb;
636   parm.kpinfo_cb_arg = kpinfo_cb_arg;
637   parm.certinfo_cb = certinfo_cb;
638   parm.certinfo_cb_arg = certinfo_cb_arg;
639   parm.sinfo_cb = sinfo_cb;
640   parm.sinfo_cb_arg = sinfo_cb_arg;
641   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
642                         NULL, NULL, NULL, NULL,
643                         learn_status_cb, &parm);
644   if (rc)
645     return unlock_scd (ctrl, rc);
646
647   return unlock_scd (ctrl, 0);
648 }
649
650
651 \f
652 static gpg_error_t
653 get_serialno_cb (void *opaque, const char *line)
654 {
655   char **serialno = opaque;
656   const char *keyword = line;
657   const char *s;
658   int keywordlen, n;
659
660   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
661     ;
662   while (spacep (line))
663     line++;
664
665   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
666     {
667       if (*serialno)
668         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
669       for (n=0,s=line; hexdigitp (s); s++, n++)
670         ;
671       if (!n || (n&1)|| !(spacep (s) || !*s) )
672         return gpg_error (GPG_ERR_ASS_PARAMETER);
673       *serialno = xtrymalloc (n+1);
674       if (!*serialno)
675         return out_of_core ();
676       memcpy (*serialno, line, n);
677       (*serialno)[n] = 0;
678     }
679
680   return 0;
681 }
682
683 /* Return the serial number of the card or an appropriate error.  The
684    serial number is returned as a hexstring. */
685 int
686 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
687 {
688   int rc;
689   char *serialno = NULL;
690
691   rc = start_scd (ctrl);
692   if (rc)
693     return rc;
694
695   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
696                         NULL, NULL, NULL, NULL,
697                         get_serialno_cb, &serialno);
698   if (rc)
699     {
700       xfree (serialno);
701       return unlock_scd (ctrl, rc);
702     }
703   *r_serialno = serialno;
704   return unlock_scd (ctrl, 0);
705 }
706
707
708
709 \f
710 static gpg_error_t
711 membuf_data_cb (void *opaque, const void *buffer, size_t length)
712 {
713   membuf_t *data = opaque;
714
715   if (buffer)
716     put_membuf (data, buffer, length);
717   return 0;
718 }
719
720 /* Handle the NEEDPIN inquiry. */
721 static gpg_error_t
722 inq_needpin (void *opaque, const char *line)
723 {
724   struct inq_needpin_s *parm = opaque;
725   char *pin;
726   size_t pinlen;
727   int rc;
728
729   if (!strncmp (line, "NEEDPIN", 7) && (line[7] == ' ' || !line[7]))
730     {
731       line += 7;
732       while (*line == ' ')
733         line++;
734
735       pinlen = 90;
736       pin = gcry_malloc_secure (pinlen);
737       if (!pin)
738         return out_of_core ();
739
740       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
741       if (!rc)
742         rc = assuan_send_data (parm->ctx, pin, pinlen);
743       xfree (pin);
744     }
745   else if (!strncmp (line, "POPUPKEYPADPROMPT", 17)
746            && (line[17] == ' ' || !line[17]))
747     {
748       line += 17;
749       while (*line == ' ')
750         line++;
751
752       rc = parm->getpin_cb (parm->getpin_cb_arg, line, NULL, 1);
753     }
754   else if (!strncmp (line, "DISMISSKEYPADPROMPT", 19)
755            && (line[19] == ' ' || !line[19]))
756     {
757       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
758     }
759   else if (parm->passthru)
760     {
761       unsigned char *value;
762       size_t valuelen;
763       int rest;
764       int needrest = !strncmp (line, "KEYDATA", 8);
765
766       /* Pass the inquiry up to our caller.  We limit the maximum
767          amount to an arbitrary value.  As we know that the KEYDATA
768          enquiry is pretty sensitive we disable logging then */
769       if ((rest = (needrest
770                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
771         assuan_begin_confidential (parm->passthru);
772       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
773       if (rest)
774         assuan_end_confidential (parm->passthru);
775       if (!rc)
776         {
777           if ((rest = (needrest
778                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
779             assuan_begin_confidential (parm->ctx);
780           rc = assuan_send_data (parm->ctx, value, valuelen);
781           if (rest)
782             assuan_end_confidential (parm->ctx);
783           xfree (value);
784         }
785       else
786         log_error ("error forwarding inquiry `%s': %s\n",
787                    line, gpg_strerror (rc));
788     }
789   else
790     {
791       log_error ("unsupported inquiry `%s'\n", line);
792       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
793     }
794
795   return rc;
796 }
797
798
799 /* Helper returning a command option to describe the used hash
800    algorithm.  See scd/command.c:cmd_pksign.  */
801 static const char *
802 hash_algo_option (int algo)
803 {
804   switch (algo)
805     {
806     case GCRY_MD_MD5   : return "--hash=md5";
807     case GCRY_MD_RMD160: return "--hash=rmd160";
808     case GCRY_MD_SHA1  : return "--hash=sha1";
809     case GCRY_MD_SHA224: return "--hash=sha224";
810     case GCRY_MD_SHA256: return "--hash=sha256";
811     case GCRY_MD_SHA384: return "--hash=sha384";
812     case GCRY_MD_SHA512: return "--hash=sha512";
813     default:             return "";
814     }
815 }
816
817
818 /* Create a signature using the current card.  MDALGO is either 0 or
819    gives the digest algorithm.  */
820 int
821 agent_card_pksign (ctrl_t ctrl,
822                    const char *keyid,
823                    int (*getpin_cb)(void *, const char *, char*, size_t),
824                    void *getpin_cb_arg,
825                    int mdalgo,
826                    const unsigned char *indata, size_t indatalen,
827                    unsigned char **r_buf, size_t *r_buflen)
828 {
829   int rc, i;
830   char *p, line[ASSUAN_LINELENGTH];
831   membuf_t data;
832   struct inq_needpin_s inqparm;
833   size_t len;
834   unsigned char *sigbuf;
835   size_t sigbuflen;
836   int prepend_nul;
837
838   *r_buf = NULL;
839   rc = start_scd (ctrl);
840   if (rc)
841     return rc;
842
843   if (indatalen*2 + 50 > DIM(line))
844     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
845
846   sprintf (line, "SETDATA ");
847   p = line + strlen (line);
848   for (i=0; i < indatalen ; i++, p += 2 )
849     sprintf (p, "%02X", indata[i]);
850   rc = assuan_transact (ctrl->scd_local->ctx, line,
851                         NULL, NULL, NULL, NULL, NULL, NULL);
852   if (rc)
853     return unlock_scd (ctrl, rc);
854
855   init_membuf (&data, 1024);
856   inqparm.ctx = ctrl->scd_local->ctx;
857   inqparm.getpin_cb = getpin_cb;
858   inqparm.getpin_cb_arg = getpin_cb_arg;
859   inqparm.passthru = 0;
860   if (ctrl->use_auth_call)
861     snprintf (line, sizeof line, "PKAUTH %s", keyid);
862   else
863     snprintf (line, sizeof line, "PKSIGN %s %s",
864               hash_algo_option (mdalgo), keyid);
865   rc = assuan_transact (ctrl->scd_local->ctx, line,
866                         membuf_data_cb, &data,
867                         inq_needpin, &inqparm,
868                         NULL, NULL);
869   if (rc)
870     {
871       xfree (get_membuf (&data, &len));
872       return unlock_scd (ctrl, rc);
873     }
874   sigbuf = get_membuf (&data, &sigbuflen);
875
876   /* Create an S-expression from it which is formatted like this:
877      "(7:sig-val(3:rsa(1:sSIGBUFLEN:SIGBUF)))".  We better make sure
878      that this won't be interpreted as a negative number.  */
879   prepend_nul = (sigbuflen && (*sigbuf & 0x80));
880
881   *r_buflen = 21 + 11 + prepend_nul + sigbuflen + 4;
882   p = xtrymalloc (*r_buflen);
883   *r_buf = (unsigned char*)p;
884   if (!p)
885     return unlock_scd (ctrl, out_of_core ());
886   p = stpcpy (p, "(7:sig-val(3:rsa(1:s" );
887   sprintf (p, "%u:", (unsigned int)sigbuflen + prepend_nul);
888   p += strlen (p);
889   if (prepend_nul)
890     *p++ = 0;
891   memcpy (p, sigbuf, sigbuflen);
892   p += sigbuflen;
893   strcpy (p, ")))");
894   xfree (sigbuf);
895
896   assert (gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL));
897   return unlock_scd (ctrl, 0);
898 }
899
900 /* Decipher INDATA using the current card. Note that the returned value is */
901 int
902 agent_card_pkdecrypt (ctrl_t ctrl,
903                       const char *keyid,
904                       int (*getpin_cb)(void *, const char *, char*, size_t),
905                       void *getpin_cb_arg,
906                       const unsigned char *indata, size_t indatalen,
907                       char **r_buf, size_t *r_buflen)
908 {
909   int rc, i;
910   char *p, line[ASSUAN_LINELENGTH];
911   membuf_t data;
912   struct inq_needpin_s inqparm;
913   size_t len;
914
915   *r_buf = NULL;
916   rc = start_scd (ctrl);
917   if (rc)
918     return rc;
919
920   /* FIXME: use secure memory where appropriate */
921   if (indatalen*2 + 50 > DIM(line))
922     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
923
924   sprintf (line, "SETDATA ");
925   p = line + strlen (line);
926   for (i=0; i < indatalen ; i++, p += 2 )
927     sprintf (p, "%02X", indata[i]);
928   rc = assuan_transact (ctrl->scd_local->ctx, line,
929                         NULL, NULL, NULL, NULL, NULL, NULL);
930   if (rc)
931     return unlock_scd (ctrl, rc);
932
933   init_membuf (&data, 1024);
934   inqparm.ctx = ctrl->scd_local->ctx;
935   inqparm.getpin_cb = getpin_cb;
936   inqparm.getpin_cb_arg = getpin_cb_arg;
937   inqparm.passthru = 0;
938   snprintf (line, DIM(line)-1, "PKDECRYPT %s", keyid);
939   line[DIM(line)-1] = 0;
940   rc = assuan_transact (ctrl->scd_local->ctx, line,
941                         membuf_data_cb, &data,
942                         inq_needpin, &inqparm,
943                         NULL, NULL);
944   if (rc)
945     {
946       xfree (get_membuf (&data, &len));
947       return unlock_scd (ctrl, rc);
948     }
949   *r_buf = get_membuf (&data, r_buflen);
950   if (!*r_buf)
951     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
952
953   return unlock_scd (ctrl, 0);
954 }
955
956
957 \f
958 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
959 int
960 agent_card_readcert (ctrl_t ctrl,
961                      const char *id, char **r_buf, size_t *r_buflen)
962 {
963   int rc;
964   char line[ASSUAN_LINELENGTH];
965   membuf_t data;
966   size_t len;
967
968   *r_buf = NULL;
969   rc = start_scd (ctrl);
970   if (rc)
971     return rc;
972
973   init_membuf (&data, 1024);
974   snprintf (line, DIM(line)-1, "READCERT %s", id);
975   line[DIM(line)-1] = 0;
976   rc = assuan_transact (ctrl->scd_local->ctx, line,
977                         membuf_data_cb, &data,
978                         NULL, NULL,
979                         NULL, NULL);
980   if (rc)
981     {
982       xfree (get_membuf (&data, &len));
983       return unlock_scd (ctrl, rc);
984     }
985   *r_buf = get_membuf (&data, r_buflen);
986   if (!*r_buf)
987     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
988
989   return unlock_scd (ctrl, 0);
990 }
991
992
993 \f
994 /* Read a key with ID and return it in an allocate buffer pointed to
995    by r_BUF as a valid S-expression. */
996 int
997 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
998 {
999   int rc;
1000   char line[ASSUAN_LINELENGTH];
1001   membuf_t data;
1002   size_t len, buflen;
1003
1004   *r_buf = NULL;
1005   rc = start_scd (ctrl);
1006   if (rc)
1007     return rc;
1008
1009   init_membuf (&data, 1024);
1010   snprintf (line, DIM(line)-1, "READKEY %s", id);
1011   line[DIM(line)-1] = 0;
1012   rc = assuan_transact (ctrl->scd_local->ctx, line,
1013                         membuf_data_cb, &data,
1014                         NULL, NULL,
1015                         NULL, NULL);
1016   if (rc)
1017     {
1018       xfree (get_membuf (&data, &len));
1019       return unlock_scd (ctrl, rc);
1020     }
1021   *r_buf = get_membuf (&data, &buflen);
1022   if (!*r_buf)
1023     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1024
1025   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1026     {
1027       xfree (*r_buf); *r_buf = NULL;
1028       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1029     }
1030
1031   return unlock_scd (ctrl, 0);
1032 }
1033
1034
1035 \f
1036 /* Type used with the card_getattr_cb.  */
1037 struct card_getattr_parm_s {
1038   const char *keyword;  /* Keyword to look for.  */
1039   size_t keywordlen;    /* strlen of KEYWORD.  */
1040   char *data;           /* Malloced and unescaped data.  */
1041   int error;            /* ERRNO value or 0 on success. */
1042 };
1043
1044 /* Callback function for agent_card_getattr.  */
1045 static gpg_error_t
1046 card_getattr_cb (void *opaque, const char *line)
1047 {
1048   struct card_getattr_parm_s *parm = opaque;
1049   const char *keyword = line;
1050   int keywordlen;
1051
1052   if (parm->data)
1053     return 0; /* We want only the first occurrence.  */
1054
1055   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1056     ;
1057   while (spacep (line))
1058     line++;
1059
1060   if (keywordlen == parm->keywordlen
1061       && !memcmp (keyword, parm->keyword, keywordlen))
1062     {
1063       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1064       if (!parm->data)
1065         parm->error = errno;
1066     }
1067
1068   return 0;
1069 }
1070
1071
1072 /* Call the agent to retrieve a single line data object. On success
1073    the object is malloced and stored at RESULT; it is guaranteed that
1074    NULL is never stored in this case.  On error an error code is
1075    returned and NULL stored at RESULT. */
1076 gpg_error_t
1077 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1078 {
1079   int err;
1080   struct card_getattr_parm_s parm;
1081   char line[ASSUAN_LINELENGTH];
1082
1083   *result = NULL;
1084
1085   if (!*name)
1086     return gpg_error (GPG_ERR_INV_VALUE);
1087
1088   memset (&parm, 0, sizeof parm);
1089   parm.keyword = name;
1090   parm.keywordlen = strlen (name);
1091
1092   /* We assume that NAME does not need escaping. */
1093   if (8 + strlen (name) > DIM(line)-1)
1094     return gpg_error (GPG_ERR_TOO_LARGE);
1095   stpcpy (stpcpy (line, "GETATTR "), name);
1096
1097   err = start_scd (ctrl);
1098   if (err)
1099     return err;
1100
1101   err = assuan_transact (ctrl->scd_local->ctx, line,
1102                          NULL, NULL, NULL, NULL,
1103                          card_getattr_cb, &parm);
1104   if (!err && parm.error)
1105     err = gpg_error_from_errno (parm.error);
1106
1107   if (!err && !parm.data)
1108     err = gpg_error (GPG_ERR_NO_DATA);
1109
1110   if (!err)
1111     *result = parm.data;
1112   else
1113     xfree (parm.data);
1114
1115   return unlock_scd (ctrl, err);
1116 }
1117
1118
1119
1120 \f
1121 static gpg_error_t
1122 pass_status_thru (void *opaque, const char *line)
1123 {
1124   assuan_context_t ctx = opaque;
1125   char keyword[200];
1126   int i;
1127
1128   for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1129     keyword[i] = *line;
1130   keyword[i] = 0;
1131   /* truncate any remaining keyword stuff. */
1132   for (; *line && !spacep (line); line++)
1133     ;
1134   while (spacep (line))
1135     line++;
1136
1137   assuan_write_status (ctx, keyword, line);
1138   return 0;
1139 }
1140
1141 static gpg_error_t
1142 pass_data_thru (void *opaque, const void *buffer, size_t length)
1143 {
1144   assuan_context_t ctx = opaque;
1145
1146   assuan_send_data (ctx, buffer, length);
1147   return 0;
1148 }
1149
1150
1151 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1152    all status messages back.  This command is used as a general quoting
1153    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1154    inquiry is handled inside gpg-agent.  */
1155 int
1156 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1157                 int (*getpin_cb)(void *, const char *, char*, size_t),
1158                 void *getpin_cb_arg, void *assuan_context)
1159 {
1160   int rc;
1161   struct inq_needpin_s inqparm;
1162   int saveflag;
1163
1164   rc = start_scd (ctrl);
1165   if (rc)
1166     return rc;
1167
1168   inqparm.ctx = ctrl->scd_local->ctx;
1169   inqparm.getpin_cb = getpin_cb;
1170   inqparm.getpin_cb_arg = getpin_cb_arg;
1171   inqparm.passthru = assuan_context;
1172   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1173   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1174   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1175                         pass_data_thru, assuan_context,
1176                         inq_needpin, &inqparm,
1177                         pass_status_thru, assuan_context);
1178   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1179   if (rc)
1180     {
1181       return unlock_scd (ctrl, rc);
1182     }
1183
1184   return unlock_scd (ctrl, 0);
1185 }