9b06e0dcb52a10e6b609a399bdc31dd9e23757ac
[kai/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-1995
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 /* these are kept here to keep the string_combinations function simple */
31 static char this_user[100]="";
32 static char this_salt[100]="";
33 static char this_crypted[100]="";
34
35 #ifdef SMB_PASSWD
36 /* Data to do lanman1/2 password challenge. */
37 static unsigned char saved_challenge[8];
38 static BOOL challenge_sent=False;
39
40 /*******************************************************************
41 Get the next challenge value - no repeats.
42 ********************************************************************/
43 void generate_next_challenge(char *challenge)
44 {
45   static int counter = 0;
46   struct timeval tval;
47   int v1,v2;
48   GetTimeOfDay(&tval);
49   v1 = (counter++) + getpid() + tval.tv_sec;
50   v2 = (counter++) * getpid() + tval.tv_usec;
51   SIVAL(challenge,0,v1);
52   SIVAL(challenge,4,v2);
53   E1(challenge,"SAMBA",(char *)saved_challenge);
54   memcpy(challenge,saved_challenge,8);
55   challenge_sent = True;
56 }
57
58 /*******************************************************************
59 set the last challenge sent, usually from a password server
60 ********************************************************************/
61 BOOL set_challenge(char *challenge)
62 {
63   memcpy(saved_challenge,challenge,8);
64   challenge_sent = True;
65   return(True);
66 }
67
68 /*******************************************************************
69 get the last challenge sent
70 ********************************************************************/
71 BOOL last_challenge(char *challenge)
72 {
73   if (!challenge_sent) return(False);
74   memcpy(challenge,saved_challenge,8);
75   return(True);
76 }
77 #endif
78
79 /* this holds info on user ids that are already validated for this VC */
80 static user_struct *validated_users = NULL;
81 static int num_validated_users = 0;
82
83 /****************************************************************************
84 check if a uid has been validated, and return an pointer to the user_struct
85 if it has. NULL if not. vuid is biased by an offset. This allows us to
86 tell random client vuid's (normally zero) from valid vuids.
87 ****************************************************************************/
88 user_struct *get_valid_user_struct(uint16 vuid)
89 {
90   if(vuid == UID_FIELD_INVALID)
91     return NULL;
92   vuid -= VUID_OFFSET;
93   if((vuid >= (uint16)num_validated_users) || 
94      (validated_users[vuid].uid == -1) || (validated_users[vuid].gid == -1))
95     return NULL;
96   return &validated_users[vuid];
97 }
98
99 /****************************************************************************
100 invalidate a uid
101 ****************************************************************************/
102 void invalidate_vuid(uint16 vuid)
103 {
104   user_struct *vuser = get_valid_user_struct(vuid);
105   if(vuser == 0)
106     return;
107
108   vuser->uid = -1;
109   vuser->gid = -1;
110   vuser->user_ngroups = 0;
111   if(vuser->user_groups && 
112      (vuser->user_groups != (gid_t *)vuser->user_igroups))
113        free(vuser->user_groups);
114   vuser->user_groups = NULL;
115   if(vuser->user_igroups)
116     free(vuser->user_igroups);
117   vuser->user_igroups = NULL;
118 }
119
120
121 /****************************************************************************
122 return a validated username
123 ****************************************************************************/
124 char *validated_username(uint16 vuid)
125 {
126   user_struct *vuser = get_valid_user_struct(vuid);
127   if(vuser == 0)
128     return 0;
129   return(vuser->name);
130 }
131
132 /****************************************************************************
133 register a uid/name pair as being valid and that a valid password
134 has been given. vuid is biased by an offset. This allows us to
135 tell random client vuid's (normally zero) from valid vuids.
136 ****************************************************************************/
137 uint16 register_vuid(int uid,int gid, char *name,BOOL guest)
138 {
139   user_struct *vuser;
140
141   int i;
142   for(i = 0; i < num_validated_users; i++) {
143     vuser = &validated_users[i];
144     if( vuser->uid == uid )
145       return i; /* User already validated */
146   }
147
148   validated_users = (user_struct *)Realloc(validated_users,
149                            sizeof(user_struct)*
150                            (num_validated_users+1));
151   
152   if (!validated_users)
153     {
154       DEBUG(0,("Failed to realloc users struct!\n"));
155       num_validated_users = 0;
156       return UID_FIELD_INVALID;
157     }
158
159   vuser = &validated_users[num_validated_users];
160   num_validated_users++;
161
162   vuser->uid = uid;
163   vuser->gid = gid;
164   vuser->guest = guest;
165   strcpy(vuser->name,name);
166
167   vuser->user_ngroups = 0;
168   vuser->user_groups = NULL;
169   vuser->user_igroups = NULL;
170
171   /* Find all the groups this uid is in and store them. 
172      Used by become_user() */
173   setup_groups(name,uid,gid,
174                &vuser->user_ngroups,
175                &vuser->user_igroups,
176                &vuser->user_groups);
177
178   DEBUG(3,("uid %d registered to name %s\n",uid,name));
179
180   return (uint16)((num_validated_users - 1) + VUID_OFFSET);
181 }
182
183
184 /****************************************************************************
185 add a name to the session users list
186 ****************************************************************************/
187 void add_session_user(char *user)
188 {
189   fstring suser;
190   StrnCpy(suser,user,sizeof(suser)-1);
191
192   if (!Get_Pwnam(suser,True)) return;
193
194   if (suser && *suser && !in_list(suser,session_users,False))
195     {
196       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
197         DEBUG(1,("Too many session users??\n"));
198       else
199         {
200           strcat(session_users," ");
201           strcat(session_users,suser);
202         }
203     }
204 }
205
206
207 #ifdef NO_GETSPNAM
208 /* a fake shadow password routine which just fills a fake spwd struct
209  * with the sp_pwdp field. (sreiz@aie.nl)
210  */
211 static struct spwd *getspnam(char *username) /* fake shadow password routine */
212 {
213        FILE *f;
214        char line[1024];
215        static char pw[20];
216        static struct spwd static_spwd;
217
218        static_spwd.sp_pwdp=0;
219        if (!(f=fopen("/etc/master.passwd", "r")))
220                return 0;
221        while (fgets(line, 1024, f)) {
222                if (!strncmp(line, username, strlen(username)) &&
223                 line[strlen(username)]==':') { /* found entry */
224                        char *p, *q;
225
226                        p=line+strlen(username)+1;
227                        if ((q=strchr(p, ':'))) {
228                                *q=0;
229                                if (q-p+1>20)
230                                        break;
231                                strcpy(pw, p);
232                                static_spwd.sp_pwdp=pw;
233                        }
234                        break;
235                }
236        }
237        fclose(f);
238        if (static_spwd.sp_pwdp)
239                return &static_spwd;
240        return 0;
241 }
242 #endif
243
244
245 #ifdef OSF1_ENH_SEC
246 /****************************************************************************
247 an enhanced crypt for OSF1
248 ****************************************************************************/
249 static char *osf1_bigcrypt(char *password,char *salt1)
250 {
251   static char result[AUTH_MAX_PASSWD_LENGTH] = "";
252   char *p1;
253   char *p2=password;
254   char salt[3];
255   int i;
256   int parts = strlen(password) / AUTH_CLEARTEXT_SEG_CHARS;
257   if (strlen(password)%AUTH_CLEARTEXT_SEG_CHARS)
258     parts++;
259
260   StrnCpy(salt,salt1,2);
261   StrnCpy(result,salt1,2);
262
263   for (i=0; i<parts;i++)
264     {
265       p1 = crypt(p2,salt);
266       strcat(result,p1+2);
267       StrnCpy(salt,&result[2+i*AUTH_CIPHERTEXT_SEG_CHARS],2);
268       p2 += AUTH_CLEARTEXT_SEG_CHARS;
269     }
270
271   return(result);
272 }
273 #endif
274
275
276 /****************************************************************************
277 update the enhanced security database. Only relevant for OSF1 at the moment.
278 ****************************************************************************/
279 static void update_protected_database( char *user, BOOL result)
280 {
281 #ifdef OSF1_ENH_SEC
282   struct pr_passwd *mypasswd;
283   time_t starttime;
284
285   mypasswd = getprpwnam (user);
286   starttime = time (NULL);
287
288   if (result)
289     {
290       mypasswd->ufld.fd_slogin = starttime;
291       mypasswd->ufld.fd_nlogins = 0;
292       
293       putprpwnam(user,mypasswd);
294       
295       DEBUG(3,("Update protected database for Account %s after succesful connection\n",user));
296     }
297   else
298     {
299       mypasswd->ufld.fd_ulogin = starttime;
300       mypasswd->ufld.fd_nlogins = mypasswd->ufld.fd_nlogins + 1;
301       if ( mypasswd->ufld.fd_max_tries != 0 && mypasswd->ufld.fd_nlogins > mypasswd->ufld.fd_max_tries )
302         {
303           mypasswd->uflg.fg_lock = 0;
304           DEBUG(3,("Account is disabled -- see Account Administrator.\n"));
305         }
306       putprpwnam ( user , mypasswd );
307       DEBUG(3,("Update protected database for Account %s after refusing connection\n",user));
308     }
309 #else
310   DEBUG(6,("Updated database with %s %s\n",user,BOOLSTR(result)));
311 #endif
312 }
313
314
315 #ifdef AFS_AUTH
316 /*******************************************************************
317 check on AFS authentication
318 ********************************************************************/
319 static BOOL afs_auth(char *this_user,char *password)
320 {
321   long password_expires = 0;
322   char *reason;
323     
324   /* For versions of AFS prior to 3.3, this routine has few arguments, */
325   /* but since I can't find the old documentation... :-)               */
326   setpag();
327   if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION+KA_USERAUTH_DOSETPAG,
328                                  this_user,
329                                  (char *) 0, /* instance */
330                                  (char *) 0, /* cell */
331                                  password,
332                                  0,          /* lifetime, default */
333                                  &password_expires, /*days 'til it expires */
334                                  0,          /* spare 2 */
335                                  &reason) == 0)
336     return(True);
337   return(False);
338 }
339 #endif
340
341
342 #ifdef DFS_AUTH
343
344 sec_login_handle_t my_dce_sec_context;
345 int dcelogin_atmost_once = 0;
346
347 /*******************************************************************
348 check on a DCE/DFS authentication
349 ********************************************************************/
350 static BOOL dfs_auth(char *this_user,char *password)
351 {
352   error_status_t err;
353   int err2;
354   int prterr;
355   boolean32 password_reset;
356   sec_passwd_rec_t my_dce_password;
357   sec_login_auth_src_t auth_src = sec_login_auth_src_network;
358   unsigned char dce_errstr[dce_c_error_string_len];
359
360   /*
361    * We only go for a DCE login context if the given password
362    * matches that stored in the local password file.. 
363    * Assumes local passwd file is kept in sync w/ DCE RGY!
364    */
365
366   if (!strcmp((char *)crypt(password,this_salt),this_crypted) ||
367       dcelogin_atmost_once)
368     return(False);
369
370   if (sec_login_setup_identity(
371                                (unsigned char *)this_user,
372                                sec_login_no_flags,
373                                &my_dce_sec_context,
374                                &err) == 0)
375     {
376       dce_error_inq_text(err, dce_errstr, &err2);
377       DEBUG(0,("DCE Setup Identity for %s failed: %s\n",
378                this_user,dce_errstr));
379       return(False);
380     }
381
382   my_dce_password.version_number = sec_passwd_c_version_none;
383   my_dce_password.pepper = NULL; 
384   my_dce_password.key.key_type = sec_passwd_plain;
385   my_dce_password.key.tagged_union.plain  = (idl_char *)password;
386   
387   if (sec_login_valid_and_cert_ident(my_dce_sec_context,
388                                      &my_dce_password,
389                                      &password_reset,
390                                      &auth_src,
391                                      &err) == 0 )
392     { 
393       dce_error_inq_text(err, dce_errstr, &err2);
394       DEBUG(0,("DCE Identity Validation failed for principal %s: %s\n",
395                this_user,dce_errstr));
396           
397       return(False);
398     }
399
400   sec_login_set_context(my_dce_sec_context, &err);
401   if (err != error_status_ok )
402     {  
403       dce_error_inq_text(err, dce_errstr, &err2);
404       DEBUG(0,("DCE login failed for principal %s, cant set context: %s\n",
405                this_user,dce_errstr));
406       sec_login_purge_context(my_dce_sec_context, &err);
407       return(False);
408     }
409   else
410     {
411       DEBUG(0,("DCE login succeeded for principal %s on pid %d\n",
412                this_user, getpid()));
413     }
414
415   dcelogin_atmost_once = 1;
416   return (True);
417 }
418
419 void dfs_unlogin(void)
420 {
421   error_status_t err;
422   int err2;
423   unsigned char dce_errstr[dce_c_error_string_len];
424
425   sec_login_purge_context(my_dce_sec_context, &err);
426   if (err != error_status_ok )
427     {  
428       dce_error_inq_text(err, dce_errstr, &err2);
429       DEBUG(0,("DCE purge login context failed for server instance %d: %s\n",
430                getpid(), dce_errstr));
431     }
432 }
433
434 #endif
435
436
437 #ifdef LINUX_BIGCRYPT
438 /****************************************************************************
439 an enhanced crypt for Linux to handle password longer than 8 characters
440 ****************************************************************************/
441 static int linux_bigcrypt(char *password,char *salt1, char *crypted)
442 {
443 #define LINUX_PASSWORD_SEG_CHARS 8
444   char salt[3];
445   int i;
446   
447   StrnCpy(salt,salt1,2);
448   crypted +=2;
449   
450   for ( i=strlen(password); i > 0; i -= LINUX_PASSWORD_SEG_CHARS) {
451     char * p = crypt(password,salt) + 2;
452     if(strncmp(p, crypted, LINUX_PASSWORD_SEG_CHARS) != 0)
453       return(0);
454     password += LINUX_PASSWORD_SEG_CHARS;
455     crypted  += strlen(p);
456   }
457   
458   return(1);
459 }
460 #endif
461
462
463 /****************************************************************************
464 apply a function to upper/lower case combinations
465 of a string and return true if one of them returns true.
466 try all combinations with N uppercase letters.
467 offset is the first char to try and change (start with 0)
468 it assumes the string starts lowercased
469 ****************************************************************************/
470 static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(),int N)
471 {
472   int len = strlen(s);
473   int i;
474
475 #ifdef PASSWORD_LENGTH
476   len = MIN(len,PASSWORD_LENGTH);
477 #endif
478
479   if (N <= 0 || offset >= len)
480     return(fn(s));
481
482   for (i=offset;i<(len-(N-1));i++)
483     {      
484       char c = s[i];
485       if (!islower(c)) continue;
486       s[i] = toupper(c);
487       if (string_combinations2(s,i+1,fn,N-1))
488         return(True);
489       s[i] = c;
490     }
491   return(False);
492 }
493
494 /****************************************************************************
495 apply a function to upper/lower case combinations
496 of a string and return true if one of them returns true.
497 try all combinations with up to N uppercase letters.
498 offset is the first char to try and change (start with 0)
499 it assumes the string starts lowercased
500 ****************************************************************************/
501 static BOOL string_combinations(char *s,BOOL (*fn)(),int N)
502 {
503   int n;
504   for (n=1;n<=N;n++)
505     if (string_combinations2(s,0,fn,n)) return(True);
506   return(False);
507 }
508
509
510
511 /****************************************************************************
512 core of password checking routine
513 ****************************************************************************/
514 BOOL password_check(char *password)
515 {
516 #ifdef AFS_AUTH
517   if (afs_auth(this_user,password)) return(True);
518 #endif
519
520 #ifdef DFS_AUTH
521   if (dfs_auth(this_user,password)) return(True);
522 #endif 
523
524 #ifdef PWDAUTH
525   if (pwdauth(this_user,password) == 0)
526     return(True);
527 #endif
528
529 #ifdef OSF1_ENH_SEC
530   return(strcmp(osf1_bigcrypt(password,this_salt),this_crypted) == 0);
531 #endif
532
533 #ifdef ULTRIX_AUTH
534   return (strcmp((char *)crypt16(password, this_salt ),this_crypted) == 0);
535 #endif
536
537 #ifdef LINUX_BIGCRYPT
538   return(linux_bigcrypt(password,this_salt,this_crypted));
539 #endif
540
541 #ifdef NO_CRYPT
542   DEBUG(1,("Warning - no crypt available\n"));
543   return(False);
544 #else
545   return(strcmp((char *)crypt(password,this_salt),this_crypted) == 0);
546 #endif
547 }
548
549 #ifdef SMB_PASSWD
550 /****************************************************************************
551 core of smb password checking routine.
552 ****************************************************************************/
553 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
554 {
555   /* Finish the encryption of part_passwd. */
556   unsigned char p21[21];
557   unsigned char p24[24];
558
559   if(part_passwd == NULL)
560     DEBUG(10,("No password set - allowing access\n"));
561   /* No password set - always true ! */
562   if(part_passwd == NULL)
563     return 1;
564
565   memset(p21,'\0',21);
566   memcpy(p21,part_passwd,16);
567   E_P24(p21, c8, p24);
568 #if DEBUG_PASSWORD
569   {
570     int i;
571     DEBUG(100,("Part password (P16) was |"));
572     for(i = 0; i < 16; i++)
573       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
574     DEBUG(100,("|\n"));
575     DEBUG(100,("Password from client was |"));
576     for(i = 0; i < 24; i++)
577       DEBUG(100,("%X ", (unsigned char)password[i]));
578     DEBUG(100,("|\n"));
579     DEBUG(100,("Given challenge was |"));
580     for(i = 0; i < 8; i++)
581       DEBUG(100,("%X ", (unsigned char)c8[i]));
582     DEBUG(100,("|\n"));
583     DEBUG(100,("Value from encryption was |"));
584     for(i = 0; i < 24; i++)
585       DEBUG(100,("%X ", (unsigned char)p24[i]));
586     DEBUG(100,("|\n"));
587   }
588 #endif
589   return (memcmp(p24, password, 24) == 0);
590 }
591 #endif
592
593 /****************************************************************************
594 check if a username/password is OK
595 ****************************************************************************/
596 BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd)
597 {
598   pstring pass2;
599   int level = lp_passwordlevel();
600   struct passwd *pass;
601 #ifdef SMB_PASSWD
602   char challenge[8];
603   struct smb_passwd *smb_pass;
604   BOOL challenge_done = False;
605 #endif
606
607   if (password) password[pwlen] = 0;
608
609 #ifdef SMB_PASSWD
610   if (pwlen == 24)
611     challenge_done = last_challenge(challenge);
612 #endif
613
614 #if DEBUG_PASSWORD
615 #ifdef SMB_PASSWD
616   if (challenge_done)
617     {
618       int i;      
619       DEBUG(100,("checking user=[%s] pass=[",user));
620       for( i = 0; i < 24; i++)
621         DEBUG(100,("%0x ", (unsigned char)password[i]));
622       DEBUG(100,("]\n"));
623     }
624   else
625 #endif
626     DEBUG(100,("checking user=[%s] pass=[%s]\n",user,password));
627 #endif
628
629   if (!password)
630     return(False);
631
632   if (((!*password) || (!pwlen)) && !lp_null_passwords())
633     return(False);
634
635   if (pwd && !user) 
636     {
637       pass = (struct passwd *) pwd;
638       user = pass->pw_name;
639     } 
640   else 
641     pass = Get_Pwnam(user,True);
642
643 #ifdef SMB_PASSWD
644
645   DEBUG(4,("SMB Password - pwlen = %d, challenge_done = %d\n", pwlen, challenge_done));
646
647   if((pwlen == 24) && challenge_done)
648     {
649       DEBUG(4,("Checking SMB password for user %s (l=24)\n",user));
650
651       if (!pass) 
652         {
653           DEBUG(3,("Couldn't find user %s\n",user));
654           return(False);
655         }
656
657       smb_pass = get_smbpwnam(user);
658       if(!smb_pass)
659         {
660           DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
661           return(False);
662         }
663
664       /* Ensure the uid's match */
665       if(smb_pass->smb_userid != pass->pw_uid)
666         {
667           DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
668           return(False);
669         }
670
671         if(Protocol >= PROTOCOL_NT1)
672         {
673                 /* We have the NT MD4 hash challenge available - see if we can
674                    use it (ie. does it exist in the smbpasswd file).
675                 */
676                 if(smb_pass->smb_nt_passwd != NULL)
677                 {
678                   DEBUG(4,("Checking NT MD4 password\n"));
679                   if(smb_password_check(password, 
680                                         smb_pass->smb_nt_passwd, 
681                                         (char *)challenge))
682                   {
683                 update_protected_database(user,True);
684                 return(True);
685           }
686                   DEBUG(4,("NT MD4 password check failed\n"));
687                 }
688         }
689
690         /* Try against the lanman password */
691
692       if (smb_password_check(password, 
693                              smb_pass->smb_passwd,
694                              (char *)challenge)) {
695         update_protected_database(user,True);
696         return(True);
697       }
698
699         DEBUG(3,("Error smb_password_check failed\n"));
700     }
701 #endif 
702
703   DEBUG(4,("Checking password for user %s (l=%d)\n",user,pwlen));
704
705   if (!pass) 
706     {
707       DEBUG(3,("Couldn't find user %s\n",user));
708       return(False);
709     }
710
711 #ifdef SHADOW_PWD
712   {
713     struct spwd *spass;
714
715     /* many shadow systems require you to be root to get the password,
716        in most cases this should already be the case when this
717        function is called, except perhaps for IPC password changing
718        requests */
719
720     spass = getspnam(pass->pw_name);
721     if (spass && spass->sp_pwdp)
722       pass->pw_passwd = spass->sp_pwdp;
723   }
724 #endif
725
726 #ifdef SecureWare
727   {
728     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
729     if (pr_pw && pr_pw->ufld.fd_encrypt)
730       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
731   }
732 #endif
733
734 #ifdef HPUX_10_TRUSTED
735   {
736     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
737     if (pr_pw && pr_pw->ufld.fd_encrypt)
738       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
739   }
740 #endif
741
742 #ifdef OSF1_ENH_SEC
743   {
744     struct pr_passwd *mypasswd;
745     DEBUG(5,("Checking password for user %s in OSF1_ENH_SEC\n",user));
746     mypasswd = getprpwnam (user);
747     if ( mypasswd )
748       { 
749         strcpy(pass->pw_name,mypasswd->ufld.fd_name);
750         strcpy(pass->pw_passwd,mypasswd->ufld.fd_encrypt);
751       }
752     else
753       {
754         DEBUG(5,("No entry for user %s in protected database !\n",user));
755         return(False);
756       }
757   }
758 #endif
759
760 #ifdef ULTRIX_AUTH
761   {
762     AUTHORIZATION *ap = getauthuid( pass->pw_uid );
763     if (ap)
764       {
765         strcpy( pass->pw_passwd, ap->a_password );
766         endauthent();
767       }
768   }
769 #endif
770
771   /* extract relevant info */
772   strcpy(this_user,pass->pw_name);  
773   strcpy(this_salt,pass->pw_passwd);
774   strcpy(this_crypted,pass->pw_passwd);
775  
776   if (!*this_crypted) {
777     if (!lp_null_passwords()) {
778       DEBUG(2,("Disallowing access to %s due to null password\n",this_user));
779       return(False);
780     }
781 #ifndef PWDAUTH
782     if (!*password) {
783       DEBUG(3,("Allowing access to %s with null password\n",this_user));
784       return(True);
785     }
786 #endif    
787   }
788
789   /* try it as it came to us */
790   if (password_check(password))
791     {
792       update_protected_database(user,True);
793       return(True);
794     }
795
796   /* if the password was given to us with mixed case then we don't
797      need to proceed as we know it hasn't been case modified by the
798      client */
799   if (strhasupper(password) && strhaslower(password))
800     return(False);
801
802   /* make a copy of it */
803   StrnCpy(pass2,password,sizeof(pstring)-1);
804   
805   /* try all lowercase */
806   strlower(password);
807   if (password_check(password))
808     {
809       update_protected_database(user,True);
810       return(True);
811     }
812
813   /* give up? */
814   if(level < 1)
815     {
816       update_protected_database(user,False);
817
818       /* restore it */
819       strcpy(password,pass2);
820
821       return(False);
822     }
823
824   /* last chance - all combinations of up to level chars upper! */
825   strlower(password);
826
827   if (string_combinations(password,password_check,level))
828     {
829       update_protected_database(user,True);
830       return(True);
831     }
832
833   update_protected_database(user,False);
834   
835   /* restore it */
836   strcpy(password,pass2);
837   
838   return(False);
839 }
840
841
842
843 /****************************************************************************
844 check if a username is valid
845 ****************************************************************************/
846 BOOL user_ok(char *user,int snum)
847 {
848   pstring valid, invalid;
849   BOOL ret;
850
851   StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
852   StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
853
854   string_sub(valid,"%S",lp_servicename(snum));
855   string_sub(invalid,"%S",lp_servicename(snum));
856
857   ret = !user_in_list(user,invalid);
858
859   if (ret && valid && *valid)
860     ret = user_in_list(user,valid);
861
862   if (ret && lp_onlyuser(snum)) {
863     char *user_list = lp_username(snum);
864     string_sub(user_list,"%S",lp_servicename(snum));
865     ret = user_in_list(user,user_list);
866   }
867
868   return(ret);
869 }
870
871
872
873
874 /****************************************************************************
875 validate a group username entry. Return the username or NULL
876 ****************************************************************************/
877 static char *validate_group(char *group,char *password,int pwlen,int snum)
878 {
879 #ifdef NETGROUP
880   {
881     char *host, *user, *domain;
882     setnetgrent(group);
883     while (getnetgrent(&host, &user, &domain)) {
884       if (user) {
885         if (user_ok(user, snum) && 
886             password_ok(user,password,pwlen,NULL)) {
887           endnetgrent();
888           return(user);
889         }
890       }
891     }
892     endnetgrent();
893   }
894 #endif
895   
896 #if HAVE_GETGRNAM 
897   {
898     struct group *gptr = (struct group *)getgrnam(group);
899     char **member;
900     if (gptr)
901       {
902         member = gptr->gr_mem;
903         while (member && *member)
904           {
905             static fstring name;
906             strcpy(name,*member);
907             if (user_ok(name,snum) &&
908                 password_ok(name,password,pwlen,NULL))
909               return(&name[0]);
910             member++;
911           }
912 #ifdef GROUP_CHECK_PWENT
913         {
914           struct passwd *pwd;
915           static fstring tm;
916           
917           setpwent ();
918           while (pwd = getpwent ()) {
919             if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
920               /* This Entry have PASSWORD and same GID then check pwd */
921               if (password_ok(NULL, password, pwlen, pwd)) {
922                 strcpy(tm, pwd->pw_name);
923                 endpwent ();
924                 return tm;
925               }
926             }
927           }
928           endpwent ();
929         }
930 #endif /* GROUP_CHECK_PWENT */
931       }
932   }      
933 #endif
934   return(NULL);
935 }
936
937
938
939 /****************************************************************************
940 check for authority to login to a service with a given username/password
941 ****************************************************************************/
942 BOOL authorise_login(int snum,char *user,char *password, int pwlen, 
943                      BOOL *guest,BOOL *force,uint16 vuid)
944 {
945   BOOL ok = False;
946   
947   *guest = False;
948   
949 #if DEBUG_PASSWORD
950   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
951 #endif
952
953   /* there are several possabilities:
954      1) login as the given user with given password
955      2) login as a previously registered username with the given password
956      3) login as a session list username with the given password
957      4) login as a previously validated user/password pair
958      5) login as the "user =" user with given password
959      6) login as the "user =" user with no password (guest connection)
960      7) login as guest user with no password
961
962      if the service is guest_only then steps 1 to 5 are skipped
963   */
964
965   if (GUEST_ONLY(snum)) *force = True;
966
967   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
968     {
969
970       user_struct *vuser = get_valid_user_struct(vuid);
971
972       /* check the given username and password */
973       if (!ok && (*user) && user_ok(user,snum)) {
974         ok = password_ok(user,password, pwlen, NULL);
975         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
976       }
977
978       /* check for a previously registered guest username */
979       if (!ok && (vuser != 0) && vuser->guest) {          
980         if (user_ok(vuser->name,snum) &&
981             password_ok(vuser->name, password, pwlen, NULL)) {
982           strcpy(user, vuser->name);
983           vuser->guest = False;
984           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
985           ok = True;
986         }
987       }
988
989
990       /* now check the list of session users */
991       if (!ok)
992         {
993           char *auser;
994           char *user_list = strdup(session_users);
995           if (!user_list) return(False);
996
997           for (auser=strtok(user_list,LIST_SEP); 
998                !ok && auser; 
999                auser = strtok(NULL,LIST_SEP))
1000             {
1001               fstring user2;
1002               strcpy(user2,auser);
1003               if (!user_ok(user2,snum)) continue;
1004                   
1005               if (password_ok(user2,password, pwlen, NULL)) {
1006                 ok = True;
1007                 strcpy(user,user2);
1008                 DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
1009               }
1010             }
1011           free(user_list);
1012         }
1013
1014       /* check for a previously validated username/password pair */
1015       if (!ok && !lp_revalidate(snum) &&
1016           (vuser != 0) && !vuser->guest &&
1017           user_ok(vuser->name,snum)) {
1018         strcpy(user,vuser->name);
1019         *guest = False;
1020         DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
1021         ok = True;
1022       }
1023
1024       /* check for a rhosts entry */
1025       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
1026         ok = True;
1027         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
1028       }
1029
1030       /* check the user= fields and the given password */
1031       if (!ok && lp_username(snum)) {
1032         char *auser;
1033         pstring user_list;
1034         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
1035
1036         string_sub(user_list,"%S",lp_servicename(snum));
1037           
1038         for (auser=strtok(user_list,LIST_SEP);
1039              auser && !ok;
1040              auser = strtok(NULL,LIST_SEP))
1041           {
1042             if (*auser == '@')
1043               {
1044                 auser = validate_group(auser+1,password,pwlen,snum);
1045                 if (auser)
1046                   {
1047                     ok = True;
1048                     strcpy(user,auser);
1049                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
1050                   }
1051               }
1052             else
1053               {
1054                 fstring user2;
1055                 strcpy(user2,auser);
1056                 if (user_ok(user2,snum) && 
1057                     password_ok(user2,password,pwlen,NULL))
1058                   {
1059                     ok = True;
1060                     strcpy(user,user2);
1061                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
1062                   }
1063               }
1064           }
1065       }      
1066     } /* not guest only */
1067
1068   /* check for a normal guest connection */
1069   if (!ok && GUEST_OK(snum))
1070     {
1071       fstring guestname;
1072       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
1073       if (Get_Pwnam(guestname,True))
1074         {
1075           strcpy(user,guestname);
1076           ok = True;
1077           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
1078         }
1079       else
1080         DEBUG(0,("Invalid guest account %s??\n",guestname));
1081       *guest = True;
1082       *force = True;
1083     }
1084
1085   if (ok && !user_ok(user,snum))
1086     {
1087       DEBUG(0,("rejected invalid user %s\n",user));
1088       ok = False;
1089     }
1090
1091   return(ok);
1092 }
1093
1094
1095 /****************************************************************************
1096 read the a hosts.equiv or .rhosts file and check if it
1097 allows this user from this machine
1098 ****************************************************************************/
1099 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
1100 {
1101   pstring buf;
1102   int plus_allowed = 1;
1103   char *file_host;
1104   char *file_user;
1105   FILE *fp = fopen(equiv_file, "r");
1106   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
1107   if (! fp) return False;
1108   while(fgets(buf, sizeof(buf), fp)) 
1109   {
1110     trim_string(buf," "," ");
1111
1112     if (buf[0] != '#' && buf[0] != '\n') 
1113     {
1114       BOOL is_group = False;
1115       int plus = 1;
1116       char *bp = buf;
1117       if (strcmp(buf, "NO_PLUS\n") == 0)
1118       {
1119         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
1120         plus_allowed = 0;
1121       }
1122       else {
1123         if (buf[0] == '+') 
1124         {
1125           bp++;
1126           if (*bp == '\n' && plus_allowed) 
1127           {
1128             /* a bare plus means everbody allowed */
1129             DEBUG(6, ("check_user_equiv everybody allowed\n"));
1130             fclose(fp);
1131             return True;
1132           }
1133         }
1134         else if (buf[0] == '-')
1135         {
1136           bp++;
1137           plus = 0;
1138         }
1139         if (*bp == '@') 
1140         {
1141           is_group = True;
1142           bp++;
1143         }
1144         file_host = strtok(bp, " \t\n");
1145         file_user = strtok(NULL, " \t\n");
1146         DEBUG(7, ("check_user_equiv %s %s\n", file_host, file_user));
1147         if (file_host && *file_host) 
1148         {
1149           BOOL host_ok = False;
1150
1151 #ifdef NETGROUP   
1152           if (is_group)
1153             {
1154               static char *mydomain = NULL;
1155               if (!mydomain)
1156                 yp_get_default_domain(&mydomain);
1157               if (mydomain && innetgr(file_host,remote,user,mydomain))
1158                 host_ok = True;
1159             }
1160 #else
1161           if (is_group)
1162             {
1163               DEBUG(1,("Netgroups not configured - add -DNETGROUP and recompile\n"));
1164               continue;
1165             }
1166 #endif
1167
1168           /* is it this host */
1169           /* the fact that remote has come from a call of gethostbyaddr
1170            * means that it may have the fully qualified domain name
1171            * so we could look up the file version to get it into
1172            * a canonical form, but I would rather just type it
1173            * in full in the equiv file
1174            */
1175           if (!host_ok && !is_group && strequal(remote, file_host))
1176             host_ok = True;
1177
1178           if (!host_ok)
1179             continue;
1180
1181           /* is it this user */
1182           if (file_user == 0 || strequal(user, file_user)) 
1183             {
1184               fclose(fp);
1185               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
1186                         (plus ? "+" : "-"), file_host,
1187                         (file_user ? file_user : "")));
1188               return (plus ? True : False);
1189             }
1190         }
1191       }
1192     }
1193   }
1194   fclose(fp);
1195   return False;
1196 }
1197
1198
1199 /****************************************************************************
1200 check for a possible hosts equiv or rhosts entry for the user
1201 ****************************************************************************/
1202 BOOL check_hosts_equiv(char *user)
1203 {
1204   char *fname = NULL;
1205   pstring rhostsfile;
1206   struct passwd *pass = Get_Pwnam(user,True);
1207
1208   if (!pass) 
1209     return(False);
1210
1211   fname = lp_hosts_equiv();
1212
1213   /* note: don't allow hosts.equiv on root */
1214   if (fname && *fname && (pass->pw_uid != 0))
1215     {
1216       if (check_user_equiv(user,client_name(),fname))
1217         return(True);
1218     }
1219   
1220   if (lp_use_rhosts())
1221     {
1222       char *home = get_home_dir(user);
1223       if (home)
1224         {
1225           sprintf(rhostsfile, "%s/.rhosts", home);
1226           if (check_user_equiv(user,client_name(),rhostsfile))
1227             return(True);
1228         }
1229     }
1230
1231   return(False);
1232 }
1233
1234
1235 int password_client = -1;
1236 static fstring pserver;
1237
1238 /****************************************************************************
1239 attempted support for server level security 
1240 ****************************************************************************/
1241 BOOL server_cryptkey(char *buf)
1242 {
1243   pstring inbuf,outbuf;
1244   fstring pass_protocol;
1245   extern fstring remote_machine;
1246   char *p;
1247   int len;
1248   fstring desthost;
1249   struct in_addr dest_ip;
1250   int port = SMB_PORT;
1251   BOOL ret;
1252
1253   if (password_client >= 0)
1254     close(password_client);
1255   password_client = -1;
1256
1257   if (Protocol < PROTOCOL_NT1) {
1258     strcpy(pass_protocol,"LM1.2X002");
1259   } else {
1260     strcpy(pass_protocol,"NT LM 0.12");
1261   }
1262
1263   bzero(inbuf,sizeof(inbuf));
1264   bzero(outbuf,sizeof(outbuf));
1265
1266   for (p=strtok(lp_passwordserver(),LIST_SEP); p ; p = strtok(NULL,LIST_SEP)) {
1267     strcpy(desthost,p);
1268     standard_sub_basic(desthost);
1269     strupper(desthost);
1270
1271     dest_ip = *interpret_addr2(desthost);
1272     if (zero_ip(dest_ip)) {
1273       DEBUG(1,("Can't resolve address for %s\n",p));
1274       continue;
1275     }
1276
1277     if (ismyip(dest_ip)) {
1278       DEBUG(1,("Password server loop - disabling password server %s\n",p));
1279       continue;
1280     }
1281
1282     password_client = open_socket_out(SOCK_STREAM, &dest_ip, port, SHORT_CONNECT_TIMEOUT);
1283     if (password_client >= 0) {
1284       DEBUG(3,("connected to password server %s\n",p));
1285       StrnCpy(pserver,p,sizeof(pserver)-1);
1286       break;
1287     }
1288   }
1289
1290   if (password_client < 0) {
1291     DEBUG(1,("password server not available\n"));
1292     return(False);
1293   }
1294
1295
1296   /* send a session request (RFC 8002) */
1297
1298   /* put in the destination name */
1299   len = 4;
1300   p = outbuf+len;
1301   name_mangle(desthost,p,' ');
1302   len += name_len(p);
1303
1304   /* and my name */
1305   p = outbuf+len;
1306   name_mangle(remote_machine,p,' ');
1307   len += name_len(p);
1308
1309   _smb_setlen(outbuf,len);
1310   CVAL(outbuf,0) = 0x81;
1311
1312   send_smb(password_client,outbuf);
1313   
1314  
1315   if (!receive_smb(password_client,inbuf,5000) ||
1316       CVAL(inbuf,0) != 0x82) {
1317     DEBUG(1,("%s rejected the session\n",pserver));
1318     close(password_client); password_client = -1;
1319     return(False);
1320   }
1321
1322   DEBUG(3,("got session\n"));
1323
1324   bzero(outbuf,smb_size);
1325
1326   /* setup the protocol string */
1327   set_message(outbuf,0,strlen(pass_protocol)+2,True);
1328   p = smb_buf(outbuf);
1329   *p++ = 2;
1330   strcpy(p,pass_protocol);
1331
1332   CVAL(outbuf,smb_com) = SMBnegprot;
1333   CVAL(outbuf,smb_flg) = 0x8;
1334   SSVAL(outbuf,smb_flg2,0x1);
1335
1336   send_smb(password_client,outbuf);
1337   ret = receive_smb(password_client,inbuf,5000);
1338
1339   if (!ret || CVAL(inbuf,smb_rcls) || SVAL(inbuf,smb_vwv0)) {
1340     DEBUG(1,("%s rejected the protocol\n",pserver));
1341     close(password_client); password_client= -1;
1342     return(False);
1343   }
1344
1345   if (!(CVAL(inbuf,smb_vwv1) & 1)) {
1346     DEBUG(1,("%s isn't in user level security mode\n",pserver));
1347     close(password_client); password_client= -1;
1348     return(False);
1349   }
1350
1351   memcpy(buf,inbuf,smb_len(inbuf)+4);
1352
1353   DEBUG(3,("password server OK\n"));
1354
1355   return(True);
1356 }
1357
1358 /****************************************************************************
1359 attempted support for server level security 
1360 ****************************************************************************/
1361 BOOL server_validate(char *buf)
1362 {
1363   pstring inbuf,outbuf;  
1364   BOOL ret;
1365
1366   if (password_client < 0) {
1367     DEBUG(1,("%s not connected\n",pserver));
1368     return(False);
1369   }  
1370
1371   bzero(inbuf,sizeof(inbuf));
1372   memcpy(outbuf,buf,sizeof(outbuf));
1373
1374   /* send a session setup command */
1375   CVAL(outbuf,smb_flg) = 0x8;
1376   SSVAL(outbuf,smb_flg2,0x1);
1377   CVAL(outbuf,smb_vwv0) = 0xFF;
1378
1379   set_message(outbuf,smb_numwords(outbuf),smb_buflen(outbuf),False);
1380
1381   SCVAL(inbuf,smb_rcls,1);
1382
1383   send_smb(password_client,outbuf);
1384   ret = receive_smb(password_client,inbuf,5000);
1385
1386   if (!ret || CVAL(inbuf,smb_rcls) != 0) {
1387     DEBUG(1,("password server %s rejected the password\n",pserver));
1388     return(False);
1389   }
1390
1391   /* if logged in as guest then reject */
1392   if ((SVAL(inbuf,smb_vwv2) & 1) != 0) {
1393     DEBUG(1,("password server %s gave us guest only\n",pserver));
1394     return(False);
1395   }
1396
1397   DEBUG(3,("password server %s accepted the password\n",pserver));
1398
1399 #if !KEEP_PASSWORD_SERVER_OPEN
1400   close(password_client); password_client= -1;
1401 #endif
1402
1403   return(True);
1404 }
1405
1406