记一次js文件AES加密的key与iv逆向分析

最新推荐文章于 2024-05-11 14:40:23 发布
最新推荐文章于 2024-05-11 14:40:23 发布
阅读量2.9k 收藏 4
点赞数
分类专栏： 笔记 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42077227/article/details/125186455
版权

文章目录

前言

最近老同学在搞app的渗透测试，在提交数据的时候，发现抓到的数据包都是经过加密的的。接着反手甩给我两个实现的js文件。“帮忙找一下aes加密的key和iv值”，有活干了，有活干了！

提示：以下是本篇文章正文内容

一、AES算法介绍

aes属于对称加密算法，解密与加密都使用同一密钥，也称为但密钥加密算法
AES（Advanced Encryption Standard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高，支持128、192、256、512位密钥的加密

二、js文件代码

1、util.js文件

代码如下：

var r = require("./aes.js"), t = a;

!function (r, t) {
    for (var e = a, n = s(); ;) try { 
        if (484953 === -parseInt(e(358)) / 1 + -parseInt(e(353)) / 2 * (parseInt(e(357)) / 3) + -parseInt(e(360)) / 4 + -parseInt(e(361)) / 5 + -parseInt(e(355)) / 6 + parseInt(e(349)) / 7 + parseInt(e(356)) / 8) break;
        n.push(n.shift());
    } catch (r) {
        n.push(n.shift());
    }
}();
var e = (r = require(t(350)))[t(352)].Utf8[t(359)](t(354) + t(351)), n = r[t(352)].Utf8.parse(t(354) + t(351));
function a(r, t) {
    var e = s();
    return (a = function (r, t) {
        return e[r -= 349];
    })(r, t);
}

function s() {
    var r = ["060708", "enc", "4gvWuDt", "0102030405", "5378064oDbRIP", "18034816mbibaH", "1362843FfkXtE", "432180CsAsqb", "parse", "456368SYwkrf", "1930445LzbczB", "6775076tiaYah", "./aes.js"];
    return (s = function () {
        return r;
    })();
}

module.exports.Decrypt = function (t) {
    var a = r.enc.Hex.parse(t), s = r.enc.Base64.stringify(a);
    console.log(a);
    console.log(s);
    return r.AES.decrypt(s, e, {
        iv: n,
        mode: r.mode.CBC,
        padding: r.pad.Pkcs7
    }).toString(r.enc.Utf8).toString();
}, module.exports.Encrypt = function (t) {
    var a = r.enc.Utf8.parse(t);
    console.log(a);
    return r.AES.encrypt(a, e, {
        iv: n,
        mode: r.mode.CBC,
        padding: r.pad.Pkcs7
    }).ciphertext.toString().toUpperCase();
};

2、aes.js文件

由于aes.js中代码太长了，这里这放出一部分
代码如下：

