API security, UAE

Seven of the top ten API risks are authorisation problems a scanner cannot find.

Broken object level authorisation is the first entry on the published list, and it looks like a valid request with a different identifier. Testing APIs properly requires understanding what each object is and who should be able to reach it.

API security assessment for UAE organisations
  • 10 risksIn the published API Security Top 10
  • Object levelThe first and most exploited category
  • Business flowsA risk category with no technical signature
  • InventoryA risk in its own right, ranked ninth
Why scanners miss most of this

An automated tool cannot know that object 4471 belongs to somebody else.

That single limitation explains why API assessments produce findings that months of automated scanning did not.

  • Broken object level authorisation looks like a perfectly valid request. Correct method, valid token, well formed body, and an identifier belonging to another customer. There is no malformed input to detect and no error to flag, because the API answers normally.
  • Property level issues are equally invisible. A response containing fields the caller should not see is a valid response. Mass assignment accepting a field the caller should not be able to set is a valid request. Both require knowing the intended data model.
  • Business flow abuse has no technical signature at all. Automating a flow that was designed for human pace is not a vulnerability in any single request, and the harm is commercial rather than technical, which is why tools have nothing to alert on.
  • What finds these is a tester with two accounts, an understanding of what the objects represent, and the patience to enumerate. That is a human activity informed by the documentation, which is one more reason inventory sits on the list as its own risk.
Ask us how we test authorisation
What an API assessment covers

Eight things that make API testing different from web testing.

APIs fail differently from web applications. The requests are well formed, the responses are valid, and the vulnerability is that the caller should not have been allowed to make that request in the first place.

Object level authorisation is the first risk

APIs tend to expose endpoints that handle object identifiers, creating a wide attack surface of object level access control issues. Changing an identifier in a valid request is the simplest attack there is and it remains the most successful.

Authentication is often implemented incorrectly

Mechanisms are frequently implemented in ways that allow attackers to compromise authentication tokens, or to exploit implementation flaws to assume other user identities temporarily or permanently. Token handling is where most of this occurs.

Property level authorisation is separate

The third entry combines excessive data exposure and mass assignment, emphasising the lack of or improper authorisation validation at the object property level. An endpoint can be correctly authorised and still return or accept fields it should not.

Resource consumption is a security risk

Satisfying API requests requires network bandwidth, CPU, memory and storage. Unrestricted consumption can be exploited to cause denial of service or to increase operational costs, which in a cloud environment is a direct financial impact.

Function level authorisation fails in complex models

Complex access control policies with different hierarchies, groups and roles, and an unclear separation between administrative and regular functions, tend to lead to authorisation flaws. Most estates have exactly that complexity.

Business flows can be abused without any flaw

A vulnerable API exposes a business flow without compensating for how the functionality could harm the business if used excessively in an automated manner. Nothing is technically broken, and the business outcome is still damaging.

Inventory is a risk category in itself

APIs tend to expose more endpoints than traditional web applications, which makes proper and updated documentation highly important. Undocumented, deprecated and forgotten endpoints are a named risk rather than an administrative untidiness.

Consuming other APIs carries its own risk

Developers tend to trust data received from third party APIs more than user input, and so tend to adopt weaker security standards for it. That inversion of trust is the tenth entry and it is almost never tested.

The published list

Ten risks, and what each one actually looks like.

Taken from the published edition. The identifiers are stable, which makes them a useful shared vocabulary between a testing team, a development team and a customer asking about your API.
IdentifierRiskWhat it looks like in practice
API1:2023Broken Object Level AuthorizationA valid request with somebody else identifier
API2:2023Broken AuthenticationToken compromise or assuming another identity
API3:2023Broken Object Property Level AuthorizationFields returned or accepted that should not be
API4:2023Unrestricted Resource ConsumptionDenial of service or a large cloud bill
API5:2023Broken Function Level AuthorizationRegular users reaching administrative functions
API6:2023Unrestricted Access to Sensitive Business FlowsAutomation of a flow designed for humans
API7:2023Server Side Request ForgeryFetching a remote resource from an unvalidated URI
API8:2023Security MisconfigurationComplex configuration with missed settings
API9:2023Improper Inventory ManagementEndpoints nobody documented or retired
API10:2023Unsafe Consumption of APIsTrusting third party responses more than user input
How we approach it

