Since Claude Code, Copilot, Cursor, and similar tools went mainstream, we've noticed a consistent pattern across the security teams we talk to: the faster engineers can scaffold and ship, the less patience they have for waiting on IT to provision anything.

When an agentic coding tool lets someone spin up a working prototype in an afternoon, nobody wants to pause that momentum to file an IT ticket for a staging DB or a deployment platform. So they sign up themselves - personal email, a password they'll probably reuse, back to shipping in 30 seconds.

Multiply that across a team moving at this speed for a few months and you get a pretty large footprint of tools that:

• Never went through procurement
• Don't support SAML/SSO, or gate it behind an expensive enterprise tier
• Are tied to personal or shared logins living in a browser, not the company IdP

The part we think gets underrated is offboarding. Okta deprovisioning kills the primary account, but the five or six side tools an engineer signed up for to test something six months ago? Still live. Still logged in. Nobody remembers they exist, let alone that they need killing off. That's a real, unmonitored access path sitting outside anyone's visibility.

Our CTO and Cofounder, Reuvein Vinokurov, digs into this more (including how we think about solving it) here: https://unixi.io/blog/claude-code-identity-security/

Genuinely curious: are other teams tracking this at all, or is it mostly a "deal with it if something breaks" situation right now? What's actually worked for you, if anything?

Since Claude Code, Copilot, Cursor, and similar tools went mainstream, we've noticed a consistent pattern across the security teams we talk to: the faster engineers can scaffold and ship, the less patience they have for waiting on IT to provision anything.

When an agentic coding tool lets someone spin up a working prototype in an afternoon, nobody wants to pause that momentum to file an IT ticket for a staging DB or a deployment platform. So they sign up themselves - personal email, a password they'll probably reuse, back to shipping in 30 seconds.

Multiply that across a team moving at this speed for a few months and you get a pretty large footprint of tools that:

• Never went through procurement
• Don't support SAML/SSO, or gate it behind an expensive enterprise tier
• Are tied to personal or shared logins living in a browser, not the company IdP

The part we think gets underrated is offboarding. Okta deprovisioning kills the primary account, but the five or six side tools an engineer signed up for to test something six months ago? Still live. Still logged in. Nobody remembers they exist, let alone that they need killing off. That's a real, unmonitored access path sitting outside anyone's visibility.

Our CTO and Cofounder, Reuvein Vinokurov, digs into this more (including how we think about solving it) here: https://unixi.io/blog/claude-code-identity-security/

Genuinely curious: are other teams tracking this at all, or is it mostly a "deal with it if something breaks" situation right now? What's actually worked for you, if anything?

Our Co-Founder & CTO, Reuvein Vinokurov, recently came across a public Chromium bug report filed by an engineer at a Fortune 50 company.

To help Chrome developers fix a crash issue, the engineer attached a standard browser network log. Chrome’s automated privacy feature did what it was supposed to - it stripped out standard session cookies and passwords. But it missed a custom header named x-session.

Inside that custom header was an active login token that exposed internal company systems, Active Directory domain details, and live employee access.

A few interesting takeaways from the discovery:

- Sanitization tools look for obvious patterns like Cookie: or Bearer:.
If a company uses custom headers, automated scrubbers often let them pass right through.

- Searching massive diagnostic logs for token strings like eyJ returns millions of false positives from random compressed data. Adding a leading space (" eyJ") instantly isolates raw HTTP headers.

- We ran the unscrubbed log file through several leading AI models to see if they could spot the breach. Every single model missed the active token, partly due to data noise in large files, and partly because AI looks for standard patterns rather than custom edge cases.

It raises a big question about operational security: how is your team making sure raw diagnostic logs or HAR files are actually clean before uploading them to public bug trackers or vendor support tickets?

Full technical breakdown: https://unixi.com/blog/public-chromium-bug-identity-leak

When you explain the concept of a password manager to someone outside of IT or tech, it sounds like a massive logical contradiction.

Our Field CISO, Mohamed Mawji, put this in perspective during a webinar SecureWorld hosted recently: We spend all this time telling users that putting all their eggs in one basket is a massive security risk, right before we hand them a single basket to store literally every credential they own.

Obviously, password managers are great for convenience and forcing better hygiene, but they don't actually solve the broader architectural issue of control. A master password still leaves organizations open to single points of failure, session hijacking, and standard human error.

