static bool parse_getdc_response(
struct packet_struct *packet,
TALLOC_CTX *mem_ctx,
const char *domain_name,
uint32_t *nt_version,
const char **dc_name,
struct netlogon_samlogon_response **samlogon_response)
{
DATA_BLOB blob;
struct netlogon_samlogon_response *r;
union dgram_message_body p;
enum ndr_err_code ndr_err;
NTSTATUS status;
const char *returned_dc = NULL;
const char *returned_domain = NULL;
blob = data_blob_const(packet->packet.dgram.data,
packet->packet.dgram.datasize);
if (blob.length < 4) {
DEBUG(1, ("invalid length: %d\n", (int)blob.length));
return false;
}
if (RIVAL(blob.data,0) != DGRAM_SMB) {
DEBUG(1, ("invalid packet\n"));
return false;
}
blob.data += 4;
blob.length -= 4;
ndr_err = ndr_pull_union_blob_all(&blob, mem_ctx, &p, DGRAM_SMB,
(ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(1, ("failed to parse packet\n"));
return false;
}
if (p.smb.smb_command != SMB_TRANSACTION) {
DEBUG(1, ("invalid smb_command: %d\n", p.smb.smb_command));
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_DEBUG(dgram_smb_packet, &p);
}
blob = p.smb.body.trans.data;
r = talloc_zero(mem_ctx, struct netlogon_samlogon_response);
if (!r) {
return false;
}
status = pull_netlogon_samlogon_response(&blob, r, r);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(r);
return false;
}
map_netlogon_samlogon_response(r);
/* do we still need this ? */
*nt_version = r->ntver;
returned_domain = r->data.nt5_ex.domain_name;
returned_dc = r->data.nt5_ex.pdc_name;
if (!strequal(returned_domain, domain_name)) {
DEBUG(3, ("GetDC: Expected domain %s, got %s\n",
domain_name, returned_domain));
TALLOC_FREE(r);
return false;
}
if (*returned_dc == '\\') returned_dc += 1;
if (*returned_dc == '\\') returned_dc += 1;
*dc_name = talloc_strdup(mem_ctx, returned_dc);
if (!*dc_name) {
TALLOC_FREE(r);
return false;
}
if (samlogon_response) {
*samlogon_response = r;
} else {
TALLOC_FREE(r);
}
DEBUG(10, ("GetDC gave name %s for domain %s\n",
*dc_name, returned_domain));
return True;
}
bool receive_getdc_response(TALLOC_CTX *mem_ctx,
struct sockaddr_storage *dc_ss,
const char *domain_name,
uint32_t *nt_version,
const char **dc_name,
struct netlogon_samlogon_response **_r)
{
struct packet_struct *packet;
const char *my_mailslot = NULL;
struct in_addr dc_ip;
DATA_BLOB blob;
struct netlogon_samlogon_response r;
union dgram_message_body p;
enum ndr_err_code ndr_err;
NTSTATUS status;
const char *returned_dc = NULL;
const char *returned_domain = NULL;
if (dc_ss->ss_family != AF_INET) {
return false;
}
dc_ip = ((struct sockaddr_in *)dc_ss)->sin_addr;
my_mailslot = mailslot_name(mem_ctx, dc_ip);
if (!my_mailslot) {
return false;
}
packet = receive_unexpected(DGRAM_PACKET, 0, my_mailslot);
if (packet == NULL) {
DEBUG(5, ("Did not receive packet for %s\n", my_mailslot));
return False;
}
DEBUG(5, ("Received packet for %s\n", my_mailslot));
blob = data_blob_const(packet->packet.dgram.data,
packet->packet.dgram.datasize);
if (blob.length < 4) {
DEBUG(0,("invalid length: %d\n", (int)blob.length));
return false;
}
if (RIVAL(blob.data,0) != DGRAM_SMB) {
DEBUG(0,("invalid packet\n"));
return false;
}
blob.data += 4;
blob.length -= 4;
ndr_err = ndr_pull_union_blob_all(&blob, mem_ctx, &p, DGRAM_SMB,
(ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(0,("failed to parse packet\n"));
return false;
}
if (p.smb.smb_command != SMB_TRANSACTION) {
DEBUG(0,("invalid smb_command: %d\n", p.smb.smb_command));
return false;
}
if (DEBUGLEVEL >= 10) {
NDR_PRINT_DEBUG(dgram_smb_packet, &p);
}
blob = p.smb.body.trans.data;
ZERO_STRUCT(r);
status = pull_netlogon_samlogon_response(&blob, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
return false;
}
map_netlogon_samlogon_response(&r);
/* do we still need this ? */
*nt_version = r.ntver;
returned_domain = r.data.nt5_ex.domain;
returned_dc = r.data.nt5_ex.pdc_name;
if (!strequal(returned_domain, domain_name)) {
DEBUG(3, ("GetDC: Expected domain %s, got %s\n",
domain_name, returned_domain));
return false;
}
*dc_name = talloc_strdup(mem_ctx, returned_dc);
if (!*dc_name) {
return false;
}
if (**dc_name == '\\') *dc_name += 1;
if (**dc_name == '\\') *dc_name += 1;
if (_r) {
*_r = (struct netlogon_samlogon_response *)talloc_memdup(
mem_ctx, &r, sizeof(struct netlogon_samlogon_response));
if (!*_r) {
return false;
}
}
DEBUG(10, ("GetDC gave name %s for domain %s\n",
*dc_name, returned_domain));
return True;
}
static NTSTATUS tcp_ldap_netlogon(void *conn,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io)
{
struct cldap_search search;
struct ldap_SearchResEntry *res;
NTSTATUS status;
DATA_BLOB *blob;
ZERO_STRUCT(search);
search.in.attributes = (const char *[]) { "netlogon", NULL };
search.in.filter = cldap_netlogon_create_filter(mem_ctx, io);
if (search.in.filter == NULL) {
return NT_STATUS_NO_MEMORY;
}
status = tcp_ldap_rootdse(conn, mem_ctx, &search);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
res = search.out.response;
if (res == NULL) {
return NT_STATUS_NOT_FOUND;
}
if (res->num_attributes != 1 ||
strcasecmp(res->attributes[0].name, "netlogon") != 0 ||
res->attributes[0].num_values != 1 ||
res->attributes[0].values->length < 2) {
return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
}
blob = res->attributes[0].values;
status = pull_netlogon_samlogon_response(blob, mem_ctx,
&io->out.netlogon);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (io->in.map_response) {
map_netlogon_samlogon_response(&io->out.netlogon);
}
return NT_STATUS_OK;
}
static NTSTATUS udp_ldap_rootdse(void *data, TALLOC_CTX *mem_ctx,
struct cldap_search *io)
{
struct cldap_socket *cldap = talloc_get_type(data,
struct cldap_socket);
return cldap_search(cldap, mem_ctx, io);
}
static bool test_netlogon_extra_attrs(struct torture_context *tctx,
request_rootdse_t request_rootdse,
void *conn)
{
struct cldap_search io;
NTSTATUS status;
const char *attrs[] = {
"netlogon",
"supportedCapabilities",
NULL
};
const char *attrs2[] = { "netlogon", "*", NULL };
struct ldb_message ldbmsg = { NULL, 0, NULL };
ZERO_STRUCT(io);
io.in.dest_address = NULL;
io.in.dest_port = 0;
io.in.timeout = 2;
io.in.retries = 2;
/* Additional attributes may be requested next to netlogon */
torture_comment(tctx, "Requesting netlogon with additional attribute\n");
io.in.filter =
talloc_asprintf(tctx, "(&"
"(NtVer=%s)(AAC=%s)"
/* Query for LDAP_CAP_ACTIVE_DIRECTORY_OID */
"(supportedCapabilities=1.2.840.113556.1.4.800)"
")",
ldap_encode_ndr_uint32(tctx,
NETLOGON_NT_VERSION_5EX),
ldap_encode_ndr_uint32(tctx, 0));
torture_assert(tctx, io.in.filter != NULL, "OOM");
io.in.attributes = attrs;
status = request_rootdse(conn, tctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
torture_assert(tctx, io.out.response != NULL, "No Entries found.");
CHECK_VAL(io.out.response->num_attributes, 2);
/* netlogon + '*' attr return zero results */
torture_comment(tctx, "Requesting netlogon and '*' attributes\n");
io.in.attributes = attrs2;
status = request_rootdse(conn, tctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
torture_assert(tctx, io.out.response != NULL, "No Entries found.");
ldbmsg.num_elements = io.out.response->num_attributes;
ldbmsg.elements = io.out.response->attributes;
torture_assert(tctx, ldb_msg_find_element(&ldbmsg, "netlogon") != NULL,
"Attribute netlogon not found in Result Entry\n");
/* Wildcards are not allowed in filters when netlogon is requested. */
torture_comment(tctx, "Requesting netlogon with invalid attr filter\n");
io.in.filter =
talloc_asprintf(tctx,
"(&(NtVer=%s)(AAC=%s)(supportedCapabilities=*))",
ldap_encode_ndr_uint32(tctx,
NETLOGON_NT_VERSION_5EX),
ldap_encode_ndr_uint32(tctx, 0));
torture_assert(tctx, io.in.filter != NULL, "OOM");
io.in.attributes = attrs;
status = request_rootdse(conn, tctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
torture_assert(tctx, io.out.response == NULL,
"A wildcard filter should return no entries.");
return true;
}
bool torture_netlogon_tcp(struct torture_context *tctx)
{
const char *host = torture_setting_string(tctx, "host", NULL);
bool ret = true;
NTSTATUS status;
struct ldap_connection *conn;
TALLOC_CTX *mem_ctx;
const char *url;
mem_ctx = talloc_init("torture_ldap_netlogon");
url = talloc_asprintf(mem_ctx, "ldap://%s/", host);
status = torture_ldap_connection(tctx, &conn, url);
if (!NT_STATUS_IS_OK(status)) {
return false;
}
ret &= test_ldap_netlogon(tctx, tcp_ldap_netlogon, conn, host);
ret &= test_ldap_netlogon_flags(tctx, tcp_ldap_netlogon, conn, host);
ret &= test_netlogon_extra_attrs(tctx, tcp_ldap_rootdse, conn);
return ret;
}
static NTSTATUS udp_ldap_netlogon(void *data,
TALLOC_CTX *mem_ctx,
struct cldap_netlogon *io)
{
struct cldap_socket *cldap = talloc_get_type(data,
struct cldap_socket);
return cldap_netlogon(cldap, mem_ctx, io);
}
bool torture_netlogon_udp(struct torture_context *tctx)
{
const char *host = torture_setting_string(tctx, "host", NULL);
bool ret = true;
int r;
struct cldap_socket *cldap;
NTSTATUS status;
struct tsocket_address *dest_addr;
r = tsocket_address_inet_from_strings(tctx, "ip",
host,
lpcfg_cldap_port(tctx->lp_ctx),
&dest_addr);
CHECK_VAL(r, 0);
/* cldap_socket_init should now know about the dest. address */
status = cldap_socket_init(tctx, NULL, dest_addr, &cldap);
CHECK_STATUS(status, NT_STATUS_OK);
ret &= test_ldap_netlogon(tctx, udp_ldap_netlogon, cldap, host);
ret &= test_ldap_netlogon_flags(tctx, udp_ldap_netlogon, cldap, host);
ret &= test_netlogon_extra_attrs(tctx, udp_ldap_rootdse, cldap);
return ret;
}
