The Endpoint Passed. The Transaction Failed: Test APIs as Business Systems

The gateway accepts the token.

The request matches the schema. The endpoint rejects malformed input. Rate limits are enabled. Automated scans return no critical findings. Each API operation appears to work as designed.

Then the business transaction fails.

A user applies the same one-time credit twice through concurrent requests. A partner calls the final step before the required approval. A mobile client changes an object identifier and acts on another customer’s record. A cancellation arrives after fulfillment has started but still triggers a full refund. A retry repeats an external payment because the first result was uncertain.

The individual requests may be technically valid.

The sequence, authority, timing, or business result is not.

That is the gap between endpoint security and transaction assurance.

API security should prove that the complete business transaction preserves its intended rules across actors, objects, states, sequence, timing, retries, and failure—not merely that individual endpoints reject malformed requests.

APISec

APIs Implement Business Decisions

An API is not only a technical interface.

It may approve a payment, reserve inventory, change ownership, create an account, release data, issue a refund, alter a configuration, assign a role, trigger a shipment, or call another provider.

The National Institute of Standards and Technology’s updated API protection guidance describes modern enterprise systems as relying on families of APIs to support organizational business processes. The March 2026 update adds API risks and recommended controls organized by lifecycle stage.

That framing matters.

If several APIs jointly implement a business process, assurance cannot stop at the boundary of each endpoint. The organization must also establish whether the combined behavior preserves the business decision.

Consider a simple approval workflow.

One endpoint creates a request. Another attaches supporting data. A third records an approval. A fourth executes the action. Each endpoint can authenticate the caller, validate its input, and return the expected status code.

The workflow can still be unsafe if:

  • The requester can also approve.
  • The approval applies to a different version of the request than the one executed.
  • The execution step can be called before approval.
  • A completed approval can be replayed.
  • Two requests can race and both consume the same limit.
  • A web client enforces a restriction that the underlying API does not.
  • A trusted downstream service accepts more authority than the original user possessed.

The security property lives in the relationships among the calls.

Start With the Business Invariant

Before testing the workflow, state what must remain true.

Call this the business invariant.

Examples include:

  • Only the owner of a record, or an explicitly authorized delegate, may modify it.
  • A requester may not approve their own high-value transaction.
  • A one-time credit may be issued only once to an eligible customer.
  • A payment may execute only for the amount, destination, and order the user approved.
  • A completed or expired step may not be replayed.
  • Inventory may not fall below the permitted threshold.
  • A refund may not exceed the amount actually settled.
  • A tenant administrator may act only within the tenant they administer.

These statements are more useful than “the API requires authentication.”

Authentication identifies an actor. The invariant defines what that actor may cause under specific business conditions.

The OWASP Top 10:2025 keeps broken access control in the first position. Its guidance includes enforcing record ownership, applying business limits in the domain model, and testing functional access control through unit and integration tests.

The OWASP API Security Top 10 adds another important dimension: an endpoint can expose a sensitive business flow whose excessive or automated use harms the business even when the operation is available by design.

The first question is therefore not:

Does the endpoint work?

It is:

What must remain true when this business transaction is performed, repeated, interrupted, reordered, or attempted by the wrong actor?

Build the Transaction Security Model

A useful transaction model has seven parts.

1. Invariant: What must never become false?

Write the rule in business language.

Avoid vague statements such as “prevent fraud” or “enforce authorization.” Name the protected result: who may act, on which object, under what conditions, how often, within which limits, and with what required approvals.

If the team cannot state the invariant, the test plan will inherit the same ambiguity.

2. Actors: Who or what can participate?

List every relevant human and machine identity.

Include customers, employees, administrators, delegates, service accounts, partners, background jobs, mobile applications, web applications, support tools, automation, and downstream providers.

Do not assume that two callers with the same role have the same authority. Ownership, tenant, relationship, device, location, transaction value, approval history, and current risk state may all change the decision.

OWASP’s authorization guidance recommends defining trust boundaries, user types, resources, operations, and the relationships among them during design, then creating tests to prove that those permissions are enforced.

3. Objects: What is being read, changed, or transferred?

Identify the accounts, records, funds, orders, documents, roles, devices, configurations, entitlements, and other objects involved.

Then test ownership and relationship explicitly.

A user may be authorized to call an endpoint without being authorized to act on every object the endpoint can reach. OWASP identifies this as broken object-level authorization: the function is available, but the requested object falls outside the caller’s authority.

