A four-year database credential was copied six months ago and used; what does shortening its validity now not undo?
answer
- forward-looking only
- use inside the window is spent
- what it created has its own life
- the setting binds the next issuance
- withdrawal, not expiry, ends a live copy
basics
~20 sExpiry only stops future use of a value. The data already read, the account already created and any credential minted with it survive it. And a shorter setting binds the next credential issued, not the copy already out there.
solid answer
~40 sShortening validity is a forward-looking change, and there are three things it does not reach. First, use inside the window: everything that credential read or changed in the last six months stays read and changed. Second, what it created — a second credential minted with it, an account added, a rule altered — which stands on its own and has to be withdrawn separately. Third, and most often missed, the copy already out there: a credential stamped with a four-year expiry at issue keeps that expiry regardless of what the configured validity is changed to. The new number applies to the next value issued. Ending a live exposure of the existing one is withdrawal — an action against the system that accepts the credential — not a shorter setting.
go deeper
Remember the direction: a validity period says when a value stops being accepted in future. It says nothing about requests that already succeeded with it.
Be able to list the survivors without prompting — use inside the window, whatever the credential created downstream, and the copy already issued under the old number.
In an incident, show that you separate the lapse from the action. Name what has to be withdrawn by hand and who owns each of those objects, rather than reporting a setting change as containment.
Watch for this in how the estate reports risk. A programme that counts shortened lifetimes as closed exposures is measuring the wrong thing; insist the report distinguishes bounded future use from work actually withdrawn.
The argument for short-lived credentials is sound, and the moment it gets overstated it becomes actively misleading. A shorter validity period is a statement about the **future acceptance of a value**, and nothing else. Reading it as containment of a leak that already happened produces the most common bad outcome in this material: a team changes a number, records the issue as handled, and leaves everything the attacker actually got exactly where it is. ## What expiry is an action against Three different things get described as "changing the credential", and only one of them is expiry: - **Expiry** — the value stops being accepted by itself, at a time fixed when it was issued. Nobody has to act, and nobody has to know. - **Withdrawal** — someone acts against the system that honours the credential so that the old value stops working now, before its own expiry. - **Replacement** — a new value is put in place. The old one keeps working until it is withdrawn or reaches its own expiry. A shorter configured validity changes the first of those, for values issued from now on. It is not an incident action, and it is not withdrawal. ## The three survivors | what happened during the six months | does the shorter validity reach it? | |---|---| | a table read out and copied away | no — the read already succeeded | | a second credential minted using the first | no — it has its own life and holder | | an account or rule created downstream | no — it must be withdrawn on its own | | the copy already deployed, stamped with four years | no — it keeps the expiry it was issued with | | a copy that escapes tomorrow, issued under the new number | yes — inert after an hour | The first row is the one candidates concede easily. The second and third are the ones that decide how an incident actually goes: an attacker holding a credential for six months rarely keeps using that credential. The useful move is to convert it into access that does not depend on the original value at all — a new account, an added rule, another credential minted from it. Every one of those is a separate object with a separate holder, and the original value expiring leaves all of them running. The fourth row is the mechanical one and the one most often got wrong out loud. Where a credential carries its expiry stamped on it at issue, the value already deployed is unaffected by a change to the configured validity: it keeps four years. Designs differ here — some systems decide acceptance against a stored record and can be made to re-evaluate, others honour only what was stamped at issue — so the safe statement in an interview is that a configured change binds the next issuance, and if you need the existing value to stop working, withdraw it. ## Why this matters for the argument about the number The honest case for shortening survives all of this intact, because the case was never that expiry repairs anything: 1. It bounds the exposure you will **not** detect, by ending copies nobody found. 2. It shrinks the value of every later copy of the same value, without anyone doing anything. 3. It changes nothing about a window that has already been used, which is why it is a control and not a remedy. Stating it that way also makes the *next* decision visible. If a credential that has been out for six months is the problem, the actions in play are withdrawal and replacement, in an order someone has to choose and pay for; a shorter lifetime for whatever is issued afterwards is a good change that does not belong in the same sentence. Teams that blur the two end up reporting an exposure as contained on the strength of a setting, and the accounts the attacker created are still there a year later. One more overstatement to avoid: "a short lifetime bounds the cost of the leak". It bounds the **time the value is accepted**, not the cost. A one-hour credential used in its second minute to pull a customer table cost the entire table. What shortening removes is the long tail — the same copy still working next year, found by someone else entirely.
- Then what actually ends the exposure of a credential that is already out there?Withdrawal at the system that accepts it, so the old value stops working before its own expiry — either on its own, or after a replacement value is in place. Expiry ends it eventually, and a four-year expiry is not an answer to a live exposure. The order you choose between replacing first and withdrawing first is a cost decision, not a default.
- Does a shorter validity at least bound how much an unnoticed leak costs?It bounds how long the value is accepted, not what happens inside that time. A credential valid for one hour, used in its second minute to pull a customer table, cost the whole table. What shortening takes away is the tail: the same copy still working next year when somebody else stumbles on it.
- An attacker used a leaked credential to mint a second one. Why does the first expiring not help?Because the second credential is a separate object with its own holder and its own validity. It was legitimately issued to a caller the system believed, so nothing about the first value expiring is visible to it. Finding and withdrawing what a leaked credential created is separate work from letting the leaked credential lapse.
saying these in an interview costs you the question
- Claims expiry rolls back what the credential already did.
- Assumes shortening the configured validity shortens credentials already issued.
- Treats a shorter number as an action on a live exposure.
- Confuses the value expiring with the downstream account being withdrawn.
- Believes follow-on access dies with the credential it came from.