说明书 on tequila sunset

shadowrocket使用手册（搬运）

Sun, 19 Apr 2026 15:15:38 +0800

本使用手册以 Shadowrocket 官方群组 使用的关键词列表文件为基础进行完善更新，包含软件绝大多数功能的介绍和部分常见问题的解答，以期能够帮助用户更好的理解和使用 Shadowrocket 软件。本仓以普通用户的身份对原作者及所有为相关项目做出贡献的人表示由衷的感谢！其他使用需求可尝试查看 配色与配置仓库

💡 提示
懒人配置
https://lowertop.github.io/Shadowrocket/lazy_group.conf
懒人配置是专为 Shadowrocket 打造的开箱即用的配置文件，首发于官方群组。该配置文件优化了各项设置并内置了常用的规则/规则集以及常用的代理分组/策略组，同时包含详细的参数说明，可在纯文本模式下详细查阅，适合几乎任何阶段的用户使用

本仓与官方群组发布的版本同步更新，Johnshall 的版本也与本仓保持同步。对新手用户而言更推荐访问官方群组使用离线版本

Shadowrocket 使用手册

📝 备注

Shadowrocket（常被用户称为 小火箭）是一款由 Shadow Launch Technology Limited 专为 iOS 设备开发的网络代理工具，同时也支持 Apple TV 等设备，软件自 2.2.70 (2712) 版本起已正式支持 macOS

官方群组：Shadowrocket App
官方频道：Shadowrocket News
反馈邮箱：buginapp@gmail.com

使用目录

点击 目录标题 可以快速定位到相关正文
点击正文的 蓝色标题 可以快速回到目录

首页

快速使用方法

添加节点

协议类型

更新订阅节点

节点排序

节点分享与整理

订阅节点筛选

代理通过/代理链

全局路由

连通性测试

修改测试地址

场景

简单模式

启用回退

配置

配置文件

使用配置

编辑配置

编辑纯文本

编译配置

预览配置

更新配置

重新命名

导出配置

扩展配置

通用参数

隐式参数💡

添加规则

规则优先级

规则类型

规则策略

策略扩展参数

APP分流

更新规则集

预览规则集

修改DNS

DNS-over-PROXY

no-resolve的作用

代理分组

代理分组类型

隐藏代理分组

负载均衡

规则集URL

脚本URL

复制配置文件

替换策略

测试规则

Hosts

URL重写

头部重写

正文重写

本地映射

HTTPS解密

脚本

模块

编辑参数

证书模块

身份证书密码

编写本地节点

数据

代理日志

DNS日志

iCloud自动同步

节点数据管理

流量统计信息

设置

延迟测试方法

小组件

颜色

按需求连接

隧道

兼容模式

前置代理

代理共享

代理类型

开启UDP转发

禁用STUN

权限

隐藏VPN图标

GEOIP数据库

自动更新

温和策略机制

其他

自动切换节点

订阅异常

节点旗帜

节点感叹号

微信转圈

模块消失

模块失效

VPN自动断开

检测代理

编译原因

URL-Schemes

软件首页

快速使用方法

首页 > 添加节点

设置 > 延迟测试方法 > CONNECT

首页 > 连通性测试 > 选可用节点连接

首次启动会提示 安装VPN配置文件，请点击好和允许才能正常使用

添加节点

Shadowrocket 兼容多种服务器订阅格式，以及支持多种代理协议类型包括 WireGuard 节点

首页 > 左上角 > 扫码添加

此操作须开启摄像头权限

复制节点链接，如 trojan://*、vmess://*、vless://* 等，打开 Shadowrocket 时会自动识别导入

此操作须开启剪贴板读取权限

首页 > 右上角 ➕ > 类型 Subscribe > URL 栏输入服务器订阅链接 > 保存

订阅链接后面加上 #1、#2、#3 等，可以重复添加同一个订阅

长按服务器订阅可选隐藏功能，启用后该订阅将默认不显示任何节点，该功能等同于在订阅编辑内的 最大值 填写数字 0

首页 > 右上角 ➕，选择对应节点类型，填写节点配置信息并保存

Shadowrocket 为了兼容部分其他类型的配置文件，也支持在配置文件中编写本地节点信息，但不要当作添加节点的优先选择

若添加或更新订阅时出现异常，请参见订阅异常
添加WireGuard节点
首页 > 右上角 ➕ > 类型选择 WireGuard，填写配置信息
复制如下格式的 WireGuard 配置信息，打开 Shadowrocket 时会自动弹出 添加对话框，点击添加
[Interface]
PrivateKey = xxxxxx
Address = 172.16.0.2/32
DNS = 1.1.1.1
MTU = 1420
[Peer]
PublicKey = xxxxxx
AllowedIPs = 0.0.0.0/0
AllowedIPs = ::/0
Endpoint = engage.cloudflareclient.com:2408
Reserved = 12,34,56
如果没有自动弹出对话框，可能是因为设置中的 允许检测剪贴板 被关闭了，您可以重新打开，或者点击首页 连通性测试 下方的粘贴按钮，手动添加配置信息

协议类型

现阶段已支持的协议类型

Subscribe（订阅）、Shadowsocks、ShadowsocksR、Vmess、VLESS、Relay、Socks5、Socks5 Over TLS、HTTP、HTTPS、HTTP2、Trojan、Hysteria、Hysteria2、AnyTLS、TUIC、Juicity、SSH、WireGuard、Snell v1-3、Mieru、Brook、Lua

当前版本支持的协议可在 首页 > 右上角 ➕ > 类型 中查看

各协议节点的纯文本格式参见编写本地节点

更新订阅节点

订阅右滑 > 更新

点击首页的更新订阅按钮🔄

设置 > 订阅 > 打开时更新（刷掉后台，重新打开应用程序时会自动更新订阅）

设置 > 订阅 > 自动后台更新（需在系统 设置 > 通用 > 后台App刷新 中开启对 Shadowrocket 的允许，更新周期可设1-24小时）

Shadowrocket 提供了 更新订阅 的快捷指令，可以实现自动化操作

长按屏幕的应用图标 > 更新订阅

软件提供自动更新服务

若添加或更新订阅时出现异常，请参见订阅异常

节点排序

设置 > 订阅 > 根据 Ping 排序

该操作支持节点按照延迟测试后得到的延迟数值进行由低到高的自动排序

节点分享与整理

节点分享

长按节点 > 拷贝，可以把节点链接分享给其他设备

左滑节点 > 二维码，其他设备可以通过扫码添加节点（二维码页面点击右上角的分享按钮，可以选择其他形式传送二维码）

节点二维码缺乏统一标准。当使用其他代理工具扫码添加某些节点时，可能会丢失部分节点信息，导致不能连接。如果遇到此问题，请仔细检查同一个节点的各项配置信息是否一致

点击节点后面的 ⓘ 图标，滑动至页面底部，有多种分享节点的菜单

展开节点列表，点击连通性测试下方的编辑按钮 •••，勾选需要分享的节点，点击左上角的复制，可以把多个节点链接同时分享给其他设备

节点整理

调整顺序：点击编辑按钮 •••，或者长按首页右上角的 ➕，即可进入编辑模式，按住订阅或节点后面的 ≡ 图标可以调整订阅或节点之间的上下顺序（本地节点默认置顶位置）

节点分类：非订阅形式添加的节点，默认会归类为 本地节点。如果需要重新对本地节点进行分类，可以使用折叠功能。点击编辑按钮 •••，勾选节点，点击左上角的折叠，为新分类的节点组命名（折叠功能可以选择本地节点或者订阅节点）

删除节点：点击编辑按钮 •••，点击左上角的删除，可以选择删除全部节点或者删除连通性测试结果中的超时节点

滑动菜单：向右滑动订阅，可以选择测试当前订阅节点的连通性，或者更新当前订阅节点。向右滑动节点，点击测试可以获取单个节点的连通性测试结果，点击复制，可以在当前节点列表中新增一个同样配置信息的节点

订阅节点筛选

Shadowrocket 支持通过脚本或正则表达式对订阅节点进行筛选，从而实现更灵活的节点过滤与管理

首页 > 订阅后面的 ⓘ 图标 > 过滤

节点筛选
保留节点名称含有关键词 A 和 B 的节点：
/(?=.*(A))^(?=.*(B))^.*$/
保留节点名称含有关键词 A 或 B 的节点：
A|B
排除节点名称含有关键词 A 或 B 的节点：
/^((?!(A|B)).)*$/
保留节点名称含有关键词 A 并排除含有关键词 B 的节点：
/(?=.*(A))^((?!(B)).)*$/
分组、代理分组中的正则写法与上述【过滤】中使用的命令相同，但需删除前后 / 符号
批量整理
节点订阅筛选功能支持使用脚本代码批量整理和修改相应订阅中节点的功能选项及节点名称
批量给节点中的关键词 a 替换成 b：
$server.title=$server.title.replace(/关键词a/g,'关键词b')
批量给节点名称增加 abc 开头的关键词：
$server.title='abc'+$server.title
批量给节点名称增加 abc 结尾的关键词：
$server.title=$server.title+'abc'
批量开启全部节点的片段：
$server.reserved="1,40-60,30-50"
批量开启全部节点的多路复用：
$server.mux=1
批量设置全部订阅节点的代理链/链式代理/代理通过，以下两种方式以生效者为准
$server.chain="订阅名称/节点名称"
$server['dialer-proxy']="UUID值"
其中 UUID 值 可在中转节点或订阅的 JSON 文本中复制，第一种命令的 订阅名称/节点名称 也可以使用 UUID 值
当节点名称不包含地区标识，且节点地址有可以分辨地区的关键词时，可以使用以下脚本为节点名称批量添加地区关键词或旗帜标识
if (/节点地址关键词/i.test($server.host)) {
 $server.title = '需要添加的关键词或旗帜'+ $server.title
 return true;
}
其他命令

该功能也支持更复杂的脚本指令，可以参阅此处示例

代理通过/代理链

当前代理通过另一个代理进行连接，支持多级链式代理，但并非所有协议都支持通过代理链作为落地节点使用。使用代理链方法：

使用节点 A 连接，点击节点 A 后面的 ⓘ 图标，代理通过 选择节点 B，流量走向：Client > B > A > Web server

支持使用分组/代理分组作为中转代理

支持批量修改订阅节点的代理链，可实现同时部署多个节点的链式代理。具体命令可查看订阅节点筛选 > 批量整理中的相关指令

取消代理通过/代理链：点击开启该功能节点后面的 ⓘ 图标，代理通过 选择右上角的取消后保存

全局路由

配置：流量根据设定规则进行分配，有些通过节点连接，有些则不通过

代理：全部流量都通过同一个节点连接

直连：全部流量都不通过节点连接

场景：根据不同的网络连接类型（Wi-Fi、蜂窝数据）自动切换到预先设置的路由模式，并选择对应的配置文件和节点连接

连通性测试

点击首页的 连通性测试，节点列表将会显示以毫秒（ms）为单位的延迟数字，这是数据包的传输时间，不同的 延迟测试方法 对应不同的计算结果。长按首页的 连通性测试，可以临时调整测试方法，仅对本次测试生效

设置 > 延迟测试方法

TCP：建立 TCP 连接的往返时间

ICMP：发送 ICMP 回显请求报文和接收 ICMP 回显应答报文的往返时间

CONNECT：向测试 URL 发送一个 HTTP HEAD 请求，测量从发送请求到接收响应头部信息的往返时间

请优先选择 CONNECT，因为它更能准确反映节点的连通性。延迟大小与网络上传下载速度没有直接关系，测速请使用其他方法，如：https://www.speedtest.net

修改测试地址

用于首页和分组节点的延迟测试

设置 > 延迟测试方法 > URL 测试设置

首页 > 连通性测试后面的圆形图标 > URL 测试设置

用于代理分组内节点的延迟测试

点击配置文件的 ⓘ 图标 > 代理分组 > 编辑或添加包含自动测试类型的分组 > 最下方 URL 栏

场景

场景是根据不同的网络连接类型（Wi-Fi、蜂窝数据）自动切换到预先设置的路由模式，并选择对应的配置文件和节点连接

首页 > 全局路由 > 设置的场景 > 添加场景

为指定的网络连接类型设置对应的路由模式（配置、直连、代理），类型（节点、分组）、配置文件及备注

网络连接类型分别为：Wi-Fi、蜂窝数据、默认。选择Wi-Fi类型时，SSID需填写Wi-Fi名称

首页 > 全局路由 > 选择场景

软件支持添加蜂窝数据场景，支持以 网络接口 作为匹配条件

默认（留空）代表接口 pdp_ip0

当设备启用了多个蜂窝数据网络时，可在 Shadowrocket 的设置 > 诊断 > 网络中查看对应的接口信息

输入格式：pdp_ip1、pdp_ip2、pdp_ip3 等

首次添加场景，可能会弹出申请权限的对话框，具体原因请看权限。当没有允许定位权限时，场景列表的 ✅ 标记不会随着网络类型的切换而自动切换，但这不影响场景功能的正常生效

设置 > 隧道/按需求连接中的 包含所有网络 相关选项可能会对场景模式的生效造成影响

简单模式

简单模式是一种以相对简单的方式实现自动测试并选择延迟低的节点进行连接的设置模式。简单模式未来或不再维护，其功能已被 代理分组 所包含，建议使用代理分组替代简单模式

首页 > 全局路由 > 分组 > 简单模式

节点的范围是什么？

当开启简单模式，此时下方会出现分组选项，如果没有继续添加分组的操作，节点范围就是首页全部节点，如果添加分组，范围就变成分组里的节点

自动测试的周期是多久？延迟低的判断依据是什么？

设置 > 延迟测试方法 > URL测试设置，这里规定了测试的间隔时间，默认 600s，即表示每 10 分钟自动进行一次节点延迟测试。相邻两次测试结果中最小延迟值的对比，根据公差机制决定是否切换节点，公差越大，触发节点切换的频次越低，默认 0ms，即表示只要后面测试结果的最低延迟节点比前面测试结果的最低延迟节点延迟小就会自动切换

切换的节点给什么规则使用？

Shadowrocket 内置策略 proxy，简单模式时自动切换的节点使用于所有指向 proxy 策略的规则

简单模式是自动切换延迟低节点，代理分组的 url-test 类型也是自动切换延迟低节点，两者有何不同？

代理分组创建后，需要在规则中修改策略指向，而简单模式已经关联 proxy 策略，节省了修改规则的步骤
全局路由 选择代理时将导致所有 代理分组 失效，而简单模式依然能够实现自动切换节点

添加分组时的测速开关是什么作用？

开启测速，这个分组才允许自动切换节点。不开启测速，这个分组只能手动选择节点

启用回退

首页 > 全局路由 > 启用回退

启用回退 的功能是当节点连接失败时自动切换其他可用节点

连接失败3次才会触发回退机制

节点只满足可用性，不要求是最低延迟节点

随机切换，不按照节点顺序选择

策略为 proxy，节点切换范围就是首页全部节点，如果开启简单模式并选择分组，则范围缩小至分组内节点

策略为 非 select 类型 的分组/代理分组类型，节点切换范围就是分组或代理分组内节点

具体切换到哪个节点，请查看代理日志

配置页面

配置文件

📝 备注

Shadowrocket 的配置文件是用于快速设置和调整软件的核心功能的重要文件，通常以 *.conf 格式保存。配置文件还可以在多设备间同步以及分享配置文件给其他用户，以快速部署相同设置、简化用户手动配置的流程。用户可以在配置文件里设置通用参数、添加规则、Hosts、URL重写、HTTPS解密、脚本等内容。模块的写法与配置文件相同
同时，Shadowrocket 支持在配置文件中编写本地节点，但该操作方式仅是为了兼容部分其他类型的配置文件，不能当作 Shadowrocket 添加节点的优先选择

Shadowrocket 内置了一个默认配置文件 default.conf，其中包含了国内外主要网站或服务的分流规则，一般可以满足大多数用户的基本需求。此配置文件的内容跟随应用更新而做不定期的调整。如果在使用过程中错误修改或误删配置文件，可以点击 配置 > 恢复默认配置。

添加配置文件方法：

从 URL 下载配置

配置 > 右上角 ➕ > 粘贴配置链接 > 下载 > 点击对应的配置文件 > 使用配置 / 编译配置

Shadowrocket 兼容使用 Clash YAML 格式 的配置文件。使用含节点信息的标准 Clash 链接可以同时导入配置文件和节点信息

从本地存储或云盘导入

配置 > 从云导入，点击对应存储路径的配置文件

点击配置文件，显示操作菜单（以下选项可能因不同的软件版本而有所不同）：

使用配置

编辑配置

编辑纯文本

编译配置

预览配置

更新配置

扩展配置

重新命名

导出配置

点击配置文件的 ⓘ 图标或点击 编辑配置，进入编辑菜单（以下选项可能因不同的软件版本而有所不同）：

通用

规则

Hosts

URL重写

头部重写

正文重写

本地映射

HTTPS解密

脚本

代理分组

规则集URL

脚本URL

复制

替换策略

测试规则

使用配置

点击 使用配置 可以编译并启用该配置文件。该功能会对该配置使用的远程规则集、脚本等远程资源进行更新

编辑配置

使用 UI 交互界面对配置文件的可设置项进行调整。部分设置或命令不提供 UI 编辑界面，如有需要可在纯文本编辑中使用

编辑纯文本

使用纯文本模式对配置文件的可设置项进行调整。部分设置或命令不提供 UI 编辑界面，仅在纯文本模式下可以设置

配置文件的纯文本编写方法可以参考：

懒人配置

懒人配置（含策略组）

编译配置

点击 编译配置 可以对该配置文件进行重新编译。可以理解为软件将该配置文件重新编辑并转译为符合当前版本规范和逻辑的底层格式。该功能会更新该配置文件所用到的规则集、脚本等远程资源。仅当软件版本大于等于特定版本时才具有该选项

预览配置

查看配置文件的纯文本格式。该选项仅当配置文件是以远程配置文件的形式添加进来的才会出现

更新配置

使用当前配置文件的远程版本对当前文件进行覆盖更新。该选项仅当配置文件是以远程配置文件的形式添加进来时才会出现，该功能一般适用于在远端维护的配置文件或远程配置需要恢复时使用。除更新配置设置外该功能还会同时更新该配置所用的规则集、脚本等远程资源，若仅需要更新规则集等远程资源，请使用使用配置 / 编译配置功能。软件同时提供自动更新功能，相关说明及其他技巧请点击查看自动更新词条

🚨 注意

更新配置会覆盖在本地对配置文件所做的修改，对于在本地修改过的远程配置而言需要谨慎使用此功能

重新命名

重命名当前配置文件

导出配置

将当前配置文件以文件的形式导出

扩展配置

从配置 a 扩展出配置 b，此时默认关系是 b 包含 a，也可以理解为 b 继承了 a 的内容

