redos_cifswitch_patch.sh

#!/bin/bash

# Copyright (C) 2026 D.G. (https://github.com/PandaInRed)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
#                             * * *
#
# Авторские права (C) 2026 D.G. (https://github.com/PandaInRed)
# 
# Эта программа является свободным программным обеспечением. Вы можете
# распространять и/или изменять ее на условиях Лицензии GNU GPL, опубликованной
# Фондом свободного программного обеспечения, версии 3 или более поздней.


# --------------------------------------------------------------
#             [РЕД ОС 7.3/8.0] CIFSwitch патч-скрипт
# --------------------------------------------------------------
#
#     Версия:     1.0.0
#                 /2026-06-14
#
#     Автор:      D.G.
#                 https://github.com/PandaInRed
#
#     Лицензия:   GNU GPLv3
#                 https://www.gnu.org/licenses/gpl-3.0.html
#
# --------------------------------------------------------------
#
# Об уязвимости CIFSwitch:
#  https://www.openwall.com/lists/oss-security/2026/05/28/2
#
# NVD NIST:
#  CVE-2026-46243
#  https://nvd.nist.gov/vuln/detail/CVE-2026-46243
#
# БДУ ФСТЭК:
#  BDU:2026-07574
#  https://bdu.fstec.ru/vul/2026-07574
#
# Бюллетени безопасности (РЕД ОС 7.3):
#  https://redos.red-soft.ru/support/secure/uyazvimosti/uyazvimost-kernel-lt-cve-2026-46243-7.3/
#
# Бюллетени безопасности (РЕД ОС 8.0):
#  https://redos.red-soft.ru/support/secure/uyazvimosti-red-os-8-0/uyazvimost-kernel-lt-cve-2026-46243-8.0/
#

set -e

# --- DO NOT MODIFY THE LINES BELOW UNLESS YOU KNOW WHAT YOU ARE DOING ---
# --- НЕ ИЗМЕНЯЙТЕ НИЖЕПРИВЕДЕННЫЕ СТРОКИ, ЕСЛИ НЕ ЗНАЕТЕ, ЧТО ДЕЛАЕТЕ ---

_quit() {
  local code=$1
  echo -e "Выход...\n"
  exit "$code"
}

_error() {
  echo -e "${RED}Критическая ошибка! Сбой выполнения скрипта в строке $1.${NC}\n" >&2
  _quit 1
}

_fmt_to_xyz() {
  local -a parts
  local x y z

  IFS='.' read -r -a parts <<< "$1"

  x="${parts[0]:-0}"
  y="${parts[1]:-0}"
  z="${parts[2]:-0}"

  echo "$x.$y.$z"
}

_compare_versions() {
  local min_version
  local v1 v2

  v1="$1"
  v2="$2"

  if [[ -z "$v1" || -z "$v2" ]]; then
    echo -e "${RED}Ошибка! Не переданы аргументы для сравнения версий.${NC}\n" >&2
    _quit 1
  fi

  local regex='^[0-9]+(\.[0-9]+){0,2}(-[0-9]+\.[a-zA-Z0-9._]+)?$'
  if [[ ! "$v1" =~ $regex || ! "$v2" =~ $regex ]]; then
    echo -e "${RED}Ошибка! Некорректный формат аргументов для сравнения версий.${NC}\n" >&2
    _quit 1
  fi

  if [[ "$v1" != *"-"* ]]; then v1=$(_fmt_to_xyz "$v1") || _error "$LINENO"; fi
  if [[ "$v2" != *"-"* ]]; then v2=$(_fmt_to_xyz "$v2") || _error "$LINENO"; fi

  # 0: v1 = v2
  if [[ "$v1" == "$v2" ]]; then
    echo "0"
    return
  fi

  min_version=$(echo -e "$v1\n$v2" | sort -V | head -n 1) || _error "$LINENO"

  # -1: v1 < v2, 1: v1 > v2
  if [[ "$min_version" == "$v1" ]]; then
    echo "-1"
  else
    echo "1"
  fi
}

