Account Recovery Is Becoming the New Identity Attack Surface

As passkeys and phishing-resistant authentication reduce password risk, attackers will move pressure to the recovery plane.

The industry is moving in the right direction.

Passkeys, FIDO2/WebAuthn, hardware security keys, conditional access, better MFA policies, and risk-based sign-in controls are all meaningful improvements. They reduce entire classes of credential theft. They make phishing harder. They remove reusable passwords from many authentication ceremonies. They shift more of the security burden from user judgment to protocol design.

That is good.

But it is not the finish line.

In my recent passkeys article, I called out a point that deserves its own treatment: passkeys do not solve weak account recovery, help desk social engineering, stolen session tokens, OAuth consent abuse, unmanaged vendor access, or excessive privilege. They are a major step forward, but they do not remove the rest of the identity attack surface. 

That matters because attackers adapt.

If passwords become harder to steal, guess, spray, reuse, or phish, attackers will apply pressure somewhere else. They will go where the assurance is weaker, the workflows are more manual, the exceptions are more frequent, and the blast radius is still large.

Increasingly, that place is account recovery.

PassKey

The Inversion Test

A useful way to think about this is inversion.

Do not start with the defender’s roadmap. Start with the attacker’s question:

Once passwords disappear, where would I attack next?

The answer is usually not exotic.

I would attack the process that lets a user back into the account after they lose the device.

I would attack the support workflow that removes an authenticator.

I would attack the exception path that grants temporary access.

I would attack the SaaS admin who can approve OAuth grants.

I would attack the vendor portal that still uses email-based recovery.

I would steal a browser session instead of a password.

I would enroll a new device.

I would persuade the help desk to do for me what the authentication system will not.

That is the problem.

Authentication is getting stronger, but recovery is often still treated like customer service, not like privileged access.

The Recovery Plane Is Bigger Than Password Reset

When many teams hear “account recovery,” they think about password reset.

That definition is too narrow.

The recovery plane includes every path that can restore, replace, bypass, reset, re-enroll, approve, or extend access after normal authentication fails or becomes inconvenient.

That includes:

  • Password reset and account unlock workflows
  • MFA reset
  • Authenticator removal
  • Passkey re-enrollment
  • Lost phone and device replacement processes
  • Temporary access passes
  • Emergency access procedures
  • Help desk verification scripts
  • Vendor support portals
  • OAuth consent grants
  • Long-lived sessions
  • Break-glass accounts
  • Shared accounts
  • Offboarding workflows

That is a lot of surface area.

It is also where many organizations have the least visibility.

They can tell you how many users enrolled a passkey. They can tell you how many privileged users have hardware keys. They can show a nice adoption dashboard.

But ask how many privileged recovery events occurred last quarter, how many required human exception, how often callbacks used known-good numbers, how many OAuth grants have offline access, or how many vendor admins can recover access without the organization’s IdP, and the room gets quieter.

That is not because security teams do not care.

It is because the measurements have not caught up to the new risk.

Passkey Adoption Is Not the Same as Recovery Risk Reduction

Most passkey programs measure adoption.

That is understandable. Adoption matters. A phishing-resistant authenticator that nobody uses is not a control; it is a feature sitting idle.

But adoption alone can become a vanity metric.

A dashboard that says “82% of users have enrolled passkeys” may look good while the recovery plane remains weak. A privileged administrator may have a hardware key and still be vulnerable if a support agent can remove that key after a convincing phone call. A finance user may authenticate with a passkey and still have an OAuth grant that allows a third-party application to read mail and files. A SaaS admin may have phishing-resistant login and still carry a session token that can be replayed from an infected endpoint.

In other words, the front door can improve while the side doors remain unchanged.

The right question is not only:

How many users have passkeys?

The better question is:

Can an attacker still recover, re-enroll, delegate, or persist access without satisfying the same level of assurance we require at login?

That question changes the program.

Why Attackers Like Recovery Paths

Recovery paths are attractive because they are designed for failure.

Users lose phones. Laptops die. Executives travel. Hardware keys get left at home. Contractors change devices. Mergers bring strange identity histories. Help desks are measured on resolution time. Business units want access restored now. Support teams are asked to be helpful, empathetic, and fast.

Attackers understand this.

They do not need to defeat your strongest control if they can trigger a workflow that temporarily removes it. They do not need a zero-day if they can convince a support agent that the CFO is locked out before payroll closes. They do not need to phish a password if a malicious OAuth application can be granted the right permissions. They do not need to reauthenticate if a stolen session or refresh token remains valid.

This is second-order identity risk.

The first-order improvement is passwordless authentication.

The second-order attacker response is pressure on the lifecycle around authentication.

That is where many programs are underbuilt.

Help Desks Are Now Part of the Identity Control Plane

Help desk directors should be in the room for passkey planning.

Not after rollout.

Before rollout.

The support function is no longer just a service channel. In a passwordless environment, it becomes one of the places where identity assurance is either preserved or quietly downgraded.

When a support agent removes an authenticator, issues a temporary access pass, resets MFA, unlocks an account, updates a phone number, or approves device replacement, that agent may be changing the effective security posture of the identity.

For normal users, that can still matter.

For privileged users, it can be catastrophic.

Scattered Spider is a useful warning here. CISA has described the group’s use of social engineering to convince IT help desk personnel to reset passwords and MFA tokens, and CISA’s mitigation guidance emphasizes phishing-resistant MFA such as FIDO/WebAuthn. 

The broader lesson is that support and recovery workflows can become identity attack paths when attackers cannot easily defeat the primary login ceremony.

The lesson is simple: recovery for privileged users should not be a normal ticket.

It should be a controlled ceremony.

That means strong proofing, out-of-band verification using known-good contact information, two-person approval, time-bound access, explicit logging, alerting to security operations, and post-event review.

It also means the help desk needs permission to slow down when risk is high.

“Fast resolution” cannot be the only service metric when the request changes identity assurance.

Fallback Methods Are the Old Attack Surface Wearing a New Name

Fallback methods are often kept for good reasons.

They reduce lockouts. They make pilots easier. They help executives. They make support less painful. They allow legacy applications to keep working. They reduce friction for BYOD and remote users.

But they also preserve the attack surface that passkeys were meant to reduce.

SMS, voice OTP, email OTP, TOTP, push approval, security questions, personal email recovery, and “call the help desk” workflows can become the weakest link in an otherwise strong authentication program.

That does not mean every fallback disappears on day one.

It means fallback must be governed by risk tier, not convenience.

For privileged users, weak fallback should be removed first.

For high-risk business users, fallback should be limited, logged, and reviewed.

For standard users, fallback should be transitional and measured.

For vendors, fallback should be part of the access contract.

For break-glass accounts, fallback should be designed, vaulted, monitored, and tested.

Do not let fallback become the permanent exception nobody owns.

Device Replacement Is a Security Event

Passkeys change the device lifecycle.

If the authenticator is a phone, laptop, platform credential, password manager, sync fabric, or hardware key, then device loss and device replacement become security-sensitive workflows.

A new phone is not just a new phone.

It may be the path to a new authenticator.

A laptop rebuild is not just an endpoint ticket.

It may become a passkey re-enrollment event.

A password manager recovery is not just a user convenience problem.

It may restore access to synced credentials.

NIST’s current SP 800-63B language draws an important assurance distinction here: syncable authenticators are not allowed at AAL3 because syncing requires the private key to be exportable, while AAL3 requires stronger hardware-protected key handling. 

That distinction should shape enterprise recovery design.

The organization should know which authenticators are allowed for which risk tiers, whether credentials are synced or device-bound, how many authenticators each user must maintain, what happens when one is lost, and who can approve replacement.

For high-risk roles, device replacement should trigger stronger checks than normal sign-in.

If the attacker’s goal is to become the new device, then treating new-device enrollment as routine is a mistake.

OAuth Grants Are Recovery’s Cousin

OAuth consent is not account recovery in the traditional sense, but it belongs in the same risk conversation.

Why?

Because OAuth grants can create durable delegated access that survives the user’s normal login ceremony. In many attacks, the adversary does not need the password. The user is tricked into granting a malicious or compromised application access to mail, files, contacts, or other SaaS data. The attacker then operates through authorized application access rather than a classic interactive login.

Microsoft describes consent phishing as an attack where users are tricked into granting permissions to malicious cloud applications, allowing those applications to access legitimate cloud services and user data. Microsoft also recommends auditing applications and consented permissions, limiting user consent, and monitoring suspicious application behavior. 

Red Canary describes application access token theft as a technique adversaries use to gain unauthorized access to SaaS, cloud, and containerized resources, including through OAuth consent grant attacks. 

That is an identity bypass from a governance point of view.

If your passkey program does not include connected-app review, admin consent workflows, publisher verification, permission classification, and revocation procedures, then you have left a major identity path out of scope.

This is especially important in Microsoft 365, Google Workspace, Salesforce, GitHub, Slack, Box, Dropbox, and other SaaS-heavy environments where business productivity depends on integrations.

Security teams should ask:

  • Who can consent to applications?
  • Which grants include mail, files, directory, impersonation, or offline access?
  • Which applications are publisher verified?
  • Which grants are unused, stale, or excessive?
  • Which service principals have tenant-wide reach?
  • How quickly can suspicious consent be revoked?
  • Are OAuth changes visible in the SIEM?