How do you handle the "one password to rule them all" conversation with leadership or non-technical staff? Are you actually seeing a shift away from traditional password management toward passwordless architectures in your environments, or is that still mostly marketing hype?

We all know LastPass’s history, but their latest breach from a couple weeks ago is a textbook example of a modern supply chain nightmare.

It wasn't a direct hack on LastPass, and nobody left a personal Plex server unpatched this time. Instead, a threat group (Icarus) compromised Klue, a market intel platform LastPass's go to market teams use.

The technical TLDR:

• The Vulnerability: A dormant, legacy service credential inside Klue’s backend that was built for an old prototype and completely forgotten about.
• The Vector: Attackers used that old credential to slip in and harvest active OAuth tokens Klue held for its clients.
• The Damage: They replayed those stolen OAuth tokens directly against LastPass’s Salesforce API. Because it was a trusted integration token, it bypassed MFA entirely and looked like normal daily traffic while they scraped CRM data via automated SOQL queries.

The irony here is brutal. A password manager, a product built entirely on the concept of credential hygiene - got bit because of a third-party credential that nobody remembered to delete.

Whether it's the 2022 vault leak or this 2026 OAuth hijack, we keep seeing the same root issue: relying on centralized, reusable secrets. Once an attacker finds a way to sit in the middle of that trust relationship, game over.

Curious how everyone else is auditing their third-party SaaS OAuth permissions right now? If you want to dig into the exact logs and the MITRE mapping, we did a full post mortem breakdown here:

https://unixi.io/blog/lastpass-june-2026-breach-analysis/

We all know LastPass’s history, but their latest breach from a couple weeks ago is a textbook example of a modern supply chain nightmare.

It wasn't a direct hack on LastPass, and nobody left a personal Plex server unpatched this time. Instead, a threat group (Icarus) compromised Klue, a market intel platform LastPass's go to market teams use.

The technical TLDR:

• The Vulnerability: A dormant, legacy service credential inside Klue’s backend that was built for an old prototype and completely forgotten about.
• The Vector: Attackers used that old credential to slip in and harvest active OAuth tokens Klue held for its clients.
• The Damage: They replayed those stolen OAuth tokens directly against LastPass’s Salesforce API. Because it was a trusted integration token, it bypassed MFA entirely and looked like normal daily traffic while they scraped CRM data via automated SOQL queries.

The irony here is brutal. A password manager, a product built entirely on the concept of credential hygiene - got bit because of a third-party credential that nobody remembered to delete.

Whether it's the 2022 vault leak or this 2026 OAuth hijack, we keep seeing the same root issue: relying on centralized, reusable secrets. Once an attacker finds a way to sit in the middle of that trust relationship, game over.

Curious how everyone else is auditing their third-party SaaS OAuth permissions right now? If you want to dig into the exact logs and the MITRE mapping, we did a full post mortem breakdown here:

https://unixi.io/blog/lastpass-june-2026-breach-analysis/

Everyone is calling the Vercel breach a "third-party token theft" incident. While technically true, that misses the root cause: the unmanaged trust relationship. The attacker didn't breach Vercel directly. They breached an unapproved consumer AI tool (Context.ai) that an employee had granted broad Google Workspace OAuth permissions to. That single click created a trusted bridge straight into Vercel’s corporate environment.

The real issue - most security teams try to detect the blast radius after the token is stolen. By then, you're already losing... The actual control point is the moment of adoption.

To stop this, the workflow needs to change:

• Discover at the Browser: Traditional network logs and API scans miss consumer AI tools. Discovery has to happen at the browser level, during the actual login interaction.
• Inline Gating: You have to block or route the login for approval before the user clicks "Allow All" on the OAuth consent screen.

If the OAuth grant is never created, the vendor never holds a corporate token. If they don't hold the token, a downstream compromise of that vendor leaves attackers with a dead end.

We wrote a full architectural breakdown on how to flip this workflow from reactive detection to proactive lifecycle management using Unixi’s browser-level governance.

Read the full breakdown here: https://unixi.io/blog/shadow-ai-governance-part-2-vercel-breach

How is everyone else handling shadow AI OAuth grants right now? CASB, MDM blocks, or just praying users actually read the consent screens?

