xhttp 五合一配置 ( reality 直连与过 CDN 共存, 附小白可抄的配置)

[Benjamin1919]

根据R佬的文章 #4113 ，写了 xhttp 五合一的配置，在同一台 VPS 的 443 端口实现了：

1. XTLS(Vision)+Reality 直连
2. xhttp+Reality 直连
3. 上行 xhttp+TLS+CDN | 下行 xhttp+Reality （上下行不同SNI）
4. xhttp+TLS 过CDN
5. 上行 xhttp+Reality | 下行 xhttp+TLS+CDN （上下行不同SNI）

如果不需要这么复杂的组合，可以直接跳转 #4118 (comment) ，适合小白直接抄配置。

假设 reality 直连的域名是 a.yourdomain.com，过 CDN 的域名是 b.yourdomain.com。

（注：双端 xray-core 的版本不能低于 v24.12.15 ）

一、服务端 Xray 的配置（仅展示入站的部分）：

{
  "inbounds": [
    {
      "listen": "0.0.0.0",
      "port": 443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "$(your_uuid_01)",
            "level": 0,
            "email": "$(vision_reality_user)",
            "flow": "xtls-rprx-vision"
          }
        ],
        "decryption": "none",
        "fallbacks": [
          {
            "dest": "/dev/shm/xhttp_client_upload.sock",
            "xver": 0    // 不向 xhttp 发送 proxy protocol
          }
        ]
      },
      "streamSettings": {
        "network": "raw",
        "security": "reality",
        "realitySettings": {
          "show": false,
          "target": "/dev/shm/nginx.sock",
          "xver": 0,    // 不向 nginx 发送 proxy protocol
          "serverNames": [
            "a.yourdomain.com"
          ],
          "privateKey": "$(your_privateKey)",
          "shortIds": ["$(your_shortId)"]
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpcongestion": "bbr",
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      },
      "tag": "VISION+REALITY",
      "sniffing": {    // sniffing 按需设置，不必照抄
        "enabled": true,
        "destOverride": ["http", "tls", "quic"],
        "metadataOnly": false,
        "routeOnly": true
      }
    },
    {
      "listen": "/dev/shm/xhttp_client_upload.sock,0666",
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "$(your_uuid_02)",
            "level": 0,
            "email": "$(xhttp_user)"
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "xhttp",
        "xhttpSettings": {
          "host": "",    // 建议服务端不验证 host，能让客户端有更多玩法
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些
          "mode": "auto",    // 服务端建议设置为 auto，允许客户端所有的上传模式，能让客户端有更多玩法
          "extra": {    // extra 里的参数默认已是最优，完全可以不写
            "noSSEHeader": false,    // 仅服务端，如果有兼容性问题则设为 true
            "scMaxEachPostBytes": 1000000,    // 允许客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式
            "scMaxBufferedPosts": 30,    // 服务端最多缓存 30 个 POST 请求，仅作用于 packet-up 模式（仅在服务端设置）
            "xPaddingBytes": "100-1000"
          }
        },
        "sockopt": {
          "tcpFastOpen": true,
          "acceptProxyProtocol": false,    // 使用nginx进行反代时，必须设为 false（默认就是false，可不写）
          "tcpcongestion": "bbr",
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      },
      "tag": "XHTTP_IN",
      "sniffing": {    // sniffing 按需设置，不必照抄
        "enabled": true,
        "destOverride": ["http", "tls", "quic"],
        "metadataOnly": false,
        "routeOnly": true
      }
    }
  ]
}

二、服务端 Nginx 的配置（仅展示 http 部分）：

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    # 获取真实IP的设置
    set_real_ip_from      unix:;
    map $http_cf_connecting_ip $real_client_ip {
        default $http_cf_connecting_ip;
        ""      $http_x_forwarded_for;
    }
    real_ip_header        X-Real-IP;

    # 以下参数请自行调整
    sendfile              on;
    server_tokens         off;
    tcp_nodelay           on;
    tcp_nopush            on;
    client_max_body_size  0;
    gzip  on;

    add_header X-Content-Type-Options nosniff;

    # SSL相关参数请自行调整
    ssl_session_cache          shared:SSL:16m;
    ssl_session_timeout        1h;
    ssl_session_tickets        off;
    ssl_protocols              TLSv1.3 TLSv1.2;
    ssl_ciphers                TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers  on;
    ssl_stapling               on;
    ssl_stapling_verify        on;
    resolver                   1.1.1.1 8.8.8.8 valid=60s;
    resolver_timeout           2s;

    # 映射关系表，用于定义 grpc header 中的某些变量（可自行调整）
    map $real_client_ip $proxy_forwarded_elem {
        ~^[0-9.]+$        "for=$real_client_ip";
        ~^[0-9A-Fa-f:.]+$ "for=\"[$real_client_ip]\"";
        default           "for=unknown";
    }

    map $http_forwarded $proxy_add_forwarded {
        "~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";
        default "$proxy_forwarded_elem";
    }

