2 Unix SMB/Netbios implementation.
4 handle NLTMSSP, server side
6 Copyright (C) Andrew Tridgell 2001
7 Copyright (C) Andrew Bartlett 2001-2003
8 Copyright (C) Andrew Bartlett 2005 (Updated from gensec).
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "../libcli/auth/ntlmssp.h"
26 #include "../libcli/auth/ntlmssp_private.h"
27 #include "../libcli/auth/libcli_auth.h"
28 #include "../librpc/gen_ndr/ndr_ntlmssp.h"
29 #include "../libcli/auth/ntlmssp_ndr.h"
30 #include "../lib/crypto/md5.h"
31 #include "../lib/crypto/arcfour.h"
32 #include "../lib/crypto/hmacmd5.h"
34 static NTSTATUS ntlmssp_client_initial(struct ntlmssp_state *ntlmssp_state,
35 DATA_BLOB reply, DATA_BLOB *next_request);
36 static NTSTATUS ntlmssp_server_negotiate(struct ntlmssp_state *ntlmssp_state,
37 const DATA_BLOB in, DATA_BLOB *out);
38 static NTSTATUS ntlmssp_client_challenge(struct ntlmssp_state *ntlmssp_state,
39 const DATA_BLOB reply, DATA_BLOB *next_request);
40 static NTSTATUS ntlmssp_server_auth(struct ntlmssp_state *ntlmssp_state,
41 const DATA_BLOB request, DATA_BLOB *reply);
44 * Callbacks for NTLMSSP - for both client and server operating modes
48 static const struct ntlmssp_callbacks {
49 enum ntlmssp_role role;
50 enum ntlmssp_message_type ntlmssp_command;
51 NTSTATUS (*fn)(struct ntlmssp_state *ntlmssp_state,
52 DATA_BLOB in, DATA_BLOB *out);
53 } ntlmssp_callbacks[] = {
54 {NTLMSSP_CLIENT, NTLMSSP_INITIAL, ntlmssp_client_initial},
55 {NTLMSSP_SERVER, NTLMSSP_NEGOTIATE, ntlmssp_server_negotiate},
56 {NTLMSSP_CLIENT, NTLMSSP_CHALLENGE, ntlmssp_client_challenge},
57 {NTLMSSP_SERVER, NTLMSSP_AUTH, ntlmssp_server_auth},
58 {NTLMSSP_CLIENT, NTLMSSP_UNKNOWN, NULL},
59 {NTLMSSP_SERVER, NTLMSSP_UNKNOWN, NULL}
64 * Default challenge generation code.
68 static NTSTATUS get_challenge(const struct ntlmssp_state *ntlmssp_state,
71 generate_random_buffer(chal, 8);
76 * Default 'we can set the challenge to anything we like' implementation
80 static bool may_set_challenge(const struct ntlmssp_state *ntlmssp_state)
86 * Default 'we can set the challenge to anything we like' implementation
88 * Does not actually do anything, as the value is always in the structure anyway.
92 static NTSTATUS set_challenge(struct ntlmssp_state *ntlmssp_state, DATA_BLOB *challenge)
94 SMB_ASSERT(challenge->length == 8);
99 * Set a username on an NTLMSSP context - ensures it is talloc()ed
103 NTSTATUS ntlmssp_set_username(struct ntlmssp_state *ntlmssp_state, const char *user)
105 ntlmssp_state->user = talloc_strdup(ntlmssp_state, user ? user : "" );
106 if (!ntlmssp_state->user) {
107 return NT_STATUS_NO_MEMORY;
113 * Store NT and LM hashes on an NTLMSSP context - ensures they are talloc()ed
116 NTSTATUS ntlmssp_set_hashes(struct ntlmssp_state *ntlmssp_state,
117 const uint8_t lm_hash[16],
118 const uint8_t nt_hash[16])
120 ntlmssp_state->lm_hash = (uint8_t *)
121 TALLOC_MEMDUP(ntlmssp_state, lm_hash, 16);
122 ntlmssp_state->nt_hash = (uint8_t *)
123 TALLOC_MEMDUP(ntlmssp_state, nt_hash, 16);
124 if (!ntlmssp_state->lm_hash || !ntlmssp_state->nt_hash) {
125 TALLOC_FREE(ntlmssp_state->lm_hash);
126 TALLOC_FREE(ntlmssp_state->nt_hash);
127 return NT_STATUS_NO_MEMORY;
133 * Converts a password to the hashes on an NTLMSSP context.
136 NTSTATUS ntlmssp_set_password(struct ntlmssp_state *ntlmssp_state, const char *password)
139 ntlmssp_state->lm_hash = NULL;
140 ntlmssp_state->nt_hash = NULL;
145 E_deshash(password, lm_hash);
146 E_md4hash(password, nt_hash);
147 return ntlmssp_set_hashes(ntlmssp_state, lm_hash, nt_hash);
153 * Set a domain on an NTLMSSP context - ensures it is talloc()ed
156 NTSTATUS ntlmssp_set_domain(struct ntlmssp_state *ntlmssp_state, const char *domain)
158 ntlmssp_state->domain = talloc_strdup(ntlmssp_state,
159 domain ? domain : "" );
160 if (!ntlmssp_state->domain) {
161 return NT_STATUS_NO_MEMORY;
167 * Request features for the NTLMSSP negotiation
169 * @param ntlmssp_state NTLMSSP state
170 * @param feature_list List of space seperated features requested from NTLMSSP.
172 void ntlmssp_want_feature_list(struct ntlmssp_state *ntlmssp_state, char *feature_list)
175 * We need to set this to allow a later SetPassword
176 * via the SAMR pipe to succeed. Strange.... We could
177 * also add NTLMSSP_NEGOTIATE_SEAL here. JRA.
179 if (in_list("NTLMSSP_FEATURE_SESSION_KEY", feature_list, True)) {
180 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
182 if (in_list("NTLMSSP_FEATURE_SIGN", feature_list, True)) {
183 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
185 if(in_list("NTLMSSP_FEATURE_SEAL", feature_list, True)) {
186 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SEAL;
188 if (in_list("NTLMSSP_FEATURE_CCACHE", feature_list, true)) {
189 ntlmssp_state->use_ccache = true;
194 * Request a feature for the NTLMSSP negotiation
196 * @param ntlmssp_state NTLMSSP state
197 * @param feature Bit flag specifying the requested feature
199 void ntlmssp_want_feature(struct ntlmssp_state *ntlmssp_state, uint32_t feature)
201 /* As per JRA's comment above */
202 if (feature & NTLMSSP_FEATURE_SESSION_KEY) {
203 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
205 if (feature & NTLMSSP_FEATURE_SIGN) {
206 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SIGN;
208 if (feature & NTLMSSP_FEATURE_SEAL) {
209 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_SEAL;
211 if (feature & NTLMSSP_FEATURE_CCACHE) {
212 ntlmssp_state->use_ccache = true;
217 * Next state function for the NTLMSSP state machine
219 * @param ntlmssp_state NTLMSSP State
220 * @param in The packet in from the NTLMSSP partner, as a DATA_BLOB
221 * @param out The reply, as an allocated DATA_BLOB, caller to free.
222 * @return Errors, NT_STATUS_MORE_PROCESSING_REQUIRED or NT_STATUS_OK.
225 NTSTATUS ntlmssp_update(struct ntlmssp_state *ntlmssp_state,
226 const DATA_BLOB input, DATA_BLOB *out)
228 uint32_t ntlmssp_command;
231 if (ntlmssp_state->expected_state == NTLMSSP_DONE) {
232 /* Called update after negotiations finished. */
233 DEBUG(1, ("Called NTLMSSP after state machine was 'done'\n"));
234 return NT_STATUS_INVALID_PARAMETER;
237 *out = data_blob_null;
240 switch (ntlmssp_state->role) {
242 ntlmssp_command = NTLMSSP_INITIAL;
245 /* 'datagram' mode - no neg packet */
246 ntlmssp_command = NTLMSSP_NEGOTIATE;
250 if (!msrpc_parse(ntlmssp_state, &input, "Cd",
253 DEBUG(1, ("Failed to parse NTLMSSP packet, could not extract NTLMSSP command\n"));
254 dump_data(2, input.data, input.length);
255 return NT_STATUS_INVALID_PARAMETER;
259 if (ntlmssp_command != ntlmssp_state->expected_state) {
260 DEBUG(1, ("got NTLMSSP command %u, expected %u\n", ntlmssp_command, ntlmssp_state->expected_state));
261 return NT_STATUS_INVALID_PARAMETER;
264 for (i=0; ntlmssp_callbacks[i].fn; i++) {
265 if (ntlmssp_callbacks[i].role == ntlmssp_state->role
266 && ntlmssp_callbacks[i].ntlmssp_command == ntlmssp_command) {
267 return ntlmssp_callbacks[i].fn(ntlmssp_state, input, out);
271 DEBUG(1, ("failed to find NTLMSSP callback for NTLMSSP mode %u, command %u\n",
272 ntlmssp_state->role, ntlmssp_command));
274 return NT_STATUS_INVALID_PARAMETER;
278 * End an NTLMSSP state machine
280 * @param ntlmssp_state NTLMSSP State, free()ed by this function
283 void ntlmssp_end(struct ntlmssp_state **ntlmssp_state)
285 data_blob_free(&(*ntlmssp_state)->chal);
286 data_blob_free(&(*ntlmssp_state)->lm_resp);
287 data_blob_free(&(*ntlmssp_state)->nt_resp);
288 TALLOC_FREE(*ntlmssp_state);
290 *ntlmssp_state = NULL;
295 * Determine correct target name flags for reply, given server role
296 * and negotiated flags
298 * @param ntlmssp_state NTLMSSP State
299 * @param neg_flags The flags from the packet
300 * @param chal_flags The flags to be set in the reply packet
301 * @return The 'target name' string.
304 static const char *ntlmssp_target_name(struct ntlmssp_state *ntlmssp_state,
305 uint32_t neg_flags, uint32_t *chal_flags)
307 if (neg_flags & NTLMSSP_REQUEST_TARGET) {
308 *chal_flags |= NTLMSSP_NEGOTIATE_TARGET_INFO;
309 *chal_flags |= NTLMSSP_REQUEST_TARGET;
310 if (ntlmssp_state->server.is_standalone) {
311 *chal_flags |= NTLMSSP_TARGET_TYPE_SERVER;
312 return ntlmssp_state->server.netbios_name;
314 *chal_flags |= NTLMSSP_TARGET_TYPE_DOMAIN;
315 return ntlmssp_state->server.netbios_domain;
322 static void ntlmssp_handle_neg_flags(struct ntlmssp_state *ntlmssp_state,
323 uint32_t neg_flags, bool allow_lm) {
324 if (neg_flags & NTLMSSP_NEGOTIATE_UNICODE) {
325 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_UNICODE;
326 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_OEM;
327 ntlmssp_state->unicode = True;
329 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_UNICODE;
330 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_OEM;
331 ntlmssp_state->unicode = False;
334 if ((neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) && allow_lm) {
335 /* other end forcing us to use LM */
336 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_LM_KEY;
337 ntlmssp_state->use_ntlmv2 = False;
339 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
342 if (!(neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)) {
343 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
346 if (!(neg_flags & NTLMSSP_NEGOTIATE_NTLM2)) {
347 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
350 if (!(neg_flags & NTLMSSP_NEGOTIATE_128)) {
351 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_128;
354 if (!(neg_flags & NTLMSSP_NEGOTIATE_56)) {
355 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_56;
358 if (!(neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH)) {
359 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_KEY_EXCH;
362 if (!(neg_flags & NTLMSSP_NEGOTIATE_SIGN)) {
363 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SIGN;
366 if (!(neg_flags & NTLMSSP_NEGOTIATE_SEAL)) {
367 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SEAL;
370 /* Woop Woop - unknown flag for Windows compatibility...
371 What does this really do ? JRA. */
372 if (!(neg_flags & NTLMSSP_NEGOTIATE_VERSION)) {
373 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_VERSION;
376 if ((neg_flags & NTLMSSP_REQUEST_TARGET)) {
377 ntlmssp_state->neg_flags |= NTLMSSP_REQUEST_TARGET;
382 * Next state function for the Negotiate packet
384 * @param ntlmssp_state NTLMSSP State
385 * @param request The request, as a DATA_BLOB
386 * @param request The reply, as an allocated DATA_BLOB, caller to free.
387 * @return Errors or MORE_PROCESSING_REQUIRED if a reply is sent.
390 static NTSTATUS ntlmssp_server_negotiate(struct ntlmssp_state *ntlmssp_state,
391 const DATA_BLOB request, DATA_BLOB *reply)
393 DATA_BLOB struct_blob;
394 uint32_t neg_flags = 0;
395 uint32_t ntlmssp_command, chal_flags;
397 const char *target_name;
400 /* parse the NTLMSSP packet */
402 file_save("ntlmssp_negotiate.dat", request.data, request.length);
405 if (request.length) {
406 if ((request.length < 16) || !msrpc_parse(ntlmssp_state, &request, "Cdd",
410 DEBUG(1, ("ntlmssp_server_negotiate: failed to parse NTLMSSP Negotiate of length %u\n",
411 (unsigned int)request.length));
412 dump_data(2, request.data, request.length);
413 return NT_STATUS_INVALID_PARAMETER;
415 debug_ntlmssp_flags(neg_flags);
417 if (DEBUGLEVEL >= 10) {
418 struct NEGOTIATE_MESSAGE *negotiate = talloc(
419 talloc_tos(), struct NEGOTIATE_MESSAGE);
420 if (negotiate != NULL) {
421 status = ntlmssp_pull_NEGOTIATE_MESSAGE(
422 &request, negotiate, negotiate);
423 if (NT_STATUS_IS_OK(status)) {
424 NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE,
427 TALLOC_FREE(negotiate);
432 ntlmssp_handle_neg_flags(ntlmssp_state, neg_flags, lp_lanman_auth());
434 /* Ask our caller what challenge they would like in the packet */
435 status = ntlmssp_state->get_challenge(ntlmssp_state, cryptkey);
436 if (!NT_STATUS_IS_OK(status)) {
440 /* Check if we may set the challenge */
441 if (!ntlmssp_state->may_set_challenge(ntlmssp_state)) {
442 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
445 /* The flags we send back are not just the negotiated flags,
446 * they are also 'what is in this packet'. Therfore, we
447 * operate on 'chal_flags' from here on
450 chal_flags = ntlmssp_state->neg_flags;
452 /* get the right name to fill in as 'target' */
453 target_name = ntlmssp_target_name(ntlmssp_state,
454 neg_flags, &chal_flags);
455 if (target_name == NULL)
456 return NT_STATUS_INVALID_PARAMETER;
458 ntlmssp_state->chal = data_blob_talloc(ntlmssp_state, cryptkey, 8);
459 ntlmssp_state->internal_chal = data_blob_talloc(ntlmssp_state,
462 /* This creates the 'blob' of names that appears at the end of the packet */
463 if (chal_flags & NTLMSSP_NEGOTIATE_TARGET_INFO)
465 msrpc_gen(ntlmssp_state, &struct_blob, "aaaaa",
466 MsvAvNbDomainName, target_name,
467 MsvAvNbComputerName, ntlmssp_state->server.netbios_name,
468 MsvAvDnsDomainName, ntlmssp_state->server.dns_domain,
469 MsvAvDnsComputerName, ntlmssp_state->server.dns_name,
472 struct_blob = data_blob_null;
476 /* Marshal the packet in the right format, be it unicode or ASCII */
477 const char *gen_string;
478 DATA_BLOB version_blob = data_blob_null;
480 if (chal_flags & NTLMSSP_NEGOTIATE_VERSION) {
481 enum ndr_err_code err;
484 /* "What Windows returns" as a version number. */
486 vers.ProductMajorVersion = NTLMSSP_WINDOWS_MAJOR_VERSION_6;
487 vers.ProductMinorVersion = NTLMSSP_WINDOWS_MINOR_VERSION_1;
488 vers.ProductBuild = 0;
489 vers.NTLMRevisionCurrent = NTLMSSP_REVISION_W2K3;
491 err = ndr_push_struct_blob(&version_blob,
494 (ndr_push_flags_fn_t)ndr_push_VERSION);
496 if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
497 return NT_STATUS_NO_MEMORY;
501 if (ntlmssp_state->unicode) {
502 gen_string = "CdUdbddBb";
504 gen_string = "CdAdbddBb";
507 msrpc_gen(ntlmssp_state, reply, gen_string,
514 struct_blob.data, struct_blob.length,
515 version_blob.data, version_blob.length);
517 data_blob_free(&version_blob);
519 if (DEBUGLEVEL >= 10) {
520 struct CHALLENGE_MESSAGE *challenge = talloc(
521 talloc_tos(), struct CHALLENGE_MESSAGE);
522 if (challenge != NULL) {
523 challenge->NegotiateFlags = chal_flags;
524 status = ntlmssp_pull_CHALLENGE_MESSAGE(
525 reply, challenge, challenge);
526 if (NT_STATUS_IS_OK(status)) {
527 NDR_PRINT_DEBUG(CHALLENGE_MESSAGE,
530 TALLOC_FREE(challenge);
535 data_blob_free(&struct_blob);
537 ntlmssp_state->expected_state = NTLMSSP_AUTH;
539 return NT_STATUS_MORE_PROCESSING_REQUIRED;
543 * Next state function for the Authenticate packet
545 * @param ntlmssp_state NTLMSSP State
546 * @param request The request, as a DATA_BLOB
547 * @param request The reply, as an allocated DATA_BLOB, caller to free.
548 * @return Errors or NT_STATUS_OK.
551 static NTSTATUS ntlmssp_server_auth(struct ntlmssp_state *ntlmssp_state,
552 const DATA_BLOB request, DATA_BLOB *reply)
554 DATA_BLOB encrypted_session_key = data_blob_null;
555 DATA_BLOB user_session_key = data_blob_null;
556 DATA_BLOB lm_session_key = data_blob_null;
557 DATA_BLOB session_key = data_blob_null;
558 uint32_t ntlmssp_command, auth_flags;
559 NTSTATUS nt_status = NT_STATUS_OK;
562 bool doing_ntlm2 = False;
564 uint8_t session_nonce[16];
565 uint8_t session_nonce_hash[16];
567 const char *parse_string;
569 /* parse the NTLMSSP packet */
570 *reply = data_blob_null;
573 file_save("ntlmssp_auth.dat", request.data, request.length);
576 if (ntlmssp_state->unicode) {
577 parse_string = "CdBBUUUBd";
579 parse_string = "CdBBAAABd";
582 data_blob_free(&ntlmssp_state->lm_resp);
583 data_blob_free(&ntlmssp_state->nt_resp);
585 ntlmssp_state->user = NULL;
586 ntlmssp_state->domain = NULL;
588 /* now the NTLMSSP encoded auth hashes */
589 if (!msrpc_parse(ntlmssp_state, &request, parse_string,
592 &ntlmssp_state->lm_resp,
593 &ntlmssp_state->nt_resp,
594 &ntlmssp_state->domain,
595 &ntlmssp_state->user,
596 &ntlmssp_state->client.netbios_name,
597 &encrypted_session_key,
601 /* Try again with a shorter string (Win9X truncates this packet) */
602 if (ntlmssp_state->unicode) {
603 parse_string = "CdBBUUU";
605 parse_string = "CdBBAAA";
608 /* now the NTLMSSP encoded auth hashes */
609 if (!msrpc_parse(ntlmssp_state, &request, parse_string,
612 &ntlmssp_state->lm_resp,
613 &ntlmssp_state->nt_resp,
614 &ntlmssp_state->domain,
615 &ntlmssp_state->user,
616 &ntlmssp_state->client.netbios_name)) {
617 DEBUG(1, ("ntlmssp_server_auth: failed to parse NTLMSSP (tried both formats):\n"));
618 dump_data(2, request.data, request.length);
620 return NT_STATUS_INVALID_PARAMETER;
625 ntlmssp_handle_neg_flags(ntlmssp_state, auth_flags, lp_lanman_auth());
627 if (DEBUGLEVEL >= 10) {
628 struct AUTHENTICATE_MESSAGE *authenticate = talloc(
629 talloc_tos(), struct AUTHENTICATE_MESSAGE);
630 if (authenticate != NULL) {
632 authenticate->NegotiateFlags = auth_flags;
633 status = ntlmssp_pull_AUTHENTICATE_MESSAGE(
634 &request, authenticate, authenticate);
635 if (NT_STATUS_IS_OK(status)) {
636 NDR_PRINT_DEBUG(AUTHENTICATE_MESSAGE,
639 TALLOC_FREE(authenticate);
643 DEBUG(3,("Got user=[%s] domain=[%s] workstation=[%s] len1=%lu len2=%lu\n",
644 ntlmssp_state->user, ntlmssp_state->domain,
645 ntlmssp_state->client.netbios_name,
646 (unsigned long)ntlmssp_state->lm_resp.length,
647 (unsigned long)ntlmssp_state->nt_resp.length));
650 file_save("nthash1.dat", &ntlmssp_state->nt_resp.data, &ntlmssp_state->nt_resp.length);
651 file_save("lmhash1.dat", &ntlmssp_state->lm_resp.data, &ntlmssp_state->lm_resp.length);
654 /* NTLM2 uses a 'challenge' that is made of up both the server challenge, and a
657 However, the NTLM2 flag may still be set for the real NTLMv2 logins, be careful.
659 if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
660 if (ntlmssp_state->nt_resp.length == 24 && ntlmssp_state->lm_resp.length == 24) {
661 struct MD5Context md5_session_nonce_ctx;
662 SMB_ASSERT(ntlmssp_state->internal_chal.data && ntlmssp_state->internal_chal.length == 8);
666 memcpy(session_nonce, ntlmssp_state->internal_chal.data, 8);
667 memcpy(&session_nonce[8], ntlmssp_state->lm_resp.data, 8);
669 MD5Init(&md5_session_nonce_ctx);
670 MD5Update(&md5_session_nonce_ctx, session_nonce, 16);
671 MD5Final(session_nonce_hash, &md5_session_nonce_ctx);
673 ntlmssp_state->chal = data_blob_talloc(
674 ntlmssp_state, session_nonce_hash, 8);
676 /* LM response is no longer useful */
677 data_blob_free(&ntlmssp_state->lm_resp);
679 /* We changed the effective challenge - set it */
680 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_state->set_challenge(ntlmssp_state, &ntlmssp_state->chal))) {
681 data_blob_free(&encrypted_session_key);
685 /* LM Key is incompatible. */
686 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
691 * Note we don't check here for NTLMv2 auth settings. If NTLMv2 auth
692 * is required (by "ntlm auth = no" and "lm auth = no" being set in the
693 * smb.conf file) and no NTLMv2 response was sent then the password check
694 * will fail here. JRA.
697 /* Finally, actually ask if the password is OK */
699 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_state->check_password(ntlmssp_state,
700 &user_session_key, &lm_session_key))) {
701 data_blob_free(&encrypted_session_key);
705 dump_data_pw("NT session key:\n", user_session_key.data, user_session_key.length);
706 dump_data_pw("LM first-8:\n", lm_session_key.data, lm_session_key.length);
708 /* Handle the different session key derivation for NTLM2 */
710 if (user_session_key.data && user_session_key.length == 16) {
711 session_key = data_blob_talloc(ntlmssp_state,
713 hmac_md5(user_session_key.data, session_nonce,
714 sizeof(session_nonce), session_key.data);
715 DEBUG(10,("ntlmssp_server_auth: Created NTLM2 session key.\n"));
716 dump_data_pw("NTLM2 session key:\n", session_key.data, session_key.length);
719 DEBUG(10,("ntlmssp_server_auth: Failed to create NTLM2 session key.\n"));
720 session_key = data_blob_null;
722 } else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) {
723 if (lm_session_key.data && lm_session_key.length >= 8) {
724 if (ntlmssp_state->lm_resp.data && ntlmssp_state->lm_resp.length == 24) {
725 session_key = data_blob_talloc(ntlmssp_state,
727 if (session_key.data == NULL) {
728 return NT_STATUS_NO_MEMORY;
730 SMBsesskeygen_lm_sess_key(lm_session_key.data, ntlmssp_state->lm_resp.data,
732 DEBUG(10,("ntlmssp_server_auth: Created NTLM session key.\n"));
734 static const uint8_t zeros[24] = {0, };
735 session_key = data_blob_talloc(
736 ntlmssp_state, NULL, 16);
737 if (session_key.data == NULL) {
738 return NT_STATUS_NO_MEMORY;
740 SMBsesskeygen_lm_sess_key(
741 lm_session_key.data, zeros,
744 dump_data_pw("LM session key:\n", session_key.data,
747 DEBUG(10,("ntlmssp_server_auth: Failed to create NTLM session key.\n"));
748 session_key = data_blob_null;
750 } else if (user_session_key.data) {
751 session_key = user_session_key;
752 DEBUG(10,("ntlmssp_server_auth: Using unmodified nt session key.\n"));
753 dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
754 } else if (lm_session_key.data) {
755 session_key = lm_session_key;
756 DEBUG(10,("ntlmssp_server_auth: Using unmodified lm session key.\n"));
757 dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
759 DEBUG(10,("ntlmssp_server_auth: Failed to create unmodified session key.\n"));
760 session_key = data_blob_null;
763 /* With KEY_EXCH, the client supplies the proposed session key,
764 but encrypts it with the long-term key */
765 if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
766 if (!encrypted_session_key.data || encrypted_session_key.length != 16) {
767 data_blob_free(&encrypted_session_key);
768 DEBUG(1, ("Client-supplied KEY_EXCH session key was of invalid length (%u)!\n",
769 (unsigned int)encrypted_session_key.length));
770 return NT_STATUS_INVALID_PARAMETER;
771 } else if (!session_key.data || session_key.length != 16) {
772 DEBUG(5, ("server session key is invalid (len == %u), cannot do KEY_EXCH!\n",
773 (unsigned int)session_key.length));
774 ntlmssp_state->session_key = session_key;
776 dump_data_pw("KEY_EXCH session key (enc):\n", encrypted_session_key.data, encrypted_session_key.length);
777 arcfour_crypt_blob(encrypted_session_key.data,
778 encrypted_session_key.length,
780 ntlmssp_state->session_key = data_blob_talloc(
781 ntlmssp_state, encrypted_session_key.data,
782 encrypted_session_key.length);
783 dump_data_pw("KEY_EXCH session key:\n", encrypted_session_key.data,
784 encrypted_session_key.length);
787 ntlmssp_state->session_key = session_key;
790 if (!NT_STATUS_IS_OK(nt_status)) {
791 ntlmssp_state->session_key = data_blob_null;
792 } else if (ntlmssp_state->session_key.length) {
793 nt_status = ntlmssp_sign_init(ntlmssp_state);
796 data_blob_free(&encrypted_session_key);
798 /* Only one authentication allowed per server state. */
799 ntlmssp_state->expected_state = NTLMSSP_DONE;
805 * Create an NTLMSSP state machine
807 * @param ntlmssp_state NTLMSSP State, allocated by this function
810 NTSTATUS ntlmssp_server_start(TALLOC_CTX *mem_ctx,
812 const char *netbios_name,
813 const char *netbios_domain,
814 const char *dns_name,
815 const char *dns_domain,
816 struct ntlmssp_state **_ntlmssp_state)
818 struct ntlmssp_state *ntlmssp_state;
824 if (!netbios_domain) {
836 ntlmssp_state = talloc_zero(mem_ctx, struct ntlmssp_state);
837 if (!ntlmssp_state) {
838 return NT_STATUS_NO_MEMORY;
841 ntlmssp_state->role = NTLMSSP_SERVER;
843 ntlmssp_state->get_challenge = get_challenge;
844 ntlmssp_state->set_challenge = set_challenge;
845 ntlmssp_state->may_set_challenge = may_set_challenge;
847 ntlmssp_state->server.is_standalone = is_standalone;
849 ntlmssp_state->expected_state = NTLMSSP_NEGOTIATE;
851 ntlmssp_state->neg_flags =
852 NTLMSSP_NEGOTIATE_128 |
853 NTLMSSP_NEGOTIATE_56 |
854 NTLMSSP_NEGOTIATE_VERSION |
855 NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
856 NTLMSSP_NEGOTIATE_NTLM |
857 NTLMSSP_NEGOTIATE_NTLM2 |
858 NTLMSSP_NEGOTIATE_KEY_EXCH |
859 NTLMSSP_NEGOTIATE_SIGN |
860 NTLMSSP_NEGOTIATE_SEAL;
862 ntlmssp_state->server.netbios_name = talloc_strdup(ntlmssp_state, netbios_name);
863 if (!ntlmssp_state->server.netbios_name) {
864 talloc_free(ntlmssp_state);
865 return NT_STATUS_NO_MEMORY;
867 ntlmssp_state->server.netbios_domain = talloc_strdup(ntlmssp_state, netbios_domain);
868 if (!ntlmssp_state->server.netbios_domain) {
869 talloc_free(ntlmssp_state);
870 return NT_STATUS_NO_MEMORY;
872 ntlmssp_state->server.dns_name = talloc_strdup(ntlmssp_state, dns_name);
873 if (!ntlmssp_state->server.dns_name) {
874 talloc_free(ntlmssp_state);
875 return NT_STATUS_NO_MEMORY;
877 ntlmssp_state->server.dns_domain = talloc_strdup(ntlmssp_state, dns_domain);
878 if (!ntlmssp_state->server.dns_domain) {
879 talloc_free(ntlmssp_state);
880 return NT_STATUS_NO_MEMORY;
883 *_ntlmssp_state = ntlmssp_state;
887 /*********************************************************************
889 *********************************************************************/
892 * Next state function for the Initial packet
894 * @param ntlmssp_state NTLMSSP State
895 * @param request The request, as a DATA_BLOB. reply.data must be NULL
896 * @param request The reply, as an allocated DATA_BLOB, caller to free.
897 * @return Errors or NT_STATUS_OK.
900 static NTSTATUS ntlmssp_client_initial(struct ntlmssp_state *ntlmssp_state,
901 DATA_BLOB reply, DATA_BLOB *next_request)
903 struct NEGOTIATE_MESSAGE negotiate;
905 if (ntlmssp_state->unicode) {
906 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_UNICODE;
908 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_OEM;
911 if (ntlmssp_state->use_ntlmv2) {
912 ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_NTLM2;
915 /* generate the ntlmssp negotiate packet */
916 msrpc_gen(ntlmssp_state, next_request, "CddAA",
919 ntlmssp_state->neg_flags,
920 ntlmssp_state->client.netbios_domain,
921 ntlmssp_state->client.netbios_name);
923 if (DEBUGLEVEL >= 10) {
924 if (NT_STATUS_IS_OK(ntlmssp_pull_NEGOTIATE_MESSAGE(next_request,
928 NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE, &negotiate);
932 ntlmssp_state->expected_state = NTLMSSP_CHALLENGE;
934 return NT_STATUS_MORE_PROCESSING_REQUIRED;
938 * Next state function for the Challenge Packet. Generate an auth packet.
940 * @param ntlmssp_state NTLMSSP State
941 * @param request The request, as a DATA_BLOB. reply.data must be NULL
942 * @param request The reply, as an allocated DATA_BLOB, caller to free.
943 * @return Errors or NT_STATUS_OK.
946 static NTSTATUS ntlmssp_client_challenge(struct ntlmssp_state *ntlmssp_state,
947 const DATA_BLOB reply, DATA_BLOB *next_request)
949 uint32_t chal_flags, ntlmssp_command, unkn1, unkn2;
950 DATA_BLOB server_domain_blob;
951 DATA_BLOB challenge_blob;
952 DATA_BLOB struct_blob = data_blob_null;
954 const char *chal_parse_string;
955 const char *auth_gen_string;
956 DATA_BLOB lm_response = data_blob_null;
957 DATA_BLOB nt_response = data_blob_null;
958 DATA_BLOB session_key = data_blob_null;
959 DATA_BLOB encrypted_session_key = data_blob_null;
960 NTSTATUS nt_status = NT_STATUS_OK;
961 struct CHALLENGE_MESSAGE challenge;
962 struct AUTHENTICATE_MESSAGE authenticate;
964 if (ntlmssp_state->use_ccache) {
965 struct wbcCredentialCacheParams params;
966 struct wbcCredentialCacheInfo *info = NULL;
967 struct wbcAuthErrorInfo *error = NULL;
968 struct wbcNamedBlob auth_blob;
969 struct wbcBlob *wbc_next = NULL;
970 struct wbcBlob *wbc_session_key = NULL;
974 params.account_name = ntlmssp_state->user;
975 params.domain_name = ntlmssp_state->domain;
976 params.level = WBC_CREDENTIAL_CACHE_LEVEL_NTLMSSP;
978 auth_blob.name = "challenge_blob";
980 auth_blob.blob.data = reply.data;
981 auth_blob.blob.length = reply.length;
982 params.num_blobs = 1;
983 params.blobs = &auth_blob;
985 wbc_status = wbcCredentialCache(¶ms, &info, &error);
987 wbcFreeMemory(error);
989 if (!WBC_ERROR_IS_OK(wbc_status)) {
993 for (i=0; i<info->num_blobs; i++) {
994 if (strequal(info->blobs[i].name, "auth_blob")) {
995 wbc_next = &info->blobs[i].blob;
997 if (strequal(info->blobs[i].name, "session_key")) {
998 wbc_session_key = &info->blobs[i].blob;
1001 if ((wbc_next == NULL) || (wbc_session_key == NULL)) {
1002 wbcFreeMemory(info);
1006 *next_request = data_blob(wbc_next->data, wbc_next->length);
1007 ntlmssp_state->session_key = data_blob(
1008 wbc_session_key->data, wbc_session_key->length);
1010 wbcFreeMemory(info);
1016 if (!msrpc_parse(ntlmssp_state, &reply, "CdBd",
1019 &server_domain_blob,
1021 DEBUG(1, ("Failed to parse the NTLMSSP Challenge: (#1)\n"));
1022 dump_data(2, reply.data, reply.length);
1024 return NT_STATUS_INVALID_PARAMETER;
1027 if (DEBUGLEVEL >= 10) {
1028 if (NT_STATUS_IS_OK(ntlmssp_pull_CHALLENGE_MESSAGE(&reply,
1032 NDR_PRINT_DEBUG(CHALLENGE_MESSAGE, &challenge);
1036 data_blob_free(&server_domain_blob);
1038 DEBUG(3, ("Got challenge flags:\n"));
1039 debug_ntlmssp_flags(chal_flags);
1041 ntlmssp_handle_neg_flags(ntlmssp_state, chal_flags, lp_client_lanman_auth());
1043 if (ntlmssp_state->unicode) {
1044 if (chal_flags & NTLMSSP_NEGOTIATE_TARGET_INFO) {
1045 chal_parse_string = "CdUdbddB";
1047 chal_parse_string = "CdUdbdd";
1049 auth_gen_string = "CdBBUUUBd";
1051 if (chal_flags & NTLMSSP_NEGOTIATE_TARGET_INFO) {
1052 chal_parse_string = "CdAdbddB";
1054 chal_parse_string = "CdAdbdd";
1057 auth_gen_string = "CdBBAAABd";
1060 DEBUG(3, ("NTLMSSP: Set final flags:\n"));
1061 debug_ntlmssp_flags(ntlmssp_state->neg_flags);
1063 if (!msrpc_parse(ntlmssp_state, &reply, chal_parse_string,
1071 DEBUG(1, ("Failed to parse the NTLMSSP Challenge: (#2)\n"));
1072 dump_data(2, reply.data, reply.length);
1073 return NT_STATUS_INVALID_PARAMETER;
1076 if (chal_flags & NTLMSSP_TARGET_TYPE_SERVER) {
1077 ntlmssp_state->server.is_standalone = true;
1079 ntlmssp_state->server.is_standalone = false;
1081 /* TODO: parse struct_blob and fill in the rest */
1082 ntlmssp_state->server.netbios_name = "";
1083 ntlmssp_state->server.netbios_domain = server_domain;
1084 ntlmssp_state->server.dns_name = "";
1085 ntlmssp_state->server.dns_domain = "";
1087 if (challenge_blob.length != 8) {
1088 data_blob_free(&struct_blob);
1089 return NT_STATUS_INVALID_PARAMETER;
1092 if (!ntlmssp_state->nt_hash || !ntlmssp_state->lm_hash) {
1093 static const uint8_t zeros[16] = {0, };
1094 /* do nothing - blobs are zero length */
1096 /* session key is all zeros */
1097 session_key = data_blob_talloc(ntlmssp_state, zeros, 16);
1099 /* not doing NLTM2 without a password */
1100 ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
1101 } else if (ntlmssp_state->use_ntlmv2) {
1102 if (!struct_blob.length) {
1103 /* be lazy, match win2k - we can't do NTLMv2 without it */
1104 DEBUG(1, ("Server did not provide 'target information', required for NTLMv2\n"));
1105 return NT_STATUS_INVALID_PARAMETER;
1108 /* TODO: if the remote server is standalone, then we should replace 'domain'
1109 with the server name as supplied above */
1111 if (!SMBNTLMv2encrypt_hash(ntlmssp_state,
1112 ntlmssp_state->user,
1113 ntlmssp_state->domain,
1114 ntlmssp_state->nt_hash, &challenge_blob,
1116 &lm_response, &nt_response, NULL,
1118 data_blob_free(&challenge_blob);
1119 data_blob_free(&struct_blob);
1120 return NT_STATUS_NO_MEMORY;
1122 } else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
1123 struct MD5Context md5_session_nonce_ctx;
1124 uint8_t session_nonce[16];
1125 uint8_t session_nonce_hash[16];
1126 uint8_t user_session_key[16];
1128 lm_response = data_blob_talloc(ntlmssp_state, NULL, 24);
1129 generate_random_buffer(lm_response.data, 8);
1130 memset(lm_response.data+8, 0, 16);
1132 memcpy(session_nonce, challenge_blob.data, 8);
1133 memcpy(&session_nonce[8], lm_response.data, 8);
1135 MD5Init(&md5_session_nonce_ctx);
1136 MD5Update(&md5_session_nonce_ctx, challenge_blob.data, 8);
1137 MD5Update(&md5_session_nonce_ctx, lm_response.data, 8);
1138 MD5Final(session_nonce_hash, &md5_session_nonce_ctx);
1140 DEBUG(5, ("NTLMSSP challenge set by NTLM2\n"));
1141 DEBUG(5, ("challenge is: \n"));
1142 dump_data(5, session_nonce_hash, 8);
1144 nt_response = data_blob_talloc(ntlmssp_state, NULL, 24);
1145 SMBNTencrypt_hash(ntlmssp_state->nt_hash,
1149 session_key = data_blob_talloc(ntlmssp_state, NULL, 16);
1151 SMBsesskeygen_ntv1(ntlmssp_state->nt_hash, user_session_key);
1152 hmac_md5(user_session_key, session_nonce, sizeof(session_nonce), session_key.data);
1153 dump_data_pw("NTLM2 session key:\n", session_key.data, session_key.length);
1155 /* lanman auth is insecure, it may be disabled */
1156 if (lp_client_lanman_auth()) {
1157 lm_response = data_blob_talloc(ntlmssp_state,
1159 SMBencrypt_hash(ntlmssp_state->lm_hash,challenge_blob.data,
1163 nt_response = data_blob_talloc(ntlmssp_state, NULL, 24);
1164 SMBNTencrypt_hash(ntlmssp_state->nt_hash,challenge_blob.data,
1167 session_key = data_blob_talloc(ntlmssp_state, NULL, 16);
1168 if ((ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
1169 && lp_client_lanman_auth()) {
1170 SMBsesskeygen_lm_sess_key(ntlmssp_state->lm_hash, lm_response.data,
1172 dump_data_pw("LM session key\n", session_key.data, session_key.length);
1174 SMBsesskeygen_ntv1(ntlmssp_state->nt_hash, session_key.data);
1175 dump_data_pw("NT session key:\n", session_key.data, session_key.length);
1178 data_blob_free(&struct_blob);
1180 /* Key exchange encryptes a new client-generated session key with
1181 the password-derived key */
1182 if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
1183 /* Make up a new session key */
1184 uint8_t client_session_key[16];
1185 generate_random_buffer(client_session_key, sizeof(client_session_key));
1187 /* Encrypt the new session key with the old one */
1188 encrypted_session_key = data_blob(client_session_key, sizeof(client_session_key));
1189 dump_data_pw("KEY_EXCH session key:\n", encrypted_session_key.data, encrypted_session_key.length);
1190 arcfour_crypt_blob(encrypted_session_key.data, encrypted_session_key.length, &session_key);
1191 dump_data_pw("KEY_EXCH session key (enc):\n", encrypted_session_key.data, encrypted_session_key.length);
1193 /* Mark the new session key as the 'real' session key */
1194 data_blob_free(&session_key);
1195 session_key = data_blob_talloc(ntlmssp_state,
1197 sizeof(client_session_key));
1200 /* this generates the actual auth packet */
1201 if (!msrpc_gen(ntlmssp_state, next_request, auth_gen_string,
1204 lm_response.data, lm_response.length,
1205 nt_response.data, nt_response.length,
1206 ntlmssp_state->domain,
1207 ntlmssp_state->user,
1208 ntlmssp_state->client.netbios_name,
1209 encrypted_session_key.data, encrypted_session_key.length,
1210 ntlmssp_state->neg_flags)) {
1212 return NT_STATUS_NO_MEMORY;
1215 if (DEBUGLEVEL >= 10) {
1216 if (NT_STATUS_IS_OK(ntlmssp_pull_AUTHENTICATE_MESSAGE(next_request,
1220 NDR_PRINT_DEBUG(AUTHENTICATE_MESSAGE, &authenticate);
1224 data_blob_free(&encrypted_session_key);
1226 data_blob_free(&ntlmssp_state->chal);
1228 ntlmssp_state->session_key = session_key;
1230 ntlmssp_state->chal = challenge_blob;
1231 ntlmssp_state->lm_resp = lm_response;
1232 ntlmssp_state->nt_resp = nt_response;
1236 ntlmssp_state->expected_state = NTLMSSP_DONE;
1238 if (!NT_STATUS_IS_OK(nt_status = ntlmssp_sign_init(ntlmssp_state))) {
1239 DEBUG(1, ("Could not setup NTLMSSP signing/sealing system (error was: %s)\n", nt_errstr(nt_status)));
1245 NTSTATUS ntlmssp_client_start(TALLOC_CTX *mem_ctx,
1246 const char *netbios_name,
1247 const char *netbios_domain,
1249 struct ntlmssp_state **_ntlmssp_state)
1251 struct ntlmssp_state *ntlmssp_state;
1253 if (!netbios_name) {
1257 if (!netbios_domain) {
1258 netbios_domain = "";
1261 ntlmssp_state = talloc_zero(mem_ctx, struct ntlmssp_state);
1262 if (!ntlmssp_state) {
1263 return NT_STATUS_NO_MEMORY;
1266 ntlmssp_state->role = NTLMSSP_CLIENT;
1268 ntlmssp_state->unicode = True;
1270 ntlmssp_state->use_ntlmv2 = use_ntlmv2;
1272 ntlmssp_state->expected_state = NTLMSSP_INITIAL;
1274 ntlmssp_state->neg_flags =
1275 NTLMSSP_NEGOTIATE_128 |
1276 NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
1277 NTLMSSP_NEGOTIATE_NTLM |
1278 NTLMSSP_NEGOTIATE_NTLM2 |
1279 NTLMSSP_NEGOTIATE_KEY_EXCH |
1280 NTLMSSP_REQUEST_TARGET;
1282 ntlmssp_state->client.netbios_name = talloc_strdup(ntlmssp_state, netbios_name);
1283 if (!ntlmssp_state->client.netbios_name) {
1284 talloc_free(ntlmssp_state);
1285 return NT_STATUS_NO_MEMORY;
1287 ntlmssp_state->client.netbios_domain = talloc_strdup(ntlmssp_state, netbios_domain);
1288 if (!ntlmssp_state->client.netbios_domain) {
1289 talloc_free(ntlmssp_state);
1290 return NT_STATUS_NO_MEMORY;
1293 *_ntlmssp_state = ntlmssp_state;
1294 return NT_STATUS_OK;