4. States: Which conditions change what is allowed?

Define the transaction states and the valid transitions among them.

A request might move from draft to submitted, reviewed, approved, executing, completed, disputed, reversed, or expired. The exact names matter less than making the transitions explicit.

The server should validate the current state before accepting the next action. The client interface should not be the only mechanism preventing a user from skipping ahead, returning to a completed step, or changing a transaction after approval.

OWASP’s business-logic security guidance recommends enforcing workflows as explicit state machines, rejecting replays of completed steps, expiring partial states, and testing the intended business process rather than relying on the user interface to preserve order.

5. Paths: Which interfaces can reach the same business action?

Map every route to the outcome.

The same action may be available through a web application, mobile API, partner integration, administrative console, GraphQL operation, webhook, batch job, legacy version, support function, or internal service.

Controls must be consistent across those paths.

A restriction in the web interface does not protect a directly callable API. An authorization check in a current endpoint does not protect an older version. An administrative function placed beside ordinary functions still requires an explicit decision for the caller. OWASP’s guidance on function-level authorization recommends reviewing the complete role and group hierarchy and denying access by default for every function.

6. Timing: What changes when requests overlap, repeat, or arrive late?

Test concurrency, retries, replay, cancellation, timeout, and partial failure.

Many business rules have the form “check a condition, then act.” That creates a risk when two requests can observe the same valid condition before either records the result.

Test whether:

  • Two requests can redeem the same benefit.
  • A retry repeats a non-idempotent external action.
  • A cancellation races with fulfillment or settlement.
  • An expired approval remains usable.
  • A partial transaction can be resumed after its assumptions changed.
  • A delayed webhook reverses a newer decision.
  • A client changes parameters while reusing an idempotency key.

These are not malformed-request tests.

They are consistency tests.

7. Evidence: What proves the invariant held?

A successful status code is not enough.

Preserve the evidence needed to reconstruct the transaction:

  • The authenticated actor and effective authority.
  • The object, owner, tenant, and relevant relationships.
  • The transaction state before and after the action.
  • The policy or business rule evaluated.
  • The significant values approved by the user or system.
  • The request, decision, downstream action, and final outcome.
  • The retry, replay, or idempotency identifiers.
  • The reason for a denial, exception, override, or reversal.

The purpose is not to log every secret or duplicate sensitive data.

It is to retain enough trustworthy evidence to determine whether the business rule was enforced and to investigate when the outcome is disputed.

Test Valid Data in the Wrong Context

Traditional negative testing often begins with invalid input.

That remains useful. APIs should reject malformed, oversized, unexpected, and dangerous data.

Business-transaction testing adds a different form of negative test:

Use valid data, valid identities, and valid functions in an invalid business context.

Try the correct request with:

  • The wrong owner.
  • The wrong tenant.
  • The wrong role.
  • The wrong relationship.
  • The wrong transaction state.
  • The wrong order of operations.
  • A changed amount or destination after approval.
  • A repeated one-time action.
  • Two simultaneous calls.
  • An alternate client or API version.
  • A delayed or duplicated downstream message.
  • A valid credential whose business authority has changed.

This is where the gap between technical permission and business permission becomes visible.

Keep the Existing Controls

This model is not an argument against gateways, authentication, schema validation, rate limits, automated scanning, code analysis, or endpoint-level testing.

Those controls answer essential questions.

They can establish that a caller presented an accepted credential, a request matched the contract, an input avoided a known weakness, or an endpoint enforced a local policy.

They cannot independently establish that the complete transaction preserved ownership, separation of duties, state, value, timing, and business intent across every participating interface.

Use the controls together:

  1. Define the invariant during design.
  2. Enforce authorization and state on the server.
  3. Test each endpoint’s local requirements.
  4. Test the complete transaction across roles and objects.
  5. Test ordering, replay, concurrency, retries, and failure.
  6. Monitor the business outcome, not only the request volume.
  7. Turn each discovered abuse path into a regression test.

The objective is not to replace automation with manual testing.

It is to give automation better rules to prove.

What Security Leaders Should Do This Week

Choose one API-supported transaction involving money, sensitive data, privilege, inventory, approval, or an irreversible action.

  1. State the invariant. Write one sentence describing what must remain true.
  2. Map the transaction. Identify the actors, objects, states, endpoints, clients, and downstream services involved.
  3. Build the authority matrix. Record who may perform each action on which objects and under which conditions.
  4. Test one sequence failure. Skip a step, reorder two steps, replay a completed step, or modify the transaction after approval.
  5. Test one timing failure. Submit simultaneous requests, repeat an uncertain operation, or race cancellation against completion.
  6. Verify the evidence. Confirm that logs and records show the actor, authority, state, decision, and final outcome without exposing unnecessary sensitive data.
  7. Create the regression. Add the discovered business rule and abuse case to design requirements, automated tests, and release criteria.

