Arjun found a hidden parameter. Is it real? Parameter discovery as a DAST finding

DedSec Security Research ·

Here is a hypothetical. A dynamic scan runs parameter discovery against four endpoints and reports three results and one clean bill of health. On /orders it found debug, rated medium. On /search it found cmd, exec, shell, eval, passwd and select, rated high because the names look like a command-execution surface. On /api/profile and on /export it found nothing.

The high gets escalated, the medium goes into a sprint, and the two clean endpoints are not looked at again. As in the earlier posts in this series, each decision rests on the title rather than on what the tool observed. The six dangerous-looking names are what a request filter in front of /search blocks. The application never reads any of them. debug is real, but "found" says only that the response changed, so nobody yet knows what it exposes. /api/profile was tested with query strings while it reads a JSON body. The /export run never got through its wordlist: a front end rejected its long request lines, the tool printed "Skipped", and the scan still exited cleanly. Behind that, /export also has a second parameter that only does anything when the first is present, which parameter discovery cannot find on its own because it tests names one at a time by design.

This post is for whoever is holding a parameter-discovery result from a dynamic scan, or a "no parameters found" they are about to rely on. It covers:

It is the fifteenth post in a series about confirming DAST findings. The earlier ones cover reflected XSS, SQL injection, OS command injection, Nuclei template matches, ffuf content discovery, path traversal, open redirect, SSRF through URL-fetch parameters, XXE, CRLF header injection, Host header injection, HTTP request smuggling, CORS misconfiguration and JWT validation. The nearest neighbour is the ffuf post. ffuf asks which paths exist, Arjun asks which names an existing path reads, and both turn "the response differed" into a claim about the application.

Sources, and how each was checked. We made the measurements below on our test machine on 4 November 2026. It runs Ubuntu 24.04.4 on a virtual machine with two vCPUs of an AMD EPYC 9354P, and every server was bound to 127.0.0.1. We installed Arjun 2.2.7 from PyPI into a virtual environment under Python 3.12.3. That pulled in requests 2.34.2 and ratelimit 2.2.1. The lab app ran on Flask 3.1.3 with Werkzeug 3.1.9's development server, and in one case under gunicorn 26.2.0. nginx 1.24.0 served as a cache and as a front end with a small request-line buffer. When we explain behaviour from source, we read the installed copy on disk, and we name the file and function. We checked RFC 9110 against the RFC Editor's text, and the CWE and OWASP titles against MITRE's and OWASP's pages, on the same day.

We did not test Arjun's --passive mode, which collects names from third-party archives, or its XML mode, its --stable mode, its import of raw requests, or its casing option. We did not test any version other than 2.2.7, any other parameter-discovery tool, a real WAF or CDN, HTTP/2, or any production application. Nor did we test hidden headers or cookies, which Arjun does not probe. The opening scenario is hypothetical. The numbers measure Arjun 2.2.7 at the settings stated against our lab, and none of them measures AppSecD or how any product configures Arjun.

What "parameter found" means, mechanically

The core of Arjun 2.2.7 is initialize() and narrower() in arjun/__main__.py, define() and compare() in arjun/core/anomaly.py, and a few helpers in arjun/core/utils.py. Read in order, a run does the following.

A reachability check. stable_request() sends one GET to the target, and skips the target if that fails or if the response's Content-Type does not mention text, HTML, JSON or XML. It rebuilds the URL from scheme, host and path, so any query string in the -u URL is dropped here. We confirmed that in the request log: with ?export=1 in the target URL, the probe arrived with no query string.

Calibration. Arjun sends the same random name and value twice, a six-character name starting with z and a six-digit value. define() compares the two responses and records each property that held steady:

It then sends a third request with a different random name. Any recorded property that this request breaks is switched off, one at a time, until the third request passes. That is the stability check, and it decides what the rest of the run can see. Whatever it switches off is gone for the whole run.

Chunking. The default wordlist is db/large.txt, which holds 25,890 names. Arjun adds the 40 entries of db/special.json, then splits the set into len(wordlist)/chunk groups, with a chunk size of 250 for GET and 500 for every other method. That gave 103 groups for GET and 51 for the other modes. populate() gives each name a six-character value built from its index, such as 111116. Each group goes out as one request, in up to five threads by default.

The comparison. compare() checks each response against the surviving properties in a fixed order and returns the first that breaks. The reason labels in the output map to them: "http code", "http headers", "redirection", "body length", "number of lines", "text length", "lines", "param name reflection" and "param value reflection". "Body length" is the label for an exact body comparison, so a one-character change with the same length still counts. Reflection only counts for names of five or more characters and six-character values that appear between quotes or whitespace.

Bisection. narrower() splits every group that broke a property into two halves with slicer() and sends both. When a group is down to one name, confirm() sets it aside. If a round produces more groups than the last one, Arjun re-sends the third calibration request. If that now differs too, it prints "Webpage is returning different content on each request. Skipping." and returns nothing for the target.

