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:;
    real_ip_header      X-Forwarded-For;
    real_ip_recursive   on;

    log_format  custom  '$remote_addr $remote_user [$time_iso8601] "$request_method $ssl_server_name'
                        '$uri $server_protocol" $status $body_bytes_sent'
                        'B "$host" "$http_user_agent" $request_time'
                        'ms $upstream_response_time'
                        'ms';
    access_log     off;
    log_not_found  off;

    # 以下参数请自行调整
    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 $remote_addr $proxy_forwarded_elem {
        ~^[0-9.]+$        "for=$remote_addr";
        ~^[0-9A-Fa-f:.]+$ "for=\"[$remote_addr]\"";
        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;

        error_log  /var/log/nginx/error_xhttp.log error;
        access_log /var/log/nginx/access_xhttp.log custom buffer=16k flush=5s;

        # 以下参数请根据服务器内存大小自行调整
        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          $remote_addr;
            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 应该咋配啊？

[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 可以，你可试一试。

[Seeagood]

SNI分流可以看下我的方案#4118 (comment)

[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": "b.example.com",    // 与服务端一致
          "allowInsecure": false,    // 仅客户端设置
          "alpn": ["h2"],    // h2 已非常丝滑，如果你使用的 CDN 支持 h3 且你所在地区对 UDP 的 QoS 不严重，可以填 "h3"
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "host": "b.example.com",    // 过CDN时必须填 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": "b.example.com",    // 过CDN时必须填 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": "b.example.com",    // 过CDN时必须填 host
                "path": "/xhttp_client_upload",    // 不要照抄，尽可能将 path 设置得复杂一些，与服务端保持一致
                "mode": "auto"
              }
            }
          }
        }
      }
    }
  ]
}

[zzlinwq]

谢谢大佬，正到处找这个模板

[zzlinwq]

按 二、xhttp+TLS 过 CDN设置
服务端
root@localhost:~# ./xray
Xray 24.12.31 (Xray, Penetrates Everything.) 4be32e9 (go1.23.4 linux/amd64)
A unified platform for anti-censorship.
2025/01/02 07:22:54 Using default config: /root/config.json
2025/01/02 07:22:54 [Info] infra/conf/serial: Reading config: &{Name:/root/config.json Format:json}
2025/01/02 07:23:13 http: TLS handshake error from 199.45.154.131:55152: read tcp 229.141.47.192:443->199.45.154.131:55152: read: connection reset by peer
2025/01/02 07:23:29 http: TLS handshake error from 199.45.154.131:52990: tls: client offered only unsupported versions: [302 301]
2025/01/02 07:23:31 http: TLS handshake error from 199.45.154.131:43726: tls: client offered only unsupported versions: [301]
2025/01/02 07:23:32 http: TLS handshake error from 199.45.154.131:43734: tls: client offered only unsupported versions: []

[zzlinwq]

