Spring Boot 如果防護 XSS + SQL 注入攻擊？一文帶你搞定！-有解無憂

1. XSS跨站腳本攻擊

①：XSS漏洞介紹

跨站腳本攻擊XSS是指攻擊者往Web頁面里插入惡意Script代碼，當用戶瀏覽該頁之時，嵌入其中Web里面的Script代碼會被決議執行，從而達到惡意攻擊用戶的目的，XSS攻擊針對的是用戶層面的攻擊！

②：XSS漏洞分類

存盤型XSS： 存盤型XSS，持久化，代碼是存盤在服務器中的，如在個人資訊或發表文章等地方，插入代碼，如果沒有過濾或過濾不嚴，那么這些代碼將儲存到服務器中，用戶訪問該頁面的時候觸發代碼執行，這種XSS比較危險，容易造成蠕蟲，盜竊cookie

反射型XSS： 非持久化，需要欺騙用戶自己去點擊鏈接才能觸發XSS代碼（服務器中沒有這樣的頁面和內容），一般容易出現在搜索頁面

DOM型XSS： 不經過后端，DOM-XSS漏洞是基于檔案物件模型(Document Objeet Model,DOM)的一種漏洞，DOM-XSS是通過url傳入引數去控制觸發的，其實也屬于反射型XSS，

③：防護建議

限制用戶輸入，表單資料規定值得型別，例如年齡只能是int，name為字母數字組合，
對資料進行html encode處理，
過濾或移除特殊的html標簽，
過濾javascript事件的標簽，

2. SQL注入攻擊

①：SQL注入漏洞介紹

SQL注入（SQLi）是一種注入攻擊，可以執行惡意SQL陳述句，它通過將任意SQL代碼插入資料庫查詢，使攻擊者能夠完全控制Web應用程式后面的資料庫服務器，攻擊者可以使用SQL注入漏洞繞過應用程式安全措施；可以繞過網頁或Web應用程式的身份驗證和授權，并檢索整個SQL資料庫的內容；還可以使用SQL注入來添加，修改和洗掉資料庫中的記錄

SQL注入漏洞可能會影響使用SQL資料庫（如MySQL，Oracle，SQL Server或其他）的任何網站或Web應用程式，犯罪分子可能會利用它來未經授權訪問用戶的敏感資料：客戶資訊，個人資料，商業機密，知識產權等，SQL注入攻擊是最古老，最流行，最危險的Web應用程式漏洞之一，

②：防護建議

使用mybatis中#{}可以有效防止sql注入

使用#{}時：

<select id="getBlogById" resultType="Blog" parameterType=”int”>
       select id,title,author,content
       from blog where id=#{id}
</select>

列印出執行的sql陳述句，會看到sql是這樣的：

select id,title,author,content from blog where id = ?

不管輸入什么引數，列印出的sql都是這樣的，這是因為mybatis啟用了預編譯功能，在sql執行前，會先將上面的sql發送給資料庫進行編譯，執行時，直接使用編譯好的sql，替換占位符“？”就可以了，因為sql注入只能對編譯程序起作用，所以像#{}這樣預編譯成？的方式就很好地避免了sql注入的問題，

mybatis是如何做到sql預編譯的呢？

其實在框架底層，是jdbc中的PreparedStatement類在起作用，PreparedStatement是我們很熟悉的Statement的子類，它的物件包含了編譯好的sql陳述句，這種“準備好”的方式不僅能提高安全性，而且在多次執行一個sql時，能夠提高效率，原因是sql已編譯好，再次執行時無需再編譯，

使用${}時

<select id="orderBlog" resultType="Blog" parameterType=”map”>
       select id,title,author,content
       from blog order by ${orderParam}
</select>

仔細觀察，行內引數的格式由“#{xxx}”變為了${xxx}，如果我們給引數“orderParam”賦值為”id”,將sql列印出來，是這樣的：

select id,title,author,contet from blog order by id

顯然，這樣是無法阻止sql注入的，引數會直接參與sql編譯，從而不能避免注入攻擊，但涉及到動態表名和列名時，只能使用“${}”這樣的引數格式，所以，這樣的引數需要我們在代碼中手工進行處理來防止注入，

3. SpringBoot中如何防止XSS攻擊和sql注入

話不多說，上代碼

Spring Boot 基礎就不介紹了，推薦看這個免費教程：

https://github.com/javastacks/spring-boot-best-practice

對于Xss攻擊和Sql注入，我們可以通過過濾器來搞定，可根據業務需要排除部分請求

①：創建Xss請求過濾類`XssHttpServletRequestWraper`

代碼如下：

public class XssHttpServletRequestWraper extends HttpServletRequestWrapper {

    Logger log = LoggerFactory.getLogger(this.getClass());


    public XssHttpServletRequestWraper() {
        super(null);
    }

