#!/usr/bin/env bash
# Install Vibeshine's out-of-tree DRM module. DKMS is preferred so kernel
# updates rebuild the module; a current-kernel direct build is the fallback.

set -uo pipefail
umask 022

PROGRAM_NAME="vibeshine-drm-install"
DKMS_NAME="vibeshine-drm"
MODULE_NAME="vibeshine_drm"
MODULE_VERSION="2.0.0"
MODULE_SOURCE_ID="d3a07464a6d298b34e1c7a73f0731684dbda3fdda391d4b7c249bff34d32dad6"
RELOAD_REQUIRED_EXIT=4
ENROLLMENT_PENDING_EXIT=5

SOURCE_DIR=""
STATE_DIR=""
MODULES_ROOT=""
SYS_MODULE_ROOT=""
BUILD_TMP_ROOT=""
KERNEL_RELEASE_OVERRIDE=""
MOK_SIGNING_KEY=""
MOK_CERTIFICATE=""
EFI_FIRMWARE_ROOT="/sys/firmware/efi"
EFI_VARS_ROOT="/sys/firmware/efi/efivars"
EFI_MOK_VARIABLES_ROOT="/sys/firmware/efi/mok-variables"
LOCKDOWN_FILE="/sys/kernel/security/lockdown"
MODULE_SIG_ENFORCE_FILE="/sys/module/module/parameters/sig_enforce"
DKMS_CONFIG_ROOT="/etc/dkms"
TTY_DEVICE="/dev/tty"
AUTO_ENROLL=0
MINIMUM_KERNEL_MAJOR=6
MINIMUM_KERNEL_MINOR=16

log() {
  printf '%s: %s\n' "$PROGRAM_NAME" "$*"
}

error() {
  printf '%s: error: %s\n' "$PROGRAM_NAME" "$*" >&2
}

configure_install_paths() {
  SOURCE_DIR=$1
  STATE_DIR=$2
  MODULES_ROOT=$3
  SYS_MODULE_ROOT=$4
  BUILD_TMP_ROOT=$5
  MOK_SIGNING_KEY=${6:-/var/lib/dkms/mok.key}
  MOK_CERTIFICATE=${7:-/var/lib/dkms/mok.pub}
}

require_root() {
  if ((EUID != 0)); then
    error "this action must be run as root"
    return 1
  fi
}

require_command() {
  local command_name=$1

  if ! command -v "$command_name" >/dev/null 2>&1; then
    error "required command not found: ${command_name}"
    return 1
  fi
}

