Short · Network security · 18 min read

Can You Block Employee Computers from Domain Controllers?

For ordinary Active Directory domain-joined computers, blocking all communication with domain controllers is generally the wrong segmentation objective. Preserve the client services the environment actually needs, restrict those flows to appropriate destinations, and separately deny unnecessary administrative access. A workstation's need to authenticate or retrieve policy is different from an administrator's need to manage the directory.

The tempting alternative is a simple diagram: employee devices on one side, identity infrastructure on the other, and a wall between them. But identity infrastructure supplies services those devices may need before a user opens an application. A boundary that breaks those services can look successful during a short test because cached state temporarily hides the missing dependency.

I would define success as a constrained, functioning relationship. The approved client completes its required identity and policy workflows; the prohibited administrative or lateral operation does not succeed; and the evidence shows which controller, protocol and operating state were exercised. “The user reached the desktop” is too narrow an acceptance criterion.

Frame the task around services and authority

This paper addresses segmentation around conventional Active Directory Domain Services, particularly Windows domain members. It does not provide a universal firewall ruleset for cloud-only identity, every trust topology, every application or every Windows release. It develops a proposed assessment method from twelve original protocol and vendor publications, with a fictional worked example. No network was changed or tested in preparing it.

The relevant distinction is between consuming an identity service and controlling that service. A computer may need to discover a controller, authenticate, retrieve policy or change a password. That does not justify giving it unrestricted access to every service on every controller. Nor does denying an administrative protocol establish that directory permissions are appropriately constrained.

Microsoft's Windows authentication documentation explains that domain computers communicate with controllers even when no human user is signed in. Computers have their own domain identities and security contexts (Microsoft, 2025a, “Security Accounts Manager database”). A migration scoped only around human sign-in therefore omits a distinct class of activity before the analysis has begun.

I would classify each proposed relationship by the initiating system, the security principal, the receiving service and the required action. Keep employee workstations, application servers, domain controllers and privileged administration devices in different source categories. A permission justified for one category should not silently become a permission for all domain members.

This approach also avoids an exaggerated security claim. Restricting network paths can reduce reachable services and constrain some forms of movement. It does not demonstrate that permitted authentication services are free from vulnerabilities, that credentials cannot be misused, or that directory authorization is correct. The objective is a defensible boundary around necessary dependencies, not an assertion that two firewall rules stop most ransomware.

Interpret the port documentation before turning it into policy

Active Directory connectivity documentation combines several scenarios. Treat it as a reference for identifying dependencies, then determine which dependencies apply to the actual source and destination roles. Copying the complete table into an employee-network allow rule can preserve substantially more access than the task requires.

Microsoft explicitly states that not every listed port is required in every scenario. Its firewall guidance gives a concrete example: a boundary between members and controllers does not require opening the FRS or DFSR replication ports merely because they appear in broader domain-and-trust documentation (Microsoft, 2026c, introductory note). That qualification is central to the design, not a footnote to discard.

The service reference describes protocols used by domain controllers, clients and application servers and distinguishes services such as Group Policy from its management and reporting tooling (Microsoft, 2026f, “Active Directory (local security authority)” and “Group Policy”). I would use the following map to organize investigation. It is not a deployable permission list, and the listed destination ports do not describe every required flow.

Dependency to investigateCommon service identificationEvidence question
Controller discoveryDNS, typically TCP/UDP 53; LDAP discovery trafficWhich resolver and candidate controllers does the client actually use?
Kerberos authenticationTCP/UDP 88Does a fresh request reach an authorized KDC?
Directory accessLDAP, commonly TCP/UDP 389; TLS and catalog variants where requiredWhich operation, protection and server role are needed?
Policy filesSMB, commonly TCP 445Can the client obtain the required SYSVOL content?
RPC servicesEndpoint mapper TCP 135 and the applicable service endpointWhich RPC interface and destination are required?
Lifecycle servicesPassword-change, time and other configured dependenciesWhich transitions are absent from a normal browsing test?

