XSS攻击和跨站脚本安全漏洞防护

Posted 2023-03-28 柚几哥哥

1、存储型XSS

      指应用程序通过Web请求获取不可信赖的数据，并且在未检验数据是否存在XSS代码的情况下，将其存入数据库。当程序下一次从数据库中获取该数据时，致使页面再次执行XSS代码。存储型XSS可以持续攻击用户，在用户提交了包含XSS代码的数据存储到数据库后，每当用户在浏览网页查询对应数据库中的数据时，那些包含XSS代码的数据就会在服务器解析并加载，当浏览器读到XSS代码后，会当做正常的html和JS解析并执行，于是发生存储型XSS攻击。

**例如**：下面JSP代码片段的功能是根据一个已知用户雇员ID（id）从数据库中查询出该用户的地址，并显示在JSP页面上 。

```java

<%

...

Statement stmt = conn.createStatement();

ResultSet rs = stmt.executeQuery("select * from users where id =" + id);

String address = null;

if (rs != null) 

rs.next();

address = rs.getString("address");



%>

家庭地址: <%= address %>

```

如果address的值是由用户提供的，且存入数据库时没有进行合理的校验，那么攻击者就可以利用上面的代码进行存储型XSS攻击。

2、反射型XSS

      指应用程序通过Web请求获取不可信赖的数据，并在未检验数据是否存在恶意代码的情况下，将其发送给用户。反射型XSS一般可以由攻击者构造带有恶意代码参数的URL来实现，在构造的URL地址被打开后，其中包含的恶意代码参数被浏览器解析和执行。这种攻击的特点是非持久化，必须用户点击包含恶意代码参数的链接时才会触发。

**例如**：下面JSP代码片段的功能是从HTTP请求中读取输入的用户名(username)并显示到页面。

```java

<%

String name= request.getParameter("username"); %>

...

姓名: <%= name%>

...

```

如果name里有包含恶意代码，那么Web浏览器就会像显示HTTP响应那样执行该代码，应用程序将受到反射型XSS攻击。

3、防范建议

为了避免存储型XSS攻击，建议采用以下方式进行防御：

1.对从数据库或其它后端数据存储获取不可信赖的数据进行合理验证（如年龄只能是数字），对特殊字符（如`<、>、'、"`以及`<script>、javascript`等进行过滤。

2.根据数据将要置于HTML上下文中的不同位置（HTML标签、HTML属性、JavaScript脚本、CSS、URL），对所有不可信数据进行恰当的输出编码。

**例如**：采用OWASP ESAPI对数据输出HTML上下文中不同位置，编码方法如下。

```java

//HTML encode

ESAPI.encoder().encodeForHTML(inputData);

//HTML attribute encode

ESAPI.encoder().encodeForHTMLAttribute(inputData);

//JavaScript encode

ESAPI.encoder().encodeForJavaScript(inputData);

//CSS encode

ESAPI.encoder().encodeForCSS(inputData);

//URL encode

ESAPI.encoder().encodeForURL(inputData);

```

3.设置HttpOnly属性，避免攻击者利用跨站脚本漏洞进行Cookie劫持攻击。在Java EE中，给Cookie添加HttpOnly的代码如下：

```java

...

response.setHeader("Set-Cookie","cookiename=cookievalue; path=/; Domain=domainvaule; Max-age=seconds; HttpOnly");

...

```

4、通过过滤器和拦截器，拦截请求和响应，对请求和响应中的内容依次校验过滤

1、跨站脚本和存储型XSS攻击防御工具类

package com.hlframe.modules.frame.utils;

import java.util.regex.Pattern;

/**
 * 跨站脚本和存储型XSS攻击防御工具类
 * @author zyw
 * @date 16:52:11
 */
