XSS：跨站脚本攻击(Cross Site Scripting)，为不和 CSS混淆，故将跨站脚本攻击缩写为XSS。XSS是指恶意攻击者往Web页面里插入恶意Script代码，当用户浏览该页时，嵌入其中Web里面的Script代码会被执行，从而达到恶意攻击用户的目的。有点类似于sql注入。

XSS攻击原理：

HTML是一种超文本标记语言，通过将一些字符特殊地对待来区别文本和标记，例如，小于符号（<）被看作是HTML标签的开始，<title>与</title>之间的字符是页面的标题等等。当动态页面中插入的内容含有这些特殊字符时，用户浏览器会将其误认为是插入了HTML标签，当这些HTML标签引入了一段JavaScript脚本时，这些脚本程序就将会在用户浏览器中执行。所以，当这些特殊字符不能被动态页面检查或检查出现失误时，就将会产生XSS漏洞。

AntiSamy是OWASP的一个开源项目，通过对用户输入的 HTML / CSS / JavaScript 等内容进行检验和清理，确保输入符合应用规范。AntiSamy被广泛应用于Web服务对存储型和反射型XSS的防御中。

在学习之前先了解以下Antisamy的策略文件：

antisamy.xml

默认规则，允许大部分HTML通过

antisamy-slashdot.xml 
用户只能提交下列的html标签：<b>, <u>, <i>, <a>, <blockquote>。

antisamy-ebay.xml
用户可以输入一系列的HTML的内容，不包含JavaScript。

antisamy-myspace.xml

更多的HTML和CSS，只要不包含JavaScript。

antisamy-anythinggoes.xml
更多的HTML和CSS元素输入，但不包含JavaScript。

antisamy-tinymce.xml

只允许文本格式通过，相对较安全

接下来让我们以入门案例展开学习：

pom.xml依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.     <!--springBoot依赖-->
  7.     <parent>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-parent</artifactId>
  10.         <version>2.2.2.RELEASE</version>
  11.         <relativePath/>
  12.     </parent>
  13.     <groupId>com.xiaoteng</groupId>
  14.     <artifactId>antiSamy-demo</artifactId>
  15.     <version>1.0-SNAPSHOT</version>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.         </dependency>
  21.         <!--antisamy-->
  22.         <dependency>
  23.             <groupId>org.owasp.antisamy</groupId>
  24.             <artifactId>antisamy</artifactId>
  25.             <version>1.5.7</version>
  26.         </dependency>
  27.         <!--lombok-->
  28.         <dependency>
  29.             <groupId>org.projectlombok</groupId>
  30.             <artifactId>lombok</artifactId>
  31.         </dependency>
  32.     </dependencies>
  34. </project>

第二步：创建策略文件，文件内容可以从antisamy的jar包中获取

    复制了一份

注：AntiSamy对“恶意代码”的过滤依赖于策略文件。策略文件规定了AntiSamy对各个标签、属性的处理方法，策略文件定义的严格与否，决定了AntiSamy对XSS漏洞的防御效果。在AntiSamy的jar包中，包含了几个常用的策略文件

xml里有对各种标签的处理：比如下图 对script是remove(删除处理)

三：创建实体类与Controller

  1. package com;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. /**
  7.  * @author xiaozhuang
  8.  * @date 2022年03月01日 22:25
  9.  */
  10. @SpringBootApplication
  11. public class AntiSamyApp {
  12.     public static void main(String[] args) {
  13.         SpringApplication.run(AntiSamyApp.class,args);
  14.     }
  15. }
  1. package com.controller;
  3. import com.entity.User;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  7. /**
  8.  * @author xiaozhuang
  9.  * @date 2022年03月01日 22:23
  10.  */
  11. @RestController
  12. @RequestMapping("/user")
  13. public class UserController {
  14.     @RequestMapping("/save")
  15.     public String save(User user){
  16.         System.out.println("传入的对象属性输出.... " + user);
  17.         return user.getName();
  18.     }
  19. }

