2 Unix SMB/CIFS implementation.
3 Password and authentication handling
4 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2001-2004
5 Copyright (C) Gerald Carter 2003
6 Copyright (C) Luke Kenneth Casson Leighton 1996-2000
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "../lib/crypto/crypto.h"
24 #include "librpc/gen_ndr/netlogon.h"
25 #include "libcli/auth/libcli_auth.h"
27 /****************************************************************************
28 Core of smb password checking routine.
29 ****************************************************************************/
31 static bool smb_pwd_check_ntlmv1(TALLOC_CTX
*mem_ctx
,
32 const DATA_BLOB
*nt_response
,
33 const uint8_t *part_passwd
,
34 const DATA_BLOB
*sec_blob
,
35 DATA_BLOB
*user_sess_key
)
37 /* Finish the encryption of part_passwd. */
40 if (part_passwd
== NULL
) {
41 DEBUG(10,("No password set - DISALLOWING access\n"));
42 /* No password set - always false ! */
46 if (sec_blob
->length
!= 8) {
47 DEBUG(0, ("smb_pwd_check_ntlmv1: incorrect challenge size (%lu)\n",
48 (unsigned long)sec_blob
->length
));
52 if (nt_response
->length
!= 24) {
53 DEBUG(0, ("smb_pwd_check_ntlmv1: incorrect password length (%lu)\n",
54 (unsigned long)nt_response
->length
));
58 SMBOWFencrypt(part_passwd
, sec_blob
->data
, p24
);
61 DEBUG(100,("Part password (P16) was |\n"));
62 dump_data(100, part_passwd
, 16);
63 DEBUGADD(100,("Password from client was |\n"));
64 dump_data(100, nt_response
->data
, nt_response
->length
);
65 DEBUGADD(100,("Given challenge was |\n"));
66 dump_data(100, sec_blob
->data
, sec_blob
->length
);
67 DEBUGADD(100,("Value from encryption was |\n"));
68 dump_data(100, p24
, 24);
70 if (memcmp(p24
, nt_response
->data
, 24) == 0) {
71 if (user_sess_key
!= NULL
) {
72 *user_sess_key
= data_blob_talloc(mem_ctx
, NULL
, 16);
73 SMBsesskeygen_ntv1(part_passwd
, user_sess_key
->data
);
80 /****************************************************************************
81 Core of smb password checking routine. (NTLMv2, LMv2)
82 Note: The same code works with both NTLMv2 and LMv2.
83 ****************************************************************************/
85 static bool smb_pwd_check_ntlmv2(TALLOC_CTX
*mem_ctx
,
86 const DATA_BLOB
*ntv2_response
,
87 const uint8_t *part_passwd
,
88 const DATA_BLOB
*sec_blob
,
89 const char *user
, const char *domain
,
90 DATA_BLOB
*user_sess_key
)
92 /* Finish the encryption of part_passwd. */
94 uint8_t value_from_encryption
[16];
95 DATA_BLOB client_key_data
;
97 if (part_passwd
== NULL
) {
98 DEBUG(10,("No password set - DISALLOWING access\n"));
99 /* No password set - always false */
103 if (sec_blob
->length
!= 8) {
104 DEBUG(0, ("smb_pwd_check_ntlmv2: incorrect challenge size (%lu)\n",
105 (unsigned long)sec_blob
->length
));
109 if (ntv2_response
->length
< 24) {
110 /* We MUST have more than 16 bytes, or the stuff below will go
111 crazy. No known implementation sends less than the 24 bytes
112 for LMv2, let alone NTLMv2. */
113 DEBUG(0, ("smb_pwd_check_ntlmv2: incorrect password length (%lu)\n",
114 (unsigned long)ntv2_response
->length
));
118 client_key_data
= data_blob_talloc(mem_ctx
, ntv2_response
->data
+16, ntv2_response
->length
-16);
120 todo: should we be checking this for anything? We can't for LMv2,
121 but for NTLMv2 it is meant to contain the current time etc.
124 if (!ntv2_owf_gen(part_passwd
, user
, domain
, kr
)) {
128 SMBOWFencrypt_ntv2(kr
, sec_blob
, &client_key_data
, value_from_encryption
);
131 DEBUG(100,("Part password (P16) was |\n"));
132 dump_data(100, part_passwd
, 16);
133 DEBUGADD(100,("Password from client was |\n"));
134 dump_data(100, ntv2_response
->data
, ntv2_response
->length
);
135 DEBUGADD(100,("Variable data from client was |\n"));
136 dump_data(100, client_key_data
.data
, client_key_data
.length
);
137 DEBUGADD(100,("Given challenge was |\n"));
138 dump_data(100, sec_blob
->data
, sec_blob
->length
);
139 DEBUGADD(100,("Value from encryption was |\n"));
140 dump_data(100, value_from_encryption
, 16);
142 data_blob_clear_free(&client_key_data
);
143 if (memcmp(value_from_encryption
, ntv2_response
->data
, 16) == 0) {
144 if (user_sess_key
!= NULL
) {
145 *user_sess_key
= data_blob_talloc(mem_ctx
, NULL
, 16);
146 SMBsesskeygen_ntv2(kr
, value_from_encryption
, user_sess_key
->data
);
153 /****************************************************************************
154 Core of smb password checking routine. (NTLMv2, LMv2)
155 Note: The same code works with both NTLMv2 and LMv2.
156 ****************************************************************************/
158 static bool smb_sess_key_ntlmv2(TALLOC_CTX
*mem_ctx
,
159 const DATA_BLOB
*ntv2_response
,
160 const uint8_t *part_passwd
,
161 const DATA_BLOB
*sec_blob
,
162 const char *user
, const char *domain
,
163 DATA_BLOB
*user_sess_key
)
165 /* Finish the encryption of part_passwd. */
167 uint8_t value_from_encryption
[16];
168 DATA_BLOB client_key_data
;
170 if (part_passwd
== NULL
) {
171 DEBUG(10,("No password set - DISALLOWING access\n"));
172 /* No password set - always false */
176 if (sec_blob
->length
!= 8) {
177 DEBUG(0, ("smb_sess_key_ntlmv2: incorrect challenge size (%lu)\n",
178 (unsigned long)sec_blob
->length
));
182 if (ntv2_response
->length
< 24) {
183 /* We MUST have more than 16 bytes, or the stuff below will go
184 crazy. No known implementation sends less than the 24 bytes
185 for LMv2, let alone NTLMv2. */
186 DEBUG(0, ("smb_sess_key_ntlmv2: incorrect password length (%lu)\n",
187 (unsigned long)ntv2_response
->length
));
191 client_key_data
= data_blob_talloc(mem_ctx
, ntv2_response
->data
+16, ntv2_response
->length
-16);
193 if (!ntv2_owf_gen(part_passwd
, user
, domain
, kr
)) {
197 SMBOWFencrypt_ntv2(kr
, sec_blob
, &client_key_data
, value_from_encryption
);
198 *user_sess_key
= data_blob_talloc(mem_ctx
, NULL
, 16);
199 SMBsesskeygen_ntv2(kr
, value_from_encryption
, user_sess_key
->data
);
204 * Compare password hashes against those from the SAM
206 * @param mem_ctx talloc context
207 * @param client_lanman LANMAN password hash, as supplied by the client
208 * @param client_nt NT (MD4) password hash, as supplied by the client
209 * @param username internal Samba username, for log messages
210 * @param client_username username the client used
211 * @param client_domain domain name the client used (may be mapped)
212 * @param stored_lanman LANMAN password hash, as stored on the SAM
213 * @param stored_nt NT (MD4) password hash, as stored on the SAM
214 * @param user_sess_key User session key
215 * @param lm_sess_key LM session key (first 8 bytes of the LM hash)
218 NTSTATUS
hash_password_check(TALLOC_CTX
*mem_ctx
,
220 const struct samr_Password
*client_lanman
,
221 const struct samr_Password
*client_nt
,
222 const char *username
,
223 const struct samr_Password
*stored_lanman
,
224 const struct samr_Password
*stored_nt
)
226 if (stored_nt
== NULL
) {
227 DEBUG(3,("ntlm_password_check: NO NT password stored for user %s.\n",
231 if (client_nt
&& stored_nt
) {
232 if (memcmp(client_nt
->hash
, stored_nt
->hash
, sizeof(stored_nt
->hash
)) == 0) {
235 DEBUG(3,("ntlm_password_check: Interactive logon: NT password check failed for user %s\n",
237 return NT_STATUS_WRONG_PASSWORD
;
240 } else if (client_lanman
&& stored_lanman
) {
242 DEBUG(3,("ntlm_password_check: Interactive logon: only LANMAN password supplied for user %s, and LM passwords are disabled!\n",
244 return NT_STATUS_WRONG_PASSWORD
;
246 if (strchr_m(username
, '@')) {
247 return NT_STATUS_NOT_FOUND
;
250 if (memcmp(client_lanman
->hash
, stored_lanman
->hash
, sizeof(stored_lanman
->hash
)) == 0) {
253 DEBUG(3,("ntlm_password_check: Interactive logon: LANMAN password check failed for user %s\n",
255 return NT_STATUS_WRONG_PASSWORD
;
258 if (strchr_m(username
, '@')) {
259 return NT_STATUS_NOT_FOUND
;
261 return NT_STATUS_WRONG_PASSWORD
;
265 * Check a challenge-response password against the value of the NT or
268 * @param mem_ctx talloc context
269 * @param challenge 8-byte challenge. If all zero, forces plaintext comparison
270 * @param nt_response 'unicode' NT response to the challenge, or unicode password
271 * @param lm_response ASCII or LANMAN response to the challenge, or password in DOS code page
272 * @param username internal Samba username, for log messages
273 * @param client_username username the client used
274 * @param client_domain domain name the client used (may be mapped)
275 * @param stored_lanman LANMAN ASCII password from our passdb or similar
276 * @param stored_nt MD4 unicode password from our passdb or similar
277 * @param user_sess_key User session key
278 * @param lm_sess_key LM session key (first 8 bytes of the LM hash)
281 NTSTATUS
ntlm_password_check(TALLOC_CTX
*mem_ctx
,
284 uint32_t logon_parameters
,
285 const DATA_BLOB
*challenge
,
286 const DATA_BLOB
*lm_response
,
287 const DATA_BLOB
*nt_response
,
288 const char *username
,
289 const char *client_username
,
290 const char *client_domain
,
291 const struct samr_Password
*stored_lanman
,
292 const struct samr_Password
*stored_nt
,
293 DATA_BLOB
*user_sess_key
,
294 DATA_BLOB
*lm_sess_key
)
296 const static uint8_t zeros
[8];
297 DATA_BLOB tmp_sess_key
;
298 const char *upper_client_domain
= NULL
;
300 if (client_domain
!= NULL
) {
301 upper_client_domain
= talloc_strdup_upper(mem_ctx
, client_domain
);
302 if (upper_client_domain
== NULL
) {
303 return NT_STATUS_NO_MEMORY
;
307 if (stored_nt
== NULL
) {
308 DEBUG(3,("ntlm_password_check: NO NT password stored for user %s.\n",
312 *lm_sess_key
= data_blob(NULL
, 0);
313 *user_sess_key
= data_blob(NULL
, 0);
315 /* Check for cleartext netlogon. Used by Exchange 5.5. */
316 if ((logon_parameters
& MSV1_0_CLEARTEXT_PASSWORD_ALLOWED
)
317 && challenge
->length
== sizeof(zeros
)
318 && (memcmp(challenge
->data
, zeros
, challenge
->length
) == 0 )) {
319 struct samr_Password client_nt
;
320 struct samr_Password client_lm
;
321 char *unix_pw
= NULL
;
324 DEBUG(4,("ntlm_password_check: checking plaintext passwords for user %s\n",
326 mdfour(client_nt
.hash
, nt_response
->data
, nt_response
->length
);
328 if (lm_response
->length
&&
329 (convert_string_talloc(mem_ctx
, CH_DOS
, CH_UNIX
,
330 lm_response
->data
, lm_response
->length
,
331 (void *)&unix_pw
, NULL
, false))) {
332 if (E_deshash(unix_pw
, client_lm
.hash
)) {
340 return hash_password_check(mem_ctx
,
342 lm_ok
? &client_lm
: NULL
,
343 nt_response
->length
? &client_nt
: NULL
,
345 stored_lanman
, stored_nt
);
348 if (nt_response
->length
!= 0 && nt_response
->length
< 24) {
349 DEBUG(2,("ntlm_password_check: invalid NT password length (%lu) for user %s\n",
350 (unsigned long)nt_response
->length
, username
));
353 if (nt_response
->length
> 24 && stored_nt
) {
354 /* We have the NT MD4 hash challenge available - see if we can
357 DEBUG(4,("ntlm_password_check: Checking NTLMv2 password with domain [%s]\n",
358 client_domain
? client_domain
: "<NULL>"));
359 if (smb_pwd_check_ntlmv2(mem_ctx
,
361 stored_nt
->hash
, challenge
,
365 if (user_sess_key
->length
) {
366 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
371 DEBUG(4,("ntlm_password_check: Checking NTLMv2 password with uppercased version of domain [%s]\n",
372 upper_client_domain
? upper_client_domain
: "<NULL>"));
373 if (smb_pwd_check_ntlmv2(mem_ctx
,
375 stored_nt
->hash
, challenge
,
379 if (user_sess_key
->length
) {
380 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
385 DEBUG(4,("ntlm_password_check: Checking NTLMv2 password without a domain\n"));
386 if (smb_pwd_check_ntlmv2(mem_ctx
,
388 stored_nt
->hash
, challenge
,
392 if (user_sess_key
->length
) {
393 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
397 DEBUG(3,("ntlm_password_check: NTLMv2 password check failed\n"));
399 } else if (nt_response
->length
== 24 && stored_nt
) {
401 /* We have the NT MD4 hash challenge available - see if we can
402 use it (ie. does it exist in the smbpasswd file).
404 DEBUG(4,("ntlm_password_check: Checking NT MD4 password\n"));
405 if (smb_pwd_check_ntlmv1(mem_ctx
,
407 stored_nt
->hash
, challenge
,
409 /* The LM session key for this response is not very secure,
410 so use it only if we otherwise allow LM authentication */
412 if (lanman_auth
&& stored_lanman
) {
413 *lm_sess_key
= data_blob_talloc(mem_ctx
, stored_lanman
->hash
, MIN(8, user_sess_key
->length
));
417 DEBUG(3,("ntlm_password_check: NT MD4 password check failed for user %s\n",
419 return NT_STATUS_WRONG_PASSWORD
;
422 DEBUG(2,("ntlm_password_check: NTLMv1 passwords NOT PERMITTED for user %s\n",
424 /* no return, because we might pick up LMv2 in the LM field */
428 if (lm_response
->length
== 0) {
429 DEBUG(3,("ntlm_password_check: NEITHER LanMan nor NT password supplied for user %s\n",
431 return NT_STATUS_WRONG_PASSWORD
;
434 if (lm_response
->length
< 24) {
435 DEBUG(2,("ntlm_password_check: invalid LanMan password length (%lu) for user %s\n",
436 (unsigned long)nt_response
->length
, username
));
437 return NT_STATUS_WRONG_PASSWORD
;
441 DEBUG(3,("ntlm_password_check: Lanman passwords NOT PERMITTED for user %s\n",
443 } else if (!stored_lanman
) {
444 DEBUG(3,("ntlm_password_check: NO LanMan password set for user %s (and no NT password supplied)\n",
446 } else if (strchr_m(username
, '@')) {
447 DEBUG(3,("ntlm_password_check: NO LanMan password allowed for username@realm logins (user: %s)\n",
450 DEBUG(4,("ntlm_password_check: Checking LM password\n"));
451 if (smb_pwd_check_ntlmv1(mem_ctx
,
453 stored_lanman
->hash
, challenge
,
455 /* The session key for this response is still very odd.
456 It not very secure, so use it only if we otherwise
457 allow LM authentication */
459 if (lanman_auth
&& stored_lanman
) {
460 uint8_t first_8_lm_hash
[16];
461 memcpy(first_8_lm_hash
, stored_lanman
->hash
, 8);
462 memset(first_8_lm_hash
+ 8, '\0', 8);
463 *user_sess_key
= data_blob_talloc(mem_ctx
, first_8_lm_hash
, 16);
464 *lm_sess_key
= data_blob_talloc(mem_ctx
, stored_lanman
->hash
, 8);
471 DEBUG(4,("ntlm_password_check: LM password check failed for user, no NT password %s\n",username
));
472 return NT_STATUS_WRONG_PASSWORD
;
475 /* This is for 'LMv2' authentication. almost NTLMv2 but limited to 24 bytes.
476 - related to Win9X, legacy NAS pass-though authentication
478 DEBUG(4,("ntlm_password_check: Checking LMv2 password with domain %s\n",
479 client_domain
? client_domain
: "<NULL>"));
480 if (smb_pwd_check_ntlmv2(mem_ctx
,
482 stored_nt
->hash
, challenge
,
486 if (nt_response
->length
> 24) {
487 /* If NTLMv2 authentication has preceeded us
488 * (even if it failed), then use the session
489 * key from that. See the RPC-SAMLOGON
491 smb_sess_key_ntlmv2(mem_ctx
,
493 stored_nt
->hash
, challenge
,
498 /* Otherwise, use the LMv2 session key */
499 *user_sess_key
= tmp_sess_key
;
501 if (user_sess_key
->length
) {
502 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
507 DEBUG(4,("ntlm_password_check: Checking LMv2 password with upper-cased version of domain %s\n",
508 upper_client_domain
? upper_client_domain
: "<NULL>"));
509 if (smb_pwd_check_ntlmv2(mem_ctx
,
511 stored_nt
->hash
, challenge
,
515 if (nt_response
->length
> 24) {
516 /* If NTLMv2 authentication has preceeded us
517 * (even if it failed), then use the session
518 * key from that. See the RPC-SAMLOGON
520 smb_sess_key_ntlmv2(mem_ctx
,
522 stored_nt
->hash
, challenge
,
527 /* Otherwise, use the LMv2 session key */
528 *user_sess_key
= tmp_sess_key
;
530 if (user_sess_key
->length
) {
531 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
536 DEBUG(4,("ntlm_password_check: Checking LMv2 password without a domain\n"));
537 if (smb_pwd_check_ntlmv2(mem_ctx
,
539 stored_nt
->hash
, challenge
,
543 if (nt_response
->length
> 24) {
544 /* If NTLMv2 authentication has preceeded us
545 * (even if it failed), then use the session
546 * key from that. See the RPC-SAMLOGON
548 smb_sess_key_ntlmv2(mem_ctx
,
550 stored_nt
->hash
, challenge
,
555 /* Otherwise, use the LMv2 session key */
556 *user_sess_key
= tmp_sess_key
;
558 if (user_sess_key
->length
) {
559 *lm_sess_key
= data_blob_talloc(mem_ctx
, user_sess_key
->data
, MIN(8, user_sess_key
->length
));
564 /* Apparently NT accepts NT responses in the LM field
565 - I think this is related to Win9X pass-though authentication
567 DEBUG(4,("ntlm_password_check: Checking NT MD4 password in LM field\n"));
569 if (smb_pwd_check_ntlmv1(mem_ctx
,
571 stored_nt
->hash
, challenge
,
573 /* The session key for this response is still very odd.
574 It not very secure, so use it only if we otherwise
575 allow LM authentication */
577 if (lanman_auth
&& stored_lanman
) {
578 uint8_t first_8_lm_hash
[16];
579 memcpy(first_8_lm_hash
, stored_lanman
->hash
, 8);
580 memset(first_8_lm_hash
+ 8, '\0', 8);
581 *user_sess_key
= data_blob_talloc(mem_ctx
, first_8_lm_hash
, 16);
582 *lm_sess_key
= data_blob_talloc(mem_ctx
, stored_lanman
->hash
, 8);
586 DEBUG(3,("ntlm_password_check: LM password, NT MD4 password in LM field and LMv2 failed for user %s\n",username
));
588 DEBUG(3,("ntlm_password_check: LM password and LMv2 failed for user %s, and NT MD4 password in LM field not permitted\n",username
));
591 /* Try and match error codes */
592 if (strchr_m(username
, '@')) {
593 return NT_STATUS_NOT_FOUND
;
595 return NT_STATUS_WRONG_PASSWORD
;