XSS攻击

原创已于 2024-04-15 11:41:48 修改 · 1.3k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#xss #网络 #安全

于 2024-04-15 11:27:45 首次发布

安全认证鉴权专栏收录该内容

20 篇文章

订阅专栏

文章目录

跨站脚本攻击（XSS，Cross-Site Scripting）是一种常见的安全漏洞，攻击者利用此漏洞向网页中插入恶意的客户端脚本，从而在用户的浏览器中执行恶意代码。攻击者通常利用 XSS 攻击来窃取用户的信息、会话令牌，或者篡改网页内容等。

XSS 攻击的类型：

存储型 XSS（Stored XSS）：攻击者将恶意代码存储在目标网站上，当其他用户访问受感染的页面时，恶意代码会从服务器加载并在用户的浏览器中执行。
反射型 XSS（Reflected XSS）：攻击者将包含恶意代码的链接发送给用户，当用户点击链接时，恶意代码被发送到服务器，并在响应中反射回用户的浏览器执行。这种类型的攻击通常需要诱使用户点击特制的恶意链接。
DOM 型 XSS（DOM-based XSS）：攻击者利用客户端脚本在浏览器中修改网页的 DOM 结构，从而执行恶意代码。这种攻击不涉及服务器端的数据传输，而是利用浏览器在处理客户端脚本时的漏洞。

XSS 攻击的原理：

攻击者通常利用网页中未经过滤的用户输入，例如表单输入、URL 参数等，向页面注入恶意脚本。这些恶意脚本可以是 JavaScript、VBScript、Flash 等客户端脚本语言。一旦用户浏览了包含恶意代码的页面，浏览器会执行其中的恶意脚本，导致攻击者获得用户的敏感信息或者执行其他恶意操作。
攻击者通过各种途径，如在输入框、URL参数、Cookie等地方注入恶意脚本代码。
当用户访问包含恶意脚本的页面时，浏览器会自动执行这些脚本，而用户可能并不知情。
恶意脚本可以窃取用户的Cookie信息、用户输入的敏感信息，篡改页面内容，甚至劫持用户会话。

XSS 攻击的危害：

窃取用户信息：攻击者可以通过 XSS 攻击窃取用户的个人信息、登录凭证、会话令牌等敏感信息。
劫持用户会话：攻击者可以利用 XSS 攻击获取用户的会话令牌，然后伪装成用户，执行未经授权的操作。
篡改网页内容：攻击者可以在受感染的网页中篡改页面内容，误导用户或传播恶意链接。
发起钓鱼攻击：攻击者可以利用 XSS 攻击伪装成受信任的网站，诱使用户输入敏感信息或下载恶意软件。

防御 XSS跨站脚本攻击的方法

跨站脚本攻击（XSS）是一种常见的 Web 安全漏洞，攻击者通过在受害者的浏览器上执行恶意脚本来实现。解决 XSS 攻击需要采取多种措施，包括以下几点：

输入验证和过滤：在接收用户输入并在网页上显示之前，应该对输入数据进行验证和过滤。可以使用白名单过滤器来只允许特定的字符或格式，或者使用黑名单过滤器来移除潜在的恶意代码。
转义输出数据：在将用户输入数据插入到 HTML、CSS、JavaScript 或其他上下文中时，应该对数据进行适当的转义，确保它们不会被解释为代码。例如，在 HTML 中使用 < 替换 <、> 替换 >，以及使用 " 替换 "。
设置 HttpOnly 标志的 Cookie：通过将敏感信息存储在带有 HttpOnly 标志的 Cookie 中，可以降低 XSS 攻击的风险，因为这样攻击者无法通过 JavaScript 访问到这些 Cookie 数据。
使用 Content Security Policy（CSP）：CSP 是一个 HTTP 头部，它允许网站管理员定义允许加载的内容源，以及限制允许执行的 JavaScript。通过正确配置 CSP，可以减少 XSS 攻击的可能性。
限制 JavaScript 功能：避免使用 eval()、document.write() 等容易被滥用的 JavaScript 功能。此外，尽量减少内联 JavaScript 代码，而是将其移动到外部文件中加载。
安全开发实践：采用安全的开发实践，包括定期审查代码、使用安全的开发框架和库、更新软件到最新版本等。
教育和意识提升：培训开发人员和终端用户，让他们了解 XSS 攻击的工作原理以及如何防范。
通过综合采取这些措施，可以有效降低网站遭受 XSS 攻击的风险，并提高 Web 应用程序的安全性。

