Skip to content

Threat Hunt Plan: Moxa Industrial Ethernet Switch TLS Renegotiation Denial-of-Service Exposure

Version 1.0 | 2026-08-25 | Classification: TLP:CLEAR

Hunt Objective and Scope

This hunt looks for evidence that the TLS client-initiated renegotiation weakness in Moxa managed industrial Ethernet switches (CVE-2011-1473, addressed by Moxa security enhancement advisory MPSA-262810, published 19 August 2026) has been probed, abused, or is reachable from a population of hosts that should not be able to reach it. The condition allows an unauthenticated party who can open a TCP session to a TLS-protected management service to force the device to perform repeated handshakes within a single connection, consuming disproportionate CPU on constrained embedded hardware and degrading management-plane availability.

In-scope device population: Moxa EDS-510A Series switches running firmware v3.14 and earlier (fixed in v3.14.4), Moxa ICS-G7826A Series switches running firmware v5.13 and earlier (fixed in v5.13.8), and Moxa SDS Series switches — SDS-3006, SDS-3008, SDS-3010, SDS-3016, SDS-G3006, SDS-G3008, SDS-G3010 and SDS-G3016 — running firmware v3.2 and earlier (fixed in v3.3 or later). In-scope network scope: every segment in which those switches sit, the engineering and operations workstations that legitimately administer them, the jump hosts and DMZ systems that bridge into those segments, and the organization's external attack surface.

Time window: 90 days back from hunt start for network flow and endpoint telemetry, extended to 180 days where the platform retains it, because a low-and-slow renegotiation probe leaves a small enough footprint to sit below routine alerting for months. The external attack-surface leg (Hypothesis 1) is a point-in-time determination corroborated against historical index observations spanning the same window.

Out of scope: exploitation of the switches through any other vulnerability class, firmware validation of the switches themselves, and any active probing of the affected devices. Every technique in this plan is passive with respect to the target devices — no port scanning, banner grabbing, or synthetic TLS handshakes against production control-network infrastructure. Where a determination requires touching a device, it is deferred to a coordinated maintenance window under plant change control.

Success criteria: every in-scope switch is inventoried with its running firmware version; the reachable-source population for each switch management interface is enumerated and compared against the authorized administrative population; any external exposure is confirmed or excluded with two-engine corroboration; and any anomalous TLS session volume, device restart, or management-plane outage in the window is either explained or escalated.

Hypotheses and Hunt Procedures

Hypothesis 1: An external actor can reach an internet-facing instance of a Moxa managed industrial Ethernet switch management interface or an OT protocol served from the same estate, observable as an exposed service in passive internet-scan indices. Execute FIRST; its output scopes the internal hypotheses.

MITRE ATT&CK: Reconnaissance | T1595 Active Scanning — defender-side passive discovery of what an actor would enumerate; Initial Access | T1133 External Remote Services — an exposed management interface is the reachable entry point; ICS | T0883 Internet Accessible Device — an industrial switch answering the internet is a maximum-severity finding on discovery.

Collection Queries — passive external indices (STRICTLY passive; never probe target infrastructure). Author each query unscoped first to prove the filter matches the product, then scoped to your own estate. API credentials are referenced by environment-variable name only (SHODAN_API_KEY, CENSYS_API_SECRET, CENSYS_ORG_ID, NETLAS_API_KEY); a missing key is non-blocking — skip that engine and record the coverage gap.

Shodan — Moxa device web management surface (unscoped first):
product:"Moxa"
http.title:"Moxa"
http.html:"Moxa" port:80,443
ssl.cert.subject.CN:"Moxa"

 

Shodan — scoped to your own estate (append one anchor at a time, then union the results):
product:"Moxa" net:<your_public_CIDR>
http.html:"Moxa" org:"<Your Org Name>"
http.html:"Moxa" asn:AS<your_ASN>

 

Shodan — industrial protocol sweep across the same estate (any hit here is maximum severity):
port:102,502,1911,2404,20000,44818,47808 net:<your_public_CIDR>

 

Shodan — count-only first call (does not consume result credits):
shodan count 'product:"Moxa" asn:AS<your_ASN>'

 

Shodan CLI export for the triage worksheet:
shodan search --fields ip_str,port,org,hostnames,product,version,timestamp 'http.html:"Moxa" net:<your_public_CIDR>'

 

Censys — CenQL (current Platform query language; do NOT mix with legacy services.* form):
host.services.software.vendor: "Moxa"
host.services: (port = "443" and endpoints.http.body: "Moxa")
host.services: (port = "80" and endpoints.http.html_title: "Moxa")
host.services.software.vendor: "Moxa" and (host.autonomous_system.asn = <your_ASN> or host.ip: "<your_public_CIDR>")

 

Netlas — tie-breaker third engine:
http.title:"Moxa"
http.body:"Moxa"
host:<your_public_CIDR> AND port:(80 OR 443 OR 23 OR 161)

 

