通过Worders打造专属于自己的ProxyIP免费订阅，高端玩法

通过Worders打造专属于自己的ProxyIP免费订阅，高端玩法，制作自己的订阅生成器和节点转换器，任意一个节点,可通过此方法，生产订阅链接。。。视频教程：https://youtu.be/KZgzMldGlDM
1，workers部署
代码地址：https://raw.githubusercontent.com/dockkkk/CF-WORKERS/main/worker.js

// version base on commit 43fad05dcdae3b723c53c226f8181fc5bd47223e, time is 2023-06-22 15:20:05 UTC.
// @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 = ‘63918e97-c93d-44b4-9d5d-af0093f64310’;
let proxyIP = ‘’;// 地址并不影响你的网速，cdn.xn—b6gac.eu.org’, ‘cdn-all.xn—b6gac.eu.org’, ‘edgetunnel.anycast.eu.org
//let sub = ‘’;// 留空则显示原版内容
let sub = ‘sub.cmliussss.workers.dev’;// 内置优选订阅生成器，
let subconverter = ‘api.v1.mk’;// clash订阅转换后端，目前使用自己的订阅转换功能。支持自建psub 可自行搭建https://github.com/bulianglin/psub
let subconfig = “https://github.com/ACL4SSR/ACL4SSR/blob/master/Clash/config/ACL4SSR_Mini_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 = ‘’;
let RproxyIP = ‘false’;
if (!isValidUUID(userID)) {
throw new Error(‘uuid is not valid’);
}
let parsedSocks5Address = {};
let enableSocks = false;
// 虚假uuid和hostname，用于发送给配置生成服务
let fakeUserID = “aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa”;
let fakeHostName = “EXAMPLE.COM”;
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 userAgent = request.headers.get('User-Agent').toLowerCase();
        userID = env.UUID || userID;
        proxyIP = env.PROXYIP || proxyIP;
        socks5Address = env.SOCKS5 || socks5Address;
        sub = env.SUB || sub;
        subconverter = env.SUBAPI || subconverter;
        subconfig = env.SUBCONFIG || subconfig;
        //RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false';
        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';
        }
        const upgradeHeader = request.headers.get('Upgrade');
        const url = new URL(request.url);
        if (!upgradeHeader || upgradeHeader !== 'websocket') {
            // const url = new URL(request.url);
            switch (url.pathname) {
            case '/':
                return new Response(JSON.stringify(request.cf), { status: 200 });
            case `/${userID}`: {
                const vlessConfig = await getVLESSConfig(userID, request.headers.get('Host'), sub, userAgent, RproxyIP);
                return new Response(`${vlessConfig}`, {
                status: 200,
                headers: {
                    "Content-Type": "text/plain;charset=utf-8",
                }
                });
            }
            default:
                return new Response('Not found', { status: 404 });
            }
        } else {
            if (new RegExp('/proxyip=', 'i').test(url.pathname)) proxyIP = url.pathname.split("=")[1];
            else if (new RegExp('/proxyip.', 'i').test(url.pathname)) proxyIP = url.pathname.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)
     );
     // 200185a300000370: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;
}
/**
@param {string} userID
@param {string | null} hostName
@param {string} sub
@param {string} userAgent

@returns {Promise<string>}
*/
async function getVLESSConfig(userID, hostName, sub, userAgent, RproxyIP) {
// 如果sub为空，则显示原始内容
if (!sub || sub === ‘’) {

 const vlessMain = `vless://${userID}@${hostName}:443?encryption=none&security=tls&sni=${hostName}&fp=randomized&type=ws&host=${hostName}&path=%2F%3Fed%3D2048#${hostName}`;

 return `

#

v2ray

${vlessMain}

#

clash-meta

type: vless
name: ${hostName}
server: ${hostName}
port: 443
uuid: ${userID}
network: ws
tls: true
udp: false
sni: ${hostName}
client-fingerprint: chrome
ws-opts:
path: “/?ed=2048”
headers:
```
host: ${hostName}
```

#

`;
} else if (sub && userAgent.includes(‘mozilla’) && !userAgent.includes(‘linux x86’)) {

 const vlessMain = `vless://${userID}@${hostName}:443?encryption=none&security=tls&sni=${hostName}&fp=randomized&type=ws&host=${hostName}&path=%2F%3Fed%3D2048#${hostName}`;

 return `

#

https://${hostName}/${userID}

#

v2ray

${vlessMain}

#

clash-meta

type: vless
name: ${hostName}
server: ${hostName}
port: 443
uuid: ${userID}
network: ws
tls: true
udp: false
sni: ${hostName}
client-fingerprint: chrome
ws-opts:
path: “/?ed=2048”
headers:
```
host: ${hostName}
```

#

telegram 交流群技术大佬~在线发牌!

https://t.me/tweekpiao

github 项目地址 Star!Star!Star!!!

https://github.com/dockkkk

#

`;
} else {

 if (typeof fetch != 'function') {
     return 'Error: fetch is not available in this environment.';
 }
 // 如果是使用默认域名，则改成一个workers的域名，订阅器会加上代理
 if (hostName.includes(".workers.dev") || hostName.includes(".pages.dev")) fakeHostName = "EXAMPLE.workers.dev";
 let content = "";
 let url = "";
 let isBase64 = false;
 if (userAgent.includes('clash')) {
     url = `https://${subconverter}/sub?target=clash&url=https%3A%2F%2F${sub}%2Fsub%3Fhost%3D${fakeHostName}%26uuid%3D${fakeUserID}%26edgetunnel%3Dcmliu%26proxyip%3D${RproxyIP}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=false&fdn=false&sort=false&new_name=true`;
 } else if (userAgent.includes('sing-box') || userAgent.includes('singbox')) {
     url = `https://${subconverter}/sub?target=singbox&url=https%3A%2F%2F${sub}%2Fsub%3Fhost%3D${fakeHostName}%26uuid%3D${fakeUserID}%26edgetunnel%3Dcmliu%26proxyip%3D${RproxyIP}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=false&fdn=false&sort=false&new_name=true`;
 } else {
     url = `https://${sub}/sub?host=${fakeHostName}&uuid=${fakeUserID}&edgetunnel=cmliu&proxyip=${RproxyIP}`;
     isBase64 = true;
 }
 try {
     const response = await fetch(url ,{
     headers: {
         'User-Agent': 'CF-Workers-edgetunnel/cmliu'
     }});
     content = await response.text();
     return revertFakeInfo(content, userID, hostName, isBase64);
 } catch (error) {
     console.error('Error fetching content:', error);
     return `Error fetching content: ${error.message}`;
 }

}
}