_check_os_release() {
  local release_str family_str

  if [[ ! -f "$RELEASE_INFO" ]]; then
    echo -e "${RED}Ошибка! Файл информации о системе $RELEASE_INFO не найден.${NC}\n" >&2
    _quit 1
  fi

  release_str=$(cat "$RELEASE_INFO") || _error "$LINENO"

  OS_VENDOR="${release_str%\ release*}"
  if [[ "$OS_VENDOR" != "RED OS" ]]; then
    echo -e "${RED}Ошибка! Скрипт предназначен только для РЕД ОС.${NC}\n" >&2
    _quit 1
  fi

  if [[ "$release_str" =~ \(([0-9.]+)\) ]]; then
    OS_VERSION="${BASH_REMATCH[1]}"
  else
    if [[ "${release_str#*release }" =~ ^[0-9.]+ ]]; then
      OS_VERSION="${BASH_REMATCH[0]}"
    else
      echo -e "${RED}Ошибка! Не удалось определить версию ОС.${NC}\n" >&2
      _quit 1
    fi
  fi
  if [[ ! "$OS_VERSION" =~ ^(7\.3|8\.0)(\.[0-9]+)?$ ]]; then
    echo -e "${RED}Ошибка! Скрипт предназначен для РЕД ОС 7.3.x и 8.0.x (обнаружена $OS_VERSION).${NC}\n" >&2
    _quit 1
  fi

  family_str="${OS_VERSION%.*}"
  family_str="${family_str/.}"

  OS_FAMILY="$family_str"

  OS_ARCH="$(_get_os_arch)" || _error "$LINENO"
  if [[ "$OS_FAMILY" == "73" && "$OS_ARCH" != "x86_64" ]]; then
    echo -e "${RED}Ошибка! РЕД ОС 7.3 поддерживает только архитектуру x86_64.${NC}\n" >&2
    _quit 1
  fi

  OS_KERNEL="$(uname -r)"

  readonly OS_VENDOR OS_VERSION OS_FAMILY OS_ARCH OS_KERNEL
}

_get_os_arch() {
  local arch

  arch=$(uname -m)
  case "$arch" in
    x86_64|amd64)  echo "x86_64" ;;
    aarch64|arm64) echo "aarch64" ;;
    *)
      echo -e "${RED}Ошибка! Неподдерживаемая архитектура: $arch.${NC}\n" >&2
      _quit 1
      ;;
  esac
}

_check_kernel_ver() {
  local safe_kernel_ver
  local kernel_ver_comp

  safe_kernel_ver="TARGET_KERNEL_RED${OS_FAMILY}"
  safe_kernel_ver="${!safe_kernel_ver}"

  if [[ -z "$safe_kernel_ver" ]]; then
    echo -e "${RED}Ошибка! Не задана целевая версия безопасного ядра для РЕД ОС $OS_VERSION.${NC}\n" >&2
    _quit 1
  fi

  KERNEL_SAFE=0

  echo -e "${BLUE}Проверяем версию активного ядра Linux...${NC}\n"
  sleep 0.25

  kernel_ver_comp=$(_compare_versions "$OS_KERNEL" "${safe_kernel_ver}.${OS_ARCH}") || _error "$LINENO"

  if (( kernel_ver_comp >= 0 )); then
    KERNEL_SAFE=1
    echo -e "${GREEN}Вы уже используете безопасную версию ядра Linux. Действий не требуется.${NC}\n"
  else
    echo -e "${YELLOW}Используемая версия ядра Linux подвержена проверяемым уязвимостям.${NC}\n"
  fi
  return 0
}

