Node.js与crypto-js实战：逆向分析前端密码加密逻辑

1. 项目概述与目标

最近在分析一个网站的前端登录逻辑时，发现它的密码在提交前被加密成了一串看不懂的密文。作为一名开发者，我本能地想知道这背后是怎么实现的，是简单的哈希，还是复杂的加密？为了搞清楚这个问题，我决定在 Windows 11 环境下，从零开始搭建一个 Node.js 环境，并利用

crypto-js

这个库来模拟和逆向分析这个加密过程。这不仅仅是一个技术探索，更是理解现代 Web 应用安全机制的一个绝佳实践。通过这个项目，你将学会如何在 Windows 11 上配置 Node.js，如何使用

crypto-js

进行常见的加密操作，并最终掌握一套逆向分析前端加密逻辑的通用方法。无论你是前端开发者想深入了解安全，还是对 Web 逆向感兴趣，这篇实战指南都能给你提供清晰的路径和可复现的代码。

2. Windows 11 上的 Node.js 环境搭建

2.1 为什么选择 Node.js 和 crypto-js？

在开始动手之前，我们先明确一下工具选型。Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行时，它让我们能够在服务器端（或者本地开发环境）运行 JavaScript。选择它来分析前端加密有两大优势：一是语言一致，前端是 JavaScript，我们用 Node.js 模拟，语法和核心 API（如

Buffer

）高度统一，降低了学习成本；二是生态丰富，

npm

上有海量的库，其中

crypto-js

是一个纯 JavaScript 实现的加密算法库，支持 AES、DES、SHA256、HMAC 等多种标准算法，完美契合我们分析前端加密的需求。

至于操作系统，Windows 11 是目前个人电脑的主流系统，其内置的 PowerShell 终端和 WSL（Windows Subsystem for Linux）支持，使得开发环境配置非常灵活。我们这次就使用原生的 PowerShell 进行所有操作，确保流程对广大 Windows 用户友好。

2.2 安装 Node.js 与 npm

Node.js 的安装过程在 Windows 上已经非常傻瓜化。我强烈建议从官网（nodejs.org）下载 LTS（长期支持）版本的安装程序。为什么是 LTS？因为它更稳定，兼容性更好，适合开发和逆向分析这种对环境一致性要求高的场景。下载完成后，双击安装程序，基本上一路“Next”即可。这里有个关键点需要注意：安装向导会询问是否将 Node.js 和 npm 添加到系统 PATH 环境变量，务必勾选上。这能让你在任意位置的 PowerShell 中直接使用

node

和

npm

命令。

安装完成后，我们需要验证一下。打开 PowerShell（可以在开始菜单搜索“PowerShell”并以管理员或普通用户身份运行），输入以下命令：

node –version
npm –version

如果正确显示了版本号（例如

v18.20.0

和

10.7.0

），恭喜你，第一步已经成功。如果提示“不是内部或外部命令”，说明环境变量可能未生效，可以尝试重启 PowerShell 或者手动检查系统环境变量 PATH 中是否包含了 Node.js 的安装路径（通常类似

C:\\Program Files\\nodejs\\

）。

注意：有些公司的电脑或旧系统可能设置了严格的执行策略，导致脚本无法运行。如果你在后续使用

npm install

时遇到权限错误，可以尝试以管理员身份运行 PowerShell，并执行

Set-ExecutionPolicy RemoteSigned

来更改执行策略（选择

[A] 全是

），操作完成后记得改回默认值以保安全。

2.3 初始化项目与安装 crypto-js

环境准备好后，我们创建一个专门的项目目录来操作。在 PowerShell 中，导航到你常用的工作目录，例如

D:\\Projects

，然后执行：

mkdir password-crypto-analysis && cd password-crypto-analysis
npm init -y

npm init -y

命令会快速创建一个默认的

package.json

文件，其中包含了项目的基本信息和依赖管理配置。

-y

参数表示接受所有默认选项，省去交互式问答。

