Let's talk
Mostafa Mamdoh

Researcher who breaks payment rails

Mostafa

I break authorization — object, function, role and tenant boundaries — and the payment logic built on top of it. The flaws scanners never reach, because nothing is malformed. 33rd all-time worldwide on Bugcrowdfirst in Egypt

or read a full sample report
P1 Race condition — balance never decremented
POST /v1/tips {"amount":500} 200
POST /v1/tips {"amount":500} 200 sent concurrently
POST /v1/tips {"amount":500} 200
GET  /v1/balance 500 unchanged after 1,500 spent
#33All-time worldwide, Bugcrowd
#1Researcher in Egypt
98.41%Submission accuracy. Not quite pure.
9,347All-time points

Three ways to work together

Scoped engagements, program design, or someone who stays close to your system.

Penetration testing

Scoped web and API engagements, usually three to ten testing days. I enumerate the surface and test every role against every object and every endpoint, rather than sampling it. Where there is a mobile client, I decompile it — it is the fastest route to undocumented endpoints and credentials that were never meant to ship. A findings report with severity, reproduction steps and remediation guidance, plus a retest once fixes land. Critical findings reach you the day I find them.

Private bug bounty programs

Standing up a program that produces signal instead of noise: scope matched to your real risk, reward tiers that attract researchers who can find the hard things, and triage your team can act on.

Ongoing advisory

An annual pass plus scoped reviews whenever you ship something touching money movement, authentication or payouts. Faster every time, because I already know how your system works.

Broken access control, in seven forms

Most of what I find comes down to a control that exists on one path and not another. A selection from managed programs, with clients and identifying detail removed.

Inconsistent authorization checks

The check exists, just not on every path

  • Reached internal network services. A private-address validator ran on repository creation but not on update.
  • Changed an account’s email without the password. A superseded route stayed live, skipping the confirmation its replacement requires.
  • Issued a full session without the second factor. A legacy password endpoint the current login had already replaced.
  • Bought at a retired price. Decommissioned plan codes still accepted at checkout — and accepted again after a patch was reverted.
  • Kept access after revocation. The gateway honoured it; a token-exchange endpoint ignored it and minted replacements lasting a year.

Client-controlled data the server trusts

The server believes what the client tells it

  • Minted unlimited real-money in-app currency. Client-supplied state persisted server-side without checking.
  • Published unmoderated content to a public page. The approval flag was accepted from the request body.
  • Upgraded a free account for nothing. The plan tier could be set directly through mass assignment.
  • Ran bulk actions while denied them. The permission was enforced in the browser and nowhere else.
  • Skipped bot protection entirely. The check ran only when the token field was present — so removing it worked.
  • Switched off cart-total validation. A partial-payment flag in the request body, with no voucher or split-tender arrangement required to exist.
  • Shipped the goods without charging the card. A capture flag decided whether payment was taken before fulfilment.

IDOR and broken object level authorization

The object is not yours and nothing checks

  • Read any customer’s database, unauthenticated. A path identifier selected it and the contents came back.
  • Returned any user’s profile by ID. The list filter was never account-scoped.
  • Retrieved a roster spanning a thousand unrelated sub-accounts. From an ordinary non-admin account.
  • Took over the primary account. An invited secondary user could change the owner’s login email.
  • Raised invoices against another workspace. The billing endpoint never checked whose account it was.
  • Subscribed to another customer’s live event stream. The realtime endpoint signed tokens for any channel name supplied.
  • Forged a signed wallet pass. Any membership number in the query string, vouched for by the platform’s own key.

Revocation that doesn’t take effect

The permission is revoked and nothing changes

  • Used a permission after it was revoked. Removed through the admin console’s own API, confirmed gone from the role, still fully exercisable — across seven separate permissions on one platform.
  • Disabled nothing. The organization-wide master switch for that same capability.
  • Read, created and deleted twenty-five team-wide resource types. From an account provisioned with every toggle off.
  • Enforced a role the server had never heard of. The model existed only in the interface drawing it.

Race conditions in limits and quotas

The limit does not hold under concurrency

  • Bypassed a limit entirely. Concurrent requests settled before the counter incremented.
  • Farmed unlimited credit. The billing cycle could be reset over and over.
  • Completed paid orders without paying. The confirmation step accepted wrong, blank or absent values.

Redirects, callbacks and uploads