配置 b 优先级高于配置 a，该功能是对配置建立包含关系，以满足同时使用多个配置的需求

点击配置文件的 ⓘ 图标 > 通用 > 包含配置，可以修改或解除包含关系

通用参数

通用参数是 Shadowrocket 的中最重要的功能参数，位于配置文件纯文本编辑模式中的 [General] 字段，该字段选项包含具有 UI 界面的设置项和不包含 UI 界面的隐式参数
UI 编辑：点击配置文件的 ⓘ 图标 > 通用

文本编辑：点击配置文件 > 编辑纯文本 > [General]

配置行的纯文本设置语法格式为 key = value
[General]
key = value
旁路系统 bypass-system

如果禁用此选项，可能会导致一些系统问题，如推送通知延迟

跳过代理 skip-proxy

跳过代理接口，使用 TUN 接口接管。此选项强制列表中的域名或 IP 的连接范围交由 Shadowrocket TUN 接口 来处理，而不是 Shadowrocket 代理接口。此选项用于提高部分应用程序对于代理环境的兼容性。若开启 TUN 模式时，将强制使用 TUN 接管所有连接，此处地址列表可以忽略。需要注意，该选项并非将设定的地址使用直连进行连接，仅表示使用 TUN 接口处理

TUN旁路路由 tun-excluded-routes

Shadowrocket TUN 接口 只能处理 TCP 协议。使用此选项可以绕过指定的 IP 范围，让其他协议通过

DNS覆写 dns-server

使用普通 DNS 或加密 DNS（如 doh、doq、dot 等）覆盖默认的系统 DNS。DNS 覆写仅针对直连类域名进行解析，代理类域名将经由代理服务器进行解析。DNS 覆写支持同时添加多个地址，Shadowrocket 采用并行查询的方式进行解析请求，最先返回的结果将被采用。有些 dns over https 支持 http3，所以将会尝试查询，如果支持就切换到 http3，可在 doh链接 后面加上 #no-h3 关闭。doh 强制通过 h3 查询的写法是将 https 改成 h3，如h3://dns.alidns.com/dns-query。其他示例或写法参见：修改DNS、DNS-over-PROXY

备用DNS fallback-dns-server

当覆写 DNS 查询失败或查询时间超过2秒，Shadowrocket 会自动回退备用 DNS。如需指定多个 DNS，可用逗号分隔。system 表示回退到系统 DNS，清空备用 DNS 等于将其设置为 system

启用IPv6支持 ipv6

false 表示不启用，true 表示启用。即使不启用此选项，当本地网络环境支持 IPv6，并且节点域名支持 IPv6 解析，Shadowrocket 也会使用节点的 IPv6 地址进行访问。解决方法是关闭节点域名的 IPv6 解析，或者在配置文件的 [Host] 项目下为节点域名指定 IP 地址

首选IPv6 prefer-ipv6

优先向 IPv6 的 DNS 服务器查询 AAAA 记录，优先使用 AAAA 记录。false 表示不启用

私有IP应答 private-ip-answer

如果不启用该选项，域名解析返回私有 IP，Shadowrocket 会认为该域名被劫持而强制使用代理

TUN包含路由 tun-included-routes

默认情况下，Shadowrocket 接口会声明自己为默认路由，但由于 Wi-Fi 接口的路由较小，有些流量可能不会通过 Shadowrocket 接口。使用此选项可以添加一个较小的路由表

总是真实IP always-real-ip

这个选项要求 Shadowrocket 在 TUN 处理 DNS 请求时返回一个真实的 IP 地址而不是假的IP地址

DNS劫持 hijack-dns

有些设备或软件总是使用硬编码的 DNS 服务器，例如 Netflix 通过 Google DNS（8.8.8.8 或 8.8.4.4）发送请求，您可以使用此选项来劫持查询

包含配置 include

表示当前配置包含另一个配置的内容，当前配置的优先级高于被包含配置。该选项是对配置建立包含关系，以满足同时使用多个配置的需求

隐式参数

🚨 注意

隐式参数是指相关选项仅支持在配置文件纯文本编辑模式中的 [General] 字段进行纯文本设置，不提供 UI 操作选项，属于通用参数的隐藏属性，建议谨慎设置。

隐式参数属于通用参数，设置语法格式为 key = value

dns-direct-system

直连的域名类规则使用系统 DNS 进行查询。设置为 true 表示启用，设置为 false 表示不启用

icmp-auto-reply

ping 数据包自动回复。设置为 true 表示启用，设置为 false 表示不启用

always-reject-url-rewrite

不开启时，「重写的REJECT策略」默认只有在配置模式下生效。开启后，可以令该策略在其他全局路由模式下都生效。设置为 true 表示启用，设置为 false 表示不启用

dns-direct-fallback-proxy

直连域名解析失败后使用代理。设置为 true 表示启用，设置为 false 表示不启用

udp-policy-not-supported-behaviour

当 UDP 流量匹配到规则里不支持 UDP 转发的节点策略时重新选择回退行为，可选行为包括 DIRECT、REJECT。DIRECT 表示直连转发 UDP 流量，REJECT 表示拒绝转发 UDP 流量

stun-response-ip

此选项包含两个命令：stun-response-ip 和 stun-response-ipv6。该选项允许返回一个虚假的IP地址，如 stun-response-ip=1.1.1.1、stun-response-ipv6=::1，目的是防止真实IP地址泄漏，提高 WebRTC 的隐私和安全性。使用此命令将忽略软件设置选项内的禁用STUN 的启用状态

compatibility-mode

网络兼容模式

compatibility-mode = 0 > 自动/禁用
compatibility-mode = 1 > Proxy with Loopback Address
compatibility-mode = 2 > Proxy Only
compatibility-mode = 3 > TUN Only
compatibility-mode = 4 > Proxy without Loopback Address
compatibility-mode = 5 > No Default Route

本设置的优先级高于软件设置内的相关选项。当参数的值设定为 3 时的效果等同于启用 Tun模式：设置 > 代理 > 代理类型 > None。当参数的值设定为 5 时的效果等同于启用兼容模式：设置 > 代理 > 兼容模式

always-ip-address

强制所有域名使用本地 DNS 解析。设置为 true 表示启用，设置为 false 表示不启用

proxy-dns-server

通过该参数来使用特定 DNS 解析所有节点域名。若未设置此参数，节点域名默认使用 dns-server 进行解析，对于 DNS-over-PROXY 则使用系统 DNS 解析

close-if-proxy-chain-missing

代理链丢失关闭连接。当设置为 true 时，若代理链中的中转节点丢失则 Reject 代理连接；当设置为 false 时等同于不设置该命令，即若代理链中的中转节点丢失则跳过中转节点直接连接落地节点使用

ipv6-only-if-no-ipv4-dns

当设置为 true 时，如果设备在网络环境中仅获取到 IPv6 的 DNS 而未获取到 IPv4 的 DNS，此时软件将认为网络环境是 IPv6 Only 网络。设置为 false 表示不启用

block-quic

QUIC协议屏蔽策略。支持使用 all-proxy、all、always-allow 对 QUIC 传输层协议进行设置。其中 all-proxy 表示只对 走代理的连接 阻断 QUIC，直连连接（DIRECT）不会被干预；all 表示对所有连接（包括直连与代理）都屏蔽 QUIC，这会完全禁止系统中一切 UDP/443 流量；always-allow 表示始终允许 QUIC，不做任何屏蔽，等同于 关闭 QUIC 屏蔽

use-local-host-item-for-proxy

本地 HOST 映射对代理生效。在默认情况下，对于代理类的 DNS 解析始终在远端服务器上执行。当设置为 true 时，若存在本地 DNS 映射，Shadowrocket 将在代理连接中使用映射后的地址，而不是原始的主机名。设置为 false 表示不启用

allow-dns-svcb

允许 DNS SVCB 查询。系统可能会执行 SVCB 记录 DNS 查询，而不是标准的 A 记录查询。这会导致无法返回虚拟 IP 地址。因此，默认情况下禁止执行 SVCB 记录查询，以强制系统执行 A 记录查询。设置为 true 表示启用，设置为 false 表示不启用

Shadowrocket 或还有其他支持的隐式参数，此处可能未能完全列出，若有相关需求请联系 buginapp@gmail.com

添加规则

在 Shadowrocket 中，“规则"是指用来决定哪些网络请求应该走代理、哪些请求应该直接连接互联网的规则集合。规则通常是基于用户的需求来配置规则策略，目的是实现对流量的精细控制。软件对规则集的识别不受文件后缀的影响，是以规则集的内容为识别标准

点击配置文件的 ⓘ 图标 > 规则 > 右上角 ➕，根据需求选择规则类型和规则策略，填写规则内容

数据 > 代理 > 启用日志记录，产生网络活动后回到该页面，从最近的日志中查看网络活动记录，点击任一记录查看详情，点击右上角 ••• 选择类型添加规则

规则匹配需要着重注意规则的优先级顺序

规则管理

配置 > 配置文件 > 编辑配置 > 规则 > 规则区域右上角 ···

可选择并批量删除规则

规则优先级

规则的匹配是从上到下逐条匹配的，一旦匹配到某条规则，Shadowrocket 就会停止继续匹配，因此规则的顺序非常重要，优先级高的规则应该放在前面

模块中的规则优先于配置文件

上面的规则优先于下面的规则

域名类的规则优先于IP类规则

此外，规则的优先级在自动编译配置时同时遵循 显式优先、推断其次、最终兜底 的原则。其中可被直接、精确匹配的显式规则（如 DOMAIN、DOMAIN-SUFFIX、URL-REGEX 等）具有最高优先级。而基于地域或数据库判断的推断类规则（如 GeoIP）会在自动编译过程中被放置在显式规则之后。FINAL 规则作为兜底项，始终位于整个规则集的最末尾

规则类型

DOMAIN-SUFFIX：匹配请求域名的后缀

如 DOMAIN-SUFFIX,example.com,DIRECT 可以匹配到 a.example.com、a.b.example.com

DOMAIN-KEYWORD：匹配请求域名的关键词

如 DOMAIN-KEYWORD,exa,DIRECT 可以匹配到 a.example.com、a.b.example.com

DOMAIN-WILDCARD：匹配请求域名，支持使用通配符 *、?

如 DOMAIN-WILDCARD,a*c.example*.com,DIRECT 可以匹配到 abc.example123.com、aqwec.example456.com

DOMAIN：匹配请求的完整域名。当为DOMAIN、DOMAIN-SUFFIX、DOMAIN-KEYWORD 等相似类型分别设置相同的值时，只有其中一种类型会生效

如 DOMAIN,www.example.com,DIRECT 只能匹配到 www.example.com

USER-AGENT：匹配用户代理字符串，支持使用通配符 *

如 USER-AGENT,MicroMessenger*,DIRECT 可以匹配到 MicroMessenger Client

URL-REGEX：匹配 URL 正则式

如 URL-REGEX,^https?://.+/item.+,REJECT 可以匹配到 https://www.example.com/item/abc/123

IP-CIDR：匹配 IPv4 或 IPv6 地址

如 IP-CIDR,192.168.1.0/24,DIRECT 可以匹配到 IP 段 192.168.1.1～192.168.1.254。当域名请求遇到IP类规则时，Shadowrocket 会向本地 DNS 服务器发送查询请求，以判断主机 IP 是否匹配规则。若 IP 类规则加 no-resolve（如：IP-CIDR,172.16.0.0/12,DIRECT,no-resolve），则域名请求将会跳过此规则，不会触发本地DNS查询

IP-ASN：匹配 IP 地址隶属的 ASN 编号

如 IP-ASN,56040,DIRECT 可以匹配到属于 China Mobile Communications Corporation 网络的 IP 地址

RULE-SET：匹配规则集内容。规则集的组成部分需包含规则类型

DOMAIN-SET：匹配域名集内容。域名集的组成部分不包含规则类型

SCRIPT：匹配脚本名称

DST-PORT：匹配目标主机名的端口号

如 DST-PORT,443,DIRECT 可以匹配到 443 目标端口

GEOIP：匹配 IP 数据库

如 GEOIP,CN,DIRECT 可以匹配到归属地为CN的IP地址

FINAL：兜底策略

如 FINAL,PROXY 表示当其他所有规则都匹配不到时才使用 FINAL 规则的策略

AND：逻辑规则，与规则

如 AND,((DOMAIN,www.example.com),(DST-PORT,123)),DIRECT 可以匹配到 www.example.com:123

NOT：逻辑规则，非规则

如 NOT,((DST-PORT,123)),DIRECT 可以匹配到除了 123 端口的其他所有请求

OR：逻辑规则，或规则

如 OR,((DST-PORT,123),(DST-PORT,456)),DIRECT 可以匹配到 123 或 456 端口的所有请求

PROTOCOL：匹配传输协议类型

PROTOCOL 类型不支持单独使用，只能作为子规则类型嵌套于逻辑规则当中。如 AND,((PROTOCOL,UDP),(DST-PORT,443)),REJECT-NO-DROP

规则策略

PROXY：代理。通过代理服务器转发流量

DIRECT：直连。连接不经过任何代理服务器

REJECT：拒绝。返回 HTTP 状态码 404，没有内容

REJECT-DICT：拒绝。返回 HTTP 状态码 200，内容为空的JSON对象

REJECT-ARRAY：拒绝。返回 HTTP 状态码 200，内容为空的JSON数组

REJECT-200：拒绝。返回 HTTP 状态码 200，没有内容

REJECT-IMG：拒绝。返回 HTTP 状态码 200，内容为 1 像素 GIF

REJECT-TINYGIF：拒绝。返回HTTP状态码200，内容为 1 像素 GIF

REJECT-DROP：拒绝。丢弃 IP 包

REJECT-NO-DROP：拒绝。返回 ICMP 端口不可达

除此之外，规则策略还可以选择分组、代理分组、订阅、服务器节点 等

策略扩展参数

Extended Matching：扩展匹配。代表将尝试同时匹配 SNI 和 HTTP 主机标头。适用于 DOMAIN、DOMAIN-SUFFIX、DOMAIN-KEYWORD 等域名规则。Shadowrocket 默认支持 extended-matching，已默认开启 SNI 匹配

Pre Matching：预匹配功能，可以快速、低开销地拒绝请求。对于使用 REJECT 策略的规则，可以通过 pre-matching 标记启用此功能预匹配。启用此参数的规则将在正常规则匹配过程之前生效，具有最高优先级

纯文本示例：
[Rule]
DOMAIN,ad.com,REJECT,extended-matching,pre-matching

APP分流

根据不同 App 或特定服务指定分流规则，并使其按照设定的规则执行代理策略

示例：YouTube App 分流走代理
复制 YouTube 的规则集链接
https://raw.githubusercontent.com/blackmatrix7/ios_rule_script/master/rule/Shadowrocket/YouTube/YouTube.list
点击配置文件的 ⓘ 图标 > 规则 > 右上角 ➕，规则类型选择 RULE-SET，规则策略选择 PROXY，输入框内粘贴 规则集链接，保存完成（规则策略可以根据需求使用其他选项或节点）
iOS系统没有常规分应用代理的操作，只能通过 域名 / ip / ua 规则实现app分流效果。可自行抓包，或者订阅 blackmatrix7 的规则集。如果引用的链接是域名集，添加规则时，规则类型请选择 DOMAIN-SET

更新规则集

手动更新：点击配置文件 > 使用配置 / 编译配置

自动更新：自动更新

预览规则集

点击配置文件 > 编辑配置 > 规则 > 在规则集上左滑 > 预览

修改DNS

DNS覆写
点击配置文件 ⓘ 图标 > 通用 > DNS 覆写

DNS 覆写仅针对直连类域名进行解析，代理类域名将经由代理服务器进行解析。DNS 覆写为并发查询，若填写多个 DNS 服务，则使用最快返回的解析结果。填 system 表示使用系统 DNS，支持普通 DNS 或加密 DNS（如 DoH、DoQ、DoT 等），也支持使用通过代理转发 DNS 查询请求

普通 DNS 示例
dns-server = 223.5.5.5,119.29.29.29
加密 DNS 示例

DNS-over-HTTPS（DoH）
dns-server = https://dns.alidns.com/dns-query
DNS-over-HTTP/3（DoH3）
dns-server = h3://dns.alidns.com/dns-query
DNS-over-QUIC（DoQ）
dns-server = quic://223.5.5.5
DNS-over-TLS（DoT）
dns-server = tls://223.5.5.5
DNS-over-PROXY
备用DNS

当覆写的 DNS 查询失败或查询时间超过2秒后回退备用 DNS 进行查询。如需指定多个 DNS，可用逗号分隔。填写 system 或者留空表示可回退到系统 DNS

DNS-over-PROXY

通过代理转发 DNS 查询请求

proxy
支持使用 默认节点 转发 DNS 查询请求，有以下两种写法：
dns-server=https://dns.google/dns-query#proxy
dns-server=https://dns.google/dns-query#proxy=proxy
proxy=name
支持使用 指定节点 转发 DNS 查询请求，需要注意此处的代理名称仅支持 URL 编码，以 香港 01 示例：
dns-server=https://dns.google/dns-query#proxy=%E9%A6%99%E6%B8%AF%2001
此处指定的节点若填写不规范会自动回退至默认节点
ecs=子网范围
ecs 参数用于设置 EDNS Client Subnet (ECS)，向 DNS 服务器传递客户端的子网信息。ECS 允许 DNS 服务器根据指定的子网范围（而非实际客户端 IP）来返回最优结果

示例：
dns-server=https://dns.google/dns-query#ecs=120.76.0.0/14|2620:149:af0::10/56&ecs-override=true
ecs-override=true
ecs 参数的强制覆盖。即使客户端的实际 IP 提供了不同的地理位置，查询会强制使用 ecs 指定的子网范围

示例：
dns-server=https://dns.google/dns-query#proxy=name&ecs=1.1.0.0/14|2620:149:af0::10/56&ecs-override=true

no-resolve的作用

当域名请求遇到 IP 类规则时，Shadowrocket 会向本地DNS服务器发送查询请求，以判断主机 IP 是否匹配规则
若IP类规则加 no-resolve，则域名请求将会跳过此规则，不触发本地 DNS 查询。如：
IP-CIDR,172.16.0.0/12,DIRECT,no-resolve

代理分组

代理分组 也可称之为 策略组，是用来 灵活管理和切换不同代理节点、自动分流网络请求 的一种核心功能。它的作用类似于一个 智能路由系统，可以根据设定的规则将不同的流量导向不同的代理节点或行为。简单来说，它就是一个容器，里面可以包含多个代理节点或其他代理分组。你可以根据需求通过 规则 → 代理分组 → 代理节点 的路径手动或自动切换。代理分组支持的类型可以查看：代理分组类型