# Reality 伪装站设置
    server {
        listen       unix:/dev/shm/nginx.sock ssl http2;
        server_name  a.yourdomain.com;

        ssl_certificate            /"$(path_of_your_cert)"/fullchain.crt;
        ssl_certificate_key        /"$(path_of_your_cert)"/private.key;
        ssl_trusted_certificate    /"$(path_of_your_cert)"/ca.crt;

        location / {
            root /"$(path_of_your_website)";
            index index.html;
        }
    }

# xhttp 伪装站设置
    server {
        listen       unix:/dev/shm/nginx.sock ssl http2 backlog=2048 so_keepalive=on;
        server_name  b.yourdomain.com;

        ssl_certificate            /"$(path_of_your_cert)"/fullchain.crt;
        ssl_certificate_key        /"$(path_of_your_cert)"/private.key;
        ssl_trusted_certificate    /"$(path_of_your_cert)"/ca.crt;

        # 以下参数请根据服务器内存大小自行调整
        http2_max_concurrent_streams 1024;
        http2_body_preread_size      128k;
        keepalive_time               2h;
        keepalive_timeout            600s;
        keepalive_requests           2048;
        client_body_buffer_size      1m;
        client_body_timeout          600s;
        client_header_timeout        300s;
        large_client_header_buffers  8 16k;
        proxy_connect_timeout        30s;
        proxy_read_timeout           2h;
        proxy_send_timeout           2h;
        proxy_buffering              off;
        proxy_request_buffering      off;

        # 根目录设置伪装站
        location / {
            root /"$(path_of_your_website)";
            index index.html;
        }

        # xhttp 设置（ path 不要照抄，要设置得复杂一些，与 xray 服务端入站保持一致）
        location /xhttp_client_upload {
            # 以下参数请根据服务器内存大小自行调整
            grpc_buffer_size         16k;
            grpc_socket_keepalive    on;
            grpc_read_timeout        1h;
            grpc_send_timeout        1h;

            grpc_set_header Connection         "";
            grpc_set_header X-Real-IP          $real_client_ip;
            grpc_set_header Forwarded          $proxy_add_forwarded;
            grpc_set_header X-Forwarded-For    $proxy_add_x_forwarded_for;
            grpc_set_header X-Forwarded-Proto  $scheme;
            grpc_set_header X-Forwarded-Port   $server_port;
            grpc_set_header Host               $host;
            grpc_set_header X-Forwarded-Host   $host;

            grpc_pass unix:/dev/shm/xhttp_client_upload.sock;
        }
    }

    server {
        listen  80   default_server;
        server_name  .yourdomain.com;
        return  301  https://$host$request_uri;
    }

}

三、客户端 Xray 的配置（仅展示出站的部份）：