_check_kernel_repo() {
  local safe_kernel_ver
  local dnf_repoquery_result dnf_repoquery_code

  safe_kernel_ver="TARGET_KERNEL_RED${OS_FAMILY}"
  safe_kernel_ver="${!safe_kernel_ver}"

  if [[ -z "$safe_kernel_ver" ]]; then
    echo -e "${RED}Ошибка! Не задана целевая версия безопасного ядра для РЕД ОС $OS_VERSION.${NC}\n" >&2
    _quit 1
  fi

  KERNEL_IN_REPO=0
  KERNEL_IN_REPO_LIST=()

  echo -e "${BLUE}Проверяем наличие обновлений с исправлением уязвимостей...${NC}\n"
  sleep 0.25

  set +e
  dnf_repoquery_result=$(dnf repoquery --quiet --showduplicates --available --arch="${OS_ARCH}" kernel-lt)
  dnf_repoquery_code="$?"
  set -e

  if [[ "$dnf_repoquery_code" -ne 0 ]]; then
    echo -e "${YELLOW}Не удалось выполнить запрос к репозиторию (код: $dnf_repoquery_code).${NC}\n"
    return 0
  fi

  if [[ -z "$dnf_repoquery_result" ]]; then
    echo -e "${YELLOW}Не удалось получить список доступных пакетов из репозитория.${NC}\n"
    return 0
  fi

  readarray -t KERNEL_IN_REPO_LIST <<< "$(echo "$dnf_repoquery_result" \
    | sort -V \
    | sed -n "/${safe_kernel_ver}\.${OS_ARCH}/,\$p" \
    | awk 'NF')"

  if (( ${#KERNEL_IN_REPO_LIST[@]} )); then
    KERNEL_IN_REPO=1
    echo -e "${GREEN}Пакет ядра Linux с исправлением уязвимостей найден в репозитории.${NC}\n"
  else
    echo -e "${YELLOW}Пакет ядра Linux с исправлением уязвимостей не найден в репозитории.${NC}\n"
  fi
  return 0
}

_check_userns_cfg() {
  [[ -f "$USERNS_FILE" ]] || return 1
  grep -qE '^[[:space:]]*user\.max_user_namespaces[[:space:]]*=[[:space:]]*0' "$USERNS_FILE"
}

_check_userns_runtime() {
  local userns_val

  userns_val=$(sysctl -n user.max_user_namespaces 2>/dev/null) || return 1
  [[ "$userns_val" == "0" ]]
}

_check_spnego_cfg() {
  [[ -f "$SPNEGO_FILE" ]] || return 1
  grep -qE '^create cifs\.spnego \* \* /usr/bin/keyctl negate %k 30 %S' "$SPNEGO_FILE"
}

_detect_patch_mode() {
  local has_userns=0
  local has_spnego=0

  if [[ -f "$USERNS_FILE" ]]; then
    has_userns=1
  fi
  
  if [[ -f "$SPNEGO_BAK" ]]; then
    has_spnego=1
  fi

  if [[ $has_userns -eq 1 && $has_spnego -eq 1 ]]; then
    echo "mismatch"
  elif [[ $has_userns -eq 1 ]]; then
    echo "userns"
  elif [[ $has_spnego -eq 1 ]]; then
    echo "spnego"
  else
    echo "none"
  fi
}

_check_patch_state() {
  local patch_mode
  local flag_ready=1
  local flag_active=1

  PATCH_READY=0
  PATCH_ACTIVE=0

  patch_mode="$(_detect_patch_mode)"

  if [[ "$patch_mode" == "mismatch" ]]; then
    echo -e "${RED}Критическая ошибка! Обнаружена некорректная комбинация примененных блокировок.${NC}"
    echo -e "${YELLOW}Для устранения ошибки перезапустите скрипт с параметром --rollback.${NC}"
    echo -e "${YELLOW}Затем снова проведите проверку / примените патч компенсирующих мер.${NC}\n"
    _quit 1
  fi

  if [[ "$patch_mode" == "none" ]]; then
    echo -e "${YELLOW}Компенсирующие меры для защиты не обнаружены.${NC}\n"
    return 0
  fi

  echo -e "${BLUE}Проверяем компоненты компенсирующих мер для защиты от уязвимости...${NC}\n"

  sleep 0.25

  # Пространства имен (sysctl)
  if [[ "$patch_mode" == "userns" ]]; then
    if _check_userns_cfg; then
      echo -e "Ограничение пространств имен найдено в $USERNS_FILE.\n"
    else
      echo -e "${YELLOW}Ограничение пространств имен не найдено в $USERNS_FILE.${NC}\n"
      flag_ready=0
    fi

    sleep 0.25

    if _check_userns_runtime; then
      echo -e "Ограничение пространств имен активно в текущей сессии.\n"
    else
      echo -e "${YELLOW}Ограничение пространств имен не активно в текущей сессии.${NC}\n"
      flag_active=0
    fi
  elif [[ -f "$USERNS_FILE" ]]; then
    echo -e "${YELLOW}Файл $USERNS_FILE присутствует, но не соответствует патчу защиты.${NC}\n"
    flag_ready=0
  fi

  sleep 0.25

  # Запрет использования cifs.upcall
  if [[ "$patch_mode" == "spnego" ]]; then
    if _check_spnego_cfg; then
      echo -e "Запрет использования cifs.upcall найден в $SPNEGO_FILE.\n"
    else
      echo -e "${YELLOW}Запрет использования cifs.upcall не найден в $SPNEGO_FILE.${NC}\n"
      flag_ready=0
    fi
  elif [[ -f "$SPNEGO_BAK" ]]; then
    echo -e "${YELLOW}Файл $SPNEGO_BAK присутствует, но не соответствует патчу защиты.${NC}\n"
    flag_ready=0
  fi

  sleep 0.25

  if [[ $flag_ready -eq 1 ]]; then
    PATCH_READY=1
    if [[ $flag_active -eq 1 ]]; then
      PATCH_ACTIVE=1
      echo -e "${GREEN}Компенсирующие меры для защиты применены и активны. Действий не требуется.${NC}\n"
    else
      echo -e "${GREEN}Компенсирующие меры для защиты от уязвимости уже применены.${NC}"
      echo -e "${YELLOW}Для активации защиты необходимо перезагрузить систему.${NC}\n"
    fi
  else
    echo -e "${YELLOW}Компенсирующие меры для защиты неполные или не обнаружены в конфигурации.${NC}\n"
  fi

  return 0
}

_check_secretnet () {
  SNLSP_FOUND=0
  if rpm -q --quiet secretnet 2>/dev/null; then
    if systemctl is-active --quiet snkernel 2>/dev/null || \
       systemctl is-active --quiet snstart 2>/dev/null || \
       systemctl is-active --quiet sn 2>/dev/null; then
      SNLSP_FOUND=1
      echo -e "${YELLOW}В системе обнаружено использование СЗИ Secret Net LSP.${NC}\n"
    fi
  fi
  return 0
}

_check_privileges() {
  if [[ $EUID -eq 0 ]]; then
    return 0
  fi

  echo -e "${YELLOW}Предупреждение: для корректной работы необходим запуск с наивысшими привилегиями.${NC}"
  echo -e "${YELLOW}Запрос прав администратора...${NC}\n"

  if sudo -v; then
    echo -e "${GREEN}Права администратора получены.${NC}\n"
    echo -e "${BLUE}Перезапуск скрипта...${NC}\n"

    local forced_key
    case "$1" in
      "-c"|"--check") forced_key="--forced-check" ;;
      "-p"|"--patch") forced_key="--forced-patch" ;;
      "-r"|"--rollback") forced_key="--forced-rollback" ;;
      *) forced_key="$1" ;;
    esac

    exec sudo "$0" "$forced_key" || _error "$LINENO"
  else
    echo -e "${RED}Права администратора не получены.${NC}\n" >&2
    _quit 1
  fi
}

