# Alertas SSH en tu teléfono: un hook de PAM que también detecta scp, sftp y reenvíos de puertos

> Recibe una notificación push en iPhone o Android cada vez que alguien abra una sesión SSH en tu servidor Linux. Un hook de pam_exec que nunca ralentiza un inicio de sesión, mantiene la clave de API solo accesible para root, silencia tus propios inicios de sesión y evita una escalada a root que la configuración habitual deja abierta en Debian 12 y Ubuntu.

*31.10.2026*

<!-- source: https://pocketalert.app/es/blog/ssh-login-alerts -->

Si alguien inicia sesión en tu servidor con una clave robada o una contraseña adivinada, el propio inicio de sesión suele ser el único momento en que podrías haberlo notado. Después, parecen cualquier otro usuario. Una notificación push en tu teléfono por cada sesión SSH te da ese momento: o reconoces el inicio de sesión, o sabes en cuestión de segundos que algo va mal.

Esto es detección, no prevención. No impedirá que nadie entre. Lo que hace es asegurarse de que te enteres mientras todavía puedes actuar.

La guía usa PAM, la capa por la que pasa todo inicio de sesión SSH. Se probó en Debian 12 y 13, Ubuntu 24.04 y Rocky Linux 9, contra una API falsa que registraba cada petición.

## Por qué no /etc/profile, .bashrc ni sshrc

El fragmento que más gente copia es una llamada a `curl` en `/etc/profile`, `~/.bashrc` o `/etc/ssh/sshrc`. Probamos qué ve realmente cada uno:

- **`/etc/profile`** solo se ejecuta en shells de inicio de sesión. En nuestras pruebas, `ssh host cmd`, `scp`, `sftp`, `rsync` y `ssh -N` iniciaron sesión sin ejecutarlo.
- **`~/.bashrc`** pertenece al usuario. Cualquiera con esa cuenta puede editarlo, y `ssh host bash --norc` lo omite.
- **`/etc/ssh/sshrc`** es mejor: se ejecutó para comandos, scp, sftp y rsync. Pero se ejecuta como el usuario que inició sesión, así que la clave de API tiene que ser legible por todas las cuentas. Además, si el usuario tiene un `~/.ssh/rc`, sshd ejecuta ese en su lugar y `sshrc` nunca se ejecuta.
- **Ninguno ve `ssh -N`.** Un reenvío de puertos o un proxy SOCKS sobre SSH no abre ninguna shell, así que no se ejecuta nada.

Todos estos se ejecutan dentro de la sesión, como el usuario, cuando el atacante ya está dentro. Un hook de PAM se ejecuta dentro de sshd, como root, antes de que empiece la sesión.

## Cómo ve PAM un inicio de sesión SSH

Con `UsePAM yes` (el valor por defecto en las cuatro distribuciones), sshd abre una sesión PAM justo después de que la autenticación tenga éxito. Eso ocurre antes de que el cliente pida una shell, un comando o sftp. Por tanto, el hook se dispara para cada conexión autenticada, incluida `ssh -N`, y no puede distinguir una shell interactiva de un `rsync`: `PAM_TTY` vale simplemente `ssh` aunque obtengas una terminal. Una conexión multiplexada (`ControlMaster`) abre una única sesión PAM, sin importar cuántos comandos se ejecuten por ella.

`pam_exec` ejecuta un comando en ese punto. Esto es lo que confirmamos en las máquinas de prueba:

- Para sshd, el comando se ejecuta como root.
- `pam_exec` espera a que el comando termine, y el inicio de sesión espera con él. Un `curl` lento aquí significa un inicio de sesión lento.
- Su salida va a `/dev/null` a menos que añadas la opción `stdout`, así que nada puede filtrarse a una sesión.
- Su entorno es el entorno de PAM, no el de root. No hay `PATH` en Debian ni en Rocky.

