AppScan安全检测工具，检测出的问题解决

最新推荐文章于 2024-08-12 17:21:32 发布
最新推荐文章于 2024-08-12 17:21:32 发布
阅读量8k 收藏 6
点赞数
分类专栏： java开发 http，网络安全 文章标签： java 安全漏洞
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangye1225/article/details/78928330
版权

一、跨站点脚本请求编制

问题体现：网页中存在类似

<script>tagJson = decodeURI('${tagJson}')的内容，则容易被注入类似下面内容进行攻击

<script>tagJson = decodeURI('${tagJson}');</script>

如果您有这样的问题存在，那只能从您自己的代码中进行解决了，最好不要再页面中存在el表达式；

除去上面提到的这种情况外，其他情况的解决方法：可以对一些特殊的字符进行拦截处理：

类似：http://blog.csdn.net/mym43210/article/details/41082999

我的解决办法，具体代码实现

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>
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;
 
/**
 *  通过过滤器过滤注入的特殊字符 
 * */
public  class InjectFilter extends HttpServlet implements Filter {
   
    private static final long serialVersionUID = 5286703103846683570L;
    private String failPage = "/error.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("----注入过滤器初始化----"); 
    } 
     
}

二、跨站点请求伪造（CSRF）

CSRF（Cross Site Request Forgery），中文是跨站点请求伪造。CSRF攻击者在用户已经登录目标网站之后，诱使用户访问一个攻击页面，利用目标网站对用户的信任，以用户身份在攻击页面对目标网站发起伪造用户操作的请求，达到攻击目的。
简单地说，是攻击者通过一些技术手段欺骗用户的浏览器去访问一个自己曾经认证过的网站并执行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去执行。这利用了web中用户身份验证的一个漏洞：简单的身份验证只能保证请求发自某个用户的浏览器，却不能保证请求本身是用户自愿发出的。
下面简单的陈述了csrf的攻击思想：

从上图可以看出，要完成一次CSRF攻击， 受害者必须依次完成两个步骤 ：
　　1. 登录受信任网站A，并在本地生成Cookie 。
　　2. 在不登出A的情况下，访问危险网站B 。
　　这里，也许会说：“ 如果不满足以上两个条件中的一个，就不会受到CSRF的攻击 ”。是的，确实如此，但不能保证以下情况不会发生：
　　1.不能保证登录了一个网站后，不再打开一个tab页面并访问另外的网站。
　　2.不能保证关闭浏览器了后，本地的Cookie立刻过期，上次的会话已经结束。（事实上，关闭浏览器不能结束一个会话，但大多数人都会错误的认为关闭浏览器就等于退出登录/结束会话了......）
　　3.上图中所谓的攻击网站，可能是一个存在其他漏洞的可信任的经常被人访问的网站。

目前防御csrf攻击的主要有以下四种策略：
1、验证 HTTP Referer 字段；
2、在请求地址中添加 token 并验证；
3、在 HTTP 头中自定义属性并验证；
4、Chrome 浏览器端启用 SameSite cookie

下面主要说明我是怎么完成的： 
package com.common.util;

import javax.servlet.http.HttpServletRequest;

public class CSRFTool {
    public static String getToken(HttpServletRequest request) {
        return CSRFTokenManager.getTokenForSession(request.getSession());
    }
}

生成token代码 
package com.common.util;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.UUID;

/**
 * {@link #getTokenForSession(HttpSession)} 得到当前会话的token（token获得的唯一方法）
 */
public final class CSRFTokenManager {

    /**
     * token参数名
     */
    static final String CSRF_PARAM_NAME = "xToken";

    /**
     * 将token保存在session中
     */
    public final static String CSRF_TOKEN_FOR_SESSION_ATTR_NAME = CSRFTokenManager.class.getName() + ".tokenval";

