home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / password.c < prev    next >
C/C++ Source or Header  |  1997-08-12  |  45KB  |  1,683 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Password and authentication handling
  5.    Copyright (C) Andrew Tridgell 1992-1997
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "includes.h"
  23.  
  24. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  25. #include "rpcsvc/ypclnt.h"
  26. #endif
  27.  
  28. extern int DEBUGLEVEL;
  29. extern int Protocol;
  30.  
  31. /* users from session setup */
  32. static pstring session_users="";
  33.  
  34. /* these are kept here to keep the string_combinations function simple */
  35. static char this_user[100]="";
  36. static char this_salt[100]="";
  37. static char this_crypted[100]="";
  38.  
  39. #ifdef SMB_PASSWD
  40. /* Data to do lanman1/2 password challenge. */
  41. static unsigned char saved_challenge[8];
  42. static BOOL challenge_sent=False;
  43.  
  44. /*******************************************************************
  45. Get the next challenge value - no repeats.
  46. ********************************************************************/
  47. void generate_next_challenge(char *challenge)
  48. {
  49.   static int counter = 0;
  50.   struct timeval tval;
  51.   int v1,v2;
  52.   GetTimeOfDay(&tval);
  53.   v1 = (counter++) + getpid() + tval.tv_sec;
  54.   v2 = (counter++) * getpid() + tval.tv_usec;
  55.   SIVAL(challenge,0,v1);
  56.   SIVAL(challenge,4,v2);
  57.   E1((uchar *)challenge,(uchar *)"SAMBA",(uchar *)saved_challenge);
  58.   memcpy(challenge,saved_challenge,8);
  59.   challenge_sent = True;
  60. }
  61.  
  62. /*******************************************************************
  63. set the last challenge sent, usually from a password server
  64. ********************************************************************/
  65. BOOL set_challenge(char *challenge)
  66. {
  67.   memcpy(saved_challenge,challenge,8);
  68.   challenge_sent = True;
  69.   return(True);
  70. }
  71.  
  72. /*******************************************************************
  73. get the last challenge sent
  74. ********************************************************************/
  75. BOOL last_challenge(char *challenge)
  76. {
  77.   if (!challenge_sent) return(False);
  78.   memcpy(challenge,saved_challenge,8);
  79.   return(True);
  80. }
  81. #endif
  82.  
  83. /* this holds info on user ids that are already validated for this VC */
  84. static user_struct *validated_users = NULL;
  85. static int num_validated_users = 0;
  86.  
  87. /****************************************************************************
  88. check if a uid has been validated, and return an pointer to the user_struct
  89. if it has. NULL if not. vuid is biased by an offset. This allows us to
  90. tell random client vuid's (normally zero) from valid vuids.
  91. ****************************************************************************/
  92. user_struct *get_valid_user_struct(uint16 vuid)
  93. {
  94.   if(vuid == UID_FIELD_INVALID)
  95.     return NULL;
  96.   vuid -= VUID_OFFSET;
  97.   if((vuid >= (uint16)num_validated_users) || 
  98.      (validated_users[vuid].uid == -1) || (validated_users[vuid].gid == -1))
  99.     return NULL;
  100.   return &validated_users[vuid];
  101. }
  102.  
  103. /****************************************************************************
  104. invalidate a uid
  105. ****************************************************************************/
  106. void invalidate_vuid(uint16 vuid)
  107. {
  108.   user_struct *vuser = get_valid_user_struct(vuid);
  109.   if(vuser == 0)
  110.     return;
  111.  
  112.   vuser->uid = -1;
  113.   vuser->gid = -1;
  114.   vuser->user_ngroups = 0;
  115.   if(vuser->user_groups && 
  116.      (vuser->user_groups != (gid_t *)vuser->user_igroups))
  117.        free(vuser->user_groups);
  118.   vuser->user_groups = NULL;
  119.   if(vuser->user_igroups)
  120.     free(vuser->user_igroups);
  121.   vuser->user_igroups = NULL;
  122. }
  123.  
  124.  
  125. /****************************************************************************
  126. return a validated username
  127. ****************************************************************************/
  128. char *validated_username(uint16 vuid)
  129. {
  130.   user_struct *vuser = get_valid_user_struct(vuid);
  131.   if(vuser == 0)
  132.     return 0;
  133.   return(vuser->name);
  134. }
  135.  
  136. /****************************************************************************
  137. register a uid/name pair as being valid and that a valid password
  138. has been given. vuid is biased by an offset. This allows us to
  139. tell random client vuid's (normally zero) from valid vuids.
  140. ****************************************************************************/
  141. uint16 register_vuid(int uid,int gid, char *name,BOOL guest)
  142. {
  143.   user_struct *vuser;
  144.  
  145. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  146.   int nis_error;        /* returned by yp all functions */
  147.   char *nis_result;     /* yp_match inits this */
  148.   int nis_result_len;  /* and set this */
  149.   char *nis_domain;     /* yp_get_default_domain inits this */
  150.   char *nis_map = (char *)lp_nis_home_map_name();
  151.   int home_server_len;
  152. #endif
  153.   struct passwd *pwfile; /* for getting real name from passwd file */
  154.   int real_name_len;
  155.  
  156. #if 0
  157.   /*
  158.    * After observing MS-Exchange services writing to a Samba share
  159.    * I belive this code is incorrect. Each service does it's own
  160.    * sessionsetup_and_X for the same user, and as each service shuts
  161.    * down, it does a user_logoff_and_X. As we are consolidating multiple
  162.    * sessionsetup_and_X's onto the same vuid here, when the first service
  163.    * shuts down, it invalidates all the open files for the other services.
  164.    * Hence I am removing this code and forcing each sessionsetup_and_X
  165.    * to get a new vuid.
  166.    * Jeremy Allison. (jallison@whistle.com).
  167.    */
  168.  
  169.   int i;
  170.   for(i = 0; i < num_validated_users; i++) {
  171.     vuser = &validated_users[i];
  172.     if( vuser->uid == uid )
  173.       return (uint16)(i + VUID_OFFSET); /* User already validated */
  174.   }
  175. #endif
  176.  
  177.   validated_users = (user_struct *)Realloc(validated_users,
  178.                sizeof(user_struct)*
  179.                (num_validated_users+1));
  180.   
  181.   if (!validated_users)
  182.     {
  183.       DEBUG(0,("Failed to realloc users struct!\n"));
  184.       num_validated_users = 0;
  185.       return UID_FIELD_INVALID;
  186.     }
  187.  
  188.   vuser = &validated_users[num_validated_users];
  189.   num_validated_users++;
  190.  
  191.   vuser->uid = uid;
  192.   vuser->gid = gid;
  193.   vuser->guest = guest;
  194.   strcpy(vuser->name,name);
  195.  
  196.   vuser->user_ngroups = 0;
  197.   vuser->user_groups = NULL;
  198.   vuser->user_igroups = NULL;
  199.  
  200.   /* Find all the groups this uid is in and store them. 
  201.      Used by become_user() */
  202.   setup_groups(name,uid,gid,
  203.            &vuser->user_ngroups,
  204.            &vuser->user_igroups,
  205.            &vuser->user_groups);
  206.  
  207.   DEBUG(3,("uid %d registered to name %s\n",uid,name));
  208.  
  209. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  210.   vuser->home_share = NULL;
  211.   DEBUG(3, ("Setting default HOMESHR to: \\\\logon server\\HOMES\n"));
  212.   vuser->home_share = Realloc(vuser->home_share, 32);
  213.   strcpy(vuser->home_share,"\\\\%L\\HOMES");
  214.  
  215.   if (nis_error = yp_get_default_domain(&nis_domain))
  216.     DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
  217.   DEBUG(3, ("NIS Domain: %s\n", nis_domain));
  218.  
  219.   if (nis_error = yp_match(nis_domain, nis_map, vuser->name, strlen(vuser->name),
  220.                         &nis_result, &nis_result_len))
  221.     DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
  222.   if (!nis_error && lp_nis_home_map()) {
  223.     home_server_len = strcspn(nis_result,":");
  224.     DEBUG(3, ("NIS lookup succeeded\n\tHome server length: %d\n",home_server_len));
  225.     vuser->home_share = (char *)Realloc(vuser->home_share, home_server_len+12);
  226.     DEBUG(3, ("\tAllocated %d bytes for HOMESHR\n",home_server_len+12 ));
  227.     strcpy(vuser->home_share,"\\\\");
  228.     strncat(vuser->home_share, nis_result, home_server_len);
  229.     strcat(vuser->home_share,"\\homes");
  230.     DEBUG(2,("\tUser = %s\n\tUID = %d\n\tNIS result = %s\n\tHOMESHR = %s\n",
  231.            vuser->name, vuser->uid, nis_result, vuser->home_share));
  232.   }
  233. #endif
  234.  
  235.   vuser->real_name = NULL;
  236.   DEBUG(3, ("Clearing default real name\n"));
  237.   vuser->real_name = Realloc(vuser->real_name, 15);
  238.   strcpy(vuser->real_name, "<Full Name>\0");
  239.   if (lp_unix_realname()) {
  240.     if((pwfile=getpwnam(vuser->name))!= NULL)
  241.       {
  242.       DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->name,pwfile->pw_gecos));
  243.       real_name_len = strcspn(pwfile->pw_gecos, ",");
  244.       DEBUG(3, ("Real name length: %d\n", real_name_len));
  245.       vuser->real_name = (char *)Realloc(vuser->real_name, real_name_len+1);
  246.       strncpy(vuser->real_name, pwfile->pw_gecos, real_name_len);
  247.       vuser->real_name[real_name_len]='\0';
  248.       }
  249.   }
  250.  
  251.   return (uint16)((num_validated_users - 1) + VUID_OFFSET);
  252. }
  253.  
  254.  
  255. /****************************************************************************
  256. add a name to the session users list
  257. ****************************************************************************/
  258. void add_session_user(char *user)
  259. {
  260.   fstring suser;
  261.   StrnCpy(suser,user,sizeof(suser)-1);
  262.  
  263.   if (!Get_Pwnam(suser,True)) return;
  264.  
  265.   if (suser && *suser && !in_list(suser,session_users,False))
  266.     {
  267.       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
  268.     DEBUG(1,("Too many session users??\n"));
  269.       else
  270.     {
  271.       strcat(session_users," ");
  272.       strcat(session_users,suser);
  273.     }
  274.     }
  275. }
  276.  
  277.  
  278. #ifdef NO_GETSPNAM
  279. /* a fake shadow password routine which just fills a fake spwd struct
  280.  * with the sp_pwdp field. (sreiz@aie.nl)
  281.  */
  282. static struct spwd *getspnam(char *username) /* fake shadow password routine */
  283. {
  284.        FILE *f;
  285.        char line[1024];
  286.        static char pw[20];
  287.        static struct spwd static_spwd;
  288.  
  289.        static_spwd.sp_pwdp=0;
  290.        if (!(f=fopen("/etc/master.passwd", "r")))
  291.                return 0;
  292.        while (fgets(line, 1024, f)) {
  293.                if (!strncmp(line, username, strlen(username)) &&
  294.                 line[strlen(username)]==':') { /* found entry */
  295.                        char *p, *q;
  296.  
  297.                        p=line+strlen(username)+1;
  298.                        if ((q=strchr(p, ':'))) {
  299.                                *q=0;
  300.                                if (q-p+1>20)
  301.                                        break;
  302.                                strcpy(pw, p);
  303.                                static_spwd.sp_pwdp=pw;
  304.                        }
  305.                        break;
  306.                }
  307.        }
  308.        fclose(f);
  309.        if (static_spwd.sp_pwdp)
  310.                return &static_spwd;
  311.        return 0;
  312. }
  313. #endif
  314.  
  315.  
  316. #ifdef OSF1_ENH_SEC
  317. /****************************************************************************
  318. an enhanced crypt for OSF1
  319. ****************************************************************************/
  320. static char *osf1_bigcrypt(char *password,char *salt1)
  321. {
  322.   static char result[AUTH_MAX_PASSWD_LENGTH] = "";
  323.   char *p1;
  324.   char *p2=password;
  325.   char salt[3];
  326.   int i;
  327.   int parts = strlen(password) / AUTH_CLEARTEXT_SEG_CHARS;
  328.   if (strlen(password)%AUTH_CLEARTEXT_SEG_CHARS)
  329.     parts++;
  330.  
  331.   StrnCpy(salt,salt1,2);
  332.   StrnCpy(result,salt1,2);
  333.  
  334.   for (i=0; i<parts;i++)
  335.     {
  336.       p1 = crypt(p2,salt);
  337.       strcat(result,p1+2);
  338.       StrnCpy(salt,&result[2+i*AUTH_CIPHERTEXT_SEG_CHARS],2);
  339.       p2 += AUTH_CLEARTEXT_SEG_CHARS;
  340.     }
  341.  
  342.   return(result);
  343. }
  344. #endif
  345.  
  346.  
  347. /****************************************************************************
  348. update the enhanced security database. Only relevant for OSF1 at the moment.
  349. ****************************************************************************/
  350. static void update_protected_database( char *user, BOOL result)
  351. {
  352. #ifdef OSF1_ENH_SEC
  353.   struct pr_passwd *mypasswd;
  354.   time_t starttime;
  355.  
  356.   mypasswd = getprpwnam (user);
  357.   starttime = time (NULL);
  358.  
  359.   if (result)
  360.     {
  361.       mypasswd->ufld.fd_slogin = starttime;
  362.       mypasswd->ufld.fd_nlogins = 0;
  363.       
  364.       putprpwnam(user,mypasswd);
  365.       
  366.       DEBUG(3,("Update protected database for Account %s after succesful connection\n",user));
  367.     }
  368.   else
  369.     {
  370.       mypasswd->ufld.fd_ulogin = starttime;
  371.       mypasswd->ufld.fd_nlogins = mypasswd->ufld.fd_nlogins + 1;
  372.       if ( mypasswd->ufld.fd_max_tries != 0 && mypasswd->ufld.fd_nlogins > mypasswd->ufld.fd_max_tries )
  373.     {
  374.       mypasswd->uflg.fg_lock = 0;
  375.       DEBUG(3,("Account is disabled -- see Account Administrator.\n"));
  376.     }
  377.       putprpwnam ( user , mypasswd );
  378.       DEBUG(3,("Update protected database for Account %s after refusing connection\n",user));
  379.     }
  380. #else
  381.   DEBUG(6,("Updated database with %s %s\n",user,BOOLSTR(result)));
  382. #endif
  383. }
  384.  
  385.  
  386. #ifdef USE_PAM
  387. /*******************************************************************
  388. check on PAM authentication
  389. ********************************************************************/
  390.  
  391. /* We first need some helper functions */
  392. #include <security/pam_appl.h>
  393. /* Static variables used to communicate between the conversation function
  394.  * and the server_login function
  395.  */
  396. static char *PAM_username;
  397. static char *PAM_password;
  398.  
  399. /* PAM conversation function
  400.  * Here we assume (for now, at least) that echo on means login name, and
  401.  * echo off means password.
  402.  */
  403. static int PAM_conv (int num_msg,
  404.                      const struct pam_message **msg,
  405.                      struct pam_response **resp,
  406.                      void *appdata_ptr) {
  407.   int count = 0, replies = 0;
  408.   struct pam_response *reply = NULL;
  409.   int size = sizeof(struct pam_response);
  410.  
  411.   #define GET_MEM if (reply) realloc(reply, size); else reply = malloc(size); \
  412.   if (!reply) return PAM_CONV_ERR; \
  413.   size += sizeof(struct pam_response)
  414.   #define COPY_STRING(s) (s) ? strdup(s) : NULL
  415.  
  416.   for (count = 0; count < num_msg; count++) {
  417.     switch (msg[count]->msg_style) {
  418.       case PAM_PROMPT_ECHO_ON:
  419.         GET_MEM;
  420.         reply[replies].resp_retcode = PAM_SUCCESS;
  421.         reply[replies++].resp = COPY_STRING(PAM_username);
  422.           /* PAM frees resp */
  423.         break;
  424.       case PAM_PROMPT_ECHO_OFF:
  425.         GET_MEM;
  426.         reply[replies].resp_retcode = PAM_SUCCESS;
  427.         reply[replies++].resp = COPY_STRING(PAM_password);
  428.           /* PAM frees resp */
  429.         break;
  430.       case PAM_TEXT_INFO:
  431.         /* ignore it... */
  432.         break;
  433.       case PAM_ERROR_MSG:
  434.       default:
  435.         /* Must be an error of some sort... */
  436.         free (reply);
  437.         return PAM_CONV_ERR;
  438.     }
  439.   }
  440.   if (reply) *resp = reply;
  441.   return PAM_SUCCESS;
  442. }
  443. static struct pam_conv PAM_conversation = {
  444.     &PAM_conv,
  445.     NULL
  446. };
  447.  
  448.  
  449. static BOOL pam_auth(char *this_user,char *password)
  450. {
  451.   pam_handle_t *pamh;
  452.   int pam_error;
  453.  
  454.   /* Now use PAM to do authentication.  For now, we won't worry about
  455.    * session logging, only authentication.  Bail out if there are any
  456.    * errors.  Since this is a limited protocol, and an even more limited
  457.    * function within a server speaking this protocol, we can't be as
  458.    * verbose as would otherwise make sense.
  459.    * Query: should we be using PAM_SILENT to shut PAM up?
  460.    */
  461.   #define PAM_BAIL if (pam_error != PAM_SUCCESS) { \
  462.      pam_end(pamh, 0); return False; \
  463.    }
  464.   PAM_password = password;
  465.   PAM_username = this_user;
  466.   pam_error = pam_start("samba", this_user, &PAM_conversation, &pamh);
  467.   PAM_BAIL;
  468.   pam_error = pam_authenticate(pamh, 0);
  469.   PAM_BAIL;
  470.   /* It is not clear to me that account management is the right thing
  471.    * to do, but it is not clear that it isn't, either.  This can be
  472.    * removed if no account management should be done.  Alternately,
  473.    * put a pam_allow.so entry in /etc/pam.conf for account handling. */
  474.   pam_error = pam_acct_mgmt(pamh, 0);
  475.   PAM_BAIL;
  476.   pam_end(pamh, PAM_SUCCESS);
  477.   /* If this point is reached, the user has been authenticated. */
  478.   return(True);
  479. }
  480. #endif
  481.  
  482.  
  483. #ifdef AFS_AUTH
  484. /*******************************************************************
  485. check on AFS authentication
  486. ********************************************************************/
  487. static BOOL afs_auth(char *this_user,char *password)
  488. {
  489.   long password_expires = 0;
  490.   char *reason;
  491.     
  492.   /* For versions of AFS prior to 3.3, this routine has few arguments, */
  493.   /* but since I can't find the old documentation... :-)               */
  494.   setpag();
  495.   if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION+KA_USERAUTH_DOSETPAG,
  496.                  this_user,
  497.                  (char *) 0, /* instance */
  498.                  (char *) 0, /* cell */
  499.                  password,
  500.                  0,          /* lifetime, default */
  501.                  &password_expires, /*days 'til it expires */
  502.                  0,          /* spare 2 */
  503.                  &reason) == 0)
  504.     return(True);
  505.   return(False);
  506. }
  507. #endif
  508.  
  509.  
  510. #ifdef DFS_AUTH
  511.  
  512. sec_login_handle_t my_dce_sec_context;
  513. int dcelogin_atmost_once = 0;
  514.  
  515. /*******************************************************************
  516. check on a DCE/DFS authentication
  517. ********************************************************************/
  518. static BOOL dfs_auth(char *this_user,char *password)
  519. {
  520.   error_status_t err;
  521.   int err2;
  522.   int prterr;
  523.   boolean32 password_reset;
  524.   sec_passwd_rec_t my_dce_password;
  525.   sec_login_auth_src_t auth_src = sec_login_auth_src_network;
  526.   unsigned char dce_errstr[dce_c_error_string_len];
  527.  
  528.   /*
  529.    * We only go for a DCE login context if the given password
  530.    * matches that stored in the local password file.. 
  531.    * Assumes local passwd file is kept in sync w/ DCE RGY!
  532.    */
  533.  
  534.   if (!strcmp((char *)crypt(password,this_salt),this_crypted) ||
  535.       dcelogin_atmost_once)
  536.     return(False);
  537.  
  538.   if (sec_login_setup_identity(
  539.                    (unsigned char *)this_user,
  540.                    sec_login_no_flags,
  541.                    &my_dce_sec_context,
  542.                    &err) == 0)
  543.     {
  544.       dce_error_inq_text(err, dce_errstr, &err2);
  545.       DEBUG(0,("DCE Setup Identity for %s failed: %s\n",
  546.            this_user,dce_errstr));
  547.       return(False);
  548.     }
  549.  
  550.   my_dce_password.version_number = sec_passwd_c_version_none;
  551.   my_dce_password.pepper = NULL; 
  552.   my_dce_password.key.key_type = sec_passwd_plain;
  553.   my_dce_password.key.tagged_union.plain  = (idl_char *)password;
  554.   
  555.   if (sec_login_valid_and_cert_ident(my_dce_sec_context,
  556.                      &my_dce_password,
  557.                      &password_reset,
  558.                      &auth_src,
  559.                      &err) == 0 )
  560.     { 
  561.       dce_error_inq_text(err, dce_errstr, &err2);
  562.       DEBUG(0,("DCE Identity Validation failed for principal %s: %s\n",
  563.            this_user,dce_errstr));
  564.       
  565.       return(False);
  566.     }
  567.  
  568.   sec_login_set_context(my_dce_sec_context, &err);
  569.   if (err != error_status_ok )
  570.     {  
  571.       dce_error_inq_text(err, dce_errstr, &err2);
  572.       DEBUG(0,("DCE login failed for principal %s, cant set context: %s\n",
  573.            this_user,dce_errstr));
  574.       sec_login_purge_context(my_dce_sec_context, &err);
  575.       return(False);
  576.     }
  577.   else
  578.     {
  579.       DEBUG(0,("DCE login succeeded for principal %s on pid %d\n",
  580.            this_user, getpid()));
  581.     }
  582.  
  583.   dcelogin_atmost_once = 1;
  584.   return (True);
  585. }
  586.  
  587. void dfs_unlogin(void)
  588. {
  589.   error_status_t err;
  590.   int err2;
  591.   unsigned char dce_errstr[dce_c_error_string_len];
  592.  
  593.   sec_login_purge_context(my_dce_sec_context, &err);
  594.   if (err != error_status_ok )
  595.     {  
  596.       dce_error_inq_text(err, dce_errstr, &err2);
  597.       DEBUG(0,("DCE purge login context failed for server instance %d: %s\n",
  598.            getpid(), dce_errstr));
  599.     }
  600. }
  601.  
  602. #endif
  603.  
  604. #ifdef KRB5_AUTH
  605. /*******************************************************************
  606. check on Kerberos authentication
  607. ********************************************************************/
  608. static BOOL krb5_auth(char *this_user,char *password)
  609. {
  610.     krb5_data tgtname = {
  611.         0,
  612.         KRB5_TGS_NAME_SIZE,
  613.          KRB5_TGS_NAME
  614.      };
  615.     krb5_context kcontext;
  616.     krb5_principal kprinc;
  617.     krb5_principal server;
  618.     krb5_creds kcreds;
  619.     int options = 0;
  620.     krb5_address **addrs = (krb5_address **)0;
  621.     krb5_preauthtype *preauth = NULL;
  622.     krb5_keytab keytab = NULL;
  623.     krb5_timestamp now;
  624.     krb5_ccache ccache = NULL;
  625.     int retval;
  626.     char *name;
  627.  
  628.     if ( retval=krb5_init_context(&kcontext))
  629.     {
  630.         return(False);
  631.     }
  632.  
  633.     if ( retval = krb5_timeofday(kcontext, &now) )
  634.     {
  635.         return(False);
  636.     }
  637.  
  638.     if ( retval = krb5_cc_default(kcontext, &ccache) )
  639.     {
  640.         return(False);
  641.     }
  642.     
  643.     if ( retval = krb5_parse_name(kcontext, this_user, &kprinc) )
  644.     {
  645.         return(False);
  646.     }
  647.  
  648.     memset((char *)&kcreds, 0, sizeof(kcreds));
  649.  
  650.     kcreds.client = kprinc;
  651.     
  652.     if ((retval = krb5_build_principal_ext(kcontext, &server,
  653.         krb5_princ_realm(kcontext, kprinc)->length,
  654.         krb5_princ_realm(kcontext, kprinc)->data,
  655.         tgtname.length,
  656.         tgtname.data,
  657.         krb5_princ_realm(kcontext, kprinc)->length,
  658.         krb5_princ_realm(kcontext, kprinc)->data,
  659.         0)))
  660.     {
  661.          return(False);
  662.     }
  663.  
  664.     kcreds.server = server;
  665.  
  666.     retval = krb5_get_in_tkt_with_password(kcontext,
  667.         options,
  668.         addrs,
  669.         NULL,
  670.         preauth,
  671.         password,
  672.         0,
  673.         &kcreds,
  674.         0);
  675.  
  676.     if ( retval )
  677.     {
  678.         return(False);
  679.     }
  680.  
  681.     return(True);
  682. }
  683. #endif /* KRB5_AUTH */
  684.  
  685. #ifdef LINUX_BIGCRYPT
  686. /****************************************************************************
  687. an enhanced crypt for Linux to handle password longer than 8 characters
  688. ****************************************************************************/
  689. static int linux_bigcrypt(char *password,char *salt1, char *crypted)
  690. {
  691. #define LINUX_PASSWORD_SEG_CHARS 8
  692.   char salt[3];
  693.   int i;
  694.   
  695.   StrnCpy(salt,salt1,2);
  696.   crypted +=2;
  697.   
  698.   for ( i=strlen(password); i > 0; i -= LINUX_PASSWORD_SEG_CHARS) {
  699.     char * p = crypt(password,salt) + 2;
  700.     if(strncmp(p, crypted, LINUX_PASSWORD_SEG_CHARS) != 0)
  701.       return(0);
  702.     password += LINUX_PASSWORD_SEG_CHARS;
  703.     crypted  += strlen(p);
  704.   }
  705.   
  706.   return(1);
  707. }
  708. #endif
  709.  
  710.  
  711. /****************************************************************************
  712. apply a function to upper/lower case combinations
  713. of a string and return true if one of them returns true.
  714. try all combinations with N uppercase letters.
  715. offset is the first char to try and change (start with 0)
  716. it assumes the string starts lowercased
  717. ****************************************************************************/
  718. static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(),int N)
  719. {
  720.   int len = strlen(s);
  721.   int i;
  722.  
  723. #ifdef PASSWORD_LENGTH
  724.   len = MIN(len,PASSWORD_LENGTH);
  725. #endif
  726.  
  727.   if (N <= 0 || offset >= len)
  728.     return(fn(s));
  729.  
  730.   for (i=offset;i<(len-(N-1));i++)
  731.     {      
  732.       char c = s[i];
  733.       if (!islower(c)) continue;
  734.       s[i] = toupper(c);
  735.       if (string_combinations2(s,i+1,fn,N-1))
  736.     return(True);
  737.       s[i] = c;
  738.     }
  739.   return(False);
  740. }
  741.  
  742. /****************************************************************************
  743. apply a function to upper/lower case combinations
  744. of a string and return true if one of them returns true.
  745. try all combinations with up to N uppercase letters.
  746. offset is the first char to try and change (start with 0)
  747. it assumes the string starts lowercased
  748. ****************************************************************************/
  749. static BOOL string_combinations(char *s,BOOL (*fn)(),int N)
  750. {
  751.   int n;
  752.   for (n=1;n<=N;n++)
  753.     if (string_combinations2(s,0,fn,n)) return(True);
  754.   return(False);
  755. }
  756.  
  757.  
  758.  
  759. /****************************************************************************
  760. core of password checking routine
  761. ****************************************************************************/
  762. BOOL password_check(char *password)
  763. {
  764.  
  765. #ifdef USE_PAM
  766. /* This falls through if the password check fails
  767.     - if NO_CRYPT is defined this causes an error msg
  768.         saying Warning - no crypt available
  769.     - if NO_CRYPT is NOT defined this is a potential security hole
  770.         as it may authenticate via the crypt call when PAM
  771.         settings say it should fail.
  772.   if (pam_auth(this_user,password)) return(True);
  773. Hence we make a direct return to avoid a second chance!!!
  774. */
  775.   return (pam_auth(this_user,password));
  776. #endif
  777.  
  778. #ifdef AFS_AUTH
  779.   if (afs_auth(this_user,password)) return(True);
  780. #endif
  781.  
  782. #ifdef DFS_AUTH
  783.   if (dfs_auth(this_user,password)) return(True);
  784. #endif 
  785.  
  786. #ifdef KRB5_AUTH
  787.   if (krb5_auth(this_user,password)) return(True);
  788. #endif
  789.  
  790. #ifdef PWDAUTH
  791.   if (pwdauth(this_user,password) == 0)
  792.     return(True);
  793. #endif
  794.  
  795. #ifdef OSF1_ENH_SEC
  796.   return(strcmp(osf1_bigcrypt(password,this_salt),this_crypted) == 0);
  797. #endif
  798.  
  799. #ifdef ULTRIX_AUTH
  800.   return (strcmp((char *)crypt16(password, this_salt ),this_crypted) == 0);
  801. #endif
  802.  
  803. #ifdef LINUX_BIGCRYPT
  804.   return(linux_bigcrypt(password,this_salt,this_crypted));
  805. #endif
  806.  
  807. #ifdef NO_CRYPT
  808.   DEBUG(1,("Warning - no crypt available\n"));
  809.   return(False);
  810. #else
  811.   return(strcmp((char *)crypt(password,this_salt),this_crypted) == 0);
  812. #endif
  813. }
  814.  
  815. #ifdef SMB_PASSWD
  816. /****************************************************************************
  817. core of smb password checking routine.
  818. ****************************************************************************/
  819. BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
  820. {
  821.   /* Finish the encryption of part_passwd. */
  822.   unsigned char p21[21];
  823.   unsigned char p24[24];
  824.  
  825.   if(part_passwd == NULL)
  826.     DEBUG(10,("No password set - allowing access\n"));
  827.   /* No password set - always true ! */
  828.   if(part_passwd == NULL)
  829.     return 1;
  830.  
  831.   memset(p21,'\0',21);
  832.   memcpy(p21,part_passwd,16);
  833.   E_P24(p21, c8, p24);
  834. #if DEBUG_PASSWORD
  835.   {
  836.     int i;
  837.     DEBUG(100,("Part password (P16) was |"));
  838.     for(i = 0; i < 16; i++)
  839.       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
  840.     DEBUG(100,("|\n"));
  841.     DEBUG(100,("Password from client was |"));
  842.     for(i = 0; i < 24; i++)
  843.       DEBUG(100,("%X ", (unsigned char)password[i]));
  844.     DEBUG(100,("|\n"));
  845.     DEBUG(100,("Given challenge was |"));
  846.     for(i = 0; i < 8; i++)
  847.       DEBUG(100,("%X ", (unsigned char)c8[i]));
  848.     DEBUG(100,("|\n"));
  849.     DEBUG(100,("Value from encryption was |"));
  850.     for(i = 0; i < 24; i++)
  851.       DEBUG(100,("%X ", (unsigned char)p24[i]));
  852.     DEBUG(100,("|\n"));
  853.   }
  854. #endif
  855.   return (memcmp(p24, password, 24) == 0);
  856. }
  857. #endif
  858.  
  859. /****************************************************************************
  860. check if a username/password is OK
  861. ****************************************************************************/
  862. BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd)
  863. {
  864.   pstring pass2;
  865.   int level = lp_passwordlevel();
  866.   struct passwd *pass;
  867. #ifdef SMB_PASSWD
  868.   char challenge[8];
  869.   struct smb_passwd *smb_pass;
  870.   BOOL challenge_done = False;
  871. #endif
  872.  
  873.   if (password) password[pwlen] = 0;
  874.  
  875. #ifdef SMB_PASSWD
  876.   if (pwlen == 24)
  877.     challenge_done = last_challenge(challenge);
  878. #endif
  879.  
  880. #if DEBUG_PASSWORD
  881. #ifdef SMB_PASSWD
  882.   if (challenge_done)
  883.     {
  884.       int i;      
  885.       DEBUG(100,("checking user=[%s] pass=[",user));
  886.       for( i = 0; i < 24; i++)
  887.     DEBUG(100,("%0x ", (unsigned char)password[i]));
  888.       DEBUG(100,("]\n"));
  889.     }
  890.   else
  891. #endif
  892.     DEBUG(100,("checking user=[%s] pass=[%s]\n",user,password));
  893. #endif
  894.  
  895.   if (!password)
  896.     return(False);
  897.  
  898.   if (((!*password) || (!pwlen)) && !lp_null_passwords())
  899.     return(False);
  900.  
  901.   if (pwd && !user) 
  902.     {
  903.       pass = (struct passwd *) pwd;
  904.       user = pass->pw_name;
  905.     } 
  906.   else 
  907.     pass = Get_Pwnam(user,True);
  908.  
  909. #ifdef SMB_PASSWD
  910.  
  911.   DEBUG(4,("SMB Password - pwlen = %d, challenge_done = %d\n", pwlen, challenge_done));
  912.  
  913.   if((pwlen == 24) && challenge_done)
  914.     {
  915.       DEBUG(4,("Checking SMB password for user %s (l=24)\n",user));
  916.  
  917.       if (!pass) 
  918.     {
  919.       DEBUG(3,("Couldn't find user %s\n",user));
  920.       return(False);
  921.     }
  922.  
  923.       smb_pass = get_smbpwnam(user);
  924.       if(!smb_pass)
  925.     {
  926.       DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
  927.       return(False);
  928.     }
  929.  
  930.       /* Ensure the uid's match */
  931.       if(smb_pass->smb_userid != pass->pw_uid)
  932.     {
  933.       DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
  934.       return(False);
  935.     }
  936.  
  937.     if(Protocol >= PROTOCOL_NT1)
  938.     {
  939.         /* We have the NT MD4 hash challenge available - see if we can
  940.            use it (ie. does it exist in the smbpasswd file).
  941.         */
  942.         if(smb_pass->smb_nt_passwd != NULL)
  943.         {
  944.           DEBUG(4,("Checking NT MD4 password\n"));
  945.           if(smb_password_check(password, 
  946.                     smb_pass->smb_nt_passwd, 
  947.                     (unsigned char *)challenge))
  948.              {
  949.               update_protected_database(user,True);
  950.             return(True);
  951.           }
  952.           DEBUG(4,("NT MD4 password check failed\n"));
  953.         }
  954.     }
  955.  
  956.     /* Try against the lanman password */
  957.  
  958.       if (smb_password_check(password, 
  959.                  smb_pass->smb_passwd,
  960.                  (unsigned char *)challenge)) {
  961.     update_protected_database(user,True);
  962.     return(True);
  963.       }
  964.  
  965.     DEBUG(3,("Error smb_password_check failed\n"));
  966.     }
  967. #endif 
  968.  
  969.   DEBUG(4,("Checking password for user %s (l=%d)\n",user,pwlen));
  970.  
  971.   if (!pass) 
  972.     {
  973.       DEBUG(3,("Couldn't find user %s\n",user));
  974.       return(False);
  975.     }
  976.  
  977. #ifdef SHADOW_PWD
  978.   {
  979.     struct spwd *spass;
  980.  
  981.     /* many shadow systems require you to be root to get the password,
  982.        in most cases this should already be the case when this
  983.        function is called, except perhaps for IPC password changing
  984.        requests */
  985.  
  986.     spass = getspnam(pass->pw_name);
  987.     if (spass && spass->sp_pwdp)
  988.       pass->pw_passwd = spass->sp_pwdp;
  989.   }
  990. #elif defined(IA_UINFO)
  991.   {
  992.       /* Need to get password with SVR4.2's ia_ functions instead of
  993.          get{sp,pw}ent functions. Required by UnixWare 2.x, tested on 
  994.          version 2.1. (tangent@cyberport.com) */
  995.       uinfo_t uinfo;
  996.       if (ia_openinfo(pass->pw_name, &uinfo) != -1)
  997.         ia_get_logpwd(uinfo, &(pass->pw_passwd));
  998.   }
  999. #endif
  1000.  
  1001. #ifdef SecureWare
  1002.   {
  1003.     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
  1004.     if (pr_pw && pr_pw->ufld.fd_encrypt)
  1005.       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
  1006.   }
  1007. #endif
  1008.  
  1009. #ifdef HPUX_10_TRUSTED
  1010.   {
  1011.     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
  1012.     if (pr_pw && pr_pw->ufld.fd_encrypt)
  1013.       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
  1014.   }
  1015. #endif
  1016.  
  1017. #ifdef OSF1_ENH_SEC
  1018.   {
  1019.     struct pr_passwd *mypasswd;
  1020.     DEBUG(5,("Checking password for user %s in OSF1_ENH_SEC\n",user));
  1021.     mypasswd = getprpwnam (user);
  1022.     if ( mypasswd )
  1023.       { 
  1024.       strcpy(pass->pw_name,mypasswd->ufld.fd_name);
  1025.       strcpy(pass->pw_passwd,mypasswd->ufld.fd_encrypt);
  1026.       }
  1027.     else
  1028.       {
  1029.     DEBUG(5,("No entry for user %s in protected database !\n",user));
  1030.     return(False);
  1031.       }
  1032.   }
  1033. #endif
  1034.  
  1035. #ifdef ULTRIX_AUTH
  1036.   {
  1037.     AUTHORIZATION *ap = getauthuid( pass->pw_uid );
  1038.     if (ap)
  1039.       {
  1040.     strcpy( pass->pw_passwd, ap->a_password );
  1041.     endauthent();
  1042.       }
  1043.   }
  1044. #endif
  1045.  
  1046.   /* extract relevant info */
  1047.   strcpy(this_user,pass->pw_name);  
  1048.   strcpy(this_salt,pass->pw_passwd);
  1049.   strcpy(this_crypted,pass->pw_passwd);
  1050.  
  1051.   if (!*this_crypted) {
  1052.     if (!lp_null_passwords()) {
  1053.       DEBUG(2,("Disallowing access to %s due to null password\n",this_user));
  1054.       return(False);
  1055.     }
  1056. #ifndef PWDAUTH
  1057.     if (!*password) {
  1058.       DEBUG(3,("Allowing access to %s with null password\n",this_user));
  1059.       return(True);
  1060.     }
  1061. #endif    
  1062.   }
  1063.  
  1064.   /* try it as it came to us */
  1065.   if (password_check(password))
  1066.     {
  1067.       update_protected_database(user,True);
  1068.       return(True);
  1069.     }
  1070.  
  1071.   /* if the password was given to us with mixed case then we don't
  1072.      need to proceed as we know it hasn't been case modified by the
  1073.      client */
  1074.   if (strhasupper(password) && strhaslower(password))
  1075.     return(False);
  1076.  
  1077.   /* make a copy of it */
  1078.   StrnCpy(pass2,password,sizeof(pstring)-1);
  1079.   
  1080.   /* try all lowercase */
  1081.   strlower(password);
  1082.   if (password_check(password))
  1083.     {
  1084.       update_protected_database(user,True);
  1085.       return(True);
  1086.     }
  1087.  
  1088.   /* give up? */
  1089.   if(level < 1)
  1090.     {
  1091.       update_protected_database(user,False);
  1092.  
  1093.       /* restore it */
  1094.       strcpy(password,pass2);
  1095.  
  1096.       return(False);
  1097.     }
  1098.  
  1099.   /* last chance - all combinations of up to level chars upper! */
  1100.   strlower(password);
  1101.  
  1102.   if (string_combinations(password,password_check,level))
  1103.     {
  1104.       update_protected_database(user,True);
  1105.       return(True);
  1106.     }
  1107.  
  1108.   update_protected_database(user,False);
  1109.   
  1110.   /* restore it */
  1111.   strcpy(password,pass2);
  1112.   
  1113.   return(False);
  1114. }
  1115.  
  1116.  
  1117.  
  1118. /****************************************************************************
  1119. check if a username is valid
  1120. ****************************************************************************/
  1121. BOOL user_ok(char *user,int snum)
  1122. {
  1123.   pstring valid, invalid;
  1124.   BOOL ret;
  1125.  
  1126.   StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
  1127.   StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
  1128.  
  1129.   string_sub(valid,"%S",lp_servicename(snum));
  1130.   string_sub(invalid,"%S",lp_servicename(snum));
  1131.  
  1132.   ret = !user_in_list(user,invalid);
  1133.  
  1134.   if (ret && valid && *valid)
  1135.     ret = user_in_list(user,valid);
  1136.  
  1137.   if (ret && lp_onlyuser(snum)) {
  1138.     char *user_list = lp_username(snum);
  1139.     string_sub(user_list,"%S",lp_servicename(snum));
  1140.     ret = user_in_list(user,user_list);
  1141.   }
  1142.  
  1143.   return(ret);
  1144. }
  1145.  
  1146.  
  1147.  
  1148.  
  1149. /****************************************************************************
  1150. validate a group username entry. Return the username or NULL
  1151. ****************************************************************************/
  1152. static char *validate_group(char *group,char *password,int pwlen,int snum)
  1153. {
  1154. #ifdef NETGROUP
  1155.   {
  1156.     char *host, *user, *domain;
  1157.     setnetgrent(group);
  1158.     while (getnetgrent(&host, &user, &domain)) {
  1159.       if (user) {
  1160.     if (user_ok(user, snum) && 
  1161.         password_ok(user,password,pwlen,NULL)) {
  1162.       endnetgrent();
  1163.       return(user);
  1164.     }
  1165.       }
  1166.     }
  1167.     endnetgrent();
  1168.   }
  1169. #endif
  1170.   
  1171. #if HAVE_GETGRNAM 
  1172.   {
  1173.     struct group *gptr = (struct group *)getgrnam(group);
  1174.     char **member;
  1175.     if (gptr)
  1176.       {
  1177.     member = gptr->gr_mem;
  1178.     while (member && *member)
  1179.       {
  1180.         static fstring name;
  1181.         strcpy(name,*member);
  1182.         if (user_ok(name,snum) &&
  1183.         password_ok(name,password,pwlen,NULL))
  1184.           return(&name[0]);
  1185.         member++;
  1186.       }
  1187. #ifdef GROUP_CHECK_PWENT
  1188.     {
  1189.       struct passwd *pwd;
  1190.       static fstring tm;
  1191.       
  1192.       setpwent ();
  1193.       while (pwd = getpwent ()) {
  1194.         if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
  1195.           /* This Entry have PASSWORD and same GID then check pwd */
  1196.           if (password_ok(NULL, password, pwlen, pwd)) {
  1197.         strcpy(tm, pwd->pw_name);
  1198.         endpwent ();
  1199.         return tm;
  1200.           }
  1201.         }
  1202.       }
  1203.       endpwent ();
  1204.     }
  1205. #endif /* GROUP_CHECK_PWENT */
  1206.       }
  1207.   }      
  1208. #endif
  1209.   return(NULL);
  1210. }
  1211.  
  1212.  
  1213.  
  1214. /****************************************************************************
  1215. check for authority to login to a service with a given username/password
  1216. ****************************************************************************/
  1217. BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
  1218.              BOOL *guest,BOOL *force,uint16 vuid)
  1219. {
  1220.   BOOL ok = False;
  1221.   
  1222.   *guest = False;
  1223.   
  1224. #if DEBUG_PASSWORD
  1225.   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
  1226. #endif
  1227.  
  1228.   /* there are several possibilities:
  1229.      1) login as the given user with given password
  1230.      2) login as a previously registered username with the given password
  1231.      3) login as a session list username with the given password
  1232.      4) login as a previously validated user/password pair
  1233.      5) login as the "user =" user with given password
  1234.      6) login as the "user =" user with no password (guest connection)
  1235.      7) login as guest user with no password
  1236.  
  1237.      if the service is guest_only then steps 1 to 5 are skipped
  1238.   */
  1239.  
  1240.   if (GUEST_ONLY(snum)) *force = True;
  1241.  
  1242.   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
  1243.     {
  1244.  
  1245.       user_struct *vuser = get_valid_user_struct(vuid);
  1246.  
  1247.       /* check the given username and password */
  1248.       if (!ok && (*user) && user_ok(user,snum)) {
  1249.     ok = password_ok(user,password, pwlen, NULL);
  1250.     if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
  1251.       }
  1252.  
  1253.       /* check for a previously registered guest username */
  1254.       if (!ok && (vuser != 0) && vuser->guest) {      
  1255.     if (user_ok(vuser->name,snum) &&
  1256.         password_ok(vuser->name, password, pwlen, NULL)) {
  1257.       strcpy(user, vuser->name);
  1258.       vuser->guest = False;
  1259.       DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
  1260.       ok = True;
  1261.     }
  1262.       }
  1263.  
  1264.  
  1265.       /* now check the list of session users */
  1266.       if (!ok)
  1267.     {
  1268.       char *auser;
  1269.       char *user_list = strdup(session_users);
  1270.       if (!user_list) return(False);
  1271.  
  1272.       for (auser=strtok(user_list,LIST_SEP); 
  1273.            !ok && auser; 
  1274.            auser = strtok(NULL,LIST_SEP))
  1275.         {
  1276.           fstring user2;
  1277.           strcpy(user2,auser);
  1278.           if (!user_ok(user2,snum)) continue;
  1279.           
  1280.           if (password_ok(user2,password, pwlen, NULL)) {
  1281.         ok = True;
  1282.         strcpy(user,user2);
  1283.         DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
  1284.           }
  1285.         }
  1286.       free(user_list);
  1287.     }
  1288.  
  1289.       /* check for a previously validated username/password pair */
  1290.       if (!ok && !lp_revalidate(snum) &&
  1291.       (vuser != 0) && !vuser->guest &&
  1292.       user_ok(vuser->name,snum)) {
  1293.     strcpy(user,vuser->name);
  1294.     *guest = False;
  1295.     DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
  1296.     ok = True;
  1297.       }
  1298.  
  1299.       /* check for a rhosts entry */
  1300.       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
  1301.     ok = True;
  1302.     DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
  1303.       }
  1304.  
  1305.       /* check the user= fields and the given password */
  1306.       if (!ok && lp_username(snum)) {
  1307.     char *auser;
  1308.     pstring user_list;
  1309.     StrnCpy(user_list,lp_username(snum),sizeof(pstring));
  1310.  
  1311.     string_sub(user_list,"%S",lp_servicename(snum));
  1312.       
  1313.     for (auser=strtok(user_list,LIST_SEP);
  1314.          auser && !ok;
  1315.          auser = strtok(NULL,LIST_SEP))
  1316.       {
  1317.         if (*auser == '@')
  1318.           {
  1319.         auser = validate_group(auser+1,password,pwlen,snum);
  1320.         if (auser)
  1321.           {
  1322.             ok = True;
  1323.             strcpy(user,auser);
  1324.             DEBUG(3,("ACCEPTED: group username and given password ok\n"));
  1325.           }
  1326.           }
  1327.         else
  1328.           {
  1329.         fstring user2;
  1330.         strcpy(user2,auser);
  1331.         if (user_ok(user2,snum) && 
  1332.             password_ok(user2,password,pwlen,NULL))
  1333.           {
  1334.             ok = True;
  1335.             strcpy(user,user2);
  1336.             DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
  1337.           }
  1338.           }
  1339.       }
  1340.       }      
  1341.     } /* not guest only */
  1342.  
  1343.   /* check for a normal guest connection */
  1344.   if (!ok && GUEST_OK(snum))
  1345.     {
  1346.       fstring guestname;
  1347.       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
  1348.       if (Get_Pwnam(guestname,True))
  1349.     {
  1350.       strcpy(user,guestname);
  1351.       ok = True;
  1352.       DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
  1353.     }
  1354.       else
  1355.     DEBUG(0,("Invalid guest account %s??\n",guestname));
  1356.       *guest = True;
  1357.       *force = True;
  1358.     }
  1359.  
  1360.   if (ok && !user_ok(user,snum))
  1361.     {
  1362.       DEBUG(0,("rejected invalid user %s\n",user));
  1363.       ok = False;
  1364.     }
  1365.  
  1366.   return(ok);
  1367. }
  1368.  
  1369.  
  1370. /****************************************************************************
  1371. read the a hosts.equiv or .rhosts file and check if it
  1372. allows this user from this machine
  1373. ****************************************************************************/
  1374. static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
  1375. {
  1376.   pstring buf;
  1377.   int plus_allowed = 1;
  1378.   char *file_host;
  1379.   char *file_user;
  1380.   FILE *fp = fopen(equiv_file, "r");
  1381.   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
  1382.   if (! fp) return False;
  1383.   while(fgets(buf, sizeof(buf), fp)) 
  1384.   {
  1385.     trim_string(buf," "," ");
  1386.  
  1387.     if (buf[0] != '#' && buf[0] != '\n') 
  1388.     {
  1389.       BOOL is_group = False;
  1390.       int plus = 1;
  1391.       char *bp = buf;
  1392.       if (strcmp(buf, "NO_PLUS\n") == 0)
  1393.       {
  1394.     DEBUG(6, ("check_user_equiv NO_PLUS\n"));
  1395.     plus_allowed = 0;
  1396.       }
  1397.       else {
  1398.     if (buf[0] == '+') 
  1399.     {
  1400.       bp++;
  1401.       if (*bp == '\n' && plus_allowed) 
  1402.       {
  1403.         /* a bare plus means everbody allowed */
  1404.         DEBUG(6, ("check_user_equiv everybody allowed\n"));
  1405.         fclose(fp);
  1406.         return True;
  1407.       }
  1408.     }
  1409.     else if (buf[0] == '-')
  1410.     {
  1411.       bp++;
  1412.       plus = 0;
  1413.     }
  1414.     if (*bp == '@') 
  1415.     {
  1416.       is_group = True;
  1417.       bp++;
  1418.     }
  1419.     file_host = strtok(bp, " \t\n");
  1420.     file_user = strtok(NULL, " \t\n");
  1421.     DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)", 
  1422.                  file_user ? file_user : "(null)" ));
  1423.     if (file_host && *file_host) 
  1424.     {
  1425.       BOOL host_ok = False;
  1426.  
  1427. #ifdef NETGROUP      
  1428.       if (is_group)
  1429.         {
  1430.           static char *mydomain = NULL;
  1431.           if (!mydomain)
  1432.         yp_get_default_domain(&mydomain);
  1433.           if (mydomain && innetgr(file_host,remote,user,mydomain))
  1434.         host_ok = True;
  1435.         }
  1436. #else
  1437.       if (is_group)
  1438.         {
  1439.           DEBUG(1,("Netgroups not configured - add -DNETGROUP and recompile\n"));
  1440.           continue;
  1441.         }
  1442. #endif
  1443.  
  1444.       /* is it this host */
  1445.       /* the fact that remote has come from a call of gethostbyaddr
  1446.        * means that it may have the fully qualified domain name
  1447.        * so we could look up the file version to get it into
  1448.        * a canonical form, but I would rather just type it
  1449.        * in full in the equiv file
  1450.        */
  1451.       if (!host_ok && !is_group && strequal(remote, file_host))
  1452.         host_ok = True;
  1453.  
  1454.       if (!host_ok)
  1455.         continue;
  1456.  
  1457.       /* is it this user */
  1458.       if (file_user == 0 || strequal(user, file_user)) 
  1459.         {
  1460.           fclose(fp);
  1461.           DEBUG(5, ("check_user_equiv matched %s%s %s\n",
  1462.             (plus ? "+" : "-"), file_host,
  1463.             (file_user ? file_user : "")));
  1464.           return (plus ? True : False);
  1465.         }
  1466.     }
  1467.       }
  1468.     }
  1469.   }
  1470.   fclose(fp);
  1471.   return False;
  1472. }
  1473.  
  1474.  
  1475. /****************************************************************************
  1476. check for a possible hosts equiv or rhosts entry for the user
  1477. ****************************************************************************/
  1478. BOOL check_hosts_equiv(char *user)
  1479. {
  1480.   char *fname = NULL;
  1481.   pstring rhostsfile;
  1482.   struct passwd *pass = Get_Pwnam(user,True);
  1483.  
  1484.   if (!pass) 
  1485.     return(False);
  1486.  
  1487.   fname = lp_hosts_equiv();
  1488.  
  1489.   /* note: don't allow hosts.equiv on root */
  1490.   if (fname && *fname && (pass->pw_uid != 0))
  1491.     {
  1492.       if (check_user_equiv(user,client_name(),fname))
  1493.     return(True);
  1494.     }
  1495.   
  1496.   if (lp_use_rhosts())
  1497.     {
  1498.       char *home = get_home_dir(user);
  1499.       if (home)
  1500.     {
  1501.       sprintf(rhostsfile, "%s/.rhosts", home);
  1502.       if (check_user_equiv(user,client_name(),rhostsfile))
  1503.         return(True);
  1504.     }
  1505.     }
  1506.  
  1507.   return(False);
  1508. }
  1509.  
  1510.  
  1511. int password_client = -1;
  1512. static fstring pserver;
  1513.  
  1514. /****************************************************************************
  1515. attempted support for server level security 
  1516. ****************************************************************************/
  1517. BOOL server_cryptkey(char *buf)
  1518. {
  1519.   pstring inbuf,outbuf;
  1520.   fstring pass_protocol;
  1521.   extern fstring remote_machine;
  1522.   char *p;
  1523.   int len;
  1524.   fstring desthost;
  1525.   struct in_addr dest_ip;
  1526.   int port = SMB_PORT;
  1527.   BOOL ret;
  1528.  
  1529.   if (password_client >= 0)
  1530.     close(password_client);
  1531.   password_client = -1;
  1532.  
  1533.   if (Protocol < PROTOCOL_NT1) {
  1534.     strcpy(pass_protocol,"LM1.2X002");
  1535.   } else {
  1536.     strcpy(pass_protocol,"NT LM 0.12");
  1537.   }
  1538.  
  1539.   bzero(inbuf,sizeof(inbuf));
  1540.   bzero(outbuf,sizeof(outbuf));
  1541.  
  1542.   for (p=strtok(lp_passwordserver(),LIST_SEP); p ; p = strtok(NULL,LIST_SEP)) {
  1543.     strcpy(desthost,p);
  1544.     standard_sub_basic(desthost);
  1545.     strupper(desthost);
  1546.  
  1547.     dest_ip = *interpret_addr2(desthost);
  1548.     if (zero_ip(dest_ip)) {
  1549.       DEBUG(1,("Can't resolve address for %s\n",p));
  1550.       continue;
  1551.     }
  1552.  
  1553.     if (ismyip(dest_ip)) {
  1554.       DEBUG(1,("Password server loop - disabling password server %s\n",p));
  1555.       continue;
  1556.     }
  1557.  
  1558.     password_client = open_socket_out(SOCK_STREAM, &dest_ip, port, SHORT_CONNECT_TIMEOUT);
  1559.     if (password_client >= 0) {
  1560.       DEBUG(3,("connected to password server %s\n",p));
  1561.       StrnCpy(pserver,p,sizeof(pserver)-1);
  1562.       break;
  1563.     }
  1564.   }
  1565.  
  1566.   if (password_client < 0) {
  1567.     DEBUG(1,("password server not available\n"));
  1568.     return(False);
  1569.   }
  1570.  
  1571.  
  1572.   /* send a session request (RFC 8002) */
  1573.  
  1574.   /* put in the destination name */
  1575.   len = 4;
  1576.   p = outbuf+len;
  1577.   name_mangle(desthost,p,' ');
  1578.   len += name_len(p);
  1579.  
  1580.   /* and my name */
  1581.   p = outbuf+len;
  1582.   name_mangle(remote_machine,p,' ');
  1583.   len += name_len(p);
  1584.  
  1585.   _smb_setlen(outbuf,len);
  1586.   CVAL(outbuf,0) = 0x81;
  1587.  
  1588.   send_smb(password_client,outbuf);
  1589.   
  1590.  
  1591.   if (!receive_smb(password_client,inbuf,5000) ||
  1592.       CVAL(inbuf,0) != 0x82) {
  1593.     DEBUG(1,("%s rejected the session\n",pserver));
  1594.     close(password_client); password_client = -1;
  1595.     return(False);
  1596.   }
  1597.  
  1598.   DEBUG(3,("got session\n"));
  1599.  
  1600.   bzero(outbuf,smb_size);
  1601.  
  1602.   /* setup the protocol string */
  1603.   set_message(outbuf,0,strlen(pass_protocol)+2,True);
  1604.   p = smb_buf(outbuf);
  1605.   *p++ = 2;
  1606.   strcpy(p,pass_protocol);
  1607.  
  1608.   CVAL(outbuf,smb_com) = SMBnegprot;
  1609.   CVAL(outbuf,smb_flg) = 0x8;
  1610.   SSVAL(outbuf,smb_flg2,0x1);
  1611.  
  1612.   send_smb(password_client,outbuf);
  1613.   ret = receive_smb(password_client,inbuf,5000);
  1614.  
  1615.   if (!ret || CVAL(inbuf,smb_rcls) || SVAL(inbuf,smb_vwv0)) {
  1616.     DEBUG(1,("%s rejected the protocol\n",pserver));
  1617.     close(password_client); password_client= -1;
  1618.     return(False);
  1619.   }
  1620.  
  1621.   if (!(CVAL(inbuf,smb_vwv1) & 1)) {
  1622.     DEBUG(1,("%s isn't in user level security mode\n",pserver));
  1623.     close(password_client); password_client= -1;
  1624.     return(False);
  1625.   }
  1626.  
  1627.   memcpy(buf,inbuf,smb_len(inbuf)+4);
  1628.  
  1629.   DEBUG(3,("password server OK\n"));
  1630.  
  1631.   return(True);
  1632. }
  1633.  
  1634. /****************************************************************************
  1635. attempted support for server level security 
  1636. ****************************************************************************/
  1637. BOOL server_validate(char *buf)
  1638. {
  1639.   pstring inbuf,outbuf;  
  1640.   BOOL ret;
  1641.  
  1642.   if (password_client < 0) {
  1643.     DEBUG(1,("%s not connected\n",pserver));
  1644.     return(False);
  1645.   }  
  1646.  
  1647.   bzero(inbuf,sizeof(inbuf));
  1648.   memcpy(outbuf,buf,sizeof(outbuf));
  1649.  
  1650.   /* send a session setup command */
  1651.   CVAL(outbuf,smb_flg) = 0x8;
  1652.   SSVAL(outbuf,smb_flg2,0x1);
  1653.   CVAL(outbuf,smb_vwv0) = 0xFF;
  1654.  
  1655.   set_message(outbuf,smb_numwords(outbuf),smb_buflen(outbuf),False);
  1656.  
  1657.   SCVAL(inbuf,smb_rcls,1);
  1658.  
  1659.   send_smb(password_client,outbuf);
  1660.   ret = receive_smb(password_client,inbuf,5000);
  1661.  
  1662.   if (!ret || CVAL(inbuf,smb_rcls) != 0) {
  1663.     DEBUG(1,("password server %s rejected the password\n",pserver));
  1664.     return(False);
  1665.   }
  1666.  
  1667.   /* if logged in as guest then reject */
  1668.   if ((SVAL(inbuf,smb_vwv2) & 1) != 0) {
  1669.     DEBUG(1,("password server %s gave us guest only\n",pserver));
  1670.     return(False);
  1671.   }
  1672.  
  1673.   DEBUG(3,("password server %s accepted the password\n",pserver));
  1674.  
  1675. #if !KEEP_PASSWORD_SERVER_OPEN
  1676.   close(password_client); password_client= -1;
  1677. #endif
  1678.  
  1679.   return(True);
  1680. }
  1681.  
  1682.  
  1683.