[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.22.2.3 and 1.23

version 1.22.2.3, 2002/06/02 22:56:09 version 1.23, 2001/05/18 14:13:28
Line 22 
Line 22 
 #include "servconf.h"  #include "servconf.h"
 #include "compat.h"  #include "compat.h"
 #include "auth.h"  #include "auth.h"
 #include "channels.h"  
 #include "session.h"  #include "session.h"
 #include "uidswap.h"  #include "misc.h"
 #include "monitor_wrap.h"  
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
Line 33 
Line 31 
 /*  /*
  * convert ssh auth msg type into description   * convert ssh auth msg type into description
  */   */
 static char *  char *
 get_authname(int type)  get_authname(int type)
 {  {
         static char buf[1024];          static char buf[1024];
Line 49 
Line 47 
         case SSH_CMSG_AUTH_TIS:          case SSH_CMSG_AUTH_TIS:
         case SSH_CMSG_AUTH_TIS_RESPONSE:          case SSH_CMSG_AUTH_TIS_RESPONSE:
                 return "challenge-response";                  return "challenge-response";
 #if defined(KRB4) || defined(KRB5)  #ifdef KRB4
         case SSH_CMSG_AUTH_KERBEROS:          case SSH_CMSG_AUTH_KERBEROS:
                 return "kerberos";                  return "kerberos";
 #endif  #endif
Line 62 
Line 60 
  * read packets, try to authenticate the user and   * read packets, try to authenticate the user and
  * return only if authentication is successful   * return only if authentication is successful
  */   */
 static void  void
 do_authloop(Authctxt *authctxt)  do_authloop(Authctxt *authctxt)
 {  {
         int authenticated = 0;          int authenticated = 0;
         u_int bits;          u_int bits;
         Key *client_host_key;          RSA *client_host_key;
         BIGNUM *n;          BIGNUM *n;
         char *client_user, *password;          char *client_user, *password;
         char info[1024];          char info[1024];
         u_int dlen;          u_int dlen;
           int plen, nlen, elen;
         u_int ulen;          u_int ulen;
         int type = 0;          int type = 0;
         struct passwd *pw = authctxt->pw;          struct passwd *pw = authctxt->pw;
   
         debug("Attempting authentication for %s%.100s.",          debug("Attempting authentication for %s%.100s.",
             authctxt->valid ? "" : "illegal user ", authctxt->user);               authctxt->valid ? "" : "illegal user ", authctxt->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 &&
 #if defined(KRB4) || defined(KRB5)  #ifdef KRB4
             (!options.kerberos_authentication || options.kerberos_or_local_passwd) &&              (!options.kerberos_authentication || options.kerberos_or_local_passwd) &&
 #endif  #endif
             PRIVSEP(auth_password(authctxt, ""))) {              auth_password(authctxt, "")) {
                 auth_log(authctxt, 1, "without authentication", "");                  auth_log(authctxt, 1, "without authentication", "");
                 return;                  return;
         }          }
Line 101 
Line 100 
                 info[0] = '\0';                  info[0] = '\0';
   
                 /* Get a packet from the client. */                  /* Get a packet from the client. */
                 type = packet_read();                  type = packet_read(&plen);
   
                 /* Process the packet. */                  /* Process the packet. */
                 switch (type) {                  switch (type) {
   #ifdef AFS
                   case SSH_CMSG_HAVE_KERBEROS_TGT:
                           if (!options.kerberos_tgt_passing) {
                                   verbose("Kerberos tgt passing disabled.");
                                   break;
                           } else {
                                   /* Accept Kerberos tgt. */
                                   char *tgt = packet_get_string(&dlen);
                                   packet_integrity_check(plen, 4 + dlen, type);
                                   if (!auth_kerberos_tgt(pw, tgt))
                                           verbose("Kerberos tgt REFUSED for %.100s", authctxt->user);
                                   xfree(tgt);
                           }
                           continue;
   
 #if defined(KRB4) || defined(KRB5)                  case SSH_CMSG_HAVE_AFS_TOKEN:
                           if (!options.afs_token_passing || !k_hasafs()) {
                                   verbose("AFS token passing disabled.");
                                   break;
                           } else {
                                   /* Accept AFS token. */
                                   char *token_string = packet_get_string(&dlen);
                                   packet_integrity_check(plen, 4 + dlen, type);
                                   if (!auth_afs_token(pw, token_string))
                                           verbose("AFS token REFUSED for %.100s", authctxt->user);
                                   xfree(token_string);
                           }
                           continue;
   #endif /* AFS */
   #ifdef KRB4
                 case SSH_CMSG_AUTH_KERBEROS:                  case SSH_CMSG_AUTH_KERBEROS:
                         if (!options.kerberos_authentication) {                          if (!options.kerberos_authentication) {
                                 verbose("Kerberos authentication disabled.");                                  verbose("Kerberos authentication disabled.");
                                   break;
                         } else {                          } else {
                                 char *kdata = packet_get_string(&dlen);                                  /* Try Kerberos v4 authentication. */
                                 packet_check_eom();                                  KTEXT_ST auth;
                                   char *tkt_user = NULL;
                                   char *kdata = packet_get_string((u_int *) &auth.length);
                                   packet_integrity_check(plen, 4 + auth.length, type);
   
                                 if (kdata[0] == 4) { /* KRB_PROT_VERSION */                                  if (authctxt->valid) {
 #ifdef KRB4                                          if (auth.length < MAX_KTXT_LEN)
                                         KTEXT_ST tkt;                                                  memcpy(auth.dat, kdata, auth.length);
                                           authenticated = auth_krb4(pw->pw_name, &auth, &tkt_user);
                                         tkt.length = dlen;                                          if (authenticated) {
                                         if (tkt.length < MAX_KTXT_LEN)                                                  snprintf(info, sizeof info,
                                                 memcpy(tkt.dat, kdata, tkt.length);                                                      " tktuser %.100s", tkt_user);
                                                   xfree(tkt_user);
                                         if (auth_krb4(authctxt, &tkt, &client_user)) {  
                                                 authenticated = 1;  
                                                 snprintf(info, sizeof(info),  
                                                     " tktuser %.100s",  
                                                     client_user);  
                                                 xfree(client_user);  
                                         }                                          }
 #endif /* KRB4 */  
                                 } else {  
 #ifdef KRB5  
                                         krb5_data tkt;  
                                         tkt.length = dlen;  
                                         tkt.data = kdata;  
   
                                         if (auth_krb5(authctxt, &tkt, &client_user)) {  
                                                 authenticated = 1;  
                                                 snprintf(info, sizeof(info),  
                                                     " tktuser %.100s",  
                                                     client_user);  
                                                 xfree(client_user);  
                                         }  
 #endif /* KRB5 */  
                                 }                                  }
                                 xfree(kdata);                                  xfree(kdata);
                         }                          }
                         break;                          break;
 #endif /* KRB4 || KRB5 */  #endif /* KRB4 */
   
 #if defined(AFS) || defined(KRB5)  
                         /* XXX - punt on backward compatibility here. */  
                 case SSH_CMSG_HAVE_KERBEROS_TGT:  
                         packet_send_debug("Kerberos TGT passing disabled before authentication.");  
                         break;  
 #ifdef AFS  
                 case SSH_CMSG_HAVE_AFS_TOKEN:  
                         packet_send_debug("AFS token passing disabled before authentication.");  
                         break;  
 #endif /* AFS */  
 #endif /* AFS || KRB5 */  
   
                 case SSH_CMSG_AUTH_RHOSTS:                  case SSH_CMSG_AUTH_RHOSTS:
                         if (!options.rhosts_authentication) {                          if (!options.rhosts_authentication) {
                                 verbose("Rhosts authentication disabled.");                                  verbose("Rhosts authentication disabled.");
Line 174 
Line 172 
                          * IP-spoofing on a local network.)                           * IP-spoofing on a local network.)
                          */                           */
                         client_user = packet_get_string(&ulen);                          client_user = packet_get_string(&ulen);
                         packet_check_eom();                          packet_integrity_check(plen, 4 + ulen, type);
   
                         /* Try to authenticate using /etc/hosts.equiv and .rhosts. */                          /* Try to authenticate using /etc/hosts.equiv and .rhosts. */
                         authenticated = auth_rhosts(pw, client_user);                          authenticated = auth_rhosts(pw, client_user);
Line 196 
Line 194 
                         client_user = packet_get_string(&ulen);                          client_user = packet_get_string(&ulen);
   
                         /* Get the client host key. */                          /* Get the client host key. */
                         client_host_key = key_new(KEY_RSA1);                          client_host_key = RSA_new();
                           if (client_host_key == NULL)
                                   fatal("RSA_new failed");
                           client_host_key->e = BN_new();
                           client_host_key->n = BN_new();
                           if (client_host_key->e == NULL || client_host_key->n == NULL)
                                   fatal("BN_new failed");
                         bits = packet_get_int();                          bits = packet_get_int();
                         packet_get_bignum(client_host_key->rsa->e);                          packet_get_bignum(client_host_key->e, &elen);
                         packet_get_bignum(client_host_key->rsa->n);                          packet_get_bignum(client_host_key->n, &nlen);
   
                         if (bits != BN_num_bits(client_host_key->rsa->n))                          if (bits != BN_num_bits(client_host_key->n))
                                 verbose("Warning: keysize mismatch for client_host_key: "                                  verbose("Warning: keysize mismatch for client_host_key: "
                                     "actual %d, announced %d",                                      "actual %d, announced %d", BN_num_bits(client_host_key->n), bits);
                                      BN_num_bits(client_host_key->rsa->n), bits);                          packet_integrity_check(plen, (4 + ulen) + 4 + elen + nlen, type);
                         packet_check_eom();  
   
                         authenticated = auth_rhosts_rsa(pw, client_user,                          authenticated = auth_rhosts_rsa(pw, client_user, client_host_key);
                             client_host_key);                          RSA_free(client_host_key);
                         key_free(client_host_key);  
   
                         snprintf(info, sizeof info, " ruser %.100s", client_user);                          snprintf(info, sizeof info, " ruser %.100s", client_user);
                         xfree(client_user);                          xfree(client_user);
Line 221 
Line 223 
                                 break;                                  break;
                         }                          }
                         /* RSA authentication requested. */                          /* RSA authentication requested. */
                         if ((n = BN_new()) == NULL)                          n = BN_new();
                                 fatal("do_authloop: BN_new failed");                          packet_get_bignum(n, &nlen);
                         packet_get_bignum(n);                          packet_integrity_check(plen, nlen, type);
                         packet_check_eom();  
                         authenticated = auth_rsa(pw, n);                          authenticated = auth_rsa(pw, n);
                         BN_clear_free(n);                          BN_clear_free(n);
                         break;                          break;
Line 240 
Line 241 
                          * not visible to an outside observer.                           * not visible to an outside observer.
                          */                           */
                         password = packet_get_string(&dlen);                          password = packet_get_string(&dlen);
                         packet_check_eom();                          packet_integrity_check(plen, 4 + dlen, type);
   
                         /* Try authentication with the password. */                          /* Try authentication with the password. */
                         authenticated = PRIVSEP(auth_password(authctxt, password));                          authenticated = auth_password(authctxt, password);
   
                         memset(password, 0, strlen(password));                          memset(password, 0, strlen(password));
                         xfree(password);                          xfree(password);
Line 269 
Line 270 
                         if (options.challenge_response_authentication == 1) {                          if (options.challenge_response_authentication == 1) {
                                 char *response = packet_get_string(&dlen);                                  char *response = packet_get_string(&dlen);
                                 debug("got response '%s'", response);                                  debug("got response '%s'", response);
                                 packet_check_eom();                                  packet_integrity_check(plen, 4 + dlen, type);
                                 authenticated = verify_response(authctxt, response);                                  authenticated = verify_response(authctxt, response);
                                 memset(response, 'r', dlen);                                  memset(response, 'r', dlen);
                                 xfree(response);                                  xfree(response);
Line 318 
Line 319 
  * Performs authentication of an incoming connection.  Session key has already   * Performs authentication of an incoming connection.  Session key has already
  * been exchanged and encryption is enabled.   * been exchanged and encryption is enabled.
  */   */
 Authctxt *  void
 do_authentication(void)  do_authentication()
 {  {
         Authctxt *authctxt;          Authctxt *authctxt;
           struct passwd *pw;
           int plen;
         u_int ulen;          u_int ulen;
         char *user, *style = NULL;          char *user, *style = NULL;
   
         /* Get the name of the user that we wish to log in as. */          /* Get the name of the user that we wish to log in as. */
         packet_read_expect(SSH_CMSG_USER);          packet_read_expect(&plen, SSH_CMSG_USER);
   
         /* Get the user name. */          /* Get the user name. */
         user = packet_get_string(&ulen);          user = packet_get_string(&ulen);
         packet_check_eom();          packet_integrity_check(plen, (4 + ulen), SSH_CMSG_USER);
   
         if ((style = strchr(user, ':')) != NULL)          if ((style = strchr(user, ':')) != NULL)
                 *style++ = '\0';                  *style++ = 0;
   
 #ifdef KRB5  
         /* XXX - SSH.com Kerberos v5 braindeath. */  
         if ((datafellows & SSH_BUG_K5USER) &&  
             options.kerberos_authentication) {  
                 char *p;  
                 if ((p = strchr(user, '@')) != NULL)  
                         *p = '\0';  
         }  
 #endif  
   
         authctxt = authctxt_new();          authctxt = authctxt_new();
         authctxt->user = user;          authctxt->user = user;
         authctxt->style = style;          authctxt->style = style;
   
         /* Verify that the user is a valid user. */          /* Verify that the user is a valid user. */
         if ((authctxt->pw = PRIVSEP(getpwnamallow(user))) != NULL)          pw = getpwnam(user);
           if (pw && allowed_user(pw)) {
                 authctxt->valid = 1;                  authctxt->valid = 1;
         else                  pw = pwcopy(pw);
           } else {
                 debug("do_authentication: illegal user %s", user);                  debug("do_authentication: illegal user %s", user);
                   pw = NULL;
           }
           authctxt->pw = pw;
   
         setproctitle("%s%s", authctxt->pw ? user : "unknown",          setproctitle("%s", pw ? user : "unknown");
             use_privsep ? " [net]" : "");  
   
         /*          /*
          * 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 (!use_privsep && getuid() != 0 && authctxt->pw &&          if (getuid() != 0 && pw && pw->pw_uid != getuid())
             authctxt->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.");
   
         /*          /*
Line 377 
Line 373 
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         return (authctxt);          /* Perform session preparation. */
           do_authenticated(authctxt);
 }  }
Legend:
Removed from v.1.22.2.3  
changed lines
  Added in v.1.23