The fuzzer found /admin. Is it really there? What an ffuf content-discovery hit proves: matchers, filters, auto-calibration, soft 404s, 401 versus 403, redirects, and how a discovered path gets confirmed

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.

What a hit is

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:

That 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.

Matchers

The default status list, and what it leaves out

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.

Setting any matcher replaces the default

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.

Regex, size, words, lines and time

-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:

-mmode: or by default

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

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.

Soft 404s: why the filter you choose matters

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.

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.

Auto-calibration, measured

-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.

What it sends

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.

What it filters on

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.

When the probes share nothing

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.

-acc, -acs and -ach

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.

The word column can show a probe name

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.

What calibration is

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.

What a status code says about a path

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.

Trailing slashes, -r and redirects

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."

Directory or file

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.

How a clean run misses

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.

Confirming a hit by hand

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.

  1. Take the URL, not the word. Use -v, or the url field in JSON output. With -ac, the word column can be a calibration probe, and in a recursive run it lacks the parent path.
  2. Take a baseline in the same place. Request two or three random paths at the same depth, with the same extension and trailing-slash form as the hit, and of different lengths. A random /admin/x7Qp.php is the baseline for /admin/config.php, not a random path at the root. If the baseline returns the same status, the hit means nothing about that path by itself.
  3. Compare bodies, not lengths. Save the hit and the baseline and diff them, after replacing any echoed path in the baseline. On our echo site, /status and the soft 404 had the same status and the same word count, and the diff showed one line: "The page /PATH could not be found." against "The service is up and fully healthy." That difference is the evidence, and no size, word or line count would have shown it.
  4. Replay it with curl using 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.
  5. Walk redirects one hop at a time. Request each Location yourself instead of using -r, so that you see which hop returns what. Our /admin was a 301 to /admin/ and then a 401. The directory's real answer was the second hop.
  6. Establish the authentication requirement. For a 401, read the challenge scheme and realm, retry with obviously wrong credentials, and check that random paths on the host do not get the same challenge. For a 403, check whether a random path under the same prefix gets the same 403. If it does, a rule for the prefix or a WAF is answering.
  7. Establish whether the application answered. A block page carrying a reference ID, a Server header naming an edge product, or an identical status and size for a random path all point to something in front. On our WAF site, /admin and a random path both returned a 403 of 65 bytes. If the engagement allows it, repeat the request against the origin directly, or from an address the WAF allowlists.
  8. Check methods. For a 405, the Allow header lists what the resource supports. Ours said POST. Try the listed method with an empty or harmless body. Do not assume OPTIONS will tell you: our test server answered OPTIONS with a 405 of its own.
  9. Check that the content is what the path suggests. For files, look at the first bytes and the Content-Type. Our /backup.zip began with the bytes 50 4B 03 04, the zip local file header signature, and was served as application/zip. A 200 HTML page at /backup.zip is a soft 404 or a download page, not a backup. For pages, look for content specific to the application, not a framework's generic page.
  10. Keep the evidence. In 2.1.0-dev, -o with -of json recorded the command line and the configuration used, including any calibrated filters, alongside the results. -od is described in the help as a "Directory path to store matched results to". Attach the request, the response and the baseline to the finding, so a retest can be compared with them.
  11. State the claim the evidence supports. "/admin/ exists and requires HTTP Basic authentication, realm admin" is a finding. "/api/export returns 403" is an observation, until a baseline shows it differs from its neighbours.

A triage checklist for an ffuf result

  1. Record the exact command, version and config file, including anything set in ffufrc and the matcher, filter and calibration settings. Two runs with different settings have different meanings for "no hit".
  2. Read the matcher set from the banner. Setting any matcher replaces the default status list. -mmode and -fmode default to or.
  3. Check what the default status list leaves out: 308, 400, 404, 410, 429 and 503 were not matched in 2.1.0-dev. Run once with -mc all and look at the status distribution before choosing filters.
  4. Use the URL, not the word column, especially with -ac or -recursion.
  5. If calibration was used, read the filters it recorded from the JSON output, and check that IsCalibrated is true. In 2.1.0-dev, -acc and -acs did not turn it on by themselves.
  6. Ask what each filter would also remove. Size, word and line filters are not tied to status, and a calibrated filter can remove a real page, an empty 204 or a redirect it never saw.
  7. Choose the filter that describes the noise. A regex on the not-found page's own text holds up better than counts on dynamic pages. Calibrate per host when one run spans several hosts, and verify the per-host filters.
  8. Take a baseline at the same depth and in the same form as each hit, and diff the bodies.
  9. Read each status for what it is: 405 with Allow and 401 with a challenge are the strongest status-only evidence; 403 and 200 need a baseline; a redirect points at the evidence rather than being it.
  10. Find out who answered. Look at the Server and Via headers, block page markers, cache headers, and whether random paths get the same answer.
  11. Replay outside ffuf with the same method, headers and Host header, and walk redirects by hand.
  12. Record what the run could not see: 429s, timeouts and errors, early stops from -sf, -sa or -maxtime, the methods, hosts and extensions not tried, and the size of the wordlist. A clean run with these gaps is not a clean application.
  13. Write the finding as the claim the evidence supports, and attach the request, response and baseline.

The hypothetical results, resolved

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.

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 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.

More about AppSecD · All posts