Direction is as important as a port number. Record who initiates the connection and distinguish a client source port from a server listening endpoint. Document how the chosen firewall handles return traffic. Do not turn a broad range found in a reference table into unrestricted bidirectional access between two entire networks without establishing why that scope is needed.

Preserve the operating-system and feature assumptions alongside the policy. Historical compatibility entries, trust relationships and administration tools can have different needs. The source documentation itself contains legacy material; its existence is not an instruction to enable obsolete protocols in a modern environment.

Controller discovery is a workflow, not a static address

A domain-joined computer needs to find a suitable controller. A test that targets one remembered address may bypass the discovery behavior that users will depend on after a restart, site change or controller outage.

Microsoft describes DNS-based discovery using SRV records that advertise controller capabilities and locality. Clients query those records, contact candidate controllers using LDAP over UDP, and cache the selected controller through Netlogon (Microsoft, 2025c, “Domain controller locator process” and “Discovery process”). This is more specific than the instruction to allow DNS somewhere.

I would identify the resolver path, the expected domain and site information, and the set of controllers that may legitimately be returned. Then compare that set with the firewall's allowed destinations. A resolver can return a perfectly valid answer for a controller that the client is not permitted to reach. The resulting failure belongs to the combined discovery-and-policy design, not necessarily to the DNS server.

Consider a branch office allowed to contact only its nearest controller. That may satisfy a limited normal-operation requirement. It does not establish that the branch can use a replacement controller during maintenance. The organization must decide whether alternate-site access is required, how it is bounded and how selection behaves in that condition.

Avoid solving every discovery failure by allowing every address in every identity subnet. Instead, resolve why the client chose that destination and whether the choice fits the intended operating mode. Sometimes the policy is too narrow; sometimes the site information or service advertisement needs correction. Those are different changes with different owners.

The test record should retain the controller selected, its relevant role, the client's location and whether cached discovery information was involved. This makes it possible to distinguish a genuinely exercised alternate path from another successful transaction with the same familiar server.

Cached sign-in can conceal a broken identity path

Windows can use previously cached domain logon information when a controller is unavailable. Microsoft distinguishes access to the local desktop from network resources that require domain validation (Microsoft, 2026a, “Summary” and “More information”). A user reaching the desktop after a firewall change therefore does not, by itself, show that online domain authentication worked.

Kerberos introduces another distinction. RFC 4120 separates the initial authentication-service exchange, the ticket-granting-service exchange and the application client/server exchange. A client obtains credentials for services through these different stages; presenting existing service credentials is not the same operation as obtaining new ones (Neuman et al., 2005, §§3.1–3.3).

I would keep these states separate in the acceptance design. A cached interactive sign-in, a new online authentication, obtaining access to a previously unused service and continuing an existing application session are different observations. Their dependencies may overlap, but one observation cannot stand in for all the others.

A controlled test should establish the starting state without disrupting unrelated users. Use an approved test account and device, record the relevant cache and session conditions, and collect evidence of the exchange intended to occur. Do not treat an arbitrary waiting period as proof that every ticket or connection has expired. Different forms of retained state require different evidence.

This is also why I would not recommend disabling cached sign-in as a quick way to make a segmentation test look rigorous. Offline access can be an intentional availability requirement. Test the distinction between online and offline behavior; do not remove a legitimate continuity mechanism merely because it complicates the measurement.

The useful result is explicit: this test demonstrated a fresh online operation against a named controller, while that test demonstrated local continuity without it. Both may be desirable. Confusing them creates false confidence about what the network boundary permits.

Policy processing requires more than successful authentication

Group Policy provides a concrete reason to assess identity connectivity beyond sign-in. Microsoft describes a Group Policy Object as including a container in Active Directory and a template in SYSVOL on domain controllers (Microsoft, 2026b, “What is a Group Policy”). Those components create related but distinguishable dependencies.

