Web系统安全问题整理（XSS攻击）

最新推荐文章于 2024-06-12 09:58:38 发布
最新推荐文章于 2024-06-12 09:58:38 发布
阅读量865 收藏 2
点赞数 1
分类专栏： 网络安全 文章标签： 安全整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li521wang/article/details/86652351
版权

Web系统安全问题整理（XSS攻击）


在不久之前曾介绍过系统中间件版本号暴露和重放安全问题，这次主要讲一下XSS攻击防护措施。

1. XSS介绍

XSS（Cross Site Scripting）, 中文名为跨站脚本, 是发生在目标用户的浏览器层面上的，当渲染DOM树的过程成发生了不在预期内执行的JS代码时，就发生了XSS攻击。跨站脚本的重点不在“跨站”上，而在于“跨站”上。大多数XSS攻击的主要方式是嵌入一段远程或者第三方域上的JS代码。实际上是在目标网站的作用域下执行了这段js代码。

2. XSS分类

2.1 反射型XSS

反射型XSS主要表现在浏览器的展示层面上，并没有将脚本数据持久化到数据库中，攻击者通过拦截服务器返回给页面的数据，利用工具在服务器返回的数据中加入攻击脚本，进而在页面上进行展示。严重的还可以窃取用户密码等信息。

2.1 存储型XSS

顾名思义，它和反射型XSS的差别仅在于，提交的代码会存储在服务器端（数据库，内存，文件系统等），下次请求目标页面时不用再提交XSS代码。最典型的例子是留言板XSS，用户提交一条包含XSS代码的留言存储到数据库，目标用户查看留言板时，那些留言的内容会从数据库查询出来并显示，浏览器发现有XSS代码，就当做正常的HTML与JS解析执行，于是触发了XSS攻击。

3. 安全测试工具

如果测试系统是否含有此漏洞，可以使用抓包工具进行测试，在这里我推荐一个工具，也是大多数安全测试人员使用的工具，工具名称为Burpsuite。想要使用此工具还要需要配置一下浏览器。这里主要介绍Burpsuite+Firefox浏览器。
配置方法：http://www.cnblogs.com/slpawn/p/7235105.html
Burpsuite和Firefox证书下载路径：https://download.csdn.net/download/li521wang/10938753
具体的使用方法就不这里详细讲了。

4. 代码过滤XSS攻击

利用Filter进行XSS过滤。首先先增加几个配置类管理XSS过滤参数以及过滤的内容。

4.1. XSSSecurityManager 安全过滤配置管理类

/**
 * @Author: LX 17839193044@162.com
 * @Description: 安全过滤配置管理类，由XSSSecurityManger修改。（admin迁移至此）
 * @Date: 2019/1/24 14:55
 * @Version: V1.0
 */
@Slf4j
public class XSSSecurityManager {

    /**
     * REGEX：校验正则表达式
     */
    public static String REGEX;

    public static String[] REGEXS = new String[15];

    /**
     * 特殊字符匹配
     */
    public static Pattern XSS_PATTERN;

    /**
     * 设置私有构造方法
     */
    private XSSSecurityManager() {
    }

