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.
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.
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:
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.
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.
debug is present). Found debug, "based on: body length", in 123 requests and 0.87 seconds. The longest request target was 3,450 characters with 252 parameters.debug must equal 1, mode must equal raw). Found nothing, in 107 requests. By hand, debug=1 returned the SQL block, while debug=on, which is what Arjun sent, and debug=true returned the unchanged page.theme parameter that adds a stylesheet link (/a/reflect). Found nothing, in 107 requests. Replaying the calibration with Arjun's own functions showed why. The third request switched off the exact-body check, then name reflection, then value reflection, leaving only status, header names and redirect. theme changed none of those.sort, "based on: number of lines". The exact-body check was never set, because the two calibration responses differed, but the line count held.sort was never found and nothing spurious was reported. One run printed the "different content" message, and four printed only "No parameters were discovered."sort was found eight times and missed seven times, and nothing spurious was reported. One miss printed the "different content" message. We logged the banner in the last ten runs, and three misses had it in one of the calibration responses.debug and six of the seven blocked names, cmd, exec, shell, eval, passwd and select, "based on: http code", in 218 requests, of which 53 got a 403. The seventh name, union, is not in the wordlist. cmd=1 got a 403 by hand, and cmd2=1 got a 200.--rate-limit 15, it stopped after 28, because 21 requests landed within one second. ratelimit 2.2.1 counts calls in a fixed one-second window that resets, rather than a rolling one, so up to twice the configured number can land within one rolling second. With --rate-limit 9, it found debug in 123 requests and 13.2 seconds.export switches to CSV, and fmt switches CSV to JSON only when export is present). Found export only. Putting ?export=1 in the target URL changed nothing, because the query was dropped. With --include 'export=1', the run did not finish. In a bounded rerun with the query string logged, two requests alternated: one carrying fmt, ie and export, and the re-sent calibration request, a random name plus export, which Arjun sends whenever a round produces more groups than the last. We stopped the first run after about ten minutes and 268,096 requests. requester() adds the included names into the group it was given, so a two-name group becomes three. slicer() splits three as two and one, and the two-name half comes back unchanged. On /a/debug with --include 'foo=1', the run finished normally, so whether it loops depends on where the bisection lands. We saw one case of each.role (/api/echo, which returns the merged profile without storing it). GET mode found nothing in 107 requests. Form POST mode found nothing in 55. JSON mode found role, name and email in 81. Before chunking, its response heuristic extracted seven words from the short JSON response, role among them, and added them to the list. role was already in the default wordlist. name and email are the documented fields: Arjun has no way to know which names are documented.user. A GET straight after the run read {"name": "111116", "email": "111114", "role": "111111"}. The scan had overwritten every field, including the role. A second run from the same reset gave the same 56 requests, the same skip and the same readback.debug, and the app saw 122 requests.large_client_header_buffers 4 1k). Found debug. 309 requests got a 414, 430 reached the app, and the longest that reached it was 957 characters. A 414 is a status change, so Arjun bisects it like any other anomaly, at the cost of six times the requests in this run.--limit-request-line 2048). The run stopped with "Server received a bad request. Try decreasing the chunk size with -c option" after gunicorn rejected 25 request lines of between 3,163 and 3,396 bytes, and 4 requests reached the app. error_handler() counts 400s that differ from the baseline status and ends the target after more than 20. With -c 100, it found debug in 274 requests, the longest 1,507 characters.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.
name and email alongside role. A discovery result is a list of names the endpoint reacts to, and someone has to subtract the API description from it before anything is "hidden".== "1", == "true" or == "raw" never sees its value. A presence or truthiness check fires on any value and gets found. An equality check is found only if it happens to compare against the one value Arjun sends for that name, such as on for debug. For names outside the special file, that value is a six-digit number nobody compares against. The special file was written to cover the common spellings, and in this version only the last one survives loading.sort was missed in all five runs. Four ended with only "No parameters were discovered", which is this case. The fifth printed the "different content" skip instead, which is the next problem down.{"user": {"role": ...}} need an --include template containing the placeholder $arjun$, for example --include '{"user": {$arjun$}}'. requester() substitutes the chunk's names wherever the placeholder appears, and XML mode works only through such a template. Requests in the JSON, XML and form modes all go out as POST, so PUT and PATCH are outside what this version tests, and so are headers and cookies. All of that comes from reading the source. We measured only the GET, form and flat JSON cases above, and we did not test a template.--include gave it a working baseline that included export. A dependent parameter is a manual test.core/error_handler.py, a 429 or a 418 ends the target at once, as does a 503. A 400 or a 413 that differs from the baseline status is counted, and more than twenty of them end the target. A soft-limit page ends it through the "different content" check. All of them exit 0.union was blocked by our filter and not in the list. The same applies to an application's own vocabulary. plugins/heuristic.py adds names that appear in the page's form inputs, in its inline scripts, or in a JSON or plain-text response under 200 characters, so a page that shows its own field names gets them tested. A name that appears only in a JavaScript bundle loaded from another URL does not get added.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.
The procedure below is general practice.
sha256sum, and the line counts. If they differ, every later comparison has to be on a property that held.debug=1 and zq999=1 both change the response, the change belongs to the request shape, not the name.cmd blocked and cmd2 allowed points to a filter.1, true, yes, on, an empty value, a number, a string, a JSON object and an array. Note which values change behaviour, and how.fmt on /a/chain shows up.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.
All of this is general practice.
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.
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.
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.