Broken Property-Level Authorization is an access control flaw where a user can read or change object fields they should not be allowed to touch. It happens when an application checks record-level access but fails to validate individual properties such as account status, ownership flags, or billing data in the request or response.
How Broken Property-Level Authorization Works
Broken Property-Level Authorization happens when an application enforces access at the record or object level, but leaves individual fields unprotected. A user may be allowed to view their own account, for example, yet still change a hidden ownership flag, billing field, or status indicator that should only be set by a trusted workflow.
This flaw is especially dangerous because the request often looks legitimate. The user is operating on an object they can reach, but the application has failed to decide whether each property on that object is writable, visible, or sensitive.
Why It Becomes a Security Problem
The core problem is that property-level checks are often implicit, inconsistent, or handled only in the user interface. If the server trusts submitted fields, attackers can submit extra parameters, alter protected attributes, or infer hidden data from responses. That can lead to privilege escalation, tampering with account state, and disclosure of sensitive business data even when record-level authorisation appears to work.
Broken property-level checks also create a false sense of safety. Teams may believe they have solved access control because users cannot access someone else’s record, while the more damaging issue is that they can still alter specific fields inside a record they legitimately reached.
Where This Flaw Commonly Appears
It often shows up in APIs, form submissions, GraphQL mutations, and object binding layers where application code maps request input directly onto domain objects. Fields such as role indicators, account flags, ownership markers, pricing, approvals, and internal notes are especially risky when they are accepted from the client without an allow-list.
Design patterns that serialise full objects back to the client can also expose sensitive properties in responses. The same weakness can therefore affect both reads and writes, which is why field-level control has to be handled separately from object-level access control.
What Good Control Looks Like
Defence requires explicit control over which properties can be read or written for each operation. Sensitive fields should be excluded by default, server-side allow-lists should define what the caller may supply, and response models should be purpose-built so the application does not leak internal fields by accident.
Broader authorisation design matters too. As Authorisation Models Guide shows, coarse role checks are rarely enough when a system needs fine-grained decisions about who may change specific properties. In API-heavy systems, that distinction is central to preventing field-level abuse, which is why OWASP API Top 10 API3 Broken Object Property Level Authorization Guide is directly relevant here.
Risk and Threat Considerations
Broken property-level authorisation can turn an ordinary update path into a privilege-escalation path. Attackers do not need to break in through a separate system if they can smuggle restricted fields through an otherwise valid request, then use those fields to change ownership, suppress security flags, or expose data that should never leave the server.
Failure mechanism: The application authorises the object, but not the individual property, so attacker-controlled input reaches sensitive fields through over-posting, mass assignment, or unsafe response shaping.
Impact: The result can include unauthorised data disclosure, account manipulation, integrity loss, and downstream abuse of business logic that assumed those fields could only be set by trusted code.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP API Security Top 10 addresses the attack surface, OWASP ASVS and NIST SP 800-53 Rev 5 set the technical controls, and ISO/IEC 27001:2022 defines the regulatory obligations.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP ASVS | V8 — Authorization | Field-level access decisions are an authorization problem at object and property scope. |
| Recommendation — Enforce explicit server-side authorization checks for each sensitive field and operation. | ||
| OWASP API Security Top 10 | API3 — Broken Object Property Level Authorization | This term is the OWASP API3 property-level authorisation weakness. |
| Recommendation — Design allow-lists for writable fields and block client-controlled sensitive properties. | ||
| NIST SP 800-53 Rev 5 | AC-6 — Least Privilege | Restrict who can set sensitive fields and limit update authority to required data. |
| SC-28 — Protection of Information at Rest | Sensitive properties such as billing or ownership data need protection against improper exposure. | |
| Recommendation — Limit write permissions so callers can change only the properties their role requires. Protect sensitive field data using encryption and controlled access in storage. | ||
| ISO/IEC 27001:2022 | A.8.3 — Information Access Restriction | The subject is about restricting access to specific data fields and object properties. |
| Recommendation — Define and enforce access rules for individual data fields and sensitive attributes. | ||
Practitioner Guidance
What to watch for: Treat any endpoint that accepts rich object payloads as a candidate for property-level review, especially when the same object is used for both persistence and response serialisation. If a field changes access, ownership, status, limits, or billing behaviour, it should not be accepted from an untrusted caller unless the server explicitly permits it.
Governance implication: Ownership needs to sit with the team that owns the data model, not only the API surface. This is where API Security Guide and API Penetration Testing Guide become useful practical references, because they connect schema design, testing, and runtime enforcement rather than assuming the UI will do the protection for you.
Related resources from NHI Mgmt Group
- Property Level Authorization
- What is the difference between broken object level authorization and broken object property level authorization?
- Why does broken object property level authorization increase risk even when API access is authenticated?
- What are the signs that an API may be vulnerable to broken object property level authorization?
Deepen Your Knowledge
Free weekly newsletter
Subscribe to the NHI & AI Identity Journal
The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.
Bonus 33% off our NHI Course when you subscribe.
Reviewed and updated by the NHIMG editorial team on November 16, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org