# sawFileVerify

**Repository Path**: 12581/sawFileVerify

## Basic Information

- **Project Name**: sawFileVerify
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-05-28
- **Last Updated**: 2026-06-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SAW 文件 CHK1 校验码逆向

## 项目目标

分析 `.saw` 文件末尾 `CHK1,<hex>` 校验行的生成算法，实现校验码的自主计算和验证。

## 背景

- `.saw` 文件来自某种裁床/服装CAD软件（YG品牌）
- 带 `_BCF` 后缀的是源文件，`_1`/`_2` 是从源文件拆分出的子文件
- 每个文件末尾有一个 `CHK1,<十六进制值>` 行，是文件的校验码
- 拆分后的 `_1`/`_2` 文件携带新的 CHK1 值，说明校验码是拆分后重新计算的
- 同组 BCF/_1/_2 的 INFO 元数据和 PNL2 面板数据完全一致，仅 PTN2/PTNR 路径数据不同
- 仅 BCF 文件在 INFO 和 CHK1 之间包含一个 base64 块（解码后128字节，大小与RSA-1024签名一致，推测为数字签名），拆分文件无此块
- **Set1 的 _1 (0xF090) 和 _2 (0x0521) 二进制 AND 为 0x0000**，即16位中无任何重叠的1位，强烈暗示XOR累加型校验算法

## 文件格式

```
Line 0:    1,0                  (格式版本)
Line 1:    (空行)
Line 2-13: BRD1/BRD2 等元数据   (电路板/裁片信息)
Line 14:   PNL1,...             (面板参数)
Line 15-N: PNL2,...             (面板数据, 同组文件完全一致)
...        PTN2,...             (切割路径数据, BCF含全部, _1/_2各含一部分)
...        PTNR,...             (路径关系/结果)
...        INFO1,...            (作业信息)
...        INFO2,...            (统计数据)
...        INFO3,...            (长数据行)
...        INFO4,...            (附加参数)
...        (空行 2-3行)
[仅BCF]   <base64块>            (数字签名, 解码后128字节)
CHK1,<hex>                      (校验码)
```

行分隔符为 `\r\n`。

## 已知 CHK1 值

| 组 | BCF | _1 | _2 |
|---|-----|----|----|
| Set1 (Y041-2) | `bf62` | `F090` | `0521` |
| Set2 (Y028-1) | `7ded` | `9990` | `98B9` |
| Set3 (Y028-1-64) | `c534` | `00B2` | `E316` |

## 文件说明