再来一个html页面

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <head>
  4.         <meta charset="UTF-8">
  5.         <title>Title</title>
  6.     </head>
  7.     <body>
  8.         <form method="post" action="/user/save">
  9.             id:<input type="text" name="id"><br>
  10.             name:<input type="text" name="name"><br>
  11.             age:<input type="text" name="age"><br>
  12.             <input type="submit" value="submit">
  13.         </form>
  14.     </body>
  15. </html>

此时我们启动服务并打开静态页面：此时我们还没有用到Antisamy的防XSS攻击，先看一下没用前是怎样的。

首先我输入第一个：

点击提交后：

后台输出：

当我们用script写一个for循环时：

页面会跳十次alert

这些就是XSS攻击！

此时我们启动的项目并进行访问，但是还没有进行参数的过滤，所以如果我们输入任意参数都可以正常传递到Controller中，这在实际项目中是非常不安全的。为了对我们输入的数据进行过滤清理，需要通过过滤器来实现。

创建过滤器，用于过滤所有提交到服务器的请求参数

  1. package com.filter;
  3. import com.entity.XssRequestWrapper;
  5. import javax.servlet.*;
  6. import javax.servlet.http.HttpServletRequest;
  7. import java.io.IOException;
  9. /*
  10.  *过滤所有提交到服务器的请求参数
  11.  */
  12. public class XssFilter implements Filter {
  13.     @Override
  14.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
  15.                          FilterChain filterChain) throws IOException, ServletException {
  17.         HttpServletRequest request = (HttpServletRequest)servletRequest;
  18.         //传入重写后的Request
  19.         filterChain.doFilter(new XssRequestWrapper(request),servletResponse);
  20.     }
  21. }

