[BACK]Return to login.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / login

Annotation of src/usr.bin/login/login.c, Revision 1.73

1.73    ! deraadt     1: /*     $OpenBSD: login.c,v 1.72 2019/12/04 09:51:07 deraadt Exp $      */
1.3       deraadt     2: /*     $NetBSD: login.c,v 1.13 1996/05/15 23:50:16 jtc Exp $   */
1.1       deraadt     3:
                      4: /*-
                      5:  * Copyright (c) 1980, 1987, 1988, 1991, 1993, 1994
                      6:  *     The Regents of the University of California.  All rights reserved.
                      7:  *
                      8:  * Redistribution and use in source and binary forms, with or without
                      9:  * modification, are permitted provided that the following conditions
                     10:  * are met:
                     11:  * 1. Redistributions of source code must retain the above copyright
                     12:  *    notice, this list of conditions and the following disclaimer.
                     13:  * 2. Redistributions in binary form must reproduce the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer in the
                     15:  *    documentation and/or other materials provided with the distribution.
1.50      millert    16:  * 3. Neither the name of the University nor the names of its contributors
1.1       deraadt    17:  *    may be used to endorse or promote products derived from this software
                     18:  *    without specific prior written permission.
                     19:  *
                     20:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
                     21:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     22:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     23:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
                     24:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     25:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     26:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     27:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     28:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     29:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     30:  * SUCH DAMAGE.
                     31:  */
1.36      millert    32: /*-
                     33:  * Copyright (c) 1995 Berkeley Software Design, Inc. All rights reserved.
                     34:  *
                     35:  * Redistribution and use in source and binary forms, with or without
                     36:  * modification, are permitted provided that the following conditions
                     37:  * are met:
                     38:  * 1. Redistributions of source code must retain the above copyright
                     39:  *    notice, this list of conditions and the following disclaimer.
                     40:  * 2. Redistributions in binary form must reproduce the above copyright
                     41:  *    notice, this list of conditions and the following disclaimer in the
                     42:  *    documentation and/or other materials provided with the distribution.
                     43:  * 3. All advertising materials mentioning features or use of this software
                     44:  *    must display the following acknowledgement:
                     45:  *      This product includes software developed by Berkeley Software Design,
                     46:  *      Inc.
                     47:  * 4. The name of Berkeley Software Design, Inc.  may not be used to endorse
                     48:  *    or promote products derived from this software without specific prior
                     49:  *    written permission.
                     50:  *
                     51:  * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN, INC. ``AS IS'' AND
                     52:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
                     53:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
                     54:  * ARE DISCLAIMED.  IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN, INC. BE LIABLE
                     55:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
                     56:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
                     57:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
                     58:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
                     59:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
                     60:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
                     61:  * SUCH DAMAGE.
                     62:  *
                     63:  *     BSDI $From: login.c,v 2.28 1999/09/08 22:35:36 prb Exp $
                     64:  */
1.1       deraadt    65:
                     66: /*
                     67:  * login [ name ]
                     68:  * login -h hostname   (for telnetd, etc.)
                     69:  * login -f name       (for pre-authenticated login: datakit, xterm, etc.)
1.49      millert    70:  * login -p            (preserve existing environment; for getty)
1.1       deraadt    71:  */
                     72:
1.36      millert    73: #include <sys/socket.h>
1.1       deraadt    74: #include <sys/stat.h>
                     75: #include <sys/time.h>
                     76: #include <sys/resource.h>
1.11      millert    77: #include <sys/wait.h>
1.1       deraadt    78:
                     79: #include <err.h>
                     80: #include <errno.h>
1.27      millert    81: #include <fcntl.h>
1.1       deraadt    82: #include <grp.h>
1.30      millert    83: #include <login_cap.h>
1.36      millert    84: #include <netdb.h>
1.1       deraadt    85: #include <pwd.h>
                     86: #include <signal.h>
1.36      millert    87: #include <stdarg.h>
1.1       deraadt    88: #include <stdio.h>
                     89: #include <stdlib.h>
                     90: #include <string.h>
                     91: #include <syslog.h>
                     92: #include <ttyent.h>
                     93: #include <unistd.h>
1.63      deraadt    94: #include <limits.h>
1.1       deraadt    95: #include <utmp.h>
1.3       deraadt    96: #include <util.h>
1.36      millert    97: #include <bsd_auth.h>
                     98:
1.1       deraadt    99: #include "pathnames.h"
                    100:
1.45      millert   101: void    badlogin(char *);
                    102: void    dolastlog(int);
                    103: void    getloginname(void);
                    104: void    motd(void);
                    105: void    quickexit(int);
                    106: int     rootterm(char *);
                    107: void    sigint(int);
                    108: void    sighup(int);
                    109: void    sleepexit(int);
                    110: char   *stypeof(char *);
                    111: void    timedout(int);
                    112: int     main(int, char **);
1.1       deraadt   113:
1.45      millert   114: extern int check_failedlogin(uid_t);
                    115: extern void log_failedlogin(uid_t, char *, char *, char *);
1.1       deraadt   116:
                    117: #define        TTYGRPNAME      "tty"           /* name of group to own ttys */
                    118:
1.64      millert   119: #define        SECSPERDAY      (24 * 60 * 60)
                    120: #define        TWOWEEKS        (2 * 7 * SECSPERDAY)
                    121:
