Why Outlook can, and why we will not
The Microsoft 365 sign-in prompt: what removes it, what that costs, and the decision we have taken
| Date | 07/09/2026 |
| Who it is for | Anyone asking why a desktop or Office application signs in each time it starts, when Outlook does not. |
| Position | This note explains the technology, the trade-off, and our position on it. It does not describe the internals of any particular product. |
| Preparation | Researched and drafted with Claude (Anthropic) across several hours of iteration and challenge. The analysis and conclusions are ours; every factual claim carries a reference to its primary source, so nothing here has to be taken on trust. |
| References | Numbered markers point to the reference list in section 12. Each carries the wording it rests on. |
The question
“Users are prompted to sign in every time the application starts. Outlook does not do that. Chrome does not do that. Can the token not be taken out of the authentication library, protected with Microsoft’s own cryptography, and loaded back in next time?”
Both comparisons are fair and both are worth answering properly, so this note starts with them. Outlook first, because it is the closest parallel. Chrome second, because Chrome tried precisely the mechanism being proposed.
1. Outlook: the comparison, and where it breaks #
Outlook does start most mornings without asking, and the reason is not that it is compiled, or Microsoft’s, or somehow privileged. It is that Windows holds its long-lived credential and hands it short-lived passes on request. We could do the same thing. The question is what happens next.
| Outlook today | A theoretical VBAuth that could remember you between application sessions | |
|---|---|---|
| What holds the long-lived credential | Windows | Windows, or a protected file. A design detail on our side, and it changes nothing else in this table. |
| Does the user get asked each morning | No | No. That is the entire point of the change. |
| Can another program running as that user obtain a token with it | Yes1 | Yes |
| Does anything ask a human first | No | No |
| What does the resulting token open | The signed-in user’s own data across Microsoft 365. Wide — desktop Office is one of a family of client applications, and a token issued to one can be redeemed as another2 — but never more than that user already holds | Whatever the registration was granted, which can include directory-level permissions no Microsoft client holds |
| Who decided what it opens | Microsoft, once, for every installation | Your developer chooses what to ask for; the permissions that matter here need your Microsoft 365 administrator’s consent |
| Can anyone find out what it opens | Yes. The list is published and has been studied3 | Only by reading your own registration — and it changes whenever a feature is added |
| Who owns the controls around it | Microsoft: device binding, Conditional Access, Continuous Access Evaluation, and the detections that fire on misuse | Your Microsoft 365 administrator, to the extent any of it is configured |
Read the first four rows and the two columns are identical. The mechanism is the same, the silence is the same, and the exposure to other programs on that machine is the same. Read the last four and what separates them is not the size of the risk — it is who is holding the controls.
1.1 We are not claiming Outlook is safe #
It is worth being straightforward about this, because anyone who follows security news will already know it. Outlook’s identity can be abused, and is. A desktop application cannot keep a secret, so the sign-in service has no way to tell one caller from another — the standard says it “MUST NOT rely on public client authentication for the purpose of identifying the client”.4 A program running as you can present Outlook’s identifier and ask for tokens exactly as Outlook does.
This is not speculative. Published research has shown that a refresh token issued to one Microsoft application can be redeemed for tokens belonging to others in the same family, giving the holder “the union of all scopes in the family” — and desktop Office is on the published list of those applications.5 Microsoft themselves publish an incident-response playbook for token theft, defining it as an attack in which “threat actors compromise and replay tokens issued to a user, even if that user has satisfied multifactor authentication”, and Defender for Endpoint watches for suspicious access to Primary Refresh Tokens and associated artefacts on Windows 10 and 11.6
None of which rescues the comparison — it sharpens it. It means Outlook and a remembering VBAuth would carry the same exposure, and that the only thing separating them is who controls what happens next.
2. Chrome: what happened when this was tried #
Chrome protected its local credential store on Windows with DPAPI — precisely the mechanism the question proposes, applied by an engineering organisation with resources nobody in this market can match. Google’s own description of what that bought them is exact: DPAPI “protects the data at rest from other users on the system or cold boot attacks”, but “does not protect against malicious applications able to execute code as the logged in user – which infostealers take advantage of”.7
That was a defensible design. What defeated it was not the cryptography but who came looking: Google’s own account, quoted above, names infostealers as precisely what DPAPI does not stop — and Google’s response was to change the mechanism rather than to strengthen the encryption.
That answer, in Chrome 127, was App-Bound Encryption — tying decryption to the identity of the requesting application through a privileged service, “similar to how the Keychain operates on macOS”. They record the intention to extend it from cookies to “passwords, payment data, and other persistent authentication tokens”.8
The last item on that list is what a remembered sign-in is.
So the honest reading of “Chrome does it” is that Chrome did do it, and then had to build something else. And even that something else raises the cost rather than closing the door: Google says plainly that “malware can bypass this protection by running elevated”.9 We would rather not create the problem in the first place.
One further point, which is uncomfortable and worth stating anyway. The industry catalogue of adversary techniques notes refresh token theft in passing, in these words: “However, in some cases, adversaries can also steal application refresh tokens, allowing them to obtain new access tokens without prompting the user.”10 We would not be stealing anything, and the comparison stops well short of that. But the outcome an attacker is working towards — new access tokens, on demand, without anyone being prompted — is the outcome we would be building in, by design, on every machine where the software is installed.
3. Why we are not doing it #
Today VBAuth holds its tokens in memory and writes nothing to disk, so when the application closes there is nothing left for the next session to use: the next token needs a person to sign in. That sign-in is the only remaining moment at which a person has to be present and act. Remove it — however it is built — and tokens become available on demand and in silence to any program running as that user. Ours, and everything else on that machine.
Microsoft removes it for Outlook, and for Microsoft that is a defensible trade — though not because Outlook’s reach is modest. It is not. Desktop Office sits in a family of client applications, and a refresh token issued to one member can be redeemed as another, including Microsoft’s own command-line management tools.11 What makes the trade defensible is the ceiling underneath it: every one of those applications acts as the signed-in user and can do nothing that user could not already do by hand. For most people that is a real limit. And Microsoft owns everything around it — the registration, the device binding, the Conditional Access surface, and the detections that fire when a token turns up where it should not.
The same ceiling exists for us, and it holds up less well. The reach is whatever your registration was granted, and it can include permissions no Microsoft application carries — reading and writing the directory, or the app registrations themselves. Those are still bounded by the rights of whoever is signed in, which is precisely the difficulty: the person running an administrative database is usually the person who has those rights. The controls belong to your Microsoft 365 administrator, if they are configured at all, and several need a licence tier not every tenant has.12 Nobody has published what your registration reaches, and in our experience nobody has enumerated it either.
Same mechanism, same silence. What differs is that Microsoft knows where its ceiling sits and holds every control beneath it, and in your case the ceiling is wherever your administrator’s own permissions happen to stop.
Removing the last human checkpoint from an application whose reach we do not control is not a decision we will take on your behalf.
The rest of this note is the supporting detail: what the two tokens are and why only one of them matters, why the refresh token is not simply handed out, and what the supported alternatives actually protect. Section 4 defines the terms it uses.
4. The terms used in this note #
| Term | What it means here |
|---|---|
| Access token | The short-lived pass the application sends with every request to Microsoft 365. A bearer access token can be used by whoever holds it. Microsoft’s default lifetime is variable, between 60 and 90 minutes, averaging 75.13 |
| Refresh token | The longer-lived credential issued alongside it. It is not sent to Microsoft 365; it goes back to the sign-in service to obtain a fresh access token without involving the user. This is the one that makes a sign-in last. |
| The authentication library | MSAL, the Microsoft Authentication Library. It performs the sign-in, holds both tokens, and hands access tokens to the application. Referred to below as “the library”. |
| Token cache | Where the library keeps those tokens. On Windows desktop it is in memory unless the application implements serialisation for itself, which Microsoft documents as an explicit step the developer takes.14 |
| App registration and client ID | The entry in the organisation’s Microsoft 365 directory representing the application, identified by a GUID called the client ID. That ID is a public identifier. |
| Scopes and consent | The permissions the registration was granted — read the user’s mail, create calendar events, and so on. A delegated token is bounded by these, and separately by the rights of the person signed in. |
| Public client | An application running on the user’s own machine. Microsoft’s definition is that such applications “can’t be trusted to safely keep application secrets”.15 |
| DPAPI | The Data Protection API: the Windows service that encrypts data so that, in CurrentUser scope, “only threads running under the current user context can unprotect the data”.16 |
| The broker | A Windows component that holds accounts on behalf of applications — “a Windows component that ships with the OS” which “acts as an authentication broker allowing the users of your app to benefit from integration with accounts known to Windows”.17 |
| Conditional Access | Policy set by the organisation’s Microsoft 365 administrator governing when and how users must reauthenticate. It overrides anything the application does, and it requires an Entra ID P1 or P2 licence.18 |
| Entra ID | Microsoft’s identity service, formerly Azure Active Directory. It issues the tokens and holds the app registrations. |
5. Two tokens, and only one of them matters #
The question refers to “the token”. Two are issued in the flow under discussion, and they differ in lifetime, in who holds them, and in what they are worth.
| Access token | Refresh token | |
|---|---|---|
| Lifetime | 60 to 90 minutes, varying with the client, the resource and whether Conditional Access is in force. Up to 28 hours in a Continuous Access Evaluation session.19 | Expires after 90 days of non-use. No maximum age while in use; the default is “Until-revoked”.20 |
| Returned to the application | Yes | No. No member of the published API returns one.21 |
| Requirement to use | Possession alone | Possession, plus the client ID, which is a public identifier because a public client cannot hold a secret.22 |
| Value if stolen | Access at the consented scopes until expiry | New access tokens for as long as it survives |
Persisting the access token is therefore possible but of little use: 60 to 90 minutes of cover in the ordinary case, in exchange for a permanent file holding a live credential that works for anyone who can read and replay it. Even where Continuous Access Evaluation stretches that to as much as 28 hours,23 it does not deliver what the question was asking for.
Persisting the refresh token is what would remove the prompt. The 90 days is Entra ID’s default maximum inactive time; refresh token lifetimes have not been adjustable through token lifetime policies since 30/01/2021, and Conditional Access sign-in frequency is the supported means of requiring periodic reauthentication.24, 25
6. Why the library will not hand you the refresh token #
The library has no published method that returns a refresh token. That is deliberate — its security model rests on the credential never leaving it. One method moves a refresh token the other way, accepting one an application already holds; Microsoft documents it for migration from the library MSAL replaced, “and in various integration scenarios where you have a RefreshToken available”.26 It does not help here.
Obtaining one means serialising the library’s token cache and reading the secret out of the result. Two things follow.
The serialisation entry points are documented; the internal structure of what they return is not.27 It should be treated as the library’s own working representation rather than a public schema, which means code that reaches inside it depends on something nobody has undertaken to keep stable. (Our assessment, not a documented Microsoft position: the breakage would surface as an authentication failure on customer machines rather than as a build error, which is the worst place to find it.)
Serialising the whole cache to reach one field inside it is already the work of persisting the cache, done by hand and less well than the library does it. There is a supported way to persist it, in section 9. The extraction adds risk and nothing else.
7. Why the calling code is the wrong place for it #
Suppose the extraction were solved. The proposal then has the calling code — typically VBA in an Access or Excel file — receive the refresh token as a string and look after it.
| It cannot be held safely in memory | VBA gives a developer nothing with which to hold a secret carefully. (Our assessment as VBA developers rather than a documented limitation:) strings are BSTRs, the string type COM uses; assignment copies them, the runtime decides when those copies go, and VBA offers no way to pin one in place or to overwrite it when finished with. Anyone who can open an unprotected VBA project can set a breakpoint and read the value straight out of the Locals pane — which needs no documentation, only a copy of the file. |
| It reaches disk by accident | The obvious way to keep a value between sessions is to put it in a table, which writes a long-lived credential into the database file in clear. From that point the credential travels wherever the file travels — into backups, onto shared drives, into whatever copy someone takes to test against. |
| It is worth more than what it replaces | A refresh token survives 90 days of inactivity and has no maximum age by default.28 It is the more persistent of the two credentials and the one that regenerates the other, and this moves it into the weakest available container. |
| There is no second lock behind it | Because desktop and Office applications are public clients, no application secret guards redemption.29 |
| It moves the problem to the wrong party | The security of the credential shifts from the library, where it can be reasoned about and tested once, to every individual developer’s code, where it cannot. |
8. What “protected with Microsoft’s own cryptography” actually means #
On Windows it means DPAPI, and it is the right mechanism for its purpose — it is what Microsoft’s own documented route for desktop applications uses.30 Windows looks after the key material itself, so there is nothing to install and no key for the application to manage. What matters here is not how that key is derived but who stands inside the boundary it draws.
8.1 The boundary is between users, not between programs #
DPAPI in CurrentUser scope means that “only threads running under the current user context can unprotect the data”.31 Every program running as the signed-in user is inside that boundary — their own applications, add-ins, anything started from a macro-enabled document, and any malware that has arrived in that session. To Windows they are all the same principal.
Such a program does not attack the encryption. It calls the same documented function the legitimate application calls, passes the same file, and Windows returns the plaintext. There is nothing to break.
And this is the point at which the two halves have to be read together, because it is the most common misreading of the whole subject. DPAPI protects the file, not the token. The file cannot be carried to another machine and opened there — true. But an attacker has no reason to move it. They are already running as the user, on the machine, in the one context where Windows will open it for them.
One call, and they hold the refresh token as a plain string, which from that instant is portable and redeemable from anywhere. The ninety days is an inactivity limit, not an expiry date: a token that keeps being used keeps working, and by default there is no maximum age at all.32 Cleaning the machine does not end it. Only revocation does.
| DPAPI in CurrentUser scope stops | It does not stop |
|---|---|
| Another user of the same machine reading the file | Any program running as that user — a macro in another document, an add-in, ordinary malware — because it can ask Windows to decrypt it, exactly as the legitimate application does |
| The file being copied to another machine and opened there | That same program reading the token on the machine and sending the plaintext elsewhere |
| An offline copy of the file on its own | Anything able to execute in that user’s session on that machine |
| Anyone browsing the disk out of curiosity | Anyone who can reach the machine as that user |
Nor does any variation escape this. The key has to be available to the application at runtime, and anything running as that user has the same access to it. Adding a fixed additional entropy value to the encryption — DPAPI supports one — does not help if the value is compiled into the application, because the same program can read the application.
9. What Microsoft provides instead #
Two supported routes reach the outcome the question was aiming at, and neither asks the application to touch a refresh token. Which one an application chose would be a design decision; section 3 is why neither is being taken.
The first has the library persist its own cache. It hands the application an opaque block of bytes and takes it back on the next run; the application protects the bytes and never sees a token. Microsoft directs desktop applications to its cross-platform cache helper for this, which on Windows protects the block with DPAPI — so the supported route has exactly the properties described in section 8.33 It cannot suppress the first sign-in on a machine, because the cache must be created by a real sign-in before it can prevent one.
The second has Windows hold the credential. The broker is available on Windows 10 version 1703 and later.34 The application never receives the refresh token: the broker hands back only the access token and keeps the refresh token itself, encrypted with DPAPI, in its own store. For a user signed in to Windows with that account it is bound to the device, so a copy lifted off the machine is worth nothing elsewhere; for a user who is not, Microsoft states that it is not device-bound.35
It carries a native component, and it requires a redirect URI to be added to the application’s registration in the customer’s own directory. (Our position, not a documented Microsoft one: enabling brokered acquisition changes what that registration can be used for on every machine where the application runs, and that is the customer’s call to make rather than ours.)
It also has no first-run limitation. On a device joined to the organisation’s directory the library can be asked for a token silently against the account already signed in to Windows,36 which means the prompt need never appear at all — not on the first run, not on any run.
It is worth saying plainly that the second is a good design. For a user signed in to Windows with that account, device binding takes away the portable credential — the part with an industry behind it — because there is no longer anything worth carrying off the machine.
What it does not take away is the exposure described in section 3. Code running as that user can still ask the broker for a token, silently, at whatever the registration was granted. Nothing removes that, because it is the feature.
10. What any of it relies on #
Keeping a sign-in between sessions is not one control but a chain, and the links are not all held by the same people.
| Control | Who provides it | What it gives | What gets past it |
|---|---|---|---|
| Device-bound credential (broker) | Windows | The refresh token never leaves the device and the application never holds it | Code running as that user on that device, which can still ask the broker for a token |
| DPAPI encryption (cache file) | Windows | The file is useless to another user, or on another machine | Any code running as that user, which can read the token and send it anywhere |
| Windows session security | The organisation’s device management | Other users of the same machine cannot use this user’s authentication state | Anyone who has that user’s session |
| Minimal consented scopes | Whoever owns the app registration | Bounds what any token can reach, alongside the rights of the person signed in | Broad consent granted once and never revisited |
| Refresh token inactivity limit | Entra ID; not adjustable37 | Sessions left unused expire after 90 days | Regular use, which keeps the chain alive with no maximum age by default |
| Conditional Access sign-in frequency | The organisation’s Microsoft 365 administrator, where the tenant is licensed for it38 | Reauthentication on a schedule, whatever the application has cached | Not being configured, which is the default — and tenants without the licence cannot configure it at all |
| Continuous Access Evaluation | Entra ID and the resource39 | Revocation within minutes rather than at token expiry | Resources that do not support it |
| Revocation, or sign out everywhere | The administrator, or the user | Ends the session; tokens already issued survive to expiry unless Continuous Access Evaluation applies | It needs someone to notice first |
| The calling project itself | The developer | Nothing, if the project is left unlocked | An unlocked project on a shared drive |
Several of these belong to the organisation’s own Microsoft 365 administrator and IT, not to whoever wrote the application and not to the developer building on it. No library delivers a secure remembered sign-in by itself. It delivers one that is secure in an environment that has done its part.
11. Where that leaves you #
| Approach | Assessment |
|---|---|
| Extract the access token and encrypt it | An hour or so of cover in the ordinary case, in exchange for a permanent file holding a live credential. |
| Extract the refresh token and encrypt it | No published way to obtain one. It requires reading an internal structure that nobody has undertaken to keep stable. |
| Hand the refresh token to the calling code | Poor custody, disproportionate value, and it moves responsibility to the party least equipped to carry it. |
| Let the library keep an encrypted cache | Supported and documented. Protects the file, not the token: it does not separate the credential from other code running as the same user, which is the limitation Chrome ran into. Not adopted. |
| Let Windows hold the credential | Supported, and genuinely strong against a stolen file. Still removes the last human checkpoint, and requires a change to the app registration in your own directory. Not adopted. |
Three things are worth establishing in any organisation weighing this up, and none of them depends on a software decision:
What scopes have the relevant app registrations actually been consented for? Everything any token can reach is bounded by that answer and by the rights of the person signed in, and the first half is usually broader than expected.
Is Conditional Access sign-in frequency configured in the tenant — and is the tenant licensed to configure it at all? It sets the ceiling on how long any remembered session can last, and no application can or should work around it. It needs Entra ID P1 or P2, which not every organisation has.
What is the prompt currently worth? It is the only remaining point at which a person has to be present and act — which is worth pricing before deciding to remove it.
If a specific case makes the trade worth taking, that is a conversation worth having on its own terms, with the risk written down and accepted by the organisation carrying it — rather than assumed by us on their behalf, for everybody, by default.
12. References #
Numbered markers in the text refer to the entries below, grouped by source. All accessed 07/09/2026.
1. RFC 6749 — The OAuth 2.0 Authorization Framework, IETF #
[1] §2.1 defines public clients as “Clients incapable of maintaining the confidentiality of their credentials … and incapable of secure client authentication via any other means.” §2.3 states that the authorisation server “MUST NOT rely on public client authentication for the purpose of identifying the client.”
[4] §2.3: “The authorization server MUST NOT rely on public client authentication for the purpose of identifying the client.”
[22] §2.1, public clients are “incapable of maintaining the confidentiality of their credentials”.
[29] §2.1 and §2.3, as above.
2. Secureworks CTU — “Family of Client IDs” research, Ryan Marcotte Cobb and Tony Gore #
[2] “a family refresh token issued to any ‘family’ client application can be redeemed for new bearer tokens as a different client than the original access token.”
[3] The accompanying published list of family client applications includes Microsoft Office (d3590ed6-52b3-4102-aeff-aad2292ab01c), Microsoft Azure CLI (04b07795-8ddb-461a-bbee-02f9e1bf7b46) and Microsoft Azure PowerShell (1950a258-227b-4e31-a9cf-717495945fc2). Every entry is a public client using delegated permissions.
[5] “a family refresh token effectively provides the possessor with access to the union of all scopes in the family.” The research states that “FOCI is only mentioned once in official Microsoft documentation” and that “No further information was available on its purpose or functionality”.
[11] As [3]. The list includes Microsoft’s command-line management tooling as well as its productivity clients.
3. Microsoft Learn — “Token theft playbook” #
[6] “A token theft attack occurs when threat actors compromise and replay tokens issued to a user, even if that user has satisfied multifactor authentication. Because authentication requirements are met, the threat actor is granted access to organizational resources by using the stolen token.” Detection triggers include “Attempted access of Primary Refresh Token (PRT) – in Windows 10 and 11, Microsoft Defender for Endpoint detects suspicious access to PRT and associated artifacts.”
4. Google Online Security Blog — “Improving the security of Chrome cookies on Windows”, Will Harris, Chrome Security Team, 30/07/2024 #
[7] Chrome used “the Data Protection API (DPAPI) which protects the data at rest from other users on the system or cold boot attacks”; it “does not protect against malicious applications able to execute code as the logged in user – which infostealers take advantage of”.
[8] App-Bound Encryption, introduced in Chrome 127, lets Chrome “encrypt data tied to app identity, similar to how the Keychain operates on macOS”, beginning with cookies and planned to extend to “passwords, payment data, and other persistent authentication tokens”. It “relies on a privileged service to verify the identity of the requesting application”.
[9] “Since malware can bypass this protection by running elevated, enterprise environments that do not grant their users the ability to run downloaded files as Administrator are particularly helped by this protection.”
5. MITRE ATT&CK — “Steal Application Access Token”, Technique T1528 (Enterprise, Credential Access) #
[10] “Application access tokens may function within a limited lifetime, limiting how long an adversary can utilize the stolen token. However, in some cases, adversaries can also steal application refresh tokens, allowing them to obtain new access tokens without prompting the user.” The technique concerns access tokens; refresh tokens are noted within it.
6. Microsoft Learn — “Configurable token lifetimes in Microsoft Entra ID” #
[13] Access token default lifetime is “assigned a random value ranging between 60-90 minutes (75 minutes on average)”. The default “also varies depending on the client application requesting the token, the resource the token is issued for, and whether Conditional Access is enabled in the tenant.”
[20], [28], [32] “Refresh Token Max Inactive Time: MaxInactiveTime: 90 days”; “Single-Factor / Multi-Factor Refresh Token Max Age: Until-revoked”.
[24], [37] “As of January 30, 2021, refresh and session token lifetimes are no longer configurable through token lifetime policies. Microsoft Entra ID uses only the default values described below.”
7. Microsoft Learn — “Custom token cache for public client applications” (MSAL.NET) #
[14] Custom serialisation is implemented by the application through SetBeforeAccess / SetAfterAccess notification handlers with SerializeMsalV3 / DeserializeMsalV3.
[30] The documented route protects the serialised cache with ProtectedData.Protect / Unprotect using DataProtectionScope.CurrentUser.
8. Microsoft Learn — “Public client and confidential client applications” #
[15] Public clients “run on devices, such as desktop, browserless APIs, mobile or client-side browser apps. They can’t be trusted to safely keep application secrets”.
9. Microsoft Learn — “DataProtectionScope Enum” #
https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.dataprotectionscope
[16], [31] CurrentUser — “The protected data is associated with the current user. Only threads running under the current user context can unprotect the data.” LocalMachine — “Any process running on the computer can unprotect data.”
10. Microsoft Learn — “Using MSAL.NET with Web Account Manager (WAM)” #
[17] WAM is “a Windows component that ships with the OS … acts as an authentication broker allowing the users of your app to benefit from integration with accounts known to Windows, such as the account you signed into your Windows session”. “WAM ensures that the refresh tokens are device bound.”
[34] Available “on Windows 10 (Version 1703 – Creators Update) and above, as well as Windows Server 2019 and above”. “MSAL will automatically fallback to a browser if WAM cannot be used.” The broker requires the redirect URI ms-appx-web://microsoft.aad.brokerplugin/{client_id} on the app registration.
[36] The documented pattern calls AcquireTokenSilent with PublicClientApplication.OperatingSystemAccount to “sign in silently with the account that the user is signed into Windows”.
11. Microsoft Learn — “What is a Primary Refresh Token?” #
[35] “WAM only returns the access token to the app and secures the refresh token: If it is a refresh token for an SSO user, then this refresh token is bound to the device, with a session key (the same as PRT) or the device key. If it is a refresh token for a non-SSO user, then this refresh token is not bound to the device. All refresh tokens are encrypted by the DPAPI.” “WAM plugin provides only the access token to the application, while it reencrypts the refresh token with DPAPI and stores it in its own cache.”
12. Microsoft Learn — “Conditional Access adaptive session lifetime policies” #
[12], [18], [38] Conditional Access sign-in frequency is the supported means of requiring periodic reauthentication. Conditional Access requires a Microsoft Entra ID P1 or P2 licence. “The Microsoft Entra ID default configuration for user sign-in frequency is a rolling window of 90 days.”
[25] Sign-in frequency, as above.
13. Microsoft Learn — “Continuous access evaluation in Microsoft Entra” #
[19], [23] “Token lifetime increases to long-lived, up to 28 hours, in CAE sessions. Critical events and policy evaluation drive revocation, not just an arbitrary time period.”
[39] Near-real-time revocation on critical events, with “latency of up to 15 minutes”; initial support in Exchange Online, Teams and SharePoint Online.
14. Microsoft Learn — “IByRefreshToken.AcquireTokenByRefreshToken Method” #
[21] Observation about the published API surface rather than a quoted statement: MSAL.NET exposes no member that returns a refresh token. The only member typed to a refresh token is IByRefreshToken.AcquireTokenByRefreshToken, which accepts one.
[26] The method “can be used in migration to MSAL from ADAL v2, and in various integration scenarios where you have a RefreshToken available”. It accepts a refresh token rather than returning one.
15. Microsoft Learn — “Token cache serialization” (MSAL.NET) #
[27] The serialisation entry points are documented; the structure of the serialised data is not published as a supported contract.
[33] “When writing a desktop application, use the cross-platform token cache as explained in desktop apps.” On Windows that cache is protected with DPAPI.
VBAuth — https://vbauth.com | Copyright © 2025–2026 Peter Bryant (Corylus Business Systems) and Andrew Richards (The IT Service Ltd)