PROXYIP，也叫反代CFIP或者代理CFIP
23.162.136.169 47.254.66.75 proxyip.fxxk.dedyn.io cdn.xn—b6gac.eu.org cdn-all.xn—b6gac.eu.org edgetunnel.anycast.eu.org
SUB订阅生成器（后面讲自建）
sub.cmliussss.workers.devCM大佬订阅器

sub.kaiche.tkOTC大佬订阅器

cfwk.ckbk8708.workers.dev自建订阅器

生成器使用：https://生成器地址/sub?host=伪装域名&uuid=你的UUID&path=/?ed=2048

SUBAPI（订阅转换后端，默认用肥羊的后端，可自建教程）
后端api.v1.mk肥羊https://sub.v1.mk/

后端v.id9.cc 品云https://id9.cc/

后端sub.xeton.devA4大佬https://acl4ssr-sub.github.io/

SUBCONFIG(可以自行用4A大佬的负载均衡)
https://github.com/ACL4SSR/ACL4SSR/blob/master/Clash/config/ACL4SSR.ini

2，订阅器部署
代码地址：https://github.com/dockkkk/CF-WORKERS/edit/main/dingyue.js

3中方法设置优选IP: 优选域名，API，CSV

icook.tw:2053#台湾

cloudflare.cfgo.cc#优选官方

icook.hk:8443#香港

cfip.xxxxxxxx.tk#官方优选-otc提供

hk.100366.xyz#香港

ali.055500.xyz#香港

3，节点转换器部署
代码地址：https://github.com/dockkkk/CF-WORKERS/blob/main/zhuanhuan.js

变量：BACKEND https://api.v1.mk

创建存储桶：变量名称SUB_BUCKET

想了解的可以看下不良林的视频。

通过Worders打造专属于自己的ProxyIP免费订阅，高端玩法

#

v2ray

${vlessMain}

#

clash-meta

#

#

Subscribe / sub 订阅地址, 支持 Base64、clash-meta、sing-box 订阅格式, 您的订阅内容由 ${sub} 提供维护支持, 自动获取ProxyIP: ${RproxyIP}.

https://${hostName}/${userID}

#

v2ray

${vlessMain}

#

clash-meta

#

https://t.me/tweekpiao

https://github.com/dockkkk

#