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
  43 #ifdef _POSIX_OPEN_MAX
  44 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
  45 #else
  46 #define MAX_OPEN_FDS 20
  47 #endif
  48
  49 /* Definition of module local data of the CTRL structure.  */
  50 struct scd_local_s
  51 {
  52   /* We keep a list of all allocated context with a an achnor at
  53      SCD_LOCAL_LIST (see below). */
  54   struct scd_local_s *next_local;
  55
  56   /* We need to get back to the ctrl object actually referencing this
  57      structure.  This is really an awkward way of enumerint the lcoal
  58      contects.  A much cleaner way would be to keep a global list of
  59      ctrl objects to enumerate them.  */
  60   ctrl_t ctrl_backlink;
  61
  62   assuan_context_t ctx; /* NULL or session context for the SCdaemon
  63                            used with this connection. */
  64   int locked;           /* This flag is used to assert proper use of
  65                            start_scd and unlock_scd. */
  66
  67 };
  68
  69
  70 /* Callback parameter for learn card */
  71 struct learn_parm_s
  72 {
  73   void (*kpinfo_cb)(void*, const char *);
  74   void *kpinfo_cb_arg;
  75   void (*certinfo_cb)(void*, const char *);
  76   void *certinfo_cb_arg;
  77   void (*sinfo_cb)(void*, const char *, size_t, const char *);
  78   void *sinfo_cb_arg;
  79 };
  80
  81 struct inq_needpin_s
  82 {
  83   assuan_context_t ctx;
  84   int (*getpin_cb)(void *, const char *, char*, size_t);
  85   void *getpin_cb_arg;
  86   assuan_context_t passthru;  /* If not NULL, pass unknown inquiries
  87                                  up to the caller.  */
  88   int any_inq_seen;
  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 infromation 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   if (ctrl->scd_local->locked != 1)
 165     {
 166       log_error ("unlock_scd: invalid lock count (%d)\n",
 167                  ctrl->scd_local->locked);
 168       if (!rc)
 169         rc = gpg_error (GPG_ERR_INTERNAL);
 170     }
 171   ctrl->scd_local->locked = 0;
 172   return rc;
 173 }
 174
 175 /* To make sure we leave no secrets in our image after forking of the
 176    scdaemon, we use this callback. */
 177 static void
 178 atfork_cb (void *opaque, int where)
 179 {
 180   (void)opaque;
 181
 182   if (!where)
 183     gcry_control (GCRYCTL_TERM_SECMEM);
 184 }
 185
 186
 187 /* Fork off the SCdaemon if this has not already been done.  Lock the
 188    daemon and make sure that a proper context has been setup in CTRL.
 189    This function might also lock the daemon, which means that the
 190    caller must call unlock_scd after this function has returned
 191    success and the actual Assuan transaction been done. */
 192 static int
 193 start_scd (ctrl_t ctrl)
 194 {
 195   gpg_error_t err = 0;
 196   const char *pgmname;
 197   assuan_context_t ctx = NULL;
 198   const char *argv[5];
 199   assuan_fd_t no_close_list[3];
 200   int i;
 201   int rc;
 202   char *abs_homedir = NULL;
 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   if (gnupg_default_homedir_p ())
 318     argv[2] = NULL;
 319   else
 320     {
 321       abs_homedir = make_absfilename_try (gnupg_homedir (), NULL);
 322       if (!abs_homedir)
 323         {
 324           log_error ("error building filename: %s\n",
 325                      gpg_strerror (gpg_error_from_syserror ()));
 326           goto leave;
 327         }
 328
 329       argv[2] = "--homedir";
 330       argv[3] = abs_homedir;
 331       argv[4] = NULL;
 332     }
 333
 334   i=0;
 335   if (!opt.running_detached)
 336     {
 337       if (log_get_fd () != -1)
 338         no_close_list[i++] = assuan_fd_from_posix_fd (log_get_fd ());
 339       no_close_list[i++] = assuan_fd_from_posix_fd (fileno (stderr));
 340     }
 341   no_close_list[i] = ASSUAN_INVALID_FD;
 342
 343   /* Connect to the scdaemon and perform initial handshaking.  Use
 344      detached flag so that under Windows SCDAEMON does not show up a
 345      new window.  */
 346   rc = assuan_pipe_connect (ctx, opt.scdaemon_program, argv,
 347                             no_close_list, atfork_cb, NULL,
 348                             ASSUAN_PIPE_CONNECT_DETACHED);
 349   if (rc)
 350     {
 351       log_error ("can't connect to the SCdaemon: %s\n",
 352                  gpg_strerror (rc));
 353       err = gpg_error (GPG_ERR_NO_SCDAEMON);
 354       goto leave;
 355     }
 356
 357   if (opt.verbose)
 358     log_debug ("first connection to SCdaemon established\n");
 359
 360
 361   /* Get the name of the additional socket opened by scdaemon. */
 362   {
 363     membuf_t data;
 364     unsigned char *databuf;
 365     size_t datalen;
 366
 367     xfree (socket_name);
 368     socket_name = NULL;
 369     init_membuf (&data, 256);
 370     assuan_transact (ctx, "GETINFO socket_name",
 371                      put_membuf_cb, &data, NULL, NULL, NULL, NULL);
 372
 373     databuf = get_membuf (&data, &datalen);
 374     if (databuf && datalen)
 375       {
 376         socket_name = xtrymalloc (datalen + 1);
 377         if (!socket_name)
 378           log_error ("warning: can't store socket name: %s\n",
 379                      strerror (errno));
 380         else
 381           {
 382             memcpy (socket_name, databuf, datalen);
 383             socket_name[datalen] = 0;
 384             if (DBG_IPC)
 385               log_debug ("additional connections at '%s'\n", socket_name);
 386           }
 387       }
 388     xfree (databuf);
 389   }
 390
 391   /* Tell the scdaemon we want him to send us an event signal.  We
 392      don't support this for W32CE.  */
 393 #ifndef HAVE_W32CE_SYSTEM
 394   if (opt.sigusr2_enabled)
 395     {
 396       char buf[100];
 397
 398 #ifdef HAVE_W32_SYSTEM
 399       snprintf (buf, sizeof buf, "OPTION event-signal=%lx",
 400                 (unsigned long)get_agent_scd_notify_event ());
 401 #else
 402       snprintf (buf, sizeof buf, "OPTION event-signal=%d", SIGUSR2);
 403 #endif
 404       assuan_transact (ctx, buf, NULL, NULL, NULL, NULL, NULL, NULL);
 405     }
 406 #endif /*HAVE_W32CE_SYSTEM*/
 407
 408   primary_scd_ctx = ctx;
 409   primary_scd_ctx_reusable = 0;
 410
 411  leave:
 412   xfree (abs_homedir);
 413   if (err)
 414     {
 415       unlock_scd (ctrl, err);
 416       if (ctx)
 417         assuan_release (ctx);
 418     }
 419   else
 420     {
 421       ctrl->scd_local->ctx = ctx;
 422     }
 423   rc = npth_mutex_unlock (&start_scd_lock);
 424   if (rc)
 425     log_error ("failed to release the start_scd lock: %s\n", strerror (rc));
 426   return err;
 427 }
 428
 429
 430 /* Check whether the SCdaemon is active.  This is a fast check without
 431    any locking and might give a wrong result if another thread is about
 432    to start the daemon or the daemon is about to be stopped.. */
 433 int
 434 agent_scd_check_running (void)
 435 {
 436   return !!primary_scd_ctx;
 437 }
 438
 439
 440 /* Check whether the Scdaemon is still alive and clean it up if not. */
 441 void
 442 agent_scd_check_aliveness (void)
 443 {
 444   pid_t pid;
 445 #ifdef HAVE_W32_SYSTEM
 446   DWORD rc;
 447 #else
 448   int rc;
 449 #endif
 450   struct timespec abstime;
 451   int err;
 452
 453   if (!primary_scd_ctx)
 454     return; /* No scdaemon running. */
 455
 456   /* This is not a critical function so we use a short timeout while
 457      acquiring the lock.  */
 458   npth_clock_gettime (&abstime);
 459   abstime.tv_sec += 1;
 460   err = npth_mutex_timedlock (&start_scd_lock, &abstime);
 461   if (err)
 462     {
 463       if (err == ETIMEDOUT)
 464         {
 465           if (opt.verbose > 1)
 466             log_info ("failed to acquire the start_scd lock while"
 467                       " doing an aliveness check: %s\n", strerror (err));
 468         }
 469       else
 470         log_error ("failed to acquire the start_scd lock while"
 471                    " doing an aliveness check: %s\n", strerror (err));
 472       return;
 473     }
 474
 475   if (primary_scd_ctx)
 476     {
 477       pid = assuan_get_pid (primary_scd_ctx);
 478 #ifdef HAVE_W32_SYSTEM
 479       /* If we have a PID we disconnect if either GetExitProcessCode
 480          fails or if ir returns the exit code of the scdaemon.  259 is
 481          the error code for STILL_ALIVE.  */
 482       if (pid != (pid_t)(void*)(-1) && pid
 483           && (!GetExitCodeProcess ((HANDLE)pid, &rc) || rc != 259))
 484 #else
 485       if (pid != (pid_t)(-1) && pid
 486           && ((rc=waitpid (pid, NULL, WNOHANG))==-1 || (rc == pid)) )
 487 #endif
 488         {
 489           /* Okay, scdaemon died.  Disconnect the primary connection
 490              now but take care that it won't do another wait. Also
 491              cleanup all other connections and release their
 492              resources.  The next use will start a new daemon then.
 493              Due to the use of the START_SCD_LOCAL we are sure that
 494              none of these context are actually in use. */
 495           struct scd_local_s *sl;
 496
 497           assuan_set_flag (primary_scd_ctx, ASSUAN_NO_WAITPID, 1);
 498           assuan_release (primary_scd_ctx);
 499
 500           for (sl=scd_local_list; sl; sl = sl->next_local)
 501             {
 502               if (sl->ctx)
 503                 {
 504                   if (sl->ctx != primary_scd_ctx)
 505                     assuan_release (sl->ctx);
 506                   sl->ctx = NULL;
 507                 }
 508             }
 509
 510           primary_scd_ctx = NULL;
 511           primary_scd_ctx_reusable = 0;
 512
 513           xfree (socket_name);
 514           socket_name = NULL;
 515         }
 516     }
 517
 518   err = npth_mutex_unlock (&start_scd_lock);
 519   if (err)
 520     log_error ("failed to release the start_scd lock while"
 521                " doing the aliveness check: %s\n", strerror (err));
 522 }
 523
 524
 525
 526 /* Reset the SCD if it has been used.  Actually it is not a reset but
 527    a cleanup of resources used by the current connection. */
 528 int
 529 agent_reset_scd (ctrl_t ctrl)
 530 {
 531   if (ctrl->scd_local)
 532     {
 533       if (ctrl->scd_local->ctx)
 534         {
 535           /* We can't disconnect the primary context because libassuan
 536              does a waitpid on it and thus the system would hang.
 537              Instead we send a reset and keep that connection for
 538              reuse. */
 539           if (ctrl->scd_local->ctx == primary_scd_ctx)
 540             {
 541               /* Send a RESTART to the SCD.  This is required for the
 542                  primary connection as a kind of virtual EOF; we don't
 543                  have another way to tell it that the next command
 544                  should be viewed as if a new connection has been
 545                  made.  For the non-primary connections this is not
 546                  needed as we simply close the socket.  We don't check
 547                  for an error here because the RESTART may fail for
 548                  example if the scdaemon has already been terminated.
 549                  Anyway, we need to set the reusable flag to make sure
 550                  that the aliveness check can clean it up. */
 551               assuan_transact (primary_scd_ctx, "RESTART",
 552                                NULL, NULL, NULL, NULL, NULL, NULL);
 553               primary_scd_ctx_reusable = 1;
 554             }
 555           else
 556             assuan_release (ctrl->scd_local->ctx);
 557           ctrl->scd_local->ctx = NULL;
 558         }
 559
 560       /* Remove the local context from our list and release it. */
 561       if (!scd_local_list)
 562         BUG ();
 563       else if (scd_local_list == ctrl->scd_local)
 564         scd_local_list = ctrl->scd_local->next_local;
 565       else
 566         {
 567           struct scd_local_s *sl;
 568
 569           for (sl=scd_local_list; sl->next_local; sl = sl->next_local)
 570             if (sl->next_local == ctrl->scd_local)
 571               break;
 572           if (!sl->next_local)
 573             BUG ();
 574           sl->next_local = ctrl->scd_local->next_local;
 575         }
 576       xfree (ctrl->scd_local);
 577       ctrl->scd_local = NULL;
 578     }
 579
 580   return 0;
 581 }
 582
 583
 584 \f
 585 static gpg_error_t
 586 learn_status_cb (void *opaque, const char *line)
 587 {
 588   struct learn_parm_s *parm = opaque;
 589   const char *keyword = line;
 590   int keywordlen;
 591
 592   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 593     ;
 594   while (spacep (line))
 595     line++;
 596   if (keywordlen == 8 && !memcmp (keyword, "CERTINFO", keywordlen))
 597     {
 598       parm->certinfo_cb (parm->certinfo_cb_arg, line);
 599     }
 600   else if (keywordlen == 11 && !memcmp (keyword, "KEYPAIRINFO", keywordlen))
 601     {
 602       parm->kpinfo_cb (parm->kpinfo_cb_arg, line);
 603     }
 604   else if (keywordlen && *line)
 605     {
 606       parm->sinfo_cb (parm->sinfo_cb_arg, keyword, keywordlen, line);
 607     }
 608
 609   return 0;
 610 }
 611
 612 /* Perform the LEARN command and return a list of all private keys
 613    stored on the card. */
 614 int
 615 agent_card_learn (ctrl_t ctrl,
 616                   void (*kpinfo_cb)(void*, const char *),
 617                   void *kpinfo_cb_arg,
 618                   void (*certinfo_cb)(void*, const char *),
 619                   void *certinfo_cb_arg,
 620                   void (*sinfo_cb)(void*, const char *, size_t, const char *),
 621                   void *sinfo_cb_arg)
 622 {
 623   int rc;
 624   struct learn_parm_s parm;
 625
 626   rc = start_scd (ctrl);
 627   if (rc)
 628     return rc;
 629
 630   memset (&parm, 0, sizeof parm);
 631   parm.kpinfo_cb = kpinfo_cb;
 632   parm.kpinfo_cb_arg = kpinfo_cb_arg;
 633   parm.certinfo_cb = certinfo_cb;
 634   parm.certinfo_cb_arg = certinfo_cb_arg;
 635   parm.sinfo_cb = sinfo_cb;
 636   parm.sinfo_cb_arg = sinfo_cb_arg;
 637   rc = assuan_transact (ctrl->scd_local->ctx, "LEARN --force",
 638                         NULL, NULL, NULL, NULL,
 639                         learn_status_cb, &parm);
 640   if (rc)
 641     return unlock_scd (ctrl, rc);
 642
 643   return unlock_scd (ctrl, 0);
 644 }
 645
 646
 647 \f
 648 static gpg_error_t
 649 get_serialno_cb (void *opaque, const char *line)
 650 {
 651   char **serialno = opaque;
 652   const char *keyword = line;
 653   const char *s;
 654   int keywordlen, n;
 655
 656   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
 657     ;
 658   while (spacep (line))
 659     line++;
 660
 661   if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
 662     {
 663       if (*serialno)
 664         return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
 665       for (n=0,s=line; hexdigitp (s); s++, n++)
 666         ;
 667       if (!n || (n&1)|| !(spacep (s) || !*s) )
 668         return gpg_error (GPG_ERR_ASS_PARAMETER);
 669       *serialno = xtrymalloc (n+1);
 670       if (!*serialno)
 671         return out_of_core ();
 672       memcpy (*serialno, line, n);
 673       (*serialno)[n] = 0;
 674     }
 675
 676   return 0;
 677 }
 678
 679 /* Return the serial number of the card or an appropriate error.  The
 680    serial number is returned as a hexstring. */
 681 int
 682 agent_card_serialno (ctrl_t ctrl, char **r_serialno)
 683 {
 684   int rc;
 685   char *serialno = NULL;
 686
 687   rc = start_scd (ctrl);
 688   if (rc)
 689     return rc;
 690
 691   rc = assuan_transact (ctrl->scd_local->ctx, "SERIALNO",
 692                         NULL, NULL, NULL, NULL,
 693                         get_serialno_cb, &serialno);
 694   if (rc)
 695     {
 696       xfree (serialno);
 697       return unlock_scd (ctrl, rc);
 698     }
 699   *r_serialno = serialno;
 700   return unlock_scd (ctrl, 0);
 701 }
 702
 703
 704
 705 \f
 706 /* Handle the NEEDPIN inquiry. */
 707 static gpg_error_t
 708 inq_needpin (void *opaque, const char *line)
 709 {
 710   struct inq_needpin_s *parm = opaque;
 711   const char *s;
 712   char *pin;
 713   size_t pinlen;
 714   int rc;
 715
 716   parm->any_inq_seen = 1;
 717   if ((s = has_leading_keyword (line, "NEEDPIN")))
 718     {
 719       line = s;
 720       pinlen = 90;
 721       pin = gcry_malloc_secure (pinlen);
 722       if (!pin)
 723         return out_of_core ();
 724
 725       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
 726       if (!rc)
 727         rc = assuan_send_data (parm->ctx, pin, pinlen);
 728       xfree (pin);
 729     }
 730   else if ((s = has_leading_keyword (line, "POPUPPINPADPROMPT")))
 731     {
 732       rc = parm->getpin_cb (parm->getpin_cb_arg, s, NULL, 1);
 733     }
 734   else if ((s = has_leading_keyword (line, "DISMISSPINPADPROMPT")))
 735     {
 736       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
 737     }
 738   else if (parm->passthru)
 739     {
 740       unsigned char *value;
 741       size_t valuelen;
 742       int rest;
 743       int needrest = !strncmp (line, "KEYDATA", 8);
 744
 745       /* Pass the inquiry up to our caller.  We limit the maximum
 746          amount to an arbitrary value.  As we know that the KEYDATA
 747          enquiry is pretty sensitive we disable logging then */
 748       if ((rest = (needrest
 749                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
 750         assuan_begin_confidential (parm->passthru);
 751       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
 752       if (rest)
 753         assuan_end_confidential (parm->passthru);
 754       if (!rc)
 755         {
 756           if ((rest = (needrest
 757                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
 758             assuan_begin_confidential (parm->ctx);
 759           rc = assuan_send_data (parm->ctx, value, valuelen);
 760           if (rest)
 761             assuan_end_confidential (parm->ctx);
 762           xfree (value);
 763         }
 764       else
 765         log_error ("error forwarding inquiry '%s': %s\n",
 766                    line, gpg_strerror (rc));
 767     }
 768   else
 769     {
 770       log_error ("unsupported inquiry '%s'\n", line);
 771       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
 772     }
 773
 774   return rc;
 775 }
 776
 777
 778 /* Helper returning a command option to describe the used hash
 779    algorithm.  See scd/command.c:cmd_pksign.  */
 780 static const char *
 781 hash_algo_option (int algo)
 782 {
 783   switch (algo)
 784     {
 785     case GCRY_MD_MD5   : return "--hash=md5";
 786     case GCRY_MD_RMD160: return "--hash=rmd160";
 787     case GCRY_MD_SHA1  : return "--hash=sha1";
 788     case GCRY_MD_SHA224: return "--hash=sha224";
 789     case GCRY_MD_SHA256: return "--hash=sha256";
 790     case GCRY_MD_SHA384: return "--hash=sha384";
 791     case GCRY_MD_SHA512: return "--hash=sha512";
 792     default:             return "";
 793     }
 794 }
 795
 796
 797 static gpg_error_t
 798 cancel_inquire (ctrl_t ctrl, gpg_error_t rc)
 799 {
 800   gpg_error_t oldrc = rc;
 801
 802   /* The inquire callback was called and transact returned a
 803      cancel error.  We assume that the inquired process sent a
 804      CANCEL.  The passthrough code is not able to pass on the
 805      CANCEL and thus scdaemon would stuck on this.  As a
 806      workaround we send a CANCEL now.  */
 807   rc = assuan_write_line (ctrl->scd_local->ctx, "CAN");
 808   if (!rc) {
 809     char *line;
 810     size_t len;
 811
 812     rc = assuan_read_line (ctrl->scd_local->ctx, &line, &len);
 813     if (!rc)
 814       rc = oldrc;
 815   }
 816
 817   return rc;
 818 }
 819
 820 /* Create a signature using the current card.  MDALGO is either 0 or
 821    gives the digest algorithm.  */
 822 int
 823 agent_card_pksign (ctrl_t ctrl,
 824                    const char *keyid,
 825                    int (*getpin_cb)(void *, const char *, char*, size_t),
 826                    void *getpin_cb_arg,
 827                    int mdalgo,
 828                    const unsigned char *indata, size_t indatalen,
 829                    unsigned char **r_buf, size_t *r_buflen)
 830 {
 831   int rc;
 832   char line[ASSUAN_LINELENGTH];
 833   membuf_t data;
 834   struct inq_needpin_s inqparm;
 835
 836   *r_buf = NULL;
 837   rc = start_scd (ctrl);
 838   if (rc)
 839     return rc;
 840
 841   if (indatalen*2 + 50 > DIM(line))
 842     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
 843
 844   bin2hex (indata, indatalen, stpcpy (line, "SETDATA "));
 845
 846   rc = assuan_transact (ctrl->scd_local->ctx, line,
 847                         NULL, NULL, NULL, NULL, NULL, NULL);
 848   if (rc)
 849     return unlock_scd (ctrl, rc);
 850
 851   init_membuf (&data, 1024);
 852   inqparm.ctx = ctrl->scd_local->ctx;
 853   inqparm.getpin_cb = getpin_cb;
 854   inqparm.getpin_cb_arg = getpin_cb_arg;
 855   inqparm.passthru = 0;
 856   inqparm.any_inq_seen = 0;
 857   if (ctrl->use_auth_call)
 858     snprintf (line, sizeof line, "PKAUTH %s", keyid);
 859   else
 860     snprintf (line, sizeof line, "PKSIGN %s %s",
 861               hash_algo_option (mdalgo), keyid);
 862   rc = assuan_transact (ctrl->scd_local->ctx, line,
 863                         put_membuf_cb, &data,
 864                         inq_needpin, &inqparm,
 865                         NULL, NULL);
 866   if (inqparm.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
 867         gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
 868     rc = cancel_inquire (ctrl, rc);
 869
 870   if (rc)
 871     {
 872       size_t len;
 873
 874       xfree (get_membuf (&data, &len));
 875       return unlock_scd (ctrl, rc);
 876     }
 877
 878   *r_buf = get_membuf (&data, r_buflen);
 879   return unlock_scd (ctrl, 0);
 880 }
 881
 882
 883
 884 \f
 885 /* Check whether there is any padding info from scdaemon.  */
 886 static gpg_error_t
 887 padding_info_cb (void *opaque, const char *line)
 888 {
 889   int *r_padding = opaque;
 890   const char *s;
 891
 892   if ((s=has_leading_keyword (line, "PADDING")))
 893     {
 894       *r_padding = atoi (s);
 895     }
 896
 897   return 0;
 898 }
 899
 900
 901 /* Decipher INDATA using the current card.  Note that the returned
 902    value is not an s-expression but the raw data as returned by
 903    scdaemon.  The padding information is stored at R_PADDING with -1
 904    for not known.  */
 905 int
 906 agent_card_pkdecrypt (ctrl_t ctrl,
 907                       const char *keyid,
 908                       int (*getpin_cb)(void *, const char *, char*, size_t),
 909                       void *getpin_cb_arg,
 910                       const unsigned char *indata, size_t indatalen,
 911                       char **r_buf, size_t *r_buflen, int *r_padding)
 912 {
 913   int rc, i;
 914   char *p, line[ASSUAN_LINELENGTH];
 915   membuf_t data;
 916   struct inq_needpin_s inqparm;
 917   size_t len;
 918
 919   *r_buf = NULL;
 920   *r_padding = -1; /* Unknown.  */
 921   rc = start_scd (ctrl);
 922   if (rc)
 923     return rc;
 924
 925   /* FIXME: use secure memory where appropriate */
 926
 927   for (len = 0; len < indatalen;)
 928     {
 929       p = stpcpy (line, "SETDATA ");
 930       if (len)
 931         p = stpcpy (p, "--append ");
 932       for (i=0; len < indatalen && (i*2 < DIM(line)-50); i++, len++)
 933         {
 934           sprintf (p, "%02X", indata[len]);
 935           p += 2;
 936         }
 937       rc = assuan_transact (ctrl->scd_local->ctx, line,
 938                             NULL, NULL, NULL, NULL, NULL, NULL);
 939       if (rc)
 940         return unlock_scd (ctrl, rc);
 941     }
 942
 943   init_membuf (&data, 1024);
 944   inqparm.ctx = ctrl->scd_local->ctx;
 945   inqparm.getpin_cb = getpin_cb;
 946   inqparm.getpin_cb_arg = getpin_cb_arg;
 947   inqparm.passthru = 0;
 948   inqparm.any_inq_seen = 0;
 949   snprintf (line, DIM(line), "PKDECRYPT %s", keyid);
 950   rc = assuan_transact (ctrl->scd_local->ctx, line,
 951                         put_membuf_cb, &data,
 952                         inq_needpin, &inqparm,
 953                         padding_info_cb, r_padding);
 954   if (inqparm.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
 955         gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
 956     rc = cancel_inquire (ctrl, rc);
 957
 958   if (rc)
 959     {
 960       xfree (get_membuf (&data, &len));
 961       return unlock_scd (ctrl, rc);
 962     }
 963   *r_buf = get_membuf (&data, r_buflen);
 964   if (!*r_buf)
 965     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
 966
 967   return unlock_scd (ctrl, 0);
 968 }
 969
 970
 971 \f
 972 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
 973 int
 974 agent_card_readcert (ctrl_t ctrl,
 975                      const char *id, char **r_buf, size_t *r_buflen)
 976 {
 977   int rc;
 978   char line[ASSUAN_LINELENGTH];
 979   membuf_t data;
 980   size_t len;
 981
 982   *r_buf = NULL;
 983   rc = start_scd (ctrl);
 984   if (rc)
 985     return rc;
 986
 987   init_membuf (&data, 1024);
 988   snprintf (line, DIM(line), "READCERT %s", id);
 989   rc = assuan_transact (ctrl->scd_local->ctx, line,
 990                         put_membuf_cb, &data,
 991                         NULL, NULL,
 992                         NULL, NULL);
 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 key with ID and return it in an allocate buffer pointed to
1008    by r_BUF as a valid S-expression. */
1009 int
1010 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1011 {
1012   int rc;
1013   char line[ASSUAN_LINELENGTH];
1014   membuf_t data;
1015   size_t len, buflen;
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), "READKEY %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, &buflen);
1034   if (!*r_buf)
1035     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1036
1037   if (!gcry_sexp_canon_len (*r_buf, buflen, NULL, NULL))
1038     {
1039       xfree (*r_buf); *r_buf = NULL;
1040       return unlock_scd (ctrl, gpg_error (GPG_ERR_INV_VALUE));
1041     }
1042
1043   return unlock_scd (ctrl, 0);
1044 }
1045
1046
1047 struct writekey_parm_s
1048 {
1049   assuan_context_t ctx;
1050   int (*getpin_cb)(void *, const char *, char*, size_t);
1051   void *getpin_cb_arg;
1052   assuan_context_t passthru;
1053   int any_inq_seen;
1054   /**/
1055   const unsigned char *keydata;
1056   size_t keydatalen;
1057 };
1058
1059 /* Handle a KEYDATA inquiry.  Note, we only send the data,
1060    assuan_transact takes care of flushing and writing the end */
1061 static gpg_error_t
1062 inq_writekey_parms (void *opaque, const char *line)
1063 {
1064   struct writekey_parm_s *parm = opaque;
1065
1066   if (has_leading_keyword (line, "KEYDATA"))
1067     return assuan_send_data (parm->ctx, parm->keydata, parm->keydatalen);
1068   else
1069     return inq_needpin (opaque, line);
1070 }
1071
1072
1073 int
1074 agent_card_writekey (ctrl_t ctrl,  int force, const char *serialno,
1075                      const char *id, const char *keydata, size_t keydatalen,
1076                      int (*getpin_cb)(void *, const char *, char*, size_t),
1077                      void *getpin_cb_arg)
1078 {
1079   int rc;
1080   char line[ASSUAN_LINELENGTH];
1081   struct writekey_parm_s parms;
1082
1083   (void)serialno;
1084   rc = start_scd (ctrl);
1085   if (rc)
1086     return rc;
1087
1088   snprintf (line, DIM(line), "WRITEKEY %s%s", force ? "--force " : "", id);
1089   parms.ctx = ctrl->scd_local->ctx;
1090   parms.getpin_cb = getpin_cb;
1091   parms.getpin_cb_arg = getpin_cb_arg;
1092   parms.passthru = 0;
1093   parms.any_inq_seen = 0;
1094   parms.keydata = keydata;
1095   parms.keydatalen = keydatalen;
1096
1097   rc = assuan_transact (ctrl->scd_local->ctx, line, NULL, NULL,
1098                         inq_writekey_parms, &parms, NULL, NULL);
1099   if (parms.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
1100                              gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
1101     rc = cancel_inquire (ctrl, rc);
1102   return unlock_scd (ctrl, rc);
1103 }
1104 \f
1105 /* Type used with the card_getattr_cb.  */
1106 struct card_getattr_parm_s {
1107   const char *keyword;  /* Keyword to look for.  */
1108   size_t keywordlen;    /* strlen of KEYWORD.  */
1109   char *data;           /* Malloced and unescaped data.  */
1110   int error;            /* ERRNO value or 0 on success. */
1111 };
1112
1113 /* Callback function for agent_card_getattr.  */
1114 static gpg_error_t
1115 card_getattr_cb (void *opaque, const char *line)
1116 {
1117   struct card_getattr_parm_s *parm = opaque;
1118   const char *keyword = line;
1119   int keywordlen;
1120
1121   if (parm->data)
1122     return 0; /* We want only the first occurrence.  */
1123
1124   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1125     ;
1126   while (spacep (line))
1127     line++;
1128
1129   if (keywordlen == parm->keywordlen
1130       && !memcmp (keyword, parm->keyword, keywordlen))
1131     {
1132       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1133       if (!parm->data)
1134         parm->error = errno;
1135     }
1136
1137   return 0;
1138 }
1139
1140
1141 /* Call the agent to retrieve a single line data object. On success
1142    the object is malloced and stored at RESULT; it is guaranteed that
1143    NULL is never stored in this case.  On error an error code is
1144    returned and NULL stored at RESULT. */
1145 gpg_error_t
1146 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1147 {
1148   int err;
1149   struct card_getattr_parm_s parm;
1150   char line[ASSUAN_LINELENGTH];
1151
1152   *result = NULL;
1153
1154   if (!*name)
1155     return gpg_error (GPG_ERR_INV_VALUE);
1156
1157   memset (&parm, 0, sizeof parm);
1158   parm.keyword = name;
1159   parm.keywordlen = strlen (name);
1160
1161   /* We assume that NAME does not need escaping. */
1162   if (8 + strlen (name) > DIM(line)-1)
1163     return gpg_error (GPG_ERR_TOO_LARGE);
1164   stpcpy (stpcpy (line, "GETATTR "), name);
1165
1166   err = start_scd (ctrl);
1167   if (err)
1168     return err;
1169
1170   err = assuan_transact (ctrl->scd_local->ctx, line,
1171                          NULL, NULL, NULL, NULL,
1172                          card_getattr_cb, &parm);
1173   if (!err && parm.error)
1174     err = gpg_error_from_errno (parm.error);
1175
1176   if (!err && !parm.data)
1177     err = gpg_error (GPG_ERR_NO_DATA);
1178
1179   if (!err)
1180     *result = parm.data;
1181   else
1182     xfree (parm.data);
1183
1184   return unlock_scd (ctrl, err);
1185 }
1186
1187
1188
1189 \f
1190 static gpg_error_t
1191 pass_status_thru (void *opaque, const char *line)
1192 {
1193   assuan_context_t ctx = opaque;
1194   char keyword[200];
1195   int i;
1196
1197   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1198     {
1199       /* We are called in convey comments mode.  Now, if we see a
1200          comment marker as keyword we forward the line verbatim to the
1201          the caller.  This way the comment lines from scdaemon won't
1202          appear as status lines with keyword '#'.  */
1203       assuan_write_line (ctx, line);
1204     }
1205   else
1206     {
1207       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1208         keyword[i] = *line;
1209       keyword[i] = 0;
1210
1211       /* Truncate any remaining keyword stuff.  */
1212       for (; *line && !spacep (line); line++)
1213         ;
1214       while (spacep (line))
1215         line++;
1216
1217       assuan_write_status (ctx, keyword, line);
1218     }
1219   return 0;
1220 }
1221
1222 static gpg_error_t
1223 pass_data_thru (void *opaque, const void *buffer, size_t length)
1224 {
1225   assuan_context_t ctx = opaque;
1226
1227   assuan_send_data (ctx, buffer, length);
1228   return 0;
1229 }
1230
1231
1232 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1233    all status messages back.  This command is used as a general quoting
1234    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1235    inquiry is handled inside gpg-agent.  */
1236 int
1237 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1238                 int (*getpin_cb)(void *, const char *, char*, size_t),
1239                 void *getpin_cb_arg, void *assuan_context)
1240 {
1241   int rc;
1242   struct inq_needpin_s inqparm;
1243   int saveflag;
1244
1245   rc = start_scd (ctrl);
1246   if (rc)
1247     return rc;
1248
1249   inqparm.ctx = ctrl->scd_local->ctx;
1250   inqparm.getpin_cb = getpin_cb;
1251   inqparm.getpin_cb_arg = getpin_cb_arg;
1252   inqparm.passthru = assuan_context;
1253   inqparm.any_inq_seen = 0;
1254   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1255   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1256   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1257                         pass_data_thru, assuan_context,
1258                         inq_needpin, &inqparm,
1259                         pass_status_thru, assuan_context);
1260   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1261     rc = cancel_inquire (ctrl, rc);
1262
1263   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1264   if (rc)
1265     {
1266       return unlock_scd (ctrl, rc);
1267     }
1268
1269   return unlock_scd (ctrl, 0);
1270 }