improving authentication code (tidyup).
[kai/samba.git] / source / 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 extern int DEBUGLEVEL;
25 extern int Protocol;
26
27 /* users from session setup */
28 static pstring session_users="";
29
30 extern pstring scope;
31 extern pstring global_myname;
32 extern fstring global_myworkgroup;
33
34 /* Data to do lanman1/2 password challenge. */
35 static unsigned char saved_challenge[8];
36 static BOOL challenge_sent=False;
37
38 /*******************************************************************
39 Get the next challenge value - no repeats.
40 ********************************************************************/
41 void generate_next_challenge(char *challenge)
42 {
43 #if 0
44         /* 
45          * Leave this ifdef'd out while we test
46          * the new crypto random number generator.
47          * JRA.
48          */
49         unsigned char buf[16];
50         static int counter = 0;
51         struct timeval tval;
52         int v1,v2;
53
54         /* get a sort-of random number */
55         GetTimeOfDay(&tval);
56         v1 = (counter++) + getpid() + tval.tv_sec;
57         v2 = (counter++) * getpid() + tval.tv_usec;
58         SIVAL(challenge,0,v1);
59         SIVAL(challenge,4,v2);
60
61         /* mash it up with md4 */
62         mdfour(buf, (unsigned char *)challenge, 8);
63 #else
64         unsigned char buf[8];
65
66         generate_random_buffer(buf,8,False);
67 #endif 
68         memcpy(saved_challenge, buf, 8);
69         memcpy(challenge,buf,8);
70         challenge_sent = True;
71 }
72
73 /*******************************************************************
74 set the last challenge sent, usually from a password server
75 ********************************************************************/
76 BOOL set_challenge(unsigned char *challenge)
77 {
78   memcpy(saved_challenge,challenge,8);
79   challenge_sent = True;
80   return(True);
81 }
82
83 /*******************************************************************
84 get the last challenge sent
85 ********************************************************************/
86 static BOOL last_challenge(unsigned char *challenge)
87 {
88   if (!challenge_sent) return(False);
89   memcpy(challenge,saved_challenge,8);
90   return(True);
91 }
92
93 /* this holds info on user ids that are already validated for this VC */
94 static user_struct *validated_users = NULL;
95 static int num_validated_users = 0;
96
97 /****************************************************************************
98 check if a uid has been validated, and return an pointer to the user_struct
99 if it has. NULL if not. vuid is biased by an offset. This allows us to
100 tell random client vuid's (normally zero) from valid vuids.
101 ****************************************************************************/
102 user_struct *get_valid_user_struct(uint16 vuid)
103 {
104   if (vuid == UID_FIELD_INVALID)
105     return NULL;
106   vuid -= VUID_OFFSET;
107   if ((vuid >= (uint16)num_validated_users) || 
108      (validated_users[vuid].uid == (uid_t)-1) || (validated_users[vuid].gid == (gid_t)-1))
109     return NULL;
110   return &validated_users[vuid];
111 }
112
113 /****************************************************************************
114 invalidate a uid
115 ****************************************************************************/
116 void invalidate_vuid(uint16 vuid)
117 {
118   user_struct *vuser = get_valid_user_struct(vuid);
119
120   if (vuser == NULL) return;
121
122   vuser->uid = (uid_t)-1;
123   vuser->gid = (gid_t)-1;
124
125   vuser->n_sids = 0;
126
127   /* same number of igroups as groups */
128   vuser->n_groups = 0;
129
130   if (vuser->groups)
131     free((char *)vuser->groups);
132
133   if (vuser->sids)
134     free((char *)vuser->sids);
135
136   vuser->sids    = NULL;
137   vuser->groups  = NULL;
138 }
139
140
141 /****************************************************************************
142 return a validated username
143 ****************************************************************************/
144 char *validated_username(uint16 vuid)
145 {
146   user_struct *vuser = get_valid_user_struct(vuid);
147   if (vuser == NULL)
148     return 0;
149   return(vuser->name);
150 }
151
152
153
154 /****************************************************************************
155 register a uid/name pair as being valid and that a valid password
156 has been given. vuid is biased by an offset. This allows us to
157 tell random client vuid's (normally zero) from valid vuids.
158 ****************************************************************************/
159 uint16 register_vuid(uid_t uid,gid_t gid, char *unix_name, char *requested_name, BOOL guest, uchar user_sess_key[16])
160 {
161   user_struct *vuser;
162   struct passwd *pwfile; /* for getting real name from passwd file */
163
164   /* Ensure no vuid gets registered in share level security. */
165   if(lp_security() == SEC_SHARE)
166     return UID_FIELD_INVALID;
167
168 #if 0
169   /*
170    * After observing MS-Exchange services writing to a Samba share
171    * I belive this code is incorrect. Each service does its own
172    * sessionsetup_and_X for the same user, and as each service shuts
173    * down, it does a user_logoff_and_X. As we are consolidating multiple
174    * sessionsetup_and_X's onto the same vuid here, when the first service
175    * shuts down, it invalidates all the open files for the other services.
176    * Hence I am removing this code and forcing each sessionsetup_and_X
177    * to get a new vuid.
178    * Jeremy Allison. (jallison@whistle.com).
179    */
180
181   int i;
182   for(i = 0; i < num_validated_users; i++) {
183     vuser = &validated_users[i];
184     if ( vuser->uid == uid )
185       return (uint16)(i + VUID_OFFSET); /* User already validated */
186   }
187 #endif
188
189   validated_users = (user_struct *)Realloc(validated_users,
190                            sizeof(user_struct)*
191                            (num_validated_users+1));
192   
193   if (!validated_users)
194     {
195       DEBUG(0,("Failed to realloc users struct!\n"));
196       num_validated_users = 0;
197       return UID_FIELD_INVALID;
198     }
199
200   vuser = &validated_users[num_validated_users];
201   num_validated_users++;
202
203   vuser->uid = uid;
204   vuser->gid = gid;
205   vuser->guest = guest;
206   fstrcpy(vuser->name,unix_name);
207   fstrcpy(vuser->requested_name,requested_name);
208   memcpy(vuser->dc.user_sess_key, user_sess_key, sizeof(vuser->dc.user_sess_key));
209
210   vuser->n_sids = 0;
211   vuser->sids   = NULL;
212
213   vuser->n_groups = 0;
214   vuser->groups  = NULL;
215
216   /* Find all the groups this uid is in and store them. 
217      Used by become_user() */
218   get_unixgroups(unix_name,uid,gid,
219                &vuser->n_groups,
220                &vuser->groups);
221
222   DEBUG(3,("uid %d registered to name %s\n",(int)uid,unix_name));
223
224   DEBUG(3, ("Clearing default real name\n"));
225   fstrcpy(vuser->real_name, "<Full Name>\0");
226   if (lp_unix_realname()) {
227     if ((pwfile=hashed_getpwnam(vuser->name))!= NULL)
228       {
229       DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->name,pwfile->pw_gecos));
230       fstrcpy(vuser->real_name, pwfile->pw_gecos);
231       }
232   }
233
234   return (uint16)((num_validated_users - 1) + VUID_OFFSET);
235 }
236
237
238 /****************************************************************************
239 add a name to the session users list
240 ****************************************************************************/
241 void add_session_user(char *user)
242 {
243   fstring suser;
244   StrnCpy(suser,user,sizeof(suser)-1);
245
246   if (!Get_Pwnam(suser,True)) return;
247
248   if (suser && *suser && !in_list(suser,session_users,False))
249     {
250       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
251         DEBUG(1,("Too many session users??\n"));
252       else
253         {
254           pstrcat(session_users," ");
255           pstrcat(session_users,suser);
256         }
257     }
258 }
259
260
261 /****************************************************************************
262 update the encrypted smbpasswd file from the plaintext username and password
263 *****************************************************************************/
264 static BOOL update_smbpassword_file(char *user, char *password)
265 {
266         struct smb_passwd *smbpw;
267         BOOL ret;
268         
269         become_root(0);
270         smbpw = getsmbpwnam(user);
271         unbecome_root(0);
272         
273         if(smbpw == NULL) {
274                 DEBUG(0,("getsmbpwnam returned NULL\n"));
275                 return False;
276         }
277  
278         /* Here, the flag is one, because we want to ignore the
279            XXXXXXX'd out password */
280         ret = change_oem_password( smbpw, password, True);
281         if (ret == False) {
282                 DEBUG(3,("change_oem_password returned False\n"));
283         }
284
285         return ret;
286 }
287
288
289
290
291
292 /****************************************************************************
293 core of smb password checking routine.
294 ****************************************************************************/
295 static BOOL smb_pwd_check_ntlmv1(char *password, unsigned char *part_passwd,
296                                 unsigned char *c8)
297 {
298   /* Finish the encryption of part_passwd. */
299   unsigned char p24[24];
300
301   if (part_passwd == NULL)
302     DEBUG(10,("No password set - allowing access\n"));
303   /* No password set - always true ! */
304   if (part_passwd == NULL)
305     return True;
306
307   SMBOWFencrypt(part_passwd, c8, p24);
308 #if DEBUG_PASSWORD
309         DEBUG(100,("Part password (P16) was |"));
310         dump_data(100, part_passwd, 16);
311         DEBUG(100,("Password from client was |"));
312         dump_data(100, password, 24);
313         DEBUG(100,("Given challenge was |"));
314         dump_data(100, c8, 8);
315         DEBUG(100,("Value from encryption was |"));
316         dump_data(100, p24, 24);
317 #endif
318   return (memcmp(p24, password, 24) == 0);
319 }
320
321 /****************************************************************************
322 core of smb password checking routine.
323 ****************************************************************************/
324 static BOOL smb_pwd_check_ntlmv2(char *password, size_t pwd_len,
325                                 unsigned char *part_passwd,
326                                 unsigned char const *c8,
327                                 const char *user, const char *domain)
328 {
329         /* Finish the encryption of part_passwd. */
330         unsigned char kr[16];
331
332         if (part_passwd == NULL)
333         {
334                 DEBUG(10,("No password set - allowing access\n"));
335         }
336         /* No password set - always true ! */
337         if (part_passwd == NULL)
338         {
339                 return True;
340         }
341
342         ntv2_owf_gen(part_passwd, user, domain, kr);
343         SMBOWFencrypt_ntv2(kr, c8, 8, password+16, pwd_len-16, kr);
344
345 #if DEBUG_PASSWORD
346         DEBUG(100,("Part password (P16) was |"));
347         dump_data(100, part_passwd, 16);
348         DEBUG(100,("Password from client was |"));
349         dump_data(100, password, pwd_len);
350         DEBUG(100,("Given challenge was |"));
351         dump_data(100, c8, 8);
352         DEBUG(100,("Value from encryption was |"));
353         dump_data(100, kr, 16);
354 #endif
355
356         return (memcmp(kr, password, 16) == 0);
357 }
358
359 /****************************************************************************
360  Do a specific test for an smb password being correct, given a smb_password and
361  the lanman and NT responses.
362 ****************************************************************************/
363 BOOL smb_password_ok(struct smb_passwd *smb_pass, uchar chal[8],
364                                 const char *user, const char *domain,
365                                 uchar *lm_pass, size_t lm_pwd_len,
366                                 uchar *nt_pass, size_t nt_pwd_len)
367 {
368         uchar challenge[8];
369
370         if (!lm_pass || !smb_pass) return(False);
371
372         DEBUG(4,("Checking SMB password for user %s\n", 
373                  smb_pass->unix_name));
374
375         if (smb_pass->acct_ctrl & ACB_DISABLED)
376         {
377                 DEBUG(3,("account for user %s was disabled.\n", 
378                          smb_pass->unix_name));
379                 return(False);
380         }
381
382         if (chal == NULL)
383         {
384                 DEBUG(5,("use last SMBnegprot challenge\n"));
385                 if (!last_challenge(challenge))
386                 {
387                         DEBUG(1,("no challenge done - password failed\n"));
388                         return False;
389                 }
390         }
391         else
392         {
393                 DEBUG(5,("challenge received\n"));
394                 memcpy(challenge, chal, 8);
395         }
396
397         if ((Protocol >= PROTOCOL_NT1) && (smb_pass->smb_nt_passwd != NULL))
398         {
399                 /* We have the NT MD4 hash challenge available - see if we can
400                    use it (ie. does it exist in the smbpasswd file).
401                 */
402                 if (lp_server_ntlmv2())
403                 {
404                         DEBUG(4,("smb_password_ok: Check NTLMv2 password\n"));
405                         if (smb_pwd_check_ntlmv2(nt_pass, nt_pwd_len,
406                                        (uchar *)smb_pass->smb_nt_passwd, 
407                                         challenge, user, domain))
408                         {
409                                 return True;
410                         }
411                 }
412                 if (lp_server_ntlmv2() != True && nt_pwd_len == 24)
413                 {
414                         DEBUG(4,("smb_password_ok: Check NT MD4 password\n"));
415                         if (smb_pwd_check_ntlmv1((char *)nt_pass, 
416                                        (uchar *)smb_pass->smb_nt_passwd, 
417                                        challenge))
418                         {
419                                 DEBUG(4,("NT MD4 password check succeeded\n"));
420                                 return True;
421                         }
422                 }
423                 DEBUG(4,("NT MD4 password check failed\n"));
424         }
425
426         if (lp_server_ntlmv2() == False)
427         {
428                 DEBUG(4,("Not checking LM MD4 password\n"));
429                 return False;
430         }
431
432         /* Try against the lanman password. smb_pass->smb_passwd == NULL means
433            no password, allow access. */
434
435         DEBUG(4,("Checking LM MD4 password\n"));
436
437         if ((smb_pass->smb_passwd == NULL) && 
438            (smb_pass->acct_ctrl & ACB_PWNOTREQ))
439         {
440                 DEBUG(4,("no password required for user %s\n",
441                          smb_pass->unix_name));
442                 return True;
443         }
444
445         if ((smb_pass->smb_passwd != NULL) && 
446            smb_pwd_check_ntlmv1((char *)lm_pass, 
447                               (uchar *)smb_pass->smb_passwd,
448                                 challenge))
449         {
450                 DEBUG(4,("LM MD4 password check succeeded\n"));
451                 return(True);
452         }
453
454         DEBUG(4,("LM MD4 password check failed\n"));
455
456         return False;
457 }
458
459
460 /****************************************************************************
461 check if a username/password is OK assuming the password is a 24 byte
462 SMB hash
463 return True if the password is correct, False otherwise
464 ****************************************************************************/
465
466 BOOL pass_check_smb(char *user, char *domain, uchar *chal,
467                 uchar *lm_pwd, size_t lm_pwd_len,
468                 uchar *nt_pwd, size_t nt_pwd_len,
469                 struct passwd *pwd, uchar user_sess_key[16])
470 {
471         const struct passwd *pass;
472         struct smb_passwd *smb_pass;
473
474         if (!lm_pwd || !nt_pwd)
475         {
476                 return(False);
477         }
478
479         if (pwd != NULL && user == NULL)
480         {
481                 pass = (struct passwd *) pwd;
482                 user = pass->pw_name;
483         }
484         else
485         {
486                 pass = Get_Pwnam(user,True);
487         }
488
489         if (pass == NULL)
490         {
491                 DEBUG(3,("Couldn't find user %s\n",user));
492                 return(False);
493         }
494
495         smb_pass = getsmbpwnam(user);
496
497         if (smb_pass == NULL)
498         {
499                 DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
500                 return(False);
501         }
502
503         /* Quit if the account was disabled. */
504         if(smb_pass->acct_ctrl & ACB_DISABLED) {
505                 DEBUG(3,("account for user %s was disabled.\n", user));
506                 return(False);
507         }
508
509         /* Ensure the uid's match */
510         if (smb_pass->unix_uid != pass->pw_uid)
511         {
512                 DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
513                 return(False);
514         }
515
516         if (lm_pwd[0] == '\0' && IS_BITS_SET_ALL(smb_pass->acct_ctrl, ACB_PWNOTREQ) && lp_null_passwords())
517         {
518                 DEBUG(3,("account for user %s has no password and null passwords are allowed.\n", smb_pass->unix_name));
519                 return(True);
520         }
521
522         if (smb_password_ok(smb_pass, chal, user, domain,
523                                             lm_pwd, lm_pwd_len,
524                                             nt_pwd, nt_pwd_len))
525         {
526                 if (user_sess_key != NULL)
527                 {
528                         mdfour(user_sess_key, smb_pass->smb_nt_passwd, 16);
529 #ifdef DEBUG_PASSWORD
530                 DEBUG(100,("user session key: "));
531                 dump_data(100, user_sess_key, 16);
532 #endif
533                 }
534                 return(True);
535         }
536         
537         DEBUG(3,("Error pass_check_smb failed\n"));
538         return False;
539 }
540
541 /****************************************************************************
542 check if a username/password pair is OK either via the system password
543 database or the encrypted SMB password database
544 return True if the password is correct, False otherwise
545 ****************************************************************************/
546 BOOL password_ok(char *user, char *password, int pwlen, struct passwd *pwd,
547                 uchar user_sess_key[16])
548 {
549         if (pwlen >= 24 || (lp_encrypted_passwords() && (pwlen == 0) && lp_null_passwords()))
550         {
551                 /* if 24 bytes or longer assume it is an encrypted password */
552                 uchar challenge[8];
553
554                 if (!last_challenge(challenge))
555                 {
556                         DEBUG(0,("Error: challenge not done for user=%s\n", user));
557                         return False;
558                 }
559
560                 return pass_check_smb(user, global_myworkgroup,
561                                       challenge, (uchar *)password,
562                                         pwlen, (uchar *)password, pwlen,
563                                         pwd, user_sess_key);
564         } 
565
566         return pass_check(user, password, pwlen, pwd, 
567                           lp_update_encrypted() ? 
568                           update_smbpassword_file : NULL);
569 }
570
571 /****************************************************************************
572 check if a username is valid
573 ****************************************************************************/
574 BOOL user_ok(char *user,int snum)
575 {
576         pstring valid, invalid;
577         BOOL ret;
578
579         StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
580         StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
581
582         string_sub(valid,"%S",lp_servicename(snum));
583         string_sub(invalid,"%S",lp_servicename(snum));
584         
585         ret = !user_in_list(user,invalid);
586         
587         if (ret && valid && *valid) {
588                 ret = user_in_list(user,valid);
589         }
590
591         if (ret && lp_onlyuser(snum)) {
592                 char *user_list = lp_username(snum);
593                 string_sub(user_list,"%S",lp_servicename(snum));
594                 ret = user_in_list(user,user_list);
595         }
596
597         return(ret);
598 }
599
600
601
602
603 /****************************************************************************
604 validate a group username entry. Return the username or NULL
605 ****************************************************************************/
606 static char *validate_group(char *group,char *password,int pwlen,int snum,
607                                 uchar user_sess_key[16])
608 {
609 #if defined(HAVE_NETGROUP) && defined(HAVE_GETNETGRENT) && defined(HAVE_SETNETGRENT) && defined(HAVE_ENDNETGRENT)
610   {
611     char *host, *user, *domain;
612     setnetgrent(group);
613     while (getnetgrent(&host, &user, &domain)) {
614       if (user) {
615         if (user_ok(user, snum) && 
616             password_ok(user,password,pwlen,NULL, user_sess_key)) {
617           endnetgrent();
618           return(user);
619         }
620       }
621     }
622     endnetgrent();
623   }
624 #endif
625   
626 #ifdef HAVE_GETGRNAM 
627   {
628     struct group *gptr = (struct group *)getgrnam(group);
629     char **member;
630     if (gptr)
631       {
632         member = gptr->gr_mem;
633         while (member && *member)
634           {
635             static fstring name;
636             fstrcpy(name,*member);
637             if (user_ok(name,snum) &&
638                 password_ok(name,password,pwlen,NULL, user_sess_key))
639               return(&name[0]);
640             member++;
641           }
642 #ifdef GROUP_CHECK_PWENT
643         {
644           struct passwd *pwd;
645           static fstring tm;
646           
647           setpwent ();
648           while (pwd = getpwent ()) {
649             if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
650               /* This Entry have PASSWORD and same GID then check pwd */
651               if (password_ok(NULL, password, pwlen, pwd, user_sess_key)) {
652                 fstrcpy(tm, pwd->pw_name);
653                 endpwent ();
654                 return tm;
655               }
656             }
657           }
658           endpwent ();
659         }
660 #endif /* GROUP_CHECK_PWENT */
661       }
662   }      
663 #endif
664   return(NULL);
665 }
666
667
668
669 /****************************************************************************
670 check for authority to login to a service with a given username/password
671 ****************************************************************************/
672 BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
673                      BOOL *guest,BOOL *force,uint16 vuid)
674 {
675   BOOL ok = False;
676   
677   *guest = False;
678   
679 #if DEBUG_PASSWORD
680   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
681 #endif
682
683   /* there are several possibilities:
684      1) login as the given user with given password
685      2) login as a previously registered username with the given password
686      3) login as a session list username with the given password
687      4) login as a previously validated user/password pair
688      5) login as the "user =" user with given password
689      6) login as the "user =" user with no password (guest connection)
690      7) login as guest user with no password
691
692      if the service is guest_only then steps 1 to 5 are skipped
693   */
694
695   if (GUEST_ONLY(snum)) *force = True;
696
697   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
698     {
699
700       user_struct *vuser = get_valid_user_struct(vuid);
701
702       /* check the given username and password */
703       if (!ok && (*user) && user_ok(user,snum)) {
704         ok = password_ok(user,password, pwlen, NULL, vuser->dc.user_sess_key);
705         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
706       }
707
708       /* check for a previously registered guest username */
709       if (!ok && (vuser != 0) && vuser->guest) {          
710         if (user_ok(vuser->name,snum) &&
711             password_ok(vuser->name, password, pwlen, NULL, vuser->dc.user_sess_key)) {
712           fstrcpy(user, vuser->name);
713           vuser->guest = False;
714           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
715           ok = True;
716         }
717       }
718
719
720       /* now check the list of session users */
721     if (!ok)
722     {
723       char *auser;
724       char *user_list = strdup(session_users);
725       if (!user_list) return(False);
726
727       for (auser=strtok(user_list,LIST_SEP); 
728            !ok && auser; 
729            auser = strtok(NULL,LIST_SEP))
730       {
731         fstring user2;
732         fstrcpy(user2,auser);
733         if (!user_ok(user2,snum)) continue;
734                   
735         if (password_ok(user2,password, pwlen, NULL, vuser->dc.user_sess_key)) {
736           ok = True;
737           fstrcpy(user,user2);
738           DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
739         }
740       }
741       free(user_list);
742     }
743
744     /* check for a previously validated username/password pair */
745     if (!ok && (!lp_revalidate(snum) || lp_security() > SEC_SHARE) &&
746         (vuser != 0) && !vuser->guest &&
747         user_ok(vuser->name,snum)) {
748       fstrcpy(user,vuser->name);
749       *guest = False;
750       DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
751       ok = True;
752     }
753
754       /* check for a rhosts entry */
755       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
756         ok = True;
757         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
758       }
759
760       /* check the user= fields and the given password */
761       if (!ok && lp_username(snum)) {
762         char *auser;
763         pstring user_list;
764         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
765
766         string_sub(user_list,"%S",lp_servicename(snum));
767           
768         for (auser=strtok(user_list,LIST_SEP);
769              auser && !ok;
770              auser = strtok(NULL,LIST_SEP))
771           {
772             if (*auser == '@')
773               {
774                 auser = validate_group(auser+1,password,pwlen,snum, vuser->dc.user_sess_key);
775                 if (auser)
776                   {
777                     ok = True;
778                     fstrcpy(user,auser);
779                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
780                   }
781               }
782             else
783               {
784                 fstring user2;
785                 fstrcpy(user2,auser);
786                 if (user_ok(user2,snum) && 
787                     password_ok(user2,password,pwlen,NULL, vuser->dc.user_sess_key))
788                   {
789                     ok = True;
790                     fstrcpy(user,user2);
791                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
792                   }
793               }
794           }
795       }      
796     } /* not guest only */
797
798   /* check for a normal guest connection */
799   if (!ok && GUEST_OK(snum))
800     {
801       fstring guestname;
802       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
803       if (Get_Pwnam(guestname,True))
804         {
805           fstrcpy(user,guestname);
806           ok = True;
807           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
808         }
809       else
810         DEBUG(0,("Invalid guest account %s??\n",guestname));
811       *guest = True;
812       *force = True;
813     }
814
815   if (ok && !user_ok(user,snum))
816     {
817       DEBUG(0,("rejected invalid user %s\n",user));
818       ok = False;
819     }
820
821   return(ok);
822 }
823
824
825 /****************************************************************************
826 read the a hosts.equiv or .rhosts file and check if it
827 allows this user from this machine
828 ****************************************************************************/
829 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
830 {
831   pstring buf;
832   int plus_allowed = 1;
833   char *file_host;
834   char *file_user;
835   FILE *fp = sys_fopen(equiv_file, "r");
836   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
837   if (! fp) return False;
838   while(fgets(buf, sizeof(buf), fp)) 
839   {
840     trim_string(buf," "," ");
841
842     if (buf[0] != '#' && buf[0] != '\n') 
843     {
844       BOOL is_group = False;
845       int plus = 1;
846       char *bp = buf;
847       if (strcmp(buf, "NO_PLUS\n") == 0)
848       {
849         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
850         plus_allowed = 0;
851       }
852       else {
853         if (buf[0] == '+') 
854         {
855           bp++;
856           if (*bp == '\n' && plus_allowed) 
857           {
858             /* a bare plus means everbody allowed */
859             DEBUG(6, ("check_user_equiv everybody allowed\n"));
860             fclose(fp);
861             return True;
862           }
863         }
864         else if (buf[0] == '-')
865         {
866           bp++;
867           plus = 0;
868         }
869         if (*bp == '@') 
870         {
871           is_group = True;
872           bp++;
873         }
874         file_host = strtok(bp, " \t\n");
875         file_user = strtok(NULL, " \t\n");
876         DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)", 
877                  file_user ? file_user : "(null)" ));
878         if (file_host && *file_host) 
879         {
880           BOOL host_ok = False;
881
882 #if defined(HAVE_NETGROUP) && defined(HAVE_YP_GET_DEFAULT_DOMAIN)
883           if (is_group)
884             {
885               static char *mydomain = NULL;
886               if (!mydomain)
887                 yp_get_default_domain(&mydomain);
888               if (mydomain && innetgr(file_host,remote,user,mydomain))
889                 host_ok = True;
890             }
891 #else
892           if (is_group)
893             {
894               DEBUG(1,("Netgroups not configured\n"));
895               continue;
896             }
897 #endif
898
899           /* is it this host */
900           /* the fact that remote has come from a call of gethostbyaddr
901            * means that it may have the fully qualified domain name
902            * so we could look up the file version to get it into
903            * a canonical form, but I would rather just type it
904            * in full in the equiv file
905            */
906           if (!host_ok && !is_group && strequal(remote, file_host))
907             host_ok = True;
908
909           if (!host_ok)
910             continue;
911
912           /* is it this user */
913           if (file_user == 0 || strequal(user, file_user)) 
914             {
915               fclose(fp);
916               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
917                         (plus ? "+" : "-"), file_host,
918                         (file_user ? file_user : "")));
919               return (plus ? True : False);
920             }
921         }
922       }
923     }
924   }
925   fclose(fp);
926   return False;
927 }
928
929
930 /****************************************************************************
931 check for a possible hosts equiv or rhosts entry for the user
932 ****************************************************************************/
933 BOOL check_hosts_equiv(char *user)
934 {
935   char *fname = NULL;
936   pstring rhostsfile;
937   const struct passwd *pass = Get_Pwnam(user,True);
938
939   if (!pass) 
940     return(False);
941
942   fname = lp_hosts_equiv();
943
944   /* note: don't allow hosts.equiv on root */
945   if (fname && *fname && (pass->pw_uid != 0)) {
946           extern int Client;
947           if (check_user_equiv(user,client_name(Client),fname))
948                   return(True);
949   }
950   
951   if (lp_use_rhosts())
952     {
953       char *home = get_home_dir(user);
954       if (home) {
955               extern int Client;
956               slprintf(rhostsfile, sizeof(rhostsfile)-1, "%s/.rhosts", home);
957               if (check_user_equiv(user,client_name(Client),rhostsfile))
958                       return(True);
959       }
960     }
961
962   return(False);
963 }
964
965
966 /****************************************************************************
967 return the client state structure
968 ****************************************************************************/
969 struct cli_state *server_client(void)
970 {
971         static struct cli_state pw_cli;
972         return &pw_cli;
973 }
974
975 /****************************************************************************
976 support for server level security 
977 ****************************************************************************/
978 struct cli_state *server_cryptkey(void)
979 {
980         if (cli_connect_serverlist(server_client(), lp_passwordserver()))
981         {
982                 return server_client();
983         }
984         return NULL;
985 }
986
987 /****************************************************************************
988 validate a password with the password server
989 ****************************************************************************/
990 BOOL server_validate(char *user, char *domain, 
991                      char *pass, int passlen,
992                      char *ntpass, int ntpasslen)
993 {
994   struct cli_state *cli;
995   static unsigned char badpass[24];
996   static BOOL tested_password_server = False;
997   static BOOL bad_password_server = False;
998
999   cli = server_client();
1000
1001   if (!cli->initialised) {
1002     DEBUG(1,("password server %s is not connected\n", cli->desthost));
1003     return(False);
1004   }  
1005
1006   if(badpass[0] == 0)
1007     memset(badpass, 0x1f, sizeof(badpass));
1008
1009   if((passlen == sizeof(badpass)) && !memcmp(badpass, pass, passlen)) {
1010     /* 
1011      * Very unlikely, our random bad password is the same as the users
1012      * password. */
1013     memset(badpass, badpass[0]+1, sizeof(badpass));
1014   }
1015
1016   /*
1017    * Attempt a session setup with a totally incorrect password.
1018    * If this succeeds with the guest bit *NOT* set then the password
1019    * server is broken and is not correctly setting the guest bit. We
1020    * need to detect this as some versions of NT4.x are broken. JRA.
1021    */
1022
1023   if(!tested_password_server) {
1024     if (cli_session_setup(cli, user, (char *)badpass, sizeof(badpass), 
1025                               (char *)badpass, sizeof(badpass), domain)) {
1026
1027       /*
1028        * We connected to the password server so we
1029        * can say we've tested it.
1030        */
1031       tested_password_server = True;
1032
1033       if ((SVAL(cli->inbuf,smb_vwv2) & 1) == 0) {
1034         DEBUG(0,("server_validate: password server %s allows users as non-guest \
1035 with a bad password.\n", cli->desthost));
1036         DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1037 use this machine as the password server.\n"));
1038         cli_ulogoff(cli);
1039
1040         /*
1041          * Password server has the bug.
1042          */
1043         bad_password_server = True;
1044         return False;
1045       }
1046       cli_ulogoff(cli);
1047     }
1048   } else {
1049
1050     /*
1051      * We have already tested the password server.
1052      * Fail immediately if it has the bug.
1053      */
1054
1055     if(bad_password_server) {
1056       DEBUG(0,("server_validate: [1] password server %s allows users as non-guest \
1057 with a bad password.\n", cli->desthost));
1058       DEBUG(0,("server_validate: [1] This is broken (and insecure) behaviour. Please do not \
1059 use this machine as the password server.\n"));
1060       return False;
1061     }
1062   }
1063
1064   /*
1065    * Now we know the password server will correctly set the guest bit, or is
1066    * not guest enabled, we can try with the real password.
1067    */
1068
1069   if (!cli_session_setup(cli, user, pass, passlen, ntpass, ntpasslen, domain)) {
1070     DEBUG(1,("password server %s rejected the password\n", cli->desthost));
1071     return False;
1072   }
1073
1074   /* if logged in as guest then reject */
1075   if ((SVAL(cli->inbuf,smb_vwv2) & 1) != 0) {
1076     DEBUG(1,("password server %s gave us guest only\n", cli->desthost));
1077     cli_ulogoff(cli);
1078     return(False);
1079   }
1080
1081
1082   cli_ulogoff(cli);
1083
1084   return(True);
1085 }
1086
1087 /***********************************************************************
1088  Do the same as security=server, but using NT Domain calls and a session
1089  key from the workstation trust account password.
1090 ************************************************************************/
1091
1092 BOOL domain_client_validate( char *user, char *domain, 
1093                              char *smb_apasswd, int smb_apasslen, 
1094                              char *smb_ntpasswd, int smb_ntpasslen)
1095 {
1096         uint16 nt_pipe_fnum;
1097         unsigned char local_challenge[8];
1098         unsigned char local_lm_response[24];
1099         unsigned char local_nt_reponse[24];
1100         unsigned char trust_passwd[16];
1101         NET_ID_INFO_CTR ctr;
1102         NET_USER_INFO_3 info3;
1103         struct cli_state cli;
1104         uint32 smb_uid_low;
1105
1106         /* 
1107         * Check that the requested domain is not our own machine name.
1108         * If it is, we should never check the PDC here, we use our own local
1109         * password file.
1110         */
1111
1112         if(strequal( domain, global_myname))
1113         {
1114                 DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1115                 return False;
1116         }
1117
1118         /*
1119         * Next, check that the passwords given were encrypted.
1120         */
1121
1122         if(((smb_apasslen  != 24) && (smb_apasslen  != 0)) || 
1123            ((smb_ntpasslen != 24) && (smb_ntpasslen != 0)))
1124         {
1125                 /*
1126                  * Not encrypted - do so.
1127                  */
1128
1129                 DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1130                 generate_random_buffer( local_challenge, 8, False);
1131                 SMBencrypt( (uchar *)smb_apasswd, local_challenge, local_lm_response);
1132                 SMBNTencrypt((uchar *)smb_ntpasswd, local_challenge, local_nt_reponse);
1133                 smb_apasslen = 24;
1134                 smb_ntpasslen = 24;
1135                 smb_apasswd = (char *)local_lm_response;
1136                 smb_ntpasswd = (char *)local_nt_reponse;
1137         }
1138         else
1139         {
1140                 /*
1141                  * Encrypted - get the challenge we sent for these
1142                  * responses.
1143                  */
1144
1145                 if (!last_challenge(local_challenge))
1146                 {
1147                         DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1148                         return False;
1149                 }
1150         }
1151
1152         /*
1153          * Get the workstation trust account password.
1154          */
1155         if (!trust_get_passwd( trust_passwd, global_myworkgroup, global_myname))
1156         {
1157                 return False;
1158         }
1159
1160         /*
1161          * At this point, smb_apasswd points to the lanman response to
1162          * the challenge in local_challenge, and smb_ntpasswd points to
1163          * the NT response to the challenge in local_challenge. Ship
1164          * these over the secure channel to a domain controller and
1165          * see if they were valid.
1166          */
1167
1168         if (!cli_connect_serverlist(&cli, lp_passwordserver()))
1169         {
1170                 DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
1171                 return False;
1172         }
1173
1174         /*
1175         * Ok - we have an anonymous connection to the IPC$ share.
1176         * Now start the NT Domain stuff :-).
1177         */
1178
1179         if(cli_nt_session_open(&cli, PIPE_NETLOGON, &nt_pipe_fnum) == False) {
1180         DEBUG(0,("domain_client_validate: unable to open the domain client session to \
1181         machine %s. Error was : %s.\n", cli.desthost, cli_errstr(&cli)));
1182         cli_nt_session_close(&cli, nt_pipe_fnum);
1183         cli_ulogoff(&cli);
1184         cli_shutdown(&cli);
1185         return False; 
1186         }
1187
1188         if(cli_nt_setup_creds(&cli, nt_pipe_fnum,
1189            cli.mach_acct, trust_passwd, SEC_CHAN_WKSTA) == False)
1190         {
1191                 DEBUG(0,("domain_client_validate: unable to setup the PDC credentials to machine \
1192                 %s. Error was : %s.\n", cli.desthost, cli_errstr(&cli)));
1193                 cli_nt_session_close(&cli, nt_pipe_fnum);
1194                 cli_ulogoff(&cli);
1195                 cli_shutdown(&cli);
1196                 return False;
1197         }
1198
1199         /* We really don't care what LUID we give the user. */
1200         generate_random_buffer( (unsigned char *)&smb_uid_low, 4, False);
1201
1202         if (!cli_nt_login_network(&cli, nt_pipe_fnum, domain, user, smb_uid_low, (char *)local_challenge,
1203         ((smb_apasslen != 0) ? smb_apasswd : NULL),
1204         ((smb_ntpasslen != 0) ? smb_ntpasswd : NULL),
1205         &ctr, &info3))
1206         {
1207                 DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
1208                 %s to Domain controller %s. Error was %s.\n", user, domain, cli.desthost, cli_errstr(&cli)));
1209                 cli_nt_session_close(&cli, nt_pipe_fnum);
1210                 cli_ulogoff(&cli);
1211                 cli_shutdown(&cli);
1212                 return False;
1213         }
1214
1215         /*
1216          * Here, if we really want it, we have lots of info about the user in info3.
1217          * LKCLXXXX - really important to check things like "is this user acct
1218          * locked out / disabled" etc!!!!
1219          */
1220
1221 #if 0
1222         /* 
1223         * We don't actually need to do this - plus it fails currently with
1224         * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
1225         * send here. JRA.
1226         */
1227
1228         if (!cli_nt_logoff(&cli, nt_pipe_fnum, &ctr))
1229         {
1230                 DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
1231                 %s to Domain controller %s. Error was %s.\n", user, domain, cli.desthost, cli_errstr(&cli)));        
1232                 cli_nt_session_close(&cli, nt_pipe_fnum);
1233                 cli_ulogoff(&cli);
1234                 cli_shutdown(&cli);
1235                 return False;
1236         }
1237 #endif /* 0 */
1238
1239         cli_nt_session_close(&cli, nt_pipe_fnum);
1240         cli_ulogoff(&cli);
1241         cli_shutdown(&cli);
1242         return True;
1243 }