[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.24 and 1.25

version 1.24, 2001/06/23 15:12:17 version 1.25, 2001/06/26 16:15:23
Line 24 
Line 24 
 #include "auth.h"  #include "auth.h"
 #include "session.h"  #include "session.h"
 #include "misc.h"  #include "misc.h"
   #include "uidswap.h"
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
Line 47 
Line 48 
         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 80 
Line 81 
   
         /* 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, "")) {              auth_password(authctxt, "")) {
                 auth_log(authctxt, 1, "without authentication", "");                  auth_log(authctxt, 1, "without authentication", "");
                 return;                  return;
         }          }
   
         /* Indicate that authentication is needed. */          /* Indicate that authentication is needed. */
         packet_start(SSH_SMSG_FAILURE);          packet_start(SSH_SMSG_FAILURE);
         packet_send();          packet_send();
Line 104 
Line 105 
   
                 /* 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;  
                                 char *tkt_user = NULL;                                  packet_integrity_check(plen, 4 + dlen, type);
                                 char *kdata = packet_get_string((u_int *) &auth.length);  
                                 packet_integrity_check(plen, 4 + auth.length, type);                                  if (kdata[0] == 4) { /* KRB_PROT_VERSION */
   #ifdef KRB4
                                 if (authctxt->valid) {                                          KTEXT_ST tkt;
                                         if (auth.length < MAX_KTXT_LEN)  
                                                 memcpy(auth.dat, kdata, auth.length);                                          tkt.length = dlen;
                                         authenticated = auth_krb4(pw->pw_name, &auth, &tkt_user);                                          if (tkt.length < MAX_KTXT_LEN)
                                         if (authenticated) {                                                  memcpy(tkt.dat, kdata, tkt.length);
                                                 snprintf(info, sizeof info,  
                                                     " tktuser %.100s", tkt_user);                                          if (auth_krb4(authctxt, &tkt, &client_user)) {
                                                 xfree(tkt_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 326 
Line 329 
         struct passwd *pw;          struct passwd *pw;
         int plen;          int plen;
         u_int ulen;          u_int ulen;
         char *user, *style = NULL;          char *p, *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(&plen, SSH_CMSG_USER);
Line 336 
Line 339 
         packet_integrity_check(plen, (4 + ulen), SSH_CMSG_USER);          packet_integrity_check(plen, (4 + ulen), SSH_CMSG_USER);
   
         if ((style = strchr(user, ':')) != NULL)          if ((style = strchr(user, ':')) != NULL)
                 *style++ = 0;                  *style++ = '\0';
   
           /* XXX - SSH.com Kerberos v5 braindeath. */
           if ((p = strchr(user, '@')) != NULL)
                   *p = '\0';
   
         authctxt = authctxt_new();          authctxt = authctxt_new();
         authctxt->user = user;          authctxt->user = user;
         authctxt->style = style;          authctxt->style = style;
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25