Techbanq

Offensive security · APIs

The endpoint is fine. The question is who may call it

API defects are rarely in the code that handles the request. They are in the decision about whether this caller, holding this token, may act on this object — and that decision is often made in a client the caller controls.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Workstation showing terminal output during a security review
  1. 01

    Market

    Saudi Arabia

  2. 02

    Written for

    CTO, CISO

  3. 03

    Decision

    Commission a penetration test of an API estate

  4. 04

    Languages

    EN · AR

Cybersecurity credentials

  • National Cybersecurity Authority, Saudi Arabia

    NCA registration

    Registered cybersecurity service provider

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

Scoping

Count the consumers, not the endpoints

We do not have an office in Saudi Arabia

We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.

An endpoint count tells you almost nothing about the work. Two hundred endpoints called by one first-party mobile client with one permission model is a narrow test. Forty endpoints called by a web client, a mobile client, three partner integrations and an internal batch process is a wide one, because each caller has a different token type, a different scope and a different set of assumptions about what it is allowed to do.

The specification is the second input, and its absence changes the engagement. With an OpenAPI or GraphQL schema we test what the API claims to offer against what it actually accepts, and the gap between the two is itself a finding — undocumented parameters that still work, deprecated versions still routed, admin operations present in the schema and absent from the documentation. Without a specification the first days go to reconstructing one, and the test is only as complete as that reconstruction.

Third: whether the gateway is in scope. Rate limiting, authentication and schema validation are frequently implemented at a gateway rather than in the service, which means testing the service directly measures something the internet cannot reach, and testing through the gateway measures the gateway. Where both paths exist — and they usually do, because internal callers bypass the gateway — both need testing, and the difference between them is often the finding.

Coverage

Where API tests actually find things

01

Object-level authorisation

The identifier in the path or body swapped for one belonging to another account in the same role. The single most productive check in this category, and the one an automated tool cannot perform because it does not know which two identifiers should not be interchangeable.

02

Function-level authorisation

Administrative operations called with an ordinary token. Where the client hides a button, the API frequently still honours the call — the interface enforced the rule and the service assumed the interface would.

03

Token handling

Whether a token is validated for signature, audience, issuer and expiry rather than merely decoded; whether refresh tokens can be replayed; whether revocation takes effect before the cached copy expires; and what a token issued for one client accepts when presented to another.

04

Mass assignment and over-posting

Fields the client never sends, accepted anyway. A role field, an account balance, a verified flag, an owner identifier — present in the model, absent from the interface, and writable by anyone who reads the response carefully.

05

Enumeration and bulk access

Sequential identifiers, unbounded page sizes, search filters that accept a wildcard, and export endpoints with no rate limit. Individually each returns one record it should not; together they return the dataset.

06

GraphQL-specific behaviour

Introspection left enabled in production, query depth and complexity unbounded, aliasing used to bypass a per-field rate limit, and mutations reachable that the schema documentation does not describe.

Sequence

How the engagement runs

STAGE 01

1 · Specification and caller map

The schema, the consumers, the token types each holds, and the objects each is meant to reach. Where the map does not exist we build it and return it, which is frequently the first thing the client keeps. A caller-to-object matrix the test is measured against.

STAGE 02

2 · Authorisation matrix execution

Every operation attempted with every token type, and every object identifier substituted across accounts. This is the bulk of the days and the source of most findings. A filled matrix: permitted, denied, or permitted and should not be.

STAGE 03

3 · Input, state and rate behaviour

Schema validation bypasses, type confusion, state transitions called out of order, and what happens when the same operation is called a thousand times in a minute. Findings against handling rather than against permission.

STAGE 04

4 · Report and retest

Each finding as the exact call, the token it was sent with and the response. Retest checks the fix and whether it was applied to every operation sharing the pattern. A document an engineer can act on without a call.

Scope boundary

What an API test covers

What we do

  • Test both the gateway path and the direct service path where both are reachable, and report the difference between them.
  • Record the exact call, token and response for every finding, so a fix can be verified the same way it was found.
  • State which operations in the specification were not reached, and why.

Where an API is in scope for a financial services framework, the supervising authority sets what evidence it accepts and from whom. Confirm the required scope, tester independence and report format with the assessor before the engagement is scoped.

Primary source

Common questions

What buyers ask

We have an OpenAPI spec. Is that enough to scope the work?+

It is most of it, but not all. The specification describes the operations; what it rarely describes is which callers exist, which token type each holds, and which objects each is meant to reach. That last part is the authorisation matrix, and it is where the findings are. If it has not been written down, the first day of the engagement produces it — and clients usually find that document more useful than they expected.

Can you test an API that is only reachable from inside our network?+

Yes, over a controlled connection you provision — a jump host, a VPN account, or a workstation on your estate that we work from. Internal APIs are frequently worth testing precisely because they were built on the assumption that only trusted callers reach them, and that assumption holds only until one workstation is compromised.

How does this differ from the web application test?+

A web application test exercises the API through the interface, which means it only reaches the calls the interface makes, in the order the interface makes them. An API test calls the service directly, which reaches undocumented operations, parameters the client never sends and sequences the interface prevents. Where the same team owns both, testing them together is cheaper than testing them separately — but a web test alone does not cover the API.

Next step

Send the spec and the caller list

A scoped API test with two accounts per role and the specification in hand. Findings written as the exact call that succeeded and should not have.

Send the spec and the caller list

What happens next

  1. 1We reply within one business day.
  2. 2A 30-minute scoping call with a senior consultant.
  3. 3A written proposal with scope, team, and timeline.

Or reach us directly

By submitting this form you agree to our Terms of Use and Privacy Policy.