.:. 草榴社區 » 技術討論區 » [自建科学上网] CF workers永久免费Trojan节点搭建教程：workers与pages两方案部署优选IP节点；如何看待Trojan被识别 [13P]
手機版回帖發布主題
--> 本頁主題: [自建科学上网] CF workers永久免费Trojan节点搭建教程：workers与pages两方案部署优选IP节点；如何看待Trojan被识别 [13P] 字體大小 寬屏顯示 只看樓主 最新點評 熱門評論 時間順序
柳东柚


級別：俠客 ( 9 )
發帖：195
威望：101 點
金錢：11538 USD
貢獻：0 點
註冊：2023-05-31
主題 資料 短信 推薦 編輯


[自建科学上网] CF workers永久免费Trojan节点搭建教程：workers与pages两方案部署优选IP节点；如何看待Trojan被识别 [13P]



1、CF workers的流量限制：workers与pages目前提供每天10万次免费请求，但很多人都超过了还能用。

2、优选域名的有效性：教程已说明两个被干的可能性，如果你平时一直用一个优选域名，且效果能满足你的要求，那别再去优选了，躺平吧！不然你天天选，那就与优选IP无异了，不如用优选IP更加有效果，所以，建议懒人小白使用。

3、某些eu.org域名都是大佬自己搞的CDN域名，日常要维护，如果有一天失效，不要惊讶。

4、你自己也可以搞个CDN域名，当然，你不会像大佬那样搞得这么复杂且优秀，最最简单的方式就是开启小黄云后的域名，这就是自己偷自己，不是偷大厂家的了。如选大厂的就直接躺平吧。

5、优选域名建议使用公共网站的域名，这样有隐蔽性！目前应用与脚本收录的数量仅收录知道的，大家可以在互联网上自行寻找哦！如果你找到一个公共优选域名，可以留个言哦，优选目录可以增加下！感谢你的参与。

6、优选大厂域名与优选IP的选择。打个比方，前者稳定但不快，后者不稳但快。且优选域名只要能ping通就能用，脚本显示的ping值的高低排序仅供参考，有时ping高的域名下载速度比ping低的域名还快哦，选择适合自己的吧。

7、优选域名也可以用在VPS搭建的WS协议上，可以看这期视频的应用：敏感时期代理协议被墙（封IP，封端口）：小白用户如何绕过GFW封锁，目前“四大方案"解君愁（躺平养老？死磕硬杠？先声夺人？），总有一种方案适合你，以小白角度总结目前代理协议与GFW的博弈。

8、关于优选IP：有优选CF官方IP（例：104开头的IP）与优选反代IP两种说法，优选反代IP更加容易失效（因为大多是上游大佬扫出来的，没自主权，且容易失效），教程中的脚本都为优选反代IP（已更新优选官方IP电脑版），而一般大厂的优选域名，所解析的IP都为CF官方IP。

优选CF官方IP：13个端口通用

CF大厂域名：13个端口通用

优选反代IP：指定端口

 

 

