From dce84ffd379012812170f68f7de8aab73123f0b3 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Sun, 9 May 2004 12:42:18 +0000 Subject: r610: - Merge the Samba3 'ntlm_auth --diagnostics' testsuite to Samba4. - This required using NETLOGON_NEG_AUTH2_FLAGS for the SetupCredentials2 negotiation flags, which is what Samba3 does, because otherwise the server uses different crypto. - This tests the returned session keys, which we decrypt. - Update the Samba4 notion of a 'session key' to be a DATA_BLOB in most places. - Fix session key code to return NT_STATUS_NO_SESSION_KEY if none is available. - Remove a useless argument to SMBsesskeygen_ntv1 - move netr_CredentialState from the .idl to the new credentials.h Andrew Bartlett (This used to be commit 44f8b5b53e6abd4de8a676f78d729988fadff320) --- source4/torture/rpc/netlogon.c | 712 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 657 insertions(+), 55 deletions(-) (limited to 'source4/torture/rpc/netlogon.c') diff --git a/source4/torture/rpc/netlogon.c b/source4/torture/rpc/netlogon.c index e06613a3d9..b49ba1ef55 100644 --- a/source4/torture/rpc/netlogon.c +++ b/source4/torture/rpc/netlogon.c @@ -4,6 +4,8 @@ test suite for netlogon rpc operations Copyright (C) Andrew Tridgell 2003 + Copyright (C) Andrew Bartlett 2003-2004 + Copyright (C) Tim Potter 2003 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -25,6 +27,14 @@ #define TEST_MACHINE_NAME "torturetest" +/* for the timebeing, use the same neg flags as Samba3. */ +/* The 7 here seems to be required to get Win2k not to downgrade us + to NT4. Actually, anything other than 1ff would seem to do... */ +#define NETLOGON_NEG_AUTH2_FLAGS 0x000701ff + +#define NETLOGON_NEG_SCHANNEL 0x40000000 + + static struct { struct dcerpc_pipe *p; const char *machine_password; @@ -48,7 +58,7 @@ static BOOL join_domain_bdc(TALLOC_CTX *mem_ctx) uint32 access_granted; uint32 rid; BOOL ret = True; - uint8 session_key[16]; + DATA_BLOB session_key; struct samr_Name name; printf("Connecting to SAMR\n"); @@ -129,14 +139,14 @@ again: encode_pw_buffer(u.info24.password.data, join.machine_password, STR_UNICODE); u.info24.pw_len = strlen(join.machine_password); - status = dcerpc_fetch_session_key(join.p, session_key); + status = dcerpc_fetch_session_key(join.p, &session_key); if (!NT_STATUS_IS_OK(status)) { printf("SetUserInfo level %u - no session key - %s\n", s.in.level, nt_errstr(status)); return False; } - SamOEMhash(u.info24.password.data, session_key, 516); + SamOEMhashBlob(u.info24.password.data, 516, &session_key); status = dcerpc_samr_SetUserInfo(join.p, mem_ctx, &s); if (!NT_STATUS_IS_OK(status)) { @@ -224,7 +234,7 @@ static BOOL test_LogonUasLogoff(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) } static BOOL test_SetupCredentials(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, - struct netr_CredentialState *creds) + struct creds_CredentialState *creds) { NTSTATUS status; struct netr_ServerReqChallenge r; @@ -277,14 +287,14 @@ static BOOL test_SetupCredentials(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, } static BOOL test_SetupCredentials2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, - struct netr_CredentialState *creds) + uint32 negotiate_flags, + struct creds_CredentialState *creds) { NTSTATUS status; struct netr_ServerReqChallenge r; struct netr_ServerAuthenticate2 a; const char *plain_pass; uint8 mach_pwd[16]; - uint32 negotiate_flags = 0; printf("Testing ServerReqChallenge\n"); @@ -334,63 +344,655 @@ static BOOL test_SetupCredentials2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, return True; } -/* - try a netlogon SamLogon -*/ -static BOOL test_SamLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) -{ - NTSTATUS status; +enum ntlm_break { + BREAK_NONE, + BREAK_LM, + BREAK_NT, + NO_LM, + NO_NT +}; + +struct samlogon_state { + TALLOC_CTX *mem_ctx; + const char *username; + const char *password; + struct dcerpc_pipe *p; struct netr_LogonSamLogon r; struct netr_Authenticator auth, auth2; - struct netr_NetworkInfo ninfo; - const char *username = lp_parm_string(-1, "torture", "username"); - const char *password = lp_parm_string(-1, "torture", "password"); - struct netr_CredentialState creds; - int i; - BOOL ret = True; + struct creds_CredentialState creds; + DATA_BLOB chall; +}; - if (!test_SetupCredentials2(p, mem_ctx, &creds)) { - return False; - } +/* + Authenticate a user with a challenge/response, checking session key + and valid authentication types +*/ +static NTSTATUS check_samlogon(struct samlogon_state *samlogon_state, + enum ntlm_break break_which, + DATA_BLOB *chall, + DATA_BLOB *lm_response, + DATA_BLOB *nt_response, + uint8 lm_key[8], + uint8 user_session_key[16], + char **error_string) +{ + NTSTATUS status; + struct netr_LogonSamLogon *r = &samlogon_state->r; + + struct netr_NetworkInfo ninfo; + samlogon_state->r.in.logon_level = 2; + samlogon_state->r.in.logon.network = &ninfo; + ninfo.logon_info.domain_name.string = lp_workgroup(); ninfo.logon_info.parameter_control = 0; ninfo.logon_info.logon_id_low = 0; ninfo.logon_info.logon_id_high = 0; - ninfo.logon_info.username.string = username; + ninfo.logon_info.username.string = samlogon_state->username; ninfo.logon_info.workstation.string = TEST_MACHINE_NAME; - generate_random_buffer(ninfo.challenge, - sizeof(ninfo.challenge), False); - ninfo.nt.length = 24; - ninfo.nt.data = talloc(mem_ctx, 24); - SMBNTencrypt(password, ninfo.challenge, ninfo.nt.data); - ninfo.lm.length = 24; - ninfo.lm.data = talloc(mem_ctx, 24); - SMBencrypt(password, ninfo.challenge, ninfo.lm.data); - r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); - r.in.workstation = TEST_MACHINE_NAME; - r.in.credential = &auth; - r.in.authenticator = &auth2; - r.in.logon_level = 2; - r.in.logon.network = &ninfo; + memcpy(ninfo.challenge, chall->data, 8); + + switch (break_which) { + case BREAK_NONE: + break; + case BREAK_LM: + if (lm_response && lm_response->data) { + lm_response->data[0]++; + } + break; + case BREAK_NT: + if (nt_response && nt_response->data) { + nt_response->data[0]++; + } + break; + case NO_LM: + data_blob_free(lm_response); + break; + case NO_NT: + data_blob_free(nt_response); + break; + } + + if (nt_response) { + ninfo.nt.data = nt_response->data; + ninfo.nt.length = nt_response->length; + } else { + ninfo.nt.data = NULL; + ninfo.nt.length = 0; + } - for (i=2;i<=3;i++) { - ZERO_STRUCT(auth2); - creds_client_authenticator(&creds, &auth); + if (lm_response) { + ninfo.lm.data = lm_response->data; + ninfo.lm.length = lm_response->length; + } else { + ninfo.lm.data = NULL; + ninfo.lm.length = 0; + } + + ZERO_STRUCT(samlogon_state->auth2); + creds_client_authenticator(&samlogon_state->creds, &samlogon_state->auth); + + status = dcerpc_netr_LogonSamLogon(samlogon_state->p, samlogon_state->mem_ctx, r); + if (!NT_STATUS_IS_OK(status)) { + if (error_string) { + *error_string = strdup(nt_errstr(status)); + } + } + + if (!creds_client_check(&samlogon_state->creds, &r->out.authenticator->cred)) { + printf("Credential chaining failed\n"); + } - r.in.validation_level = i; + if (!NT_STATUS_IS_OK(status)) { + /* we cannot check the session key, if the logon failed... */ + return status; + } + + /* find and decyrpt the session keys, return in parameters above */ + if (r->in.validation_level == 2) { + static const char zeros[16]; + + if (memcmp(r->out.validation.sam->LMSessKey.key, zeros, sizeof(r->out.validation.sam->LMSessKey.key)) != 0) { + creds_arcfour_crypt(&samlogon_state->creds, + r->out.validation.sam->LMSessKey.key, + sizeof(r->out.validation.sam->LMSessKey.key)); + } + + if (lm_key) { + memcpy(lm_key, r->out.validation.sam->LMSessKey.key, 8); + } - printf("Testing SamLogon with validation level %d\n", i); + if (memcmp(r->out.validation.sam->key.key, zeros, sizeof(r->out.validation.sam->key.key)) != 0) { + creds_arcfour_crypt(&samlogon_state->creds, + r->out.validation.sam->key.key, + sizeof(r->out.validation.sam->key.key)); + } - status = dcerpc_netr_LogonSamLogon(p, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { - printf("LogonSamLogon - %s\n", nt_errstr(status)); - ret = False; + if (user_session_key) { + memcpy(user_session_key, r->out.validation.sam->key.key, 16); + } + + } else if (r->in.validation_level == 3) { + static const char zeros[16]; + if (memcmp(r->out.validation.sam2->LMSessKey.key, zeros, sizeof(r->out.validation.sam2->LMSessKey.key)) != 0) { + creds_arcfour_crypt(&samlogon_state->creds, + r->out.validation.sam2->LMSessKey.key, + sizeof(r->out.validation.sam2->LMSessKey.key)); } - if (!creds_client_check(&creds, &r.out.authenticator->cred)) { - printf("Credential chaining failed\n"); + if (lm_key) { + memcpy(lm_key, r->out.validation.sam2->LMSessKey.key, 8); + } + + if (memcmp(r->out.validation.sam2->key.key, zeros, sizeof(r->out.validation.sam2->key.key)) != 0) { + creds_arcfour_crypt(&samlogon_state->creds, + r->out.validation.sam2->key.key, + sizeof(r->out.validation.sam2->key.key)); + } + + if (user_session_key) { + memcpy(user_session_key, r->out.validation.sam2->key.key, 16); + } + } + + return status; +} + +/* + * Test the normal 'LM and NTLM' combination + */ + +static BOOL test_lm_ntlm_broken(struct samlogon_state *samlogon_state, enum ntlm_break break_which, char **error_string) +{ + BOOL pass = True; + NTSTATUS nt_status; + DATA_BLOB lm_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24); + DATA_BLOB nt_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24); + DATA_BLOB session_key = data_blob_talloc(samlogon_state->mem_ctx, NULL, 16); + + uchar lm_key[8]; + uchar user_session_key[16]; + uchar lm_hash[16]; + uchar nt_hash[16]; + + ZERO_STRUCT(lm_key); + ZERO_STRUCT(user_session_key); + + SMBencrypt(samlogon_state->password, samlogon_state->chall.data, lm_response.data); + E_deshash(samlogon_state->password, lm_hash); + + SMBNTencrypt(samlogon_state->password, samlogon_state->chall.data, nt_response.data); + + E_md4hash(samlogon_state->password, nt_hash); + SMBsesskeygen_ntv1(nt_hash, session_key.data); + + nt_status = check_samlogon(samlogon_state, + break_which, + &samlogon_state->chall, + &lm_response, + &nt_response, + lm_key, + user_session_key, + error_string); + + data_blob_free(&lm_response); + + if (!NT_STATUS_IS_OK(nt_status)) { + return break_which == BREAK_NT; + } + + if (memcmp(lm_hash, lm_key, + sizeof(lm_key)) != 0) { + printf("LM Key does not match expectations!\n"); + printf("lm_key:\n"); + dump_data(1, (const char *)lm_key, 8); + printf("expected:\n"); + dump_data(1, (const char *)lm_hash, 8); + pass = False; + } + + if (break_which == NO_NT) { + char lm_key_expected[16]; + memcpy(lm_key_expected, lm_hash, 8); + memset(lm_key_expected+8, '\0', 8); + if (memcmp(lm_key_expected, user_session_key, + 16) != 0) { + printf("NT Session Key does not match expectations (should be first-8 LM hash)!\n"); + printf("user_session_key:\n"); + dump_data(1, (const char *)user_session_key, sizeof(user_session_key)); + printf("expected:\n"); + dump_data(1, (const char *)lm_key_expected, sizeof(lm_key_expected)); + pass = False; + } + } else { + if (memcmp(session_key.data, user_session_key, + sizeof(user_session_key)) != 0) { + printf("NT Session Key does not match expectations!\n"); + printf("user_session_key:\n"); + dump_data(1, (const char *)user_session_key, 16); + printf("expected:\n"); + dump_data(1, (const char *)session_key.data, session_key.length); + pass = False; + } + } + return pass; +} + +/* + * Test LM authentication, no NT response supplied + */ + +static BOOL test_lm(struct samlogon_state *samlogon_state, char **error_string) +{ + + return test_lm_ntlm_broken(samlogon_state, NO_NT, error_string); +} + +/* + * Test the NTLM response only, no LM. + */ + +static BOOL test_ntlm(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lm_ntlm_broken(samlogon_state, NO_LM, error_string); +} + +/* + * Test the NTLM response only, but in the LM field. + */ + +static BOOL test_ntlm_in_lm(struct samlogon_state *samlogon_state, char **error_string) +{ + BOOL pass = True; + NTSTATUS nt_status; + DATA_BLOB nt_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24); + + uchar lm_key[8]; + uchar lm_hash[16]; + uchar user_session_key[16]; + + ZERO_STRUCT(user_session_key); + + SMBNTencrypt(samlogon_state->password, samlogon_state->chall.data, nt_response.data); + + E_deshash(samlogon_state->password, lm_hash); + + nt_status = check_samlogon(samlogon_state, + BREAK_NONE, + &samlogon_state->chall, + &nt_response, + NULL, + lm_key, + user_session_key, + error_string); + + if (!NT_STATUS_IS_OK(nt_status)) { + return False; + } + + if (memcmp(lm_hash, lm_key, + sizeof(lm_key)) != 0) { + printf("LM Key does not match expectations!\n"); + printf("lm_key:\n"); + dump_data(1, (const char *)lm_key, 8); + printf("expected:\n"); + dump_data(1, (const char *)lm_hash, 8); + pass = False; + } + if (memcmp(lm_hash, user_session_key, 8) != 0) { + char lm_key_expected[16]; + memcpy(lm_key_expected, lm_hash, 8); + memset(lm_key_expected+8, '\0', 8); + if (memcmp(lm_key_expected, user_session_key, + 16) != 0) { + printf("NT Session Key does not match expectations (should be first-8 LM hash)!\n"); + printf("user_session_key:\n"); + dump_data(1, (const char *)user_session_key, sizeof(user_session_key)); + printf("expected:\n"); + dump_data(1, (const char *)lm_key_expected, sizeof(lm_key_expected)); + pass = False; + } + } + return pass; +} + +/* + * Test the NTLM response only, but in the both the NT and LM fields. + */ + +static BOOL test_ntlm_in_both(struct samlogon_state *samlogon_state, char **error_string) +{ + BOOL pass = True; + NTSTATUS nt_status; + DATA_BLOB nt_response = data_blob_talloc(samlogon_state->mem_ctx, NULL, 24); + DATA_BLOB session_key = data_blob_talloc(samlogon_state->mem_ctx, NULL, 16); + + char lm_key[8]; + char lm_hash[16]; + char user_session_key[16]; + char nt_hash[16]; + + ZERO_STRUCT(lm_key); + ZERO_STRUCT(user_session_key); + + SMBNTencrypt(samlogon_state->password, samlogon_state->chall.data, + nt_response.data); + E_md4hash(samlogon_state->password, (unsigned char *)nt_hash); + SMBsesskeygen_ntv1((const unsigned char *)nt_hash, + session_key.data); + + E_deshash(samlogon_state->password, (unsigned char *)lm_hash); + + nt_status = check_samlogon(samlogon_state, + BREAK_NONE, + &samlogon_state->chall, + NULL, + &nt_response, + lm_key, + user_session_key, + error_string); + + if (!NT_STATUS_IS_OK(nt_status)) { + return False; + } + + if (memcmp(lm_hash, lm_key, + sizeof(lm_key)) != 0) { + printf("LM Key does not match expectations!\n"); + printf("lm_key:\n"); + dump_data(1, lm_key, 8); + printf("expected:\n"); + dump_data(1, lm_hash, 8); + pass = False; + } + if (memcmp(session_key.data, user_session_key, + sizeof(user_session_key)) != 0) { + printf("NT Session Key does not match expectations!\n"); + printf("user_session_key:\n"); + dump_data(1, user_session_key, 16); + printf("expected:\n"); + dump_data(1, (const char *)session_key.data, session_key.length); + pass = False; + } + + + return pass; +} + +/* + * Test the NTLMv2 and LMv2 responses + */ + +static BOOL test_lmv2_ntlmv2_broken(struct samlogon_state *samlogon_state, enum ntlm_break break_which, char **error_string) +{ + BOOL pass = True; + NTSTATUS nt_status; + DATA_BLOB ntlmv2_response = data_blob(NULL, 0); + DATA_BLOB lmv2_response = data_blob(NULL, 0); + DATA_BLOB ntlmv2_session_key = data_blob(NULL, 0); + DATA_BLOB names_blob = NTLMv2_generate_names_blob(lp_netbios_name(), lp_workgroup()); + + uchar user_session_key[16]; + + ZERO_STRUCT(user_session_key); + + if (!SMBNTLMv2encrypt(samlogon_state->username, lp_workgroup(), samlogon_state->password, &samlogon_state->chall, + &names_blob, + &lmv2_response, &ntlmv2_response, + &ntlmv2_session_key)) { + data_blob_free(&names_blob); + return False; + } + data_blob_free(&names_blob); + + nt_status = check_samlogon(samlogon_state, + break_which, + &samlogon_state->chall, + &lmv2_response, + &ntlmv2_response, + NULL, + user_session_key, + error_string); + + data_blob_free(&lmv2_response); + data_blob_free(&ntlmv2_response); + + if (!NT_STATUS_IS_OK(nt_status)) { + return break_which == BREAK_NT; + } + + if (break_which != NO_NT && break_which != BREAK_NT && memcmp(ntlmv2_session_key.data, user_session_key, + sizeof(user_session_key)) != 0) { + printf("USER (NTLMv2) Session Key does not match expectations!\n"); + printf("user_session_key:\n"); + dump_data(1, (const char *)user_session_key, 16); + printf("expected:\n"); + dump_data(1, (const char *)ntlmv2_session_key.data, ntlmv2_session_key.length); + pass = False; + } + return pass; +} + +/* + * Test the NTLMv2 and LMv2 responses + */ + +static BOOL test_lmv2_ntlmv2(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lmv2_ntlmv2_broken(samlogon_state, BREAK_NONE, error_string); +} + +/* + * Test the LMv2 response only + */ + +static BOOL test_lmv2(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lmv2_ntlmv2_broken(samlogon_state, NO_NT, error_string); +} + +/* + * Test the NTLMv2 response only + */ + +static BOOL test_ntlmv2(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lmv2_ntlmv2_broken(samlogon_state, NO_LM, error_string); +} + +static BOOL test_lm_ntlm(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lm_ntlm_broken(samlogon_state, BREAK_NONE, error_string); +} + +static BOOL test_ntlm_lm_broken(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lm_ntlm_broken(samlogon_state, BREAK_LM, error_string); +} + +static BOOL test_ntlm_ntlm_broken(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lm_ntlm_broken(samlogon_state, BREAK_NT, error_string); +} + +static BOOL test_ntlmv2_lmv2_broken(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lmv2_ntlmv2_broken(samlogon_state, BREAK_LM, error_string); +} + +static BOOL test_ntlmv2_ntlmv2_broken(struct samlogon_state *samlogon_state, char **error_string) +{ + return test_lmv2_ntlmv2_broken(samlogon_state, BREAK_NT, error_string); +} + +static BOOL test_plaintext(struct samlogon_state *samlogon_state, enum ntlm_break break_which, char **error_string) +{ + NTSTATUS nt_status; + DATA_BLOB nt_response = data_blob(NULL, 0); + DATA_BLOB lm_response = data_blob(NULL, 0); + char *password; + char *dospw; + smb_ucs2_t *unicodepw; + + uchar user_session_key[16]; + uchar lm_key[16]; + static const uchar zeros[8]; + DATA_BLOB chall = data_blob_talloc(samlogon_state->mem_ctx, zeros, sizeof(zeros)); + + ZERO_STRUCT(user_session_key); + + if ((push_ucs2_talloc(samlogon_state->mem_ctx, (smb_ucs2_t **)&unicodepw, + samlogon_state->password)) == -1) { + DEBUG(0, ("push_ucs2_allocate failed!\n")); + exit(1); + } + + nt_response = data_blob_talloc(samlogon_state->mem_ctx, unicodepw, + strlen_w(((void *)unicodepw))*sizeof(smb_ucs2_t)); + + password = strdup_upper(samlogon_state->password); + + if ((convert_string_talloc(samlogon_state->mem_ctx, CH_UNIX, + CH_DOS, password, + strlen(password)+1, + (const void**)&dospw)) == -1) { + DEBUG(0, ("push_ascii_allocate failed!\n")); + exit(1); + } + + SAFE_FREE(password); + + lm_response = data_blob_talloc(samlogon_state->mem_ctx, dospw, strlen(dospw)); + + nt_status = check_samlogon(samlogon_state, + break_which, + &chall, + &lm_response, + &nt_response, + lm_key, + user_session_key, + error_string); + + if (!NT_STATUS_IS_OK(nt_status)) { + return break_which == BREAK_NT; + } + + return True; +} + +static BOOL test_plaintext_none_broken(struct samlogon_state *samlogon_state, + char **error_string) { + return test_plaintext(samlogon_state, BREAK_NONE, error_string); +} + +static BOOL test_plaintext_lm_broken(struct samlogon_state *samlogon_state, + char **error_string) { + return test_plaintext(samlogon_state, BREAK_LM, error_string); +} + +static BOOL test_plaintext_nt_broken(struct samlogon_state *samlogon_state, + char **error_string) { + return test_plaintext(samlogon_state, BREAK_NT, error_string); +} + +static BOOL test_plaintext_nt_only(struct samlogon_state *samlogon_state, + char **error_string) { + return test_plaintext(samlogon_state, NO_LM, error_string); +} + +static BOOL test_plaintext_lm_only(struct samlogon_state *samlogon_state, + char **error_string) { + return test_plaintext(samlogon_state, NO_NT, error_string); +} + +/* + Tests: + + - LM only + - NT and LM + - NT + - NT in LM field + - NT in both fields + - NTLMv2 + - NTLMv2 and LMv2 + - LMv2 + - plaintext tests (in challenge-response feilds) + + check we get the correct session key in each case + check what values we get for the LM session key + +*/ + +static const struct ntlm_tests { + BOOL (*fn)(struct samlogon_state *, char **); + const char *name; + BOOL expect_fail; +} test_table[] = { + {test_lm, "LM", False}, + {test_lm_ntlm, "LM and NTLM", False}, + {test_ntlm, "NTLM", False}, + {test_ntlm_in_lm, "NTLM in LM", False}, + {test_ntlm_in_both, "NTLM in both", False}, + {test_ntlmv2, "NTLMv2", False}, + {test_lmv2_ntlmv2, "NTLMv2 and LMv2", False}, + {test_lmv2, "LMv2", False}, + {test_ntlmv2_lmv2_broken, "NTLMv2 and LMv2, LMv2 broken", False}, + {test_ntlmv2_ntlmv2_broken, "NTLMv2 and LMv2, NTLMv2 broken", False}, + {test_ntlm_lm_broken, "NTLM and LM, LM broken", False}, + {test_ntlm_ntlm_broken, "NTLM and LM, NTLM broken", False}, + {test_plaintext_none_broken, "Plaintext", True}, + {test_plaintext_lm_broken, "Plaintext LM broken", True}, + {test_plaintext_nt_broken, "Plaintext NT broken", True}, + {test_plaintext_nt_only, "Plaintext NT only", True}, + {test_plaintext_lm_only, "Plaintext LM only", True}, + {NULL, NULL} +}; + +/* + try a netlogon SamLogon +*/ +static BOOL test_SamLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) +{ + int i, j; + BOOL ret = True; + + struct samlogon_state samlogon_state; + + samlogon_state.mem_ctx = mem_ctx; + samlogon_state.username = lp_parm_string(-1, "torture", "username"); + samlogon_state.password = lp_parm_string(-1, "torture", "password"); + samlogon_state.p = p; + + samlogon_state.chall = data_blob_talloc(mem_ctx, NULL, 8); + + generate_random_buffer(samlogon_state.chall.data, + 8, False); + + if (!test_SetupCredentials2(p, mem_ctx, NETLOGON_NEG_AUTH2_FLAGS, &samlogon_state.creds)) { + return False; + } + + samlogon_state.r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p)); + samlogon_state.r.in.workstation = TEST_MACHINE_NAME; + samlogon_state.r.in.credential = &samlogon_state.auth; + samlogon_state.r.in.authenticator = &samlogon_state.auth2; + + for (i=2;i<=3;i++) { + samlogon_state.r.in.validation_level = i; + for (j=0; test_table[j].fn; j++) { + char *error_string = NULL; + printf("Testing SamLogon with '%s' at validation level %d\n", test_table[j].name, i); + + if (!test_table[j].fn(&samlogon_state, &error_string)) { + if (test_table[j].expect_fail) { + printf("Test %s failed (expected, test incomplete): %s\n", test_table[j].name, error_string); + } else { + printf("Test %s failed: %s\n", test_table[j].name, error_string); + ret = False; + } + SAFE_FREE(error_string); + } } } @@ -406,7 +1008,7 @@ static BOOL test_SetPassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) NTSTATUS status; struct netr_ServerPasswordSet r; const char *password; - struct netr_CredentialState creds; + struct creds_CredentialState creds; if (!test_SetupCredentials(p, mem_ctx, &creds)) { return False; @@ -420,7 +1022,7 @@ static BOOL test_SetPassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) password = generate_random_str(8); E_md4hash(password, r.in.new_password.data); - creds_client_encrypt(&creds, &r.in.new_password); + creds_des_encrypt(&creds, &r.in.new_password); printf("Testing ServerPasswordSet on machine account\n"); @@ -468,7 +1070,7 @@ static BOOL test_DatabaseSync(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_DatabaseSync r; - struct netr_CredentialState creds; + struct creds_CredentialState creds; const uint32 database_ids[] = {0, 1, 2}; int i; BOOL ret = True; @@ -530,7 +1132,7 @@ static BOOL test_DatabaseDeltas(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_DatabaseDeltas r; - struct netr_CredentialState creds; + struct creds_CredentialState creds; const uint32 database_ids[] = {0, 1, 2}; int i; BOOL ret = True; @@ -587,7 +1189,7 @@ static BOOL test_AccountDeltas(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_AccountDeltas r; - struct netr_CredentialState creds; + struct creds_CredentialState creds; BOOL ret = True; if (!test_SetupCredentials(p, mem_ctx, &creds)) { @@ -622,7 +1224,7 @@ static BOOL test_AccountSync(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_AccountSync r; - struct netr_CredentialState creds; + struct creds_CredentialState creds; BOOL ret = True; if (!test_SetupCredentials(p, mem_ctx, &creds)) { @@ -816,12 +1418,12 @@ static BOOL test_DatabaseSync2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx) { NTSTATUS status; struct netr_DatabaseSync2 r; - struct netr_CredentialState creds; + struct creds_CredentialState creds; const uint32 database_ids[] = {0, 1, 2}; int i; BOOL ret = True; - if (!test_SetupCredentials2(p, mem_ctx, &creds)) { + if (!test_SetupCredentials2(p, mem_ctx, NETLOGON_NEG_AUTH2_FLAGS, &creds)) { return False; } -- cgit