lsa.c

samba最新软件

					       levels[j], nt_errstr(status));
					ret = false;
				}
			}
		}

		trust_by_name.in.handle = handle;
		trust_by_name.in.name.string = domains->domains[i].name.string;
		trust_by_name.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
		trust_by_name.out.trustdom_handle = &trustdom_handle;
			
		status = dcerpc_lsa_OpenTrustedDomainByName(p, mem_ctx, &trust_by_name);
			
		if (!NT_STATUS_IS_OK(status)) {
			printf("OpenTrustedDomainByName failed - %s\n", nt_errstr(status));
			return false;
		}

		for (j=0; j < ARRAY_SIZE(levels); j++) {
			struct lsa_QueryTrustedDomainInfo q;
			union lsa_TrustedDomainInfo info;
			q.in.trustdom_handle = &trustdom_handle;
			q.in.level = levels[j];
			q.out.info = &info;
			status = dcerpc_lsa_QueryTrustedDomainInfo(p, mem_ctx, &q);
			if (!NT_STATUS_IS_OK(status) && ok[j]) {
				printf("QueryTrustedDomainInfo level %d failed - %s\n", 
				       levels[j], nt_errstr(status));
				ret = false;
			} else if (NT_STATUS_IS_OK(status) && !ok[j]) {
				printf("QueryTrustedDomainInfo level %d unexpectedly succeeded - %s\n", 
				       levels[j], nt_errstr(status));
				ret = false;
			}
		}
		
		c.in.handle = &trustdom_handle;
		c.out.handle = &handle2;

		status = dcerpc_lsa_Close(p, mem_ctx, &c);
		if (!NT_STATUS_IS_OK(status)) {
			printf("Close of trusted domain failed - %s\n", nt_errstr(status));
			return false;
		}

		for (j=0; j < ARRAY_SIZE(levels); j++) {
			struct lsa_QueryTrustedDomainInfoByName q;
			union lsa_TrustedDomainInfo info;
			q.in.handle         = handle;
			q.in.trusted_domain.string = domains->domains[i].name.string;
			q.in.level          = levels[j];
			q.out.info          = &info;
			status = dcerpc_lsa_QueryTrustedDomainInfoByName(p, mem_ctx, &q);
			if (!NT_STATUS_IS_OK(status) && ok[j]) {
				printf("QueryTrustedDomainInfoByName level %d failed - %s\n", 
				       levels[j], nt_errstr(status));
				ret = false;
			} else if (NT_STATUS_IS_OK(status) && !ok[j]) {
				printf("QueryTrustedDomainInfoByName level %d unexpectedly succeeded - %s\n", 
				       levels[j], nt_errstr(status));
				ret = false;
			}
		}
	}
	return ret;
}

static bool test_EnumTrustDom(struct dcerpc_pipe *p, 
			      TALLOC_CTX *mem_ctx, 
			      struct policy_handle *handle)
{
	struct lsa_EnumTrustDom r;
	struct lsa_EnumTrustedDomainsEx r_ex;
	NTSTATUS enum_status;
	uint32_t resume_handle = 0;
	struct lsa_DomainList domains;
	struct lsa_DomainListEx domains_ex;
	bool ret = true;

	printf("\nTesting EnumTrustDom\n");

	do {
		r.in.handle = handle;
		r.in.resume_handle = &resume_handle;
		r.in.max_size = LSA_ENUM_TRUST_DOMAIN_MULTIPLIER * 3;
		r.out.domains = &domains;
		r.out.resume_handle = &resume_handle;
		
		enum_status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
		
		/* NO_MORE_ENTRIES is allowed */
		if (NT_STATUS_EQUAL(enum_status, NT_STATUS_NO_MORE_ENTRIES)) {
			return true;
		} else if (NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)) {
			/* Windows 2003 gets this off by one on the first run */
			if (r.out.domains->count < 3 || r.out.domains->count > 4) {
				printf("EnumTrustDom didn't fill the buffer we "
				       "asked it to (got %d, expected %d / %d == %d entries)\n",
				       r.out.domains->count, LSA_ENUM_TRUST_DOMAIN_MULTIPLIER * 3, 
				       LSA_ENUM_TRUST_DOMAIN_MULTIPLIER, r.in.max_size);
				ret = false;
			}
		} else if (!NT_STATUS_IS_OK(enum_status)) {
			printf("EnumTrustDom failed - %s\n", nt_errstr(enum_status));
			return false;
		}
		
