Encrypt-Labs 靶场实战：前端加密解密与爆破全流程解析

下载脚本示例代码，便于独立脚本的开发：

git clone https://github.com/outlaws-bai/GalaxyHttpHooker.git 

示例说明：

• aes_cbc.py（基础版本）直接处理请求体中的 JSON 数据
• aes_cbc_form.py（表单版本）处理表单数据 (a=1&b=2)
• aes_cbc_query.py（查询参数版本）只对查询参数中的字段进行加解密 (?a=1&b=2)

因此我们遇到的 HTTP 参数加密请求，可以依据上述模板进行修改。

所有脚本围绕 4 个 hook 方法：hookRequestToBurp，hookRequestToServer，hookResponseToBurp，hookResponseToClient。

作用分别如下：我们对请求的加解密是前 2 个方法，如果响应内容加密了，你想解密需要实现后 2 个方法。

1. HTTP 请求从客户端到达 Burp 时被触发。你需要在此处完成请求解密的代码，这样就可以在 Burp 中看到明文的请求报文。
2. HTTP 请求从 Burp 将要发送到 Server 时被触发。你需要在此处完成请求加密的代码，这样就可以将加密后的请求报文发送到 Server。
3. HTTP 响应从 Server 到达 Burp 时被触发。你需要在此处完成响应解密的代码，这样就可以在 Burp 中看到明文的响应报文。
4. HTTP 响应从 Burp 将要返回到 Client 时被触发。你需要在此处完成响应加密的代码，这样就可以将加密后的响应报文返回给 Client。

autoDecoder

官方仓库：https://github.com/f0ng/autoDecoder

AES 固定 Key

使用火狐浏览器的'栈跟踪'功能，查看调用的所有 JS 代码。

可以看到 sendDataAes http://192.168.10.11:82/js/app.js:1:1098 和发起者都是 app.js，因此从 app.js 查询加密逻辑。

如果是谷歌浏览器，只能看发起时的 JS 文件，当然这个靶场不复杂，无伤大雅。

继续使用火狐浏览器演示，查看 app.js 代码，可以看到代码经过了混淆。

在右边 click 处勾上，表示点击时调试。

点击登录按钮，然后点击'AES 固定 key'，继续调试。

自动定位到如下 sendDataAes 函数中，可以看到对用户名、密码的对象使用 AES 加密，包含 iv、CBC 的 mode、padding 填充信息。

我们需要知道是如何将用户名密码进行 AES 加密的，直接将此处代码给 AI 分析下：

函数：sendDataAes()

加密参数：

• 算法：AES-CBC
• 密钥（Key）：固定 16 位字符串 1234567890123456（Utf8 编码）
• 偏移量（IV）：固定 16 位字符串 1234567890123456（Utf8 编码）
• 填充方式：PKCS7（默认填充规则）
• 输出：Base64 编码的加密结果

传输方式：将加密后的数据拼接为 encryptedData=加密值，以 application/x-www-form-urlencoded 格式 POST 提交

抓包查看请求信息，是表单格式的。

点击 start 按钮启动插件，这里不勾选 Hook Response，原因是响应内容是明文，request.host 填入的是靶机的 IP。

直接复制 aes_cbc_form.py 脚本进行修改：这里修改了 KEY、IV 的值，将模板中的 username 修改为 encryptedData，因为请求时的参数是 encryptedData。

import json
import base64
import typing as t
from fastapi import FastAPI
from urllib.parse import parse_qs, urlencode
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from _base_classes import *

KEY = b"1234567890123456"
IV = b"1234567890123456"
JSON_KEY = "data"

app = FastAPI()

