,

Device Bound Session Credentials: Why a Stolen Cookie May Stop Working

By Editorial Team Published 7 min read
Two matching teal tickets sit beside a metal press with a brass key in its lock under a clear cover

At 10:00, Maya signs in to a project dashboard with a passkey. At 10:07, an attacker copies her session cookie and presents it from another computer. The website may still accept it. Maya’s passkey did its job at sign-in; the site now checks a different credential.

At 10:10, the cookie expires. Maya keeps working. The copy stops opening the dashboard.

That last part takes deliberate design. Device Bound Session Credentials (DBSC) let a website require proof of possession of a private key before renewing a short-lived session cookie. The attacker may be able to use the ticket, but copying the ticket does not copy the means to renew it. [1, 2]

Why a Good Login Can Leave Behind a Copyable Credential

HTTP does not remember who sent yesterday’s request. A website can use an HTTP cookie to recognize a logged-in browser on later requests. The cookie might contain a random identifier that points to a server-side session. It need not contain a password or even a username. [3]

If the server accepts possession of that value as sufficient proof of the session, the value acts as a bearer credential. Once copied, it can be presented again while the server still accepts it. The server may see a valid cookie on a perfectly good HTTPS connection from the wrong client.

The usual protections still matter. HTTPS and the Secure attribute help keep cookies off unencrypted connections. HttpOnly prevents ordinary page scripts from reading the cookie through the usual script API. SameSite controls when the browser sends it in cross-site contexts. These controls address useful parts of the problem; they do not make a stolen bearer value prove where it came from. [3, 4]

How Device Bound Session Credentials Work

A supporting browser and a participating website cooperate. During session registration, the browser creates a key pair and proves possession of the private key. The site associates the public key with that session. In Chrome’s Windows implementation, a trusted platform module (TPM) can protect the private key so the browser can use it for signing without normally exporting it. [1, 2, 5]

Think of a transit ticket that can last for ten minutes. The station still checks tickets at the gate. It asks for stronger proof at the renewal desk. That distinction is why DBSC can fit into an application that already relies on cookies.

  1. Register. The site initiates registration from an authenticated context, for example with the Secure-Session-Registration response header. The browser and server establish the session’s key association, the cookie it needs, and where to renew it.
  2. Use a short-lived cookie. The browser presents it for ordinary in-scope requests. The application can keep checking the cookie as before, with the server enforcing its shorter lifetime.
  3. Prove possession when renewal is needed. If an eligible request needs a cookie that is now missing or expired, the browser can hold the request while it tries to refresh. It signs a challenge supplied by the server using the registered private key.
  4. Issue a new cookie. The server checks the signed proof against the public key registered for that session and verifies that the session is still allowed to continue. If the checks pass, it issues a new short-lived cookie and the browser can send the deferred request. [1, 2]

The private key stays on the client during normal operation. The proof goes to the server. The server asks for proof at renewal; this design does not require every application request to be signed.

Back to Maya. Suppose the service issues a cookie at 10:00 that it will accept until 10:10. The attacker steals only that one value at 10:07, and Maya’s device remains under her control. Here is what happens if the service requires a valid short-lived cookie for the protected dashboard.

TimeMaya’s registered browserAttacker with the copied cookie
10:00Signs in and receives the short-lived cookie after registration.Has no session credential.
10:07Uses the cookie for ordinary requests.May get up to three minutes of access with the copy.
At or after 10:10On an eligible request, can prove possession of the key and obtain a fresh cookie if the session is still valid.The old value fails server validation. A copy of that value cannot sign the renewal challenge.

Ten minutes is an example, not a limit set by the protocol. Nothing gets erased on the attacker’s machine at 10:10. The server stops honoring the old value. That matters because browser-side expiration alone cannot stop a client from sending a saved string manually. The server needs an actual expiration check, such as an expiry in its session record or one it verifies in the credential. [2, 3]