Then ask a direct question:

Can we prove that this business transaction stays within its intended limits when every individual request is technically valid?

If the answer is unclear, the endpoint tests are not the end of the assessment.

They are the beginning of the transaction test.

Put Transaction-Level Assurance Into Practice

MicroSolved, Inc. can help organizations evaluate application, API, and mobile workflows where authorization, business logic, and transaction integrity matter.

Useful consulting engagements may include:

  • Identifying high-consequence business transactions and their required invariants.
  • Threat modeling actors, objects, roles, tenants, states, and downstream dependencies.
  • Testing object-level and function-level authorization across web, mobile, administrative, partner, and legacy paths.
  • Evaluating sequence, replay, concurrency, idempotency, cancellation, rollback, and partial-failure behavior.
  • Reviewing API design, gateways, schemas, logging, monitoring, and abuse controls as one assurance system.
  • Converting findings into prioritized mitigations, regression tests, and practical release criteria.
  • Supporting targeted assessments for payments, approvals, account recovery, data access, administrative actions, and other sensitive workflows.

To discuss an application or API security review, contact MicroSolved at info@microsolved.com or +1.614.351.1237.

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 Dangerous Moment Is the State Change: Security Testing for Connected Devices

The firmware image passes static analysis.

The administrative interface survives a penetration test. The network scan shows only approved services. The mobile application and cloud API have been reviewed. The device enters production with a clean report.

Then the device changes state.

A technician enters maintenance mode. An update loses power halfway through installation. A factory reset prepares the device for a new owner. A recovery process restores an older image. A field engineer connects to a local service interface. A retired device remains registered to a cloud account.

The controls that worked during normal operation may not work the same way during any of those transitions.

That is the testing gap.

Connected-device security is usually evaluated as a collection of components and attack surfaces: firmware, hardware, network services, wireless interfaces, applications, APIs, and cloud infrastructure. Each view matters. None of them, by itself, proves that the product preserves its intended trust state when it is provisioned, updated, interrupted, repaired, reset, transferred, recovered, or retired.

The practical lesson is straightforward:

Device security assurance should test the transitions that change authority, software, data, and operating mode—not only the device’s steady state.

ConfigRvw

A Connected Product Has More Than One Security State

A connected device is not simply secure or insecure.

It moves through states.

The lifecycle may include manufacturing, initial provisioning, normal operation, degraded operation, maintenance, software update, rollback, recovery, factory reset, ownership transfer, and retirement. Some products add calibration, emergency operation, offline modes, safety overrides, diagnostic modes, or vendor-support access.

Each state can change:

  • Which identities are trusted.
  • Which interfaces are reachable.
  • Which code is allowed to run.
  • Which secrets are present.
  • Which data is retained.
  • Which actions are permitted.
  • Which events are logged.
  • Which recovery paths are available.

The current NIST IR 8259 Revision 1, finalized in April 2026, tells IoT product manufacturers to define expected customers and use cases, identify cybersecurity requirements, and plan how the product will support customer risk management. The companion NIST IR 8259A baseline includes device identification, configuration, data protection, logical access to interfaces, secure software update, and cybersecurity-state awareness.

Those capabilities do not exist only during normal operation.

They must remain meaningful while the product changes state.

Steady-State Testing Can Miss Transition Risk

Static firmware analysis can identify exposed secrets, unsafe configurations, vulnerable components, dangerous functions, and other defects inside an image.

Dynamic testing can examine running services, authentication, authorization, input handling, communications, and runtime behavior.

Hardware and interface testing can examine local access paths that a remote network assessment will never see.

Application and API testing can evaluate the services that control the device, store its data, and connect it to other systems.

The OWASP IoT Security Testing Guide reflects this broader reality by organizing testing around the device model, firmware, interfaces, communications, and runtime behavior rather than treating an IoT product as a single web endpoint.

The transition problem appears between those views.

Consider the questions created by an update:

  • Who is allowed to initiate it?
  • How does the device authenticate the update source and verify the image?
  • Can an authorized image be replayed after it should have expired?
  • What happens if power, storage, or connectivity fails halfway through installation?
  • Does rollback return the device to an older but vulnerable state?
  • Are security settings, keys, and logs preserved correctly?
  • Does the device report that it is running a degraded or unexpected version?