    public static String getTokenForSession(HttpSession session) {
        String token = null;
        DESUtil des = new DESUtil("jrkj123");
        synchronized (session) {
            token = (String) session.getAttribute(CSRF_TOKEN_FOR_SESSION_ATTR_NAME);
//            token = des.encryptStr(tokens1);
            if (null == token) {
                String tokens = UUID.randomUUID().toString();
                token = des.encryptStr(tokens);
                session.setAttribute(CSRF_TOKEN_FOR_SESSION_ATTR_NAME, token);
            }
        }
        return token;
    }

    /**
     * 从会话中提取token值
     *
     * @param request
     * @return
     */
    public static String getTokenFromRequest(HttpServletRequest request) {
        String token = request.getParameter(CSRF_PARAM_NAME);
        if (token == null || "".equals(token)) {
            token = request.getHeader(CSRF_PARAM_NAME);
        }
        return token;
    }

    private CSRFTokenManager() {
    }
}

加密方法： 
package com.common.util;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
import java.security.SecureRandom;

public class DESUtil {
    Key key ;
    public DESUtil() {

    }
    public DESUtil(String str) {
        setKey(str); // 生成密匙
    }
    public Key getKey() {
        return key ;
    }
    public void setKey(Key key) {
        this . key = key;
    }
    public void setKey(String strKey) {
        try {
            KeyGenerator _generator = KeyGenerator.getInstance ( "DES" );
            _generator.init( new SecureRandom(strKey.getBytes("utf-8")));
            SecureRandom secureRandom= SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(strKey.getBytes());
            _generator.init(56, secureRandom);
            this.key = _generator.generateKey();
            _generator = null ;
        } catch (Exception e) {
            throw new RuntimeException("Error initializing class. Cause: " + e);
        }
    }

    /**
     * 加密 String 明文输入 ,String 密文输出
     */
    public String encryptStr(String strMing) {
        byte [] byteMi = null ;
        byte [] byteMing = null ;
        String strMi = "" ;
        BASE64Encoder base64en = new BASE64Encoder();
        try {
            byteMing = strMing.getBytes( "UTF-8" );
            byteMi = this.encryptByte(byteMing);
            strMi = base64en.encode(byteMi);
        } catch (Exception e) {
            throw new RuntimeException("Error initializing class. Cause: " + e);
        } finally {
            base64en = null ;
            byteMing = null ;
            byteMi = null ;
        }
        return strMi;
    }

    /**
     * 解密 以 String 密文输入 ,String 明文输出
     *
     * @param strMi
     * @return
     */
    public String decryptStr(String strMi) {
        BASE64Decoder base64De = new BASE64Decoder();
        byte [] byteMing = null ;
        byte [] byteMi = null ;
        String strMing = "" ;
        try {
            byteMi = base64De.decodeBuffer(strMi);
            byteMing = this.decryptByte(byteMi);
            strMing = new String(byteMing, "UTF-8" );
        } catch (Exception e) {
            throw new RuntimeException("Error initializing class. Cause: " + e);
        } finally {
            base64De = null ;
            byteMing = null ;
            byteMi = null ;
        }
        return strMing;
    }

    /**
     * 加密以 byte[] 明文输入 ,byte[] 密文输出
     *
     * @param byteS
     * @return
     */
    private byte [] encryptByte( byte [] byteS) {
        byte [] byteFina = null ;
        Cipher cipher;
        try {
            cipher = Cipher.getInstance ( "DES" );
            cipher.init(Cipher.ENCRYPT_MODE , key );
            byteFina = cipher.doFinal(byteS);
        } catch (Exception e) {
            throw new RuntimeException("Error initializing class. Cause: " + e);
        } finally {
            cipher = null ;
        }
        return byteFina;
    }