validate_signing_paths() {
  case "$MOK_SIGNING_KEY" in
    /*/mok.key) ;;
    *)
      error "unsafe MOK signing-key path: ${MOK_SIGNING_KEY}"
      return 1
      ;;
  esac
  case "$MOK_CERTIFICATE" in
    /*/mok.pub | /*/MOK.der) ;;
    *)
      error "unsafe MOK certificate path: ${MOK_CERTIFICATE}"
      return 1
      ;;
  esac
  if [[ -L "$MOK_SIGNING_KEY" || -L "$MOK_CERTIFICATE" ]]; then
    error "refusing symbolic-link MOK signing files"
    return 1
  fi
}

prepare_signing_key() {
  local signing_dir

  validate_signing_paths || return 1
  signing_dir=${MOK_SIGNING_KEY%/*}
  if [[ "$signing_dir" != "${MOK_CERTIFICATE%/*}" || -L "$signing_dir" ]]; then
    error "MOK signing files must share a safe directory"
    return 1
  fi
  if [[ -f "$MOK_SIGNING_KEY" && -f "$MOK_CERTIFICATE" ]]; then
    if [[ ! -d "$signing_dir" ]]; then
      error "MOK signing directory is unavailable or unsafe: ${signing_dir}"
      return 1
    fi
    validate_signing_key_pair || return 1
    chmod 0600 -- "$MOK_SIGNING_KEY" || return 1
    chmod 0644 -- "$MOK_CERTIFICATE" || return 1
    return 0
  fi
  if [[ -e "$MOK_SIGNING_KEY" && ! -f "$MOK_SIGNING_KEY" ]] ||
     [[ -e "$MOK_CERTIFICATE" && ! -f "$MOK_CERTIFICATE" ]]; then
    error "MOK signing path exists but is not a regular file"
    return 1
  fi
  if [[ -e "$MOK_SIGNING_KEY" || -e "$MOK_CERTIFICATE" ]]; then
    error "refusing to replace an incomplete MOK signing-key pair"
    return 1
  fi

  require_command mkdir || return 1
  require_command openssl || return 1
  mkdir -p -- "$signing_dir" || return 1
  if [[ ! -d "$signing_dir" || -L "$signing_dir" ]]; then
    error "MOK signing directory is unavailable or unsafe: ${signing_dir}"
    return 1
  fi

  log "generating the local DKMS module-signing key"
  if ! (umask 077 && openssl req -new -x509 -nodes -days 36500 \
      -subj "/CN=Vibeshine DKMS module signing key/" \
      -newkey rsa:2048 -keyout "$MOK_SIGNING_KEY" \
      -addext "extendedKeyUsage=codeSigning" \
      -outform DER -out "$MOK_CERTIFICATE" >/dev/null 2>&1); then
    error "could not generate the MOK signing key"
    return 1
  fi
  chmod 0600 -- "$MOK_SIGNING_KEY" || return 1
  chmod 0644 -- "$MOK_CERTIFICATE" || return 1
  validate_signing_key_pair
}

validate_signing_key_pair() {
  local key_fingerprint certificate_fingerprint

  require_command openssl || return 1
  require_command sha256sum || return 1
  key_fingerprint=$(openssl pkey -in "$MOK_SIGNING_KEY" -pubout -outform DER 2>/dev/null | sha256sum) || {
    error "could not read the MOK private key"
    return 1
  }
  certificate_fingerprint=$(openssl x509 -inform DER -in "$MOK_CERTIFICATE" -pubkey -noout 2>/dev/null |
    openssl pkey -pubin -outform DER 2>/dev/null | sha256sum) || {
    error "could not read the MOK certificate"
    return 1
  }
  key_fingerprint=${key_fingerprint%% *}
  certificate_fingerprint=${certificate_fingerprint%% *}
  if [[ "$key_fingerprint" != "$certificate_fingerprint" ]]; then
    error "the MOK private key and certificate do not match"
    return 1
  fi
}

kernel_sign_file() {
  local kernel_release=$1
  printf '%s/%s/build/scripts/sign-file\n' "$MODULES_ROOT" "$kernel_release"
}

kernel_sign_hash() {
  local kernel_release=$1 config_file hash

  config_file="$MODULES_ROOT/$kernel_release/build/.config"
  hash=""
  if [[ -f "$config_file" ]]; then
    hash=$(sed -n 's/^CONFIG_MODULE_SIG_HASH="\([A-Za-z0-9_-]*\)"$/\1/p' "$config_file" | head -n 1)
  fi
  printf '%s\n' "${hash:-sha256}"
}

sign_module_file() {
  local kernel_release=$1 module_file=$2 sign_file sign_hash

  prepare_signing_key || return 1
  sign_file=$(kernel_sign_file "$kernel_release")
  if [[ ! -x "$sign_file" || -L "$sign_file" ]]; then
    error "kernel module signer is unavailable at ${sign_file}"
    return 1
  fi
  sign_hash=$(kernel_sign_hash "$kernel_release")
  log "signing ${MODULE_NAME} for ${kernel_release}"
  "$sign_file" "$sign_hash" "$MOK_SIGNING_KEY" "$MOK_CERTIFICATE" "$module_file" || return 1
  verify_module_signature_matches_certificate "$module_file"
}

certificate_serial() {
  local certificate=$1 serial
  local -a certificate_args

  if grep -q '^-----BEGIN CERTIFICATE-----' "$certificate" 2>/dev/null; then
    certificate_args=(-in "$certificate")
  else
    certificate_args=(-inform DER -in "$certificate")
  fi
  serial=$(openssl x509 "${certificate_args[@]}" -noout -serial 2>/dev/null) || return 1
  serial=${serial#serial=}
  serial=${serial//:/}
  printf '%s\n' "${serial^^}"
}

verify_module_signature_matches_certificate() {
  local module_file=$1 certificate_key module_key

  require_command modinfo || return 1
  certificate_key=$(certificate_serial "$MOK_CERTIFICATE") || {
    error "could not read the module-signing certificate serial"
    return 1
  }
  module_key=$(modinfo -F sig_key "$module_file" 2>/dev/null) || {
    error "could not inspect the signature on ${module_file}"
    return 1
  }
  module_key=${module_key//:/}
  module_key=${module_key^^}
  if [[ -z "$module_key" || "$module_key" != "$certificate_key" ]]; then
    error "${module_file} was not signed with the configured Vibeshine key"
    return 1
  fi
}

installed_module_matches_signing_certificate() {
  local kernel_release=$1 module_file

  module_file=$(modinfo -k "$kernel_release" -n "$MODULE_NAME" 2>/dev/null) || {
    error "could not locate the installed ${MODULE_NAME} module for ${kernel_release}"
    return 1
  }
  if [[ ! -f "$module_file" || -L "$module_file" ]]; then
    error "installed module path is unavailable or unsafe: ${module_file}"
    return 1
  fi
  verify_module_signature_matches_certificate "$module_file"
}

certificate_sha1_fingerprint() {
  local certificate=$1 fingerprint

  fingerprint=$(openssl x509 -inform DER -in "$certificate" -noout -sha1 -fingerprint 2>/dev/null) || return 1
  fingerprint=${fingerprint#*=}
  fingerprint=${fingerprint//:/}
  printf '%s\n' "${fingerprint^^}"
}

mok_certificate_is_in_list() {
  local list_action=$1 certificate_fingerprint line listed_fingerprint
  local list_output

  command -v mokutil >/dev/null 2>&1 || return 1
  certificate_fingerprint=$(certificate_sha1_fingerprint "$MOK_CERTIFICATE") || return 1
  list_output=$(LC_ALL=C mokutil "$list_action" 2>/dev/null) || return 1
  while IFS= read -r line; do
    case "$line" in
      *"SHA1 Fingerprint:"*)
        listed_fingerprint=${line#*SHA1 Fingerprint:}
        listed_fingerprint=${listed_fingerprint//:/}
        listed_fingerprint=${listed_fingerprint//[[:space:]]/}
        [[ "${listed_fingerprint^^}" == "$certificate_fingerprint" ]] && return 0
        ;;
    esac
  done <<<"$list_output"
  return 1
}

mok_certificate_is_enrolled() {
  mok_certificate_is_in_list --list-enrolled
}

mok_certificate_is_enrollment_pending() {
  mok_certificate_is_in_list --list-new
}

mok_manager_is_active() {
  [[ -d "$EFI_MOK_VARIABLES_ROOT" && ! -L "$EFI_MOK_VARIABLES_ROOT" ]]
}

mok_list_is_trusted() {
  local trusted_value trusted_variable

  if [[ -f "$EFI_MOK_VARIABLES_ROOT/MokListTrustedRT" &&
        ! -L "$EFI_MOK_VARIABLES_ROOT/MokListTrustedRT" ]]; then
    trusted_value=$(od -An -tu1 -N1 "$EFI_MOK_VARIABLES_ROOT/MokListTrustedRT" 2>/dev/null) || return 1
    trusted_value=${trusted_value//[[:space:]]/}
    [[ "$trusted_value" == 1 ]]
    return
  fi
  for trusted_variable in "$EFI_VARS_ROOT"/MokListTrustedRT-*; do
    [[ -f "$trusted_variable" && ! -L "$trusted_variable" ]] || continue
    trusted_value=$(od -An -tu1 -j4 -N1 "$trusted_variable" 2>/dev/null) || continue
    trusted_value=${trusted_value//[[:space:]]/}
    [[ "$trusted_value" == 1 ]] && return 0
  done
  return 1
}

secure_boot_state() {
  local secure_boot_var secure_boot_value state_output

  for secure_boot_var in "$EFI_VARS_ROOT"/SecureBoot-*; do
    [[ -f "$secure_boot_var" && ! -L "$secure_boot_var" ]] || continue
    secure_boot_value=$(od -An -tu1 -j4 -N1 "$secure_boot_var" 2>/dev/null) || continue
    secure_boot_value=${secure_boot_value//[[:space:]]/}
    case "$secure_boot_value" in
      1) printf 'enabled\n'; return 0 ;;
      0) printf 'disabled\n'; return 0 ;;
    esac
  done

  if command -v mokutil >/dev/null 2>&1; then
    state_output=$(LC_ALL=C mokutil --sb-state 2>/dev/null || true)
    case "$state_output" in
      *"SecureBoot enabled"*) printf 'enabled\n'; return 0 ;;
      *"SecureBoot disabled"*) printf 'disabled\n'; return 0 ;;
    esac
  fi
  if command -v sbctl >/dev/null 2>&1; then
    state_output=$(sbctl setup --print-state --json 2>/dev/null || true)
    if grep -Eq '"secure_boot"[[:space:]]*:[[:space:]]*true' <<<"$state_output"; then
      printf 'enabled\n'
      return 0
    fi
    if grep -Eq '"secure_boot"[[:space:]]*:[[:space:]]*false' <<<"$state_output"; then
      printf 'disabled\n'
      return 0
    fi
  fi
  printf 'unknown\n'
}

secure_boot_is_enabled() {
  [[ $(secure_boot_state) == enabled ]]
}

module_signature_is_enforced() {
  local enforcement lockdown

  if [[ -f "$MODULE_SIG_ENFORCE_FILE" && ! -L "$MODULE_SIG_ENFORCE_FILE" ]]; then
    IFS= read -r enforcement <"$MODULE_SIG_ENFORCE_FILE" || enforcement=""
    case "$enforcement" in
      1 | Y | y | yes | true) return 0 ;;
    esac
  fi
  if [[ -f "$LOCKDOWN_FILE" && ! -L "$LOCKDOWN_FILE" ]]; then
    IFS= read -r lockdown <"$LOCKDOWN_FILE" || lockdown=""
    [[ "$lockdown" == *"[integrity]"* || "$lockdown" == *"[confidentiality]"* ]] && return 0
  fi
  return 1
}

sbctl_is_configured() {
  local state_output

  command -v sbctl >/dev/null 2>&1 || return 1
  state_output=$(sbctl setup --print-state --json 2>/dev/null || true)
  grep -Eq '"installed"[[:space:]]*:[[:space:]]*true' <<<"$state_output"
}

report_enrollment_needed() {
  local boot_state

  boot_state=$(secure_boot_state)
  if ! module_signature_is_enforced; then
    case "$boot_state" in
      enabled)
        log "the module is signed; this Arch kernel does not require MOK enrollment"
        ;;
      unknown)
        log "could not determine the Secure Boot state; this kernel does not enforce trusted module signatures"
        ;;
    esac
    return 0
  fi
  if mok_certificate_is_enrolled && mok_list_is_trusted; then
    return 0
  fi

  if [[ "$boot_state" == enabled ]]; then
    log "Secure Boot is enabled, but the Vibeshine module-signing key is not trusted."
  else
    log "The running kernel enforces signatures, but the Vibeshine module-signing key is not trusted."
  fi
  if mok_manager_is_active; then
    log "Run '/usr/libexec/vibeshine/${PROGRAM_NAME} enroll-key', reboot, and complete the MOK requests."
  elif sbctl_is_configured; then
    log "This system uses direct sbctl/UEFI owner keys. Those keys trust EFI programs, not out-of-tree Linux modules."
    log "For trusted module loading, boot through shim once and enroll the Vibeshine MOK key."
  else
    log "Boot through shim once, then run '/usr/libexec/vibeshine/${PROGRAM_NAME} enroll-key'."
  fi
  error "the running kernel enforces trusted module signatures; managed displays remain unavailable until enrollment"
}

module_signing_trust_is_available() {
  module_signature_is_enforced || return 0
  if mok_certificate_is_enrolled && mok_list_is_trusted; then
    return 0
  fi
  return 1
}

module_signing_trust_is_usable() {
  module_signing_trust_is_available && return 0
  error "the running kernel requires a trusted module signature"
  return 1
}

request_signing_key_enrollment() {
  local enrollment_rc tty_fd

  if [[ -t 0 ]]; then
    enroll_signing_key
    return
  fi
  if { exec {tty_fd}<>"$TTY_DEVICE"; } 2>/dev/null; then
    if [[ -t "$tty_fd" ]]; then
      enroll_signing_key <&"$tty_fd"
      enrollment_rc=$?
      exec {tty_fd}>&-
      return "$enrollment_rc"
    fi
    exec {tty_fd}>&-
  fi
  error "the package frontend cannot display the one-time module-signing confirmation"
  error "retry the package installation from a terminal"
  return 1
}

finish_module_installation() {
  if module_signing_trust_is_available; then
    report_enrollment_needed
    report_loaded_module_freshness
    return $?
  fi

  if ((AUTO_ENROLL)); then
    log "this kernel requires one-time authorization of the Vibeshine module-signing key"
    if ! request_signing_key_enrollment; then
      error "could not start the module-signing authorization prompt"
      return 1
    fi
    log "authorization is queued; reboot and approve the pending MOK confirmations once"
    return "$ENROLLMENT_PENDING_EXIT"
  fi

  report_enrollment_needed
  return 1
}

enroll_signing_key() {
  local enrollment_requested=0

  require_root || return 1
  require_command mokutil || return 1
  [[ -d "$EFI_FIRMWARE_ROOT" && ! -L "$EFI_FIRMWARE_ROOT" ]] || {
    error "MOK enrollment requires a UEFI boot"
    return 1
  }
  mok_manager_is_active || {
    error "the current boot did not provide shim's MOK table"
    if sbctl_is_configured; then
      error "sbctl owner keys authorize EFI programs, not out-of-tree Linux modules"
    fi
    error "boot through shim once, then retry this command"
    return 1
  }
  prepare_signing_key || return 1
  if ! mok_certificate_is_enrolled && ! mok_certificate_is_enrollment_pending; then
    log "requesting one-time MOK enrollment for the DKMS signing key"
    log "Choose a temporary password when prompted. After reboot, use the firmware MOK manager"
    log "to enroll the key with that password. The normal desktop login password is not changed."
    mokutil --import "$MOK_CERTIFICATE" || return 1
    enrollment_requested=1
  elif ! mok_certificate_is_enrolled; then
    log "the DKMS module-signing key is already pending enrollment"
    enrollment_requested=1
  fi

  if ! mok_list_is_trusted; then
    if ! LC_ALL=C mokutil --help 2>&1 | grep -q -- '--trust-mok'; then
      error "this mokutil version cannot request MOK-list trust; update mokutil and retry"
      return 1
    fi
    log "requesting that Linux trust the enrolled MOK list for module verification"
    mokutil --trust-mok || return 1
    enrollment_requested=1
  fi

  if ((enrollment_requested)); then
    log "reboot and complete every pending request in the firmware MOK manager"
  else
    log "the DKMS module-signing key is enrolled and trusted by Linux"
  fi
}

signing_status() {
  local boot_state

  if [[ ! -f "$MOK_CERTIFICATE" || -L "$MOK_CERTIFICATE" ]]; then
    log "the DKMS module-signing key has not been generated"
    return 3
  fi
  boot_state=$(secure_boot_state)
  if ! module_signature_is_enforced; then
    if [[ "$boot_state" == enabled ]]; then
      log "the module is signed; this Arch kernel does not require MOK enrollment"
    else
      log "the module is signed and this kernel does not require MOK enrollment"
    fi
    return 0
  fi
  if mok_certificate_is_enrolled && mok_list_is_trusted; then
    log "the DKMS module-signing key is enrolled and trusted by Linux"
    return 0
  fi
  if mok_certificate_is_enrolled; then
    log "the DKMS module-signing key is enrolled, but Linux is not configured to trust the MOK list"
  fi
  log "the DKMS module-signing key is not trusted by the running kernel"
  if [[ "$boot_state" == enabled ]] && sbctl_is_configured && ! mok_manager_is_active; then
    log "sbctl owner keys do not authorize out-of-tree Linux modules; use shim/MOK for trusted loading"
  fi
  return 3
}

current_kernel_release() {
  if [[ -n "$KERNEL_RELEASE_OVERRIDE" ]]; then
    printf '%s\n' "$KERNEL_RELEASE_OVERRIDE"
  else
    uname -r
  fi
}

validate_kernel_release() {
  local kernel_release=$1

  case "$kernel_release" in
    "" | *[!A-Za-z0-9._+-]*)
      error "unsafe kernel release string: '${kernel_release}'"
      return 1
      ;;
  esac
}

kernel_version_is_supported() {
  local kernel_release=$1 kernel_major kernel_minor

  if [[ ! "$kernel_release" =~ ^([0-9]+)\.([0-9]+)(\.[0-9]+)?([-+].*)?$ ]]; then
    return 2
  fi
  kernel_major=$((10#${BASH_REMATCH[1]}))
  kernel_minor=$((10#${BASH_REMATCH[2]}))
  ((kernel_major > MINIMUM_KERNEL_MAJOR ||
    (kernel_major == MINIMUM_KERNEL_MAJOR && kernel_minor >= MINIMUM_KERNEL_MINOR)))
}

require_supported_kernel() {
  local kernel_release=$1 result

  if kernel_version_is_supported "$kernel_release"; then
    return 0
  else
    result=$?
  fi
  if ((result == 2)); then
    error "could not determine the Linux version from kernel release '${kernel_release}'"
  else
    error "managed virtual displays require Linux 6.16 or newer"
    error "the running kernel is ${kernel_release} and is unsupported"
  fi
  error "Vibeshine was installed, but its virtual-display driver was not"
  error "install and boot a supported Linux kernel, then retry:"
  error "  sudo /usr/libexec/vibeshine/${PROGRAM_NAME} install"
  return 1
}

kernel_build_files_are_available() {
  local kernel_release=$1
  local build_dir="$MODULES_ROOT/$kernel_release/build"

  [[ -d "$build_dir" && -f "$build_dir/Makefile" ]]
}

arch_kernel_headers_package() {
  local kernel_release=$1 kernel_package

  command -v pacman >/dev/null 2>&1 || return 1
  kernel_package=$(pacman -Qqo "$MODULES_ROOT/$kernel_release/vmlinuz" 2>/dev/null) || return 1
  case "$kernel_package" in
    "" | *$'\n'* | *[!A-Za-z0-9@._+:-]*) return 1 ;;
  esac
  printf '%s-headers\n' "$kernel_package"
}

report_missing_kernel_headers() {
  local kernel_release=$1 build_dir headers_package

  build_dir="$MODULES_ROOT/$kernel_release/build"
  error "kernel build files are unavailable at ${build_dir}"
  error "kernel headers for ${kernel_release} are missing"
  if headers_package=$(arch_kernel_headers_package "$kernel_release"); then
    error "install them with:"
    error "  sudo pacman -S --needed ${headers_package}"
  else
    error "install matching kernel headers that provide ${build_dir}"
  fi
  error "then retry:"
  error "  sudo /usr/libexec/vibeshine/${PROGRAM_NAME} install"
}

validate_source_tree() {
  local required_file

  if [[ ! -d "$SOURCE_DIR" || -L "$SOURCE_DIR" ]]; then
    error "module source directory is unavailable or unsafe: ${SOURCE_DIR}"
    return 1
  fi
  for required_file in Makefile build-module dkms.conf vkms_drv.c; do
    if [[ ! -f "$SOURCE_DIR/$required_file" || -L "$SOURCE_DIR/$required_file" ]]; then
      error "module source file is unavailable or unsafe: ${SOURCE_DIR}/${required_file}"
      return 1
    fi
  done
  if [[ ! -x "$SOURCE_DIR/build-module" ]]; then
    error "module build helper is not executable: ${SOURCE_DIR}/build-module"
    return 1
  fi
  case "$MODULE_SOURCE_ID" in
    "" | *[!0-9A-Fa-f]*)
      error "configured module source identity is invalid"
      return 1
      ;;
  esac
  if ((${#MODULE_SOURCE_ID} != 64)); then
    error "configured module source identity has an unexpected length"
    return 1
  fi
}

ensure_state_dir() {
  if [[ -L "$STATE_DIR" ]]; then
    error "refusing to use symbolic-link state directory: ${STATE_DIR}"
    return 1
  fi
  if ! mkdir -p -- "$STATE_DIR"; then
    error "could not create module state directory: ${STATE_DIR}"
    return 1
  fi
  if [[ ! -d "$STATE_DIR" || -L "$STATE_DIR" ]]; then
    error "module state directory is unavailable or unsafe: ${STATE_DIR}"
    return 1
  fi
}

state_marker_matches_source() {
  local marker=$1
  local recorded_id expected_id

  [[ -f "$marker" && ! -L "$marker" ]] || return 1
  IFS= read -r recorded_id <"$marker" || return 1
  expected_id=$(module_install_identity) || return 1
  [[ "$recorded_id" == "$expected_id" ]]
}

module_install_identity() {
  local certificate_hash

  [[ -f "$MOK_CERTIFICATE" && ! -L "$MOK_CERTIFICATE" ]] || return 1
  require_command sha256sum || return 1
  certificate_hash=$(sha256sum -- "$MOK_CERTIFICATE") || return 1
  certificate_hash=${certificate_hash%% *}
  [[ ${#certificate_hash} -eq 64 ]] || return 1
  printf '%s:%s\n' "$MODULE_SOURCE_ID" "$certificate_hash"
}

loaded_module_matches_installed() {
  local field installed_value loaded_path loaded_value

  [[ -d "$SYS_MODULE_ROOT/$MODULE_NAME" ]] || return 0
  require_command modinfo || return 2

  for field in version srcversion; do
    loaded_path="$SYS_MODULE_ROOT/$MODULE_NAME/$field"
    if [[ ! -f "$loaded_path" || -L "$loaded_path" ]]; then
      return 2
    fi
    IFS= read -r loaded_value <"$loaded_path" || return 2
    installed_value=$(modinfo -F "$field" "$MODULE_NAME" 2>/dev/null) || return 2
    if [[ -z "$loaded_value" || -z "$installed_value" ]]; then
      return 2
    fi
    if [[ "$loaded_value" != "$installed_value" ]]; then
      return 1
    fi
  done
}

report_loaded_module_freshness() {
  local result

  if loaded_module_matches_installed; then
    return 0
  else
    result=$?
  fi
  if ((result == 1)); then
    error "the loaded ${MODULE_NAME} differs from the installed module; reboot or safely reload it before using managed displays"
  else
    error "could not verify the loaded ${MODULE_NAME} against the installed module; reboot or safely reload it before using managed displays"
  fi
  return "$RELOAD_REQUIRED_EXIT"
}

write_state_marker() {
  local marker=$1
  local install_identity
  shift

  ensure_state_dir || return 1
  install_identity=$(module_install_identity) || return 1
  if [[ -L "$marker" ]]; then
    error "refusing symbolic-link module state marker: ${marker}"
    return 1
  fi
  if ! printf '%s\n' "$install_identity" "$@" >"$marker"; then
    error "could not record module state at ${marker}"
    return 1
  fi
}

dkms_status() {
  dkms status -m "$DKMS_NAME" -v "$MODULE_VERSION" 2>/dev/null || true
}

dkms_all_status() {
  dkms status -m "$DKMS_NAME" 2>/dev/null || true
}

dkms_available() {
  command -v dkms >/dev/null 2>&1
}

effective_dkms_signing_configuration() (
  local kernelver=$1 config_file
  local mok_signing_key=/var/lib/dkms/mok.key
  local mok_certificate=/var/lib/dkms/mok.pub
  local try_sign_modules=not_in_chroot

  # DKMS treats these root-owned files as shell configuration. Read them in a
  # subshell so they cannot alter the installer's state.
  set +u
  if [[ -f "$DKMS_CONFIG_ROOT/framework.conf" ]]; then
    # shellcheck source=/dev/null
    source "$DKMS_CONFIG_ROOT/framework.conf" || return 1
  fi
  for config_file in "$DKMS_CONFIG_ROOT"/framework.conf.d/*.conf; do
    [[ -f "$config_file" ]] || continue
    # shellcheck source=/dev/null
    source "$config_file" || return 1
  done
  printf '%s\n%s\n%s\n' "$mok_signing_key" "$mok_certificate" "$try_sign_modules"
)

dkms_uses_expected_signing_key() {
  local kernel_release=$1 signing_output
  local -a signing_configuration

  signing_output=$(effective_dkms_signing_configuration "$kernel_release") || return 1
  mapfile -t signing_configuration <<<"$signing_output"
  if ((${#signing_configuration[@]} != 3)); then
    error "could not determine DKMS's module-signing configuration"
    return 1
  fi
  if [[ "${signing_configuration[2]}" == false ]]; then
    error "DKMS module signing is disabled by the system configuration"
    return 1
  fi
  if [[ "${signing_configuration[0]}" != "$MOK_SIGNING_KEY" ||
        "${signing_configuration[1]}" != "$MOK_CERTIFICATE" ]]; then
    error "DKMS is configured with a different module-signing key"
    return 1
  fi
}

dkms_is_registered() {
  local status_output line

  status_output=$(dkms_status)
  while IFS= read -r line; do
    case "$line" in
      "${DKMS_NAME}/${MODULE_VERSION},"* | "${DKMS_NAME}/${MODULE_VERSION}:"*)
        return 0
        ;;
    esac
  done <<<"$status_output"
  return 1
}

dkms_is_installed_for_kernel() {
  local kernel_release=$1
  local status_output line

  status_output=$(dkms_status)
  while IFS= read -r line; do
    if [[ "$line" == "${DKMS_NAME}/${MODULE_VERSION}, ${kernel_release}, "*": installed"* ]]; then
      return 0
    fi
  done <<<"$status_output"
  return 1
}

install_with_dkms() {
  local kernel_release=$1
  local marker
  local -a refresh_args=()

  marker=$(dkms_marker "$kernel_release")

  if dkms_is_installed_for_kernel "$kernel_release" &&
     state_marker_matches_source "$marker"; then
    if installed_module_matches_signing_certificate "$kernel_release"; then
      log "DKMS module ${DKMS_NAME}/${MODULE_VERSION} is already installed for ${kernel_release}"
      return 0
    fi
    log "refreshing DKMS module with an unexpected signature for ${kernel_release}"
  fi

  if dkms_is_installed_for_kernel "$kernel_release"; then
    log "refreshing stale DKMS module for ${kernel_release}"
    refresh_args=(--force)
  fi

  if ! dkms_is_registered; then
    log "registering ${DKMS_NAME}/${MODULE_VERSION} with DKMS"
    if ! dkms add -m "$DKMS_NAME" -v "$MODULE_VERSION"; then
      error "DKMS registration failed"
      return 1
    fi
  fi

  log "building ${DKMS_NAME}/${MODULE_VERSION} with DKMS for ${kernel_release}"
  if ! dkms build -m "$DKMS_NAME" -v "$MODULE_VERSION" -k "$kernel_release" "${refresh_args[@]}"; then
    error "DKMS build failed for ${kernel_release}"
    return 1
  fi
  if ! dkms install -m "$DKMS_NAME" -v "$MODULE_VERSION" -k "$kernel_release" "${refresh_args[@]}"; then
    error "DKMS install failed for ${kernel_release}"
    return 1
  fi

  if ! dkms_is_installed_for_kernel "$kernel_release"; then
    error "DKMS did not report an installed module after a successful install"
    return 1
  fi
  if ! installed_module_matches_signing_certificate "$kernel_release"; then
    error "DKMS installed ${MODULE_NAME} with an unexpected or missing signature"
    return 1
  fi
  write_state_marker "$marker" dkms "$kernel_release" || return 1
  if ! remove_direct_installations; then
    error "current-version direct-build cleanup was incomplete"
  fi
  log "installed HDR DRM module with DKMS for ${kernel_release}"
}

direct_destination() {
  local kernel_release=$1

  printf '%s/%s/updates/vibeshine/%s.ko\n' "$MODULES_ROOT" "$kernel_release" "$MODULE_NAME"
}

direct_marker() {
  local kernel_release=$1

  printf '%s/direct-%s-%s\n' "$STATE_DIR" "$MODULE_VERSION" "$kernel_release"
}

dkms_marker() {
  local kernel_release=$1

  printf '%s/dkms-%s-%s\n' "$STATE_DIR" "$MODULE_VERSION" "$kernel_release"
}

direct_is_installed_for_kernel() {
  local kernel_release=$1
  local destination marker

  destination=$(direct_destination "$kernel_release")
  marker=$(direct_marker "$kernel_release")
  [[ -f "$destination" && ! -L "$destination" ]] && state_marker_matches_source "$marker"
}

install_direct() (
  local kernel_release=$1
  local build_dir destination marker build_workdir

  build_dir="$MODULES_ROOT/$kernel_release/build"
  destination=$(direct_destination "$kernel_release")
  marker=$(direct_marker "$kernel_release")

  if direct_is_installed_for_kernel "$kernel_release"; then
    if verify_module_signature_matches_certificate "$destination"; then
      log "direct-built module is already installed for ${kernel_release}"
      return 0
    fi
    log "refreshing directly built module with an unexpected signature for ${kernel_release}"
  fi
  if ! kernel_build_files_are_available "$kernel_release"; then
    report_missing_kernel_headers "$kernel_release"
    return 1
  fi
  require_command make || return 1
  require_command install || return 1
  require_command depmod || return 1
  require_command cp || return 1
  require_command mktemp || return 1
  require_command rm || return 1

  if [[ ! -d "$BUILD_TMP_ROOT" || -L "$BUILD_TMP_ROOT" ]]; then
    error "temporary build root is unavailable or unsafe: ${BUILD_TMP_ROOT}"
    return 1
  fi
  if ! build_workdir=$(mktemp -d "$BUILD_TMP_ROOT/vibeshine-drm-build.XXXXXX"); then
    error "could not create a temporary module build directory"
    return 1
  fi
  trap 'cleanup_build_directory "$build_workdir"' EXIT
  trap 'cleanup_build_directory "$build_workdir"; exit 1' HUP INT TERM
  if ! cp -a -- "$SOURCE_DIR/." "$build_workdir/"; then
    error "could not copy module sources to ${build_workdir}"
    cleanup_build_directory "$build_workdir"
    return 1
  fi

  log "building ${MODULE_NAME} directly for ${kernel_release}"
  if ! run_build_helper "$build_workdir" "$kernel_release"; then
    error "direct kernel-module build failed for ${kernel_release}"
    cleanup_build_directory "$build_workdir"
    return 1
  fi
  if [[ ! -f "$build_workdir/${MODULE_NAME}.ko" || -L "$build_workdir/${MODULE_NAME}.ko" ]]; then
    error "kernel build completed without ${build_workdir}/${MODULE_NAME}.ko"
    cleanup_build_directory "$build_workdir"
    return 1
  fi
  if ! sign_module_file "$kernel_release" "$build_workdir/${MODULE_NAME}.ko"; then
    error "could not sign the directly built kernel module"
    cleanup_build_directory "$build_workdir"
    return 1
  fi

  ensure_state_dir || return 1
  if ! install -D -m 0644 -- "$build_workdir/${MODULE_NAME}.ko" "$destination"; then
    error "could not install module at ${destination}"
    cleanup_build_directory "$build_workdir"
    return 1
  fi
  if ! depmod -a "$kernel_release"; then
    error "depmod failed for ${kernel_release}"
    rm -f -- "$destination"
    cleanup_build_directory "$build_workdir"
    return 1
  fi
  if ! write_state_marker "$marker" direct "$destination"; then
    rm -f -- "$destination"
    depmod -a "$kernel_release" || true
    cleanup_build_directory "$build_workdir"
    return 1
  fi
  cleanup_build_directory "$build_workdir" || return 1
  log "installed directly built HDR DRM module for ${kernel_release}"
)

run_build_helper() {
  local build_workdir=$1
  local kernel_release=$2

  "$build_workdir/build-module" "$kernel_release" "$build_workdir"
}

cleanup_build_directory() {
  local build_workdir=$1

  case "$build_workdir" in
    "$BUILD_TMP_ROOT"/vibeshine-drm-build.*)
      ;;
    *)
      error "refusing cleanup of unexpected temporary path: ${build_workdir}"
      return 1
      ;;
  esac
  if [[ -L "$build_workdir" ]]; then
    error "refusing cleanup of symbolic-link build directory: ${build_workdir}"
    return 1
  fi
  rm -rf -- "$build_workdir"
}

install_module() {
  local kernel_release cleanup_rc=0

  kernel_release=$(current_kernel_release) || return 1
  validate_kernel_release "$kernel_release" || return 1
  require_supported_kernel "$kernel_release" || return 1
  if ! kernel_build_files_are_available "$kernel_release"; then
    report_missing_kernel_headers "$kernel_release"
    return 1
  fi
  validate_source_tree || return 1
  prepare_signing_key || return 1
  cleanup_obsolete_installations || cleanup_rc=1

  if dkms_available && dkms_uses_expected_signing_key "$kernel_release"; then
    if install_with_dkms "$kernel_release"; then
      ((cleanup_rc == 0)) || log "obsolete module cleanup was incomplete; current DKMS module is ready"
      finish_module_installation
      return $?
    fi
    if dkms_is_installed_for_kernel "$kernel_release"; then
      error "preserving the existing current-kernel DKMS installation after the failed refresh"
      return 1
    fi
    log "DKMS installation failed; attempting a current-kernel direct build"
  elif dkms_available; then
    if dkms_is_installed_for_kernel "$kernel_release"; then
      error "preserving the current DKMS installation signed with the system-configured key"
      return 1
    fi
    log "DKMS cannot guarantee the Vibeshine signing key; using a verified direct build"
  else
    log "DKMS is unavailable; attempting a current-kernel direct build"
  fi
  install_direct "$kernel_release" || return 1
  ((cleanup_rc == 0)) || log "obsolete module cleanup was incomplete; current direct-built module is ready"
  finish_module_installation
}

unload_module() {
  if [[ ! -d "$SYS_MODULE_ROOT/$MODULE_NAME" ]]; then
    return 0
  fi
  require_command modprobe || return 1
  log "unloading ${MODULE_NAME}"
  if ! modprobe -r "$MODULE_NAME"; then
    error "could not unload ${MODULE_NAME}; stop the virtual-display service first"
    return 1
  fi
}

remove_direct_marker() {
  local marker=$1
  local line destination="" relative kernel_release expected_destination

  if [[ ! -f "$marker" || -L "$marker" ]]; then
    error "refusing unsafe direct-install marker: ${marker}"
    return 1
  fi
  while IFS= read -r line || [[ -n "$line" ]]; do
    destination=$line
  done <"$marker"

  case "$destination" in
    "$MODULES_ROOT"/*"/updates/vibeshine/${MODULE_NAME}.ko")
      ;;
    *)
      error "refusing unsafe direct-install destination in ${marker}: ${destination}"
      return 1
      ;;
  esac
  relative=${destination#"$MODULES_ROOT"/}
  kernel_release=${relative%%/*}
  validate_kernel_release "$kernel_release" || return 1
  expected_destination=$(direct_destination "$kernel_release")
  if [[ "$destination" != "$expected_destination" ]]; then
    error "refusing unexpected direct-install destination: ${destination}"
    return 1
  fi

  if [[ -e "$destination" || -L "$destination" ]]; then
    if ! rm -f -- "$destination"; then
      error "could not remove direct-built module: ${destination}"
      return 1
    fi
  fi
  if ! rm -f -- "$marker"; then
    error "could not remove direct-install marker: ${marker}"
    return 1
  fi
  if command -v depmod >/dev/null 2>&1; then
    depmod -a "$kernel_release" || return 1
  fi
  log "removed directly built module for ${kernel_release}"
}

remove_direct_installations() {
  local marker rc=0

  [[ -d "$STATE_DIR" ]] || return 0
  if [[ -L "$STATE_DIR" ]]; then
    error "refusing to traverse symbolic-link state directory: ${STATE_DIR}"
    return 1
  fi

  for marker in "$STATE_DIR/direct-${MODULE_VERSION}-"*; do
    [[ -e "$marker" || -L "$marker" ]] || continue
    remove_direct_marker "$marker" || rc=1
  done
  return "$rc"
}

remove_obsolete_direct_installations() {
  local marker marker_name rc=0

  [[ -d "$STATE_DIR" ]] || return 0
  if [[ -L "$STATE_DIR" ]]; then
    error "refusing to traverse symbolic-link state directory: ${STATE_DIR}"
    return 1
  fi
  for marker in "$STATE_DIR"/direct-*; do
    [[ -e "$marker" || -L "$marker" ]] || continue
    marker_name=${marker##*/}
    case "$marker_name" in
      direct-"$MODULE_VERSION"-*) continue ;;
    esac
    remove_direct_marker "$marker" || rc=1
  done
  return "$rc"
}