点击配置文件的 ⓘ 图标 > 代理分组 > 右上角 ➕。填写名称，根据需求选择代理分组类型，通过正则匹配策略，或者从策略输入框后面的 ••• 手动添加策略，保存

策略是规则的组成部分，创建的代理分组只有放到规则里才能发挥作用

进入对应规则的详情页，点击策略选项，从列表中选择所需的代理分组，保存

代理分组中可以包含其他代理分组，形成层级结构，但需要注意各级代理分组的类型

代理分组内的右上角设有测试按钮，点击测试可对当前分组内的节点进行延迟测试。测试按钮仅支持对节点进行测试，不支持测试分组内的其他策略

代理分组下方设有 测试并选择最快服务器 选项

该选项开启后，将在手动点击右上角的测试后自动选择并使用延迟最低的节点

该选项的开启或关闭对全部代理分组同时生效

该选项仅存在于版本号大于等于 2.2.65 (2604) 的软件上

代理分组内设有订阅开关，开启开关会在下方出现 服务器节点 选项，需要进入选择所需要的订阅

开启订阅开关并选择所需订阅后，下方策略内会出现该订阅的所有节点

支持同时使用正则表达式对节点进行筛选，筛选范围受限于所选择的订阅

快捷进入代理分组

首页下拉，可以快捷进入代理分组界面

首页本地节点上方设有指示牌图标，点击该图标可以快捷进入代理分组界面，软件版本需大于等于 2.2.65 (2614)

代理分组其他设置参数

interval：测试周期。指定间隔多长时间后需要重新发起测试

timeout：超时时间。如果测试在超时前未完成，放弃测试

tolerance：公差。只有当新优胜者的分数高于旧优胜者的分数加上公差时，才会进行线路更换

url：测试地址。指定要测试的URL

hidden：隐藏代理分组

代理分组类型

select：允许用户手动选择一个子策略，可以指定其他代理分组或代理服务器。纯文本中设置为 0 表示第一个策略，1 表示第二个策略，2 表示第三个策略，以此类推

url-test：根据设定的自动测试周期和结果自动切换延迟最低的节点

fallback：节点不可用时自动切换其他可用节点，可用节点范围被上次自动测试结果所限

load-balance：不同规则的请求使用分组里的不同节点进行负载均衡，相同的域名会使用同一个节点

random：随机使用分组里的不同节点进行连接，相同的域名可能使用不同的节点，该类型也可以用作负载均衡

除 select 类型外，其余代理分组类型均基于自动测试机制运行。当连接命中此类分组时，系统将优先使用最近一次测试结果选定的节点，并按照该分组的设定执行下一轮测试

在两次测试间隔期间，若当前节点状态发生变化（例如节点变为不可用），可能出现仍使用失效节点的情况。对此，可酌情使用 启用回退 功能，以在节点异常时保障连接可用性。但需要详细阅读回退功能的详细说明

自动测试类型的代理分组允许用户在界面中临时手动选择了该类分组所包含的节点，但实际连接行为仍受分组自身设置约束，且 UI 中显示的测试结果并不影响该分组在背景中的自动测试，代理分组将继续根据自动测试结果自动发生切换。基于上述特性，除 select 类型外，不建议在此类代理分组中嵌套包含其他代理分组，以避免服务器节点选择逻辑复杂化或出现不符合预期的切换行为

隐藏代理分组

自 Shadowrocket Version 2.2.66 (2649) 版本开始，新增参数 hidden=1，可用于在图形界面隐藏不希望展示的代理分组。当 hidden 设置为数值 1 时，表示隐藏当前代理分组；当设置为 0 时表示不隐藏，等同于不设置此参数。该功能仅提供纯文本编辑设置方式，无图形设置界面

示例：
香港节点 = url-test,HK 01,HK 02,HK 03,policy-select-name=HK 01,interval=600,tolerance=100,timeout=5,url=http://www.gstatic.com/generate_204,hidden=1

负载均衡

代理分组类型中的 load-balance、random 表示将连接请求随机使用分组里的节点进行连接，能够尽可能将流量平均分配给所有子策略或代理。其中 load-balance 会将相同的域名使用同一个节点进行连接，random 会将所有请求使用随机节点进行连接，不区分是否是同一个域名

使用负载均衡的方法：

点击配置文件的 ⓘ 图标 > 代理分组 > 右上角 ➕，类型选择 load-balance 或者 random

规则集URL

配置 > 配置文件 > 编辑配置 > 规则集 URL

当前使用的所有远程规则资源的展示页面，其后显示的数字为当前成功下载的数量和总共包含的数量。进入后所显示的 ✅ 表示当前规则下载成功，❎ 表示当前规则下载失败。点击相应地址可重新拉取并弹出状态提示，但不会重新编译更新配置文件，点击使用配置 / 编译配置，可以对当前所有 URL 进行更新并重新编译更新配置文件

脚本URL

配置 > 配置文件 > 编辑配置 > 脚本 URL

当前使用的所有远程脚本资源的展示页面，其后显示的数字为当前成功下载的数量和总共包含的数量。进入后所显示的 ✅ 表示当前脚本下载成功，❎ 表示当前脚本下载失败。点击相应地址可重新拉取并弹出状态提示，但不会重新编译更新配置文件，点击使用配置 / 编译配置，可以对当前所有 URL 进行更新并重新编译更新配置文件

复制配置文件

配置 > 点击配置文件 > 编辑配置 > 复制

点击该选项可将当前配置生成一份备份并命名为 *-copy.conf

替换策略

配置 > 点击配置文件 > 编辑配置 > 替换策略

点击查找右侧的 ⓘ 图标选择准备替换的策略，或输入准备替换的策略

点击替换右侧的 ⓘ 图标选择欲替换成的策略，或输入欲替换成的策略

点击完成后替换完成

测试规则

配置 > 测试规则

配置 > 点击配置文件 > 编辑配置 > 测试规则

基于当前配置进行规则策略测试

Hosts

Shadowrocket 支持本地自定义 DNS 映射。包含 本地值 和 DNS服务器 两种设定方式。在纯文本编辑模式中位于配置文件的 [Host] 字段。在默认情况下，对于代理类的 DNS 解析始终在远端服务器上执行，支持使用 use-local-host-item-for-proxy 等隐式参数

UI 编辑：点击配置文件的 ⓘ 图标 > Hosts

文本编辑：点击配置文件 > 编辑纯文本 > [Host]

编辑示例：

将特定域名映射到指定 IP 地址，绕过 DNS 解析，直接控制域名到 IP 的对应关系
example.com = 1.2.3.4

将特定域名指定特定的 DNS 服务器进行解析
example.com = server:1.2.3.4

URL重写

修改 HTTP(S) 请求/响应，动态拦截并修改请求的 URL 或内容，在纯文本编辑模式中位于配置文件的 [URL Rewrite] 字段。重写类型包含 HEADER、302、307 以及其他支持的代理策略。支持使用 always-reject-url-rewrite 等隐式参数

UI 编辑：点击配置文件的 ⓘ 图标 > URL重写

文本编辑：点击配置文件 > 编辑纯文本 > [URL Rewrite]

头部重写

支持 请求头/响应头 重写功能，即标头重写，包含 del、add、replace、replace-regex 几种操作。在纯文本编辑模式中位于配置文件的 [Header Rewrite] 字段

UI 编辑：点击配置文件的 ⓘ 图标 > 头部重写

文本编辑：点击配置文件 > 编辑纯文本 > [Header Rewrite]

类型：

http-request：作用于请求头
http-response：作用于响应头

行为：

header-del：从请求头或响应头中删除指定字段
header-add：向请求头或响应头中添加字段及其对应的值
header-replace：在请求头或响应头中替换指定字段的值
header-replace-regex：使用正则表达式在请求头或响应头中替换字段的值

表达式：

正则表达式用于匹配目标网站的 URL

常用字段：

Content-Type、User-Agent、Accept-Language、Authorization、Host、Referer、Cookie、X-Forwarded-For、Location 等

正文重写

支持 请求体/响应体 重写功能，支持使用 jq 语法。在纯文本编辑模式中位于配置文件的 [Body Rewrite] 字段

UI 编辑：点击配置文件的 ⓘ 图标 > 正文重写

文本编辑：点击配置文件 > 编辑纯文本 > [Body Rewrite]

类型：

http-request：作用于请求体
http-response：作用于响应体
http-request-jq：使用 jq 语法处理请求体
http-response-jq：使用 jq 语法处理响应体

表达式：

正则表达式用于匹配目标网站的 URL

本地映射

支持 本地映射 功能，在纯文本编辑模式中位于配置文件的 [Map Local] 字段

UI 编辑：点击配置文件的 ⓘ 图标 > 本地映射

文本编辑：点击配置文件 > 编辑纯文本 > [Map Local]

类型：

text：返回文本类型响应
file：返回文件类型响应。文件内容不一定是本地文件，支持引用远程文件地址
tiny-gif：返回一个 1x1 像素的 GIF 图片
base64：返回 base64 编码数据类型响应

表达式：

正则表达式用于匹配目标网站的 URL

数据：

填写所需返回的数据

额外请求头：

可选返回额外请求头

HTTPS解密

对正在使用的配置开启 HTTPS 解密才能使包含 MITM 的模块完整生效，不包含 MITM 的模块除外

打开HTTPS解密方法：

点击配置文件的 ⓘ 图标 > HTTPS 解密 > 证书 > 生成新的 CA 证书 > 安装证书

系统设置 > 已下载描述文件 > 安装

系统设置 > 通用 > 关于本机 > 证书信任设置 > 开启对应 Shadowrocket 证书信任

自版本 2.2.81 (3096-3099) 起支持通过 HTTP/2 协议进行中间人攻击来解密 HTTPS 流量

点击配置文件的 ⓘ 图标 > HTTPS 解密 > 通过 HTTP/2 进行中间人攻击（MitM）

或者在配置文件、模块纯文本模式中的 [MITM] 字段中使用 h2 = true 表示启用

若模块中包含此命令，则会覆盖配置文件中的相关设置

HTTPS解密仅对启用此功能的配置文件生效，若切换或更换配置文件需要对新配置文件重新开启解密，为避免重复安装证书可使用证书模块

若多终端经 iCloud 使用同一个配置文件，需要使用证书 ⓘ 图标的复制粘贴功能将同一个证书在多个终端上进行安装信任

脚本

使用 JavaScript 拓展 Shadowrocket 的功能，在纯文本编辑模式中位于配置文件的 [Script] 字段

UI 编辑：点击配置文件的 ⓘ 图标 > 脚本

文本编辑：点击配置文件 > 编辑纯文本 > [Script]

类型：

http-request：使用脚本修改 HTTP 请求
http-response：使用脚本修改 HTTP 响应
event：在指定事件发生时运行脚本
rule：使用脚本作为规则使用
dns：使用脚本作为DNS 解析器
cron：在指定时间运行脚本

引擎：

auto：自动选择脚本引擎
jsc：适用于小型、简单、频繁调用的脚本，例如规则、DNS等
webview：适用于复杂、高内存需求的脚本，例如解析 MB 级别的 JSON

若脚本类型为 http-request 或 http-response，则在配置 engine=auto 参数时，系统将默认调用 WebView 引擎，而非 JSC 引擎。因此，从使用规范与一致性角度考虑，该参数建议明确指定类型，以确保行为符合预期

其他参数：

参见软件内的具体选项及释义

脚本文本示例如下：
[Script]
script = type=rule,script-path=rule.js

模块

模块是指为 Shadowrocket 提供额外功能的插件或者扩展项，一般是以增强或自定义软件的使用体验为出发点。模块的写法与配置文件相同，且模块的规则优先级高于配置文件。一般情况下，模块仅包含完整配置文件格式中的特定部分，以实现特定的特殊效果且不影响配置文件的其他功能。用户可以在模块里另外设置通用参数以及添加规则、Hosts、URL重写、证书内容、解密主机名、脚本等内容

下载远程模块

配置 > 模块 > 右上角 ➕ > 填写链接 > 下载

本地新建模块
配置 > 模块 > 新建模块 > 编辑后保存

模块 [MITM] 部分需要加 %APPEND%，表示把内容插入到配置中，不加时会覆盖配置中对应内容，并影响其他模块功能
[MITM]
hostname = %APPEND% 主机名
模块管理

配置 > 模块 > 模块区域右上角 ···

可以对模块顺序进行重新排序，并可以选择并批量删除/启用/禁用选定的模块

备注

对正在使用的配置开启 HTTPS 解密或使用证书模块，才能使包含 MITM 的模块完整生效，不包含 MITM 的模块除外

因模块可能包含不同规则，所以大多数模块仅在全局路由设为配置时生效，不包含规则类的模块除外

iOS 15 之后，NE的内存限制由 15 MB 增加到了 50 MB，低版本系统可能因内存不足导致模块失效或 VPN 自动断开

若出现以下问题可以查看相应说明：模块消失、模块失效

编辑参数

配置 > 模块 > 点击模块 > 编辑参数 > 按需填写或修改

Shadowrocket 的 编辑参数 / 传递参数 功能，是用于对请求或响应中的参数进行动态修改的一个高级功能，可用于配合模块中的 URL Rewrite、Script、MITM 等代码使用，目的是实现对网络请求的精准控制与定制化处理。编辑参数所修改或填写的内容不会因为模块更新而丢失，若开启了 iCloud，其自定义参数保存在 iCloud - Shadowrocket - Modules 内与模块同名的 *.meta 文件内

示例：
#!name=证书模块
#!desc=需要以编辑参数的方式启用并填写完整
#!arguments=证书模块:false, 证书内容:此处粘贴有效的证书内容, 证书密码:此处粘贴有效的证书密码
#!arguments-desc=证书模块：启用并填写证书内容方可生效\n\n证书内容：粘贴自有效证书\n\n证书密码：若默认密码是Shadowrocket则可不动

[MITM]
enable={{{证书模块}}}
ca-passphrase={{{证书密码}}}
ca-p12={{{证书内容}}}

证书模块

在实际使用软件时如果需要切换或更换配置文件，且原配置已开启过 HTTPS 解密，则需要对新的配置文件重新安装并信任证书，才可使解密继续生效。为免除重复安装 CA 证书，可以选择使用证书模块。证书模块是一组手动添加已生效解密证书的模块，由于模块的优先级高于配置文件，可以使解密状态不受更换配置的影响。其原理参见：模块
新建模块：

软件 配置 > 模块 > 新建模块，复制以下内容并粘贴进去保存备用：
#!name=证书（名字可更改）
[MITM]
enable=true

# 在下方 “ca-passphrase=” 后面粘贴证书密码
ca-passphrase=

# 在下方 “ca-p12=” 后面粘贴证书内容
ca-p12=
点击「已安装证书的配置文件」后面的 ⓘ 图标 > HTTPS 解密 > 证书后面的 ⓘ 图标 > 复制

将复制的证书内容粘贴至第一步创建的证书模块内的 ca-p12= 后面保存
证书模块原本可以省略 ca-passphrase 这行参数。但由于引用的配置文件可能已经包含了证书密码，且证书密码可能不是 Shadowrocket，为防止出错，因此才增加 ca-passphrase 参数来覆盖引用的配置文件的证书密码

身份证书密码

Shadowrocket 安装 CA 证书时，如果遇到「输入证书 身份证书 的密码」页面，可以尝试输入：Shadowrocket

编写本地节点

Shadowrocket 支持在配置文件中编写本地节点，但该操作方式仅是为了兼容部分其他类型的配置文件，不能当作 Shadowrocket 添加节点的优先选择

Shadowsocks类型

节点名称=ss,地址,端口,password=密码,其他参数(如method=aes-256-cfb,obfs=websocket,plugin=none)

Vmess类型

节点名称=vmess,地址,端口,password=密码,其他参数(如alterId=0,method=auto,obfs=websocket,tfo=1)

VLESS类型

节点名称=vless,地址,端口,password=密码,tls=true,其他参数(如obfs=websocket,peer=example.com)

HTTP/HTTPS/Socks5/Socks5 Over TLS等类型

节点名称=http,地址,端口,用户,密码节点名称=https,地址,端口,用户,密码节点名称=socks5,地址,端口,用户,密码节点名称=socks5-tls,地址,端口,用户,密码,skip-common-name-verify=true

Trojan类型

节点名称=trojan,地址,端口,password=密码,其他参数(如allowInsecure=1,peer=example.com)

Hysteria类型

节点名称=hysteria,地址,端口,auth=密码,obfsParam=混淆,protocol=协议,udp=1,其他参数(如peer=example.com,alpn=h2,upmbps=100,downmbps=100)

Hysteria2类型

节点名称=hysteria2,地址,端口,auth=密码,obfsParam=混淆,udp=1,其他参数(如peer=example.com,alpn=h3)

TUIC类型

节点名称=tuic,地址,端口,password=密码,udp=1,其他参数(如user=uuid值,peer=example.com,alpn=h2)

Juicity类型

节点名称=juicity,地址,端口,password=密码,udp=1,其他参数(如user=uuid值,peer=example.com,alpn=h2)

WireGuard类型

节点名称=wireguard,地址,端口,privateKey=私钥,publicKey=公钥,ip=子网IP,udp=1,其他参数(如dns=1.1.1.1,mtu=1350,keepalive=40,reserved=1/2/3)

Snell v2 类型

节点名称=snell,地址,端口,password=密码,udp=1,其他参数(如obfs=http,obfs-host=example.com,obfs-uri=/abc)

数据页面

代理日志

代理日志 记录了网络活动过程中 Shadowrocket 处理请求的具体信息

数据 > 代理 > 启用日志记录

产生网络活动时，返回 数据 > 代理 页面查看日志文件

每条记录包含信息：

请求 URL

请求匹配的规则策略

请求传输协议

请求发送时间

记录显示 MITM，表示请求域名已启用解密

点击每条记录查看详情，详情页右上角 ••• 可以选择类型添加规则

数据 > 代理 页面，右上角 ••• 可以手动删除所有日志文件。日志文件页面，右上角 ••• 可以选择导出

数据 > 自动删除 > 打开，程序会自动删除7天前的日志文件。Shadowrocket 已连接状态，手动删除将保留最新的日志文件，未连接时，手动删除所有

DNS日志

DNS 日志 记录了网络活动过程中 DNS 服务器处理域名查询请求的具体信息

数据 > 代理 > DNS > 启用日志记录

产生网络活动时，返回 数据 > DNS 页面查看日志文件

每条记录包含信息：

请求域名

查询结果

DNS 响应时间

处理请求的 DNS

旗帜是根据返回IP地址的地理位置信息自动显示

覆写 DNS 不可用或未返回有效响应时，将回退至 备用 DNS 来查询域名

记录信息中如果响应时间超过2秒，意味着系统正在触发回退机制

iCloud自动同步

