Files
rubix-deploy/bootstrap-vps-ssh.sh
Ognjen Djukic da7bf7107a VPS bootstrap: unlock the deploy user and give it passwordless sudo
useradd leaves the password field as '!'. After hardening sets UsePAM no,
sshd treats that account as locked and refuses even key logins, so the
bootstrap stopped with 'Key login failed after hardening'. Set the field to
'*' (no password, not locked).

The key-only deploy user has no password, so sudo for install-rubix.sh and
up.sh could never succeed. Add /etc/sudoers.d/90-rubix-<user> with NOPASSWD,
checked with visudo, and install sudo if the image lacks it.
2026-10-26 13:59:50 +01:00

528 lines
15 KiB
Bash
Executable File

#!/bin/bash
# First-time VPS bootstrap from your workstation:
# password login → deploy user + SSH key → test key → disable password auth → apt upgrade
# → optional ~/.ssh/config alias on this machine
#
# Run locally (not on the VPS):
# wget -O bootstrap-vps-ssh.sh \
# https://gitea.dialer.work/swissdatabase/rubix-deploy/raw/branch/main/bootstrap-vps-ssh.sh
# chmod +x bootstrap-vps-ssh.sh
# ./bootstrap-vps-ssh.sh
#
# Needs: ssh, optional sshpass (apt install sshpass)
set -euo pipefail
SSH_CONFIG="${HOME}/.ssh/config"
SSH_DIR="${HOME}/.ssh"
KNOWN_HOSTS_FILE="${HOME}/.ssh/known_hosts"
MARKER_BEGIN="# --- RUBIX-VPS-BEGIN"
MARKER_END="# --- RUBIX-VPS-END"
prompt() {
local var_name="$1"
local text="$2"
local default="${3:-}"
local value=""
if [[ -n "${default}" ]]; then
read -r -p "${text} [${default}]: " value
value="${value:-${default}}"
else
read -r -p "${text}: " value
fi
printf -v "${var_name}" '%s' "${value}"
}
prompt_secret() {
local var_name="$1"
local text="$2"
local value=""
read -r -s -p "${text}: " value
echo ""
printf -v "${var_name}" '%s' "${value}"
}
prompt_yes_no() {
local var_name="$1"
local text="$2"
local default="${3:-y}"
local hint="Y/n"
[[ "${default}" == "y" ]] && hint="Y/n" || hint="y/N"
local answer=""
read -r -p "${text} [${hint}]: " answer
answer="${answer:-${default}}"
case "${answer}" in
y|Y|yes|YES) printf -v "${var_name}" '%s' "yes" ;;
*) printf -v "${var_name}" '%s' "no" ;;
esac
}
have_sshpass() {
command -v sshpass >/dev/null 2>&1
}
# Install sshpass on the machine running this script (your PC), not on the VPS.
ensure_local_sshpass() {
if have_sshpass; then
return 0
fi
echo "[rubix-vps] sshpass not found — installing locally (one sudo prompt) ..."
local run_as=(bash -c)
if [[ "$(id -u)" -ne 0 ]]; then
if ! command -v sudo >/dev/null 2>&1; then
echo "[rubix-vps] WARN: need sudo to install sshpass (run: sudo apt install sshpass)." >&2
return 1
fi
run_as=(sudo bash -c)
fi
if command -v apt-get >/dev/null 2>&1; then
"${run_as[@]}" 'apt-get update -qq && apt-get install -y sshpass'
elif command -v apt >/dev/null 2>&1; then
"${run_as[@]}" 'apt update -qq && apt install -y sshpass'
elif command -v dnf >/dev/null 2>&1; then
"${run_as[@]}" 'dnf install -y sshpass'
elif command -v yum >/dev/null 2>&1; then
"${run_as[@]}" 'yum install -y sshpass'
elif command -v pacman >/dev/null 2>&1; then
"${run_as[@]}" 'pacman -Sy --noconfirm sshpass'
elif command -v zypper >/dev/null 2>&1; then
"${run_as[@]}" 'zypper install -y sshpass'
else
echo "[rubix-vps] WARN: no supported package manager for auto-install of sshpass." >&2
return 1
fi
if have_sshpass; then
echo "[rubix-vps] sshpass installed."
return 0
fi
echo "[rubix-vps] WARN: sshpass install failed." >&2
return 1
}
# Stop ssh-agent from offering keys (avoids "Too many authentication failures" on password login).
password_ssh_common_opts() {
printf '%s\n' \
StrictHostKeyChecking=accept-new \
IdentitiesOnly=yes \
IdentityAgent=none \
PubkeyAuthentication=no \
PreferredAuthentications=password,keyboard-interactive \
NumberOfPasswordPrompts=3
}
ssh_password() {
local target="$1"
shift
local -a base=(ssh -p "${VPS_PORT}")
local opt
while IFS= read -r opt; do
base+=(-o "${opt}")
done < <(password_ssh_common_opts)
if [[ -n "${ROOT_PASSWORD:-}" ]] && have_sshpass; then
sshpass -p "${ROOT_PASSWORD}" "${base[@]}" "${target}" "$@"
else
"${base[@]}" "${target}" "$@"
fi
}
scp_password() {
local src="$1"
local dest="$2"
local -a base=(scp -P "${VPS_PORT}")
local opt
while IFS= read -r opt; do
base+=(-o "${opt}")
done < <(password_ssh_common_opts)
if [[ -n "${ROOT_PASSWORD:-}" ]] && have_sshpass; then
sshpass -p "${ROOT_PASSWORD}" "${base[@]}" "${src}" "${dest}"
else
"${base[@]}" "${src}" "${dest}"
fi
}
ssh_key() {
local user="$1"
shift
ssh -o BatchMode=yes \
-o StrictHostKeyChecking=accept-new \
-o PasswordAuthentication=no \
-o IdentitiesOnly=yes \
-i "${PRIVATE_KEY_FILE}" \
-p "${VPS_PORT}" \
"${user}@${VPS_HOST}" \
"$@"
}
test_key_login() {
local user="$1"
ssh_key "${user}" "echo ok" >/dev/null 2>&1
}
cleanup_known_host_entries() {
local host="$1"
local port="$2"
[[ -f "${KNOWN_HOSTS_FILE}" ]] || return 0
# Remove stale host keys so reinstalled/reprovisioned VPS can be reached without manual known_hosts edits.
ssh-keygen -f "${KNOWN_HOSTS_FILE}" -R "${host}" >/dev/null 2>&1 || true
ssh-keygen -f "${KNOWN_HOSTS_FILE}" -R "[${host}]:${port}" >/dev/null 2>&1 || true
}
remote_env() {
printf 'DEPLOY_USER=%q KEEP_ROOT=%q INSTALL_ROOT_KEY=%q' \
"${DEPLOY_USER}" "${KEEP_ROOT}" "${INSTALL_ROOT_KEY}"
}
update_local_ssh_config() {
local alias="$1"
local host="$2"
local port="$3"
local user="$4"
local key_file="$5"
mkdir -p "${SSH_DIR}"
chmod 700 "${SSH_DIR}"
touch "${SSH_CONFIG}"
chmod 600 "${SSH_CONFIG}"
local block
block="$(cat <<EOF
${MARKER_BEGIN} ${alias} ---
Host ${alias}
HostName ${host}
User ${user}
Port ${port}
IdentityFile ${key_file}
IdentitiesOnly yes
${MARKER_END} ${alias} ---
EOF
)"
local tmp
tmp="$(mktemp)"
if [[ -f "${SSH_CONFIG}" ]]; then
awk -v begin="${MARKER_BEGIN} ${alias} ---" -v end="${MARKER_END} ${alias} ---" '
$0 == begin { skip=1; next }
$0 == end { skip=0; next }
!skip { print }
' "${SSH_CONFIG}" > "${tmp}" || true
fi
{
cat "${tmp}"
echo ""
printf '%s\n' "${block}"
} > "${SSH_CONFIG}.new"
mv "${SSH_CONFIG}.new" "${SSH_CONFIG}"
rm -f "${tmp}"
echo "[rubix-vps] wrote Host ${alias} → ${SSH_CONFIG}"
}
print_key_summary() {
local alias="$1"
echo ""
echo "[rubix-vps] SSH key for Host alias \"${alias}\":"
echo " Private key : ${PRIVATE_KEY_FILE}"
echo " Public key : ${PUBLIC_KEY_FILE}"
echo " ssh config : Host ${alias} → IdentityFile ${PRIVATE_KEY_FILE}"
echo ""
echo " authorized_keys line:"
sed 's/^/ /' "${PUBLIC_KEY_FILE}"
echo ""
}
pick_ssh_key() {
local alias="$1"
local choice=""
local key_path="${SSH_DIR}/${alias}.ed25519"
echo ""
echo "SSH key for ~/.ssh/config Host \"${alias}\":"
echo " Naming: ${key_path} (+ ${key_path}.pub)"
echo ""
echo " 1) Use existing public key"
echo " 2) Generate new ed25519 key pair at ${key_path}"
read -r -p "Choice [2]: " choice
choice="${choice:-2}"
case "${choice}" in
1)
local default_pub="${SSH_DIR}/id_ed25519.pub"
prompt PUBLIC_KEY_FILE "Path to public key (.pub)" "${default_pub}"
if [[ ! -f "${PUBLIC_KEY_FILE}" ]]; then
echo "Missing: ${PUBLIC_KEY_FILE}" >&2
exit 1
fi
local priv="${PUBLIC_KEY_FILE%.pub}"
if [[ -f "${priv}" ]]; then
PRIVATE_KEY_FILE="${priv}"
else
prompt PRIVATE_KEY_FILE "Path to matching private key" "${SSH_DIR}/id_ed25519"
fi
;;
*)
if [[ -f "${key_path}" ]]; then
prompt_yes_no OVERWRITE "Key ${key_path} exists. Overwrite?" "n"
if [[ "${OVERWRITE}" != "yes" ]]; then
echo "Aborted." >&2
exit 1
fi
rm -f "${key_path}" "${key_path}.pub"
fi
local comment="rubix-vps-${alias}-$(date +%Y%m%d)"
echo ""
echo "[rubix-vps] Generating ${key_path} (comment: ${comment}) ..."
ssh-keygen -t ed25519 -f "${key_path}" -C "${comment}" -N ""
PRIVATE_KEY_FILE="${key_path}"
PUBLIC_KEY_FILE="${key_path}.pub"
;;
esac
if [[ ! -f "${PRIVATE_KEY_FILE}" ]]; then
echo "Private key not found: ${PRIVATE_KEY_FILE}" >&2
exit 1
fi
chmod 600 "${PRIVATE_KEY_FILE}" 2>/dev/null || true
print_key_summary "${alias}"
}
remote_install_users_and_keys() {
ssh_password "${INITIAL_USER}@${VPS_HOST}" \
"$(remote_env)" bash -s <<'REMOTE'
set -euo pipefail
if [[ "$(id -u)" -ne 0 ]]; then
echo "Remote: must run as root." >&2
exit 1
fi
PUBKEY="$(tr -d '\r\n' < /tmp/rubix-bootstrap.pub)"
if ! id "${DEPLOY_USER}" >/dev/null 2>&1; then
useradd -m -s /bin/bash "${DEPLOY_USER}"
echo "Created user ${DEPLOY_USER}"
else
echo "User ${DEPLOY_USER} already exists"
fi
if getent group sudo >/dev/null 2>&1; then
usermod -aG sudo "${DEPLOY_USER}"
elif getent group wheel >/dev/null 2>&1; then
usermod -aG wheel "${DEPLOY_USER}"
fi
# useradd leaves the password field as "!" (locked). With UsePAM no (set during
# hardening) sshd then rejects even key logins: "account is locked".
# "*" = no password but not locked.
if [[ "$(getent shadow "${DEPLOY_USER}" | cut -d: -f2)" =~ ^!+\*?$ ]]; then
usermod -p '*' "${DEPLOY_USER}"
fi
# Key-only user has no password to type, so sudo must not ask for one.
if [[ "${DEPLOY_USER}" != "root" ]]; then
if ! command -v sudo >/dev/null 2>&1 && command -v apt-get >/dev/null 2>&1; then
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq sudo >/dev/null
fi
SUDOERS="/etc/sudoers.d/90-rubix-${DEPLOY_USER}"
echo "${DEPLOY_USER} ALL=(ALL) NOPASSWD:ALL" > "${SUDOERS}.tmp"
chmod 440 "${SUDOERS}.tmp"
if visudo -cf "${SUDOERS}.tmp" >/dev/null; then
mv "${SUDOERS}.tmp" "${SUDOERS}"
else
rm -f "${SUDOERS}.tmp"
echo "WARN: sudoers check failed, ${DEPLOY_USER} has no passwordless sudo" >&2
fi
fi
install_key_for_user() {
local u="$1"
local home_dir
home_dir="$(getent passwd "${u}" | cut -d: -f6)"
local ssh_dir="${home_dir}/.ssh"
mkdir -p "${ssh_dir}"
chmod 700 "${ssh_dir}"
touch "${ssh_dir}/authorized_keys"
if ! grep -qxF "${PUBKEY}" "${ssh_dir}/authorized_keys" 2>/dev/null; then
echo "${PUBKEY}" >> "${ssh_dir}/authorized_keys"
fi
chown -R "${u}:${u}" "${ssh_dir}"
chmod 600 "${ssh_dir}/authorized_keys"
}
install_key_for_user "${DEPLOY_USER}"
if [[ "${INSTALL_ROOT_KEY}" == "yes" ]]; then
install_key_for_user root
fi
echo "Keys installed for ${DEPLOY_USER} (and root if requested)."
REMOTE
}
remote_harden_and_upgrade() {
ssh_password "${INITIAL_USER}@${VPS_HOST}" \
"$(remote_env)" bash -s <<'REMOTE'
set -euo pipefail
SSHD="/etc/ssh/sshd_config"
cp -a "${SSHD}" "${SSHD}.rubix-backup-$(date +%Y%m%d%H%M%S)"
set_sshd_option() {
local key="$1"
local value="$2"
if grep -qE "^[#[:space:]]*${key}[[:space:]]" "${SSHD}"; then
sed -i "s/^[#[:space:]]*${key}[[:space:]].*/${key} ${value}/" "${SSHD}"
else
echo "${key} ${value}" >> "${SSHD}"
fi
}
set_sshd_option PasswordAuthentication no
set_sshd_option KbdInteractiveAuthentication no
set_sshd_option ChallengeResponseAuthentication no
set_sshd_option PubkeyAuthentication yes
set_sshd_option UsePAM no
if [[ "${KEEP_ROOT}" == "yes" ]]; then
set_sshd_option PermitRootLogin prohibit-password
else
set_sshd_option PermitRootLogin no
fi
if sshd -t 2>/dev/null || /usr/sbin/sshd -t 2>/dev/null; then
:
else
latest="$(ls -t ${SSHD}.rubix-backup-* 2>/dev/null | head -1)"
[[ -n "${latest}" ]] && cp -a "${latest}" "${SSHD}"
echo "sshd config test failed — restored backup" >&2
exit 1
fi
if systemctl list-units --type=service --all 2>/dev/null | grep -q 'sshd\.service'; then
systemctl reload sshd
elif systemctl list-units --type=service --all 2>/dev/null | grep -q 'ssh\.service'; then
systemctl reload ssh
else
service ssh reload 2>/dev/null || service sshd reload
fi
if command -v apt-get >/dev/null 2>&1; then
export DEBIAN_FRONTEND=noninteractive
apt-get update -y
apt-get upgrade -y
apt-get install -y locales
if [[ -f /etc/locale.gen ]]; then
sed -i '/en_US.UTF-8 UTF-8/s/^# *//' /etc/locale.gen
grep -q '^en_US.UTF-8 UTF-8' /etc/locale.gen || echo 'en_US.UTF-8 UTF-8' >> /etc/locale.gen
locale-gen en_US.UTF-8 2>/dev/null || locale-gen
fi
update-locale LANG=en_US.UTF-8 LC_CTYPE=en_US.UTF-8 LC_MESSAGES=en_US.UTF-8 2>/dev/null || true
mkdir -p /var/lib/cloud/instance
touch /var/lib/cloud/instance/locale-check.skip 2>/dev/null || true
elif command -v dnf >/dev/null 2>&1; then
dnf -y upgrade
elif command -v yum >/dev/null 2>&1; then
yum -y update
fi
rm -f /tmp/rubix-bootstrap.pub
echo "SSH hardened and packages upgraded."
REMOTE
}
main() {
echo "=== Rubix VPS first-time SSH bootstrap (run on your PC) ==="
echo ""
ensure_local_sshpass || true
prompt VPS_HOST "VPS hostname or IP"
prompt VPS_PORT "SSH port" "22"
prompt INITIAL_USER "First-login user (usually root)" "root"
prompt DEPLOY_USER "Deploy/sudo user to create" "deployer"
if [[ "${DEPLOY_USER}" == "root" ]]; then
echo "WARN: Using root as deploy user — prefer a sudo user (e.g. deployer) for daily SSH." >&2
fi
prompt SSH_ALIAS "Local ~/.ssh/config Host alias (e.g. rubix-server-5)" "${DEPLOY_USER}-${VPS_HOST}"
prompt_yes_no KEEP_ROOT "Keep root SSH login (key-only, no password)" "yes"
prompt_yes_no INSTALL_ROOT_KEY "Install same public key for root" "${KEEP_ROOT}"
if have_sshpass; then
prompt_secret ROOT_PASSWORD "Initial ${INITIAL_USER} password (entered once via sshpass)"
else
echo ""
echo "[rubix-vps] sshpass unavailable — ssh/scp will prompt for the VPS password each time."
echo ""
prompt_secret ROOT_PASSWORD "Initial ${INITIAL_USER} password (empty = type when ssh asks)"
fi
mkdir -p "${SSH_DIR}"
chmod 700 "${SSH_DIR}"
pick_ssh_key "${SSH_ALIAS}"
if [[ ! -f "${PUBLIC_KEY_FILE}" ]]; then
PUBLIC_KEY_FILE="${PRIVATE_KEY_FILE}.pub"
fi
if [[ ! -f "${PUBLIC_KEY_FILE}" ]]; then
echo "Public key not found: ${PUBLIC_KEY_FILE}" >&2
exit 1
fi
echo "[rubix-vps] Cleaning stale known_hosts entries for ${VPS_HOST}:${VPS_PORT} ..."
cleanup_known_host_entries "${VPS_HOST}" "${VPS_PORT}"
echo ""
echo "[rubix-vps] Testing password login ..."
ssh_password "${INITIAL_USER}@${VPS_HOST}" "echo connected && uname -a"
echo "[rubix-vps] Uploading public key ..."
scp_password "${PUBLIC_KEY_FILE}" "${INITIAL_USER}@${VPS_HOST}:/tmp/rubix-bootstrap.pub"
echo "[rubix-vps] Creating ${DEPLOY_USER} and installing authorized_keys ..."
remote_install_users_and_keys
echo "[rubix-vps] Testing key login (before disabling passwords) ..."
if ! test_key_login "${DEPLOY_USER}"; then
echo "ERROR: Key login as ${DEPLOY_USER} failed. Password auth still enabled — fix keys and retry." >&2
exit 1
fi
echo "[rubix-vps] Key login OK for ${DEPLOY_USER}"
if [[ "${INSTALL_ROOT_KEY}" == "yes" && "${DEPLOY_USER}" != "root" ]]; then
if test_key_login root; then
echo "[rubix-vps] Key login OK for root"
else
echo "[rubix-vps] WARN: root key login failed (deploy user works)" >&2
fi
fi
echo "[rubix-vps] Disabling password auth, reloading sshd, running apt upgrade ..."
remote_harden_and_upgrade
echo "[rubix-vps] Testing key login after hardening ..."
if ! test_key_login "${DEPLOY_USER}"; then
echo "ERROR: Key login failed after hardening. Use provider console; restore /etc/ssh/sshd_config.rubix-backup-*" >&2
exit 1
fi
prompt_yes_no WRITE_CONFIG "Add Host ${SSH_ALIAS} to ${SSH_CONFIG}" "yes"
if [[ "${WRITE_CONFIG}" == "yes" ]]; then
update_local_ssh_config "${SSH_ALIAS}" "${VPS_HOST}" "${VPS_PORT}" "${DEPLOY_USER}" "${PRIVATE_KEY_FILE}"
echo ""
echo "Next login:"
echo " ssh ${SSH_ALIAS}"
else
echo ""
echo "Manual login:"
echo " ssh -i ${PRIVATE_KEY_FILE} -p ${VPS_PORT} ${DEPLOY_USER}@${VPS_HOST}"
fi
echo ""
echo "Done."
}
main "$@"