Do not celebrate passwordless authentication while ignoring delegated access.

Sessions Are Where Authentication Becomes Authorization

Another uncomfortable point: authentication strength does not automatically protect the entire session.

After authentication succeeds, applications issue session tokens, cookies, and refresh tokens. Those artifacts often become the practical proof that the user is already trusted. If malware, a phishing proxy, browser compromise, or endpoint theft captures that token, the attacker may be able to bypass the login ceremony entirely.

Ping Identity describes session hijacking as reuse of a stolen session token to impersonate a logged-in user; because the attack occurs after login, MFA may already be satisfied. 

Microsoft has also published guidance on cloud token theft, including prevention, detection, and response considerations for token-based attacks. 

That is why session governance belongs in the passkey roadmap.

Shorter session lifetimes, device compliance, token binding where available, continuous access evaluation, impossible travel detection, user-agent and device mismatch analytics, rapid revocation, EDR coverage, browser hardening, and SaaS session visibility all matter.

Passkeys reduce credential theft.

They do not make stolen sessions harmless.

A Recovery-Plane Risk Score

Organizations need a way to score recovery paths the same way they score applications, data, vendors, and vulnerabilities.

Here is a practical model.

Factor Question High-Risk Signal
Proof strength How strongly does the process verify the person requesting recovery? Email access, caller ID, personal information, or manager approval alone.
Social-engineering exposure Can a human be pressured into overriding controls? Phone-only recovery, urgent executive exceptions, vague escalation rules.
Exception frequency How often is the standard process bypassed? Frequent temporary access, recurring VIP exceptions, non-expiring risk acceptances.
Blast radius What can the recovered account access? Admin roles, finance workflows, HR data, developer systems, mailboxes, cloud consoles.
Persistence Does recovery create long-lived access? Refresh tokens, remembered devices, OAuth grants, persistent sessions, new authenticators.
Visibility Can security see and investigate the event? No SIEM logging, no alerting, limited ticket context, SaaS-only logs.
Ownership Who governs the path? No control owner, no review cadence, split responsibility between IAM and support.

Score each recovery path from 1 to 5 on each factor.

Then multiply or weight by user tier.

A recovery path for a standard user with limited SaaS access is not the same as a recovery path for a global admin, payroll approver, domain admin, developer with production access, or vendor administrator.

Do not flatten the organization.

Risk is not evenly distributed. Recovery controls should not be either.

What Leaders Should Measure

CISOs and IAM leaders should add recovery-plane metrics to identity dashboards.

At minimum, track:

  • Recovery events by user tier
  • Authenticator resets and removals
  • New authenticator enrollments
  • Temporary access passes
  • Privileged recovery exceptions
  • Help desk recovery requests denied or escalated
  • Recovery events outside business hours
  • Users with fewer than two approved authenticators
  • Weak fallback still enabled by tier
  • OAuth grants by risk level
  • Long-lived session exceptions
  • Third-party accounts without phishing-resistant authentication
  • Vendor support paths that bypass the primary IdP
  • Open recovery exceptions by owner and expiration date

The executive dashboard should answer a plain question:

Can someone get back into a high-risk account through a process weaker than the process required to sign in?

If the answer is yes, the organization has work to do.

A Practical 90-Day Plan

Days 0–30: Inventory the Recovery Plane

Start with the systems that matter most:

  • IdP
  • Email
  • Endpoint management
  • PAM
  • Cloud consoles
  • Finance systems
  • HR systems
  • Developer platforms
  • Backup consoles
  • EDR
  • SIEM
  • Ticketing
  • Major SaaS applications

For each system, document:

  • Normal authentication method
  • Recovery method
  • Fallback methods
  • Approval path
  • Required proof
  • Generated logs
  • Alerts
  • Temporary access lifetime
  • Post-recovery review process

Do not start by buying another tool.

Start by finding the paths.

Days 31–60: Harden High-Risk Recovery

Prioritize administrators, executives, finance, HR, developers, help desk staff, security staff, and third parties with privileged or sensitive access.

For those users:

  • Require at least two approved authenticators before enforcement.
  • Remove weak fallback where feasible.
  • Require device-bound passkeys or hardware keys for privileged access.
  • Implement two-person approval for privileged authenticator reset.
  • Use known-good callback procedures.
  • Alert on authenticator removal and re-enrollment.
  • Require post-recovery review for high-risk accounts.

This is also the time to train the help desk on adversarial recovery scenarios.

Not generic security awareness.

Specific scripts.

Specific red flags.

Specific escalation authority.

The help desk needs to know when a request is no longer just a request.

It is a security event.

Days 61–90: Govern Tokens, Grants, Vendors, and Exceptions

Once the human recovery paths are under control, expand to adjacent identity persistence.

Review OAuth grants and connected applications.

Restrict user consent for higher-risk permissions.

Implement admin consent workflows.

Review refresh token and session lifetime policies.

Test rapid session revocation.

Identify vendor-controlled recovery paths.

Require phishing-resistant MFA for vendors with privileged access.

Publish an exception register with owners and expiration dates.

Run a tabletop exercise against recovery abuse.

The tabletop should be blunt:

An attacker has convinced the help desk to remove MFA from a finance administrator. What alerts fire? Who knows? How fast can we revoke sessions, disable OAuth grants, suspend the account, preserve evidence, and determine blast radius?

If that exercise feels uncomfortable, good.

That is the point.

Policy Baseline Language

Here is practical language to adapt:

Account recovery, authenticator reset, passkey registration, passkey removal, device replacement, temporary access issuance, OAuth consent approval, and session revocation are security-sensitive identity lifecycle events. These events must be governed by risk tier, verified using approved proofing methods, logged centrally, monitored for abuse, and reviewed for privileged or high-impact users. Recovery processes must not allow access to be restored through a weaker assurance path than the access being recovered without documented, time-bound risk acceptance.

That last sentence is the core principle.

Do not let recovery be weaker than login.

Where Compliance and Risk Teams Fit

Compliance teams should pay attention because recovery-plane risk creates evidence problems.

When auditors ask whether privileged access is controlled, the answer cannot stop at:

We require MFA.

The next questions are predictable:

  • How is MFA reset?
  • Who can approve a reset?
  • Are approvals logged?
  • Can support staff bypass the policy?
  • Are exceptions time-bound?
  • Are recovery events reviewed?
  • Are vendor recovery paths included?
  • Are OAuth grants reviewed?
  • Can sessions be revoked?

Those are not theoretical questions.

They are control design questions.

They are also incident response questions.

A mature identity program should be able to produce evidence for recovery events the same way it produces evidence for access reviews, privileged access approvals, and policy exceptions.

The Bottom Line

Passkeys are a real improvement.

Phishing-resistant authentication is worth doing.

Hardware keys for privileged users are worth the operational effort.

Conditional access, MFA cleanup, passkey rollout roadmaps, and fallback reduction all matter.

But the next identity fight is not only at login.

It is in recovery.

It is in help desk workflows.

It is in device replacement.

It is in OAuth consent.

It is in session persistence.

It is in vendor support paths.

It is in the exception process.

Attackers follow pressure. As the password attack surface shrinks, the recovery attack surface becomes more valuable.

So build for that reality now.

Measure recovery-plane risk.

Score recovery paths by proof strength, social-engineering exposure, exception frequency, persistence, visibility, ownership, and blast radius.

Harden the workflows that can restore high-impact access.

Give the help desk better procedures and the authority to use them.

Govern OAuth and sessions as part of identity, not as unrelated SaaS hygiene.

Treat vendor access and support recovery as part of the enterprise control plane.

The goal is not to make recovery impossible.

People will lose devices. Executives will travel. Hardware will fail. Business will need continuity.

The goal is to make recovery trustworthy.

Because in a passwordless world, the attacker does not need your password if they can become your recovery event.

More Information and Assistance

At MicroSolved, Inc., we help organizations move from security intentions to operational reality. If you are rolling out passkeys, hardening MFA, modernizing IAM, or trying to understand whether your recovery plane is becoming your weakest identity control, we can help.

MicroSolved can assist with:

  • Identity architecture assessments
  • Passkey and phishing-resistant authentication roadmaps
  • Account recovery and help desk workflow hardening
  • OAuth grant and SaaS identity reviews
  • Privileged access and vendor access risk reduction
  • Identity logging and SIEM use-case development
  • Tabletop exercises and adversarial simulations focused on recovery abuse
  • Executive dashboards for identity risk reduction

Contact MicroSolved at +1.614.351.1237 or info@microsolved.com.

Relax. We’re on watch.

 

* AI tools were used as a research assistant for this content, but human moderation and writing are also included. The included images are AI-generated.

Passkeys, Not Passcodes: A Practical Enterprise Guide to Moving Beyond Passwords

There is a small terminology problem in the identity world right now, and it matters more than it looks.

passcode or PIN is usually a local unlock secret. It unlocks a phone, a laptop, Windows Hello, an authenticator app, or a hardware security key. A passkey is different. A passkey is the standards-based replacement for passwords, built on FIDO2/WebAuthn. The user unlocks the passkey locally with a fingerprint, face scan, device PIN, pattern, or security key, but the website or application receives cryptographic proof — not a reusable password. FIDO defines passkeys as FIDO authentication credentials based on FIDO standards, tied to an account, and used with the same process the user already uses to unlock a device. 

