Overview
A profile-editing feature should let a user change personal preferences—not decide their own privileges.
I reported a Privilege Escalation vulnerability in a large company’s GraphQL API. I followed the schema from introspection to a profile-update mutation whose input accepted two Boolean fields associated with property-manager status. My report records submitting both flags as true, then querying the profile again to check the resulting state.
The report received a four-figure USD bounty ($X,XXX). The company and exact amount are withheld. This write-up explains the discovery process, the privilege escalation request, and the authorization boundary involved.
Introspection made the relevant input discoverable. It was not, by itself, proof of a vulnerability: GraphQL provides introspection for schema discovery and developer tooling. The security question was whether the caller was allowed to change those particular properties. GraphQL introspection documentation
The cover is an original conceptual illustration, not a screenshot of the affected system or evidence of exploitation.
Scope
The finding involved current-user profile operations in an undisclosed company’s GraphQL API. The sequence below summarizes the original report, not a new test of the resolved issue.
Any reproduction must stay within an explicitly authorized program scope and use a researcher-controlled account. Do not test the requests against an unidentified third party. This article contains no live endpoint, credentials, or customer data.
Methodology
The eight phases below preserve the sequence of my report. Every example is a JSON request body containing a GraphQL document in the query string, including the mutation in Phase 7. Use Content-Type: application/json with the authorized endpoint and account context; neither the endpoint nor authentication headers are included here.
The names viewer, updateProfile, ProfileUpdateInput, isPropertyManager, and isManagerMember are generalized labels. The examples also limit profile selections to the fields relevant to the finding.
Phase 1 — Discover the schema
{
"query": "query DiscoverSchema { __schema { types { name fields { name type { name kind } } } } }"
}
My notes recorded more than 500 types, including objects related to profiles, property metadata, and bookings. Those names helped map the API. Seeing a type’s definition is not the same as obtaining the records represented by that type.
Phase 2 — Enumerate queries and mutations
{
"query": "query DiscoverOperations { __schema { queryType { name fields { name description } } mutationType { name fields { name description } } } }"
}
The report recorded 108 queries and 85 mutations. A current-user profile query and a profile-update mutation were particularly relevant because they provided a possible read/write pair for the same account state. Other operation names were leads, not evidence that I could execute those operations.
Phase 3 — Inspect query arguments
{
"query": "query InspectQueryArguments { __type(name: \"Query\") { fields { name args { name defaultValue type { kind name ofType { kind name ofType { kind name } } } } } } }"
}
Use the root type name returned in Phase 2; Query is a convention, not a requirement. The report identified current-user queries for the profile, contacts, and preferences without required arguments. This does not mean they were unauthenticated: a resolver can obtain the caller’s identity from the request context.
The expanded type selection makes wrappers such as NON_NULL and LIST visible. A wrapper’s name can be null; follow ofType to inspect its underlying type, extending the selection if it is nested more deeply. GraphQL introspection documentation
Phase 4 — Inspect mutation arguments
{
"query": "query InspectMutationArguments { __type(name: \"Mutation\") { fields { name args { name type { kind name ofType { kind name ofType { kind name } } } } } } }"
}
Again, use the discovered root type name. The profile-update operation led to an input object, called ProfileUpdateInput in this anonymized version. The next question was which properties a caller could submit through it.
Phase 5 — Inspect the profile-update input
{
"query": "query InspectProfileUpdateInput { __type(name: \"ProfileUpdateInput\") { kind inputFields { name type { kind name ofType { kind name } } } } }"
}
Two Boolean inputs stood out: the fields generalized here as isPropertyManager and isManagerMember. Their names suggested a relationship to privileges. That was a hypothesis to validate—not enough to establish that the application used them in authorization decisions.
Phase 6 — Capture the initial profile state
{
"query": "query ProfileBeforeUpdate { viewer { id isPropertyManager isManagerMember } }"
}
Query the profile before the mutation to establish a baseline for the same account. Compare the two role-related flags with the later read-back result.
Phase 7 — Privilege escalation request
{
"query": "mutation UpdateOwnProfileFlags { updateProfile( update: { isPropertyManager: true isManagerMember: true } ) { isPropertyManager isManagerMember } }"
}
This is the state-changing step in the report. The intended check was whether the profile-editing path accepted fields that should instead be controlled by an authorized role-management workflow.
A successful HTTP status alone is not enough. Inspect GraphQL’s data and errors, then verify state separately; a mutation response should not be treated as independent proof of a durable privilege change.
Phase 8 — Read back the profile
{
"query": "query ProfileAfterUpdate { viewer { id isPropertyManager isManagerMember } }"
}
My report described the result as gaining Property Manager privileges after setting the flags and querying the profile again.
Findings
Vulnerability type: Privilege Escalation (vertical). The report describes elevating the account to Property Manager privileges through a profile-update mutation.
The reported behavior is consistent with broken object property-level authorization: a caller can reach an object but should not be allowed to change every property on it. This is the closest fit to OWASP API3:2023, based on the supplied account of the behavior. OWASP API3:2023
Mass assignment is a possible implementation-level explanation if the service binds client input directly to protected account attributes. Without server-side code, it remains an inference; the presence of fields in an input type does not establish how the resolver saves them. OWASP Mass Assignment Cheat Sheet
Impact
If downstream authorization trusts these client-writable flags, an ordinary profile-editing path can become a vertical privilege-escalation path. The actual scope depends on the checks protecting each operation, not on the flag names alone.
The scope described here is the reported elevation of the account’s role, not account takeover, cross-account access, or changes to other users’ records.
Mitigations
The issue is resolved. The following are general prevention recommendations, not a description of the company’s specific patch:
- Separate profile editing from role administration. Keep role, entitlement, and approval properties out of ordinary profile-update inputs.
- Allowlist editable properties. Map approved profile fields explicitly into the update operation instead of binding arbitrary client input to an account model. OWASP Mass Assignment Cheat Sheet
- Enforce authorization in shared business logic. Check the acting identity and permitted state transition before saving a role change, across every entry point. GraphQL’s authorization guidance recommends centralizing these decisions rather than duplicating them inconsistently in resolvers. GraphQL authorization documentation
- Check the protected action itself. A field update or a client-side interface change must not grant access that the server has not authorized.
- Add regression tests and an audit trail. Cover ordinary users, intended administrators, rejected role changes, and the identity responsible for each permitted transition.
- Review introspection separately. Restrict discovery where appropriate for the API’s audience, but do not treat hiding the schema as the fix for missing authorization. GraphQL introspection documentation
Regression checks
A remediation retest should establish that an ordinary user can still edit permitted profile fields, cannot alter role-related properties, and remains unable to perform a manager-only action. An approved administrator should retain the intended role-management capability. Record both rejected requests and unchanged state; restore any test changes through an authorized workflow.