    public XssHttpServletRequestWraper(HttpServletRequest httpservletrequest) {
        super(httpservletrequest);
    }

 //過濾springmvc中的 @RequestParam 注解中的引數
    public String[] getParameterValues(String s) {

        String str[] = super.getParameterValues(s);
        if (str == null) {
            return null;
        }
        int i = str.length;
        String as1[] = new String[i];
        for (int j = 0; j < i; j++) {
            //System.out.println("getParameterValues:"+str[j]);
            as1[j] = cleanXSS(cleanSQLInject(str[j]));
        }
        log.info("XssHttpServletRequestWraper凈化后的請求為：==========" + as1);
        return as1;
    }

 //過濾request.getParameter的引數
    public String getParameter(String s) {
        String s1 = super.getParameter(s);
        if (s1 == null) {
            return null;
        } else {
            String s2 = cleanXSS(cleanSQLInject(s1));
            log.info("XssHttpServletRequestWraper凈化后的請求為：==========" + s2);
            return s2;
        }
    }

 //過濾請求體 json 格式的
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(inputHandlers(super.getInputStream ()).getBytes ());

        return new ServletInputStream() {

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

            @Override
            public boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) { }
        };
    }

 
    public   String inputHandlers(ServletInputStream servletInputStream){
        StringBuilder sb = new StringBuilder();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(servletInputStream, Charset.forName("UTF-8")));
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (servletInputStream != null) {
                try {
                    servletInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return  cleanXSS(sb.toString ());
    }

    public String cleanXSS(String src) {
        String temp = src;

        src = https://www.cnblogs.com/javastack/p/src.replaceAll("<", "＜").replaceAll(">", "＞");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("\\(", "（").replaceAll("\\)", "）");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("'", "＇");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll(";", "；");
        //bgh 2018/05/30  新增
        /**-----------------------start--------------------------*/
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("\\(", "& #40;").replaceAll("\\)", "& #41");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("eval\\((.*)\\)", "");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("script", "");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("link", "");
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("frame", "");
        /**-----------------------end--------------------------*/
        Pattern pattern = Pattern.compile("(eval\\((.*)\\)|script)",
                Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(src);
        src = https://www.cnblogs.com/javastack/p/matcher.replaceAll("");

        pattern = Pattern.compile("[\\\"\\'][\\s]*javascript:(.*)[\\\"\\']",
                Pattern.CASE_INSENSITIVE);
        matcher = pattern.matcher(src);
        src = https://www.cnblogs.com/javastack/p/matcher.replaceAll("\"\"");

        // 增加腳本
        src = https://www.cnblogs.com/javastack/p/src.replaceAll("script", "").replaceAll(";", "")
                /*.replaceAll("\"", "").replaceAll("@", "")*/
                .replaceAll("0x0d", "").replaceAll("0x0a", "");

        if (!temp.equals(src)) {
            // System.out.println("輸入資訊存在xss攻擊！");
            // System.out.println("原始輸入資訊-->" + temp);
            // System.out.println("處理后資訊-->" + src);

            log.error("xss攻擊檢查：引數含有非法攻擊字符，已禁止繼續訪問！！");
            log.error("原始輸入資訊-->" + temp);

            throw new CustomerException("xss攻擊檢查：引數含有非法攻擊字符，已禁止繼續訪問！！");
        }
        return src;
    }

    //輸出
    public void outputMsgByOutputStream(HttpServletResponse response, String msg) throws IOException {
        ServletOutputStream outputStream = response.getOutputStream(); //獲取輸出流
        response.setHeader("content-type", "text/html;charset=UTF-8"); //通過設定回應頭控制瀏覽器以UTF-8的編碼顯示資料，如果不加這句話，那么瀏覽器顯示的將是亂碼
        byte[] dataByteArr = msg.getBytes("UTF-8");// 將字符轉換成位元組陣列，指定以UTF-8編碼進行轉換
        outputStream.write(dataByteArr);// 使用OutputStream流向客戶端輸出位元組陣列
    }

    // 需要增加通配，過濾大小寫組合
    public String cleanSQLInject(String src) {
        String lowSrc = https://www.cnblogs.com/javastack/p/src.toLowerCase();
        String temp = src;
        String lowSrcAfter = lowSrc.replaceAll("insert", "forbidI")
                .replaceAll("select", "forbidS")
                .replaceAll("update", "forbidU")
                .replaceAll("delete", "forbidD").replaceAll("and", "forbidA")
                .replaceAll("or", "forbidO");

        if (!lowSrcAfter.equals(lowSrc)) {
            log.error("sql注入檢查：輸入資訊存在SQL攻擊！");
            log.error("原始輸入資訊-->" + temp);
            log.error("處理后資訊-->" + lowSrc);
            throw new CustomerException("sql注入檢查：引數含有非法攻擊字符，已禁止繼續訪問！！");

        }
        return src;
    }

}

②：把請求過濾類`XssHttpServletRequestWraper`添加到Filter中，注入容器

@Component
public class XssFilter implements Filter {

    Logger log  = LoggerFactory.getLogger(this.getClass());

    // 忽略權限檢查的url地址
    private final String[] excludeUrls = new String[]{
            "null"
    };

    public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
            throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest) arg0;
        HttpServletResponse response = (HttpServletResponse) arg1;

        String pathInfo = req.getPathInfo() == null ? "" : req.getPathInfo();
        //獲取請求url的后兩層
        String url = req.getServletPath() + pathInfo;
        //獲取請求你ip后的全部路徑
        String uri = req.getRequestURI();
        //注入xss過濾器實體
        XssHttpServletRequestWraper reqW = new XssHttpServletRequestWraper(req);

        //過濾掉不需要的Xss校驗的地址
        for (String str : excludeUrls) {
            if (uri.indexOf(str) >= 0) {
                arg2.doFilter(arg0, response);
                return;
            }
        }
        //過濾
        arg2.doFilter(reqW, response);
    }
    public void destroy() {
    }
    public void init(FilterConfig filterconfig1) throws ServletException {
    }
}

