File size: 17,330 Bytes
e48a2d8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 | // subscription.go 代理订阅归一化:把「订阅内容」变成可导入的代理 URL(借鉴
// ardeyouxipianyi/workbuddy2api-hub 的 wb_subbridge.py 的输入侧)。
//
// 为什么需要:本网关的传输层只支持 http / https / socks5 三种代理(见 transport.go),
// 而订阅给的是 base64 的 ss/vmess/trojan 列表或 Clash YAML。此前唯一的导入入口是
// 「一行一个 http:// 或 socks5:// URL」,于是订阅拿到手还得手工转一遍。
//
// 本文件做的是**纯文本解析**,不做的事有三件,都是刻意的:
//
// 1. **不抓取订阅 URL**。面板进程去 GET 任意外部地址是 SSRF 面(内网地址探测、
// 云元数据端点),要有独立的域名白名单与出站审计才安全,不在这版范围。用户把
// 订阅内容(或订阅返回的正文)粘进来即可。
// 2. **不起 mihomo/clash 子进程**。参照实现为了支持 ss/vmess/trojan 起一个本地
// mihomo 监听并渲染 yaml,那是把「网关」变成「代理编排器」:多一个二进制、
// 多一份配置生成器、多一组进程生命周期问题。本网关的取舍是不支持这些协议,
// 而是**明确报出被跳过的是哪些、为什么**(ImportResult.Status = "unsupported"
// 带上协议名),让运维知道该另外起一个本地 mihomo 再把它的 socks5 端口导入。
// 3. **不猜**。认不出的行报 invalid 并原样留在输入框里(面板既有行为),不做
// 「尽力而为」的模糊匹配——一条猜错的代理会把某个账号的流量发到不该去的地方。
package proxypool
import (
"encoding/base64"
"fmt"
"net"
"net/url"
"strconv"
"strings"
)
// SubEntry 订阅里的一项:要么归一出了受支持的 URL,要么带一条说明为什么不行。
type SubEntry struct {
// Line 原文行号(1 起)。Clash 块式条目取该条目首行,便于用户在 yaml 里定位。
Line int
// Name 订阅里给的名字(Clash 的 name 字段 / URI 的 fragment),仅作展示。
Name string
// Kind 原始协议名(http / socks5 / ss / vmess / …),报错文案用。
Kind string
// URL 归一后的代理 URL(http/https/socks5)。空 = 不支持或无法解析。
URL string
// Unsupported true = 协议**认得出来**,只是本网关的传输层不解析它
// (ss / vmess / trojan …)。与「认不出的行」是两件事:前者不是用户写错了,
// 报「格式错误」会让人去改一个本来正确的东西。
Unsupported bool
// Reason 不支持 / 无法解析的原因(人类可读)。URL 非空时为空。
Reason string
}
// supportedProxySchemes 传输层真正支持的协议(与 parseURL 的 defaultPort 同一份口径)。
var supportedProxySchemes = map[string]string{
"http": "80", "https": "443", "socks5": "1080", "socks5h": "1080",
}
// knownUnsupportedSchemes 认得出来、但本网关不解析的订阅协议。
//
// 列出来是为了给出**具体**的报错(「ss 不解析」)而不是笼统的「格式错误」——
// 后者会让用户以为是自己粘错了。
var knownUnsupportedSchemes = map[string]bool{
"ss": true, "ssr": true, "vmess": true, "vless": true, "trojan": true,
"hysteria": true, "hysteria2": true, "hy2": true, "tuic": true,
"wireguard": true, "wg": true, "snell": true, "juicity": true, "anytls": true,
"mieru": true, "ssh": true, "socks4": true, "socks4a": true,
}
// ParseSubscription 把订阅正文归一成条目列表。空输入返回空列表(不是错误)。
//
// 支持三种形态,自动识别:
// - 明文 URI 列表(一行一个 http:// / socks5:// / ss:// …);
// - base64 正文(V2Ray/机场最常见的 ss/vmess 订阅,整段 base64);
// - Clash / mihomo 的 YAML 配置(只取 proxies: 段)。
func ParseSubscription(text string) ([]SubEntry, error) {
// 刻意**不** TrimSpace 原文:行号是面板回填输入框的索引(无效行会被原样放回
// 文本框让用户改),前面少几行就会错位——实测「首行是空行」的输入因此把第 2 行
// 报成第 1 行。只在判空时 Trim。
if strings.TrimSpace(text) == "" {
return nil, nil
}
if decoded, ok := decodeBase64Body(text); ok {
text = strings.TrimSpace(decoded)
}
if hasClashProxies(text) {
return parseClashProxies(text)
}
return parseURILines(text)
}
// decodeBase64Body 整段 base64 订阅(去掉换行后解码)。判据刻意收紧:
//
// 原文必须既不含 "://" 也不含 "proxies:" —— 那两种是明文订阅与 yaml 的特征,
// 先排除掉才不会把「恰好全由 base64 字符组成的配置」误当编码内容;
// 解码结果必须含 "://" 或 "proxies:" —— 否则这就是一段碰巧能解出来的字,不是订阅。
//
// 返回 ok=false 时调用方按原文继续处理(绝不因为「不像 base64」就丢弃输入)。
func decodeBase64Body(text string) (string, bool) {
if strings.Contains(text, "://") || strings.Contains(strings.ToLower(text), "proxies:") {
return "", false
}
compact := strings.Join(strings.Fields(text), "")
if compact == "" {
return "", false
}
for _, enc := range []*base64.Encoding{
base64.StdEncoding, base64.RawStdEncoding,
base64.URLEncoding, base64.RawURLEncoding,
} {
raw, err := enc.DecodeString(compact)
if err != nil {
continue
}
decoded := string(raw)
if strings.Contains(decoded, "://") || strings.Contains(strings.ToLower(decoded), "proxies:") {
return decoded, true
}
}
return "", false
}
// hasClashProxies 报告正文是否是一个带 proxies: 段的 Clash 配置。
func hasClashProxies(text string) bool {
for _, line := range strings.Split(text, "\n") {
if isClashProxiesKey(line) {
return true
}
}
return false
}
// isClashProxiesKey 顶层(或任意缩进)的 `proxies:` 键。
//
// 允许缩进是因为有的订阅把 proxies 放在别的结构里;`proxies: []` 这种空值的也认
// (下面解析会得到 0 条,用户看到「没有可用节点」而不是「格式错误」)。
// 值为**流式序列**(`proxies: [{...}, {...}]`)时同样是合法的 proxies 段——此前只认
// 字面量 "[]",于是这种写法整体落到 URI 行解析,产出一个既无 type 也无 server 的
// 空条目:节点被静默丢掉,还不报错。
func isClashProxiesKey(line string) bool {
t := strings.TrimSpace(line)
if !strings.HasPrefix(t, "proxies:") {
return false
}
rest := strings.TrimSpace(strings.TrimPrefix(t, "proxies:"))
if rest == "" || strings.HasPrefix(rest, "#") {
return true
}
return strings.HasPrefix(rest, "[")
}
// parseClashProxies 只解析 proxies: 段,其余段一概不看。
//
// 为什么手写而不引 YAML 库:仓库当前零 yaml 依赖,而为「读一个 {type, server, port,
// username, password}」这五个标量字段引一个通用解析器不值得——它带来的是一整套
// 类型系统与宽松语法的边界问题,而我们只需要扁平的 key: value。
//
// 支持两种写法(都是真实订阅里出现的):
//
// - name: 香港 01
// type: socks5
// server: hk.example.com
// port: 1080
// username: u
// password: p
//
// - {name: "香港 01", type: socks5, server: hk.example.com, port: 1080}
//
// 段内出现新的顶层键(proxy-groups: 等)即结束。
func parseClashProxies(text string) ([]SubEntry, error) {
lines := strings.Split(text, "\n")
var out []SubEntry
inProxies := false
// baseIndent 「- 」列表项的缩进;块式条目的字段缩进必须比它深。
baseIndent := -1
var cur map[string]string
var curLine int
var curName string
flush := func() {
if cur == nil {
return
}
out = append(out, clashEntryToSubEntry(curLine, curName, cur))
cur = nil
}
for i, raw := range lines {
lineNo := i + 1
line := strings.TrimRight(raw, "\r")
trimmed := strings.TrimSpace(line)
if trimmed == "" || strings.HasPrefix(trimmed, "#") {
continue
}
indent := len(line) - len(strings.TrimLeft(line, " \t"))
if !inProxies {
if isClashProxiesKey(line) {
// proxies 的值是流式序列时整段取出来单独解析(可能同一行,也可能跨行:
// proxies: [{...}, {...}]
// proxies: [
// {...},
// ]
// )。块式写法(下一行起 "- name: ...")走下面的逐行状态机,两条路径
// 互斥,不会重复解析。
if val, vl, ok := flowSequenceValue(lines, i); ok {
if !bracketsBalanced(val) {
// 未闭合的数组按错误上报:静默返回 0 条会让用户以为订阅是空的。
return nil, fmt.Errorf("proxies 的流式数组未闭合(第 %d 行起)", vl)
}
return append(out, parseFlowArray(vl, val)...), nil
}
inProxies = true
}
continue
}
// 段结束:出现非列表项、且缩进不比列表项深的 key(如 proxy-groups:)。
if !strings.HasPrefix(trimmed, "- ") && trimmed != "-" {
if baseIndent < 0 || indent <= baseIndent {
flush()
inProxies = false
continue
}
// 块式条目的字段行。
if cur != nil {
if k, v, ok := splitYAMLKV(trimmed); ok {
cur[k] = v
}
}
continue
}
// 新的列表项。
flush()
if baseIndent < 0 {
baseIndent = indent
}
item := strings.TrimSpace(strings.TrimPrefix(trimmed, "-"))
curLine = lineNo
cur = map[string]string{}
curName = ""
if strings.HasPrefix(item, "{") {
// 流式写法:整条在行内。
cur = parseFlowMap(item)
curName = cur["name"]
flush()
continue
}
if k, v, ok := splitYAMLKV(item); ok {
cur[k] = v
if k == "name" {
curName = v
}
}
}
flush()
return out, nil
}
// flowSequenceValue 取出 `proxies:` 的流式序列值(`[...]`,含跨行形式),并返回其
// 起始行号(1 起)。值不是流式序列(块式 `- name: ...`)时 ok=false,调用方走原来的
// 逐行状态机。
//
// 三种真实写法都要认:
//
// proxies: [{name: a, ...}, {name: b, ...}]
// proxies: [
// {name: a, ...},
// ]
// proxies:
// [{name: a, ...}]
func flowSequenceValue(lines []string, keyIdx int) (string, int, bool) {
rest := strings.TrimSpace(valueAfterColon(lines[keyIdx]))
if rest == "" {
// 值在后续行:跳过空行与注释行,看第一行是不是 "["。
for j := keyIdx + 1; j < len(lines); j++ {
t := strings.TrimSpace(strings.TrimRight(lines[j], "\r"))
if t == "" || strings.HasPrefix(t, "#") {
continue
}
if !strings.HasPrefix(t, "[") {
return "", 0, false
}
return collectFlowValue(lines, j, t), j + 1, true
}
return "", 0, false
}
if !strings.HasPrefix(rest, "[") {
return "", 0, false
}
return collectFlowValue(lines, keyIdx, rest), keyIdx + 1, true
}
// collectFlowValue 从 start 行开始累积,直到方括号配平(跨行时按空格拼接,跳过纯注释行)。
func collectFlowValue(lines []string, start int, first string) string {
buf := first
if bracketsBalanced(buf) {
return buf
}
for j := start + 1; j < len(lines); j++ {
t := strings.TrimSpace(strings.TrimRight(lines[j], "\r"))
if t == "" || strings.HasPrefix(t, "#") {
continue
}
buf += " " + t
if bracketsBalanced(buf) {
break
}
}
return buf
}
// valueAfterColon 取 `key: value` 里冒号之后的部分(未去引号;只用于判形态)。
func valueAfterColon(line string) string {
i := strings.Index(line, ":")
if i < 0 {
return ""
}
return strings.TrimSpace(line[i+1:])
}
// bracketsBalanced 报告 [ ] 与 { } 是否配平,忽略引号内的括号(名字/密码里出现
// 括号是常见的,按字符数数必然误判)。
func bracketsBalanced(s string) bool {
depth := 0
var quote byte
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case quote != 0:
if c == '\\' {
i++
} else if c == quote {
quote = 0
}
case c == '"' || c == '\'':
quote = c
case c == '[' || c == '{':
depth++
case c == ']' || c == '}':
depth--
}
}
return depth == 0 && quote == 0
}
// parseFlowArray 解析 `[ {...}, {...} ]` 形式的流式数组。
func parseFlowArray(lineNo int, s string) []SubEntry {
inner := strings.TrimSpace(strings.TrimPrefix(strings.TrimSuffix(strings.TrimSpace(s), "]"), "["))
var out []SubEntry
for _, part := range splitFlowItems(inner) {
m := parseFlowMap(part)
if len(m) == 0 {
continue
}
out = append(out, clashEntryToSubEntry(lineNo, m["name"], m))
}
return out
}
// splitFlowItems 按顶层逗号切分流式写法(引号内、花括号内的逗号不切)。
func splitFlowItems(s string) []string {
var parts []string
var buf strings.Builder
depth := 0
var quote byte
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case quote != 0:
if c == quote {
quote = 0
} else if c == '\\' && i+1 < len(s) {
buf.WriteByte(c)
i++
c = s[i]
}
case c == '"' || c == '\'':
quote = c
case c == '{' || c == '[':
depth++
case c == '}' || c == ']':
depth--
case c == ',' && depth == 0:
parts = append(parts, buf.String())
buf.Reset()
continue
}
buf.WriteByte(c)
}
if s := strings.TrimSpace(buf.String()); s != "" {
parts = append(parts, s)
}
return parts
}
// parseFlowMap 把 `{k: v, k2: v2}`(或去掉花括号的 `k: v, k2: v2`)解析成 map。
func parseFlowMap(s string) map[string]string {
s = strings.TrimSpace(s)
s = strings.TrimPrefix(s, "{")
s = strings.TrimSuffix(s, "}")
out := map[string]string{}
for _, part := range splitFlowItems(s) {
if k, v, ok := splitYAMLKV(part); ok {
out[k] = v
}
}
return out
}
// splitYAMLKV 切 `key: value`,去掉值两端引号。没有冒号或键为空时 ok=false。
func splitYAMLKV(s string) (string, string, bool) {
s = strings.TrimSpace(s)
i := strings.Index(s, ":")
if i <= 0 {
return "", "", false
}
k := strings.TrimSpace(s[:i])
v := strings.TrimSpace(s[i+1:])
if k == "" {
return "", "", false
}
// 去掉 yaml 注释(值里的人名/密码带 # 的情况极少,且带引号时下面的 Trim 会先处理)。
if len(v) >= 2 && ((v[0] == '"' && v[len(v)-1] == '"') || (v[0] == '\'' && v[len(v)-1] == '\'')) {
v = v[1 : len(v)-1]
}
return strings.ToLower(k), v, true
}
// clashEntryToSubEntry 把一条 Clash 代理定义转成受支持的代理 URL,或给出不支持的说明。
func clashEntryToSubEntry(line int, name string, m map[string]string) SubEntry {
kind := strings.ToLower(strings.TrimSpace(m["type"]))
e := SubEntry{Line: line, Name: name, Kind: kind}
if kind == "" {
e.Reason = "缺少 type 字段,无法判定协议"
return e
}
if knownUnsupportedSchemes[kind] {
e.Unsupported = true
e.Reason = unsupportedReason(kind)
return e
}
if _, ok := supportedProxySchemes[kind]; !ok {
e.Reason = "未知的代理类型 " + kind + "(本网关只支持 http/https/socks5)"
return e
}
host := strings.TrimSpace(m["server"])
if host == "" {
e.Reason = "缺少 server 字段"
return e
}
port, err := strconv.Atoi(strings.TrimSpace(m["port"]))
if err != nil || port < 1 || port > 65535 {
e.Reason = "port 字段缺失或不是 1-65535 的整数"
return e
}
u := &url.URL{Scheme: kind, Host: net.JoinHostPort(host, strconv.Itoa(port))}
if user := strings.TrimSpace(m["username"]); user != "" {
u.User = url.UserPassword(user, strings.TrimSpace(m["password"]))
}
e.URL = u.String()
return e
}
// parseURILines 明文 URI 列表:一行一个。
func parseURILines(text string) ([]SubEntry, error) {
lines := strings.Split(text, "\n")
out := make([]SubEntry, 0, len(lines))
for i, raw := range lines {
line := strings.TrimSpace(strings.TrimRight(raw, "\r"))
if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "//") {
continue
}
out = append(out, parseURILine(i+1, line))
}
return out, nil
}
// parseURILine 归一一行 URI。socks:// 是 socks5 的常见别名,按 socks5 处理;
// 其余不支持的协议给出具体原因。
func parseURILine(line int, s string) SubEntry {
scheme := ""
if i := strings.Index(s, "://"); i > 0 {
scheme = strings.ToLower(s[:i])
}
e := SubEntry{Line: line, Kind: scheme}
if scheme == "" {
e.Reason = "不是代理 URL(缺少 scheme://);本框也接受 Clash/subscription 全文"
return e
}
if knownUnsupportedSchemes[scheme] {
e.Unsupported = true
e.Reason = unsupportedReason(scheme)
return e
}
switch scheme {
case "socks", "socks5", "socks5h", "http", "https":
default:
e.Reason = "未知的协议 " + scheme + "(本网关只支持 http/https/socks5)"
return e
}
u, err := url.Parse(s)
if err != nil || u == nil {
e.Reason = "无法解析的代理 URL"
return e
}
if scheme == "socks" {
u.Scheme = "socks5"
e.Kind = "socks5"
}
// 名字(#fragment)只作展示:parseURL 明确拒绝带 fragment 的 URL,这里剥掉。
if u.Fragment != "" {
e.Name = u.Fragment
u.Fragment, u.RawFragment = "", ""
}
e.URL = u.String()
return e
}
func unsupportedReason(kind string) string {
return kind + " 协议不由本网关解析(传输层只支持 http/https/socks5);" +
"可在本机另起一个 mihomo 导出 socks5 端口,再把那个 socks5:// 地址导入"
}
|