---
title: "IAM w chmurze: kto co może zrobić"
domain: cloud-computing
level: intermediate
duration: "50 min"
objectives:
  - "Wyjaśnić podstawowe elementy IAM w chmurze: podmioty (użytkownicy, grupy, role, konta usług), uwierzytelnianie a autoryzacja oraz sposób oceny żądania."
  - "Czytać i pisać polityki dostępu JSON z akcjami, zasobami, efektami i warunkami oraz przewidywać wynik, gdy instrukcje zezwalające i odmowne nakładają się na siebie."
  - "Stosować zasadę najmniejszych uprawnień i porównać kontrolę dostępu opartą na rolach (RBAC) z opartą na atrybutach (ABAC)."
  - "Wyjaśnić poświadczenia tymczasowe i federację (SAML 2.0, OpenID Connect) oraz dlaczego są bezpieczniejsze niż długotrwałe klucze dostępu."
  - "Ocenić typowe błędy IAM (polityki z symbolami wieloznacznymi, wyciekłe klucze, nieużywane konta, brak MFA) i sposoby ich wykrywania."
lang: pl
source_hash: 3b4a802e0a01
---

# IAM w chmurze: kto co może zrobić

## Dlaczego to ważne
W piątkowe popołudnie programistka wysyła małą poprawkę do publicznego repozytorium kodu. W commicie ukryty jest plik z kluczem dostępu do chmury, tym, który dwa lata temu utworzyła „tylko po to, żeby coś przetestować”. Po kilku minutach znajdują go automatyczne skanery. W sobotę rano konto uruchamia setki serwerów dla koparki kryptowalut, a bucket z eksportami danych klientów został skopiowany gdzie indziej. Nikt nikogo nie „zhakował” w filmowym sensie: atakujący po prostu poprosił chmurę o wykonanie operacji, a chmura sprawdziła, że klucz jest ważny i że przypisana do niego polityka na to zezwala. Zezwalała, bo klucz należał do administratora.

W chmurze konsola i interfejs programistyczny aplikacji (API, Application Programming Interface) są dostępne z dowolnego miejsca w Internecie. Nie ma biurowej sieci, za którą można się schować, więc prawdziwym perymetrem staje się **tożsamość**. **Zarządzanie tożsamościami i dostępem (IAM, Identity and Access Management)** to ta część każdej chmury, która decyduje, kto wysyła żądanie i co może zrobić. Dobre opanowanie IAM pozwala nadać każdej osobie i każdemu programowi dokładnie taki dostęp, jakiego potrzebują, najlepiej na kilka minut, a nie na zawsze, oraz przeczytać cudzą politykę i wiedzieć, na co naprawdę zezwala.

## Cele nauki
- Wyjaśnić podstawowe elementy IAM w chmurze: podmioty (użytkownicy, grupy, role, konta usług), uwierzytelnianie a autoryzacja oraz sposób oceny żądania.
- Czytać i pisać polityki dostępu JSON z akcjami, zasobami, efektami i warunkami oraz przewidywać wynik, gdy instrukcje zezwalające i odmowne nakładają się na siebie.
- Stosować zasadę najmniejszych uprawnień i porównać kontrolę dostępu opartą na rolach (RBAC) z opartą na atrybutach (ABAC).
- Wyjaśnić poświadczenia tymczasowe i federację (SAML 2.0, OpenID Connect) oraz dlaczego są bezpieczniejsze niż długotrwałe klucze dostępu.
- Ocenić typowe błędy IAM (polityki z symbolami wieloznacznymi, wyciekłe klucze, nieużywane konta, brak MFA) i sposoby ich wykrywania.

## Kluczowe pojęcia

### Podmioty: kto wysyła żądanie?
Wyobraź sobie budynek z czytnikami kart przy każdych drzwiach. Każda karta należy do kogoś lub do czegoś, a każde drzwi mają regułę, które karty je otwierają. W chmurze posiadaczem karty jest **podmiot (principal)**: każda tożsamość, która może wysłać żądanie do chmury i zostać rozpoznana. Większość chmur oferuje te same cztery rodzaje:

| Podmiot | Czym jest | Typowe zastosowanie |
|---|---|---|
| **Użytkownik (user)** | Nazwana tożsamość jednej osoby, zwykle z hasłem i drugim składnikiem. Może mieć też **klucze dostępu (access keys)** do wiersza poleceń i programów. | Inżynier, który loguje się do konsoli. |
| **Grupa (group)** | Zbiór użytkowników. Grupa sama nie jest podmiotem: nie można zalogować się jako grupa. Przypisuje się do niej polityki, a każdy członek je dziedziczy. | `analysts`, `network-admins`. |
| **Rola (role)** | Tożsamość z uprawnieniami, ale **bez hasła i bez stałych kluczy**. Ktoś lub coś ją *przyjmuje (assume)* i otrzymuje poświadczenia tymczasowe. | Osoba, która potrzebuje podwyższonego dostępu na godzinę; serwer; użytkownik z innego konta. |
| **Konto usługi (service account)** (nazywane też tożsamością obciążenia lub tożsamością maszynową) | Tożsamość programu, a nie osoby: aplikacji, maszyny wirtualnej (VM), kontenera, pipeline'u. | Aplikacja WWW, która odczytuje bucket. |

![Przegląd IAM w chmurze. Po lewej podmioty: użytkownik (osoba z hasłem i MFA), grupa (zbiór użytkowników, polityki przypisane raz), rola (przyjmowana tymczasowo, bez hasła i klucza) i konto usługi (tożsamość aplikacji lub VM). W środku mechanizm autoryzacji: uwierzytelnia wywołującego, ocenia polityki, zezwala lub odmawia; odczytuje polityki pod sobą, politykę tożsamości przypisaną do podmiotu i politykę zasobu przypisaną do zasobu. Po prawej zasoby: bucket lab-data z ARN arn:aws:s3:::lab-data oraz maszyna wirtualna, osiągalne tylko wtedy, gdy żądanie jest dozwolone. Pasek na dole pokazuje, co niesie żądanie: podmiot, akcję s3:GetObject, zasób arn:aws:s3:::lab-data/reports/q3.txt oraz kontekst, taki jak czas, źródłowy adres IP i MFA](../../../assets/diagrams/iam-who-what-resource.pl.svg)

*Rysunek 1. Każde żądanie niesie podmiot, akcję, zasób i trochę kontekstu; mechanizm autoryzacji porównuje je z politykami i odpowiada: zezwolić lub odmówić.*