{
  "outbounds": [
    {    // 出站1: XTLS+Reality
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_of_your_vps)",    // 填写 VPS 的 IP
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid_01)",
                "encryption": "none",
                "flow": "xtls-rprx-vision",
                "level": 0
              }
            ]
          }
        ]
      },
      "tag": "VISION+REALITY",
      "streamSettings": {
        "network": "raw",
        "security": "reality",
        "realitySettings": {
          "show": false,
          "serverName": "a.yourdomain.com",
          "fingerprint": "chrome",
          "publicKey": "$(your_publicKey)",
          "shortId": "$(your_shortId)",
          "spiderX": "/"
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      },
      "mux": {
        "enabled": true,
        "concurrency": -1,
        "xudpConcurrency": 16,
        "xudpProxyUDP443": "reject"
      }
    },
    {    // 出站2: xhttp+Reality 上下行不分离 （上行为 stream-one 模式）
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_of_your_vps)",    // 填写 VPS 的 IP
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid_02)",
                "encryption": "none",
                "level": 0
              }
            ]
          }
        ]
      },
      "tag": "XHTTP+REALITY",
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "realitySettings": {
          "show": false,
          "serverName": "a.yourdomain.com",
          "fingerprint": "chrome",
          "publicKey": "$(your_publicKey)",
          "shortId": "$(your_shortId)",
          "spiderX": "/"
        },
        "xhttpSettings": {
          "host": "",    // xhttp+reality 客户端可以不发送 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",    // 也可以写成 stream-one，其他模式不生效
          "extra": {    // extra 里的参数默认已是最优，完全可以不写
            "noGRPCHeader": false,    // 不发送 GRPC 响应头，默认 false，即伪装成 GRPC（仅在客户端设置，仅作用于 stream-up/one 模式）
            "scMaxEachPostBytes": 1000000,    // 客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式，不能大于服务端设定的数值
            "scMinPostsIntervalMs": 30,    // 客户端发起 POST 请求的最小间隔为 30 毫秒，仅作用于 packet-up 模式（仅在客户端设置）
            "xPaddingBytes": "100-1000",
            "xmux": {    // 仅在客户端设置
              "maxConcurrency": "16-32",    // 每条 H2/H3 连接中最多同时存在 16-32 条代理请求，超出后会建立新的连接
              "maxConnections": 0,    // 不限制同时存在的连接数
              "cMaxReuseTimes": "64-128",    // 每条连接最多被复用 64-128 次
              "cMaxLifetimeMs": 0,    // 不限制每条连接的存活时间
              "hMaxRequestTimes": "800-900",    // 每条连接最多承载 800-900 个请求
              "hKeepAlivePeriod": 0    // H2/H3 连接空闲时客户端每隔多少秒发一次保活包，默认 0，即 Chrome H2 的 45 秒，或 quic-go H3 的 10 秒
            }
          }
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      }
    },
    {    // 出站3: 上行 xhttp+TLS+CDN | 下行 xhttp+Reality
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_or_domain_of_your_cdn)",    // 此处填写你使用的 CDN 的 IP 或 域名
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid_02)",
                "encryption": "none",
                "level": 0
              }
            ]
          }
        ]
      },
      "tag": "CDN_UP+REALITY_DOWN",
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "b.yourdomain.com",
          "allowInsecure": false,
          "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "host": "b.yourdomain.com",    // xhttp 过 nginx 时必须要填 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",    // 建议 auto，alpn 为 h2 时 stream-up，h3 时 packet-up
          "extra": {    // extra 里只需要设置 downloadSettings，其余参数默认已是最优，完全可以不写
            "noGRPCHeader": false,    // 不发送 GRPC 响应头，默认 false，即伪装成 GRPC（仅在客户端设置，仅作用于 stream-up/one 模式）
            "scMaxEachPostBytes": 1000000,    // 客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式，不能大于服务端设定的数值
            "scMinPostsIntervalMs": 30,    // 客户端发起 POST 请求的最小间隔为 30 毫秒，仅作用于 packet-up 模式（仅在客户端设置）
            "xPaddingBytes": "100-1000",
            "xmux": {    // 仅在客户端设置
              "maxConcurrency": "16-32",    // 每条 H2/H3 连接中最多同时存在 16-32 条代理请求，超出后会建立新的连接
              "maxConnections": 0,    // 不限制同时存在的连接数
              "cMaxReuseTimes": "64-128",    // 每条连接最多被复用 64-128 次
              "cMaxLifetimeMs": 0,    // 不限制每条连接的存活时间
              "hMaxRequestTimes": "800-900",    // 每条连接最多承载 800-900 个请求
              "hKeepAlivePeriod": 0    // H2/H3 连接空闲时客户端每隔多少秒发一次保活包，默认 0，即 Chrome H2 的 45 秒，或 quic-go H3 的 10 秒
            },
            "downloadSettings": {    // 此处其实就是套娃 xhhtp+reality 的配置，看着很长，但其实没有复杂的配置项
              "address": "$(ip_of_your_vps)",    // 填写 VPS 的 IP
              "port": 443,
              "network": "xhttp",
              "security": "reality",
              "realitySettings": {
                "show": false,
                "serverName": "a.yourdomain.com",
                "fingerprint": "chrome",
                "publicKey": "$(your_publicKey)",
                "shortId": "$(your_shortId)",
                "spiderX": "/"
              },
              "xhttpSettings": {
                "host": "",    // xhttp+reality 客户端可以不发送 host
                "path": "/xhttp_client_upload",
                "mode": "auto",
                "extra": {    // extra 里的参数默认已是最优，完全可以不写
                  "noGRPCHeader": false,
                  "scMaxEachPostBytes": 1000000,
                  "scMinPostsIntervalMs": 30,
                  "xPaddingBytes": "100-1000",
                  "xmux": {
                    "maxConcurrency": "16-32",
                    "maxConnections": 0,
                    "cMaxReuseTimes": "64-128",
                    "cMaxLifetimeMs": 0,
                    "hMaxRequestTimes": "800-900",
                    "hKeepAlivePeriod": 0
                  }
                }
              }
            }
          }
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      }
    },
    {    // 出站4: xhttp+TLS+CDN 上下行不分离
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_or_domain_of_your_cdn)",    // 此处填写你使用的 CDN 的 IP 或 域名
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid_02)",
                "encryption": "none",
                "level": 0
              }
            ]
          }
        ]
      },
      "tag": "XHTTP+TLS+CDN",
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "b.yourdomain.com",
          "allowInsecure": false,
          "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "host": "b.yourdomain.com",    // xhttp 过 nginx 时必须要填 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",    // 建议 auto，alpn 为 h2 时 stream-up/one，h3 时 packet-up
          "extra": {    // extra 里参数默认已是最优，完全可以不写
            "noGRPCHeader": false,    // 不发送 GRPC 响应头，默认 false，即伪装成 GRPC（仅在客户端设置，仅作用于 stream-up/one 模式）
            "scMaxEachPostBytes": 1000000,    // 客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式，不能大于服务端设定的数值
            "scMinPostsIntervalMs": 30,    // 客户端发起 POST 请求的最小间隔为 30 毫秒，仅作用于 packet-up 模式（仅在客户端设置）
            "xPaddingBytes": "100-1000",
            "xmux": {    // 仅在客户端设置
              "maxConcurrency": "16-32",    // 每条 H2/H3 连接中最多同时存在 16-32 条代理请求，超出后会建立新的连接
              "maxConnections": 0,    // 不限制同时存在的连接数
              "cMaxReuseTimes": "64-128",    // 每条连接最多被复用 64-128 次
              "cMaxLifetimeMs": 0,    // 不限制每条连接的存活时间
              "hMaxRequestTimes": "800-900",    // 每条连接最多承载 800-900 个请求
              "hKeepAlivePeriod": 0    // H2/H3 连接空闲时客户端每隔多少秒发一次保活包，默认 0，即 Chrome H2 的 45 秒，或 quic-go H3 的 10 秒
            }
          }
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      }
    },
    {    // 出站5: 上行 xhttp+Reality | 下行 xhttp+TLS+CDN
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_of_your_vps)",
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid_02)",
                "encryption": "none",
                "level": 0
              }
            ]
          }
        ]
      },
      "tag": "REALITY_UP+CDN_DOWN",
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "realitySettings": {
          "show": false,
          "serverName": "a.yourdomain.com",
          "fingerprint": "chrome",
          "publicKey": "$(your_publicKey)",
          "shortId": "$(your_shortId)",
          "spiderX": "/"
        },
        "xhttpSettings": {
          "host": "",    // xhttp+reality 客户端可以不发送 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",    // 上下行分离时，xhttp+Reality 的上行模式为 stream-up
          "extra": {    // extra 里只需要设置 downloadSettings，其余参数默认已是最优，完全可以不写
            "noGRPCHeader": false,    // 不发送 GRPC 响应头，默认 false，即伪装成 GRPC（仅在客户端设置，仅作用于 stream-up/one 模式）
            "scMaxEachPostBytes": 1000000,    // 客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式，不能大于服务端设定的数值
            "scMinPostsIntervalMs": 30,    // 客户端发起 POST 请求的最小间隔为 30 毫秒，仅作用于 packet-up 模式（仅在客户端设置）
            "xPaddingBytes": "100-1000",
            "xmux": {    // 仅在客户端设置
              "maxConcurrency": "16-32",    // 每条 H2/H3 连接中最多同时存在 16-32 条代理请求，超出后会建立新的连接
              "maxConnections": 0,    // 不限制同时存在的连接数
              "cMaxReuseTimes": "64-128",    // 每条连接最多被复用 64-128 次
              "cMaxLifetimeMs": 0,    // 不限制每条连接的存活时间
              "hMaxRequestTimes": "800-900",    // 每条连接最多承载 800-900 个请求
              "hKeepAlivePeriod": 0    // H2/H3 连接空闲时客户端每隔多少秒发一次保活包，默认 0，即 Chrome H2 的 45 秒，或 quic-go H3 的 10 秒
            },
            "downloadSettings": {
              "address": "$(ip_or_domain_of_your_cdn)",    // 此处填写你使用的 CDN 的 IP 或 域名
              "port": 443,
              "network": "xhttp",
              "security": "tls",
              "tlsSettings": {
                "serverName": "b.yourdomain.com",
                "allowInsecure": false,
                "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
                "fingerprint": "chrome"
              },
              "xhttpSettings": {
                "host": "b.yourdomain.com",    // xhttp 过 nginx 时必须要填 host
                "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
                "mode": "auto",    // 建议 auto，alpn 为 h2 时 stream-up，h3 时 packet-up
                "extra": {    // extra 里参数默认已是最优，完全可以不写
                  "noGRPCHeader": false,    // 不发送 GRPC 响应头，默认 false，即伪装成 GRPC（仅在客户端设置，仅作用于 stream-up/one 模式）
                  "scMaxEachPostBytes": 1000000,    // 客户端每个 POST 携带 1MB 数据，仅作用于 packet-up 模式，不能大于服务端设定的数值
                  "scMinPostsIntervalMs": 30,    // 客户端发起 POST 请求的最小间隔为 30 毫秒，仅作用于 packet-up 模式（仅在客户端设置）
                  "xPaddingBytes": "100-1000",
                  "xmux": {    // 仅在客户端设置
                    "maxConcurrency": "16-32",    // 每条 H2/H3 连接中最多同时存在 16-32 条代理请求，超出后会建立新的连接
                    "maxConnections": 0,    // 不限制同时存在的连接数
                    "cMaxReuseTimes": "64-128",    // 每条连接最多被复用 64-128 次
                    "cMaxLifetimeMs": 0,    // 不限制每条连接的存活时间
                    "hMaxRequestTimes": "800-900",    // 每条连接最多承载 800-900 个请求
                    "hKeepAlivePeriod": 0    // H2/H3 连接空闲时客户端每隔多少秒发一次保活包，默认 0，即 Chrome H2 的 45 秒，或 quic-go H3 的 10 秒
                  }
                }
              }
            }
          }
        },
        "sockopt": {    // sockopt 按需设置，不必照抄
          "tcpFastOpen": true,
          "tcpMptcp": true,
          "tcpNoDelay": true
        }
      }
    }
  ]
}

