在 SpringBoot3.3 中攔截修改請求 Body 的多種正確方式

作者：編程疏影 2024-09-02 08:17:18

經處理的用戶輸入可能會包含惡意的 HTML 或 JavaScript 代碼，攻擊者可以利用這些代碼在用戶瀏覽器中執行惡意腳本，導致跨站腳本攻擊（XSS）。

在現代Web應用中，安全性和數據完整性是至關重要的，尤其是在處理用戶提交的數據時。請求的Body部分通常包含了關鍵的數據，如用戶輸入的表單信息、JSON數據、XML數據等，這些數據在傳輸和處理過程中如果沒有經過適當的驗證和安全檢查，可能會導致嚴重的安全漏洞。

例如，未經處理的用戶輸入可能會包含惡意的 HTML 或 JavaScript 代碼，攻擊者可以利用這些代碼在用戶瀏覽器中執行惡意腳本，導致跨站腳本攻擊（XSS）。此外，數據的完整性和準確性也可能受到篡改，這可能會導致應用程序在處理過程中出現錯誤或異常。

為了應對這些挑戰，開發人員通常需要攔截并修改請求 Body 的內容，對其進行驗證、過濾和格式化，以確保其安全性和可靠性。在Spring Boot 框架中，攔截和修改請求 Body 的方式有多種，常見的包括使用過濾器（Filter）、攔截器（Interceptor）、自定義HttpMessageConverter，以及直接在Controller中處理。

本文將深入探討在 Spring Boot 中攔截和修改請求 Body 的多種正確方式，結合代碼示例對每種方式進行詳細講解，并特別強調如何通過格式化和內容安全性檢測來防止 XSS 攻擊，確保應用程序的安全性和數據的完整性。我們還將介紹如何在這些方法中集成內容安全策略，增強對 HTML 和 JavaScript 標簽的檢測和處理，以防止潛在的安全威脅。這些技術不僅適用于一般的 Web 應用開發，還對構建高安全性的企業級應用有著重要的指導意義。

運行效果：

若想獲取項目完整代碼以及其他文章的項目源碼，且在代碼編寫時遇到問題需要咨詢交流，歡迎加入下方的知識星球。

項目結構

我們將創建一個 Spring Boot 項目，其中包含以下文件和配置：

pom.xml：項目依賴配置
application.yml：項目屬性配置
前端頁面：使用 Thymeleaf 模板引擎，結合 Bootstrap 進行樣式美化
控制器、過濾器、中間件：實現攔截和修改請求 Body 的功能

項目依賴配置（pom.xml）

首先，在pom.xml文件中添加必要的依賴項。我們的項目需要以下依賴：

<?xml versinotallow="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.3.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.icoderoad</groupId>
	<artifactId>request-body</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>request-body</name>
	<description>Demo project for Spring Boot</description>
	
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>

		<!-- Spring Boot Starter Web -->
	    <dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-web</artifactId>
	    </dependency>
	
	    <!-- Thymeleaf -->
	    <dependency>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-thymeleaf</artifactId>
	    </dependency>
		
		<!-- Apache Commons Text (for string escape operations) -->
	    <dependency>
	        <groupId>org.apache.commons</groupId>
	        <artifactId>commons-text</artifactId>
	        <version>1.9</version>
	    </dependency>
	

	    <!-- Lombok (optional for reducing boilerplate code) -->
	    <dependency>
	        <groupId>org.projectlombok</groupId>
	        <artifactId>lombok</artifactId>
	        <scope>provided</scope>
	    </dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

項目配置（application.yml）

接下來，在application.yml文件中進行一些基本配置。通常，我們可以在這里配置服務器端口、日志級別等信息：

server:
  port: 8080

spring:
  thymeleaf:
    cache: false
    mode: HTML
    suffix: .html
    prefix: classpath:/templates/

前端頁面（Thymeleaf模板）

