1179 lines
49 KiB
JavaScript
1179 lines
49 KiB
JavaScript
|
||
import { connect } from 'cloudflare:sockets';
|
||
|
||
let userID = '';
|
||
let proxyIP = '';
|
||
let sub = '';
|
||
let subConverter = 'SUBAPI.fxxk.dedyn.io';
|
||
let subConfig = "https://raw.githubusercontent.com/ACL4SSR/ACL4SSR/master/Clash/config/ACL4SSR_Online_Mini_MultiMode.ini";
|
||
let subProtocol = 'https';
|
||
let subEmoji = 'true';
|
||
let socks5Address = '';
|
||
let parsedSocks5Address = {};
|
||
let enableSocks = false;
|
||
|
||
let fakeUserID;
|
||
let fakeHostName;
|
||
let noTLS = 'false';
|
||
const expire = 4102329600;//2099-12-31
|
||
let proxyIPs;
|
||
let socks5s;
|
||
let go2Socks5s = [
|
||
'*ttvnw.net',
|
||
'*tapecontent.net',
|
||
'*cloudatacdn.com',
|
||
'*.loadshare.org',
|
||
];
|
||
let addresses = [];
|
||
let addressesapi = [];
|
||
let addressesnotls = [];
|
||
let addressesnotlsapi = [];
|
||
let addressescsv = [];
|
||
let DLS = 8;
|
||
let remarkIndex = 1;//CSV备注所在列偏移量
|
||
let FileName = atob('ZWRnZXR1bm5lbA==');
|
||
let BotToken;
|
||
let ChatID;
|
||
let proxyhosts = [];
|
||
let proxyhostsURL = '';
|
||
let RproxyIP = 'false';
|
||
let httpsPorts = ["2053", "2083", "2087", "2096", "8443"];
|
||
let gValidTime = 7;
|
||
let gUpdateTime = 3;
|
||
let userIDLow;
|
||
let userIDTime = "";
|
||
let proxyIPPool = [];
|
||
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.UUID || env.uuid || env.PASSWORD || env.pswd || userID;
|
||
if (env.KEY || env.TOKEN || (userID && !isValidUUID(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('请设置你的UUID变量，或尝试重试部署，检查变量是否生效？', {
|
||
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)}`;
|
||
|
||
proxyIP = env.PROXYIP || env.proxyip || proxyIP;
|
||
proxyIPs = await cleanUp(proxyIP);
|
||
proxyIP = 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 || !proxyIP ? 'true' : 'false';
|
||
enableSocks = false;
|
||
}
|
||
} else {
|
||
RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false';
|
||
}
|
||
|
||
const upgradeHeader = request.headers.get('Upgrade');
|
||
const url = new URL(request.url);
|
||
if (!upgradeHeader || upgradeHeader !== 'websocket') {
|
||
if (env.ADD) addresses = await cleanUp(env.ADD);
|
||
if (env.ADDAPI) addressesapi = await cleanUp(env.ADDAPI);
|
||
if (env.ADDNOTLS) addressesnotls = await cleanUp(env.ADDNOTLS);
|
||
if (env.ADDNOTLSAPI) addressesnotlsapi = await cleanUp(env.ADDNOTLSAPI);
|
||
if (env.ADDCSV) addressescsv = await cleanUp(env.ADDCSV);
|
||
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;
|
||
subConverter = env.SUBAPI || subConverter;
|
||
if (subConverter.includes("http://")) {
|
||
subConverter = subConverter.split("//")[1];
|
||
subProtocol = 'http';
|
||
} else {
|
||
subConverter = subConverter.split("//")[1] || subConverter;
|
||
}
|
||
subConfig = env.SUBCONFIG || subConfig;
|
||
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')) {
|
||
proxyIP = url.searchParams.get('proxyip');
|
||
enableSocks = false;
|
||
} else if (new RegExp('/proxyip=', 'i').test(url.pathname)) {
|
||
proxyIP = url.pathname.toLowerCase().split('/proxyip=')[1];
|
||
enableSocks = false;
|
||
} else if (new RegExp('/proxyip.', 'i').test(url.pathname)) {
|
||
proxyIP = `proxyip.${url.pathname.toLowerCase().split("/proxyip.")[1]}`;
|
||
enableSocks = false;
|
||
} else if (new RegExp('/pyip=', 'i').test(url.pathname)) {
|
||
proxyIP = 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 (!proxyIP || proxyIP == '') {
|
||
proxyIP = atob(`UFJPWFlJUC50cDEuZnh4ay5kZWR5bi5pbw==`);
|
||
} else if (proxyIP.includes(']:')) {
|
||
portRemote = proxyIP.split(']:')[1] || portRemote;
|
||
proxyIP = proxyIP.split(']:')[0] || proxyIP;
|
||
} else if (proxyIP.split(':').length === 2) {
|
||
portRemote = proxyIP.split(':')[1] || portRemote;
|
||
proxyIP = proxyIP.split(':')[0] || proxyIP;
|
||
}
|
||
if (proxyIP.includes('.tp')) portRemote = proxyIP.split('.tp')[1].split('.')[0] || portRemote;
|
||
tcpSocket = await connectAndWrite(proxyIP || 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 };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 这不是真正的 UUID 验证，而是一个简化的版本
|
||
* @param {string} uuid 要验证的 UUID 字符串
|
||
* @returns {boolean} 如果字符串匹配 UUID 格式则返回 true，否则返回 false
|
||
*/
|
||
function isValidUUID(uuid) {
|
||
// 定义一个正则表达式来匹配 UUID 格式
|
||
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
|
||
|
||
// 使用正则表达式测试 UUID 字符串
|
||
return uuidRegex.test(uuid);
|
||
}
|
||
|
||
// 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));
|
||
}
|
||
|
||
/**
|
||
* 快速地将字节数组转换为 UUID 字符串，不进行有效性检查
|
||
* 这是一个底层函数，直接操作字节，不做任何验证
|
||
* @param {Uint8Array} arr 包含 UUID 字节的数组
|
||
* @param {number} offset 数组中 UUID 开始的位置，默认为 0
|
||
* @returns {string} UUID 字符串
|
||
*/
|
||
function unsafeStringify(arr, offset = 0) {
|
||
// 直接从查找表中获取每个字节的十六进制表示，并拼接成 UUID 格式
|
||
// 8-4-4-4-12 的分组是通过精心放置的连字符 "-" 实现的
|
||
// toLowerCase() 确保整个 UUID 是小写的
|
||
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();
|
||
}
|
||
|
||
/**
|
||
* 将字节数组转换为 UUID 字符串，并验证其有效性
|
||
* 这是一个安全的函数，它确保返回的 UUID 格式正确
|
||
* @param {Uint8Array} arr 包含 UUID 字节的数组
|
||
* @param {number} offset 数组中 UUID 开始的位置，默认为 0
|
||
* @returns {string} 有效的 UUID 字符串
|
||
* @throws {TypeError} 如果生成的 UUID 字符串无效
|
||
*/
|
||
function stringify(arr, offset = 0) {
|
||
// 使用不安全的函数快速生成 UUID 字符串
|
||
const uuid = unsafeStringify(arr, offset);
|
||
// 验证生成的 UUID 是否有效
|
||
if (!isValidUUID(uuid)) {
|
||
// 原：throw TypeError("Stringified UUID is invalid");
|
||
throw TypeError(`生成的 UUID 不符合规范 ${uuid}`);
|
||
//uuid = userID;
|
||
}
|
||
return uuid;
|
||
}
|
||
|
||
/**
|
||
* 处理 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<string>} 双重哈希后的小写十六进制字符串
|
||
*/
|
||
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 gUID(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);
|
||
|
||
// 生成两个 UUID
|
||
const currentUUIDPromise = gUID(key + currentWeeks);
|
||
const previousUUIDPromise = gUID(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([currentUUIDPromise, previousUUIDPromise, expirationTimeString]);
|
||
}
|