Cross-reference every exposed service and version banner against the CISA Known Exploited Vulnerabilities catalog (https://www.cisa.gov/known-exploited-vulnerabilities-catalog) and against CVE-2011-1473. CVE-2011-1473 is not currently a KEV entry, so a KEV match on the same host indicates a second, higher-priority condition on the same asset and reprioritizes the finding accordingly.

 

Analysis Queries — attribution, version triage and corroboration:

- Attribute each hit with at least two independent ownership signals — PTR record, ASN registration, TLS certificate CN or SAN, WHOIS/RDAP registrant, and your own authoritative public IP and cloud asset inventory — before reporting it as your exposure. Shared hosting and CDN fronting break attribution in both directions; an unattributable hit is inconclusive, not negative. A provider-announced ASN is not by itself an attribution anchor.
- Version-triage each banner against the affected firmware ranges (EDS-510A at or below v3.14, ICS-G7826A at or below v5.13, SDS Series at or below v3.2) and record the index scan timestamp with every hit. A banner is stale in both directions: an in-range banner is a prompt to verify current state, and a fixed-version banner is not evidence of safety if the scan predates the hunt window.
- Corroborate every candidate in at least two of Shodan, Censys and Netlas before escalating. Absence from an index is evidence only that the index did not observe the host.
- Historical pivot — establish whether the exposure spans the 19 August 2026 advisory publication date. Continuous exposure across that boundary means the device should be treated as presumptively enumerated.
- Pivot into the internal hypotheses — feed every confirmed-owned, in-range instance into Hypotheses 2, 3 and 4 as a priority target and hunt it exhaustively rather than by sampling. Where an exposed switch carries or reaches OT workloads, escalate to the OT protocol analysis below and document the blast radius; internet reachability of infrastructure serving a control environment is a finding in its own right under IEC 62443 and NERC CIP, independent of confirmed exploitation.

 

Favicon-hash pivoting is high yield for stripped banners and non-standard management ports, but the hash is deployment-specific and the engines compute it differently (Shodan MurmurHash3, Censys sha256/md5). Derive it passively from an instance you own by reusing an index-computed hash — never by fetching /favicon.ico from a target, and never by copying a hash from a third-party write-up.

 

Hypothesis 2: An unauthenticated actor has directed repeated TLS handshake or renegotiation traffic at the HTTPS management interface of an in-scope Moxa switch, observable as anomalous session volume and repeated ClientHello records within single TCP streams in network flow telemetry and packet capture.

MITRE ATT&CK: Impact | T1499.002 Endpoint Denial of Service: Service Exhaustion Flood — repeated handshakes exhaust the switch CPU budget; ICS | T0814 Denial of Service — the operational effect is loss of management-plane availability on a control-network device; Discovery | T1046 Network Service Discovery — the same traffic shape is produced by TLS posture scanning, which is the most common benign explanation and must be excluded first.

Collection Queries

CrowdStrike Falcon LogScale (CQL) — endpoints connecting to switch management addresses on 443. Substitute your own OT management supernet for the illustrative 10.20.0.0/16 literal:

#event_simpleName = "NetworkConnectIP4"
| RemotePort = 443
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
| groupBy([ComputerName, aid, RemoteAddressIP4], function=count(as=Connections), limit=max)
| sort(Connections, order=desc, limit=max)

 

CrowdStrike Falcon LogScale (CQL) — full management-port reach across the same supernet, to establish the authorized administrative population before judging any single source anomalous:

#event_simpleName = "NetworkConnectIP4"
| in(RemotePort, values=[22, 23, 80, 443, 161])
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
| groupBy([ComputerName, RemoteAddressIP4, RemotePort], function=count(as=SessionCount), limit=max)
| sort(SessionCount, order=desc, limit=max)

 

BPF packet capture — rolling capture of management-plane TLS at the switch uplink or the SPAN aggregation point. The strftime format in the -w filename is mandatory with -G, otherwise each rotation overwrites the previous file:

tcpdump -i eth0 -s 0 -G 300 -C 100 -w /var/captures/moxa-mgmt-%Y%m%d-%H%M%S.pcap 'tcp port 443 and net 10.20.0.0/16'

 

BPF packet capture — TLS handshake records only, for a low-volume rate baseline (matches TLS content type 0x16 at the first byte of the TCP payload):

tcpdump -i eth0 -n 'tcp port 443 and net 10.20.0.0/16 and (tcp[((tcp[12] & 0xf0) >> 2)] = 0x16)'

 

BPF packet capture — connection-establishment rate toward the management interfaces:

tcpdump -i eth0 -n 'tcp[tcpflags] & tcp-syn != 0 and tcp[tcpflags] & tcp-ack = 0 and dst net 10.20.0.0/16 and dst port 443'

 

Datadog Log Search — Windows endpoint network telemetry, the log-based parallel to the CQL collection queries above:

source:windows @network.destination.port:443 @network.destination.ip:10.20.0.*
// time range: last 90 days
// Analytics: Table view, group by @network.destination.ip, host; time range: last 90 days

 

Datadog Log Search — containerized collector or Linux jump-host parallel, for environments where the management workstations are not Windows:

source:kubernetes @kubernetes.namespace_name:"ot-collector" message:"443"
// time range: last 90 days
// Analytics: Table view, group by @kubernetes.pod_name; time range: last 90 days

 

Datadog Live Process Monitoring (Infrastructure > Processes — NOT a log source and NOT log-search syntax; requires the Datadog Agent with process_config.process_collection.enabled: true):

command:openssl user:root

 

command:python

 

Datadog CloudTrail — cloud-side changes that could have created or widened the exposure found in Hypothesis 1:

source:cloudtrail @evt.name:(AuthorizeSecurityGroupIngress OR ModifyNetworkInterfaceAttribute OR CreateRoute) -@network.client.ip:10.* -@network.client.ip:172.16.* -@network.client.ip:192.168.*
// time range: last 90 days
// Analytics: Table view, group by @network.client.ip, @userIdentity.arn; time range: last 90 days

 

Data source gaps to declare explicitly before running this hypothesis: VPC flow logs are frequently not forwarded for OT-adjacent subnets, DNS query logs are rarely available for management-plane traffic that is addressed by IP, and Live Process Monitoring is commonly not enabled on locked-down engineering workstations. Where any of those hold, the source:windows and source:kubernetes log searches above are the fallback, and the coverage gap must be recorded in the Section 9 report rather than left implicit.

Windows Event IDs to collect on the administrative workstations and jump hosts:

- 4688 — a new process has been created (captures TLS tooling execution; requires command-line auditing to be enabled)
- 5156 — the Windows Filtering Platform has permitted a connection (destination address and port for outbound management-plane sessions)
- 5158 — the Windows Filtering Platform has permitted a bind to a local port
- 4104 — PowerShell script block logging (captures scripted TLS client loops that never spawn a separate process)
- 4625 — an account failed to log on (repeated management-interface authentication attempts from the same source)

 

PowerShell collection of outbound management-plane connections from the WFP log:

Get-WinEvent -FilterHashtable @{LogName='Security'; Id=5156; StartTime=(Get-Date).AddDays(-90)} |
Where-Object { $_.Message -match 'Destination Port:\s+443' -and $_.Message -match 'Destination Address:\s+10\.20\.' } |
Select-Object TimeCreated, MachineName, Message |
Export-Csv -NoTypeInformation .\wfp_5156_moxa_mgmt.csv

 

OT Data Collection: Claroty xDome — in Network > Communication > Communication Analysis, build a three-bucket query with Side A empty (matches every source), Communication set to Port = 443 and Protocol = HTTPS, and Side B set to Device Type = Industrial Network Equipment with Manufacturer = Moxa; set Time Frame to Past Quarter, then export. Cross-check the exported session and byte totals against an independent source — xDome is known to under-report both silently.

OT Data Collection: Claroty CTD — the on-premises platform retains continuous full PCAP, which xDome does not. Pull the packet capture for any flagged conversation through the CTD-only per-event PCAP surface and carry it into the Wireshark analysis below; a CTD deployment is the only Claroty variant that can answer a retrospective packet-level question about this hypothesis.

OT Data Collection: Dragos Platform — in the Communications Hub, filter destination asset to the Moxa switch population and flow protocol to HTTPS over a 30-day window, then pivot each candidate session to its asset record and its event-based PCAP. Use the Assets view first to scope the switch population by vendor and Purdue level, and export a time-bounded PCAP window at the Sensor for any conversation that warrants offline analysis.

OT Data Collection: Nozomi Guardian — query the links table, which is where traffic lives, and join back to nodes on each side to make the result readable:

links | where protocol == "https" | join nodes to ip | join nodes from ip
| select from_ip to_ip joined_node_to_ip.label->to_label joined_node_from_ip.label->from_label
| sort sum(sent.bytes,received.bytes) desc | head 200

 

nodes | where vendor == "Moxa" | select ip label type firmware_version last_activity_time

 

alerts | where time >= days_ago(90) | group_by type_id avg(risk) avg(severity)

 

OT Data Collection: Armis Centrix — run each query in the console with the window set in the UI time-picker (do not embed timeFrame in the query body):

in:ipConnections
serverPort:22,23,80,443,161
endpointA:(networkLocation:"External")

 

in:ipConnections
serverPort:80,443
endpointA:(device:(boundary:"Guest"))

 

in:ipConnections
protocol:HTTPS serverPort:443
orderBy:(bytesCount desc)

 

OT Data Collection: Tenable One OT Exposure — work in Inventory > All Assets filtered to the Moxa switch population and export the selection, then use Risks > Findings to enumerate CVE matches against the running firmware. Programmatic collection uses the GraphQL endpoint (/graphql) — there are no REST /api/v1 query endpoints on this product — with pyTenable as the supported wrapper for repeatable sweeps; note that origins is deprecated in favour of networkAreas as of v4.7.44.

OT Data Collection: Forescout eyeInspect — use the Command Center asset inventory to enumerate the Moxa switch population and the alerts view to pull LAN CP baseline deviations against those assets, filtered by MITRE ATT&CK for ICS technique. Forward alerts and asset data to the SIEM over CEF/syslog for free-text hunting, because eyeInspect itself is filter-driven and has no analyst query language. Run ICS Patrol active enrichment only in scoped, low-cadence mode and never against safety-rated assets without engineering sign-off.

SNMP polling of the switch-facing infrastructure and the affected devices — repeat at 60-second intervals across the hunt window and diff successive values:

snmpwalk -v2c -c <community> <switch_ip> IF-MIB::ifTable

 

snmpget -v2c -c <community> <switch_ip> IF-MIB::ifInOctets.<ifIndex> IF-MIB::ifOutOctets.<ifIndex> IF-MIB::ifInErrors.<ifIndex> IF-MIB::ifOutErrors.<ifIndex>

 

# On high-speed links the 32-bit octet counters wrap — use the 64-bit forms for volumetric baselining
snmpget -v2c -c <community> <switch_ip> IF-MIB::ifHCInOctets.<ifIndex> IF-MIB::ifHCOutOctets.<ifIndex>

 

# Baseline the affected device directly; flag any sysUpTime reset as an unexpected restart
snmpwalk -v2c -c <community> <device_ip> system

 

snmpwalk -v2c -c <community> <device_ip> IF-MIB::ifTable

 

# Prefer SNMPv3 authPriv where the device supports it; provision credentials via snmp.conf rather than inline
snmpwalk -v3 -l authPriv -u <user> -a SHA-256 -A <authpass> -x AES-256 -X <privpass> <device_ip> IF-MIB::ifTable

 

Treat any SNMPv1 or SNMPv2c community-string access to an in-scope OT asset as a finding in its own right — those credentials transit essentially in cleartext, and RFC 3410 recommends v3 authPriv.

YARA file-system scan of the administrative workstations and jump hosts, for staged TLS stress tooling:

yara -r rules/tls_reneg_dos_tooling.yar C:\Users\ >> hits_disk.txt

 

yara -r rules/tls_reneg_dos_tooling.yar /home/ >> hits_disk_linux.txt

 

Analysis Queries

CrowdStrike Falcon LogScale (CQL) — per-minute session rate against each management address; a legitimate administrator produces single-digit sessions per minute, a renegotiation or handshake flood produces orders of magnitude more:

#event_simpleName = "NetworkConnectIP4"
| RemotePort = 443
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
| formatTime(format="%Y-%m-%dT%H:%M", as=MinuteBucket)
| groupBy([ComputerName, RemoteAddressIP4, MinuteBucket], function=count(as=Connections), limit=max)
| Connections > 50
| sort(Connections, order=desc, limit=max)

 

CrowdStrike Falcon LogScale (CQL) — process attribution for the connecting endpoint. NetworkConnectIP4 does not carry ImageFileName or CommandLine, so the connection must be joined back to ProcessRollup2; the join is written in the reverse direction, with ProcessRollup2 as the streaming main query and the tightly filtered connection set as the subquery, so neither the 100k subquery row cap nor the group cap is reached:

#event_simpleName = "ProcessRollup2"
| join({
#event_simpleName = "NetworkConnectIP4"
| RemotePort = 443
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
},
field=[aid, TargetProcessId], key=[aid, ContextProcessId], mode=inner)
| groupBy([ComputerName, UserName, ImageFileName, CommandLine], function=count(as=cnt), limit=max)
| sort(cnt, order=desc, limit=max)

 

Run that join over Last 90d or longer. A long-running monitoring daemon that started before a narrow window emits no ProcessRollup2 inside it, and a 7-day run will return zero matches even while the connections are plainly active.

Wireshark display filters — renegotiation is visible as more than one ClientHello inside a single TCP stream:

tls.handshake.type == 1

 

tls.handshake.type == 1 && ip.dst == 10.20.0.10

 

tls.handshake.extension.type == 65281

 

tcp.port == 443 && tcp.analysis.retransmission

 

tshark CLI equivalents — count ClientHello records per TCP stream; any stream with a count above one indicates renegotiation, and a stream in the hundreds is the abuse pattern this hunt exists to find:

tshark -r moxa-mgmt.pcap -Y "tls.handshake.type == 1" -T fields -e tcp.stream -e ip.src -e ip.dst | sort | uniq -c | sort -rn | head -50

 

tshark -r moxa-mgmt.pcap -Y "tls.handshake.type == 1" -T fields -e frame.time_epoch -e ip.src -e ip.dst -e tcp.stream > clienthello_timeline.tsv

 

tshark -r moxa-mgmt.pcap -q -z conv,tcp | head -60

 

Note that in TLS 1.2 a renegotiation handshake after the first is encrypted, so the second and subsequent ClientHello records may appear only as encrypted handshake records rather than as parsed ClientHellos. Where that is the case, fall back to counting handshake-type records and to the byte-and-duration profile of the stream: a session carrying many small symmetric exchanges with almost no application data is the signature.

Datadog Log Analytics — the same analysis as the CQL rate query above:

source:windows @network.destination.port:443 @network.destination.ip:10.20.0.*
// Use Timeseries view; group by @network.destination.ip; time range: last 90 days
// Use Table view; group by host, @network.destination.ip; time range: last 90 days

 

Datadog Audit Trail — confirm that no monitor, integration or access-management change suppressed the visibility this hunt depends on:

source:datadog @evt.name:"Access Management"
// time range: last 90 days
// Use Table view; group by @asset.type, @action; time range: last 90 days

 

source:datadog @evt.name:Monitor @action:deleted
// time range: last 90 days

 

Datadog Monitor definition for this hypothesis:

Type: Log Alert
Query: source:windows @network.destination.port:443 @network.destination.ip:10.20.0.*
Evaluation window: last 5 minutes
Alert condition: count > 200
Message: "ALERT: sustained HTTPS session volume against OT management addresses — possible TLS renegotiation resource exhaustion against Moxa switch management plane; investigate immediately @ot-soc-slack"
Prerequisites: Windows endpoint logs with network telemetry forwarded to Datadog; OT management supernet substituted for the illustrative 10.20.0.0/16 literal
Create via: Monitors > New Monitor > Log Alert OR POST /api/v1/monitors

 

OT network and protocol analysis — correlate any candidate window against the industrial traffic on the same segment. Where the switch carries EtherNet/IP, Modbus or DNP3, confirm whether control traffic degraded during the same interval:

tshark -r moxa-segment.pcap -Y "cip" -T fields -e frame.time_epoch -e ip.src -e ip.dst -e cip.service | sort | uniq -c | sort -rn | head -40

 

tshark -r moxa-segment.pcap -Y "modbus.func_code" -T fields -e frame.time_epoch -e ip.src -e ip.dst -e modbus.func_code

 

tshark -r moxa-segment.pcap -Y "dnp3" -T fields -e frame.time_epoch -e ip.src -e ip.dst -e dnp3.al.func

 

Correlate the SNMP interface-counter deltas collected above against the same intervals. A CPU-exhaustion event on the switch shows as management-interface unresponsiveness while hardware forwarding counters continue to advance normally — that divergence is the discriminator between a switch under resource pressure and a genuine link or forwarding fault.

Historian and SCADA alarm correlation — pull the alarm and event journal for the process cell served by each candidate switch across the same window, and look for communication-loss, poll-timeout, or watchdog alarms that coincide with the flagged TLS session volume. A network event that produced no process-side alarm is a lower-severity finding than one that did, and the historian is the only source that settles the question.

YARA memory scan of any endpoint surfaced by the process-attribution join above. Classic YARA 4.5 takes the PID as a positional argument — there is no -p flag for process scanning, and YARA-X (yr scan) cannot scan process memory at all:

yara rules/tls_reneg_dos_memory.yar <pid>

 

# Bulk enumeration on Windows: scan every candidate interpreter or network utility process
Get-Process | Where-Object { $_.ProcessName -match 'openssl|python|pwsh|powershell|nmap' } | ForEach-Object { yara rules\tls_reneg_dos_memory.yar $_.Id }

 

CrowdStrike Custom IOAs can be authored to fire on the tooling command lines below, and Falcon Real Time Response can put the YARA binary and rule file on a remote host and execute the scan there, which is the practical route when the candidate endpoint is a plant-floor workstation that cannot be physically reached.

Hypothesis 3: An in-scope Moxa switch has experienced management-plane unresponsiveness, unexpected restart, or control-plane degradation consistent with CPU exhaustion, observable as SNMP trap activity, interface counter anomalies, syslog gaps and OT platform detections without a corresponding change record.

MITRE ATT&CK: ICS | T0816 Device Restart/Shutdown — an unexplained switch restart is the observable outcome of successful resource exhaustion; ICS | T0814 Denial of Service — loss of management availability on control-network infrastructure; Impact | T1499 Endpoint Denial of Service — the enterprise-side equivalent for the same behaviour.

Collection Queries

SNMP trap collection from the trap receiver for the hunt window — filter to the in-scope device address ranges and extract the four trap classes that matter here:

# coldStart — device restarted from a powered-off or reset state
grep -E '1\.3\.6\.1\.6\.3\.1\.1\.5\.1' /var/log/snmptrapd.log > coldstart_traps.txt

 

# warmStart — device reinitialized without a power cycle
grep -E '1\.3\.6\.1\.6\.3\.1\.1\.5\.2' /var/log/snmptrapd.log > warmstart_traps.txt

 

# linkDown / linkUp — port flaps that may accompany control-plane starvation
grep -E '1\.3\.6\.1\.6\.3\.1\.1\.5\.(3|4)' /var/log/snmptrapd.log > linkflap_traps.txt

 

# authenticationFailure — unauthorized access attempts against the OT network interface
grep -E '1\.3\.6\.1\.6\.3\.1\.1\.5\.5' /var/log/snmptrapd.log > authfail_traps.txt

 

SNMP direct polling of the affected devices to establish uptime and detect resets:

snmpget -v2c -c <community> <device_ip> SNMPv2-MIB::sysUpTime.0 SNMPv2-MIB::sysDescr.0 SNMPv2-MIB::sysName.0

 

snmpwalk -v2c -c <community> <device_ip> IF-MIB::ifOperStatus

 

CrowdStrike Falcon LogScale (CQL) — distinct-source concentration per management address per hour. A single management address suddenly reached by many distinct sources, or by one source at very high volume, is the shape worth pulling on:

#event_simpleName = "NetworkConnectIP4"
| RemotePort = 443
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
| formatTime(format="%Y-%m-%dT%H", as=HourBucket)
| groupBy([RemoteAddressIP4, HourBucket], function=count(distinct=true, field=ComputerName, as=DistinctSources), limit=max)
| sort(DistinctSources, order=desc, limit=max)

 

Datadog Log Search — switch syslog forwarded through the SIEM collector:

source:syslog "coldStart" OR "warmStart" OR "system restart"
// time range: last 90 days
// Analytics: Table view, group by host; time range: last 90 days

 

Datadog Log Search — Windows-side view of the monitoring platform losing contact with the switch:

source:windows status:error message:"timeout"
// time range: last 90 days
// Analytics: Timeseries view; group by host; time range: last 90 days

 

Windows Event IDs to collect from the network monitoring server:

- 1 through 3 in the application log of the NMS product — device unreachable and device recovered events (product-specific IDs; enumerate them once and pin them)
- 7031 and 7034 — a service terminated unexpectedly on the monitoring host, which can masquerade as a device outage
- 6008 — the previous system shutdown was unexpected

 

PowerShell collection of unexpected-shutdown and service-failure events on the monitoring infrastructure, so a monitoring-side outage is not mistaken for a switch-side one:

Get-WinEvent -FilterHashtable @{LogName='System'; Id=6008,7031,7034; StartTime=(Get-Date).AddDays(-90)} |
Select-Object TimeCreated, Id, MachineName, Message |
Export-Csv -NoTypeInformation .\nms_outage_events.csv

 

OT Data Collection: Claroty xDome — pull the Alerts surface filtered to Alert Category = Threat Alert and Alert Category = OT Activity Alert, sort by ALERT UPDATED descending, and scan for detections against the Moxa asset population. There is no time-frame selector on this surface; use the API detected_time filter where a hard window is required.

OT Data Collection: Dragos Platform — triage the Notifications queue filtered to ATT&CK for ICS Impact techniques across the switch population, and check the Knowledge Pack version before concluding that an absence of detections is a capability gap rather than a stale pack.

OT Data Collection: Nozomi Guardian — alerts and node liveness for the switch population:

alerts | where time >= days_ago(90) | select id name severity host_ip created | sort created desc | head 200

 

nodes | where vendor == "Moxa" | select ip label last_activity_time sent.bytes received.bytes

 

OT Data Collection: Armis Centrix — off-baseline behaviour and repeated authentication against the in-scope assets:

in:activity type:"Traffic Anomaly Detected"

 

in:alerts type:"Multiple Failed Login Attempts"

 

in:devices boundary:"Unsupervised"

 

OT Data Collection: Tenable One OT Exposure — review the Events view for policy violations and intrusion-detection events against the Moxa population, and use My Saved Views to persist the filter combination across hunt iterations. Tenable's State Query would answer the device-state question directly, but it is an active query and must not be enabled against in-scope devices without staged non-production validation and written engineering sign-off.

OT Data Collection: Forescout eyeInspect — review LAN CP baseline deviations and Industrial Threat Library matches against the Moxa assets, and check whether a learning-window re-baseline coincided with any apparent detection gap.

Analysis Queries

Correlate the SNMP uptime series against the trap log and against the session-volume timeline from Hypothesis 2. The finding shape that matters is a sysUpTime reset or a management-interface outage whose start falls inside a window of elevated TLS session volume from a single source, with no matching entry in the change-management record.

# Diff successive sysUpTime polls to detect a reset that the trap receiver missed
awk '{print $1, $NF}' sysuptime_series.txt | sort -k1,1 | uniq

 

# Cross-reference trap timestamps against the ClientHello timeline from Hypothesis 2
join -1 1 -2 1 <(sort coldstart_traps.txt) <(sort clienthello_timeline.tsv) | head -50

 

Datadog Log Analytics — device restart frequency over the window, and whether it clusters:

source:syslog "coldStart" OR "warmStart"
// Use Timeseries view; group by host; time range: last 90 days
// Use Top List view; group by host; sort descending; time range: last 90 days

 

Datadog Audit Trail — verify no monitor covering these devices was muted or deleted during the window:

source:datadog @evt.name:Monitor
// time range: last 90 days
// Use Table view; group by @action, @asset.name; time range: last 90 days

 

Datadog Monitor definition for this hypothesis:

Type: Log Alert
Query: source:syslog "coldStart" OR "warmStart"
Evaluation window: last 15 minutes
Alert condition: count > 0
Message: "ALERT: unexpected restart reported by an OT network switch — correlate against management-plane session volume and the change record before dispositioning @ot-soc-slack"
Prerequisites: Switch syslog forwarded to Datadog; SNMP trap receiver output ingested as a log source
Create via: Monitors > New Monitor > Log Alert OR POST /api/v1/monitors

 

OT protocol analysis — confirm whether the process traffic on the affected segment degraded in the same interval, which is what turns a management-plane finding into an operational one:

tshark -r moxa-segment.pcap -q -z io,stat,60,"COUNT(cip) cip","COUNT(modbus) modbus","COUNT(dnp3) dnp3"

 

tshark -r moxa-segment.pcap -Y "icmp.type == 3" -T fields -e frame.time_epoch -e ip.src -e ip.dst -e icmp.code

 

Historian correlation — retrieve poll-quality and communication-status tags for the cell served by each candidate switch and overlay them on the restart timeline. Sustained bad-quality intervals aligned to a management-plane event are the operational impact statement the report needs.

YARA memory scan is not applicable to the switch itself, which runs vendor firmware with no analyst-accessible process surface. Where the monitoring server or a jump host is implicated as the traffic source, run the memory rule against its candidate processes as described under Hypothesis 2.

Hypothesis 4: An internal host — an engineering workstation, a jump host, or a contractor laptop — has run TLS posture-scanning or renegotiation stress tooling against control-network infrastructure, observable as tool execution in endpoint process telemetry correlated with connections into the OT management supernet.

MITRE ATT&CK: Discovery | T1046 Network Service Discovery — TLS posture scanning of the management plane; Execution | T1059.001 Command and Scripting Interpreter: PowerShell and T1059.004 Unix Shell — the common delivery vehicles for scripted handshake loops; Impact | T1499.002 Endpoint Denial of Service: Service Exhaustion Flood — the same tooling produces the exhaustion condition whether or not that was the operator's intent.

Collection Queries

CrowdStrike Falcon LogScale (CQL) — TLS assessment and stress tooling by binary name:

#event_simpleName = "ProcessRollup2"
| FileName = /^(openssl|openssl\.exe|nmap|nmap\.exe|sslyze|sslyze\.exe|testssl\.sh|thc-ssl-dos|ncat|ncat\.exe)$/i
| groupBy([ComputerName, UserName, FileName, CommandLine], function=count(as=cnt), limit=max)
| sort(cnt, order=desc, limit=max)

 

CrowdStrike Falcon LogScale (CQL) — the same activity by command-line indicator, which catches the tooling when it has been renamed or invoked through an interpreter:

#event_simpleName = "ProcessRollup2"
| CommandLine = /(legacy_renegotiation|s_client|ssl-enum-ciphers|ssl-dos|renegotiat|sslscan)/i
| groupBy([ComputerName, UserName, ImageFileName, CommandLine], function=count(as=cnt), limit=max)
| sort(cnt, order=desc, limit=max)

 

Datadog Log Search — the log-based parallel for Windows administrative hosts:

source:windows message:"s_client" OR message:"ssl-enum-ciphers" OR message:"legacy_renegotiation"
// time range: last 90 days
// Analytics: Table view, group by host; time range: last 90 days

 

Datadog Log Search — containerized scanner or CI runner parallel:

source:kubernetes message:"testssl" OR message:"sslyze" OR message:"s_client"
// time range: last 90 days
// Analytics: Table view, group by @kubernetes.pod_name, @kubernetes.namespace_name; time range: last 90 days

 

Datadog Live Process Monitoring (Infrastructure > Processes; falls back to the source:windows log search above where the Agent process collection is not enabled):

command:openssl

 

command:nmap

 

Windows Event IDs to collect on candidate hosts:

- 4688 — process creation with the full command line, the primary evidence for this hypothesis
- 4104 — PowerShell script block logging, which captures scripted SslStream handshake loops that never appear as a distinct process
- 4103 — PowerShell module logging, as a secondary corroborating source
- 5156 — Windows Filtering Platform connection permitted, tying the tool execution to the destination it reached

 

PowerShell collection of tool execution from the process-creation log:

Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4688; StartTime=(Get-Date).AddDays(-90)} |
Where-Object { $_.Message -match 'openssl|s_client|testssl|sslyze|ssl-enum-ciphers|renegotiat|thc-ssl-dos' } |
Select-Object TimeCreated, MachineName, Message |
Export-Csv -NoTypeInformation .\tls_tooling_4688.csv

 

