src/pinentry.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4     Ben Kibbey <bjk@luxsci.net>
   5
   6     This file is part of libpwmd.
   7
   8     Libpwmd 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 2 of the License, or
  11     (at your option) any later version.
  12
  13     Libpwmd 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 Libpwmd.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <sys/types.h>
  26 #include <signal.h>
  27 #include <errno.h>
  28 #include <stdlib.h>
  29 #include <limits.h>
  30
  31 #ifdef HAVE_STRING_H
  32 #include <string.h>
  33 #endif
  34
  35 #include "pinentry.h"
  36 #include "misc.h"
  37
  38 #ifdef WITH_QUALITY
  39 #include <crack.h>
  40 #endif
  41
  42 static pwm_t *gpwm;
  43 static int gelapsed, gtimeout;
  44 static gpg_error_t grc;
  45
  46 static gpg_error_t set_pinentry_strings(pwm_t *pwm, pwmd_pinentry_t which);
  47
  48 static gpg_error_t launch_pinentry(pwm_t *pwm)
  49 {
  50     int rc;
  51     assuan_context_t ctx;
  52     int child_list[] = {-1};
  53     const char *argv[10];
  54     const char **p = argv;
  55     static struct assuan_malloc_hooks mhooks = {
  56         pwmd_malloc, pwmd_realloc, pwmd_free
  57     };
  58
  59     update_pinentry_settings(pwm);
  60     if (!pwm->pinentry_display && !pwm->pinentry_tty)
  61         return GPG_ERR_ENOTTY;
  62
  63     *p++ = "pinentry";
  64     *p++ = pwm->pinentry_display ? "--display" : "--ttyname";
  65     *p++ = pwm->pinentry_display ? pwm->pinentry_display : pwm->pinentry_tty;
  66
  67     if (pwm->pinentry_lcctype) {
  68         *p++ = "--lc-ctype";
  69         *p++ = pwm->pinentry_lcctype;
  70     }
  71
  72     if (pwm->pinentry_lcmessages) {
  73         *p++ = "--lc-messages";
  74         *p++ = pwm->pinentry_lcmessages;
  75     }
  76
  77     *p = NULL;
  78
  79     if (!pwm->pinentry_display) {
  80         *p++ = "--ttytype";
  81         *p++ = pwm->pinentry_term ? pwm->pinentry_term : getenv("TERM");
  82         *p = NULL;
  83     }
  84
  85     rc = assuan_new_ext(&ctx, GPG_ERR_SOURCE_PINENTRY, &mhooks, NULL, NULL);
  86     if (rc)
  87         return rc;
  88
  89     rc = assuan_pipe_connect(ctx,
  90             pwm->pinentry_path ? pwm->pinentry_path : PINENTRY_PATH, argv,
  91             child_list, NULL, NULL, 0);
  92     if (rc)
  93         return rc;
  94
  95     pwm->pinentry_pid = assuan_get_pid(ctx);
  96     pwm->pctx = ctx;
  97     return set_pinentry_strings(pwm, 0);
  98 }
  99
 100 static gpg_error_t pinentry_command(pwm_t *pwm, char **result, size_t *len,
 101         const char *cmd)
 102 {
 103     if (!pwm->pctx) {
 104         gpg_error_t rc = launch_pinentry(pwm);
 105
 106         if (rc)
 107             return rc;
 108     }
 109
 110     return _assuan_command(pwm, pwm->pctx, result, len, cmd);
 111 }
 112
 113 #ifdef WITH_QUALITY
 114 static gpg_error_t quality_cb(void *data, const char *line)
 115 {
 116     pwm_t *pwm = data;
 117     int score = 0;
 118     char buf[5];
 119     const char *tmp;
 120
 121     if (strncmp(line, "QUALITY ", 8))
 122         return GPG_ERR_INV_ARG;
 123
 124     if (!(tmp = FascistCheck(line+8, CRACKLIB_DICT)))
 125         return assuan_send_data(pwm->pctx, "100", 3);
 126
 127     if (!strcmp(tmp, N_("it is WAY too short")))
 128         score = 10;
 129     else if (!strcmp(tmp, N_("it is too short")))
 130         score = 20;
 131     else if (!strcmp(tmp, N_("it is all whitespace")))
 132         score = 25;
 133     else if (!strcmp(tmp, N_("it is based on your username")))
 134         score = 30;
 135     else if (!strcmp(tmp, N_("it does not contain enough DIFFERENT characters")))
 136         score = 35;
 137     else if (!strcmp(tmp, N_("it is based on a dictionary word")))
 138         score = 40;
 139     else if (!strcmp(tmp, N_("it is based upon your password entry")))
 140         score = 50;
 141     else if (!strcmp(tmp, N_("it's derived from your password entry")))
 142         score = 50;
 143     else if (!strcmp(tmp, N_("it is derived from your password entry")))
 144         score = 50;
 145     else if (!strcmp(tmp, N_("it is based on a (reversed) dictionary word")))
 146         score = 60;
 147     else if (!strcmp(tmp, N_("it is derivable from your password entry")))
 148         score = 70;
 149     else if (!strcmp(tmp, N_("it's derivable from your password entry")))
 150         score = 70;
 151     else if (!strcmp(tmp, N_("it looks like a National Insurance number.")))
 152         score = 80;
 153     else if (!strcmp(tmp, N_("it is too simplistic/systematic")))
 154         score = 90;
 155     else
 156         score = 0;
 157
 158     snprintf(buf, sizeof(buf), "%i", score);
 159     return assuan_send_data(pwm->pctx, buf, strlen(buf));
 160 }
 161 #endif
 162
 163 static gpg_error_t set_pinentry_strings(pwm_t *pwm, pwmd_pinentry_t which)
 164 {
 165     char *tmp, *desc = NULL;
 166     gpg_error_t rc;
 167
 168     if (which != PWMD_PINENTRY_USER) {
 169         rc = pinentry_command(pwm, NULL, NULL, "SETERROR ");
 170         if (rc)
 171             return rc;
 172     }
 173
 174     tmp = pwmd_malloc(ASSUAN_LINELENGTH+1);
 175     if (!tmp)
 176         return gpg_error_from_errno(ENOMEM);
 177
 178     if (!pwm->pinentry_prompt) {
 179         pwm->pinentry_prompt = pwmd_strdup(N_("Passphrase:"));
 180         if (!pwm->pinentry_prompt) {
 181             pwmd_free(tmp);
 182             return GPG_ERR_ENOMEM;
 183         }
 184     }
 185
 186     if (!pwm->pinentry_desc) {
 187         if (which == PWMD_PINENTRY_OPEN || which == PWMD_PINENTRY_OPEN_FAILED)
 188             desc = pwmd_strdup_printf(N_("A passphrase is required to unlock the secret key for the encrypted data file \"%s\". Please enter the passphrase below."), pwm->filename);
 189         else if (which == PWMD_PINENTRY_SAVE
 190                 || which == PWMD_PINENTRY_SAVE_FAILED)
 191             desc = pwmd_strdup_printf(N_("Please enter the passphrase to use to encrypt the data file \"%s\"."), pwm->filename);
 192         else if (which == PWMD_PINENTRY_SAVE_CONFIRM)
 193             desc = pwmd_strdup_printf(N_("Please re-enter the passphrase for confirmation."), pwm->filename);
 194
 195         if (!desc) {
 196             pwmd_free(tmp);
 197             return GPG_ERR_ENOMEM;
 198         }
 199     }
 200
 201     if (pwm->pinentry_desc)
 202         desc = pwm->pinentry_desc;
 203
 204     if (which == PWMD_PINENTRY_USER) {
 205         snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s",
 206                 pwm->pinentry_error ? pwm->pinentry_error : "");
 207         rc = pinentry_command(pwm, NULL, NULL, tmp);
 208         if (rc) {
 209             pwmd_free(tmp);
 210             return rc;
 211         }
 212
 213         snprintf(tmp, ASSUAN_LINELENGTH, "SETDESC %s",
 214                 pwm->pinentry_desc ? pwm->pinentry_desc : "");
 215     }
 216     else {
 217         if (which == PWMD_PINENTRY_SAVE_FAILED
 218                 || which == PWMD_PINENTRY_OPEN_FAILED) {
 219             if (which == PWMD_PINENTRY_SAVE_FAILED)
 220                 snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s",
 221                         N_("Passphrases do not match, try again."));
 222             else {
 223                 if (pwm->pinentry_tries) {
 224                     strcpy(tmp, "SETERROR ");
 225                     snprintf(tmp+strlen("SETERROR "), ASSUAN_LINELENGTH,
 226                             N_("Bad passphrase (try %i of %i)"),
 227                             pwm->pinentry_try+1, pwm->pinentry_tries);
 228                 }
 229                 else
 230                     snprintf(tmp, ASSUAN_LINELENGTH, "SETERROR %s",
 231                             N_("Bad passphrase, try again"));
 232             }
 233
 234             rc = pinentry_command(pwm, NULL, NULL, tmp);
 235             if (rc) {
 236                 pwmd_free(tmp);
 237                 return rc;
 238             }
 239         }
 240
 241         snprintf(tmp, ASSUAN_LINELENGTH, "SETDESC %s", desc);
 242
 243         if (pwm->pinentry_desc != desc)
 244             pwmd_free(desc);
 245     }
 246
 247     rc = pinentry_command(pwm, NULL, NULL, tmp);
 248     if (rc) {
 249         pwmd_free(tmp);
 250         return rc;
 251     }
 252
 253     snprintf(tmp, ASSUAN_LINELENGTH, "SETPROMPT %s", pwm->pinentry_prompt);
 254     rc = pinentry_command(pwm, NULL, NULL, tmp);
 255     pwmd_free(tmp);
 256
 257 #ifdef WITH_QUALITY
 258     if (!rc && (which == PWMD_PINENTRY_SAVE ||
 259                 which == PWMD_PINENTRY_SAVE_FAILED)) {
 260         rc = pinentry_command(pwm, NULL, NULL, "SETQUALITYBAR");
 261         if (!rc) {
 262             pwm->_inquire_func = quality_cb;
 263             pwm->_inquire_data = pwm;
 264         }
 265     }
 266 #endif
 267
 268     return rc;
 269 }
 270
 271 static gpg_error_t terminate_pinentry(pwm_t *pwm)
 272 {
 273     pid_t pid = pwm->pinentry_pid;
 274
 275     pwm->pinentry_pid = -1;
 276
 277     if (!pwm || pid == -1)
 278         return GPG_ERR_INV_ARG;
 279
 280     if (kill(pid, 0) == 0) {
 281         if (kill(pid, SIGTERM) == -1) {
 282             if (kill(pid, SIGKILL) == -1)
 283                 return gpg_error_from_errno(errno);
 284         }
 285     }
 286     else
 287         return gpg_error_from_errno(errno);
 288
 289     return 0;
 290 }
 291
 292 void _pinentry_disconnect(pwm_t *pwm)
 293 {
 294     if (pwm->pctx)
 295         assuan_release(pwm->pctx);
 296
 297     pwm->pctx = NULL;
 298     pwm->pinentry_pid = -1;
 299 }
 300
 301 /*
 302  * Only called from a child process.
 303  */
 304 static void catchsig(int sig)
 305 {
 306     switch (sig) {
 307         case SIGALRM:
 308             if (++gelapsed >= gtimeout) {
 309                 terminate_pinentry(gpwm);
 310                 grc = gpg_err_make(GPG_ERR_SOURCE_PINENTRY, GPG_ERR_CANCELED);
 311             }
 312             else
 313                 alarm(1);
 314             break;
 315         default:
 316             break;
 317     }
 318 }
 319
 320 gpg_error_t _getpin(pwm_t *pwm, char **result, size_t *len,
 321         pwmd_pinentry_t which)
 322 {
 323     grc = 0;
 324     gpg_error_t rc = set_pinentry_strings(pwm, which);
 325
 326     if (rc) {
 327         _pinentry_disconnect(pwm);
 328         return rc;
 329     }
 330
 331     if (result)
 332         *result = NULL;
 333
 334     if (gtimeout) {
 335         signal(SIGALRM, catchsig);
 336         alarm(1);
 337     }
 338
 339     if (result)
 340         *result = NULL;
 341
 342     rc = pinentry_command(pwm, result, len,
 343             which == PWMD_PINENTRY_CONFIRM ? "CONFIRM" : "GETPIN");
 344
 345     /*
 346      * Since there was input cancel any timeout setting.
 347      */
 348     alarm(0);
 349     signal(SIGALRM, SIG_DFL);
 350
 351     if (rc) {
 352         _pinentry_disconnect(pwm);
 353
 354         /* This lets PWMD_OPTION_PINENTRY_TIMEOUT work. Note that it is not
 355          * thread safe do to the global variables. */
 356         if (gpg_err_code(rc) == GPG_ERR_EOF)
 357             rc = GPG_ERR_CANCELED;
 358     }
 359
 360     return rc;
 361 }
 362
 363 gpg_error_t _pwmd_getpin(pwm_t *pwm, const char *filename, char **result,
 364         size_t *len, pwmd_pinentry_t which)
 365 {
 366     gpg_error_t rc;
 367     char *p = pwm->filename;
 368
 369     if (!pwm)
 370         return GPG_ERR_INV_ARG;
 371
 372     if (which == PWMD_PINENTRY_CLOSE) {
 373         _pinentry_disconnect(pwm);
 374         return 0;
 375     }
 376
 377     if (!result && which != PWMD_PINENTRY_CONFIRM)
 378         return GPG_ERR_INV_ARG;
 379
 380     /* Another handle is using this pinentry method. Allowing this instance
 381      * would reset the timeout and global handle which wouldn't be good. */
 382     if (gpwm)
 383         return GPG_ERR_PIN_BLOCKED;
 384
 385     if (pwm->pinentry_timeout != 0) {
 386         gpwm = pwm;
 387         gtimeout = abs(pwm->pinentry_timeout);
 388         gelapsed = 0;
 389     }
 390
 391     pwm->filename = (char *)filename;
 392     rc = _getpin(pwm, result, len, which);
 393     pwm->filename = p;
 394
 395     /* Don't timeout when an invalid passphrase was entered. */
 396     gtimeout = 0;
 397     gpwm = NULL;
 398     return rc;
 399 }