A client may be able to contact an authentication service while failing to retrieve the policy content needed for a particular setting. Conversely, a device may retain previously applied settings while its ability to receive changes is broken. The question is whether the intended policy version was obtained and applied, not merely whether the existing desktop still looks normal.

Microsoft's processing documentation distinguishes foreground and background application. It also notes that some extensions, such as software installation and folder redirection, do not behave like a routine background refresh (Microsoft, 2025b, “How Group Policy processing works”). A test that triggers one refresh cannot automatically establish startup, user-sign-in and extension-specific behavior.

I would select a harmless, reversible policy change in a controlled scope and observe the complete result. Record the applicable policy, version, source controller and client-side outcome. Where a business-critical extension matters, include the lifecycle event that causes it to run. A successful query for policy metadata is weaker evidence than the required setting taking effect.

This matters particularly when the network restriction itself is delivered through endpoint policy. If the deployment cuts off the channel needed to receive its correction, ordinary rollback may become unavailable. Establish a supported recovery mechanism before rollout and test it in the pilot. A design should not depend on the broken channel to remove the rule that broke it.

I would also separate policy consumption from policy administration. The source used by a client to retrieve settings does not imply that the same client should be permitted to edit those settings, manage controllers or run every reporting tool across the boundary. Review directory and file permissions alongside the network path rather than expecting the port filter to distinguish every permitted action.

Reduce SMB exposure without deleting necessary policy access

“Block SMB” is too imprecise to be a domain-segmentation policy. It can mean blocking workstation-to-workstation file sharing, preventing internet exposure, constraining access to file servers, or cutting off a controller's policy share. These changes have different operational effects.

Microsoft's SMB guidance discusses lateral restrictions, explicit allowances for domain controllers and file servers, and phased testing. It warns that incorrectly deployed connection-security rules can prevent access to data (Microsoft, 2024, “Configure Windows Defender Firewall” and “Test and deploy using policy”). The relevant lesson is to identify required server relationships while narrowing unnecessary ones.

I would define separate destination sets for policy retrieval, business file services and administration. If two sets currently overlap, retain that fact in the design rather than collapsing every server into one trusted category. A workstation needing one file share does not thereby need SMB access to every machine advertising the service.

On the target side, review what the authenticated identity can access. A permitted SMB connection does not mean every share or named-pipe operation should be available. The network boundary and service authorization should support the same purpose even though they enforce different parts of it.

Include remote and mobile devices in the scope. A rule deployed only at an office gateway does not establish the laptop's behavior on another network. Conversely, an endpoint rule may have a different effective profile or exception set away from the office. Record the location and active enforcement context in the test rather than assuming that one successful office pilot covers every use case.

RPC narrowing requires an interface-specific explanation

Dynamic RPC often provokes an unhelpful choice between allowing a large range everywhere and blocking it without understanding the consequences. A more useful review asks which RPC services the source needs, how their endpoints are discovered and whether a supported restriction changes the intended exposure.

Microsoft describes the endpoint mapper on TCP 135 directing a client to the service endpoint. Its guidance for restricting Active Directory RPC also warns that the procedure is not a complete replication-firewall configuration and that clients use RPC services beyond Netlogon (Microsoft, 2026d, “Summary” and “More information”). Reducing one configured range or pinning one service therefore does not establish that every relevant dependency has been covered.

I would resist a blanket rule that treats all RPC as administration. Classify the actual interface and operation. At the same time, the existence of one legitimate client RPC dependency should not authorize unrelated management services or all traffic from every workstation to every server.

A proposed static endpoint design needs its own acceptance work. Confirm the supported configuration for the operating-system release, inspect the endpoint actually registered, verify the approved source can use it, and check the alternate paths the change was intended to remove. Configuration intent and observed endpoint behavior should agree.

Keep replication and ordinary client access in separate test groups. An apparently healthy workstation tells little about controller-to-controller replication, and successful replication does not prove that a newly joined computer can complete its client workflow. These dependencies may share hosts or transport mechanisms while serving different roles.

