使用过滤器解决SQL注入和跨站点脚本编制

最新推荐文章于 2024-05-23 14:50:28 发布
最新推荐文章于 2024-05-23 14:50:28 发布
阅读量566 收藏 3
点赞数 1
文章标签： java 数据库 c#

1 SQL注入、盲注

1.1 SQL注入、盲注概述

Web 应用程序通常在后端使用数据库，以与企业数据仓库交互。查询数据库事实上的标准语言是 SQL（各大数据库供应商都有自己的不同版本）。Web 应用程序通常会获取用户输入（取自 HTTP 请求），将它并入 SQL 查询中，然后发送到后端数据库。接着应用程序便处理查询结果，有时会向用户显示结果。 如果应用程序对用户（攻击者）的输入处理不够小心，攻击者便可以利用这种操作方式。在此情况下，攻击者可以注入恶意的数据，当该数据并入 SQL 查询中时，就将查询的原始语法更改得面目全非。例如，如果应用程序使用用户的输入（如用户名和密码）来查询用户帐户的数据库表，以认证用户，而攻击者能够将恶意数据注入查询的用户名部分（或密码部分），查询便可能更改成完全不同的数据复制查询，可能是修改数据库的查询，或在数据库服务器上运行 Shell 命令的查询。

1.2 安全风险及原因

 高风险漏洞，攻击者可能会查看、修改或删除数据库条目和表

 原因：未对用户输入正确执行危险字符清理

 固定值： 查看危险字符注入的可能解决方案

1.3 AppScan扫描建议

若干问题的补救方法在于对用户输入进行清理。 通过验证用户输入未包含危险字符，便可能防止恶意的用户导致应用程序执行计划外的任务，例如：启动任意 SQL 查询、嵌入将在客户端执行的 Javascript 代码、运行各种操作系统命令，等等。 建议过滤出所有以下字符：

[1] |（竖线符号）

[2] & （& 符号）

[3];（分号）

[4] $（美元符号）

[5] %（百分比符号）

[6] @（at 符号）

[7] '（单引号）

[8] "（引号）

[9] \'（反斜杠转义单引号）

[10] \"（反斜杠转义引号）

[11] <>（尖括号）

[12] ()（括号）

[13] +（加号）

[14] CR（回车符，ASCII 0x0d）

[15] LF（换行，ASCII 0x0a）

[16] ,（逗号）

[17] \（反斜杠）

以下部分描述各种问题、问题的修订建议以及可能触发这些问题的危险字符：

SQL 注入和 SQL 盲注： A. 确保用户输入的值和类型（如 Integer、Date 等）有效，且符合应用程序预期。 B. 利用存储过程，将数据访问抽象化，让用户不直接访问表或视图。当使用存储过程时，请利用 ADO 命令对象来实施它们，以强化变量类型。 C. 清理输入以排除上下文更改符号，例如：

[1] '（单引号）

[2] "（引号）

[3] \'（反斜线转义单引号）

[4] \"（反斜杠转义引号）

[5] )（结束括号）

[6] ;（分号）

跨站点脚本编制： A. 清理用户输入，并过滤出 JavaScript 代码。我们建议您过滤下列字符：

[1] <>（尖括号）

[2] "（引号）

[3] '（单引号）

[4] %（百分比符号）

[5] ;（分号）

[6] ()（括号）

[7] &（& 符号）

[8] +（加号）

 

LDAP 注入： A. 使用正面验证。字母数字过滤（A..Z,a..z,0..9）适合大部分 LDAP 查询。 B. 应该过滤出或进行转义的特殊 LDAP 字符：

[1] 在字符串开头的空格或“#”字符

[2] 在字符串结尾的空格字符

[3] ,（逗号）

[4] +（加号）

[5] "（引号）

[6] \（反斜杠）

[7] <>（尖括号）

[8] ;（分号）

[9] ()（括号）

 

ORM 注入： A. 确保用户输入的值和类型（如 Integer、Date 等）有效，且符合应用程序预期。 B. 利用存储过程，将数据访问抽象化，让用户不直接访问表或视图。 C. 使用参数化查询 API D. 清理输入以排除上下文更改符号，例如： (*)：

[1] '（单引号）

[2] "（引号）

[3] \'（反斜线转义单引号）

[4] \"（反斜杠转义引号）

[5] )（结束括号）

[6] ;（分号）

