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