使用Cloudflare的Workers创建永久免费的V2ray节点

  • 首页 > 技术文献
  • 作者：浪漫の小牛奶
  • 时间： 2024年3月4日 1:15
  • 字数：33189 个
  • 字号：小 中 大
  • 评论：0 条
  • 浏览：3412 次
  • 百度：百度已收录
  • 分类： 技术文献
    • 时间：2024-3-4 1:15 热度：3412° 评论：0 条 

    如何创建Workers并编辑代码，这里就不再赘述了，下面直接贴出JS代码，使用时记得修改代码第7行的UUID "e6986ed7-82c9-48a9-9bca-dfc8eb0a8ef5" 


    1. // @ts-ignore
    2. import { connect } from 'cloudflare:sockets';
    3.  
    4. // How to generate your own UUID:
    5. // [Windows] Press "Win + R", input cmd and run:  Powershell -NoExit -Command "[guid]::NewGuid()"
    6. let userID = 'e6986ed7-82c9-48a9-9bca-dfc8eb0a8ef5';
    7.  
    8. const proxyIPs = ['cdn.xn--b6gac.eu.org', 'cdn-all.xn--b6gac.eu.org', 'workers.cloudflare.cyou'];
    9.  
    10. // if you want to use ipv6 or single proxyIP, please add comment at this line and remove comment at the next line
    11. let proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];
    12. // use single proxyIP instead of random
    13. // let proxyIP = 'cdn.xn--b6gac.eu.org';
    14. // ipv6 proxyIP example remove comment to use
    15. // let proxyIP = "[2a01:4f8:c2c:123f:64:5:6810:c55a]"
    16.  
    17. let dohURL = 'https://sky.rethinkdns.com/1:-Pf_____9_8A_AMAIgE8kMABVDDmKOHTAKg='; // https://cloudflare-dns.com/dns-query or https://dns.google/dns-query
    18.  
    19. if (!isValidUUID(userID)) {
    20. 	throw new Error('uuid is invalid');
    21. }
    22.  
    23. export default {
    24. 	/**
    25. 	 * @param {import("@cloudflare/workers-types").Request} request
    26. 	 * @param {{UUID: string, PROXYIP: string, DNS_RESOLVER_URL: string, NODE_ID: int, API_HOST: string, API_TOKEN: string}} env
    27. 	 * @param {import("@cloudflare/workers-types").ExecutionContext} ctx
    28. 	 * @returns {Promise<Response>}
    29. 	 */
    30. 	async fetch(request, env, ctx) {
    31. 		// uuid_validator(request);
    32. 		try {
    33. 			userID = env.UUID || userID;
    34. 			proxyIP = env.PROXYIP || proxyIP;
    35. 			dohURL = env.DNS_RESOLVER_URL || dohURL;
    36. 			let userID_Path = userID;
    37. 			if (userID.includes(',')) {
    38. 				userID_Path = userID.split(',')[0];
    39. 			}
    40. 			const upgradeHeader = request.headers.get('Upgrade');
    41. 			if (!upgradeHeader || upgradeHeader !== 'websocket') {
    42. 				const url = new URL(request.url);
    43. 				switch (url.pathname) {
    44. 					case `/cf`: {
    45. 						return new Response(JSON.stringify(request.cf, null, 4), {
    46. 							status: 200,
    47. 							headers: {
    48. 								"Content-Type": "application/json;charset=utf-8",
    49. 							},
    50. 						});
    51. 					}
    52. 					case `/${userID_Path}`: {
    53. 						const vlessConfig = getVLESSConfig(userID, request.headers.get('Host'));
    54. 						return new Response(`${vlessConfig}`, {
    55. 							status: 200,
    56. 							headers: {
    57. 								"Content-Type": "text/html; charset=utf-8",
    58. 							}
    59. 						});
    60. 					};
    61. 					case `/sub/${userID_Path}`: {
    62. 						const url = new URL(request.url);
    63. 						const searchParams = url.searchParams;
    64. 						const vlessSubConfig = createVLESSSub(userID, request.headers.get('Host'));
    65. 						// Construct and return response object
    66. 						return new Response(btoa(vlessSubConfig), {
    67. 							status: 200,
    68. 							headers: {
    69. 								"Content-Type": "text/plain;charset=utf-8",
    70. 							}
    71. 						});
    72. 					};
    73. 					case `/bestip/${userID_Path}`: {
    74. 						const headers = request.headers;
    75. 						const url = `https://sub.xf.free.hr/auto?host=${request.headers.get('Host')}&uuid=${userID}&path=/`;
    76. 						const bestSubConfig = await fetch(url, { headers: headers });
    77. 						return bestSubConfig;
    78. 					};
    79. 					default:
    80. 						// return new Response('Not found', { status: 404 });
    81. 						// For any other path, reverse proxy to 'ramdom website' and return the original response, caching it in the process
    82. 						const randomHostname = cn_hostnames[Math.floor(Math.random() * cn_hostnames.length)];
    83. 						const newHeaders = new Headers(request.headers);
    84. 						newHeaders.set('cf-connecting-ip', '1.2.3.4');
    85. 						newHeaders.set('x-forwarded-for', '1.2.3.4');
    86. 						newHeaders.set('x-real-ip', '1.2.3.4');
    87. 						newHeaders.set('referer', 'https://www.google.com/search?q=edtunnel');
    88. 						// Use fetch to proxy the request to 15 different domains
    89. 						const proxyUrl = 'https://' + randomHostname + url.pathname + url.search;
    90. 						let modifiedRequest = new Request(proxyUrl, {
    91. 							method: request.method,
    92. 							headers: newHeaders,
    93. 							body: request.body,
    94. 							redirect: 'manual',
    95. 						});
    96. 						const proxyResponse = await fetch(modifiedRequest, { redirect: 'manual' });
    97. 						// Check for 302 or 301 redirect status and return an error response
    98. 						if ([301, 302].includes(proxyResponse.status)) {
    99. 							return new Response(`Redirects to ${randomHostname} are not allowed.`, {
    100. 								status: 403,
    101. 								statusText: 'Forbidden',
    102. 							});
    103. 						}
    104. 						// Return the response from the proxy server
    105. 						return proxyResponse;
    106. 				}
    107. 			} else {
    108. 				return await vlessOverWSHandler(request);
    109. 			}
    110. 		} catch (err) {
    111. 			/** @type {Error} */ let e = err;
    112. 			return new Response(e.toString());
    113. 		}
    114. 	},
    115. };
    116.  
    117. export async function uuid_validator(request) {
    118. 	const hostname = request.headers.get('Host');
    119. 	const currentDate = new Date();
    120.  
    121. 	const subdomain = hostname.split('.')[0];
    122. 	const year = currentDate.getFullYear();
    123. 	const month = String(currentDate.getMonth() + 1).padStart(2, '0');
    124. 	const day = String(currentDate.getDate()).padStart(2, '0');
    125.  
    126. 	const formattedDate = `${year}-${month}-${day}`;
    127.  
    128. 	// const daliy_sub = formattedDate + subdomain
    129. 	const hashHex = await hashHex_f(subdomain);
    130. 	// subdomain string contains timestamps utc and uuid string TODO.
    131. 	console.log(hashHex, subdomain, formattedDate);
    132. }
    133.  
    134. export async function hashHex_f(string) {
    135. 	const encoder = new TextEncoder();
    136. 	const data = encoder.encode(string);
    137. 	const hashBuffer = await crypto.subtle.digest('SHA-256', data);
    138. 	const hashArray = Array.from(new Uint8Array(hashBuffer));
    139. 	const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
    140. 	return hashHex;
    141. }
    142.  
    143. /**
    144.  * Handles VLESS over WebSocket requests by creating a WebSocket pair, accepting the WebSocket connection, and processing the VLESS header.
    145.  * @param {import("@cloudflare/workers-types").Request} request The incoming request object.
    146.  * @returns {Promise<Response>} A Promise that resolves to a WebSocket response object.
    147.  */
    148. async function vlessOverWSHandler(request) {
    149. 	const webSocketPair = new WebSocketPair();
    150. 	const [client, webSocket] = Object.values(webSocketPair);
    151. 	webSocket.accept();
    152.  
    153. 	let address = '';
    154. 	let portWithRandomLog = '';
    155. 	let currentDate = new Date();
    156. 	const log = (/** @type {string} */ info, /** @type {string | undefined} */ event) => {
    157. 		console.log(`[${currentDate} ${address}:${portWithRandomLog}] ${info}`, event || '');
    158. 	};
    159. 	const earlyDataHeader = request.headers.get('sec-websocket-protocol') || '';
    160.  
    161. 	const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log);
    162.  
    163. 	/** @type {{ value: import("@cloudflare/workers-types").Socket | null}}*/
    164. 	let remoteSocketWapper = {
    165. 		value: null,
    166. 	};
    167. 	let udpStreamWrite = null;
    168. 	let isDns = false;
    169.  
    170. 	// ws --> remote
    171. 	readableWebSocketStream.pipeTo(new WritableStream({
    172. 		async write(chunk, controller) {
    173. 			if (isDns && udpStreamWrite) {
    174. 				return udpStreamWrite(chunk);
    175. 			}
    176. 			if (remoteSocketWapper.value) {
    177. 				const writer = remoteSocketWapper.value.writable.getWriter()
    178. 				await writer.write(chunk);
    179. 				writer.releaseLock();
    180. 				return;
    181. 			}
    182.  
    183. 			const {
    184. 				hasError,
    185. 				message,
    186. 				portRemote = 443,
    187. 				addressRemote = '',
    188. 				rawDataIndex,
    189. 				vlessVersion = new Uint8Array([0, 0]),
    190. 				isUDP,
    191. 			} = processVlessHeader(chunk, userID);
    192. 			address = addressRemote;
    193. 			portWithRandomLog = `${portRemote} ${isUDP ? 'udp' : 'tcp'} `;
    194. 			if (hasError) {
    195. 				// controller.error(message);
    196. 				throw new Error(message); // cf seems has bug, controller.error will not end stream
    197. 			}
    198.  
    199. 			// If UDP and not DNS port, close it
    200. 			if (isUDP && portRemote !== 53) {
    201. 				throw new Error('UDP proxy only enabled for DNS which is port 53');
    202. 				// cf seems has bug, controller.error will not end stream
    203. 			}
    204.  
    205. 			if (isUDP && portRemote === 53) {
    206. 				isDns = true;
    207. 			}
    208.  
    209. 			// ["version", "附加信息长度 N"]
    210. 			const vlessResponseHeader = new Uint8Array([vlessVersion[0], 0]);
    211. 			const rawClientData = chunk.slice(rawDataIndex);
    212.  
    213. 			// TODO: support udp here when cf runtime has udp support
    214. 			if (isDns) {
    215. 				const { write } = await handleUDPOutBound(webSocket, vlessResponseHeader, log);
    216. 				udpStreamWrite = write;
    217. 				udpStreamWrite(rawClientData);
    218. 				return;
    219. 			}
    220. 			handleTCPOutBound(remoteSocketWapper, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log);
    221. 		},
    222. 		close() {
    223. 			log(`readableWebSocketStream is close`);
    224. 		},
    225. 		abort(reason) {
    226. 			log(`readableWebSocketStream is abort`, JSON.stringify(reason));
    227. 		},
    228. 	})).catch((err) => {
    229. 		log('readableWebSocketStream pipeTo error', err);
    230. 	});
    231.  
    232. 	return new Response(null, {
    233. 		status: 101,
    234. 		webSocket: client,
    235. 	});
    236. }
    237.  
    238. /**
    239.  * Handles outbound TCP connections.
    240.  *
    241.  * @param {any} remoteSocket 
    242.  * @param {string} addressRemote The remote address to connect to.
    243.  * @param {number} portRemote The remote port to connect to.
    244.  * @param {Uint8Array} rawClientData The raw client data to write.
    245.  * @param {import("@cloudflare/workers-types").WebSocket} webSocket The WebSocket to pass the remote socket to.
    246.  * @param {Uint8Array} vlessResponseHeader The VLESS response header.
    247.  * @param {function} log The logging function.
    248.  * @returns {Promise<void>} The remote socket.
    249.  */
    250. async function handleTCPOutBound(remoteSocket, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log,) {
    251.  
    252. 	/**
    253. 	 * Connects to a given address and port and writes data to the socket.
    254. 	 * @param {string} address The address to connect to.
    255. 	 * @param {number} port The port to connect to.
    256. 	 * @returns {Promise<import("@cloudflare/workers-types").Socket>} A Promise that resolves to the connected socket.
    257. 	 */
    258. 	async function connectAndWrite(address, port) {
    259. 		/** @type {import("@cloudflare/workers-types").Socket} */
    260. 		const tcpSocket = connect({
    261. 			hostname: address,
    262. 			port: port,
    263. 		});
    264. 		remoteSocket.value = tcpSocket;
    265. 		log(`connected to ${address}:${port}`);
    266. 		const writer = tcpSocket.writable.getWriter();
    267. 		await writer.write(rawClientData); // first write, nomal is tls client hello
    268. 		writer.releaseLock();
    269. 		return tcpSocket;
    270. 	}
    271.  
    272. 	/**
    273. 	 * Retries connecting to the remote address and port if the Cloudflare socket has no incoming data.
    274. 	 * @returns {Promise<void>} A Promise that resolves when the retry is complete.
    275. 	 */
    276. 	async function retry() {
    277. 		const tcpSocket = await connectAndWrite(proxyIP || addressRemote, portRemote)
    278. 		tcpSocket.closed.catch(error => {
    279. 			console.log('retry tcpSocket closed error', error);
    280. 		}).finally(() => {
    281. 			safeCloseWebSocket(webSocket);
    282. 		})
    283. 		remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, null, log);
    284. 	}
    285.  
    286. 	const tcpSocket = await connectAndWrite(addressRemote, portRemote);
    287.  
    288. 	// when remoteSocket is ready, pass to websocket
    289. 	// remote--> ws
    290. 	remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, retry, log);
    291. }
    292.  
    293. /**
    294.  * Creates a readable stream from a WebSocket server, allowing for data to be read from the WebSocket.
    295.  * @param {import("@cloudflare/workers-types").WebSocket} webSocketServer The WebSocket server to create the readable stream from.
    296.  * @param {string} earlyDataHeader The header containing early data for WebSocket 0-RTT.
    297.  * @param {(info: string)=> void} log The logging function.
    298.  * @returns {ReadableStream} A readable stream that can be used to read data from the WebSocket.
    299.  */
    300. function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) {
    301. 	let readableStreamCancel = false;
    302. 	const stream = new ReadableStream({
    303. 		start(controller) {
    304. 			webSocketServer.addEventListener('message', (event) => {
    305. 				const message = event.data;
    306. 				controller.enqueue(message);
    307. 			});
    308.  
    309. 			webSocketServer.addEventListener('close', () => {
    310. 				safeCloseWebSocket(webSocketServer);
    311. 				controller.close();
    312. 			});
    313.  
    314. 			webSocketServer.addEventListener('error', (err) => {
    315. 				log('webSocketServer has error');
    316. 				controller.error(err);
    317. 			});
    318. 			const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader);
    319. 			if (error) {
    320. 				controller.error(error);
    321. 			} else if (earlyData) {
    322. 				controller.enqueue(earlyData);
    323. 			}
    324. 		},
    325.  
    326. 		pull(controller) {
    327. 			// if ws can stop read if stream is full, we can implement backpressure
    328. 			// https://streams.spec.whatwg.org/#example-rs-push-backpressure
    329. 		},
    330.  
    331. 		cancel(reason) {
    332. 			log(`ReadableStream was canceled, due to ${reason}`)
    333. 			readableStreamCancel = true;
    334. 			safeCloseWebSocket(webSocketServer);
    335. 		}
    336. 	});
    337.  
    338. 	return stream;
    339. }
    340.  
    341. // https://xtls.github.io/development/protocols/vless.html
    342. // https://github.com/zizifn/excalidraw-backup/blob/main/v2ray-protocol.excalidraw
    343.  
    344. /**
    345.  * Processes the VLESS header buffer and returns an object with the relevant information.
    346.  * @param {ArrayBuffer} vlessBuffer The VLESS header buffer to process.
    347.  * @param {string} userID The user ID to validate against the UUID in the VLESS header.
    348.  * @returns {{
    349.  *  hasError: boolean,
    350.  *  message?: string,
    351.  *  addressRemote?: string,
    352.  *  addressType?: number,
    353.  *  portRemote?: number,
    354.  *  rawDataIndex?: number,
    355.  *  vlessVersion?: Uint8Array,
    356.  *  isUDP?: boolean
    357.  * }} An object with the relevant information extracted from the VLESS header buffer.
    358.  */
    359. function processVlessHeader(vlessBuffer, userID) {
    360. 	if (vlessBuffer.byteLength < 24) {
    361. 		return {
    362. 			hasError: true,
    363. 			message: 'invalid data',
    364. 		};
    365. 	}
    366.  
    367. 	const version = new Uint8Array(vlessBuffer.slice(0, 1));
    368. 	let isValidUser = false;
    369. 	let isUDP = false;
    370. 	const slicedBuffer = new Uint8Array(vlessBuffer.slice(1, 17));
    371. 	const slicedBufferString = stringify(slicedBuffer);
    372. 	// check if userID is valid uuid or uuids split by , and contains userID in it otherwise return error message to console
    373. 	const uuids = userID.includes(',') ? userID.split(",") : [userID];
    374. 	// uuid_validator(hostName, slicedBufferString);
    375.  
    376.  
    377. 	// isValidUser = uuids.some(userUuid => slicedBufferString === userUuid.trim());
    378. 	isValidUser = uuids.some(userUuid => slicedBufferString === userUuid.trim()) || uuids.length === 1 && slicedBufferString === uuids[0].trim();
    379.  
    380. 	console.log(`userID: ${slicedBufferString}`);
    381.  
    382. 	if (!isValidUser) {
    383. 		return {
    384. 			hasError: true,
    385. 			message: 'invalid user',
    386. 		};
    387. 	}
    388.  
    389. 	const optLength = new Uint8Array(vlessBuffer.slice(17, 18))[0];
    390. 	//skip opt for now
    391.  
    392. 	const command = new Uint8Array(
    393. 		vlessBuffer.slice(18 + optLength, 18 + optLength + 1)
    394. 	)[0];
    395.  
    396. 	// 0x01 TCP
    397. 	// 0x02 UDP
    398. 	// 0x03 MUX
    399. 	if (command === 1) {
    400. 		isUDP = false;
    401. 	} else if (command === 2) {
    402. 		isUDP = true;
    403. 	} else {
    404. 		return {
    405. 			hasError: true,
    406. 			message: `command ${command} is not support, command 01-tcp,02-udp,03-mux`,
    407. 		};
    408. 	}
    409. 	const portIndex = 18 + optLength + 1;
    410. 	const portBuffer = vlessBuffer.slice(portIndex, portIndex + 2);
    411. 	// port is big-Endian in raw data etc 80 == 0x005d
    412. 	const portRemote = new DataView(portBuffer).getUint16(0);
    413.  
    414. 	let addressIndex = portIndex + 2;
    415. 	const addressBuffer = new Uint8Array(
    416. 		vlessBuffer.slice(addressIndex, addressIndex + 1)
    417. 	);
    418.  
    419. 	// 1--> ipv4  addressLength =4
    420. 	// 2--> domain name addressLength=addressBuffer[1]
    421. 	// 3--> ipv6  addressLength =16
    422. 	const addressType = addressBuffer[0];
    423. 	let addressLength = 0;
    424. 	let addressValueIndex = addressIndex + 1;
    425. 	let addressValue = '';
    426. 	switch (addressType) {
    427. 		case 1:
    428. 			addressLength = 4;
    429. 			addressValue = new Uint8Array(
    430. 				vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
    431. 			).join('.');
    432. 			break;
    433. 		case 2:
    434. 			addressLength = new Uint8Array(
    435. 				vlessBuffer.slice(addressValueIndex, addressValueIndex + 1)
    436. 			)[0];
    437. 			addressValueIndex += 1;
    438. 			addressValue = new TextDecoder().decode(
    439. 				vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
    440. 			);
    441. 			break;
    442. 		case 3:
    443. 			addressLength = 16;
    444. 			const dataView = new DataView(
    445. 				vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength)
    446. 			);
    447. 			// 2001:0db8:85a3:0000:0000:8a2e:0370:7334
    448. 			const ipv6 = [];
    449. 			for (let i = 0; i < 8; i++) {
    450. 				ipv6.push(dataView.getUint16(i * 2).toString(16));
    451. 			}
    452. 			addressValue = ipv6.join(':');
    453. 			// seems no need add [] for ipv6
    454. 			break;
    455. 		default:
    456. 			return {
    457. 				hasError: true,
    458. 				message: `invild  addressType is ${addressType}`,
    459. 			};
    460. 	}
    461. 	if (!addressValue) {
    462. 		return {
    463. 			hasError: true,
    464. 			message: `addressValue is empty, addressType is ${addressType}`,
    465. 		};
    466. 	}
    467.  
    468. 	return {
    469. 		hasError: false,
    470. 		addressRemote: addressValue,
    471. 		addressType,
    472. 		portRemote,
    473. 		rawDataIndex: addressValueIndex + addressLength,
    474. 		vlessVersion: version,
    475. 		isUDP,
    476. 	};
    477. }
    478.  
    479.  
    480. /**
    481.  * Converts a remote socket to a WebSocket connection.
    482.  * @param {import("@cloudflare/workers-types").Socket} remoteSocket The remote socket to convert.
    483.  * @param {import("@cloudflare/workers-types").WebSocket} webSocket The WebSocket to connect to.
    484.  * @param {ArrayBuffer | null} vlessResponseHeader The VLESS response header.
    485.  * @param {(() => Promise<void>) | null} retry The function to retry the connection if it fails.
    486.  * @param {(info: string) => void} log The logging function.
    487.  * @returns {Promise<void>} A Promise that resolves when the conversion is complete.
    488.  */
    489. async function remoteSocketToWS(remoteSocket, webSocket, vlessResponseHeader, retry, log) {
    490. 	// remote--> ws
    491. 	let remoteChunkCount = 0;
    492. 	let chunks = [];
    493. 	/** @type {ArrayBuffer | null} */
    494. 	let vlessHeader = vlessResponseHeader;
    495. 	let hasIncomingData = false; // check if remoteSocket has incoming data
    496. 	await remoteSocket.readable
    497. 		.pipeTo(
    498. 			new WritableStream({
    499. 				start() {
    500. 				},
    501. 				/**
    502. 				 * 
    503. 				 * @param {Uint8Array} chunk 
    504. 				 * @param {*} controller 
    505. 				 */
    506. 				async write(chunk, controller) {
    507. 					hasIncomingData = true;
    508. 					remoteChunkCount++;
    509. 					if (webSocket.readyState !== WS_READY_STATE_OPEN) {
    510. 						controller.error(
    511. 							'webSocket.readyState is not open, maybe close'
    512. 						);
    513. 					}
    514. 					if (vlessHeader) {
    515. 						webSocket.send(await new Blob([vlessHeader, chunk]).arrayBuffer());
    516. 						vlessHeader = null;
    517. 					} else {
    518. 						// console.log(`remoteSocketToWS send chunk ${chunk.byteLength}`);
    519. 						// seems no need rate limit this, CF seems fix this??..
    520. 						// if (remoteChunkCount > 20000) {
    521. 						// 	// cf one package is 4096 byte(4kb),  4096 * 20000 = 80M
    522. 						// 	await delay(1);
    523. 						// }
    524. 						webSocket.send(chunk);
    525. 					}
    526. 				},
    527. 				close() {
    528. 					log(`remoteConnection!.readable is close with hasIncomingData is ${hasIncomingData}`);
    529. 					// 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.
    530. 				},
    531. 				abort(reason) {
    532. 					console.error(`remoteConnection!.readable abort`, reason);
    533. 				},
    534. 			})
    535. 		)
    536. 		.catch((error) => {
    537. 			console.error(
    538. 				`remoteSocketToWS has exception `,
    539. 				error.stack || error
    540. 			);
    541. 			safeCloseWebSocket(webSocket);
    542. 		});
    543.  
    544. 	// seems is cf connect socket have error,
    545. 	// 1. Socket.closed will have error
    546. 	// 2. Socket.readable will be close without any data coming
    547. 	if (hasIncomingData === false && retry) {
    548. 		log(`retry`)
    549. 		retry();
    550. 	}
    551. }
    552.  
    553. /**
    554.  * Decodes a base64 string into an ArrayBuffer.
    555.  * @param {string} base64Str The base64 string to decode.
    556.  * @returns {{earlyData: ArrayBuffer|null, error: Error|null}} An object containing the decoded ArrayBuffer or null if there was an error, and any error that occurred during decoding or null if there was no error.
    557.  */
    558. function base64ToArrayBuffer(base64Str) {
    559. 	if (!base64Str) {
    560. 		return { earlyData: null, error: null };
    561. 	}
    562. 	try {
    563. 		// go use modified Base64 for URL rfc4648 which js atob not support
    564. 		base64Str = base64Str.replace(/-/g, '+').replace(/_/g, '/');
    565. 		const decode = atob(base64Str);
    566. 		const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0));
    567. 		return { earlyData: arryBuffer.buffer, error: null };
    568. 	} catch (error) {
    569. 		return { earlyData: null, error };
    570. 	}
    571. }
    572.  
    573. /**
    574.  * Checks if a given string is a valid UUID.
    575.  * Note: This is not a real UUID validation.
    576.  * @param {string} uuid The string to validate as a UUID.
    577.  * @returns {boolean} True if the string is a valid UUID, false otherwise.
    578.  */
    579. function isValidUUID(uuid) {
    580. 	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;
    581. 	return uuidRegex.test(uuid);
    582. }
    583.  
    584. const WS_READY_STATE_OPEN = 1;
    585. const WS_READY_STATE_CLOSING = 2;
    586. /**
    587.  * Closes a WebSocket connection safely without throwing exceptions.
    588.  * @param {import("@cloudflare/workers-types").WebSocket} socket The WebSocket connection to close.
    589.  */
    590. function safeCloseWebSocket(socket) {
    591. 	try {
    592. 		if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) {
    593. 			socket.close();
    594. 		}
    595. 	} catch (error) {
    596. 		console.error('safeCloseWebSocket error', error);
    597. 	}
    598. }
    599.  
    600. const byteToHex = [];
    601.  
    602. for (let i = 0; i < 256; ++i) {
    603. 	byteToHex.push((i + 256).toString(16).slice(1));
    604. }
    605.  
    606. function unsafeStringify(arr, offset = 0) {
    607. 	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();
    608. }
    609.  
    610. function stringify(arr, offset = 0) {
    611. 	const uuid = unsafeStringify(arr, offset);
    612. 	if (!isValidUUID(uuid)) {
    613. 		throw TypeError("Stringified UUID is invalid");
    614. 	}
    615. 	return uuid;
    616. }
    617.  
    618.  
    619. /**
    620.  * Handles outbound UDP traffic by transforming the data into DNS queries and sending them over a WebSocket connection.
    621.  * @param {import("@cloudflare/workers-types").WebSocket} webSocket The WebSocket connection to send the DNS queries over.
    622.  * @param {ArrayBuffer} vlessResponseHeader The VLESS response header.
    623.  * @param {(string) => void} log The logging function.
    624.  * @returns {{write: (chunk: Uint8Array) => void}} An object with a write method that accepts a Uint8Array chunk to write to the transform stream.
    625.  */
    626. async function handleUDPOutBound(webSocket, vlessResponseHeader, log) {
    627.  
    628. 	let isVlessHeaderSent = false;
    629. 	const transformStream = new TransformStream({
    630. 		start(controller) {
    631.  
    632. 		},
    633. 		transform(chunk, controller) {
    634. 			// udp message 2 byte is the the length of udp data
    635. 			// TODO: this should have bug, beacsue maybe udp chunk can be in two websocket message
    636. 			for (let index = 0; index < chunk.byteLength;) {
    637. 				const lengthBuffer = chunk.slice(index, index + 2);
    638. 				const udpPakcetLength = new DataView(lengthBuffer).getUint16(0);
    639. 				const udpData = new Uint8Array(
    640. 					chunk.slice(index + 2, index + 2 + udpPakcetLength)
    641. 				);
    642. 				index = index + 2 + udpPakcetLength;
    643. 				controller.enqueue(udpData);
    644. 			}
    645. 		},
    646. 		flush(controller) {
    647. 		}
    648. 	});
    649.  
    650. 	// only handle dns udp for now
    651. 	transformStream.readable.pipeTo(new WritableStream({
    652. 		async write(chunk) {
    653. 			const resp = await fetch(dohURL, // dns server url
    654. 				{
    655. 					method: 'POST',
    656. 					headers: {
    657. 						'content-type': 'application/dns-message',
    658. 					},
    659. 					body: chunk,
    660. 				})
    661. 			const dnsQueryResult = await resp.arrayBuffer();
    662. 			const udpSize = dnsQueryResult.byteLength;
    663. 			// console.log([...new Uint8Array(dnsQueryResult)].map((x) => x.toString(16)));
    664. 			const udpSizeBuffer = new Uint8Array([(udpSize >> 8) & 0xff, udpSize & 0xff]);
    665. 			if (webSocket.readyState === WS_READY_STATE_OPEN) {
    666. 				log(`doh success and dns message length is ${udpSize}`);
    667. 				if (isVlessHeaderSent) {
    668. 					webSocket.send(await new Blob([udpSizeBuffer, dnsQueryResult]).arrayBuffer());
    669. 				} else {
    670. 					webSocket.send(await new Blob([vlessResponseHeader, udpSizeBuffer, dnsQueryResult]).arrayBuffer());
    671. 					isVlessHeaderSent = true;
    672. 				}
    673. 			}
    674. 		}
    675. 	})).catch((error) => {
    676. 		log('dns udp has error' + error)
    677. 	});
    678.  
    679. 	const writer = transformStream.writable.getWriter();
    680.  
    681. 	return {
    682. 		/**
    683. 		 * 
    684. 		 * @param {Uint8Array} chunk 
    685. 		 */
    686. 		write(chunk) {
    687. 			writer.write(chunk);
    688. 		}
    689. 	};
    690. }
    691.  
    692. /**
    693.  *
    694.  * @param {string} userID - single or comma separated userIDs
    695.  * @param {string | null} hostName
    696.  * @returns {string}
    697.  */
    698. function getVLESSConfig(userIDs, hostName) {
    699. 	const commonUrlPart = `:443?encryption=none&security=tls&sni=${hostName}&fp=randomized&type=ws&host=${hostName}&path=%2F%3Fed%3D2048#${hostName}`;
    700. 	const hashSeparator = "################################################################";
    701.  
    702. 	// Split the userIDs into an array
    703. 	const userIDArray = userIDs.split(",");
    704.  
    705. 	// Prepare output string for each userID
    706. 	const output = userIDArray.map((userID) => {
    707. 		const vlessMain = `vless://${userID}@${hostName}${commonUrlPart}`;
    708. 		const vlessSec = `vless://${userID}@${proxyIP}${commonUrlPart}`;
    709. 		return `<h2>UUID: ${userID}</h2>${hashSeparator}\nv2ray default ip
    710. ---------------------------------------------------------------
    711. ${vlessMain}
    712. <button onclick='copyToClipboard("${vlessMain}")'><i class="fa fa-clipboard"></i> Copy vlessMain</button>
    713. ---------------------------------------------------------------
    714. v2ray with bestip
    715. ---------------------------------------------------------------
    716. ${vlessSec}
    717. <button onclick='copyToClipboard("${vlessSec}")'><i class="fa fa-clipboard"></i> Copy vlessSec</button>
    718. ---------------------------------------------------------------`;
    719. 	}).join('\n');
    720. 	const sublink = `https://${hostName}/sub/${userIDArray[0]}?format=clash`
    721. 	const subbestip = `https://${hostName}/bestip/${userIDArray[0]}`;
    722. 	const clash_link = `https://api.v1.mk/sub?target=clash&url=${encodeURIComponent(sublink)}&insert=false&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`;
    723. 	// Prepare header string
    724. 	const header = `
    725. <p align='center'><img src='https://cloudflare-ipfs.com/ipfs/bafybeigd6i5aavwpr6wvnwuyayklq3omonggta4x2q7kpmgafj357nkcky' alt='图片描述' style='margin-bottom: -50px;'>
    726. <b style='font-size: 15px;'>Welcome! This function generates configuration for VLESS protocol. If you found this useful, please check our GitHub project for more:</b>
    727. <b style='font-size: 15px;'>欢迎！这是生成 VLESS 协议的配置。如果您发现这个项目很好用，请查看我们的 GitHub 项目给我一个star：</b>
    728. <a href='https://github.com/3Kmfi6HP/EDtunnel' target='_blank'>EDtunnel - https://github.com/3Kmfi6HP/EDtunnel</a>
    729. <iframe src='https://ghbtns.com/github-btn.html?user=USERNAME&repo=REPOSITORY&type=star&count=true&size=large' frameborder='0' scrolling='0' width='170' height='30' title='GitHub'></iframe>
    730. <a href='//${hostName}/sub/${userIDArray[0]}' target='_blank'>VLESS 节点订阅连接</a>
    731. <a href='clash://install-config?url=${encodeURIComponent(`https://${hostName}/sub/${userIDArray[0]}?format=clash`)}}' target='_blank'>Clash for Windows 节点订阅连接</a>
    732. <a href='${clash_link}' target='_blank'>Clash 节点订阅连接</a>
    733. <a href='${subbestip}' target='_blank'>优选IP自动节点订阅</a>
    734. <a href='clash://install-config?url=${encodeURIComponent(subbestip)}' target='_blank'>Clash优选IP自动</a>
    735. <a href='sing-box://import-remote-profile?url=${encodeURIComponent(subbestip)}' target='_blank'>singbox优选IP自动</a>
    736. <a href='sn://subscription?url=${encodeURIComponent(subbestip)}' target='_blank'>nekobox优选IP自动</a>
    737. <a href='v2rayng://install-config?url=${encodeURIComponent(subbestip)}' target='_blank'>v2rayNG优选IP自动</a></p>`;
    738.  
    739. 	// HTML Head with CSS and FontAwesome library
    740. 	const htmlHead = `
    741.   <head>
    742. 	<title>EDtunnel: VLESS configuration</title>
    743. 	<meta name='description' content='This is a tool for generating VLESS protocol configurations. Give us a star on GitHub https://github.com/3Kmfi6HP/EDtunnel if you found it useful!'>
    744. 	<meta name='keywords' content='EDtunnel, cloudflare pages, cloudflare worker, severless'>
    745. 	<meta name='viewport' content='width=device-width, initial-scale=1'>
    746. 	<meta property='og:site_name' content='EDtunnel: VLESS configuration' />
    747. 	<meta property='og:type' content='website' />
    748. 	<meta property='og:title' content='EDtunnel - VLESS configuration and subscribe output' />
    749. 	<meta property='og:description' content='Use cloudflare pages and worker severless to implement vless protocol' />
    750. 	<meta property='og:url' content='https://${hostName}/' />
    751. 	<meta property='og:image' content='https://api.qrserver.com/v1/create-qr-code/?size=500x500&data=${encodeURIComponent(`vless://${userIDs.split(",")[0]}@${hostName}${commonUrlPart}`)}' />
    752. 	<meta name='twitter:card' content='summary_large_image' />
    753. 	<meta name='twitter:title' content='EDtunnel - VLESS configuration and subscribe output' />
    754. 	<meta name='twitter:description' content='Use cloudflare pages and worker severless to implement vless protocol' />
    755. 	<meta name='twitter:url' content='https://${hostName}/' />
    756. 	<meta name='twitter:image' content='https://cloudflare-ipfs.com/ipfs/bafybeigd6i5aavwpr6wvnwuyayklq3omonggta4x2q7kpmgafj357nkcky' />
    757. 	<meta property='og:image:width' content='1500' />
    758. 	<meta property='og:image:height' content='1500' />
    759.  
    760. 	<style>
    761. 	body {
    762. 	  font-family: Arial, sans-serif;
    763. 	  background-color: #f0f0f0;
    764. 	  color: #333;
    765. 	  padding: 10px;
    766. 	}
    767.  
    768. 	a {
    769. 	  color: #1a0dab;
    770. 	  text-decoration: none;
    771. 	}
    772. 	img {
    773. 	  max-width: 100%;
    774. 	  height: auto;
    775. 	}
    776.  
    777. 	pre {
    778. 	  white-space: pre-wrap;
    779. 	  word-wrap: break-word;
    780. 	  background-color: #fff;
    781. 	  border: 1px solid #ddd;
    782. 	  padding: 15px;
    783. 	  margin: 10px 0;
    784. 	}
    785. 	/* Dark mode */
    786. 	@media (prefers-color-scheme: dark) {
    787. 	  body {
    788. 		background-color: #333;
    789. 		color: #f0f0f0;
    790. 	  }
    791.  
    792. 	  a {
    793. 		color: #9db4ff;
    794. 	  }
    795.  
    796. 	  pre {
    797. 		background-color: #282a36;
    798. 		border-color: #6272a4;
    799. 	  }
    800. 	}
    801. 	</style>
    802.  
    803. 	<!-- Add FontAwesome library -->
    804. 	<link rel='stylesheet' href='https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css'>
    805.   </head>
    806.   `;
    807.  
    808. 	// Join output with newlines, wrap inside <html> and <body>
    809. 	return `
    810.   <html>
    811.   ${htmlHead}
    812.   <body>
    813.   <pre style='background-color: transparent; border: none;'>${header}</pre>
    814.   <pre>${output}</pre>
    815.   </body>
    816.   <script>
    817. 	function copyToClipboard(text) {
    818. 	  navigator.clipboard.writeText(text)
    819. 		.then(() => {
    820. 		  alert("Copied to clipboard");
    821. 		})
    822. 		.catch((err) => {
    823. 		  console.error("Failed to copy to clipboard:", err);
    824. 		});
    825. 	}
    826.   </script>
    827.   </html>`;
    828. }
    829.  
    830. const portSet_http = new Set([80, 8080, 8880, 2052, 2086, 2095, 2082]);
    831. const portSet_https = new Set([443, 8443, 2053, 2096, 2087, 2083]);
    832.  
    833. function createVLESSSub(userID_Path, hostName) {
    834. 	const userIDArray = userID_Path.includes(',') ? userID_Path.split(',') : [userID_Path];
    835. 	const commonUrlPart_http = `?encryption=none&security=none&fp=random&type=ws&host=${hostName}&path=%2F%3Fed%3D2048#`;
    836. 	const commonUrlPart_https = `?encryption=none&security=tls&sni=${hostName}&fp=random&type=ws&host=${hostName}&path=%2F%3Fed%3D2048#`;
    837.  
    838. 	const output = userIDArray.flatMap((userID) => {
    839. 		const httpConfigurations = Array.from(portSet_http).flatMap((port) => {
    840. 			if (!hostName.includes('pages.dev')) {
    841. 				const urlPart = `${hostName}-HTTP-${port}`;
    842. 				const vlessMainHttp = `vless://${userID}@${hostName}:${port}${commonUrlPart_http}${urlPart}`;
    843. 				return proxyIPs.flatMap((proxyIP) => {
    844. 					const vlessSecHttp = `vless://${userID}@${proxyIP}:${port}${commonUrlPart_http}${urlPart}-${proxyIP}-EDtunnel`;
    845. 					return [vlessMainHttp, vlessSecHttp];
    846. 				});
    847. 			}
    848. 			return [];
    849. 		});
    850.  
    851. 		const httpsConfigurations = Array.from(portSet_https).flatMap((port) => {
    852. 			const urlPart = `${hostName}-HTTPS-${port}`;
    853. 			const vlessMainHttps = `vless://${userID}@${hostName}:${port}${commonUrlPart_https}${urlPart}`;
    854. 			return proxyIPs.flatMap((proxyIP) => {
    855. 				const vlessSecHttps = `vless://${userID}@${proxyIP}:${port}${commonUrlPart_https}${urlPart}-${proxyIP}-EDtunnel`;
    856. 				return [vlessMainHttps, vlessSecHttps];
    857. 			});
    858. 		});
    859.  
    860. 		return [...httpConfigurations, ...httpsConfigurations];
    861. 	});
    862.  
    863. 	return output.join('\n');
    864. }
    865.  
    866. const cn_hostnames = [
    867. 	// 'weibo.com',                // Weibo - A popular social media platform
    868. 	'baidu.com'            // Secoo - A Chinese luxury e-commerce platform
    869. ];



    正文到此结束
    本文标签：这篇文章木有标签
    您阅读这篇文章共花了： 0小时00分01秒
    本文链接：https://57scs.com/post-38.html
    版权声明：若无特殊注明，本文皆为《浪漫の小牛奶》原创，转载请保留文章出处。
    捐赠支持：如果觉得这篇文章对您有帮助，请“扫一扫”鼓励作者！

    热门推荐


    既然没有吐槽，那就赶紧抢沙发吧！
    返回顶部    返回首页    手气不错    捐赠支持    自定义链接    自定义链接    自定义链接    手机版本   后花园   
    版权所有：盛夏的回忆    站点维护：    今天是:2025年4月3日 星期四 |本站已安全运行了: 6395 天        
    正在加载中...