S7comm 协议¶

01100110

import struct
import re

# 打开 pcapng 文件并读取全部内容
pcap = "s7.pcapng"
raw = open(pcap, "rb").read()

# 默认使用小端字节序
endian = "<"
# 当前读取偏移
off = 0
# 存放提取出的隐藏数据
hidden = bytearray()

def parse_tcp(pkt):
    """解析以太网帧中的 TCP 报文，返回 (src_ip, dst_ip, src_port, dst_port, payload)"""
    # 以太网帧最小长度 14 字节（目的 MAC + 源 MAC + 类型）
    if len(pkt) < 14:
        return None

    # 以太类型字段（大端）
    eth_type = int.from_bytes(pkt[12:14], "big")
    pos = 14

    # 若存在 802.1Q VLAN 标签（0x8100），再读取内层类型
    if eth_type == 0x8100:
        eth_type = int.from_bytes(pkt[16:18], "big")
        pos = 18

    # 只处理 IPv4（0x0800）
    if eth_type != 0x0800:
        return None

    # IP 头部长度（ihl * 4 字节）
    ihl = (pkt[pos] & 0x0f) * 4
    # IP 协议字段（6 = TCP）
    proto = pkt[pos + 9]

    if proto != 6:
        return None

    # 源 IP 和目标 IP（点分十进制）
    src = ".".join(map(str, pkt[pos + 12:pos + 16]))
    dst = ".".join(map(str, pkt[pos + 16:pos + 20]))

    # TCP 首部起始位置
    tcp = pos + ihl
    # 源端口、目的端口
    sport = int.from_bytes(pkt[tcp:tcp + 2], "big")
    dport = int.from_bytes(pkt[tcp + 2:tcp + 4], "big")
    # TCP 数据偏移（4 位，单位 4 字节）
    doff = (pkt[tcp + 12] >> 4) * 4

    # TCP 有效载荷
    payload = pkt[tcp + doff:]
    return src, dst, sport, dport, payload

# 解析 pcapng 文件：逐块读取
while off + 12 <= len(raw):
    # 块类型和块长度（使用当前字节序）
    block_type, block_len = struct.unpack(endian + "II", raw[off:off + 8])

    # 块长度不合理则退出
    if block_len < 12 or off + block_len > len(raw):
        break

    # 块体（去除头部类型/长度和尾部重复长度）
    body = raw[off + 8:off + block_len - 4]

    # 块类型 0x0A0D0D0A 是 Section Header Block（SHB），用于判断字节序
    if block_type == 0x0A0D0D0A:
        # 魔术数字判断大小端：b"\x4d\x3c\x2b\x1a" 表示小端，否则大端
        endian = "<" if body[:4] == b"\x4d\x3c\x2b\x1a" else ">"

    # 块类型 6 是 Enhanced Packet Block（EPB），包含数据包
    elif block_type == 6:
        if len(body) >= 20:
            # 块选项中的捕获长度（caplen）在固定字段的第三个 int 里
            caplen = struct.unpack(endian + "IIIII", body[:20])[3]
            # 提取数据包字节
            pkt = body[20:20 + caplen]

            # 解析 TCP 报文
            parsed = parse_tcp(pkt)
            if parsed:
                src, dst, sport, dport, payload = parsed

                # 只取攻击者发往 PLC 102 端口的数据
                if dport == 102 and payload.startswith(b"\x03\x00"):
                    # S7Comm Job 包，Read Var 功能，固定长度 31
                    if (
                        len(payload) == 31
                        and payload[7] == 0x32   # 功能码：Read Var
                        and payload[8] == 0x01   # 读取变量数量：1
                        and payload[17] == 0x04  # 数据长度：4 字节
                    ):
                        # 提取最后一个字节（读取到的数据）
                        hidden.append(payload[-1])

    # 移动到下一个块
    off += block_len

# 将隐藏数据写入文件
open("hidden", "wb").write(hidden)

# 打印恢复信息
print("hidden length:", len(hidden))
print("file header:", hidden[:10].hex())

# 搜索 flag 并输出
flags = re.findall(rb"flag\{[^}]+\}", hidden)
for f in flags:
    print(f.decode())

import struct
import socket
import re

# 读取 pcapng 文件
pcap = "/mnt/data/s702(1).pcapng"
data = open(pcap, "rb").read()

