---
title: "IAM na cloud: quem pode fazer o quê"
domain: cloud-computing
level: intermediate
duration: "50 min"
objectives:
  - "Explicar os blocos de construção do IAM na cloud: principais (utilizadores, grupos, roles, contas de serviço), autenticação versus autorização, e como um pedido é avaliado."
  - "Ler e escrever políticas de acesso JSON com ações, recursos, efeitos e condições, e prever o resultado quando declarações de permitir e de negar se sobrepõem."
  - "Aplicar o princípio do menor privilégio e comparar o controlo de acesso baseado em funções (RBAC) e o baseado em atributos (ABAC)."
  - "Explicar as credenciais temporárias e a federação (SAML 2.0, OpenID Connect) e porque são mais seguras do que as chaves de acesso de longa duração."
  - "Avaliar os erros comuns de IAM (políticas com carateres universais, chaves divulgadas, contas sem uso, falta de MFA) e como detetá-los."
lang: pt
source_hash: 3b4a802e0a01
---

# IAM na cloud: quem pode fazer o quê

## Porque é que isto importa
Uma programadora envia uma pequena correção para um repositório de código público numa tarde de sexta-feira. No meio do commit está um ficheiro com uma chave de acesso à cloud, a que criou há dois anos "só para testar uma coisa". Em poucos minutos, ferramentas automáticas encontram-na. Na manhã de sábado, a conta está a executar centenas de servidores para um minerador de criptomoedas, e o bucket com as exportações de clientes foi copiado para outro sítio. Nada foi "pirateado" ao estilo dos filmes: o atacante limitou-se a pedir à cloud que fizesse coisas, e a cloud verificou que a chave era válida e que a política associada a ela permitia as ações. Permitia, porque a chave pertencia a um administrador.

Na cloud, a consola e a interface de programação de aplicações (API, Application Programming Interface) são acessíveis a partir de qualquer ponto da Internet. Não há uma rede de escritório atrás da qual se esconder, pelo que a **identidade** passa a ser o verdadeiro perímetro. A **gestão de identidades e acessos (IAM, Identity and Access Management)** é a parte de qualquer cloud que decide quem está a fazer o pedido e o que essa entidade pode fazer. Dominá-la significa poder dar a cada pessoa e a cada programa exatamente o acesso de que precisam, de preferência durante alguns minutos e não para sempre, e conseguir ler a política de outra pessoa e saber o que ela realmente permite.

## Objetivos de aprendizagem
- Explicar os blocos de construção do IAM na cloud: principais (utilizadores, grupos, roles, contas de serviço), autenticação versus autorização, e como um pedido é avaliado.
- Ler e escrever políticas de acesso JSON com ações, recursos, efeitos e condições, e prever o resultado quando declarações de permitir e de negar se sobrepõem.
- Aplicar o princípio do menor privilégio e comparar o controlo de acesso baseado em funções (RBAC) e o baseado em atributos (ABAC).
- Explicar as credenciais temporárias e a federação (SAML 2.0, OpenID Connect) e porque são mais seguras do que as chaves de acesso de longa duração.
- Avaliar os erros comuns de IAM (políticas com carateres universais, chaves divulgadas, contas sem uso, falta de MFA) e como detetá-los.

## Conceitos-chave

### Principais: quem faz o pedido?
Pense-se num edifício com leitores de crachás em todas as portas. Cada crachá pertence a alguém ou a alguma coisa, e cada porta tem uma regra sobre quais os crachás que a abrem. Na cloud, o titular do crachá é um **principal**: qualquer identidade que possa enviar um pedido à cloud e ser reconhecida. A maioria das clouds oferece os mesmos quatro tipos:

| Principal | O que é | Utilização típica |
|---|---|---|
| **Utilizador** | Uma identidade nomeada para uma pessoa, normalmente com palavra-passe e um segundo fator. Pode ter também **chaves de acesso** para a linha de comandos e para programas. | Um engenheiro que inicia sessão na consola. |
| **Grupo** | Um conjunto de utilizadores. Um grupo não é um principal: não se pode iniciar sessão como um grupo. Associam-se-lhe políticas e todos os membros herdam-nas. | `analysts`, `network-admins`. |
| **Role** | Uma identidade com permissões, mas **sem palavra-passe nem chaves permanentes**. Alguém ou alguma coisa *assume-o* e recebe credenciais temporárias. | Uma pessoa que precisa de acesso elevado durante uma hora; um servidor; um utilizador de outra conta. |
| **Conta de serviço** (também chamada identidade de carga de trabalho ou identidade de máquina) | A identidade de um programa e não de uma pessoa: uma aplicação, uma máquina virtual (VM), um contentor, uma pipeline. | Uma aplicação web que lê um bucket. |

![IAM na cloud numa vista geral. À esquerda, os principais: um utilizador (uma pessoa com palavra-passe e MFA), um grupo (um conjunto de utilizadores, com as políticas associadas uma só vez), um role (assumido temporariamente, sem palavra-passe nem chave) e uma conta de serviço (identidade de uma aplicação ou VM). No meio, o motor de autorização: autentica quem chama, avalia as políticas, permite ou nega; lê as políticas que tem por baixo, uma política de identidade no principal e uma política de recurso no recurso. À direita, os recursos: o bucket lab-data com o ARN arn:aws:s3:::lab-data e uma máquina virtual, alcançados apenas se o pedido for permitido. Uma faixa na parte inferior mostra o que um pedido transporta: principal, ação s3:GetObject, recurso arn:aws:s3:::lab-data/reports/q3.txt e contexto como hora, IP de origem e MFA](../../../assets/diagrams/iam-who-what-resource.pt.svg)

*Figura 1. Todos os pedidos transportam um principal, uma ação, um recurso e algum contexto; o motor de autorização compara-os com as políticas e responde permitir ou negar.*