客户端 WIN10系统 V2RAYN V7.3.2
"outbounds": [
{
"tag": "proxy",
"protocol": "vless",
"settings": {
"vnext": [
{
"address": "XXXXXX",
"port": 443,
"users": [
{
"id": "9e061b54-b008-4096-8f95-fa3e99213f14",
"email": "[email protected]",
"security": "auto",
"encryption": "none"
}
]
}
]
},
"streamSettings": {
"network": "xhttp",
"security": "tls",
"tlsSettings": {
"allowInsecure": false,
"serverName": "XXXXXX",
"alpn": [
"h2"
],
"fingerprint": "chrome"
},
"xhttpSettings": {
"path": "/xhttp_client_upload",
"mode": "auto",
"scMaxEachPostBytes": "500000-1000000",
"scMaxConcurrentPosts": "50-100",
"scMinPostsIntervalMs": "30-50"
}
},

[zzlinwq]

这是什么问题呢？咋整

[hss-oss]

请教下，第二种配置 xhttp+TLS 过 CDN，不需要考虑回落的场景吗？

[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封号？？

[ZqinKing]

太强了，使用xhttp+Reality替换XTLS(Vision)+Reality，延迟大降。

[i4DL]

啊，羡慕，有一键脚本么

[toyo2333]

太强了，使用xhttp+Reality替换XTLS(Vision)+Reality，延迟大降。

我单线程测试测是延迟还升高了，速度倒是还差不多，

XTLS(Vision)+Reality：

xhttp+Reality：

[toyo2333]

太强了，使用xhttp+Reality替换XTLS(Vision)+Reality，延迟大降。

我单线程测试测是延迟还升高了，速度倒是还差不多，

XTLS(Vision)+Reality：

xhttp+Reality：

xhttp+Reality 或（xhttp+TLS） 在测速的时候 上传测试时候的ping 会高于 XTLS(Vision)+Reality

[iciness]

我尝试打印了请求
`# 获取真实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;

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"';

access_log /opt/nginx/access.log custom;`

无法获取任何ip
` - [2025-01-01T20:46:19+08:00] "GET / HTTP/2.0" 200 900B "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0" "-"

• [2025-01-01T20:46:25+08:00] "GET /img/QR.jpg HTTP/2.0" 200 6386B "-" "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)" "-"
• [2025-01-01T20:46:27+08:00] "GET /img/large.gif HTTP/2.0" 200 1211B "-" "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)" "-"
• [2025-01-01T20:46:29+08:00] "GET /css/css.css HTTP/2.0" 200 2757B "-" "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)" "-"
• [2025-01-01T20:46:54+08:00] "GET / HTTP/1.1" 200 3307B "-" "fasthttp" "-"
• [2025-01-01T20:47:07+08:00] "GET / HTTP/1.1" 301 162B "-" "fasthttp" "-"
• [2025-01-01T20:47:16+08:00] "GET / HTTP/1.1" 301 162B "-" "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)" "-"
• [2025-01-01T20:47:16+08:00] "GET /robots.txt HTTP/2.0" 404 107B "-" "Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)" "-"`

[iciness]

[dukeduffff]

搞好了，上行reality, 下行 cf， 最近cf发善心不用优选，都分配了香港的ip， 速度贼快

[hiby-arch]

有一个疑问请教下：对于五合一的场景下，从（1. XTLS(Vision)+Reality ）回落到 （2. xhttp+Reality），服务端的配置文件中，（2. xhttp+Reality）为什么没有realitySettings的配置？是回落的时候默认继承了1的realitySettings么？没太明白是怎么实现的

[ZqinKing]

有一个疑问请教下：对于五合一的场景下，从（1. XTLS(Vision)+Reality ）回落到 （2. xhttp+Reality），服务端的配置文件中，（2. xhttp+Reality）为什么没有realitySettings的配置？是回落的时候默认继承了1的realitySettings么？没太明白是怎么实现的

一样没看明白，测试了一下，客户端1、3都能通，唯独2，混合reality和xhttp时通不了。

[roger2255]

我按照这个配置没问题 都通过了

[ZqinKing]

我按照这个配置没问题 都通过了

重新配置了一下，可以了，之前reality和xhttp的id写一样了。没有回落

[Sign-up-admin]

感谢大神分享👍。可以在ngnix那份配置的最下面server_name .yourdomain.com;这里加一个注释，提示填写。因为ide 批量替换容易遗漏

[roger2255]

感谢大神分享👍。可以在ngnix那份配置的最下面server_name .yourdomain.com;这里加一个注释，提示填写。因为ide 批量替换容易遗漏

是的，同感

[delicacyyy]

sing-box能不能用

[carusyte]

现在哪个手机客户端能支持XHTTP？

[achaorg]

一直在这里蹲iOS app

[roger2255]

ruaxray呀 testflight

[achaorg]

有链接不？

[roger2255]

有链接不？

https://testflight.apple.com/join/UgrUq1ew RuaXray

[achaorg]

谢谢老板，非常丝滑

[SuperNG6]

求问一下，xhttp是不是无法和xtls-rprx-vision 共存，我配置后会报错，flow必须留空才行

[roger2255]

我和你想法一样

[roger2255]

vision的效果是最好的

[lxhao61]

可两者共存，见 https://github.com/lxhao61/integrated-examples 中对应示例。另 XHTTP 应用本不支持 Vision。

[ChaingTsung]

必须用443端口吗？

[roger2255]

443不是一定要 但最好443 因为网络上大多数tls流量都是跑在443的

[wuai1024]

有没有不用CDN的配置模版，服务器网络质量很好，用 uuu.aaa.com(上行) ddd.bbb.com(下行)，要如何配置啊

[fucktimi]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

[fucktimi]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

是运营商针对cf的h3流量的干扰，换cft可解。

好的，感谢解答，有空试试cft

[roger2255]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

这种明显是q了udp流量，换啥都用处不大，当地运营商的问题，你用H2吧

[roger2255]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

这种明显是q了udp流量，换啥都用处不大，当地运营商的问题，你用H2吧

[aiguo688]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

是运营商针对cf的h3流量的干扰，换cft可解。

好的，感谢解答，有空试试cft

是不是cf的问题呢

[fucktimi]

我遇到一个奇怪的问题。按照xhttp的说明，实现了quic过cdn，只要客户端alpn单独设置h3，使用packet-up模式即可。但是我尝试了各种客户端，包括openwrt上的passwall，linux和windows下的v2rayn，一开始网络是通的，但是很快就不通了，比如passwall只能ping google.com10几次左右就再也不通了。但是如果不过cdn，quic直连服务器就是一直通的，改为h2也是一直通的。我想知道是不是cloudflare对quic有什么限制？我已经打开了cloudflare的http3支持，直接访问伪装网站也是quic。我想问问其他人有没有类似的情况，你们的quic过cdn一直是通的吗？如果有人感兴趣，我也可以提供配置跟日志。

是运营商针对cf的h3流量的干扰，换cft可解。

好的，感谢解答，有空试试cft

是不是cf的问题呢

已经确定不是cf的问题了，换了cloudfront就可以用了，h3、h2都是正常的，但是h3延迟更高，我这里对udp的qos太严了，没法用。

[Sumire-Heanna]

How does the section fallback your template mentioned work in a reality-secured stream? My guess was the section steers an xhttp stream to dest it set, as another term whether ever the HTTP2 support nginx was set to, features requiring HTTP2 thereof would work since the section bypasses nginx, but seems like nginx still receives data and handles streams of falling back to xhttp, and HTTP2 does not work if nginx did not enable it.

[ChaingTsung]

客户端clash meta的配置文件怎么写啊，大佬

[MoRanYue]

由于这里的域名有其它用途，而这里在Cloudflare的SSL设置启用了 “完全（严格）” ，而似乎正文所提供的Xray配置中，fallbacks配置导致CDN流量亦回落到xhttp_client_upload.sock而非nginx.sock，导致CDN无法验证SSL证书。因此，这里尝试添加以下回落配置：

{
  "name": "<CDN Domain, like b.yourdomain.com>"
  "dest": "/dev/shm/nginx.sock"
  "xver": 0
}

在使用浏览器测试访问CDN后域名时，Cloudflare仍然返回“此站点的连接不安全”，应该怎么办呢？
这里想继续使用Unix套接字域进行IPC而非通过网络（端口）。难道，只得使Nginx监听443端口，并根据server_name，将请求转发至nginx.sock与xhttp_client_upload.sock中嘛？

[MoRanYue]

这里改用Nginx监听443端口，作为Xray的反向代理，以使用主机名与路径进行分流。不过，似乎Reality不可使用Nginx前置，这里并不知道 如何在此情况下，使用“VLESS+XHTTP+CDN+TLS上行，VLESS+XHTTP+Reality下行”呀。

[Seeagood]

声明：本教程参考大神 Benjamin1919 的 #4118 讨论和大神 lxhao61 的 1_nginx.conf 配置及本人实践整理而来，可随意转载无须任何授权

本人也是小白，只有一个域名和一台VPS
需求是使用 nginx 前置 sni 分流来实现 5in1 ，采用docker部署，自动更新ssl证书，共用443端口，不影响部署其他网站
ps 尽量保证细节避免疏漏，有错误请指出， 不解答任何疑问！ 请自行搜索
ps 以下内容中 域名 和 大括号{}包裹的部分(含大括号) 需根据实际情况替换

准备工作

1.域名{domain.com}，VPS公网ip{pubip}
2.Cloudflare账号，获取邮箱{CFMail}和API token{CFToken}；ps token需要DNS编辑权限
3.VPS安装docker，安装portainer
4.准备uuid2个{uuid1}{uuid2}；ps 使用xray uuid命令生成
5.准备Private key: {prikey}和Public key: {pubkey}；ps 使用xray x25519命令生成
6.一个可访问的站点用于伪装，例如https://{www.website.com}；ps 该网站解析IP位置和VPS所在地尽量一致

CloudFlare配置

DNS配置：
*.domain.com解析到VPS的{pubip}，关闭小云朵
xray.domain.com解析到VPS的{pubip}，关闭小云朵
cdn.domain.com解析到VPS的{pubip}，开启小云朵
SSL/TLS加密模式为：完全（严格）
网络配置页的开关都开启，尤其是开启grpc
缓存配置页的Cache Rules新增缓存规则：
选择(自定义筛选表达式)，字段(URI完整)运算符(包含)值({/your_path})，选择(绕过缓存)

VPS准备

执行以下命令
拉取镜像
docker pull jc21/nginx-proxy-manager:latest
docker pull teddysun/xray:latest
docker pull nginx
创建文件夹，可自行调整
mkdir -p ~/docker/conf/npm/letsencrypt
mkdir -p ~/docker/conf/npm/data
mkdir -p ~/docker/conf/xray/xhttp/xray
mkdir -p ~/docker/conf/xray/xhttp/html

安装nginx proxy manager
npm的作用是自动更新证书和部署其他网站
在portainer的Networks中添加网络名称npm
在portainer的Stacks中创建npm

version: "3.9"
services:
  my-npm:
    image: jc21/nginx-proxy-manager:latest
    container_name: my-npm
    environment:
      PUID: 1001
      PGID: 1001
    ports:
      - 81:81
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /home/{uid}/docker/conf/npm/letsencrypt:/etc/letsencrypt
      - /home/{uid}/docker/conf/npm/data:/data
    restart: always
networks:
  default:
    external: true
    name: npm

访问http://{vpslocalhost}:81
使用默认用户登录
默认帐户：[email protected]
默认密码：changeme
修改账户和密码：admin@{domain}.com
点击SSL Certificates，点击Add SSL Certificate，选择Let's Encrypt
Domain Names填写：
*.domain.com xray.domain.com cdn.domain.com
Email Address for Let's Encrypt填写：{CFMail}
开启Use a DNS Challenge
DNS Provider选择Cloudflare
Credentials File Content填写
dns_cloudflare_api_token={CFToken}
点击保存，这里可能会报错失败，请多点几次保存直到成功
成功后点击该行记录最后的三个竖点查看，通常第一行会显示Certificate #带一个数字，假如点2次保存失败第3次保存成功显示Certificate #3，那么证书保存的路径在/etc/letsencrypt/live/{npm-3}/

准备配置文件

准备xray配置
nano ~/docker/conf/xray/xhttp/xray/config.json
保存以下内容

{
  "log": {
    "loglevel": "info"
  },
  "inbounds": [
    {
      "port": 1443,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "{uuid1}",
            "flow": "xtls-rprx-vision"
          }
        ],
        "decryption": "none",
        "fallbacks": [
          {
            "dest": 1234
          }
        ]
      },
      "streamSettings": {
        "network": "raw",
        "security": "reality",
        "rawSettings": {
          "acceptProxyProtocol": true
        },
        "realitySettings": {
          "target": "my-nginx-xhttp:8000",
          "xver": 1,
          "serverNames": [
            "xray.domain.com"
          ],
          "privateKey": "{prikey}",
          "shortIds": [
            ""
          ]
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ]
      }
    },
    {
      "port": 1234,
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "{uuid2}"
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "xhttp",
        "xhttpSettings": {
          "path": "{/your_path}"
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ]
      }
    }
  ],
  "outbounds": [
    {
      "tag": "direct",
      "protocol": "freedom"
    }
  ],
  "routing": {
    "rules": []
  }
}