1.1       deraadt   122: /*
1.37      millert   123:  * This bounds the time given to login; may be overridden by /etc/login.conf.
1.1       deraadt   124:  */
1.30      millert   125: u_int          timeout = 300;
1.1       deraadt   126:
1.36      millert   127: struct passwd  *pwd;
1.30      millert   128: login_cap_t    *lc = NULL;
1.36      millert   129: auth_session_t *as = NULL;
1.30      millert   130: int            failures;
1.36      millert   131: int            needbanner = 1;
1.30      millert   132: char           term[64], *hostname, *tty;
1.36      millert   133: char           *style;
1.30      millert   134: char           *username = NULL, *rusername = NULL;
1.1       deraadt   135:
1.47      deraadt   136: extern char **environ;
                    137:
1.1       deraadt   138: int
1.47      deraadt   139: main(int argc, char *argv[])
1.1       deraadt   140: {
1.47      deraadt   141:        char *domain, *p, *ttyn, *shell, *fullname, *instance;
                    142:        char *lipaddr, *script, *ripaddr, *style, *type, *fqdn;
1.63      deraadt   143:        char tbuf[PATH_MAX + 2], tname[sizeof(_PATH_TTY) + 10];
                    144:        char localhost[HOST_NAME_MAX+1], *copyright;
1.59      martynas  145:        char mail[sizeof(_PATH_MAILDIR) + 1 + NAME_MAX];
1.47      deraadt   146:        int ask, ch, cnt, fflag, pflag, quietlog, rootlogin, lastchance;
                    147:        int error, homeless, needto, authok, tries, backoff;
1.36      millert   148:        struct addrinfo *ai, hints;
1.47      deraadt   149:        struct rlimit cds, scds;
                    150:        quad_t expire, warning;
                    151:        struct utmp utmp;
1.1       deraadt   152:        struct group *gr;
                    153:        struct stat st;
                    154:        uid_t uid;
                    155:
                    156:        openlog("login", LOG_ODELAY, LOG_AUTH);
                    157:
1.37      millert   158:        fqdn = lipaddr = ripaddr = fullname = type = NULL;
                    159:        authok = 0;
                    160:        tries = 10;
                    161:        backoff = 3;
1.36      millert   162:
1.1       deraadt   163:        domain = NULL;
1.71      deraadt   164:        if (gethostname(localhost, sizeof(localhost)) == -1) {
1.1       deraadt   165:                syslog(LOG_ERR, "couldn't get local hostname: %m");
1.49      millert   166:                strlcpy(localhost, "localhost", sizeof(localhost));
                    167:        } else if ((domain = strchr(localhost, '.'))) {
1.21      deraadt   168:                domain++;
                    169:                if (*domain && strchr(domain, '.') == NULL)
                    170:                        domain = localhost;
                    171:        }
1.1       deraadt   172:
1.36      millert   173:        if ((as = auth_open()) == NULL) {
1.39      millert   174:                syslog(LOG_ERR, "auth_open: %m");
                    175:                err(1, "unable to initialize BSD authentication");
1.36      millert   176:        }
1.39      millert   177:        auth_setoption(as, "login", "yes");
1.36      millert   178:
1.49      millert   179:        /*
                    180:         * -p is used by getty to tell login not to destroy the environment
                    181:         * -f is used to skip a second login authentication
                    182:         * -h is used by other servers to pass the name of the remote
                    183:         *    host to login so that it may be placed in utmp and wtmp
                    184:         */
1.36      millert   185:        fflag = pflag = 0;
1.1       deraadt   186:        uid = getuid();
1.36      millert   187:        while ((ch = getopt(argc, argv, "fh:pu:L:R:")) != -1)
1.1       deraadt   188:                switch (ch) {
                    189:                case 'f':
                    190:                        fflag = 1;
                    191:                        break;
                    192:                case 'h':
1.36      millert   193:                        if (uid) {
1.62      guenther  194:                                warnc(EPERM, "-h option");
1.36      millert   195:                                quickexit(1);
                    196:                        }
1.60      tobias    197:                        free(fqdn);
1.36      millert   198:                        if ((fqdn = strdup(optarg)) == NULL) {
                    199:                                warn(NULL);
                    200:                                quickexit(1);
                    201:                        }
                    202:                        auth_setoption(as, "fqdn", fqdn);
1.1       deraadt   203:                        if (domain && (p = strchr(optarg, '.')) &&
1.21      deraadt   204:                            strcasecmp(p+1, domain) == 0)
1.1       deraadt   205:                                *p = 0;
                    206:                        hostname = optarg;
1.36      millert   207:                        auth_setoption(as, "hostname", hostname);
                    208:                        break;
                    209:                case 'L':
                    210:                        if (uid) {
1.62      guenther  211:                                warnc(EPERM, "-L option");
1.36      millert   212:                                quickexit(1);
                    213:                        }
                    214:                        if (lipaddr) {
                    215:                                warnx("duplicate -L option");
                    216:                                quickexit(1);
                    217:                        }
                    218:                        lipaddr = optarg;
                    219:                        memset(&hints, 0, sizeof(hints));
                    220:                        hints.ai_family = PF_UNSPEC;
                    221:                        hints.ai_flags = AI_CANONNAME;
                    222:                        error = getaddrinfo(lipaddr, NULL, &hints, &ai);
                    223:                        if (!error) {
                    224:                                strlcpy(localhost, ai->ai_canonname,
                    225:                                    sizeof(localhost));
                    226:                                freeaddrinfo(ai);
                    227:                        } else
                    228:                                strlcpy(localhost, lipaddr, sizeof(localhost));
                    229:                        auth_setoption(as, "local_addr", lipaddr);
1.1       deraadt   230:                        break;
                    231:                case 'p':
                    232:                        pflag = 1;
                    233:                        break;
1.36      millert   234:                case 'R':
                    235:                        if (uid) {
1.62      guenther  236:                                warnc(EPERM, "-R option");
1.36      millert   237:                                quickexit(1);
                    238:                        }
                    239:                        if (ripaddr) {
                    240:                                warnx("duplicate -R option");
                    241:                                quickexit(1);
                    242:                        }
                    243:                        ripaddr = optarg;
                    244:                        auth_setoption(as, "remote_addr", ripaddr);
                    245:                        break;
1.14      millert   246:                case 'u':
1.36      millert   247:                        if (uid) {
1.62      guenther  248:                                warnc(EPERM, "-u option");
1.36      millert   249:                                quickexit(1);
                    250:                        }
1.14      millert   251:                        rusername = optarg;
                    252:                        break;
1.1       deraadt   253:                default:
                    254:                        if (!uid)
                    255:                                syslog(LOG_ERR, "invalid flag %c", ch);
                    256:                        (void)fprintf(stderr,
1.57      jmc       257:                            "usage: login [-fp] [-h hostname] [-L local-addr] "
                    258:                            "[-R remote-addr] [-u username]\n\t[user]\n");
1.36      millert   259:                        quickexit(1);
1.1       deraadt   260:                }
                    261:        argc -= optind;
                    262:        argv += optind;
                    263:
                    264:        if (*argv) {
                    265:                username = *argv;
                    266:                ask = 0;
                    267:        } else
                    268:                ask = 1;
                    269:
1.49      millert   270:        /*
                    271:         * If effective user is not root, just run su(1) to emulate login(1).
                    272:         */
                    273:        if (geteuid() != 0) {
                    274:                char *av[5], **ap;
                    275:
                    276:                auth_close(as);
                    277:                closelog();
1.54      millert   278:                closefrom(STDERR_FILENO + 1);
1.49      millert   279:
                    280:                ap = av;
                    281:                *ap++ = _PATH_SU;
                    282:                *ap++ = "-L";
                    283:                if (!pflag)
                    284:                        *ap++ = "-l";
                    285:                if (!ask)
                    286:                        *ap++ = username;
                    287:                *ap = NULL;
                    288:                execv(_PATH_SU, av);
                    289:                warn("unable to exec %s", _PATH_SU);
                    290:                _exit(1);
                    291:        }
                    292:
1.1       deraadt   293:        ttyn = ttyname(STDIN_FILENO);
                    294:        if (ttyn == NULL || *ttyn == '\0') {
                    295:                (void)snprintf(tname, sizeof(tname), "%s??", _PATH_TTY);
                    296:                ttyn = tname;
                    297:        }
1.12      millert   298:        if ((tty = strrchr(ttyn, '/')))
1.1       deraadt   299:                ++tty;
                    300:        else
                    301:                tty = ttyn;
                    302:
1.49      millert   303:        /*
                    304:         * Since login deals with sensitive information, turn off coredumps.
                    305:         */
1.71      deraadt   306:        if (getrlimit(RLIMIT_CORE, &scds) == -1) {
1.49      millert   307:                syslog(LOG_ERR, "couldn't get core dump size: %m");
                    308:                scds.rlim_cur = scds.rlim_max = QUAD_MIN;
                    309:        }
                    310:        cds.rlim_cur = cds.rlim_max = 0;
1.71      deraadt   311:        if (setrlimit(RLIMIT_CORE, &cds) == -1) {
1.49      millert   312:                syslog(LOG_ERR, "couldn't set core dump size to 0: %m");
                    313:                scds.rlim_cur = scds.rlim_max = QUAD_MIN;
                    314:        }
                    315:
                    316:        (void)signal(SIGALRM, timedout);
                    317:        if (argc > 1) {
                    318:                needto = 0;
                    319:                (void)alarm(timeout);
                    320:        } else
                    321:                needto = 1;
                    322:        (void)signal(SIGQUIT, SIG_IGN);
                    323:        (void)signal(SIGINT, SIG_IGN);
                    324:        (void)signal(SIGHUP, SIG_IGN);
                    325:        (void)setpriority(PRIO_PROCESS, 0, 0);
1.36      millert   326:
                    327:        /* get the default login class */
1.47      deraadt   328:        if ((lc = login_getclass(0)) == NULL) { /* get the default class */
1.36      millert   329:                warnx("Failure to retrieve default class");
                    330:                quickexit(1);
                    331:        }
1.37      millert   332:        timeout = (u_int)login_getcapnum(lc, "login-timeout", 300, 300);
1.36      millert   333:        if ((script = login_getcapstr(lc, "classify", NULL, NULL)) != NULL) {
                    334:                unsetenv("AUTH_TYPE");
                    335:                unsetenv("REMOTE_NAME");
                    336:                if (script[0] != '/') {
                    337:                        syslog(LOG_ERR, "Invalid classify script: %s", script);
                    338:                        warnx("Classification failure");
                    339:                        quickexit(1);
                    340:                }
                    341:                shell = strrchr(script, '/') + 1;
                    342:                auth_setstate(as, AUTH_OKAY);
1.72      deraadt   343:                if (fflag) {
                    344:                        auth_call(as, script, shell, "-f", "--", username,
                    345:                            (char *)NULL);
                    346:                } else {
                    347:                        auth_call(as, script, shell, "--", username,
                    348:                            (char *)NULL);
                    349:                }
1.36      millert   350:                if (!(auth_getstate(as) & AUTH_ALLOW))
                    351:                        quickexit(1);
                    352:                auth_setenv(as);
                    353:                if ((p = getenv("AUTH_TYPE")) != NULL &&
                    354:                    strncmp(p, "auth-", 5) == 0)
                    355:                        type = p;
                    356:                if ((p = getenv("REMOTE_NAME")) != NULL)
                    357:                        hostname = p;
                    358:                /*
                    359:                 * we may have changed some values, reset them
                    360:                 */
                    361:                auth_clroptions(as);
                    362:                if (type)
                    363:                        auth_setoption(as, "auth_type", type);
                    364:                if (fqdn)
                    365:                        auth_setoption(as, "fqdn", fqdn);
                    366:                if (hostname)
                    367:                        auth_setoption(as, "hostname", hostname);
                    368:                if (lipaddr)
                    369:                        auth_setoption(as, "local_addr", lipaddr);
                    370:                if (ripaddr)
                    371:                        auth_setoption(as, "remote_addr", ripaddr);
                    372:        }
                    373:
                    374:        /*
1.72      deraadt   375:         * Request that things like the approval script print things
1.36      millert   376:         * to stdout (in particular, the nologins files)
                    377:         */
                    378:        auth_setitem(as, AUTHV_INTERACTIVE, "True");
                    379:
1.1       deraadt   380:        for (cnt = 0;; ask = 1) {
1.36      millert   381:                /*
                    382:                 * Clean up our current authentication session.
                    383:                 * Options are not cleared so we need to clear any
                    384:                 * we might set below.
                    385:                 */
                    386:                auth_clean(as);
                    387:                auth_clroption(as, "style");
                    388:                auth_clroption(as, "lastchance");
                    389:
                    390:                lastchance = 0;
                    391:
1.1       deraadt   392:                if (ask) {
                    393:                        fflag = 0;
                    394:                        getloginname();
                    395:                }
1.36      millert   396:                if (needto) {
                    397:                        needto = 0;
                    398:                        alarm(timeout);
                    399:                }
1.47      deraadt   400:                if ((style = strchr(username, ':')) != NULL)
1.36      millert   401:                        *style++ = '\0';
1.66      mmcc      402:                free(fullname);
1.36      millert   403:                if (auth_setitem(as, AUTHV_NAME, username) < 0 ||
                    404:                    (fullname = strdup(username)) == NULL) {
                    405:                        syslog(LOG_ERR, "%m");
                    406:                        warn(NULL);
                    407:                        quickexit(1);
                    408:                }
1.1       deraadt   409:                rootlogin = 0;
1.55      millert   410:                if ((instance = strchr(username, '/')) != NULL) {
1.40      millert   411:                        if (strncmp(instance + 1, "root", 4) == 0)
1.1       deraadt   412:                                rootlogin = 1;
1.70      fcambus   413:                        *instance = '\0';
                    414:                }
1.36      millert   415:
1.1       deraadt   416:                if (strlen(username) > UT_NAMESIZE)
                    417:                        username[UT_NAMESIZE] = '\0';
                    418:
                    419:                /*
                    420:                 * Note if trying multiple user names; log failures for
                    421:                 * previous user name, but don't bother logging one failure
                    422:                 * for nonexistent name (mistyped username).
                    423:                 */
                    424:                if (failures && strcmp(tbuf, username)) {
                    425:                        if (failures > (pwd ? 0 : 1))
                    426:                                badlogin(tbuf);
                    427:                        failures = 0;
                    428:                }
1.36      millert   429:                (void)strlcpy(tbuf, username, sizeof(tbuf));
1.1       deraadt   430:
1.36      millert   431:                if ((pwd = getpwnam(username)) != NULL &&
                    432:                    auth_setpwd(as, pwd) < 0) {
                    433:                        syslog(LOG_ERR, "%m");
                    434:                        warn(NULL);
                    435:                        quickexit(1);
                    436:                }
1.1       deraadt   437:
1.36      millert   438:                lc = login_getclass(pwd ? pwd->pw_class : NULL);
                    439:                if (!lc)
                    440:                        goto failed;
1.1       deraadt   441:
1.36      millert   442:                style = login_getstyle(lc, style, type);
                    443:                if (!style)
                    444:                        goto failed;
1.1       deraadt   445:
1.36      millert   446:                /*
1.37      millert   447:                 * We allow "login-tries" attempts to login but start
                    448:                 * slowing down after "login-backoff" attempts.
                    449:                 */
                    450:                tries = (int)login_getcapnum(lc, "login-tries", 10, 10);
                    451:                backoff = (int)login_getcapnum(lc, "login-backoff", 3, 3);
                    452:
                    453:                /*
1.60      tobias    454:                 * Turn off the fflag if we have an invalid user
1.36      millert   455:                 * or we are not root and we are trying to change uids.
                    456:                 */
                    457:                if (!pwd || (uid && uid != pwd->pw_uid))
                    458:                        fflag = 0;
1.1       deraadt   459:
1.36      millert   460:                if (pwd && pwd->pw_uid == 0)
                    461:                        rootlogin = 1;
1.25      millert   462:
1.36      millert   463:                /*
                    464:                 * If we do not have the force flag authenticate the user
                    465:                 */
1.44      millert   466:                if (!fflag) {
1.36      millert   467:                        lastchance =
                    468:                            login_getcaptime(lc, "password-dead", 0, 0) != 0;
                    469:                        if (lastchance)
                    470:                                auth_setoption(as, "lastchance", "yes");
                    471:                        /*
                    472:                         * Once we start asking for a password
                    473:                         *  we want to log a failure on a hup.
                    474:                         */
                    475:                        signal(SIGHUP, sighup);
                    476:                        auth_verify(as, style, NULL, lc->lc_class, NULL);
                    477:                        authok = auth_getstate(as);
                    478:                        /*
                    479:                         * If their password expired and it has not been
                    480:                         * too long since then, give the user one last
                    481:                         * chance to change their password
                    482:                         */
                    483:                        if ((authok & AUTH_PWEXPIRED) && lastchance) {
                    484:                                authok = AUTH_OKAY;
                    485:                        } else
                    486:                                lastchance = 0;
                    487:                        if ((authok & AUTH_ALLOW) == 0)
                    488:                                goto failed;
                    489:                        if (auth_setoption(as, "style", style) < 0) {
                    490:                                syslog(LOG_ERR, "%m");
                    491:                                warn(NULL);
                    492:                                quickexit(1);
1.25      millert   493:                        }
1.1       deraadt   494:                }
1.36      millert   495:                /*
                    496:                 * explicitly reject users without password file entries
                    497:                 */
1.47      deraadt   498:                if (pwd == NULL)
1.36      millert   499:                        goto failed;
1.1       deraadt   500:
                    501:                /*
1.36      millert   502:                 * If trying to log in as root on an insecure terminal,
                    503:                 * refuse the login attempt unless the authentication
                    504:                 * style explicitly says a root login is okay.
1.1       deraadt   505:                 */
1.44      millert   506:                if (pwd && rootlogin && !rootterm(tty))
1.36      millert   507:                        goto failed;
1.29      millert   508:
1.36      millert   509:                if (fflag) {
                    510:                        type = 0;
                    511:                        style = "forced";
                    512:                }
                    513:                break;
                    514:
                    515: failed:
                    516:                if (authok & AUTH_SILENT)
                    517:                        quickexit(0);
1.29      millert   518:                if (rootlogin && !rootterm(tty)) {
1.36      millert   519:                        warnx("%s login refused on this terminal.",
                    520:                            fullname);
1.1       deraadt   521:                        if (hostname)
                    522:                                syslog(LOG_NOTICE,
1.14      millert   523:                                    "LOGIN %s REFUSED FROM %s%s%s ON TTY %s",
1.36      millert   524:                                    fullname, rusername ? rusername : "",
1.14      millert   525:                                    rusername ? "@" : "", hostname, tty);
1.1       deraadt   526:                        else
                    527:                                syslog(LOG_NOTICE,
                    528:                                    "LOGIN %s REFUSED ON TTY %s",
1.47      deraadt   529:                                    fullname, tty);
1.36      millert   530:                } else {
                    531:                        if (!as || (p = auth_getvalue(as, "errormsg")) == NULL)
                    532:                                p = "Login incorrect";
                    533:                        (void)printf("%s\n", p);
                    534:                }
1.1       deraadt   535:                failures++;
1.13      millert   536:                if (pwd)
1.14      millert   537:                        log_failedlogin(pwd->pw_uid, hostname, rusername, tty);
1.37      millert   538:                /*
                    539:                 * By default, we allow 10 tries, but after 3 we start
                    540:                 * backing off to slow down password guessers.
                    541:                 */
                    542:                if (++cnt > backoff) {
                    543:                        if (cnt >= tries) {
1.1       deraadt   544:                                badlogin(username);
                    545:                                sleepexit(1);
                    546:                        }
1.68      beck      547:                        sleep(1);
1.1       deraadt   548:                }
                    549:        }
                    550:
                    551:        /* committed to login -- turn off timeout */
1.36      millert   552:        (void)alarm(0);
1.1       deraadt   553:
                    554:        endpwent();
                    555:
1.30      millert   556:        shell = login_getcapstr(lc, "shell", pwd->pw_shell, pwd->pw_shell);
                    557:        if (*shell == '\0')
                    558:                shell = _PATH_BSHELL;
1.63      deraadt   559:        else if (strlen(shell) >= PATH_MAX) {
1.30      millert   560:                syslog(LOG_ERR, "shell path too long: %s", shell);
                    561:                warnx("invalid shell");
1.36      millert   562:                quickexit(1);
1.24      art       563:        }
1.1       deraadt   564:
                    565:        /* Destroy environment unless user has requested its preservation. */
1.24      art       566:        if (!pflag) {
1.22      deraadt   567:                if ((environ = calloc(1, sizeof (char *))) == NULL)
                    568:                        err(1, "calloc");
1.24      art       569:        } else {
1.9       millert   570:                char **cpp, **cpp2;
                    571:
                    572:                for (cpp2 = cpp = environ; *cpp; cpp++) {
                    573:                        if (strncmp(*cpp, "LD_", 3) &&
1.29      millert   574:                            strncmp(*cpp, "ENV=", 4) &&
                    575:                            strncmp(*cpp, "BASH_ENV=", 9) &&
1.9       millert   576:                            strncmp(*cpp, "IFS=", 4))
                    577:                                *cpp2++ = *cpp;
                    578:                }
                    579:                *cpp2 = 0;
                    580:        }
1.30      millert   581:        /* Note: setusercontext(3) will set PATH */
1.34      deraadt   582:        if (setenv("HOME", pwd->pw_dir, 1) == -1 ||
1.58      martynas  583:            setenv("SHELL", pwd->pw_shell, 1) == -1) {
1.34      deraadt   584:                warn("unable to setenv()");
1.36      millert   585:                quickexit(1);
1.34      deraadt   586:        }
1.1       deraadt   587:        if (term[0] == '\0')
1.29      millert   588:                (void)strlcpy(term, stypeof(tty), sizeof(term));
1.59      martynas  589:        (void)snprintf(mail, sizeof(mail), "%s/%s", _PATH_MAILDIR,
                    590:                pwd->pw_name);
1.34      deraadt   591:        if (setenv("TERM", term, 0) == -1 ||
                    592:            setenv("LOGNAME", pwd->pw_name, 1) == -1 ||
1.59      martynas  593:            setenv("USER", pwd->pw_name, 1) == -1 ||
                    594:            setenv("MAIL", mail, 1) == -1) {
1.34      deraadt   595:                warn("unable to setenv()");
1.36      millert   596:                quickexit(1);
1.34      deraadt   597:        }
                    598:        if (hostname) {
                    599:                if (setenv("REMOTEHOST", hostname, 1) == -1) {
                    600:                        warn("unable to setenv()");
1.36      millert   601:                        quickexit(1);
1.34      deraadt   602:                }
                    603:        }
                    604:        if (rusername) {
                    605:                if (setenv("REMOTEUSER", rusername, 1) == -1) {
                    606:                        warn("unable to setenv()");
1.36      millert   607:                        quickexit(1);
1.34      deraadt   608:                }
                    609:        }
1.36      millert   610:
                    611:        if (setusercontext(lc, pwd, pwd->pw_uid, LOGIN_SETPATH)) {
                    612:                warn("unable to set user context");
                    613:                quickexit(1);
                    614:        }
                    615:        auth_setenv(as);
                    616:
                    617:        /* if user not super-user, check for disabled logins */
                    618:        if (!rootlogin)
                    619:                auth_checknologin(lc);
                    620:
                    621:        setegid(pwd->pw_gid);
                    622:        seteuid(pwd->pw_uid);
                    623:
                    624:        homeless = chdir(pwd->pw_dir);
                    625:        if (homeless) {
                    626:                if (login_getcapbool(lc, "requirehome", 0)) {
                    627:                        (void)printf("No home directory %s!\n", pwd->pw_dir);
                    628:                        quickexit(1);
1.34      deraadt   629:                }
1.36      millert   630:                if (chdir("/"))
                    631:                        quickexit(0);
1.34      deraadt   632:        }
1.36      millert   633:
                    634:        quietlog = ((strcmp(pwd->pw_shell, "/sbin/nologin") == 0) ||
                    635:            login_getcapbool(lc, "hushlogin", 0) ||
                    636:            (access(_PATH_HUSHLOGIN, F_OK) == 0));
                    637:
                    638:        seteuid(0);
                    639:        setegid(0);     /* XXX use a saved gid instead? */
                    640:
                    641:        if ((p = auth_getvalue(as, "warnmsg")) != NULL)
                    642:                (void)printf("WARNING: %s\n\n", p);
                    643:
                    644:        expire = auth_check_expire(as);
                    645:        if (expire < 0) {
                    646:                (void)printf("Sorry -- your account has expired.\n");
                    647:                quickexit(1);
                    648:        } else if (expire > 0 && !quietlog) {
                    649:                warning = login_getcaptime(lc, "expire-warn",
1.64      millert   650:                    TWOWEEKS, TWOWEEKS);
1.36      millert   651:                if (expire < warning)
1.47      deraadt   652:                        (void)printf("Warning: your account expires on %s",
1.36      millert   653:                            ctime(&pwd->pw_expire));
1.34      deraadt   654:        }
1.36      millert   655:
                    656:        /* Nothing else left to fail -- really log in. */
                    657:        (void)signal(SIGHUP, SIG_DFL);
                    658:        memset(&utmp, 0, sizeof(utmp));
                    659:        (void)time(&utmp.ut_time);
                    660:        (void)strncpy(utmp.ut_name, username, sizeof(utmp.ut_name));
                    661:        if (hostname)
                    662:                (void)strncpy(utmp.ut_host, hostname, sizeof(utmp.ut_host));
                    663:        (void)strncpy(utmp.ut_line, tty, sizeof(utmp.ut_line));
                    664:        login(&utmp);
                    665:
                    666:        if (!quietlog)
                    667:                (void)check_failedlogin(pwd->pw_uid);
                    668:        dolastlog(quietlog);
                    669:
                    670:        login_fbtab(tty, pwd->pw_uid, pwd->pw_gid);
                    671:
                    672:        (void)chown(ttyn, pwd->pw_uid,
                    673:            (gr = getgrnam(TTYGRPNAME)) ? gr->gr_gid : pwd->pw_gid);
                    674:
1.1       deraadt   675:        /* If fflag is on, assume caller/authenticator has logged root login. */
1.24      art       676:        if (rootlogin && fflag == 0) {
1.1       deraadt   677:                if (hostname)
1.14      millert   678:                        syslog(LOG_NOTICE, "ROOT LOGIN (%s) ON %s FROM %s%s%s",
                    679:                            username, tty, rusername ? rusername : "",
                    680:                            rusername ? "@" : "", hostname);
1.1       deraadt   681:                else
                    682:                        syslog(LOG_NOTICE, "ROOT LOGIN (%s) ON %s", username, tty);
1.24      art       683:        }
1.1       deraadt   684:
                    685:        if (!quietlog) {
1.36      millert   686:                if ((copyright =
                    687:                    login_getcapstr(lc, "copyright", NULL, NULL)) != NULL)
                    688:                        auth_cat(copyright);
1.1       deraadt   689:                motd();
1.59      martynas  690:                if (stat(mail, &st) == 0 && st.st_size != 0)
1.1       deraadt   691:                        (void)printf("You have %smail.\n",
                    692:                            (st.st_mtime > st.st_atime) ? "new " : "");
                    693:        }
                    694:
                    695:        (void)signal(SIGALRM, SIG_DFL);
                    696:        (void)signal(SIGQUIT, SIG_DFL);
1.36      millert   697:        (void)signal(SIGHUP, SIG_DFL);
1.1       deraadt   698:        (void)signal(SIGINT, SIG_DFL);
                    699:        (void)signal(SIGTSTP, SIG_IGN);
                    700:
                    701:        tbuf[0] = '-';
1.30      millert   702:        (void)strlcpy(tbuf + 1, (p = strrchr(shell, '/')) ?
1.36      millert   703:            p + 1 : shell, sizeof(tbuf) - 1);
                    704:
                    705:        if ((scds.rlim_cur != QUAD_MIN || scds.rlim_max != QUAD_MIN) &&
1.71      deraadt   706:            setrlimit(RLIMIT_CORE, &scds) == -1)
1.36      millert   707:                syslog(LOG_ERR, "couldn't reset core dump size: %m");
                    708:
                    709:        if (lastchance)
1.47      deraadt   710:                (void)printf("WARNING: Your password has expired."
                    711:                    "  You must change your password, now!\n");
1.1       deraadt   712:
1.38      millert   713:        if (setusercontext(lc, pwd, rootlogin ? 0 : pwd->pw_uid,
1.36      millert   714:            LOGIN_SETALL & ~LOGIN_SETPATH) < 0) {
1.30      millert   715:                warn("unable to set user context");
1.36      millert   716:                quickexit(1);
                    717:        }
                    718:
                    719:        if (homeless) {
                    720:                (void)printf("No home directory %s!\n", pwd->pw_dir);
                    721:                (void)printf("Logging in with home = \"/\".\n");
                    722:                (void)setenv("HOME", "/", 1);
1.15      tholo     723:        }
1.30      millert   724:
1.36      millert   725:        if (auth_approval(as, lc, NULL, "login") == 0) {
                    726:                if (auth_getstate(as) & AUTH_EXPIRED)
                    727:                        (void)printf("Sorry -- your account has expired.\n");
                    728:                else
                    729:                        (void)printf("approval failure\n");
                    730:                quickexit(1);
                    731:        }
                    732:
                    733:        /*
                    734:         * The last thing we do is discard all of the open file descriptors.
                    735:         * Last because the C library may have some open.
                    736:         */
1.53      deraadt   737:        closefrom(STDERR_FILENO + 1);
1.36      millert   738:
                    739:        /*
                    740:         * Close the authentication session, make sure it is marked
                    741:         * as okay so no files are removed.
                    742:         */
                    743:        auth_setstate(as, AUTH_OKAY);
                    744:        auth_close(as);
                    745:
1.42      deraadt   746:        execlp(shell, tbuf, (char *)NULL);
1.30      millert   747:        err(1, "%s", shell);
1.1       deraadt   748: }
                    749:
                    750: /*
1.36      millert   751:  * Allow for a '.' and 16 characters for any instance as well as
1.60      tobias    752:  * space for a ':' and 16 characters defining the authentication type.
1.1       deraadt   753:  */
1.36      millert   754: #define NBUFSIZ                (UT_NAMESIZE + 1 + 16 + 1 + 16)
1.1       deraadt   755:
                    756: void
