常见js混淆

js混淆是把原本可读性比较高的代码，用另外一种或者几种代码进行替换，降低代码的可读性，但是执行效果又等同

常见混淆

• 字符串转十六进制、unicode编码

  //字符串转ASCII码
  console.log('abc'.charCodeAt(0)) // 97
  console.log('bcd'.charCodeAt(0)) // 98
  
  // ASCII码转字符串
  // 传入不定长参数
  console.log(String.fromCharCode(97, 98)) // 'ab'
  // 传入数组作为参数
  console.log(String.fromCharCode.apply(String, [97, 98])); // 'ab'
  
  // 转十六进制字符串
  function hexEnc(code) {
      for (var hexStr = '', i = 0; i < code.length; i++) {
          hexStr += '\\x' + ('0' + code.charCodeAt(i).toString(16)).substr(-2)
      }
      return hexStr
  }
  console.log(hexEnc('yyy-MM-dd')) // \x79\x79\x79\x2d\x4d\x4d\x2d\x64\x64
  
  // 转unicode字符串
  function unicodeEnc(code){
      for (var uniStr='', i = 0; i < code.length; i++) {
          // 不足4位的，前面补0
          uniStr += '\\u' + ('0000' + code.charCodeAt(i).toString(16)).substr(-4)
      }
      return uniStr
  }
  console.log(unicodeEnc('yyy-MM-dd')) // \u0079\u0079\u0079\u002d\u004d\u004d\u002d\u0064\u0064

• base64加密

  // base64加密
  function btoa(data){
      let buff = Buffer.from(data); // 默认用 utf-8 编码格式解释字符串
      let base64data = buff.toString('base64');
      return base64data
  }
  
  // base64解密
  function atob(base64data){
      let buff = Buffer.from(base64data, 'base64');
      let text = buff.toString('utf-8');
      return text
  }
  
  console.log(btoa('中国')) // 5Lit5Zu9
  console.log(atob('5Lit5Zu9')) // 中国

• 数值加密（位异或）

  // 数值加密
  // 可以利用位异或的特性，如果a ^ b = c，那么b ^ c = a, a ^ c = b
  console.log(25 ^ 36) // 61，等价于console.log(61)
  console.log(25 ^ 61) // 36
  console.log(36 ^ 61) // 25

• 数组混淆、乱序

  // 数组混淆
  var bigArr = [true, null, undefined, 1000, '\u0079\u0079\u0079', {name: 'eliwang', age: 20}, function(){console.log("hello world!")}]
  // 数组乱序
  !function (arr, num){
      while(--num){
          arr.unshift(arr.pop())
      }
  }(bigArr,3)
  
  console.log(bigArr) // [{ name: 'eliwang', age: 20 },[Function (anonymous)], true, null, undefined, 1000, 'yyy']
  console.log(bigArr[0]['name']) // eliwang
  bigArr[1]() // hello world!
  console.log(bigArr[5]) //1000

• 花指令

  // 加法花指令
  var a =10, b = 20;
  function _0x20ab1fxe1(a,b){
      return a + b
  }
  var c = _0x20ab1fxe1(a,b)
  // var c = a + b
  console.log(c) // 30

• 逗号表达式

  // 逗号表达式
  // 依次执行括号中的表达式，但是只返回最后一个表达式执行的结果
  var m = (n=1000, n + 2000)
  console.log(m) // 3000
  function commaExpression(a,b,c,d,e){
      return e = (d = (c = (b = (a = 0, a + 1000),b + 2000), c + 3000), d + 3000, d + 4000) // d + 3000 是花指令，无实际意义
  }
  console.log(commaExpression()) // 10000 <=> 0 + 1000 + 2000 + 3000 +4000

• 控制流程平坦化

  // 控制流程平坦化
  /*
      function processFlattening(){
          var a = 1000;
          var b = a + 2000;
          var c = b + 3000;
          var d = c + 4000;
          var e = d + 5000;
          var f = e + 6000;
          return f
      }
      console.log(processFlattening())
  */
  function processFlattening(){
      // 分发器
      var arrStr = '6|3|7|4|2|1|5'.split('|'), i = 0;
      while(!![]){
          switch (arrStr[i++]){
              case '1':
                  var f = e + 6000;
                  continue
              case '2':
                  var e = d + 5000;
                  continue
              case '3':
                  var b = a + 2000;
                  continue
              case '4':
                  var d = c + 4000;
                  continue
              case '5':
                  return f
                  continue // 不会执行，但会起到混淆作用
              case '6':
                  var a = 1000;
                  continue
              case '7':
                  var c = b + 3000;
                  continue
          }
          break // switch表达式的值与每个case都不匹配时，会执行这句，跳出while循环
      }
  }
  console.log(processFlattening())

• eval执行

  // eval执行
  code = `
      function evalFunc(){
          var a = 1000;
          var b = a + 2000;
          var c = b + 3000;
          var d = c + 4000;
          var e = d + 5000;
          var f = e + 6000;
          return f
      }
      console.log(evalFunc())
  `
  eval(code) // 21000