准备nginx配置
nano ~/docker/conf/xray/xhttp/nginx.conf
保存以下内容

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log notice;
pid /var/run/nginx.pid;
events {
    worker_connections 1024;
}
stream {
    map $ssl_preread_server_name $tcpsni {
        xray.domain.com xray;
        cdn.domain.com cdn;
        web.domain.com myweb;
        default sslweb;
    }
    upstream xray {
        server my-xray-xhttp:1443;
    }
    upstream cdn {
        server 127.0.0.1:8000;
    }
    upstream myweb {
        server 127.0.0.1:8001;
    }
    upstream sslweb {
        server 127.0.0.1:1443;
    }
    upstream npm {
        server my-npm:443;
    }
    server {
        listen 1443 proxy_protocol;
        proxy_pass npm;
    }
    server {
        listen 443;
        listen [::]:443;
        ssl_preread on;
        proxy_protocol on;
        proxy_pass $tcpsni;
    }
}
http {
    include mime.types;
    default_type application/octet-stream;
    map $http_x_forwarded_for $client_ip {
        "" $remote_addr;
        "~*(?P<firstAddr>([0-9a-f]{0,4}:){1,7}[0-9a-f]{1,4}|([0-9]{1,3}\.){3}[0-9]{1,3})$" $firstAddr;
    }
    log_format main '$client_ip - $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;
    server_tokens off;
    keepalive_timeout 65;
    server {
        listen 80;
        listen [::]:80;
        return 301 https://$host$request_uri;
    }
    server {
        listen 443 quic reuseport;
        listen [::]:443 quic reuseport;
        listen 8000 ssl proxy_protocol;
        http2 on;
        set_real_ip_from 127.0.0.1;
        real_ip_header proxy_protocol;
        ssl_certificate     /etc/letsencrypt/live/{npm-3}/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/{npm-3}/privkey.pem;
        ssl_protocols             TLSv1.2 TLSv1.3;
        ssl_prefer_server_ciphers on;
        ssl_ciphers               ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305; 
        ssl_ecdh_curve            secp521r1:secp384r1:secp256r1:x25519;
        resolver                  1.1.1.1 valid=60s;
        resolver_timeout          5s;
        set $website              {www.website.com};
        location {/your_path} {
            grpc_pass grpc://my-xray-xhttp:1234;
            grpc_set_header Host $host;
            grpc_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }   
        location / {
            add_header Alt-Svc 'h3=":443"; ma=86400';
            add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;
            proxy_pass                         https://$website;
            proxy_ssl_server_name              on;
            proxy_ssl_protocols                TLSv1.2 TLSv1.3;
            proxy_ssl_verify                   off;
            proxy_set_header Host              $website;
            proxy_set_header Accept-Encoding   "";
            proxy_set_header Connection        "";
            proxy_set_header X-Real-IP         $remote_addr;
            proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_http_version                 1.1;
            proxy_buffering                    off;
            proxy_connect_timeout              60s;
            proxy_send_timeout                 60s;
            proxy_read_timeout                 60s;
        }
    }
    server {
        listen 8001 ssl proxy_protocol;
        http2 on;
        set_real_ip_from 127.0.0.1;
        real_ip_header proxy_protocol;
        ssl_certificate     /etc/letsencrypt/live/{npm-3}/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/{npm-3}/privkey.pem;
        location / {
            root /usr/share/nginx/html;
            index index.html;
        }
    }
}

