java内存马查杀工具

最新推荐文章于 2024-04-04 18:22:56 发布
最新推荐文章于 2024-04-04 18:22:56 发布
阅读量912 收藏 1
点赞数
分类专栏： CTF 文章标签： java tomcat jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44749590/article/details/126413996
版权

java-memshell-scanner:扫描java内存马

<%@ page import="java.net.URL" %>
<%@ page import="java.lang.reflect.Field" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="com.sun.org.apache.bcel.internal.Repository" %>
<%@ page import="java.net.URLEncoder" %>
<%@ page import="java.util.Map" %>
<%@ page import="org.apache.catalina.core.StandardWrapper" %>
<%@ page import="java.lang.reflect.Method" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.concurrent.CopyOnWriteArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>tomcat-memshell-killer</title>
</head>
<body>
<center>
    <div>
        <%!
            public Object getStandardContext(HttpServletRequest request) throws NoSuchFieldException, IllegalAccessException {
                Object context = request.getSession().getServletContext();
                Field _context = context.getClass().getDeclaredField("context");
                _context.setAccessible(true);
                Object appContext = _context.get(context);
                Field __context = appContext.getClass().getDeclaredField("context");
                __context.setAccessible(true);
                Object standardContext = __context.get(appContext);
                return standardContext;
            }

            public HashMap<String, Object> getFilterConfig(HttpServletRequest request) throws Exception {
                Object standardContext = getStandardContext(request);
                Field _filterConfigs = standardContext.getClass().getDeclaredField("filterConfigs");
                _filterConfigs.setAccessible(true);
                HashMap<String, Object> filterConfigs = (HashMap<String, Object>) _filterConfigs.get(standardContext);
                return filterConfigs;
            }

            // FilterMap[]
            public Object[] getFilterMaps(HttpServletRequest request) throws Exception {
                Object standardContext = getStandardContext(request);
                Field _filterMaps = standardContext.getClass().getDeclaredField("filterMaps");
                _filterMaps.setAccessible(true);
                Object filterMaps = _filterMaps.get(standardContext);

                Object[] filterArray = null;
                try { // tomcat 789
                    Field _array = filterMaps.getClass().getDeclaredField("array");
                    _array.setAccessible(true);
                    filterArray = (Object[]) _array.get(filterMaps);
                } catch (Exception e) { // tomcat 6
                    filterArray = (Object[]) filterMaps;
                }

                return filterArray;
            }

            /**
             * 遗留问题,getFilterConfig()依然存在2个
             * @param request
             * @param filterName
             * @throws Exception
             */
            public synchronized void deleteFilter(HttpServletRequest request, String filterName) throws Exception {
                Object standardContext = getStandardContext(request);
                // org.apache.catalina.core.StandardContext#removeFilterDef
                HashMap<String, Object> filterConfig = getFilterConfig(request);
                Object appFilterConfig = filterConfig.get(filterName);
                Field _filterDef = appFilterConfig.getClass().getDeclaredField("filterDef");
                _filterDef.setAccessible(true);
                Object filterDef = _filterDef.get(appFilterConfig);
                Class clsFilterDef = null;
                try {
                    // Tomcat 8
                    clsFilterDef = Class.forName("org.apache.tomcat.util.descriptor.web.FilterDef");
                } catch (Exception e) {
                    // Tomcat 7
                    clsFilterDef = Class.forName("org.apache.catalina.deploy.FilterDef");
                }
                Method removeFilterDef = standardContext.getClass().getDeclaredMethod("removeFilterDef", new Class[]{clsFilterDef});
                removeFilterDef.setAccessible(true);
                removeFilterDef.invoke(standardContext, filterDef);

                // org.apache.catalina.core.StandardContext#removeFilterMap
                Class clsFilterMap = null;
                try {
                    // Tomcat 8
                    clsFilterMap = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap");
                } catch (Exception e) {
                    // Tomcat 7
                    clsFilterMap = Class.forName("org.apache.catalina.deploy.FilterMap");
                }
                Object[] filterMaps = getFilterMaps(request);
                for (Object filterMap : filterMaps) {
                    Field _filterName = filterMap.getClass().getDeclaredField("filterName");
                    _filterName.setAccessible(true);
                    String filterName0 = (String) _filterName.get(filterMap);
                    if (filterName0.equals(filterName)) {
                        Method removeFilterMap = standardContext.getClass().getDeclaredMethod("removeFilterMap", new Class[]{clsFilterMap});
                        removeFilterDef.setAccessible(true);
                        removeFilterMap.invoke(standardContext, filterMap);
                    }
                }
            }

            public synchronized void deleteServlet(HttpServletRequest request, String servletName) throws Exception {
                HashMap<String, Object> childs = getChildren(request);
                Object objChild = childs.get(servletName);
                String urlPattern = null;
                HashMap<String, String> servletMaps = getServletMaps(request);
                for (Map.Entry<String, String> servletMap : servletMaps.entrySet()) {
                    if (servletMap.getValue().equals(servletName)) {
                        urlPattern = servletMap.getKey();
                        break;
                    }
                }

                if (urlPattern != null) {
                    // 反射调用 org.apache.catalina.core.StandardContext#removeServletMapping
                    Object standardContext = getStandardContext(request);
                    Method removeServletMapping = standardContext.getClass().getDeclaredMethod("removeServletMapping", new Class[]{String.class});
                    removeServletMapping.setAccessible(true);
                    removeServletMapping.invoke(standardContext, urlPattern);
                    // Tomcat 6必须removeChild 789可以不用
                    // 反射调用 org.apache.catalina.core.StandardContext#removeChild
                    Method removeChild = standardContext.getClass().getDeclaredMethod("removeChild", new Class[]{org.apache.catalina.Container.class});
                    removeChild.setAccessible(true);
                    removeChild.invoke(standardContext, objChild);
                }
            }

            public synchronized HashMap<String, Object> getChildren(HttpServletRequest request) throws Exception {
                Object standardContext = getStandardContext(request);
                Field _children = standardContext.getClass().getSuperclass().getDeclaredField("children");
                _children.setAccessible(true);
                HashMap<String, Object> children = (HashMap<String, Object>) _children.get(standardContext);
                return children;
            }


            public synchronized HashMap<String, String> getServletMaps(HttpServletRequest request) throws Exception {
                Object standardContext = getStandardContext(request);
                Field _servletMappings = standardContext.getClass().getDeclaredField("servletMappings");
                _servletMappings.setAccessible(true);
                HashMap<String, String> servletMappings = (HashMap<String, String>) _servletMappings.get(standardContext);
                return servletMappings;
            }

            public synchronized List<Object> getListenerList(HttpServletRequest request) throws Exception {
                Object standardContext = getStandardContext(request);
                Field _listenersList = standardContext.getClass().getDeclaredField("applicationEventListenersList");
                _listenersList.setAccessible(true);
                List<Object> listenerList = (CopyOnWriteArrayList) _listenersList.get(standardContext);
                return listenerList;
            }

            public String getFilterName(Object filterMap) throws Exception {
                Method getFilterName = filterMap.getClass().getDeclaredMethod("getFilterName");
                getFilterName.setAccessible(true);
                return (String) getFilterName.invoke(filterMap, null);
            }

            public String[] getURLPatterns(Object filterMap) throws Exception {
                Method getFilterName = filterMap.getClass().getDeclaredMethod("getURLPatterns");
                getFilterName.setAccessible(true);
                return (String[]) getFilterName.invoke(filterMap, null);
            }


            String classFileIsExists(Class clazz) {
                if (clazz == null) {
                    return "class is null";
                }

                String className = clazz.getName();
                String classNamePath = className.replace(".", "/") + ".class";
                URL is = clazz.getClassLoader().getResource(classNamePath);
                if (is == null) {
                    return "在磁盘上没有对应class文件，可能是内存马";
                } else {
                    return is.getPath();
                }
            }

            String arrayToString(String[] str) {
                String res = "[";
                for (String s : str) {
                    res += String.format("%s,", s);
                }
                res = res.substring(0, res.length() - 1);
                res += "]";
                return res;
            }
        %>

        <%
            out.write("<h2>Tomcat memshell scanner 0.1.0</h2>");
            String action = request.getParameter("action");
            String filterName = request.getParameter("filterName");
            String servletName = request.getParameter("servletName");
            String className = request.getParameter("className");
            if (action != null && action.equals("kill") && filterName != null) {
                deleteFilter(request, filterName);
            } else if (action != null && action.equals("kill") && servletName != null) {
                deleteServlet(request, servletName);
            } else if (action != null && action.equals("dump") && className != null) {
                byte[] classBytes = Repository.lookupClass(Class.forName(className)).getBytes();
                response.addHeader("content-Type", "application/octet-stream");
                String filename = Class.forName(className).getSimpleName() + ".class";

                String agent = request.getHeader("User-Agent");
                if (agent.toLowerCase().indexOf("chrome") > 0) {
                    response.addHeader("content-Disposition", "attachment;filename=" + new String(filename.getBytes("UTF-8"), "ISO8859-1"));
                } else {
                    response.addHeader("content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
                }
                ServletOutputStream outDumper = response.getOutputStream();
                outDumper.write(classBytes, 0, classBytes.length);
                outDumper.close();
            } else {
                // Scan filter
                out.write("<h4>Filter scan result</h4>");
                out.write("<table border=\"1\" cellspacing=\"0\" width=\"95%\" style=\"table-layout:fixed;word-break:break-all;background:#f2f2f2\">\n" +
                        "    <thead>\n" +
                        "        <th width=\"5%\">ID</th>\n" +
                        "        <th width=\"10%\">Filter name</th>\n" +
                        "        <th width=\"10%\">Patern</th>\n" +
                        "        <th width=\"20%\">Filter class</th>\n" +
                        "        <th width=\"20%\">Filter classLoader</th>\n" +
                        "        <th width=\"25%\">Filter class file path</th>\n" +
                        "        <th width=\"5%\">dump class</th>\n" +
                        "        <th width=\"5%\">kill</th>\n" +
                        "    </thead>\n" +
                        "    <tbody>");

                HashMap<String, Object> filterConfigs = getFilterConfig(request);
                Object[] filterMaps1 = getFilterMaps(request);
                for (int i = 0; i < filterMaps1.length; i++) {
                    out.write("<tr>");
                    Object fm = filterMaps1[i];
                    Object appFilterConfig = filterConfigs.get(getFilterName(fm));
                    if (appFilterConfig == null) {
                        continue;
                    }
                    Field _filter = appFilterConfig.getClass().getDeclaredField("filter");
                    _filter.setAccessible(true);
                    Object filter = _filter.get(appFilterConfig);
                    String filterClassName = filter.getClass().getName();
                    String filterClassLoaderName = filter.getClass().getClassLoader().getClass().getName();
                    // ID Filtername 匹配路径 className classLoader 是否存在file dump kill
                    out.write(String.format("<td style=\"text-align:center\">%d</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td style=\"text-align:center\"><a href=\"?action=dump&className=%s\">dump</a></td><td style=\"text-align:center\"><a href=\"?action=kill&filterName=%s\">kill</a></td>"
                            , i + 1
                            , getFilterName(fm)
                            , arrayToString(getURLPatterns(fm))
                            , filterClassName
                            , filterClassLoaderName
                            , classFileIsExists(filter.getClass())
                            , filterClassName
                            , getFilterName(fm)));
                    out.write("</tr>");
                }
                out.write("</tbody></table>");

                // Scan servlet
                out.write("<h4>Servlet scan result</h4>");
                out.write("<table border=\"1\" cellspacing=\"0\" width=\"95%\" style=\"table-layout:fixed;word-break:break-all;background:#f2f2f2\">\n" +
                        "    <thead>\n" +
                        "        <th width=\"5%\">ID</th>\n" +
                        "        <th width=\"10%\">Servlet name</th>\n" +
                        "        <th width=\"10%\">Patern</th>\n" +
                        "        <th width=\"20%\">Servlet class</th>\n" +
                        "        <th width=\"20%\">Servlet classLoader</th>\n" +
                        "        <th width=\"25%\">Servlet class file path</th>\n" +
                        "        <th width=\"5%\">dump class</th>\n" +
                        "        <th width=\"5%\">kill</th>\n" +
                        "    </thead>\n" +
                        "    <tbody>");

                HashMap<String, Object> children = getChildren(request);
                Map<String, String> servletMappings = getServletMaps(request);

                int servletId = 0;
                for (Map.Entry<String, String> map : servletMappings.entrySet()) {
                    String servletMapPath = map.getKey();
                    String servletName1 = map.getValue();
                    StandardWrapper wrapper = (StandardWrapper) children.get(servletName1);

                    Class servletClass = null;
                    try {
                        servletClass = Class.forName(wrapper.getServletClass());
                    } catch (Exception e) {
                        Object servlet = wrapper.getServlet();
                        if (servlet != null) {
                            servletClass = servlet.getClass();
                        }
                    }
                    if (servletClass != null) {
                        out.write("<tr>");
                        String servletClassName = servletClass.getName();
                        String servletClassLoaderName = null;
                        try {
                            servletClassLoaderName = servletClass.getClassLoader().getClass().getName();
                        } catch (Exception e) {
                        }
                        out.write(String.format("<td style=\"text-align:center\">%d</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td style=\"text-align:center\"><a href=\"?action=dump&className=%s\">dump</a></td><td style=\"text-align:center\"><a href=\"?action=kill&servletName=%s\">kill</a></td>"
                                , servletId + 1
                                , servletName1
                                , servletMapPath
                                , servletClassName
                                , servletClassLoaderName
                                , classFileIsExists(servletClass)
                                , servletClassName
                                , servletName1));
                        out.write("</tr>");
                    }
                    servletId++;
                }
                out.write("</tbody></table>");

                List<Object> listeners = getListenerList(request);
                if (listeners == null || listeners.size() == 0) {
                    return;
                }
                out.write("<tbody>");
                List<ServletRequestListener> newListeners = new ArrayList<>();
                for (Object o : listeners) {
                    if (o instanceof ServletRequestListener) {
                        newListeners.add((ServletRequestListener) o);
                    }
                }

                // Scan listener
                out.write("<h4>Listener scan result</h4>");
                out.write("<table border=\"1\" cellspacing=\"0\" width=\"95%\" style=\"table-layout:fixed;word-break:break-all;background:#f2f2f2\">\n" +
                        "    <thead>\n" +
                        "        <th width=\"5%\">ID</th>\n" +
                        "        <th width=\"20%\">Listener class</th>\n" +
                        "        <th width=\"30%\">Listener classLoader</th>\n" +
                        "        <th width=\"35%\">Listener class file path</th>\n" +
                        "        <th width=\"5%\">dump class</th>\n" +
                        "        <th width=\"5%\">kill</th>\n" +
                        "    </thead>\n" +
                        "    <tbody>");

                int index = 0;
                for (ServletRequestListener listener : newListeners) {
                    out.write("<tr>");
                    out.write(String.format("<td style=\"text-align:center\">%d</td><td>%s</td><td>%s</td><td>%s</td><td style=\"text-align:center\"><a href=\"?action=dump&className=%s\">dump</a></td><td style=\"text-align:center\"><a href=\"?action=kill&servletName=%s\">kill</a></td>"
                            , index + 1
                            , listener.getClass().getName()
                            , listener.getClass().getClassLoader()
                            , classFileIsExists(listener.getClass())
                            , listener.getClass().getName()
                            , listener.getClass().getName()));
                    out.write("</tr>");
                    index++;
                }
                out.write("</tbody></table>");
            }
        %>
    </div>
    <br/>
    code by c0ny1
</center>
</body>
</html>
甜筒化了 -
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
tomcat-memshell-scanner.jsp
12-18
Java内存马查杀 这里推荐几款内存马查杀工具 java-memshell-scanner：通过jsp脚本扫描并查杀各类中间件内存马。 只需要将tomcat-memshell-scanner.jsp放在可能被注入内存马的web录下，然后使用浏览器访问即可...
Java内存马检测工具推荐
2301_81907423的博客
01-02 469
java-memshell-scanner （GitHub - c0ny1/java-memshell-scanner: 通过jsp脚本扫描java web Filter/Servlet型内存马）shell-analyzer（https://github.com/4ra1n/shell-analyzer）GitHub - r00t4dm/aLIEz: 杀内存马的工具，欢迎code review，提出更好的意见 GitHub - LandGrey/copagent: java memory web she
在校自研内存马查杀工具，非常好用
woshiyanfu的博客
09-19 144
该工具总体解决了tomcat和spring内存马的查杀问题，使蓝队师傅们在面对内存马时不再只能使用重启大法。还得为一些可能再也起不来的服务担惊受怕。且该工具比较轻便，对服务没有太多入侵，不会影响服务的正常运行（别删错人家正常功能就行）。再者，该代码尽可能兼容了多版本的环境，使用起来兼容性较高。目前代码已经满足基本功能，后续打算放在github上开源供大家使用。目前还在不断的实战中看看有没有什么新的bug出现，等调试好了就会放到github上。在我后续文章中会放出github链接。
浅析JavaWeb内存马基础原理与查杀思路
最新发布
道阻且长，行则将至。
04-04 1540
传统的 Webshell 后门很容易被当前 WAF、HIDS、EDR 等安全设备检测出来，于是无文件落地的内存马技术得以诞生并快速发展。本文简要分析了Java内存马的原理、分类，并实践了主流Webshell客户端管理工具内存马的使用与当前应对内存马的一些查杀思路、手段。
Java内存马查杀GUI工具
公众号:乌云安全
03-28 263
注意：请勿在生产环境使用，存在打崩业务的风险，目前适用于自己搭建靶机分析学习功能：关于内存马查杀的文章和工具已经有不少，不过大都不够完善，各有缺点；于是我做了一款版本的实时内存马查杀工具，支持本地查杀与远程查杀；仅测试了这一种中间件，不过理论上任何实现了规范的中间件都可以查杀。优势：实时监控目标一键反编译分析代码一键查杀内存马工具下载地址 ： Java内存马查杀GUI工具https://mp.weixin.qq.com/s/PEM83gFVAQeBWZ4lzixMGA
内存马检测排查手段
热门推荐
SimoSimoSimo的博客
11-05 1万+
内存马是无文件落地webshell中最常见的攻击手段，随着攻防演练对抗强度越来越高，流量分析、EDR等专业安全设备被蓝方广泛使用，传统的文件上传的webshll以及文件形式的后门容易被检测到，文件shell明显气数已尽，而内存马因其隐蔽性等优点从而越来越盛行。
在校自研内存马查杀工具，非常实用
stopys6的博客
09-07 491
该工具总体解决了tomcat和spring内存马的查杀问题，使蓝队师傅们在面对内存马时不再只能使用重启大法。还得为一些可能再也起不来的服务担惊受怕。且该工具比较轻便，对服务没有太多入侵，不会影响服务的正常运行（别删错人家正常功能就行）。再者，该代码尽可能兼容了多版本的环境，使用起来兼容性较高。目前代码已经满足基本功能，后续打算放在github上开源供大家使用。目前还在不断的实战中看看有没有什么新的bug出现，等调试好了就会放到github上。在我后续文章中会放出github链接。
【网络安全】Agent内存马的自动分析与查杀
wuli1024的博客
12-15 157
以上是背景，接下来介绍我做了些什么，能够实现怎样的效果不难看出，以上内存马查杀手段都是半自动结合人工审核的方式，当检测出内存马后检测（同时支持普通内存马和Java Agent内存马的检测）分析（如何确定该类是内存马，仅根据恶意类名和注解等信息不完善）查杀（当确定内存马存在，如何自动地删除内存马并恢复正常业务逻辑）大致看来，实现起来似乎不难，然而实际中遇到了很多坑，接下来我会逐个介绍→点击获取网络安全资料·攻略←200多本网络安全系列电子书网络安全标准题库资料项目源码。
Tomcat Filter类型内存马与查杀技术学习
wangluoanquan111的博客
08-04 659
从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。因为入门学习阶段知识点比较杂，所以我讲得比较笼统，大家如果有不懂的地方可以找我咨询，我保证知无不言言无不尽，需要相关资料也可以找我要，我的网盘里一大堆资料都在吃灰呢。干货主要有：①1000+CTF历届题库（主流和经典的应该都有了）②CTF技术文档（最全中文版）③项目源码（四五十个有趣且经典的练手项目及源码）
藏东地区马查拉组煤层特征研究
07-07
西藏地区蕴含着丰富的煤炭资源,具成煤时期...作为成煤时期最早的马查拉组,形成于海陆过渡环境中的潮坪沉积体系,厚煤层多发育于泥炭沼泽中。对煤质特征的分析表明,马查拉煤系属于低中灰、低硫-中硫、中高-特高热值贫煤。
网络安全应急响应工具清单.xlsx
10-07
工具分类如下，共计70+，适用于网络安全领域从业者，仅供学习测试使用； 实用杀毒软件 注册表信息收集工具 超级弱口令工具 ...内存马查杀工具 蓝队分析研判工具箱 浏览器日志分析工具 勒索病毒解密工具汇总
qcobjects-wp-plugin：这是一个使QCObjects进入Wordpress的插件。 QCObjects是一种基于JavaScript的开源技术，旨在使Web开发人员能够将针对台式机和移动设备的代码编码到运行时组件和对象范围中。 它正Swift成为现代软件开发的下一代工具
02-22
QCObjects WordPress插件贡献者让马查卡捐赠链接 标签节点，quickcorp，javascript，pure，mvc，对象，microfrontend，micro-frontend，架构，组件，pure，framework，javascript-framework，mvc-pattern，demo，...
Machapi:克里斯·庞奇（Chris Punches）的各种站点的Python API，并在其上构建了一个广播实用程序的示例。 目前支持POF.com
05-08
马查比 用于连接到各种社交网站的库引擎。 Machapi通过将模块插入旨在运行它们的引擎中来工作。 创建并插入引擎模块后，Machapi即可连接到该站点并执行各种功能。 当前支持的模块： muchoffish.com 为什么存在 该...
应急--内存马查杀演示（极简）
m0_58355451的博客
08-30 1300
由客户端发起的Web请求后，中间件的各个独立的组件如Listener、Filter、Servlet等组件会在请求过程中做监听、判断、过滤等操作，内存马就是利用请求过程在内存中修改已有的组件或动态注册一个新的组件，插入恶意的shellcode，达到持久化控制服务器的目的。以java为例，客户端发起的web请求会依次经过Listener、Filter、Servlet三个组件，我们只要在这个请求的过程中做手脚，在内存中修改已有的组件或者动态注册一个新的组件，插入恶意的shellcode，就可以达到我们的目的。
内存马查杀工具FindShell试用
HRay's blog
03-17 6164
首先使用冰蝎创建一个内存马 成功进入内存马界面 接下来尝试使用findshell查杀，项目主页为 https://github.com/4ra1n/FindShell 服务器上首先部署代码，执行 git clone https://github.com/4ra1n/FindShell.git 然后进入到FindShell目录，打包项目，执行（如果没有mvn命令需要先yum -y install apache-maven安装） mvn package 打包后在targe..
干货|冰蝎、哥斯拉 内存马应急排查
m0_60571990的博客
12-29 6043
干货|冰蝎、哥斯拉 内存马应急排查
应急响应 -162天：webshell和内存马查杀
wuqingsix的博客
02-14 795
如：利用此系统中间件等爆出的通用漏洞，利用安全知识进行模拟攻击，了解外来攻击的方法。应急人员：通过网站程序利用红队思路排查漏洞，根据漏洞数据包配合日志分析攻击行为。应急人员：在时间和漏洞配合日志没有头绪分析下，可以尝试对后门分析找到攻击行为。获取当前WEB环境的组成架构（语言，数据库，中间件，系统等）如：翻日志 确定攻击时间，请求方式，请求地址，ip。背景交代：某公司在某个时间发现网站出现篡改或异常。背景交代：某公司在发现网站出现篡改或异常。背景交代：某公司在发现网站出现篡改或异常。
idea安装程序包com.sun.org.apache.bcel.internal.generic
07-14
在 IntelliJ IDEA 中安装 com.sun.org.apache.bcel.internal.generic 的程序包可能不是一个好的做法，因为该包是 Java 内部的一个实现细节，不应该直接在代码中使用。 如果你想使用 BCEL（Byte Code Engineering Library）库，可以通过以下步骤在 IntelliJ IDEA 中添加该库的依赖： 1. 打开你的项目，在项目根目录下找到 `pom.xml`（如果是 Maven 项目）或 `build.gradle`（如果是 Gradle 项目）文件。 2. 如果是 Maven 项目，在 `<dependencies>` 标签中添加以下依赖： ```xml <dependency> <groupId>org.apache.bcel</groupId> <artifactId>bcel</artifactId> <version>6.5.0</version> </dependency> ``` 如果是 Gradle 项目，在 `dependencies` 块中添加以下依赖： ```groovy implementation 'org.apache.bcel:bcel:6.5.0' ``` 3. 保存文件并重新构建项目。IDEA 将会自动下载并添加所需的 BCEL 库依赖。 请注意，`com.sun.org.apache.bcel.internal.generic` 是一个内部包，不建议直接使用。相反，你应该使用 `org.apache.bcel.generic` 包中的类和方法来进行字节码操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值