Which tenant operations must demand fresh proof of authentication, and what does that gate still not deny?
answer
- gate what outlives the session
- recovery paths are a second front door
- freshness is measured, never claimed
- durability capped, reach untouched
basics
~20 sThe ones that turn borrowed access into owned access: changing the password, enrolling a factor, editing a recovery address, granting delegated administration. The gate caps how durable the access becomes, and denies nothing the identity can already read or send.
solid answer
~50 sPick the operations whose effect outlives the session that performed them. Changing the password locks the owner out; enrolling a factor means the holder's own authenticator is accepted at every future ceremony; editing the recovery address points account recovery at them; granting delegated administration creates access that no longer depends on this identity at all. Each must refuse to run unless authentication happened recently - measured against the operation, for example by requiring `auth_time` within a few minutes, never by trusting an `amr` claim minted at issuance - and the check belongs on the server at the operation, on every path to it including the API, not on the button that hides it. What it does not deny is everything the identity reaches today: reading the mailbox and files, sending in the user's name, approving what that user approves. Fresh proof caps durability, not reach.
go deeper
Know the name of this control - re-authentication, or step-up, demanded before a sensitive change - and be able to offer password change and adding a login factor as obvious candidates.
Explain why those particular operations are chosen: each produces access that keeps working after the current session is gone. Explain how a service checks recency instead of believing the session's own claims.
Show that you know the control's limit. Fresh proof caps how durable the access becomes and leaves everything the identity reads and sends untouched, and it fails entirely if a second path to the operation skips it.
Be ready to argue where the prompts go when you are allowed only a few, and to defend a written list of gated operations to an owner who wants their own account exempted from it.
## What class of control this is This is a **preventive precondition**, usually called re-authentication or step-up. It is not about *who* the identity is - that question was settled at issuance - but about *how recently* the human behind it proved anything. It is the only control class that puts a factor back in front of someone who already holds a working session, because everything else about that session is honoured on possession. ## Choosing the operations: the durability test Apply one question to each operation: **if this succeeds, does its effect keep working after the session that performed it is gone?** - **Changing the password.** The effect is that the owner can no longer sign in and the holder decides who can. It converts a borrowed, expiring position into control of the account of record. - **Enrolling (or removing) an authentication factor.** The strongest of the four, and the one most often left ungated. Registering their own authenticator means they now pass the front door themselves; the session becomes disposable. - **Editing a recovery address or phone.** The quiet one, because nothing visibly changes today. Account recovery is a second front door, and this operation re-points it. - **Granting delegated administration.** Creates access attached to a different principal entirely, so it survives everything done to this identity. Contrast a large export or a bulk read. Damaging, certainly - but it produces no new access, so gating it spends friction without shortening anybody's foothold by a minute. ## How freshness has to be measured Freshness is a comparison against now, so the check must ask *when did authentication last happen* rather than *what does the session say about itself*. OpenID Connect gives the vocabulary: `max_age` sets the maximum seconds since `auth_time` before the provider must authenticate the user again, and `prompt=login` forces a ceremony outright. A window of a few minutes is normal for this class of operation. The defect to name explicitly is trusting `amr`. That claim lists the methods used at the original ceremony and travels unchanged through renewal, so a token minted a month later still says a second factor was involved. Reading it as "this request is multi-factor protected" turns a historical statement into a permission. ## Where the check belongs On the server, at the operation, on **every** route that reaches it. The classic failures are an API that performs the change without the interactive flow's precondition, and a delegated-administration surface that edits another account's factors while only the self-service path is gated. Disabling a control in the interface is not a gate; it is a suggestion. ## What form the proof should take For the position we are discussing - someone holding exactly one live session, no code running anywhere, no host owned - even re-typing the current password is a real barrier, because they do not have it. But it is weaker against other positions and it is not a fresh ceremony, so the stronger demand is the enrolled second factor. That matters most on factor enrolment, where the password may already be known to whoever is asking. ## What the gate still does not deny Everything the identity can reach right now. The mailbox and the files it can open. Messages sent in the user's name and believed because of it. Approvals that user is entitled to click. Directory information visible to any employee. Fresh proof bounds **how durable** the access becomes; it does nothing to **how far** it reaches while the session is honoured. A candidate who says step-up "protects the data" has the direction of the claim wrong, and it is the most common wrong answer on this subject after the multi-factor one. ## Failure modes worth naming - One path gated, another not. - The recency window measured in hours, which for an active holder is no window at all. - The gate in the interface rather than the service. - `amr` accepted as proof of recency. - Prompts sprinkled over reads, so users learn to click through the one that mattered.
- Why is trusting the `amr` claim in the presented token a broken way to enforce this?Because `amr` records the methods used at issuance and travels unchanged through renewal, so a token minted a month later still says a second factor was used. Freshness has to be a comparison - how long ago authentication happened, relative to now - which is what `auth_time` together with a maximum age expresses.
- For someone holding only a session, does asking for the current password count as fresh proof?For that position it is a real barrier: they have the session and not the password, so they stop. It is weaker against other positions and it is not a ceremony, so demanding the enrolled second factor is the stronger form - especially on factor enrolment, where the password may already be known.
- Where do these gates most often fail in practice?On alternative routes to the same effect: an API that performs the change without the interactive flow's precondition, or a delegated-administration surface that edits another account's factors while only the self-service path is gated. The precondition has to sit on the operation, not on one path to it.
saying these in an interview costs you the question
- Gates the interface control instead of the operation
- Accepts an amr claim as proof of recent authentication
- Claims step-up prevents data being read
- Forgets recovery address and factor enrolment
- Gates the web flow but leaves the API open