JS逆向常见问题解决方式**
一、AES加密
JS实现
const CryptoJS = require('crypto-js'); //引用AES源码js
const key = CryptoJS.enc.Utf8.parse("1234123412ABCDEF"); //十六位十六进制数作为密钥
const iv = CryptoJS.enc.Utf8.parse('ABCDEF1234123412'); //十六位十六进制数作为密钥偏移量
//解密方法
function Decrypt(word) {
let encryptedHexStr = CryptoJS.enc.Hex.parse(word);
let srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
let decrypt = CryptoJS.AES.decrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
}
//加密方法
function Encrypt(word) {
let srcs = CryptoJS.enc.Utf8.parse(word);
let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
return encrypted.ciphertext.toString().toUpperCase();
}
export default {
Decrypt ,
Encrypt
}
Python实现
import base64
import binascii
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
class AESUtil(object):
config = {
'ECB': 1,
'CBC': 2,
'CFB': 3,
'OFB': 5,
'CTR': 6,
'OPENPGP': 7,
'CCM': 8,
'EAX': 9,
'SIV': 10,
'GCM': 11,
'OCB': 12
}
@classmethod
def encrypt(cls, text, key, iv=None, encoding='b64', mode='ECB', padding='pkcs7'):
key = key.encode() # 秘钥，b就是表示为bytes类型
if mode != 'ECB':
iv = iv.encode()
aes = AES.new(key, mode=cls.config[mode], iv=iv) # 创建一个aes对象
else:
aes = AES.new(key, mode=cls.config[mode]) # 创建一个aes对象
text = text.encode()
if padding:
text = pad(text, AES.block_size, style='pkcs7') # 选择pkcs7补全
encrypt_aes = aes.encrypt(text)
if encoding == 'b64':
encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8') # 解码
elif encoding == 'hex':
encrypted_text = str(binascii.b2a_hex(encrypt_aes), encoding='utf-8')
else:
raise ValueError('错误的编码')
encrypted_text_str = encrypted_text.replace("\n", "")
return encrypted_text_str
if __name__ == '__main__':
t = '{"YSZH":"2023","XMMC":"","verifyCode":"bg34"}'
key = 'dbd99c5139145091'
# iv = '0000000000000000'
m = 'ECB'
encoding = 'hex'
res = AESUtil.encrypt(t, key=key, iv=None, mode=m, encoding=encoding)
print(res)
import base64
import binascii
from Crypto.Cipher import AES
# 需要补位，str不是16的倍数那就补足为16的倍数
def add_to_16(value):
while len(value) % 16 != 0:
value += '\0'
return str.encode(value)
# 加密方法
def aes_encrypt(key, t, iv):
aes = AES.new(add_to_16(key), AES.MODE_CBC, add_to_16(iv)) # 初始化加密器
encrypt_aes = aes.encrypt(add_to_16(t)) # 先进行 aes 加密
encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8') # 执行加密并转码返回 bytes
return encrypted_text
# 解密方法
def aes_decrypt(key, t, iv):
aes = AES.new(add_to_16(key), AES.MODE_CBC, add_to_16(iv)) # 初始化加密器
base64_decrypted = binascii.a2b_hex(t) # 优先逆向解密 hex 成 bytes
decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '') # 执行解密密并转码返回str
return decrypted_text
if __name__ == '__main__':
secret_key = 'jo8j9wGw%6HbxfFn'
encrypted_str = ''
iv = '0123456789ABCDEF'
decrypted_str = aes_decrypt(secret_key, encrypted_str, iv)
print('解密字符串：', decrypted_str)
import rsa
import json
import struct
import base64
import random
import binascii
import hashlib
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pksc1_v1_5
class AESUtil(object):
config = {
'ECB': 1,
'CBC': 2,
'CFB': 3,
'OFB': 5,
'CTR': 6,
'OPENPGP': 7,
'CCM': 8,
'EAX': 9,
'SIV': 10,
'GCM': 11,
'OCB': 12
}
@classmethod
def encrypt(cls, text, key, iv='0000000000000000', mode='CBC', padding='pkcs7'):
key = key.encode() # 秘钥，b就是表示为bytes类型
iv = iv.encode()
text = text.encode()
if padding:
text = pad(text, AES.block_size, style='pkcs7') # 选择pkcs7补全
aes = AES.new(key, mode=cls.config[mode], iv=iv) # 创建一个aes对象
encrypt_aes = aes.encrypt(text)
integers = struct.unpack('>' + 'i'*int(len(encrypt_aes)/4), encrypt_aes)
s = []
for i in range(len(encrypt_aes)):
c = integers[i >> 2] >> 24 - i % 4 * 8 & 255
s.append(c)
return s
@classmethod
def decrypt(cls, text, key='jo8j9wGw%6HbxfFn', iv='0123456789ABCDEF',):
key = key.encode() # 秘钥，b就是表示为bytes类型
iv = iv.encode()
text = text.encode()
aes = AES.new(key, AES.MODE_CBC, iv) # 初始化加密器
base64_decrypted = binascii.a2b_hex(text) # 优先逆向解密 hex 成 bytes
decrypted_text = aes.decrypt(base64_decrypted).decode() # 执行解密密并转码返回str
unpad = lambda x: x[0:-ord(x[-1])]
return unpad(decrypted_text)
class RsaUtil:
@staticmethod
def rsa_encrypt(password, public_key):
public_key = '-----BEGIN PUBLIC KEY-----\n' + public_key + '\n-----END PUBLIC KEY-----'
rsa_key = RSA.importKey(public_key)
cipher = Cipher_pksc1_v1_5.new(rsa_key)
cipher_text = base64.b64encode(cipher.encrypt(password.encode()))
return cipher_text.decode()
@staticmethod
def encrypt(e=None, n=None, text=None):
e = int(e, 16)
n = int(n, 16)
pub_key = rsa.PublicKey(e=e, n=n)
m = rsa.encrypt(text.encode(), pub_key)
return m.hex()
def gen_rsa_number():
def _e():
return str(hex(int(65536 * (1 + random.random())))).replace('0x', '')[1:]
def _rand_str_16():
random_16_str = ''.join([_e() for i in range(4)])
return random_16_str
def _gen_u():
while True:
n = "00C1E3934D1614465B33053E7F48EE4EC87B14B95EF88947713D25EECBFF7E74C7977D02DC1D9451F79DD5D1C10C29ACB6A9B4D6FB7D0A0279B6719E1772565F09AF627715919221AEF91899CAE08C0D686D748B20A3603BE2318CA6BC2B59706592A9219D0BF05C9F65023A21D2330807252AE0066D59CEEFA5F2748EA80BAB81"
e = '10001'
random_str = _rand_str_16()
u = RsaUtil().encrypt(e, n, random_str)
if len(u) == 256:
return u, random_str
return _gen_u()
def _gen_p(e):
def t(e, t):
n = 0
for r in range(23, -1, -1):
if 1 == (t >> r & 1):
n = (n << 1) + (e >> r & 1)
return n
def bggf(e):
t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789()"
return "." if e < 0 or e >= len(t) else t[e]
n = ''
r = ''
o = len(e)
for _ in range(0, o, 3):
if _ + 2 < o:
a = (e[_] << 16) + (e[_ + 1] << 8) + e[_ + 2]
n += bggf(t(a, 7274496)) + bggf(t(a, 9483264)) + bggf(t(a, 19220)) + bggf(t(a, 235))
else:
c = o % 3
if 2 == c:
a = e[_] << 16 + e[_ + 1] << 8
n += bggf(t(a, 7274496)) + bggf(t(a, 9483264)) + bggf(t(a, 19220))
r = '.'
elif 1 == c:
a = e[_] << 16
n += bggf(t(a, 7274496)) + bggf(t(a, 9483264))
r = '.' + '.'
# print(n)
return {
'res': n,
'end': r
}
def gen_i(data, u, random_str):
text = json.dumps(data, separators=(',', ':'))
o = AESUtil.encrypt(text, key=random_str)
r = ''.join([v for k, v in _gen_p(o).items()])
w = r + u
return w
def get_ord_md5(magic):
magic_ord_list = [ord(i) for i in magic]
r = ''.join([v for k, v in _gen_p(magic_ord_list).items()])
md5_str = hashlib.md5(r.encode()).hexdigest()
return md5_str
def get_md5(magic):
md5_str = hashlib.md5(magic.encode()).hexdigest()
return md5_str
if __name__ == '__main__':
# t = '{"lang":"zh-cn","passtime":570,"a":"1885_8784","pic":"/nerualpic/space_l1_zh_2019.07.17/space/6e4b452f02a5bc85a995e189b550affd.jpg","tt":"M.O8Pjn5(?PjUA3(/@AJ@Ff0B-1/9j5)*)**O,/jK:*)))P3M9)Lp**5*)M9Y9G1(gY85555,8e,b(c,((beo94*M?0)(Y7)4)(fD)(d8)(N4)(?5Y-,SD)N5/,bE1I-*-E-(ME-P:TOU-4SURjM9JTM99j-*M9/)(0qq(()(*gSLM0qM/2wk-b(b1(56(99,-9)/39A0(MA,)b52(MF*9b9(((","ep":{"ca":[{"x":1225,"y":305,"t":1,"dt":734},{"x":1364,"y":391,"t":3,"dt":583},{"x":1176,"y":322,"t":1,"dt":22696},{"x":1336,"y":384,"t":3,"dt":569}],"v":"3.0.8","te":false,"me":true,"tm":{"a":1690862300260,"b":1690862300321,"c":1690862300322,"d":0,"e":0,"f":1690862300261,"g":1690862300266,"h":1690862300266,"i":1690862300266,"j":1690862300299,"k":1690862300282,"l":1690862300300,"m":1690862300320,"n":1690862300320,"o":1690862300323,"p":1690862301099,"q":1690862301099,"r":1690862301099,"s":1690862301428,"t":1690862301428,"u":1690862301428}},"h9s9":"1816378497","rp":"ebf4ed2074c7d048821a9e00bf2b9fdf"}'
# key = 'fa45533e57615018'
# iv = '0000000000000000'
# m = 'CBC'
# encoding = 'hex'
# res = AESUtil.encrypt(t, key=key, iv=iv, mode=m, encoding=encoding)
# print(res)
# t = '04aba42c7f286c7387e7ca2d1134c344fb8f4e142ac42aba39d1ed76735d249ef44e8ff177c74512439b932d70aa9c17'
# key = 'jo8j9wGw%6HbxfFn'
# iv = '0123456789ABCDEF'
# res = AESUtil.decrypt(t, key, iv)
# print(res)
# gen_rsa_number()
print(AESUtil.decrypt(
'fa8f1891eb026fa5ffabbd521d5acd4dace8066fd57432ad7076b9deb603f4890bdd337cec56fe776c64ff0de5a9be054b76ab1f4952248619c76d1f88cbb64714242b80311914b51c2e53b76e51cf4a0f09c4a8a39be3a9e2abd92009e9ab04cf5ec42feecf1e9470e7e4838ce9c65afcdd4d453697f8883ba4ce19d9000a6fae0e704c1c3504dfd8fed03c02e7cc85a7e3138c2c951d224c1c5089978080f1a764f33210c08b0079d4efc539a78450b97fa9196dcb25c46f088cf7c2fe1d130e393eceda5d71539e6e77bfe3b4d51acaf3485d493db3c06bee24c992bd3ca8'))
二、DES加密
JS代码
// DES-128-CBC-Zero-crypt
function desZeroEncrypt(data, key) {
let iv = CryptoJS.enc.Utf8.parse(key);
iv = CryptoJS.enc.Base64.stringify(iv).toString().substring(0,8);//base64加密取前8位
iv = CryptoJS.enc.Utf8.parse(iv);
key = CryptoJS.enc.Utf8.parse(key);
return CryptoJS.DES.encrypt(data, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.ZeroPadding
}).toString();
}
Python代码
# -*- coding:utf-8 -*-
import base64
import json
from Crypto.Cipher import DES
class Crypt(object):
"""加密和解密工具类"""
des_key = "fipFfVsZsTda94hJNKJfLoaqyqMZFFimwLt"
block_size = DES.block_size
pad_str = ['\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\x08']
@classmethod
def des_base64_encrypt(cls, reqdata):
""" 基于DES和base64的加密算法
@:param reqdata 需要加密的请求数据
"""
key = cls.des_key.encode()[:8]
length = len(reqdata)
if length < cls.block_size:
add = cls.block_size - length
elif length > cls.block_size:
add = cls.block_size - (length % cls.block_size)
else:
add = 8
reqdata = reqdata + (cls.pad_str[add - 1] * add)
des = DES.new(key, DES.MODE_ECB)
encrypt_data = des.encrypt(reqdata.encode())
return base64.b64encode(encrypt_data).decode()
@classmethod
def des_base64_decrypt(cls, retdata):
"""DES解密
@:param retdata: lakala reponse retData
"""
key = cls.des_key.encode()[:8]
debase64_data = base64.b64decode(retdata)
des = DES.new(key, DES.MODE_ECB)
decrypt_data = des.decrypt(debase64_data)
return decrypt_data
if __name__ == '__main__':
item = {
'name': '凯文-杜兰特',
'image': 'durant.png',
'birthday': '1988-09-29',
'height': '208cm',
'weight': '108.9KG'
}
string = f'{base64.b64encode(item["name"].encode()).decode()}{item["birthday"]}{item["height"]}{item["weight"]}'
print(string)
print(Crypt.des_base64_encrypt(string))
三、RSA加密
JS代码
import JSEncrypt from "jsencrypt";
export const encryption = (params: string) => {
const encryptor = new JSEncrypt(); // 创建加密对象实例
// openssl生成的公钥，复制的时候要小心不要有空格
let pubKey = ''
pubKey =
"-----BEGIN PUBLIC KEY-----" +
"这里放公钥"
"-----END PUBLIC KEY-----";
encryptor.setPublicKey(pubKey); // 设置公钥
const rsaPassWord = encryptor.encrypt(params); // 对内容进行加密
return rsaPassWord;
};
Python代码
import base64
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pksc1_v1_5
from Crypto.PublicKey import RSA
def encrypt(password, public_key):
public_key = '-----BEGIN PUBLIC KEY-----\n' + public_key + '\n-----END PUBLIC KEY-----'
rsakey = RSA.importKey(public_key)
cipher = Cipher_pksc1_v1_5.new(rsakey)
cipher_text = base64.b64encode(cipher.encrypt(password.encode()))
return cipher_text.decode()
import rsa
def encrypt(e, n, text):
e = int(e, 16)
n = int(n, 16)
pub_key = rsa.PublicKey(e=e, n=n)
m = rsa.encrypt(text.encode(), pub_key)
return m.hex()
四、DES3加密
JS代码
// 引用 crypto-js 加密模块
var CryptoJS = require('crypto-js')
function tripleDesEncrypt() {
var key = CryptoJS.enc.Utf8.parse(desKey),
iv = CryptoJS.enc.Utf8.parse(desIv),
srcs = CryptoJS.enc.Utf8.parse(text),
// ECB 加密方式，Iso10126 填充方式
encrypted = CryptoJS.TripleDES.encrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Iso10126
});
return encrypted.toString();
}
function tripleDesDecrypt() {
var key = CryptoJS.enc.Utf8.parse(desKey),
iv = CryptoJS.enc.Utf8.parse(desIv),
srcs = encryptedData,
// ECB 加密方式，Iso10126 填充方式
decrypted = CryptoJS.TripleDES.decrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Iso10126
});
return decrypted.toString(CryptoJS.enc.Utf8);
}
var text = "I love Python!" // 待加密对象
var desKey = "6f726c64f2c2057c" // 密钥
var desIv = "0123456789ABCDEF" // 偏移量
var encryptedData = tripleDesEncrypt()
var decryptedData = tripleDesDecrypt()
console.log("加密字符串: ", encryptedData)
console.log("解密字符串: ", decryptedData)
// 加密字符串: 3J0NX7x6GbewjjhoW2HKqg==
// 解密字符串: I love Python!
Python代码
from Cryptodome.Cipher import DES3
from Cryptodome import Random
# 需要补位，str不是16的倍数那就补足为16的倍数
def add_to_16(value):
while len(value) % 16 != 0:
value += '\0'
return str.encode(value)
def des_encrypt(key, text, iv):
# 加密模式 OFB
cipher_encrypt = DES3.new(add_to_16(key), DES3.MODE_OFB, iv)
encrypted_text = cipher_encrypt.encrypt(text.encode("utf-8"))
return encrypted_text
def des_decrypt(key, text, iv):
# 加密模式 OFB
cipher_decrypt = DES3.new(add_to_16(key), DES3.MODE_OFB, iv)
decrypted_text = cipher_decrypt.decrypt(text)
return decrypted_text
if __name__ == '__main__':
key = '12345678' # 密钥，16 位
text = 'I love Python!' # 加密对象
iv = Random.new().read(DES3.block_size) # DES3.block_size == 8
secret_str = des_encrypt(key, text, iv)
print('加密字符串：', secret_str)
clear_str = des_decrypt(key, secret_str, iv)
print('解密字符串：', clear_str)
# 加密字符串：b'\xa5\x8a\xd4R\x99\x16j\xba?vg\xf2\xb6\xa9'
# 解密字符串：b'I love Python!'
五、无限Debugger绕过
Function.prototype.constructor_bc=Function.prototype.constructor;
Function.prototype.constructor=function(){
if(arguments && arguments[0]==="debugger"){"什么都不做"} //利用arguments关键字的属性获取当前方法里面的参数
else{
return Function.prototype.constructor_bc.apply(this,arguments) //跟上面处理debugger和定时器一起用的处理方法一样
}
}
六、Hook cookie
// ==UserScript==
// @name Hook Cookie
// @namespace http://tampermonkey.net/
// @version 0.1
// @description try to take over the world!
// @author You
// @include *
// @grant none
// @run-at document-start
// ==/UserScript==
(function () {
'use strict';
var cookie_cache = document.cookie;
Object.defineProperty(document, 'cookie', {
get: function () {
return cookie_cache;
},
set: function (val) {
console.log('Setting cookie', val);
// 填写cookie名
if (val.indexOf('lqWVdQzgOVyaT') != -1) {
debugger;
}
var cookie = val.split(";")[0];
var ncookie = cookie.split("=");
var flag = false;
var cache = cookie_cache.split("; ");
cache = cache.map(function (a) {
if (a.split("=")[0] === ncookie[0]) {
flag = true;
return cookie;
}
return a;
})
cookie_cache = cache.join("; ");
if (!flag) {
cookie_cache += cookie + "; ";
}
return cookie_cache;
}
});
})();
(function () {
'use strict';
var cookie_cache = document.cookie;
Object.defineProperty(document, 'cookie', {
get: function () {
return cookie_cache;
},
set: function (val) {
console.log('Setting cookie', val);
// 填写cookie名
if (val.indexOf('lqWVdQzgOVyaT') != -1) {
debugger;
}
var cookie = val.split(";")[0];
var ncookie = cookie.split("=");
var flag = false;
var cache = cookie_cache.split("; ");
cache = cache.map(function (a) {
if (a.split("=")[0] === ncookie[0]) {
flag = true;
return cookie;
}
return a;
})
cookie_cache = cache.join("; ");
if (!flag) {
cookie_cache += cookie + "; ";
}
return cookie_cache;
}
});
})();
七、Hook JSON.parse
(function() {
var parse = JSON.parse;
JSON.parse = function(params) {
console.log("Hook JSON.parse ——> ", params);
debugger;
return parse(params);
}
})();
八、Proxy代理设置
function vmProxy(object){
return new Proxy(object, {
get: function(target, property, receiver) {
if(target[property] == undefined){
console.log("get: ", target, property, target[property]);
}
return target[property];
},
set: function(target, property, value) {
console.log("set: ", target, property, value);
return Reflect.set(...arguments);
}
})
}
ld = {};
ld.config = {};
ld.config.proxy = true; // 代理开关
ld.getType = function getType(obj){
return Object.prototype.toString.call(obj);
}
ld.proxy = function proxy(obj, objName){
// obj: 原始对象
// objName: 原始对象的名字
if(!ld.config.proxy){
return obj;
}
let handler = {
get:function (target,prop,receiver){ // 三个参数 获取属性时调用
let result;
try {//防止报错
result = Reflect.get(target,prop,receiver);
let type = ld.getType(result);
if(result instanceof Object){
console.log(`{get|obj:[${objName}] -> prop:[${prop.toString()}],type:[${type}]}`);
// 递归代理
result = ld.proxy(result, `${objName}.${prop.toString()}`);
}else if(typeof result === "symbol"){
console.log(`{get|obj:[${objName}] -> prop:[${prop.toString()}],ret:[${result.toString()}]}`);
}else{
console.log(`{get|obj:[${objName}] -> prop:[${prop.toString()}],ret:[${result}]}`);
}
}catch (e) {
console.log(`{get|obj:[${objName}] -> prop:[${prop.toString()}],error:[${e.message}]}`);
}
return result;
},
set:function (target,prop,value,receiver){ // 设置属性时调用
let result;
try{
result = Reflect.set(target,prop,value,receiver);
let type = ld.getType(value);
if(value instanceof Object){
console.log(`{set|obj:[${objName}] -> prop:[${prop.toString()}],type:[${type}]}`);
}else if(typeof value === "symbol"){
console.log(`{set|obj:[${objName}] -> prop:[${prop.toString()}],value:[${value.toString()}]}`);
}else{
console.log(`{set|obj:[${objName}] -> prop:[${prop.toString()}],value:[${value}]}`);
}
}catch (e){
console.log(`{set|obj:[${objName}] -> prop:[${prop.toString()}],error:[${e.message}]}`);
}
return result;
},
getOwnPropertyDescriptor:function (target, prop){ // 获取属性描述符时调用
let result;// undefined, 描述符对象
try{
result = Reflect.getOwnPropertyDescriptor(target, prop);
let type = ld.getType(result);
// debugger;
console.log(`{getOwnPropertyDescriptor|obj:[${objName}] -> prop:[${prop.toString()}],type:[${type}]}`);
// if(typeof result !== "undefined"){
// result = ld.proxy(result, `${objName}.${prop.toString()}.PropertyDescriptor`);
// }
}catch (e){
console.log(`{getOwnPropertyDescriptor|obj:[${objName}] -> prop:[${prop.toString()}],error:[${e.message}]}`);
}
return result;
},
defineProperty: function (target, prop, descriptor){ // 定义属性时调用
let result;
try{
result = Reflect.defineProperty(target, prop, descriptor);
console.log(`{defineProperty|obj:[${objName}] -> prop:[${prop.toString()}]}`);
}catch (e) {
console.log(`{defineProperty|obj:[${objName}] -> prop:[${prop.toString()}],error:[${e.message}]}`);
}
return result;
},
apply:function (target, thisArg, argumentsList){ // 函数调用时使用
// target: 函数对象
// thisArg: 调用函数的this指针
// argumentsList: 数组， 函数的入参组成的一个列表
let result;
try{
result = Reflect.apply(target, thisArg, argumentsList);
let type = ld.getType(result);
if(result instanceof Object){
console.log(`{apply|function:[${objName}], type:[${type}]}`);
}else if(typeof result === "symbol"){
console.log(`{apply|function:[${objName}], result:[${result.toString()}]}`);
}else{
console.log(`{apply|function:[${objName}], result:[${result}]}`);
}
}catch (e) {
console.log(`{apply|function:[${objName}],error:[${e.message}]}`);
}
return result;
},
construct:function (target, argArray, newTarget) { // 构造器，实例化的时候调用
// target: 函数对象
// argArray： 参数列表
// newTarget：代理对象
let result;
try{
result = Reflect.construct(target, argArray, newTarget);
let type = ld.getType(result);
console.log(`{construct|function:[${objName}], type:[${type}]}`);
}catch (e) {
console.log(`{construct|function:[${objName}],error:[${e.message}]}`);
}
return result;
},
deleteProperty:function (target, propKey){ //删除属性
let result = Reflect.deleteProperty(target, propKey);
console.log(`{deleteProperty|obj:[${objName}] -> prop:[${propKey.toString()}], result:[${result}]}`);
return result;
},
has:function (target, propKey){ // in 操作符
let result = Reflect.has(target, propKey);
console.log(`{has|obj:[${objName}] -> prop:[${propKey.toString()}], result:[${result}]}`);
return result;
},
ownKeys: function (target){ // 是否
let result = Reflect.ownKeys(target);
console.log(`{ownKeys|obj:[${objName}]}`);
return result
},
getPrototypeOf:function(target){ // 获取原型对象
let result = Reflect.getPrototypeOf(target);
console.log(`{getPrototypeOf|obj:[${objName}]}`);
return result;
},
setPrototypeOf:function(target, proto){ // 设置原型对象
let result = Reflect.setPrototypeOf(target, proto);
console.log(`{setPrototypeOf|obj:[${objName}]}`);
return result;
},
preventExtensions:function(target){ // 扩展
let result = Reflect.preventExtensions(target, proto);
console.log(`{preventExtensions|obj:[${objName}]}`);
return result;
},
// isExtensible:function(target){
// let result = Reflect.isExtensible(target, proto);
// console.log(`{isExtensible|obj:[${objName}]}`);
// return result;
// }
};
return new Proxy(obj, handler);
};
