2 Unix SMB/Netbios implementation.
4 Password and authentication handling
5 Copyright (C) Andrew Tridgell 1992-1998
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.
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.
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.
24 extern int DEBUGLEVEL
;
27 /* users from session setup */
28 static pstring session_users
="";
31 extern pstring global_myname
;
32 extern fstring global_myworkgroup
;
34 /* Data to do lanman1/2 password challenge. */
35 static unsigned char saved_challenge
[8];
36 static BOOL challenge_sent
=False
;
38 /*******************************************************************
39 Get the next challenge value - no repeats.
40 ********************************************************************/
41 void generate_next_challenge(char *challenge
)
45 * Leave this ifdef'd out while we test
46 * the new crypto random number generator.
49 unsigned char buf
[16];
50 static int counter
= 0;
54 /* get a sort-of random number */
56 v1
= (counter
++) + getpid() + tval
.tv_sec
;
57 v2
= (counter
++) * getpid() + tval
.tv_usec
;
58 SIVAL(challenge
,0,v1
);
59 SIVAL(challenge
,4,v2
);
61 /* mash it up with md4 */
62 mdfour(buf
, (unsigned char *)challenge
, 8);
66 generate_random_buffer(buf
,8,False
);
68 memcpy(saved_challenge
, buf
, 8);
69 memcpy(challenge
,buf
,8);
70 challenge_sent
= True
;
73 /*******************************************************************
74 set the last challenge sent, usually from a password server
75 ********************************************************************/
76 BOOL
set_challenge(unsigned char *challenge
)
78 memcpy(saved_challenge
,challenge
,8);
79 challenge_sent
= True
;
83 /*******************************************************************
84 get the last challenge sent
85 ********************************************************************/
86 static BOOL
last_challenge(unsigned char *challenge
)
88 if (!challenge_sent
) return(False
);
89 memcpy(challenge
,saved_challenge
,8);
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;
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
)
104 if (vuid
== UID_FIELD_INVALID
)
107 if ((vuid
>= (uint16
)num_validated_users
) ||
108 (validated_users
[vuid
].uid
== (uid_t
)-1) || (validated_users
[vuid
].gid
== (gid_t
)-1))
110 return &validated_users
[vuid
];
113 /****************************************************************************
115 ****************************************************************************/
116 void invalidate_vuid(uint16 vuid
)
118 user_struct
*vuser
= get_valid_user_struct(vuid
);
120 if (vuser
== NULL
) return;
122 vuser
->uid
= (uid_t
)-1;
123 vuser
->gid
= (gid_t
)-1;
127 /* same number of igroups as groups */
131 free((char *)vuser
->groups
);
134 free((char *)vuser
->sids
);
137 vuser
->groups
= NULL
;
141 /****************************************************************************
142 return a validated username
143 ****************************************************************************/
144 char *validated_username(uint16 vuid
)
146 user_struct
*vuser
= get_valid_user_struct(vuid
);
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
)
160 gid_t
*groups
= NULL
;
162 if (-1 == initgroups(user
,gid
))
166 DEBUG(0,("Unable to initgroups!\n"));
167 if (gid
< 0 || gid
> 16000 || uid
< 0 || uid
> 16000)
169 DEBUG(0,("This is probably a problem with the account %s\n", user
));
175 ngroups
= sys_getgroups(0,&grp
);
181 if((groups
= (gid_t
*)malloc(sizeof(gid_t
)*ngroups
)) == NULL
)
183 DEBUG(0,("setup_groups malloc fail !\n"));
187 ngroups
= sys_getgroups(ngroups
,groups
);
189 (*p_ngroups
) = ngroups
;
190 (*p_groups
) = groups
;
192 DEBUG( 3, ( "%s is in %d groups: ", user
, ngroups
) );
193 for (i
= 0; i
< ngroups
; i
++ )
195 DEBUG( 3, ( "%s%d", (i
? ", " : ""), (int)groups
[i
] ) );
197 DEBUG( 3, ( "\n" ) );
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
)
211 struct passwd
*pwfile
; /* for getting real name from passwd file */
213 /* Ensure no vuid gets registered in share level security. */
214 if(lp_security() == SEC_SHARE
)
215 return UID_FIELD_INVALID
;
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
227 * Jeremy Allison. (jallison@whistle.com).
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 */
238 validated_users
= (user_struct
*)Realloc(validated_users
,
240 (num_validated_users
+1));
242 if (!validated_users
)
244 DEBUG(0,("Failed to realloc users struct!\n"));
245 num_validated_users
= 0;
246 return UID_FIELD_INVALID
;
249 vuser
= &validated_users
[num_validated_users
];
250 num_validated_users
++;
254 vuser
->guest
= guest
;
255 fstrcpy(vuser
->name
,unix_name
);
256 fstrcpy(vuser
->requested_name
,requested_name
);
262 vuser
->groups
= NULL
;
264 /* Find all the groups this uid is in and store them.
265 Used by become_user() */
266 setup_groups(unix_name
,uid
,gid
,
270 DEBUG(3,("uid %d registered to name %s\n",(int)uid
,unix_name
));
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
)
277 DEBUG(3, ("User name: %s\tReal name: %s\n",vuser
->name
,pwfile
->pw_gecos
));
278 fstrcpy(vuser
->real_name
, pwfile
->pw_gecos
);
282 return (uint16
)((num_validated_users
- 1) + VUID_OFFSET
);
286 /****************************************************************************
287 add a name to the session users list
288 ****************************************************************************/
289 void add_session_user(char *user
)
292 StrnCpy(suser
,user
,sizeof(suser
)-1);
294 if (!Get_Pwnam(suser
,True
)) return;
296 if (suser
&& *suser
&& !in_list(suser
,session_users
,False
))
298 if (strlen(suser
) + strlen(session_users
) + 2 >= sizeof(pstring
))
299 DEBUG(1,("Too many session users??\n"));
302 pstrcat(session_users
," ");
303 pstrcat(session_users
,suser
);
309 /****************************************************************************
310 update the encrypted smbpasswd file from the plaintext username and password
311 *****************************************************************************/
312 static BOOL
update_smbpassword_file(char *user
, char *password
)
314 struct smb_passwd
*smbpw
;
318 smbpw
= getsmbpwnam(user
);
322 DEBUG(0,("getsmbpwnam returned NULL\n"));
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
);
330 DEBUG(3,("change_oem_password returned False\n"));
340 /****************************************************************************
341 core of smb password checking routine.
342 ****************************************************************************/
343 BOOL
smb_password_check(char *password
, unsigned char *part_passwd
, unsigned char *c8
)
345 /* Finish the encryption of part_passwd. */
346 unsigned char p21
[21];
347 unsigned char p24
[24];
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
)
356 memcpy(p21
,part_passwd
,16);
361 DEBUG(100,("Part password (P16) was |"));
362 for(i
= 0; i
< 16; i
++)
363 DEBUG(100,("%X ", (unsigned char)part_passwd
[i
]));
365 DEBUG(100,("Password from client was |"));
366 for(i
= 0; i
< 24; i
++)
367 DEBUG(100,("%X ", (unsigned char)password
[i
]));
369 DEBUG(100,("Given challenge was |"));
370 for(i
= 0; i
< 8; i
++)
371 DEBUG(100,("%X ", (unsigned char)c8
[i
]));
373 DEBUG(100,("Value from encryption was |"));
374 for(i
= 0; i
< 24; i
++)
375 DEBUG(100,("%X ", (unsigned char)p24
[i
]));
379 return (memcmp(p24
, password
, 24) == 0);
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])
391 if (!lm_pass
|| !smb_pass
) return(False
);
393 DEBUG(4,("Checking SMB password for user %s\n",
394 smb_pass
->smb_name
));
396 if(smb_pass
->acct_ctrl
& ACB_DISABLED
) {
397 DEBUG(3,("account for user %s was disabled.\n",
398 smb_pass
->smb_name
));
404 DEBUG(5,("use last SMBnegprot challenge\n"));
405 if (!last_challenge(challenge
))
407 DEBUG(1,("no challenge done - password failed\n"));
413 DEBUG(5,("challenge received\n"));
414 memcpy(challenge
, chal
, 8);
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).
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
,
425 DEBUG(4,("NT MD4 password check succeeded\n"));
428 DEBUG(4,("NT MD4 password check failed\n"));
431 /* Try against the lanman password. smb_pass->smb_passwd == NULL means
432 no password, allow access. */
434 DEBUG(4,("Checking LM MD4 password\n"));
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
));
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"));
450 DEBUG(4,("LM MD4 password check failed\n"));
456 /****************************************************************************
457 check if a username/password is OK assuming the password is a 24 byte
459 return True if the password is correct, False otherwise
460 ****************************************************************************/
462 BOOL
pass_check_smb(char *user
, char *domain
,
463 uchar
*chal
, uchar
*lm_pwd
, uchar
*nt_pwd
,
467 struct smb_passwd
*smb_pass
;
469 if (!lm_pwd
|| !nt_pwd
)
474 if (pwd
!= NULL
&& user
== NULL
)
476 pass
= (struct passwd
*) pwd
;
477 user
= pass
->pw_name
;
481 pass
= Get_Pwnam(user
,True
);
486 DEBUG(3,("Couldn't find user %s\n",user
));
490 smb_pass
= getsmbpwnam(user
);
492 if (smb_pass
== NULL
)
494 DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user
));
498 /* Quit if the account was disabled. */
499 if(smb_pass
->acct_ctrl
& ACB_DISABLED
) {
500 DEBUG(3,("account for user %s was disabled.\n", user
));
504 /* Ensure the uid's match */
505 if (smb_pass
->smb_userid
!= pass
->pw_uid
)
507 DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
511 if (lm_pwd
[0] == '\0' && IS_BITS_SET_ALL(smb_pass
->acct_ctrl
, ACB_PWNOTREQ
) && lp_null_passwords())
513 DEBUG(3,("account for user %s has no password and null passwords are allowed.\n", smb_pass
->smb_name
));
517 if (smb_password_ok(smb_pass
, chal
, lm_pwd
, nt_pwd
))
522 DEBUG(3,("Error smb_password_check failed\n"));
526 /****************************************************************************
527 check if a username/password pair is OK either via the system password
528 database or the encrypted SMB password database
529 return True if the password is correct, False otherwise
530 ****************************************************************************/
531 BOOL
password_ok(char *user
, char *password
, int pwlen
, struct passwd
*pwd
)
533 if (pwlen
== 24 || (lp_encrypted_passwords() && (pwlen
== 0) && lp_null_passwords()))
535 /* if 24 bytes long assume it is an encrypted password */
538 if (!last_challenge(challenge
))
540 DEBUG(0,("Error: challenge not done for user=%s\n", user
));
544 return pass_check_smb(user
, global_myworkgroup
,
545 challenge
, (uchar
*)password
, (uchar
*)password
, pwd
);
548 return pass_check(user
, password
, pwlen
, pwd
,
549 lp_update_encrypted() ?
550 update_smbpassword_file
: NULL
);
553 /****************************************************************************
554 check if a username is valid
555 ****************************************************************************/
556 BOOL
user_ok(char *user
,int snum
)
558 pstring valid
, invalid
;
561 StrnCpy(valid
, lp_valid_users(snum
), sizeof(pstring
));
562 StrnCpy(invalid
, lp_invalid_users(snum
), sizeof(pstring
));
564 string_sub(valid
,"%S",lp_servicename(snum
));
565 string_sub(invalid
,"%S",lp_servicename(snum
));
567 ret
= !user_in_list(user
,invalid
);
569 if (ret
&& valid
&& *valid
) {
570 ret
= user_in_list(user
,valid
);
573 if (ret
&& lp_onlyuser(snum
)) {
574 char *user_list
= lp_username(snum
);
575 string_sub(user_list
,"%S",lp_servicename(snum
));
576 ret
= user_in_list(user
,user_list
);
585 /****************************************************************************
586 validate a group username entry. Return the username or NULL
587 ****************************************************************************/
588 static char *validate_group(char *group
,char *password
,int pwlen
,int snum
)
592 char *host
, *user
, *domain
;
594 while (getnetgrent(&host
, &user
, &domain
)) {
596 if (user_ok(user
, snum
) &&
597 password_ok(user
,password
,pwlen
,NULL
)) {
609 struct group
*gptr
= (struct group
*)getgrnam(group
);
613 member
= gptr
->gr_mem
;
614 while (member
&& *member
)
617 fstrcpy(name
,*member
);
618 if (user_ok(name
,snum
) &&
619 password_ok(name
,password
,pwlen
,NULL
))
623 #ifdef GROUP_CHECK_PWENT
629 while (pwd
= getpwent ()) {
630 if (*(pwd
->pw_passwd
) && pwd
->pw_gid
== gptr
->gr_gid
) {
631 /* This Entry have PASSWORD and same GID then check pwd */
632 if (password_ok(NULL
, password
, pwlen
, pwd
)) {
633 fstrcpy(tm
, pwd
->pw_name
);
641 #endif /* GROUP_CHECK_PWENT */
650 /****************************************************************************
651 check for authority to login to a service with a given username/password
652 ****************************************************************************/
653 BOOL
authorise_login(int snum
,char *user
,char *password
, int pwlen
,
654 BOOL
*guest
,BOOL
*force
,uint16 vuid
)
661 DEBUG(100,("checking authorisation on user=%s pass=%s\n",user
,password
));
664 /* there are several possibilities:
665 1) login as the given user with given password
666 2) login as a previously registered username with the given password
667 3) login as a session list username with the given password
668 4) login as a previously validated user/password pair
669 5) login as the "user =" user with given password
670 6) login as the "user =" user with no password (guest connection)
671 7) login as guest user with no password
673 if the service is guest_only then steps 1 to 5 are skipped
676 if (GUEST_ONLY(snum
)) *force
= True
;
678 if (!(GUEST_ONLY(snum
) && GUEST_OK(snum
)))
681 user_struct
*vuser
= get_valid_user_struct(vuid
);
683 /* check the given username and password */
684 if (!ok
&& (*user
) && user_ok(user
,snum
)) {
685 ok
= password_ok(user
,password
, pwlen
, NULL
);
686 if (ok
) DEBUG(3,("ACCEPTED: given username password ok\n"));
689 /* check for a previously registered guest username */
690 if (!ok
&& (vuser
!= 0) && vuser
->guest
) {
691 if (user_ok(vuser
->name
,snum
) &&
692 password_ok(vuser
->name
, password
, pwlen
, NULL
)) {
693 fstrcpy(user
, vuser
->name
);
694 vuser
->guest
= False
;
695 DEBUG(3,("ACCEPTED: given password with registered user %s\n", user
));
701 /* now check the list of session users */
705 char *user_list
= strdup(session_users
);
706 if (!user_list
) return(False
);
708 for (auser
=strtok(user_list
,LIST_SEP
);
710 auser
= strtok(NULL
,LIST_SEP
))
713 fstrcpy(user2
,auser
);
714 if (!user_ok(user2
,snum
)) continue;
716 if (password_ok(user2
,password
, pwlen
, NULL
)) {
719 DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
725 /* check for a previously validated username/password pair */
726 if (!ok
&& (!lp_revalidate(snum
) || lp_security() > SEC_SHARE
) &&
727 (vuser
!= 0) && !vuser
->guest
&&
728 user_ok(vuser
->name
,snum
)) {
729 fstrcpy(user
,vuser
->name
);
731 DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
735 /* check for a rhosts entry */
736 if (!ok
&& user_ok(user
,snum
) && check_hosts_equiv(user
)) {
738 DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
741 /* check the user= fields and the given password */
742 if (!ok
&& lp_username(snum
)) {
745 StrnCpy(user_list
,lp_username(snum
),sizeof(pstring
));
747 string_sub(user_list
,"%S",lp_servicename(snum
));
749 for (auser
=strtok(user_list
,LIST_SEP
);
751 auser
= strtok(NULL
,LIST_SEP
))
755 auser
= validate_group(auser
+1,password
,pwlen
,snum
);
760 DEBUG(3,("ACCEPTED: group username and given password ok\n"));
766 fstrcpy(user2
,auser
);
767 if (user_ok(user2
,snum
) &&
768 password_ok(user2
,password
,pwlen
,NULL
))
772 DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
777 } /* not guest only */
779 /* check for a normal guest connection */
780 if (!ok
&& GUEST_OK(snum
))
783 StrnCpy(guestname
,lp_guestaccount(snum
),sizeof(guestname
)-1);
784 if (Get_Pwnam(guestname
,True
))
786 fstrcpy(user
,guestname
);
788 DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
791 DEBUG(0,("Invalid guest account %s??\n",guestname
));
796 if (ok
&& !user_ok(user
,snum
))
798 DEBUG(0,("rejected invalid user %s\n",user
));
806 /****************************************************************************
807 read the a hosts.equiv or .rhosts file and check if it
808 allows this user from this machine
809 ****************************************************************************/
810 static BOOL
check_user_equiv(char *user
, char *remote
, char *equiv_file
)
813 int plus_allowed
= 1;
816 FILE *fp
= sys_fopen(equiv_file
, "r");
817 DEBUG(5, ("check_user_equiv %s %s %s\n", user
, remote
, equiv_file
));
818 if (! fp
) return False
;
819 while(fgets(buf
, sizeof(buf
), fp
))
821 trim_string(buf
," "," ");
823 if (buf
[0] != '#' && buf
[0] != '\n')
825 BOOL is_group
= False
;
828 if (strcmp(buf
, "NO_PLUS\n") == 0)
830 DEBUG(6, ("check_user_equiv NO_PLUS\n"));
837 if (*bp
== '\n' && plus_allowed
)
839 /* a bare plus means everbody allowed */
840 DEBUG(6, ("check_user_equiv everybody allowed\n"));
845 else if (buf
[0] == '-')
855 file_host
= strtok(bp
, " \t\n");
856 file_user
= strtok(NULL
, " \t\n");
857 DEBUG(7, ("check_user_equiv %s %s\n", file_host
? file_host
: "(null)",
858 file_user
? file_user
: "(null)" ));
859 if (file_host
&& *file_host
)
861 BOOL host_ok
= False
;
863 #if defined(HAVE_NETGROUP) && defined(HAVE_YP_GET_DEFAULT_DOMAIN)
866 static char *mydomain
= NULL
;
868 yp_get_default_domain(&mydomain
);
869 if (mydomain
&& innetgr(file_host
,remote
,user
,mydomain
))
875 DEBUG(1,("Netgroups not configured\n"));
880 /* is it this host */
881 /* the fact that remote has come from a call of gethostbyaddr
882 * means that it may have the fully qualified domain name
883 * so we could look up the file version to get it into
884 * a canonical form, but I would rather just type it
885 * in full in the equiv file
887 if (!host_ok
&& !is_group
&& strequal(remote
, file_host
))
893 /* is it this user */
894 if (file_user
== 0 || strequal(user
, file_user
))
897 DEBUG(5, ("check_user_equiv matched %s%s %s\n",
898 (plus
? "+" : "-"), file_host
,
899 (file_user
? file_user
: "")));
900 return (plus
? True
: False
);
911 /****************************************************************************
912 check for a possible hosts equiv or rhosts entry for the user
913 ****************************************************************************/
914 BOOL
check_hosts_equiv(char *user
)
918 struct passwd
*pass
= Get_Pwnam(user
,True
);
923 fname
= lp_hosts_equiv();
925 /* note: don't allow hosts.equiv on root */
926 if (fname
&& *fname
&& (pass
->pw_uid
!= 0)) {
928 if (check_user_equiv(user
,client_name(Client
),fname
))
934 char *home
= get_home_dir(user
);
937 slprintf(rhostsfile
, sizeof(rhostsfile
)-1, "%s/.rhosts", home
);
938 if (check_user_equiv(user
,client_name(Client
),rhostsfile
))
947 /****************************************************************************
948 return the client state structure
949 ****************************************************************************/
950 struct cli_state
*server_client(void)
952 static struct cli_state pw_cli
;
956 /****************************************************************************
957 support for server level security
958 ****************************************************************************/
959 struct cli_state
*server_cryptkey(void)
961 struct cli_state
*cli
;
963 struct in_addr dest_ip
;
964 extern fstring local_machine
;
966 BOOL connected_ok
= False
;
967 struct nmb_name calling
, called
;
969 cli
= server_client();
971 if (!cli_initialise(cli
))
974 p
= lp_passwordserver();
975 while(p
&& next_token( &p
, desthost
, LIST_SEP
, sizeof(desthost
))) {
976 standard_sub_basic(desthost
);
979 if(!resolve_name( desthost
, &dest_ip
, 0x20)) {
980 DEBUG(1,("server_cryptkey: Can't resolve address for %s\n",desthost
));
984 if (ismyip(dest_ip
)) {
985 DEBUG(1,("Password server loop - disabling password server %s\n",desthost
));
989 if (cli_connect(cli
, desthost
, &dest_ip
)) {
990 DEBUG(3,("connected to password server %s\n",desthost
));
997 DEBUG(0,("password server not available\n"));
1002 make_nmb_name(&calling
, local_machine
, 0x0 , scope
);
1003 make_nmb_name(&called
, desthost
, 0x20, scope
);
1005 if (!cli_session_request(cli
, &calling
, &called
)) {
1006 /* try with *SMBSERVER if the first name fails */
1008 make_nmb_name(&called
, "*SMBSERVER", 0x20, scope
);
1009 if (!cli_initialise(cli
) ||
1010 !cli_connect(cli
, desthost
, &dest_ip
) ||
1011 !cli_session_request(cli
, &calling
, &called
)) {
1012 DEBUG(1,("%s rejected the session\n",desthost
));
1018 DEBUG(3,("got session\n"));
1020 if (!cli_negprot(cli
)) {
1021 DEBUG(1,("%s rejected the negprot\n",desthost
));
1026 if (cli
->protocol
< PROTOCOL_LANMAN2
||
1027 !(cli
->sec_mode
& 1)) {
1028 DEBUG(1,("%s isn't in user level security mode\n",desthost
));
1033 DEBUG(3,("password server OK\n"));
1038 /****************************************************************************
1039 validate a password with the password server
1040 ****************************************************************************/
1041 BOOL
server_validate(char *user
, char *domain
,
1042 char *pass
, int passlen
,
1043 char *ntpass
, int ntpasslen
)
1045 struct cli_state
*cli
;
1046 static unsigned char badpass
[24];
1047 static BOOL tested_password_server
= False
;
1048 static BOOL bad_password_server
= False
;
1050 cli
= server_client();
1052 if (!cli
->initialised
) {
1053 DEBUG(1,("password server %s is not connected\n", cli
->desthost
));
1058 memset(badpass
, 0x1f, sizeof(badpass
));
1060 if((passlen
== sizeof(badpass
)) && !memcmp(badpass
, pass
, passlen
)) {
1062 * Very unlikely, our random bad password is the same as the users
1064 memset(badpass
, badpass
[0]+1, sizeof(badpass
));
1068 * Attempt a session setup with a totally incorrect password.
1069 * If this succeeds with the guest bit *NOT* set then the password
1070 * server is broken and is not correctly setting the guest bit. We
1071 * need to detect this as some versions of NT4.x are broken. JRA.
1074 if(!tested_password_server
) {
1075 if (cli_session_setup(cli
, user
, (char *)badpass
, sizeof(badpass
),
1076 (char *)badpass
, sizeof(badpass
), domain
)) {
1079 * We connected to the password server so we
1080 * can say we've tested it.
1082 tested_password_server
= True
;
1084 if ((SVAL(cli
->inbuf
,smb_vwv2
) & 1) == 0) {
1085 DEBUG(0,("server_validate: password server %s allows users as non-guest \
1086 with a bad password.\n", cli
->desthost
));
1087 DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1088 use this machine as the password server.\n"));
1092 * Password server has the bug.
1094 bad_password_server
= True
;
1102 * We have already tested the password server.
1103 * Fail immediately if it has the bug.
1106 if(bad_password_server
) {
1107 DEBUG(0,("server_validate: [1] password server %s allows users as non-guest \
1108 with a bad password.\n", cli
->desthost
));
1109 DEBUG(0,("server_validate: [1] This is broken (and insecure) behaviour. Please do not \
1110 use this machine as the password server.\n"));
1116 * Now we know the password server will correctly set the guest bit, or is
1117 * not guest enabled, we can try with the real password.
1120 if (!cli_session_setup(cli
, user
, pass
, passlen
, ntpass
, ntpasslen
, domain
)) {
1121 DEBUG(1,("password server %s rejected the password\n", cli
->desthost
));
1125 /* if logged in as guest then reject */
1126 if ((SVAL(cli
->inbuf
,smb_vwv2
) & 1) != 0) {
1127 DEBUG(1,("password server %s gave us guest only\n", cli
->desthost
));
1138 /***********************************************************************
1139 Do the same as security=server, but using NT Domain calls and a session
1140 key from the machine password.
1141 ************************************************************************/
1143 BOOL
domain_client_validate( char *user
, char *domain
,
1144 char *smb_apasswd
, int smb_apasslen
,
1145 char *smb_ntpasswd
, int smb_ntpasslen
,
1148 unsigned char local_challenge
[8];
1149 unsigned char local_lm_response
[24];
1150 unsigned char local_nt_reponse
[24];
1151 unsigned char trust_passwd
[16];
1152 fstring remote_machine
;
1154 struct in_addr dest_ip
;
1155 NET_ID_INFO_CTR ctr
;
1156 NET_USER_INFO_3 info3
;
1157 struct cli_state cli
;
1159 BOOL connected_ok
= False
;
1160 struct nmb_name calling
, called
;
1162 if(user_exists
!= NULL
)
1163 *user_exists
= True
; /* Only set false on a very specific error. */
1166 * Check that the requested domain is not our own machine name.
1167 * If it is, we should never check the PDC here, we use our own local
1171 if(strequal( domain
, global_myname
)) {
1172 DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1177 * Next, check that the passwords given were encrypted.
1180 if(((smb_apasslen
!= 24) && (smb_apasslen
!= 0)) ||
1181 ((smb_ntpasslen
!= 24) && (smb_ntpasslen
!= 0))) {
1184 * Not encrypted - do so.
1187 DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1188 generate_random_buffer( local_challenge
, 8, False
);
1189 SMBencrypt( (uchar
*)smb_apasswd
, local_challenge
, local_lm_response
);
1190 SMBNTencrypt((uchar
*)smb_ntpasswd
, local_challenge
, local_nt_reponse
);
1193 smb_apasswd
= (char *)local_lm_response
;
1194 smb_ntpasswd
= (char *)local_nt_reponse
;
1198 * Encrypted - get the challenge we sent for these
1202 if (!last_challenge(local_challenge
)) {
1203 DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1209 * Get the machine account password.
1211 if (!trust_get_passwd( trust_passwd
, global_myworkgroup
, global_myname
))
1217 * At this point, smb_apasswd points to the lanman response to
1218 * the challenge in local_challenge, and smb_ntpasswd points to
1219 * the NT response to the challenge in local_challenge. Ship
1220 * these over the secure channel to a domain controller and
1221 * see if they were valid.
1226 if(cli_initialise(&cli
) == False
) {
1227 DEBUG(0,("domain_client_validate: unable to initialize client connection.\n"));
1232 * Treat each name in the 'password server =' line as a potential
1233 * PDC/BDC. Contact each in turn and try and authenticate.
1236 p
= lp_passwordserver();
1237 while(p
&& next_token(&p
,remote_machine
,LIST_SEP
,sizeof(remote_machine
))) {
1239 standard_sub_basic(remote_machine
);
1240 strupper(remote_machine
);
1242 if(!resolve_name( remote_machine
, &dest_ip
, 0x20)) {
1243 DEBUG(1,("domain_client_validate: Can't resolve address for %s\n", remote_machine
));
1247 if (ismyip(dest_ip
)) {
1248 DEBUG(1,("domain_client_validate: Password server loop - not using password server %s\n",remote_machine
));
1252 if (!cli_connect(&cli
, remote_machine
, &dest_ip
)) {
1253 DEBUG(0,("domain_client_validate: unable to connect to SMB server on \
1254 machine %s. Error was : %s.\n", remote_machine
, cli_errstr(&cli
) ));
1258 make_nmb_name(&calling
, global_myname
, 0x0 , scope
);
1259 make_nmb_name(&called
, remote_machine
, 0x20, scope
);
1261 if (!cli_session_request(&cli
, &calling
, &called
))
1263 DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
1264 Error was : %s.\n", remote_machine
, cli_errstr(&cli
) ));
1269 cli
.protocol
= PROTOCOL_NT1
;
1271 if (!cli_negprot(&cli
)) {
1272 DEBUG(0,("domain_client_validate: machine %s rejected the negotiate protocol. \
1273 Error was : %s.\n", remote_machine
, cli_errstr(&cli
) ));
1278 if (cli
.protocol
!= PROTOCOL_NT1
) {
1279 DEBUG(0,("domain_client_validate: machine %s didn't negotiate NT protocol.\n",
1286 * Do an anonymous session setup.
1289 if (!cli_session_setup(&cli
, "", "", 0, "", 0, "")) {
1290 DEBUG(0,("domain_client_validate: machine %s rejected the session setup. \
1291 Error was : %s.\n", remote_machine
, cli_errstr(&cli
) ));
1296 if (!(cli
.sec_mode
& 1)) {
1297 DEBUG(1,("domain_client_validate: machine %s isn't in user level security mode\n",
1303 if (!cli_send_tconX(&cli
, "IPC$", "IPC", "", 1)) {
1304 DEBUG(0,("domain_client_validate: machine %s rejected the tconX on the IPC$ share. \
1305 Error was : %s.\n", remote_machine
, cli_errstr(&cli
) ));
1311 * We have an anonymous connection to IPC$.
1313 connected_ok
= True
;
1317 if (!connected_ok
) {
1318 DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
1324 * Ok - we have an anonymous connection to the IPC$ share.
1325 * Now start the NT Domain stuff :-).
1328 if(cli_nt_session_open(&cli
, PIPE_NETLOGON
) == False
) {
1329 DEBUG(0,("domain_client_validate: unable to open the domain client session to \
1330 machine %s. Error was : %s.\n", remote_machine
, cli_errstr(&cli
)));
1331 cli_nt_session_close(&cli
);
1337 if(cli_nt_setup_creds(&cli
, trust_passwd
) == False
) {
1338 DEBUG(0,("domain_client_validate: unable to setup the PDC credentials to machine \
1339 %s. Error was : %s.\n", remote_machine
, cli_errstr(&cli
)));
1340 cli_nt_session_close(&cli
);
1346 /* We really don't care what LUID we give the user. */
1347 generate_random_buffer( (unsigned char *)&smb_uid_low
, 4, False
);
1349 if(cli_nt_login_network(&cli
, domain
, user
, smb_uid_low
, (char *)local_challenge
,
1350 ((smb_apasslen
!= 0) ? smb_apasswd
: NULL
),
1351 ((smb_ntpasslen
!= 0) ? smb_ntpasswd
: NULL
),
1352 &ctr
, &info3
) == False
) {
1355 cli_error(&cli
, NULL
, NULL
, &nt_rpc_err
);
1356 DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
1357 %s to Domain controller %s. Error was %s.\n", user
, domain
, remote_machine
, cli_errstr(&cli
)));
1358 cli_nt_session_close(&cli
);
1362 if((nt_rpc_err
== NT_STATUS_NO_SUCH_USER
) && (user_exists
!= NULL
))
1363 *user_exists
= False
;
1369 * Here, if we really want it, we have lots of info about the user in info3.
1374 * We don't actually need to do this - plus it fails currently with
1375 * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
1379 if(cli_nt_logoff(&cli
, &ctr
) == False
) {
1380 DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
1381 %s to Domain controller %s. Error was %s.\n", user
, domain
, remote_machine
, cli_errstr(&cli
)));
1382 cli_nt_session_close(&cli
);
1389 cli_nt_session_close(&cli
);