Zero trust is a security model that grants no implicit trust to any user, device or service, whatever its location. Every request is authenticated and authorized against a policy before a session opens, and the permissions granted are the minimum the task requires.
The distance between adopting zero trust and enforcing it shows up in code. In Fluid Attacks’ State of Attacks 2026 report, the absence or evasion of an authentication mechanism carried 19.1% of the 27,440,146 CVSSF units of risk exposure reported and appeared in 32.9% of the systems assessed, while improper authorization control for web services appeared in 47.6% of them.
This page covers what the zero trust model is, how its architecture works, why it is not a synonym for ZTNA, how it extends to applications and APIs, and how to test whether its controls can be bypassed.
What is the zero trust security model?
The zero trust security model replaces location-based trust with per-request verification. NIST Special Publication 800-207, published in 2020, states that “zero trust focuses on protecting resources (assets, services, workflows, network accounts, etc.), not network segments,” because network location is no longer the prime component of a resource’s security posture. Authentication and authorization are distinct functions, and both run before the session begins.
The phrase that summarizes zero trust is never trust, always verify. A user inside the corporate network gets no more credit than one connecting from an airport, and an approved request grants access to one resource, not the segment hosting it.
Four principles hold the model together:
Least privilege: every identity receives the minimum permissions its function requires. Fluid Attacks’ Database writes it as a testable requirement: it “must be applied when creating new objects and roles, setting access permissions, and accessing other systems.”
Explicit verification: protected resources require authentication, and public ones are the documented exception. A related requirement asks for deny by default, so new roles start with no permissions.
Assume breach: design as though an attacker already holds valid credentials, then limit what those credentials reach.
Continuous authentication: identity, device health and context are re-checked across the session. Continuous authentication keeps a long-lived session from becoming implicit trust by another name.
What zero trust is not: a product you buy, a network you rebuild once, or another name for MFA. It is a set of design decisions that controls enforce and someone verifies.
Why the castle-and-moat model failed
The approach zero trust replaces is castle-and-moat: the network is the castle, the perimeter is the moat, and whoever crosses it is trusted. Picture a building where residents prove residency once at the door, then walk into any apartment.
That design held while every asset lived in one data center and every employee worked on a company laptop in one office. Remote work and cloud services removed both conditions. But its deeper flaw is not obsolescence: castle-and-moat assumes attacks come from outside, so it guards the boundary and leaves the interior flat. An attacker who buys credentials becomes an insider on first login, and lateral movement costs nothing. That is the pattern Juan Restrepo, Certified DevSecOps Professional at Fluid Attacks, found reviewing a chain of exchange compromises:
“In each case, the first target was a person with privileged access, not a public application.”
Never trust, always verify is the design answer to exactly that.
Microsegmentation is the structural answer zero trust brings. Splitting the network into small zones with their own policies limits the blast radius, so a compromised workstation reaches the one service it was authorized to reach instead of the payment environment.
Castle-and-moat | Zero trust | |
|---|---|---|
Trust basis | Network location | Identity, device posture and context |
Verification | Once, at the perimeter | Per request, for the life of the session |
Default answer | Allow, once inside | Deny, unless a policy says otherwise |
Scope of access | The network segment | One resource |
Stolen credentials | Free movement across the interior | Access limited to that identity’s permissions |
Where controls live | Firewalls, IPS, IDS at the edge | Enforcement points next to each resource |
Zero trust at Fluid Attacks
Fluid Attacks applies the zero trust model in two directions: to its own access to client systems, and to the application-layer controls it tests inside them. A vendor asking for broad network access is asking its client to break the policy it just adopted.
What we assess, and under what rules
External security testing is the moment most organizations open a hole in their own architecture: a VPN account for an auditor, or an inbound port for a scanner, reintroduces the implicit trust the model removes.
Fluid Attacks’ Connector connection avoids that. A pivot agent inside the client’s network opens an outbound encrypted tunnel, so “you do not open inbound ports on your side.” The firewall gives that agent “only the minimum necessary permissions,” and access is scoped by an explicit list: “Fluid Attacks accesses only the resources that you list.” A connection routes at most 1,024 hosts, and the client can change those permissions, firewall rules or network architecture at any time.
Internally the rule is the same: Fluid Attacks’ compliance documentation states that its pentesters “can only get access to the source code, environments, exploits, and secrets of their assigned projects.”
What it looks like in practice
Policy claims are cheap; evidence is not. The table maps each control to what an auditor can inspect afterwards.
Control | How it is enforced | Evidence that remains |
|---|---|---|
Scoped network access | Explicit route list on the tunnel; outbound-only agent | Connection configuration and host list |
Channel control | The channel between pentester and target stays under the provider’s control | Tunnel configuration and session records |
Access traceability | HTTP, network and session logs for every access to client assets | Logs with date, user email, source IP and destination IP, exportable as CSV |
Analyst scoping | Identity and key management limited to assigned projects | Permission assignments per project |
Access revocation | IAM account, repository access and laptop blocked within 24 hours of extended leave or exit | Revocation records |
The traceability row is the one clients use most: the platform shows “HTTP, network and session logs about access to the assets of your organization when your organization uses zero trust network access (ZTNA)”, filterable and downloadable. The auditor is audited too.

