@comate/zulu 1.3.3 → 1.3.4-beta.2

package/comate-engine/assets/skills/code-security-comate/references/vul_repair-java_sql_injection.md

@@ -38,8 +38,8 @@ public void processFileToSql(MultipartFile file, int recordId) throws Exception
 1. 基于当前数据流代码文件中进行漏洞修复，不要创建新的用于代码过滤的工具类文件，例如：在需要过滤表名列名的情况下，直接在当前 java 文件中建立通用的过滤函数，并在需要过滤的地方使用。（过滤方式参考过滤方式规则）
 2. 同个文件进行参数过滤时，可以在文件头定义过滤正则或者过滤函数，如果定义已经存在，直接复用。
 3. 当修复需要对**函数签名修改时，需要对函数进行重载**，避免修改函数签名导致原业务编译使用异常。
-4. 污点表名、列名、视图名称、DataBase 名称、order 信息、orderby 信息等拼接进入SQL 语句时需要进行过滤的方式修复漏洞，过滤使用的正则："^[\\w\\s\\[\\]\"`$.,*]+$"。（XML/JSON配置中可能为"^[\\w\\s\\[\\]\\\"`$.,*]+$", 注意这里的引号转义问题，避免转义失败导致语法错误）
-5. show、create 、drop、grant 语句场景不支持预编译参数方式修复漏洞，需要使用对污点参数进行过滤的方法进行修复，过滤使用的正则："^[\\w\\s\\[\\]\"`$.,*]+$"。（XML/JSON配置中可能为"^[\\w\\s\\[\\]\\\"`$.,*]+$", 注意这里的引号转义问题，避免转义失败导致语法错误）
+4. 污点表名、列名、视图名称、DataBase 名称、order 信息、orderby 信息等拼接进入SQL 语句时需要进行过滤的方式修复漏洞。
+5. show、create 、drop、grant 语句场景不支持预编译参数方式修复漏洞，需要使用对污点参数进行过滤的方法进行修复。
 6. SQL 语句拼接 in 的参数时，需要对其中的每个子项进行过滤或者预编译，如果适合修改成预编译，则**按照参数个数的对 in () 中的内容进行 ? 替换**（**即每个子项均进行参数预编译，NamedParameterJdbcTemplate和**`JPQL`**支持 in (:ids) 的除外**），将每个参数放入查询参数中，优先进行预编译参数绑定。
 7. 在 where 语句场景 field 操作符 value，如果 field 或者 操作符为污点信息，则进行过滤，如果 value 为污点数据，则进行预编译操作。
 8. 当污点拼接进入 sql 语句时，在分析确认需要通过预编译修复的时候，需要考虑 sql 语句的所在位置，例如有时 sql 语句为全局变量赋值到局部变量，改成预编译执行时，需要将当前函数变更为预编译方式，且需要变更全局 sql 语句为预编译方式，避免遗漏导致用户执行出错。