That distinction is not pedantry. It is the difference between a local unlock method and a replacement for one of the most abused controls in the history of computing.

Passwords have had a long run. They also have had a long list of failures: reuse, phishing, spraying, stuffing, database theft, weak reset workflows, help desk abuse, and user fatigue. We have spent decades trying to compensate for those failures with complexity rules, expiration schedules, password managers, SMS codes, mobile push prompts, training campaigns, and detective controls.

Some of those helped. Some just moved the pain around.

Passkeys change the model.

They are not merely “better passwords.” They are a different authentication architecture.

A hacker is seated in front of a computer fingers poised over the keyboard They are ready to break into a system and gain access to sensitive information 6466041

The Problem: Passwords Are Shared Secrets in a World Built to Steal Them

A password proves identity by revealing a secret. That is the root of the problem.

When users type passwords into websites, there is always a chance they will type them into the wrong website. When companies store password material, there is always a chance attackers will steal it. When people reuse passwords, a breach in one place becomes an entry point somewhere else. When attackers automate guessing, weak and reused passwords become an industrial-scale attack surface.

Microsoft’s 2025 Digital Defense Report says 97% of identity attacks were password spray attacks, which is a pretty direct reminder that attackers still love the boring stuff that works. Verizon’s 2026 DBIR highlights that breaches continue to involve the human element, phishing, stolen credentials, ransomware, and software vulnerability exploitation — and also reports that 31% of breaches now start with software vulnerabilities, beating stolen passwords as the top initial entry point in that dataset. 

That combination matters. It tells us two things at once.

First, passwords remain a major identity risk. Second, replacing passwords is not the whole security program.

That is the right mental model for passkeys: they are a major improvement in authentication, not a magic shield around the enterprise.

What a Passkey Does Differently

A password is something the user knows and types.

A passkey is a cryptographic credential. When the user registers a passkey for a site or application, the device creates a unique public/private key pair. The private key stays with the authenticator or passkey provider. The public key is registered with the service. At sign-in, the service sends a fresh challenge. The authenticator signs the challenge with the private key. The service verifies the response with the public key.

No reusable password crosses the wire.

No password database needs to be protected in the same way.

No user has to remember whether the login page looks slightly wrong.

The protocol carries a lot of the security burden that we previously dumped on the user.

That is the real breakthrough.

FIDO describes passkeys as password replacement technology that uses cryptographic key pairs for phishing-resistant sign-in. It also notes that passkeys can be synced across devices or bound to a particular device. Microsoft Entra describes the same basic model: the private key is stored on the user device, the public key is stored with the app or website, and both unique keys are needed to sign in. 

The user experience is simple: unlock the device.

The security model is not simple — and that is a good thing.

The Plain-English Explanation for Users

For users, do not start with asymmetric cryptography. Start with what changes for them.

“A passkey is a safer way to sign in without typing a password. Instead of remembering and entering a password, you unlock your phone, laptop, or security key. The website gets proof that your device has the right key, but it never gets a password. That means there is no password for you to forget, reuse, mistype, or accidentally give to a fake website.”

That is enough for most end users.

Then answer the question they are really asking:

Does the website get my fingerprint or face scan?

No. The biometric check happens locally. FIDO states that biometric information and processing remain on the device and are not sent to a remote server; the server receives assurance that the biometric check succeeded. 

Is my device PIN now my corporate password?

No. NIST distinguishes centrally verified passwords from local activation secrets. A device PIN or unlock secret used locally to access an authenticator is not sent to the verifier the way a website password is. 

That is an important communication point. Users often hear “PIN” and think “weak password.” In a passkey model, the PIN is usually a local unlock mechanism protecting the private key, not the secret being verified by the website.

Why Passkeys Reduce Risk

Passkeys reduce several common attack paths:

Risk How passkeys help
Phishing The user does not type a reusable password, and the passkey is scoped to the legitimate relying party. A fake site should not be able to obtain a valid assertion for the real site.
Credential stuffing There is no shared password to reuse from another breach.
Password spraying Attackers cannot guess a password that is no longer accepted for that workflow.
Password database theft The service stores public key material rather than reusable passwords.
Weak MFA interception Passkeys can replace password plus SMS OTP, password plus TOTP, or password plus push approval in many use cases.
User fatigue Users approve sign-in with a familiar local unlock gesture rather than remembering and typing complex passwords.

FIDO states that passkeys are resistant to phishing, designed without shared secrets, and can replace legacy MFA flows such as password plus SMS OTP. FIDO also notes that common second factors such as OTPs and phone approvals remain phishable. NIST is similarly direct: passwords are not phishing-resistant, and authenticator outputs manually entered into an impostor verifier — such as OTP-style flows — are not considered phishing-resistant because they can be relayed. 

That last point is key.

A lot of organizations believe they solved phishing because they deployed MFA. In many cases, they deployed phishable MFA. That is better than passwords alone, but it is not the same as phishing-resistant authentication.

What Actually Happens Under the Hood

There are two ceremonies that matter: registration and authentication.

Registration

When a user creates a passkey:

  1. The user starts registration through an approved enrollment path.
  2. The relying party sends registration options to the browser or application.
  3. The browser or app calls the WebAuthn API.
  4. The authenticator creates a new public/private key pair scoped to that relying party.
  5. The private key stays in the authenticator or passkey provider.
  6. The public key, credential ID, user handle, flags, and optional attestation data are returned.
  7. The relying party stores the credential record with the user account.

W3C WebAuthn describes a model where the public key is returned to the relying party during registration, while the private key is bound to the authenticator and is expected not to be exposed. It also describes the credential record that the relying party stores for later authentication ceremonies. 

Authentication

When the user signs in later:

  1. The relying party generates a fresh random challenge.
  2. The browser or app sends the challenge and relying-party information to the authenticator.
  3. The authenticator checks whether it has a credential scoped to that relying party.
  4. The user performs local verification, such as biometric, PIN, device unlock, or security-key touch.
  5. The authenticator signs the challenge and relevant context.
  6. The relying party verifies the signature using the stored public key.
  7. The relying party checks the challenge, origin, RP ID, user verification flags, and policy requirements before granting access.

WebAuthn depends on randomized challenges to prevent replay attacks, and the relying party must generate those challenges in a trusted environment and verify that the returned challenge matches. 

This is why passkeys are different from passwords. A password login proves identity by disclosing a shared secret. A passkey login proves possession of a private key without disclosing it.

Why Phishing Resistance Works

The important concept is origin binding or relying party binding.

A passkey created for one legitimate service is not supposed to work for an attacker’s lookalike domain. A fake site may fool the human eye, but it should not be able to get a valid passkey assertion for the real service’s relying party ID.

W3C WebAuthn notes that credentials are scoped to a specific relying party and that only that relying party, identified by its RP ID, can use the credential in authentication ceremonies. It also warns relying parties not to accept unexpected origins, because origin validation is an additional layer of protection. 

That is the practical security gain.

The protocol stops relying solely on user vigilance.

We should still train users. We should still harden browsers. We should still detect malicious domains. But the highest-value control is to prevent the stolen credential from existing in the first place.

User Presence vs. User Verification

Two terms get mixed together too often:

Concept Plain-English meaning Why it matters
User presence The user touched the key, approved the prompt, or was physically involved. Helps prove that authentication was not entirely silent.
User verification The authenticator locally verified the user with a PIN, biometric, or equivalent method. Provides stronger assurance that the right person, not merely the right device, approved the login.

WebAuthn authenticator data includes flags for User Present and User Verified. For enterprise deployments, user verification should be required for normal workforce access and especially for privileged access.

Do not settle for “the device was there” when the workflow needs “the authorized user unlocked the credential.”

Attestation: Knowing What Created the Key

Attestation answers a simple question:

What kind of authenticator created this credential, and do we trust that model for this use case?

For broad workforce adoption, strict attestation may not always be required. Many consumer passkey providers do not expose the same provenance details, and requiring attestation everywhere can create adoption friction.

For privileged users, administrators, financial approvers, developers, security staff, and high-risk workflows, attestation becomes much more important. In those cases, the organization may want to allow only approved hardware security keys, approved device-bound passkeys, or approved enterprise passkey providers.

Microsoft Entra allows attestation enforcement at the passkey profile level. When attestation is enabled, only device-bound passkeys are allowed and synced passkeys are excluded. 

That is the correct direction for high-risk access.

Use convenience where the risk allows it. Use hardware-backed assurance where the blast radius demands it.

Synced Passkeys vs. Device-Bound Passkeys

Not all passkeys carry the same operational risk.

Type What it means Good fit Risk notes
Synced passkey The credential can be synced across devices through a passkey provider, such as an OS/cloud keychain or password manager. Standard workforce, lower-risk SaaS, broad adoption, BYOD-friendly scenarios. Better usability and recovery, but introduces sync-fabric, sharing, restore, and account-recovery risks.
Device-bound passkey The private key remains tied to one device or authenticator. Admins, executives, finance, developers, security teams, regulated workflows. Stronger control and provenance, but higher support cost and lockout risk.
Hardware security key A roaming authenticator, often USB/NFC/BLE, with keys protected in dedicated hardware. Highest-risk users, break-glass accounts, privileged access, financial approvals. Requires inventory, backup keys, training, and lifecycle management.