PowerShell review of script block content for scripted handshake loops:

Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-PowerShell/Operational'; Id=4104; StartTime=(Get-Date).AddDays(-90)} |
Where-Object { $_.Message -match 'SslStream|AuthenticateAsClient|System\.Net\.Security|ServicePointManager' } |
Select-Object TimeCreated, MachineName, Message |
Export-Csv -NoTypeInformation .\ps_scriptblock_tls.csv

 

OT Data Collection: Claroty xDome — in Communication Analysis set Side A to Device Type = Industrial Workstation, Communication to Port = 443, and Side B to Manufacturer = Moxa over Past Month, to enumerate which engineering workstations reached the management plane at all. For tenant-legacy coverage cite Device Type IN ("Industrial Workstation","Engineering Workstation").

OT Data Collection: Dragos Platform — query the Industrial Protocols QFD and the SSH-sessions QFD for the same host population, and use the Assets view to confirm whether the source host is a sanctioned engineering workstation or an asset that has no business on that segment.

OT Data Collection: Nozomi Guardian — Arc host telemetry, where deployed, captures process execution on OT-locked engineering workstations that cannot run an IT EDR:

nodes | where_link protocol == https | head 200

 

links | where protocol == "https" | join nodes from ip | select from_ip joined_node_from_ip.label->source_label to_ip

 

