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, const char *demand)
 683 {
 684   int rc;
 685   char *serialno = NULL;
 686   char line[ASSUAN_LINELENGTH];
 687
 688   rc = start_scd (ctrl);
 689   if (rc)
 690     return rc;
 691
 692   if (!demand)
 693     strcpy (line, "SERIALNO");
 694   else
 695     snprintf (line, DIM(line), "SERIALNO --demand=%s", demand);
 696
 697   rc = assuan_transact (ctrl->scd_local->ctx, line,
 698                         NULL, NULL, NULL, NULL,
 699                         get_serialno_cb, &serialno);
 700   if (rc)
 701     {
 702       xfree (serialno);
 703       return unlock_scd (ctrl, rc);
 704     }
 705   *r_serialno = serialno;
 706   return unlock_scd (ctrl, 0);
 707 }
 708
 709
 710
 711 \f
 712 /* Handle the NEEDPIN inquiry. */
 713 static gpg_error_t
 714 inq_needpin (void *opaque, const char *line)
 715 {
 716   struct inq_needpin_s *parm = opaque;
 717   const char *s;
 718   char *pin;
 719   size_t pinlen;
 720   int rc;
 721
 722   parm->any_inq_seen = 1;
 723   if ((s = has_leading_keyword (line, "NEEDPIN")))
 724     {
 725       line = s;
 726       pinlen = 90;
 727       pin = gcry_malloc_secure (pinlen);
 728       if (!pin)
 729         return out_of_core ();
 730
 731       rc = parm->getpin_cb (parm->getpin_cb_arg, line, pin, pinlen);
 732       if (!rc)
 733         rc = assuan_send_data (parm->ctx, pin, pinlen);
 734       xfree (pin);
 735     }
 736   else if ((s = has_leading_keyword (line, "POPUPPINPADPROMPT")))
 737     {
 738       rc = parm->getpin_cb (parm->getpin_cb_arg, s, NULL, 1);
 739     }
 740   else if ((s = has_leading_keyword (line, "DISMISSPINPADPROMPT")))
 741     {
 742       rc = parm->getpin_cb (parm->getpin_cb_arg, "", NULL, 0);
 743     }
 744   else if (parm->passthru)
 745     {
 746       unsigned char *value;
 747       size_t valuelen;
 748       int rest;
 749       int needrest = !strncmp (line, "KEYDATA", 8);
 750
 751       /* Pass the inquiry up to our caller.  We limit the maximum
 752          amount to an arbitrary value.  As we know that the KEYDATA
 753          enquiry is pretty sensitive we disable logging then */
 754       if ((rest = (needrest
 755                    && !assuan_get_flag (parm->passthru, ASSUAN_CONFIDENTIAL))))
 756         assuan_begin_confidential (parm->passthru);
 757       rc = assuan_inquire (parm->passthru, line, &value, &valuelen, 8096);
 758       if (rest)
 759         assuan_end_confidential (parm->passthru);
 760       if (!rc)
 761         {
 762           if ((rest = (needrest
 763                        && !assuan_get_flag (parm->ctx, ASSUAN_CONFIDENTIAL))))
 764             assuan_begin_confidential (parm->ctx);
 765           rc = assuan_send_data (parm->ctx, value, valuelen);
 766           if (rest)
 767             assuan_end_confidential (parm->ctx);
 768           xfree (value);
 769         }
 770       else
 771         log_error ("error forwarding inquiry '%s': %s\n",
 772                    line, gpg_strerror (rc));
 773     }
 774   else
 775     {
 776       log_error ("unsupported inquiry '%s'\n", line);
 777       rc = gpg_error (GPG_ERR_ASS_UNKNOWN_INQUIRE);
 778     }
 779
 780   return rc;
 781 }
 782
 783
 784 /* Helper returning a command option to describe the used hash
 785    algorithm.  See scd/command.c:cmd_pksign.  */
 786 static const char *
 787 hash_algo_option (int algo)
 788 {
 789   switch (algo)
 790     {
 791     case GCRY_MD_MD5   : return "--hash=md5";
 792     case GCRY_MD_RMD160: return "--hash=rmd160";
 793     case GCRY_MD_SHA1  : return "--hash=sha1";
 794     case GCRY_MD_SHA224: return "--hash=sha224";
 795     case GCRY_MD_SHA256: return "--hash=sha256";
 796     case GCRY_MD_SHA384: return "--hash=sha384";
 797     case GCRY_MD_SHA512: return "--hash=sha512";
 798     default:             return "";
 799     }
 800 }
 801
 802
 803 static gpg_error_t
 804 cancel_inquire (ctrl_t ctrl, gpg_error_t rc)
 805 {
 806   gpg_error_t oldrc = rc;
 807
 808   /* The inquire callback was called and transact returned a
 809      cancel error.  We assume that the inquired process sent a
 810      CANCEL.  The passthrough code is not able to pass on the
 811      CANCEL and thus scdaemon would stuck on this.  As a
 812      workaround we send a CANCEL now.  */
 813   rc = assuan_write_line (ctrl->scd_local->ctx, "CAN");
 814   if (!rc) {
 815     char *line;
 816     size_t len;
 817
 818     rc = assuan_read_line (ctrl->scd_local->ctx, &line, &len);
 819     if (!rc)
 820       rc = oldrc;
 821   }
 822
 823   return rc;
 824 }
 825
 826 /* Create a signature using the current card.  MDALGO is either 0 or
 827    gives the digest algorithm.  */
 828 int
 829 agent_card_pksign (ctrl_t ctrl,
 830                    const char *keyid,
 831                    int (*getpin_cb)(void *, const char *, char*, size_t),
 832                    void *getpin_cb_arg,
 833                    int mdalgo,
 834                    const unsigned char *indata, size_t indatalen,
 835                    unsigned char **r_buf, size_t *r_buflen)
 836 {
 837   int rc;
 838   char line[ASSUAN_LINELENGTH];
 839   membuf_t data;
 840   struct inq_needpin_s inqparm;
 841
 842   *r_buf = NULL;
 843   rc = start_scd (ctrl);
 844   if (rc)
 845     return rc;
 846
 847   if (indatalen*2 + 50 > DIM(line))
 848     return unlock_scd (ctrl, gpg_error (GPG_ERR_GENERAL));
 849
 850   bin2hex (indata, indatalen, stpcpy (line, "SETDATA "));
 851
 852   rc = assuan_transact (ctrl->scd_local->ctx, line,
 853                         NULL, NULL, NULL, NULL, NULL, NULL);
 854   if (rc)
 855     return unlock_scd (ctrl, rc);
 856
 857   init_membuf (&data, 1024);
 858   inqparm.ctx = ctrl->scd_local->ctx;
 859   inqparm.getpin_cb = getpin_cb;
 860   inqparm.getpin_cb_arg = getpin_cb_arg;
 861   inqparm.passthru = 0;
 862   inqparm.any_inq_seen = 0;
 863   if (ctrl->use_auth_call)
 864     snprintf (line, sizeof line, "PKAUTH %s", keyid);
 865   else
 866     snprintf (line, sizeof line, "PKSIGN %s %s",
 867               hash_algo_option (mdalgo), keyid);
 868   rc = assuan_transact (ctrl->scd_local->ctx, line,
 869                         put_membuf_cb, &data,
 870                         inq_needpin, &inqparm,
 871                         NULL, NULL);
 872   if (inqparm.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
 873         gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
 874     rc = cancel_inquire (ctrl, rc);
 875
 876   if (rc)
 877     {
 878       size_t len;
 879
 880       xfree (get_membuf (&data, &len));
 881       return unlock_scd (ctrl, rc);
 882     }
 883
 884   *r_buf = get_membuf (&data, r_buflen);
 885   return unlock_scd (ctrl, 0);
 886 }
 887
 888
 889
 890 \f
 891 /* Check whether there is any padding info from scdaemon.  */
 892 static gpg_error_t
 893 padding_info_cb (void *opaque, const char *line)
 894 {
 895   int *r_padding = opaque;
 896   const char *s;
 897
 898   if ((s=has_leading_keyword (line, "PADDING")))
 899     {
 900       *r_padding = atoi (s);
 901     }
 902
 903   return 0;
 904 }
 905
 906
 907 /* Decipher INDATA using the current card.  Note that the returned
 908    value is not an s-expression but the raw data as returned by
 909    scdaemon.  The padding information is stored at R_PADDING with -1
 910    for not known.  */
 911 int
 912 agent_card_pkdecrypt (ctrl_t ctrl,
 913                       const char *keyid,
 914                       int (*getpin_cb)(void *, const char *, char*, size_t),
 915                       void *getpin_cb_arg,
 916                       const unsigned char *indata, size_t indatalen,
 917                       char **r_buf, size_t *r_buflen, int *r_padding)
 918 {
 919   int rc, i;
 920   char *p, line[ASSUAN_LINELENGTH];
 921   membuf_t data;
 922   struct inq_needpin_s inqparm;
 923   size_t len;
 924
 925   *r_buf = NULL;
 926   *r_padding = -1; /* Unknown.  */
 927   rc = start_scd (ctrl);
 928   if (rc)
 929     return rc;
 930
 931   /* FIXME: use secure memory where appropriate */
 932
 933   for (len = 0; len < indatalen;)
 934     {
 935       p = stpcpy (line, "SETDATA ");
 936       if (len)
 937         p = stpcpy (p, "--append ");
 938       for (i=0; len < indatalen && (i*2 < DIM(line)-50); i++, len++)
 939         {
 940           sprintf (p, "%02X", indata[len]);
 941           p += 2;
 942         }
 943       rc = assuan_transact (ctrl->scd_local->ctx, line,
 944                             NULL, NULL, NULL, NULL, NULL, NULL);
 945       if (rc)
 946         return unlock_scd (ctrl, rc);
 947     }
 948
 949   init_membuf (&data, 1024);
 950   inqparm.ctx = ctrl->scd_local->ctx;
 951   inqparm.getpin_cb = getpin_cb;
 952   inqparm.getpin_cb_arg = getpin_cb_arg;
 953   inqparm.passthru = 0;
 954   inqparm.any_inq_seen = 0;
 955   snprintf (line, DIM(line), "PKDECRYPT %s", keyid);
 956   rc = assuan_transact (ctrl->scd_local->ctx, line,
 957                         put_membuf_cb, &data,
 958                         inq_needpin, &inqparm,
 959                         padding_info_cb, r_padding);
 960   if (inqparm.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
 961         gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
 962     rc = cancel_inquire (ctrl, rc);
 963
 964   if (rc)
 965     {
 966       xfree (get_membuf (&data, &len));
 967       return unlock_scd (ctrl, rc);
 968     }
 969   *r_buf = get_membuf (&data, r_buflen);
 970   if (!*r_buf)
 971     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
 972
 973   return unlock_scd (ctrl, 0);
 974 }
 975
 976
 977 \f
 978 /* Read a certificate with ID into R_BUF and R_BUFLEN. */
 979 int
 980 agent_card_readcert (ctrl_t ctrl,
 981                      const char *id, char **r_buf, size_t *r_buflen)
 982 {
 983   int rc;
 984   char line[ASSUAN_LINELENGTH];
 985   membuf_t data;
 986   size_t len;
 987
 988   *r_buf = NULL;
 989   rc = start_scd (ctrl);
 990   if (rc)
 991     return rc;
 992
 993   init_membuf (&data, 1024);
 994   snprintf (line, DIM(line), "READCERT %s", id);
 995   rc = assuan_transact (ctrl->scd_local->ctx, line,
 996                         put_membuf_cb, &data,
 997                         NULL, NULL,
 998                         NULL, NULL);
 999   if (rc)
1000     {
1001       xfree (get_membuf (&data, &len));
1002       return unlock_scd (ctrl, rc);
1003     }
1004   *r_buf = get_membuf (&data, r_buflen);
1005   if (!*r_buf)
1006     return unlock_scd (ctrl, gpg_error (GPG_ERR_ENOMEM));
1007
1008   return unlock_scd (ctrl, 0);
1009 }
1010
1011
1012 \f
1013 /* Read a key with ID and return it in an allocate buffer pointed to
1014    by r_BUF as a valid S-expression. */
1015 int
1016 agent_card_readkey (ctrl_t ctrl, const char *id, unsigned char **r_buf)
1017 {
1018   int rc;
1019   char line[ASSUAN_LINELENGTH];
1020   membuf_t data;
1021   size_t len, buflen;
1022
1023   *r_buf = NULL;
1024   rc = start_scd (ctrl);
1025   if (rc)
1026     return rc;
1027
1028   init_membuf (&data, 1024);
1029   snprintf (line, DIM(line), "READKEY %s", id);
1030   rc = assuan_transact (ctrl->scd_local->ctx, line,
1031                         put_membuf_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 (has_leading_keyword (line, "KEYDATA"))
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), "WRITEKEY %s%s", force ? "--force " : "", id);
1095   parms.ctx = ctrl->scd_local->ctx;
1096   parms.getpin_cb = getpin_cb;
1097   parms.getpin_cb_arg = getpin_cb_arg;
1098   parms.passthru = 0;
1099   parms.any_inq_seen = 0;
1100   parms.keydata = keydata;
1101   parms.keydatalen = keydatalen;
1102
1103   rc = assuan_transact (ctrl->scd_local->ctx, line, NULL, NULL,
1104                         inq_writekey_parms, &parms, NULL, NULL);
1105   if (parms.any_inq_seen && (gpg_err_code(rc) == GPG_ERR_CANCELED ||
1106                              gpg_err_code(rc) == GPG_ERR_ASS_CANCELED))
1107     rc = cancel_inquire (ctrl, rc);
1108   return unlock_scd (ctrl, rc);
1109 }
1110 \f
1111 /* Type used with the card_getattr_cb.  */
1112 struct card_getattr_parm_s {
1113   const char *keyword;  /* Keyword to look for.  */
1114   size_t keywordlen;    /* strlen of KEYWORD.  */
1115   char *data;           /* Malloced and unescaped data.  */
1116   int error;            /* ERRNO value or 0 on success. */
1117 };
1118
1119 /* Callback function for agent_card_getattr.  */
1120 static gpg_error_t
1121 card_getattr_cb (void *opaque, const char *line)
1122 {
1123   struct card_getattr_parm_s *parm = opaque;
1124   const char *keyword = line;
1125   int keywordlen;
1126
1127   if (parm->data)
1128     return 0; /* We want only the first occurrence.  */
1129
1130   for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
1131     ;
1132   while (spacep (line))
1133     line++;
1134
1135   if (keywordlen == parm->keywordlen
1136       && !memcmp (keyword, parm->keyword, keywordlen))
1137     {
1138       parm->data = percent_plus_unescape ((const unsigned char*)line, 0xff);
1139       if (!parm->data)
1140         parm->error = errno;
1141     }
1142
1143   return 0;
1144 }
1145
1146
1147 /* Call the agent to retrieve a single line data object. On success
1148    the object is malloced and stored at RESULT; it is guaranteed that
1149    NULL is never stored in this case.  On error an error code is
1150    returned and NULL stored at RESULT. */
1151 gpg_error_t
1152 agent_card_getattr (ctrl_t ctrl, const char *name, char **result)
1153 {
1154   int err;
1155   struct card_getattr_parm_s parm;
1156   char line[ASSUAN_LINELENGTH];
1157
1158   *result = NULL;
1159
1160   if (!*name)
1161     return gpg_error (GPG_ERR_INV_VALUE);
1162
1163   memset (&parm, 0, sizeof parm);
1164   parm.keyword = name;
1165   parm.keywordlen = strlen (name);
1166
1167   /* We assume that NAME does not need escaping. */
1168   if (8 + strlen (name) > DIM(line)-1)
1169     return gpg_error (GPG_ERR_TOO_LARGE);
1170   stpcpy (stpcpy (line, "GETATTR "), name);
1171
1172   err = start_scd (ctrl);
1173   if (err)
1174     return err;
1175
1176   err = assuan_transact (ctrl->scd_local->ctx, line,
1177                          NULL, NULL, NULL, NULL,
1178                          card_getattr_cb, &parm);
1179   if (!err && parm.error)
1180     err = gpg_error_from_errno (parm.error);
1181
1182   if (!err && !parm.data)
1183     err = gpg_error (GPG_ERR_NO_DATA);
1184
1185   if (!err)
1186     *result = parm.data;
1187   else
1188     xfree (parm.data);
1189
1190   return unlock_scd (ctrl, err);
1191 }
1192
1193
1194
1195 \f
1196 static gpg_error_t
1197 pass_status_thru (void *opaque, const char *line)
1198 {
1199   assuan_context_t ctx = opaque;
1200   char keyword[200];
1201   int i;
1202
1203   if (line[0] == '#' && (!line[1] || spacep (line+1)))
1204     {
1205       /* We are called in convey comments mode.  Now, if we see a
1206          comment marker as keyword we forward the line verbatim to the
1207          the caller.  This way the comment lines from scdaemon won't
1208          appear as status lines with keyword '#'.  */
1209       assuan_write_line (ctx, line);
1210     }
1211   else
1212     {
1213       for (i=0; *line && !spacep (line) && i < DIM(keyword)-1; line++, i++)
1214         keyword[i] = *line;
1215       keyword[i] = 0;
1216
1217       /* Truncate any remaining keyword stuff.  */
1218       for (; *line && !spacep (line); line++)
1219         ;
1220       while (spacep (line))
1221         line++;
1222
1223       assuan_write_status (ctx, keyword, line);
1224     }
1225   return 0;
1226 }
1227
1228 static gpg_error_t
1229 pass_data_thru (void *opaque, const void *buffer, size_t length)
1230 {
1231   assuan_context_t ctx = opaque;
1232
1233   assuan_send_data (ctx, buffer, length);
1234   return 0;
1235 }
1236
1237
1238 /* Send the line CMDLINE with command for the SCDdaemon to it and send
1239    all status messages back.  This command is used as a general quoting
1240    mechanism to pass everything verbatim to SCDAEMON.  The PIN
1241    inquiry is handled inside gpg-agent.  */
1242 int
1243 agent_card_scd (ctrl_t ctrl, const char *cmdline,
1244                 int (*getpin_cb)(void *, const char *, char*, size_t),
1245                 void *getpin_cb_arg, void *assuan_context)
1246 {
1247   int rc;
1248   struct inq_needpin_s inqparm;
1249   int saveflag;
1250
1251   rc = start_scd (ctrl);
1252   if (rc)
1253     return rc;
1254
1255   inqparm.ctx = ctrl->scd_local->ctx;
1256   inqparm.getpin_cb = getpin_cb;
1257   inqparm.getpin_cb_arg = getpin_cb_arg;
1258   inqparm.passthru = assuan_context;
1259   inqparm.any_inq_seen = 0;
1260   saveflag = assuan_get_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS);
1261   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, 1);
1262   rc = assuan_transact (ctrl->scd_local->ctx, cmdline,
1263                         pass_data_thru, assuan_context,
1264                         inq_needpin, &inqparm,
1265                         pass_status_thru, assuan_context);
1266   if (inqparm.any_inq_seen && gpg_err_code(rc) == GPG_ERR_ASS_CANCELED)
1267     rc = cancel_inquire (ctrl, rc);
1268
1269   assuan_set_flag (ctrl->scd_local->ctx, ASSUAN_CONVEY_COMMENTS, saveflag);
1270   if (rc)
1271     {
1272       return unlock_scd (ctrl, rc);
1273     }
1274
1275   return unlock_scd (ctrl, 0);
1276 }