@@ -106,20 +106,22 @@ public void processFileToSql(MultipartFile file, int recordId) throws Exception
 ```
 3、**MyBatis/ORM 场景下对象属性过滤的特殊处理**：当污点数据通过对象属性传递到 MyBatis XML（如 `${page.orderBy}`、`${entity.tableName}` 等）时，需要根据赋值和读取方式选择正确的过滤位置：
 
-| 赋值方式 | 读取方式 | 过滤位置 |
-|---------|---------|---------|
-| 调用 setter | MyBatis `${obj.field}` 隐式访问 | **setter 中过滤** |
-| 调用 setter | 代码显式调用 getter | **setter 和 getter 都过滤** |
-| 构造函数/反射赋值 | 代码显式调用 getter | **getter 中过滤**（构造函数也建议加） |
-| 构造函数/反射赋值 | MyBatis `${obj.field}` 隐式访问 | **构造函数中过滤** |
+|赋值方式|读取方式|过滤位置|
+|-|-|-|
+|调用 setter|MyBatis `${obj.field}` 隐式访问|**setter 中过滤**|
+|调用 setter|代码显式调用 getter|**setter 和 getter 都过滤**|
+|构造函数/反射赋值|代码显式调用 getter|**getter 中过滤**（构造函数也建议加）|
+|构造函数/反射赋值|MyBatis `${obj.field}` 隐式访问|**构造函数中过滤**|
 
 **原理说明**：静态分析器存在两个追踪限制：
+
 1. **隐式调用不可见**：无法追踪 MyBatis OGNL 表达式对 getter 的隐式调用（如 `${obj.field}`），因此 getter 中的过滤对 MyBatis 隐式访问无效，必须在 setter/构造函数等赋值入口过滤。
 2. **对象级污点追踪**：当整个对象被标记为污点（如 Spring Controller 的 `@RequestBody` 参数），即使 setter 中已对某个字段做了过滤，后续通过显式 getter 调用获取该字段时，分析器仍可能因对象级污点而认为返回值是污点。此时需要在 getter 中也加过滤，让分析器在追踪 getter 方法体时命中清洗规则。
 
 **最佳实践：在 setter 和 getter 中同时过滤**，确保无论是 MyBatis 隐式访问还是代码显式调用 getter，都能被静态分析器识别到防护措施。构造函数中如有直接赋值也需过滤。
 
 **示例1：setter 赋值 + MyBatis 隐式访问 / 显式 getter 调用（setter 和 getter 都过滤）**
+
 ```java
 // 原始代码（有漏洞）
 public class Page<T> {
@@ -137,7 +139,7 @@ public class Page<T> {
 // 修复后（setter 和 getter 都过滤）
 public class Page<T> {
     private String orderBy;
-    private static final Pattern SAFE_PATTERN = Pattern.compile("^[\\w\\s\\[\\]\"`$.,*]+$");
+    private static final Pattern SAFE_PATTERN = Pattern.compile("^(\\*|((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*))$");
     
     private static String safeFilterOrderBy(String input) {
         if (input == null || input.isEmpty()) return "";
@@ -154,8 +156,8 @@ public class Page<T> {
     }
 }
 ```
-
 **示例2：构造函数赋值 + 显式 getter 调用（构造函数、setter、getter 都过滤）**
+
 ```java
 // 原始代码（有漏洞）
 public class Page<T> {
@@ -169,7 +171,7 @@ public class Page<T> {
 // 修复后（所有入口和出口都过滤）
 public class Page<T> {
     private String orderBy;
-    private static final Pattern SAFE_PATTERN = Pattern.compile("^[\\w\\s\\[\\]\"`$.,*]+$");
+    private static final Pattern SAFE_PATTERN = Pattern.compile("^(\\*|((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*))$");
     
     private static String safeFilterOrderBy(String input) {
         if (input == null || input.isEmpty()) return "";
@@ -190,9 +192,532 @@ public class Page<T> {
     }
 }
 ```
-
 **注意**：这种模式适用于所有通过 ORM/模板引擎（MyBatis、Hibernate、Freemarker 等）访问的对象属性。setter 和 getter 都加过滤虽然看似冗余，但因为静态分析器的两种限制（隐式调用不可见 + 对象级污点追踪），这是确保所有场景都能被识别到防护的最可靠方式。
 
+##### SQLi 正则过滤规范 
+###### 核心决策树
+```
+用户输入需要过滤？
+│
+├─ 是 SQL 标识符（表名/列名/数据库名/索引名）？
+│   └─ → 正则验证格式 + 白名单验证（双重保障）
+│
+├─ 是 SELECT 列表？
+│   └─ → 正则验证格式 + 提取列名后白名单验证
+│
+├─ 是 WHERE 条件/IN 子句？
+│   └─ → 使用参数化查询（强烈推荐）
+│
+├─ 是 ORDER BY/GROUP BY？
+│   └─ → 正则验证格式 + 提取列名后白名单验证
+│
+├─ 是 LIMIT/OFFSET？
+│   └─ → 正则验证纯数字
+│
+└─ 其他场景
+    └─ → 根据具体需求选择白名单或精确正则
+```
+---
+
+###### 白名单数据来源与处理策略
+###### 白名单数据从哪里来？
+|来源|说明|示例|
+|-|-|-|
+|**数据库元数据查询**|从数据库系统表查询实际存在的表/列名|`SELECT column_name FROM information_schema.columns WHERE table_name = 'users'`|
+|**代码静态分析**|扫描代码中定义的实体类、ORM 模型|JPA `@Entity`、MyBatis mapper、SQLAlchemy Model|
+|**配置文件/注解**|从配置文件或注解中提取允许的字段列表|`@AllowedFields({"id", "name", "email"})`|
+|**API 文档/接口定义**|从 Swagger/OpenAPI 等文档中提取字段定义||
+
+###### 白名单不完整时的处理策略
+```
+白名单验证失败？
+│
+├─ 白名单数据来源明确（如元数据查询、ORM 模型）？
+│   └─ → 拒绝输入，记录日志，提示用户
+│
+├─ 白名单数据来源不明确（如硬编码、不完整）？
+│   └─ → 降级为仅正则验证，记录警告日志
+│
+└─ 无法获取白名单（如动态表名）？
+    └─ → 仅正则验证格式，加强输入长度限制
+```
+**AI 修复决策原则**：
+
+1. **优先获取白名单**：如果代码中有 ORM 模型或实体类定义，优先从中提取字段列表
+2. **正则兜底**：当白名单获取困难或不完整时，使用严格正则作为安全底线
+3. **记录决策原因**：在代码注释中说明为什么选择正则而非白名单
+
+---
+
+###### 不同数据库的差异说明
+|数据库|标识符引用符|参数占位符|特殊注意事项|
+|-|-|-|-|
+|**MySQL**|反引号 ```|`?` 或 `:name`|支持反引号包裹标识符，如 `user_name`|
+|**PostgreSQL**|双引号 `"`|`$1, $2, ...` 或 `?`|支持双引号包裹标识符，如 `"user_name"`|
+|**SQL Server**|方括号 `[` `]`|`@param` 或 `?`|支持方括号包裹标识符，如 `[user_name]`|
+|**Oracle**|双引号 `"`|`:name` 或 `?`|标识符默认大写，双引号区分大小写|
+|**SQLite**|双引号 `"` 或方括号 `[` `]`|`?` 或 `:name`|兼容多种引用符|
+
+**AI 修复原则**：根据当前使用的数据库类型，选择对应的引用符和参数占位符。
+
+---
+
+###### 选择策略对比
+|场景|推荐策略|原因|
+|-|-|-|
+|SQL 标识符（表名/列名/数据库名/索引名）|正则 + 白名单|格式验证 + 值验证，双重保障|
+|SELECT 列表|正则 + 白名单|允许通配符 `*` 和多列，列名需白名单验证|
+|ORDER BY/GROUP BY|正则 + 白名单|格式验证 + 列名白名单 + 方向关键字（ASC/DESC）|
+|LIMIT/OFFSET|严格正则|只允许数字，不需要白名单|
+|WHERE 条件|**参数化查询**|正则过滤仍有风险，参数化最安全|
+|IN 子句|参数化查询优先|优先参数化，其次严格正则|
+
+---
+
+###### 各场景正则与实现
+###### 1. SELECT 列名列表 `__SELECT_FILTER__`
+**适用场景**：SELECT 后面的列名列表（如 `SELECT id,name,email FROM users` 或 `SELECT users.id,users.name FROM users`）
+
+**正则（通用版，支持引用符）**：
+
+```
+^(\*|((`[^`]+`|"[^"]+"|\w+\.\w+|\w+)(,\s*(`[^`]+`|"[^"]+"|\w+\.\w+|\w+))*))$
+```
+**支持格式**：
+
+* `*` （通配符）
+* `id` （单列）
+* `users.id` （表名.列名）
+* `user_name` （MySQL 反引号）
+* `"user_name"` （PostgreSQL/Oracle 双引号）
+* `id,name,email` （多列，逗号分隔）
+* `users.id, users.name, users.email` （带表名前缀的多列）
+* `id, name, email` （允许逗号前后空格）
+
+**AI 修复指引**：
+
+```java
+import java.util.regex.Pattern;
+import java.util.Set;
+
+// 定义过滤函数
+public static String safeFilterSelect(String select, Set<String> allowedColumns) {
+    // 1. 先 trim() 去除首尾空白
+    select = select.trim();
+    // 2. 正则验证格式（支持引用符）
+    String regex = "^(\\*|((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*))$";
+    if (!select.matches(regex)) {
+        return null; // 或抛出异常
+    }
+    // 3. 如果是通配符 *，直接允许
+    if ("*".equals(select)) {
+        return select;
+    }
+    // 4. 提取列名并验证白名单
+    String[] parts = select.split("\\s*,\\s*");
+    for (String part : parts) {
+        // 去除引用符
+        String cleanPart = part.replaceAll("^[`\"]|[`\"]$", "");
+        // 处理表名.列名格式，提取列名部分
+        String column = cleanPart.contains(".") ? cleanPart.substring(cleanPart.lastIndexOf(".") + 1) : cleanPart;
+        // 白名单验证（如果白名单不完整，跳过此步仅使用正则）
+        if (allowedColumns != null && !allowedColumns.isEmpty()) {
+            if (!allowedColumns.contains(column.toLowerCase().trim())) {
+                return null; // 或抛出异常
+            }
+        }
+    }
+    return select;
+}
+```
+---
+
+###### 2. SQL 标识符（表名/列名/数据库名/索引名）`__IDENTIFIER_FILTER__`
+**适用场景**：表名、列名、数据库名、索引名、视图名等 SQL 标识符
+
+**正则（通用版，支持引用符）**：
+
+```
+^[A-Za-z_][A-Za-z0-9_]{0,127}$|^`[^`]{1,128}`$|^"[^"]{1,128}"$
+```
+**支持格式**：
+
+* `user` （小写字母开头）
+* `User123` （字母数字）
+* `user_name` （下划线）
+* `_private` （下划线开头，部分数据库支持）
+* `user_name` （MySQL 反引号）
+* `"user_name"` （PostgreSQL/Oracle 双引号）
+* `[user_name]` （SQL Server 方括号）
+* 长度限制：1-128 字符
+
+**AI 修复指引**：
+
+```java
+import java.util.regex.Pattern;
+import java.util.Set;
+
+// 定义过滤函数
+public static String safeFilterIdentifier(String identifier, Set<String> allowedIdentifiers) {
+    // 1. 先 trim() 去除首尾空白
+    identifier = identifier.trim();
+    // 2. 正则验证格式（支持引用符）
+    String regex = "^[A-Za-z_][A-Za-z0-9_]{0,127}$|^`[^`]{1,128}`$|^\"[^\"]{1,128}\"$|^\\[[^\\]]{1,128}\\]$";
+    if (!identifier.matches(regex)) {
+        return null; // 或抛出异常
+    }
+    // 3. 去除引用符
+    String cleanIdentifier = identifier.replaceAll("^[`\"\\[]|[`\"\\]]$", "");
+    // 4. 白名单验证（如果白名单不完整，跳过此步仅使用正则）
+    if (allowedIdentifiers != null && !allowedIdentifiers.isEmpty()) {
+        if (!allowedIdentifiers.contains(cleanIdentifier.toLowerCase())) {
+            return null; // 或抛出异常
+        }
+    }
+    return identifier;
+}
+```
+**说明**：
+
+* 表名、列名、数据库名、索引名等标识符都遵循相同的命名规范
+* 正则验证格式 + 白名单验证允许的值，双重保障
+* 如果白名单不完整或无法获取，可省略步骤 4，仅使用正则验证
+
+---
+
+###### 3. ORDER BY `__ORDER_FILTER__`
+**适用场景**：ORDER BY 后的字段（如 `ORDER BY name ASC, id DESC` 或 `ORDER BY users.name ASC, users.id DESC`）
+
+**正则（通用版，支持引用符）**：
+
+```
+^((`[^`]+`|"[^"]+"|\w+\.\w+|\w+)(\s+(ASC|DESC))?(,\s*(`[^`]+`|"[^"]+"|\w+\.\w+|\w+)(\s+(ASC|DESC))?)*)$
+```
+**支持格式**：
+
+* `name` （单列）
+* `users.name` （表名.列名）
+* `user_name` （MySQL 反引号）
+* `"user_name"` （PostgreSQL/Oracle 双引号）
+* `name ASC` / `name DESC` （带方向）
+* `users.name ASC` / `users.name DESC` （带表名前缀和方向）
+* `name ASC, id DESC` （多列）
+* `users.name ASC, users.id DESC` （带表名前缀的多列）
+
+**AI 修复指引**：
+
+```java
+import java.util.regex.Pattern;
+import java.util.Set;
+
+// 定义过滤函数
+public static String safeFilterOrderBy(String order, Set<String> allowedColumns) {
+    // 1. 正则验证格式（不区分大小写）
+    String regex = "^((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(\\s+(ASC|DESC))?(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(\\s+(ASC|DESC))?)*)$";
+    Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
+    if (!pattern.matcher(order).matches()) {
+        return null; // 或抛出异常
+    }
+    // 2. 提取列名并验证白名单
+    String[] parts = order.split("\\s*,\\s*");
+    for (String part : parts) {
+        // 提取列名部分（处理表名.列名格式）
+        String columnPart = part.split("\\s+")[0];
+        // 去除引用符
+        String cleanPart = columnPart.replaceAll("^[`\"]|[`\"]$", "");
+        String column = cleanPart.contains(".") ? cleanPart.substring(cleanPart.lastIndexOf(".") + 1) : cleanPart;
+        // 白名单验证（如果白名单不完整，跳过此步仅使用正则）
+        if (allowedColumns != null && !allowedColumns.isEmpty()) {
+            if (!allowedColumns.contains(column.toLowerCase())) {
+                return null; // 或抛出异常
+            }
+        }
+    }
+    return order;
+}
+```
+---
+
+###### 4. GROUP BY `__GROUP_FILTER__`
+**适用场景**：GROUP BY 后的字段（如 `GROUP BY name, age` 或 `GROUP BY users.name, users.age`）
+
+**正则（通用版，支持引用符）**：
+
+```
+^((`[^`]+`|"[^"]+"|\w+\.\w+|\w+)(,\s*(`[^`]+`|"[^"]+"|\w+\.\w+|\w+))*)$
+```
+**支持格式**：
+
+* `name` （单列）
+* `users.name` （表名.列名）
+* `user_name` （MySQL 反引号）
+* `"user_name"` （PostgreSQL/Oracle 双引号）
+* `name, age` （多列）
+* `users.name, users.age` （带表名前缀的多列）
+
+**AI 修复指引**：
+
+```java
+import java.util.Set;
+
+// 定义过滤函数
+public static String safeFilterGroupBy(String group, Set<String> allowedColumns) {
+    // 1. 正则验证格式
+    String regex = "^((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*)$";
+    if (!group.matches(regex)) {
+        return null; // 或抛出异常
+    }
+    // 2. 提取列名并验证白名单
+    String[] parts = group.split("\\s*,\\s*");
+    for (String part : parts) {
+        // 去除引用符
+        String cleanPart = part.replaceAll("^[`\"]|[`\"]$", "");
+        // 提取列名部分（处理表名.列名格式）
+        String column = cleanPart.contains(".") ? cleanPart.substring(cleanPart.lastIndexOf(".") + 1) : cleanPart;
+        // 白名单验证（如果白名单不完整，跳过此步仅使用正则）
+        if (allowedColumns != null && !allowedColumns.isEmpty()) {
+            if (!allowedColumns.contains(column.toLowerCase().trim())) {
+                return null; // 或抛出异常
+            }
+        }
+    }
+    return group;
+}
+```
+---
+
+###### 5. LIMIT/OFFSET `__LIMIT_FILTER__`
+**适用场景**：LIMIT、OFFSET 后的数值（如 `LIMIT 10`、`LIMIT 1,10`）
+
+**正则**：`^\d+\s*,\s*\d+$|^\d+$`
+
+**支持格式**：
+
+* `10` （单数字）
+* `1,10` （带偏移量）
+* `1, 10` （允许逗号前后空格）
+
+**AI 修复指引**：
+
+```java
+// 定义过滤函数
+public static String safeFilterLimit(String limit) {
+    // 1. 先 trim() 去除首尾空白
+    limit = limit.trim();
+    // 2. 正则验证纯数字
+    if (limit.matches("^\\d+\\s*,\\s*\\d+$|^\\d+$")) {
+        return limit;
+    }
+    return null; // 或抛出异常
+}
+```
+---
+
+###### 6. WHERE 条件 `__WHERE_FILTER__`
+**适用场景**：WHERE 子句、条件判断
+
+**策略**：**放弃正则，使用参数化查询**
+
+**AI 修复指引**：
+
+```java
+// ❌ 错误：字符串拼接
+String sql = "SELECT * FROM users WHERE name = '" + name + "'";
+
+// ✅ 正确：参数化查询（MySQL/SQLite 使用 ?）
+String sql = "SELECT * FROM users WHERE name = ?";
+PreparedStatement stmt = conn.prepareStatement(sql);
+stmt.setString(1, name);
+
+// ✅ 正确：参数化查询（PostgreSQL 使用 $1, $2）
+String sql = "SELECT * FROM users WHERE name = $1";
+PreparedStatement stmt = conn.prepareStatement(sql);
+stmt.setString(1, name);
+
+// ✅ 正确：参数化查询（SQL Server 使用 @param）
+String sql = "SELECT * FROM users WHERE name = @name";
+PreparedStatement stmt = conn.prepareStatement(sql);
+stmt.setString("@name", name);
+```
+---
+
+###### 7. IN 子句 `__IN_FILTER__`
+**适用场景**：IN 后面的值列表（如 `IN (1,2,3)`）
+
+**策略**：优先参数化查询，其次严格正则
+
+**正则**：
+
+* 数字：`^\(\s*\d+(\s*,\s*\d+)*\s*\)$`
+* 字符串：`^\(\s*'[^']*'(\s*,\s*'[^']*')*\s*\)$`
+
+**支持格式**：
+
+* `(1,2,3)` （数字列表）
+* `('a','b','c')` （字符串列表）
+* `(1, 2, 3)` （允许逗号前后空格）
+
+**AI 修复指引**：
+
+```java
+// ✅ 优先：参数化查询（MySQL/SQLite 使用 ?）
+String sql = "SELECT * FROM users WHERE id IN (?, ?, ?)";
+PreparedStatement stmt = conn.prepareStatement(sql);
+stmt.setInt(1, id1);
+stmt.setInt(2, id2);
+stmt.setInt(3, id3);
+
+// ✅ 优先：参数化查询（PostgreSQL 使用 $1, $2）
+String sql = "SELECT * FROM users WHERE id IN ($1, $2, $3)";
+PreparedStatement stmt = conn.prepareStatement(sql);
+stmt.setInt(1, id1);
+stmt.setInt(2, id2);
+stmt.setInt(3, id3);
+
+// ⚠️ 备选：严格正则验证（仅当无法参数化时）
+String inClause = inClause.trim();
+if (!inClause.matches("^\\(\\s*\\d+(\\s*,\\s*\\d+)*\\s*\\)$")) {
+    return false;
+}
+```
+---
+
+###### 8. 方向关键字 `__DIRECTION_FILTER__`
+**适用场景**：ORDER BY 后的 ASC/DESC
+
+**正则**：`^(asc|desc)$`
+
+**支持格式**：
+
+* `ASC` / `DESC` / `asc` / `desc` （不区分大小写）
+
+**AI 修复指引**：
+
+```java
+import java.util.regex.Pattern;
+
+// 定义过滤函数
+public static String safeFilterDirection(String direction) {
+    // 正则验证（不区分大小写）
+    Pattern pattern = Pattern.compile("^(asc|desc)$", Pattern.CASE_INSENSITIVE);
+    if (pattern.matcher(direction).matches()) {
+        return direction.toUpperCase();
+    }
+    return null; // 或抛出异常
+}
+```
+---
+
+###### 9. 纯字母数字标识符 `__W_FILTER__`
+**适用场景**：简单的表名、列名（无特殊字符）
+
+**正则**：`^[\w-]+$`
+
+**支持格式**：
+
+* `user_name` （下划线）
+* `User123` （字母数字）
+* `table-1` （连字符）
+
+**AI 修复指引**：
+
+```java
+// 定义过滤函数
+public static String safeFilterSimpleIdentifier(String identifier) {
+    if (identifier.matches("^[\\w-]+$")) {
+        return identifier;
+    }
+    return null; // 或抛出异常
+}
+```
+---
+
+###### 10. 路径过滤 `__PATH_FILTER__`
+**适用场景**：文件路径、URL 路径
+
+**正则**：`^[\w/-]+$`
+
+**支持格式**：
+
+* `/path/to/file` （绝对路径）
+* `path/to/file` （相对路径）
+
+**AI 修复指引**：
+
+```java
+// 定义过滤函数
+public static String safeFilterPath(String path) {
+    if (path.matches("^[\\w/-]+$")) {
+        return path;
+    }
+    return null; // 或抛出异常
+}
+```
+---
+
+###### 11. 运算符 `__OP_FILTER__`
+**适用场景**：算术运算符（如 `score+1`）
+
+**正则**：`[+\-*/%]`
+
+**支持格式**：
+
+* `+` `-` `*` `/` `%` （基本算术运算符）
+
+**AI 修复指引**：
+
+```java
+// 定义过滤函数
+public static String safeFilterOperator(String operator) {
+    if (operator.matches("^[+\\-*/%]$")) {
+        return operator;
+    }
+    return null; // 或抛出异常
+}
+```
+---
+
+###### 正则速查表
+|过滤器|正则|说明|
+|-|-|-|
+|`__IDENTIFIER_FILTER__`|`^[A-Za-z_][A-Za-z0-9_]{0,127}$\|^`[^`]{1,128}`$\|^"[^"]{1,128}"$`|SQL 标识符，支持反引号/双引号，1-128字符|
+|`__SELECT_FILTER__`|`^(\*\|((`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+)(,\s*(`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+))*))$`|允许通配符 `*` 和逗号分隔的列名|
+|`__ORDER_FILTER__`|`^((`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+)(\s+(ASC\|DESC))?(,\s*(`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+)(\s+(ASC\|DESC))?)*)$`|列名 + 方向关键字（不区分大小写）|
+|`__GROUP_FILTER__`|`^((`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+)(,\s*(`[^`]+`\|"[^"]+"\|\w+\.\w+\|\w+))*)$`|多列，逗号分隔|
+|`__LIMIT_FILTER__`|`^\d+\s*,\s*\d+$\|^\d+$`|纯数字，允许逗号|
+|`__WHERE_FILTER__`|**参数化查询**|不要用正则|
+|`__IN_FILTER__`|`^\(\s*\d+(\s*,\s*\d+)*\s*\)$`|数字列表|
+|`__DIRECTION_FILTER__`|`^(asc\|desc)$`|ASC 或 DESC（不区分大小写）|
+|`__W_FILTER__`|`^[\w-]+$`|字母数字+下划线+连字符|
+|`__PATH_FILTER__`|`^[\w/-]+$`|路径字符|
+|`__OP_FILTER__`|`^[+\-*/%]$`|算术运算符|
+
+**Java 正则使用注意事项**：
+```java
+// 1. Java 字符串中反斜杠需要双重转义
+String regex = "^\\w+$";  // 匹配 \w+
+
+// 2. String.matches() 不支持传入 Pattern 标志，需使用 Pattern.compile()
+// 错误写法：
+// str.matches(regex, Pattern.CASE_INSENSITIVE);  // 编译错误！
+// 正确写法：
+Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
+boolean matched = pattern.matcher(str).matches();
+
+// 3. 反引号 ` 在 Java 正则中不需要转义
+String regex = "^`[^`]+`$";  // 匹配反引号包裹的标识符
+```
+
+---
+
+###### 重要提示
+1. **所有正则验证前，务必先 **`trim()`** 去除首尾空白字符**
+2. **白名单优先**：列名/表名等固定值优先用白名单
+3. **白名单不完整时降级**：当白名单获取困难或不完整时，使用严格正则作为安全底线
+4. **参数化优先**：WHERE 条件、IN 子句优先用参数化查询
+5. **数据库适配**：根据使用的数据库类型选择对应的引用符和参数占位符
+6. **最小化改动**：只修复漏洞点，不重构其他代码
+
 ### 修复后的检查点
 1. 检查补丁代码其中参数是否在当前函数范围。
 2. 检查补丁代码是否存在语法异常问题，例如正则中引号转义失败，导致非预期字符串闭合问题。
@@ -286,15 +811,16 @@ public class TestServiceImp implements TestService {
 
 
 ```java
-if (!tableName.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+if (!tableName.matches("^(\\*|((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*))$")) {
     throw new IllegalArgumentException("Invalid tableName");
 }
-if (!order.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+if (!order.matches("^((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(\\s+(ASC|DESC))?(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(\\s+(ASC|DESC))?)*)$")) {
     throw new IllegalArgumentException("Invalid order");
 }
 ```
-    * 使用 `#` 绑定参数传递普通值, 例如，这里的${username} 改为 #{username} 。
-
+```
+* 使用 `#` 绑定参数传递普通值, 例如，这里的${username} 改为 #{username} 。
+```
 ```java
 <select id="getUserByName" resultType="User">
     SELECT * FROM ${tableName} WHERE username = #{username} order by ${order}
@@ -379,7 +905,7 @@ List<User> users = entityManager.createQuery(cq).getResultList();
 CriteriaBuilder cb = entityManager.getCriteriaBuilder();
 CriteriaQuery<User> cq = cb.createQuery(User.class);
 Root<User> user = cq.from(User.class);
-if (!username.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+if (!username.matches("^[A-Za-z_][A-Za-z0-9_]{0,127}$")) {
     throw new IllegalArgumentException("Invalid username");
 }
 cq.where(cb.equal(user.get("username"), username));
@@ -443,10 +969,10 @@ ResultSet rs = stmt.executeQuery(baseQuery);
 * **修复**：对表名、列名进行正则过滤，对条件直使用 `PreparedStatement` 动态绑定参数：
 
 ```java
-if (!addr.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+if (!addr.matches("^(\\*|((`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+)(,\\s*(`[^`]+`|\"[^\"]+\"|\\w+\\.\\w+|\\w+))*))$")) {
     throw new IllegalArgumentException("Invalid column addr");
 }
-if (!userTable.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+if (!userTable.matches("^[A-Za-z_][A-Za-z0-9_]{0,127}$")) {
     throw new IllegalArgumentException("Invalid userTable");
 }
 StringBuilder sb = new StringBuilder("SELECT id,username,email," + addr + " FROM " + userTable + " WHERE 1=1");
@@ -465,8 +991,6 @@ for (int i = 0; i < params.size(); i++) {
 }
 ResultSet rs = pstmt.executeQuery();
 ```
-
-
 ### 9. **组合条件查询中的动态拼接3**
 * **场景**：在复杂查询中，动态拼接条件时未使用参数化查询，且被其他函数使用。
 * **示例**：