AI Security Maturity Model·AWS v1.0.0

Drag to explore · pinch to zoom

Foundational Identity and Access ManagementDefense-in-depth layer: Identity & Data Capability 1 · Model inferenceUse case: AI that answers 👤 CustomerAWS Shared Responsibility Model: who implements and operates this control. Customer = you own it; AWS = AWS operates it and you inherit it; Shared = both have obligations.

c1.1 Scope model access with least-privilege IAM

Grant callers only the specific Amazon Bedrock actions and model ARNs they need, so a compromised identity cannot invoke arbitrary models or reach data it should not.

Foundational
Enhanced
Advanced
Effort: Low Impact: High GenAI scopesFrom the AWS Generative AI Security Scoping Matrix.: 3 · Pre-trained models

Implementation guidance

How to implement on AWS

Write IAM policies that allow only the required Bedrock actions (e.g. bedrock:InvokeModel) on specific model ARNs, scoped by condition keys where possible. Separate who may invoke models from who may administer them, and prefer temporary credentials over long-lived keys.

Why least privilege matters for model access

Amazon Bedrock exposes powerful foundation models behind a small set of IAM actions. If an application role is granted bedrock: on Resource: , a single leaked credential can invoke any model in the account, reconfigure guardrails, or start costly customization jobs. Scoping access to the exact actions and model ARNs a workload needs turns a broad compromise into a contained one.

Separate invoking a model from administering it

Treat these as two different jobs with two different roles:

  • Invoke — the runtime application only needs bedrock:InvokeModel (and bedrock:InvokeModelWithResponseStream for streaming) on the specific model ARNs it is approved to call.
  • Administer — creating or updating guardrails, custom models, and model access belongs to a platform/operator role that the runtime application never assumes.

Keeping these apart means a compromised application identity can call its approved models but cannot change how the models are governed.

Scope to explicit model ARNs

Foundation models are addressable by ARN in the form arn:aws:bedrock:<region>::foundation-model/<model-id>. List the exact model ARNs in the policy Resource block instead of *, so the role cannot reach models it was never approved for. The example below grants invoke-only access to two specific models and nothing else:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "InvokeApprovedModelsOnly",
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-5-sonnet-20240620-v1:0",
        "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan-embed-text-v2:0"
      ]
    }
  ]
}

Bind invocation to the approved network path

Layer condition keys onto the invoke policy so the credential is only usable from where the workload actually runs — for example, require calls to arrive through your Bedrock VPC endpoint with aws:SourceVpce. This means an exfiltrated credential is useless from the public internet:

{
  "Effect": "Allow",
  "Action": "bedrock:InvokeModel",
  "Resource": "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-5-sonnet-20240620-v1:0",
  "Condition": {
    "StringEquals": { "aws:SourceVpce": "vpce-0abc123456789def0" }
  }
}

Prefer temporary credentials

Have the application assume a role (task role, instance profile, or cross-account role) rather than embedding long-lived access keys. Temporary credentials rotate automatically and are far easier to revoke if a workload is compromised.

Naming note: replace the example model IDs and VPC endpoint ID with the values for your region and account. Model IDs differ by Region and change as new model versions are released.

Acceptance criteria

IAM policies list explicit model ARNs and actions; no wildcard bedrock:* on * resources; access reviews show callers limited to their approved models.

Practical implementation

How this control is implemented in each reference architecture:

The application account assumes a scoped role into the Generative AI account; that role can invoke only the approved model ARNs, nothing else.

  1. In the Generative AI account, create an invoke-only IAM role that allows bedrock:InvokeModel and bedrock:InvokeModelWithResponseStream on the specific foundation-model ARNs the workload is approved to use, and nothing on bedrock:*.
    Generative AI account IAM Amazon Bedrock
  2. Let the Application account role assume that invoke-only role via a trust policy scoped to the app's execution role, so the app never holds model-admin permissions.
    Application account → Generative AI account IAM
  3. Add condition keys (e.g. aws:SourceVpce, aws:PrincipalTag) to bind invocation to the approved VPC endpoint and workload, and keep model administration in a separate role held only by the platform team.
    Generative AI account IAM

How to validate: IAM Access Analyzer shows no role with bedrock:* on *; the app role can invoke only the listed model ARNs; an attempt to call an unlisted model or a management action is denied.

Avoid: Granting bedrock:* on Resource:* to the application role because it is convenient. A single leaked credential then reaches every model and admin action; scope to explicit ARNs and split invoke from admin.

Generative AI OU (multi-account) →

Two distinct IAM roles in the one account — an application role and a model-invocation role — keep invoke and admin duties apart without account boundaries.

  1. Create a dedicated model-invocation role allowing only bedrock:InvokeModel on the approved model ARNs, and have the application role assume it (or attach it as the task/execution role) instead of embedding broad Bedrock permissions in the app.
    Generative AI tier (IAM role) IAM Amazon Bedrock
  2. Keep model administration (create/update guardrails, custom models) in a separate role held only by operators, never granted to the runtime application role.
    Application tier (IAM role) IAM
  3. Use temporary credentials (role assumption / instance or task roles) rather than long-lived access keys for every Bedrock call.
    Application tier (IAM role) IAM

How to validate: The runtime role's effective policy lists explicit model ARNs and no bedrock:* wildcard; no long-lived keys exist for the app identity; admin actions are denied to the runtime role.

Avoid: Using one shared role for the app and model administration. Separate the invoke role from the admin role even inside a single account so a compromised app identity cannot reconfigure models.

Single account (entry point) →

Threats addressed

  • Over-permissive identities invoking models or actions beyond their purpose.
  • Data exfiltration through prompt techniques when access is not scoped.

AWS services

AWS IAM Amazon Bedrock

Pricing

IAM policies and roles are free. You pay only for the Bedrock model invocations themselves, billed per input/output token (on-demand) or per provisioned throughput; scoping access does not add cost.

Framework mappings

OWASP GenAI/LLM Top 10 (2026)

  • LLM02 Sensitive Information Disclosure
  • LLM03 Excessive Agency

NIST AI Risk Management Framework (AI 100-1)

  • GOVERN.1 Policies, processes, procedures and accountability structures
  • MANAGE.1 AI risks are prioritized, responded to and managed

AWS Well-Architected Generative AI Lens (Security)

  • GENSEC01-BP01 Grant least privilege access to foundation model endpoints

Learning resources

References

  • AWS SRA for AI — Capability 1, Defense in depth