Update api.js

api.js

@@ -1,7 +1,7 @@
 const express = require('express');
 const crypto = require('crypto');
 const axios = require('axios');
-const cors = require('cors'); 
+const cors = require('cors');
 const app = express();
 
 app.use((req, res, next) => {
@@ -14,13 +14,13 @@ app.use(express.static('public'));
 
 
 
-app.get('/blued', async (req, res) => {
+app.get('/search', async (req, res) => {
   const { name } = req.query;
 
   const input = `16566580507931f7c79f67099ddad3a4f0e4ed29a6name${name}page1`;
 
   const sign = crypto.createHash('md5').update(input).digest('hex').toUpperCase();
-  
+
   const url = 'https://app.blued.cn/home/web-recharge/getUserInfoByNickname';
 
   const params = {
@@ -31,13 +31,356 @@ app.get('/blued', async (req, res) => {
 
   try {
     const response = await axios.get(url, { params });
-    res.send(response.data);
+    res.send(processResponse(response.data));
   } catch (error) {
     console.error(error);
-    res.status(500).send('Error getting data from Blued'); 
+    res.status(500).send('Error getting data from Blued');
+  }
+});
+
+app.get('/viewPhone', async (req, res) => {
+  const { id } = req.query;
+
+  const url = 'https://app.blued.cn/msg/phone/list';
+
+  const headers = {
+    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
+    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+    'Accept-Encoding': 'gzip, deflate, br',
+    'Connection': 'keep-alive',
+    'Cookie': 'uid=' + id
+  };
+
+  try {
+    const response = await axios({
+      url,
+      headers
+    });
+    res.send((response.data));
+  } catch (error) {
+    console.error(error);
+    res.status(500).send('Error getting data from Blued');
+  }
+});
+
+
+// 新增路由：代理用户主页
+app.get('/getDetail', async (req, res) => {
+  const { id } = req.query;
+
+  if (!id) {
+    return res.status(400).send('Missing id parameter');
+  }
+
+  const targetUrl = `https://app.blued.cn/user`;
+  const params = { id };
+
+  // 模拟真实浏览器请求头（关键！）
+  const headers = {
+    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+    'Accept-Encoding': 'gzip, deflate, br',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1',
+    'Sec-Fetch-Dest': 'document',
+    'Sec-Fetch-Mode': 'navigate',
+    'Sec-Fetch-Site': 'none',
+    'Sec-Fetch-User': '?1',
+  };
+
+  try {
+    const response = await axios({
+      method: 'GET',
+      url: targetUrl,
+      params: params,
+      headers: headers,
+      responseType: 'text', // 确保返回文本
+      timeout: 10000,
+      // 如果 Blued 使用 gzip，axios 会自动解压
+    });
+
+    // 设置正确的内容类型
+    res.set('Content-Type', 'text/html; charset=utf-8');
+    // 可选：移除或修改 CSP/X-Frame-Options（但通常在 HTML meta 或响应头中）
+    // 注意：响应头由 Blued 控制，我们只能改 HTML 内容
+
+    // （可选）尝试移除 HTML 中的 X-Frame-Options meta（如果存在）
+    let html = response.data;
+    // 移除可能的 <meta http-equiv="X-Frame-Options"> 标签
+    html = html.replace(/<meta[^>]*http-equiv=["']?X-Frame-Options["']?[^>]*>/gi, '');
+    console.log(extractConfigFromHtml(html))
+    // 返回修改后的 HTML
+    res.json(extractConfigFromHtml(html));
+  } catch (error) {
+    console.error('Proxy error:', error.message);
+    if (error.response) {
+      console.error('Blued responded with status:', error.response.status);
+    }
+    res.status(500).send('Failed to fetch user page');
   }
 });
 
+
+
+
+
+function extractConfigFromHtml(htmlString) {
+  // 匹配 window.CONFIG = { ... };
+  const match = htmlString.match(/window\.CONFIG\s*=\s*(\{[\s\S]*?\});\s*</);
+  if (match) {
+    try {
+      // 安全地解析 JSON（注意：这里其实是 JS 对象字面量，不是标准 JSON）
+      // 但由于 Blued 的 CONFIG 是合法 JS 对象，且无函数，可用 eval（谨慎！）或更安全方式
+      // 推荐：先替换掉末尾分号，再用 Function 构造器（比 eval 稍安全）
+      const configStr = match[1];
+      // 使用 Function 构造器解析（避免污染作用域）
+      const config = new Function(`return (${configStr})`)();
+      return config;
+    } catch (e) {
+      console.error('解析 CONFIG 失败:', e);
+      return null;
+    }
+  }
+  return null;
+}
+
+// 示例用法（假设你已通过 fetch 或 axios 获取到 html 字符串）
+// const html = await response.text();
+// const config = extractConfigFromHtml(html);
+
+function processResponse(response) {
+  // 检查结构是否合法
+  if (!response || !response.data || !Array.isArray(response.data.list)) {
+    return response; // 结构不符合，直接返回原数据
+  }
+
+  // 深拷贝并处理 list 中的每个对象
+  const processedList = response.data.list.map(item => {
+    if (item && typeof item === 'object' && item.hasOwnProperty('uid')) {
+      return {
+        ...item,
+        uuid: decrypt(item.uid)
+      };
+    }
+    // 如果没有 uid，保留原对象
+    return { ...item };
+  });
+
+  // 返回新结构
+  return {
+    ...response,
+    data: {
+      ...response.data,
+      list: processedList
+    }
+  };
+}
+
+
+class Hashids {
+  constructor(salt = '', minLength = 0, alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123567890') {
+    this.salt = salt + '';
+    this.minLength = Math.max(0, parseInt(minLength, 10) || 0);
+    this.alphabet = '';
+    // deduplicate alphabet chars (preserve order)
+    for (let ch of alphabet) if (!this.alphabet.includes(ch)) this.alphabet += ch;
+    if (this.alphabet.length < 16) throw new Error('alphabet must contain at least 16 unique characters');
+    if (this.alphabet.includes(' ')) throw new Error('alphabet cannot contains spaces');
+
+    this.seps = 'cfhistuCFHISTU';
+    // remove seps from alphabet (mirror Java logic)
+    let a = this.alphabet;
+    for (let i = 0; i < this.seps.length; i++) {
+      const idx = a.indexOf(this.seps.charAt(i));
+      if (idx === -1) {
+        // if not found, replace that position in seps with space (same effect as Java)
+        this.seps = this.seps.substring(0, i) + ' ' + this.seps.substring(i + 1);
+      } else {
+        a = a.substring(0, idx) + ' ' + a.substring(idx + 1);
+      }
+    }
+    a = a.replace(/\s+/g, '');
+    this.seps = this.seps.replace(/\s+/g, '');
+
+    // m21293b(strReplaceAll, this.f22838a);
+    let shuffledSeps = this._consistentShuffle(this.seps, this.salt);
+    this.seps = shuffledSeps;
+
+    // adjust seps/alphabet according to Java logic
+    if (!this.seps || (a.length / this.seps.length) > 3.5) {
+      let ceil = Math.ceil(a.length / 3.5);
+      if (ceil === 1) ceil = ceil + 1;
+      if (ceil > this.seps.length) {
+        const diff = ceil - this.seps.length;
+        this.seps += a.substring(0, diff);
+        a = a.substring(diff);
+      } else {
+        this.seps = this.seps.substring(0, ceil);
+      }
+    }
+
+    // now shuffle alphabet with salt
+    a = this._consistentShuffle(a, this.salt);
+
+    const guardCount = Math.ceil(a.length / 12);
+    if (a.length < 3) {
+      this.guards = this.seps.substring(0, guardCount);
+      this.seps = this.seps.substring(guardCount);
+    } else {
+      this.guards = a.substring(0, guardCount);
+      a = a.substring(guardCount);
+    }
+
+    this.alphabet = a;
+  }
+
+  // consistent shuffle m21293b
+  _consistentShuffle(alphabet, salt) {
+    if (!salt || salt.length === 0) return alphabet;
+    const arr = alphabet.split('');
+    const saltChars = salt.split('').map(c => c.charCodeAt(0));
+    let i = arr.length - 1;
+    let v = 0;
+    let p = 0;
+    while (i > 0) {
+      const idx = v % saltChars.length;
+      const c = saltChars[idx];
+      p += c;
+      const j = (c + idx + p) % i;
+      // swap arr[j] and arr[i]
+      const tmp = arr[j]; arr[j] = arr[i]; arr[i] = tmp;
+      i--;
+      v = idx + 1;
+    }
+    return arr.join('');
+  }
+
+  // encode numbers -> hash (m21296a -> m21294b)
+  encode(...numbers) {
+    if (!numbers || numbers.length === 0) return '';
+    // check max like Java: > 9007199254740992L
+    const MAX_ALLOWED = BigInt('9007199254740992');
+    for (let n of numbers) {
+      // accept BigInt or Number or numeric string
+      let bn = (typeof n === 'bigint') ? n : BigInt(n);
+      if (bn > MAX_ALLOWED) throw new Error('number can not be greater than 9007199254740992');
+    }
+    return this._encode(numbers);
+  }
+
+  _encode(nums) {
+    // compute i sum
+    let iSum = 0;
+    for (let idx = 0; idx < nums.length; idx++) {
+      const n = BigInt(nums[idx]);
+      iSum = Number(iSum + Number(n % BigInt(idx + 100)));
+    }
+    let alphabet = this.alphabet;
+    const lotteryChar = alphabet.charAt(iSum % alphabet.length);
+    let ret = lotteryChar;
+    for (let i = 0; i < nums.length; i++) {
+      const n = BigInt(nums[i]);
+      alphabet = this._consistentShuffle(alphabet, (lotteryChar + this.salt + alphabet).substring(0, alphabet.length));
+      ret += this._hashNumber(n, alphabet);
+      if (i + 1 < nums.length) {
+        const guardIndex = Number((n % BigInt(alphabet.charCodeAt(0) + i)) % BigInt(this.seps.length));
+        ret += this.seps.charAt(guardIndex);
+      }
+    }
+
+    // pad with guards/guards logic like Java
+    if (ret.length < this.minLength) {
+      ret = this.guards.charAt((ret.charCodeAt(0) + iSum) % this.guards.length) + ret;
+      if (ret.length < this.minLength) {
+        ret = ret + this.guards.charAt((iSum + ret.charCodeAt(2 % ret.length)) % this.guards.length);
+      }
+    }
+
+    // while still less than minLength, expand by shuffling alphabet etc
+    let half = Math.floor(alphabet.length / 2);
+    while (ret.length < this.minLength) {
+      alphabet = this._consistentShuffle(alphabet, alphabet);
+      let str = alphabet.substring(half) + ret + alphabet.substring(0, half);
+      const excess = str.length - this.minLength;
+      if (excess > 0) {
+        const start = Math.floor(excess / 2);
+        str = str.substring(start, start + this.minLength);
+      }
+      ret = str;
+    }
+
+    return ret;
+  }
+
+  // convert number to string using alphabet (m21291a)
+  _hashNumber(number, alphabet) {
+    let num = BigInt(number);
+    const len = alphabet.length;
+    let out = '';
+    if (num === 0n) return alphabet.charAt(0);
+    while (num > 0n) {
+      const idx = Number(num % BigInt(len));
+      out = alphabet.charAt(idx) + out;
+      num = num / BigInt(len);
+    }
+    return out;
+  }
+
+  // decode hash -> array of numbers (m21297a -> m21292a)
+  decode(hash) {
+    if (hash === '') return [];
+    // remove guards
+    const hashSplit = hash.replace(new RegExp('[' + this.guards.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&') + ']', 'g'), ' ').split(' ').filter(Boolean);
+    const hashPart = (hashSplit.length === 3 || hashSplit.length === 2) ? hashSplit[1] : hashSplit[0];
+    const lottery = hashPart.charAt(0);
+    const parts = hashPart.substring(1).replace(new RegExp('[' + this.seps.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&') + ']', 'g'), ' ').split(' ').filter(Boolean);
+    const result = [];
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      let alphabet = this._consistentShuffle(this.alphabet, (lottery + this.salt + this.alphabet).substring(0, this.alphabet.length));
+      result.push(this._unhash(part, alphabet));
+    }
+
+    // verify
+    const encoded = this._encode(result);
+    // if verification fails, return empty arr
+    if (encoded !== hash) return [];
+    return result;
+  }
+
+  _unhash(input, alphabet) {
+    let num = 0n;
+    const len = BigInt(alphabet.length);
+    for (let i = 0; i < input.length; i++) {
+      const pos = BigInt(alphabet.indexOf(input.charAt(i)));
+      num = num * len + pos;
+    }
+    return num;
+  }
+}
+
+// --- 对外封装的函数（与 Java 中的 HashidEncryptTool 对应） ---
+// decrypt: Java m22018a(String str) -> 传入 hash，返回拼接的数字字符串
+function decrypt(hashStr) {
+  if (!hashStr) return '';
+  try {
+    const h = new Hashids('1766', 6);
+    const arr = h.decode(hashStr);
+    // arr contains BigInt values. Concatenate them as decimal strings without separator (same as Java append)
+    return arr.map(x => x.toString()).join('');
+  } catch (e) {
+    console.error(e);
+    return '';
+  }
+}
+
+
+module.exports = {
+  HashidsJS: Hashids,
+  decrypt: decrypt
+};
+
 app.listen(3000, '0.0.0.0', () => {
-  console.log('Server listening on port 80'); 
+  console.log('Server listening on port 80');
 });