detecting-modbus-protocol-anomalies

name	detecting-modbus-protocol-anomalies
description	This skill covers detecting anomalies in Modbus/TCP and Modbus RTU communications in industrial control systems. It addresses function code monitoring, register range validation, timing analysis, unauthorized client detection, and deep packet inspection for malformed Modbus frames. The skill leverages Zeek with Modbus protocol analyzers, Suricata IDS with OT rules, and custom Python-based detection using Markov chain models for normal Modbus transaction sequences.
domain	cybersecurity
subdomain	ot-ics-security
tags	["ot-security","ics","scada","industrial-control","iec62443","modbus","protocol-anomaly"]
version	1.0.0
author	mahipal
license	Apache-2.0

Detecting Modbus Protocol Anomalies

When to Use

• When deploying Modbus-specific intrusion detection in an OT environment
• When building baseline models for deterministic Modbus polling patterns
• When investigating suspicious Modbus traffic flagged by OT monitoring tools
• When implementing function code allowlisting on industrial firewalls
• When detecting unauthorized Modbus write commands that could manipulate process setpoints

Do not use for securing Modbus communications end-to-end (Modbus has no native security; see implementing-network-segmentation-for-ot for firewall-based controls), for non-Modbus protocol monitoring (see detecting-anomalies-in-industrial-control-systems for multi-protocol), or for active fuzzing of Modbus implementations (see performing-plc-firmware-security-analysis).

Prerequisites

• Network SPAN/TAP access to monitor Modbus/TCP traffic (port 502)
• Zeek (formerly Bro) with Modbus protocol analyzer or Suricata with OT rulesets
• Python 3.9+ with scapy and pymodbus for custom analysis
• Baseline capture of normal Modbus traffic (minimum 1-2 weeks)
• Documentation of authorized Modbus clients, function codes, and register maps

Workflow

Step 1: Capture and Parse Modbus Traffic

Deploy passive monitoring to capture all Modbus/TCP traffic and parse it into structured records for analysis.

#!/usr/bin/env python3
"""Modbus Protocol Anomaly Detection System.

Monitors Modbus/TCP traffic for anomalies including unauthorized
function codes, unusual register access, timing deviations,
and rogue client devices.
"""

import json
import struct
import sys
import time
from collections import defaultdict, deque
from dataclasses import dataclass, field
from datetime import datetime
from statistics import mean, stdev

try:
    from scapy.all import sniff, rdpcap, IP, TCP
except ImportError:
    ()
    sys.exit()