1.4 应用程序解决方案

1、我们为了调试方便，在页面上会抛出数据库异常信息，如果入侵工具获取了这些信息，就可以获取系统的一些配置信息，如web系统框架、采用的数据库等，从而找出系统漏洞。所以不要在页面上抛出异常的详细信息，这些信息对客户并没有用，只是方便技术人员调试罢了，处理方法是在异常处理页面把打印异常代码删除即可；

2、新建一个过滤器，通过过滤器过滤SQL注入特殊字符，配置成功后，重启服务，用Appsan工具扫描，漏洞得到解决。

通过过滤器可以解决SQL注入、跨站点脚本编制及通过框架钓鱼等问题，具体实现方式如下：

1、在web.xml文件中配置过滤器

 

<!--配置过滤器 通过过滤器过滤SQL注入特殊字符  -->
    
    <filter>
        <filter-name>InjectFilter</filter-name>
        <filter-class>com.filter.InjectFilter</filter-class>
    </filter>
    <!--映射过滤器-->
    
    <!--<filter-mapping>
      <filter-name>InjectFilter</filter-name>-->
        <!--“/*”表示拦截所有的请求 -->
       <!-- <url-pattern>/*</url-pattern>
    </filter-mapping>-->
    
    <filter-mapping>
      <filter-name>InjectFilter</filter-name>
        <!--“/*”表示拦截所有的请求 -->
       <url-pattern>/*</url-pattern>
    </filter-mapping>

 

2、过滤器过滤代码

package com.filter;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Enumeration;
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.Filter;
import javax.servlet.http.HttpServlet;

/**
 *  通过过滤器过滤SQL注入特殊字符  
 * */
public  class InjectFilter extends HttpServlet implements Filter {
	/**
	 * 
	 */
	private static final long serialVersionUID = 5286703103846683570L;
	private String failPage = "/info.jsp";//发生注入时，跳转页面

    public void doFilter(ServletRequest request,ServletResponse response,
    		FilterChain filterchain)throws IOException, ServletException {
	    //判断是否有注入攻击字符
	    HttpServletRequest req = (HttpServletRequest) request;
	 	String inj = injectInput(req);
		if (!inj.equals("")) {
			 request.getRequestDispatcher(failPage).forward(request, response);
			 return;
	    } else {
		    // 传递控制到下一个过滤器
	    	filterchain.doFilter(request, response);
	    }
    }
    
    /**
     * 判断request中是否含有注入攻击字符
     * @param request
     * @return
     */
    public String injectInput(ServletRequest request) {
	    
	    Enumeration e = request.getParameterNames();
	    String attributeName;
	    String attributeValues[];
	    String inj = "";
	    String injdb = "";
	    while (e.hasMoreElements()) { 
	    	attributeName = (String)e.nextElement();
	    	//不对密码信息进行过滤，一般密码中可以包含特殊字符
	    	if(attributeName.equals("userPassword")||attributeName.equals("confirmPassword")||attributeName.equals("PASSWORD")
	    			||attributeName.equals("password")||attributeName.equals("PASSWORD2")||attributeName.equals("valiPassword")){
	    		continue;
	    	}
	    	
	    	attributeValues = request.getParameterValues(attributeName);
	    	for (int i = 0; i < attributeValues.length; i++) {
	    		
	if(attributeValues[i]==null||attributeValues[i].equals(""))
	    			continue;
	    		inj = injectChar(attributeValues[i]);
	    		
	    		if (!inj.equals("")) 
	    		{
	    			return inj;
	    		}		 
	    	}
	    }   
    	return inj;
    }
    
    /**
     * 判断字符串中是否含有注入攻击字符
     * @param str
     * @return
     */
    public String injectChar(String str) {
    	
       String inj_str = "\" ) \' * % < > &";
       String inj_stra[] = inj_str.split(" ");
    	
       for (int i = 0 ; i < inj_stra.length ; i++ )
       {
           if (str.indexOf(inj_stra[i])>=0)
           {
               return inj_stra[i];
           }
       }
       return "";
    }
       	
	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub 
           // System.out.println("----注入过滤器初始化----");  
    }  
	
}

 3.如果跨站点的脚本编制还存在或者存在其他漏洞风险就再搞个过滤器继续加固验证过滤

1.在xml文件继续配置一个新的过滤器：