准备本地web文件
nano ~/docker/conf/xray/xhttp/html/index.html
保存以下内容

<html lang="en">
  <head>
    <title>Hello Everyone</title>
  </head>
  <body>
    <h1>Welcome to My Blog.</h1>
    <p>Tip: This Website is building...</p>
  </body>
</html>

安装xray服务

在portainer的Stacks中创建xray-xhttp

version: "3.9"
services:
  my-xray-xhttp:
    image: teddysun/xray:latest
    container_name: my-xray-xhttp
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /home/{uid}/docker/conf/xray/xhttp/xray:/etc/xray
    networks:
      - xhttp
    restart: always
  my-nginx-xhttp:
    image: nginx
    container_name: my-nginx-xhttp
    ports:
      - 80:80
      - 443:443
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /home/{uid}/docker/conf/npm/letsencrypt:/etc/letsencrypt
      - /home/{uid}/docker/conf/xray/xhttp/nginx.conf:/etc/nginx/nginx.conf:ro
      - /home/{uid}/docker/conf/xray/xhttp/html:/usr/share/nginx/html
    networks:
      - xhttp
      - npm
    restart: always
networks:
  xhttp:
  npm:
    external: true

访问 https://xray.domain.com 和 https://cdn.domain.com 将展示https://{www.website.com}网站内容
访问 https://web.domain.com 将展示Welcome to My Blog.