```
sawFileVerify/
├── README.md                    ← 本文件
├── RESEARCH_SUMMARY.md          ← 精简研究总结 (快速查阅)
├── CHK1_research_log.md         ← 详细研究日志 (Phase 1-4 所有测试清单)
├── reverse_chk1.py              ← Phase 1 批量测试脚本 (1080种组合)
├── reverse_chk1_v2.py           ← Phase 2 测试脚本 (FileData类 + 多阶段)
├── quick_test.py                ← 32种标准CRC变体逐行XOR快速测试
├── test_more.py                 ← CRC-32/Adler-32/FNV-1a/字段级补充测试
├── brute.c                      ← C语言: 逐行XOR CRC-16 全32K多项式暴力搜索
├── brute2.c                     ← C语言: 连续CRC + init=0xFFFF 暴力搜索
├── gf2_search_v2.c              ← C语言: GF(2)线性代数搜索 (修复版, 逐行XOR模型)
├── gf2_contig_search.c          ← Phase 5: GF(2)搜索 (连续CRC模型 + 矩阵快速幂)
├── contig_brute.c               ← C语言: 连续CRC + 全init搜索 (常见多项式)
├── split_range_test.py          ← Phase 5: BCF参数 × Split数据范围测试
├── verify_bcf_match.py          ← Phase 5: BCF算法交叉验证脚本
├── chk1.py                      ← ★ BCF CHK1 校验工具 (零依赖, 可直接使用)
├── field_xor.py                 ← Phase 3A: 字段级XOR测试
├── line_ending_test.py          ← Phase 3E: 换行符变体测试
├── hash_test.py                 ← Phase 3F: 非CRC哈希函数测试
├── crypto_hash_test.py          ← Phase 4C: MD5/SHA截断测试
├── post_crc_test.py             ← Phase 4D: Post-CRC变换测试
├── hypothesis_test.py           ← Phase 4E/4F: 新假设测试
├── gf2_split_search.c            ← Phase 7: 全模型 GF(2) 搜索（奇/偶多项式 + 全数据范围）
├── gf2_ptn2_search.c             ← Phase 8: PTN2-only GF(2) 全搜索 [有PTN2提取bug]
├── gf2_perline_xor_search.c      ← Phase 9: 逐行XOR GF(2) 全搜索 (CHK1⊕BCF + bug修复)
├── gf2_ptn2_fixed.c              ← Phase 10: 真·PTN2-only 连续CRC (修复PTN2提取+xorout bug)
├── gf2_crc8_search.c             ← Phase 10: CRC-8×2 组合16bit GF(2) 全搜索
├── phase11_group_pair_analysis.py ← Phase 11: PTN2 Group-Pair 联合理计算
├── phase11b_custom_hash.py       ← Phase 11: 自定义 16-bit 哈希算法测试
├── deep_analyze2.py              ← Phase 7: 深度数据分析
├── phase8_tests.py               ← Phase 8: 多种假设测试
├── phase8b_analysis.py           ← Phase 8: S2 深度对比分析
├── check_ptnr_xor.py             ← Phase 8: PTNR 数字 XOR 跨文件对比
├── test_bcf_params.py            ← Phase 8: BCF参数×Split数据范围
├── *.exe                        ← 编译后的C程序 (gcc -O3)
├── YG26042803-28-Y041-2_BCF.saw ← Set1 源文件
├── YG26042803-28-Y041-2_1.saw   ← Set1 拆分1
├── YG26042803-28-Y041-2_2.saw   ← Set1 拆分2
├── YG26042804-32-Y028-1_BCF.saw ← Set2 源文件
├── YG26042804-32-Y028-1_1.saw   ← Set2 拆分1
├── YG26042804-32-Y028-1_2.saw   ← Set2 拆分2
├── YG26040305-64-Y028-1_BCF.saw ← Set3 源文件
├── YG26040305-64-Y028-1_1.saw   ← Set3 拆分1
└── YG26040305-64-Y028-1_2.saw   ← Set3 拆分2
```

## 研究现状

**截至 2026-05-31 Phase 13：BCF 算法已破解，Split 算法经 103 项排除（全部 CRC/哈希/变换/Metadata 穷举）后仍未破解。唯一解法：获取 YG 软件动态逆向。**

### ✅ BCF 文件 CHK1 算法（已破解）

**模型**: 连续 CRC-16，覆盖 CHK1 行之前全部原始字节

```
CHK1 = CRC16(all_bytes_before_CHK1, poly, init, xorout)
```

经 GF(2) 线性代数搜索找到 3 组有效参数（GF(2) 等价，对全部 3 个 BCF 文件均匹配）：

| # | poly | refin | refout | init | xorout |
|---|------|-------|--------|------|--------|
| 1 | `0x4567` | 1 | 1 | `0xEF20` | `0xCFD2` |
| 2 | `0x7EDB` | 1 | 1 | `0xB1EE` | `0xE0DD` |
| 3 | `0x18C5` | 0 | 1 | `0x5B7C` | `0x126A` |

**验证**: 三组参数均通过 Python 交叉验证，正确计算全部 3 个 BCF 文件的 CHK1。

### ❌ Split 文件 CHK1 算法（未破解）

Split (_1/_2) 文件使用与 BCF 完全不同的算法。

**已穷举排除（Phase 1-9）:**

| 类别 | 搜索范围 | 结果 |
|------|---------|:---:|
| 连续 CRC-16 | 全部 65,536 多项式(奇+偶) × 全 init/xorout × 4 refin/refout × 7 数据范围 | ✗ |
| 逐行 XOR CRC-16 | 全部 65,536 多项式(奇+偶) × 全 init/xorout × 4 refin/refout × 4 数据范围 × 2 目标 | ✗ |
| 非 CRC 哈希 | 18 种 (MurmurHash3, xxHash32, Jenkins, Pearson, SuperFastHash 等) | ✗ |
| 加密哈希截断 | MD5, SHA-1, SHA-256 (3种换行 × 4种截断) | ✗ |
| 简单校验和 | Sum16, XOR16, Fletcher-16, Adler-16, IP checksum, 位置加权 | ✗ |
| Post-CRC 变换 | byte_swap, reflect16, XOR/加法常数 | ✗ |
| 字段级计算 | PTN2 字段 XOR/SUM, PTNR 数字 XOR/SUM | 值太小 |
| 预处理 | 去前缀, 纯数值, pair分组, 换行符变体, 15+ 字节范围 | ✗ |
| CRC-8×2 组合 | 9 种 (PTN2+PTNR 交叉 × shared params), CRC-8(PTN2) 单字节 | ✗ |
| Group-Pair CRC | 5 CRC × 3 组合方式 × 6 文件 + nonptn 组合 | ✗ |
| PTNR 语义 | 数字 XOR/Sum/CRC/运算符计数 | ✗ |
| 自定义哈希 | 位置加权/Fletcher/旋转/模累加/位操作等 14 类 | ✗ |

