How Long Does a Micro-Segmentation Policy Stay Correct?

Micro-segmentation divides a network into many small zones and allows only the specific connections each machine needs, so that an attacker who takes over one machine cannot freely move to others. Recent systems learn these zones automatically from traffic logs. The best example, ZTS, clusters cloud machines into roles and writes allow-lists between them (Securing Public Cloud Networks with Efficient Role-based Micro-Segmentation). These systems are judged the way many clinical interventions are judged: by how well they perform right after deployment, on a snapshot of data. Clinical research has learned the cost of that habit. Short follow-up hides late recurrence (A predictive model using left atrial function and B‐type natriuretic peptide level in predicting the recurrence of early persistent atrial fibrillation after radiofrequency ablation), and early surrogate markers fail to predict the outcomes that matter (A prospective evaluation of cardiovascular magnetic resonance measures of dyssynchrony in the prediction of response to cardiac resynchronization therapy). Nobody has asked the equivalent question of a learned network policy: how long it keeps allowing the right traffic and blocking the wrong traffic, and whether its day-one score tells you that.

We propose treating each learned policy as a patient in a survival study. Each policy is followed over months of replayed or live traffic. Two hard endpoints are recorded: the first time the policy blocks legitimate traffic beyond a tolerance, and the first time an injected compromise spreads further than the policy should allow. Follow-up that ends before either event is recorded as censored rather than dropped. With this measurement in hand, we test a specific tension. Re-learning the policy often keeps it current, but it may also learn a patient attacker's traffic as legitimate. Keeping the old policy is safer against that, but the policy goes stale. The contribution is the measurement protocol plus an answer to where the best operating point lies on that tradeoff. It is not another segmentation algorithm.

Core Claim

We make two falsifiable claims. First, the snapshot quality of a learned segmentation, measured as clustering agreement with true roles (the adjusted Rand index, ARI), is a weak predictor of how long the policy survives. The practical consequence is that ranking segmentation methods by day-one ARI can reverse their ranking on long-horizon containment. Second, scheduled re-inference from a sliding window of recent traffic is not a free fix, even when compute is cheap. Under slow lateral movement, where the attacker adds a few new connections per week and never produces a burst, a sliding-window re-learner gradually absorbs the attacker's flows into the allowed communication graph. We call this ratcheting. A re-learner that inherits the previous policy and admits new edges only with evidence should avoid it.

To state the endpoint precisely, let $T$ be the number of days from deployment until a policy first exceeds either a false-block rate $\epsilon$ on legitimate flows or a lateral-reach budget $k$ for an injected compromise. The object of study is the survival curve

$$S(t) = \Pr(T > t),$$

estimated with Kaplan–Meier curves (a standard way to estimate survival when some follow-up ends early). The first claim is then a concrete test: the concordance index, which measures how well day-zero ARI orders policies by their $T$, should sit close to 0.5 (chance) rather than near 1.

Positioning Against Prior Work

The method we build on is ZTS. It supplies the segmentation pipeline: it combines PCA, a contrastive autoencoder and hierarchical clustering to infer roles, reaching average ARI 0.77 against 0.39 for the best baseline across 11 cloud deployments, at a telemetry cost of about 0.5% of VM costs. Its authors note that role inference is not fully automated and that policies drift as applications change. However, their evaluation uses static telemetry, so the rate of decay is unmeasured. We keep their pipeline as the object under study and add the time axis.

Two works motivate the proposal by identifying the gap without filling it. Zero-Trust Foundation Models reports isolation of malicious nodes within 1.5 seconds and names long-horizon trust calibration as open. That reported figure measures reaction to acute events and says nothing about slow drift, which is exactly the regime we target. Enhancing Patient-Centric Healthcare through Secure and Resilient Intelligent Cyber-Physical Systems and the Internet of Things argues for automatically micro-segmenting medical devices but offers no empirical data. It does sharpen why false blocks matter: a stale policy that cuts off a legitimate device's telemetry is itself a harm. The edge-learning survey (Edge Learning for 6G-enabled Internet of Things) constrains our design. It reports that clean-label and distributed backdoor attacks exceed 90% success against collaborative learners while evading aggregation defenses. Any re-learner that trusts recent data is therefore exposed, which is why ratcheting is our central hypothesis rather than an afterthought.

The intrusion-detection results supply the surrogate we expect to fail. Deep Learning-Based Intrusion Detection Methods in Cyber-Physical Systems reports 99.87% accuracy on KDD Cup 1999. Intrusion Detection in IoT Using Deep Residual Networks with Attention Mechanisms reports 99.55% on ToN_IoT and 89.23% on UNSW-NB15. Both use time-agnostic splits. From Direction 2 we borrow method rather than content: censoring, fixed pre-registered endpoints, and the explicit comparison of surrogate against hard outcome that the cardiac study makes between 6-month remodeling and mortality.

Research Program

The first component is a longitudinal testbed. The public benchmarks in the file (ToN_IoT, UNSW-NB15, Edge-IIoTset) carry timestamps but cover short spans. We use them in two ways. First, we replay them in time order to calibrate short-horizon behavior. Second, we use them as sources of attack traces to inject into longer benign streams. The long benign streams come from two places. The first is multi-month flow logs from cloud deployments of the kind ZTS used, obtained through an operator partnership; this is the main external dependency, and we state it as a risk. The second is a simulated microservice estate. It evolves on a schedule drawn from real deployment histories: services are added, retired and renamed, and dependencies are rewired. Its true roles are known at every timestep.

