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