Shadowrocket 支持将服务器节点、配置文件、模块和脚本文件等数据类型自动同步至 iCloud 云端

数据 > iCloud > 自动同步 > 打开

设备 设置 > 账号 > iCloud，确保使用 iCloud 的 APP 列表中已经开启 Shadowrocket 和 iCloud 云盘 项目，否则会出现 iCloud 自动同步失败 的提示

同步成功时，点击 iCloud 文件 可以看到存储云端的配置文件

文件app > iCloud 云盘 > Shadowrocket，可以看到存储云端的所有数据。其中的 shadowrocket.v2.model 文件包含服务器节点的配置信息

iCloud 服务中断、网络连接问题以及其他复杂原因可能导致 iCloud 同步异常，这种情况建议选择手动删除 iCloud 备份并重新同步数据

如果用户删除首页某个节点后发现它又自动恢复，可以尝试以下解决方法：数据 > iCloud，服务器节点下面点击删除 iCloud 备份和同步服务器节点

添加的场景和分组不属于 iCloud 自动同步的数据类型，需要手动备份下载，才能在设备间共享数据

💡 提示

由于 iCloud 的同步机制存在一定限制，在使用 iCloud 进行多设备数据同步时，建议采用以下方式：

主设备：开启自动同步

副设备：保持关闭自动同步，仅在需要更新数据时手动执行同步操作

这种方式可以有效降低多设备同时同步所导致的数据冲突或覆盖问题

节点数据管理

导出节点：将首页的所有节点数据整合成一个 JSON 文件，选择存储在本地或云端，也可以通过其他共享方式传输文件

导入节点：将存储在本地或云端 JSON 文件中的节点数据解析并添加到首页

删除本地节点：一键删除首页所有节点数据

流量统计信息

统计是 Shadowrocket 开启连接后接管设备所有网络传输的流量统计信息

数据 > 统计

统计包含信息：

开始时间

连接时间

Wi-Fi 和蜂窝数据的上下行流量

流量分流的柱形图统计

默认记录所有流量统计信息。打开 启用存档 将会单独记录每一次连接的流量统计信息，关闭首页连接后可以从归档查看

点击右上角 ••• 可以重置统计信息

首页订阅支持显示流量统计信息

方法一，订阅链接添加响应头：subscription-userinfo: upload=xxx; download=xxx; total=xxx; expire=xxx

方法二，在订阅链接指向的纯文本 base64 编码前添加 STATUS=xxx 或 REMARKS=xxx 字段，这样订阅名称下方就能显示自定义信息。如果没有添加字段或者隐藏用户代理字符串，可能导致不返回相关统计信息，只显示时间

设置页面

延迟测试方法

详见词条连通性测试

小组件

设置 > 小组件

服务器节点：根据需求添加6个常用节点，点击 Today 小组件 右上角的 > 可以展开查看，方便手动切换节点

显示Ping值：启用后，长按 Today小组件 中心位置可以测试 服务器节点 连通性并显示延迟数字

根据Ping排序：启用后，长按 Today小组件 中心位置可以测试 服务器节点 连通性并依延迟大小自动排序

添加小组件方法：

Today 小组件

负一屏 > 编辑 > 自定 > 点击 Shadowrocket 旁边的添加按钮 ➕。（系统要求低于 iOS 18）

屏幕小组件

长按屏幕 > 左上角 ➕ > Shadowrocket，选择合适类型添加。（系统要求≥ iOS 17）

更新 Shadowrocket 后，如果找不到小组件添加按钮，请尝试重启手机。如果小组件显示 无法加载，请尝试以下方法：

系统设置 > 通用 > 语言与地区，添加或删除一种其他语言

颜色

设置 > 颜色

Shadowrocket 支持自定义设置软件配色方案，可以根据个人喜好调整各个板块的颜色，并可以随时恢复默认颜色。同时支持分享和安装已有配色方案，配色案例参考此处

配色安装方法：复制已知的配色链接，在配置页面点击 ➕ 号粘贴安装

外观：支持匹配系统的自动色彩方案，以及深色、浅色模式

传统样式：使用传统应用样式

颜色：自定义设置颜色，编码为 十六进制颜色编码（Hex Color Code）

重设颜色：恢复默认配色

复制网址：复制当前配色的 URL 地址，可用以分享或保存

以下为软件配色项目的名称及其中文译名，需要注意因系统限制，部分项目不可自定义

NavigationBarColor / 导航栏背景色
NavigationBar2Color / 导航栏背景色2
NavigationBarTextColor / 导航栏文字颜色
NavigationBar2TextColor / 导航栏文字颜色2
TabBarColor / 标签栏背景色
TabBarBorderColor / 标签栏边框颜色
TabBarSelectedColor / 标签栏选中项颜色
TabBarUnselectedColor / 标签栏未选中项颜色
TableBackgroundColor / 表格背景颜色
TableCellBackgroundColor / 表格单元格背景颜色
TableCellSelectedBackgroundColor / 表格单元格选中项背景颜色
TableSeparatorColor / 表格分隔线颜色
TextFieldTextColor / 文本框文字颜色
PlaceholderColor / 占位符颜色
TextLabelTextColor / 文本标签文字颜色
DetailLabelTextColor / 详细标签文字颜色
TextLabelDeleteColor / 文本标签删除文字颜色
HeaderFooterTextColor / 页眉页脚文字颜色
SearchFieldBackgroundColor / 搜索框背景颜色
IndicatorColor / 指示器颜色
ButtonIconColor / 按钮图标颜色
ButtonNormalColor / 按钮正常状态颜色
ButtonNormal2Color / 按钮正常状态颜色2
ButtonNormal3Color / 按钮正常状态颜色3
ButtonHighlightedColor / 按钮高亮状态颜色
ButtonHighlighted2Color / 按钮高亮状态颜色2
ButtonHighlighted3Color / 按钮高亮状态颜色3
ButtonDisabledColor / 按钮禁用状态颜色
ButtonDisabled2Color / 按钮禁用状态颜色2
PingSuccessTextColor / 测试Ping成功文字颜色
PingTimeoutTextColor / 测试Ping超时文字颜色
DefaultDotColor / 默认指示点颜色
HUDBackgroundColor / 弹窗HUD背景颜色

按需求连接

始终开启

VPN 保持连接状态。意外断开或者重启设备，也会自动连接

脚本 / 模块 / 解密 等需求比较多时建议开启

按需求连接

根据添加的 按需求规则 自动切换 VPN 状态。默认规则是任意网络类型下保持连接状态，相当于 始终开启

按需求规则：

当访问列表中的域名时，系统会向 Shadowrocket 发送请求，如果响应成功，VPN 自动连接

网络中指定的 DNS（通常认为是网络运营商/Wi-Fi路由器提供的 DNS 服务器地址）与列表任一内容相匹配时，VPN 自动连接或断开

SSIDS 填写需要匹配的 Wi-Fi 名称

VPN 连接行为可以通过 网络类型 / 域名 / DNS 条件触发

VPN 断开行为可以通过 网络类型 / DNS 条件触发，不能通过域名条件触发

从上到下依次匹配添加的 按需求规则

添加 按需求规则 后，打开 按需求连接 开关，规则才能生效

同时打开 始终开启 和 按需求连接，只有 始终开启 选项能够生效

按需求连接是系统管理行为，域名通过系统 DNS 触发开启 VPN，如果域名被解析过或者有缓存则可能不会触发，Shadowrocket 只负责按需求规则的配置，是否生效取决于系统行为

睡眠时断开

当设备进入睡眠状态，VPN 自动断开连接

Shadowrocket 响应系统发送的睡眠指令才会断开连接，有时候熄屏的系统未必处于睡眠状态

显示断开信息

显示 VPN 断开连接的通知信息

隧道

强制路由

如果开启，这个隧道的路由规则将优先于任何本地自定义的路由，默认是关闭状态

包括所有网络

启用后系统会通过隧道进行路由所有的网络流量，但为维持预期设备功能所必需的指定系统服务的流量除外

包括本地网络：如果开启，所有发送到本地网络的流量都将包含在隧道中，如 AirPlay、AirDrop 和 CarPlay 的网络连接

包括APNs：如果开启，苹果的 Apple Push Notification 推送通知服务（APN）的网络流量将包含在隧道中

包括蜂窝服务：如果开启，来自蜂窝服务的互联网可路由网络流量（VoLTE、Wi-Fi通话、IMS、MMS、视觉语音信箱等）将包含在隧道中。

兼容模式

设置 > 代理 > 兼容模式

HomeKit 与摄像头建立连接时，会主动将本机 IP 发送给摄像头端逆向连接。部分情况下 iOS 可能并未处理 VPN 开启时的情况，会将 VPN 的内网地址发送给摄像头，导致 RTSP 数据回包无法发回到 iOS 设备上。若当前设备与家庭中枢设备处于同一局域网下且开启代理时，如果出现无法正常使用家庭应用查看流式传输的 HomeKit 实况影像时，可以尝试开启此项以提高相应的兼容性。此处的设置是配置文件通用隐式参数中 compatibility-mode 的一种，开启该选项效果等同于配置文件内设置 compatibility-mode=5

前置代理

设置 > 代理 > 前置代理

「前置代理」表示所有流量先通过 HTTP/SOCKS5 代理转发，再根据配置规则向节点服务器发送请求

代理共享

代理共享指的是将你当前配置的代理设置分享给其他设备使用。通过代理共享，你可以把自己配置好的代理服务器（如Shadowsocks、Vmess等）通过局域网或者热点网络的方式让其他设备也能够通过相同的代理设置访问互联网

在局域网条件下

A设备：设置 > 代理 > 代理共享 > 启用共享

B设备：系统设置 > WiFi > WiFi 名称后面的 ⓘ 图标 > HTTP代理 > 手动输入Shadowrocket「代理共享」的IP和端口

使用热点条件下

A设备：开启热点

B设备：连接热点

然后按照局域网条件下方法进行设置
此处需要注意下操作顺序，原理是连接设备热点后先形成局域网环境，然后按照局域网条件进行设置

备注

当 iOS 设备开启代理共享时，或需保持该设备屏幕常亮或连接充电器，以防意外退出

如果配置文件开启了 HTTPS 解密，请确保其他设备已安装并信任相同的证书才能正常使用。当其他设备不需要使用解密功能时，可以在 代理共享 页面关闭「HTTPS解密」开关

使用代理共享时需要对应的 APP 打开系统设置中的 本地网络 开关

Telegram 可能不被系统代理接管，可单独在应用内添加 SOCKS5 代理

代理类型

Shadowrocket 代理类型：

设置 > 代理 > 代理类型

HTTP：系统代理模式，对于不支持的程序会交给 TUN 接管网络连接

None：TUN 模式，全部网络请求都将通过 TUN 接口进行处理。效果等同于配置文件内设置 compatibility-mode=3

开启UDP转发

设置 > UDP > 启用转发 > 打开

首页 > 订阅后面的 ⓘ 图标 > UDP转发 > 打开

首页 > 节点后面的 ⓘ 图标 > UDP转发 > 打开

禁用STUN

设置 > UDP > 禁用STUN > 打开

禁用 STUN（Session Traversal Utilities for NAT）的意思是完全阻止 WebRTC 通过 STUN 服务器获取公网 IP，从而彻底杜绝 WebRTC IP 泄露的问题

若在配置文件通用参数中使用 stun-response-ip 的相关命令，则此处的开关状态将被忽略

权限

位置

iOS 系统要求必须开启位置权限才可以读取 Wi-Fi 网络的 SSID 名称。在 Shadowrocket 中，此权限仅在需要使用基于连接 Wi-Fi 网络触发特定配置的场景功能时才需要

通知

开启通知权限才可允许软件发送重要通知或警报，包括：脚本执行结果、订阅更新通知、VPN 断开通知等

剪贴板

开启剪贴板权限后，Shadowrocket 将在打开应用程序后尝试识别剪贴板中的内容是否是代理服务器的 URL，若是则会提示将其导入到应用。若未启用此权限，Shadowrocket 主页的本地节点上方将出现一个专用的粘贴按钮，以允许手动粘贴和导入剪贴板的内容

隐藏VPN图标

设置 > 排除路由 0.0.0.0/31 > 打开

注意：该选项是利用系统漏洞实现的，打开开关可能会导致网络异常，不推荐开启此项

GEOIP数据库

设置 > GeoLite2 数据库

软件已内置常规 GeoIP 数据库，一般情况下无需设置，若有需要请参考以下设置方式

方法一

填写 MaxMind官网注册的账户 ID 和密钥，点击下方的更新按钮

方法二
关注 GitHub 的 IP 数据库项目，复制 mmdb 格式的下载链接，粘贴在国家/ASN 对应的 URL 位置，点击更新按钮。当点击重置时，可以恢复为系统自带的数据库

Loyalsoldier 的 IP 数据库：
https://raw.githubusercontent.com/Loyalsoldier/geoip/release/Country.mmdb
Hackl0us 的 IP 数据库：
https://github.com/Hackl0us/GeoIP2-CN/raw/release/Country.mmdb
Masaiki 的 IP 数据库：
https://github.com/Masaiki/GeoIP2-CN/raw/release/Country.mmdb
P3TERX 的 ASN 数据库：
https://github.com/P3TERX/GeoLite.mmdb/raw/download/GeoLite2-ASN.mmdb

自动更新

现阶段软件的自动更新包含配置文件自动更新、模块自动更新、服务器订阅自动更新以及 GeoLite2 数据库自动更新。需要在 系统设置 > 通用 > 后台App刷新 中为 Shadowrocket 启用后台刷新。在重新启动设备、杀死应用程序等结束了程序进程或后台的情况下，后台任务将不能自动启动

配置：根据设置自动更新配置以及当前所用的规则集、脚本等远程资源。

自动后台更新：开启后可根据设置自动更新配置文件

更新提醒：开启后，更新时会弹出相应提醒。需要开启设备推送通知

更新间隔：单位为天，可选 1-7 天

若当前配置文件是不含更新地址的本地配置文件，则自动更新功能仅会更新当前所用的规则集、脚本等远程资源，参见：使用配置 / 编译配置、规则集URL、脚本URL

规则集/脚本资源手动更新方法：点击配置文件 > 使用配置 / 编译配置

需要注意：自动更新配置会覆盖自定义设置，参见更新配置

模块：根据设置自动更新远程模块资源

自动后台更新：开启后可根据设置自动更新模块

更新提醒：开启后，更新时会弹出相应提醒。需要开启设备推送通知

更新间隔：单位为天，可选 1-7 天

订阅：根据设置自动更新服务器订阅，另外可参见此处

自动后台更新：开启后可根据设置自动更新订阅

更新提醒：开启后，更新时会弹出相应提醒。需要开启设备推送通知

更新间隔：单位为小时，可选 1-24 小时

DNS：使用指定的 HTTPS DNS 来解析订阅链接的域名，点击右侧的 ⓘ 可以挑选内置的 DNS

根据 PING 排序：以连通性测试的结果从小到大排列服务器节点

发送 HWID：开启该开关后，Shadowrocket 将在更新订阅时发送 X-HWID 标头

显示删除确认：连通性测试结束后，显示是否删除超时节点的对话框

GeoLite2 数据库：包含自动后台更新选项、更新提醒选项、更新间隔选项，其中更新间隔单位为天。其他设置参见此处

💡 提示

若当前配置是远程配置，希望定期更新远程资源，且不希望自定义设置被覆盖或丢失时，可参考以下两种方法：

进入纯文本编辑删除或注释掉 update-url = *，然后再使用自动更新功能

使用扩展配置/包含配置功能后，再使用自动更新功能

温和策略机制

当使用温和策略机制时，切换策略不会打断之前与之相关的TCP连接，仅会对之后的网络请求使用新的策略进行连接
当不使用该功能机制时，切换策略会打断与该策略相关的旧有 TCP 连接，若继续使用则使用新的策略重新连接

例如：打断会使旧有策略相关的连接所进行的下载任务中断

其他问题

自动切换节点

自动切换延迟低的节点：

方法一

首页 > 全局路由 > 分组 > 简单模式 > 打开

方法二

点击配置文件的 ⓘ 图标 > 代理分组 > 右上角 ➕ > 类型 url-test

备注

如果节点不稳定，可同时开启回退

订阅异常

添加/更新订阅时异常的原因：

forbidden 表示订阅被重置或令牌 token 错误

not found 表示订阅路径或链接信息错误

service unavailable 表示域名信息错误或域名被运营商屏蔽

SSL 错误 表示无法建立与该服务器的安全连接

添加/更新订阅链接时，如果发生异常，可以尝试的解决方法：

全局路由选代理，使用另外一个节点来添加/更新订阅链接

切换网络后再添加/更新订阅链接

检查订阅链接是否错误或失效

节点旗帜

节点优先根据备注名称匹配旗帜，如果匹配不成功，由节点地址解析出 IP，通过数据库判断该IP的国家或地区，然后显示对应的旗帜

节点后面的 ⓘ 图标 > 地址栏的图标，可以手动修改旗帜

订阅后面的 ⓘ 图标 > 订阅界面的筛选输入框，输入相关脚本能批量修改旗帜，参考：订阅节点筛选

如果把旗帜的 Emoji 放在节点备注开头，保存时会自动显示对应的旗帜，且不显示开头的 Emoji

节点感叹号

节点显示感叹号 ⚠ 的原因：

您的节点使用了 TLS，地址是 IP，却没有设 SNI

这不是正确的服务器设置，但为了可以正常连接，Shadowrocket 会主动开启 允许不安全。允许不安全 将跳过TLS证书验证，这将导致一些安全问题。如果您使用自签名证书，请将证书导入系统并信任它，否则请及时续订服务器端证书，以防止证书过期。在 2.2.23 等特定版本中，该选项可能默认为关闭状态

微信转圈

如果使用 Shadowrocket 时微信一直显示 连接中/收取中，可以尝试的解决方法：

微信分流走直连

点击配置文件的 ⓘ 图标 > 通用 > 启用IPv6 > 关闭

本质上该问题是由于现阶段某些地区的运营商对 IPv6 的支持不够稳定，或是路由器设置不当，可能会引发微信加载异常的问题

模块消失

模块页面已经开启 保存到 iCloud，如果出现模块消失的问题，请检查：

系统设置 > Apple ID > iCloud > 使用iCloud的APP中，确保Shadowrocket/iCloud云盘已经打开同步

文件app > iCloud云盘 > Shadowrocket，确定其中包含 Modules 和 Script 两个子文件夹

文件app > iCloud云盘 > Shadowrocket > Modules，如果iCloud的本地缓存被清理，此时模块文件是未下载状态，请等待自动下载或手动下载

模块失效

切换配置文件需要重新开启解密，为避免解密失效可使用证书模块