1.47      deraadt   757: getloginname(void)
1.1       deraadt   758: {
1.47      deraadt   759:        static char nbuf[NBUFSIZ], *p;
1.1       deraadt   760:        int ch;
                    761:
                    762:        for (;;) {
                    763:                (void)printf("login: ");
                    764:                for (p = nbuf; (ch = getchar()) != '\n'; ) {
                    765:                        if (ch == EOF) {
                    766:                                badlogin(username);
1.36      millert   767:                                quickexit(0);
1.1       deraadt   768:                        }
                    769:                        if (p < nbuf + (NBUFSIZ - 1))
                    770:                                *p++ = ch;
                    771:                }
1.24      art       772:                if (p > nbuf) {
1.1       deraadt   773:                        if (nbuf[0] == '-')
                    774:                                (void)fprintf(stderr,
                    775:                                    "login names may not start with '-'.\n");
                    776:                        else {
                    777:                                *p = '\0';
                    778:                                username = nbuf;
                    779:                                break;
                    780:                        }
1.24      art       781:                }
1.1       deraadt   782:        }
                    783: }
                    784:
                    785: int
1.47      deraadt   786: rootterm(char *ttyn)
1.1       deraadt   787: {
                    788:        struct ttyent *t;
                    789:
1.36      millert   790:        /* XXX - stash output of getttynam() elsewhere */
1.1       deraadt   791:        return ((t = getttynam(ttyn)) && t->ty_status & TTY_SECURE);
                    792: }
                    793:
                    794: void