_get_choice() {
  local choice

  while true; do
    echo -ne "${BOLD}$1 (д/н): ${NC}" >&2
    read -r choice
    echo >&2
    case "$choice" in
      [YyДд] )
        echo "0"
        return;;
      [NnНн] )
        echo "1"
        return;;
    esac
  done
}

_ask_patch() {
  local response

  response=$(_get_choice "Применить компенсирующие меры для защиты от уязвимости?") || _error "$LINENO"
  if [[ "$response" -eq 0 ]]; then
    _run_patch
  fi
}

_ask_update() {
  local kver kver_cut response

  kver="${1:-}"
  kver_cut="${kver#*:}"
  kver_cut="${kver_cut%%-*}"

  response=$(_get_choice "Обновить ядро Linux до безопасной версии${kver_cut:+ $kver_cut}?") || _error "$LINENO"

  if [[ "$response" -eq 0 ]]; then
    _run_update ${kver:+"$kver"}
  else
    _ask_patch
  fi
}

_run_check() {
  local safe_kernel_ver
  local response

  safe_kernel_ver="TARGET_KERNEL_RED${OS_FAMILY}"
  safe_kernel_ver="${!safe_kernel_ver}"

  if [[ -z "$safe_kernel_ver" ]]; then
    _check_patch_state
    sleep 0.25

    if [[ $PATCH_READY -eq 1 ]]; then
      _quit 0
    fi

    _ask_patch
    _quit 0
  fi

  _check_kernel_ver
  sleep 0.25

  if [[ $KERNEL_SAFE -eq 1 ]]; then
    _quit 0
  else
    _check_kernel_repo
    sleep 0.25

    if [[ $KERNEL_IN_REPO -eq 0 ]]; then
      _ask_patch
      _quit 0
    fi
  fi

  _check_patch_state
  sleep 0.25

  if [[ $PATCH_READY -eq 1 ]]; then
    _quit 0
  fi

  _check_secretnet
  sleep 0.25

  if [[ $SNLSP_FOUND -eq 1 ]]; then
    local snlsp_notes_url snlsp_notes_raw snlsp_limit_kver snlsp_match_kver repo_kver

    snlsp_notes_url="SNLSP_PACKAGE_RED${OS_FAMILY}"
    snlsp_notes_url="${!snlsp_notes_url}"

    if [[ -z "$snlsp_notes_url" ]]; then
      _ask_patch
      _quit 0
    fi

    if ! snlsp_notes_raw=$(curl -fsSL --connect-timeout 10 --max-time 30 "$snlsp_notes_url" 2>/dev/null); then
      snlsp_notes_raw=""
    fi

    if [[ -z "$snlsp_notes_raw" ]]; then
      echo -e "${YELLOW}Не удалось загрузить данные о совместимости СЗИ с безопасной версией ядра.${NC}\n"
      echo -e "${BLUE}Рекомендуется применение компенсирующих мер для защиты от уязвимости.${NC}\n"

      _ask_patch
      _quit 0
    fi

    snlsp_limit_kver=$(echo "$snlsp_notes_raw" \
      | awk '/### All Supported kernels/,/### Changes/ {
          if ($0 ~ /Support kernel/) {
            sub(/\r$/, "", $4);
            print $4;
          }
        }' \
      | sort -V \
      | tail -n 1)

    if [[ -z "$snlsp_limit_kver" ]]; then
      echo -e "${YELLOW}Не удалось определить крайнюю поддерживаемую Secret Net LSP версию ядра.${NC}\n"
      echo -e "${BLUE}Рекомендуется применение компенсирующих мер для защиты от уязвимости.${NC}\n"

      _ask_patch
      _quit 0
    fi

    for repo_kver in "${KERNEL_IN_REPO_LIST[@]}"; do
      if [[ "$repo_kver" == *"$snlsp_limit_kver"* ]]; then
        snlsp_match_kver="$repo_kver"
        break
      fi
    done

    if [[ -n "$snlsp_match_kver" ]]; then
      local short_kver="${snlsp_match_kver#*:}"
      short_kver="${short_kver%%-*}"

      echo -e "${GREEN}Среди поддерживаемых Secret Net LSP ядер найдена безопасная версия: $short_kver.${NC}\n"
      echo -e "${BLUE}Для устранения уязвимости рекомендуется произвести обновление системы.${NC}\n"

      echo -e "${YELLOW}Перед обновлением убедитесь, что у Вас установлена актуальная версия Secret Net LSP.${NC}"
      echo -e "${YELLOW}Запуск ОС с неподдерживаемой СЗИ версией ядра может привести к блокировке системы!${NC}\n"

      _ask_update "$snlsp_match_kver"
      _quit 0
    else
      echo -e "${YELLOW}Безопасная версия ядра ${safe_kernel_ver}.${OS_ARCH} и выше не поддерживается Secret Net LSP.${NC}\n"
      echo -e "${BLUE}Рекомендуется применение компенсирующих мер для защиты от уязвимости.${NC}\n"

      _ask_patch
      _quit 0
    fi
  fi

  echo -e "${BLUE}Для устранения уязвимости рекомендуется произвести обновление системы.${NC}\n"

  _ask_update "${KERNEL_IN_REPO_LIST[-1]}"
  _quit 0
}

