Перейти к содержимому
Оформить зарубежную карту за $49 Перейти
>AISTUDY_
AUTHORСвежий выпуск №031 → Git и конвейер для агента

Защищённый туннель и оплата AI-подписок

Правовой статус и назначение материала

Страница входит в справочный раздел бесплатного курса «AI-агенты: от основ к практике» и описывает настройку собственного зашифрованного канала связи до личного арендованного сервера (VDS) для удалённого администрирования, защиты рабочих данных в публичных сетях и подключения к зарубежным облачным средам разработки (OpenAI API, Anthropic Claude API, Cursor, GitHub Copilot), которые не запрещены в РФ, но ограничивают запросы по региону со своей стороны.

Мы не рекламируем коммерческие VPN-сервисы, не продаём доступ к прокси и не описываем способы доступа к ресурсам, ограниченным на территории Российской Федерации.

Справка по законодательству РФ: ч. 18 ст. 14.3 КоАП РФ (ФЗ № 281-ФЗ с 01.09.2025) устанавливает штрафы за рекламу средств доступа к запрещённым ресурсам; ст. 15.1 и 15.8 ФЗ-149 (с учётом Приказа Роскомнадзора от 17.10.2024 № 196) сохраняют исключение для технической информации о защищённом удалённом доступе и информационной безопасности. Использование собственного шифрованного туннеля для рабочих и учебных задач закону не противоречит (при соблюдении запрета на поиск заведомо экстремистских материалов — ст. 13.53 КоАП РФ).

Зарубежные платформы разработки (Claude API, OpenAI, Cursor) часто отклоняют запросы с российских IP-адресов на своей стороне. Стандартное инженерное решение — арендовать собственный недорогой VDS за рубежом и поднять до него личный зашифрованный канал.

Ниже собрана вся цепочка: автоматическая настройка сервера сразу с четырьмя профилями связи (чтобы протестировать и оставить лучший под вашу сеть), удобные клиенты для Mac, ПК и телефона, а также рабочие способы оплаты подписок и приёма SMS.

Оплата подписок и оформление зарубежной карты

Для оплаты зарубежных тарифов (ChatGPT Plus, Claude Pro, Cursor, API) есть два пути: оформить собственную именную карту зарубежного банка онлайн через официальную государственную программу eResidency Казахстана (чтобы платить напрямую без наценок за каждый месяц и пользоваться картой в поездках) либо покупать разовые ваучеры в рублях.

eResidency Казахстана Госпрограмма Республики Казахстан

Своя карта зарубежного банка онлайн за 30 минут

Официальная государственная программа цифрового резидентства Казахстана (Указ Президента РК от 25.04.2026 № 1242). Позволяет дистанционно получить цифровой ИИН и открыть полноценный счёт с картой в зарубежном банке-партнёре — без посредников и передачи личных данных третьим лицам.

ИИН + eSIM ОНЛАЙН
Цифровой ИИН и номер Казахстана за ~30 минут

Оформляется дистанционно по загранпаспорту с NFC-чипом. Цифровой ИИН действует бессрочно и признаётся государственными системами и банками-партнёрами программы.

СЧЁТ С IBAN + КАРТА
Именной банковский счёт и карта Mastercard на 5 лет

Открывается онлайн в приложении зарубежного банка-партнёра. Подходит для прямой оплаты ChatGPT Plus, Claude Pro, Cursor, API, зарубежных поездок, аренды авто и Apple Pay.

ПЕРЕВОДЫ В РУБЛЯХ И SWIFT
Пополнение со своей карты и управление в приложении

В банке-партнёре доступны отправка и приём переводов в рублях по номеру телефона, международные SWIFT-переводы, валютные счета, вклады и инвестиции.

СПЕЦТАРИФ ПО НАШЕЙ ССЫЛКЕ
Специальная цена $49 только по нашей ссылке

При переходе по нашей специальной ссылке действует льготный тариф $49 — разовый платёж прямо со своей карты. Ежегодно продлевать статус eResidency для работы счёта и карты необязательно.

Как оформить карту дистанционно (4 шага)
  1. 1 Перейдите по нашей специальной ссылке (цена $49 закреплена только за ней) и укажите email — на почту придут инструкция и ссылка на официальное приложение.
  2. 2 Скачайте приложение eResidency (App Store / Google Play) и пройдите онлайн-проверку по загранпаспорту с NFC-чипом.
  3. 3 Оплатите разовый тариф $49 прямо со своей банковской карты и получите цифровой ИИН и казахстанскую eSIM.
  4. 4 Дистанционно откройте именной счёт с IBAN и выпустите карту в приложении банка-партнёра программы.
Спеццена $49 только по нашей ссылке Разовый платёж со своей карты Карта на 5 лет
Оформить за $49 по спецссылке →

Оплата рублями без зарубежной карты (разовые ваучеры)

Если зарубежная карта пока не нужна, через витрину МТС Оплата можно приобрести разовые ваучеры или предоплаченные реквизиты для зарубежных AI-сервисов с оплатой по СБП или российской картой.

МТС

МТС Оплата — зарубежные AI-подписки

В каталоге более 30 зарубежных сервисов: ChatGPT (и отдельно OpenAI API), Claude, Cursor, Midjourney, JetBrains, Figma и другие. Оплата рублями через СБП или карту, код активации и инструкция приходят на почту обычно в течение 15 минут (итоговая сумма с учётом сервисного сбора видна до подтверждения платежа).

Порядок действий:

  1. Откройте payment.mts.ru/tools и выберите нужный сервис
  2. Укажите свою почту, выберите тариф и проверьте условия активации на карточке товара
  3. Оплатите через СБП или российскую карту
  4. Дождитесь письма с ваучером или платёжными реквизитами и активируйте подписку по инструкции

Нюанс по региону и активной подписке: ваучеры рассчитаны на аккаунты региона США и, как правило, активируются только тогда, когда на аккаунте нет действующей активной подписки. Для новых учётных записей используйте международную почту (например, gmail.com) и зарубежный IP при регистрации.

Иностранный номер для приёма SMS

Сначала проверьте, нужен ли вам номер вообще: ChatGPT при обычной регистрации через электронную почту или зарубежный аккаунт Google / Apple телефон по умолчанию не запрашивает (а при оформлении eResidency Казахстана казахстанская eSIM уже входит в программу). Отдельный виртуальный номер чаще требуется для разового создания аккаунта в Claude (Anthropic) или в отдельных API-кабинетах.

SMS

Кибер Ёж (CyberYozh) — виртуальные номера

Сервис на русском языке с виртуальными и резидентскими номерами разных стран для приёма разовых SMS или аренды номера. Поддерживает пополнение из России (СБП, карты «Мир», криптовалюта — доступные платёжные шлюзы и их комиссия видны в личном кабинете в момент пополнения).

Практические советы перед покупкой номера:

  • Включите соединение через свой зарубежный VDS до открытия страницы регистрации AI-сервиса
  • Выбирайте страну номера близко к региону вашего IP (например, Нидерланды, Великобритания, США)
  • Не храните на балансе лишние суммы — антифрод у Anthropic строгий, пополняйте счёт ровно под нужную активацию

Мы не аффилированы с площадкой и не отвечаем за работу сторонних платёжных и SMS-сервисов — используйте их как ориентир и проверяйте условия самостоятельно.

Что понадобится для своего VDS

  • Зарубежный VDS-сервер (Нидерланды, Германия, Казахстан) — на российских хостингах с оплатой рублями подходящие зарубежные тарифы стоят около 480–640 руб/мес (если впервые берёте сервер — загляните в гайд «VDS для начинающих»)
  • 5 минут на запуск одной команды по SSH
  • Клиентское приложение (например, Happ или Hiddify) для импорта готовых ссылок
VDS

Где арендовать зарубежный сервер в рублях

Удобный вариант с оплатой российскими картами и СБП — FirstVDS (площадки в Нидерландах и Казахстане). Зарубежные локации начинаются с тарифа VDS Старт (1 ядро, 2 ГБ RAM, 40 ГБ NVMe) — 639 руб/мес, а со скидкой 25% по промокоду первый заказ выходит около 479 руб.