接下来，安装我们本次实战的核心库

crypto-js

：

npm install crypto-js

这个命令会从 npm 仓库下载

crypto-js

库及其依赖，并保存在项目下的

node_modules

文件夹中，同时在

package.json

的

dependencies

字段里记录这个依赖。安装过程通常很快，网络通畅的话几秒钟就能完成。

为了更方便地编写和测试我们的分析脚本，我建议再安装一个辅助工具

nodemon

。它可以监视文件变化并自动重启 Node.js 应用，在开发调试时非常省心。使用

–save-dev

参数将其安装为开发依赖：

npm install –save-dev nodemon

安装完成后，你的

package.json

文件应该类似于这样：

{
"name": "password-crypto-analysis",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \\"Error: no test specified\\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"crypto-js": "^4.2.0"
},
"devDependencies": {
"nodemon": "^3.1.0"
}
}

现在，基础环境已经就绪。我们创建两个核心文件：

analyze.js

用于编写主要的逆向分析逻辑，

test.html

作为一个简单的模拟前端页面，用来生成加密后的密码供我们分析。在项目根目录下执行：

New-Item -Path . -Name "analyze.js" -ItemType "file"
New-Item -Path . -Name "test.html" -ItemType "file"

或者直接用你喜欢的代码编辑器（如 VSCode）在项目中新建这两个文件。至此，一个干净、专注的 Node.js 分析环境就在你的 Windows 11 上搭建完成了。

3. 前端密码加密常见模式与 crypto-js 基础

在动手逆向之前，我们必须先了解“敌人”可能使用的武器。现代 Web 前端对密码的加密（更准确地说，是哈希或编码）通常不是为了实现高强度的机密性（那是 HTTPS 和后端加密该做的事），而是为了增加攻击者直接获取明文密码的难度，或者满足后端特定的验证格式。常见的模式有以下几种，而

crypto-js

库都能很好地支持对这些模式的模拟和验证。

3.1 哈希（Hash）算法：单向不可逆

哈希是前端处理密码最常见的方式。它将任意长度的输入（密码）通过一个数学函数（哈希算法）转换成固定长度的字符串（哈希值）。核心特性是

单向性

：从哈希值几乎无法反推出原始密码。常用的算法有：

• MD5

  : 产生 128 位（32位十六进制字符）哈希值。

  已不安全

  ，因其碰撞漏洞已被广泛证实，但一些老旧系统可能仍在用。

• SHA-1

  : 产生 160 位（40位十六进制字符）哈希值。安全性也已受到威胁，逐渐被淘汰。

• SHA-256

  : SHA-2 家族的一员，产生 256 位（64位十六进制字符）哈希值。目前是行业标准，广泛应用于密码存储和数字签名。

• SHA-512

  : 更长的 512 位哈希，更安全但计算量稍大。

使用

crypto-js

计算哈希非常简单。我们在

analyze.js

中写一段测试代码：

// analyze.js
const CryptoJS = require("crypto-js");

const password = "MySecretPassword123";

// 计算不同算法的哈希
const md5Hash = CryptoJS.MD5(password).toString();
const sha1Hash = CryptoJS.SHA1(password).toString();
const sha256Hash = CryptoJS.SDHA256(password).toString(); // 注意：正确的属性名是 SHA256
const sha512Hash = CryptoJS.SHA512(password).toString();

console.log("MD5:", md5Hash);
console.log("SHA1:", sha1Hash);
console.log("SHA256:", sha256Hash);
console.log("SHA512:", sha512Hash);

运行

node analyze.js

，你会看到四串不同的十六进制输出。一个关键细节是，单纯的哈希很容易受到

彩虹表攻击

（预先计算好的哈希字典）。因此，实战中通常会加“盐”（Salt）。

3.2 HMAC：基于密钥的哈希消息认证码

HMAC 可以看作是一种“带密钥的哈希”。它需要一个密钥（Secret Key）和消息（密码）一起计算哈希。即使相同的密码，使用不同的密钥也会产生完全不同的 HMAC 值，安全性更高。后端通常会提供一个动态或固定的密钥给前端用于计算 HMAC。

