skip to content

What does a valid signature on a federated identity assertion actually prove?

level: seniorimportance: should knowfreq 38%

answer

  1. verification is local, not a question
  2. possession of the key, nothing more
  3. nobody asks the issuer to confirm
  4. self-contained versus resolvable credentials
  5. the forger writes the validity window

basics

~10 s

Only that something holding the signing key produced it. It does not prove the issuer authenticated anyone, that the named person was present, or that the issuer would agree it issued this.

solid answer

~50 s

A relying party validating an assertion checks that the signature verifies against the key it was configured to trust, that the validity window is current, and that the assertion is addressed to it. All of that is arithmetic done locally; none of it is a question put to the issuer. So the claim actually proven is narrow: the holder of that key produced this artefact. It is not proof that an authentication happened, that a second factor was satisfied, or that the named account still exists. From the relying party's side a forged assertion and a genuine one are indistinguishable by construction, because the design deliberately removed the issuer from the request path for scale and availability. The exception is a credential the relying party must resolve with the issuer, such as an opaque reference token, where acceptance depends on the issuer confirming it rather than on a signature alone.

go deeper

for a junior

Learn the one-line version: a valid signature proves the key signed it, nothing more. It says nothing about a person being present or an account still existing.

for a middle

Explain what a relying party actually checks and that every check is local. Be able to say why no back-channel question to the issuer is part of the normal flow.

for a senior

Show the consequence under pressure: from the relying party's side a forged and a genuine assertion are indistinguishable, and you must bound the claim honestly instead of asserting the user signed in.

for a principal

Own the tradeoff: self-contained credentials buy scale and issuer-independence at the price of making one key's custody the whole security of the trust. Decide where in the estate resolvable credentials are worth their coupling.

## The direction of the claim The single most useful discipline in this area is asking what a piece of proof actually asserts, in the direction it actually points. A verified signature asserts: *this artefact was produced by something holding the corresponding private key*. Everything else people read into it is inference layered on an assumption that only the issuer holds that key. What a valid signature therefore does **not** prove: - that a human was present, or that any credential was presented anywhere; - that an authentication occurred at the issuer at all; - that a second factor or sign-in condition was satisfied, since those are applied at issuance and issuance did not happen; - that the named account exists, is enabled, or holds the groups the assertion claims; - that the issuer would confirm it issued this, because it usually is not asked. ## What a relying party actually does When an assertion or token arrives, a relying party typically performs local checks: the signature verifies against a key it obtained in advance, the validity window has not expired, and the assertion is addressed to this relying party rather than another. Some also pin the issuer identifier and refuse assertions replayed twice. Every one of these is computed from the artefact plus previously configured material. There is no call to the issuer that asks *did you issue this?* This is not an oversight. Self-contained signed credentials exist precisely so that verification is cheap, works at scale, and continues to work when the issuer is slow or unreachable. A per-request call to the issuer would couple every sign-in to the issuer's availability and add a round trip to the critical path. The property that makes the design good is the same property a key holder exploits: acceptance depends only on the signature. ## The exceptions, and why they matter Two designs break the symmetry, and naming them is what turns this from a definition into a control-class answer. **Resolvable or reference credentials.** If what the relying party receives is an opaque handle it must resolve with the issuer before use, forgery of the artefact buys nothing: the forger cannot make the issuer's own state contain a handle it never created. The cost is exactly the coupling that self-contained tokens were invented to avoid, which is why this design tends to appear at high-value relying parties rather than everywhere. **Back-channel delivery.** Some federation profiles have the relying party fetch the assertion from the issuer over a direct channel rather than receiving it through the user's browser. This narrows the delivery path, though it does not by itself defeat a key holder who can reach that channel. ## Why lifetimes and audience restrictions do not save you A short validity window limits how long a **captured** genuine assertion can be replayed. Against someone who can sign at will it is not a control at all: they write the window themselves, and if it expires they mint another. An audience restriction limits which relying party a given assertion is for, but the forger writes that field too. Both controls constrain what somebody who **found** an artefact can do with it. Neither constrains somebody who **authors** artefacts. ## What this means when you have to make a claim Asked whether a specific admission was legitimate, the honest position from the relying party's side is that its acceptance is consistent with both a genuine issuance and a forged one, and that the distinction can only be drawn at the issuer, where in the forged case there is nothing at all. That is an uncomfortable answer, and it is the correct one. Candidates who assert that the acceptance itself proves the user signed in have inverted the direction of the claim, which is the most common single error in this whole subject. ## The design conclusion If your identity design is entirely self-contained signed credentials verified locally, then the security of every relying party reduces to the custody of one key and the honesty of everything that can invoke it. That is a defensible design, but it should be a chosen one, with the key's custody and the replacement drill treated as first-class, and with resolvable credentials preferred at the relying parties whose loss you could not accept.

  • Why do federation designs verify locally instead of calling the issuer per request?
    Because self-contained signed credentials scale and keep relying parties working when the issuer is slow or unreachable. A call per request couples every sign-in to the issuer's availability and adds latency to the critical path. The cost of that choice is the exact property a key holder exploits: acceptance turns on the signature and never on the issuer confirming anything.
  • Does shortening assertion lifetimes help against someone holding the signing key?
    Barely. Lifetimes constrain replay of a captured genuine assertion. A key holder writes the validity window themselves and mints a fresh assertion whenever the old one lapses, so lifetimes change the tempo of forgery, not whether it succeeds. They are worth having for other reasons, but they are not the answer to this question.
  • What would make forgery of a signed credential useless at a relying party?
    Requiring the relying party to resolve the credential with the issuer before honouring it, as with an opaque reference token. The forger cannot make the issuer's own state contain something it never created. The price is coupling to issuer availability and an extra round trip, which is why this is usually reserved for the relying parties you could least afford to lose.

A verifier checking a signature is a shop checking a banknote's watermark. It tests the note in its hand; it never phones the mint to ask whether that note was ever printed.

saying these in an interview costs you the question

  • Says a valid signature proves the user authenticated
  • Thinks the relying party asks the issuer to confirm issuance
  • Believes short lifetimes stop someone who can sign at will
  • Treats signature validity as proof the claims are true
  • Assumes the verifier checks whether the account is enabled

context