1.47      deraadt   795: motd(void)
1.1       deraadt   796: {
1.47      deraadt   797:        char tbuf[8192], *motd;
1.1       deraadt   798:        int fd, nchars;
1.48      millert   799:        struct sigaction sa, osa;
1.30      millert   800:
                    801:        motd = login_getcapstr(lc, "welcome", _PATH_MOTDFILE, _PATH_MOTDFILE);
1.1       deraadt   802:
1.73    ! deraadt   803:        if ((fd = open(motd, O_RDONLY)) == -1)
1.1       deraadt   804:                return;
1.48      millert   805:
                    806:        memset(&sa, 0, sizeof(sa));
                    807:        sa.sa_handler = sigint;
                    808:        sigemptyset(&sa.sa_mask);
                    809:        sa.sa_flags = 0;                /* don't set SA_RESTART */
                    810:        (void)sigaction(SIGINT, &sa, &osa);
                    811:
                    812:        /* read and spew motd until EOF, error, or SIGINT */
                    813:        while ((nchars = read(fd, tbuf, sizeof(tbuf))) > 0 &&
                    814:            write(STDOUT_FILENO, tbuf, nchars) == nchars)
                    815:                ;
                    816:
                    817:        (void)sigaction(SIGINT, &osa, NULL);
1.1       deraadt   818:        (void)close(fd);
                    819: }
                    820:
                    821: /* ARGSUSED */
                    822: void
