crypto/openssh/auth2.c

   1 /* $OpenBSD: auth2.c,v 1.126 2012/12/02 20:34:09 djm Exp $ */
   2 /*
   3  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "includes.h"
  27 __RCSID("$FreeBSD$");
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <sys/uio.h>
  32
  33 #include <fcntl.h>
  34 #include <pwd.h>
  35 #include <stdarg.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39 #include "atomicio.h"
  40 #include "xmalloc.h"
  41 #include "ssh2.h"
  42 #include "packet.h"
  43 #include "log.h"
  44 #include "buffer.h"
  45 #include "servconf.h"
  46 #include "compat.h"
  47 #include "key.h"
  48 #include "hostfile.h"
  49 #include "auth.h"
  50 #include "dispatch.h"
  51 #include "pathnames.h"
  52 #include "buffer.h"
  53 #include "canohost.h"
  54
  55 #ifdef GSSAPI
  56 #include "ssh-gss.h"
  57 #endif
  58 #include "monitor_wrap.h"
  59
  60 /* import */
  61 extern ServerOptions options;
  62 extern u_char *session_id2;
  63 extern u_int session_id2_len;
  64 extern Buffer loginmsg;
  65
  66 /* methods */
  67
  68 extern Authmethod method_none;
  69 extern Authmethod method_pubkey;
  70 extern Authmethod method_passwd;
  71 extern Authmethod method_kbdint;
  72 extern Authmethod method_hostbased;
  73 #ifdef GSSAPI
  74 extern Authmethod method_gssapi;
  75 #endif
  76 #ifdef JPAKE
  77 extern Authmethod method_jpake;
  78 #endif
  79
  80 Authmethod *authmethods[] = {
  81         &method_none,
  82         &method_pubkey,
  83 #ifdef GSSAPI
  84         &method_gssapi,
  85 #endif
  86 #ifdef JPAKE
  87         &method_jpake,
  88 #endif
  89         &method_passwd,
  90         &method_kbdint,
  91         &method_hostbased,
  92         NULL
  93 };
  94
  95 /* protocol */
  96
  97 static void input_service_request(int, u_int32_t, void *);
  98 static void input_userauth_request(int, u_int32_t, void *);
  99
 100 /* helper */
 101 static Authmethod *authmethod_lookup(Authctxt *, const char *);
 102 static char *authmethods_get(Authctxt *authctxt);
 103 static int method_allowed(Authctxt *, const char *);
 104 static int list_starts_with(const char *, const char *);
 105
 106 char *
 107 auth2_read_banner(void)
 108 {
 109         struct stat st;
 110         char *banner = NULL;
 111         size_t len, n;
 112         int fd;
 113
 114         if ((fd = open(options.banner, O_RDONLY)) == -1)
 115                 return (NULL);
 116         if (fstat(fd, &st) == -1) {
 117                 close(fd);
 118                 return (NULL);
 119         }
 120         if (st.st_size <= 0 || st.st_size > 1*1024*1024) {
 121                 close(fd);
 122                 return (NULL);
 123         }
 124
 125         len = (size_t)st.st_size;               /* truncate */
 126         banner = xmalloc(len + 1);
 127         n = atomicio(read, fd, banner, len);
 128         close(fd);
 129
 130         if (n != len) {
 131                 xfree(banner);
 132                 return (NULL);
 133         }
 134         banner[n] = '\0';
 135
 136         return (banner);
 137 }
 138
 139 void
 140 userauth_send_banner(const char *msg)
 141 {
 142         if (datafellows & SSH_BUG_BANNER)
 143                 return;
 144
 145         packet_start(SSH2_MSG_USERAUTH_BANNER);
 146         packet_put_cstring(msg);
 147         packet_put_cstring("");         /* language, unused */
 148         packet_send();
 149         debug("%s: sent", __func__);
 150 }
 151
 152 static void
 153 userauth_banner(void)
 154 {
 155         char *banner = NULL;
 156
 157         if (options.banner == NULL ||
 158             strcasecmp(options.banner, "none") == 0 ||
 159             (datafellows & SSH_BUG_BANNER) != 0)
 160                 return;
 161
 162         if ((banner = PRIVSEP(auth2_read_banner())) == NULL)
 163                 goto done;
 164         userauth_send_banner(banner);
 165
 166 done:
 167         if (banner)
 168                 xfree(banner);
 169 }
 170
 171 /*
 172  * loop until authctxt->success == TRUE
 173  */
 174 void
 175 do_authentication2(Authctxt *authctxt)
 176 {
 177         dispatch_init(&dispatch_protocol_error);
 178         dispatch_set(SSH2_MSG_SERVICE_REQUEST, &input_service_request);
 179         dispatch_run(DISPATCH_BLOCK, &authctxt->success, authctxt);
 180 }
 181
 182 /*ARGSUSED*/
 183 static void
 184 input_service_request(int type, u_int32_t seq, void *ctxt)
 185 {
 186         Authctxt *authctxt = ctxt;
 187         u_int len;
 188         int acceptit = 0;
 189         char *service = packet_get_cstring(&len);
 190         packet_check_eom();
 191
 192         if (authctxt == NULL)
 193                 fatal("input_service_request: no authctxt");
 194
 195         if (strcmp(service, "ssh-userauth") == 0) {
 196                 if (!authctxt->success) {
 197                         acceptit = 1;
 198                         /* now we can handle user-auth requests */
 199                         dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &input_userauth_request);
 200                 }
 201         }
 202         /* XXX all other service requests are denied */
 203
 204         if (acceptit) {
 205                 packet_start(SSH2_MSG_SERVICE_ACCEPT);
 206                 packet_put_cstring(service);
 207                 packet_send();
 208                 packet_write_wait();
 209         } else {
 210                 debug("bad service request %s", service);
 211                 packet_disconnect("bad service request %s", service);
 212         }
 213         xfree(service);
 214 }
 215
 216 /*ARGSUSED*/
 217 static void
 218 input_userauth_request(int type, u_int32_t seq, void *ctxt)
 219 {
 220         Authctxt *authctxt = ctxt;
 221         Authmethod *m = NULL;
 222         char *user, *service, *method, *style = NULL;
 223         int authenticated = 0;
 224 #ifdef HAVE_LOGIN_CAP
 225         login_cap_t *lc;
 226         const char *from_host, *from_ip;
 227
 228         from_host = get_canonical_hostname(options.use_dns);
 229         from_ip = get_remote_ipaddr();
 230 #endif
 231
 232         if (authctxt == NULL)
 233                 fatal("input_userauth_request: no authctxt");
 234
 235         user = packet_get_cstring(NULL);
 236         service = packet_get_cstring(NULL);
 237         method = packet_get_cstring(NULL);
 238         debug("userauth-request for user %s service %s method %s", user, service, method);
 239         debug("attempt %d failures %d", authctxt->attempt, authctxt->failures);
 240
 241         if ((style = strchr(user, ':')) != NULL)
 242                 *style++ = 0;
 243
 244         if (authctxt->attempt++ == 0) {
 245                 /* setup auth context */
 246                 authctxt->pw = PRIVSEP(getpwnamallow(user));
 247                 authctxt->user = xstrdup(user);
 248                 if (authctxt->pw && strcmp(service, "ssh-connection")==0) {
 249                         authctxt->valid = 1;
 250                         debug2("input_userauth_request: setting up authctxt for %s", user);
 251                 } else {
 252                         logit("input_userauth_request: invalid user %s", user);
 253                         authctxt->pw = fakepw();
 254 #ifdef SSH_AUDIT_EVENTS
 255                         PRIVSEP(audit_event(SSH_INVALID_USER));
 256 #endif
 257                 }
 258 #ifdef USE_PAM
 259                 if (options.use_pam)
 260                         PRIVSEP(start_pam(authctxt));
 261 #endif
 262                 setproctitle("%s%s", authctxt->valid ? user : "unknown",
 263                     use_privsep ? " [net]" : "");
 264                 authctxt->service = xstrdup(service);
 265                 authctxt->style = style ? xstrdup(style) : NULL;
 266                 if (use_privsep)
 267                         mm_inform_authserv(service, style);
 268                 userauth_banner();
 269                 if (auth2_setup_methods_lists(authctxt) != 0)
 270                         packet_disconnect("no authentication methods enabled");
 271         } else if (strcmp(user, authctxt->user) != 0 ||
 272             strcmp(service, authctxt->service) != 0) {
 273                 packet_disconnect("Change of username or service not allowed: "
 274                     "(%s,%s) -> (%s,%s)",
 275                     authctxt->user, authctxt->service, user, service);
 276         }
 277
 278 #ifdef HAVE_LOGIN_CAP
 279         if (authctxt->pw != NULL) {
 280                 lc = login_getpwclass(authctxt->pw);
 281                 if (lc == NULL)
 282                         lc = login_getclassbyname(NULL, authctxt->pw);
 283                 if (!auth_hostok(lc, from_host, from_ip)) {
 284                         logit("Denied connection for %.200s from %.200s [%.200s].",
 285                             authctxt->pw->pw_name, from_host, from_ip);
 286                         packet_disconnect("Sorry, you are not allowed to connect.");
 287                 }
 288                 if (!auth_timeok(lc, time(NULL))) {
 289                         logit("LOGIN %.200s REFUSED (TIME) FROM %.200s",
 290                             authctxt->pw->pw_name, from_host);
 291                         packet_disconnect("Logins not available right now.");
 292                 }
 293                 login_close(lc);
 294                 lc = NULL;
 295         }
 296 #endif  /* HAVE_LOGIN_CAP */
 297
 298         /* reset state */
 299         auth2_challenge_stop(authctxt);
 300 #ifdef JPAKE
 301         auth2_jpake_stop(authctxt);
 302 #endif
 303
 304 #ifdef GSSAPI
 305         /* XXX move to auth2_gssapi_stop() */
 306         dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);
 307         dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);
 308 #endif
 309
 310         authctxt->postponed = 0;
 311         authctxt->server_caused_failure = 0;
 312
 313         /* try to authenticate user */
 314         m = authmethod_lookup(authctxt, method);
 315         if (m != NULL && authctxt->failures < options.max_authtries) {
 316                 debug2("input_userauth_request: try method %s", method);
 317                 authenticated = m->userauth(authctxt);
 318         }
 319         userauth_finish(authctxt, authenticated, method, NULL);
 320
 321         xfree(service);
 322         xfree(user);
 323         xfree(method);
 324 }
 325
 326 void
 327 userauth_finish(Authctxt *authctxt, int authenticated, const char *method,
 328     const char *submethod)
 329 {
 330         char *methods;
 331         int partial = 0;
 332
 333         if (!authctxt->valid && authenticated)
 334                 fatal("INTERNAL ERROR: authenticated invalid user %s",
 335                     authctxt->user);
 336         if (authenticated && authctxt->postponed)
 337                 fatal("INTERNAL ERROR: authenticated and postponed");
 338
 339         /* Special handling for root */
 340         if (authenticated && authctxt->pw->pw_uid == 0 &&
 341             !auth_root_allowed(method)) {
 342                 authenticated = 0;
 343 #ifdef SSH_AUDIT_EVENTS
 344                 PRIVSEP(audit_event(SSH_LOGIN_ROOT_DENIED));
 345 #endif
 346         }
 347
 348         if (authenticated && options.num_auth_methods != 0) {
 349                 if (!auth2_update_methods_lists(authctxt, method)) {
 350                         authenticated = 0;
 351                         partial = 1;
 352                 }
 353         }
 354
 355         /* Log before sending the reply */
 356         auth_log(authctxt, authenticated, partial, method, submethod, " ssh2");
 357
 358         if (authctxt->postponed)
 359                 return;
 360
 361 #ifdef USE_PAM
 362         if (options.use_pam && authenticated) {
 363                 if (!PRIVSEP(do_pam_account())) {
 364                         /* if PAM returned a message, send it to the user */
 365                         if (buffer_len(&loginmsg) > 0) {
 366                                 buffer_append(&loginmsg, "\0", 1);
 367                                 userauth_send_banner(buffer_ptr(&loginmsg));
 368                                 packet_write_wait();
 369                         }
 370                         fatal("Access denied for user %s by PAM account "
 371                             "configuration", authctxt->user);
 372                 }
 373         }
 374 #endif
 375
 376 #ifdef _UNICOS
 377         if (authenticated && cray_access_denied(authctxt->user)) {
 378                 authenticated = 0;
 379                 fatal("Access denied for user %s.", authctxt->user);
 380         }
 381 #endif /* _UNICOS */
 382
 383         if (authenticated == 1) {
 384                 /* turn off userauth */
 385                 dispatch_set(SSH2_MSG_USERAUTH_REQUEST, &dispatch_protocol_ignore);
 386                 packet_start(SSH2_MSG_USERAUTH_SUCCESS);
 387                 packet_send();
 388                 packet_write_wait();
 389                 /* now we can break out */
 390                 authctxt->success = 1;
 391         } else {
 392
 393                 /* Allow initial try of "none" auth without failure penalty */
 394                 if (!authctxt->server_caused_failure &&
 395                     (authctxt->attempt > 1 || strcmp(method, "none") != 0))
 396                         authctxt->failures++;
 397                 if (authctxt->failures >= options.max_authtries) {
 398 #ifdef SSH_AUDIT_EVENTS
 399                         PRIVSEP(audit_event(SSH_LOGIN_EXCEED_MAXTRIES));
 400 #endif
 401                         packet_disconnect(AUTH_FAIL_MSG, authctxt->user);
 402                 }
 403                 methods = authmethods_get(authctxt);
 404                 debug3("%s: failure partial=%d next methods=\"%s\"", __func__,
 405                     partial, methods);
 406                 packet_start(SSH2_MSG_USERAUTH_FAILURE);
 407                 packet_put_cstring(methods);
 408                 packet_put_char(partial);
 409                 packet_send();
 410                 packet_write_wait();
 411                 xfree(methods);
 412         }
 413 }
 414
 415 /*
 416  * Checks whether method is allowed by at least one AuthenticationMethods
 417  * methods list. Returns 1 if allowed, or no methods lists configured.
 418  * 0 otherwise.
 419  */
 420 static int
 421 method_allowed(Authctxt *authctxt, const char *method)
 422 {
 423         u_int i;
 424
 425         /*
 426          * NB. authctxt->num_auth_methods might be zero as a result of
 427          * auth2_setup_methods_lists(), so check the configuration.
 428          */
 429         if (options.num_auth_methods == 0)
 430                 return 1;
 431         for (i = 0; i < authctxt->num_auth_methods; i++) {
 432                 if (list_starts_with(authctxt->auth_methods[i], method))
 433                         return 1;
 434         }
 435         return 0;
 436 }
 437
 438 static char *
 439 authmethods_get(Authctxt *authctxt)
 440 {
 441         Buffer b;
 442         char *list;
 443         u_int i;
 444
 445         buffer_init(&b);
 446         for (i = 0; authmethods[i] != NULL; i++) {
 447                 if (strcmp(authmethods[i]->name, "none") == 0)
 448                         continue;
 449                 if (authmethods[i]->enabled == NULL ||
 450                     *(authmethods[i]->enabled) == 0)
 451                         continue;
 452                 if (!method_allowed(authctxt, authmethods[i]->name))
 453                         continue;
 454                 if (buffer_len(&b) > 0)
 455                         buffer_append(&b, ",", 1);
 456                 buffer_append(&b, authmethods[i]->name,
 457                     strlen(authmethods[i]->name));
 458         }
 459         buffer_append(&b, "\0", 1);
 460         list = xstrdup(buffer_ptr(&b));
 461         buffer_free(&b);
 462         return list;
 463 }
 464
 465 static Authmethod *
 466 authmethod_lookup(Authctxt *authctxt, const char *name)
 467 {
 468         int i;
 469
 470         if (name != NULL)
 471                 for (i = 0; authmethods[i] != NULL; i++)
 472                         if (authmethods[i]->enabled != NULL &&
 473                             *(authmethods[i]->enabled) != 0 &&
 474                             strcmp(name, authmethods[i]->name) == 0 &&
 475                             method_allowed(authctxt, authmethods[i]->name))
 476                                 return authmethods[i];
 477         debug2("Unrecognized authentication method name: %s",
 478             name ? name : "NULL");
 479         return NULL;
 480 }
 481
 482 /*
 483  * Check a comma-separated list of methods for validity. Is need_enable is
 484  * non-zero, then also require that the methods are enabled.
 485  * Returns 0 on success or -1 if the methods list is invalid.
 486  */
 487 int
 488 auth2_methods_valid(const char *_methods, int need_enable)
 489 {
 490         char *methods, *omethods, *method;
 491         u_int i, found;
 492         int ret = -1;
 493
 494         if (*_methods == '\0') {
 495                 error("empty authentication method list");
 496                 return -1;
 497         }
 498         omethods = methods = xstrdup(_methods);
 499         while ((method = strsep(&methods, ",")) != NULL) {
 500                 for (found = i = 0; !found && authmethods[i] != NULL; i++) {
 501                         if (strcmp(method, authmethods[i]->name) != 0)
 502                                 continue;
 503                         if (need_enable) {
 504                                 if (authmethods[i]->enabled == NULL ||
 505                                     *(authmethods[i]->enabled) == 0) {
 506                                         error("Disabled method \"%s\" in "
 507                                             "AuthenticationMethods list \"%s\"",
 508                                             method, _methods);
 509                                         goto out;
 510                                 }
 511                         }
 512                         found = 1;
 513                         break;
 514                 }
 515                 if (!found) {
 516                         error("Unknown authentication method \"%s\" in list",
 517                             method);
 518                         goto out;
 519                 }
 520         }
 521         ret = 0;
 522  out:
 523         free(omethods);
 524         return ret;
 525 }
 526
 527 /*
 528  * Prune the AuthenticationMethods supplied in the configuration, removing
 529  * any methods lists that include disabled methods. Note that this might
 530  * leave authctxt->num_auth_methods == 0, even when multiple required auth
 531  * has been requested. For this reason, all tests for whether multiple is
 532  * enabled should consult options.num_auth_methods directly.
 533  */
 534 int
 535 auth2_setup_methods_lists(Authctxt *authctxt)
 536 {
 537         u_int i;
 538
 539         if (options.num_auth_methods == 0)
 540                 return 0;
 541         debug3("%s: checking methods", __func__);
 542         authctxt->auth_methods = xcalloc(options.num_auth_methods,
 543             sizeof(*authctxt->auth_methods));
 544         authctxt->num_auth_methods = 0;
 545         for (i = 0; i < options.num_auth_methods; i++) {
 546                 if (auth2_methods_valid(options.auth_methods[i], 1) != 0) {
 547                         logit("Authentication methods list \"%s\" contains "
 548                             "disabled method, skipping",
 549                             options.auth_methods[i]);
 550                         continue;
 551                 }
 552                 debug("authentication methods list %d: %s",
 553                     authctxt->num_auth_methods, options.auth_methods[i]);
 554                 authctxt->auth_methods[authctxt->num_auth_methods++] =
 555                     xstrdup(options.auth_methods[i]);
 556         }
 557         if (authctxt->num_auth_methods == 0) {
 558                 error("No AuthenticationMethods left after eliminating "
 559                     "disabled methods");
 560                 return -1;
 561         }
 562         return 0;
 563 }
 564
 565 static int
 566 list_starts_with(const char *methods, const char *method)
 567 {
 568         size_t l = strlen(method);
 569
 570         if (strncmp(methods, method, l) != 0)
 571                 return 0;
 572         if (methods[l] != ',' && methods[l] != '\0')
 573                 return 0;
 574         return 1;
 575 }
 576
 577 /*
 578  * Remove method from the start of a comma-separated list of methods.
 579  * Returns 0 if the list of methods did not start with that method or 1
 580  * if it did.
 581  */
 582 static int
 583 remove_method(char **methods, const char *method)
 584 {
 585         char *omethods = *methods;
 586         size_t l = strlen(method);
 587
 588         if (!list_starts_with(omethods, method))
 589                 return 0;
 590         *methods = xstrdup(omethods + l + (omethods[l] == ',' ? 1 : 0));
 591         free(omethods);
 592         return 1;
 593 }
 594
 595 /*
 596  * Called after successful authentication. Will remove the successful method
 597  * from the start of each list in which it occurs. If it was the last method
 598  * in any list, then authentication is deemed successful.
 599  * Returns 1 if the method completed any authentication list or 0 otherwise.
 600  */
 601 int
 602 auth2_update_methods_lists(Authctxt *authctxt, const char *method)
 603 {
 604         u_int i, found = 0;
 605
 606         debug3("%s: updating methods list after \"%s\"", __func__, method);
 607         for (i = 0; i < authctxt->num_auth_methods; i++) {
 608                 if (!remove_method(&(authctxt->auth_methods[i]), method))
 609                         continue;
 610                 found = 1;
 611                 if (*authctxt->auth_methods[i] == '\0') {
 612                         debug2("authentication methods list %d complete", i);
 613                         return 1;
 614                 }
 615                 debug3("authentication methods list %d remaining: \"%s\"",
 616                     i, authctxt->auth_methods[i]);
 617         }
 618         /* This should not happen, but would be bad if it did */
 619         if (!found)
 620                 fatal("%s: method not in AuthenticationMethods", __func__);
 621         return 0;
 622 }
 623
 624