XSS攻击项目整改

关于网站XSS攻击的防范办法，请开发时注意：
1.目前增加了XssFilter针对Xss攻击的提交信息做大面积的拦截，并且增强了验证规则(对tagName验证，通过el表达式对内容验证)
2.在XssFilter处理的是大概率的事件，但仍有机会绕过过滤器，请开发人员做到如下两点：
1）表单提交的内容，可能会被Xss攻击利用的，使用apache lang包的方法 StringEscapeUtils.escapeHtml(str) 对内容处理后再入库
2）校验内容：RegexUtils.judgeTagByRegular(str.toLowerCase()) 对内容进行正则校验,如果匹配，则方法直接返回，跳转到提示页
XSS
后端对所有请求增加xss过滤，代码结构如下

自定义xxs请求过滤，对请求头、参数及url参数做特殊字符过滤

package com.yuntongxun.aihelper.api.filter;
import com.yuntongxun.aihelper.api.utils.XssUtil;
import org.springframework.web.servlet.HandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;


/**
 * @author lc
 * @Date 2022/12/01
 */
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {

    public XssHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    /**
    * 对header处理
    * @param name
    * @return
    */
    @Override
    public String getHeader(String name) {
        String value = super.getHeader(name);
        return XssUtil.cleanXSS(value);
    }

    /**
    * 对参数处理
    * @param name
    * @return
    */
    @Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        return XssUtil.cleanXSS(value);
    }

    /**
    * 对数值进行处理
    * @param name
    * @return
    */
    @Override
    public String[] getParameterValues(String name) {
        String[] values = super.getParameterValues(name);
        if (values != null) {
            int length = values.length;
            String[] escapesValues = new String[length];
            for (int i = 0; i < length; i++) {
                escapesValues[i] = XssUtil.cleanXSS(values[i]);
            }
            return escapesValues;
        }
        return super.getParameterValues(name);
    }

    /**
    * 主要是针对HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE 获取pathvalue的时候把原来的pathvalue经过xss过滤掉
    */
    @Override
    public Object getAttribute(String name) {
        // 获取pathvalue的值
        if (HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE.equals(name)) {
            Map uriTemplateVars = (Map) super.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
            if (Objects.isNull(uriTemplateVars)) {
                return uriTemplateVars;
            }
            Map newMap = new LinkedHashMap<>();
            uriTemplateVars.forEach((key, value) -> {
                if (value instanceof String) {
                    newMap.put(key, XssUtil.cleanXSS((String) value));
                } else {
                    newMap.put(key, value);

                }
            });
            return newMap;
        } else {
            return super.getAttribute(name);
        }
    }
}
对json形式的参数做特殊字符过滤

package com.yuntongxun.aihelper.api.filter;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.yuntongxun.aihelper.api.utils.XssUtil;

import java.io.IOException;

/**
 * @author wangjs
 * @Date 2022/12/01
 */
public class XssStringJsonDeserializer extends JsonDeserializer<String> {


    @Override
    public Class<String> handledType() {
        return String.class;
    }

    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        return XssUtil.cleanXSS(jsonParser.getValueAsString());
   }
}
自定义需过滤的字符

package com.yuntongxun.aihelper.api.utils;
 
import java.util.Objects;
 