_run_patch() {
  local response
  local need_os_reboot=0

  echo -e "${BLUE}Применяем компенсирующие меры для защиты от уязвимости...${NC}\n"
  sleep 0.25

  response=$(_get_choice "Используется ли автоматическая авторизация в AD/Samba на данном компьютере?") || _error "$LINENO"
  if [[ "$response" -eq 0 ]]; then
    # Ограничиваем пространства имен (sysctl)
    echo -e "${BLUE}Ограничиваем непривилегированные пространства имен...${NC}\n"
    sleep 0.25

    if echo "user.max_user_namespaces = 0" > "$USERNS_FILE"; then
      echo -e "${GREEN}Конфигурация sysctl успешно добавлена в файл $USERNS_FILE.${NC}\n"

      echo -e "${YELLOW}ОБРАТИТЕ ВНИМАНИЕ:${NC}"
      echo -e "${YELLOW}Эта мера может сделать невозможным использование rootless-контейнеров${NC}"
      echo -e "${YELLOW}(Docker/Podman) и ПО для создания изолированных окружений (песочниц).${NC}\n"
    else
      echo -e "${RED}Ошибка! Не удалось добавить конфигурацию в файл $USERNS_FILE.${NC}\n" >&2
      _quit 1
    fi

    sleep 0.25

    # ...и применяем ограничение (runtime)
    if sysctl -w user.max_user_namespaces=0 >/dev/null 2>&1; then
      echo -e "${GREEN}Ограничение пространств имен успешно применено.${NC}\n"
    else
      echo -e "${YELLOW}Не удалось применить ограничение в текущей сессии.${NC}\n"
      need_os_reboot=1
    fi
  else
    # Запрещаем использование cifs.upcall
    echo -e "${BLUE}Запрещаем использование cifs.upcall при обработке ключей Kerberos...${NC}\n"
    sleep 0.25

    if [[ -f "$SPNEGO_FILE" && ! -f "$SPNEGO_BAK" ]]; then
      if cp -p "$SPNEGO_FILE" "$SPNEGO_TMP" && mv "$SPNEGO_TMP" "$SPNEGO_BAK"; then
        echo -e "Создана резервная копия файла конфигурации $SPNEGO_BAK.\n"
        sleep 0.25
      else
        echo -e "${RED}Ошибка! Не удалось создать резервную копию $SPNEGO_FILE.${NC}\n" >&2
        rm -f "$SPNEGO_TMP"
        _quit 1
      fi
    fi

    if echo "create cifs.spnego * * /usr/bin/keyctl negate %k 30 %S" > "$SPNEGO_FILE"; then
      echo -e "${GREEN}Запрет использования cifs.upcall успешно добавлен в конфигурацию.${NC}\n"

      echo -e "${YELLOW}ОБРАТИТЕ ВНИМАНИЕ:${NC}"
      echo -e "${YELLOW}Эта мера сделает невозможной автоматическую доменную авторизацию в AD/Samba.${NC}"
      echo -e "${YELLOW}Пользователи не смогут автоматически монтировать сетевые диски под своей УЗ.${NC}"
      echo -e "${YELLOW}Монтирование сетевых каталогов с указанием доменной учетной записи и пароля${NC}"
      echo -e "${YELLOW}в командной строке (параметры username и password) продолжит работать.${NC}\n"
    else
      echo -e "${RED}Ошибка! Не удалось добавить запрет в файл $SPNEGO_FILE.${NC}\n" >&2
      _quit 1
    fi
  fi

  sleep 0.25

  if [[ "$need_os_reboot" -eq 1 ]]; then
    echo -e "${GREEN}Компенсирующие меры для защиты от уязвимости успешно добавлены.${NC}"
    echo -e "${YELLOW}Для применения изменений необходимо перезагрузить систему.${NC}\n"
  else
    echo -e "${GREEN}Компенсирующие меры для защиты от уязвимости успешно применены.${NC}\n"
  fi
  _quit 0
}