		ret &= test_query_each_TrustDom(p, mem_ctx, handle, &domains);
		
	} while ((NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)));

	printf("\nTesting EnumTrustedDomainsEx\n");

	resume_handle = 0;
	do {
		r_ex.in.handle = handle;
		r_ex.in.resume_handle = &resume_handle;
		r_ex.in.max_size = LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER * 3;
		r_ex.out.domains = &domains_ex;
		r_ex.out.resume_handle = &resume_handle;
		
		enum_status = dcerpc_lsa_EnumTrustedDomainsEx(p, mem_ctx, &r_ex);
		
		/* NO_MORE_ENTRIES is allowed */
		if (NT_STATUS_EQUAL(enum_status, NT_STATUS_NO_MORE_ENTRIES)) {
			return true;
		} else if (NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)) {
			/* Windows 2003 gets this off by one on the first run */
			if (r_ex.out.domains->count < 3 || r_ex.out.domains->count > 4) {
				printf("EnumTrustDom didn't fill the buffer we "
				       "asked it to (got %d, expected %d / %d == %d entries)\n",
				       r_ex.out.domains->count, 
				       r_ex.in.max_size,
				       LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER, 
				       r_ex.in.max_size / LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER);
				ret = false;
				exit(1);
			}
		} else if (!NT_STATUS_IS_OK(enum_status)) {
			printf("EnumTrustedDomainEx failed - %s\n", nt_errstr(enum_status));
			return false;
		}

		ret &= test_query_each_TrustDomEx(p, mem_ctx, handle, &domains_ex);
		
	} while ((NT_STATUS_EQUAL(enum_status, STATUS_MORE_ENTRIES)));

	return ret;
}

static bool test_CreateTrustedDomain(struct dcerpc_pipe *p, 
				     TALLOC_CTX *mem_ctx, 
				     struct policy_handle *handle)
{
	NTSTATUS status;
	bool ret = true;
	struct lsa_CreateTrustedDomain r;
	struct lsa_DomainInfo trustinfo;
	struct dom_sid *domsid[12];
	struct policy_handle trustdom_handle[12];
	struct lsa_QueryTrustedDomainInfo q;
	int i;

	printf("Testing CreateTrustedDomain for 12 domains\n");

	for (i=0; i< 12; i++) {
		char *trust_name = talloc_asprintf(mem_ctx, "torturedom%02d", i);
		char *trust_sid = talloc_asprintf(mem_ctx, "S-1-5-21-97398-379795-100%02d", i);
		
		domsid[i] = dom_sid_parse_talloc(mem_ctx, trust_sid);

		trustinfo.sid = domsid[i];
		init_lsa_String((struct lsa_String *)&trustinfo.name, trust_name);

		r.in.handle = handle;
		r.in.info = &trustinfo;
		r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
		r.out.trustdom_handle = &trustdom_handle[i];
		
		status = dcerpc_lsa_CreateTrustedDomain(p, mem_ctx, &r);
		if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) {
			test_DeleteTrustedDomain(p, mem_ctx, handle, trustinfo.name);
			status = dcerpc_lsa_CreateTrustedDomain(p, mem_ctx, &r);
		}
		if (!NT_STATUS_IS_OK(status)) {
			printf("CreateTrustedDomain failed - %s\n", nt_errstr(status));
			ret = false;
		} else {
		
			q.in.trustdom_handle = &trustdom_handle[i];
			q.in.level = LSA_TRUSTED_DOMAIN_INFO_NAME;
			status = dcerpc_lsa_QueryTrustedDomainInfo(p, mem_ctx, &q);
			if (!NT_STATUS_IS_OK(status)) {
				printf("QueryTrustedDomainInfo level 1 failed - %s\n", nt_errstr(status));
				ret = false;
			} else if (!q.out.info) {
				ret = false;
			} else {
				if (strcmp(q.out.info->name.netbios_name.string, trustinfo.name.string) != 0) {
					printf("QueryTrustedDomainInfo returned inconsistant short name: %s != %s\n",
					       q.out.info->name.netbios_name.string, trustinfo.name.string);
					ret = false;
				}
			}
		}
	}

	/* now that we have some domains to look over, we can test the enum calls */
	if (!test_EnumTrustDom(p, mem_ctx, handle)) {
		ret = false;
	}
	
	for (i=0; i<12; i++) {
		if (!test_DeleteTrustedDomainBySid(p, mem_ctx, handle, domsid[i])) {
			ret = false;
		}
	}

	return ret;
}