Обратите внимание: младший тариф «Прогрев» (299 руб/мес) размещается только в Москве и не поддерживает промокоды — для работы с зарубежными AI API выбирайте Амстердам или Алматы и ОС Ubuntu 22.04 / 24.04 LTS.

FirstVDS →
ПРОМОКОД: 6481165030 -25%

Способ 1: Автоматический скрипт (4 профиля сразу)

Разные сети ведут себя по-разному: домашний оптоволоконный канал отлично держит быстрый UDP, мобильный интернет чувствителен к фиксированным UDP-портам, а корпоративный или отельный Wi-Fi порой пропускает только TCP на порту 443.

Поэтому наш скрипт за один прогон поднимает на сервере сразу 4 готовых профиля (Hysteria 2 в трёх режимах UDP + резервный TCP-профиль VLESS Reality) и выдаёт единый блок ссылок. Вы импортируете их одним кликом, проверяете пинг в приложении и оставляете тот профиль, который лучше работает именно у вас.

Шаг 1. Скачайте и запустите на сервере

Подключитесь к VDS по SSH. Хорошая привычка — сначала скачать скрипт, бегло просмотреть его и затем запустить:

рекомендуемый запуск на сервере
# 1. Скачать скрипт
curl -sL https://ai.arckep.ru/deploy-vpn.sh -o deploy-vpn.sh

# 2. Просмотреть содержимое
less deploy-vpn.sh

# 3. Запустить настройку всех 4 профилей
sudo bash deploy-vpn.sh

Можно сразу задать понятное имя для подписей в клиенте (или поставить только UDP-профили без Xray флагом --hy2-only):

bash
sudo bash deploy-vpn.sh --name "Work-VDS"
Профиль 1 • UDP + Salamander

Основной быстрый профиль на случайном UDP-порту с пакетной обфускацией Salamander (включена сразу по умолчанию). Хорошо держит домашний и мобильный канал.

Профиль 2 • UDP + Port Hopping

Тот же сервер Hysteria 2, но клиент автоматически меняет UDP-порты внутри выделенного диапазона из 400 портов. Помогает, если долгие сессии на одном UDP-порту теряют скорость.

Профиль 3 • UDP HTTP/3 (порт 443)

Чистый QUIC на стандартном порту 443 без дополнительной обёртки. Выручает в сетях, где нестандартные UDP-порты закрыты, а обычный HTTP/3 открыт.

Профиль 4 • TCP VLESS Reality (порт 443)

Резервный профиль по протоколу TCP (Xray). Работает в отелях, офисах и публичных Wi-Fi, где протокол UDP заблокирован целиком.

Посмотреть содержимое deploy-vpn.sh
deploy-vpn.sh — 549 строк
#!/bin/bash
# ═══════════════════════════════════════════════════════════
#  VDS Secure Tunnel Quick Deploy — Multi-Profile Setup
#  Настраивает сразу набор готовых профилей для защищённого
#  подключения к собственному серверу (UDP + резервный TCP),
#  чтобы выбрать самый стабильный вариант под свою сеть:
#    1. Hysteria 2 + Salamander (UDP, случайный порт)
#    2. Hysteria 2 + Port Hopping (UDP, диапазон портов + Salamander)
#    3. Hysteria 2 HTTP/3 (UDP, порт 443 — чистый QUIC)
#    4. VLESS + Reality (TCP, порт 443 — для сетей с закрытым UDP)
#
#  Использование:
#    sudo bash deploy-vpn.sh
#    sudo bash deploy-vpn.sh --name "MacBook"
#
#  Опции:
#    --name NAME      Имя устройства/профиля (по умолчанию: client1)
#    --port PORT      Основной UDP-порт Hysteria 2 (по умолчанию: случайный)
#    --pass PASSWORD  Пароль авторизации Hysteria 2 (по умолчанию: случайный)
#    --obfs PASS      Свой ключ Salamander (по умолчанию: генерируется сам)
#    --no-obfs        Отключить пакетную маскировку Salamander
#    --no-hop         Не настраивать диапазон UDP-портов (Port Hopping)
#    --no-quic443     Не поднимать второй профиль Hysteria 2 на UDP 443
#    --hy2-only       Установить только Hysteria 2 (без TCP-профиля VLESS)
# ═══════════════════════════════════════════════════════════
set -euo pipefail

RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'
CYAN='\033[0;36m'; BOLD='\033[1m'; NC='\033[0m'

CLIENT_NAME="client1"
CUSTOM_PORT=""
CUSTOM_PASS=""
OBFS_PASS=""
ENABLE_OBFS=true
ENABLE_HOP=true
ENABLE_QUIC443=true
ENABLE_VLESS=true

while [[ $# -gt 0 ]]; do
    case $1 in
        --name) CLIENT_NAME="$2"; shift 2 ;;
        --port) CUSTOM_PORT="$2"; shift 2 ;;
        --pass) CUSTOM_PASS="$2"; shift 2 ;;
        --obfs) OBFS_PASS="$2"; ENABLE_OBFS=true; shift 2 ;;
        --no-obfs) ENABLE_OBFS=false; OBFS_PASS=""; shift ;;
        --no-hop) ENABLE_HOP=false; shift ;;
        --no-quic443) ENABLE_QUIC443=false; shift ;;
        --hy2-only|--no-vless) ENABLE_VLESS=false; shift ;;
        *) echo "Неизвестный параметр: $1"; exit 1 ;;
    esac
done

if [[ $EUID -ne 0 ]]; then
    echo -e "${RED}Запустите от root: sudo bash deploy-vpn.sh${NC}"
    exit 1
fi

rand_port() { shuf -i "$1"-"$2" -n 1; }
rand_hex() { openssl rand -hex "$1"; }

urlencode() {
    if command -v python3 &>/dev/null; then
        python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$1"
    else
        printf '%s' "$1"
    fi
}

is_udp_busy_by_other() {
    local p="$1" ignore_pat="${2:-hysteria}"
    if command -v ss &>/dev/null; then
        local out
        out=$(ss -H -lnup "sport = :${p}" 2>/dev/null || true)
        [[ -n "$out" ]] && ! echo "$out" | grep -qiE "$ignore_pat"
    else
        return 1
    fi
}

is_tcp_busy_by_other() {
    local p="$1" ignore_pat="${2:-xray}"
    if command -v ss &>/dev/null; then
        local out
        out=$(ss -H -lntp "sport = :${p}" 2>/dev/null || true)
        [[ -n "$out" ]] && ! echo "$out" | grep -qiE "$ignore_pat"
    else
        return 1
    fi
}

pick_free_udp_port() {
    local p tries=0
    while [[ $tries -lt 20 ]]; do
        p=$(rand_port 15000 39999)
        if ! is_udp_busy_by_other "$p" "none_match_placeholder"; then
            echo "$p"
            return 0
        fi
        tries=$((tries + 1))
    done
    rand_port 15000 39999
}

# ── Шаг 1: Базовые пакеты + BBR + UDP-буферы ──
echo -e "\n${GREEN}[1/6]${NC} Подготовка системы и сетевых буферов..."
export DEBIAN_FRONTEND=noninteractive
apt-get update -qq > /dev/null 2>&1 || true
apt-get install -y -qq curl wget openssl ca-certificates python3 iproute2 iptables > /dev/null 2>&1 || true

VPN_PORT=${CUSTOM_PORT:-$(pick_free_udp_port)}
PASSWORD=${CUSTOM_PASS:-$(rand_hex 12)}
if [[ "$ENABLE_OBFS" == true && -z "$OBFS_PASS" ]]; then
    OBFS_PASS=$(rand_hex 12)
fi

HOP_START=$(rand_port 41000 54000)
HOP_END=$((HOP_START + 399))

QUIC_PORT=443
if [[ "$ENABLE_QUIC443" == true ]]; then
    if [[ "$VPN_PORT" == "443" ]] || is_udp_busy_by_other 443 "hysteria"; then
        QUIC_PORT=8443
        if [[ "$VPN_PORT" == "8443" ]] || is_udp_busy_by_other 8443 "hysteria"; then
            QUIC_PORT=$(rand_port 10443 14443)
        fi
    fi
fi