若模块确认有效且解密设置无误时存在模块失效的情况，则可能是加载资源时因内存、网络等原因导致部分内容出现漏编译的情况。尝试对当前配置点击使用配置 / 编译配置，以使远程资源进行重新拉取，一般可恢复正常

VPN自动断开

因系统版本低于 iOS 15、处理复杂请求、加解密数据、运行脚本等因素或多种因素相互作用之下可能导致 NE 内存占用过高，从而造成 VPN 自动断开，解决方法：

设置 > 按需求连接 > 始终开启 > 启用

检测代理

如果在使用 Shadowrocket 的时候，遇到某些 APP 提示需关闭代理才能使用，可以在 Shadowrocket > 设置 > 代理类型 > 选择 None

该设置将使用 TUN 模式接管代理，能很大程度上缓解上述情况，但对于某些直接检测系统 VPN 状态或使用其他检测手段的 APP 无效

编译原因

Shadowrocket 2.2.29 之前的版本是使用 Xcode 13.2.1 编译的

2023年4月份以后，苹果官方要求开发者在提交应用到 App Store 时必须至少使用 Xcode 14 编译，所以 iOS12 以下系统无法使用

Shadowrocket 在版本 2.2.30 之后设置最低安装要求 iOS12，然后停止 2.2.29 版本，iOS 低版本用户可以安装 2.2.28 版本

URL-Schemes

请使用相应内容直接替换代码中的大括号及其内容

Shadowrocket 支持 X-callback-urls，允许其他应用程序在 Shadowrocket 中触发某些操作

支持添加 autoclose=true 查询值，可在动作触发后退出 Shadowrocket

启动 VPN 隧道
shadowrocket://connect
shadowrocket://open
停止 VPN 隧道
shadowrocket://disconnect
shadowrocket://close
切换 VPN 开关状态
shadowrocket://toggle
连通性测试
shadowrocket://connectivity-test
使用特定节点
shadowrocket://select?s={节点名称}
添加订阅/节点
shadowrocket://add/{url}
更新订阅
shadowrocket://update-subs
安装/使用配置
shadowrocket://config/add/{url}
安装/使用模块
shadowrocket://install?module={url}
切换全局路由（代理/配置/直连/场景）
shadowrocket://route/proxy
shadowrocket://route/config
shadowrocket://route/direct
shadowrocket://route/scene
安装/使用配色
shadowrocket://color?{配色设置}

白嫖123云盘的流量与速度

Wed, 06 Aug 2025 22:16:29 +0800

最近买了一台小米8ud（屏下指纹版）因而在网上上苦求刷机包，可惜大部分资源都被存在了123云盘中，迫不得已，在网上苦求突破123云盘的下载限制，顺便提个速。经过一番折腾，终于成功了，现将方法记录如下：

本教程部分应用要在VPN环境下下载，建议先开启VPN。
下载一个可用的浏览器，仅限于Chrome、Edge、Opera、Firefox浏览器，其他浏览器不行。
下载并安装Tampermonkey插件，地址：https://www.tampermonkey.net/
安装脚本，地址：https://greasyfork.org/zh-CN/scripts/519353-123%E4%BA%91%E7%9B%98%E8%A7%A3%E9%94%81
安装Motrix下载助手，地址：https://github.com/gautamkrishnar/motrix-webextension
访问Motrix官网，地址：https://motrix.app/
点击下载，下载合适的Motrix客户端，安装完成后打开。
单击浏览器中的Tampermonkey图标，选择“123云盘解锁”，然后点击“启用”。
打开扩展中的开发人员选项，并允许篡改猴执行用户脚本。
选择扩展中的motrix下载助手，启用它。
访问123云盘的下载链接，点击保存到云盘。
打开云盘网页端，选择刚才保存的文件。
点击右下角的设置面板，启用里面的选项
然后点击下载即可

这个方法好在不受流量限制，而且不限速，缺点是需要安装几个插件和软件，稍微麻烦一些。以及每次只能下1GB以内的多文件或随意大小的单文件（单文件可以有随意大小），不能大批量下载。祝大家下载愉快！我所下到的刷机包回头会分享出来的。

使用cloudflare搭建VPN的实战演练及免费节点

Mon, 14 Jul 2025 14:22:13 +0800

本文章为这篇文章的后续，并提供免费示例

在成功部署后，我们就可以输入

https://example.com/114514

来访问我们的网站此时它应该是这样的：你们也可以通过https://edge.realityme.top/1145141919810来访问我搭建的这个站点纯公益，不收费（酷炫）

通过Cloudflare的worker和Pages搭建永久免费的VPN

Mon, 14 Jul 2025 09:37:49 +0800

今天我们主要来说下如果通过 Cloudflare 的 worker 、Pages 搭建永久免费的VPN，真正做到无限流量！

准备工作

首先你需要注册一个免费的 Cloudflare 账号【点击前往】
接着你需要准备好开源软件：V2rayN，因为一会要用到【点击下载】
在Cloudflare 上创建worker，并填写下面的代码，这个代码来自CM在【 GitHub 】社区的开源项目，代码已经内置IP优选和代理功能，自带动态的UUID，可以大大减少手动配置过程，非常适合新手和特殊用户。

创建的worker项目名称最好使用系统默认的，别自定义，以免被系统识别到特殊字符而被屏蔽。

获取Cloudflare 的 worker 开源代码

加密版：【点击获取】

明文版：直接复制下方的代码即可！仅限海外用户使用，大陆用户切勿使用（可能违法），别给站长找麻烦！！

import { connect } from 'cloudflare:sockets';

let userID = '';
let proxyIP = '';
//let sub = '';
let subConverter = 'SUBAPI.fxxk.dedyn.io';
let subConfig = "https://raw.githubusercontent.com/ACL4SSR/ACL4SSR/master/Clash/config/ACL4SSR_Online_Mini_MultiMode.ini";
let subProtocol = 'https';
let subEmoji = 'true';
let socks5Address = '';
let parsedSocks5Address = {};
let enableSocks = false;

