@comate/zulu 1.2.1-beta.1 → 1.3.0

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

@@ -0,0 +1,591 @@
+JAVA SQL 注入漏洞修复知识
+
+# Java sqli 漏洞修复最佳实践
+采用先分析漏洞报告->分析数据传递链路->判断是否存在依赖->分析修复方式（判断是否可以修复、使用哪种修复方式）->修复漏洞->验证是否存在语法问题和依赖问题（注意：**不要做与漏洞修复无关的代码改动**）。
+
+## 漏洞分析
+### 不可修复场景
+1. sql 语句为外部包生成或者传入(例如：request 参数、用户文件上传后读取等)，无法通过当前数据流链路的函数或者源码中找到定义或者生成方法，无法确定 sql 语句的信息，这里作为不可修复场景，不进行漏洞修复。
+2. 污点数据以select、update、delete 等子句拼接到 sql 语句时，且无法确定污点数据子句具体信息，为不可修复场景，不进行漏洞修复。
+3. 明确的知道传入的数据为表名、列名或列名列表等，表示可修复，参考可修复场景进行修复。
+
+示例：
+
+```java
+//sql 从外部 form requestbody 或者 request 请求数据 中直接输入
+public StreamingResponseBody queryDataBySql(@RequestBody MetaDataSqlForm form){
+    String sql = form.sql; //sql 语句直接通过外部参数传递进来，无法知道 sql 具体内容，所以不能简单的进行过滤修复，返回不可修复
+    PreparedStatement stmt = conn.prepareStatement(sql);
+}
+
+//Condition 从外部 form requestbody 或者 request 请求数据 中直接输入
+public StreamingResponseBody queryDataBySql(@RequestBody MetaDataSqlForm form){
+    String whereCondition = form.condition; 
+    String sql = "select * from user " + whereCondition; //外部输入了新的子句，但是子句无法知道具体内容，无法通过过滤修复，返回不可修复
+    PreparedStatement stmt = conn.prepareStatement(sql);
+} 
+// 从外部文件输入
+public void processFileToSql(MultipartFile file, int recordId) throws Exception {
+        String fileContent;
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(file.getInputStream()))) {
+            fileContent = reader.lines().collect(Collectors.joining("\n"));
+        }
+        String sql = fileContent; //sql 语句直接通过外部参数传递进来，无法知道 sql 具体内容，所以不能简单的进行过滤修复，返回不可修复
+        PreparedStatement stmt = conn.prepareStatement(sql);
+} 
+```
+### 可修复场景
+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\\[\\]\\\"`$.,*]+$", 注意这里的引号转义问题，避免转义失败导致语法错误）
+6. SQL 语句拼接 in 的参数时，需要对其中的每个子项进行过滤或者预编译，如果适合修改成预编译，则**按照参数个数的对 in () 中的内容进行 ? 替换**（**即每个子项均进行参数预编译，NamedParameterJdbcTemplate和**`JPQL`**支持 in (:ids) 的除外**），将每个参数放入查询参数中，优先进行预编译参数绑定。
+7. 在 where 语句场景 field 操作符 value，如果 field 或者 操作符为污点信息，则进行过滤，如果 value 为污点数据，则进行预编译操作。
+8. 当污点拼接进入 sql 语句时，在分析确认需要通过预编译修复的时候，需要考虑 sql 语句的所在位置，例如有时 sql 语句为全局变量赋值到局部变量，改成预编译执行时，需要将当前函数变更为预编译方式，且需要变更全局 sql 语句为预编译方式，避免遗漏导致用户执行出错。
+9. mybatis 场景下，漏洞触发为 xml 文件时，需要通过参数传递链路，从 java 代码文件层面找到合适的位置，对污点参数进行过滤。例如表名、列名、orderby 和 in 等参数场景，无法直接通过将 $ 改为 # 绑定参数或预编译。
+10. 对于同一个参数进行漏洞修复时，只需要采取一种修复方式即可，不要同时对一个参数进行预编译、参数绑定和过滤等多种方式。
+11. 当污点数据拼接进入到 sql ，需要详细分析当前函数是否还存在其他地方使用了该 sql，避免因为采用预编译修复方案，导致其他使用该 sql 的场景存在异常；如果其他使用的场景在当前文件中，可以统一进行预编译方式修改，得对函数需要重载，保障其他文件调用正常。
+
+#### 过滤方式规则
+1、对于需要过滤或者正则校验进行防护的参数在后续使用时为直接拼接或者传递，可以直接通过正则过滤；如果使用的是某个对象的成员或者可迭代对象时，后续直接使用的是『对象.成员函数()』的，**使用临时变量承接过滤函数过滤后的结果, 函数起名以 safeFilter 或者safeValidate 开头（如果不存在需要在当前文件中定义，只有存在的函数才能使用），过滤后使用新的对象进行传递（保障后续数据流检测可以识别到该防护，即用安全的函数截断数据流）**。例如：
+
+```java
+//原始代码
+       if (CollectionUtils.isNotEmpty(param.getOrgIdList())) {
+            sb.append(" AND txf.org_id IN " + SqlUtils.getInSql(param.getOrgIdList())); // 原始代码，param.getOrgIdList() 外部传入的误点参数
+        }
+....
+// 定义过滤函数，返回一个新的 list 对象
+    public static List<String> safeFilterOrgIdList(List<String> input) {
+        if (input == null) return null;
+        Pattern ID_PATTERN = Pattern.compile("^\\d+$");
+        return input.stream()
+                .filter(item -> item != null && !item.trim().isEmpty()) // 判空
+                .filter(item -> ID_PATTERN.matcher(item).matches())    // 正则匹配
+                .collect(Collectors.toList());
+    }
+// 修复后的代码
+    if (CollectionUtils.isNotEmpty(param.getOrgIdList())) {
+        // 1. 先过滤非法参数
+        List<String> cleanList = safeFilterOrgIdList(param.getOrgIdList());
+        
+        // 2. 只有过滤后仍有值，才拼接 SQL，其他地方使用 param.getOrgIdList()，也需要使用 cleanList
+        if (CollectionUtils.isNotEmpty(cleanList)) {
+            // 使用清洗后的 cleanList，避免注入风险
+            sb.append(" AND txf.org_id IN " + SqlUtils.getInSql(cleanList)); //使用过滤后的参数传递，确保orgid 的传递是通过了清洗函数的，这里的清洗函数为 safeFilterOrgIdList
+        }
+    }
+
+```
+2、如果传入下层函数的为一个对象，有污点的是其中一个属性，使用过滤函数过滤整个对象，**函数起名以 safeFilter 或者safeValidate 开头，并通过临时变量承接过滤函数产生的过滤后的对象，使用临时对象向下层调用传递**。例如：
+
+```java
+//原始代码
+       if (CollectionUtils.isNotEmpty(param.getOrgIdList())) {
+            return xxx.selectOrg(param);
+        }
+....
+// 定义过滤函数，返回一个新的 CourseQuery 对象，用安全的函数截断数据流
+    public static CourseQuery safeFilterOrgIdList(CourseQuery param) {
+        if (param == null) return null;
+        Pattern ID_PATTERN = Pattern.compile("^\\d+$");
+        for (String item : param.getOrgIdList()) {
+            if (item != null && !ID_PATTERN.matcher(item).matches()) {
+                throw new IllegalArgumentException("Invalid OrgIdList contains invalid item: " + item);
+            }
+        }
+        return param;
+    }
+// 修复后的代码
+       if (CollectionUtils.isNotEmpty(param.getOrgIdList())) {
+            CourseQuery tmpParam = safeFilterOrgIdList(param); //通过 safeFilterOrgIdList 函数过滤
+            return xxx.selectOrg(tmpParam); // 向下传递过滤后的
+        }
+
+```
+3、**MyBatis/ORM 场景下对象属性过滤的特殊处理**：当污点数据通过对象属性传递到 MyBatis XML（如 `${page.orderBy}`、`${entity.tableName}` 等）时，需要根据赋值和读取方式选择正确的过滤位置：
+
+| 赋值方式 | 读取方式 | 过滤位置 |
+|---------|---------|---------|
+| 调用 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> {
+    private String orderBy;
+    
+    public void setOrderBy(String orderBy) {
+        this.orderBy = orderBy;  // 未过滤，MyBatis ${page.orderBy} 访问时有注入风险
+    }
+    
+    public String getOrderBy() {
+        return orderBy;  // 未过滤，显式调用时对象级污点会穿透
+    }
+}
+
+// 修复后（setter 和 getter 都过滤）
+public class Page<T> {
+    private String orderBy;
+    private static final Pattern SAFE_PATTERN = Pattern.compile("^[\\w\\s\\[\\]\"`$.,*]+$");
+    
+    private static String safeFilterOrderBy(String input) {
+        if (input == null || input.isEmpty()) return "";
+        if (!SAFE_PATTERN.matcher(input).matches()) return "";
+        return input;
+    }
+    
+    public void setOrderBy(String orderBy) {
+        this.orderBy = safeFilterOrderBy(orderBy);  // setter 过滤：覆盖 MyBatis 隐式访问场景
+    }
+    
+    public String getOrderBy() {
+        return safeFilterOrderBy(orderBy);  // getter 过滤：覆盖代码显式调用 getter 时对象级污点场景
+    }
+}
+```
+
+**示例2：构造函数赋值 + 显式 getter 调用（构造函数、setter、getter 都过滤）**
+```java
+// 原始代码（有漏洞）
+public class Page<T> {
+    private String orderBy;
+    
+    public Page(HttpServletRequest request) {
+        this.orderBy = request.getParameter("orderBy");  // 构造函数直接赋值，未过滤
+    }
+}
+
+// 修复后（所有入口和出口都过滤）
+public class Page<T> {
+    private String orderBy;
+    private static final Pattern SAFE_PATTERN = Pattern.compile("^[\\w\\s\\[\\]\"`$.,*]+$");
+    
+    private static String safeFilterOrderBy(String input) {
+        if (input == null || input.isEmpty()) return "";
+        if (!SAFE_PATTERN.matcher(input).matches()) return "";
+        return input;
+    }
+    
+    public Page(HttpServletRequest request) {
+        this.orderBy = safeFilterOrderBy(request.getParameter("orderBy"));  // 构造函数中过滤
+    }
+    
+    public void setOrderBy(String orderBy) {
+        this.orderBy = safeFilterOrderBy(orderBy);  // setter 过滤：覆盖 MyBatis 隐式访问场景
+    }
+    
+    public String getOrderBy() {
+        return safeFilterOrderBy(orderBy);  // getter 过滤：覆盖显式调用时对象级污点场景
+    }
+}
+```
+
+**注意**：这种模式适用于所有通过 ORM/模板引擎（MyBatis、Hibernate、Freemarker 等）访问的对象属性。setter 和 getter 都加过滤虽然看似冗余，但因为静态分析器的两种限制（隐式调用不可见 + 对象级污点追踪），这是确保所有场景都能被识别到防护的最可靠方式。
+
+### 修复后的检查点
+1. 检查补丁代码其中参数是否在当前函数范围。
+2. 检查补丁代码是否存在语法异常问题，例如正则中引号转义失败，导致非预期字符串闭合问题。
+3. 检查补丁代码是否影响其他调用场景使用。
+
+## 修复示例
+以下是针对 SQL 注入漏洞在不同场景下的详细整理，包括常见 Java 框架（如 MyBatis、JDBC、Hibernate 等）中的注入风险及其示例：
+
+---
+
+### 1. **JDBC 拼接 SQL 语句**
+* **场景**：动态拼接条件时未使用参数化查询，且原始 sql 为全局定义。
+* **示例**：
+
+```java
+public class TestServiceImp implements TestService {
+
+    /**
+     * 周期营销数据,总和表
+     */
+    private static final String QUERY_SQL =
+            "select id,uid,name from user_table where uid = '%s' and tid in (%s)";
+    private static final String QUERY_SQL_ALL =
+            "select * from user_table where uid = '%s' and tid in (%s)";
+            
+    private List<ScheduleReportDTO> getData(String uId, List<String> tId) {
+        String queryReady;
+        if (isAll) {
+            queryReady = QUERY_SQL_ALL;
+        else{
+            queryReady = QUERY_SQL;
+        }
+        String queryReadySQL = String.format(queryReady, uId, StringUtils.join(tId, ","));
+        resultSet = statement.executeQuery(queryReadySQL);
+        List<ScheduleReportDTO> remindReportDataList = new ArrayList<>();
+        //获取返回结果
+        return remindReportDataList;
+    }
+}
+```
+* **风险**：用户输入的 uId 参数会导致 SQL 注入，tId 也是用户输入的，是List<String> 类型，可能也会导致 SQL 注入，如果这里 tId 为List<long>等情况，则tId不存在注入风险，不用修复。另外， sql 语句在全局变量定义，修复时需要考虑修改全局变量定义的 sql 语句。
+* **修复**：条件直使用 PreparedStatement 动态绑定参数，同时需要对 sql 语句的源头QUERY_SQL_ALL 和 QUERY_SQL 两个全局变量进行修改，使其支持预编译：
+
+```java
+public class TestServiceImp implements TestService {
+
+    /**
+     * 周期营销数据,总和表
+     */
+    private static final String QUERY_SQL =
+            "select id,uid,name from user_table where uid = ? and tid in (%s)";
+    private static final String QUERY_SQL_ALL =
+            "select * from user_table where uid = ? and tid in (%s)";
+            
+    private List<ScheduleReportDTO> getData(String uid, List<String> tId) {
+        String queryReady;
+        if (isAll) {
+            queryReady = QUERY_SQL_ALL;
+        } else {
+            queryReady = QUERY_SQL;
+        }
+        String queryReadySQL = String.format(queryReady, String.join(",", Collections.nCopies(tId.size(), "?")));
+        PreparedStatement pstmt = connection.prepareStatement(queryReadySQL);
+        pstmt.setString(1, uid);
+        for (int i = 0; i < tId.size(); i++) {
+            pstmt.setString(i + 2, tId.get(i));
+        }
+        resultSet = pstmt.executeQuery();
+        List<ScheduleReportDTO> remindReportDataList = new ArrayList<>();
+        //获取返回结果
+        return remindReportDataList;
+    }
+}
+```
+---
+
+### 2. **MyBatis 使用 **`$`** 传递动态表名、列名、orderby 等**
+* **场景**：MyBatis 中使用 `$` 符号直接拼接用户输入到 SQL 语句中。
+* **示例**：
+
+```xml
+<select id="getUserByName" resultType="User">
+    SELECT * FROM ${tableName} WHERE username = ${username} order by ${order}
+</select>
+```
+* 若用户传入 `tableName = users; DROP TABLE users;`、`username = zhangsan; DROP TABLE users;`或者 `order = order; DROP TABLE users;`，会导致 SQL 注入。
+* **风险**：`$` 符号直接拼接字符串，不进行参数化处理。
+* **修复**：
+    * 避免使用 `$` 传递动态表名、列名或者排序条件等。
+    * 在 java 代码层面进行参数过滤，例如：
+
+
+```java
+if (!tableName.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+    throw new IllegalArgumentException("Invalid tableName");
+}
+if (!order.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+    throw new IllegalArgumentException("Invalid order");
+}
+```
+    * 使用 `#` 绑定参数传递普通值, 例如，这里的${username} 改为 #{username} 。
+
+```java
+<select id="getUserByName" resultType="User">
+    SELECT * FROM ${tableName} WHERE username = #{username} order by ${order}
+</select>
+```
+---
+
+### 3. **Hibernate 拼接 HQL 查询**
+* **场景**：在 Hibernate 中直接拼接用户输入到 HQL 查询中。
+* **示例**：
+
+```java
+String username = request.getParameter("username");
+String hql = "FROM User WHERE username = '" + username + "'";
+Query query = session.createQuery(hql);
+List<User> users = query.list();
+```
+* **风险**：用户输入 `' OR '1'='1` 会导致 SQL 注入（HQL 注入）。
+* **修复**：使用命名参数绑定：
+
+```java
+String hql = "FROM User WHERE username = :username";
+Query query = session.createQuery(hql);
+query.setParameter("username", username);
+List<User> users = query.list();
+```
+---
+
+### 4. **Spring Data JPA 动态查询**
+* **场景**：使用 `@Query` 注解或原生 SQL 查询时，直接拼接用户输入。
+* **示例**：
+
+```java
+@Query(value = "SELECT * FROM users WHERE username = '" + username + "'", nativeQuery = true)
+List<User> findByUsernameNative(String username);
+
+```
+* **风险**：使用原生 SQL 拼接则存在SQL 注入。
+* **修复**：使用命名参数绑定：
+
+```java
+@Query("SELECT u FROM User u WHERE u.username = :username")
+List<User> findByUsername(@Param("username") String username);
+```
+---
+
+### 5. **存储过程调用传递动态参数**
+* **场景**：在调用存储过程时，直接拼接用户输入到参数中。
+* **示例**：
+
+```java
+String username = request.getParameter("username");
+CallableStatement cstmt = connection.prepareCall("{CALL getUser(?)}");
+cstmt.setString(1, "'" + username + "'"); // 直接拼接用户输入
+ResultSet rs = cstmt.executeQuery();
+```
+* **风险**：用户输入 `'; DROP TABLE users; --` 会导致 SQL 注入。
+* **修复**：使用参数化调用：
+
+```java
+CallableStatement cstmt = connection.prepareCall("{CALL getUser(?)}");
+cstmt.setString(1, username); // 参数化传递
+ResultSet rs = cstmt.executeQuery();
+```
+---
+
+### 6. **ORM 框架的动态查询（如 JPA Criteria API）**
+* **场景**：在 ORM 框架中使用动态查询时，未正确验证用户输入。
+* **示例**：
+
+```java
+CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+CriteriaQuery<User> cq = cb.createQuery(User.class);
+Root<User> user = cq.from(User.class);
+cq.where(cb.equal(user.get("username"), username)); // 假设 username 未验证
+List<User> users = entityManager.createQuery(cq).getResultList();
+```
+* **风险**：若 `username` 未验证，可能被恶意构造。
+* **修复**：确保用户输入经过验证，避免直接使用未经验证的输入。
+
+```java
+CriteriaBuilder cb = entityManager.getCriteriaBuilder();
+CriteriaQuery<User> cq = cb.createQuery(User.class);
+Root<User> user = cq.from(User.class);
+if (!username.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+    throw new IllegalArgumentException("Invalid username");
+}
+cq.where(cb.equal(user.get("username"), username));
+List<User> users = entityManager.createQuery(cq).getResultList();
+```
+---
+
+### 7. **组合条件查询中的动态拼接1**
+* **场景**：在复杂查询中，动态拼接多个条件时未使用参数化查询。
+* **示例**：
+
+```java
+String baseQuery = "SELECT * FROM users WHERE 1=1";
+if (username != null) {
+    baseQuery += " AND username = '" + username + "'";
+}
+if (email != null) {
+    baseQuery += " AND email = '" + email + "'";
+}
+Statement stmt = connection.createStatement();
+ResultSet rs = stmt.executeQuery(baseQuery);
+```
+* **风险**：用户输入 `'; DROP TABLE users; --` 会导致 SQL 注入。
+* **修复**：使用 `PreparedStatement` 动态绑定参数：
+
+```java
+StringBuilder sb = new StringBuilder("SELECT * FROM users WHERE 1=1");
+List<Object> params = new ArrayList<>();
+if (username != null) {
+    sb.append(" AND username = ?");
+    params.add(username);
+}
+if (email != null) {
+    sb.append(" AND email = ?");
+    params.add(email);
+}
+PreparedStatement pstmt = connection.prepareStatement(sb.toString());
+for (int i = 0; i < params.size(); i++) {
+    pstmt.setObject(i + 1, params.get(i));
+}
+ResultSet rs = pstmt.executeQuery();
+```
+---
+
+### 8. **组合条件查询中的动态拼接2**
+* **场景**：在复杂查询中，动态拼接多个条件时未使用参数化查询，动态拼接表名列名未进行过滤。
+* **示例**：
+
+```java
+String baseQuery = "SELECT id,username,email," + addr + " FROM " + userTable + " WHERE 1=1";
+if (username != null) {
+    baseQuery += " AND username = '" + username + "'";
+}
+if (email != null) {
+    baseQuery += " AND email = '" + email + "'";
+}
+Statement stmt = connection.createStatement();
+ResultSet rs = stmt.executeQuery(baseQuery);
+```
+* **风险**：用户输入 `'; DROP TABLE users; --` 会导致 SQL 注入。
+* **修复**：对表名、列名进行正则过滤，对条件直使用 `PreparedStatement` 动态绑定参数：
+
+```java
+if (!addr.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+    throw new IllegalArgumentException("Invalid column addr");
+}
+if (!userTable.matches("^[\\w\\s\\[\\]\"`$.,*]+$")) {
+    throw new IllegalArgumentException("Invalid userTable");
+}
+StringBuilder sb = new StringBuilder("SELECT id,username,email," + addr + " FROM " + userTable + " WHERE 1=1");
+List<Object> params = new ArrayList<>();
+if (username != null) {
+    sb.append(" AND username = ?");
+    params.add(username);
+}
+if (email != null) {
+    sb.append(" AND email = ?");
+    params.add(email);
+}
+PreparedStatement pstmt = connection.prepareStatement(sb.toString());
+for (int i = 0; i < params.size(); i++) {
+    pstmt.setObject(i + 1, params.get(i));
+}
+ResultSet rs = pstmt.executeQuery();
+```
+
+
+### 9. **组合条件查询中的动态拼接3**
+* **场景**：在复杂查询中，动态拼接条件时未使用参数化查询，且被其他函数使用。
+* **示例**：
+
+```java
+    @Override
+    public Page<Object> queryPageFieldData(String schema, String tableName, String fieldName, String keyword,
+                                           OrderType orderType, int currentPage, int pageSize) {
+        StringBuilder sqlSb = new StringBuilder();
+        sqlSb.append("select distinct ").append(fieldName)
+                .append(" from ")
+                .append(quoteName(schema)).append(".").append(quoteName(tableName));
+        if (StringUtils.isNotEmpty(keyword)) {
+            sqlSb.append(" where ").append(quoteName(fieldName)).append(" like '%").append(keyword).append("%'");
+        }
+        sqlSb.append(" order by ").append(quoteName(fieldName)).append(" ").append(orderType != null ?
+                orderType.toString() : "asc");
+        String sql = sqlSb.toString();
+        log.info("[{}]. queryPageFieldData. sql=[{}]", ThreadLocalUtil.getTraceId(), sql);
+
+        List<Object> result = new ArrayList<>();
+        String pageSql = genPageSql(sql, currentPage, pageSize);
+        try (Statement stmt = connection.createStatement();
+             ResultSet rs = stmt.executeQuery(pageSql)) {
+            ResultSetMetaData rsmd = rs.getMetaData();
+            while (rs.next()) {
+                result.add(rs.getObject(fieldName));
+            }
+        } catch (SQLException e) {
+            throw new ShowException(e);
+        }
+        int count = queryCount(sql);
+        Page page = new Page(count, pageSize, currentPage);
+        page.setData(result);
+        return page;
+    }
+
+    @Override
+    public int queryCount(String sql) {
+        StringBuilder countSql = new StringBuilder();
+        countSql.append("select count(*) as count from (").append(sql).append(") count");
+        List<Integer> result = new ArrayList<>();
+        try (Statement stmt = connection.createStatement();
+             ResultSet rs = stmt.executeQuery(countSql.toString())) {
+            while (rs.next()) {
+                result.add(rs.getInt("count"));
+            }
+            return result.get(0);
+        } catch (SQLException e) {
+            throw new ShowException(e.getMessage());
+        }
+    }
+```
+* **风险**：用户输入的 like 参数会导致 SQL 注入，同时sqlSb 在当前函数使用，且被引入到sql变量中，导致风险传递到 queryCount 函数，此时需要考虑queryPageFieldData和queryCount两个函数的风险修复。
+* **修复**：条件直使用 `PreparedStatement` 动态绑定参数，同时对queryCount情况也修复，因为使用预编译，所以参数也需要通过函数参数传递，此时通过重载queryCount函数，加入需要传递的参数，并对queryCount中的查询进行预编译改造：
+
+```java
+    @Override
+    public Page<Object> queryPageFieldData(String schema, String tableName, String fieldName, String keyword,
+                                           OrderType orderType, int currentPage, int pageSize) {
+        StringBuilder sqlSb = new StringBuilder();
+        sqlSb.append("select distinct ").append(fieldName)
+                .append(" from ")
+                .append(quoteName(schema)).append(".").append(quoteName(tableName));
+        String sql;
+        List<Object> params = new ArrayList<>();
+        if (StringUtils.isNotEmpty(keyword)) {
+            sqlSb.append(" where ").append(quoteName(fieldName)).append(" like ?");
+            params.add("%" + keyword + "%");
+        }
+        sqlSb.append(" order by ").append(quoteName(fieldName)).append(" ").append(orderType != null ?
+                orderType.toString() : "asc");
+        sql = sqlSb.toString();
+        log.info("[{}]. queryPageFieldData. sql=[{}]", ThreadLocalUtil.getTraceId(), sql);
+
+        List<Object> result = new ArrayList<>();
+        String pageSql = genPageSql(sql, currentPage, pageSize);
+        try (PreparedStatement stmt = connection.prepareStatement(pageSql)) {
+            for (int i = 0; i < params.size(); i++) {
+                stmt.setObject(i + 1, params.get(i));
+            }
+            try (ResultSet rs = stmt.executeQuery()) {
+                ResultSetMetaData rsmd = rs.getMetaData();
+                while (rs.next()) {
+                    result.add(rs.getObject(fieldName));
+                }
+            }
+        } catch (SQLException e) {
+            throw new ShowException(e);
+        }
+        int count = queryCount(sql, params);
+        Page page = new Page(count, pageSize, currentPage);
+        page.setData(result);
+        return page;
+    }
+
+    @Override
+    public int queryCount(String sql, List<Object> params) {
+        StringBuilder countSql = new StringBuilder();
+        countSql.append("select count(*) as count from (").append(sql).append(") count");
+        List<Integer> result = new ArrayList<>();
+        try (PreparedStatement stmt = connection.prepareStatement(countSql.toString())) {
+            for (int i = 0; i < params.size(); i++) {
+                stmt.setObject(i + 1, params.get(i));
+            }
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getInt("count"));
+                }
+                return result.get(0);
+            }
+        } catch (SQLException e) {
+            throw new ShowException(e.getMessage());
+        }
+    }
+    
+    @Override
+    public int queryCount(String sql) {
+        return queryCount(sql, Collections.emptyList());
+    }
+```
+---