Global SOC / Blog
DNS Audit

THREAT RESEARCH & LABS · Yogesh · 13 November 2026

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

CategoryQualys (31 min)Attackers (18 days)
Other path probes6,2001,510
.env, .git and config files1703,307
Home page only8371,908
PHP file probes1,015590
Other CMS517638
Java enterprise (Struts, WebLogic, Spring...)807112
Not HTTP / malformed148748
PHPUnit eval-stdin18430
WordPress158270
VPN and edge appliances34374
Other POST/PUT119279
Path traversal / LFI27945
Microsoft (Exchange, SharePoint, IIS)24173
IoT and routers55126
AI / LLM infrastructure27105
PHP2Shell category (multipart POST)3383
PHP code injection1044
Shell command injection8511
PHP-CGI argument injection1159
React2Shell1058
Log4Shell450
ThinkPHP625
SQL injection300
Apache path traversal RCE029
Open proxy test411
pearcmd LFI011
Laravel Ignition03

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 scannerHow 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-AgentTrivial. Most of this scan had no User-Agent anyway.
By source IP, for web-layer rules onlyHard. They'd need to come from your scanner's address. This is the right level.
By source IP, at the EDR layer tooDangerous. 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

  1. 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.
  2. W3 gaps: raise them with the scan owner. Turn on file-exposure checks, or add custom checks for the top gap paths.
  3. V1 silence: fix the rule before the next scan, then confirm it fires next time.
  4. 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