VM还原触发SDK检测的深度分析与修复#

1
if (t < 38) {
2
    if (t < 19) {
3
        if (t < 9) {
4
            if (t < 4) {
5
                if (t < 2) {
6
                    if (0 === t) { ... }
7
                    else { ... }  // 操作码1
8
                } else {
9
                    if (2 === t) { ... }
10
                    else { ... }  // 操作码3
11
                }
12
            } else {
13
                // 操作码4-8
14
            }
15
        } else {
16
            // 操作码9-18
17
        }
18
    } else {
19
        // 操作码19-37
20
    }
21
} else {
22
    // 操作码38-75
23
}

1
function parseRange(testPath) {
2
    if (!testPath || testPath.type !== 'BinaryExpression') return null;
3

4
    const left = testPath.get('left');
5
    const right = testPath.get('right');
6
    const op = testPath.get('operator').node;
7

8
    if (left.type === 'Identifier' && left.node.name === 't') {
9
        if (right.type === 'NumericLiteral') {
10
            const num = right.node.value;
11
            switch (op) {
12
                case '<':
13
                    return { min: -Infinity, max: num };
14
                case '<=':
15
                    return { min: -Infinity, max: num + 1 };
16
                case '>':
17
                    return { min: num + 1, max: Infinity };
18
                case '>=':
19
                    return { min: num, max: Infinity };
20
                case '===':
21
                case '==':
22
                    return { min: num, max: num + 1 };  // 真区间
23
                case '!==':
24
                case '!=':
25
                    return { min: num, max: num + 1 };  // 假区间！
26
            }
27
        }
28
    }
29
    // 处理反向情况 (num === t)
30
    else if (right.type === 'Identifier' && right.node.name === 't') {
31
        // ... 类似处理
32
    }
33
    return null;
34
}

1
function squeezeRange(path, currentRange) {
2
    const testPath = path.get('test');
3
    const range = parseRange(testPath);
4

5
    if (!range) return;
6

7
    // 对于 !== 操作符，parseRange返回的是假区间
8
    const testOp = testPath.get('operator').node;
9
    const isNotEqual = testOp === '!==' || testOp === '!=';
10

11
    // 计算当前分支的实际区间
12
    let branchRange;
13
    if (isNotEqual) {
14
        // !== 的真分支区间是当前区间减去假区间
15
        // 即：条件为真时，t 不等于 num
16
        branchRange = { min: currentRange.min, max: range.min };
17
    } else {
18
        // 其他操作符的真分支区间是当前区间与parseRange结果的交集
19
        branchRange = intersect(currentRange, range);
20
    }
21

22
    // 处理 consequent 分支（条件为真时执行）
23
    const consequent = path.get('consequent');
24
    // ... 处理真分支代码
25

26
    // 处理 alternate 分支（条件为假时执行）
27
    const alternate = path.get('alternate');
28
    if (alternate.node) {
29
        // 对于 !==，假分支区间就是 parseRange 返回的区间
30
        // 对于其他操作符，需要根据操作符类型计算假分支区间
31
        let elseRangeRaw;
32
        const testOp = testPath.get('operator').node;
33
        if (testOp === '<') {
34
            elseRangeRaw = { min: range.max, max: Infinity };
35
        } else if (testOp === '<=') {
36
            elseRangeRaw = { min: range.max, max: Infinity };
37
        } else if (testOp === '>' || testOp === '>=') {
38
            elseRangeRaw = { min: -Infinity, max: range.min };
39
        } else if (testOp === '===' || testOp === '==' || testOp === '!==' || testOp === '!=') {
40
            elseRangeRaw = { min: currentRange.min, max: currentRange.max };
41
        }
42

43
        const elseRange = intersect(currentRange, elseRangeRaw);
44
        // ... 处理假分支代码
45
    }
46
}

1
if (52 === t)
2
    return U = o[a++], f = 1, void (l = a + U);
