diff --git a/.github/workflows/package-worker.yml b/.github/workflows/package-worker.yml deleted file mode 100644 index 3acdcfbf10..0000000000 --- a/.github/workflows/package-worker.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: Package Worker # 工作流程的名称 - -on: # 触发事件 - workflow_dispatch: # 手动触发 - push: # 当代码被推送到仓库时触发 - paths: # 指定触发条件的文件路径 - - '_worker.js' # 当_worker.js文件发生变动时触发 - -jobs: # 工作流程中的任务 - package-and-commit: # 任务名称 - runs-on: ubuntu-latest # 运行环境，这里使用最新版本的Ubuntu - steps: # 任务步骤 - - name: Checkout Repository # 步骤名称，检出代码 - uses: actions/checkout@v2 # 使用actions/checkout动作 - - - name: Zip the worker file # 将_worker.js文件打包成worker.zip - run: zip worker.zip _worker.js # 使用zip命令直接打包 - - - name: Commit and push the packaged file # 提交并推送打包后的文件 - uses: EndBug/add-and-commit@v7 # 使用EndBug/add-and-commit动作 - with: - add: 'worker.zip' # 指定要提交的文件 - message: 'Automatically package and commit worker.zip' # 提交信息 - author_name: github-actions[bot] # 提交者名称 - author_email: actions[bot]@users.noreply.github.com # 提交者邮箱 - token: ${{ secrets.GH_TOKEN }} # 使用GH_TOKEN作为身份验证 diff --git a/README.md b/README.md index ba24dd3341..e2ec1b7ff8 100644 --- a/README.md +++ b/README.md @@ -1,202 +1,185 @@ -# edgetunnel -这是一个基于 CF Worker 平台的脚本，在原版的基础上修改了显示 VLESS 配置信息转换为订阅内容。使用该脚本，你可以方便地将 VLESS 配置信息使用在线配置转换到 Clash 或 Singbox 等工具中。 +# 🚀 edgetunnel 2.0 +![后台页面](./img.png) -- 基础部署视频教程：https://www.youtube.com/watch?v=LeT4jQUh8ok -- 快速部署视频教程：https://www.youtube.com/watch?v=59THrmJhmAw ***最佳推荐!!!*** -- 进阶使用视频教程：https://www.youtube.com/watch?v=s91zjpw3-P8 +- **Edgetunnel 图文教程**：https://cmliussss.com/p/edt2 ***必看内容!必看内容!必看内容!!!*** +- **报错 Error 1101 详解**：https://www.youtube.com/watch?v=r4uVTEJptdE -Telegram交流群：[@CMLiussss](https://t.me/CMLiussss)，**感谢[Alice Networks](https://alice.ws/aff.php?aff=15)提供的云服务器维持[CM订阅转换服务](https://sub.fxxk.dedyn.io/)！** +- Telegram交流群：[@CMLiussss](https://t.me/CMLiussss) -# 免责声明 +## ⚠️ 免责声明 -本免责声明适用于 GitHub 上的 “edgetunnel” 项目（以下简称“该项目”），项目链接为：https://github.com/cmliu/edgetunnel +本免责声明适用于 GitHub 上的 “edgetunnel” 项目（以下简称“本项目”），项目链接为：https://github.com/cmliu/edgetunnel 。 ### 用途 -该项目被设计和开发仅供学习、研究和安全测试目的。它旨在为安全研究者、学术界人士和技术爱好者提供一个了解和实践网络通信技术的工具。 +本项目仅供教育、研究和安全测试目的而设计和开发。旨在为安全研究人员、学术界人士及技术爱好者提供一个探索和实践网络通信技术的工具。 ### 合法性 -使用者在下载和使用该项目时，必须遵守当地法律和规定。使用者有责任确保他们的行为符合其所在地区的法律、规章以及其他适用的规定。 +在下载和使用本项目代码时，必须遵守使用者所适用的法律和规定。使用者有责任确保其行为符合所在地区的法律框架、规章制度及其他相关规定。 ### 免责 -1. 作为该项目的作者，我（以下简称“作者”）强调该项目应仅用于合法、道德和教育目的。 -2. 作者不鼓励、不支持也不促进任何形式的非法使用该项目。如果发现该项目被用于非法或不道德的活动，作者将强烈谴责这种行为。 -3. 作者对任何人或团体使用该项目进行的任何非法活动不承担责任。使用者使用该项目时产生的任何后果由使用者本人承担。 -4. 作者不对使用该项目可能引起的任何直接或间接损害负责。 -5. 通过使用该项目，使用者表示理解并同意本免责声明的所有条款。如果使用者不同意这些条款，应立即停止使用该项目。 +1. 作为本项目的 **二次开发作者**（以下简称“作者”），我 **cmliu** 强调本项目仅应用于合法、道德和教育目的。 +2. 作者不认可、不支持亦不鼓励任何形式的非法使用。如果发现本项目被用于任何非法或不道德的活动，作者将对此强烈谴责。 +3. 作者对任何人或组织利用本项目代码从事的任何非法活动不承担责任。使用本项目代码所产生的任何后果，均由使用者自行承担。 +4. 作者不对使用本项目代码可能引起的任何直接或间接损害负责。 +5. 为避免任何意外后果或法律风险，使用者应在使用本项目代码后的 24 小时内删除代码。 -作者保留随时更新本免责声明的权利，且不另行通知。最新的免责声明版本将会在该项目的 GitHub 页面上发布。 +通过使用本项目代码，使用者即表示理解并同意本免责声明的所有条款。如使用者不同意这些条款，应立即停止使用本项目。 -## 风险提示 +作者保留随时更新本免责声明的权利，且不另行通知。最新版本的免责声明将发布在本项目的 GitHub 页面上。 + +## 🔥 风险提示 - 通过提交虚假的节点配置给订阅服务，避免节点配置信息泄露。 - 另外，您也可以选择自行部署 [WorkerVless2sub 订阅生成服务](https://github.com/cmliu/WorkerVless2sub)，这样既可以利用订阅生成器的便利。 -## Workers 部署方法 [视频教程](https://www.youtube.com/watch?v=LeT4jQUh8ok&t=83s) +## 💡 如何使用? +### ⚙️ Workers 部署方法 + +
+「 Workers 部署文字教程 」 + 1. 部署 CF Worker： - 在 CF Worker 控制台中创建一个新的 Worker。 - 将 [worker.js](https://github.com/cmliu/edgetunnel/blob/main/_worker.js) 的内容粘贴到 Worker 编辑器中。 - - 将第 7 行 `userID` 修改成你自己的 **UUID** 。 + - 在左侧的 `设置`选项卡中，选择 `变量` > `添加变量`。 + 变量名称填写**ADMIN**，值则为你的管理员密码，后点击 `保存`即可。 -2. 访问订阅内容： - - 访问 `https://[YOUR-WORKERS-URL]/[UUID]` 即可获取订阅内容。 - - 例如 `https://vless.google.workers.dev/90cd4a77-141a-43c9-991b-08263cfe9c10` 就是你的通用自适应订阅地址。 - - 例如 `https://vless.google.workers.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sub` Base64订阅格式，适用PassWall,SSR+等。 - - 例如 `https://vless.google.workers.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?clash` Clash订阅格式，适用OpenClash等。 - - 例如 `https://vless.google.workers.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sb` singbox订阅格式，适用singbox等。 +2. 绑定 KV 命名空间： + - 在 `绑定`选项卡中选择 `添加绑定 +` > `KV 命名空间` > `添加绑定`，然后选择一个已有的命名空间或创建一个新的命名空间进行绑定。 + - `变量名称`填写**KV**，然后点击 `添加绑定`即可。 -3. 给 workers绑定 自定义域： +3. 给 Workers绑定 自定义域： - 在 workers控制台的 `触发器`选项卡，下方点击 `添加自定义域`。 - 填入你已转入 CF 域名解析服务的次级域名，例如:`vless.google.com`后 点击`添加自定义域`，等待证书生效即可。 - - **如果你是小白，你现在可以直接起飞，不用再往下看了！！！** -
-「 我不是小白！我真的真的不是小白！我要玩花活！我要开启高端玩法！ 」 - -4. 使用自己的`优选域名`/`优选IP`的订阅内容： - - 如果你想使用自己的优选域名或者是自己的优选IP，可以参考 [WorkerVless2sub GitHub 仓库](https://github.com/cmliu/WorkerVless2sub) 中的部署说明自行搭建。 - - 打开 [worker.js](https://github.com/cmliu/edgetunnel/blob/main/_worker.js) 文件，在第 12 行找到 `sub` 变量，将其修改为你部署的订阅生成器地址。例如 `let sub = 'sub.cmliussss.workers.dev';`，注意不要带https等协议信息和符号。 - - 注意，如果您使用了自己的订阅地址，要求订阅生成器的 `sub`域名 和 `[YOUR-WORKER-URL]`的域名 不同属一个顶级域名，否则会出现异常。您可以在 `sub` 变量赋值为 workers.dev 分配到的域名。 +4. 访问后台： + - 访问 `https://vless.google.com/admin` 输入管理员密码即可登录后台。
-## Pages 上传 部署方法 **最佳推荐!!!** [视频教程](https://www.youtube.com/watch?v=59THrmJhmAw) +### 🛠 Pages 上传 部署方法 **最佳推荐!!!** [图文教程](https://cmliussss.com/p/edt2/) + +
+「 Pages 上传文件部署文字教程 」 + 1. 部署 CF Pages： - - 下载 [worker.zip](https://raw.githubusercontent.com/cmliu/edgetunnel/main/worker.zip) 文件，并点上 Star !!! - - 在 CF Pages 控制台中选择 `上传资产`后，为你的项目取名后点击 `创建项目`，然后上传你下载好的 [worker.zip](https://raw.githubusercontent.com/cmliu/edgetunnel/main/worker.zip) 文件后点击 `部署站点`。 + - 下载 [main.zip](https://github.com/cmliu/edgetunnel/archive/refs/heads/main.zip) 文件，并点上 Star !!! + - 在 CF Pages 控制台中选择 `上传资产`后，为你的项目取名后点击 `创建项目`，然后上传你下载好的 [main.zip](https://github.com/cmliu/edgetunnel/archive/refs/heads/main.zip) 文件后点击 `部署站点`。 - 部署完成后点击 `继续处理站点` 后，选择 `设置` > `环境变量` > **制作**为生产环境定义变量 > `添加变量`。 - 变量名称填写**UUID**，值则为你的UUID，后点击 `保存`即可。 - - 返回 `部署` 选项卡，在右下角点击 `创建新部署` 后，重新上传 [worker.zip](https://raw.githubusercontent.com/cmliu/edgetunnel/main/worker.zip) 文件后点击 `保存并部署` 即可。 + 变量名称填写**ADMIN**，值则为你的管理员密码，后点击 `保存`即可。 + - 返回 `部署` 选项卡，在右下角点击 `创建新部署` 后，重新上传 [main.zip](https://github.com/cmliu/edgetunnel/archive/refs/heads/main.zip) 文件后点击 `保存并部署` 即可。 -2. 访问订阅内容： - - 访问 `https://[YOUR-PAGES-URL]/[YOUR-UUID]` 即可获取订阅内容。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10` 就是你的通用自适应订阅地址。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sub` Base64订阅格式，适用PassWall,SSR+等。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?clash` Clash订阅格式，适用OpenClash等。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sb` singbox订阅格式，适用singbox等。 +2. 绑定 KV 命名空间： + - 在 `设置`选项卡中选择 `绑定` > `+ 添加` > `KV 命名空间`，然后选择一个已有的命名空间或创建一个新的命名空间进行绑定。 + - `变量名称`填写**KV**，然后点击 `保存`后重试部署即可。 -
-「 我自己有域名！我要绑定自己的域名！我已经熟练的掌握域名解析！ 」 - 3. 给 Pages绑定 CNAME自定义域：[视频教程](https://www.youtube.com/watch?v=LeT4jQUh8ok&t=851s) - 在 Pages控制台的 `自定义域`选项卡，下方点击 `设置自定义域`。 - 填入你的自定义次级域名，注意不要使用你的根域名，例如： 您分配到的域名是 `fuck.cloudns.biz`，则添加自定义域填入 `lizi.fuck.cloudns.biz`即可； - 按照 CF 的要求将返回你的域名DNS服务商，添加 该自定义域 `lizi`的 CNAME记录 `edgetunnel.pages.dev` 后，点击 `激活域`即可。 - - **如果你是小白，那么你的 pages 绑定`自定义域`之后即可直接起飞，不用再往下看了！！！** - - -
-
-「 我不是小白！我真的真的不是小白！我要玩花活！我要开启高端玩法！ 」 -4. 使用自己的`优选域名`/`优选IP`的订阅内容： - - 如果你想使用自己的优选域名或者是自己的优选IP，可以参考 [WorkerVless2sub GitHub 仓库](https://github.com/cmliu/WorkerVless2sub) 中的部署说明自行搭建。 - - 在 Pages控制台的 `设置`选项卡，选择 `环境变量`> `制作`> `编辑变量`> `添加变量`； - - 变量名设置为`SUB`，对应的值为你部署的订阅生成器地址。例如 `sub.cmliussss.workers.dev`，后点击 **保存**。 - - 之后在 Pages控制台的 `部署`选项卡，选择 `所有部署`> `最新部署最右的 ...`> `重试部署`，即可。 - - 注意，如果您使用了自己的订阅地址，要求订阅生成器的 `SUB`域名 和 `[YOUR-PAGES-URL]`的域名 不同属一个顶级域名，否则会出现异常。您可以在 `SUB` 变量赋值为 Pages.dev 分配到的域名。 +4. 访问后台： + - 访问 `https://lizi.fuck.cloudns.biz/admin` 输入管理员密码即可登录后台。
-## Pages GitHub 部署方法 [视频教程](https://www.youtube.com/watch?v=LeT4jQUh8ok&t=560s) +### 🛠 Pages GitHub 部署方法 + +
+「 Pages GitHub 部署文字教程 」 + 1. 部署 CF Pages： - 在 Github 上先 Fork 本项目，并点上 Star !!! - 在 CF Pages 控制台中选择 `连接到 Git`后，选中 `edgetunnel`项目后点击 `开始设置`。 - 在 `设置构建和部署`页面下方，选择 `环境变量（高级）`后并 `添加变量` - 变量名称填写**UUID**，值则为你的UUID，后点击 `保存并部署`即可。 + 变量名称填写**ADMIN**，值则为你的管理员密码，后点击 `保存并部署`即可。 -2. 访问订阅内容： - - 访问 `https://[YOUR-PAGES-URL]/[YOUR-UUID]` 即可获取订阅内容。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10` 就是你的通用自适应订阅地址。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sub` Base64订阅格式，适用PassWall,SSR+等。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?clash` Clash订阅格式，适用OpenClash等。 - - 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sb` singbox订阅格式，适用singbox等。 +2. 绑定 KV 命名空间： + - 在 `设置`选项卡中选择 `绑定` > `+ 添加` > `KV 命名空间`，然后选择一个已有的命名空间或创建一个新的命名空间进行绑定。 + - `变量名称`填写**KV**，然后点击 `保存`后重试部署即可。 3. 给 Pages绑定 CNAME自定义域：[视频教程](https://www.youtube.com/watch?v=LeT4jQUh8ok&t=851s) - 在 Pages控制台的 `自定义域`选项卡，下方点击 `设置自定义域`。 - 填入你的自定义次级域名，注意不要使用你的根域名，例如： 您分配到的域名是 `fuck.cloudns.biz`，则添加自定义域填入 `lizi.fuck.cloudns.biz`即可； - 按照 CF 的要求将返回你的域名DNS服务商，添加 该自定义域 `lizi`的 CNAME记录 `edgetunnel.pages.dev` 后，点击 `激活域`即可。 - - **如果你是小白，那么你的 pages 绑定`自定义域`之后即可直接起飞，不用再往下看了！！！** - -
-「 我不是小白！我真的真的不是小白！我要玩花活！我要开启高端玩法！ 」 -4. 使用自己的`优选域名`/`优选IP`的订阅内容： - - 如果你想使用自己的优选域名或者是自己的优选IP，可以参考 [WorkerVless2sub GitHub 仓库](https://github.com/cmliu/WorkerVless2sub) 中的部署说明自行搭建。 - - 在 Pages控制台的 `设置`选项卡，选择 `环境变量`> `制作`> `编辑变量`> `添加变量`； - - 变量名设置为`SUB`，对应的值为你部署的订阅生成器地址。例如 `sub.cmliussss.workers.dev`，后点击 **保存**。 - - 之后在 Pages控制台的 `部署`选项卡，选择 `所有部署`> `最新部署最右的 ...`> `重试部署`，即可。 - - 注意，如果您使用了自己的订阅地址，要求订阅生成器的 `SUB`域名 和 `[YOUR-PAGES-URL]`的域名 不同属一个顶级域名，否则会出现异常。您可以在 `SUB` 变量赋值为 Pages.dev 分配到的域名。 +4. 访问后台： + - 访问 `https://lizi.fuck.cloudns.biz/admin` 输入管理员密码即可登录后台。
-## 变量说明 -| 变量名 | 示例 | 必填 | 备注 | YT | -|--------|---------|-|-----|-----| -| UUID | `90cd4a77-141a-43c9-991b-08263cfe9c10` |✅| Powershell -NoExit -Command "[guid]::NewGuid()"| [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=72s) | -| PROXYIP | `proxyip.fxxk.dedyn.io` |❌| 备选作为访问CFCDN站点的代理节点(支持多ProxyIP, ProxyIP之间使用`,`或 换行 作间隔) | [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=166s) | -| SOCKS5 | `user:password@127.0.0.1:1080` |❌| 优先作为访问CFCDN站点的SOCKS5代理 | [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=826s) | -| ADD | `icook.tw:2053#官方优选域名` |❌| 本地优选TLS域名/优选IP(支持多元素之间`,`或 换行 作间隔) || -| ADDAPI | [https://raw.github.../addressesapi.txt](https://raw.githubusercontent.com/cmliu/WorkerVless2sub/main/addressesapi.txt) |❌| 优选IP的API地址(支持多元素之间`,`或 换行 作间隔) || -| ADDNOTLS | `icook.hk:8080#官方优选域名` |❌| 本地优选noTLS域名/优选IP(支持多元素之间`,`或 换行 作间隔) || -| ADDNOTLSAPI | [https://raw.github.../addressesapi.txt](https://raw.githubusercontent.com/cmliu/CFcdnVmess2sub/main/addressesapi.txt) |❌| 优选IP的API地址(支持多元素之间`,`或 换行 作间隔) || -| ADDCSV | [https://raw.github.../addressescsv.csv](https://raw.githubusercontent.com/cmliu/WorkerVless2sub/main/addressescsv.csv) |❌| iptest测速结果(支持多元素, 元素之间使用`,`作间隔) || -| DLS | `8` |❌| `ADDCSV`测速结果满足速度下限 || -| TGTOKEN | `6894123456:XXXXXXXXXX0qExVsBPUhHDAbXXX` |❌| 发送TG通知的机器人token | -| TGID | `6946912345` |❌| 接收TG通知的账户数字ID | -| SUB | `VLESS.fxxk.dedyn.io` | ❌ | 内建域名、IP节点信息的订阅生成器地址 | [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=1193s) | -| SUBAPI | `SUBAPI.fxxk.dedyn.io` |❌| clash、singbox等 订阅转换后端 | [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=1446s) | -| SUBCONFIG | [https://raw.github.../ACL4SSR_Online_Full_MultiMode.ini](https://raw.githubusercontent.com/cmliu/ACL4SSR/main/Clash/config/ACL4SSR_Online_Full_MultiMode.ini) |❌| clash、singbox等 订阅转换配置文件 | [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=1605s) | -| RPROXYIP | `false` |❌| 设为 true 即可强制获取订阅器分配的ProxyIP(需订阅器支持)| [Video](https://www.youtube.com/watch?v=s91zjpw3-P8&t=1816s) | -| URL302 | `https://t.me/CMLiussss` |❌| 主页302跳转(支持多url, url之间使用`,`或 换行 作间隔, 小白别用) | | -| URL | `https://t.me/CMLiussss` |❌| 主页伪装(支持多url, url之间使用`,`或 换行 作间隔, 乱设容易触发反诈) | | -| CFEMAIL | `admin@gmail.com` |❌| CF账户邮箱(与`CFKEY`都填上后, 订阅信息将显示请求使用量, 小白别用) | | -| CFKEY | `c6a944b5c956b6c18c2352880952bced8b85e` |❌| CF账户Global API Key(与`CFEMAIL`都填上后, 订阅信息将显示请求使用量, 小白别用) | | - -**注意: 填入`SOCKS5`后将不再启用`PROXYIP`！请二选一使用！！！** - -**注意: 填入`SUB`后将不再启用`ADD*`类变量生成的订阅内容！请二选一使用！！！** - -**注意: 同时填入`CFEMAIL`和`CFKEY`才会启用显示请求使用量，但是不推荐使用！没必要给一个Worker项目这么高的权限！后果自负！！！** - -## 实用小技巧 - -**该项目部署的订阅可通过添加`sub`键值快速更换优选订阅生成器！** -> 例如 `https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10` 是你的通用自适应订阅地址 - -- 快速更换订阅器为`VLESS.fxxk.dedyn.io`的订阅地址 - - ```url - https://edgetunnel.pages.dev/90cd4a77-141a-43c9-991b-08263cfe9c10?sub=VLESS.fxxk.dedyn.io - ``` - -**该项目部署的节点可通过节点PATH(路径)的方式，使用指定的`PROXYIP`或`SOCKS5`！！！** +## 🔑 变量说明 + +| 变量名 | 示例 | 必填 | 备注 | +|--------|---------|-|-----| +| ADMIN | `123456` |✅| 面板登录密码 | +| KEY | `CMLiussss` |❌| 快速订阅密钥，访问`/CMLiussss`即可快读订阅。 | +| HOST | `edt-pages.github.io` |❌| 强制固定伪装域名(支持多元素，使用`换行符`或`,`做间隔) | +| UUID | `90cd4a77-141a-43c9-991b-08263cfe9c10` |❌| 强制固定UUID | +| PATH | `/` |❌| 强制固定路径 | +| PROXYIP | `proxyip.cmliussss.net:443` |❌| 更换默认内置PROXYIP | +| URL | `https://cloudflare-error-page-3th.pages.dev` |❌| 主页反代伪装(乱设容易触发反诈，反代被墙的网站会加速域名被墙) | +| GO2SOCKS5 | `blog.cmliussss.com`,`*.ip111.cn`,`*google.com` |❌| 设置`SOCKS5`或`HTTP`变量之后，可设置强制使用socks5访问名单(设置为`*`可作为全局代理) | + +## 🔧 实用技巧 +该项目部署的节点可通过节点PATH(路径)的方式，使用指定的`PROXYIP`或`SOCKS5`！！！ - 指定 `PROXYIP` 案例 ```url - /proxyip=proxyip.fxxk.dedyn.io - /?proxyip=proxyip.fxxk.dedyn.io - /proxyip.fxxk.dedyn.io (仅限于域名开头为'proxyip.'的域名) + /proxyip=proxyip.cmliussss.net + /?proxyip=proxyip.cmliussss.net + /proxyip.cmliussss.net (仅限于域名开头为'proxyip.'的域名) ``` - 指定 `SOCKS5` 案例 ```url /socks5=user:password@127.0.0.1:1080 /?socks5=user:password@127.0.0.1:1080 - /socks://dXNlcjpwYXNzd29yZA==@127.0.0.1:1080 - /socks5://user:password@127.0.0.1:1080 + /socks://dXNlcjpwYXNzd29yZA==@127.0.0.1:1080 (默认激活全局SOCKS5) + /socks5://user:password@127.0.0.1:1080 (默认激活全局SOCKS5) ``` +- 指定 `HTTP代理` 案例 + ```url + /http=user:password@127.0.0.1:1080 + /http://user:password@127.0.0.1:8080 (默认激活全局SOCKS5) + ``` -## Star 星星走起 +## ⭐ Star 星星走起 [![Stargazers over time](https://starchart.cc/cmliu/edgetunnel.svg?variant=adaptive)](https://starchart.cc/cmliu/edgetunnel) -## 已适配自适应订阅内容 +## 💻 已适配客户端 +### Windows - [v2rayN](https://github.com/2dust/v2rayN) - - clash.meta（[clash-verge-rev -](https://github.com/clash-verge-rev/clash-verge-rev)，[Clash Nyanpasu](https://github.com/keiko233/clash-nyanpasu)，~[clash-verge](https://github.com/zzzgydi/clash-verge/tree/main)~，ClashX Meta） - - sing-box（SFI） - - - -# 感谢 -[zizifn](https://github.com/zizifn/edgetunnel)、[3Kmfi6HP](https://github.com/3Kmfi6HP/EDtunnel)、[Stanley-baby](https://github.com/Stanley-baby)、[ACL4SSR](https://github.com/ACL4SSR/ACL4SSR/tree/master/Clash/config)、[SHIJS1999](https://github.com/SHIJS1999/cloudflare-worker-vless-ip)、Alice Networks LTD、 + - clash.meta（[FlClash](https://github.com/chen08209/FlClash)，[mihomo-party](https://github.com/mihomo-party-org/mihomo-party)，[clash-verge-rev](https://github.com/clash-verge-rev/clash-verge-rev)，[Clash Nyanpasu](https://github.com/keiko233/clash-nyanpasu)） +### IOS + - Surge，小火箭 + - sing-box（[SFI](https://sing-box.sagernet.org/zh/clients/apple/)） +### 安卓 + - clash.meta（[ClashMetaForAndroid](https://github.com/MetaCubeX/ClashMetaForAndroid)，[FlClash](https://github.com/chen08209/FlClash)） + - sing-box（[SFA](https://github.com/SagerNet/sing-box)） +### MacOS + - clash.meta（[FlClash](https://github.com/chen08209/FlClash)，[mihomo-party](https://github.com/mihomo-party-org/mihomo-party)） + + +# 🙏 特别鸣谢 +### 💖 赞助支持 - 提供云服务器维持[订阅转换服务](https://sub.cmliussss.net/) +- [NodeLoc](https://www.nodeloc.com/) +- [Alice](https://url.cmliussss.com/alice) +- [EasyLinks](https://www.vmrack.net?ref_code=5Zk7eNhbgL7) +- [ZMTO(VTEXS)](https://zmto.com/?affid=1532) + +### 🛠 开源代码引用 +- [zizifn/edgetunnel](https://github.com/zizifn/edgetunnel) +- [3Kmfi6HP/EDtunnel](https://github.com/6Kmfi6HP/EDtunnel) +- [SHIJS1999/cloudflare-worker-vless-ip](https://github.com/SHIJS1999/cloudflare-worker-vless-ip) +- [Stanley-baby](https://github.com/Stanley-baby) +- [ACL4SSR](https://github.com/ACL4SSR/ACL4SSR/tree/master/Clash/config) +- [股神](https://t.me/CF_NAT/38889) +- [Workers/Pages Metrics](https://t.me/zhetengsha/3382) +- [白嫖哥](https://t.me/bestcfipas) +- [Mingyu](https://github.com/ymyuuu/workers-vless) +- [Alexandre Kojève](https://t.me/Enkelte_notif/784)：stallTCP v1.3 +- [eooce](https://github.com/eooce/Cloudflare-proxy) +- [Sukka](https://ip.skk.moe/) \ No newline at end of file diff --git a/_worker.js b/_worker.js index dd69285af2..898183a6be 100644 --- a/_worker.js +++ b/_worker.js @@ -1,1726 +1,1798 @@ -// 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 = '90cd4a77-141a-43c9-991b-08263cfe9c10'; - -let proxyIP = '';// 小白勿动，该地址并不影响你的网速，这是给CF代理使用的。'cdn.xn--b6gac.eu.org, cdn-all.xn--b6gac.eu.org, workers.cloudflare.cyou' - -let sub = '';// 留空则使用内置订阅 -let subconverter = 'SUBAPI.fxxk.dedyn.io';// clash订阅转换后端，目前使用CM的订阅转换功能。自带虚假uuid和host订阅。 -let subconfig = "https://raw.githubusercontent.com/ACL4SSR/ACL4SSR/master/Clash/config/ACL4SSR_Online.ini"; //订阅配置文件 -let subProtocol = 'https'; -// The user name and password do not contain special characters -// Setting the address will ignore proxyIP -// Example: user:pass@host:port or host:port -let socks5Address = ''; - -if (!isValidUUID(userID)) { - throw new Error('uuid is not valid'); -} - -let parsedSocks5Address = {}; -let enableSocks = false; - -// 虚假uuid和hostname，用于发送给配置生成服务 -let fakeUserID ; -let fakeHostName ; -let noTLS = 'false'; -const expire = 4102329600;//2099-12-31 -let proxyIPs; -let addresses = []; -let addressesapi = []; -let addressesnotls = []; -let addressesnotlsapi = []; -let addressescsv = []; -let DLS = 8; -let FileName = 'edgetunnel'; -let BotToken =''; -let ChatID =''; -let proxyhosts = [];//本地代理域名池 -let proxyhostsURL = 'https://raw.githubusercontent.com/cmliu/CFcdnVmess2sub/main/proxyhosts';//在线代理域名池URL -let RproxyIP = 'false'; -export default { - /** - * @param {import("@cloudflare/workers-types").Request} request - * @param {{UUID: string, PROXYIP: string}} env - * @param {import("@cloudflare/workers-types").ExecutionContext} ctx - * @returns {Promise} - */ - async fetch(request, env, ctx) { - try { - const UA = request.headers.get('User-Agent') || 'null'; - const userAgent = UA.toLowerCase(); - userID = (env.UUID || userID).toLowerCase(); - - const currentDate = new Date(); - currentDate.setHours(0, 0, 0, 0); - const timestamp = Math.ceil(currentDate.getTime() / 1000); - const fakeUserIDMD5 = await MD5MD5(`${userID}${timestamp}`); - fakeUserID = fakeUserIDMD5.slice(0, 8) + "-" + fakeUserIDMD5.slice(8, 12) + "-" + fakeUserIDMD5.slice(12, 16) + "-" + fakeUserIDMD5.slice(16, 20) + "-" + fakeUserIDMD5.slice(20); - fakeHostName = fakeUserIDMD5.slice(6, 9) + "." + fakeUserIDMD5.slice(13, 19); - console.log(`虚假UUID: ${fakeUserID}`); // 打印fakeID - - proxyIP = env.PROXYIP || proxyIP; - proxyIPs = await ADD(proxyIP); - proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)]; - //console.log(proxyIP); - socks5Address = env.SOCKS5 || socks5Address; - sub = env.SUB || sub; - subconverter = env.SUBAPI || subconverter; - if( subconverter.includes("http://") ){ - subconverter = subconverter.split("//")[1]; - subProtocol = 'http'; - } else { - subconverter = subconverter.split("//")[1] || subconverter; - } - subconfig = env.SUBCONFIG || subconfig; - if (socks5Address) { - try { - parsedSocks5Address = socks5AddressParser(socks5Address); - RproxyIP = env.RPROXYIP || 'false'; - enableSocks = true; - } catch (err) { - /** @type {Error} */ - let e = err; - console.log(e.toString()); - RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false'; - enableSocks = false; - } - } else { - RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false'; - } - if (env.ADD) addresses = await ADD(env.ADD); - if (env.ADDAPI) addressesapi = await ADD(env.ADDAPI); - if (env.ADDNOTLS) addressesnotls = await ADD(env.ADDNOTLS); - if (env.ADDNOTLSAPI) addressesnotlsapi = await ADD(env.ADDNOTLSAPI); - if (env.ADDCSV) addressescsv = await ADD(env.ADDCSV); - DLS = env.DLS || DLS; - BotToken = env.TGTOKEN || BotToken; - ChatID = env.TGID || ChatID; - const upgradeHeader = request.headers.get('Upgrade'); - const url = new URL(request.url); - if (url.searchParams.has('sub') && url.searchParams.get('sub') !== '') sub = url.searchParams.get('sub'); - if (url.searchParams.has('notls')) noTLS = 'true'; - if (!upgradeHeader || upgradeHeader !== 'websocket') { - // const url = new URL(request.url); - switch (url.pathname.toLowerCase()) { - case '/': - const envKey = env.URL302 ? 'URL302' : (env.URL ? 'URL' : null); - if (envKey) { - const URLs = await ADD(env[envKey]); - const URL = URLs[Math.floor(Math.random() * URLs.length)]; - return envKey === 'URL302' ? Response.redirect(URL, 302) : fetch(new Request(URL, request)); - } - return new Response(JSON.stringify(request.cf, null, 4), { status: 200 }); - case `/${fakeUserID}`: - const fakeConfig = await getVLESSConfig(userID, request.headers.get('Host'), sub, 'CF-Workers-SUB', RproxyIP, url); - return new Response(`${fakeConfig}`, { status: 200 }); - case `/${userID}`: { - await sendMessage(`#获取订阅 ${FileName}`, request.headers.get('CF-Connecting-IP'), `UA: ${UA}\n域名: ${url.hostname}\n入口: ${url.pathname + url.search}`); - if ((!sub || sub == '') && (addresses.length + addressesapi.length + addressesnotls.length + addressesnotlsapi.length + addressescsv.length) == 0){ - if (request.headers.get('Host').includes(".workers.dev")) { - sub = 'noTLS.fxxk.dedyn.io'; - subconfig = env.SUBCONFIG || 'https://raw.githubusercontent.com/cmliu/ACL4SSR/main/Clash/config/ACL4SSR_Online.ini'; - } else { - sub = 'VLESS.fxxk.dedyn.io'; - subconfig = env.SUBCONFIG || "https://raw.githubusercontent.com/cmliu/ACL4SSR/main/Clash/config/ACL4SSR_Online_Full_MultiMode.ini"; - } - } - const vlessConfig = await getVLESSConfig(userID, request.headers.get('Host'), sub, UA, RproxyIP, url); - const now = Date.now(); - //const timestamp = Math.floor(now / 1000); - const today = new Date(now); - today.setHours(0, 0, 0, 0); - const UD = Math.floor(((now - today.getTime())/86400000) * 24 * 1099511627776 / 2); - let pagesSum = UD; - let workersSum = UD; - let total = 24 * 1099511627776 ; - if (env.CFEMAIL && env.CFKEY){ - const email = env.CFEMAIL; - const key = env.CFKEY; - const accountIndex = env.CFID || 0; - const accountId = await getAccountId(email, key); - if (accountId){ - const now = new Date() - now.setUTCHours(0, 0, 0, 0) - const startDate = now.toISOString() - const endDate = new Date().toISOString(); - const Sum = await getSum(accountId, accountIndex, email, key, startDate, endDate); - pagesSum = Sum[0]; - workersSum = Sum[1]; - total = 102400 ; - } - } - //console.log(`pagesSum: ${pagesSum}\nworkersSum: ${workersSum}\ntotal: ${total}`); - if (userAgent && userAgent.includes('mozilla')){ - return new Response(`${vlessConfig}`, { - status: 200, - headers: { - "Content-Type": "text/plain;charset=utf-8", - "Profile-Update-Interval": "6", - "Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`, - } - }); - } else { - return new Response(`${vlessConfig}`, { - status: 200, - headers: { - "Content-Disposition": `attachment; filename=${FileName}; filename*=utf-8''${encodeURIComponent(FileName)}`, - "Content-Type": "text/plain;charset=utf-8", - "Profile-Update-Interval": "6", - "Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`, - } - }); - } - } - default: - return new Response('Not found', { status: 404 }); - } - } else { - proxyIP = url.searchParams.get('proxyip') || proxyIP; - if (new RegExp('/proxyip=', 'i').test(url.pathname)) proxyIP = url.pathname.toLowerCase().split('/proxyip=')[1]; - else if (new RegExp('/proxyip.', 'i').test(url.pathname)) proxyIP = `proxyip.${url.pathname.toLowerCase().split("/proxyip.")[1]}`; - - socks5Address = url.searchParams.get('socks5') || socks5Address; - if (new RegExp('/socks5=', 'i').test(url.pathname)) socks5Address = url.pathname.split('5=')[1]; - else if (new RegExp('/socks://', 'i').test(url.pathname) || new RegExp('/socks5://', 'i').test(url.pathname)) { - socks5Address = url.pathname.split('://')[1].split('#')[0]; - if (socks5Address.includes('@')){ - let userPassword = socks5Address.split('@')[0]; - const base64Regex = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i; - if (base64Regex.test(userPassword) && !userPassword.includes(':')) userPassword = atob(userPassword); - socks5Address = `${userPassword}@${socks5Address.split('@')[1]}`; - } - } - if (socks5Address) { - try { - parsedSocks5Address = socks5AddressParser(socks5Address); - enableSocks = true; - } catch (err) { - /** @type {Error} */ - let e = err; - console.log(e.toString()); - enableSocks = false; - } - } else { - enableSocks = false; - } - return await vlessOverWSHandler(request); - } - } catch (err) { - /** @type {Error} */ let e = err; - return new Response(e.toString()); - } - }, -}; - -/** - * 处理 VLESS over WebSocket 的请求 - * @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 连接 - webSocket.accept(); - - let address = ''; - let portWithRandomLog = ''; - // 日志函数，用于记录连接信息 - const log = (/** @type {string} */ info, /** @type {string | undefined} */ event) => { - console.log(`[${address}:${portWithRandomLog}] ${info}`, event || ''); - }; - // 获取早期数据头部，可能包含了一些初始化数据 - const earlyDataHeader = request.headers.get('sec-websocket-protocol') || ''; - - // 创建一个可读的 WebSocket 流，用于接收客户端数据 - const readableWebSocketStream = makeReadableWebSocketStream(webSocket, earlyDataHeader, log); - - /** @type {{ value: import("@cloudflare/workers-types").Socket | null}}*/ - // 用于存储远程 Socket 的包装器 - let remoteSocketWapper = { - value: null, - }; - // 标记是否为 DNS 查询 - let isDns = false; - - // WebSocket 数据流向远程服务器的管道 - readableWebSocketStream.pipeTo(new WritableStream({ - async write(chunk, controller) { - if (isDns) { - // 如果是 DNS 查询，调用 DNS 处理函数 - return await handleDNSQuery(chunk, webSocket, null, log); - } - if (remoteSocketWapper.value) { - // 如果已有远程 Socket，直接写入数据 - const writer = remoteSocketWapper.value.writable.getWriter() - await writer.write(chunk); - writer.releaseLock(); - return; - } - - // 处理 VLESS 协议头部 - 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) { - // 如果有错误，抛出异常 - throw new Error(message); - return; - } - // 如果是 UDP 且端口不是 DNS 端口（53），则关闭连接 - if (isUDP) { - if (portRemote === 53) { - isDns = true; - } else { - throw new Error('UDP 代理仅对 DNS（53 端口）启用'); - return; - } - } - // 构建 VLESS 响应头部 - const vlessResponseHeader = new Uint8Array([vlessVersion[0], 0]); - // 获取实际的客户端数据 - const rawClientData = chunk.slice(rawDataIndex); - - if (isDns) { - // 如果是 DNS 查询，调用 DNS 处理函数 - return handleDNSQuery(rawClientData, webSocket, vlessResponseHeader, log); - } - // 处理 TCP 出站连接 - log(`处理 TCP 出站连接 ${addressRemote}:${portRemote}`); - handleTCPOutBound(remoteSocketWapper, addressType, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log); - }, - close() { - log(`readableWebSocketStream 已关闭`); - }, - abort(reason) { - log(`readableWebSocketStream 已中止`, JSON.stringify(reason)); - }, - })).catch((err) => { - log('readableWebSocketStream 管道错误', err); - }); - - // 返回一个 WebSocket 升级的响应 - return new Response(null, { - status: 101, - // @ts-ignore - webSocket: client, - }); -} - -/** - * 处理出站 TCP 连接。 - * - * @param {any} remoteSocket 远程 Socket 的包装器，用于存储实际的 Socket 对象 - * @param {number} addressType 要连接的远程地址类型（如 IP 类型：IPv4 或 IPv6） - * @param {string} addressRemote 要连接的远程地址 - * @param {number} portRemote 要连接的远程端口 - * @param {Uint8Array} rawClientData 要写入的原始客户端数据 - * @param {import("@cloudflare/workers-types").WebSocket} webSocket 用于传递远程 Socket 的 WebSocket - * @param {Uint8Array} vlessResponseHeader VLESS 响应头部 - * @param {function} log 日志记录函数 - * @returns {Promise} 异步操作的 Promise - */ -async function handleTCPOutBound(remoteSocket, addressType, addressRemote, portRemote, rawClientData, webSocket, vlessResponseHeader, log,) { - /** - * 连接远程服务器并写入数据 - * @param {string} address 要连接的地址 - * @param {number} port 要连接的端口 - * @param {boolean} socks 是否使用 SOCKS5 代理连接 - * @returns {Promise} 连接后的 TCP Socket - */ - async function connectAndWrite(address, port, socks = false) { - /** @type {import("@cloudflare/workers-types").Socket} */ - log(`connected to ${address}:${port}`); - //if (/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(address)) address = `${atob('d3d3Lg==')}${address}${atob('LmlwLjA5MDIyNy54eXo=')}`; - // 如果指定使用 SOCKS5 代理，则通过 SOCKS5 协议连接；否则直接连接 - const tcpSocket = socks ? await socks5Connect(addressType, address, port, log) - : connect({ - hostname: address, - port: port, - }); - remoteSocket.value = tcpSocket; - //log(`connected to ${address}:${port}`); - const writer = tcpSocket.writable.getWriter(); - // 首次写入，通常是 TLS 客户端 Hello 消息 - await writer.write(rawClientData); - writer.releaseLock(); - return tcpSocket; - } - - /** - * 重试函数：当 Cloudflare 的 TCP Socket 没有传入数据时，我们尝试重定向 IP - * 这可能是因为某些网络问题导致的连接失败 - */ - async function retry() { - if (enableSocks) { - // 如果启用了 SOCKS5，通过 SOCKS5 代理重试连接 - tcpSocket = await connectAndWrite(addressRemote, portRemote, true); - } else { - // 否则，尝试使用预设的代理 IP（如果有）或原始地址重试连接 - if (!proxyIP || proxyIP == '') proxyIP = atob('cHJveHlpcC5meHhrLmRlZHluLmlv'); - tcpSocket = await connectAndWrite(proxyIP || addressRemote, portRemote); - } - // 无论重试是否成功，都要关闭 WebSocket（可能是为了重新建立连接） - tcpSocket.closed.catch(error => { - console.log('retry tcpSocket closed error', error); - }).finally(() => { - safeCloseWebSocket(webSocket); - }) - // 建立从远程 Socket 到 WebSocket 的数据流 - remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, null, log); - } - - // 首次尝试连接远程服务器 - let tcpSocket = await connectAndWrite(addressRemote, portRemote); - - // 当远程 Socket 就绪时，将其传递给 WebSocket - // 建立从远程服务器到 WebSocket 的数据流，用于将远程服务器的响应发送回客户端 - // 如果连接失败或无数据，retry 函数将被调用进行重试 - remoteSocketToWS(tcpSocket, webSocket, vlessResponseHeader, retry, log); -} - -/** - * 将 WebSocket 转换为可读流（ReadableStream） - * @param {import("@cloudflare/workers-types").WebSocket} webSocketServer 服务器端的 WebSocket 对象 - * @param {string} earlyDataHeader WebSocket 0-RTT（零往返时间）的早期数据头部 - * @param {(info: string)=> void} log 日志记录函数，用于记录 WebSocket 0-RTT 相关信息 - * @returns {ReadableStream} 由 WebSocket 消息组成的可读流 - */ -function makeReadableWebSocketStream(webSocketServer, earlyDataHeader, log) { - // 标记可读流是否已被取消 - let readableStreamCancel = false; - - // 创建一个新的可读流 - const stream = new ReadableStream({ - // 当流开始时的初始化函数 - start(controller) { - // 监听 WebSocket 的消息事件 - webSocketServer.addEventListener('message', (event) => { - // 如果流已被取消，不再处理新消息 - if (readableStreamCancel) { - return; - } - const message = event.data; - // 将消息加入流的队列中 - controller.enqueue(message); - }); - - // 监听 WebSocket 的关闭事件 - // 注意：这个事件意味着客户端关闭了客户端 -> 服务器的流 - // 但是，服务器 -> 客户端的流仍然打开，直到在服务器端调用 close() - // WebSocket 协议要求在每个方向上都要发送单独的关闭消息，以完全关闭 Socket - webSocketServer.addEventListener('close', () => { - // 客户端发送了关闭信号，需要关闭服务器端 - safeCloseWebSocket(webSocketServer); - // 如果流未被取消，则关闭控制器 - if (readableStreamCancel) { - return; - } - controller.close(); - }); - - // 监听 WebSocket 的错误事件 - webSocketServer.addEventListener('error', (err) => { - log('WebSocket 服务器发生错误'); - // 将错误传递给控制器 - controller.error(err); - }); - - // 处理 WebSocket 0-RTT（零往返时间）的早期数据 - // 0-RTT 允许在完全建立连接之前发送数据，提高了效率 - const { earlyData, error } = base64ToArrayBuffer(earlyDataHeader); - if (error) { - // 如果解码早期数据时出错，将错误传递给控制器 - controller.error(error); - } else if (earlyData) { - // 如果有早期数据，将其加入流的队列中 - controller.enqueue(earlyData); - } - }, - - // 当使用者从流中拉取数据时调用 - pull(controller) { - // 这里可以实现反压机制 - // 如果 WebSocket 可以在流满时停止读取，我们就可以实现反压 - // 参考：https://streams.spec.whatwg.org/#example-rs-push-backpressure - }, - - // 当流被取消时调用 - cancel(reason) { - // 流被取消的几种情况： - // 1. 当管道的 WritableStream 有错误时，这个取消函数会被调用，所以在这里处理 WebSocket 服务器的关闭 - // 2. 如果 ReadableStream 被取消，所有 controller.close/enqueue 都需要跳过 - // 3. 但是经过测试，即使 ReadableStream 被取消，controller.error 仍然有效 - if (readableStreamCancel) { - return; - } - log(`可读流被取消，原因是 ${reason}`); - readableStreamCancel = true; - // 安全地关闭 WebSocket - safeCloseWebSocket(webSocketServer); - } - }); - - return stream; -} - -// https://xtls.github.io/development/protocols/vless.html -// https://github.com/zizifn/excalidraw-backup/blob/main/v2ray-protocol.excalidraw - -/** - * 解析 VLESS 协议的头部数据 - * @param { ArrayBuffer} vlessBuffer VLESS 协议的原始头部数据 - * @param {string} userID 用于验证的用户 ID - * @returns {Object} 解析结果，包括是否有错误、错误信息、远程地址信息等 - */ -function processVlessHeader(vlessBuffer, userID) { - // 检查数据长度是否足够（至少需要 24 字节） - if (vlessBuffer.byteLength < 24) { - return { - hasError: true, - message: 'invalid data', - }; - } - - // 解析 VLESS 协议版本（第一个字节） - const version = new Uint8Array(vlessBuffer.slice(0, 1)); - - let isValidUser = false; - let isUDP = false; - - // 验证用户 ID（接下来的 16 个字节） - if (stringify(new Uint8Array(vlessBuffer.slice(1, 17))) === userID) { - isValidUser = true; - } - // 如果用户 ID 无效，返回错误 - if (!isValidUser) { - return { - hasError: true, - message: `invalid user ${(new Uint8Array(vlessBuffer.slice(1, 17)))}`, - }; - } - - // 获取附加选项的长度（第 17 个字节） - const optLength = new Uint8Array(vlessBuffer.slice(17, 18))[0]; - // 暂时跳过附加选项 - - // 解析命令（紧跟在选项之后的 1 个字节） - // 0x01: TCP, 0x02: UDP, 0x03: MUX（多路复用） - const command = new Uint8Array( - vlessBuffer.slice(18 + optLength, 18 + optLength + 1) - )[0]; - - // 0x01 TCP - // 0x02 UDP - // 0x03 MUX - if (command === 1) { - // TCP 命令，不需特殊处理 - } else if (command === 2) { - // UDP 命令 - isUDP = true; - } else { - // 不支持的命令 - return { - hasError: true, - message: `command ${command} is not support, command 01-tcp,02-udp,03-mux`, - }; - } - - // 解析远程端口（大端序，2 字节） - const portIndex = 18 + optLength + 1; - const portBuffer = 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(4字节), 2-域名(可变长), 3-IPv6(16字节) - const addressType = addressBuffer[0]; - let addressLength = 0; - let addressValueIndex = addressIndex + 1; - let addressValue = ''; - - switch (addressType) { - case 1: - // IPv4 地址 - addressLength = 4; - // 将 4 个字节转为点分十进制格式 - addressValue = new Uint8Array( - 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: - // IPv6 地址 - addressLength = 16; - const dataView = new DataView( - vlessBuffer.slice(addressValueIndex, addressValueIndex + addressLength) - ); - // 每 2 字节构成 IPv6 地址的一部分 - const ipv6 = []; - for (let i = 0; i < 8; i++) { - ipv6.push(dataView.getUint16(i * 2).toString(16)); - } - addressValue = ipv6.join(':'); - // seems no need add [] for ipv6 - break; - default: - // 无效的地址类型 - return { - hasError: true, - message: `invild addressType is ${addressType}`, - }; - } - - // 确保地址不为空 - if (!addressValue) { - return { - hasError: true, - message: `addressValue is empty, addressType is ${addressType}`, - }; - } - - // 返回解析结果 - return { - hasError: false, - addressRemote: addressValue, // 解析后的远程地址 - addressType, // 地址类型 - portRemote, // 远程端口 - rawDataIndex: addressValueIndex + addressLength, // 原始数据的实际起始位置 - vlessVersion: version, // VLESS 协议版本 - isUDP, // 是否是 UDP 请求 - }; -} - - -/** - * 将远程 Socket 的数据转发到 WebSocket - * - * @param {import("@cloudflare/workers-types").Socket} remoteSocket 远程服务器的 Socket 连接 - * @param {import("@cloudflare/workers-types").WebSocket} webSocket 客户端的 WebSocket 连接 - * @param {ArrayBuffer} vlessResponseHeader VLESS 协议的响应头部 - * @param {(() => Promise) | null} retry 重试函数，当没有数据时调用 - * @param {*} log 日志函数 - */ -async function remoteSocketToWS(remoteSocket, webSocket, vlessResponseHeader, retry, log) { - // 将数据从远程服务器转发到 WebSocket - let remoteChunkCount = 0; - let chunks = []; - /** @type {ArrayBuffer | null} */ - let vlessHeader = vlessResponseHeader; - let hasIncomingData = false; // 检查远程 Socket 是否有传入数据 - - // 使用管道将远程 Socket 的可读流连接到一个可写流 - await remoteSocket.readable - .pipeTo( - new WritableStream({ - start() { - // 初始化时不需要任何操作 - }, - /** - * 处理每个数据块 - * @param {Uint8Array} chunk 数据块 - * @param {*} controller 控制器 - */ - async write(chunk, controller) { - hasIncomingData = true; // 标记已收到数据 - // remoteChunkCount++; // 用于流量控制，现在似乎不需要了 - - // 检查 WebSocket 是否处于开放状态 - if (webSocket.readyState !== WS_READY_STATE_OPEN) { - controller.error( - 'webSocket.readyState is not open, maybe close' - ); - } - - if (vlessHeader) { - // 如果有 VLESS 响应头部，将其与第一个数据块一起发送 - webSocket.send(await new Blob([vlessHeader, chunk]).arrayBuffer()); - vlessHeader = null; // 清空头部，之后不再发送 - } else { - // 直接发送数据块 - // 以前这里有流量控制代码，限制大量数据的发送速率 - // 但现在 Cloudflare 似乎已经修复了这个问题 - // if (remoteChunkCount > 20000) { - // // cf one package is 4096 byte(4kb), 4096 * 20000 = 80M - // await delay(1); - // } - webSocket.send(chunk); - } - }, - close() { - // 当远程连接的可读流关闭时 - log(`remoteConnection!.readable is close with hasIncomingData is ${hasIncomingData}`); - // 不需要主动关闭 WebSocket，因为这可能导致 HTTP ERR_CONTENT_LENGTH_MISMATCH 问题 - // 客户端无论如何都会发送关闭事件 - // safeCloseWebSocket(webSocket); - }, - abort(reason) { - // 当远程连接的可读流中断时 - console.error(`remoteConnection!.readable abort`, reason); - }, - }) - ) - .catch((error) => { - // 捕获并记录任何异常 - console.error( - `remoteSocketToWS has exception `, - error.stack || error - ); - // 发生错误时安全地关闭 WebSocket - safeCloseWebSocket(webSocket); - }); - - // 处理 Cloudflare 连接 Socket 的特殊错误情况 - // 1. Socket.closed 将有错误 - // 2. Socket.readable 将关闭，但没有任何数据 - if (hasIncomingData === false && retry) { - log(`retry`); - retry(); // 调用重试函数，尝试重新建立连接 - } -} - -/** - * 将 Base64 编码的字符串转换为 ArrayBuffer - * - * @param {string} base64Str Base64 编码的输入字符串 - * @returns {{ earlyData: ArrayBuffer | undefined, error: Error | null }} 返回解码后的 ArrayBuffer 或错误 - */ -function base64ToArrayBuffer(base64Str) { - // 如果输入为空，直接返回空结果 - if (!base64Str) { - return { error: null }; - } - try { - // Go 语言使用了 URL 安全的 Base64 变体（RFC 4648） - // 这种变体使用 '-' 和 '_' 来代替标准 Base64 中的 '+' 和 '/' - // JavaScript 的 atob 函数不直接支持这种变体，所以我们需要先转换 - base64Str = base64Str.replace(/-/g, '+').replace(/_/g, '/'); - - // 使用 atob 函数解码 Base64 字符串 - // atob 将 Base64 编码的 ASCII 字符串转换为原始的二进制字符串 - const decode = atob(base64Str); - - // 将二进制字符串转换为 Uint8Array - // 这是通过遍历字符串中的每个字符并获取其 Unicode 编码值（0-255）来完成的 - const arryBuffer = Uint8Array.from(decode, (c) => c.charCodeAt(0)); - - // 返回 Uint8Array 的底层 ArrayBuffer - // 这是实际的二进制数据，可以用于网络传输或其他二进制操作 - return { earlyData: arryBuffer.buffer, error: null }; - } catch (error) { - // 如果在任何步骤中出现错误（如非法 Base64 字符），则返回错误 - return { error }; - } -} - -/** - * 这不是真正的 UUID 验证，而是一个简化的版本 - * @param {string} uuid 要验证的 UUID 字符串 - * @returns {boolean} 如果字符串匹配 UUID 格式则返回 true，否则返回 false - */ -function isValidUUID(uuid) { - // 定义一个正则表达式来匹配 UUID 格式 - const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; - - // 使用正则表达式测试 UUID 字符串 - return uuidRegex.test(uuid); -} - -// WebSocket 的两个重要状态常量 -const WS_READY_STATE_OPEN = 1; // WebSocket 处于开放状态，可以发送和接收消息 -const WS_READY_STATE_CLOSING = 2; // WebSocket 正在关闭过程中 - -/** - * 安全地关闭 WebSocket 连接 - * 通常，WebSocket 在关闭时不会抛出异常，但为了以防万一，我们还是用 try-catch 包裹 - * @param {import("@cloudflare/workers-types").WebSocket} socket 要关闭的 WebSocket 对象 - */ -function safeCloseWebSocket(socket) { - try { - // 只有在 WebSocket 处于开放或正在关闭状态时才调用 close() - // 这避免了在已关闭或连接中的 WebSocket 上调用 close() - if (socket.readyState === WS_READY_STATE_OPEN || socket.readyState === WS_READY_STATE_CLOSING) { - socket.close(); - } - } catch (error) { - // 记录任何可能发生的错误，虽然按照规范不应该有错误 - console.error('safeCloseWebSocket error', error); - } -} - -// 预计算 0-255 每个字节的十六进制表示 -const byteToHex = []; -for (let i = 0; i < 256; ++i) { - // (i + 256).toString(16) 确保总是得到两位数的十六进制 - // .slice(1) 删除前导的 "1"，只保留两位十六进制数 - byteToHex.push((i + 256).toString(16).slice(1)); -} - -/** - * 快速地将字节数组转换为 UUID 字符串，不进行有效性检查 - * 这是一个底层函数，直接操作字节，不做任何验证 - * @param {Uint8Array} arr 包含 UUID 字节的数组 - * @param {number} offset 数组中 UUID 开始的位置，默认为 0 - * @returns {string} UUID 字符串 - */ -function unsafeStringify(arr, offset = 0) { - // 直接从查找表中获取每个字节的十六进制表示，并拼接成 UUID 格式 - // 8-4-4-4-12 的分组是通过精心放置的连字符 "-" 实现的 - // toLowerCase() 确保整个 UUID 是小写的 - return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + - byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + - byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + - byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + - byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + - byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); -} - -/** - * 将字节数组转换为 UUID 字符串，并验证其有效性 - * 这是一个安全的函数，它确保返回的 UUID 格式正确 - * @param {Uint8Array} arr 包含 UUID 字节的数组 - * @param {number} offset 数组中 UUID 开始的位置，默认为 0 - * @returns {string} 有效的 UUID 字符串 - * @throws {TypeError} 如果生成的 UUID 字符串无效 - */ -function stringify(arr, offset = 0) { - // 使用不安全的函数快速生成 UUID 字符串 - const uuid = unsafeStringify(arr, offset); - // 验证生成的 UUID 是否有效 - if (!isValidUUID(uuid)) { - // 原：throw TypeError("Stringified UUID is invalid"); - throw TypeError(`生成的 UUID 不符合规范 ${uuid}`); - //uuid = userID; - } - return uuid; -} - -/** - * 处理 DNS 查询的函数 - * @param {ArrayBuffer} udpChunk - 客户端发送的 DNS 查询数据 - * @param {import("@cloudflare/workers-types").WebSocket} webSocket - 与客户端建立的 WebSocket 连接 - * @param {ArrayBuffer} vlessResponseHeader - VLESS 协议的响应头部数据 - * @param {(string)=> void} log - 日志记录函数 - */ -async function handleDNSQuery(udpChunk, webSocket, vlessResponseHeader, log) { - // 无论客户端发送到哪个 DNS 服务器，我们总是使用硬编码的服务器 - // 因为有些 DNS 服务器不支持 DNS over TCP - try { - // 选用 Google 的 DNS 服务器（注：后续可能会改为 Cloudflare 的 1.1.1.1） - const dnsServer = '8.8.4.4'; // 在 Cloudflare 修复连接自身 IP 的 bug 后，将改为 1.1.1.1 - const dnsPort = 53; // DNS 服务的标准端口 - - /** @type {ArrayBuffer | null} */ - let vlessHeader = vlessResponseHeader; // 保存 VLESS 响应头部，用于后续发送 - - /** @type {import("@cloudflare/workers-types").Socket} */ - // 与指定的 DNS 服务器建立 TCP 连接 - const tcpSocket = connect({ - hostname: dnsServer, - port: dnsPort, - }); - - log(`连接到 ${dnsServer}:${dnsPort}`); // 记录连接信息 - const writer = tcpSocket.writable.getWriter(); - await writer.write(udpChunk); // 将客户端的 DNS 查询数据发送给 DNS 服务器 - writer.releaseLock(); // 释放写入器，允许其他部分使用 - - // 将从 DNS 服务器接收到的响应数据通过 WebSocket 发送回客户端 - await tcpSocket.readable.pipeTo(new WritableStream({ - async write(chunk) { - if (webSocket.readyState === WS_READY_STATE_OPEN) { - if (vlessHeader) { - // 如果有 VLESS 头部，则将其与 DNS 响应数据合并后发送 - webSocket.send(await new Blob([vlessHeader, chunk]).arrayBuffer()); - vlessHeader = null; // 头部只发送一次，之后置为 null - } else { - // 否则直接发送 DNS 响应数据 - webSocket.send(chunk); - } - } - }, - close() { - log(`DNS 服务器(${dnsServer}) TCP 连接已关闭`); // 记录连接关闭信息 - }, - abort(reason) { - console.error(`DNS 服务器(${dnsServer}) TCP 连接异常中断`, reason); // 记录异常中断原因 - }, - })); - } catch (error) { - // 捕获并记录任何可能发生的错误 - console.error( - `handleDNSQuery 函数发生异常，错误信息: ${error.message}` - ); - } -} - -/** - * 建立 SOCKS5 代理连接 - * @param {number} addressType 目标地址类型（1: IPv4, 2: 域名, 3: IPv6） - * @param {string} addressRemote 目标地址（可以是 IP 或域名） - * @param {number} portRemote 目标端口 - * @param {function} log 日志记录函数 - */ -async function socks5Connect(addressType, addressRemote, portRemote, log) { - const { username, password, hostname, port } = parsedSocks5Address; - // 连接到 SOCKS5 代理服务器 - const socket = connect({ - hostname, // SOCKS5 服务器的主机名 - port, // SOCKS5 服务器的端口 - }); - - // 请求头格式（Worker -> SOCKS5 服务器）: - // +----+----------+----------+ - // |VER | NMETHODS | METHODS | - // +----+----------+----------+ - // | 1 | 1 | 1 to 255 | - // +----+----------+----------+ - - // https://en.wikipedia.org/wiki/SOCKS#SOCKS5 - // METHODS 字段的含义: - // 0x00 不需要认证 - // 0x02 用户名/密码认证 https://datatracker.ietf.org/doc/html/rfc1929 - const socksGreeting = new Uint8Array([5, 2, 0, 2]); - // 5: SOCKS5 版本号, 2: 支持的认证方法数, 0和2: 两种认证方法（无认证和用户名/密码） - - const writer = socket.writable.getWriter(); - - await writer.write(socksGreeting); - log('已发送 SOCKS5 问候消息'); - - const reader = socket.readable.getReader(); - const encoder = new TextEncoder(); - let res = (await reader.read()).value; - // 响应格式（SOCKS5 服务器 -> Worker）: - // +----+--------+ - // |VER | METHOD | - // +----+--------+ - // | 1 | 1 | - // +----+--------+ - if (res[0] !== 0x05) { - log(`SOCKS5 服务器版本错误: 收到 ${res[0]}，期望是 5`); - return; - } - if (res[1] === 0xff) { - log("服务器不接受任何认证方法"); - return; - } - - // 如果返回 0x0502，表示需要用户名/密码认证 - if (res[1] === 0x02) { - log("SOCKS5 服务器需要认证"); - if (!username || !password) { - log("请提供用户名和密码"); - return; - } - // 认证请求格式: - // +----+------+----------+------+----------+ - // |VER | ULEN | UNAME | PLEN | PASSWD | - // +----+------+----------+------+----------+ - // | 1 | 1 | 1 to 255 | 1 | 1 to 255 | - // +----+------+----------+------+----------+ - const authRequest = new Uint8Array([ - 1, // 认证子协议版本 - username.length, // 用户名长度 - ...encoder.encode(username), // 用户名 - password.length, // 密码长度 - ...encoder.encode(password) // 密码 - ]); - await writer.write(authRequest); - res = (await reader.read()).value; - // 期望返回 0x0100 表示认证成功 - if (res[0] !== 0x01 || res[1] !== 0x00) { - log("SOCKS5 服务器认证失败"); - return; - } - } - - // 请求数据格式（Worker -> SOCKS5 服务器）: - // +----+-----+-------+------+----------+----------+ - // |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT | - // +----+-----+-------+------+----------+----------+ - // | 1 | 1 | X'00' | 1 | Variable | 2 | - // +----+-----+-------+------+----------+----------+ - // ATYP: 地址类型 - // 0x01: IPv4 地址 - // 0x03: 域名 - // 0x04: IPv6 地址 - // DST.ADDR: 目标地址 - // DST.PORT: 目标端口（网络字节序） - - // addressType - // 1 --> IPv4 地址长度 = 4 - // 2 --> 域名 - // 3 --> IPv6 地址长度 = 16 - let DSTADDR; // DSTADDR = ATYP + DST.ADDR - switch (addressType) { - case 1: // IPv4 - DSTADDR = new Uint8Array( - [1, ...addressRemote.split('.').map(Number)] - ); - break; - case 2: // 域名 - DSTADDR = new Uint8Array( - [3, addressRemote.length, ...encoder.encode(addressRemote)] - ); - break; - case 3: // IPv6 - DSTADDR = new Uint8Array( - [4, ...addressRemote.split(':').flatMap(x => [parseInt(x.slice(0, 2), 16), parseInt(x.slice(2), 16)])] - ); - break; - default: - log(`无效的地址类型: ${addressType}`); - return; - } - const socksRequest = new Uint8Array([5, 1, 0, ...DSTADDR, portRemote >> 8, portRemote & 0xff]); - // 5: SOCKS5版本, 1: 表示CONNECT请求, 0: 保留字段 - // ...DSTADDR: 目标地址, portRemote >> 8 和 & 0xff: 将端口转为网络字节序 - await writer.write(socksRequest); - log('已发送 SOCKS5 请求'); - - res = (await reader.read()).value; - // 响应格式（SOCKS5 服务器 -> Worker）: - // +----+-----+-------+------+----------+----------+ - // |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT | - // +----+-----+-------+------+----------+----------+ - // | 1 | 1 | X'00' | 1 | Variable | 2 | - // +----+-----+-------+------+----------+----------+ - if (res[1] === 0x00) { - log("SOCKS5 连接已建立"); - } else { - log("SOCKS5 连接建立失败"); - return; - } - writer.releaseLock(); - reader.releaseLock(); - return socket; -} - - -/** - * SOCKS5 代理地址解析器 - * 此函数用于解析 SOCKS5 代理地址字符串，提取出用户名、密码、主机名和端口号 - * - * @param {string} address SOCKS5 代理地址，格式可以是： - * - "username:password@hostname:port" （带认证） - * - "hostname:port" （不需认证） - * - "username:password@[ipv6]:port" （IPv6 地址需要用方括号括起来） - */ -function socks5AddressParser(address) { - // 使用 "@" 分割地址，分为认证部分和服务器地址部分 - // reverse() 是为了处理没有认证信息的情况，确保 latter 总是包含服务器地址 - let [latter, former] = address.split("@").reverse(); - let username, password, hostname, port; - - // 如果存在 former 部分，说明提供了认证信息 - if (former) { - const formers = former.split(":"); - if (formers.length !== 2) { - throw new Error('无效的 SOCKS 地址格式：认证部分必须是 "username:password" 的形式'); - } - [username, password] = formers; - } - - // 解析服务器地址部分 - const latters = latter.split(":"); - // 从末尾提取端口号（因为 IPv6 地址中也包含冒号） - port = Number(latters.pop()); - if (isNaN(port)) { - throw new Error('无效的 SOCKS 地址格式：端口号必须是数字'); - } - - // 剩余部分就是主机名（可能是域名、IPv4 或 IPv6 地址） - hostname = latters.join(":"); - - // 处理 IPv6 地址的特殊情况 - // IPv6 地址包含多个冒号，所以必须用方括号括起来，如 [2001:db8::1] - const regex = /^\[.*\]$/; - if (hostname.includes(":") && !regex.test(hostname)) { - throw new Error('无效的 SOCKS 地址格式：IPv6 地址必须用方括号括起来，如 [2001:db8::1]'); - } - - //if (/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(hostname)) hostname = `${atob('d3d3Lg==')}${hostname}${atob('LmlwLjA5MDIyNy54eXo=')}`; - // 返回解析后的结果 - return { - username, // 用户名，如果没有则为 undefined - password, // 密码，如果没有则为 undefined - hostname, // 主机名，可以是域名、IPv4 或 IPv6 地址 - port, // 端口号，已转换为数字类型 - } -} - -/** - * 恢复被伪装的信息 - * 这个函数用于将内容中的假用户ID和假主机名替换回真实的值 - * - * @param {string} content 需要处理的内容 - * @param {string} userID 真实的用户ID - * @param {string} hostName 真实的主机名 - * @param {boolean} isBase64 内容是否是Base64编码的 - * @returns {string} 恢复真实信息后的内容 - */ -function revertFakeInfo(content, userID, hostName, isBase64) { - if (isBase64) content = atob(content); // 如果内容是Base64编码的，先解码 - - // 使用正则表达式全局替换（'g'标志） - // 将所有出现的假用户ID和假主机名替换为真实的值 - content = content.replace(new RegExp(fakeUserID, 'g'), userID) - .replace(new RegExp(fakeHostName, 'g'), hostName); - - if (isBase64) content = btoa(content); // 如果原内容是Base64编码的，处理完后再次编码 - - return content; -} - -/** - * 双重MD5哈希函数 - * 这个函数对输入文本进行两次MD5哈希，增强安全性 - * 第二次哈希使用第一次哈希结果的一部分作为输入 - * - * @param {string} text 要哈希的文本 - * @returns {Promise} 双重哈希后的小写十六进制字符串 - */ -async function MD5MD5(text) { - const encoder = new TextEncoder(); - - // 第一次MD5哈希 - const firstPass = await crypto.subtle.digest('MD5', encoder.encode(text)); - const firstPassArray = Array.from(new Uint8Array(firstPass)); - const firstHex = firstPassArray.map(b => b.toString(16).padStart(2, '0')).join(''); - - // 第二次MD5哈希，使用第一次哈希结果的中间部分（索引7到26） - const secondPass = await crypto.subtle.digest('MD5', encoder.encode(firstHex.slice(7, 27))); - const secondPassArray = Array.from(new Uint8Array(secondPass)); - const secondHex = secondPassArray.map(b => b.toString(16).padStart(2, '0')).join(''); - - return secondHex.toLowerCase(); // 返回小写的十六进制字符串 -} - -/** - * 解析并清理环境变量中的地址列表 - * 这个函数用于处理包含多个地址的环境变量 - * 它会移除所有的空白字符、引号等，并将地址列表转换为数组 - * - * @param {string} envadd 包含地址列表的环境变量值 - * @returns {Promise} 清理和分割后的地址数组 - */ -async function ADD(envadd) { - // 将制表符、双引号、单引号和换行符都替换为逗号 - // 然后将连续的多个逗号替换为单个逗号 - var addtext = envadd.replace(/[ |"'\r\n]+/g, ',').replace(/,+/g, ','); - - // 删除开头和结尾的逗号（如果有的话） - if (addtext.charAt(0) == ',') addtext = addtext.slice(1); - if (addtext.charAt(addtext.length - 1) == ',') addtext = addtext.slice(0, addtext.length - 1); - - // 使用逗号分割字符串，得到地址数组 - const add = addtext.split(','); - - return add; -} - -const 啥啥啥_写的这是啥啊 = 'dmxlc3M='; -function 配置信息(UUID, 域名地址) { - const 协议类型 = atob(啥啥啥_写的这是啥啊); - - const 别名 = 域名地址; - let 地址 = 域名地址; - let 端口 = 443; - - const 用户ID = UUID; - const 加密方式 = 'none'; - - const 传输层协议 = 'ws'; - const 伪装域名 = 域名地址; - const 路径 = '/?ed=2560'; - - let 传输层安全 = ['tls',true]; - const SNI = 域名地址; - const 指纹 = 'randomized'; - - if (域名地址.includes('.workers.dev')){ - 地址 = 'www.wto.org'; - 端口 = 80 ; - 传输层安全 = ['',false]; - } - - const v2ray = `${协议类型}://${用户ID}@${地址}:${端口}?encryption=${加密方式}&security=${传输层安全[0]}&sni=${SNI}&fp=${指纹}&type=${传输层协议}&host=${伪装域名}&path=${encodeURIComponent(路径)}#${encodeURIComponent(别名)}`; - const clash = `- type: ${协议类型} - name: ${别名} - server: ${地址} - port: ${端口} - uuid: ${用户ID} - network: ${传输层协议} - tls: ${传输层安全[1]} - udp: false - sni: ${SNI} - client-fingerprint: ${指纹} - ws-opts: - path: "${路径}" - headers: - host: ${伪装域名}`; - return [v2ray,clash]; -} - -let subParams = ['sub','base64','b64','clash','singbox','sb']; - -/** - * @param {string} userID - * @param {string | null} hostName - * @param {string} sub - * @param {string} UA - * @returns {Promise} - */ -async function getVLESSConfig(userID, hostName, sub, UA, RproxyIP, _url) { - const userAgent = UA.toLowerCase(); - const Config = 配置信息(userID , hostName); - const v2ray = Config[0]; - const clash = Config[1]; - let proxyhost = ""; - if(hostName.includes(".workers.dev") || hostName.includes(".pages.dev")){ - if ( proxyhostsURL && (!proxyhosts || proxyhosts.length == 0)) { - try { - const response = await fetch(proxyhostsURL); - - if (!response.ok) { - console.error('获取地址时出错:', response.status, response.statusText); - return; // 如果有错误，直接返回 - } - - const text = await response.text(); - const lines = text.split('\n'); - // 过滤掉空行或只包含空白字符的行 - const nonEmptyLines = lines.filter(line => line.trim() !== ''); - - proxyhosts = proxyhosts.concat(nonEmptyLines); - } catch (error) { - //console.error('获取地址时出错:', error); - } - } - if (proxyhosts.length != 0) proxyhost = proxyhosts[Math.floor(Math.random() * proxyhosts.length)] + "/"; - } - - if ( userAgent.includes('mozilla') && !subParams.some(_searchParams => _url.searchParams.has(_searchParams))) { - let 订阅器 = `您的订阅内容由 ${sub} 提供维护支持, 自动获取ProxyIP: ${RproxyIP}`; - if (!sub || sub == '') { - if (!proxyIP || proxyIP =='') { - 订阅器 = '您的订阅内容由 内置 addresses/ADD 参数提供, 当前使用的ProxyIP为空, 推荐您设置 proxyIP/PROXYIP ！！！'; - } else { - 订阅器 = `您的订阅内容由 内置 addresses/ADD 参数提供, 当前使用的ProxyIP: ${proxyIPs.join(', ')}`; - } - } else if (RproxyIP != 'true'){ - if (enableSocks) 订阅器 += `, 当前使用的Socks5: ${parsedSocks5Address.hostname}:${String(parsedSocks5Address.port)}`; - else 订阅器 += `, 当前使用的ProxyIP: ${proxyIPs.join(', ')}`; - } - return ` -################################################################ -Subscribe / sub 订阅地址, 支持 Base64、clash-meta、sing-box 订阅格式, ${订阅器} ---------------------------------------------------------------- -快速自适应订阅地址: -https://${proxyhost}${hostName}/${userID} -https://${proxyhost}${hostName}/${userID}?sub - -Base64订阅地址: -https://${proxyhost}${hostName}/${userID}?b64 -https://${proxyhost}${hostName}/${userID}?base64 - -clash订阅地址: -https://${proxyhost}${hostName}/${userID}?clash - -singbox订阅地址: -https://${proxyhost}${hostName}/${userID}?sb -https://${proxyhost}${hostName}/${userID}?singbox ---------------------------------------------------------------- -################################################################ -v2ray ---------------------------------------------------------------- -${v2ray} ---------------------------------------------------------------- -################################################################ -clash-meta ---------------------------------------------------------------- -${clash} ---------------------------------------------------------------- -################################################################ -telegram 交流群 技术大佬~在线发牌! -https://t.me/CMLiussss ---------------------------------------------------------------- -github 项目地址 Star!Star!Star!!! -https://github.com/cmliu/edgetunnel ---------------------------------------------------------------- -################################################################ -`; - } else { - if (typeof fetch != 'function') { - return 'Error: fetch is not available in this environment.'; - } - - let newAddressesapi = []; - let newAddressescsv = []; - let newAddressesnotlsapi = []; - let newAddressesnotlscsv = []; - - // 如果是使用默认域名，则改成一个workers的域名，订阅器会加上代理 - if (hostName.includes(".workers.dev")){ - noTLS = 'true'; - fakeHostName = `${fakeHostName}.workers.dev`; - newAddressesnotlsapi = await getAddressesapi(addressesnotlsapi); - newAddressesnotlscsv = await getAddressescsv('FALSE'); - } else if (hostName.includes(".pages.dev")){ - fakeHostName = `${fakeHostName}.pages.dev`; - } else if (hostName.includes("worker") || hostName.includes("notls") || noTLS == 'true'){ - noTLS = 'true'; - fakeHostName = `notls${fakeHostName}.net`; - newAddressesnotlsapi = await getAddressesapi(addressesnotlsapi); - newAddressesnotlscsv = await getAddressescsv('FALSE'); - } else { - fakeHostName = `${fakeHostName}.xyz` - } - console.log(`虚假HOST: ${fakeHostName}`); - let url = `${subProtocol}://${sub}/sub?host=${fakeHostName}&uuid=${fakeUserID}&edgetunnel=cmliu&proxyip=${RproxyIP}`; - let isBase64 = true; - - if (!sub || sub == ""){ - if(hostName.includes('workers.dev') || hostName.includes('pages.dev')) { - if (proxyhostsURL && (!proxyhosts || proxyhosts.length == 0)) { - try { - const response = await fetch(proxyhostsURL); - - if (!response.ok) { - console.error('获取地址时出错:', response.status, response.statusText); - return; // 如果有错误，直接返回 - } - - const text = await response.text(); - const lines = text.split('\n'); - // 过滤掉空行或只包含空白字符的行 - const nonEmptyLines = lines.filter(line => line.trim() !== ''); - - proxyhosts = proxyhosts.concat(nonEmptyLines); - } catch (error) { - console.error('获取地址时出错:', error); - } - } - // 使用Set对象去重 - proxyhosts = [...new Set(proxyhosts)]; - } - - newAddressesapi = await getAddressesapi(addressesapi); - newAddressescsv = await getAddressescsv('TRUE'); - url = `https://${hostName}/${fakeUserID}`; - if (hostName.includes("worker") || hostName.includes("notls") || noTLS == 'true') url += '?notls'; - console.log(`虚假订阅: ${url}`); - } - - if (!userAgent.includes(('CF-Workers-SUB').toLowerCase())){ - if ((userAgent.includes('clash') && !userAgent.includes('nekobox')) || ( _url.searchParams.has('clash') && !userAgent.includes('subconverter'))) { - url = `${subProtocol}://${subconverter}/sub?target=clash&url=${encodeURIComponent(url)}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`; - isBase64 = false; - } else if (userAgent.includes('sing-box') || userAgent.includes('singbox') || (( _url.searchParams.has('singbox') || _url.searchParams.has('sb')) && !userAgent.includes('subconverter'))) { - url = `${subProtocol}://${subconverter}/sub?target=singbox&url=${encodeURIComponent(url)}&insert=false&config=${encodeURIComponent(subconfig)}&emoji=true&list=false&tfo=false&scv=true&fdn=false&sort=false&new_name=true`; - isBase64 = false; - } - } - - try { - let content; - if ((!sub || sub == "") && isBase64 == true) { - content = await subAddresses(fakeHostName,fakeUserID,noTLS,newAddressesapi,newAddressescsv,newAddressesnotlsapi,newAddressesnotlscsv); - } else { - const response = await fetch(url ,{ - headers: { - 'User-Agent': `${UA} CF-Workers-edgetunnel/cmliu` - }}); - content = await response.text(); - } - - if (_url.pathname == `/${fakeUserID}`) return content; - - return revertFakeInfo(content, userID, hostName, isBase64); - - } catch (error) { - console.error('Error fetching content:', error); - return `Error fetching content: ${error.message}`; - } - - } -} - -async function getAccountId(email, key) { - try { - const url = 'https://api.cloudflare.com/client/v4/accounts'; - const headers = new Headers({ - 'X-AUTH-EMAIL': email, - 'X-AUTH-KEY': key - }); - const response = await fetch(url, { headers }); - const data = await response.json(); - return data.result[0].id; // 假设我们需要第一个账号ID - } catch (error) { - return false ; - } -} - -async function getSum(accountId, accountIndex, email, key, startDate, endDate) { - try { - const startDateISO = new Date(startDate).toISOString(); - const endDateISO = new Date(endDate).toISOString(); - - const query = JSON.stringify({ - query: `query getBillingMetrics($accountId: String!, $filter: AccountWorkersInvocationsAdaptiveFilter_InputObject) { - viewer { - accounts(filter: {accountTag: $accountId}) { - pagesFunctionsInvocationsAdaptiveGroups(limit: 1000, filter: $filter) { - sum { - requests - } - } - workersInvocationsAdaptive(limit: 10000, filter: $filter) { - sum { - requests - } - } - } - } - }`, - variables: { - accountId, - filter: { datetime_geq: startDateISO, datetime_leq: endDateISO } - }, - }); - - const headers = new Headers({ - 'Content-Type': 'application/json', - 'X-AUTH-EMAIL': email, - 'X-AUTH-KEY': key, - }); - - const response = await fetch(`https://api.cloudflare.com/client/v4/graphql`, { - method: 'POST', - headers: headers, - body: query - }); - - if (!response.ok) { - throw new Error(`HTTP error! status: ${response.status}`); - } - - const res = await response.json(); - - const pagesFunctionsInvocationsAdaptiveGroups = res?.data?.viewer?.accounts?.[accountIndex]?.pagesFunctionsInvocationsAdaptiveGroups; - const workersInvocationsAdaptive = res?.data?.viewer?.accounts?.[accountIndex]?.workersInvocationsAdaptive; - - if (!pagesFunctionsInvocationsAdaptiveGroups && !workersInvocationsAdaptive) { - throw new Error('找不到数据'); - } - - const pagesSum = pagesFunctionsInvocationsAdaptiveGroups.reduce((a, b) => a + b?.sum.requests, 0); - const workersSum = workersInvocationsAdaptive.reduce((a, b) => a + b?.sum.requests, 0); - - //console.log(`范围: ${startDateISO} ~ ${endDateISO}\n默认取第 ${accountIndex} 项`); - - return [pagesSum, workersSum ]; - } catch (error) { - return [ 0,0 ]; - } -} - -async function getAddressesapi(api) { - if (!api || api.length === 0) { - return []; - } - - let newapi = ""; - - // 创建一个AbortController对象，用于控制fetch请求的取消 - const controller = new AbortController(); - - const timeout = setTimeout(() => { - controller.abort(); // 取消所有请求 - }, 2000); // 2秒后触发 - - try { - // 使用Promise.allSettled等待所有API请求完成，无论成功或失败 - // 对api数组进行遍历，对每个API地址发起fetch请求 - const responses = await Promise.allSettled(api.map(apiUrl => fetch(apiUrl, { - method: 'get', - headers: { - 'Accept': 'text/html,application/xhtml+xml,application/xml;', - 'User-Agent': 'CF-Workers-edgetunnel/cmliu' - }, - signal: controller.signal // 将AbortController的信号量添加到fetch请求中，以便于需要时可以取消请求 - }).then(response => response.ok ? response.text() : Promise.reject()))); - - // 遍历所有响应 - for (const response of responses) { - // 检查响应状态是否为'fulfilled'，即请求成功完成 - if (response.status === 'fulfilled') { - // 获取响应的内容 - const content = await response.value; - newapi += content + '\n'; - } - } - } catch (error) { - console.error(error); - } finally { - // 无论成功或失败，最后都清除设置的超时定时器 - clearTimeout(timeout); - } - - const newAddressesapi = await ADD(newapi); - - // 返回处理后的结果 - return newAddressesapi; -} - -async function getAddressescsv(tls) { - if (!addressescsv || addressescsv.length === 0) { - return []; - } - - let newAddressescsv = []; - - for (const csvUrl of addressescsv) { - try { - const response = await fetch(csvUrl); - - if (!response.ok) { - console.error('获取CSV地址时出错:', response.status, response.statusText); - continue; - } - - const text = await response.text();// 使用正确的字符编码解析文本内容 - let lines; - if (text.includes('\r\n')){ - lines = text.split('\r\n'); - } else { - lines = text.split('\n'); - } - - // 检查CSV头部是否包含必需字段 - const header = lines[0].split(','); - const tlsIndex = header.indexOf('TLS'); - - const ipAddressIndex = 0;// IP地址在 CSV 头部的位置 - const portIndex = 1;// 端口在 CSV 头部的位置 - const dataCenterIndex = tlsIndex + 1; // 数据中心是 TLS 的后一个字段 - - if (tlsIndex === -1) { - console.error('CSV文件缺少必需的字段'); - continue; - } - - // 从第二行开始遍历CSV行 - for (let i = 1; i < lines.length; i++) { - const columns = lines[i].split(','); - const speedIndex = columns.length - 1; // 最后一个字段 - // 检查TLS是否为"TRUE"且速度大于DLS - if (columns[tlsIndex].toUpperCase() === tls && parseFloat(columns[speedIndex]) > DLS) { - const ipAddress = columns[ipAddressIndex]; - const port = columns[portIndex]; - const dataCenter = columns[dataCenterIndex]; - - const formattedAddress = `${ipAddress}:${port}#${dataCenter}`; - newAddressescsv.push(formattedAddress); - } - } - } catch (error) { - console.error('获取CSV地址时出错:', error); - continue; - } - } - - return newAddressescsv; -} - -function subAddresses(host,UUID,noTLS,newAddressesapi,newAddressescsv,newAddressesnotlsapi,newAddressesnotlscsv) { - const regex = /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[.*\]):?(\d+)?#?(.*)?$/; - addresses = addresses.concat(newAddressesapi); - addresses = addresses.concat(newAddressescsv); - let notlsresponseBody ; - if (noTLS == 'true'){ - addressesnotls = addressesnotls.concat(newAddressesnotlsapi); - addressesnotls = addressesnotls.concat(newAddressesnotlscsv); - const uniqueAddressesnotls = [...new Set(addressesnotls)]; - - notlsresponseBody = uniqueAddressesnotls.map(address => { - let port = "80"; - let addressid = address; - - const match = addressid.match(regex); - if (!match) { - if (address.includes(':') && address.includes('#')) { - const parts = address.split(':'); - address = parts[0]; - const subParts = parts[1].split('#'); - port = subParts[0]; - addressid = subParts[1]; - } else if (address.includes(':')) { - const parts = address.split(':'); - address = parts[0]; - port = parts[1]; - } else if (address.includes('#')) { - const parts = address.split('#'); - address = parts[0]; - addressid = parts[1]; - } - - if (addressid.includes(':')) { - addressid = addressid.split(':')[0]; - } - } else { - address = match[1]; - port = match[2] || port; - addressid = match[3] || address; - } - - const httpPorts = ["8080","8880","2052","2082","2086","2095"]; - if (!isValidIPv4(address) && port == "80") { - for (let httpPort of httpPorts) { - if (address.includes(httpPort)) { - port = httpPort; - break; - } - } - } - - let 伪装域名 = host ; - let 最终路径 = '/?ed=2560' ; - let 节点备注 = ''; - const 协议类型 = atob(啥啥啥_写的这是啥啊); - - const vlessLink = `${协议类型}://${UUID}@${address}:${port}?encryption=none&security=&type=ws&host=${伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`; - - return vlessLink; - - }).join('\n'); - - } - - // 使用Set对象去重 - const uniqueAddresses = [...new Set(addresses)]; - - const responseBody = uniqueAddresses.map(address => { - let port = "443"; - let addressid = address; - - const match = addressid.match(regex); - if (!match) { - if (address.includes(':') && address.includes('#')) { - const parts = address.split(':'); - address = parts[0]; - const subParts = parts[1].split('#'); - port = subParts[0]; - addressid = subParts[1]; - } else if (address.includes(':')) { - const parts = address.split(':'); - address = parts[0]; - port = parts[1]; - } else if (address.includes('#')) { - const parts = address.split('#'); - address = parts[0]; - addressid = parts[1]; - } - - if (addressid.includes(':')) { - addressid = addressid.split(':')[0]; - } - } else { - address = match[1]; - port = match[2] || port; - addressid = match[3] || address; - } - - const httpsPorts = ["2053","2083","2087","2096","8443"]; - if (!isValidIPv4(address) && port == "443") { - for (let httpsPort of httpsPorts) { - if (address.includes(httpsPort)) { - port = httpsPort; - break; - } - } - } - - let 伪装域名 = host ; - let 最终路径 = '/?ed=2560' ; - let 节点备注 = ''; - - if(proxyhosts.length > 0 && (伪装域名.includes('.workers.dev') || 伪装域名.includes('pages.dev'))) { - 最终路径 = `/${伪装域名}${最终路径}`; - 伪装域名 = proxyhosts[Math.floor(Math.random() * proxyhosts.length)]; - 节点备注 = ` 已启用临时域名中转服务，请尽快绑定自定义域！`; - } - - const 协议类型 = atob(啥啥啥_写的这是啥啊); - const vlessLink = `${协议类型}://${UUID}@${address}:${port}?encryption=none&security=tls&sni=${伪装域名}&fp=random&type=ws&host=${伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`; - - return vlessLink; - }).join('\n'); - - let base64Response = responseBody; // 重新进行 Base64 编码 - if(noTLS == 'true') base64Response += `\n${notlsresponseBody}`; - return btoa(base64Response); -} - -async function sendMessage(type, ip, add_data = "") { - if ( BotToken !== '' && ChatID !== ''){ - let msg = ""; - const response = await fetch(`http://ip-api.com/json/${ip}?lang=zh-CN`); - if (response.status == 200) { - const ipInfo = await response.json(); - msg = `${type}\nIP: ${ip}\n国家: ${ipInfo.country}\n城市: ${ipInfo.city}\n组织: ${ipInfo.org}\nASN: ${ipInfo.as}\n${add_data}`; - } else { - msg = `${type}\nIP: ${ip}\n${add_data}`; - } - - let url = "https://api.telegram.org/bot"+ BotToken +"/sendMessage?chat_id=" + ChatID + "&parse_mode=HTML&text=" + encodeURIComponent(msg); - return fetch(url, { - method: 'get', - headers: { - 'Accept': 'text/html,application/xhtml+xml,application/xml;', - 'Accept-Encoding': 'gzip, deflate, br', - 'User-Agent': 'Mozilla/5.0 Chrome/90.0.4430.72' - } - }); - } -} - -function isValidIPv4(address) { - const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/; - return ipv4Regex.test(address); -} +import { connect } from "cloudflare:sockets"; +let config_JSON, 反代IP = '', 启用SOCKS5反代 = null, 启用SOCKS5全局反代 = false, 我的SOCKS5账号 = '', parsedSocks5Address = {}; +let 缓存反代IP, 缓存反代解析数组, 缓存反代数组索引 = 0, 启用反代兜底 = true; +let SOCKS5白名单 = ['*tapecontent.net', '*cloudatacdn.com', '*loadshare.org', '*cdn-centaurus.com', 'scholar.google.com']; +const Pages静态页面 = 'https://edt-pages.github.io'; +///////////////////////////////////////////////////////主程序入口/////////////////////////////////////////////// +export default { + async fetch(request, env, ctx) { + const url = new URL(request.url); + const UA = request.headers.get('User-Agent') || 'null'; + const upgradeHeader = request.headers.get('Upgrade'); + const 管理员密码 = env.ADMIN || env.admin || env.PASSWORD || env.password || env.pswd || env.TOKEN || env.KEY || env.UUID || env.uuid; + const 加密秘钥 = env.KEY || '勿动此默认密钥，有需求请自行通过添加变量KEY进行修改'; + const userIDMD5 = await MD5MD5(管理员密码 + 加密秘钥); + const uuidRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/; + const envUUID = env.UUID || env.uuid; + const userID = (envUUID && uuidRegex.test(envUUID)) ? envUUID.toLowerCase() : [userIDMD5.slice(0, 8), userIDMD5.slice(8, 12), '4' + userIDMD5.slice(13, 16), '8' + userIDMD5.slice(17, 20), userIDMD5.slice(20)].join('-'); + const hosts = env.HOST ? (await 整理成数组(env.HOST)).map(h => h.toLowerCase().replace(/^https?:\/\//, '').split('/')[0].split(':')[0]) : [url.hostname]; + const host = hosts[0]; + if (env.PROXYIP) { + const proxyIPs = await 整理成数组(env.PROXYIP); + 反代IP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)]; + 启用反代兜底 = false; + } else 反代IP = (request.cf.colo + '.PrOxYIp.CmLiUsSsS.nEt').toLowerCase(); + const 访问IP = request.headers.get('X-Real-IP') || request.headers.get('CF-Connecting-IP') || request.headers.get('X-Forwarded-For') || request.headers.get('True-Client-IP') || request.headers.get('Fly-Client-IP') || request.headers.get('X-Appengine-Remote-Addr') || request.headers.get('X-Forwarded-For') || request.headers.get('X-Real-IP') || request.headers.get('X-Cluster-Client-IP') || request.cf?.clientTcpRtt || '未知IP'; + if (env.GO2SOCKS5) SOCKS5白名单 = await 整理成数组(env.GO2SOCKS5); + if (!upgradeHeader || upgradeHeader !== 'websocket') { + if (url.protocol === 'http:') return Response.redirect(url.href.replace(`http://${url.hostname}`, `https://${url.hostname}`), 301); + if (!管理员密码) return fetch(Pages静态页面 + '/noADMIN').then(r => { const headers = new Headers(r.headers); headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate'); headers.set('Pragma', 'no-cache'); headers.set('Expires', '0'); return new Response(r.body, { status: 404, statusText: r.statusText, headers }); }); + if (env.KV && typeof env.KV.get === 'function') { + const 访问路径 = url.pathname.slice(1).toLowerCase(); + const 区分大小写访问路径 = url.pathname.slice(1); + if (访问路径 === 加密秘钥 && 加密秘钥 !== '勿动此默认密钥，有需求请自行通过添加变量KEY进行修改') {//快速订阅 + const params = new URLSearchParams(url.search); + params.set('token', await MD5MD5(host + userID)); + return new Response('重定向中...', { status: 302, headers: { 'Location': `/sub?${params.toString()}` } }); + } else if (访问路径 === 'login') {//处理登录页面和登录请求 + const cookies = request.headers.get('Cookie') || ''; + const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))?.split('=')[1]; + if (authCookie == await MD5MD5(UA + 加密秘钥 + 管理员密码)) return new Response('重定向中...', { status: 302, headers: { 'Location': '/admin' } }); + if (request.method === 'POST') { + const formData = await request.text(); + const params = new URLSearchParams(formData); + const 输入密码 = params.get('password'); + if (输入密码 === 管理员密码) { + // 密码正确，设置cookie并返回成功标记 + const 响应 = new Response(JSON.stringify({ success: true }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + 响应.headers.set('Set-Cookie', `auth=${await MD5MD5(UA + 加密秘钥 + 管理员密码)}; Path=/; Max-Age=86400; HttpOnly`); + return 响应; + } + } + return fetch(Pages静态页面 + '/login'); + } else if (访问路径 === 'admin' || 访问路径.startsWith('admin/')) {//验证cookie后响应管理页面 + const cookies = request.headers.get('Cookie') || ''; + const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))?.split('=')[1]; + // 没有cookie或cookie错误，跳转到/login页面 + if (!authCookie || authCookie !== await MD5MD5(UA + 加密秘钥 + 管理员密码)) return new Response('重定向中...', { status: 302, headers: { 'Location': '/login' } }); + if (访问路径 === 'admin/log.json') {// 读取日志内容 + const 读取日志内容 = await env.KV.get('log.json') || '[]'; + return new Response(读取日志内容, { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } else if (区分大小写访问路径 === 'admin/getCloudflareUsage') {// 查询请求量 + try { + const Usage_JSON = await getCloudflareUsage(url.searchParams.get('Email'), url.searchParams.get('GlobalAPIKey'), url.searchParams.get('AccountID'), url.searchParams.get('APIToken')); + return new Response(JSON.stringify(Usage_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json' } }); + } catch (err) { + const errorResponse = { msg: '查询请求量失败，失败原因：' + err.message, error: err.message }; + return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else if (区分大小写访问路径 === 'admin/getADDAPI') {// 验证优选API + if (url.searchParams.get('url')) { + const 待验证优选URL = url.searchParams.get('url'); + try { + new URL(待验证优选URL); + const 请求优选API内容 = await 请求优选API([待验证优选URL], url.searchParams.get('port') || '443'); + const 优选API的IP = 请求优选API内容[0].length > 0 ? 请求优选API内容[0] : 请求优选API内容[1]; + return new Response(JSON.stringify({ success: true, data: 优选API的IP }, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (err) { + const errorResponse = { msg: '验证优选API失败，失败原因：' + err.message, error: err.message }; + return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } + return new Response(JSON.stringify({ success: false, data: [] }, null, 2), { status: 403, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } else if (访问路径 === 'admin/check') {// SOCKS5代理检查 + let 检测代理响应; + if (url.searchParams.has('socks5')) { + 检测代理响应 = await SOCKS5可用性验证('socks5', url.searchParams.get('socks5')); + } else if (url.searchParams.has('http')) { + 检测代理响应 = await SOCKS5可用性验证('http', url.searchParams.get('http')); + } else { + return new Response(JSON.stringify({ error: '缺少代理参数' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + return new Response(JSON.stringify(检测代理响应, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + + config_JSON = await 读取config_JSON(env, host, userID, env.PATH); + + if (访问路径 === 'admin/init') {// 重置配置为默认值 + try { + config_JSON = await 读取config_JSON(env, host, userID, env.PATH, true); + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Init_Config', config_JSON)); + config_JSON.init = '配置已重置为默认值'; + return new Response(JSON.stringify(config_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (err) { + const errorResponse = { msg: '配置重置失败，失败原因：' + err.message, error: err.message }; + return new Response(JSON.stringify(errorResponse, null, 2), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else if (request.method === 'POST') {// 处理 KV 操作（POST 请求） + if (访问路径 === 'admin/config.json') { // 保存config.json配置 + try { + const newConfig = await request.json(); + // 验证配置完整性 + if (!newConfig.UUID || !newConfig.HOST) return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + + // 保存到 KV + await env.KV.put('config.json', JSON.stringify(newConfig, null, 2)); + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON)); + return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (error) { + console.error('保存配置失败:', error); + return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else if (访问路径 === 'admin/cf.json') { // 保存cf.json配置 + try { + const newConfig = await request.json(); + const CF_JSON = { Email: null, GlobalAPIKey: null, AccountID: null, APIToken: null, UsageAPI: null }; + if (!newConfig.init || newConfig.init !== true) { + if (newConfig.Email && newConfig.GlobalAPIKey) { + CF_JSON.Email = newConfig.Email; + CF_JSON.GlobalAPIKey = newConfig.GlobalAPIKey; + } else if (newConfig.AccountID && newConfig.APIToken) { + CF_JSON.AccountID = newConfig.AccountID; + CF_JSON.APIToken = newConfig.APIToken; + } else if (newConfig.UsageAPI){ + CF_JSON.UsageAPI = newConfig.UsageAPI; + } else { + return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } + + // 保存到 KV + await env.KV.put('cf.json', JSON.stringify(CF_JSON, null, 2)); + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON)); + return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (error) { + console.error('保存配置失败:', error); + return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else if (访问路径 === 'admin/tg.json') { // 保存tg.json配置 + try { + const newConfig = await request.json(); + if (newConfig.init && newConfig.init === true) { + const TG_JSON = { BotToken: null, ChatID: null }; + await env.KV.put('tg.json', JSON.stringify(TG_JSON, null, 2)); + } else { + if (!newConfig.BotToken || !newConfig.ChatID) return new Response(JSON.stringify({ error: '配置不完整' }), { status: 400, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + await env.KV.put('tg.json', JSON.stringify(newConfig, null, 2)); + } + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Config', config_JSON)); + return new Response(JSON.stringify({ success: true, message: '配置已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (error) { + console.error('保存配置失败:', error); + return new Response(JSON.stringify({ error: '保存配置失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else if (区分大小写访问路径 === 'admin/ADD.txt') { // 保存自定义优选IP + try { + const customIPs = await request.text(); + await env.KV.put('ADD.txt', customIPs);// 保存到 KV + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Save_Custom_IPs', config_JSON)); + return new Response(JSON.stringify({ success: true, message: '自定义IP已保存' }), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } catch (error) { + console.error('保存自定义IP失败:', error); + return new Response(JSON.stringify({ error: '保存自定义IP失败: ' + error.message }), { status: 500, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + } else return new Response(JSON.stringify({ error: '不支持的POST请求路径' }), { status: 404, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } else if (访问路径 === 'admin/config.json') {// 处理 admin/config.json 请求，返回JSON + return new Response(JSON.stringify(config_JSON, null, 2), { status: 200, headers: { 'Content-Type': 'application/json' } }); + } else if (区分大小写访问路径 === 'admin/ADD.txt') {// 处理 admin/ADD.txt 请求，返回本地优选IP + let 本地优选IP = await env.KV.get('ADD.txt') || 'null'; + if (本地优选IP == 'null') 本地优选IP = (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[1]; + return new Response(本地优选IP, { status: 200, headers: { 'Content-Type': 'text/plain;charset=utf-8', 'asn': request.cf.asn } }); + } else if (访问路径 === 'admin/cf.json') {// CF配置文件 + return new Response(JSON.stringify(request.cf, null, 2), { status: 200, headers: { 'Content-Type': 'application/json;charset=utf-8' } }); + } + + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Admin_Login', config_JSON)); + return fetch(Pages静态页面 + '/admin'); + } else if (访问路径 === 'logout') {//清除cookie并跳转到登录页面 + const 响应 = new Response('重定向中...', { status: 302, headers: { 'Location': '/login' } }); + 响应.headers.set('Set-Cookie', 'auth=; Path=/; Max-Age=0; HttpOnly'); + return 响应; + } else if (访问路径 === 'sub') {//处理订阅请求 + const 订阅TOKEN = await MD5MD5(host + userID); + if (url.searchParams.get('token') === 订阅TOKEN) { + config_JSON = await 读取config_JSON(env, host, userID, env.PATH); + ctx.waitUntil(请求日志记录(env, request, 访问IP, 'Get_SUB', config_JSON)); + const ua = UA.toLowerCase(); + const expire = 4102329600;//2099-12-31 到期时间 + const now = Date.now(); + const today = new Date(now); + today.setHours(0, 0, 0, 0); + const UD = Math.floor(((now - today.getTime()) / 86400000) * 24 * 1099511627776 / 2); + let pagesSum = UD, workersSum = UD, total = 24 * 1099511627776; + if (config_JSON.CF.Usage.success) { + pagesSum = config_JSON.CF.Usage.pages; + workersSum = config_JSON.CF.Usage.workers; + total = Number.isFinite(config_JSON.CF.Usage.max) ? (config_JSON.CF.Usage.max / 1000) * 1024 : 1024 * 100; + } + const responseHeaders = { + "content-type": "text/plain; charset=utf-8", + "Profile-Update-Interval": config_JSON.优选订阅生成.SUBUpdateTime, + "Profile-web-page-url": url.protocol + '//' + url.host + '/admin', + "Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`, + "Cache-Control": "no-store", + }; + const isSubConverterRequest = url.searchParams.has('b64') || url.searchParams.has('base64') || request.headers.get('subconverter-request') || request.headers.get('subconverter-version') || ua.includes('subconverter') || ua.includes(('CF-Workers-SUB').toLowerCase()); + const 订阅类型 = isSubConverterRequest + ? 'mixed' + : url.searchParams.has('target') + ? url.searchParams.get('target') + : url.searchParams.has('clash') || ua.includes('clash') || ua.includes('meta') || ua.includes('mihomo') + ? 'clash' + : url.searchParams.has('sb') || url.searchParams.has('singbox') || ua.includes('singbox') || ua.includes('sing-box') + ? 'singbox' + : url.searchParams.has('surge') || ua.includes('surge') + ? 'surge&ver=4' + : url.searchParams.has('quanx') || ua.includes('quantumult') + ? 'quanx' + : url.searchParams.has('loon') || ua.includes('loon') + ? 'loon' + : 'mixed'; + + if (!ua.includes('mozilla')) responseHeaders["Content-Disposition"] = `attachment; filename*=utf-8''${encodeURIComponent(config_JSON.优选订阅生成.SUBNAME)}`; + const 协议类型 = (url.searchParams.has('surge') || ua.includes('surge')) ? 'tro' + 'jan' : config_JSON.协议类型; + let 订阅内容 = ''; + if (订阅类型 === 'mixed') { + const 节点路径 = config_JSON.启用0RTT ? config_JSON.PATH + '?ed=2560' : config_JSON.PATH; + const TLS分片参数 = config_JSON.TLS分片 == 'Shadowrocket' ? `&fragment=${encodeURIComponent('1,40-60,30-50,tlshello')}` : config_JSON.TLS分片 == 'Happ' ? `&fragment=${encodeURIComponent('3,1,tlshello')}` : ''; + let 完整优选IP = [], 其他节点LINK = ''; + + if (!url.searchParams.has('sub') && config_JSON.优选订阅生成.local) { // 本地生成订阅 + const 完整优选列表 = config_JSON.优选订阅生成.本地IP库.随机IP ? (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[0] : await env.KV.get('ADD.txt') ? await 整理成数组(await env.KV.get('ADD.txt')) : (await 生成随机IP(request, config_JSON.优选订阅生成.本地IP库.随机数量, config_JSON.优选订阅生成.本地IP库.指定端口))[0]; + const 优选API = [], 优选IP = [], 其他节点 = []; + for (const 元素 of 完整优选列表) { + if (元素.toLowerCase().startsWith('https://')) 优选API.push(元素); + else if (元素.toLowerCase().includes('://')) { + if (元素.includes('#')) { + const 地址备注分离 = 元素.split('#'); + 其他节点.push(地址备注分离[0] + '#' + encodeURIComponent(decodeURIComponent(地址备注分离[1]))); + } else 其他节点.push(元素); + } else 优选IP.push(元素); + } + const 请求优选API内容 = await 请求优选API(优选API); + const 合并其他节点数组 = [...new Set(其他节点.concat(请求优选API内容[1]))]; + 其他节点LINK = 合并其他节点数组.length > 0 ? 合并其他节点数组.join('\n') + '\n' : ''; + const 优选API的IP = 请求优选API内容[0]; + 完整优选IP = [...new Set(优选IP.concat(优选API的IP))]; + } else { // 优选订阅生成器 + let 优选订阅生成器HOST = url.searchParams.get('sub') || config_JSON.优选订阅生成.SUB; + 优选订阅生成器HOST = 优选订阅生成器HOST && !/^https?:\/\//i.test(优选订阅生成器HOST) ? `https://${优选订阅生成器HOST}` : 优选订阅生成器HOST; + const 优选订阅生成器URL = `${优选订阅生成器HOST}/sub?host=example.com&uuid=00000000-0000-4000-8000-000000000000`; + try { + const response = await fetch(优选订阅生成器URL, { headers: { 'User-Agent': 'v2rayN/edge' + 'tunnel (https://github.com/cmliu/edge' + 'tunnel)' } }); + if (!response.ok) return new Response('优选订阅生成器异常：' + response.statusText, { status: response.status }); + const 优选订阅生成器返回订阅内容 = atob(await response.text()); + const 订阅行列表 = 优选订阅生成器返回订阅内容.includes('\r\n') ? 优选订阅生成器返回订阅内容.split('\r\n') : 优选订阅生成器返回订阅内容.split('\n'); + for (const 行内容 of 订阅行列表) { + if (!行内容.trim()) continue; // 跳过空行 + if (行内容.includes('00000000-0000-4000-8000-000000000000') && 行内容.includes('example.com')) { // 这是优选IP行，提取 域名:端口#备注 + const 地址匹配 = 行内容.match(/:\/\/[^@]+@([^?]+)/); + if (地址匹配) { + let 地址端口 = 地址匹配[1], 备注 = ''; // 域名:端口 或 IP:端口 + const 备注匹配 = 行内容.match(/#(.+)$/); + if (备注匹配) 备注 = '#' + decodeURIComponent(备注匹配[1]); + 完整优选IP.push(地址端口 + 备注); + } + } else 其他节点LINK += 行内容 + '\n'; + } + } catch (error) { + return new Response('优选订阅生成器异常：' + error.message, { status: 403 }); + } + } + + 订阅内容 = 其他节点LINK + 完整优选IP.map(原始地址 => { + // 统一正则: 匹配 域名/IPv4/IPv6地址 + 可选端口 + 可选备注 + // 示例: + // - 域名: hj.xmm1993.top:2096#备注 或 example.com + // - IPv4: 166.0.188.128:443#Los Angeles 或 166.0.188.128 + // - IPv6: [2606:4700::]:443#CMCC 或 [2606:4700::] + const regex = /^(\[[\da-fA-F:]+\]|[\d.]+|[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*)(?::(\d+))?(?:#(.+))?$/; + const match = 原始地址.match(regex); + + let 节点地址, 节点端口 = "443", 节点备注; + + if (match) { + 节点地址 = match[1]; // IP地址或域名(可能带方括号) + 节点端口 = match[2] || "443"; // 端口,默认443 + 节点备注 = match[3] || 节点地址; // 备注,默认为地址本身 + } else { + // 不规范的格式，跳过处理返回null + console.warn(`[订阅内容] 不规范的IP格式已忽略: ${原始地址}`); + return null; + } + + return `${协议类型}://00000000-0000-4000-8000-000000000000@${节点地址}:${节点端口}?security=tls&type=${config_JSON.传输协议}&host=example.com&sni=example.com&path=${encodeURIComponent(config_JSON.随机路径 ? 随机路径() + 节点路径 : 节点路径) + TLS分片参数}&encryption=none${config_JSON.跳过证书验证 ? '&allowInsecure=1' : ''}#${encodeURIComponent(节点备注)}`; + }).filter(item => item !== null).join('\n'); + } else { // 订阅转换 + const 订阅转换URL = `${config_JSON.订阅转换配置.SUBAPI}/sub?target=${订阅类型}&url=${encodeURIComponent(url.protocol + '//' + url.host + '/sub?target=mixed&token=' + 订阅TOKEN + (url.searchParams.has('sub') && url.searchParams.get('sub') != '' ? `&sub=${url.searchParams.get('sub')}` : ''))}&config=${encodeURIComponent(config_JSON.订阅转换配置.SUBCONFIG)}&emoji=${config_JSON.订阅转换配置.SUBEMOJI}&scv=${config_JSON.跳过证书验证}`; + try { + const response = await fetch(订阅转换URL, { headers: { 'User-Agent': 'Subconverter for ' + 订阅类型 + ' edge' + 'tunnel(https://github.com/cmliu/edge' + 'tunnel)' } }); + if (response.ok) { + 订阅内容 = await response.text(); + if (url.searchParams.has('surge') || ua.includes('surge')) 订阅内容 = Surge订阅配置文件热补丁(订阅内容, url.protocol + '//' + url.host + '/sub?token=' + 订阅TOKEN + '&surge', config_JSON); + } else return new Response('订阅转换后端异常：' + response.statusText, { status: response.status }); + } catch (error) { + return new Response('订阅转换后端异常：' + error.message, { status: 403 }); + } + } + + if (!ua.includes('subconverter')) 订阅内容 = 批量替换域名(订阅内容.replace(/00000000-0000-4000-8000-000000000000/g, config_JSON.UUID), config_JSON.HOSTS) + + if (订阅类型 === 'mixed' && (!ua.includes('mozilla') || url.searchParams.has('b64') || url.searchParams.has('base64'))) 订阅内容 = btoa(订阅内容); + + if (订阅类型 === 'singbox') { + 订阅内容 = Singbox订阅配置文件热补丁(订阅内容); + responseHeaders["content-type"] = 'application/json; charset=utf-8'; + } else if (订阅类型 === 'clash') { + responseHeaders["content-type"] = 'application/x-yaml; charset=utf-8'; + } + return new Response(订阅内容, { status: 200, headers: responseHeaders }); + } + } else if (访问路径 === 'locations') {//反代locations列表 + const cookies = request.headers.get('Cookie') || ''; + const authCookie = cookies.split(';').find(c => c.trim().startsWith('auth='))?.split('=')[1]; + if (authCookie && authCookie == await MD5MD5(UA + 加密秘钥 + 管理员密码)) return fetch(new Request('https://speed.cloudflare.com/locations', { headers: { 'Referer': 'https://speed.cloudflare.com/' } })); + } else if (访问路径 === 'robots.txt') return new Response('User-agent: *\nDisallow: /', { status: 200, headers: { 'Content-Type': 'text/plain; charset=UTF-8' } }); + } else if (!envUUID) return fetch(Pages静态页面 + '/noKV').then(r => { const headers = new Headers(r.headers); headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate'); headers.set('Pragma', 'no-cache'); headers.set('Expires', '0'); return new Response(r.body, { status: 404, statusText: r.statusText, headers }); }); + } else if (管理员密码) {// ws代理 + await 反代参数获取(request); + return await 处理WS请求(request, userID); + } + + let 伪装页URL = env.URL || 'nginx'; + if (伪装页URL && 伪装页URL !== 'nginx' && 伪装页URL !== '1101') { + 伪装页URL = 伪装页URL.trim().replace(/\/$/, ''); + if (!伪装页URL.match(/^https?:\/\//i)) 伪装页URL = 'https://' + 伪装页URL; + if (伪装页URL.toLowerCase().startsWith('http://')) 伪装页URL = 'https://' + 伪装页URL.substring(7); + try { const u = new URL(伪装页URL); 伪装页URL = u.protocol + '//' + u.host; } catch (e) { 伪装页URL = 'nginx'; } + } + if (伪装页URL === '1101') return new Response(await html1101(url.host, 访问IP), { status: 200, headers: { 'Content-Type': 'text/html; charset=UTF-8' } }); + try { + const 反代URL = new URL(伪装页URL), 新请求头 = new Headers(request.headers); + 新请求头.set('Host', 反代URL.host); + 新请求头.set('Referer', 反代URL.origin); + 新请求头.set('Origin', 反代URL.origin); + if (!新请求头.has('User-Agent') && UA && UA !== 'null') 新请求头.set('User-Agent', UA); + const 反代响应 = await fetch(反代URL.origin + url.pathname + url.search, { method: request.method, headers: 新请求头, body: request.body, cf: request.cf }); + const 内容类型 = 反代响应.headers.get('content-type') || ''; + // 只处理文本类型的响应 + if (/text|javascript|json|xml/.test(内容类型)) { + const 响应内容 = (await 反代响应.text()).replaceAll(反代URL.host, url.host); + return new Response(响应内容, { status: 反代响应.status, headers: { ...Object.fromEntries(反代响应.headers), 'Cache-Control': 'no-store' } }); + } + return 反代响应; + } catch (error) { } + return new Response(await nginx(), { status: 200, headers: { 'Content-Type': 'text/html; charset=UTF-8' } }); + } +}; +///////////////////////////////////////////////////////////////////////WS传输数据/////////////////////////////////////////////// +async function 处理WS请求(request, yourUUID) { + const wssPair = new WebSocketPair(); + const [clientSock, serverSock] = Object.values(wssPair); + serverSock.accept(); + let remoteConnWrapper = { socket: null }; + let isDnsQuery = false; + const earlyData = request.headers.get('sec-websocket-protocol') || ''; + const readable = makeReadableStr(serverSock, earlyData); + let 判断是否是木马 = null; + readable.pipeTo(new WritableStream({ + async write(chunk) { + if (isDnsQuery) return await forwardataudp(chunk, serverSock, null); + if (remoteConnWrapper.socket) { + const writer = remoteConnWrapper.socket.writable.getWriter(); + await writer.write(chunk); + writer.releaseLock(); + return; + } + + if (判断是否是木马 === null) { + const bytes = new Uint8Array(chunk); + 判断是否是木马 = bytes.byteLength >= 58 && bytes[56] === 0x0d && bytes[57] === 0x0a; + } + + if (remoteConnWrapper.socket) { + const writer = remoteConnWrapper.socket.writable.getWriter(); + await writer.write(chunk); + writer.releaseLock(); + return; + } + + if (判断是否是木马) { + const { port, hostname, rawClientData } = 解析木马请求(chunk, yourUUID); + if (isSpeedTestSite(hostname)) throw new Error('Speedtest site is blocked'); + await forwardataTCP(hostname, port, rawClientData, serverSock, null, remoteConnWrapper, yourUUID); + } else { + const { port, hostname, rawIndex, version, isUDP } = 解析魏烈思请求(chunk, yourUUID); + if (isSpeedTestSite(hostname)) throw new Error('Speedtest site is blocked'); + if (isUDP) { + if (port === 53) isDnsQuery = true; + else throw new Error('UDP is not supported'); + } + const respHeader = new Uint8Array([version[0], 0]); + const rawData = chunk.slice(rawIndex); + if (isDnsQuery) return forwardataudp(rawData, serverSock, respHeader); + await forwardataTCP(hostname, port, rawData, serverSock, respHeader, remoteConnWrapper, yourUUID); + } + }, + })).catch((err) => { + // console.error('Readable pipe error:', err); + }); + + return new Response(null, { status: 101, webSocket: clientSock }); +} + +function 解析木马请求(buffer, passwordPlainText) { + const sha224Password = sha224(passwordPlainText); + if (buffer.byteLength < 56) return { hasError: true, message: "invalid data" }; + let crLfIndex = 56; + if (new Uint8Array(buffer.slice(56, 57))[0] !== 0x0d || new Uint8Array(buffer.slice(57, 58))[0] !== 0x0a) return { hasError: true, message: "invalid header format" }; + const password = new TextDecoder().decode(buffer.slice(0, crLfIndex)); + if (password !== sha224Password) return { hasError: true, message: "invalid password" }; + + const socks5DataBuffer = buffer.slice(crLfIndex + 2); + if (socks5DataBuffer.byteLength < 6) return { hasError: true, message: "invalid S5 request data" }; + + const view = new DataView(socks5DataBuffer); + const cmd = view.getUint8(0); + if (cmd !== 1) return { hasError: true, message: "unsupported command, only TCP is allowed" }; + + const atype = view.getUint8(1); + let addressLength = 0; + let addressIndex = 2; + let address = ""; + switch (atype) { + case 1: // IPv4 + addressLength = 4; + address = new Uint8Array(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)).join("."); + break; + case 3: // Domain + addressLength = new Uint8Array(socks5DataBuffer.slice(addressIndex, addressIndex + 1))[0]; + addressIndex += 1; + address = new TextDecoder().decode(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)); + break; + case 4: // IPv6 + addressLength = 16; + const dataView = new DataView(socks5DataBuffer.slice(addressIndex, addressIndex + addressLength)); + const ipv6 = []; + for (let i = 0; i < 8; i++) { + ipv6.push(dataView.getUint16(i * 2).toString(16)); + } + address = ipv6.join(":"); + break; + default: + return { hasError: true, message: `invalid addressType is ${atype}` }; + } + + if (!address) { + return { hasError: true, message: `address is empty, addressType is ${atype}` }; + } + + const portIndex = addressIndex + addressLength; + const portBuffer = socks5DataBuffer.slice(portIndex, portIndex + 2); + const portRemote = new DataView(portBuffer).getUint16(0); + + return { + hasError: false, + addressType: atype, + port: portRemote, + hostname: address, + rawClientData: socks5DataBuffer.slice(portIndex + 4) + }; +} + +function 解析魏烈思请求(chunk, token) { + if (chunk.byteLength < 24) return { hasError: true, message: 'Invalid data' }; + const version = new Uint8Array(chunk.slice(0, 1)); + if (formatIdentifier(new Uint8Array(chunk.slice(1, 17))) !== token) return { hasError: true, message: 'Invalid uuid' }; + const optLen = new Uint8Array(chunk.slice(17, 18))[0]; + const cmd = new Uint8Array(chunk.slice(18 + optLen, 19 + optLen))[0]; + let isUDP = false; + if (cmd === 1) { } else if (cmd === 2) { isUDP = true; } else { return { hasError: true, message: 'Invalid command' }; } + const portIdx = 19 + optLen; + const port = new DataView(chunk.slice(portIdx, portIdx + 2)).getUint16(0); + let addrIdx = portIdx + 2, addrLen = 0, addrValIdx = addrIdx + 1, hostname = ''; + const addressType = new Uint8Array(chunk.slice(addrIdx, addrValIdx))[0]; + switch (addressType) { + case 1: + addrLen = 4; + hostname = new Uint8Array(chunk.slice(addrValIdx, addrValIdx + addrLen)).join('.'); + break; + case 2: + addrLen = new Uint8Array(chunk.slice(addrValIdx, addrValIdx + 1))[0]; + addrValIdx += 1; + hostname = new TextDecoder().decode(chunk.slice(addrValIdx, addrValIdx + addrLen)); + break; + case 3: + addrLen = 16; + const ipv6 = []; + const ipv6View = new DataView(chunk.slice(addrValIdx, addrValIdx + addrLen)); + for (let i = 0; i < 8; i++) ipv6.push(ipv6View.getUint16(i * 2).toString(16)); + hostname = ipv6.join(':'); + break; + default: + return { hasError: true, message: `Invalid address type: ${addressType}` }; + } + if (!hostname) return { hasError: true, message: `Invalid address: ${addressType}` }; + return { hasError: false, addressType, port, hostname, isUDP, rawIndex: addrValIdx + addrLen, version }; +} +async function forwardataTCP(host, portNum, rawData, ws, respHeader, remoteConnWrapper, yourUUID) { + console.log(`[TCP转发] 目标: ${host}:${portNum} | 反代IP: ${反代IP} | 反代兜底: ${启用反代兜底 ? '是' : '否'} | 反代类型: ${启用SOCKS5反代 || 'proxyip'} | 全局: ${启用SOCKS5全局反代 ? '是' : '否'}`); + + async function connectDirect(address, port, data, 所有反代数组 = null, 反代兜底 = true) { + let remoteSock; + if (所有反代数组 && 所有反代数组.length > 0) { + for (let i = 0; i < 所有反代数组.length; i++) { + const 反代数组索引 = (缓存反代数组索引 + i) % 所有反代数组.length; + const [反代地址, 反代端口] = 所有反代数组[反代数组索引]; + try { + console.log(`[反代连接] 尝试连接到: ${反代地址}:${反代端口} (索引: ${反代数组索引})`); + remoteSock = connect({ hostname: 反代地址, port: 反代端口 }); + // 等待TCP连接真正建立，设置1秒超时 + await Promise.race([ + remoteSock.opened, + new Promise((_, reject) => setTimeout(() => reject(new Error('连接超时')), 1000)) + ]); + const testWriter = remoteSock.writable.getWriter(); + await testWriter.write(data); + testWriter.releaseLock(); + console.log(`[反代连接] 成功连接到: ${反代地址}:${反代端口}`); + 缓存反代数组索引 = 反代数组索引; + return remoteSock; + } catch (err) { + console.log(`[反代连接] 连接失败: ${反代地址}:${反代端口}, 错误: ${err.message}`); + try { remoteSock?.close?.(); } catch (e) { } + continue; + } + } + } + + if (反代兜底) { + remoteSock = connect({ hostname: address, port: port }); + const writer = remoteSock.writable.getWriter(); + await writer.write(data); + writer.releaseLock(); + return remoteSock; + } else { + closeSocketQuietly(ws); + throw new Error('[反代连接] 所有反代连接失败，且未启用反代兜底，连接终止。'); + } + } + + async function connecttoPry() { + let newSocket; + if (启用SOCKS5反代 === 'socks5') { + console.log(`[SOCKS5代理] 代理到: ${host}:${portNum}`); + newSocket = await socks5Connect(host, portNum, rawData); + } else if (启用SOCKS5反代 === 'http' || 启用SOCKS5反代 === 'https') { + console.log(`[HTTP代理] 代理到: ${host}:${portNum}`); + newSocket = await httpConnect(host, portNum, rawData); + } else { + console.log(`[反代连接] 代理到: ${host}:${portNum}`); + const 所有反代数组 = await 解析地址端口(反代IP, host, yourUUID); + newSocket = await connectDirect(atob('UFJPWFlJUC50cDEuMDkwMjI3Lnh5eg=='), 1, rawData, 所有反代数组, 启用反代兜底); + } + remoteConnWrapper.socket = newSocket; + newSocket.closed.catch(() => { }).finally(() => closeSocketQuietly(ws)); + connectStreams(newSocket, ws, respHeader, null); + } + + const 验证SOCKS5白名单 = (addr) => SOCKS5白名单.some(p => new RegExp(`^${p.replace(/\*/g, '.*')}$`, 'i').test(addr)); + if (启用SOCKS5反代 && (启用SOCKS5全局反代 || 验证SOCKS5白名单(host))) { + console.log(`[TCP转发] 启用 SOCKS5/HTTP 全局代理`); + try { + await connecttoPry(); + } catch (err) { + throw err; + } + } else { + try { + console.log(`[TCP转发] 尝试直连到: ${host}:${portNum}`); + const initialSocket = await connectDirect(host, portNum, rawData); + remoteConnWrapper.socket = initialSocket; + connectStreams(initialSocket, ws, respHeader, connecttoPry); + } catch (err) { + await connecttoPry(); + } + } +} + +async function forwardataudp(udpChunk, webSocket, respHeader) { + try { + const tcpSocket = connect({ hostname: '8.8.4.4', port: 53 }); + let vlessHeader = respHeader; + const writer = tcpSocket.writable.getWriter(); + await writer.write(udpChunk); + writer.releaseLock(); + await tcpSocket.readable.pipeTo(new WritableStream({ + async write(chunk) { + if (webSocket.readyState === WebSocket.OPEN) { + if (vlessHeader) { + const response = new Uint8Array(vlessHeader.length + chunk.byteLength); + response.set(vlessHeader, 0); + response.set(chunk, vlessHeader.length); + webSocket.send(response.buffer); + vlessHeader = null; + } else { + webSocket.send(chunk); + } + } + }, + })); + } catch (error) { + // console.error('UDP forward error:', error); + } +} + +function closeSocketQuietly(socket) { + try { + if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CLOSING) { + socket.close(); + } + } catch (error) { } +} + +function formatIdentifier(arr, offset = 0) { + const hex = [...arr.slice(offset, offset + 16)].map(b => b.toString(16).padStart(2, '0')).join(''); + return `${hex.substring(0, 8)}-${hex.substring(8, 12)}-${hex.substring(12, 16)}-${hex.substring(16, 20)}-${hex.substring(20)}`; +} +async function connectStreams(remoteSocket, webSocket, headerData, retryFunc) { + let header = headerData, hasData = false; + await remoteSocket.readable.pipeTo( + new WritableStream({ + async write(chunk, controller) { + hasData = true; + if (webSocket.readyState !== WebSocket.OPEN) controller.error('ws.readyState is not open'); + if (header) { + const response = new Uint8Array(header.length + chunk.byteLength); + response.set(header, 0); + response.set(chunk, header.length); + webSocket.send(response.buffer); + header = null; + } else { + webSocket.send(chunk); + } + }, + abort() { }, + }) + ).catch((err) => { + closeSocketQuietly(webSocket); + }); + if (!hasData && retryFunc) { + await retryFunc(); + } +} + +function makeReadableStr(socket, earlyDataHeader) { + let cancelled = false; + return new ReadableStream({ + start(controller) { + socket.addEventListener('message', (event) => { + if (!cancelled) controller.enqueue(event.data); + }); + socket.addEventListener('close', () => { + if (!cancelled) { + closeSocketQuietly(socket); + controller.close(); + } + }); + socket.addEventListener('error', (err) => controller.error(err)); + const { earlyData, error } = base64ToArray(earlyDataHeader); + if (error) controller.error(error); + else if (earlyData) controller.enqueue(earlyData); + }, + cancel() { + cancelled = true; + closeSocketQuietly(socket); + } + }); +} + +function isSpeedTestSite(hostname) { + const speedTestDomains = [atob('c3BlZWQuY2xvdWRmbGFyZS5jb20=')]; + if (speedTestDomains.includes(hostname)) { + return true; + } + + for (const domain of speedTestDomains) { + if (hostname.endsWith('.' + domain) || hostname === domain) { + return true; + } + } + return false; +} + +function base64ToArray(b64Str) { + if (!b64Str) return { error: null }; + try { + const binaryString = atob(b64Str.replace(/-/g, '+').replace(/_/g, '/')); + const bytes = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return { earlyData: bytes.buffer, error: null }; + } catch (error) { + return { error }; + } +} +////////////////////////////////SOCKS5/HTTP函数/////////////////////////////////////////////// +async function socks5Connect(targetHost, targetPort, initialData) { + const { username, password, hostname, port } = parsedSocks5Address; + const socket = connect({ hostname, port }), writer = socket.writable.getWriter(), reader = socket.readable.getReader(); + try { + const authMethods = username && password ? new Uint8Array([0x05, 0x02, 0x00, 0x02]) : new Uint8Array([0x05, 0x01, 0x00]); + await writer.write(authMethods); + let response = await reader.read(); + if (response.done || response.value.byteLength < 2) throw new Error('S5 method selection failed'); + + const selectedMethod = new Uint8Array(response.value)[1]; + if (selectedMethod === 0x02) { + if (!username || !password) throw new Error('S5 requires authentication'); + const userBytes = new TextEncoder().encode(username), passBytes = new TextEncoder().encode(password); + const authPacket = new Uint8Array([0x01, userBytes.length, ...userBytes, passBytes.length, ...passBytes]); + await writer.write(authPacket); + response = await reader.read(); + if (response.done || new Uint8Array(response.value)[1] !== 0x00) throw new Error('S5 authentication failed'); + } else if (selectedMethod !== 0x00) throw new Error(`S5 unsupported auth method: ${selectedMethod}`); + + const hostBytes = new TextEncoder().encode(targetHost); + const connectPacket = new Uint8Array([0x05, 0x01, 0x00, 0x03, hostBytes.length, ...hostBytes, targetPort >> 8, targetPort & 0xff]); + await writer.write(connectPacket); + response = await reader.read(); + if (response.done || new Uint8Array(response.value)[1] !== 0x00) throw new Error('S5 connection failed'); + + await writer.write(initialData); + writer.releaseLock(); reader.releaseLock(); + return socket; + } catch (error) { + try { writer.releaseLock(); } catch (e) { } + try { reader.releaseLock(); } catch (e) { } + try { socket.close(); } catch (e) { } + throw error; + } +} + +async function httpConnect(targetHost, targetPort, initialData) { + const { username, password, hostname, port } = parsedSocks5Address; + const socket = connect({ hostname, port }), writer = socket.writable.getWriter(), reader = socket.readable.getReader(); + try { + const auth = username && password ? `Proxy-Authorization: Basic ${btoa(`${username}:${password}`)}\r\n` : ''; + const request = `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\nHost: ${targetHost}:${targetPort}\r\n${auth}User-Agent: Mozilla/5.0\r\nConnection: keep-alive\r\n\r\n`; + await writer.write(new TextEncoder().encode(request)); + + let responseBuffer = new Uint8Array(0), headerEndIndex = -1, bytesRead = 0; + while (headerEndIndex === -1 && bytesRead < 8192) { + const { done, value } = await reader.read(); + if (done) throw new Error('Connection closed before receiving HTTP response'); + responseBuffer = new Uint8Array([...responseBuffer, ...value]); + bytesRead = responseBuffer.length; + const crlfcrlf = responseBuffer.findIndex((_, i) => i < responseBuffer.length - 3 && responseBuffer[i] === 0x0d && responseBuffer[i + 1] === 0x0a && responseBuffer[i + 2] === 0x0d && responseBuffer[i + 3] === 0x0a); + if (crlfcrlf !== -1) headerEndIndex = crlfcrlf + 4; + } + + if (headerEndIndex === -1) throw new Error('Invalid HTTP response'); + const statusCode = parseInt(new TextDecoder().decode(responseBuffer.slice(0, headerEndIndex)).split('\r\n')[0].match(/HTTP\/\d\.\d\s+(\d+)/)[1]); + if (statusCode < 200 || statusCode >= 300) throw new Error(`Connection failed: HTTP ${statusCode}`); + + await writer.write(initialData); + writer.releaseLock(); reader.releaseLock(); + return socket; + } catch (error) { + try { writer.releaseLock(); } catch (e) { } + try { reader.releaseLock(); } catch (e) { } + try { socket.close(); } catch (e) { } + throw error; + } +} +//////////////////////////////////////////////////功能性函数/////////////////////////////////////////////// +function Singbox订阅配置文件热补丁(sb_json_text) { + try { + let config = JSON.parse(sb_json_text); + + // --- 1. TUN 入站迁移 (1.10.0+) --- + if (Array.isArray(config.inbounds)) { + config.inbounds.forEach(inbound => { + if (inbound.type === 'tun') { + const addresses = []; + if (inbound.inet4_address) addresses.push(inbound.inet4_address); + if (inbound.inet6_address) addresses.push(inbound.inet6_address); + if (addresses.length > 0) { + inbound.address = addresses; + delete inbound.inet4_address; + delete inbound.inet6_address; + } + + const route_addresses = []; + if (Array.isArray(inbound.inet4_route_address)) route_addresses.push(...inbound.inet4_route_address); + if (Array.isArray(inbound.inet6_route_address)) route_addresses.push(...inbound.inet6_route_address); + if (route_addresses.length > 0) { + inbound.route_address = route_addresses; + delete inbound.inet4_route_address; + delete inbound.inet6_route_address; + } + + const route_exclude_addresses = []; + if (Array.isArray(inbound.inet4_route_exclude_address)) route_exclude_addresses.push(...inbound.inet4_route_exclude_address); + if (Array.isArray(inbound.inet6_route_exclude_address)) route_exclude_addresses.push(...inbound.inet6_route_exclude_address); + if (route_exclude_addresses.length > 0) { + inbound.route_exclude_address = route_exclude_addresses; + delete inbound.inet4_route_exclude_address; + delete inbound.inet6_route_exclude_address; + } + } + }); + } + + // --- 2. 迁移 Geosite/GeoIP 到 rule_set (1.8.0+) 及 Actions (1.11.0+) --- + const ruleSetsDefinitions = new Map(); + const processRules = (rules, isDns = false) => { + if (!Array.isArray(rules)) return; + rules.forEach(rule => { + if (rule.geosite) { + const geositeList = Array.isArray(rule.geosite) ? rule.geosite : [rule.geosite]; + rule.rule_set = geositeList.map(name => { + const tag = `geosite-${name}`; + if (!ruleSetsDefinitions.has(tag)) { + ruleSetsDefinitions.set(tag, { + tag: tag, + type: "remote", + format: "binary", + url: `https://gh.090227.xyz/https://raw.githubusercontent.com/SagerNet/sing-geosite/rule-set/geosite-${name}.srs`, + download_detour: "DIRECT" + }); + } + return tag; + }); + delete rule.geosite; + } + if (rule.geoip) { + const geoipList = Array.isArray(rule.geoip) ? rule.geoip : [rule.geoip]; + rule.rule_set = rule.rule_set || []; + geoipList.forEach(name => { + const tag = `geoip-${name}`; + if (!ruleSetsDefinitions.has(tag)) { + ruleSetsDefinitions.set(tag, { + tag: tag, + type: "remote", + format: "binary", + url: `https://gh.090227.xyz/https://raw.githubusercontent.com/SagerNet/sing-geoip/rule-set/geoip-${name}.srs`, + download_detour: "DIRECT" + }); + } + rule.rule_set.push(tag); + }); + delete rule.geoip; + } + const targetField = isDns ? 'server' : 'outbound'; + const actionValue = String(rule[targetField]).toUpperCase(); + if (actionValue === 'REJECT' || actionValue === 'BLOCK') { + rule.action = 'reject'; + rule.method = 'drop'; // 强制使用现代方式 + delete rule[targetField]; + } + }); + }; + + if (config.dns && config.dns.rules) processRules(config.dns.rules, true); + if (config.route && config.route.rules) processRules(config.route.rules, false); + + if (ruleSetsDefinitions.size > 0) { + if (!config.route) config.route = {}; + config.route.rule_set = Array.from(ruleSetsDefinitions.values()); + } + + // --- 3. 兼容性与纠错 --- + if (!config.outbounds) config.outbounds = []; + + // 移除 outbounds 中冗余的 block 类型节点 (如果它们已经被 action 替代) + // 但保留 DIRECT 这种必需的特殊出站 + config.outbounds = config.outbounds.filter(o => { + if (o.tag === 'REJECT' || o.tag === 'block') { + return false; // 移除，因为已经改用 action: reject 了 + } + return true; + }); + + const existingOutboundTags = new Set(config.outbounds.map(o => o.tag)); + + if (!existingOutboundTags.has('DIRECT')) { + config.outbounds.push({ "type": "direct", "tag": "DIRECT" }); + existingOutboundTags.add('DIRECT'); + } + + if (config.dns && config.dns.servers) { + const dnsServerTags = new Set(config.dns.servers.map(s => s.tag)); + if (config.dns.rules) { + config.dns.rules.forEach(rule => { + if (rule.server && !dnsServerTags.has(rule.server)) { + if (rule.server === 'dns_block' && dnsServerTags.has('block')) { + rule.server = 'block'; + } else if (rule.server.toLowerCase().includes('block') && !dnsServerTags.has(rule.server)) { + config.dns.servers.push({ "tag": rule.server, "address": "rcode://success" }); + dnsServerTags.add(rule.server); + } + } + }); + } + } + + config.outbounds.forEach(outbound => { + if (outbound.type === 'selector' || outbound.type === 'urltest') { + if (Array.isArray(outbound.outbounds)) { + // 修正：如果选择器引用了被移除的 REJECT/block，直接将其过滤掉 + // 因为路由规则已经通过 action 拦截了，不需要走选择器 + outbound.outbounds = outbound.outbounds.filter(tag => { + const upperTag = tag.toUpperCase(); + return existingOutboundTags.has(tag) && upperTag !== 'REJECT' && upperTag !== 'BLOCK'; + }); + if (outbound.outbounds.length === 0) outbound.outbounds.push("DIRECT"); + } + } + }); + + return JSON.stringify(config, null, 2); + } catch (e) { + console.error("Singbox热补丁执行失败:", e); + return JSON.stringify(JSON.parse(sb_json_text), null, 2); + } +} + +function Surge订阅配置文件热补丁(content, url, config_JSON) { + const 每行内容 = content.includes('\r\n') ? content.split('\r\n') : content.split('\n'); + + let 输出内容 = ""; + const realSurgePath = config_JSON.启用0RTT ? config_JSON.PATH + '?ed=2560' : config_JSON.PATH; + for (let x of 每行内容) { + if (x.includes('= tro' + 'jan,') && !x.includes('ws=true') && !x.includes('ws-path=')) { + const host = x.split("sni=")[1].split(",")[0]; + const 备改内容 = `sni=${host}, skip-cert-verify=${config_JSON.跳过证书验证}`; + const 正确内容 = `sni=${host}, skip-cert-verify=${config_JSON.跳过证书验证}, ws=true, ws-path=${realSurgePath}, ws-headers=Host:"${host}"`; + 输出内容 += x.replace(new RegExp(备改内容, 'g'), 正确内容).replace("[", "").replace("]", "") + '\n'; + } else { + 输出内容 += x + '\n'; + } + } + + 输出内容 = `#!MANAGED-CONFIG ${url} interval=${config_JSON.优选订阅生成.SUBUpdateTime * 60 * 60} strict=false` + 输出内容.substring(输出内容.indexOf('\n')); + return 输出内容; +} + +async function 请求日志记录(env, request, 访问IP, 请求类型 = "Get_SUB", config_JSON) { + const KV容量限制 = 4;//MB + try { + const 当前时间 = new Date(); + const 日志内容 = { TYPE: 请求类型, IP: 访问IP, ASN: `AS${request.cf.asn || '0'} ${request.cf.asOrganization || 'Unknown'}`, CC: `${request.cf.country || 'N/A'} ${request.cf.city || 'N/A'}`, URL: request.url, UA: request.headers.get('User-Agent') || 'Unknown', TIME: 当前时间.getTime() }; + let 日志数组 = []; + const 现有日志 = await env.KV.get('log.json'); + if (现有日志) { + try { + 日志数组 = JSON.parse(现有日志); + if (!Array.isArray(日志数组)) { 日志数组 = [日志内容]; } + else if (请求类型 !== "Get_SUB") { + const 三十分钟前时间戳 = 当前时间.getTime() - 30 * 60 * 1000; + if (日志数组.some(log => log.TYPE !== "Get_SUB" && log.IP === 访问IP && log.URL === request.url && log.UA === (request.headers.get('User-Agent') || 'Unknown') && log.TIME >= 三十分钟前时间戳)) return; + 日志数组.push(日志内容); + while (JSON.stringify(日志数组, null, 2).length > KV容量限制 * 1024 * 1024 && 日志数组.length > 0) 日志数组.shift(); + } else { + 日志数组.push(日志内容); + while (JSON.stringify(日志数组, null, 2).length > KV容量限制 * 1024 * 1024 && 日志数组.length > 0) 日志数组.shift(); + } + if (config_JSON.TG.启用) { + try { + const TG_TXT = await env.KV.get('tg.json'); + const TG_JSON = JSON.parse(TG_TXT); + await sendMessage(TG_JSON.BotToken, TG_JSON.ChatID, 日志内容, config_JSON); + } catch (error) { console.error(`读取tg.json出错: ${error.message}`) } + } + } catch (e) { 日志数组 = [日志内容]; } + } else { 日志数组 = [日志内容]; } + await env.KV.put('log.json', JSON.stringify(日志数组, null, 2)); + } catch (error) { console.error(`日志记录失败: ${error.message}`); } +} + +async function sendMessage(BotToken, ChatID, 日志内容, config_JSON) { + if (!BotToken || !ChatID) return; + + try { + const 请求时间 = new Date(日志内容.TIME).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }); + const 请求URL = new URL(日志内容.URL); + const msg = `#${config_JSON.优选订阅生成.SUBNAME} 日志通知\n\n` + + `📌 类型：#${日志内容.TYPE}\n` + + `🌐 IP：${日志内容.IP}\n` + + `📍 位置：${日志内容.CC}\n` + + `🏢 ASN：${日志内容.ASN}\n` + + `🔗 域名：${请求URL.host}\n` + + `🔍 路径：${请求URL.pathname + 请求URL.search}\n` + + `🤖 UA：${日志内容.UA}\n` + + `📅 时间：${请求时间}\n` + + `${config_JSON.CF.Usage.success ? `📊 请求用量：${config_JSON.CF.Usage.total}/100000 ${((config_JSON.CF.Usage.total / 100000) * 100).toFixed(2)}%\n` : ''}`; + + const url = `https://api.telegram.org/bot${BotToken}/sendMessage?chat_id=${ChatID}&parse_mode=HTML&text=${encodeURIComponent(msg)}`; + return fetch(url, { + method: 'GET', + headers: { + 'Accept': 'text/html,application/xhtml+xml,application/xml;', + 'Accept-Encoding': 'gzip, deflate, br', + 'User-Agent': 日志内容.UA || 'Unknown', + } + }); + } catch (error) { console.error('Error sending message:', error) } +} + +function 掩码敏感信息(文本, 前缀长度 = 3, 后缀长度 = 2) { + if (!文本 || typeof 文本 !== 'string') return 文本; + if (文本.length <= 前缀长度 + 后缀长度) return 文本; // 如果长度太短，直接返回 + + const 前缀 = 文本.slice(0, 前缀长度); + const 后缀 = 文本.slice(-后缀长度); + const 星号数量 = 文本.length - 前缀长度 - 后缀长度; + + return `${前缀}${'*'.repeat(星号数量)}${后缀}`; +} + +async function MD5MD5(文本) { + const 编码器 = new TextEncoder(); + + const 第一次哈希 = await crypto.subtle.digest('MD5', 编码器.encode(文本)); + const 第一次哈希数组 = Array.from(new Uint8Array(第一次哈希)); + const 第一次十六进制 = 第一次哈希数组.map(字节 => 字节.toString(16).padStart(2, '0')).join(''); + + const 第二次哈希 = await crypto.subtle.digest('MD5', 编码器.encode(第一次十六进制.slice(7, 27))); + const 第二次哈希数组 = Array.from(new Uint8Array(第二次哈希)); + const 第二次十六进制 = 第二次哈希数组.map(字节 => 字节.toString(16).padStart(2, '0')).join(''); + + return 第二次十六进制.toLowerCase(); +} + +function 随机路径() { + const 常用路径目录 = ["about", "account", "acg", "act", "activity", "ad", "ads", "ajax", "album", "albums", "anime", "api", "app", "apps", "archive", "archives", "article", "articles", "ask", "auth", "avatar", "bbs", "bd", "blog", "blogs", "book", "books", "bt", "buy", "cart", "category", "categories", "cb", "channel", "channels", "chat", "china", "city", "class", "classify", "clip", "clips", "club", "cn", "code", "collect", "collection", "comic", "comics", "community", "company", "config", "contact", "content", "course", "courses", "cp", "data", "detail", "details", "dh", "directory", "discount", "discuss", "dl", "dload", "doc", "docs", "document", "documents", "doujin", "download", "downloads", "drama", "edu", "en", "ep", "episode", "episodes", "event", "events", "f", "faq", "favorite", "favourites", "favs", "feedback", "file", "files", "film", "films", "forum", "forums", "friend", "friends", "game", "games", "gif", "go", "go.html", "go.php", "group", "groups", "help", "home", "hot", "htm", "html", "image", "images", "img", "index", "info", "intro", "item", "items", "ja", "jp", "jump", "jump.html", "jump.php", "jumping", "knowledge", "lang", "lesson", "lessons", "lib", "library", "link", "links", "list", "live", "lives", "m", "mag", "magnet", "mall", "manhua", "map", "member", "members", "message", "messages", "mobile", "movie", "movies", "music", "my", "new", "news", "note", "novel", "novels", "online", "order", "out", "out.html", "out.php", "outbound", "p", "page", "pages", "pay", "payment", "pdf", "photo", "photos", "pic", "pics", "picture", "pictures", "play", "player", "playlist", "post", "posts", "product", "products", "program", "programs", "project", "qa", "question", "rank", "ranking", "read", "readme", "redirect", "redirect.html", "redirect.php", "reg", "register", "res", "resource", "retrieve", "sale", "search", "season", "seasons", "section", "seller", "series", "service", "services", "setting", "settings", "share", "shop", "show", "shows", "site", "soft", "sort", "source", "special", "star", "stars", "static", "stock", "store", "stream", "streaming", "streams", "student", "study", "tag", "tags", "task", "teacher", "team", "tech", "temp", "test", "thread", "tool", "tools", "topic", "topics", "torrent", "trade", "travel", "tv", "txt", "type", "u", "upload", "uploads", "url", "urls", "user", "users", "v", "version", "video", "videos", "view", "vip", "vod", "watch", "web", "wenku", "wiki", "work", "www", "zh", "zh-cn", "zh-tw", "zip"]; + const 随机数 = Math.floor(Math.random() * 3 + 1); + const 随机路径 = 常用路径目录.sort(() => 0.5 - Math.random()).slice(0, 随机数).join('/'); + return `/${随机路径}`; +} + +function 随机替换通配符(h) { + if (!h?.includes('*')) return h; + const 字符集 = 'abcdefghijklmnopqrstuvwxyz0123456789'; + return h.replace(/\*/g, () => { + let s = ''; + for (let i = 0; i < Math.floor(Math.random() * 14) + 3; i++) + s += 字符集[Math.floor(Math.random() * 36)]; + return s; + }); +} + +function 批量替换域名(内容, hosts, 每组数量 = 2) { + const 打乱后数组 = [...hosts].sort(() => Math.random() - 0.5); + let count = 0, currentRandomHost = null; + return 内容.replace(/example\.com/g, () => { + if (count % 每组数量 === 0) currentRandomHost = 随机替换通配符(打乱后数组[Math.floor(count / 每组数量) % 打乱后数组.length]); + count++; + return currentRandomHost; + }); +} + +async function 读取config_JSON(env, hostname, userID, path, 重置配置 = false) { + //const host = 随机替换通配符(hostname); + const host = hostname; + const 初始化开始时间 = performance.now(); + const 默认配置JSON = { + TIME: new Date().toISOString(), + HOST: host, + HOSTS: [hostname], + UUID: userID, + 协议类型: "v" + "le" + "ss", + 传输协议: "ws", + 跳过证书验证: true, + 启用0RTT: false, + TLS分片: null, + 随机路径: false, + 优选订阅生成: { + local: true, // true: 基于本地的优选地址 false: 优选订阅生成器 + 本地IP库: { + 随机IP: true, // 当 随机IP 为true时生效，启用随机IP的数量，否则使用KV内的ADD.txt + 随机数量: 16, + 指定端口: -1, + }, + SUB: null, + SUBNAME: "edge" + "tunnel", + SUBUpdateTime: 6, // 订阅更新时间（小时） + TOKEN: await MD5MD5(hostname + userID), + }, + 订阅转换配置: { + SUBAPI: "https://SUBAPI.cmliussss.net", + SUBCONFIG: "https://raw.githubusercontent.com/cmliu/ACL4SSR/refs/heads/main/Clash/config/ACL4SSR_Online_Mini_MultiMode_CF.ini", + SUBEMOJI: false, + }, + 反代: { + PROXYIP: "auto", + SOCKS5: { + 启用: 启用SOCKS5反代, + 全局: 启用SOCKS5全局反代, + 账号: 我的SOCKS5账号, + 白名单: SOCKS5白名单, + }, + }, + TG: { + 启用: false, + BotToken: null, + ChatID: null, + }, + CF: { + Email: null, + GlobalAPIKey: null, + AccountID: null, + APIToken: null, + UsageAPI: null, + Usage: { + success: false, + pages: 0, + workers: 0, + total: 0, + max: 100000, + }, + } + }; + + try { + let configJSON = await env.KV.get('config.json'); + if (!configJSON || 重置配置 == true) { + await env.KV.put('config.json', JSON.stringify(默认配置JSON, null, 2)); + config_JSON = 默认配置JSON; + } else { + config_JSON = JSON.parse(configJSON); + } + } catch (error) { + console.error(`读取config_JSON出错: ${error.message}`); + config_JSON = 默认配置JSON; + } + + config_JSON.HOST = host; + if (!config_JSON.HOSTS) config_JSON.HOSTS = [hostname]; + if (env.HOST) config_JSON.HOSTS = (await 整理成数组(env.HOST)).map(h => h.toLowerCase().replace(/^https?:\/\//, '').split('/')[0].split(':')[0]); + config_JSON.UUID = userID; + config_JSON.PATH = path ? (path.startsWith('/') ? path : '/' + path) : (config_JSON.反代.SOCKS5.启用 ? ('/' + config_JSON.反代.SOCKS5.启用 + (config_JSON.反代.SOCKS5.全局 ? '://' : '=') + config_JSON.反代.SOCKS5.账号) : (config_JSON.反代.PROXYIP === 'auto' ? '/' : `/proxyip=${config_JSON.反代.PROXYIP}`)); + const TLS分片参数 = config_JSON.TLS分片 == 'Shadowrocket' ? `&fragment=${encodeURIComponent('1,40-60,30-50,tlshello')}` : config_JSON.TLS分片 == 'Happ' ? `&fragment=${encodeURIComponent('3,1,tlshello')}` : ''; + config_JSON.LINK = `${config_JSON.协议类型}://${userID}@${host}:443?security=tls&type=${config_JSON.传输协议}&host=${host}&sni=${host}&path=${encodeURIComponent(config_JSON.启用0RTT ? config_JSON.PATH + '?ed=2560' : config_JSON.PATH) + TLS分片参数}&encryption=none${config_JSON.跳过证书验证 ? '&allowInsecure=1' : ''}#${encodeURIComponent(config_JSON.优选订阅生成.SUBNAME)}`; + config_JSON.优选订阅生成.TOKEN = await MD5MD5(hostname + userID); + + const 初始化TG_JSON = { BotToken: null, ChatID: null }; + config_JSON.TG = { 启用: config_JSON.TG.启用 ? config_JSON.TG.启用 : false, ...初始化TG_JSON }; + try { + const TG_TXT = await env.KV.get('tg.json'); + if (!TG_TXT) { + await env.KV.put('tg.json', JSON.stringify(初始化TG_JSON, null, 2)); + } else { + const TG_JSON = JSON.parse(TG_TXT); + config_JSON.TG.ChatID = TG_JSON.ChatID ? TG_JSON.ChatID : null; + config_JSON.TG.BotToken = TG_JSON.BotToken ? 掩码敏感信息(TG_JSON.BotToken) : null; + } + } catch (error) { + console.error(`读取tg.json出错: ${error.message}`); + } + + const 初始化CF_JSON = { Email: null, GlobalAPIKey: null, AccountID: null, APIToken: null, UsageAPI: null }; + config_JSON.CF = { ...初始化CF_JSON, Usage: { success: false, pages: 0, workers: 0, total: 0, max: 100000 } }; + try { + const CF_TXT = await env.KV.get('cf.json'); + if (!CF_TXT) { + await env.KV.put('cf.json', JSON.stringify(初始化CF_JSON, null, 2)); + } else { + const CF_JSON = JSON.parse(CF_TXT); + if (CF_JSON.UsageAPI) { + try { + const response = await fetch(CF_JSON.UsageAPI); + const Usage = await response.json(); + config_JSON.CF.Usage = Usage; + } catch (err) { + console.error(`请求 CF_JSON.UsageAPI 失败: ${err.message}`); + } + } else { + config_JSON.CF.Email = CF_JSON.Email ? CF_JSON.Email : null; + config_JSON.CF.GlobalAPIKey = CF_JSON.GlobalAPIKey ? 掩码敏感信息(CF_JSON.GlobalAPIKey) : null; + config_JSON.CF.AccountID = CF_JSON.AccountID ? 掩码敏感信息(CF_JSON.AccountID) : null; + config_JSON.CF.APIToken = CF_JSON.APIToken ? 掩码敏感信息(CF_JSON.APIToken) : null; + config_JSON.CF.UsageAPI = null; + const Usage = await getCloudflareUsage(CF_JSON.Email, CF_JSON.GlobalAPIKey, CF_JSON.AccountID, CF_JSON.APIToken); + config_JSON.CF.Usage = Usage; + } + } + } catch (error) { + console.error(`读取cf.json出错: ${error.message}`); + } + + config_JSON.加载时间 = (performance.now() - 初始化开始时间).toFixed(2) + 'ms'; + return config_JSON; +} + +async function 生成随机IP(request, count = 16, 指定端口 = -1) { + const asnMap = { '9808': 'cmcc', '4837': 'cu', '4134': 'ct' }, asn = request.cf.asn; + const cidr_url = asnMap[asn] ? `https://raw.githubusercontent.com/cmliu/cmliu/main/CF-CIDR/${asnMap[asn]}.txt` : 'https://raw.githubusercontent.com/cmliu/cmliu/main/CF-CIDR.txt'; + const cfname = { '9808': 'CF移动优选', '4837': 'CF联通优选', '4134': 'CF电信优选' }[asn] || 'CF官方优选'; + const cfport = [443, 2053, 2083, 2087, 2096, 8443]; + let cidrList = []; + try { const res = await fetch(cidr_url); cidrList = res.ok ? await 整理成数组(await res.text()) : ['104.16.0.0/13']; } catch { cidrList = ['104.16.0.0/13']; } + + const generateRandomIPFromCIDR = (cidr) => { + const [baseIP, prefixLength] = cidr.split('/'), prefix = parseInt(prefixLength), hostBits = 32 - prefix; + const ipInt = baseIP.split('.').reduce((a, p, i) => a | (parseInt(p) << (24 - i * 8)), 0); + const randomOffset = Math.floor(Math.random() * Math.pow(2, hostBits)); + const mask = (0xFFFFFFFF << hostBits) >>> 0, randomIP = (((ipInt & mask) >>> 0) + randomOffset) >>> 0; + return [(randomIP >>> 24) & 0xFF, (randomIP >>> 16) & 0xFF, (randomIP >>> 8) & 0xFF, randomIP & 0xFF].join('.'); + }; + + const randomIPs = Array.from({ length: count }, () => { + const ip = generateRandomIPFromCIDR(cidrList[Math.floor(Math.random() * cidrList.length)]); + return `${ip}:${指定端口 === -1 ? cfport[Math.floor(Math.random() * cfport.length)] : 指定端口}#${cfname}`; + }); + return [randomIPs, randomIPs.join('\n')]; +} + +async function 整理成数组(内容) { + var 替换后的内容 = 内容.replace(/[ "'\r\n]+/g, ',').replace(/,+/g, ','); + if (替换后的内容.charAt(0) == ',') 替换后的内容 = 替换后的内容.slice(1); + if (替换后的内容.charAt(替换后的内容.length - 1) == ',') 替换后的内容 = 替换后的内容.slice(0, 替换后的内容.length - 1); + const 地址数组 = 替换后的内容.split(','); + return 地址数组; +} + +function isValidBase64(str) { + if (typeof str !== 'string') return false; + const cleanStr = str.replace(/\s/g, ''); + if (cleanStr.length === 0 || cleanStr.length % 4 !== 0) return false; + const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/; + if (!base64Regex.test(cleanStr)) return false; + try { + atob(cleanStr); + return true; + } catch { + return false; + } +} + +function base64Decode(str) { + const bytes = new Uint8Array(atob(str).split('').map(c => c.charCodeAt(0))); + const decoder = new TextDecoder('utf-8'); + return decoder.decode(bytes); +} + +async function 请求优选API(urls, 默认端口 = '443', 超时时间 = 3000) { + if (!urls?.length) return [[], [], []]; + const results = new Set(); + let 订阅链接响应的明文LINK内容 = '', 需要订阅转换订阅URLs = []; + await Promise.allSettled(urls.map(async (url) => { + try { + const controller = new AbortController(); + const timeoutId = setTimeout(() => controller.abort(), 超时时间); + const response = await fetch(url, { signal: controller.signal }); + clearTimeout(timeoutId); + let text = ''; + try { + const buffer = await response.arrayBuffer(); + const contentType = (response.headers.get('content-type') || '').toLowerCase(); + const charset = contentType.match(/charset=([^\s;]+)/i)?.[1]?.toLowerCase() || ''; + + // 根据 Content-Type 响应头判断编码优先级 + let decoders = ['utf-8', 'gb2312']; // 默认优先 UTF-8 + if (charset.includes('gb') || charset.includes('gbk') || charset.includes('gb2312')) { + decoders = ['gb2312', 'utf-8']; // 如果明确指定 GB 系编码，优先尝试 GB2312 + } + + // 尝试多种编码解码 + let decodeSuccess = false; + for (const decoder of decoders) { + try { + const decoded = new TextDecoder(decoder).decode(buffer); + // 验证解码结果的有效性 + if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) { + text = decoded; + decodeSuccess = true; + break; + } else if (decoded && decoded.length > 0) { + // 如果有替换字符 (U+FFFD)，说明编码不匹配，继续尝试下一个编码 + continue; + } + } catch (e) { + // 该编码解码失败，尝试下一个 + continue; + } + } + + // 如果所有编码都失败或无效，尝试 response.text() + if (!decodeSuccess) { + text = await response.text(); + } + + // 如果返回的是空或无效数据，返回 + if (!text || text.trim().length === 0) { + return; + } + } catch (e) { + console.error('Failed to decode response:', e); + return; + } + + // 预处理订阅内容 + /* + if (text.includes('proxies:') || (text.includes('outbounds"') && text.includes('inbounds"'))) {// Clash Singbox 配置 + 需要订阅转换订阅URLs.add(url); + return; + } + */ + + const 预处理订阅明文内容 = isValidBase64(text) ? base64Decode(text) : text; + if (预处理订阅明文内容.split('#')[0].includes('://')) { + 订阅链接响应的明文LINK内容 += 预处理订阅明文内容 + '\n'; // 追加LINK明文内容 + return; + } + + const lines = text.trim().split('\n').map(l => l.trim()).filter(l => l); + const isCSV = lines.length > 1 && lines[0].includes(','); + const IPV6_PATTERN = /^[^\[\]]*:[^\[\]]*:[^\[\]]/; + if (!isCSV) { + lines.forEach(line => { + const hashIndex = line.indexOf('#'); + const [hostPart, remark] = hashIndex > -1 ? [line.substring(0, hashIndex), line.substring(hashIndex)] : [line, '']; + let hasPort = false; + if (hostPart.startsWith('[')) { + hasPort = /\]:(\d+)$/.test(hostPart); + } else { + const colonIndex = hostPart.lastIndexOf(':'); + hasPort = colonIndex > -1 && /^\d+$/.test(hostPart.substring(colonIndex + 1)); + } + const port = new URL(url).searchParams.get('port') || 默认端口; + results.add(hasPort ? line : `${hostPart}:${port}${remark}`); + }); + } else { + const headers = lines[0].split(',').map(h => h.trim()); + const dataLines = lines.slice(1); + if (headers.includes('IP地址') && headers.includes('端口') && headers.includes('数据中心')) { + const ipIdx = headers.indexOf('IP地址'), portIdx = headers.indexOf('端口'); + const remarkIdx = headers.indexOf('国家') > -1 ? headers.indexOf('国家') : + headers.indexOf('城市') > -1 ? headers.indexOf('城市') : headers.indexOf('数据中心'); + const tlsIdx = headers.indexOf('TLS'); + dataLines.forEach(line => { + const cols = line.split(',').map(c => c.trim()); + if (tlsIdx !== -1 && cols[tlsIdx]?.toLowerCase() !== 'true') return; + const wrappedIP = IPV6_PATTERN.test(cols[ipIdx]) ? `[${cols[ipIdx]}]` : cols[ipIdx]; + results.add(`${wrappedIP}:${cols[portIdx]}#${cols[remarkIdx]}`); + }); + } else if (headers.some(h => h.includes('IP')) && headers.some(h => h.includes('延迟')) && headers.some(h => h.includes('下载速度'))) { + const ipIdx = headers.findIndex(h => h.includes('IP')); + const delayIdx = headers.findIndex(h => h.includes('延迟')); + const speedIdx = headers.findIndex(h => h.includes('下载速度')); + const port = new URL(url).searchParams.get('port') || 默认端口; + dataLines.forEach(line => { + const cols = line.split(',').map(c => c.trim()); + const wrappedIP = IPV6_PATTERN.test(cols[ipIdx]) ? `[${cols[ipIdx]}]` : cols[ipIdx]; + results.add(`${wrappedIP}:${port}#CF优选 ${cols[delayIdx]}ms ${cols[speedIdx]}MB/s`); + }); + } + } + } catch (e) { } + })); + // 将LINK内容转换为数组并去重 + const LINK数组 = 订阅链接响应的明文LINK内容.trim() ? [...new Set(订阅链接响应的明文LINK内容.split(/\r?\n/).filter(line => line.trim() !== ''))] : []; + return [Array.from(results), LINK数组, 需要订阅转换订阅URLs]; +} + +async function 反代参数获取(request) { + const url = new URL(request.url); + const { pathname, searchParams } = url; + const pathLower = pathname.toLowerCase(); + + // 初始化 + 我的SOCKS5账号 = searchParams.get('socks5') || searchParams.get('http') || null; + 启用SOCKS5全局反代 = searchParams.has('globalproxy') || false; + + // 统一处理反代IP参数 (优先级最高,使用正则一次匹配) + const proxyMatch = pathLower.match(/\/(proxyip[.=]|pyip=|ip=)(.+)/); + if (searchParams.has('proxyip')) { + const 路参IP = searchParams.get('proxyip'); + 反代IP = 路参IP.includes(',') ? 路参IP.split(',')[Math.floor(Math.random() * 路参IP.split(',').length)] : 路参IP; + 启用反代兜底 = false; + return; + } else if (proxyMatch) { + const 路参IP = proxyMatch[1] === 'proxyip.' ? `proxyip.${proxyMatch[2]}` : proxyMatch[2]; + 反代IP = 路参IP.includes(',') ? 路参IP.split(',')[Math.floor(Math.random() * 路参IP.split(',').length)] : 路参IP; + 启用反代兜底 = false; + return; + } + + // 处理SOCKS5/HTTP代理参数 + let socksMatch; + if ((socksMatch = pathname.match(/\/(socks5?|http):\/?\/?(.+)/i))) { + // 格式: /socks5://... 或 /http://... + 启用SOCKS5反代 = socksMatch[1].toLowerCase() === 'http' ? 'http' : 'socks5'; + 我的SOCKS5账号 = socksMatch[2].split('#')[0]; + 启用SOCKS5全局反代 = true; + + // 处理Base64编码的用户名密码 + if (我的SOCKS5账号.includes('@')) { + const atIndex = 我的SOCKS5账号.lastIndexOf('@'); + let userPassword = 我的SOCKS5账号.substring(0, atIndex).replaceAll('%3D', '='); + if (/^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i.test(userPassword) && !userPassword.includes(':')) { + userPassword = atob(userPassword); + } + 我的SOCKS5账号 = `${userPassword}@${我的SOCKS5账号.substring(atIndex + 1)}`; + } + } else if ((socksMatch = pathname.match(/\/(g?s5|socks5|g?http)=(.+)/i))) { + // 格式: /socks5=... 或 /s5=... 或 /gs5=... 或 /http=... 或 /ghttp=... + const type = socksMatch[1].toLowerCase(); + 我的SOCKS5账号 = socksMatch[2]; + 启用SOCKS5反代 = type.includes('http') ? 'http' : 'socks5'; + 启用SOCKS5全局反代 = type.startsWith('g') || 启用SOCKS5全局反代; // gs5 或 ghttp 开头启用全局 + } + + // 解析SOCKS5地址 + if (我的SOCKS5账号) { + try { + parsedSocks5Address = await 获取SOCKS5账号(我的SOCKS5账号); + 启用SOCKS5反代 = searchParams.get('http') ? 'http' : 启用SOCKS5反代; + } catch (err) { + console.error('解析SOCKS5地址失败:', err.message); + 启用SOCKS5反代 = null; + } + } else 启用SOCKS5反代 = null; +} + +async function 获取SOCKS5账号(address) { + if (address.includes('@')) { + const lastAtIndex = address.lastIndexOf('@'); + let userPassword = address.substring(0, lastAtIndex).replaceAll('%3D', '='); + const base64Regex = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i; + if (base64Regex.test(userPassword) && !userPassword.includes(':')) userPassword = atob(userPassword); + address = `${userPassword}@${address.substring(lastAtIndex + 1)}`; + } + const atIndex = address.lastIndexOf("@"); + const [hostPart, authPart] = atIndex === -1 ? [address, undefined] : [address.substring(atIndex + 1), address.substring(0, atIndex)]; + + // 解析认证 + let username, password; + if (authPart) { + [username, password] = authPart.split(":"); + if (!password) throw new Error('无效的 SOCKS 地址格式：认证部分必须是 "username:password" 的形式'); + } + + // 解析主机端口 + let hostname, port; + if (hostPart.includes("]:")) { // IPv6带端口 + [hostname, port] = [hostPart.split("]:")[0] + "]", Number(hostPart.split("]:")[1].replace(/[^\d]/g, ''))]; + } else if (hostPart.startsWith("[")) { // IPv6无端口 + [hostname, port] = [hostPart, 80]; + } else { // IPv4/域名 + const parts = hostPart.split(":"); + [hostname, port] = parts.length === 2 ? [parts[0], Number(parts[1].replace(/[^\d]/g, ''))] : [hostPart, 80]; + } + + if (isNaN(port)) throw new Error('无效的 SOCKS 地址格式：端口号必须是数字'); + if (hostname.includes(":") && !/^\[.*\]$/.test(hostname)) throw new Error('无效的 SOCKS 地址格式：IPv6 地址必须用方括号括起来，如 [2001:db8::1]'); + + return { username, password, hostname, port }; +} + +async function getCloudflareUsage(Email, GlobalAPIKey, AccountID, APIToken) { + const API = "https://api.cloudflare.com/client/v4"; + const sum = (a) => a?.reduce((t, i) => t + (i?.sum?.requests || 0), 0) || 0; + const cfg = { "Content-Type": "application/json" }; + + try { + if (!AccountID && (!Email || !GlobalAPIKey)) return { success: false, pages: 0, workers: 0, total: 0, max: 100000 }; + + if (!AccountID) { + const r = await fetch(`${API}/accounts`, { + method: "GET", + headers: { ...cfg, "X-AUTH-EMAIL": Email, "X-AUTH-KEY": GlobalAPIKey } + }); + if (!r.ok) throw new Error(`账户获取失败: ${r.status}`); + const d = await r.json(); + if (!d?.result?.length) throw new Error("未找到账户"); + const idx = d.result.findIndex(a => a.name?.toLowerCase().startsWith(Email.toLowerCase())); + AccountID = d.result[idx >= 0 ? idx : 0]?.id; + } + + const now = new Date(); + now.setUTCHours(0, 0, 0, 0); + const hdr = APIToken ? { ...cfg, "Authorization": `Bearer ${APIToken}` } : { ...cfg, "X-AUTH-EMAIL": Email, "X-AUTH-KEY": GlobalAPIKey }; + + const res = await fetch(`${API}/graphql`, { + method: "POST", + headers: hdr, + body: JSON.stringify({ + query: `query getBillingMetrics($AccountID: String!, $filter: AccountWorkersInvocationsAdaptiveFilter_InputObject) { + viewer { accounts(filter: {accountTag: $AccountID}) { + pagesFunctionsInvocationsAdaptiveGroups(limit: 1000, filter: $filter) { sum { requests } } + workersInvocationsAdaptive(limit: 10000, filter: $filter) { sum { requests } } + } } + }`, + variables: { AccountID, filter: { datetime_geq: now.toISOString(), datetime_leq: new Date().toISOString() } } + }) + }); + + if (!res.ok) throw new Error(`查询失败: ${res.status}`); + const result = await res.json(); + if (result.errors?.length) throw new Error(result.errors[0].message); + + const acc = result?.data?.viewer?.accounts?.[0]; + if (!acc) throw new Error("未找到账户数据"); + + const pages = sum(acc.pagesFunctionsInvocationsAdaptiveGroups); + const workers = sum(acc.workersInvocationsAdaptive); + const total = pages + workers; + const max = 100000; + console.log(`统计结果 - Pages: ${pages}, Workers: ${workers}, 总计: ${total}, 上限: 100000`); + return { success: true, pages, workers, total, max }; + + } catch (error) { + console.error('获取使用量错误:', error.message); + return { success: false, pages: 0, workers: 0, total: 0, max: 100000 }; + } +} + +function sha224(s) { + const K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]; + const r = (n, b) => ((n >>> b) | (n << (32 - b))) >>> 0; + s = unescape(encodeURIComponent(s)); + const l = s.length * 8; s += String.fromCharCode(0x80); + while ((s.length * 8) % 512 !== 448) s += String.fromCharCode(0); + const h = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]; + const hi = Math.floor(l / 0x100000000), lo = l & 0xFFFFFFFF; + s += String.fromCharCode((hi >>> 24) & 0xFF, (hi >>> 16) & 0xFF, (hi >>> 8) & 0xFF, hi & 0xFF, (lo >>> 24) & 0xFF, (lo >>> 16) & 0xFF, (lo >>> 8) & 0xFF, lo & 0xFF); + const w = []; for (let i = 0; i < s.length; i += 4)w.push((s.charCodeAt(i) << 24) | (s.charCodeAt(i + 1) << 16) | (s.charCodeAt(i + 2) << 8) | s.charCodeAt(i + 3)); + for (let i = 0; i < w.length; i += 16) { + const x = new Array(64).fill(0); + for (let j = 0; j < 16; j++)x[j] = w[i + j]; + for (let j = 16; j < 64; j++) { + const s0 = r(x[j - 15], 7) ^ r(x[j - 15], 18) ^ (x[j - 15] >>> 3); + const s1 = r(x[j - 2], 17) ^ r(x[j - 2], 19) ^ (x[j - 2] >>> 10); + x[j] = (x[j - 16] + s0 + x[j - 7] + s1) >>> 0; + } + let [a, b, c, d, e, f, g, h0] = h; + for (let j = 0; j < 64; j++) { + const S1 = r(e, 6) ^ r(e, 11) ^ r(e, 25), ch = (e & f) ^ (~e & g), t1 = (h0 + S1 + ch + K[j] + x[j]) >>> 0; + const S0 = r(a, 2) ^ r(a, 13) ^ r(a, 22), maj = (a & b) ^ (a & c) ^ (b & c), t2 = (S0 + maj) >>> 0; + h0 = g; g = f; f = e; e = (d + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0; + } + for (let j = 0; j < 8; j++)h[j] = (h[j] + (j === 0 ? a : j === 1 ? b : j === 2 ? c : j === 3 ? d : j === 4 ? e : j === 5 ? f : j === 6 ? g : h0)) >>> 0; + } + let hex = ''; + for (let i = 0; i < 7; i++) { + for (let j = 24; j >= 0; j -= 8)hex += ((h[i] >>> j) & 0xFF).toString(16).padStart(2, '0'); + } + return hex; +} + +async function 解析地址端口(proxyIP, 目标域名 = 'dash.cloudflare.com', UUID = '00000000-0000-4000-8000-000000000000') { + if (!缓存反代IP || !缓存反代解析数组 || 缓存反代IP !== proxyIP) { + proxyIP = proxyIP.toLowerCase(); + async function DoH查询(域名, 记录类型) { + try { + const response = await fetch(`https://1.1.1.1/dns-query?name=${域名}&type=${记录类型}`, { + headers: { 'Accept': 'application/dns-json' } + }); + if (!response.ok) return []; + const data = await response.json(); + return data.Answer || []; + } catch (error) { + console.error(`DoH查询失败 (${记录类型}):`, error); + return []; + } + } + + function 解析地址端口字符串(str) { + let 地址 = str, 端口 = 443; + if (str.includes(']:')) { + const parts = str.split(']:'); + 地址 = parts[0] + ']'; + 端口 = parseInt(parts[1], 10) || 端口; + } else if (str.includes(':') && !str.startsWith('[')) { + const colonIndex = str.lastIndexOf(':'); + 地址 = str.slice(0, colonIndex); + 端口 = parseInt(str.slice(colonIndex + 1), 10) || 端口; + } + return [地址, 端口]; + } + + let 所有反代数组 = []; + + if (proxyIP.includes('.william')) { + try { + const txtRecords = await DoH查询(proxyIP, 'TXT'); + const txtData = txtRecords.filter(r => r.type === 16).map(r => r.data); + if (txtData.length > 0) { + let data = txtData[0]; + if (data.startsWith('"') && data.endsWith('"')) data = data.slice(1, -1); + const prefixes = data.replace(/\\010/g, ',').replace(/\n/g, ',').split(',').map(s => s.trim()).filter(Boolean); + 所有反代数组 = prefixes.map(prefix => 解析地址端口字符串(prefix)); + } + } catch (error) { + console.error('解析William域名失败:', error); + } + } else { + let [地址, 端口] = 解析地址端口字符串(proxyIP); + + if (proxyIP.includes('.tp')) { + const tpMatch = proxyIP.match(/\.tp(\d+)/); + if (tpMatch) 端口 = parseInt(tpMatch[1], 10); + } + + // 判断是否是域名（非IP地址） + const ipv4Regex = /^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$/; + const ipv6Regex = /^\[?([a-fA-F0-9:]+)\]?$/; + + if (!ipv4Regex.test(地址) && !ipv6Regex.test(地址)) { + // 并行查询 A 和 AAAA 记录 + const [aRecords, aaaaRecords] = await Promise.all([ + DoH查询(地址, 'A'), + DoH查询(地址, 'AAAA') + ]); + + const ipv4List = aRecords.filter(r => r.type === 1).map(r => r.data); + const ipv6List = aaaaRecords.filter(r => r.type === 28).map(r => `[${r.data}]`); + const ipAddresses = [...ipv4List, ...ipv6List]; + + 所有反代数组 = ipAddresses.length > 0 + ? ipAddresses.map(ip => [ip, 端口]) + : [[地址, 端口]]; + } else { + 所有反代数组 = [[地址, 端口]]; + } + } + const 排序后数组 = 所有反代数组.sort((a, b) => a[0].localeCompare(b[0])); + const 目标根域名 = 目标域名.includes('.') ? 目标域名.split('.').slice(-2).join('.') : 目标域名; + let 随机种子 = [...(目标根域名 + UUID)].reduce((a, c) => a + c.charCodeAt(0), 0); + console.log(`[反代解析] 随机种子: ${随机种子}\n目标站点: ${目标根域名}`) + const 洗牌后 = [...排序后数组].sort(() => (随机种子 = (随机种子 * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff - 0.5); + 缓存反代解析数组 = 洗牌后.slice(0, 8); + console.log(`[反代解析] 解析完成 总数: ${缓存反代解析数组.length}个\n${缓存反代解析数组.map(([ip, port], index) => `${index + 1}. ${ip}:${port}`).join('\n')}`); + 缓存反代IP = proxyIP; + } else console.log(`[反代解析] 读取缓存 总数: ${缓存反代解析数组.length}个\n${缓存反代解析数组.map(([ip, port], index) => `${index + 1}. ${ip}:${port}`).join('\n')}`); + return 缓存反代解析数组; +} + +async function SOCKS5可用性验证(代理协议 = 'socks5', 代理参数) { + const startTime = Date.now(); + try { parsedSocks5Address = await 获取SOCKS5账号(代理参数); } catch (err) { return { success: false, error: err.message, proxy: 代理协议 + "://" + 代理参数, responseTime: Date.now() - startTime }; } + const { username, password, hostname, port } = parsedSocks5Address; + const 完整代理参数 = username && password ? `${username}:${password}@${hostname}:${port}` : `${hostname}:${port}`; + try { + const initialData = new Uint8Array(0); + const tcpSocket = 代理协议 == 'socks5' ? await socks5Connect('check.socks5.090227.xyz', 80, initialData) : await httpConnect('check.socks5.090227.xyz', 80, initialData); + if (!tcpSocket) return { success: false, error: '无法连接到代理服务器', proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime }; + try { + const writer = tcpSocket.writable.getWriter(), encoder = new TextEncoder(); + await writer.write(encoder.encode(`GET /cdn-cgi/trace HTTP/1.1\r\nHost: check.socks5.090227.xyz\r\nConnection: close\r\n\r\n`)); + writer.releaseLock(); + const reader = tcpSocket.readable.getReader(), decoder = new TextDecoder(); + let response = ''; + try { while (true) { const { done, value } = await reader.read(); if (done) break; response += decoder.decode(value, { stream: true }); } } finally { reader.releaseLock(); } + await tcpSocket.close(); + return { success: true, proxy: 代理协议 + "://" + 完整代理参数, ip: response.match(/ip=(.*)/)[1], loc: response.match(/loc=(.*)/)[1], responseTime: Date.now() - startTime }; + } catch (error) { + try { await tcpSocket.close(); } catch (e) { console.log('关闭连接时出错:', e); } + return { success: false, error: error.message, proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime }; + } + } catch (error) { return { success: false, error: error.message, proxy: 代理协议 + "://" + 完整代理参数, responseTime: Date.now() - startTime }; } +} +//////////////////////////////////////////////////////HTML伪装页面/////////////////////////////////////////////// +async function nginx() { + return ` + + + + Welcome to nginx! + + + +

Welcome to nginx!

+

If you see this page, the nginx web server is successfully installed and + working. Further configuration is required.

+ +

For online documentation and support please refer to + nginx.org.
+ Commercial support is available at + nginx.com.

+ +

Thank you for using nginx.

+ + + ` +} + +async function html1101(host, 访问IP) { + const now = new Date(); + const 格式化时间戳 = now.getFullYear() + '-' + String(now.getMonth() + 1).padStart(2, '0') + '-' + String(now.getDate()).padStart(2, '0') + ' ' + String(now.getHours()).padStart(2, '0') + ':' + String(now.getMinutes()).padStart(2, '0') + ':' + String(now.getSeconds()).padStart(2, '0'); + const 随机字符串 = Array.from(crypto.getRandomValues(new Uint8Array(8))).map(b => b.toString(16).padStart(2, '0')).join(''); + + return ` + + + + + +Worker threw exception | ${host} | Cloudflare + + + + + + + + + + + + + + + + +
+ +
+
+

+ Error + 1101 + Ray ID: ${随机字符串} • ${格式化时间戳} UTC +

+

Worker threw exception

+
+ +
+ +
+
+
+

What happened?

+

You've requested a page on a website (${host}) that is on the Cloudflare network. An unknown error occurred while rendering the page.

+
+ +
+

What can I do?

+

If you are the owner of this website:
refer to Workers - Errors and Exceptions and check Workers Logs for ${host}.

+
+ +
+
+ +
+

+ Cloudflare Ray ID: ${随机字符串} + • + + Performance & security by Cloudflare + +

+ +
+ +
+
+ + + +`; +} + diff --git a/img.png b/img.png new file mode 100644 index 0000000000..c4ece45392 Binary files /dev/null and b/img.png differ diff --git a/worker.zip b/worker.zip deleted file mode 100644 index f6cbc2cdbf..0000000000 Binary files a/worker.zip and /dev/null differ diff --git a/wrangler.toml b/wrangler.toml new file mode 100644 index 0000000000..6b0aed31b3 --- /dev/null +++ b/wrangler.toml @@ -0,0 +1,8 @@ +name = "v20251104" +main = "_worker.js" +compatibility_date = "2025-11-04" +keep_vars = true + +#[[kv_namespaces]] +#binding = "KV" #KV绑定名默认不可修改 +#id = "" #KV数据库id \ No newline at end of file