Hi people,

In this write-up I want to share a small form behavior that became much more interesting once I stopped looking at the page and started looking at the request behind it.

The page had a normal public form. You entered a value, the application checked it, and the interface told you whether you could continue. Nothing about that flow looked special. But the request carried more than the value. It also carried information that influenced which validation logic the server ran.

Publication note: This story is reconstructed from private research. The company, product, routes, identifiers, dates, and UI labels were removed or replaced. The examples are synthetic. I am not claiming that a fix was deployed or that a completed retest occurred.

A public validation control illuminating information inside a hidden data archive.
Original cyanotype blueprint illustration for this anonymized field note.

Why the request caught my attention

When I test a form, I like to separate two things: the value a visitor is allowed to supply and the rule the application should own. The visitor can choose an email address, username, reference, or coupon code. The visitor should not be able to choose an internal database rule and ask the server to run it.

That was the boundary I wanted to test. I captured the ordinary request, changed only the caller-controlled action and validation fields, and kept the rest of the flow untouched. The first few changes produced ordinary errors. Then one combination returned a meaningful yes-or-no answer about a value that the public form did not need to know.

Reconstructed flow using generic labels. No original route, field name, or response is shown.

How I tested the difference

I used values belonging only to my controlled test setup. First I sent a value that I knew existed. Then I sent a random value that I knew did not exist. I repeated both requests and changed one input at a time. The answer changed consistently with the stored state, not with timing or a front-end message.

The simplified shape looked like this:

POST /forms/check HTTP/1.1
Host: app.example
Content-Type: application/json

{"action":"check_value","field":"contact","value":"candidate@example"}

HTTP/1.1 200 OK
Content-Type: application/json

{"result":"known"}

This is not an original request. The route, names, values, and response were invented for the article. What mattered in the actual test was the stable difference between a controlled present value and a controlled absent value.

This is where it became interesting

A boolean answer can look harmless. It is only one bit. But one bit can still cross a security boundary when the question is sensitive. An anonymous availability check may be expected. A check that confirms whether a private account, invitation, or internal record exists may not be.

I also saw diagnostic behavior that exposed more structure when the helper failed. I treated that separately. Removing a stack detail or internal name would improve the error response, but it would not remove the data oracle. The server still needed to decide which questions a public caller was allowed to ask.

I did not prove direct database access, bulk extraction, or account takeover. The finding was narrower: a public caller could influence server-side validation and learn a fact about a candidate value that the intended form did not need to reveal.

Why hiding the button would not fix it

The problem lived behind the interface. Removing a field from the page or disabling a button would not change the callable server behavior. Even an action allowlist would be incomplete if an allowed action still accepted its validation policy from the request.

The cleaner design is simple: register every public action explicitly, give it a fixed server-owned schema, accept only values from the visitor, and build a deliberate public response. Privileged presence checks should sit behind a different operation with an authorization check before any lookup happens.

Open-source workflow companion: ffuf

For this kind of validation oracle, ffuf is a useful open-source companion. It can place its FUZZ keyword in a URL, header, or request body, then match or filter responses by status, size, words, or a regular expression. I would start from a sanitized raw request, use a short approved list of candidate validation modes, and compare only controlled present and absent values. That removes manual drift and makes a stable response difference easier to spot. A match is still only a lead; I would manually replay the matched pair before reporting it. This is a current workflow recommendation, not a claim that ffuf was used in the original private submission. Use conservative rates and never test real customer identifiers.

Takeaway

  • Let the visitor provide the value, not the validation rule.
  • Map public actions explicitly instead of exposing a generic helper dispatcher.
  • Test known-present and known-absent controlled values to prove a stable difference.
  • Keep internal diagnostics in protected logs, but remember that a quiet boolean can still leak data.
  • Check that rejected actions perform no database work, not only that they return an error.

The biggest lesson for me was that validation is not only about rejecting bad input. It is also about controlling which question the application is willing to answer.

That is all for this write-up. Hope you found it useful. For another boundary story, read when a private response escaped through a shared cache, or browse the complete Bug Bounty Archive.

Continue reading

Test what the server trusts.

Explore our web application penetration testing service or continue through the Bug Bounty Archive for more first-person security research.

Research topics: bug bounty / validation / data exposure / web security