解决跨站脚本注入，跨站伪造用户请求，sql注入等http安全漏洞(转)

转载：

http://blog.csdn.net/u011794238/article/details/46419911

 

跨站脚本就是在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不能相同
例如在登录页面上加上一段代码：

[java]  view plain  copy

 

1. request.getSession().invalidate() ;         //清空session  
2. if (request.getCookies()!=null) {  
3.    Cookie cookie = request.getCookies()[0];     // 获取cookie  
4.    cookie.setMaxAge(0);                    // 让cookie过期  
5. }"    

 

• 文件上传

 

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

• jQuery跨站脚本

 

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

 

• 启用了不安全的HTTP方法

 

 

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

[html]  view plain  copy

 

1. <login-config>  
2.        <!-- Authorization setting for SSL -->  
3.        <auth-method>CLIENT-CERT</auth-method>  
4.        <realm-name>Client Cert Users-only Area</realm-name>  
5.   <auth-method>BASIC</auth-method>  
6.    </login-config>  
7.    <security-constraint>  
8.        <!-- Authorization setting for SSL -->  
9.   <web-resource-collection>  
10.    <web-resource-name>SSL</web-resource-name>  
11.    <url-pattern>/oa/login.jsp</url-pattern>  
12.        </web-resource-collection>  
13.          
14.        <user-data-constraint>  
15.            <transport-guarantee>CONFIDENTIAL</transport-guarantee>  
16.        </user-data-constraint>  
17.    </security-constraint>  
18.   
19.   
20.  <!-- 禁止不安全的http方法 -->  
21.  <security-constraint>  
22.   <web-resource-collection>  
23.         <web-resource-name>fortune</web-resource-name>  
24.         <url-pattern>/*</url-pattern>  
25.         <http-method>PUT</http-method>  
26.         <http-method>DELETE</http-method>  
27.         <http-method>HEAD</http-method>  
28.         <http-method>OPTIONS</http-method>  
29.         <http-method>TRACE</http-method>  
30.   </web-resource-collection>  
31.   <auth-constraint></auth-constraint>  
32.  </security-constraint>   

 

• 登录错误消息凭证枚举

 

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

 

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

 

[java]  view plain  copy

 

1. package com.asiainfo.aiga.common.filter;  
2.   
3. import java.io.IOException;  
4. import java.util.Enumeration;  
5.   
6. import javax.servlet.Filter;  
7. import javax.servlet.FilterChain;  
8. import javax.servlet.FilterConfig;  
9. import javax.servlet.ServletException;  
10. import javax.servlet.ServletRequest;  
11. import javax.servlet.ServletResponse;  
12. import javax.servlet.http.HttpServletRequest;  
13. import javax.servlet.http.HttpServletResponse;  
14.   
15. import org.apache.commons.lang3.StringUtils;  
16.   
17. public class XSSCheckFilter implements Filter  
18. {  
19.     private FilterConfig config;  
20.     private static String errorPath;//出错跳转的目的地  
21.     private static String[] excludePaths;//不进行拦截的url  
22.     private static String[] safeless = { "<script", //需要拦截的JS字符关键字  
23.     "</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"  
24.     //"<",  
25.     //">",  
26.     //"</",  
27.     //"/>",  
28.     //"%3c",  
29.     //"%3e",  
30.     //"%3c/",  
31.     //"/%3e"  
32.     };  
33.   
34.     public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException  
35.     {  
36.         Enumeration params = req.getParameterNames();  
37.         HttpServletRequest request = (HttpServletRequest) req;  
38.         HttpServletResponse response = (HttpServletResponse) resp;  
39.   
40.         boolean isSafe = true;  
41.         String requestUrl = request.getRequestURI();  
42.         if (isSafe(requestUrl))  
43.         {  
44.             requestUrl = requestUrl.substring(requestUrl.indexOf("/"));  
45.             if (!excludeUrl(requestUrl))  
46.             {  
47.                 while (params.hasMoreElements())  
48.                 {  
49.                     String cache = req.getParameter((String) params.nextElement());  
50.                     if (StringUtils.isNotBlank(cache))  
51.                     {  
52.                         if (!isSafe(cache))  
53.                         {  
54.                             isSafe = false;  
55.                             break;  
56.                         }  
57.                     }  
58.                 }  
59.             }  
60.         }  
61.         else  
62.         {  
63.             isSafe = false;  
64.         }  
65.         if (!isSafe)  
66.         {  
67.             request.setAttribute("msg", "There is some illegal characters in paramters.");  
68.             request.getRequestDispatcher(errorPath).forward(request, response);  
69.             return;  
70.         }  
71.         else  
72.         {  
73.             String referer = request.getHeader("referer");  
74.             if (!("/index.jsp".equals(request.getServletPath()) || "/refresh.jsp".equals(request.getServletPath())))  
75.             {  
76.                 if(request.getServletPath()!=null&&request.getServletPath().endsWith(".action")){  
77.                       
78.                 }else if (referer == null || !referer.contains(request.getServerName()))  
79.                 {  
80.                     System.out.println("跨站请求伪造");  
81.                     //转到一个错误的图片  
82.                     request.getRequestDispatcher(errorPath).forward(request, response);  
83.                 }  
84.             }  
85.         }  
86.         filterChain.doFilter(req, resp);  
87.     }  
88.   
89.     private static boolean isSafe(String str)  
90.     {  
91.         if (StringUtils.isNotBlank(str))  
92.         {  
93.             for (String s : safeless)  
94.             {  
95.                 String[] strs = str.split("/");  
96.                 for (String urlStr : strs)  
97.                 {  
98.                     if (s.equals(urlStr.toLowerCase()))  
99.                     {  
100.                         return false;  
101.                     }  
102.                 }  
103.             }  
104.         }  
105.         return true;  
106.     }  
107.   
108.     private boolean excludeUrl(String url)  
109.     {  
110.         if (excludePaths != null && excludePaths.length > 0)  
111.         {  
112.             for (String path : excludePaths)  
113.             {  
114.                 if (url.toLowerCase().equals(path))  
115.                 {  
116.                     return true;  
117.                 }  
118.             }  
119.         }  
120.         return false;  
121.     }  
122.   
123.     public void destroy()  
124.     {  
125.     }  
126.   
127.     public void init(FilterConfig config) throws ServletException  
128.     {  
129.         this.config = config;  
130.         errorPath = config.getInitParameter("errorPath");  
131.         String excludePath = config.getInitParameter("excludePaths");  
132.         if (StringUtils.isNotBlank(excludePath))  
133.         {  
134.             excludePaths = excludePath.split(",");  
135.         }  
136.     }  
137. }