DedSec Security Research ·
Here is a hypothetical. A content-discovery run against a staging host comes back with four lines worth a second look: admin with a 301, backup with a 200, api/export with a 403, and a line whose word column reads .htaccessDoPkCAQE, which nobody put in the wordlist. The ticket that follows says "admin panel, backup and export API exposed". A second engineer reruns the job with auto-calibration turned off and gets four hundred 200s. A third says the whole host is behind a firewall and none of it means anything.
All three are reading a list of responses as a list of resources. An ffuf hit is a response that passed the matchers and was not removed by the filters. It records what one server, or something in front of it, said to one request. Whether a resource sits behind that path is a separate question, and ffuf's output can only start to answer it.
This post is for whoever is holding an ffuf result. It covers how a hit is decided, what auto-calibration actually sends and filters on, why soft 404s and dynamic pages defeat some filters and not others, what each status code says about existence, how a clean run misses things, and how to confirm a discovered path by hand. It is the fifth post in a series about confirming DAST findings, after reflected XSS, SQL injection, OS command injection and Nuclei template matches. The DAST coverage post explains where brute-force discovery fits among crawling, schema import and parameter discovery. This post picks up where that one stops, at the moment a hit appears. The general argument that a clean run is not proof of absence is in why "the scan passed" is not "the scan ran".
Sources: from the ffuf repository on GitHub, the README, CHANGELOG.md and the wiki pages Home, Autocalibration, Recursion, Performance and rate, Request options and Input methods, all retrieved on 30 October 2026; RFC 9110 (HTTP Semantics), sections 15.4 to 15.6, and RFC 6585, section 4, for status-code semantics. The changelog lists releases up to v2.3.0, with further work on master, and the wiki describes current behaviour, including flags our binary does not have. The behaviour described as measured below was measured the same day with ffuf 2.1.0-dev, the build installed on our test machine (it reports itself as v2.1.0-dev), so other versions may behave differently. Where the documentation and our measurements disagree, we say so. ffuf ran together with a small Python test server we wrote, inside a Linux network namespace that had only a loopback interface. The server ran nine test sites on 127.0.0.1, and the wordlists were ones we wrote, between three and one hundred entries long. Nothing outside 127.0.0.1 was requested. The opening scenario is hypothetical, and no number in this post measures the accuracy of any scanner, ours included.
The wiki's Home page sets out ffuf's internal logic as a sequence: send the request, receive the response, discard it unless it matches one of the matchers, discard it if it matches one of the filters, send it to the replay proxy if one is set, then display it and keep it for the output file. Matchers decide what is interesting. Filters remove what you have decided is noise. Both look at the same few properties of a response.
A result line in ffuf 2.1.0-dev looks like this, from our first run against a test site that returns ordinary 404s:
admin [Status: 301, Size: 5, Words: 1, Lines: 1, Duration: 0ms]
The first column is the wordlist entry substituted into the FUZZ keyword. Size is the length of the response body in bytes. Words and lines are counts ffuf computes from the body, and they are less obvious than they look. The wiki describes words as "strings terminated by a whitespace". In our measurement, 2.1.0-dev counted spaces only:
a b c counted 3 words and 1 linea and b separated by two spaces counted 3 wordsa b c followed by a newline counted 2 linesThat matters as soon as you filter on word count. HTML laid out one tag per line can show a small, stable word count while its visible text changes completely. Before using -fw or -fl as a filter, look at the counts ffuf reports for a few known responses.
With no matcher given, ffuf matches on status code. The help text of the installed build gives the default as 200-299,301,302,307,401,403,405,500. The wiki's Home page gives an older list, "200,204,301,302,307,401,403,405,500", and the changelog for v2.1.0 records the change: "All 2XX status codes are now matched". Trust the help output of the binary you are running.
We requested one path per status code with the default matcher. 200, 204, 206, 301, 302, 307, 403, 405 and 500 were reported. 308, 400, 404, 410 and 503 were not, and neither were 429s from our rate-limited site (see "Rate limits" below). The list is a judgement about which responses usually mean "something is here", and three of its omissions can hide one:
-mc all matches every status, leaving you to filter.
The changelog records that "If any matcher is set, ignore -mc default value." We measured it. With -mr 'Not Found' and no -mc, the banner listed Matcher : Regexp: Not Found and nothing else, and the results were six 404s. The default status list was gone. This is the right behaviour, but it surprises people who add a regex matcher expecting it to narrow the default set. If you want both, give both, and set -mmode.
-mr, -ms, -mw, -ml and -mt match on a regular expression, a size, a word count, a line count, or the time to the first response byte (>100 or <100, in milliseconds). Two details about -mr and -fr came from measurement:
-mr 'WWW-Authenticate: Basic' matched nothing against our 401 page. -mr 'Www-Authenticate: Basic' and -mr '(?i)www-authenticate: basic' both matched it. A header regex written the way a browser's developer tools display the header can fail silently. Prefix header patterns with (?i).-fr 'page /FUZZ could' to filter a not-found page that echoes the requested path, and it removed every echo and nothing else.When there is more than one matcher, -mmode decides how they combine. The default is or. With -mc 200 -mr form, our run returned two hits: the login page, which contains a form, and a zip file, which returned 200 and contains no such text. With -mmode and it returned only the login page. A default-mode run with a status matcher and a content matcher is satisfied by the status alone.
Filters mirror the matchers: -fc for status, -fs for size, -fw for words, -fl for lines, -fr for regex and -ft for time, and the numeric ones accept lists and ranges. -fmode, also or by default, decides how several filters combine.
With -fc 403 -fs 5, or mode removed both /internal (a 403 of 9 bytes) and /admin (a 301 of 5 bytes). Each filter was satisfied by a different response. With -fmode and, the same pair removed nothing, because no response was both a 403 and 5 bytes long. -fc 403 -fs 9 -fmode and removed only /internal.
Or mode removes whatever any filter matches. A size filter chosen to remove the soft 404 also removes any real response that happens to be the same length, and in or mode it does so whatever the status code.
A soft 404 is a "not found" answer with a success status. The Nuclei post's section "The catch-all 200 that echoes the path" covers why applications do this and how it fools a matcher. For content discovery, the effect is simple: with the default status matcher, every word in the list is a hit. Each of our three soft-404 test sites returned 20 hits for a 20-word list.
What differs between soft 404s is which property stays constant, and that decides which filter can remove them.
-fs 142 removes the shell. It also removes /admin, because on this site /admin is a client-side route and the server returns the same shell for it. Nothing in the HTTP response distinguishes the admin route from a typo, so content discovery cannot find routes that exist only in the JavaScript bundle. Reading the bundle is the crawler's job, which the coverage post discusses. On this site only /api/health and /.env, which the server answers itself, were distinguishable from the shell.The page /path could not be found. Size changes with the length of the path, and the word count is constant at 7. -fs 70, taken from one sample, left 17 of the 20 hits. It removed only the paths whose length gave exactly 70 bytes. -fw 7 left only /admin. It also removed /status, a real page we built for the test whose text, "The service is up and fully healthy.", also counts 7 words in ffuf's terms. -fr 'could not be found' left /admin and /status.-fw 8, taken from one sample, left 18 of the 20 hits. -fl 8 left only /admin. -fr 'Sorry, nothing at' also left only /admin.The general lesson is that size, word and line counts are proxies for "this is the not-found page", and each one fails differently. Size breaks on any reflection or dynamic value. Words break on dynamic text, and can coincide with a real page. Lines hold up against inline variation, but a real page with the same layout is removed with the noise. A regex on the not-found page's own wording is the most specific of these, since it describes the page rather than its dimensions. Its failure mode is the opposite one: a real page that happens to contain the phrase is removed too. And there is no response property at all that separates an SPA's client-side route from a missing page.
-ac is described in the help as "Automatically calibrate filtering options". The wiki's Autocalibration page says that before the real run ffuf sends "a handful of requests for paths that almost certainly do not exist", compares the responses, and turns the first property they share into a filter, checking size, then word count, then line count. It also says calibration only uses probe responses that the matchers would have accepted. We logged every request the test server received and read the calibrated filters from ffuf's JSON output file, where 2.1.0-dev records them under config.matchers.Filters.
With plain -ac, ffuf sent six extra GET requests, all with the FUZZ keyword replaced. In our server log they arrived after the first wordlist request and before the rest of the list:
/adminumvnQJUVZRheMQLF, /adminHVXPYqom, /yJiCbMotVElcinge, /zwIGpUbB, /.htaccessWlVatMbQTBNztxJB and /.htaccessDoPkCAQE
That is two random strings of 16 and 8 characters, each sent bare, after "admin" and after ".htaccess". They come from a strategy file, basic.json, which ffuf wrote to $XDG_CONFIG_HOME/ffuf/autocalibration/ on first use, together with advanced.json. The advanced strategy adds four directory probes with a trailing slash, two of them starting with "admin". With -ac -acs advanced our server received ten probes. The wiki suggests the advanced strategy when "the server treats a trailing slash differently".
The "admin" and ".htaccess" variants exist because some applications treat those names differently from other paths. Our ninth test site redirects anything that starts with /admin to the login page. Calibration on that site produced a size filter of 0, learned from the admin-prefixed probes, and the /admin redirect disappeared from the results, which is correct: it said nothing more than a random admin-prefixed path did.
The random strings are not regenerated per run. They were generated once, when the strategy file was written, and every -ac run in our lab, against every test site we calibrated on, sent the same six paths. The file on another machine, or under another user's config directory, holds different strings. The practical points are that calibration is not a fresh random baseline each time, that the probes look the same in the target's logs every run, and that a team sharing a config directory sends the same probes from every scanner.
The calibrated filters for our sites were:
These were the usual results, not the only ones. In repeat runs against the dynamic site, 2.1.0-dev sometimes recorded two filters at once (line 8 plus a size or a word count), and in one run of nine it recorded a size and a word count but no line filter, and 19 of the 20 soft 404s came through. The wiki describes a single filter taken from the first shared property. That is not what this build recorded every time.
Each of those is a filter on a body property. None was tied to a status code. On the admin-prefix site, the size 0 filter, learned from 302 responses, also removed a 204 at /status and a 307 at /temp, both of which have empty bodies and neither of which calibration ever saw. On the echo site, the word 7 filter removed the real /status page along with the soft 404s, exactly as the hand-written -fw 7 did.
Against the WAF site, calibration removed everything. Without -ac, every path was a hit, 100 of 100 in a run with a larger list, all of them the block page. With -ac, none was. The empty result is accurate, since the block page is noise, but it is not a statement about the application behind the firewall, which received none of the requests.
We built a site whose not-found page varies in size, words and lines on every request. We ran calibration against it three times. In two runs, no filter was recorded, and all 20 soft 404s came through. In the third, the probes happened to share a line count, a filter of 11 lines was recorded, and three of the 20 soft 404s were removed, along with anything else that happened to be 11 lines long. The wiki says that when the probes have nothing in common, "ffuf tells you it couldn't calibrate". In our 2.1.0-dev runs we saw no such message in the output, so check what was recorded rather than relying on a warning.
The help describes -acc as "Custom auto-calibration string. Can be used multiple times. Implies -ac" and -acs as "Custom auto-calibration strategies. Can be used multiple times. Implies -ac". The wiki says the same. In 2.1.0-dev, neither implied -ac. With -acc zzcustomzz alone, and with -acs advanced alone, the server received only the wordlist requests, the JSON output recorded IsCalibrated false and no filters, and every soft 404 came through. With -ac added, both worked. Whatever version you run, pass -ac explicitly and check that the JSON output records the calibration.
With -ac -acc zzcustomzz -acc yycustomyy, the custom strings replaced the strategy probes. Only those two paths were sent. Both are ten characters long, so the echo site answered both with 73 bytes, and the recorded filter was size 73, which removes only soft 404s for paths of exactly that length. The login, status and missing-path soft 404s all came through. Custom calibration strings should differ in length and shape, or every one of them will produce the same accident.
-ach is "Per host autocalibration". It is meant for runs that span several hosts, where a single global filter is wrong. We fuzzed two hosts in one clusterbomb run, the SPA site and the echo site. With global -ac, the server log showed probes sent only to the first host, the recorded filter was its shell size, 142, and every soft 404 from the echo site came through. With -ach, both hosts were probed. But the JSON output recorded the same per-host filter for both, a list of four sizes, three from the echo site's probes and one from the SPA's, and the echo site's soft 404s for the wordlist paths, which had other sizes, still came through. We did not investigate further. Before trusting per-host calibration in a given build, read the recorded per-host filters.
When the FUZZ keyword is in a header, calibration puts the probes there too. Fuzzing the Host header against our virtual-host site with -ac, the server received the six probe strings as Host values. The default virtual host's page gave a size filter of 43, and only app.internal remained. -ack sets which keyword calibration substitutes into when it is not FUZZ.
With -ac, the word column in the output was sometimes a calibration probe, not the wordlist entry. On the echo site, the one real hit, /admin, was printed under its own name in 9 of 20 runs. In the other 11, it was printed as .htaccessDoPkCAQE, adminHVXPYqom or zwIGpUbB. With -t 1, all 20 runs printed a probe name. In JSON output, the input field for the hit held a probe name in 5 of 10 runs. In every case the URL was correct: -v printed http://127.0.0.1:8083/admin, and the url field in the JSON said the same. The changelog for v2.3.0 lists "Fix autocalibration mutating the caller's input map". We did not test v2.3.0 and cannot say whether that fix is for this behaviour. Whatever the cause, triage from the URL, not the word column. That explains the fourth line in the opening scenario.
Calibration is a filter generator. It removes responses that look like the responses to its own probes, using one or more body properties that its probes happened to share in that run. It has no notion of status, of which response is "real", or of what the application behind the response is. It is useful, and it is the cause of some false negatives. It does not confirm a hit.
RFC 9110 defines what each status code means for the origin server. Content discovery adds one complication: the response may not come from the origin at all. A load balancer, CDN, WAF, authentication proxy or API gateway can answer before the application sees the request, and each has its own idea of what to say.
Allow: POST. A 405 is often the strongest status-only evidence in a discovery run, because a router had to match the path to know that the method was wrong. Not every framework sends it, though. Our /api/import returned 404 to GET and 200 to POST, as frameworks that register routes per method commonly do, so it appeared only in a run with -X POST.Our first site redirects /admin to /admin/, which answers 401 with WWW-Authenticate: Basic realm="admin". The default run reported admin [Status: 301, Size: 5, ...]. The 401, which is the interesting fact, appeared only when we requested /admin/ ourselves or used -r. -v printed the Location under each redirect hit, which is enough to see where each one leads without following it.
-r follows redirects, and the result line then describes the final response. In our run with -r, admin became a 401, and /old (302), /temp (307) and /perm (308) all became 200 with 48 bytes, the login page. Three hits, one page. The wiki's Request options page warns that with -r on, "a lot of responses come back 200, so lean on size, word, or regex matching rather than status codes."
The wiki's Recursion page says the default recursion strategy treats a match as a directory when the server redirects it to the same path with a trailing slash. We measured it. With -recursion, /admin's 301 to /admin/ queued a job for /admin/FUZZ, and /admin/users was found with a 401. The result line for that hit read users [Status: 401, ...], with no parent path. The only context was the preceding line, [INFO] Starting queued job on target: http://127.0.0.1:8081/admin/FUZZ. Pasted into a ticket without -v, a recursive hit looks like a top-level path.
A directory that answers 200 without redirecting is not recursed into under the default strategy. -recursion-strategy greedy recurses into every match. -recursion-depth defaults to 0 in the help text, and the wiki says the default has no depth limit. At the limit, our greedy run at depth 1 printed [WARN] Maximum recursion depth reached. Ignoring: http://127.0.0.1:8081/admin/users. The wiki shows the same warning with different wording, another sign that output text changes between versions.
Files are bounded by extensions. -e "Extends FUZZ keyword", and the wiki says each word is tried on its own and with each extension appended. Our list contained config.php, which returned 404. With -e .bak, config.php.bak was found. -D does the same for DirSearch-style lists with an %EXT% placeholder.
A path not reported by ffuf is a path whose responses did not survive the matchers and filters. That includes paths that do not exist, and also every path whose request never reached the code that would have answered it, or whose answer was removed. These are the ways it happened in our lab, and one from the documentation.
Host: app.internal. Scanning an IP address tests the default virtual host, and scanning a CDN hostname tests the edge.Errors: 0. The run looked complete and clean. The wiki's Performance and rate page says -sa also stops when more than 20% of responses are 429. The help text for -sa says only "Stop on all error cases. Implies -sf and -se." With -sa and -t 1, the run stopped after about 50 requests with [WARN] Getting an unusual amount of 429 responses, exiting. -rate and -p slow a run down to stay under a limiter.[WARN] Getting an unusual amount of 403 responses, exiting. The wiki says ffuf waits for more than 50 requests before deciding; we observed that threshold only with -t 1. Without -sf, the run reported every path as a 403 hit, and with -ac it reported none. A stopped run is an incomplete one, so record it as such. A WAF that answers with a 200 block page triggers none of these.-timeout 1, it was not reported, the progress line showed Errors: 1, and with -s nothing in the output showed that a request had failed at all. With the default timeout of 10 seconds it was found. -se "Stop on spurious errors"; the wiki says that means more errors than twice the thread count.-maxtime 2 -p 0.1 -t 1, our run stopped after 20 of 100 requests with [WARN] Maximum running time for entire process reached, exiting. In a repeat of that run with JSON output, ffuf exited with status 0, and the output file held the 20 results it had collected with nothing recording that the run had stopped early. Unless the console log is kept, it reads like a complete result. -maxtime-job does the same for each recursion job.A hit is a lead. Confirming it means establishing, for that path, what answered and what the answer means. The procedure below is general practice. The measurements behind each step come from our lab.
curl -sS -D - -o hit.body with the same method, headers and Host as the run, and read every header. The status, Location, WWW-Authenticate, Allow, Content-Type, Server, Via and any cache headers each say something different about who answered and what they meant.-mc all and look at the status distribution before choosing filters.Back to the hypothetical run from the opening.
In the scenario, the admin 301 pointed at /admin/, and requesting /admin/ returned 401 with a Basic challenge whose realm named the application. Random paths under /admin/ returned the same 401, so the claim the evidence supported was narrower than "admin panel exposed": an authentication-protected admin area is reachable from the network the scan ran from. The finding was kept, with that wording, and passed to the owner to decide whether the admin area should be reachable from there at all.
In the scenario, the backup 200 came from a server rule that answered any path starting with /backup with the same 4,817-byte page. Calibration's probes never started with "backup", so it learned nothing about that prefix. A random path under /backup/ returned the same 4,817 bytes and the diff was empty. The four hundred 200s in the second engineer's run, without calibration, were the application shell at the root. The finding was closed with the baseline attached.
In the scenario, the api/export 403 came from the API gateway, which answered every path under /api/ that was not in its route table with the same 403 and body. That said nothing about whether an export endpoint exists. The team checked the gateway's route list instead, found an export route on a separate virtual host, and scheduled a run against that hostname with POST as well as GET.
In the scenario, the line labelled .htaccessDoPkCAQE was the label behaviour measured above. Its URL was /status, a health endpoint that was meant to be public. The firewall engineer's objection was half right: the WAF had been answering 403 for a block of requests in the middle of the run. -sf would not have caught that, since it stops only when more than 95% of responses are 403s, but a -mc all run's status distribution would have. That block was rerun from an allowlisted address.
AppSecD's dynamic and API testing runs Nuclei, Dalfox, SQLMap, Commix, Katana, Arjun, FFuf and Interactsh for out-of-band detection, plus more than 150 native checks and API discovery across more than 50 web frameworks. In its lifecycle this is the runtime stage: DAST and API testing run against the deployed application, because code review cannot see an exposed API route that only appears once the application is assembled and running. Its findings are deduplicated across scans and tracked through new, reopened and fixed states, and its lifecycle supports maker-checker approval, so a finding marked as a false positive can require a second person to confirm it.
That is the whole claim. This post does not claim which ffuf version AppSecD runs, which wordlists, extensions, methods or virtual hosts it uses, whether or how it uses auto-calibration, recursion, -sf, -sa or -maxtime, what rate limits, delays or timeouts it applies, how it filters soft 404s, whether it takes baselines or confirms hits, how it maps a discovered path onto a finding or its severity, or how accurate its content discovery is. The measurements, the confirmation procedure and the checklist above are general practice, not a description of how AppSecD runs ffuf internally, and they apply to any content-discovery output, ours included. The scenario in this post is hypothetical and does not describe any AppSecD deployment, user or finding.