Global SOC / Blog
DNS Audit

THREAT RESEARCH & LABS · Yogesh · 12 November 2026

One IP, Many Exploits: Detecting Spray Scanners by How They Behave, Not What They Send

152 sources sent 1,143 exploit requests to my honeypot, and 52 of them tried more than one exploit type. I show how to detect spray kits by behaviour (canary paths, kit fingerprints, slow fingerprinting), then how to turn all that noise into one high-fidelity alert with risk-based correlation in Splunk and Sentinel.

Part of my honeypot detection series. Org A runs Splunk Enterprise Security 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 behaviour KQL ran against the honeypot's real logs. The correlation rules are templates for your environment.

1. What Hit the Server

I counted 15 kinds of exploit in the honeypot data. 1,143 requests tried one of them, from 152 sources. Most sources tried one thing. The rest sprayed:

Exploit types sentSource IPsExploit requests
1100229
233113
313
45120
52150
611528

A spray scanner doesn't ask what it's talking to. It fires its whole list and looks for a response that proves success. Most kits finished in under two minutes.

Every SOC sees this all day, and the usual answer is either to alert on all of it (alert fatigue) or none of it (blind spot). This post is about a third option: detect the behaviour of the kit, cheaply and with no CVE list to maintain, and then only page a human when that behaviour lines up with something on the endpoint.

2. The Attack, Step by Step

Recon Step 1: Calibrate with canary paths

Good scanners first check how your server says "not found". ReconX asked for paths that can't exist:

/__l2s_debug_probe__
/reconx-2bdaef5dde6d
/.git/reconx-599a9650d3d5
/html/.git/reconx-91cffb045283
/old/.git/reconx-abbf32b43304
/.svn/reconx-12d8891a6fc1
/.git.bak/reconx-6735de42a3b1
/backup/.git/reconx-84cfd5238b0a

If /.git/reconx-599a9650d3d5 returns 200, the server answers 200 to everything, and a 200 for /.git/config means nothing. That's how the scanner avoids false positives (T1595.003). For us it's a fingerprint: random-suffix paths only come from tools.

Recon Step 2: Fingerprint slowly

67.205.160[.]10 sent 78 requests over 21 minutes, one every 14 seconds, with no payloads. Just login pages:

12:43:35  /robots.txt
12:44:03  /+CSCOE+/logon.html
12:44:20  /+CSCOT+/oem-customization?app=AnyConnect&type=oem&platform=..&resource-type=..&name=%2BCSCOE%2B/portal_inc.lua
12:44:35  /.env
12:44:48  /.ftpconfig
12:45:01  /.git/config
12:45:16  /.idea/WebServers.xml
12:45:33  /.remote-sync.json
12:45:52  /.vscode/ftp-sync.json
12:46:12  /.vscode/sftp.json
12:46:31  /AHT/AHT_UI/public/js/app.min.js
12:46:52  /CACHE/sdesktop/install/start.htm
12:47:14  /EndUserPortal.jsp
12:47:35  /Guest.aspx
...

Read it as a product list: Cisco ASA and AnyConnect, CrushFTP, Pulse Secure / Ivanti, Fortinet, SolarWinds Orion, SharePoint. One request every 14 seconds stays under almost every rate limit and doesn't look like a scan on a per-minute dashboard (T1595.002, T1592.002). It's the reconnaissance that comes before the next edge-device zero-day.

Exploit Step 3: Spray the kit

Kits run unchanged from many addresses. The RedTail kit came from 11 addresses with identical path sets. A phpMyAdmin hunter calling itself "Go Web Pentest Tool" ran the same 128 paths from 7 addresses. A Laravel kit called SNIPPER ran Ignition, Livewire, Passport and PHPUnit checks, then 143 .env variants, in 68 seconds (T1190).

Exploit Step 4: Check the answer

Each exploit carries a check: an MD5, an arithmetic result like $((63187*52324)), or a marker. Covered in detail in the legacy PHP post.

3. Pyramid of Pain