Cada principal tem um nome único no formato do fornecedor. Na Amazon Web Services (AWS) é um **Amazon Resource Name (ARN)**, como `arn:aws:iam::123456789012:user/bob`: `arn`, a partição, o serviço, a região (vazia no IAM), o ID da conta e o recurso. Outros fornecedores usam os seus próprios formatos (um endereço ao estilo de e-mail para uma conta de serviço do Google Cloud, um ID de objeto no Microsoft Entra), mas a ideia é a mesma.

No topo de cada conta existe ainda uma identidade: o **utilizador raiz** (chamado proprietário ou administrador global noutras clouds). É criado com a conta, pode fazer tudo e não pode ser restringido por políticas normais. Protege-se e quase nunca se usa.

> [!NOTE]
> Este módulo usa o vocabulário e a sintaxe de políticas do AWS IAM por ser o mais amplamente implementado: muitos serviços de armazenamento compatíveis com S3 noutros fornecedores aceitam o mesmo JSON de políticas de bucket, e ferramentas de código aberto emulam-no, e é por isso que o laboratório pode correr no seu portátil. Outros fornecedores usam palavras diferentes para as mesmas ideias: o Google Cloud IAM associa roles a membros num recurso, o Microsoft Azure atribui roles com controlo de acesso baseado em funções num âmbito, e o OpenStack Keystone emite tokens para utilizadores em projetos. Quando for relevante, a lição indica em que diferem.

> [!CHECK]
> Uma empresa quer que uma aplicação web que corre numa VM leia ficheiros de um bucket de armazenamento, sem guardar qualquer palavra-passe ou chave na VM. Qual é o principal mais adequado?
>
> - [ ] Um utilizador para a aplicação, com a chave de acesso guardada num ficheiro de configuração
> - [ ] Um grupo, porque os grupos podem conter políticas para muitos programas
> - [x] Um role (ou conta de serviço) associado à VM, que lhe dá credenciais temporárias
> - [ ] O utilizador raiz, porque nunca precisa de uma política
>
> Um role ou uma conta de serviço não tem palavra-passe e distribui credenciais de curta duração automaticamente. Um grupo não pode fazer pedidos, e o utilizador raiz é poderoso em demasia.

### Autenticação versus autorização
Em cada pedido são feitas duas perguntas diferentes, e confundi-las está na origem de muitas configurações erradas.

- A **autenticação (authN)** responde a "quem é você?". Quem chama prova a sua identidade com algo que sabe (uma palavra-passe), que tem (uma chave de hardware, um telemóvel) ou que é (uma impressão digital), ou, no caso dos programas, com uma assinatura criptográfica ou um token.
- A **autorização (authZ)** responde a "o que lhe é permitido fazer?". A cloud compara o principal autenticado, a ação pedida e o recurso de destino com as políticas.

A autenticação vem sempre primeiro, e passá-la não concede nada por si só. A diferença vê-se no erro que se obtém. Um pedido com uma chave desconhecida ou revogada falha na autenticação (no laboratório: `InvalidClientTokenId`). Uma chave válida sem permissão falha na autorização (`AccessDenied`). Se aparecer `AccessDenied`, a cloud sabe exatamente quem é e decidiu que não lhe é permitido.

Os programas autenticam-se normalmente **assinando** cada pedido com uma chave secreta, por exemplo com o AWS Signature Version 4: o segredo em si nunca viaja pela rede, apenas uma assinatura calculada sobre o pedido, o que também impede que alguém o altere em trânsito. Os tokens funcionam de outra forma: um token é uma declaração assinada, válida por um período limitado, que o recetor pode verificar sem contactar ninguém.

> [!CHECK]
> Um script recebe `AccessDenied` ao listar um bucket. O que lhe diz este erro?
>
> - [ ] A chave de acesso é inválida ou foi eliminada
> - [x] A cloud autenticou quem chama, mas nenhuma política permite essa ação nesse recurso
> - [ ] O pedido foi alterado em trânsito
> - [ ] Quem chama tem de iniciar sessão novamente com a sua palavra-passe
>
> `AccessDenied` é um resultado de autorização: a identidade foi reconhecida. Uma chave inválida ou desconhecida falharia mais cedo, na autenticação, com um erro diferente.

### Como um pedido é avaliado
Depois de quem chama estar autenticado, a cloud avalia as **políticas**: documentos que listam o que é permitido ou negado. Há duas famílias relevantes:

- As **políticas baseadas em identidade** estão associadas a um principal (utilizador, grupo ou role): "O Bob pode ler a pasta de relatórios."
- As **políticas baseadas em recursos** estão associadas a um recurso, como uma política de bucket: "O role da Carol pode ler este bucket." Indicam o principal a que se aplicam.

As regras de avaliação são simples e são as mesmas em todas as grandes clouds:

1. **Negação por omissão.** Se nada mencionar o pedido, este é negado. As permissões nunca são implícitas.
2. **Allow explícito.** Uma declaração coincidente com efeito `Allow` permite o pedido.
3. **O deny explícito prevalece.** Uma declaração coincidente com efeito `Deny` bloqueia o pedido, mesmo que outras dez declarações o permitam.

![Avaliação de políticas em quatro passos: autenticar (provar quem é com uma assinatura, token ou palavra-passe; se falhar, o pedido é rejeitado), reunir as políticas (as políticas de identidade do principal mais a política de recurso do destino), existe algum Deny explícito (sim: NEGADO, parar aqui), existe algum Allow explícito (sim: PERMITIDO, não: NEGADO). Em baixo, três resultados: um Deny coincidente significa NEGADO e prevalece sempre; um Allow coincidente sem Deny significa PERMITIDO; nenhuma coincidência significa NEGADO por omissão](../../../assets/diagrams/iam-evaluation-flow.pt.svg)

*Figura 2. O deny prevalece sobre o allow, e o silêncio é um deny. Esta ordem nunca muda, por mais políticas que se apliquem.*