<!--配置过滤器 跨站点脚本编制过滤 -->
    
    <filter>  
        <filter-name>XssFilter</filter-name>  
        <filter-class>com.filter.XssFilter</filter-class>  
    </filter> 
    <!--映射过滤器--> 
    
    <filter-mapping>
      <filter-name>XssFilter</filter-name>
        <!--“/*”表示拦截所有的请求 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

2.过滤器代码：

package com.filter;

import java.io.IOException;

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;
import com.RequestWrapper;
import javax.servlet.http.HttpServlet;

/*
 * XSS过滤
 */
public class XssFilter extends HttpServlet implements Filter {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 6846384055249714181L;

	/**  
	    * 需要排除的页面  
	    */    
	    private String excludedPages;    
	        
	    private String[] excludedPageArray;   
	      
	    @SuppressWarnings("unused")  
	    private FilterConfig filterConfig;  
	  
	    public void destroy() {  
	        this.filterConfig = null;  
	       // System.out.println("----过滤器销毁----");
	    }  
	      
	    public void doFilter(ServletRequest request, ServletResponse response,  
	            FilterChain chain) throws IOException, ServletException {  
	        boolean isExcludedPage = false;  
	     // 强制类型转换 HttpServletRequest
	        HttpServletRequest request2 = (HttpServletRequest) request;  
	        String ctx_path = request2.getContextPath();  
	        String request_url = request2.getRequestURI();  
	        String action = request_url.substring(ctx_path.length());  
	        
	        HttpServletResponse response2 = (HttpServletResponse)response;
	        response2.addHeader("Set-Cookie", "uid=112; Path=/; HttpOnly");
	          
	       	    if (isExcludedPage) {  
	            chain.doFilter(request, response2);  
	        } else {  // 构造RequestWrapper对象处理XSS
	            chain.doFilter(new RequestWrapper(request2), response2);  
	        }  
	          
	    }  
	      
	    /** 
	     * 自定义过滤规则 
	     */  
	    public void init(FilterConfig filterConfig) throws ServletException {  
	        this.filterConfig = filterConfig;  
	        excludedPages = filterConfig.getInitParameter("excludedPages");    
	        if (StringUtils.isNotEmpty(excludedPages)) {  
	            excludedPageArray = excludedPages.replaceAll("[\\s]", "").split(",");  
	            //System.out.println("----过滤器初始化----");
	        }  
	    }  
}

 2.类RequestWrapper

package com.servlet;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

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

import com.util.XssClean;

/*
 * 增加XSS过滤
 * 自定义的RequestWrapper中，对getParameter和getParameterValues进行重写，从而达到对各个用户输入的form参数的值进行过滤
 */
public class RequestWrapper extends HttpServletRequestWrapper {
	HttpServletRequest orgRequest = null;  
	   
    public RequestWrapper(HttpServletRequest request) {  
        super(request);  
        orgRequest = request;  
    }  
    /** 
     * 获取最原始的request 
     *  
     * @return 
     */ 
    public HttpServletRequest getOrgRequest() {  
        return orgRequest;  
    }  
   
    /** 
     * 获取最原始的request的静态方法 
     *  
     * @return 
     */ 
    public static HttpServletRequest getOrgRequest(HttpServletRequest req) {  
        if (req instanceof RequestWrapper) {  
            return ((RequestWrapper) req).getOrgRequest();  
        }  
   
        return req;  
    } 

   /**
    * 覆盖getParameterMap 方法，对sql、html、script注入进行过滤
    */
   public Map<String,String> getParameterMap() {
       HashMap<String,String> paramMap = (HashMap<String,String>) super.getParameterMap();
       paramMap = (HashMap<String,String>) paramMap.clone();

       for (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] instanceof String){
                   values[i] = XssClean.xssClean(values[i]);
               }
           }
           entry.setValue(values);
       }
       return paramMap;
   }
   //
   ///
   //滤掉form data中的恶意脚本
   public String[] getParameterValues(String paramString){  
     String[] arrayOfString1 = super.getParameterValues(paramString);  
     if (arrayOfString1 == null)  
       return null;  
     int i = arrayOfString1.length;  
     String[] arrayOfString2 = new String[i];  
     for (int j = 0; j < i; j++)  
       arrayOfString2[j] =XssClean.xssClean_New(arrayOfString1[j]);  
     return arrayOfString2;  
   }  
   

   public String getParameter(String paramString){  
     String str = super.getParameter(paramString);  
     if (str == null)  
       return null;  
     return XssClean.xssClean(str);  
   }  