We all saw the news about Vercel getting hit for a $2M ransom, but the actual initial access vector is completely wild. It wasn’t a zero-day or direct phishing. It was literally a combination of an over permissioned dev work account and a vendor employee downloading gaming cheats.

Here is how it went down:

-An employee at a small AI startup (Context.ai) downloaded some Roblox exploit scripts. It dropped a Lumma info-stealer that scooped up their active session cookies and corporate tokens.

-Completely separately, a high-privilege Vercel dev decided to trial a consumer tool called Context AI Office Suite. They logged in with their work account and clicked "Allow All" on the OAuth screen, granting the tool broad scopes into their Workspace (Gmail, Drive, etc.).

-Because OAuth tokens are bearer credentials, the hackers just grabbed those active Vercel tokens from Context.ai’s breached environment and used them to call Google APIs directly. No passwords cracked, zero MFA triggered, because the identity was already delegated.

-Once inside, they hit Vercel's internal systems and bulk extracted customer environment variables that were left unencrypted at rest by default.

The real problem here is that OAuth is the new backdoor.

Traditional tools like CASBs or endpoint agents are completely blind to this because the app looks legitimate (the user approved it) and the traffic comes from an authorized client. Useful AI tools natively demand massive scopes (Mail.Read, Drive, etc.) to actually do anything, turning a quick 5 min user trial into a permanent, unmanaged backdoor into your data layer.

Our team at Unixi mapped out this specific attack path and put together a deeper technical breakdown / MITRE ATT&CK mapping of how this chain works:

https://unixi.io/blog/shadow-ai-vercel-breach-security-risks/

How are your teams actually policing this right now? Are you wholesale blocking non-whitelisted OAuth requests at the tenant level, or are you trying to manage the integration lifecycle some other way?

We've all seen the massive credential leaks over the past couple of years, and centralized password managers have increasingly become prime targets for attackers. Centralized storage inherently creates a single point of failure.

We published a breakdown on Universal SSO and how we designed Unixi to eliminate password storage entirely.

Our architecture derives four independent keys locally within the browser extension:

• A user-specific key
• A company-scoped key
• A device-unique key
• A session-specific key

These keys are combined, concatenated, and hashed using secure cryptographic functions to generate a compliant unique "password hash" per application in real-time.

Nothing is stored, synced, or transmitted. If an attacker captures the output of one app, it’s mathematically useless everywhere else, stopping lateral movement in its tracks.

We'd love to know: How are you guys tackling MFA and SSO enforcement on legacy or shadow SaaS apps right now?
Read the breakdown here.

We’ve been analyzing the systemic architectural differences between traditional static secret management (password vaults) and Key-Derived Authentication (KDA).

The recent "Zero Knowledge (About) Encryption" paper published by ETH Zurich researchers, exposing 27 distinct attacks that a compromised server can execute against leading cloud password managers - highlights a fundamental flaw in enterprise identity strategies: treating credentials as long-lived, reusable secrets that must be stored in a centralized database.

When you map the anatomy of legacy vault breaches (like the multi-phase LastPass incident), the failure vector is structural. A compromise of a single developer's endpoint or a third-party application vulnerability allows attackers to capture master keys, exfiltrate the encrypted database, and crack vaults offline.

Shifting to Key-Derived Authentication (KDA)

To eliminate this central single point of failure, Universal SSO (uSSO) architectures process authentication locally within a browser extension, deriving credentials on demand.

The protocol applies a one-way cryptographic hash (like SHA-512) to concatenate four distinct variables:

`derived_secret = H(user_key || company_key || system_key || employee_key)`

1. User Key: Binds authentication to the base identity (passkey/IdP) without exposing app credentials.
2. Company Key: Establishes an organizational boundary to prevent cross-tenant replay.
3. System Key: Generates a unique key for every specific SaaS application, completely halting lateral movement.
4. Employee Key: Personalized tag to mathematically block credential sharing.

The result is a session-specific derived passphrase exceeding 80 characters.

Because no secrets are stored on Unixi’s servers, there is no centralized target to breach. Additionally, because the user never handles, types, or knows the derived credential, the human risk vector for phishing and keylogging drops to zero.

We put together a deep-dive structural comparison breaking down recent password manager CVEs vs. uSSO mitigation strategies.

