2019-04-14

LSIS-XGT 协议

概述

LSIS-XGT 可以把它理解成：LS ELECTRIC / 原 LSIS 系列 PLC 的专用以太网通信协议。它主要用于 PC、HMI、上位机、工程软件和 PLC 之间读写 PLC 内部数据区。官方手册里也说，XGT dedicated / XGT server protocol 支持通过命令进行读写，PC、HMI 可以用它和 PLC 通信

默认端口

协议	传输层	默认端口
XGT dedicated / XGT server	TCP	2004
XGT dedicated / XGT server	UDP	2005
Modbus TCP	TCP	502

特征

它的典型特征是 TCP payload 开头有固定公司标识

1 2	4c 53 49 53 2d 58 47 54 L S I S - X G T

报文结构

一个完整 TCP payload 大概是

┌──────────────────────────────┐
│ Application Header  20 bytes │
├──────────────────────────────┤
│ Application Instruction      │
│   Command                    │
│   Data Type                  │
│   Reserved                   │
│   Block Count                │
│   Variable / Data            │
└──────────────────────────────┘

XGT 的应用层头部长度通常是 20 字节。字段如下

偏移	长度	字段	说明
`0x00`	8	Company ID	固定字符串 `LSIS-XGT`
`0x08`	2	Reserved / Company 扩展	通常为保留字段
`0x0A`	2	PLC Info	PLC 状态/CPU 类型等信息，客户端请求时通常不用关心
`0x0C`	1	CPU Info	CPU 系列信息，例如 XGK 常见 `0xA0`
`0x0D`	1	Source of Frame	报文方向，客户端常见 `0x33`，PLC 响应常见 `0x11`
`0x0E`	2	Invoke ID	会话/帧序号，请求和响应对应
`0x10`	2	Length	后面 Instruction 区长度
`0x12`	1	FEnet Position	通信模块位置，槽号/基号
`0x13`	1	BCC / Checksum	头部校验或保留校验

Command 字段

XGT 常见 4 类基础命令：

功能	逻辑值	报文中
读请求	`h0054`	`54 00`
读响应	`h0055`	`55 00`
写请求	`h0058`	`58 00`
写响应	`h0059`	`59 00`

Data Type 字段

Command 后面紧跟 Data Type，也是 2 字节。常见类型

类型	逻辑值	报文中
Bit	`h0000`	`00 00`
Byte	`h0001`	`01 00`
Word	`h0002`	`02 00`
DWord	`h0003`	`03 00`
LWord	`h0004`	`04 00`
Continuous / 连续块读写	`h0014`	`14 00`

连续读请求结构

Header
Command
Data Type
Reserved
Number of Blocks
Variable Length
Variable Name
Number of Data

具体字段如下：

偏移，相对于 Instruction 起点	长度	字段	说明
`+0x00`	2	Command	`54 00`，读请求
`+0x02`	2	Data Type	`14 00`，连续块
`+0x04`	2	Reserved	一般 `00 00`
`+0x06`	2	Number of Blocks	连续读固定 `01 00`
`+0x08`	2	Variable Length	变量名长度
`+0x0A`	N	Variable Name	ASCII，例如 `%PB100`
`+0x0A+N`	2	Number of Data	要读取多少字节

连续读响应结构

Header
Command
Data Type
Reserved
Error Status
Number of Blocks
Number of Data
Data

字段如下：

偏移，相对于 Instruction 起点	长度	字段	说明
`+0x00`	2	Command	`55 00`，读响应
`+0x02`	2	Data Type	`14 00`，连续块
`+0x04`	2	Reserved	保留字段
`+0x06`	2	Error Status	`00 00` 表示正常
`+0x08`	2	Number of Blocks	正常时通常 `01 00`
`+0x0A`	2	Number of Data	返回数据长度
`+0x0C`	N	Data	真正读取到的数据

实战案例

协议分析又来了（LSIS-XGT 工控协议）

统计会话中的主要端口是 2004

过滤 tcp.port == 2004，发现明显特征

过滤器直接搜 tcp contains "LSIS-XGT"

使用 tshark 提取上面这些数据出来

