Join our Newsletter — 33% off our NHI Course
Home› Guides› Device-Bound Session Credentials (DBSC) Guide: Making Stolen Session…
Guide Authentication

Device-Bound Session Credentials (DBSC) Guide: Making Stolen Session Cookies Useless

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 15 min read
On this page

A session cookie copied off a laptop by an infostealer works just as well on the attacker's machine, and MFA has already been passed by the time it is stolen. Device-Bound Session Credentials (DBSC) changes that by tying a browser session to a private key held in hardware on the device, so the server can demand proof of possession before it renews the short-lived cookies that carry the session. This guide explains how the protocol works, where it stands in standardisation and in browsers, how to deploy it on your own sites and identity provider, and what it does not fix. It is written for identity engineers, web application owners and security architects who already understand cookie theft (see the Session Hijacking and Cookie Theft Guide) and want to move from detection to prevention.

Key takeaways

  • DBSC binds sessions, not users. At sign-in the browser creates a per-session key pair, ideally in a TPM, and registers the public key; afterwards only that device can obtain fresh session cookies.
  • Short cookies plus proof of possession is the whole design. The bound cookie lives for minutes; when it expires the browser signs a server challenge with the device key and the refresh endpoint issues a new one, so an exfiltrated cookie dies quickly.
  • Status is mixed: shipped in Chrome, still a draft at W3C. Chrome 146 made DBSC publicly available on Windows in April 2026 and Google accounts use it by default, while the W3C WebAppSec specification remains an Editor's Draft that is explicitly in early drafting.
  • It forces malware to stay local, it does not remove it. An attacker resident on the device can still drive the browser, and an attacker present at registration can bind the session to their own key; endpoint security and detection still matter.
  • Fallback is part of the deployment. Browsers without DBSC, devices without secure key storage and refresh failures all need a defined path, and how strict that path is decides how much protection you actually get.

The problem DBSC solves

Bearer session cookies are the weakest link left once phishing-resistant MFA is in place. Infostealer families harvest browser cookie stores at scale, and stolen session cookies are sold and replayed to skip sign-in entirely. MITRE ATT&CK tracks the theft as T1539 Steal Web Session Cookie and the replay as T1550.004 Use Alternate Authentication Material: Web Session Cookie; driving a live browser on the victim's machine is T1185 Browser Session Hijacking.

The CircleCI breach is the reference case: malware on an engineer's laptop stole a valid, 2FA-backed SSO session, and the attacker used it from elsewhere to reach production systems and customer secrets. No password or second factor was needed. Google's security team put the underlying problem plainly when announcing DBSC: once malware has access to a machine, software alone gives no reliable way to stop cookies being copied off it on any operating system. The fix therefore has to make the copied cookie worthless rather than try to keep it secret.

Earlier attempts at binding failed for practical reasons. Token Binding (RFC 8471) tied tokens to TLS keys but was never broadly implemented in browsers. DPoP (RFC 9449) and mutual TLS (RFC 8705) bind OAuth tokens well for API clients, but they do not cover the cookie-based sessions that most web applications and identity providers rely on. DBSC is aimed squarely at that cookie layer and is designed to sit alongside existing cookie infrastructure rather than replace it.

How the protocol works