const secretKey = "aFixedSecretFromBackend";
const hmacSha256 = CryptoJS.HmacSHA256(password, secretKey).toString();
console.log("HMAC-SHA256:", hmacSha256);

3.3 AES 对称加密：可逆的加密

AES（高级加密标准）是一种对称加密算法，意味着加密和解密使用同一个密钥。前端有时会用 AES 加密密码后再传输，但这要求密钥在前端代码中，

本质上是不安全的

（因为前端代码对用户是透明的），只能起到增加逆向难度或编码转换的作用。

crypto-js

支持 AES 加密，并通常需要指定模式（如 CBC）和填充方式（如 Pkcs7）。

const aesKey = CryptoJS.enc.Utf8.parse("1234567890123456"); // 密钥必须是16/24/32字节
const iv = CryptoJS.enc.Utf8.parse("1234567890123456"); // 初始化向量，通常16字节

const encrypted = CryptoJS.AES.encrypt(password, aesKey, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7,
}).toString();

console.log("AES Encrypted (Base64):", encrypted);

// 解密验证
const decrypted = CryptoJS.AES.decrypt(encrypted, aesKey, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7,
}).toString(CryptoJS.enc.Utf8);

console.log("AES Decrypted:", decrypted); // 应该输出 MySecretPassword123

3.4 Base64 编码：不是加密

Base64 是一种编码方式，将二进制数据转换成由 64 个字符（A-Z, a-z, 0-9, +, /）组成的字符串。它常被用来“伪装”数据，使其在纯文本环境（如 HTTP 请求）中安全传输。

Base64 不是加密

，因为它没有密钥，任何人都可以轻松解码。前端可能先对密码进行哈希或加密，再将结果进行 Base64 编码后传输。

const wordArray = CryptoJS.enc.Utf8.parse(password);
const base64Encoded = CryptoJS.enc.Base64.stringify(wordArray);
console.log("Base64 Encoded:", base64Encoded); // TXlTZWNyZXRQYXNzd29yZDEyMw==

const decoded = CryptoJS.enc.Base64.parse(base64Encoded).toString(CryptoJS.enc.Utf8);
console.log("Base64 Decoded:", decoded);

掌握了这些基础模式，我们就有了逆向分析的“武器库”。在实际网站中，加密逻辑往往是这些基础模式的组合，比如

SHA256(密码 + 固定盐)

、

HMAC-SHA256(密码, 动态令牌)

，或者

Base64(AES_ECB(密码))

。我们的任务就是通过观察网络请求和前端代码，找出它具体使用了哪种或哪几种组合。

4. 逆向分析实战：定位与模拟加密逻辑

理论准备就绪，现在进入实战环节。我们的目标是：给定一个目标网站，找出其登录时密码字段的加密方式，并用 Node.js + crypto-js 复现这一过程。这个过程就像侦探破案，需要细心观察和逻辑推理。

4.1 第一步：捕获网络请求，观察加密特征

打开你浏览器的开发者工具（F12），切换到“网络”（Network）选项卡。清空现有记录，然后在目标网站的登录框输入一个测试密码（比如

test123

），点击登录。在网络请求列表中找到登录请求（通常是

POST

类型，URL 可能包含

login

、

signin

等关键词）。

点击这个请求，查看其“载荷”（Payload）或“请求体”（Request Body）。你会看到提交的数据，重点关注

password

、

pwd

、

encryptedPassword

这类字段。它的值很可能是一长串看似随机的字符。记录下这个值，这是我们分析的起点。

观察要点：

4.2 第二步：审查前端 JavaScript 源码

加密逻辑一定在前端的 JavaScript 代码中执行。在开发者工具的“源代码”（Sources）选项卡中，搜索与密码字段或加密相关的关键词。你可以使用全局搜索（Ctrl+Shift+F），搜索词可以尝试：