VLESS_PORT=443
if [[ "$ENABLE_VLESS" == true ]]; then
    if is_tcp_busy_by_other 443 "xray"; then
        VLESS_PORT=8443
        if is_tcp_busy_by_other 8443 "xray"; then
            VLESS_PORT=$(rand_port 10444 14999)
        fi
    fi
fi

# ── Внешний IPv4 сервера ──
SERVER_IP=$(ip -4 route get 1.1.1.1 2>/dev/null | awk '{for(i=1;i<=NF;i++) if($i=="src") print $(i+1)}' || true)
if [[ -z "$SERVER_IP" \
   || "$SERVER_IP" =~ ^127\. \
   || "$SERVER_IP" =~ ^10\. \
   || "$SERVER_IP" =~ ^192\.168\. \
   || "$SERVER_IP" =~ ^172\.(1[6-9]|2[0-9]|3[0-1])\. ]]; then
    SERVER_IP=$(curl -s4 --max-time 5 ifconfig.me 2>/dev/null \
        || curl -s4 --max-time 5 ip.sb 2>/dev/null \
        || curl -s4 --max-time 5 ipinfo.io/ip 2>/dev/null \
        || echo "UNKNOWN")
fi

if [[ "$SERVER_IP" == "UNKNOWN" || -z "$SERVER_IP" ]]; then
    echo -e "${RED}Не удалось определить внешний IPv4 сервера${NC}"
    exit 1
fi

echo -e "${CYAN}╔═════════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║  Настройка защищённого туннеля (мульти-профиль) ║${NC}"
echo -e "${CYAN}╠═════════════════════════════════════════════════╣${NC}"
echo -e "${CYAN}║  Сервер IP:      ${GREEN}${SERVER_IP}${NC}"
echo -e "${CYAN}║  Имя профиля:    ${GREEN}${CLIENT_NAME}${NC}"
echo -e "${CYAN}║  UDP основной:   ${GREEN}${VPN_PORT}${NC}"
[[ "$ENABLE_HOP" == true ]] && echo -e "${CYAN}║  UDP диапазон:   ${GREEN}${HOP_START}-${HOP_END}${NC}"
[[ "$ENABLE_QUIC443" == true ]] && echo -e "${CYAN}║  UDP HTTP/3:     ${GREEN}${QUIC_PORT}${NC}"
[[ "$ENABLE_VLESS" == true ]] && echo -e "${CYAN}║  TCP резерв:     ${GREEN}${VLESS_PORT}${NC}"
echo -e "${CYAN}╚═════════════════════════════════════════════════╝${NC}"

if ! grep -q "net.core.rmem_max = 16777216" /etc/sysctl.conf 2>/dev/null; then
    cat >> /etc/sysctl.conf << 'SYSCTL'
# Network optimization for QUIC & TCP
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
net.ipv4.tcp_fastopen = 3
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.core.rmem_default = 262144
net.core.wmem_default = 262144
SYSCTL
fi
sysctl -p > /dev/null 2>&1 || true
echo -e "  BBR и сетевые буферы ${GREEN}активны${NC}"

# ── Шаг 2: Файрвол и перенаправление диапазона UDP ──
echo -e "\n${GREEN}[2/6]${NC} Открытие портов в файрволе..."

open_port_spec() {
    local spec="$1" proto="$2"
    local fw_spec="${spec/-/:}"
    local fd_spec="${spec/:/-}"

    if command -v ufw &>/dev/null; then
        if ! ufw status 2>/dev/null | grep -q "Status: active"; then
            ufw default allow outgoing > /dev/null 2>&1 || true
            ufw default deny incoming > /dev/null 2>&1 || true
            ufw allow ssh > /dev/null 2>&1 || true
            ufw --force enable > /dev/null 2>&1 || true
        fi
        ufw allow "${fw_spec}/${proto}" > /dev/null 2>&1 || true
    fi

    if command -v firewall-cmd &>/dev/null && systemctl is-active --quiet firewalld 2>/dev/null; then
        firewall-cmd --permanent --add-port="${fd_spec}/${proto}" > /dev/null 2>&1 || true
    fi

    if command -v iptables &>/dev/null; then
        if ! iptables -C INPUT -p "$proto" --dport "$fw_spec" -j ACCEPT 2>/dev/null; then
            iptables -I INPUT -p "$proto" --dport "$fw_spec" -j ACCEPT 2>/dev/null || true
        fi
    fi
}

open_port_spec "$VPN_PORT" "udp"
[[ "$ENABLE_HOP" == true ]] && open_port_spec "${HOP_START}:${HOP_END}" "udp"
[[ "$ENABLE_QUIC443" == true ]] && open_port_spec "$QUIC_PORT" "udp"
[[ "$ENABLE_VLESS" == true ]] && open_port_spec "$VLESS_PORT" "tcp"

command -v ufw &>/dev/null && ufw reload > /dev/null 2>&1 || true
if command -v firewall-cmd &>/dev/null && systemctl is-active --quiet firewalld 2>/dev/null; then
    firewall-cmd --reload > /dev/null 2>&1 || true
fi

if [[ "$ENABLE_HOP" == true ]] && command -v iptables &>/dev/null; then
    cat > /usr/local/sbin/hysteria-porthop.sh << HOPSH
#!/bin/bash
ACTION="\${1:-start}"
if [[ "\$ACTION" == "stop" ]]; then
    while iptables -t nat -C PREROUTING -p udp --dport ${HOP_START}:${HOP_END} -j REDIRECT --to-ports ${VPN_PORT} 2>/dev/null; do
        iptables -t nat -D PREROUTING -p udp --dport ${HOP_START}:${HOP_END} -j REDIRECT --to-ports ${VPN_PORT} 2>/dev/null || break
    done
else
    if ! iptables -t nat -C PREROUTING -p udp --dport ${HOP_START}:${HOP_END} -j REDIRECT --to-ports ${VPN_PORT} 2>/dev/null; then
        iptables -t nat -A PREROUTING -p udp --dport ${HOP_START}:${HOP_END} -j REDIRECT --to-ports ${VPN_PORT}
    fi
fi
HOPSH
    chmod 755 /usr/local/sbin/hysteria-porthop.sh

    cat > /etc/systemd/system/hysteria-porthop.service << 'HOPUNIT'
[Unit]
Description=Hysteria 2 UDP Port Hopping Redirect
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/usr/local/sbin/hysteria-porthop.sh start
ExecStop=/usr/local/sbin/hysteria-porthop.sh stop

[Install]
WantedBy=multi-user.target
HOPUNIT
    systemctl daemon-reload
    systemctl enable --now hysteria-porthop.service > /dev/null 2>&1 || /usr/local/sbin/hysteria-porthop.sh start || true
    systemctl restart hysteria-porthop.service > /dev/null 2>&1 || true
fi
echo -e "  Правила файрвола ${GREEN}применены${NC}"

# ── Шаг 3: TLS-сертификат для Hysteria 2 ──
echo -e "\n${GREEN}[3/6]${NC} Генерация TLS-сертификата..."
mkdir -p /etc/hysteria
CERT_PATH="/etc/hysteria/server.crt"
KEY_PATH="/etc/hysteria/server.key"

openssl req -x509 -nodes -newkey rsa:2048 \
    -keyout "$KEY_PATH" \
    -out "$CERT_PATH" \
    -subj "/CN=www.bing.com" \
    -days 3650 >/dev/null 2>&1
echo -e "  Сертификат ${GREEN}готов${NC}"

# ── Шаг 4: Hysteria 2 (основной профиль + чистый HTTP/3) ──
echo -e "\n${GREEN}[4/6]${NC} Установка и запуск Hysteria 2..."
if ! command -v hysteria &>/dev/null; then
    curl -fsSL https://get.hy2.sh/ | bash
fi

if [[ -n "$OBFS_PASS" ]]; then
cat > /etc/hysteria/config.yaml << EOF
listen: :${VPN_PORT}

tls:
  cert: ${CERT_PATH}
  key: ${KEY_PATH}

auth:
  type: password
  password: ${PASSWORD}

obfs:
  type: salamander
  salamander:
    password: ${OBFS_PASS}

