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;
26 extern struct in_addr ipzero;
28 /* users from session setup */
29 static pstring session_users="";
32 extern pstring global_myname;
33 extern fstring global_myworkgroup;
35 /* Data to do lanman1/2 password challenge. */
36 static unsigned char saved_challenge[8];
37 static BOOL challenge_sent=False;
39 /*******************************************************************
40 Get the next challenge value - no repeats.
41 ********************************************************************/
42 void generate_next_challenge(char *challenge)
46 * Leave this ifdef'd out while we test
47 * the new crypto random number generator.
50 unsigned char buf[16];
51 static int counter = 0;
55 /* get a sort-of random number */
57 v1 = (counter++) + getpid() + tval.tv_sec;
58 v2 = (counter++) * getpid() + tval.tv_usec;
59 SIVAL(challenge,0,v1);
60 SIVAL(challenge,4,v2);
62 /* mash it up with md4 */
63 mdfour(buf, (unsigned char *)challenge, 8);
67 generate_random_buffer(buf,8,False);
69 memcpy(saved_challenge, buf, 8);
70 memcpy(challenge,buf,8);
71 challenge_sent = True;
74 /*******************************************************************
75 set the last challenge sent, usually from a password server
76 ********************************************************************/
77 BOOL set_challenge(unsigned char *challenge)
79 memcpy(saved_challenge,challenge,8);
80 challenge_sent = True;
84 /*******************************************************************
85 get the last challenge sent
86 ********************************************************************/
87 static BOOL last_challenge(unsigned char *challenge)
89 if (!challenge_sent) return(False);
90 memcpy(challenge,saved_challenge,8);
94 /* this holds info on user ids that are already validated for this VC */
95 static user_struct *validated_users = NULL;
96 static int num_validated_users = 0;
98 /****************************************************************************
99 check if a uid has been validated, and return an pointer to the user_struct
100 if it has. NULL if not. vuid is biased by an offset. This allows us to
101 tell random client vuid's (normally zero) from valid vuids.
102 ****************************************************************************/
103 user_struct *get_valid_user_struct(uint16 vuid)
105 if (vuid == UID_FIELD_INVALID)
108 if ((vuid >= (uint16)num_validated_users) ||
109 (validated_users[vuid].uid == (uid_t)-1) || (validated_users[vuid].gid == (gid_t)-1))
111 return &validated_users[vuid];
114 /****************************************************************************
116 ****************************************************************************/
117 void invalidate_vuid(uint16 vuid)
119 user_struct *vuser = get_valid_user_struct(vuid);
121 if (vuser == NULL) return;
123 vuser->uid = (uid_t)-1;
124 vuser->gid = (gid_t)-1;
128 /* same number of igroups as groups */
132 free((char *)vuser->groups);
135 free((char *)vuser->sids);
138 vuser->groups = NULL;
142 /****************************************************************************
143 return a validated username
144 ****************************************************************************/
145 char *validated_username(uint16 vuid)
147 user_struct *vuser = get_valid_user_struct(vuid);
154 /****************************************************************************
155 Setup the groups a user belongs to.
156 ****************************************************************************/
157 int setup_groups(char *user, uid_t uid, gid_t gid, int *p_ngroups, gid_t **p_groups)
161 gid_t *groups = NULL;
163 if (-1 == initgroups(user,gid))
165 DEBUG(0,("Unable to initgroups. Error was %s\n", strerror(errno) ));
168 if (gid < 0 || gid > 32767 || uid < 0 || uid > 32767)
170 DEBUG(0,("This is probably a problem with the account %s\n", user));
176 ngroups = sys_getgroups(0,&grp);
183 if((groups = (gid_t *)malloc(sizeof(gid_t)*NGROUPS_MAX)) == NULL)
184 #else /* NGROUPS_MAX */
185 if((groups = (gid_t *)malloc(sizeof(gid_t)*ngroups)) == NULL)
186 #endif /* NGROUPS_MAX */
188 DEBUG(0,("setup_groups malloc fail !\n"));
192 ngroups = sys_getgroups(ngroups,groups);
194 (*p_ngroups) = ngroups;
195 (*p_groups) = groups;
197 DEBUG( 3, ( "%s is in %d groups: ", user, ngroups ) );
198 for (i = 0; i < ngroups; i++ )
200 DEBUG( 3, ( "%s%d", (i ? ", " : ""), (int)groups[i] ) );
202 DEBUG( 3, ( "\n" ) );
208 /****************************************************************************
209 register a uid/name pair as being valid and that a valid password
210 has been given. vuid is biased by an offset. This allows us to
211 tell random client vuid's (normally zero) from valid vuids.
212 ****************************************************************************/
213 uint16 register_vuid(uid_t uid,gid_t gid, char *unix_name, char *requested_name, BOOL guest)
216 struct passwd *pwfile; /* for getting real name from passwd file */
218 /* Ensure no vuid gets registered in share level security. */
219 if(lp_security() == SEC_SHARE)
220 return UID_FIELD_INVALID;
224 * After observing MS-Exchange services writing to a Samba share
225 * I belive this code is incorrect. Each service does its own
226 * sessionsetup_and_X for the same user, and as each service shuts
227 * down, it does a user_logoff_and_X. As we are consolidating multiple
228 * sessionsetup_and_X's onto the same vuid here, when the first service
229 * shuts down, it invalidates all the open files for the other services.
230 * Hence I am removing this code and forcing each sessionsetup_and_X
232 * Jeremy Allison. (jallison@whistle.com).
236 for(i = 0; i < num_validated_users; i++) {
237 vuser = &validated_users[i];
238 if ( vuser->uid == uid )
239 return (uint16)(i + VUID_OFFSET); /* User already validated */
243 validated_users = (user_struct *)Realloc(validated_users,
245 (num_validated_users+1));
247 if (!validated_users)
249 DEBUG(0,("Failed to realloc users struct!\n"));
250 num_validated_users = 0;
251 return UID_FIELD_INVALID;
254 vuser = &validated_users[num_validated_users];
255 num_validated_users++;
259 vuser->guest = guest;
260 fstrcpy(vuser->name,unix_name);
261 fstrcpy(vuser->requested_name,requested_name);
267 vuser->groups = NULL;
269 /* Find all the groups this uid is in and store them.
270 Used by become_user() */
271 setup_groups(unix_name,uid,gid,
275 DEBUG(3,("uid %d registered to name %s\n",(int)uid,unix_name));
277 DEBUG(3, ("Clearing default real name\n"));
278 fstrcpy(vuser->real_name, "<Full Name>\0");
279 if (lp_unix_realname()) {
280 if ((pwfile=sys_getpwnam(vuser->name))!= NULL)
282 DEBUG(3, ("User name: %s\tReal name: %s\n",vuser->name,pwfile->pw_gecos));
283 fstrcpy(vuser->real_name, pwfile->pw_gecos);
287 return (uint16)((num_validated_users - 1) + VUID_OFFSET);
291 /****************************************************************************
292 add a name to the session users list
293 ****************************************************************************/
294 void add_session_user(char *user)
297 StrnCpy(suser,user,sizeof(suser)-1);
299 if (!Get_Pwnam(suser,True)) return;
301 if (suser && *suser && !in_list(suser,session_users,False))
303 if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
304 DEBUG(1,("Too many session users??\n"));
307 pstrcat(session_users," ");
308 pstrcat(session_users,suser);
314 /****************************************************************************
315 update the encrypted smbpasswd file from the plaintext username and password
316 *****************************************************************************/
317 static BOOL update_smbpassword_file(char *user, char *password)
319 struct smb_passwd *smbpw;
323 smbpw = getsmbpwnam(user);
327 DEBUG(0,("getsmbpwnam returned NULL\n"));
332 * Remove the account disabled flag - we are updating the
333 * users password from a login.
335 smbpw->acct_ctrl &= ~ACB_DISABLED;
337 /* Here, the flag is one, because we want to ignore the
338 XXXXXXX'd out password */
339 ret = change_oem_password( smbpw, password, True);
341 DEBUG(3,("change_oem_password returned False\n"));
351 /****************************************************************************
352 core of smb password checking routine.
353 ****************************************************************************/
354 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
356 /* Finish the encryption of part_passwd. */
357 unsigned char p21[21];
358 unsigned char p24[24];
360 if (part_passwd == NULL)
361 DEBUG(10,("No password set - allowing access\n"));
362 /* No password set - always true ! */
363 if (part_passwd == NULL)
367 memcpy(p21,part_passwd,16);
372 DEBUG(100,("Part password (P16) was |"));
373 for(i = 0; i < 16; i++)
374 DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
376 DEBUG(100,("Password from client was |"));
377 for(i = 0; i < 24; i++)
378 DEBUG(100,("%X ", (unsigned char)password[i]));
380 DEBUG(100,("Given challenge was |"));
381 for(i = 0; i < 8; i++)
382 DEBUG(100,("%X ", (unsigned char)c8[i]));
384 DEBUG(100,("Value from encryption was |"));
385 for(i = 0; i < 24; i++)
386 DEBUG(100,("%X ", (unsigned char)p24[i]));
390 return (memcmp(p24, password, 24) == 0);
393 /****************************************************************************
394 Do a specific test for an smb password being correct, given a smb_password and
395 the lanman and NT responses.
396 ****************************************************************************/
397 BOOL smb_password_ok(struct smb_passwd *smb_pass, uchar chal[8],
398 uchar lm_pass[24], uchar nt_pass[24])
402 if (!lm_pass || !smb_pass) return(False);
404 DEBUG(4,("Checking SMB password for user %s\n",
405 smb_pass->smb_name));
407 if(smb_pass->acct_ctrl & ACB_DISABLED) {
408 DEBUG(1,("account for user %s was disabled.\n",
409 smb_pass->smb_name));
415 DEBUG(5,("use last SMBnegprot challenge\n"));
416 if (!last_challenge(challenge))
418 DEBUG(1,("no challenge done - password failed\n"));
424 DEBUG(5,("challenge received\n"));
425 memcpy(challenge, chal, 8);
428 if ((Protocol >= PROTOCOL_NT1) && (smb_pass->smb_nt_passwd != NULL)) {
429 /* We have the NT MD4 hash challenge available - see if we can
430 use it (ie. does it exist in the smbpasswd file).
432 DEBUG(4,("smb_password_ok: Checking NT MD4 password\n"));
433 if (smb_password_check((char *)nt_pass,
434 (uchar *)smb_pass->smb_nt_passwd,
436 DEBUG(4,("NT MD4 password check succeeded\n"));
439 DEBUG(4,("NT MD4 password check failed\n"));
442 /* Try against the lanman password. smb_pass->smb_passwd == NULL means
443 no password, allow access. */
445 DEBUG(4,("Checking LM MD4 password\n"));
447 if((smb_pass->smb_passwd == NULL) &&
448 (smb_pass->acct_ctrl & ACB_PWNOTREQ)) {
449 DEBUG(4,("no password required for user %s\n",
450 smb_pass->smb_name));
454 if((smb_pass->smb_passwd != NULL) &&
455 smb_password_check((char *)lm_pass,
456 (uchar *)smb_pass->smb_passwd, challenge)) {
457 DEBUG(4,("LM MD4 password check succeeded\n"));
461 DEBUG(4,("LM MD4 password check failed\n"));
467 /****************************************************************************
468 check if a username/password is OK assuming the password is a 24 byte
470 return True if the password is correct, False otherwise
471 ****************************************************************************/
473 BOOL pass_check_smb(char *user, char *domain,
474 uchar *chal, uchar *lm_pwd, uchar *nt_pwd,
478 struct smb_passwd *smb_pass;
480 if (!lm_pwd || !nt_pwd)
485 if (pwd != NULL && user == NULL)
487 pass = (struct passwd *) pwd;
488 user = pass->pw_name;
492 pass = Get_Pwnam(user,True);
497 DEBUG(1,("Couldn't find user '%s' in UNIX password database.\n",user));
501 smb_pass = getsmbpwnam(user);
503 if (smb_pass == NULL)
505 DEBUG(1,("Couldn't find user '%s' in smb_passwd file.\n", user));
509 /* Quit if the account was disabled. */
510 if(smb_pass->acct_ctrl & ACB_DISABLED) {
511 DEBUG(1,("Account for user '%s' was disabled.\n", user));
515 /* Ensure the uid's match */
516 if (smb_pass->smb_userid != pass->pw_uid)
518 DEBUG(0,("Error : UNIX and SMB uids in password files do not match for user '%s'!\n", user));
522 if (lm_pwd[0] == '\0' && IS_BITS_SET_ALL(smb_pass->acct_ctrl, ACB_PWNOTREQ) && lp_null_passwords())
524 DEBUG(3,("Account for user '%s' has no password and null passwords are allowed.\n", smb_pass->smb_name));
528 if (smb_password_ok(smb_pass, chal, lm_pwd, nt_pwd))
533 DEBUG(2,("pass_check_smb failed - invalid password for user [%s]\n", user));
537 /****************************************************************************
538 check if a username/password pair is OK either via the system password
539 database or the encrypted SMB password database
540 return True if the password is correct, False otherwise
541 ****************************************************************************/
542 BOOL password_ok(char *user, char *password, int pwlen, struct passwd *pwd)
544 if (pwlen == 24 || (lp_encrypted_passwords() && (pwlen == 0) && lp_null_passwords()))
546 /* if 24 bytes long assume it is an encrypted password */
549 if (!last_challenge(challenge))
551 DEBUG(0,("Error: challenge not done for user=%s\n", user));
555 return pass_check_smb(user, global_myworkgroup,
556 challenge, (uchar *)password, (uchar *)password, pwd);
559 return pass_check(user, password, pwlen, pwd,
560 lp_update_encrypted() ?
561 update_smbpassword_file : NULL);
564 /****************************************************************************
565 check if a username is valid
566 ****************************************************************************/
567 BOOL user_ok(char *user,int snum)
569 pstring valid, invalid;
572 StrnCpy(valid, lp_valid_users(snum), sizeof(pstring)-1);
573 StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring)-1);
575 pstring_sub(valid,"%S",lp_servicename(snum));
576 pstring_sub(invalid,"%S",lp_servicename(snum));
578 ret = !user_in_list(user,invalid);
580 if (ret && valid && *valid) {
581 ret = user_in_list(user,valid);
584 if (ret && lp_onlyuser(snum)) {
585 char *user_list = lp_username(snum);
586 pstring_sub(user_list,"%S",lp_servicename(snum));
587 ret = user_in_list(user,user_list);
596 /****************************************************************************
597 validate a group username entry. Return the username or NULL
598 ****************************************************************************/
599 static char *validate_group(char *group,char *password,int pwlen,int snum)
603 char *host, *user, *domain;
605 while (getnetgrent(&host, &user, &domain)) {
607 if (user_ok(user, snum) &&
608 password_ok(user,password,pwlen,NULL)) {
623 while ((gptr = (struct group *)getgrent())) {
624 if (!strequal(gptr->gr_name,group))
626 member = gptr->gr_mem;
627 while (member && *member) {
629 fstrcpy(name,*member);
630 if (user_ok(name,snum) &&
631 password_ok(name,password,pwlen,NULL)) {
646 /****************************************************************************
647 check for authority to login to a service with a given username/password
648 ****************************************************************************/
649 BOOL authorise_login(int snum,char *user,char *password, int pwlen,
650 BOOL *guest,BOOL *force,uint16 vuid)
657 DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
660 /* there are several possibilities:
661 1) login as the given user with given password
662 2) login as a previously registered username with the given password
663 3) login as a session list username with the given password
664 4) login as a previously validated user/password pair
665 5) login as the "user =" user with given password
666 6) login as the "user =" user with no password (guest connection)
667 7) login as guest user with no password
669 if the service is guest_only then steps 1 to 5 are skipped
672 if (GUEST_ONLY(snum)) *force = True;
674 if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
677 user_struct *vuser = get_valid_user_struct(vuid);
679 /* check the given username and password */
680 if (!ok && (*user) && user_ok(user,snum)) {
681 ok = password_ok(user,password, pwlen, NULL);
682 if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
685 /* check for a previously registered guest username */
686 if (!ok && (vuser != 0) && vuser->guest) {
687 if (user_ok(vuser->name,snum) &&
688 password_ok(vuser->name, password, pwlen, NULL)) {
689 fstrcpy(user, vuser->name);
690 vuser->guest = False;
691 DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
697 /* now check the list of session users */
701 char *user_list = strdup(session_users);
702 if (!user_list) return(False);
704 for (auser=strtok(user_list,LIST_SEP);
706 auser = strtok(NULL,LIST_SEP))
709 fstrcpy(user2,auser);
710 if (!user_ok(user2,snum)) continue;
712 if (password_ok(user2,password, pwlen, NULL)) {
715 DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
721 /* check for a previously validated username/password pair */
722 if (!ok && (!lp_revalidate(snum) || lp_security() > SEC_SHARE) &&
723 (vuser != 0) && !vuser->guest &&
724 user_ok(vuser->name,snum)) {
725 fstrcpy(user,vuser->name);
727 DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
731 /* check for a rhosts entry */
732 if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
734 DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
737 /* check the user= fields and the given password */
738 if (!ok && lp_username(snum)) {
741 StrnCpy(user_list,lp_username(snum),sizeof(pstring));
743 pstring_sub(user_list,"%S",lp_servicename(snum));
745 for (auser=strtok(user_list,LIST_SEP);
747 auser = strtok(NULL,LIST_SEP))
751 auser = validate_group(auser+1,password,pwlen,snum);
756 DEBUG(3,("ACCEPTED: group username and given password ok\n"));
762 fstrcpy(user2,auser);
763 if (user_ok(user2,snum) &&
764 password_ok(user2,password,pwlen,NULL))
768 DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
773 } /* not guest only */
775 /* check for a normal guest connection */
776 if (!ok && GUEST_OK(snum))
779 StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
780 if (Get_Pwnam(guestname,True))
782 fstrcpy(user,guestname);
784 DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
787 DEBUG(0,("Invalid guest account %s??\n",guestname));
792 if (ok && !user_ok(user,snum))
794 DEBUG(0,("rejected invalid user %s\n",user));
802 /****************************************************************************
803 read the a hosts.equiv or .rhosts file and check if it
804 allows this user from this machine
805 ****************************************************************************/
806 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
809 int plus_allowed = 1;
812 FILE *fp = sys_fopen(equiv_file, "r");
813 DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
814 if (! fp) return False;
815 while(fgets(buf, sizeof(buf), fp))
817 trim_string(buf," "," ");
819 if (buf[0] != '#' && buf[0] != '\n')
821 BOOL is_group = False;
824 if (strcmp(buf, "NO_PLUS\n") == 0)
826 DEBUG(6, ("check_user_equiv NO_PLUS\n"));
833 if (*bp == '\n' && plus_allowed)
835 /* a bare plus means everbody allowed */
836 DEBUG(6, ("check_user_equiv everybody allowed\n"));
841 else if (buf[0] == '-')
851 file_host = strtok(bp, " \t\n");
852 file_user = strtok(NULL, " \t\n");
853 DEBUG(7, ("check_user_equiv %s %s\n", file_host ? file_host : "(null)",
854 file_user ? file_user : "(null)" ));
855 if (file_host && *file_host)
857 BOOL host_ok = False;
859 #if defined(HAVE_NETGROUP) && defined(HAVE_YP_GET_DEFAULT_DOMAIN)
862 static char *mydomain = NULL;
864 yp_get_default_domain(&mydomain);
865 if (mydomain && innetgr(file_host,remote,user,mydomain))
871 DEBUG(1,("Netgroups not configured\n"));
876 /* is it this host */
877 /* the fact that remote has come from a call of gethostbyaddr
878 * means that it may have the fully qualified domain name
879 * so we could look up the file version to get it into
880 * a canonical form, but I would rather just type it
881 * in full in the equiv file
883 if (!host_ok && !is_group && strequal(remote, file_host))
889 /* is it this user */
890 if (file_user == 0 || strequal(user, file_user))
893 DEBUG(5, ("check_user_equiv matched %s%s %s\n",
894 (plus ? "+" : "-"), file_host,
895 (file_user ? file_user : "")));
896 return (plus ? True : False);
907 /****************************************************************************
908 check for a possible hosts equiv or rhosts entry for the user
909 ****************************************************************************/
910 BOOL check_hosts_equiv(char *user)
914 struct passwd *pass = Get_Pwnam(user,True);
919 fname = lp_hosts_equiv();
921 /* note: don't allow hosts.equiv on root */
922 if (fname && *fname && (pass->pw_uid != 0)) {
924 if (check_user_equiv(user,client_name(Client),fname))
930 char *home = get_user_home_dir(user);
933 slprintf(rhostsfile, sizeof(rhostsfile)-1, "%s/.rhosts", home);
934 if (check_user_equiv(user,client_name(Client),rhostsfile))
943 /****************************************************************************
944 Return the client state structure.
945 ****************************************************************************/
947 struct cli_state *server_client(void)
949 static struct cli_state pw_cli;
953 /****************************************************************************
954 Support for server level security.
955 ****************************************************************************/
957 struct cli_state *server_cryptkey(void)
959 struct cli_state *cli;
961 struct in_addr dest_ip;
963 BOOL connected_ok = False;
965 cli = server_client();
967 if (!cli_initialise(cli))
970 p = lp_passwordserver();
971 while(p && next_token( &p, desthost, LIST_SEP, sizeof(desthost))) {
972 standard_sub_basic(desthost);
975 if(!resolve_name( desthost, &dest_ip, 0x20)) {
976 DEBUG(1,("server_cryptkey: Can't resolve address for %s\n",desthost));
980 if (ismyip(dest_ip)) {
981 DEBUG(1,("Password server loop - disabling password server %s\n",desthost));
985 if (cli_connect(cli, desthost, &dest_ip)) {
986 DEBUG(3,("connected to password server %s\n",desthost));
993 DEBUG(0,("password server not available\n"));
998 if (!attempt_netbios_session_request(cli, global_myname, desthost, &dest_ip))
1001 DEBUG(3,("got session\n"));
1003 if (!cli_negprot(cli)) {
1004 DEBUG(1,("%s rejected the negprot\n",desthost));
1009 if (cli->protocol < PROTOCOL_LANMAN2 ||
1010 !(cli->sec_mode & 1)) {
1011 DEBUG(1,("%s isn't in user level security mode\n",desthost));
1016 DEBUG(3,("password server OK\n"));
1021 /****************************************************************************
1022 Validate a password with the password server.
1023 ****************************************************************************/
1025 BOOL server_validate(char *user, char *domain,
1026 char *pass, int passlen,
1027 char *ntpass, int ntpasslen)
1029 struct cli_state *cli;
1030 static unsigned char badpass[24];
1031 static BOOL tested_password_server = False;
1032 static BOOL bad_password_server = False;
1034 cli = server_client();
1036 if (!cli->initialised) {
1037 DEBUG(1,("password server %s is not connected\n", cli->desthost));
1042 memset(badpass, 0x1f, sizeof(badpass));
1044 if((passlen == sizeof(badpass)) && !memcmp(badpass, pass, passlen)) {
1046 * Very unlikely, our random bad password is the same as the users
1048 memset(badpass, badpass[0]+1, sizeof(badpass));
1052 * Attempt a session setup with a totally incorrect password.
1053 * If this succeeds with the guest bit *NOT* set then the password
1054 * server is broken and is not correctly setting the guest bit. We
1055 * need to detect this as some versions of NT4.x are broken. JRA.
1058 if(!tested_password_server) {
1059 if (cli_session_setup(cli, user, (char *)badpass, sizeof(badpass),
1060 (char *)badpass, sizeof(badpass), domain)) {
1063 * We connected to the password server so we
1064 * can say we've tested it.
1066 tested_password_server = True;
1068 if ((SVAL(cli->inbuf,smb_vwv2) & 1) == 0) {
1069 DEBUG(0,("server_validate: password server %s allows users as non-guest \
1070 with a bad password.\n", cli->desthost));
1071 DEBUG(0,("server_validate: This is broken (and insecure) behaviour. Please do not \
1072 use this machine as the password server.\n"));
1076 * Password server has the bug.
1078 bad_password_server = True;
1086 * We have already tested the password server.
1087 * Fail immediately if it has the bug.
1090 if(bad_password_server) {
1091 DEBUG(0,("server_validate: [1] password server %s allows users as non-guest \
1092 with a bad password.\n", cli->desthost));
1093 DEBUG(0,("server_validate: [1] This is broken (and insecure) behaviour. Please do not \
1094 use this machine as the password server.\n"));
1100 * Now we know the password server will correctly set the guest bit, or is
1101 * not guest enabled, we can try with the real password.
1104 if (!cli_session_setup(cli, user, pass, passlen, ntpass, ntpasslen, domain)) {
1105 DEBUG(1,("password server %s rejected the password\n", cli->desthost));
1109 /* if logged in as guest then reject */
1110 if ((SVAL(cli->inbuf,smb_vwv2) & 1) != 0) {
1111 DEBUG(1,("password server %s gave us guest only\n", cli->desthost));
1121 /***********************************************************************
1122 Connect to a remote machine for domain security authentication
1123 given a name or IP address.
1124 ************************************************************************/
1126 static BOOL connect_to_domain_password_server(struct cli_state *pcli, char *remote_machine,
1127 unsigned char *trust_passwd)
1129 struct in_addr dest_ip;
1131 if(cli_initialise(pcli) == False) {
1132 DEBUG(0,("connect_to_domain_password_server: unable to initialize client connection.\n"));
1136 standard_sub_basic(remote_machine);
1137 strupper(remote_machine);
1139 if(!resolve_name( remote_machine, &dest_ip, 0x20)) {
1140 DEBUG(1,("connect_to_domain_password_server: Can't resolve address for %s\n", remote_machine));
1145 if (ismyip(dest_ip)) {
1146 DEBUG(1,("connect_to_domain_password_server: Password server loop - not using password server %s\n",
1152 if (!cli_connect(pcli, remote_machine, &dest_ip)) {
1153 DEBUG(0,("connect_to_domain_password_server: unable to connect to SMB server on \
1154 machine %s. Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1159 if (!attempt_netbios_session_request(pcli, global_myname, remote_machine, &dest_ip)) {
1160 DEBUG(0,("connect_to_password_server: machine %s rejected the NetBIOS \
1161 session request. Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1165 pcli->protocol = PROTOCOL_NT1;
1167 if (!cli_negprot(pcli)) {
1168 DEBUG(0,("connect_to_domain_password_server: machine %s rejected the negotiate protocol. \
1169 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1174 if (pcli->protocol != PROTOCOL_NT1) {
1175 DEBUG(0,("connect_to_domain_password_server: machine %s didn't negotiate NT protocol.\n",
1182 * Do an anonymous session setup.
1185 if (!cli_session_setup(pcli, "", "", 0, "", 0, "")) {
1186 DEBUG(0,("connect_to_domain_password_server: machine %s rejected the session setup. \
1187 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1192 if (!(pcli->sec_mode & 1)) {
1193 DEBUG(1,("connect_to_domain_password_server: machine %s isn't in user level security mode\n",
1199 if (!cli_send_tconX(pcli, "IPC$", "IPC", "", 1)) {
1200 DEBUG(0,("connect_to_domain_password_server: machine %s rejected the tconX on the IPC$ share. \
1201 Error was : %s.\n", remote_machine, cli_errstr(pcli) ));
1207 * We now have an anonymous connection to IPC$ on the domain password server.
1211 * Even if the connect succeeds we need to setup the netlogon
1212 * pipe here. We do this as we may just have changed the domain
1213 * account password on the PDC and yet we may be talking to
1214 * a BDC that doesn't have this replicated yet. In this case
1215 * a successful connect to a DC needs to take the netlogon connect
1216 * into account also. This patch from "Bjart Kvarme" <bjart.kvarme@usit.uio.no>.
1219 if(cli_nt_session_open(pcli, PIPE_NETLOGON) == False) {
1220 DEBUG(0,("connect_to_domain_password_server: unable to open the domain client session to \
1221 machine %s. Error was : %s.\n", remote_machine, cli_errstr(pcli)));
1222 cli_nt_session_close(pcli);
1228 if (cli_nt_setup_creds(pcli, trust_passwd) == False) {
1229 DEBUG(0,("connect_to_domain_password_server: unable to setup the PDC credentials to machine \
1230 %s. Error was : %s.\n", remote_machine, cli_errstr(pcli)));
1231 cli_nt_session_close(pcli);
1240 /***********************************************************************
1241 Utility function to attempt a connection to an IP address of a DC.
1242 ************************************************************************/
1244 static BOOL attempt_connect_to_dc(struct cli_state *pcli, struct in_addr *ip, unsigned char *trust_passwd)
1249 * Ignore addresses we have already tried.
1252 if(ip_equal(ipzero, *ip))
1255 if(!lookup_pdc_name(global_myname, lp_workgroup(), ip, dc_name))
1258 return connect_to_domain_password_server(pcli, dc_name, trust_passwd);
1261 /***********************************************************************
1262 Do the same as security=server, but using NT Domain calls and a session
1263 key from the machine password.
1264 ************************************************************************/
1266 BOOL domain_client_validate( char *user, char *domain,
1267 char *smb_apasswd, int smb_apasslen,
1268 char *smb_ntpasswd, int smb_ntpasslen,
1271 unsigned char local_challenge[8];
1272 unsigned char local_lm_response[24];
1273 unsigned char local_nt_reponse[24];
1274 unsigned char trust_passwd[16];
1275 fstring remote_machine;
1277 NET_ID_INFO_CTR ctr;
1278 NET_USER_INFO_3 info3;
1279 struct cli_state cli;
1281 BOOL connected_ok = False;
1283 if(user_exists != NULL)
1284 *user_exists = True; /* Only set false on a very specific error. */
1287 * Check that the requested domain is not our own machine name.
1288 * If it is, we should never check the PDC here, we use our own local
1292 if(strequal( domain, global_myname)) {
1293 DEBUG(3,("domain_client_validate: Requested domain was for this machine.\n"));
1298 * Next, check that the passwords given were encrypted.
1301 if(((smb_apasslen != 24) && (smb_apasslen != 0)) ||
1302 ((smb_ntpasslen != 24) && (smb_ntpasslen != 0))) {
1305 * Not encrypted - do so.
1308 DEBUG(3,("domain_client_validate: User passwords not in encrypted format.\n"));
1309 generate_random_buffer( local_challenge, 8, False);
1310 SMBencrypt( (uchar *)smb_apasswd, local_challenge, local_lm_response);
1311 SMBNTencrypt((uchar *)smb_ntpasswd, local_challenge, local_nt_reponse);
1314 smb_apasswd = (char *)local_lm_response;
1315 smb_ntpasswd = (char *)local_nt_reponse;
1319 * Encrypted - get the challenge we sent for these
1323 if (!last_challenge(local_challenge)) {
1324 DEBUG(0,("domain_client_validate: no challenge done - password failed\n"));
1330 * Get the machine account password.
1332 if (!trust_get_passwd( trust_passwd, global_myworkgroup, global_myname))
1338 * At this point, smb_apasswd points to the lanman response to
1339 * the challenge in local_challenge, and smb_ntpasswd points to
1340 * the NT response to the challenge in local_challenge. Ship
1341 * these over the secure channel to a domain controller and
1342 * see if they were valid.
1348 * Treat each name in the 'password server =' line as a potential
1349 * PDC/BDC. Contact each in turn and try and authenticate.
1352 p = lp_passwordserver();
1353 while(!connected_ok && p &&
1354 next_token(&p,remote_machine,LIST_SEP,sizeof(remote_machine))) {
1355 if(strequal(remote_machine, "*")) {
1358 * We have been asked to dynamcially determine the IP addresses of
1359 * the PDC and BDC's for this DOMAIN, and query them in turn.
1362 struct in_addr *ip_list = NULL;
1366 if(!get_dc_list(lp_workgroup(), &ip_list, &count))
1370 * Firstly try and contact a PDC/BDC who has the same
1371 * network address as any of our interfaces.
1374 for(i = 0; i < count; i++) {
1375 if(!is_local_net(ip_list[i]))
1378 if((connected_ok = attempt_connect_to_dc(&cli, &ip_list[i], trust_passwd)))
1381 ip_list[i] = ipzero; /* Tried and failed. */
1385 * Secondly try and contact a random PDC/BDC.
1389 i = (sys_random() % count);
1391 if(!(connected_ok = attempt_connect_to_dc(&cli, &ip_list[i], trust_passwd)))
1392 ip_list[i] = ipzero; /* Tried and failed. */
1396 * Finally go through the IP list in turn, ignoring any addresses
1397 * we have already tried.
1403 * Try and connect to any of the other IP addresses in the PDC/BDC list.
1404 * Note that from a WINS server the #1 IP address is the PDC.
1407 for(i = 0; i < count; i++) {
1408 if((connected_ok = attempt_connect_to_dc(&cli, &ip_list[i], trust_passwd)))
1414 free((char *)ip_list);
1417 connected_ok = connect_to_domain_password_server(&cli, remote_machine, trust_passwd);
1421 if (!connected_ok) {
1422 DEBUG(0,("domain_client_validate: Domain password server not available.\n"));
1427 /* We really don't care what LUID we give the user. */
1428 generate_random_buffer( (unsigned char *)&smb_uid_low, 4, False);
1430 if(cli_nt_login_network(&cli, domain, user, smb_uid_low, (char *)local_challenge,
1431 ((smb_apasslen != 0) ? smb_apasswd : NULL),
1432 ((smb_ntpasslen != 0) ? smb_ntpasswd : NULL),
1433 &ctr, &info3) == False) {
1436 cli_error(&cli, NULL, NULL, &nt_rpc_err);
1437 DEBUG(0,("domain_client_validate: unable to validate password for user %s in domain \
1438 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
1439 cli_nt_session_close(&cli);
1443 if((nt_rpc_err == NT_STATUS_NO_SUCH_USER) && (user_exists != NULL))
1444 *user_exists = False;
1450 * Here, if we really want it, we have lots of info about the user in info3.
1455 * We don't actually need to do this - plus it fails currently with
1456 * NT_STATUS_INVALID_INFO_CLASS - we need to know *exactly* what to
1460 if(cli_nt_logoff(&cli, &ctr) == False) {
1461 DEBUG(0,("domain_client_validate: unable to log off user %s in domain \
1462 %s to Domain controller %s. Error was %s.\n", user, domain, remote_machine, cli_errstr(&cli)));
1463 cli_nt_session_close(&cli);
1470 cli_nt_session_close(&cli);