The Logs section of the platform: every access to the client’s assets, with date, user email, source IP and destination IP.
What our own data says about zero trust controls
The two weaknesses that break this model are among the most common findings in Fluid Attacks’ assessments. In the State of Attacks 2026 report, built on 1,119,396 vulnerabilities and 27,440,146 CVSSF units of risk exposure, authentication absence or evasion carried 19.1% of that exposure across 8,515 vulnerabilities, and improper authorization control for web services appeared in 47.6% of systems.
The detection split matters for anyone planning a zero trust verification program: automated tools found 88.4% of all vulnerabilities but only 55.8% of total risk exposure, averaging 15.5 CVSSF units per finding against 93.2 for pentesters.
The benchmark scope, and what it supports
A result means what its scope covers, so the scope comes first. Fluid Attacks’ benchmark measures 36 third-party AppSec tools against an application seeded with 1,201 vulnerabilities across 105 CWE categories. Within that scope, the best-performing automated scanner — Fluid Attacks’ own — detected 22.7% of the seeded vulnerabilities, equivalent to 8.8% of the target’s total risk exposure, while a pentester reached 89.6% recall at 100% precision.
What the benchmark supports is a claim about method coverage: a scan and a manual review reach very different portions of an authorization layer. A zero trust maturity score is worth more when it records which method produced it, and on what scope.
Test authorization per object, not per login
Most verification effort goes into proving authentication works, and authentication is the easier half. A user can hold a valid session, pass MFA and still read another user’s records by changing an identifier. Fluid Attacks’ Database catalogs that as insecure object reference: the authorization mechanism “does not prevent one user from accessing another users data by modifying the key value that identifies it.” Nothing about the login was wrong; the authorization decision was never made for that object.
How a zero trust architecture works
A zero trust deployment separates the decision from the enforcement. NIST SP 800-207 names three logical components: a policy engine, “responsible for the ultimate decision to grant access to a resource for a given subject”; a policy administrator, responsible for “establishing and/or shutting down the communication path”; and a policy enforcement point, responsible for “enabling, monitoring, and eventually terminating connections.” The three communicate over a control plane kept separate from the data plane that carries the traffic itself, and the decision uses current inputs: identity, device posture, the resource requested and the policy.
The scope is broader than networking. CISA’s Zero Trust Maturity Model version 2.0, published in 2023, organizes implementation across five pillars — Identity, Devices, Networks, Applications and Workloads, and Data — plus three cross-cutting capabilities: Visibility and Analytics, Automation and Orchestration, and Governance.
The same zero trust maturity model defines four stages: Traditional, Initial, Advanced and Optimal. Progress is uneven by design, so an organization can reach Advanced on Identity while its Applications and Workloads pillar is still Traditional — the normal starting point for companies that bought an access product and stopped there.
Zero trust and ZTNA are not the same thing
ZTNA is a technology that implements part of the zero trust model. Zero trust is the model itself. Treating them as synonyms is the most common way an implementation stalls, leaving the network pillar addressed and the application pillar untouched.
Zero Trust Network Access controls which resources an authenticated identity can reach over the network, replacing the broad access a VPN grants after login. It does not decide whether that identity may read a specific record or call a specific API method. Those decisions live in the application.
Zero trust | ZTNA | |
|---|---|---|
What it is | A security model and set of design principles | A technology for controlling network access to resources |
Covers | Identity, devices, networks, applications and workloads, data | Network reachability of a resource |
Decides | Whether this identity may perform this action on this object | Whether this identity may connect to this resource |
Relationship | The architecture | One enforcement point within it |
Fluid Attacks uses ZTNA for what it is good at: reaching client resources through a controlled channel, which its service comparison records as channel control. Verifying that the applications behind it enforce their own authorization is separate work.
Zero trust for applications, APIs and microservices
Applications are where zero trust gets tested, because service-to-service traffic has no user at the keyboard. NIST SP 800-207A, published in 2023, extends the architecture to cloud-native and multi-cloud environments and concludes that it “requires authentication and authorization policies based on application and service identities.”
Three controls carry most of the weight. Service identity: each workload authenticates as itself, so a compromised container cannot impersonate a peer. Per-resource authorization: every call is checked against what that identity may do to that object, not a role granted at the edge. Scoped, short-lived credentials: Fluid Attacks’ analysis of Model Context Protocol security recommends minimally scoped tokens and only the permissions each server’s function needs — least privilege for non-human identities.
The risk data is the strongest argument for extending zero trust past the network. Fluid Attacks’ review of the 2025 OWASP Top 10 notes that broken access control holds the first position, spanning 40 CWEs found on average in around 4% of tested applications, and that server-side request forgery is an access control failure. Its guidance on API security recommends access control measures such as zero trust security to restrict API access by user identity, role and device.
How to test a zero trust architecture
Testing a zero trust deployment means trying to reach a resource without the authorization the policy requires. The question is not whether the controls were deployed, but whether an attacker gets past them. Five tests cover most of the ground.
Authentication bypass
Check whether a protected resource can be reached without an active session. Fluid Attacks’ Database describes the weakness as a system that “lacks an authentication mechanism or has one that can be bypassed.” Test forgotten endpoints, legacy API versions and anything added after the original review.
Object-level authorization
Authenticate as a low-privilege user and request another user’s records by changing identifiers in URLs, request bodies and tokens. This is the insecure object reference case, and the most instructive test for a team that equates zero trust with a strong login.
Web service authorization
Call API methods directly, outside the interface that normally invokes them. The matching weakness covers web services whose authorization mechanism is absent or can be bypassed. Validate through session cookies or tokens that the caller is authenticated — then, separately, that they are authorized for the resource.