Estas son las variables que usa el script:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Variable</th><th>Ejemplo</th><th>De dónde viene</th></tr></thead>
<tbody>
<tr><th><code>PAM_TYPE</code></th><td><code>open_session</code></td><td>También <code>close_session</code> al cerrar sesión</td></tr>
<tr><th><code>PAM_SERVICE</code></th><td><code>sshd</code></td><td>El archivo de PAM en uso</td></tr>
<tr><th><code>PAM_USER</code></th><td><code>root</code></td><td>La cuenta que inició sesión</td></tr>
<tr><th><code>PAM_RHOST</code></th><td><code>198.51.100.23</code></td><td>La dirección del cliente (una IP, con el valor por defecto de sshd <code>UseDNS no</code>)</td></tr>
<tr><th><code>SSH_AUTH_INFO_0</code></th><td><code>publickey ssh-ed25519 AAAA...</code></td><td>Lo define sshd: el método y la clave pública que se aceptó</td></tr>
</tbody>
</table>
</div>

`SSH_AUTH_INFO_0` estaba presente en todas las distribuciones que probamos, sin `ExposeAuthInfo`. Esto significa que la notificación puede indicar la clave que se usó, no solo la cuenta.

## Qué necesitas

- Un servidor Linux con OpenSSH. Comprueba que PAM esté activo: `sudo sshd -T | grep -i usepam` debería mostrar `usepam yes`.
- `curl` y `jq`: `sudo apt install curl jq`, o `sudo dnf install jq` en Rocky, Alma y RHEL (curl ya viene instalado allí).
- La aplicación Pocket Alert en [iPhone o Android](/get-app) y una clave de API desde [Claves de API](/account/apikeys). Crea una clave distinta para cada servidor, así puedes revocar una sin tocar las demás.

## El script

```bash
#!/bin/bash
# /usr/local/sbin/pa-ssh-login
# Run by pam_exec when a session opens. It must never slow down or break a login.
PATH=/usr/sbin:/usr/bin:/sbin:/bin
CONF=/etc/pa-ssh-login.conf

[ "$PAM_TYPE" = open_session ] || exit 0
[ "$(stat -c '%u %a' "$CONF" 2>/dev/null)" = "0 600" ] || exit 0
# shellcheck source=/dev/null
. "$CONF"
[ -n "$POCKETALERT_API_KEY" ] || exit 0

host=$(uname -n)
if [ "$PAM_SERVICE" = sshd ]; then
  who=${PAM_USER:-unknown}
  from=${PAM_RHOST:-unknown}
  title="SSH login: $who@$host"
  auth=${SSH_AUTH_INFO_0%%$'\n'*}
  case $auth in
    publickey\ *) auth="Key: $(ssh-keygen -lf - <<<"${auth#publickey }" 2>/dev/null | awk '{print $2, $NF}')" ;;
    '') auth="Method: unknown" ;;
    *) auth="Method: ${auth%% *}" ;;
  esac
  message="From $from"$'\n'"$auth"
else
  who=${PAM_RUSER:-unknown}
  from=local
  title="$PAM_SERVICE on $host: $who as ${PAM_USER:-unknown}"
  message="Terminal: ${PAM_TTY:-none}"
fi

level=${PA_UNKNOWN_LEVEL:-high}
read -ra rules <<<"${PA_KNOWN:-}"
for rule in "${rules[@]}"; do
  # shellcheck disable=SC2053 # user@address, both halves are glob patterns on purpose
  if [[ $who == ${rule%@*} && $from == ${rule##*@} ]]; then
    level=${PA_KNOWN_LEVEL:-low}
    break
  fi
done
[ "$level" = none ] && exit 0

ip=
[[ $from =~ ^[0-9A-Fa-f:.]+$ ]] && ip=$from

json=$(jq -n --arg title "$title" --arg message "$message" --arg level "$level" --arg ip "$ip" '
  {title: $title, message: $message, level: $level}
  + (if $ip == "" then {} else {actions: [
      {type: "copy", label: "Copy IP", value: $ip},
      {type: "view", label: "Look up IP", value: ("https://ipinfo.io/" + $ip)}
    ]} end)') || exit 0

{
  printf 'header = "Token: %s"\n' "$POCKETALERT_API_KEY" |
    curl -fsS -o /dev/null --connect-timeout 5 --max-time 15 -K - \
      -H 'Content-Type: application/json' --data-binary "$json" \
      "${POCKETALERT_API_URL:-https://api.pocketalert.app/v1/messages}" ||
    logger -t pa-ssh-login "push failed, curl exit code $?"
} </dev/null >/dev/null 2>&1 &

exit 0
```

