集合运算：交集 &，差集 -，并集 +

在静态代码分析和安全审计中，集合运算是一种强大的工具，用于处理和分析代码中的数据流。SyntaxFlow 定义了一套集合运算的运算符，通过交集 (&)、差集 (-) 和并集 (+)，用户可以灵活地组合和修改数据集，以满足特定的分析需求。本文将详细介绍这些运算符的定义、使用方法以及实际应用中的注意事项。

• 简介
• 集合运算语法定义
  • 运算符概览
  • 语法结构
• 使用实例与解释
  • 案例一：识别共同的安全漏洞点
  • 案例二：排除已验证的危险数据流
  • 案例三：合并多来源的数据流进行全面分析
• 实战中的注意事项
  • 1. 确保集合变量的准确性
  • 2. 关注性能开销
  • 3. 理解运算符的优先级
  • 4. 处理空集情况
• 最佳实践
  • 1. 明确集合的来源和内容
  • 2. 组合使用不同的运算符
  • 3. 分模块编写规则
  • 4. 定期优化和测试规则
  • 5. 记录和注释规则逻辑
• 总结

简介

在代码审计过程中，常常需要对不同的数据流集合进行比较和操作。例如，您可能需要找出两个不同分析路径中共同的数据点，或排除某些已处理的数据点，甚至合并来自不同源的数据集以进行更全面的分析。集合运算通过提供交集、差集和并集运算符，简化了这些操作，使得审计过程更加高效和灵活。

SyntaxFlow 中的集合运算符如下：

• 交集运算符 &：找出两个集合中共有的元素。
• 差集运算符 -：从一个集合中移除存在于另一个集合中的元素。
• 并集运算符 +：合并两个集合的元素，结果集包含两个集合中的所有元素（重复的元素只保留一份）。

集合运算语法定义

运算符概览

运算符类型	描述	示例
交集 &	找出两个集合中共有的元素，用于识别共同的安全漏洞点或关键点	$callPoint & $filteredCall as $vuln
差集 -	从一个集合中移除存在于另一个集合中的元素，用于排除特定数据点	$callPoint - $filteredCall as $vuln
并集 +	合并两个集合的元素，结果集包含所有元素，用于组合不同数据源	$paramDirectly + $paramIndirectly as $vuln

语法结构

filterItem
    : filterItemFirst                            # First
    ...
    | '+' refVariable                            # MergeRefFilter
    | '-' refVariable                            # RemoveRefFilter
    | '&' refVariable                            # IntersectionRefFilter
    ...
    ;

• + refVariable：将当前集合与 refVariable 集合进行并集操作。
• - refVariable：将当前集合与 refVariable 集合进行差集操作。
• & refVariable：将当前集合与 refVariable 集合进行交集操作。

使用实例与解释

通过具体的代码案例，结合 SyntaxFlow 的语法规则，可以更直观地理解集合运算的应用。

案例一：识别共同的安全漏洞点

背景：在多个不同的数据流分析路径中，可能存在一些共同的安全漏洞点。通过交集运算符，可以识别出这些共同的关键点，帮助审计员集中注意力。

审计代码示例

public class ExampleVulnerabilities {
    public void methodA(String input) {
        // 潜在的漏洞点1
        String cmd = "ping " + input;
        Runtime.getRuntime().exec(cmd);
    }

    public void methodB(String input) {
        // 潜在的漏洞点2
        String cmd = "curl " + input;
        Runtime.getRuntime().exec(cmd);
    }
}

SyntaxFlow 规则案例

// 定义潜在的命令执行点
desc(title: "潜在的命令执行漏洞")

// 捕获所有通过 Runtime.exec 方法执行的命令
$callPoint = Runtime.exec(*);
    
// 捕获所有包含直接参数的命令执行调用
$directCalls = Runtime.exec($cmdDirectly) as $direct;

    
// 捕获所有包含间接参数的命令执行调用
$indirectCalls = Runtime.exec($cmdIndirectly) as $indirect;

// 识别同时存在于直接和间接调用中的漏洞点
$vulnerablePoints = $directCalls & $indirectCalls as $vuln;

// 输出结果
check $vuln then "共同的命令执行漏洞" else "未发现共同漏洞";

执行效果

执行以下命令进行审计：