為了演示請求攔截和修改的效果，我們可以創建一個簡單的表單頁面index.html，用戶可以在此頁面上提交數據。

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>請求表單</title>
    <!-- 引入Bootstrap CSS -->
    <link  rel="stylesheet">
    <!-- 引入jQuery -->
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
    <div class="container">
        <h2>提交請求表單</h2>
        <form id="requestForm">
            <div class="mb-3">
                <label for="inputData" class="form-label">輸入數據</label>
                <textarea class="form-control" id="inputData" rows="3" required></textarea>
            </div>
            <button type="submit" class="btn btn-primary">提交</button>
        </form>

        <!-- 提示信息 -->
        <div id="resultMessage" class="alert mt-3" role="alert" style="display:none;"></div>
    </div>

    <script>
        $(document).ready(function() {
            $("#requestForm").on("submit", function(event) {
                event.preventDefault(); // 阻止表單的默認提交行為

                // 獲取用戶輸入的數據
                var inputData = $("#inputData").val();

                // 使用 jQuery 發送 AJAX 請求
                $.ajax({
                    url: "/submit",
                    type: "POST",
                    contentType: "application/json",
                    data: JSON.stringify({data: inputData}),
                    success: function(response) {
                        // 成功后在頁面上顯示提示信息
                        $("#resultMessage").removeClass("alert-danger").addClass("alert-success")
                            .text("提交成功: " + response.message)
                            .show();
                    },
                    error: function(xhr, status, error) {
                        // 失敗時顯示錯誤信息
                        $("#resultMessage").removeClass("alert-success").addClass("alert-danger")
                            .text("提交失敗: " + xhr.responseText)
                            .show();
                    }
                });
            });
        });
    </script>
</body>
</html>

攔截和修改請求Body的實現方式

創建過濾器配置類

創建一個 FilterConfig 配置類，在該類中注冊 RequestBodyFilter 過濾器。

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RequestBodyFilter> requestBodyFilterRegistration() {
        FilterRegistrationBean<RequestBodyFilter> registrationBean = new FilterRegistrationBean<>();

        // 將自定義過濾器注冊為Bean
        registrationBean.setFilter(new RequestBodyFilter());
        
        // 過濾器應用于所有URL
        registrationBean.addUrlPatterns("/*");
        
        // 設置過濾器的優先級
        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE);

        return registrationBean;
    }
}

使用過濾器（Filter）攔截請求Body

過濾器是一種常見的攔截HTTP請求的方式。我們可以通過實現jakarta.servlet.Filter接口來攔截請求并修改請求體。

package com.icoderoad.request_body.filter;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;

import org.apache.commons.text.StringEscapeUtils;
import org.springframework.stereotype.Component;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import jakarta.servlet.http.HttpServletResponse;

@Component
public class RequestBodyFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
            HttpServletRequest httpRequest = (HttpServletRequest) request;

            // 使用自定義 HttpServletRequestWrapper 包裝請求
            CustomHttpServletRequestWrapper wrappedRequest = new CustomHttpServletRequestWrapper(httpRequest);

            // 確保請求體內容被讀取并緩存
            String originalBody = wrappedRequest.getBody();

            // 確認請求體內容
            System.out.println("Original Request Body: " + originalBody);

            // 對內容進行安全性處理：轉義HTML和JavaScript標簽
            String sanitizedBody = sanitizeBody(originalBody);

            // 將處理后的內容作為新的輸入流返回
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(sanitizedBody.getBytes(StandardCharsets.UTF_8));
            HttpServletRequest sanitizedRequest = new CustomHttpServletRequestWrapper(wrappedRequest) {
                @Override
                public ServletInputStream getInputStream() throws IOException {
                    return new CustomServletInputStream(byteArrayInputStream);
                }
            };

            // 繼續過濾鏈
            chain.doFilter(sanitizedRequest, response);
        } else {
            chain.doFilter(request, response);
        }
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化Filter所需資源
    }

    @Override
    public void destroy() {
        // 釋放Filter所占用的資源
    }

    // 用于安全處理請求體內容
    private String sanitizeBody(String originalBody) {
        String sanitizedBody = StringEscapeUtils.escapeHtml4(originalBody);
        sanitizedBody = sanitizedBody.replaceAll("(?i)<script", "<script")
                                     .replaceAll("(?i)</script", "</script");
        
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            JsonNode jsonNode = objectMapper.readTree(originalBody);
            // 對 JSON 數據進行處理（比如移除不必要的字段）
            return objectMapper.writeValueAsString(jsonNode);
        } catch (IOException e) {
            e.printStackTrace();
            // 處理 JSON 解析異常
            return sanitizedBody;
        }
    }

    // 自定義ServletInputStream類，簡化流操作
    private static class CustomServletInputStream extends ServletInputStream {
        private final ByteArrayInputStream inputStream;

        public CustomServletInputStream(ByteArrayInputStream inputStream) {
            this.inputStream = inputStream;
        }

        @Override
        public int read() throws IOException {
            return inputStream.read();
        }

        @Override
        public boolean isFinished() {
            return inputStream.available() == 0;
        }

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setReadListener(jakarta.servlet.ReadListener readListener) {
            // 讀取監聽器設置，當前未實現
        }
    }

    // 自定義 HttpServletRequestWrapper 類
    private static class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {
        private final byte[] body;

        public CustomHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
            super(request);
            // 讀取請求體內容并緩存
            InputStream inputStream = request.getInputStream();
            body = inputStream.readAllBytes();
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            return new CustomServletInputStream(new ByteArrayInputStream(body));
        }

        public String getBody() {
            return new String(body, StandardCharsets.UTF_8);
        }
    }
}

