mirror of
https://github.com/lush2020/edgetunnel.git
synced 2026-03-22 01:22:21 +08:00
1425 lines
46 KiB
JavaScript
1425 lines
46 KiB
JavaScript
// <!--GAMFC-->version base on commit 43fad05dcdae3b723c53c226f8181fc5bd47223e, time is 2023-06-22 15:20:05 UTC<!--GAMFC-END-->.
|
||
// @ts-ignore
|
||
import { connect } from 'cloudflare:sockets';
|
||
|
||
// How to generate your own UUID:
|
||
// [Windows] Press "Win + R", input cmd and run: Powershell -NoExit -Command "[guid]::NewGuid()"
|
||
let userID = '90cd4a77-141a-43c9-991b-08263cfe9c10';
|
||
|
||
let proxyIP = '';// 小白勿动，该地址并不影响你的网速，这是给CF代理使用的。'cdn.xn--b6gac.eu.org, cdn-all.xn--b6gac.eu.org, workers.cloudflare.cyou'
|
||
|
||
let sub = '';// 留空则使用内置订阅
|
||
let subconverter = 'apiurl.v1.mk';// clash订阅转换后端，目前使用肥羊的订阅转换功能。自带虚假uuid和host订阅。
|
||
let subconfig = "https://raw.githubusercontent.com/cmliu/ACL4SSR/main/Clash/config/ACL4SSR_Online_Full_MultiMode.ini"; //订阅配置文件
|
||
|
||
// The user name and password do not contain special characters
|
||
// Setting the address will ignore proxyIP
|
||
// Example: user:pass@host:port or host:port
|
||
let socks5Address = '';
|
||
|
||
if (!isValidUUID(userID)) {
|
||
throw new Error('uuid is not valid');
|
||
}
|
||
|
||
let parsedSocks5Address = {};
|
||
let enableSocks = false;
|
||
|
||
// 虚假uuid和hostname，用于发送给配置生成服务
|
||
let fakeUserID = generateUUID();
|
||
let fakeHostName = generateRandomString();
|
||
let noTLS = 'false';
|
||
const expire = 4102329600;//2099-12-31
|
||
let proxyIPs;
|
||
let addresses = [];
|
||
let addressesapi = [];
|
||
let addressesnotls = [];
|
||
let addressesnotlsapi = [];
|
||
let addressescsv = [];
|
||
let DLS = 8;
|
||
let FileName = 'edgetunnel';
|
||
let BotToken ='';
|
||
let ChatID ='';
|
||
let proxyhosts = [];//本地代理域名池
|
||
let proxyhostsURL = 'https://raw.githubusercontent.com/cmliu/CFcdnVmess2sub/main/proxyhosts';//在线代理域名池URL
|
||
let RproxyIP = 'false';
|
||
export default {
|
||
/**
|
||
* @param {import("@cloudflare/workers-types").Request} request
|
||
* @param {{UUID: string, PROXYIP: string}} env
|
||
* @param {import("@cloudflare/workers-types").ExecutionContext} ctx
|
||
* @returns {Promise<Response>}
|
||
*/
|
||
async fetch(request, env, ctx) {
|
||
try {
|
||
const UA = request.headers.get('User-Agent') || 'null';
|
||
const userAgent = UA.toLowerCase();
|
||
userID = (env.UUID || userID).toLowerCase();
|
||
proxyIP = env.PROXYIP || proxyIP;
|
||
proxyIPs = await ADD(proxyIP);
|
||
proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];
|
||
//console.log(proxyIP);
|
||
socks5Address = env.SOCKS5 || socks5Address;
|
||
sub = env.SUB || sub;
|
||
subconverter = env.SUBAPI || subconverter;
|
||
subconfig = env.SUBCONFIG || subconfig;
|
||
if (socks5Address) {
|
||
RproxyIP = env.RPROXYIP || 'false';
|
||
try {
|
||
parsedSocks5Address = socks5AddressParser(socks5Address);
|
||
enableSocks = true;
|
||
} catch (err) {
|
||
/** @type {Error} */ let e = err;
|
||
console.log(e.toString());
|
||
enableSocks = false;
|
||
}
|
||
} else {
|
||
RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false';
|
||
}
|
||
if (env.ADD) addresses = await ADD(env.ADD);
|
||
if (env.ADDAPI) addressesapi = await ADD(env.ADDAPI);
|
||
if (env.ADDNOTLS) addressesnotls = await ADD(env.ADDNOTLS);
|
||
if (env.ADDNOTLSAPI) addressesnotlsapi = await ADD(env.ADDNOTLSAPI);
|
||
if (env.ADDCSV) addressescsv = await ADD(env.ADDCSV);
|
||
DLS = env.DLS || DLS;
|
||
BotToken = env.TGTOKEN || BotToken;
|
||
ChatID = env.TGID || ChatID;
|
||
const upgradeHeader = request.headers.get('Upgrade');
|
||
const url = new URL(request.url);
|
||
if (url.searchParams.has('notls')) noTLS = 'true';
|
||
if (!upgradeHeader || upgradeHeader !== 'websocket') {
|
||
// const url = new URL(request.url);
|
||
switch (url.pathname.toLowerCase()) {
|
||
case '/':
|
||
const envKey = env.URL302 ? 'URL302' : (env.URL ? 'URL' : null);
|
||
if (envKey) {
|
||
const URLs = await ADD(env[envKey]);
|
||
const URL = URLs[Math.floor(Math.random() * URLs.length)];
|
||
return envKey === 'URL302' ? Response.redirect(URL, 302) : fetch(new Request(URL, request));
|
||
}
|
||
return new Response(JSON.stringify(request.cf, null, 4), { status: 200 });
|
||
case `/${userID}`: {
|
||
await sendMessage(`#获取订阅 ${FileName}`, request.headers.get('CF-Connecting-IP'), `UA: ${UA}</tg-spoiler>\n域名: ${url.hostname}\n<tg-spoiler>入口: ${url.pathname + url.search}</tg-spoiler>`);
|
||
if ((!sub || sub == '') && (addresses.length + addressesapi.length + addressesnotls.length + addressesnotlsapi.length + addressescsv.length) == 0) sub = 'vless-4ca.pages.dev';
|
||
const vlessConfig = await getVLESSConfig(userID, request.headers.get('Host'), sub, UA, RproxyIP, url);
|
||
const now = Date.now();
|
||
//const timestamp = Math.floor(now / 1000);
|
||
const today = new Date(now);
|
||
today.setHours(0, 0, 0, 0);
|
||
const UD = Math.floor(((now - today.getTime())/86400000) * 24 * 1099511627776 / 2);
|
||
let pagesSum = UD;
|
||
let workersSum = UD;
|
||
let total = 24 * 1099511627776 ;
|
||
if (env.CFEMAIL && env.CFKEY){
|
||
const email = env.CFEMAIL;
|
||
const key = env.CFKEY;
|
||
const accountIndex = env.CFID || 0;
|
||
const accountId = await getAccountId(email, key);
|
||
if (accountId){
|
||
const now = new Date()
|
||
now.setUTCHours(0, 0, 0, 0)
|
||
const startDate = now.toISOString()
|
||
const endDate = new Date().toISOString();
|
||
const Sum = await getSum(accountId, accountIndex, email, key, startDate, endDate);
|
||
pagesSum = Sum[0];
|
||
workersSum = Sum[1];
|
||
total = 102400 ;
|
||
}
|
||
}
|
||
//console.log(`pagesSum: ${pagesSum}\nworkersSum: ${workersSum}\ntotal: ${total}`);
|
||
if (userAgent && userAgent.includes('mozilla')){
|
||
return new Response(`${vlessConfig}`, {
|
||
status: 200,
|
||
headers: {
|
||
"Content-Type": "text/plain;charset=utf-8",
|
||
"Profile-Update-Interval": "6",
|
||
"Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`,
|
||
}
|
||
});
|
||
} else {
|
||
return new Response(`${vlessConfig}`, {
|
||
status: 200,
|
||
headers: {
|
||
"Content-Disposition": `attachment; filename=${FileName}; filename*=utf-8''${encodeURIComponent(FileName)}`,
|
||
"Content-Type": "text/plain;charset=utf-8",
|
||
"Profile-Update-Interval": "6",
|
||
"Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`,
|
||
}
|
||
});
|
||
}
|
||
}
|
||
default:
|
||
return new Response('Not found', { status: 404 });
|
||
}
|
||
} else {
|
||
proxyIP = url.searchParams.get('proxyip') || proxyIP;
|
||
if (new RegExp('/proxyip=', 'i').test(url.pathname)) proxyIP = url.pathname.toLowerCase().split('/proxyip=')[1];
|
||
else if (new RegExp('/proxyip.', 'i').test(url.pathname)) proxyIP = `proxyip.${url.pathname.toLowerCase().split("/proxyip.")[1]}`;
|
||
else if (!proxyIP || proxyIP == '') proxyIP = 'proxyip.fxxk.dedyn.io';
|
||
return await vlessOverWSHandler(request);
|
||
}
|
||
} catch (err) {
|
||
/** @type {Error} */ let e = err;
|
||
return new Response(e.toString());
|
||
}
|
||
},
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @param {import("@cloudflare/workers-types").Request} request
|
||
*/
|
||
async function vlessOverWSHandler(request) {
|
||
|
||
/** @type {import("@cloudflare/workers-types").WebSocket[]} */
|
||
// @ts-ignore
|
||
const webSocketPair = new WebSocketPair();
|
||
const [client, webSocket] = Object.values(webSocketPair);
|
||
|
||
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') || '';
|
||
|
||
const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log);
|
||
|
||
/** @type {{ value: import("@cloudflare/workers-types").Socket | null}}*/
|
||
let remoteSocketWapper = {
|
||
value: null,
|
||
};
|
||
let isDns = false;
|
||
|
||
// ws --> remote
|
||
readableWebSocketStream.pipeTo(new WritableStream({
|
||
async write(chunk, controller) {
|
||
if (isDns) {
|
||
return await handleDNSQuery(chunk, webSocket, null, log);
|
||
}
|
||
if (remoteSocketWapper.value) {
|
||
const writer = remoteSocketWapper.value.writable.getWriter()
|
||
await writer.write(chunk);
|
||
writer.releaseLock();
|
||
return;
|
||
}
|
||
|
||
const {
|
||
hasError,
|
||
message,
|
||
addressType,
|
||
portRemote = 443,
|
||
addressRemote = '',
|
||
rawDataIndex,
|
||
vlessVersion = new Uint8Array([0, 0]),
|
||
isUDP,
|
||
} = processVlessHeader(chunk, userID);
|
||
address = addressRemote;
|
||
portWithRandomLog = `${portRemote}--${Math.random()} ${isUDP ? 'udp ' : 'tcp '
|
||
} `;
|
||
if (hasError) {
|
||
// controller.error(message);
|
||
throw new Error(message); // cf seems has bug, controller.error will not end stream
|
||
// webSocket.close(1000, message);
|
||
return;
|
||
}
|
||
// if UDP but port not DNS port, close it
|
||
if (isUDP) {
|
||
if (portRemote === 53) {
|
||
isDns = true;
|
||
} else {
|
||
// controller.error('UDP proxy only enable for DNS which is port 53');
|
||
throw new Error('UDP proxy only enable for DNS which is port 53'); // cf seems has bug, controller.error will not end stream
|
||
return;
|
||
}
|
||
}
|
||
// ["version", "附加信息长度 N"]
|
||
const vlessResponseHeader = new Uint8Array([vlessVersion[0], 0]);
|
||
const rawClientData = chunk.slice(rawDataIndex);
|
||
|
||
if (isDns) {
|
||
return handleDNSQuery(rawClientData, webSocket, vlessResponseHeader, log);
|
||
}
|
||
handleTCPOutBound(remoteSocketWapper, addressType, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log);
|
||
},
|
||
close() {
|
||
log(`readableWebSocketStream is close`);
|
||
},
|
||
abort(reason) {
|
||
log(`readableWebSocketStream is abort`, JSON.stringify(reason));
|
||
},
|
||
})).catch((err) => {
|
||
log('readableWebSocketStream pipeTo error', err);
|
||
});
|
||
|
||
return new Response(null, {
|
||
status: 101,
|
||
// @ts-ignore
|
||
webSocket: client,
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Handles outbound TCP connections.
|
||
*
|
||
* @param {any} remoteSocket
|
||
* @param {number} addressType The remote address type to connect to.
|
||
* @param {string} addressRemote The remote address to connect to.
|
||
* @param {number} portRemote The remote port to connect to.
|
||
* @param {Uint8Array} rawClientData The raw client data to write.
|
||
* @param {import("@cloudflare/workers-types").WebSocket} webSocket The WebSocket to pass the remote socket to.
|
||
* @param {Uint8Array} vlessResponseHeader The VLESS response header.
|
||
* @param {function} log The logging function.
|
||
* @returns {Promise<void>} The remote socket.
|
||
*/
|
||
async function handleTCPOutBound(remoteSocket, addressType, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log,) {
|
||
async function connectAndWrite(address, port, socks = false) {
|
||
/** @type {import("@cloudflare/workers-types").Socket} */
|
||
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();
|
||
await writer.write(rawClientData); // first write, normal is tls client hello
|
||
writer.releaseLock();
|
||
return tcpSocket;
|
||
}
|
||
|
||
// if the cf connect tcp socket have no incoming data, we retry to redirect ip
|
||
async function retry() {
|
||
if (enableSocks) {
|
||
tcpSocket = await connectAndWrite(addressRemote, portRemote, true);
|
||
} else {
|
||
tcpSocket = await connectAndWrite(proxyIP || addressRemote, portRemote);
|
||
}
|
||
// no matter retry success or not, close websocket
|
||
tcpSocket.closed.catch(error => {
|
||
console.log('retry tcpSocket closed error', error);
|
||
}).finally(() => {
|
||
safeCloseWebSocket(webSocket);
|
||
})
|
||
remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, null, log);
|
||
}
|
||
|
||
let tcpSocket = await connectAndWrite(addressRemote, portRemote);
|
||
|
||
// when remoteSocket is ready, pass to websocket
|
||
// remote--> ws
|
||
remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, retry, log);
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param {import("@cloudflare/workers-types").WebSocket} webSocketServer
|
||
* @param {string} earlyDataHeader for ws 0rtt
|
||
* @param {(info: string)=> void} log for ws 0rtt
|
||
*/
|
||
function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) {
|
||
let readableStreamCancel = false;
|
||
const stream = new ReadableStream({
|
||
start(controller) {
|
||
webSocketServer.addEventListener('message', (event) => {
|
||
if (readableStreamCancel) {
|
||
return;
|
||
}
|
||
const message = event.data;
|
||
controller.enqueue(message);
|
||
});
|
||
|
||
// The event means that the client closed the client -> server stream.
|
||
// However, the server -> client stream is still open until you call close() on the server side.
|
||
// The WebSocket protocol says that a separate close message must be sent in each direction to fully close the socket.
|
||
webSocketServer.addEventListener('close', () => {
|
||
// client send close, need close server
|
||
// if stream is cancel, skip controller.close
|
||
safeCloseWebSocket(webSocketServer);
|
||
if (readableStreamCancel) {
|
||
return;
|
||
}
|
||
controller.close();
|
||
}
|
||
);
|
||
webSocketServer.addEventListener('error', (err) => {
|
||
log('webSocketServer has error');
|
||
controller.error(err);
|
||
}
|
||
);
|
||
// for ws 0rtt
|
||
const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader);
|
||
if (error) {
|
||
controller.error(error);
|
||
} else if (earlyData) {
|
||
controller.enqueue(earlyData);
|
||
}
|
||
},
|
||
|
||
pull(controller) {
|
||
// if ws can stop read if stream is full, we can implement backpressure
|
||
// https://streams.spec.whatwg.org/#example-rs-push-backpressure
|
||
},
|
||
cancel(reason) {
|
||
// 1. pipe WritableStream has error, this cancel will called, so ws handle server close into here
|
||
// 2. if readableStream is cancel, all controller.close/enqueue need skip,
|
||
// 3. but from testing controller.error still work even if readableStream is cancel
|
||
if (readableStreamCancel) {
|
||
return;
|
||
}
|
||
log(`ReadableStream was canceled, due to ${reason}`)
|
||
readableStreamCancel = true;
|
||
safeCloseWebSocket(webSocketServer);
|
||
}
|
||
});
|
||
|
||
return stream;
|
||
|
||
}
|
||
|
||
// https://xtls.github.io/development/protocols/vless.html
|
||
// https://github.com/zizifn/excalidraw-backup/blob/main/v2ray-protocol.excalidraw
|
||
|
||
/**
|
||
*
|
||
* @param { ArrayBuffer} vlessBuffer
|
||
* @param {string} userID
|
||
* @returns
|
||
*/
|
||
function processVlessHeader(vlessBuffer, userID) {
|
||
if (vlessBuffer.byteLength < 24) {
|
||
return {
|
||
hasError: true,
|
||
message: 'invalid data',
|
||
};
|
||
}
|
||
const version = new Uint8Array(vlessBuffer.slice(0, 1));
|
||
let isValidUser = false;
|
||
let isUDP = false;
|
||
if (stringify(new Uint8Array(vlessBuffer.slice(1, 17))) === userID) {
|
||
isValidUser = true;
|
||
}
|
||
if (!isValidUser) {
|
||
return {
|
||
hasError: true,
|
||
message: 'invalid user',
|
||
};
|
||
}
|
||
|
||
const optLength = new Uint8Array(vlessBuffer.slice(17, 18))[0];
|
||
//skip opt for now
|
||
|
||
const command = new Uint8Array(
|
||
vlessBuffer.slice(18 + optLength, 18 + optLength + 1)
|
||
)[0];
|
||
|
||
// 0x01 TCP
|
||
// 0x02 UDP
|
||
// 0x03 MUX
|
||
if (command === 1) {
|
||
} else if (command === 2) {
|
||
isUDP = true;
|
||
} else {
|
||
return {
|
||
hasError: true,
|
||
message: `command ${command} is not support, command 01-tcp,02-udp,03-mux`,
|
||
};
|
||
}
|
||
const portIndex = 18 + optLength + 1;
|
||
const portBuffer = vlessBuffer.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(
|
||
vlessBuffer.slice(addressIndex, addressIndex + 1)
|
||
);
|
||
|
||
// 1--> ipv4 addressLength =4
|
||
// 2--> domain name addressLength=addressBuffer[1]
|
||
// 3--> ipv6 addressLength =16
|
||
const addressType = addressBuffer[0];
|
||
let addressLength = 0;
|
||
let addressValueIndex = addressIndex + 1;
|
||
let addressValue = '';
|
||
switch (addressType) {
|
||
case 1:
|
||
addressLength = 4;
|
||
addressValue = new Uint8Array(
|
||
vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
|
||
).join('.');
|
||
break;
|
||
case 2:
|
||
addressLength = new Uint8Array(
|
||
vlessBuffer.slice(addressValueIndex, addressValueIndex + 1)
|
||
)[0];
|
||
addressValueIndex += 1;
|
||
addressValue = new TextDecoder().decode(
|
||
vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
|
||
);
|
||
break;
|
||
case 3:
|
||
addressLength = 16;
|
||
const dataView = new DataView(
|
||
vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
|
||
);
|
||
// 2001:0db8:85a3:0000:0000:8a2e:0370:7334
|
||
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,
|
||
vlessVersion: version,
|
||
isUDP,
|
||
};
|
||
}
|
||
|
||
|
||
/**
|
||
*
|
||
* @param {import("@cloudflare/workers-types").Socket} remoteSocket
|
||
* @param {import("@cloudflare/workers-types").WebSocket} webSocket
|
||
* @param {ArrayBuffer} vlessResponseHeader
|
||
* @param {(() => Promise<void>) | null} retry
|
||
* @param {*} log
|
||
*/
|
||
async function remoteSocketToWS(remoteSocket, webSocket, vlessResponseHeader, retry, log) {
|
||
// remote--> ws
|
||
let remoteChunkCount = 0;
|
||
let chunks = [];
|
||
/** @type {ArrayBuffer | null} */
|
||
let vlessHeader = vlessResponseHeader;
|
||
let hasIncomingData = false; // check if remoteSocket has incoming data
|
||
await remoteSocket.readable
|
||
.pipeTo(
|
||
new WritableStream({
|
||
start() {
|
||
},
|
||
/**
|
||
*
|
||
* @param {Uint8Array} chunk
|
||
* @param {*} controller
|
||
*/
|
||
async write(chunk, controller) {
|
||
hasIncomingData = true;
|
||
// remoteChunkCount++;
|
||
if (webSocket.readyState !== WS_READY_STATE_OPEN) {
|
||
controller.error(
|
||
'webSocket.readyState is not open, maybe close'
|
||
);
|
||
}
|
||
if (vlessHeader) {
|
||
webSocket.send(await new Blob([vlessHeader, chunk]).arrayBuffer());
|
||
vlessHeader = null;
|
||
} else {
|
||
// seems no need rate limit this, CF seems fix this??..
|
||
// 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}`);
|
||
// safeCloseWebSocket(webSocket); // no need server close websocket frist for some case will casue HTTP ERR_CONTENT_LENGTH_MISMATCH issue, client will send close event anyway.
|
||
},
|
||
abort(reason) {
|
||
console.error(`remoteConnection!.readable abort`, reason);
|
||
},
|
||
})
|
||
)
|
||
.catch((error) => {
|
||
console.error(
|
||
`remoteSocketToWS has exception `,
|
||
error.stack || error
|
||
);
|
||
safeCloseWebSocket(webSocket);
|
||
});
|
||
|
||
// seems is cf connect socket have error,
|
||
// 1. Socket.closed will have error
|
||
// 2. Socket.readable will be close without any data coming
|
||
if (hasIncomingData === false && retry) {
|
||
log(`retry`)
|
||
retry();
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param {string} base64Str
|
||
* @returns
|
||
*/
|
||
function base64ToArrayBuffer(base64Str) {
|
||
if (!base64Str) {
|
||
return { error: null };
|
||
}
|
||
try {
|
||
// go use modified Base64 for URL rfc4648 which js atob not support
|
||
base64Str = base64Str.replace(/-/g, '+').replace(/_/g, '/');
|
||
const decode = atob(base64Str);
|
||
const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0));
|
||
return { earlyData: arryBuffer.buffer, error: null };
|
||
} catch (error) {
|
||
return { error };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* This is not real UUID validation
|
||
* @param {string} uuid
|
||
*/
|
||
function isValidUUID(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;
|
||
return uuidRegex.test(uuid);
|
||
}
|
||
|
||
const WS_READY_STATE_OPEN = 1;
|
||
const WS_READY_STATE_CLOSING = 2;
|
||
/**
|
||
* Normally, WebSocket will not has exceptions when close.
|
||
* @param {import("@cloudflare/workers-types").WebSocket} socket
|
||
*/
|
||
function safeCloseWebSocket(socket) {
|
||
try {
|
||
if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) {
|
||
socket.close();
|
||
}
|
||
} catch (error) {
|
||
console.error('safeCloseWebSocket error', error);
|
||
}
|
||
}
|
||
|
||
const byteToHex = [];
|
||
for (let i = 0; i < 256; ++i) {
|
||
byteToHex.push((i + 256).toString(16).slice(1));
|
||
}
|
||
function unsafeStringify(arr, offset = 0) {
|
||
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();
|
||
}
|
||
function stringify(arr, offset = 0) {
|
||
const uuid = unsafeStringify(arr, offset);
|
||
if (!isValidUUID(uuid)) {
|
||
throw TypeError("Stringified UUID is invalid");
|
||
}
|
||
return uuid;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param {ArrayBuffer} udpChunk
|
||
* @param {import("@cloudflare/workers-types").WebSocket} webSocket
|
||
* @param {ArrayBuffer} vlessResponseHeader
|
||
* @param {(string)=> void} log
|
||
*/
|
||
async function handleDNSQuery(udpChunk, webSocket, vlessResponseHeader, log) {
|
||
// no matter which DNS server client send, we alwasy use hard code one.
|
||
// beacsue someof DNS server is not support DNS over TCP
|
||
try {
|
||
const dnsServer = '8.8.4.4'; // change to 1.1.1.1 after cf fix connect own ip bug
|
||
const dnsPort = 53;
|
||
/** @type {ArrayBuffer | null} */
|
||
let vlessHeader = vlessResponseHeader;
|
||
/** @type {import("@cloudflare/workers-types").Socket} */
|
||
const tcpSocket = connect({
|
||
hostname: dnsServer,
|
||
port: dnsPort,
|
||
});
|
||
|
||
log(`connected to ${dnsServer}:${dnsPort}`);
|
||
const writer = tcpSocket.writable.getWriter();
|
||
await writer.write(udpChunk);
|
||
writer.releaseLock();
|
||
await tcpSocket.readable.pipeTo(new WritableStream({
|
||
async write(chunk) {
|
||
if (webSocket.readyState === WS_READY_STATE_OPEN) {
|
||
if (vlessHeader) {
|
||
webSocket.send(await new Blob([vlessHeader, chunk]).arrayBuffer());
|
||
vlessHeader = null;
|
||
} else {
|
||
webSocket.send(chunk);
|
||
}
|
||
}
|
||
},
|
||
close() {
|
||
log(`dns server(${dnsServer}) tcp is close`);
|
||
},
|
||
abort(reason) {
|
||
console.error(`dns server(${dnsServer}) tcp is abort`, reason);
|
||
},
|
||
}));
|
||
} catch (error) {
|
||
console.error(
|
||
`handleDNSQuery have exception, error: ${error.message}`
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param {number} addressType
|
||
* @param {string} addressRemote
|
||
* @param {number} portRemote
|
||
* @param {function} log The logging function.
|
||
*/
|
||
async function socks5Connect(addressType, addressRemote, portRemote, log) {
|
||
const { username, password, hostname, port } = parsedSocks5Address;
|
||
// Connect to the SOCKS server
|
||
const socket = connect({
|
||
hostname,
|
||
port,
|
||
});
|
||
|
||
// Request head format (Worker -> Socks Server):
|
||
// +----+----------+----------+
|
||
// |VER | NMETHODS | METHODS |
|
||
// +----+----------+----------+
|
||
// | 1 | 1 | 1 to 255 |
|
||
// +----+----------+----------+
|
||
|
||
// https://en.wikipedia.org/wiki/SOCKS#SOCKS5
|
||
// For METHODS:
|
||
// 0x00 NO AUTHENTICATION REQUIRED
|
||
// 0x02 USERNAME/PASSWORD https://datatracker.ietf.org/doc/html/rfc1929
|
||
const socksGreeting = new Uint8Array([5, 2, 0, 2]);
|
||
|
||
const writer = socket.writable.getWriter();
|
||
|
||
await writer.write(socksGreeting);
|
||
log('sent socks greeting');
|
||
|
||
const reader = socket.readable.getReader();
|
||
const encoder = new TextEncoder();
|
||
let res = (await reader.read()).value;
|
||
// Response format (Socks Server -> Worker):
|
||
// +----+--------+
|
||
// |VER | METHOD |
|
||
// +----+--------+
|
||
// | 1 | 1 |
|
||
// +----+--------+
|
||
if (res[0] !== 0x05) {
|
||
log(`socks server version error: ${res[0]} expected: 5`);
|
||
return;
|
||
}
|
||
if (res[1] === 0xff) {
|
||
log("no acceptable methods");
|
||
return;
|
||
}
|
||
|
||
// if return 0x0502
|
||
if (res[1] === 0x02) {
|
||
log("socks server needs auth");
|
||
if (!username || !password) {
|
||
log("please provide username/password");
|
||
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;
|
||
// expected 0x0100
|
||
if (res[0] !== 0x01 || res[1] !== 0x00) {
|
||
log("fail to auth socks server");
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Request data format (Worker -> Socks Server):
|
||
// +----+-----+-------+------+----------+----------+
|
||
// |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT |
|
||
// +----+-----+-------+------+----------+----------+
|
||
// | 1 | 1 | X'00' | 1 | Variable | 2 |
|
||
// +----+-----+-------+------+----------+----------+
|
||
// ATYP: address type of following address
|
||
// 0x01: IPv4 address
|
||
// 0x03: Domain name
|
||
// 0x04: IPv6 address
|
||
// DST.ADDR: desired destination address
|
||
// DST.PORT: desired destination port in network octet order
|
||
|
||
// addressType
|
||
// 1--> ipv4 addressLength =4
|
||
// 2--> domain name
|
||
// 3--> ipv6 addressLength =16
|
||
let DSTADDR; // DSTADDR = ATYP + DST.ADDR
|
||
switch (addressType) {
|
||
case 1:
|
||
DSTADDR = new Uint8Array(
|
||
[1, ...addressRemote.split('.').map(Number)]
|
||
);
|
||
break;
|
||
case 2:
|
||
DSTADDR = new Uint8Array(
|
||
[3, addressRemote.length, ...encoder.encode(addressRemote)]
|
||
);
|
||
break;
|
||
case 3:
|
||
DSTADDR = new Uint8Array(
|
||
[4, ...addressRemote.split(':').flatMap(x => [parseInt(x.slice(0, 2), 16), parseInt(x.slice(2), 16)])]
|
||
);
|
||
break;
|
||
default:
|
||
log(`invild addressType is ${addressType}`);
|
||
return;
|
||
}
|
||
const socksRequest = new Uint8Array([5, 1, 0, ...DSTADDR, portRemote >> 8, portRemote & 0xff]);
|
||
await writer.write(socksRequest);
|
||
log('sent socks request');
|
||
|
||
res = (await reader.read()).value;
|
||
// Response format (Socks Server -> Worker):
|
||
// +----+-----+-------+------+----------+----------+
|
||
// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
|
||
// +----+-----+-------+------+----------+----------+
|
||
// | 1 | 1 | X'00' | 1 | Variable | 2 |
|
||
// +----+-----+-------+------+----------+----------+
|
||
if (res[1] === 0x00) {
|
||
log("socks connection opened");
|
||
} else {
|
||
log("fail to open socks connection");
|
||
return;
|
||
}
|
||
writer.releaseLock();
|
||
reader.releaseLock();
|
||
return socket;
|
||
}
|
||
|
||
|
||
/**
|
||
*
|
||
* @param {string} address
|
||
*/
|
||
function socks5AddressParser(address) {
|
||
let [latter, former] = address.split("@").reverse();
|
||
let username, password, hostname, port;
|
||
if (former) {
|
||
const formers = former.split(":");
|
||
if (formers.length !== 2) {
|
||
throw new Error('Invalid SOCKS address format');
|
||
}
|
||
[username, password] = formers;
|
||
}
|
||
const latters = latter.split(":");
|
||
port = Number(latters.pop());
|
||
if (isNaN(port)) {
|
||
throw new Error('Invalid SOCKS address format');
|
||
}
|
||
hostname = latters.join(":");
|
||
const regex = /^\[.*\]$/;
|
||
if (hostname.includes(":") && !regex.test(hostname)) {
|
||
throw new Error('Invalid SOCKS address format');
|
||
}
|
||
return {
|
||
username,
|
||
password,
|
||
hostname,
|
||
port,
|
||
}
|
||
}
|
||
|
||
function revertFakeInfo(content, userID, hostName, isBase64) {
|
||
if (isBase64) content = atob(content);//Base64解码
|
||
content = content.replace(new RegExp(fakeUserID, 'g'), userID).replace(new RegExp(fakeHostName, 'g'), hostName);
|
||
if (isBase64) content = btoa(content);//Base64编码
|
||
|
||
return content;
|
||
}
|
||
|
||
function generateRandomNumber() {
|
||
let minNum = 100000;
|
||
let maxNum = 999999;
|
||
return Math.floor(Math.random() * (maxNum - minNum + 1)) + minNum;
|
||
}
|
||
|
||
function generateRandomString() {
|
||
let minLength = 2;
|
||
let maxLength = 3;
|
||
let length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength;
|
||
let characters = 'abcdefghijklmnopqrstuvwxyz';
|
||
let result = '';
|
||
for (let i = 0; i < length; i++) {
|
||
result += characters[Math.floor(Math.random() * characters.length)];
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function generateUUID() {
|
||
let uuid = '';
|
||
for (let i = 0; i < 32; i++) {
|
||
let num = Math.floor(Math.random() * 16);
|
||
if (num < 10) {
|
||
uuid += num;
|
||
} else {
|
||
uuid += String.fromCharCode(num + 55);
|
||
}
|
||
}
|
||
return uuid.replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '$1-$2-$3-$4-$5').toLowerCase();
|
||
}
|
||
|
||
async function ADD(envadd) {
|
||
var addtext = envadd.replace(/[ |"'\r\n]+/g, ',').replace(/,+/g, ','); // 将双引号、单引号和换行符替换为逗号
|
||
//console.log(addtext);
|
||
if (addtext.charAt(0) == ',') addtext = addtext.slice(1);
|
||
if (addtext.charAt(addtext.length -1) == ',') addtext = addtext.slice(0, addtext.length - 1);
|
||
const add = addtext.split(',');
|
||
//console.log(add);
|
||
return add ;
|
||
}
|
||
|
||
const 啥啥啥_写的这是啥啊 = 'dmxlc3M=';
|
||
function 配置信息(UUID, 域名地址) {
|
||
const 协议类型 = atob(啥啥啥_写的这是啥啊);
|
||
|
||
const 别名 = 域名地址;
|
||
let 地址 = 域名地址;
|
||
let 端口 = 443;
|
||
|
||
const 用户ID = UUID;
|
||
const 加密方式 = 'none';
|
||
|
||
const 传输层协议 = 'ws';
|
||
const 伪装域名 = 域名地址;
|
||
const 路径 = '/?ed=2560';
|
||
|
||
let 传输层安全 = ['tls',true];
|
||
const SNI = 域名地址;
|
||
const 指纹 = 'randomized';
|
||
|
||
if (域名地址.includes('.workers.dev')){
|
||
地址 = 'www.wto.org';
|
||
端口 = 80 ;
|
||
传输层安全 = ['',false];
|
||
}
|
||
|
||
const v2ray = `${协议类型}://${用户ID}@${地址}:${端口}?encryption=${加密方式}&security=${传输层安全[0]}&sni=${SNI}&fp=${指纹}&type=${传输层协议}&host=${伪装域名}&path=${encodeURIComponent(路径)}#${encodeURIComponent(别名)}`;
|
||
const clash = `- type: ${协议类型}
|
||
name: ${别名}
|
||
server: ${地址}
|
||
port: ${端口}
|
||
uuid: ${用户ID}
|
||
network: ${传输层协议}
|
||
tls: ${传输层安全[1]}
|
||
udp: false
|
||
sni: ${SNI}
|
||
client-fingerprint: ${指纹}
|
||
ws-opts:
|
||
path: "${路径}"
|
||
headers:
|
||
host: ${伪装域名}`;
|
||
return [v2ray,clash];
|
||
}
|
||
|
||
let subParams = ['sub','base64','b64','clash','singbox','sb'];
|
||
|
||
/**
|
||
* @param {string} userID
|
||
* @param {string | null} hostName
|
||
* @param {string} sub
|
||
* @param {string} UA
|
||
* @returns {Promise<string>}
|
||
*/
|
||
async function getVLESSConfig(userID, hostName, sub, UA, RproxyIP, _url) {
|
||
const userAgent = UA.toLowerCase();
|
||
const Config = 配置信息(userID , hostName);
|
||
const v2ray = Config[0];
|
||
const clash = Config[1];
|
||
// 如果sub为空，则显示原始内容
|
||
if ( userAgent.includes('mozilla') && !subParams.some(_searchParams => _url.searchParams.has(_searchParams))) {
|
||
let 订阅器 = `您的订阅内容由 ${sub} 提供维护支持, 自动获取ProxyIP: ${RproxyIP}`;
|
||
if (!sub || sub == '') {
|
||
if (!proxyIP || proxyIP =='') {
|
||
订阅器 = '您的订阅内容由 内置 addresses/ADD 参数提供, 当前使用的ProxyIP为空, 推荐您设置 proxyIP/PROXYIP ！！！';
|
||
} else {
|
||
订阅器 = `您的订阅内容由 内置 addresses/ADD 参数提供, 当前使用的ProxyIP： ${proxyIPs.join(',')}`;
|
||
}
|
||
} else if (RproxyIP != 'true'){
|
||
订阅器 += `, 当前使用的ProxyIP： ${proxyIPs.join(',')}`;
|
||
}
|
||
return `
|
||
################################################################
|
||
Subscribe / sub 订阅地址, 支持 Base64、clash-meta、sing-box 订阅格式, ${订阅器}
|
||
---------------------------------------------------------------
|
||
快速自适应订阅地址:
|
||
https://${hostName}/${userID}
|
||
|
||
Base64订阅地址:
|
||
https://${hostName}/${userID}?sub
|
||
https://${hostName}/${userID}?b64
|
||
https://${hostName}/${userID}?base64
|
||
|
||
clash订阅地址:
|
||
https://${hostName}/${userID}?clash
|
||
|
||
singbox订阅地址:
|
||
https://${hostName}/${userID}?sb
|
||
https://${hostName}/${userID}?singbox
|
||
---------------------------------------------------------------
|
||
################################################################
|
||
v2ray
|
||
---------------------------------------------------------------
|
||
${v2ray}
|
||
---------------------------------------------------------------
|
||
################################################################
|
||
clash-meta
|
||
---------------------------------------------------------------
|
||
${clash}
|
||
---------------------------------------------------------------
|
||
################################################################
|
||
telegram 交流群 技术大佬~在线发牌!
|
||
https://t.me/CMLiussss
|
||
---------------------------------------------------------------
|
||
github 项目地址 Star!Star!Star!!!
|
||
https://github.com/cmliu/edgetunnel
|
||
---------------------------------------------------------------
|
||
################################################################
|
||
`;
|
||
} else {
|
||
if (typeof fetch != 'function') {
|
||
return 'Error: fetch is not available in this environment.';
|
||
}
|
||
|
||
const newAddressesapi = await getAddressesapi(addressesapi);
|
||
const newAddressescsv = await getAddressescsv('TRUE');
|
||
let newAddressesnotlsapi;
|
||
let newAddressesnotlscsv;
|
||
|
||
// 如果是使用默认域名，则改成一个workers的域名，订阅器会加上代理
|
||
if (hostName.includes(".workers.dev")){
|
||
fakeHostName = `${fakeHostName}.${generateRandomString()}${generateRandomNumber()}.workers.dev`;
|
||
newAddressesnotlsapi = await getAddressesapi(addressesnotlsapi);
|
||
newAddressesnotlscsv = await getAddressescsv('FALSE');
|
||
} else if (hostName.includes(".pages.dev")){
|
||
fakeHostName = `${fakeHostName}.${generateRandomString()}${generateRandomNumber()}.pages.dev`;
|
||
} else if (hostName.includes("worker") || hostName.includes("notls") || noTLS == 'true'){
|
||
fakeHostName = `notls.${fakeHostName}${generateRandomNumber()}.net`;
|
||
newAddressesnotlsapi = await getAddressesapi(addressesnotlsapi);
|
||
newAddressesnotlscsv = await getAddressescsv('FALSE');
|
||
} else {
|
||
fakeHostName = `${fakeHostName}.${generateRandomNumber()}.xyz`
|
||
}
|
||
|
||
if(hostName.includes('workers.dev') || hostName.includes('pages.dev')) {
|
||
if (proxyhostsURL && (!proxyhosts || proxyhosts.length == 0)) {
|
||
try {
|
||
const response = await fetch(proxyhostsURL);
|
||
|
||
if (!response.ok) {
|
||
console.error('获取地址时出错:', response.status, response.statusText);
|
||
return; // 如果有错误，直接返回
|
||
}
|
||
|
||
const text = await response.text();
|
||
const lines = text.split('\n');
|
||
// 过滤掉空行或只包含空白字符的行
|
||
const nonEmptyLines = lines.filter(line => line.trim() !== '');
|
||
|
||
proxyhosts = proxyhosts.concat(nonEmptyLines);
|
||
} catch (error) {
|
||
console.error('获取地址时出错:', error);
|
||
}
|
||
}
|
||
// 使用Set对象去重
|
||
proxyhosts = [...new Set(proxyhosts)];
|
||
}
|
||
|
||
let url = `https://${sub}/sub?host=${fakeHostName}&uuid=${fakeUserID}&edgetunnel=cmliu&proxyip=${RproxyIP}`;
|
||
let isBase64 = true;
|
||
|
||
if (!sub || sub == ""){
|
||
const 生成本地节点 = await subAddresses(fakeHostName,fakeUserID,noTLS,newAddressesapi,newAddressescsv,newAddressesnotlsapi,newAddressesnotlscsv);
|
||
const 解码本地节点 = atob(生成本地节点)
|
||
const 本地节点数组 = 解码本地节点.split('\n');
|
||
url = 本地节点数组.join('|');
|
||
//console.log(url);
|
||
}
|
||
|
||
if (!userAgent.includes(('CF-Workers-SUB').toLowerCase())){
|
||
if ((userAgent.includes('clash') && !userAgent.includes('nekobox')) || ( _url.searchParams.has('clash') && !userAgent.includes('subconverter'))) {
|
||
url = `https://${subconverter}/sub?target=clash&url=${encodeURIComponent(url)}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`;
|
||
isBase64 = false;
|
||
} else if (userAgent.includes('sing-box') || userAgent.includes('singbox') || (( _url.searchParams.has('singbox') || _url.searchParams.has('sb')) && !userAgent.includes('subconverter'))) {
|
||
url = `https://${subconverter}/sub?target=singbox&url=${encodeURIComponent(url)}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`;
|
||
isBase64 = false;
|
||
}
|
||
}
|
||
|
||
try {
|
||
let content;
|
||
if ((!sub || sub == "") && isBase64 == true) {
|
||
content = await subAddresses(fakeHostName,fakeUserID,noTLS,newAddressesapi,newAddressescsv,newAddressesnotlsapi,newAddressesnotlscsv);
|
||
} else {
|
||
const response = await fetch(url ,{
|
||
headers: {
|
||
'User-Agent': `${UA} CF-Workers-edgetunnel/cmliu`
|
||
}});
|
||
content = await response.text();
|
||
}
|
||
let 输出内容 = revertFakeInfo(content, userID, hostName, isBase64);
|
||
//console.log(输出内容);
|
||
return 输出内容;
|
||
} catch (error) {
|
||
console.error('Error fetching content:', error);
|
||
return `Error fetching content: ${error.message}`;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
async function getAccountId(email, key) {
|
||
try {
|
||
const url = 'https://api.cloudflare.com/client/v4/accounts';
|
||
const headers = new Headers({
|
||
'X-AUTH-EMAIL': email,
|
||
'X-AUTH-KEY': key
|
||
});
|
||
const response = await fetch(url, { headers });
|
||
const data = await response.json();
|
||
return data.result[0].id; // 假设我们需要第一个账号ID
|
||
} catch (error) {
|
||
return false ;
|
||
}
|
||
}
|
||
|
||
async function getSum(accountId, accountIndex, email, key, startDate, endDate) {
|
||
try {
|
||
const startDateISO = new Date(startDate).toISOString();
|
||
const endDateISO = new Date(endDate).toISOString();
|
||
|
||
const query = JSON.stringify({
|
||
query: `query getBillingMetrics($accountId: String!, $filter: AccountWorkersInvocationsAdaptiveFilter_InputObject) {
|
||
viewer {
|
||
accounts(filter: {accountTag: $accountId}) {
|
||
pagesFunctionsInvocationsAdaptiveGroups(limit: 1000, filter: $filter) {
|
||
sum {
|
||
requests
|
||
}
|
||
}
|
||
workersInvocationsAdaptive(limit: 10000, filter: $filter) {
|
||
sum {
|
||
requests
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}`,
|
||
variables: {
|
||
accountId,
|
||
filter: { datetime_geq: startDateISO, datetime_leq: endDateISO }
|
||
},
|
||
});
|
||
|
||
const headers = new Headers({
|
||
'Content-Type': 'application/json',
|
||
'X-AUTH-EMAIL': email,
|
||
'X-AUTH-KEY': key,
|
||
});
|
||
|
||
const response = await fetch(`https://api.cloudflare.com/client/v4/graphql`, {
|
||
method: 'POST',
|
||
headers: headers,
|
||
body: query
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP error! status: ${response.status}`);
|
||
}
|
||
|
||
const res = await response.json();
|
||
|
||
const pagesFunctionsInvocationsAdaptiveGroups = res?.data?.viewer?.accounts?.[accountIndex]?.pagesFunctionsInvocationsAdaptiveGroups;
|
||
const workersInvocationsAdaptive = res?.data?.viewer?.accounts?.[accountIndex]?.workersInvocationsAdaptive;
|
||
|
||
if (!pagesFunctionsInvocationsAdaptiveGroups && !workersInvocationsAdaptive) {
|
||
throw new Error('找不到数据');
|
||
}
|
||
|
||
const pagesSum = pagesFunctionsInvocationsAdaptiveGroups.reduce((a, b) => a + b?.sum.requests, 0);
|
||
const workersSum = workersInvocationsAdaptive.reduce((a, b) => a + b?.sum.requests, 0);
|
||
|
||
//console.log(`范围: ${startDateISO} ~ ${endDateISO}\n默认取第 ${accountIndex} 项`);
|
||
|
||
return [pagesSum, workersSum ];
|
||
} catch (error) {
|
||
return [ 0,0 ];
|
||
}
|
||
}
|
||
|
||
async function getAddressesapi(api) {
|
||
if (!api || api.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
let newapi = "";
|
||
|
||
// 创建一个AbortController对象，用于控制fetch请求的取消
|
||
const controller = new AbortController();
|
||
|
||
const timeout = setTimeout(() => {
|
||
controller.abort(); // 取消所有请求
|
||
}, 2000); // 2秒后触发
|
||
|
||
try {
|
||
// 使用Promise.allSettled等待所有API请求完成，无论成功或失败
|
||
// 对api数组进行遍历，对每个API地址发起fetch请求
|
||
const responses = await Promise.allSettled(api.map(apiUrl => fetch(apiUrl, {
|
||
method: 'get',
|
||
headers: {
|
||
'Accept': 'text/html,application/xhtml+xml,application/xml;',
|
||
'User-Agent': 'CF-Workers-edgetunnel/cmliu'
|
||
},
|
||
signal: controller.signal // 将AbortController的信号量添加到fetch请求中，以便于需要时可以取消请求
|
||
}).then(response => response.ok ? response.text() : Promise.reject())));
|
||
|
||
// 遍历所有响应
|
||
for (const response of responses) {
|
||
// 检查响应状态是否为'fulfilled'，即请求成功完成
|
||
if (response.status === 'fulfilled') {
|
||
// 获取响应的内容
|
||
const content = await response.value;
|
||
newapi += content + '\n';
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error(error);
|
||
} finally {
|
||
// 无论成功或失败，最后都清除设置的超时定时器
|
||
clearTimeout(timeout);
|
||
}
|
||
|
||
const newAddressesapi = await ADD(newapi);
|
||
|
||
// 返回处理后的结果
|
||
return newAddressesapi;
|
||
}
|
||
|
||
async function getAddressescsv(tls) {
|
||
if (!addressescsv || addressescsv.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
let newAddressescsv = [];
|
||
|
||
for (const csvUrl of addressescsv) {
|
||
try {
|
||
const response = await fetch(csvUrl);
|
||
|
||
if (!response.ok) {
|
||
console.error('获取CSV地址时出错:', response.status, response.statusText);
|
||
continue;
|
||
}
|
||
|
||
const text = await response.text();// 使用正确的字符编码解析文本内容
|
||
let lines;
|
||
if (text.includes('\r\n')){
|
||
lines = text.split('\r\n');
|
||
} else {
|
||
lines = text.split('\n');
|
||
}
|
||
|
||
// 检查CSV头部是否包含必需字段
|
||
const header = lines[0].split(',');
|
||
const tlsIndex = header.indexOf('TLS');
|
||
const speedIndex = header.length - 1; // 最后一个字段
|
||
|
||
const ipAddressIndex = 0;// IP地址在 CSV 头部的位置
|
||
const portIndex = 1;// 端口在 CSV 头部的位置
|
||
const dataCenterIndex = tlsIndex + 1; // 数据中心是 TLS 的后一个字段
|
||
|
||
if (tlsIndex === -1) {
|
||
console.error('CSV文件缺少必需的字段');
|
||
continue;
|
||
}
|
||
|
||
// 从第二行开始遍历CSV行
|
||
for (let i = 1; i < lines.length; i++) {
|
||
const columns = lines[i].split(',');
|
||
|
||
// 检查TLS是否为"TRUE"且速度大于DLS
|
||
if (columns[tlsIndex].toUpperCase() === tls && parseFloat(columns[speedIndex]) > DLS) {
|
||
const ipAddress = columns[ipAddressIndex];
|
||
const port = columns[portIndex];
|
||
const dataCenter = columns[dataCenterIndex];
|
||
|
||
const formattedAddress = `${ipAddress}:${port}#${dataCenter}`;
|
||
newAddressescsv.push(formattedAddress);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
console.error('获取CSV地址时出错:', error);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
return newAddressescsv;
|
||
}
|
||
|
||
function subAddresses(host,UUID,noTLS,newAddressesapi,newAddressescsv,newAddressesnotlsapi,newAddressesnotlscsv) {
|
||
const regex = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[.*\]):?(\d+)?#?(.*)?$/;
|
||
addresses = addresses.concat(newAddressesapi);
|
||
addresses = addresses.concat(newAddressescsv);
|
||
let notlsresponseBody ;
|
||
if (noTLS == 'true'){
|
||
addressesnotls = addressesnotls.concat(newAddressesnotlsapi);
|
||
addressesnotls = addressesnotls.concat(newAddressesnotlscsv);
|
||
const uniqueAddressesnotls = [...new Set(addressesnotls)];
|
||
|
||
notlsresponseBody = uniqueAddressesnotls.map(address => {
|
||
let port = "80";
|
||
let addressid = address;
|
||
|
||
const match = addressid.match(regex);
|
||
if (!match) {
|
||
if (address.includes(':') && address.includes('#')) {
|
||
const parts = address.split(':');
|
||
address = parts[0];
|
||
const subParts = parts[1].split('#');
|
||
port = subParts[0];
|
||
addressid = subParts[1];
|
||
} else if (address.includes(':')) {
|
||
const parts = address.split(':');
|
||
address = parts[0];
|
||
port = parts[1];
|
||
} else if (address.includes('#')) {
|
||
const parts = address.split('#');
|
||
address = parts[0];
|
||
addressid = parts[1];
|
||
}
|
||
|
||
if (addressid.includes(':')) {
|
||
addressid = addressid.split(':')[0];
|
||
}
|
||
} else {
|
||
address = match[1];
|
||
port = match[2] || port;
|
||
addressid = match[3] || address;
|
||
}
|
||
|
||
let 伪装域名 = host ;
|
||
let 最终路径 = '/?ed=2560' ;
|
||
let 节点备注 = '';
|
||
|
||
if(proxyhosts.length > 0 && (伪装域名.includes('.workers.dev') || 伪装域名.includes('pages.dev'))) {
|
||
最终路径 = `/${伪装域名}${最终路径}`;
|
||
伪装域名 = proxyhosts[Math.floor(Math.random() * proxyhosts.length)];
|
||
节点备注 = ` 已启用临时域名中转服务，请尽快绑定自定义域！`;
|
||
}
|
||
|
||
const vlessLink = `vless://${UUID}@${address}:${port}?encryption=none&security=&type=ws&host=${伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`;
|
||
|
||
return vlessLink;
|
||
|
||
}).join('\n');
|
||
|
||
}
|
||
|
||
// 使用Set对象去重
|
||
const uniqueAddresses = [...new Set(addresses)];
|
||
|
||
const responseBody = uniqueAddresses.map(address => {
|
||
let port = "443";
|
||
let addressid = address;
|
||
|
||
const match = addressid.match(regex);
|
||
if (!match) {
|
||
if (address.includes(':') && address.includes('#')) {
|
||
const parts = address.split(':');
|
||
address = parts[0];
|
||
const subParts = parts[1].split('#');
|
||
port = subParts[0];
|
||
addressid = subParts[1];
|
||
} else if (address.includes(':')) {
|
||
const parts = address.split(':');
|
||
address = parts[0];
|
||
port = parts[1];
|
||
} else if (address.includes('#')) {
|
||
const parts = address.split('#');
|
||
address = parts[0];
|
||
addressid = parts[1];
|
||
}
|
||
|
||
if (addressid.includes(':')) {
|
||
addressid = addressid.split(':')[0];
|
||
}
|
||
} else {
|
||
address = match[1];
|
||
port = match[2] || port;
|
||
addressid = match[3] || address;
|
||
}
|
||
|
||
let 伪装域名 = host ;
|
||
let 最终路径 = '/?ed=2560' ;
|
||
let 节点备注 = '';
|
||
|
||
if(proxyhosts.length > 0 && (伪装域名.includes('.workers.dev') || 伪装域名.includes('pages.dev'))) {
|
||
最终路径 = `/${伪装域名}${最终路径}`;
|
||
伪装域名 = proxyhosts[Math.floor(Math.random() * proxyhosts.length)];
|
||
节点备注 = ` 已启用临时域名中转服务，请尽快绑定自定义域！`;
|
||
}
|
||
|
||
const 协议类型 = atob(啥啥啥_写的这是啥啊);
|
||
const vlessLink = `${协议类型}://${UUID}@${address}:${port}?encryption=none&security=tls&sni=${伪装域名}&fp=random&type=ws&host=${伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`;
|
||
|
||
return vlessLink;
|
||
}).join('\n');
|
||
|
||
let base64Response = responseBody; // 重新进行 Base64 编码
|
||
if(noTLS == 'true') base64Response += `\nnotlsresponseBody`
|
||
return btoa(base64Response);
|
||
}
|
||
|
||
async function sendMessage(type, ip, add_data = "") {
|
||
if ( BotToken !== '' && ChatID !== ''){
|
||
let msg = "";
|
||
const response = await fetch(`http://ip-api.com/json/${ip}?lang=zh-CN`);
|
||
if (response.status == 200) {
|
||
const ipInfo = await response.json();
|
||
msg = `${type}\nIP: ${ip}\n国家: ${ipInfo.country}\n<tg-spoiler>城市: ${ipInfo.city}\n组织: ${ipInfo.org}\nASN: ${ipInfo.as}\n${add_data}`;
|
||
} else {
|
||
msg = `${type}\nIP: ${ip}\n<tg-spoiler>${add_data}`;
|
||
}
|
||
|
||
let url = "https://api.telegram.org/bot"+ BotToken +"/sendMessage?chat_id=" + ChatID + "&parse_mode=HTML&text=" + encodeURIComponent(msg);
|
||
return fetch(url, {
|
||
method: 'get',
|
||
headers: {
|
||
'Accept': 'text/html,application/xhtml+xml,application/xml;',
|
||
'Accept-Encoding': 'gzip, deflate, br',
|
||
'User-Agent': 'Mozilla/5.0 Chrome/90.0.4430.72'
|
||
}
|
||
});
|
||
}
|
||
}
|