The redirect is trusted more than it should be

  • Handed the authorization code to an attacker’s domain. The OAuth redirect target was validated by an unanchored substring match.
  • Linked a victim’s identity in one click. The callback applied to whoever requested it, not the account it was issued for.
  • Drove a victim’s workspace from an attacker-controlled one. The two could be linked without the victim agreeing.
  • Turned user content into executable script. Uploads were served back with an attacker-chosen content type.

Excessive agency in AI agents

The agent reaches further than the user

  • Exfiltrated a victim’s workspace data to an external host. Page content the assistant read as instructions.
  • Reached cloud instance metadata and internal services. Through the agent’s own fetch tool.
  • Disclosed configuration the API refuses to that same role. Asked of the support assistant instead.
  • Minted third-party model credentials, billed to the operator. No authentication required.
  • Skipped the agent’s mandatory query review. A forged “already validated” marker, typed straight into the question box.
  • Disclosed the system prompt in full. Refused on every direct request, then handed over when asked to translate it.
The deliverable See a full sample report A worked example of what lands at the end of an engagement: severity, reproduction steps, remediation, and an explicit statement of what was and was not tested. Read it ↗

Also: server-side request forgery across webhook and integration surfaces, stored cross-site scripting chained to credentialed cross-origin reads, unrestricted API keys billed per use, and unauthenticated access to internal document stores.

How an engagement runs

Five testing days, as an example. Shorter engagements compress the middle, never the ends.

Before

Scope and authorization

A written scope naming the systems, the test window and an escalation contact, signed by whoever owns the assets. Nothing is touched until that is on file. Half the fee is invoiced at signing.

Day 1

Map the system, not the surface

Walkthrough with your engineer, the API specification, and every role provisioned. I spend the first day understanding how money and permissions are meant to move, because that is what tells me where they might not.

Days 2–4

Test the paths that matter

Authorization boundaries between roles and tenants, whatever the server takes on trust from the client, concurrency on anything that counts or spends, and the routes that were replaced but never removed. Anything critical reaches you the same day.

Day 5

Chain and confirm

Individually minor findings are worth more together. The last day is spent building the realistic attack path and confirming each issue reproduces cleanly, so your team is not chasing something that only worked once.

After

Report, then retest

See a sample report — a worked example of the deliverable, so you can judge it before you buy it. A written report within three working days: severity, reproduction steps, and remediation your engineers can act on without a follow-up call. One retest is included once fixes land, because a patch that reverts is a finding I have reported before.

What it costs

Fixed price per scope, not a day rate to negotiate down. Minimum engagement $9,000. Half at signing, half on delivery of the report.

Focused pass

3 testing days $9,000
  • One system or one critical flow
  • Full report with reproduction steps
  • One retest round included
  • Same-day escalation of criticals

Standard engagement

5 testing days $13,000
  • Web and API, plus a mobile client
  • Multi-role and multi-tenant boundaries
  • Full report with reproduction steps
  • One retest round included
  • Same-day escalation of criticals

Extended engagement

10 testing days $23,000
  • Several systems, or one large one in depth
  • Every role against every object and endpoint
  • Chained attack paths, not just isolated findings
  • One retest round included

Ongoing advisory

Annual, plus scoped reviews Quoted per scope
  • One comprehensive pass a year
  • Short reviews when you ship something risky
  • Faster each time, since I know the system
  • Reserved days each month, booked ahead
  • Help designing a private bounty program

One retest round is included in every engagement; further rounds are quoted separately. Scope drives the number, not the calendar. If the budget is fixed, I would rather narrow what gets tested and do it properly than stretch the same days across more surface.

Questions I get before we start

Do you need production access?

No. A staging environment with seeded data and provisioned roles is better for both of us. If only production exists, we agree in writing what is off limits and I work read-mostly.

Will you sign an NDA?

Yes, and I expect to. I will also want written authorization to test, which an NDA does not provide on its own. Client names never appear in my public work.

How is this different from a scanner?

A scanner finds what it has a signature for. Nothing in the list above would appear in one, because every item is a system behaving exactly as written and wrongly as designed. The sample report shows what that looks like written up.

What if you find nothing?

You get the report anyway, documenting what was tested and how. That is a defensible artifact for a customer or an auditor. In practice it has not happened yet.

How quickly can you start?

Usually two to four weeks out. Scoping takes one email exchange; the wait is the calendar, not the paperwork.

How does payment work?

Half at signing, half on delivery of the report. Bank transfer or Wise, in US dollars. I am an individual contractor, so a W-8BEN is available if your finance team needs one.

Tell me what you need tested

mostafa@waltwhitehat.com

Describe the system and what worries you about it. I will come back with a scope, a timeline and a price.