---
title: "IAM en la nube: quién puede hacer qué"
domain: cloud-computing
level: intermediate
duration: "50 min"
objectives:
  - "Explicar los bloques básicos de IAM en la nube: principales (usuarios, grupos, roles, cuentas de servicio), autenticación frente a autorización, y cómo se evalúa una solicitud."
  - "Leer y escribir políticas de acceso JSON con acciones, recursos, efectos y condiciones, y predecir el resultado cuando se solapan sentencias de permitir y denegar."
  - "Aplicar el principio de mínimo privilegio y comparar el control de acceso basado en roles (RBAC) y el basado en atributos (ABAC)."
  - "Explicar las credenciales temporales y la federación (SAML 2.0, OpenID Connect) y por qué son más seguras que las claves de acceso de larga duración."
  - "Evaluar los errores habituales de IAM (políticas con comodines, claves filtradas, cuentas sin uso, falta de MFA) y cómo detectarlos."
lang: es
source_hash: 3b4a802e0a01
---

# IAM en la nube: quién puede hacer qué

## Por qué importa
Una desarrolladora sube el viernes por la tarde una pequeña corrección a un repositorio de código público. Entre los cambios del commit hay un archivo con una clave de acceso a la nube, la que creó hace dos años "solo para probar algo". En pocos minutos, unos escáneres automáticos la encuentran. El sábado por la mañana la cuenta está ejecutando cientos de servidores para un minero de criptomonedas, y el bucket con las exportaciones de clientes se ha copiado a otro sitio. Nadie "hackeó" nada al estilo de las películas: el atacante simplemente pidió a la nube que hiciera cosas, y la nube comprobó que la clave era válida y que la política asociada a ella permitía las acciones. Las permitía, porque la clave pertenecía a un administrador.

En la nube, la consola y la interfaz de programación de aplicaciones (API, Application Programming Interface) son accesibles desde cualquier lugar de Internet. No hay una red de oficina tras la que esconderse, así que la **identidad** se convierte en el verdadero perímetro. La **gestión de identidades y accesos (IAM, Identity and Access Management)** es la parte de cada nube que decide quién hace la solicitud y qué puede hacer. Aprenderla bien significa que puedes dar a cada persona y a cada programa exactamente el acceso que necesita, preferiblemente durante unos minutos en lugar de para siempre, y que puedes leer la política de otra persona y saber qué permite realmente.

## Objetivos de aprendizaje
- Explicar los bloques básicos de IAM en la nube: principales (usuarios, grupos, roles, cuentas de servicio), autenticación frente a autorización, y cómo se evalúa una solicitud.
- Leer y escribir políticas de acceso JSON con acciones, recursos, efectos y condiciones, y predecir el resultado cuando se solapan sentencias de permitir y denegar.
- Aplicar el principio de mínimo privilegio y comparar el control de acceso basado en roles (RBAC) y el basado en atributos (ABAC).
- Explicar las credenciales temporales y la federación (SAML 2.0, OpenID Connect) y por qué son más seguras que las claves de acceso de larga duración.
- Evaluar los errores habituales de IAM (políticas con comodines, claves filtradas, cuentas sin uso, falta de MFA) y cómo detectarlos.

## Conceptos clave

### Principales: ¿quién hace la solicitud?
Piensa en un edificio con lectores de tarjetas en cada puerta. Cada tarjeta pertenece a alguien o a algo, y cada puerta tiene una regla sobre qué tarjetas la abren. En la nube, quien porta la tarjeta es un **principal**: cualquier identidad que puede enviar una solicitud a la nube y ser reconocida. La mayoría de las nubes ofrecen los mismos cuatro tipos:

| Principal | Qué es | Uso típico |
|---|---|---|
| **Usuario** | Una identidad con nombre para una persona, normalmente con contraseña y un segundo factor. También puede tener **claves de acceso** para la línea de comandos y los programas. | Un ingeniero que inicia sesión en la consola. |
| **Grupo** | Un conjunto de usuarios. Un grupo no es un principal en sí mismo: no puedes iniciar sesión como un grupo. Le asocias políticas y cada miembro las hereda. | `analysts`, `network-admins`. |
| **Rol** | Una identidad con permisos pero **sin contraseña ni claves permanentes**. Alguien o algo la *asume* y recibe credenciales temporales. | Una persona que necesita acceso elevado durante una hora; un servidor; un usuario de otra cuenta. |
| **Cuenta de servicio** (también llamada identidad de carga de trabajo o identidad de máquina) | La identidad de un programa en lugar de una persona: una aplicación, una máquina virtual (VM), un contenedor, una pipeline. | Una aplicación web que lee un bucket. |

![IAM en la nube de un vistazo. A la izquierda, los principales: un usuario (una persona con contraseña y MFA), un grupo (un conjunto de usuarios, políticas asociadas una sola vez), un rol (se asume temporalmente, sin contraseña ni clave) y una cuenta de servicio (identidad de una aplicación o VM). En el centro, el motor de autorización: autentica al llamante, evalúa las políticas, permite o deniega; lee las políticas que tiene debajo, una política de identidad en el principal y una política de recurso en el recurso. A la derecha, los recursos: el bucket lab-data con ARN arn:aws:s3:::lab-data y una máquina virtual, a los que solo se llega si la solicitud se permite. Una franja inferior muestra lo que lleva una solicitud: principal, acción s3:GetObject, recurso arn:aws:s3:::lab-data/reports/q3.txt y contexto como la hora, la IP de origen y MFA](../../../assets/diagrams/iam-who-what-resource.es.svg)

*Figura 1. Cada solicitud lleva un principal, una acción, un recurso y algo de contexto; el motor de autorización los compara con las políticas y responde permitir o denegar.*

Cada principal tiene un nombre único en el formato del proveedor. En Amazon Web Services (AWS) es un **Amazon Resource Name (ARN)**, como `arn:aws:iam::123456789012:user/bob`: `arn`, la partición, el servicio, la región (vacía en IAM), el ID de la cuenta y el recurso. Otros proveedores usan sus propios formatos (una dirección con forma de correo electrónico para una cuenta de servicio de Google Cloud, un ID de objeto en Microsoft Entra), pero la idea es la misma.