• 密码字段的

  id

  或

  name

  ，如

  #password

  、

  input[name='password']

• 加密函数名，如

  encrypt

  、

  hash

  、

  CryptoJS

  、

  SHA

  、

  HMAC

  、

  AES

• 提交表单时触发的事件，如

  onsubmit

  、

  $.ajax

  、

  fetch

  、

  axios.post

找到疑似加密的代码段后，仔细阅读。现代网站可能会对 JavaScript 进行压缩和混淆，变量名可能是单个字母，增加了解读难度。这时需要耐心，关注函数调用和字符串常量。如果看到了

CryptoJS

这个对象，那几乎可以确定使用了我们正在研究的这个库。

4.3 第三步：构建模拟加密函数

假设我们通过分析，推测出目标网站的加密逻辑是：

password = Base64(SHA256(明文密码 + 固定盐值))

。其中盐值

salt

在代码中硬编码为

"my_fixed_salt"

。

我们现在在

analyze.js

中编写复现函数：

// analyze.js – 模拟加密函数
function simulateWebsiteEncrypt(plainPassword) {
const salt = "my_fixed_salt";
// 1. 密码与盐拼接
const dataToHash = plainPassword + salt;
// 2. 计算 SHA256 哈希
const hashDigest = CryptoJS.SHA256(dataToHash);
// 3. 将哈希结果转换为 Base64 字符串
const base64Output = CryptoJS.enc.Base64.stringify(hashDigest);
return base64Output;
}

// 测试我们的模拟函数
const testPassword = "test123";
const simulatedOutput = simulateWebsiteEncrypt(testPassword);
console.log(`模拟加密输出: ${simulatedOutput}`);

运行这个脚本，得到输出结果。然后，回到浏览器，用同样的密码

test123

再次尝试登录（或使用开发者工具的重放请求功能），捕获到的加密密码值应该与我们模拟输出的结果

完全一致

。如果一致，恭喜你，成功破译！如果不一致，说明我们的推测有误，需要回到第二步，重新审查代码，看看是否漏掉了某些步骤，比如：

• 密码是否先进行了 UTF-8 或 Unicode 转换？
• 盐的拼接顺序是

  salt + password

  还是

  password + salt

  ？

• 哈希结果是否被转换成了十六进制（

  toString()

  ）而不是 Base64？

• 是否进行了多轮哈希？
• 是否使用了 HMAC 而不是简单哈希？

4.4 第四步：处理动态参数与复杂逻辑

很多网站的加密逻辑不会这么简单。它们可能会引入动态参数，比如从服务器获取一个临时的

token

或

nonce

，将其作为盐或密钥的一部分。这时，你需要分析这个动态参数是如何获取的（可能来自上一个 API 响应或一个隐藏的 HTML 字段），并在你的 Node.js 脚本中模拟这一获取过程。

另一种复杂情况是，加密逻辑被封装在一个庞大的、混淆过的 JavaScript 文件里，直接解读非常困难。这时可以尝试一种“黑盒”方法：在浏览器控制台中，直接调用你找到的加密函数。首先，在源代码中找到加密函数的入口，比如

window.encryptPassword

。然后在控制台输入：

// 在浏览器控制台执行
var encrypted = window.encryptPassword("test123");
console.log(encrypted);

如果能够成功输出，并且输出值与网络请求中的一致，那么你可以直接“借用”这个函数。更进阶的做法是，使用

puppeteer

或

playwright

这类无头浏览器库，在 Node.js 环境中自动化执行这段前端代码来获取加密结果，这适用于加密逻辑极度复杂或严重混淆的情况。

5. 编写健壮的分析脚本与调试技巧

当我们初步确定了加密算法后，需要编写一个健壮的、可配置的 Node.js 脚本来固化我们的分析成果。这个脚本应该能够灵活地处理不同的加密参数，并方便地进行测试和调试。

5.1 创建可配置的加密模块