**Phase 9 新排除项:**

| 模型 | 数据范围 | 目标 | 多项式 | 结果 |
|------|---------|------|--------|:---:|
| 逐行 XOR | ALL/PTN/PTN2/PTNR | CHK1 XOR BCF | 32K odd | 0/6 |
| 逐行 XOR | ALL/PTN/PTN2/PTNR | CHK1 | 32K odd | 0/6 |
| 逐行 XOR | ALL/PTN/PTN2/PTNR | CHK1 XOR BCF | 32K even | 0/6 |

**Bug 发现与修复 (Phase 9):**
- **refout=1 xorout 位反转**: gf2_search_v2.c, gf2_contig_search.c, gf2_split_search.c 中 refout=1 的 xorout 位映射错误 `(1 << (15-ri))` 应为 `(1 << ri)`，Phase 9 已修复并重跑所有逐行 XOR 模型
- **PTN2 提取错误**: gf2_ptn2_search.c 的 PTN2-only 提取包含了交错 PTNR 行（连续字节范围而非逐行过滤），Phase 8B 结果不准确

**关键发现 (Phase 8-9):**
- PTNR 数字 XOR 在同组内完全一致（S1=0x00A5, S2=0x009A）— PTNR 对 CHK1 差异无贡献
- PTN2 字段值很小（<1000），不能解释 CHK1（178-61584）
- BCF参数对Split数据范围 (Full/PTN/PTN2/NonPTN) 均不匹配
- **CRC-16 家族穷举正式完成** (Phase 9): 连续CRC + 逐行XOR，全部模型均已测试完毕

**结论**: Split 算法不属于任何 CRC-16/哈希/校验和变体，极可能是厂商自定义实现。
- BCF 参数 × 9 种数据范围 → **0匹配**（split_range_test.py）
- 多种多项式猜测（0x0123, 0x0789, BCF_CHK1等） → **0/6 匹配**
- 偶数多项式、CRC-32截断、加密哈希截断 → **0/6 匹配**

详细研究记录见 `CHK1_research_log.md` 和 `RESEARCH_SUMMARY.md`。

---

### 已排除的方向（Phase 1-5 完整清单）

**CRC-16 多项式穷举（逐行XOR 模型）**:
- [x] 全部 65,536 多项式（奇+偶）× 全部 65,536 init × 全部 65,536 xorout × 4 refin/refout × 4 数据范围 × 2 目标 (GF(2)) → **BCF: 3匹配, Split: 0匹配**
- [x] 32+ 种标准/自定义 CRC-16 变体 → 0匹配
- [x] 8 种 CRC-8 变体 → 0匹配

**CRC-16 多项式穷举（连续 CRC 模型）**:
- [x] 全部 65,536 多项式（奇+偶）× 全部 65,536 init × 全部 65,536 xorout × 4 refin/refout × 7 数据范围 (GF(2) 矩阵快速幂) → **BCF: 3匹配, Split: 0匹配**

**Split 文件多项式猜测测试**:
- [x] poly=0x0123, 0x0789, 连续数字多项式 (0x1234-0x789A), 12-bit变体 → 0/6 匹配
- [x] BCF多项式(0x4567) + 不同 init/xorout 组合 → 0/6 匹配
- [x] poly=BCF_CHK1（用BCF校验码作为多项式） → 0/6 匹配
- [x] GF(2) 线性搜索、偶数多项式、CRC-32截断 → 0/6 匹配

**非 CRC 哈希函数**:
- [x] MurmurHash3-32, xxHash32, Jenkins (2种), Pearson, SuperFastHash → 0匹配
- [x] FNV-1a-16/32, DJB2-16, SDBM-16 → 0匹配
- [x] MD5, SHA-1, SHA-256 截断 → 0匹配