    /**
     * @Author: LX 17839193044@162.com
     * @Description: 初始化过滤匹配的字符
     * @Date: 2019/1/24 15:20
     * @Version: V1.0
     */
    public static void init() {
        log.info("XSSSecurityManager.initConfig(String path) begin");

        //  匹配含有字符： alert
        REGEXS[0] = ".*[A|a][L|l][E|e][R|r][T|t]\\s*\\(.*\\).*";
        //  匹配含有字符： window.location =
        REGEXS[1] = ".*[W|w][I|i][N|n][D|d][O|o][W|w]\\.[L|l][O|o][C|c][A|a][T|t][I|i][O|o][N|n]\\s*=.*";
        //  匹配含有字符：style = x:ex pression ( ) 
        REGEXS[2] = ".*[S|s][T|t][Y|y][L|l][E|e]\\s*=.*[X|x]:[E|e][X|x].*[P|p][R|r][E|e][S|s]{1,2}[I|i][O|o][N|n]\\s*\\(.*\\).*";
        //  匹配含有字符： document.cookie 
        REGEXS[3] = ".*[D|d][O|o][C|c][U|u][M|m][E|e][N|n][T|t]\\.[C|c][O|o]{2}[K|k][I|i][E|e].*";
        //  匹配含有字符： eval( ) 
        REGEXS[4] = ".*[E|e][V|v][A|a][L|l]\\s*\\(.*\\).*";
        //  匹配含有字符： unescape() 
        REGEXS[5] = ".*[U|u][N|n][E|e][S|s][C|c][A|a][P|p][E|e]\\s*\\(.*\\).*";
        //  匹配含有字符： execscript( ) 
        REGEXS[6] = ".*[E|e][X|x][E|e][C|c][S|s][C|c][R|r][I|i][P|p][T|t]\\s*\\(.*\\).*";
        //  匹配含有字符： msgbox( ) 
        REGEXS[7] = ".*[M|m][S|s][G|g][B|b][O|o][X|x]\\s*\\(.*\\).*";
        //  匹配含有字符： confirm( ) 
        REGEXS[8] = ".*[C|c][O|o][N|n][F|f][I|i][R|r][M|m]\\s*\\(.*\\).*";
        //  匹配含有字符： prompt( ) 
        REGEXS[9] = ".*[P|p][R|r][O|o][M|m][P|p][T|t]\\s*\\(.*\\).*";
        //  匹配含有字符： <script> </script> 
        REGEXS[10] = ".*<[S|s][C|c][R|r][I|i][P|p][T|t]>.*</[S|s][C|c][R|r][I|i][P|p][T|t]>.*";
        //  匹配含有字符： 含有一个符号： " 
        REGEXS[11] = "[.&[^\"]]*\"[.&[^\"]]*";
        //  匹配含有字符： 含有一个符号： ' 
        REGEXS[12] = "[.&[^']]*'[.&[^']]*";
        //  匹配含有字符： 含有回车换行 和 <script> </script> 
        REGEXS[13] = ".&[^a]]|[|a|\n|\r\n|\r|\u0085|\u2028|\u2029]]*<[S|s][C|c][R|r][I|i][P|p][T|t]>.*</[S|s][C|c][R|r][I|i][P|p][T|t]>[[.&[^a]]|[|a|\n|\r\n|\r|\u0085|\u2028|\u2029]]*";
        //  匹配特殊sql字符 
        REGEXS[14] = "(?:')|(?:--)|(/\\*(?:.|[\\n\\r])*?\\*/)|" + "(.*\\b(select|update|and|or|delete|insert|trancate|char|into|substr|ascii|declare|exec|count|master|into|drop|execute)\\b.*)";

        StringBuffer sb = new StringBuffer("^");
        for (String tmp : REGEXS) {
            tmp = tmp.replaceAll("\\\\\\\\", "\\\\");
            sb.append(tmp);
            sb.append("|");
        }

        if (sb.charAt(sb.length() - 1) == '|') {
            REGEX = sb.substring(0, sb.length() - 1) + "$";
            log.info("安全匹配规则" + REGEX);
        } else {
            log.error("安全过滤配置文件加载失败:正则表达式异常 " + sb.toString());
        }
        // 生成匹配器
        XSS_PATTERN = Pattern.compile(REGEX);

        log.info("XSSSecurityManager.initConfig(String path) end");
    }


    /**
     * 匹配字符是否含特殊字符
     *
     * @param text
     * @return
     */
    public static boolean matches(String text) {
        if (StringUtils.isBlank(text)) {
            return false;
        }
        return XSS_PATTERN.matcher(text).matches();
    }
}

4.2. XSSSecurityConfig 开关配置类

/**
 * @Author: LX 17839193044@162.com
 * @Description: XSS配置类
 * @Date: 2019/1/24 14:54
 * @Version: V1.0
 */
public class XSSSecurityConfig {

    private XSSSecurityConfig() {
    }

    /**
     * CHECK_HEADER：是否开启header校验
     */
    public static boolean IS_CHECK_HEADER = false;

    /**
     * CHECK_PARAMETER：是否开启parameter校验
     */
    public static boolean IS_CHECK_PARAMETER = true;

    /**
     * IS_LOG：是否记录日志
     */
    public static boolean IS_LOG = true;

    /**
     * IS_LOG：是否中断操作
     */
    public static boolean IS_CHAIN = false;

    /**
     * REPLACE：是否开启替换
     */
    public static boolean REPLACE = true;


    /**
     * FILTER_ERROR_PAGE:过滤后错误页面
     */
    public static String FILTER_ERROR_PAGE2 = "/error";

    /**
     * IS_FILTER_REFERER：是否开启防盗链
     */
    public static boolean IS_FILTER_REFERER = false;

}