//
   //在输入流中检测滤掉来自其他网站的URL中的恶意脚本
   public String getHeader(String paramString) {  
     String str = super.getHeader(paramString);  
     if (str == null)  
       return null;  
     return XssClean.xssClean(str);  
   } 
   
   ///
   
   public String getQueryString() {
		String value = super.getQueryString();
		if (value != null) {
			value = XssClean.xssClean(value);
		}
		return value;
	}
 }

 3.类XssClean

package com.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.owasp.validator.html.AntiSamy;
import org.owasp.validator.html.CleanResults;
import org.owasp.validator.html.Policy;

import org.owasp.validator.html.PolicyException;
import org.owasp.validator.html.ScanException;
import org.springframework.web.util.HtmlUtils;
import org.apache.commons.io.IOUtils;

/*
 * 增加 XSS过滤
 * 加入了dependency之后，就可以在xssClean中加入antisamy对恶意脚本进行清理。其中policy.xml是白名单，
 * policy.xml中规定了各个html元素所必须满足的条件。antisamy的精髓之处在于，使用policy文件来规定你的过滤条件，
 * 若输入字符串不满足policy文件中的条件，则会过滤掉字符中的恶意脚本，返回过滤后的结果。
 */
public class XssClean {
    private static  Policy policy = null;  
      
