#!/usr/bin/env bash
# relay-login.sh — obtiene un certificado SSH de Vault (identidad: Keycloak por OIDC) y,
# opcionalmente, mantiene abierto el túnel del relay (puerto 2223 del servidor).
#
#   ./relay-login.sh              # solo obtiene/renueva el certificado
#   ./relay-login.sh --tunel      # certificado + túnel con reconexión
#
# SIN CLAVES EN DISCO: se genera un par EFÍMERO en un directorio temporal (0700), Vault firma la pública,
# la privada + el certificado se cargan en el ssh-agent con la misma caducidad que el certificado y el
# directorio temporal se borra. No hay ~/.ssh/relay-vault ni authorized_keys que dar al profesor.
# Variables (con valores por defecto):
#   RELAY_VAULT_ADDR URL del Vault                                              (https://vault.alumnos.codecrypto.academy)
#   RELAY_USER       id del alumno (OBLIGATORIO); la cuenta del servidor es al_<id>  (sin valor por defecto)
#   VAULT_SIGN_PATH  endpoint de firma del rol SSH de Vault                      (ssh/sign/relay)
#   VAULT_OIDC_ROLE  rol del método de login OIDC, si hace falta                 (vacío = el por defecto)
#   RELAY_MIN_LEFT   renovar si quedan menos de N segundos de validez            (1800)
set -euo pipefail

RELAY_USER=${RELAY_USER:-}
if [ -z "$RELAY_USER" ]; then
  echo "falta tu id de alumno. Ejecuta, por ejemplo:  RELAY_USER=<tu-id> $0" >&2
  echo "  (tu id es el que te asignó el profesor: minúsculas, letras y números, 3-20 caracteres)" >&2
  exit 1
fi
if ! [[ "$RELAY_USER" =~ ^[a-z][a-z0-9]{2,19}$ ]]; then
  echo "id de alumno inválido: '$RELAY_USER' (minúsculas y números, 3-20 caracteres, empieza por letra)" >&2
  exit 1
fi
ALIAS=${RELAY_ALIAS:-relay-$RELAY_USER}
VAULT_SIGN_PATH=${VAULT_SIGN_PATH:-ssh/sign/relay}
VAULT_OIDC_ROLE=${VAULT_OIDC_ROLE:-}
MIN_LEFT=${RELAY_MIN_LEFT:-1800}
# Vault del servidor (NO el 127.0.0.1:8200 que pueda haber en tu máquina, que es otro Vault)
VAULT_ADDR=${RELAY_VAULT_ADDR:-https://vault.alumnos.codecrypto.academy}
export VAULT_ADDR

command -v vault >/dev/null      || { echo "falta el binario 'vault'" >&2; exit 1; }
command -v ssh-keygen >/dev/null || { echo "falta ssh-keygen" >&2; exit 1; }

command -v ssh-add >/dev/null || { echo "falta ssh-add" >&2; exit 1; }
[ -n "${SSH_AUTH_SOCK:-}" ] && ssh-add -l >/dev/null 2>&1 || [ $? -eq 1 ] \
  || { echo "no hay ssh-agent activo (eval \"\$(ssh-agent -s)\")" >&2; exit 1; }

# segundos de validez que le quedan al certificado cargado en el agente (0 si no hay)
cert_left() {
  local end now e
  end=$(ssh-add -L 2>/dev/null | grep -F "relay-$RELAY_USER" | grep -- '-cert-v01' | head -1 \
        | ssh-keygen -L -f /dev/stdin 2>/dev/null | awk '/Valid:/{print $NF}')
  [ -n "$end" ] || { echo 0; return; }
  now=$(date +%s)
  e=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$end" +%s 2>/dev/null || date -d "$end" +%s 2>/dev/null || echo 0)
  echo $(( e > now ? e - now : 0 ))
}

ensure_cert() {
  local left; left=$(cert_left)
  if [ "$left" -ge "$MIN_LEFT" ]; then
    echo "certificado vigente en el agente ($((left/60)) min restantes)"; return 0
  fi
  if ! vault token lookup >/dev/null 2>&1; then
    echo "login en Vault (se abrirá el navegador con Keycloak)…"
    vault login -no-print -method=oidc ${VAULT_OIDC_ROLE:+role="$VAULT_OIDC_ROLE"}
  fi
  local d; d=$(mktemp -d); chmod 700 "$d"
  # shellcheck disable=SC2064
  trap "rm -rf '$d'" RETURN
  ssh-keygen -q -t ed25519 -N '' -C "relay-$RELAY_USER" -f "$d/k"
  # primero pidiendo el principal explícito; si el rol lo fija por plantilla, sin él
  if ! vault write -field=signed_key "$VAULT_SIGN_PATH" public_key=@"$d/k.pub" valid_principals="al_$RELAY_USER" >"$d/k-cert.pub" 2>"$d/err"; then
    vault write -field=signed_key "$VAULT_SIGN_PATH" public_key=@"$d/k.pub" >"$d/k-cert.pub" 2>>"$d/err" \
      || { echo "Vault no firmó la clave:" >&2; cat "$d/err" >&2; return 1; }
  fi
  ssh-keygen -L -f "$d/k-cert.pub" | grep -q "al_$RELAY_USER" \
    || echo "AVISO: el certificado NO incluye el principal al_$RELAY_USER; el relay lo rechazará" >&2
  # quitar el par anterior de este alumno y cargar el nuevo con caducidad = la del certificado
  ssh-add -L 2>/dev/null | grep -F "relay-$RELAY_USER" >/dev/null && ssh-add -d "$d/k" >/dev/null 2>&1 || true
  local life; life=$(ssh-keygen -L -f "$d/k-cert.pub" | awk '/Valid:/{print $NF}')
  life=$(( $(date -j -f "%Y-%m-%dT%H:%M:%S" "$life" +%s 2>/dev/null || date -d "$life" +%s) - $(date +%s) ))
  ssh-add -t "$life" "$d/k" 2>&1 | sed 's/^/  /'   # ssh-add carga también $d/k-cert.pub
  echo "certificado firmado y cargado en el agente:"
  ssh-keygen -L -f "$d/k-cert.pub" | grep -E "Key ID|Valid:|Principals" -A1 | grep -v '^--' | sed 's/^ */  /'
}

ensure_cert

if [ "${1:-}" = "--tunel" ]; then
  while true; do
    ssh -N "$ALIAS" || true
    sleep $(( (RANDOM % 20) + 5 ))   # reconexión con espera aleatoria: evita tormentas tras un corte
    ensure_cert || true               # renueva el certificado antes de reconectar si le queda poco
  done
fi