Now consider a factory reset:

  • Which user data is removed?
  • Which device identity and cryptographic material remain?
  • Are cloud registrations, mobile-app bindings, or vendor accounts disconnected?
  • Does the reset restore an unsafe default configuration?
  • Can a previous owner or administrator still reach the product?
  • Is the reset event visible to the next operator?

A review that tests only the stable image before and after the transition may miss the condition created during the transition itself.

Build a State-Transition Test Model

Start with a state diagram, not a tool list.

For each important transition, create a compact test record with six fields.

1. Entry condition: What starts the transition?

Identify the command, signal, physical action, scheduled event, fault, account action, or environmental condition that moves the device out of its current state.

Examples include an update request, boot failure, service-button sequence, cloud command, expired certificate, loss of connectivity, storage exhaustion, ownership transfer, or operator decision.

The entry condition should be testable. If the team cannot reproduce the condition safely, it cannot demonstrate how the product behaves when the condition occurs.

2. Authority: Who or what may cause it?

Name every actor that can initiate, approve, block, or complete the transition.

That may include the device owner, local administrator, vendor support team, cloud service, companion application, update-signing system, physical technician, automation service, or another device.

Then test the boundary between those roles.

An identity authorized to read device status should not automatically gain authority to install firmware. A field technician permitted to run diagnostics should not silently become a permanent administrator. A cloud service that can request an update should not be able to bypass the device’s independent verification of the image.

3. Protected state: What changes or persists?

List the assets and security properties that the transition can modify:

  • Firmware and boot components.
  • Configuration and policy.
  • Credentials, keys, certificates, and trust anchors.
  • User, customer, operational, or diagnostic data.
  • Device identity and ownership records.
  • Local and network interfaces.
  • Logging and monitoring state.
  • Safety limits and operating parameters.

Testing should confirm both what changes and what must not change.

4. Failure path: What happens when the transition does not finish normally?

Interrupt the process in a controlled environment.

Remove a dependency. Deny a required authorization. Present an invalid or older image. Exhaust an expected resource. Break connectivity at a defined step. Restart the device while state is being written.

The purpose is not to create theatrical destruction.

It is to learn whether failure moves the product into a secure, observable, and recoverable condition.

5. Evidence: What proves the resulting state?

Define the evidence an operator, customer, assessor, or incident responder can use to determine what happened.

That may include version and integrity measurements, event logs, update records, administrative actions, device-state reports, cloud audit records, tamper indicators, recovery results, or retained forensic artifacts.

If the device cannot explain its own security state, the organization may have to guess whether the transition succeeded.

6. Consequence: What can the new state affect?

Connect the technical result to the product’s real use.

Could the device disclose data, stop a business process, permit unauthorized control, produce incorrect measurements, lose availability, weaken a safety function, or become impossible to recover remotely?

The same technical defect can have very different significance in a consumer accessory, payment device, building controller, medical product, industrial sensor, or safety-related system.

Protect, Detect, and Recover

Device assurance is incomplete if it tests only whether unauthorized change can be prevented.

NIST SP 800-193 organizes platform-firmware resilience around three goals: protect the platform from unauthorized change, detect unauthorized change when it occurs, and recover rapidly and securely.

That sequence is a useful testing standard.

Protect

Verify that only authorized entities can initiate the transition and that the device independently validates the software, configuration, or command it is about to trust.

Test version policy, signing, authorization separation, local access controls, service interfaces, and the protection of keys and trust anchors.

Detect

Verify that the product can recognize and report an incomplete, unauthorized, degraded, or unexpected state.

An update mechanism that rejects a bad image but leaves no useful record may protect the device while weakening incident response. A device that boots a fallback image without reporting the version change may remain operational while concealing a material security event.

Recover

Verify that recovery returns the product to an intended trust state, not merely to an operable state.

The device may power on and still be running an obsolete image, unsafe configuration, untrusted key set, or diagnostic mode. Recovery evidence should show what was restored, which trust decision authorized it, and what follow-up action remains.

Physical Consequence Changes the Test Plan

Connected products can affect more than data.

The final NIST SP 800-82 Revision 3 defines operational technology broadly as programmable systems and devices that interact with the physical environment and emphasizes that security measures must account for performance, reliability, and safety requirements.