remove_dkms_state_markers_for_version() {
  local version=$1
  local marker rc=0

  [[ -d "$STATE_DIR" && ! -L "$STATE_DIR" ]] || return 0
  for marker in "$STATE_DIR"/dkms-"$version"-*; do
    [[ -e "$marker" || -L "$marker" ]] || continue
    if [[ ! -f "$marker" || -L "$marker" ]] || ! rm -f -- "$marker"; then
      error "could not remove obsolete DKMS state marker: ${marker}"
      rc=1
    fi
  done
  return "$rc"
}

remove_obsolete_dkms_registrations() {
  local status_output line version seen=" " rc=0

  dkms_available || return 0
  status_output=$(dkms_all_status)
  while IFS= read -r line; do
    [[ "$line" == "$DKMS_NAME/"* ]] || continue
    version=${line#"$DKMS_NAME"/}
    version=${version%%,*}
    version=${version%%:*}
    case "$version" in
      "" | *[!A-Za-z0-9._+-]*)
        error "refusing unsafe DKMS version from status: ${version}"
        rc=1
        continue
        ;;
    esac
    [[ "$version" == "$MODULE_VERSION" ]] && continue
    [[ "$seen" == *" ${version} "* ]] && continue
    seen+="${version} "
    log "removing obsolete ${DKMS_NAME}/${version} registration"
    if dkms remove -m "$DKMS_NAME" -v "$version" --all; then
      remove_dkms_state_markers_for_version "$version" || rc=1
    else
      error "could not remove obsolete DKMS registration ${DKMS_NAME}/${version}"
      rc=1
    fi
  done <<<"$status_output"
  return "$rc"
}