Każdy podmiot ma unikalną nazwę w formacie dostawcy. W Amazon Web Services (AWS) jest to **Amazon Resource Name (ARN)**, na przykład `arn:aws:iam::123456789012:user/bob`: `arn`, partycja, usługa, region (w IAM pusty), identyfikator konta i zasób. Inni dostawcy używają własnych formatów (adres w stylu e-mail dla konta usługi Google Cloud, identyfikator obiektu w Microsoft Entra), ale idea jest ta sama.

Na szczycie każdego konta stoi jeszcze jedna tożsamość: **użytkownik root** (na innych chmurach zwany właścicielem lub administratorem globalnym). Powstaje razem z kontem, może wszystko i nie da się go ograniczyć zwykłymi politykami. Chroni się go i prawie nigdy nie używa.

> [!NOTE]
> Ten moduł używa słownictwa i składni polityk AWS IAM, ponieważ jest najszerzej zaimplementowana: wiele usług magazynowania zgodnych z S3 u innych dostawców akceptuje ten sam JSON polityk bucketów, a narzędzia open source ją emulują, dlatego laboratorium może działać na Twoim laptopie. Inni dostawcy używają innych słów na te same idee: Google Cloud IAM wiąże role z członkami na zasobie, Microsoft Azure przypisuje role za pomocą kontroli dostępu opartej na rolach w danym zakresie, a OpenStack Keystone wydaje tokeny użytkownikom w projektach. Tam, gdzie to ważne, lekcja wskazuje różnice.

> [!CHECK]
> Firma chce, aby aplikacja WWW działająca na VM odczytywała pliki z bucketu, bez przechowywania na VM jakiegokolwiek hasła ani klucza. Który podmiot pasuje najlepiej?
>
> - [ ] Użytkownik aplikacji z kluczem dostępu zapisanym w pliku konfiguracyjnym
> - [ ] Grupa, bo grupy mogą zawierać polityki dla wielu programów
> - [x] Rola (lub konto usługi) przypisana do VM, która daje jej poświadczenia tymczasowe
> - [ ] Użytkownik root, bo nigdy nie potrzebuje polityki
>
> Rola lub konto usługi nie ma hasła i automatycznie wydaje krótkotrwałe poświadczenia. Grupa nie może być wywołującym, a użytkownik root jest znacznie zbyt potężny.

### Uwierzytelnianie a autoryzacja
Przy każdym żądaniu padają dwa różne pytania, a ich mylenie jest początkiem wielu błędnych konfiguracji.

- **Uwierzytelnianie (authN, authentication)** odpowiada na pytanie „kim jesteś?”. Wywołujący potwierdza tożsamość czymś, co wie (hasło), co ma (klucz sprzętowy, telefon) lub czym jest (odcisk palca), a w przypadku programów podpisem kryptograficznym lub tokenem.
- **Autoryzacja (authZ, authorization)** odpowiada na pytanie „co możesz robić?”. Chmura porównuje uwierzytelniony podmiot, żądaną akcję i docelowy zasób z politykami.

Uwierzytelnianie zawsze jest pierwsze, a jego przejście samo w sobie niczego nie daje. Różnicę widać w komunikacie o błędzie. Żądanie z nieznanym lub unieważnionym kluczem kończy się niepowodzeniem uwierzytelniania (w laboratorium: `InvalidClientTokenId`). Ważny klucz bez uprawnień kończy się niepowodzeniem autoryzacji (`AccessDenied`). Gdy widać `AccessDenied`, chmura dokładnie wie, kim jesteś, i zdecydowała, że nie możesz tego zrobić.

Programy zwykle uwierzytelniają się przez **podpisywanie** każdego żądania tajnym kluczem, na przykład za pomocą AWS Signature Version 4: sam sekret nigdy nie podróżuje po sieci, tylko podpis obliczony z żądania, który dodatkowo uniemożliwia jego zmianę w drodze. Tokeny działają inaczej: token to podpisane oświadczenie, ważne przez ograniczony czas, które odbiorca może sprawdzić bez odpytywania kogokolwiek.

> [!CHECK]
> Skrypt dostaje `AccessDenied` przy próbie wylistowania bucketu. Co mówi ten błąd?
>
> - [ ] Klucz dostępu jest nieprawidłowy lub został usunięty
> - [x] Chmura uwierzytelniła wywołującego, ale żadna polityka nie zezwala na tę akcję na tym zasobie
> - [ ] Żądanie zostało zmodyfikowane w drodze
> - [ ] Wywołujący musi zalogować się ponownie hasłem
>
> `AccessDenied` to wynik autoryzacji: tożsamość została rozpoznana. Nieprawidłowy lub nieznany klucz zawiódłby wcześniej, na etapie uwierzytelniania, z innym błędem.

### Jak oceniane jest żądanie
Gdy wywołujący jest uwierzytelniony, chmura ocenia **polityki (policies)**: dokumenty, które wymieniają, na co zezwala się lub czego odmawia. Znaczenie mają dwie rodziny:

- **Polityki oparte na tożsamości (identity-based policies)** są przypisane do podmiotu (użytkownika, grupy lub roli): „Bob może czytać folder reports”.
- **Polityki oparte na zasobie (resource-based policies)** są przypisane do zasobu, na przykład polityka bucketu: „Rola Carol może czytać ten bucket”. Wskazują podmiot, którego dotyczą.

Reguły oceny są proste i takie same w każdej dużej chmurze:

1. **Domyślna odmowa (default deny).** Jeśli nic nie wspomina o żądaniu, jest ono odrzucane. Uprawnienia nigdy nie są domniemane.
2. **Jawny allow.** Pasująca instrukcja z efektem `Allow` zezwala na żądanie.
3. **Jawny deny wygrywa.** Pasująca instrukcja z efektem `Deny` blokuje żądanie, nawet jeśli dziesięć innych instrukcji na nie zezwala.

![Ocena polityki w czterech krokach: uwierzytelnienie (potwierdź, kim jesteś, podpisem, tokenem lub hasłem; niepowodzenie odrzuca żądanie), zebranie polityk (polityki tożsamości podmiotu oraz polityka zasobu docelowego), czy istnieje jawny Deny (tak: ODRZUCONE, koniec), czy istnieje jawny Allow (tak: DOZWOLONE, nie: ODRZUCONE). Poniżej trzy wyniki: pasujący Deny oznacza ODRZUCONE i zawsze wygrywa; pasujący Allow bez Deny oznacza DOZWOLONE; brak jakiegokolwiek dopasowania oznacza ODRZUCONE domyślnie](../../../assets/diagrams/iam-evaluation-flow.pl.svg)

*Rysunek 2. Deny wygrywa z allow, a brak reguły to odmowa. Ta kolejność nigdy się nie zmienia, niezależnie od tego, ile polityk obowiązuje.*

