隧道掉头：反向转发、DoS 封顶与单张证书吊销

// 正向：-bind 90:127.0.0.1:80   本端监听 :90，服务端拨 127.0.0.1:80
// 反向：-reverse -bind 90:127.0.0.1:80   服务端监听 :90，本端拨 127.0.0.1:80
//
// 数据面两边走的是同一段代码——Session 本来就是对称的（v2 埋的），
// 区别只在谁 Open、谁 Accept。

// bridge 把一条用户连接经反向流接到客户端身边的目标。
//
// 与正向唯一的区别是方向：这里由服务端 Open、客户端 Accept——
// 帧和语义与 v2 完全相同，对称性在这里兑现。
func (rm *reverseManager) bridge(bind string, conn net.Conn, target string) {
    st, err := rm.sess.Open(target)
    if err != nil {
        log.Printf("reverse open failed, bind=%s, target=%s, err=%v", bind, target, err)
        _ = conn.Close()
        return
    }
    log.Printf("reverse accepted, bind=%s, remote=%s, id=%d", bind, conn.RemoteAddr(), st.ID())

    in, out, berr := bridge(conn, st)
    log.Printf("reverse finished, bind=%s, target=%s, user_to_target=%d, target_to_user=%d, err=%v",
        bind, target, in, out, berr)
}

// run 是反向监听的控制循环：收一条、办一条、回一条。
// 一个 bind 只属于一个会话，后来者会拿到 address already in use。
func (rm *reverseManager) run() {
    go func() {
        <-rm.sess.Done()
        rm.closeAll() // 会话死亡 → 名下监听全部清零
    }()

    for {
        select {
        case msg := <-rm.sess.Ctl():
            var err error
            if msg.unlisten {
                err = rm.unlisten(msg.bind)
            } else {
                err = rm.listen(msg.bind, msg.target)
            }
            rm.sess.ReplyCtl(msg, err)
        case <-rm.sess.Done():
            return
        }
    }
}

// bootSession 把一条裸连接组装成完整的客户端会话（重连时也走这里）：
// 逼出裁决 → 心跳 → 反向数据面 → 反向注册重放。
func bootSession(conn net.Conn, reg *reverseRegistry, allow *AllowList) (*Session, error) {
    sess := newSession(conn, true)
    if err := sess.Handshake(handshakeTimeout); err != nil {
        _ = conn.Close()
        return nil, err
    }
    go sess.KeepAlive(keepAliveInterval, keepAliveTimeout)
    go serveSession(sess, allow)

    // 反向注册：控制面状态是 per-session 的，每次（重）连成功后整体重放。
    // 失败补试一把（多半是撞上旧会话的清理），再失败只记日志不拖垮正向。
    for _, m := range reg.snapshot() {
        err := sess.ListenRemote(m.bind, m.target, ctlTimeout)
        if err != nil {
            time.Sleep(reverseRetryDelay)
            err = sess.ListenRemote(m.bind, m.target, ctlTimeout)
        }
        ...
    }
    return sess, nil
}

func serveCrypto(ln net.Listener, allow *AllowList, maxConns int) {
    slots := make(chan struct{}, maxConns)
    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Printf("accept failed, err=%v", err)
            return
        }
        select {
        case slots <- struct{}{}:
        default:
            log.Printf("tunnel conn refused, remote=%s, conns=%d (limit)", conn.RemoteAddr(), maxConns)
            _ = conn.Close() // 连握手的 CPU 都不给
            continue
        }
        go func(conn net.Conn) {
            defer func() { <-slots }()
            if err := verifyClientSourceIP(conn); err != nil {
                _ = conn.Close()
                return
            }
            sess := newSession(conn, false)
            go sess.KeepAlive(keepAliveInterval, keepAliveTimeout)
            go serveSession(sess, allow)
            go newReverseManager(sess).run()
        }(conn)
    }
}

func verifyPeer(rl *RevocationList) func([][]byte, [][]*x509.Certificate) error {
    return func(rawCerts [][]byte, _ [][]*x509.Certificate) error {
        leaf, err := x509.ParseCertificate(rawCerts[0]) // (1)!
        if err != nil {
            return nil // 链校验已在标准流程报错，这里不抢它的错误
        }
        if rl.IsRevoked(leaf.SerialNumber) { // (2)!
            return fmt.Errorf("peer certificate revoked: serial=%s", leaf.SerialNumber.Text(16))
        }
        return nil
    }
}

base := 10
if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
    s = s[2:]
    base = 16
} else if strings.ContainsAny(s, "abcdefABCDEF") {
    base = 16 // openssl 风格 6F:04:A1（冒号已剥掉）
}