NIST allows syncable authenticators in applications seeking up to AAL2, but AAL3 requires a phishing-resistant authenticator with a non-exportable key. NIST explicitly says syncable authenticators cannot be used at AAL3 because their private keys are inherently exportable. 

That gives us a clean enterprise rule:

Use synced passkeys where usability and broad risk reduction matter most. Use device-bound credentials or hardware security keys where privilege, regulation, or business impact requires stronger assurance.

The Big Deployment Mistake: Turning On Passkeys and Declaring Victory

The wrong strategy is simple:

“We enabled passkeys. We are passwordless now.”

No.

A passkey project is not just an IdP configuration change. It is an identity modernization project.

The common failures are predictable:

  1. Weak fallback methods remain enabled.
  2. Recovery workflows become the new attack path.
  3. Privileged users are treated the same as standard users.
  4. Legacy applications keep password paths alive.
  5. Enrollment is not monitored.
  6. Exceptions never expire.
  7. Help desk processes are not hardened.
  8. Service accounts are ignored.
  9. Token theft and session abuse are treated as unrelated problems.

Passkeys reduce credential compromise risk. They do not solve endpoint malware, stolen browser sessions, OAuth abuse, SaaS misconfiguration, vulnerable internet-facing systems, malicious insiders, or weak vendor access.

Identity security is a system. Passkeys are one of the strongest components we have, but they still have to be engineered into the system.

Enterprise Implementation Methodology

The enterprise goal should be stated plainly:

Move the organization from password-centric authentication to phishing-resistant authentication while reducing weak fallback methods, hardening recovery, and tiering controls by risk.

Phase 0: Define Scope, Risk Tiers, and Target State

Start with decisions, not tools.

Decide:

  • Which IdP or IdPs are authoritative?
  • Which users are highest risk?
  • Which applications can use SSO?
  • Which applications support native WebAuthn/FIDO2?
  • Which workflows require phishing-resistant authentication immediately?
  • Which users may use synced passkeys?
  • Which users must use device-bound passkeys or hardware keys?
  • What fallback methods are acceptable during transition?
  • What is the exception process?
  • What is the recovery process?
  • What logs must be collected?
  • What metrics will leadership see?

Then build a risk-tier model.

Tier Examples Recommended approach
Tier 0 / highest privilege Global admins, domain admins, IdP admins, cloud admins, PAM admins, break-glass accounts. Two approved device-bound credentials or hardware security keys; attestation required where possible; no SMS, TOTP, or push fallback.
Tier 1 / high risk Executives, finance, HR, developers, help desk, security team, wire/ACH approvers. Device-bound preferred; synced allowed only with managed device and strong conditional access; hardened recovery.
Tier 2 / standard workforce General staff using SaaS and productivity apps. Synced or platform passkeys allowed; user verification required; backup method required before enforcement.
Tier 3 / frontline/shared device Kiosks, shared workstations, shift users. Hardware keys, badge-integrated FIDO, named-user access, or carefully designed shared-device strategy.
Third parties Vendors, contractors, MSPs. Require phishing-resistant MFA for privileged or sensitive access; enforce federation and conditional access.
Service accounts Non-human accounts, integrations, automations. Do not use passkeys. Use managed identities, workload identity federation, certificates, scoped tokens, vaulting, and rotation.

The biggest lesson: do not flatten the organization. A payroll clerk, a warehouse kiosk user, a cloud administrator, and a break-glass account do not carry the same risk.

Phase 1: Inventory Authentication Surfaces

Before enforcement, inventory where authentication actually happens.

Minimum fields should include:

  • Application or system name
  • Business owner
  • Authentication path
  • IdP integration
  • Current MFA methods
  • WebAuthn/FIDO2 support
  • SSO capability
  • User population
  • Privilege level
  • Recovery path
  • Logging source
  • Legacy protocols
  • Exception owner
  • Exception expiration date

Pay special attention to legacy authentication. Basic auth, old VPN flows, app passwords, IMAP/POP/SMTP AUTH, ROPC, local admin portals, unmanaged SaaS accounts, and shadow IdPs can quietly preserve the password attack surface after leadership thinks the problem is fixed.

This is where many “passwordless” projects fail. The modern front door gets hardened, but the side doors stay open.

Phase 2: Choose the Enterprise Passkey Architecture

Most organizations will deploy passkeys through their primary identity provider.

Microsoft Entra ID

Microsoft Entra supports passkeys using FIDO2/WebAuthn concepts and describes both device-bound passkeys and synced passkeys. Microsoft also recommends FIDO2 security keys for highly regulated industries or users with elevated privileges, while describing synced passkeys as a convenient, lower-cost option for most users outside highly regulated or sensitive contexts. 

A good Entra pattern usually includes:

  • Separate passkey profiles for standard users and privileged users.
  • Device-bound/security-key requirements for administrators.
  • Attestation enforcement for high-risk profiles where feasible.
  • Conditional Access authentication strengths.
  • Managed device requirements for sensitive access.
  • At least two authenticators enrolled before enforcement.
  • Removal of SMS, voice, TOTP, and push fallback for privileged users.
  • Logging of registration, removal, sign-in, recovery, and policy changes.

Google Workspace

Google Workspace administrators can allow users to skip password sign-in challenges and use a passkey covering first and second-factor authentication. Google also notes that administrators can restrict passkeys to hardware security keys only and can monitor passkey enrollment and usage through the security investigation tool. 

A good Google Workspace pattern usually includes:

  • Enabling skip-password capability by organizational unit.
  • Restricting hardware security keys for privileged OUs where required.
  • Confirming users have enrolled backup methods before enforcement.
  • Monitoring passkey enrollment and successful passkey sign-ins.
  • Removing weaker fallback for high-risk users.
  • Aligning device management and account recovery policies.

Okta

Okta describes Passkeys/FIDO2 WebAuthn and Okta FastPass as phishing-resistant authenticators and supports app sign-in policies that require phishing-resistant possession factors. Okta also logs phishing-resistant authentication events, including declined phishing attempts. 

A good Okta pattern usually includes:

  • Enabling Passkeys/FIDO2 WebAuthn and/or Okta FastPass.
  • Creating authenticator enrollment policies by risk group.
  • Requiring phishing-resistant authenticators for sensitive apps.
  • Using app sign-in policies rather than broad, one-size-fits-all rules.
  • Integrating managed device posture where available.
  • Alerting on enrollment changes, recovery activity, and phishing-resistant authentication failures.

Phase 3: Pilot With the People Who Can Break the Program Safely

Pilot with IT, security, identity administrators, help desk, a small executive group, finance users, mobile users, and a few users who are likely to have edge cases.

Test:

  • New device enrollment
  • Lost device recovery
  • Hardware key enrollment
  • Mobile sign-in
  • Cross-device sign-in
  • VPN access
  • SaaS access
  • Admin portal access
  • Password reset flows
  • Help desk identity verification
  • Offboarding
  • Break-glass access
  • Legacy application behavior
  • Logging and SIEM correlation
  • User communications

The pilot is not just about whether passkeys work. It is about whether the organization can support them without creating a weaker recovery path than the password path it replaced.

Phase 4: Roll Out by Risk, Not by Org Chart

The rollout sequence should be boring and deliberate:

  1. Identity administrators and security team.
  2. Cloud administrators and PAM administrators.
  3. Break-glass accounts.
  4. Finance, payroll, HR, executives, and developers.
  5. Help desk and support teams.
  6. General workforce.
  7. Third parties with privileged or sensitive access.
  8. Remaining business applications through SSO modernization.

Do not start with “everyone by Friday.” Start with the users whose compromise would hurt the most and whose workflows you can monitor carefully.

Phase 5: Harden Recovery, Lifecycle, and Monitoring

Attackers follow the path of least resistance.

If passkeys close the front door, attackers will look at recovery, registration, device replacement, and help desk exceptions.

Recovery controls should include:

  • Strong identity verification for authenticator reset.
  • Separate procedures for standard users and privileged users.
  • Two-person approval for privileged recovery.
  • Out-of-band callback using known-good contact information.
  • No recovery approval based solely on email access.
  • Logging and alerting for passkey addition, removal, reset, and recovery.
  • Time-bound temporary access.
  • Post-recovery review.
  • Executive reporting on recovery volume and exceptions.

NIST’s usability guidance explicitly calls out the need to provide users information about what to do if an authenticator is lost or stolen and to consider alternative authentication options for loss, damage, or availability issues. 

The enterprise interpretation is simple: do not enforce passkeys until recovery is engineered.

Policy Baseline Language

Here is a practical policy statement to adapt:

The organization will transition workforce authentication from password-centric methods to phishing-resistant authentication using passkeys based on FIDO2/WebAuthn. Standard users may use approved synced or device-bound passkeys. Privileged, administrative, financial, and other high-risk users must use approved device-bound passkeys or hardware security keys. Passwords, SMS OTP, voice OTP, email OTP, TOTP, and push approval may be used only as temporary transition or exception methods where explicitly risk-accepted. Account recovery, passkey registration, passkey removal, and fallback authentication are security-sensitive workflows and must be logged, monitored, and governed.

