一. XSS 介绍

网站中包含大量的动态内容以提高用户体验，比过去要复杂得多。所谓动态内容，就是根据用户环境和需要，Web 应用程序能够输出相应的内容。动态站点会受到一种名为 “跨站脚本攻击”（Cross Site Scripting, 安全专家们通常将其缩写成 XSS, 原本应当是 css，但为了和层叠样式表（Cascading Style Sheet,CSS ）有所区分，故称 XSS）的威胁，而静态站点则完全不受其影响。

二. 攻击类型

  1. 持久型跨站：最直接的危害类型，跨站代码存储在服务器（数据库）。
  2. 非持久型跨站：反射型跨站脚本漏洞，最普遍的类型。用户访问服务器 - 跨站链接 - 返回跨站代码。
  3. DOM 跨站（DOM XSS）:DOM(document object model 文档对象模型)，客户端脚本处理逻辑导致的安全问题。

关于 XSS 的更多信息，具体可以参考百度百科。

三. 解决方案

1. 自定义 HttpServletRequestWrapper

  1. /**
  2.  * XSS过滤处理类，用于HTTP请求中特殊字符的转换，解决跨站点等攻击
  3.  *
  4.  * @date 2020-03-16
  5.  * @author DaiQi
  6.  */
  7. public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
  9.     /**
  10.      * 请求
  11.      */
  12.     private HttpServletRequest xssRequest = null;
  14.     public XssHttpServletRequestWrapper(HttpServletRequest request) {
  15.         super(request);
  16.         xssRequest = request;
  17.     }
  19.     /**
  20.      * 覆盖getParameter方法，将参数名和参数值都做xss过滤。<br/>
  21.      * 如果需要获得原始的值，则通过super.getParameterValues(name)来获取<br/>
  22.      * getParameterNames,getParameterValues和getParameterMap也可能需要覆盖
  23.      * @param name 名称
  24.      * @return 返回字符串
  25.      */
  26.     public String getParameter(String name) {
  27.         String value = super.getParameter(XssUtil.xssEncode(name));
  28.         if (value != null) {
  29.             value = XssUtil.xssEncode(value);
  30.         }
  32.         return value;
  33.     }
  35.     /**
  36.      * 覆盖getHeader方法，将参数名和参数值都做xss过滤。<br/>
  37.      * 如果需要获得原始的值，则通过super.getHeaders(name)来获取<br/>
  38.      * getHeaderNames 也可能需要覆盖
  39.      * @param name 名称
  40.      * @return 返回字符串
  41.      */
  42.     public String getHeader(String name) {
  43.         String value = super.getHeader(XssUtil.xssEncode(name));
  44.         if (!StringUtils.isEmpty(value)) {
  45.             //方法一：自定义XSS过滤工具类
  46.             value = XssUtil.xssEncode(value);
  47.             //方法二：转义为html格式
  48.             //org.apache.commons.lang3下的StringEscapeUtils已经过时了
  49.             //可以使用org.apache.commons.text.StringEscapeUtils 进行替换
  50.             //value = org.apache.commons.lang3.StringEscapeUtils.escapeHtml4(value);
  51.         }
  52.         return value;
  53.     }
  55.     /**
  56.      * 获取最原始的request的静态方法
  57.      * @param req req`在这里插入代码片`
  58.      * @return HttpServletRequest
  59.      */
  60.     public static HttpServletRequest getOrgRequest(HttpServletRequest req) {
  61.         if (req instanceof XssHttpServletRequestWrapper) {
  62.             return ((XssHttpServletRequestWrapper) req).xssRequest;
  63.         }
  64.         return req;
  65.     }
  66. }

2. 自定义过滤器

  1. /**
  2.  * XSS过滤器
  3.  * 
  4.  * @date 2020-03-16
  5.  * @author DaiQi
  6.  */
  7. @Order(2)
  8. @WebFilter(filterName = "xssFilter", urlPatterns = "/*")
  9. public class XssFilter extends OncePerRequestFilter {
  11.     /**
  12.      * 内部过滤
  13.      * 
  14.      * @param request
  15.      * @param response
  16.      * @param filterChain
  17.      * @throws ServletException
  18.      * @throws IOException
  19.      */
  20.     @Override
  21.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
  22.             throws ServletException, IOException {
  23.         XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper(request);
  25.         filterChain.doFilter(xssRequest, response);
  26.     }
  28. }

3.XssUtil

  1. /**
  2.  * XSS工具类
  3.  */
  4. public class XssUtil {
  6.     /**
  7.      * 常量16
  8.      */
  9.     public static final int NUM_16 = 16;
  11.     /**
  12.      * 私有构造函数
  13.      */
  14.     private XssUtil() {
  16.     }
  18.     /**
  19.      * 将容易引起xss漏洞的半角字符直接替换成全角字符
  20.      *
  21.      * @param s 原字符串
  22.      * @return 替换后的字符串
  23.      */
  24.     public static String xssEncode(String s) {
  25.         if (s == null || "".equals(s)) {
  26.             return s;
  27.         }
  28.         StringBuilder sb = new StringBuilder(s.length() + NUM_16);
  29.         for (int i = 0; i < s.length(); i++) {
  30.             char c = s.charAt(i);
  31.             switch (c) {
  32.                 case '>':
  33.                     sb.append('＞');// 全角大于号
  34.                     break;
  35.                 case '<':
  36.                     sb.append('＜');// 全角小于号
  37.                     break;
  38.                  case '\'':
  39.                  sb.append('‘');// 全角单引号
  40.                  break;
  41.                  case '\"':
  42.                  sb.append('“');// 全角双引号
  43.                  break;
  44.                  case '&':
  45.                  sb.append('＆');// 全角与逻辑符
  46.                  break;
  47.                  case '%':
  48.                  sb.append('％');// 全角百分号
  49.                  break;
  50.                  case '+':
  51.                  sb.append("＋");// 全角加号
  52.                  break;
  53.                  case ';':
  54.                  sb.append("；");// 全角分号
  55.                  break;
  56.                  case '\\':
  57.                  sb.append('＼');// 全角斜线
  58.                  break;
  59.                  case '/':
  60.                  sb.append('／');// 全角斜线
  61.                  break;
  62.                  case '#':
  63.                  sb.append('＃');// 全角井号
  64.                  break;
  65.                  case ':':
  66.                  sb.append('：');// 全角冒号
  67.                  break;
  68.                 default:
  69.                     sb.append(c);
  70.                     break;
  71.             }
  72.         }
  73.         return sb.toString();
  74.     }
  75. }