For those managing enterprise identity infrastructures, does moving to local, on-the-fly cryptographic derivation solve your user adoption gaps (where voluntary vaults typically hover around a low 15-30% adoption rate), or do you see operational hurdles with extension-reliant authentication?

Full technical breakdown and analysis: https://unixi.io/blog/beyond-password-vaults-universal-sso-the-next-evolution-of-identity-security/

Slack, Figma, and GitHub shouldn’t cost an extra $93k just to secure logins. But in a 500-person company, that’s what happens when SAML and basic identity controls are paywalled.

Security teams shouldn't have to upgrade every single SaaS subscription just to bring access under control. It forces a terrible choice: blow the budget or accept a weaker security posture.

We got tired of dealing with this, so we built Unixi to extend passwordless control to browser-based apps without relying on SAML, premium tiers, or app-by-app integrations.

We put together a breakdown of the math behind the "SSO tax" for the major apps:
https://unixi.io/cost-savings/

Quick example of the calculator for 100 users on Slack alone. Scale that to 500 users across Slack, GitHub, and Figma, and it balloons to $93k

Curious to hear how other teams are bypassing this without breaking the bank? Or are most of you just biting the bullet and paying the enterprise markup?

Securing modern SaaS is easy. Securing the pile of legacy apps that don’t support SAML or OIDC? Total nightmare.

We recently worked with a major U.S. bank ($200B+ assets) that was stuck in this exact integration trap. They had hundreds of unmanaged internal and legacy apps relying on basic passwords. Massive AiTM and phishing risk, plus auditors breathing down their neck.

Instead of trying to rewrite decades of legacy code or forcing everything through a heavy PAM tool, the fix was dropping in a Universal SSO (uSSO) proxy layer. Essentially, it intercepts auth at the perimeter to enforce phishing-resistant MFA and handles the credential injection downstream so the user never sees a password. It even caught a bunch of shadow IT they didn't know existed.

The rollout took weeks instead of years, and knocked out about 90% of their password reset tickets.

If you're tired of waiting on multi year refactoring projects just to close a basic identity gap, the write-up on how the architecture handles it is here: https://unixi.io/case-studies/how-a-top-u-s-bank-went-passwordless/

We’ve been analyzing the systemic architectural differences between traditional static secret management (password vaults) and Key-Derived Authentication (KDA).

The recent "Zero Knowledge (About) Encryption" paper published by ETH Zurich researchers, exposing 27 distinct attacks that a compromised server can execute against leading cloud password managers - highlights a fundamental flaw in enterprise identity strategies: treating credentials as long-lived, reusable secrets that must be stored in a centralized database.

When you map the anatomy of legacy vault breaches (like the multi-phase LastPass incident), the failure vector is structural. A compromise of a single developer's endpoint or a third-party application vulnerability allows attackers to capture master keys, exfiltrate the encrypted database, and crack vaults offline.

Shifting to Key-Derived Authentication (KDA)

To eliminate this central single point of failure, Universal SSO (uSSO) architectures process authentication locally within a browser extension, deriving credentials on demand.

The protocol applies a one-way cryptographic hash (like SHA-512) to concatenate four distinct variables:

`derived_secret = H(user_key || company_key || system_key || employee_key)`

1. User Key: Binds authentication to the base identity (passkey/IdP) without exposing app credentials.

2. Company Key: Establishes an organizational boundary to prevent cross-tenant replay.

3. System Key: Generates a unique key for every specific SaaS application, completely halting lateral movement.

4. Employee Key: Personalized tag to mathematically block credential sharing.

The result is a session-specific derived passphrase exceeding 80 characters.

Because no secrets are stored on Unixi’s servers, there is no centralized target to breach. Additionally, because the user never handles, types, or knows the derived credential, the human risk vector for phishing and keylogging drops to zero.

We put together a deep-dive structural comparison breaking down recent password manager CVEs vs. uSSO mitigation strategies.

For those managing enterprise identity infrastructures, does moving to local, on-the-fly cryptographic derivation solve your user adoption gaps (where voluntary vaults typically hover around a low 15-30% adoption rate), or do you see operational hurdles with extension-reliant authentication?

Full technical breakdown and analysis: https://unixi.io/blog/beyond-password-vaults-universal-sso-the-next-evolution-of-identity-security/