1	tshark -r .\capture.pcapng -Y "tcp.port == 2004 && tcp.len > 0" -T fields -e tcp.payload > xgt_payloads.txt

编写脚本解析

import re

input_file = "xgt_payloads.txt"

# 用于存放未匹配响应的请求队列，每个元素为 (地址, 请求读取长度)
pending = []

# 以 UTF-16 编码打开输入文件
with open(input_file, "r", encoding="utf-16") as f:
    # enumerate 从 1 开始计数行号，便于定位
    for line_no, line in enumerate(f, 1):
        # 去除行首尾空白字符（包括换行符）
        line = line.strip()
        # 跳过空行
        if not line:
            continue

        # 将十六进制字符串转换为字节序列（例如 "AA BB" -> b'\xAA\xBB'）
        payload = bytes.fromhex(line)

        # LSIS-XGT 协议报文固定以 "LSIS-XGT" 开头（ASCII 字符串）
        if not payload.startswith(b"LSIS-XGT"):
            continue

        # 报文长度至少需要 0x20 字节才包含完整头部，否则跳过
        if len(payload) < 0x20:
            continue

        # 命令码位于偏移 0x14，占 2 字节，小端序
        # 0x54 = 读请求，0x55 = 读响应
        cmd = int.from_bytes(payload[0x14:0x16], "little")

        # ---------- 处理读请求 (cmd == 0x54) ----------
        if cmd == 0x54:
            # 在报文中搜索 "%PB" 后跟一个或多个数字的模式（变量名）
            # 例如 "%PB100" 表示 PB 区地址 100
            m = re.search(rb"%PB(\d+)", payload)
            if not m:
                # 未找到变量名，无法解析，跳过
                continue

            # 提取地址数字（从匹配组中获取）
            addr = int(m.group(1))

            # 变量名字符串后面紧接 2 字节，表示本次读取的长度（小端序）
            # m.end() 是匹配结束的位置，其后 2 字节即为长度字段
            size = int.from_bytes(payload[m.end():m.end() + 2], "little")

            # 将该请求加入待匹配队列（先进先出，用于与后续响应配对）
            pending.append((addr, size))

            # 打印请求信息，方便追踪
            print(f"[请求] line={line_no}, %PB{addr}, size={size}")

        # ---------- 处理读响应 (cmd == 0x55) ----------
        elif cmd == 0x55:
            # 如果 pending 为空，说明收到一个没有对应请求的响应
            if not pending:
                print(f"[响应] line={line_no}, 但是找不到对应请求")
                continue

            # 从队列头部取出最早的请求（假定响应顺序与请求一致）
            addr, req_size = pending.pop(0)

            # 响应数据长度位于偏移 0x1e，占 2 字节，小端序
            data_len = int.from_bytes(payload[0x1e:0x20], "little")

            # 实际数据从偏移 0x20 开始，长度为 data_len
            data = payload[0x20:0x20 + data_len]

            # 打印响应信息，包括请求的地址、请求长度、实际数据长度和十六进制数据
            print(
                f"[响应] line={line_no}, %PB{addr}, "
                f"req_size={req_size}, data_len={data_len}, "
                f"data={data.hex()}"
            )

总结出规律地址

%PB100
%PB200
%PB300
%PB400
%PB500
...

修改脚本，按照这些顺序拼接数据得到

# 1. 新增字典，用于存储符合条件的数据块（地址 -> 响应数据）
chunks = {}

# 2. 在原有的读响应处理分支（cmd == 0x55）中，替换掉了直接打印，改为收集数据：

        # ...（前面的响应解析代码与第一个脚本相同）
        data_len = int.from_bytes(payload[0x1e:0x20], "little")
        data = payload[0x20:0x20 + data_len]

        # 新增：检查请求长度与实际数据长度是否一致，不一致则警告并跳过
        if data_len != req_size:
            print(f"[!] 长度不一致: %PB{addr}, req={req_size}, resp={data_len}")
            continue

        # 新增：只收集地址为100的整数倍，且在100~29900范围内的“主线”数据块
        if addr % 100 == 0 and 100 <= addr <= 29900:
            # 避免重复覆盖（每个地址只保存第一次收到的数据）
            if addr not in chunks:
                chunks[addr] = data
                print(f"[+] 收集 %PB{addr}, len={len(data)}")