let fakeUserID;
let fakeHostName;
let noTLS = 'false';
const expire = 4102329600;//2099-12-31
let proxyIPs;
let socks5s;
let go2Socks5s = [
 '*ttvnw.net',
 '*tapecontent.net',
 '*cloudatacdn.com',
 '*.loadshare.org',
];
let addresses = [];
let addressesapi = [];
let addressesnotls = [];
let addressesnotlsapi = [];
let addressescsv = [];
let DLS = 8;
let remarkIndex = 1;//CSV备注所在列偏移量
let FileName = atob('ZWRnZXR1bm5lbA==');
let BotToken;
let ChatID;
let proxyhosts = [];
let proxyhostsURL = '';
let RproxyIP = 'false';
let httpsPorts = ["2053", "2083", "2087", "2096", "8443"];
let 有效时间 = 7;
let 更新时间 = 3;
let userIDLow;
let userIDTime = "";
let proxyIPPool = [];
let path = '/?ed=2560';
let 动态UUID;
let link = [];
let banHosts = [atob('c3BlZWQuY2xvdWRmbGFyZS5jb20=')];
export default {
 async fetch(request, env, ctx) {
 try {
 const UA = request.headers.get('User-Agent') || 'null';
 const userAgent = UA.toLowerCase();
 userID = env.UUID || env.uuid || env.PASSWORD || env.pswd || userID;
 if (env.KEY || env.TOKEN || (userID && !isValidUUID(userID))) {
 动态UUID = env.KEY || env.TOKEN || userID;
 有效时间 = Number(env.TIME) || 有效时间;
 更新时间 = Number(env.UPTIME) || 更新时间;
 const userIDs = await 生成动态UUID(动态UUID);
 userID = userIDs[0];
 userIDLow = userIDs[1];
 }

 if (!userID) {
 return new Response('请设置你的UUID变量，或尝试重试部署，检查变量是否生效？', {
 status: 404,
 headers: {
 "Content-Type": "text/plain;charset=utf-8",
 }
 });
 }
 const currentDate = new Date();
 currentDate.setHours(0, 0, 0, 0);
 const timestamp = Math.ceil(currentDate.getTime() / 1000);
 const fakeUserIDMD5 = await 双重哈希(`${userID}${timestamp}`);
 fakeUserID = [
 fakeUserIDMD5.slice(0, 8),
 fakeUserIDMD5.slice(8, 12),
 fakeUserIDMD5.slice(12, 16),
 fakeUserIDMD5.slice(16, 20),
 fakeUserIDMD5.slice(20)
 ].join('-');

 fakeHostName = `${fakeUserIDMD5.slice(6, 9)}.${fakeUserIDMD5.slice(13, 19)}`;

 proxyIP = env.PROXYIP || env.proxyip || proxyIP;
 proxyIPs = await 整理(proxyIP);
 proxyIP = proxyIPs[Math.floor(Math.random() * proxyIPs.length)];

 socks5Address = env.SOCKS5 || socks5Address;
 socks5s = await 整理(socks5Address);
 socks5Address = socks5s[Math.floor(Math.random() * socks5s.length)];
 socks5Address = socks5Address.split('//')[1] || socks5Address;
 if (env.GO2SOCKS5) go2Socks5s = await 整理(env.GO2SOCKS5);
 if (env.CFPORTS) httpsPorts = await 整理(env.CFPORTS);
 if (env.BAN) banHosts = await 整理(env.BAN);
 if (socks5Address) {
 try {
 parsedSocks5Address = socks5AddressParser(socks5Address);
 RproxyIP = env.RPROXYIP || 'false';
 enableSocks = true;
 } catch (err) {
 let e = err;
 console.log(e.toString());
 RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false';
 enableSocks = false;
 }
 } else {
 RproxyIP = env.RPROXYIP || !proxyIP ? 'true' : 'false';
 }

 const upgradeHeader = request.headers.get('Upgrade');
 const url = new URL(request.url);
 if (!upgradeHeader || upgradeHeader !== 'websocket') {
 if (env.ADD) addresses = await 整理(env.ADD);
 if (env.ADDAPI) addressesapi = await 整理(env.ADDAPI);
 if (env.ADDNOTLS) addressesnotls = await 整理(env.ADDNOTLS);
 if (env.ADDNOTLSAPI) addressesnotlsapi = await 整理(env.ADDNOTLSAPI);
 if (env.ADDCSV) addressescsv = await 整理(env.ADDCSV);
 DLS = Number(env.DLS) || DLS;
 remarkIndex = Number(env.CSVREMARK) || remarkIndex;
 BotToken = env.TGTOKEN || BotToken;
 ChatID = env.TGID || ChatID;
 FileName = env.SUBNAME || FileName;
 subEmoji = env.SUBEMOJI || env.EMOJI || subEmoji;
 if (subEmoji == '0') subEmoji = 'false';
 if (env.LINK) link = await 整理(env.LINK);
 let sub = env.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 (url.searchParams.has('sub') && url.searchParams.get('sub') !== '') sub = url.searchParams.get('sub');
 if (url.searchParams.has('notls')) noTLS = 'true';

 if (url.searchParams.has('proxyip')) {
 path = `/?ed=2560&proxyip=${url.searchParams.get('proxyip')}`;
 RproxyIP = 'false';
 } else if (url.searchParams.has('socks5')) {
 path = `/?ed=2560&socks5=${url.searchParams.get('socks5')}`;
 RproxyIP = 'false';
 } else if (url.searchParams.has('socks')) {
 path = `/?ed=2560&socks5=${url.searchParams.get('socks')}`;
 RproxyIP = 'false';
 }

 const 路径 = url.pathname.toLowerCase();
 if (路径 == '/') {
 if (env.URL302) return Response.redirect(env.URL302, 302);
 else if (env.URL) return await 代理URL(env.URL, url);
 else return new Response(JSON.stringify(request.cf, null, 4), {
 status: 200,
 headers: {
 'content-type': 'application/json',
 },
 });
 } else if (路径 == `/${fakeUserID}`) {
 const fakeConfig = await 生成配置信息(userID, request.headers.get('Host'), sub, 'CF-Workers-SUB', RproxyIP, url, env);
 return new Response(`${fakeConfig}`, { status: 200 });
 } else if (url.pathname == `/${动态UUID}/edit` || 路径 == `/${userID}/edit`) {
 const html = await KV(request, env);
 return html;
 } else if (url.pathname == `/${动态UUID}` || 路径 == `/${userID}`) {
 await sendMessage(`#获取订阅 ${FileName}`, request.headers.get('CF-Connecting-IP'), `UA: ${UA}</tg-spoiler>\n域名: ${url.hostname}\n<tg-spoiler>入口: ${url.pathname + url.search}</tg-spoiler>`);
 const 维列斯Config = await 生成配置信息(userID, request.headers.get('Host'), sub, UA, RproxyIP, url, env);
 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 (userAgent && userAgent.includes('mozilla')) {
 return new Response(`<div style="font-size:13px;">${维列斯Config}</div>`, {
 status: 200,
 headers: {
 "Content-Type": "text/html;charset=utf-8",
 "Profile-Update-Interval": "6",
 "Subscription-Userinfo": `upload=${pagesSum}; download=${workersSum}; total=${total}; expire=${expire}`,
 "Cache-Control": "no-store",
 }
 });
 } else {
 return new Response(`${维列斯Config}`, {
 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}`,
 }
 });
 }
 } else {
 if (env.URL302) return Response.redirect(env.URL302, 302);
 else if (env.URL) return await 代理URL(env.URL, url);
 else return new Response('不用怀疑！你UUID就是错的！！！', { status: 404 });
 }
 } else {
 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) {
 let e = err;
 console.log(e.toString());
 enableSocks = false;
 }
 } else {
 enableSocks = false;
 }

 if (url.searchParams.has('proxyip')) {
 proxyIP = url.searchParams.get('proxyip');
 enableSocks = false;
 } else if (new RegExp('/proxyip=', 'i').test(url.pathname)) {
 proxyIP = url.pathname.toLowerCase().split('/proxyip=')[1];
 enableSocks = false;
 } else if (new RegExp('/proxyip.', 'i').test(url.pathname)) {
 proxyIP = `proxyip.${url.pathname.toLowerCase().split("/proxyip.")[1]}`;
 enableSocks = false;
 } else if (new RegExp('/pyip=', 'i').test(url.pathname)) {
 proxyIP = url.pathname.toLowerCase().split('/pyip=')[1];
 enableSocks = false;
 }

 return await 维列斯OverWSHandler(request);
 }
 } catch (err) {
 let e = err;
 return new Response(e.toString());
 }
 },
};

async function 维列斯OverWSHandler(request) {

 // @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);

 // 用于存储远程 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;
 }

 // 处理 维列斯 协议头部
 const {
 hasError,
 message,
 addressType,
 portRemote = 443,
 addressRemote = '',
 rawDataIndex,
 维列斯Version = new Uint8Array([0, 0]),
 isUDP,
 } = process维列斯Header(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;
 }
 }
 // 构建 维列斯 响应头部
 const 维列斯ResponseHeader = new Uint8Array([维列斯Version[0], 0]);
 // 获取实际的客户端数据
 const rawClientData = chunk.slice(rawDataIndex);

 if (isDns) {
 // 如果是 DNS 查询，调用 DNS 处理函数
 return handleDNSQuery(rawClientData, webSocket, 维列斯ResponseHeader, log);
 }
 // 处理 TCP 出站连接
 if (!banHosts.includes(addressRemote)) {
 log(`处理 TCP 出站连接 ${addressRemote}:${portRemote}`);
 handleTCPOutBound(remoteSocketWapper, addressType, addressRemote, portRemote, rawClientData, webSocket, 维列斯ResponseHeader, log);
 } else {
 throw new Error(`黑名单关闭 TCP 出站连接 ${addressRemote}:${portRemote}`);
 }
 },
 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,
 });
}

async function handleTCPOutBound(remoteSocket, addressType, addressRemote, portRemote, rawClientData, webSocket, 维列斯ResponseHeader, log,) {
 async function useSocks5Pattern(address) {
 if (go2Socks5s.includes(atob('YWxsIGlu')) || go2Socks5s.includes(atob('Kg=='))) return true;
 return go2Socks5s.some(pattern => {
 let regexPattern = pattern.replace(/\*/g, '.*');
 let regex = new RegExp(`^${regexPattern}$`, 'i');
 return regex.test(address);
 });
 }

 async function connectAndWrite(address, port, socks = false) {
 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(`UFJPWFlJUC50cDEuZnh4ay5kZWR5bi5pbw==`);
 } else if (proxyIP.includes(']:')) {
 portRemote = proxyIP.split(']:')[1] || portRemote;
 proxyIP = proxyIP.split(']:')[0] || proxyIP;
 } else if (proxyIP.split(':').length === 2) {
 portRemote = proxyIP.split(':')[1] || portRemote;
 proxyIP = proxyIP.split(':')[0] || proxyIP;
 }
 if (proxyIP.includes('.tp')) portRemote = proxyIP.split('.tp')[1].split('.')[0] || portRemote;
 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, 维列斯ResponseHeader, null, log);
 }

 let useSocks = false;
 if (go2Socks5s.length > 0 && enableSocks) useSocks = await useSocks5Pattern(addressRemote);
 // 首次尝试连接远程服务器
 let tcpSocket = await connectAndWrite(addressRemote, portRemote, useSocks);

 // 当远程 Socket 就绪时，将其传递给 WebSocket
 // 建立从远程服务器到 WebSocket 的数据流，用于将远程服务器的响应发送回客户端
 // 如果连接失败或无数据，retry 函数将被调用进行重试
 remoteSocketToWS(tcpSocket, webSocket, 维列斯ResponseHeader, retry, log);
}

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/维列斯.html
// https://github.com/zizifn/excalidraw-backup/blob/main/v2ray-protocol.excalidraw

/**
 * 解析 维列斯 协议的头部数据
 * @param { ArrayBuffer} 维列斯Buffer 维列斯 协议的原始头部数据
 * @param {string} userID 用于验证的用户 ID
 * @returns {Object} 解析结果，包括是否有错误、错误信息、远程地址信息等
 */
function process维列斯Header(维列斯Buffer, userID) {
 // 检查数据长度是否足够（至少需要 24 字节）
 if (维列斯Buffer.byteLength < 24) {
 return {
 hasError: true,
 message: 'invalid data',
 };
 }

 // 解析 维列斯 协议版本（第一个字节）
 const version = new Uint8Array(维列斯Buffer.slice(0, 1));

 let isValidUser = false;
 let isUDP = false;

 // 验证用户 ID（接下来的 16 个字节）
 function isUserIDValid(userID, userIDLow, buffer) {
 const userIDArray = new Uint8Array(buffer.slice(1, 17));
 const userIDString = stringify(userIDArray);
 return userIDString === userID || userIDString === userIDLow;
 }

 // 使用函数验证
 isValidUser = isUserIDValid(userID, userIDLow, 维列斯Buffer);

 // 如果用户 ID 无效，返回错误
 if (!isValidUser) {
 return {
 hasError: true,
 message: `invalid user ${(new Uint8Array(维列斯Buffer.slice(1, 17)))}`,
 };
 }

 // 获取附加选项的长度（第 17 个字节）
 const optLength = new Uint8Array(维列斯Buffer.slice(17, 18))[0];
 // 暂时跳过附加选项

 // 解析命令（紧跟在选项之后的 1 个字节）
 // 0x01: TCP, 0x02: UDP, 0x03: MUX（多路复用）
 const command = new Uint8Array(
 维列斯Buffer.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 = 维列斯Buffer.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(
 维列斯Buffer.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(
 维列斯Buffer.slice(addressValueIndex, addressValueIndex + addressLength)
 ).join('.');
 break;
 case 2:
 // 域名
 // 第一个字节是域名长度
 addressLength = new Uint8Array(
 维列斯Buffer.slice(addressValueIndex, addressValueIndex + 1)
 )[0];
 addressValueIndex += 1;
 // 解码域名
 addressValue = new TextDecoder().decode(
 维列斯Buffer.slice(addressValueIndex, addressValueIndex + addressLength)
 );
 break;
 case 3:
 // IPv6 地址
 addressLength = 16;
 const dataView = new DataView(
 维列斯Buffer.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, // 原始数据的实际起始位置
 维列斯Version: version, // 维列斯 协议版本
 isUDP, // 是否是 UDP 请求
 };
}

async function remoteSocketToWS(remoteSocket, webSocket, 维列斯ResponseHeader, retry, log) {
 // 将数据从远程服务器转发到 WebSocket
 let remoteChunkCount = 0;
 let chunks = [];
 /** @type {ArrayBuffer | null} */
 let 维列斯Header = 维列斯ResponseHeader;
 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 (维列斯Header) {
 // 如果有 维列斯 响应头部，将其与第一个数据块一起发送
 webSocket.send(await new Blob([维列斯Header, chunk]).arrayBuffer());
 维列斯Header = 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 { earlyData: undefined, 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 { earlyData: undefined, 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 正在关闭过程中

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 {ArrayBuffer} 维列斯ResponseHeader - 维列斯 协议的响应头部数据
 * @param {(string)=> void} log - 日志记录函数
 */
async function handleDNSQuery(udpChunk, webSocket, 维列斯ResponseHeader, 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 服务的标准端口

 let 维列斯Header = 维列斯ResponseHeader; // 保存 维列斯 响应头部，用于后续发送

 // 与指定的 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 (维列斯Header) {
 // 如果有 维列斯 头部，则将其与 DNS 响应数据合并后发送
 webSocket.send(await new Blob([维列斯Header, chunk]).arrayBuffer());
 维列斯Header = 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 恢复伪装信息(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} 文本 要哈希的文本
 * @returns {Promise<string>} 双重哈希后的小写十六进制字符串
 */
async function 双重哈希(文本) {
 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();
}

async function 代理URL(代理网址, 目标网址) {
 const 网址列表 = await 整理(代理网址);
 const 完整网址 = 网址列表[Math.floor(Math.random() * 网址列表.length)];

 // 解析目标 URL
 let 解析后的网址 = new URL(完整网址);
 console.log(解析后的网址);
 // 提取并可能修改 URL 组件
 let 协议 = 解析后的网址.protocol.slice(0, -1) || 'https';
 let 主机名 = 解析后的网址.hostname;
 let 路径名 = 解析后的网址.pathname;
 let 查询参数 = 解析后的网址.search;

 // 处理路径名
 if (路径名.charAt(路径名.length - 1) == '/') {
 路径名 = 路径名.slice(0, -1);
 }
 路径名 += 目标网址.pathname;

 // 构建新的 URL
 let 新网址 = `${协议}://${主机名}${路径名}${查询参数}`;

 // 反向代理请求
 let 响应 = await fetch(新网址);

 // 创建新的响应
 let 新响应 = new Response(响应.body, {
 status: 响应.status,
 statusText: 响应.statusText,
 headers: 响应.headers
 });

 // 添加自定义头部，包含 URL 信息
 //新响应.headers.set('X-Proxied-By', 'Cloudflare Worker');
 //新响应.headers.set('X-Original-URL', 完整网址);
 新响应.headers.set('X-New-URL', 新网址);

 return 新响应;
}

const 啥啥啥_写的这是啥啊 = atob('ZG14bGMzTT0=');
function 配置信息(UUID, 域名地址) {
 const 协议类型 = atob(啥啥啥_写的这是啥啊);

 const 别名 = FileName;
 let 地址 = 域名地址;
 let 端口 = 443;

 const 用户ID = UUID;
 const 加密方式 = 'none';

 const 传输层协议 = 'ws';
 const 伪装域名 = 域名地址;
 const 路径 = path;

 let 传输层安全 = ['tls', true];
 const SNI = 域名地址;
 const 指纹 = 'randomized';

 if (域名地址.includes('.workers.dev')) {
 地址 = atob('dmlzYS5jbg==');
 端口 = 80;
 传输层安全 = ['', false];
 }

 const 威图瑞 = `${协议类型}://${用户ID}@${地址}:${端口}\u003f\u0065\u006e\u0063\u0072\u0079` + 'p' + `${atob('dGlvbj0=') + 加密方式}\u0026\u0073\u0065\u0063\u0075\u0072\u0069\u0074\u0079\u003d${传输层安全[0]}&sni=${SNI}&fp=${指纹}&type=${传输层协议}&host=${伪装域名}&path=${encodeURIComponent(路径)}#${encodeURIComponent(别名)}`;
 const 猫猫猫 = `- {name: ${FileName}, server: ${地址}, port: ${端口}, type: ${协议类型}, uuid: ${用户ID}, tls: ${传输层安全[1]}, alpn: [h3], udp: false, sni: ${SNI}, tfo: false, skip-cert-verify: true, servername: ${伪装域名}, client-fingerprint: ${指纹}, network: ${传输层协议}, ws-opts: {path: "${路径}", headers: {${伪装域名}}}}`;
 return [威图瑞, 猫猫猫];
}

let subParams = ['sub', 'base64', 'b64', 'clash', 'singbox', 'sb'];
const cmad = decodeURIComponent(atob('dGVsZWdyYW0lMjAlRTQlQkElQTQlRTYlQjUlODElRTclQkUlQTQlMjAlRTYlOEElODAlRTYlOUMlQUYlRTUlQTQlQTclRTQlQkQlQUMlN0UlRTUlOUMlQTglRTclQkElQkYlRTUlOEYlOTElRTclODklOEMhJTNDYnIlM0UKJTNDYSUyMGhyZWYlM0QlMjdodHRwcyUzQSUyRiUyRnQubWUlMkZDTUxpdXNzc3MlMjclM0VodHRwcyUzQSUyRiUyRnQubWUlMkZDTUxpdXNzc3MlM0MlMkZhJTNFJTNDYnIlM0UKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tJTNDYnIlM0UKZ2l0aHViJTIwJUU5JUExJUI5JUU3JTlCJUFFJUU1JTlDJUIwJUU1JTlEJTgwJTIwU3RhciFTdGFyIVN0YXIhISElM0NiciUzRQolM0NhJTIwaHJlZiUzRCUyN2h0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRmNtbGl1JTJGZWRnZXR1bm5lbCUyNyUzRWh0dHBzJTNBJTJGJTJGZ2l0aHViLmNvbSUyRmNtbGl1JTJGZWRnZXR1bm5lbCUzQyUyRmElM0UlM0NiciUzRQotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0lM0NiciUzRQolMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjMlMjM='));
/**
 * @param {string} userID
 * @param {string | null} hostName
 * @param {string} sub
 * @param {string} UA
 * @returns {Promise<string>}
 */
async function 生成配置信息(userID, hostName, sub, UA, RproxyIP, _url, env) {
 if (sub) {
 const match = sub.match(/^(?:https?:\/\/)?([^\/]+)/);
 if (match) {
 sub = match[1];
 }
 const subs = await 整理(sub);
 if (subs.length > 1) sub = subs[0];
 } else {
 if (env.KV) {
 await 迁移地址列表(env);
 const 优选地址列表 = await env.KV.get('ADD.txt');
 if (优选地址列表) {
 const 优选地址数组 = await 整理(优选地址列表);
 const 分类地址 = {
 接口地址: new Set(),
 链接地址: new Set(),
 优选地址: new Set()
 };

 for (const 元素 of 优选地址数组) {
 if (元素.startsWith('https://')) {
 分类地址.接口地址.add(元素);
 } else if (元素.includes('://')) {
 分类地址.链接地址.add(元素);
 } else {
 分类地址.优选地址.add(元素);
 }
 }

 addressesapi = [...分类地址.接口地址];
 link = [...分类地址.链接地址];
 addresses = [...分类地址.优选地址];
 }
 }

 if ((addresses.length + addressesapi.length + addressesnotls.length + addressesnotlsapi.length + addressescsv.length) == 0) {
 // 定义 Cloudflare IP 范围的 CIDR 列表
 let cfips = [
 '103.21.244.0/23',
 '104.16.0.0/13',
 '104.24.0.0/14',
 '172.64.0.0/14',
 '103.21.244.0/23',
 '104.16.0.0/14',
 '104.24.0.0/15',
 '141.101.64.0/19',
 '172.64.0.0/14',
 '188.114.96.0/21',
 '190.93.240.0/21',
 ];

 // 生成符合给定 CIDR 范围的随机 IP 地址
 function generateRandomIPFromCIDR(cidr) {
 const [base, mask] = cidr.split('/');
 const baseIP = base.split('.').map(Number);
 const subnetMask = 32 - parseInt(mask, 10);
 const maxHosts = Math.pow(2, subnetMask) - 1;
 const randomHost = Math.floor(Math.random() * maxHosts);

 const randomIP = baseIP.map((octet, index) => {
 if (index < 2) return octet;
 if (index === 2) return (octet & (255 << (subnetMask - 8))) + ((randomHost >> 8) & 255);
 return (octet & (255 << subnetMask)) + (randomHost & 255);
 });

 return randomIP.join('.');
 }
 addresses = addresses.concat('127.0.0.1:1234#CFnat');
 if (hostName.includes(".workers.dev")) {
 addressesnotls = addressesnotls.concat(cfips.map(cidr => generateRandomIPFromCIDR(cidr) + '#CF随机节点'));
 } else {
 addresses = addresses.concat(cfips.map(cidr => generateRandomIPFromCIDR(cidr) + '#CF随机节点'));
 }
 }
 }

 const uuid = (_url.pathname == `/${动态UUID}`) ? 动态UUID : userID;
 const userAgent = UA.toLowerCase();
 const Config = 配置信息(userID, hostName);
 const v2ray = Config[0];
 const clash = Config[1];
 let proxyhost = "";
 if (hostName.includes(".workers.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))) {
 const newSocks5s = socks5s.map(socks5Address => {
 if (socks5Address.includes('@')) return socks5Address.split('@')[1];
 else if (socks5Address.includes('//')) return socks5Address.split('//')[1];
 else return socks5Address;
 });

 let socks5List = '';
 if (go2Socks5s.length > 0 && enableSocks) {
 socks5List = `${decodeURIComponent('SOCKS5%EF%BC%88%E7%99%BD%E5%90%8D%E5%8D%95%EF%BC%89%3A%20')}`;
 if (go2Socks5s.includes(atob('YWxsIGlu')) || go2Socks5s.includes(atob('Kg=='))) socks5List += `${decodeURIComponent('%E6%89%80%E6%9C%89%E6%B5%81%E9%87%8F')}<br>`;
 else socks5List += `<br> ${go2Socks5s.join('<br> ')}<br>`;
 }

 let 订阅器 = '<br>';
 if (sub) {
 if (enableSocks) 订阅器 += `CFCDN（访问方式）: Socks5<br> ${newSocks5s.join('<br> ')}<br>${socks5List}`;
 else if (proxyIP && proxyIP != '') 订阅器 += `CFCDN（访问方式）: ProxyIP<br> ${proxyIPs.join('<br> ')}<br>`;
 else if (RproxyIP == 'true') 订阅器 += `CFCDN（访问方式）: 自动获取ProxyIP<br>`;
 else 订阅器 += `CFCDN（访问方式）: 无法访问, 需要您设置 proxyIP/PROXYIP ！！！<br>`
 订阅器 += `<br>SUB（优选订阅生成器）: ${sub}`;
 } else {
 if (enableSocks) 订阅器 += `CFCDN（访问方式）: Socks5<br> ${newSocks5s.join('<br> ')}<br>${socks5List}`;
 else if (proxyIP && proxyIP != '') 订阅器 += `CFCDN（访问方式）: ProxyIP<br> ${proxyIPs.join('<br> ')}<br>`;
 else 订阅器 += `CFCDN（访问方式）: 无法访问, 需要您设置 proxyIP/PROXYIP ！！！<br>`;
 let 判断是否绑定KV空间 = '';
 if (env.KV) 判断是否绑定KV空间 = ` <a href='${_url.pathname}/edit'>编辑优选列表</a>`;
 订阅器 += `<br>您的订阅内容由 内置 addresses/ADD* 参数变量提供${判断是否绑定KV空间}<br>`;
 if (addresses.length > 0) 订阅器 += `ADD（TLS优选域名&IP）: <br> ${addresses.join('<br> ')}<br>`;
 if (addressesnotls.length > 0) 订阅器 += `ADDNOTLS（noTLS优选域名&IP）: <br> ${addressesnotls.join('<br> ')}<br>`;
 if (addressesapi.length > 0) 订阅器 += `ADDAPI（TLS优选域名&IP 的 API）: <br> ${addressesapi.join('<br> ')}<br>`;
 if (addressesnotlsapi.length > 0) 订阅器 += `ADDNOTLSAPI（noTLS优选域名&IP 的 API）: <br> ${addressesnotlsapi.join('<br> ')}<br>`;
 if (addressescsv.length > 0) 订阅器 += `ADDCSV（IPTest测速csv文件 限速 ${DLS} ）: <br> ${addressescsv.join('<br> ')}<br>`;
 }

 if (动态UUID && _url.pathname !== `/${动态UUID}`) 订阅器 = '';
 else 订阅器 += `<br>SUBAPI（订阅转换后端）: ${subProtocol}://${subConverter}<br>SUBCONFIG（订阅转换配置文件）: ${subConfig}`;
 const 动态UUID信息 = (uuid != userID) ? `TOKEN: ${uuid}<br>UUIDNow: ${userID}<br>UUIDLow: ${userIDLow}<br>${userIDTime}TIME（动态UUID有效时间）: ${有效时间} 天<br>UPTIME（动态UUID更新时间）: ${更新时间} 时（北京时间）<br><br>` : `${userIDTime}`;
 const 节点配置页 = `
 ################################################################<br>
 Subscribe / sub 订阅地址, 点击链接自动 <strong>复制订阅链接</strong> 并 <strong>生成订阅二维码</strong> <br>
 ---------------------------------------------------------------<br>
 自适应订阅地址:<br>
 <a href="javascript:void(0)" onclick="copyToClipboard('https://${proxyhost}${hostName}/${uuid}?sub','qrcode_0')" style="color:blue;text-decoration:underline;cursor:pointer;">https://${proxyhost}${hostName}/${uuid}</a><br>
 <div id="qrcode_0" style="margin: 10px 10px 10px 10px;"></div>
 Base64订阅地址:<br>
 <a href="javascript:void(0)" onclick="copyToClipboard('https://${proxyhost}${hostName}/${uuid}?b64','qrcode_1')" style="color:blue;text-decoration:underline;cursor:pointer;">https://${proxyhost}${hostName}/${uuid}?b64</a><br>
 <div id="qrcode_1" style="margin: 10px 10px 10px 10px;"></div>
 clash订阅地址:<br>
 <a href="javascript:void(0)" onclick="copyToClipboard('https://${proxyhost}${hostName}/${uuid}?clash','qrcode_2')" style="color:blue;text-decoration:underline;cursor:pointer;">https://${proxyhost}${hostName}/${uuid}?clash</a><br>
 <div id="qrcode_2" style="margin: 10px 10px 10px 10px;"></div>
 singbox订阅地址:<br>
 <a href="javascript:void(0)" onclick="copyToClipboard('https://${proxyhost}${hostName}/${uuid}?sb','qrcode_3')" style="color:blue;text-decoration:underline;cursor:pointer;">https://${proxyhost}${hostName}/${uuid}?sb</a><br>
 <div id="qrcode_3" style="margin: 10px 10px 10px 10px;"></div>
 <strong><a href="javascript:void(0);" id="noticeToggle" onclick="toggleNotice()">实用订阅技巧∨</a></strong><br>
 <div id="noticeContent" class="notice-content" style="display: none;">
 <strong>1.</strong> 如您使用的是 PassWall、SSR+ 等路由插件，推荐使用 <strong>Base64订阅地址</strong> 进行订阅；<br>
 <br>
 <strong>2.</strong> 快速切换 <a href='${atob('aHR0cHM6Ly9naXRodWIuY29tL2NtbGl1L1dvcmtlclZsZXNzMnN1Yg==')}'>优选订阅生成器</a> 至：sub.google.com，您可将"?sub=sub.google.com"参数添加到链接末尾，例如：<br>
 https://${proxyhost}${hostName}/${uuid}<strong>?sub=sub.google.com</strong><br>
 <br>
 <strong>3.</strong> 快速更换 PROXYIP 至：proxyip.fxxk.dedyn.io:443，您可将"?proxyip=proxyip.fxxk.dedyn.io:443"参数添加到链接末尾，例如：<br>
 https://${proxyhost}${hostName}/${uuid}<strong>?proxyip=proxyip.fxxk.dedyn.io:443</strong><br>
 <br>
 <strong>4.</strong> 快速更换 SOCKS5 至：user:password@127.0.0.1:1080，您可将"?socks5=user:password@127.0.0.1:1080"参数添加到链接末尾，例如：<br>
 https://${proxyhost}${hostName}/${uuid}<strong>?socks5=user:password@127.0.0.1:1080</strong><br>
 <br>
 <strong>5.</strong> 如需指定多个参数则需要使用'&'做间隔，例如：<br>
 https://${proxyhost}${hostName}/${uuid}?sub=sub.google.com<strong>&</strong>proxyip=proxyip.fxxk.dedyn.io<br>
 </div>
 <script src="https://cdn.jsdelivr.net/npm/@keeex/qrcodejs-kx@1.0.2/qrcode.min.js"></script>
 <script>
 function copyToClipboard(text, qrcode) {
 navigator.clipboard.writeText(text).then(() => {
 alert('已复制到剪贴板');
 }).catch(err => {
 console.error('复制失败:', err);
 });
 const qrcodeDiv = document.getElementById(qrcode);
 qrcodeDiv.innerHTML = '';
 new QRCode(qrcodeDiv, {
 text: text,
 width: 220, // 调整宽度
 height: 220, // 调整高度
 colorDark: "#000000", // 二维码颜色
 colorLight: "#ffffff", // 背景颜色
 correctLevel: QRCode.CorrectLevel.Q, // 设置纠错级别
 scale: 1 // 调整像素颗粒度
 });
 }

 function toggleNotice() {
 const noticeContent = document.getElementById('noticeContent');
 const noticeToggle = document.getElementById('noticeToggle');
 if (noticeContent.style.display === 'none') {
 noticeContent.style.display = 'block';
 noticeToggle.textContent = '实用订阅技巧∧';
 } else {
 noticeContent.style.display = 'none'; 
 noticeToggle.textContent = '实用订阅技巧∨';
 }
 }
 </script>
 ---------------------------------------------------------------<br>
 ################################################################<br>
 ${FileName} 配置信息<br>
 ---------------------------------------------------------------<br>
 ${动态UUID信息}HOST: ${hostName}<br>
 UUID: ${userID}<br>
 FKID: ${fakeUserID}<br>
 UA: ${UA}<br>
 ${订阅器}<br>
 ---------------------------------------------------------------<br>
 ################################################################<br>
 v2ray<br>
 ---------------------------------------------------------------<br>
 <a href="javascript:void(0)" onclick="copyToClipboard('${v2ray}','qrcode_v2ray')" style="color:blue;text-decoration:underline;cursor:pointer;">${v2ray}</a><br>
 <div id="qrcode_v2ray" style="margin: 10px 10px 10px 10px;"></div>
 ---------------------------------------------------------------<br>
 ################################################################<br>
 clash-meta<br>
 ---------------------------------------------------------------<br>
 ${clash}<br>
 ---------------------------------------------------------------<br>
 ################################################################<br>
 ${cmad}
 `;
 return 节点配置页;
 } 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 整理优选列表(addressesnotlsapi);
 newAddressesnotlscsv = await 整理测速结果('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 整理优选列表(addressesnotlsapi);
 newAddressesnotlscsv = await 整理测速结果('FALSE');
 } else {
 fakeHostName = `${fakeHostName}.xyz`
 }
 console.log(`虚假HOST: ${fakeHostName}`);
 let url = `${subProtocol}://${sub}/sub?host=${fakeHostName}&uuid=${fakeUserID + atob('JmVkZ2V0dW5uZWw9Y21saXUmcHJveHlpcD0=') + RproxyIP}&path=${encodeURIComponent(path)}`;
 let isBase64 = true;

 if (!sub || sub == "") {
 if (hostName.includes('workers.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 整理优选列表(addressesapi);
 newAddressescsv = await 整理测速结果('TRUE');
 url = `https://${hostName}/${fakeUserID + _url.search}`;
 if (hostName.includes("worker") || hostName.includes("notls") || noTLS == 'true') {
 if (_url.search) url += '&notls';
 else 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=${subEmoji}&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=${subEmoji}&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 生成本地订阅(fakeHostName, fakeUserID, noTLS, newAddressesapi, newAddressescsv, newAddressesnotlsapi, newAddressesnotlscsv);
 } else {
 const response = await fetch(url, {
 headers: {
 'User-Agent': UA + atob('IENGLVdvcmtlcnMtZWRnZXR1bm5lbC9jbWxpdQ==')
 }
 });
 content = await response.text();
 }

 if (_url.pathname == `/${fakeUserID}`) return content;

 return 恢复伪装信息(content, userID, hostName, isBase64);

 } catch (error) {
 console.error('Error fetching content:', error);
 return `Error fetching content: ${error.message}`;
 }
 }
}

async function 整理优选列表(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': atob('Q0YtV29ya2Vycy1lZGdldHVubmVsL2NtbGl1')
 },
 signal: controller.signal // 将AbortController的信号量添加到fetch请求中，以便于需要时可以取消请求
 }).then(response => response.ok ? response.text() : Promise.reject())));

 // 遍历所有响应
 for (const [index, response] of responses.entries()) {
 // 检查响应状态是否为'fulfilled'，即请求成功完成
 if (response.status === 'fulfilled') {
 // 获取响应的内容
 const content = await response.value;

 const lines = content.split(/\r?\n/);
 let 节点备注 = '';
 let 测速端口 = '443';

 if (lines[0].split(',').length > 3) {
 const idMatch = api[index].match(/id=([^&]*)/);
 if (idMatch) 节点备注 = idMatch[1];

 const portMatch = api[index].match(/port=([^&]*)/);
 if (portMatch) 测速端口 = portMatch[1];

 for (let i = 1; i < lines.length; i++) {
 const columns = lines[i].split(',')[0];
 if (columns) {
 newapi += `${columns}:${测速端口}${节点备注 ? `#${节点备注}` : ''}\n`;
 if (api[index].includes('proxyip=true')) proxyIPPool.push(`${columns}:${测速端口}`);
 }
 }
 } else {
 // 验证当前apiUrl是否带有'proxyip=true'
 if (api[index].includes('proxyip=true')) {
 // 如果URL带有'proxyip=true'，则将内容添加到proxyIPPool
 proxyIPPool = proxyIPPool.concat((await 整理(content)).map(item => {
 const baseItem = item.split('#')[0] || item;
 if (baseItem.includes(':')) {
 const port = baseItem.split(':')[1];
 if (!httpsPorts.includes(port)) {
 return baseItem;
 }
 } else {
 return `${baseItem}:443`;
 }
 return null; // 不符合条件时返回 null
 }).filter(Boolean)); // 过滤掉 null 值
 }
 // 将内容添加到newapi中
 newapi += content + '\n';
 }
 }
 }
 } catch (error) {
 console.error(error);
 } finally {
 // 无论成功或失败，最后都清除设置的超时定时器
 clearTimeout(timeout);
 }

 const newAddressesapi = await 整理(newapi);

 // 返回处理后的结果
 return newAddressesapi;
}

async function 整理测速结果(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 + remarkIndex; // 数据中心是 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);
 if (csvUrl.includes('proxyip=true') && columns[tlsIndex].toUpperCase() == 'true' && !httpsPorts.includes(port)) {
 // 如果URL带有'proxyip=true'，则将内容添加到proxyIPPool
 proxyIPPool.push(`${ipAddress}:${port}`);
 }
 }
 }
 } catch (error) {
 console.error('获取CSV地址时出错:', error);
 continue;
 }
 }

 return newAddressescsv;
}