No registry changes or port-pinning recipe is reproduced here. The decision is whether a supported, narrower configuration is justified and verifiable in the specific environment. A copied setting without its prerequisites, restart implications and operational tests can create a smaller-looking ruleset with less reliable service.

Reachability and protection of directory sessions are separate controls

A firewall that admits a directory connection has not established the security properties of that connection. Conversely, encryption of a permitted session does not justify allowing it from every source. Treat service exposure, session protection and directory authorization as three separate claims.

LDAP includes a StartTLS operation that negotiates installation of a TLS layer after the connection has begun (Sermersheim, 2006, §4.14). Consequently, the port number alone does not determine whether a particular LDAP session is protected by TLS. A review based solely on allowing one port and blocking another can miss the actual negotiation and client behavior.

Microsoft's LDAP signing guidance distinguishes integrity from confidentiality and separates signing, SASL sealing, TLS and channel binding. It also describes version- and deployment-dependent defaults (Microsoft, 2026e, “What LDAP signing does and doesn't do” and “How signing, encryption, and channel binding relate”). Do not assume that a server upgrade, a port label or the word secure establishes every required property.

For a required application connection, I would record how the client authenticates, which session protection is negotiated and which directory operations its identity is authorized to perform. The evidence should come from the actual supported client and server configuration. A test with one administration utility may not represent a legacy application using another library or authentication method.

Separate compatibility remediation from network rollback. If a permitted application fails because a stronger directory-session policy rejects its behavior, reopening a broad network boundary may not address the cause. Diagnose the failed layer, retain the intended security objective and choose a supported remediation. Otherwise every incident can become an excuse to restore unrestricted access without explaining what it fixed.

Use lifecycle coverage as the unit of acceptance

I propose a lifecycle matrix because a domain member is not in one permanent state. The following cases organize the assessment; they are not a claim that every organization needs identical tests or that every row uses the same protocols.

Operating casePositive evidence to seekSeparate restriction to verify
Ordinary online useNamed controller and required identity operation succeedUnneeded administration remains unavailable
Fresh authentication stateIntended online exchange is observedCached desktop access is not counted as that exchange
Computer startup and policy changeRequired computer/user policy version is appliedPolicy-editing authority is not inherited by the client
Approved enrollment or password lifecycleThe named transition completes through the intended servicesTemporary permissions do not become permanent broad access
Controller maintenance or alternate siteThe intended replacement controller is selected and usableFailover does not grant unrelated destinations
Recovery from a policy errorApproved reversal works through the documented recovery pathEmergency access remains bounded and is closed afterward

For each row, name the source class, target set, principal, starting state, expected transaction and evidence location. Define failure in advance. A timeout, an explicit service rejection and an application authorization failure should not be reported as the same network defect.

Use a positive control before interpreting a negative result. The relevant target and service should be known to operate for an approved source, or the team should have equivalent evidence that the tested service was available. Otherwise a failed prohibited connection may merely reflect an unavailable server.

The matrix also needs a scope statement. Record which domain and site relationships, operating-system builds and application classes were represented. If a trusted-domain workflow or a rarely used business process was not exercised, leave it open. A documented gap is more useful than a green label that silently excludes the difficult case.

I would avoid combining every new restriction into one change window. A pilot that changes controller reachability, authentication policy, endpoint firewall behavior and application configuration at once is difficult to interpret. Sequence changes so that failures can be attributed, while retaining the protections already established. The goal is an explainable result, not the maximum number of changed settings.

Worked example: a pilot that passes until Monday morning

Consider fictional Dunmere, an organization migrating an employee subnet from broad internal access to a restricted identity-services path. Its pilot keeps DNS and Kerberos connectivity to one local controller and removes other traffic classified as unnecessary. Several established users sign in, open familiar applications and report no immediate problem. This is an illustrative scenario, not a client incident or a measured deployment.

