Ministack: Free, open-source local AWS emulator - 60+ services, Terraform compatible, real databases. Free forever. MIT licensed.
Python awsaws-emulatoraws-localaws-sdkdevtoolsdockerdynamodbec2emulatorlambdalocalstacklocalstack-alternativeministackmock-awsopen-sourcepythons3sqsterraform
feat(iam): permissions boundaries, session policies and GetFederationToken (#2155)
iot-rocket26ccff7601cd
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex f6ba7569..c9f27e51 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -7,6 +7,10 @@ Versioning follows [Semantic Versioning](https://semver.org/).## [Unreleased]+### Added+- **STS — session policies and `GetFederationToken`** — `AssumeRole` ignored `Policy` and `PolicyArns` and `GetFederationToken` answered `InvalidAction`; under `AUTH=true` a role session now gets only what both the role and its session policies allow, a `Deny` in them denies, and `AssumeRole` rejects a malformed policy with `MalformedPolicyDocument` and an unknown policy ARN with `ValidationError`. `GetFederationToken` is added: its federated user gets the calling user's permissions within the session policies (none without one) and its `Tags`, not the user's tags, as `aws:PrincipalTag/*`; it checks its `Name`, policies and tags, and under `AUTH=true` a temporary caller answers `AccessDenied`. Contributed by @iot-rocket.+- **IAM — permissions boundaries are enforced** — the boundaries of users and roles were stored and never applied; under `AUTH=true` a boundary now limits what the identity policies allow and a `Deny` in it denies, a boundary must name a known managed policy (`ValidationError` for a malformed ARN, CloudFormation `AWS::IAM::User` included), deleting an absent boundary answers `NoSuchEntity`, and a policy in use as a boundary cannot be deleted. `ListUsers` and `ListRoles` leave the boundary out, `ListEntitiesForPolicy` lists boundary users and roles and honours `PolicyUsageFilter`, and a managed policy reports `PermissionsBoundaryUsageCount`. Contributed by @iot-rocket.+### Fixed- **STS — trust policies see principal tags, session tags and web identities under `AUTH=true`** — `AssumeRole` trust conditions had no `aws:PrincipalTag/*`, a `Service` principal matched any IAM user whose ARN contained the service name, `Tags` passed without `sts:TagSession` in the trust policy, and `AssumeRoleWithWebIdentity` skipped the trust policy; trust conditions now see the caller's keys and the session tags as `aws:RequestTag/*` and `aws:TagKeys`, a `Service` principal no longer matches an IAM user, session tags need `sts:TagSession`, and a web identity needs a `Federated` principal naming its issuer, with `<issuer>:aud`, `:sub` and `:amr` evaluated. Under `AUTH=true` session tag keys that differ only in case answer `InvalidParameterValue`. Contributed by @iot-rocket.- **IAM — `aws:ResourceTag/*` under `AUTH=true`** — the key was always absent outside CloudWatch Logs, so a tag-scoped grant denied every request; a request on an existing SQS queue, SNS topic, DynamoDB table, Lambda function, IAM user or role, SSM parameter, Secrets Manager secret or KMS key now sees that resource's tags. Contributed by @iot-rocket.diff --git a/README.md b/README.mdindex 3979be3f..4c95aaa6 100644--- a/README.md+++ b/README.md@@ -408,8 +408,8 @@ subnet = ec2.create_subnet(| **DynamoDB** | CreateTable, UpdateTable, DeleteTable, DescribeTable, ListTables, PutItem, GetItem, DeleteItem, UpdateItem, Query, Scan, BatchWriteItem, BatchGetItem, TransactWriteItems, TransactGetItems, DescribeTimeToLive, UpdateTimeToLive, DescribeContinuousBackups, UpdateContinuousBackups, DescribeEndpoints, TagResource, UntagResource, ListTagsOfResource, EnableKinesisStreamingDestination, DisableKinesisStreamingDestination, DescribeKinesisStreamingDestination, UpdateKinesisStreamingDestination | TTL enforced via thread-safe background reaper (60s cadence); DynamoDB Streams — `StreamSpecification` emits INSERT/MODIFY/REMOVE records on every write that changes an item, respects `StreamViewType`; `Query` and `Scan` pages stop at 1 MB of data read; GSIs accept multi-attribute keys (up to four `HASH` and four `RANGE` attributes); Kinesis streaming destinations (`aws_dynamodb_kinesis_streaming_destination`) fan item mutations out into any Kinesis stream by ARN while the destination is ACTIVE; global tables (version 2019.11.21) through `UpdateTable` `ReplicaUpdates`: a replica is a copy of the table in the other region, and writes replicate between them || **DynamoDB Streams** | ListStreams, DescribeStream, GetShardIterator, GetRecords | Reads records emitted by the main DynamoDB service via `boto3.client("dynamodbstreams")` — single synthetic shard per stream; `TRIM_HORIZON`/`LATEST`/`AT_SEQUENCE_NUMBER`/`AFTER_SEQUENCE_NUMBER` iterator types; `NEW_AND_OLD_IMAGES`, `NEW_IMAGE`, `OLD_IMAGE`, `KEYS_ONLY` view types; opaque base64 iterator tokens that expire after 15 minutes; `GetRecords` pages stop at 1,000 records or 1 MB; a disabled stream, or the stream of a deleted table, stays readable for 24 hours as `DISABLED` || **Lambda** | CreateFunction, DeleteFunction, GetFunction, GetFunctionConfiguration, ListFunctions, Invoke, UpdateFunctionCode, UpdateFunctionConfiguration, AddPermission, RemovePermission, GetPolicy, ListVersionsByFunction, PublishVersion, CreateAlias, GetAlias, UpdateAlias, DeleteAlias, ListAliases, TagResource, UntagResource, ListTags, CreateEventSourceMapping, DeleteEventSourceMapping, GetEventSourceMapping, ListEventSourceMappings, UpdateEventSourceMapping, CreateFunctionUrlConfig, GetFunctionUrlConfig, UpdateFunctionUrlConfig, DeleteFunctionUrlConfig, ListFunctionUrlConfigs, PutFunctionConcurrency, GetFunctionConcurrency, DeleteFunctionConcurrency, PutFunctionEventInvokeConfig, GetFunctionEventInvokeConfig, DeleteFunctionEventInvokeConfig, PublishLayerVersion, GetLayerVersion, GetLayerVersionByArn, ListLayerVersions, DeleteLayerVersion, ListLayers, AddLayerVersionPermission, RemoveLayerVersionPermission, GetLayerVersionPolicy, CheckpointDurableExecution, GetDurableExecution, GetDurableExecutionState, GetDurableExecutionHistory, ListDurableExecutionsByFunction, StopDurableExecution, SendDurableExecutionCallbackSuccess, SendDurableExecutionCallbackFailure, SendDurableExecutionCallbackHeartbeat | Python and Node.js runtimes execute with warm worker pool; `provided.al2023`/`provided.al2` runtimes reuse local bootstrap processes via the Lambda Runtime API (Go, Rust, C++ support), or use Docker RIE when configured; `Publish=True` creates immutable numbered versions; Code via `ZipFile`, `S3Bucket`/`S3Key` (with optional `S3ObjectVersion`), or `ImageUri` (Docker image); `PackageType: Image` pulls and invokes user-provided Docker images via Lambda RIE; SQS, Kinesis, and DynamoDB Streams event source mappings; Function URL CRUD; Lambda Layers CRUD; Aliases; Concurrency; EventInvokeConfig; **SnapStart** — `SnapStart.ApplyOn=PublishedVersions` round-trips on `CreateFunction`/`UpdateFunctionConfiguration` (Java 11+/Python 3.12+/.NET 8+ and container images, per AWS's constraints); publishing a version initializes its execution environment then and there, so the version reports `OptimizationStatus: On`, walks `Pending` → `Active`, answers `ResourceConflictException` while `Pending`, fails the publish on a broken init, and runs `snapshot-restore-py` before-snapshot/after-restore hooks during init (Python); **Durable Functions** — `CreateFunction` accepts `DurableConfig`; checkpoint/state/history/list/stop ops at the preview API (`2025-12-01`); external `SendCallback{Success,Failure,Heartbeat}` resume the SDK across invocations; resume scheduler fires WAIT expiries, callback timeouts, and step-retry backoffs; verified against the official `aws-durable-execution-sdk-python` and `aws-durable-execution-sdk-java`; **X-Ray active tracing** — `TracingConfig.Mode=Active` injects `_X_AMZN_TRACE_ID` (`Root=1-<hex>-<hex>;Parent=<hex>;Sampled=1`) into the runtime per invocation so the AWS X-Ray SDK runs without `Missing AWS Lambda trace data`; supported on the warm Python / Node executor, provided runtimes, and the local subprocess fallback (docker RIE upstream does not implement X-Ray and is logged but unsupported) |-| **IAM** | CreateUser, GetUser, ListUsers, DeleteUser, CreateRole, GetRole, ListRoles, DeleteRole, UpdateRoleDescription, PutRolePermissionsBoundary, DeleteRolePermissionsBoundary, PutUserPermissionsBoundary, DeleteUserPermissionsBoundary, CreatePolicy, GetPolicy, DeletePolicy, AttachRolePolicy, DetachRolePolicy, PutRolePolicy, GetRolePolicy, DeleteRolePolicy, ListRolePolicies, ListAttachedRolePolicies, CreateAccessKey, ListAccessKeys, DeleteAccessKey, UpdateAccessKey, GetAccessKeyLastUsed, CreateInstanceProfile, GetInstanceProfile, DeleteInstanceProfile, AddRoleToInstanceProfile, RemoveRoleFromInstanceProfile, ListInstanceProfiles, TagInstanceProfile, UntagInstanceProfile, ListInstanceProfileTags, CreateGroup, GetGroup, AddUserToGroup, RemoveUserFromGroup, AttachGroupPolicy, DetachGroupPolicy, ListAttachedGroupPolicies, PutGroupPolicy, GetGroupPolicy, DeleteGroupPolicy, ListGroupPolicies, CreateServiceLinkedRole, DeleteServiceLinkedRole, GetServiceLinkedRoleDeletionStatus, CreateOpenIDConnectProvider, ListOpenIDConnectProviders, CreateSAMLProvider, GetSAMLProvider, ListSAMLProviders, UpdateSAMLProvider, DeleteSAMLProvider, CreateLoginProfile, GetLoginProfile, UpdateLoginProfile, DeleteLoginProfile, CreateVirtualMFADevice, EnableMFADevice, DeactivateMFADevice, ResyncMFADevice, ListMFADevices, ListVirtualMFADevices, DeleteVirtualMFADevice, GetAccountAuthorizationDetails, GenerateServiceLastAccessedDetails, GetServiceLastAccessedDetails, TagRole, UntagRole, TagUser, UntagUser, TagPolicy, UntagPolicy, GenerateCredentialReport, GetCredentialReport, GetAccountSummary, GetAccountPasswordPolicy, UpdateAccountPasswordPolicy, DeleteAccountPasswordPolicy, ListAccountAliases, CreateAccountAlias, DeleteAccountAlias | Role descriptions and permissions boundaries round-trip through role reads; boundaries support put/delete updates. |-| **STS** | GetCallerIdentity, AssumeRole, GetSessionToken, AssumeRoleWithWebIdentity | |+| **IAM** | CreateUser, GetUser, ListUsers, DeleteUser, CreateRole, GetRole, ListRoles, DeleteRole, UpdateRoleDescription, PutRolePermissionsBoundary, DeleteRolePermissionsBoundary, PutUserPermissionsBoundary, DeleteUserPermissionsBoundary, CreatePolicy, GetPolicy, DeletePolicy, AttachRolePolicy, DetachRolePolicy, PutRolePolicy, GetRolePolicy, DeleteRolePolicy, ListRolePolicies, ListAttachedRolePolicies, CreateAccessKey, ListAccessKeys, DeleteAccessKey, UpdateAccessKey, GetAccessKeyLastUsed, CreateInstanceProfile, GetInstanceProfile, DeleteInstanceProfile, AddRoleToInstanceProfile, RemoveRoleFromInstanceProfile, ListInstanceProfiles, TagInstanceProfile, UntagInstanceProfile, ListInstanceProfileTags, CreateGroup, GetGroup, AddUserToGroup, RemoveUserFromGroup, AttachGroupPolicy, DetachGroupPolicy, ListAttachedGroupPolicies, PutGroupPolicy, GetGroupPolicy, DeleteGroupPolicy, ListGroupPolicies, CreateServiceLinkedRole, DeleteServiceLinkedRole, GetServiceLinkedRoleDeletionStatus, CreateOpenIDConnectProvider, ListOpenIDConnectProviders, CreateSAMLProvider, GetSAMLProvider, ListSAMLProviders, UpdateSAMLProvider, DeleteSAMLProvider, CreateLoginProfile, GetLoginProfile, UpdateLoginProfile, DeleteLoginProfile, CreateVirtualMFADevice, EnableMFADevice, DeactivateMFADevice, ResyncMFADevice, ListMFADevices, ListVirtualMFADevices, DeleteVirtualMFADevice, GetAccountAuthorizationDetails, GenerateServiceLastAccessedDetails, GetServiceLastAccessedDetails, TagRole, UntagRole, TagUser, UntagUser, TagPolicy, UntagPolicy, GenerateCredentialReport, GetCredentialReport, GetAccountSummary, GetAccountPasswordPolicy, UpdateAccountPasswordPolicy, DeleteAccountPasswordPolicy, ListAccountAliases, CreateAccountAlias, DeleteAccountAlias | Role descriptions and permissions boundaries round-trip through role and user reads; boundaries support put/delete updates and limit permissions under `AUTH=true`. |+| **STS** | GetCallerIdentity, AssumeRole, GetSessionToken, GetFederationToken, AssumeRoleWithWebIdentity | || **IMDS** (EC2 Instance Metadata) | `PUT /latest/api/token`, `GET /latest/meta-data/instance-id`, `GET /latest/meta-data/iam/security-credentials/`, `GET /latest/meta-data/iam/security-credentials/<role>`, `GET /latest/meta-data/iam/info`, `GET /latest/meta-data/placement/{region,availability-zone,...}`, `GET /latest/dynamic/instance-identity/document` | IMDSv1 + IMDSv2; default credential chain falls through to a `ministack-instance-role` document with `ASIA*` session creds. Point SDKs at ministack via `AWS_EC2_METADATA_SERVICE_ENDPOINT=http://localhost:4566` (or `ec2_metadata_service_endpoint` in `~/.aws/config`); set `MINISTACK_IMDS_V2_REQUIRED=1` to require the token PUT || **ECS Task Metadata V4** | `GET /v4/<token>`, `GET /v4/<token>/task`, `GET /v4/<token>/stats`, `GET /v4/<token>/task/stats` | Per-container token injected as `ECS_CONTAINER_METADATA_URI_V4` on every container started by `RunTask`. `/task` returns sibling containers in the same task. Containers reach the gateway via `host.docker.internal` (mapped through `extra_hosts: host-gateway`, so it works on user-defined Docker networks); `networkMode: host` containers use loopback. Volatile by design (stripped on persistence, cleared by `/_ministack/reset`) || **ECS Container Credentials** | `GET /v2/credentials/<uuid>` | The path real ECS exposes via `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=/v2/credentials/<uuid>` (resolved by SDKs against `169.254.170.2`). MiniStack serves the same path on the gateway and returns the AWS-strict 5-field credentials document (`AccessKeyId`, `SecretAccessKey`, `Token`, `Expiration`, `RoleArn`) — distinct from the IMDS shape served at `/latest/meta-data/iam/security-credentials/<role>`. `RunTask` injects `AWS_CONTAINER_CREDENTIALS_FULL_URI`, `AWS_CONTAINER_AUTHORIZATION_TOKEN` (satisfies botocore's allow-list for non-loopback gateway hosts), and `AWS_ENDPOINT_URL` so unmodified SDKs inside the task fetch credentials and route service calls through MiniStack with no client config |diff --git a/ministack/core/iam_evaluator.py b/ministack/core/iam_evaluator.pyindex cd69fee4..f7b3566d 100644--- a/ministack/core/iam_evaluator.py+++ b/ministack/core/iam_evaluator.py@@ -3,11 +3,12 @@"""IAM policy evaluation engine.Implements the AWS IAM policy evaluation algorithm (single-account,-no SCPs/permissions boundaries/session policies) behind the AUTH=true flag.+no SCPs) behind the AUTH=true flag.Evaluation order:- 1. Explicit Deny in any applicable policy → DENY- 2. Explicit Allow in any applicable policy → ALLOW+ 1. Explicit Deny in any applicable policy, boundary or session policy → DENY+ 2. Explicit Allow in an identity policy, also allowed by the boundary+ and the session policies → ALLOW3. No matching Allow → implicit DENY"""@@ -47,7 +48,7 @@ class ParsedStatement:@dataclassclass EvalContext:principal_arn: str- principal_type: str # "User", "AssumedRole", "Root"+ principal_type: str # "User", "AssumedRole", "FederatedUser", "Root"principal_account: straction: str # "s3:PutObject"resource_arn: str # "*" until per-service resource ARN construction@@ -71,10 +72,11 @@ class EvalResult:@dataclassclass PrincipalInfo:arn: str- type: str # "User", "AssumedRole", "Root"+ type: str # "User", "AssumedRole", "FederatedUser", "Root"account: strpolicies: list[list[ParsedStatement]] | None # None = root (allow-all)keys: dict[str, Any] = field(default_factory=dict)+ limits: list[list[list[ParsedStatement]]] = field(default_factory=list)@dataclass@@ -567,43 +569,35 @@ def validate_policy_document(doc: str | dict) -> str | None:# Core evaluation# ---------------------------------------------------------------------------+def _first_match(ctx: EvalContext, stmts: list[ParsedStatement],+ effect: str) -> ParsedStatement | None:+ for stmt in stmts:+ if (stmt.effect == effect+ and _action_matches(ctx.action, stmt.actions, stmt.not_actions)+ and _resource_matches(ctx.resource_arn, stmt.resources, stmt.not_resources)+ and _conditions_met(stmt.conditions, ctx)):+ return stmt+ return None++def evaluate(ctx: EvalContext,- policies: list[list[ParsedStatement]]) -> EvalResult:+ policies: list[list[ParsedStatement]],+ *limits: list[list[ParsedStatement]]) -> EvalResult:"""Evaluate all policies against a request context.``policies`` is a list of parsed-statement lists (one per policy document).+ Each of ``limits`` (a permissions boundary, the session policies) has the same shape: a Deny in+ it denies, and an Allow in ``policies`` counts only if every limit allows.Returns Allow, Deny, or ImplicitDeny."""- # Flatten all statements- all_stmts: list[ParsedStatement] = []- for stmts in policies:- all_stmts.extend(stmts)-- # Step 1: explicit Deny- for stmt in all_stmts:- if stmt.effect != "Deny":- continue- if not _action_matches(ctx.action, stmt.actions, stmt.not_actions):- continue- if not _resource_matches(ctx.resource_arn, stmt.resources, stmt.not_resources):- continue- if not _conditions_met(stmt.conditions, ctx):- continue- return EvalResult("Deny", ctx.principal_arn, stmt.sid, "Explicit deny")-- # Step 2: explicit Allow- for stmt in all_stmts:- if stmt.effect != "Allow":- continue- if not _action_matches(ctx.action, stmt.actions, stmt.not_actions):- continue- if not _resource_matches(ctx.resource_arn, stmt.resources, stmt.not_resources):- continue- if not _conditions_met(stmt.conditions, ctx):- continue- return EvalResult("Allow", ctx.principal_arn, stmt.sid, "Explicit allow")-- # Step 3: implicit deny+ layers = [[stmt for stmts in layer for stmt in stmts] for layer in (policies, *limits)]+ for stmts in layers:+ deny = _first_match(ctx, stmts, "Deny")+ if deny:+ return EvalResult("Deny", ctx.principal_arn, deny.sid, "Explicit deny")+ allow = _first_match(ctx, layers[0], "Allow")+ if allow and all(_first_match(ctx, stmts, "Allow") for stmts in layers[1:]):+ return EvalResult("Allow", ctx.principal_arn, allow.sid, "Explicit allow")return EvalResult("ImplicitDeny", ctx.principal_arn, "","No matching Allow statement")@@ -793,6 +787,27 @@ def _gather_user_policies(user_name: str, account_id: str) -> list[list[ParsedStreturn policies+def _permissions_boundary(store, name: str,+ account_id: str) -> list[list[list[ParsedStatement]]]:+ """The evaluation limits a user's or role's permissions boundary sets."""+ arn = (store.get_scoped(account_id, None, name) or {}).get("PermissionsBoundary")+ if not arn:+ return []+ doc = _resolve_managed_policy_document(arn, account_id)+ return [[parse_policy_document(doc) if doc else []]]+++def _session_policy_limits(session: dict,+ account_id: str) -> list[list[list[ParsedStatement]]]:+ """The evaluation limits the session policies of an STS session set."""+ passed = session.get("SessionPolicies")+ if passed is None:+ return []+ docs = [passed["Policy"]] if passed.get("Policy") else []+ docs += [_resolve_managed_policy_document(arn, account_id) for arn in passed.get("PolicyArns", [])]+ return [[parse_policy_document(doc) for doc in docs if doc]]++def _resolve_managed_policy_document(policy_arn: str,account_id: str) -> dict | str | None:"""Resolve a managed policy ARN to its default version's document."""@@ -1090,28 +1105,45 @@ def resolve_principal(access_key_id: str,from ministack.core.responses import _account_from_sts_sessionaccount_id = _account_from_sts_session(access_key_id) or account_id+ from ministack.services import iam as iam_svc+ from ministack.services import sts as sts_svc+credential = credential or resolve_credential(access_key_id, account_id)if isinstance(credential, CredentialResolutionError):return AuthError(credential.code, credential.message)+ session = sts_svc._sessions.get(access_key_id) or {}+ limits = []if credential.principal_type == "Root":policies = Noneelif credential.principal_type == "User":policies = _gather_user_policies(credential.principal_name, account_id)+ limits = _permissions_boundary(iam_svc._users, credential.principal_name, account_id)elif credential.principal_type == "AssumedRole":- policies = _gather_role_policies(- _role_name_from_assumed_arn(credential.principal_arn), account_id- )+ role_name = _role_name_from_assumed_arn(credential.principal_arn)+ policies = _gather_role_policies(role_name, account_id)+ limits = _permissions_boundary(iam_svc._roles, role_name, account_id)+ elif credential.principal_type == "FederatedUser":+ user_name = session.get("PrincipalName")+ if user_name:+ policies = _gather_user_policies(user_name, account_id)+ limits = _permissions_boundary(iam_svc._users, user_name, account_id)+ else:+ # Federated by the account root, which holds every permission.+ policies = [parse_policy_document({"Statement": {"Effect": "Allow", "Action": "*", "Resource": "*"}})]else:return AuthError("UnrecognizedClientException","The security token included in the request is invalid.",)+ if policies is not None:+ limits += _session_policy_limits(session, account_id)return PrincipalInfo(arn=credential.principal_arn,type=credential.principal_type,account=credential.account_id,policies=policies,keys=_principal_keys(credential),+ limits=limits,)@@ -1304,7 +1336,7 @@ def enforce(access_key_id: str, iam_action: str, service: str,principal_keys=principal.keys,)- result = evaluate(ctx, principal.policies)+ result = evaluate(ctx, principal.policies, *principal.limits)if result.decision == "Allow":return Nonediff --git a/ministack/core/rds_iam.py b/ministack/core/rds_iam.pyindex a6035f37..0b553400 100644--- a/ministack/core/rds_iam.py+++ b/ministack/core/rds_iam.py@@ -296,7 +296,7 @@ def authorize_rds_iam_token(principal_arn=principal.arn, principal_type=principal.type,principal_account=account_id, action="rds-db:connect",resource_arn=resource_arn, region=region, principal_keys=principal.keys,- ), principal.policies)+ ), principal.policies, *principal.limits)if result.decision != "Allow":return RdsIamAuthorizationError(result.decision)return AuthorizedRdsConnection(verified, resource_arn)diff --git a/ministack/core/router.py b/ministack/core/router.pyindex 7b2937b8..ec6929d8 100644--- a/ministack/core/router.py+++ b/ministack/core/router.py@@ -961,6 +961,8 @@ def detect_service(method: str, path: str, headers: dict, query_params: dict) ->"UpdateRoleDescription": "iam","PutRolePermissionsBoundary": "iam","DeleteRolePermissionsBoundary": "iam",+ "PutUserPermissionsBoundary": "iam",+ "DeleteUserPermissionsBoundary": "iam","AttachUserPolicy": "iam","DetachUserPolicy": "iam","ListAttachedUserPolicies": "iam",@@ -976,6 +978,7 @@ def detect_service(method: str, path: str, headers: dict, query_params: dict) ->"GetCallerIdentity": "sts","AssumeRole": "sts","GetSessionToken": "sts",+ "GetFederationToken": "sts","AssumeRoleWithWebIdentity": "sts","AssumeRoleWithSAML": "sts",# CloudWatch actionsdiff --git a/ministack/services/iam.py b/ministack/services/iam.pyindex d0e6ddb6..ba862725 100644--- a/ministack/services/iam.py+++ b/ministack/services/iam.py@@ -45,6 +45,7 @@ from urllib.parse import parse_qsfrom urllib.parse import quote as _url_quotefrom xml.sax.saxutils import escape as _xml_escape+from ministack.core.arn import ArnParseError, parse_arnfrom ministack.core.responses import AccountScopedDict, get_account_id, get_region, new_uuidlogger = logging.getLogger("iam")@@ -202,6 +203,13 @@ def _policy_exists(arn: str) -> bool:return _lookup_policy(arn) is not None+def policy_known(arn: str, account_id: str | None = None) -> bool:+ """Whether ``arn`` names a known AWS managed policy or one stored in ``account_id`` (default: the caller's)."""+ if _is_aws_managed_arn(arn) or account_id is None:+ return _lookup_policy(arn) is not None+ return _policies.get_scoped(account_id, None, arn) is not None++def _seed_aws_managed_policies() -> None:"""Seed the global AWS-managed policy store with the canonicaldocuments for the most commonly referenced AWS-managed policies.@@ -420,6 +428,9 @@ def _create_user(p):if name in _users:return _error(409, "EntityAlreadyExists",f"User with name {name} already exists.", ns="iam")+ boundary_err = _p(p, "PermissionsBoundary") and _boundary_policy_error(_p(p, "PermissionsBoundary"))+ if boundary_err:+ return boundary_errtags = _extract_tags(p)if _identity_tags_have_duplicate_keys(tags):return _error(400, "InvalidInput", DUPLICATE_IDENTITY_TAG_KEYS, ns="iam")@@ -462,7 +473,7 @@ def _get_user(p):def _list_users(p):prefix = _p(p, "PathPrefix") or "/"members = "".join(- f"<member>{_user_xml(n)}</member>"+ f"<member>{_user_xml(n, boundary=False)}</member>"for n, u in _users.items()if u.get("Path", "/").startswith(prefix))@@ -478,6 +489,9 @@ def _put_user_permissions_boundary(p):if not user:return _error(404, "NoSuchEntity",f"The user with name {name} cannot be found.", ns="iam")+ boundary_err = _boundary_policy_error(_p(p, "PermissionsBoundary"))+ if boundary_err:+ return boundary_erruser["PermissionsBoundary"] = _p(p, "PermissionsBoundary")return _xml(200, "PutUserPermissionsBoundaryResponse", "", ns="iam")@@ -488,6 +502,9 @@ def _delete_user_permissions_boundary(p):if not user:return _error(404, "NoSuchEntity",f"The user with name {name} cannot be found.", ns="iam")+ absent_err = _absent_boundary_error(user, user["UserId"])+ if absent_err:+ return absent_erruser["PermissionsBoundary"] = Nonereturn _xml(200, "DeleteUserPermissionsBoundaryResponse", "", ns="iam")@@ -549,6 +566,9 @@ def _create_role(p):if name in _roles:return _error(409, "EntityAlreadyExists",f"Role with name {name} already exists.", ns="iam")+ boundary_err = _p(p, "PermissionsBoundary") and _boundary_policy_error(_p(p, "PermissionsBoundary"))+ if boundary_err:+ return boundary_errtags = _extract_tags(p)if _identity_tags_have_duplicate_keys(tags):return _error(400, "InvalidInput", DUPLICATE_IDENTITY_TAG_KEYS, ns="iam")@@ -585,7 +605,7 @@ def _get_role(p):def _list_roles(p):prefix = _p(p, "PathPrefix") or "/"members = "".join(- f"<member>{_role_xml(n)}</member>"+ f"<member>{_role_xml(n, boundary=False)}</member>"for n, r in _roles.items()if r.get("Path", "/").startswith(prefix))@@ -662,6 +682,9 @@ def _put_role_permissions_boundary(p):if not role:return _error(404, "NoSuchEntity",f"Role {name} not found.", ns="iam")+ boundary_err = _boundary_policy_error(_p(p, "PermissionsBoundary"))+ if boundary_err:+ return boundary_errrole["PermissionsBoundary"] = _p(p, "PermissionsBoundary")return _xml(200, "PutRolePermissionsBoundaryResponse", "", ns="iam")@@ -672,10 +695,45 @@ def _delete_role_permissions_boundary(p):if not role:return _error(404, "NoSuchEntity",f"Role {name} not found.", ns="iam")+ absent_err = _absent_boundary_error(role, role["RoleId"])+ if absent_err:+ return absent_errrole["PermissionsBoundary"] = Nonereturn _xml(200, "DeleteRolePermissionsBoundaryResponse", "", ns="iam")+def _boundary_policy_error(arn):+ """Under AUTH, ValidationError for a malformed ARN and NoSuchEntity unless it names a known policy."""+ from ministack.app import AUTH+ if not AUTH:+ return None+ try:+ parse_arn(arn)+ except ArnParseError:+ return _error(400, "ValidationError", "Invalid ARN: Could not be parsed!", ns="iam")+ if _policy_exists(arn):+ return None+ return _error(404, "NoSuchEntity",+ f"Scope ARN: {arn} does not exist or is not attachable.", ns="iam")+++def _absent_boundary_error(entity, principal_id):+ """Under AUTH, NoSuchEntity for deleting a permissions boundary that is not set."""+ from ministack.app import AUTH+ if AUTH and not entity.get("PermissionsBoundary"):+ return _error(404, "NoSuchEntity", f"Principal {principal_id} does not have scope", ns="iam")+ return None+++def _boundary_usage_counts():+ """The number of users and roles that use each policy ARN as their permissions boundary."""+ counts = {}+ for entity in (*_roles.values(), *_users.values()):+ if entity.get("PermissionsBoundary"):+ counts[entity["PermissionsBoundary"]] = counts.get(entity["PermissionsBoundary"], 0) + 1+ return counts++# -------------------- Managed policy management --------------------def store_policy(arn: str, name: str, path: str, document, *,@@ -857,18 +915,19 @@ def _list_policies(p):scope = _p(p, "Scope") or "All"prefix = _p(p, "PathPrefix") or "/"members = ""+ usage_counts = _boundary_usage_counts()# Customer-managed policies — always returned unless scope == "AWS".if scope != "AWS":for arn, pol in _policies.items():if not pol.get("Path", "/").startswith(prefix):continue- members += f"<member>{_managed_policy_xml(arn)}</member>"+ members += f"<member>{_managed_policy_xml(arn, usage_counts)}</member>"# AWS-managed policies — returned for scope "All" or "AWS".if scope != "Local":for arn, pol in _aws_managed_policies.items():if not pol.get("Path", "/").startswith(prefix):continue- members += f"<member>{_managed_policy_xml(arn)}</member>"+ members += f"<member>{_managed_policy_xml(arn, usage_counts)}</member>"return _xml(200, "ListPoliciesResponse",f"<ListPoliciesResult><Policies>{members}</Policies>""<IsTruncated>false</IsTruncated></ListPoliciesResult>",@@ -883,7 +942,8 @@ def _delete_policy(p):if arn not in _policies:return _error(404, "NoSuchEntity", f"Policy {arn} not found.", ns="iam")pol = _policies[arn]- if pol.get("AttachmentCount", 0) > 0:+ from ministack.app import AUTH+ if pol.get("AttachmentCount", 0) > 0 or (AUTH and _boundary_usage_counts().get(arn)):return _error(409, "DeleteConflict","Cannot delete a policy attached to entities.", ns="iam")del _policies[arn]@@ -898,13 +958,18 @@ def _list_entities_for_policy(p):return _error(404, "NoSuchEntity", f"Policy {arn} not found.", ns="iam")entity_filter = _p(p, "EntityFilter") or ""path_prefix = _p(p, "PathPrefix") or "/"+ usage_filter = _p(p, "PolicyUsageFilter")++ def uses(entity):+ return ((usage_filter != "PermissionsBoundary" and arn in entity.get("AttachedPolicies", []))+ or (usage_filter != "PermissionsPolicy" and entity.get("PermissionsBoundary") == arn))groups_xml = ""if entity_filter in ("", "Group"):for g in _groups.values():if not g.get("Path", "/").startswith(path_prefix):continue- if arn in g.get("AttachedPolicies", []):+ if uses(g):groups_xml += (f"<member><GroupName>{g['GroupName']}</GroupName>"f"<GroupId>{g['GroupId']}</GroupId></member>")@@ -913,7 +978,7 @@ def _list_entities_for_policy(p):for r in _roles.values():if not r.get("Path", "/").startswith(path_prefix):continue- if arn in r.get("AttachedPolicies", []):+ if uses(r):roles_xml += (f"<member><RoleName>{r['RoleName']}</RoleName>"f"<RoleId>{r['RoleId']}</RoleId></member>")@@ -922,7 +987,7 @@ def _list_entities_for_policy(p):for u in _users.values():if not u.get("Path", "/").startswith(path_prefix):continue- if arn in u.get("AttachedPolicies", []):+ if uses(u):users_xml += (f"<member><UserName>{u['UserName']}</UserName>"f"<UserId>{u['UserId']}</UserId></member>")@@ -2982,7 +3047,7 @@ def _extract_tag_keys(p):# -------------------- XML builders ---------------------def _user_xml(name):+def _user_xml(name, boundary=True):u = _users[name]# Tags are emitted when present (#441). _role_xml follows the same pattern.tags_xml = ""@@ -2993,7 +3058,7 @@ def _user_xml(name):)tags_xml = f"<Tags>{tag_members}</Tags>"boundary_xml = ""- if u.get("PermissionsBoundary"):+ if boundary and u.get("PermissionsBoundary"):boundary_xml = ("<PermissionsBoundary>""<PermissionsBoundaryType>PermissionsBoundaryPolicy</PermissionsBoundaryType>"@@ -3009,7 +3074,7 @@ def _user_xml(name):f"{tags_xml}")-def _role_xml(name):+def _role_xml(name, boundary=True):r = _roles[name]assume_doc = _url_quote(r.get("AssumeRolePolicyDocument") or "{}", safe="")desc = r.get("Description") or ""@@ -3022,7 +3087,7 @@ def _role_xml(name):)tags_xml = f"<Tags>{tag_members}</Tags>"boundary_xml = ""- if r.get("PermissionsBoundary"):+ if boundary and r.get("PermissionsBoundary"):boundary_xml = ("<PermissionsBoundary>""<PermissionsBoundaryType>PermissionsBoundaryPolicy</PermissionsBoundaryType>"@@ -3041,7 +3106,7 @@ def _role_xml(name):f"{tags_xml}")-def _managed_policy_xml(arn):+def _managed_policy_xml(arn, usage_counts=None):pol = _lookup_policy(arn)# Description is omitted when empty to match real AWS (#438).description = pol.get("Description") or ""@@ -3069,6 +3134,9 @@ def _managed_policy_xml(arn):f"<PolicyId>{pol['PolicyId']}</PolicyId>"f"<DefaultVersionId>{pol['DefaultVersionId']}</DefaultVersionId>"f"<AttachmentCount>{attachment_count}</AttachmentCount>"+ f"<PermissionsBoundaryUsageCount>"+ f"{(_boundary_usage_counts() if usage_counts is None else usage_counts).get(arn, 0)}"+ f"</PermissionsBoundaryUsageCount>"f"<IsAttachable>true</IsAttachable>"f"<CreateDate>{pol['CreateDate']}</CreateDate>"f"<UpdateDate>{pol.get('UpdateDate', pol['CreateDate'])}</UpdateDate>"diff --git a/ministack/services/sts.py b/ministack/services/sts.pyindex 3d840f32..460b8d78 100644--- a/ministack/services/sts.py+++ b/ministack/services/sts.py@@ -5,7 +5,7 @@ STS Service Emulator (AWS-compatible).Actions:GetCallerIdentity, AssumeRole, AssumeRoleWithWebIdentity,- GetSessionToken, GetAccessKeyInfo, GetWebIdentityToken.+ GetSessionToken, GetFederationToken, GetAccessKeyInfo, GetWebIdentityToken."""import base64@@ -27,6 +27,7 @@ from ministack.core.iam_evaluator import (find_iam_access_key_account,is_root_access_key,resolve_credential,+ validate_policy_document,)from ministack.core.responses import (_account_from_sts_session,@@ -49,6 +50,7 @@ from ministack.services.iam import (_gen_session_token,_p,_xml,+ policy_known,)_sessions: dict[str, dict] = {}@@ -209,6 +211,54 @@ def _session_tags(params: dict, check=True):return tags, None+def _session_policies(params, account_id=None, check=True):+ """Policy and PolicyArns of a request, or with *check* its validation error (ARNs must be in ``account_id``)."""+ policy = _p(params, "Policy")+ arns = [a.get("arn", "") for a in params.get("PolicyArns", []) if isinstance(a, dict)]+ while arn := _p(params, f"PolicyArns.member.{len(arns) + 1}.arn"):+ arns.append(arn)+ if not check:+ return {"Policy": policy, "PolicyArns": arns}, None+ if len(policy) > 2048:+ return None, _error(400, "ValidationError",+ f"1 validation error detected: Value '{escape(policy)}' at 'policy' failed to satisfy "+ "constraint: Member must have length less than or equal to 2048", ns="sts")+ malformed = policy and validate_policy_document(policy)+ if malformed:+ return None, _error(400, "MalformedPolicyDocument", escape(malformed), ns="sts")+ if not all(policy_known(arn, account_id) for arn in arns):+ return None, _error(400, "ValidationError",+ "At least one Policy ARN in the PolicyArns parameter does not match "+ "an existing IAM Managed Policy ARN.", ns="sts")+ return {"Policy": policy, "PolicyArns": arns}, None+++def _federated_name_error(name):+ """ValidationError unless ``name`` is a valid GetFederationToken Name."""+ if name is None:+ constraint = "Member must not be null"+ elif len(name) < 2:+ constraint = "Member must have length greater than or equal to 2"+ elif len(name) > 32:+ constraint = "Member must have length less than or equal to 32"+ elif not re.fullmatch(r"[\w+=,.@-]*", name, re.ASCII):+ constraint = "Member must satisfy regular expression pattern: [\\w+=,.@-]*"+ else:+ return None+ value = "null" if name is None else f"'{escape(name)}'"+ return _error(400, "ValidationError",+ f"1 validation error detected: Value {value} at 'name' failed to satisfy constraint: {constraint}",+ ns="sts")+++def _session_caller_refused(caller, action):+ """AccessDenied for temporary credentials under AUTH, or None."""+ from ministack.app import AUTH+ if AUTH and caller["isTemporary"]:+ return _error(403, "AccessDenied", f"Cannot call {action} with session credentials", ns="sts")+ return None++def _invalid_role_arn(role_arn: str):return _error(400, "ValidationError", f"Invalid RoleArn: {role_arn}", ns="sts")@@ -312,6 +362,9 @@ async def handle_request(method, path, headers, body, query_params):return validation_errorfrom ministack.app import AUTHsession_tags, validation_error = _session_tags(params, check=AUTH)+ if validation_error:+ return validation_error+ session_policies, validation_error = _session_policies(params, role_arn.split(":")[4], check=AUTH)if validation_error:return validation_errorcaller = _caller_identity(headers, query_params)@@ -393,6 +446,7 @@ async def handle_request(method, path, headers, body, query_params):"SourceAccessKeyId": caller["accessKey"],"SourcePrincipalArn": caller["userArn"],"SessionTags": session_tags,+ "SessionPolicies": session_policies if any(session_policies.values()) else None,})if use_json:return json_response({@@ -477,14 +531,9 @@ async def handle_request(method, path, headers, body, query_params):caller = _caller_identity(headers, query_params)if isinstance(caller, CredentialResolutionError):return _credential_error_response(caller)- from ministack.app import AUTH- if AUTH and caller["isTemporary"]:- return _error(- 403,- "AccessDenied",- "Cannot call GetSessionToken with session credentials",- ns="sts",- )+ refused = _session_caller_refused(caller, action)+ if refused:+ return refusedregister_session(access_key, {"Arn": caller["userArn"],"UserId": caller["userId"],@@ -512,6 +561,66 @@ async def handle_request(method, path, headers, body, query_params):f"</GetSessionTokenResult>",ns="sts")+ if action == "GetFederationToken":+ name = _p(params, "Name", None)+ validation_error = _federated_name_error(name)+ if validation_error:+ return validation_error+ session_tags, validation_error = _session_tags(params)+ if validation_error:+ return validation_error+ session_policies, validation_error = _session_policies(params)+ if validation_error:+ return validation_error+ caller = _caller_identity(headers, query_params)+ if isinstance(caller, CredentialResolutionError):+ return _credential_error_response(caller)+ refused = _session_caller_refused(caller, action)+ if refused:+ return refused+ duration = int(_p(params, "DurationSeconds") or 43200)+ access_key = _gen_session_access_key()+ secret_key = _gen_secret()+ session_token = _gen_session_token()+ federated_arn = f"arn:aws:sts::{caller['accountId']}:federated-user/{name}"+ federated_id = f"{caller['accountId']}:{name}"+ register_session(access_key, {+ "Arn": federated_arn,+ "UserId": federated_id,+ "SecretAccessKey": secret_key,+ "SessionToken": session_token,+ "Expiration": time.time() + duration,+ "AccountId": caller["accountId"],+ "PrincipalType": "FederatedUser",+ "PrincipalName": caller["principalName"],+ "SourceAccessKeyId": caller["accessKey"],+ "SourcePrincipalArn": caller["userArn"],+ "SessionTags": session_tags,+ "SessionPolicies": session_policies,+ })+ if use_json:+ return json_response({+ "Credentials": {"AccessKeyId": access_key, "SecretAccessKey": secret_key,+ "SessionToken": session_token, "Expiration": int(time.time() + duration)},+ "FederatedUser": {"FederatedUserId": federated_id, "Arn": federated_arn},+ "PackedPolicySize": 0,+ })+ return _xml(200, "GetFederationTokenResponse",+ f"<GetFederationTokenResult>"+ f"<Credentials>"+ f"<AccessKeyId>{access_key}</AccessKeyId>"+ f"<SecretAccessKey>{secret_key}</SecretAccessKey>"+ f"<SessionToken>{session_token}</SessionToken>"+ f"<Expiration>{_future(duration)}</Expiration>"+ f"</Credentials>"+ f"<FederatedUser>"+ f"<FederatedUserId>{federated_id}</FederatedUserId>"+ f"<Arn>{federated_arn}</Arn>"+ f"</FederatedUser>"+ f"<PackedPolicySize>0</PackedPolicySize>"+ f"</GetFederationTokenResult>",+ ns="sts")+if action == "GetAccessKeyInfo":key_id = _p(params, "AccessKeyId", None)problems = _access_key_id_problems(key_id)diff --git a/tests/test_iam.py b/tests/test_iam.pyindex f05aa970..df8aae9d 100644--- a/tests/test_iam.py+++ b/tests/test_iam.py@@ -156,6 +156,146 @@ def test_iam_user_permissions_boundary_missing_user(iam, operation):assert exc.value.response["Error"]["Code"] == "NoSuchEntity"+def _boundary_policy(iam, name):+ doc = json.dumps({"Version": "2012-10-17", "Statement": [+ {"Effect": "Allow", "Action": "sqs:ListQueues", "Resource": "*"}]})+ return iam.create_policy(PolicyName=name, PolicyDocument=doc)["Policy"]["Arn"]+++def _iam_action(monkeypatch, auth, action, **params):+ """Run one IAM query action in-process with AUTH set to *auth*; return (status, body)."""+ import asyncio+ from urllib.parse import urlencode++ from ministack import app as app_mod+ from ministack.services import iam as iam_svc++ monkeypatch.setattr(app_mod, "AUTH", auth)+ body = urlencode({"Action": action, "Version": "2010-05-08", **params}).encode()+ status, _headers, payload = asyncio.run(iam_svc.handle_request("POST", "/", {}, body, {}))+ return status, payload.decode()+++def _message(body):+ return body.split("<Message>", 1)[1].split("</Message>", 1)[0]++[email protected]("auth", [True, False])[email protected]("kind", ["customer", "aws"])[email protected]("operation", [+ "CreateRole", "CreateUser", "PutRolePermissionsBoundary", "PutUserPermissionsBoundary"])+def test_iam_permissions_boundary_must_name_a_known_policy_under_auth(monkeypatch, auth, kind, operation):+ name = f"boundary-missing-{_uuid_mod.uuid4().hex[:8]}"+ missing = f"arn:aws:iam::{'aws' if kind == 'aws' else '000000000000'}:policy/{name}"+ entity = "Role" if "Role" in operation else "User"+ key = {f"{entity}Name": name}+ create = {"AssumeRolePolicyDocument": "{}"} if entity == "Role" else {}+ if operation.startswith("Put"):+ assert _iam_action(monkeypatch, False, f"Create{entity}", **key, **create)[0] == 200+ params = {**key, **(create if operation.startswith("Create") else {})}+ try:+ status, body = _iam_action(monkeypatch, auth, operation, PermissionsBoundary=missing, **params)+ if auth:+ assert (status, f"Scope ARN: {missing} does not exist or is not attachable.") == (404, _message(body))+ else:+ assert status == 200+ finally:+ _iam_action(monkeypatch, False, f"Delete{entity}", **key)++[email protected]("auth, status", [(True, 400), (False, 200)])+def test_iam_permissions_boundary_must_be_an_arn_under_auth(monkeypatch, auth, status):+ name = f"boundary-malformed-{_uuid_mod.uuid4().hex[:8]}"+ _iam_action(monkeypatch, False, "CreateUser", UserName=name)+ try:+ got, body = _iam_action(monkeypatch, auth, "PutUserPermissionsBoundary", UserName=name,+ PermissionsBoundary=f"not-an-arn-{name}")+ assert got == status+ if auth:+ assert _message(body) == "Invalid ARN: Could not be parsed!"+ finally:+ _iam_action(monkeypatch, False, "DeleteUser", UserName=name)++[email protected]("auth, status", [(True, 404), (False, 200)])[email protected]("entity", ["Role", "User"])+def test_iam_delete_absent_permissions_boundary_under_auth(monkeypatch, auth, status, entity):+ name = f"boundary-absent-{_uuid_mod.uuid4().hex[:8]}"+ create = {"AssumeRolePolicyDocument": "{}"} if entity == "Role" else {}+ _, created = _iam_action(monkeypatch, False, f"Create{entity}", **{f"{entity}Name": name}, **create)+ principal_id = created.split(f"<{entity}Id>", 1)[1].split("<", 1)[0]+ try:+ got, body = _iam_action(monkeypatch, auth, f"Delete{entity}PermissionsBoundary", **{f"{entity}Name": name})+ assert got == status+ if auth:+ assert _message(body) == f"Principal {principal_id} does not have scope"+ finally:+ _iam_action(monkeypatch, False, f"Delete{entity}", **{f"{entity}Name": name})++[email protected]("auth, status", [(True, 409), (False, 200)])+def test_iam_delete_policy_in_use_as_a_boundary_under_auth(monkeypatch, auth, status):+ name = f"boundary-delete-{_uuid_mod.uuid4().hex[:8]}"+ _, created = _iam_action(monkeypatch, False, "CreatePolicy", PolicyName=name, PolicyDocument=json.dumps(+ {"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "sqs:ListQueues", "Resource": "*"}]}))+ arn = created.split("<Arn>", 1)[1].split("<", 1)[0]+ _iam_action(monkeypatch, False, "CreateUser", UserName=name, PermissionsBoundary=arn)+ try:+ assert _iam_action(monkeypatch, auth, "DeletePolicy", PolicyArn=arn)[0] == status+ finally:+ _iam_action(monkeypatch, False, "DeleteUser", UserName=name)+ _iam_action(monkeypatch, False, "DeletePolicy", PolicyArn=arn)+++def test_iam_permissions_boundary_uses_are_listed_as_policy_entities(iam):+ name = f"boundary-entities-{_uuid_mod.uuid4().hex[:8]}"+ boundary = _boundary_policy(iam, name)+ iam.create_user(UserName=name, PermissionsBoundary=boundary)+ iam.create_role(RoleName=name, PermissionsBoundary=boundary,+ AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}))++ def entities(**kwargs):+ resp = iam.list_entities_for_policy(PolicyArn=boundary, **kwargs)+ return [r["RoleName"] for r in resp["PolicyRoles"]], [u["UserName"] for u in resp["PolicyUsers"]]++ assert entities() == ([name], [name])+ assert entities(PolicyUsageFilter="PermissionsBoundary") == ([name], [name])+ assert entities(PolicyUsageFilter="PermissionsPolicy") == ([], [])+ listed_user = next(u for u in iam.list_users()["Users"] if u["UserName"] == name)+ listed_role = next(r for r in iam.list_roles()["Roles"] if r["RoleName"] == name)+ assert "PermissionsBoundary" not in listed_user and "PermissionsBoundary" not in listed_role+ iam.delete_user(UserName=name)+ iam.delete_role(RoleName=name)+ iam.delete_policy(PolicyArn=boundary)+++def test_iam_permissions_boundary_accepts_an_aws_managed_policy(iam):+ name = f"boundary-managed-{_uuid_mod.uuid4().hex[:8]}"+ boundary = "arn:aws:iam::aws:policy/ReadOnlyAccess"+ iam.create_user(UserName=name)+ iam.put_user_permissions_boundary(UserName=name, PermissionsBoundary=boundary)+ assert iam.get_user(UserName=name)["User"]["PermissionsBoundary"]["PermissionsBoundaryArn"] == boundary+ iam.delete_user(UserName=name)+++def test_iam_policy_counts_its_permissions_boundary_uses(iam):+ name = f"boundary-count-{_uuid_mod.uuid4().hex[:8]}"+ boundary = _boundary_policy(iam, name)+ assert iam.get_policy(PolicyArn=boundary)["Policy"]["PermissionsBoundaryUsageCount"] == 0+ iam.create_user(UserName=f"{name}-user", PermissionsBoundary=boundary)+ iam.create_role(RoleName=f"{name}-role", PermissionsBoundary=boundary,+ AssumeRolePolicyDocument=json.dumps({"Version": "2012-10-17", "Statement": []}))+ policy = iam.get_policy(PolicyArn=boundary)["Policy"]+ assert (policy["AttachmentCount"], policy["PermissionsBoundaryUsageCount"]) == (0, 2)+ listed = next(p for p in iam.list_policies(Scope="Local")["Policies"] if p["Arn"] == boundary)+ assert listed["PermissionsBoundaryUsageCount"] == 2+ iam.delete_user(UserName=f"{name}-user")+ iam.delete_role_permissions_boundary(RoleName=f"{name}-role")+ assert iam.get_policy(PolicyArn=boundary)["Policy"]["PermissionsBoundaryUsageCount"] == 0+ iam.delete_role(RoleName=f"{name}-role")+ iam.delete_policy(PolicyArn=boundary)++def test_iam_list_roles(iam):resp = iam.list_roles()names = [r["RoleName"] for r in resp["Roles"]]diff --git a/tests/test_iam_auth.py b/tests/test_iam_auth.pyindex 14315849..504eac18 100644--- a/tests/test_iam_auth.py+++ b/tests/test_iam_auth.py@@ -306,6 +306,16 @@ class TestEvaluate:assert evaluate(_ctx(action="s3:DeleteBucket"), [allow, deny]).decision == "Deny"assert evaluate(_ctx(action="s3:PutObject"), [allow, deny]).decision == "Allow"+ def test_every_limit_must_allow(self):+ identity = parse_policy_document(+ {"Statement": [{"Effect": "Allow", "Action": ["s3:*", "sqs:*"], "Resource": "*"}]})+ boundary = parse_policy_document(+ {"Statement": [{"Effect": "Allow", "Action": ["s3:*", "ec2:*"], "Resource": "*"}]})+ assert evaluate(_ctx(action="s3:PutObject"), [identity], [boundary]).decision == "Allow"+ assert evaluate(_ctx(action="sqs:SendMessage"), [identity], [boundary]).decision == "ImplicitDeny"+ assert evaluate(_ctx(action="ec2:RunInstances"), [identity], [boundary]).decision == "ImplicitDeny"+ assert evaluate(_ctx(action="s3:PutObject"), [identity], []).decision == "ImplicitDeny"+# ---------------------------------------------------------------------------# Condition operators (per IAM condition operators reference)@@ -1102,6 +1112,182 @@ class TestEnforce:iam_svc._access_keys.pop(fake_key, None)iam_svc._users.pop("inline-user", None)iam_svc._user_inline_policies.pop("inline-user", None)+++_PROBES = {"S": "sqs:ListQueues", "D": "dynamodb:ListTables",+ "B": "s3:ListAllMyBuckets", "L": "logs:DescribeLogGroups"}+_IDENTITY = {"Statement": [{"Effect": "Allow", "Resource": "*",+ "Action": ["sqs:ListQueues", "dynamodb:ListTables", "logs:DescribeLogGroups"]}]}+_BOUNDARY = {"Statement": [+ {"Effect": "Allow", "Resource": "*",+ "Action": ["sqs:ListQueues", "dynamodb:ListTables", "s3:ListAllMyBuckets"]},+ {"Effect": "Deny", "Action": "dynamodb:ListTables", "Resource": "*"},+]}+++def _allowed(access_key):+ """The probe actions ``enforce`` lets through, as letters."""+ return "".join(letter for letter, action in _PROBES.items()+ if enforce(access_key, action, action.split(":")[0], "us-east-1") is None)+++def _iam_call(action, **params):+ from ministack.services import iam as iam_svc+ status, _headers, body = iam_svc._IAM_HANDLERS[action](+ {"Action": [action], **{k: [v] for k, v in params.items()}})+ assert status == 200, body+ return body+++def boundary_principals():+ """A user and a role session with the probe identity policy, and a boundary policy."""+ from ministack.services import iam as iam_svc+ from ministack.services import sts as sts_svc+ boundary = "arn:aws:iam::000000000000:policy/probe-boundary"+ iam_svc.store_policy(boundary, "probe-boundary", "/", json.dumps(_BOUNDARY))+ _iam_call("CreateUser", UserName="probe-user")+ _iam_call("PutUserPolicy", UserName="probe-user", PolicyName="identity",+ PolicyDocument=json.dumps(_IDENTITY))+ iam_svc._access_keys["AKIATESTBOUNDARY01"] = {+ "UserName": "probe-user", "AccessKeyId": "AKIATESTBOUNDARY01",+ "SecretAccessKey": "s", "Status": "Active", "CreateDate": "2024-01-01",+ }+ _iam_call("CreateRole", RoleName="probe-role", AssumeRolePolicyDocument=json.dumps({"Statement": [+ {"Effect": "Allow", "Principal": {"AWS": "000000000000"}, "Action": "sts:AssumeRole"}]}))+ _iam_call("PutRolePolicy", RoleName="probe-role", PolicyName="identity",+ PolicyDocument=json.dumps(_IDENTITY))+ sts_svc._sessions["ASIATESTBOUNDARY01"] = {+ "Arn": "arn:aws:sts::000000000000:assumed-role/probe-role/s",+ "UserId": "AROA123:s", "SecretAccessKey": "s", "PrincipalType": "AssumedRole",+ "AccountId": "000000000000", "Expiration": time.time() + 3600,+ }+ try:+ yield {"user": "AKIATESTBOUNDARY01", "role": "ASIATESTBOUNDARY01", "boundary": boundary}+ finally:+ sts_svc._sessions.pop("ASIATESTBOUNDARY01", None)+ iam_svc._access_keys.pop("AKIATESTBOUNDARY01", None)+ iam_svc._user_inline_policies.pop("probe-user", None)+ iam_svc._users.pop("probe-user", None)+ iam_svc._roles.pop("probe-role", None)+ iam_svc._policies.pop(boundary, None)+++class TestPermissionsBoundary:+ """A boundary limits identity policies: only actions both allow pass, and its Deny denies."""++ @pytest.mark.parametrize("kind", ["user", "role"])+ def test_boundary_limits_identity_policies(self, boundary_principals, kind):+ key, boundary = boundary_principals[kind], boundary_principals["boundary"]+ name = {"UserName": "probe-user"} if kind == "user" else {"RoleName": "probe-role"}+ entity = "User" if kind == "user" else "Role"+ assert _allowed(key) == "SDL"+ _iam_call(f"Put{entity}PermissionsBoundary", PermissionsBoundary=boundary, **name)+ assert _allowed(key) == "S"+ _iam_call(f"Delete{entity}PermissionsBoundary", **name)+ assert _allowed(key) == "SDL"++ def test_boundary_set_at_creation(self, boundary_principals):+ from ministack.services import iam as iam_svc+ _iam_call("CreateUser", UserName="probe-user-2", PermissionsBoundary=boundary_principals["boundary"])+ _iam_call("PutUserPolicy", UserName="probe-user-2", PolicyName="identity",+ PolicyDocument=json.dumps(_IDENTITY))+ iam_svc._access_keys["AKIATESTBOUNDARY02"] = {+ "UserName": "probe-user-2", "AccessKeyId": "AKIATESTBOUNDARY02",+ "SecretAccessKey": "s", "Status": "Active", "CreateDate": "2024-01-01",+ }+ try:+ assert _allowed("AKIATESTBOUNDARY02") == "S"+ denied = enforce("AKIATESTBOUNDARY02", "dynamodb:ListTables", "dynamodb", "us-east-1")+ assert denied.decision == "Deny"+ finally:+ iam_svc._access_keys.pop("AKIATESTBOUNDARY02", None)+ iam_svc._user_inline_policies.pop("probe-user-2", None)+ iam_svc._users.pop("probe-user-2", None)+++def _sts_key(access_key, **params):+ """Call STS in-process as ``access_key`` and return the issued access key."""+ import re+ from urllib.parse import urlencode++ from ministack.services import sts as sts_svc+ headers = {+ "authorization": f"AWS4-HMAC-SHA256 Credential={access_key}/20260930/us-east-1/sts/aws4_request",+ "content-type": "application/x-www-form-urlencoded",+ }+ body = urlencode({"Version": "2011-06-15", **params}).encode()+ status, _headers, payload = asyncio.run(sts_svc.handle_request("POST", "/", headers, body, {}))+ assert status == 200, payload+ return re.search(r"<AccessKeyId>(.*?)</AccessKeyId>", payload.decode()).group(1)+++def _allow(*actions, deny=None):+ stmts = [{"Effect": "Allow", "Action": list(actions), "Resource": "*"}]+ if deny:+ stmts.append({"Effect": "Deny", "Action": deny, "Resource": "*"})+ return json.dumps({"Version": "2012-10-17", "Statement": stmts})+++def issued_sessions():+ from ministack.services import sts as sts_svc+ before = set(sts_svc._sessions)+ yield+ for key in set(sts_svc._sessions) - before:+ sts_svc._sessions.pop(key, None)+++class TestSessionPolicies:+ """Session policies narrow a session to what both allow; a federated user without one gets nothing."""++ def _assume(self, **params):+ return _sts_key("test", Action="AssumeRole", RoleSessionName="s",+ RoleArn="arn:aws:iam::000000000000:role/probe-role", **params)++ def test_session_policy_limits_the_role(self, boundary_principals, issued_sessions):+ from ministack.services import iam as iam_svc+ logs = "arn:aws:iam::000000000000:policy/probe-logs"+ iam_svc.store_policy(logs, "probe-logs", "/", _allow("logs:DescribeLogGroups"))+ try:+ assert _allowed(self._assume()) == "SDL"+ assert _allowed(self._assume(Policy=_allow("sqs:ListQueues", "s3:ListAllMyBuckets"))) == "S"+ assert _allowed(self._assume(**{"PolicyArns.member.1.arn": logs})) == "L"+ assert _allowed(self._assume(Policy=_allow("*", deny="dynamodb:ListTables"))) == "SL"+ finally:+ iam_svc._policies.pop(logs, None)++ def test_session_policy_and_boundary_both_limit(self, boundary_principals, issued_sessions):+ _iam_call("PutRolePermissionsBoundary", RoleName="probe-role",+ PermissionsBoundary=boundary_principals["boundary"])+ assert _allowed(self._assume(Policy=_allow("dynamodb:ListTables", "logs:DescribeLogGroups"))) == ""+ assert _allowed(self._assume(Policy=_allow("*"))) == "S"++ def test_federated_user_is_limited_by_user_and_session_policies(self, boundary_principals, issued_sessions):+ user = boundary_principals["user"]+ fed = _sts_key(user, Action="GetFederationToken", Name="fed",+ Policy=_allow("sqs:ListQueues", "s3:ListAllMyBuckets"))+ assert _allowed(fed) == "S"+ assert _allowed(_sts_key(user, Action="GetFederationToken", Name="fed")) == ""+ _iam_call("PutUserPermissionsBoundary", UserName="probe-user",+ PermissionsBoundary=boundary_principals["boundary"])+ assert _allowed(_sts_key(user, Action="GetFederationToken", Name="fed", Policy=_allow("*"))) == "S"++ def test_federated_user_principal_tags_are_the_session_tags(self, boundary_principals, issued_sessions):+ from ministack.services import iam as iam_svc+ iam_svc._users["probe-user"]["Tags"] = [{"Key": "team", "Value": "blue"}, {"Key": "env", "Value": "dev"}]+ fed = _sts_key(boundary_principals["user"], Action="GetFederationToken", Name="fed", Policy=_allow("*"),+ **{"Tags.member.1.Key": "TEAM", "Tags.member.1.Value": "green"})+ keys = resolve_principal(fed, "000000000000").keys+ assert keys["aws:principaltag/team"] == "green" and "aws:principaltag/env" not in keys+ assert keys["aws:userid"] == "000000000000:fed" and "aws:username" not in keys++ def test_root_federation_is_limited_by_the_session_policy(self, issued_sessions):+ fed = _sts_key("test", Action="GetFederationToken", Name="fed", Policy=_allow("sqs:ListQueues"))+ assert _allowed(fed) == "S"+ assert resolve_principal(fed, "000000000000").arn == "arn:aws:sts::000000000000:federated-user/fed"++class TestCustomerManagedPolicyResolution:"""Customer policies belong to the explicit account and use full ARNs."""diff --git a/tests/test_sts.py b/tests/test_sts.pyindex d5208349..1b3b5cb9 100644--- a/tests/test_sts.py+++ b/tests/test_sts.py@@ -429,6 +429,148 @@ def test_sts_get_session_token_rejects_temporary_caller_when_auth_enabled(monkeysts_mod._sessions.pop(source_key, None)+def test_sts_get_federation_token_names_the_federated_user(sts):+ policy = json.dumps({"Version": "2012-10-17", "Statement": [+ {"Effect": "Allow", "Action": "sqs:ListQueues", "Resource": "*"}]})+ resp = sts.get_federation_token(Name="fed", Policy=policy)+ assert resp["FederatedUser"] == {+ "FederatedUserId": "000000000000:fed",+ "Arn": "arn:aws:sts::000000000000:federated-user/fed",+ }+ creds = resp["Credentials"]+ import boto3+ fed = boto3.client("sts", endpoint_url=sts.meta.endpoint_url, region_name="us-east-1",+ aws_access_key_id=creds["AccessKeyId"],+ aws_secret_access_key=creds["SecretAccessKey"],+ aws_session_token=creds["SessionToken"])+ assert fed.get_caller_identity()["Arn"] == "arn:aws:sts::000000000000:federated-user/fed"+++_SESSION_POLICY_ERRORS = [+ ({"Policy": '{"Statement":'}, "MalformedPolicyDocument"),+ ({"Policy": json.dumps({"Statement": [{"Effect": "Maybe", "Action": "*", "Resource": "*"}]})},+ "MalformedPolicyDocument"),+ ({"Policy": json.dumps({"Statement": [{"Effect": "Allow", "Action": f"sqs:A{i}", "Resource": "<&>"}+ for i in range(60)]})}, "ValidationError"),+ ({"PolicyArns": [{"arn": "arn:aws:iam::000000000000:policy/no-such-session-policy"}]}, "ValidationError"),+ ({"PolicyArns": [{"arn": "arn:aws:iam::aws:policy/NoSuchManagedSessionPolicy"}]}, "ValidationError"),+]++[email protected]("params, code", _SESSION_POLICY_ERRORS)+def test_sts_get_federation_token_validates_session_policies(sts, params, code):+ with pytest.raises(ClientError) as exc:+ sts.get_federation_token(Name="fed", **params)+ assert exc.value.response["Error"]["Code"] == code++[email protected]("auth", [True, False])[email protected]("params, code", _SESSION_POLICY_ERRORS)+def test_sts_assume_role_validates_session_policies_under_auth(monkeypatch, auth, params, code):+ import asyncio+ from urllib.parse import urlencode++ import ministack.app as app_mod+ from ministack.services import iam as iam_svc+ from ministack.services import sts as sts_mod++ monkeypatch.setattr(app_mod, "AUTH", auth)+ role = f"session-policy-{os.urandom(4).hex()}"+ trust = {"Statement": [{"Effect": "Allow", "Principal": {"AWS": "000000000000"}, "Action": "sts:AssumeRole"}]}+ iam_svc._roles[role] = {"RoleName": role, "Arn": f"arn:aws:iam::000000000000:role/{role}", "Tags": [],+ "AssumeRolePolicyDocument": json.dumps(trust)}+ query = {"Action": "AssumeRole", "Version": "2011-06-15", "RoleSessionName": "s1",+ "RoleArn": f"arn:aws:iam::000000000000:role/{role}"}+ if "Policy" in params:+ query["Policy"] = params["Policy"]+ for n, entry in enumerate(params.get("PolicyArns", []), 1):+ query[f"PolicyArns.member.{n}.arn"] = entry["arn"]+ headers = {"content-type": "application/x-www-form-urlencoded",+ "authorization": "AWS4-HMAC-SHA256 Credential=test/20260930/us-east-1/sts/aws4_request"}+ try:+ status, _headers, payload = asyncio.run(sts_mod.handle_request(+ "POST", "/", headers, urlencode(query).encode(), {}))+ finally:+ iam_svc._roles.pop(role, None)+ if auth:+ assert (status, f"<Code>{code}</Code>".encode() in payload) == (400, True)+ else:+ assert status == 200++[email protected]("name, value, constraint", [+ (None, "null", "Member must not be null"),+ ("f", "'f'", "Member must have length greater than or equal to 2"),+ ("x" * 33, f"'{'x' * 33}'", "Member must have length less than or equal to 32"),+ ("fed <&>", "'fed <&>'", "Member must satisfy regular expression pattern: [\\w+=,.@-]*"),+])+def test_sts_get_federation_token_validates_the_name(sts, name, value, constraint):+ import boto3+ from botocore.config import Config++ unchecked = boto3.client("sts", endpoint_url=sts.meta.endpoint_url, region_name="us-east-1",+ aws_access_key_id="test", aws_secret_access_key="test",+ config=Config(parameter_validation=False))+ with pytest.raises(ClientError) as exc:+ unchecked.get_federation_token(**({} if name is None else {"Name": name}))+ assert exc.value.response["Error"]["Message"] == (+ f"1 validation error detected: Value {value} at 'name' failed to satisfy constraint: {constraint}")+++def test_sts_session_policy_arns_are_looked_up_in_the_role_account(sts):+ import uuid++ import boto3++ role_account = "222233334444"+ iam = boto3.client("iam", endpoint_url=sts.meta.endpoint_url, region_name="us-east-1",+ aws_access_key_id=role_account, aws_secret_access_key="test")+ name = f"session-{uuid.uuid4().hex[:8]}"+ arn = iam.create_policy(PolicyName=name, PolicyDocument=json.dumps(+ {"Version": "2012-10-17", "Statement": [{"Effect": "Allow", "Action": "sqs:*", "Resource": "*"}]}),+ )["Policy"]["Arn"]+ iam.create_role(RoleName=name, AssumeRolePolicyDocument=json.dumps({"Statement": [+ {"Effect": "Allow", "Principal": {"AWS": "000000000000"}, "Action": "sts:AssumeRole"}]}))+ try:+ resp = sts.assume_role(RoleArn=f"arn:aws:iam::{role_account}:role/{name}", RoleSessionName="s1",+ PolicyArns=[{"arn": arn}])+ assert resp["AssumedRoleUser"]["Arn"] == f"arn:aws:sts::{role_account}:assumed-role/{name}/s1"+ finally:+ iam.delete_role(RoleName=name)+ iam.delete_policy(PolicyArn=arn)+++def test_sts_get_federation_token_refuses_session_credentials(monkeypatch):+ import asyncio+ import time++ import ministack.app as app_mod+ from ministack.core.responses import get_account_id+ from ministack.services import sts as sts_mod++ account_id = get_account_id()+ source_key = "test-federation-source-key"+ monkeypatch.setattr(app_mod, "AUTH", True)+ sts_mod._sessions[source_key] = {+ "Arn": f"arn:aws:sts::{account_id}:assumed-role/role/session",+ "UserId": "AROA123:session", "SecretAccessKey": "secret",+ "SessionToken": "token", "Expiration": time.time() + 900,+ "AccountId": account_id, "PrincipalType": "AssumedRole",+ }+ headers = {+ "authorization": f"AWS4-HMAC-SHA256 Credential={source_key}/20260930/us-east-1/sts/aws4_request",+ "content-type": "application/x-www-form-urlencoded",+ "x-amz-security-token": "token",+ }+ try:+ status, _headers, payload = asyncio.run(sts_mod.handle_request(+ "POST", "/", headers, b"Action=GetFederationToken&Version=2011-06-15&Name=fed", {}))+ finally:+ sts_mod._sessions.pop(source_key, None)+ assert status == 403+ assert b"Cannot call GetFederationToken with session credentials" in payload++@pytest.mark.parametrize("auth_enabled", [False, True])@pytest.mark.parametrize("action", ["GetSessionToken", "AssumeRole"])@pytest.mark.parametrize("credential_kind", ["unknown", "inactive", "expired"])