skip to content

Your CDN-fronted C2 rule has been rewritten three times this month — what must its replacement prove?

level: seniorimportance: should knowfreq 55%

answer

  1. three rewrites is a ledger, not noise
  2. artefact or invariant, decided by test
  3. change the artefacts and re-run
  4. replaying the old record proves nothing
  5. know which legitimate software also matches

basics

~20 s

That its clause still fires when the fixed artefacts are deliberately changed. Re-run the behaviour with a fresh hostname, certificate and TLS stack; replaying the stored record proves nothing, because it carries the artefacts you already know.

solid answer

~50 s

Three rewrites in a month is the ledger telling you the rule is written against artefacts, not against the behaviour. The replacement has to clear two bars. First, its clause must be a property the operator cannot drop without giving up the capability, and "cannot" has to be demonstrated rather than asserted: run the same technique with every fixed artefact deliberately changed — new fronted hostname, new certificate, new TLS client stack, freshly built payload — and see whether the clause still fires. Replaying the record captured last time proves nothing, because it still carries the artefacts you already knew. Second, you must know the clause's benign population in advance, so tuning has a shape and your one analyst's queue survives the rollout. Beware promoting a slower-moving artefact, such as a JA3 hash, to "invariant" merely because it outlasted the hostname.

code

text · 7 lines
text
2026-03-02 04:11:07  10.4.19.66  CORP\svc_backup  CONNECT  cdn-edge-9c2.example-cdn.net:443  203.0.113.41   200
2026-03-09 21:36:44  10.4.19.66  CORP\svc_backup  CONNECT  assets-7f1.example-cdn.net:443    203.0.113.86   200
2026-03-17 13:02:19  10.4.19.66  CORP\svc_backup  CONNECT  static-b30.example-cdn.net:443    198.51.100.7   200
...
# rule v1 matched the hostname          -> rewritten 2026-03-09
# rule v2 matched the edge address      -> rewritten 2026-03-17
# rule v3 matched the TLS client hash   -> rewritten 2026-03-24

go deeper

for a junior

Recall that a rule needing constant rewriting is matching something the operator changes cheaply, and that testing it means making the behaviour happen rather than reusing an old log sample.

for a middle

Explain the difference between an artefact that has been stable for a while and a property the technique cannot drop, and name the structural question that separates them.

for a senior

Show you would design the validation run — which artefacts you change on purpose, what fires, and how you enumerate the legitimate software that also satisfies the clause before rollout on a thin team.

for a principal

Own the measurement that drives the decision: rewrites per rule per quarter, and the willingness to conclude that a behaviour is not separable from normal work with what you currently collect.

