zhywpt-plug/wxminipro/plugin/new-utils/encryption.js

const ksort = require("./ksort.js").ksort;
const md5 = require("./md5.js").md5;
const sha1 = require("./sha1.js").sha1;
const {
  default: SM4Util
} = require('./sm4');
const sm3 = require('./SM3.js').sm3;
const {configObj, isNeedEncry} = require("../config.js");

const _signCode = "etc123456"; //签名码
const s4 = new SM4Util();
/**
 * 数字补零函数
 * @param {number} n - 需要补零的数字
 * @param {boolean} isMill - 是否为毫秒
 * @returns {string} 补零后的字符串
 */
function pad2(n, isMill = false) {
  if (isMill) {
    if (n < 10) {
      return "00" + n
    } else if (n < 100 && n >= 10) {
      return "0" + n
    } else {
      return n
    }
  } else {
    return n < 10 ? "0" + n : n;
  }
}


function sm4Decrypt(bizContent) {
  const decrypted = s4.decryptData_CBC({
    data: {
      bizContent
    }
  }, configObj.sm4Key)
  if (decrypted.data && decrypted.data.bizContent) {
    return JSON.parse(decrypted.data.bizContent)
  }
}
/**
 * 获取时间ymdHis格式
 * @returns {string} 时间字符串
 */
function getDate() {
  var date = new Date();
  return (
    date.getFullYear().toString() +
    pad2(date.getMonth() + 1) +
    pad2(date.getDate()) +
    pad2(date.getHours()) +
    pad2(date.getMinutes()) +
    pad2(date.getSeconds()) +
    pad2(date.getMilliseconds(), true)
  );
}

/**
 * 获取随机数
 * @param {number} n - 随机数长度
 * @returns {string} 随机数字符串
 */
function generateMixed(n) {
  var chars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
  var res = "";
  for (var i = 0; i < n; i++) {
    var id = Math.ceil(Math.random() * 8);
    res += chars[id];
  }
  return res;
}

/**
 * 签名函数
 * @param {Object} data - 需要签名的数据
 * @param {string} signCode - 签名码
 * @returns {string|boolean} 签名结果或false
 */
function sign(data, signCode) {
  data = ksort(data);
  var signStr = "";
  var requestId = false;
  for (let k in data) {
    if (k != "sign") {
      if (k == "requestId") {
        requestId = data[k];
      }
      signStr += k + "=" + data[k] + "&";
    }
  }
  signStr += "signCode=" + signCode;
  // console.log("signStr*************"+signStr);
  if (!requestId) {
    return false;
  }
  signStr = md5(signStr);
  signStr = signStr.toUpperCase();
  // console.log('MD5**************' + signStr);
  signStr += requestId;
  // console.log('requestId**************' + signStr);
  signStr = sha1(signStr);
  signStr = signStr.toUpperCase();
  // console.log('SHA1**************' + signStr);
  return signStr;
}

/**
 * arrayToJsonString array 转json字符串
 * @param {Array} array - 需要转换的数组
 * @returns {string} JSON字符串
 */
function arrayToJsonString(array) {
  var json = {};
  for (var i in array) {
    if (array[i] instanceof Array) {
      json[i] = {};
      for (var o in array[i]) {
        if (array[i][o] instanceof Array) {
          json[i][o] = {};
          for (var q in array[i][o]) {
            if (array[i][o][q] instanceof Array) {
              json[i][o][q] = {};
              for (var w in array[i][o][q]) {
                json[i][o][q][w] = array[i][o][q][w];
              }
            } else {
              json[i][o][q] = array[i][o][q];
            }
          }
        } else {
          json[i][o] = array[i][o];
        }
      }
    } else {
      json[i] = array[i];
    }
  }
  return JSON.stringify(json);
}

/**
 * json字符串转换成json对象
 * @param {string} data - JSON字符串
 * @returns {Object} JSON对象
 */
function stringToJson(data) {
  return JSON.parse(data);
}

/**
 * array转json对象
 * @param {Array} array - 需要转换的数组
 * @returns {Object} JSON对象
 */
function arrayToJson(array) {
  return stringToJson(arrayToJsonString(array));
}

/**
 * 时间格式化
 * @param {Date} date - 日期对象
 * @returns {string} 格式化后的时间字符串
 */
function formatTime(date) {
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  const hour = date.getHours();
  const minute = date.getMinutes();
  const second = date.getSeconds();

  return `${[year, month, day].map(formatNumber).join("-")}T${[
    hour,
    minute,
    second,
  ]
    .map(formatNumber)
    .join(":")}`;;
}

/**
 * 数字格式化
 * @param {number} n - 需要格式化的数字
 * @returns {string} 格式化后的字符串
 */
function formatNumber(n) {
  n = n.toString();
  return n[1] ? n : `0${n}`;
}

/**
 * 获取Token函数（需要根据实际情况实现）
 * @returns {string|null} Token字符串或null
 */
function getToken() {
  // 这里需要根据实际情况实现获取token的逻辑
  // 暂时返回null
  return null;
}

/**
 * 调用中台参数加密函数
 * @param {string} ifCode - 接口编码
 * @param {Object} subdata - 需要加密的数据
 * @param {string} type - 类型（可选）
 * @returns {Object} 加密后的数据对象
 */
function encryption(ifCode, subdata, type) {
  try {
    console.log('开始加密处理，接口编码:', ifCode);
    console.log('原始数据:', subdata);


    let requestData = new Array();
    requestData["ifCode"] = ifCode;
    requestData["appId"] = configObj.reqEtcAppId; //"52088945";
    requestData["encryptType"] = configObj.reqEncryptType;

    // 执行SM4加密
    console.log("sm4Key", configObj.sm4Key)

    // 是否需要加密
    if (isNeedEncry()) {
      requestData["bizContent"] = s4.encryptData_CBC(subdata, configObj.sm4Key);
    } else {
      requestData["bizContent"] = JSON.stringify(subdata);
    }

    console.log('加密后的bizContent:', requestData["bizContent"]);

    requestData["reqId"] = requestData["appId"] + "_" + getDate() + "_" + generateMixed(5);
    requestData["timestamp"] = formatTime(new Date());

    // 生产环境
    let token = getToken();
    requestData['signType'] = 'SM3';
    let sm3Data = 'appId=' + requestData['appId'] +
      '&bizContent=' + requestData['bizContent'] +
      '&signType=' + requestData['signType'] +
      '&encryptType=' + requestData["encryptType"] +
      '&timestamp=' + requestData['timestamp'] +
      '&ifCode=' + ifCode +
      '&reqId=' + requestData['reqId'];
    if (token) {
      requestData['accessToken'] = token;
      sm3Data += `&accessToken=${token}`;
    }
    console.log("sm3Data原始数据:" + sm3Data)
    console.log("sm3Key:", configObj.sm3Key)
    requestData['sign'] = sm3(sm3Data, configObj.sm3Key);
    console.log("sign:" + requestData['sign'])
    let endData = arrayToJson(requestData);
    console.log('最终加密数据:', endData);
    return endData;
  } catch (error) {
    console.error('加密过程出错:', error);
    throw error;
  }
}

// CommonJS 导出
module.exports = {
  arrayToJsonString,
  stringToJson,
  arrayToJson,
  formatTime,
  encryption,
  sm4Decrypt,
};