Minimum technical requirements:

Control Standard
User verification Required.
User presence Required where applicable.
Passkey count Minimum two approved authenticators per user before enforcement.
Admin authentication Device-bound FIDO2/security key; attestation preferred or required.
Standard workforce Synced or device-bound passkeys based on risk.
Shared accounts Prohibited where feasible; replace with named accounts and PAM.
Service accounts No passkeys; use workload identity or managed secrets.
Recovery Documented, verified, logged, and alert-generating.
Logging Registration, sign-in, failure, recovery, removal, device change, and admin changes.
Exceptions Time-bound, owner-assigned, and risk-accepted.

Enterprise Risk Register

Risk Probability Impact Mitigation
Weak fallback remains enabled High High Remove SMS/TOTP/push for admins first; enforce phishing-resistant authentication strength; maintain an exception register.
Help desk becomes the new attack path High High Require strong identity verification, callback procedures, two-person approval for privileged recovery, and recovery-event alerting.
Users lose access due to device loss Medium Medium Require two authenticators; issue backup keys for high-risk users; document recovery.
Synced passkeys are restored or shared to unmanaged devices Medium Medium/High Use managed profiles, MDM, device compliance, passkey provider controls, and device-bound keys for high-risk groups.
Legacy apps block enforcement High Medium/High Inventory apps, front with SSO, modernize authentication, isolate, or risk-accept temporarily.
Token theft bypasses authentication strength Medium High Use device compliance, session protection, continuous access evaluation, EDR, browser/session controls, and rapid revocation.
Attestation gaps create uncertainty Medium Medium Require attestation for privileged groups; use approved authenticator lists; allow non-attested only for lower-risk users.
BYOD creates inconsistent security posture Medium Medium Separate standard and high-risk use cases; require compliant devices for sensitive access.
Break-glass accounts remain password-only Medium High Use hardware keys, strong vaulting, monitoring, emergency access review, and tested procedures.
Users misunderstand biometrics Medium Low/Medium Explain that biometrics stay local and are not sent to the website, application, or employer.

A Practical 12-Month Roadmap

0–30 Days: Planning and Readiness

  • Define passkey policy and risk tiers.
  • Inventory applications and authentication paths.
  • Identify privileged and sensitive user groups.
  • Decide approved authenticator types.
  • Configure pilot policies in the IdP.
  • Draft help desk and recovery runbooks.
  • Prepare user communications.
  • Procure hardware security keys for administrators and high-risk users.

31–60 Days: Pilot

  • Enroll IT, security, and admin pilot users first.
  • Require at least two authenticators per pilot user.
  • Validate registration, sign-in, recovery, mobile, VPN, and legacy app behavior.
  • Run phishing-resistant authentication tests.
  • Tune SIEM alerts and help desk workflows.
  • Document blockers and exceptions.

61–90 Days: Privileged Enforcement

  • Require device-bound passkeys or hardware security keys for administrators.
  • Disable SMS, TOTP, and push fallback for admin accounts.
  • Require phishing-resistant authentication for IdP admin portals, cloud consoles, PAM, EDR, backup consoles, VPN admin access, finance approvals, and security tools.
  • Review break-glass accounts.
  • Begin executive and finance enrollment.

91–180 Days: Workforce Expansion

  • Enable passkey sign-in for all users.
  • Require two authenticators before enforcement.
  • Retire weak MFA for sensitive applications.
  • Move remaining password-based applications behind SSO where possible.
  • Track adoption metrics weekly.
  • Publish exceptions to leadership and security governance.

181–365 Days: Password Reduction and Optimization

  • Reduce password prompts.
  • Remove legacy authentication protocols.
  • Decommission app passwords and basic auth.
  • Expand phishing-resistant authentication to third parties.
  • Review account recovery events quarterly.
  • Run tabletop exercises and red-team simulations against recovery and fallback paths.
  • Add passkey support requirements to procurement and vendor risk management.

Metrics Leadership Should See

A passkey program needs measurement. Otherwise it becomes another “we turned it on” control.

Track:

  • Percent of users with at least one passkey.
  • Percent of users with at least two authenticators.
  • Percent of privileged users using device-bound credentials.
  • Password sign-ins by application.
  • Passkey sign-ins by application.
  • Failed passkey attempts.
  • Recovery events.
  • Passkey removals.
  • New authenticator registrations.
  • Weak MFA usage.
  • Exceptions by owner and expiration date.
  • Legacy authentication attempts.
  • High-risk users without compliant authentication.
  • Third-party users without phishing-resistant authentication.
  • Admin sign-ins that did not meet policy.

The dashboard should not be complicated. It should answer one question:

Are we actually reducing credential risk, or did we just add a new option?

What Passkeys Do Not Solve

This is the part vendors sometimes skip.

Passkeys do not fix:

  • Compromised endpoints.
  • Stolen session tokens.
  • Malware running in the user context.
  • OAuth consent abuse.
  • Overprivileged SaaS integrations.
  • Weak device management.
  • Poor logging.
  • Vulnerable internet-facing systems.
  • Help desk social engineering.
  • Weak account recovery.
  • Shared accounts.
  • Unmanaged vendor access.
  • Excessive privilege.
  • Poor offboarding.
  • Business process fraud.

That is not a criticism of passkeys. It is a reminder that identity security is layered.

Passkeys make it much harder to steal and replay credentials. That is a huge win. But attackers adapt. Once the password is gone, they will move toward recovery abuse, token theft, endpoint compromise, malicious OAuth grants, social engineering of support teams, and exploitation of systems that sit outside the modern IdP.

So build the rest of the program.

The Bottom Line

Passkeys are a major improvement because they remove the reusable password from the authentication ceremony.

They replace a shared secret with public-key cryptography, origin binding, local user verification, and challenge-response authentication. That is a structural improvement, not a cosmetic one.

But the right enterprise approach is not “turn on passkeys for everyone and declare victory.”

The right approach is:

  1. Use passkeys for broad workforce passwordless authentication.
  2. Use device-bound passkeys or hardware security keys for privileged and regulated users.
  3. Remove weak fallback methods.
  4. Harden recovery and lifecycle management.
  5. Measure adoption and residual risk.
  6. Tie identity hardening to endpoint security, session protection, vulnerability management, vendor access, and incident response.

Passkeys should be part of a rational identity security program.

Not hype.

Not magic.

Just better engineering.

More Information and Assistance

At MicroSolved, Inc., we help organizations move from security intentions to operational reality. Passkeys are a strong control, but the success of a passkey program depends on architecture, policy, implementation sequencing, recovery design, monitoring, and user communication.

MicroSolved can help your organization:

  • Assess your current authentication architecture.
  • Inventory password, MFA, SSO, and legacy authentication paths.
  • Build a passkey deployment roadmap.
  • Define risk tiers for standard, privileged, executive, financial, developer, and third-party users.
  • Design policy for synced passkeys, device-bound passkeys, and hardware security keys.
  • Harden account recovery and help desk workflows.
  • Configure SIEM monitoring and identity alerts.
  • Test fallback paths through tabletop exercises and adversarial simulations.
  • Build executive dashboards for identity risk reduction.
  • Integrate phishing-resistant authentication into broader security governance.

If you are planning a passkey rollout, struggling with legacy authentication, or unsure how to reduce password risk without creating new recovery risk, reach out to MicroSolved, Inc. We would be glad to help you think it through.

Contact MicroSolved at +1.614.351.1237 or info@microsolved.com.

Relax. We’re on watch.


References

  • FIDO Alliance — Passkeys and passwordless authentication. 
  • W3C — Web Authentication: An API for accessing Public Key Credentials, Level 3. 
  • NIST SP 800-63B — Authentication and Lifecycle Management. 
  • Microsoft Learn — Passkeys/FIDO2 authentication in Microsoft Entra ID. 
  • Google Workspace Admin Help — Allow users to skip passwords at sign-in. 
  • Okta Help — Phishing-resistant authentication. 
  • Microsoft Digital Defense Report 2025. 
  • Verizon 2026 Data Breach Investigations Report. 

AI tools were used as a research assistant for this content, but human moderation and writing are also included. Images are AI-generated.

AI Agents Are Already Working for You. Who’s Managing Them?

AI Agents Are Not Applications. They Are Digital Workers.

Most organizations are adopting AI agents faster than they are learning how to govern them.

That is the problem.

A chatbot that answers questions is one thing. An AI agent that can access business data, use tools, trigger workflows, generate artifacts, make recommendations, or alter enterprise state is something else entirely.

At that point, the organization is no longer just deploying software.

It is introducing a new kind of operational actor.

That actor needs identity.

It needs boundaries.

It needs oversight.

It needs evidence.

It needs a human owner.

It needs a kill switch.

In other words, AI agents must be managed more like digital workers than ordinary applications.

AIAgentBanner

Continue reading

Why My AI Agents Needed CaneCorso as a Security Control Plane

AI agents are powerful because they can read, reason, summarize, decide, and act across a wide range of information sources.

That is also what makes them dangerous.

The more useful an agent becomes, the more likely it is to consume data I do not fully trust. Emails. Newsletters. RSS feeds. API responses. Documents sent as attachments. Social media. YouTube transcripts. Scraped search results. Web pages. Translated content. Random bits of text pulled from places where I do not control the author, the formatting, the intent, or the payload.