1.47      deraadt   823: sigint(int signo)
1.1       deraadt   824: {
1.52      otto      825:        return;                 /* just interrupt syscall */
1.1       deraadt   826: }
                    827:
                    828: /* ARGSUSED */
                    829: void
1.47      deraadt   830: timedout(int signo)
1.1       deraadt   831: {
1.69      deraadt   832:        dprintf(STDERR_FILENO,
1.47      deraadt   833:            "Login timed out after %d seconds\n", timeout);
1.37      millert   834:        if (username)
                    835:                badlogin(username);
1.47      deraadt   836:        _exit(0);
1.1       deraadt   837: }
                    838:
                    839: void
1.47      deraadt   840: dolastlog(int quiet)
1.1       deraadt   841: {
                    842:        struct lastlog ll;
1.67      guenther  843:        off_t pos;
1.1       deraadt   844:        int fd;
                    845:
1.73    ! deraadt   846:        if ((fd = open(_PATH_LASTLOG, O_RDWR)) >= 0) {
1.67      guenther  847:                pos = (off_t)pwd->pw_uid * sizeof(ll);
1.1       deraadt   848:                if (!quiet) {
1.67      guenther  849:                        if (pread(fd, &ll, sizeof(ll), pos) == sizeof(ll) &&
1.1       deraadt   850:                            ll.ll_time != 0) {
                    851:                                (void)printf("Last login: %.*s ",
                    852:                                    24-5, (char *)ctime(&ll.ll_time));
1.14      millert   853:                                (void)printf("on %.*s",
                    854:                                    (int)sizeof(ll.ll_line),
                    855:                                    ll.ll_line);
1.1       deraadt   856:                                if (*ll.ll_host != '\0')
1.14      millert   857:                                        (void)printf(" from %.*s",
1.1       deraadt   858:                                            (int)sizeof(ll.ll_host),
                    859:                                            ll.ll_host);
1.14      millert   860:                                (void)putchar('\n');
1.1       deraadt   861:                        }
                    862:                }
1.67      guenther  863:                memset(&ll, 0, sizeof(ll));
1.1       deraadt   864:                (void)time(&ll.ll_time);
                    865:                (void)strncpy(ll.ll_line, tty, sizeof(ll.ll_line));
                    866:                if (hostname)
                    867:                        (void)strncpy(ll.ll_host, hostname, sizeof(ll.ll_host));
1.67      guenther  868:                (void)pwrite(fd, &ll, sizeof(ll), pos);
1.1       deraadt   869:                (void)close(fd);
                    870:        }
                    871: }
                    872:
                    873: void