The second component is the endpoint definition and the attack injector. For false blocks, legitimate flows are labeled by the simulator's ground truth, or by operator-confirmed change tickets in real logs. For containment, a compromised host is injected at a random time. It then attempts lateral movement at a controlled rate, from a burst down to a few new edges per week. We record how many hosts it reaches under the current policy.

The third component is a set of re-inference regimes, compared at a matched compute and administrator-review budget. The regimes are: no re-inference, fixed-schedule sliding-window re-inference, drift-triggered re-inference, and an anchored re-learner. The anchored re-learner reinitializes clustering from the previous roles. It admits a new allowed edge only if the edge persists across several windows and is supported by a change in the source role's overall communication profile, not just by the individual host. We also measure policy churn, meaning the fraction of rules that change per re-inference, because each change costs administrator review.

Baselines

The do-nothing reference is ZTS trained once on the first window and never updated. Its survival curve shows the raw decay rate, and every other regime must beat it on area under $S(t)$ to justify its cost.

The strongest existing method is ZTS re-run on a fixed schedule (daily and weekly) over a sliding window. It is the strongest competitor because its reported low telemetry cost makes frequent re-running realistic, and it inherits the 0.77 ARI reported in Securing Public Cloud Networks with Efficient Role-based Micro-Segmentation. We run it on identical traffic, with identical hyperparameter search budgets tuned on the first month only, and with the same number of re-inference events as the other regimes within each budget tier. The anchored re-learner beats it only if two conditions hold together. It must show higher restricted mean survival time under slow lateral movement, and it must show no worse false-block survival and equal or lower churn. Winning on containment while losing on false blocks does not count. No reported survival or containment result was found on Lacuna for ZTS or any segmentation method, so the baseline's numbers are generated in this study.

We also include the naive clustering baselines that ZTS compares against (Jaccard, SimRank, GAS, CloudCluster, averaging 0.39 ARI in that paper). These test the first claim directly: if a 0.39-ARI method survives about as long as a 0.77-ARI method, the snapshot score is not doing its job.

An ablation isolates the key ingredient. We remove only the edge-admission rule from the anchored re-learner, keeping the inherited initialization. If survival under slow attack then collapses to the sliding-window level, the admission rule is what prevents ratcheting.

Why not just…?

Why not just re-run segmentation every day, since it is cheap? This is the real threat to the proposal. If daily sliding-window re-inference shows no ratcheting at slow attack rates and acceptable churn, then the second claim is wrong, and the practical recommendation is simply "re-run often." The experiment settles this directly: we sweep the attack rate down to the level where each weekly window contains only a handful of attacker edges, and we measure reach under the daily schedule. The survey's evidence that slowly poisoned learners evade defenses (Edge Learning for 6G-enabled Internet of Things) makes ratcheting plausible but does not prove it. We would report a null result as the main finding.

Why not just put a standard drift detector on the violation rate and re-segment when it fires? This approach is simple and may match the anchored re-learner on false-block survival, so we include it as a regime. Its weakness is structural. A slow attacker does not raise the violation rate, because the attacker's flows are what get absorbed. So a detector watching violations cannot tell legitimate change from absorbed attacks. The containment endpoint under slow attack is where the two approaches should separate. If they do not, the drift detector is the better recommendation because it is simpler.

Why not just evaluate intrusion detectors on temporal splits instead? Temporal splits of classifiers are a useful and simpler check, and we run one on ToN_IoT as a sanity reference. But a detector's accuracy is not a segmentation policy's containment. The object that decays here is an allow-list whose failure is measured in reachable hosts and severed legitimate connections. The detector accuracies of 99.55% and 99.87% cited above are exactly the kind of number whose link to that outcome is untested.

Why not just use coarse VLAN zones that never drift? Coarse zones decay slowly because they allow a great deal. We include a VLAN-style policy as one more survival arm. We expect it to have long false-block survival and near-immediate containment failure, consistent with the smart-home findings in Assessing and Mitigating Network Vulnerabilities in Philips Hue and Nest Protect Smart Home Devices. This makes explicit that survival must be judged on both endpoints jointly.

Proposed Experiments and Decisive Checks

The first decisive check is surrogate validity. Across all methods and deployments, we compute the concordance between day-zero ARI and $T$ for both endpoints. A concordance near 0.5 supports the first claim. A concordance above roughly 0.75 refutes it, and would mean snapshot evaluation is adequate after all.

The second check is ratcheting. We plot reach of an injected compromise after 90 days against attack rate for each re-inference regime. The hypothesis predicts that sliding-window reach grows as the attack slows, while anchored-learner reach stays flat. The ablation should reproduce the sliding-window curve.

The third check guards against short follow-up in our own study. We pre-register a 12-month simulated horizon and report how conclusions change if the analysis stops at month 3 or month 6. If rankings of regimes flip between 3 and 12 months, that is itself direct evidence of the sustainability gap in this domain.

Throughout, we report Kaplan–Meier curves with censoring, restricted mean survival time, churn per re-inference, and compute cost. All comparisons use matched budgets as described under Baselines.