我们将加密逻辑抽象成一个模块，将可变的部分（如盐值、密钥、算法类型）作为配置项。在项目根目录创建

encryptor.js

：

// encryptor.js
const CryptoJS = require("crypto-js");

class PasswordEncryptor {
constructor(config = {}) {
this.algorithm = config.algorithm || 'SHA256'; // 算法类型
this.salt = config.salt || ''; // 静态盐
this.secretKey = config.secretKey || ''; // HMAC密钥或AES密钥
this.iv = config.iv || ''; // AES初始化向量
this.outputEncoding = config.outputEncoding || 'Base64'; // 输出编码：Hex, Base64
this.useHmac = config.useHmac || false;
this.useAES = config.useAES || false;
this.aesMode = config.aesMode || CryptoJS.mode.CBC;
this.aesPadding = config.aesPadding || CryptoJS.pad.Pkcs7;
}

encrypt(plainText, dynamicSalt = '') {
let processedData = plainText;
let output;

// 1. 处理盐值拼接
const finalSalt = this.salt + dynamicSalt; // 假设是后缀盐
if (finalSalt) {
processedData = processedData + finalSalt;
}

// 2. 核心加密/哈希
if (this.useAES && this.secretKey) {
const key = CryptoJS.enc.Utf8.parse(this.secretKey);
const iv = this.iv ? CryptoJS.enc.Utf8.parse(this.iv) : undefined;
const encryptedObj = CryptoJS.AES.encrypt(processedData, key, {
iv: iv,
mode: this.aesMode,
padding: this.aesPadding,
});
output = encryptedObj.ciphertext; // 获取CipherParams对象中的密文WordArray
} else if (this.useHmac && this.secretKey) {
output = CryptoJS.HmacSHA256(processedData, this.secretKey);
} else {
// 使用指定的哈希算法
switch (this.algorithm.toUpperCase()) {
case 'MD5':
output = CryptoJS.MD5(processedData);
break;
case 'SHA1':
output = CryptoJS.SHA1(processedData);
break;
case 'SHA256':
default:
output = CryptoJS.SHA256(processedData);
break;
case 'SHA512':
output = CryptoJS.SHA512(processedData);
break;
}
}

// 3. 输出编码转换
if (this.outputEncoding.toUpperCase() === 'HEX') {
return output.toString(CryptoJS.enc.Hex);
} else if (this.outputEncoding.toUpperCase() === 'BASE64') {
// 注意：对于AES加密，CryptoJS默认返回的就是Base64格式的字符串
if (this.useAES) {
return output.toString();
} else {
return CryptoJS.enc.Base64.stringify(output);
}
} else {
return output.toString(); // 默认返回十六进制
}
}
}

module.exports = PasswordEncryptor;

5.2 编写测试用例与调试

创建

test.js

来系统性地测试我们的加密模块，并与从目标网站捕获的真实数据进行比对：

// test.js
const PasswordEncryptor = require('./encryptor.js');

// 场景1：模拟简单的 SHA256 + 盐 + Base64
console.log('=== 场景1: SHA256 + Salt + Base64 ===');
const config1 = {
algorithm: 'SHA256',
salt: 'my_fixed_salt',
outputEncoding: 'Base64'
};
const encryptor1 = new PasswordEncryptor(config1);
const testPwd = 'test123';
const result1 = encryptor1.encrypt(testPwd);
console.log(`输入: ${testPwd}`);
console.log(`输出: ${result1}`);
console.log(`预期（需替换为实际抓包值）: YzI0OG…（此处填写你抓包得到的值）`);
console.log(`匹配: ${result1 === 'YzI0OG…' ? '是' : '否'}`); // 手动替换预期值

// 场景2：模拟 HMAC-SHA256
console.log('\\n=== 场景2: HMAC-SHA256 (Hex输出) ===');
const config2 = {
useHmac: true,
secretKey: 'dynamic_key_from_server',
outputEncoding: 'Hex'
};
const encryptor2 = new PasswordEncryptor(config2);
const result2 = encryptor2.encrypt(testPwd);
console.log(`HMAC输出: ${result2}`);