OT Data Collection: Armis Centrix — enumerate the workstation population reaching the management plane, then left-join against the Secure Remote Access session log where that module is licensed; any flow without a matching SRA entry is out-of-band by construction:

in:ipConnections
serverPort:443
endpointA:(device:(category:"Computers"))

 

OT Data Collection: Tenable One OT Exposure — scope the source-host population using the Eng and OtWorkstation asset types rather than the generic Workstation type, which would miss exactly the hosts that matter here.

OT Data Collection: Forescout eyeInspect — pivot from the LAN CP alert on the workstation to the IT-side EDR record for the same host, which is the cross-domain pattern the CrowdStrike eyeExtend module exists to support.

YARA file-system scan for staged tooling on the candidate hosts:

yara -r rules/tls_reneg_dos_tooling.yar C:\Users\ C:\ProgramData\ C:\Temp\ >> hits_disk.txt

 

yara -r rules/tls_reneg_dos_tooling.yar /home/ /tmp/ /opt/ >> hits_disk_linux.txt

 

Analysis Queries

CrowdStrike Falcon LogScale (CQL) — tie the tooling execution to a connection into the OT management supernet, which is what separates a laptop-local posture test from an action against production control infrastructure:

#event_simpleName = "ProcessRollup2"
| CommandLine = /(legacy_renegotiation|s_client|ssl-enum-ciphers|ssl-dos|renegotiat|sslscan)/i
| join({
#event_simpleName = "NetworkConnectIP4"
| cidr(RemoteAddressIP4, subnet=["10.20.0.0/16"])
},
field=[aid, TargetProcessId], key=[aid, ContextProcessId], mode=inner)
| groupBy([ComputerName, UserName, ImageFileName, CommandLine], function=count(as=cnt), limit=max)
| sort(cnt, order=desc, limit=max)

 