MODBUS_FUNCTION_CODES = {
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
    : (, ),
}



 :
    timestamp: 
    anomaly_type: 
    severity: 
    src_ip: 
    dst_ip: 
    unit_id: 
    func_code: 
    detail: 
    mitre_technique:  = 



 :
    
    src_ip: 
    dst_ip: 
    func_codes_seen:  = field(default_factory=: defaultdict())
    register_ranges:  = field(default_factory=)
    intervals:  = field(default_factory=: deque(maxlen=))
    last_timestamp:  = 
    request_count:  = 
    write_count:  = 


 :
    

     ():
        .sessions = {}
        .baseline_sessions = {}
        .anomalies = []
        .authorized_clients = ()
        .authorized_func_codes = {}  
        .packet_count = 

     ():
        
        .authorized_clients = (clients)

     ():
        
        .authorized_func_codes[session_key] = (func_codes)

     ():
        
         (baseline_file)  f:
            baseline = json.load(f)
         key, data  baseline.get(, {}).items():
            .baseline_sessions[key] = data
            .authorized_func_codes[key] = (data.get(, []))
        ()

     ():
        
          pkt.haslayer(TCP)   pkt.haslayer(IP):
            

        
         pkt[TCP].dport !=   pkt[TCP].sport != :
            

        payload = (pkt[TCP].payload)
         (payload) < :
            

        .packet_count += 
        timestamp = (pkt.time)
        ts_str = datetime.fromtimestamp(timestamp).isoformat()

        
        :
            trans_id = struct.unpack(, payload[:])[]
            proto_id = struct.unpack(, payload[:])[]
            length = struct.unpack(, payload[:])[]
            unit_id = payload[]
            func_code = payload[]
         (IndexError, struct.error):
            

        
         pkt[TCP].dport == :
            src_ip = pkt[IP].src
            dst_ip = pkt[IP].dst
            is_request = 
        :
            src_ip = pkt[IP].dst
            dst_ip = pkt[IP].src
            is_request = 

          is_request:
              

        session_key = 

        
         session_key   .sessions:
            .sessions[session_key] = ModbusSession(src_ip=src_ip, dst_ip=dst_ip)

        session = .sessions[session_key]
        session.request_count += 
        session.func_codes_seen[func_code] += 

        

        
         .authorized_clients  src_ip   .authorized_clients:
            .anomalies.append(ModbusAnomaly(
                timestamp=ts_str,
                anomaly_type=,
                severity=,
                src_ip=src_ip, dst_ip=dst_ip,
                unit_id=unit_id, func_code=func_code,
                detail=,
                mitre_technique=,
            ))

        
        allowed_fcs = .authorized_func_codes.get(session_key)
         allowed_fcs  func_code   allowed_fcs:
            fc_info = MODBUS_FUNCTION_CODES.get(func_code, (, ))
            severity =   fc_info[] ==   
            .anomalies.append(ModbusAnomaly(
                timestamp=ts_str,
                anomaly_type=,
                severity=severity,
                src_ip=src_ip, dst_ip=dst_ip,
                unit_id=unit_id, func_code=func_code,
                detail=,
                mitre_technique=,
            ))

        
         func_code  (, , , , , ):
            session.write_count += 
            fc_name = MODBUS_FUNCTION_CODES.get(func_code, (, ))[]

            
             (payload) >= :
                register_addr = struct.unpack(, payload[:])[]
                session.register_ranges.add((func_code, register_addr))

                .anomalies.append(ModbusAnomaly(
                    timestamp=ts_str,
                    anomaly_type=,
                    severity=,
                    src_ip=src_ip, dst_ip=dst_ip,
                    unit_id=unit_id, func_code=func_code,
                    detail=,
                    mitre_technique=,
                ))

        
         session.last_timestamp > :
            interval = (timestamp - session.last_timestamp) *   
            session.intervals.append(interval)

            baseline = .baseline_sessions.get(session_key)
             baseline  (session.intervals) > :
                expected_interval = baseline.get(, ) * 
                expected_std = baseline.get(, ) * 

                 expected_std > :
                    z_score = (interval - expected_interval) / expected_std
                     z_score > :
                        .anomalies.append(ModbusAnomaly(
                            timestamp=ts_str,
                            anomaly_type=,
                            severity=,
                            src_ip=src_ip, dst_ip=dst_ip,
                            unit_id=unit_id, func_code=func_code,
                            detail=(
                                
                                
                            ),
                            mitre_technique=,
                        ))

        
         proto_id != :
            .anomalies.append(ModbusAnomaly(
                timestamp=ts_str,
                anomaly_type=,
                severity=,
                src_ip=src_ip, dst_ip=dst_ip,
                unit_id=unit_id, func_code=func_code,
                detail=,
                mitre_technique=,
            ))

        
         unit_id ==   func_code  (, , , ):
            .anomalies.append(ModbusAnomaly(
                timestamp=ts_str,
                anomaly_type=,
                severity=,
                src_ip=src_ip, dst_ip=dst_ip,
                unit_id=unit_id, func_code=func_code,
                detail=,
                mitre_technique=,
            ))

        session.last_timestamp = timestamp

     ():
        
        ()
        packets = rdpcap(pcap_file)
         pkt  packets:
            .process_packet(pkt)
        ()

     ():
        
        ()
        ()
        ()
        ()
        ()
        ()

        severity_counts = defaultdict()
        type_counts = defaultdict()
         a  .anomalies:
            severity_counts[a.severity] += 
            type_counts[a.anomaly_type] += 

        ()
         sev  [, , , ]:
             severity_counts[sev]:
                ()

        ()
         atype, count  (type_counts.items(), key= x: -x[]):
            ()

        ()
         a  .anomalies[:]:
            ()


 __name__ == :
    detector = ModbusAnomalyDetector()

     (sys.argv) > :
        
         (sys.argv) > :
            detector.load_baseline(sys.argv[])
        detector.analyze_pcap(sys.argv[])
        detector.generate_report()
    :
        ()