function 生成本地订阅(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 = "-1";
 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 == "-1") {
 for (let httpPort of httpPorts) {
 if (address.includes(httpPort)) {
 port = httpPort;
 break;
 }
 }
 }
 if (port == "-1") port = "80";

 let 伪装域名 = host;
 let 最终路径 = path;
 let 节点备注 = '';
 const 协议类型 = atob(啥啥啥_写的这是啥啊);

 const 维列斯Link = `${协议类型}://${UUID}@${address}:${port + atob('P2VuY3J5cHRpb249bm9uZSZzZWN1cml0eT0mdHlwZT13cyZob3N0PQ==') + 伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`;

 return 维列斯Link;

 }).join('\n');

 }

 // 使用Set对象去重
 const uniqueAddresses = [...new Set(addresses)];

 const responseBody = uniqueAddresses.map(address => {
 let port = "-1";
 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;
 }

 if (!isValidIPv4(address) && port == "-1") {
 for (let httpsPort of httpsPorts) {
 if (address.includes(httpsPort)) {
 port = httpsPort;
 break;
 }
 }
 }
 if (port == "-1") port = "443";

 let 伪装域名 = host;
 let 最终路径 = path;
 let 节点备注 = '';
 const matchingProxyIP = proxyIPPool.find(proxyIP => proxyIP.includes(address));
 if (matchingProxyIP) 最终路径 += `&proxyip=${matchingProxyIP}`;

 if (proxyhosts.length > 0 && (伪装域名.includes('.workers.dev'))) {
 最终路径 = `/${伪装域名}${最终路径}`;
 伪装域名 = proxyhosts[Math.floor(Math.random() * proxyhosts.length)];
 节点备注 = ` 已启用临时域名中转服务，请尽快绑定自定义域！`;
 }

 const 协议类型 = atob(啥啥啥_写的这是啥啊);
 const 维列斯Link = `${协议类型}://${UUID}@${address}:${port + atob('P2VuY3J5cHRpb249bm9uZSZzZWN1cml0eT10bHMmc25pPQ==') + 伪装域名}&fp=random&type=ws&host=${伪装域名}&path=${encodeURIComponent(最终路径)}#${encodeURIComponent(addressid + 节点备注)}`;

 return 维列斯Link;
 }).join('\n');

 let base64Response = responseBody; // 重新进行 Base64 编码
 if (noTLS == 'true') base64Response += `\n${notlsresponseBody}`;
 if (link.length > 0) base64Response += '\n' + link.join('\n');
 return btoa(base64Response);
}

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 地址数组;
}

async function sendMessage(type, ip, add_data = "") {
 if (!BotToken || !ChatID) return;

 try {
 let msg = "";
 const response = await fetch(`http://ip-api.com/json/${ip}?lang=zh-CN`);
 if (response.ok) {
 const ipInfo = await response.json();
 msg = `${type}\nIP: ${ip}\n国家: ${ipInfo.country}\n<tg-spoiler>城市: ${ipInfo.city}\n组织: ${ipInfo.org}\nASN: ${ipInfo.as}\n${add_data}`;
 } else {
 msg = `${type}\nIP: ${ip}\n<tg-spoiler>${add_data}`;
 }

 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': 'Mozilla/5.0 Chrome/90.0.4430.72'
 }
 });
 } catch (error) {
 console.error('Error sending message:', error);
 }
}

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);
}

function 生成动态UUID(密钥) {
 const 时区偏移 = 8; // 北京时间相对于UTC的时区偏移+8小时
 const 起始日期 = new Date(2007, 6, 7, 更新时间, 0, 0); // 固定起始日期为2007年7月7日的凌晨3点
 const 一周的毫秒数 = 1000 * 60 * 60 * 24 * 有效时间;

 function 获取当前周数() {
 const 现在 = new Date();
 const 调整后的现在 = new Date(现在.getTime() + 时区偏移 * 60 * 60 * 1000);
 const 时间差 = Number(调整后的现在) - Number(起始日期);
 return Math.ceil(时间差 / 一周的毫秒数);
 }

 function 生成UUID(基础字符串) {
 const 哈希缓冲区 = new TextEncoder().encode(基础字符串);
 return crypto.subtle.digest('SHA-256', 哈希缓冲区).then((哈希) => {
 const 哈希数组 = Array.from(new Uint8Array(哈希));
 const 十六进制哈希 = 哈希数组.map(b => b.toString(16).padStart(2, '0')).join('');
 return `${十六进制哈希.substr(0, 8)}-${十六进制哈希.substr(8, 4)}-4${十六进制哈希.substr(13, 3)}-${(parseInt(十六进制哈希.substr(16, 2), 16) & 0x3f | 0x80).toString(16)}${十六进制哈希.substr(18, 2)}-${十六进制哈希.substr(20, 12)}`;
 });
 }

 const 当前周数 = 获取当前周数(); // 获取当前周数
 const 结束时间 = new Date(起始日期.getTime() + 当前周数 * 一周的毫秒数);

 // 生成两个 UUID
 const 当前UUIDPromise = 生成UUID(密钥 + 当前周数);
 const 上一个UUIDPromise = 生成UUID(密钥 + (当前周数 - 1));

 // 格式化到期时间
 const 到期时间UTC = new Date(结束时间.getTime() - 时区偏移 * 60 * 60 * 1000); // UTC时间
 const 到期时间字符串 = `到期时间(UTC): ${到期时间UTC.toISOString().slice(0, 19).replace('T', ' ')} (UTC+8): ${结束时间.toISOString().slice(0, 19).replace('T', ' ')}\n`;

 return Promise.all([当前UUIDPromise, 上一个UUIDPromise, 到期时间字符串]);
}

async function 迁移地址列表(env, txt = 'ADD.txt') {
 const 旧数据 = await env.KV.get(`/${txt}`);
 const 新数据 = await env.KV.get(txt);

 if (旧数据 && !新数据) {
 // 写入新位置
 await env.KV.put(txt, 旧数据);
 // 删除旧数据
 await env.KV.delete(`/${txt}`);
 return true;
 }
 return false;
}

async function KV(request, env, txt = 'ADD.txt') {
 try {
 // POST请求处理
 if (request.method === "POST") {
 if (!env.KV) return new Response("未绑定KV空间", { status: 400 });
 try {
 const content = await request.text();
 await env.KV.put(txt, content);
 return new Response("保存成功");
 } catch (error) {
 console.error('保存KV时发生错误:', error);
 return new Response("保存失败: " + error.message, { status: 500 });
 }
 }

 // GET请求部分
 let content = '';
 let hasKV = !!env.KV;

 if (hasKV) {
 try {
 content = await env.KV.get(txt) || '';
 } catch (error) {
 console.error('读取KV时发生错误:', error);
 content = '读取数据时发生错误: ' + error.message;
 }
 }

 const html = `
 <!DOCTYPE html>
 <html>
 <head>
 <title>优选订阅列表</title>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <style>
 body {
 margin: 0;
 padding: 15px; /* 调整padding */
 box-sizing: border-box;
 font-size: 13px; /* 设置全局字体大小 */
 }
 .editor-container {
 width: 100%;
 max-width: 100%;
 margin: 0 auto;
 }
 .editor {
 width: 100%;
 height: 520px; /* 调整高度 */
 margin: 15px 0; /* 调整margin */
 padding: 10px; /* 调整padding */
 box-sizing: border-box;
 border: 1px solid #ccc;
 border-radius: 4px;
 font-size: 13px;
 line-height: 1.5;
 overflow-y: auto;
 resize: none;
 }
 .save-container {
 margin-top: 8px; /* 调整margin */
 display: flex;
 align-items: center;
 gap: 10px; /* 调整gap */
 }
 .save-btn, .back-btn {
 padding: 6px 15px; /* 调整padding */
 color: white;
 border: none;
 border-radius: 4px;
 cursor: pointer;
 }
 .save-btn {
 background: #4CAF50;
 }
 .save-btn:hover {
 background: #45a049;
 }
 .back-btn {
 background: #666;
 }
 .back-btn:hover {
 background: #555;
 }
 .save-status {
 color: #666;
 }
 .notice-content {
 display: none;
 margin-top: 10px;
 font-size: 13px;
 color: #333;
 }
 </style>
 </head>
 <body>
 ################################################################<br>
 ${FileName} 优选订阅列表:<br>
 ---------------------------------------------------------------<br>
 <strong><a href="javascript:void(0);" id="noticeToggle" onclick="toggleNotice()">注意事项∨</a></strong><br>
 <div id="noticeContent" class="notice-content">
 ${decodeURIComponent(atob('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'))}
 </div>
 <div class="editor-container">
 ${hasKV ? `
 <textarea class="editor" 
 placeholder="${decodeURIComponent(atob('QUREJUU3JUE0JUJBJUU0JUJFJThCJUVGJUJDJTlBCnZpc2EuY24lMjMlRTQlQkMlOTglRTklODAlODklRTUlOUYlOUYlRTUlOTAlOEQKMTI3LjAuMC4xJTNBMTIzNCUyM0NGbmF0CiU1QjI2MDYlM0E0NzAwJTNBJTNBJTVEJTNBMjA1MyUyM0lQdjYKCiVFNiVCMyVBOCVFNiU4NCU4RiVFRiVCQyU5QQolRTYlQUYlOEYlRTglQTElOEMlRTQlQjglODAlRTQlQjglQUElRTUlOUMlQjAlRTUlOUQlODAlRUYlQkMlOEMlRTYlQTAlQkMlRTUlQkMlOEYlRTQlQjglQkElMjAlRTUlOUMlQjAlRTUlOUQlODAlM0ElRTclQUIlQUYlRTUlOEYlQTMlMjMlRTUlQTQlODclRTYlQjMlQTgKSVB2NiVFNSU5QyVCMCVFNSU5RCU4MCVFOSU5QyU4MCVFOCVBNiU4MSVFNyU5NCVBOCVFNCVCOCVBRCVFNiU4QiVBQyVFNSU4RiVCNyVFNiU4QiVBQyVFOCVCNSVCNyVFNiU5RCVBNSVFRiVCQyU4QyVFNSVBNiU4MiVFRiVCQyU5QSU1QjI2MDYlM0E0NzAwJTNBJTNBJTVEJTNBMjA1MwolRTclQUIlQUYlRTUlOEYlQTMlRTQlQjglOEQlRTUlODYlOTklRUYlQkMlOEMlRTklQkIlOTglRTglQUUlQTQlRTQlQjglQkElMjA0NDMlMjAlRTclQUIlQUYlRTUlOEYlQTMlRUYlQkMlOEMlRTUlQTYlODIlRUYlQkMlOUF2aXNhLmNuJTIzJUU0JUJDJTk4JUU5JTgwJTg5JUU1JTlGJTlGJUU1JTkwJThECgoKQUREQVBJJUU3JUE0JUJBJUU0JUJFJThCJUVGJUJDJTlBCmh0dHBzJTNBJTJGJTJGcmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSUyRmNtbGl1JTJGV29ya2VyVmxlc3Myc3ViJTJGcmVmcyUyRmhlYWRzJTJGbWFpbiUyRmFkZHJlc3Nlc2FwaS50eHQKCiVFNiVCMyVBOCVFNiU4NCU4RiVFRiVCQyU5QUFEREFQSSVFNyU5QiVCNCVFNiU4RSVBNSVFNiVCNyVCQiVFNSU4QSVBMCVFNyU5QiVCNCVFOSU5MyVCRSVFNSU4RCVCMyVFNSU4RiVBRg=='))}"
 id="content">${content}</textarea>
 <div class="save-container">
 <button class="back-btn" onclick="goBack()">返回配置页</button>
 <button class="save-btn" onclick="saveContent(this)">保存</button>
 <span class="save-status" id="saveStatus"></span>
 </div>
 <br>
 ################################################################<br>
 ${cmad}
 ` : '<p>未绑定KV空间</p>'}
 </div>
 
 <script>
 if (document.querySelector('.editor')) {
 let timer;
 const textarea = document.getElementById('content');
 const originalContent = textarea.value;
 
 function goBack() {
 const currentUrl = window.location.href;
 const parentUrl = currentUrl.substring(0, currentUrl.lastIndexOf('/'));
 window.location.href = parentUrl;
 }
 
 function replaceFullwidthColon() {
 const text = textarea.value;
 textarea.value = text.replace(/：/g, ':');
 }
 
 function saveContent(button) {
 try {
 const updateButtonText = (step) => {
 button.textContent = \`保存中: \${step}\`;
 };
 // 检测是否为iOS设备
 const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
 
 // 仅在非iOS设备上执行replaceFullwidthColon
 if (!isIOS) {
 replaceFullwidthColon();
 }
 updateButtonText('开始保存');
 button.disabled = true;
 // 获取textarea内容和原始内容
 const textarea = document.getElementById('content');
 if (!textarea) {
 throw new Error('找不到文本编辑区域');
 }
 updateButtonText('获取内容');
 let newContent;
 let originalContent;
 try {
 newContent = textarea.value || '';
 originalContent = textarea.defaultValue || '';
 } catch (e) {
 console.error('获取内容错误:', e);
 throw new Error('无法获取编辑内容');
 }
 updateButtonText('准备状态更新函数');
 const updateStatus = (message, isError = false) => {
 const statusElem = document.getElementById('saveStatus');
 if (statusElem) {
 statusElem.textContent = message;
 statusElem.style.color = isError ? 'red' : '#666';
 }
 };
 updateButtonText('准备按钮重置函数');
 const resetButton = () => {
 button.textContent = '保存';
 button.disabled = false;
 };
 if (newContent !== originalContent) {
 updateButtonText('发送保存请求');
 fetch(window.location.href, {
 method: 'POST',
 body: newContent,
 headers: {
 'Content-Type': 'text/plain;charset=UTF-8'
 },
 cache: 'no-cache'
 })
 .then(response => {
 updateButtonText('检查响应状态');
 if (!response.ok) {
 throw new Error(\`HTTP error! status: \${response.status}\`);
 }
 updateButtonText('更新保存状态');
 const now = new Date().toLocaleString();
 document.title = \`编辑已保存 \${now}\`;
 updateStatus(\`已保存 \${now}\`);
 })
 .catch(error => {
 updateButtonText('处理错误');
 console.error('Save error:', error);
 updateStatus(\`保存失败: \${error.message}\`, true);
 })
 .finally(() => {
 resetButton();
 });
 } else {
 updateButtonText('检查内容变化');
 updateStatus('内容未变化');
 resetButton();
 }
 } catch (error) {
 console.error('保存过程出错:', error);
 button.textContent = '保存';
 button.disabled = false;
 const statusElem = document.getElementById('saveStatus');
 if (statusElem) {
 statusElem.textContent = \`错误: \${error.message}\`;
 statusElem.style.color = 'red';
 }
 }
 }
 
 textarea.addEventListener('blur', saveContent);
 textarea.addEventListener('input', () => {
 clearTimeout(timer);
 timer = setTimeout(saveContent, 5000);
 });
 }
 
 function toggleNotice() {
 const noticeContent = document.getElementById('noticeContent');
 const noticeToggle = document.getElementById('noticeToggle');
 if (noticeContent.style.display === 'none' || noticeContent.style.display === '') {
 noticeContent.style.display = 'block';
 noticeToggle.textContent = '注意事项∧';
 } else {
 noticeContent.style.display = 'none';
 noticeToggle.textContent = '注意事项∨';
 }
 }
 
 // 初始化 noticeContent 的 display 属性
 document.addEventListener('DOMContentLoaded', () => {
 document.getElementById('noticeContent').style.display = 'none';
 });
 </script>
 </body>
 </html>
 `;

 return new Response(html, {
 headers: { "Content-Type": "text/html;charset=utf-8" }
 });
 } catch (error) {
 console.error('处理请求时发生错误:', error);
 return new Response("服务器错误: " + error.message, {
 status: 500,
 headers: { "Content-Type": "text/plain;charset=utf-8" }
 });
 }
}