Dentro de uma mesma conta, basta um allow na política de identidade *ou* na política de recurso, desde que nada negue. Entre duas contas, ambos os lados têm de permitir: o proprietário do recurso tem de deixar entrar o principal externo, e a conta do próprio principal tem de lhe permitir fazer a chamada.

As clouds reais acrescentam **barreiras de proteção (guardrails)** por cima: os limites de permissões e as políticas de controlo de serviços da AWS, os grupos de gestão e as atribuições de negação do Azure, as políticas da organização e as políticas de negação do Google Cloud. Uma barreira nunca concede nada; apenas limita o máximo que um principal pode alguma vez receber, sejam quais forem as suas próprias políticas. É assim que uma organização pode dizer "ninguém, em nenhum projeto, pode usar estas regiões" uma única vez, para todos.

> [!CHECK]
> A política de grupo da Alice permite `s3:*` num bucket. O seu utilizador tem também uma política com um `Deny` para `s3:DeleteObject` nesse bucket. Ela tenta eliminar um objeto. O que acontece?
>
> - [ ] Tem êxito, porque o allow mais abrangente cobre a ação específica
> - [ ] Tem êxito, porque prevalece a política associada mais recentemente
> - [x] É negado, porque um deny explícito prevalece sobre qualquer allow
> - [ ] É negado apenas se ela não estiver no grupo
>
> O deny explícito ganha sempre, independentemente de quantos allow coincidam ou de onde estejam associados.

### Ler uma política JSON
As políticas ao estilo da AWS são documentos em JavaScript Object Notation (JSON). A mesma estrutura aparece nas políticas do IAM, nas políticas de confiança de roles e nas políticas de bucket, e os serviços compatíveis com S3 de muitos fornecedores também a aceitam.

```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" } }
    }
  ]
}
```