var t, e, r = r || function(t, e) {
    var r = {}, i = r.lib = {}, n = function() {}, s = i.Base = {
        extend: function(t) {
            n.prototype = this;
            var e = new n();
            return t && e.mixIn(t), e.hasOwnProperty("init") || (e.init = function() {
                e.$super.init.apply(this, arguments);
            }), e.init.prototype = e, e.$super = this, e;
        },
        create: function() {
            var t = this.extend();
            return t.init.apply(t, arguments), t;
        },
        init: function() {},
        mixIn: function(t) {
            for (var e in t) t.hasOwnProperty(e) && (this[e] = t[e]);
            t.hasOwnProperty("toString") && (this.toString = t.toString);
        },
        clone: function() {
            return this.init.prototype.extend(this);
        }
    }, o = i.WordArray = s.extend({
        init: function(t, e) {
            t = this.words = t || [], this.sigBytes = null != e ? e : 4 * t.length;
        },
        toString: function(t) {
            return (t || a).stringify(this);
        },
        concat: function(t) {
            var e = this.words, r = t.words, i = this.sigBytes;
            if (t = t.sigBytes, this.clamp(), i % 4) for (var n = 0; n < t; n++) e[i + n >>> 2] |= (r[n >>> 2] >>> 24 - n % 4 * 8 & 255) << 24 - (i + n) % 4 * 8; else if (65535 < r.length) for (n = 0; n < t; n += 4) e[i + n >>> 2] = r[n >>> 2]; else e.push.apply(e, r);
            return this.sigBytes += t, this;
        },
        clamp: function() {
            var e = this.words, r = this.sigBytes;
            e[r >>> 2] &= 4294967295 << 32 - r % 4 * 8, e.length = t.ceil(r / 4);
        },
        clone: function() {
            var t = s.clone.call(this);
            return t.words = this.words.slice(0), t;
        },
        random: function(e) {
            for (var r = [], i = 0; i < e; i += 4) r.push(4294967296 * t.random() | 0);
            return new o.init(r, e);
        }
    }), c = r.enc = {}, a = c.Hex = {
        stringify: function(t) {
            var e = t.words;
            t = t.sigBytes;
            for (var r = [], i = 0; i < t; i++) {
                var n = e[i >>> 2] >>> 24 - i % 4 * 8 & 255;
                r.push((n >>> 4).toString(16)), r.push((15 & n).toString(16));
            }
            return r.join("");
        },
        parse: function(t) {
            for (var e = t.length, r = [], i = 0; i < e; i += 2) r[i >>> 3] |= parseInt(t.substr(i, 2), 16) << 24 - i % 8 * 4;
            return new o.init(r, e / 2);
        }
    }, f = c.Latin1 = {
        stringify: function(t) {
            var e = t.words;
            t = t.sigBytes;
            for (var r = [], i = 0; i < t; i++) r.push(String.fromCharCode(e[i >>> 2] >>> 24 - i % 4 * 8 & 255));
            return r.join("");
        },
       
        parse: function(t) {
           
            for (var e = t.length, r = [], i = 0; i < e; i++) r[i >>> 2] |= (255 & t.charCodeAt(i)) << 24 - i % 4 * 8;
            return new o.init(r, e);
        }
    }, h = c.Utf8 = {
        stringify: function(t) {
            try {
                return decodeURIComponent(escape(f.stringify(t)));
            } catch (t) {
                throw Error("Malformed UTF-8 data");
            }
        },.............
        ................
      ...................

三、代码分析

在上面的两个js文件中通过简单的分析后，得出util.js文件主要是进行调用aes加密的，而aes.js文件是实现aes加密的过程。

1.分析加密调用及过程

在分析中，可以看到直接调用中 n 赋值给了iv，也就是aes的偏移参数值。了解过aes加密或者解密的同学们众所周知util.js文中的AES.encrypt(a,e,{…}） 参数e的位置就是密钥参数位置，所以e是密钥。

因此，我第一想到的是能不能在调用aes加密过程中把密钥“e”与“n”直接打印出来，结果如下图所示，出来的是一串列表数组形式的数据值。所以这也不是真正的key与iv值，通过了解应该某种函数解密转换得到的。
在这里插入图片描述

在这里插入图片描述

2. 分析e（key），n（iv）生成的过程

既然是通过某种函数解密转换得到的，那中间肯定会有明文的key与iv值出现过，只需要跟踪到没加密之前的明文就能知道了。

在这里入图片描述分析过程：

1.在util.js文件的16行中对e,n进行了赋值：

var e = (r = require(t(350)))[t(352)].Utf8[t(359)](t(354) + t(351)), n = r[t(352)].Utf8.parse(t(354) + t(351));

2.其中的初始r数组值是：
var r = ["060708", "enc", "4gvWuDt", "0102030405", "5378064oDbRIP", "18034816mbibaH", "1362843FfkXtE", "432180CsAsqb", "parse", "456368SYwkrf", "1930445LzbczB", "6775076tiaYah", "./aes.js"];

3.在开头文件中：var r = require("./aes.js"), t = a;//t=a；而a是一个函数
function a(r, t) {
    var e = s();
    return (a = function (r, t) {
        return e[r -= 349];
    })(r, t);
}
4.在e,n赋值生成之前还执行了这一段代码，调试分析过程发现是对原始数组r进行了多次的重新组合。
最终得到新的组合
//新的组合：r=["6775076tiaYah","./aes.js","060708","enc","4gvWuDt","0102030405","5378064oDbRIP","18034816mbibaH","1362843FfkXtE","432180CsAsqb","parse","456368SYwkrf","1930445LzbczB",]
!function (r, t) {
   
    for (var e = a, n = s(); ;) try { //进行多次循环组合s()的r数组，得到新的组合r =["6775076tiaYah","./aes.js","060708","enc","4gvWuDt","0102030405","5378064oDbRIP","18034816mbibaH","1362843FfkXtE","432180CsAsqb","parse","456368SYwkrf","1930445LzbczB",]
        if (484953 === -parseInt(e(358)) / 1 + -parseInt(e(353)) / 2 * (parseInt(e(357)) / 3) + -parseInt(e(360)) / 4 + -parseInt(e(361)) / 5 + -parseInt(e(355)) / 6 + parseInt(e(349)) / 7 + parseInt(e(356)) / 8) break;
        n.push(n.shift());
    } catch (r) {
        n.push(n.shift());
    }
}();

5.这里赋值得到未加密的e,n值, "0102030405060708" 作为参数值 执行require("./aes.js").enc.Utf8.parse() 函数进行了转换。
所以到这一步很明显了，"0102030405060708" 就是明文key与iv值
//e = (r=require(./aes.js))[enc].Utf8[parse]('0102030405' + '060708'), r=require("./aes.js").enc.Utf8.parse('0102030405060708')
var e = (r = require(t(350)))[t(352)].Utf8[t(359)](t(354) + t(351)), n = r[t(352)].Utf8.parse(t(354) + t(351));

在这里插入图片描述到此结束

总结

在分析过程中，我们可以根据要观察的变量或者值，一步一步的跟随变量生成之前在代码执行中进行了那些操作，便可很快的得到我们想要的信息

隐形卟
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 stm32 AES加密解密
06-22
在本文中，我们将深入探讨如何在STM32微控制器上...总的来说，STM32与C语言实现的AES加密解密工具类为开发安全的嵌入式系统提供了基础。通过理解和应用这些工具，开发者可以为STM32设备构建安全的数据通信和存储功能。
Android AES加密解密
11-10
在本文中，我们将深入探讨Android环境下如何实现AES加密解密，以及如何修改加密过程中的关键参数——密钥（key）和偏移量（initialization vector，简称IV）。 首先，了解AES加密的基本原理：AES是一种块密码，将...
JS爬虫逆向获取AES加密的KEY和IV
gao0035yang的博客
02-18 829
因需要获取一个列表信息，在获取get请求时发现有一个变量是基于时间戳的AES加密校验，于是尝试使用python生成对应字段。# 将 "words" 数组转化为字节序列。# 将字节序列转化为字符串。# 截取实际有效字节数。# 打印还原的字符串。即可获得原始的字符串。
AES加密
re1wn
10-14 6737
AES加密模板脚本
AES加密和解密---KEY需要32位
最新发布
qq_44749121的博客
05-11 200
【代码】AES加密和解密---KEY需要32位。
vue中使用js进行AES加密及解密（含密钥和iv偏移量）、以及HMAC-SHA256加密方法对于签名加密的使用
zhaotian2017的博客
03-23 1万+
一、AES加密解密 1.下载安装 npm install crypto-js --save-dev 2.在utils文件夹下创建encryp.js文件进行aes加密解密工具类方法的封装 import CryptoJS from 'crypto-js'; export default { // 解密 data：要加密解密的数据，AES_KEY：密钥，IV:偏移量 decrypt(data, AES_KEY, IV) { const key = CryptoJS.enc.Utf8
JS AES加密解密实现
qq_43351249的博客
07-07 1994
aes加密解密问题
03、AES加密
重楼的博客
08-20 1579
03、AES加密1、AES介绍2、AES加密模式介绍2.1、ECB模式（电子密码本模式: Electronic codebook）2.2、CBC模式（密码分组链接：Cipher-block chaining）2.3、CTR 模式（计算器模式：Counter）2.4、CFB 模式（密文反馈：Cipher feedback）2.5、OFB 模式（输出反馈：Output feedback）3、AES 加密-iOS 与 Java 的同步实现3.1、密钥长度3.2、加密模式3.3、填充方式3.4、初始向量3.5、iO
从AES源码分析AES对称加密如何生成key
云在青天水在瓶
06-29 748
key 长度为16、24、32个字节，128、192、256个bit, 使用SecureRandom生成随机字节。KeyGenerator 使用了 SecureRandom。也可以 直接使用 SecureRandom 生成 key。只需将 key 进行base64转换。
PHP实现AES加密.doc
01-12
1. **AddRoundKey**：这是每一轮的开始，将当前轮的轮密钥（Round Key）与状态矩阵的每个元素异或。轮密钥由原始密钥通过扩展函数生成。 2. **SubBytes**：状态矩阵中的每个字节通过一个非线性的S盒（S-box）替换，...
Delphi AES，又一个加密算法例子.rar
04-09
1. **初始化向量(IV)**：在AES加密过程中，初始化向量用于确保即使相同的明文在多次加密后也能得到不同的密文，增加了加密的安全性。 2. **密钥生成**：AES支持128位、192位和256位三种密钥长度。开发者需要根据...
AES 加密和解密
12-01
**AES加密解密详解** AES，全称Advanced Encryption Standard，即高级加密标准，是目前广泛应用于数据加密领域的标准算法之一。AES是由NIST（美国国家标准与技术研究院）在2001年正式采纳，取代了之前的DES加密算法...
RSA加密传输AES的key和iv (补2016年11月)
技术黑板
02-01 2万+
项目包含敏感数据，传输过程要求加密，我们研究了两种算法：AES和RSA     传输过程，也就是指前台到后台     AES，对称加密；只有一把密钥，获得密钥，即可解开加密内容     RSA，非对称加密，有两把密钥，公钥和私钥，获得两把钥匙，才可解开加密内容     RSA对需加密的内容长度有限制，前辈们就采取分段加密，但自己并没有解决遇到的问题，技术研究时间有限，最终项
Python 实现 AES 加密/解密
热门推荐
Herishwater的博客
06-15 4万+
一、前言 AES，高级加密标准（Advanced Encryption Standard）。是用来替代 DES，目前比较流行的对称加密算法。与上一篇博文提到过的 RSA 非对称算法不同，对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下图： 明文 P：等待加密的数据。 密钥 K：用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的。密钥为接收方与发送方协商产生，但不可以直接在......
JS 实现AES方式加密数据实现示例
非专业程序员小田
03-05 1435
Javascript CryptoJS AES 实现示例
AES加密,CBC模式,使用向量iv,工具类
Wy_Vae的博客
10-23 7203
适用于参数前后端加减密，提高安全性。 import cn.hutool.core.codec.Base64; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; /** * @Description: AES单元类 提供A...
逆向系列 | AES逆向加密案例分析
weixin_42577686的博客
12-28 3331
AES加密详解 简介：全称高级加密标准（英文名称：Advanced Encryption Standard），在密码学中又称 Rijndael 加密法，由美国国家标准与技术研究院 （NIST）于 2001 年发布，并在 2002 年成为有效的标准，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的 DES，已经被多方分析且广为全世界所使用，它本身只有一个密钥，即用来实现加密，也用于解密。 mode支持 CBC，CFB，CTR，CTRGladman，ECB，OFB 等。 padding支持 Zero
生成一套aes加密的 key和iv
05-19
好的，以下是生成 AES 加密的 key 和 iv 的 Python 代码示例： ```python import os from Crypto.Cipher import AES # 生成一个16字节的随机 key key = os.urandom(16) # 生成一个16字节的随机 iv iv = os.urandom(16) print("key: ", key) print("iv: ", iv) ``` 运行代码后，会输出一个随机生成的 16 字节的 key 和 iv，如下所示： ``` key: b'\xcd\x89\x8f\x9d\xa2\xdb\x8c\x8d\x9a\x98\xb0\xd2\x3d\x11C\x9e' iv: b'Z\x1dC\x95\xe9o\xcc\xd7\xd6\x0b\xfd\xf9<\x1b\x92\x8a' ``` 注意，这里使用了 PyCryptodome 库中的 Crypto.Cipher.AES 类来生成加密所需的 key 和 iv。如果你的机器没有安装这个库，可以使用 pip 安装： ``` pip install pycryptodomex ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值