masquerade:
  type: proxy
  proxy:
    url: https://www.bing.com
    rewriteHost: true
EOF
else
cat > /etc/hysteria/config.yaml << EOF
listen: :${VPN_PORT}

tls:
  cert: ${CERT_PATH}
  key: ${KEY_PATH}

auth:
  type: password
  password: ${PASSWORD}

masquerade:
  type: proxy
  proxy:
    url: https://www.bing.com
    rewriteHost: true
EOF
fi

if [[ "$ENABLE_QUIC443" == true ]]; then
cat > /etc/hysteria/quic.yaml << EOF
listen: :${QUIC_PORT}

tls:
  cert: ${CERT_PATH}
  key: ${KEY_PATH}

auth:
  type: password
  password: ${PASSWORD}

masquerade:
  type: proxy
  proxy:
    url: https://www.bing.com
    rewriteHost: true
EOF
fi

if id "hysteria" &>/dev/null; then
    chown -R hysteria:hysteria /etc/hysteria
    chmod 750 /etc/hysteria
    chmod 640 "$KEY_PATH" || true
    chmod 644 "$CERT_PATH" /etc/hysteria/config.yaml || true
    [[ -f /etc/hysteria/quic.yaml ]] && chmod 644 /etc/hysteria/quic.yaml || true
fi

systemctl daemon-reload
systemctl enable --now hysteria-server >/dev/null 2>&1 || true
systemctl restart hysteria-server

QUIC_ACTIVE=false
if [[ "$ENABLE_QUIC443" == true ]]; then
    systemctl enable --now hysteria-server@quic >/dev/null 2>&1 || true
    systemctl restart hysteria-server@quic >/dev/null 2>&1 || true
fi

sleep 2
if systemctl is-active --quiet hysteria-server; then
    echo -e "  Основной сервис hysteria-server (${VPN_PORT}/udp): ${GREEN}запущен${NC}"
else
    echo -e "  ${RED}Ошибка запуска hysteria-server!${NC} Логи:"
    journalctl -u hysteria-server -n 20 --no-pager
    exit 1
fi

if [[ "$ENABLE_QUIC443" == true ]] && systemctl is-active --quiet hysteria-server@quic; then
    QUIC_ACTIVE=true
    echo -e "  Профиль HTTP/3 hysteria-server@quic (${QUIC_PORT}/udp): ${GREEN}запущен${NC}"
fi

# ── Шаг 5: Резервный TCP-профиль (Xray VLESS + Reality) ──
VLESS_ACTIVE=false
VLESS_LINK=""
if [[ "$ENABLE_VLESS" == true ]]; then
    echo -e "\n${GREEN}[5/6]${NC} Настройка резервного TCP-профиля (VLESS + Reality)..."
    XRAY_BIN=""
    if command -v xray &>/dev/null; then
        XRAY_BIN=$(command -v xray)
    elif [[ -x /usr/local/bin/xray ]]; then
        XRAY_BIN="/usr/local/bin/xray"
    else
        bash -c "$(curl -fsSL https://github.com/XTLS/Xray-install/raw/main/install-release.sh)" @ install >/dev/null 2>&1 || true
        [[ -x /usr/local/bin/xray ]] && XRAY_BIN="/usr/local/bin/xray"
    fi

    if [[ -n "$XRAY_BIN" ]]; then
        VLESS_UUID=$("$XRAY_BIN" uuid 2>/dev/null || cat /proc/sys/kernel/random/uuid)
        KEYS_OUT=$("$XRAY_BIN" x25519 2>/dev/null || true)
        REALITY_PRIV=$(echo "$KEYS_OUT" | awk -F': ' '/^(PrivateKey|Private key):/ {print $2}' | tr -d ' \r\n')
        REALITY_PUB=$(echo "$KEYS_OUT" | awk -F': ' '/^(Password \(PublicKey\)|Password|Public key):/ {print $2}' | tr -d ' \r\n')
        REALITY_SID=$(rand_hex 4)
        REALITY_SNI="www.microsoft.com"

        if [[ -n "$REALITY_PRIV" && -n "$REALITY_PUB" ]]; then
            mkdir -p /usr/local/etc/xray
            cat > /usr/local/etc/xray/config.json << XEOF
{
  "log": {
    "loglevel": "warning"
  },
  "inbounds": [
    {
      "listen": "0.0.0.0",
      "port": ${VLESS_PORT},
      "protocol": "vless",
      "settings": {
        "clients": [
          {
            "id": "${VLESS_UUID}",
            "flow": "xtls-rprx-vision"
          }
        ],
        "decryption": "none"
      },
      "streamSettings": {
        "network": "tcp",
        "security": "reality",
        "realitySettings": {
          "show": false,
          "dest": "${REALITY_SNI}:443",
          "xver": 0,
          "serverNames": [
            "${REALITY_SNI}"
          ],
          "privateKey": "${REALITY_PRIV}",
          "shortIds": [
            "${REALITY_SID}"
          ]
        }
      },
      "sniffing": {
        "enabled": true,
        "destOverride": [
          "http",
          "tls",
          "quic"
        ]
      }
    }
  ],
  "outbounds": [
    {
      "protocol": "freedom",
      "tag": "direct"
    },
    {
      "protocol": "blackhole",
      "tag": "block"
    }
  ]
}
XEOF
            systemctl daemon-reload
            systemctl enable --now xray >/dev/null 2>&1 || true
            systemctl restart xray >/dev/null 2>&1 || true
            sleep 1
            if systemctl is-active --quiet xray; then
                VLESS_ACTIVE=true
                VLESS_NAME_ENC=$(urlencode "4-VLESS-TCP-${VLESS_PORT}-${CLIENT_NAME}")
                VLESS_LINK="vless://${VLESS_UUID}@${SERVER_IP}:${VLESS_PORT}?encryption=none&flow=xtls-rprx-vision&security=reality&sni=${REALITY_SNI}&fp=chrome&pbk=${REALITY_PUB}&sid=${REALITY_SID}&type=tcp&headerType=none#${VLESS_NAME_ENC}"
                echo -e "  Резервный профиль xray (${VLESS_PORT}/tcp): ${GREEN}запущен${NC}"
            else
                echo -e "  ${YELLOW}Предупреждение: xray не запустился, остаются UDP-профили Hysteria 2${NC}"
            fi
        fi
    else
        echo -e "  ${YELLOW}Предупреждение: не удалось скачать Xray, остаются UDP-профили Hysteria 2${NC}"
    fi
else
    echo -e "\n${GREEN}[5/6]${NC} Резервный TCP-профиль пропущен (--hy2-only)"
fi

# ── Шаг 6: Формирование готовых ссылок ──
echo -e "\n${GREEN}[6/6]${NC} Сборка готовых профилей для клиента..."

PASS_ENC=$(urlencode "$PASSWORD")
NAME1_ENC=$(urlencode "1-HY2-Salamander-${CLIENT_NAME}")
NAME2_ENC=$(urlencode "2-HY2-PortHop-${CLIENT_NAME}")
NAME3_ENC=$(urlencode "3-HY2-HTTP3-${QUIC_PORT}-${CLIENT_NAME}")

if [[ -n "$OBFS_PASS" ]]; then
    OBFS_ENC=$(urlencode "$OBFS_PASS")
    HY2_MAIN_LINK="hysteria2://${PASS_ENC}@${SERVER_IP}:${VPN_PORT}/?insecure=1&sni=www.bing.com&alpn=h3&obfs=salamander&obfs-password=${OBFS_ENC}#${NAME1_ENC}"
    HY2_HOP_LINK="hysteria2://${PASS_ENC}@${SERVER_IP}:${VPN_PORT},${HOP_START}-${HOP_END}/?insecure=1&sni=www.bing.com&alpn=h3&obfs=salamander&obfs-password=${OBFS_ENC}&mport=${HOP_START}-${HOP_END}#${NAME2_ENC}"
else
    HY2_MAIN_LINK="hysteria2://${PASS_ENC}@${SERVER_IP}:${VPN_PORT}/?insecure=1&sni=www.bing.com&alpn=h3#${NAME1_ENC}"
    HY2_HOP_LINK="hysteria2://${PASS_ENC}@${SERVER_IP}:${VPN_PORT},${HOP_START}-${HOP_END}/?insecure=1&sni=www.bing.com&alpn=h3&mport=${HOP_START}-${HOP_END}#${NAME2_ENC}"