1.47      deraadt   874: badlogin(char *name)
1.1       deraadt   875: {
1.47      deraadt   876:        struct syslog_data sdata = SYSLOG_DATA_INIT;
                    877:
1.1       deraadt   878:        if (failures == 0)
                    879:                return;
                    880:        if (hostname) {
1.47      deraadt   881:                syslog_r(LOG_NOTICE, &sdata,
                    882:                    "%d LOGIN FAILURE%s FROM %s%s%s",
1.14      millert   883:                    failures, failures > 1 ? "S" : "",
                    884:                    rusername ? rusername : "", rusername ? "@" : "", hostname);
1.47      deraadt   885:                syslog_r(LOG_AUTHPRIV|LOG_NOTICE, &sdata,
1.14      millert   886:                    "%d LOGIN FAILURE%s FROM %s%s%s, %s",
                    887:                    failures, failures > 1 ? "S" : "",
                    888:                    rusername ? rusername : "", rusername ? "@" : "",
                    889:                    hostname, name);
1.1       deraadt   890:        } else {
1.47      deraadt   891:                syslog_r(LOG_NOTICE, &sdata,
                    892:                    "%d LOGIN FAILURE%s ON %s",
1.1       deraadt   893:                    failures, failures > 1 ? "S" : "", tty);
1.47      deraadt   894:                syslog_r(LOG_AUTHPRIV|LOG_NOTICE, &sdata,
1.1       deraadt   895:                    "%d LOGIN FAILURE%s ON %s, %s",
                    896:                    failures, failures > 1 ? "S" : "", tty, name);
                    897:        }
                    898: }
                    899:
                    900: #undef UNKNOWN
                    901: #define        UNKNOWN "su"
                    902:
                    903: char *
1.47      deraadt   904: stypeof(char *ttyid)
1.1       deraadt   905: {
                    906:        struct ttyent *t;
                    907:
1.30      millert   908:        return (ttyid && (t = getttynam(ttyid)) ? t->ty_type :
                    909:            login_getcapstr(lc, "term", UNKNOWN, UNKNOWN));
1.1       deraadt   910: }
                    911:
                    912: void
1.47      deraadt   913: sleepexit(int eval)
1.1       deraadt   914: {
1.36      millert   915:        auth_close(as);
1.1       deraadt   916:        (void)sleep(5);
                    917:        exit(eval);
1.11      millert   918: }
                    919:
                    920: void
1.47      deraadt   921: quickexit(int eval)
1.36      millert   922: {
                    923:        if (as)
                    924:                auth_close(as);
                    925:        exit(eval);
                    926: }
                    927:
                    928:
                    929: void
1.47      deraadt   930: sighup(int signum)
1.11      millert   931: {
                    932:        if (username)
                    933:                badlogin(username);
1.47      deraadt   934:        _exit(0);
1.1       deraadt   935: }