# 3. 新增文件读取循环结束后，进行数据块拼接和输出：

# 按地址顺序拼接，预期地址范围：100, 200, 300, ... , 29900（步长100）
buf = bytearray()

for addr in range(100, 30000, 100):
    # 检查是否所有预期地址都已收集到，否则抛出异常
    if addr not in chunks:
        raise Exception(f"缺少数据块: %PB{addr}")

    data = chunks[addr]

    # 检查每个数据块长度是否为100字节（根据协议固定长度），否则异常
    if len(data) != 100:
        raise Exception(f"数据块长度异常: %PB{addr}, len={len(data)}")

    # 按顺序追加到缓冲区
    buf.extend(data)

# 将拼接好的二进制数据写入文件
with open("raw_pb.bin", "wb") as f:
    f.write(buf)

# 输出统计信息
print("[+] 拼接完成")
print("[+] 数据块数量:", len(chunks))
print("[+] raw_pb.bin size:", len(buf))
print("[+] raw_pb.bin 前16字节:", buf[:16].hex())

文件开头是 b2 a5 6f ff fc ff ff ff fb ff ff ff 00 00 ff ff，对其异或 0xff 得到 4d 5a 90 00 ...

4d 5a 就是 Windows EXE 的 MZ 文件头

raw = open("raw_pb.bin", "rb").read()

decoded = bytes(b ^ 0xff for b in raw)

open("flag.exe", "wb").write(decoded)

print("raw size:", len(raw))
print("decoded size:", len(decoded))
print("magic:", decoded[:16].hex())

从字符串中识别出它是一个 .NET / WPF 程序

IDA 反编译发现一堆数值

这种格式在 WPF 里非常像 Margin="62,62,0,0"

1	strings -a flag.exe \| grep -E "[0-9]+,[0-9]+,0,0"

提取出来类似于 UI 布局

编写脚本绘图拿到 flag

import re

data = open("flag.exe", "rb").read()

# 用于存储筛选后的有效坐标点
points = []

# 使用正则表达式在二进制数据中查找形如 "数字,数字,0,0" 的片段
# \d{1,4} 匹配1到4位数字，逗号分隔，后面紧跟 ",0,0"
for x, y in re.findall(rb"(\d{1,4}),(\d{1,4}),0,0", data):
    # 将匹配到的字节串转为整数
    x = int(x)
    y = int(y)

    # 过滤有效坐标范围：x 在 [40, 760]，y 在 [50, 160]
    # 这个范围可能是根据原图或屏幕区域设定的可见区域
    if 40 <= x <= 760 and 50 <= y <= 160:
        points.append((x, y))

print("valid points:", len(points))

# 计算所有有效点的最小/最大坐标，用于确定 SVG 画布尺寸
min_x = min(x for x, y in points)
min_y = min(y for x, y in points)
max_x = max(x for x, y in points)
max_y = max(y for x, y in points)

# 准备构建SVG图片
svg = []

# SVG 头部，设置命名空间，宽度和高度留出 40 像素边距（各边 20 像素）
svg.append(
    f'<svg xmlns="http://www.w3.org/2000/svg" '
    f'width="{max_x - min_x + 80}" height="{max_y - min_y + 80}">'
)

# 添加白色背景矩形，占满整个画布
svg.append('<rect width="100%" height="100%" fill="white"/>')

# 遍历所有有效坐标点，在SVG中绘制黑色小方块（16x16）
# 坐标偏移 (min_x, min_y) 并额外增加20像素边距，使得图形居中
for x, y in points:
    svg.append(
        f'<rect x="{x - min_x + 20}" '
        f'y="{y - min_y + 20}" '
        f'width="16" height="16" fill="black"/>'
    )

# SVG闭合标签
svg.append("</svg>")

# 将生成的SVG内容写入文件 "flag.svg"
open("flag.svg", "w", encoding="utf-8").write("\n".join(svg))

print("[+] 已生成 flag.svg")