fi

HY2_QUIC_LINK="hysteria2://${PASS_ENC}@${SERVER_IP}:${QUIC_PORT}/?insecure=1&sni=www.bing.com&alpn=h3#${NAME3_ENC}"

ALL_LINKS="${HY2_MAIN_LINK}"
[[ "$ENABLE_HOP" == true ]] && ALL_LINKS="${ALL_LINKS}"$'\n'"${HY2_HOP_LINK}"
[[ "$QUIC_ACTIVE" == true ]] && ALL_LINKS="${ALL_LINKS}"$'\n'"${HY2_QUIC_LINK}"
[[ "$VLESS_ACTIVE" == true ]] && ALL_LINKS="${ALL_LINKS}"$'\n'"${VLESS_LINK}"

echo ""
echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo -e "${CYAN}  ${BOLD}ГОТОВЫЕ ПРОФИЛИ ПОДКЛЮЧЕНИЯ (ПО ОТДЕЛЬНОСТИ)${NC}"
echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo -e "  ${BOLD}1. Основной (UDP + Salamander, порт ${VPN_PORT}) — домашний и мобильный интернет:${NC}"
echo -e "  ${GREEN}${HY2_MAIN_LINK}${NC}\n"

if [[ "$ENABLE_HOP" == true ]]; then
    echo -e "  ${BOLD}2. Смена портов (UDP ${HOP_START}-${HOP_END} + Salamander) — если один UDP-порт замедляется:${NC}"
    echo -e "  ${GREEN}${HY2_HOP_LINK}${NC}\n"
fi

if [[ "$QUIC_ACTIVE" == true ]]; then
    echo -e "  ${BOLD}3. Чистый HTTP/3 (UDP ${QUIC_PORT}) — если открыт только стандартный QUIC:${NC}"
    echo -e "  ${GREEN}${HY2_QUIC_LINK}${NC}\n"
fi

if [[ "$VLESS_ACTIVE" == true ]]; then
    echo -e "  ${BOLD}4. Резерв по TCP (VLESS + Reality, порт ${VLESS_PORT}) — офис, отель, закрытый UDP:${NC}"
    echo -e "  ${GREEN}${VLESS_LINK}${NC}\n"
fi

echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo -e "${CYAN}  ${BOLD}ВСЕ ПРОФИЛИ ОДНИМ БЛОКОМ (СКОПИРУЙТЕ ВСЁ СРАЗУ)${NC}"
echo -e "${CYAN}═══════════════════════════════════════════════════════════${NC}"
echo -e "  Скопируйте строки ниже целиком и нажмите «Вставить из буфера» в Happ или Hiddify —"
echo -e "  добавятся сразу все профили, останется проверить пинг и выбрать лучший:\n"
printf '%s\n' "$ALL_LINKS"

CREDS_FILE="/root/hysteria-credentials.txt"
cat > "$CREDS_FILE" << CREDEOF
VDS Tunnel Credentials (Multi-Profile)
Created:     $(date '+%Y-%m-%d %H:%M')
Server IP:   ${SERVER_IP}

UDP Main:    ${VPN_PORT}
Password:    ${PASSWORD}
$([ -n "$OBFS_PASS" ] && echo "Salamander:  ${OBFS_PASS}")
$([ "$ENABLE_HOP" == true ] && echo "UDP Hopping: ${HOP_START}-${HOP_END} -> ${VPN_PORT}")
$([ "$QUIC_ACTIVE" == true ] && echo "UDP HTTP/3:  ${QUIC_PORT}")
$([ "$VLESS_ACTIVE" == true ] && echo "TCP VLESS:   ${VLESS_PORT}")

--- All Links (paste whole block into Happ / Hiddify) ---
${ALL_LINKS}
CREDEOF
chmod 600 "$CREDS_FILE"

echo ""
echo -e "${GREEN}Все ссылки и параметры сохранены в: ${CREDS_FILE}${NC}\n"

Шаг 2. Импортируйте сразу все профили и выберите лучший

В конце работы скрипт выведет блок «Все профили одним блоком» (4 строки подряд) и сохранит копию в /root/hysteria-credentials.txt.

  1. Скопируйте все 4 строки разом в буфер обмена
  2. В приложении Happ или Hiddify нажмите добавление из буфера — все профили появятся в списке одновременно
  3. Нажмите кнопку проверки задержки (пинга) и включите профиль с минимальным откликом; при смене Wi-Fi на мобильную сеть можно переключиться в один клик

Клиентский скрипт для Linux и серверов

Если подключаться нужно не с ноутбука или телефона, а с другой Linux-машины по терминалу — используйте клиентский скрипт. Он понимает и hysteria2:// (включая диапазон портов), и vless://, а при наличии Xray формирует актуальный конфиг под Xray v26+ (с блоком finalmask для Salamander), не ломая существующую установку.

клиент Linux: конфиг Hysteria / Xray
# 1. Скачать клиентский скрипт
curl -sL https://ai.arckep.ru/install-hysteria-config.sh -o install-hysteria-config.sh

# 2. Передать любую ссылку из вывода серверного скрипта (hysteria2:// или vless://)
bash install-hysteria-config.sh 'hysteria2://…'
Посмотреть install-hysteria-config.sh
install-hysteria-config.sh — 506 строк
#!/bin/bash
# ═══════════════════════════════════════════════════════════
#  Клиентский конфиг для Linux / VPS (Hysteria 2 + Xray VLESS)
#
#  - Понимает ссылки hysteria2:// (включая диапазон портов) и vless://
#  - Для hysteria2:// пишет native-конфиг Hysteria (config.yaml)
#  - Если установлен Xray — формирует актуальный outbound JSON
#    (с блоком finalmask для Salamander в Xray v26+) и аккуратно
#    добавляет профиль в writable config.json, не удаляя старые
#
#  Использование:
#    bash install-hysteria-config.sh 'hysteria2://…'
#    bash install-hysteria-config.sh 'vless://…'
#    curl -sL https://ai.arckep.ru/install-hysteria-config.sh | bash -s -- 'hysteria2://…'
#
#  Опции:
#    --uri URI         ссылка (то же, что позиционный аргумент)
#    --dir DIR         каталог конфигов (по умолчанию: ~/.config/hysteria)
#    --name NAME       имя профиля / tag outbound (из #fragment ссылки)
#    --socks PORT      локальный SOCKS5-порт (по умолчанию: 1080)
#    --http PORT       локальный HTTP-прокси (по умолчанию: 8080)
#    --no-install      не устанавливать бинарь Hysteria
#    --force-hysteria  ставить бинарь Hysteria даже если найден Xray
#    --start           сразу запустить клиент в текущем терминале
# ═══════════════════════════════════════════════════════════
set -euo pipefail

RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'
CYAN='\033[0;36m'; BOLD='\033[1m'; NC='\033[0m'

URI=""
CONFIG_DIR="${HOME}/.config/hysteria"
PROFILE_NAME=""
SOCKS_PORT="1080"
HTTP_PORT="8080"
NO_INSTALL=false
FORCE_HYSTERIA=false
DO_START=false

while [[ $# -gt 0 ]]; do
    case $1 in
        --uri) URI="$2"; shift 2 ;;
        --dir) CONFIG_DIR="$2"; shift 2 ;;
        --name) PROFILE_NAME="$2"; shift 2 ;;
        --socks) SOCKS_PORT="$2"; shift 2 ;;
        --http) HTTP_PORT="$2"; shift 2 ;;
        --no-install) NO_INSTALL=true; shift ;;
        --force-hysteria) FORCE_HYSTERIA=true; shift ;;
        --start) DO_START=true; shift ;;
        -h|--help)
            sed -n '2,25p' "$0" | sed 's/^# \?//'
            exit 0
            ;;
        hysteria2://*|hy2://*|vless://*)
            URI="$1"; shift
            ;;
        *)
            echo -e "${RED}Неизвестный параметр: $1${NC}"
            echo "Пример: bash install-hysteria-config.sh 'hysteria2://pass@1.2.3.4:443/?insecure=1&sni=www.bing.com'"
            exit 1
            ;;
    esac