static bool test_QueryDomainInfoPolicy(struct dcerpc_pipe *p, 
				 struct torture_context *tctx, 
				 struct policy_handle *handle)
{
	struct lsa_QueryDomainInformationPolicy r;
	NTSTATUS status;
	int i;
	bool ret = true;
	if (torture_setting_bool(tctx, "samba4", false)) {
		printf("skipping QueryDomainInformationPolicy test against Samba4\n");
		return true;
	}

	printf("\nTesting QueryDomainInformationPolicy\n");

	for (i=2;i<4;i++) {
		r.in.handle = handle;
		r.in.level = i;

		printf("\ntrying QueryDomainInformationPolicy level %d\n", i);

		status = dcerpc_lsa_QueryDomainInformationPolicy(p, tctx, &r);

		if (!NT_STATUS_IS_OK(status)) {
			printf("QueryDomainInformationPolicy failed - %s\n", nt_errstr(status));
			ret = false;
			continue;
		}
	}

	return ret;
}


static bool test_QueryInfoPolicy(struct dcerpc_pipe *p, 
				 struct torture_context *tctx, 
				 struct policy_handle *handle)
{
	struct lsa_QueryInfoPolicy r;
	NTSTATUS status;
	int i;
	bool ret = true;
	printf("\nTesting QueryInfoPolicy\n");