**Post-CRC 变换**:
- [x] byte_swap, reflect16, XOR 常数, 加法常数 → 0匹配

**预处理 / 数据范围**:
- [x] 15+ 种字节范围, 换行符变体, base64 解码 → 0匹配
- [x] BCF/split 分离测试 → **BCF 3匹配 / Split 0匹配**
- [x] Split: 9 种数据范围 × BCF 参数 → 0匹配
- [x] Split: 逐行 XOR CRC × BCF 参数 → 0匹配

**字段级计算**:
- [x] PTN2 数值/PTNR 数字/INFO 统计值 → 0匹配

**简单校验和**:
- [x] Sum16, XOR8/16, Fletcher-16, Adler-16/32, IP checksum, 位置加权求和 → 0匹配

---

### 关键发现

1. **BCF 算法已破解** — 连续 CRC-16，**init ≠ 0, xorout ≠ 0** 是之前搜索失败的根本原因
2. **BCF 与 _1/_2 使用不同的算法/参数** — 验证了 BCF 小写 hex vs _1/_2 大写 hex 的观察
3. **Set1 AND(_1,_2) = 0x0000** — 两个拆分文件 CHK1 二进制位完全不重叠，强烈暗示 XOR 累加型算法
4. **CRC-16 穷举正式完成 (Phase 9)** — 连续 + 逐行XOR，奇+偶全部 65,536 多项式，全部数据范围和目标，均彻底排除
5. **refout=1 xorout 位反转 bug** — 发现于 gf2_search_v2.c/gf2_contig_search.c，Phase 9 已修复
6. **PTN2 提取 bug** — gf2_ptn2_search.c 的 PTN2-only 实际包含了交错 PTNR 行
7. **三重 XOR 值在每组内一致** — Set1=0x4AD3, Set2=0x7CC4, Set3=0x2690
8. **矩阵快速幂优化** — `T(L) = T(1)^L` 将搜索速度从 ~1 poly/min 提升到 ~100-10000 poly/s

---

## chk1.py — BCF 校验工具

```bash
# 单个文件
python chk1.py YG26042803-28-Y041-2_BCF.saw

# 批量验证
python chk1.py *.saw
```

输出示例：
```
FILE                                          TYPE   COMPUTED EXPECTED  MATCH  BYTES
------------------------------------------------------------------------------------------
YG26042803-28-Y041-2_BCF.saw                  BCF    0xBF62   0xBF62   OK     336100
YG26042804-32-Y028-1_BCF.saw                  BCF    0x7DED   0x7DED   OK     455341
YG26040305-64-Y028-1_BCF.saw                  BCF    0xC534   0xC534   OK     483064
```

BCF 算法参数：`poly=0x4567, refin=1, refout=1, init=0xEF20, xorout=0xCFD2`
（另有 2 组 GF(2) 等价解：`0x7EDB/0xB1EE/0xE0DD` 和 `0x18C5/0x5B7C/0x126A`）

---

## 如何继续研究

### 当前状态 (Phase 10 完成后)

CRC-16 / CRC-8×2 / 非 CRC 哈希 / 校验和 / Post-CRC 变换 / 字段计算 / 数据预处理 / 参数注入等共 **170+ 种模型配置**均已穷举排除（0/6）。**Split CHK1 不属于任何已知 CRC/哈希/校验和变体。**

### 剩余可行方向

| 方向 | 可能性 | 方法 |
|------|:---:|------|
| **反编译 YG 软件** | 最高 | 获取 YG2-GT18mm/YG-HPL430 安装包，IDA/Ghidra 分析 CHK1 函数 |
| PTNR 语义解析 | 中 | PTNR 包含数学表达式，算法可能基于这些计算结果 |
| 获取更多样本 | 中 | 更多 .saw 文件用于差分分析 |
| CRC-8 独立参数 | 低 | 两个 CRC-8 使用不同 poly/init（搜索空间 ~128×128） |

### 已确认的 BCF 参数

3 组 GF(2) 等价解，实际使用的参数需要通过更多 BCF 样本或软件分析确定。

### 验证方法

```python
# BCF 文件验证 (已确认):
# CRC16(data_before_chk1, poly=0x4567, init=0xEF20, xorout=0xCFD2, refin=1, refout=1)

# Split 文件验证 (未破解):
# 算法不在 CRC/哈希/校验和族内，大概率是厂商自定义实现
```