Entry 039 of Fluid Attacks’ catalog: web services with no authorization control, or one that can be bypassed.
Privilege escalation
Attempt administrative actions from a standard account. Fluid Attacks’ Database records cases where “due to an insecure role configuration, it is possible to obtain administrative access or privileges using a standard user account” — a contradiction of least privilege no policy document reveals.
Segmentation and lateral movement
This test exposes a deployment stuck at the network pillar. From a compromised foothold, map what is actually reachable and compare it against what the policy says should be. The difference between those two lists is the real microsegmentation posture.
These checks belong with the practices that find the same flaws elsewhere: Static Application Security Testing (SAST) over authorization logic, Dynamic Application Security Testing (DAST) against running services, Software Composition Analysis (SCA) over dependencies, and manual testing for business rules no scanner recognizes.
How to implement zero trust
A zero trust implementation is a sequence: each step produces what the next needs.
Define the attack surface. Identify the critical data, assets, applications and services, and map how data moves between them. What you have not listed cannot be covered by a policy.
Inventory identities. Users, devices, service accounts, workloads and AI agents, with what each legitimately needs. Service accounts and workloads need the same treatment as people: an identity, a defined set of permissions and a way to revoke them.
Write granular policies. Per resource and per action, starting from deny by default. Fluid Attacks’ Database maps that requirement to PCI DSS 7.3.3 and CWE-276, so the policy is auditable from day one.
Enforce and instrument. Place policy enforcement points next to resources, require multi-factor authentication for critical systems, and keep the telemetry CISA’s Visibility and Analytics capability needs.
Measure zero trust maturity, then test it. Score each pillar against the four stages and verify the claim with the tests above. A pillar scored Advanced on a configuration review is not verified.
Conclusions
Zero trust is a security model, not a purchase. Its value comes from one decision applied consistently: nothing gets access because of where it sits, and every request is checked against a policy first.
Most zero trust implementations stop at the network pillar, because that is where the products are. The application pillar is where the model usually breaks, and Fluid Attacks’ own data shows why: authorization and authentication weaknesses are among its most prevalent findings. A zero trust program never tested at the object, API and role level is a design document, not a posture.
Frequently asked questions
Is zero trust the same as ZTNA?
No. Zero trust is the security model; Zero Trust Network Access is a technology that enforces one part of it. ZTNA decides whether an identity may connect to a resource, not whether it may read a particular record or call an API method. Those are application-level decisions.
Does zero trust replace multi-factor authentication?
No. MFA is one control inside the model, not a substitute for it. It strengthens the proof of identity and says nothing about whether that identity is authorized for the resource requested, a separate decision the application makes per object and action.
How do you know a zero trust architecture actually works?
By trying to bypass it. Test for authentication bypass, object-level authorization by changing identifiers, direct API calls outside the normal interface, privilege escalation from a standard account, and broken access control reachable from a simulated foothold. A configuration review confirms controls were deployed; testing shows whether they hold.
Does the model apply to APIs and microservices?
Yes, and that is where most implementations are weakest. Service-to-service traffic has no user to re-authenticate, so each workload needs its own identity, per-resource authorization and short-lived scoped tokens. In Fluid Attacks’ State of Attacks 2026 report, improper authorization control for web services appeared in 47.6% of systems.
Does Fluid Attacks use the zero trust model?
Yes, in two ways. It reaches client resources through ZTNA tunnels scoped to an explicit list of hosts, with no inbound ports opened on the client side and full HTTP, network and session logs available to the client. It also tests whether client applications enforce the authorization decisions their policies assume.
Stop trusting your access controls. Test them.
Our pentesters and scanners check whether the authentication and authorization controls behind your zero trust policy can be bypassed. Start free trial · Contact us.
Get started with Fluid Attacks' application security solution right now