yak ssa -t . --program vulnerable && yak sf --program vulnerable vuln_common.sf

输出示例：

[INFO] 2024-06-26 16:20:30 [ssacli:272] syntax flow query result:
rule md5 hash: a1b2c3d4e5f67890123456789abcdef0
rule preview: desc(title: "潜在的命令执行漏洞")...
description: {title: "潜在的命令执行漏洞", $vuln: "共同的命令执行漏洞"}
Result Vars:
  vuln:
    t1326001: Runtime.exec(cmdDirectly)
        ExampleVulnerabilities.java:5:34 - 5:54
    t1326002: Runtime.exec(cmdIndirectly)
        ExampleVulnerabilities.java:10:34 - 10:53

解释

• $callPoint = Runtime.exec(*);：捕获所有通过 Runtime.exec 方法执行的命令，并存储在 $callPoint 中。
• $directCalls 和 $indirectCalls：分别捕获直接和间接参数传递的命令执行调用。
• $vulnerablePoints = $directCalls & $indirectCalls as $vuln;：使用交集运算符 & 找出同时存在于直接和间接调用中的漏洞点。
• check $vuln then "共同的命令执行漏洞" else "未发现共同漏洞";：检查是否存在共同的命令执行漏洞，并输出相应的结果。

案例二：排除已验证的危险数据流

背景：在某些情况下，可能已经对部分数据流进行了验证或过滤，审计时需要排除这些已处理的数据流，以免产生误报。通过差集运算符，可以有效地排除这些已验证的数据点。

审计代码示例

public class SecureExample {
    public void processInput(String input) {
        // 已验证的数据流
        if (isValid(input)) {
            String cmd = "echo " + input;
            Runtime.getRuntime().exec(cmd);
        }
    }

    public boolean isValid(String input) {
        // 验证逻辑
        return input.matches("[a-zA-Z0-9]+");
    }
}

SyntaxFlow 规则案例

// 定义潜在的命令执行点
desc(title: "排除已验证的命令执行漏洞")

// 捕获所有通过 Runtime.exec 方法执行的命令
$allCalls = Runtime.exec(*);

// 捕获所有经过验证的命令执行调用
$validatedCalls = Runtime.exec($cmdValidated) as $validated;

// 排除已验证的命令执行调用
$unvalidatedCalls = $allCalls - $validatedCalls as $vuln;

// 输出结果
check $vuln then "未验证的命令执行漏洞" else "所有命令执行调用已验证";

执行效果

执行以下命令进行审计：

yak ssa -t . --program secure && yak sf --program secure secure_filter.sf

输出示例：

[INFO] 2024-06-26 16:45:50 [ssacli:272] syntax flow query result:
rule md5 hash: b1c2d3e4f5a67890123456789abcdef1
rule preview: desc(title: "排除已验证的命令执行漏洞")...
description: {title: "排除已验证的命令执行漏洞", $vuln: "未验证的命令执行漏洞"}
Result Vars:
  vuln:
    t1326101: Runtime.exec(cmdUnvalidated)
        SecureExample.java:6:34 - 6:54

解释

• $allCalls = Runtime.exec(*);：捕获所有通过 Runtime.exec 方法执行的命令，并存储在 $allCalls 中。
• $validatedCalls：捕获所有经过验证的命令执行调用。
• $unvalidatedCalls = $allCalls - $validatedCalls as $vuln;：使用差集运算符 - 从所有调用中排除已验证的调用，得到未验证的漏洞点。
• check $vuln then "未验证的命令执行漏洞" else "所有命令执行调用已验证";：检查是否存在未验证的命令执行漏洞，并输出相应的结果。

案例三：合并多来源的数据流进行全面分析

背景：有时需要将来自不同来源的数据流合并，以进行更全面的分析。例如，结合直接和间接传递的参数来识别潜在的漏洞。

审计代码示例

public class ComprehensiveExample {
    public void methodOne(String input) {
        String cmdDirect = "ls " + input;
        Runtime.getRuntime().exec(cmdDirect);
    }

    public void methodTwo(String input) {
        String cmdIndirect = "rm " + input;
        Runtime.getRuntime().exec(cmdIndirect);
    }
}

SyntaxFlow 规则案例