複製代碼
  1. src/worker.js
  2. import { connect } from "cloudflare:sockets";
  4. let Pswd = 'trojan';
  5. const proxyIPs = ["cdn.xn--b6gac.eu.org"]; //workers.cloudflare.cyou bestproxy.onecf.eu.org cdn-all.xn--b6gac.eu.org cdn.xn--b6gac.eu.org
  6. let hostnames = [''];
  8. let sha224Password ;
  9. let proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];
  10. const worker_default = {
  11.     /**
  12.      * @param {import("@cloudflare/workers-types").Request} request
  13.      * @param {proxyip: string, pswd: string} env
  14.      * @param {import("@cloudflare/workers-types").ExecutionContext} ctx
  15.      * @returns {Promise<Response>}
  16.      */
  17.     async fetch(request, env, ctx) {
  18.         try {
  19.             proxyIP = env.proxyip || proxyIP;
  20.             Pswd = env.pswd || Pswd
  21.             sha224Password = sha256.sha224(Pswd);
  22.             const upgradeHeader = request.headers.get("Upgrade");
  23.             if (!upgradeHeader || upgradeHeader !== 'websocket') {
  24.                 const url = new URL(request.url);
  25.                 switch (url.pathname) {
  26.                     case '/cf':
  27.                         return new Response(JSON.stringify(request.cf, null, 4), {
  28.                             status: 200,
  29.                             headers: {
  30.                                 "Content-Type": "application/json;charset=utf-8",
  31.                             },
  32.                         });
  33.                    
  34.                     case `/${Pswd}`: {
  35.                         const trojanConfig = gettrojanConfig(Pswd, request.headers.get('Host'));
  36.                         return new Response(`${trojanConfig}`, {
  37.                             status: 200,
  38.                             headers: {
  39.                                 "Content-Type": "text/plain;charset=utf-8",
  40.                             }
  41.                         });
  42.                     }
  43.                     default:
  44.                         // return new Response('Not found', { status: 404 });
  45.                         // For any other path, reverse proxy to 'ramdom website' and return the original response, caching it in the process
  46.                         const randomHostname = hostnames[Math.floor(Math.random() * hostnames.length)];
  47.                         const newHeaders = new Headers(request.headers);
  48.                         newHeaders.set('cf-connecting-ip', '1.2.3.4');
  49.                         newHeaders.set('x-forwarded-for', '1.2.3.4');
  50.                         newHeaders.set('x-real-ip', '1.2.3.4');
  51.                         newHeaders.set('referer', 'https://www.google.com/search?q=edtunnel');
  52.                         // Use fetch to proxy the request to 15 different domains
  53.                         const proxyUrl = 'https://' + randomHostname + url.pathname + url.search;
  54.                         let modifiedRequest = new Request(proxyUrl, {
  55.                             method: request.method,
  56.                             headers: newHeaders,
  57.                             body: request.body,
  58.                             redirect: 'manual',
  59.                         });
  60.                         const proxyResponse = await fetch(modifiedRequest, { redirect: 'manual' });
  61.                         // Check for 302 or 301 redirect status and return an error response
  62.                         if ([301, 302].includes(proxyResponse.status)) {
  63.                             return new Response(`Redirects to ${randomHostname} are not allowed.`, {
  64.                                 status: 403,
  65.                                 statusText: 'Forbidden',
  66.                             });
  67.                         }
  68.                         // Return the response from the proxy server
  69.                         return proxyResponse;
  70.                 }
  71.             } else {
  72.                 return await trojanOverWSHandler(request);
  73.             }
  74.         } catch (err) {
  75.             /** @type {Error} */ let e = err;
  76.             return new Response(e.toString());
  77.         }
  78.     },
  79. };
  81. async function trojanOverWSHandler(request) {
  82.     const webSocketPair = new WebSocketPair();
  83.     const [client, webSocket] = Object.values(webSocketPair);
  84.     webSocket.accept();
  85.     let address = "";
  86.     let portWithRandomLog = "";
  87.     const log = (info, event) => {
  88.         console.log(`[${address}:${portWithRandomLog}] ${info}`, event || "");
  89.     };
  90.     const earlyDataHeader = request.headers.get("sec-websocket-protocol") || "";
  91.     const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log);
  92.     let remoteSocketWapper = {
  93.         value: null
  94.     };
  95.     let udpStreamWrite = null;
  96.     readableWebSocketStream.pipeTo(new WritableStream({
  97.         async write(chunk, controller) {
  98.             if (udpStreamWrite) {
  99.                 return udpStreamWrite(chunk);
  100.             }
  101.             if (remoteSocketWapper.value) {
  102.                 const writer = remoteSocketWapper.value.writable.getWriter();
  103.                 await writer.write(chunk);
  104.                 writer.releaseLock();
  105.                 return;
  106.             }
  107.             const {
  108.                 hasError,
  109.                 message,
  110.                 portRemote = 443,
  111.                 addressRemote = "",
  112.                 rawClientData
  113.             } = await parseTrojanHeader(chunk);
  114.             address = addressRemote;
  115.             portWithRandomLog = `${portRemote}--${Math.random()} tcp`;
  116.             if (hasError) {
  117.                 throw new Error(message);
  118.                 return;
  119.             }
  120.             handleTCPOutBound(remoteSocketWapper, addressRemote, portRemote, rawClientData, webSocket, log);
  121.         },
  122.         close() {
  123.             log(`readableWebSocketStream is closed`);
  124.         },
  125.         abort(reason) {
  126.             log(`readableWebSocketStream is aborted`, JSON.stringify(reason));
  127.         }
  128.     })).catch((err) => {
  129.         log("readableWebSocketStream pipeTo error", err);
  130.     });
  131.     return new Response(null, {
  132.         status: 101,
  133.         // @ts-ignore
  134.         webSocket: client
  135.     });
  136. }
  138. async function parseTrojanHeader(buffer) {
  139.     if (buffer.byteLength < 56) {
  140.         return {
  141.             hasError: true,
  142.             message: "invalid data"
  143.         };
  144.     }
  145.     let crLfIndex = 56;
  146.     if (new Uint8Array(buffer.slice(56, 57))[0] !== 0x0d || new Uint8Array(buffer.slice(57, 58))[0] !== 0x0a) {
  147.         return {
  148.             hasError: true,
  149.             message: "invalid header format (missing CR LF)"
  150.         };
  151.     }
  152.     const password = new TextDecoder().decode(buffer.slice(0, crLfIndex));
  153.     if (password !== sha224Password) {
  154.         return {
  155.             hasError: true,
  156.             message: "invalid password"
  157.         };
  158.     }
  160.     const socks5DataBuffer = buffer.slice(crLfIndex + 2);
  161.     if (socks5DataBuffer.byteLength < 6) {
  162.         return {
  163.             hasError: true,
  164.             message: "invalid SOCKS5 request data"
  165.         };
  166.     }
  168.     const view = new DataView(socks5DataBuffer);
  169.     const cmd = view.getUint8(0);
  170.     if (cmd !== 1) {
  171.         return {
  172.             hasError: true,
  173.             message: "unsupported command, only TCP (CONNECT) is allowed"
  174.         };
  175.     }
  177.     const atype = view.getUint8(1);
  178.     // 0x01: IPv4 address
  179.     // 0x03: Domain name
  180.     // 0x04: IPv6 address
  181.     let addressLength = 0;
  182.     let addressIndex = 2;
  183.     let address = "";
  184.     switch (atype) {
  185.         case 1:
  186.             addressLength = 4;
  187.             address = new Uint8Array(
  188.               socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)
  189.             ).join(".");
  190.             break;
  191.         case 3:
  192.             addressLength = new Uint8Array(
  193.               socks5DataBuffer.slice(addressIndex, addressIndex + 1)
  194.             )[0];
  195.             addressIndex += 1;
  196.             address = new TextDecoder().decode(
  197.               socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)
  198.             );
  199.             break;
  200.         case 4:
  201.             addressLength = 16;
  202.             const dataView = new DataView(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength));
  203.             const ipv6 = [];
  204.             for (let i = 0; i < 8; i++) {
  205.                 ipv6.push(dataView.getUint16(i * 2).toString(16));
  206.             }
  207.             address = ipv6.join(":");
  208.             break;
  209.         default:
  210.             return {
  211.                 hasError: true,
  212.                 message: `invalid addressType is ${atype}`
  213.             };
  214.     }
  216.     if (!address) {
  217.         return {
  218.             hasError: true,
  219.             message: `address is empty, addressType is ${atype}`
  220.         };
  221.     }
  223.     const portIndex = addressIndex + addressLength;
  224.     const portBuffer = socks5DataBuffer.slice(portIndex, portIndex + 2);
  225.     const portRemote = new DataView(portBuffer).getUint16(0);
  226.     return {
  227.         hasError: false,
  228.         addressRemote: address,
  229.         portRemote,
  230.         rawClientData: socks5DataBuffer.slice(portIndex + 4)
  231.     };
  232. }
  234. async function handleTCPOutBound(remoteSocket, addressRemote, portRemote, rawClientData, webSocket, log) {
  235.     async function connectAndWrite(address, port) {
  236.         const tcpSocket2 = connect({
  237.             hostname: address,
  238.             port
  239.         });
  240.         remoteSocket.value = tcpSocket2;
  241.         log(`connected to ${address}:${port}`);
  242.         const writer = tcpSocket2.writable.getWriter();
  243.         await writer.write(rawClientData);
  244.         writer.releaseLock();
  245.         return tcpSocket2;
  246.     }
  247.     async function retry() {
  248.         const tcpSocket2 = await connectAndWrite(proxyIP || addressRemote, portRemote);
  249.         tcpSocket2.closed.catch((error) => {
  250.             console.log("retry tcpSocket closed error", error);
  251.         }).finally(() => {
  252.             safeCloseWebSocket(webSocket);
  253.         });
  254.         remoteSocketToWS(tcpSocket2, webSocket, null, log);
  255.     }
  256.     const tcpSocket = await connectAndWrite(addressRemote, portRemote);
  257.     remoteSocketToWS(tcpSocket, webSocket, retry, log);
  258. }
  260. function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) {
  261.     let readableStreamCancel = false;
  262.     const stream = new ReadableStream({
  263.         start(controller) {
  264.             webSocketServer.addEventListener("message", (event) => {
  265.                 if (readableStreamCancel) {
  266.                     return;
  267.                 }
  268.                 const message = event.data;
  269.                 controller.enqueue(message);
  270.             });
  271.             webSocketServer.addEventListener("close", () => {
  272.                 safeCloseWebSocket(webSocketServer);
  273.                 if (readableStreamCancel) {
  274.                     return;
  275.                 }
  276.                 controller.close();
  277.             });
  278.             webSocketServer.addEventListener("error", (err) => {
  279.                 log("webSocketServer error");
  280.                 controller.error(err);
  281.             });
  282.             const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader);
  283.             if (error) {
  284.                 controller.error(error);
  285.             } else if (earlyData) {
  286.                 controller.enqueue(earlyData);
  287.             }
  288.         },
  289.         pull(controller) {},
  290.         cancel(reason) {
  291.             if (readableStreamCancel) {
  292.                 return;
  293.             }
  294.             log(`readableStream was canceled, due to ${reason}`);
  295.             readableStreamCancel = true;
  296.             safeCloseWebSocket(webSocketServer);
  297.         }
  298.     });
  299.     return stream;
  300. }
  302. async function remoteSocketToWS(remoteSocket, webSocket, retry, log) {
  303.     let hasIncomingData = false;
  304.     await remoteSocket.readable.pipeTo(
  305.         new WritableStream({
  306.             start() {},
  307.             /**
  308.              *
  309.              * @param {Uint8Array} chunk
  310.              * @param {*} controller
  311.              */
  312.             async write(chunk, controller) {
  313.                 hasIncomingData = true;
  314.                 if (webSocket.readyState !== WS_READY_STATE_OPEN) {
  315.                     controller.error(
  316.                         "webSocket connection is not open"
  317.                     );
  318.                 }
  319.                 webSocket.send(chunk);
  320.             },
  321.             close() {
  322.                 log(`remoteSocket.readable is closed, hasIncomingData: ${hasIncomingData}`);
  323.             },
  324.             abort(reason) {
  325.                 console.error("remoteSocket.readable abort", reason);
  326.             }
  327.         })
  328.     ).catch((error) => {
  329.         console.error(
  330.             `remoteSocketToWS error:`,
  331.             error.stack || error
  332.         );
  333.         safeCloseWebSocket(webSocket);
  334.     });
  335.     if (hasIncomingData === false && retry) {
  336.         log(`retry`);
  337.         retry();
  338.     }
  339. }
  341. function base64ToArrayBuffer(base64Str) {
  342.     if (!base64Str) {
  343.         return { error: null };
  344.     }
  345.     try {
  346.         base64Str = base64Str.replace(/-/g, "+").replace(/_/g, "/");
  347.         const decode = atob(base64Str);
  348.         const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0));
  349.         return { earlyData: arryBuffer.buffer, error: null };
  350.     } catch (error) {
  351.         return { error };
  352.     }
  353. }
  355. let WS_READY_STATE_OPEN = 1;
  356. let WS_READY_STATE_CLOSING = 2;
  358. function safeCloseWebSocket(socket) {
  359.     try {
  360.         if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) {
  361.             socket.close();
  362.         }
  363.     } catch (error) {
  364.         console.error("safeCloseWebSocket error", error);
  365.     }
  366. }
  367. export {
  368.     worker_default as
  369.     default
  370. };
  372. //# sourceMappingURL=worker.js.map
  373. function gettrojanConfig(Pswd, hostName) {
  374.     const wtrojanws = `trojan://${Pswd}\u0040www.visa.com.sg:8880?security=none&type=ws&host=${hostName}&path=%2F%3Fed%3D2560#${hostName}`;
  375.     const ptrojanwstls = `trojan://${Pswd}\u0040www.visa.com.sg:8443?security=tls&type=ws&host=${hostName}&sni=${hostName}&fp=random&path=%2F%3Fed%3D2560#${hostName}`;
  376.     const note = `甬哥博客地址：https://ygkkk.blogspot.com\n甬哥YouTube频道：https://www.youtube.com/@ygkkk\n甬哥TG电报群组：https://t.me/+jZHc6-A-1QQ5ZGVl\n甬哥TG电报频道：https://t.me/+DkC9ZZUgEFQzMTZl\n\n\n正在使用的ProxyIP：${proxyIP}`;
  377.  
  378.     if (hostName.includes('pages.dev')) {
  379.     return `
  380. ==========================配置详解==============================
  382. ${note}
  384. ################################################################
  385. CF-pages-trojan+ws+tls节点，分享链接如下：
  387. ${ptrojanwstls}
  389. ---------------------------------------------------------------
  390. 注意：如果 ${hostName} 在本地网络打不开（中国移动用户注意），客户端必须开启切片功能
  391. ---------------------------------------------------------------
  392. 客户端必要文明参数如下：
  393. 客户端地址(address)：自定义的域名 或者 优选域名 或者 优选IP（反代IP必须与反代端口对应）
  394. 端口(port)：6个https端口可任意选择(443、8443、2053、2083、2087、2096)
  395. 密码：${Pswd}
  396. 传输协议(network)：ws 或者 websocket
  397. 伪装域名(host)：${hostName}
  398. 路径(path)：/?ed=2560
  399. 传输安全(TLS)：开启
  400. 跳过证书验证(allowlnsecure)：false
  401. ################################################################
  402. `;
  403.   } else {
  404.     return `
  405. ==========================配置详解==============================
  407. ${note}
  409. ################################################################
  410. 一、CF-workers-trojan+ws节点，分享链接如下：
  412. ${wtrojanws}
  414. ---------------------------------------------------------------
  415. 注意：当前节点无需使用CF解析完成的域名，客户端选项的TLS选项必须关闭
  416. ---------------------------------------------------------------
  417. 客户端必要文明参数如下：
  418. 客户端地址(address)：自定义的域名 或者 优选域名 或者 优选IP（反代IP必须与反代端口对应）
  419. 端口(port)：7个http端口可任意选择(80、8080、8880、2052、2082、2086、2095)
  420. 密码：${Pswd}
  421. 传输协议(network)：ws 或者 websocket
  422. 伪装域名(host)：${hostName}
  423. 路径(path)：/?ed=2560
  424. ################################################################
  426. ################################################################
  427. 二、CF-workers-trojan+ws+tls 或者 CF-pages-trojan+ws+tls节点，分享链接如下：
  429. ${ptrojanwstls}
  431. ---------------------------------------------------------------
  432. 注意：使用workers域名开启TLS，客户端必须开启切片功能
  433. ---------------------------------------------------------------
  434. 客户端必要文明参数如下：
  435. 客户端地址(address)：自定义的域名 或者 优选域名 或者 优选IP（反代IP必须与反代端口对应）
  436. 端口(port)：6个https端口可任意选择(443、8443、2053、2083、2087、2096)
  437. 密码：${Pswd}
  438. 传输协议(network)：ws 或者 websocket
  439. 伪装域名(host)：${hostName}
  440. 路径(path)：/?ed=2560
  441. 传输安全(TLS)：开启
  442. 跳过证书验证(allowlnsecure)：false
  443. ################################################################
  444. `;
  445.   }
  446. }
  448. /**
  449. * [js-sha256]{@link https://github.com/emn178/js-sha256}
  450. *
  451. * @version 0.11.0
  452. * @author Chen, Yi-Cyuan [[email][email protected][/email]]
  453. * @copyright Chen, Yi-Cyuan 2014-2024
  454. * @license MIT
  455. */
  456. /*jslint bitwise: true */
  457. (function () {
  458.   'use strict';
  460.   var ERROR = 'input is invalid type';
  461.   var WINDOW = typeof window === 'object';
  462.   var root = WINDOW ? window : {};
  463.   if (root.JS_SHA256_NO_WINDOW) {
  464.     WINDOW = false;
  465.   }
  466.   var WEB_WORKER = !WINDOW && typeof self === 'object';
  467.   var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
  468.   if (NODE_JS) {
  469.     root = global;
  470.   } else if (WEB_WORKER) {
  471.     root = self;
  472.   }
  473.   var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module === 'object' && module.exports;
  474.   var AMD = typeof define === 'function' && define.amd;
  475.   var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
  476.   var HEX_CHARS = '0123456789abcdef'.split('');
  477.   var EXTRA = [-2147483648, 8388608, 32768, 128];
  478.   var SHIFT = [24, 16, 8, 0];
  479.   var K = [
  480.     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
  481.     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
  482.     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
  483.     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
  484.     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
  485.     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
  486.     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
  487.     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
  488.   ];
  489.   var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
  491.   var blocks = [];
  493.   if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {
  494.     Array.isArray = function (obj) {
  495.       return Object.prototype.toString.call(obj) === '[object Array]';
  496.     };
  497.   }
  499.   if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
  500.     ArrayBuffer.isView = function (obj) {
  501.       return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
  502.     };
  503.   }
  505.   var createOutputMethod = function (outputType, is224) {
  506.     return function (message) {
  507.       return new Sha256(is224, true).update(message)[outputType]();
  508.     };
  509.   };
  511.   var createMethod = function (is224) {
  512.     var method = createOutputMethod('hex', is224);
  513.     if (NODE_JS) {
  514.       method = nodeWrap(method, is224);
  515.     }
  516.     method.create = function () {
  517.       return new Sha256(is224);
  518.     };
  519.     method.update = function (message) {
  520.       return method.create().update(message);
  521.     };
  522.     for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
  523.       var type = OUTPUT_TYPES[i];
  524.       method[type] = createOutputMethod(type, is224);
  525.     }
  526.     return method;
  527.   };
  529.   var nodeWrap = function (method, is224) {
  530.     var crypto = require('crypto')
  531.     var Buffer = require('buffer').Buffer;
  532.     var algorithm = is224 ? 'sha224' : 'sha256';
  533.     var bufferFrom;
  534.     if (Buffer.from && !root.JS_SHA256_NO_BUFFER_FROM) {
  535.       bufferFrom = Buffer.from;
  536.     } else {
  537.       bufferFrom = function (message) {
  538.         return new Buffer(message);
  539.       };
  540.     }
  541.     var nodeMethod = function (message) {
  542.       if (typeof message === 'string') {
  543.         return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');
  544.       } else {
  545.         if (message === null || message === undefined) {
  546.           throw new Error(ERROR);
  547.         } else if (message.constructor === ArrayBuffer) {
  548.           message = new Uint8Array(message);
  549.         }
  550.       }
  551.       if (Array.isArray(message) || ArrayBuffer.isView(message) ||
  552.         message.constructor === Buffer) {
  553.         return crypto.createHash(algorithm).update(bufferFrom(message)).digest('hex');
  554.       } else {
  555.         return method(message);
  556.       }
  557.     };
  558.     return nodeMethod;
  559.   };
  561.   var createHmacOutputMethod = function (outputType, is224) {
  562.     return function (key, message) {
  563.       return new HmacSha256(key, is224, true).update(message)[outputType]();
  564.     };
  565.   };
  567.   var createHmacMethod = function (is224) {
  568.     var method = createHmacOutputMethod('hex', is224);
  569.     method.create = function (key) {
  570.       return new HmacSha256(key, is224);
  571.     };
  572.     method.update = function (key, message) {
  573.       return method.create(key).update(message);
  574.     };
  575.     for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
  576.       var type = OUTPUT_TYPES[i];
  577.       method[type] = createHmacOutputMethod(type, is224);
  578.     }
  579.     return method;
  580.   };
  582.   function Sha256(is224, sharedMemory) {
  583.     if (sharedMemory) {
  584.       blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
  585.         blocks[4] = blocks[5] = blocks[6] = blocks[7] =
  586.         blocks[8] = blocks[9] = blocks[10] = blocks[11] =
  587.         blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
  588.       this.blocks = blocks;
  589.     } else {
  590.       this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  591.     }
  593.     if (is224) {
  594.       this.h0 = 0xc1059ed8;
  595.       this.h1 = 0x367cd507;
  596.       this.h2 = 0x3070dd17;
  597.       this.h3 = 0xf70e5939;
  598.       this.h4 = 0xffc00b31;
  599.       this.h5 = 0x68581511;
  600.       this.h6 = 0x64f98fa7;
  601.       this.h7 = 0xbefa4fa4;
  602.     } else { // 256
  603.       this.h0 = 0x6a09e667;
  604.       this.h1 = 0xbb67ae85;
  605.       this.h2 = 0x3c6ef372;
  606.       this.h3 = 0xa54ff53a;
  607.       this.h4 = 0x510e527f;
  608.       this.h5 = 0x9b05688c;
  609.       this.h6 = 0x1f83d9ab;
  610.       this.h7 = 0x5be0cd19;
  611.     }
  613.     this.block = this.start = this.bytes = this.hBytes = 0;
  614.     this.finalized = this.hashed = false;
  615.     this.first = true;
  616.     this.is224 = is224;
  617.   }
  619.   Sha256.prototype.update = function (message) {
  620.     if (this.finalized) {
  621.       return;
  622.     }
  623.     var notString, type = typeof message;
  624.     if (type !== 'string') {
  625.       if (type === 'object') {
  626.         if (message === null) {
  627.           throw new Error(ERROR);
  628.         } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
  629.           message = new Uint8Array(message);
  630.         } else if (!Array.isArray(message)) {
  631.           if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
  632.             throw new Error(ERROR);
  633.           }
  634.         }
  635.       } else {
  636.         throw new Error(ERROR);
  637.       }
  638.       notString = true;
  639.     }
  640.     var code, index = 0, i, length = message.length, blocks = this.blocks;
  641.     while (index < length) {
  642.       if (this.hashed) {
  643.         this.hashed = false;
  644.         blocks[0] = this.block;
  645.         this.block = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
  646.           blocks[4] = blocks[5] = blocks[6] = blocks[7] =
  647.           blocks[8] = blocks[9] = blocks[10] = blocks[11] =
  648.           blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
  649.       }
  651.       if (notString) {
  652.         for (i = this.start; index < length && i < 64; ++index) {
  653.           blocks[i >>> 2] |= message[index] << SHIFT[i++ & 3];
  654.         }
  655.       } else {
  656.         for (i = this.start; index < length && i < 64; ++index) {
  657.           code = message.charCodeAt(index);
  658.           if (code < 0x80) {
  659.             blocks[i >>> 2] |= code << SHIFT[i++ & 3];
  660.           } else if (code < 0x800) {
  661.             blocks[i >>> 2] |= (0xc0 | (code >>> 6)) << SHIFT[i++ & 3];
  662.             blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
  663.           } else if (code < 0xd800 || code >= 0xe000) {
  664.             blocks[i >>> 2] |= (0xe0 | (code >>> 12)) << SHIFT[i++ & 3];
  665.             blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
  666.             blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
  667.           } else {
  668.             code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
  669.             blocks[i >>> 2] |= (0xf0 | (code >>> 18)) << SHIFT[i++ & 3];
  670.             blocks[i >>> 2] |= (0x80 | ((code >>> 12) & 0x3f)) << SHIFT[i++ & 3];
  671.             blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
  672.             blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
  673.           }
  674.         }
  675.       }
  677.       this.lastByteIndex = i;
  678.       this.bytes += i - this.start;
  679.       if (i >= 64) {
  680.         this.block = blocks[16];
  681.         this.start = i - 64;
  682.         this.hash();
  683.         this.hashed = true;
  684.       } else {
  685.         this.start = i;
  686.       }
  687.     }
  688.     if (this.bytes > 4294967295) {
  689.       this.hBytes += this.bytes / 4294967296 << 0;
  690.       this.bytes = this.bytes % 4294967296;
  691.     }
  692.     return this;
  693.   };
  695.   Sha256.prototype.finalize = function () {
  696.     if (this.finalized) {
  697.       return;
  698.     }
  699.     this.finalized = true;
  700.     var blocks = this.blocks, i = this.lastByteIndex;
  701.     blocks[16] = this.block;
  702.     blocks[i >>> 2] |= EXTRA[i & 3];
  703.     this.block = blocks[16];
  704.     if (i >= 56) {
  705.       if (!this.hashed) {
  706.         this.hash();
  707.       }
  708.       blocks[0] = this.block;
  709.       blocks[16] = blocks[1] = blocks[2] = blocks[3] =
  710.         blocks[4] = blocks[5] = blocks[6] = blocks[7] =
  711.         blocks[8] = blocks[9] = blocks[10] = blocks[11] =
  712.         blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
  713.     }
  714.     blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
  715.     blocks[15] = this.bytes << 3;
  716.     this.hash();
  717.   };
  719.   Sha256.prototype.hash = function () {
  720.     var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6,
  721.       h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
  723.     for (j = 16; j < 64; ++j) {
  724.       // rightrotate
  725.       t1 = blocks[j - 15];
  726.       s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);
  727.       t1 = blocks[j - 2];
  728.       s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);
  729.       blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;
  730.     }
  732.     bc = b & c;
  733.     for (j = 0; j < 64; j += 4) {
  734.       if (this.first) {
  735.         if (this.is224) {
  736.           ab = 300032;
  737.           t1 = blocks[0] - 1413257819;
  738.           h = t1 - 150054599 << 0;
  739.           d = t1 + 24177077 << 0;
  740.         } else {
  741.           ab = 704751109;
  742.           t1 = blocks[0] - 210244248;
  743.           h = t1 - 1521486534 << 0;
  744.           d = t1 + 143694565 << 0;
  745.         }
  746.         this.first = false;
  747.       } else {
  748.         s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
  749.         s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
  750.         ab = a & b;
  751.         maj = ab ^ (a & c) ^ bc;
  752.         ch = (e & f) ^ (~e & g);
  753.         t1 = h + s1 + ch + K[j] + blocks[j];
  754.         t2 = s0 + maj;
  755.         h = d + t1 << 0;
  756.         d = t1 + t2 << 0;
  757.       }
  758.       s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));
  759.       s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));
  760.       da = d & a;
  761.       maj = da ^ (d & b) ^ ab;
  762.       ch = (h & e) ^ (~h & f);
  763.       t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
  764.       t2 = s0 + maj;
  765.       g = c + t1 << 0;
  766.       c = t1 + t2 << 0;
  767.       s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));
  768.       s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));
  769.       cd = c & d;
  770.       maj = cd ^ (c & a) ^ da;
  771.       ch = (g & h) ^ (~g & e);
  772.       t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
  773.       t2 = s0 + maj;
  774.       f = b + t1 << 0;
  775.       b = t1 + t2 << 0;
  776.       s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));
  777.       s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));
  778.       bc = b & c;
  779.       maj = bc ^ (b & d) ^ cd;
  780.       ch = (f & g) ^ (~f & h);
  781.       t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
  782.       t2 = s0 + maj;
  783.       e = a + t1 << 0;
  784.       a = t1 + t2 << 0;
  785.       this.chromeBugWorkAround = true;
  786.     }
  788.     this.h0 = this.h0 + a << 0;
  789.     this.h1 = this.h1 + b << 0;
  790.     this.h2 = this.h2 + c << 0;
  791.     this.h3 = this.h3 + d << 0;
  792.     this.h4 = this.h4 + e << 0;
  793.     this.h5 = this.h5 + f << 0;
  794.     this.h6 = this.h6 + g << 0;
  795.     this.h7 = this.h7 + h << 0;
  796.   };
  798.   Sha256.prototype.hex = function () {
  799.     this.finalize();
  801.     var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
  802.       h6 = this.h6, h7 = this.h7;
  804.     var hex = HEX_CHARS[(h0 >>> 28) & 0x0F] + HEX_CHARS[(h0 >>> 24) & 0x0F] +
  805.       HEX_CHARS[(h0 >>> 20) & 0x0F] + HEX_CHARS[(h0 >>> 16) & 0x0F] +
  806.       HEX_CHARS[(h0 >>> 12) & 0x0F] + HEX_CHARS[(h0 >>> 8) & 0x0F] +
  807.       HEX_CHARS[(h0 >>> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
  808.       HEX_CHARS[(h1 >>> 28) & 0x0F] + HEX_CHARS[(h1 >>> 24) & 0x0F] +
  809.       HEX_CHARS[(h1 >>> 20) & 0x0F] + HEX_CHARS[(h1 >>> 16) & 0x0F] +
  810.       HEX_CHARS[(h1 >>> 12) & 0x0F] + HEX_CHARS[(h1 >>> 8) & 0x0F] +
  811.       HEX_CHARS[(h1 >>> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
  812.       HEX_CHARS[(h2 >>> 28) & 0x0F] + HEX_CHARS[(h2 >>> 24) & 0x0F] +
  813.       HEX_CHARS[(h2 >>> 20) & 0x0F] + HEX_CHARS[(h2 >>> 16) & 0x0F] +
  814.       HEX_CHARS[(h2 >>> 12) & 0x0F] + HEX_CHARS[(h2 >>> 8) & 0x0F] +
  815.       HEX_CHARS[(h2 >>> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
  816.       HEX_CHARS[(h3 >>> 28) & 0x0F] + HEX_CHARS[(h3 >>> 24) & 0x0F] +
  817.       HEX_CHARS[(h3 >>> 20) & 0x0F] + HEX_CHARS[(h3 >>> 16) & 0x0F] +
  818.       HEX_CHARS[(h3 >>> 12) & 0x0F] + HEX_CHARS[(h3 >>> 8) & 0x0F] +
  819.       HEX_CHARS[(h3 >>> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
  820.       HEX_CHARS[(h4 >>> 28) & 0x0F] + HEX_CHARS[(h4 >>> 24) & 0x0F] +
  821.       HEX_CHARS[(h4 >>> 20) & 0x0F] + HEX_CHARS[(h4 >>> 16) & 0x0F] +
  822.       HEX_CHARS[(h4 >>> 12) & 0x0F] + HEX_CHARS[(h4 >>> 8) & 0x0F] +
  823.       HEX_CHARS[(h4 >>> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
  824.       HEX_CHARS[(h5 >>> 28) & 0x0F] + HEX_CHARS[(h5 >>> 24) & 0x0F] +
  825.       HEX_CHARS[(h5 >>> 20) & 0x0F] + HEX_CHARS[(h5 >>> 16) & 0x0F] +
  826.       HEX_CHARS[(h5 >>> 12) & 0x0F] + HEX_CHARS[(h5 >>> 8) & 0x0F] +
  827.       HEX_CHARS[(h5 >>> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
  828.       HEX_CHARS[(h6 >>> 28) & 0x0F] + HEX_CHARS[(h6 >>> 24) & 0x0F] +
  829.       HEX_CHARS[(h6 >>> 20) & 0x0F] + HEX_CHARS[(h6 >>> 16) & 0x0F] +
  830.       HEX_CHARS[(h6 >>> 12) & 0x0F] + HEX_CHARS[(h6 >>> 8) & 0x0F] +
  831.       HEX_CHARS[(h6 >>> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
  832.     if (!this.is224) {
  833.       hex += HEX_CHARS[(h7 >>> 28) & 0x0F] + HEX_CHARS[(h7 >>> 24) & 0x0F] +
  834.         HEX_CHARS[(h7 >>> 20) & 0x0F] + HEX_CHARS[(h7 >>> 16) & 0x0F] +
  835.         HEX_CHARS[(h7 >>> 12) & 0x0F] + HEX_CHARS[(h7 >>> 8) & 0x0F] +
  836.         HEX_CHARS[(h7 >>> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
  837.     }
  838.     return hex;
  839.   };
  841.   Sha256.prototype.toString = Sha256.prototype.hex;
  843.   Sha256.prototype.digest = function () {
  844.     this.finalize();
  846.     var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
  847.       h6 = this.h6, h7 = this.h7;
  849.     var arr = [
  850.       (h0 >>> 24) & 0xFF, (h0 >>> 16) & 0xFF, (h0 >>> 8) & 0xFF, h0 & 0xFF,
  851.       (h1 >>> 24) & 0xFF, (h1 >>> 16) & 0xFF, (h1 >>> 8) & 0xFF, h1 & 0xFF,
  852.       (h2 >>> 24) & 0xFF, (h2 >>> 16) & 0xFF, (h2 >>> 8) & 0xFF, h2 & 0xFF,
  853.       (h3 >>> 24) & 0xFF, (h3 >>> 16) & 0xFF, (h3 >>> 8) & 0xFF, h3 & 0xFF,
  854.       (h4 >>> 24) & 0xFF, (h4 >>> 16) & 0xFF, (h4 >>> 8) & 0xFF, h4 & 0xFF,
  855.       (h5 >>> 24) & 0xFF, (h5 >>> 16) & 0xFF, (h5 >>> 8) & 0xFF, h5 & 0xFF,
  856.       (h6 >>> 24) & 0xFF, (h6 >>> 16) & 0xFF, (h6 >>> 8) & 0xFF, h6 & 0xFF
  857.     ];
  858.     if (!this.is224) {
  859.       arr.push((h7 >>> 24) & 0xFF, (h7 >>> 16) & 0xFF, (h7 >>> 8) & 0xFF, h7 & 0xFF);
  860.     }
  861.     return arr;
  862.   };
  864.   Sha256.prototype.array = Sha256.prototype.digest;
  866.   Sha256.prototype.arrayBuffer = function () {
  867.     this.finalize();
  869.     var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
  870.     var dataView = new DataView(buffer);
  871.     dataView.setUint32(0, this.h0);
  872.     dataView.setUint32(4, this.h1);
  873.     dataView.setUint32(8, this.h2);
  874.     dataView.setUint32(12, this.h3);
  875.     dataView.setUint32(16, this.h4);
  876.     dataView.setUint32(20, this.h5);
  877.     dataView.setUint32(24, this.h6);
  878.     if (!this.is224) {
  879.       dataView.setUint32(28, this.h7);
  880.     }
  881.     return buffer;
  882.   };
  884.   function HmacSha256(key, is224, sharedMemory) {
  885.     var i, type = typeof key;
  886.     if (type === 'string') {
  887.       var bytes = [], length = key.length, index = 0, code;
  888.       for (i = 0; i < length; ++i) {
  889.         code = key.charCodeAt(i);
  890.         if (code < 0x80) {
  891.           bytes[index++] = code;
  892.         } else if (code < 0x800) {
  893.           bytes[index++] = (0xc0 | (code >>> 6));
  894.           bytes[index++] = (0x80 | (code & 0x3f));
  895.         } else if (code < 0xd800 || code >= 0xe000) {
  896.           bytes[index++] = (0xe0 | (code >>> 12));
  897.           bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
  898.           bytes[index++] = (0x80 | (code & 0x3f));
  899.         } else {
  900.           code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));
  901.           bytes[index++] = (0xf0 | (code >>> 18));
  902.           bytes[index++] = (0x80 | ((code >>> 12) & 0x3f));
  903.           bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
  904.           bytes[index++] = (0x80 | (code & 0x3f));
  905.         }
  906.       }
  907.       key = bytes;
  908.     } else {
  909.       if (type === 'object') {
  910.         if (key === null) {
  911.           throw new Error(ERROR);
  912.         } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
  913.           key = new Uint8Array(key);
  914.         } else if (!Array.isArray(key)) {
  915.           if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
  916.             throw new Error(ERROR);
  917.           }
  918.         }
  919.       } else {
  920.         throw new Error(ERROR);
  921.       }
  922.     }
  924.     if (key.length > 64) {
  925.       key = (new Sha256(is224, true)).update(key).array();
  926.     }
  928.     var oKeyPad = [], iKeyPad = [];
  929.     for (i = 0; i < 64; ++i) {
  930.       var b = key[i] || 0;
  931.       oKeyPad[i] = 0x5c ^ b;
  932.       iKeyPad[i] = 0x36 ^ b;
  933.     }
  935.     Sha256.call(this, is224, sharedMemory);
  937.     this.update(iKeyPad);
  938.     this.oKeyPad = oKeyPad;
  939.     this.inner = true;
  940.     this.sharedMemory = sharedMemory;
  941.   }
  942.   HmacSha256.prototype = new Sha256();
  944.   HmacSha256.prototype.finalize = function () {
  945.     Sha256.prototype.finalize.call(this);
  946.     if (this.inner) {
  947.       this.inner = false;
  948.       var innerHash = this.array();
  949.       Sha256.call(this, this.is224, this.sharedMemory);
  950.       this.update(this.oKeyPad);
  951.       this.update(innerHash);
  952.       Sha256.prototype.finalize.call(this);
  953.     }
  954.   };
  956.   var exports = createMethod();
  957.   exports.sha256 = exports;
  958.   exports.sha224 = createMethod(true);
  959.   exports.sha256.hmac = createHmacMethod();
  960.   exports.sha224.hmac = createHmacMethod(true);
  962.   if (COMMON_JS) {
  963.     module.exports = exports;
  964.   } else {
  965.     root.sha256 = exports.sha256;
  966.     root.sha224 = exports.sha224;
  967.     if (AMD) {
  968.       define(function () {
  969.         return exports;
  970.       });
  971.     }
  972.   }
  973. })();
複製代碼


 

 

 

 

 

 

 

 

 

 

 


       请各位多点赞，谢谢！



最新高价定制分享，极品反差女大生04年清纯小姐姐【胡椒仔】露脸私拍，各种COSER裸体骚舞大号道具紫薇脸逼同框 [13P]

 

 

 

 

 

 

 

 

 

 

 

 

 


[ 此貼被Diss在2024-05-11 18:38重新編輯 ]

赞(32)
DMCA / ABUSE REPORT | TOP Posted: 05-11 13:12 樓主 引用 | 發表評論
杺訴


級別：俠客 ( 9 )
發帖：2038
威望：199 點
金錢：2884 USD
貢獻：0 點
註冊：2016-04-13
赞(0) | 資料 短信 推薦 編輯


感谢分享
TOP Posted: 05-11 13:15 #1樓 引用 | 點評
茎深


級別：光明使者 ( 14 )
發帖：14551
威望：8065 點
金錢：53724 USD
貢獻：123456 點
註冊：2023-11-21
赞(1) | 資料 短信 推薦 編輯

内容很深奥，不太明白，防水图不错
------------------------
K
TOP Posted: 05-11 13:32 #2樓 引用 | 點評
错拥相思


級別：精靈王 ( 12 )
發帖：2658
威望：1052 點
金錢：505029 USD
貢獻：10235 點
註冊：2013-07-03
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-11 13:36 #3樓 引用 | 點評
斜阳晚照


級別：俠客 ( 9 )
發帖：2692
威望：270 點
金錢：11269 USD
貢獻：0 點
註冊：2022-07-25
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-11 13:59 #4樓 引用 | 點評
长黑毛毛


級別：風雲使者 ( 13 )
發帖：25004
威望：8365 點
金錢：29327 USD
貢獻：0 點
註冊：2011-06-06
赞(1) | 資料 短信 推薦 編輯

看看防水图
TOP Posted: 05-11 14:22 #5樓 引用 | 點評
蓝色口罩


級別：俠客 ( 9 )
發帖：1343
威望：139 點
金錢：6676 USD
貢獻：0 點
註冊：2023-01-11
赞(1) | 資料 短信 推薦 編輯

太吊了，算你厉害
TOP Posted: 05-11 14:24 #6樓 引用 | 點評
伸茎百战6


級別：騎士 ( 10 )
發帖：1141
威望：345 點
金錢：950 USD
貢獻：3435 點
註冊：2022-10-02
赞(1) | 資料 短信 推薦 編輯

勇哥侃侃侃的教程。
TOP Posted: 05-11 14:27 #7樓 引用 | 點評
行走中的衣架


級別：聖騎士 ( 11 )
發帖：4190
威望：646 點
金錢：5637 USD
貢獻：79 點
註冊：2023-10-03
赞(1) | 資料 短信 推薦 編輯

技术大咖！防水图非常棒！
TOP Posted: 05-11 14:37 #8樓 引用 | 點評
siobhan


級別：俠客 ( 9 )
發帖：952
威望：111 點
金錢：23891 USD
貢獻：291 點
註冊：2020-02-11
赞(1) | 資料 短信 推薦 編輯

好人一生平安
TOP Posted: 05-11 14:39 #9樓 引用 | 點評
erican


級別：騎士 ( 10 )
發帖：1068
威望：107 點
金錢：2437 USD
貢獻：21339 點
註冊：2023-10-24
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-11 14:41 #10樓 引用 | 點評
曼殊沙华


級別：天使 ( 14 )
發帖：2358
威望：508 點
金錢：52377086 USD
貢獻：2518888 點
註冊：2014-08-06
赞(0) | 資料 短信 推薦 編輯


技术贴
------------------------
X
TOP Posted: 05-11 14:43 #11樓 引用 | 點評
qqq0623


級別：精靈王 ( 12 )
發帖：45172
威望：4400 點
金錢：1975711 USD
貢獻：1137 點
註冊：2011-06-06
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-11 16:13 #12樓 引用 | 點評
观水


級別：聖騎士 ( 11 )
發帖：357
威望：106 點
金錢：883 USD
貢獻：25000 點
註冊：2022-10-18
赞(0) | 資料 短信 推薦 編輯

不明觉厉
TOP Posted: 05-11 16:51 #13樓 引用 | 點評
大鸟东南飞


級別：俠客 ( 9 )
發帖：2791
威望：280 點
金錢：7984 USD
貢獻：0 點
註冊：2020-02-16
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-11 17:44 #14樓 引用 | 點評
草原科多兽


級別：精靈王 ( 12 )
發帖：11067
威望：1127 點
金錢：100142 USD
貢獻：4657 點
註冊：2023-07-31
赞(1) | 資料 短信 推薦 編輯

有时候也搞不懂在小草发这种贴到底是什么心态…
TOP Posted: 05-11 22:00 #15樓 引用 | 點評
盲流子


級別：光明使者 ( 14 )
發帖：32788
威望：31985 點
金錢：25832 USD
貢獻：456789 點
註冊：2023-01-21
赞(1) | 資料 短信 推薦 編輯

看不懂，放弃了
------------------------
D
TOP Posted: 05-11 22:16 #16樓 引用 | 點評
没有不可能


級別：精靈王 ( 12 )
發帖：15796
威望：1679 點
金錢：29593 USD
貢獻：0 點
註冊：2016-11-01
赞(1) | 資料 短信 推薦 編輯


看看防水图
TOP Posted: 05-11 22:19 #17樓 引用 | 點評
zhang礼


級別：騎士 ( 10 )
發帖：4066
威望：402 點
金錢：7442 USD
貢獻：0 點
註冊：2023-10-18
赞(0) | 資料 短信 推薦 編輯

好长的假阳具
TOP Posted: 05-12 15:31 #18樓 引用 | 點評
吾名木板屋


級別：俠客 ( 9 )
發帖：1394
威望：140 點
金錢：3731 USD
貢獻：5064 點
註冊：2012-11-11
赞(0) | 資料 短信 推薦 編輯

感谢分享
TOP Posted: 05-12 22:52 #19樓 引用 | 點評

.:. 草榴社區 -> 技術討論區

快速回帖 頂端
內容：
HTML 代碼不可用

使用簽名
Wind Code自動轉換

按 Ctrl+Enter 直接提交