JS逆向案例,破解加密JSON字符串数据!真的强!

[Unity][存档][JSONUnity]加密数据 在场景中的实体保存固定的数据, 对字符串数据进行加密(D加密都能够被破解,何况短短32位的密钥加密) 在场景中的实体保存固定的数据 根据相关资料1,2 SaveData.json存储的字符串显示为 {"Items":[{"jsonCubes":[{"m_FileID":894,"m_PathID":0},{"m_FileID":890,"m_PathID":0}... 阅读详情

之前,我们介绍了两种基础的JS逆向案例。今天,就继续来分享一个稍微复杂的JS逆向案例吧~

爬取网址:企业科技,本次爬取仅供学习,无任何商业用途

一、寻找加密源码

进入网站后,利用Chrome浏览器进行抓包,结果如下

 

从上图可知,我们需要的数据encypt_data被加密成一长串字符。按照JS逆向的一般套路,首先,我们来搜索一下encypt_data参数,基本步骤如下

通过比对搜索出的6个encypt_data参数,最终定位到10790行的encypt_data,在此数打下断点,刷新页面,结果如下

依步调试代码,最终定位在11087行

 

不难看出,参数t就是之前我们看到的加密后字符串encypt_data!分析o函数可知:它将encypt_data参数传给s函数,然后利用json解析其返回值即可实现解密!(JSON.parse是javascript中解析json字符串的方法,后续就无需复制此处,因为我们可以利用Python复写)

由于上述s函数与a.a.decode函数均未定义,因此我们对其进行补充,将鼠标放置s上即可进行跳转。最终复制的JS代码如下,并将其另存为tech.js(这里我将a.a.decode函数重命名为mydecode函数)

function o(t) {
	//注意此处没有JSON.parse,并且将a.a.decode改为mydecode
    return  s("5e5062e82f15fe4ca9d24bc5", mydecode(t), 0, 0, "012345677890123", 1)  
}

function s(t, e, i, n, a, s) {
    var o, r, c, l, u, d, h, p, f, v, m, g, b, y, C = new Array(16843776,0,65536,16843780,16842756,66564,4,65536,1024,16843776,16843780,1024,16778244,16842756,16777216,4,1028,16778240,16778240,66560,66560,16842752,16842752,16778244,65540,16777220,16777220,65540,0,1028,66564,16777216,65536,16843780,4,16842752,16843776,16777216,16777216,1024,16842756,65536,66560,16777220,1024,4,16778244,66564,16843780,65540,16842752,16778244,16777220,1028,66564,16843776,1028,16778240,16778240,0,65540,66560,0,16842756), _ = new Array(-2146402272,-2147450880,32768,1081376,1048576,32,-2146435040,-2147450848,-2147483616,-2146402272,-2146402304,-2147483648,-2147450880,1048576,32,-2146435040,1081344,1048608,-2147450848,0,-2147483648,32768,1081376,-2146435072,1048608,-2147483616,0,1081344,32800,-2146402304,-2146435072,32800,0,1081376,-2146435040,1048576,-2147450848,-2146435072,-2146402304,32768,-2146435072,-2147450880,32,-2146402272,1081376,32,32768,-2147483648,32800,-2146402304,1048576,-2147483616,1048608,-2147450848,-2147483616,1048608,1081344,0,-2147450880,32800,-2147483648,-2146435040,-2146402272,1081344), w = new Array(520,134349312,0,134348808,134218240,0,131592,134218240,131080,134217736,134217736,131072,134349320,131080,134348800,520,134217728,8,134349312,512,131584,134348800,134348808,131592,134218248,131584,131072,134218248,8,134349320,512,134217728,134349312,134217728,131080,520,131072,134349312,134218240,0,512,131080,134349320,134218240,134217736,512,0,134348808,134218248,131072,134217728,134349320,8,131592,131584,134217736,134348800,134218248,520,134348800,131592,8,134348808,131584), x = new Array(8396801,8321,8321,128,8396928,8388737,8388609,8193,0,8396800,8396800,8396929,129,0,8388736,8388609,1,8192,8388608,8396801,128,8388608,8193,8320,8388737,1,8320,8388736,8192,8396928,8396929,129,8388736,8388609,8396800,8396929,129,0,0,8396800,8320,8388736,8388737,1,8396801,8321,8321,128,8396929,129,1,8192,8388609,8193,8396928,8388737,8193,8320,8388608,8396801,128,8388608,8192,8396928), k = new Array(256,34078976,34078720,1107296512,524288,256,1073741824,34078720,1074266368,524288,33554688,1074266368,1107296512,1107820544,524544,1073741824,33554432,1074266112,1074266112,0,1073742080,1107820800,1107820800,33554688,1107820544,1073742080,0,1107296256,34078976,33554432,1107296256,524544,524288,1107296512,256,33554432,1073741824,34078720,1107296512,1074266368,33554688,1073741824,1107820544,34078976,1074266368,256,33554432,1107820544,1107820800,524544,1107296256,1107820800,34078720,0,1074266112,1107296256,524544,33554688,1073742080,524288,0,1074266112,34078976,1073742080), A = new Array(536870928,541065216,16384,541081616,541065216,16,541081616,4194304,536887296,4210704,4194304,536870928,4194320,536887296,536870912,16400,0,4194320,536887312,16384,4210688,536887312,16,541065232,541065232,0,4210704,541081600,16400,4210688,541081600,536870912,536887296,16,541065232,4210688,541081616,4194304,16400,536870928,4194304,536887296,536870912,16400,536870928,541081616,4210688,541065216,4210704,541081600,0,541065232,16,16384,541065216,4210704,16384,4194320,536887312,0,541081600,536870912,4194320,536887312), T = new Array(2097152,69206018,67110914,0,2048,67110914,2099202,69208064,69208066,2097152,0,67108866,2,67108864,69206018,2050,67110912,2099202,2097154,67110912,67108866,69206016,69208064,2097154,69206016,2048,2050,69208066,2099200,2,67108864,2099200,67108864,2099200,2097152,67110914,67110914,69206018,69206018,2,2097154,67108864,67110912,2097152,69208064,2050,2099202,69208064,2050,67108866,69208066,69206016,2099200,0,2,69208066,0,2099202,69206016,2048,67108866,67110912,2048,2097154), L = new Array(268439616,4096,262144,268701760,268435456,268439616,64,268435456,262208,268697600,268701760,266240,268701696,266304,4096,64,268697600,268435520,268439552,4160,266240,262208,268697664,268701696,4160,0,0,268697664,268435520,268439552,266304,262144,266304,262144,268701696,4096,64,268697664,4096,266304,268439552,64,268435520,268697600,268697664,268435456,262144,268439616,0,268701760,262208,268435520,268697600,268439552,268439616,0,268701760,266240,266240,4160,4160,262208,268435456,268701696), S = function(t) {
        for (var e, i, n, a = new Array(0,4,536870912,536870916,65536,65540,536936448,536936452,512,516,536871424,536871428,66048,66052,536936960,536936964), s = new Array(0,1,1048576,1048577,67108864,67108865,68157440,68157441,256,257,1048832,1048833,67109120,67109121,68157696,68157697), o = new Array(0,8,2048,2056,16777216,16777224,16779264,16779272,0,8,2048,2056,16777216,16777224,16779264,16779272), r = new Array(0,2097152,134217728,136314880,8192,2105344,134225920,136323072,131072,2228224,134348800,136445952,139264,2236416,134356992,136454144), c = new Array(0,262144,16,262160,0,262144,16,262160,4096,266240,4112,266256,4096,266240,4112,266256), l = new Array(0,1024,32,1056,0,1024,32,1056,33554432,33555456,33554464,33555488,33554432,33555456,33554464,33555488), u = new Array(0,268435456,524288,268959744,2,268435458,524290,268959746,0,268435456,524288,268959744,2,268435458,524290,268959746), d = new Array(0,65536,2048,67584,536870912,536936448,536872960,536938496,131072,196608,133120,198656,537001984,537067520,537004032,537069568), h = new Array(0,262144,0,262144,2,262146,2,262146,33554432,33816576,33554432,33816576,33554434,33816578,33554434,33816578), p = new Array(0,268435456,8,268435464,0,268435456,8,268435464,1024,268436480,1032,268436488,1024,268436480,1032,268436488), f = new Array(0,32,0,32,1048576,1048608,1048576,1048608,8192,8224,8192,8224,1056768,1056800,1056768,1056800), v = new Array(0,16777216,512,16777728,2097152,18874368,2097664,18874880,67108864,83886080,67109376,83886592,69206016,85983232,69206528,85983744), m = new Array(0,4096,134217728,134221824,524288,528384,134742016,134746112,16,4112,134217744,134221840,524304,528400,134742032,134746128), g = new Array(0,4,256,260,0,4,256,260,1,5,257,261,1,5,257,261), b = t.length > 8 ? 3 : 1, y = new Array(32 * b), C = new Array(0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0), _ = 0, w = 0, x = 0; x < b; x++) {
            var k = t.charCodeAt(_++) << 24 | t.charCodeAt(_++) << 16 | t.charCodeAt(_++) << 8 | t.charCodeAt(_++)
              , A = t.charCodeAt(_++) << 24 | t.charCodeAt(_++) << 16 | t.charCodeAt(_++) << 8 | t.charCodeAt(_++);
            k ^= (n = 252645135 & (k >>> 4 ^ A)) << 4,
            k ^= n = 65535 & ((A ^= n) >>> -16 ^ k),
            k ^= (n = 858993459 & (k >>> 2 ^ (A ^= n << -16))) << 2,
            k ^= n = 65535 & ((A ^= n) >>> -16 ^ k),
            k ^= (n = 1431655765 & (k >>> 1 ^ (A ^= n << -16))) << 1,
            k ^= n = 16711935 & ((A ^= n) >>> 8 ^ k),
            n = (k ^= (n = 1431655765 & (k >>> 1 ^ (A ^= n << 8))) << 1) << 8 | (A ^= n) >>> 20 & 240,
            k = A << 24 | A << 8 & 16711680 | A >>> 8 & 65280 | A >>> 24 & 240,
            A = n;
            for (var T = 0; T < C.length; T++)
                C[T] ? (k = k << 2 | k >>> 26,
                A = A << 2 | A >>> 26) : (k = k << 1 | k >>> 27,
                A = A << 1 | A >>> 27),
                A &= -15,
                e = a[(k &= -15) >>> 28] | s[k >>> 24 & 15] | o[k >>> 20 & 15] | r[k >>> 16 & 15] | c[k >>> 12 & 15] | l[k >>> 8 & 15] | u[k >>> 4 & 15],
                i = d[A >>> 28] | h[A >>> 24 & 15] | p[A >>> 20 & 15] | f[A >>> 16 & 15] | v[A >>> 12 & 15] | m[A >>> 8 & 15] | g[A >>> 4 & 15],
                n = 65535 & (i >>> 16 ^ e),
                y[w++] = e ^ n,
                y[w++] = i ^ n << 16
        }
        return y
    }(t), F = 0, I = e.length, B = 0, j = 32 == S.length ? 3 : 9;
    p = 3 == j ? i ? new Array(0,32,2) : new Array(30,-2,-2) : i ? new Array(0,32,2,62,30,-2,64,96,2) : new Array(94,62,-2,32,64,2,30,-2,-2),
    2 == s ? e += "        " : 1 == s ? i && (c = 8 - I % 8,
    e += String.fromCharCode(c, c, c, c, c, c, c, c),
    8 === c && (I += 8)) : s || (e += "\0\0\0\0\0\0\0\0");
    var z = ""
      , O = "";
    for (1 == n && (f = a.charCodeAt(F++) << 24 | a.charCodeAt(F++) << 16 | a.charCodeAt(F++) << 8 | a.charCodeAt(F++),
    m = a.charCodeAt(F++) << 24 | a.charCodeAt(F++) << 16 | a.charCodeAt(F++) << 8 | a.charCodeAt(F++),
    F = 0); F < I; ) {
        for (d = e.charCodeAt(F++) << 24 | e.charCodeAt(F++) << 16 | e.charCodeAt(F++) << 8 | e.charCodeAt(F++),
        h = e.charCodeAt(F++) << 24 | e.charCodeAt(F++) << 16 | e.charCodeAt(F++) << 8 | e.charCodeAt(F++),
        1 == n && (i ? (d ^= f,
        h ^= m) : (v = f,
        g = m,
        f = d,
        m = h)),
        d ^= (c = 252645135 & (d >>> 4 ^ h)) << 4,
        d ^= (c = 65535 & (d >>> 16 ^ (h ^= c))) << 16,
        d ^= c = 858993459 & ((h ^= c) >>> 2 ^ d),
        d ^= c = 16711935 & ((h ^= c << 2) >>> 8 ^ d),
        d = (d ^= (c = 1431655765 & (d >>> 1 ^ (h ^= c << 8))) << 1) << 1 | d >>> 31,
        h = (h ^= c) << 1 | h >>> 31,
        r = 0; r < j; r += 3) {
            for (b = p[r + 1],
            y = p[r + 2],
            o = p[r]; o != b; o += y)
                l = h ^ S[o],
                u = (h >>> 4 | h << 28) ^ S[o + 1],
                c = d,
                d = h,
                h = c ^ (_[l >>> 24 & 63] | x[l >>> 16 & 63] | A[l >>> 8 & 63] | L[63 & l] | C[u >>> 24 & 63] | w[u >>> 16 & 63] | k[u >>> 8 & 63] | T[63 & u]);
            c = d,
            d = h,
            h = c
        }
        h = h >>> 1 | h << 31,
        h ^= c = 1431655765 & ((d = d >>> 1 | d << 31) >>> 1 ^ h),
        h ^= (c = 16711935 & (h >>> 8 ^ (d ^= c << 1))) << 8,
        h ^= (c = 858993459 & (h >>> 2 ^ (d ^= c))) << 2,
        h ^= c = 65535 & ((d ^= c) >>> 16 ^ h),
        h ^= c = 252645135 & ((d ^= c << 16) >>> 4 ^ h),
        d ^= c << 4,
        1 == n && (i ? (f = d,
        m = h) : (d ^= v,
        h ^= g)),
        O += String.fromCharCode(d >>> 24, d >>> 16 & 255, d >>> 8 & 255, 255 & d, h >>> 24, h >>> 16 & 255, h >>> 8 & 255, 255 & h),
        512 == (B += 8) && (z += O,
        O = "",
        B = 0)
    }
    if (z = (z += O).replace(/\0*$/g, ""),
    !i) {
        if (1 === s) {
            var E = 0;
            (I = z.length) && (E = z.charCodeAt(I - 1)),
            E <= 8 && (z = z.substring(0, I - E))
        }
        z = decodeURIComponent(escape(z))
    }
    return z
}

//修改函数名为mydecode
function   mydecode(t) {
                var e = (t = String(t).replace(f, "")).length;
                e % 4 == 0 && (e = (t = t.replace(/==?$/, "")).length),
                (e % 4 == 1 || /[^+a-zA-Z0-9/]/.test(t)) && l("Invalid character: the string to be decoded is not correctly encoded.");
                for (var n, r, i = 0, o = "", a = -1; ++a < e; )
                    r = c.indexOf(t.charAt(a)),
                    n = i % 4 ? 64 * n + r : r,
                    i++ % 4 && (o += String.fromCharCode(255 & n >> (-2 * i & 6)));
                return o
            }

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106

 

二、查漏补全JS代码

这里我们依旧是借助execjs库来执行JS代码,执行代码如下

import execjs
import json
import requests

def get_encrypt_data(url):
    header = {
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36'}
    r = requests.get(url, headers=header)
    return r.json()['encrypt_data']


def load_jscode(js_path):
    with open(js_path, 'r', encoding='utf8') as f:
        jscode = f.read()
    return jscode


if __name__ == '__main__':
    url = 'https://vipapi.qimingpian.com/DataList/productListVip'
    encrypt_data = get_encrypt_data(url)
    jscode = load_jscode('c:/Users/dell/Desktop/tech.js')
    rst = execjs.compile(jscode).call('o', encrypt_data)
    data = json.loads(rst)
    print(data)
123456789101112131415161718192021222324

执行结果如下,分析可知参数f未定义,接下来就到了"查漏补缺"的时候了

 

通过分析上述JS代码可知,参数f是在decode函数中的。在11282处打下断点,刷新页面,将鼠标放置f上可得到/[\t\n\f\r ]/g(或者在console控制台输入f亦可得到,注意:这里需要将之前打过的断点删除,否则不会有参数显示!)

 

将参数f加入之前的mydecode函数,如下所示

function   mydecode(t) {
				var f = '/[\t\n\f\r ]/g'  //添加f的定义
                var e = (t = String(t).replace(f, "")).length;
                e % 4 == 0 && (e = (t = t.replace(/==?$/, "")).length),
                (e % 4 == 1 || /[^+a-zA-Z0-9/]/.test(t)) && l("Invalid character: the string to be decoded is not correctly encoded.");
                for (var n, r, i = 0, o = "", a = -1; ++a < e; )
                    r = c.indexOf(t.charAt(a)),
                    n = i % 4 ? 64 * n + r : r,
                    i++ % 4 && (o += String.fromCharCode(255 & n >> (-2 * i & 6)));
                return o
            }
1234567891011

再次执行代码,结果如下,可知参数c尚未定义

 

同理,找到参数c的位置后(依然是在decode函数下),打断点分析,可知参数c为ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/.将参数c加入之前的mydecode函数,如下所示

function   mydecode(t) {
				var f = '/[\t\n\f\r ]/g'  //添加f的定义
				var c = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' //添加c的定义
                var e = (t = String(t).replace(f, "")).length;
                e % 4 == 0 && (e = (t = t.replace(/==?$/, "")).length),
                (e % 4 == 1 || /[^+a-zA-Z0-9/]/.test(t)) && l("Invalid character: the string to be decoded is not correctly encoded.");
                for (var n, r, i = 0, o = "", a = -1; ++a < e; )
                    r = c.indexOf(t.charAt(a)),
                    n = i % 4 ? 64 * n + r : r,
                    i++ % 4 && (o += String.fromCharCode(255 & n >> (-2 * i & 6)));
                return o
            }
123456789101112

再次执行代码,结果如下

 

 

已成功返回数据!

三、全部代码

将得到的json字符串,整理为Dataframe格式,全部代码如下

import execjs
import json
import requests
import pandas as pd

def get_encrypt_data(url):
    header = {
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.75 Safari/537.36'}
    r = requests.get(url, headers=header)
    return r.json()['encrypt_data']


def load_jscode(js_path):
    with open(js_path, 'r', encoding='utf8') as f:
        jscode = f.read()
    return jscode

def save_data(data):
    df = []
    for content in data['list']:
        item = content['product']
        business = content['yewu']
        industry = content['hangye1']
        loc = content['province']
        period = content['jieduan']
        invest_time = content['time']
        invest_money = content['money']
        investor = [investor['investor'] for investor in content['investor_info']]
        df.append([item,business,industry,loc,period,invest_time,invest_money,investor])
    df1 = pd.DataFrame(df,columns=['项目','业务','行业','地区',
                                   '投资阶段','投资时间','投资金额','投资方'])
    df1.to_csv('c:/users/dell/Desktop/company.csv',index=False,encoding='gbk')
    print('数据保存成功')
    
if __name__ == '__main__':
    url = 'https://vipapi.qimingpian.com/DataList/productListVip'
    encrypt_data = get_encrypt_data(url)
    jscode = load_jscode('c:/Users/dell/Desktop/tech.js')
    rst = execjs.compile(jscode).call('o', encrypt_data)
    data = json.loads(rst)
    save_data(data)
1234567891011121314151617181920212223242526272829303132333435363738394041

爬取数据如下

 

以上就是本次分享的全部内容~

近期有很多朋友通过私信咨询有关Python学习问题。为便于交流,点击蓝色自己加入讨论解答资源基地

 

大模型加持下js逆向效率倍增 介绍使用大模型可以帮助小白或者初入爬虫行业的同学带来一个新的思路,在一些特定的加密且可逆的情况下,可以借助AI大模型快速的推理出加密的元数据! 阅读详情

相关推荐

请求逆向|加密案例--1、AES-福建省公共资源交易平台Sign破解

为什么会有请求逆向:加密分析?问题1:随着时间延长,请求会过期超时,无法获取正常数据问题2:正常请求,只能获取当页请求所以最终,我们还要解决,动态生成签名,解决动态验签的问题加密关键字检索请求关键字检索(key or value)

2504_90439617的博客 2018

JS逆向进阶案例 | 破解加密JSON字符串数据

目录一、抓包分析字段来源二、寻找加密源码三、完善JS代码 一、抓包分析字段来源 二、寻找加密源码 三、完善JS代码

shine4869的博客 3936

JS逆向新技巧2025:破解某电商App v3.0签名加密,Python复现sign生成逻辑,直抓JSON数据

破解某电商App v3.0的加密,关键不是“逐行分析混淆代码”,而是用Frida Hook快速定位加密函数,绕开复杂的混淆逻辑;再通过抓包分析参数特征,还原核心生成逻辑,最后用Python复现。这套“Hook定位+逻辑还原+Python复现”的流程,不仅适用于电商App,还能破解大多数App的签名加密(如短视频App的接口签名、社交App的请求加密)。记住:逆向的本质是“理解App的执行逻辑”,而不是“死磕代码”,用对工具和技巧,再复杂的加密也能快速破解。你在逆向App时遇到过哪些难缠的加密?

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1399

逆向Json 解析

前两天需要做问卷评分功能,发现需要将前台的很多键值对数据返回给webservers使用。 一般我们是在后台拼装了Json后发送给前台页面再解析使用的。这次需要进行逆向的传输并解析。 没有这方面的经验,第一时间去百度了一下,发现并没有网友提供这种类似的逆向解析方法。 没办法只能自己想办法了,我是个初学者,刚在一家公司工作一个月来着,大学还没毕业经验不足,所以忽略了很多概念性的东西。 经过网...

a406502972的专栏 1075

实战解密:如何用Python+JS逆向破解私募排排网数据加密(附完整代码)

本文详细介绍了如何利用Python和JS逆向技术破解私募排排网的数据加密机制,提供完整的代码实现和实战案例。通过分析金融数据加密特点、定位解密逻辑、处理动态密钥等关键步骤,帮助开发者掌握逆向工程技术,实现高效、合法的数据获取。文章还涵盖了反爬策略、性能优化和法律合规等重要考量。

weixin_29209825的博客 1169

JS逆向实战:破解前端AES加密表单,Python爬取加密数据

在Web开发与数据采集领域,前端加密是保护数据传输安全、防止恶意爬虫的常见技术手段,其核心原理在于利用JavaScript在浏览器端对请求参数或数据进行混淆或加密处理后再发送至服务器。理解其技术价值,不仅有助于开发者构建更安全的Web应用,也是数据分析师、爬虫工程师应对反爬策略、合规获取公开数据的必备技能。典型的应用场景包括登录认证、表单提交、API接口防护等,其中AES对称加密因其安全性和效率被广泛采用。本文以一次真实的招标数据抓取为例,聚焦于前端AES-CBC加密表单的逆向分析与破解,详细拆解了如何通过

weixin_32234493的博客 815

【Js基础一】解密前端加密:掌握JavaScript逆向,轻松破解复杂数据!

jsjavaScript是一种弱类型语言,也就是说不需要指定变量的类型,JavaScript的变量类型由它的值来决定, 定义变量需要用关键字 'var', 一条JavaScript语句应该以“;”结尾var 变量名 = 值;//同时定义多个变量可以用","隔开,公用一个‘var’关键字函数就是可以重复使用的代码块, 使用关键字function定义函数。// 函数定义');定义函数时,函数如果有参数,参数放到小括号里面,函数如果有返回值,返回值通过return关键字来返回arguments。

kdayjj966的博客 3159

私募排排网JS逆向实战:解密加密数据与Python调用全解析

本文详细解析了私募排排网数据加密的JS逆向实战过程。通过定位核心解密函数、破解动态密钥生成逻辑,并最终使用Python的execjs库成功调用解密流程,完整实现了对加密数据的自动化获取与解密,为金融数据采集提供了实用的技术方案。

weixin_29311017的博客 1363

JS逆向进阶案例 | 破解Base64加密数据

目录

shine4869的博客 2528

JS逆向实战:破解前端加密数据,实现小说网站爬虫

前端加密是Web开发中常见的数据保护技术,通过在客户端JavaScript中实现加密逻辑,确保敏感数据在传输或渲染前不被轻易窃取。其核心原理通常涉及编码转换、对称加密算法或自定义混淆运算,旨在增加数据获取的难度。掌握JS逆向技术,对于数据分析、爬虫开发和Web安全研究具有重要价值,能有效应对数据采集中的加密壁垒。在实际应用中,如小说网站的内容保护,前端加密常表现为响应数据被编码或加密。通过浏览器开发者工具进行网络抓包和代码调试,可以定位解密函数入口,分析其算法逻辑,最终将解密过程移植到Node.js环境中,

weixin_33978044的博客 332

前端领域JSON数据的加密与解密

随着Web应用的复杂性不断增加,前端数据安全问题日益突出。JSON作为前后端通信的主要数据格式,其安全性直接关系到整个应用的安全。本文旨在为前端开发者提供一套完整的JSON数据加密与解密解决方案,涵盖从基础理论到实际应用的各个方面。前端数据安全的基本概念常见加密算法在前端的应用JSON数据的加密与解密实现性能与安全的平衡策略实际应用场景分析首先介绍背景知识和核心概念然后深入探讨加密算法原理接着提供实际代码实现最后讨论应用场景和未来趋势。

AI架构全栈开发实战笔记 1817

深度解析:用Python爬虫逆向破解加密数据!

大家好!我是敢敢,关注我,收看每期的编程干货。本期文章将带你详细地逆向解析某查查加密数据的构造逻辑,Follow me~

xiaoganbuaiuk的博客 3万+

savejson:轻松以JSON格式保存数据

savejson 什么是savejson? savejson是一个npm模块,以JSON格式保存数据。 使用起来非常简单! 如何安装? 在终端中,只需键入以下内容: npm install savejson --save 如何使用? savejson具有4个功能:保存,更新,获取,获取全部 得到: async function dataFunction ( ) { let savejson = require ( "savejson" ) let myData = new savejson ( "data_name_here" ) let saved = await myData . get ( "data_key_here" ) console . log ( saved ) // returns undefined because no value was s

动态 Token、加密参数逆向全流程:从原理到实战破解

本文详细介绍了Python网络爬虫开发中应对动态Token和加密参数反爬机制的方法。首先解析了动态Token和加密参数的核心概念与常见类型,包括JWT、时间戳Token、AES/RSA加密等。然后提供了完整的逆向分析流程:从定位目标接口、查找加密函数、调试破解逻辑到Python代码复现。文章还推荐了必备工具链(Chrome DevTools、Fiddler、CryptoJS等),并通过电商平台实战案例演示了JWT Token和AES加密的破解过程。最后强调了合规使用逆向技术的重要性,提醒开发者遵守robot

weixin_41943766的博客 3046

深入解析FOC电流环PI参数整定:从理论到实践

本文深入解析了FOC(磁场定向控制)中电流环PI参数整定的核心原理与实践方法。文章从永磁同步电机模型出发,详细阐述了基于带宽与零极点对消的工程法及考虑逆变器延迟的二阶系统整定法两种经典策略,并提供了从理论计算到安全上电调试的完整步骤与常见问题解决方案,帮助工程师精准调校电机控制性能。

weixin_29164497的博客 446

深入解析经典蓝牙连接:从HCI命令到LMP协议的完整流程

本文深入解析经典蓝牙连接的完整流程,从设备发现、寻呼建立物理链路,到安全配对与加密的每一步。通过对照HCI LOG与AIR LOG,详细拆解了HCI命令与LMP协议报文的对应关系,帮助开发者精准定位连接问题,掌握蓝牙调试的核心方法。

weixin_29260291的博客 449

JS逆向案例 | CryptoJS模块破解加密字符串

目录一、寻找加密源码二、引入CryptoJS模块三、Python解密四、全部代码 本次爬取仅供学习交流,无任何商业用途,目标网址已做脱敏处理! 目标网址:aHR0cDovL2p6c2MubW9odXJkLmdvdi5jbi9kYXRhL2NvbXBhbnk= 一、寻找加密源码 抓包分析可知,原数据已被加密成长串字符。之前的博客已分析过,这种可能是JSON加密过的。因此,搜索Json.parse函数,最终定位到JS文件如下所示 跟进JS文件后,继续搜索Json.parse,最终定位到935行,在此打断点刷新

shine4869的博客 4690

洛达开发--AB1585 PC 工具介绍

洛达常用的PC开发工具包括三款:1)IOT_Flash_Tool是固件烧写工具,支持USB/UART接口下载,需通过断电重启完成烧录;2)EPT是图形化PinMux配置工具,适用于MT25x3/MT768x等芯片的引脚复用设置;3)ATK是综合开发套件,包含日志工具、配置工具、OTA工具和实验室测试工具等组件。这三款工具分别针对固件烧录、硬件配置和系统调试等不同开发环节,形成完整的开发工具链。

Joon2020的博客 669

【JavaScript 逆向】某升学助考网登录参数逆向,Hook + 跟栈

使用 Hook 注入及直接跟栈方式实现对某升学助考网登录加密参数的逆向

Yy_Rose的博客 3457

3、数据导入与清洗:Excel、SQL、SPSS、Stata和SAS数据处理

本文详细介绍了如何从Excel文件、SQL数据库以及SPSS、Stata和SAS等统计软件中导入和清洗数据。针对不同数据来源的特点,提供了具体的处理方法,包括跳过无用行、重命名列、处理缺失值、转换数据类型、保留元数据等关键步骤。同时,通过实际应用案例展示了如何整合多源数据,并总结了数据导入和清洗的最佳实践,帮助读者高效完成数据预处理工作,为后续的数据分析打下坚实基础。

133

芒果YOLOv11改进175:DCNv4卷积,全网首发纯Pytorch实现代码,无需cuda编译|即插即用,一键运行:高效可变形卷积网络:重新思考视觉应用的动态和稀疏算子

芒果YOLOv11改进:DCNv4卷积,全网首发纯Pytorch实现代码,无需cuda编译|即插即用,一键运行:高效可变形卷积网络:重新思考视觉应用的动态和稀疏算子

包括YOLOv5、YOLOv7、YOLOv8等模型改进 1296

Python爬虫破解JS混淆数据加密实战

通过分析目标网站的JS混淆与数据加密机制,结合浏览器调试与Python模拟执行,成功提取加密参数并还原真实数据。重点涉及断点调试、AST分析、环境模拟及自动化解密流程。

weixin_36213081的博客 1422

【思考模型框架】前景理论(Prospect Theory),认为人们并不是完全理性的决策者,而是根据一些心理上的偏差来评估选项的价值

前景理论,是一种行为经济学理论。前景理论,描述了人们在不确定条件下如何作出决策。前景理论,认为人们并不是完全理性的决策者,而是根据一些心理上的偏差来评估选项的价值。

奶爸的编程之路,也就一周冷个三天 1642
上一篇: Python爬取链家北京租房信息!北京租房都租不起啊!
下一篇: 办公脚本——基于python自动导出疫情通每日打卡数据
pythonlaodi
博客等级 码龄6年 286粉丝 244原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值