@comate/zulu 1.3.3-internal.4 → 1.3.4-beta.1

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

@@ -26,11 +26,11 @@ func escapeLikeValue(s string) string {
 // 使用示例：WHERE name LIKE ?
 db.Query("SELECT * FROM users WHERE name LIKE ?", "%"+escapeLikeValue(keyword)+"%")
 ```
-4. 表名、列名、视图名称、DataBase 名称等拼接进入SQL 语句时需要进行过滤的方式修复漏洞，过滤使用的正则：`"^[\w\s\[\]"`$.,*]+$"`。
-5. show、create 、drop、grant 语句场景不支持预编译参数方式修复漏洞，需要使用对污点参数进行过滤的方法进行修复，过滤使用的正则：`"^[\w\s\[\]"`$.,*]+$"`。
-6. 对于 limit、SortBy、orderBy 等子句无法使用预编译，需要使用 `"^[\w\s\[\]"`$.,*]+$"` 过滤。
+4. 表名、列名、视图名称、DataBase 名称等拼接进入SQL 语句时需要进行白名单或者过滤的方式修复漏洞。
+5. show、create 、drop、grant 语句场景不支持预编译参数方式修复漏洞，需要使用对污点参数进行白名单或者过滤的方法进行修复。
+6. 对于 limit、SortBy、orderBy 等子句无法使用预编译，需要使用白名单或者正则过滤的方式修复。
 7. 当前框架支持安全写法时，优先使用框架安全写法，在无法使用安全写法时，才使用过滤等方案进行漏洞修复（注意不可修复场景不需要强行进行过滤修复）。
-8. 几何函数例如ST_GeometryN,第一个参数为列名，不支持预编译，如果污点数据传入，需要过滤 `"^[\w\s\[\]"`$.,*]+$"`，第二个参数支持预编译，使用预编译方式修复。
+8. 几何函数例如ST_GeometryN,第一个参数为列名，不支持预编译，如果污点数据传入，需要白名单或者正则过滤的方式修复 ，第二个参数支持预编译，使用预编译方式修复。
 9. SQL 语句拼接 in 的参数时，需要对其中的每个子项进行过滤或者预编译，如果适合修改成预编译，则进行参数个数的?替换，将参数放入查询参数中，优先进行预编译参数绑定。注意事项：(1) 过滤 IN 子项时，如果所有子项都被过滤，必须有兜底逻辑（如返回空结果或返回错误），不能生成空的 `IN ()`，否则会导致 SQL 语法错误；(2) 动态构建 IN 列表时，建议先收集合法项到新切片，再用 `strings.Join` 拼接，避免基于原始索引判断逗号导致的尾随逗号问题；(3) 某些数据库对单条 SQL 的参数数量有限制（如 SQLite 默认 999 个），大量 IN 参数需分批处理。
 
 **IN 子句预编译示例：**
