- dce/rpc code
[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 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 Setup the groups a user belongs to.
155 ****************************************************************************/
156 int setup_groups(char *user, uid_t uid, gid_t gid, int *p_ngroups, gid_t **p_groups)
157 {
158         int i,ngroups;
159         gid_t grp = 0;
160         gid_t *groups = NULL;
161
162         if (-1 == initgroups(user,gid))
163         {
164                 if (getuid() == 0)
165                 {
166                         DEBUG(0,("Unable to initgroups!\n"));
167                         if (gid < 0 || gid > 16000 || uid < 0 || uid > 16000)
168                         {
169                                 DEBUG(0,("This is probably a problem with the account %s\n", user));
170                         }
171                 }
172                 return -1;
173         }
174
175         ngroups = sys_getgroups(0,&grp);
176         if (ngroups <= 0)
177         {
178                 ngroups = 32;
179         }
180
181         if((groups = (gid_t *)malloc(sizeof(gid_t)*ngroups)) == NULL)
182         {
183                 DEBUG(0,("setup_groups malloc fail !\n"));
184                 return -1;
185         }
186
187         ngroups = sys_getgroups(ngroups,groups);
188
189         (*p_ngroups) = ngroups;
190         (*p_groups) = groups;
191
192         DEBUG( 3, ( "%s is in %d groups: ", user, ngroups ) );
193         for (i = 0; i < ngroups; i++ )
194         {
195                 DEBUG( 3, ( "%s%d", (i ? ", " : ""), (int)groups[i] ) );
196         }
197         DEBUG( 3, ( "\n" ) );
198
199         return 0;
200 }
201
202
203 /****************************************************************************
204 register a uid/name pair as being valid and that a valid password
205 has been given. vuid is biased by an offset. This allows us to
206 tell random client vuid's (normally zero) from valid vuids.
207 ****************************************************************************/
208 uint16 register_vuid(uid_t uid,gid_t gid, char *unix_name, char *requested_name, BOOL guest)
209 {
210   user_struct *vuser;
211   struct passwd *pwfile; /* for getting real name from passwd file */
212
213   /* Ensure no vuid gets registered in share level security. */
214   if(lp_security() == SEC_SHARE)
215     return UID_FIELD_INVALID;
216
217 #if 0
218   /*
219    * After observing MS-Exchange services writing to a Samba share
220    * I belive this code is incorrect. Each service does its own
221    * sessionsetup_and_X for the same user, and as each service shuts
222    * down, it does a user_logoff_and_X. As we are consolidating multiple
223    * sessionsetup_and_X's onto the same vuid here, when the first service
224    * shuts down, it invalidates all the open files for the other services.
225    * Hence I am removing this code and forcing each sessionsetup_and_X
226    * to get a new vuid.
227    * Jeremy Allison. (jallison@whistle.com).
228    */
229
230   int i;
231   for(i = 0; i < num_validated_users; i++) {
232     vuser = &validated_users[i];
233     if ( vuser->uid == uid )
234       return (uint16)(i + VUID_OFFSET); /* User already validated */
235   }
236 #endif
237
238   validated_users = (user_struct *)Realloc(validated_users,
239                            sizeof(user_struct)*
240                            (num_validated_users+1));
241   
242   if (!validated_users)
243     {
244       DEBUG(0,("Failed to realloc users struct!\n"));
245       num_validated_users = 0;
246       return UID_FIELD_INVALID;
247     }
248
249   vuser = &validated_users[num_validated_users];
250   num_validated_users++;
251
252   vuser->uid = uid;
253   vuser->gid = gid;
254   vuser->guest = guest;
255   fstrcpy(vuser->name,unix_name);
256   fstrcpy(vuser->requested_name,requested_name);
257
258   vuser->n_sids = 0;
259   vuser->sids   = NULL;
260
261   vuser->n_groups = 0;
262   vuser->groups  = NULL;
263
264   /* Find all the groups this uid is in and store them. 
265      Used by become_user() */
266   setup_groups(unix_name,uid,gid,
267                &vuser->n_groups,
268                &vuser->groups);
269
270   DEBUG(3,("uid %d registered to name %s\n",(int)uid,unix_name));
271
272   DEBUG(3, ("Clearing default real name\n"));
273   fstrcpy(vuser->real_name, "<Full Name>\0");
274   if (lp_unix_realname()) {
275     if ((pwfile=getpwnam(vuser->name))!= NULL)
276       {
277       DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->name,pwfile->pw_gecos));
278       fstrcpy(vuser->real_name, pwfile->pw_gecos);
279       }
280   }
281
282   return (uint16)((num_validated_users - 1) + VUID_OFFSET);
283 }
284
285
286 /****************************************************************************
287 add a name to the session users list
288 ****************************************************************************/
289 void add_session_user(char *user)
290 {
291   fstring suser;
292   StrnCpy(suser,user,sizeof(suser)-1);
293
294   if (!Get_Pwnam(suser,True)) return;
295
296   if (suser && *suser && !in_list(suser,session_users,False))
297     {
298       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
299         DEBUG(1,("Too many session users??\n"));
300       else
301         {
302           pstrcat(session_users," ");
303           pstrcat(session_users,suser);
304         }
305     }
306 }
307
308
309 /****************************************************************************
310 update the encrypted smbpasswd file from the plaintext username and password
311 *****************************************************************************/
312 static BOOL update_smbpassword_file(char *user, char *password)
313 {
314         struct smb_passwd *smbpw;
315         BOOL ret;
316         
317         become_root(0);
318         smbpw = getsmbpwnam(user);
319         unbecome_root(0);
320         
321         if(smbpw == NULL) {
322                 DEBUG(0,("getsmbpwnam returned NULL\n"));
323                 return False;
324         }
325  
326         /* Here, the flag is one, because we want to ignore the
327            XXXXXXX'd out password */
328         ret = change_oem_password( smbpw, password, True);
329         if (ret == False) {
330                 DEBUG(3,("change_oem_password returned False\n"));
331         }
332
333         return ret;
334 }
335
336
337
338
339
340 /****************************************************************************
341 core of smb password checking routine.
342 ****************************************************************************/
343 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
344 {
345   /* Finish the encryption of part_passwd. */
346   unsigned char p21[21];
347   unsigned char p24[24];
348
349   if (part_passwd == NULL)
350     DEBUG(10,("No password set - allowing access\n"));
351   /* No password set - always true ! */
352   if (part_passwd == NULL)
353     return 1;
354
355   memset(p21,'\0',21);
356   memcpy(p21,part_passwd,16);
357   E_P24(p21, c8, p24);
358 #if DEBUG_PASSWORD
359   {
360     int i;
361     DEBUG(100,("Part password (P16) was |"));
362     for(i = 0; i < 16; i++)
363       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
364     DEBUG(100,("|\n"));
365     DEBUG(100,("Password from client was |"));
366     for(i = 0; i < 24; i++)
367       DEBUG(100,("%X ", (unsigned char)password[i]));
368     DEBUG(100,("|\n"));
369     DEBUG(100,("Given challenge was |"));
370     for(i = 0; i < 8; i++)
371       DEBUG(100,("%X ", (unsigned char)c8[i]));
372     DEBUG(100,("|\n"));
373     DEBUG(100,("Value from encryption was |"));
374     for(i = 0; i < 24; i++)
375       DEBUG(100,("%X ", (unsigned char)p24[i]));
376     DEBUG(100,("|\n"));
377   }
378 #endif
379   return (memcmp(p24, password, 24) == 0);
380 }
381
382 /****************************************************************************
383  Do a specific test for an smb password being correct, given a smb_password and
384  the lanman and NT responses.
385 ****************************************************************************/
386 BOOL smb_password_ok(struct smb_passwd *smb_pass, uchar chal[8],
387                      uchar lm_pass[24], uchar nt_pass[24])
388 {
389         uchar challenge[8];
390
391         if (!lm_pass || !smb_pass) return(False);
392
393         DEBUG(4,("Checking SMB password for user %s\n", 
394                  smb_pass->smb_name));
395
396         if(smb_pass->acct_ctrl & ACB_DISABLED) {
397                 DEBUG(3,("account for user %s was disabled.\n", 
398                          smb_pass->smb_name));
399                 return(False);
400         }
401
402         if (chal == NULL)
403         {
404                 DEBUG(5,("use last SMBnegprot challenge\n"));
405                 if (!last_challenge(challenge))
406                 {
407                         DEBUG(1,("no challenge done - password failed\n"));
408                         return False;
409                 }
410         }
411         else
412         {
413                 DEBUG(5,("challenge received\n"));
414                 memcpy(challenge, chal, 8);
415         }
416
417         if ((Protocol >= PROTOCOL_NT1) && (smb_pass->smb_nt_passwd != NULL)) {
418                 /* We have the NT MD4 hash challenge available - see if we can
419                    use it (ie. does it exist in the smbpasswd file).
420                 */
421                 DEBUG(4,("smb_password_ok: Checking NT MD4 password\n"));
422                 if (smb_password_check((char *)nt_pass, 
423                                        (uchar *)smb_pass->smb_nt_passwd, 
424                                        challenge)) {
425                         DEBUG(4,("NT MD4 password check succeeded\n"));
426                         return(True);
427                 }
428                 DEBUG(4,("NT MD4 password check failed\n"));
429         }
430
431         /* Try against the lanman password. smb_pass->smb_passwd == NULL means
432            no password, allow access. */
433
434         DEBUG(4,("Checking LM MD4 password\n"));
435
436         if((smb_pass->smb_passwd == NULL) && 
437            (smb_pass->acct_ctrl & ACB_PWNOTREQ)) {
438                 DEBUG(4,("no password required for user %s\n",
439                          smb_pass->smb_name));
440                 return True;
441         }
442
443         if((smb_pass->smb_passwd != NULL) && 
444            smb_password_check((char *)lm_pass, 
445                               (uchar *)smb_pass->smb_passwd, challenge)) {
446                 DEBUG(4,("LM MD4 password check succeeded\n"));
447                 return(True);
448         }
449
450         DEBUG(4,("LM MD4 password check failed\n"));
451
452         return False;
453 }
454
455
456 /****************************************************************************
457 check if a username/password is OK assuming the password is a 24 byte
458 SMB hash
459 return True if the password is correct, False otherwise
460 ****************************************************************************/
461 BOOL pass_check_smb(char *user, char *domain,
462                 uchar *chal, char *lm_pwd, char *nt_pwd,
463                 struct passwd *pwd)
464 {
465         struct passwd *pass;
466         struct smb_passwd *smb_pass;
467
468         if (!lm_pwd || !nt_pwd)
469         {
470                 return(False);
471         }
472
473         if (pwd != NULL && user == NULL)
474         {
475                 pass = (struct passwd *) pwd;
476                 user = pass->pw_name;
477         }
478         else
479         {
480                 pass = Get_Pwnam(user,True);
481         }
482
483         if (pass == NULL)
484         {
485                 DEBUG(3,("Couldn't find user %s\n",user));
486                 return(False);
487         }
488
489         smb_pass = getsmbpwnam(user);
490
491         if (smb_pass == NULL)
492         {
493                 DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
494                 return(False);
495         }
496
497         /* Quit if the account was disabled. */
498         if(smb_pass->acct_ctrl & ACB_DISABLED) {
499                 DEBUG(3,("account for user %s was disabled.\n", user));
500                 return(False);
501         }
502
503         /* Ensure the uid's match */
504         if (smb_pass->smb_userid != pass->pw_uid)
505         {
506                 DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
507                 return(False);
508         }
509
510         if (lm_pwd[0] == '\0' && IS_BITS_SET_ALL(smb_pass->acct_ctrl, ACB_PWNOTREQ) && lp_null_passwords())
511         {
512                 DEBUG(3,("account for user %s has no password and null passwords are allowed.\n", smb_pass->smb_name));
513                 return(True);
514         }
515
516         if (smb_password_ok(smb_pass, chal, (uchar *)lm_pwd, (uchar *)nt_pwd))
517         {
518                 return(True);
519         }
520         
521         DEBUG(3,("Error smb_password_check failed\n"));
522         return False;
523 }
524
525 /****************************************************************************
526 check if a username/password pair is OK either via the system password
527 database or the encrypted SMB password database
528 return True if the password is correct, False otherwise
529 ****************************************************************************/
530 BOOL password_ok(char *user, char *password, int pwlen, struct passwd *pwd)
531 {
532         if (pwlen == 24 || (lp_encrypted_passwords() && (pwlen == 0) && lp_null_passwords()))
533         {
534                 /* if 24 bytes long assume it is an encrypted password */
535                 uchar challenge[8];
536
537                 if (!last_challenge(challenge))
538                 {
539                         DEBUG(0,("Error: challenge not done for user=%s\n", user));
540                         return False;
541                 }
542
543                 return pass_check_smb(user, global_myworkgroup,
544                                       challenge, password, password, pwd);
545         } 
546
547         return pass_check(user, password, pwlen, pwd, 
548                           lp_update_encrypted() ? 
549                           update_smbpassword_file : NULL);
550 }
551
552 /****************************************************************************
553 check if a username is valid
554 ****************************************************************************/
555 BOOL user_ok(char *user,int snum)
556 {
557         pstring valid, invalid;
558         BOOL ret;
559
560         StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
561         StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
562
563         string_sub(valid,"%S",lp_servicename(snum));
564         string_sub(invalid,"%S",lp_servicename(snum));
565         
566         ret = !user_in_list(user,invalid);
567         
568         if (ret && valid && *valid) {
569                 ret = user_in_list(user,valid);
570         }
571
572         if (ret && lp_onlyuser(snum)) {
573                 char *user_list = lp_username(snum);
574                 string_sub(user_list,"%S",lp_servicename(snum));
575                 ret = user_in_list(user,user_list);
576         }
577
578         return(ret);
579 }
580
581
582
583
584 /****************************************************************************
585 validate a group username entry. Return the username or NULL
586 ****************************************************************************/
587 static char *validate_group(char *group,char *password,int pwlen,int snum)
588 {
589 #ifdef HAVE_NETGROUP
590   {
591     char *host, *user, *domain;
592     setnetgrent(group);
593     while (getnetgrent(&host, &user, &domain)) {
594       if (user) {
595         if (user_ok(user, snum) && 
596             password_ok(user,password,pwlen,NULL)) {
597           endnetgrent();
598           return(user);
599         }
600       }
601     }
602     endnetgrent();
603   }
604 #endif
605   
606 #ifdef HAVE_GETGRNAM 
607   {
608     struct group *gptr = (struct group *)getgrnam(group);
609     char **member;
610     if (gptr)
611       {
612         member = gptr->gr_mem;
613         while (member && *member)
614           {
615             static fstring name;
616             fstrcpy(name,*member);
617             if (user_ok(name,snum) &&
618                 password_ok(name,password,pwlen,NULL))
619               return(&name[0]);
620             member++;
621           }
622 #ifdef GROUP_CHECK_PWENT
623         {
624           struct passwd *pwd;
625           static fstring tm;
626           
627           setpwent ();
628           while (pwd = getpwent ()) {
629             if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
630               /* This Entry have PASSWORD and same GID then check pwd */
631               if (password_ok(NULL, password, pwlen, pwd)) {
632                 fstrcpy(tm, pwd->pw_name);
633                 endpwent ();
634                 return tm;
635               }
636             }
637           }
638           endpwent ();
639         }
640 #endif /* GROUP_CHECK_PWENT */
641       }
642   }      
643 #endif
644   return(NULL);
645 }
646
647
648
649 /****************************************************************************
650 check for authority to login to a service with a given username/password
651 ****************************************************************************/
652 BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
653                      BOOL *guest,BOOL *force,uint16 vuid)
654 {
655   BOOL ok = False;
656   
657   *guest = False;
658   
659 #if DEBUG_PASSWORD
660   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
661 #endif
662
663   /* there are several possibilities:
664      1) login as the given user with given password
665      2) login as a previously registered username with the given password
666      3) login as a session list username with the given password
667      4) login as a previously validated user/password pair
668      5) login as the "user =" user with given password
669      6) login as the "user =" user with no password (guest connection)
670      7) login as guest user with no password
671
672      if the service is guest_only then steps 1 to 5 are skipped
673   */
674
675   if (GUEST_ONLY(snum)) *force = True;
676
677   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
678     {
679
680       user_struct *vuser = get_valid_user_struct(vuid);
681
682       /* check the given username and password */
683       if (!ok && (*user) && user_ok(user,snum)) {
684         ok = password_ok(user,password, pwlen, NULL);
685         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
686       }
687
688       /* check for a previously registered guest username */
689       if (!ok && (vuser != 0) && vuser->guest) {          
690         if (user_ok(vuser->name,snum) &&
691             password_ok(vuser->name, password, pwlen, NULL)) {
692           fstrcpy(user, vuser->name);
693           vuser->guest = False;
694           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
695           ok = True;
696         }
697       }
698
699
700       /* now check the list of session users */
701     if (!ok)
702     {
703       char *auser;
704       char *user_list = strdup(session_users);
705       if (!user_list) return(False);
706
707       for (auser=strtok(user_list,LIST_SEP); 
708            !ok && auser; 
709            auser = strtok(NULL,LIST_SEP))
710       {
711         fstring user2;
712         fstrcpy(user2,auser);
713         if (!user_ok(user2,snum)) continue;
714                   
715         if (password_ok(user2,password, pwlen, NULL)) {
716           ok = True;
717           fstrcpy(user,user2);
718           DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
719         }
720       }
721       free(user_list);
722     }
723
724     /* check for a previously validated username/password pair */
725     if (!ok && (!lp_revalidate(snum) || lp_security() > SEC_SHARE) &&
726         (vuser != 0) && !vuser->guest &&
727         user_ok(vuser->name,snum)) {
728       fstrcpy(user,vuser->name);
729       *guest = False;
730       DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
731       ok = True;
732     }
733
734       /* check for a rhosts entry */
735       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
736         ok = True;
737         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
738       }
739
740       /* check the user= fields and the given password */
741       if (!ok && lp_username(snum)) {
742         char *auser;
743         pstring user_list;
744         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
745
746         string_sub(user_list,"%S",lp_servicename(snum));
747           
748         for (auser=strtok(user_list,LIST_SEP);
749              auser && !ok;
750              auser = strtok(NULL,LIST_SEP))
751           {
752             if (*auser == '@')
753               {
754                 auser = validate_group(auser+1,password,pwlen,snum);
755                 if (auser)
756                   {
757                     ok = True;
758                     fstrcpy(user,auser);
759                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
760                   }
761               }
762             else
763               {
764                 fstring user2;
765                 fstrcpy(user2,auser);
766                 if (user_ok(user2,snum) && 
767                     password_ok(user2,password,pwlen,NULL))
768                   {
769                     ok = True;
770                     fstrcpy(user,user2);
771                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
772                   }
773               }
774           }
775       }      
776     } /* not guest only */
777
778   /* check for a normal guest connection */
779   if (!ok && GUEST_OK(snum))
780     {
781       fstring guestname;
782       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
783       if (Get_Pwnam(guestname,True))
784         {
785           fstrcpy(user,guestname);
786           ok = True;
787           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
788         }
789       else
790         DEBUG(0,("Invalid guest account %s??\n",guestname));
791       *guest = True;
792       *force = True;
793     }
794
795   if (ok && !user_ok(user,snum))
796     {
797       DEBUG(0,("rejected invalid user %s\n",user));
798       ok = False;
799     }
800
801   return(ok);
802 }
803
804
805 /****************************************************************************
806 read the a hosts.equiv or .rhosts file and check if it
807 allows this user from this machine
808 ****************************************************************************/
809 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
810 {
811   pstring buf;
812   int plus_allowed = 1;
813   char *file_host;
814   char *file_user;
815   FILE *fp = fopen(equiv_file, "r");
816   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
817   if (! fp) return False;
818   while(fgets(buf, sizeof(buf), fp)) 
819   {
820     trim_string(buf," "," ");
821
822     if (buf[0] != '#' && buf[0] != '\n') 
823     {
824       BOOL is_group = False;
825       int plus = 1;
826       char *bp = buf;
827       if (strcmp(buf, "NO_PLUS\n") == 0)
828       {
829         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
830         plus_allowed = 0;
831       }
832       else {
833         if (buf[0] == '+') 
834         {
835           bp++;
836           if (*bp == '\n' && plus_allowed) 
837           {
838             /* a bare plus means everbody allowed */
839             DEBUG(6, ("check_user_equiv everybody allowed\n"));
840             fclose(fp);
841             return True;
842           }
843         }
844         else if (buf[0] == '-')
845         {
846           bp++;
847           plus = 0;
848         }
849         if (*bp == '@') 
850         {
851           is_group = True;
852           bp++;
853         }
854         file_host = strtok(bp, " \t\n");
855         file_user = strtok(NULL, " \t\n");
856         DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)", 
857                  file_user ? file_user : "(null)" ));
858         if (file_host && *file_host) 
859         {
860           BOOL host_ok = False;
861
862 #if defined(HAVE_NETGROUP) && defined(HAVE_YP_GET_DEFAULT_DOMAIN)
863           if (is_group)
864             {
865               static char *mydomain = NULL;
866               if (!mydomain)
867                 yp_get_default_domain(&mydomain);
868               if (mydomain && innetgr(file_host,remote,user,mydomain))
869                 host_ok = True;
870             }
871 #else
872           if (is_group)
873             {
874               DEBUG(1,("Netgroups not configured\n"));
875               continue;
876             }
877 #endif
878
879           /* is it this host */
880           /* the fact that remote has come from a call of gethostbyaddr
881            * means that it may have the fully qualified domain name
882            * so we could look up the file version to get it into
883            * a canonical form, but I would rather just type it
884            * in full in the equiv file
885            */
886           if (!host_ok && !is_group && strequal(remote, file_host))
887             host_ok = True;
888
889           if (!host_ok)
890             continue;
891
892           /* is it this user */
893           if (file_user == 0 || strequal(user, file_user)) 
894             {
895               fclose(fp);
896               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
897                         (plus ? "+" : "-"), file_host,
898                         (file_user ? file_user : "")));
899               return (plus ? True : False);
900             }
901         }
902       }
903     }
904   }
905   fclose(fp);
906   return False;
907 }
908
909
910 /****************************************************************************
911 check for a possible hosts equiv or rhosts entry for the user
912 ****************************************************************************/
913 BOOL check_hosts_equiv(char *user)
914 {
915   char *fname = NULL;
916   pstring rhostsfile;
917   struct passwd *pass = Get_Pwnam(user,True);
918
919   if (!pass) 
920     return(False);
921
922   fname = lp_hosts_equiv();
923
924   /* note: don't allow hosts.equiv on root */
925   if (fname && *fname && (pass->pw_uid != 0)) {
926           extern int Client;
927           if (check_user_equiv(user,client_name(Client),fname))
928                   return(True);
929   }
930   
931   if (lp_use_rhosts())
932     {
933       char *home = get_home_dir(user);
934       if (home) {
935               extern int Client;
936               slprintf(rhostsfile, sizeof(rhostsfile)-1, "%s/.rhosts", home);
937               if (check_user_equiv(user,client_name(Client),rhostsfile))
938                       return(True);
939       }
940     }
941
942   return(False);
943 }
944
945
946 /****************************************************************************
947 return the client state structure
948 ****************************************************************************/
949 struct cli_state *server_client(void)
950 {
951         static struct cli_state pw_cli;
952         return &pw_cli;
953 }
954
955 /****************************************************************************
956 support for server level security 
957 ****************************************************************************/
958 struct cli_state *server_cryptkey(void)
959 {
960         struct cli_state *cli;
961         fstring desthost;
962         struct in_addr dest_ip;
963         extern fstring local_machine;
964         char *p;
965         BOOL connected_ok = False;
966         struct nmb_name calling, called;
967
968         cli = server_client();
969
970         if (!cli_initialise(cli))
971                 return NULL;
972
973         p = lp_passwordserver();
974         while(p && next_token( &p, desthost, LIST_SEP, sizeof(desthost))) {
975                 standard_sub_basic(desthost);
976                 strupper(desthost);
977
978                 if(!resolve_name( desthost, &dest_ip, 0x20)) {
979                         DEBUG(1,("server_cryptkey: Can't resolve address for %s\n",desthost));
980                         continue;
981                 }
982
983                 if (ismyip(dest_ip)) {
984                         DEBUG(1,("Password server loop - disabling password server %s\n",desthost));
985                         continue;
986                 }
987
988                 if (cli_connect(cli, desthost, &dest_ip)) {
989                         DEBUG(3,("connected to password server %s\n",desthost));
990                         connected_ok = True;
991                         break;
992                 }
993         }
994
995         if (!connected_ok) {
996                 DEBUG(0,("password server not available\n"));
997                 cli_shutdown(cli);
998                 return NULL;
999         }
1000
1001         make_nmb_name(&calling, local_machine, 0x0 , scope);
1002         make_nmb_name(&called , desthost     , 0x20, scope);
1003
1004         if (!cli_session_request(cli, &calling, &called))
1005         {
1006                 DEBUG(1,("%s rejected the session\n",desthost));
1007                 cli_shutdown(cli);
1008                 return NULL;
1009         }
1010
1011         DEBUG(3,("got session\n"));
1012
1013         if (!cli_negprot(cli)) {
1014                 DEBUG(1,("%s rejected the negprot\n",desthost));
1015                 cli_shutdown(cli);
1016                 return NULL;
1017         }
1018
1019         if (cli->protocol < PROTOCOL_LANMAN2 ||
1020             !(cli->sec_mode & 1)) {
1021                 DEBUG(1,("%s isn't in user level security mode\n",desthost));
1022                 cli_shutdown(cli);
1023                 return NULL;
1024         }
1025
1026         DEBUG(3,("password server OK\n"));
1027
1028         return cli;
1029 }
1030
1031 /****************************************************************************
1032 validate a password with the password server
1033 ****************************************************************************/
1034 BOOL server_validate(char *user, char *domain, 
1035                      char *pass, int passlen,
1036                      char *ntpass, int ntpasslen)
1037 {
1038         struct cli_state *cli;
1039         extern fstring local_machine;
1040         static unsigned char badpass[24];
1041         cli = server_client();
1042
1043         if (!cli->initialised) {
1044                 DEBUG(1,("password server %s is not connected\n", cli->desthost));
1045                 return(False);
1046         }  
1047
1048         if(badpass[0] == 0) {
1049           memset(badpass, 0x1f, sizeof(badpass));
1050         }
1051
1052         if((passlen == sizeof(badpass)) && !memcmp(badpass, pass, passlen)) {
1053           /* Very unlikely, our random bad password is the same as the users
1054              password. */
1055           memset(badpass, badpass[0]+1, sizeof(badpass));
1056         }
1057
1058         /*
1059          * Attempt a session setup with a totally incorrect password.
1060          * If this succeeds with the guest bit *NOT* set then the password
1061          * server is broken and is not correctly setting the guest bit. We
1062          * need to detect this as some versions of NT4.x are broken. JRA.
1063          */
1064
1065         if (cli_session_setup(cli, user, (char *)badpass, sizeof(badpass), 
1066                               (char *)badpass, sizeof(badpass), domain)) {
1067           if ((SVAL(cli->inbuf,smb_vwv2) & 1) == 0) {
1068             DEBUG(0,("server_validate: password server %s allows users as non-guest \
1069 with a bad password.\n", cli->desthost));
1070             DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1071 use this machine as the password server.\n"));
1072             cli_ulogoff(cli);
1073             return False;
1074           }
1075           cli_ulogoff(cli);
1076         }
1077
1078         /*
1079          * Now we know the password server will correctly set the guest bit, or is
1080          * not guest enabled, we can try with the real password.
1081          */
1082
1083         if (!cli_session_setup(cli, user, pass, passlen, ntpass, ntpasslen, domain)) {
1084                 DEBUG(1,("password server %s rejected the password\n", cli->desthost));
1085                 return False;
1086         }
1087
1088         /* if logged in as guest then reject */
1089         if ((SVAL(cli->inbuf,smb_vwv2) & 1) != 0) {
1090                 DEBUG(1,("password server %s gave us guest only\n", cli->desthost));
1091                 cli_ulogoff(cli);
1092                 return(False);
1093         }
1094
1095         /*
1096          * This patch from Rob Nielsen <ran@adc.com> makes doing
1097          * the NetWksaUserLogon a dynamic, rather than compile-time
1098          * parameter, defaulting to on. This is somewhat dangerous
1099          * as it allows people to turn off this neccessary check,
1100          * but so many people have had problems with this that I
1101          * think it is a neccessary change. JRA.
1102          */
1103
1104         if (lp_net_wksta_user_logon()) {
1105                 DEBUG(3,("trying NetWkstaUserLogon with password server %s\n", cli->desthost));
1106
1107                 if (!cli_send_tconX(cli, "IPC$", "IPC", "", 1)) {
1108                         DEBUG(0,("password server %s refused IPC$ connect\n", cli->desthost));
1109                         cli_ulogoff(cli);
1110                         return False;
1111                 }
1112
1113                 if (!cli_NetWkstaUserLogon(cli,user,local_machine)) {
1114                         DEBUG(0,("password server %s failed NetWkstaUserLogon\n", cli->desthost));
1115                         cli_tdis(cli);
1116                         cli_ulogoff(cli);
1117                         return False;
1118                 }
1119
1120                 if (cli->privilages == 0) {
1121                         DEBUG(0,("password server %s gave guest privilages\n", cli->desthost));
1122                         cli_tdis(cli);
1123                         cli_ulogoff(cli);
1124                         return False;
1125                 }
1126
1127                 if (!strequal(cli->eff_name, user)) {
1128                         DEBUG(0,("password server %s gave different username %s\n", 
1129                                 cli->desthost,
1130                                 cli->eff_name));
1131                         cli_tdis(cli);
1132                         cli_ulogoff(cli);
1133                         return False;
1134                 }
1135                 cli_tdis(cli);
1136         }
1137         else {
1138                 DEBUG(3,("skipping NetWkstaUserLogon with password server %s\n", cli->desthost));
1139         }
1140
1141         DEBUG(3,("password server %s accepted the password\n", cli->desthost));
1142
1143         cli_ulogoff(cli);
1144
1145         return(True);
1146 }
1147
1148 /***********************************************************************
1149  Do the same as security=server, but using NT Domain calls and a session
1150  key from the machine password.
1151 ************************************************************************/
1152
1153 BOOL domain_client_validate( char *user, char *domain, 
1154                              char *smb_apasswd, int smb_apasslen, 
1155                              char *smb_ntpasswd, int smb_ntpasslen)
1156 {
1157   unsigned char local_challenge[8];
1158   unsigned char local_lm_response[24];
1159   unsigned char local_nt_reponse[24];
1160   unsigned char trust_passwd[16];
1161   fstring remote_machine;
1162   char *p;
1163   struct in_addr dest_ip;
1164   NET_ID_INFO_CTR ctr;
1165   NET_USER_INFO_3 info3;
1166   struct cli_state cli;
1167   uint32 smb_uid_low;
1168   BOOL connected_ok = False;
1169   struct nmb_name calling, called;
1170
1171   /* 
1172    * Check that the requested domain is not our own machine name.
1173    * If it is, we should never check the PDC here, we use our own local
1174    * password file.
1175    */
1176
1177   if(strequal( domain, global_myname)) {
1178     DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1179     return False;
1180   }
1181
1182   /*
1183    * Next, check that the passwords given were encrypted.
1184    */
1185
1186   if(((smb_apasslen != 24) && (smb_apasslen != 0)) || 
1187      ((smb_ntpasslen != 24) && (smb_ntpasslen != 0))) {
1188
1189     /*
1190      * Not encrypted - do so.
1191      */
1192
1193     DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1194     generate_random_buffer( local_challenge, 8, False);
1195     SMBencrypt( (uchar *)smb_apasswd, local_challenge, local_lm_response);
1196     SMBNTencrypt((uchar *)smb_ntpasswd, local_challenge, local_nt_reponse);
1197     smb_apasslen = 24;
1198     smb_ntpasslen = 24;
1199     smb_apasswd = (char *)local_lm_response;
1200     smb_ntpasswd = (char *)local_nt_reponse;
1201   } else {
1202
1203     /*
1204      * Encrypted - get the challenge we sent for these
1205      * responses.
1206      */
1207
1208     if (!last_challenge(local_challenge)) {
1209       DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1210       return False;
1211     }
1212   }
1213
1214   /*
1215    * Get the machine account password.
1216    */
1217   if (!trust_get_passwd( trust_passwd, global_myworkgroup, global_myname))
1218   {
1219     return False;
1220   }
1221
1222   /*
1223    * At this point, smb_apasswd points to the lanman response to
1224    * the challenge in local_challenge, and smb_ntpasswd points to
1225    * the NT response to the challenge in local_challenge. Ship
1226    * these over the secure channel to a domain controller and
1227    * see if they were valid.
1228    */
1229
1230   ZERO_STRUCT(cli);
1231
1232   if(cli_initialise(&cli) == False) {
1233     DEBUG(0,("domain_client_validate: unable to initialize client connection.\n"));
1234     return False;
1235   }
1236
1237   /*
1238    * Treat each name in the 'password server =' line as a potential
1239    * PDC/BDC. Contact each in turn and try and authenticate.
1240    */
1241
1242   p = lp_passwordserver();
1243   while(p && next_token(&p,remote_machine,LIST_SEP,sizeof(remote_machine))) {
1244
1245     standard_sub_basic(remote_machine);
1246     strupper(remote_machine);
1247  
1248     if(!resolve_name( remote_machine, &dest_ip, 0x20)) {
1249       DEBUG(1,("domain_client_validate: Can't resolve address for %s\n", remote_machine));
1250       continue;
1251     }   
1252     
1253     if (ismyip(dest_ip)) {
1254       DEBUG(1,("domain_client_validate: Password server loop - not using password server %s\n",remote_machine));
1255       continue;
1256     }
1257       
1258     if (!cli_connect(&cli, remote_machine, &dest_ip)) {
1259       DEBUG(0,("domain_client_validate: unable to connect to SMB server on \
1260 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1261       continue;
1262     }
1263     
1264         make_nmb_name(&calling, global_myname , 0x0 , scope);
1265         make_nmb_name(&called , remote_machine, 0x20, scope);
1266
1267         if (!cli_session_request(&cli, &calling, &called))
1268         {
1269       DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
1270 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1271       cli_shutdown(&cli);
1272       continue;
1273     }
1274     
1275     cli.protocol = PROTOCOL_NT1;
1276
1277     if (!cli_negprot(&cli)) {
1278       DEBUG(0,("domain_client_validate: machine %s rejected the negotiate protocol. \
1279 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1280       cli_shutdown(&cli);
1281       continue;
1282     }
1283     
1284     if (cli.protocol != PROTOCOL_NT1) {
1285       DEBUG(0,("domain_client_validate: machine %s didn't negotiate NT protocol.\n",
1286                      remote_machine));
1287       cli_shutdown(&cli);
1288       continue;
1289     }
1290
1291     /* 
1292      * Do an anonymous session setup.
1293      */
1294
1295     if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) {
1296       DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
1297 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1298       cli_shutdown(&cli);
1299       continue;
1300     }      
1301
1302     if (!(cli.sec_mode & 1)) {
1303       DEBUG(1,("domain_client_validate: machine %s isn't in user level security mode\n",
1304                  remote_machine));
1305       cli_shutdown(&cli);
1306       continue;
1307     }
1308
1309     if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) {
1310       DEBUG(0,("domain_client_validate: machine %s rejected the tconX on the IPC$ share. \
1311 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1312       cli_shutdown(&cli);
1313       continue;
1314     }
1315
1316     /*
1317      * We have an anonymous connection to IPC$.
1318      */
1319     connected_ok = True;
1320     break;
1321   }
1322
1323   if (!connected_ok) {
1324     DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
1325     cli_shutdown(&cli);
1326     return False;
1327   }
1328
1329   /*
1330    * Ok - we have an anonymous connection to the IPC$ share.
1331    * Now start the NT Domain stuff :-).
1332    */
1333
1334   if(cli_nt_session_open(&cli, PIPE_NETLOGON) == False) {
1335     DEBUG(0,("domain_client_validate: unable to open the domain client session to \
1336 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli)));
1337     cli_nt_session_close(&cli);
1338     cli_ulogoff(&cli);
1339     cli_shutdown(&cli);
1340     return False; 
1341   }
1342
1343   if(cli_nt_setup_creds(&cli, trust_passwd) == False) {
1344     DEBUG(0,("domain_client_validate: unable to setup the PDC credentials to machine \
1345 %s. Error was : %s.\n", remote_machine, cli_errstr(&cli)));
1346     cli_nt_session_close(&cli);
1347     cli_ulogoff(&cli);
1348     cli_shutdown(&cli);
1349     return False;
1350   }
1351
1352   /* We really don't care what LUID we give the user. */
1353   generate_random_buffer( (unsigned char *)&smb_uid_low, 4, False);
1354
1355   if(cli_nt_login_network(&cli, domain, user, smb_uid_low, (char *)local_challenge,
1356                           ((smb_apasslen != 0) ? smb_apasswd : NULL),
1357                           ((smb_ntpasslen != 0) ? smb_ntpasswd : NULL),
1358                           &ctr, &info3) == False) {
1359     DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
1360 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
1361     cli_nt_session_close(&cli);
1362     cli_ulogoff(&cli);
1363     cli_shutdown(&cli);
1364     return False;
1365   }
1366
1367   /*
1368    * Here, if we really want it, we have lots of info about the user in info3.
1369    */
1370
1371 #if 0
1372   /* 
1373    * We don't actually need to do this - plus it fails currently with
1374    * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
1375    * send here. JRA.
1376    */
1377
1378   if(cli_nt_logoff(&cli, &ctr) == False) {
1379     DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
1380 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));        
1381     cli_nt_session_close(&cli);
1382     cli_ulogoff(&cli);
1383     cli_shutdown(&cli);
1384     return False;
1385   }
1386 #endif /* 0 */
1387
1388   cli_nt_session_close(&cli);
1389   cli_ulogoff(&cli);
1390   cli_shutdown(&cli);
1391   return True;
1392 }