2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 extern fstring global_myworkgroup;
26 BOOL global_encrypted_passwords_negotiated = False;
27 BOOL global_spnego_negotiated = False;
28 struct auth_context *negprot_global_auth_context = NULL;
30 static void get_challenge(char buff[8])
33 const uint8 *cryptkey;
35 /* We might be called more than once, muliple negprots are premitted */
36 if (negprot_global_auth_context) {
37 DEBUG(3, ("get challenge: is this a secondary negprot? negprot_global_auth_context is non-NULL!\n"));
38 (negprot_global_auth_context->free)(&negprot_global_auth_context);
41 DEBUG(10, ("get challenge: creating negprot_global_auth_context\n"));
42 if (!NT_STATUS_IS_OK(nt_status = make_auth_context_subsystem(&negprot_global_auth_context))) {
43 DEBUG(0, ("make_auth_context_subsystem returned %s", nt_errstr(nt_status)));
44 smb_panic("cannot make_negprot_global_auth_context!\n");
46 DEBUG(10, ("get challenge: getting challenge\n"));
47 cryptkey = negprot_global_auth_context->get_ntlm_challenge(negprot_global_auth_context);
48 memcpy(buff, cryptkey, 8);
51 /****************************************************************************
52 Reply for the core protocol.
53 ****************************************************************************/
55 static int reply_corep(char *inbuf, char *outbuf)
57 int outsize = set_message(outbuf,1,0,True);
59 Protocol = PROTOCOL_CORE;
64 /****************************************************************************
65 Reply for the coreplus protocol.
66 ****************************************************************************/
68 static int reply_coreplus(char *inbuf, char *outbuf)
70 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
71 int outsize = set_message(outbuf,13,0,True);
72 SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
73 readbraw and writebraw (possibly) */
74 /* Reply, SMBlockread, SMBwritelock supported. */
75 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
76 SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */
78 Protocol = PROTOCOL_COREPLUS;
83 /****************************************************************************
84 Reply for the lanman 1.0 protocol.
85 ****************************************************************************/
87 static int reply_lanman1(char *inbuf, char *outbuf)
89 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
91 time_t t = time(NULL);
93 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
95 if (lp_security()>=SEC_USER)
96 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
97 if (global_encrypted_passwords_negotiated)
98 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
100 set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
101 SSVAL(outbuf,smb_vwv1,secword);
102 /* Create a token value and add it to the outgoing packet. */
103 if (global_encrypted_passwords_negotiated) {
104 get_challenge(smb_buf(outbuf));
107 Protocol = PROTOCOL_LANMAN1;
109 /* Reply, SMBlockread, SMBwritelock supported. */
110 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
111 SSVAL(outbuf,smb_vwv2,max_recv);
112 SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
113 SSVAL(outbuf,smb_vwv4,1);
114 SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
115 readbraw writebraw (possibly) */
116 SIVAL(outbuf,smb_vwv6,sys_getpid());
117 SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
119 put_dos_date(outbuf,smb_vwv8,t);
121 return (smb_len(outbuf)+4);
124 /****************************************************************************
125 Reply for the lanman 2.0 protocol.
126 ****************************************************************************/
128 static int reply_lanman2(char *inbuf, char *outbuf)
130 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
132 time_t t = time(NULL);
134 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
136 if (lp_security()>=SEC_USER)
137 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
138 if (global_encrypted_passwords_negotiated)
139 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
141 set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
142 SSVAL(outbuf,smb_vwv1,secword);
143 SIVAL(outbuf,smb_vwv6,sys_getpid());
145 /* Create a token value and add it to the outgoing packet. */
146 if (global_encrypted_passwords_negotiated) {
147 get_challenge(smb_buf(outbuf));
150 Protocol = PROTOCOL_LANMAN2;
152 /* Reply, SMBlockread, SMBwritelock supported. */
153 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
154 SSVAL(outbuf,smb_vwv2,max_recv);
155 SSVAL(outbuf,smb_vwv3,lp_maxmux());
156 SSVAL(outbuf,smb_vwv4,1);
157 SSVAL(outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
158 SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
159 put_dos_date(outbuf,smb_vwv8,t);
161 return (smb_len(outbuf)+4);
164 /****************************************************************************
165 Generate the spnego negprot reply blob. Return the number of bytes used.
166 ****************************************************************************/
168 static int negprot_spnego(char *p)
171 extern pstring global_myname;
173 const char *OIDs_krb5[] = {OID_NTLMSSP,
177 const char *OIDs_plain[] = {OID_NTLMSSP, NULL};
181 global_spnego_negotiated = True;
184 safe_strcpy((char *)guid, global_myname, 16);
185 strlower((char *)guid);
188 /* strangely enough, NT does not sent the single OID NTLMSSP when
189 not a ADS member, it sends no OIDs at all
191 we can't do this until we teach our sesssion setup parser to know
192 about raw NTLMSSP (clients send no ASN.1 wrapping if we do this)
194 if (lp_security() != SEC_ADS) {
199 if (lp_security() != SEC_ADS) {
200 blob = spnego_gen_negTokenInit(guid, OIDs_plain, "NONE");
202 /* win2000 uses host$@REALM, which we will probably use eventually,
203 but for now this works */
204 asprintf(&principal, "HOST/%s@%s", guid, lp_realm());
205 blob = spnego_gen_negTokenInit(guid, OIDs_krb5, principal);
208 memcpy(p, blob.data, blob.length);
210 data_blob_free(&blob);
214 /****************************************************************************
215 Reply for the nt protocol.
216 ****************************************************************************/
218 static int reply_nt1(char *inbuf, char *outbuf)
220 /* dual names + lock_and_read + nt SMBs + remote API calls */
221 int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ|
222 CAP_LEVEL_II_OPLOCKS;
225 time_t t = time(NULL);
227 BOOL negotiate_spnego = False;
229 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
231 /* do spnego in user level security if the client
232 supports it and we can do encrypted passwords */
234 if (global_encrypted_passwords_negotiated &&
235 (lp_security() != SEC_SHARE) &&
237 (SVAL(inbuf, smb_flg2) & FLAGS2_EXTENDED_SECURITY)) {
238 negotiate_spnego = True;
239 capabilities |= CAP_EXTENDED_SECURITY;
242 capabilities |= CAP_NT_SMBS|CAP_RPC_REMOTE_APIS|CAP_UNIX;
244 if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64))
245 capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_W2K_SMBS;
247 if (SMB_OFF_T_BITS == 64)
248 capabilities |= CAP_LARGE_FILES;
250 if (lp_readraw() && lp_writeraw())
251 capabilities |= CAP_RAW_MODE;
253 /* allow for disabling unicode */
255 capabilities |= CAP_UNICODE;
257 if (lp_nt_status_support())
258 capabilities |= CAP_STATUS32;
261 capabilities |= CAP_DFS;
263 if (lp_security() >= SEC_USER)
264 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
265 if (global_encrypted_passwords_negotiated)
266 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
268 set_message(outbuf,17,0,True);
270 SCVAL(outbuf,smb_vwv1,secword);
272 Protocol = PROTOCOL_NT1;
274 SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
275 SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */
276 SIVAL(outbuf,smb_vwv3+1,0xffff); /* max buffer. LOTS! */
277 SIVAL(outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */
278 SIVAL(outbuf,smb_vwv7+1,sys_getpid()); /* session key */
279 SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */
280 put_long_date(outbuf+smb_vwv11+1,t);
281 SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
283 p = q = smb_buf(outbuf);
284 if (!negotiate_spnego) {
285 /* Create a token value and add it to the outgoing packet. */
286 if (global_encrypted_passwords_negotiated) {
287 /* note that we do not send a challenge at all if
288 we are using plaintext */
290 SSVALS(outbuf,smb_vwv16+1,8);
293 p += srvstr_push(outbuf, p, global_myworkgroup, -1,
294 STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
295 DEBUG(3,("not using SPNEGO\n"));
297 int len = negprot_spnego(p);
299 SSVALS(outbuf,smb_vwv16+1,len);
301 DEBUG(3,("using SPNEGO\n"));
304 SSVAL(outbuf,smb_vwv17, p - q); /* length of challenge+domain strings */
305 set_message_end(outbuf, p);
307 return (smb_len(outbuf)+4);
310 /* these are the protocol lists used for auto architecture detection:
313 protocol [PC NETWORK PROGRAM 1.0]
314 protocol [XENIX CORE]
315 protocol [MICROSOFT NETWORKS 1.03]
317 protocol [Windows for Workgroups 3.1a]
320 protocol [NT LM 0.12]
323 protocol [PC NETWORK PROGRAM 1.0]
324 protocol [XENIX CORE]
325 protocol [MICROSOFT NETWORKS 1.03]
327 protocol [Windows for Workgroups 3.1a]
330 protocol [NT LM 0.12]
333 protocol [PC NETWORK PROGRAM 1.0]
335 protocol [Windows for Workgroups 3.1a]
338 protocol [NT LM 0.12]
341 protocol [PC NETWORK PROGRAM 1.0]
342 protocol [XENIX CORE]
349 * Modified to recognize the architecture of the remote machine better.
351 * This appears to be the matrix of which protocol is used by which
353 Protocol WfWg Win95 WinNT Win2K OS/2
354 PC NETWORK PROGRAM 1.0 1 1 1 1 1
356 MICROSOFT NETWORKS 3.0 2 2
358 MICROSOFT NETWORKS 1.03 3
361 Windows for Workgroups 3.1a 5 5 5 3
366 * tim@fsg.com 09/29/95
367 * Win2K added by matty 17/7/99
370 #define ARCH_WFWG 0x3 /* This is a fudge because WfWg is like Win95 */
371 #define ARCH_WIN95 0x2
372 #define ARCH_WINNT 0x4
373 #define ARCH_WIN2K 0xC /* Win2K is like NT */
374 #define ARCH_OS2 0x14 /* Again OS/2 is like NT */
375 #define ARCH_SAMBA 0x20
377 #define ARCH_ALL 0x3F
379 /* List of supported protocols, most desired first */
383 int (*proto_reply_fn)(char *, char *);
385 } supported_protocols[] = {
386 {"NT LANMAN 1.0", "NT1", reply_nt1, PROTOCOL_NT1},
387 {"NT LM 0.12", "NT1", reply_nt1, PROTOCOL_NT1},
388 {"LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
389 {"Samba", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
390 {"DOS LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
391 {"LANMAN1.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
392 {"MICROSOFT NETWORKS 3.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
393 {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
394 {"PC NETWORK PROGRAM 1.0", "CORE", reply_corep, PROTOCOL_CORE},
398 /****************************************************************************
400 ****************************************************************************/
402 int reply_negprot(connection_struct *conn,
403 char *inbuf,char *outbuf, int dum_size,
406 int outsize = set_message(outbuf,1,0,True);
411 int bcc = SVAL(smb_buf(inbuf),-2);
414 static BOOL done_negprot = False;
416 START_PROFILE(SMBnegprot);
419 END_PROFILE(SMBnegprot);
420 exit_server("multiple negprot's are not permitted");
424 p = smb_buf(inbuf)+1;
425 while (p < (smb_buf(inbuf) + bcc)) {
427 DEBUG(3,("Requested protocol [%s]\n",p));
428 if (strcsequal(p,"Windows for Workgroups 3.1a"))
429 arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
430 else if (strcsequal(p,"DOS LM1.2X002"))
431 arch &= ( ARCH_WFWG | ARCH_WIN95 );
432 else if (strcsequal(p,"DOS LANMAN2.1"))
433 arch &= ( ARCH_WFWG | ARCH_WIN95 );
434 else if (strcsequal(p,"NT LM 0.12"))
435 arch &= ( ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
436 else if (strcsequal(p,"LANMAN2.1"))
437 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
438 else if (strcsequal(p,"LM1.2X002"))
439 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
440 else if (strcsequal(p,"MICROSOFT NETWORKS 1.03"))
442 else if (strcsequal(p,"XENIX CORE"))
443 arch &= ( ARCH_WINNT | ARCH_OS2 );
444 else if (strcsequal(p,"Samba")) {
454 set_remote_arch(RA_SAMBA);
457 set_remote_arch(RA_WFWG);
460 set_remote_arch(RA_WIN95);
463 if(SVAL(inbuf,smb_flg2)==FLAGS2_WIN2K_SIGNATURE)
464 set_remote_arch(RA_WIN2K);
466 set_remote_arch(RA_WINNT);
469 set_remote_arch(RA_WIN2K);
472 set_remote_arch(RA_OS2);
475 set_remote_arch(RA_UNKNOWN);
479 /* possibly reload - change of architecture */
480 reload_services(True);
482 /* Check for protocols, most desirable first */
483 for (protocol = 0; supported_protocols[protocol].proto_name; protocol++) {
484 p = smb_buf(inbuf)+1;
486 if ((supported_protocols[protocol].protocol_level <= lp_maxprotocol()) &&
487 (supported_protocols[protocol].protocol_level >= lp_minprotocol()))
488 while (p < (smb_buf(inbuf) + bcc)) {
489 if (strequal(p,supported_protocols[protocol].proto_name))
498 SSVAL(outbuf,smb_vwv0,choice);
500 extern fstring remote_proto;
501 fstrcpy(remote_proto,supported_protocols[protocol].short_name);
502 reload_services(True);
503 outsize = supported_protocols[protocol].proto_reply_fn(inbuf, outbuf);
504 DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
506 DEBUG(0,("No protocol supported !\n"));
508 SSVAL(outbuf,smb_vwv0,choice);
510 DEBUG( 5, ( "negprot index=%d\n", choice ) );
512 END_PROFILE(SMBnegprot);