password.c: Fixes to allow Win95 clients to have lm encrypted passwords
[samba.git] / source3 / smbd / password.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    Password and authentication handling
5    Copyright (C) Andrew Tridgell 1992-1998
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 BOOL global_machine_pasword_needs_changing;
32
33 /* users from session setup */
34 static pstring session_users="";
35
36 extern pstring global_myname;
37 extern fstring global_myworkgroup;
38
39 /* these are kept here to keep the string_combinations function simple */
40 static char this_user[100]="";
41 static char this_salt[100]="";
42 static char this_crypted[100]="";
43
44 /* Data to do lanman1/2 password challenge. */
45 static unsigned char saved_challenge[8];
46 static BOOL challenge_sent=False;
47
48 /*******************************************************************
49 Get the next challenge value - no repeats.
50 ********************************************************************/
51 void generate_next_challenge(char *challenge)
52 {
53 #if 0
54         /* 
55          * Leave this ifdef'd out while we test
56          * the new crypto random number generator.
57          * JRA.
58          */
59         unsigned char buf[16];
60         static int counter = 0;
61         struct timeval tval;
62         int v1,v2;
63
64         /* get a sort-of random number */
65         GetTimeOfDay(&tval);
66         v1 = (counter++) + getpid() + tval.tv_sec;
67         v2 = (counter++) * getpid() + tval.tv_usec;
68         SIVAL(challenge,0,v1);
69         SIVAL(challenge,4,v2);
70
71         /* mash it up with md4 */
72         mdfour(buf, (unsigned char *)challenge, 8);
73 #else
74         unsigned char buf[8];
75
76         generate_random_buffer(buf,8,False);
77 #endif 
78         memcpy(saved_challenge, buf, 8);
79         memcpy(challenge,buf,8);
80         challenge_sent = True;
81 }
82
83 /*******************************************************************
84 set the last challenge sent, usually from a password server
85 ********************************************************************/
86 BOOL set_challenge(char *challenge)
87 {
88   memcpy(saved_challenge,challenge,8);
89   challenge_sent = True;
90   return(True);
91 }
92
93 /*******************************************************************
94 get the last challenge sent
95 ********************************************************************/
96 BOOL last_challenge(unsigned char *challenge)
97 {
98   if (!challenge_sent) return(False);
99   memcpy(challenge,saved_challenge,8);
100   return(True);
101 }
102
103 /* this holds info on user ids that are already validated for this VC */
104 static user_struct *validated_users = NULL;
105 static int num_validated_users = 0;
106
107 /****************************************************************************
108 check if a uid has been validated, and return an pointer to the user_struct
109 if it has. NULL if not. vuid is biased by an offset. This allows us to
110 tell random client vuid's (normally zero) from valid vuids.
111 ****************************************************************************/
112 user_struct *get_valid_user_struct(uint16 vuid)
113 {
114   if (vuid == UID_FIELD_INVALID)
115     return NULL;
116   vuid -= VUID_OFFSET;
117   if ((vuid >= (uint16)num_validated_users) || 
118      (validated_users[vuid].uid == -1) || (validated_users[vuid].gid == -1))
119     return NULL;
120   return &validated_users[vuid];
121 }
122
123 /****************************************************************************
124 invalidate a uid
125 ****************************************************************************/
126 void invalidate_vuid(uint16 vuid)
127 {
128   user_struct *vuser = get_valid_user_struct(vuid);
129
130   if (vuser == NULL) return;
131
132   vuser->uid = -1;
133   vuser->gid = -1;
134
135   vuser->n_sids = 0;
136
137   /* same number of igroups as groups as attrs */
138   vuser->n_groups = 0;
139
140   if (vuser->groups && (vuser->groups != (gid_t *)vuser->igroups))
141        free(vuser->groups);
142
143   if (vuser->igroups) free(vuser->igroups);
144   if (vuser->attrs  ) free(vuser->attrs);
145   if (vuser->sids   ) free(vuser->sids);
146
147   vuser->attrs   = NULL;
148   vuser->sids    = NULL;
149   vuser->igroups = NULL;
150   vuser->groups  = NULL;
151 }
152
153
154 /****************************************************************************
155 return a validated username
156 ****************************************************************************/
157 char *validated_username(uint16 vuid)
158 {
159   user_struct *vuser = get_valid_user_struct(vuid);
160   if (vuser == NULL)
161     return 0;
162   return(vuser->name);
163 }
164
165
166 /****************************************************************************
167 Setup the groups a user belongs to.
168 ****************************************************************************/
169 int setup_groups(char *user, int uid, int gid, int *p_ngroups, 
170                  int **p_igroups, gid_t **p_groups,
171          int **p_attrs)
172 {
173   if (-1 == initgroups(user,gid))
174     {
175       if (getuid() == 0)
176         {
177           DEBUG(0,("Unable to initgroups!\n"));
178           if (gid < 0 || gid > 16000 || uid < 0 || uid > 16000)
179             DEBUG(0,("This is probably a problem with the account %s\n",user));
180         }
181     }
182   else
183     {
184       int i,ngroups;
185       int *igroups;
186       int *attrs;
187       gid_t grp = 0;
188       ngroups = getgroups(0,&grp);
189       if (ngroups <= 0)
190         ngroups = 32;
191       igroups = (int *)malloc(sizeof(int)*ngroups);
192       attrs   = (int *)malloc(sizeof(int)*ngroups);
193       for (i=0;i<ngroups;i++)
194       {
195         attrs  [i] = 0x7; /* XXXX don't know what NT user attributes are yet! */
196         igroups[i] = 0x42424242;
197       }
198       ngroups = getgroups(ngroups,(gid_t *)igroups);
199
200       if (igroups[0] == 0x42424242)
201         ngroups = 0;
202
203       *p_ngroups = ngroups;
204       *p_attrs   = attrs;
205
206       /* The following bit of code is very strange. It is due to the
207          fact that some OSes use int* and some use gid_t* for
208          getgroups, and some (like SunOS) use both, one in prototypes,
209          and one in man pages and the actual code. Thus we detect it
210          dynamically using some very ugly code */
211       if (ngroups > 0)
212         {
213           /* does getgroups return ints or gid_t ?? */
214           static BOOL groups_use_ints = True;
215
216           if (groups_use_ints && 
217               ngroups == 1 && 
218               SVAL(igroups,2) == 0x4242)
219             groups_use_ints = False;
220           
221           for (i=0;groups_use_ints && i<ngroups;i++)
222             if (igroups[i] == 0x42424242)
223               groups_use_ints = False;
224               
225           if (groups_use_ints)
226           {
227               *p_igroups = igroups;
228               *p_groups = (gid_t *)igroups;       
229           }
230           else
231           {
232               gid_t *groups = (gid_t *)igroups;
233               igroups = (int *)malloc(sizeof(int)*ngroups);
234               for (i=0;i<ngroups;i++)
235           {
236                 igroups[i] = groups[i];
237           }
238               *p_igroups = igroups;
239               *p_groups = (gid_t *)groups;
240             }
241         }
242       DEBUG(3,("%s is in %d groups\n",user,ngroups));
243       for (i=0;i<ngroups;i++)
244         DEBUG(3,("%d ",igroups[i]));
245       DEBUG(3,("\n"));
246     }
247   return 0;
248 }
249
250
251 /****************************************************************************
252 register a uid/name pair as being valid and that a valid password
253 has been given. vuid is biased by an offset. This allows us to
254 tell random client vuid's (normally zero) from valid vuids.
255 ****************************************************************************/
256 uint16 register_vuid(int uid,int gid, char *unix_name, char *requested_name, BOOL guest)
257 {
258   user_struct *vuser;
259   struct passwd *pwfile; /* for getting real name from passwd file */
260
261   /* Ensure no vuid gets registered in share level security. */
262   if(lp_security() == SEC_SHARE)
263     return UID_FIELD_INVALID;
264
265 #if 0
266   /*
267    * After observing MS-Exchange services writing to a Samba share
268    * I belive this code is incorrect. Each service does its own
269    * sessionsetup_and_X for the same user, and as each service shuts
270    * down, it does a user_logoff_and_X. As we are consolidating multiple
271    * sessionsetup_and_X's onto the same vuid here, when the first service
272    * shuts down, it invalidates all the open files for the other services.
273    * Hence I am removing this code and forcing each sessionsetup_and_X
274    * to get a new vuid.
275    * Jeremy Allison. (jallison@whistle.com).
276    */
277
278   int i;
279   for(i = 0; i < num_validated_users; i++) {
280     vuser = &validated_users[i];
281     if ( vuser->uid == uid )
282       return (uint16)(i + VUID_OFFSET); /* User already validated */
283   }
284 #endif
285
286   validated_users = (user_struct *)Realloc(validated_users,
287                            sizeof(user_struct)*
288                            (num_validated_users+1));
289   
290   if (!validated_users)
291     {
292       DEBUG(0,("Failed to realloc users struct!\n"));
293       num_validated_users = 0;
294       return UID_FIELD_INVALID;
295     }
296
297   vuser = &validated_users[num_validated_users];
298   num_validated_users++;
299
300   vuser->uid = uid;
301   vuser->gid = gid;
302   vuser->guest = guest;
303   fstrcpy(vuser->name,unix_name);
304   fstrcpy(vuser->requested_name,requested_name);
305
306   vuser->n_sids = 0;
307   vuser->sids   = NULL;
308
309   vuser->n_groups = 0;
310   vuser->groups  = NULL;
311   vuser->igroups = NULL;
312   vuser->attrs    = NULL;
313
314   /* Find all the groups this uid is in and store them. 
315      Used by become_user() */
316   setup_groups(unix_name,uid,gid,
317                &vuser->n_groups,
318                &vuser->igroups,
319                &vuser->groups,
320                &vuser->attrs);
321
322   DEBUG(3,("uid %d registered to name %s\n",uid,unix_name));
323
324   DEBUG(3, ("Clearing default real name\n"));
325   fstrcpy(vuser->real_name, "<Full Name>\0");
326   if (lp_unix_realname()) {
327     if ((pwfile=getpwnam(vuser->name))!= NULL)
328       {
329       DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->name,pwfile->pw_gecos));
330       fstrcpy(vuser->real_name, pwfile->pw_gecos);
331       }
332   }
333
334   return (uint16)((num_validated_users - 1) + VUID_OFFSET);
335 }
336
337
338 /****************************************************************************
339 add a name to the session users list
340 ****************************************************************************/
341 void add_session_user(char *user)
342 {
343   fstring suser;
344   StrnCpy(suser,user,sizeof(suser)-1);
345
346   if (!Get_Pwnam(suser,True)) return;
347
348   if (suser && *suser && !in_list(suser,session_users,False))
349     {
350       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
351         DEBUG(1,("Too many session users??\n"));
352       else
353         {
354           pstrcat(session_users," ");
355           pstrcat(session_users,suser);
356         }
357     }
358 }
359
360
361 #ifdef NO_GETSPNAM
362 /* a fake shadow password routine which just fills a fake spwd struct
363  * with the sp_pwdp field. (sreiz@aie.nl)
364  */
365 static struct spwd *getspnam(char *username) /* fake shadow password routine */
366 {
367        FILE *f;
368        char line[1024];
369        static fstring pw;
370        static struct spwd static_spwd;
371
372        static_spwd.sp_pwdp=0;
373        if (!(f=fopen("/etc/master.passwd", "r")))
374                return 0;
375        while (fgets(line, 1024, f)) {
376                if (!strncmp(line, username, strlen(username)) &&
377                 line[strlen(username)]==':') { /* found entry */
378                        char *p, *q;
379
380                        p=line+strlen(username)+1;
381                        if ((q=strchr(p, ':'))) {
382                                *q=0;
383                                if (q-p+1>20)
384                                        break;
385                                fstrcpy(pw, p);
386                                static_spwd.sp_pwdp=pw;
387                        }
388                        break;
389                }
390        }
391        fclose(f);
392        if (static_spwd.sp_pwdp)
393                return &static_spwd;
394        return 0;
395 }
396 #endif
397
398
399 #ifdef OSF1_ENH_SEC
400 /****************************************************************************
401 an enhanced crypt for OSF1
402 ****************************************************************************/
403 static char *osf1_bigcrypt(char *password,char *salt1)
404 {
405   static char result[AUTH_MAX_PASSWD_LENGTH] = "";
406   char *p1;
407   char *p2=password;
408   char salt[3];
409   int i;
410   int parts = strlen(password) / AUTH_CLEARTEXT_SEG_CHARS;
411   if (strlen(password)%AUTH_CLEARTEXT_SEG_CHARS)
412     parts++;
413
414   StrnCpy(salt,salt1,2);
415   StrnCpy(result,salt1,2);
416
417   for (i=0; i<parts;i++)
418     {
419       p1 = crypt(p2,salt);
420       strncat(result,p1+2,AUTH_MAX_PASSWD_LENGTH-strlen(p1+2)-1);
421       StrnCpy(salt,&result[2+i*AUTH_CIPHERTEXT_SEG_CHARS],2);
422       p2 += AUTH_CLEARTEXT_SEG_CHARS;
423     }
424
425   return(result);
426 }
427 #endif
428
429 /****************************************************************************
430 update the encrypted smbpasswd file from the plaintext username and password
431 *****************************************************************************/
432 BOOL update_smbpassword_file( char *user, fstring password)
433 {
434   struct smb_passwd *smbpw;
435   BOOL ret;
436
437   become_root(0);
438   smbpw = getsmbpwnam(user);
439   unbecome_root(0);
440
441   if(smbpw == NULL)
442   {
443     DEBUG(0,("update_smbpassword_file: getsmbpwnam returned NULL\n"));
444     return False;
445   }
446  
447   /* Here, the flag is one, because we want to ignore the XXXXXXX'd out password */
448   ret = change_oem_password( smbpw, password, True);
449   if (ret == False)
450     DEBUG(3,("update_smbpasswd_file: change_oem_password returned False\n"));
451
452   return ret;
453 }
454
455 /****************************************************************************
456 update the enhanced security database. Only relevant for OSF1 at the moment.
457 ****************************************************************************/
458 static void update_protected_database( char *user, BOOL result)
459 {
460 #ifdef OSF1_ENH_SEC
461   struct pr_passwd *mypasswd;
462   time_t starttime;
463
464   mypasswd = getprpwnam (user);
465   starttime = time (NULL);
466
467   if (result)
468     {
469       mypasswd->ufld.fd_slogin = starttime;
470       mypasswd->ufld.fd_nlogins = 0;
471       
472       putprpwnam(user,mypasswd);
473       
474       DEBUG(3,("Update protected database for Account %s after succesful connection\n",user));
475     }
476   else
477     {
478       mypasswd->ufld.fd_ulogin = starttime;
479       mypasswd->ufld.fd_nlogins = mypasswd->ufld.fd_nlogins + 1;
480       if ( mypasswd->ufld.fd_max_tries != 0 && mypasswd->ufld.fd_nlogins > mypasswd->ufld.fd_max_tries )
481         {
482           mypasswd->uflg.fg_lock = 0;
483           DEBUG(3,("Account is disabled -- see Account Administrator.\n"));
484         }
485       putprpwnam ( user , mypasswd );
486       DEBUG(3,("Update protected database for Account %s after refusing connection\n",user));
487     }
488 #else
489   DEBUG(6,("Updated database with %s %s\n",user,BOOLSTR(result)));
490 #endif
491 }
492
493
494 #ifdef USE_PAM
495 /*******************************************************************
496 check on PAM authentication
497 ********************************************************************/
498
499 /* We first need some helper functions */
500 #include <security/pam_appl.h>
501 /* Static variables used to communicate between the conversation function
502  * and the server_login function
503  */
504 static char *PAM_username;
505 static char *PAM_password;
506
507 /* PAM conversation function
508  * Here we assume (for now, at least) that echo on means login name, and
509  * echo off means password.
510  */
511 static int PAM_conv (int num_msg,
512                      const struct pam_message **msg,
513                      struct pam_response **resp,
514                      void *appdata_ptr) {
515   int replies = 0;
516   struct pam_response *reply = NULL;
517
518   #define COPY_STRING(s) (s) ? strdup(s) : NULL
519
520   reply = malloc(sizeof(struct pam_response) * num_msg);
521   if (!reply) return PAM_CONV_ERR;
522
523   for (replies = 0; replies < num_msg; replies++) {
524     switch (msg[replies]->msg_style) {
525       case PAM_PROMPT_ECHO_ON:
526         reply[replies].resp_retcode = PAM_SUCCESS;
527         reply[replies].resp = COPY_STRING(PAM_username);
528           /* PAM frees resp */
529         break;
530       case PAM_PROMPT_ECHO_OFF:
531         reply[replies].resp_retcode = PAM_SUCCESS;
532         reply[replies].resp = COPY_STRING(PAM_password);
533           /* PAM frees resp */
534         break;
535       case PAM_TEXT_INFO:
536         /* fall through */
537       case PAM_ERROR_MSG:
538         /* ignore it... */
539         reply[replies].resp_retcode = PAM_SUCCESS;
540         reply[replies].resp = NULL;
541         break;
542       default:
543         /* Must be an error of some sort... */
544         free (reply);
545         return PAM_CONV_ERR;
546     }
547   }
548   if (reply) *resp = reply;
549   return PAM_SUCCESS;
550 }
551 static struct pam_conv PAM_conversation = {
552     &PAM_conv,
553     NULL
554 };
555
556
557 static BOOL pam_auth(char *this_user,char *password)
558 {
559   pam_handle_t *pamh;
560   int pam_error;
561
562   /* Now use PAM to do authentication.  For now, we won't worry about
563    * session logging, only authentication.  Bail out if there are any
564    * errors.  Since this is a limited protocol, and an even more limited
565    * function within a server speaking this protocol, we can't be as
566    * verbose as would otherwise make sense.
567    * Query: should we be using PAM_SILENT to shut PAM up?
568    */
569   #define PAM_BAIL if (pam_error != PAM_SUCCESS) { \
570      pam_end(pamh, 0); return False; \
571    }
572   PAM_password = password;
573   PAM_username = this_user;
574   pam_error = pam_start("samba", this_user, &PAM_conversation, &pamh);
575   PAM_BAIL;
576 /* Setting PAM_SILENT stops generation of error messages to syslog
577  * to enable debugging on Red Hat Linux set:
578  * /etc/pam.d/samba:
579  *      auth required /lib/security/pam_pwdb.so nullok shadow audit
580  * _OR_ change PAM_SILENT to 0 to force detailed reporting (logging)
581  */
582   pam_error = pam_authenticate(pamh, PAM_SILENT);
583   PAM_BAIL;
584   /* It is not clear to me that account management is the right thing
585    * to do, but it is not clear that it isn't, either.  This can be
586    * removed if no account management should be done.  Alternately,
587    * put a pam_allow.so entry in /etc/pam.conf for account handling. */
588   pam_error = pam_acct_mgmt(pamh, PAM_SILENT);
589   PAM_BAIL;
590   pam_end(pamh, PAM_SUCCESS);
591   /* If this point is reached, the user has been authenticated. */
592   return(True);
593 }
594 #endif
595
596
597 #ifdef AFS_AUTH
598 /*******************************************************************
599 check on AFS authentication
600 ********************************************************************/
601 static BOOL afs_auth(char *this_user,char *password)
602 {
603   long password_expires = 0;
604   char *reason;
605     
606   /* For versions of AFS prior to 3.3, this routine has few arguments, */
607   /* but since I can't find the old documentation... :-)               */
608   setpag();
609   if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION+KA_USERAUTH_DOSETPAG,
610                                  this_user,
611                                  (char *) 0, /* instance */
612                                  (char *) 0, /* cell */
613                                  password,
614                                  0,          /* lifetime, default */
615                                  &password_expires, /*days 'til it expires */
616                                  0,          /* spare 2 */
617                                  &reason) == 0)
618     return(True);
619   return(False);
620 }
621 #endif
622
623
624 #ifdef DFS_AUTH
625
626 sec_login_handle_t my_dce_sec_context;
627 int dcelogin_atmost_once = 0;
628
629 /*******************************************************************
630 check on a DCE/DFS authentication
631 ********************************************************************/
632 static BOOL dfs_auth(char *this_user,char *password)
633 {
634   error_status_t err;
635   int err2;
636   int prterr;
637   boolean32 password_reset;
638   sec_passwd_rec_t my_dce_password;
639   sec_login_auth_src_t auth_src = sec_login_auth_src_network;
640   unsigned char dce_errstr[dce_c_error_string_len];
641
642   /*
643    * We only go for a DCE login context if the given password
644    * matches that stored in the local password file.. 
645    * Assumes local passwd file is kept in sync w/ DCE RGY!
646    */
647
648   /* Fix for original (broken) code from Brett Wooldridge <brettw@austin.ibm.com> */
649   if (dcelogin_atmost_once)
650     return (False);
651   /* This can be ifdefed as the DCE check below is stricter... */
652 #ifndef NO_CRYPT
653   if ( strcmp((char *)crypt(password,this_salt),this_crypted) )
654     return (False);
655 #endif
656
657   if (sec_login_setup_identity(
658                                (unsigned char *)this_user,
659                                sec_login_no_flags,
660                                &my_dce_sec_context,
661                                &err) == 0)
662     {
663       dce_error_inq_text(err, dce_errstr, &err2);
664       DEBUG(0,("DCE Setup Identity for %s failed: %s\n",
665                this_user,dce_errstr));
666       return(False);
667     }
668
669   my_dce_password.version_number = sec_passwd_c_version_none;
670   my_dce_password.pepper = NULL; 
671   my_dce_password.key.key_type = sec_passwd_plain;
672   my_dce_password.key.tagged_union.plain  = (idl_char *)password;
673   
674   if (sec_login_valid_and_cert_ident(my_dce_sec_context,
675                                      &my_dce_password,
676                                      &password_reset,
677                                      &auth_src,
678                                      &err) == 0 )
679     { 
680       dce_error_inq_text(err, dce_errstr, &err2);
681       DEBUG(0,("DCE Identity Validation failed for principal %s: %s\n",
682                this_user,dce_errstr));
683           
684       return(False);
685     }
686
687   sec_login_set_context(my_dce_sec_context, &err);
688   if (err != error_status_ok )
689     {  
690       dce_error_inq_text(err, dce_errstr, &err2);
691       DEBUG(0,("DCE login failed for principal %s, cant set context: %s\n",
692                this_user,dce_errstr));
693       sec_login_purge_context(my_dce_sec_context, &err);
694       return(False);
695     }
696   else
697     {
698       DEBUG(0,("DCE login succeeded for principal %s on pid %d\n",
699                this_user, getpid()));
700     }
701
702   dcelogin_atmost_once = 1;
703   return (True);
704 }
705
706 void dfs_unlogin(void)
707 {
708   error_status_t err;
709   int err2;
710   unsigned char dce_errstr[dce_c_error_string_len];
711
712   sec_login_purge_context(my_dce_sec_context, &err);
713   if (err != error_status_ok )
714     {  
715       dce_error_inq_text(err, dce_errstr, &err2);
716       DEBUG(0,("DCE purge login context failed for server instance %d: %s\n",
717                getpid(), dce_errstr));
718     }
719 }
720
721 #endif
722
723 #ifdef KRB5_AUTH
724 /*******************************************************************
725 check on Kerberos authentication
726 ********************************************************************/
727 static BOOL krb5_auth(char *this_user,char *password)
728 {
729         krb5_data tgtname = {
730                 0,
731                 KRB5_TGS_NAME_SIZE,
732                 KRB5_TGS_NAME
733         };
734         krb5_context kcontext;
735         krb5_principal kprinc;
736         krb5_principal server;
737         krb5_creds kcreds;
738         int options = 0;
739         krb5_address **addrs = (krb5_address **)0;
740         krb5_preauthtype *preauth = NULL;
741         krb5_keytab keytab = NULL;
742         krb5_timestamp now;
743         krb5_ccache ccache = NULL;
744         int retval;
745         char *name;
746
747         if ( retval=krb5_init_context(&kcontext))
748         {
749                 return(False);
750         }
751
752         if ( retval = krb5_timeofday(kcontext, &now) )
753         {
754                 return(False);
755         }
756
757         if ( retval = krb5_cc_default(kcontext, &ccache) )
758         {
759                 return(False);
760         }
761         
762         if ( retval = krb5_parse_name(kcontext, this_user, &kprinc) )
763         {
764                 return(False);
765         }
766
767         memset((char *)&kcreds, 0, sizeof(kcreds));
768
769         kcreds.client = kprinc;
770         
771         if ((retval = krb5_build_principal_ext(kcontext, &server,
772                 krb5_princ_realm(kcontext, kprinc)->length,
773                 krb5_princ_realm(kcontext, kprinc)->data,
774                 tgtname.length,
775                 tgtname.data,
776                 krb5_princ_realm(kcontext, kprinc)->length,
777                 krb5_princ_realm(kcontext, kprinc)->data,
778                 0)))
779         {
780                 return(False);
781         }
782
783         kcreds.server = server;
784
785         retval = krb5_get_in_tkt_with_password(kcontext,
786                 options,
787                 addrs,
788                 NULL,
789                 preauth,
790                 password,
791                 0,
792                 &kcreds,
793                 0);
794
795         if ( retval )
796         {
797                 return(False);
798         }
799
800         return(True);
801 }
802 #endif /* KRB5_AUTH */
803
804 #ifdef KRB4_AUTH
805 /*******************************************************************
806 check on Kerberos authentication
807 ********************************************************************/
808 static BOOL krb4_auth(char *this_user,char *password)
809 {
810   char realm[REALM_SZ];
811   char tkfile[MAXPATHLEN];
812   
813   if (krb_get_lrealm(realm, 1) != KSUCCESS)
814     (void) safe_strcpy(realm, KRB_REALM, sizeof (realm) - 1);
815   
816   (void) slprintf(tkfile, sizeof(tkfile) - 1, "/tmp/samba_tkt_%d", getpid());
817   
818   krb_set_tkt_string(tkfile);
819   if (krb_verify_user(this_user, "", realm,
820                      password, 0,
821                      "rmcd") == KSUCCESS) {
822     unlink(tkfile);
823     return 1;
824   }
825   unlink(tkfile);
826   return 0;
827 }
828 #endif /* KRB4_AUTH */
829
830 #ifdef LINUX_BIGCRYPT
831 /****************************************************************************
832 an enhanced crypt for Linux to handle password longer than 8 characters
833 ****************************************************************************/
834 static int linux_bigcrypt(char *password,char *salt1, char *crypted)
835 {
836 #define LINUX_PASSWORD_SEG_CHARS 8
837   char salt[3];
838   int i;
839   
840   StrnCpy(salt,salt1,2);
841   crypted +=2;
842   
843   for ( i=strlen(password); i > 0; i -= LINUX_PASSWORD_SEG_CHARS) {
844     char * p = crypt(password,salt) + 2;
845     if (strncmp(p, crypted, LINUX_PASSWORD_SEG_CHARS) != 0)
846       return(0);
847     password += LINUX_PASSWORD_SEG_CHARS;
848     crypted  += strlen(p);
849   }
850   
851   return(1);
852 }
853 #endif
854
855
856 /****************************************************************************
857 apply a function to upper/lower case combinations
858 of a string and return true if one of them returns true.
859 try all combinations with N uppercase letters.
860 offset is the first char to try and change (start with 0)
861 it assumes the string starts lowercased
862 ****************************************************************************/
863 static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(char *),int N)
864 {
865   int len = strlen(s);
866   int i;
867
868 #ifdef PASSWORD_LENGTH
869   len = MIN(len,PASSWORD_LENGTH);
870 #endif
871
872   if (N <= 0 || offset >= len)
873     return(fn(s));
874
875   for (i=offset;i<(len-(N-1));i++)
876     {      
877       char c = s[i];
878       if (!islower(c)) continue;
879       s[i] = toupper(c);
880       if (string_combinations2(s,i+1,fn,N-1))
881         return(True);
882       s[i] = c;
883     }
884   return(False);
885 }
886
887 /****************************************************************************
888 apply a function to upper/lower case combinations
889 of a string and return true if one of them returns true.
890 try all combinations with up to N uppercase letters.
891 offset is the first char to try and change (start with 0)
892 it assumes the string starts lowercased
893 ****************************************************************************/
894 static BOOL string_combinations(char *s,BOOL (*fn)(char *),int N)
895 {
896   int n;
897   for (n=1;n<=N;n++)
898     if (string_combinations2(s,0,fn,n)) return(True);
899   return(False);
900 }
901
902
903
904 /****************************************************************************
905 core of password checking routine
906 ****************************************************************************/
907 BOOL password_check(char *password)
908 {
909
910 #ifdef USE_PAM
911 /* This falls through if the password check fails
912         - if NO_CRYPT is defined this causes an error msg
913                 saying Warning - no crypt available
914         - if NO_CRYPT is NOT defined this is a potential security hole
915                 as it may authenticate via the crypt call when PAM
916                 settings say it should fail.
917   if (pam_auth(this_user,password)) return(True);
918 Hence we make a direct return to avoid a second chance!!!
919 */
920   return (pam_auth(this_user,password));
921 #endif
922
923 #ifdef AFS_AUTH
924   if (afs_auth(this_user,password)) return(True);
925 #endif
926
927 #ifdef DFS_AUTH
928   if (dfs_auth(this_user,password)) return(True);
929 #endif 
930
931 #ifdef KRB5_AUTH
932   if (krb5_auth(this_user,password)) return(True);
933 #endif
934
935 #ifdef KRB4_AUTH
936   if (krb4_auth(this_user,password)) return(True);
937 #endif
938
939 #ifdef PWDAUTH
940   if (pwdauth(this_user,password) == 0)
941     return(True);
942 #endif
943
944 #ifdef OSF1_ENH_SEC
945   {
946     BOOL ret = (strcmp(osf1_bigcrypt(password,this_salt),this_crypted) == 0);
947     if(!ret) {
948       DEBUG(2,("password_check: OSF1_ENH_SEC failed. Trying normal crypt.\n"));
949       ret = (strcmp((char *)crypt(password,this_salt),this_crypted) == 0);
950     }
951     return ret;
952   }
953 #endif
954
955 #ifdef ULTRIX_AUTH
956   return (strcmp((char *)crypt16(password, this_salt ),this_crypted) == 0);
957 #endif
958
959 #ifdef LINUX_BIGCRYPT
960   return(linux_bigcrypt(password,this_salt,this_crypted));
961 #endif
962
963 #ifdef HPUX_10_TRUSTED
964   return(strcmp(bigcrypt(password,this_salt),this_crypted) == 0);
965 #endif
966
967 #ifdef NO_CRYPT
968   DEBUG(1,("Warning - no crypt available\n"));
969   return(False);
970 #else
971   return(strcmp((char *)crypt(password,this_salt),this_crypted) == 0);
972 #endif
973 }
974
975 /****************************************************************************
976 core of smb password checking routine.
977 ****************************************************************************/
978 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
979 {
980   /* Finish the encryption of part_passwd. */
981   unsigned char p21[21];
982   unsigned char p24[24];
983
984   if (part_passwd == NULL)
985     DEBUG(10,("No password set - allowing access\n"));
986   /* No password set - always true ! */
987   if (part_passwd == NULL)
988     return 1;
989
990   memset(p21,'\0',21);
991   memcpy(p21,part_passwd,16);
992   E_P24(p21, c8, p24);
993 #if DEBUG_PASSWORD
994   {
995     int i;
996     DEBUG(100,("Part password (P16) was |"));
997     for(i = 0; i < 16; i++)
998       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
999     DEBUG(100,("|\n"));
1000     DEBUG(100,("Password from client was |"));
1001     for(i = 0; i < 24; i++)
1002       DEBUG(100,("%X ", (unsigned char)password[i]));
1003     DEBUG(100,("|\n"));
1004     DEBUG(100,("Given challenge was |"));
1005     for(i = 0; i < 8; i++)
1006       DEBUG(100,("%X ", (unsigned char)c8[i]));
1007     DEBUG(100,("|\n"));
1008     DEBUG(100,("Value from encryption was |"));
1009     for(i = 0; i < 24; i++)
1010       DEBUG(100,("%X ", (unsigned char)p24[i]));
1011     DEBUG(100,("|\n"));
1012   }
1013 #endif
1014   return (memcmp(p24, password, 24) == 0);
1015 }
1016
1017 /****************************************************************************
1018  Do a specific test for an smb password being correct, given a smb_password and
1019  the lanman and NT responses.
1020 ****************************************************************************/
1021
1022 BOOL smb_password_ok(struct smb_passwd *smb_pass,
1023                      uchar lm_pass[24], uchar nt_pass[24])
1024 {
1025   uchar challenge[8];
1026
1027   if (!lm_pass || !smb_pass) return(False);
1028
1029   if(smb_pass->acct_ctrl & ACB_DISABLED)
1030   {
1031     DEBUG(3,("smb_password_ok: account for user %s was disabled.\n", smb_pass->smb_name));
1032     return(False);
1033   }
1034
1035   if (!last_challenge(challenge))
1036   {
1037     DEBUG(1,("smb_password_ok: no challenge done - password failed\n"));
1038     return False;
1039   }
1040
1041   DEBUG(4,("smb_password_ok: Checking SMB password for user %s\n", smb_pass->smb_name));
1042
1043   if ((Protocol >= PROTOCOL_NT1) && (smb_pass->smb_nt_passwd != NULL))
1044   {
1045     /* We have the NT MD4 hash challenge available - see if we can
1046        use it (ie. does it exist in the smbpasswd file).
1047      */
1048     DEBUG(4,("smb_password_ok: Checking NT MD4 password\n"));
1049     if (smb_password_check((char *)nt_pass, (uchar *)smb_pass->smb_nt_passwd, challenge))
1050     {
1051       DEBUG(4,("smb_password_ok: NT MD4 password check succeeded\n"));
1052       return(True);
1053     }
1054     DEBUG(4,("smb_password_ok: NT MD4 password check failed\n"));
1055   }
1056
1057   /* Try against the lanman password. smb_pass->smb_passwd == NULL means
1058      no password, allow access. */
1059
1060   DEBUG(4,("Checking LM MD4 password\n"));
1061
1062   if((smb_pass->smb_passwd == NULL) && (smb_pass->acct_ctrl & ACB_PWNOTREQ))
1063   {
1064     DEBUG(4,("smb_password_ok: no password required for user %s\n", smb_pass->smb_name));
1065     return True;
1066   }
1067
1068   if((smb_pass->smb_passwd != NULL) && smb_password_check((char *)lm_pass, (uchar *)smb_pass->smb_passwd, challenge))
1069   {
1070     DEBUG(4,("smb_password_ok: LM MD4 password check succeeded\n"));
1071     return(True);
1072   }
1073
1074   DEBUG(4,("smb_password_ok: LM MD4 password check failed\n"));
1075
1076   return False;
1077 }
1078
1079 /****************************************************************************
1080 check if a username/password is OK
1081 ****************************************************************************/
1082 BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd)
1083 {
1084   pstring pass2;
1085   int level = lp_passwordlevel();
1086   struct passwd *pass;
1087   uchar challenge[8];
1088   struct smb_passwd *smb_pass;
1089   BOOL update_encrypted = lp_update_encrypted();
1090   BOOL challenge_done = False;
1091
1092   if (password) password[pwlen] = 0;
1093
1094   if (pwlen == 24)
1095     challenge_done = last_challenge(challenge);
1096
1097 #if DEBUG_PASSWORD
1098   if (challenge_done)
1099     {
1100       int i;      
1101       DEBUG(100,("checking user=[%s] pass=[",user));
1102       for( i = 0; i < 24; i++)
1103         DEBUG(100,("%0x ", (unsigned char)password[i]));
1104       DEBUG(100,("]\n"));
1105     } else {
1106             DEBUG(100,("checking user=[%s] pass=[%s]\n",user,password));
1107     }
1108 #endif
1109
1110   if (!password)
1111     return(False);
1112
1113   if (((!*password) || (!pwlen)) && !lp_null_passwords())
1114     return(False);
1115
1116   if (pwd && !user) 
1117     {
1118       pass = (struct passwd *) pwd;
1119       user = pass->pw_name;
1120     } 
1121   else 
1122     pass = Get_Pwnam(user,True);
1123
1124   DEBUG(4,("SMB Password - pwlen = %d, challenge_done = %d\n", pwlen, challenge_done));
1125
1126   if ((pwlen == 24) && challenge_done)
1127     {
1128       DEBUG(4,("Checking SMB password for user %s (l=24)\n",user));
1129
1130       if (!pass) 
1131         {
1132           DEBUG(3,("Couldn't find user %s\n",user));
1133           return(False);
1134         }
1135
1136       smb_pass = getsmbpwnam(user);
1137
1138       if (!smb_pass)
1139         {
1140           DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
1141           return(False);
1142         }
1143
1144       /* Quit if the account was disabled. */
1145       if(smb_pass->acct_ctrl & ACB_DISABLED)
1146         {
1147           DEBUG(3,("password_ok: account for user %s was disabled.\n", user));
1148           return(False);
1149         }
1150
1151       /* Ensure the uid's match */
1152       if (smb_pass->smb_userid != pass->pw_uid)
1153         {
1154           DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
1155           return(False);
1156         }
1157
1158       if(smb_password_ok( smb_pass, (unsigned char *)password,(uchar *)password))
1159         {
1160           update_protected_database(user,True);
1161           return(True);
1162         }
1163
1164       DEBUG(3,("Error smb_password_check failed\n"));
1165     }
1166
1167   DEBUG(4,("Checking password for user %s (l=%d)\n",user,pwlen));
1168
1169   if (!pass) 
1170     {
1171       DEBUG(3,("Couldn't find user %s\n",user));
1172       return(False);
1173     }
1174
1175 #ifdef SHADOW_PWD
1176   {
1177     struct spwd *spass;
1178
1179     /* many shadow systems require you to be root to get the password,
1180        in most cases this should already be the case when this
1181        function is called, except perhaps for IPC password changing
1182        requests */
1183
1184     spass = getspnam(pass->pw_name);
1185     if (spass && spass->sp_pwdp)
1186       pass->pw_passwd = spass->sp_pwdp;
1187   }
1188 #elif defined(IA_UINFO)
1189   {
1190       /* Need to get password with SVR4.2's ia_ functions instead of
1191          get{sp,pw}ent functions. Required by UnixWare 2.x, tested on 
1192          version 2.1. (tangent@cyberport.com) */
1193       uinfo_t uinfo;
1194       if (ia_openinfo(pass->pw_name, &uinfo) != -1)
1195         ia_get_logpwd(uinfo, &(pass->pw_passwd));
1196   }
1197 #endif
1198
1199 #ifdef SecureWare
1200   {
1201     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
1202     if (pr_pw && pr_pw->ufld.fd_encrypt)
1203       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
1204   }
1205 #endif
1206
1207 #ifdef HPUX_10_TRUSTED
1208   {
1209     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
1210     if (pr_pw && pr_pw->ufld.fd_encrypt)
1211       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
1212   }
1213 #endif
1214
1215 #ifdef OSF1_ENH_SEC
1216   {
1217     struct pr_passwd *mypasswd;
1218     DEBUG(5,("Checking password for user %s in OSF1_ENH_SEC\n",user));
1219     mypasswd = getprpwnam (user);
1220     if ( mypasswd )
1221       { 
1222         fstrcpy(pass->pw_name,mypasswd->ufld.fd_name);
1223         fstrcpy(pass->pw_passwd,mypasswd->ufld.fd_encrypt);
1224       }
1225     else
1226       {
1227         DEBUG(5,("No entry for user %s in protected database !\n",user));
1228         return(False);
1229       }
1230   }
1231 #endif
1232
1233 #ifdef ULTRIX_AUTH
1234   {
1235     AUTHORIZATION *ap = getauthuid( pass->pw_uid );
1236     if (ap)
1237       {
1238         fstrcpy( pass->pw_passwd, ap->a_password );
1239         endauthent();
1240       }
1241   }
1242 #endif
1243
1244   /* extract relevant info */
1245   fstrcpy(this_user,pass->pw_name);  
1246   fstrcpy(this_salt,pass->pw_passwd);
1247 #ifdef HPUX
1248   /* The crypt on HPUX won't work with more than 2 salt characters. */
1249   this_salt[2] = 0;
1250 #endif /* HPUX */
1251   fstrcpy(this_crypted,pass->pw_passwd);
1252  
1253   if (!*this_crypted) {
1254     if (!lp_null_passwords()) {
1255       DEBUG(2,("Disallowing access to %s due to null password\n",this_user));
1256       return(False);
1257     }
1258 #ifndef PWDAUTH
1259     if (!*password) {
1260       DEBUG(3,("Allowing access to %s with null password\n",this_user));
1261       return(True);
1262     }
1263 #endif    
1264   }
1265
1266   /* try it as it came to us */
1267   if (password_check(password))
1268     {
1269       update_protected_database(user,True);
1270       if (update_encrypted)
1271         update_smbpassword_file(user,password);
1272       return(True);
1273     }
1274
1275   /* if the password was given to us with mixed case then we don't
1276      need to proceed as we know it hasn't been case modified by the
1277      client */
1278   if (strhasupper(password) && strhaslower(password))
1279     return(False);
1280
1281   /* make a copy of it */
1282   StrnCpy(pass2,password,sizeof(pstring)-1);
1283   
1284   /* try all lowercase */
1285   strlower(password);
1286   if (password_check(password))
1287     {
1288       update_protected_database(user,True);
1289       if (update_encrypted)
1290         update_smbpassword_file(user,password);
1291       return(True);
1292     }
1293
1294   /* give up? */
1295   if (level < 1)
1296     {
1297       update_protected_database(user,False);
1298
1299       /* restore it */
1300       fstrcpy(password,pass2);
1301
1302       return(False);
1303     }
1304
1305   /* last chance - all combinations of up to level chars upper! */
1306   strlower(password);
1307
1308   if (string_combinations(password,password_check,level))
1309     {
1310       update_protected_database(user,True);
1311       if (update_encrypted)
1312         update_smbpassword_file(user,password);
1313       return(True);
1314     }
1315
1316   update_protected_database(user,False);
1317   
1318   /* restore it */
1319   fstrcpy(password,pass2);
1320   
1321   return(False);
1322 }
1323
1324
1325
1326 /****************************************************************************
1327 check if a username is valid
1328 ****************************************************************************/
1329 BOOL user_ok(char *user,int snum)
1330 {
1331   pstring valid, invalid;
1332   BOOL ret;
1333
1334   StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
1335   StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
1336
1337   string_sub(valid,"%S",lp_servicename(snum));
1338   string_sub(invalid,"%S",lp_servicename(snum));
1339
1340   ret = !user_in_list(user,invalid);
1341
1342   if (ret && valid && *valid)
1343     ret = user_in_list(user,valid);
1344
1345   if (ret && lp_onlyuser(snum)) {
1346     char *user_list = lp_username(snum);
1347     string_sub(user_list,"%S",lp_servicename(snum));
1348     ret = user_in_list(user,user_list);
1349   }
1350
1351   return(ret);
1352 }
1353
1354
1355
1356
1357 /****************************************************************************
1358 validate a group username entry. Return the username or NULL
1359 ****************************************************************************/
1360 static char *validate_group(char *group,char *password,int pwlen,int snum)
1361 {
1362 #ifdef NETGROUP
1363   {
1364     char *host, *user, *domain;
1365     setnetgrent(group);
1366     while (getnetgrent(&host, &user, &domain)) {
1367       if (user) {
1368         if (user_ok(user, snum) && 
1369             password_ok(user,password,pwlen,NULL)) {
1370           endnetgrent();
1371           return(user);
1372         }
1373       }
1374     }
1375     endnetgrent();
1376   }
1377 #endif
1378   
1379 #if HAVE_GETGRNAM 
1380   {
1381     struct group *gptr = (struct group *)getgrnam(group);
1382     char **member;
1383     if (gptr)
1384       {
1385         member = gptr->gr_mem;
1386         while (member && *member)
1387           {
1388             static fstring name;
1389             fstrcpy(name,*member);
1390             if (user_ok(name,snum) &&
1391                 password_ok(name,password,pwlen,NULL))
1392               return(&name[0]);
1393             member++;
1394           }
1395 #ifdef GROUP_CHECK_PWENT
1396         {
1397           struct passwd *pwd;
1398           static fstring tm;
1399           
1400           setpwent ();
1401           while (pwd = getpwent ()) {
1402             if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
1403               /* This Entry have PASSWORD and same GID then check pwd */
1404               if (password_ok(NULL, password, pwlen, pwd)) {
1405                 fstrcpy(tm, pwd->pw_name);
1406                 endpwent ();
1407                 return tm;
1408               }
1409             }
1410           }
1411           endpwent ();
1412         }
1413 #endif /* GROUP_CHECK_PWENT */
1414       }
1415   }      
1416 #endif
1417   return(NULL);
1418 }
1419
1420
1421
1422 /****************************************************************************
1423 check for authority to login to a service with a given username/password
1424 ****************************************************************************/
1425 BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
1426                      BOOL *guest,BOOL *force,uint16 vuid)
1427 {
1428   BOOL ok = False;
1429   
1430   *guest = False;
1431   
1432 #if DEBUG_PASSWORD
1433   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
1434 #endif
1435
1436   /* there are several possibilities:
1437      1) login as the given user with given password
1438      2) login as a previously registered username with the given password
1439      3) login as a session list username with the given password
1440      4) login as a previously validated user/password pair
1441      5) login as the "user =" user with given password
1442      6) login as the "user =" user with no password (guest connection)
1443      7) login as guest user with no password
1444
1445      if the service is guest_only then steps 1 to 5 are skipped
1446   */
1447
1448   if (GUEST_ONLY(snum)) *force = True;
1449
1450   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
1451     {
1452
1453       user_struct *vuser = get_valid_user_struct(vuid);
1454
1455       /* check the given username and password */
1456       if (!ok && (*user) && user_ok(user,snum)) {
1457         ok = password_ok(user,password, pwlen, NULL);
1458         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
1459       }
1460
1461       /* check for a previously registered guest username */
1462       if (!ok && (vuser != 0) && vuser->guest) {          
1463         if (user_ok(vuser->name,snum) &&
1464             password_ok(vuser->name, password, pwlen, NULL)) {
1465           fstrcpy(user, vuser->name);
1466           vuser->guest = False;
1467           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
1468           ok = True;
1469         }
1470       }
1471
1472
1473       /* now check the list of session users */
1474     if (!ok)
1475     {
1476       char *auser;
1477       char *user_list = strdup(session_users);
1478       if (!user_list) return(False);
1479
1480       for (auser=strtok(user_list,LIST_SEP); 
1481            !ok && auser; 
1482            auser = strtok(NULL,LIST_SEP))
1483       {
1484         fstring user2;
1485         fstrcpy(user2,auser);
1486         if (!user_ok(user2,snum)) continue;
1487                   
1488         if (password_ok(user2,password, pwlen, NULL)) {
1489           ok = True;
1490           fstrcpy(user,user2);
1491           DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
1492         }
1493       }
1494       free(user_list);
1495     }
1496
1497     /* check for a previously validated username/password pair */
1498     if (!ok && (!lp_revalidate(snum) || lp_security() > SEC_SHARE) &&
1499         (vuser != 0) && !vuser->guest &&
1500         user_ok(vuser->name,snum)) {
1501       fstrcpy(user,vuser->name);
1502       *guest = False;
1503       DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
1504       ok = True;
1505     }
1506
1507       /* check for a rhosts entry */
1508       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
1509         ok = True;
1510         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
1511       }
1512
1513       /* check the user= fields and the given password */
1514       if (!ok && lp_username(snum)) {
1515         char *auser;
1516         pstring user_list;
1517         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
1518
1519         string_sub(user_list,"%S",lp_servicename(snum));
1520           
1521         for (auser=strtok(user_list,LIST_SEP);
1522              auser && !ok;
1523              auser = strtok(NULL,LIST_SEP))
1524           {
1525             if (*auser == '@')
1526               {
1527                 auser = validate_group(auser+1,password,pwlen,snum);
1528                 if (auser)
1529                   {
1530                     ok = True;
1531                     fstrcpy(user,auser);
1532                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
1533                   }
1534               }
1535             else
1536               {
1537                 fstring user2;
1538                 fstrcpy(user2,auser);
1539                 if (user_ok(user2,snum) && 
1540                     password_ok(user2,password,pwlen,NULL))
1541                   {
1542                     ok = True;
1543                     fstrcpy(user,user2);
1544                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
1545                   }
1546               }
1547           }
1548       }      
1549     } /* not guest only */
1550
1551   /* check for a normal guest connection */
1552   if (!ok && GUEST_OK(snum))
1553     {
1554       fstring guestname;
1555       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
1556       if (Get_Pwnam(guestname,True))
1557         {
1558           fstrcpy(user,guestname);
1559           ok = True;
1560           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
1561         }
1562       else
1563         DEBUG(0,("Invalid guest account %s??\n",guestname));
1564       *guest = True;
1565       *force = True;
1566     }
1567
1568   if (ok && !user_ok(user,snum))
1569     {
1570       DEBUG(0,("rejected invalid user %s\n",user));
1571       ok = False;
1572     }
1573
1574   return(ok);
1575 }
1576
1577
1578 /****************************************************************************
1579 read the a hosts.equiv or .rhosts file and check if it
1580 allows this user from this machine
1581 ****************************************************************************/
1582 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
1583 {
1584   pstring buf;
1585   int plus_allowed = 1;
1586   char *file_host;
1587   char *file_user;
1588   FILE *fp = fopen(equiv_file, "r");
1589   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
1590   if (! fp) return False;
1591   while(fgets(buf, sizeof(buf), fp)) 
1592   {
1593     trim_string(buf," "," ");
1594
1595     if (buf[0] != '#' && buf[0] != '\n') 
1596     {
1597       BOOL is_group = False;
1598       int plus = 1;
1599       char *bp = buf;
1600       if (strcmp(buf, "NO_PLUS\n") == 0)
1601       {
1602         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
1603         plus_allowed = 0;
1604       }
1605       else {
1606         if (buf[0] == '+') 
1607         {
1608           bp++;
1609           if (*bp == '\n' && plus_allowed) 
1610           {
1611             /* a bare plus means everbody allowed */
1612             DEBUG(6, ("check_user_equiv everybody allowed\n"));
1613             fclose(fp);
1614             return True;
1615           }
1616         }
1617         else if (buf[0] == '-')
1618         {
1619           bp++;
1620           plus = 0;
1621         }
1622         if (*bp == '@') 
1623         {
1624           is_group = True;
1625           bp++;
1626         }
1627         file_host = strtok(bp, " \t\n");
1628         file_user = strtok(NULL, " \t\n");
1629         DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)", 
1630                  file_user ? file_user : "(null)" ));
1631         if (file_host && *file_host) 
1632         {
1633           BOOL host_ok = False;
1634
1635 #ifdef NETGROUP   
1636           if (is_group)
1637             {
1638               static char *mydomain = NULL;
1639               if (!mydomain)
1640                 yp_get_default_domain(&mydomain);
1641               if (mydomain && innetgr(file_host,remote,user,mydomain))
1642                 host_ok = True;
1643             }
1644 #else
1645           if (is_group)
1646             {
1647               DEBUG(1,("Netgroups not configured - add -DNETGROUP and recompile\n"));
1648               continue;
1649             }
1650 #endif
1651
1652           /* is it this host */
1653           /* the fact that remote has come from a call of gethostbyaddr
1654            * means that it may have the fully qualified domain name
1655            * so we could look up the file version to get it into
1656            * a canonical form, but I would rather just type it
1657            * in full in the equiv file
1658            */
1659           if (!host_ok && !is_group && strequal(remote, file_host))
1660             host_ok = True;
1661
1662           if (!host_ok)
1663             continue;
1664
1665           /* is it this user */
1666           if (file_user == 0 || strequal(user, file_user)) 
1667             {
1668               fclose(fp);
1669               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
1670                         (plus ? "+" : "-"), file_host,
1671                         (file_user ? file_user : "")));
1672               return (plus ? True : False);
1673             }
1674         }
1675       }
1676     }
1677   }
1678   fclose(fp);
1679   return False;
1680 }
1681
1682
1683 /****************************************************************************
1684 check for a possible hosts equiv or rhosts entry for the user
1685 ****************************************************************************/
1686 BOOL check_hosts_equiv(char *user)
1687 {
1688   char *fname = NULL;
1689   pstring rhostsfile;
1690   struct passwd *pass = Get_Pwnam(user,True);
1691
1692   if (!pass) 
1693     return(False);
1694
1695   fname = lp_hosts_equiv();
1696
1697   /* note: don't allow hosts.equiv on root */
1698   if (fname && *fname && (pass->pw_uid != 0)) {
1699           extern int Client;
1700           if (check_user_equiv(user,client_name(Client),fname))
1701                   return(True);
1702   }
1703   
1704   if (lp_use_rhosts())
1705     {
1706       char *home = get_home_dir(user);
1707       if (home) {
1708               extern int Client;
1709               slprintf(rhostsfile, sizeof(rhostsfile)-1, "%s/.rhosts", home);
1710               if (check_user_equiv(user,client_name(Client),rhostsfile))
1711                       return(True);
1712       }
1713     }
1714
1715   return(False);
1716 }
1717
1718
1719 static struct cli_state pw_cli;
1720
1721 /****************************************************************************
1722 return the client state structure
1723 ****************************************************************************/
1724 struct cli_state *server_client(void)
1725 {
1726         return &pw_cli;
1727 }
1728
1729 /****************************************************************************
1730 support for server level security 
1731 ****************************************************************************/
1732 struct cli_state *server_cryptkey(void)
1733 {
1734         fstring desthost;
1735         struct in_addr dest_ip;
1736         extern fstring local_machine;
1737         char *p;
1738         BOOL connected_ok = False;
1739
1740         if (!cli_initialise(&pw_cli))
1741                 return NULL;
1742
1743         p = lp_passwordserver();
1744         while(p && next_token( &p, desthost, LIST_SEP)) {
1745                 standard_sub_basic(desthost);
1746                 strupper(desthost);
1747
1748                 if(!resolve_name( desthost, &dest_ip)) {
1749                         DEBUG(1,("server_cryptkey: Can't resolve address for %s\n",desthost));
1750                         continue;
1751                 }
1752
1753                 if (ismyip(dest_ip)) {
1754                         DEBUG(1,("Password server loop - disabling password server %s\n",desthost));
1755                         continue;
1756                 }
1757
1758                 if (cli_connect(&pw_cli, desthost, &dest_ip)) {
1759                         DEBUG(3,("connected to password server %s\n",desthost));
1760                         connected_ok = True;
1761                         break;
1762                 }
1763         }
1764
1765         if (!connected_ok) {
1766                 DEBUG(0,("password server not available\n"));
1767                 cli_shutdown(&pw_cli);
1768                 return NULL;
1769         }
1770
1771         if (!cli_session_request(&pw_cli, desthost, 0x20, local_machine)) {
1772                 DEBUG(1,("%s rejected the session\n",desthost));
1773                 cli_shutdown(&pw_cli);
1774                 return NULL;
1775         }
1776
1777         DEBUG(3,("got session\n"));
1778
1779         if (!cli_negprot(&pw_cli)) {
1780                 DEBUG(1,("%s rejected the negprot\n",desthost));
1781                 cli_shutdown(&pw_cli);
1782                 return NULL;
1783         }
1784
1785         if (pw_cli.protocol < PROTOCOL_LANMAN2 ||
1786             !(pw_cli.sec_mode & 1)) {
1787                 DEBUG(1,("%s isn't in user level security mode\n",desthost));
1788                 cli_shutdown(&pw_cli);
1789                 return NULL;
1790         }
1791
1792         DEBUG(3,("password server OK\n"));
1793
1794         return &pw_cli;
1795 }
1796
1797 /****************************************************************************
1798 validate a password with the password server
1799 ****************************************************************************/
1800 BOOL server_validate(char *user, char *domain, 
1801                      char *pass, int passlen,
1802                      char *ntpass, int ntpasslen)
1803 {
1804         extern fstring local_machine;
1805         static unsigned char badpass[24];
1806
1807         if (!pw_cli.initialised) {
1808                 DEBUG(1,("password server %s is not connected\n", pw_cli.desthost));
1809                 return(False);
1810         }  
1811
1812         if(badpass[0] == 0) {
1813           memset(badpass, 0x1f, sizeof(badpass));
1814         }
1815
1816         if((passlen == sizeof(badpass)) && !memcmp(badpass, pass, passlen)) {
1817           /* Very unlikely, our random bad password is the same as the users
1818              password. */
1819           memset(badpass, badpass[0]+1, sizeof(badpass));
1820         }
1821
1822         /*
1823          * Attempt a session setup with a totally incorrect password.
1824          * If this succeeds with the guest bit *NOT* set then the password
1825          * server is broken and is not correctly setting the guest bit. We
1826          * need to detect this as some versions of NT4.x are broken. JRA.
1827          */
1828
1829         if (cli_session_setup(&pw_cli, user, (char *)badpass, sizeof(badpass), 
1830                               (char *)badpass, sizeof(badpass), domain)) {
1831           if ((SVAL(pw_cli.inbuf,smb_vwv2) & 1) == 0) {
1832             DEBUG(0,("server_validate: password server %s allows users as non-guest \
1833 with a bad password.\n", pw_cli.desthost));
1834             DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1835 use this machine as the password server.\n"));
1836             cli_ulogoff(&pw_cli);
1837             return False;
1838           }
1839           cli_ulogoff(&pw_cli);
1840         }
1841
1842         /*
1843          * Now we know the password server will correctly set the guest bit, or is
1844          * not guest enabled, we can try with the real password.
1845          */
1846
1847         if (!cli_session_setup(&pw_cli, user, pass, passlen, ntpass, ntpasslen, domain)) {
1848                 DEBUG(1,("password server %s rejected the password\n", pw_cli.desthost));
1849                 return False;
1850         }
1851
1852         /* if logged in as guest then reject */
1853         if ((SVAL(pw_cli.inbuf,smb_vwv2) & 1) != 0) {
1854                 DEBUG(1,("password server %s gave us guest only\n", pw_cli.desthost));
1855                 cli_ulogoff(&pw_cli);
1856                 return(False);
1857         }
1858
1859         /*
1860          * This patch from Rob Nielsen <ran@adc.com> makes doing
1861          * the NetWksaUserLogon a dynamic, rather than compile-time
1862          * parameter, defaulting to on. This is somewhat dangerous
1863          * as it allows people to turn off this neccessary check,
1864          * but so many people have had problems with this that I
1865          * think it is a neccessary change. JRA.
1866          */
1867
1868         if (lp_net_wksta_user_logon()) {
1869                 DEBUG(3,("trying NetWkstaUserLogon with password server %s\n", pw_cli.desthost));
1870
1871                 if (!cli_send_tconX(&pw_cli, "IPC$", "IPC", "", 1)) {
1872                         DEBUG(0,("password server %s refused IPC$ connect\n", pw_cli.desthost));
1873                         cli_ulogoff(&pw_cli);
1874                         return False;
1875                 }
1876
1877                 if (!cli_NetWkstaUserLogon(&pw_cli,user,local_machine)) {
1878                         DEBUG(0,("password server %s failed NetWkstaUserLogon\n", pw_cli.desthost));
1879                         cli_tdis(&pw_cli);
1880                         cli_ulogoff(&pw_cli);
1881                         return False;
1882                 }
1883
1884                 if (pw_cli.privilages == 0) {
1885                         DEBUG(0,("password server %s gave guest privilages\n", pw_cli.desthost));
1886                         cli_tdis(&pw_cli);
1887                         cli_ulogoff(&pw_cli);
1888                         return False;
1889                 }
1890
1891                 if (!strequal(pw_cli.eff_name, user)) {
1892                         DEBUG(0,("password server %s gave different username %s\n", 
1893                                 pw_cli.desthost,
1894                                 pw_cli.eff_name));
1895                         cli_tdis(&pw_cli);
1896                         cli_ulogoff(&pw_cli);
1897                         return False;
1898                 }
1899                 cli_tdis(&pw_cli);
1900         }
1901         else {
1902                 DEBUG(3,("skipping NetWkstaUserLogon with password server %s\n", pw_cli.desthost));
1903         }
1904
1905         DEBUG(3,("password server %s accepted the password\n", pw_cli.desthost));
1906
1907         cli_ulogoff(&pw_cli);
1908
1909         return(True);
1910 }
1911
1912 /***********************************************************************
1913  Do the same as security=server, but using NT Domain calls and a session
1914  key from the machine password.
1915 ************************************************************************/
1916
1917 BOOL domain_client_validate( char *user, char *domain, 
1918                              char *smb_apasswd, int smb_apasslen, 
1919                              char *smb_ntpasswd, int smb_ntpasslen)
1920 {
1921   unsigned char local_challenge[8];
1922   unsigned char local_lm_response[24];
1923   unsigned char local_nt_reponse[24];
1924   unsigned char trust_passwd[16];
1925   time_t lct;
1926   fstring remote_machine;
1927   char *p;
1928   struct in_addr dest_ip;
1929   NET_ID_INFO_CTR ctr;
1930   NET_USER_INFO_3 info3;
1931   struct cli_state cli;
1932   uint32 smb_uid_low;
1933   BOOL connected_ok = False;
1934
1935   /* 
1936    * Check that the requested domain is not our own machine name.
1937    * If it is, we should never check the PDC here, we use our own local
1938    * password file.
1939    */
1940
1941   if(strequal( domain, global_myname)) {
1942     DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1943     return False;
1944   }
1945
1946   /*
1947    * Next, check that the passwords given were encrypted.
1948    */
1949
1950   if(((smb_apasslen != 24) && (smb_apasslen != 0)) || 
1951      ((smb_ntpasslen != 24) && (smb_ntpasslen != 0))) {
1952
1953     /*
1954      * Not encrypted - do so.
1955      */
1956
1957     DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1958     generate_random_buffer( local_challenge, 8, False);
1959     SMBencrypt( (uchar *)smb_apasswd, local_challenge, local_lm_response);
1960     SMBNTencrypt((uchar *)smb_ntpasswd, local_challenge, local_nt_reponse);
1961     smb_apasslen = 24;
1962     smb_ntpasslen = 24;
1963     smb_apasswd = (char *)local_lm_response;
1964     smb_ntpasswd = (char *)local_nt_reponse;
1965   } else {
1966
1967     /*
1968      * Encrypted - get the challenge we sent for these
1969      * responses.
1970      */
1971
1972     if (!last_challenge(local_challenge)) {
1973       DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1974       return False;
1975     }
1976   }
1977
1978   /*
1979    * Get the machine account password.
1980    */
1981   if(!trust_password_lock( global_myworkgroup, global_myname, False)) {
1982     DEBUG(0,("domain_client_validate: unable to open the machine account password file for \
1983 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
1984     return False;
1985   }
1986
1987   if(get_trust_account_password( trust_passwd, &lct) == False) {
1988     DEBUG(0,("domain_client_validate: unable to read the machine account password for \
1989 machine %s in domain %s.\n", global_myname, global_myworkgroup ));
1990     trust_password_unlock();
1991     return False;
1992   }
1993
1994   trust_password_unlock();
1995
1996   /* 
1997    * Here we should check the last change time to see if the machine
1998    * password needs changing..... TODO... JRA. 
1999    */
2000
2001   if(time(NULL) > lct + lp_machine_password_timeout())
2002     global_machine_pasword_needs_changing = True;
2003
2004   /*
2005    * At this point, smb_apasswd points to the lanman response to
2006    * the challenge in local_challenge, and smb_ntpasswd points to
2007    * the NT response to the challenge in local_challenge. Ship
2008    * these over the secure channel to a domain controller and
2009    * see if they were valid.
2010    */
2011
2012   memset(&cli, '\0', sizeof(struct cli_state));
2013   if(cli_initialise(&cli) == False) {
2014     DEBUG(0,("domain_client_validate: unable to initialize client connection.\n"));
2015     return False;
2016   }
2017
2018   /*
2019    * Treat each name in the 'password server =' line as a potential
2020    * PDC/BDC. Contact each in turn and try and authenticate.
2021    */
2022
2023   p = lp_passwordserver();
2024   while(p && next_token( &p, remote_machine, LIST_SEP)) {                       
2025
2026     standard_sub_basic(remote_machine);
2027     strupper(remote_machine);
2028  
2029     if(!resolve_name( remote_machine, &dest_ip)) {
2030       DEBUG(1,("domain_client_validate: Can't resolve address for %s\n", remote_machine));
2031       continue;
2032     }   
2033     
2034     if (ismyip(dest_ip)) {
2035       DEBUG(1,("domain_client_validate: Password server loop - not using password server %s\n",remote_machine));
2036       continue;
2037     }
2038       
2039     if (!cli_connect(&cli, remote_machine, &dest_ip)) {
2040       DEBUG(0,("domain_client_validate: unable to connect to SMB server on \
2041 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
2042       continue;
2043     }
2044     
2045     if (!cli_session_request(&cli, remote_machine, 0x20, global_myname)) {
2046       DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
2047 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
2048       cli_shutdown(&cli);
2049       continue;
2050     }
2051     
2052     cli.protocol = PROTOCOL_NT1;
2053
2054     if (!cli_negprot(&cli)) {
2055       DEBUG(0,("domain_client_validate: machine %s rejected the negotiate protocol. \
2056 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
2057       cli_shutdown(&cli);
2058       continue;
2059     }
2060     
2061     if (cli.protocol != PROTOCOL_NT1) {
2062       DEBUG(0,("domain_client_validate: machine %s didn't negotiate NT protocol.\n",
2063                      remote_machine));
2064       cli_shutdown(&cli);
2065       continue;
2066     }
2067
2068     /* 
2069      * Do an anonymous session setup.
2070      */
2071
2072     if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) {
2073       DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
2074 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
2075       cli_shutdown(&cli);
2076       continue;
2077     }      
2078
2079     if (!(cli.sec_mode & 1)) {
2080       DEBUG(1,("domain_client_validate: machine %s isn't in user level security mode\n",
2081                  remote_machine));
2082       cli_shutdown(&cli);
2083       continue;
2084     }
2085
2086     if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) {
2087       DEBUG(0,("domain_client_validate: machine %s rejected the tconX on the IPC$ share. \
2088 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
2089       cli_shutdown(&cli);
2090       continue;
2091     }
2092
2093     /*
2094      * We have an anonymous connection to IPC$.
2095      */
2096     connected_ok = True;
2097     break;
2098   }
2099
2100   if (!connected_ok) {
2101     DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
2102     cli_shutdown(&cli);
2103     return False;
2104   }
2105
2106   /*
2107    * Ok - we have an anonymous connection to the IPC$ share.
2108    * Now start the NT Domain stuff :-).
2109    */
2110
2111   if(cli_nt_session_open(&cli, PIPE_NETLOGON, False) == False) {
2112     DEBUG(0,("domain_client_validate: unable to open the domain client session to \
2113 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli)));
2114     cli_nt_session_close(&cli);
2115     cli_ulogoff(&cli);
2116     cli_shutdown(&cli);
2117     return False; 
2118   }
2119
2120   if(cli_nt_setup_creds(&cli, trust_passwd) == False) {
2121     DEBUG(0,("domain_client_validate: unable to setup the PDC credentials to machine \
2122 %s. Error was : %s.\n", remote_machine, cli_errstr(&cli)));
2123     cli_nt_session_close(&cli);
2124     cli_ulogoff(&cli);
2125     cli_shutdown(&cli);
2126     return False;
2127   }
2128
2129   /* We really don't care what LUID we give the user. */
2130   generate_random_buffer( (unsigned char *)&smb_uid_low, 4, False);
2131
2132   if(cli_nt_login_network(&cli, domain, user, smb_uid_low, (char *)local_challenge,
2133                           ((smb_apasslen != 0) ? smb_apasswd : NULL),
2134                           ((smb_ntpasslen != 0) ? smb_ntpasswd : NULL),
2135                           &ctr, &info3) == False) {
2136     DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
2137 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
2138     cli_nt_session_close(&cli);
2139     cli_ulogoff(&cli);
2140     cli_shutdown(&cli);
2141     return False;
2142   }
2143
2144   /*
2145    * Here, if we really want it, we have lots of info about the user in info3.
2146    */
2147
2148 #if 0
2149   /* 
2150    * We don't actually need to do this - plus it fails currently with
2151    * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
2152    * send here. JRA.
2153    */
2154
2155   if(cli_nt_logoff(&cli, &ctr) == False) {
2156     DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
2157 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));        
2158     cli_nt_session_close(&cli);
2159     cli_ulogoff(&cli);
2160     cli_shutdown(&cli);
2161     return False;
2162   }
2163 #endif /* 0 */
2164
2165   cli_nt_session_close(&cli);
2166   cli_ulogoff(&cli);
2167   cli_shutdown(&cli);
2168   return True;
2169 }