Verification. Each single name is sent once more on its own. If a property breaks again, Arjun prints "parameter detected" with the reason.

So a hit means one thing. A request carrying that name differed from the calibrated baseline on a property still being checked, at every level of the bisection and once more alone. It does not mean that the name is undocumented, that the application does anything security-relevant with it, or that any value other than the one Arjun sent would behave the same way.

The values matter more than they look. db/special.json is written as 151 name and value pairs for 40 names, such as "debug": "yes", "debug": "true", "debug": "1" and "debug": "on". Python's json.load keeps the last value for a repeated key, so only 40 entries survive, and they replace the generated values. In this version, debug, admin, test and source are sent only as on, and env only as uat. The other 35 special names also get one fixed value each, such as nil, no or 1. Every name outside the special file gets a six-digit number.

The claim a finding must support

A discovered parameter is usually filed as informational, and that is the right default. When it is escalated, the classification depends on what the parameter does. CWE-489 (Active Debug Code) and CWE-215 (Insertion of Sensitive Information Into Debugging Code) fit a debug switch. CWE-915 (Improperly Controlled Modification of Dynamically-Determined Object Attributes) fits mass assignment. In the OWASP API Security Top 10 2023, mass assignment is part of API3:2023 Broken Object Property Level Authorization, which the project's page says was "previously named" Mass Assignment.

Whatever the label, an exploitable result is a conjunction of three things:

  1. The application reads the name. The response changed because of it, not because of noise, a filter or a cache.
  2. Some value changes behaviour that matters. It exposes data, changes state, skips a check, or reaches a code path with weaker controls.
  3. The caller should not be able to cause that.

Arjun's output speaks only to point 1, and only for the value it sent. Points 2 and 3 are what the other checks, and a person, have to establish.

What Arjun reported on the lab, measured

The lab app had one known answer per endpoint. A small script ran Arjun with default settings unless stated otherwise, timed each run, and counted the requests the app logged. Each result below comes from that run's saved output.

Every run that finished exited with status 0, including the ones that printed "Skipped" or "different content". The JSON report was written only for runs that found something. The default GET chunks stayed under 3,500 characters in every run. That is well below the 8000 octets that RFC 9110 section 4.1 recommends senders and recipients support, so both length limits above were ones we configured. RFC 9110 section 15.5.15 defines 414 (URI Too Long), and the front ends that answer a long request line with 400 instead are the ones that end the run.

What it flags that is not a parameter

What it misses

When "no parameters" means the scan did not run

Eight of our runs that exited normally stopped before Arjun had finished with the target. Three ended on errors: the hard rate limit, at the default rate and at --rate-limit 15, and the gunicorn front end. Five ended on the "different content" check: the soft limit, one rotating run, one flaky run and both runs against the persisted profile. Every one exited with status 0. The output said so in words, with "Skipped ... due to errors", "Server received a bad request" or "Webpage is returning different content on each request". A pipeline that reads the exit status or the presence of a JSON report treats all of them as clean. The scan-passed post covers that failure in general.

The primary check is to read the output for those messages, or to capture it and fail the job when one appears. Counting the requests the target received is a useful second check, but it is necessary rather than sufficient. The error-ended runs were obvious: 23, 28 and 4 requests reached the app, against 107 for a complete GET run with the default wordlist and chunk size that found nothing. The "different content" skips were not. That check runs after the first full pass over the chunks. So the soft-limit run and the rotating skip each logged 108 requests, the flaky skip 130, and each persisted-profile run 56, against 55 for a complete form run. Their counts look like finished scans.

Confirming a discovered parameter by hand

The procedure below is general practice.

  1. Establish the baseline's stability. Send the unmodified request five times and compare the bodies, for example with sha256sum, and the line counts. If they differ, every later comparison has to be on a property that held.
  2. Add the name with an unrelated value, then with a junk name. If debug=1 and zq999=1 both change the response, the change belongs to the request shape, not the name.
  3. Try a near-miss name. cmd blocked and cmd2 allowed points to a filter.
  4. Vary the value deliberately. Try 1, true, yes, on, an empty value, a number, a string, a JSON object and an array. Note which values change behaviour, and how.
  5. Move it. Try the name in the query string, a form body and a JSON body, and at a nested level if the API nests objects.
  6. Combine it with the endpoint's documented parameters and with other discovered names. That is how fmt on /a/chain shows up.
  7. Check the path between you and the application. Look for a cache-status header, a different response with a cache-busting parameter, and the status a long query gets.
  8. For state-changing endpoints, use a test account and read back the stored state after each request. The scan does not do this, and our discovery run had already rewritten the profile.
  9. Keep the evidence: the baseline, the request with and without the parameter, the values tried, and what each changed.