上述代碼已經可以完成請求引數、JSON請求體的過濾，但對于json請求體還有其他的方式實作，有興趣的請看下面的擴展！

擴展：還可以重寫spring中的MappingJackson2HttpMessageConverter來過濾Json請求體

因為請求體在進出Contoroller時，會經過MappingJackson2HttpMessageConverter的一個轉換，把請求體轉換成我們需要的json格式，所以可以在這里邊做一些修改！

@Configuration
public class MyConfiguration {

    @Bean
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter(){
        //自定義轉換器
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();


        //轉換器日期格式設定
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleDateFormat smt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        objectMapper.setDateFormat(smt);
        converter.setObjectMapper(objectMapper);

        //轉換器添加自定義Module擴展，主要是在這里做XSS過濾的！！，其他的是其他業務，不用看
        SimpleModule simpleModule = new SimpleModule();
        //添加過濾邏輯類！
        simpleModule.addDeserializer(String.class,new StringDeserializer());
        converter.getObjectMapper().registerModule(simpleModule);

        //設定中文編碼格式
        List<MediaType> list = new ArrayList<>();
        list.add(MediaType.APPLICATION_JSON_UTF8);
        converter.setSupportedMediaTypes(list);

        return converter;
    }

}

真正的過濾邏輯類StringDeserializer：

//檢驗請求體的引數
@Component
public class StringDeserializer extends JsonDeserializer<String> {
    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        String str = jsonParser.getText().trim();
        //sql注入攔截
        if (sqlInject(str)) {
          throw new CustomerException("引數含有非法攻擊字符，已禁止繼續訪問！");
        }

        return xssClean(str);

    }

    public boolean sqlInject(String str) {

        if (StringUtils.isEmpty(str)) {
            return false;
        }

        //去掉'|"|;|\字符
        str = org.apache.commons.lang3.StringUtils.replace(str, "'", "");
        str = org.apache.commons.lang3.StringUtils.replace(str, "\"", "");
        str = org.apache.commons.lang3.StringUtils.replace(str, ";", "");
        str = org.apache.commons.lang3.StringUtils.replace(str, "\\", "");

        //轉換成小寫
        str = str.toLowerCase();

        //非法字符
        String[] keywords = {"master", "truncate", "insert", "select", "delete", "update", "declare", "alert","alter", "drop"};

        //判斷是否包含非法字符
        for (String keyword : keywords) {
            if (str.indexOf(keyword) != -1) {
                return true;
            }
        }
        return false;

    }

    //xss攻擊攔截

    public String xssClean(String value) {
        if (value =https://www.cnblogs.com/javastack/p/= null ||"".equals(value)) {
            return value;
        }

        //非法字符
        String[] keywords = {"<", ">", "<>", "()", ")", "(", "javascript:", "script","alter", "''","'"};
        //判斷是否包含非法字符
        for (String keyword : keywords) {
            if (value.indexOf(keyword) != -1) {
               throw new CustomerException("引數含有非法攻擊字符，已禁止繼續訪問！");
            }
        }

        return value;
    }
}

使用這種形式也可以完成json請求體的過濾，但個人更推薦使用XssHttpServletRequestWraper的形式來完成xss過濾！！

來源：blog.csdn.net/qq_45076180/article/details/115000495

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了，，，

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/547440.html

標籤：Java

上一篇：聊一聊系統重構

下一篇：主流的第三方直播SDK對比（騰訊云、即構、阿里云、聲網、網易云信、網宿）

Spring Boot 如果防護 XSS + SQL 注入攻擊 ？一文帶你搞定！