@app.post("/hookRequestToBurp", response_model=RequestModel)
async def hook_request_to_burp(request: RequestModel):
    """HTTP 请求从数据客户端到达 Burp 时被调用。在此处完成请求解密的代码就可以在 Burp 中看到明文的请求报文。"""
    # 获取需要解密的数据
    encrypted_data: bytes = base64.b64decode(parse_qs(request.content.decode())["encryptedData"][0])
    # 调用函数解密
    data: bytes = decrypt(encrypted_data)
    print(f"[DEBUG] 解密后的数据：{data.decode()}")
    # 更新 query
    request.content = urlencode({"encryptedData": data.decode()}).encode()
    return request

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求加密的代码就可以将加密后的请求报文发送到 Server。"""
    # 获取被解密的数据
    data: bytes = parse_qs(request.content.decode())["encryptedData"][0].encode()
    # 调用函数加密回去
    encryptedData: bytes = encrypt(data)
    print(f"[DEBUG] 加密后的数据：{base64.b64encode(encryptedData)}")
    # 更新 query
    request.content = urlencode({"encryptedData": base64.b64encode(encryptedData)}).encode()
    return request

@app.post("/hookResponseToBurp", response_model=ResponseModel)
async def hook_response_to_burp(response: ResponseModel):
    return response

@app.post("/hookResponseToClient", response_model=ResponseModel)
async def hook_response_to_client(response: ResponseModel):
    return response

def decrypt(content: bytes) -> bytes:
    cipher = AES.new(KEY, AES.MODE_CBC, IV)
    return unpad(cipher.decrypt(content), AES.block_size)

def encrypt(content: bytes) -> bytes:
    cipher = AES.new(KEY, AES.MODE_CBC, IV)
    return cipher.encrypt(pad(content, AES.block_size))

def get_data(content: bytes) -> bytes:
    body_json: t.Dict = json.loads(content)
    return base64.b64decode(body_json[JSON_KEY])

def to_data(contnet: bytes) -> bytes:
    body_json = {}
    body_json[JSON_KEY] = base64.b64encode(contnet).decode()
    return json.dumps(body_json).encode()

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

然后可以在 proxy 请求中尝试解密，操作如下：

解密后可以看到明文显示，这里是弹出了一个窗口，可以看到 url 编码后的结果；注意这里的 X-Galaxy-Http-Hook: HookedRequest 是 Galaxy 插件 hook 的标识，有这个标识才会进行加密脚本中 hookRequestToServer 的执行。

使用 Decoder 模块进行 URL 解码看看结果。

如果觉得手动解码有点麻烦，可以将请求发送到 repeater 模块中解密，右侧的 inspector 功能自动解码，省去一次操作步骤。

脚本也会同步打印调试信息，可以看到解密后的信息。

那么我们修改输入的明文，看看插件的效果，能否自动加密后发送请求。

可以看到，脚本中的 hookRequestToServer 将明文加密后发送给服务端。

接下来就是如何进行爆破的问题，其实跟普通的爆破是一样的，将解密后端请求添加到 intruder 模块中，针对爆破参数添加字典进行爆破即可（后续题目不再赘述爆破步骤）。

可以看到响应结果是正常显示。

插件脚本也会自动进行加密后发送请求，这里提供的脚本也同步打印了加密的信息。

AES 服务端获取 Key

查看请求：先从服务端获取 aes 加密的 key 和 iv 的值，多次请求可以看到这 2 个值是固定的。

然后发送加密请求，响应内容存在 Unicode 编码，使用 python print 解码得到 用户名或密码错误

通过栈跟踪，定位到关键代码后分析如下：

请求格式：POST + application/json + encryptedData 的 JSON 体；

请求内容：明文是账号密码 JSON，加密后仅传加密字符串；

加密方式：AES-CBC + PKCS7 填充 + Base64 输出；

加密参数：Key/IV 从后端动态获取（Base64 解码后使用），长度均为 16 字节（AES-128）。

那么我们复制模板中的 aes_cbc.py 脚本，修改对 key 和 iv 进行 base64 解码、修改 JSON_KEY 为请求中的参数 encryptedData：

import json
import base64
import typing as t
from fastapi import FastAPI
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from _base_classes import *

KEY = base64.b64decode("UMmKw73GSNZcCFqj6/XN5A==")
IV = base64.b64decode("1SofbOFnjQCBcNt2M35PTQ==")
JSON_KEY = "encryptedData"

app = FastAPI()

@app.post("/hookRequestToBurp", response_model=RequestModel)
async def hook_request_to_burp(request: RequestModel):
    """HTTP 请求从客户端到达 Burp 时被调用。在此处完成请求解密的代码就可以在 Burp 中看到明文的请求报文。"""
    # print(f"[+] hookRequestToBurp be called. request: {request.model_dump_json()}")
    # 获取需要解密的数据
    encrypted_data: bytes = get_data(request.content)
    # 调用函数解密
    data: bytes = decrypt(encrypted_data)
    print(f"[DEBUG] 解密后的数据：{data.decode()}")
    # 更新 body 为已解密的数据
    request.content = data
    return request

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求加密的代码就可以将加密后的请求报文发送到 Server。"""
    # print(f"[+] hookRequestToServer be called. request: {request.model_dump_json()}")
    # 获取被解密的数据
    data: bytes = request.content
    # 调用函数加密回去
    encryptedData: bytes = encrypt(data)
    # 将已加密的数据转换为 Server 可识别的格式
    body: bytes = to_data(encryptedData)
    print(f"[DEBUG] 加密后的数据：{base64.b64encode(encryptedData)}")
    # 更新 body
    request.content = body
    return request