The W3C Editor's Draft defines a small set of HTTP headers, a JSON session description and a signed proof JWT. The flow has three phases.

  1. Registration. After the user authenticates, the server sends a Secure-Session-Registration response header listing the signature algorithms it accepts (ES256, RS256) with parameters including the registration path and a challenge. The browser generates a new key pair for this session, protected by the TPM or equivalent where available, and posts a proof JWT (header typ of dbsc+jwt, the public key as jwk, and the challenge as jti) to the registration endpoint.
  2. Session instructions. The registration endpoint stores the public key and returns JSON describing the session: session_identifier, refresh_url, a scope (origin, whether to include the whole site, and include or exclude rules for paths), and credentials, the list of cookies (by name and attributes) that the browser must keep fresh. It also sets the first short-lived bound cookie.
  3. Refresh. When a request in scope would go out without a valid bound cookie, the browser defers that request and calls the refresh URL with a Sec-Secure-Session-Id header. The server answers with a Secure-Session-Challenge (Chrome's documentation shows this as a 403 carrying the challenge), the browser signs it with the session key in a Secure-Session-Response, and the server verifies the signature against the registered key and issues a new cookie. The original request then proceeds.

Because hardware signing is relatively slow, the design keeps the key out of the normal request path: ordinary requests carry an ordinary cookie, and only the refresh touches the TPM. That is why cookie lifetime is the main tuning knob. Chrome's developer documentation uses a 10-minute bound cookie in its example. The browser may also refresh proactively before expiry so users do not see the deferral.

Reference: DBSC headers and fields

ElementDirectionPurpose
Secure-Session-RegistrationServer to browserStarts registration; lists accepted algorithms, registration path, challenge and optional authorisation value
Proof JWT (typ: dbsc+jwt)Browser to serverSigned with the session key; carries the challenge as jti, and the public jwk at registration only
Session instructions (JSON)Server to browsersession_identifier, refresh_url, scope, credentials, optional allowed_refresh_initiators
Sec-Secure-Session-IdBrowser to serverIdentifies which session a refresh belongs to
Secure-Session-ChallengeServer to browserFresh challenge for the browser to sign on refresh
Secure-Session-ResponseBrowser to serverSigned proof answering the challenge
Secure-Session-SkippedBrowser to serverTells the server a refresh was skipped and why (for example unreachable, server_error, quota_exceeded)
/.well-known/device-bound-sessionsPublished by serverDeclares registering, relying and provider origins for federated and multi-origin set-ups

These names come from the Editor's Draft as it stood when checked on 27 October 2026. The draft is under active change, so confirm names and semantics against the current text before you build to them.

Standards and browser status

ItemStatus (checked 27 October 2026)What it means for you
W3C specificationEditor's Draft in the Web Application Security Working Group (webappsec-dbsc), marked as very early drafting; editors from Google, with a former editor from AppleNot a Recommendation; header names and JSON fields may change
Chrome on WindowsPublicly available from Chrome 146 (Google announcement, April 2026), using the TPM for key protectionThe main platform you can rely on today
Chrome on macOSAnnounced as planned, using the Secure EnclavePlan for fallback on Mac fleets until it ships
Google accountsGenerally available in Chrome on Windows from May 2026, on by default, with no admin control to switch it offWorkspace tenants already get it; binding events appear in audit logs
Other browsersNo shipped implementation found in the sources checkedTreat as unsupported and design the fallback

Google says it developed DBSC with Microsoft, that two origin trials ran before launch (Okta took part), and that it saw a significant reduction in session theft for protected accounts, without publishing figures. Do not quote a percentage that the primary sources do not give.

Deploying DBSC on your own site or identity provider

The highest-value place for DBSC is the session at your identity provider or SSO portal, because that cookie mints access to everything downstream. Next come high-value applications that keep their own long sessions: admin consoles, CI/CD platforms, finance and support tools.

  1. Inventory session cookies. List every cookie that carries authentication state on the target origin, its lifetime and whether it is HttpOnly, Secure and SameSite. DBSC needs HTTPS, and Chrome's documentation states that Partitioned cookies are not supported. See the Cookie Security Guide.
  2. Split the session. Keep a long-lived session record server side, and issue a short-lived bound cookie that the server checks on every request. Decide whether to keep a long-lived fallback cookie for browsers that do not register; Chrome's documentation describes this as optional.
  3. Add the registration step after authentication. Return Secure-Session-Registration on the response that completes sign-in, with a fresh, single-use challenge. Store the public key against the server-side session, never in the cookie.
  4. Build the refresh endpoint. Validate Sec-Secure-Session-Id, issue short-lived challenges and reject stale or reused ones, verify the signature against the stored key, and only then set the new cookie. The draft warns about a timing side channel on the refresh endpoint: keep CORS narrow and set X-Frame-Options or Cross-Origin-Resource-Policy so other sites cannot probe it.
  5. Handle errors deliberately. Chrome falls back when the network or server fails, the TPM is busy, or third-party cookies are blocked, and the spec defines Secure-Session-Skipped reasons. Log every skip and decide per application whether a skip means continue, step up or sign out.
  6. Pilot, then enforce. Start in observe mode: register sessions and log refresh outcomes without rejecting unbound cookies. Measure registration rate by browser and platform, then enforce for supported clients. Rollback is simple if designed in: stop sending the registration header and fall back to the long-lived cookie.
  7. Wire up sign-out. Ending the server-side session must also invalidate the bound key. Clear-Site-Data clears DBSC sessions in the browser, and the spec ties session and key lifetime to site data. See the OpenID Connect Logout and Session Management Guide.

Federated and multi-origin sessions

The draft adds a federated model in which one origin acts as the Session Provider and relying origins accept sessions bound to the provider's key, using parameters such as provider_key, provider_session_id and provider_url, plus the well-known file listing which origins may register and rely. The guidance is that relying parties should accept only sessions whose keys come from the provider. This part of the draft is the least settled; build single-origin first and add federation when the text stabilises.

Choosing a session binding approach

ApproachWhat is boundBest fitLimits
DBSCBrowser session cookies to a per-session device keyWeb apps and IdP sessions used in Chrome on WindowsDraft spec; limited browser and OS coverage; resident malware still acts locally
Microsoft Entra Token ProtectionSign-in session tokens (Primary Refresh Token) to the deviceMicrosoft 365 and Entra-protected resources via Conditional AccessNative Windows clients first; browser support for Azure Resource Manager is in preview; requires joined or registered Windows 10+ devices
DPoP (RFC 9449)OAuth access and refresh tokens to a client keySPAs, mobile and API clients you controlNot a cookie mechanism; software keys unless the client uses hardware
Mutual TLS (RFC 8705)OAuth tokens to a client certificateService-to-service and high-assurance API clientsCertificate lifecycle overhead; poor fit for consumer browsers
Short sessions and reauthentication onlyNothing; reduces the windowStop-gap where binding is not availableStolen cookie works until expiry; user friction

Decision guidance: on Microsoft 365, enable Token Protection through Conditional Access for supported clients and let DBSC protect the Google or custom web sessions alongside it; on your own web estate, start DBSC at the IdP; for API clients, prefer DPoP or mTLS. Small organisations that rely on a SaaS IdP should check whether the provider already supports DBSC and turn it on rather than build it. Large organisations with their own login service should treat DBSC as a session platform change with a named owner, because refresh endpoint availability becomes part of sign-in availability. For the token side, see the Entra ID Primary Refresh Token Security Guide and the Token and Session Security Guide.

What DBSC does not stop

  • Resident malware: the draft's security considerations are explicit that DBSC does not prevent access while the attacker is on the device. It turns remote replay into local abuse, which is noisier and easier for EDR to catch, but it does not end it.
  • Compromise at registration: if the attacker controls the browser when the session is created, they can bind it to a key they hold. Pair DBSC with phishing-resistant sign-in. See the Passwordless and Passkeys Guide.
  • Device trust: DBSC makes no claim about the device. There is no attestation and no stable device identifier, by design for privacy. If you need device compliance, use your device management and Conditional Access signals separately.
  • Unbound cookies: any authentication cookie left outside the session's credentials list, or any long-lived fallback cookie accepted from all clients, remains a bearer credential. Coverage gaps undo the control.
  • Tokens outside the browser: OAuth refresh tokens in desktop apps, CLI tokens and API keys are not touched. Infostealers take those too. See the Infostealer Threat Guide.

Where identity fits

DBSC is a session control, but its value depends on identity hygiene around it. Administrative and privileged web sessions should be the first enforced, with no fallback cookie accepted for them. Shared kiosks and virtual desktops without a TPM will fall back, so treat those sessions as higher risk and keep them short. Service accounts and automation that use browser sessions (for example scripted access to a SaaS console) should not be doing so at all: move them to API credentials with their own binding and rotation.

Detection and measurement

Log the registration and refresh events your servers see: session identifier, public key thumbprint, registration outcome, refresh success or failure, Secure-Session-Skipped reason, user agent and source IP. Google Workspace tenants can see binding events in the security investigation tool audit logs. For Entra Token Protection, Microsoft recommends report-only mode and analysis of interactive and non-interactive sign-in logs before enforcing.

  • Signal: refresh failures with a valid session identifier. A signature that fails verification, or a refresh attempt from a different network minutes after a successful one, suggests a stolen cookie being replayed.
  • Signal: unbound cookies on enforced sessions. Requests presenting a fallback or long-lived cookie for a session that registered successfully should not happen.
  • Signal: repeated registration. Many new sessions for one user in a short time may indicate an attacker re-registering from their own browser after a credential theft.

Metrics that show it is working:

  1. Percentage of authenticated sessions that registered a DBSC key, by browser and OS.
  2. Percentage of privileged sessions protected with no fallback accepted (target 100%).
  3. Median and 95th percentile refresh latency, and refresh error rate.
  4. Count of skips by reason per week, trending down as coverage improves.
  5. Session replay detections per month, and time from detection to session revocation.

Framework mapping

FrameworkReferenceHow DBSC supports it
NIST SP 800-53 Rev 5SC-23 Session AuthenticityProof of possession on refresh protects session authenticity against replay
NIST SP 800-53 Rev 5AC-12 Session Termination; IA-11 Re-authenticationShort bound cookies and server-side key revocation make termination effective
NIST CSF 2.0PR.AA-03; DE.CM-09Authenticates the session holder; refresh logs feed monitoring
OWASP ASVS 5.0V7.2.1; V7.3.1Session token verification at a trusted backend and session timeout requirements
MITRE ATT&CK v20T1539; T1550.004; T1185Defeats remote replay of stolen cookies; does not prevent local browser hijacking

Common failure patterns

  • Binding one cookie and leaving another. Applications often have a legacy "remember me" cookie or an API cookie that also authenticates. If it is not in the session's credentials list, attackers simply steal that one instead.
  • Accepting the fallback from everyone. Keeping a long-lived cookie for unsupported browsers is reasonable; accepting it from browsers that did register removes the protection.
  • Cookie lifetimes left long. A bound cookie that lives for a day gives a stolen copy a day of use. Keep it in the minutes range and tune by measured refresh cost.
  • Weak challenge handling. Reusable or long-lived challenges, or challenges not tied to the session, invite replay of signed responses. Issue single-use, short-lived challenges.
  • Treating DBSC as endpoint protection. The CircleCI breach would have been harder to exploit remotely with bound sessions, but the malware on the laptop would still have had local access. Keep EDR and response playbooks in scope.
  • Building to the draft without tracking it. Header or field changes in the specification can silently break registration. Pin to the browser behaviour you have tested and recheck at each Chrome release.

Practitioner checklist

  • Confirm which of your user browsers and operating systems support DBSC today, and size the fallback population.
  • Inventory every authentication cookie on the IdP and high-value apps, and list which will be bound.
  • Split sessions into a server-side record and a short-lived bound cookie of minutes, not hours.
  • Implement registration and refresh endpoints with single-use challenges, signature verification, narrow CORS and anti-framing headers.
  • Run in observe mode, measure registration and refresh outcomes, then enforce for supported clients.
  • Refuse the fallback cookie for privileged sessions and for any session that registered successfully.
  • Revoke the stored public key on sign-out, password reset and incident response, and send Clear-Site-Data.
  • Turn on Entra Token Protection in report-only mode where you run Microsoft 365, then enforce.
  • Alert on refresh signature failures, unbound cookies on enforced sessions and bursts of re-registration.
  • Recheck the W3C draft and Chrome release notes each quarter and record the version you build to.

Standards and references

Related NHI Mgmt Group resources: Session Hijacking and Cookie Theft Guide · Token and Session Security Guide · Infostealer Threat Guide · Entra ID Primary Refresh Token Security Guide

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.