That changes how testing should be performed.

An aggressive production scan, unplanned reboot, malformed command, or interrupted update may be acceptable in a disposable lab unit and unacceptable in a live operational process. Some questions should be answered through offline firmware analysis, emulation, configuration review, representative hardware, isolated test networks, or a controlled lab before anyone considers validation in the field.

The test plan should distinguish:

  1. What can be examined without operating the device.
  2. What can be exercised safely on representative hardware.
  3. What requires an isolated system or simulated environment.
  4. What must be validated in the deployed environment under a carefully approved procedure.
  5. What should not be tested actively because the safety or availability consequence is unacceptable.

Restraint is part of good testing.

The objective is not to prove that the assessor can break the device.

It is to produce useful evidence without creating the harm the assessment is supposed to prevent.

Scale Assurance by Consequence and Change

Not every connected product needs the same depth of testing.

A low-consequence, easily replaced device with no sensitive data and minimal authority does not need the same assurance program as a long-lived controller that can alter a physical process.

Set the testing tier using factors such as:

  • Safety and operational consequence.
  • Access to sensitive data or privileged actions.
  • Exposure to untrusted networks, users, or physical access.
  • Authority of local, wireless, cloud, and service interfaces.
  • Complexity of update, rollback, and recovery mechanisms.
  • Dependence on companion applications, APIs, and vendor cloud services.
  • Expected service life and ability to replace the product.
  • Availability of logs, integrity evidence, and emergency recovery.

Then define retest triggers.

A new firmware branch, bootloader, hardware revision, wireless stack, update service, cloud backend, cryptographic design, manufacturing process, or field-service workflow can change the transition model even when the product name remains the same.

The current NIST IR 8259 Revision 1 reinforces this lifecycle view by asking manufacturers to consider customer needs, product requirements, risk mitigations, and the support customers require to use the product securely.

Security testing should follow the product as those conditions change.

Measure Transition Assurance, Not Just Defect Counts

A vulnerability count is useful for remediation tracking.

It does not show whether the product preserves trust across its lifecycle.

More useful measures include:

  • Percentage of high-consequence state transitions represented in the test model.
  • Percentage of update and recovery paths that independently authenticate software and enforce version policy.
  • Percentage of reset, transfer, and retirement paths that remove customer data and obsolete account bindings as designed.
  • Percentage of maintenance and diagnostic actions attributable to a named identity.
  • Percentage of interrupted transitions that produce an observable security-state record.
  • Time required to recover a representative device to a known, supported, and verified state.
  • Number of product changes that altered the threat model but did not trigger security retesting.
  • Percentage of critical transition tests that include the companion application, API, cloud service, and deployed operating assumptions.

One question is especially revealing:

After an update, reset, or recovery fails, can you prove which trust state the device is in?

If the answer depends on a visual guess, undocumented service sequence, or the memory of one engineer, the product may be recoverable without being governable.

What Security Leaders Should Do This Week

Choose one connected product with meaningful business, safety, privacy, or operational consequence.

  1. Draw its states. Include provisioning, normal operation, update, degraded operation, maintenance, recovery, reset, transfer, and retirement where applicable.
  2. Name every transition authority. Identify who or what can initiate, approve, complete, or block each state change.
  3. Map what changes and persists. Include software, configuration, identities, keys, data, interfaces, logging, and cloud bindings.
  4. Choose one failure path. Safely interrupt an update, recovery, reset, or maintenance workflow on representative equipment.
  5. Verify protect, detect, and recover. Confirm that unauthorized change is prevented, abnormal state is visible, and recovery restores a supported trust state.
  6. Connect the result to consequence. Decide what the observed behavior could mean for safety, operations, customers, data, and incident response.
  7. Set the retest triggers. Require reassessment when a material component, interface, update path, backend dependency, or field workflow changes.

A secure firmware image matters.

A hardened interface matters.

A tested API matters.

The product still has to move safely between the states that join those components together.

Test the transition.

That is where the device changes what it trusts.


Put MicroSolved’s Device and Lab Testing Experience to Work

MicroSolved, Inc. can help organizations evaluate industrial, IoT, embedded, and connected products through controlled, evidence-driven security testing.

MSI can assist with:

  • Product threat modeling and state-transition test design.
  • Firmware extraction, static analysis, emulation, and controlled runtime testing.
  • Review of local, network, wireless, service, application, API, and cloud interfaces.
  • Update, rollback, reset, maintenance, recovery, and retirement-path validation.
  • Embedded-device, firmware, AMI, SCADA, segmentation, and tamper-resistance assessment.
  • Test planning for high-availability, safety-sensitive, and critical-infrastructure environments.
  • Prioritized mitigation guidance that connects technical findings to business and operational consequence.