	for (i=1;i<13;i++) {
		r.in.handle = handle;
		r.in.level = i;

		printf("\ntrying QueryInfoPolicy level %d\n", i);

		status = dcerpc_lsa_QueryInfoPolicy(p, tctx, &r);

		switch (i) {
		case LSA_POLICY_INFO_DB:
		case LSA_POLICY_INFO_AUDIT_FULL_SET:
		case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
			if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
				printf("server should have failed level %u: %s\n", i, nt_errstr(status));
				ret = false;
			}
			break;
		case LSA_POLICY_INFO_DOMAIN:
		case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
		case LSA_POLICY_INFO_DNS:
			if (!NT_STATUS_IS_OK(status)) {
				printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
				ret = false;
			}
			break;
		default:
			if (torture_setting_bool(tctx, "samba4", false)) {
				/* Other levels not implemented yet */
				if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
					printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
					ret = false;
				}
			} else if (!NT_STATUS_IS_OK(status)) {
				printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
				ret = false;
			}
			break;
		}

		if (NT_STATUS_IS_OK(status) && i == LSA_POLICY_INFO_DNS) {
			/* Let's look up some of these names */

			struct lsa_TransNameArray tnames;
			tnames.count = 14;
			tnames.names = talloc_zero_array(tctx, struct lsa_TranslatedName, tnames.count);
			tnames.names[0].name.string = r.out.info->dns.name.string;
			tnames.names[0].sid_type = SID_NAME_DOMAIN;
			tnames.names[1].name.string = r.out.info->dns.dns_domain.string;
			tnames.names[1].sid_type = SID_NAME_DOMAIN;
			tnames.names[2].name.string = talloc_asprintf(tctx, "%s\\", r.out.info->dns.name.string);
			tnames.names[2].sid_type = SID_NAME_DOMAIN;
			tnames.names[3].name.string = talloc_asprintf(tctx, "%s\\", r.out.info->dns.dns_domain.string);
			tnames.names[3].sid_type = SID_NAME_DOMAIN;
			tnames.names[4].name.string = talloc_asprintf(tctx, "%s\\guest", r.out.info->dns.name.string);
			tnames.names[4].sid_type = SID_NAME_USER;
			tnames.names[5].name.string = talloc_asprintf(tctx, "%s\\krbtgt", r.out.info->dns.name.string);
			tnames.names[5].sid_type = SID_NAME_USER;
			tnames.names[6].name.string = talloc_asprintf(tctx, "%s\\guest", r.out.info->dns.dns_domain.string);
			tnames.names[6].sid_type = SID_NAME_USER;
			tnames.names[7].name.string = talloc_asprintf(tctx, "%s\\krbtgt", r.out.info->dns.dns_domain.string);
			tnames.names[7].sid_type = SID_NAME_USER;
			tnames.names[8].name.string = talloc_asprintf(tctx, "krbtgt@%s", r.out.info->dns.name.string);
			tnames.names[8].sid_type = SID_NAME_USER;
			tnames.names[9].name.string = talloc_asprintf(tctx, "krbtgt@%s", r.out.info->dns.dns_domain.string);
			tnames.names[9].sid_type = SID_NAME_USER;
			tnames.names[10].name.string = talloc_asprintf(tctx, "%s\\"TEST_MACHINENAME "$", r.out.info->dns.name.string);
			tnames.names[10].sid_type = SID_NAME_USER;
			tnames.names[11].name.string = talloc_asprintf(tctx, "%s\\"TEST_MACHINENAME "$", r.out.info->dns.dns_domain.string);
			tnames.names[11].sid_type = SID_NAME_USER;
			tnames.names[12].name.string = talloc_asprintf(tctx, TEST_MACHINENAME "$@%s", r.out.info->dns.name.string);
			tnames.names[12].sid_type = SID_NAME_USER;
			tnames.names[13].name.string = talloc_asprintf(tctx, TEST_MACHINENAME "$@%s", r.out.info->dns.dns_domain.string);
			tnames.names[13].sid_type = SID_NAME_USER;
			ret &= test_LookupNames(p, tctx, handle, &tnames);

		}
	}

	return ret;
}

static bool test_QueryInfoPolicy2(struct dcerpc_pipe *p, 
				  struct torture_context *tctx, 
				  struct policy_handle *handle)
{
	struct lsa_QueryInfoPolicy2 r;
	NTSTATUS status;
	int i;
	bool ret = true;
	printf("\nTesting QueryInfoPolicy2\n");
	for (i=1;i<13;i++) {
		r.in.handle = handle;
		r.in.level = i;

		printf("\ntrying QueryInfoPolicy2 level %d\n", i);

		status = dcerpc_lsa_QueryInfoPolicy2(p, tctx, &r);
		
		switch (i) {
		case LSA_POLICY_INFO_DB:
		case LSA_POLICY_INFO_AUDIT_FULL_SET:
		case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
			if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
				printf("server should have failed level %u: %s\n", i, nt_errstr(status));
				ret = false;
			}
			break;
		case LSA_POLICY_INFO_DOMAIN:
		case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
		case LSA_POLICY_INFO_DNS:
			if (!NT_STATUS_IS_OK(status)) {
				printf("QueryInfoPolicy2 failed - %s\n", nt_errstr(status));
				ret = false;
			}
			break;
		default:
			if (torture_setting_bool(tctx, "samba4", false)) {
				/* Other levels not implemented yet */
				if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
					printf("QueryInfoPolicy2 failed - %s\n", nt_errstr(status));
					ret = false;
				}
			} else if (!NT_STATUS_IS_OK(status)) {
				printf("QueryInfoPolicy2 failed - %s\n", nt_errstr(status));
				ret = false;
			}
			break;
		}
	}

	return ret;
}

