MoeNovaClient/common/encryption.js

/**
 * 高级加密与解密工具
 * 提供字符串和对象的加密解密功能
 */

// 密钥（生产环境应更换为强密钥）
const DEFAULT_KEY = 'mengchuangPlanet2025';

/**
 * 简单的字符串加密
 * @param {String} str - 要加密的字符串
 * @param {String} key - 加密密钥（可选）
 * @returns {String} - 加密后的字符串
 */
export function encryptString(str, key = DEFAULT_KEY) {
  if (!str) return '';
  
  try {
    // 生成密钥字节序列
    const keyBytes = generateKeyBytes(key);
    
    // 加密
    let encrypted = '';
    for (let i = 0; i < str.length; i++) {
      const charCode = str.charCodeAt(i);
      const keyByte = keyBytes[i % keyBytes.length];
      encrypted += String.fromCharCode(charCode ^ keyByte);
    }
    
    // Base64编码
    return btoa(encrypted);
  } catch (e) {
    console.error('字符串加密失败:', e);
    return '';
  }
}

/**
 * 解密字符串
 * @param {String} encryptedStr - 加密后的字符串
 * @param {String} key - 解密密钥（需与加密密钥相同）
 * @returns {String} - 解密后的字符串
 */
export function decryptString(encryptedStr, key = DEFAULT_KEY) {
  if (!encryptedStr) return '';
  
  try {
    // Base64解码
    const encrypted = atob(encryptedStr);
    
    // 生成密钥字节序列
    const keyBytes = generateKeyBytes(key);
    
    // 解密
    let decrypted = '';
    for (let i = 0; i < encrypted.length; i++) {
      const charCode = encrypted.charCodeAt(i);
      const keyByte = keyBytes[i % keyBytes.length];
      decrypted += String.fromCharCode(charCode ^ keyByte);
    }
    
    return decrypted;
  } catch (e) {
    console.error('字符串解密失败:', e);
    return '';
  }
}

/**
 * 加密对象
 * @param {Object} obj - 要加密的对象
 * @param {String} key - 加密密钥（可选）
 * @returns {String} - 加密后的字符串
 */
export function encryptObject(obj, key = DEFAULT_KEY) {
  if (!obj) return '';
  
  try {
    // 将对象转为JSON字符串
    const jsonStr = JSON.stringify(obj);
    
    // 加密JSON字符串
    return encryptString(jsonStr, key);
  } catch (e) {
    console.error('对象加密失败:', e);
    return '';
  }
}

/**
 * 解密对象
 * @param {String} encryptedStr - 加密后的字符串
 * @param {String} key - 解密密钥（需与加密密钥相同）
 * @returns {Object|null} - 解密后的对象，失败返回null
 */
export function decryptObject(encryptedStr, key = DEFAULT_KEY) {
  if (!encryptedStr) return null;
  
  try {
    // 解密JSON字符串
    const jsonStr = decryptString(encryptedStr, key);
    
    // 解析JSON
    return JSON.parse(jsonStr);
  } catch (e) {
    console.error('对象解密失败:', e);
    return null;
  }
}

/**
 * 生成安全的URL参数
 * @param {Object} params - 参数对象
 * @param {String} key - 加密密钥（可选）
 * @returns {String} - 加密后的URL参数字符串
 */
export function generateSecureUrlParams(params, key = DEFAULT_KEY) {
  if (!params) return '';
  
  try {
    // 加密对象
    const encrypted = encryptObject(params, key);
    
    // URL安全编码
    return encodeURIComponent(encrypted);
  } catch (e) {
    console.error('URL参数加密失败:', e);
    return '';
  }
}

/**
 * 解析安全的URL参数
 * @param {String} encryptedParams - 加密的URL参数字符串
 * @param {String} key - 解密密钥（需与加密密钥相同）
 * @returns {Object|null} - 解密后的参数对象
 */
export function parseSecureUrlParams(encryptedParams, key = DEFAULT_KEY) {
  if (!encryptedParams) return null;
  
  try {
    // URL解码
    const decoded = decodeURIComponent(encryptedParams);
    
    // 解密对象
    return decryptObject(decoded, key);
  } catch (e) {
    console.error('URL参数解密失败:', e);
    return null;
  }
}

/**
 * 生成密钥的字节序列
 * @param {String} key - 密钥
 * @returns {Array} - 字节序列
 * @private
 */
function generateKeyBytes(key) {
  const bytes = [];
  for (let i = 0; i < key.length; i++) {
    bytes.push(key.charCodeAt(i));
  }
  return bytes;
}

/**
 * 生成随机密钥
 * @param {Number} length - 密钥长度
 * @returns {String} - 随机密钥
 */
export function generateRandomKey(length = 32) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';
  
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  
  return result;
}

/**
 * 使用随机盐值加密敏感数据
 * @param {String} data - 要加密的数据
 * @param {String} key - 加密密钥（可选）
 * @returns {Object} - 包含加密数据和盐值的对象
 */
export function encryptWithSalt(data, key = DEFAULT_KEY) {
  // 生成随机盐值
  const salt = generateRandomKey(16);
  
  // 使用盐值和密钥加密
  const encrypted = encryptString(data, salt + key);
  
  return {
    data: encrypted,
    salt: salt
  };
}

/**
 * 使用盐值解密数据
 * @param {String} encryptedData - 加密后的数据
 * @param {String} salt - 盐值
 * @param {String} key - 解密密钥（可选）
 * @returns {String} - 解密后的数据
 */
export function decryptWithSalt(encryptedData, salt, key = DEFAULT_KEY) {
  return decryptString(encryptedData, salt + key);
}

export default {
  encryptString,
  decryptString,
  encryptObject,
  decryptObject,
  generateSecureUrlParams,
  parseSecureUrlParams,
  generateRandomKey,
  encryptWithSalt,
  decryptWithSalt
}