@app.post("/hookResponseToBurp", response_model=ResponseModel)
async def hook_response_to_burp(response: ResponseModel):
    return response

@app.post("/hookResponseToClient", response_model=ResponseModel)
async def hook_response_to_client(response: ResponseModel):
    return response

def decrypt(content: bytes) -> bytes:
    cipher = AES.new(KEY, AES.MODE_CBC, IV)
    return unpad(cipher.decrypt(content), AES.block_size)

def encrypt(content: bytes) -> bytes:
    cipher = AES.new(KEY, AES.MODE_CBC, IV)
    return cipher.encrypt(pad(content, AES.block_size))

def get_data(content: bytes) -> bytes:
    body_json: t.Dict = json.loads(content)
    return base64.b64decode(body_json[JSON_KEY])

def to_data(contnet: bytes) -> bytes:
    body_json = {}
    body_json[JSON_KEY] = base64.b64encode(contnet).decode()
    return json.dumps(body_json).encode()

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

启动后将加密请求发送到 repeater 模块进行解密。

成功解密，脚本也正常打印调试信息。

修改密码请求，发送成功。

脚本也成功打印调试信息。

RSA 加密

加密请求如下：

通过栈追踪定位到如下代码，分析结果如下：

请求方式：POST + 表单格式（application/x-www-form-urlencoded）；

请求参数：明文是账号密码 JSON 串（格式是 data={"username":"xxx","password":"xxx"}），加密后为 Base64 格式的 RSA 密文；

加密方法：RSA 非对称加密，PKCS#1 v1.5 填充；

加密参数：固定硬编码的 RSA 1024 位公钥。

Galaxy

改造模板中的 rsa.py 代码：

• 本题不知道解密的私钥，只能尝试进行请求的加密（前面分析已经知道了请求体的格式）；
• 这个题目需要对加密后的结果进行 url 编码；
• 注意公钥书写的格式，\n 手动换行；
• 提取请求的参数 JSON_KEY 是 data；
• 需要对 BurpSuite 请求添加请求头 X-Galaxy-Http-Hook: HookedRequest，以让 Galaxy 插件识别是要加密的请求。

import base64
from urllib.parse import parse_qs, quote_plus
from Crypto.Cipher import PKCS1_v1_5
from Crypto.PublicKey import RSA
from fastapi import FastAPI
from _base_classes import *

pub_key = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRvA7giwinEkaTYllDYCkzujvi
NH+up0XAKXQot8RixKGpB7nr8AdidEvuo+wVCxZwDK3hlcRGrrqt0Gxqwc11btlM
DSj92Mr3xSaJcshZU8kfj325L8DRh9jpruphHBfh955ihvbednGAvOHOrz3Qy3Cb
ocDbsNeCwNpRxwjIdQIDAQAB
-----END PUBLIC KEY-----"""

JSON_KEY = "data"

app = FastAPI()

@app.post("/hookRequestToBurp", response_model=RequestModel)
async def hook_request_to_burp(request: RequestModel):
    return request

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求加密的代码就可以将加密后的请求报文发送到 Server。"""
    # 获取请求内容
    content_str = request.content.decode('utf-8')
    # 解析请求内容，提取参数的值
    try:
        parsed_data = parse_qs(content_str)
        if 'data' in parsed_data:
            # 获取参数的值
            original_data = parsed_data['data'][0]
            print(f"[DEBUG] 加密前的数据：{original_data}")
            # 对值进行 RSA 加密
            encrypted_data = encrypt(original_data.encode('utf-8'), pub_key)
            # Base64 编码
            encrypted_b64 = base64.b64encode(encrypted_data).decode('utf-8')
            # URL 编码
            encrypted_url_encoded = quote_plus(encrypted_b64)
            # 构造新的请求内容
            new_content = f"data={encrypted_url_encoded}"
            print(f"[DEBUG] 加密后的数据：{new_content}")
            # 更新请求内容
            request.content = new_content.encode('utf-8')
        else:
            print("[WARNING] 请求中未找到指定参数")
    except Exception as e:
        print(f"[ERROR] 处理请求时出错：{e}")
        pass
    return request