LevelIndicatorWhat I'd do with it
IP addresses152 sourcesKits run from many disposable addresses. A blocklist is always a step behind.
Network artefactsUser-Agents (Go Web Pentest Tool, ReconX-L2S), canary prefixes (reconx-)Fine for labelling. ReconX rotated its User-Agent mid-run anyway.
ToolsThe kit's exact path set; canary calibration; fixed-interval fingerprintingDetect these. A kit fingerprint survives IP rotation, because the operator rarely edits the list.
TTPsSpray against a host, then a web-server child process on that hostThe only combination worth waking someone for.

4. Behaviour 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. The multi-family burst rule is in the RedTail post. These three add the other behaviours.

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

B1. Canary calibration (T1595.003)

Org B Tested: one hit, ReconX, with 10 canaries among 79 requests in ten minutes.

WebAccess
| where Url matches regex @"/[a-z]{0,10}[-_]?[0-9a-f]{10,16}$" and Status == 404
| summarize Canaries = count(), Sample = take_any(Url) by SrcIp, Window = bin(TimeGenerated, 10m)
| join kind=inner (WebAccess | summarize Requests = count() by SrcIp, Window = bin(TimeGenerated, 10m)) on SrcIp, Window
| where Requests >= 20
| project Window, SrcIp, Canaries, Requests, Sample
| order by Window asc

Org A

| tstats count from datamodel=Web by _time span=10m Web.src Web.url Web.status
| rename Web.* as *
| eval canary=if(status=404 AND match(url, "/[a-z]{0,10}[-_]?[0-9a-f]{10,16}$"), count, 0)
| stats sum(canary) as canaries sum(count) as requests values(eval(if(canary>0,url,null()))) as sample by _time src
| where canaries > 0 AND requests >= 20

Low volume and very precise. The only false positive I'd expect is cache-busting asset names (app-3f9a…e1.js), so exclude your static paths.

B2. Slow edge-device fingerprinting (T1592.002)

Org B Tested: found the 14-second fingerprinter 67.205.160[.]10, and a second address I hadn't spotted, 138.197.223[.]34, with the same User-Agent and the same 16-product list. It also flagged my own authorised scanner, which is the false positive to allowlist.

let EdgeLogin = @"(?i)(\+CSCOE\+|/dana-na/|/remote/login|/global-protect/|/WebInterface/login|/api/v2/cmdb|/Orion/Login|/owa/auth|/vpn/index\.html|/cgi-bin/login|/logon/LogonPoint|/my\.policy|/ui/login|/manage/account/login)";
WebAccess
| where Url matches regex EdgeLogin
| summarize Requests = count(), Products = dcount(Url), Start = min(TimeGenerated), End = max(TimeGenerated) by SrcIp, UserAgent
| where Requests >= 10
| extend Minutes = round(datetime_diff("second", End, Start) / 60.0, 1),
         PerMinute = round(Requests / (datetime_diff("second", End, Start) / 60.0 + 1), 1)
| project SrcIp, UserAgent, Requests, Products, Minutes, PerMinute
| order by Requests desc

Org A

| tstats count min(_time) as start max(_time) as end dc(Web.url) as products from datamodel=Web
    where (Web.url="*+CSCOE+*" OR Web.url="*/dana-na/*" OR Web.url="*/remote/login*" OR Web.url="*/global-protect/*"
        OR Web.url="*/WebInterface/login*" OR Web.url="*/api/v2/cmdb*" OR Web.url="*/Orion/Login*" OR Web.url="*/owa/auth*"
        OR Web.url="*/logon/LogonPoint*" OR Web.url="*/my.policy*")
    by Web.src Web.http_user_agent
| rename Web.* as *
| eval minutes=round((end-start)/60,1), per_minute=round(count/(minutes+1),1)
| where count >= 10

Run this one against your VPN and edge appliances' logs, not only your web servers. Someone listing your edge products at 0.8 requests a minute is doing homework on you.

B3. Same kit, many addresses

Org B Tested: four kits ran from 3 or more addresses. RedTail (48 paths, 11 addresses), the phpMyAdmin hunter (128 paths, 7 addresses), and two smaller ones (3 addresses each).

WebAccess
| where Status != 200 or Url != "/"
| summarize Paths = make_set(Url, 1000), Requests = count() by SrcIp
| where array_length(Paths) >= 10
| extend Kit = hash_sha256(strcat_array(array_sort_asc(Paths), "|"))
| summarize Sources = dcount(SrcIp), SourceList = make_set(SrcIp, 20), PathCount = take_any(array_length(Paths)) by Kit
| where Sources >= 3
| project Sources, PathCount, SourceList
| order by Sources desc