CrowdStrike Falcon LogScale (CQL) — scripted TLS clients invoked through PowerShell, which produce no distinctive binary name:

#event_simpleName = "ProcessRollup2"
| FileName = /^(powershell\.exe|pwsh\.exe)$/i
| CommandLine = /(SslStream|AuthenticateAsClient|System\.Net\.Security)/i
| groupBy([ComputerName, UserName, CommandLine], function=count(as=cnt), limit=max)
| sort(cnt, order=desc, limit=max)

 

Datadog Log Analytics — rarity analysis over the tooling population; the rarest command lines are the ones worth reading:

source:windows message:"s_client" OR message:"ssl-enum-ciphers"
// Use Top List view; group by host; sort ascending for rarest-first; time range: last 90 days
// Equivalent to CQL: groupBy([ComputerName], function=count()) | sort(_count, order=asc, limit=50)

 

Datadog Audit Trail — where the tooling was run from a Datadog-integrated CI or automation host, confirm which identity triggered it:

source:datadog @evt.name:"API Request"
// time range: last 90 days
// Use Table view; group by @usr.email, @asset.type; time range: last 90 days

 

Datadog Monitor definition for this hypothesis:

Type: Log Alert
Query: source:windows message:"legacy_renegotiation" OR message:"thc-ssl-dos" OR message:"ssl-enum-ciphers"
Evaluation window: last 5 minutes
Alert condition: count > 0
Message: "ALERT: TLS renegotiation or posture-scanning tooling executed on a host with control-network reach — confirm the change record before dispositioning @ot-soc-slack"
Prerequisites: Windows Security log with command-line auditing (4688) and PowerShell script block logging (4104) forwarded to Datadog
Create via: Monitors > New Monitor > Log Alert OR POST /api/v1/monitors

 

Windows Event Log analysis — reconstruct the operator session around any hit, and establish whether the account, the host and the time align with an approved assessment window:

Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4624,4634,4688; StartTime=(Get-Date).AddDays(-90)} |
Where-Object { $_.MachineName -eq 'ENGWS-01' } |
Sort-Object TimeCreated |
Select-Object TimeCreated, Id, Message |
Export-Csv -NoTypeInformation .\engws01_session_timeline.csv

 

YARA memory scan of the implicated processes, run through Falcon Real Time Response where the host cannot be reached physically:

yara rules/tls_reneg_dos_memory.yar <pid>

 

Get-Process | Where-Object { $_.ProcessName -match 'openssl|python|pwsh|powershell|nmap|ncat' } | ForEach-Object { yara rules\tls_reneg_dos_memory.yar $_.Id }

 

Threat Actor Profile

Opportunistic internet-wide scanner — low sophistication, high volume. Access path: direct TCP connection to any management interface reachable from the internet, discovered through the same passive indices used in Hypothesis 1. TTPs: mass TLS posture enumeration, version banner collection, and occasional automated exploitation of whatever the banner reveals. This is the most probable actor class to interact with an exposed Moxa management interface, and the interaction is far more likely to be enumeration than deliberate exhaustion. It matters because enumeration precedes targeting, and because the same exposure that permits enumeration permits the denial-of-service condition.

Commodity ransomware and initial-access broker — moderate sophistication. Access path: internet-exposed edge and management services, then credential reuse and lateral movement toward higher-value systems. TTPs: T1133 External Remote Services, T1190 Exploit Public-Facing Application, followed by enterprise-standard tooling. An industrial switch is not a target of value to this class in itself, but an exposed switch management interface is a strong indicator that the surrounding segmentation posture will yield something that is, and it can serve as a persistence foothold on a device that no endpoint tool watches.

OT-focused state-aligned actor — high sophistication. Access path: patient reconnaissance of the external surface, compromise of an IT-side pivot, then lateral movement to the control network. TTPs: living-off-the-land movement toward engineering workstations, enumeration of control-network infrastructure, and staging of capability against availability rather than immediate use of it. For this actor class the value of the renegotiation condition is not the outage itself but the option to create one at a chosen moment — a management-plane blackout during a concurrent physical or cyber action degrades exactly the visibility responders need. The absence of confirmed exploitation of CVE-2011-1473 in the wild does not reduce this consideration, because the technique requires no tooling development and leaves little distinctive evidence.

Insider and authorized-but-unsanctioned activity — variable sophistication, high access. Access path: legitimate credentials and legitimate network position. TTPs: running assessment tooling outside an approved window, contractor laptops brought onto the control network with a security-testing toolchain installed, and vulnerability-scanner configurations that include aggressive TLS checks pointed at OT ranges. This is the single most likely explanation for any hit that Hypothesis 4 produces, and it must be excluded through the change record before any escalation is raised.

Data Sources Required

Network — full packet capture or SPAN at the OT management aggregation point and at the IT/OT boundary; NetFlow or IPFIX from the routed boundary; firewall session and deny logs for every rule governing access to the management supernet; and the switch configuration backups needed to establish which management services are enabled on each device.

Endpoint — CrowdStrike Falcon telemetry (ProcessRollup2 and SyntheticProcessRollup2, NetworkConnectIP4, UserLogon) from every workstation and jump host with control-network reach; Windows Security and PowerShell Operational event logs (4688, 4104, 4103, 5156, 5158, 4624, 4625, 4634) with command-line auditing and script block logging enabled; Sysmon where deployed; and Datadog Agent logs and Live Process Monitoring where the environment supports it.