    /**
     * 解密以 byte[] 密文输入 , 以 byte[] 明文输出
     *
     * @param byteD
     * @return
     */
    private byte [] decryptByte( byte [] byteD) {
        Cipher cipher;
        byte [] byteFina = null ;
        try {
            cipher = Cipher.getInstance ( "DES" );
            cipher.init(Cipher.DECRYPT_MODE , key );
            byteFina = cipher.doFinal(byteD);
        } catch (Exception e) {
            throw new RuntimeException("Error initializing class. Cause: " + e);
        } finally {
            cipher = null ;
        }
        return byteFina;
    }
    public static void main(String[] args) throws Exception {
        DESUtil des = new DESUtil("jrkj123");
        String str1 = "4cdbc040657a4847b2667e31d9e2c3d9" ;
        // DES 加密字符串
        String str2 = des.encryptStr(str1);
        // DES 解密字符串
        String deStr = des.decryptStr(str2);
        System. out .println( " 加密前： " + str1);
        System. out .println( " 加密后： " + str2);
        System. out .println( " 解密后： " + deStr);
    }
}

拦截器： 
package com.common.interceptors;

import com.common.util.CSRFTool;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TokenAjaxInterceptor extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        response.setContentType("multipart/form-data");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html");
        //从前端获取到的token
        String token = request.getHeader("token");
        response.setHeader("token", token);//将token放到response中
        //后台生成的token
        String req_token = CSRFTool.getToken(request);

        //判断是不是ajax请求
        String requestUri = request.getRequestURI(); //请求完整路径，可用于登陆后跳转
        String contextPath = request.getContextPath();  //项目下完整路径
        String url = requestUri.substring(contextPath.length()); //请求页面

//        System.out.println("发生拦截...");
//        System.out.println("来自："+requestUri+"的请求");
        System.out.println("来自url："+url);
        /**
         * 拦截目录下请求，是否为ajax请求
         *   是：需要验证token是否正常；正常-->通过，不正常-->不通过
         *   否：全部拦截
         */
        if (request.getHeader("x-requested-with") != null && request.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")){
            //如果是ajax请求响应头会有，x-requested-with
            System.out.println("发生ajax请求...");
            if(req_token != null){
                //验证token是否合理
                if(token.equals(req_token) || token == req_token){
                    System.out.println("token验证正确，请求成功");
                    return true;
                }else{
                    System.out.println("token验证不正确，请求失败");
                    return false;
                }
            }else {
                System.out.println("没有token信息，请求失败");
                return false;
            }
        }else{
            System.out.println("非ajax请求，拦截...");
            return false;
        }
    }
}

配置文件中添加： 
<!--该拦截器主要作用是：对ajax请求进行拦截，同时判断token-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/login/help"/>
            <bean class="com.common.interceptors.TokenAjaxInterceptor"/>
        </mvc:interceptor>

三、HTTP动词篡改的认证旁路
AppScan 检测的问题：
原始：

测试：


