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

Diff for /src/usr.bin/ssh/Attic/auth1.c between version 1.2 and 1.2.2.2

version 1.2, 2000/04/29 18:11:52 version 1.2.2.2, 2000/11/08 21:30:23
Line 1 
Line 1 
 /*  /*
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland   * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
  *                    All rights reserved   *                    All rights reserved
    *
    * As far as I am concerned, the code I have written for this software
    * can be used freely for any purpose.  Any derived versions of this
    * software must be clearly marked as such, and if the derived work is
    * incompatible with the protocol description in the RFC file, it must be
    * called by a name other than "ssh" or "Secure Shell".
  */   */
   
 #include "includes.h"  #include "includes.h"
Line 11 
Line 17 
 #include "ssh.h"  #include "ssh.h"
 #include "packet.h"  #include "packet.h"
 #include "buffer.h"  #include "buffer.h"
 #include "cipher.h"  
 #include "mpaux.h"  #include "mpaux.h"
 #include "servconf.h"  #include "servconf.h"
 #include "compat.h"  #include "compat.h"
Line 52 
Line 57 
 }  }
   
 /*  /*
  * The user does not exist or access is denied,   * read packets and try to authenticate local user 'luser'.
  * but fake indication that authentication is needed.   * return if authentication is successfull. not that pw == NULL
    * if the user does not exists or is not allowed to login.
    * each auth method has to 'fake' authentication for nonexisting
    * users.
  */   */
 void  void
 do_fake_authloop1(char *user)  do_authloop(struct passwd * pw, char *luser)
 {  {
           int authenticated = 0;
         int attempt = 0;          int attempt = 0;
   
         log("Faking authloop for illegal user %.200s from %.200s port %d",  
             user,  
             get_remote_ipaddr(),  
             get_remote_port());  
   
         /* Indicate that authentication is needed. */  
         packet_start(SSH_SMSG_FAILURE);  
         packet_send();  
         packet_write_wait();  
   
         /*  
          * Keep reading packets, and always respond with a failure.  This is  
          * to avoid disclosing whether such a user really exists.  
          */  
         for (attempt = 1;; attempt++) {  
                 /* Read a packet.  This will not return if the client disconnects. */  
                 int plen;  
                 int type = packet_read(&plen);  
 #ifdef SKEY  
                 unsigned int dlen;  
                 char *password, *skeyinfo;  
                 password = NULL;  
                 /* Try to send a fake s/key challenge. */  
                 if (options.skey_authentication == 1 &&  
                     (skeyinfo = skey_fake_keyinfo(user)) != NULL) {  
                         if (type == SSH_CMSG_AUTH_TIS) {  
                                 packet_start(SSH_SMSG_AUTH_TIS_CHALLENGE);  
                                 packet_put_string(skeyinfo, strlen(skeyinfo));  
                                 packet_send();  
                                 packet_write_wait();  
                                 continue;  
                         } else if (type == SSH_CMSG_AUTH_PASSWORD &&  
                                    options.password_authentication &&  
                                    (password = packet_get_string(&dlen)) != NULL &&  
                                    dlen == 5 &&  
                                    strncasecmp(password, "s/key", 5) == 0 ) {  
                                 packet_send_debug(skeyinfo);  
                         }  
                 }  
                 if (password != NULL)  
                         xfree(password);  
 #endif  
                 if (attempt > AUTH_FAIL_MAX)  
                         packet_disconnect(AUTH_FAIL_MSG, user);  
   
                 /*  
                  * Send failure.  This should be indistinguishable from a  
                  * failed authentication.  
                  */  
                 packet_start(SSH_SMSG_FAILURE);  
                 packet_send();  
                 packet_write_wait();  
         }  
         /* NOTREACHED */  
         abort();  
 }  
   
 /*  
  * read packets and try to authenticate local user *pw.  
  * return if authentication is successfull  
  */  
 void  
 do_authloop(struct passwd * pw)  
 {  
         int attempt = 0;  
         unsigned int bits;          unsigned int bits;
         RSA *client_host_key;          RSA *client_host_key;
         BIGNUM *n;          BIGNUM *n;
Line 142 
Line 85 
         packet_write_wait();          packet_write_wait();
   
         for (attempt = 1;; attempt++) {          for (attempt = 1;; attempt++) {
                 int authenticated = 0;                  /* default to fail */
                   authenticated = 0;
   
                 strlcpy(user, "", sizeof user);                  strlcpy(user, "", sizeof user);
   
                 /* Get a packet from the client. */                  /* Get a packet from the client. */
Line 153 
Line 98 
 #ifdef AFS  #ifdef AFS
                 case SSH_CMSG_HAVE_KERBEROS_TGT:                  case SSH_CMSG_HAVE_KERBEROS_TGT:
                         if (!options.kerberos_tgt_passing) {                          if (!options.kerberos_tgt_passing) {
                                 /* packet_get_all(); */  
                                 verbose("Kerberos tgt passing disabled.");                                  verbose("Kerberos tgt passing disabled.");
                                 break;                                  break;
                         } else {                          } else {
Line 161 
Line 105 
                                 char *tgt = packet_get_string(&dlen);                                  char *tgt = packet_get_string(&dlen);
                                 packet_integrity_check(plen, 4 + dlen, type);                                  packet_integrity_check(plen, 4 + dlen, type);
                                 if (!auth_kerberos_tgt(pw, tgt))                                  if (!auth_kerberos_tgt(pw, tgt))
                                         verbose("Kerberos tgt REFUSED for %s", pw->pw_name);                                          verbose("Kerberos tgt REFUSED for %.100s", luser);
                                 xfree(tgt);                                  xfree(tgt);
                         }                          }
                         continue;                          continue;
   
                 case SSH_CMSG_HAVE_AFS_TOKEN:                  case SSH_CMSG_HAVE_AFS_TOKEN:
                         if (!options.afs_token_passing || !k_hasafs()) {                          if (!options.afs_token_passing || !k_hasafs()) {
                                 /* packet_get_all(); */  
                                 verbose("AFS token passing disabled.");                                  verbose("AFS token passing disabled.");
                                 break;                                  break;
                         } else {                          } else {
Line 176 
Line 119 
                                 char *token_string = packet_get_string(&dlen);                                  char *token_string = packet_get_string(&dlen);
                                 packet_integrity_check(plen, 4 + dlen, type);                                  packet_integrity_check(plen, 4 + dlen, type);
                                 if (!auth_afs_token(pw, token_string))                                  if (!auth_afs_token(pw, token_string))
                                         verbose("AFS token REFUSED for %s", pw->pw_name);                                          verbose("AFS token REFUSED for %.100s", luser);
                                 xfree(token_string);                                  xfree(token_string);
                         }                          }
                         continue;                          continue;
Line 198 
Line 141 
                                         memcpy(auth.dat, kdata, auth.length);                                          memcpy(auth.dat, kdata, auth.length);
                                 xfree(kdata);                                  xfree(kdata);
   
                                 authenticated = auth_krb4(pw->pw_name, &auth, &tkt_user);                                  if (pw != NULL) {
                                           authenticated = auth_krb4(pw->pw_name, &auth, &tkt_user);
                                 if (authenticated) {                                          if (authenticated) {
                                         snprintf(user, sizeof user, " tktuser %s", tkt_user);                                                  snprintf(user, sizeof user, " tktuser %s", tkt_user);
                                         xfree(tkt_user);                                                  xfree(tkt_user);
                                           }
                                 }                                  }
                         }                          }
                         break;                          break;
Line 222 
Line 166 
                         client_user = packet_get_string(&ulen);                          client_user = packet_get_string(&ulen);
                         packet_integrity_check(plen, 4 + ulen, type);                          packet_integrity_check(plen, 4 + ulen, type);
   
                         /* Try to authenticate using /etc/hosts.equiv and                          /* Try to authenticate using /etc/hosts.equiv and .rhosts. */
                            .rhosts. */  
                         authenticated = auth_rhosts(pw, client_user);                          authenticated = auth_rhosts(pw, client_user);
   
                         snprintf(user, sizeof user, " ruser %s", client_user);                          snprintf(user, sizeof user, " ruser %s", client_user);
Line 255 
Line 198 
                         packet_get_bignum(client_host_key->n, &nlen);                          packet_get_bignum(client_host_key->n, &nlen);
   
                         if (bits != BN_num_bits(client_host_key->n))                          if (bits != BN_num_bits(client_host_key->n))
                                 log("Warning: keysize mismatch for client_host_key: "                                  verbose("Warning: keysize mismatch for client_host_key: "
                                     "actual %d, announced %d", BN_num_bits(client_host_key->n), bits);                                      "actual %d, announced %d", BN_num_bits(client_host_key->n), bits);
                         packet_integrity_check(plen, (4 + ulen) + 4 + elen + nlen, type);                          packet_integrity_check(plen, (4 + ulen) + 4 + elen + nlen, type);
   
Line 303 
Line 246 
                 case SSH_CMSG_AUTH_TIS:                  case SSH_CMSG_AUTH_TIS:
                         debug("rcvd SSH_CMSG_AUTH_TIS");                          debug("rcvd SSH_CMSG_AUTH_TIS");
                         if (options.skey_authentication == 1) {                          if (options.skey_authentication == 1) {
                                 char *skeyinfo = skey_keyinfo(pw->pw_name);                                  char *skeyinfo = NULL;
                                   if (pw != NULL)
                                           skey_keyinfo(pw->pw_name);
                                 if (skeyinfo == NULL) {                                  if (skeyinfo == NULL) {
                                         debug("generating fake skeyinfo for %.100s.", pw->pw_name);                                          debug("generating fake skeyinfo for %.100s.", luser);
                                         skeyinfo = skey_fake_keyinfo(pw->pw_name);                                          skeyinfo = skey_fake_keyinfo(luser);
                                 }                                  }
                                 if (skeyinfo != NULL) {                                  if (skeyinfo != NULL) {
                                         /* we send our s/key- in tis-challenge messages */                                          /* we send our s/key- in tis-challenge messages */
                                         debug("sending challenge '%s'", skeyinfo);                                          debug("sending challenge '%s'", skeyinfo);
                                         packet_start(SSH_SMSG_AUTH_TIS_CHALLENGE);                                          packet_start(SSH_SMSG_AUTH_TIS_CHALLENGE);
                                         packet_put_string(skeyinfo, strlen(skeyinfo));                                          packet_put_cstring(skeyinfo);
                                         packet_send();                                          packet_send();
                                         packet_write_wait();                                          packet_write_wait();
                                         continue;                                          continue;
Line 325 
Line 270 
                                 char *response = packet_get_string(&dlen);                                  char *response = packet_get_string(&dlen);
                                 debug("skey response == '%s'", response);                                  debug("skey response == '%s'", response);
                                 packet_integrity_check(plen, 4 + dlen, type);                                  packet_integrity_check(plen, 4 + dlen, type);
                                 authenticated = (skey_haskey(pw->pw_name) == 0 &&                                  authenticated = (pw != NULL &&
                                                  skey_passcheck(pw->pw_name, response) != -1);                                      skey_haskey(pw->pw_name) == 0 &&
                                       skey_passcheck(pw->pw_name, response) != -1);
                                 xfree(response);                                  xfree(response);
                         }                          }
                         break;                          break;
Line 345 
Line 291 
                         log("Unknown message during authentication: type %d", type);                          log("Unknown message during authentication: type %d", type);
                         break;                          break;
                 }                  }
                   if (authenticated && pw == NULL)
                           fatal("internal error: authenticated for pw == NULL");
   
                 /*                  /*
                  * Check if the user is logging in as root and root logins                   * Check if the user is logging in as root and root logins
                  * are disallowed.                   * are disallowed.
                  * Note that root login is allowed for forced commands.                   * Note that root login is allowed for forced commands.
                  */                   */
                 if (authenticated && pw->pw_uid == 0 && !options.permit_root_login) {                  if (authenticated && pw && pw->pw_uid == 0 && !options.permit_root_login) {
                         if (forced_command) {                          if (forced_command) {
                                 log("Root login accepted for forced command.");                                  log("Root login accepted for forced command.");
                         } else {                          } else {
Line 367 
Line 315 
                     type == SSH_CMSG_AUTH_PASSWORD)                      type == SSH_CMSG_AUTH_PASSWORD)
                         authlog = log;                          authlog = log;
   
                 authlog("%s %s for %.200s from %.200s port %d%s",                  authlog("%s %s for %s%.100s from %.200s port %d%s",
                         authenticated ? "Accepted" : "Failed",                          authenticated ? "Accepted" : "Failed",
                         get_authname(type),                          get_authname(type),
                         pw->pw_uid == 0 ? "ROOT" : pw->pw_name,                          pw ? "" : "illegal user ",
                           pw && pw->pw_uid == 0 ? "ROOT" : luser,
                         get_remote_ipaddr(),                          get_remote_ipaddr(),
                         get_remote_port(),                          get_remote_port(),
                         user);                          user);
Line 379 
Line 328 
                         return;                          return;
   
                 if (attempt > AUTH_FAIL_MAX)                  if (attempt > AUTH_FAIL_MAX)
                         packet_disconnect(AUTH_FAIL_MSG, pw->pw_name);                          packet_disconnect(AUTH_FAIL_MSG, luser);
   
                 /* Send a message indicating that the authentication attempt failed. */                  /* Send a message indicating that the authentication attempt failed. */
                 packet_start(SSH_SMSG_FAILURE);                  packet_start(SSH_SMSG_FAILURE);
Line 419 
Line 368 
   
         /* Verify that the user is a valid user. */          /* Verify that the user is a valid user. */
         pw = getpwnam(user);          pw = getpwnam(user);
         if (!pw || !allowed_user(pw))          if (pw && allowed_user(pw)) {
                 do_fake_authloop1(user);                  /* Take a copy of the returned structure. */
         xfree(user);                  memset(&pwcopy, 0, sizeof(pwcopy));
                   pwcopy.pw_name = xstrdup(pw->pw_name);
                   pwcopy.pw_passwd = xstrdup(pw->pw_passwd);
                   pwcopy.pw_uid = pw->pw_uid;
                   pwcopy.pw_gid = pw->pw_gid;
                   pwcopy.pw_class = xstrdup(pw->pw_class);
                   pwcopy.pw_dir = xstrdup(pw->pw_dir);
                   pwcopy.pw_shell = xstrdup(pw->pw_shell);
                   pw = &pwcopy;
           } else {
                   pw = NULL;
           }
   
         /* Take a copy of the returned structure. */  
         memset(&pwcopy, 0, sizeof(pwcopy));  
         pwcopy.pw_name = xstrdup(pw->pw_name);  
         pwcopy.pw_passwd = xstrdup(pw->pw_passwd);  
         pwcopy.pw_uid = pw->pw_uid;  
         pwcopy.pw_gid = pw->pw_gid;  
         pwcopy.pw_dir = xstrdup(pw->pw_dir);  
         pwcopy.pw_shell = xstrdup(pw->pw_shell);  
         pw = &pwcopy;  
   
         /*          /*
          * If we are not running as root, the user must have the same uid as           * If we are not running as root, the user must have the same uid as
          * the server.           * the server.
          */           */
         if (getuid() != 0 && pw->pw_uid != getuid())          if (getuid() != 0 && pw && pw->pw_uid != getuid())
                 packet_disconnect("Cannot change user when server not running as root.");                  packet_disconnect("Cannot change user when server not running as root.");
   
         debug("Attempting authentication for %.100s.", pw->pw_name);          debug("Attempting authentication for %s%.100s.", pw ? "" : "illegal user ", user);
   
         /* If the user has no password, accept authentication immediately. */          /* If the user has no password, accept authentication immediately. */
         if (options.password_authentication &&          if (options.password_authentication &&
Line 450 
Line 400 
             auth_password(pw, "")) {              auth_password(pw, "")) {
                 /* Authentication with empty password succeeded. */                  /* Authentication with empty password succeeded. */
                 log("Login for user %s from %.100s, accepted without authentication.",                  log("Login for user %s from %.100s, accepted without authentication.",
                     pw->pw_name, get_remote_ipaddr());                      user, get_remote_ipaddr());
         } else {          } else {
                 /* Loop until the user has been authenticated or the                  /* Loop until the user has been authenticated or the
                    connection is closed, do_authloop() returns only if                     connection is closed, do_authloop() returns only if
                    authentication is successfull */                     authentication is successfull */
                 do_authloop(pw);                  do_authloop(pw, user);
         }          }
           if (pw == NULL)
                   fatal("internal error, authentication successfull for user '%.100s'", user);
   
         /* The user has been authenticated and accepted. */          /* The user has been authenticated and accepted. */
         packet_start(SSH_SMSG_SUCCESS);          packet_start(SSH_SMSG_SUCCESS);
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.2.2.2