2 Unix SMB/Netbios implementation.
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.
26 extern fstring global_myworkgroup;
27 extern fstring remote_machine;
28 BOOL global_encrypted_passwords_negotiated = False;
29 BOOL global_spnego_negotiated = False;
30 auth_authsupplied_info *negprot_global_auth_info = NULL;
32 /****************************************************************************
33 reply for the core protocol
34 ****************************************************************************/
35 static int reply_corep(char *inbuf, char *outbuf)
37 int outsize = set_message(outbuf,1,0,True);
39 Protocol = PROTOCOL_CORE;
45 /****************************************************************************
46 reply for the coreplus protocol
47 ****************************************************************************/
48 static int reply_coreplus(char *inbuf, char *outbuf)
50 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
51 int outsize = set_message(outbuf,13,0,True);
52 SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
53 readbraw and writebraw (possibly) */
54 /* Reply, SMBlockread, SMBwritelock supported. */
55 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
56 SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */
58 Protocol = PROTOCOL_COREPLUS;
64 /****************************************************************************
65 reply for the lanman 1.0 protocol
66 ****************************************************************************/
67 static int reply_lanman1(char *inbuf, char *outbuf)
69 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
71 time_t t = time(NULL);
74 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
76 if (lp_security()>=SEC_USER) secword |= 1;
77 if (global_encrypted_passwords_negotiated) secword |= 2;
79 set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
80 SSVAL(outbuf,smb_vwv1,secword);
81 /* Create a token value and add it to the outgoing packet. */
82 if (global_encrypted_passwords_negotiated) {
83 if (!make_auth_info_subsystem(&negprot_global_auth_info)) {
84 smb_panic("cannot make_negprot_global_auth_info!\n");
86 cryptkey = auth_get_challenge(negprot_global_auth_info);
87 memcpy(smb_buf(outbuf), cryptkey.data, 8);
88 data_blob_free(&cryptkey);
91 Protocol = PROTOCOL_LANMAN1;
93 /* Reply, SMBlockread, SMBwritelock supported. */
94 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
95 SSVAL(outbuf,smb_vwv2,max_recv);
96 SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
97 SSVAL(outbuf,smb_vwv4,1);
98 SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
99 readbraw writebraw (possibly) */
100 SIVAL(outbuf,smb_vwv6,sys_getpid());
101 SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
103 put_dos_date(outbuf,smb_vwv8,t);
105 return (smb_len(outbuf)+4);
109 /****************************************************************************
110 reply for the lanman 2.0 protocol
111 ****************************************************************************/
112 static int reply_lanman2(char *inbuf, char *outbuf)
114 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
116 time_t t = time(NULL);
119 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
121 if (lp_security()>=SEC_USER) secword |= 1;
122 if (global_encrypted_passwords_negotiated) secword |= 2;
124 set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
125 SSVAL(outbuf,smb_vwv1,secword);
126 SIVAL(outbuf,smb_vwv6,sys_getpid());
128 if (global_encrypted_passwords_negotiated) {
129 if (!make_auth_info_subsystem(&negprot_global_auth_info)) {
130 smb_panic("cannot make_negprot_global_auth_info!\n");
132 cryptkey = auth_get_challenge(negprot_global_auth_info);
133 memcpy(smb_buf(outbuf), cryptkey.data, 8);
134 data_blob_free(&cryptkey);
137 Protocol = PROTOCOL_LANMAN2;
139 /* Reply, SMBlockread, SMBwritelock supported. */
140 SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
141 SSVAL(outbuf,smb_vwv2,max_recv);
142 SSVAL(outbuf,smb_vwv3,lp_maxmux());
143 SSVAL(outbuf,smb_vwv4,1);
144 SSVAL(outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
145 SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
146 put_dos_date(outbuf,smb_vwv8,t);
148 return (smb_len(outbuf)+4);
154 generate the spnego negprot reply blob. Return the number of bytes used
156 static int negprot_spnego(char *p)
159 extern pstring global_myname;
161 const char *OIDs_krb5[] = {OID_NTLMSSP,
165 const char *OIDs_plain[] = {OID_NTLMSSP, NULL};
169 global_spnego_negotiated = True;
172 safe_strcpy((char *)guid, global_myname, 16);
173 strlower((char *)guid);
176 /* strangely enough, NT does not sent the single OID NTLMSSP when
177 not a ADS member, it sends no OIDs at all
179 we can't do this until we teach our sesssion setup parser to know
180 about raw NTLMSSP (clients send no ASN.1 wrapping if we do this)
182 if (lp_security() != SEC_ADS) {
189 ads = ads_init(NULL, NULL, NULL);
191 /* win2000 uses host$@REALM, which we will probably use eventually,
192 but for now this works */
193 asprintf(&principal, "HOST/%s@%s", guid, ads->realm);
194 blob = spnego_gen_negTokenInit(guid,
195 lp_security()==SEC_ADS ? OIDs_krb5 : OIDs_plain,
200 memcpy(p, blob.data, blob.length);
202 data_blob_free(&blob);
208 /****************************************************************************
209 reply for the nt protocol
210 ****************************************************************************/
211 static int reply_nt1(char *inbuf, char *outbuf)
213 /* dual names + lock_and_read + nt SMBs + remote API calls */
214 int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ|
215 CAP_LEVEL_II_OPLOCKS|CAP_STATUS32;
218 time_t t = time(NULL);
221 BOOL negotiate_spnego = False;
223 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
225 /* do spnego in user level security if the client
226 supports it and we can do encrypted passwords */
228 if (global_encrypted_passwords_negotiated &&
229 (lp_security() != SEC_SHARE) &&
230 (SVAL(inbuf, smb_flg2) & FLAGS2_EXTENDED_SECURITY)) {
231 negotiate_spnego = True;
232 capabilities |= CAP_EXTENDED_SECURITY;
235 capabilities |= CAP_NT_SMBS|CAP_RPC_REMOTE_APIS;
237 if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64)) {
238 capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_W2K_SMBS;
241 if (SMB_OFF_T_BITS == 64) {
242 capabilities |= CAP_LARGE_FILES;
245 if (lp_readraw() && lp_writeraw()) {
246 capabilities |= CAP_RAW_MODE;
249 /* allow for disabling unicode */
251 capabilities |= CAP_UNICODE;
255 capabilities |= CAP_DFS;
257 if (lp_security() >= SEC_USER) secword |= 1;
258 if (global_encrypted_passwords_negotiated) secword |= 2;
260 set_message(outbuf,17,0,True);
262 CVAL(outbuf,smb_vwv1) = secword;
264 Protocol = PROTOCOL_NT1;
266 SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
267 SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */
268 SIVAL(outbuf,smb_vwv3+1,0xffff); /* max buffer. LOTS! */
269 SIVAL(outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */
270 SIVAL(outbuf,smb_vwv7+1,sys_getpid()); /* session key */
271 SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */
272 put_long_date(outbuf+smb_vwv11+1,t);
273 SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
275 p = q = smb_buf(outbuf);
276 if (!negotiate_spnego) {
277 if (global_encrypted_passwords_negotiated) {
278 if (!make_auth_info_subsystem(&negprot_global_auth_info)) {
279 smb_panic("cannot make_negprot_global_auth_info!\n");
281 cryptkey = auth_get_challenge(negprot_global_auth_info);
282 memcpy(p, cryptkey.data, 8);
283 data_blob_free(&cryptkey);
285 SSVALS(outbuf,smb_vwv16+1,8);
287 p += srvstr_push(outbuf, p, global_myworkgroup, -1,
288 STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
289 DEBUG(3,("not using SPNEGO\n"));
291 int len = negprot_spnego(p);
293 SSVALS(outbuf,smb_vwv16+1,len);
295 DEBUG(3,("using SPNEGO\n"));
298 SSVAL(outbuf,smb_vwv17, p - q); /* length of challenge+domain strings */
299 set_message_end(outbuf, p);
301 return (smb_len(outbuf)+4);
304 /* these are the protocol lists used for auto architecture detection:
307 protocol [PC NETWORK PROGRAM 1.0]
308 protocol [XENIX CORE]
309 protocol [MICROSOFT NETWORKS 1.03]
311 protocol [Windows for Workgroups 3.1a]
314 protocol [NT LM 0.12]
317 protocol [PC NETWORK PROGRAM 1.0]
318 protocol [XENIX CORE]
319 protocol [MICROSOFT NETWORKS 1.03]
321 protocol [Windows for Workgroups 3.1a]
324 protocol [NT LM 0.12]
327 protocol [PC NETWORK PROGRAM 1.0]
329 protocol [Windows for Workgroups 3.1a]
332 protocol [NT LM 0.12]
335 protocol [PC NETWORK PROGRAM 1.0]
336 protocol [XENIX CORE]
343 * Modified to recognize the architecture of the remote machine better.
345 * This appears to be the matrix of which protocol is used by which
347 Protocol WfWg Win95 WinNT Win2K OS/2
348 PC NETWORK PROGRAM 1.0 1 1 1 1 1
350 MICROSOFT NETWORKS 3.0 2 2
352 MICROSOFT NETWORKS 1.03 3
355 Windows for Workgroups 3.1a 5 5 5 3
360 * tim@fsg.com 09/29/95
361 * Win2K added by matty 17/7/99
364 #define ARCH_WFWG 0x3 /* This is a fudge because WfWg is like Win95 */
365 #define ARCH_WIN95 0x2
366 #define ARCH_WINNT 0x4
367 #define ARCH_WIN2K 0xC /* Win2K is like NT */
368 #define ARCH_OS2 0x14 /* Again OS/2 is like NT */
369 #define ARCH_SAMBA 0x20
371 #define ARCH_ALL 0x3F
373 /* List of supported protocols, most desired first */
377 int (*proto_reply_fn)(char *, char *);
379 } supported_protocols[] = {
380 {"NT LANMAN 1.0", "NT1", reply_nt1, PROTOCOL_NT1},
381 {"NT LM 0.12", "NT1", reply_nt1, PROTOCOL_NT1},
382 {"LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
383 {"Samba", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
384 {"DOS LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
385 {"LANMAN1.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
386 {"MICROSOFT NETWORKS 3.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
387 {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
388 {"PC NETWORK PROGRAM 1.0", "CORE", reply_corep, PROTOCOL_CORE},
393 /****************************************************************************
395 ****************************************************************************/
396 int reply_negprot(connection_struct *conn,
397 char *inbuf,char *outbuf, int dum_size,
400 int outsize = set_message(outbuf,1,0,True);
405 int bcc = SVAL(smb_buf(inbuf),-2);
407 START_PROFILE(SMBnegprot);
409 p = smb_buf(inbuf)+1;
410 while (p < (smb_buf(inbuf) + bcc))
413 DEBUG(3,("Requested protocol [%s]\n",p));
414 if (strcsequal(p,"Windows for Workgroups 3.1a"))
415 arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
416 else if (strcsequal(p,"DOS LM1.2X002"))
417 arch &= ( ARCH_WFWG | ARCH_WIN95 );
418 else if (strcsequal(p,"DOS LANMAN2.1"))
419 arch &= ( ARCH_WFWG | ARCH_WIN95 );
420 else if (strcsequal(p,"NT LM 0.12"))
421 arch &= ( ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
422 else if (strcsequal(p,"LANMAN2.1"))
423 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
424 else if (strcsequal(p,"LM1.2X002"))
425 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
426 else if (strcsequal(p,"MICROSOFT NETWORKS 1.03"))
428 else if (strcsequal(p,"XENIX CORE"))
429 arch &= ( ARCH_WINNT | ARCH_OS2 );
430 else if (strcsequal(p,"Samba")) {
440 set_remote_arch(RA_SAMBA);
443 set_remote_arch(RA_WFWG);
446 set_remote_arch(RA_WIN95);
449 if(SVAL(inbuf,smb_flg2)==FLAGS2_WIN2K_SIGNATURE)
450 set_remote_arch(RA_WIN2K);
452 set_remote_arch(RA_WINNT);
455 set_remote_arch(RA_WIN2K);
458 set_remote_arch(RA_OS2);
461 set_remote_arch(RA_UNKNOWN);
465 /* possibly reload - change of architecture */
466 reload_services(True);
468 /* Check for protocols, most desirable first */
469 for (protocol = 0; supported_protocols[protocol].proto_name; protocol++)
471 p = smb_buf(inbuf)+1;
473 if ((supported_protocols[protocol].protocol_level <= lp_maxprotocol()) &&
474 (supported_protocols[protocol].protocol_level >= lp_minprotocol()))
475 while (p < (smb_buf(inbuf) + bcc))
477 if (strequal(p,supported_protocols[protocol].proto_name))
486 SSVAL(outbuf,smb_vwv0,choice);
488 extern fstring remote_proto;
489 fstrcpy(remote_proto,supported_protocols[protocol].short_name);
490 reload_services(True);
491 outsize = supported_protocols[protocol].proto_reply_fn(inbuf, outbuf);
492 DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
495 DEBUG(0,("No protocol supported !\n"));
497 SSVAL(outbuf,smb_vwv0,choice);
499 DEBUG( 5, ( "negprot index=%d\n", choice ) );
501 END_PROFILE(SMBnegprot);