CAN 总线数据记录格式-ASC

文件结构

一个典型的 .asc 文件由三部分组成：

  • 文件头 (Header)：包含日志的元数据，如开始日期、时间戳格式等
1
2
3
date Fri May 12 04:16:06.532 pm 2023    # 记录开始时间[reference:16]
base hex timestamps absolute            # 基数(hex)和时间戳类型(absolute)[reference:17]
internal events logged                 # 是否记录内部事件[reference:18]
  • 触发块 (Trigger Block)：代表一段连续的记录会话。如果记录被停止并重新开始，一个文件里可能会有多个触发块
1
2
3
Begin Triggerblock Fri May 12 04:16:06.532 pm 2023 0.000000  # 触发块开始[reference:20]
... (此处是报文数据) ...
End TriggerBlock                                          # 触发块结束[reference:21]
  • 报文/事件行 (Message/Event Lines)：这是文件的主体，由一行行的CAN报文或事件记录组成

报文行格式

一条典型的 CAN 报文行格式如下：

1
<时间戳> <通道> <ID> <方向> d|r <DLC> <数据字节>

  • 时间戳：报文的时间，单位是秒，通常是一个浮点数

  • 通道：标识报文来自哪个 CAN 通道（如 0, 1, 2）

  • ID：报文的仲裁 ID，通常以十六进制表示

  • 方向 (Direction)：Tx 表示发送，Rx 表示接收

  • 帧类型：d 表示数据帧（Data frame），r 表示远程帧（Remote frame）

  • DLC：Data Length Code，表示后续数据字节的长度

  • 数据字节 (Data bytes)：报文的具体数据，以十六进制字节列出

实战案例

teslaaaaa（CAN 总线数据记录格式-ASC）

pasted_1788071387170_l4hnph.png

题目给的附件是常见的 CAN 总线日志格式，其中

1
2
730 Tx = 测试设备发给汽车 ECU 的数据
7B0 Rx = 汽车 ECU 回给测试设备的数据

所以我们重点关注 730 Tx，第 27 行有这么一段请求 10 0B 34 00 44 08 00 00

ISO-TP（ISO 15765-2）是一个传输层协议。它的核心作用就是解决 CAN 总线一帧最多只能传 8 字节数据的限制

1
10 0B 34 00 44 08 00 00

  • 1 (PCI 高 4 位): 值为 1，表示这是一个首帧 (FF)。它宣告了一个多帧传输的开始

  • 0B (PCI 低 12 位): 十六进制 0x00B，即十进制的 11。这表示整个 UDS 指令的总长度是 11 个字节

  • 34 00 44 08 00 00 (后续 6 字节): 这是原始 UDS 指令的前 6 个字节的数据

第二段请求则是 21 00 00 00 20 00 AA AA，取剩下的 5 个字节，21 00 00 00 20

得到 34 00 44 08 00 00 00 00 00 20 00：

1
2
3
4
5
34                RequestDownload
00                DataFormatIdentifier
44                AddressAndLengthFormatIdentifier
08 00 00 00       写入地址：0x08000000
00 00 20 00       写入大小：0x2000

所以后面 ECU 要被刷入一段大小为 0x2000 = 8192 bytes 的固件，加载地址是 0x08000000

紧接着后面出现大量这种数据，这里是 ISO-TP 多帧

1
2
3
10 82 36 01 28 04 00 20
21 45 01 00 08 21 03 00
22 08 23 03 00 08 ...

10 82 表示本次 ISO-TP 数据总长度 = 0x82 = 130 bytes

重组后的 UDS payload 是 36 01 + 128 bytes 固件数据

附件里从 36 01 到 36 40 一共有 0x40 块，每块有效固件数据是 128 字节，正好对应前面的 RequestDownload 大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import re
from pathlib import Path

asc_path = "ecu_can_log.asc"
out_path = "firmware_08000000.bin"

# 编译正则表达式，用于匹配 ASC 文件中标准 CAN 帧（ID 为 3 位十六进制，数据长度 8 字节）
frame_re = re.compile(
    r"^\s*(?P<ts>\d+\.\d+)\s+1\s+(?P<id>[0-9A-F]{3})\s+"   # 匹配时间戳、通道 1、ID
    r"(?P<dir>Tx|Rx)\s+d\s+8\s+"                           # 匹配方向(Tx/Rx)和 "d 8"
    r"(?P<data>(?:[0-9A-F]{2}\s+){7}[0-9A-F]{2})",        # 匹配 8 个十六进制字节（空格分隔）
    re.I                                                   # 忽略大小写
)

frames = []  # 存储所有符合条件的 CAN 帧信息（行号和数据）

