[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 and 1.22.2.3

version 1.22, 2001/03/23 12:02:49 version 1.22.2.3, 2002/06/02 22:56:09
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 "misc.h"  #include "uidswap.h"
   #include "monitor_wrap.h"
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
Line 31 
Line 33 
 /*  /*
  * convert ssh auth msg type into description   * convert ssh auth msg type into description
  */   */
 char *  static char *
 get_authname(int type)  get_authname(int type)
 {  {
         static char buf[1024];          static char buf[1024];
Line 47 
Line 49 
         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";
 #ifdef KRB4  #if defined(KRB4) || defined(KRB5)
         case SSH_CMSG_AUTH_KERBEROS:          case SSH_CMSG_AUTH_KERBEROS:
                 return "kerberos";                  return "kerberos";
 #endif  #endif
Line 60 
Line 62 
  * 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
  */   */
 void  static void
 do_authloop(Authctxt *authctxt)  do_authloop(Authctxt *authctxt)
 {  {
         int authenticated = 0;          int authenticated = 0;
         u_int bits;          u_int bits;
         RSA *client_host_key;          Key *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 &&
 #ifdef KRB4  #if defined(KRB4) || defined(KRB5)
             (!options.kerberos_authentication || options.kerberos_or_local_passwd) &&              (!options.kerberos_authentication || options.kerberos_or_local_passwd) &&
 #endif  #endif
             auth_password(authctxt, "")) {              PRIVSEP(auth_password(authctxt, ""))) {
                 auth_log(authctxt, 1, "without authentication", "");                  auth_log(authctxt, 1, "without authentication", "");
                 return;                  return;
         }          }
Line 100 
Line 101 
                 info[0] = '\0';                  info[0] = '\0';
   
                 /* Get a packet from the client. */                  /* Get a packet from the client. */
                 type = packet_read(&plen);                  type = packet_read();
   
                 /* 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;  
   
                 case SSH_CMSG_HAVE_AFS_TOKEN:  #if defined(KRB4) || defined(KRB5)
                         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 {
                                 /* Try Kerberos v4 authentication. */                                  char *kdata = packet_get_string(&dlen);
                                 KTEXT_ST auth;                                  packet_check_eom();
                                 char *tkt_user = NULL;  
                                 char *kdata = packet_get_string((u_int *) &auth.length);  
                                 packet_integrity_check(plen, 4 + auth.length, type);  
   
                                 if (authctxt->valid) {                                  if (kdata[0] == 4) { /* KRB_PROT_VERSION */
                                         if (auth.length < MAX_KTXT_LEN)  #ifdef KRB4
                                                 memcpy(auth.dat, kdata, auth.length);                                          KTEXT_ST tkt;
                                         authenticated = auth_krb4(pw->pw_name, &auth, &tkt_user);  
                                         if (authenticated) {                                          tkt.length = dlen;
                                                 snprintf(info, sizeof info,                                          if (tkt.length < MAX_KTXT_LEN)
                                                     " tktuser %.100s", tkt_user);                                                  memcpy(tkt.dat, kdata, tkt.length);
                                                 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 */  #endif /* KRB4 || KRB5 */
   
   #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 172 
Line 174 
                          * 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_integrity_check(plen, 4 + ulen, type);                          packet_check_eom();
   
                         /* 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 194 
Line 196 
                         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 = RSA_new();                          client_host_key = key_new(KEY_RSA1);
                         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->e, &elen);                          packet_get_bignum(client_host_key->rsa->e);
                         packet_get_bignum(client_host_key->n, &nlen);                          packet_get_bignum(client_host_key->rsa->n);
   
                         if (bits != BN_num_bits(client_host_key->n))                          if (bits != BN_num_bits(client_host_key->rsa->n))
                                 verbose("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",
                         packet_integrity_check(plen, (4 + ulen) + 4 + elen + nlen, type);                                       BN_num_bits(client_host_key->rsa->n), bits);
                           packet_check_eom();
   
                         authenticated = auth_rhosts_rsa(pw, client_user, client_host_key);                          authenticated = auth_rhosts_rsa(pw, client_user,
                         RSA_free(client_host_key);                              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 223 
Line 221 
                                 break;                                  break;
                         }                          }
                         /* RSA authentication requested. */                          /* RSA authentication requested. */
                         n = BN_new();                          if ((n = BN_new()) == NULL)
                         packet_get_bignum(n, &nlen);                                  fatal("do_authloop: BN_new failed");
                         packet_integrity_check(plen, nlen, type);                          packet_get_bignum(n);
                           packet_check_eom();
                         authenticated = auth_rsa(pw, n);                          authenticated = auth_rsa(pw, n);
                         BN_clear_free(n);                          BN_clear_free(n);
                         break;                          break;
Line 241 
Line 240 
                          * not visible to an outside observer.                           * not visible to an outside observer.
                          */                           */
                         password = packet_get_string(&dlen);                          password = packet_get_string(&dlen);
                         packet_integrity_check(plen, 4 + dlen, type);                          packet_check_eom();
   
                         /* Try authentication with the password. */                          /* Try authentication with the password. */
                         authenticated = auth_password(authctxt, password);                          authenticated = PRIVSEP(auth_password(authctxt, password));
   
                         memset(password, 0, strlen(password));                          memset(password, 0, strlen(password));
                         xfree(password);                          xfree(password);
Line 252 
Line 251 
   
                 case SSH_CMSG_AUTH_TIS:                  case SSH_CMSG_AUTH_TIS:
                         debug("rcvd SSH_CMSG_AUTH_TIS");                          debug("rcvd SSH_CMSG_AUTH_TIS");
                         if (options.challenge_reponse_authentication == 1) {                          if (options.challenge_response_authentication == 1) {
                                 char *challenge = get_challenge(authctxt, authctxt->style);                                  char *challenge = get_challenge(authctxt);
                                 if (challenge != NULL) {                                  if (challenge != NULL) {
                                         debug("sending challenge '%s'", challenge);                                          debug("sending challenge '%s'", challenge);
                                         packet_start(SSH_SMSG_AUTH_TIS_CHALLENGE);                                          packet_start(SSH_SMSG_AUTH_TIS_CHALLENGE);
                                         packet_put_cstring(challenge);                                          packet_put_cstring(challenge);
                                           xfree(challenge);
                                         packet_send();                                          packet_send();
                                         packet_write_wait();                                          packet_write_wait();
                                         continue;                                          continue;
Line 266 
Line 266 
                         break;                          break;
                 case SSH_CMSG_AUTH_TIS_RESPONSE:                  case SSH_CMSG_AUTH_TIS_RESPONSE:
                         debug("rcvd SSH_CMSG_AUTH_TIS_RESPONSE");                          debug("rcvd SSH_CMSG_AUTH_TIS_RESPONSE");
                         if (options.challenge_reponse_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_integrity_check(plen, 4 + dlen, type);                                  packet_check_eom();
                                 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 318 
  * 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.
  */   */
 void  Authctxt *
 do_authentication()  do_authentication(void)
 {  {
         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(&plen, SSH_CMSG_USER);          packet_read_expect(SSH_CMSG_USER);
   
         /* Get the user name. */          /* Get the user name. */
         user = packet_get_string(&ulen);          user = packet_get_string(&ulen);
         packet_integrity_check(plen, (4 + ulen), SSH_CMSG_USER);          packet_check_eom();
   
         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. */
         pw = getpwnam(user);          if ((authctxt->pw = PRIVSEP(getpwnamallow(user))) != NULL)
         if (pw && allowed_user(pw)) {  
                 authctxt->valid = 1;                  authctxt->valid = 1;
                 pw = pwcopy(pw);          else
         } else {  
                 debug("do_authentication: illegal user %s", user);                  debug("do_authentication: illegal user %s", user);
                 pw = NULL;  
         }  
         authctxt->pw = pw;  
   
         setproctitle("%s", pw ? user : "unknown");          setproctitle("%s%s", authctxt->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 (getuid() != 0 && pw && pw->pw_uid != getuid())          if (!use_privsep && getuid() != 0 && authctxt->pw &&
               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 372 
Line 377 
         packet_send();          packet_send();
         packet_write_wait();          packet_write_wait();
   
         /* Perform session preparation. */          return (authctxt);
         do_authenticated(authctxt);  
 }  }
Legend:
Removed from v.1.22  
changed lines
  Added in v.1.22.2.3