diff --git a/node/js_confuse.js b/node/js_confuse.js
new file mode 100644
index 0000000..5bbad61
--- /dev/null
+++ b/node/js_confuse.js
@@ -0,0 +1,213 @@
+const parser = require("@babel/parser");
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const generator = require("@babel/generator").default;
+const fs = require('fs');
+
+
+const argv = process.argv
+const fileParam = argv[2]
+
+
+const jscode = fs.readFileSync(fileParam, {
+        encoding: "utf-8"
+    });
+
+
+let ast = parser.parse(jscode);
+
+// 字符串转unicode
+function string2unicode(str){
+    let ret ="";
+    for(let i=0; i<str.length; i++){
+       ret += "\\u" + "00" + str.charCodeAt(i).toString(16);  //字符串的charCodeAt方法转化成16进制ascii编码，再加上\u00前缀
+      }
+       return ret;
+}
+
+// 双重base64解码函数
+function double_b64_decode(sss){
+    return atob(atob(sss));
+}
+
+// 双重base64编码函数
+function double_b64_encode(sss){
+    return btoa(btoa(sss));
+}
+
+// 转化为异或表达式
+function num2xor(num){
+    let key = parseInt(Math.random() * 999999, 10);  // 生成随机数
+    let cipherNum = key ^ num;
+    return [key, cipherNum];
+}
+
+// 转化为减法运算表达式
+function num2add(num){
+    let key = parseInt(Math.random() * 999999, 10);  // 生成随机数
+    let cipherNum = key - num;
+    return [key, cipherNum];
+}
+
+// 生成随机字符串
+function randomString(len) {
+　　len = len || 32;
+　　var $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
+　　var maxPos = $chars.length;
+　　var pwd = '';
+　　for (i = 0; i < len; i++) {
+　　　　pwd += $chars.charAt(Math.floor(Math.random() * maxPos));
+　　}
+　　return pwd;
+}
+
+let strList = [];
+
+
+
+const visitor = {
+    // 改变对象的访问方式
+    MemberExpression(path){
+        if (path.node.computed == false){  // computed为false时执行
+            //const name = path.get('property').toString();  // toString方法获取原始值
+            const name = path.node.property.name;  // node节点获取原始值
+            path.node.property = t.stringLiteral(name);  // 将原始值赋值给property
+            path.node.computed = true;  // 改变computed为true
+        }
+    },
+    // 标识符unicode编码
+    Identifier(path){
+        const src_value = path.node.name;  // 获取原始值
+        path.replaceWith(t.Identifier(string2unicode(src_value)));  // 使用replace替换当前节点为unicode编码后的数据
+        path.skip();  // 跳过当前节点防止死循环，新生成的ast树也存在标识符
+    },
+    // 字符串双重base64编码
+    StringLiteral(path){  // 改变字符串为函数表达式
+        const src_value = path.node.value;  // 获取原始值
+        const en_Str = t.CallExpression(
+                t.identifier('double_b64_decode'),  // 函数名
+                [t.stringLiteral(double_b64_encode(src_value))]  // 加密后的字符串
+            )
+        path.replaceWith(en_Str);
+        path.skip();
+    },
+    // 数值位异或加密
+    NumericLiteral(path){
+        const src_value = path.node.value;  // 获取原始值
+        let xxx = num2add(src_value);  // 将原始值分解成减法运算表达式
+        let xxx_2 = num2xor(xxx[0]);  // 将减法运算表达式左边的值转变为异或表达式
+        let xxx_3 = num2xor(xxx[1]);  // 将减法运算表达式右边的值转变为异或表达式
+        path.replaceWith(t.binaryExpression('-',   // 替换原始数字字面量
+            t.binaryExpression('^', t.NumericLiteral(xxx_2[0]), t.NumericLiteral(xxx_2[1])), 
+            t.binaryExpression('^', t.NumericLiteral(xxx_3[0]), t.NumericLiteral(xxx_3[1]))
+        ));
+        path.skip();
+    },
+    // 数组混淆
+    StringLiteral(path){
+        let srcValue = double_b64_encode(path.node.value);  // 双重base64编码原始数据
+        let index = strList.indexOf(srcValue);  // 字符串的indexOf方法查询srcValue是否已存在
+        if (index == -1){  // 不存在时将srcValue加入数组
+            let length = strList.push(srcValue);  // 数组的push方法会将值加入最后并返回数组长度
+            index = length - 1;  // 数组以0开始计数，-1则表示最后一个值得位置
+        }
+        path.replaceWith(t.CallExpression(
+            t.identifier('double_b64_decode'),
+            [t.memberExpression(
+                t.identifier('Arr'),
+                t.numericLiteral(index),  // 写入数组下标
+                true
+                )]
+            ));
+    },
+    // 二项式转花指令
+    BinaryExpression(path){
+        let xxx = "_" + randomString(4);  // 生成随机字符串
+        let left = path.node.left;  // 获取原始二项式左边值
+        let right = path.node.right;  // 获取原始二项式右边值
+        let operator = path.node.operator;  // 获取原始二项式运算符
+        let j = t.identifier('j');
+        let k = t.identifier('k');
+
+        path.replaceWith(t.CallExpression(  // 将二项式替换为函数
+                t.identifier(xxx),  // 函数名为随机字符串
+                [left, right]  // 函数参数为原始二项式参数
+            ));
+
+        let newFunc = t.functionDeclaration(  // 新增用于处理花指令的函数
+                t.identifier(xxx),
+                [j, k],
+                t.blockStatement(
+                        [t.returnStatement(
+                                t.binaryExpression(operator,j,k)
+                            )]
+                    )
+            )
+        let rootPath = path.findParent(  // 向上查找，返回根节点
+                function(p){
+                    return p.isProgram();
+                }
+            )
+        rootPath.node.body.unshift(newFunc);  // 在根节点创建花指令函数
+    },
+    //  指定行加密
+    FunctionDeclaration(path){
+        let tmp = path.node.body;
+        let body = tmp.body.map(function(p){  // 遍历body下每一个子节点
+            if (t.isReturnStatement(p)) {return p};  // 不对return做操作
+            let src_code = generator(p).code;  // 将ast还原为js代码
+            let ciperCode = double_b64_encode(src_code);  // 对js代码进行加密处理
+            let ciperFunc = t.callExpression(  // 生成double_b64_decode表调用达式
+                    t.identifier('double_b64_decode'),
+                    [t.stringLiteral(ciperCode)]
+                );
+            let newFunc = t.callExpression(  // 生成eval调用表达式
+                    t.identifier('eval'),
+                    [ciperFunc]
+                );
+            return t.expressionStatement(newFunc);  // 单个节点处理完成，返回表达式节点
+        })
+        path.get('body').replaceWith(t.blockStatement(body));  // 替换原有body
+    },
+}
+
+traverse(ast, visitor);
+
+// 增加Arr数组
+strList = strList.map(function(sss){  // 将数组转化为节点形式
+    return t.StringLiteral(sss);
+})
+let var_tion = t.variableDeclaration('var',
+    [t.variableDeclarator(
+        t.identifier('Arr'),
+        t.arrayExpression(strList)
+    )]
+)
+ast.program.body.unshift(var_tion);
+
+
+// 增加double_b64_decode函数
+let fun_tion = t.functionDeclaration(
+    t.identifier('double_b64_decode'),
+    [t.identifier('sss')],
+    t.blockStatement(
+        [t.returnStatement(
+            t.CallExpression(
+                t.identifier('atob'),
+                [t.CallExpression(
+                    t.identifier('atob'),
+                    [t.identifier('sss')]
+                    )]
+                )
+        )]
+    )
+)
+ast.program.body.unshift(fun_tion);
+
+
+let code = generator(ast, {
+    compact: true,  // 是否去除空格
+    comments: false,  // 是否显示注释
+}).code;
+console.log(code);
+//fs.writeFile('./demoNew.js', code, (err)=>{});