/**
 * @author wangjs
 * @Date 2022/12/01
 */
public class XssUtil {
 
   public static String cleanXSS(String value) {
      if (Objects.isNull(value)) {
         return null;
      }
      //在这里自定义需要过滤的字符
      value = value.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
      value = value.replaceAll("&", "&amp;");
      value = value.replaceAll("\\(", "&#40;").replaceAll("\\)", "&#41;");
      value = value.replaceAll("'", "&#39;");
      value = value.replaceAll("eval\\((.*)\\)", "");
      value = value.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
      value = value.replaceAll("<script>", "");
      return value;
   }
}
实现过滤器   并设置response的返回的cookie为httponly

package com.yuntongxun.aihelper.api.filter;
 
import org.springframework.stereotype.Component;
 
import javax.servlet.*;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
 
/**
 * @author wangjs
 * @Date 2022/12/01
 */
@Component
public class XssFilter implements Filter {
 
   @Override
   public void doFilter(ServletRequest req, ServletResponse res,
                   FilterChain chain) throws IOException, ServletException {
        // 在这里，使用我们实现的XSS过滤器
      XssHttpServletRequestWrapper request =
            new XssHttpServletRequestWrapper((HttpServletRequest) req);
 
      HttpServletResponse response = (HttpServletResponse) res;
      response.setHeader("Access-Control-Allow-Origin", "*");
      response.setHeader("Access-Control-Allow-Methods",
            "POST, GET, PUT, OPTIONS, DELETE");
      response.setHeader("Access-Control-Max-Age", "3600");
      response.setHeader("Access-Control-Allow-Headers",
            "Origin, X-Requested-With, Content-Type, Accept, token");
 
      Cookie[] cookies = request.getCookies();
 
      if (cookies != null) {
         Cookie cookie = cookies[0];
         if (cookie != null) {
            //Servlet 2.5不支持在Cookie上直接设置HttpOnly属性
            String value = cookie.getValue();
            StringBuilder builder = new StringBuilder();
            builder.append("JSESSIONID=" + value + "; ");
            builder.append("Secure; ");
            builder.append("HttpOnly; ");
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.HOUR, 1);
            Date date = cal.getTime();
            Locale locale = Locale.CHINA;
            SimpleDateFormat sdf =
                  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", locale);
            builder.append("Expires=" + sdf.format(date));
            response.setHeader("Set-Cookie", builder.toString());
         }
      }
        
      chain.doFilter(request, response);
      
   }
 
   @Override
   public void init(FilterConfig filterConfig) {
   }
 
   @Override
   public void destroy() {
   }
 
}
注册过滤器

package com.yuntongxun.aihelper.api.filter;
 
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 
/**
 * @author wangjs
 * @Date 2022/12/01
 */
@Configuration
public class XssFilterAutoConfig {
 
   /**
    * 注册自定义过滤器
    * @return
    */
   @Bean
   public FilterRegistrationBean xssFilterRegister() {
      FilterRegistrationBean registration = new FilterRegistrationBean();
      //设置系统过滤器
      registration.setFilter(new XssFilter());
      //过滤所有路径
      registration.addUrlPatterns("/*");
      //过滤器名称
      registration.setName("XssFilter");
      //优先级
      registration.setOrder(1);
      return registration;
   }
 
   /**
    * 过滤JSON数据
    * @return
    */
   @Bean
   @Primary
   public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
      SimpleModule module = new SimpleModule();
      //自定义序列化过滤配置(XssStringJsonDeserializer), 对入参进行转译
      module.addDeserializer(String.class, new XssStringJsonDeserializer());
      // 注册解析器
      ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
      objectMapper.registerModule(module);
      return new MappingJackson2HttpMessageConverter(objectMapper);
   }
}

对于特殊字符参数辅助系统前端已做过转义

谷歌浏览器默认开启xss防护若检测到为xss攻击则会自动停止页面渲染