skip to content

You set the issuance standard for a shared store — what must every mint record so one compromised identity stays survivable?

level: principalimportance: should knowfreq 27%

answer

  1. design for the 02:40 question
  2. parentage is written, never derived
  3. an orphan still works
  4. record, cap, alert together
  5. retention shorter than maximum life

basics

~20 s

Parentage above all: which identity and which session requested the mint, plus the target, the issue time and the expiry. Without that link stored at mint time, credentials from a compromised identity are orphans that still work and cannot be listed.

solid answer

~50 s

The incident asks one question — *what did this identity mint, and what of it is still live?* — and the answer is a query over records written at mint time or it is a manual sweep of every downstream system. So the standard requires each issuance record to carry the **parent identity**, the **bounded session** it was minted under, the **target** it works against, `issuedAt` and `expiresAt`, and an owner. On top of that the standard states a cleanup contract: revoking a parent identity produces the list of its live children, withdrawal is confirmed at each target rather than assumed from the store's record, and anything that cannot be withdrawn is escalated rather than dropped. The judgment call a lead owns is whether that cleanup runs automatically — cheap when children are re-mintable in seconds, dangerous when one mistaken revoke takes a fleet's work down with it.

code

pseudocode · 18 lines
pseudocode
record IssuedCredential:
    id
    parentIdentityId     # which identity requested it
    parentSessionId      # which bounded session it was minted under
    target               # which downstream system it works against
    owner                # which team is accountable for the consumer
    issuedAt
    expiresAt
    revokedAt            # null while still live

# the question the incident asks, answerable only from stored parentage
liveChildrenOf(identityId):
    return IssuedCredential where parentIdentityId == identityId
                             and revokedAt is null
                             and expiresAt > now

# a credential minted without parentIdentityId never appears in this answer,
# and is found only by sweeping each target system for accounts in a window

go deeper

for a junior

Recall that an issued credential should carry a stored link back to whoever requested it, because that link cannot be created after the fact.

for a middle

Explain the fields and what each buys: parent identity and session to scope the set, target to name the reach, issue time and expiry to size the tail, revocation time to filter for what is still live.

for a senior

Show the operating consequences: withdrawal confirmed at the target rather than inferred from the store, anything unwithdrawable escalated with its expiry, and the cleanup rehearsed before it is needed.

for a principal

Own the trade-off and the standard: automatic cascade against a reviewed list and who bears the outage risk, caps and alerting declared alongside the record, and retention matched to the longest credential lifetime you permit.

## Start from the question the incident will ask At 02:40, forty minutes into a takeover, somebody will ask: **what did this identity mint, and what of it is still live?** Every other decision in the response waits on that answer — how wide the reach is, which teams to wake, whether the tail closes on its own in an hour or a week. Designing issuance for a compromised identity means designing so that this question is a query that returns in seconds. That is a design-time property. Nothing you do at 02:40 can create a link that was not written at mint time. ## What each issuance record carries - **`parentIdentityId`** — the identity that requested it. This is the field the whole incident hangs on. - **`parentSessionId`** — the bounded session it was minted under, which narrows the set to one episode rather than to everything the identity has ever done. - **`issuedAt` and `expiresAt`** — the window, so the tail length is arithmetic rather than a guess. - **`target`** — the downstream system it works against, so the reach is listable and each owner can be told precisely what to withdraw. - **`owner`** — the team accountable for the consumer, so the escalation path is in the record rather than in somebody's memory. - **`revokedAt`** — null while live, which is what makes "still live" a filter instead of an inference. ## The orphan, and what it costs A credential minted with no stored parentage still works perfectly. It is simply unfindable from the parent's side. Cleanup then becomes a sweep of every downstream system for accounts created in a window — plausible against one database, unrealistic against forty target systems owned by a dozen teams, and it cannot separate the attacker's 4,000 from the fleet's legitimate mints in the same window unless something in the target's own record carries the requester. That is the practical difference between a two-hour incident and a two-week one, and it is decided by one stored field. ## The cleanup contract, stated in the standard 1. **Revoking a parent identity produces the list of its live children** — every record where `parentIdentityId` matches, `revokedAt` is null and `expiresAt` is in the future. 2. **Withdrawal is confirmed at the target**, not inferred from the store's own record. A store that has marked a credential revoked has updated its bookkeeping; the downstream system decides whether the credential still opens the door. 3. **Anything that cannot be withdrawn is escalated**, with its expiry attached, rather than quietly dropped from the list. A credential you cannot withdraw is a countdown you have to staff. ## The judgment call: automatic or reviewed | | Automatic cascade | Reviewed list | |---|---|---| | Time to contain | seconds | as long as the review takes | | Cost of a mistaken revoke | every consumer under that identity stops at once | bounded; a human sees the list first | | Fits | short-lived children a consumer can re-request immediately | long-lived children, or targets where the account carries state | | Failure to plan for | a cascade nobody rehearsed firing during a busy hour | a list nobody triaged while the tail ran | Most estates land on **automatic for generated short-lived children and a reviewed list for anything long-lived** — and then, crucially, rehearse the automatic path once, off-hours, before an incident needs it. An untested cascade is a claim, not a control. ## The three parts only work together - The **record** makes cleanup possible — without it you cannot list what to withdraw. - The **cap** makes cleanup small — the difference between withdrawing 10 credentials and 4,000. - The **alert** makes cleanup timely — it fires while the loop is running rather than at the next morning's review. A standard carrying only one of the three sounds complete and is not: perfect records of an unbounded, unnoticed incident still take days to work through. ## What to require of a team onboarding a workload - Declare the identity class's **legitimate live count and mint rate**, which become the caps. - Name the **owner** and the escalation contact, stored on the record rather than in a wiki. - State the **maximum life** the consumer needs, so the tail is a chosen number. - **Prove the cleanup once**, in a drill, before the first incident relies on it. ## The part that fails quietly Retention. If issuance records are pruned after 7 days but credentials may carry a 30-day maximum life, then any child minted 10 days ago is live with no parent row — an orphan created by a retention setting rather than by a missing field. Match the record's retention to the longest credential lifetime the standard permits, plus margin, and make sure the records survive the store's own backup and restore: a restore that brings back the credentials but not their parentage rebuilds the estate and loses the ability to clean it up.

  • Why store the session as well as the identity?
    Because the identity's full history is usually far wider than the incident. A collector that has minted legitimately for eighteen months would produce a list dominated by ordinary activity, and the responder would have to date-filter by hand. The session narrows it to one episode: everything minted while the attacker was inside, and nothing else — which is also what makes a partial, targeted cleanup defensible afterwards.
  • When would you not make the cleanup automatic?
    When the children are expensive to lose. If a minted credential is a downstream account other things depend on, or the child is long-lived and re-requesting it is not instant, an automatic cascade turns one mistaken or over-broad revoke into a fleet-wide outage. Those cases get a generated list and a human decision. Short-lived children a consumer can re-request in seconds are the case where automatic is clearly worth it.
  • What does a restore of the store have to bring back for this to keep working?
    The issuance records, not just the store's contents. A restore that returns credentials and policy but loses parentage leaves every credential minted before the restore point unlinkable, so the estate comes back up with no ability to answer what any identity minted. Treat the issuance record as first-class restorable state, and check it in the same drill that checks the store comes back at all.

saying these in an interview costs you the question

  • Parentage can be reconstructed afterwards from access logs
  • Deleting the store's record withdraws the credential
  • An automatic cascade is always the right default
  • Records matter more than caps or alerting
  • Prune issuance records on the general log retention setting
  • A store marking it revoked means the target refuses it