## Read the ledger first Three rewrites in a month is data, not an annoyance. It says every field the rule has matched on so far — the fronted hostname, the edge address, the certificate serial, the TLS client fingerprint — is an artefact of *this deployment* of the technique rather than a property of the technique. Each rewrite bought a few days of coverage and cost real time from a team that has one analyst and no dedicated detection engineer. The right response is not a fourth rewrite; it is to change what the rule is written against, and to set a bar the replacement must clear before it takes the slot. ## Bar one: the clause must be demonstrated, not asserted An invariant is a property the operator cannot drop while still doing the thing they are doing. Candidates for the CDN-fronted case usually live one layer away from the network artefacts, because the network artefacts are exactly what is cheap for them to churn: - the initiating **process** is not a browser, an updater or any sanctioned client, yet it is holding outbound TLS sessions to an internet edge; - the destination was contacted with **no preceding name resolution** from that host, or by an account that never runs interactive web traffic; - a **service account** with no interactive logon history is originating proxy traffic at all. Every one of these is a hypothesis until it is tested. The test that separates an invariant from an artefact you simply have not watched change yet is **executing the behaviour with the fixed artefacts deliberately swapped**. Stand up a new fronted hostname, present a different certificate, use a different TLS library so the client fingerprint moves, rebuild the payload so the hash moves — then run the technique and watch whether the candidate clause fires. That is the only evidence available to you, and it is a genuinely different exercise from replaying the record you captured during the last case: that record still contains the old hostname and the old fingerprint, so a replay tells you the rule matches history, not that it matches the technique. This matters more here than in most detection work, because a detection's silence is uninformative. A rule that has never fired might be guarding a quiet estate or might have been dead since the day the hostname rotated, and its own output cannot tell the two apart. You cannot compute a miss rate from an absence. The only way to know the rule works is to make the behaviour happen. ## The trap: promoting a slower artefact The most common failure at this point is to notice that one field changed less often than the others last quarter and to declare it the invariant. A TLS client fingerprint such as a JA3 value is still an artefact — it is a hash of ClientHello fields, and it moves when the operator changes TLS library, version or configuration. "It has held for six weeks" is evidence about your observation window, not about the field's nature. The question to ask about any candidate clause is structural: *if this field changed, would the operator still have their capability?* If the answer is yes, you are looking at an artefact and you will be back here next month. ## Bar two: know the benign population before you ship A behavioural clause that survives artefact churn will also match legitimate software, and on a one-analyst team an untuned behavioural rule is worse than no rule, because it consumes the only triage capacity you have. So the replacement must arrive with an answer to "what legitimate things satisfy this?" — the backup agent, the monitoring collector, the software-distribution client, the security tool's own updater. Enumerate them from your own telemetry before rollout, exclude them on stable attributes rather than on the same volatile artefacts you are trying to escape, and record each exclusion so a later reader knows what the rule stopped covering. These hits are **benign true positives**: the clause matched what it says it matches and the cause is authorised. Treating them as false positives is how people weaken the behavioural condition itself and end up back with something artefact-shaped. ## What ships, and what happens to the old rule The outcome is a portfolio trade rather than an escalation. The behavioural rule takes the alerting slot. The artefact rule does not need a fourth rewrite; what remains useful from it — the small set of hostnames and addresses tied to this specific activity — folds into a narrow match list with an expiry date and a named owner, where it costs almost nothing and closes the occasional case fast. Then keep measuring the thing that started this: rewrites per rule per quarter. If the replacement is still being rewritten in three months, the clause was not an invariant, and the honest conclusion may be that nothing you currently collect separates this behaviour from normal work.

  • Why is replaying the captured record from the last case not sufficient evidence?
    Because that record contains the very artefacts you are trying to stop depending on. A replay confirms the rule matches a sample of history; it cannot tell you whether the clause survives a hostname, certificate or TLS stack the operator has not used yet. Only executing the behaviour with those artefacts deliberately changed produces evidence about the future.
  • The candidate clause held for six weeks without a rewrite. Is that enough to call it an invariant?
    No. Stability over a short window is a statement about your observation period, not about the field. Ask the structural question instead: if this field changed, would the operator still have the capability? If the answer is yes, it is an artefact that happens to have been stable, and it will move eventually.
  • The behavioural rule fires ninety times a week on your one-analyst team. What do you do?
    Do not weaken the behavioural condition, because that reintroduces artefact dependence. Enumerate the benign population from your own telemetry, exclude each identified system on a stable attribute, and record what each exclusion removes from coverage. If the population is genuinely unbounded, the honest verdict is that this record set does not separate the behaviour from normal work here.
  • What happens to the old artefact rule once the behavioural one ships?
    It is retired rather than rewritten a fourth time. The hostnames and addresses tied to this specific activity fold into a small match list with an expiry date and a named owner, which costs almost nothing while silent and closes a repeat case quickly. The maintenance you free up goes into tuning the behavioural rule.

saying these in an interview costs you the question

  • Proposes a fourth rewrite against the next artefact
  • Calls a JA3 hash an invariant of the behaviour
  • Validates the new rule by replaying an old record
  • Ships a behavioural rule with no benign population known
  • Treats hits on the backup agent as false positives
  • Assumes a silent rule is a working rule

context