generated from tailored/router-template
401 lines
13 KiB
TypeScript
401 lines
13 KiB
TypeScript
import { createHash } from 'crypto';
|
|
import fs from 'node:fs';
|
|
import { DOMParser } from 'xmldom';
|
|
|
|
// Helper functions
|
|
function randomStr(length: number): string {
|
|
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
return Array.from({ length }, () => alphabet.charAt(Math.floor(Math.random() * alphabet.length))).join('');
|
|
}
|
|
|
|
function getA1AndWebId(): [string, string] {
|
|
const d = Math.floor(Date.now()).toString(16) + randomStr(30) + '5' + '0' + '000';
|
|
const crc32 = (str: string): number => {
|
|
let crc = 0 ^ (-1);
|
|
for (let i = 0; i < str.length; i++) {
|
|
const char = str.charCodeAt(i);
|
|
crc = (crc >>> 8) ^ crc32Table[(crc ^ char) & 0xFF];
|
|
}
|
|
return (crc ^ (-1)) >>> 0;
|
|
};
|
|
const g = (d + crc32(d).toString()).slice(0, 52);
|
|
const webId = Array.from(new Uint8Array(createHash('md5').update(g).digest()))
|
|
.map(b => b.toString(16).padStart(2, '0')).join('');
|
|
return [g, webId];
|
|
}
|
|
|
|
// CRC32 table
|
|
const crc32Table = Array.from({ length: 256 }, (_, i) => {
|
|
let crc = i;
|
|
for (let j = 0; j < 8; j++) {
|
|
crc = crc & 1 ? 0xEDB88320 ^ (crc >>> 1) : crc >>> 1;
|
|
}
|
|
return crc;
|
|
});
|
|
|
|
// Image and video CDNs
|
|
const imgCdns = [
|
|
"https://sns-img-qc.xhscdn.com",
|
|
"https://sns-img-hw.xhscdn.com",
|
|
"https://sns-img-bd.xhscdn.com",
|
|
"https://sns-img-qn.xhscdn.com",
|
|
];
|
|
|
|
const videoCdns = [
|
|
"https://sns-video-qc.xhscdn.com",
|
|
"https://sns-video-hw.xhscdn.com",
|
|
"https://sns-video-bd.xhscdn.com",
|
|
"https://sns-video-qn.xhscdn.com",
|
|
];
|
|
|
|
// URL handling functions
|
|
function getImgUrlByTraceId(traceId: string, format: string = "png"): string {
|
|
return `${imgCdns[Math.floor(Math.random() * imgCdns.length)]}/${traceId}?imageView2/format/${format}`;
|
|
}
|
|
|
|
function getImgUrlsByTraceId(traceId: string, format: string = "png"): string[] {
|
|
return imgCdns.map(cdn => `${cdn}/${traceId}?imageView2/format/${format}`);
|
|
}
|
|
|
|
function getTraceId(imgUrl: string): string {
|
|
const parts = imgUrl.split('/');
|
|
const traceId = parts[parts.length - 1].split('!')[0];
|
|
return imgUrl.includes('spectrum') ? `spectrum/${traceId}` : traceId;
|
|
}
|
|
|
|
function getImgsUrlFromNote(note: any): string[] {
|
|
const imgs = note.image_list || [];
|
|
return imgs.map((img: any) => getImgUrlByTraceId(getTraceId(img.info_list[0].url)));
|
|
}
|
|
|
|
function getImgsUrlsFromNote(note: any): string[][] {
|
|
const imgs = note.image_list || [];
|
|
return imgs.map((img: any) => getImgUrlsByTraceId(img.trace_id));
|
|
}
|
|
|
|
function getVideoUrlFromNote(note: any): string {
|
|
if (!note.video) return '';
|
|
const originVideoKey = note.video.consumer.origin_video_key;
|
|
return `${videoCdns[Math.floor(Math.random() * videoCdns.length)]}/${originVideoKey}`;
|
|
}
|
|
|
|
function getVideoUrlsFromNote(note: any): string[] {
|
|
if (!note.video) return [];
|
|
const originVideoKey = note.video.consumer.origin_video_key;
|
|
return videoCdns.map(cdn => `${cdn}/${originVideoKey}`);
|
|
}
|
|
|
|
// File download
|
|
async function downloadFile(url: string, filename: string): Promise<void> {
|
|
const response = await fetch(url);
|
|
if (!response.ok) throw new Error(`Failed to download file: ${response.statusText}`);
|
|
const buffer = await response.arrayBuffer();
|
|
await fs.promises.writeFile(filename, Buffer.from(buffer));
|
|
}
|
|
|
|
// Path handling
|
|
function getValidPathName(text: string): string {
|
|
const invalidChars = '<>:"/\\|?*';
|
|
return text.replace(new RegExp(`[${invalidChars.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1')}]`, 'g'), '_');
|
|
}
|
|
|
|
// Signing functions
|
|
function mrc(e: string): number {
|
|
const ie = [
|
|
0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685,
|
|
2657392035, 249268274, 2044508324, 3772115230, 2547177864, 162941995,
|
|
2125561021, 3887607047, 2428444049, 498536548, 1789927666, 4089016648,
|
|
2227061214, 450548861, 1843258603, 4107580753, 2211677639, 325883990,
|
|
1684777152, 4251122042, 2321926636, 335633487, 1661365465, 4195302755,
|
|
2366115317, 997073096, 1281953886, 3579855332, 2724688242, 1006888145,
|
|
1258607687, 3524101629, 2768942443, 901097722, 1119000684, 3686517206,
|
|
2898065728, 853044451, 1172266101, 3705015759, 2882616665, 651767980,
|
|
1373503546, 3369554304, 3218104598, 565507253, 1454621731, 3485111705,
|
|
3099436303, 671266974, 1594198024, 3322730930, 2970347812, 795835527,
|
|
1483230225, 3244367275, 3060149565, 1994146192, 31158534, 2563907772,
|
|
4023717930, 1907459465, 112637215, 2680153253, 3904427059, 2013776290,
|
|
251722036, 2517215374, 3775830040, 2137656763, 141376813, 2439277719,
|
|
3865271297, 1802195444, 476864866, 2238001368, 4066508878, 1812370925,
|
|
453092731, 2181625025, 4111451223, 1706088902, 314042704, 2344532202,
|
|
4240017532, 1658658271, 366619977, 2362670323, 4224994405, 1303535960,
|
|
984961486, 2747007092, 3569037538, 1256170817, 1037604311, 2765210733,
|
|
3554079995, 1131014506, 879679996, 2909243462, 3663771856, 1141124467,
|
|
855842277, 2852801631, 3708648649, 1342533948, 654459306, 3188396048,
|
|
3373015174, 1466479909, 544179635, 3110523913, 3462522015, 1591671054,
|
|
702138776, 2966460450, 3352799412, 1504918807, 783551873, 3082640443,
|
|
3233442989, 3988292384, 2596254646, 62317068, 1957810842, 3939845945,
|
|
2647816111, 81470997, 1943803523, 3814918930, 2489596804, 225274430,
|
|
2053790376, 3826175755, 2466906013, 167816743, 2097651377, 4027552580,
|
|
2265490386, 503444072, 1762050814, 4150417245, 2154129355, 426522225,
|
|
1852507879, 4275313526, 2312317920, 282753626, 1742555852, 4189708143,
|
|
2394877945, 397917763, 1622183637, 3604390888, 2714866558, 953729732,
|
|
1340076626, 3518719985, 2797360999, 1068828381, 1219638859, 3624741850,
|
|
2936675148, 906185462, 1090812512, 3747672003, 2825379669, 829329135,
|
|
1181335161, 3412177804, 3160834842, 628085408, 1382605366, 3423369109,
|
|
3138078467, 570562233, 1426400815, 3317316542, 2998733608, 733239954,
|
|
1555261956, 3268935591, 3050360625, 752459403, 1541320221, 2607071920,
|
|
3965973030, 1969922972, 40735498, 2617837225, 3943577151, 1913087877,
|
|
83908371, 2512341634, 3803740692, 2075208622, 213261112, 2463272603,
|
|
3855990285, 2094854071, 198958881, 2262029012, 4057260610, 1759359992,
|
|
534414190, 2176718541, 4139329115, 1873836001, 414664567, 2282248934,
|
|
4279200368, 1711684554, 285281116, 2405801727, 4167216745, 1634467795,
|
|
376229701, 2685067896, 3608007406, 1308918612, 956543938, 2808555105,
|
|
3495958263, 1231636301, 1047427035, 2932959818, 3654703836, 1088359270,
|
|
936918000, 2847714899, 3736837829, 1202900863, 817233897, 3183342108,
|
|
3401237130, 1404277552, 615818150, 3134207493, 3453421203, 1423857449,
|
|
601450431, 3009837614, 3294710456, 1567103746, 711928724, 3020668471,
|
|
3272380065, 1510334235, 755167117,
|
|
];
|
|
let o = -1;
|
|
|
|
const rightWithoutSign = (num: number, bit = 0): number => {
|
|
const val = num >>> bit;
|
|
const MAX32INT = 4294967295;
|
|
return (val + (MAX32INT + 1)) % (2 * (MAX32INT + 1)) - MAX32INT - 1;
|
|
};
|
|
|
|
for (let n = 0; n < 57; n++) {
|
|
o = ie[(o & 255) ^ e.charCodeAt(n)] ^ rightWithoutSign(o, 8);
|
|
}
|
|
return o ^ -1 ^ 3988292384;
|
|
}
|
|
|
|
// Base64 encoding
|
|
const lookup = [
|
|
"Z", "m", "s", "e", "r", "b", "B", "o", "H", "Q", "t", "N", "P", "+", "w", "O",
|
|
"c", "z", "a", "/", "L", "p", "n", "g", "G", "8", "y", "J", "q", "4", "2", "K",
|
|
"W", "Y", "j", "0", "D", "S", "f", "d", "i", "k", "x", "3", "V", "T", "1", "6",
|
|
"I", "l", "U", "A", "F", "M", "9", "7", "h", "E", "C", "v", "u", "R", "X", "5",
|
|
];
|
|
|
|
function tripletToBase64(e: number): string {
|
|
return (
|
|
lookup[63 & (e >> 18)] +
|
|
lookup[63 & (e >> 12)] +
|
|
lookup[(e >> 6) & 63] +
|
|
lookup[e & 63]
|
|
);
|
|
}
|
|
|
|
function encodeChunk(e: Uint8Array, t: number, r: number): string {
|
|
const m: string[] = [];
|
|
for (let b = t; b < r; b += 3) {
|
|
const n = (16711680 & (e[b] << 16)) +
|
|
((e[b + 1] << 8) & 65280) +
|
|
(e[b + 2] & 255);
|
|
m.push(tripletToBase64(n));
|
|
}
|
|
return m.join('');
|
|
}
|
|
|
|
function b64Encode(e: Uint8Array): string {
|
|
const P = e.length;
|
|
const W = P % 3;
|
|
const U: string[] = [];
|
|
const z = 16383;
|
|
let H = 0;
|
|
const Z = P - W;
|
|
while (H < Z) {
|
|
U.push(encodeChunk(e, H, Math.min(H + z, Z)));
|
|
H += z;
|
|
}
|
|
if (W === 1) {
|
|
const F = e[P - 1];
|
|
U.push(lookup[F >> 2] + lookup[(F << 4) & 63] + "==");
|
|
} else if (W === 2) {
|
|
const F = (e[P - 2] << 8) + e[P - 1];
|
|
U.push(lookup[F >> 10] + lookup[63 & (F >> 4)] + lookup[(F << 2) & 63] + "=");
|
|
}
|
|
return U.join('');
|
|
}
|
|
|
|
function encodeUtf8(e: string): Uint8Array {
|
|
const b: number[] = [];
|
|
const m = encodeURIComponent(e).replace(/%([0-9A-F]{2})/g, (match, p1) => {
|
|
b.push(parseInt(p1, 16));
|
|
return '';
|
|
});
|
|
for (let w = 0; w < m.length; w++) {
|
|
b.push(m.charCodeAt(w));
|
|
}
|
|
return new Uint8Array(b);
|
|
}
|
|
|
|
// Base36 encoding
|
|
function base36encode(number: number, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'): string {
|
|
if (!Number.isInteger(number)) {
|
|
throw new TypeError('number must be an integer');
|
|
}
|
|
|
|
let base36 = '';
|
|
let sign = '';
|
|
|
|
if (number < 0) {
|
|
sign = '-';
|
|
number = -number;
|
|
}
|
|
|
|
if (0 <= number && number < alphabet.length) {
|
|
return sign + alphabet[number];
|
|
}
|
|
|
|
while (number !== 0) {
|
|
const remainder = number % alphabet.length;
|
|
number = Math.floor(number / alphabet.length);
|
|
base36 = alphabet[remainder] + base36;
|
|
}
|
|
|
|
return sign + base36;
|
|
}
|
|
|
|
function base36decode(number: string): number {
|
|
return parseInt(number, 36);
|
|
}
|
|
|
|
// XML parsing
|
|
function xmlToDict(element: Element): Record<string, any> {
|
|
const result: Record<string, any> = {};
|
|
for (let i = 0; i < element.children.length; i++) {
|
|
const child = element.children[i];
|
|
if (child.children.length > 0) {
|
|
const childDict = xmlToDict(child);
|
|
if (child.tagName in result) {
|
|
if (Array.isArray(result[child.tagName])) {
|
|
result[child.tagName].push(childDict);
|
|
} else {
|
|
result[child.tagName] = [result[child.tagName], childDict];
|
|
}
|
|
} else {
|
|
result[child.tagName] = childDict;
|
|
}
|
|
} else {
|
|
result[child.tagName] = child.textContent;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function parseXml(xmlString: string): Record<string, any> {
|
|
const parser = new DOMParser();
|
|
const doc = parser.parseFromString(xmlString, "text/xml");
|
|
return xmlToDict(doc.documentElement);
|
|
}
|
|
|
|
// Search ID generation
|
|
function getSearchId(): string {
|
|
const e = Math.floor(Date.now()) << 64;
|
|
const t = Math.floor(Math.random() * 2147483646);
|
|
return base36encode(e + t);
|
|
}
|
|
|
|
// Cookie handling
|
|
function cookieStrToCookieDict(cookieStr: string): Record<string, string> {
|
|
return cookieStr.split(';').reduce((acc, cookieBlock) => {
|
|
const [key, value] = cookieBlock.trim().split('=');
|
|
if (key && value) acc[key] = value;
|
|
return acc;
|
|
}, {} as Record<string, string>);
|
|
}
|
|
|
|
function cookieJarToCookieStr(cookieJar: Record<string, string>): string {
|
|
return Object.entries(cookieJar).map(([key, value]) => `${key}=${value}`).join(';');
|
|
}
|
|
|
|
function updateSessionCookiesFromCookie(session: { cookies: Record<string, string> }, cookie: string): void {
|
|
const cookieDict = cookie ? cookieStrToCookieDict(cookie) : {};
|
|
if (!cookieDict.a1 || !cookieDict.webId) {
|
|
const [a1, webId] = getA1AndWebId();
|
|
cookieDict.a1 = a1;
|
|
cookieDict.webId = webId;
|
|
}
|
|
if (!cookieDict.gid) {
|
|
cookieDict['gid.sign'] = 'PSF1M3U6EBC/Jv6eGddPbmsWzLI=';
|
|
cookieDict.gid = 'yYWfJfi820jSyYWfJfdidiKK0YfuyikEvfISMAM348TEJC28K23TxI888WJK84q8S4WfY2Sy';
|
|
}
|
|
session.cookies = cookieDict;
|
|
}
|
|
|
|
// Main sign function
|
|
function sign(uri: string, data: any = null, options: { ctime?: number; a1?: string; b1?: string } = {}): {
|
|
'x-s': string;
|
|
'x-t': string;
|
|
'x-s-common': string;
|
|
} {
|
|
function h(n: string): string {
|
|
let m = '';
|
|
const d = 'A4NjFqYu5wPHsO0XTdDgMa2r1ZQocVte9UJBvk6/7=yRnhISGKblCWi+LpfE8xzm3';
|
|
for (let i = 0; i < 32; i += 3) {
|
|
const o = n.charCodeAt(i);
|
|
const g = i + 1 < 32 ? n.charCodeAt(i + 1) : 0;
|
|
const h = i + 2 < 32 ? n.charCodeAt(i + 2) : 0;
|
|
const x = ((o & 3) << 4) | (g >> 4);
|
|
let p = ((15 & g) << 2) | (h >> 6);
|
|
const v = o >> 2;
|
|
let b = h ? h & 63 : 64;
|
|
if (!g) {
|
|
p = 64;
|
|
b = 64;
|
|
}
|
|
m += d[v] + d[x] + d[p] + d[b];
|
|
}
|
|
return m;
|
|
}
|
|
|
|
const v = options.ctime || Math.floor(Date.now());
|
|
const rawStr = `${v}test${uri}${
|
|
data && typeof data === 'object'
|
|
? JSON.stringify(data, null, '')
|
|
: data || ''
|
|
}`;
|
|
const md5Str = createHash('md5').update(rawStr).digest('hex');
|
|
const x_s = h(md5Str);
|
|
const x_t = v.toString();
|
|
|
|
const common = {
|
|
s0: 5,
|
|
s1: '',
|
|
x0: '1',
|
|
x1: '3.2.0',
|
|
x2: 'Windows',
|
|
x3: 'xhs-pc-web',
|
|
x4: '2.3.1',
|
|
x5: options.a1 || '',
|
|
x6: x_t,
|
|
x7: x_s,
|
|
x8: options.b1 || '',
|
|
x9: mrc(x_t + x_s),
|
|
x10: 1,
|
|
};
|
|
const encodeStr = encodeUtf8(JSON.stringify(common, null, ''));
|
|
const x_s_common = b64Encode(encodeStr);
|
|
return {
|
|
'x-s': x_s,
|
|
'x-t': x_t,
|
|
'x-s-common': x_s_common,
|
|
};
|
|
}
|
|
|
|
// Export all functions
|
|
export {
|
|
sign,
|
|
getA1AndWebId,
|
|
getImgUrlByTraceId,
|
|
getImgUrlsByTraceId,
|
|
getTraceId,
|
|
getImgsUrlFromNote,
|
|
getImgsUrlsFromNote,
|
|
getVideoUrlFromNote,
|
|
getVideoUrlsFromNote,
|
|
downloadFile,
|
|
getValidPathName,
|
|
mrc,
|
|
b64Encode,
|
|
encodeUtf8,
|
|
base36encode,
|
|
base36decode,
|
|
parseXml,
|
|
getSearchId,
|
|
cookieStrToCookieDict,
|
|
cookieJarToCookieStr,
|
|
updateSessionCookiesFromCookie,
|
|
}; |