En lo más alto de cada cuenta hay una identidad más: el **usuario raíz** (llamado propietario o administrador global en otras nubes). Se crea junto con la cuenta, puede hacerlo todo y las políticas normales no pueden restringirlo. Lo proteges y casi nunca lo usas.

> [!NOTE]
> Este módulo usa el vocabulario y la sintaxis de políticas de AWS IAM porque es la más implementada: muchos servicios de almacenamiento compatibles con S3 de otros proveedores aceptan el mismo JSON de políticas de bucket, y hay herramientas de código abierto que lo emulan, por eso el laboratorio puede ejecutarse en tu portátil. Otros proveedores usan palabras distintas para las mismas ideas: Google Cloud IAM asocia roles a miembros sobre un recurso, Microsoft Azure asigna roles con control de acceso basado en roles en un ámbito, y OpenStack Keystone emite tokens para usuarios en proyectos. Donde importa, la lección explica en qué se diferencian.

> [!CHECK]
> Una empresa quiere que una aplicación web que se ejecuta en una VM lea archivos de un bucket de almacenamiento, sin guardar ninguna contraseña ni clave en la VM. ¿Qué principal es el más adecuado?
>
> - [ ] Un usuario para la aplicación, con su clave de acceso guardada en un archivo de configuración
> - [ ] Un grupo, porque los grupos pueden contener políticas para muchos programas
> - [x] Un rol (o cuenta de servicio) asociado a la VM, que le proporciona credenciales temporales
> - [ ] El usuario raíz, porque nunca necesita una política
>
> Un rol o una cuenta de servicio no tiene contraseña y entrega automáticamente credenciales de corta duración. Un grupo no puede ser un llamante, y el usuario raíz es demasiado poderoso.

### Autenticación frente a autorización
En cada solicitud se plantean dos preguntas distintas, y confundirlas es el origen de muchas configuraciones erróneas.

- La **autenticación (authN)** responde a "¿quién eres?". El llamante demuestra su identidad con algo que sabe (una contraseña), tiene (una llave de hardware, un teléfono) o es (una huella dactilar), o, en el caso de los programas, con una firma criptográfica o un token.
- La **autorización (authZ)** responde a "¿qué tienes permitido hacer?". La nube compara el principal autenticado, la acción solicitada y el recurso de destino con las políticas.

La autenticación va siempre primero, y superarla no concede nada por sí sola. Puedes ver la diferencia en el error que recibes. Una solicitud con una clave desconocida o revocada falla en la autenticación (en el laboratorio: `InvalidClientTokenId`). Una clave válida sin permiso falla en la autorización (`AccessDenied`). Si ves `AccessDenied`, la nube sabe exactamente quién eres y ha decidido que no puedes.

Los programas suelen autenticarse **firmando** cada solicitud con una clave secreta, por ejemplo con AWS Signature Version 4: el secreto en sí nunca viaja por la red, solo una firma calculada sobre la solicitud, que además impide que nadie la altere por el camino. Los tokens funcionan de otra manera: un token es una declaración firmada, válida durante un tiempo limitado, que el receptor puede comprobar sin llamar a nadie.

> [!CHECK]
> Un script recibe `AccessDenied` al listar un bucket. ¿Qué te indica este error?
>
> - [ ] La clave de acceso no es válida o se ha borrado
> - [x] La nube autenticó al llamante, pero ninguna política permite esa acción sobre ese recurso
> - [ ] La solicitud se alteró de camino
> - [ ] El llamante tiene que volver a iniciar sesión con su contraseña
>
> `AccessDenied` es un resultado de autorización: la identidad se reconoció. Una clave no válida o desconocida fallaría antes, en la autenticación, con un error distinto.

### Cómo se evalúa una solicitud
Una vez autenticado el llamante, la nube evalúa las **políticas**: documentos que enumeran lo que se permite o se deniega. Importan dos familias:

- Las **políticas basadas en identidad** se asocian a un principal (usuario, grupo o rol): "Bob puede leer la carpeta de informes."
- Las **políticas basadas en recursos** se asocian a un recurso, como la política de un bucket: "El rol de Carol puede leer este bucket." Nombran el principal al que se aplican.

Las reglas de evaluación son sencillas y son las mismas en todas las nubes principales:

1. **Denegación por defecto.** Si nada menciona la solicitud, se deniega. Los permisos nunca se dan por supuestos.
2. **Allow explícito.** Una sentencia coincidente con efecto `Allow` permite la solicitud.
3. **El deny explícito gana.** Una sentencia coincidente con efecto `Deny` bloquea la solicitud, aunque otras diez sentencias la permitan.

![Evaluación de políticas en cuatro pasos: autenticar (demuestra quién eres con una firma, un token o una contraseña; si falla, se rechaza la solicitud), reunir las políticas (las políticas de identidad del principal más la política de recurso del destino), ¿hay algún Deny explícito? (sí: DENEGADO, se detiene aquí), ¿hay algún Allow explícito? (sí: PERMITIDO, no: DENEGADO). Debajo, tres resultados: un Deny coincidente significa DENEGADO y siempre gana; un Allow coincidente sin Deny significa PERMITIDO; ninguna coincidencia significa DENEGADO por defecto](../../../assets/diagrams/iam-evaluation-flow.es.svg)

*Figura 2. El deny gana al allow, y el silencio es un deny. Este orden nunca cambia, por muchas políticas que se apliquen.*

Dentro de una misma cuenta, basta un allow en la política de identidad *o* en la política de recurso, siempre que nada lo deniegue. Entre dos cuentas, deben permitirlo las dos partes: el propietario del recurso tiene que dejar entrar al principal externo, y la cuenta del propio principal tiene que dejarle hacer la llamada.

Las nubes reales añaden **salvaguardas (guardrails)** por encima: los límites de permisos y las políticas de control de servicios de AWS, los grupos de administración y las asignaciones de denegación de Azure, las políticas de organización y las políticas de denegación de Google Cloud. Una salvaguarda nunca concede nada; solo limita el máximo que un principal podrá recibir, digan lo que digan sus propias políticas. Así es como una organización puede decir una sola vez "nadie, en ningún proyecto, puede usar estas regiones", para todos.

