> For the complete documentation index, see [llms.txt](https://wiki.datadike.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.datadike.com/es/pam/administration/access/command-filtering.md).

# Inspección de comandos

Inspeccione los comandos antes de que se ejecuten dentro de una sesión, y bloquéelos, permítalos, envíelos a aprobación o genere una alerta.

## Qué es y cuándo usarlo

La inspección de comandos se sitúa entre el usuario y el destino. Cada comando escrito en una sesión se intercepta **antes de ejecutarse**, se compara con las reglas que se aplican a ese usuario, activo y cuenta, y luego se permite, se bloquea, se pone en cola de aprobación o se permite con alerta.

Es el control que convierte "esta persona tiene acceso al shell" en "esta persona tiene acceso al shell, menos aquello que nadie debería hacer en este host".

Úsela en activos de producción, en cuentas administrativas compartidas y allí donde un solo comando mal escrito resulta caro.

{% hint style="info" %}
La inspección se aplica en el servidor, no en el cliente. También alcanza a los comandos ejecutados mediante automatizaciones **adhoc**, no solo a las sesiones interactivas, y cada intento queda escrito en el registro de auditoría, se haya ejecutado o no.
{% endhint %}

## Cómo funciona

Son dos objetos, y es fácil confundirlos:

| Objeto                 | Qué es                                                                                                                          |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Grupo de comandos**  | Un catálogo de comandos o patrones, es decir, *qué* buscar                                                                      |
| **Filtro de comandos** | Una regla que aplica grupos a un conjunto de usuarios, activos y cuentas, con una acción, es decir, *quién, dónde y qué ocurre* |

Un grupo por sí solo no hace nada. Es el filtro el que lo pone en vigor.

La secuencia en cada comando:

1. El usuario escribe un comando durante la sesión
2. La solución lo intercepta antes de ejecutarlo
3. Busca un filtro que coincida con esa combinación de usuario, activo y cuenta
4. Compara el comando con los grupos asociados a ese filtro
5. Aplica la acción del filtro
6. Registra el intento para auditoría

## Las cuatro acciones

| Acción       | Qué ocurre                                                                              | Cuándo usarla                                                |
| ------------ | --------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
| **Rechazar** | Bloqueado de inmediato y nunca llega al destino. Se informa al usuario de la denegación | Comandos que nadie debería ejecutar en ese host              |
| **Aceptar**  | Permitido y ejecutado con normalidad                                                    | Abrir excepciones dentro de una regla restrictiva más amplia |
| **Revisión** | Retenido en una cola de aprobación. Se notifica a un aprobador designado, que decide    | Comandos críticos pero legítimos                             |
| **Alarm**    | Se ejecuta con normalidad, pero genera una alerta a los administradores                 | Vigilar actividad sospechosa sin detener el trabajo          |

## Pasos

### 1. Crear el grupo de comandos

1. Abra **Políticas › Inspecciones de comandos** y vaya a la pestaña **Grupo de comandos**.
2. Haga clic en **Crear**.
3. Póngale un **Nombre** que diga qué captura: *Comandos destructivos*, *Cambios de red*.
4. Elija el **Tipo**:
   * **Comando**: comandos literales
   * **Expresión regular**: un patrón, para familias de comandos
5. Rellene el **Contenido**, un comando por línea:

```bash
rm
reboot
hostname
sudo df -h
```

6. Decida si quiere ignorar mayúsculas y minúsculas.
7. Guarde.

{% hint style="warning" %}
Con **Tipo = Comando**, la coincidencia es literal, **espacios incluidos**. `sudo df -h` y `sudo df -h` son cadenas distintas y la segunda no coincidirá. Cuando el espaciado o los argumentos varían, use una expresión regular.
{% endhint %}

### 2. Crear el filtro

1. Vaya a la pestaña **Filtro de comandos** y haga clic en **Crear**.
2. Fije el **Nombre** y la **Prioridad**, numérica, donde el número menor se procesa primero, con 50 por defecto.
3. Elija el alcance de **Usuario**: todos los usuarios, usuarios específicos, o filtrado por atributo.
4. Elija el alcance de **Activo** del mismo modo.
5. Asocie los grupos de comandos y elija la **Acción**.
6. Guarde.

## Qué debe ver

![La pestaña ACL de filtro de comandos, con la lista de filtros](https://162891664-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2Fs5AnPAmUmMC3tSpoBhHY%2Fuploads%2Fgit-blob-cf94d2bf9b80b376b8ec05369df2a52f5609f139%2Fcommand-inspection.png?alt=media)

**1** Cuántos filtros existen. **2** Un filtro, con su prioridad. La pestaña Grupo de comandos guarda los catálogos que aplican los filtros.

El filtro aparece en la lista con su prioridad. La prioridad importa en cuanto dos filtros pueden aplicarse a la misma sesión: el número menor se procesa primero.

## Cómo verificar que funcionó

La lista de reglas no prueba nada. Pruébelo desde una sesión:

1. Abra una sesión hacia un activo cubierto, como un usuario cubierto y usando una cuenta cubierta.
2. Escriba uno de los comandos del grupo.
3. El resultado esperado depende de la acción:
   * **Rechazar**: el comando no se ejecuta y se informa al usuario de la denegación
   * **Revisión**: la sesión espera y se notifica al aprobador
   * **Alarm**: el comando se ejecuta y se genera una alerta
4. Abra el registro de auditoría y confirme que el intento quedó registrado, incluso cuando fue bloqueado.

Si no ocurre nada, la causa habitual es que el alcance de usuario, activo o cuenta del filtro no cubre realmente la sesión que acaba de abrir.

## Errores comunes

| Síntoma                                        | Causa                                                                                     | Solución                                                                                                |
| ---------------------------------------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| El comando se ejecuta aunque está en un grupo  | El grupo no está asociado a ningún filtro, o el alcance del filtro no llega a esta sesión | Compruebe que algún filtro asocia el grupo y que su alcance de usuario, activo y cuenta cubre la sesión |
| Un comando coincide unas veces y otras no      | Coincidencia literal, y el espaciado o los argumentos varían                              | Cambie el grupo a expresión regular                                                                     |
| Un comando bloqueado debería haberse permitido | Un filtro más amplio tiene mayor prioridad                                                | Baje el número del filtro más específico                                                                |
| Nada se bloquea para un usuario                | Otro filtro con **Aceptar** y un número menor coincide antes                              | Revise las prioridades del conjunto de filtros, no de uno en uno                                        |

## Referencia de campos

### Grupo de comandos

| Campo       | Qué hace                                                                                |
| ----------- | --------------------------------------------------------------------------------------- |
| Nombre      | Identifica el grupo                                                                     |
| Tipo        | **Comando** para cadenas literales, **Expresión regular** para patrones                 |
| Contenido   | Un comando o patrón por línea. La coincidencia literal respeta los espacios exactamente |
| Ignore case | Hace que la coincidencia no distinga mayúsculas de minúsculas                           |

### Filtro de comandos

| Campo     | Qué hace                                                          |
| --------- | ----------------------------------------------------------------- |
| Nombre    | Identifica la regla                                               |
| Prioridad | Numérica. El número menor se procesa primero. 50 por defecto      |
| Usuario   | Todos los usuarios, usuarios específicos, o filtrado por atributo |
| Activo    | Todos los activos, activos específicos, o filtrado por atributo   |
| Acción    | Rechazar, Aceptar, Revisión o Alarm                               |

## Catálogos de comandos listos para usar

DataDike publica listas mantenidas de comandos que conviene bloquear, organizadas por plataforma, en [DataDike-commands-block](https://github.com/DataDike/DataDike-commands-block), con carpetas para AIX, Cisco, Fortinet, Linux, Oracle y Windows.

Son un punto de partida, no una política. Léalas antes de aplicarlas.

## Páginas relacionadas

* [Autorizaciones](/es/pam/administration/access/authorizations.md): conceder la sesión que la inspección después restringe
* [Flujos de aprobación](/es/pam/administration/access/approvals.md): adónde envía el comando la acción **Revisión**
* [Registro de auditoría](/es/pam/administration/audit/audit-trail.md): donde queda cada intento