OT and ICS — process historian tag history and alarm journal for the cells served by the in-scope switches; SCADA and HMI event logs; the SNMP trap receiver log and interface counter polling series described in Hypothesis 2; and the OT monitoring platform in use, which will be one or more of Claroty xDome or CTD, Dragos Platform, Nozomi Guardian and Vantage, Armis Centrix, Tenable One OT Exposure, and Forescout eyeInspect. Note the platform-specific constraints that bear on this hunt: Armis Centrix forwards metadata only and cannot supply packet capture, so any packet-level question must be answered from a SPAN or TAP feed or from a capture-capable platform; xDome does not retain continuous PCAP while CTD does; and Tenable's device-state active query must not be enabled against in-scope devices without staged validation and written engineering sign-off.

Vendor and device logs — switch syslog forwarded to the SIEM, switch authentication and configuration-change logs, RADIUS or TACACS+ accounting for management-plane authentication, and the firmware inventory export that establishes which devices are in the affected version range.

External attack surface — the passive internet-scan indices queried read-only (Shodan, Censys, Netlas), the CISA Known Exploited Vulnerabilities catalog, and the organization's authoritative public IP allocation and cloud asset inventory. That last source is required: without it, attribution of an index hit to the organization cannot be made, and the exposure determination cannot be completed. Absence of a host from an index is evidence only that the index did not observe it.

Change and process records — the change-management ticket queue, the approved maintenance window schedule, the authorized administrator roster for the switch management plane, and the vulnerability-scanning schedule and target scope. These are what convert a technical observation into a disposition, and a hunt that cannot reach them will produce findings it cannot close.

Detection Signatures

SIGMA rule 1 — TLS renegotiation and posture-stress tooling execution (process_creation):

title: TLS Renegotiation or Posture Stress Tooling Execution
id: 8f3b2c14-6d5a-4e79-9b02-1a7c4e8d5f36
status: experimental
description: Detects execution of TLS assessment or renegotiation stress tooling, which produces the client-initiated renegotiation traffic pattern described in CVE-2011-1473 and can exhaust CPU on embedded industrial network devices.
references:
- https://www.moxa.com/en/support/product-support/security-advisory/mpsa-262810-security-enhancement-tls-client-initiated-renegotiation
- https://nvd.nist.gov/vuln/detail/CVE-2011-1473
author: 1898 & Co.
date: 2026/08/25
tags:
- attack.discovery
- attack.t1046
- attack.impact
- attack.t1499.002
logsource:
category: process_creation
detection:
selection_image:
Image|endswith:
- '\openssl.exe'
- '\nmap.exe'
- '\sslyze.exe'
- '\ncat.exe'
selection_cmdline:
CommandLine|contains:
- 'legacy_renegotiation'
- 's_client'
- 'ssl-enum-ciphers'
- 'thc-ssl-dos'
- 'testssl'
- 'sslscan'
condition: selection_image or selection_cmdline
falsepositives:
- Scheduled vulnerability scanning from an authorized scanner host
- Certificate validation scripting run by the PKI team
- Developer or engineer testing a TLS endpoint during a sanctioned change window
level: medium

 

SIGMA rule 2 — repeated management-plane TLS connections toward OT network equipment (network_connection):

title: Repeated TLS Connections to OT Network Equipment Management Interface
id: 2b7e91d4-3c68-4a15-8e0f-6d92a4b3c7e8
status: experimental
description: Detects a host establishing repeated outbound TLS connections to the management interface address range of OT network equipment, the network-side signature of the CVE-2011-1473 renegotiation exhaustion pattern and of TLS posture scanning against control-network infrastructure.
references:
- https://www.moxa.com/en/support/product-support/security-advisory/mpsa-262810-security-enhancement-tls-client-initiated-renegotiation
author: 1898 & Co.
date: 2026/08/25
tags:
- attack.impact
- attack.t1499.002
logsource:
category: network_connection
product: windows
detection:
selection:
DestinationPort: 443
DestinationIp|cidr:
- '10.20.0.0/16'
filter_authorized:
Image|endswith:
- '\chrome.exe'
- '\msedge.exe'
- '\firefox.exe'
condition: selection and not filter_authorized
falsepositives:
- Network management platform polling the switch web interface on a schedule
- Configuration backup automation retrieving the running configuration over HTTPS
- Browser-based administration from an authorized engineering workstation
level: medium

 

SIGMA rule 3 — scripted TLS client handshake loop in PowerShell (ps_script):

title: PowerShell Scripted TLS Handshake Loop Against Internal Host
id: c4d18a7e-5f92-4b36-a0c7-3e8b1d6f9a25
status: experimental
description: Detects PowerShell script block content that constructs a raw TLS client and repeatedly authenticates, the scripted equivalent of the renegotiation flood described in CVE-2011-1473. This form leaves no distinctive process name and is invisible to image-based detection.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2011-1473
author: 1898 & Co.
date: 2026/08/25
tags:
- attack.execution
- attack.t1059.001
- attack.impact
- attack.t1499.002
logsource:
product: windows
category: ps_script
detection:
selection_tls:
ScriptBlockText|contains:
- 'SslStream'
- 'AuthenticateAsClient'
- 'System.Net.Security'
selection_loop:
ScriptBlockText|contains:
- 'while'
- 'for ('
- 'foreach'
condition: selection_tls and selection_loop
falsepositives:
- Certificate inventory scripts that enumerate endpoints in a loop
- Monitoring scripts that test TLS endpoint availability on a schedule
level: medium

 

SIGMA rule 4 — unexpected industrial switch restart reported to the collector (file_event on the trap receiver spool, as a portable proxy for syslog ingestion):

title: Industrial Network Switch Cold or Warm Start Trap Recorded
id: 6a2f5b83-9e71-4c04-b58d-2f7a3c9e14b6
status: experimental
description: Detects the trap receiver writing a coldStart or warmStart record for an in-scope industrial switch, the observable outcome of a device restart that may follow management-plane resource exhaustion.
references:
- https://www.moxa.com/en/support/product-support/security-advisory/mpsa-262810-security-enhancement-tls-client-initiated-renegotiation
author: 1898 & Co.
date: 2026/08/25
tags:
- attack.impact
- attack.t1499
logsource:
category: file_event
detection:
selection:
TargetFilename|contains:
- 'coldstart_traps'
- 'warmstart_traps'
condition: selection
falsepositives:
- Scheduled firmware upgrade or planned power work inside an approved maintenance window
- Site power event affecting multiple devices simultaneously
level: low

 

Snort/Suricata rule 1 — excessive TLS ClientHello records toward the OT management range. The detection_filter fires only after the threshold is crossed within the window, which is what separates renegotiation abuse from ordinary administration:

alert tcp any any -> 10.20.0.0/16 443 (msg:"OT-MGMT TLS ClientHello flood toward industrial switch management interface - possible CVE-2011-1473 renegotiation exhaustion"; flow:to_server,established; content:"|16 03|"; depth:2; content:"|01|"; distance:3; within:1; detection_filter:track by_src, count 30, seconds 60; classtype:attempted-dos; reference:cve,2011-1473; reference:url,www.moxa.com/en/support/product-support/security-advisory/mpsa-262810-security-enhancement-tls-client-initiated-renegotiation; sid:1000001; rev:1;)

 

Snort/Suricata rule 2 — TLS handshake initiated by a client that advertises no RFC 5746 renegotiation_info extension, toward the same range. Legacy renegotiation support is the precondition for the condition this hunt targets, and a client deliberately negotiating without the extension is worth surfacing on its own:

alert tcp any any -> 10.20.0.0/16 443 (msg:"OT-MGMT TLS ClientHello without RFC 5746 renegotiation_info extension toward industrial switch"; flow:to_server,established; content:"|16 03|"; depth:2; content:"|01|"; distance:3; within:1; content:!"|ff 01|"; threshold:type limit, track by_src, count 1, seconds 300; classtype:protocol-command-decode; reference:cve,2011-1473; sid:1000002; rev:1;)

 

Snort/Suricata rule 3 — sustained connection establishment toward the switch management plane, a lower-fidelity but protocol-independent backstop that fires even when the TLS payload is not parseable:

alert tcp any any -> 10.20.0.0/16 443 (msg:"OT-MGMT sustained TCP connection rate toward industrial switch management interface"; flags:S; detection_filter:track by_src, count 100, seconds 60; classtype:attempted-dos; reference:cve,2011-1473; sid:1000003; rev:1;)

 