That is a very different security model than the one most of us are used to.

In traditional applications, we spend a lot of time separating code from data, users from administrators, trusted networks from untrusted networks, and internal systems from the internet. With LLMs and agents, all of those boundaries start to blur. Instructions, context, content, and intent all arrive in the same stream. The model has to reason over that stream, and the agent has to decide what to do with the result.

That is exactly why I wanted a security control plane in front of my own AI agents.

For me, that control plane became CaneCorso™.

CaneCorsoAI

Continue reading

CaneCorso™ and the Real Problems AI Is Creating for the Business

AI didn’t sneak into the enterprise.

It walked in through productivity.

Email triage. Document handling. Support workflows. Internal copilots. Retrieval systems. Early agentic use cases. All of it made sense at the time. All of it still does.

But something changed along the way.

We didn’t just adopt AI—we embedded it into workflows that can influence decisions, expose data, and take action.

That’s where the problem starts.

And it’s exactly where CaneCorso™ is designed to operate.

CaneCorsoAI


AI Risk Isn’t a Model Problem — It’s a Workflow Problem

There’s a persistent misunderstanding in the market right now.

Most conversations about AI security still center on the model—what it knows, how it behaves, whether it can be tricked.

That’s not where the real risk lives.

The real risk shows up when:

  • Untrusted content enters a workflow
  • That workflow uses AI to interpret or transform it
  • And the output influences business operations

That content might come from:

  • Email
  • Documents
  • OCR pipelines
  • Retrieved knowledge (RAG)
  • Support tickets
  • External data sources

Once it’s in the workflow, it’s no longer just data.

It’s influence.

CaneCorso™ exists to control that influence—before it becomes an operational problem.

Continue reading

Introducing CaneCorso: An AI Application Firewall Built for Real Workflows

AI has officially crossed the line from experiment to infrastructure.

Email flows into copilots. Documents feed RAG pipelines. Support tickets trigger agents that can take action. The convenience is real—and so is the risk.

What hasn’t caught up is security.

Most security models were built for a world where inputs were predictable and trust boundaries were well-defined. That world doesn’t exist anymore. Today, untrusted content flows directly into systems that can reason, decide, and act.

That’s exactly where things get interesting—and dangerous.


When Good Data Carries Bad Instructions

One of the biggest misconceptions about AI security is that it’s a model problem. It’s not. It’s a workflow problem.

Attackers don’t need to break in anymore. They ride along with legitimate data—emails, PDFs, tickets, knowledge base entries—and inject instructions that your AI system may interpret as truth.

Think about what that means in practice:

  • A support ticket that contains hidden instructions
  • A PDF with embedded prompt injection
  • A knowledge base entry that poisons RAG outputs
  • An approval workflow manipulated through summarization

Layer in human behavior—blind trust, over-privileged access, weak validation—and you’ve got a system primed to fail in ways that traditional controls simply won’t catch.

CaneCorsoAI


A More Rational Approach to AI Security

CaneCorso™ takes a different path.

Instead of trying to block everything suspicious (and breaking workflows in the process), it follows what’s described in the Rational AI Security model —security that behaves more like an immune system than a wall.

That means:

  • Detecting and isolating threats without stopping the system
  • Treating all inbound content as untrusted by default
  • Preserving business continuity while reducing risk
  • Producing measurable, auditable outcomes

This isn’t theoretical. It’s a direct response to how AI systems actually behave in production.


One Control Plane for AI Workflows

At its core, CaneCorso gives you a shared AI Application Firewall—a single control plane that sits between your workflows and your models.

Instead of every team building its own brittle filters, you get consistent, reusable protection across:

  • Email triage and analysis
  • RAG pipelines and knowledge systems
  • Document AI and OCR ingestion
  • Support and ticketing workflows
  • Agent-driven automation

The platform delivers:

  • Runtime decisions: allow, sanitize, tokenize, or block
  • Privacy controls: redact or tokenize sensitive data before model exposure
  • Audit-ready logs: reasons, scores, and evidence you can actually use
  • Adversarial validation: Injection Scanner proves controls before and after deployment

This isn’t just about stopping attacks—it’s about making security operationally usable.

Continue reading

Building MSI PromptDefense Suite: How a Safety Tool Became a Security Platform

The Impetus: Wanting Something We Could Actually Run

Like many security folks watching the rise of LLM-driven workflows, I kept hearing the same conversations about prompt injection. They were thoughtful discussions. Smart people. Solid theory.

But the theory wasn’t what I wanted.

What I wanted was something we could actually run.

The moment that really pushed me forward came when I started testing real prompt-injection payloads against simple LLM workflows that pull content from the internet. Suddenly, the problem didn’t feel abstract anymore. A malicious instruction buried in retrieved text could quietly override system instructions, leak data, or coerce tools.

At that point, the goal became clear: build a practical defensive layer that could sit between untrusted content and an LLM — and make sure the application didn’t fall apart when something suspicious showed up.

AISecImage


What I Set Out to Build

The initial concept was simple: create a defensive scanner that could inspect incoming text before it ever reached a model. That idea eventually became PromptShield.

PromptShield focuses on defensive controls:

  • Scanning untrusted text and structured data

  • Detecting prompt injection patterns

  • Applying context-aware policies based on source trust

  • Routing suspicious content safely without crashing workflows

But I quickly realized something important:

Security teams don’t just need blocking.

They need proof.

That realization led to the second tool in the suite: InjectionProbe — an offensive assessment library and CLI designed to test scripts and APIs with standardized prompt-injection payloads and produce structured reports.

The goal became a full lifecycle toolkit:

  • PromptShield – Prevent prompt injection and sanitize risky inputs

  • InjectionProbe – Prove whether attacks still succeed

In other words: one suite that both blocks attacks and verifies what still slips through.


The Build Journey

Like many engineering projects, the first version was far from elegant. It started with basic pattern matching and policy routing.

From there, the system evolved quickly:

  • Structured payload scanning

  • JSON logging and telemetry

  • Regression testing harnesses

  • Red-team simulation frameworks

Over time the detection logic expanded to handle a wide range of adversarial techniques including:

  • Direct prompt override attempts

  • Data exfiltration instructions

  • Tool abuse and role hijacking

  • Base64 and encoded payloads

  • Leetspeak and Unicode confusables

  • Typoglycemia attacks

  • Indirect retrieval injection

  • Transcript and role spoofing

  • Many-shot role chain manipulation

  • Multimodal instruction cues

  • Bidi control character tricks

Each time a bypass appeared, it became part of a versioned adversarial corpus used for regression testing.

That was a turning point: attacks became test cases, and the system started behaving more like a traditional secure software project with CI gates and measurable thresholds.


The Fun Part

The most satisfying moments were watching the “misses” shrink after each defensive iteration.

There’s something deeply rewarding about seeing a payload that slipped through last week suddenly fail detection tests because you tightened a rule or added a new heuristic.

Another surprisingly enjoyable part was the naming process.

What started as a set of ad-hoc scripts slowly evolved into something that looked like a real platform. Eventually the pieces came together under a single identity: the MSI PromptDefense Suite.

That naming step might seem cosmetic, but it matters. Branding and workflow clarity are often what turn a security experiment into something teams actually adopt.


Lessons Learned

A few practical lessons emerged during the process:

  • Defense and offense must evolve together. Building detection without testing is guesswork.

  • Fail-safe behavior matters. Detection should never crash the application path.

  • Attack corpora should be versioned like code. This prevents security regressions.

  • Context-aware policy is a major win. Not all sources deserve the same trust level.

  • Clear reporting drives adoption. Security tools need outputs stakeholders can understand.

One practical takeaway: prompt injection testing should look more like unit testing than traditional penetration testing. It should be continuous, automated, and measurable.


Where Things Landed

The final result is a fully operational toolkit:

  • PromptShield defensive scanning library

  • InjectionProbe offensive testing framework

  • CI-style regression gates

  • JSON and Markdown assessment reporting

The suite produces artifacts such as:

  • injectionprobe_results.json

  • injectionprobe_findings_todo.md

  • assessment_report.json

  • assessment_report.md

These outputs give both developers and security teams a consistent way to evaluate the safety posture of AI-integrated systems.


What Comes Next

There’s still plenty of room to expand the platform:

  • Semantic classifiers layered on top of pattern detection

  • Adapters for queues, webhooks, and agent frameworks

  • Automated baseline policy profiles

  • Expanded adversarial benchmark corpora

The AI ecosystem is evolving quickly, and defensive tooling needs to evolve just as fast.

The good news is that the engineering model works: treat attacks like test cases, keep the corpus versioned, and measure improvements continuously.


More Information and Help

If your organization is integrating LLMs with internet content, APIs, or automated workflows, prompt injection risk needs to be part of your threat model.

At MicroSolved, we work with organizations to:

  • Assess AI-enabled systems for prompt injection risks

  • Build practical defensive guardrails around LLM workflows

  • Perform offensive testing against AI integrations and agent systems

  • Implement monitoring and policy enforcement for production environments

If you’d like to explore how tools like the MSI PromptDefense Suite could be applied in your environment — or if you want experienced consultants to help evaluate the security of your AI deployments — contact the MicroSolved team to start the conversation.