# -------- 解析 pcapng 块 --------
packets = []
off = 0
endian = "<"  # 默认小端

while off + 12 <= len(data):
    # 块类型和块总长度（含固定尾）
    block_type, block_len = struct.unpack(endian + "II", data[off:off+8])
    if block_len < 12 or off + block_len > len(data):
        break

    body = data[off+8:off+block_len-4]  # 排除尾部的块总长度字段

    # Section Header Block (SHB)
    if block_type == 0x0A0D0D0A:
        # 字节序标记：0x1A2B3C4D 表示大端
        endian = ">" if body[:4] == b"\x1a\x2b\x3c\x4d" else "<"

    # Enhanced Packet Block (EPB)
    elif block_type == 0x00000006 and len(body) >= 20:
        # 接口ID、时间戳高低位、捕获长度、原始长度
        iface, ts_high, ts_low, cap_len, orig_len = struct.unpack(
            endian + "IIIII", body[:20]
        )
        # 提取实际捕获的报文数据
        packets.append(body[20:20+cap_len])

    off += block_len


def get_tcp_payload(pkt):
    """从原始以太网帧中提取 TCP 载荷及四元组"""
    if len(pkt) < 54:  # 最小长度：以太网14 + IP20 + TCP20
        return None

    # 以太网类型必须为 IPv4 (0x0800)
    if pkt[12:14] != b"\x08\x00":
        return None

    # IP 协议字段必须为 TCP (6)
    if pkt[23] != 6:
        return None

    # IP 头长度（IHL）及偏移
    ihl = (pkt[14] & 0x0F) * 4
    ip_start = 14
    tcp_start = ip_start + ihl

    # 源IP、目的IP
    src = socket.inet_ntoa(pkt[ip_start+12:ip_start+16])
    dst = socket.inet_ntoa(pkt[ip_start+16:ip_start+20])

    tcp = pkt[tcp_start:]
    if len(tcp) < 20:
        return None

    # 源端口、目的端口
    sport, dport = struct.unpack("!HH", tcp[:4])
    # TCP 数据偏移
    data_offset = (tcp[12] >> 4) * 4
    payload = tcp[data_offset:]

    return src, sport, dst, dport, payload


def parse_s7_write_values(payload):
    """从 TCP 载荷中提取 S7 写变量操作的写入值（每次写1字节）"""
    values = []
    off = 0

    while off + 4 <= len(payload):
        # TPKT 头部：版本 0x03，保留 0x00，总长度
        if payload[off:off+2] != b"\x03\x00":
            break

        tpkt_len = int.from_bytes(payload[off+2:off+4], "big")
        tpkt = payload[off:off+tpkt_len]

        # COTP 数据 TPDU：DT Data (0x0f) 且最后字节 0x80 表示数据
        if len(tpkt) >= 17 and tpkt[4:7] == b"\x02\xf0\x80":
            s7 = tpkt[7:]

            # S7 协议标识 (0x32)
            if len(s7) >= 10 and s7[0] == 0x32:
                rosctr = s7[1]  # 报文类型

                # 0x01 = Job（请求）
                if rosctr == 0x01:
                    # 参数长度、数据长度
                    param_len = int.from_bytes(s7[6:8], "big")
                    data_len = int.from_bytes(s7[8:10], "big")

                    param = s7[10:10+param_len]
                    d = s7[10+param_len:10+param_len+data_len]

                    # 功能码 0x05 = 写变量
                    if param and param[0] == 0x05:
                        # 本题每次写入 1 字节，S7 写数据前 4 字节为：
                        # 保留/传输大小/位长度
                        if len(d) >= 5:
                            values.append(d[4:5])  # 提取写入值

        off += tpkt_len

    return values


# 累积所有写入值，拼接成字节序列
seq = b""

for pkt in packets:
    item = get_tcp_payload(pkt)
    if not item:
        continue

    src, sport, dst, dport, payload = item

    # 只看上位机 (192.168.88.2) 发给 PLC (192.168.88.23) 端口 102 的 S7 写入
    if src == "192.168.88.2" and dst == "192.168.88.23" and dport == 102:
        for v in parse_s7_write_values(payload):
            seq += v

print("extracted length:", len(seq))

# 在累积的序列中搜索 flag{...} 模式
m = re.search(rb"flag\{[^}]+\}", seq)
if m:
    print(m.group().decode())
else:
    print("not found")