YARA rule 1 — file and disk artifacts. This rule targets the staging phase: TLS stress and posture tooling written to disk on a host that has control-network reach. The condition requires either a strong single-tool indicator or two weaker generic indicators, because strings like "s_client" and "renegotiation" appear legitimately in OpenSSL documentation, certificate management scripts and vendor support bundles. The file-size ceiling excludes large vendor archives and documentation sets, which are the dominant false-positive source when the rule is run recursively across a user profile.

rule TLS_Renegotiation_DoS_Tooling_Disk
{
meta:
description = "Detects TLS renegotiation stress and posture-scanning tooling staged on disk, associated with the CVE-2011-1473 client-initiated renegotiation exhaustion pattern against embedded industrial network devices"
author = "1898 & Co."
date = "2026-08-25"
reference = "https://nvd.nist.gov/vuln/detail/CVE-2011-1473"
reference2 = "https://www.moxa.com/en/support/product-support/security-advisory/mpsa-262810-security-enhancement-tls-client-initiated-renegotiation"
strings:
// Purpose-built TLS renegotiation denial-of-service tool - single strong indicator
$tool1 = "thc-ssl-dos" ascii wide nocase
$tool2 = "THC-SSL-DOS" ascii wide
// Public renegotiation flood proof-of-concept naming conventions
$tool3 = "ssl_reneg" ascii wide nocase
$tool4 = "renegotiation_flood" ascii wide nocase
// OpenSSL client invocation strings used to drive manual renegotiation
$generic1 = "s_client" ascii wide
$generic2 = "-legacy_renegotiation" ascii wide
$generic3 = "SSL_renegotiate" ascii
// Scripted loop harness indicators around a TLS client
$generic4 = "AuthenticateAsClient" ascii wide
$generic5 = "ssl-enum-ciphers" ascii wide
// Target-selection strings tying the tooling to industrial network equipment
$target1 = "EDS-510A" ascii wide nocase
$target2 = "ICS-G7826A" ascii wide nocase
$target3 = "SDS-G30" ascii wide nocase
condition:
filesize < 20MB and
(
any of ($tool*) or
( 2 of ($generic*) ) or
( any of ($generic*) and any of ($target*) )
)
}

 

YARA rule 2 — process memory artifacts. This rule targets the execution phase rather than the staging phase, and exists because the tooling is frequently run from a removable volume, a network share, or an interpreter that leaves nothing durable on local disk. The condition is deliberately stricter than the disk rule: it requires a TLS-client API indicator together with either an explicit renegotiation string or a loop-construct indicator, because a bare "s_client" string is present in the memory of any process that has merely loaded the OpenSSL library. The private string block holds the industrial-target indicators so a memory hit that also names an in-scope device family is separable in triage.

rule TLS_Renegotiation_DoS_Memory_Artifacts
{
meta:
description = "Detects in-memory artifacts of an active TLS renegotiation flood or TLS posture-stress client, for live-process scanning on hosts with control-network reach"
author = "1898 & Co."
date = "2026-08-25"
reference = "https://nvd.nist.gov/vuln/detail/CVE-2011-1473"
scan_note = "Classic YARA 4.5 only - pass the PID as a positional argument. YARA-X yr scan cannot scan process memory."
strings:
// TLS client API surfaces present in the address space of an active handshake driver
$api1 = "SSL_do_handshake" ascii
$api2 = "SSL_renegotiate" ascii
$api3 = "SSL_renegotiate_pending" ascii
$api4 = "AuthenticateAsClient" ascii wide
$api5 = "SSL_connect" ascii
// Explicit renegotiation intent, as opposed to an incidental library load
$reneg1 = "legacy_renegotiation" ascii wide
$reneg2 = "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION" ascii
$reneg3 = "client_renegotiation" ascii wide nocase
// Loop harness resident in the same address space
$loop1 = "while(1)" ascii
$loop2 = "for(;;)" ascii
$loop3 = "Start-Sleep" ascii wide
// In-scope device identifiers, present when the tooling was aimed deliberately
$target1 = "EDS-510A" ascii wide nocase
$target2 = "ICS-G7826A" ascii wide nocase
$target3 = "SDS-G30" ascii wide nocase
condition:
( 1 of ($api*) and 1 of ($reneg*) ) or
( 2 of ($api*) and 1 of ($loop*) ) or
( 1 of ($api*) and 1 of ($target*) )
}

 

Indicators of Compromise

Network indicators — more than one TLS ClientHello record inside a single TCP stream toward a switch management address, and any stream carrying tens or hundreds of them; sustained TCP connection establishment toward port 443 on the management supernet from a source that is not on the authorized administrator roster; TLS sessions to the management plane whose byte profile is dominated by handshake exchange with almost no application data; connections to switch management ports (22, 23, 80, 443, 161) originating from a guest network, a contractor VLAN, or any external network location; and management-plane traffic from a host that appears in no change record for the interval.

Host indicators — execution of openssl with an s_client or legacy_renegotiation argument, nmap with ssl-enum-ciphers, sslyze, sslscan, testssl.sh, or thc-ssl-dos on any host with control-network reach; PowerShell script block content constructing an SslStream and calling AuthenticateAsClient inside a loop; TLS assessment tooling present in a user profile, a temporary directory, or on removable media on an engineering workstation; and a YARA hit on either rule defined in Section 5.

OT and operational indicators — a sysUpTime reset on an in-scope switch with no corresponding change record; coldStart or warmStart traps from the switch population outside an approved maintenance window; management-interface unresponsiveness while hardware forwarding counters continue to advance normally, which is the discriminating signature of CPU exhaustion as against a link or forwarding fault; authenticationFailure traps clustering on a single device; SCADA poll-timeout, communication-loss or bad-quality alarms in a cell whose serving switch showed elevated management-plane session volume in the same interval; and OT monitoring platform detections mapping to ATT&CK for ICS T0814 or T0816 against the switch population.

External exposure indicators — any Moxa management interface, any switch web administration surface, or any OT protocol port answering from an IP address attributable to the organization, corroborated in at least two passive indices; a version banner in the affected firmware ranges; continuous observation of the exposure spanning the 19 August 2026 advisory publication date, which means the device should be treated as presumptively enumerated; and a CISA KEV match against any other service on the same host, which reprioritizes the finding upward independent of this advisory.

False Positive Baseline

1. Network management platform polling. NMS products poll switch web and SNMP interfaces on a fixed schedule, producing a steady, highly periodic session count from a small number of known source addresses. Suppress by source host and confirm the cadence is regular; an abrupt rate change from an NMS source is itself worth reading, so suppress the baseline rate rather than the source outright.

2. Scheduled vulnerability scanning. Authorized scanners routinely include aggressive TLS cipher and renegotiation checks, and a scan window will produce exactly the ClientHello concentration this hunt looks for. Correlate every candidate window against the scanning schedule and the scanner source addresses before escalating. Note that a scanner configuration that includes OT ranges is a finding of its own if OT was meant to be excluded from the scan scope.

3. Configuration backup automation. Many environments retrieve switch running configurations over HTTPS on a nightly or weekly cycle. These sessions are short, periodic, and originate from a single automation host; suppress by source and schedule, and verify the retrieved configuration size is stable — a change in that profile can indicate the automation account being used for something else.

4. Browser-based administration. An engineer working in the switch web interface generates a burst of TLS sessions as the UI loads assets and polls status, which can look like a rate anomaly at minute granularity. Suppress by correlating the source host against the authorized administrator roster and the session against an interactive logon on the same host at the same time.

5. Certificate lifecycle tooling. PKI inventory and certificate expiry monitoring scripts connect to every TLS endpoint in an estate on a schedule and are a routine source of s_client and SslStream indicators. Suppress by identifying the tooling host and the recurring cadence; verify that the scope of the tooling was meant to include OT ranges.

6. Site power events and planned maintenance. A power interruption or a scheduled firmware upgrade produces coldStart traps across multiple devices simultaneously. The discriminator is simultaneity and breadth: a genuine resource-exhaustion restart affects one device, while a power event affects everything on the same feed. Check the maintenance calendar and the facility power record before treating a restart cluster as a security finding.

7. External attack-surface misattribution. Shared hosting, CDN fronting, cloud provider address reassignment, and a provider-announced ASN all produce index hits that are not the organization's asset. A hit that cannot be attributed with two independent ownership signals is inconclusive, not a finding — and equally, it must not be recorded as a clean negative. Internet-facing honeypots are heavily deployed against OT protocols specifically; down-weight any hit carrying a honeypot classification or a Conpot fingerprint and never report it as client exposure.