done

if [[ -z "$URI" ]]; then
    echo -e "${RED}Передайте ссылку hysteria2://… или vless://…${NC}"
    echo ""
    echo "  bash install-hysteria-config.sh 'hysteria2://…'"
    echo "  curl -sL https://ai.arckep.ru/install-hysteria-config.sh | bash -s -- 'hysteria2://…'"
    exit 1
fi

case "$URI" in
    hy2://*) URI="hysteria2://${URI#hy2://}" ;;
    hysteria2://*|vless://*) ;;
    *)
        echo -e "${RED}Ссылка должна начинаться с hysteria2://, hy2:// или vless://${NC}"
        exit 1
        ;;
esac

if ! command -v python3 &>/dev/null; then
    if [[ $EUID -eq 0 ]]; then
        export DEBIAN_FRONTEND=noninteractive
        apt-get update -qq >/dev/null 2>&1 || true
        apt-get install -y -qq python3 >/dev/null 2>&1 || true
    fi
fi
if ! command -v python3 &>/dev/null; then
    echo -e "${RED}Нужен python3 для разбора ссылки${NC}"
    exit 1
fi

# ── Разбор URI (поддержка multi-port :PORT,START-END и vless://) ──
eval "$(python3 - "$URI" "${PROFILE_NAME}" <<'PY'
import sys, urllib.parse, shlex, re

raw = sys.argv[1].strip()
forced_name = sys.argv[2] if len(sys.argv) > 2 else ""

m = re.match(r'^([a-zA-Z0-9+.-]+)://([^/?#]+)(?:Path|\?)?([^#]*)(?:#(.*))?$', raw)
# Use urlsplit gently, extracting netloc manually to allow multi-port like :45123,41000-41399
sp = urllib.parse.urlsplit(raw)
scheme = sp.scheme.lower()
if scheme not in ("hysteria2", "hy2", "vless"):
    print('echo -e "${RED}Неверная схема URI${NC}"; exit 1'); sys.exit(0)

netloc = sp.netloc
if "@" in netloc:
    userinfo, hostport = netloc.rsplit("@", 1)
else:
    userinfo, hostport = "", netloc

if hostport.startswith("["):
    hm = re.match(r'^\[([^\]]+)\](?::(.+))?$', hostport)
    host = hm.group(1) if hm else ""
    port_spec = (hm.group(2) or "443") if hm else "443"
else:
    if ":" in hostport:
        host, port_spec = hostport.rsplit(":", 1)
    else:
        host, port_spec = hostport, "443"

first_port_m = re.match(r'^(\d+)', port_spec)
base_port = int(first_port_m.group(1)) if first_port_m else 443

auth = urllib.parse.unquote(userinfo)
qs = urllib.parse.parse_qs(sp.query)
def q1(k, d=""):
    return (qs.get(k) or [d])[0]

sni = q1("sni")
insecure = q1("insecure", "0") in ("1", "true", "True")
obfs = q1("obfs")
obfs_pass = q1("obfs-password")
pin = q1("pinSHA256") or q1("pinsha256")
mport = q1("mport")
flow = q1("flow")
pbk = q1("pbk")
sid = q1("sid")
fp = q1("fp", "chrome")
security = q1("security", "tls")

frag = urllib.parse.unquote(sp.fragment or "")
name = forced_name or frag or scheme
safe = re.sub(r"[^A-Za-z0-9._-]+", "-", name).strip("-") or scheme

if not host or not auth:
    print('echo -e "${RED}В ссылке отсутствует адрес сервера или ключ авторизации${NC}"; exit 1'); sys.exit(0)

def exp(k, v):
    print(f"{k}={shlex.quote(str(v))}")

exp("P_SCHEME", "vless" if scheme == "vless" else "hysteria2")
exp("P_HOST", host)
exp("P_PORT", base_port)
exp("P_PORTSPEC", port_spec)
exp("P_MPORT", mport)
exp("P_AUTH", auth)
exp("P_SNI", sni)
exp("P_INSECURE", "1" if insecure else "0")
exp("P_OBFS", obfs)
exp("P_OBFS_PASS", obfs_pass)
exp("P_PIN", pin)
exp("P_FLOW", flow)
exp("P_PBK", pbk)
exp("P_SID", sid)
exp("P_FP", fp)
exp("P_SECURITY", security)
exp("P_NAME", name)
exp("P_SAFE", safe)
PY
)"

find_xray() {
    if command -v xray &>/dev/null; then
        command -v xray; return 0
    fi
    local c
    for c in /usr/local/bin/xray /usr/bin/xray /usr/local/x-ui/bin/xray-linux-amd64 /usr/local/x-ui/bin/xray-linux-arm64; do
        if [[ -x "$c" ]]; then echo "$c"; return 0; fi
    done
    local found
    found=$(find /usr/local/x-ui/bin -name 'xray-linux-*' -type f -executable 2>/dev/null | head -1 || true)
    if [[ -n "$found" ]]; then echo "$found"; return 0; fi
    return 1
}

XRAY_BIN=""
HAS_XRAY=false
if XRAY_BIN=$(find_xray); then
    HAS_XRAY=true
fi

HAS_HYSTERIA=false
if command -v hysteria &>/dev/null; then
    HAS_HYSTERIA=true
fi

echo -e "${CYAN}╔═══════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║  Установка клиентского профиля            ║${NC}"
echo -e "${CYAN}╠═══════════════════════════════════════════╣${NC}"
echo -e "${CYAN}║  Протокол: ${GREEN}${P_SCHEME}${NC}"
echo -e "${CYAN}║  Сервер:   ${GREEN}${P_HOST}:${P_PORTSPEC}${NC}"
echo -e "${CYAN}║  Профиль:  ${GREEN}${P_NAME}${NC}"
echo -e "${CYAN}║  Каталог:  ${GREEN}${CONFIG_DIR}${NC}"
if [[ "$HAS_XRAY" == true ]]; then
echo -e "${CYAN}║  Xray:     ${GREEN}найден${NC} (${XRAY_BIN})"
else
echo -e "${CYAN}║  Xray:     ${YELLOW}не найден${NC}"
fi
if [[ "$HAS_HYSTERIA" == true ]]; then
echo -e "${CYAN}║  Hysteria: ${GREEN}найден${NC} ($(command -v hysteria))"
else
echo -e "${CYAN}║  Hysteria: ${YELLOW}не найден${NC}"
fi
echo -e "${CYAN}╚═══════════════════════════════════════════╝${NC}"

mkdir -p "$CONFIG_DIR"

HY_CFG="${CONFIG_DIR}/config-${P_SAFE}.yaml"
HY_CFG_DEFAULT="${CONFIG_DIR}/config.yaml"
URI_FILE="${CONFIG_DIR}/share-${P_SAFE}.uri"
XRAY_OUT="${CONFIG_DIR}/xray-outbound-${P_SAFE}.json"
XRAY_SNIPPET="${CONFIG_DIR}/xray-outbound-${P_SAFE}.snippet.json"

printf '%s\n' "$URI" > "$URI_FILE"
chmod 600 "$URI_FILE" 2>/dev/null || true

# ── Native Hysteria config (только для hysteria2://) ──
if [[ "$P_SCHEME" == "hysteria2" ]]; then
    python3 - "$URI" "$P_NAME" "$P_HOST" "$P_PORTSPEC" "$SOCKS_PORT" "$HTTP_PORT" "$HY_CFG" <<'PY'
import json, sys, datetime
uri, name, host, portspec, socks, http, path = sys.argv[1:8]
doc = f"""# Generated by install-hysteria-config.sh — {datetime.datetime.now():%Y-%m-%d %H:%M}
# Profile: {name}
# Server:  {host}:{portspec}

server: {json.dumps(uri)}

bandwidth:
  up: 50 mbps
  down: 200 mbps

socks5:
  listen: 127.0.0.1:{socks}

http:
  listen: 127.0.0.1:{http}
"""
open(path, "w", encoding="utf-8").write(doc)
PY
    cp -f "$HY_CFG" "$HY_CFG_DEFAULT"
    chmod 600 "$HY_CFG" "$HY_CFG_DEFAULT" 2>/dev/null || true
