【好靶场】JS加密逆向分析笔记
本文主要给大家分享关于Js逆向和解密的相关方法和思路
0x00 前言
文本大部分内容都是由好靶场团队-秋佬编写,额外添加了一些简要的说明。废话不多说开始正文。
JS 加密逆向分析是前端安全与逆向工程领域的核心技术之一,主要针对网页、移动端 H5 或 Electron 等基于 JavaScript 运行的应用中,用于保护数据传输、接口请求、核心逻辑的加密机制,通过技术手段还原加密流程、推导加密算法、破解加密参数的一系列分析过程。
在很多时候,有一些接口存在越权漏洞,但是因为数据包被加密了,导致我们无法进行漏洞利用,这个时候我们就需要去分析JS,进行参数伪造,以及数据包构造。是作为安全研究员必回的能力之一。
以下所有的内容都是根据真实报告改编,取材于真实案例~
0x01 JS 加密逆向分析反调试对抗 1
解题思路
已知本题考验的是javascript逆向,那肯定要从源码分析,我们首先看一下请求包。
咱们的id是2,那么管理员的就是1了,修改,重发包试试:
可以看到请求失败了,因为没有cookie等身份认证的字段,那用作身份校验的肯定就是请求体里的htccheck了,而且出现在请求体里,说明肯定是前段传过来的,那么我们从前端代码处分析一下:
正片开始……
反调试手段
首先,网站是开启了禁止调试的,通过禁用快捷键和右键菜单、持续触发 debugger 暂停以及通过窗口尺寸变化检测 DevTools 状态等多种手段,阻止用户对网页进行调试、查看和复制代码的操作,是一种典型的反调试技术,好了,大家可以暂停一下心里暗骂@llm几句了。更详细的反调试这里就不做分析了,有兴趣的朋友可以去源码里面找到这段代码研究一下。
既然禁止我们调试,那就只能把源码扒下来了,在页面ctrs+s保存到本地即可!或者喜欢前段调试的朋友,可以直接选择“一律不在此处暂停”。
javascript逆向分析
在页面中,DOMContentLoaded 时拼出一个隐藏节点 #__k,其中 data-x 存储了被“插隔符+反转+Base64”的公钥数据,data-s 存储分隔符。
加密请求构造:默认 id = 2,并用公钥对字符串 "2" 加密,得到 htccheck 一并传给后端。
公钥还原函数 d() 的等价实现,从 data-x 用 data-s 拼接 → 反转 → Base64 解码 → PEM 文本:
加密实现核心:RSA-OAEP(SHA-256),优先 WebCrypto,回退 node-forge,这里两条路径算法一致总结:
到这里让我们捋一捋!
- 明文就是字符串 "2",前端未把 id 动态绑定给加密函数的第二参
- 算法是 RSA-OAEP,哈希为 SHA-256,输出 Base64
- 你要生成 id=1 的 htccheck,只需对明文 "1" 用相同公钥同算法加密即可,id 放在 JSON 明文字段里
加密算法编写步骤:
- 还原 PEM 公钥:
- 从 data-x 去掉分隔符 ::,拼接为一条长串;
- 整串反转
- Base64 解码得到 PEM 文本,包含
- 对明文 "1" 执行 RSA-OAEP(SHA-256) 加密
- 对密文字节做 Base64 编码,得到 htccheck
理论存在,实践开始:
脚本编写
知道了加密流程,解密流程逆着来就行了,就很简单了
# pip install cryptography
import base64
import argparse
from typing import Tuple
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding
DATA_X = "自己找data-x哦"
DATA_S = "::"
def resolve_pem(data_x: str, sep: str = "::") -> str:
joined = "".join(data_x.split(sep))
reversed_str = joined[::-1]
pem_bytes = base64.b64decode(reversed_str)
return pem_bytes.decode("utf-8")
def rsa_oaep_sha256_encrypt_base64(pem: str, plaintext: str) -> str:
public_key = serialization.load_pem_public_key(pem.encode("utf-8"))
ciphertext = public_key.encrypt(
plaintext.encode("utf-8"),
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
return base64.b64encode(ciphertext).decode("utf-8")
def build_htccheck_for_id(target_id: int) -> Tuple[int, str]:
pem = resolve_pem(DATA_X, DATA_S)
htccheck = rsa_oaep_sha256_encrypt_base64(pem, str(target_id))
return target_id, htccheck
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--id", type=int, default=1, help="ID(默认1)")
args = parser.parse_args()
target_id, htccheck = build_htccheck_for_id(args.id)
print(htccheck)
- 用法:
- 只生成 id=1:python htccheck.py
- 生成任意 id:python htccheck.py --id 2
0x02 JS 加密加盐逆向分析案例
代码分析
通过main.min.js代码可以发现,在相关常量与辅助函数初始化中:
- 代码把常量数组收在
b里,通过r(idx)取值,主要是公钥头尾与算法参数字面量:
b[0]="-----BEGIN PUBLIC KEY-----"b[1]="-----END PUBLIC KEY-----"b[2]="spki"b[3]="RSA-OAEP"b[4]="SHA-256"b[5]="encrypt"b[6]="data-x"b[7]="data-s"
- c() 是一个回退加载器:如果没全局 forge.pki,就依次尝试 3 个 CDN 动态加载 node-forge。成功则 resolve(true),失败轮换到下一个,全部失败才 reject。
从 DOM 还原 PEM 公钥:__resolvePem()
- 查找元素:document.getElementById('__k'),若不存在直接返回空串。
- 读取两个自定义属性:
data-x:承载“处理后”的公钥数据data-s:data-x 内部的分隔符(默认 '::')
- 还原流程:
- 用分隔符把 data-x 中的分隔标记去掉,拼回连续字符串
- 将结果整体反转
- 对反转后的字符串执行 atob,得到标准 PEM 文本
- 导出到全局:window.__resolvePem = d
加密主函数签名:
默认前缀 + “10086”
- 入参:
g:PEM 公钥字符串(上一步 __resolvePem() 的返回值)h:可选明文前缀,缺省时设为 "2"
- 明文构造:
- 若 h 未传:h = "2"
- 固定拼接尾部 "10086":h = h + "10086"
- 因此默认明文是 "210086";自定义时如传 "9" 则为 "910086"
- 这里有一个无用的微型循环 p(),那小子骗人的
- 导出到全局:window.rsaEncryptWithPEM = a
WebCrypto 加密(RSA-OAEP/SHA-256)
当浏览器支持 window.crypto.subtle 时,按以下步骤执行:
- 去掉 PEM 包裹与空白,得到 base64 的主体
- k = g.trim()
- 依次 replace("-----BEGIN PUBLIC KEY-----","")、replace("-----END PUBLIC KEY-----","")
- replace(/ \s+/g,'') 去除换行与空白
- 此时 k 是纯 base64 内容(SPKI 的 DER 编码)
- base64 → 二进制 → ArrayBuffer
- l = Uint8Array.from(atob(k), ch => ch.charCodeAt(0))
- 取 l.buffer 作为密钥原始字节
- 导入公钥为 CryptoKey
- subtle.importKey("spki", l.buffer, { name:"RSA-OAEP", hash:"SHA-256" }, false, ["encrypt"])
- 格式为 spki
- 算法 RSA-OAEP
- 摘要 SHA-256
- 用途 encrypt
- 明文编码
- 通过 TextEncoder() 把上一步的字符串明文 h 编码成 Uint8Array
- 执行加密并 base64 输出
- subtle.encrypt({ name:"RSA-OAEP" }, publicKey, plaintextBytes)
- 将返回的 ArrayBuffer 转成 Uint8Array 再转成字符串,最后 btoa 得到 base64 密文,作为 htccheck
要点:
- 算法为 RSA-OAEP,MGF1 默认跟随 hash=SHA-256。
- 输出统一为 base64 字符串。
回退使用 node-forge(同为 RSA-OAEP/SHA-256)
若 WebCrypto 不可用:
- 如果还没全局 forge,则先执行 c() 动态加载
- 使用 forge.pki.publicKeyFromPem(g) 解析 PEM
- 明文用 forge.util.encodeUtf8(h) 得到字节
- 调用 publicKey.encrypt(plaintext, 'RSA-OAEP', { md: forge.md.sha256.create(), mgf1: forge.mgf1.create(forge.md.sha256.create()) })
- 指定 OAEP 的哈希与 MGF1 都是 SHA-256
- 最后 forge.util.encode64(cipherBytes) 作为 htccheck
全流程
- 页面需要一个 id="__k" 的节点,包含:
data-x:被插入分隔符、整体反转、再 base64 的字符串data-s:分隔符(默认 '::')
- 取 PEM:const pem = __resolvePem()
- 算出 htccheck:const htccheck = await rsaEncryptWithPEM(pem, prefix?)
- 若不传 prefix,默认明文 "210086";传 "9" 则 "910086"
至于beta.min.js、gamma.min.js、zeta.min.js 分别生成 sessionStorage.k1..k3、window.__z、window.__q 之类的,纯属凑数的
总结
- 明文 = 前缀(默认"2") + "10086"
- RSA-OAEP/SHA-256 加密,输出 base64
- PEM 公钥从 #__k[data-x][data-s] 逆变换还原得到
- 先用 WebCrypto,失败回退 node-forge(同参数)
加密算法编写:
首先从页面属性还原 PEM:
document.getElementById('__k')?.getAttribute('data-x')然后使用脚本生成htccheck:
python generate_htccheck.py --data-x " PEM" --data-s "::" --h 1
重新发包:
脚本附上:
import argparse
import base64
import sys
from typing import Optional
def resolve_pem_from_data_attrs(data_x: str, data_s: str = "::") -> str:
"""
Mirror JS __resolvePem():
- remove separators (split/join by data_s)
- reverse the string
- atob (base64 decode) => PEM (UTF-8)
"""
if data_x is None:
raise ValueError("data-x is required to resolve PEM")
if data_s is None:
data_s = "::"
joined = (data_x or "").split(data_s)
joined = "".join(joined)
reversed_str = joined[::-1]
try:
pem_bytes = base64.b64decode(reversed_str)
return pem_bytes.decode("utf-8")
except Exception as exc:
raise ValueError(f"Failed to decode PEM from data-x/data-s: {exc}") from exc
def rsa_oaep_sha256_encrypt_b64_with_cryptography(pem: str, plaintext: bytes) -> Optional[str]:
try:
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
except Exception:
return None
try:
public_key = serialization.load_pem_public_key(
pem.encode("utf-8"), backend=default_backend()
)
ciphertext = public_key.encrypt(
plaintext,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None,
),
)
return base64.b64encode(ciphertext).decode("ascii")
except Exception as exc:
raise RuntimeError(f"cryptography encryption failed: {exc}") from exc
def rsa_oaep_sha256_encrypt_b64_with_pycryptodome(pem: str, plaintext: bytes) -> Optional[str]:
try:
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Hash import SHA256
except Exception:
return None
try:
key = RSA.import_key(pem)
cipher = PKCS1_OAEP.new(key, hashAlgo=SHA256)
ciphertext = cipher.encrypt(plaintext)
return base64.b64encode(ciphertext).decode("ascii")
except Exception as exc:
raise RuntimeError(f"PyCryptodome encryption failed: {exc}") from exc
def generate_htccheck(pem: str, h_value: str = "1") -> str:
if h_value is None or h_value == "":
h_value = "1"
plaintext = (h_value + "10086").encode("utf-8")
# Try cryptography first
out = rsa_oaep_sha256_encrypt_b64_with_cryptography(pem, plaintext)
if out is not None:
return out
# Fallback to PyCryptodome
out = rsa_oaep_sha256_encrypt_b64_with_pycryptodome(pem, plaintext)
if out is not None:
return out
raise RuntimeError(
"Neither 'cryptography' nor 'PyCryptodome' is available. Please install one of them."
)
def main(argv=None) -> int:
parser = argparse.ArgumentParser(description="Generate htccheck via RSA-OAEP(SHA-256)")
src = parser.add_mutually_exclusive_group(required=True)
src.add_argument("--pem-file", help="Path to PEM public key file")
src.add_argument("--data-x", help="Obfuscated data-x attribute content")
parser.add_argument("--data-s", default="::", help="Separator used in data-x (default '::')")
parser.add_argument("--h", default="1", help="Prefix h (default '1')")
args = parser.parse_args(argv)
if args.pem_file:
with open(args.pem_file, "rb") as f:
pem = f.read().decode("utf-8")
else:
pem = resolve_pem_from_data_attrs(args.data_x, args.data_s)
htccheck = generate_htccheck(pem, args.h)
print(htccheck)
return 0
if __name__ == "__main__":
sys.exit(main())
0x03 总结
感谢秋佬对团队做出的卓越贡献。