A short lifetime also does not undo anything the attacker managed to do before expiry. If an operation is too sensitive to rely on a recently copied cookie alone, the application can require a separate authorization or a fresh authentication step.

What the Binding Protects—and What It Leaves Open

The intended win is against remote replay after cookie theft. Malware that exports a cookie should have a harder time turning that one value into a durable session on a different machine. The design is much less helpful if the attacker can keep acting through the victim’s browser. Code already running on the endpoint may ride the active session or use signing capabilities there without ever exporting the key. A device compromised during registration is another case the design does not solve. [1]

The server also learns something narrower than “this is Maya’s healthy laptop.” A successful renewal demonstrates possession of the registered key. The strength of the binding depends on how that key was generated and protected. The mechanism is not a general device health check or proof that the human is still at the keyboard. [1]

Three controls are easy to confuse because they all appear around a login:

ControlWhat it addresses
Passkeys / WebAuthnStrong user authentication for a site. An application can also ask for a fresh authentication at a sensitive moment. [6]
DBSCContinuity of a web session: proof of possession when the browser renews its short-lived cookie. [1, 2]
OAuth DPoPSender-constraining OAuth tokens to a key in a protocol designed for those tokens. It is separate from a browser renewing a website’s cookie. [7]

An identity provider can authenticate somebody for a site, and the site can then issue a separate cookie of its own. Protecting the identity provider’s session does not automatically protect every application’s session. Likewise, in device code phishing, an attacker may get tokens issued to a client they set up themselves. That is a different path to access from stealing a cookie out of an already registered browser.

What to Check Before Turning It On

Google announced availability in Chrome 145 on Windows. That is a confirmed shipping milestone, rather than a promise about every browser, device, or website. As of November 14, 2026, the W3C publication record listed a First Public Working Draft, and the work also had a newer editor’s draft. Check the actual browser and operating system combinations your users run, and remember that the site must implement registration and refresh. [1, 2, 5, 8]

For a pilot, pick an operation you can observe, such as opening the dashboard after the test cookie expires. Run the following checks in a test environment you control:

  • Verify renewal, expiration, and revocation separately. The registered browser should renew successfully. An expired value must fail server-side. A revoked session must not be renewed even by a browser that can still sign with the original key.
  • Test the fallback as a security decision. Unsupported clients and temporary refresh failures need a defined outcome. If an older, long-lived cookie can still authorize the same protected operation or obtain a replacement without the key, an attacker may never need to defeat the binding.
  • Measure the cost of renewal. Track refresh latency, failures, and the share of users on a fallback path. If you shorten the cookie lifetime, watch how often real requests have to wait for refresh. Keep cookie values and proofs out of diagnostic logs. [1, 2]

A password, passkey, or other sign-in method gets the user through the door. After that, ask what keeps the session alive. If a copied value can keep renewing itself, the next place to improve is the renewal desk.

References and Further Reading

  1. W3C: Device Bound Session Credentials, Editor’s Draft — work in progress; scope, key possession, and threat-model limits.
  2. Chrome for Developers: Device Bound Session Credentials — browser and server integration, registration, renewal, and fallback.
  3. RFC 6265: HTTP State Management Mechanism — cookie delivery, persistence attributes, and security considerations.
  4. HTTP State Management Mechanism, RFC 6265bis Internet-Draft — source for SameSite semantics; work in progress.
  5. Chrome for Developers: Device Bound Session Credentials Now Available on Windows — Chrome 145 milestone and TPM-backed implementation.
  6. W3C: Web Authentication Level 3 — public-key authentication for web applications.
  7. RFC 9449: OAuth 2.0 Demonstrating Proof of Possession — sender-constrained OAuth tokens and their security properties.
  8. W3C: Device Bound Session Credentials Publication History — formal publication status.

Network Encyclopedia Editorial Team

Every entry is written, reviewed and kept up to date by our editors. Spotted a mistake? We fix it in the open.

Editorial Mission · Correction Policy · Suggest a correction