## 协作方式

如果你有新的发现或思路:

1. 先阅读 `RESEARCH_SUMMARY.md` 快速了解已排除的方向 (精简版)
2. 详细测试清单见 `CHK1_research_log.md` (完整版)
3. 重点关注"尚未尝试的方向"部分
4. 运行并记录结果到 `CHK1_research_log.md`
5. 如找到匹配算法，更新本 README 并标注算法详情

## 运行测试

### Python 脚本

```bash
cd sawFileVerify

# Phase 1: 标准算法 + 多字节范围 (1080种组合)
python3 reverse_chk1.py

# Phase 2: 扩展测试 (非CRC算法 + 字段级处理)
python3 reverse_chk1_v2.py

# 32种标准CRC变体逐行XOR
python3 quick_test.py

# CRC-32/Adler-32/FNV-1a 截断 + 字段级测试
python3 test_more.py

# Phase 3A: 字段级XOR
python3 field_xor.py

# Phase 3E: 换行符变体
python3 line_ending_test.py

# Phase 3F: 非CRC哈希函数
python3 hash_test.py

# Phase 4C: MD5/SHA截断
python3 crypto_hash_test.py

# Phase 4D: Post-CRC变换
python3 post_crc_test.py

# Phase 4E/4F: 新假设测试
python3 hypothesis_test.py

# Split 算法猜测验证
python3 verify_split_guess.py

# Phase 7-8: 深度分析
python3 deep_analyze2.py         # 数据结构深度分析
python3 phase8b_analysis.py      # S2深度对比
python3 check_ptnr_xor.py        # PTNR数字XOR对比
python3 test_bcf_params.py       # BCF参数×Split数据范围
```

### C 语言暴力搜索 (需要 gcc)

```bash
# Phase 2: 逐行XOR CRC-16: 全部 32,768 个奇数多项式 (约2分钟)
gcc -O3 -o brute.exe brute.c && ./brute.exe

# Phase 2: 连续CRC + init=0xFFFF: 全部 32,768 个奇数多项式 (约4分钟)
gcc -O3 -o brute2.exe brute2.c && ./brute2.exe

# Phase 4A: GF(2)逐行XOR搜索: 全多项式×全init×4种refin/refout (~30分钟/模式)
gcc -O3 -o gf2_search_v2.exe gf2_search_v2.c && ./gf2_search_v2.exe

# Phase 5: GF(2)连续CRC搜索: BCF 3组解, Split 0匹配 (~72分钟)
gcc -O3 -o gf2_contig_search.exe gf2_contig_search.c && ./gf2_contig_search.exe

# Phase 7: 全模型 GF(2)搜索: 奇+偶多项式 × PTN/PTNR × ^BCF (~45分钟)
gcc -O3 -o gf2_split_search.exe gf2_split_search.c && ./gf2_split_search.exe

# Phase 8: PTN2-only GF(2)全搜索 (~14秒) [PTN2提取有bug, 结果不准确]
gcc -O3 -o gf2_ptn2_search.exe gf2_ptn2_search.c && ./gf2_ptn2_search.exe

# Phase 9: 逐行XOR GF(2)全搜索 (CHK1⊕BCF + all ranges + bug fix) (~2小时)
gcc -O3 -o gf2_perline_xor_search.exe gf2_perline_xor_search.c && ./gf2_perline_xor_search.exe

# Phase 10: 真·PTN2-only 连续CRC (修复提取bug + xorout) (~20秒)
gcc -O3 -o gf2_ptn2_fixed.exe gf2_ptn2_fixed.c && ./gf2_ptn2_fixed.exe

# Phase 10: CRC-8×2 组合16bit GF(2)全搜索 (<1秒)
gcc -O3 -o gf2_crc8_search.exe gf2_crc8_search.c && ./gf2_crc8_search.exe

# Phase 11: Group-Pair 与自定义哈希
python3 phase11_group_pair_analysis.py
python3 phase11b_custom_hash.py

# Phase 12: 差分分析与 Metadata 依赖
python3 diff_analysis.py

# Phase 10: Python 补充测试
python3 test_bcf_init.py          # BCF_CHK1 as init + 14 data ranges
python3 test_excluded.py          # 排除PTN2数据假设
```