Practical AI security starts with testing, measurement, and iterative defense.

 

 

* AI tools were used as a research assistant for this content, but human moderation and writing are also included. The included images are AI-generated.

Identity Security Is Now the #1 Attack Vector — and Most Organizations Are Not Architected for It

How identity became the new perimeter

In 2025, identity is no longer simply a control at the edge of your network — it is the perimeter. As organizations adopt SaaS‑first strategies, hybrid work, remote access, and cloud identity federation, the traditional notion of network perimeter has collapsed. What remains is the identity layer — and attackers know it.

Today’s breaches often don’t involve malware, brute‑force password cracking, or noisy exploits. Instead, adversaries leverage stolen tokens, hijacked sessions, and compromised identity‑provider (IdP) infrastructure — all while appearing as legitimate users.

SyntheticID

That shift makes identity security not just another checkbox — but the foundation of enterprise defense.


Failure points of modern identity stacks

Even organizations that have deployed defenses like multi‑factor authentication (MFA), single sign‑on (SSO), and conditional access policies often remain vulnerable. Why? Because many identity architectures are:

  • Overly permissive — long‑lived tokens, excessive scopes, and flat permissioning.

  • Fragmented — identity data is scattered across IdPs, directories, cloud apps, and shadow IT.

  • Blind to session risk — session tokens are often unmonitored, allowing token theft and session hijacking to go unnoticed.

  • Incompatible with modern infrastructure — legacy IAMs often can’t handle dynamic, cloud-native, or hybrid environments.

In short: you can check off MFA, SSO, and PAM, and still be wide open to identity‑based compromise.


Token‑based attack: A walkthrough

Consider this realistic scenario:

  1. An employee logs in using SSO. The browser receives a token (OAuth or session cookie).

  2. A phishing attack — or adversary-in-the-middle (AiTM) — captures that token after the user completes MFA.

  3. The attacker imports the token into their browser and now impersonates the user — bypassing MFA.

  4. The attacker explores internal SaaS tools, installs backdoor OAuth apps, and escalates privileges — all without tripping alarms.

A single stolen token can unlock everything.


Building identity security from first principles

The modern identity stack must be redesigned around the realities of today’s attacks:

  • Identity is the perimeter — access should flow through hardened, monitored, and policy-enforced IdPs.

  • Session analytics is a must — don’t just authenticate at login. Monitor behavior continuously throughout the session.

  • Token lifecycle control — enforce short token lifetimes, minimize scopes, and revoke unused sessions immediately.

  • Unify the view — consolidate visibility across all human and machine identities, across SaaS and cloud.


How to secure identity for SaaS-first orgs

For SaaS-heavy and hybrid-cloud organizations, these practices are key:

  • Use a secure, enterprise-grade IdP

  • Implement phishing-resistant MFA (e.g., hardware keys, passkeys)

  • Enforce context-aware access policies

  • Monitor and analyze every identity session in real time

  • Treat machine identities as equal in risk and value to human users


Blueprint: continuous identity hygiene

Use systems thinking to model identity as an interconnected ecosystem:

  • Pareto principle — 20% of misconfigurations lead to 80% of breaches.

  • Inversion — map how you would attack your identity infrastructure.

  • Compounding — small permissions or weak tokens can escalate rapidly.

Core practices:

  • Short-lived tokens and ephemeral access

  • Just-in-time and least privilege permissions

  • Session monitoring and token revocation pipelines

  • OAuth and SSO app inventory and control

  • Unified identity visibility across environments


30‑Day Identity Rationalization Action Plan

Day Action
1–3 Inventory all identities — human, machine, and service.
4–7 Harden your IdP; audit key management.
8–14 Enforce phishing-resistant MFA organization-wide.
15–18 Apply risk-based access policies.
19–22 Revoke stale or long-lived tokens.
23–26 Deploy session monitoring and anomaly detection.
27–30 Audit and rationalize privileges and unused accounts.

More Information

If you’re unsure where to start, ask these questions:

  • How many active OAuth grants are in our environment?

  • Are we monitoring session behavior after login?

  • When was the last identity privilege audit performed?

  • Can we detect token theft in real time?

If any of those are difficult to answer — you’re not alone. Most organizations aren’t architected to handle identity as the new perimeter. But the gap between today’s risks and tomorrow’s solutions is closing fast — and the time to address it is now.


Help from MicroSolved, Inc.

At MicroSolved, Inc., we’ve helped organizations evolve their identity security models for more than 30 years. Our experts can:

  • Audit your current identity architecture and token hygiene

  • Map identity-related escalation paths

  • Deploy behavioral identity monitoring and continuous session analytics

  • Coach your team on modern IAM design principles

  • Build a 90-day roadmap for secure, unified identity operations

Let’s work together to harden identity before it becomes your organization’s softest target. Contact us at microsolved.com to start your identity security assessment.


References

  1. BankInfoSecurity – “Identity Under Siege: Enterprises Are Feeling It”

  2. SecurityReviewMag – “Identity Security in 2025”

  3. CyberArk – “Lurking Threats in Post-Authentication Sessions”

  4. Kaseya – “What Is Token Theft?”

  5. CrowdStrike – “Identity Attacks in the Wild”

  6. Wing Security – “How to Minimize Identity-Based Attacks in SaaS”

  7. SentinelOne – “Identity Provider Security”

  8. Thales Group – “What Is Identity Security?”

  9. System4u – “Identity Security in 2025: What’s Evolving?”

  10. DoControl – “How to Stop Compromised Account Attacks in SaaS”

 

* AI tools were used as a research assistant for this content, but human moderation and writing are also included. The included images are AI-generated.

Securing AI / Generative AI Use in the Enterprise: Risks, Gaps & Governance

Imagine this: a data science team is evaluating a public generative AI API to help with summarization of documents. One engineer—trying to accelerate prototyping—uploads a dataset containing customer PII (names, addresses, payment tokens) without anonymization. The API ingests that data. Later, another user submits a prompt that triggers portions of the PII to be regurgitated in an output. The leakage reaches customers, regulators, and media.

This scenario is not hypothetical. As enterprise adoption of generative AI accelerates, organizations are discovering that the boundary between internal data and external AI systems is porous—and many have no governance guardrails in place.

VendorRiskAI

According to a recent report, ~89% of enterprise generative AI usage is invisible to IT oversight—that is, it bypasses sanctioned channels entirely. Another survey finds that nearly all large firms deploying AI have seen risk‑related losses tied to flawed outputs, compliance failures, or bias.

The time to move from opportunistic pilots toward robust governance and security is now. In this post I map the risk taxonomy, expose gaps, propose controls and governance models, and sketch a maturity roadmap for enterprises.


Risk Taxonomy

Below I classify major threat vectors for AI / generative AI in enterprise settings.

1. Model Poisoning & Adversarial Inputs

  • Training data poisoning: attackers insert malicious or corrupted data into the training set so that the model learns undesirable associations or backdoors.

  • Backdoor / trigger attacks: a model behaves normally unless a specific trigger pattern (e.g. a token or phrase) is present, which causes malicious behavior.

  • Adversarial inputs at inference time: small perturbations or crafted inputs cause misclassification or manipulation of model outputs.

  • Prompt injection / jailbreaking: an end user crafts prompts to override constraints, extract internal context, or escalate privileges.

2. Training Data Leakage

  • Sensitive training data (proprietary IP, PII, trade secrets) may inadvertently be memorized by large models and revealed via probing.

  • Even with fine‑tuning, embeddings or internal layers might leak associations that can be reverse engineered.

  • Leakage can also occur via model updates, snapshots, or transfer learning pipelines.

3. Inference-Time Output Attacks & Leakage

  • Model outputs might infer relationships (e.g. “given X, the missing data is Y”) that were not explicitly in training but learned implicitly.

  • Large models can combine inputs across multiple queries to reconstruct confidential data.

  • Malicious users can sample outputs exhaustively or probe with adversarial prompts to elicit sensitive data.

4. Misuse & “Shadow AI”

  • Shadow AI: employees use external generative tools outside IT visibility (e.g. via personal ChatGPT accounts) and paste internal documents, violating policy and leaking data.

  • Use of unconstrained AI for high-stakes decisions without validation or oversight.

  • Automation of malicious behaviors (fraud, social engineering) via internal AI capabilities.

5. Compliance, Privacy & Governance Risks

  • Violation of data protection regulations (e.g. GDPR, CCPA) via improper handling or cross‑boundary transfer of PII.

  • In regulated industries (healthcare, finance), AI outputs may inadvertently produce disallowed inferences or violate auditability requirements.

  • Lack of explainability or audit trails makes it hard to prove compliance or investigate incidents.

  • Model decisions may reflect bias, unfairness, or discriminatory patterns that trigger regulatory or reputational liabilities.


Gaps in Existing Solutions

  • Traditional security tooling is blind to AI risks: DLP, EDR, firewall rules do not inspect semantic inference or prompt-based leakage.

  • Lack of visibility into model internals: Most deployed models (especially third‑party or foundation models) are black boxes.

  • Sparse standards & best practices: While frameworks exist (NIST AI RMF, EU AI Act, ISO proposals), concrete guidance for securing generative AI in enterprises is immature.

  • Tooling mismatch: Many AI governance tools are nascent and do not integrate smoothly with existing enterprise security stacks.

  • Team silos: Data science, DevOps, and security often operate in silos. Defects emerge at the intersection.

  • Skill and resource gaps: Few organizations have staff experienced in adversarial ML, formal verification, or privacy-preserving AI.

  • Lifecycle mismatch: AI models require continuous retraining, drift detection, versioning—traditional security is static.