To discuss connected-device, firmware, industrial, or lab testing, contact MicroSolved at info@microsolved.com or +1.614.351.1237.

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 Top Three Things Security Teams Need to Understand About AI-Driven Attacks

The easiest mistake security teams can make about AI-driven attacks is to imagine a completely new species of adversary.

That is not what most organizations are facing.

The objectives remain familiar: steal credentials, gain access, persist, move laterally, collect data, commit fraud, extort the victim, or conduct espionage. What AI changes is the economics of the attack. It reduces the time, expertise, and attention required to move from one step to the next.

That distinction matters because it tells defenders where to act.

Google Threat Intelligence Group reported this week that it has observed adversaries moving beyond basic prompting into agentic workflows and AI-enabled automation. In one Q2 2026 case, a threat actor used an AI coding chatbot and agent instructions to help plan, build, and execute a mass credential-harvesting campaign in less than six hours. The framework automated scanning, troubleshooting, and IP rotation with limited human involvement. (Google Threat Intelligence Group, September 8, 2026)

That does not mean every attacker has become an autonomous machine. It means the constraints that used to slow attackers down are weakening.

OnlineScammer

Security teams need to understand three things.

Continue reading →

Your Security Controls May Be Less Independent Than You Think

Most enterprise security programs still measure strength by counting controls.

MFA is deployed. EDR is deployed. Logging is centralized. Privileged access is monitored. Cloud guardrails are active. The dashboard shows broad framework coverage, so leadership concludes that the organization has defense in depth.

That conclusion may be wrong.

The problem is not necessarily that the controls are weak. The problem is that several supposedly independent controls may rely on the same underlying service.

An identity provider may authenticate administrators to the EDR console, SIEM, cloud environment, ticketing system, and incident-response platform. A centralized telemetry pipeline may supply detection data to multiple tools. Several controls may reside in the same cloud account, depend on the same DNS or time service, or be managed through one administrative plane.

On a control matrix, these appear to be separate layers.

In the actual system, they may be branches of the same tree.

Continue reading →

AI Agents Need Autonomy Budgets, Not Just Governance Policies

Most organizations are granting AI agents authority faster than they are defining the limits of that authority.

That is the problem.

We have already started treating AI agents as digital workers. That is the right mental model. An agent that can access data, call tools, trigger workflows, generate artifacts, influence decisions, or alter enterprise state is not just another application. It needs identity. It needs boundaries. It needs oversight. It needs evidence. It needs a human owner. It needs a kill switch. That has been the right foundation for agent governance.

But it is not enough.

There is another question that needs to be asked much earlier:

How much damage is this agent allowed to cause before a human must approve the next action?

Not theoretically.

Not in vague risk language.

In actual economic terms.

How much money can it spend?
How many systems can it change?
How many records can it touch?
How much customer impact can it create?
How much privacy exposure can it cause?
How much reputational risk can it accumulate?

If we cannot answer those questions, we have not governed autonomy.

Continue reading →

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.

Continue reading →

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.

A 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.

Continue reading →

Rational Security in the AI Era: How Attackers Are Evolving and How We Must Respond

The weaponization of artificial intelligence by cybercriminals and nation-state actors has crossed a critical inflection point. We no longer live in a world where we can rely solely on traditional perimeters; the threat landscape has fundamentally shifted into what we might call “Extremistan,” where the speed and scale of attacks demand a completely new level of resilience.

SadKitty

At MicroSolved, our mission is to provide rational cybersecurity for an irrational world. To do that effectively, we must look unflinchingly at the data.

The Problem and the Metrics

The numbers tell a stark story of industrialization at machine speed. According to recent threat reports, AI-enabled adversaries increased their attack volume by 89% year-over-year. More concerning is the velocity: the average eCrime breakout time has collapsed to just 29 minutes, with the fastest recorded intrusion moving from initial access to lateral movement in a staggering 27 seconds.

The financial impact is equally severe. The FBI IC3 recorded over 22,000 AI-related complaints with adjusted losses exceeding $893 million in 2025 alone, including tens of millions lost to AI-enabled Business Email Compromise (BEC). AI is accelerating attack speeds by 4x, making human-speed incident response no longer viable.

Continue reading →

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 →