四、补充说明：

1. xhttp+Reality 上下行均为 h2；
2. xhttpSettings 中的 "extra": {} 里的配置项 默认参数在大多数场景下是最优的，如果觉得繁琐，可以删掉整个 "extra": {}，然后你会发现 xhttp 其实只需要配置 host、path、mode，与大家熟悉的 ws/httpupgrade 一样简单，而且客户端还不需要在 path 后面加 ?ed=2560 ；
3. xhttp+TLS+CDN 与 xhttp+Reality 建议使用不同的 SNI；
4. xhttp 上下行分离指的是用户数据的上传与下载分离，但TLS握手永远是双向的，所以“上行 xhttp+TLS+CDN | 下行 xhttp+Reality ”不能拯救被墙 IP，因为 xhttp+Reality 过不了 CDN；如果 VPS 的 IP 被墙，只能采用 上下行均为 xhttp+TLS+CDN 的方式；
5. 当服务端 nginx 版本不低于 1.25 时，nginx 可监听 UDP 端口，此时 xhttp+TLS 直连可实现 h3 （Reality 的target 需设置为 nginx 监听的端口而不是 UDS）；
6. Nginx 使用 grpc_pass 反代 xhttp 时 不支持 http/1.1，如果要支持，请使用 proxy_pass（建议舍弃 http/1.1，因为 grpc_pass 性能更好）；
7. 使用 Cloudflare 的CDN 时，请检查你的缓存规则，确保 b.yourdomain.com/xhttp_client_upload 不会被缓存；
8. 丢包率超过 5% 的线路，可以适当降低 maxConcurrency 的数值，比如设为 "8-16"

