CSE Roadmap

Common tier · about 3 hours · 12 parts

Part 5 of 12 · 2 min read

The cheapest set of controls that blocks every path, not the cheapest control

Picking mitigations one attack at a time misses the controls that quietly block several attacks for the price of one.

Think of sandbagging a house against a flood. Sandbagging only the front door looks cheap and effective for that one door. But if water can also come in through the garage, the front-door bags bought you nothing until both entrances are covered at once.

a cut is a set of mitigations that makes every path to the attacker's goal impossible, and a minimal cut is the cheapest such set. Which is different from picking the cheapest or most effective single control. That is because a control that blocks two different attack paths at once is worth more than its price tag suggests. Finding the true cheapest covering set means searching combinations, not ranking controls one at a time.

A worked example. Applied alone, egress allowlisting and quarantine each leave the goal at 33.2% success; least privilege alone leaves it at 28.9% -- none of the three single controls gets close to zero, because each only closes off some of the four OR'd paths. Searching every combination of the seven available mitigations for the cheapest one that blocks all four paths finds least privilege, a tenant filter and trace access control, together costing 5 of a possible 12 -- and that set works specifically because least privilege alone cuts two separate paths (the injection path and the stolen-credential path) rather than just one.

The key lines. From code/mini-threats/threats.py:

# from code/mini-threats/threats.py
def cheapest_cut(t, mitigation_costs):
    """Brute force the cheapest set of mitigations that makes the goal impossible. Returns (cost, sorted set) or None."""
    names = sorted(mitigation_costs)
    best = None
    for r in range(len(names) + 1):
        for combo in combinations(names, r):
            if blocked(t, frozenset(combo)):
                c = sum(mitigation_costs[m] for m in combo)
                if best is None or c < best[0]:
                    best = (c, list(combo))
    return best

Read it as: the search tries every combination of every size, from zero mitigations up to all of them. It keeps the cheapest one where blocked returns true. This brute-force approach is honest about combinations, including the ones where a single shared control happens to cover two paths at once. That is exactly the thing a "pick the best control per threat" process would never discover.

Minimal cut

A cut is a set of mitigations that makes every path to the goal impossible; a minimal cut is the cheapest such set.

Example: least privilege landing in the cheapest 5-of-12 cut, rather than some more "obviously severe-sounding" single control, is the minimal-cut search finding value a per-threat checklist would have missed entirely -- it was cheap and it did double duty.