The initial conclusion is that domain access has been safely minimized. A closer review shows that the test never established which sign-ins were validated online, whether new service credentials were acquired, or whether a fresh policy version arrived. Those missing observations do not prove the design is broken. They mean the pilot has not yet supported the conclusion being reported.

On a controlled second pass, Dunmere uses a test device and account with documented starting conditions. It verifies the intended authentication exchange, then checks a harmless policy update. Authentication succeeds but policy retrieval fails. The team identifies a required policy-file relationship omitted from the proposed destination-and-service set. It adds that specific justified relationship and repeats the relevant restrictions, rather than restoring a whole-subnet allow rule.

A separate maintenance test reveals another gap. The approved local controller is unavailable, and discovery selects a legitimate alternate outside the firewall's destination set. Dunmere now has an explicit decision: support that alternate path with bounded access, change the intended service design, or accept loss of that function during the named outage. A normal-operation success cannot make the decision disappear.

Finally, the team checks whether its endpoint policy can receive a reversal if a future restriction blocks normal policy retrieval. It discovers that the current rollback instruction assumes the same path remains healthy. That is a recovery-design defect, not a missing authentication port. The remediation needs a supported alternate route or local recovery procedure, with its own access limits.

This example produces three different findings: incomplete observation of authentication state, an omitted policy dependency and an unproven recovery path. They should not be reduced to “AD needs all ports.” The review identifies which claim failed and supplies a narrow acceptance condition for each correction. The final evidence should show both restored legitimate work and continued denial of the unnecessary access the migration set out to remove.

Counterarguments and boundaries of this method

One objection is that allowing any workstation access to a controller undermines protection of identity infrastructure. The concern is understandable, but ordinary domain-service consumption and administrative control are not identical. If the organization wants an architecture without those client dependencies, it needs a supported redesign of identity and device management. A firewall cannot perform that migration by silently removing the services an existing design depends on.

Another objection is that a very broad allow rule is the only practical way to keep Active Directory reliable. Broad access can reduce immediate troubleshooting friction, but it leaves the purpose of many relationships unexplained. The alternative proposed here is incremental: define one representative source class and its supported workflows, establish the required relationships, then test the prohibited alternatives. Expansion should follow evidence rather than a universal template.

A third objection is that cloud authentication makes all of this obsolete. The scope is narrower: organizations still using conventional domain membership, hybrid dependencies or applications integrated with AD DS. Their actual paths need to be established. A cloud sign-in experience does not by itself prove that a device, service or application has no remaining controller dependency.

The lifecycle matrix and fictional example have not been empirically validated. The bibliography describes protocol mechanisms and vendor behavior, not a controlled trial demonstrating a particular reduction in breaches. Microsoft documentation is necessarily prominent because the implementation under discussion is Active Directory; that concentration limits independent evaluation of the vendor's design assumptions. The RFCs supply protocol context, not guarantees about Windows behavior.

Implementation details change, and the references contain both current guidance and historical compatibility material. Validate the relevant product version and enabled features before using a detail operationally. The paper intentionally does not prescribe a complete rule list or assert that every listed service is required in every topology.

Make the next change narrow enough to explain

I would begin with one defined workstation class, an explicit controller destination set and a small set of business and lifecycle workflows. Build the dependency record, agree on the restrictions and demonstrate the required operations. Then evaluate alternate-controller behavior and rollback before extending the policy to more devices.

If the proposed change involves deleting apparently unused permissions, the firewall-rule retirement assessment explains how observation and effective policy differ. For the separate problem of controlling who administers the infrastructure, see protecting network management access. Those decisions complement domain-service segmentation without turning them into one undifferentiated access rule.

Discuss an Active Directory segmentation assessment if your current choice appears to be unrestricted access or broken sign-in. A useful engagement would map the required client relationships, identify excessive administrative reach and define a bounded pilot with evidence for policy processing, alternate-controller use and recovery. The deliverable should explain which access remains, why it remains and what was actually verified.

References