fi

# ── Xray outbound (для Xray v26+: finalmask для Salamander и поддержка vless://) ──
if [[ "$HAS_XRAY" == true || "$P_SCHEME" == "vless" ]]; then
    python3 - "$P_SCHEME" "$P_SAFE" "$P_HOST" "$P_PORT" "$P_AUTH" "$P_SNI" "$P_INSECURE" "$P_OBFS" "$P_OBFS_PASS" "$P_PIN" "$P_FLOW" "$P_PBK" "$P_SID" "$P_FP" "$P_SECURITY" "$SOCKS_PORT" "$HTTP_PORT" "$XRAY_OUT" "$XRAY_SNIPPET" <<'PY'
import json, sys

(scheme, tag, host, port, auth, sni, insecure, obfs, obfs_pass,
 pin, flow, pbk, sid, fp, security, socks_p, http_p, path_full, path_snip) = sys.argv[1:20]
port = int(port)
socks_p = int(socks_p)
http_p = int(http_p)
insecure = insecure in ("1", "true", "True")

if scheme == "vless":
    out_tag = f"vless-{tag}"
    stream = {"network": "tcp", "security": security or "reality"}
    if (security or "reality") == "reality":
        stream["realitySettings"] = {
            "serverName": sni or "www.microsoft.com",
            "fingerprint": fp or "chrome",
            "publicKey": pbk,
            "shortId": sid,
            "spiderX": "/",
        }
    else:
        stream["tlsSettings"] = {
            "serverName": sni or host,
            "allowInsecure": insecure,
            "fingerprint": fp or "chrome",
        }
    user = {"id": auth, "encryption": "none"}
    if flow:
        user["flow"] = flow
    outbound = {
        "tag": out_tag,
        "protocol": "vless",
        "settings": {"vnext": [{"address": host, "port": port, "users": [user]}]},
        "streamSettings": stream,
    }
else:
    out_tag = f"hy2-{tag}"
    tls = {
        "serverName": sni or host,
        "allowInsecure": insecure,
        "alpn": ["h3"],
    }
    if pin:
        tls["pinnedPeerCertSha256"] = pin
    stream = {
        "network": "hysteria",
        "security": "tls",
        "tlsSettings": tls,
        "hysteriaSettings": {
            "version": 2,
            "auth": auth,
            "udpIdleTimeout": 120,
        },
    }
    if obfs == "salamander" and obfs_pass:
        stream["finalmask"] = {
            "udp": [
                {
                    "type": "salamander",
                    "settings": {"password": obfs_pass},
                }
            ]
        }
    outbound = {
        "tag": out_tag,
        "protocol": "hysteria",
        "settings": {"version": 2, "address": host, "port": port},
        "streamSettings": stream,
    }

full = {
    "log": {"loglevel": "warning"},
    "inbounds": [
        {
            "tag": "socks-in",
            "listen": "127.0.0.1",
            "port": socks_p,
            "protocol": "socks",
            "settings": {"udp": True},
        },
        {
            "tag": "http-in",
            "listen": "127.0.0.1",
            "port": http_p,
            "protocol": "http",
        },
    ],
    "outbounds": [
        outbound,
        {"tag": "direct", "protocol": "freedom"},
        {"tag": "block", "protocol": "blackhole"},
    ],
    "routing": {
        "domainStrategy": "AsIs",
        "rules": [{"type": "field", "outboundTag": out_tag, "network": "tcp,udp"}],
    },
}

open(path_full, "w", encoding="utf-8").write(json.dumps(full, ensure_ascii=False, indent=2) + "\n")
open(path_snip, "w", encoding="utf-8").write(json.dumps(outbound, ensure_ascii=False, indent=2) + "\n")
PY
    chmod 600 "$XRAY_OUT" "$XRAY_SNIPPET" 2>/dev/null || true

    CANDIDATE_CONFIGS=(
        "${HOME}/.config/xray/config.json"
        "${HOME}/xray/config.json"
        "/usr/local/etc/xray/config.json"
        "/etc/xray/config.json"
        "/usr/local/x-ui/bin/config.json"
    )
    MERGED=""
    for cfg in "${CANDIDATE_CONFIGS[@]}"; do
        [[ -f "$cfg" && -w "$cfg" ]] || continue
        merge_result=$(python3 - "$cfg" "$XRAY_SNIPPET" <<'PY'
import json, sys, shutil, time
cfg_path, snip_path = sys.argv[1], sys.argv[2]
try:
    with open(cfg_path, encoding="utf-8") as f:
        data = json.load(f)
    with open(snip_path, encoding="utf-8") as f:
        outbound = json.load(f)
except Exception as e:
    print(f"skip:{e}"); sys.exit(0)
# Не вливаем клиентский outbound в чисто серверный конфиг без локальных socks/http или других proxy outbounds
ins = data.get("inbounds") or []
if all(isinstance(i, dict) and i.get("protocol") == "vless" for i in ins) and len(ins) > 0:
    print("skip:server-config"); sys.exit(0)
outs = data.get("outbounds")
if not isinstance(outs, list):
    print("skip:no-outbounds"); sys.exit(0)
tag = outbound.get("tag")
if any(isinstance(o, dict) and o.get("tag") == tag for o in outs):
    data["outbounds"] = [outbound if (isinstance(o, dict) and o.get("tag") == tag) else o for o in outs]
    action = "replaced"
else:
    insert_at = len(outs)
    for idx, o in enumerate(outs):
        if isinstance(o, dict) and o.get("protocol") in ("freedom", "blackhole"):
            insert_at = idx; break
    outs.insert(insert_at, outbound)
    data["outbounds"] = outs
    action = "added"
bak = cfg_path + ".bak." + time.strftime("%Y%m%d%H%M%S")
shutil.copy2(cfg_path, bak)
with open(cfg_path, "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
    f.write("\n")
print(f"ok:{action}:{cfg_path} (backup {bak})")
PY
)
        if [[ "$merge_result" == ok:* ]]; then
            MERGED="$merge_result"
            break
        fi
    done
fi

ensure_hysteria() {
    if [[ "$P_SCHEME" != "hysteria2" ]]; then
        return 0
    fi
    if [[ "$HAS_HYSTERIA" == true ]]; then
        echo -e "  Бинарь hysteria ${GREEN}уже установлен${NC}: $(command -v hysteria)"
        return 0
    fi
    if [[ "$NO_INSTALL" == true ]]; then
        echo -e "  ${YELLOW}--no-install: бинарь не устанавливаем${NC}"
        return 0
    fi
    if [[ "$HAS_XRAY" == true && "$FORCE_HYSTERIA" != true ]]; then
        echo -e "  Xray уже найден — ${GREEN}бинарь Hysteria не ставим${NC} (для установки передайте ${BOLD}--force-hysteria${NC})"
        return 0
    fi
    echo -e "  Установка клиента Hysteria 2…"
    if [[ $EUID -eq 0 ]]; then
        curl -fsSL https://get.hy2.sh/ | bash
    elif command -v sudo &>/dev/null; then
        curl -fsSL https://get.hy2.sh/ | sudo bash
    else
        mkdir -p "${HOME}/.local/bin"
        local arch os url
        arch=$(uname -m)
        case "$arch" in
            x86_64|amd64) arch="amd64" ;;
            aarch64|arm64) arch="arm64" ;;
            *) echo -e "${RED}Неизвестная архитектура: $arch${NC}"; return 1 ;;
        esac
        os=$(uname -s | tr '[:upper:]' '[:lower:]')
        url=$(curl -fsSL "https://api.github.com/repos/apernet/hysteria/releases/latest" \
            | python3 -c "import sys,json,re; j=json.load(sys.stdin); arch=sys.argv[1]; osn=sys.argv[2];
assets=j.get('assets') or [];
pat=re.compile(rf'hysteria-{osn}-{arch}(\.exe)?$', re.I);
cands=[a for a in assets if pat.search(a['name']) and 'avx' not in a['name'].lower() and 'fips' not in a['name'].lower()]
if not cands: cands=[a for a in assets if arch in a['name'] and osn in a['name']]
print(cands[0]['browser_download_url'] if cands else '')" "$arch" "$os")
        [[ -z "$url" ]] && { echo -e "${RED}Не удалось найти релиз Hysteria${NC}"; return 1; }
        curl -fsSL "$url" -o "${HOME}/.local/bin/hysteria"
        chmod +x "${HOME}/.local/bin/hysteria"
        export PATH="${HOME}/.local/bin:${PATH}"
    fi
    command -v hysteria &>/dev/null && HAS_HYSTERIA=true
}