Escalation Criteria

1. Any in-scope Moxa switch management interface is confirmed reachable from the internet in two independent passive indices, with an ownership attribution supported by at least two signals. Engage incident response and initiate exposure removal in parallel; do not wait for evidence of exploitation.

2. Confirmed external exposure whose observation window spans the 19 August 2026 advisory publication date. Treat the device as presumptively enumerated and expand the internal hunt on that device from sampling to an exhaustive pass across the full retention window.

3. A CISA KEV-listed service is found on the same host or the same public address as an exposed switch management interface. Escalate on the KEV entry immediately; it carries a presumptive ransomware and actor-associated initial-access risk independent of this advisory.

4. More than one TLS ClientHello record is observed inside a single TCP stream toward a switch management address, from a source outside the authorized administrator roster, and the activity does not correlate to a scheduled scan or an approved change.

5. Management-plane session volume against a single switch exceeds the established baseline by an order of magnitude for a sustained interval, from a single source, with no change record covering the window.

6. A sysUpTime reset, coldStart trap, or warmStart trap is recorded on an in-scope switch outside an approved maintenance window, and it is not explained by a site power event affecting other devices on the same feed.

7. Management-interface unresponsiveness is observed on an in-scope switch while its hardware forwarding counters continue to advance normally, in a window that also carries elevated management-plane TLS session volume.

8. SCADA or historian records show poll timeouts, communication-loss alarms, or sustained bad-quality intervals in a cell whose serving switch appears in any of the criteria above. This converts a management-plane finding into an operational impact finding and raises the response tier accordingly.

9. Any YARA hit on TLS_Renegotiation_DoS_Tooling_Disk against a file staged on an engineering workstation, a jump host, or any system with control-network reach, where the file is not accounted for by an approved assessment engagement.

10. Any YARA hit on TLS_Renegotiation_DoS_Memory_Artifacts against a live process on a host with control-network reach. A memory hit indicates active execution rather than staging and warrants immediate host containment consideration.

11. TLS renegotiation or posture-stress tooling execution correlates in time with a connection into the OT management supernet from the same host, and the operator, the host, or the window is not covered by an approved change record.

12. Any inbound connection to a switch management port from an external network location, a guest network, or a contractor VLAN, regardless of volume or apparent intent.

13. Discovery that an in-scope switch is reachable from a broad internal population — an entire user VLAN, the general enterprise network, or any segment not intended to carry management traffic. This is a segmentation finding that stands independently of whether the renegotiation condition was ever exercised.

Hunt Completion Criteria and Reporting

The hunt is complete when every in-scope Moxa switch has been inventoried with its running firmware version and classified as in-range or fixed; when the reachable-source population for each management interface has been enumerated from network telemetry and compared against the authorized administrator roster; when the external exposure determination has been made with two-engine corroboration and per-hit attribution, or the coverage gap has been stated where an engine could not be queried; when every anomalous TLS session concentration, device restart, and management-plane outage inside the window has been either explained against the change record or escalated; and when every YARA and tooling hit has been dispositioned against the approved-assessment record.

The report must contain: the full in-scope device inventory with firmware versions and remediation status against the fixed releases (v3.14.4 for EDS-510A, v5.13.8 for ICS-G7826A, v3.3 or later for SDS Series); the enumerated reachable-source population per management interface, with the delta against the authorized roster called out explicitly; the external attack-surface sweep result stated as coverage as well as findings — which engines were queried, which were skipped for a missing credential, what was searched and what could therefore not be concluded — with per-hit provenance recorded as engine, query, index scan timestamp and the attribution signals used; every anomaly examined with its disposition and the evidence behind it; the queries actually run per platform, with their time windows, so a subsequent iteration can reproduce or extend the pass; and an explicit statement of the data-source gaps encountered, because a hunt that ran without VPC flow logs, without command-line auditing, or without Live Process Monitoring has a materially different negative than one that ran with them.

The report must also carry the segmentation and compliance findings this hunt produces as a by-product, independent of whether any malicious activity was found: which management interfaces are reachable from populations that should not reach them, which devices remain on affected firmware after the evaluation window, and the documented decision for each device that will not be updated immediately. Under NERC CIP-007-6 R2 that documented evaluation — applied, mitigated with a dated plan, or assessed as not applicable within thirty-five days of patch availability — is itself the compliance artifact, and it is as important to the audit outcome as the update.

Recommend making the external attack-surface sweep a recurring control rather than a one-time pass. Exposure is created by ordinary change — a firewall rule added under time pressure, a cloud route modified, a device relocated — and a point-in-time clean result decays from the day it is taken. Recommend the same for the management-plane reachable-source enumeration, which is the internal counterpart and decays for the same reasons.

Advisory IoC Reference

IOC Type IOC
CVE CVE-2011-1473 | CVSS v2.0 5.0 (AV:N/AC:L/Au:N/C:N/I:N/A:P) | Moxa EDS-510A firmware v3.14 and earlier (fixed v3.14.4) | SSL/TLS implementations fail to restrict client-initiated renegotiation, allowing unauthenticated CPU exhaustion via repeated handshakes in one connection; NVD records the entry as DISPUTED and has not published CVSS v3.1 or v4.0.
CVE CVE-2011-1473 | CVSS v2.0 5.0 | Moxa ICS-G7826A firmware v5.13 and earlier (fixed v5.13.8) | Same TLS renegotiation condition on the modular managed switch family; availability impact only, no confidentiality or integrity impact.
CVE CVE-2011-1473 | CVSS v2.0 5.0 | Moxa SDS-3006/3008/3010/3016 and SDS-G3006/G3008/G3010/G3016 firmware v3.2 and earlier (fixed v3.3 or later) | Same condition on the SDS smart switch family; Moxa assesses exploitability as low in a segmented architecture.
Threat Actor None attributed — no named group, APT cluster or campaign is associated with exploitation of CVE-2011-1473 against Moxa devices; the plausible actor classes are opportunistic internet scanners, commodity initial-access brokers, OT-focused state-aligned actors staging availability options, and unsanctioned internal assessment activity.
Malware None published in source material — no malware family, implant or tooling package is attributed to this condition. The relevant tooling is legitimate TLS assessment software (openssl s_client, nmap ssl-enum-ciphers, sslyze, sslscan, testssl.sh) and the public thc-ssl-dos proof of concept.
Network IOC None published in source material — Moxa published no IP addresses, domains or C2 infrastructure. Monitor https://www.cisa.gov/known-exploited-vulnerabilities-catalog and https://www.cisa.gov/news-events/cybersecurity-advisories for indicators should exploitation be observed.
File IOC None published in source material — no file hashes, filenames or paths were published by the vendor. The YARA rules in Section 5 are behavioural and string-based rather than hash-based for this reason.
Behavioral More than one TLS ClientHello record observed inside a single TCP stream toward a switch management address.
Behavioral Sustained TCP connection establishment to port 443 on the OT management supernet from a source outside the authorized administrator roster.
Behavioral TLS session to a management interface whose byte profile is dominated by handshake exchange with negligible application data.
Behavioral Inbound connection to switch management ports 22, 23, 80, 443 or 161 from an external network location, a guest network, or a contractor VLAN.
Behavioral Execution of openssl with s_client or -legacy_renegotiation, nmap with ssl-enum-ciphers, sslyze, sslscan, testssl.sh or thc-ssl-dos on a host with control-network reach.
Behavioral PowerShell script block constructing an SslStream and calling AuthenticateAsClient inside a loop construct.
Behavioral sysUpTime reset, coldStart trap or warmStart trap on an in-scope switch outside an approved maintenance window and not explained by a site power event.
Behavioral Management-interface unresponsiveness while hardware forwarding counters continue to advance normally — the discriminator between CPU exhaustion and a link or forwarding fault.
Behavioral authenticationFailure traps (OID 1.3.6.1.6.3.1.1.5.5) clustering on a single switch management interface.
Behavioral SCADA poll-timeout, communication-loss or sustained bad-quality alarms in a cell whose serving switch showed elevated management-plane session volume in the same interval.
Behavioral Moxa management interface or any OT protocol port answering from an organization-attributable public IP address, corroborated in two passive internet-scan indices.
Behavioral Continuous external exposure of a switch management interface spanning the 19 August 2026 advisory publication date — treat as presumptively enumerated.