# 打开并读取ASC文件
with open(asc_path, "r", encoding="utf-8", errors="ignore") as f:
    for line_no, line in enumerate(f):          # 遍历每一行，记录行号（从 0 开始）
        m = frame_re.search(line)               # 尝试用正则匹配该行
        if not m:                               # 如果不匹配，跳过该行
            continue

        can_id = int(m.group("id"), 16)         # 提取 CAN ID 并转为整数（十六进制）
        direction = m.group("dir")              # 提取方向（Tx 或 Rx）
        data = bytes.fromhex(m.group("data"))   # 将数据部分的十六进制字符串转为字节串

        # 本题只关心 Tester 发送给 ECU 的 0x730 Tx 帧（即诊断请求）
        if can_id == 0x730 and direction == "Tx":
            frames.append((line_no, data))      # 将符合条件的帧加入列表

messages = []   # 存放所有重组后的 UDS 消息（完整 payload）
cur = None      # 当前正在重组的多帧消息的缓存（bytearray）
need = 0        # 当前多帧消息期望接收的总有效载荷字节数

for line_no, data in frames:        # 按 ASC 文件顺序遍历所有筛选出的帧
    pci_type = data[0] >> 4         # PCI 类型（高半字节）：0=单帧，1=首帧，2=连续帧，3=流控

    # 单帧（Single Frame）
    if pci_type == 0x0:
        length = data[0] & 0x0F      # 低 4 位表示有效载荷长度（0-7）
        payload = data[1:1 + length] # 截取有效数据
        messages.append(payload)     # 直接作为一个完整消息
        cur = None                   # 重置当前重组状态（确保没有未完成的多帧）

    # 首帧（First Frame）
    elif pci_type == 0x1:
        need = ((data[0] & 0x0F) << 8) | data[1]  # 低 12 位表示总有效载荷长度（大端）
        cur = bytearray(data[2:])                  # 初始化缓存，首帧携带的前 6 字节数据

    # 连续帧（Consecutive Frame）
    elif pci_type == 0x2:
        if cur is not None:          # 只有当前存在未完成的多帧时，才追加数据
            cur.extend(data[1:])     # 连续帧的 PCI 后 7 字节均为有效载荷

    # 流控帧（Flow Control）本题不需要处理
    elif pci_type == 0x3:
        continue                     # 直接忽略

    # 检查当前多帧重组是否已收满（如果 cur 存在且长度已达到 need）
    if cur is not None and len(cur) >= need:
        messages.append(bytes(cur[:need]))  # 截取前 need 个字节作为一个完整消息
        cur = None                          # 重置状态

blocks = []   # 存储所有的固件块（每个块包含序号和块数据）

# 遍历所有重组后的 UDS 消息
for payload in messages:
    # 查找 UDS 服务 0x36（请求下载/数据传输），其第一个字节为 0x36
    if len(payload) >= 2 and payload[0] == 0x36:
        seq = payload[1]                    # 第二个字节为块序列号（从 0 或 1 开始）
        block_data = payload[2:]            # 剩余部分为实际块数据

        # 按照协议，每个块应为 128 字节（0x80），如果不是则抛出异常
        if len(block_data) != 0x80:
            raise Exception(f"bad block {seq:02x}, len={len(block_data)}")

        blocks.append((seq, block_data))    # 将块序号和数据存入列表

blocks.sort(key=lambda x: x[0])             # 按块序号升序排序，确保顺序正确

firmware = b"".join(block for _, block in blocks)  # 将所有块的数据按顺序拼接成完整的固件

Path(out_path).write_bytes(firmware)        # 将固件数据写入输出文件

IDA 反编译可以看到一个 flag，但可惜是假的

pasted_1788094692808_g2tjdx.png

去看看谁引用了它，因为这个固件没有 main 函数

pasted_1788094917580_aw5s8g.png

这里在修改 flag 的每一位，跳过前面的 flag{

pasted_1788095480715_d8ui3p.png

编写脚本解密得到 flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
fake = "flag{canoecr7-zd9h-1emi-or8m-f8vm2od81nfk}"

inner = list(fake[5:-1])

ops = {
    2:  -0x0d,
    11: -0x05,
    15: -0x2c,
    3:  -0x0b,
    5:  -0x30,
    7:  +0x2b,
    28: +0x32,
    31: +0x2e,
    19: -0x0d,
    20: -0x42,
    1:  +0x03,
    29: -0x37,
    24: -0x33,
    9:  -0x17,
    25: -0x06,
    27: -0x3c,
    4:  -0x34,
    6:  -0x0e,
    30: -0x34,
    22: -0x3a,
    12: -0x30,
    16: -0x38,
    34: -0x35,
    0:  -0x30,
    14: +0x03,
    17: -0x05,
    33: -0x37,
    35: -0x38,
    10: -0x02,
    26: -0x43,
    21: -0x06,
}

for idx, delta in ops.items():
    inner[idx] = chr(ord(inner[idx]) + delta)

flag = "flag{" + "".join(inner) + "}"
print(flag)

得到 flag{3dad13db-cb48-495d-b023-3231d80f1713}