echo ""
echo -e "${GREEN}[1/2]${NC} Записаны файлы конфигурации:"
[[ "$P_SCHEME" == "hysteria2" ]] && echo -e "  Hysteria YAML: ${GREEN}${HY_CFG}${NC}"
if [[ -f "$XRAY_OUT" ]]; then
    echo -e "  Xray полный:   ${GREEN}${XRAY_OUT}${NC}"
    echo -e "  Xray outbound: ${GREEN}${XRAY_SNIPPET}${NC}"
    if [[ -n "${MERGED:-}" ]]; then
        echo -e "  Добавлено в:   ${GREEN}${MERGED#ok:}${NC}"
    fi
fi

echo ""
echo -e "${GREEN}[2/2]${NC} Проверка клиентского бинаря…"
ensure_hysteria

echo ""
echo -e "${CYAN}═══════════════════════════════════════════${NC}"
echo -e "${CYAN}  ${BOLD}ССЫЛКА ПРОФИЛЯ (для Happ / Hiddify)${NC}"
echo -e "${CYAN}═══════════════════════════════════════════${NC}"
echo -e "  ${GREEN}${URI}${NC}"
echo ""

if [[ -f "$XRAY_SNIPPET" ]]; then
    echo -e "${CYAN}═══════════════════════════════════════════${NC}"
    echo -e "${CYAN}  ${BOLD}XRAY OUTBOUND JSON${NC}"
    echo -e "${CYAN}═══════════════════════════════════════════${NC}"
    cat "$XRAY_SNIPPET"
    echo ""
fi

echo -e "  Локальные прокси после запуска — SOCKS5: ${GREEN}127.0.0.1:${SOCKS_PORT}${NC} | HTTP: ${GREEN}127.0.0.1:${HTTP_PORT}${NC}"
echo -e "${GREEN}Готово. Профиль «${P_NAME}» сохранён, прежние профили не тронуты.${NC}\n"

if [[ "$DO_START" == true ]]; then
    if [[ "$P_SCHEME" == "hysteria2" ]] && command -v hysteria &>/dev/null; then
        exec hysteria -c "$HY_CFG"
    elif [[ "$HAS_XRAY" == true ]]; then
        exec "$XRAY_BIN" run -c "$XRAY_OUT"
    else
        echo -e "${RED}Не найден бинарь для запуска (hysteria / xray)${NC}"
        exit 1
    fi
fi

Способ 2: Минимальная ручная настройка Hysteria 2

Если хотите поднять один базовый UDP-профиль вручную и контролировать каждую команду самостоятельно.

1. Включите BBR и увеличьте UDP-буферы

bash
apt update && apt install -y curl openssl ca-certificates

cat >> /etc/sysctl.conf << 'EOF'
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
EOF
sysctl -p

2. Поставьте Hysteria 2 и запишите конфиг

Замените порт и оба пароля на длинные случайные строки (можно сгенерировать через openssl rand -hex 12):

bash
bash <(curl -fsSL https://get.hy2.sh/)

mkdir -p /etc/hysteria
openssl req -x509 -nodes -newkey rsa:2048 \
  -keyout /etc/hysteria/server.key \
  -out /etc/hysteria/server.crt \
  -subj "/CN=www.bing.com" -days 3650

cat > /etc/hysteria/config.yaml << 'EOF'
listen: :45123

tls:
  cert: /etc/hysteria/server.crt
  key: /etc/hysteria/server.key

auth:
  type: password
  password: ЗАМЕНИТЕ_НА_ПАРОЛЬ_АВТОРИЗАЦИИ

obfs:
  type: salamander
  salamander:
    password: ЗАМЕНИТЕ_НА_КЛЮЧ_SALAMANDER

masquerade:
  type: proxy
  proxy:
    url: https://www.bing.com
    rewriteHost: true
EOF

chown -R hysteria:hysteria /etc/hysteria && chmod 640 /etc/hysteria/server.key
ufw allow 45123/udp
systemctl enable --now hysteria-server && systemctl restart hysteria-server

3. Соберите ссылку для клиента

hysteria2://ПАРОЛЬ@IP:45123/?insecure=1&sni=www.bing.com&alpn=h3&obfs=salamander&obfs-password=КЛЮЧ_SALAMANDER#my-vds

Если UDP-профили не соединяются: некоторые облачные панели блокируют входящий UDP снаружи виртуальной машины. Проверьте раздел Firewall / Security Groups в личном кабинете хостинга — либо переключитесь на 4-й профиль (VLESS TCP 443) из вывода нашего авто-скрипта.

Приложения для подключения

Все клиенты ниже работают только с вашими собственными серверами, понимают оба формата наших ссылок (hysteria2:// и vless://) и умеют импортировать сразу несколько профилей из буфера обмена.

Happ

macOS, iOS, Windows, Linux, Android

рекомендуем

Отлично работает на Mac (прямой .dmg с сайта или GitHub без привязки к региону App Store), ПК и телефонах. Принимает пачку профилей из буфера и показывает пинг каждого.

Hiddify

Windows, macOS, Linux, Android, iOS

Кроссплатформенный open-source клиент на sing-box. На компьютер и Android скачивается напрямую с GitHub (для установки на iPhone потребуется зарубежный регион Apple ID).

GitHub Releases →

NekoBox for Android

Android (APK)

Лёгкий открытый клиент именно для Android (десктопная ветка закрыта — для Mac и Windows берите Happ или Hiddify). Поддерживает смену UDP-портов и VLESS.

GitHub Releases →

CLI / Xray

Linux, терминал, сервер

Скрипт install-hysteria-config.sh поднимает локальный SOCKS5/HTTP-прокси через native Hysteria или добавляет профиль в установленный Xray.

Скачать скрипт →

Заметка для iPhone и iPad: из российского региона App Store многие универсальные сетевые клиенты (Happ, Hiddify, Streisand) периодически удаляются. На Mac проще всего скачать прямой .dmg с сайта Happ или GitHub, а на iOS — проверить актуальные ссылки/TestFlight на happ.su/main/ru либо временно переключить регион App Store на зарубежный.

Диагностика и частые вопросы

Что проверить, если профиль не отвечает

  • Переключите профиль: если на мобильной или офисной сети молчат первые три UDP-профиля, включите 4-й профиль (VLESS-TCP)
  • Статус служб на VDS: systemctl status hysteria-server hysteria-server@quic xray
  • Логи сервера: journalctl -u hysteria-server -n 50 --no-pager
  • Файрвол в панели хостинга: убедитесь, что провайдер VDS не закрыл входящий UDP во внешнем сетевом фильтре

Как подключить второе устройство или коллегу

Достаточно скопировать тот же блок ссылок из /root/hysteria-credentials.txt на второе устройство — минимальный VDS на 1–2 ядра и 2 ГБ памяти спокойно выдерживает десятки одновременных сессий для личной или командной разработки. Если для каждого участника команды нужны отдельные учётные данные, в /etc/hysteria/config.yaml можно переключить auth.type на userpass, а в /usr/local/etc/xray/config.json добавить новый UUID в массив clients.

А если не хочется настраивать сервер вообще?

Для текстовых, графических и видеомоделей без собственного VDS и зарубежных карт можно работать напрямую через arckep.ru (и чат chat.arckep.ru) — с российским IP и оплатой в рублях. Собственный VDS с туннелем незаменим прежде всего там, где нужны локальные терминальные инструменты разработки: Cursor, Claude Code, Codex CLI или прямые ключи зарубежных API.

// Обсуждение

Можно писать анонимно. Укажите email, чтобы получать уведомления об ответах.