A parameter is an input, not a finding

Once a name is confirmed, it is an input like any other, and the rest of a dynamic scan applies to it. Every injection check can only test inputs it knows about, which is why parameter discovery belongs ahead of the SQL injection, command injection, path traversal, SSRF and open redirect checks rather than beside them. A name like url, next, file or template tells you which of those to run first. Three patterns are worth knowing because the parameter itself is the bug.

A debug switch. On /a/debug, any value printed a query and a database name. The finding is what the switch exposes or enables, such as stack traces, queries, configuration, a disabled check or verbose logging, and who can flip it. A switch that only works from an internal address is a different finding from one that works for everyone.

Mass assignment. On /api/echo, role in a JSON body set the role in the returned object. A form field with the same name did not. The finding needs the persisted state, read back as the affected user, and a second test account that shows one user cannot raise their own privileges. When the bound object belongs to another user, it is also an authorisation question, and the BOLA and IDOR post covers how to test it.

An alternate code path. export on /a/chain switched to a different serialiser, and fmt switched it again. In real applications, an export, legacy, preview or raw path is often older code with its own authorisation and output handling. The finding is whatever that path does differently, tested with the same checks as the main one.

A discovered parameter with no behaviour that matters is an informational note about the attack surface, and closing it as such is correct.

The fix

All of this is general practice.

The static side

Most hidden parameters are visible in source, and the source shows the exact value Arjun could not guess. request.args.get('debug') == '1' reads as plainly as it runs. Framework binding of a whole request body into a model, such as Model(**request.json), a permissive strong-parameters list, or an ORM update from an unfiltered dict, is a mass-assignment pattern. A parameter read is a taint source like any other, and following it to the code it switches on is the same source-to-sink work as for any injection. The SAST false-positive post covers how that analysis goes wrong in mechanism.

What source does not show:

Those are the parts of the confirmation that need the running system.

A triage checklist for a parameter-discovery finding

  1. What did the tool compare, and what did calibration switch off? A reason of "http code" on a dangerous-looking name points to a filter.
  2. Did the run finish? Look for "Skipped", "bad request" or "different content" in the output, and count the requests the target received.
  3. Is the name documented? Diff against the API description.
  4. Does a junk name, and a near-miss name, produce the same change?
  5. Which values change behaviour, and in which part of the request?
  6. Does it depend on another parameter?
  7. What does it do: expose data, change state, skip a check, or reach another code path?
  8. Who can trigger it, and does it cross a user or tenant boundary?
  9. Has it been run through the injection checks as an input?
  10. For a clean result, was the endpoint tested in the method and body format it actually reads, and was a cache or limiter in the way?

The hypothetical findings, resolved

Back to the four hypothetical endpoints.

/search. In the scenario, the six "parameters" were a block list in front of the application. cmd=1 got a 403 and cmd2=1 did not. The application's code never read any of the six. The finding was closed as a false positive, with the near-miss requests attached.

/orders. In the scenario, debug was real and worse than its medium suggested. Any value printed the SQL behind the page and the database name, for any caller. It was removed from the production build, and the retest confirmed that debug with any value no longer changed the response.

/api/profile. In the scenario, the clean result came from testing query strings against an endpoint that reads JSON. The endpoint stores what it receives, so a JSON-mode rerun printed the "different content" skip and found nothing. It also rewrote the test profile it was pointed at. role was found by hand instead, from the field names in the endpoint's own response. A test account set its own role to admin in a JSON body and read it back, and the binding was changed to an allow-list.

/export. In the scenario, the clean result was a run that had ended after a front end answered its long request lines with 400s. It exited 0 and printed "Skipped". A rerun with a smaller chunk size found export and, as expected, not the parameter that depends on it. A manual test of export combined with each documented name found that fmt=json switched to an older serialiser that skipped the tenant filter. That was then filed and tested as an authorisation finding.

Where AppSecD fits

AppSecD's dynamic and API testing runs Nuclei, Dalfox, SQLMap, Commix, Katana, Arjun, FFuf and Interactsh for out-of-band detection, plus 150+ native checks and API discovery across 50+ web frameworks. Its static analysis includes dataflow taint analysis that traces source to sink across functions. Its findings are deduplicated across scans and tracked through new, reopened and fixed states, and they need maker-checker approval to close, so a finding cannot be closed unilaterally.

That is the whole claim. data/products.ts is the single source of truth for what these products do. It names Arjun, and it does not describe how Arjun is configured or used. So this post does not claim anything about:

The measurements, the confirmation procedure, the fixes and the checklist above are general practice, not a description of how AppSecD works internally, and they apply to any scanner's output, ours included. The scenario in this post is hypothetical and does not describe any AppSecD deployment, user or finding.

More about AppSecD · All posts