skip to content

A CVE against your appliance is tagged DISPUTED by the vendor — how do you judge your exposure?

level: seniorimportance: should knowfreq 40%

answer

  1. a disagreement recorded, not resolved
  2. different state from withdrawn
  3. no referee rules on the substance
  4. read the behaviour, not the label
  5. intended behaviour means no fix coming

basics

~20 s

A dispute records that a party contests the record; it does not withdraw it, and nobody adjudicates. Judge the described behaviour against your own deployment. If the vendor calls it intended, no fix is coming.

solid answer

~50 s

DISPUTED is a marker on a still-published record saying one party, usually the vendor, contests that the described behaviour is a vulnerability. It is not withdrawal; that is the rejected state, and it is a different thing. Crucially, nobody rules on the substance: the scheme records the disagreement rather than deciding it. So the label tells you nothing about your exposure, and you go back to the behaviour. Read what the record describes, work out whether the precondition holds where you run the appliance, and decide whether that behaviour is acceptable. The dispute does change one thing: a vendor who insists the behaviour is documented and intended is telling you no fixed version is coming. That converts the item from `wait for a patch` into a design problem, so you restrict who can reach it or accept it explicitly with an owner and a review date.

go deeper

for a junior

Know that a disputed record is still published and still real, and that it is not the same as a record that was withdrawn as invalid.

for a middle

Explain the mechanics: the marker sits on a published record, both positions stay visible, and no body adjudicates the substance of the disagreement.

for a senior

Show the working: decode the vendor's grounds, test whether the precondition holds in your own deployment, and reclassify the item as a design constraint when no fix is coming.

for a principal

Own the standing decision — a contested record recurs forever, so the organisation needs one recorded ruling with an owner and a review date rather than a fresh argument each cycle.

## What the marker actually is When a published record is contested, the contest is recorded on the record. The record stays public, keeps its identifier, and keeps its description; it gains a note that a party disputes it. This is deliberately different from withdrawal. A **withdrawn** (rejected) record is one the assigner has retracted — a duplicate, not a vulnerability at all, or issued in error — and it carries a stated reason. A **disputed** record is one that two parties disagree about *in public*, with both positions visible and neither erased. The single most common mistake is to collapse those two into 'it is not real, close it'. They are opposite situations: withdrawal is a decision, dispute is the absence of one. ## Nobody is the referee Candidates often assume some body adjudicates. It does not work that way. The scheme's job is naming, and it has no mandate to rule on whether a behaviour constitutes a vulnerability. Escalating to the assigner's root can resolve *process* questions — whether the issue was in scope, whether it duplicates another identifier, whether the assigner followed the rules — but it cannot resolve the substantive question of whether documented behaviour is a defect. That question has no central answer, because 'vulnerability' is defined relative to a security model, and the vendor's model and yours may genuinely differ. ## The usual grounds for a dispute, and what each implies - **'It is documented and intended.'** A support account, a debug interface, a permissive default that the manual describes. The vendor's position is that a documented behaviour cannot be a flaw. The practical consequence for you: it will not change. - **'It requires privileges the model already grants.'** The reporter demonstrated something from an account that, in the vendor's design, is already trusted. Whether this matters depends entirely on whether *your* deployment grants that account to people you would not trust with the result. - **'It is only reachable in an unsupported configuration.'** Then the question is simply whether you are in that configuration. - **'The affected component is not ours.'** A packaging or attribution dispute — the behaviour may be entirely real, in somebody else's code. Notice that every one of those, decoded, is a question about *your* deployment rather than about the record. ## How to reach a defensible position 1. **Read the description, ignore the label.** What behaviour, reachable by whom, under what precondition? 2. **Test the precondition against your estate.** Is the interface exposed? Is the account issued to anyone? Is the option enabled? A dispute changes nothing about whether the precondition holds for you. 3. **Ask what changes if both parties are right.** Very often the vendor is right that it is intended *and* the reporter is right that it is dangerous. Both can hold. Your decision does not require picking a winner. 4. **Decide the handling class.** If a fix might come, it is a patching item. If the vendor calls it intended, it is a design item: compensate around it with placement, network position, credential handling or an access boundary — or accept it with a named owner and a review date. 5. **Write the decision down once.** A disputed record does not vanish. It will keep reappearing in whatever lists your organisation maintains, and re-arguing it every quarter is pure cost. A recorded decision with its reasoning ends that. ## What the dispute does not change It does not remove the identifier, which stays permanent and citable. It does not stop downstream databases carrying the record. It does not make the described behaviour go away, and it does not make it dangerous either — plenty of disputed records describe behaviours that really are intended and really are harmless. ## The senior signal The answer an interviewer wants is the refusal to let a metadata label make a technical decision. A weak candidate treats the tag as a verdict in either direction — closes it because it is disputed, or escalates it because a vendor is being defensive. A strong one says: the label records a disagreement, the behaviour is what matters, the precondition is checkable in my own environment, and the vendor's position mainly tells me whether to expect a fixed version.

  • Who decides a dispute between a vendor and a reporter over a CVE record?
    Nobody, in the sense people expect. The scheme records that a party contests the record; it does not rule on whether the behaviour is a vulnerability. Escalating to the assigner's root can settle process questions — scope, duplication, rule-following — but not the substantive disagreement, because that depends on whose security model you adopt.
  • The vendor disputes it as documented, intended behaviour. What changes about how you handle it?
    It stops being a patching item and becomes a design constraint. A vendor who calls it intended will not remove it, so if the behaviour matters you compensate around it through placement, access boundaries or configuration, or accept it explicitly with an owner. Waiting for a fixed version is the failure mode.
  • A third-party datasheet cites an identifier whose record was withdrawn. What do you say about it?
    That the record was retracted — duplicate, not a vulnerability, or issued in error — and it carries a stated reason, while the number itself is permanent and never reassigned. Citing a withdrawn record as evidence in either direction is a mistake; ask what behaviour they actually mean and evaluate that.

saying these in an interview costs you the question

  • Treats a disputed record as withdrawn and closes it
  • Expects the scheme to rule on who is right
  • Waits for a fixed version on a disputed record
  • Confuses the disputed marker with the withdrawn state
  • Argues the label instead of testing the precondition

context