contrib/openpam/lib/libpam/openpam_ttyconv.c

   1 /*-
   2  * Copyright (c) 2002-2003 Networks Associates Technology, Inc.
   3  * Copyright (c) 2004-2014 Dag-Erling Smørgrav
   4  * All rights reserved.
   5  *
   6  * This software was developed for the FreeBSD Project by ThinkSec AS and
   7  * Network Associates Laboratories, the Security Research Division of
   8  * Network Associates, Inc.  under DARPA/SPAWAR contract N66001-01-C-8035
   9  * ("CBOSS"), as part of the DARPA CHATS research program.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The name of the author may not be used to endorse or promote
  20  *    products derived from this software without specific prior written
  21  *    permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * $OpenPAM: openpam_ttyconv.c 938 2017-04-30 21:34:42Z des $
  36  */
  37
  38 #ifdef HAVE_CONFIG_H
  39 # include "config.h"
  40 #endif
  41
  42 #include <sys/types.h>
  43 #include <sys/poll.h>
  44 #include <sys/time.h>
  45
  46 #include <errno.h>
  47 #include <fcntl.h>
  48 #include <signal.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <termios.h>
  53 #include <unistd.h>
  54
  55 #include <security/pam_appl.h>
  56
  57 #include "openpam_impl.h"
  58 #include "openpam_strlset.h"
  59
  60 int openpam_ttyconv_timeout = 0;
  61
  62 static volatile sig_atomic_t caught_signal;
  63
  64 /*
  65  * Handle incoming signals during tty conversation
  66  */
  67 static void
  68 catch_signal(int signo)
  69 {
  70
  71         switch (signo) {
  72         case SIGINT:
  73         case SIGQUIT:
  74         case SIGTERM:
  75                 caught_signal = signo;
  76                 break;
  77         }
  78 }
  79
  80 /*
  81  * Accept a response from the user on a tty
  82  */
  83 static int
  84 prompt_tty(int ifd, int ofd, const char *message, char *response, int echo)
  85 {
  86         struct sigaction action;
  87         struct sigaction saction_sigint, saction_sigquit, saction_sigterm;
  88         struct termios tcattr;
  89         struct timeval now, target, remaining;
  90         int remaining_ms;
  91         tcflag_t slflag;
  92         struct pollfd pfd;
  93         int serrno;
  94         int pos, ret;
  95         char ch;
  96
  97         /* write prompt */
  98         if (write(ofd, message, strlen(message)) < 0) {
  99                 openpam_log(PAM_LOG_ERROR, "write(): %m");
 100                 return (-1);
 101         }
 102
 103         /* turn echo off if requested */
 104         slflag = 0; /* prevent bogus uninitialized variable warning */
 105         if (!echo) {
 106                 if (tcgetattr(ifd, &tcattr) != 0) {
 107                         openpam_log(PAM_LOG_ERROR, "tcgetattr(): %m");
 108                         return (-1);
 109                 }
 110                 slflag = tcattr.c_lflag;
 111                 tcattr.c_lflag &= ~ECHO;
 112                 if (tcsetattr(ifd, TCSAFLUSH, &tcattr) != 0) {
 113                         openpam_log(PAM_LOG_ERROR, "tcsetattr(): %m");
 114                         return (-1);
 115                 }
 116         }
 117
 118         /* install signal handlers */
 119         caught_signal = 0;
 120         action.sa_handler = &catch_signal;
 121         action.sa_flags = 0;
 122         sigfillset(&action.sa_mask);
 123         sigaction(SIGINT, &action, &saction_sigint);
 124         sigaction(SIGQUIT, &action, &saction_sigquit);
 125         sigaction(SIGTERM, &action, &saction_sigterm);
 126
 127         /* compute timeout */
 128         if (openpam_ttyconv_timeout > 0) {
 129                 (void)gettimeofday(&now, NULL);
 130                 remaining.tv_sec = openpam_ttyconv_timeout;
 131                 remaining.tv_usec = 0;
 132                 timeradd(&now, &remaining, &target);
 133         } else {
 134                 /* prevent bogus uninitialized variable warning */
 135                 now.tv_sec = now.tv_usec = 0;
 136                 remaining.tv_sec = remaining.tv_usec = 0;
 137                 target.tv_sec = target.tv_usec = 0;
 138         }
 139
 140         /* input loop */
 141         pos = 0;
 142         ret = -1;
 143         serrno = 0;
 144         while (!caught_signal) {
 145                 pfd.fd = ifd;
 146                 pfd.events = POLLIN;
 147                 pfd.revents = 0;
 148                 if (openpam_ttyconv_timeout > 0) {
 149                         gettimeofday(&now, NULL);
 150                         if (timercmp(&now, &target, >))
 151                                 break;
 152                         timersub(&target, &now, &remaining);
 153                         remaining_ms = remaining.tv_sec * 1000 +
 154                             remaining.tv_usec / 1000;
 155                 } else {
 156                         remaining_ms = -1;
 157                 }
 158                 if ((ret = poll(&pfd, 1, remaining_ms)) < 0) {
 159                         serrno = errno;
 160                         if (errno == EINTR)
 161                                 continue;
 162                         openpam_log(PAM_LOG_ERROR, "poll(): %m");
 163                         break;
 164                 } else if (ret == 0) {
 165                         /* timeout */
 166                         write(ofd, " timed out", 10);
 167                         openpam_log(PAM_LOG_NOTICE, "timed out");
 168                         break;
 169                 }
 170                 if ((ret = read(ifd, &ch, 1)) < 0) {
 171                         serrno = errno;
 172                         openpam_log(PAM_LOG_ERROR, "read(): %m");
 173                         break;
 174                 } else if (ret == 0 || ch == '\n') {
 175                         response[pos] = '\0';
 176                         ret = pos;
 177                         break;
 178                 }
 179                 if (pos + 1 < PAM_MAX_RESP_SIZE)
 180                         response[pos++] = ch;
 181                 /* overflow is discarded */
 182         }
 183
 184         /* restore tty state */
 185         if (!echo) {
 186                 tcattr.c_lflag = slflag;
 187                 if (tcsetattr(ifd, 0, &tcattr) != 0) {
 188                         /* treat as non-fatal, since we have our answer */
 189                         openpam_log(PAM_LOG_NOTICE, "tcsetattr(): %m");
 190                 }
 191         }
 192
 193         /* restore signal handlers and re-post caught signal*/
 194         sigaction(SIGINT, &saction_sigint, NULL);
 195         sigaction(SIGQUIT, &saction_sigquit, NULL);
 196         sigaction(SIGTERM, &saction_sigterm, NULL);
 197         if (caught_signal != 0) {
 198                 openpam_log(PAM_LOG_ERROR, "caught signal %d",
 199                     (int)caught_signal);
 200                 raise((int)caught_signal);
 201                 /* if raise() had no effect... */
 202                 serrno = EINTR;
 203                 ret = -1;
 204         }
 205
 206         /* done */
 207         write(ofd, "\n", 1);
 208         errno = serrno;
 209         return (ret);
 210 }
 211
 212 /*
 213  * Accept a response from the user on a non-tty stdin.
 214  */
 215 static int
 216 prompt_notty(const char *message, char *response)
 217 {
 218         struct timeval now, target, remaining;
 219         int remaining_ms;
 220         struct pollfd pfd;
 221         int ch, pos, ret;
 222
 223         /* show prompt */
 224         fputs(message, stdout);
 225         fflush(stdout);
 226
 227         /* compute timeout */
 228         if (openpam_ttyconv_timeout > 0) {
 229                 (void)gettimeofday(&now, NULL);
 230                 remaining.tv_sec = openpam_ttyconv_timeout;
 231                 remaining.tv_usec = 0;
 232                 timeradd(&now, &remaining, &target);
 233         } else {
 234                 /* prevent bogus uninitialized variable warning */
 235                 now.tv_sec = now.tv_usec = 0;
 236                 remaining.tv_sec = remaining.tv_usec = 0;
 237                 target.tv_sec = target.tv_usec = 0;
 238         }
 239
 240         /* input loop */
 241         pos = 0;
 242         for (;;) {
 243                 pfd.fd = STDIN_FILENO;
 244                 pfd.events = POLLIN;
 245                 pfd.revents = 0;
 246                 if (openpam_ttyconv_timeout > 0) {
 247                         gettimeofday(&now, NULL);
 248                         if (timercmp(&now, &target, >))
 249                                 break;
 250                         timersub(&target, &now, &remaining);
 251                         remaining_ms = remaining.tv_sec * 1000 +
 252                             remaining.tv_usec / 1000;
 253                 } else {
 254                         remaining_ms = -1;
 255                 }
 256                 if ((ret = poll(&pfd, 1, remaining_ms)) < 0) {
 257                         /* interrupt is ok, everything else -> bail */
 258                         if (errno == EINTR)
 259                                 continue;
 260                         perror("\nopenpam_ttyconv");
 261                         return (-1);
 262                 } else if (ret == 0) {
 263                         /* timeout */
 264                         break;
 265                 } else {
 266                         /* input */
 267                         if ((ch = getchar()) == EOF && ferror(stdin)) {
 268                                 perror("\nopenpam_ttyconv");
 269                                 return (-1);
 270                         }
 271                         if (ch == EOF || ch == '\n') {
 272                                 response[pos] = '\0';
 273                                 return (pos);
 274                         }
 275                         if (pos + 1 < PAM_MAX_RESP_SIZE)
 276                                 response[pos++] = ch;
 277                         /* overflow is discarded */
 278                 }
 279         }
 280         fputs("\nopenpam_ttyconv: timeout\n", stderr);
 281         return (-1);
 282 }
 283
 284 /*
 285  * Determine whether stdin is a tty; if not, try to open the tty; in
 286  * either case, call the appropriate method.
 287  */
 288 static int
 289 prompt(const char *message, char *response, int echo)
 290 {
 291         int ifd, ofd, ret;
 292
 293         if (isatty(STDIN_FILENO)) {
 294                 fflush(stdout);
 295 #ifdef HAVE_FPURGE
 296                 fpurge(stdin);
 297 #endif
 298                 ifd = STDIN_FILENO;
 299                 ofd = STDOUT_FILENO;
 300         } else {
 301                 if ((ifd = open("/dev/tty", O_RDWR)) < 0)
 302                         /* no way to prevent echo */
 303                         return (prompt_notty(message, response));
 304                 ofd = ifd;
 305         }
 306         ret = prompt_tty(ifd, ofd, message, response, echo);
 307         if (ifd != STDIN_FILENO)
 308                 close(ifd);
 309         return (ret);
 310 }
 311
 312 /*
 313  * OpenPAM extension
 314  *
 315  * Simple tty-based conversation function
 316  */
 317
 318 int
 319 openpam_ttyconv(int n,
 320          const struct pam_message **msg,
 321          struct pam_response **resp,
 322          void *data)
 323 {
 324         char respbuf[PAM_MAX_RESP_SIZE];
 325         struct pam_response *aresp;
 326         int i;
 327
 328         ENTER();
 329         (void)data;
 330         if (n <= 0 || n > PAM_MAX_NUM_MSG)
 331                 RETURNC(PAM_CONV_ERR);
 332         if ((aresp = calloc(n, sizeof *aresp)) == NULL)
 333                 RETURNC(PAM_BUF_ERR);
 334         for (i = 0; i < n; ++i) {
 335                 aresp[i].resp_retcode = 0;
 336                 aresp[i].resp = NULL;
 337                 switch (msg[i]->msg_style) {
 338                 case PAM_PROMPT_ECHO_OFF:
 339                         if (prompt(msg[i]->msg, respbuf, 0) < 0 ||
 340                             (aresp[i].resp = strdup(respbuf)) == NULL)
 341                                 goto fail;
 342                         break;
 343                 case PAM_PROMPT_ECHO_ON:
 344                         if (prompt(msg[i]->msg, respbuf, 1) < 0 ||
 345                             (aresp[i].resp = strdup(respbuf)) == NULL)
 346                                 goto fail;
 347                         break;
 348                 case PAM_ERROR_MSG:
 349                         fputs(msg[i]->msg, stderr);
 350                         if (strlen(msg[i]->msg) > 0 &&
 351                             msg[i]->msg[strlen(msg[i]->msg) - 1] != '\n')
 352                                 fputc('\n', stderr);
 353                         break;
 354                 case PAM_TEXT_INFO:
 355                         fputs(msg[i]->msg, stdout);
 356                         if (strlen(msg[i]->msg) > 0 &&
 357                             msg[i]->msg[strlen(msg[i]->msg) - 1] != '\n')
 358                                 fputc('\n', stdout);
 359                         break;
 360                 default:
 361                         goto fail;
 362                 }
 363         }
 364         *resp = aresp;
 365         memset(respbuf, 0, sizeof respbuf);
 366         RETURNC(PAM_SUCCESS);
 367 fail:
 368         for (i = 0; i < n; ++i) {
 369                 if (aresp[i].resp != NULL) {
 370                         strlset(aresp[i].resp, 0, PAM_MAX_RESP_SIZE);
 371                         FREE(aresp[i].resp);
 372                 }
 373         }
 374         memset(aresp, 0, n * sizeof *aresp);
 375         FREE(aresp);
 376         *resp = NULL;
 377         memset(respbuf, 0, sizeof respbuf);
 378         RETURNC(PAM_CONV_ERR);
 379 }
 380
 381 /*
 382  * Error codes:
 383  *
 384  *      PAM_SYSTEM_ERR
 385  *      PAM_BUF_ERR
 386  *      PAM_CONV_ERR
 387  */
 388
 389 /**
 390  * The =openpam_ttyconv function is a standard conversation function
 391  * suitable for use on TTY devices.
 392  * It should be adequate for the needs of most text-based interactive
 393  * programs.
 394  *
 395  * The =openpam_ttyconv function allows the application to specify a
 396  * timeout for user input by setting the global integer variable
 397  * :openpam_ttyconv_timeout to the length of the timeout in seconds.
 398  *
 399  * >openpam_nullconv
 400  * >pam_prompt
 401  * >pam_vprompt
 402  */