static bool test_GetUserName(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
{
	struct lsa_GetUserName r;
	NTSTATUS status;
	bool ret = true;
	struct lsa_StringPointer authority_name_p;

	printf("\nTesting GetUserName\n");

	r.in.system_name = "\\";
	r.in.account_name = NULL;
	r.in.authority_name = &authority_name_p;
	authority_name_p.string = NULL;

	status = dcerpc_lsa_GetUserName(p, mem_ctx, &r);

	if (!NT_STATUS_IS_OK(status)) {
		printf("GetUserName failed - %s\n", nt_errstr(status));
		ret = false;
	}

	return ret;
}

bool test_lsa_Close(struct dcerpc_pipe *p, 
		    TALLOC_CTX *mem_ctx, 
		    struct policy_handle *handle)
{
	NTSTATUS status;
	struct lsa_Close r;
	struct policy_handle handle2;

	printf("\ntesting Close\n");

	r.in.handle = handle;
	r.out.handle = &handle2;

	status = dcerpc_lsa_Close(p, mem_ctx, &r);
	if (!NT_STATUS_IS_OK(status)) {
		printf("Close failed - %s\n", nt_errstr(status));
		return false;
	}

	status = dcerpc_lsa_Close(p, mem_ctx, &r);
	/* its really a fault - we need a status code for rpc fault */
	if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
		printf("Close failed - %s\n", nt_errstr(status));
		return false;
	}

	printf("\n");

	return true;
}

bool torture_rpc_lsa(struct torture_context *tctx)
{
        NTSTATUS status;
        struct dcerpc_pipe *p;
	bool ret = true;
	struct policy_handle *handle;
	struct test_join *join = NULL;
	struct cli_credentials *machine_creds;

	status = torture_rpc_connection(tctx, &p, &ndr_table_lsarpc);
	if (!NT_STATUS_IS_OK(status)) {
		return false;
	}

	if (!test_OpenPolicy(p, tctx)) {
		ret = false;
	}

	if (!test_lsa_OpenPolicy2(p, tctx, &handle)) {
		ret = false;
	}

	if (handle) {
		join = torture_join_domain(tctx, TEST_MACHINENAME, ACB_WSTRUST, &machine_creds);
		if (!join) {
			ret = false;
		}

		if (!test_LookupNames_wellknown(p, tctx, handle)) {
			ret = false;
		}		

		if (!test_LookupNames_bogus(p, tctx, handle)) {
			ret = false;
		}		

		if (!test_LookupSids_async(p, tctx, handle)) {
			ret = false;
		}

		if (!test_QueryDomainInfoPolicy(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_CreateAccount(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_CreateSecret(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_CreateTrustedDomain(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_EnumAccounts(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_EnumPrivs(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_QueryInfoPolicy(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_QueryInfoPolicy2(p, tctx, handle)) {
			ret = false;
		}
		
#if 0
		if (!test_Delete(p, tctx, handle)) {
			ret = false;
		}
#endif
		
		if (!test_many_LookupSids(p, tctx, handle)) {
			ret = false;
		}
		
		if (!test_lsa_Close(p, tctx, handle)) {
			ret = false;
		}
		
		torture_leave_domain(join);

	} else {
		if (!test_many_LookupSids(p, tctx, handle)) {
			ret = false;
		}
	}

	if (!test_GetUserName(p, tctx)) {
		ret = false;
	}

	return ret;
}

bool torture_rpc_lsa_get_user(struct torture_context *torture)
{
        NTSTATUS status;
        struct dcerpc_pipe *p;
	TALLOC_CTX *mem_ctx;
	bool ret = true;

	mem_ctx = talloc_init("torture_rpc_lsa_get_user");

	status = torture_rpc_connection(torture, &p, &ndr_table_lsarpc);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(mem_ctx);
		return false;
	}

	if (!test_GetUserName(p, mem_ctx)) {
		ret = false;
	}
		
	talloc_free(mem_ctx);

	return ret;
}