Four things that make an API assessment worth commissioning.

The value comes almost entirely from the manual authorisation work, which is why the scoping conversation focuses on access to accounts and documentation rather than on tooling.

We test with real accounts at different privilege levels

Object level authorisation cannot be assessed from one account, because the test is whether account A can reach account B data. Getting several accounts provisioned before the engagement starts is the single biggest determinant of finding quality.

We enumerate before we test

Improper inventory management is a named risk, and it is the precondition for the rest. Old versions, undocumented endpoints and internet reachable non production environments are found in this phase and they are frequently the most serious findings.

We include business flow abuse

The published list includes exposing a business flow without compensating for how it could harm the business if used excessively in an automated manner. That requires understanding the business, and it is the category most testing simply omits.

We report against stable identifiers

Findings mapped to the published identifiers give developers, security teams and customers a shared vocabulary. It also lets an organisation compare assessments over time and across products without translating between report formats.

How an engagement runs

Three phases across roughly four to eight weeks.

Length depends on endpoint count and how much documentation exists. Authorisation testing is the slow part because it is genuinely manual.
  1. 01
    Weeks 1 to 2

    Inventory and understand

    Every endpoint across versions and environments, what objects each exposes, what the intended authorisation model is, and which flows have business significance. Documentation is assessed as part of this, since inventory is a named risk.

    • Endpoint inventory across versions and environments
    • Object and property model documented
    • Intended authorisation model captured
    • Sensitive business flows identified
  2. 02
    Weeks 3 to 6

    Test authorisation properly

    Object level, property level and function level authorisation tested with multiple accounts at different privilege levels. This is the part that produces the findings, and it cannot be automated because it depends on knowing what should be permitted.

    • Object level authorisation tested per endpoint
    • Property level exposure and mass assignment tested
    • Function level separation tested across roles
    • Findings evidenced with reproducible requests
  3. 03
    Weeks 7 to 8

    The remaining categories and the report

    Authentication and token handling, resource consumption limits, business flow abuse, server side request forgery, configuration, and how your API consumes other APIs. Then a report structured around the published identifiers.

    • Authentication and token handling assessed
    • Rate and resource limits tested
    • Business flow abuse scenarios exercised
    • Report structured by the published risk identifiers
Where this comes up

Six situations that prompt an assessment.

APIs get tested when somebody outside asks, or when something has already gone wrong through one.

A UAE company whose product is mostly API

Where the API is the product, its security is the product security. Web application testing that treats the API as an implementation detail behind a front end misses the interface customers and attackers actually use.

A financial services firm exposing open banking interfaces

Regulated interfaces attract informed attackers and informed auditors. Object and function level authorisation across account hierarchies is exactly the complex access control the fifth risk describes, and it needs deliberate testing.

A business suffering automated abuse

Bulk account creation, inventory hoarding, promotional code enumeration and scraping are business flow abuse rather than technical vulnerabilities. The published list treats them as a distinct risk, which is what makes them addressable.

An organisation with an unexplained cloud bill

Unrestricted resource consumption can lead to denial of service or increased operational costs. Where consumption based cloud spending rises without a matching business explanation, an unlimited endpoint is a plausible cause worth testing.

A team that has accumulated API versions

Every version that was never retired remains an attack surface, usually receiving less attention than the current one. Enumerating versions and environments regularly finds interfaces the current team did not know were still serving traffic.

A product that integrates several third party services

Developers tend to trust data received from third party APIs more than user input, adopting weaker standards for it. Where your product processes responses from payment, identity, logistics or data providers, that trust deserves testing.

Three positions

How UAE organisations test their APIs.