使用Spring Interceptor攔截請求Body

Spring的攔截器（Interceptor）是另一種攔截HTTP請求的方式。它比過濾器更接近Spring的處理機制。

package com.icoderoad.request_body.interceptor;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

import org.apache.commons.text.StringEscapeUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.util.ContentCachingRequestWrapper;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import jakarta.servlet.http.HttpServletResponse;

public class RequestBodyInterceptor implements HandlerInterceptor {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        // 使用 ContentCachingRequestWrapper 包裝 HttpServletRequest
        ContentCachingRequestWrapper cachingRequest = new ContentCachingRequestWrapper(request);

        // 讀取請求體內容
        String originalBody = readRequestBody(cachingRequest);
        if (originalBody == null || originalBody.isEmpty()) {
            return true; // 如果沒有請求體，直接返回
        }

        System.out.println("Original Request Body: " + originalBody);

        // 處理請求體內容
        String sanitizedBody = sanitizeBody(originalBody);

        // 使用自定義 HttpServletRequestWrapper 包裝請求
        HttpServletRequest wrappedRequest = new CustomHttpServletRequestWrapper(cachingRequest, sanitizedBody);

        // 替換請求對象
        request.setAttribute("wrappedRequest", wrappedRequest);

        return true;
    }

    private String readRequestBody(HttpServletRequest request) throws IOException {
        ContentCachingRequestWrapper wrapper = (ContentCachingRequestWrapper) request;
        byte[] buf = wrapper.getContentAsByteArray();
        if (buf.length > 0) {
            return new String(buf, 0, buf.length, wrapper.getCharacterEncoding());
        }
        return null;
    }

    private String sanitizeBody(String originalBody) {
        // 如果請求體是 JSON 格式，則對其進行特殊處理
        if (isJson(originalBody)) {
            try {
                JsonNode jsonNode = objectMapper.readTree(originalBody);
                // 對 JSON 數據進行處理（比如移除不必要的字段）
                return objectMapper.writeValueAsString(jsonNode);
            } catch (IOException e) {
                // 捕獲 JSON 解析異常，記錄錯誤并返回原始內容
                e.printStackTrace();
                return originalBody; // 返回原始內容
            }
        } else {
            // 對內容進行安全性處理：轉義HTML和JavaScript標簽
            String sanitizedBody = StringEscapeUtils.escapeHtml4(originalBody);
            sanitizedBody = sanitizedBody.replaceAll("(?i)<script", "<script")
                                         .replaceAll("(?i)</script", "</script>");
            return sanitizedBody;
        }
    }

    private boolean isJson(String content) {
        // 簡單檢查內容是否是 JSON 格式
        return content.trim().startsWith("{") || content.trim().startsWith("[");
    }

    private static class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {
        private final ByteArrayInputStream inputStream;

        public CustomHttpServletRequestWrapper(HttpServletRequest request, String body) {
            super(request);
            this.inputStream = new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8));
        }

        @Override
        public ServletInputStream getInputStream() throws IOException {
            return new CustomServletInputStream(inputStream);
        }

        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(getInputStream(), StandardCharsets.UTF_8));
        }
    }

    private static class CustomServletInputStream extends ServletInputStream {
        private final ByteArrayInputStream inputStream;

        public CustomServletInputStream(ByteArrayInputStream inputStream) {
            this.inputStream = inputStream;
        }

        @Override
        public int read() throws IOException {
            return inputStream.read();
        }

        @Override
        public boolean isFinished() {
            return inputStream.available() == 0;
        }

        @Override
        public boolean isReady() {
            return true;
        }

        @Override
        public void setReadListener(ReadListener readListener) {
            // 讀取監聽器設置，當前未實現
        }
    }
}

創建配置類來注冊攔截器

在你的 Spring Boot 項目中創建一個配置類，配置 RequestBodyInterceptor：