Governance & Defensive Strategies

Below are controls, governance practices, and architectural strategies enterprises should consider.

AI Risk Assessment / Classification Framework

  • Inventorize all AI / ML assets (foundation models, fine‑tuned models, inference APIs).

  • Classify models by risk tier (e.g. low / medium / high) based on sensitivity of inputs/outputs, business criticality, and regulatory impact.

  • Map threat models for each asset: e.g. poisoning, leakage, adversarial use.

  • Integrate this with enterprise risk management (ERM) and vendor risk processes.

Secure Development & DevSecOps for Models

  • Embed adversarial testing, fuzzing, red‑teaming in model training pipelines.

  • Use data validation, anomaly detection, outlier filtering before ingesting training data.

  • Employ version control, model lineage, and reproducibility controls.

  • Build a “model sandbox” environment with strict controls before production rollout.

Access Control, Segmentation & Audit Trails

  • Enforce least privilege access for training data, model parameters, hyperparameters.

  • Use role-based access control (RBAC) and attribute-based access (ABAC) for model execution.

  • Maintain full audit logging of prompts, responses, model invocations, and guardrails.

  • Segment model infrastructure from general infrastructure (use private VPCs, zero trust).

Privacy / Sanitization Techniques

  • Use differential privacy to add noise and limit exposure of individual records.

  • Use secure multiparty computation (SMPC) or homomorphic encryption for sensitive computations.

  • Apply data anonymization / tokenization / masking before use.

  • Use output filtering / content policies to supersede model outputs that might leak or violate policy.

Monitoring, Anomaly Detection & Runtime Guardrails

  • Monitor model outputs for anomalies, drift, suspicious prompting patterns.

  • Use “canary” prompts or test probes to detect model corruption or behavior shifts.

  • Rate-limit or throttle requests to model endpoints.

  • Use AI-defense systems to detect prompt injection or malicious patterns.

  • Flag or block high-risk output paths (e.g. outputs that contain PII, internal config, backdoor triggers).


Operational Integration

Security–Data Science Collaboration

  • Embed security engineers in the AI development lifecycle (shift-left).

  • Educate data scientists in adversarial ML, model risks, privacy constraints.

  • Use cross-functional review boards for high-risk model deployments.

Shadow AI Discovery & Mitigation

  • Monitor outbound traffic or SaaS logins for generative AI usage.

  • Use SaaS monitoring tools or proxy policies to intercept and flag unsanctioned AI use.

  • Deploy internal tools or wrappers for generative AI that inject audit controls.

  • Train employees and publish acceptable use policies for AI usage.

Runtime Controls & Continuous Testing

  • Periodically red-team models (both internal and third-party) to detect vulnerabilities.

  • Revalidate models after each update or retrain.

  • Set up incident response plans specific to AI incidents (model rollback, containment).

  • Conduct regular audits of model behavior, logs, and drift performance.


Case Studies & Real-World Failures & Successes

  • Researchers have found that injecting as few as 250 malicious documents can backdoor a model.

  • Foundation model leakage incidents have been demonstrated in academic research (models regurgitating verbatim input).

  • Organizations like Microsoft Azure, Google Cloud, and OpenAI are starting to offer tools and guardrails (rate limits, privacy options, usage logging) to support enterprise introspection.

  • Some enterprises are mandating all internal AI interactions to flow through a “governed AI proxy” layer to filter or scrub prompts/outputs.


Roadmap / Maturity Model

I propose a phased model:

  1. Awareness & Inventory

    • Catalog AI/ML assets

    • Basic training & policies

    • Executive buy-in

  2. Baseline Controls

    • Access controls, audit logging

    • Data sanitization & DLP for AI pipelines

    • Shadow AI monitoring

  3. Model Protection & Hardening

    • Differential privacy, adversarial testing, prompt filters

    • Runtime anomaly detection

    • Sandbox staging

  4. Audit, Metrics & Continuous Improvement

    • Regular red teaming

    • Drift detection & revalidation

    • Integration into ERM / compliance

    • Internal assurance & audit loops

  5. Advanced Guardrails & Automation

    • Automated policy enforcement

    • Self-healing / rollback mechanisms

    • Formal verification, provable defenses

    • Model explainability & transparency audits


By advancing along this maturity curve, enterprises can evolve from reactive posture to proactive, governed, and resilient AI operations—reducing risk while still reaping the transformative potential of generative technologies.

Need Help or More Information?

Contact MicroSolved and put our deep expertise to work for you in this area. Email us (info@microsolved.com) or give us a call (+1.614.351.1237) for a no-hassle, no-pressure discussion of your needs and our capabilities. We look forward to helping you protect today and predict what is coming next. 

 

 

* AI tools were used as a research assistant for this content, but human moderation and writing are also included. The included images are AI-generated.

Zero-Trust API Security: Bridging the Gaps in a Fragmented Landscape

It feels like every security product today is quick to slap on a “zero-trust” label, especially when it comes to APIs. But as we dig deeper, we keep encountering a sobering reality: despite all the buzzwords, many “zero-trust” API security stacks are hollow at the core. They authenticate traffic, sure. But visibility? Context? Real-time policy enforcement? Not so much.

APISecurity

We’re in the middle of a shift—from token-based perimeter defenses to truly identity- and context-aware interactions. Our recent research highlights where most of our current stacks fall apart, and where the industry is hustling to catch up.

1. The Blind Spots We Don’t Talk About

APIs have become the connective tissue of modern enterprise architectures. Unfortunately, nearly 50% of these interfaces are expected to be operating outside any formal gateway by 2025. That means shadow, zombie, and rogue APIs are living undetected in production environments—unrouted, uninspected, unmanaged.

Traditional gateways only see what they route. Anything else—misconfigured dev endpoints, forgotten staging interfaces—falls off the radar. And once they’re forgotten, they’re defenseless.

2. Static Secrets Are Not Machine Identity

Another gaping hole: how we handle machine identities. The zero-trust principle says, “never trust, always verify,” yet most API clients still rely on long-lived secrets and certificates. These are hard to track, rotate, or revoke—leaving wide-open attack windows.

Machine identities now outnumber human users 45 to 1. That’s a staggering ratio, and without dynamic credentials and automated lifecycle controls, it’s a recipe for disaster. Short-lived tokens, mutual TLS, identity-bound proxies—these aren’t future nice-to-haves. They’re table stakes.

3. Context-Poor Enforcement

The next hurdle is enforcement that’s blind to context. Most Web Application and API Protection (WAAP) layers base their decisions on IPs, static tokens, and request rates. That won’t cut it anymore.

Business logic abuse, like BOLA (Broken Object Level Authorization) and GraphQL aliasing, often appears totally legit to traditional defenses. We need analytics that understand the data, the user, the behavior—and can tell the difference between a normal batch query and a cleverly disguised scraping attack.

4. Authorization: Still Too Coarse

Least privilege isn’t just a catchphrase. It’s a mandate. Yet most authorization today is still role-based, and roles tend to explode in complexity. RBAC becomes unmanageable, leading to users with far more access than they need.

Fine-grained, policy-as-code models using tools like OPA (Open Policy Agent) or Cedar are starting to make a difference. But externalizing that logic—making it reusable and auditable—is still rare.

5. The Lifecycle Is Still a Siloed Mess

Security can’t be a bolt-on at runtime. Yet today, API security tools are spread across design, test, deploy, and incident response, with weak integrations and brittle handoffs. That gap means misconfigurations persist and security debt accumulates.

The modern goal should be lifecycle integration: shift-left with CI/CD-aware fuzzing, shift-right with real-time feedback loops. A living, breathing security pipeline.


The Path Forward: What the New Guard Looks Like

Here’s where some vendors are stepping up:

  • API Discovery: Real-time inventories from tools like Noname and Salt Illuminate.

  • Machine Identity: Dynamic credentials from Corsha and Venafi.

  • Runtime Context: Behavior analytics engines by Traceable and Salt.

  • Fine-Grained Authorization: Centralized policy with Amazon Verified Permissions and Permify.

  • Lifecycle Integration: Fuzzing and feedback via CI/CD from Salt and Traceable.

If you’re rebuilding your API security stack, this is your north star.


Final Thoughts

Zero-trust for APIs isn’t about more tokens or tighter gateways. It’s about building a system where every interaction is validated, every machine has a verifiable identity, and every access request is contextually and precisely authorized. We’re not quite there yet, but the map is emerging.

Security pros, it’s time to rethink our assumptions. Forget the checkboxes. Focus on visibility, identity, context, and policy. Because in this new world, trust isn’t just earned—it’s continuously verified.

For help or to discuss modern approaches, give MicroSolved, Inc. a call (+1.614.351.1237) or drop us a line (info@microsolved.com). We’ll be happy to see how our capabilities align with your initiatives. 

 

 

* AI tools were used as a research assistant for this content, but human moderation and writing are also included. The included images are AI-generated.