remove_obsolete_source_trees() {
  local source_parent source_name candidate candidate_name candidate_version rc=0

  source_parent=${SOURCE_DIR%/*}
  source_name=${SOURCE_DIR##*/}
  if [[ "$source_name" != "${DKMS_NAME}-${MODULE_VERSION}" ||
        ! -d "$source_parent" || -L "$source_parent" ]]; then
    return 0
  fi

  for candidate in "$source_parent"/"$DKMS_NAME"-*; do
    [[ -e "$candidate" || -L "$candidate" ]] || continue
    [[ "$candidate" == "$SOURCE_DIR" ]] && continue
    candidate_name=${candidate##*/}
    candidate_version=${candidate_name#"$DKMS_NAME"-}
    case "$candidate_version" in
      "" | [!0-9]* | *[!A-Za-z0-9._+-]*)
        continue
        ;;
    esac
    if [[ ! -d "$candidate" || -L "$candidate" ]]; then
      error "refusing unsafe obsolete source tree: ${candidate}"
      rc=1
      continue
    fi
    log "removing obsolete module source tree ${candidate}"
    rm -rf -- "$candidate" || rc=1
  done
  return "$rc"
}

cleanup_obsolete_installations() {
  local rc=0

  if ! remove_obsolete_dkms_registrations; then
    rc=1
  else
    remove_obsolete_source_trees || rc=1
  fi
  remove_obsolete_direct_installations || rc=1
  return "$rc"
}

remove_module() {
  local marker rc=0

  unload_module || rc=1
  if dkms_available && dkms_is_registered; then
    log "removing ${DKMS_NAME}/${MODULE_VERSION} from DKMS"
    dkms remove -m "$DKMS_NAME" -v "$MODULE_VERSION" --all || rc=1
  fi
  if [[ -d "$STATE_DIR" && ! -L "$STATE_DIR" ]]; then
    for marker in "$STATE_DIR"/dkms-"$MODULE_VERSION"-*; do
      [[ -e "$marker" || -L "$marker" ]] || continue
      if [[ ! -f "$marker" || -L "$marker" ]] || ! rm -f -- "$marker"; then
        error "could not remove DKMS state marker: ${marker}"
        rc=1
      fi
    done
  fi
  remove_obsolete_dkms_registrations || rc=1
  remove_direct_installations || rc=1
  remove_obsolete_direct_installations || rc=1
  remove_obsolete_source_trees || rc=1
  return "$rc"
}

module_status() {
  local kernel_release installed=0

  kernel_release=$(current_kernel_release) || return 1
  validate_kernel_release "$kernel_release" || return 1
  require_supported_kernel "$kernel_release" || return 1
  if [[ -d "$SYS_MODULE_ROOT/$MODULE_NAME" ]]; then
    log "${MODULE_NAME} is loaded"
  fi
  if dkms_available && dkms_is_installed_for_kernel "$kernel_release"; then
    log "DKMS module is installed for ${kernel_release}"
    installed=1
  fi
  if direct_is_installed_for_kernel "$kernel_release"; then
    log "direct-built module is installed for ${kernel_release}"
    installed=1
  fi
  if ((installed == 0)); then
    if ! kernel_build_files_are_available "$kernel_release"; then
      report_missing_kernel_headers "$kernel_release"
    else
      log "the current HDR DRM module is not installed for ${kernel_release}"
    fi
    return 3
  fi
  if ! installed_module_matches_signing_certificate "$kernel_release"; then
    error "the module selected for ${kernel_release} does not have the expected Vibeshine signature"
    return 3
  fi
  report_enrollment_needed
  module_signing_trust_is_usable || return 3
  report_loaded_module_freshness
}

usage() {
  printf 'Usage: %s {install|install-package|remove|status|enroll-key|signing-status}\n' "$PROGRAM_NAME" >&2
}

main() {
  local action=${1:-}

  # Privileged production paths are fixed at configure time and cannot be
  # redirected through the environment. Tests source the functions directly.
  configure_install_paths \
    "/usr/src/vibeshine-drm-2.0.0" \
    /var/lib/vibeshine-drm \
    /lib/modules \
    /sys/module \
    /var/tmp \
    /var/lib/dkms/mok.key \
    /var/lib/dkms/mok.pub
  KERNEL_RELEASE_OVERRIDE=""

  case "$action" in
    install)
      require_root || return 1
      require_command uname || return 1
      require_command rm || return 1
      install_module
      ;;
    install-package)
      require_root || return 1
      require_command uname || return 1
      require_command rm || return 1
      AUTO_ENROLL=1
      install_module
      ;;
    remove)
      require_root || return 1
      require_command rm || return 1
      remove_module
      ;;
    status)
      require_command uname || return 1
      module_status
      ;;
    enroll-key)
      enroll_signing_key
      ;;
    signing-status)
      signing_status
      ;;
    *)
      usage
      return 2
      ;;
  esac
}

if [[ ${BASH_SOURCE[0]} == "$0" ]]; then
  main "$@"
fi