五、几种代理方式可能的使用场景：

1. XTLS+Reality
   ① 客户端 GUI 不支持 xhttp；
   ② 不想开启 TCP 多路复用；
   ③ 想要尽可能低的延迟与尽可能高的上下行速度

2. 上下行均为 xhttp+Reality
   ① VPS 去程和回程的线路都比较好；
   ② 想要尽可能低的延迟与尽可能高的上下行速度

3. 上行 xhttp+TLS+CDN | 下行 xhttp+Reality
   ① 去程(客户端→VPS)线路较差，回程(VPS→客户端)线路较好；
   ② 日常使用更偏重下载，很少上传

4. 上下行均为 xhttp+TLS+CDN
   ① VPS 去程和回程的线路都很差；
   ② 不希望 VPS 的 IP 暴露在公网；
   ③ VPS 的 IP 已被墙

5. 上行 xhttp+Reality | 下行 xhttp+TLS+CDN
   ① 去程(客户端→VPS)线路较好，回程(VPS→客户端)线路较差；
   ② 日常使用更偏重上传，很少下载

六、xhttp 上传模式

Reality	TLS alpn	上下行分离	上传模式
是	-	是	stream-up
	-	否	stream-one
否	h3	是	packet-up
		否	packet-up
	h2	是	stream-up
		否	stream-one
	http/1.1	是	packet-up
		否	packet-up

理论上 packet-up 性能弱于 stream-up/one，但经过R佬的不断优化，packet-up 性能已经改善许多，非常接近 stream-up/one 。
如果没有上下行分离的需求，强烈建议选择 stream-one 模式，可解决访问某些网站的断流问题：

1. xhttp+reality，客户端 mode 填 "auto" 或 "stream-one" 效果相同；
2. xhttp+TLS，客户端 mode 填 "auto" 时， 会在 "stream-one" 和 "stream-up" 中自动选择，但往往会选择 "stream-up"，所以建议客户端 mode 填 "stream-one"。
   目前 Cloudflare 完美支持 stream-one 模式，其他 CDN 有待测试。

[RPRX]