客户端配置如下：

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）
ps 如果你的网络环境udp的QOS不严重，tlsSettings里的alpn可以改为h3

{
  "outbounds": [
    {
      "tag": "1-xtls-reality",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "xray.domain.com",
            "port": 443,
            "users": [
              {
                "id": "{uuid1}",
                "flow": "xtls-rprx-vision",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "tcp",
        "security": "reality",
        "realitySettings": {
          "serverName": "xray.domain.com",
          "fingerprint": "chrome",
          "publicKey": "{pubkey}",
          "shortId": ""
        }
      }
    },
    {
      "tag": "2-xhttp-reality",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "xray.domain.com",
            "port": 443,
            "users": [
              {
                "id": "{uuid2}",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "xhttpSettings": {
          "path": "{/your_path}",
          "mode": "auto"
        },
        "realitySettings": {
          "serverName": "xray.domain.com",
          "fingerprint": "chrome",
          "publicKey": "{pubkey}",
          "shortId": ""
        }
      }
    },
    {
      "tag": "3-cdn-reality",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "cdn.domain.com",
            "port": 443,
            "users": [
              {
                "id": "{uuid2}",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "allowInsecure": false,
          "serverName": "cdn.domain.com",
          "alpn": [
            "h2"
          ],
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "path": "{/your_path}",
          "host": "cdn.domain.com",
          "mode": "auto",
          "extra": {
            "downloadSettings": {
              "address": "xray.domain.com",
              "port": 443,
              "network": "xhttp",
              "security": "reality",
              "realitySettings": {
                "serverName": "xray.domain.com",
                "fingerprint": "chrome",
                "publicKey": "{pubkey}"
              },
              "xhttpSettings": {
                "host": "",
                "path": "{/your_path}",
                "mode": "auto"
              }
            }
          }
        }
      }
    },
    {
      "tag": "4-cdn",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "cdn.domain.com",
            "port": 443,
            "users": [
              {
                "id": "{uuid2}",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "tls",
        "tlsSettings": {
          "allowInsecure": false,
          "serverName": "cdn.domain.com",
          "alpn": [
            "h2"
          ],
          "fingerprint": "chrome"
        },
        "xhttpSettings": {
          "path": "{/your_path}",
          "host": "cdn.domain.com",
          "mode": "auto"
        }
      }
    },
    {
      "tag": "5-reality-cdn",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "xray.domain.com",
            "port": 443,
            "users": [
              {
                "id": "{uuid2}",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "xhttp",
        "security": "reality",
        "xhttpSettings": {
          "path": "{/your_path}",
          "mode": "auto",
          "extra": {
            "downloadSettings": {
              "address": "cdn.domain.com",
              "port": 443,
              "network": "xhttp",
              "security": "tls",
              "tlsSettings": {
                "serverName": "cdn.domain.com",
                "allowInsecure": false,
                "alpn": [
                  "h2"
                ],
                "fingerprint": "chrome"
              },
              "xhttpSettings": {
                "host": "cdn.domain.com",
                "path": "{/your_path}",
                "mode": "auto"
              }
            }
          }
        },
        "realitySettings": {
          "serverName": "xray.domain.com",
          "fingerprint": "chrome",
          "publicKey": "{pubkey}",
          "shortId": ""
        }
      }
    }
  ]
}

以上配置导入v2rayN后测试结果如下：

[sacc-leo]

How to import the client setting for v2rayN?

[weiyan3421]

你好，有一处笔误，xray的配置文件中有两个uuid1，第二个应该改为uuid2

[Seeagood]

你好，有一处笔误，xray的配置文件中有两个uuid1，第二个应该改为uuid2

感谢指正！

[Seeagood]

How to import the client setting for v2rayN?

如何导入v2rayN，可以参考这个youtube视频：https://www.youtube.com/watch?v=uj6xslo3sIk ，从9:40开始播放即可

[MelodyUSA]

看了【五合一配置】，在下新手入門，大致梳理了一下入站的數據邏輯和流程，不知道我理解的對不對

三種協議組合的入站：

Client 連進來（vision+reality）
    │
    ├─ Reality入站：是否是協議格式？
    │     ├─ ❌ 否 → fallback
    │     └─ ✅ 是
    │          ├─ 後端 Nginx：拿 a 域名的 client hello
    │          │     ├─ ✅ 驗證過關，建立連線

Client 連進來（xhttp+reality）
    │
    ├─ Reality入站：是否是協議格式？
    │     ├─ ❌ 否 → fallback
    │     └─ ✅ 是
    │          ├─ 後端 Nginx：拿 a 域名的 client hello
    │          │     ├─ ✅ 路徑是/xhttp_client_upload，
    │          │     │     轉發到 XHTTP_IN (UDS)
    │          │     │           ├─ ✅ XHTTP_IN：處理 xhttp 流量，建立連線

Client 連進來（xhttp+tls）
    │
    ├─ Reality入站：是否是協議格式？
    │     ├─ ❌ 否 → fallback
    │     └─ ✅ 是      ↓
    │                 XHTTP_IN：處理 xhttp 流量，建立連線

[sacc-leo]

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

1. XTLS(Vision)+Reality 直连

"I noticed that I can directly access the homepage via the server's IP address, and it uses the certificate for  “a.yourdomain.com” .
Is it possible to configure Nginx to block access via the IP address directly?"

[sacc-leo]

It is recommended to use the ssl_reject_handshake parameter in Nginx to meet your requirements.​
Refer to the example of Xray(M+H+K+G+B+A)+Nginx in https://github.com/lxhao61/integrated-examples .​
I tried to add "ssl_reject_handshake" to Reality server section, it works. But two of the five modes failed.

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;
    ssl_reject_handshake on;
    location / {
        root /"$(path_of_your_website)";
        index index.html;
    }
}

[lxhao61]

If you can't even copy it correctly, go learn the usage of this parameter in Nginx first!​
https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_reject_handshake

[sacc-leo]

Thank you! I read the documentation about this parameter. The current issue is not being able to find the appropriate location to set ssl_reject_handshake.
According to the five-in-one configuration, Nginx isn't directly listening on port 443, but rather on unix:/dev/shm/nginx.sock. In this configuration scenario, is this parameter still applicable?

[lxhao61]

๑_๑，Check my previous reply!​

[sacc-leo]

๑_๑，Check my previous reply!​

It works. Thanks a lot.

[sacc-leo]

Under the current settings, the server can obtain the local real IP address. How can the local IP be hidden through configuration adjustments?

[wenge110110]

能否通过x-ui这种面板来实现

[jas0nxu]

可以，蛮简单的，看油管不良林的视频