The middle column is common and it creates a false sense of coverage, because the scanner reports clean on exactly the categories that dominate the published list.
Object level authorisation tested
Manual assessment against the listYes, with multiple accounts
Automated scanning onlyNo
Tested as part of the web appRarely
Property level issues found
Manual assessment against the listYes
Automated scanning onlyNo
Tested as part of the web appNo
Function level separation tested
Manual assessment against the listYes
Automated scanning onlyPartially
Tested as part of the web appNo
Business flow abuse considered
Manual assessment against the listYes
Automated scanning onlyNo
Tested as part of the web appNo
Full endpoint inventory produced
Manual assessment against the listYes
Automated scanning onlyCrawled only
Tested as part of the web appPartial
Old versions included
Manual assessment against the listYes
Automated scanning onlyIf discovered
Tested as part of the web appNo
Third party consumption assessed
Manual assessment against the listYes
Automated scanning onlyNo
Tested as part of the web appNo
Findings reproducible
Manual assessment against the listWith exact requests
Automated scanning onlyTool output
Tested as part of the web appVaries
Maps to a published risk list
Manual assessment against the listYes
Automated scanning onlyLoosely
Tested as part of the web appNo
Effort
Manual assessment against the listWeeks, mostly manual
Automated scanning onlyHours
Tested as part of the web appIncluded, superficially
The one to fix first

Improper inventory management is ninth on the list and first in practice.

You cannot assess, protect or retire an endpoint you do not know exists, which makes this risk the precondition for addressing the other nine.

  • The published description is that APIs tend to expose more endpoints than traditional web applications, which makes proper and updated documentation highly important. Endpoint counts in the hundreds are ordinary and are rarely fully documented.
  • Old versions are the classic case. A version two rollout rarely retires version one, because a client somewhere still calls it. Version one then stops receiving the attention version two gets, while continuing to expose the same data through weaker controls.
  • Non production environments are the second case. Staging and test APIs frequently hold copies of production data behind noticeably weaker authentication, and they are reachable from the internet far more often than their owners believe.
  • The assessment starts here for practical reasons. Enumerating what exists, including versions and environments, is what determines the scope of everything else, and it routinely surfaces endpoints nobody in the room knew were still running.
Ask us to enumerate your API estate
How an engagement runs

Five steps, and the middle three are manual by necessity.

Automation contributes to inventory and configuration. The authorisation categories that dominate the published list require a person who understands the data model.
  1. 1

    Enumerate the API estate

    Every endpoint across versions and environments, since APIs tend to expose more endpoints than traditional web applications and documentation is frequently incomplete. Undocumented and deprecated interfaces are recorded as findings in their own right.

  2. 2

    Understand the intended authorisation model

    What each object represents, who should be able to read and modify it, which properties are sensitive, and where the boundary between administrative and regular functions sits. Testing authorisation requires knowing what correct looks like.

  3. 3

    Test object, property and function level authorisation

    With multiple accounts at different privilege levels, enumerating identifiers, attempting to set properties that should be restricted, and reaching functions that should be separated. These three categories produce most findings in most assessments.

  4. 4

    Cover the remaining categories

    Authentication and token handling, resource consumption limits, sensitive business flows exercised at automated pace, server side request forgery where remote resources are fetched, configuration per environment, and consumption of third party APIs.

  5. 5

    Report against the published identifiers

    Each finding mapped to its identifier, evidenced with a reproducible request, and prioritised by exploitability and business impact rather than by category order. That structure makes remediation assignable and progress measurable.

Straight answers

What organisations ask about API security assessment.

API readiness check

Fifteen questions to ask your development team.

These are answerable without any tooling, and the pattern of hesitation usually predicts the findings quite accurately.

Inventory

  • How many endpoints do we expose?
    An exact number.
  • Which old versions are still live?
    Usually more than expected.
  • Are staging APIs internet reachable?
    Often, unintentionally.
  • Is the documentation current?
    A named risk category.
  • Who owns each endpoint?
    Retirement needs an owner.

Authorisation

  • Is object ownership checked every request?
    The first risk.
  • Can a user set fields they should not?
    Mass assignment.
  • Do responses include hidden fields?
    Excessive exposure.
  • Are admin functions separated clearly?
    Function level risk.
  • Have we tested with two real accounts?
    The essential test.

Everything else

  • Are there rate and size limits?
    Resource consumption.
  • Could a business flow be automated?
    A distinct risk.
  • Do we fetch user supplied URIs?
    Server side request forgery.
  • Do we validate third party responses?
    The tenth risk.
  • Is configuration reviewed per environment?
    Misconfiguration.
Next step

Ask your team how many API endpoints you expose, including old versions.

Tell us about the API inventory, environment, authentication methods, user roles and authorised testing window. We will confirm the requirements and proposed scope with you.