所以我猜只要在 xray 服务端 xhttpSettings 里加入 extra，把客户端 xPaddingBytes、xmux、downloadSettings 等参数写进 extra 里面，这样客户端的配置就不用写这些参数了，配置文件大幅精简。

“下发”的意思是服务发布者设置好，发给客户端后客户端直接拿来用，所以在客户端的 extra 里会看到这些参数

[Benjamin1919]

所以我猜只要在 xray 服务端 xhttpSettings 里加入 extra，把客户端 xPaddingBytes、xmux、downloadSettings 等参数写进 extra 里面，这样客户端的配置就不用写这些参数了，配置文件大幅精简。

“下发”的意思是服务发布者设置好，发给客户端后客户端直接拿来用，所以在客户端的 extra 里会看到这些参数

明白了😂 是人去“下发”，不是服务器“下发”

[lxhao61]

你回落 XHTTP_IN 应该取消 PROXY protocol 发送、删除 PROXY protocol 接受，否则你反代 XHTTP_IN 就不能匹配了。

[RPRX]

大段引用太刷屏，替你删掉了

[lxhao61]

好的。

[Benjamin1919]

你回落 XHTTP_IN 应该取消 PROXY protocol 发送、删除 PROXY protocol 接受，否则你反代 XHTTP_IN 就不能匹配了。

感谢提醒，已修正

[Darkbish]

所以如果要 nginx 前置来做 sni，复用 443 端口，做上下行都偷自己的 xhttp + reality 应该咋配啊？

[Darkbish]

因为前面一直用的nginx来做的sni，现在不想改了，想直接调一下就用😂

[lxhao61]

@Benjamin1919 你 SNI 分流弄复杂了，使用 stream_ssl_preread_module 模块，直接分流到两个不同域名的 REALITY Vision 应用即可。

[lxhao61]

@Darkbish 你干嘛非得上下行都使用 REALITY XHTTP？其应用不支持 HTTP/3 传输、不支持过 CDN，正常情况最多使用一个来做上行或下行。
若己有 REALITY Vision 及反代 XHTTP 应用，直接 REALITY Vision 应用加回落配置即可实现 REALITY XHTTP 应用。

[Benjamin1919]

@lxhao61 请教一下，stream_ssl_preread_module 能否读取 reality 中的 SNI ？

[lxhao61]

@Benjamin1919 可以，你可试一试。

[Benjamin1919]

附上一份适用于小白的简化配置，不需要 nginx，但是 xhttp+reality 与 xhttp+TLS+CDN 不能共用 443 端口，如果要共用，必须通过 nginx 或 caddy 反代（参考正文的配置）。

一、xhttp+reality 直连

服务端配置：

{
  "inbounds": [
    {
      "listen": "0.0.0.0",
      "port": 443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "$(your_uuid)"    // 长度为 1-30 字节的任意字符串，或执行 xray uuid 生成
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "realitySettings": {
          "target": "a1.example.com",    // 目标网站最低标准：国外网站，支持 TLSv1.3、X25519 与 H2，域名非跳转用（主域名可能被用于跳转到 www） 更多内容请见 https://github.com/XTLS/Xray-core/discussions/2256#discussioncomment-6295296
          "serverNames": [    // 客户端可用的 serverName 列表，暂不支持 * 通配符，在 Chrome 里输入 "dest" 的网址 -> F12 -> 安全 -> F5 -> 主要来源（安全），填证书中 SAN 的值
            "a1.example.com",
            "a2.example.com"
          ],
          "privateKey": "$(your_privateKey)",    // 执行 xray x25519 生成一对公钥与私钥，服务端填私钥 "Private key" 的值，客户端填公钥 "Public key" 的值
          "shortIds": ["$(your_shortId)"]    // 客户端可用的 shortId 列表，可用于区分不同的客户端，0 到 f，长度为 2 的倍数，长度上限为 16，可留空，或执行 openssl rand -hex 1到8 生成
        },
        "xhttpSettings": {
          "host": "",    // 服务端可以留空，若不留空，客户端必须填与服务端相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些
          "mode": "auto"
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": ["http", "tls", "quic"],
        "metadataOnly": false
      }
    }
  ]
}

客户端配置：

{
  "outbounds": [
    {
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_of_your_vps)",    // 填写 VPS 的 IP
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid)",    // 与服务端一致
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "tag": "PROXY:XHTTP+REALITY",
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "realitySettings": {
          "serverName": "a1.example.com",    // 服务端允许的 serverNames 之一
          "fingerprint": "chrome",
          "publicKey": "$(your_publicKey)",    // 填写服务端运行 xray x25519 生成的公钥的值
          "shortId": "$(your_shortId)"    // 与服务端一致
        },
        "xhttpSettings": {
          "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto"
        }
      }
    }
  ]
}