// 定义潜在的命令执行点
desc(title: "全面合并命令执行漏洞点")

// 捕获所有通过 Runtime.exec 方法执行的命令
$execCalls = Runtime.exec(*);

// 捕获直接传递的命令执行调用
$directCalls = Runtime.exec($cmdDirect) as $direct;

// 捕获间接传递的命令执行调用
$indirectCalls = Runtime.exec($cmdIndirect) as $indirect;

// 合并直接和间接调用的漏洞点
$combinedVulns = $directCalls + $indirectCalls as $vuln;

// 输出结果
check $combinedVulns then "发现命令执行漏洞点" else "未发现命令执行漏洞点";

执行效果

执行以下命令进行审计：

yak ssa -t . --program comprehensive && yak sf --program comprehensive comprehensive_merge.sf

输出示例：

[INFO] 2024-06-26 17:10:15 [ssacli:272] syntax flow query result:
rule md5 hash: c1d2e3f4a5b67890123456789abcdef2
rule preview: desc(title: "全面合并命令执行漏洞点")...
description: {title: "全面合并命令执行漏洞点", $vuln: "发现命令执行漏洞点"}
Result Vars:
  vuln:
    t1326201: Runtime.exec(cmdDirect)
        ComprehensiveExample.java:4:34 - 4:54
    t1326202: Runtime.exec(cmdIndirect)
        ComprehensiveExample.java:9:34 - 9:54

解释

• $execCalls = Runtime.exec(*);：捕获所有通过 Runtime.exec 方法执行的命令，并存储在 $execCalls 中。
• $directCalls 和 $indirectCalls：分别捕获直接和间接传递的命令执行调用。
• $combinedVulns = $directCalls + $indirectCalls as $vuln;：使用并集运算符 + 合并直接和间接调用的漏洞点。
• check $combinedVulns then "发现命令执行漏洞点" else "未发现命令执行漏洞点";：检查是否存在命令执行漏洞点，并输出相应的结果。

实战中的注意事项

在实际应用中，使用集合运算符时需要注意以下几点：

1. 确保集合变量的准确性

确保参与集合运算的变量准确无误。例如，使用正确的变量名和数据类型，避免因变量错误导致运算结果不正确。

2. 关注性能开销

在处理大型数据集时，集合运算可能会带来性能开销。建议在可能的情况下，优化集合的大小或运算顺序，以减少不必要的计算。

3. 理解运算符的优先级

在复杂的规则中，合理安排运算符的使用顺序，避免因为优先级问题导致逻辑错误。必要时，使用括号明确运算顺序。

4. 处理空集情况

在执行集合运算前，考虑可能存在的空集合情况，避免因空集导致的意外结果或错误。

最佳实践

为了充分发挥 SyntaxFlow 中集合运算的优势，建议遵循以下最佳实践：

1. 明确集合的来源和内容

在进行集合运算前，确保明确每个集合的来源和内容，以便理解运算结果的含义。例如，清晰定义哪些调用属于直接调用，哪些属于间接调用。

2. 组合使用不同的运算符

根据实际需求，灵活组合使用交集、差集和并集运算符，以实现复杂的数据流分析。例如，可以先使用差集排除已验证的数据，再使用交集找出共同的漏洞点。

3. 分模块编写规则

将复杂的集合运算任务分解为多个模块，每个模块专注于特定的运算或数据流处理，提升规则的可读性和可维护性。

4. 定期优化和测试规则

随着代码库的变化，定期优化和测试集合运算规则，确保其适应最新的代码结构和调用模式，保持审计的有效性和准确性。

5. 记录和注释规则逻辑

为复杂的集合运算规则添加详细的注释，记录运算逻辑和目的，便于后续维护和理解。

总结

集合运算在 SyntaxFlow 中提供了一种简洁而强大的方式来操作和分析代码中的数据流。通过交集 (&)、差集 (-) 和并集 (+) 运算符，用户能够灵活地组合、排除或扩展数据集，以满足特定的分析需求。结合实际案例的应用，本文展示了如何利用这些运算符识别共同的漏洞点、排除已验证的安全数据流以及合并多来源的数据进行全面分析。

掌握并应用上述集合运算方法和最佳实践，您将能够更高效地进行代码审计和安全分析，确保代码的整体安全性与稳定性。

---