Org A

| tstats values(Web.url) as paths from datamodel=Web where NOT (Web.status=200 Web.url="/") by Web.src
| rename Web.src as src
| where mvcount(paths) >= 10
| eval kit=sha256(mvjoin(mvsort(paths), "|")), path_count=mvcount(paths)
| stats dc(src) as sources values(src) as source_list first(path_count) as path_count by kit
| where sources >= 3

This is a threat-intel rule more than an alert. It turns 21 IPs into 4 named kits. When a kit shows up again from a new address, you already know what it does.

5. Correlation: Making Noise Useful

No single rule above should page a human. What should is a spray against a host followed by the host doing something a web server shouldn't do.

Org B C1. Spray, then a web-server child process on the same host

let Spray = WebAccess
| extend Family = case(
      Request has_any ("allow_url_include","auto_prepend_file"), "php-cgi",
      Request has "eval-stdin.php", "phpunit", Request has "invokefunction", "thinkphp",
      Request has "pearcmd", "pearcmd", Body has "constructor:constructor", "react2shell",
      Body has "PHP_SESSION_UPLOAD_PROGRESS", "php2shell", Request has "/.env", "env", "")
| where isnotempty(Family)
| summarize Families = dcount(Family), SprayStart = min(TimeGenerated) by SrcIp, DestHost, SprayWindow = bin(TimeGenerated, 5m)
| where Families >= 3
| project DestHost, SrcIp, SprayStart;
DeviceProcessEvents
| where Timestamp > ago(1d)
| where InitiatingProcessFileName in~ ("apache2","httpd","nginx","php","php-fpm","node","java","w3wp.exe")
     or InitiatingProcessParentFileName in~ ("apache2","httpd","nginx","php","php-fpm","node","java","w3wp.exe")
| where FileName in~ ("sh","bash","dash","wget","curl","powershell.exe","cmd.exe")
| join kind=inner Spray on $left.DeviceName == $right.DestHost
| where Timestamp between (SprayStart .. SprayStart + 30m)
| summarize Sprayers = make_set(SrcIp, 20), LatestSpray = max(SprayStart)
          by Timestamp, DeviceName, FileName, ProcessCommandLine

Run it as a scheduled analytics rule every 15 minutes, with entity mapping on DeviceName and the sprayer IPs. Sentinel's Fusion engine does something similar automatically for some pairs, but an explicit rule is easier to explain to an auditor.

Org A C1. Risk-based alerting in Enterprise Security

In ES, don't make the spray rules notable events. Give them a Risk Analysis action instead: risk object = the destination host, a score of 10 to 20, and the source IP as the threat object. Do the same for the Falcon process rules from the other posts, with a higher score (60 to 80). Then one risk-incident rule fires when a host collects enough risk from more than one detection:

| from datamodel:"Risk.All_Risk"
| search risk_object_type=system
| stats sum(risk_score) as total_risk dc(source) as detections values(source) as rules
        values(threat_object) as threat_objects by risk_object
| where total_risk >= 100 AND detections >= 2

A spray alone (20) never fires. A spray plus "web server spawned a shell" (20 + 80) does. The analyst gets one incident with the whole story attached.

6. When It Fires

  1. B1 to B3 alone: no action beyond enrichment. Tag the source with the kit name.
  2. B2 against your edge devices: check those products are on the latest firmware this week. You've just been told someone is interested.
  3. C1: the spray landed. Org A Network-contain the host in Falcon. Org B Isolate it in Defender. Then follow the response steps in whichever per-exploit post matches the payload.

7. Hardening

8. IOCs

TypeValueContext
Canary scanner181.215.186[.]252, prefix reconx-, UA ReconX-L2S/1.0Calibration paths
Slow fingerprint67.205.160[.]10, 138.197.223[.]34Edge-device login pages, about 1 per 14 s
Laravel kit31.76.118[.]108, marker SNIPPER_OK_Ignition, Livewire, PHPUnit, then .env
phpMyAdmin hunterUA Go Web Pentest Tool, 128 paths, 7 addressesDatabase admin panels
Arithmetic check152.236.14[.]113, 63187*52324ThinkPHP and PHPUnit