@neteasecloudmusicapienhanced/api 4.29.11

package/util/client-sign.js

@@ -0,0 +1,169 @@
+const crypto = require("crypto");
+const os = require("os");
+
+class AdvancedClientSignGenerator {
+  /**
+   * 获取本机MAC地址
+   */
+  static getRealMacAddress() {
+    try {
+      const interfaces = os.networkInterfaces();
+      for (let interfaceName in interfaces) {
+        const interface = interfaces[interfaceName];
+        for (let i = 0; i < interface.length; i++) {
+          const alias = interface[i];
+          // 排除内部地址和无效地址
+          if (
+            alias.mac &&
+            alias.mac !== "00:00:00:00:00:00" &&
+            !alias.internal
+          ) {
+            return alias.mac.toUpperCase();
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      console.warn("获取MAC地址失败:", error.message);
+      return null;
+    }
+  }
+
+  /**
+   * 生成随机MAC地址
+   */
+  static generateRandomMac() {
+    const chars = "0123456789ABCDEF";
+    let mac = "";
+    for (let i = 0; i < 6; i++) {
+      if (i > 0) mac += ":";
+      mac +=
+        chars[Math.floor(Math.random() * 16)] +
+        chars[Math.floor(Math.random() * 16)];
+    }
+    // 确保第一个字节是单播地址（最低位为0）
+    const firstByte = parseInt(mac.substring(0, 2), 16);
+    const unicastFirstByte = (firstByte & 0xfe)
+      .toString(16)
+      .padStart(2, "0")
+      .toUpperCase();
+    return unicastFirstByte + mac.substring(2);
+  }
+
+  /**
+   * 获取MAC地址（优先真实，否则随机）
+   */
+  static getMacAddress() {
+    const realMac = this.getRealMacAddress();
+    if (realMac) {
+      return realMac;
+    }
+    console.warn("无法获取真实MAC地址，使用随机生成");
+    return this.generateRandomMac();
+  }
+
+  /**
+   * 字符串转HEX编码
+   */
+  static stringToHex(str) {
+    return Buffer.from(str, "utf8").toString("hex").toUpperCase();
+  }
+
+  /**
+   * SHA-256哈希
+   */
+  static sha256(data) {
+    return crypto.createHash("sha256").update(data, "utf8").digest("hex");
+  }
+
+  /**
+   * 生成随机设备ID
+   */
+  static generateRandomDeviceId() {
+    const partLengths = [4, 4, 4, 4, 4, 4, 4, 5]; // 各部分长度
+    const chars = "0123456789ABCDEF";
+
+    const parts = partLengths.map((length) => {
+      let part = "";
+      for (let i = 0; i < length; i++) {
+        part += chars[Math.floor(Math.random() * 16)];
+      }
+      return part;
+    });
+
+    return parts.join("_");
+  }
+
+  /**
+   * 生成随机clientSign（优先使用真实MAC，否则随机）
+   */
+  static generateRandomClientSign(secretKey = "") {
+    // 获取MAC地址（优先真实，否则随机）
+    const macAddress = this.getMacAddress();
+
+    // 生成随机设备ID
+    const deviceId = this.generateRandomDeviceId();
+
+    // 转换设备ID为HEX
+    const hexDeviceId = this.stringToHex(deviceId);
+
+    // 构造签名字符串
+    const signString = `${macAddress}@@@${hexDeviceId}`;
+
+    // 生成哈希
+    const hash = this.sha256(signString + secretKey);
+
+    return `${signString}@@@@@@${hash}`;
+  }
+
+  /**
+   * 批量生成多个随机签名
+   */
+  static generateMultipleRandomSigns(count, secretKey = "") {
+    const signs = [];
+    for (let i = 0; i < count; i++) {
+      signs.push(this.generateRandomClientSign(secretKey));
+    }
+    return signs;
+  }
+
+  /**
+   * 使用指定参数生成签名
+   */
+  static generateWithCustomDeviceId(macAddress, deviceId, secretKey = "") {
+    const hexDeviceId = this.stringToHex(deviceId);
+    const signString = `${macAddress}@@@${hexDeviceId}`;
+    const hash = this.sha256(signString + secretKey);
+    return `${signString}@@@@@@${hash}`;
+  }
+
+  /**
+   * 验证签名格式是否正确
+   */
+  static validateClientSign(clientSign) {
+    try {
+      const parts = clientSign.split("@@@@@@");
+      if (parts.length !== 2) return false;
+
+      const [infoPart, hash] = parts;
+      const infoParts = infoPart.split("@@@");
+      if (infoParts.length !== 2) return false;
+
+      const [mac, hexDeviceId] = infoParts;
+
+      // 验证MAC地址格式
+      const macRegex = /^([0-9A-F]{2}:){5}[0-9A-F]{2}$/;
+      if (!macRegex.test(mac)) return false;
+
+      // 验证哈希格式
+      const hashRegex = /^[0-9a-f]{64}$/;
+      if (!hashRegex.test(hash)) return false;
+
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+module.exports = AdvancedClientSignGenerator;

package/util/config.json

@@ -0,0 +1,20 @@
+{
+  "resourceTypeMap": {
+    "0": "R_SO_4_",
+    "1": "R_MV_5_",
+    "2": "A_PL_0_",
+    "3": "R_AL_3_",
+    "4": "A_DJ_1_",
+    "5": "R_VI_62_",
+    "6": "A_EV_2_",
+    "7": "A_DR_14_"
+  },
+  "APP_CONF": {
+    "apiDomain": "https://interface.music.163.com",
+    "domain": "https://music.163.com",
+    "encrypt": true,
+    "encryptResponse": false,
+    "clientSign": "18:C0:4D:B9:8F:FE@@@453832335F384641365F424635335F303030315F303031425F343434415F343643365F333638332@@@@@@6ff673ef74955b38bce2fa8562d95c976ed4758b1227c4e9ee345987cee17bc9",
+    "checkToken": "9ca17ae2e6ffcda170e2e6ee8af14fbabdb988f225b3868eb2c15a879b9a83d274a790ac8ff54a97b889d5d42af0feaec3b92af58cff99c470a7eafd88f75e839a9ea7c14e909da883e83fb692a3abdb6b92adee9e"
+  }
+}

package/util/crypto.js

@@ -0,0 +1,135 @@
+const CryptoJS = require('crypto-js')
+const forge = require('node-forge')
+const iv = '0102030405060708'
+const presetKey = '0CoJUm6Qyw8W8jud'
+const linuxapiKey = 'rFgB&h#%2?^eDg:Q'
+const base62 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+const publicKey = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDgtQn2JZ34ZC28NWYpAUd98iZ37BUrX/aKzmFbt7clFSs6sXqHauqKWqdtLkF2KexO40H1YTX8z2lSgBBOAxLsvaklV8k4cBFK9snQXE9/DDaFt6Rr7iVZMldczhC0JNgTz+SHXT6CBHuX3e9SdB1Ua44oncaTWz7OBGLbCiK45wIDAQAB
+-----END PUBLIC KEY-----`
+const eapiKey = 'e82ckenh8dichen8'
+
+const aesEncrypt = (text, mode, key, iv, format = 'base64') => {
+  let encrypted = CryptoJS.AES.encrypt(
+    CryptoJS.enc.Utf8.parse(text),
+    CryptoJS.enc.Utf8.parse(key),
+    {
+      iv: CryptoJS.enc.Utf8.parse(iv),
+      mode: CryptoJS.mode[mode.toUpperCase()],
+      padding: CryptoJS.pad.Pkcs7,
+    },
+  )
+  if (format === 'base64') {
+    return encrypted.toString()
+  }
+
+  return encrypted.ciphertext.toString().toUpperCase()
+}
+const aesDecrypt = (ciphertext, key, iv, format = 'base64') => {
+  let bytes
+  if (format === 'base64') {
+    bytes = CryptoJS.AES.decrypt(ciphertext, CryptoJS.enc.Utf8.parse(key), {
+      iv: CryptoJS.enc.Utf8.parse(iv),
+      mode: CryptoJS.mode.ECB,
+      padding: CryptoJS.pad.Pkcs7,
+    })
+  } else {
+    bytes = CryptoJS.AES.decrypt(
+      { ciphertext: CryptoJS.enc.Hex.parse(ciphertext) },
+      CryptoJS.enc.Utf8.parse(key),
+      {
+        iv: CryptoJS.enc.Utf8.parse(iv),
+        mode: CryptoJS.mode.ECB,
+        padding: CryptoJS.pad.Pkcs7,
+      },
+    )
+  }
+  return bytes.toString(CryptoJS.enc.Utf8)
+}
+const rsaEncrypt = (str, key) => {
+  const forgePublicKey = forge.pki.publicKeyFromPem(key)
+  const encrypted = forgePublicKey.encrypt(str, 'NONE')
+  return forge.util.bytesToHex(encrypted)
+}
+
+const weapi = (object) => {
+  const text = JSON.stringify(object)
+  let secretKey = ''
+  for (let i = 0; i < 16; i++) {
+    secretKey += base62.charAt(Math.round(Math.random() * 61))
+  }
+  return {
+    params: aesEncrypt(
+      aesEncrypt(text, 'cbc', presetKey, iv),
+      'cbc',
+      secretKey,
+      iv,
+    ),
+    encSecKey: rsaEncrypt(secretKey.split('').reverse().join(''), publicKey),
+  }
+}
+
+const linuxapi = (object) => {
+  const text = JSON.stringify(object)
+  return {
+    eparams: aesEncrypt(text, 'ecb', linuxapiKey, '', 'hex'),
+  }
+}
+
+const eapi = (url, object) => {
+  const text = typeof object === 'object' ? JSON.stringify(object) : object
+  const message = `nobody${url}use${text}md5forencrypt`
+  const digest = CryptoJS.MD5(message).toString()
+  const data = `${url}-36cd479b6b5-${text}-36cd479b6b5-${digest}`
+  return {
+    params: aesEncrypt(data, 'ecb', eapiKey, '', 'hex'),
+  }
+}
+const eapiResDecrypt = (encryptedParams) => {
+  // 使用aesDecrypt解密参数
+  try {
+    const decryptedData = aesDecrypt(encryptedParams, eapiKey, '', 'hex')
+    return JSON.parse(decryptedData)
+  } catch (error) {
+    console.log('eapiResDecrypt error:', error)
+    return null
+  }
+}
+const eapiReqDecrypt = (encryptedParams) => {
+  // 使用aesDecrypt解密参数
+  const decryptedData = aesDecrypt(encryptedParams, eapiKey, '', 'hex')
+  // 使用正则表达式解析出URL和数据
+  const match = decryptedData.match(/(.*?)-36cd479b6b5-(.*?)-36cd479b6b5-(.*)/)
+  if (match) {
+    const url = match[1]
+    const data = JSON.parse(match[2])
+    return { url, data }
+  }
+
+  // 如果没有匹配到，返回null
+  return null
+}
+const decrypt = (cipher) => {
+  const decipher = CryptoJS.AES.decrypt(
+    {
+      ciphertext: CryptoJS.enc.Hex.parse(cipher),
+    },
+    eapiKey,
+    {
+      mode: CryptoJS.mode.ECB,
+    },
+  )
+  const decryptedBytes = CryptoJS.enc.Utf8.stringify(decipher)
+  return decryptedBytes
+}
+
+module.exports = {
+  weapi,
+  linuxapi,
+  eapi,
+  decrypt,
+  aesEncrypt,
+  aesDecrypt,
+  eapiReqDecrypt,
+  eapiResDecrypt,
+}

package/util/index.js

@@ -0,0 +1,159 @@
+const logger = require('./logger')
+// 预先定义常量和函数引用
+const chinaIPPrefixes = [
+  '116.25',
+  '116.76',
+  '116.77',
+  '116.78',
+  '116.79',
+  '116.80',
+  '116.81',
+  '116.82',
+  '116.83',
+  '116.84',
+  '116.85',
+  '116.86',
+  '116.87',
+  '116.88',
+  '116.89',
+  '116.90',
+  '116.91',
+  '116.92',
+  '116.93',
+  '116.94',
+]
+const prefixesLength = chinaIPPrefixes.length
+const floor = Math.floor
+const random = Math.random
+const keys = Object.keys
+
+// 预编译encodeURIComponent以减少查找开销
+const encode = encodeURIComponent
+
+module.exports = {
+  toBoolean(val) {
+    if (typeof val === 'boolean') return val
+    if (val === '') return val
+    return val === 'true' || val == '1'
+  },
+
+  cookieToJson(cookie) {
+    if (!cookie) return {}
+    let cookieArr = cookie.split(';')
+    let obj = {}
+
+    // 优化：使用for循环替代forEach，性能更好
+    for (let i = 0, len = cookieArr.length; i < len; i++) {
+      let item = cookieArr[i]
+      let arr = item.split('=')
+      // 优化：使用严格等于
+      if (arr.length === 2) {
+        obj[arr[0].trim()] = arr[1].trim()
+      }
+    }
+    return obj
+  },
+
+  cookieObjToString(cookie) {
+    // 优化：使用预绑定的keys函数和for循环
+    const cookieKeys = keys(cookie)
+    const result = []
+
+    // 优化：使用for循环和预分配数组
+    for (let i = 0, len = cookieKeys.length; i < len; i++) {
+      const key = cookieKeys[i]
+      result[i] = `${encode(key)}=${encode(cookie[key])}`
+    }
+
+    return result.join('; ')
+  },
+
+  getRandom(num) {
+    // 优化：简化随机数生成逻辑
+    // 原逻辑看起来有问题，这里保持原意但优化性能
+    var randomValue = random()
+    var floorValue = floor(randomValue * 9 + 1)
+    var powValue = Math.pow(10, num - 1)
+    var randomNum = floor((randomValue + floorValue) * powValue)
+    return randomNum
+  },
+
+  generateRandomChineseIP() {
+    // 优化：使用预绑定的函数和常量
+    const randomPrefix = chinaIPPrefixes[floor(random() * prefixesLength)]
+    const returns = `${randomPrefix}.${generateIPSegment()}.${generateIPSegment()}`
+    logger.info('Generated Random Chinese IP:', returns)
+    return returns
+  },
+  // 生成chainId的函数
+  generateChainId(cookie) {
+    const version = 'v1'
+    const randomNum = Math.floor(Math.random() * 1e6)
+    const deviceId =
+      getCookieValue(cookie, 'sDeviceId') || 'unknown-' + randomNum
+    const platform = 'web'
+    const action = 'login'
+    const timestamp = Date.now()
+
+    return `${version}_${deviceId}_${platform}_${action}_${timestamp}`
+  },
+
+  generateDeviceId() {
+    const hexChars = '0123456789ABCDEF'
+    const chars = []
+    for (let i = 0; i < 52; i++) {
+      const randomIndex = Math.floor(Math.random() * hexChars.length)
+      chars.push(hexChars[randomIndex])
+    }
+    return chars.join('')
+  },
+}
+
+// 优化：预先绑定函数
+function getRandomInt(min, max) {
+  // 优化：简化计算
+  return floor(random() * (max - min + 1)) + min
+}
+
+// 优化：预先绑定generateIPSegment函数引用
+function generateIPSegment() {
+  // 优化：内联常量
+  return getRandomInt(1, 255)
+}
+
+// 进一步优化版本（如果需要更高性能）：
+/*
+const cookieToJsonOptimized = (function() {
+  // 预编译trim函数
+  const trim = String.prototype.trim
+  
+  return function(cookie) {
+    if (!cookie) return {}
+    
+    const cookieArr = cookie.split(';')
+    const obj = {}
+    
+    for (let i = 0, len = cookieArr.length; i < len; i++) {
+      const item = cookieArr[i]
+      const eqIndex = item.indexOf('=')
+      
+      if (eqIndex > 0 && eqIndex < item.length - 1) {
+        const key = trim.call(item.substring(0, eqIndex))
+        const value = trim.call(item.substring(eqIndex + 1))
+        obj[key] = value
+      }
+    }
+    return obj
+  }
+})()
+*/
+
+// 用于从cookie字符串中获取指定值的辅助函数
+function getCookieValue(cookieStr, name) {
+  if (!cookieStr) return ''
+
+  const cookies = '; ' + cookieStr
+  const parts = cookies.split('; ' + name + '=')
+  if (parts.length === 2) return parts.pop().split(';').shift()
+  return ''
+}

package/util/logger.js

@@ -0,0 +1,29 @@
+// ANSI 颜色代码
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m'
+};
+
+const logger = {
+    debug: (msg, ...args) => console.info(`${colors.cyan}[DEBUG]${colors.reset}`, msg, ...args),
+    info: (msg, ...args) => console.info(`${colors.green}[INFO]${colors.reset}`, msg, ...args),
+    warn: (msg, ...args) => console.info(`${colors.yellow}[WARN]${colors.reset}`, msg, ...args),
+    error: (msg, ...args) => console.error(`${colors.red}[ERROR]${colors.reset}`, msg, ...args),
+    success: (msg, ...args) => console.log(`${colors.bright}${colors.green}[SUCCESS]${colors.reset}`, msg, ...args),
+    critical: (msg, ...args) => console.error(`${colors.bright}${colors.bgRed}[CRITICAL]${colors.reset}`, msg, ...args)
+};
+
+// 导出logger
+module.exports = logger;

package/util/memory-cache.js

@@ -0,0 +1,71 @@
+class MemoryCache {
+  constructor() {
+    this.cache = new Map()
+    this.size = 0
+  }
+
+  add(key, value, time, timeoutCallback) {
+    // 移除旧的条目（如果存在）
+    const old = this.cache.get(key)
+    if (old) {
+      clearTimeout(old.timeout)
+    }
+
+    // 创建新的缓存条目
+    const entry = {
+      value,
+      expire: time + Date.now(),
+      timeout: setTimeout(() => {
+        this.delete(key)
+        if (typeof timeoutCallback === 'function') {
+          timeoutCallback(value, key)
+        }
+      }, time),
+    }
+
+    this.cache.set(key, entry)
+    this.size = this.cache.size
+
+    return entry
+  }
+
+  delete(key) {
+    const entry = this.cache.get(key)
+    if (entry) {
+      clearTimeout(entry.timeout)
+      this.cache.delete(key)
+      this.size = this.cache.size
+    }
+    return null
+  }
+
+  get(key) {
+    return this.cache.get(key) || null
+  }
+
+  getValue(key) {
+    const entry = this.cache.get(key)
+    return entry ? entry.value : undefined
+  }
+
+  clear() {
+    this.cache.forEach((entry) => clearTimeout(entry.timeout))
+    this.cache.clear()
+    this.size = 0
+    return true
+  }
+
+  has(key) {
+    const entry = this.cache.get(key)
+    if (!entry) return false
+
+    if (Date.now() > entry.expire) {
+      this.delete(key)
+      return false
+    }
+
+    return true
+  }
+}
+
+module.exports = MemoryCache

package/util/option.js

@@ -0,0 +1,14 @@
+const createOption = (query, crypto = '') => {
+  return {
+    crypto: query.crypto || crypto || '',
+    cookie: query.cookie || process.env.NETEASE_COOKIE,
+    ua: query.ua || '',
+    proxy: query.proxy,
+    realIP: query.realIP,
+    randomCNIP: query.randomCNIP || false,
+    e_r: query.e_r || undefined,
+    domain: query.domain || '',
+    checkToken: query.checkToken || false,
+  }
+}
+module.exports = createOption