def encrypt(content: bytes, secret: bytes) -> bytes:
    rsa_key = RSA.import_key(secret)
    cipher = PKCS1_v1_5.new(rsa_key)
    return cipher.encrypt(content)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

启动脚本后，通过构造 BurpSuite 请求完成加密请求，注意添加请求体 X-Galaxy-Http-Hook: HookedRequest，让请求走我们编写的 Galaxy 的脚本。

autoDecoder

配置如下图：题目中的密文还进行了 url 编码，所有要勾选 2

注意密钥是公钥：填写格式如下：

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRvA7giwinEkaTYllDYCkzujvi
NH+up0XAKXQot8RixKGpB7nr8AdidEvuo+wVCxZwDK3hlcRGrrqt0Gxqwc11btlM
DSj92Mr3xSaJcshZU8kfj325L8DRh9jpruphHBfh955ihvbednGAvOHOrz3Qy3Cb
ocDbsNeCwNpRxwjIdQIDAQAB

配置后在 repeater 模块发送请求，可以成功加密。

AES+RSA 加密

加密请求如下：

定位到加密代码，分析如下：

使用算法：

• AES-CBC 模式，加密数据格式 {"username":"xxx","password":"xxx"}，AES 的 key 和 iv 随机 16 字节。
• RSA 公钥加密，_0x41d8d9[_0x13ef4f(953, 972)](_0x13ef4f(990, 973)) 这一行，就是设置 RSA 公钥的地方；_0x13ef4f(953, 972)对应 setPublicKey，(_0x13ef4f(990, 973)即公钥内容。

{
"encryptedData":"AES 加密后的用户名 + 密码 JSON 字符串",// AES 加密数据
"encryptedKey":"RSA 加密后的 AES key(Base64 格式)",// RSA 加密后的 AES key
"encryptedIv":"RSA 加密后的 AES iv(Base64 格式)"// RSA 加密后的 AES iv
}

在浏览器的控制台打印 console.log(_0x13ef4f(990, 973)) 获取 RSA 公钥：

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRvA7giwinEkaTYllDYCkzujvi
NH+up0XAKXQot8RixKGpB7nr8AdidEvuo+wVCxZwDK3hlcRGrrqt0Gxqwc11btlM
DSj92Mr3xSaJcshZU8kfj325L8DRh9jpruphHBfh955ihvbednGAvOHOrz3Qy3Cb
ocDbsNeCwNpRxwjIdQIDAQAB
-----END PUBLIC KEY-----

思路：

• 目标是替换 encryptedData 的内容，因此需要进行 AES 解密；
• AES 解密需要 AES 的 key 和 iv；
• key 和 iv 在 encryptedKey 和 encryptedIv 中被 RSA 的公钥加密；
• 不知道 RSA 私钥无法解密 key 和 iv；通过 Chrome 浏览器固定 AES 的 key 和 iv 的值；
• 传参时 encryptedData 使用明文数据（格式前面分析已经知道）；encryptedKey 和 encryptedIv 使用请求中的原始密文。
• 加密时通过 AES 算法加密 encryptedData 的值。

使用 Chrome 浏览器的 override content 功能替换 app.js：先将原始 app.js 下载到本地，在浏览器源码处右键 Overrides content 选择本地的文件，选中后修改代码中固定 key 和 iv 为 16 字节，修改完按 Ctrl+S 保存，注意格式。

注意：下次打开浏览器即使该页面启用了 Overrides content 也会失效，需要在修改的地方打断点，用 debugger 的形式运行。

, _0x4515a4 = CryptoJS.enc.Utf8.parse('1234567890123456')
, _0x5e9345 = CryptoJS.enc.Utf8.parse('1234567890123456')

然后抓包，可以看到使用固定 key 和 iv 进行 AES 加密后的 encryptedData，重试一次保证 encryptedData 的值不变，说明代码修改有效。

Galaxy

脚本需要实现的是使用 AES 加密参数 encryptedData 的值，固定 key 和 iv 为我们指定的值；其他 2 个参数的值不变。

import base64
import json
from Crypto.Cipher import PKCS1_v1_5, AES
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad
from fastapi import FastAPI
from _base_classes import *

KEY = b"1234567890123456"  # 16 字节
IV = b"1234567890123456"  # 16 字节
JSON_KEY1 = "encryptedData"

app = FastAPI()

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    try:
        # 获取请求内容
        data: bytes = request.content
        # 解析 JSON
        request_json = json.loads(data.decode())
        # print(f"解析的 JSON: {request_json}")
        # 只修改 encryptedData 参数，保持其他参数不变
        if JSON_KEY1 in request_json:
            # 获取原始的 encryptedData 值
            original_encrypted_data = request_json[JSON_KEY1]
            print(f"原始 encryptedData: {original_encrypted_data}")
            # 处理 encryptedData 值
            if isinstance(original_encrypted_data, str):
                try:
                    # 尝试将字符串解析为 JSON 对象
                    inner_json = json.loads(original_encrypted_data)
                    print(f"解析出的 JSON: {inner_json}")
                    # 重新序列化为字符串用于加密
                    encrypted_data_bytes = original_encrypted_data.encode()
                except json.JSONDecodeError:
                    # 如果不是有效的 JSON 字符串，直接使用原字符串
                    print("encryptedData 不是有效的 JSON 格式，直接使用原值")
                    encrypted_data_bytes = original_encrypted_data.encode()
            else:
                # 如果不是字符串，转换为字符串
                encrypted_data_bytes = str(original_encrypted_data).encode()
            # 对 encryptedData 进行 AES 加密
            encryptedData1: bytes = aes_encrypt(encrypted_data_bytes)
            # 更新 encryptedData 参数的值
            request_json[JSON_KEY1] = base64.b64encode(encryptedData1).decode()
            # 构造新的请求体
            body: bytes = json.dumps(request_json, ensure_ascii=False).encode()
            encrypted_json_str = body.decode()
            print(f"[DEBUG] 修改后的数据：{encrypted_json_str}")
            request.content = body
        else:
            print(f"未找到 {JSON_KEY1} 参数")
    except Exception as e:
        print(f"处理错误：{e}")
    return request

def aes_encrypt(content: bytes) -> bytes:
    cipher = AES.new(KEY, AES.MODE_CBC, IV)
    return cipher.encrypt(pad(content, AES.block_size))

def rsa_encrypt(content: bytes, secret: bytes) -> bytes:
    rsa_key = RSA.import_key(secret)
    cipher = PKCS1_v1_5.new(rsa_key)
    return cipher.encrypt(content)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

启动编写的脚本，将加密请求发送到 repeater 模块，添加 hook 的请求头，修改加密数据为 {"username":"admin","password":"123456"}，发送请求后，服务端成功响应。

脚本也同步打印调试信息：

autoDecoder

使用 autoDecoder 比较方便，配置如下（记得保存配置）：正则是 "encryptedData":"(.*)","encryptedKey"。

记得重新加载下新配置，以免不生效。

直接在请求中明文输入，内容是 {"username":"admin","password":"123456"}，实战中可以对这里进行爆破。

DES 规律 key

请求如下：

核心代码使用 DES-CBC 模式加密密码，核心规则：

• 密钥（Key）：从用户名截取前 8 位（0 开始），不足补字符 6 到 8 位；
• 向量（IV）：固定前缀 9999 + 用户名前 4 位（0 开始），不足补字符 9 到 8 位；
• 填充方式：PKCS7（CryptoJS 默认）；
• 输出格式：加密后的二进制密文转 16 进制字符串（而非 Base64）；
• 加密对象：页面输入的密码（password 输入框的值）。

一句话总结：通过用户名获取 key 和 iv 的值，对密码进行 DES-CBC 加密，结果转 16 进制字符串。

Galaxy

脚本代码如下：实现的就是对 password 值的加解密，需要获取 username 来生成 key 和 iv 的值。

import json
from Crypto.Cipher import DES
from Crypto.Util.Padding import pad, unpad
from fastapi import FastAPI
from _base_classes import *

KEY = b""
IV = b""

app = FastAPI()

@app.post("/hookRequestToBurp", response_model=RequestModel)
async def hook_request_to_burp(request: RequestModel):
    """HTTP 请求从客户端到达 Burp 时被调用。在此处完成请求解密的代码就可以在 Burp 中看到明文的请求报文。"""
    # print(f"[+] hookRequestToBurp be called. request: {request.model_dump_json()}")
    try:
        # 解析请求体 JSON
        request_body = json.loads(request.content.decode())
        username = request_body.get("username", "")
        password_encrypted = request_body.get("password", "")
        if not username or not password_encrypted:
            print("缺少 username 或 password 字段")
            return request
        # 生成 KEY 和 IV
        global KEY, IV
        KEY, IV = generate_key_iv(username)
        print(f"生成的 KEY: {KEY}, IV: {IV}")
        # 将十六进制字符串转换为字节用于解密
        encrypted_bytes = bytes.fromhex(password_encrypted)
        # 使用 decrypt 方法解密
        decrypted_bytes = decrypt(encrypted_bytes)
        password_decrypted = decrypted_bytes.decode('utf-8')
        print(f"解密后的 password: {password_decrypted}")
        # 更新请求体
        request_body["password"] = password_decrypted
        request.content = json.dumps(request_body, ensure_ascii=False).encode()
    except Exception as e:
        print(f"解密过程出错：{e}")
    return request

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求加密的代码就可以将加密后的请求报文发送到 Server。"""
    # print(f"[+] hookRequestToServer be called. request: {request.model_dump_json()}")
    try:
        # 解析请求体 JSON（此时 password 应该是明文）
        request_body = json.loads(request.content.decode())
        username = request_body.get("username", "")
        password_decrypted = request_body.get("password", "")
        if not username or not password_decrypted:
            print("缺少 username 或 password 字段")
            return request
        # 生成 KEY 和 IV
        global KEY, IV
        KEY, IV = generate_key_iv(username)
        print(f"[+] 生成的 KEY: {KEY}, IV: {IV}")
        # 使用现有的 encrypt 方法加密 password
        password_bytes = password_decrypted.encode('utf-8')
        encrypted_bytes = encrypt(password_bytes)
        # 转换为十六进制字符串
        password_encrypted = encrypted_bytes.hex()
        print(f"加密后的 password: {password_encrypted}")
        # 只更新 password 字段
        request_body["password"] = password_encrypted
        # 构造新的请求体
        request.content = json.dumps(request_body, ensure_ascii=False).encode()
    except Exception as e:
        print(f"加密过程出错：{e}")
    return request

def generate_key_iv(username: str) -> tuple[bytes, bytes]:
    """
    根据用户名生成 KEY 和 IV
    KEY: 用户名截取前 8 位（0 开始），不足补字符'6'到 8 位
    IV: 固定前缀'9999' + 用户名前 4 位（0 开始），不足补字符'9'到 8 位
    """
    # 生成 KEY
    username_prefix = username[:8]
    key = username_prefix.ljust(8, '6').encode()
    # 生成 IV
    username_prefix_4 = username[:4]
    iv_str = "9999" + username_prefix_4.ljust(4, '9')
    iv = iv_str.encode()
    return key, iv

def decrypt(content: bytes) -> bytes:
    cipher = DES.new(KEY, DES.MODE_CBC, IV)
    return unpad(cipher.decrypt(content), DES.block_size)

def encrypt(content: bytes) -> bytes:
    cipher = DES.new(KEY, DES.MODE_CBC, IV)
    return cipher.encrypt(pad(content, DES.block_size))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

在 repeater 中解密请求：

解密后密码是明文：

发送也正常：

脚本调试信息也正常：

autoDecoder

使用这个工具的话只能单个进行验证，需要自己算 key 和 iv，密码记得选 16 进制 (hex)；因此这关使用 autoDecoder 工具只能爆破固定用户名的密码。

明文加签

请求如下：

核心代码分析如下：

随机数

• 签名算法：HmacSHA256（基于哈希的消息认证码，不可逆）；
• nonce 是随机小数转换成 36 进制再去掉 0.；
• timestamp 是获取当前毫秒时间戳，除以 1000 并向下取整；
• 签名密钥：固定值 be56e057f20f883e；
• 签名原文：用户名 + 密码 + 随机数 (nonce) + 时间戳 (timestamp)；
• 签名输出：HmacSHA256 结果转 16 进制字符串。

选中使用 Galaxy 进行请求加签，脚本如下：

import hashlib
import hmac
import json
import random
import string
import time
from fastapi import FastAPI
from _base_classes import *

app = FastAPI()

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求签名计算的代码。"""
    try:
        # 获取原始请求内容
        content_str = request.content.decode('utf-8')
        # 解析请求体 JSON
        request_body = json.loads(content_str)
        # 获取用户名和密码
        username = request_body.get("username", "")
        password = request_body.get("password", "")
        if not username or not password:
            print("缺少 username 或 password 字段")
            return request
        # 生成随机数
        nonce = ''.join(random.choices(string.ascii_lowercase + string.digits, k=10))
        # 获取当前毫秒时间戳
        timestamp = int(time.time())
        # 签名密钥
        secret_key = "be56e057f20f883e"
        # 构造签名原文：用户名 + 密码 + 随机数 + 时间戳
        sign_text = f"{username}{password}{nonce}{timestamp}"
        # 计算 HmacSHA256 签名
        signature = hmac.new(
            secret_key.encode('utf-8'),
            sign_text.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        # 更新请求体中的字段
        request_body["nonce"] = nonce
        request_body["timestamp"] = timestamp
        request_body["signature"] = signature
        # 构造新的请求体
        new_content = json.dumps(request_body, ensure_ascii=False).encode()
        request.content = new_content
        print(f"新的请求内容：{new_content.decode()}")
    except json.JSONDecodeError as e:
        print(f"JSON 解析错误：{e}")
        return request
    except Exception as e:
        print(f"签名计算过程出错：{e}")
        return request
    return request

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)

发送请求时记得添加请求头：X-Galaxy-Http-Hook: HookedRequest

加签 key 在服务器端

请求有 2 个，先从服务端获取签名，再发送请求：

核心代码逻辑：账号密码 + 生成时间戳 → 找服务器要签名 → 带签名提交登录信息。

async function sendDataWithNonceServer(_0xb4476b){
function _0x5b14e6(_0x9f039f, _0x3746ee){return _0x4f79d5(_0x9f039f -0xde, _0x3746ee);}
const _0x41822d = document['getElementById']('username')['value'], _0x3c65d8 = document['getElementById']('password')['value'], _0x173dbd = Math[_0x5b14e6(0x281,0x282)](Date[_0x5b14e6(0x282,0x26f)]()/0x3e8);
try{
const _0x55d2c7 = await fetch(_0xb4476b + _0x5b14e6(0x283,0x28d),{'method':_0x5b14e6(0x27a,0x26b),'headers':{'Content-Type':_0x5b14e6(0x280,0x26f)},'body':JSON['stringify']({'username': _0x41822d,'password': _0x3c65d8,'timestamp': _0x173dbd })});
closeModal();
if(!_0x55d2c7['ok']){ console['error']('获取签名失败:', _0x55d2c7['statusText']),alert('获取签名失败，请稍后重试。');return;}
const{signature: _0x2755ad}=await _0x55d2c7[_0x5b14e6(0x26b,0x279)]();
if(!_0x2755ad){alert('签名获取失败，服务器未返回签名。');return;}
const _0x58deb5 = await fetch(''+ _0xb4476b,{'method':'POST','headers':{'Content-Type':'application/json'},'body':JSON['stringify']({'username': _0x41822d,'password': _0x3c65d8,'timestamp': _0x173dbd,'signature': _0x2755ad })});
if(!_0x58deb5['ok']){ console['error'](_0x5b14e6(0x284,0x28b), _0x58deb5['statusText']),alert('提交数据失败，请稍后重试。');return;}
const _0x22648d = await _0x58deb5['json'](); _0x22648d[_0x5b14e6(0x26c,0x26a)]?(alert('登录成功'), window['location']['href']='success.html'):alert(_0x22648d[_0x5b14e6(0x274,0x285)]||'用户名或密码错误');
}catch(_0x30ffca){ console['error'](_0x5b14e6(0x26f,0x265), _0x30ffca),alert('发生错误，请稍后重试。');}
}

直接通过纯 python 脚本实现即可，没必要使用插件。

import requests
import json
import time

host = "http://192.168.10.11:82"
headers = {
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
"Cookie": "PHPSESSID=73fc283a7d583cc5433f44f606f9822a"
}

def get_timestamp():
    return int(time.time())

def step1_get_signature(username, password, timestamp):
    url = f"{host}/encrypt/get-signature.php"
    payload = {
        "username": username,
        "password": password,
        "timestamp": timestamp
    }
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    result = response.json()
    return result.get("signature")

def step2_send_signed_request(username, password, timestamp, signature):
    url = f"{host}/encrypt/signdataserver.php"
    payload = {
        "username": username,
        "password": password,
        "timestamp": timestamp,
        "signature": signature
    }
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

def main():
    username = "admin"
    password = "123456"
    timestamp = get_timestamp()
    try:
        signature = step1_get_signature(username, password, timestamp)
        result = step2_send_signed_request(username, password, timestamp, signature)
        print(f"服务器响应：{json.dumps(result, indent=2, ensure_ascii=False)}")
    except Exception as e:
        print(f"发生错误：{e}")

if __name__ == "__main__":
    main()

禁止重放

请求如下：可以看到核心在于生成的 random 参数的值。

核心代码：random = RSA 加密 (毫秒时间戳 )。

function generateRequestData(){
function _0x34b479(_0x38b999, _0x500418){return _0x4f79d5(_0x38b999 -0x1e4, _0x500418);}
const _0x1da0ac = document[_0x34b479(0x360,0x357)](_0x34b479(0x366,0x379))['value'], _0x4fdc07 = document[_0x34b479(0x360,0x360)](_0x34b479(0x368,0x37d))[_0x34b479(0x367,0x351)], _0x5a8525 = Date[_0x34b479(0x388,0x37a)](), _0x9f2be4 = _0x34b479(0x37e,0x381);
function _0x5b0e97(_0x482893, _0x201f27){
const _0x3ef89b = new JSEncrypt(); _0x3ef89b[_0x434cfc(0x300,0x2f2)](_0x201f27);
const _0x311c6b = _0x3ef89b[_0x434cfc(0x2ed,0x2fc)](_0x482893['toString']());
function _0x434cfc(_0x57eb61, _0x7fc509){return _0x34b479(_0x57eb61 --0x7d, _0x7fc509);}
if(!_0x311c6b) throw new Error('RSA\x20encryption\x20failed.');
return _0x311c6b;
}
let _0x110e21;
try{ _0x110e21 = _0x5b0e97(_0x5a8525, _0x9f2be4);}
catch(_0x16a5f1){return console['error']('Encryption\x20error:', _0x16a5f1),null;}
const _0x163cb9 = {'username': _0x1da0ac,'password': _0x4fdc07,'random': _0x110e21 };
return _0x163cb9;
}

经过断点调试，找到公钥：

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRvA7giwinEkaTYllDYCkzujvi
NH+up0XAKXQot8RixKGpB7nr8AdidEvuo+wVCxZwDK3hlcRGrrqt0Gxqwc11btlM
DSj92Mr3xSaJcshZU8kfj325L8DRh9jpruphHBfh955ihvbednGAvOHOrz3Qy3Cb
ocDbsNeCwNpRxwjIdQIDAQAB
-----END PUBLIC KEY-----

编写 Galaxy 脚本，纯 python 脚本也行，逻辑一样。

import base64
import json
import time
from Crypto.Cipher import PKCS1_v1_5
from Crypto.PublicKey import RSA
from fastapi import FastAPI
from _base_classes import *

app = FastAPI()

KEY = """-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDRvA7giwinEkaTYllDYCkzujvi
NH+up0XAKXQot8RixKGpB7nr8AdidEvuo+wVCxZwDK3hlcRGrrqt0Gxqwc11btlM
DSj92Mr3xSaJcshZU8kfj325L8DRh9jpruphHBfh955ihvbednGAvOHOrz3Qy3Cb
ocDbsNeCwNpRxwjIdQIDAQAB
-----END PUBLIC KEY-----"""

@app.post("/hookRequestToServer", response_model=RequestModel)
async def hook_request_to_server(request: RequestModel):
    """HTTP 请求从 Burp 将要发送到 Server 时被调用。在此处完成请求签名计算的代码。"""
    # print(f"[+] hookRequestToServer be called. request: {request.model_dump_json()}")
    try:
        # 获取原始请求内容
        content_str = request.content.decode('utf-8')
        # 解析请求体 JSON
        request_body = json.loads(content_str)
        # 获取用户名和密码
        username = request_body.get("username", "")
        password = request_body.get("password", "")
        if not username or not password:
            print("缺少 username 或 password 字段")
            return request
        # 获取当前毫秒时间戳
        timestamp = str(int(time.time())*1000)
        # 对时间戳进行 RSA 加密
        encrypted_bytes = encrypt(timestamp.encode('utf-8'), KEY)
        random = base64.b64encode(encrypted_bytes).decode()
        # 更新请求体中的字段
        request_body["random"] = random
        # 构造新的请求体
        new_content = json.dumps(request_body, ensure_ascii=False).encode()
        request.content = new_content
        print(f"新的请求内容：{new_content.decode()}")
    except Exception as e:
        print(e)
    return request

return request

def encrypt(content, secret) -> bytes:
    rsa_key = RSA.import_key(secret)
    cipher = PKCS1_v1_5.new(rsa_key)
    return cipher.encrypt(content)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=5000)