注意：如果你的 VPS 是单栈（只有 IPv4 或只有 IPv6），那么客户端不能使用上下行分离；
如果你的 VPS 是双栈（同时有 IPv4 和 IPv6 地址），那么可以上下行分离，比如上行用 IPv6、下行用 IPv4 的客户端配置：

{
  "outbounds": [
    {
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ipv6_of_your_vps)",    // 填写 VPS 的 IPv6 地址
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid)",    // 与服务端一致
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "tag": "PROXY:XHTTP+REALITY",
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "realitySettings": {
          "serverName": "a1.example.com",    // 服务端允许的 serverNames 之一
          "fingerprint": "chrome",
          "publicKey": "$(your_publicKey)",    // 填写服务端运行 xray x25519 生成的公钥的值
          "shortId": "$(your_shortId)"    // 与服务端一致
        },
        "xhttpSettings": {
          "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",
          "extra": {
            "downloadSettings": {
              "address": "$(ipv4_of_your_vps)",    // 填写 VPS 的 IPv4 地址
              "port": 443,
              "network": "xhttp",
              "security": "reality",
              "realitySettings": {
                "serverName": "a1.example.com",    // 服务端允许的 serverNames 之一
                "fingerprint": "chrome",
                "publicKey": "$(your_publicKey)",    // 填写服务端运行 xray x25519 生成的公钥的值
                "shortId": "$(your_shortId)"    // 与服务端一致
              },
              "xhttpSettings": {
                "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
                "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
                "mode": "auto"
              }
            }
          }
        }
      }
    }
  ]
}

二、xhttp+TLS 过 CDN

服务端配置：

{
  "inbounds": [
    {
      "listen": "0.0.0.0",
      "port": 443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "$(your_uuid)"    // 长度为 1-30 字节的任意字符串，或执行 xray uuid 生成
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "b.example.com",    // 填写启用了 CDN 的域名
          "alpn": ["h3","h2","http/1.1"],
          "minVersion": "1.2",    // 为了安全起见，至少要求 TLS1.2
          "certificates": [    // 用于验证服务器与 CDN 的TLS握手，可以用 acme.sh 生成，也可以使用 CDN 提供的源服务器证书（如果有的话）
            {
              "certificateFile": "/path/to/certificate.crt",    // 换成你的证书，绝对路径
              "keyFile": "/path/to/private.key"    // 换成你的私钥，绝对路径
            }
          ]
        },
        "xhttpSettings": {
          "host": "",    // 服务端可以留空，若不留空，客户端必须填与服务端相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些
          "mode": "auto"
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": ["http", "tls", "quic"],
        "metadataOnly": false
      }
    }
  ]
}

客户端配置：

{
  "outbounds": [
    {
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip_or_domain_of_your_cdn)",    // 此处填写你使用的 CDN 的 IP 或 域名
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid)",    // 与服务端一致
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "tag": "PROXY:XHTTP+TLS",
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "xray.com",    // 与服务端一致
          "allowInsecure": false,    // 仅客户端设置
          "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto"
        }
      }
    }
  ]
}

由于 CDN 往往有多个可用 IP，因此你可以任选两个 CDN 的 IP 实现上下行分离：

{
  "outbounds": [
    {
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "$(ip1_or_domain1_of_your_cdn)",    // 此处填写你使用的 CDN 的 IP 或 域名
            "port": 443,
            "users": [
              {
                "id": "$(your_uuid)",    // 与服务端一致
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "tag": "PROXY:XHTTP+TLS",
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "b.example.com",    // 与服务端一致
          "allowInsecure": false,    // 仅客户端设置
          "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
          "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
          "mode": "auto",
          "extra": {
            "downloadSettings": {
              "address": "$(ip2_or_domain2_of_your_cdn)",    // 此处填写你使用的 CDN 的另一个 IP 或 域名
              "port": 443,
              "network": "xhttp",
              "security": "tls",
              "tlsSettings": {
                "serverName": "b.example.com",    // 与服务端一致
                "allowInsecure": false,    // 仅客户端设置
                "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
                "fingerprint": "chrome"
              },
              "xhttpSettings": {
                "host": "",    // 服务端留空时客户端也可以留空；服务端不留空时客户端必须填相同的 host
                "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
                "mode": "auto"
              }
            }
          }
        }
      }
    }
  ]
}

[burjuyz]

I'm using nginx with with preread names to backends

