#!/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
#
# La clave PRIVADA se crea aquí y no sale de esta máquina: Vault solo firma la pública.
# Variables (con valores por defecto):
#   RELAY_VAULT_ADDR URL del Vault                                              (https://vault.alumnos.codecrypto.academy)
#   RELAY_USER       id del alumno; la cuenta del servidor es al_<id>            (jviejo)
#   RELAY_KEY        ruta de la clave                                            (~/.ssh/relay-vault)
#   VAULT_SIGN_PATH  endpoint de firma del rol SSH de Vault                      (ssh/sign/alumno)
#   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:-jviejo}
ALIAS=${RELAY_ALIAS:-relay-$RELAY_USER}
KEY=${RELAY_KEY:-$HOME/.ssh/relay-vault}
CERT="$KEY-cert.pub"
VAULT_SIGN_PATH=${VAULT_SIGN_PATH:-ssh/sign/alumno}
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; }

# segundos de validez que le quedan al certificado (0 si no existe o caducó)
cert_left() {
  [ -f "$CERT" ] || { echo 0; return; }
  local end now e
  end=$(ssh-keygen -L -f "$CERT" 2>/dev/null | awk '/Valid:/{print $NF}')
  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() {
  [ -f "$KEY" ] || { ssh-keygen -q -t ed25519 -N '' -C "relay-$RELAY_USER" -f "$KEY"; echo "clave nueva creada: $KEY"; }
  local left; left=$(cert_left)
  if [ "$left" -ge "$MIN_LEFT" ]; then
    echo "certificado vigente ($((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
  # 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=@"$KEY.pub" valid_principals="al_$RELAY_USER" >"$CERT.tmp" 2>"$CERT.err"; then
    vault write -field=signed_key "$VAULT_SIGN_PATH" public_key=@"$KEY.pub" >"$CERT.tmp" 2>>"$CERT.err" \
      || { echo "Vault no firmó la clave:" >&2; cat "$CERT.err" >&2; rm -f "$CERT.tmp" "$CERT.err"; return 1; }
  fi
  mv "$CERT.tmp" "$CERT"; rm -f "$CERT.err"; chmod 600 "$CERT"
  echo "certificado firmado:"
  ssh-keygen -L -f "$CERT" | grep -E "Key ID|Valid:|Principals" -A1 | grep -v '^--' | sed 's/^ */  /'
  ssh-keygen -L -f "$CERT" | grep -q "al_$RELAY_USER" \
    || echo "AVISO: el certificado NO incluye el principal al_$RELAY_USER; el relay lo rechazará" >&2
}

ensure_cert

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