W obrębie jednego konta wystarczy allow w *którejkolwiek* z polityk, tożsamości lub zasobu, o ile nic tego nie odmawia. Między dwoma kontami muszą zezwolić obie strony: właściciel zasobu musi wpuścić zewnętrzny podmiot, a konto samego podmiotu musi pozwolić mu na wykonanie wywołania.

Prawdziwe chmury dodają na wierzchu **bariery ochronne (guardrails)**: granice uprawnień (permissions boundaries) i polityki kontroli usług (service control policies) w AWS, grupy zarządzania i przypisania odmowy (deny assignments) w Azure, polityki organizacji i polityki odmowy (deny policies) w Google Cloud. Bariera ochronna niczego nie przyznaje; tylko ogranicza maksimum, jakie podmiot może kiedykolwiek otrzymać, niezależnie od jego własnych polityk. Dzięki temu organizacja może raz, dla wszystkich, powiedzieć: „nikt w żadnym projekcie nie może używać tych regionów”.

> [!CHECK]
> Polityka grupy Alice zezwala na `s3:*` w buckecie. Jej użytkownik ma też politykę z `Deny` dla `s3:DeleteObject` w tym buckecie. Alice próbuje usunąć obiekt. Co się dzieje?
>
> - [ ] Udaje się, bo szerszy allow obejmuje konkretną akcję
> - [ ] Udaje się, bo wygrywa ostatnio przypisana polityka
> - [x] Zostaje odrzucone, bo jawny deny uchyla każdy allow
> - [ ] Zostaje odrzucone tylko wtedy, gdy Alice nie należy do grupy
>
> Jawny deny zawsze wygrywa, niezależnie od tego, ile allow pasuje ani gdzie są przypisane.

### Czytanie polityki JSON
Polityki w stylu AWS to dokumenty JavaScript Object Notation (JSON). Ta sama struktura występuje w politykach IAM, w politykach zaufania ról i w politykach bucketów, a akceptują ją także usługi zgodne z S3 u wielu dostawców.