package com.icoderoad.request_body.config;

import java.util.List;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.icoderoad.request_body.converter.CustomHttpMessageConverter;
import com.icoderoad.request_body.interceptor.RequestBodyInterceptor;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new RequestBodyInterceptor());
    }
    
    @Bean
    public CustomHttpMessageConverter customHttpMessageConverter(ObjectMapper objectMapper) {
        return new CustomHttpMessageConverter(objectMapper);
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        // 移除默認的 Jackson 2 HttpMessageConverter
        converters.removeIf(converter -> converter instanceof AbstractHttpMessageConverter);
        // 添加自定義的 HttpMessageConverter
        converters.add(customHttpMessageConverter(new ObjectMapper()));
    }
}

使用自定義HttpMessageConverter

Spring提供了HttpMessageConverter來處理請求體的轉換。我們可以自定義一個HttpMessageConverter來攔截和修改請求體。

package com.icoderoad.request_body.converter;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.text.StringEscapeUtils;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class CustomHttpMessageConverter extends AbstractHttpMessageConverter<Object> {

    private final ObjectMapper objectMapper;

    public CustomHttpMessageConverter(ObjectMapper objectMapper) {
        super(MediaType.APPLICATION_JSON);
        this.objectMapper = objectMapper;
    }

    @Override
    protected boolean supports(Class<?> clazz) {
        return true; // 支持所有類
    }

    @Override
    protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException {
        String body = new String(inputMessage.getBody().readAllBytes(), StandardCharsets.UTF_8);

        // 處理請求體內容
        String sanitizedBody = sanitizeBody(body);

        // 將處理后的內容轉換為對象
        return objectMapper.readValue(sanitizedBody, clazz);
    }

    @Override
    protected void writeInternal(Object object, HttpOutputMessage outputMessage) throws IOException {
        // 將對象轉換為 JSON 字符串
        String json = objectMapper.writeValueAsString(object);

        // 輸出處理后的 JSON 字符串
        outputMessage.getBody().write(json.getBytes(StandardCharsets.UTF_8));
    }

    private String sanitizeBody(String originalBody) {
        // 如果請求體是 JSON 格式，則對其進行特殊處理
        if (originalBody.trim().startsWith("{") || originalBody.trim().startsWith("[")) {
            try {
                JsonNode jsonNode = objectMapper.readTree(originalBody);
                // 對 JSON 數據進行處理（比如移除不必要的字段）
                return objectMapper.writeValueAsString(jsonNode);
            } catch (IOException e) {
                // 捕獲 JSON 解析異常，記錄錯誤并返回原始內容
                e.printStackTrace();
                return originalBody; // 返回原始內容
            }
        } else {
            // 對內容進行安全性處理：轉義HTML和JavaScript標簽
            String sanitizedBody = StringEscapeUtils.escapeHtml4(originalBody);
            sanitizedBody = sanitizedBody.replaceAll("(?i)<script", "<script")
                                         .replaceAll("(?i)</script", "</script>");
            return sanitizedBody;
        }
    }
}

在Controller中直接修改請求Body

最后一種方式是在Controller中直接讀取并修改請求體。

package com.icoderoad.request_body.controller;

import java.util.HashMap;
import java.util.Map;

import org.apache.commons.text.StringEscapeUtils;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RequestController {

    @PostMapping("/submit")
    public ResponseEntity<Map<String, String>> submit(@RequestBody Map<String, String> requestData) {
        String data = requestData.get("data");
        
        String sanitizedBody = StringEscapeUtils.escapeHtml4(data);
        sanitizedBody = sanitizedBody.replaceAll("(?i)<script", "<script")
                                     .replaceAll("(?i)</script", "</script");

        
        // 在此處理接收到的數據（例如存儲、驗證等）
        // 這里我們假設處理成功并返回一條消息

        Map<String, String> response = new HashMap<>();
        response.put("message", "接收到的數據: " + sanitizedBody);

        // 返回200 OK響應和響應消息
        return ResponseEntity.ok(response);
    }
}

總結

以上介紹了在 Spring Boot3.3 中攔截和修改請求 Body 的多種方式，包括使用過濾器、攔截器、HttpMessageConverter 以及在控制器中直接修改請求體。每種方式都有其適用場景，可以根據實際需求選擇合適的方式。希望本文對大家在實際開發中有所幫助。

責任編輯：武曉燕來源：路條編程

攔截修改請求