_run_rollback() {
  local need_os_reboot=0

  echo -e "${BLUE}Отменяем компенсирующие меры для защиты от уязвимости...${NC}\n"
  sleep 0.25

  # Отменяем ограничения пространств имен (sysctl)
  if [[ -f "$USERNS_FILE" ]]; then
    echo -e "${BLUE}Восстанавливаем параметры пространств имен sysctl...${NC}\n"
    sleep 0.25

    if rm -f "$USERNS_FILE"; then
      echo -e "${GREEN}Конфигурация ограничения пространств имен успешно удалена.${NC}"
      echo -e "${YELLOW}Изменения вступят в силу после перезагрузки.${NC}\n"
      need_os_reboot=1
    else
      echo -e "${RED}Ошибка! Не получилось удалить файл конфигурации sysctl $USERNS_FILE.${NC}\n" >&2
      _quit 1
    fi
  fi

  sleep 0.25

  # Отменяем запрет использования cifs.upcall
  if [[ -f "$SPNEGO_BAK" ]]; then
    echo -e "${BLUE}Разрешаем использование cifs.upcall при обработке ключей Kerberos...${NC}\n"
    sleep 0.25

    if [[ -s "$SPNEGO_BAK" ]]; then
      if cp -p "$SPNEGO_BAK" "$SPNEGO_TMP" && mv "$SPNEGO_TMP" "$SPNEGO_FILE"; then
        echo -e "${GREEN}Запрет использования cifs.upcall успешно удален (конфигурация восстановлена).${NC}\n"
        rm -f "$SPNEGO_BAK"
      else
        echo -e "${RED}Ошибка! Не удалось восстановить резервную копию $SPNEGO_BAK.${NC}\n" >&2
        rm -f "$SPNEGO_TMP"
        _quit 1
      fi
    else
      echo -e "${RED}Ошибка! Восстановление конфигурации из резервной копии прервано (файл пуст).${NC}\n"
      echo -e "${YELLOW}Для исправления рекомендуется:${NC}"
      echo -e "${YELLOW}1) Удалить файл резервной копии $SPNEGO_BAK${NC}"
      echo -e "${YELLOW}2) Отредактировать конфигурацию $SPNEGO_FILE вручную:${NC}"
      echo -e "${YELLOW}${BOLD}create  cifs.spnego    * * /usr/sbin/cifs.upcall %k${NC}\n"
      _quit 1
    fi
  fi

  sleep 0.25

  if [[ "$need_os_reboot" -eq 1 ]]; then
    echo -e "${GREEN}Компенсирующие меры для защиты от уязвимости успешно отменены.${NC}"
    echo -e "${YELLOW}Для применения изменений необходимо перезагрузить систему.${NC}\n"
  else
    echo -e "${GREEN}Компенсирующие меры для защиты от уязвимости успешно отменены.${NC}\n"
  fi
  _quit 0
}