域名

注册一个免费的域名，可以使用零度前几期介绍的注册方法，来获取你自己的免费域名【点击前往】当然如果你已经有域名那么更好！有域名就可以添加进自定义域了

UUID

在设置中，找到 变量与机密 ，添加一条，标题为

UUID

值自己随意定，假设值为

访问

打开浏览器，输入你的自定义域，并在结尾加上

/114514

如果前一步的值为其他值，则填入

/其他值

优选

如果想获得更多的优质节点，那么推荐使用IP优选网站或优选工具进行获取！【点击前往】

视频链接

https://youtu.be/DYGu71OaqGI

关于steam的注册，客户端下载，及更多内容

Sat, 21 Jun 2025 22:43:29 +0800

准备工作：

一个邮箱（事实上不太推荐QQ邮箱，不过我自己用的就是QQ邮箱，所以无所diao谓）、
一台电脑（win10/11，mac也行，Linux……也不是不可以，但是我这里不教macOS和Linux的安装方法）（电脑下载电脑客户端用，你要是不玩游戏只是领个别人送的礼物，或者趁促销结束前赶紧买个游戏，那一台手机也可以）
加速器
- UU加速器、雷神加速器、迅游加速器皆可免费加速steam，可以使用
- 使用VPN的朋友，可以直接使用VPN
- steam++（watt tolkit）也可免费加速

安装steam Windows客户端（以下简称客户端）

开启加速器
打开steam官网
点击右上方的绿色按钮「安装steam」
点击左侧蓝色大按钮「安装steam」，然后运行浏览器所下载的可执行文件（.exe）
双击安装包，若弹出用户账户控制界面，选择是，进入安装页面
一路选择下一步注：在选定安装路径时，遵循一下要点：
- 路径内无中文字符，包括特殊符号
- 建议不要装到C盘（当然只有C盘那就装C盘吧）
完成，steam自动更新，等待即可

注册

注：此步骤极难（），可寻求他人帮助

在客户端窗口打开后，点击登录界面的右下角「创建免费账户」
填写你的邮箱到上面两行
进行人机验证注：此步骤极难（）建议使用手机热点作为WiFi，并保持加速器开启。若失败请多次尝试，或更换加速器节点
勾选同意条款
在出现「正在等待您进行验证」的窗口后，打开邮箱，接收到一封来自steam的邮件，点击邮件中的蓝色大按钮「验证我的电子邮件地址」
想一个好记的名称，用于账户登录，只可使用英文、数字，不可使用中文与特殊字符
想一个好记的密码，用于登录

安装steam Android客户端

打开https://media.steampowered.com/apps/steam-android/steam-3.10.0.apk并下载安装包（.apk）
点击并安装即可

安装steam iOS客户端

打开https://apps.apple.com/us/app/steam-mobile/id495369748，跳转到app store
点击「获取」并安装即可

更改个人资料名称

如果你嫌初始名称不好听，可通过以下方法更改（此方法无法更改登录名称）

点击客户端主页右上角的「管理账户」按钮（从左往右数第三个按钮）
点击查看我的个人资料
点击右侧的「编辑个人资料」
更改个人资料名称

hexo博客搭建指北

Sun, 11 May 2025 20:02:30 +0800

注：教程以Windows系统为例

1. 安装Node.js

2. 安装git

一直点确定就行，全部按它默认勾的，若要细细配置可参照这篇文章

3. 测试一下，管理员运行cmd，依次输入

node -v
npm -v
git -v

若正常显示版本号即可

4. 下载hexo

新建一个文件夹，用来存放blog
右键，选择Open git bash here
依次输入

npm install hexo-cli -g
hexo init blog
cd blog
npm install
hexo server

5. 简单认识hexo

进入自动创建的blog文件夹
_config.yml，在这个文件内修改博客基础设置
blog\source_posts，在这个文件夹内修改博客文章
themes，在这个文件夹内修改主题
在自动创建的blog文件夹内右键，选择Open git bash here
基础指令：

# 开启服务
hexo s

# 新建文章
hexo new 文章名

# 新建草稿
hexo new draft 文章名

# 发布草稿成为文章
hexo publish 文章名

# 普通页面
hexo new page 页面名

# 清空缓存
hexo cl

# 生成静态页面
hexo g
# 然后访问localhost:4000

# 部署文章
hexo d

6. 搭建仓库

注册/登入Github（可能无法访问，建议使用watt tolkit）
点击Create a new repository进入新建仓库页面，仓库名输入：

你的GitHub用户名.github.io

勾选 Public
勾选 Add a README file
拉到下面点击create创建

7. 生成SSH Keys

进入任意文件夹，右键空白处然后点Open Git bash here,输入

ssh-keygen -t rsa -C "你的GitHub注册邮箱"

敲4次Enter
进入C:\Users\用户名，在里面进入 .ssh文件夹
打开里面的id_rsa.pub，全选复制里面的代码
打开github
进入用户设置，找到SSH keys
新建SSH keys，名称随意，在下面粘贴代码，然后创建

8. 测试是否成功

在git bash中输入

ssh -T git@github.com

回车，然后再输入yes

9. 配置_config.yml

进入之前的Blog文件夹，打开 _config.yml
拉到最下面将deploy后面的全删掉，复制粘贴这段

 type: git
 repository: 
 branch: main

注意缩进格式：每行前面都有两个空格不要删，每个冒号后面都有个空格也不要删！

去github之前生成的仓库页面，点code，复制https链接，将其粘贴到**repository：**后面，然后保存退出

10. 安装自动部署发布工具

回到博客文件夹，一样git bash
输入：

npm install hexo-deployer-git --save

在Blog文件夹右键打开git bash，依次输入

hexo g
hexo d

如果是第一次使用git的话会需要配置

git config --global user.email

user.email即你注册GitHub的邮箱

git config --global user.name

user.name即你注册GitHub的名字

配置完后再输入

hexo d

，然后在跳出来的窗口内进行登录接下来我们就成功把本地内容上传到github了

11.上传成功

上传成功以后，我们就算搭建好了！上自己的网址看看吧网址是我们之前设的仓库名：你的GitHub用户名.github.io

LSPatch使用指北

Sat, 12 Apr 2025 14:45:15 +0800

注：LSPatch支持系统：Android，且需要使用Shizuku

下载并安装LSPatch

点击下载，下载安装包（.apk）
点击安装包，安装软件

激活LSPatch

打开LSPatch，显示Shizuku服务未连接，部分功能不可用，不过没关系，可以先不管它
点击LSPatch下方第二个图标管理，再点击右下角的加号，此时会提示选择一个目录来存储已修复的apk
选择自己方便调用的文件夹，点击使用此文件夹并给予存储权限
再点击加号，弹出新建修补，我们可从存储目录中选择安装包（.apk）或选择已安装的应用程序
选择好程序和修补模式后即可开始修补注：推荐便携模式并嵌入提前下载好的对应Xposed模块，模块需要自行寻找，后文会放几个模块供大家练手
修复过程需要耐心等待一段时间，待修补完成后我们点击安装会提示Shizuku服务未链接，这是因为前面我们刚打开LSPatch时显示的Shizuku服务未连接部分功能不可用，不过没有关系，但是如果想使用Shizuku可以参考这篇文章
在文件管理器里打开刚才设置的文件夹，可以看到修补后的安装包,只需要手动卸载原包再手动安装修补后的包即可。安装完成后打开该APP，在设置中可以看到模块已嵌入成功（有的模块可能不会在设置里显示）

提醒事项

用便携模式修补后的APK可脱离LSPatch框架使用，分享给别的设备也可正常使用对应模块。而本地模式修补无需内置模块，但是修补后的应用需要LSPatch保持后台持续运行且需要Shizuku才能正常使用，并且只能在本机上运行，这也是更推荐大家使用便携模式的原因
若模块在嵌入后不起作用，可能是模块本体的问题，也可能是安装包的问题（这不跟没说一样吗），需自行查找问题

关于模块

模块通常以软件形式存在，下载后是安装包，需要安装后才能使用

官方仓库，里面有大量模块，但是被墙了，可以参考这篇文章使用Clash或者其他软件进行科学上网，这里不过多赘述
模块推荐：
1. HookVIP，目前最新的3.5.5与3.5.6已经失效，只有3.5.4可以正常使用
2. 道道道，功能很简单，破解一些VPN应用会员，但是很好用
3. 杜比大喇叭，一款网易云音乐的音源代理模块。模块工作原理为音源替换而非破解，所以单曲付费与无版权歌曲有几率匹配错误，真心支持歌手请付费！

Shizuku使用指北

Sat, 12 Apr 2025 10:00:39 +0800

注：Shizuku支持系统：Android

下载并安装shizuku

点击下载，下载安装包（.apk）
点击安装包，安装软件

激活shizuku

打开开发人员选项 通常是进入关于后点击版本号5或7次，可能会要求输入密码，不同品牌可能会有区别，视情况而定
进入开发人员选项
找到调试一栏中的USB调试和仅充电模式下允许ADB调试（没有仅充电模式下允许ADB调试可以不开），将其开启

接下来的步骤会分为两大类，请视自己情况而定

若在调试一栏中找到无线调试，可以跳转到下一章节 若没有无线调试，请准备一台搭载Windows系统的电脑并继续往下看

通过电脑启动（无无线调试，适用于Windows）

下载ADB调试工具
解压缩后将解压出来的文件夹重命名为adb并移动到C盘根目录（非必需，但是推荐这么做）
进入电脑设置，搜索高级系统设置并进入
选择环境变量
点击系统变量一栏中的path并双击进行编辑
点击右侧新建
输入刚才的文件路径（C:\adb）
然后一路确定，保存并退出
接下来将手机（或其他设备）连接电脑，
打开cmd（直接在搜索栏输入并回车），输入adb devices，此时若正确开起了开发人员选项中的USB调试，此时设备上可能会出现是否允许调试的对话框，勾选总是允许，接下来可以在通知中心看到USB调试的信息
再次在终端中输入adb devices，如无问题将会看到类似如下内容

List of devices attached
XXX device

复制以下指令并粘贴到cmd中，如无问题你将会在 Shizuku 中看到已启动成功

adb shell sh /sdcard/Android/data/moe.shizuku.privileged.api/start.sh

该启动方式适用于未 root 且运行 Android 10 及以下版本或者HarmonyOS的设备。很不幸，该启动方式需要连接电脑。且由于系统限制，每次重新启动后都需要再次进行启动步骤

通过无线调试启动

进入开发人员选项中的无线调试
启用无线调试
配对（仅需一次）
1. 在 Shizuku 内开始配对
2. 点按无线调试中的使用配对码配对设备
3. 在Shizuku的通知中填入配对码
启动Shizuku 如果无法启动，尝试禁用并启用无线调试

通过无线调试启动适用于 Android 11 或以上版本。这种启动方式无需连接电脑。由于系统限制，每次重新启动后都需要再次进行启动步骤

通过 root 启动

如果您的设备已经 root，直接启动即可

常见问题

许多厂商对 Android 系统进行了修改，这会造成 Shizuku 无法正常工作。

通过无线调试启动：一直显示“正在搜索配对服务”

请允许 Shizuku 在后台运行。搜索配对服务需要访问本地网络，许多厂商在应用不可见后立刻禁止应用访问网络。您可以在网络上搜索如何在您的设备上允许应用在后台运行。

通过无线调试启动：点击“输入配对码”后立刻提示失败

MIUI（小米、POCO）在系统设置的“通知管理”-“通知显示设置”将通知样式切换为“原生样式”。

通过无线调试启动/通过连接电脑启动：adb 权限受限

MIUI（小米、POCO）

在“开发者选项”中开启“USB 调试（安全设置）”。注意，这和“USB 调试”是两个分开的选项。

ColorOS（OPPO & OnePlus）

在“开发者选项”中关闭“权限监控”。

Flyme（魅族）

在“开发者选项”中关闭“Flyme 支付保护”。

通过无线调试启动/通过连接电脑启动：Shizuku 随机停止

所有设备

保证 Shizuku 可以在后台运行。

不要关闭“USB 调试”及“开发者选项”。

在“开发者选项”中将 USB 使用模式改为“仅充电”。

在 Android 8 上的选项是“选择 USB 配置”-“仅充电”。在 Android 9 及以上版本上选项是“默认 USB 配置”-“不进行数据传输”。

（Android 11+）启用“停用 adb 授权超时功能”选项

EMUI (华为)

在“开发者选项”中开启「“仅充电”模式下允许 ADB 调试选项」。

MIUI（小米、POCO）

不要使用“手机管家”的扫描功能，因为它会禁用开发者选项。

Sony

不要点击连接 USB 后弹出的对话框，因为这会导致 USB 使用模式发生变化。

通过 root 启动：无法开机启动

请允许 Shizuku 在后台运行。

Clash使用指北

Fri, 04 Apr 2025 19:53:20 +0800

墙国有我，请挡放心

此文档为学习交流而分享，建议您在下载后24小时内删除。如有版权问题请告知，我将第一时间处理。请注意，使用产生的责任需由使用者自行承担。

尽量使用浏览器打开本文章（如edge），而非微信内置浏览器等

注意：Clash支持系统：Android，Windows，MacOS（本教程不涉及）

iOS及iPadOS可以使用Spectre或者Shadowrocket，以及hidify，请自行去App Store下载。

Windows安装及使用（以Clash Verge Rev为例）：

下载Clash Verge Rev，双击安装包并安装（若申请管理员权限则允许），步骤如下
- 选择语言（推荐中文简体），点击OK
- 点击下一步
- 点击下一步
- 点击安装
- 等待
- 点击下一步
- 点击完成
- 后续可能会申请两次管理员权限，允许即可
导入配置文件
- 若配置文件需从链接下载，则点击左侧订阅，在页面上方订阅文件链接处输入链接，点击右侧导入即可。
- 若配置文件在本地，则只需将文件拖拽进窗口即可
使用
- 点击左侧设置，点击左列系统代理即可使用，不需要时可直接关闭系统代理
推荐打开：开机自启；静默启动；局域网链接
- 局域网链接说明：对于部分无法使用clash客户端的设备，可通过这种方式实现曲线救国，具体操作如下：
- 点进设置并与电脑链接在同一局域网，点进网络详情，将http代理切换为手动，服务器填写为电脑的内网IP地址，可点击clash设置中局域网链接旁边的有三个连接在一起的方块的图标查看，上面的IP地址即为所要
- 端口默认是7897
- 关闭鉴定

Android安装及使用

下载Clash Meta for Android，点击安装包（文件后缀为apk），安装
打开Clash Meta for Android，点击配置
点击右上角加号，然后导入
- 若配置文件需从链接下载，则点击从URL导入，输入链接后点击右上角保存按钮
- 若配置文件在本地，则点击从文件导入，点击浏览文件，点击配置文件右侧三个点，点击下方弹出窗口的导入，选择文件后点击左上角箭头，点击右上角保存按钮
回到主页，点击启动，若申请权限则同意
点击代理可选择节点，若想停止只需回到主页，点击运行中（蓝色的图标）即可停止

部分Android手机在控制中心可以自定义快捷开关，可以将Clash Meta快捷开关添加到控制中心，以方便使用部分情况下会碰到无法添加配置文件的情况，可以多尝试几次，不排除是服务器或软件的问题

文章可能会继续更新以补充使用技巧，文章中所有下载链接来自Clash中文网