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; }