src/pinentry.c

   1 /*
   2     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015
   3     Ben Kibbey <bjk@luxsci.net>
   4
   5     This file is part of pwmd.
   6
   7     Pwmd is free software: you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation, either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     Pwmd is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <pwd.h>
  27 #include <sys/types.h>
  28 #include <signal.h>
  29 #include <sys/wait.h>
  30
  31 #include "pwmd-error.h"
  32 #include <gcrypt.h>
  33 #include "mem.h"
  34 #include "util-misc.h"
  35 #include "common.h"
  36 #include "commands.h"
  37 #include "pinentry.h"
  38 #include "mutex.h"
  39 #include "rcfile.h"
  40 #include "util-string.h"
  41
  42 #ifdef WITH_QUALITY
  43 #include <crack.h>
  44 #endif
  45
  46 void cleanup_all_clients (int atfork);
  47 static gpg_error_t set_pinentry_strings (struct pinentry_s *pin, int which);
  48
  49 static gpg_error_t
  50 mem_realloc_cb (void *data, const void *buffer, size_t len)
  51 {
  52   membuf_t *mem = (membuf_t *) data;
  53   void *p;
  54
  55   if (!buffer)
  56     return 0;
  57
  58   p = xrealloc (mem->buf, mem->len + len);
  59   if (!p)
  60     return 1;
  61
  62   mem->buf = p;
  63   memcpy ((char *) mem->buf + mem->len, buffer, len);
  64   mem->len += len;
  65   return 0;
  66 }
  67
  68 #ifdef WITH_QUALITY
  69 static gpg_error_t
  70 quality_cb (void *data, const char *line)
  71 {
  72   struct pinentry_s *pin = data;
  73   const char *tmp;
  74   int score = 0;
  75   char buf[5];
  76
  77   if (strncmp (line, "QUALITY ", 8) != 0)
  78     return GPG_ERR_INV_ARG;
  79
  80   tmp = FascistCheck (line + 8, CRACKLIB_DICT);
  81   if (!tmp)
  82     return assuan_send_data (pin->ctx, "100", 3);
  83
  84   if (!strcmp (tmp, _("it's WAY too short")))
  85     score = 10;
  86   else if (!strcmp (tmp, _("it is too short")))
  87     score = 20;
  88   else if (!strcmp (tmp, _("it is all whitespace")))
  89     score = 25;
  90   else if (!strcmp (tmp, _("it is based on your username")))
  91     score = 30;
  92   else if (!strcmp (tmp, _("it is based on a dictionary word")))
  93     score = 40;
  94   else if (!strcmp (tmp, _("it is based upon your password entry")))
  95     score = 50;
  96   else if (!strcmp (tmp, _("it's derived from your password entry")))
  97     score = 50;
  98   else if (!strcmp (tmp, _("it is based on a (reversed) dictionary word")))
  99     score = 60;
 100   else if (!strcmp (tmp, _("it is derivable from your password entry")))
 101     score = 70;
 102   else
 103     if (!strcmp
 104         (tmp, _("it does not contain enough DIFFERENT characters")))
 105       score = 80;
 106     else if (!strcmp (tmp, _("it is too simplistic/systematic")))
 107       score = 90;
 108     else
 109       score = 0;
 110
 111   snprintf (buf, sizeof (buf), "%i", score);
 112   tmp = buf;
 113   return assuan_send_data (pin->ctx, tmp, strlen (tmp));
 114 }
 115 #endif
 116
 117 static gpg_error_t
 118 assuan_command (struct pinentry_s *pin, char **result, const char *cmd)
 119 {
 120   gpg_error_t rc;
 121
 122   pin->data.len = 0;
 123   pin->data.buf = NULL;
 124
 125   rc = assuan_transact (pin->ctx, cmd, mem_realloc_cb, &pin->data,
 126                         pin->inquire_cb, pin->inquire_data, NULL, NULL);
 127   if (rc)
 128     {
 129       if (pin->data.buf)
 130         {
 131           xfree (pin->data.buf);
 132           pin->data.buf = NULL;
 133         }
 134     }
 135   else
 136     {
 137       if (pin->data.buf)
 138         {
 139           mem_realloc_cb (&pin->data, "", 1);
 140           *result = (char *) pin->data.buf;
 141         }
 142     }
 143
 144   return rc;
 145 }
 146
 147 static gpg_error_t
 148 set_pinentry_options (struct pinentry_s *pin)
 149 {
 150   char *display = getenv ("DISPLAY");
 151   int have_display = 0;
 152   char *tty = NULL, *ttytype = NULL;
 153   char *opt, *val;
 154   gpg_error_t rc;
 155   char *result = NULL;
 156   char cmd[ASSUAN_LINELENGTH];
 157
 158   if (pin->pinentry_opts.display || display)
 159     have_display = 1;
 160   else
 161     {
 162       tty = pin->pinentry_opts.ttyname ? pin->pinentry_opts.ttyname
 163         : ttyname (STDOUT_FILENO);
 164       if (!tty)
 165         return gpg_error_from_errno (errno);
 166     }
 167
 168   if (!have_display && !tty)
 169     return GPG_ERR_CANCELED;
 170
 171   if (!have_display)
 172     {
 173       char *p = getenv ("TERM");
 174
 175       ttytype = pin->pinentry_opts.ttytype ? pin->pinentry_opts.ttytype : p;
 176       if (!ttytype)
 177         return GPG_ERR_ENOTTY;
 178     }
 179
 180   opt = have_display ? str_dup ("DISPLAY") : str_dup ("TTYNAME");
 181   val = have_display ? pin->pinentry_opts.display ? pin->pinentry_opts.display
 182     : display : tty;
 183   snprintf (cmd, sizeof (cmd), "OPTION %s=%s", str_down (opt), val);
 184   xfree (opt);
 185   rc = assuan_command (pin, &result, cmd);
 186   if (rc)
 187     return rc;
 188
 189   if (!have_display)
 190     {
 191       snprintf (cmd, sizeof (cmd), "OPTION ttytype=%s", ttytype);
 192       rc = assuan_command (pin, &result, cmd);
 193     }
 194
 195   if (!rc)
 196     {
 197       snprintf (cmd, sizeof(cmd), "SETTIMEOUT %i", pin->pinentry_opts.timeout);
 198       rc = assuan_command (pin, NULL, cmd);
 199       /* Not all pinentrys support the SETTIMEOUT command. */
 200       if (rc && gpg_err_source (rc) == GPG_ERR_SOURCE_PINENTRY
 201           && gpg_err_code (rc) == GPG_ERR_ASS_UNKNOWN_CMD)
 202         rc = 0;
 203     }
 204
 205   return rc;
 206 }
 207
 208 #ifdef HAVE_PTHREAD_ATFORK
 209 static void
 210 atfork_cb ()
 211 {
 212   cleanup_all_clients (1);
 213 }
 214 #else
 215 static void
 216 atfork_cb (void *data, int n)
 217 {
 218   (void)data;
 219   if (!n)
 220     cleanup_all_clients (1);
 221 }
 222 #endif
 223
 224 static gpg_error_t
 225 launch_pinentry (struct pinentry_s *pin)
 226 {
 227   gpg_error_t rc;
 228   assuan_context_t ctx;
 229   static struct assuan_malloc_hooks mhooks = { xmalloc, xrealloc, xfree };
 230   int child_list[] = { -1 };
 231   const char *argv[8];
 232   const char **p = argv;
 233   char *tmp;
 234
 235   *p++ = "pinentry";
 236
 237   if (pin->pinentry_opts.display)
 238     {
 239       *p++ = "--display";
 240       *p++ = pin->pinentry_opts.display;
 241     }
 242
 243   if (pin->pinentry_opts.lc_ctype)
 244     {
 245       *p++ = "--lc-ctype";
 246       *p++ = pin->pinentry_opts.lc_ctype;
 247     }
 248
 249   if (pin->pinentry_opts.lc_messages)
 250     {
 251       *p++ = "--lc-messages";
 252       *p++ = pin->pinentry_opts.lc_messages;
 253     }
 254
 255   *p = NULL;
 256   rc = assuan_new_ext (&ctx, GPG_ERR_SOURCE_DEFAULT, &mhooks, NULL, NULL);
 257   if (rc)
 258     return rc;
 259
 260   tmp = config_get_string ("global", "pinentry_path");
 261 #ifdef HAVE_PTHREAD_ATFORK
 262   pthread_atfork (NULL, NULL, atfork_cb);
 263   rc = assuan_pipe_connect (ctx, tmp, argv, child_list, NULL, NULL, 0);
 264 #else
 265   rc = assuan_pipe_connect (ctx, tmp, argv, child_list, atfork_cb, NULL, 0);
 266 #endif
 267   xfree (tmp);
 268   if (rc)
 269     return rc;
 270
 271   pin->ctx = ctx;
 272   rc = set_pinentry_options (pin);
 273   return rc ? rc : set_pinentry_strings (pin, pin->which);
 274 }
 275
 276 static gpg_error_t
 277 pinentry_command (struct pinentry_s *pin, char **result, const char *cmd)
 278 {
 279   gpg_error_t rc = 0;
 280
 281   if (!pin->ctx)
 282     rc = launch_pinentry (pin);
 283
 284   return rc ? rc : assuan_command (pin, result, cmd);
 285 }
 286
 287 static gpg_error_t
 288 set_pinentry_strings (struct pinentry_s *pin, int which)
 289 {
 290   char *buf;
 291   gpg_error_t rc;
 292   char *title = NULL;
 293
 294   /* The initial prompt from launch_pinentry(). */
 295   pin->which = which;
 296
 297   if (which == PINENTRY_FAIL_CONFIRM)
 298     {
 299       title = str_dup (_("Passphrase mismatch, please try again."));
 300       which = PINENTRY_SAVE;
 301     }
 302   else if (!pin->pinentry_opts.title)
 303     title = str_asprintf (_("Password Manager Daemon%s%s"),
 304                           pin->name ? ": " : "",
 305                           pin->name ? pin->name : "");
 306   else
 307     title = str_dup (pin->pinentry_opts.title);
 308
 309 #ifdef WITH_QUALITY
 310   if (which == PINENTRY_SAVE)
 311     {
 312       rc = pinentry_command (pin, NULL, "SETQUALITYBAR");
 313       if (rc)
 314         goto done;
 315
 316       pin->inquire_cb = quality_cb;
 317       pin->inquire_data = pin;
 318     }
 319 #endif
 320
 321   if (!pin->pinentry_opts.prompt)
 322     pin->pinentry_opts.prompt = str_dup (_("Passphrase:"));
 323
 324   if (!pin->pinentry_opts.desc)
 325     pin->pinentry_opts.desc = str_asprintf (which == PINENTRY_OPEN ?
 326                               _("A passphrase is required to open the file "
 327                                 "\"%s\". Please enter the passphrase below.")
 328                               :
 329                               _("A passphrase is required to save to the file "
 330                                 "\"%s\". Please enter the passphrase below."),
 331                               pin->filename);
 332
 333   if (which == PINENTRY_SAVE_CONFIRM)
 334     buf = str_asprintf ("SETDESC %s",
 335                         _("Please enter the passphrase again for confirmation."));
 336   else
 337     buf = str_asprintf ("SETDESC %s", pin->pinentry_opts.desc);
 338
 339   rc = pinentry_command (pin, NULL, buf);
 340   xfree (buf);
 341   if (rc)
 342     goto done;
 343
 344   buf = str_asprintf ("SETPROMPT %s", pin->pinentry_opts.prompt);
 345   rc = pinentry_command (pin, NULL, buf);
 346   xfree (buf);
 347   if (rc)
 348     goto done;
 349
 350   buf = str_asprintf ("SETERROR %s", title);
 351   rc = pinentry_command (pin, NULL, buf);
 352   xfree (buf);
 353
 354  done:
 355   free (title);
 356   return rc;
 357 }
 358
 359 static void
 360 pinentry_disconnect (struct pinentry_s *pin)
 361 {
 362   if (!pin)
 363     return;
 364
 365   if (pin->ctx)
 366     assuan_release (pin->ctx);
 367
 368   pin->ctx = NULL;
 369 }
 370
 371 static gpg_error_t
 372 do_getpin (struct pinentry_s *pin, char **result)
 373 {
 374   gpg_error_t rc;
 375
 376   *result = NULL;
 377   rc = pinentry_command (pin, result, "GETPIN");
 378   if (rc)
 379     return rc;
 380
 381   if (!*result)
 382     *result = str_dup ("");
 383
 384   return rc;
 385 }
 386
 387 gpg_error_t
 388 pinentry_getpin (struct pinentry_s * pin, char **result, pinentry_cmd_t which)
 389 {
 390   gpg_error_t rc = set_pinentry_strings (pin, which);
 391   char *result1 = NULL;
 392
 393   if (rc)
 394     goto done;
 395
 396  again:
 397   rc = do_getpin (pin, result);
 398   if (rc)
 399     goto done;
 400
 401   if (which == PINENTRY_SAVE)
 402     {
 403       if (!result1)
 404         {
 405           rc = set_pinentry_strings (pin, PINENTRY_SAVE_CONFIRM);
 406           if (rc)
 407             goto done;
 408
 409           result1 = *result;
 410           goto again;
 411         }
 412
 413       if (strcmp (result1, *result))
 414         {
 415           xfree (result1);
 416           xfree (*result);
 417           result1 = *result = NULL;
 418           rc = set_pinentry_strings (pin, PINENTRY_FAIL_CONFIRM);
 419           if (rc)
 420             goto done;
 421
 422           goto again;
 423         }
 424     }
 425
 426  done:
 427   xfree (result1);
 428   pinentry_disconnect (pin);
 429   return rc;
 430 }
 431
 432 gpg_error_t
 433 pinentry_lock (assuan_context_t ctx, struct pinentry_s *pin)
 434 {
 435   gpg_error_t rc = 0;
 436
 437   MUTEX_TRYLOCK (ctx, &pin_mutex, rc, pin->pinentry_opts.timeout*10);
 438
 439   if (!rc)
 440     pin->has_lock = 1;
 441
 442   return rc;
 443 }
 444
 445 void
 446 pinentry_unlock (struct pinentry_s *pin)
 447 {
 448   if (pin->has_lock == 0)
 449     return;
 450
 451   MUTEX_UNLOCK (&pin_mutex);
 452   pin->has_lock = 0;
 453 }
 454
 455 void
 456 pinentry_deinit (struct pinentry_s *pin)
 457 {
 458   if (!pin)
 459     return;
 460
 461   pinentry_unlock (pin);
 462
 463   if (pin->ctx)
 464     pinentry_disconnect (pin);
 465
 466   xfree (pin->name);
 467   xfree (pin->filename);
 468   pinentry_free_opts (&pin->pinentry_opts);
 469   xfree (pin);
 470 }
 471
 472 struct pinentry_s *
 473 pinentry_init (const char *filename)
 474 {
 475   struct pinentry_s *pin = xcalloc (1, sizeof (struct pinentry_s));
 476
 477   if (!pin)
 478     return NULL;
 479
 480   pin->filename = str_dup (filename);
 481   if (!pin->filename)
 482     {
 483       xfree (pin);
 484       return NULL;
 485     }
 486
 487   return pin;
 488 }
 489
 490 void
 491 pinentry_free_opts (struct pinentry_option_s *opts)
 492 {
 493   xfree (opts->title);
 494   xfree (opts->desc);
 495   xfree (opts->prompt);
 496   xfree (opts->ttyname);
 497   xfree (opts->ttytype);
 498   xfree (opts->display);
 499   xfree (opts->lc_messages);
 500   xfree (opts->lc_ctype);
 501 }
 502
 503 gpg_error_t
 504 pinentry_merge_options (struct pinentry_option_s *dst,
 505                         struct pinentry_option_s *src)
 506 {
 507   dst->timeout = src->timeout;
 508
 509   if (src->title)
 510     {
 511       xfree (dst->title);
 512       dst->title = str_dup (src->title);
 513     }
 514
 515   if (src->desc)
 516     {
 517       xfree (dst->desc);
 518       dst->desc = str_dup (src->desc);
 519     }
 520
 521   if (src->prompt)
 522     {
 523       xfree (dst->prompt);
 524       dst->prompt = str_dup (src->prompt);
 525     }
 526
 527   if (src->display)
 528     {
 529       xfree (dst->display);
 530       dst->display = str_dup (src->display);
 531     }
 532
 533   if (src->ttyname)
 534     {
 535       xfree (dst->ttyname);
 536       dst->ttyname = str_dup (src->ttyname);
 537     }
 538
 539   if (src->ttytype)
 540     {
 541       xfree (dst->ttytype);
 542       dst->ttytype = str_dup (src->ttytype);
 543     }
 544
 545   if (src->lc_ctype)
 546     {
 547       xfree (dst->lc_ctype);
 548       dst->lc_ctype = str_dup (src->lc_ctype);
 549     }
 550
 551   if (src->lc_messages)
 552     {
 553       xfree (dst->lc_messages);
 554       dst->lc_messages = str_dup (src->lc_messages);
 555     }
 556
 557   return 0;
 558 }