```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 polityki dostępu JSON: polityka bucketu dla lab-data z Version 2012-10-17, jedną instrukcją z Sid ReadReports, Effect Allow, Principal użytkownik carol, Action s3:GetObject, Resource arn:aws:s3:::lab-data/reports/* oraz Condition wymagającym MFA. Każdy element jest wyróżniony i opisany: Version to wersja języka; Sid opcjonalna etykieta; Effect Allow lub Deny; Principal kto, tylko w politykach zasobów i zaufania; Action które operacje; Resource które obiekty jako ARN; Condition dodatkowe testy, takie jak MFA, IP, czas i tagi](../../../assets/diagrams/iam-policy-anatomy.pl.svg)

*Rysunek 3. Instrukcja odpowiada na cztery pytania: jaki efekt, kto, co i na jakim zasobie, a opcjonalnie także „tylko jeśli”.*

| Element | Znaczenie |
|---|---|
| `Version` | Wersja języka polityk. Zawsze `2012-10-17`: to nie jest data, którą się wybiera, a starsza `2008-10-17` nie ma funkcji takich jak zmienne polityk. |
| `Statement` | Jedna instrukcja lub lista. Każda jest oceniana osobno. |
| `Sid` | Opcjonalna etykieta, przydatna podczas audytów. |
| `Effect` | `Allow` lub `Deny`. Nic innego. |
| `Principal` | Kogo dotyczy instrukcja. Używany tylko w politykach **opartych na zasobie** i w politykach **zaufania**; w polityce tożsamości podmiotem jest ten, do kogo jest przypisana, więc element nie jest tam dozwolony. |
| `Action` | Operacje, zapisane jako `service:Operation`: `s3:GetObject`, `iam:CreateUser`. Symbole wieloznaczne działają: `s3:Get*`. |
| `Resource` | Czego dotyczy akcja, jako ARN. Symbole wieloznaczne działają. |
| `Condition` | Dodatkowe testy, które muszą być prawdziwe: źródłowy adres IP, czas, czy użyto MFA, tagi i inne. |

Dwa szczegóły potykają prawie wszystkich:

- **Akcje na poziomie bucketu i na poziomie obiektu wymagają różnych ARN.** `s3:ListBucket` dotyczy bucketu, `arn:aws:s3:::lab-data`. `s3:GetObject` dotyczy obiektów, `arn:aws:s3:::lab-data/reports/*`. Polityka, która umieszcza `GetObject` przy ARN bucketu albo `ListBucket` przy `lab-data/*`, po cichu nie pasuje do niczego.
- **`Action` i `Resource` są dopasowywane łącznie.** Instrukcja ma zastosowanie tylko wtedy, gdy żądana akcja *oraz* żądany zasób oba pasują (i warunek jest prawdziwy). Allow dla `s3:GetObject` na `reports/*` nic nie mówi o `secret/*`.

**Warunek (Condition)** ma operator, klucz warunku i wartość. `Bool` z `aws:MultiFactorAuthPresent` sprawdza, czy wywołujący zalogował się z drugim składnikiem; `IpAddress` z `aws:SourceIp` ogranicza wywołania do zakresu sieci, takiego jak `203.0.113.0/24`; `DateLessThan` z `aws:CurrentTime` sprawia, że dostęp wygasa. Żądanie musi spełniać wszystkie warunki instrukcji, aby ta instrukcja miała zastosowanie.

> [!CHECK]
> Instrukcja ma `"Effect": "Allow"`, `"Action": "s3:GetObject"` i `"Resource": "arn:aws:s3:::lab-data"`. Użytkownik z tą polityką próbuje pobrać `reports/q3.txt` z `lab-data`. Jaki jest wynik?
>
> - [ ] Dozwolone: użytkownik może czytać cały bucket
> - [x] Odrzucone: `GetObject` działa na obiektach, więc ARN zasobu potrzebuje `/*` (lub ścieżki) po nazwie bucketu
> - [ ] Dozwolone, ale tylko dla obiektów w folderze `reports/`
> - [ ] Polityka jest odrzucana jako nieprawidłowa przy zapisie
>
> ARN `arn:aws:s3:::lab-data` wskazuje sam bucket, a nie obiekty w nim. Instrukcja jest poprawna, ale nigdy nie pasuje do żądania dotyczącego obiektu, więc działa domyślna odmowa.

### Najmniejsze uprawnienia, RBAC i ABAC
**Zasada najmniejszych uprawnień (principle of least privilege)** mówi, że każdy podmiot dostaje tylko uprawnienia potrzebne do jego zadania i tylko na tak długo, jak ich potrzebuje. Ogranicza ona **promień rażenia (blast radius)**: jeśli poświadczenie wycieknie albo ktoś popełni błąd, szkoda jest ograniczona tym, co ta tożsamość mogła zrobić.

W praktyce stosuje się ją przez:
- zaczynanie od zera i dodawanie uprawnień do znanego zadania, zamiast zaczynania od administratora i odejmowania;
- wskazywanie konkretnych akcji i zasobów zamiast `*`;
- używanie grup i ról według funkcji zawodowej, a nie według osoby;
- dodawanie warunków (MFA, sieć źródłowa, czas) dla wrażliwych akcji;
- przeglądanie, co jest faktycznie używane, i przycinanie reszty.

Dwa modele określają, jak przyznawane są uprawnienia:

| | **Kontrola dostępu oparta na rolach (RBAC, Role-based access control)** | **Kontrola dostępu oparta na atrybutach (ABAC, Attribute-based access control)** |
|---|---|---|
| Decyduje na podstawie | Roli lub grupy, do której należy podmiot | Atrybutów podmiotu, zasobu, akcji i środowiska |
| Przykładowa reguła | „Członkowie `analysts` mogą czytać bucket z raportami.” | „Użytkownik może uruchomić VM, jeśli tag `project` maszyny jest równy tagowi `project` użytkownika.” |
| Mocna strona | Łatwa do zrozumienia i audytu; odpowiada stanowiskom. | Skaluje się bez nowych polityk: nowy projekt wymaga nowych tagów, a nie nowych ról. Szczegółowa i dynamiczna. |
| Słaba strona | Role mnożą się („eksplozja ról”) w miarę pojawiania się wyjątków. | Trudniejsza do analizy; zależy od wiarygodnych atrybutów, więc to, kto może zmieniać tagi, staje się kwestią bezpieczeństwa. |
| Typowe zastosowanie | Większość obciążeń, dobry punkt wyjścia. | Duże środowiska z wieloma zespołami. |

ABAC został zdefiniowany przez amerykański National Institute of Standards and Technology (NIST) w Special Publication (SP) 800-162, *Guide to Attribute Based Access Control (ABAC) Definition and Considerations*. Większość prawdziwych środowisk łączy oba modele: role dla ogólnego kształtu, atrybuty dla szczegółów. Oto instrukcja ABAC w stylu AWS, która pozwala podmiotowi uruchamiać i zatrzymywać tylko te VM, które mają tag z jego własnym projektem:

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

`${aws:PrincipalTag/project}` to zmienna polityki: chmura podstawia tag projektu wywołującego w chwili żądania. Jedna instrukcja obsługuje każdy projekt.

> [!CHECK]
> Firma ma 200 projektów i chce, aby każdy zespół zarządzał tylko zasobami własnego projektu, bez pisania nowej polityki dla każdego projektu. Które podejście pasuje najlepiej?
>
> - [ ] Jedna grupa na projekt, każda z własną ręcznie napisaną polityką
> - [ ] Dać każdemu inżynierowi dostęp administratora i zaufać ludziom
> - [x] ABAC: oznaczyć podmioty i zasoby tagiem `project` i zezwalać na akcje, gdy tagi się zgadzają
> - [ ] Współdzielić jeden klucz dostępu na zespół
>
> ABAC porównuje atrybuty w chwili żądania, więc jedna polityka obejmuje wszystkie projekty. Grupy per projekt działają (RBAC), ale mnożą polityki do utrzymania.

### Poświadczenia tymczasowe i przyjmowanie roli
Długotrwałe klucze dostępu to największe pojedyncze ryzyko w IAM w chmurze: nie wygasają, są kopiowane do skryptów, laptopów i repozytoriów, a nikt nie zauważa, kiedy wyciekną. Rozwiązaniem są **poświadczenia tymczasowe (temporary credentials)**: zestaw złożony z identyfikatora klucza dostępu, sekretu i **tokenu sesji (session token)**, który przestaje działać po krótkim czasie, od minut do kilku godzin.

Uzyskuje się je przez **przyjęcie roli (assuming a role)** za pośrednictwem **usługi tokenów bezpieczeństwa (security token service)**: API w stylu STS (AWS Security Token Service). Rola ma dwa rodzaje polityk:

- **Polityka zaufania (trust policy)** mówi, *kto może przyjąć rolę* (element principal, jak w przykładzie z rysunku 3).
- **Polityka uprawnień (permissions policy)** mówi, *co rola może robić* po przyjęciu.

![Sekwencja między Carol, użytkowniczką IAM, usługą tokenów (STS) i bucketem lab-data. 1. Carol wywołuje AssumeRole dla roli reader, podpisane własnym kluczem; STS sprawdza politykę zaufania i jej uprawnienie. 2. STS zwraca poświadczenia tymczasowe: klucz dostępu zaczynający się od ASIA, sekret i token sesji, wygasające po 900 sekundach. 3. Carol wywołuje GetObject dla reports/q3.txt z poświadczeniami tymczasowymi; magazyn ocenia politykę roli i odpowiada 200 OK. PutObject dla reports/c.txt dostaje 403 AccessDenied, bo rola jest tylko do odczytu. Po wygaśnięciu poświadczenia przestają działać, więc nie ma czego unieważniać ani rotować](../../../assets/diagrams/iam-assume-role.pl.svg)

*Rysunek 4. Dopóki trwa sesja, Carol działa jako rola, z uprawnieniami roli, a nie własnymi. Gdy sesja wygasa, dostęp kończy się sam.*

Tożsamość wywołującego się zmienia: po `AssumeRole` API raportuje wywołującego jako `arn:aws:sts::123456789012:assumed-role/reader/carol-lab`, a nie jako użytkownika. Dzienniki audytu zapisują nazwę sesji, więc nadal można ustalić, kto co zrobił. Klucze dostępu zaczynające się od `AKIA` są długotrwałe; klucze zaczynające się od `ASIA` są tymczasowe i wymagają także tokenu sesji.

Przyjmowanie ról to także sposób, w jaki osoba dostaje podwyższony dostęp tylko wtedy, gdy jest potrzebny („break glass” lub dostęp just-in-time), oraz sposób, w jaki obciążenia otrzymują poświadczenia od platformy: profil instancji (instance profile) na VM, konto usługi powiązane z podem Kubernetes lub tożsamość zarządzana (managed identity) w Azure. Program prosi lokalny punkt końcowy metadanych o świeże poświadczenia; nigdzie nie jest przechowywany żaden sekret.

> [!NOTE]
> Polityka zaufania roli wskazuje, kto *może* ją przyjąć. W prawdziwym AWS polityka zaufania wskazująca konkretnego użytkownika lub rolę z tego samego konta wystarcza sama w sobie. Jeśli wskazuje całe konto (`arn:aws:iam::<account-id>:root`), każdy podmiot potrzebuje dodatkowo polityki tożsamości zezwalającej na `sts:AssumeRole`. Wiele organizacji i tak dodaje politykę tożsamości zezwalającą na `sts:AssumeRole` dla konkretnej roli, aby uprawnienie było widoczne także na podmiocie. Laboratorium tak robi, bo wymaga tego emulator.

> [!CHECK]
> Które stwierdzenie o poświadczeniach tymczasowych z `AssumeRole` jest prawdziwe?
>
> - [ ] Zachowują uprawnienia użytkownika, który o nie poprosił
> - [ ] Nigdy nie wygasają, dopóki istnieje rola
> - [x] Niosą uprawnienia roli i przestają działać po ustalonym czasie
> - [ ] Są ważne tylko razem z hasłem użytkownika
>
> Sesja działa jako rola, więc obowiązują uprawnienia roli, a nie wywołującego. Wygaśnięcie jest wbudowane w poświadczenia i token sesji.

### Federacja: SAML 2.0 i OpenID Connect
Tworzenie osobnego użytkownika w chmurze dla każdego pracownika, każdego kontraktora i każdego pipeline'u się nie skaluje, a hasła i klucze się piętrzą. **Federacja (federation)** pozwala chmurze zaufać zewnętrznemu **dostawcy tożsamości (IdP, identity provider)**: katalogowi firmy, logowaniu przez serwis społecznościowy lub systemowi CI. Użytkownik loguje się u IdP, a IdP poświadcza za niego podpisanym tokenem. Chmura nigdy nie widzi hasła; sprawdza tylko token i przypisuje użytkownika do roli.

![Sekwencja federacji między użytkownikiem lub obciążeniem, dostawcą tożsamości, IAM chmury z jego usługą tokenów i zasobem w chmurze. 1. Użytkownik loguje się u IdP hasłem i MFA albo zadanie CI przedstawia własny token. 2. IdP zwraca podpisany token: token ID OIDC (JWT) lub asercję SAML 2.0. 3. Użytkownik wymienia token na rolę za pomocą AssumeRoleWithWebIdentity lub AssumeRoleWithSAML; IAM chmury weryfikuje podpis kluczem publicznym IdP, sprawdza wystawcę, odbiorcę i wygaśnięcie oraz dopasowuje politykę zaufania roli. 4. Wracają poświadczenia tymczasowe, ważne od minut do godzin. 5. Użytkownik wywołuje zasób w chmurze za ich pomocą, co zezwala polityka roli](../../../assets/diagrams/iam-federation.pl.svg)

*Rysunek 5. Dostawca tożsamości uwierzytelnia; chmura autoryzuje. Wynikiem są poświadczenia tymczasowe, bez żadnego długotrwałego klucza.*

Dominują dwa standardy:

| | **SAML 2.0** | **OpenID Connect (OIDC)** |
|---|---|---|
| Pełna nazwa | Security Assertion Markup Language 2.0 (standard OASIS) | OpenID Connect Core 1.0 |
| Token | **Asercja**: podpisany dokument Extensible Markup Language (XML) | **Token ID**: podpisany JSON Web Token (JWT, RFC 7519) |
| Zbudowany na | XML i przekierowaniach przeglądarki | OAuth 2.0 (RFC 6749), z dodaną warstwą uwierzytelniania |
| Typowe zastosowanie | Jednokrotne logowanie (SSO, single sign-on) w przedsiębiorstwie, dla osób wchodzących do konsoli | Aplikacje WWW i mobilne oraz **federacja tożsamości obciążeń (workload identity federation)** dla pipeline'ów i programów |
| Przykład | Pracownik loguje się do portalu firmy i trafia do konsoli chmury | Zadanie CI dowodzi: „jestem gałęzią `main` tego repozytorium” i dostaje rolę do wdrożenia |

Sam OAuth 2.0 dotyczy *delegowanej autoryzacji* (pozwalania aplikacji działać w czyimś imieniu), a nie dowodzenia, kim się jest. OIDC dodaje na nim brakującą warstwę tożsamości.

Federacja tożsamości obciążeń zastępuje przechowywany klucz wdrożeniowy. Platforma CI wydaje każdemu zadaniu krótkotrwały token OIDC, którego twierdzenia (claims) mówią, skąd pochodzi, na przykład `sub: repo:example-org/example-repo:ref:refs/heads/main`. Polityka zaufania roli w chmurze akceptuje tylko tego wystawcę, tego odbiorcę i ten podmiot (subject). Inne repozytorium ani inna gałąź nie mogą przyjąć roli.

> [!CHECK]
> Co weryfikuje chmura, gdy otrzymuje od dostawcy tożsamości token ID OIDC lub asercję SAML?
>
> - [ ] Hasło użytkownika, które przekazuje dostawca tożsamości
> - [x] Podpis (kluczem publicznym IdP), wystawcę, odbiorcę i wygaśnięcie, a następnie politykę zaufania roli
> - [ ] Tylko to, że token jest poprawnie sformułowanym dokumentem JSON lub XML
> - [ ] Że użytkownik ma klucz dostępu na koncie w chmurze
>
> Chmura ufa podpisowi IdP, a nie hasłu. Nadal sprawdza, że token jest przeznaczony dla niej, jest wciąż ważny i pasuje do polityki zaufania roli.

### Uwierzytelnianie wieloskładnikowe
**Uwierzytelnianie wieloskładnikowe (MFA, Multi-factor authentication)** wymaga co najmniej dwóch różnych rodzajów dowodu: czegoś, co wiesz, czegoś, co masz, i czegoś, czym jesteś. Samo skradzione hasło nie otwiera już drzwi. Typowe drugie składniki, od najsłabszego do najsilniejszego:

- **Kody SMS.** Lepsze niż nic, ale podatne na SIM swapping i przechwycenie.
- **Jednorazowe hasła czasowe (TOTP, Time-based one-time passwords, RFC 6238)** z aplikacji uwierzytelniającej. Podatne na phishing: fałszywa strona może poprosić o kod i natychmiast go odtworzyć.
- **Klucze sprzętowe FIDO2 / WebAuthn i klucze dostępu (passkeys).** Klucz podpisuje wyzwanie zawierające nazwę prawdziwej strony, więc strona-podróbka nie dostaje niczego użytecznego. To MFA **odporne na phishing (phishing-resistant)**.

Wymuszaj MFA dla każdego użytkownika będącego człowiekiem, zawsze dla użytkownika root i dla wrażliwych akcji za pomocą warunku (`aws:MultiFactorAuthPresent`). Programy nie mogą używać MFA, co jest kolejnym powodem, by dawać im poświadczenia tymczasowe zamiast kluczy.

> [!CHECK]
> Dlaczego klucz bezpieczeństwa FIDO2 jest uważany za silniejszy niż kod TOTP z aplikacji?
>
> - [ ] Kod jest dłuższy, więc trudniej go odgadnąć
> - [ ] Klucz działa bez Internetu, więc nikt nie może go przechwycić
> - [x] Klucz podpisuje wyzwanie powiązane z prawdziwą stroną, więc strona phishingowa nie może go ponownie użyć
> - [ ] Chmura przechowuje sekret klucza, aby móc go zresetować
>
> Kod TOTP można wpisać na fałszywej stronie i odtworzyć. Odpowiedź FIDO2 jest powiązana z origin prawdziwej strony, więc jej kopia nigdzie indziej nie ma wartości.

## Jak to działa
Prześledź jedno żądanie od początku do końca. Bob, którego użytkownik ma politykę najmniejszych uprawnień z laboratorium, uruchamia `aws s3api get-object --bucket lab-data --key reports/q3.txt`:

1. **Podpisanie.** Narzędzie wiersza poleceń buduje żądanie HTTP i podpisuje je tajnym kluczem Boba. W żądaniu idzie identyfikator klucza dostępu; sekret nie.
2. **Uwierzytelnienie.** Usługa wyszukuje identyfikator klucza dostępu, ponownie oblicza podpis za pomocą pasującego sekretu i porównuje. Niezgodność lub nieznany klucz kończy żądanie błędem uwierzytelniania.
3. **Zbudowanie kontekstu.** Usługa notuje kto (`arn:aws:iam::123456789012:user/bob`), co (`s3:GetObject`), na jakim zasobie (`arn:aws:s3:::lab-data/reports/q3.txt`) oraz środowisko (źródłowy adres IP, czas, czy użyto MFA i TLS).
4. **Zebranie polityk.** Polityki użytkownika Boba, polityki jego grup, polityka bucketu `lab-data` i ewentualne bariery ochronne organizacji.
5. **Ocena.** Szukanie pasującego `Deny`: brak. Szukanie pasującego `Allow`: pasuje instrukcja dla `GetObject` na `lab-data/reports/*`. Wynik: zezwolić.
6. **Wykonanie i zapis w dzienniku.** Obiekt zostaje zwrócony, a dziennik audytu rejestruje wywołanie z podmiotem, akcją, zasobem, źródłowym adresem IP i wynikiem.

> [!CHECK]
> Który krok w życiu żądania następuje jako pierwszy?
>
> - [ ] Chmura zbiera polityki, które mają zastosowanie
> - [ ] Chmura szuka pasującego jawnego deny
> - [x] Chmura uwierzytelnia wywołującego na podstawie podpisu lub tokenu
> - [ ] Chmura sprawdza, czy rola wywołującego wygasła
>
> Polityki są oceniane dla *znanego* podmiotu, więc uwierzytelnianie zawsze jest pierwsze. Wygasła sesja zawodzi na tym samym etapie uwierzytelniania.

## Przykład praktyczny
Zarządzasz bucketem `lab-data` z dwoma prefiksami, `reports/` i `secret/`. Bob ma taką politykę tożsamości (to ta, którą budujesz w laboratorium):

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

Bucket ma też politykę zasobu, która odrzuca każde żądanie niezaszyfrowane w tranzycie (częsta konfiguracja bazowa):

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

Przewidź wynik każdego żądania Boba, a potem sprawdź rozumowanie:

| # | Żądanie | Wynik | Dlaczego |
|---|---|---|---|
| 1 | `GetObject` `reports/q3.txt` przez HTTPS | **Dozwolone** | `EverythingInReports` na to zezwala; żaden deny nie pasuje (`SecureTransport` jest true, więc `DenyPlainHttp` nie ma zastosowania). |
| 2 | `GetObject` `reports/q3.txt` przez zwykły HTTP | **Odrzucone** | `DenyPlainHttp` pasuje: jawny deny wygrywa z allow. |
| 3 | `PutObject` `reports/q4.txt` przez HTTPS | **Dozwolone** | `s3:*` na `reports/*` to obejmuje. |
| 4 | `DeleteObject` `reports/q3.txt` przez HTTPS | **Odrzucone** | `NeverDelete` to jawny deny; wygrywa z allow `s3:*`. |
| 5 | `GetObject` `secret/passwords.txt` przez HTTPS | **Odrzucone** | Żadna instrukcja nie zezwala na `secret/*`: domyślna odmowa. |
| 6 | `ListBucket` na `lab-data` | **Dozwolone** | `ListTheBucket` na to zezwala, dla całego bucketu: Bob widzi *nazwy* obiektów także w `secret/`. |

Wiersz 6 to klasyczna niespodzianka. Listowanie to akcja na poziomie bucketu, więc ta polityka nie może ograniczyć go do `reports/` samym zasobem. W prawdziwych chmurach dodaje się `Condition` na prefiks klucza (w AWS `s3:prefix`), aby to zawęzić.

## Typowe błędy
- **Wpisywanie `*` w `Action` lub `Resource`, „żeby zadziałało”** — działa, bo zezwala na wszystko. Znajdź dokładną akcję w komunikacie błędu lub dzienniku audytu i wskaż ją.
- **Mylenie ARN bucketu z ARN obiektu** — `ListBucket` wymaga `arn:aws:s3:::name`, `GetObject` wymaga `arn:aws:s3:::name/*`. Jeśli jedna połowa polityki działa, a druga nie, sprawdź to najpierw.
- **Oczekiwanie, że późniejszy lub węższy allow uchyli deny** — nigdy tak nie jest. Aby przywrócić dostęp, trzeba usunąć lub zawęzić deny.
- **Zapominanie, że grupa nie jest tożsamością** — nie można zalogować się jako grupa i nie można jej wskazać jako `Principal` polityki zasobu ani zaufania. Przypisuje się do niej polityki, a jej członkowie je dziedziczą.
- **Testowanie z tożsamością administratora** — może wszystko, więc nigdy nie widać brakującego uprawnienia. Testuj jako tożsamość, która naprawdę będzie wykonywać zadanie.
- **Zakładanie, że warunki są zawsze egzekwowane przez każde narzędzie** — niektóre emulatory i niektóre częściowe usługi zgodne z S3 je ignorują. Przetestuj warunki na prawdziwej usłudze, zanim zaczniesz na nich polegać.

## Kwestie bezpieczeństwa
Większość włamań do chmury zaczyna się od tożsamości, a nie od podatności w oprogramowaniu. Oto błędy, które powtarzają się raz po raz, i sposoby ich znajdowania.

### Typowe błędy
- **Polityki z symbolami wieloznacznymi.** `"Action": "*"` na `"Resource": "*"` czyni z każdego poświadczenia, które je niesie, klucz uniwersalny. Nawet `s3:*` na `*` pozwala posiadaczowi czytać, zmieniać i usuwać każdy bucket na koncie.
- **Długotrwałe i wyciekłe klucze.** Klucze dostępu zatwierdzone w repozytoriach, wklejone na czacie, wbudowane w obrazy kontenerów lub zostawione w zmiennej CI na lata. Publiczne repozytoria są skanowane w poszukiwaniu kluczy, często w ciągu minut od wypchnięcia zmian. Preferuj role, federację i poświadczenia tymczasowe; tam, gdzie klucz jest nieunikniony, rotuj go i ogranicz warunkami.
- **Nieużywane konta i poświadczenia.** Byli pracownicy, porzuceni użytkownicy testowi i stare klucze pozostają ważne, dopóki ktoś ich nie usunie. Każda nieużywana tożsamość to niemonitorowane wejście.
- **Codzienne używanie konta root lub właściciela.** Nie da się go ograniczyć. Chroń je silnym hasłem i MFA odpornym na phishing, nie nadawaj mu kluczy dostępu i zachowaj je do kilku zadań, które tego wymagają.
- **Brak MFA lub słabe MFA.** Skradzione hasło oznacza wtedy pełne przejęcie. Wymagaj MFA od każdego człowieka, a dla administratorów preferuj FIDO2.
- **Zbyt szerokie polityki zaufania.** Rolę, która ufa całemu kontu lub `"Principal": "*"`, może przyjąć każdy na tym koncie albo ktokolwiek. Wskaż dokładny podmiot, a dla federacji dokładnego wystawcę, odbiorcę i podmiot (subject).
- **Uprawnienia przyznane przez możliwość zmiany uprawnień.** Podmiot z prawem do `iam:PutUserPolicy` lub `iam:AttachUserPolicy` może nadać sobie prawa administratora. Traktuj akcje zapisu IAM jak uprawnienia administratora.

### Wykrywanie
- **Dzienniki audytu.** Każde wywołanie API jest rejestrowane z informacją, kto, co, kiedy i skąd: AWS CloudTrail, Azure Activity Log i dzienniki logowania Microsoft Entra, Google Cloud Audit Logs. Przechowuj je na osobnym koncie z ochroną przed zapisem i ustaw alerty na wrażliwe zdarzenia: użycie root, logowanie do konsoli bez MFA, nowe klucze dostępu, zmiany polityk, wywołania z nietypowych krajów.
- **Przeglądy dostępów.** Według harmonogramu (często co kwartał) właściciel każdego zasobu potwierdza, kto nadal potrzebuje dostępu, a resztę się usuwa. Uwzględnij konta usług i zaufania między kontami, o których łatwo zapomnieć.
- **Raporty higieny poświadczeń.** Wylistuj użytkowników, klucze, ich wiek i ostatnie użycie (laboratorium używa `get-access-key-last-used`). Usuń klucze, których nikt nie używał od 90 dni, rotuj te, które muszą zostać, i porównaj przyznane uprawnienia z używanymi; większość chmur potrafi zaproponować węższą politykę na podstawie dziennika aktywności (na przykład IAM Access Analyzer w AWS, narzędzia analizy polityk w Google Cloud).
- **Rotacja kluczy.** Utwórz nowy klucz, przełącz aplikację, sprawdź, że stary klucz nie jest już używany, a potem go usuń. W żadnym momencie nie trzeba zatrzymywać aplikacji. Rotacja skraca życie wycieku, ale nie zwalnia z unikania długotrwałych kluczy.
- **Skanowanie sekretów.** Skanuj repozytoria i obrazy w poszukiwaniu kluczy, zanim zostaną wypchnięte, a każdy klucz, który kiedykolwiek trafił w publiczne miejsce, traktuj jako skompromitowany: usuń go, nie wystarczy przepisać historii.

> [!WARNING]
> Jeśli klucz dostępu wycieknie, natychmiast go dezaktywuj lub usuń, a potem przejrzyj dziennik audytu, aby sprawdzić, co zrobił między wyciekiem a unieważnieniem. Zmiana kodu ani usunięcie repozytorium nie cofa ekspozycji.

## Podsumowanie
- IAM odpowiada na dwa pytania: kim jesteś (uwierzytelnianie) i co możesz robić (autoryzacja). `AccessDenied` oznacza, że uwierzytelnianie się powiodło, a autoryzacja nie.
- Żądanie jest dozwolone tylko wtedy, gdy jakaś instrukcja na nie zezwala i żadna go nie odrzuca: domyślna odmowa, jawny allow, jawny deny wygrywa.
- Instrukcja polityki JSON ma efekt, podmiot (w politykach zasobów i zaufania), akcje, zasoby i opcjonalne warunki. Pamiętaj o różnicy między ARN bucketu a ARN obiektu.
- Stosuj najmniejsze uprawnienia: konkretne akcje i zasoby, wąskie zakresy, grupy i role, warunki oraz regularne przeglądy. Używaj RBAC dla ogólnego kształtu, a ABAC dla szczegółowych, skalowalnych reguł.
- Preferuj role i poświadczenia tymczasowe (`AssumeRole` w stylu STS) zamiast długotrwałych kluczy, a ludzi i pipeline'y federuj za pomocą SAML 2.0 lub OpenID Connect, aby chmura nigdy nie przechowywała ich haseł.
- Wymuszaj MFA, chroń konto root, usuwaj nieużywane tożsamości, rotuj nieuniknione klucze i obserwuj dzienniki audytu.

## Słowniczek
| Termin | Definicja |
|---|---|
| Zarządzanie tożsamościami i dostępem (IAM, Identity and Access Management) | Usługa chmurowa i dyscyplina, które decydują, kto wysyła żądanie i co może zrobić. |
| Tożsamość (identity) | Rozpoznany uczestnik systemu: osoba, program lub rola. |
| Podmiot (principal) | Każda tożsamość, która może wysłać żądanie: użytkownik, członek grupy, sesja roli lub konto usługi. |
| Użytkownik (user) | Nazwana tożsamość jednej osoby, z poświadczeniami takimi jak hasło i klucze dostępu. |
| Grupa (group) | Zbiór użytkowników, do którego przypisane są polityki; członkowie je dziedziczą. Sama nie może wysyłać żądań. |
| Rola (role) | Tożsamość z uprawnieniami, ale bez stałych poświadczeń, przyjmowana tymczasowo. |
| Konto usługi (service account) | Tożsamość niebędąca człowiekiem, dla aplikacji, VM lub pipeline'u. Nazywana też tożsamością obciążenia lub tożsamością maszynową. |
| Użytkownik root (root user) | Wszechpotężna tożsamość tworzona razem z kontem (gdzie indziej właściciel lub administrator globalny). |
| Amazon Resource Name (ARN) | Unikalna nazwa zasobu lub podmiotu w AWS, taka jak `arn:aws:iam::123456789012:user/bob`. |
| Klucz dostępu (access key) | Para kluczy (identyfikator i sekret), która podpisuje żądania API. Długotrwały, chyba że wydany w ramach poświadczeń tymczasowych. |
| Uwierzytelnianie (authN) | Potwierdzenie, kim jest wywołujący. |
| Autoryzacja (authZ) | Decydowanie, co uwierzytelniony wywołujący może robić. |
| Polityka (policy) | Dokument wymieniający dozwolone lub zabronione akcje na zasobach. |
| Polityka oparta na tożsamości (identity-based policy) | Polityka przypisana do użytkownika, grupy lub roli. |
| Polityka oparta na zasobie (resource-based policy) | Polityka przypisana do zasobu, na przykład polityka bucketu; wskazuje podmioty, których dotyczy. |
| Domyślna odmowa (default deny) | Reguła, że wszystko, na co jawnie nie zezwolono, jest odrzucane. |
| Jawny deny (explicit deny) | Instrukcja z `Effect: Deny`; uchyla każdy allow. |
| Instrukcja (statement) | Jedna reguła w polityce: efekt, podmiot, akcja, zasób i opcjonalny warunek. |
| Warunek (condition) | Dodatkowy test w instrukcji (MFA, zakres IP, czas, tagi), który musi być prawdziwy, aby instrukcja miała zastosowanie. |
| Bariera ochronna (guardrail) | Ograniczenie na poziomie organizacji (takie jak granice uprawnień lub polityki kontroli usług), które wyznacza maksimum uprawnień, jakie podmioty mogą kiedykolwiek otrzymać. |
| Zasada najmniejszych uprawnień (principle of least privilege) | Nadawanie każdemu podmiotowi tylko uprawnień, których potrzebuje, na tak długo, jak ich potrzebuje. |
| Promień rażenia (blast radius) | Wielkość możliwych szkód, jeśli jedna tożsamość lub jedno poświadczenie zostanie skompromitowane. |
| Kontrola dostępu oparta na rolach (RBAC) | Przyznawanie uprawnień według ról lub grup, do których należy podmiot. |
| Kontrola dostępu oparta na atrybutach (ABAC) | Przyznawanie uprawnień przez porównanie atrybutów podmiotu, zasobu, akcji i środowiska (NIST SP 800-162). |
| Poświadczenia tymczasowe (temporary credentials) | Klucz dostępu, sekret i token sesji, które wygasają po krótkim czasie. |
| Token sesji (session token) | Dodatkowa wartość, która musi towarzyszyć poświadczeniom tymczasowym w każdym żądaniu. |
| Usługa tokenów bezpieczeństwa (STS, security token service) | API wydające poświadczenia tymczasowe, na przykład przez `AssumeRole`. |
| Przyjęcie roli (assume a role) | Wymiana własnej tożsamości na poświadczenia tymczasowe niosące uprawnienia roli. |
| Polityka zaufania (trust policy) | Polityka roli, która mówi, kto może ją przyjąć. |
| Federacja (federation) | Zaufanie zewnętrznemu dostawcy tożsamości w uwierzytelnianiu użytkowników, dzięki czemu chmura nie przechowuje ich haseł. |
| Dostawca tożsamości (IdP, identity provider) | System, który uwierzytelnia użytkowników i wydaje podpisane tokeny lub asercje. |
| SAML 2.0 | Standard oparty na XML dla podpisanych asercji, szeroko używany do jednokrotnego logowania w przedsiębiorstwach. |
| OpenID Connect (OIDC) | Warstwa uwierzytelniania nad OAuth 2.0, która wydaje podpisane tokeny ID w formacie JWT. |
| Federacja tożsamości obciążeń (workload identity federation) | Pozwalanie pipeline'owi lub programowi wymienić krótkotrwały token jego platformy na poświadczenia chmury, bez przechowywanego klucza. |
| Uwierzytelnianie wieloskładnikowe (MFA) | Uwierzytelnianie wymagające co najmniej dwóch rodzajów dowodu. |
| MFA odporne na phishing (phishing-resistant MFA) | MFA, takie jak klucze FIDO2, którego odpowiedź jest powiązana z prawdziwą stroną i nie może być odtworzona z fałszywej. |
| Dziennik audytu (audit log) | Zapis wywołań API: kto, co, kiedy, skąd i z jakim wynikiem. |
| Przegląd dostępów (access review) | Zaplanowane sprawdzenie, czy każda tożsamość nadal potrzebuje posiadanego dostępu. |
| Rotacja kluczy (key rotation) | Zastąpienie poświadczenia nowym i wycofanie starego. |

## Sprawdź swoją wiedzę
1. Polityka kolegi z zespołu ma `"Action": "s3:*"` i `"Resource": "*"`, „bo tylko tak działał skrypt wgrywający”. Wyjaśnij, jak znaleźć rzeczywiste uprawnienia potrzebne skryptowi i jak napisać zamiennik z najmniejszymi uprawnieniami.
2. Użytkownik należy do dwóch grup. Grupa A zezwala na `s3:GetObject` na `reports/*`. Grupa B ma jawny `Deny` dla `s3:*` na całym buckecie dla każdego bez MFA. Co może zrobić użytkownik zalogowany bez MFA, a co z MFA? Który element robi różnicę?
3. Zaprojektuj dostęp dla pipeline'u CI, który wdraża do Twojego konta w chmurze. Jaki podmiot, jakie poświadczenia, jakie warunki zaufania? Co usuwasz w porównaniu z przechowywaniem klucza dostępu w zmiennej CI?
4. Wyjaśnij własnymi słowami, dlaczego `AccessDenied` i `InvalidClientTokenId` wskazują na różne problemy i co sprawdzisz w każdym z nich.
5. Twoja firma ma 40 programistów i 5 zespołów. Kiedy wybierzesz RBAC, kiedy ABAC i co trzeba kontrolować, aby ABAC był bezpieczny?
6. Odkrywasz, że klucz dostępu należący do pracownika, który odszedł rok temu, był ostatnio użyty wczoraj. Opisz po kolei, co zrobisz w pierwszej godzinie.

## Źródła
- [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/) — policy evaluation logic, policy reference and temporary credentials.
- [Google Cloud IAM overview](https://cloud.google.com/iam/docs/overview), [Azure RBAC overview](https://learn.microsoft.com/azure/role-based-access-control/overview) and [OpenStack Keystone](https://docs.openstack.org/keystone/latest/) — the same concepts in other providers.
