skip to content

Why might the filter behind your VPN head-end see only the forward direction of decrypted traffic?

level: middleimportance: should knowfreq 46%

answer

  1. the diagram is not the path
  2. who routes back to the client pool
  3. one leftover adjacency into the tier
  4. half a conversation, no alarm
  5. sole path, or no claim

basics

~20 s

Routing decides the path, not the diagram. If the core reaches the VPN client pool over an adjacency that skips the filter, return packets never traverse it — and flows still work, so the gap stays silent.

solid answer

~50 s

You put the head-end's inside leg in a screened tier whose gateway is the second enforcement device, so decrypted traffic leaves through it. But if the core also has an interface in that tier — a leftover backup adjacency nobody removed — and its route for the VPN client pool points at the head-end's inside address, return traffic goes core to head-end directly and never crosses the filter. The forward direction is still permitted, the flow completes, and nothing looks broken. What you lose is half the enforcement: anything an internal host initiates toward the pool or toward the head-end itself is unfiltered, and the device has no return-side state to reason about. The fix is to make the filter the only path in and out of that tier, and the price is a routing change with an outage window.

code

text · 10 lines
text
screened tier            10.20.0.0/24
  head-end inside leg    10.20.0.9      (default gateway 10.20.0.1)
  enforcement device     10.20.0.1      -> core
  core's legacy SVI      10.20.0.2      (backup link, never removed)

core routing:  10.99.0.0/16  (VPN client pool)  via 10.20.0.9

forward:  pool -> head-end -> 10.20.0.1 -> core -> app server
return:   app server -> core -> 10.20.0.2 -> 10.20.0.9 -> pool
          ...enforcement device not on the return path; flow still works

go deeper

for a junior

Know that a device only enforces on traffic that physically passes through it, and that routing — not the drawing — decides whether it does.

for a middle

Explain how a leftover adjacency plus a route to the client pool produces a one-directional path, and why the flow still works so the gap goes unnoticed.

for a senior

Show how you would establish the path with both-direction evidence from the device itself, and negotiate removing the convenient adjacency that someone depends on.

for a principal

Own the decision that the screened tier gets exactly one path in and out, the outage window that costs, and the re-provisioning owed to whoever loses the backup route.

## The claim being tested "We land the tunnel in a screened tier behind a second enforcement device" is an assertion about **paths**, not about racks. A path is produced by routing and layer-2 adjacency, and both are edited by people who are not thinking about your boundary claim. The characteristic way the claim quietly becomes false is that only one direction of the traffic actually crosses the device. ## How it happens The forward direction is easy to get right: the head-end's inside leg has the enforcement device as its default gateway, so everything it decapsulates leaves through it. The return direction is decided somewhere else entirely — by how the rest of the estate routes back to the VPN client pool. If the core learns or is configured with a route for the pool pointing at the head-end's inside-leg address, then the return path is whatever the core uses to reach *that address*. If the core has its own interface in the screened tier (very common: a legacy backup link, a management adjacency, an SVI created for a migration and never removed), it reaches the head-end directly and the enforcement device is simply not on the return path. ## Why nobody notices Because the traffic works. Both endpoints get their packets; the application is fine. A stateful device seeing only the forward direction of a flow still forwards what its policy permits — it just never observes the responses, so its state table is built on half the conversation. There is no alarm and no failed connection to investigate. The gap surfaces only when somebody actually tests the boundary, or after an incident when you try to say what the device would have stopped. The other outcome is worth naming because it looks like the opposite problem: if the *return* path traverses a stateful device that never saw the forward direction, that device drops the responses as out-of-state, and you get an intermittent, protocol-dependent breakage that gets blamed on the application. Same root cause, louder symptom. ## What is actually lost - **Internally initiated traffic toward the tunnel population and toward the head-end itself is unenforced.** That is precisely the direction a lateral move takes, and precisely the direction that matters if the head-end is the thing being attacked from inside. - **The device cannot reason about responses**, so any policy or logging that depends on a completed exchange is unreliable. - **Your evidence is invalid.** A deny test in the forward direction proves nothing about the reverse one, and "the device is in the path" was the load-bearing sentence in the design review. ## Fixing it, and what the fix costs The only durable fix is topological: the enforcement device must be the *sole* path between the screened tier and everything else. In practice that means removing every other adjacency into the tier — including the convenient ones — or placing the tier in a separate routing instance so that reachability to the pool exists only via the filter. Source-address verification on the tier's uplink helps catch the leak but does not create the path. The cost is a routing change in the core, an outage window for remote access while the return path moves, and the loss of whatever the leftover adjacency was doing (backup access, a management path) — which someone will have to re-provision the long way. That negotiation is the real work; the configuration is minutes. ## Proving the path, not the intent The honest test is a known flow in both directions: originate from a tunnel client to an internal service and confirm both the forward and return packets appear in the enforcement device's own accounting, then originate from an internal host toward the pool and confirm the same. Path evidence from the endpoints alone is not enough, because a bypassed device is invisible from the endpoints — that is exactly why it went unnoticed. ## Interview framing The question separates people who have drawn the diagram from people who have traced the packet. Say that placement is a routing property, name the leftover adjacency as the usual cause, note that the failure is silent because the traffic still works, and finish with what the fix costs in outage and in taking someone's backup path away.

  • If the enforcement device only sees one direction, why does the connection still succeed?
    Because the return packets take a physically different path and never reach it. The device permits and forwards the forward direction as normal; the responses simply route around it. Nothing drops, nothing logs an error. The contrasting case is when the return path crosses a *different* stateful device that never saw the forward direction — then responses are dropped as out-of-state and you get intermittent, protocol-dependent breakage instead.
  • Which direction of unfiltered traffic worries you more here?
    Internally initiated traffic toward the pool and toward the head-end's inside leg. That is the direction an adversary already inside the estate uses to reach the appliance, and it is the direction your forward-only deny test says nothing about. The tunnel population being unfiltered outbound is bad; the appliance being reachable from inside without policy is the one that changes the blast radius.

saying these in an interview costs you the question

  • It is behind the firewall, so both directions are covered
  • Asymmetry only matters for stateful inspection performance
  • A forward-direction deny test proves the device is in the path
  • Source-address verification alone puts the device back on the path
  • The leftover backup adjacency is harmless because nothing uses it

context