_run_update() {
  local inst_kernel_ver safe_kernel_ver
  local dnf_install_code dnf_vlock_used

  if [[ -n "${1:-}" ]]; then
    inst_kernel_ver="$1"
  else
    safe_kernel_ver="TARGET_KERNEL_RED${OS_FAMILY}"
    safe_kernel_ver="${!safe_kernel_ver}"

    if [[ -z "$safe_kernel_ver" ]]; then
      echo -e "${RED}Ошибка! Не задана целевая версия безопасного ядра для РЕД ОС $OS_VERSION.${NC}\n" >&2
      _quit 1
    fi

    inst_kernel_ver="kernel-lt-${safe_kernel_ver}.${OS_ARCH}"
  fi

  echo -e "${BLUE}Запускаем установку ядра Linux...${NC}\n"
  sleep 0.25

  if rpm -q --quiet --whatprovides 'dnf-command(versionlock)'; then
    dnf_vlock_used=1
    dnf --quiet versionlock delete "kernel-lt" || true
  else
    dnf_vlock_used=0
  fi

  set +e
  dnf install "$inst_kernel_ver"
  dnf_install_code="$?"
  set -e

  if [[ "$dnf_install_code" -eq 0 ]]; then
    if [[ "$dnf_vlock_used" -eq 1 ]]; then
      dnf --quiet versionlock add "$inst_kernel_ver" || true
    fi

    echo -e "${GREEN}Обновление ядра Linux и сопутствующих зависимостей успешно завершено.${NC}"
    echo -e "${YELLOW}Для применения изменений загрузите систему, выбрав безопасное ядро.${NC}\n"
    _quit 0
  fi

  sleep 0.25

  echo -e "${RED}Критическая ошибка! Сбой пакетного менеджера dnf при установке (код: $dnf_install_code).${NC}\n" >&2
  _quit 1
}

# --- INIT VALUES ---

readonly RELEASE_INFO="/etc/system-release"
readonly USERNS_FILE="/etc/sysctl.d/99-no-userns-cifswitch.conf"
readonly SPNEGO_FILE="/etc/request-key.d/cifs.spnego.conf"
readonly SPNEGO_BAK="${SPNEGO_FILE}.bak~cifswitch"
readonly SPNEGO_TMP="${SPNEGO_FILE}.tmp~cifswitch"

readonly TARGET_KERNEL_RED73="6.1.175-1.el7.3"
readonly TARGET_KERNEL_RED80="6.12.92-1.red80"

readonly SNLSP_PACKAGE_RED73="https://download.securitycode.ru/snlsp/redos/7.3/1.12/updates/package_notes.txt"
readonly SNLSP_PACKAGE_RED80="https://download.securitycode.ru/snlsp/redos/8.0/1.12/updates/package_notes.txt"

readonly BLUE='\033[0;94m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[0;93m'
readonly RED='\033[0;31m'
readonly BOLD='\033[1m'
readonly NC='\033[0m'

OS_VENDOR=""
OS_FAMILY=""
OS_VERSION=""
OS_ARCH=""
OS_KERNEL=""

KERNEL_SAFE=0
KERNEL_IN_REPO=0
KERNEL_IN_REPO_LIST=()
PATCH_READY=0
PATCH_ACTIVE=0
SNLSP_FOUND=0

# --- LET'S GO TO THE DANCING ---