4.3. XssHttpServletRequestWrapper 自定义XSS过滤wrapper

/**
 * @Author: LX 17839193044@162.com
 * @Description: 自定义XSS过滤wrapper
 * @Date: 2019/1/24 14:50
 * @Version: V1.0
 */
@Slf4j
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {

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

    @Override
    public String getHeader(String name) {
        String value = super.getHeader(name);
//        // 若开启特殊字符替换，对特殊字符进行替换
//        if (XSSSecurityConfig.REPLACE && StringUtils.isNotBlank(value)) {
//            return stringFilter(value);
//        }
        return value;
    }

    @Override
    public String getQueryString() {
        String queryString = super.getQueryString();
        // 若开启特殊字符替换，对特殊字符进行替换
        if (XSSSecurityConfig.REPLACE && StringUtils.isNotBlank(queryString)) {
            return stringFilter(queryString);
        }
        return StringEscapeUtils.escapeHtml4(super.getQueryString());
    }

    @Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        // 若开启特殊字符替换，对特殊字符进行替换
        if (XSSSecurityConfig.REPLACE && StringUtils.isNotBlank(value)) {
            return stringFilter(value);
        }
        return value;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] values = super.getParameterValues(name);
        if (values != null) {
            int length = values.length;
            String[] escapseValues = new String[length];
            for (int i = 0; i < length; i++) {
                escapseValues[i] = StringEscapeUtils.escapeHtml4(values[i]);
            }
            return escapseValues;
        }
        return super.getParameterValues(name);
    }

    /**
     * 没有违规的数据，就返回false;
     * 若存在违规数据，根据配置信息判断是否跳转到错误页面
     *
     * @return
     * @throws IOException
     * @throws ServletException
     */
    public boolean validateParameter() {
        // 开始header校验，对header信息进行校验
        if (XSSSecurityConfig.IS_CHECK_HEADER) {
            if (this.checkHeader()) {
                return true;
            }
        }
        // 开始parameter校验，对parameter信息进行校验
        if (XSSSecurityConfig.IS_CHECK_PARAMETER) {
            if (this.checkParameter()) {
                return true;
            }
        }
        return false;
    }


    /**
     * 没有违规的数据，就返回false;
     *
     * @return
     */
    private boolean checkHeader() {
        Enumeration<String> headerParams = this.getHeaderNames();
        while (headerParams.hasMoreElements()) {
            String headerName = headerParams.nextElement();
            String headerValue = this.getHeader(headerName);
            if (XSSSecurityManager.matches(headerValue)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 没有违规的数据，就返回false;
     *
     * @return
     */
    private boolean checkParameter() {
        Map<String, String[]> submitParams = this.getParameterMap();
        Set<String> submitNames = submitParams.keySet();
        for (String submitName : submitNames) {
            String[] submitValues = submitParams.get(submitName);
            for (String submitValue : submitValues) {
                try {
                    submitValue = StringEscapeUtils.unescapeHtml4(submitValue);
                    log.debug(submitName + ":" + submitValue + "----" + XSSSecurityManager.matches(submitValue));
                    if (XSSSecurityManager.matches(submitValue)) {
                        return true;
                    }
                } catch (Exception e) {
                    log.info("地址解码异常:" + submitValue);
                    return false;
                }
            }
        }
        return false;
    }

    /**
     * 过滤字符串里的的特殊字符
     *
     * @param str 要过滤的字符串
     * @return 过滤后的字符串
     */
    public static String stringFilter(String str) {
        String temp = StringUtils.replace(str, "%27", "");
        temp = StringUtils.replace(temp, "*", "");
        temp = StringUtils.replace(temp, "\"", "&quot;");
        temp = StringUtils.replace(temp, "'", "");
        temp = StringUtils.replace(temp, "\\\"", "");
        temp = StringUtils.replace(temp, ";", "");
        temp = StringUtils.replace(temp, "<", "&lt;");
        temp = StringUtils.replace(temp, ">", "&gt;");
        temp = StringUtils.replace(temp, "(", "");
        temp = StringUtils.replace(temp, ")", "");
        temp = StringUtils.replace(temp, "{", "");
        temp = StringUtils.replace(temp, "}", "");
        return temp.trim();
    }

}

4.4. XssFilter 过滤器，拦截所有请求，对Header、Parameter进行过滤

/**
 * @Author: LX 17839193044@162.com
 * @Description: XSS过滤器 拦截所有请求，对Header、Parameter进行过滤
 * @Date: 2019/1/24 14:51
 * @Version: V1.0
 */
@Slf4j
public class XssFilter implements Filter {

    /**
     * @Author: LX 17839193044@162.com
     * @Description: 项目启动时初始化
     * @Date: 2019/1/24 16:11
     * @Version: V1.0
     */
    @Override
    public void init(FilterConfig filterConfig) {
        //初始化XSS过滤词库
        XSSSecurityManager.init();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;

        // LX 17839193044@162.com 此处增加CSRF过滤  下编讲

        // http信息封装类
        XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper(req);
        String pageLink = xssRequest.getServletPath();
        if (StringUtils.isNotBlank(pageLink)) {

            // 对request信息进行封装并进行校验工作，若校验失败（含非法字符），
            // 根据配置信息进行日志记录和请求中断处理
            if (!pageLink.equals(XSSSecurityConfig.FILTER_ERROR_PAGE2)
                    && xssRequest.validateParameter()) {
                //判断是否记录日志
                if (XSSSecurityConfig.IS_LOG) {
                    // 记录攻击访问日志 可使用数据库、日志、文件等方式
                    log.error("访问IP:{},请求后缀:{},查询参数:{}", request.getRemoteAddr(),
                            pageLink, xssRequest.getQueryString());
                }
                if (XSSSecurityConfig.IS_CHAIN) {
                    //进行页面跳转
                    request.getRequestDispatcher(XSSSecurityConfig.FILTER_ERROR_PAGE2).forward(request, resp);
                    return;
                }
                chain.doFilter(xssRequest, resp);
            } else {
                chain.doFilter(xssRequest, resp);
            }
        } else {
            chain.doFilter(xssRequest, resp);
        }
    }

    /**
     * @Author: LX 17839193044@162.com
     * @Description: 生命周期结束时调用
     * @Date: 2019/1/24 16:11
     * @Version: V1.0
     */
    @Override
    public void destroy() {
    }
}

4.5. web.xml 最重要的一步，不解释。

  <!-- XSS过滤器 -->
    <filter>
        <filter-name>XssFilter</filter-name>
        <filter-class>com.***.XssFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>XssFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

到此处将修改后的代码部署到服务器。利用Burpsuite再次进行安全测试，XSS攻击已经被我们过滤了。如果大家还有其他比较好的XSS防护对策，可以分享一下。万分感谢！

ThisLX
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jquery xss验证代码
08-13
jquery xss验证代码，以txt打开，修改http://xxx/jquery.js,保存后加载有问题的jquery，可以出现弹窗
web考试资料整理.rar
12-06
在IT领域，Web安全是至关重要的一环，尤其是在UCAS（大学计算机科学）的学习过程中。"web考试资料整理.rar...通过学习这些内容，可以提升在UCAS或其他相关考试中的竞争力，同时也能在实际工作中保障Web系统的安全性。
xss漏洞校验
01-24 781
Xss（跨站脚本攻击）大家应该已经都有所了解，下面讲讲怎样查找xss漏洞吧。 确定xss漏洞的基本方法是使用攻击字符串来验证的，例如”><script>alert(document.cookie)</script>这个字符串被提交给每个应用程序的每个参数，许多扫描工具的xss自动化测试的基础规则就是这个。同时，攻击者监控这个输入的响应，如果攻击字符串原...
Xss漏洞常见绕过过滤攻击场景
chaottop的博客
05-04 1773
在某些情况下，后台作的过滤非常简单，只对一些特殊的字符串作黑名单过滤，导致可直接通过字母大小写绕过后台的过滤。如下例子
Java XSS 漏洞防护，校验
weixin_43992507的博客
10-17 1569
Java过滤器中 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { HttpServletRequest req=(HttpServletRequest) request; // XSS 漏洞校验 XssHttpServletRequestWrapper xssRequest = n
PHP代码块
抠脚强的博客
01-02 2628
php常用代码块
XSSSecurityFilter实战
langdashu
09-06 659
XSSSecurityFilter实战
Web攻击检测与分类识别数据集（自己整理所得）
10-16
5. **XSS（跨站脚本）攻击**: XSS攻击发生在攻击者通过注入恶意脚本到网页，欺骗用户执行不安全的操作。这可能导致会话劫持、钓鱼或其他恶意行为。防止XSS的方法包括对所有用户输入进行编码和过滤，启用HTTP-only...
哈工大信息内容安全复习整理
12-23
对于Web应用，理解OWASP十大安全风险，如CSRF、XSS攻击，以及如何进行安全的输入验证和输出编码。 七、应急响应与灾难恢复 面对安全事件，应急响应计划是必不可少的。学习者应掌握事件报告、分析、遏制、修复和事后...
WEB前端测试点汇总整理
03-29
- **XSS攻击**：防止跨站脚本攻击，测试输入数据是否被正确转义和过滤。 - **CSRF攻击**：验证防止跨站请求伪造的措施，如令牌验证。 - **数据加密**：检查敏感数据（如密码）在传输和存储过程中的加密处理。 - ...
web后端知识整理 初学者.zip
12-01
9. **安全性**：包括防止SQL注入、XSS攻击、CSRF攻击等，以及使用HTTPS进行数据加密传输。 10. **部署与运维**：了解如何将应用部署到服务器，如使用Docker容器化、配置Nginx反向代理、使用Git进行版本控制等。 ...
XssHttpServletRequestWrapper.java
12-03
XssHttpServletRequestWrapper.java
浅谈XSS
weixin_50464560的博客
06-02 729
XSS漏洞 绕过推荐 XSS绕过可以看看该文章：XSS过滤绕过速查表 0.介绍 跨站攻击，即Cross Site Script Execution(通常简写为XSS)，是前端的漏洞，产生在浏览器一端的漏洞。它是指攻击者在网页中嵌入客户端脚本，主要利用js编写的恶意代码来执行一些想要的功能，也就是说它能干嘛是受到js的控制，那么js能执行出什么脚本代码就取决于它能干嘛。当用户使用浏览器浏览被嵌入恶意代码的网页时，恶意代码将会在用户的浏览器上执行。 0.1.能干嘛 常规用到的是盗取cookie、js做钓鱼攻击、
XSS漏洞验证语句
桦少's blog
01-31 3252
XSS又叫CSS (Cross Site Script) ，跨站脚本攻击。它指的是恶意攻击者往Web页面里插入恶意html代码，当用户浏览该页之时，嵌入其中Web里面的html代码会被执行，从而达到恶意用户的特殊目的。 相关测试代码，可供漏洞验证： >alert(document.cookie) =’>alert(document.cookie) alert(document.co
XSS漏洞（三）
不秃头的程序Yang
05-16 337
一、XSS实战 1 反射型xss挖掘 1.寻找用户能够输入，在客户端可控的输入点。 2.输入恶意参数后，能够原型输出，输入没有过滤恶意代码。 1.1 反射型挖掘步骤 1、输入检测代码浏览器查看网页源码是否过滤，如果过滤了，过滤一般是实体过滤，如图 2、<、>实体变成&lt;&gt;在html里是不能执行的。 3、输入测试语句后，发现标签没有过滤，数据没有插入数据库的，这种属于反射型xss漏洞。 4、payload:<script>alert(/xss/
【XSS漏洞03】XSS漏洞验证、语句构造与绕过方法
Fighting_hawk的博客
02-24 1万+
1. 了解漏洞验证相关概念含义； 2. 掌握XSS漏洞验证的方法； 3. 掌握XSS语句构造的5种方法； 4. 掌握XSS语句绕过的8种方法。
【精选】【XSS漏洞03】XSS漏洞验证、语句构造与绕过方法
最新发布
zzz6583zz的博客
06-12 550
了解漏洞验证相关概念含义；掌握XSS漏洞验证的方法；掌握XSS语句构造的5种方法；掌握XSS语句绕过的8种方法。
【XSS漏洞-01】XSS漏洞简介、危害与分类及验证
热门推荐
m0_64378913的博客
05-13 2万+
目录1 XSS漏洞简介2 XSS漏洞危害3 XSS漏洞分类3.1 反射型XSS3.2 存储型XSS3.3 DOM型XSS3.3.1 节点树模型3.3.2 DOM型XSS4 漏洞验证4.1 漏洞验证相关概念4.2 漏洞验证相关概念之间的区别4.3 常见POC5 XSS漏洞验证实例5.1 反射型XSS漏洞验证实例5.2 存储型XSS漏洞验证实例5.3 DOM型XSS漏洞验证实例6 总结参考文章 1 XSS漏洞简介 定义/原理：跨站脚本（Cross-Site Scripting），本应该缩写为CSS，但是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值