注意：通过上面的过滤器可以发现我们并没有在过滤器中直接进行请求参数的过滤清理，而是直接放行了，那么我们还怎么进行请求参数的过滤清理呢？其实过滤清理的工作是在另外一个类XssRequestWrapper中进行的，当上面的过滤器放行时需要调用filterChain.doFilter()方法，此方法需要传入请求Request对象，此时我们可以将当前的request对象进行包装，而XssRequestWrapper就是Request对象的包装类，在过滤器放行时会自动调用包装类的getParameterValues方法，我们可以在包装类的getParameterValues方法中进行统一的请求参数过滤清理。

  1. package com.entity;
  3. import org.owasp.validator.html.*;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletRequestWrapper;
  7. import java.util.Map;
  8. import java.util.Objects;
  10. /**
  11.  * @author xiaozhuang
  12.  * @date 2022年03月02日 22:57
  13.  */
  14. public class XssRequestWrapper extends HttpServletRequestWrapper {
  15.     /**
  16.      * 策略文件 需要将要使用的策略文件放到项目资源文件路径下
  17.      * */
  18.     private static String antiSamyPath = Objects.requireNonNull(XssRequestWrapper.class.getClassLoader()
  19.             .getResource("antisamy-ebay.xml")).getFile();
  21.     private static  Policy policy = null;
  22.     static {
  23.         // 指定策略文件
  24.         try {
  25.             policy = Policy.getInstance(antiSamyPath);
  26.         } catch (PolicyException e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  31.     /**
  32.      * AntiSamy过滤数据
  33.      * @param taintedHTML 需要进行过滤的数据
  34.      * @return 返回过滤后的数据
  35.      * */
  36.     private String xssClean( String taintedHTML){
  37.         try{
  38.             // 使用AntiSamy进行过滤
  39.             AntiSamy antiSamy = new AntiSamy();
  40.             CleanResults cr = antiSamy.scan( taintedHTML, policy);
  41.             taintedHTML = cr.getCleanHTML();
  42.         }catch( ScanException | PolicyException e) {
  43.             e.printStackTrace();
  44.         }
  45.         return taintedHTML;
  46.     }
  48.     public XssRequestWrapper(HttpServletRequest request) {
  49.         super(request);
  50.     }
  51.     @Override
  52.     public String[] getParameterValues(String name){
  53.         String[] values = super.getParameterValues(name);
  54.         if ( values == null){
  55.             return null;
  56.         }
  57.         int len = values.length;
  58.         String[] newArray = new String[len];
  59.         for (int j = 0; j < len; j++){
  60.             // 过滤清理
  61.             newArray[j] = xssClean(values[j]);
  62.         }
  63.         return newArray;
  64.     }
  66.     @Override
  67.     public String getParameter(String paramString) {
  68.         String str = super.getParameter(paramString);
  69.         if (str == null) {
  70.             return null;
  71.         }
  72.         return xssClean(str);
  73.     }
  75.     @Override
  76.     public String getHeader(String paramString) {
  77.         String str = super.getHeader(paramString);
  78.         if (str == null) {
  79.             return null;
  80.         }
  81.         return xssClean(str);
  82.     }
  84.     @Override
  85.     public Map<String, String[]> getParameterMap() {
  86.         Map<String, String[]> requestMap = super.getParameterMap();
  87.         for (Map.Entry<String, String[]> me : requestMap.entrySet()) {
  88.             String[] values = me.getValue();
  89.             for (int i = 0; i < values.length; i++) {
  90.                 values[i] = xssClean(values[i]);
  91.             }
  92.         }
  93.         return requestMap;
  94.     }
  96. }

为了使上面定义的过滤器生效，需要创建配置类，用于初始化过滤器对象

  1. package com.config;
  3. import com.filter.XssFilter;
  4. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  8. /**
  9.  * @author xiaozhuang
  10.  * @date 2022年03月02日 23:03
  11.  */
  12. @Configuration
  13. public class AntiSamyConfiguration {
  14.     /**
  15.      * 配置跨站攻击过滤器
  16.      */
  17.     @Bean
  18.     public FilterRegistrationBean filterRegistrationBean() {
  19.         FilterRegistrationBean filterRegistration =
  20.                 new FilterRegistrationBean(new XssFilter());
  21.         filterRegistration.addUrlPatterns("/*");
  22.         filterRegistration.setOrder(1);
  24.         return filterRegistration;
  25.     }
  26. }

启动项目，页面输入非法数据，可以看到非法数据被清理掉了。

注意：当前我们在进行请求参数过滤时只是在包装类的getParameterValues方法中进行了处理，真实项目中可能用户提交的数据在请求头中，也可能用户提交的是json数据，所以如果考虑所有情况，我们可以在包装类中的多个方法中都进行清理处理即可

我们来看一下效果：

可以看到name属性传过来的script标签被过滤掉了！

紧接着我又输入了h1的标签 ，看看情况：

这时h1的

就如同上面接收策略文件时所说，不会过滤此些标签！

XSS防跨站脚本攻击-AntiSamy的基本使用的更多相关文章

  1. Anti XSS 防跨站脚本攻击库

    https://wpl.codeplex.com/ Before understanding Anti-Cross Site Scripting Library (AntiXSS), let us u ...

  2. web 安全 & web 攻防: XSS（跨站脚本攻击）和 CSRF（跨站请求伪造）

    web 安全 & web 攻防: XSS(跨站脚本攻击)和 CSRF(跨站请求伪造) XSS(跨站脚本攻击)和CSRF(跨站请求伪造) Cross-site Scripting (XSS) h ...

  3. thinkphp 防止XSS（跨站脚本攻击）

    XSS(跨站脚本攻击)可以用于窃取其他用户的Cookie信息,要避免此类问题,可以采用如下解决方案: 直接过滤所有的JavaScript脚本: 转义Html元字符,使用htmlentities.htm ...

  4. xss（跨站脚本攻击）

    xss(跨站脚本攻击) 原理:攻击者可以通过在页面中注入恶意链接或者脚本代码,当受害者访问时,脚本代码会在其浏览器中执行,这个时候,我们可以获取当前用户的cookie或者进行重定向等操作. xss造成 ...

  5. 聊两句XSS（跨站脚本攻击）

    XSS(跨站脚本攻击),聊两句,五毛的. XSS的危害: 窃取Cookie,盗用用户身份信息 这玩意儿是大多数XSS的目标,也好解决,可以先治个标,直接设置HttpOnly=true ,即不允许客户端 ...

  6. XSS（跨站脚本攻击）的最全总结

    从OWASP的官网意译过来,加上自己的理解,算是比较全面的介绍.有兴趣的可私下交流. XSS 跨站脚本攻击 ============================================== ...

  7. 关于XSS（跨站脚本攻击）和CSRF（跨站请求伪造）

    我们常说的网络安全其实应该包括以下三方面的安全: 1.机密性,比如用户的隐私被窃取,帐号被盗,常见的方式是木马. 2.完整性,比如数据的完整,举个例子,康熙传位十四子,被当时四阿哥篡改遗诏:传位于四子 ...

  8. Magicodes.WeiChat——使用AntiXssAttribute阻止XSS（跨站脚本攻击）攻击

    跨站脚本攻击(Cross Site Scripting),为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆,故将跨站脚本攻击缩写为XSS.恶意攻击者往Web页面里插 ...

  9. Web安全测试之XSS（跨站脚本攻击）

    XSS 全称(Cross Site Scripting) 跨站脚本攻击, 是Web程序中最常见的漏洞.指攻击者在网页中嵌入客户端脚本(例如JavaScript), 当用户浏览此网页时,脚本就会在用户的 ...

随机推荐

  1. 「实践篇」解决微前端 single-spa 项目中 Vue 和 React 路由跳转问题

    前言 本文介绍的是在做微前端 single-spa 项目过程中,遇到的 Vue 子应用和 React 子应用互相跳转路由时遇到的问题. 项目情况:single-spa 项目,基座用的是 React,目 ...

  2. 使用nmtui命令解决network-scripts目录下无网卡对应配置文件问题

    //网卡通过命令ifconfig可以识别到,但是在配置文件目录下,没有该文件,一旦重启等配置了该地址的应用则可能会出现问题所以需要重新生成对应配置文件,我首先想到的就是用 nmtui 这个程序来重新生 ...

  3. Android 环境搭建记录

    Android 环境搭建记录 官网 https://developer.android.com/ studio 下载地址 官方下载 jikexueyuanwiki 国内镜像 studio历史版本 安装 ...

  4. Solon 1.6.36 发布，更现代感的应用开发框架

    相对于 Spring Boot 和 Spring Cloud 的项目 启动快 5 - 10 倍 qps 高 2- 3 倍 运行时内存节省 1/3 ~ 1/2 打包可以缩小到 1/2 ~ 1/10(比如 ...

  5. gh-ost使用问题记录

    因为 pt-osc 对数据库性能影响较大,且容易造成死锁问题,目前我们在线更改表结构都使用 gh-ost 工具进行修改,这里记录一下使用 gh-ost 过程中的问题,以作记录:首先先复习一下gh-os ...

  6. 【论文阅读】ConvNeXt：A ConvNet for the 2020s 新时代卷积网络

    一.ConvNext Highlight 核心宗旨:基于ResNet-50的结构,参考Swin-Transformer的思想进行现代化改造,知道卷机模型超过trans-based方法的SOTA效果. ...

  7. react 可拖拽改变位置和大小的弹窗

    一 目标 最近,项目上需要一个可以弹出一个可以移动位置和改变大小的窗口,来显示一下对当前页面的一个辅助内容 二 思路 1.之前写过一个antd modal的可移动弹窗但是毕竟不如自己写的更定制化,比如 ...

  8. php 迭代器的学习

    在PHP中有一些预定义的类,比如迭代器类,有SPL提供.常用的几个类: Iterator------最基本的迭代器 IteratorAggregate --------可以提供一个迭代器的对象,但它本 ...

  9. 做SaaS的程序员们，是时候关注企业架构了

    SaaS赛道是一个超大赛道,足够容纳上万家服务商,不太可能有哪个服务商能满足所有场景,大部分SaaS服务商在某个垂直领域,提供差异化的产品和服务.SaaS产品大部分都是面向B端客户,少部分面向C端客户 ...

  10. Spring配置及依赖注入

    入门 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-we ...