```bash
sudo install -m 0755 -o root -g root pa-ssh-login /usr/local/sbin/pa-ssh-login
```

Qué hace y por qué:

- **La llamada HTTP se ejecuta en segundo plano.** El script arranca `curl` y termina enseguida, así que `pam_exec` deja de esperar. Con la API respondiendo con normalidad, tras 4 segundos o sin respuesta (una dirección que descarta paquetes), `ssh host true` tardó entre 0,15 y 0,36 segundos en todas las pruebas en Debian 12 y Rocky 9. Un `curl` que no puede conectar se rinde como máximo a los 15 segundos, y el fallo se registra en syslog como `pa-ssh-login: push failed, curl exit code 7`.
- **Siempre termina con código 0**, y toda la salida se redirige, así que la sesión no ve nada. La salida de un inicio de sesión interactivo y de `ssh host cmd` fue idéntica con y sin el hook, salvo por la hora de la línea "Last login".
- **La clave nunca aparece en una línea de comandos.** `curl` lee la cabecera `Token` desde su entrada estándar (`-K -`). Los argumentos son visibles para todos los usuarios locales en `ps`. Mientras una petición estaba colgada, la clave no aparecía en el `/proc/<pid>/cmdline` de ningún proceso.
- **Los valores no confiables entran en el JSON a través de `jq --arg`.** Ejecutamos el script con un nombre de usuario, una dirección, un servicio y una información de clave llenos de comillas, barras invertidas, saltos de línea, `$(id)`, caracteres de control y UTF-8 no válido. Cada cuerpo de petición era JSON válido, y nada se ejecutó.
- **Los botones solo se añaden para una dirección IP.** La API rechaza el mensaje completo con un `400` si un botón `view` no contiene una URL válida. Un `PAM_RHOST` extraño debe seguir enviándote la alerta, solo que sin botones.
- **Los patrones se comparan por partes.** `user@address` se divide en la última `@`, y cada lado se compara por separado. Unirlos en una sola cadena permitiría que una cuenta llamada `x@10.8.0.5` coincidiera con `*@10.8.0.*` aunque se conectara desde cualquier lugar.

Un inicio de sesión desde una dirección desconocida llega así, con `high`, para que atraviese el modo Concentración en iPhone:

```
SSH login: root@web-1
From 198.51.100.23
Key: SHA256:iZtVU4EwMulogUeoneZkIXA9eeQfCvpyRB66QrrxBRA (ED25519)
```

Para ver a qué clave corresponde, ejecuta `ssh-keygen -lf ~/.ssh/authorized_keys` en el servidor. Muestra las mismas huellas, con los comentarios.

## El archivo de configuración

La clave va en un archivo que solo root puede leer. El script se niega a cargarlo a menos que sea propiedad de root y tenga el modo `600`, porque el script lo carga como código de shell. Escribe la clave en un prompt oculto, para que no acabe en tu historial de shell:

```bash
sudo bash -c 'umask 077; read -rsp "API key: " k; echo; printf "POCKETALERT_API_KEY=%s\n" "$k" > /etc/pa-ssh-login.conf'
sudo tee -a /etc/pa-ssh-login.conf >/dev/null <<'EOF'
PA_KNOWN="*@203.0.113.10 deploy@198.51.100.*"
PA_KNOWN_LEVEL=low
PA_UNKNOWN_LEVEL=high
EOF
sudo stat -c '%U %a' /etc/pa-ssh-login.conf   # root 600
```