> [!CHECK]
> La política de grupo de Alice permite `s3:*` sobre un bucket. Su usuario tiene además una política con un `Deny` para `s3:DeleteObject` sobre ese bucket. Ella intenta borrar un objeto. ¿Qué ocurre?
>
> - [ ] Se consigue, porque el allow más amplio cubre la acción concreta
> - [ ] Se consigue, porque gana la política asociada más recientemente
> - [x] Se deniega, porque un deny explícito anula cualquier allow
> - [ ] Se deniega solo si ella no está en el grupo
>
> El deny explícito siempre gana, sin importar cuántos allow coincidan ni dónde estén asociados.

### Leer una política JSON
Las políticas al estilo de AWS son documentos JavaScript Object Notation (JSON). La misma estructura aparece en las políticas de IAM, en las políticas de confianza de los roles y en las políticas de bucket, y los servicios compatibles con S3 de muchos proveedores también la aceptan.

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadReports",
      "Effect": "Allow",
      "Principal": { "AWS": "arn:aws:iam::123456789012:user/carol" },
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::lab-data/reports/*",
      "Condition": { "Bool": { "aws:MultiFactorAuthPresent": "true" } }
    }
  ]
}
```

![Anatomía de una política de acceso JSON: una política de bucket para lab-data con Version 2012-10-17, una sentencia con Sid ReadReports, Effect Allow, Principal el usuario carol, Action s3:GetObject, Resource arn:aws:s3:::lab-data/reports/* y una Condition que exige MFA. Cada elemento aparece resaltado y explicado: Version es la versión del lenguaje; Sid una etiqueta opcional; Effect Allow o Deny; Principal quién, solo en políticas de recurso y de confianza; Action qué operaciones; Resource qué objetos, como ARN; Condition pruebas adicionales como MFA, IP, hora y etiquetas](../../../assets/diagrams/iam-policy-anatomy.es.svg)

*Figura 3. Una sentencia responde a cuatro preguntas: efecto, quién, qué y sobre qué recurso, y opcionalmente "solo si".*

| Elemento | Significado |
|---|---|
| `Version` | La versión del lenguaje de políticas. Siempre `2012-10-17`: no es una fecha que elijas, y la antigua `2008-10-17` carece de funciones como las variables de política. |
| `Statement` | Una sentencia o una lista. Cada una se evalúa por separado. |
| `Sid` | Etiqueta opcional, útil en las auditorías. |
| `Effect` | `Allow` o `Deny`. Nada más. |
| `Principal` | A quién se refiere la sentencia. Se usa solo en políticas **basadas en recursos** y de **confianza**; en una política de identidad el principal es aquel al que está asociada, así que el elemento no se admite ahí. |
| `Action` | Las operaciones, escritas como `service:Operation`: `s3:GetObject`, `iam:CreateUser`. Los comodines funcionan: `s3:Get*`. |
| `Resource` | A qué se aplica la acción, como ARN. Los comodines funcionan. |
| `Condition` | Pruebas adicionales que deben cumplirse: la dirección IP de origen, la hora, si se usó MFA, las etiquetas y más. |

Hay dos detalles en los que tropieza casi todo el mundo:

- **Las acciones a nivel de bucket y a nivel de objeto necesitan ARN distintos.** `s3:ListBucket` se aplica al bucket, `arn:aws:s3:::lab-data`. `s3:GetObject` se aplica a los objetos, `arn:aws:s3:::lab-data/reports/*`. Una política que pone `GetObject` sobre el ARN del bucket, o `ListBucket` sobre `lab-data/*`, no coincide con nada y no avisa.
- **`Action` y `Resource` se comparan a la vez.** Una sentencia se aplica solo si la acción solicitada *y* el recurso solicitado coinciden (y la condición es verdadera). Un allow para `s3:GetObject` sobre `reports/*` no dice nada de `secret/*`.

Una **Condition** tiene un operador, una clave de condición y un valor. `Bool` con `aws:MultiFactorAuthPresent` comprueba que el llamante inició sesión con un segundo factor; `IpAddress` con `aws:SourceIp` limita las llamadas a un rango de red como `203.0.113.0/24`; `DateLessThan` con `aws:CurrentTime` hace que el acceso caduque. Una solicitud debe cumplir todas las condiciones de una sentencia para que esta se aplique.

> [!CHECK]
> Una sentencia tiene `"Effect": "Allow"`, `"Action": "s3:GetObject"` y `"Resource": "arn:aws:s3:::lab-data"`. Un usuario con esta política intenta descargar `reports/q3.txt` de `lab-data`. ¿Cuál es el resultado?
>
> - [ ] Permitido: el usuario puede leer todo el bucket
> - [x] Denegado: `GetObject` actúa sobre objetos, así que el ARN del recurso necesita `/*` (o una ruta) tras el nombre del bucket
> - [ ] Permitido, pero solo para los objetos de la carpeta `reports/`
> - [ ] La política se rechaza por no ser válida al guardarla
>
> El ARN `arn:aws:s3:::lab-data` nombra el bucket en sí, no los objetos que contiene. La sentencia es válida, pero nunca coincide con una solicitud sobre un objeto, así que se aplica la denegación por defecto.

### Mínimo privilegio, RBAC y ABAC
El **principio de mínimo privilegio** dice que cada principal recibe solo los permisos que necesita para su tarea, y solo durante el tiempo que los necesita. Limita el **radio de impacto (blast radius)**: si una credencial se filtra o una persona comete un error, el daño queda acotado por lo que esa identidad podía hacer.

En la práctica lo aplicas así:
- partiendo de cero y añadiendo permisos para una tarea conocida, en lugar de partir de administrador y quitar;
- nombrando acciones y recursos concretos en lugar de `*`;
- usando grupos y roles por función laboral en lugar de por persona;
- añadiendo condiciones (MFA, red de origen, hora) para las acciones sensibles;
- revisando lo que realmente se usa y recortando el resto.

Dos modelos deciden cómo se asignan los permisos:

| | **Control de acceso basado en roles (RBAC)** | **Control de acceso basado en atributos (ABAC)** |
|---|---|---|
| Decide según | El rol o grupo al que pertenece el principal | Atributos del principal, del recurso, de la acción y del entorno |
| Regla de ejemplo | "Los miembros de `analysts` pueden leer el bucket de informes." | "Un usuario puede arrancar una VM si la etiqueta `project` de la VM es igual a la etiqueta `project` del usuario." |
| Fortaleza | Fácil de entender y auditar; se corresponde con los puestos de trabajo. | Escala sin políticas nuevas: un proyecto nuevo necesita etiquetas nuevas, no roles nuevos. Granularidad fina y dinámica. |
| Debilidad | Los roles se multiplican ("explosión de roles") a medida que aparecen excepciones. | Más difícil de razonar; depende de que los atributos sean fiables, así que quién puede cambiar las etiquetas pasa a ser una cuestión de seguridad. |
| Uso típico | La mayoría de las cargas de trabajo; un buen punto de partida. | Entornos grandes con varios equipos. |

El ABAC lo define el Instituto Nacional de Estándares y Tecnología de EE. UU. (NIST, National Institute of Standards and Technology) en la Special Publication (SP) 800-162, *Guide to Attribute Based Access Control (ABAC) Definition and Considerations*. La mayoría de los entornos reales combinan ambos: roles para la forma general, atributos para la letra pequeña. Esta es una sentencia ABAC al estilo de AWS, que permite a un principal arrancar y parar solo las VM etiquetadas con su propio proyecto:

```json
{
  "Effect": "Allow",
  "Action": ["ec2:StartInstances", "ec2:StopInstances"],
  "Resource": "arn:aws:ec2:*:*:instance/*",
  "Condition": {
    "StringEquals": { "aws:ResourceTag/project": "${aws:PrincipalTag/project}" }
  }
}
```

`${aws:PrincipalTag/project}` es una variable de política: la nube sustituye la etiqueta de proyecto del llamante en el momento de la solicitud. Una sola sentencia sirve para todos los proyectos.

> [!CHECK]
> Una empresa tiene 200 proyectos y quiere que cada equipo gestione solo los recursos de su proyecto, sin escribir una política nueva para cada uno. ¿Qué enfoque encaja mejor?
>
> - [ ] Un grupo por proyecto, cada uno con su propia política escrita a mano
> - [ ] Dar acceso de administrador a todos los ingenieros y confiar en ellos
> - [x] ABAC: etiquetar principales y recursos con `project`, y permitir acciones cuando las etiquetas coinciden
> - [ ] Compartir una clave de acceso por equipo
>
> ABAC compara atributos en el momento de la solicitud, así que una sola política cubre todos los proyectos. Los grupos por proyecto funcionan (RBAC), pero multiplican las políticas que hay que mantener.

### Credenciales temporales y asumir un rol
Las claves de acceso de larga duración son el mayor riesgo individual de IAM en la nube: no caducan, se copian en scripts, portátiles y repositorios, y nadie se entera cuando se filtran. La solución son las **credenciales temporales**: un conjunto formado por un ID de clave de acceso, un secreto y un **token de sesión** que deja de funcionar al cabo de poco tiempo, de minutos a unas horas.

Las obtienes **asumiendo un rol**, mediante un **servicio de tokens de seguridad**: una API de tipo STS (AWS Security Token Service). El rol tiene dos tipos de política:

- Una **política de confianza** dice *quién puede asumir el rol* (el elemento principal, como en el ejemplo de la Figura 3).
- Una **política de permisos** dice *qué puede hacer el rol* una vez asumido.

![Secuencia entre Carol, un usuario de IAM, el servicio de tokens (STS) y el bucket lab-data. 1. Carol llama a AssumeRole para el rol reader, firmada con su propia clave; STS comprueba la política de confianza y el permiso de ella. 2. STS devuelve credenciales temporales: una clave de acceso que empieza por ASIA, un secreto y un token de sesión, que caducan en 900 segundos. 3. Carol llama a GetObject sobre reports/q3.txt con las credenciales temporales; el almacenamiento evalúa la política del rol y responde 200 OK. Un PutObject sobre reports/c.txt recibe 403 AccessDenied porque el rol es de solo lectura. Al caducar, las credenciales dejan de funcionar, así que no hay nada que revocar ni rotar](../../../assets/diagrams/iam-assume-role.es.svg)

*Figura 4. Mientras dura la sesión, Carol actúa como el rol, con los permisos del rol y no con los suyos. Cuando caduca, el acceso termina por sí solo.*

La identidad del llamante cambia: tras `AssumeRole`, la API informa del llamante como `arn:aws:sts::123456789012:assumed-role/reader/carol-lab`, no como el usuario. Los registros de auditoría anotan el nombre de la sesión, así que aun así puedes saber quién hizo qué. Las claves de acceso que empiezan por `AKIA` son de larga duración; las que empiezan por `ASIA` son temporales y necesitan también el token de sesión.

Asumir roles es también la forma en que una persona obtiene acceso elevado solo cuando lo necesita (acceso "de emergencia", o *break glass*, o acceso justo a tiempo), y la forma en que las cargas de trabajo reciben credenciales de la plataforma: un perfil de instancia en una VM, una cuenta de servicio vinculada a un pod de Kubernetes o una identidad administrada en Azure. El programa pide credenciales nuevas a un punto de acceso local de metadatos; no se guarda ningún secreto en ningún sitio.

> [!NOTE]
> La política de confianza del rol nombra quién *puede* asumirlo. En AWS real, una política de confianza que nombra a un usuario o rol concreto de la misma cuenta basta por sí sola. Si nombra a la cuenta entera (`arn:aws:iam::<account-id>:root`), cada principal necesita además una política de identidad que permita `sts:AssumeRole`. Muchas organizaciones añaden de todos modos una política de identidad que permite `sts:AssumeRole` sobre el rol concreto, para que el permiso sea visible también en el principal. El laboratorio lo hace así, porque el emulador lo necesita.

> [!CHECK]
> ¿Qué afirmación sobre las credenciales temporales de `AssumeRole` es verdadera?
>
> - [ ] Conservan los permisos del usuario que las solicitó
> - [ ] Nunca caducan mientras el rol exista
> - [x] Llevan los permisos del rol y dejan de funcionar tras un tiempo determinado
> - [ ] Solo son válidas junto con la contraseña del usuario
>
> La sesión actúa como el rol, así que se aplican los permisos del rol, no los del llamante. La caducidad está integrada en las credenciales y en el token de sesión.

### Federación: SAML 2.0 y OpenID Connect
Crear un usuario de nube distinto para cada empleado, cada colaborador externo y cada pipeline no escala, y las contraseñas y claves se acumulan. La **federación** permite que la nube confíe en un **proveedor de identidad (IdP, identity provider)** externo: el directorio de la empresa, un inicio de sesión social o un sistema de CI. El usuario inicia sesión en el IdP, y el IdP responde por él con un token firmado. La nube nunca ve la contraseña; solo comprueba el token y asigna al usuario un rol.

![Secuencia de federación entre un usuario o carga de trabajo, el proveedor de identidad, el IAM de la nube con su servicio de tokens y un recurso de la nube. 1. El usuario inicia sesión en el IdP con contraseña y MFA, o un job de CI presenta su propio token. 2. El IdP devuelve un token firmado: un token de ID OIDC (JWT) o una aserción SAML 2.0. 3. El usuario canjea el token por un rol con AssumeRoleWithWebIdentity o AssumeRoleWithSAML; el IAM de la nube verifica la firma con la clave pública del IdP, comprueba el emisor, la audiencia y la caducidad, y la contrasta con la política de confianza del rol. 4. Vuelven credenciales temporales, válidas de minutos a horas. 5. El usuario llama al recurso de la nube con ellas, permitido por la política del rol](../../../assets/diagrams/iam-federation.es.svg)

*Figura 5. El proveedor de identidad autentica; la nube autoriza. El resultado son credenciales temporales, sin ninguna clave de larga duración en ningún sitio.*

Dominan dos estándares:

| | **SAML 2.0** | **OpenID Connect (OIDC)** |
|---|---|---|
| Nombre completo | Security Assertion Markup Language 2.0 (estándar de OASIS) | OpenID Connect Core 1.0 |
| Token | Una **aserción**: un documento Extensible Markup Language (XML) firmado | Un **token de ID**: un JSON Web Token (JWT, RFC 7519) firmado |
| Basado en | XML y redirecciones del navegador | OAuth 2.0 (RFC 6749), al que añade una capa de autenticación |
| Uso típico | Inicio de sesión único (SSO, single sign-on) empresarial para que las personas accedan a la consola | Aplicaciones web y móviles, y **federación de identidad de cargas de trabajo** para pipelines y programas |
| Ejemplo | Una persona de la plantilla inicia sesión en el portal de la empresa y aterriza en la consola de la nube | Un job de CI demuestra "soy la rama `main` de este repositorio" y obtiene un rol para un despliegue |

OAuth 2.0 por sí solo trata de la *autorización delegada* (dejar que una aplicación actúe en tu nombre), no de demostrar quién eres. OIDC añade por encima la capa de identidad que falta.

La federación de identidad de cargas de trabajo sustituye a la clave de despliegue almacenada. Una plataforma de CI emite para cada job un token OIDC de corta duración cuyas declaraciones (claims) dicen de dónde procede, por ejemplo `sub: repo:example-org/example-repo:ref:refs/heads/main`. La política de confianza del rol de la nube acepta solo ese emisor, esa audiencia y ese sujeto. Otro repositorio, u otra rama, no puede asumir el rol.

> [!CHECK]
> ¿Qué verifica una nube cuando recibe un token de ID OIDC o una aserción SAML de un proveedor de identidad?
>
> - [ ] La contraseña del usuario, que reenvía el proveedor de identidad
> - [x] La firma (con la clave pública del IdP), el emisor, la audiencia y la caducidad, y después la política de confianza del rol
> - [ ] Solo que el token sea un documento JSON o XML bien formado
> - [ ] Que el usuario tenga una clave de acceso en la cuenta de la nube
>
> La nube confía en la firma del IdP, no en una contraseña. Aun así comprueba que el token está destinado a ella, que sigue siendo válido y que coincide con la política de confianza del rol.

### Autenticación multifactor
La **autenticación multifactor (MFA, multi-factor authentication)** exige dos o más tipos distintos de prueba: algo que sabes, algo que tienes y algo que eres. Una contraseña robada, por sí sola, ya no abre la puerta. Los segundos factores habituales, del más débil al más fuerte:

- **Códigos por SMS.** Mejor que nada, pero vulnerables al intercambio de SIM (SIM swapping) y a la interceptación.
- **Contraseñas de un solo uso basadas en el tiempo (TOTP, RFC 6238)** de una aplicación autenticadora. Susceptibles de phishing: un sitio falso puede pedir el código y reutilizarlo al instante.
- **Llaves de hardware FIDO2 / WebAuthn y passkeys.** La llave firma un desafío que incluye el nombre del sitio real, así que un sitio parecido no obtiene nada útil. Es la MFA **resistente al phishing**.

Exige MFA a todos los usuarios humanos, siempre al usuario raíz y en las acciones sensibles mediante una condición (`aws:MultiFactorAuthPresent`). Los programas no pueden usar MFA, otra razón más para darles credenciales temporales en lugar de claves.

> [!CHECK]
> ¿Por qué se considera que una llave de seguridad FIDO2 es más fuerte que un código TOTP de una aplicación?
>
> - [ ] El código es más largo, así que es más difícil de adivinar
> - [ ] La llave funciona sin Internet, así que nadie puede interceptarla
> - [x] La llave firma un desafío vinculado al sitio auténtico, así que un sitio de phishing no puede reutilizarlo
> - [ ] La nube guarda el secreto de la llave para poder restablecerlo
>
> Un código TOTP puede teclearse en una página falsa y reutilizarse. Una respuesta FIDO2 está vinculada al origen del sitio real, así que una copia no vale para nada en otro sitio.

## Cómo funciona
Sigue una solicitud de principio a fin. Bob, cuyo usuario tiene la política de mínimo privilegio del laboratorio, ejecuta `aws s3api get-object --bucket lab-data --key reports/q3.txt`:

1. **Firmar.** La herramienta de línea de comandos construye la solicitud HTTP y la firma con la clave secreta de Bob. El ID de la clave de acceso va en la solicitud; el secreto no.
2. **Autenticar.** El servicio busca el ID de la clave de acceso, recalcula la firma con el secreto correspondiente y compara. Una discrepancia o una clave desconocida termina la solicitud con un error de autenticación.
3. **Construir el contexto.** El servicio anota quién (`arn:aws:iam::123456789012:user/bob`), qué (`s3:GetObject`), sobre qué recurso (`arn:aws:s3:::lab-data/reports/q3.txt`) y el entorno (dirección IP de origen, hora, si se usaron MFA y TLS).
4. **Reunir las políticas.** Las políticas del usuario de Bob, las de sus grupos, la política de bucket de `lab-data` y las salvaguardas de la organización, si las hay.
5. **Evaluar.** Se busca un `Deny` coincidente: ninguno. Se busca un `Allow` coincidente: la sentencia de `GetObject` sobre `lab-data/reports/*` coincide. Resultado: permitir.
6. **Actuar y registrar.** Se devuelve el objeto, y el registro de auditoría anota la llamada con el principal, la acción, el recurso, la dirección IP de origen y el resultado.

> [!CHECK]
> ¿Qué paso de la vida de una solicitud ocurre primero?
>
> - [ ] La nube reúne las políticas que se aplican
> - [ ] La nube busca un deny explícito coincidente
> - [x] La nube autentica al llamante a partir de la firma o del token
> - [ ] La nube comprueba si el rol del llamante ha caducado
>
> Las políticas se evalúan para un principal *conocido*, así que la autenticación va siempre primero. Una sesión caducada falla en ese mismo paso de autenticación.

## Ejemplo práctico
Gestionas el bucket `lab-data` con dos prefijos, `reports/` y `secret/`. Bob tiene esta política de identidad (es la que construyes en el laboratorio):

```json
{
  "Version": "2012-10-17",
  "Statement": [
    { "Sid": "ListTheBucket", "Effect": "Allow", "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::lab-data" },
    { "Sid": "EverythingInReports", "Effect": "Allow", "Action": "s3:*",
      "Resource": "arn:aws:s3:::lab-data/reports/*" },
    { "Sid": "NeverDelete", "Effect": "Deny", "Action": "s3:DeleteObject",
      "Resource": "*" }
  ]
}
```

El bucket tiene además una política de recurso que rechaza cualquier solicitud que no esté cifrada en tránsito (una base de seguridad habitual):

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "DenyPlainHttp",
      "Effect": "Deny",
      "Principal": "*",
      "Action": "s3:*",
      "Resource": ["arn:aws:s3:::lab-data", "arn:aws:s3:::lab-data/*"],
      "Condition": { "Bool": { "aws:SecureTransport": "false" } }
    }
  ]
}
```

Predice el resultado de cada solicitud de Bob y después comprueba el razonamiento:

| # | Solicitud | Resultado | Por qué |
|---|---|---|---|
| 1 | `GetObject` `reports/q3.txt` por HTTPS | **Permitido** | `EverythingInReports` lo permite; ningún deny coincide (`SecureTransport` es verdadero, así que `DenyPlainHttp` no se aplica). |
| 2 | `GetObject` `reports/q3.txt` por HTTP sin cifrar | **Denegado** | `DenyPlainHttp` coincide: el deny explícito gana al allow. |
| 3 | `PutObject` `reports/q4.txt` por HTTPS | **Permitido** | `s3:*` sobre `reports/*` lo cubre. |
| 4 | `DeleteObject` `reports/q3.txt` por HTTPS | **Denegado** | `NeverDelete` es un deny explícito; gana al allow de `s3:*`. |
| 5 | `GetObject` `secret/passwords.txt` por HTTPS | **Denegado** | Ninguna sentencia permite `secret/*`: denegación por defecto. |
| 6 | `ListBucket` sobre `lab-data` | **Permitido** | `ListTheBucket` lo permite, para todo el bucket: Bob ve también los *nombres* de los objetos de `secret/`. |

La fila 6 es una sorpresa clásica. Listar es una acción a nivel de bucket, así que esta política no puede limitarla a `reports/` solo con el recurso. En las nubes reales añades una `Condition` sobre el prefijo de la clave (en AWS, `s3:prefix`) para acotarla.

## Errores comunes
- **Poner `*` en `Action` o `Resource` "para que funcione"** — funciona porque lo permite todo. Busca la acción exacta en el error o en el registro de auditoría y nómbrala.
- **Confundir el ARN del bucket con el ARN del objeto** — `ListBucket` necesita `arn:aws:s3:::name`, `GetObject` necesita `arn:aws:s3:::name/*`. Si una mitad de una política funciona y la otra no, comprueba esto primero.
- **Esperar que un allow posterior o más estrecho anule un deny** — nunca lo hace. Para recuperar el acceso debes eliminar o acotar el deny.
- **Olvidar que un grupo no es una identidad** — no puedes iniciar sesión como un grupo, y no puedes nombrarlo como `Principal` de una política de recurso o de confianza. Le asocias políticas y sus miembros las heredan.
- **Probar con la identidad de administrador** — puede hacerlo todo, así que nunca ves el permiso que falta. Prueba con la identidad que realmente ejecutará la tarea.
- **Suponer que todas las herramientas aplican siempre las condiciones** — algunos emuladores y algunos servicios parcialmente compatibles con S3 las ignoran. Prueba las condiciones en el servicio real antes de fiarte de ellas.

## Consideraciones de seguridad
La mayoría de las brechas en la nube empiezan por la identidad, no por una vulnerabilidad de software. Estos son los errores que aparecen una y otra vez, y cómo se detectan.

### Errores habituales
- **Políticas con comodines.** `"Action": "*"` sobre `"Resource": "*"` convierte en llave maestra cualquier credencial que la lleve. Incluso `s3:*` sobre `*` permite a quien la posee leer, modificar y borrar todos los buckets de la cuenta.
- **Claves de larga duración y filtradas.** Claves de acceso subidas a repositorios, pegadas en un chat, incrustadas en imágenes de contenedor o olvidadas años en una variable de CI. Los repositorios públicos se escanean en busca de claves, a menudo a los pocos minutos de un push. Prefiere roles, federación y credenciales temporales; cuando una clave es inevitable, rótala y límitala con condiciones.
- **Cuentas y credenciales sin uso.** Antiguos empleados, usuarios de prueba abandonados y claves viejas siguen siendo válidos hasta que alguien los borra. Cada identidad sin uso es una vía de entrada sin vigilancia.
- **Usar a diario la cuenta raíz o de propietario.** No se puede restringir. Protégela con una contraseña fuerte y MFA resistente al phishing, no le des claves de acceso y resérvala para las pocas tareas que la necesitan.
- **Sin MFA, o con MFA débil.** Entonces una contraseña robada equivale a un compromiso total. Exige MFA a todos los humanos, y prefiere FIDO2 para los administradores.
- **Políticas de confianza demasiado amplias.** Un rol que confía en una cuenta entera, o en `"Principal": "*"`, puede ser asumido por cualquiera de esa cuenta, o por cualquiera sin más. Nombra el principal exacto y, en la federación, el emisor, la audiencia y el sujeto exactos.
- **Permisos concedidos a través de la capacidad de cambiar permisos.** Un principal con permiso para `iam:PutUserPolicy` o `iam:AttachUserPolicy` puede darse a sí mismo derechos de administrador. Trata las acciones de escritura de IAM como de nivel administrador.

### Detección
- **Registros de auditoría.** Cada llamada a la API se registra con quién, qué, cuándo y desde dónde: AWS CloudTrail, el Activity Log de Azure y los registros de inicio de sesión de Microsoft Entra, los Audit Logs de Google Cloud. Guárdalos en una cuenta aparte y protegida contra escritura, y configura alertas para los eventos sensibles: uso de la cuenta raíz, inicio de sesión en la consola sin MFA, claves de acceso nuevas, cambios de políticas, llamadas desde países inusuales.
- **Revisiones de accesos.** Con una periodicidad fija (la trimestral es habitual), el propietario de cada recurso confirma quién sigue necesitando acceso, y tú eliminas el resto. Incluye las cuentas de servicio y las confianzas entre cuentas, que se olvidan con facilidad.
- **Informes de higiene de credenciales.** Enumera usuarios, claves, su antigüedad y su último uso (el laboratorio usa `get-access-key-last-used`). Borra las claves que nadie ha usado en 90 días, rota las que deban quedarse y compara los permisos concedidos con los permisos usados; la mayoría de las nubes pueden sugerir una política más estrecha a partir del registro de actividad (por ejemplo IAM Access Analyzer en AWS, las herramientas de análisis de políticas en Google Cloud).
- **Rotación de claves.** Crea la clave nueva, cambia la aplicación para que la use, comprueba que la clave antigua ya no se usa y después bórrala. En ningún momento tienes que parar la aplicación. La rotación acorta la vida de una filtración, pero no elimina la necesidad de evitar las claves de larga duración.
- **Escaneo de secretos.** Escanea repositorios e imágenes en busca de claves antes de que se suban, y trata como comprometida cualquier clave que haya llegado alguna vez a un lugar público: bórrala, no te limites a reescribir el historial.

> [!WARNING]
> Si se filtra una clave de acceso, desactívala o bórrala de inmediato y después revisa el registro de auditoría para ver qué hizo entre la filtración y la revocación. Cambiar el código o borrar el repositorio no deshace la exposición.

## Resumen
- IAM responde a dos preguntas: quién eres (autenticación) y qué puedes hacer (autorización). `AccessDenied` significa que la autenticación tuvo éxito y la autorización no.
- Una solicitud se permite solo si alguna sentencia la permite y ninguna la deniega: denegación por defecto, allow explícito, el deny explícito gana.
- Una sentencia de política JSON tiene un efecto, un principal (en políticas de recurso y de confianza), acciones, recursos y condiciones opcionales. Ojo con la diferencia entre ARN de bucket y de objeto.
- Aplica el mínimo privilegio: acciones y recursos concretos, ámbitos estrechos, grupos y roles, condiciones y revisiones periódicas. Usa RBAC para la forma general y ABAC para reglas finas y escalables.
- Prefiere roles y credenciales temporales (un `AssumeRole` de tipo STS) a las claves de larga duración, y federa a personas y pipelines con SAML 2.0 u OpenID Connect para que la nube nunca guarde sus contraseñas.
- Exige MFA, protege la cuenta raíz, borra las identidades sin uso, rota las claves inevitables y vigila los registros de auditoría.

## Glosario
| Término | Definición |
|---|---|
| Gestión de identidades y accesos (IAM, Identity and Access Management) | El servicio y la disciplina de la nube que decide quién hace la solicitud y qué puede hacer. |
| Identidad | Un actor reconocido en un sistema: una persona, un programa o un rol. |
| Principal | Cualquier identidad que puede hacer una solicitud: usuario, miembro de un grupo, sesión de un rol o cuenta de servicio. |
| Usuario | Una identidad con nombre para una persona, con credenciales como una contraseña y claves de acceso. |
| Grupo | Un conjunto de usuarios al que se asocian políticas; los miembros las heredan. No puede hacer solicitudes por sí mismo. |
| Rol | Una identidad con permisos pero sin credenciales permanentes, que se asume temporalmente. |
| Cuenta de servicio | Una identidad no humana para una aplicación, VM o pipeline. También llamada identidad de carga de trabajo o identidad de máquina. |
| Usuario raíz | La identidad todopoderosa creada junto con la cuenta (propietario o administrador global en otras nubes). |
| Amazon Resource Name (ARN) | El nombre único de un recurso o principal en AWS, como `arn:aws:iam::123456789012:user/bob`. |
| Clave de acceso | Un par de claves (ID y secreto) que firma las solicitudes a la API. De larga duración salvo que se emita como parte de credenciales temporales. |
| Autenticación (authN) | Demostrar quién es el llamante. |
| Autorización (authZ) | Decidir qué puede hacer un llamante autenticado. |
| Política | Un documento que enumera acciones permitidas o denegadas sobre recursos. |
| Política basada en identidad | Una política asociada a un usuario, grupo o rol. |
| Política basada en recursos | Una política asociada a un recurso, como la política de un bucket; nombra los principales a los que se aplica. |
| Denegación por defecto | La regla de que todo lo que no se permite explícitamente se deniega. |
| Deny explícito | Una sentencia con `Effect: Deny`; anula todos los allow. |
| Sentencia | Una regla de una política: efecto, principal, acción, recurso y condición opcional. |
| Condición | Una prueba adicional en una sentencia (MFA, rango de IP, hora, etiquetas) que debe cumplirse para que se aplique. |
| Salvaguarda (guardrail) | Un límite a nivel de organización (como los límites de permisos o las políticas de control de servicios) que fija el tope de lo que los principales podrán recibir. |
| Principio de mínimo privilegio | Dar a cada principal solo los permisos que necesita, durante el tiempo que los necesita. |
| Radio de impacto (blast radius) | La cantidad de daño posible si se compromete una identidad o credencial. |
| Control de acceso basado en roles (RBAC) | Conceder permisos según los roles o grupos a los que pertenece un principal. |
| Control de acceso basado en atributos (ABAC) | Conceder permisos comparando atributos del principal, del recurso, de la acción y del entorno (NIST SP 800-162). |
| Credenciales temporales | Una clave de acceso, un secreto y un token de sesión que caducan al cabo de poco tiempo. |
| Token de sesión | El valor adicional que debe acompañar a las credenciales temporales en cada solicitud. |
| Servicio de tokens de seguridad (STS, Security Token Service) | La API que emite credenciales temporales, por ejemplo mediante `AssumeRole`. |
| Asumir un rol | Cambiar tu identidad por credenciales temporales que llevan los permisos de un rol. |
| Política de confianza | La política de un rol que dice quién puede asumirlo. |
| Federación | Confiar en un proveedor de identidad externo para autenticar a los usuarios, de modo que la nube no guarde contraseñas de ellos. |
| Proveedor de identidad (IdP) | El sistema que autentica a los usuarios y emite tokens o aserciones firmados. |
| SAML 2.0 | Un estándar basado en XML para aserciones firmadas, muy usado en el inicio de sesión único empresarial. |
| OpenID Connect (OIDC) | Una capa de autenticación sobre OAuth 2.0 que emite tokens de ID JWT firmados. |
| Federación de identidad de cargas de trabajo | Permitir que una pipeline o un programa cambie un token de corta duración de su plataforma por credenciales de la nube, sin ninguna clave almacenada. |
| Autenticación multifactor (MFA) | Autenticación que exige dos o más tipos de prueba. |
| MFA resistente al phishing | MFA, como las llaves FIDO2, cuya respuesta está vinculada al sitio auténtico y no puede reutilizarse desde uno falso. |
| Registro de auditoría | El registro de las llamadas a la API: quién, qué, cuándo, desde dónde y el resultado. |
| Revisión de accesos | Una comprobación periódica de que cada identidad sigue necesitando el acceso que tiene. |
| Rotación de claves | Sustituir una credencial por otra nueva y retirar la antigua. |

## Comprueba lo que has aprendido
1. La política de un compañero tiene `"Action": "s3:*"` y `"Resource": "*"` "porque era la única manera de que funcionara el script de subida." Explica cómo averiguarías los permisos reales que necesita el script y escribirías una política de mínimo privilegio que la sustituya.
2. Un usuario está en dos grupos. El grupo A permite `s3:GetObject` sobre `reports/*`. El grupo B tiene un `Deny` explícito para `s3:*` sobre todo el bucket para quien no tenga MFA. ¿Qué puede hacer el usuario cuando inicia sesión sin MFA y con MFA? ¿Qué elemento marca la diferencia?
3. Diseña el acceso de una pipeline de CI que despliega en tu cuenta de la nube. ¿Qué principal, qué credenciales, qué condiciones de confianza? ¿Qué eliminas respecto a guardar una clave de acceso en una variable de CI?
4. Explica, con tus propias palabras, por qué `AccessDenied` e `InvalidClientTokenId` apuntan a problemas distintos, y qué comprobarías en cada caso.
5. Tu empresa tiene 40 desarrolladores y 5 equipos. ¿Cuándo elegirías RBAC, cuándo ABAC, y qué debes controlar para que ABAC sea seguro?
6. Descubres que una clave de acceso de un empleado que se fue hace un año se usó por última vez ayer. Describe, por orden, qué harías en la primera hora.

## Referencias
- [NIST SP 800-162](https://csrc.nist.gov/pubs/sp/800/162/upd2/final) — Guide to Attribute Based Access Control (ABAC) Definition and Considerations: guía de definición y consideraciones del control de acceso basado en atributos.
- [NIST SP 800-63-4](https://pages.nist.gov/800-63-4/) — Digital Identity Guidelines: directrices de identidad digital (autenticación, federación).
- [OpenID Connect Core 1.0](https://openid.net/specs/openid-connect-core-1_0.html).
- [SAML 2.0 Technical Overview](https://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html) — OASIS.
- [RFC 6749](https://www.rfc-editor.org/rfc/rfc6749) — The OAuth 2.0 Authorization Framework: el marco de autorización OAuth 2.0.
- [RFC 7519](https://www.rfc-editor.org/rfc/rfc7519) — JSON Web Token (JWT).
- [RFC 6238](https://www.rfc-editor.org/rfc/rfc6238) — TOTP: Time-Based One-Time Password Algorithm: algoritmo de contraseña de un solo uso basada en el tiempo.
- [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/) — lógica de evaluación de políticas, referencia de políticas y credenciales temporales.
- [Google Cloud IAM overview](https://cloud.google.com/iam/docs/overview), [Azure RBAC overview](https://learn.microsoft.com/azure/role-based-access-control/overview) y [OpenStack Keystone](https://docs.openstack.org/keystone/latest/) — los mismos conceptos en otros proveedores.