@@ -251,6 +251,628 @@ safeParams, err := safeFilterQueryParams(params)
 if err != nil { return err }
 result, err := queryData(db, safeParams)
 ```
+##### 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 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterSelect 过滤 SELECT 列名列表
+// allowedColumns 为可选白名单，传入 nil 则仅做正则校验
+func safeFilterSelect(selectStr string, allowedColumns map[string]bool) (string, error) {
+    // 1. 先 TrimSpace 去除首尾空白
+    selectStr = strings.TrimSpace(selectStr)
+    // 2. 正则验证格式（支持引用符）
+    regex := `^(\*|(` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+)(,\s*(` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+))*))$`
+    matched, _ := regexp.MatchString(regex, selectStr)
+    if !matched {
+        return "", fmt.Errorf("invalid select columns")
+    }
+    // 3. 如果是通配符 *，直接允许
+    if selectStr == "*" {
+        return selectStr, nil
+    }
+    // 4. 提取列名并验证白名单
+    parts := regexp.MustCompile(`\s*,\s*`).Split(selectStr, -1)
+    for _, part := range parts {
+        // 去除引用符
+        cleanPart := strings.Trim(part, "`\"")
+        // 处理表名.列名格式，提取列名部分
+        column := cleanPart
+        if idx := strings.LastIndex(cleanPart, "."); idx != -1 {
+            column = cleanPart[idx+1:]
+        }
+        // 白名单验证（如果白名单不为空）
+        if allowedColumns != nil && len(allowedColumns) > 0 {
+            if !allowedColumns[strings.ToLower(strings.TrimSpace(column))] {
+                return "", fmt.Errorf("column not in whitelist: %s", column)
+            }
+        }
+    }
+    return selectStr, nil
+}
+```
+---
+
+###### 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 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterIdentifier 过滤 SQL 标识符（表名/列名/数据库名/索引名）
+// allowedIdentifiers 为可选白名单，传入 nil 则仅做正则校验
+func safeFilterIdentifier(identifier string, allowedIdentifiers map[string]bool) (string, error) {
+    // 1. 先 TrimSpace 去除首尾空白
+    identifier = strings.TrimSpace(identifier)
+    // 2. 正则验证格式（支持引用符）
+    regex := `^[A-Za-z_][A-Za-z0-9_]{0,127}$|^` + "`[^`]{1,128}`" + `$|^"[^"]{1,128}"$|^\[[^\]]{1,128}\]$`
+    matched, _ := regexp.MatchString(regex, identifier)
+    if !matched {
+        return "", fmt.Errorf("invalid identifier")
+    }
+    // 3. 去除引用符
+    cleanIdentifier := strings.Trim(identifier, "`\"[]")
+    // 4. 白名单验证（如果白名单不为空）
+    if allowedIdentifiers != nil && len(allowedIdentifiers) > 0 {
+        if !allowedIdentifiers[strings.ToLower(cleanIdentifier)] {
+            return "", fmt.Errorf("identifier not in whitelist: %s", cleanIdentifier)
+        }
+    }
+    return identifier, nil
+}
+```
+**说明**：
+
+* 表名、列名、数据库名、索引名等标识符都遵循相同的命名规范
+* 正则验证格式 + 白名单验证允许的值，双重保障
+* 如果白名单不完整或无法获取，可省略步骤 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 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterOrderBy 过滤 ORDER BY 子句
+// allowedColumns 为可选白名单，传入 nil 则仅做正则校验
+func safeFilterOrderBy(order string, allowedColumns map[string]bool) (string, error) {
+    // 1. 正则验证格式（不区分大小写）
+    regex := `(?i)^((` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+)(\s+(ASC|DESC))?(,\s*(` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+)(\s+(ASC|DESC))?)*)$`
+    matched, _ := regexp.MatchString(regex, order)
+    if !matched {
+        return "", fmt.Errorf("invalid order by clause")
+    }
+    // 2. 提取列名并验证白名单
+    parts := regexp.MustCompile(`\s*,\s*`).Split(order, -1)
+    for _, part := range parts {
+        // 提取列名部分（处理表名.列名格式）
+        columnPart := regexp.MustCompile(`\s+`).Split(part, -1)[0]
+        // 去除引用符
+        cleanPart := strings.Trim(columnPart, "`\"")
+        column := cleanPart
+        if idx := strings.LastIndex(cleanPart, "."); idx != -1 {
+            column = cleanPart[idx+1:]
+        }
+        // 白名单验证（如果白名单不为空）
+        if allowedColumns != nil && len(allowedColumns) > 0 {
+            if !allowedColumns[strings.ToLower(column)] {
+                return "", fmt.Errorf("column not in whitelist: %s", column)
+            }
+        }
+    }
+    return order, nil
+}
+```
+---
+
+###### 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 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterGroupBy 过滤 GROUP BY 子句
+// allowedColumns 为可选白名单，传入 nil 则仅做正则校验
+func safeFilterGroupBy(group string, allowedColumns map[string]bool) (string, error) {
+    // 1. 正则验证格式
+    regex := `^((` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+)(,\s*(` + "`[^`]+`" + `|"[^"]+"|\w+\.\w+|\w+))*)$`
+    matched, _ := regexp.MatchString(regex, group)
+    if !matched {
+        return "", fmt.Errorf("invalid group by clause")
+    }
+    // 2. 提取列名并验证白名单
+    parts := regexp.MustCompile(`\s*,\s*`).Split(group, -1)
+    for _, part := range parts {
+        // 去除引用符
+        cleanPart := strings.Trim(part, "`\"")
+        // 提取列名部分（处理表名.列名格式）
+        column := cleanPart
+        if idx := strings.LastIndex(cleanPart, "."); idx != -1 {
+            column = cleanPart[idx+1:]
+        }
+        // 白名单验证（如果白名单不为空）
+        if allowedColumns != nil && len(allowedColumns) > 0 {
+            if !allowedColumns[strings.ToLower(strings.TrimSpace(column))] {
+                return "", fmt.Errorf("column not in whitelist: %s", column)
+            }
+        }
+    }
+    return group, nil
+}
+```
+---
+
+###### 5. LIMIT/OFFSET `__LIMIT_FILTER__`
+**适用场景**：LIMIT、OFFSET 后的数值（如 `LIMIT 10`、`LIMIT 1,10`）
+
+**正则**：`^\d+\s*,\s*\d+$|^\d+$`
+
+**支持格式**：
+
+* `10` （单数字）
+* `1,10` （带偏移量）
+* `1, 10` （允许逗号前后空格）
+
+**AI 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterLimit 过滤 LIMIT/OFFSET 参数
+func safeFilterLimit(limit string) (string, error) {
+    // 1. 先 TrimSpace 去除首尾空白
+    limit = strings.TrimSpace(limit)
+    // 2. 正则验证纯数字
+    regex := `^\d+\s*,\s*\d+$|^\d+$`
+    matched, _ := regexp.MatchString(regex, limit)
+    if matched {
+        return limit, nil
+    }
+    return "", fmt.Errorf("invalid limit value")
+}
+```
+---
+
+###### 6. WHERE 条件 `__WHERE_FILTER__`
+**适用场景**：WHERE 子句、条件判断
+
+**策略**：**放弃正则，使用参数化查询**
+
+**AI 修复指引**：
+
+```go
+import "database/sql"
+
+// ❌ 错误：字符串拼接
+sql := fmt.Sprintf("SELECT * FROM users WHERE name = '%s'", name)
+
+// ✅ 正确：参数化查询（database/sql 使用 ?）
+rows, err := db.Query("SELECT * FROM users WHERE name = ?", name)
+
+// ✅ 正确：参数化查询（PostgreSQL 使用 $1, $2）
+rows, err := db.Query("SELECT * FROM users WHERE name = $1", name)
+
+// ✅ 正确：GORM 参数绑定
+db.Where("name = ?", name).First(&user)
+```
+---
+
+###### 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 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// ✅ 优先：参数化查询（动态生成占位符）
+func queryByIDs(db *sql.DB, ids []int64) ([]User, error) {
+    if len(ids) == 0 {
+        return []User{}, nil // 兜底：空列表直接返回空结果
+    }
+    placeholders := make([]string, len(ids))
+    args := make([]interface{}, len(ids))
+    for i, id := range ids {
+        placeholders[i] = "?"
+        args[i] = id
+    }
+    query := fmt.Sprintf("SELECT * FROM users WHERE id IN (%s)", strings.Join(placeholders, ","))
+    rows, err := db.Query(query, args...)
+    // ...
+}
+
+// ⚠️ 备选：严格正则验证（仅当无法参数化时）
+func safeFilterInClause(inClause string) (string, error) {
+    inClause = strings.TrimSpace(inClause)
+    regex := `^\(\s*\d+(\s*,\s*\d+)*\s*\)$`
+    matched, _ := regexp.MatchString(regex, inClause)
+    if matched {
+        return inClause, nil
+    }
+    return "", fmt.Errorf("invalid IN clause")
+}
+```
+---
+
+###### 8. 方向关键字 `__DIRECTION_FILTER__`
+**适用场景**：ORDER BY 后的 ASC/DESC
+
+**正则**：`^(asc|desc)$`
+
+**支持格式**：
+
+* `ASC` / `DESC` / `asc` / `desc` （不区分大小写）
+
+**AI 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+    "strings"
+)
+
+// safeFilterDirection 过滤排序方向（ASC/DESC）
+func safeFilterDirection(direction string) (string, error) {
+    // 正则验证（不区分大小写）
+    regex := `(?i)^(asc|desc)$`
+    matched, _ := regexp.MatchString(regex, direction)
+    if matched {
+        return strings.ToUpper(direction), nil
+    }
+    return "", fmt.Errorf("invalid direction")
+}
+```
+---
+
+###### 9. 纯字母数字标识符 `__W_FILTER__`
+**适用场景**：简单的表名、列名（无特殊字符）
+
+**正则**：`^[\w-]+$`
+
+**支持格式**：
+
+* `user_name` （下划线）
+* `User123` （字母数字）
+* `table-1` （连字符）
+
+**AI 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+)
+
+// safeFilterSimpleIdentifier 过滤简单标识符（字母数字下划线连字符）
+func safeFilterSimpleIdentifier(identifier string) (string, error) {
+    regex := `^[\w-]+$`
+    matched, _ := regexp.MatchString(regex, identifier)
+    if matched {
+        return identifier, nil
+    }
+    return "", fmt.Errorf("invalid identifier")
+}
+```
+---
+
+###### 10. 路径过滤 `__PATH_FILTER__`
+**适用场景**：文件路径、URL 路径
+
+**正则**：`^[\w/-]+$`
+
+**支持格式**：
+
+* `/path/to/file` （绝对路径）
+* `path/to/file` （相对路径）
+
+**AI 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+)
+
+// safeFilterPath 过滤文件路径/URL路径
+func safeFilterPath(path string) (string, error) {
+    regex := `^[\w/-]+$`
+    matched, _ := regexp.MatchString(regex, path)
+    if matched {
+        return path, nil
+    }
+    return "", fmt.Errorf("invalid path")
+}
+```
+---
+
+###### 11. 运算符 `__OP_FILTER__`
+**适用场景**：算术运算符（如 `score+1`）
+
+**正则**：`[+\-*/%]`
+
+**支持格式**：
+
+* `+` `-` `*` `/` `%` （基本算术运算符）
+
+**AI 修复指引**：
+
+```go
+import (
+    "fmt"
+    "regexp"
+)
+
+// safeFilterOperator 过滤算术运算符
+func safeFilterOperator(operator string) (string, error) {
+    regex := `^[+\-*/%]$`
+    matched, _ := regexp.MatchString(regex, operator)
+    if matched {
+        return operator, nil
+    }
+    return "", fmt.Errorf("invalid operator")
+}
+```
+---
+
+###### 正则速查表
+|过滤器|正则|说明|
+|-|-|-|
+|`__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__`|`` (?i)^((`[^`]+`\|"[^"]+"\|\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__`|`(?i)^(asc\|desc)$`|ASC 或 DESC|
+|`__W_FILTER__`|`^[\w-]+$`|字母数字+下划线+连字符|
+|`__PATH_FILTER__`|`^[\w/-]+$`|路径字符|
+|`__OP_FILTER__`|`^[+\-*/%]$`|算术运算符|
+
+**Go 语言正则使用示例**：
+```go
+import "regexp"
+
+// =====================================================
+// 重要：Go 正则字符串的两种写法（必须二选一，不能混用）
+// =====================================================
+
+// 方式1：原始字符串（推荐）- 反斜杠不需要转义
+regex := `^[\w\s\[\]"` + "`" + `$.,*]+$`
+matched, _ := regexp.MatchString(regex, input)
+
+// 方式2：普通字符串 - 反斜杠必须双重转义
+regex := "^[\\w\\s\\[\\]\"`$.,*]+$"
+matched, _ := regexp.MatchString(regex, input)
+
+// ❌ 错误写法（会导致编译错误或运行时错误）：
+// regex := "^[\w\s]+$"  // \w \s 不是有效的 Go 字符串转义！
+
+// 使用预编译正则（性能更好，适合多次使用）
+var identifierRegex = regexp.MustCompile(`^[\w-]+$`)
+matched := identifierRegex.MatchString(identifier)
+
+// 不区分大小写：在正则开头加 (?i)
+matched, _ := regexp.MatchString(`(?i)^(asc|desc)$`, direction)
+```
+
+**Go 正则转义对照表**：
+|正则元字符|原始字符串写法|普通字符串写法|
+|-|-|-|
+|`\w`|`` `\w` ``|`"\\w"`|
+|`\s`|`` `\s` ``|`"\\s"`|
+|`\d`|`` `\d` ``|`"\\d"`|
+|`\.`|`` `\.` ``|`"\\."`|
+|`\[`|`` `\[` ``|`"\\["`|
+|反引号 `` ` ``|需拼接：`` `a` + "`" + `b` ``|`"\`"`|
+
+---
+
+###### 重要提示
+1. **所有正则验证前，务必先 `strings.TrimSpace()` 去除首尾空白字符**
+2. **白名单优先**：列名/表名等固定值优先用白名单
+3. **白名单不完整时降级**：当白名单获取困难或不完整时，使用严格正则作为安全底线
+4. **参数化优先**：WHERE 条件、IN 子句优先用参数化查询
+5. **数据库适配**：根据使用的数据库类型选择对应的引用符和参数占位符
+6. **最小化改动**：只修复漏洞点，不重构其他代码
+7. **Go 正则特点**：Go 使用 RE2 引擎，不支持回溯，用 `(?i)` 实现大小写不敏感
+8. **Go 正则字符串写法（关键）**：
+   - 使用原始字符串 `` `...` `` 时，`\w` `\s` 等直接写，不需要转义
+   - 使用普通字符串 `"..."` 时，必须写成 `\\w` `\\s`（双重转义）
+   - **绝对不能**在普通字符串中写 `"\w"` `"\s"`，这会导致编译错误或运行时错误
+
 ## 各框架SQL注入风险与防护
 ### 1. 标准库 database/sql
 #### 风险示例
@@ -396,4 +1018,4 @@ Beego ORM同样存在直接拼接SQL导致注入的风险。
 // 安全: 使用参数化查询
 o.Raw("SELECT * FROM users WHERE username = ?", username).QueryRow(&user)
 ```
-## 
+##