_show_banner() {
  echo "
--------------------------------------------------------------
            [РЕД ОС 7.3/8.0] CIFSwitch патч-скрипт
--------------------------------------------------------------

     Скрипт для проверки и устранения угроз безопасности,
      вызванных критическими уязвимостями в ядре Linux,
     в операционной системе РЕД ОС (версии 7.3.x и 8.0.x)

     Уязвимости:
      – CIFSwitch (CVE-2026-46243)

--------------------------------------------------------------
"
}

_show_info() {
  echo "
 CIFSwitch является Local Privilege Escalation уязвимостью
 и может быть использована в системах на базе ядра Linux
 (не проверяется происхождение описания ключа cifs.spnego,
 используемого для аутентификации на SMB-сервере).

 При помощи этой уязвимости непривилегированный локальный
 пользователь может получить доступ к системе уровня root.


 Об уязвимости CIFSwitch:
  https://www.openwall.com/lists/oss-security/2026/05/28/2


 NVD NIST:
  CVE-2026-46243
  https://nvd.nist.gov/vuln/detail/CVE-2026-46243

 БДУ ФСТЭК:
  BDU:2026-07574
  https://bdu.fstec.ru/vul/2026-07574
"
}

_show_about() {
  echo "
--------------------------------------------------------------
            [РЕД ОС 7.3/8.0] CIFSwitch патч-скрипт
--------------------------------------------------------------

    Версия:     1.0.0
                /2026-06-14

    Автор:      D.G.
                https://github.com/PandaInRed

    Лицензия:   GNU GPLv3
                https://www.gnu.org/licenses/gpl-3.0.html

--------------------------------------------------------------

 Bash-скрипт (далее – Программный продукт) предоставляется
 автором на основе принципа «КАК ЕСТЬ» (AS IS), выражаемого
 в отказе от предоставления любых явных или подразумеваемых
 гарантий, а также в отсутствии обязательства предоставлять
 сопровождение, поддержку, обновление или изменение
 Программного продукта.
 
 Конечный пользователь использует данный Программный продукт
 на свой страх и риск.

 Автор не несет ответственности за качество и функциональные
 особенности данного Программного продукта, как явные, так
 и предполагаемые, равно как и за фактическое соответствие
 Программного продукта заявленной функциональности.
 
 Автор не несет ответственности за проблемы, которые могут
 возникать в процессе эксплуатации Программного продукта,
 как в случаях, когда проблемы обусловлены несовместимостью
 с другими программными продуктами (пакетами, драйверами),
 так и в случаях несоответствия результатов использования
 Программного продукта ожиданиям Конечного пользователя.

 Конечный пользователь понимает и выражает согласие с тем,
 что, используя Программный продукт, он делает это по своему
 усмотрению и несет полную ответственность за любой ущерб,
 который это может за собой повлечь, включая несовместимость
 или конфликты Программного продукта с другими программными
 продуктами, используемыми Конечным пользователем.
"
}

_show_help() {
  echo "
 Справка по командам запуска:
   -c (--check)     проверка наличия уязвимостей
   -i (--info)      информация об уязвимостях

   -p (--patch)     применить патч (без проверки --check)
   -r (--rollback)  откатить патч

   -a (--about)     подробнее об этом скрипте
   -h (--help)      данное сообщение
"
}

_show_hint() {
  echo "
 Использование скрипта:
   -h (--help) – справка по параметрам запуска
"
}

if [[ "$#" -ne 1 ]]; then
  _show_hint
  exit 1
fi

case $1 in
  "-c"|"--check")
    _show_banner
    sleep 2
    _check_privileges "$1"
    _check_os_release
    _run_check
    ;;
  "--forced-check")
    _check_os_release
    _run_check
    ;;
  "-p"|"--patch")
    _show_banner
    sleep 2
    _check_privileges "$1"
    _check_os_release
    _run_patch
    ;;
  "--forced-patch")
    _check_os_release
    _run_patch
    ;;
  "-r"|"--rollback")
    _show_banner
    sleep 2
    _check_privileges "$1"
    _check_os_release
    _run_rollback
    ;;
  "--forced-rollback")
    _check_os_release
    _run_rollback
    ;;
  "-i"|"--info")
    _show_info
    ;;
  "-a"|"--about")
    _show_about
    ;;
  "-h"|"--help")
    _show_help
    ;;
  *)
    _show_hint
    exit 1
    ;;
esac