import { connect } from 'cloudflare:sockets'; let userID = ''; let IPCF = ''; let sub = ''; let subEmoji = 'true'; let socks5Address = ''; let parsedSocks5Address = {}; let enableSocks = false; let fakeUserID; let fakeHostName; let noTLS = 'false'; let proxyIPs; let socks5s; let go2Socks5s = [ '*ttvnw.net', '*tapecontent.net', '*cloudatacdn.com', '*.loadshare.org', ]; let DLS = 8; let remarkIndex = 1;//CSV备注所在列偏移量 let FileName = atob('ZWRnZXR1bm5lbA=='); let BotToken; let ChatID; let RproxyIP = 'false'; let httpsPorts = ["2053", "2083", "2087", "2096", "8443"]; let gValidTime = 7; let gUpdateTime = 3; let userIDLow; let path = '/?ed=2560'; let dyUID; let link = []; let banHosts = [atob('c3BlZWQuY2xvdWRmbGFyZS5jb20=')]; export default { async fetch(request, env, ctx) { try { const UA = request.headers.get('User-Agent') || 'null'; const userAgent = UA.toLowerCase(); userID = env.YOUKEY || env.youkey || env.PASSWORD || env.pswd || userID; if (env.KEY || env.TOKEN || (userID && !isValidYouKey(userID))) { dyUID = env.KEY || env.TOKEN || userID; gValidTime = Number(env.TIME) || gValidTime; gUpdateTime = Number(env.UPTIME) || gUpdateTime; const userIDs = await gDyUID(dyUID); userID = userIDs[0]; userIDLow = userIDs[1]; } if (!userID) { return new Response('请设置你的YOUKEY变量，或尝试重试部署，检查变量是否生效？', { status: 404, headers: { "Content-Type": "text/plain;charset=utf-8", } }); } const currentDate = new Date(); currentDate.setHours(0, 0, 0, 0); const timestamp = Math.ceil(currentDate.getTime() / 1000); const fakeUserIDMD5 = await dHashIt(`${userID}${timestamp}`); fakeUserID = [ fakeUserIDMD5.slice(0, 8), fakeUserIDMD5.slice(8, 12), fakeUserIDMD5.slice(12, 16), fakeUserIDMD5.slice(16, 20), fakeUserIDMD5.slice(20) ].join('-'); fakeHostName = `${fakeUserIDMD5.slice(6, 9)}.${fakeUserIDMD5.slice(13, 19)}`; IPCF = env.IPCF || env.ipcf || IPCF; proxyIPs = await cleanUp(IPCF); IPCF = proxyIPs[Math.floor(Math.random() * proxyIPs.length)]; socks5Address = env.SOCKS5 || socks5Address; socks5s = await cleanUp(socks5Address); socks5Address = socks5s[Math.floor(Math.random() * socks5s.length)]; socks5Address = socks5Address.split('//')[1] || socks5Address; if (env.GO2SOCKS5) go2Socks5s = await cleanUp(env.GO2SOCKS5); if (env.CFPORTS) httpsPorts = await cleanUp(env.CFPORTS); if (env.BAN) banHosts = await cleanUp(env.BAN); if (socks5Address) { try { parsedSocks5Address = socks5AddressParser(socks5Address); RproxyIP = env.RPROXYIP || 'false'; enableSocks = true; } catch (err) { let e = err; console.log(e.toString()); RproxyIP = env.RPROXYIP || !IPCF ? 'true' : 'false'; enableSocks = false; } } else { RproxyIP = env.RPROXYIP || !IPCF ? 'true' : 'false'; } const upgradeHeader = request.headers.get('Upgrade'); const url = new URL(request.url); if (!upgradeHeader || upgradeHeader !== 'websocket') { DLS = Number(env.DLS) || DLS; remarkIndex = Number(env.CSVREMARK) || remarkIndex; BotToken = env.TGTOKEN || BotToken; ChatID = env.TGID || ChatID; FileName = env.SUBNAME || FileName; subEmoji = env.SUBEMOJI || env.EMOJI || subEmoji; if (subEmoji == '0') subEmoji = 'false'; if (env.LINK) link = await cleanUp(env.LINK); sub = env.SUB || sub; if (url.searchParams.has('sub') && url.searchParams.get('sub') !== '') sub = url.searchParams.get('sub'); if (url.searchParams.has('notls')) noTLS = 'true'; if (url.searchParams.has('proxyip')) { path = `/?ed=2560&proxyip=${url.searchParams.get('proxyip')}`; RproxyIP = 'false'; } else if (url.searchParams.has('socks5')) { path = `/?ed=2560&socks5=${url.searchParams.get('socks5')}`; RproxyIP = 'false'; } else if (url.searchParams.has('socks')) { path = `/?ed=2560&socks5=${url.searchParams.get('socks')}`; RproxyIP = 'false'; } const 路径 = url.pathname.toLowerCase(); if (路径 == '/') { if (env.URL302) return Response.redirect(env.URL302, 302); else if (env.URL) return await pLink(env.URL, url); else return new Response(JSON.stringify(request.cf, null, 4), { status: 200, headers: { 'content-type': 'application/json', }, }); } else { if (env.URL302) return Response.redirect(env.URL302, 302); else if (env.URL) return await pLink(env.URL, url); else return new Response('ID Error', { status: 404 }); } } else { socks5Address = url.searchParams.get('socks5') || socks5Address; if (new RegExp('/socks5=', 'i').test(url.pathname)) socks5Address = url.pathname.split('5=')[1]; else if (new RegExp('/socks://', 'i').test(url.pathname) || new RegExp('/socks5://', 'i').test(url.pathname)) { socks5Address = url.pathname.split('://')[1].split('#')[0]; if (socks5Address.includes('@')) { let userPassword = socks5Address.split('@')[0]; const base64Regex = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i; if (base64Regex.test(userPassword) && !userPassword.includes(':')) userPassword = atob(userPassword); socks5Address = `${userPassword}@${socks5Address.split('@')[1]}`; } } if (socks5Address) { try { parsedSocks5Address = socks5AddressParser(socks5Address); enableSocks = true; } catch (err) { let e = err; console.log(e.toString()); enableSocks = false; } } else { enableSocks = false; } if (url.searchParams.has('proxyip')) { IPCF = url.searchParams.get('proxyip'); enableSocks = false; } else if (new RegExp('/proxyip=', 'i').test(url.pathname)) { IPCF = url.pathname.toLowerCase().split('/proxyip=')[1]; enableSocks = false; } else if (new RegExp('/proxyip.', 'i').test(url.pathname)) { IPCF = `proxyip.${url.pathname.toLowerCase().split("/proxyip.")[1]}`; enableSocks = false; } else if (new RegExp('/pyip=', 'i').test(url.pathname)) { IPCF = url.pathname.toLowerCase().split('/pyip=')[1]; enableSocks = false; } return await vbridgeOverWSHandler(request); } } catch (err) { let e = err; return new Response(e.toString()); } }, }; async function vbridgeOverWSHandler(request) { // @ts-ignore const webSocketPair = new WebSocketPair(); const [client, webSocket] = Object.values(webSocketPair); // 接受 WebSocket 连接 webSocket.accept(); let address = ''; let portWithRandomLog = ''; // 日志函数，用于记录连接信息 const log = (/** @type {string} */ info, /** @type {string | undefined} */ event) => { console.log(`[${address}:${portWithRandomLog}] ${info}`, event || ''); }; // 获取早期数据头部，可能包含了一些初始化数据 const earlyDataHeader = request.headers.get('sec-websocket-protocol') || ''; // 创建一个可读的 WebSocket 流，用于接收客户端数据 const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log); // 用于存储远程 Socket 的包装器 let remoteSocketWapper = { value: null, }; // 标记是否为 DNS 查询 let isDns = false; // WebSocket 数据流向远程服务器的管道 readableWebSocketStream.pipeTo(new WritableStream({ async write(chunk, controller) { if (isDns) { // 如果是 DNS 查询，调用 DNS 处理函数 return await handleDNSQuery(chunk, webSocket, null, log); } if (remoteSocketWapper.value) { // 如果已有远程 Socket，直接写入数据 const writer = remoteSocketWapper.value.writable.getWriter() await writer.write(chunk); writer.releaseLock(); return; } // 处理 vbridge 协议头部 const { hasError, message, addressType, portRemote = 443, addressRemote = '', rawDataIndex, vbridgeVersion = new Uint8Array([0, 0]), isUDP, } = processVbridgeHeader(chunk, userID); // 设置地址和端口信息，用于日志 address = addressRemote; portWithRandomLog = `${portRemote}--${Math.random()} ${isUDP ? 'udp ' : 'tcp '} `; if (hasError) { // 如果有错误，抛出异常 throw new Error(message); return; } // 如果是 UDP 且端口不是 DNS 端口（53），则关闭连接 if (isUDP) { if (portRemote === 53) { isDns = true; } else { throw new Error('UDP 代理仅对 DNS（53 端口）启用'); return; } } // 构建 vbridge 响应头部 const vbridgeResponseHeader = new Uint8Array([vbridgeVersion[0], 0]); // 获取实际的客户端数据 const rawClientData = chunk.slice(rawDataIndex); if (isDns) { // 如果是 DNS 查询，调用 DNS 处理函数 return handleDNSQuery(rawClientData, webSocket, vbridgeResponseHeader, log); } // 处理 TCP 出站连接 if (!banHosts.includes(addressRemote)) { log(`处理 TCP 出站连接 ${addressRemote}:${portRemote}`); handleTCPOutBound(remoteSocketWapper, addressType, addressRemote, portRemote, rawClientData, webSocket, vbridgeResponseHeader, log); } else { throw new Error(`黑名单关闭 TCP 出站连接 ${addressRemote}:${portRemote}`); } }, close() { log(`readableWebSocketStream 已关闭`); }, abort(reason) { log(`readableWebSocketStream 已中止`, JSON.stringify(reason)); }, })).catch((err) => { log('readableWebSocketStream 管道错误', err); }); // 返回一个 WebSocket 升级的响应 return new Response(null, { status: 101, // @ts-ignore webSocket: client, }); } async function handleTCPOutBound(remoteSocket, addressType, addressRemote, portRemote, rawClientData, webSocket, vbridgeResponseHeader, log,) { async function useSocks5Pattern(address) { if (go2Socks5s.includes(atob('YWxsIGlu')) || go2Socks5s.includes(atob('Kg=='))) return true; return go2Socks5s.some(pattern => { let regexPattern = pattern.replace(/\*/g, '.*'); let regex = new RegExp(`^${regexPattern}$`, 'i'); return regex.test(address); }); } async function connectAndWrite(address, port, socks = false) { log(`connected to ${address}:${port}`); //if (/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(address)) address = `${atob('d3d3Lg==')}${address}${atob('LmlwLjA5MDIyNy54eXo=')}`; // 如果指定使用 SOCKS5 代理，则通过 SOCKS5 协议连接；否则直接连接 const tcpSocket = socks ? await socks5Connect(addressType, address, port, log) : connect({ hostname: address, port: port, }); remoteSocket.value = tcpSocket; //log(`connected to ${address}:${port}`); const writer = tcpSocket.writable.getWriter(); // 首次写入，通常是 TLS 客户端 Hello 消息 await writer.write(rawClientData); writer.releaseLock(); return tcpSocket; } /** * 重试函数：当 Cloudflare 的 TCP Socket 没有传入数据时，我们尝试重定向 IP * 这可能是因为某些网络问题导致的连接失败 */ async function retry() { if (enableSocks) { // 如果启用了 SOCKS5，通过 SOCKS5 代理重试连接 tcpSocket = await connectAndWrite(addressRemote, portRemote, true); } else { // 否则，尝试使用预设的代理 IP（如果有）或原始地址重试连接 if (!IPCF || IPCF == '') { IPCF = atob(`UFJPWFlJUC50cDEuZnh4ay5kZWR5bi5pbw==`); } else if (IPCF.includes(']:')) { portRemote = IPCF.split(']:')[1] || portRemote; IPCF = IPCF.split(']:')[0] || IPCF; } else if (IPCF.split(':').length === 2) { portRemote = IPCF.split(':')[1] || portRemote; IPCF = IPCF.split(':')[0] || IPCF; } if (IPCF.includes('.tp')) portRemote = IPCF.split('.tp')[1].split('.')[0] || portRemote; tcpSocket = await connectAndWrite(IPCF || addressRemote, portRemote); } // 无论重试是否成功，都要关闭 WebSocket（可能是为了重新建立连接） tcpSocket.closed.catch(error => { console.log('retry tcpSocket closed error', error); }).finally(() => { safeCloseWebSocket(webSocket); }) // 建立从远程 Socket 到 WebSocket 的数据流 remoteSocketToWS(tcpSocket, webSocket, vbridgeResponseHeader, null, log); } let useSocks = false; if (go2Socks5s.length > 0 && enableSocks) useSocks = await useSocks5Pattern(addressRemote); // 首次尝试连接远程服务器 let tcpSocket = await connectAndWrite(addressRemote, portRemote, useSocks); // 当远程 Socket 就绪时，将其传递给 WebSocket // 建立从远程服务器到 WebSocket 的数据流，用于将远程服务器的响应发送回客户端 // 如果连接失败或无数据，retry 函数将被调用进行重试 remoteSocketToWS(tcpSocket, webSocket, vbridgeResponseHeader, retry, log); } function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) { // 标记可读流是否已被取消 let readableStreamCancel = false; // 创建一个新的可读流 const stream = new ReadableStream({ // 当流开始时的初始化函数 start(controller) { // 监听 WebSocket 的消息事件 webSocketServer.addEventListener('message', (event) => { // 如果流已被取消，不再处理新消息 if (readableStreamCancel) { return; } const message = event.data; // 将消息加入流的队列中 controller.enqueue(message); }); // 监听 WebSocket 的关闭事件 // 注意：这个事件意味着客户端关闭了客户端 -> 服务器的流 // 但是，服务器 -> 客户端的流仍然打开，直到在服务器端调用 close() // WebSocket 协议要求在每个方向上都要发送单独的关闭消息，以完全关闭 Socket webSocketServer.addEventListener('close', () => { // 客户端发送了关闭信号，需要关闭服务器端 safeCloseWebSocket(webSocketServer); // 如果流未被取消，则关闭控制器 if (readableStreamCancel) { return; } controller.close(); }); // 监听 WebSocket 的错误事件 webSocketServer.addEventListener('error', (err) => { log('WebSocket 服务器发生错误'); // 将错误传递给控制器 controller.error(err); }); // 处理 WebSocket 0-RTT（零往返时间）的早期数据 // 0-RTT 允许在完全建立连接之前发送数据，提高了效率 const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader); if (error) { // 如果解码早期数据时出错，将错误传递给控制器 controller.error(error); } else if (earlyData) { // 如果有早期数据，将其加入流的队列中 controller.enqueue(earlyData); } }, // 当使用者从流中拉取数据时调用 pull(controller) { // 这里可以实现反压机制 // 如果 WebSocket 可以在流满时停止读取，我们就可以实现反压 // 参考：https://streams.spec.whatwg.org/#example-rs-push-backpressure }, // 当流被取消时调用 cancel(reason) { // 流被取消的几种情况： // 1. 当管道的 WritableStream 有错误时，这个取消函数会被调用，所以在这里处理 WebSocket 服务器的关闭 // 2. 如果 ReadableStream 被取消，所有 controller.close/enqueue 都需要跳过 // 3. 但是经过测试，即使 ReadableStream 被取消，controller.error 仍然有效 if (readableStreamCancel) { return; } log(`可读流被取消，原因是 ${reason}`); readableStreamCancel = true; // 安全地关闭 WebSocket safeCloseWebSocket(webSocketServer); } }); return stream; } // https://xtls.github.io/development/protocols/vbridge.html // https://github.com/zizifn/excalidraw-backup/blob/main/v2ray-protocol.excalidraw /** * 解析 vbridge 协议的头部数据 * @param { ArrayBuffer} vbridgeBuffer vbridge 协议的原始头部数据 * @param {string} userID 用于验证的用户 ID * @returns {Object} 解析结果，包括是否有错误、错误信息、远程地址信息等 */ function processVbridgeHeader(vbridgeBuffer, userID) { // 检查数据长度是否足够（至少需要 24 字节） if (vbridgeBuffer.byteLength < 24) { return { hasError: true, message: 'invalid data', }; } // 解析 vbridge 协议版本（第一个字节） const version = new Uint8Array(vbridgeBuffer.slice(0, 1)); let isValidUser = false; let isUDP = false; // 验证用户 ID（接下来的 16 个字节） function isUserIDValid(userID, userIDLow, buffer) { const userIDArray = new Uint8Array(buffer.slice(1, 17)); const userIDString = stringify(userIDArray); return userIDString === userID || userIDString === userIDLow; } // 使用函数验证 isValidUser = isUserIDValid(userID, userIDLow, vbridgeBuffer); // 如果用户 ID 无效，返回错误 if (!isValidUser) { return { hasError: true, message: `invalid user ${(new Uint8Array(vbridgeBuffer.slice(1, 17)))}`, }; } // 获取附加选项的长度（第 17 个字节） const optLength = new Uint8Array(vbridgeBuffer.slice(17, 18))[0]; // 暂时跳过附加选项 // 解析命令（紧跟在选项之后的 1 个字节） // 0x01: TCP, 0x02: UDP, 0x03: MUX（多路复用） const command = new Uint8Array( vbridgeBuffer.slice(18 + optLength, 18 + optLength + 1) )[0]; // 0x01 TCP // 0x02 UDP // 0x03 MUX if (command === 1) { // TCP 命令，不需特殊处理 } else if (command === 2) { // UDP 命令 isUDP = true; } else { // 不支持的命令 return { hasError: true, message: `command ${command} is not support, command 01-tcp,02-udp,03-mux`, }; } // 解析远程端口（大端序，2 字节） const portIndex = 18 + optLength + 1; const portBuffer = vbridgeBuffer.slice(portIndex, portIndex + 2); // port is big-Endian in raw data etc 80 == 0x005d const portRemote = new DataView(portBuffer).getUint16(0); // 解析地址类型和地址 let addressIndex = portIndex + 2; const addressBuffer = new Uint8Array( vbridgeBuffer.slice(addressIndex, addressIndex + 1) ); // 地址类型：1-IPv4(4字节), 2-域名(可变长), 3-IPv6(16字节) const addressType = addressBuffer[0]; let addressLength = 0; let addressValueIndex = addressIndex + 1; let addressValue = ''; switch (addressType) { case 1: // IPv4 地址 addressLength = 4; // 将 4 个字节转为点分十进制格式 addressValue = new Uint8Array( vbridgeBuffer.slice(addressValueIndex, addressValueIndex + addressLength) ).join('.'); break; case 2: // 域名 // 第一个字节是域名长度 addressLength = new Uint8Array( vbridgeBuffer.slice(addressValueIndex, addressValueIndex + 1) )[0]; addressValueIndex += 1; // 解码域名 addressValue = new TextDecoder().decode( vbridgeBuffer.slice(addressValueIndex, addressValueIndex + addressLength) ); break; case 3: // IPv6 地址 addressLength = 16; const dataView = new DataView( vbridgeBuffer.slice(addressValueIndex, addressValueIndex + addressLength) ); // 每 2 字节构成 IPv6 地址的一部分 const ipv6 = []; for (let i = 0; i < 8; i++) { ipv6.push(dataView.getUint16(i * 2).toString(16)); } addressValue = ipv6.join(':'); // seems no need add [] for ipv6 break; default: // 无效的地址类型 return { hasError: true, message: `invild addressType is ${addressType}`, }; } // 确保地址不为空 if (!addressValue) { return { hasError: true, message: `addressValue is empty, addressType is ${addressType}`, }; } // 返回解析结果 return { hasError: false, addressRemote: addressValue, // 解析后的远程地址 addressType, // 地址类型 portRemote, // 远程端口 rawDataIndex: addressValueIndex + addressLength, // 原始数据的实际起始位置 vbridgeVersion: version, // vbridge 协议版本 isUDP, // 是否是 UDP 请求 }; } async function remoteSocketToWS(remoteSocket, webSocket, vbridgeResponseHeader, retry, log) { // 将数据从远程服务器转发到 WebSocket let remoteChunkCount = 0; let chunks = []; /** @type {ArrayBuffer | null} */ let vbridgeHeader = vbridgeResponseHeader; let hasIncomingData = false; // 检查远程 Socket 是否有传入数据 // 使用管道将远程 Socket 的可读流连接到一个可写流 await remoteSocket.readable .pipeTo( new WritableStream({ start() { // 初始化时不需要任何操作 }, /** * 处理每个数据块 * @param {Uint8Array} chunk 数据块 * @param {*} controller 控制器 */ async write(chunk, controller) { hasIncomingData = true; // 标记已收到数据 // remoteChunkCount++; // 用于流量控制，现在似乎不需要了 // 检查 WebSocket 是否处于开放状态 if (webSocket.readyState !== WS_READY_STATE_OPEN) { controller.error( 'webSocket.readyState is not open, maybe close' ); } if (vbridgeHeader) { // 如果有 vbridge 响应头部，将其与第一个数据块一起发送 webSocket.send(await new Blob([vbridgeHeader, chunk]).arrayBuffer()); vbridgeHeader = null; // 清空头部，之后不再发送 } else { // 直接发送数据块 // 以前这里有流量控制代码，限制大量数据的发送速率 // 但现在 Cloudflare 似乎已经修复了这个问题 // if (remoteChunkCount > 20000) { // // cf one package is 4096 byte(4kb), 4096 * 20000 = 80M // await delay(1); // } webSocket.send(chunk); } }, close() { // 当远程连接的可读流关闭时 log(`remoteConnection!.readable is close with hasIncomingData is ${hasIncomingData}`); // 不需要主动关闭 WebSocket，因为这可能导致 HTTP ERR_CONTENT_LENGTH_MISMATCH 问题 // 客户端无论如何都会发送关闭事件 // safeCloseWebSocket(webSocket); }, abort(reason) { // 当远程连接的可读流中断时 console.error(`remoteConnection!.readable abort`, reason); }, }) ) .catch((error) => { // 捕获并记录任何异常 console.error( `remoteSocketToWS has exception `, error.stack || error ); // 发生错误时安全地关闭 WebSocket safeCloseWebSocket(webSocket); }); // 处理 Cloudflare 连接 Socket 的特殊错误情况 // 1. Socket.closed 将有错误 // 2. Socket.readable 将关闭，但没有任何数据 if (hasIncomingData === false && retry) { log(`retry`); retry(); // 调用重试函数，尝试重新建立连接 } } /** * 将 Base64 编码的字符串转换为 ArrayBuffer * * @param {string} base64Str Base64 编码的输入字符串 * @returns {{ earlyData: ArrayBuffer | undefined, error: Error | null }} 返回解码后的 ArrayBuffer 或错误 */ function base64ToArrayBuffer(base64Str) { // 如果输入为空，直接返回空结果 if (!base64Str) { return { earlyData: undefined, error: null }; } try { // Go 语言使用了 URL 安全的 Base64 变体（RFC 4648） // 这种变体使用 '-' 和 '_' 来代替标准 Base64 中的 '+' 和 '/' // JavaScript 的 atob 函数不直接支持这种变体，所以我们需要先转换 base64Str = base64Str.replace(/-/g, '+').replace(/_/g, '/'); // 使用 atob 函数解码 Base64 字符串 // atob 将 Base64 编码的 ASCII 字符串转换为原始的二进制字符串 const decode = atob(base64Str); // 将二进制字符串转换为 Uint8Array // 这是通过遍历字符串中的每个字符并获取其 Unicode 编码值（0-255）来完成的 const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0)); // 返回 Uint8Array 的底层 ArrayBuffer // 这是实际的二进制数据，可以用于网络传输或其他二进制操作 return { earlyData: arryBuffer.buffer, error: null }; } catch (error) { // 如果在任何步骤中出现错误（如非法 Base64 字符），则返回错误 return { earlyData: undefined, error }; } } /** * 这不是真正的 YOUKEY 验证，而是一个简化的版本 * @param {string} youkey 要验证的 YOUKEY 字符串 * @returns {boolean} 如果字符串匹配 YOUKEY 格式则返回 true，否则返回 false */ function isValidYouKey(youkey) { // 定义一个正则表达式来匹配 YOUKEY 格式 const youKeyRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; // 使用正则表达式测试 YOUKEY 字符串 return youKeyRegex.test(youkey); } // WebSocket 的两个重要状态常量 const WS_READY_STATE_OPEN = 1; // WebSocket 处于开放状态，可以发送和接收消息 const WS_READY_STATE_CLOSING = 2; // WebSocket 正在关闭过程中 function safeCloseWebSocket(socket) { try { // 只有在 WebSocket 处于开放或正在关闭状态时才调用 close() // 这避免了在已关闭或连接中的 WebSocket 上调用 close() if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) { socket.close(); } } catch (error) { // 记录任何可能发生的错误，虽然按照规范不应该有错误 console.error('safeCloseWebSocket error', error); } } // 预计算 0-255 每个字节的十六进制表示 const byteToHex = []; for (let i = 0; i < 256; ++i) { // (i + 256).toString(16) 确保总是得到两位数的十六进制 // .slice(1) 删除前导的 "1"，只保留两位十六进制数 byteToHex.push((i + 256).toString(16).slice(1)); } /** * 快速地将字节数组转换为 YOUKEY 字符串，不进行有效性检查 * 这是一个底层函数，直接操作字节，不做任何验证 * @param {Uint8Array} arr 包含 YOUKEY 字节的数组 * @param {number} offset 数组中 YOUKEY 开始的位置，默认为 0 * @returns {string} YOUKEY 字符串 */ function unsafeStringify(arr, offset = 0) { // 直接从查找表中获取每个字节的十六进制表示，并拼接成 YOUKEY 格式 // 8-4-4-4-12 的分组是通过精心放置的连字符 "-" 实现的 // toLowerCase() 确保整个 YOUKEY 是小写的 return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); } /** * 将字节数组转换为 YOUKEY 字符串，并验证其有效性 * 这是一个安全的函数，它确保返回的 YOUKEY 格式正确 * @param {Uint8Array} arr 包含 YOUKEY 字节的数组 * @param {number} offset 数组中 YOUKEY 开始的位置，默认为 0 * @returns {string} 有效的 YOUKEY 字符串 * @throws {TypeError} 如果生成的 YOUKEY 字符串无效 */ function stringify(arr, offset = 0) { // 使用不安全的函数快速生成 YOUKEY 字符串 const youkey = unsafeStringify(arr, offset); // 验证生成的 YOUKEY 是否有效 if (!isValidYouKey(youkey)) { // 原：throw TypeError("Stringified YOUKEY is invalid"); throw TypeError(`生成的 YOUKEY 不符合规范 ${youkey}`); //youkey = userID; } return youkey; } /** * 处理 DNS 查询的函数 * @param {ArrayBuffer} udpChunk - 客户端发送的 DNS 查询数据 * @param {ArrayBuffer} vbridgeResponseHeader - vbridge 协议的响应头部数据 * @param {(string)=> void} log - 日志记录函数 */ async function handleDNSQuery(udpChunk, webSocket, vbridgeResponseHeader, log) { // 无论客户端发送到哪个 DNS 服务器，我们总是使用硬编码的服务器 // 因为有些 DNS 服务器不支持 DNS over TCP try { // 选用 Google 的 DNS 服务器（注：后续可能会改为 Cloudflare 的 1.1.1.1） const dnsServer = '8.8.4.4'; // 在 Cloudflare 修复连接自身 IP 的 bug 后，将改为 1.1.1.1 const dnsPort = 53; // DNS 服务的标准端口 let vbridgeHeader = vbridgeResponseHeader; // 保存 vbridge 响应头部，用于后续发送 // 与指定的 DNS 服务器建立 TCP 连接 const tcpSocket = connect({ hostname: dnsServer, port: dnsPort, }); log(`连接到 ${dnsServer}:${dnsPort}`); // 记录连接信息 const writer = tcpSocket.writable.getWriter(); await writer.write(udpChunk); // 将客户端的 DNS 查询数据发送给 DNS 服务器 writer.releaseLock(); // 释放写入器，允许其他部分使用 // 将从 DNS 服务器接收到的响应数据通过 WebSocket 发送回客户端 await tcpSocket.readable.pipeTo(new WritableStream({ async write(chunk) { if (webSocket.readyState === WS_READY_STATE_OPEN) { if (vbridgeHeader) { // 如果有 vbridge 头部，则将其与 DNS 响应数据合并后发送 webSocket.send(await new Blob([vbridgeHeader, chunk]).arrayBuffer()); vbridgeHeader = null; // 头部只发送一次，之后置为 null } else { // 否则直接发送 DNS 响应数据 webSocket.send(chunk); } } }, close() { log(`DNS 服务器(${dnsServer}) TCP 连接已关闭`); // 记录连接关闭信息 }, abort(reason) { console.error(`DNS 服务器(${dnsServer}) TCP 连接异常中断`, reason); // 记录异常中断原因 }, })); } catch (error) { // 捕获并记录任何可能发生的错误 console.error( `handleDNSQuery 函数发生异常，错误信息: ${error.message}` ); } } /** * 建立 SOCKS5 代理连接 * @param {number} addressType 目标地址类型（1: IPv4, 2: 域名, 3: IPv6） * @param {string} addressRemote 目标地址（可以是 IP 或域名） * @param {number} portRemote 目标端口 * @param {function} log 日志记录函数 */ async function socks5Connect(addressType, addressRemote, portRemote, log) { const { username, password, hostname, port } = parsedSocks5Address; // 连接到 SOCKS5 代理服务器 const socket = connect({ hostname, // SOCKS5 服务器的主机名 port, // SOCKS5 服务器的端口 }); // 请求头格式（Worker -> SOCKS5 服务器）: // +----+----------+----------+ // |VER | NMETHODS | METHODS | // +----+----------+----------+ // | 1 | 1 | 1 to 255 | // +----+----------+----------+ // https://en.wikipedia.org/wiki/SOCKS#SOCKS5 // METHODS 字段的含义: // 0x00 不需要认证 // 0x02 用户名/密码认证 https://datatracker.ietf.org/doc/html/rfc1929 const socksGreeting = new Uint8Array([5, 2, 0, 2]); // 5: SOCKS5 版本号, 2: 支持的认证方法数, 0和2: 两种认证方法（无认证和用户名/密码） const writer = socket.writable.getWriter(); await writer.write(socksGreeting); log('已发送 SOCKS5 问候消息'); const reader = socket.readable.getReader(); const encoder = new TextEncoder(); let res = (await reader.read()).value; // 响应格式（SOCKS5 服务器 -> Worker）: // +----+--------+ // |VER | METHOD | // +----+--------+ // | 1 | 1 | // +----+--------+ if (res[0] !== 0x05) { log(`SOCKS5 服务器版本错误: 收到 ${res[0]}，期望是 5`); return; } if (res[1] === 0xff) { log("服务器不接受任何认证方法"); return; } // 如果返回 0x0502，表示需要用户名/密码认证 if (res[1] === 0x02) { log("SOCKS5 服务器需要认证"); if (!username || !password) { log("请提供用户名和密码"); return; } // 认证请求格式: // +----+------+----------+------+----------+ // |VER | ULEN | UNAME | PLEN | PASSWD | // +----+------+----------+------+----------+ // | 1 | 1 | 1 to 255 | 1 | 1 to 255 | // +----+------+----------+------+----------+ const authRequest = new Uint8Array([ 1, // 认证子协议版本 username.length, // 用户名长度 ...encoder.encode(username), // 用户名 password.length, // 密码长度 ...encoder.encode(password) // 密码 ]); await writer.write(authRequest); res = (await reader.read()).value; // 期望返回 0x0100 表示认证成功 if (res[0] !== 0x01 || res[1] !== 0x00) { log("SOCKS5 服务器认证失败"); return; } } // 请求数据格式（Worker -> SOCKS5 服务器）: // +----+-----+-------+------+----------+----------+ // |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT | // +----+-----+-------+------+----------+----------+ // | 1 | 1 | X'00' | 1 | Variable | 2 | // +----+-----+-------+------+----------+----------+ // ATYP: 地址类型 // 0x01: IPv4 地址 // 0x03: 域名 // 0x04: IPv6 地址 // DST.ADDR: 目标地址 // DST.PORT: 目标端口（网络字节序） // addressType // 1 --> IPv4 地址长度 = 4 // 2 --> 域名 // 3 --> IPv6 地址长度 = 16 let DSTADDR; // DSTADDR = ATYP + DST.ADDR switch (addressType) { case 1: // IPv4 DSTADDR = new Uint8Array( [1, ...addressRemote.split('.').map(Number)] ); break; case 2: // 域名 DSTADDR = new Uint8Array( [3, addressRemote.length, ...encoder.encode(addressRemote)] ); break; case 3: // IPv6 DSTADDR = new Uint8Array( [4, ...addressRemote.split(':').flatMap(x => [parseInt(x.slice(0, 2), 16), parseInt(x.slice(2), 16)])] ); break; default: log(`无效的地址类型: ${addressType}`); return; } const socksRequest = new Uint8Array([5, 1, 0, ...DSTADDR, portRemote >> 8, portRemote & 0xff]); // 5: SOCKS5版本, 1: 表示CONNECT请求, 0: 保留字段 // ...DSTADDR: 目标地址, portRemote >> 8 和 & 0xff: 将端口转为网络字节序 await writer.write(socksRequest); log('已发送 SOCKS5 请求'); res = (await reader.read()).value; // 响应格式（SOCKS5 服务器 -> Worker）: // +----+-----+-------+------+----------+----------+ // |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | // +----+-----+-------+------+----------+----------+ // | 1 | 1 | X'00' | 1 | Variable | 2 | // +----+-----+-------+------+----------+----------+ if (res[1] === 0x00) { log("SOCKS5 连接已建立"); } else { log("SOCKS5 连接建立失败"); return; } writer.releaseLock(); reader.releaseLock(); return socket; } /** * SOCKS5 代理地址解析器 * 此函数用于解析 SOCKS5 代理地址字符串，提取出用户名、密码、主机名和端口号 * * @param {string} address SOCKS5 代理地址，格式可以是： * - "username:password@hostname:port" （带认证） * - "hostname:port" （不需认证） * - "username:password@[ipv6]:port" （IPv6 地址需要用方括号括起来） */ function socks5AddressParser(address) { // 使用 "@" 分割地址，分为认证部分和服务器地址部分 // reverse() 是为了处理没有认证信息的情况，确保 latter 总是包含服务器地址 let [latter, former] = address.split("@").reverse(); let username, password, hostname, port; // 如果存在 former 部分，说明提供了认证信息 if (former) { const formers = former.split(":"); if (formers.length !== 2) { throw new Error('无效的 SOCKS 地址格式：认证部分必须是 "username:password" 的形式'); } [username, password] = formers; } // 解析服务器地址部分 const latters = latter.split(":"); // 从末尾提取端口号（因为 IPv6 地址中也包含冒号） port = Number(latters.pop()); if (isNaN(port)) { throw new Error('无效的 SOCKS 地址格式：端口号必须是数字'); } // 剩余部分就是主机名（可能是域名、IPv4 或 IPv6 地址） hostname = latters.join(":"); // 处理 IPv6 地址的特殊情况 // IPv6 地址包含多个冒号，所以必须用方括号括起来，如 [2001:db8::1] const regex = /^\[.*\]$/; if (hostname.includes(":") && !regex.test(hostname)) { throw new Error('无效的 SOCKS 地址格式：IPv6 地址必须用方括号括起来，如 [2001:db8::1]'); } //if (/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(hostname)) hostname = `${atob('d3d3Lg==')}${hostname}${atob('LmlwLjA5MDIyNy54eXo=')}`; // 返回解析后的结果 return { username, // 用户名，如果没有则为 undefined password, // 密码，如果没有则为 undefined hostname, // 主机名，可以是域名、IPv4 或 IPv6 地址 port, // 端口号，已转换为数字类型 } } /** * 双重MD5哈希函数 * 这个函数对输入文本进行两次MD5哈希，增强安全性 * 第二次哈希使用第一次哈希结果的一部分作为输入 * * @param {string} 文本 要哈希的文本 * @returns {Promise} 双重哈希后的小写十六进制字符串 */ async function dHashIt(text) { const encoder = new TextEncoder(); const firstHash = await crypto.subtle.digest('MD5', encoder.encode(text)); const firstHashArray = Array.from(new Uint8Array(firstHash)); const firstHex = firstHashArray.map(byte => byte.toString(16).padStart(2, '0')).join(''); const secondHash = await crypto.subtle.digest('MD5', encoder.encode(firstHex.slice(7, 27))); const secondHashArray = Array.from(new Uint8Array(secondHash)); const secondHex = secondHashArray.map(byte => byte.toString(16).padStart(2, '0')).join(''); return secondHex.toLowerCase(); } async function pLink(pUrl, tUrl) { const urlList = await cleanUp(pUrl); const fullUrl = urlList[Math.floor(Math.random() * urlList.length)]; // 解析目标 URL let parsedUrl = new URL(fullUrl); console.log(parsedUrl); // 提取并可能修改 URL 组件 let protocol = parsedUrl.protocol.slice(0, -1) || 'https'; let hostname = parsedUrl.hostname; let pathname = parsedUrl.pathname; let searchParams = parsedUrl.search; // 处理路径名 if (pathname.charAt(pathname.length - 1) == '/') { pathname = pathname.slice(0, -1); } pathname += tUrl.pathname; // 构建新的 URL let xUrl = `${protocol}://${hostname}${pathname}${searchParams}`; // 反向代理请求 let resp = await fetch(xUrl); // 创建新的响应 let xResponse = new Response(resp.body, { status: resp.status, statusText: resp.statusText, headers: resp.headers }); // 添加自定义头部，包含 URL 信息 //xResponse.headers.set('X-Proxied-By', 'Cloudflare Worker'); //xResponse.headers.set('X-Original-URL', fullUrl); xResponse.headers.set('X-New-URL', xUrl); return xResponse; } async function cleanUp(content) { // 将制表符、双引号、单引号和换行符都替换为逗号 // 然后将连续的多个逗号替换为单个逗号 var replacedContent = content.replace(/[ |"'\r\n]+/g, ',').replace(/,+/g, ','); // 删除开头和结尾的逗号（如果有的话） if (replacedContent.charAt(0) == ',') replacedContent = replacedContent.slice(1); if (replacedContent.charAt(replacedContent.length - 1) == ',') replacedContent = replacedContent.slice(0, replacedContent.length - 1); // 使用逗号分割字符串，得到地址数组 const 地址数组 = replacedContent.split(','); return 地址数组; } let subParams = ['sub', 'base64', 'b64', 'clash', 'singbox', 'sb']; const cmad = decodeURIComponent(atob('dGVsZWdyYW0lMjAlRTQlQkElQTQlRTYlQjUlODElRTclQkUlQTQlMjAlRTYlOEElODAlRTYlOUMlQUYlRTUlQTQlQTclRTQlQkQlQUMlN0UlRTUlOUMlQTglRTclQkElQkYlRTUlOEYlOTElRTclODklOEMhJTNDYnIlM0UKJTNDYSUyMGhyZWYlM0QlMjdodHRwcyUzQSUyRiUyRnQubWUlMkZDTUxpdXNzc3MlMjclM0VodHRwcyUzQSUyRiUyRnQubWUlMkZDTUxpdXNzc3MlM0MlMkZhJTNFJTNDYnIlM0UKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tJTNDYnIlM0UKZ2l0aHViJTIwJUU5JUExJUI5JUU3JTlCJUFFJUU1JTlDJUIwJUU1JTlEJTgwJTIwU3RhciFTdGFyIVN0YXIhISElM0NiciUzRQolM0NhJTIwaHJlZiUzRCUyN2h0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRmNtbGl1JTJGZWRnZXR1bm5lbCUyNyUzRWh0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRmNtbGl1JTJGZWRnZXR1bm5lbCUzQyUyRmElM0UlM0NiciUzRQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0lM0NiciUzRQolMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjM=')); function isValidIPv4(address) { const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/; return ipv4Regex.test(address); } function gDyUID(key) { const tZoneOffset = 8; // 北京时间相对于UTC的时区偏移+8小时 const beginDate = new Date(2007, 6, 7, gUpdateTime, 0, 0); // 固定起始日期为2007年7月7日的凌晨3点 const weekMilliseconds = 1000 * 60 * 60 * 24 * gValidTime; function getCWeeks() { const now = new Date(); const adNow = new Date(now.getTime() + tZoneOffset * 60 * 60 * 1000); const timeDelta = Number(adNow) - Number(beginDate); return Math.ceil(timeDelta / weekMilliseconds); } function gYouKey(baseStr) { const hashBuffer = new TextEncoder().encode(baseStr); return crypto.subtle.digest('SHA-256', hashBuffer).then((hash) => { const hashArray = Array.from(new Uint8Array(hash)); const hexHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join(''); return `${hexHash.substr(0, 8)}-${hexHash.substr(8, 4)}-4${hexHash.substr(13, 3)}-${(parseInt(hexHash.substr(16, 2), 16) & 0x3f | 0x80).toString(16)}${hexHash.substr(18, 2)}-${hexHash.substr(20, 12)}`; }); } const currentWeeks = getCWeeks(); // 获取当前周数 const endTime = new Date(beginDate.getTime() + currentWeeks * weekMilliseconds); // 生成两个 YOUKEY const currentYOUKEYPromise = gYouKey(key + currentWeeks); const previousYOUKEYPromise = gYouKey(key + (currentWeeks - 1)); // 格式化到期时间 const expirationTimeUTC = new Date(endTime.getTime() - tZoneOffset * 60 * 60 * 1000); // UTC时间 const expirationTimeString = `到期时间(UTC): ${expirationTimeUTC.toISOString().slice(0, 19).replace('T', ' ')} (UTC+8): ${endTime.toISOString().slice(0, 19).replace('T', ' ')}\n`; return Promise.all([currentYOUKEYPromise, previousYOUKEYPromise, expirationTimeString]); }