    public static Policy getPolicy() throws PolicyException {  
        if (policy == null) {  
            InputStream policyFile = XssClean.class.getResourceAsStream("/resource/antisamy.xml");  //antisamy.xml此文件可能大装载会报错，直接抛出异常即可不用理会也行。
              
           // 推荐一个jar包，用来转换InputStream到String，
            // 引入apache的io包  import org.apache.commons.io.IOUtils;
            String result = null;
			try {
				result = IOUtils.toString(policyFile, "UTF-8");
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            policy = Policy.getInstance(result); 
            
        }  
        return policy;  
    }  
     //将client端用户输入的request，在server端进行了拦截，并且进行了过滤   
此方法可以不用直接用下面的新的写法即可   

public static String xssClean_New(String value) 
{ 
        if (StringUtils.isNotEmpty(value)) {  
            AntiSamy antiSamy = new AntiSamy();  
            try {  
                //如果 不用此方法 可以 使用 下面注释的代码实现
            	final CleanResults cr = antiSamy.scan(StringUtil.UrlDecode(value, "UTF-8"), getPolicy());  
               
            	// final CleanResults cr = antiSamy.scan(value, Policy.getInstance("antisamy.xml"), AntiSamy.SAX);
                
                //安全的HTML输出  
                value = cr.getCleanHTML(); 
                value = HtmlUtils.htmlEscape(value);
                
                //return cr.getCleanHTML();
            } catch (ScanException e) {  
                e.printStackTrace();  
            } catch (PolicyException e) {  
                System.out.println("加载XSS规则文件异常: " + e.getMessage());  
                
            }  
        }  
        return value;  
    } 
    
//使用此方法即可
 public static String xssClean_New(String value)
 { 
        if (StringUtils.isNotEmpty(value))
        {  
            AntiSamy antiSamy = new AntiSamy();  
           
               value = HtmlUtils.htmlEscape(value);
               
        }  
        return value;  
    }
  

    
    public static String xssClean_4(String value) {//界面会报错
    	value = StringUtil.UrlDecode(value, "UTF-8");
    	value = HtmlUtils.htmlEscape(value);
		value = value.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
		value = value.replaceAll("\\(", "& #40;").replaceAll("\\)", "& #41;");
		value = value.replaceAll("'", "& #39;");
		value = value.replaceAll("eval\\((.*)\\)", "");
		value = value.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
		value = value.replaceAll("script", "");
		return value;
    } 

    
    
    /** 
     * 将容易引起xss漏洞的半角字符直接替换成全角字符 
     *  清除恶意的XSS脚本
     * @param s 
     * @return 
     */  
    public static String xssClean(String value) {  
        if (value == null || value.isEmpty()) {  
            return value;  
        }  
        value = StringUtil.UrlDecode(value, "UTF-8");
        value = HtmlUtils.htmlEscape(value);
        
        value = value.replaceAll("<", "& lt;").replaceAll(">", "& gt;");
		value = value.replaceAll("\\(", "& #40;").replaceAll("\\)", "& #41;");
		value = value.replaceAll("'", "& #39;");
		value = value.replaceAll("eval\\((.*)\\)", "");
		value = value.replaceAll("[\\\"\\\'][\\s]*javascript:(.*)[\\\"\\\']", "\"\"");
		value = value.replaceAll("script", "");
        
        StringBuilder sb = new StringBuilder(value.length() + 16);  
        for (int i = 0; i < value.length(); i++) {  
            char c = value.charAt(i);  
            switch (c) {  
            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();  
    } 
    
    
    
    public static  String xssClean_error(String value) {
        if (value != null) {
            value = value.replaceAll("", "");
            // Avoid anything between script tags
            Pattern scriptPattern = Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid anything in a src="http://www.yihaomen.com/article/java/..." type of e­xpression
            scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            scriptPattern = Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Remove any lonesome </script> tag
            scriptPattern = Pattern.compile("</script>", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Remove any lonesome <script ...> tag
            scriptPattern = Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid eval(...) e­xpressions
            scriptPattern = Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid e­xpression(...) e­xpressions
            scriptPattern = Pattern.compile("e­xpression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid javascript:... e­xpressions
            scriptPattern = Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid vbscript:... e­xpressions
            scriptPattern = Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE);
            value = scriptPattern.matcher(value).replaceAll("");
            // Avoid οnlοad= e­xpressions
            scriptPattern = Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL);
            value = scriptPattern.matcher(value).replaceAll("");
            
            
            value = HtmlUtils.htmlEscape(value);
        }
        return value;
    }
    
}

 万事大吉！他娘的再也不用担心Appscan扫出来了，我们的道路都是IBM他娘的套路。

 

weixin_34090643
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
config.getInitParameter（）获取的param-value为null
beautyliz的博客
08-08 1565
config.getInitParameter（）获取的param-value为null 今天学习ServletConfig的时候照着例子做一遍，但是发现获取web.xml的初始信息中的param-value为null servlet代码如下： @WebServlet("/TestServlet02") public class TestServlet02 extends HttpServlet { private static final long serialVersionUID = 1L; /*
Java 防SQL注入过滤器代码
热门推荐
seesun2012的专栏
01-14 3万+
前言 浅谈SQL注入： 所谓SQL注入，就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令，达到一定的非法用途。 解决办法 1、配置WEB-INF/web.xml web-app&amp;amp;gt; welcome-file-list&amp;amp;gt; welcome-file&amp;amp;gt;index.htmlwe
SpringBoot中如何防止XSS攻击和sql注入
最新发布
2302_77596945的博客
05-23 636
***自定义过滤注解*/⑤自定义拦截器配置类@Override最后最后！！！一定要在启动类添加扫描@ServletComponentScan(basePackages ="全限定名")以上仅供参考。
《appscan教程》 三 sql注入跨站点脚本编制
程序猿学社的博客
08-30 2156
sql注入跨站点脚本编制 package com.cloudtech.web.filter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servle...
java跨站点脚本编制_跨站点请求伪造 跨站点脚本编制 通过框架钓鱼漏洞 | 学步园...
weixin_33324435的博客
02-26 220
1、跨站点请求伪造 跨站点脚本编制 通过框架钓鱼漏洞主要是通过在url或参数中添加脚本如：1、URL中添加alert(1)2、参数value=。添加一个过滤器对特殊字符进行拦截package com.xxx.sys.filter;import java.io.IOException;import java.util.Enumeration;import javax.servlet.Filter;i...
AppScan扫描安全问题解决实录-跨站点脚本编制
yaovirus的专栏
05-15 1790
问题分析 未对用户可控制的输入正确进行无害化处理，就将其放置到充当 Web 页面的输出中。这可被跨站点脚本编制攻击利用。 白话解析：攻击者将脚本作为参数发送到被攻击的接口，然后接口直接返回语句到页面，那么页面就会执行攻击者的脚本。攻击者可以利用脚本获取token、cookie等信息，进而下一步攻击。 解决方案一 Apache配置解决方案： 1开放module LoadModule security2_module modules/mod_security2.so 2添加如下配置 <If
SQL注入和跨站点脚本
04-08
SQL注入和跨站点脚本（XSS）是两种常见的网络安全威胁，主要针对基于Web的应用程序。这篇文章将深入探讨这两种攻击方式，以及如何在C#环境中防止它们。 **SQL注入** SQL注入是一种攻击手段，攻击者通过输入恶意的...
C# MVC 过滤器防止SQL注入
09-15
C# MVC 过滤器防止SQL注入
JSP使用过滤器防止SQL注入的简单实现
01-08
什么是SQL注入攻击？引用百度百科的解释： sql注入_百度百科： 所谓SQL注入，就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有...
java过滤器防sql注入
04-04
外网可能会被攻击，简单的处理可以避免！ 外网可能会被攻击，简单的处理可以避免！ 外网可能会被攻击，简单的处理可以避免！ 外网可能会被攻击，简单的处理可以避免！...外网可能会被攻击，简单的处理可以避免！...
xss跨站点脚本编制漏洞/antisamy策略过滤
09-07
XSS跨站点脚本注入攻击过滤器，包括antisamy官方提供的各种策略xml文件。 antisamy-slashdot.xml 策略 antisamy-ebay.xml 策略 antisamy-myspace.xml 策略 antisamy-anythinggoes.xml 策略
JSP使用过滤器防止Xss漏洞
10-17
主要为大家详细介绍了JSP使用过滤器防止Xss漏洞，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA：URL存在跨站漏洞,注入漏洞解决方案
yiluoAK_47的专栏
12-12 5060
跨网站脚本介绍 一 跨网站脚本 跨网站脚本（Cross-site scripting，通常简称为XSS或跨站脚本或跨站脚本攻击）是一种网站应用程序的安全漏洞攻击，是代码注入的一种。它允许恶意用户将代码注入到网页上，其他用户在观看网页时就会受到影响。这类攻击通常包含了HTML以及用户端脚本语言。 XSS攻击通常指的是通过利用网页开发时留下的漏洞，通过巧妙的方法注入恶意指令代码到网页，使用户加载
跨站点脚本编制（好多博客说写的过滤器亲测都是假的，都拿不到参数）
阳光
12-11 2063
为什么说别人的都是有问题的呢，看起来没问题，实际上request获取的getParameterMap拿到的Map是锁定的，不能修改，   如何修改拿到的Map呢，需要引入tomcat里的catalina.jar 参考https://blog.csdn.net/darkness_j/article/details/6325245 如下：亲测可用 最后value = HtmlUtils.ht...
AppScan跨站点脚本编制修复
weixin_34253539的博客
03-16 1385
2019独角兽企业重金招聘Python工程师标准>>> ...
js解决跨站点脚本编制问题
weixin_34237596的博客
08-02 1265
1.前台处理（容易绕过）： &lt;script type="text/javascript"&gt; $(document).ready(function(){ var url=window.location.href; window.location.href=HTMLEnCode(url); }); function HTMLEnCode(str) { var s = ""; i...
web项目配置防止跨站点请求(XSS攻击)的过滤器
master_02的博客
11-23 1548
一、Microsoft Windows MHTML （XSS）跨站点脚本编制漏洞描述 XSS(Cross Site Scripting)，即跨站脚本攻击，是一种常见于web项目中的计算机安全漏洞。 1、严重性：中危。 2、风险：可能会窃取或操纵客户会话和 cookie，它们可能用于模仿合法用户，从而使黑客能够以该用户身份查 看或变更用户记录以及执行事务。 3、原因：未对用户输入正确执行危险...
什么是SQL注入和跨站脚本攻击？
05-08
SQL注入攻击是指攻击者通过在应用程序的输入字段中插入或“注入”恶意的SQL代码，从而操纵后端数据库的执行。攻击者可以利用这种漏洞来绕过应用程序的身份验证、访问敏感数据、修改数据或执行任意代码。SQL注入攻击对系统的安全性构成严重威胁，可能导致数据泄露、数据篡改或系统崩溃[^1]。 跨站脚本攻击（XSS）是指攻击者通过在网页中插入恶意脚本代码，使得用户在浏览器中执行这些恶意脚本。这些脚本可以窃取用户的敏感信息、篡改网页内容或进行其他恶意操作。跨站脚本攻击通常利用了网页中未正确过滤或转义的用户输入，攻击者可以通过注入恶意脚本来利用这些漏洞。为了防止跨站脚本攻击，开发人员需要对用户输入进行正确的验证、过滤和编码处理[^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值