// 场景3：模拟 AES-CBC 加密
console.log('\\n=== 场景3: AES-CBC 加密 ===');
const config3 = {
useAES: true,
secretKey: '1234567890123456', // 16字节
iv: '1234567890123456', // 16字节
aesMode: CryptoJS.mode.CBC,
aesPadding: CryptoJS.pad.Pkcs7
};
const encryptor3 = new PasswordEncryptor(config3);
const result3 = encryptor3.encrypt(testPwd);
console.log(`AES加密输出(Base64): ${result3}`);

// 动态盐测试
console.log('\\n=== 动态盐测试 ===');
const encryptorDynamic = new PasswordEncryptor({ algorithm: 'SHA256', outputEncoding: 'Hex' });
const dynamicSalt = Date.now().toString(); // 模拟一个时间戳盐
const resultDynamic = encryptorDynamic.encrypt(testPwd, dynamicSalt);
console.log(`动态盐: ${dynamicSalt}`);
console.log(`输出: ${resultDynamic}`);

通过运行

node test.js

，我们可以快速验证不同配置下的输出，并与抓包数据对比。

调试的核心在于比对

：让你的脚本输出与浏览器实际发送的数据一模一样。

实操心得：在比对时，务必注意字符的大小写和编码格式。有些网站传输的十六进制可能是大写，而

crypto-js

默认输出小写，这时需要用

.toUpperCase()

转换。Base64 字符串也可能存在 URL 安全变种（将

+

和

/

替换为

–

和

_

），需要使用

CryptoJS.enc.Base64.parse

后再做比较，或者进行字符串替换。

5.3 使用 Nodemon 进行热重载调试

在开发过程中，频繁修改代码并重启 node 进程很麻烦。我们可以利用之前安装的

nodemon

。修改

package.json

中的

scripts

部分：

"scripts": {
"dev": "nodemon test.js",
"analyze": "node analyze.js"
}

然后，在终端运行

npm run dev

。

nodemon

会监视

test.js

及其依赖文件的变化，一旦你保存修改，它会自动重启应用，让你能立刻看到新代码的输出效果，极大提升调试效率。

6. 常见问题排查与安全思考

在逆向分析和模拟加密的过程中，你几乎一定会遇到各种问题导致输出对不上。这里我总结了一份常见问题排查清单，以及一些重要的安全启示。

6.1 加密结果不一致的排查清单

当你模拟的加密结果与网站实际发送的值不匹配时，请按照以下顺序检查：

可能原因

验证方法

6.2 逆向分析中的安全与法律边界

在进行此类技术探索时，必须时刻牢记安全与法律的边界：

6.3 从分析到防御：给开发者的建议

作为开发者，从攻击者（分析者）的角度审视自己的系统，能更好地构建防御：

• 避免在前端使用硬编码的对称加密密钥

  ：这形同虚设。

• 如果必须前端加密，使用非对称加密

  ：后端生成公钥，前端用公钥加密，后端用私钥解密。这样即使加密逻辑暴露，攻击者没有私钥也无法解密。

• 强化哈希过程

  ：后端存储密码时，务必使用强哈希算法（如 Argon2、bcrypt、PBKDF2），并为每个用户使用独立、随机的盐。

• 启用并正确配置 HTTPS

  ：这是保护传输过程中数据安全的基石。

• 考虑使用 Web Crypto API

  ：这是一个浏览器原生支持的加密 API，比引入第三方库可能更高效，但同样无法隐藏逻辑。

通过这个从环境搭建到逆向实战的完整流程，你不仅掌握了

crypto-js

在 Node.js 中的用法，更重要的是获得了一套分析前端加密行为的通用方法论。下次再遇到神秘的登录加密，你就能有条不紊地揭开它的面纱了。记住，工具和技巧是中立的，如何使用它们，取决于你的意图和所遵守的规则。