Qualys vs Real Attackers: What Your Scanner Misses, and How to Stop It Drowning Your SOC
An authorised Qualys scan sent 11,262 requests to my honeypot in 31 minutes. Over three and a half weeks, attackers sent 3,307 requests for secret files, and the scan asked for .env zero times. I compare the two, then show how to handle scanner noise properly in Splunk and Sentinel, find the coverage gaps, and use the scan to test your own detections.
Part of my honeypot detection series. Org A runs Splunk with CrowdStrike Falcon. Its Falcon queries use Event Search field names; on raw FDR data, apply the normalisation macro first. Org B runs Microsoft Sentinel with Defender for Endpoint. The web-layer KQL ran against the honeypot's real logs. The validation queries are templates for your environment.
1. What Hit the Server
The day after the honeypot went live, I pointed a Qualys scan at it: 11,262 requests from 52.176.19.239 in 31 minutes. That's more than everything every attacker sent in the following three and a half weeks put together. In my logs, the authorised scan was more than half of all web traffic.
That's the first problem for a SOC. A vulnerability scan looks exactly like an attack, lands in the same tables, and fires the same rules. The second problem is subtler. The scan and the attackers barely asked the same questions:
- The scanner requested 6,078 different paths. Attackers requested 2,050. Only 212 appear in both lists.
- Attackers' favourite target was secret files: 3,307 requests for
.env,.gitand config files. The scan sent 170, and not one was for.env. - The scan spent 45 requests on Log4Shell and 807 on Java enterprise software. Attackers sent zero Log4Shell requests to a server that announces it runs PHP.
- The scan tried PHPUnit's
eval-stdin.phpon 17 paths. Attackers tried 41.
The scan may have a separate module for exposed files that my profile didn't have enabled. I don't have the scan configuration to check. But that's the point: a clean scan report tells you what the scan checked, not what attackers check.
2. Side by Side
| Category | Qualys (31 min) | Attackers (18 days) |
|---|---|---|
| Other path probes | 6,200 | 1,510 |
| .env, .git and config files | 170 | 3,307 |
| Home page only | 837 | 1,908 |
| PHP file probes | 1,015 | 590 |
| Other CMS | 517 | 638 |
| Java enterprise (Struts, WebLogic, Spring...) | 807 | 112 |
| Not HTTP / malformed | 148 | 748 |
| PHPUnit eval-stdin | 18 | 430 |
| WordPress | 158 | 270 |
| VPN and edge appliances | 343 | 74 |
| Other POST/PUT | 119 | 279 |
| Path traversal / LFI | 279 | 45 |
| Microsoft (Exchange, SharePoint, IIS) | 241 | 73 |
| IoT and routers | 55 | 126 |
| AI / LLM infrastructure | 27 | 105 |
| PHP2Shell category (multipart POST) | 33 | 83 |
| PHP code injection | 104 | 4 |
| Shell command injection | 85 | 11 |
| PHP-CGI argument injection | 11 | 59 |
| React2Shell | 10 | 58 |
| Log4Shell | 45 | 0 |
| ThinkPHP | 6 | 25 |
| SQL injection | 30 | 0 |
| Apache path traversal RCE | 0 | 29 |
| Open proxy test | 4 | 11 |
| pearcmd LFI | 0 | 11 |
| Laravel Ignition | 0 | 3 |
The top attacker paths the scan never requested:
318 /.env
259 /favicon.ico
112 /wp-includes/version.php
106 /readme.html
104 /license.txt
104 /nope.php
44 /.well-known/security.txt
40 /.env.local
36 /.env.backup
35 /.env.production
34 /.env.prod
33 /.env.dev
30 /api/.env
29 /.env.bak
28 /.env.save
28 /app/.env
28 /config/.env
28 /security.txt
25 /.env.old
24 /.env.example
24 /.git/HEAD
22 /.env.test
22 /laravel/.env
21 /backend/.env
21 /.aws/credentials
And here's how the scanner proves a React2Shell finding without doing harm. It uses the same exploit wrapper the attackers use (see the React2Shell post), with harmless commands:
echo $((191*7))
echo QUALYS_TEST_733480
id
powershell -c "echo QUALYS_TEST_733480"
powershell -c 191*7
A marker, or 191*7 = 1337. The attackers' versions of the same request opened reverse shells and stole environment variables.
3. Pyramid of Pain, Applied to Your Own Scanner
The pyramid works in reverse here. How you recognise your scanner decides how easily an attacker can hide behind it:
| How you allowlist the scanner | How easy it is for an attacker to abuse |
|---|---|
By marker string (QUALYS in the payload) | Trivial. Anyone can type QUALYS into a request. |
| By User-Agent | Trivial. Most of this scan had no User-Agent anyway. |
| By source IP, for web-layer rules only | Hard. They'd need to come from your scanner's address. This is the right level. |
| By source IP, at the EDR layer too | Dangerous. If the scanner ever causes a real shell, you won't see it. Never suppress endpoint rules for scanner traffic. |
4. Detections
For Org B I've parsed the honeypot's nginx log into a WebAccess function. For Org A I've used the CIM Web data model and a lookup of authorised scanners.
let WebAccess = Syslog
| where SyslogMessage startswith "php_http: "
| extend j = parse_json(substring(SyslogMessage, 10))
| project TimeGenerated, DestHost = Computer, SrcIp = tostring(j.client), Method = tostring(j.method), Request = tostring(j.request),
Url = tostring(j.uri), Status = toint(j.status), BytesOut = toint(j.bytes_out),
UserAgent = tostring(j.user_agent), ContentType = tostring(j.content_type), Body = tostring(j.body);
W1. Recognise the authorised scan
Org B Tested: 648 requests carried a QUALYS marker, all from the scanner's address, within its 31-minute window.
WebAccess
| extend Hay = strcat(Request, " ", Body, " ", UserAgent)
| where Hay contains "QUALYS"
| summarize Requests = count(), First = min(TimeGenerated), Last = max(TimeGenerated) by SrcIp
Org A
index=web sourcetype=nginx:access "QUALYS"
| stats count min(_time) as first max(_time) as last by clientip
| convert ctime(first) ctime(last)
Use this once, to confirm the scanner's addresses. Then put those addresses in a Sentinel watchlist (AuthorisedScanners) or a Splunk lookup (authorised_scanners.csv), and exclude them from web-layer rules only.
W2. Scanner markers from the wrong address (T1036)
Org B Tested: zero, correctly. Every marker came from the real scanner.
// Sentinel watchlist "AuthorisedScanners" with columns SearchKey (IP) and Owner
let Scanners = _GetWatchlist("AuthorisedScanners") | project SrcIp = SearchKey;
WebAccess
| extend Hay = strcat(Request, " ", Body, " ", UserAgent)
| where Hay matches regex @"(?i)QUALYS|NESSUS|TENABLE|RAPID7|INSIGHTVM|ACUNETIX|BURP|NUCLEI"
| join kind=leftanti Scanners on SrcIp
| summarize Requests = count(), Markers = make_set(extract(@"(?i)(QUALYS\w*|NESSUS\w*|TENABLE\w*|RAPID7\w*|ACUNETIX\w*|BURP\w*|NUCLEI\w*)", 1, Hay), 10) by SrcIp
Org A
index=web sourcetype=nginx:access
| regex _raw="(?i)QUALYS|NESSUS|TENABLE|RAPID7|INSIGHTVM|ACUNETIX|BURP|NUCLEI"
| lookup authorised_scanners.csv src AS clientip OUTPUT owner
| where isnull(owner)
| rex "(?i)(?<marker>QUALYS\w*|NESSUS\w*|TENABLE\w*|RAPID7\w*|ACUNETIX\w*|BURP\w*|NUCLEI\w*)"
| stats count values(marker) as markers by clientip
Someone sending scanner markers from an address that isn't your scanner is either a rogue scan, a pentester nobody told you about, or an attacker hoping you suppress on markers. All three are worth a conversation. Medium severity.
W3. The coverage gap: what attackers ask that your scanner doesn't
Org B Tested: the top gap was /.env (325 attacker requests from 50 sources), followed by WordPress version files, security.txt, and ten more .env variants.
let Scanner = dynamic(["52.176.19.239"]);
let ScannerPaths = WebAccess | where SrcIp in (Scanner) | distinct Url;
WebAccess
| where SrcIp !in (Scanner) and Status != 200
| summarize AttackerRequests = count(), Sources = dcount(SrcIp) by Url
| join kind=leftanti ScannerPaths on Url
| top 15 by AttackerRequests
Org A
| tstats count dc(Web.src) as sources from datamodel=Web where NOT Web.status=200 by Web.url Web.src
| rename Web.* as *
| lookup authorised_scanners.csv src OUTPUT owner
| eval who=if(isnotnull(owner), "scanner", "attacker")
| stats sum(eval(if(who="attacker",count,0))) as attacker_requests dc(eval(if(who="attacker",src,null()))) as sources
max(eval(if(who="scanner",1,0))) as scanner_tested by url
| where scanner_tested=0
| sort - attacker_requests | head 15
Run it monthly against your own web logs and send the result to whoever owns the scan profile. It's the cheapest purple-team exercise there is, because the attackers write the test cases for you.
5. Using the Scan to Test Your SOC
An authorised scan is a free, scheduled attack simulation. Use it.
V1. Which rules fired during the scan?
Org B
// Which of your rules fired during the authorised scan window? Silence is the finding.
let ScanStart = datetime(2026-10-23 02:18); let ScanEnd = datetime(2026-10-23 02:50);
SecurityAlert
| where TimeGenerated between (ScanStart .. ScanEnd + 15m)
| summarize Alerts = count() by AlertName, ProviderName
| order by Alerts desc
Org A
index=notable earliest="10/23/2026:02:18:00" latest="10/23/2026:03:05:00"
| stats count by search_name urgency
| sort - count
Compare the list against what the scan sent. It tried React2Shell, PHPUnit, Log4Shell, Struts and SQL injection. If your web-exploit rules didn't fire for those (before suppression), they won't fire for an attacker either. Silence is the finding.
E1. Did the scan cause anything on the endpoint?
Org A
index=crowdstrike event_simpleName=ProcessRollup2 earliest="10/23/2026:02:18:00" latest="10/23/2026:03:05:00"
ParentBaseFileName IN ("apache2","httpd","nginx","php","php-fpm*","node","java","w3wp.exe")
NOT FileName IN ("php","php-fpm*","apache2","httpd")
| table _time ComputerName ParentBaseFileName FileName CommandLine
Org B
// During a scan window, any web-server child process means the scan found something real
let ScanStart = datetime(2026-10-23 02:18); let ScanEnd = datetime(2026-10-23 02:50);
DeviceProcessEvents
| where Timestamp between (ScanStart .. ScanEnd + 15m)
| where InitiatingProcessFileName in~ ("apache2","httpd","nginx","php","php-fpm","node","java","w3wp.exe")
| where FileName !in~ ("php","php-fpm","apache2","httpd")
| project Timestamp, DeviceName, InitiatingProcessFileName, FileName, ProcessCommandLine
A scanner's proof-of-concept commands are harmless, but they still run. If echo QUALYS_TEST_733480 appears as a child of your web server, the vulnerability is real and exploitable today, whatever the scan report's severity says. It's also proof that your EDR rule from the RedTail post works.
6. When It Fires
- W2 (markers from the wrong IP): check with your vulnerability-management team and any pentest vendors. If nobody owns it, treat it as hostile recon.
- W3 gaps: raise them with the scan owner. Turn on file-exposure checks, or add custom checks for the top gap paths.
- V1 silence: fix the rule before the next scan, then confirm it fires next time.
- E1 hits: patch that host now. Org A and Org B both: raise it as an incident, not a scan finding. An attacker can reach the same code path.
7. Hardening
- Run authenticated scans plus a file-exposure check, not just the default external profile.
- Scan on a fixed schedule from fixed addresses, and publish both to the SOC.
- Suppress scanner traffic by source IP, at the web layer only. Never suppress at the EDR layer.
- Feed W3's top attacker paths back into the scan profile every month.