![Anatomia de uma política de acesso JSON: uma política de bucket para lab-data com Version 2012-10-17, uma declaração com Sid ReadReports, Effect Allow, Principal o utilizador carol, Action s3:GetObject, Resource arn:aws:s3:::lab-data/reports/* e uma Condition que exige MFA. Cada elemento está realçado e explicado: Version é a versão da linguagem; Sid uma etiqueta opcional; Effect Allow ou Deny; Principal quem, apenas em políticas de recurso e de confiança; Action que operações; Resource que objetos, como ARNs; Condition testes adicionais como MFA, IP, hora e etiquetas](../../../assets/diagrams/iam-policy-anatomy.pt.svg)

*Figura 3. Uma declaração responde a quatro perguntas: efeito, quem, o quê e em que recurso, e, opcionalmente, "apenas se".*

| Elemento | Significado |
|---|---|
| `Version` | A versão da linguagem de políticas. Sempre `2012-10-17`: não é uma data que se escolhe, e a mais antiga, `2008-10-17`, não tem funcionalidades como as variáveis de política. |
| `Statement` | Uma declaração ou uma lista. Cada uma é avaliada de forma independente. |
| `Sid` | Etiqueta opcional, útil em auditorias. |
| `Effect` | `Allow` ou `Deny`. Mais nada. |
| `Principal` | Sobre quem é a declaração. Usado apenas em políticas **baseadas em recursos** e de **confiança**; numa política de identidade, o principal é aquele a quem está associada, pelo que o elemento não é permitido aí. |
| `Action` | As operações, escritas como `service:Operation`: `s3:GetObject`, `iam:CreateUser`. Os carateres universais funcionam: `s3:Get*`. |
| `Resource` | A que se aplica a ação, como ARNs. Os carateres universais funcionam. |
| `Condition` | Testes adicionais que têm de ser verdadeiros: o endereço IP de origem, a hora, se foi usado MFA, etiquetas, e mais. |

Há dois detalhes que enganam quase toda a gente:

- **As ações ao nível do bucket e ao nível do objeto precisam de ARNs diferentes.** `s3:ListBucket` aplica-se ao bucket, `arn:aws:s3:::lab-data`. `s3:GetObject` aplica-se aos objetos, `arn:aws:s3:::lab-data/reports/*`. Uma política que ponha `GetObject` no ARN do bucket, ou `ListBucket` em `lab-data/*`, não coincide com nada, sem qualquer aviso.
- **`Action` e `Resource` são avaliados em conjunto.** Uma declaração só se aplica se a ação pedida *e* o recurso pedido coincidirem ambos (e a condição for verdadeira). Um allow para `s3:GetObject` em `reports/*` não diz nada sobre `secret/*`.

Uma **Condition** tem um operador, uma chave de condição e um valor. `Bool` com `aws:MultiFactorAuthPresent` verifica se quem chama iniciou sessão com um segundo fator; `IpAddress` com `aws:SourceIp` limita as chamadas a um intervalo de rede como `203.0.113.0/24`; `DateLessThan` com `aws:CurrentTime` faz o acesso expirar. Um pedido tem de satisfazer todas as condições de uma declaração para que a declaração se aplique.

> [!CHECK]
> Uma declaração tem `"Effect": "Allow"`, `"Action": "s3:GetObject"` e `"Resource": "arn:aws:s3:::lab-data"`. Um utilizador com esta política tenta descarregar `reports/q3.txt` de `lab-data`. Qual é o resultado?
>
> - [ ] Permitido: o utilizador pode ler todo o bucket
> - [x] Negado: `GetObject` atua sobre objetos, pelo que o ARN do recurso precisa de `/*` (ou de um caminho) a seguir ao nome do bucket
> - [ ] Permitido, mas apenas para os objetos da pasta `reports/`
> - [ ] A política é rejeitada como inválida ao ser guardada
>
> O ARN `arn:aws:s3:::lab-data` designa o próprio bucket, não os objetos que contém. A declaração é válida, mas nunca coincide com um pedido a um objeto, pelo que se aplica a negação por omissão.

### Menor privilégio, RBAC e ABAC
O **princípio do menor privilégio** diz que cada principal recebe apenas as permissões de que precisa para a sua tarefa, e apenas durante o tempo de que precisa delas. Limita o **raio de impacto (blast radius)**: se uma credencial for divulgada ou uma pessoa cometer um erro, o dano fica limitado ao que essa identidade podia fazer.

Na prática, aplica-se:
- partindo do zero e acrescentando permissões para uma tarefa conhecida, em vez de partir do administrador e retirar;
- indicando ações e recursos específicos em vez de `*`;
- usando grupos e roles por função profissional em vez de por pessoa;
- acrescentando condições (MFA, rede de origem, hora) para ações sensíveis;
- revendo o que é realmente usado e eliminando o resto.

Há dois modelos para decidir como se atribuem as permissões:

| | **Controlo de acesso baseado em funções (RBAC)** | **Controlo de acesso baseado em atributos (ABAC)** |
|---|---|---|
| Decide por | O role ou o grupo a que o principal pertence | Atributos do principal, do recurso, da ação e do ambiente |
| Exemplo de regra | "Os membros de `analysts` podem ler o bucket de relatórios." | "Um utilizador pode iniciar uma VM se a etiqueta `project` da VM for igual à etiqueta `project` do utilizador." |
| Ponto forte | Fácil de compreender e de auditar; corresponde às funções profissionais. | Escala sem novas políticas: um projeto novo precisa de etiquetas novas, não de roles novos. Granular e dinâmico. |
| Ponto fraco | Os roles multiplicam-se ("explosão de roles") à medida que surgem exceções. | Mais difícil de analisar; depende de atributos fiáveis, pelo que quem pode alterar etiquetas passa a ser uma questão de segurança. |
| Utilização típica | A maioria das cargas de trabalho, um bom ponto de partida. | Ambientes grandes, com várias equipas. |

O ABAC é definido pelo National Institute of Standards and Technology (NIST) dos EUA na Special Publication (SP) 800-162, *Guide to Attribute Based Access Control (ABAC) Definition and Considerations*. A maioria dos ambientes reais combina ambos: roles para a forma geral, atributos para os pormenores. Segue-se uma declaração ABAC ao estilo da AWS, que permite a um principal iniciar e parar apenas as VMs etiquetadas com o seu próprio projeto:

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

`${aws:PrincipalTag/project}` é uma variável de política: a cloud substitui-a, no momento do pedido, pela etiqueta de projeto de quem chama. Uma só declaração serve todos os projetos.

> [!CHECK]
> Uma empresa tem 200 projetos e quer que cada equipa gira apenas os recursos do seu próprio projeto, sem escrever uma política nova para cada projeto. Que abordagem se adequa melhor?
>
> - [ ] Um grupo por projeto, cada um com a sua política escrita à mão
> - [ ] Dar a todos os engenheiros acesso de administrador e confiar neles
> - [x] ABAC: etiquetar principais e recursos com `project`, e permitir as ações quando as etiquetas coincidem
> - [ ] Partilhar uma chave de acesso por equipa
>
> O ABAC compara atributos no momento do pedido, pelo que uma só política cobre todos os projetos. Os grupos por projeto funcionam (RBAC), mas multiplicam as políticas a manter.

### Credenciais temporárias e assumir um role
As chaves de acesso de longa duração são o maior risco isolado no IAM na cloud: não expiram, são copiadas para scripts, portáteis e repositórios, e ninguém repara quando são divulgadas. A solução são as **credenciais temporárias**: um conjunto formado por um ID de chave de acesso, um segredo e um **token de sessão** que deixa de funcionar passado pouco tempo, de minutos a algumas horas.

Obtêm-se **assumindo um role**, através de um **serviço de tokens de segurança**: uma API do tipo STS (AWS Security Token Service). O role tem dois tipos de política:

- Uma **política de confiança** diz *quem pode assumir o role* (o elemento principal, como no exemplo da Figura 3).
- Uma **política de permissões** diz *o que o role pode fazer* depois de assumido.

![Sequência entre a Carol, uma utilizadora IAM, o serviço de tokens (STS) e o bucket lab-data. 1. A Carol chama AssumeRole para o role reader, assinado com a sua própria chave; o STS verifica a política de confiança e a permissão dela. 2. O STS devolve credenciais temporárias: uma chave de acesso que começa por ASIA, um segredo e um token de sessão, a expirar em 900 segundos. 3. A Carol chama GetObject em reports/q3.txt com as credenciais temporárias; o armazenamento avalia a política do role e responde 200 OK. Um PutObject em reports/c.txt recebe 403 AccessDenied porque o role é só de leitura. Na expiração, as credenciais deixam de funcionar, pelo que não há nada a revogar nem a rodar](../../../assets/diagrams/iam-assume-role.pt.svg)

*Figura 4. Enquanto a sessão dura, a Carol atua como o role, com as permissões do role e não as suas. Quando expira, o acesso termina por si.*

A identidade de quem chama muda: depois de `AssumeRole`, a API indica quem chama como `arn:aws:sts::123456789012:assumed-role/reader/carol-lab`, e não como o utilizador. Os registos de auditoria guardam o nome da sessão, pelo que ainda se consegue saber quem fez o quê. As chaves de acesso que começam por `AKIA` são de longa duração; as que começam por `ASIA` são temporárias e precisam também do token de sessão.

Assumir roles é também a forma de uma pessoa obter acesso elevado apenas quando é necessário (acesso de emergência, "break glass", ou just-in-time), e a forma de as cargas de trabalho receberem credenciais da plataforma: um perfil de instância numa VM, uma conta de serviço associada a um pod do Kubernetes, ou uma identidade gerida no Azure. O programa pede credenciais novas a um endpoint de metadados local; não se guarda nenhum segredo em lado nenhum.

> [!NOTE]
> A política de confiança do role indica quem *pode* assumi-lo. Na AWS real, uma política de confiança que indique um utilizador ou um role específico da mesma conta basta por si só. Se indicar a conta inteira (`arn:aws:iam::<account-id>:root`), cada principal precisa também de uma política de identidade que permita `sts:AssumeRole`. Muitas organizações acrescentam, mesmo assim, uma política de identidade que permite `sts:AssumeRole` no role específico, para que a permissão fique visível também no principal. O laboratório faz isto, porque o emulador o exige.

> [!CHECK]
> Qual das afirmações sobre as credenciais temporárias de `AssumeRole` é verdadeira?
>
> - [ ] Mantêm as permissões do utilizador que as pediu
> - [ ] Nunca expiram enquanto o role existir
> - [x] Transportam as permissões do role e deixam de funcionar passado um tempo definido
> - [ ] Só são válidas em conjunto com a palavra-passe do utilizador
>
> A sessão atua como o role, pelo que se aplicam as permissões do role, não as de quem chama. A expiração está incorporada nas credenciais e no token de sessão.

### Federação: SAML 2.0 e OpenID Connect
Criar um utilizador na cloud separado para cada colaborador, cada prestador de serviços e cada pipeline não escala, e as palavras-passe e as chaves acumulam-se. A **federação** permite que a cloud confie num **fornecedor de identidade (IdP, identity provider)** externo: o diretório da empresa, um início de sessão social ou um sistema de CI. O utilizador inicia sessão no IdP, e o IdP garante por ele com um token assinado. A cloud nunca vê a palavra-passe; limita-se a verificar o token e a associar o utilizador a um role.

![Sequência da federação entre um utilizador ou carga de trabalho, o fornecedor de identidade, o IAM da cloud com o seu serviço de tokens e um recurso da cloud. 1. O utilizador inicia sessão no IdP com palavra-passe e MFA, ou uma tarefa de CI apresenta o seu próprio token. 2. O IdP devolve um token assinado: um token de ID OIDC (JWT) ou uma asserção SAML 2.0. 3. O utilizador troca o token por um role com AssumeRoleWithWebIdentity ou AssumeRoleWithSAML; o IAM da cloud verifica a assinatura com a chave pública do IdP, confirma o emissor, o destinatário e a expiração, e compara com a política de confiança do role. 4. Voltam credenciais temporárias, válidas de minutos a horas. 5. O utilizador chama o recurso da cloud com elas, permitido pela política do role](../../../assets/diagrams/iam-federation.pt.svg)

*Figura 5. O fornecedor de identidade autentica; a cloud autoriza. O resultado são credenciais temporárias, sem nenhuma chave de longa duração em lado nenhum.*

Dois padrões dominam:

| | **SAML 2.0** | **OpenID Connect (OIDC)** |
|---|---|---|
| Nome completo | Security Assertion Markup Language 2.0 (norma OASIS) | OpenID Connect Core 1.0 |
| Token | Uma **asserção**: um documento assinado em Extensible Markup Language (XML) | Um **token de ID**: um JSON Web Token (JWT, RFC 7519) assinado |
| Assenta em | XML e redirecionamentos do navegador | OAuth 2.0 (RFC 6749), acrescentando uma camada de autenticação |
| Utilização típica | Início de sessão único (SSO) empresarial para pessoas na consola | Aplicações web e móveis, e **federação de identidade de cargas de trabalho** para pipelines e programas |
| Exemplo | Um colaborador inicia sessão no portal da empresa e chega à consola da cloud | Uma tarefa de CI prova "sou o ramo `main` deste repositório" e recebe um role para uma implementação |

O OAuth 2.0, só por si, trata de *autorização delegada* (deixar uma aplicação agir em seu nome), não de provar quem se é. O OIDC acrescenta-lhe a camada de identidade que falta.

A federação de identidade de cargas de trabalho substitui a chave de implementação armazenada. Uma plataforma de CI emite, para cada tarefa, um token OIDC de curta duração cujas declarações (claims) dizem de onde vem, por exemplo `sub: repo:example-org/example-repo:ref:refs/heads/main`. A política de confiança do role da cloud aceita apenas esse emissor, esse destinatário e esse sujeito. Outro repositório, ou outro ramo, não consegue assumir o role.

> [!CHECK]
> O que verifica uma cloud quando recebe um token de ID OIDC ou uma asserção SAML de um fornecedor de identidade?
>
> - [ ] A palavra-passe do utilizador, que o fornecedor de identidade reencaminha
> - [x] A assinatura (com a chave pública do IdP), o emissor, o destinatário e a expiração, e depois a política de confiança do role
> - [ ] Apenas que o token é um documento JSON ou XML bem formado
> - [ ] Que o utilizador tem uma chave de acesso na conta da cloud
>
> A cloud confia na assinatura do IdP, não numa palavra-passe. Continua a verificar que o token se destina a ela, que ainda é válido e que corresponde à política de confiança do role.

### Autenticação multifator
A **autenticação multifator (MFA, multi-factor authentication)** exige duas ou mais provas de tipos diferentes: algo que se sabe, algo que se tem e algo que se é. Uma palavra-passe roubada, só por si, já não abre a porta. Os segundos fatores mais comuns, do mais fraco ao mais forte:

- **Códigos por SMS.** Melhor do que nada, mas vulneráveis a troca de SIM (SIM swapping) e a interceção.
- **Palavras-passe de utilização única baseadas no tempo (TOTP, RFC 6238)** a partir de uma aplicação de autenticação. Vulneráveis a phishing: um site falso pode pedir o código e reutilizá-lo de imediato.
- **Chaves de hardware FIDO2 / WebAuthn e passkeys.** A chave assina um desafio que inclui o nome do site verdadeiro, pelo que um site falso não obtém nada de útil. Esta é a MFA **resistente a phishing**.

Deve exigir-se MFA a todos os utilizadores humanos, sempre ao utilizador raiz e para ações sensíveis através de uma condição (`aws:MultiFactorAuthPresent`). Os programas não podem usar MFA, o que é mais uma razão para lhes dar credenciais temporárias em vez de chaves.

> [!CHECK]
> Porque é que uma chave de segurança FIDO2 é considerada mais forte do que um código TOTP de uma aplicação?
>
> - [ ] O código é mais longo, pelo que é mais difícil de adivinhar
> - [ ] A chave funciona sem Internet, pelo que ninguém a pode intercetar
> - [x] A chave assina um desafio associado ao site genuíno, pelo que um site de phishing não o consegue reutilizar
> - [ ] A cloud guarda o segredo da chave para a poder repor
>
> Um código TOTP pode ser escrito numa página falsa e reutilizado. Uma resposta FIDO2 está ligada à origem do site verdadeiro, pelo que uma cópia não tem valor noutro lado.

## Como funciona
Acompanhe-se um pedido do princípio ao fim. O Bob, cujo utilizador tem a política de menor privilégio do laboratório, executa `aws s3api get-object --bucket lab-data --key reports/q3.txt`:

1. **Assinar.** A ferramenta de linha de comandos constrói o pedido HTTP e assina-o com a chave secreta do Bob. O ID da chave de acesso vai no pedido; o segredo não.
2. **Autenticar.** O serviço procura o ID da chave de acesso, volta a calcular a assinatura com o segredo correspondente e compara. Uma divergência ou uma chave desconhecida termina o pedido com um erro de autenticação.
3. **Construir o contexto.** O serviço regista quem (`arn:aws:iam::123456789012:user/bob`), o quê (`s3:GetObject`), em que recurso (`arn:aws:s3:::lab-data/reports/q3.txt`) e o ambiente (endereço IP de origem, hora, se foram usados MFA e TLS).
4. **Reunir as políticas.** As políticas do utilizador do Bob, as dos seus grupos, a política de bucket de `lab-data` e quaisquer barreiras de proteção da organização.
5. **Avaliar.** Procura-se um `Deny` coincidente: nenhum. Procura-se um `Allow` coincidente: a declaração para `GetObject` em `lab-data/reports/*` coincide. Resultado: permitir.
6. **Agir e registar.** O objeto é devolvido, e o registo de auditoria guarda a chamada com o principal, a ação, o recurso, o endereço IP de origem e o resultado.

> [!CHECK]
> Qual dos passos da vida de um pedido acontece primeiro?
>
> - [ ] A cloud reúne as políticas que se aplicam
> - [ ] A cloud procura um deny explícito coincidente
> - [x] A cloud autentica quem chama a partir da assinatura ou do token
> - [ ] A cloud verifica se o role de quem chama expirou
>
> As políticas são avaliadas para um principal *conhecido*, pelo que a autenticação vem sempre primeiro. Uma sessão expirada falha nesse mesmo passo de autenticação.

## Exemplo prático
Gere-se o bucket `lab-data`, com dois prefixos, `reports/` e `secret/`. O Bob tem esta política de identidade (é a que se constrói no laboratório):

```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": "*" }
  ]
}
```

O bucket tem também uma política de recurso que recusa qualquer pedido que não esteja cifrado em trânsito (uma base 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" } }
    }
  ]
}
```

Preveja-se o resultado de cada pedido do Bob e depois verifique-se o raciocínio:

| # | Pedido | Resultado | Porquê |
|---|---|---|---|
| 1 | `GetObject` `reports/q3.txt` por HTTPS | **Permitido** | `EverythingInReports` permite-o; nenhum deny coincide (`SecureTransport` é verdadeiro, pelo que `DenyPlainHttp` não se aplica). |
| 2 | `GetObject` `reports/q3.txt` por HTTP simples | **Negado** | `DenyPlainHttp` coincide: o deny explícito prevalece sobre o allow. |
| 3 | `PutObject` `reports/q4.txt` por HTTPS | **Permitido** | `s3:*` em `reports/*` cobre-o. |
| 4 | `DeleteObject` `reports/q3.txt` por HTTPS | **Negado** | `NeverDelete` é um deny explícito; prevalece sobre o allow `s3:*`. |
| 5 | `GetObject` `secret/passwords.txt` por HTTPS | **Negado** | Nenhuma declaração permite `secret/*`: negação por omissão. |
| 6 | `ListBucket` em `lab-data` | **Permitido** | `ListTheBucket` permite-o, para todo o bucket: o Bob vê também os *nomes* dos objetos em `secret/`. |

A linha 6 é uma surpresa clássica. Listar é uma ação ao nível do bucket, pelo que esta política não a consegue limitar a `reports/` apenas pelo recurso. Nas clouds reais, acrescenta-se uma `Condition` sobre o prefixo da chave (na AWS, `s3:prefix`) para a restringir.

## Erros comuns
- **Pôr `*` em `Action` ou `Resource` "para funcionar"** — funciona porque permite tudo. Descubra-se a ação exata a partir do erro ou do registo de auditoria e indique-se.
- **Confundir o ARN do bucket com o ARN do objeto** — `ListBucket` precisa de `arn:aws:s3:::name`, `GetObject` precisa de `arn:aws:s3:::name/*`. Se uma metade de uma política funciona e a outra não, verifique-se isto primeiro.
- **Esperar que um allow posterior ou mais restrito anule um deny** — nunca anula. Para repor o acesso, é preciso remover ou restringir o deny.
- **Esquecer que um grupo não é uma identidade** — não se pode iniciar sessão como um grupo, nem indicá-lo como `Principal` de uma política de recurso ou de confiança. Associam-se-lhe políticas e os seus membros herdam-nas.
- **Testar com a identidade de administrador** — pode fazer tudo, pelo que nunca se vê a permissão em falta. Teste-se com a identidade que realmente vai executar a tarefa.
- **Assumir que as condições são sempre aplicadas por todas as ferramentas** — alguns emuladores e alguns serviços parcialmente compatíveis com S3 ignoram-nas. Testem-se as condições no serviço real antes de contar com elas.

## Considerações de segurança
A maioria das violações na cloud começa na identidade, não numa vulnerabilidade de software. Estes são os erros que surgem uma e outra vez, e a forma de os encontrar.

### Erros habituais
- **Políticas com carateres universais.** `"Action": "*"` em `"Resource": "*"` transforma cada credencial que a transporte numa chave-mestra. Mesmo `s3:*` em `*` permite ao titular ler, alterar e eliminar todos os buckets da conta.
- **Chaves de longa duração e divulgadas.** Chaves de acesso submetidas em repositórios, coladas em chats, incorporadas em imagens de contentores ou deixadas numa variável de CI durante anos. Os repositórios públicos são analisados à procura de chaves, muitas vezes minutos depois de um push. Prefiram-se roles, federação e credenciais temporárias; quando uma chave é inevitável, deve rodar-se e limitar-se com condições.
- **Contas e credenciais sem uso.** Antigos colaboradores, utilizadores de teste abandonados e chaves antigas continuam válidos até alguém os eliminar. Cada identidade sem uso é uma entrada não monitorizada.
- **Usar a conta raiz ou de proprietário no dia a dia.** Não pode ser restringida. Proteja-se com uma palavra-passe forte e MFA resistente a phishing, não se lhe dê chaves de acesso e reserve-se para as poucas tarefas que a exigem.
- **Sem MFA, ou com MFA fraca.** Uma palavra-passe roubada equivale então a um comprometimento total. Exija-se MFA a todos os humanos, e prefira-se FIDO2 para os administradores.
- **Políticas de confiança demasiado abrangentes.** Um role que confia numa conta inteira, ou em `"Principal": "*"`, pode ser assumido por qualquer pessoa dessa conta, ou por qualquer pessoa de todo. Indique-se o principal exato e, na federação, o emissor, o destinatário e o sujeito exatos.
- **Permissões concedidas através da capacidade de alterar permissões.** Um principal com permissão para `iam:PutUserPolicy`, ou `iam:AttachUserPolicy`, pode atribuir-se direitos de administrador. Tratem-se as ações de escrita do IAM como ações ao nível de administrador.

### Deteção
- **Registos de auditoria.** Cada chamada à API é registada com quem, o quê, quando e a partir de onde: AWS CloudTrail, Azure Activity Log e os registos de início de sessão do Microsoft Entra, Google Cloud Audit Logs. Guardem-se numa conta separada e protegida contra escrita, e definam-se alertas para eventos sensíveis: utilização do utilizador raiz, início de sessão na consola sem MFA, chaves de acesso novas, alterações de políticas, chamadas a partir de países invulgares.
- **Revisões de acessos.** Periodicamente (a cada trimestre é habitual), o proprietário de cada recurso confirma quem ainda precisa de acesso, e removem-se os restantes. Incluam-se as contas de serviço e as relações de confiança entre contas, que se esquecem com facilidade.
- **Relatórios de higiene de credenciais.** Listem-se os utilizadores, as chaves, a sua idade e a última utilização (o laboratório usa `get-access-key-last-used`). Eliminem-se as chaves que ninguém usou durante 90 dias, rodem-se as que têm de ficar, e comparem-se as permissões concedidas com as permissões usadas; a maioria das clouds consegue sugerir uma política mais restrita a partir do registo de atividade (por exemplo, o IAM Access Analyzer na AWS, as ferramentas de análise de políticas no Google Cloud).
- **Rotação de chaves.** Crie-se a chave nova, passe-se a aplicação para ela, verifique-se que a chave antiga já não é usada e só então se elimine. Em nenhum momento é preciso parar a aplicação. A rotação encurta a vida de uma fuga, mas não elimina a necessidade de evitar chaves de longa duração.
- **Análise de segredos.** Analisem-se repositórios e imagens à procura de chaves antes de serem enviados, e trate-se qualquer chave que alguma vez chegou a um local público como comprometida: elimine-se, não se limite a reescrever o histórico.

> [!WARNING]
> Se uma chave de acesso for divulgada, desative-a ou elimine-a de imediato e, depois, reveja o registo de auditoria para ver o que fez entre a fuga e a revogação. Alterar o código ou apagar o repositório não desfaz a exposição.

## Resumo
- O IAM responde a duas perguntas: quem é você (autenticação) e o que lhe é permitido fazer (autorização). `AccessDenied` significa que a autenticação teve êxito e a autorização não.
- Um pedido só é permitido se alguma declaração o permitir e nenhuma o negar: negação por omissão, allow explícito, o deny explícito prevalece.
- Uma declaração de política JSON tem um efeito, um principal (em políticas de recurso e de confiança), ações, recursos e condições opcionais. Atenção à diferença entre ARNs de bucket e de objeto.
- Aplique-se o menor privilégio: ações e recursos específicos, âmbitos restritos, grupos e roles, condições e revisões regulares. Use-se RBAC para a forma geral e ABAC para regras finas e escaláveis.
- Preferem-se roles e credenciais temporárias (um `AssumeRole` do tipo STS) a chaves de longa duração, e federam-se pessoas e pipelines com SAML 2.0 ou OpenID Connect, para que a cloud nunca guarde as suas palavras-passe.
- Exija-se MFA, proteja-se a conta raiz, eliminem-se as identidades sem uso, rodem-se as chaves inevitáveis e vigiem-se os registos de auditoria.

## Glossário
| Termo | Definição |
|---|---|
| Gestão de identidades e acessos (IAM, Identity and Access Management) | O serviço e a disciplina da cloud que decide quem está a fazer o pedido e o que essa entidade pode fazer. |
| Identidade | Um ator reconhecido num sistema: uma pessoa, um programa ou um role. |
| Principal | Qualquer identidade que possa fazer um pedido: utilizador, membro de grupo, sessão de role ou conta de serviço. |
| Utilizador | Uma identidade nomeada para uma pessoa, com credenciais como uma palavra-passe e chaves de acesso. |
| Grupo | Um conjunto de utilizadores a que se associam políticas; os membros herdam-nas. Não pode fazer pedidos por si. |
| Role | Uma identidade com permissões mas sem credenciais permanentes, assumida temporariamente. |
| Conta de serviço | Uma identidade não humana para uma aplicação, VM ou pipeline. Também chamada identidade de carga de trabalho ou identidade de máquina. |
| Utilizador raiz | A identidade todo-poderosa criada com a conta (proprietário ou administrador global noutras clouds). |
| Amazon Resource Name (ARN) | O nome único de um recurso ou principal na AWS, como `arn:aws:iam::123456789012:user/bob`. |
| Chave de acesso | Um par de chaves (ID e segredo) que assina pedidos à API. De longa duração, salvo se emitida como parte de credenciais temporárias. |
| Autenticação (authN) | Provar quem é quem chama. |
| Autorização (authZ) | Decidir o que um chamador autenticado pode fazer. |
| Política | Um documento que lista ações permitidas ou negadas em recursos. |
| Política baseada em identidade | Uma política associada a um utilizador, grupo ou role. |
| Política baseada em recursos | Uma política associada a um recurso, como uma política de bucket; indica os principais a que se aplica. |
| Negação por omissão | A regra de que tudo o que não é explicitamente permitido é negado. |
| Deny explícito | Uma declaração com `Effect: Deny`; sobrepõe-se a qualquer allow. |
| Declaração | Uma regra numa política: efeito, principal, ação, recurso e condição opcional. |
| Condição | Um teste adicional numa declaração (MFA, intervalo de IP, hora, etiquetas) que tem de ser verdadeiro para que ela se aplique. |
| Barreira de proteção (guardrail) | Um limite ao nível da organização (como os limites de permissões ou as políticas de controlo de serviços) que fixa o máximo que os principais podem alguma vez receber. |
| Princípio do menor privilégio | Dar a cada principal apenas as permissões de que precisa, durante o tempo de que precisa delas. |
| Raio de impacto (blast radius) | A quantidade de dano possível se uma identidade ou credencial for comprometida. |
| Controlo de acesso baseado em funções (RBAC) | Conceder permissões de acordo com os roles ou grupos a que um principal pertence. |
| Controlo de acesso baseado em atributos (ABAC) | Conceder permissões comparando atributos do principal, do recurso, da ação e do ambiente (NIST SP 800-162). |
| Credenciais temporárias | Uma chave de acesso, um segredo e um token de sessão que expiram passado pouco tempo. |
| Token de sessão | O valor adicional que tem de acompanhar as credenciais temporárias em cada pedido. |
| Serviço de tokens de segurança (STS) | A API que emite credenciais temporárias, por exemplo através de `AssumeRole`. |
| Assumir um role | Trocar a sua identidade por credenciais temporárias com as permissões de um role. |
| Política de confiança | A política de um role que diz quem o pode assumir. |
| Federação | Confiar num fornecedor de identidade externo para autenticar utilizadores, para que a cloud não guarde palavras-passe deles. |
| Fornecedor de identidade (IdP) | O sistema que autentica utilizadores e emite tokens ou asserções assinados. |
| SAML 2.0 | Uma norma baseada em XML para asserções assinadas, muito usada no início de sessão único empresarial. |
| OpenID Connect (OIDC) | Uma camada de autenticação sobre o OAuth 2.0 que emite tokens de ID JWT assinados. |
| Federação de identidade de cargas de trabalho | Deixar uma pipeline ou programa trocar um token de curta duração da sua plataforma por credenciais da cloud, sem chave armazenada. |
| Autenticação multifator (MFA) | Autenticação que exige dois ou mais tipos de prova. |
| MFA resistente a phishing | MFA, como as chaves FIDO2, cuja resposta está ligada ao site genuíno e não pode ser reutilizada a partir de um site falso. |
| Registo de auditoria | O registo das chamadas à API: quem, o quê, quando, a partir de onde e o resultado. |
| Revisão de acessos | Uma verificação periódica de que cada identidade ainda precisa do acesso que tem. |
| Rotação de chaves | Substituir uma credencial por uma nova e retirar a antiga. |

## Verifique o que aprendeu
1. A política de um colega tem `"Action": "s3:*"` e `"Resource": "*"` "porque era a única forma de o script de carregamento funcionar". Explique como encontraria as permissões reais de que o script precisa e escreveria uma substituição de menor privilégio.
2. Um utilizador está em dois grupos. O grupo A permite `s3:GetObject` em `reports/*`. O grupo B tem um `Deny` explícito para `s3:*` em todo o bucket para quem não tenha MFA. O que pode o utilizador fazer quando inicia sessão sem MFA, e com MFA? Que elemento faz a diferença?
3. Desenhe o acesso de uma pipeline de CI que implementa na sua conta da cloud. Que principal, que credenciais, que condições de confiança? O que remove em comparação com guardar uma chave de acesso numa variável de CI?
4. Explique, por palavras suas, porque é que `AccessDenied` e `InvalidClientTokenId` apontam para problemas diferentes, e o que verificaria em cada caso.
5. A sua empresa tem 40 programadores e 5 equipas. Quando escolheria RBAC, quando ABAC, e o que é preciso controlar para que o ABAC seja seguro?
6. Descobre que uma chave de acesso de um colaborador que saiu há um ano foi usada pela última vez ontem. Descreva, por ordem, o que faria na primeira hora.

## Referências
- [NIST SP 800-162](https://csrc.nist.gov/pubs/sp/800/162/upd2/final) — Guide to Attribute Based Access Control (ABAC) Definition and Considerations.
- [NIST SP 800-63-4](https://pages.nist.gov/800-63-4/) — Digital Identity Guidelines (authentication, federation).
- [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.
- [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.
- [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/) — lógica de avaliação de políticas, referência de políticas e credenciais temporárias.
- [Google Cloud IAM overview](https://cloud.google.com/iam/docs/overview), [Azure RBAC overview](https://learn.microsoft.com/azure/role-based-access-control/overview) e [OpenStack Keystone](https://docs.openstack.org/keystone/latest/) — os mesmos conceitos noutros fornecedores.