请求方法改变了，但是结果，居然请求成功了，是不是很奇怪……
修改方法也挺简单，改下tomcat的web.xml就好。 
<security-constraint>  
    <web-resource-collection>  
        <http-method>HEAD</http-method>  
        <http-method>PUT</http-method>  
        <http-method>DELETE</http-method>  
        <http-method>OPTIONS</http-method>  
        <http-method>TRACE</http-method>  
        <url-pattern>/*</url-pattern>  
    </web-resource-collection>  
    <auth-constraint>  
        <role-name></role-name>  
    </auth-constraint>  
</security-constraint>

这种方法可能的弊端就是需要修改服务器环境中的toncat配置，有一些公司可能不太好实现，需要找到一种比较好的解决方法， 请各位大神指教

四、缺少 “ X-XSS-Protection”头
web.xml中添加代码如下：
<add name="X-XSS-Protection" value="1;mode=block"/>

五、缺少“ X-Content-Type-Options ” 头
web.xml中添加代码如下： 
<add name="X-Content-Type-Options" value="nosniff"/>

六、缺少“ Content-Security-Policy” 头
web.xml中添加代码如下：
 
<system.webServer>
　　<httpProtocol> 
　　　　<customHeaders>
　　　　　　<add name="X-Content-Type-Options" value="nosniff"/>
　　　　　　<add name="X-XSS-Protection" value="1;mode=block"/>
　　　　　　<add name="X-Frame-Options" value="SAMEORIGIN"/>
　　　　　　<add name="Content-Security-Policy" value="default-src 'self'"/>
　　　　</customHeaders>
　　</httpProtocol>
</system.webServer>

上述四五六这三个问题在网上查到的代码说在web里添加这几行的头就行，结果不行； 请各路大神指教！




youcey
关注
专栏目录
AppScan安全扫描记录遇到的一些问题
qq_41345150的博客
09-26 1842
AppScan安全扫描记录遇到的一些问题sql注入&跨站点脚本编制&通过框架钓鱼&链接注入（便于跨站请求伪造）缺少跨帧脚本编制防御 X-Frame-Options缺少“Content-Security-Policy”头缺少 HTTP Strict-Transport-Security 头缺少“X-Content-Type-Options”头缺少“X-XSS-Protecti...
AppScan安全测试漏洞检测工具10.4版本
12-25
**AppScan安全测试漏洞检测工具10.4版本详解** IBM AppScan是一款广泛使用的安全测试工具，主要用于检测Web应用程序中的安全漏洞。它以其强大的扫描功能和全面的安全评估能力，在IT行业中备受推崇。AppScan 10.4...
安全测试--AppScan使用问题记录
IceKing12138的博客
11-10 487
安全测试appscan的下载使用。
Appscan 检测到其已不在会话环境中，请重新登录
最新发布
weixin_42532350的博客
08-12 249
在扫描含验证码的系统时，往往会提示“会话已过期”、“检测到其已不再会话环境中”、“请重新登录”等。遇到这种情况，我们可以通过——绕过会话检测的方式进行操作。在浏览器输入被测地址，回车进入页面，返回appscan查看是否连接上。继续进行，登录操作，手动探索被测页面，完成后点击【停止记录】，保存。5、根据实际情况，选择【开始完全扫描】或【仅测试】4、进入火狐浏览器，【设置】——【网络设置】2、扫描配置向导——【我将稍后启动扫描】3、手动探索——外部客户机——其他。配置代理地址及端口号，保存。
质量AppScan（测试）安全性问题相关方法
u013619689的专栏
05-22 1312
1. SQL注入文件写入（需要用户验证） 解决办法：通过建立过滤器方法，对所有用户输入信息进行清理过滤。通过清理过滤用户输入所包含的危险字符，便可能防止恶意的用户导致应用程序执行计划外的任务，例如：启动任意 SQL 查询、嵌入将在客户端执行的Javascript代码、运行各种操作系统命令等。 建议过滤出所有以下字符： [1] |（竖线符号） [2] &
AppScan安全扫描问题解决方案
weixin_43988600的博客
02-23 7021
本人遇见过的扫描漏洞解决方案。 一、查询中的密码参数 【解决方案】 password是关键字，把passwod的传参名称改为pcode或其他名称。 风险： 可能会窃取查询字符串中发送的敏感数据，例如用户名和密码 原因： SSL（安全套接字层）可为 HTTP 提供数据机密性和完整性。通过加密 HTTP 消息，SSL 可防止攻击者窃听或更改消息内容。登 录页应始终采用 SSL 来保护从客户机传输到服务器的用户名和密码。如果不使用 SSL，会使用户凭证在传输到服务器期间作为 明文公开，从而易被窃听。 固定值：.
安全扫描工具HCL AppScan最新版本10.0.7
06-01
【安全扫描工具HCL AppScan最新版本10.0.7】是一款强大的Web应用程序安全测试解决方案，由全球知名科技公司HCL Technologies开发。这个版本带来了最新的功能和改进，旨在为用户提供更高效、全面的安全评估体验。...
安全检测及分析神器——AppScan10.0版本 window版本
06-28
AppScan是IBM公司推出的一...总之，AppScan 10.0版本作为一款强大的Web应用安全检测工具，对于保障企业的信息安全具有重要意义。通过持续的扫描、分析和修复，可以有效地防止恶意攻击，确保Web应用程序的安全稳定运行。
IBM Rational AppScan 网站安全检测
03-21
总结来说，IBM Rational AppScan 是一款强大的Web应用安全检测工具，通过对源码或运行中的应用程序进行扫描，来发现并预防安全漏洞。它的强大功能和易用性使其成为开发团队的重要安全伴侣，通过整合到开发流程中，...
AppScan安全测试总结.docx
06-30
扫描结束后，AppScan提供详尽的报告，包括发现的漏洞类型、漏洞原理的解释、修复建议以及手动验证的方法，这对于开发团队理解和解决安全问题十分有帮助。 安装AppScan的过程相对简单，只需按照提示进行，包括选择...
【安全性测试】解决关于appscan基于登录会话检测失败问题
w36680130的博客
07-31 2552
【安全性测试】解决关于appscan基于登录会话检测失败问题
AppScan进行测试的过程中常见故障及解决方法
weixin_42874924的博客
12-01 9337
1.AppScan的扫描只有登陆的页面，无法扫描其他菜单 一般测试的项目会有验证码什么的，可以先把多余的注释掉，然后再重新扫描，如果只有用户名和密码，就需要排查一下登录页是否存在问题，不过也有一些项目无法进行自动扫描，可以进行手动探索，将页面上的可见的尽可能都点到，可以分多次进行 2.使用外部浏览器,最好使用IE的，其他的好像多少有点毛病，谷歌的在进行手动探索时无法获取url（appscan9.0.1.1,暂时未解决） 3.Appscan扫描时卡住不动的问题 均在探索的时候，在不同的地方卡住不动，暂停按钮
AppScan安全专项问题解决
m0_61869253的博客
06-24 1216
网络安全行业产业以来，随即新增加了几十个网络安全行业岗位︰网络安全专家、网络安全分析师、安全咨询师、网络安全工程师、安全架构师、安全运维工程师、渗透工程师、信息安全管理员、数据安全工程师、网络安全运营工程师、网络安全应急响应工程师、数据鉴定师、网络安全产品经理、网络安全服务工程师、网络安全培训师、网络安全审计员、威胁情报分析工程师、灾难恢复专业人员、实战攻防专业人员…随着个人能力的不断提升，所从事工作的职业价值也会随着自身经验的丰富以及项目运作的成熟，升值空间一路看涨，这也是为什么受大家欢迎的主要原因。
安全扫描工具 AppScan
2201_75362610的博客
04-10 1584
是一个面向 Web 应用安全检测的自动化工具，使用它可以自动化检测 Web 应用的安全漏洞。比如跨站点脚本攻击（Cross Site Scripting Flaws）、注入式攻击（Injection Flaws）、失效的访问控制（Broken Access Control）、缓存溢出问题（Buffer Overflows）等等。
appscan安全测试工具
mao_xiaoxi的博客
06-04 432
AppScan使用教程参考https://blog.csdn.net/qq_36761831/article/details/80031086 一、安装顺序： 第一次安装顺序不对，安装完启动报错：--------卸载后再装一遍试试 重装后可以了 ...
AppScan漏洞风险处理
qq_32590535的博客
06-19 3410
文章主要记录了一些由IBM Security AppScan Standard扫描的漏洞以及对应的修复方案，主要的应用技术架构为java的springboot单体
AppScan 扫出隐藏文件，隐藏文件可能是项目目录下面的脚本，liunx命令
weixin_34345560的博客
11-10 1341
在项目目录里面查看有哪些隐藏文件，ls -a查看哪些隐藏文件是liunx命令，或者是一些敏感信息；让隐藏文件显示，然后删除掉； 转载于:https://blog.51cto.com/xuliangjun/1711288...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值