stream {
    map $ssl_preread_server_name $backend {

Here is my location

` location /VLSpdG9k {
grpc_pass grpc://127.0.0.1:9011;

		grpc_set_header Connection         "";
		grpc_set_header Host 			   $host;
		grpc_set_header X-Real-IP          $real_client_ip;
		grpc_set_header Forwarded          $proxy_add_forwarded;
        grpc_set_header X-Forwarded-For    $proxy_add_x_forwarded_for;
		grpc_set_header X-Forwarded-Proto  $scheme;
        grpc_set_header X-Forwarded-Port   $server_port;
		grpc_set_header X-Forwarded-Host   $host;
		grpc_read_timeout 1h;
        grpc_send_timeout 1h;
		
		client_body_buffer_size 1m;
        client_body_timeout 1h;
        client_max_body_size 0;
    }`

my nginx.conf section http

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;

    keepalive_timeout  65;

    resolver 8.8.8.8 8.8.4.4;

    include /etc/nginx/conf.d/*.conf;
	
	set_real_ip_from      127.0.0.1;
	set_real_ip_from 173.245.48.0/20;
	set_real_ip_from 103.21.244.0/22;
	set_real_ip_from 103.22.200.0/22;
	set_real_ip_from 103.31.4.0/22;
	set_real_ip_from 141.101.64.0/18;
	set_real_ip_from 108.162.192.0/18;
	set_real_ip_from 190.93.240.0/20;
	set_real_ip_from 188.114.96.0/20;
	set_real_ip_from 197.234.240.0/22;
	set_real_ip_from 198.41.128.0/17;
	set_real_ip_from 162.158.0.0/15;
	set_real_ip_from 104.16.0.0/13;
	set_real_ip_from 104.24.0.0/14;
	set_real_ip_from 172.64.0.0/13;
	set_real_ip_from 131.0.72.0/22;
	set_real_ip_from 2400:cb00::/32;
	set_real_ip_from 2606:4700::/32;
	set_real_ip_from 2803:f800::/32;
	set_real_ip_from 2405:b500::/32;
	set_real_ip_from 2405:8100::/32;
	set_real_ip_from 2a06:98c0::/29;
	set_real_ip_from 2c0f:f248::/32;

    map $http_cf_connecting_ip $real_client_ip {
        default $http_cf_connecting_ip;
        ""      $http_x_forwarded_for;
    }
    real_ip_header        X-Real-IP;
	
	map $real_client_ip $proxy_forwarded_elem {
        ~^[0-9.]+$        "for=$real_client_ip";
        ~^[0-9A-Fa-f:.]+$ "for=\"[$real_client_ip]\"";
        default           "for=unknown";
    }

    map $http_forwarded $proxy_add_forwarded {
        "~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";
        default "$proxy_forwarded_elem";
    }
}

I cant get real ip in my logs. Can anyone point me how to fix it?
2024/12/19 11:18:07 from 127.0.0.1:0 accepted udp:142.250.74.170:443 [VLESS+XHTTP >> DIRECT] email: 6.test

[Benjamin1919]

In this case, only "$real_client_ip" can get real ip, not "$remote_addr".

Here is a nginx log format example, just for your reference:

    log_format  custom  '$real_client_ip $remote_user [$time_iso8601] "$request" $status $body_bytes_sent'
                        'B "$http_referer" "$http_user_agent" "$http_x_forwarded_for"';

You can assign the log format in "http { } " or "server { } " like this:

    access_log /var/log/nginx/access.log custom;

[burjuyz]

My section of http { }
https://pastebin.com/18t0by2j

access_custom.log is empty, the problem is not solved...

[Benjamin1919]

You can only use "access_log" for once in the config.

Delete the following lines:

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
 
    access_log  /var/log/nginx/access.log  main;

[burjuyz]

There is a problem somewhere else.
If you can please contact me pm
When we fix it i will post the solution here.

[gtnttot]

我参考上附的“xhttp+TLS 过 CDN” 的配置在VPS中搭建的账号，域名是在CF中解析的，测试开启CF代理走CDN，mode设置为 stream-up 时也可用，但把域名再套一层CF workers 或 pages 反代就不行了，不知是什么原因，反代这种流量时要注意哪些吗？

mode设置为packet-up倒是都可用，但CF workers的每天10万免费次数几个小时就用完了，承受不住。

[Benjamin1919]

请问你是如何用CF workers 或 pages 反代的？我还不知道有这种操作……

[HappyCoupon]

可能是类似这个？
https://github.com/vrnobody/cfxhttp

[gtnttot]

请问你是如何用CF workers 或 pages 反代的？我还不知道有这种操作……

就是直接获取请求然后转发流量，范例代码：

export default {
  async fetch(request, env) {
    let url = new URL(request.url);
    if (url.pathname.startsWith('/')) {
      url.hostname = 'example.com'
      let new_request = new Request(url, request);
      return fetch(new_request);
    }
    return env.ASSETS.fetch(request);
  },
};

之前转发ws流量可用，xhttp的把mode设置为packet-up也可用，stream-up不行，应该是这个用法不对，头部是不是要处理什么，但我不知道怎么写对...

[gtnttot]

可能是类似这个？ https://github.com/vrnobody/cfxhttp

原来还可以这样直接搭建代理，会不会被CF封号？？