2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Volker Lendecke 2007
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 3 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, see <http://www.gnu.org/licenses/>.
23 extern fstring remote_proto;
24 extern enum protocol_types Protocol;
27 BOOL global_encrypted_passwords_negotiated = False;
28 BOOL global_spnego_negotiated = False;
29 struct auth_context *negprot_global_auth_context = NULL;
31 static void get_challenge(uint8 buff[8])
34 const uint8 *cryptkey;
36 /* We might be called more than once, multiple negprots are
38 if (negprot_global_auth_context) {
39 DEBUG(3, ("get challenge: is this a secondary negprot? negprot_global_auth_context is non-NULL!\n"));
40 (negprot_global_auth_context->free)(&negprot_global_auth_context);
43 DEBUG(10, ("get challenge: creating negprot_global_auth_context\n"));
44 if (!NT_STATUS_IS_OK(nt_status = make_auth_context_subsystem(&negprot_global_auth_context))) {
45 DEBUG(0, ("make_auth_context_subsystem returned %s", nt_errstr(nt_status)));
46 smb_panic("cannot make_negprot_global_auth_context!");
48 DEBUG(10, ("get challenge: getting challenge\n"));
49 cryptkey = negprot_global_auth_context->get_ntlm_challenge(negprot_global_auth_context);
50 memcpy(buff, cryptkey, 8);
53 /****************************************************************************
54 Reply for the core protocol.
55 ****************************************************************************/
57 static void reply_corep(struct smb_request *req, uint16 choice)
59 reply_outbuf(req, 1, 0);
60 SSVAL(req->outbuf, smb_vwv0, choice);
62 Protocol = PROTOCOL_CORE;
65 /****************************************************************************
66 Reply for the coreplus protocol.
67 ****************************************************************************/
69 static void reply_coreplus(struct smb_request *req, uint16 choice)
71 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
73 reply_outbuf(req, 13, 0);
75 SSVAL(req->outbuf,smb_vwv0,choice);
76 SSVAL(req->outbuf,smb_vwv5,raw); /* tell redirector we support
77 readbraw and writebraw (possibly) */
78 /* Reply, SMBlockread, SMBwritelock supported. */
79 SCVAL(req->outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
80 SSVAL(req->outbuf,smb_vwv1,0x1); /* user level security, don't
82 Protocol = PROTOCOL_COREPLUS;
85 /****************************************************************************
86 Reply for the lanman 1.0 protocol.
87 ****************************************************************************/
89 static void reply_lanman1(struct smb_request *req, uint16 choice)
91 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
93 time_t t = time(NULL);
95 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
97 if (lp_security()>=SEC_USER)
98 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
99 if (global_encrypted_passwords_negotiated)
100 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
102 reply_outbuf(req, 13, global_encrypted_passwords_negotiated?8:0);
104 SSVAL(req->outbuf,smb_vwv0,choice);
105 SSVAL(req->outbuf,smb_vwv1,secword);
106 /* Create a token value and add it to the outgoing packet. */
107 if (global_encrypted_passwords_negotiated) {
108 get_challenge((uint8 *)smb_buf(req->outbuf));
109 SSVAL(req->outbuf,smb_vwv11, 8);
112 Protocol = PROTOCOL_LANMAN1;
114 /* Reply, SMBlockread, SMBwritelock supported. */
115 SCVAL(req->outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
116 SSVAL(req->outbuf,smb_vwv2,max_recv);
117 SSVAL(req->outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
118 SSVAL(req->outbuf,smb_vwv4,1);
119 SSVAL(req->outbuf,smb_vwv5,raw); /* tell redirector we support
120 readbraw writebraw (possibly) */
121 SIVAL(req->outbuf,smb_vwv6,sys_getpid());
122 SSVAL(req->outbuf,smb_vwv10, set_server_zone_offset(t)/60);
124 srv_put_dos_date((char *)req->outbuf,smb_vwv8,t);
129 /****************************************************************************
130 Reply for the lanman 2.0 protocol.
131 ****************************************************************************/
133 static void reply_lanman2(struct smb_request *req, uint16 choice)
135 int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
137 time_t t = time(NULL);
139 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
141 if (lp_security()>=SEC_USER)
142 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
143 if (global_encrypted_passwords_negotiated)
144 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
146 reply_outbuf(req, 13, global_encrypted_passwords_negotiated?8:0);
148 SSVAL(req->outbuf,smb_vwv0,choice);
149 SSVAL(req->outbuf,smb_vwv1,secword);
150 SIVAL(req->outbuf,smb_vwv6,sys_getpid());
152 /* Create a token value and add it to the outgoing packet. */
153 if (global_encrypted_passwords_negotiated) {
154 get_challenge((uint8 *)smb_buf(req->outbuf));
155 SSVAL(req->outbuf,smb_vwv11, 8);
158 Protocol = PROTOCOL_LANMAN2;
160 /* Reply, SMBlockread, SMBwritelock supported. */
161 SCVAL(req->outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
162 SSVAL(req->outbuf,smb_vwv2,max_recv);
163 SSVAL(req->outbuf,smb_vwv3,lp_maxmux());
164 SSVAL(req->outbuf,smb_vwv4,1);
165 SSVAL(req->outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
166 SSVAL(req->outbuf,smb_vwv10, set_server_zone_offset(t)/60);
167 srv_put_dos_date((char *)req->outbuf,smb_vwv8,t);
170 /****************************************************************************
171 Generate the spnego negprot reply blob. Return the number of bytes used.
172 ****************************************************************************/
174 static DATA_BLOB negprot_spnego(void)
183 const char *OIDs_krb5[] = {OID_KERBEROS5,
187 const char *OIDs_plain[] = {OID_NTLMSSP, NULL};
189 global_spnego_negotiated = True;
191 memset(guid, '\0', sizeof(guid));
193 safe_strcpy(unix_name, global_myname(), sizeof(unix_name)-1);
194 strlower_m(unix_name);
195 push_ascii_nstring(dos_name, unix_name);
196 safe_strcpy(guid, dos_name, sizeof(guid)-1);
199 /* Fix valgrind 'uninitialized bytes' issue. */
200 slen = strlen(dos_name);
201 if (slen < sizeof(guid)) {
202 memset(guid+slen, '\0', sizeof(guid) - slen);
206 /* strangely enough, NT does not sent the single OID NTLMSSP when
207 not a ADS member, it sends no OIDs at all
209 OLD COMMENT : "we can't do this until we teach our sesssion setup parser to know
210 about raw NTLMSSP (clients send no ASN.1 wrapping if we do this)"
212 Our sessionsetup code now handles raw NTLMSSP connects, so we can go
213 back to doing what W2K3 does here. This is needed to make PocketPC 2003
214 CIFS connections work with SPNEGO. See bugzilla bugs #1828 and #3133
219 if (lp_security() != SEC_ADS && !lp_use_kerberos_keytab()) {
221 /* Code for PocketPC client */
222 blob = data_blob(guid, 16);
224 /* Code for standalone WXP client */
225 blob = spnego_gen_negTokenInit(guid, OIDs_plain, "NONE");
229 char *host_princ_s = NULL;
230 name_to_fqdn(myname, global_myname());
232 asprintf(&host_princ_s, "cifs/%s@%s", myname, lp_realm());
233 if (host_princ_s == NULL) {
234 blob = data_blob_null;
237 blob = spnego_gen_negTokenInit(guid, OIDs_krb5, host_princ_s);
238 SAFE_FREE(host_princ_s);
244 /****************************************************************************
245 Reply for the nt protocol.
246 ****************************************************************************/
248 static void reply_nt1(struct smb_request *req, uint16 choice)
250 /* dual names + lock_and_read + nt SMBs + remote API calls */
251 int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ|
252 CAP_LEVEL_II_OPLOCKS;
256 BOOL negotiate_spnego = False;
257 time_t t = time(NULL);
260 global_encrypted_passwords_negotiated = lp_encrypted_passwords();
262 /* Check the flags field to see if this is Vista.
263 WinXP sets it and Vista does not. But we have to
264 distinguish from NT which doesn't set it either. */
266 if ( (req->flags2 & FLAGS2_EXTENDED_SECURITY) &&
267 ((req->flags2 & FLAGS2_UNKNOWN_BIT4) == 0) )
269 if (get_remote_arch() != RA_SAMBA) {
270 set_remote_arch( RA_VISTA );
274 reply_outbuf(req,17,0);
276 /* do spnego in user level security if the client
277 supports it and we can do encrypted passwords */
279 if (global_encrypted_passwords_negotiated &&
280 (lp_security() != SEC_SHARE) &&
282 (req->flags2 & FLAGS2_EXTENDED_SECURITY)) {
283 negotiate_spnego = True;
284 capabilities |= CAP_EXTENDED_SECURITY;
285 add_to_common_flags2(FLAGS2_EXTENDED_SECURITY);
286 /* Ensure FLAGS2_EXTENDED_SECURITY gets set in this reply
287 (already partially constructed. */
288 SSVAL(req->outbuf, smb_flg2,
289 req->flags2 | FLAGS2_EXTENDED_SECURITY);
292 capabilities |= CAP_NT_SMBS|CAP_RPC_REMOTE_APIS|CAP_UNICODE;
294 if (lp_unix_extensions()) {
295 capabilities |= CAP_UNIX;
298 if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64))
299 capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_W2K_SMBS;
301 if (SMB_OFF_T_BITS == 64)
302 capabilities |= CAP_LARGE_FILES;
304 if (lp_readraw() && lp_writeraw())
305 capabilities |= CAP_RAW_MODE;
307 if (lp_nt_status_support())
308 capabilities |= CAP_STATUS32;
311 capabilities |= CAP_DFS;
313 if (lp_security() >= SEC_USER)
314 secword |= NEGOTIATE_SECURITY_USER_LEVEL;
315 if (global_encrypted_passwords_negotiated)
316 secword |= NEGOTIATE_SECURITY_CHALLENGE_RESPONSE;
318 if (lp_server_signing()) {
319 if (lp_security() >= SEC_USER) {
320 secword |= NEGOTIATE_SECURITY_SIGNATURES_ENABLED;
321 /* No raw mode with smb signing. */
322 capabilities &= ~CAP_RAW_MODE;
323 if (lp_server_signing() == Required)
324 secword |=NEGOTIATE_SECURITY_SIGNATURES_REQUIRED;
325 srv_set_signing_negotiated();
327 DEBUG(0,("reply_nt1: smb signing is incompatible with share level security !\n"));
328 if (lp_server_signing() == Required) {
329 exit_server_cleanly("reply_nt1: smb signing required and share level security selected.");
334 SSVAL(req->outbuf,smb_vwv0,choice);
335 SCVAL(req->outbuf,smb_vwv1,secword);
337 Protocol = PROTOCOL_NT1;
339 SSVAL(req->outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
340 SSVAL(req->outbuf,smb_vwv2+1,1); /* num vcs */
341 SIVAL(req->outbuf,smb_vwv3+1,max_recv); /* max buffer. LOTS! */
342 SIVAL(req->outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */
343 SIVAL(req->outbuf,smb_vwv7+1,sys_getpid()); /* session key */
344 SIVAL(req->outbuf,smb_vwv9+1,capabilities); /* capabilities */
345 put_long_date((char *)req->outbuf+smb_vwv11+1,t);
346 SSVALS(req->outbuf,smb_vwv15+1,set_server_zone_offset(t)/60);
348 p = q = smb_buf(req->outbuf);
349 if (!negotiate_spnego) {
350 /* Create a token value and add it to the outgoing packet. */
351 if (global_encrypted_passwords_negotiated) {
353 /* note that we do not send a challenge at all if
354 we are using plaintext */
356 ret = message_push_blob(
357 &req->outbuf, data_blob_const(chal, sizeof(chal)));
359 DEBUG(0, ("Could not push challenge\n"));
360 reply_nterror(req, NT_STATUS_NO_MEMORY);
363 SCVAL(req->outbuf, smb_vwv16+1, ret);
366 ret = message_push_string(&req->outbuf, lp_workgroup(),
367 STR_UNICODE|STR_TERMINATE
370 DEBUG(0, ("Could not push challenge\n"));
371 reply_nterror(req, NT_STATUS_NO_MEMORY);
374 DEBUG(3,("not using SPNEGO\n"));
376 DATA_BLOB spnego_blob = negprot_spnego();
378 if (spnego_blob.data == NULL) {
379 reply_nterror(req, NT_STATUS_NO_MEMORY);
383 ret = message_push_blob(&req->outbuf, spnego_blob);
385 DEBUG(0, ("Could not push spnego blob\n"));
386 reply_nterror(req, NT_STATUS_NO_MEMORY);
390 data_blob_free(&spnego_blob);
392 SCVAL(req->outbuf,smb_vwv16+1, 0);
393 DEBUG(3,("using SPNEGO\n"));
396 SSVAL(req->outbuf,smb_vwv17, p - q); /* length of challenge+domain
402 /* these are the protocol lists used for auto architecture detection:
405 protocol [PC NETWORK PROGRAM 1.0]
406 protocol [XENIX CORE]
407 protocol [MICROSOFT NETWORKS 1.03]
409 protocol [Windows for Workgroups 3.1a]
412 protocol [NT LM 0.12]
415 protocol [PC NETWORK PROGRAM 1.0]
416 protocol [XENIX CORE]
417 protocol [MICROSOFT NETWORKS 1.03]
419 protocol [Windows for Workgroups 3.1a]
422 protocol [NT LM 0.12]
425 protocol [PC NETWORK PROGRAM 1.0]
427 protocol [Windows for Workgroups 3.1a]
430 protocol [NT LM 0.12]
433 protocol [PC NETWORK PROGRAM 1.0]
435 protocol [Windows for Workgroups 3.1a]
438 protocol [NT LM 0.12]
442 protocol [PC NETWORK PROGRAM 1.0]
443 protocol [XENIX CORE]
450 * Modified to recognize the architecture of the remote machine better.
452 * This appears to be the matrix of which protocol is used by which
454 Protocol WfWg Win95 WinNT Win2K OS/2 Vista
455 PC NETWORK PROGRAM 1.0 1 1 1 1 1 1
457 MICROSOFT NETWORKS 3.0 2 2
459 MICROSOFT NETWORKS 1.03 3
462 Windows for Workgroups 3.1a 5 5 5 3 3
468 * tim@fsg.com 09/29/95
469 * Win2K added by matty 17/7/99
472 #define ARCH_WFWG 0x3 /* This is a fudge because WfWg is like Win95 */
473 #define ARCH_WIN95 0x2
474 #define ARCH_WINNT 0x4
475 #define ARCH_WIN2K 0xC /* Win2K is like NT */
476 #define ARCH_OS2 0x14 /* Again OS/2 is like NT */
477 #define ARCH_SAMBA 0x20
478 #define ARCH_CIFSFS 0x40
479 #define ARCH_VISTA 0x8C /* Vista is like XP/2K */
481 #define ARCH_ALL 0x7F
483 /* List of supported protocols, most desired first */
484 static const struct {
485 const char *proto_name;
486 const char *short_name;
487 void (*proto_reply_fn)(struct smb_request *req, uint16 choice);
489 } supported_protocols[] = {
490 {"NT LANMAN 1.0", "NT1", reply_nt1, PROTOCOL_NT1},
491 {"NT LM 0.12", "NT1", reply_nt1, PROTOCOL_NT1},
492 {"POSIX 2", "NT1", reply_nt1, PROTOCOL_NT1},
493 {"LANMAN2.1", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
494 {"LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
495 {"Samba", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
496 {"DOS LM1.2X002", "LANMAN2", reply_lanman2, PROTOCOL_LANMAN2},
497 {"LANMAN1.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
498 {"MICROSOFT NETWORKS 3.0", "LANMAN1", reply_lanman1, PROTOCOL_LANMAN1},
499 {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
500 {"PC NETWORK PROGRAM 1.0", "CORE", reply_corep, PROTOCOL_CORE},
504 /****************************************************************************
506 conn POINTER CAN BE NULL HERE !
507 ****************************************************************************/
509 void reply_negprot(connection_struct *conn, struct smb_request *req)
511 size_t size = smb_len(req->inbuf) + 4;
515 int bcc = SVAL(smb_buf(req->inbuf),-2);
521 static BOOL done_negprot = False;
523 START_PROFILE(SMBnegprot);
526 END_PROFILE(SMBnegprot);
527 exit_server_cleanly("multiple negprot's are not permitted");
531 if (req->inbuf[size-1] != '\0') {
532 DEBUG(0, ("negprot protocols not 0-terminated\n"));
533 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
534 END_PROFILE(SMBnegprot);
538 p = smb_buf(req->inbuf) + 1;
543 while (p < (smb_buf(req->inbuf) + bcc)) {
547 tmp = TALLOC_REALLOC_ARRAY(tmp_talloc_ctx(), cliprotos, char *,
550 DEBUG(0, ("talloc failed\n"));
551 TALLOC_FREE(cliprotos);
552 reply_nterror(req, NT_STATUS_NO_MEMORY);
553 END_PROFILE(SMBnegprot);
559 if (pull_ascii_talloc(cliprotos, &cliprotos[num_cliprotos], p)
561 DEBUG(0, ("pull_ascii_talloc failed\n"));
562 TALLOC_FREE(cliprotos);
563 reply_nterror(req, NT_STATUS_NO_MEMORY);
564 END_PROFILE(SMBnegprot);
568 DEBUG(3, ("Requested protocol [%s]\n",
569 cliprotos[num_cliprotos]));
575 for (i=0; i<num_cliprotos; i++) {
576 if (strcsequal(cliprotos[i], "Windows for Workgroups 3.1a"))
577 arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT
579 else if (strcsequal(cliprotos[i], "DOS LM1.2X002"))
580 arch &= ( ARCH_WFWG | ARCH_WIN95 );
581 else if (strcsequal(cliprotos[i], "DOS LANMAN2.1"))
582 arch &= ( ARCH_WFWG | ARCH_WIN95 );
583 else if (strcsequal(cliprotos[i], "NT LM 0.12"))
584 arch &= ( ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K
586 else if (strcsequal(cliprotos[i], "SMB 2.001"))
588 else if (strcsequal(cliprotos[i], "LANMAN2.1"))
589 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
590 else if (strcsequal(cliprotos[i], "LM1.2X002"))
591 arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
592 else if (strcsequal(cliprotos[i], "MICROSOFT NETWORKS 1.03"))
594 else if (strcsequal(cliprotos[i], "XENIX CORE"))
595 arch &= ( ARCH_WINNT | ARCH_OS2 );
596 else if (strcsequal(cliprotos[i], "Samba")) {
599 } else if (strcsequal(cliprotos[i], "POSIX 2")) {
605 /* CIFSFS can send one arch only, NT LM 0.12. */
606 if (i == 1 && (arch & ARCH_CIFSFS)) {
612 set_remote_arch(RA_CIFSFS);
615 set_remote_arch(RA_SAMBA);
618 set_remote_arch(RA_WFWG);
621 set_remote_arch(RA_WIN95);
624 if(req->flags2 == FLAGS2_WIN2K_SIGNATURE)
625 set_remote_arch(RA_WIN2K);
627 set_remote_arch(RA_WINNT);
630 /* Vista may have been set in the negprot so don't
632 if ( get_remote_arch() != RA_VISTA )
633 set_remote_arch(RA_WIN2K);
636 set_remote_arch(RA_VISTA);
639 set_remote_arch(RA_OS2);
642 set_remote_arch(RA_UNKNOWN);
646 /* possibly reload - change of architecture */
647 reload_services(True);
649 /* moved from the netbios session setup code since we don't have that
650 when the client connects to port 445. Of course there is a small
651 window where we are listening to messages -- jerry */
654 NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
656 /* Check for protocols, most desirable first */
657 for (protocol = 0; supported_protocols[protocol].proto_name; protocol++) {
659 if ((supported_protocols[protocol].protocol_level <= lp_maxprotocol()) &&
660 (supported_protocols[protocol].protocol_level >= lp_minprotocol()))
661 while (i < num_cliprotos) {
662 if (strequal(cliprotos[i],supported_protocols[protocol].proto_name))
671 fstrcpy(remote_proto,supported_protocols[protocol].short_name);
672 reload_services(True);
673 supported_protocols[protocol].proto_reply_fn(req, choice);
674 DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
676 DEBUG(0,("No protocol supported !\n"));
677 reply_outbuf(req, 1, 0);
678 SSVAL(req->outbuf, smb_vwv0, choice);
681 DEBUG( 5, ( "negprot index=%d\n", choice ) );
683 if ((lp_server_signing() == Required) && (Protocol < PROTOCOL_NT1)) {
684 exit_server_cleanly("SMB signing is required and "
685 "client negotiated a downlevel protocol");
688 TALLOC_FREE(cliprotos);
689 END_PROFILE(SMBnegprot);