skip to content

How can a workload gain new microsegmentation reach with no rule change and no reviewer seeing it?

level: middleimportance: should knowfreq 46%

answer

  1. rules name groups, not machines
  2. membership is compiled into the rule set
  3. two change queues, one reviewer
  4. the policy diff can be empty
  5. a tag is a permission grant

basics

~20 s

By joining a group. Policy is written against groups and compiled per virtual NIC, so a tag set by build automation, in a change queue no reviewer watches, grants every existing rule naming that group.

solid answer

~50 s

The enforced rule set is the product of two inputs: the rule text and the group membership it resolves against. Reviewers only ever see the first. When build automation tags a new virtual machine as `tier=app`, the compiler attaches every rule naming that group to its virtual NIC, including rules approved years earlier and any intra-group `allow any`. The policy diff for that change is empty. That matters two ways. An adversary who can write that attribute - a provisioning API, a naming convention - grants themselves permissions without touching policy; and far more often a mis-tagged workload lands inside a permission set nobody intended. Closing it means reviewing membership as well as rules, which doubles a review burden the team already cannot staff, or pinning your highest-value rules to explicit static membership and giving up the automation that made per-workload policy feasible at several thousand machines.

code

text · 11 lines
text
change CR-8841   approved by 1 reviewer
  policy diff:      (none)
  membership diff:
    + vm-4471   tier = app          <- set by build automation
    + vm-4471   app  = claims-intake

compiled per-vNIC rule set for vm-4471 after this change:
    allow  tier=app  -> tier=db     tcp/1433     (R-102, unchanged, approved 2023)
    allow  tier=app  -> tier=app    any          (R-007, unchanged, approved 2021)
    allow  mgmt      -> tier=app    tcp/22,5985  (R-031, unchanged, approved 2021)
    ...

go deeper

for a junior

Know that microsegmentation rules are written against groups rather than individual machines, so which group a workload is in decides which rules apply to it.

for a middle

Explain the compile step: rule text times current membership produces the per-virtual-NIC filter set, so a membership change alters enforcement with an empty policy diff.

for a senior

Demonstrate the fix in proportion: gate membership only for groups that source rules into valuable destinations, and show approvers a reachability delta instead of a tag change.

for a principal

Be ready to argue that the inventory or tagging plane is in scope as a security boundary, and to say who funds gating it when provisioning automation currently owns that write.

## Two inputs, one of which is reviewed Microsegmentation at scale is only tractable because rules are not written per machine. You write `tier=app -> tier=db : tcp/1433` once, and the platform compiles it into the filter set of every virtual NIC whose workload currently matches. The compiled output is therefore a function of two things: 1. **the rule text**, which lives in the policy repository and goes through change review; and 2. **the membership**, which lives in the inventory - a tag, a label, a custom attribute, a folder, a naming convention - and is usually set by build automation or the platform team. Only the first has a reviewer attached to it. The second is treated as inventory metadata, which is exactly the misconception: **membership is a permission grant**. ## What that looks like on the day A change record shows an empty policy diff and two tags applied to a newly built virtual machine. After compilation, that machine carries rules approved in 2021 and 2023 that nobody re-opened, including an intra-tier rule permitting members of the group to talk to each other on any port. Nothing in the change asked a reviewer to consider that. Nothing in the rule base changed. The estate's permitted set grew. ## Why an adversary cares Two distinct routes, and they deserve separating. - **Deliberate.** If the attribute that drives membership can be set from a place the attacker already holds - a provisioning API, a self-service build pipeline, an inventory field editable by application owners, a name the automation pattern-matches on - then group assignment is a privilege-escalation primitive that produces no policy change to review. The control plane that sets tags is now as sensitive as the policy itself, and it is very often not treated that way. - **Accidental, and more common.** A workload is mis-tagged by a template, a copied build definition or a typo, and inherits a permission set intended for something else. It is a benign true positive with a real security consequence: an ordinary application server sitting inside the group that may reach the payments or actuarial tier. Either way, the reviewer's artefact never showed it, which returns you to this leaf's central problem: nobody can state what the set permits in aggregate, and the intruder's route is inside exactly that blind spot. ## What it costs to close There is no free version. - **Review membership too.** Correct in principle, unaffordable in practice at several thousand workloads with continuous provisioning. If you do it uniformly, you have doubled a review queue that is already being rubber-stamped. - **Review membership selectively.** Realistic. Pick the groups that appear as the *source* of a rule reaching something you care about, and gate membership in those groups only. It is a small list, it is defensible to an auditor, and it leaves the bulk of provisioning untouched. - **Render the delta as reach, not as tags.** A reviewer shown `tier=app added` cannot judge anything. A reviewer shown `this workload may now reach the actuarial data store on tcp/1433, and 412 peers on any port` can. Same computation, different artefact. - **Pin the crown jewels to explicit membership.** For the handful of rules protecting the highest-value destinations, name the workloads rather than a dynamic group. You lose the automation benefit exactly where you can afford to. - **Treat the tagging plane as a security boundary.** Who may write the attribute, is that write logged, and does the log get read. ## The intra-group rule deserves its own paragraph An `allow any` between members of the same group is the single most consequential line in most of these policies, because it converts membership into the whole control. Everything in the group is mutually reachable on every port. One mis-tagged or compromised member is inside a flat network with the rest, and the policy document still reads as microsegmentation. When you audit a generated policy, find these first - they are where the grain you paid for quietly disappears. ## The claim to get right "Nothing can change without a change request" is false here, and stating it confidently is the failure this question is aimed at. The policy *text* cannot change without one. What is *enforced* can, and does, several times a day.

  • So who should approve a membership change?
    You cannot review all of it. Gate membership only for groups that appear as the source of a rule reaching something valuable - that is a short, defensible list. And render the request as a reachability delta rather than a tag delta, so the approver sees what the workload may now reach rather than which label was applied.
  • What makes the tagging or inventory plane a security boundary in this design?
    Because a write to it changes enforcement. Whoever can set the attribute that drives group membership can grant permissions without touching policy, so that write path needs the same authorisation care and the same logging as the policy repository itself. Most estates protect the second and leave the first open to build automation and application owners.
  • Would static, explicitly listed membership fix this?
    For a handful of rules, yes, and that is where to spend it - the rules protecting your highest-value destinations. Estate-wide it fails: explicit lists at several thousand workloads go stale immediately, and stale lists produce outages and standing exceptions, which is a worse trade than the one you were fixing.

saying these in an interview costs you the question

  • Claims enforcement cannot change without a policy change request
  • Treats tags and inventory attributes as metadata, not permission grants
  • Reviews the rule diff and never the membership diff
  • Trusts automation-set attributes as an input to policy without gating the write path
  • Overlooks intra-group allow-any rules when auditing a generated policy

context