Java 代码审计题目类型和修复方案
Java 代码审计
行为问题不可控的内存分配存在问题的代码： public class Example {
public int exmpleFun(int length) {
String[] buffer;
if (length < 0) {
return 0;
}
buffer = new String[length];
return length;
}
}
上述代码中可能存在的安全问题包括： - exmpleFun 方法的 length 参数未经过合适的验证。调用者可能会传入一个负数或一个大于 MAX_LENGTH 的数作为该参数，这会导致 if 语句返回 0，同时没有为 buffer 数组分配内存。如果调用者试图访问 buffer 数组，就可能会产生空指针异常。
- buffer 数组没有被初始化，所以它默认情况下会包含空引用。如果调用者在没有检查空值的情况下试图访问数组的某个元素，就可能会产生空指针异常。
- buffer 数组在堆上分配，但当不再需要它时没有明确地释放内存。如果不停地调用 exmpleFun 方法而不释放 buffer 数组使用的内存，就可能会导致内存泄漏。
- buffer 数组被声明为 exmpleFun 方法的局部变量，这意味着它只能在该方法的作用域内访问。如果调用者在 exmpleFun 方法返回后需要访问数组，就无法做到。这可能会导致混淆和意想不到的行为。
为了解决这些潜在问题，可以对代码进行如下更改： - 对 length 参数进行验证，确保它始终为正整数且小于等于 MAX_LENGTH。
- 用空字符串初始化 buffer 数组，避免空指针异常。
- 使用 try-finally 块确保在不再需要 buffer 数组时始终释放其使用的内存。
- 从 exmpleFun 方法中返回 buffer 数组，以便在方法返回后调用者可以访问它。
示例如下： public class Example {
static int MAX_LENGTH = 1000;
public String[] exmpleFun(int length) {
String[] buffer;
if (length <= 0 || length > MAX_LENGTH) {
return new String[0];
}
buffer = new String[length];
Arrays.fill(buffer, "");
try {
return buffer;
} finally {
// Deallocate the memory used by the buffer array
buffer = null;
}
}
}
路径错误不可信的搜索路径存在问题的代码： public class Example {
private String command;
public void exampleFun() {
Runtime.getRuntime().exec(command);
}
}
上述代码中可能存在的安全问题包括： - command 字段未经过任何保护，可以被任何人随意修改。如果恶意用户修改了这个字段，可能会导致执行恶意命令。
- exampleFun 方法将 command 字段拼接到一个由硬编码路径组成的字符串中，然后执行拼接后的字符串。如果恶意用户修改了 command 字段，可能会导致执行恶意命令。
- exampleFun 方法没有对命令进行任何安全检查。如果恶意用户修改了 command 字段，可能会导致执行恶意命令。
为了解决这些潜在问题，可以对代码进行如下更改： - 将 command 字段声明为私有的，并为其提供访问器方法（如 getCommand 和 setCommand）。这样可以防止恶意用户直接修改这个字段。
- 在 exampleFun 方法中添加安全检查。例如，可以使用正则表达式检查 command 字段中的命令是否包含危险字符，并在发现危险字符时抛出异常。这样可以防止恶意用户传入恶意命令。
示例如下： import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Example {
private String command;
private static final String PATH = "/usr/bin/";
public String getCommand() {
return command;
}
public void setCommand(String command) {
this.command = command;
}
public void exampleFun() throws SecurityException {
String cmd = PATH + command;
// Check if the command contains any dangerous characters
Pattern pattern = Pattern.compile("[^a-zA-Z0-9\\s]");
Matcher matcher = pattern.matcher(cmd);
if (matcher.find()) {
throw new SecurityException("Dangerous characters found in command");
}
Runtime.getRuntime().exec(cmd);
}
}
数据处理相对路径遍历存在问题的代码： import java.io.File;
public class Example {
private String dataPath;
public void exampleFun(String filename) {
String path = dataPath + filename;
try {
File file = new File(path);
if (file.exists()) {
file.open();
}
} catch (Exception ignored) {
}
}
}
上述代码中可能存在的安全问题包括： - dataPath 字段未经过任何保护，可以被任何人随意修改。如果恶意用户修改了这个字段，可能会导致打开非法文件。
- exampleFun 方法没有对文件名进行路径检查，可能会导致打开非法文件。例如，恶意用户可能会在文件名中包含路径分隔符（如 .. 或 /），从而导致打开非法文件。
- exampleFun 方法没有捕获文件打开失败时可能抛出的异常。这可能会导致方法没有正确处理异常情况，从而导致错误或意料之外的行为。
为了解决这些潜在问题，可以对代码进行如下更改： - 将 dataPath 字段声明为私有的，并为其提供访问器方法（如 getDataPath 和 setDataPath）。这样可以防止恶意用户直接修改这个字段。
- 在 exampleFun 方法中对文件名进行路径检查。例如，可以使用正则表达式检查文件名是否包含路径分隔符，并在发现路径分隔符时抛出异常。
- 在 exampleFun 方法中捕获可能抛出的异常。例如，当文件打开失败时，可以捕获相应的异常，并在日志中记录错误信息。这样可以确保方法能够正确处理异常情况。
示例如下： import java.io.File;
import java.util.logging.Logger;
public class Example {
private static final Logger LOGGER = Logger.getLogger(Example.class.getName());
private String dataPath;
public String getDataPath() {
return dataPath;
}
public void setDataPath(String dataPath) {
this.dataPath = dataPath;
}
public void exampleFun(String filename) throws SecurityException {
String regex = "^[A-Za-z0-9]+\.[a-z]+$";
if (filename.matches(regex)) {
String path = dataPath + filename;
try {
File file = new File(path);
if (file.exists()) {
file.open();
}
} catch (Exception e) {
LOGGER.warning("Failed to open file: " + e.getMessage());
}
}
}
}
绝对路径遍历存在问题的代码： import java.io.File;
public class Example {
public void exampleFun(String absolutePath) {
try {
File file = new File(absolutePath);
if (file.exists()) {
file.open();
}
} catch (Exception ignored) {
}
}
}
上述代码中可能存在的安全问题包括： - exampleFun 方法没有对传入的绝对路径进行路径检查。例如，恶意用户可能会传入包含非法字符（如 .. 或 /）的路径，从而导致打开非法文件。
- exampleFun 方法没有捕获文件打开失败时可能抛出的异常。这可能会导致方法没有正确处理异常情况，从而导致错误或意料之外的行为。
为了解决这些潜在问题，可以对代码进行如下更改： - 在 exampleFun 方法中对传入的绝对路径进行路径检查。例如，可以使用正则表达式检查路径是否包含非法字符，并在发现非法字符时抛出异常。这样可以防止恶意用户传入恶意路径。
- 在 exampleFun 方法中捕获可能抛出的异常。例如，当文件打开失败时，可以捕获相应的异常，并在日志中记录错误信息。这样可以确保方法能够正确处理异常情况。
示例如下： import java.io.File;
import java.util.logging.Logger;
public class Example {
private static final Logger LOGGER = Logger.getLogger(Example.class.getName());
private static final String DATA_PATH = "C:\\data\\";
public void exampleFun(String filename) throws SecurityException {
String regex = "^[A-Za-z0-9]+\.[a-z]+$";
if (filename.matches(regex)) {
String path = DATA_PATH + filename;
// Check if the file path contains any dangerous characters
Pattern pattern = Pattern.compile("[^a-zA-Z0-9\\s]");
Matcher matcher = pattern.matcher(path);
if (matcher.find()) {
throw new SecurityException("Dangerous characters found in file path");
}
try {
File file = new File(path);
if (file.exists()) {
file.open();
}
} catch (Exception e) {
LOGGER.warning("Failed to open file: " + e.getMessage());
}
}
}
}
命令注入存在问题的代码： public class Example {
public void exampleFun(String parameter) {
String INIT_CMD = PATH + "cmd.exe /c \"dir.exe ";
if (parameter != null) {
String cmd = INIT_CMD + parameter + "\"";
Runtime.getRuntime().exec(cmd);
}
}
}
上述代码中可能存在的安全问题包括： - exampleFun 方法没有对传入的参数进行路径检查。例如，恶意用户可能会传入包含非法字符（如 .. 或 /）的路径，从而导致打开非法文件。
- exampleFun 方法没有捕获文件打开失败时可能抛出的异常。这可能会导致方法没有正确处理异常情况，从而导致错误或意料之外的行为。
- exampleFun 方法直接使用了用户传入的参数来构造命令行，没有进行任何过滤。这可能会导致恶意用户传入恶意参数，从而导致执行非法命令。
建议将上述代码修改为如下形式： import java.io.File;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Example {
private static final Logger LOGGER = Logger.getLogger(Example.class.getName());
private static final String INIT_CMD = "cmd.exe /c \"dir.exe ";
public void exampleFun(String parameter) throws SecurityException {
String regex = "^[\\w\\]+$";
if (parameter.matches(regex)) {
// Check if the parameter contains any dangerous characters
Pattern pattern = Pattern.compile("[^a-zA-Z0-9\\s]");
Matcher matcher = pattern.matcher(parameter);
if (matcher.find()) {
throw new SecurityException("Dangerous characters found in parameter");
}
// Construct the command
String cmd = INIT_CMD + parameter + "\"";
try {
Runtime.getRuntime().exec(cmd);
} catch (Exception e) {
LOGGER.warning("Failed to execute command: " + e.getMessage());
}
}
}
}
SQL 注入存在问题的代码： import org.jetbrains.annotations.NotNull;
import javax.servlet.http.HttpServletRequest;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Example {
public ResultSet getUserDate(@NotNull HttpServletRequest request, Connection con) throws SQLException {
String owner = request.getParameter("owner");
// 请查看示例 https://gist.github.com/retanoj/5fd369524a18ab68a4fe7ac5e0d121e8
String query = "SELECT * FROM user_data WHERE userid = '" + owner + "'";
Statement statement = con.createStatement();
ResultSet results = statement.executeQuery(query);
return results;
}
}
上述代码中可能存在的安全问题包括： - getUserDate 方法没有对用户传入的参数进行校验。恶意用户可能会传入包含攻击代码的参数，从而导致 SQL 注入攻击。
- getUserDate 方法没有关闭数据库连接和预编译的 SQL 语句。这可能会导致数据库连接泄露和性能问题。
为了解决这些潜在问题，可以对代码进行如下更改： - 在 getUserDate 方法中对用户传入的参数进行校验。例如，可以使用正则表达式检查参数是否包含非法字符，并在发现非法字符时抛出异常。这样可以防止恶意用户传入恶意参数。
- 在 getUserDate 方法中关闭数据库连接和预编译的 SQL 语句。
建议将上述代码修改为如下形式： import org.jetbrains.annotations.NotNull;
import javax.servlet.http.HttpServletRequest;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Example {
public ResultSet getUserDate(@NotNull HttpServletRequest request, Connection con) throws SQLException {
String owner = request.getParameter("owner");
// Check if the parameter contains any dangerous characters
Pattern pattern = Pattern.compile("[^a-zA-Z0-9\\s]");
Matcher matcher = pattern.matcher(owner);
if (matcher.find()) {
throw new SecurityException("Dangerous characters found in parameter");
}
// Execute the query
PreparedStatement preparedStatement = con.prepareStatement("SELECT * FROM user_data WHERE userid = ?");
preparedStatement.setString(1, owner);
ResultSet results = preparedStatement.executeQuery();
// Close the prepared statement and database connection
preparedStatement.close();
con.close();
return results;
}
}
代码注入存在问题的代码： import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class Example {
public void exampleFun(String code) throws ScriptException {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("javascript");
engine.eval(code);
}
}
修复代码： import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
public class Example {
public void exampleFun(String code) throws ScriptException {
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("javascript");
String regex = "^document.write\([A-Za-z0-9]+\);$";
if (code != null && code.matches(regex)) {
engine.eval(code);
}
}
}
进程控制存在问题的代码： public class Example {
public void loadLib(String libraryName) {
String path = "C:\\" + libraryName;
System.load(path);
}
}
- 在定义方法 verification 时，方法签名中缺少参数类型。
- 在调用方法 verification 时，需要传入参数。
- 方法 loadLib 中字符串 path 的值是写死的，不够灵活。
- 方法 loadLib 中没有对传入的 libraryName 参数进行合法性检查。
- 方法 loadLib 中没有处理可能发生的异常情况。
下面是修改后的代码： public class Example {
public boolean verification(String libraryName) {
// 检查 libraryName 参数的合法性
// 比如检查 libraryName 是否为空，是否符合文件名的规范等
return true;
}
public void loadLib(String libraryName) {
String path = "C:\\";
if (verification(libraryName)) {
path += libraryName;
try {
System.load(path);
} catch (Exception e) {
// 处理异常情况
}
}
}
}
信息通过错误消息泄露存在问题的代码： import javax.servlet.Servlet;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Example extends Servlet {
private String dbUrl;
private String username;
private String password;
public void exampleFun(HttpServletRequest request) throws SQLException {
DriverManager.getConnection(dbUrl, username, password);
}
}
这段代码存在以下问题： - 类 Example 没有继承 HttpServlet，因此不能正确处理 HTTP 请求。
- 变量 dbUrl、username 和 password 没有初始化，因此可能会导致连接数据库失败。
- exampleFun 方法没有声明可能抛出的异常，因此可能会导致代码运行时出错。
- 在 catch 块中使用了不存在的变量 errormsg，因此可能会出现编译错误。
下面是修复后的代码： import javax.servlet.Servlet;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Example extends HttpServlet {
private String dbUrl = "jdbc:mysql://localhost:3306/mydatabase";
private String username = "user";
private String password = "password";
public void exampleFun(HttpServletRequest request) throws SQLException {
try {
DriverManager.getConnection(dbUrl, username, password);
} catch (SQLException e) {
String msg = "Sorry!We will fix the problem soon!";
request.getSession().setAttribute("msg", msg);
}
}
}
信息通过服务器日志文件泄露存在问题的代码： public class Example {
public void writeLog(String msg) {
}
private boolean isTrue(String username, String password) {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {
String username = request.getParameter("username");
String password = request.getParameter("password");
if (isTrue(username, password)) {
String msg = username + " and " + password + " correct!";
writeLog(msg);
}
}
}
以上代码存在以下问题： - 对于写入日志的方法，没有指定日志的存储位置。
- 对于验证用户名和密码的方法，没有给出实际的验证逻辑。
- 对于doGet方法，没有处理可能出现的异常。
修复代码如下： public class Example {
// 使用日志记录器记录日志
private static final Logger log = Logger.getLogger(Example.class);
public void writeLog(String msg) {
log.info(msg);
}
private boolean isTrue(String username, String password) {
// 根据实际需要给出验证逻辑
return username.equals("admin") && password.equals("123456");
}
public void doGet(HttpServletRequest request, HttpServletResponse response) {
try {
String username = request.getParameter("username");
String password = request.getParameter("password");
if (isTrue(username, password)) {
String msg = "Login success!";
writeLog(msg);
}
} catch (Exception e) {
// 记录异常日志
log.error("Login failed!", e);
}
}
}
信息通过调试日志泄露存在问题的代码： <!-- 以下为 log4j.properties 配置文件的部分内容 -->
<!-- 设置日志级别为 DEBUG -->
log4j.rootLogger = DEBUG,LOG1
<!-- 设置日志输出为文件 -->
log4j.appender.LOG1 = org.apache.log4j.FileAppender
<!-- 设置日志输出的路径 -->
log4j.appender.LOG1.File = c:/Data.log
<!-- 设置日志内容样式 -->
log4j.appender.LOG1.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p [%t] %c %x - %m%n
//以下为 DataStore.java 的部分内容
import org.apache.log4j.Logger;
import java.util.logging.Logger;
public class DataStore{
private static Logger logger = Logger.getLogger(DataStore.class);
private String msg;
public static void main(String[] args){
logger.debug(msg);
}
}
以上代码存在以下问题： - log4j 包和 java.util.logging 包里面都定义了一个名为 Logger 的类，但是两个包中的类并不兼容，使用时应该注意区分。
- 在 DataStore 类中，使用了错误的包名和类名，应该改为 org.apache.log4j.Logger。
- 在 main 方法中，使用了一个未初始化的变量 msg。
修复代码如下： <!-- 以下为 log4j.properties 配置文件的部分内容 -->
<!-- 设置日志级别为 INFO,则 INFO 级别以下的日志将不会得到输出 -->
log4j.rootLogger = INFO,LOG1
<!-- 设置日志输出为文件 -->
log4j.appender.LOG1 = org.apache.log4j.FileAppender
<!-- 设置日志输出的路径 -->
log4j.appender.LOG1.File = c:/Data.log
<!-- 设置日志内容样式 -->
log4j.appender.LOG1.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p [%t] %c %x - %m%n
//以下为 DataStore.java 的部分内容
import org.apache.log4j.Logger;
public class DataStore{
private static Logger logger = Logger.getLogger(DataStore.class);
private static String msg = "debug message";
public static void main(String[] args){
logger.debug(msg);
}
}
信息通过持久 Cookie 泄露存在问题的代码： public class Example {
public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
String cookieName = "Sender";
String username = request.getParameter("username");
String password = request.getParameter("password");
Cookie cookieUsername = new Cookie(cookieName + "Name:",username);
cookieUsername.setMaxAge(14*24*60*60);
response.addCookie(cookieUsername);
Cookie cookiePassword = new Cookie(cookieName + "Password:",password);
cookiePassword.setMaxAge(14*24*60*60);
response.addCookie(cookiePassword);
}
}
该代码存在几个问题。首先，将用户名和密码存储在Cookie中不安全。这些敏感信息应该使用更安全的方式存储，例如使用会话存储。 其次，使用相同的Cookie名称来存储用户名和密码可能会导致混淆。应该使用不同的Cookie名称来存储这两个信息，以避免混淆。 此外，Cookie的最大生存期设置为14天可能过长。更好的做法是将Cookie的生存期设置为只在浏览器会话期间保留，即在用户关闭浏览器时立即过期。 下面是修复后的代码示例： public class Example {
public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
String username = request.getParameter("username");
String password = request.getParameter("password");
// 使用会话存储来存储用户名和密码
HttpSession session = request.getSession();
session.setAttribute("username", username);
session.setAttribute("password", password);
// 使用不同的Cookie名称来存储用户名和密码
Cookie cookieUsername = new Cookie("username",username);
// 设置Cookie的生存期为浏览器会话期间
cookieUsername.setMaxAge(-1);
response.addCookie(cookieUsername);
/*
Cookie cookiePassword = new Cookie("password",password);
cookiePassword.setMaxAge(-1);
response.addCookie(cookiePassword);
*/
}
}
未检查的输入作为循环条件存在问题的代码： public class Example {
public void exampleFun(int count){
int i = 0;
if(count > 0){
for (i = 0;i < count;i++){
}
}
}
}
该代码存在两个问题。首先，变量i的作用域为循环的作用域。这意味着当循环结束时，变量i仍然可以被访问。这可能会导致意料之外的行为，因此应该在循环结束后立即将变量i设置为null。 其次，变量MAX_COUNT是一个类变量，但它没有使用static修饰符。这意味着每个实例都将有自己的MAX_COUNT变量。这会浪费内存空间，并且不利于代码的可维护性。应该将该变量声明为静态变量，并使用static修饰符进行修饰。 下面是修复后的代码示例： public class Example {
// 声明为静态变量
private static final int MAX_COUNT = 1000;
public void exampleFun(int count){
int i = 0;
if(count > 0 && count <= MAX_COUNT){
for (i = 0;i < count;i++){
}
// 在循环结束后立即将变量i设置为null
i = null;
}
}
}
XPath 注入存在问题的代码： import javax.xml.xpath.*;
import java.io.IOException;
public class Example {
public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException{
XQDataSource ds = new SaxonXQDataSource();
XQConnection conn = ds.getConnection();
XQExpression expression = conn.createExpression();
String author = request.getParameter("author");
String query = "for $x in doc(\"books.xml\")//bookstore/book" + "where $x/author=\"" + author + "\"" + "return $x/title";
XQResultSequence res = expression.executeQuery(query);
}
}
这段代码有几个问题： - XQDataSource、XQConnection 和 XQExpression 类型的对象没有被关闭，这会导致内存泄漏。
- XQConnection 的 createExpression 方法的名称写错了。应该是 createExpression 而不是 CreateAtomType。
- conn.CreateAtomType(XQItemType.XQBASETYPE_STRING) 中的 CreateAtomType 方法也写错了。应该是 createAtomicType 而不是 CreateAtomType。
- XQResultSequence 对象没有被使用，也没有被关闭。
下面是修改后的代码： import javax.xml.xpath.*;
import java.io.IOException;
public class Example {
public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException{
XQDataSource ds = new SaxonXQDataSource();
XQConnection conn = ds.getConnection();
XQExpression expression = conn.createExpression();
String author = request.getParameter("author");
XQItemType strType = conn.createAtomicType(XQItemType.XQBASETYPE_STRING);
if(author != null){
String query = "declare variables $author as xs:string external;" +"for $x in doc(\"books.xml\")//bookstore/book" + "where $x/author=$author" + "return $x/title";
expression.bindString(new QName("author"),author,strType);
XQResultSequence res = expression.executeQuery(query);
try {
while (res.next()) {
System.out.println(res.getItemAsString(null));
}
} finally {
res.close();
}
}
conn.close();
}
}
该代码没有处理用户输入中包含特殊字符的情况，这可能会导致 SQL 注入攻击。可以在传入参数之前使用 PreparedStatement 的 setString() 方法进行转义。 修复代码： import javax.xml.xpath.*;
import java.sql.PreparedStatement;
public class Example {
private String regex = "^[A-Za-z\.]+$";
public void doPost(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException{
XQDataSource ds = new SaxonXQDataSource();
XQConnection conn = ds.getConnection();
XQExpression expression = conn.createExpression();
String author = request.getParameter("author");
if(author != null && author.matches(regex)){
String query = "for $x in doc(\"books.xml\")//bookstore//book" + "where $x//author=?" + "return $x//title";
PreparedStatement ps = conn.prepareStatement(query);
ps.setString(1, author);
XQResultSequence res = ps.executeQuery();
}
}
}
处理程序错误未限制危险类型文件的上传存在问题的代码： import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import java.util.Iterator;
import java.util.List;
public class Example {
public void exampleFun(HttpServletRequest request){
DiskFileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new DiskFileUpload(factory);
List<FileItem> items = upload.parseRequest(request);
Iterator<FileItem> iter = items.iterator();
while (iter.hasNext()){
FileItem item = iter.next();
}
}
}
这段代码存在几个问题： - 它使用了DiskFileUpload类，但该类已被废弃，应改为使用ServletFileUpload类。
- 它使用了错误的正则表达式，匹配文件名后缀。应该使用"^(gif|jpg|bmp)$"。
- 它在替换文件名中的控制字符时使用了错误的正则表达式，应该使用"[\\p{Cntrl}]"。
这个正则表达式有问题。它会匹配以字符"g"、"i"、"f"、"|"、"j"、"p"、"b"、"m"或"p"开头，以这些字符之一结尾的字符串。这并不是想要匹配的内容。 应该改为"^(gif|jpg|bmp)$"，它会匹配以"gif"、"jpg"或"bmp"结尾的字符串。例如，它会匹配"my_file.gif"，但不会匹配"my_file.txt"。 \p{Cntrl}是一个Unicode字符集的正则表达式。它会匹配所有控制字符，也就是ASCII值在0-31之间或127的字符。例如，它会匹配换行符(\n)，回车符(\r)和制表符(\t)。 这种正则表达式的作用是用于替换文本中的控制字符。例如，你可以使用它来将文本中的换行符替换为空格，以便在一行显示文本。 正则表达式中的\p和\P是Unicode字符集的概念。\p表示匹配某种类型的字符，而\P表示不匹配该类型的字符。例如，\p{L}表示匹配所有字母字符，而\P{L}表示不匹配字母字符。 在Java中，你需要写成"\\p{Cntrl}"或"[\\p{Cntrl}]"。 修复代码如下： import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import java.util.Iterator;
import java.util.List;
public class Example {
private String regex = "^(gif|jpg|bmp)$";
public void exampleFun(HttpServletRequest request){
DiskFileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
List<FileItem> items = upload.parseRequest(request);
Iterator<FileItem> iter = items.iterator();
while (iter.hasNext()){
FileItem item = iter.next();
String fileName = item.getName();
fileName = fileName.replaceAll("[\\p{Cntrl}]","_");
String fileEnd = fileName.substring(fileName.lastIndexOf(".")+1).toLowerCase();
if (fileEnd.matches(regex)){
}
}
}
}
|
发表于 2022-12-16 19:55:02