public class XSSUtils 

    public static Pattern scriptPattern1 = Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE);
    public static Pattern scriptPattern2 = Pattern.compile("src[\\r\\n]*=[\\r\\n]*\\\\\\'(.*?)\\\\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern3 = Pattern.compile("src[\\r\\n]*=[\\r\\n]*\\\\\\"(.*?)\\\\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern4 = Pattern.compile("</script>", Pattern.CASE_INSENSITIVE);
    public static Pattern scriptPattern5 = Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern6 = Pattern.compile("eval\\\\((.*?)\\\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern7 = Pattern.compile("e­xpression\\\\((.*?)\\\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern8 = Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE);
    public static Pattern scriptPattern9 = Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE);
    public static Pattern scriptPattern10 = Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
    public static Pattern scriptPattern11 = Pattern.compile(".*<.*", Pattern.CASE_INSENSITIVE );

    public static String striptXSS(String value) 
        if (value != null) 

            value = value.replaceAll("", "");
            value = scriptPattern1.matcher(value).replaceAll("");
            value = scriptPattern2.matcher(value).replaceAll("");
            value = scriptPattern3.matcher(value).replaceAll("");
            value = scriptPattern4.matcher(value).replaceAll("");
            value = scriptPattern5.matcher(value).replaceAll("");
            value = scriptPattern6.matcher(value).replaceAll("");
            value = scriptPattern7.matcher(value).replaceAll("");
            value = scriptPattern8.matcher(value).replaceAll("");
            value = scriptPattern9.matcher(value).replaceAll("");
            value = scriptPattern10.matcher(value).replaceAll("");
            value = scriptPattern11.matcher(value).replaceAll("");
        
        return value;
    

2、请求过滤业务实现类

package com.hlframe.modules.frame.interceptor;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import com.hlframe.modules.frame.utils.XSSUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

/**
 * 请求过滤业务实现类
 */
public class XssRequestWrappers extends HttpServletRequestWrapper

    private CommonsMultipartResolver multiparResolver = new CommonsMultipartResolver();

    public XssRequestWrappers(HttpServletRequest request) 
        super(request);

        String type = request.getHeader("Content-Type");
        if (!StringUtils.isEmpty(type) && type.contains("multipart/form-data")) 
            MultipartHttpServletRequest multipartHttpServletRequest = multiparResolver.resolveMultipart(request);
            Map<String, String[]> stringMap = multipartHttpServletRequest.getParameterMap();
            if (!stringMap.isEmpty()) 
                for (String key : stringMap.keySet()) 
                    String value = multipartHttpServletRequest.getParameter(key);
                    XSSUtils.striptXSS(key);
                    XSSUtils.striptXSS(value);
                
            
            super.setRequest(multipartHttpServletRequest);
        
    

    @Override
    public String[] getParameterValues(String parameter) 
        String[] values = super.getParameterValues(parameter);
        if (values == null) 
            return null;
        
        int count = values.length;
        String[] encodedValues = new String[count];
        for (int i = 0; i < count; i++) 
            encodedValues[i] = XSSUtils.striptXSS(values[i]);
        
        return encodedValues;
    

    @Override
    public String getParameter(String parameter) 
        String value = super.getParameter(parameter);
        return XSSUtils.striptXSS(value);
    

    @Override
    public String getHeader(String name) 
        String value = super.getHeader(name);
        return XSSUtils.striptXSS(value);
    

    @Override
    public Map<String, String[]> getParameterMap() 
        Map<String, String[]> map1 = super.getParameterMap();
        Map<String, String[]> escapseMap = new HashMap<String, String[]>();
        Set<String> keys = map1.keySet();
        for (String key : keys) 
            String[] valArr = map1.get(key);
            if (valArr != null && valArr.length > 0) 
                String[] escapseValArr = new String[valArr.length];
                for (int i = 0; i < valArr.length; i++) 
                    String escapseVal = XSSUtils.striptXSS(valArr[i]);
                    escapseValArr[i] = escapseVal;
                
                escapseMap.put(key, escapseValArr);
            
        

        return escapseMap;
    

 3、XSSFilter拦截类

package com.hlframe.modules.frame.interceptor;
import com.hlframe.modules.frame.utils.XSSUtils;
import org.springframework.stereotype.Component;

import java.io.IOException;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 存储型XSS、跨站脚本过滤器
 * @author zyw
 * @since 2022-09-01 20:09:31
 */
@Component
@WebFilter(filterName = "XSSFilter",
        /**
         * 通配符（*）表示对所有的web资源进行拦截
        */
        urlPatterns = "/*"
)
public class XSSFilter implements Filter  
    @Override
    public void init(FilterConfig arg0) throws ServletException 
        System.out.println("初始化过滤器!");
    

    @Override
    public void destroy() 
        System.out.println("销毁过滤器!");
    

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException 
        //过滤请求
//        chain.doFilter(new XssRequestWrappers((HttpServletRequest) request), response);

        //过滤返回
        ResponseWrapper wrapperResponse = new ResponseWrapper((HttpServletResponse)response);//转换成代理类

        chain.doFilter(new XssRequestWrappers((HttpServletRequest) request), wrapperResponse);
        byte[] content = wrapperResponse.getContent();//获取返回值
        //判断是否有值
        if (content.length > 0)
        

            String str = new String(content, "UTF-8");
            System.out.println("返回值:" + str);
            String ciphertext = null;

            try
            
                System.out.println("str = " + str);
                //......根据需要处理返回值
                ciphertext = XSSUtils.striptXSS(str);
                System.out.println("ciphertext = " + ciphertext);


            
            catch (Exception e)
            
                e.printStackTrace();
            
            //把返回值输出到客户端
            ServletOutputStream out = response.getOutputStream();
            out.write(ciphertext.getBytes());
            out.flush();
        
    

4、返回值输出代理类

/**
 * 返回值输出代理类
 *
 * @Title: ResponseWrapper
 * @Description:
 * @author zyw
 * @date 9:52:11
 */
public class ResponseWrapper extends HttpServletResponseWrapper 
    private ByteArrayOutputStream buffer;

    private ServletOutputStream out;

    public ResponseWrapper(HttpServletResponse httpServletResponse)
    
        super(httpServletResponse);
        buffer = new ByteArrayOutputStream();
        out = new WrapperOutputStream(buffer);
    

    @Override
    public ServletOutputStream getOutputStream()
            throws IOException
    
        return out;
    

    @Override
    public void flushBuffer()
            throws IOException
    
        if (out != null)
        
            out.flush();
        
    

    public byte[] getContent()
            throws IOException
    
        flushBuffer();
        return buffer.toByteArray();
    

    class WrapperOutputStream extends ServletOutputStream
    
        private ByteArrayOutputStream bos;

        public WrapperOutputStream(ByteArrayOutputStream bos)
        
            this.bos = bos;
        

        @Override
        public void write(int b)
                throws IOException
        
            bos.write(b);
        

        @Override
        public boolean isReady()
        

            // TODO Auto-generated method stub
            return false;

        

        @Override
        public void setWriteListener(WriteListener arg0)
        

            // TODO Auto-generated method stub

        
    

注意：SpingBoot3.0.0之前旧版本不支持通过正则表达式对响应进行过滤

此时可以通过String类中的各种方法直接对响应或请求中的内容进行修改

package com.hlframe.modules.frame.utils;

import java.util.regex.Pattern;

/**
 * 跨站脚本和存储型XSS攻击防御工具类
 * @author zyw
 * @date 16:52:11
 */
public class XSSUtils 
    
    public static String striptXSS(String value) 
        if (value != null) 

            value = value.replaceAll("", "");
            value = value.replace('<',' ');
            value = value.replace('>',' ');

        

        return value;
    

浅谈XSS攻击与防护（跨站脚本攻击）

XSS漏洞是Web应用程序中最常见的漏洞之一，XSS-即Cross Site Scripting. 为了与"CSS"不混淆，故简称XSS。 

XSS的原理为恶意攻击者往Web页面里插入JavaScript恶意代码。当用户浏览到写入JavaScript之时，被嵌入Web网页里面的JavaScript恶意代码就会自动被执行，从而达到恶意攻击用户的目的，例如盗取各类用户帐号、网站挂马、盗窃企业重要信息等。

那么如何去防范这类侵害呢？你又了解它多少呢？小编特在此与大家分享全面的XSS常识，让我们拥有一个安全的Web环境。

一.XSS的分类

XSS主要分为两大类：非持久型攻击、持久型攻击。非持久型攻击（反射型XSS）：经过后端，不经过数据库；持久型攻击（存储型XSS）：经过后端，经过数据库。

1.持久型也可认为是存储型XSS：当恶意的JavaScript代码写入web页面，会被存储到应用服务器端，简而言之就是会被存储到数据库。等用户再次打开web页面时，页面会继续执行恶意代码，达到持续攻击用户的作用。如下案例：在欢迎词处输入框输入JavaScript恶意代码进行保存，当用户在打开这个写入恶意JavaScript代码web页面的时候就会弹出带有恶意数据的弹窗。

2.非持久型XSS：非持久型XSS又叫反射型XSS，属于一次性攻击，仅对当次的页面访问产生影响。非持久型XSS攻击，要求用户访问一个被攻击者篡改后的链接，用户访问该链接时，被植入的攻击脚本被用户游览器执行，从而达到攻击目的。如下案例：通过搜索功能执行恶意的JavaScript代码点击搜索即执行恶意的JavaScript代码。

3. DOM是一个平台和语言都中立的接口，可以执行程序和脚本，能够动态访问和更新文档的内容、结构以及样式。DOM型XSS是一种特殊类型的反射型XSS，它是基于DOM文档对象模型的一种漏洞。如下案例：

http://**.**.**.**/tran/WCCMainPlatV5?CCB_IBSVersion=V5&SERVLET_NAME=WCCMainPlatV5&TXCODE=L10001&tourl=http://**.**.**.**");}alert('456789');});$(function(){if(aa=1){// 

XSS防护方案

XSS漏洞在web站点运用中是最为常见的漏洞之一，XSS会以各种方式执行恶意的JavaScript代码来破坏用户使用的站点。我们能够修补XSS漏洞，但是我们也不能100%的肯定没有人可以打破我们的过滤机制。恶意的攻击者总能够找到办法，绕过我们的过滤机制，从而进行恶意代码的执行。 

1. 在web页面上，将用户输入的数据都进行转译，也就是将常用的恶意代码中的[<,>,”,,&]等符号都用[<,>,",&]字符进行转译。当这些html标签符号被转译后，浏览器就会拿它当作一个普通字符串对待，而不是当作一个标签的开始/结束标志对待。从而不会执行JavaScript的恶意代码。

2. DOM型XSS的防御方法：DOM型XSS主要是由客户端的脚本通过DOM动态数据输入到页面，而不是依赖于将数据提交给服务器端，从客户端获得DOM中的数据在本地执行。因而，仅从服务器端是无法防御的。其防御在于：（1） 避免客户端文档重写、重定向或其他敏感操作；同时，避免使用客户端数据，这些操作尽量在服务器端使用动态页面来实现；（2） 分析和强化客户端JS代码；特别是受到用户影响的DOM对象，注意能直接修改DOM和创建HTML文件的相关函数或方法，并在输出变量到页面时先进行编码转义，如输出到HTML则进行HTML编码、输出到<script>则进行JS编码。

3.  利用XSS漏洞之所以具有重要意义，是因为通常难以看到XSS漏洞的威胁，而该XSS攻击则将其发挥得淋漓尽致。所以，小编在此与你一起分享了有关XSS攻击的理论知识和常见问题，不知是否对你有所帮助呢？让我们共同来创建一个安全、健康的Web环境。

 

点击阅读更多往期精彩

卓网信息