`PA_KNOWN` enumera los inicios de sesión que esperas, como patrones glob `user@address` separados por espacios. En el ejemplo, cualquier cuenta que salga de tu VPN por `203.0.113.10` se considera esperada, y también `deploy` desde la subred de CI. Llegan como `low`: en el listado, sin sonido. Todo lo demás usa `PA_UNKNOWN_LEVEL`. Con un plan de pago puedes poner ese valor en `critical`, que suena aunque el interruptor silencioso esté activado y en No molestar. En el plan gratuito, `critical` se entrega como `high`. Consulta [niveles de prioridad](https://info.pocketalert.app/features/priority-levels.html) para ver qué hace cada nivel en iOS y Android.

Los patrones son globs, no CIDR: `198.51.100.*` cubre una /24, y otros rangos necesitan más de un patrón. Pon `PA_KNOWN_LEVEL=none` si no quieres que se envíe nada en absoluto para los inicios de sesión esperados.

Cuenta tus inicios de sesión antes de dejarlo en `low`. El plan gratuito permite 50 mensajes al día, y cada conexión SSH es un mensaje. Un trabajo de CI que ejecute `rsync` cada 15 minutos consume 96 de ellos. Asigna `none` a esas fuentes o cambia a un plan de pago. Una vez alcanzado el límite diario, la API rechaza los mensajes hasta las 00:00 UTC, y eso incluiría el único inicio de sesión que te importa.

## Engánchalo a PAM, al principio

Esta parte importa más que el script. Mantén una shell de root abierta en otra terminal mientras cambias PAM, para que un error tipográfico no te deje fuera. sshd lee su archivo de PAM en cada conexión, así que no hace falta reiniciar nada.

```bash
sudo cp /etc/pam.d/sshd /root/pam.d-sshd.bak
sudo sed -i '0,/^session/s|^session|session    optional     pam_exec.so quiet type=open_session /usr/local/sbin/pa-ssh-login\n&|' /etc/pam.d/sshd
sudo grep -n -m2 '^session' /etc/pam.d/sshd
```

En Debian, el último comando muestra:

```
19:session    optional     pam_exec.so quiet type=open_session /usr/local/sbin/pa-ssh-login
20:session [success=ok ignore=ignore module_unknown=ignore default=bad]        pam_selinux.so close
```

Esto coloca la línea por encima de la primera línea `session`, no al final del archivo, que es donde la mayoría de guías la añaden. La razón está en el `/etc/pam.d/sshd` de Debian 12 y de Ubuntu 24.04:

```
session    required     pam_env.so user_readenv=1 envfile=/etc/default/locale
```

`user_readenv=1` carga variables del propio `~/.pam_environment` del usuario en el entorno de PAM. Cualquier línea `pam_exec` situada debajo las pasa al comando que ejecuta. La página de manual de `pam_exec` lo advierte: "Commands called by pam_exec need to be aware of that the user can have control over the environment." (Los comandos invocados por pam_exec deben tener en cuenta que el usuario puede controlar el entorno.)

Comprobamos qué significa esto en Ubuntu 24.04. Con el hook al final del archivo, un usuario normal escribió `LD_PRELOAD /tmp/x.so` en su `~/.pam_environment` e inició sesión. La biblioteca se cargó en el script de root, y en cada programa que este ejecutó, como uid 0. Eso es una shell de root para cualquiera que pueda iniciar sesión por SSH. Con el hook al principio, la variable no estaba presente. Debian 13 y Rocky 9 no definen `user_readenv`, pero poner el hook primero tampoco les cuesta nada. Lo mismo se aplica a cualquier línea `pam_exec` que ya tengas debajo de `pam_env`.

Las opciones de la línea:

- **`optional`**: si el script falta o falla, el inicio de sesión continúa. Renombramos el script e iniciamos sesión. Funcionó, sin mostrar nada.
- **`type=open_session`**: `pam_exec` no ejecuta el script al cerrar sesión. Eso importa por la misma razón que la posición: al cerrar sesión, `pam_env` ya se ha ejecutado, y en nuestra prueba el `LD_PRELOAD` de `~/.pam_environment` estaba de nuevo en el entorno.
- **`quiet`**: si el comando falla, `pam_exec` no muestra su código de salida al usuario.

En los sistemas de la familia RHEL la línea queda por encima de `pam_selinux.so close`, así que se ejecuta en el contexto SELinux de sshd. Nuestras pruebas se ejecutaron en contenedores sin SELinux en modo enforcing. Si las notificaciones no llegan en un sistema con enforcing, revisa `sudo ausearch -m avc -ts recent`.

Las actualizaciones de paquetes pueden reemplazar `/etc/pam.d/sshd`, o dejar una copia `.dpkg-dist` o `.rpmnew` junto a él. Después de actualizar OpenSSH, comprueba que la línea sigue ahí.

## Pruébalo

Puedes llamar al script a mano, del mismo modo que lo hace `pam_exec`:

```bash
sudo env PAM_TYPE=open_session PAM_SERVICE=sshd PAM_USER=test PAM_RHOST=203.0.113.9 /usr/local/sbin/pa-ssh-login
```

Debería llegar una notificación titulada `SSH login: test@<hostname>` en pocos segundos, con `Method: unknown`, ya que no hubo un inicio de sesión SSH real. Si quieres ver primero la petición, añade `POCKETALERT_API_URL=http://<your test endpoint>` a la configuración, y elimínalo cuando termines.

Después, inicia sesión desde un lugar que no esté en `PA_KNOWN`. En las máquinas de prueba, cada una de estas acciones generó una notificación: una shell interactiva, `ssh host cmd`, `scp`, `sftp`, `rsync`, un inicio de sesión con contraseña y `ssh -N`.

## Opcional: su y sudo

El mismo script puede informar de `su` y `sudo`, a través de sus propios archivos de PAM. Necesitan una opción más:

```bash
for f in su sudo; do
  sudo sed -i '0,/^session/s|^session|session    optional     pam_exec.so quiet seteuid type=open_session /usr/local/sbin/pa-ssh-login\n&|' /etc/pam.d/$f
done
```

Sin `seteuid`, `pam_exec` ejecuta el comando con el ID de usuario real del proceso que lo invoca. Para `su` y `sudo`, ese es el usuario que escribió el comando, no root. En nuestras máquinas de prueba, el script se ejecutó como uid 1000, no pudo leer el archivo de configuración y no envió nada. Con `seteuid` se ejecuta como root, y la notificación tiene este aspecto: `sudo on web-1: alice as root`.

Para estos servicios, el script compara `PA_KNOWN` con el usuario que ejecutó el comando, usando `local` como dirección. `alice@local` silencia el `sudo` propio de Alice. `root@local` silencia los scripts que se ejecutan como root y cambian a otro usuario con `su`, que también generan una notificación.

Piensa en el volumen antes de añadir `sudo`. Cada comando `sudo` abre una sesión, así que cada uno de ellos genera una notificación. En un servidor donde la gente usa `sudo` todo el día, engancharse solo a `su` suele ser suficiente.

## Los botones

En los planes de pago, cada notificación SSH incluye dos [botones de acción](/features/action-buttons): **Copy IP** copia la dirección al portapapeles para una regla de cortafuegos o una búsqueda en los logs, y **Look up IP** la abre en ipinfo.io, para que veas si es de tu proveedor o de una red de hosting en otro continente. En el plan gratuito, el servidor elimina los botones, y la notificación se entrega igualmente.

## Lo que esto no cubre

- **Inicios de sesión fallidos.** Las sesiones PAM solo se abren después de que la autenticación tenga éxito. Adivinar contraseñas es tarea de fail2ban, o de revisar el log de sshd en el journal.
- **Cualquier cosa después del inicio de sesión.** Alguien que consiga root puede borrar la línea de `/etc/pam.d/sshd`. No puede retirar la notificación del inicio de sesión que le dio acceso: la petición ya está en camino antes de que empiece su shell.
- **Inicios de sesión que no pasan por la pila de PAM de sshd.** Eso incluye la consola local, otros servicios de acceso remoto y sshd con `UsePAM no`.
- **Distinguir una shell de una transferencia de archivos.** Como se explicó antes, PAM todavía no lo sabe. La dirección y la clave suelen bastar para distinguir tu trabajo de CI de una persona.

Con esto cubres el momento en que alguien entra. Para otros eventos del servidor que merecen una notificación, consulta [alertas de seguridad](/use-cases/security-alerts).