3
U = o[a++], a += U;  // 这是操作码53的代码，但不是显式的else分支

1
if (75 !== t)
2
    return f = 2, void (l = v[p--]);
3
v[++p] = null  // 这是操作码75的代码，隐式else分支

1
// 特殊处理：如果BlockStatement中有if语句和其他语句，其他语句可能是if的else分支
2
if (body.length === 2 && body[0].isIfStatement() && !body[0].node.alternate) {
3
    const ifStmt = body[0];
4
    const elseStmt = body[1];  // 第二个语句是隐式else
5

6
    const ifTestPath = ifStmt.get('test');
7
    const ifRange = parseRange(ifTestPath);
8

9
    if (ifRange && (ifTestPath.get('operator').node === '===' || ifTestPath.get('operator').node === '!==')) {
10
        const op = ifTestPath.get('operator').node;
11

12
        if (op === '===') {
13
            // 对于 === 条件，隐式else区间是去掉这个精确值
14
            const elseRange1 = { min: branchRange.min, max: ifRange.min };
15
            const elseRange2 = { min: ifRange.max, max: branchRange.max };
16

17
            storeOpcode(intersect(branchRange, elseRange1), elseStmt.node);
18
            storeOpcode(intersect(branchRange, elseRange2), elseStmt.node);
19
            squeezeRange(ifStmt, branchRange);  // 递归处理if语句
20
        } else if (op === '!==') {
21
            // 对于 !== 条件，隐式else区间就是if的精确值（当条件为假时）
22
            const elseRange = { min: ifRange.min, max: ifRange.max };
23

24
            storeOpcode(intersect(branchRange, elseRange), elseStmt.node);
25
            // 不要递归处理if语句！它的consequent属于不同的区间
26
        }
27
    }
28
}

1
else if (t < 75) {
2
    // ... 操作码70-74
3
} else {
4
    // 这个else块的区间是 [75, +∞)
5
    if (75 !== t)
6
        return f = 2, void (l = v[p--]);
7
    v[++p] = null
8
}

1
elseBody.forEach((stmtPath, index) => {
2
    if (stmtPath.isIfStatement()) {
3
        // 检查是否是 "num !== t" 的模式
4
        const test = stmtPath.get('test');
5
        if (test.type === 'BinaryExpression' && test.get('operator').node === '!==') {
6
            const num = extractNumericValue(test);
7
            if (num !== null) {
8
                // 设置隐式else区间：t == num
9
                implicitElseRange = { min: num, max: num + 1 };
10
            }
11
        }
12
        squeezeRange(stmtPath, elseRange);
13
    } else if (stmtPath.isExpressionStatement()) {
14
        // 如果前面有 "if (num !== t)"，使用隐式else区间
15
        const rangeToUse = implicitElseRange || elseRange;
16
        storeOpcode(rangeToUse, stmtPath.node);
17
    }
18
});

1
else代码块处理流程
2
│
3
├─ 遍历body中的语句
4
│   │
5
│   ├─ 发现 if (75 !== t)
6
│   │   ├─ 提取 num = 75
7
│   │   ├─ 设置 implicitElseRange = [75, 76)
8
│   │   └─ 调用 squeezeRange 处理if语句（不存储）
9
│   │
10
│   ├─ 发现 v[++p] = null
11
│   │   ├─ 检查 implicitElseRange 是否已设置
12
│   │   ├─ 使用 implicitElseRange = [75, 76) 作为区间
13
│   │   └─ storeOpcode([75, 76), v[++p] = null)
14
│   │       ├─ isSingleInt([75, 76)) = true
15
│   │       └─ 存储到 stream[75]
16
│   │
17
│   └─ 继续处理后续语句...

1
收集到的操作码数量: 76
2
操作码列表: [
3
  '0', '1', '2', ..., '75'  // 全部76个操作码
4
]

1
case 75:
2
    v[++p] = null;  // ✅ 正确！
3
    break;